This is a continual work-in-progress personal development workspace. It is also my portfolio for .NET libraries and related tooling.

This repository is a .NET-focused toolkit of libraries and apps for business data: APIs with a rich query model, durable file handling, document parsing, and cross-cutting infrastructure (security, compression, observability, and more). Most code lives under Lyo.Net/.

Note. Generative AI tools were used to help build and maintain parts of this codebase where scale made that practical. Notably the numerical packages Mathematics and Scientific (including their function libraries), documentation (including long-form package READMEs), test projects and libraries, and some JavaScript (load-testing scripts, Blazor companion scripts, other web-related assets). Human review still applies. Treat those areas with the same scrutiny you would for any large or subtle code.

These are the areas that tend to anchor product work. Each links to deeper docs where they exist in-tree.

Individual projects are mostly one folder per NuGet-style package (for example Lyo.Something). The sections below list every in-repo README.md beside a library, grouped by top-level area.

• Lyo.Email: MailKit SMTP sender. EmailService is the IEmailService implementation.
• Lyo.Email.Models: Shared models, options, failure codes, and event payloads for the Lyo.Email SMTP sender.
• Lyo.Email.Postgres: PostgreSQL EF Core store for email mailbox logs (EmailLogEntity). The package never sends or fetches mail. Hosts insert outbound rows after SMTP send and inbound rows after their own IMAP/POP client.
• Lyo.Email.Web.Components: MudBlazor workbench that sends mail through an injected IEmailService.
• Lyo.MessageQueue: IMqService defines the queue and exchange contract. Schedulers, workers, and gateways compile against one interface and swap Lyo.MessageQueue.* brokers behind it.
• Lyo.MessageQueue.RabbitMq: IMqService implementation (RabbitMqService) on RabbitMQ.Client. Also wired as IRabbitMqService for exchanges and other RabbitMQ-only methods.
• Lyo.MessageQueue.RabbitMq.Web.Components: Blazor UI for RabbitMQ exchanges, bindings, and broker workbenches.
• Lyo.MessageQueue.Web.Components: Blazor UI for provider-neutral queue dashboards and workbenches.
• Lyo.Sms: Shared SMS contracts and send pipeline. Providers (Lyo.Sms.Twilio, and others) implement SmsServiceBase.
• Lyo.Sms.Models: Shared types used by Lyo.Sms: payloads, paging, events, normalization, and base options. The package never sends SMS. Implementations live in provider packages (Lyo.Sms.Twilio, and others).
• Lyo.Sms.Postgres: PostgreSQL EF Core store for outbound SMS logs (SmsLogEntity). The package never sends SMS. It wires SmsDbContext so workers or gateways can store send outcomes.
• Lyo.Sms.Twilio: Twilio SMS and MMS via Lyo.Sms. TwilioSmsService implements ISmsService.
• Lyo.Sms.Twilio.Postgres: PostgreSQL EF Core store for Twilio SMS traces: TwilioSmsDbContext and TwilioSmsLogEntity.
• Lyo.Sms.Web.Components: MudBlazor workbench for an injected ISmsService. Uses MudBlazor and snackbar helpers in Lyo.Web.Components.
• Lyo.Stt: Lyo speech-to-text contract. Ships ISttService, SttServiceBase, request/result/options/event records, and metric name constants. This repo ships no provider packages.
• Lyo.Translation: Archetype B (capability). Providers (Lyo.Translation.Google, Lyo.Translation.Aws) remain under Communication/Translation/, not under Integration/. See package layout.
• Lyo.Translation.Aws: Amazon Translate that implements ITranslationService. Translates text, runs bounded bulk translation, infers language via a Translate call, and probes connectivity with ListLanguages.
• Lyo.Translation.Google: Google Cloud Translation v2 that implements ITranslationService. GoogleTranslationService extends TranslationServiceBase and calls the REST API over HTTP.
• Lyo.Translation.Web.Components: MudBlazor workbench for whichever Lyo.Translation implementation the host wired.
• Lyo.Tts: TTS contracts and shared behavior: provider-agnostic interfaces, a non-generic facade, and a base service with bulk synthesis, metrics, and lifecycle events.
• Lyo.Tts.AwsPolly: TTS via Amazon Polly. AwsPollyTtsService extends TtsServiceBase<AwsPollyTtsRequest> with voice selection, output formats, bulk synthesis, metrics, and DI helpers.
• Lyo.Tts.AwsPolly.Web.Components: MudBlazor workbench for exercising Lyo.Tts.AwsPolly inside a host app.
• Lyo.Tts.Models: Shared TTS requests, results, options, and event payloads. Provider packages depend on this package instead of on each other.
• Lyo.Tts.Typecast: Typecast TTS through Lyo.Typecast.Client. TypecastTtsService synthesizes audio through TypecastClient, can load the voice catalog for validation (LoadVoicesAsync), and uses the bulk pipeline plus Typecast-namespaced metrics from Lyo.Tts.
• Lyo.Tts.Typecast.Web.Components: MudBlazor workbench for exercising Lyo.Tts.Typecast inside a host app.
• Lyo.Tts.WindowsSpeech: Text-to-speech through Windows SAPI. WindowsSpeechTtsService uses the built-in Speech API.
• Lyo.Webhook: ASP.NET Core inbound webhook verification: headers and raw body, HMAC helpers, MapWebhook().Verify().Handle(), and Lyo.Metrics timings.
• Lyo.Webhook.Twilio: Twilio webhook signature checks for Lyo.Webhook. Compares X-Twilio-Signature to an HMAC-SHA1 (Base64) of the public request URL plus sorted key+value form parameters.

