stitchkit 0.67.0 → 0.68.1

package/llms-full.txt

@@ -51,6 +51,7 @@ own, recorded as an ADR.
 | `stitchkit/server` | server (Bun) | stable | `createServer`, `implement`, hooks, auth, Socket.IO server, server primitives |
 | `stitchkit/node` | server (Node ≥ 22) | stable | `serveNode` + the runtime-agnostic core — the Node mirror of `/server` |
 | `stitchkit/tools` | server | stable | `createMcpHandler`, `mountMcp`, `mountAgent`, the OAuth provider, native tools |
+| `stitchkit/tools/invoker` | server | stable | peer-free `createToolInvoker` over the canonical contract tool runner |
 | `stitchkit/cli` | server | stable | `createCli` — the CLI transport, light (no MCP SDK / `ai`) |
 | `stitchkit/remote` | browser **and** server | stable | peer-free `implementRemote` for thin HTTP proxy processes |
 | `stitchkit/files` | server (Bun or Node) | stable | peer-free managed local-file boundary |
@@ -58,9 +59,9 @@ own, recorded as an ADR.
 | `stitchkit/testing` | tests on Bun or Node | stable | in-process generated clients over a real Fetch handler, plus the store and managed-resource conformance kits |
 | `stitchkit/declaration` | build and deployment tooling (Bun or Node) | evolving | `ProjectDeclarationSchema` — the one machine-readable statement a repository makes about itself |
 | `stitchkit/react` | browser | stable | `createCursorQuery`, `createCacheBridge` |
-| `stitchkit/agent-runtime` | server | evolving<br>_redefined in 9 of the 12 minors since 0.56.2, most recently 0.66.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
+| `stitchkit/agent-runtime` | server | evolving<br>_redefined in 9 of the 13 minors since 0.56.2, most recently 0.66.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
 | `stitchkit/agent-runtime/openrouter` | server | evolving | isolated OpenRouter language-model adapter |
-| `stitchkit/application` | server | evolving<br>_redefined in 3 of the 12 minors since 0.56.2, most recently 0.67.0_ | managed resource graph, readiness, admission, schedules and bounded shutdown |
+| `stitchkit/application` | server | evolving<br>_redefined in 3 of the 13 minors since 0.56.2, most recently 0.67.0_ | managed resource graph, readiness, admission, schedules and bounded shutdown |
 | `stitchkit/application/grammy` | server | evolving | isolated grammY polling and webhook lifecycle adapters |
 | `stitchkit/application/opentelemetry` | server | evolving | maps application snapshots onto an injected OpenTelemetry `Meter` |
 
@@ -159,7 +160,8 @@ map — feature → packages:
 | anything (validation) | `zod` |
 | `createServer` (Bun) | — (uses `Bun.serve`) |
 | `serveNode` (Node ≥ 22) | `srvx` (+ `@types/bun` dev) |
-| MCP / agent tools (`stitchkit/tools`) | `@modelcontextprotocol/server` `ai` |
+| In-process contract tools (`stitchkit/tools/invoker`) | — |
+| MCP / agent adapters (`stitchkit/tools`) | `@modelcontextprotocol/server` `ai` |
 | Agent application runtime (`stitchkit/agent-runtime`) | `ai` |
 | OpenRouter runtime adapter (`stitchkit/agent-runtime/openrouter`) | `ai` `@openrouter/ai-sdk-provider` |
 | MCP host/client tests | `@modelcontextprotocol/client` |
@@ -167,7 +169,7 @@ map — feature → packages:
 | React data layer (`stitchkit/react`) | `@tanstack/react-query` `react-query-kit` |
 | **Socket.IO server on Bun** | `socket.io` `@socket.io/bun-engine` |
 | **Socket.IO server on Node** | `socket.io` |
-| Socket.IO client | `socket.io-client` (brings `@socket.io/component-emitter`, which the browser declarations reference for types only) |
+| Socket.IO client | `socket.io-client` (runtime peer; unrelated root declarations remain peer-free) |
 | grammY lifecycle adapters (`stitchkit/application/grammy`) | `grammy` |
 | OpenTelemetry gauges (`stitchkit/application/opentelemetry`) | `@opentelemetry/api` |
 
@@ -1521,6 +1523,57 @@ focused helper — not a sub-framework.
 | `createCache()` + `cacheHeaders()` | in-memory TTL cache; `Cache-Control` builder |
 | `createEventBus<EventMap>()` | typed in-process pub/sub |
 
+### Contract-first streams
+
+Use an endpoint `stream` descriptor when the item schema and completion belong
+to the contract, rather than handing an application-owned `Response` to
+`rawResponse`:
+
+```ts
+const Item = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('line'), text: z.string() }),
+  z.object({ kind: z.literal('complete'), count: z.number().int() }),
+])
+
+const reports = defineContract({ prefix: 'reports' }, {
+  watch: {
+    method: 'GET', path: '/:id/watch', desc: 'Watch one report',
+    params: z.object({ id: z.string() }),
+    stream: {
+      item: Item,
+      format: 'ndjson',
+      maxFrameBytes: 64 * 1024,
+      terminal: z.object({ kind: z.literal('complete') }).loose(),
+    },
+  },
+})
+
+const service = implement(reports, {
+  watch: async function* ({ params, signal }) {
+    yield { kind: 'line', text: `starting ${params.id}` }
+    if (signal.aborted) return
+    yield { kind: 'complete', count: 1 }
+  },
+})
+```
+
+The handler return is inferred as `AsyncIterable<z.output<typeof Item>>`; an
+invalid JavaScript producer is rejected before its value reaches the wire. Data,
+safe errors and normal end use a framework envelope. The default encoded frame
+limit is 256 KiB. `format` defaults to `ndjson`; `heartbeatMs` defaults to five
+seconds; `idleTimeoutSeconds` defaults to disabled; `lifetimeMs` is optional.
+
+After headers, HTTP status can no longer report failure, so the stream sends a
+normalized code and never the raw internal exception. Normal producer completion
+sends an explicit `end`; when `terminal` is declared, at least one item must
+match it. Request abort and client iterator return abort `signal`, including a
+source waiting in `next()` or suspended at a yielded item.
+
+Contract streams are HTTP-only and cannot declare `output`, `rawResponse`,
+multipart or tool exposure. They do not provide replay, cursors or durable
+subscriptions. Keep using `streamingRoute` for an application-owned protocol and
+`rawResponse` for arbitrary response bodies. → ADR 0117.
+
 ### SSE streaming
 
 `streamSSE` returns a `Response`, so its endpoint declares
