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: SMTP email through MailKit. EmailService implements IEmailService.
• Lyo.Email.Models: Shared models, options, error codes, and event arguments for the Lyo.Email SMTP service.
• Lyo.Email.Postgres: PostgreSQL schema and EmailDbContext for logging emails sent by Lyo.Email. This package does not subscribe to EmailService events. Consumers map and insert rows themselves.
• Lyo.Email.Web.Components: Blazor (MudBlazor) workbench for sending email through an injected IEmailService.
• Lyo.MessageQueue: IMqService is 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 registered as IRabbitMqService for exchanges and other RabbitMQ-only methods.
• Lyo.MessageQueue.RabbitMq.Web.Components: Blazor components for RabbitMQ exchanges, bindings, and broker workbenches.
• Lyo.MessageQueue.Web.Components: Blazor components for provider-neutral message queue dashboards and workbenches.
• Lyo.Sms: SMS contracts and shared send pipeline. Providers (Lyo.Sms.Twilio, and others) implement SmsServiceBase.
• Lyo.Sms.Models: Shared types for Lyo.Sms: payloads, paging, events, normalization, and base options. This package does not send SMS. Implementations live in provider packages (Lyo.Sms.Twilio, and others).
• Lyo.Sms.Postgres: EF Core PostgreSQL store for outbound SMS logs (SmsLogEntity). This package does not send SMS. It wires SmsDbContext so workers or gateways can persist send outcomes.
• Lyo.Sms.Twilio: Twilio SMS and MMS through Lyo.Sms. TwilioSmsService implements ISmsService.
• Lyo.Sms.Twilio.Postgres: EF Core PostgreSQL store for Twilio SMS traces: TwilioSmsDbContext and TwilioSmsLogEntity.
• Lyo.Sms.Web.Components: Blazor (MudBlazor) workbench for an injected ISmsService. Uses MudBlazor and snackbar helpers from Lyo.Web.Components.
• Lyo.Stt: Speech-to-text contract for Lyo. Ships ISttService, SttServiceBase, request/result/options/event records, and metric name constants. No provider packages ship in this repo.
• Lyo.Translation: Archetype B (capability). Providers (Lyo.Translation.Google, Lyo.Translation.Aws) stay under Communication/Translation/, not Integration/. See package layout.
• Lyo.Translation.Aws: Amazon Translate implementation of 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 implementation of ITranslationService. GoogleTranslationService extends TranslationServiceBase and calls the REST API over HTTP.
• Lyo.Translation.Web.Components: Blazor (MudBlazor) workbench for the configured Lyo.Translation implementation.
• Lyo.Tts: Contracts and shared TTS behavior: provider-agnostic interfaces, a non-generic facade, and a base service with bulk synthesis, metrics, and lifecycle events.
• Lyo.Tts.AwsPolly: Amazon Polly TTS. AwsPollyTtsService extends TtsServiceBase<AwsPollyTtsRequest> with voice selection, output formats, bulk synthesis, metrics, and DI helpers.
• Lyo.Tts.AwsPolly.Web.Components: Blazor (MudBlazor) workbench for trying Lyo.Tts.AwsPolly from a host app.
• Lyo.Tts.Models: Shared TTS requests, results, options, and event payloads. Provider packages reference this instead of each other.
• Lyo.Tts.Typecast: Typecast TTS via Lyo.Typecast.Client. TypecastTtsService synthesizes audio through TypecastClient, can load the voice catalog for validation (LoadVoicesAsync), and uses the bulk pipeline and Typecast-namespaced metrics from Lyo.Tts.
• Lyo.Tts.Typecast.Web.Components: Blazor (MudBlazor) workbench for trying Lyo.Tts.Typecast from a host app.
• Lyo.Tts.WindowsSpeech: Windows SAPI text-to-speech. WindowsSpeechTtsService uses the built-in Speech API.

