stitchkit 0.74.1 → 0.75.1

package/llms-full.txt

@@ -48,6 +48,7 @@ own, recorded as an ADR.
 |--------|--------|----------|-------|
 | `stitchkit` | browser **and** server | stable | `defineContract`, `createClient`, `createHttpClient`, `createSocketIOClient`, `parseSSE`, the error model |
 | `stitchkit/contract` | browser **and** server | stable | the contract layer alone — `defineContract`, errors, pagination |
+| `stitchkit/live` | browser **and** server | evolving | `defineEvents` — topic declarations beside the operation contract, projected onto the realtime contract |
 | `stitchkit/primitives` | browser **and** server | evolving | generic values and declarations for lifecycle, access, audit, delivery and exports |
 | `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` |
@@ -61,7 +62,7 @@ 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 10 of the 19 minors since 0.56.2, most recently 0.69.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
+| `stitchkit/agent-runtime` | server | evolving<br>_redefined in 11 of the 20 minors since 0.56.2, most recently 0.75.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
 | `stitchkit/agent-runtime/harness` | server | evolving | resource-aware process-local facade over the canonical Agent runtime; supervision stays outside |
 | `stitchkit/agent-runtime/coding-tools` | server (Bun or Node) | evolving | bounded host-authorized direct file and shell tools; a root boundary, not an OS sandbox |
 | `stitchkit/agent-runtime/openrouter` | server | evolving | isolated OpenRouter language-model adapter |
@@ -69,7 +70,7 @@ own, recorded as an ADR.
 | `stitchkit/agent-runtime/sqlite/bun` | server (Bun) | evolving | durable built-in SQLite store for the agent runtime |
 | `stitchkit/agent-runtime/sqlite/node` | server (Node ≥ 22.5) | evolving | durable built-in SQLite store for the agent runtime |
 | `stitchkit-tui` | terminal (Bun) | evolving | optional official OpenTUI host over a caller-composed headless runtime |
