Contracts

The narrative is in Contracts & adapters; this is the index — each capability, the spec it's keyed by, how a handler reaches it from the ExecutionContext, and the dep key it resolves under. Capabilities with a dedicated reference page are linked (the spec fields, the method surface, and the integrations that implement it).

Read the last column when you are wiring rather than calling: a dep key is what a deps module binds, so it is the name you register a custom provider against and the name a resolution error prints. Handlers should keep to the accessor.

Data & storage¶

Capability	Spec	Resolve via	Dep key
Document (read / write)	`DocumentSpec`	`ctx.document.query(spec)` / `ctx.document.command(spec)`	`DocumentQueryDepKey` / `DocumentCommandDepKey` (+ `DocumentCommandHookDepKey`, which `ctx.deps` applies to one document's command port)
Cache	`CacheSpec`	`ctx.cache(spec)`	`CacheDepKey`
Counter	`CounterSpec`	`ctx.counter(spec)`	`CounterDepKey` (+ `CounterAdminDepKey` for reset / drop)
Object storage	`StorageSpec`	`ctx.storage.query(spec)` / `ctx.storage.command(spec)`	`StorageQueryDepKey` / `StorageCommandDepKey` (+ `StorageUploadSessionDepKey` for presigned uploads)
Graph	`GraphModuleSpec`	`ctx.graph`	`GraphQueryDepKey` / `GraphCommandDepKey` (+ `GraphManagementDepKey`, `GraphRawQueryDepKey`)
Embeddings	`EmbeddingsSpec`	`ctx.embeddings.provider(spec)`	`EmbeddingsProviderDepKey`
Dynamic read	`DynamicReadSpec`	`ctx.dynamic_read.query(spec)`	`DynamicReadDepKey`

Search & analytics¶

Capability	Spec	Resolve via	Dep key
Search (query / index)	`SearchSpec`	`ctx.search.query(spec)` / `ctx.search.command(spec)`	`SearchQueryDepKey` / `SearchCommandDepKey` (+ `SearchManagementDepKey` for index admin)
Federated & hub search	`SearchSpec`	`ctx.search.federated(spec)` / `ctx.search.hub(spec)`	`FederatedSearchQueryDepKey` / `HubSearchQueryDepKey` (+ `SearchResultSnapshotDepKey` for late materialization)
Analytics	`AnalyticsSpec`	`ctx.analytics.query(spec)` (+ ingest)	`AnalyticsQueryDepKey` / `AnalyticsIngestDepKey`
Procedures (command / compute)	`ProcedureSpec`	`ctx.procedure.command(spec)`	`ProcedureCommandDepKey`

Messaging & events¶

Capability	Spec / key	Resolve via	Dep key
Queue (produce / consume)	queue route	by dep key + route	`QueueCommandDepKey` / `QueueQueryDepKey`
Pub/Sub	topic route	by dep key + route	`PubSubCommandDepKey` / `PubSubQueryDepKey`
Stream	stream route	by dep key + route; `ctx.stream.commit_query` / `.commit_admin` for the commit sub-model	`StreamCommandDepKey` / `StreamQueryDepKey` (+ `AckStreamGroupQueryDepKey`, `AckStreamGroupAdminDepKey`, `CommitStreamGroupQueryDepKey`, `CommitStreamGroupAdminDepKey`)
Outbox	`OutboxSpec`	`ctx.outbox.command(spec)` / `ctx.outbox.query(spec)`	`OutboxCommandDepKey` / `OutboxQueryDepKey` (+ `OutboxAdminDepKey` for the relay)
Inbox	`InboxSpec`	`ctx.inbox`	`InboxDepKey`
Domain events	—	`ctx.domain` (dispatch)	`DomainEventDispatcherDepKey`
Saga	`SagaDefinition`	by dep key	`SagaExecutorDepKey`
Realtime egress	`RealtimeEvent` catalog	`build_realtime_publisher(ctx, …)` (wire protocol)	— (composed from the stream and pub/sub keys above)

Reliability & coordination¶

Capability	Spec / key	Resolve via	Dep key
Transactions	tx route	`ctx.transaction(route)` for the manager; `ctx.tx_ctx.scope(route)` for the ambient scope	`TransactionManagerDepKey`
Transaction-scoped lock	tx route	`ctx.tx_locks(route).hold(*keys)`, or `SerializeOperation` on an operation	`TransactionManagerDepKey`: the route's manager hands it out when it implements `TxLockCapable`
Idempotency	`IdempotencySpec`	`ctx.idempotency(spec)`	`IdempotencyDepKey`
Resilience	`ResiliencePolicy`	`ctx.resilience().run(fn, policy=…)`	`ResilienceExecutorDepKey` (+ `ResiliencePortPoliciesDepKey` for per-port defaults, `ResilienceAdminDepKey` for breaker state)
Distributed lock	`DistributedLockSpec`	`ctx.dlock`	`DistributedLockCommandDepKey` / `DistributedLockQueryDepKey`
Fleet membership	`FleetSpec`	`ctx.fleet(spec)`	`FleetDepKey`
Hybrid logical clock	—	by dep key	`HlcCheckpointDepKey`
Sandboxed execution	`SandboxSpec`	`ctx.sandbox.run(spec)`	`SandboxDepKey`

Durable execution¶

Capability	Spec	Resolve via	Dep key
Durable workflows	`DurableWorkflowSpec`	by dep key	`DurableWorkflowCommandDepKey` / `DurableWorkflowQueryDepKey`
Workflow schedules	—	by dep key	`DurableWorkflowScheduleCommandDepKey` / `DurableWorkflowScheduleQueryDepKey`
Durable functions	`DurableFunctionSpec`	by dep key	`DurableFunctionEventCommandDepKey` / `DurableFunctionStepDepKey`
Run & schedule stores, run listing	—	by dep key	`DurableRunStoreDepKey` / `DurableRunAdminDepKey` / `DurableScheduleStoreDepKey`

Identity & access¶

Capability	Spec	Resolve via	Dep key
Authentication	`AuthnSpec`	`ctx.authn`	`AuthnDepKey` (the lifecycle ports it composes are in identity)
Authorization	`AuthzSpec`	`ctx.authz.decision(spec)` / `ctx.authz.scope(spec)`	`AuthzDecisionDepKey` / `AuthzScopeDepKey`
Tenancy	—	`ctx.tenancy`	`TenantResolverDepKey` (+ `TenantManagementDepKey` for provisioning)
Secrets	`SecretRef`	by dep key	`SecretsDepKey` (+ `SecretsAdminDepKey`, `SecretsLeaseDepKey`)
Counterparty-rotated credentials	`SecretRef`	by dep key	`RotatingCredentialsDepKey` (+ `RotatingCredentialsAdminDepKey` for the refresh sweeper)
Field encryption	`FieldEncryption`	declared on a spec; applied by the plane, never called directly	`AeadDepKey` / `DeterministicCipherDepKey` (+ `RequiredReachDepKey` for the tier floor)
Key management	`KeyRef`	by dep key	`KeyringDepKey` / `KeyManagementDepKey` (+ `KeyDirectoryDepKey` for per-tenant key lookup)

Integration¶

Capability	Spec	Resolve via	Dep key
Outbound HTTP	`HttpServiceSpec`	`ctx.http.service(spec)`	`HttpServiceDepKey`
Model inference	`InferenceSpec`	`ctx.inference.model(spec)`	`InferenceDepKey`

A capability whose Resolve via cell reads by dep key has no short ctx.<x> accessor: resolve it through the context's dependency resolution, by the key in the last column and the route it is registered under. Streams are the mixed case — shortcuts exist for the commit sub-model only, and the rest of the family resolves by key.