• Lyo.Audit: Audit trail library with two records: AuditChange (entity change tracking) and AuditEvent (events to log).
• Lyo.Audit.Postgres: PostgreSQL implementation of Lyo.Audit using Entity Framework Core. Persists AuditChange and AuditEvent records to PostgreSQL with JSONB columns for dictionary data.
• Lyo.Benchmark: Benchmark-only helpers shared by every *.Benchmarks executable. The BenchmarkDotNet analogue of Lyo.Testing.
• Lyo.Benchmark.Models: Models and builders for the Lyo benchmark report schema (lyo.bench/v1).
• Lyo.Cache: Local ICacheService plus typed byte payload methods. Serialize once, store framed bytes, optionally compress or encrypt on .NET 10+.
• Lyo.Cache.Fusion: FusionCacheService adapts ZiggyCreatures.FusionCache to ICacheService 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 built around Lyo.EntityReference.Models.EntityRef. Record property-level changes for any entity type without coupling the tracker to a specific aggregate.
• Lyo.ChangeTracker.Postgres: PostgreSQL implementation of Lyo.ChangeTracker. Persists entity-scoped change history using Lyo.EntityReference.Models.EntityRef for both the target entity and the optional actor.
• Lyo.Common: Shared primitives: ID generators, file/MIME/language/HTTP/file-size metadata, geometry, secure RNG, typed extensions, and shared System.Text.Json options.
• Lyo.DateAndTime: Date, time, US timezone conversion, day-of-week scheduling, and US holiday metadata. Static and thread-safe. No mutable shared state.
• Lyo.Diagnostic: Stack trace decoding, exception classification, breadcrumb trails, an in-memory error inbox, sanitisation, and structured logging.
• Lyo.Diagnostic.AspNetCore: ASP.NET Core integration for Lyo.Diagnostic. Scoped breadcrumb trails per request 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 for analyzing and triaging .NET stack traces and exception payloads with Lyo.Diagnostic.
• Lyo.Diff: Side-by-side comparison for human-readable text and object graphs.
• Lyo.EntityReference.Models: Typed pair of logical entity kind (EntityType) and identifier string (EntityId), plus helpers for composite keys, JSON, opaque tokens, validation, and domain row shapes.
• Lyo.EntityReference.Postgres: Entity Framework Core building blocks for relation rows (subject/actor associations) and source link rows (import provenance) on PostgreSQL.
• Lyo.Exceptions: Exception types and argument validation helpers used by Lyo packages.
• Lyo.Geolocation: Provider-agnostic geospatial operations and persistence contracts.
• Lyo.Geolocation.Models: Neutral data contracts for Lyo.Geolocation and Lyo.Geolocation.Postgres.
• Lyo.Geolocation.Postgres: PostgreSQL persistence for canonical geolocation data using Entity Framework Core.
• Lyo.Health: Interface for services that report their own health. Implement IHealth. There is no central health service.
• Lyo.Lock: Key-based exclusive locks and keyed semaphores (bounded concurrency per key), plus in-memory implementations for a single process.
• Lyo.Lock.Redis: Distributed ILockService on Redis via StackExchange.Redis. Use this when multiple app instances must exclude each other on the same 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 for discoverability.
• Lyo.Metrics: Thread-safe counters, gauges, histograms, timings, errors, and events, with in-memory, OpenTelemetry, and null implementations.
• Lyo.Metrics.OpenTelemetry: OpenTelemetry implementation of IMetrics for exporting metrics to OpenTelemetry-compatible backends.
• Lyo.Metrics.Statistics: Statistical analysis extensions for Lyo.Metrics histograms. Provides percentile / quartile / moving-average / anomaly-detection helpers on top of the metrics primitives in Lyo.Metrics.
• Lyo.Notification: In-process publish/subscribe for small domain events. Not durable, not distributed, and not ordered across machines. Only useful when every publisher and handler lives in the same process.
• Lyo.PackageMetadata: Multi-ecosystem PackageMetadata rows, PackageMetadataRegistration, IPackageMetadataStore, and PackageArtifactDigest helpers for correlating stack-trace namespaces with persisted catalog data.
• Lyo.PackageMetadata.Postgres: EF Core persistence for Lyo.PackageMetadata.IPackageMetadataStore.
• Lyo.People.Models: Person, contact, employment, identification, and relationship records for the people domain.
• Lyo.People.Postgres: PostgreSQL persistence for Lyo.People.Models using Entity Framework Core.
• Lyo.Privacy: Redacts emails, phones, Luhn card numbers, IBAN, secrets, IDs, URLs, IPs, and street lines in free text, JSON, and XML.
• Lyo.Privacy.AspNetCore: ASP.NET Core DI integration for Lyo.Privacy: registers ITextRedactor / IStructuredRedactor, binds PrivacyRedactorOptions from configuration, and supports keyed per-tenant or per-feature…
• Lyo.Privacy.Web.Components: Blazor (Server / Interactive) workbench components for Lyo.Privacy. Lets operators preview, compare, and tune redaction policies without round-tripping through a host config edit.
• Lyo.Resilience: A thin wrapper around Polly for resilience pipelines with configuration-from-appsettings support and built-in logging.
• Lyo.Result: Result / Result<T> with Error graphs, builders, bulk/paged envelopes, and Task composition. Separate from Lyo.Common Result.
• Lyo.Schedule.Models: DTO-only assembly that describes a schedule. Used by Lyo.Scheduler, Lyo.Job.Postgres, and any consumer that needs a transport-friendly representation of "when does this run".
• Lyo.Schedule.Web.Components: Blazor component(s) for building and previewing Lyo.Schedule.Models.ScheduleDefinition values interactively.
• Lyo.Scheduler: In-process scheduler service for executing 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. Persists 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 built on Lyo.Mathematics.
• Lyo.Streams: TeeStream, CountingStream, ProgressStream, ConcatenatedStream, and related stream wrappers. Incremental hashing lives in Lyo.Hashing (HashingStream).
• Lyo.Testing: xUnit v3 helpers: fluent Should* assertions, exception and collection helpers, polling assertions, and an ITestOutputHelper logger.
• Lyo.Testing.Containers: xUnit v3 fixtures around Testcontainers for PostgreSQL and RabbitMQ.
• Lyo.TextEncoding: Binary codecs (Base64 / Base64Url / Hex) and 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 return Lyo.Result.Result<T> failures.
• Lyo.Validation.Postgres: PostgreSQL persistence for ValidationSchema documents (WhereClause JSONB) via IValidationSchemaStore.
• Lyo.Webhook: Inbound webhook verification for ASP.NET Core: raw body and headers, HMAC helpers, MapWebhook().Verify().Handle(), and Lyo.Metrics timings.
• Lyo.Webhook.Twilio: Twilio webhook signature validation for Lyo.Webhook. Compares X-Twilio-Signature to an HMAC-SHA1 (Base64) of the public request URL plus sorted key+value form parameters.