@@ -1834,23 +1887,54 @@ your own `(pathname) => boolean`.
 
 ### Unix domain sockets
 
-The same typed client dials a local daemon's socket file
-([server side](server.md#local-daemon-over-a-unix-socket)):
+The same typed client dials a local daemon's socket file through an explicit,
+owned Bun/Node transport ([server side](server.md#local-daemon-over-a-unix-socket)):
 
 ```ts
+import { createHttpClient } from 'stitchkit'
+import { createUnixClientTransport } from 'stitchkit/server' // or stitchkit/node
+
+const transport = createUnixClientTransport({
+  socketPath: '/run/my-daemon.sock',
+  maxRequestBytes: 4 * 1024 * 1024,
+  maxResponseBytes: 16 * 1024 * 1024,
+})
 const http = createHttpClient({
-  baseUrl: 'http://localhost', // required prefix source; its host is ignored
-  unix: '/run/my-daemon.sock',
+  baseUrl: 'http://my-daemon', // URL/Host source; never dialled as TCP
+  fetch: transport.fetch,
+  retry: { limit: 0 },
 })
 const daemon = createClient(daemonContract, http)
+
+// At application shutdown:
+await transport.close()
 ```
 
-`baseUrl` stays required — it supplies the path prefix and the `Host` header,
-while the connection itself goes through the socket file. Bun runtime only:
-other runtimes ignore the option and dial `baseUrl` over TCP (Node's fetch
-would need an undici dispatcher — out of scope). A missing socket file
-surfaces as a normal `ApiError` and is not retried (transport retry stays
-connection-refused-only).
+`baseUrl` stays required because it supplies the URL and `Host` header. The
+adapter structurally owns dispatch: relative and absolute redirects use the same
+socket, and a missing socket cannot fall through to that host over TCP. Defaults
+are 16 MiB request/response bodies, 64 KiB headers, 30 s to response headers,
+eight connections and five redirects.
+
+`maxHeaderBytes` is enforced before exposing a response. Bun's owned parser
+counts the complete response head in wire bytes, including the status line and
+terminating blank line. Node passes the same configured integer unchanged to
+`http.request({ maxHeaderSize })`, so its native parser's documented header-size
+accounting is authoritative there. Exceeding either ceiling yields
+`UNIX_HEADERS_TOO_LARGE` with `delivery: 'response-received'`. A stalled body
+pauses its socket, and resuming preserves the exact chunked body.
+
+`UnixClientTransportError` carries a stable `code` and `delivery`:
+`not-dispatched`, `possibly-dispatched` or `response-received`. Only the first
+proves that the remote operation did not begin; Stitchkit never silently retries
+an ambiguous write. Response consumption/cancellation belongs to the operation,
+and `close()` interrupts active work and destroys owned connections.
+
+The legacy `createHttpClient({ unix: '/absolute/path' })` spelling remains a
+Bun-only convenience. On a non-Bun runtime it now refuses before dispatch
+instead of ignoring the selection and dialing TCP. `unix` and an injected
+`fetch` are mutually exclusive; use `createUnixClientTransport` for portable,
+explicit lifecycle ownership. → ADR 0116.
 
 `trace: true` mints a fresh root trace per request. The stitchkit server
 [continues an inbound `traceparent`](./observability.md#trace-context), so the
@@ -1954,12 +2038,58 @@ Abort and timeout do not emit `network_error` and are not retried. The same
 options work for query, JSON, multipart and raw-response calls. Stitchkit does
 not expose upload progress: Fetch has no portable upload-progress primitive.
 
+An injected transport failure is normalized to `UNKNOWN_ERROR` while its exact
+object remains available as `ApiError.cause`. This is how a bounded adapter can
+preserve facts the generic client cannot invent — for example a Unix transport's
+`not-dispatched`, `possibly-dispatched` or `response-received` state. Never replay
+an effect from `UNKNOWN_ERROR` alone; inspect the owned adapter's cause and retry
+only when it proves that dispatch did not happen.
+
 For an endpoint without contract arguments, pass only the options object:
 
 ```ts
 await api.health.withOptions({ signal: controller.signal })
 ```
 
+### Injected delivery adapters
+
+`ClientFetch` is the narrow composition seam for application-owned delivery.
+The contract still owns operation identity, request serialization and response
+validation; the adapter owns I/O, bounds and dispatch certainty:
+
+```ts
+import { type ClientFetch, createClient } from 'stitchkit'
+
+const delivery: ClientFetch = async (input, init) => {
+  // Fixed deployment destination and policy are chosen here, not by caller data.
+  return boundedFetch(input, { ...init, signal: init?.signal })
+}
+
+const query = createClient(queryContract, {
+  baseUrl: 'https://service.internal',
+  fetch: delivery,
+})
+const work = createClient(requestWorkContract, {
+  baseUrl: 'https://service.internal',
+  fetch: delivery,
+})
+```
+
+The same adapter accepts unrelated contract shapes without learning their DTOs
+or operation inventory. `createClient` chooses method/path from the contract,
+serializes only the declared arguments, forwards `.withOptions(..., { signal })`
+and validates the response through the endpoint's output schema. A caller payload
+cannot replace the configured base URL or reserved operation path.
+
+Contract metadata describes an effect; it does not authorize one. Authentication,
+scope and destination policy remain in the application/server boundary. A schema
+mismatch is an explicit validation failure and is not retried automatically. A
+timeout means the caller stopped waiting, not that the remote effect did not run.
+
+Published declarations are checked from a clean tarball under both bundler and
+NodeNext resolution. The HTTP-only NodeNext proof uses `skipLibCheck: false` and
+installs no Socket.IO peer. → ADR 0120.
+
 ### Many contracts at once
 
 ```ts
@@ -2096,6 +2226,7 @@ try {
     err.details  // structured details, if any
     err.hint     // optional hint
     err.traceId  // x-request-id — correlate this failure with backend logs
+    err.cause    // concrete injected transport failure, when delivery failed
   }
 }
 ```
@@ -2218,6 +2349,41 @@ sends one. The result keeps the full `react-query-kit` surface (`.getKey()`,
 `useSuspenseInfiniteQuery`, every option). The endpoint must return the
 `{ items, nextCursor }` envelope — see [Contracts → pagination](./contracts.md#pagination).
 
+## Contract-first streams
+
+When an endpoint declares `stream`, `createClient` returns a schema-derived
+owned iterator rather than an untyped `Response`:
+
+```ts
+const Progress = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('line'), text: z.string() }),
+  z.object({ kind: z.literal('complete'), count: z.number().int() }),
+])
+
+const contract = defineContract({ prefix: 'reports' }, {
+  watch: {
+    method: 'GET', path: '/:id/watch', desc: 'Watch one report',
+    params: z.object({ id: z.string() }),
+    stream: {
+      item: Progress,
+      format: 'ndjson',                 // default; `sse` is also supported
+      maxFrameBytes: 64 * 1024,         // default 256 KiB
+      terminal: z.object({ kind: z.literal('complete') }).loose(),
+    },
+  },
+})
+
+const stream = await createClient(contract, http).watch({ id: 'r-1' })
+for await (const item of stream) console.log(item) // inferred from Progress
+```
+
+The iterator validates every frame and item. Normal completion requires the
+wire `end` frame and, when declared, at least one matching terminal item; EOF is
+`STREAM_TRUNCATED`, and a missing terminal is `STREAM_TERMINAL_MISSING`.
+`return()`/`break`, caller abort, producer failure and optional `lifetimeMs`
+converge on the request operation. See the
+[server half](./server.md#contract-first-streams). → ADR 0117.
+
 ## SSE
 
 For a streaming endpoint, consume the response with `parseSSE`:
@@ -2233,7 +2399,9 @@ for await (const event of parseSSE(res)) {
 
 The server side is [`streamSSE`](./server.md#sse-streaming), or
 [`sseRoute`](./server.md#long-lived-subscriptions) for a subscription that stays
-open.
+open. One line is bounded by `maxLineBytes` (default 1 MiB), UTF-8 is decoded
+strictly and malformed input throws. Supply `onParseError` only when
+skip-and-report is an explicit application policy.
 
 ## NDJSON
 
@@ -2265,8 +2433,9 @@ convenience: a long-lived stream must send something while it is idle or
 intermediaries drop it, and an empty line is the natural pulse for this framing.
 Writing the rule down on both sides is what stops it being a verbal agreement —
 the server's keep-alive and the reader's skip are one decision with two
-implementations. A frame that is not valid JSON goes to `onParseError` rather
-than throwing, so one bad line does not end the subscription.
+implementations. One line is bounded by `maxLineBytes` (default 1 MiB), UTF-8 is
+decoded strictly and malformed input throws. Passing `onParseError` explicitly
+selects tolerant skip-and-report behaviour.
 
 
 ==============================================================================
@@ -2356,7 +2525,7 @@ AI SDK `ToolSet` and call its transport adapter manually. Compile an in-process
 invoker once and call the shared framework runner directly:
 
 ```ts
-import { createToolInvoker } from 'stitchkit/tools'
+import { createToolInvoker } from 'stitchkit/tools/invoker'
 
 const invoker = createToolInvoker(services, {
   transport: 'AGENT',       // required exposure policy
@@ -2385,6 +2554,11 @@ recursive calls without retaining request state. Every invocation gets a fresh
 tool-call context and runs the same extension resolution, input/output
 validation, lifecycle, hooks and output-strip reporter as mounted tools.
 
+The dedicated entrypoint needs only the normal `stitchkit`/`zod` install. Use
+the broader `stitchkit/tools` barrel when the same program also mounts MCP or AI
+adapters and has installed their optional peers. Both imports reach the same
+runner; this is dependency isolation, not a second execution implementation.
+
 `invoke` returns the canonical discriminated `ToolResult`, not an AI SDK or MCP
 presentation envelope. `invokeOrThrow` returns validated data and throws the
 runner's normalized `AppError` on failure, preserving an application error's
@@ -3660,6 +3834,14 @@ const store = createAgentRuntimeStore({
 })
 ```
 
+Prompt budgeting keeps reservation deficits signed. If instructions,
+`reservedOutput`, tool schemas, attachments and provider overhead already exceed
+`contextWindow`, `composeAgentPrompt` returns `contextDecision: 'oversized'`
+and a negative `availableHistoryTokens` even when history is empty. A `compact`
+policy is returned only when removing history could actually make the prompt
+fit. Exact equality (including a zero window with zero reservations/history)
+fits; any unavailable component keeps the decision `unavailable`.
+
 The same opaque `tx` reaches head, run, admission and history callbacks. The adapter maps rows
 and supplies atomicity; Stitchkit owns transition validation and revision
 arithmetic. The executable reference is
@@ -3987,6 +4169,24 @@ is the reserved built-in policy name. `loop.prepareStep` is the controlled AI
 SDK step boundary for changing active tools, model, instructions or messages.
 It cannot replace the managed tool set or bypass its lifecycle fence.
 
+Completion validity belongs to the protocol and is checked before the terminal
+CAS. Protocols that require a visible answer opt in explicitly:
+
+```ts
+const protocol = defineAgentProtocol({
+  context: ContextSchema,
+  inputMetadata: InputMetadataSchema,
+  terminalAcceptance: 'require-output',
+})
+```
+
+The built-in rule accepts non-blank text, generated files, structured provider
+parts, and a named tool-only `policy_stop`. The default is `allow-empty` for
+protocols where an empty acknowledgement is meaningful. Pass a callback when
+the product has a narrower definition; it receives the candidate message,
+terminal reason and optional policy name, and runs before persistence. A false
+result fails the candidate instead of rewriting an already committed success.
+
 `loop.idleTimeoutMs` is inactivity, not total duration: the deadline resets on
 every model stream event. A stalled call aborts with durable reason `timeout`;
 user interruption and shutdown remain distinct.
@@ -4009,7 +4209,10 @@ effect must be replay-safe.
 ## History, provider metadata and files
 
 `projectAgentHistory` converts canonical engine records into provider-valid AI
-SDK messages and pairs tool calls/results. Provider-required metadata is kept
+SDK messages and pairs tool calls/results in persisted causal order. Adjacent
+parallel calls stay in one assistant round and their adjacent results stay in
+one tool round; a dependent call after those results starts a new assistant
+round, and trailing final text remains after the last tool result. Provider-required metadata is kept
 in a versioned opaque envelope and omitted from product delivery by default.
 `projectAgentHistoryDetailed` additionally returns one inspectable decision per canonical record;
 leading assistant records, crash drafts and unmatched tool chronology are never silently passed to
@@ -4246,10 +4449,12 @@ const cleanup = createManagedSchedule({
 const http = managedServerResource({
   id: 'http',
   dependsOn: [database],
-  // Called during `start`, after `database` is ready — which is how "bind the
-  // port once the database is up" is expressed. Pass an already-running server
-  // instead when the application created it itself.
-  server: () => createServer({ port: env.PORT, services }),
+  // Called during `start`, after `database` is ready. The factory receives the
+  // same declared-dependency and startup-signal context as any resource.
+  server: (context) => {
+    const db = context.use(database)
+    return createServer({ port: env.PORT, services: createServices(db) })
+  },
 })
 
 const app = createApplication({
@@ -4337,6 +4542,12 @@ Declare the dependency with the **resource**, not its id, whenever you intend to
 read from it: that is the form `use` can type, and it keeps the declaration and
 the read from drifting apart. A string still works when all you need is order.
 
+`managedServerResource` follows the same rule. Its factory receives this context
+during `start`, so constructing routes from a database/service/socket value does
+not need an outer mutable handoff or a custom `start` override. A zero-argument
+factory remains valid when it needs only ordering, and an already-running handle
+can still be passed directly. → ADR 0121.
+
 The value is published when `start` resolves and stays readable for the rest of
 the application's life — from `activate` and from the shutdown phases too, where
 a dependant may still need the handle it was given.
@@ -4530,6 +4741,69 @@ try {
 `release()` is idempotent. Admission and counter increment are atomic, so work
 cannot slip between the shutdown check and drain accounting.
 
+### Bounded operation admission
+
+Compose `createBoundedAdmission` when accepted work also competes for a finite
+process-local resource:
+
+```ts
+const generations = createBoundedAdmission({
+  upstream: app.admission,
+  policy: {
+    global: { maxConcurrent: 8, rate: { limit: 120, intervalMs: 60_000 } },
+    perKey: { maxConcurrent: 1, maxKeys: 2_000 },
+  },
+})
+
+await generations.run(accountId, ({ signal }) => generate({ signal }), {
+  signal: request.signal,
+  timeoutMs: 30_000,
+})
+```
+
+Acquisition is no-queue and atomic across every configured budget. Refusal names
+the exact bound; only a rate refusal carries `retryAfterMs`. `maxKeys` keeps the
+per-key registry finite, and expired idle entries are retired.
+
+The caller timeout is a wait budget, not proof that the resource stopped. It
+aborts the signal and settles the caller, but the lease remains active until the
+underlying Promise actually settles. `drain()` therefore reports real work;
+`force()` closes admission and reports remaining work without claiming to have
+terminated it. → ADR 0118.
+
+### Bounded delivery and byte credit
+
+`createBoundedChannel` is for one asynchronous reader when an event bus is not a
+queue:
+
+```ts
+const output = createBoundedChannel<string>({
+  policy: 'ordered',
+  maxItems: 64,
+  maxBytes: 256 * 1024,
+  sizeOf: (value) => new TextEncoder().encode(value).byteLength,
+})
+
+const progress = createBoundedChannel<{ revision: number }>({
+  policy: 'latest',
+  maxItems: 1,
+  maxBytes: 128,
+  sizeOf: () => 128,
+})
+```
+
+`ordered` never overwrites accepted values; overflow is a reasoned refusal.
+`latest` retains exactly one pending replaceable value and reports
+`coalesced`. Offers never create a hidden writer queue, and only one `next()` may
+wait. Close chooses `drain` (default) or `discard`; abort discards; failure
+rejects the parked and all later reads.
+
+`createCreditWindow({ capacityBytes })` is the smaller primitive for a protocol
+that already owns its queue but needs exact byte permission. Each credit lease
+replenishes once; it is flow-control credit, not a durable acknowledgement. The
+application snapshot sink now shares the same latest-value mechanics without
+changing its revision or status contract. → ADR 0119.
+
 Shutdown performs one phase barrier at a time: stop admission everywhere,
 cancel future schedules, drain admitted work, then close in reverse stable
 topological order. Every hook shares the same grace deadline. Forced cleanup
@@ -4804,6 +5078,56 @@ asynchronous subscriber callback racing cleanup: publish `getSnapshot()` before
 closing the outer sink, so any older or duplicate late delivery is rejected as
 stale instead of dropping the final state.
 
+## Bound a handler and a local worker with one lease policy
+
+Use a bounded admission when two entry paths consume the same finite local
+capacity. Composing it with `application.admission` keeps readiness and shutdown
+as the upstream gate:
+
+```ts
+const work = createBoundedAdmission({
+  upstream: app.admission,
+  policy: {
+    global: { maxConcurrent: 4 },
+    perKey: { maxConcurrent: 1, maxKeys: 1_000 },
+  },
+})
+
+const fromHttp = (key: string, signal: AbortSignal) =>
+  work.run(key, (context) => render(context.signal), { signal, timeoutMs: 20_000 })
+
+const fromWorker = (key: string) =>
+  work.run(key, (context) => reconcile(context.signal))
+```
+
+A timeout in `fromHttp` does not free a permit while `render` remains active.
+At shutdown call `work.stopAdmission()` with the other admission owners and
+await `work.drain(...)`; the result reports the actual remainder.
+
+## Replace ad-hoc output and progress queues
+
+Ordered output and replaceable progress are separate declarations:
+
+```ts
+const lines = createBoundedChannel<string>({
+  policy: 'ordered', maxItems: 100, maxBytes: 1_000_000,
+  sizeOf: (line) => new TextEncoder().encode(line).byteLength,
+})
+
+const state = createBoundedChannel<{ revision: number; percent: number }>({
+  policy: 'latest', maxItems: 1, maxBytes: 64,
+  sizeOf: () => 64,
+})
+
+const lineResult = lines.offer('one durable-in-process ordering unit')
+const stateResult = state.offer({ revision: 2, percent: 50 })
+```
+
+Handle `refused` from `lines` at the protocol boundary; do not turn it into
+implicit loss. A `coalesced` state result is expected latest-value behaviour,
+not evidence that an ordered event was delivered. Neither channel is durable;
+persist first when restart replay is required.
+
 ## Handing a handle to the resources that depend on it
 
 `dependsOn` carries ordering. To carry the object as well, return a `value` from
@@ -4846,7 +5170,10 @@ already-listening server and it adopts that one instead.
 const http = managedServerResource({
   id: 'http',
   dependsOn: [database],
-  server: () => createServer({ port: env.PORT, services }),
+  server: (context) => {
+    const db = context.use(database)
+    return createServer({ port: env.PORT, services: createServices(db) })
+  },
 })
 
 const app = createApplication({ id: 'service', resources: [database, http] })
@@ -4857,6 +5184,11 @@ The server resource publishes its `ManagedServerHandle`, so anything that needs
 the running server — a Socket.IO attachment, a URL to log, a probe — reads it
 with `context.use(http)` rather than through a module-local.
 
+The factory itself receives `ManagedResourceContext` too. It can read only the
+dependencies declared on the server resource and shares the graph's startup
+signal. A dependency failure prevents the factory from binding; a factory
+rejection is rolled back without invoking the factory a second time.
+
 Do not spread this resource over your own `start` to control creation order:
 that shape exists only as a workaround for the version whose `start` was empty,
 and `dependsOn` now expresses the order directly. The executable recipe binds a
@@ -5770,6 +6102,36 @@ page metadata and `pageParams`; an infinite create changes only the selected
 edge page (`createAt: 'start' | 'end'`). Creates are deduplicated across every
 cached page. `updateMissing` makes an absent update explicitly skip or insert.
 
+Filtered query families can additionally declare membership per exact key and
+evidence-aware total reconciliation:
+
+```ts
+list: {
+  key: ['tickets'],
+  shape: 'infinite-paginated',
+  createAt: 'start',
+  updateMissing: 'skip',
+  membership: {
+    evaluate: (event, queryKey) => membershipFor(event, queryKey),
+    unknown: 'invalidate',
+  },
+  total: {
+    mode: 'reconcile',
+    unknown: 'invalidate',
+    delta: ({ event, present, membership }) => provenDelta(event, present, membership),
+  },
+}
+```
+
+Membership is `include | exclude | unknown`. An excluded update removes an
+existing row; an included one follows `updateMissing`. Unknown evidence never
+guesses and either preserves or invalidates the exact query. The conservative
+total policy increments only a non-duplicate create and decrements only a
+delete/update whose membership is observed; unseen IDs are `unknown`. Supply
+`delta` only when the event itself proves a stronger transition. Every page's
+numeric `total` changes together while cursor metadata and `pageParams` remain
+unchanged.
+
 The event entity may be richer than a list row. Keep the full value in detail
 cache, project it for lists, and provide the same comparator the backend uses:
 
@@ -5807,9 +6169,9 @@ deleted payload without guessing. The same resolved detail key drives the
 `isFresh` echo guard. Shape checks also leave neighbouring detail caches alone
 when a list key is intentionally used as a partial query-key prefix.
 
-The helper deliberately does **not** flatten pages, update totals, derive a
-sort order or replace arbitrary `setQueryData` logic. Those are application
-policies; this helper only applies declared CRUD semantics.
+The helper deliberately does **not** flatten pages, infer filter semantics,
+derive a sort order or replace arbitrary `setQueryData` logic. Those remain
+declared application policies; Stitchkit applies their generic cache mechanics.
 
 ## Raw binary lane (Bun)
 
@@ -7418,6 +7780,11 @@ runtime or type-only package outside a case's budget fails with both the case id
 and package name, so an accidental eager import cannot hide behind another
 fixture's transitive dependency.
 
+That includes `stitchkit/tools/invoker`: a minimal packed consumer imports it
+without MCP/AI peers and executes validation, output projection and normalized
+errors on Bun and Node. The broader `stitchkit/tools` barrel deliberately keeps
+the adapter peer budget.
+
 Beside the matrix, one case is about the ARTIFACT rather than the inventory: a
 program that injects the Socket.IO peer loaders is bundled and started in a
 directory with no `node_modules`, under Node and under Bun with auto-install
@@ -7449,6 +7816,11 @@ const socket = await createSocketIOServer({
 })
 ```
 
+The packed Next/Webpack gate compiles the browser
+`peers.client: () => import('socket.io-client')` loader and rejects Webpack's
+"request is an expression" warning. Stitchkit's runtime fallback remains lazy;
+its emitted import carries a count-checked ignore directive.
+
 Omit `peers` and nothing changes: the peers stay lazy and are resolved from the
 machine. Both peers must be listed as dependencies of the package you bundle,
 because they now genuinely are.
@@ -8038,6 +8410,56 @@ implement `AgentRuntimeStoreDriver` and compose the aggregate with
    runtime): bootstrap the server, one HTTP request, and any feature you rely on
    (Socket.IO connect, an MCP tool call, a multipart upload, …).
 
+## Released migration: 0.68.0
+
+### Make Unix transport selection explicit outside Bun
+
+The legacy `unix` option remains a Bun convenience, but on Node or another
+runtime it now fails before dispatch. Replace it with the owned adapter and close
+that adapter with the application:
+
+```ts
+// before — unsafe outside Bun: an unsupported fetch could dial baseUrl over TCP
+const http = createHttpClient({ baseUrl, unix: '/run/service.sock' })
+
+// after — Bun and Node; every dispatch and redirect stays on the socket
+import { createUnixClientTransport } from 'stitchkit/server' // or stitchkit/node
+const transport = createUnixClientTransport({ socketPath: '/run/service.sock' })
+const http = createHttpClient({ baseUrl, fetch: transport.fetch })
+// during shutdown
+await transport.close()
+```
+
+Do not automatically replay `possibly-dispatched`: a timeout or connection loss
+after bytes left the process does not prove that a write did not happen.
+
+### Choose tolerant stream parsing explicitly
+
+`parseNDJSON` and `parseSSE` now throw on malformed JSON, invalid UTF-8 and an
+over-limit line. The default line ceiling is 1 MiB. If a feed deliberately skips
+bad records, retain that policy explicitly:
+
+```ts
+// before — malformed input disappeared implicitly
+parseNDJSON(response)
+
+// after — ordinary fail-closed path
+parseNDJSON(response, { maxLineBytes: 256 * 1024 })
+
+// after — deliberately tolerant path
+parseNDJSON(response, { onParseError: (raw, error) => report(raw, error) })
+```
+
+### Extend exhaustive framework-error handling
+
+If a switch makes `StitchErrorCode` exhaustive, add
+`STREAM_ITEM_INVALID`, `STREAM_FRAME_TOO_LARGE`,
+`STREAM_TERMINAL_MISSING` and `STREAM_LIFETIME_EXCEEDED`. A partial application
+status map needs no change (ADR 0105).
+
+The admission/channel APIs and endpoint `stream` descriptor are additive; raw
+responses and raw `streamingRoute` remain supported.
+
 ## Released migration: 0.67.0
 
 Three application-kernel changes. Two of them fix silent failures, so the most
@@ -10431,16 +10853,16 @@ The browser-and-server entrypoint. Re-exports everything from
 | `createUrlBuilders` | function | build one exact URL builder per contract in a registry |
 | `UrlBuilderConfig` | _type_ | explicit `{ baseUrl }` source for a URL builder |
 | `ClientConfig` | _type_ | config for `createClient`'s bare-fetch mode (2nd arg, no `HttpClient`) |
-| `ClientFetch` | _type_ | injectable Fetch-compatible transport used by framework testing adapters |
+| `ClientFetch` | _type_ | injectable Fetch-compatible transport used by framework and application-owned adapters |
 | `ClientRequestOptions` | _type_ | per-call `{ signal?: AbortSignal }` passed through an endpoint callable's `.withOptions(...)`; caller abort is distinct from timeout — [guide](../guide/client.md#per-call-cancellation) |
 | `ContractClientConfig` | _type_ | per-tenant / resource-scoped client config — dynamic `pathPrefix` + `stripPrefixKeys` ([guide](../guide/client.md#contractclientconfig--per-tenant--resource-scoped-clients)) |
 | `contractEndpointMatchers` | function | compile exact pathname matchers for selected HTTP contract operations and expected-401 policy |
 | `PathPrefixArgs` | _type_ | required string-valued keys exposed to a typed dynamic `pathPrefix` callback |
 | `createHttpClient` | function | the Ky-based HTTP transport; on Next.js SSR its first attempt stays request-memoizable while every retry is a distinct transport attempt — [guide](../guide/client.md#createhttpclient) |
-| `ApiError` | class | a non-2xx response, with `code` / `status` / `details` / `hint` and optional readonly `traceId` from `x-request-id` |
+| `ApiError` | class | a non-2xx or client failure, with `code` / `status` / `details` / `hint`, optional readonly `traceId` from `x-request-id`, and standard `cause` preserving an injected transport failure |
 | `HttpClient` | _type_ | the transport interface `createClient` builds on |
 | `ConfiguredHttpClient` | _type_ | a framework-created `HttpClient` carrying its readonly `baseUrl` for URL builders |
-| `HttpClientConfig` | _type_ | config for `createHttpClient`; retry `limit` counts retries after the initial attempt (default 2 = at most 3 GET attempts), with `statusCodes: []` by default; `unix` dials a unix domain socket (Bun only) — [details](../guide/client.md#createhttpclient) |
+| `HttpClientConfig` | _type_ | config for `createHttpClient`; retry `limit` counts retries after the initial attempt (default 2 = at most 3 GET attempts), with `statusCodes: []` by default; `fetch` installs an explicit transport and is mutually exclusive with the legacy Bun-only `unix` option — [details](../guide/client.md#createhttpclient) |
 | `UnauthorizedMatcher` | _type_ | exact `(pathname) => boolean` policy accepted by `suppressUnauthorizedFor` |
 | `RequestOptions` | _type_ | per-call options — params, timeout, response type |
 | `HeaderProvider` | _type_ | static or per-request headers |
@@ -10458,6 +10880,8 @@ The browser-and-server entrypoint. Re-exports everything from
 | `createRetainedTopics` | function | retained last-value store for sticky events — [guide](../guide/realtime.md#sticky-events) |
 | `parseSSE` | function | parse an SSE `Response` into an async generator — [guide](../guide/client.md#sse) |
 | `parseNDJSON` | function | parse an NDJSON `Response`; blank keep-alive lines are skipped — [guide](../guide/client.md#ndjson) |
+| `ContractStreamFrameSchema` / `ContractStreamFrame` | schema / _type_ | internal-on-the-wire `data` / safe `error` / `end` envelope of a contract-first stream |
+| `DEFAULT_CONTRACT_STREAM_FRAME_BYTES` | const | default maximum encoded contract-stream frame: 256 KiB |
 | `SocketIOClient` | _type_ | low-level client handle; `emit` reports disconnected drops and `emitWithAck` exposes the native Promise primitive used by validated `request()` |
 | `SocketIOClientPeerLoaders` | _type_ | inject `socket.io-client` so a bundler can put it in a self-contained artifact |
 | `SocketIOClientConfig` | _type_ | config for `createSocketIOClient` (incl. `retain`, `onConnectError`, `onDroppedEmit`) |
@@ -10533,6 +10957,7 @@ from the root `stitchkit`.
 | `ContractDef` | _type_ | a defined contract |
 | `ContractMeta` | _type_ | a contract's `prefix` + optional `scope` and `meta` (a default every endpoint shallow-merges over) |
 | `EndpointDef` | _type_ | a single endpoint definition; `output` declares JSON response presence (`null` is data, `undefined` is invalid) |
+| `EndpointStreamDescriptor` | _type_ | HTTP-only schema-derived stream declaration: item schema, NDJSON/SSE framing, frame/lifetime/heartbeat/idle bounds and optional terminal predicate — [guide](../guide/server.md#contract-first-streams) |
 | `HeadEndpointDef` | _type_ | explicit HTTP-only, bodyless `HEAD` endpoint definition |
 | `EndpointResponseMeta` | _type_ | static success metadata declared by an HTTP-only typed-data endpoint |
 | `ResponseMetadata` | _type_ | per-request outbound collector exposed as `ctx.response` only for a `responseMeta` endpoint |
@@ -10791,6 +11216,12 @@ Also re-exports the error helpers from `stitchkit/contract`.
 | `StreamingRouteOptions` | _type_ | options for `streamingRoute` / `ndjsonRoute` / `sseRoute` |
 | `StreamingSourceContext` | _type_ | what a streaming source is given, including the cancellation `signal` |
 | `StreamingFormat` | _type_ | `'ndjson' \| 'sse'` |
+| `createUnixClientTransport` | function | owned Fetch-compatible Unix-socket transport on Bun and Node; every redirect stays on the socket — [guide](../guide/client.md#unix-domain-sockets) |
+| `UnixClientTransportConfig` | _type_ | absolute socket path plus request/response/header/connection/redirect bounds |
+| `UnixClientTransport` | _type_ | `{ fetch, closed, close() }`; `close()` settles owned active work |
+| `UnixClientTransportError` | class | stable transport failure with `code` and dispatch certainty in `delivery` |
+| `UnixClientTransportErrorCode` | _type_ | finite Unix transport failure-code union |
+| `UnixClientDeliveryState` | _type_ | `not-dispatched \| possibly-dispatched \| response-received`; input to application retry policy, never an implicit retry |
 
 ### OpenAPI
 
@@ -10835,11 +11266,44 @@ cutovers are covered by the executable
 | `ManagedResourceDependency` | _type_ | a dependency named by id or given as the resource itself — the second form is what `context.use(...)` can type |
 | `ManagedResourcePublished` | _type_ | the value type `context.use(resource)` returns, recovered from that resource's own `start` |
 | `ManagedResourcePublishesNoValue` | _type_ | what `context.use(...)` returns for a resource that publishes nothing — a branded refusal rather than `never`, so reading it does not silently compile |
-| `ManagedServerResourceConfig` | _type_ | the server or a thunk that makes one, stable ID, dependencies and policy for `managedServerResource` |
+| `ManagedServerResourceConfig` | _type_ | the server or a sync/async factory receiving `ManagedResourceContext`, plus stable ID, dependencies and shutdown policy for `managedServerResource` |
 | `ManagedServerResource` | _type_ | the resource `managedServerResource` returns, whose `start` publishes the `ManagedServerHandle` |
 | `ApplicationHealthHandlerOptions` / `ApplicationHealthHandlerOptionsSchema` | _type_ / schema | liveness/readiness selection and sanitized `Retry-After` policy |
 | `ApplicationOperationalHandlers` / `ApplicationOperationalHandlersOptions` / `ApplicationOperationalHandlersOptionsSchema` | _type_ / schema | conventional status/readiness/liveness route surface and shared retry policy |
 
+### Bounded admission
+
+| Export | Kind | Summary |
+|--------|------|---------|
+| `createBoundedAdmission` | function | process-local no-queue global/per-key concurrency and rate leases, optionally composed with application admission |
+| `BoundedAdmissionPolicySchema` / `BoundedAdmissionPolicy` | schema / _type_ | finite global budget and optional finite per-key budget with `maxKeys` |
+| `BoundedRateBudgetSchema` / `BoundedRateBudget` | schema / _type_ | `{ limit, intervalMs }` monotonic sliding-window budget |
+| `BoundedAdmissionStateSchema` / `BoundedAdmissionState` | schema / _type_ | `accepting \| draining \| closed` |
+| `BoundedAdmissionRefusalReasonSchema` / `BoundedAdmissionRefusalReason` | schema / _type_ | exact local/upstream refusal vocabulary |
+| `BoundedAdmissionSnapshotSchema` / `BoundedAdmissionSnapshot` | schema / _type_ | absolute active/lifetime/refusal/rate-accounting counters |
+| `BoundedAdmission` / `BoundedAdmissionConfig` / `BoundedAdmissionClock` | _type_ | handle, policy/upstream/clock configuration and monotonic clock seam |
+| `BoundedAdmissionResult` / `BoundedAdmissionLeaseResult` / `BoundedAdmissionRefusedResult` | _type_ | explicit leased-or-refused acquisition result; retry time exists only for rate bounds |
+| `BoundedOperationLease` | _type_ | idempotent release lease, optionally carrying its key |
+| `BoundedOperationRunContext` / `BoundedOperationRunOptions` | _type_ | underlying work signal and caller abort/timeout wait budget |
+| `BoundedAdmissionDrainOptions` / `BoundedAdmissionDrainResult` / `BoundedAdmissionForceResult` | _type_ | bounded drain inputs and honest remaining-work results |
+| `BoundedAdmissionRefusalError` | class | `run()` refusal with reason and optional `retryAfterMs` |
+| `BoundedOperationWaitError` | class | caller wait ended as `cancelled` or `timed-out`; underlying capacity remains leased until work settles |
+
+### Bounded delivery
+
+| Export | Kind | Summary |
+|--------|------|---------|
+| `createBoundedChannel` | function | finite single-reader async channel with explicit ordered or latest-value policy |
+| `BoundedChannelPolicySchema` / `BoundedChannelPolicy` | schema / _type_ | `ordered \| latest` retention policy |
+| `BoundedChannelStateSchema` / `BoundedChannelState` | schema / _type_ | `open \| draining \| closed \| failed` |
+| `BoundedChannelSnapshotSchema` / `BoundedChannelSnapshot` | schema / _type_ | exact retained count/bytes, waiter and outcome counters |
+| `BoundedChannel` / `BoundedChannelConfig` / `BoundedChannelCloseOptions` | _type_ | iterator/offer handle, explicit count/byte/size policy and drain/discard close mode |
+| `BoundedChannelOfferResult` | _type_ | `delivered`, `queued`, `coalesced`, or reasoned `refused` outcome |
+| `BoundedChannelReaderError` | class | refusal of a second concurrent pending `next()` |
+| `createCreditWindow` | function | finite byte-credit lease window with exact once-only replenishment |
+| `CreditWindow` / `CreditWindowSnapshot` / `CreditWindowSnapshotSchema` | _type_ / schema | byte-credit handle and absolute accounting record |
+| `CreditAcquireResult` / `CreditLease` | _type_ | reasoned refusal or idempotently releasable byte-credit lease |
+
 ### Managed schedules
 
 | Export | Kind | Summary |
@@ -10930,7 +11394,8 @@ Server-only optional application runtime. See the
 | Export | Kind | Summary |
 |--------|------|---------|
 | `createAgentRuntime` | function | compose durable acceptance, stream loop, checkpoints, coordination, managed tools and winner-only terminal publication; reconciles same-owner terminal/interrupt/head CAS races before releasing the lane |
-| `defineAgentProtocol` | function | declare and validate context, input metadata and canonical message parts |
+| `defineAgentProtocol` | function | declare context, input metadata, canonical parts and optional pre-CAS terminal acceptance (`allow-empty`, `require-output` or callback) |
+| `hasAgentTerminalOutput` | function | generic `require-output` predicate for non-blank text, generated files, structured provider parts and explicit tool-only policy stops |
 | `AgentMessageSchema` / `AgentRunSchema` / `AgentSnapshotSchema` | schema | versioned canonical engine records |
 | `AgentRuntimeStore` | _type_ | aggregate CAS transaction boundary for message, run and compaction mutations |
 | `createAgentRuntimeStore` | function | build the aggregate store from one coherent transaction driver; framework owns every state transition |
@@ -10943,7 +11408,7 @@ Server-only optional application runtime. See the
 | `createMemoryAgentRuntimeStore` | function | process-local reference adapter, not production durability |
 | `projectAgentHistory` | function | asynchronously project canonical records and resolved multimodal files into provider-valid AI SDK messages |
 | `defineModelRegistry` | function | typed language-model descriptors, capabilities and provider construction |
-| `composeAgentPrompt` | function | ordered prompt contributions and provenance-aware context budget |
+| `composeAgentPrompt` | function | ordered prompt contributions and provenance-aware signed context budget; irreducible reservation deficits are `oversized`, not compactable history |
 | `structuredCompaction` | function | summarize a provider-valid snapshot range and replace it through CAS |
 | `createAgentSessionCoordinator` | function | strict process-local queue/interrupt/supersede lifecycle |
 | `AgentRuntimeStopPolicy` | _type_ | named custom AI SDK stop condition persisted and published on policy stop |
@@ -10972,7 +11437,8 @@ transport adapters validate the same records. Runtime composition types are `Age
 `AgentSessionCoordinator`, `AgentCompactionContext`, `AgentCompactionResult` and
 `StructuredCompactionConfig`.
 
-Canonical protocol exports are `AgentProtocol`, `AgentProtocolConfig`, `AgentRecordIdSchema`, `AgentRecordVersionSchema`,
+Canonical protocol exports are `AgentProtocol`, `AgentProtocolConfig`, `AgentTerminalAcceptance`,
+`AgentTerminalAcceptanceInput`, `hasAgentTerminalOutput`, `AgentRecordIdSchema`, `AgentRecordVersionSchema`,
 `AgentTimestampSchema`, `AgentJsonObjectSchema`, `AgentProviderEnvelopeSchema`,
 `AgentProviderEnvelope`, `AgentMessagePartSchema`, `AgentMessagePart`, `AgentTextPartSchema`,
 `AgentReasoningPartSchema`, `AgentFilePartSchema`, `AgentSourcePartSchema`,
@@ -11168,7 +11634,7 @@ payload.
 | `mountAgent` | function | a Vercel AI SDK `ToolSet` from a service — [guide](../guide/mcp-and-agents.md#ai-agents--mountagent) |
 | `defineRuntimeTool` | function | define one validated pathless operation for explicit MCP, Agent and/or CLI surfaces — [guide](../guide/mcp-and-agents.md#pathless-runtime-tools-and-multimodal-results) |
 | `createRuntimeToolFactory` | function | bind shared identity and Zod-validated per-call context for runtime tools — [guide](../guide/mcp-and-agents.md#pathless-runtime-tools-and-multimodal-results) |
-| `createToolInvoker` | function | compile an exposure-aware in-process dispatcher over the canonical tool runner — [guide](../guide/mcp-and-agents.md#in-process-calls--createtoolinvoker) |
+| `createToolInvoker` | function | compile an exposure-aware in-process dispatcher over the canonical tool runner; use peer-free `stitchkit/tools/invoker`, or the full `stitchkit/tools` adapter barrel — [guide](../guide/mcp-and-agents.md#in-process-calls--createtoolinvoker) |
 | `createCli` | function | a command-line program from contracts — [guide](../guide/cli.md) (also on `stitchkit/cli`) |
 | `defineCliCommand` | function | define one typed CLI-only command with optional post-validation `present` and successful `exitCode` policy — [guide](../guide/cli.md#native-binary-commands) (also on `stitchkit/cli`) |
 | `createToolkit` | function | context-typed tool mounts — [guide](../guide/cli.md#typed-context) |
@@ -11556,6 +12022,7 @@ runtime-agnostic pieces of `stitchkit/server` and the error helpers.
 | `serveNode` | function | build the router and start a Node HTTP server (via `srvx`) |
 | `createHandler` | function | the router as a bare `(req) => Response` (same as `/server`) |
 | `createSocketIOServer` | function | the typed Node Socket.IO server (`io` + `attach`; no Bun engine declarations) |
+| `createUnixClientTransport` | function | the same fail-closed Bun/Node Unix client adapter exported by `stitchkit/server` |
 | `implement` / `createImplement` / `createScopedImplement` / `createScopedImplementRegistry` / `createMultipartStream` | function | bind a contract to typed handlers, optionally typed per endpoint scope (same as `/server`) |
 | `NodeServerConfig` | _type_ | config for `serveNode` |
 | `NodeServerHandle` | _type_ | managed Node handle (`url`, `port`, `runtime`, `status`, `shutdown`) |
@@ -11563,6 +12030,8 @@ runtime-agnostic pieces of `stitchkit/server` and the error helpers.
 | `NodeSocketLifecycle` | _type_ | Bun-free Socket.IO lifecycle accepted by `serveNode` |
 | `HandlerConfig` / `ServiceDef` / `RawRoute` / `RawRouteContext` | _type_ | runtime-neutral handler types; raw routes default their host server to `unknown` |
 | `SocketIORequestPolicy` / `SocketIOServerConfig` / `SocketIOPeerLoaders` / `SocketIOServerHandle` | _type_ | runtime-neutral handshake policy, config, optional-peer loaders and the Bun-free Node handle with `io`, `attach` and lifecycle |
+| `UnixClientTransportConfig` / `UnixClientTransport` | _type_ | Unix socket bounds and owned Fetch-compatible handle |
+| `UnixClientTransportError` / `UnixClientTransportErrorCode` / `UnixClientDeliveryState` | class / _type_ | stable failure plus dispatch certainty; no cross-transport fallback |
 | `AppError` + `appError` / `badRequest` / `unauthorized` / `forbidden` / `notFound` / `conflict` / `rateLimited` | — | error helpers (same as `/contract`) |
 
 ---
@@ -11610,6 +12079,8 @@ and `react-query-kit` peers.
 | `createCacheBridge` | function | sync socket events into the Query cache — [guide](../guide/realtime.md#cache-bridge) |
 | `createEntityCacheHandlers` | function | created/updated/deleted cache handlers for one entity — [guide](../guide/realtime.md#entity-cache-handlers) |
 | `EntityCacheConfig` | _type_ | config for `createEntityCacheHandlers` |
+| `EntityCacheMembership` / `EntityCacheMembershipPolicy` | _type_ | per-exact-query `include | exclude | unknown` filter decision and unknown invalidation policy |
+| `EntityCacheTotalPolicy` / `EntityCacheTotalDeltaInput` | _type_ | evidence-aware reconciliation of numeric totals on paginated cache shapes |
 | `EntityCacheHandlers` | _type_ | the `{ created, updated, deleted }` handlers it returns |
 | `EntityCacheEvent` | _type_ | discriminated created/updated/deleted input for dynamic cache keys |
 | `EntityCacheKey` | _type_ | static `QueryKey` or event-aware key factory |