Capabilities
Choose the opt-in platform pieces you need — transports, policy, messaging, realtime, coordination, persistence, and operations.
Concepts covers the application model you cannot avoid: every Elarion app has handlers, results, modules, and the source generation that wires them. Capabilities are different — they are the platform pieces you opt into and explicitly wire. You can ship a working application without any of them, and add each one only when a real requirement calls for it.
That line is the framework's guiding principle in practice:
Auto-detect application patterns, explicitly wire platform capabilities.
Each capability below is independent. Add its package, declare any compile-time opt-in it needs, and wire the runtime in your host.
Hosting & transports
Hosting & composition
Compose modules into an ASP.NET Core host with the generated bootstrapper, feature gating, and endpoint mapping.
Serialization & AOT
Compose per-module JSON contexts into one AOT-friendly serializer shared across transports.
Transports
Map the same handler over HTTP, JSON-RPC, or MCP — and decide which one fits.
Application policy
Current user
Transport-neutral access to the authenticated caller, without depending on HttpContext.
Identity
Optional ASP.NET Core Identity host wiring over the application's existing DbContext.
Authorization
One generated handler gate for permissions, roles, claims, policies, and every transport.
Validation
Data-annotation request validation with generated metadata and transport-safe failures.
Caching
Declarative handler result caching with [Cacheable] and tag-based invalidation.
Resilience
Named retry and timeout policies applied to handlers and jobs.
Feature flags
Gate handlers with [FeatureGate] and swap per-variant services over any OpenFeature provider.
Work, messaging & realtime
Scheduling
Source-generated recurring and one-off jobs, with optional cross-node occurrence claims.
Domain & integration events
In-process domain events and after-commit integration events, with a durable EF Core outbox.
Client events
At-most-once, latest-wins hints that tell browsers when to re-query authoritative state.
Ordered streams
Hot sequenced broadcasts with replay, visible gaps, and resumable SSE delivery.
Coordination & role leases
Elect one instance for a coarse application role and route holder-owned HTTP work to it.
Client connections
Long-lived bidirectional links (device gateways, interactive clients) over a transport-neutral kernel.
Device identity
Pairing codes, per-device keys, and the connect-time HMAC handshake for device gateways.
Data-rate shaping
Batch high-frequency samples to the database and conflate hot values to the UI, latest-wins per key.
Data & persistence
Entity Framework Core
Generated DbSets and entity configuration on your concrete DbContext.
Bulk operations
Non-tracking ExecuteInsertAsync at PostgreSQL binary COPY speed.
Pagination
Transport-neutral keyset and offset paging that produces a Page<T>.
SQL migrations
Startup-applied SQL migrations for EF-free (NativeAOT) hosts, PostgreSQL or SQLite — no repair command, no undo.
SQL mapping
Generated ISqlRowMapper contracts + injection-safe SQL interpolation for EF-free (NativeAOT) hosts.
PostgreSQL extensions
Extensions are composition, not scale-out — one image for TimescaleDB, pgvector & co.
Time series
Telemetry on the PostgreSQL you already run — the TimescaleDB recipe.
Blob storage
Provider-neutral, streaming-first blob contracts with a PostgreSQL implementation.
Blob uploads
Direct and resumable uploads over one staged-upload lifecycle, with tus as the recommended transport.
Operations & governance
Telemetry
OpenTelemetry-compatible traces and metrics through System.Diagnostics — no SDK lock-in.
Audit trail
Durable, explicit action records with outcomes, resource context, correlation ids, and optional diffs.
Runtime settings
Global and per-user settings with optimistic concurrency and cross-node change notification.
Solution structure
Where entities, modules, and schema configuration belong relative to the module-boundary rule — keep entities in a shared-kernel namespace, treat configuration as part of the shared data layer (not feature-owned), and graduate to bounded contexts only when they earn their keep.
Hosting
Wire the module bootstrapper, handler registry, and JSON-RPC endpoint into an ASP.NET Core host.