• Lyo.Barcode: Barcode generation and decoding contracts: IBarcodeService, request and options models, and BarcodeBuilder.
• Lyo.Barcode.Native: IBarcodeService implementation for Lyo.Barcode. No third-party barcode generator.
• Lyo.Barcode.TestWorkbench.Web.Components: MudBlazor page wrapper that hosts from Lyo.Barcode.Web.Components inside a MudContainer for the Lyo gateway test harness.
• Lyo.Barcode.Web.Components: MudBlazor components that call IBarcodeService from Lyo.Barcode.
• Lyo.Compression: Compress and decompress bytes, strings, streams, and files through ICompressionService. One default codec, plus ICompressionResolver for per-algorithm dispatch.
• Lyo.Compression.BZip2: BZip2 compression addon for Lyo.Compression. Registers a BZip2 ICompressorFactory.
• Lyo.Compression.Lz4: LZ4 compression addon for Lyo.Compression. Registers an LZ4 ICompressorFactory backed by EasyCompressor.LZ4.
• Lyo.Compression.Lzma: LZMA compression addon for Lyo.Compression. Registers an LZMA ICompressorFactory.
• Lyo.Compression.Snappier: Snappy compression addon for Lyo.Compression. Registers a Snappier ICompressorFactory.
• Lyo.Compression.Xz: XZ / LZMA2 compression addon for Lyo.Compression. Registers an XZ ICompressorFactory.
• Lyo.Compression.Zstd: Zstandard compression addon for Lyo.Compression. Registers a Zstd ICompressorFactory.
• Lyo.Csv: Owned CSV stack implementing 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: Interfaces and value types for the Lyo CSV stack. Lyo.Csv implements this contract so consumers can depend on ICsvService, ICsvReader, and ICsvWriter without the implementation package.
• Lyo.DataTable: Empty package placeholder reserving the Lyo.DataTable name. The runtime types (DataTable, DataTableRow, DataTableBuilder, cell types, HTML renderer) all live in Lyo.DataTable.Models.
• Lyo.DataTable.Models: Mutable in-memory data table with sparse columns, thin cells, an optional format map, fluent builders, and an HTML renderer.
• Lyo.FFmpeg: Wraps the ffmpeg, ffprobe, and ffplay CLIs (via CliWrap) behind IAudioPlayer, IAudioProber, and IAudioConverter from Lyo.FFmpeg.Models.
• Lyo.FFmpeg.Models: Contracts and models for Lyo.FFmpeg: IAudioPlayer, IAudioProber, IAudioConverter, AudioConversionRequest, AudioConversionOptions, AudioProbeResult, and FFmpegOptions.
• Lyo.FileMetadataStore: File identity without bytes. Canonical Guid file identifiers and metadata, not blob I/O.
• Lyo.FileMetadataStore.Postgres: Postgres IFileMetadataStore plus adjunct stores used by richer file pipelines.
• Lyo.FileMetadataStore.Sqlite: SQLite IFileMetadataStore using Entity Framework Core. 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 metadata for files. Optional compression (Lyo.Compression), two-key encryption (Lyo.Encryption), duplicate hashing, access policies, malware scans, audit hooks, multipart uploads (IMultipartUploadService), and presigned/direct-upload/copy on cloud backends.
• Lyo.FileStorage.AzureBlob: Azure Blob Storage implementation of IFileStorageService using Azure.Storage.Blobs.
• Lyo.FileStorage.Ftp: FTP-backed IFileStorageService via Lyo.Ftp.Client.
• Lyo.FileStorage.S3: S3-compatible storage for Lyo.FileStorage (AWS S3, Backblaze B2, MinIO, and others) via AWSSDK.S3.
• Lyo.FileStorage.Sftp: SFTP-backed IFileStorageService via Lyo.Sftp.Client.
• Lyo.FileStorage.Web.Components: Blazor Server / Interactive UI for Lyo.FileStorage. Tree/grids and dialogs for file metadata, expected storage keys, download access links, and DEK migrate/rotate.
• Lyo.FileSystemWatcher: Snapshot-based file watcher for .NET. Detects creates, deletes, changes, moves, and renames with debounce and SHA256 hashing.
• Lyo.Formatter: SmartFormat.NET templating 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. Works on WASM.
• Lyo.Ftp.Client: Pooled FluentFTP client with PathHelpers jail, logging, and Lyo.Metrics. Prefer *Async.
• Lyo.IO.Temp: Create and manage temporary files and directories with sessions, naming strategies, and overflow handling.
• Lyo.IO.Temp.Ftp: FTP-backed IIOTempStorageProvider for Lyo.IO.Temp.
• Lyo.IO.Temp.Sftp: SFTP-backed IIOTempStorageProvider for Lyo.IO.Temp.
• Lyo.Images: Raster image processing for .NET using SixLabors.ImageSharp.
• Lyo.Images.Ocr: OCR contracts for Lyo: IOcrEngine, request/response models, Y-up pixel bounding boxes (aligned with BoundingBox2D), coordinate helpers, and shared options.
• Lyo.Images.Ocr.Tesseract: Tesseract implementation of IOcrEngine from Lyo.Images.Ocr. Calls are serialized with an internal lock because native Tesseract instances are not safely concurrent.
• Lyo.Images.OpenCv: OpenCV helpers for .NET via OpenCvSharp4. Separate from higher-level pipelines (e.g. comic overlay) so hosts pull native OpenCV only where needed.
• Lyo.Images.Skia: SkiaSharp IImageService from Lyo.Images: resize, crop, rotate, watermark, convert, thumbnails, compression, metadata, palette, batch.
• Lyo.Images.Web.Components: Blazor / MudBlazor workbenches for Lyo.Images: IImageService ops and a spritesheet animator/extractor on ISpriteSheetExportService.
• Lyo.Pdf: PdfPig-backed reading and PDFsharp-backed editing for Lyo.Pdf.Models. PdfService is the entry point; it returns disposable IPdfReader instances for read/extract workflows and IPdfWriter…
• Lyo.Pdf.Models: Interfaces and value types for the Lyo PDF stack. Defines the contracts implemented by Lyo.Pdf so consumers can depend on IPdfService, IPdfReader, IPdfWriter, and ITextExtractor without…
• Lyo.Pdf.Ocr: Renders a PDF page to PNG via Lyo.Pdf.Rendering, runs IOcrEngine, then maps OCR pixel boxes back into PDF points.
• Lyo.Pdf.Rendering: Rasterizes PDF pages to PNG via PDFtoImage (PDFium + Skia; bblanchon.PDFium native packages). Targets net10.0.
• Lyo.Pdf.Web.Components: Blazor / MudBlazor PDF workbenches: HTML to PDF, annotation, and LyoPdfAnnotator for drawing bounding-box regions that emit PdfBoundingBox.
• Lyo.Postgres: Shared PostgreSQL migration plumbing for Lyo libraries that ship their own EF Core schema (Audit, Email, ChangeTracker, EntityReference, etc.).
• Lyo.QRCode: QR code generation and reading for Lyo: IQRCodeService, QRCodeBuilder, ISO Model 2 encoding in-box (BuiltInQRCodeService), optional QRCoder adapter.
• Lyo.QRCode.QRCoder: QRCoder implementation of IQRCodeService from Lyo.QRCode. Use this for JPEG / Bitmap on Windows, or QRCoder's renderers.
• Lyo.QRCode.Web.Components: Blazor / MudBlazor components for QR code generation and preview.
• Lyo.Query: WhereClause AST → LINQ on IQueryable: filter, multi-key sort, in-memory match/explain, with ICache-backed compiled predicates.
• Lyo.Query.Models: Filter / sort / projection DTOs and fluent builders (WhereClause, QueryConcrete / QueryProject / root Query) shared by Lyo.Query and Lyo.Api.
• Lyo.Query.Web.Components: Blazor / MudBlazor components for editing and running Lyo.Query.Models requests against any Lyo.Api host.
• Lyo.Sftp.Client: Pooled SSH.NET SFTP client with PathHelpers jail, logging, and Lyo.Metrics. Prefer *Async.
• Lyo.Sqlite: Shared SQLite migration plumbing for Lyo libraries that ship their own EF Core schema.
• Lyo.Xlsx: Implementation of Lyo.Xlsx.Models. XlsxService composes an XlsxWriter (streaming DocumentFormat.OpenXml writer) and an XlsxReader (ExcelDataReader / ClosedXML) to read and write XLSX…
• Lyo.Xlsx.Models: Interfaces and value types for the Lyo XLSX stack. Defines the contract implemented by Lyo.Xlsx so consumers can depend on IXlsxService / IXlsxReader / IXlsxWriter without pulling in ClosedXML…