-| `stitchkit/application` | server | evolving<br>_redefined in 4 of the 19 minors since 0.56.2, most recently 0.72.0_ | managed resource graph, readiness, admission, schedules and bounded shutdown |
+| `stitchkit/application` | server | evolving<br>_redefined in 4 of the 20 minors since 0.56.2, most recently 0.72.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` |
 
@@ -7471,6 +7472,320 @@ gives you the contract and the metadata (`idempotent`, the open `source` tag,
 [ADR 0028](../decisions/0028-revert-contract-dispatcher.md).
 
 
+==============================================================================
+# Guide: Live data  (docs/guide/live.md)
+==============================================================================
+
+---
+title: Live data — announcements, watched reads, keyspaces and the trust fence
+description: How to declare events beside the operation contract, share one server-side read between every browser asking the same question, keep authoritative memory in front of a durable backend, and refuse a request whose authority you never agreed to answer on.
+type: guide
+status: active
+created: 2026-09-02
+updated: 2026-09-02
+---
+
+# Live data
+
+Four things an application builds by hand the second time it needs them.
+`stitchkit/live` is **evolving**: it ships from its own entrypoint so that is
+visible rather than discovered in a minor.
+
+- [Announcements — `defineEvents`](#announcements)
+- [Watched reads — `createWatchHub` / `createWatchClient`](#watched-reads)
+- [Keyspaces — `defineKeyspace`](#keyspaces)
+- [The trust fence — `createTrustFence`](#the-trust-fence)
+
+---
+
+## Announcements
+
+`defineContract` says what a caller may **ask**. `defineEvents` says what the
+server may **announce**.
+
+```ts
+import { defineEvents } from 'stitchkit/live';
+import { z } from 'zod';
+
+export const events = defineEvents(
+  { prefix: 'notes' },
+  {
+    'changed': { schema: z.object({ folder: z.string() }), mode: 'emit' },
+    'archiving': {
+      schema: z.object({ folder: z.string() }),
+      mode: 'decision',
+      whenAllDefer: 'allow',
+      listenerTimeoutMs: 2_000,
+    },
+  },
+);
+// events.topics has the keys 'notes.changed' and 'notes.archiving'
+```
+
+A topic has exactly one name: the prefixed one. It is the key of `topics`, the
+event on the wire, and the string you pass to `on`. The short key in the literal
+is where the full name is *built*, not a second name for the same topic.
+
+### The wire is the socket you already run
+
+`toRealtimeContract` projects the declaration onto `RealtimeContract`. Everything
+after that is the machinery Stitchkit already ships — validation both ways,
+rejection reporting, rooms, and the client's `retain:` replay.
+
+```ts
+import { bindRealtimeServer } from 'stitchkit/server';
+import { bindRealtimeClient } from 'stitchkit';
+import { toRealtimeContract } from 'stitchkit/live';
+
+const realtime = bindRealtimeServer(toRealtimeContract(events), { io });
+realtime.emit('notes.changed', { folder: 'inbox' });
+
+// browser
+const live = bindRealtimeClient(toRealtimeContract(events), socket);
+live.on('notes.changed', (payload) => { /* payload is typed */ });
+```
+
+There is no `bindEvents`. Subscribing to an announcement is `bindRealtimeClient`,
+because a second `on()` over the same socket would be a second name for one
+thing.
+
+Two details worth knowing before you meet them:
+
+- A rejected announcement is reported **at the peer that refused it**, through
+  `onRejected`. A fire-and-forget event has no acknowledgement channel to carry
+  a refusal back to the sender.
+- An issue path names the tuple position — a bad `revision` field appears as
+  `0.revision`, because event arguments are a tuple and one payload sits at
+  index 0 of it.
+
+### Delivery modes are about **this process**
+
+A browser cannot delay or veto a server's announcement, so a mode says nothing
+about the wire. It says what the server's own listeners may do.
+
+| mode | what the caller gets back | a listener that fails |
+|---|---|---|
+| `emit` | nothing; announce and continue | isolated, reported, the others still run |
+| `serial` | a promise for the whole sequence | reported at its deadline; the next still runs |
+| `decision` | a promise for `allow` / `deny` | **denies**, with the reason |
+
+Pass the declaration to the bus and it enforces the mode:
+
+```ts
+import { createEventBus } from 'stitchkit/server';
+import type { EventPayloads } from 'stitchkit/live';
+
+const bus = createEventBus<EventPayloads<typeof events>>({ topics: events.topics });
+
+bus.on('notes.archiving', async () =>
+  (await runsOpen()) ? { outcome: 'deny', reason: 'a run is still open' } : { outcome: 'allow' },
+);
+
+const decision = await bus.decide('notes.archiving', { folder: 'inbox' });
+bus.emit('notes.archiving', …);   // throws: that topic is delivered with decide()
+```
+
+The asymmetry in the table is deliberate and is the point of the mode. For
+`emit`, isolating a failing listener means "the others carry on". For a vote, the
+same isolation would mean "counted as consent" — so a listener that throws, times
+out, or returns something that is not a decision **denies**. A listener that was
+asked and did not answer has not agreed.
+
+`whenAllDefer` and `listenerTimeoutMs` have no defaults, and that is on purpose:
+either default would be a standing `allow`/`deny`, or an unbounded wait, applied
+to every topic whose author never thought about it.
+
+---
+
+## Watched reads
+
+A watched read is a GET the server re-runs when a topic announces a change,
+pushing the new answer to everyone watching it.
+
+```ts
+// server
+import { createWatchHub } from 'stitchkit/application';
+
+const hub = createWatchHub({
+  read: (operation, args) => api[operation.action](args),
+  watchable: (operation) => operation.service === 'notes',
+  invalidatedBy: () => ['notes.changed'],
+  subscribe: (topic, listener) => bus.on(topic, listener),
+  holdMs: 30_000,
+});
+```
+
+```ts
+// browser
+import { createWatchClient } from 'stitchkit/live';
+
+const watch = createWatchClient(notesContract, { transport: live, holdMs: 30_000 });
+
+const handle = watch.list({ folder: 'inbox' });
+const stop = handle.subscribe({
+  value: (notes) => render(notes),
+  state: (state) => {
+    if (state.phase === 'unavailable') showBanner(state.message);
+  },
+});
+```
+
+Two browsers asking the same question are **one read**. The identity of a
+question is `(service, action, digest of arguments)`, and the digest is
+order-independent — `{a, b}` and `{b, a}` are the same question, which a plain
+`JSON.stringify` key would get wrong exactly when two components happen to build
+their argument object in a different order.
+
+### Who shares with whom
+
+A key is `(service, action, digest of arguments)`, and everyone on that key gets
+one read. So the question a sharing primitive has to answer is what keeps one
+caller's answer from reaching another — and here the answer is structural:
+`read` is **given no subscriber**. An answer that depends on who is asking has to
+carry the asker in its arguments, and the arguments are what the digest is taken
+over, so two callers who differ get two keys and two reads.
+
+The one way to defeat that is to resolve an identity from ambient state *inside*
+`read` — a request-scoped context, a module-level "current user". Then every
+subscriber on that key receives whatever the first read happened to resolve.
+Put the identity in the arguments instead.
+
+### Three states, not two
+
+`state.phase` comes from `LiveStatePhase`, the vocabulary the live-state
+controller already uses. The one to notice is `opening`: subscribed, nothing read
+yet. It is neither healthy nor broken, and rendering it as "unavailable" tells a
+user something is wrong when the truth is that it is early.
+
+A failed read arrives as `unavailable` with the read's own `code` and `message`.
+The hub retries on its own backoff, and a success clears the state without anyone
+asking.
+
+### `watch` or `createLiveStateController`?
+
+> **If you would have written `applyEvent` as `(_, next) => next`, you want
+> `watch`: the server sends the value whole.** `createLiveStateController` is for
+> a server that sends *deltas* you have to fold. `watch` is that controller with
+> the fold fixed to replacement, plus the key sharing and the retention — so
+> applying both to one value is always a mistake.
+
+### What it cannot promise
+
+One source per **process**. Two processes behind a balancer are two reads, and no
+test can show you otherwise from inside one of them.
+
+---
+
+## Keyspaces
+
+Authoritative memory in front of a durable backend: read synchronously, write
+through one serialised chain.
+
+```ts
+import { defineKeyspace, keyspaceResource, sqliteKeyspaceBackend } from 'stitchkit/application';
+
+const sessions = defineKeyspace('sessions', {
+  schema: SessionSchema,
+  key: (session) => session.id,
+});
+
+createApplication({
+  resources: [
+    keyspaceResource(sessions, {
+      backend: sqliteKeyspaceBackend(sessions, { database }),
+      onChanged: (change) => bus.emit('sessions.changed', { id: change.key }),
+      dependsOn: ['database'],
+    }),
+  ],
+});
+```
+
+The order is **backend, then memory, then the change event**, and it is the whole
+point:
+
+- Backend first is what makes the memory authoritative — a reader can never
+  observe a value that did not survive. The reverse order makes writes feel
+  instant and makes every rejected write a lie somebody already read.
+- The event last, after memory, because a subscriber woken by it reads
+  immediately. An event emitted before the memory update is a wake-up to the old
+  value.
+
+It is a **resource**, read with `context.use(...)`, not a function you call
+wherever you need it. The kernel resolves its resource graph in the constructor
+and cannot register one afterwards, so a keyspace opened by a bare call inside
+another resource's `start` is never drained, never closed, and never ordered
+against the things that write to it.
+
+"Durable" means the backend's `put` resolved. It does **not** mean `fsync` —
+SQLite in WAL mode with `synchronous = NORMAL` returns success before the data
+reaches the disk. What an acknowledgement is worth is the backend's to state and
+yours to configure. In the same spirit, a keyspace that closes with writes still
+queued reports how many through `onUnwritten`, because a graceful close is
+deadline-bounded and a forced one can cut a drain short.
+
+---
+
+## The trust fence
+
+Compare the authority a request addressed against a list you declared, and refuse
+before anything is dispatched.
+
+```ts
+import { createTrustFence } from 'stitchkit/server';
+
+const fence = createTrustFence({
+  trustedHosts: ['app.internal', 'localhost:5180', '192.168.1.10:5180'],
+  logger,
+});
+
+createServer({
+  services,
+  hooks: composeLifecycleHooks(fence.hooks, applicationHooks),
+  socket: { io, allowRequest: fence.allowRequest },
+});
+```
+
+### Install **both** halves
+
+`fence.hooks` fences HTTP. `fence.allowRequest` fences the Socket.IO lane — and
+that lane never reaches `hooks.onRequest` on either runtime: on Bun the fetch
+handler answers the socket prefix before the contract handler exists, and on Node
+`socket.attach` hands the upgrade to Socket.IO directly. A fence installed only
+in `hooks` leaves open the lane a live application pushes its data over.
+
+Order matters too: `composeLifecycleHooks` stops at the first hook that answers,
+so the fence goes **first**. Behind a hook that returns a maintenance page, it
+never runs.
+
+### What it does not do
+
+- **It does not gate operations.** "Only from this machine" is a property of an
+  operation, and an operation is known after routing, not before it. Write it as
+  an auth rule over `ctx.ipAddress` — `isLoopbackAddress` is exported for
+  exactly that — where it composes with your other rules.
+- **It does not re-check an open connection.** Both lanes check at admission.
+- **It does not see an `OPTIONS` preflight** when `cors` is configured; that is
+  answered earlier. The preflight carries no operation and no body, and the
+  DNS-rebinding attack the fence exists for is same-origin and sends none.
+
+An entry is `host` or `host:port` — no scheme, no path, no wildcard — and an
+entry that is not a readable authority stops startup naming itself, rather than
+quietly matching nothing. There is no implicit `localhost`: list it when you want
+it.
+
+Every refusal answers the same bare 403. A response that said *which* rule
+refused would let a caller learn your trusted list one guess at a time; the
+reason goes to `onRefused` and the log, where you are.
+
+### One thing that changed
+
+A route group can no longer declare `onRequest`. It never worked — the framework
+dispatched only the server-level hook — and it could not be made to work without
+matching group prefixes a second time, ahead of the real router. Use the
+server-level `hooks.onRequest` to refuse before dispatch, or the group's
+`authorize` to gate once the endpoint is known.
+
+
 ==============================================================================
 # Guide: Auth & errors  (docs/guide/auth-and-errors.md)
 ==============================================================================
@@ -7925,6 +8240,15 @@ is turned into a `400 VALIDATION_ERROR` automatically — and it carries the
 offending fields as structured `details.issues`, so a machine client matches on
 them instead of parsing the text `message`:
 
+`path` and `code` are the framework's. **`message` is not** — it is `issue.message`
+as Zod produced it, so for a `.refine()` it is whatever the schema's author wrote.
+The framework never puts a submitted value into it, and its own messages describe
+types rather than values (`expected string, received undefined`, `Invalid UUID`),
+but that is a property of today's messages, not a guarantee anyone is in a
+position to make: the text belongs to whoever declared the schema. Forward `path`
+and `code` to an end user freely; treat `message` as internal unless you wrote
+every refine in the contract.
+
 ```json
 {
   "error": {
@@ -9594,6 +9918,51 @@ makes one thing your job rather than the resolver's:
 The mechanical part is identical either way. Only the *noticing* differs, and an
 exact pin moves it onto you.
 
+## Released migration: 0.75.0
+
+Two mechanical renames and one option that has to move. Nothing about a passing
+request changes.
+
+### 1. A route group's `onRequest`
+
+```bash
+rg -n "hooks:\s*\{[^}]*onRequest" --glob '*.ts'
+```
+
+Any match **inside a `groups: [...]` entry** must move. The hook was accepted and
+never dispatched, so the behaviour you have today is "no hook"; the fix is to
+decide which one you meant:
+
+```ts
+// refuse before dispatch, for the whole server
+createServer({ groups, hooks: { onRequest: gate } });
+
+// gate this group once the endpoint is known
+groups: [{ pathPrefix: '/admin', services, hooks: { authorize: gate } }]
+```
+
+A group that still declares `onRequest` fails at startup with that message.
+
+### 2. The SQLite boundary type
+
+```bash
+rg -l "AgentRuntimeSqlite(Database|Statement|Value)" | xargs sed -i \
+  -e 's/AgentRuntimeSqliteDatabase/SqliteDatabase/g' \
+  -e 's/AgentRuntimeSqliteStatement/SqliteStatement/g' \
+  -e 's/AgentRuntimeSqliteValue/SqliteValue/g'
+```
+
+Type-only: the same three methods, the same structural compatibility with
+`bun:sqlite` and a `node:sqlite` wrapper, imported from the same entrypoints.
+`initializeAgentRuntimeSqlite` keeps its name — it really is the agent runtime's
+schema.
+
+### 3. Nothing else
+
+`stitchkit/live`, the watch hub, the keyspace and the trust fence are all
+additive. Adopt them when you want them; the guide is
+[Live data](./live.md).
+
 ## Released migration: 0.74.0
 
 One change, and it only reaches you if you catch a refusal the **client** raised — one it made while
@@ -12664,6 +13033,30 @@ from the root `stitchkit`.
 
 ---
 
+## `stitchkit/live`
+
+**Evolving.** Browser-and-server-safe declarations for the things that change while a caller is
+watching: announcements, and reads the server re-runs. It owns no transport — the wire is the
+realtime contract from `stitchkit`, and the server halves live in `stitchkit/application`.
+→ [ADR 0150](../decisions/0150-an-event-declaration-projects-onto-the-socket-we-already-run.md),
+[ADR 0153](../decisions/0153-a-watched-read-is-one-read-per-question.md).
+
+| Export | Kind | Summary |
+|--------|------|---------|
+| `defineEvents` | function | declare topics: a wire name, one payload schema and how the topic is delivered to in-process listeners |
+| `toRealtimeContract` | function | project a declaration onto `RealtimeContract`, so the existing validated socket carries it |
+| `EventDeliveryMode` / `EventDecision` / `EventUndecided` | _types_ | `emit` / `serial` / `decision`, one listener's vote, and the outcome when every listener defers |
+| `EventTopicDeclaration` / `EventTopicRegistry` / `EventsConfig` / `EventsDeclaration` | _types_ | one topic's schema, mode, `whenAllDefer` and `listenerTimeoutMs`, and the declaration they compose into |
+| `EventPayloads` / `EventTopicsOfMode` / `WireTopic` | _types_ | payload map keyed by wire topic, the topics of one mode, and the `prefix.name` a topic is addressed by |
+| `createWatchClient` | function | contract-shaped watch client: `watch.action(args)` returns a ref-counted handle sharing one subscription |
+| `WatchHandle` / `WatchListeners` / `WatchClientConfig` / `WatchTransport` / `TypedWatchClient` | _types_ | subscribe/close, the value and state listeners, hold window and open deadline, and the bound realtime client it rides |
+| `watchContract` | const | the four-event realtime contract a watched read travels on |
+| `WATCH_OPEN` / `WATCH_CLOSE` / `WATCH_VALUE` / `WATCH_STATE` | const | the event names of that contract |
+| `WatchKey` / `WatchKeySchema` / `watchKeyString` | type / schema / function | `(service, action, arguments digest)` — the identity both ends compute the same way |
+| `WatchValueFrame` / `WatchValueSchema` / `WatchStateFrame` / `WatchStateSchema` | _types_ | a value with its monotonic revision, and a phase from `LiveStatePhase` with the read's own code and message |
+
+---
+
 ## `stitchkit/primitives`
 
 Browser-and-server-safe declarations for facts an application wants to define once. See the
@@ -12918,6 +13311,21 @@ Also re-exports the error helpers from `stitchkit/contract`.
 
 ---
 
+### Trust fence
+
+Refuses a request whose `Host` is not a declared authority, at both admission points — the socket
+lane never reaches the hooks on either runtime.
+→ [ADR 0151](../decisions/0151-a-trust-fence-names-its-lanes-because-one-of-them-bypasses-hooks.md).
+
+| Export | Kind | Summary |
+|--------|------|---------|
+| `createTrustFence` | function | `hooks` for the HTTP lane and `allowRequest` for the Socket.IO lane; a bare 403 that never says which rule refused |
+| `isLoopbackAddress` | function | whether an address is this machine — for the auth rule a privileged operation belongs in, not for the fence |
+| `TrustFence` / `TrustFenceConfig` / `TrustRefusal` / `TrustRefusalReason` / `TrustLane` | _types_ | the two admission points, the declared authorities, and why and where a request was refused |
+| `RouteGroupHooks` | _type_ | a route group's hooks — `LifecycleHooks` without `onRequest`, which runs before the group is known |
+
+---
+
 ## `stitchkit/application`
 
 Server-only process-local application composition. See the
@@ -13067,6 +13475,20 @@ the function that derives it from a snapshot,
 `ApplicationResourceShutdownSchema` / `ApplicationResourceShutdown`, and
 `ApplicationShutdownResultSchema` / `ApplicationShutdownResult`.
 
+### Keyspace and watched reads
+
+| Export | Kind | Summary |
+|--------|------|---------|
+| `defineKeyspace` / `keyspaceResource` | function | a named record set read synchronously from memory and written through one serialised chain; backend first, then memory, then the change event |
+| `KeyspaceBackend` / `KeyspaceDeclaration` / `KeyspaceChange` / `KeyspaceResourceConfig` / `OpenKeyspace` | _types_ | the four-method durability port, the declaration, the announced change, the resource's options and the published handle |
+| `memoryKeyspaceBackend` / `sqliteKeyspaceBackend` / `SqliteKeyspaceBackendConfig` | function / type | a disposable in-process backend, and one table with a key and a JSON payload over a caller-owned database |
+| `SqliteDatabase` / `SqliteStatement` / `SqliteValue` | _types_ | the minimal synchronous SQLite boundary the framework types against |
+| `createWatchHub` / `watchKey` | function | one read per question however many are asking: single-flight per key, re-read on a declared topic, publish only what changed |
+| `WatchHub` / `WatchHubConfig` / `WatchOperation` / `WatchSubscriber` / `AttachedWatcher` | _types_ | the hub, its read/watchable/invalidation policy, the operation identity, and one connection's attachment |
+
+→ [ADR 0152](../decisions/0152-a-keyspace-is-memory-that-nothing-reaches-before-it-is-durable.md),
+[ADR 0153](../decisions/0153-a-watched-read-is-one-read-per-question.md).
+
 ## `stitchkit/application/grammy`
 
 Isolated optional-peer lifecycle adapters. Importing `stitchkit/application`
@@ -13405,7 +13827,7 @@ loaded by the neutral, browser or Node runtime surfaces.
 | `BunSqliteAgentRuntimeStoreConfig` | _type_ | database filename plus optional create and initialization policies |
 | `createSqliteAgentRuntimeStore` | function | build the normalized store over an injected synchronous SQLite boundary |
 | `initializeAgentRuntimeSqlite` | function | initialize or validate only Stitchkit's namespaced SQLite schema |
-| `AgentRuntimeSqliteDatabase` / `AgentRuntimeSqliteStatement` / `AgentRuntimeSqliteValue` | _type_ | minimal runtime-neutral synchronous SQLite boundary |
+| `SqliteDatabase` / `SqliteStatement` / `SqliteValue` | _type_ | minimal runtime-neutral synchronous SQLite boundary |
 | `SqliteAgentRuntimeStore` / `SqliteAgentRuntimeStoreConfig` | _type_ | durable store handle, owned connection lifecycle and initialization policy |
 
 ---
@@ -13460,7 +13882,7 @@ the Bun leaf but imports only `node:sqlite`.
 | `createNodeSqliteAgentRuntimeStore` | function | open an owned Node `DatabaseSync`, initialize/validate schema v1 and return `{ store, close }` |
 | `NodeSqliteAgentRuntimeStoreConfig` | _type_ | database filename plus optional read-only and initialization policies; read-only requires an initialized schema |
 | `createSqliteAgentRuntimeStore` / `initializeAgentRuntimeSqlite` | function | shared normalized adapter and namespaced schema lifecycle |
-| `AgentRuntimeSqliteDatabase` / `AgentRuntimeSqliteStatement` / `AgentRuntimeSqliteValue` | _type_ | minimal runtime-neutral synchronous SQLite boundary |
+| `SqliteDatabase` / `SqliteStatement` / `SqliteValue` | _type_ | minimal runtime-neutral synchronous SQLite boundary |
 | `SqliteAgentRuntimeStore` / `SqliteAgentRuntimeStoreConfig` | _type_ | durable store handle, owned connection lifecycle and initialization policy |
 
 ## `stitchkit/observability`

package/llms.txt

@@ -16,6 +16,7 @@ Build with stitchkit: define a contract once, then `implement` it and serve it (
 - [Application migration recipes](https://github.com/max-listov/stitchkit/blob/master/docs/guide/application-migration-recipes.md): executable database, poller, queue-consumer and operational publishing cutovers
 - [CLI](https://github.com/max-listov/stitchkit/blob/master/docs/guide/cli.md): contracts as a command-line program
 - [Realtime](https://github.com/max-listov/stitchkit/blob/master/docs/guide/realtime.md): Socket.IO server/client wrappers, handshake auth, the cache bridge, a raw WebSocket lane
+- [Live data](https://github.com/max-listov/stitchkit/blob/master/docs/guide/live.md): defineEvents beside the contract, watched reads shared by every subscriber, keyspaces with authoritative memory, and the trust fence
 - [Auth & errors](https://github.com/max-listov/stitchkit/blob/master/docs/guide/auth-and-errors.md): scopes, createAuthHook, JWT/cookies, the AppError model, the stitch error-code registry
 - [Observability](https://github.com/max-listov/stitchkit/blob/master/docs/guide/observability.md): request and tool-call observability, W3C trace context, createObservability
 - [Testing & deployment](https://github.com/max-listov/stitchkit/blob/master/docs/guide/testing-and-deployment.md): in-process testing; deploying on Bun and on Node (serveNode)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.74.1",
+  "version": "0.75.1",
   "description": "Contract-first backend framework — one defineContract() into an HTTP API, MCP tools, AI-agent tools and a typed client. Bun and Node.",
   "keywords": [
     "bun",
@@ -49,6 +49,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./live": {
+      "types": "./dist/live.d.ts",
+      "import": "./dist/live.js"
+    },
     "./react": {
       "types": "./dist/react.d.ts",
       "import": "./dist/react.js"
@@ -152,7 +156,7 @@
   "scripts": {
     "build:native-contained-files": "node scripts/build-contained-files-native.mjs",
     "check": "bun x tsc --noEmit",
-    "build:browser": "bun build src/index.ts src/react.ts src/contract/index.ts src/primitives.ts src/declaration.ts src/agent-runtime-browser.ts --outdir dist --target node --packages external --splitting --root src",
+    "build:browser": "bun build src/index.ts src/live.ts src/react.ts src/contract/index.ts src/primitives.ts src/declaration.ts src/agent-runtime-browser.ts --outdir dist --target node --packages external --splitting --root src",
     "build:server": "bun build src/server/index.ts src/node.ts src/tools.ts src/tool-invoker.ts src/cli.ts src/remote.ts src/files.ts src/testing.ts src/observability/index.ts src/agent-runtime.ts src/agent-runtime-harness.ts src/agent-runtime-coding-tools.ts src/agent-runtime-openrouter.ts src/agent-runtime-sqlite-bun.ts src/agent-runtime-sqlite-node.ts src/application.ts src/application-grammy.ts src/application-opentelemetry.ts src/telegram.ts --outdir dist --target node --packages external --splitting --root src",
     "build:js": "bun run build:browser && bun run build:server && bun scripts/preserve-webpack-ignore.mjs",
     "build:types": "bun x tsc -p tsconfig.build.json --emitDeclarationOnly && bun scripts/rewrite-declaration-specifiers.mjs",