• Lyo.Audit: Audit trail with two records: AuditChange (entity change tracking) and AuditEvent (events to log).
• Lyo.Audit.Postgres: EF Core persistence for Lyo.Audit in PostgreSQL. Stores AuditChange and AuditEvent rows with JSONB columns for dictionary data.
• Lyo.Benchmark: Helpers used only by *.Benchmarks executables. The BenchmarkDotNet counterpart to Lyo.Testing.
• Lyo.Benchmark.Models: Builders and models for the Lyo benchmark report schema (lyo.bench/v1).
• Lyo.Cache: In-process ICacheService plus typed byte-payload methods. Serialize once, store framed bytes, and optionally compress or encrypt on .NET 10+.
• Lyo.Cache.Fusion: ZiggyCreatures.FusionCache is adapted to ICacheService by FusionCacheService so Lyo.Api, workers, and feature modules can swap in-memory Lyo.Cache for Fusion plus an optional Redis backplane without rewriting call sites.
• Lyo.ChangeTracker: Generic entity change history around Lyo.EntityReference.Models.EntityRef. Record property-level changes for any entity type without tying the tracker to one aggregate.
• Lyo.ChangeTracker.Postgres: PostgreSQL adapter for Lyo.ChangeTracker. Stores entity-scoped change history using Lyo.EntityReference.Models.EntityRef for both the target entity and the optional actor.
• Lyo.Common.Core: Bottom of the Lyo stack: enums, identifier generators, scalar and string extensions, type conversion, path helpers, secure randomness, and HTTP constants, with no Lyo dependency beyond Lyo.Exceptions.
• Lyo.Common.Json: LyoJsonSerializerOptions — the HTTP JSON contract every Lyo API and first-party client shares — plus opt-in converters for upstreams that quote their scalars.
• Lyo.Common.Metadata: Lyo registry records — file type, MIME, language, port, HTTP status, HTTP header, geography, and CLR type catalogs — plus the extensions that bridge enums to those records.
• Lyo.DateAndTime: Dates, times, US timezone conversion, day-of-week scheduling, and US holiday metadata. Static and thread-safe. No mutable shared state.
• Lyo.Diagnostic: Decode stack traces, classify exceptions, keep breadcrumb trails, hold an in-memory error inbox, sanitise output, and write structured logs.
• Lyo.Diagnostic.AspNetCore: ASP.NET Core integration for Lyo.Diagnostic. Per-request scoped breadcrumb trails and exception recording to the in-memory error inbox plus structured logging, without replacing existing problem-details middleware.
• Lyo.Diagnostic.Web.Components: Blazor (Server / Interactive) workbench that uses Lyo.Diagnostic to analyze and triage .NET stack traces and exception payloads.
• Lyo.Diff: Compare human-readable text and object graphs side by side.
• Lyo.EntityReference.Models: Typed pair of logical entity kind (EntityType) and identifier string (EntityId), with helpers for composite keys, JSON, opaque tokens, validation, and domain row shapes.
• Lyo.EntityReference.Postgres: EF Core building blocks on PostgreSQL for relation rows (subject/actor associations) and source-link rows (import provenance).
• Lyo.Exceptions: Exception types and argument-validation helpers shared by Lyo packages.
• Lyo.Geolocation: Geospatial operations and persistence contracts that do not pick a vendor.
• Lyo.Geolocation.Models: Vendor-neutral data contracts used by Lyo.Geolocation and Lyo.Geolocation.Postgres.
• Lyo.Geolocation.Postgres: Entity Framework Core persistence of canonical geolocation data in PostgreSQL.
• Lyo.Health: Contract for services that report their own health. Implement IHealth. There is no central health service.
• Lyo.Lock: Exclusive locks by key and keyed semaphores (bounded concurrency per key), plus in-memory implementations for a single process.
• Lyo.Lock.Redis: Redis-backed ILockService through StackExchange.Redis. Reach for this when several app instances must exclude each other on one logical key.
• Lyo.Mathematics: C# contracts for the Lyo math stack: physical quantities as structs, 2D/3D vectors and small matrices, typed inputs/results for formulas, and a small registry so they can be discovered.
• Lyo.Metrics: Thread-safe counters, gauges, histograms, timings, errors, and events — in-memory, OpenTelemetry, and null implementations.
• Lyo.Metrics.DependencyInjection: Service-collection registration for Lyo.Metrics, split out so the metrics library itself has no NuGet dependencies.
• Lyo.Metrics.OpenTelemetry: IMetrics implementation that exports through OpenTelemetry to OpenTelemetry-compatible backends.
• Lyo.Metrics.Statistics: Histogram statistics on top of Lyo.Metrics: percentile, quartile, moving-average, and anomaly-detection helpers.
• Lyo.Notification: Small domain events via in-process publish/subscribe. Not distributed, not durable, and not ordered across machines. Only useful when every publisher and handler lives in the same process.
• Lyo.PackageMetadata: PackageMetadata rows across ecosystems, PackageMetadataRegistration, IPackageMetadataStore, and PackageArtifactDigest helpers that correlate stack-trace namespaces with persisted catalog data.
• Lyo.PackageMetadata.Postgres: EF Core store behind Lyo.PackageMetadata.IPackageMetadataStore.
• Lyo.Parameters: Keyed parameter contracts and the parameter-definition model shared by jobs, reports, and query templates.
• Lyo.People.Models: People-domain records: Person, contact, employment, identification, and relationships.
• Lyo.People.Postgres: EF Core persistence of Lyo.People.Models in PostgreSQL.
• Lyo.Privacy: Masks emails, phones, Luhn card numbers, IBAN, secrets, IDs, URLs, IPs, and street lines in free text, JSON, and XML.
• Lyo.Privacy.AspNetCore: DI wiring for Lyo.Privacy on ASP.NET Core: registers ITextRedactor / IStructuredRedactor, binds PrivacyRedactorOptions from configuration, and allows keyed per-tenant or per-feature…
• Lyo.Privacy.Web.Components: Blazor (Server / Interactive) workbench components for Lyo.Privacy. Operators can preview, compare, and tune redaction policies without a host config round-trip.
• Lyo.Resilience: Thin Polly wrapper for resilience pipelines, with appsettings binding and built-in logging.
• Lyo.Result: Result / Result<T> with Error graphs, builders, bulk/paged envelopes, and Task composition. Distinct from Lyo.Common.Core Result.
• Lyo.Schedule.Models: Schedule-only DTOs. Lyo.Scheduler, Lyo.Job.Postgres, and other callers use this when they need a transport-friendly answer to "when does this run".
• Lyo.Schedule.Web.Components: Blazor component(s) for interactively building and previewing Lyo.Schedule.Models.ScheduleDefinition values.
• Lyo.Scheduler: In-process scheduler that runs actions at scheduled times. Supports SetTimes, Interval, OneShot, and Cron schedules (5- or 6-field expressions) with logging, metrics, and…
• Lyo.Scheduler.Cache: Cache-backed ISchedulerStateStore for Lyo.Scheduler. Writes each schedule's LastRunUtc / NextRunUtc / state markers through Lyo.Cache so cron/interval/one-shot schedules survive process…
• Lyo.Scientific: Scientific domain models, reference datasets, SI-oriented unit helpers, and formula discovery on top of Lyo.Mathematics.
• Lyo.Streams: TeeStream, CountingStream, ProgressStream, ConcatenatedStream, and related wrappers. Incremental hashing lives in Lyo.Hashing (HashingStream).
• Lyo.SystemInformation: Inventory of the host machine — hardware, software, drives, network interfaces, and monitors (including EDID parsing) — plus structured logging of that snapshot.
• Lyo.Testing: Helpers for xUnit v3: fluent Should* asserts, exception and collection helpers, polling checks, and a logger backed by ITestOutputHelper.
• Lyo.Testing.Containers: Testcontainers fixtures for xUnit v3 covering Redis, RabbitMQ, and PostgreSQL, plus a DI-wired Postgres service fixture.
• Lyo.TextEncoding: Binary codecs (Base64 / Base64Url / Hex) plus charset encode/decode/convert with CodePages, detection, PEM/MIME, and injectable services.
• Lyo.Validation: C# validators, fluent rule builders, validation attributes, and WhereClause schemas that surface failures as Lyo.Result.Result<T>.
• Lyo.Validation.Models: Contracts for validation plus the data-driven rule model: schemas, rules, messages, and projecting a where-clause into Error.
• Lyo.Validation.Postgres: PostgreSQL store for ValidationSchema documents (WhereClause JSONB) behind IValidationSchemaStore.
• Lyo.Web.Primitives: Shared MudBlazor UI primitives for every Lyo component package, with no query, data-grid, or API dependencies.