• 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 + 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: Abstractions for threaded, reactable comments on any entity. Each comment has a subject, an actor, optional ReplyToCommentId, and cached like/dislike counters.
• Lyo.Comment.Postgres: PostgreSQL implementation of Lyo.Comment using Entity Framework Core. Persists comments to comment.comment and reactions to 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 + 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 handle validation, error-code mapping, and logging. Storage lives in sibling packages.
• Lyo.ContactUs.Postgres: PostgreSQL + EF Core implementation of Lyo.ContactUs.IContactUsService (PostgresContactUsService) via ContactUsDbContext and PostgresContactUsOptions.
• Lyo.Favorite: Abstractions for "X favorited Y" relationships across any two entities. The API accepts EntityRef at the boundary.
• Lyo.Favorite.Postgres: PostgreSQL implementation of Lyo.Favorite using Entity Framework Core. Persists favorites to the favorite.favorite table (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.Note: Abstractions for notes attached to entities. Each note has a subject (what it is about) and an actor (who wrote it), expressed as EntityRef.
• Lyo.Note.Postgres: PostgreSQL implementation of Lyo.Note using Entity Framework Core. Persists notes to the note.note table (PostgresNoteOptions.Schema = "note") and ships migrations.
• Lyo.Profanity: File-based profanity filter. Detects and replaces profane words. Multiple languages, regex patterns, plain word lists, and configurable replacement strategies.
• Lyo.Rating: Abstractions for rating and reviewing entities, plus like/dislike reactions on those ratings.
• Lyo.Rating.Postgres: PostgreSQL implementation of Lyo.Rating using Entity Framework Core. Persists ratings to rating.rating and reactions to rating.rating_reaction.
• Lyo.ShortUrl: URL shortening contracts: IShortUrlService, ShortUrlServiceBase for validation / metrics / error-code mapping, a default ShortUrlService that generates short codes (no storage), UrlShortenBuilder, and shorten / expand / statistics DTOs.
• Lyo.ShortUrl.Postgres: EF Core schema and DbContext registration for a PostgreSQL-backed short-URL store.
• Lyo.Tag: Abstractions for tagging entities. Tags key off an EntityRef (what is tagged) and an optional second EntityRef (who applied the tag).
• Lyo.Tag.Postgres: PostgreSQL implementation of Lyo.Tag using Entity Framework Core. Persists tags to the tag.tag table (PostgresTagOptions.Schema = "tag") and ships migrations.

• Lyo.Api: Minimal-API library that maps EF Core entities to REST CRUD. ApiEndpointBuilder emits Query, Get, Create, Update, Patch, Delete, Upsert, bulk variants, and optional export.
• Lyo.Api.Client: HTTP client for Lyo minimal APIs: JSON in/out, gzip/brotli/deflate, query-string encoding for GET DTOs, file upload helpers, and System.Text.Json parity with server options when you wire them.
• Lyo.Api.Export: Optional export for Lyo.Api. Registers the Export CRUD endpoint and IExportService<TContext>.
• Lyo.Api.FileStorage: HTTP endpoints for Lyo file storage. Hosts map BuildFileStorageApi after registering a keyed IFileStorageService stack.
• Lyo.Api.FileStorage.Models: HTTP request and response DTOs for the file-storage API. No dependency on Lyo.FileStorage.
• Lyo.Api.Models: Shared HTTP contract models for Lyo minimal APIs and their clients. Distinct from Lyo.Query.Models (filter trees + projection DTOs).
• Lyo.Api.Reporting: Authenticated HTTP endpoints for Lyo Reporting. Postgres stays service-only (ReportService + EF). This package owns BuildReportingGroup.
• Lyo.Api.Tests.Host: Reference ASP.NET Core minimal-API host used by Lyo.Api.Tests and other integration tests as a WebApplicationFactory<Program> target.
• Lyo.Discord.Bot: Library (not an executable) that runs a DSharpPlus Discord bot and upserts guild data into your Lyo API (Lyo.Discord.Client to PostgreSQL-backed Discord/* endpoints).
• Lyo.Discord.Client: Typed HTTP client for the Discord REST endpoints exposed by Lyo.Api (the Discord/* group registered by Lyo.Discord.Postgres).
• Lyo.Discord.Models: Wire-level DTOs and shared constants for the Discord integration. Used by Lyo.Discord.Client (typed HTTP client) and Lyo.Discord.Postgres (API host + persistence) so request and response shapes match.
• Lyo.Discord.Postgres: PostgreSQL persistence and Lyo.Api endpoint mappings for Discord entities. Schema name is fixed to discord (PostgresDiscordOptions.Schema).
• Lyo.Endato.Client: Typed HTTP client for the Endato data-enrichment REST API.
• Lyo.Endato.Postgres: PostgreSQL schema and EF Core context for caching Endato Person Search (PS) and Contact Enrichment (CE) responses. Schema name is endato.
• Lyo.Espn.Fantasy.Football.Client: Typed read-only client for the ESPN fantasy football v3 API (lm-api-reads.fantasy.espn.com/apis/v3/games/ffl/).
• Lyo.Google.Geolocation.Client: Google Maps REST client and IGeolocationService implementation.
• Lyo.Job.Alerts: Hosted JobAlertConsumer that subscribes to the job.notifications.alert routing key on the job.events exchange, deserializes JobAlertEvent payloads, and dispatches them through INotificationPublisher and/or an optional HTTP webhook.
• Lyo.Job.Client: Typed HTTP client for the Lyo Job API. Wraps IApiClient with run lifecycle methods (StartAsync, LogAsync, FinishAsync, RequeueAsync) and worker-instance endpoints from Lyo.Job.Models.Constants.Rest.Job.
• Lyo.Job.Models: Shared DTOs, builders, enums, metrics constants, distributed-tracing helpers, and message-queue contracts for the Lyo job-management subsystem.
• Lyo.Job.Postgres: PostgreSQL persistence and minimal-API host for the Lyo job-management subsystem.
• Lyo.Job.Scheduler: Hosted JobScheduler that polls the Job API for enabled definitions, evaluates schedules (misfire catch-up, blackout calendars, per-schedule time zones), and creates job runs via IApiClient.
• Lyo.Job.Web.Components: Blazor / MudBlazor dashboard for the Lyo job stack. Add JobManagement to a host page for Statistics, Definitions, Schedules, Runs (progress and SLA breach), worker registry, and workflow views.
• Lyo.Job.Worker: Worker SDK for the Lyo job system. Subclass JobWorkerBase and implement ExecuteAsync(IJobWorkerContext). The base class consumes the priority-enabled worker-type queue.
• Lyo.Reporting.Client: Typed HTTP client for the Lyo Reporting API (netstandard2.0;net10.0).
• Lyo.Reporting.Models: Composition models, fluent builders, API contracts, and generation hooks for Lyo Reporting.
• Lyo.Reporting.Postgres: PostgreSQL schema (reporting), EF migrations, CSV/XLSX/JSON renderers, ReportService generation pipeline, and ReportRetentionService cleanup.
• Lyo.Reporting.Web: Blazor ReportViewer, business document templates, and an IReportRenderer that emits HTML and PDF.
• Lyo.Reporting.Web.Components: MudBlazor ops UI for Lyo Reporting: browse definitions, run reports, and view/download generations.
• Lyo.Typecast.Client: Typecast API client for text-to-speech and voice management. TypecastClient extends Lyo.Api.Client.ApiClient, configures the X-API-KEY header from TypecastClientOptions, and exposes two…
• Lyo.Web.Automation: Shared browser automation models: element locators, JSON automation plans, session abstraction, and plan runners. No Playwright or Selenium types.
• Lyo.Web.Automation.Playwright: Playwright implementation of the Lyo.Web.Automation abstractions: launches Chromium / Firefox / WebKit, manages session-scoped browser contexts, and matches the Selenium helpers.
• Lyo.Web.Automation.Selenium: Selenium WebDriver implementation of the Lyo.Web.Automation abstractions: browser launch (Chrome / Edge / Firefox / Safari + Selenium Grid), session isolation, polling, tabs, frames, and plans.
• Lyo.Web.Components: Blazor / MudBlazor components 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: Export menu items for Lyo data grids. Reference this package (plus optional format packages) and add items to BulkExportControls.
• Lyo.Web.WebRenderer: Server-side rendering of Razor components and HTML→PDF conversion. Razor rendering uses Microsoft.AspNetCore.Components.Web.HtmlRenderer; PDF conversion is driven by PuppeteerSharp against a…

• Lyo.Config.Api: HTTP host for central app configuration backed by PostgreSQL and Lyo.Config.
• Lyo.Config.Api.Client: Typed HTTP client for Lyo.Config.Api. Conditional app-config reads with If-None-Match / ?version polling, optional X-Api-Key, HTTP IConfigStore (ConfigApiStore) over manage routes, and DI extensions.
• Lyo.Config.Api.Host: Standalone ASP.NET host for Lyo.Config.Api.
• Lyo.Config.Api.Hosting: Wires IConfigApiClient (Lyo.Config.Api.Client) into Microsoft.Extensions.DependencyInjection and Microsoft.Extensions.Options. A BackgroundService polls a shared ResolvedConfigRecord ledger.
• Lyo.Config.Api.Models: Contracts for the Config HTTP API: ConfigResolveOutcome, ConfigResolveConditionalResult, and HttpStatusDescriptor.

• 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, and IExternalIdentityStore.
• Lyo.Authentication.Web.Components: Host-agnostic Razor / MudBlazor components for Lyo authentication. Ships the Login, Auth Debug, and Profile pages 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.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.Cli: Installable lyo command-line tool for encryption, encoding, compression, hashing, IDs, query build/exec, and CSV/XLSX.
• Lyo.Preview: Cross-platform preview in the system default browser. BrowserPreview starts an HttpListener on 127.0.0.1 (random free port), serves one byte buffer per call, opens the URL, and drops the entry after the browser fetches it.
• Lyo.Seed: Generator-agnostic seeder: contributors return items, then EF or Lyo.Api bulk-create persists them.
• Lyo.TestApi: Minimal-API host that backs 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 for exercising Lyo services from a long-lived Microsoft.Extensions.Hosting process.
• Lyo.TestGateway: Interactive 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 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.