A composable HTTP middleware chain. The `Chain` type wraps a list of `Middleware` functions (func(http.Handler) http.Handler) and applies them in an onion-like fashion, with the innermost handler being the final target. The `Then` method returns a single http.Handler. This is a self-contained, generic pattern extractable to any Go HTTP server. It does not import any internal packages beyond stdlib.

A concurrent publish-subscribe system using lock-free subscription management via atomic pointer swap. Subscribers register typed event handlers via channel-based callback. The dispatcher fans out events to all subscriber queues with backpressure (configurable max queue depth). Supports unsubscription and draining. The core design is independent of llama-swap's domain and can serve as a generic in-process event bus.

A fixed-capacity circular buffer for storing log messages or any time-series data. Provides thread-safe append, iteration with index tracking for SSE tailing, and reset. Uses `sync.RWMutex` for safe concurrent access. The implementation is small, well-tested, and can be extracted as a standalone data structure for any Go project needing a rolling history buffer.

A rate-limited event counter (`SuppressionCounter`) that deduplicates repeated log messages by allowing at most one event per key within a configurable window. It tracks `time.Time` for each key, suppressing duplicates until the window expires. The pattern is self-contained (imports only `sync` and `time`) and can be reused wherever noisy repeated events need to be throttled, such as error logs, health-check failures, or status updates.

A poll-based file and directory watcher that periodically checks file modification times and detects changes (created, modified, deleted, directory added). Uses a `map[string]time.Time` to track last known mod times. Designed to be resilient in environments where `inotify` is unreliable (Docker bind-mounts, Kubernetes). The polling interval is configurable. The component is self-contained (stdlib only: `os`, `time`) and can be reused anywhere polling-based file monitoring is needed.

Orchestration layer for cross-platform hardware detection. It collects results from platform-specific probes (Linux via sysfs, Windows via DXGI, macOS via IOKit), merges them by GPU PCI address, and returns a unified `HardwareInfo`. The detection is pluggable: each probe returns a list of GPUs or nil; the merge strategy deduplicates by PCI ID. The pattern is a clean abstract factory for platform-specific hardware queries, extractable to any Go project needing cross-platform GPU or system information.

Indexes a knowledge base of documentation articles (YAML frontmatter + markdown body) into a flat namespace for LLM retrieval. Each article is assigned a deterministic ID, and the index stores a byte-capped window of lines for context. Supports listing, searching (by keywords/regex), and retrieving full article text. Designed for the MCP tool surface. The indexing pattern is generic and can be reused to expose any structured documentation to LLM agents via MCP or other retrieval interfaces.

A macro expansion engine for YAML configuration values. Supports global macros (`${MODEL_ID}`, `${PORT}`, `${PID}`), model-level macros, environment variable references (`${env.VAR}`), and recursive macro resolution (with cycle detection). Macros are expanded in a specific order (global → model → env) with proper scoping. The implementation is non-obvious: it walks the YAML tree, substitutes string nodes, handles typed values (ints, bools, arrays) by converting back and forth. This pattern can be extracted for any application needing template-like configuration with variable substitution.