• Lyo.Barcode: Contracts for generating and decoding barcodes: IBarcodeService, request and options models, plus BarcodeBuilder.
• Lyo.Barcode.Native: Lyo.Barcode IBarcodeService with no third-party barcode generator.
• Lyo.Barcode.TestWorkbench.Web.Components: MudBlazor page that puts from Lyo.Barcode.Web.Components in a MudContainer for the Lyo gateway test harness.
• Lyo.Barcode.Web.Components: MudBlazor UI that talks to Lyo.Barcode's IBarcodeService.
• Lyo.Compression: Compress and decompress bytes, strings, streams, and files with ICompressionService. One default codec, plus ICompressionResolver for per-algorithm dispatch.
• Lyo.Compression.BZip2: Addon that plugs BZip2 into Lyo.Compression by registering a BZip2 ICompressorFactory.
• Lyo.Compression.Lz4: Lyo.Compression addon that registers an LZ4 ICompressorFactory using EasyCompressor.LZ4.
• Lyo.Compression.Lzma: LZMA plugin for Lyo.Compression that registers an LZMA ICompressorFactory.
• Lyo.Compression.Snappier: Snappy support for Lyo.Compression via a Snappier ICompressorFactory.
• Lyo.Compression.Xz: XZ / LZMA2 support for Lyo.Compression through an XZ ICompressorFactory.
• Lyo.Compression.Zstd: Zstandard addon for Lyo.Compression that registers a Zstd ICompressorFactory.
• Lyo.Csv: In-house CSV stack for Lyo.Csv.Models. CsvService composes a CsvWriter and CsvReader over an internal tokenizer/writer with typed binders. No third-party CSV library.
• Lyo.Csv.Models: CSV stack contracts and value types. Depend on ICsvService, ICsvReader, and ICsvWriter here; Lyo.Csv is the implementation package.
• Lyo.DataTable: Placeholder package that holds the Lyo.DataTable name only. Runtime types (DataTable, DataTableRow, DataTableBuilder, cell types, HTML renderer) ship in Lyo.DataTable.Models.
• Lyo.DataTable.Models: In-memory mutable table: sparse columns, thin cells, optional format map, fluent builders, HTML renderer.
• Lyo.FFmpeg: CliWrap wrapper around ffmpeg, ffprobe, and ffplay for convert, play, and stream of audio and video.
• Lyo.FFmpeg.Models: FFmpeg host options and command-line model for Lyo.FFmpeg.
• Lyo.FileMetadataStore: File identity without the bytes. Canonical Guid identifiers and metadata, not blob I/O.
• Lyo.FileMetadataStore.Postgres: Postgres IFileMetadataStore plus the adjunct stores richer file pipelines use.
• Lyo.FileMetadataStore.Sqlite: EF Core SQLite IFileMetadataStore. Same store and adjunct services as Lyo.FileMetadataStore.Postgres, for embedded, offline-first, and local-dev hosts.
• Lyo.FileStorage: Save, stream-save, read, delete, and file metadata. Optional compression (Lyo.Compression), two-key encryption (Lyo.Encryption), duplicate hashing, access policies, audit hooks, multipart (IMultipartUploadService), and presigned/direct-upload/copy on cloud backends.
• Lyo.FileStorage.AzureBlob: Azure.Storage.Blobs IFileStorageService for Azure Blob Storage.
• Lyo.FileStorage.Ftp: IFileStorageService on FTP through Lyo.Ftp.Client.
• Lyo.FileStorage.S3: Lyo.FileStorage on S3-compatible endpoints (AWS S3, Backblaze B2, MinIO, and others) through AWSSDK.S3.
• Lyo.FileStorage.Sftp: IFileStorageService on SFTP through Lyo.Sftp.Client.
• Lyo.FileStorage.Web.Components: Blazor Server / Interactive UI for Lyo.FileStorage. Trees, grids, and dialogs for file metadata, expected storage keys, download access links, and DEK migrate/rotate.
• Lyo.FileSystemWatcher: Snapshot-based .NET file watcher. Finds creates, deletes, changes, moves, and renames with debounce and SHA256 hashing.
• Lyo.FileSystemWatcher.Models: Persistable file-system snapshot, change, and watch-options DTOs, plus DTO-native change detection.
• Lyo.FileSystemWatcher.Postgres: PostgreSQL store for FileSystemWatcher snapshots and change events. Service layer only — no HTTP.
• Lyo.Formatter: SmartFormat.NET templates plus C#-like {...} expressions (DateTime, ternary, in-memory LINQ) for user-defined strings.
• Lyo.Formatter.Web.Components: Blazor pair for live SmartFormat editing: a debounced template box and an annotated preview that color-links {keys} to replacements. Runs on WASM.
• Lyo.Ftp.Client: FluentFTP client with a connection pool, PathHelpers jail, logging, and Lyo.Metrics. Prefer *Async.
• Lyo.IO.FileSystem: Path-rooted virtual file system: one contract for local disk, memory, SFTP, FTP, S3, and Azure Blob.
• Lyo.IO.Temp: Session-scoped temp files and directories, with naming strategies and overflow policies.
• Lyo.Images: SixLabors.ImageSharp raster processing for .NET.
• Lyo.Images.Ocr: Lyo OCR contracts: IOcrEngine, request/response models, Y-up pixel boxes (same as BoundingBox2D), coordinate helpers, and shared options.
• Lyo.Images.Ocr.Tesseract: Tesseract IOcrEngine for Lyo.Images.Ocr. An internal lock serializes calls because native Tesseract instances are not safely concurrent.
• Lyo.Images.OpenCv: OpenCvSharp4 helpers for .NET. Split from higher-level pipelines (e.g. comic overlay) so hosts take native OpenCV only where they need it.
• Lyo.Images.Skia: SkiaSharp IImageService for Lyo.Images: resize, crop, rotate, watermark, convert, thumbnails, compression, metadata, palette, batch.
• Lyo.Images.Web.Components: Blazor / MudBlazor workbenches for Lyo.Images: IImageService tools plus a spritesheet animator/extractor on ISpriteSheetExportService.
• Lyo.Media.Models: Sibling IAudio* and IVideo* contracts, encoder catalogs, and conversion/play/probe records. Images stay IImageService.
• Lyo.Pdf: Read with PdfPig and edit with PDFsharp for Lyo.Pdf.Models. Start at PdfService: disposable IPdfReader for extract work, IPdfWriter for structural edits.
• Lyo.Pdf.Models: PDF stack contracts and value types. Depend on IPdfService, IPdfReader, IPdfWriter, and ITextExtractor here; Lyo.Pdf is the PdfPig/PDFsharp implementation.
• Lyo.Pdf.Ocr: PNG-renders a PDF page with Lyo.Pdf.Rendering, runs IOcrEngine, then lifts OCR pixel boxes into PDF points.
• Lyo.Pdf.Rendering: Turns PDF pages into PNG through PDFtoImage (PDFium + Skia; bblanchon.PDFium native packages). Targets net10.0.
• Lyo.Pdf.Web.Components: Blazor / MudBlazor PDF workbenches: HTML to PDF, annotation, and LyoPdfAnnotator so drawn regions emit PdfBoundingBox.
• Lyo.Postgres: Shared PostgreSQL host bits for Lyo libraries that own an EF Core schema (Audit, Email, ChangeTracker, EntityReference, etc.): migrations, schema/option building, design-time factories, and health checks.
• Lyo.QRCode: Generate and read QR codes: IQRCodeService, QRCodeBuilder, in-box ISO Model 2 encoding (BuiltInQRCodeService), optional QRCoder adapter.
• Lyo.QRCode.QRCoder: IQRCodeService from Lyo.QRCode implemented with QRCoder. Pick this for JPEG / Bitmap on Windows, or for QRCoder's renderers.
• Lyo.QRCode.Web.Components: Blazor / MudBlazor UI that generates and previews QR codes.
• Lyo.Query: Turn a WhereClause AST into LINQ on IQueryable: filter, multi-key sort, in-memory match/explain, with ICache-backed compiled predicates.
• Lyo.Query.Evaluation: Evaluate where clauses without a cache: build expressions, match in memory, explain matches, and resolve property paths.
• Lyo.Query.Models: Filter / sort / projection DTOs and fluent builders (WhereClause, QueryConcrete / QueryProject / root Query) that Lyo.Query and Lyo.Api share.
• Lyo.Query.Web.Components: Blazor / MudBlazor UI that edits and runs Lyo.Query.Models requests against any Lyo.Api host.
• Lyo.Seed: Seeder that does not care how items are built: contributors yield them, then EF or Lyo.Api bulk-create writes them.
• Lyo.Sftp.Client: SSH.NET SFTP client with a connection pool, PathHelpers jail, logging, and Lyo.Metrics. Prefer *Async.
• Lyo.Sqlite: Common SQLite migration host bits for Lyo libraries that own an EF Core schema.
• Lyo.Xlsx: Lyo.Xlsx.Models implementation. XlsxService composes an XlsxWriter (streaming DocumentFormat.OpenXml) and an XlsxReader (ExcelDataReader / ClosedXML).
• Lyo.Xlsx.Models: XLSX stack contracts and value types. Depend on IXlsxService / IXlsxReader / IXlsxWriter here; Lyo.Xlsx is the ClosedXML implementation.

• Lyo.Comic: Domain contracts for a serialized fiction catalog: series (ComicSeries, ComicAlternateTitle), hierarchy (ComicVolume, ComicChapter, ComicPage), cast (ComicCharacter), ComicSeriesQuery, ComicType/ComicStatus, and IComicStore.
• Lyo.Comic.Postgres: PostgreSQL and EF Core implementation of Lyo.Comic.IComicStore (PostgresComicStore) via ComicDbContext and PostgresComicOptions.
• Lyo.Comic.Web.Components: Blazor components for browsing, previewing, and reading comic series. Search panel, result grids and lists, browse cards, and a MangaFire-style tap-to-navigate reader.
• Lyo.Comment: Contracts for threaded, reactable comments on any entity. Each comment has a subject, an actor, optional ReplyToCommentId, and cached like/dislike counters.
• Lyo.Comment.Postgres: Entity Framework Core store for Lyo.Comment on PostgreSQL. Comments live in comment.comment and reactions in comment.comment_reaction.
• Lyo.Config: Typed, definition-driven configuration for per-entity values (a Discord guild, a tenant). The abstract API lives here. PostgreSQL persistence is in Lyo.Config.Postgres.
• Lyo.Config.Postgres: PostgreSQL and EF Core implementation of Lyo.Config.IConfigStore for typed configuration definitions and per-entity bindings.
• Lyo.Config.Web.Components: Blazor / MudBlazor dashboard for Lyo.Config. Add ConfigManagement to a host page for definitions, resolved bindings, and two first-class histories against IConfigStore.
• Lyo.ContactUs: Contact-form submission contracts. IContactUsService and ContactUsServiceBase cover validation, error-code mapping, and logging. Storage sits in sibling packages.
• Lyo.ContactUs.Postgres: PostgreSQL and EF Core implementation of Lyo.ContactUs.IContactUsService (PostgresContactUsService) through ContactUsDbContext and PostgresContactUsOptions.
• Lyo.Favorite: Contracts for "X favorited Y" ties between any two entities. The boundary takes EntityRef.
• Lyo.Favorite.Postgres: Entity Framework Core store for Lyo.Favorite on PostgreSQL. Rows live in favorite.favorite (PostgresFavoriteOptions.Schema = "favorite").
• Lyo.HomeInventory: Contract for household inventory: large purchases (electronics, appliances) with warranty tracking, kitchen consumables across pantries / freezers, and garage bin locations.
• Lyo.HomeInventory.Postgres: EF Core implementation of IHomeInventoryStore backed by PostgreSQL.
• Lyo.Job.Models: Shared DTOs, builders, enums, metrics constants, distributed-tracing helpers, and message-queue contracts for Lyo job management.
• Lyo.Job.Postgres: PostgreSQL persistence for Lyo job management.
• Lyo.Job.Web.Components: Blazor / MudBlazor dashboard for the Lyo job stack. Drop JobManagement on a host page for Statistics, Definitions, Schedules, Runs (progress and SLA breach), worker registry, and workflow views.
• Lyo.Note: Contracts for notes hung on entities. A note has a subject (what it is about) and an actor (who wrote it), both as EntityRef.
• Lyo.Note.Postgres: Entity Framework Core store for Lyo.Note on PostgreSQL. Rows live in note.note (PostgresNoteOptions.Schema = "note"), and the package includes migrations.
• Lyo.Profanity: File-based profanity filter. Finds and replaces profane words. Several languages, regex patterns, plain word lists, and configurable replacement strategies.
• Lyo.Rating: Contracts for rating and reviewing entities, plus like/dislike reactions on those ratings.
• Lyo.Rating.Postgres: Entity Framework Core store for Lyo.Rating on PostgreSQL. Ratings live in rating.rating and reactions in rating.rating_reaction.
• Lyo.Reporting.Models: Lyo Reporting composition models, fluent builders, API contracts, and generation hooks.
• Lyo.Reporting.Postgres: PostgreSQL schema (reporting), EF migrations, CSV/XLSX/JSON renderers, the ReportService generation pipeline, and ReportRetentionService cleanup.
• Lyo.Reporting.Web: Blazor ReportViewer plus IReportRenderer producing HTML and PDF.
• Lyo.Reporting.Web.Components: MudBlazor ops UI for Lyo Reporting: browse definitions, run reports, design compositions, and view or download generations.
• Lyo.ShortUrl: URL-shortening contracts: IShortUrlService, ShortUrlServiceBase for validation / metrics / error-code mapping, a default ShortUrlService that mints short codes (no storage), UrlShortenBuilder, and DTOs for shorten / expand / statistics.
• Lyo.ShortUrl.Postgres: EF Core schema and DbContext registration for a PostgreSQL-backed short-URL store.
• Lyo.Tag: Contracts for hanging tags on entities. The target is an EntityRef, and the person or system that applied the tag is an optional second EntityRef.
• Lyo.Tag.Postgres: Entity Framework Core store for Lyo.Tag on PostgreSQL. Rows live in tag.tag (PostgresTagOptions.Schema = "tag"), and the package includes migrations.

• Lyo.Discord.Bot: Library (not an executable) that runs a DSharpPlus Discord bot and upserts guild data into your Lyo API (Lyo.Discord.Client against PostgreSQL-backed Discord/* endpoints).
• Lyo.Discord.Client: Typed HTTP client for the Discord REST endpoints Lyo.Api exposes (the Discord/* group registered by Lyo.Discord.Postgres).
• Lyo.Discord.Models: Wire-level DTOs and shared constants for the Discord integration. Lyo.Discord.Client (typed HTTP client) and Lyo.Discord.Postgres (API host + persistence) both use these so request and response shapes stay aligned.
• Lyo.Discord.Postgres: PostgreSQL persistence plus Lyo.Api endpoint mappings for Discord entities. Schema name is locked to discord (PostgresDiscordOptions.Schema).
• Lyo.Endato.Client: Typed HTTP client for Endato's data-enrichment REST API.
• Lyo.Endato.Postgres: EF Core context and PostgreSQL schema that cache Endato Person Search (PS) and Contact Enrichment (CE) responses. Schema name is endato.
• Lyo.Endato.Web.Components: Blazor workbench UI for Endato person search and enrichment.
• Lyo.Espn.Fantasy.Football.Client: Read-only typed client for ESPN's fantasy football v3 API (lm-api-reads.fantasy.espn.com/apis/v3/games/ffl/).
• Lyo.Google.Geolocation.Client: REST client for Google Maps plus an IGeolocationService implementation.
• Lyo.Typecast.Client: HTTP client for Typecast TTS and voice catalog work. TypecastClient subclasses Lyo.Api.Client.ApiClient, sets X-API-KEY from TypecastClientOptions, and surfaces two…

• Lyo.Api: Minimal-API library that maps EF Core entities onto REST CRUD. ApiEndpointBuilder emits Query, Get, Create, Update, Patch, Delete, Upsert, bulk variants, and optional export.
• Lyo.Api.Authentication: Administrative HTTP endpoints for Lyo Authentication. Postgres stores stay in Lyo.Authentication.Postgres. BuildAuthenticationApi lives here.
• Lyo.Api.Client: Lyo API HTTP client: problem-details (ApiException), ApiRouteBuilder, Query/QueryProject, correlation. Generic JSON verbs live on Lyo.Http.Client.
• Lyo.Api.Export: Optional export add-on for Lyo.Api. Registers the Export CRUD endpoint and IExportService<TContext>.
• Lyo.Api.Export.Csv: CSV format handler for Lyo.Api export.
• Lyo.Api.Export.Xlsx: XLSX format handler for Lyo.Api export.
• Lyo.Api.FileStorage: HTTP endpoints for Lyo file storage. Hosts map BuildFileStorageApi after a keyed IFileStorageService stack is registered.
• Lyo.Api.FileStorage.Models: Request and response DTOs for the file-storage HTTP API. This package does not depend on Lyo.FileStorage.
• Lyo.Api.Models: HTTP contract models shared by Lyo minimal APIs and their clients. Distinct from Lyo.Query.Models (projection DTOs + filter trees).
• Lyo.Api.Tests.Host: Reference ASP.NET Core minimal-API host that Lyo.Api.Tests and other integration tests target via WebApplicationFactory<Program>.
• Lyo.Comic.Api: HTTP mapping for the Lyo Comic API (BuildComicGroup).
• Lyo.Comic.Api.Host: Standalone ASP.NET host for the Lyo Comic API.
• Lyo.Config.Api: HTTP host for central app configuration, backed by PostgreSQL and Lyo.Config.
• Lyo.Config.Api.Client: HTTP client typed for Lyo.Config.Api. Conditional app-config reads with ?version / If-None-Match polling, optional X-Api-Key, HTTP IConfigStore (ConfigApiStore) over manage routes, and DI extensions.
• Lyo.Config.Api.Host: ASP.NET host that runs Lyo.Config.Api on its own.
• Lyo.Config.Api.Hosting: Connects IConfigApiClient (Lyo.Config.Api.Client) to Microsoft.Extensions.Options and Microsoft.Extensions.DependencyInjection. A BackgroundService polls a shared ResolvedConfigRecord ledger.
• Lyo.Config.Api.Models: Config HTTP API contracts: ConfigResolveOutcome, ConfigResolveConditionalResult, and HttpStatusDescriptor.
• Lyo.Drift.Agent: Watches configured directories and posts file-tree and system-info snapshots to the Drift collector.
• Lyo.Drift.Api: HTTP mapping for the Lyo Drift collector API (BuildDriftGroup).
• Lyo.Drift.Api.Host: Standalone ASP.NET host for the Lyo Drift collector API.
• Lyo.Drift.Client: HTTP client for the Lyo Drift collector API.
• Lyo.HomeInventory.Api: HTTP mapping for the Lyo HomeInventory API (BuildHomeInventoryGroup).
• Lyo.HomeInventory.Api.Host: Standalone ASP.NET host for the Lyo HomeInventory API.
• Lyo.Http.Client: Generic HTTP client: IHttpClientFactory, JSON verbs, serializable plans, AngleSharp extract, rate limiting, cookies, and opt-in timing/UA rotation.
• Lyo.Http.Client.Flared: FlareSolverr adapter for Lyo.Http.Client: ThroughSolver HTML/JSON, cookie+UA streaming downloads, PerSession UA pin. Educational/personal use.
• Lyo.Job.Alerts: Hosted JobAlertConsumer that binds the job.notifications.alert routing key on the job.events exchange, deserializes JobAlertEvent payloads, and sends them through INotificationPublisher and/or an optional HTTP webhook.
• Lyo.Job.Api: HTTP mapping for the Lyo Job API (BuildJobGroup).
• Lyo.Job.Api.Host: Standalone ASP.NET host for the Lyo Job API.
• Lyo.Job.Client: Typed HTTP client for the Lyo Job API. Wraps IApiClient and exposes run-lifecycle methods (StartAsync, LogAsync, FinishAsync, RequeueAsync) plus worker-instance endpoints from Lyo.Job.Models.Constants.Rest.Job.
• Lyo.Job.Scheduler: A hosted JobScheduler polls the Job API for enabled definitions, evaluates schedules (blackout calendars, misfire catch-up, per-schedule time zones), and creates job runs via IApiClient.
• Lyo.Job.Worker: Lyo job-system worker SDK. Subclass JobWorkerBase and implement ExecuteAsync(IJobWorkerContext). The base class consumes the priority-enabled worker-type queue.
• Lyo.Reporting.Api: Authenticated HTTP endpoints for Lyo Reporting. Postgres stays service-only (ReportService + EF). BuildReportingGroup lives in this package.
• Lyo.Reporting.Api.Host: Standalone ASP.NET host for the Lyo Reporting API.
• Lyo.Reporting.Client: Typed HTTP client targeting the Lyo Reporting API (netstandard2.0;net10.0).
• Lyo.Web.Automation: Browser-automation models shared across runners: locators, JSON plans, a session abstraction, and plan execution. Playwright and Selenium types stay out of this package.
• Lyo.Web.Automation.Playwright: Playwright backend for the Lyo.Web.Automation abstractions: launches Chromium / Firefox / WebKit, owns session-scoped browser contexts, and matches the Selenium helpers.
• Lyo.Web.Automation.Selenium: Selenium WebDriver backend for the Lyo.Web.Automation abstractions: launch Chrome / Edge / Firefox / Safari (plus Selenium Grid), isolate sessions, and cover polling, tabs, frames, and plans.
• Lyo.Web.Components: MudBlazor / Blazor pieces for Lyo web UI: data grid, query builder, change-tracking form, file upload, rich-text editor, JSON editor, text-diff viewer, and identifier workbench.
• Lyo.Web.Components.Export: Menu items that export from Lyo data grids. Reference this package (and any optional format packages) and drop items into BulkExportControls.
• Lyo.Web.Components.Export.Csv: CSV export menu item for Lyo data grids.
• Lyo.Web.Components.Export.Xlsx: XLSX export menu item for Lyo data grids.
• Lyo.Web.Host: Shared Blazor host shell so a second app does not have to copy TestGateway's layout, theme, and client DI.
• Lyo.Web.WebRenderer: Server-side Razor rendering and HTML→PDF conversion. Razor rendering uses Microsoft.AspNetCore.Components.Web.HtmlRenderer; PDF conversion is driven by PuppeteerSharp against a…

• Lyo.Authentication: Server-side authentication services for Lyo. Two coexisting bearer formats behind a single contract.
• Lyo.Authentication.AspNetCore: ASP.NET Core integration for Lyo.Authentication. Three schemes coexist behind a single dispatcher.
• Lyo.Authentication.Client: Consumer-side runtime for the Lyo BFF auth flow. Plugs a web host, typically a Blazor Server gateway or a server-rendered API consumer, into a Lyo authentication API without ever exposing tokens to the browser.
• Lyo.Authentication.Google: Google profile for Lyo.Authentication.OpenIdConnect. Registers https://accounts.google.com as a confidential OIDC client in the BFF login flow.
• Lyo.Authentication.Keycloak: Keycloak profile for Lyo.Authentication.OpenIdConnect. Wires one or more Keycloak realms as confidential OIDC clients in the BFF login flow.
• Lyo.Authentication.Models: Wire-shape data for Lyo.Authentication. The half of the auth stack that's safe to ship to anyone, including Blazor WebAssembly clients.
• Lyo.Authentication.OpenIdConnect: OpenID Connect client base for Lyo. The Lyo API is the OIDC confidential client (BFF pattern). The frontend never sees the IdP and never receives tokens by URL fragment.
• Lyo.Authentication.Postgres: PostgreSQL persistence for Lyo.Authentication. Replaces the in-memory stores from the base lib with EF Core-backed implementations of IApiTokenStore, IUserStore, IExternalIdentityStore, IUserClaimStore, and IUserScopeStore.
• Lyo.Authentication.Web.Components: Host-agnostic Razor / MudBlazor components for Lyo authentication. Ships Login, Profile, Tokens, Auth Debug, and the AuthAdminPanel plus the abstractions that the Server and Wasm host adapters implement.
• Lyo.Authentication.Web.Components.Server: Blazor Server host adapter for Lyo.Authentication.Web.Components. Plugs the shared login / debug / profile pages into the BFF-cookie auth runtime in Lyo.Authentication.Client.
• Lyo.Authentication.Web.Components.Wasm: Blazor WebAssembly host adapter for Lyo.Authentication.Web.Components. Implements the same login / debug / profile pages over a pure-browser auth flow. No consumer-side server, no HttpOnly cookie.
• Lyo.ContentThreatScan: Heuristic scanning and numeric disposition scoring for readable text payloads: scripts, markup, suspicious SQL-ish patterns.
• Lyo.ContentThreatScan.Intel: Optional DefaultContentThreatReputationPipeline for Malware Bazaar, VirusTotal, and clamd INSTREAM (TCP).
• Lyo.Drift.Models: DTOs, enums, and route constants for the Lyo Drift collector: instances, structure snapshots, and diffs.
• Lyo.Drift.Postgres: PostgreSQL persistence for the Lyo Drift collector.
• Lyo.Drift.Web.Components: Blazor workbench for Drift collector instances, snapshots, diffs, and live changes.
• Lyo.Encryption: Authenticated encryption for .NET. AEAD, RSA hybrids, and envelope (two-key) flows with optional Lyo.KeyStore lookup.
• Lyo.Encryption.AesCcm: AES-CCM authenticated encryption addon for Lyo.Encryption. Provides AesCcmEncryptionService (BouncyCastle-backed on all targets) and matching DI extensions.
• Lyo.Encryption.AesSiv: AES-SIV (RFC 5297) deterministic authenticated encryption addon for Lyo.Encryption. Provides AesSivEncryptionService backed by Dorssel.Security.Cryptography.AesExtra and matching DI extensions.
• Lyo.Encryption.XChaCha20Poly1305: XChaCha20-Poly1305 (24-byte nonce, 32-byte key) authenticated-encryption addon for Lyo.Encryption.
• Lyo.Hashing: Digests (SHA-256/384/512), optional MD5 for non-security fingerprints only, non-cryptographic checksums (CRC-32/CRC-32C/CRC-64/Adler-32), hexadecimal encoding (HexEncoding), incremental hashing (HashingStream), sparse file fingerprints (SparseFileFingerprinter), and injectable IHashingService / HashingService.
• Lyo.KeyStore: Key encryption key (KEK) storage and rotation contracts for Lyo.Encryption.
• Lyo.KeyStore.Aws: AwsKeyStore takes an IAmazonSecretsManager client and a secret-name prefix. It implements Lyo.KeyStore.IKeyStore and Lyo.KeyStore.IKeyInventoryStore, so admin UIs and key-rotation jobs can encrypt against it and list keyIds and versions.
• Lyo.KeyStore.Web.Components: In-process Blazor workbench for IKeyStore. Lists key ids and versions, adds from a string, rotates, and sets current. No HTTP, no raw key bytes.

• Lyo.Drift.Agent.Example: Sample Drift agent host.
• Lyo.Job.Scheduler.Example: Sample job scheduler host.
• Lyo.Job.Worker.Example: Sample job worker that subscribes to job.run.example.
• Lyo.Reporting.Business.Example: Sample reporting host that wires Lyo.Reporting into a small Blazor app.

• Lyo.Cli: Installable lyo CLI that covers encryption, encoding, compression, hashing, IDs, query build/exec, and CSV/XLSX.
• Lyo.TestApi: Minimal-API host backing Lyo.TestGateway and Lyo.TestConsole. Wires Lyo Postgres stores, the RabbitMQ job system, S3 file storage with two-key encryption, and the file-storage workbench endpoints.
• Lyo.TestConsole: Scratch host used to exercise Lyo services from a long-lived Microsoft.Extensions.Hosting process.
• Lyo.TestGateway: Blazor Server workbench for the Lyo platform. About 30 routed test pages (cache, locks, file storage, PDF, and more) plus a thin proxy so each page can hit a remote API or in-process services.
• Lyo.Tools.Postgres: Spectre.Console TUI used for EF Core migrations against Lyo Postgres DbContexts, plus Lyo.Seed contributors (EF direct and Lyo.Api bulk).

• k6 framework: Person Query API: k6 workloads and query shapes against TestApi persons.
• K6 benchmark analysis: latest archived run metrics and comparison to common API stacks (Hasura/PostgREST, typical ORM APIs, etc.).

Project-wide guides live in docs/. Per-package API docs are the README.md beside each library.

Interactive HTML, open locally or via Pages: the project graph and the benchmark dashboards.

• Start from the Major capabilities table for API/query, storage, PDF (Lyo.Pdf), encryption, caching, diagnostics, content-threat scanning, hashing, and compression.
• For API query behavior and endpoints, the Lyo.Api README is the overview to read first.
• For any other documented package, use All packages with READMEs above (complete list as of the last edit).

The license does not require users of the library to send changes back. That keeps adoption easy for companies and side projects. We still welcome fixes and improvements. See CONTRIBUTING.md and the CODE_OF_CONDUCT.md. Security issues should follow SECURITY.md.

Licensed under the Apache License, Version 2.0 (view on apache.org). You may use Lyo in commercial and closed-source software. See the license for attribution and redistribution requirements. Replace "The Lyo authors" in LICENSE if you want a specific copyright line.