@earendil-works/chord 1.2.0 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## [1.4.0] - 2026-10-21
+
+### Breaking Changes
+
+- Custom `Context` implementations must provide `telemetry: TelemetrySpan`; use the no-op span `NOOP_TELEMETRY_CONTEXT` when disabled. `withTelemetry()` accepts spans, not adapters.
+
+### Added
+
+- `@earendil-works/chord/telemetry-sqlite`: portable SQLite telemetry recording with bounded settled-span queues, ten-second metric aggregates, periodic flushes, and retention cleanup.
+- `Context.telemetry` is an explicit, non-optional telemetry parent (no-op by default). `withTelemetry(telemetry, context)` derives it without changing values or cancellation; `traceIn(context, options, fn)` starts a child span and passes its derived context to the callback.
+- `@earendil-works/chord/sqlite`: portable SQLite interfaces, atomic migration runner, and schema-prefix validation, with Node (`/sqlite/node`) and Cloudflare Durable Object (`/sqlite/cloudflare`) drivers. Moved from Durable, which keeps its storage implementations and re-exports the moved public names.
+- `@earendil-works/chord/output`: `Progress` takes an optional `ProgressClock` (`now`, `setTimer`) to pace commits on, by default `Date.now` and `setTimeout`.
+
+## [1.3.0] - 2026-10-15
+
+### Breaking Changes
+
+- Terminology follows the concepts: a reference (what `get` returns) is `Ref<C>` (was `Handle<C>`), its status `RefStatus` (was `HandleStatus`); what a factory returns is `ImplementationOf<C>` (was `BehaviorOf<C>`); a resource's options are a `ResourceDeclaration` (was `ResourceSpec`); epochs are code versions: `Ctx.codeVersion`, `RootOptions.codeVersion`, `Host.codeVersion`/`previousCodeVersion`, and the `codeVersion` fields of frames and reload reports (all were `epoch`). Docs and messages say object (was record) and reference (was handle and hold); the `hold` and `release` frame types keep their names
+- A remote object's variant is named `variant` (was `kind`): factories return `{ variant: "editor", … }`, references expose `ref.variant` and `shape.variant`, and the `shape` frame carries `variant`. `variant` is reserved as a member name; `kind` no longer is
+- Links have a protocol version (`PROTOCOL_VERSION`, now 2), announced in `hello`. Peers of different versions do not talk: the side that notices closes the link with reason `protocol-version <n>`, and both sides report it through `LinkOptions.onProtocolMismatch`. Peers without a version (older Chord) are refused
+- `serve(…, { lifetime })` replaces `eager`: `"referenced"` (the default) creates an object at the first `get` of its address and disposes it after the last reference is released (plus `linger`); `"host"` creates the type's one object when its facet loads and keeps it until the host closes or a reload removes its facet. `lifetime: "host"` is refused at `serve` for remote types, for inputs that do not accept `{}` and together with `linger`; every `get` of such a type reaches its one object, created for the host principal, and another input is `invalid/input`. `eager: { input }` and the extra objects host-principal `get`s with other inputs created are gone. Only `"host"` objects may register (reason `invalid/not_host_lifetime`, was `not_eager`). `LoadOptions.awaitHostObjects` replaces `awaitEager`
+- Declarations are calls by name: `self.state(name, schema, initial, { version?, migrate? })` returns the cell, `self.resource(name, { version, deps?, exclusive?, open, close? })` the resource (`rev` is now `version`), `self.on(name, source, [select,] handler)` declares a listener; `self.derive(sources, fn)` and `self.task(fn)` take no name. `cell()`, `derivation()`, `resource()`, `listener()`, `self.resources`, `self.listen`, `self.tasks` and the declaration maps are gone, and so are the types `CellDecl`, `ResourceDecl`, `DerivationDecl`, `ListenerDecl`. A repeated name of one kind in a run is `invalid/duplicate`
+- State versions belong to cells: `ServeOptions.state` is gone; a cell's `version` (default 1) and `migrate(old, from)` replace it. A raised version migrates only that cell; a lowered one refuses the reload
+- A derivation is new at every reload (computed at the commit) instead of kept with its function replaced. A listener whose state source a reload replaced subscribes again and gets the current value again: listeners on state must reconcile. Listeners on state subscribe when they activate, so they get the value current then
+- `method(args?, result?)`: without arguments a method is called `ref.name(ctx?)` and implemented `(ctx) => …`; without a result it is void (callers get `undefined`). Descriptions record both by leaving `args`/`result` out (fingerprints of such methods change), `call` frames omit `args` and `result` frames `value` for them. Coverage requires both sides to agree on arguments; a void consumer accepts a result
+- Remote contracts declare where their objects live, and callers no longer name a host: `remote(name, { …, host: hostNamed("server") })` or `host: hostFamily("session:", "session")` (the host `session:` + the input's required string field `session`, checked by TypeScript). `host` is required on remote contracts; `GetOptions.at` is removed. A `get` normalizes the input, resolves the host, and acquires locally or over the link to it. `serve` refuses a type whose placement does not include the host (also at a reload), a host refuses a hold whose input its own contract places elsewhere (`invalid/placement`), and a relay refuses a hold whose target disagrees with its contract token. The placement is part of the description and fingerprint; coverage requires equal placements, and `accepts` adapters do not bridge placements. Remote references are addressed by type, normalized input and principal, without a host name. `PROTOCOL_VERSION` is 3 (remote tokens carry `host`; a hold's input is normalized). New exports: `hostNamed`, `hostFamily`, `Placement`, `PlacementFor`, `HostNamed`, `HostFamily`
+- `FacetApi` has a `signal` (below): code that builds a `FacetApi` by hand, for example to wrap `serve`, must pass it on
+- Principals are typed and supplied by the app: `createHost<P>`, `Host<P>`, `defineFacet<P>`, `FacetApi<P>`, `Serve<P>`, `Factory<C, P>`, `Self<P>`, `Ctx<P>`, `GetOptions<P>`, `RootOptions<P>`, `Route<P>`, `AcceptOptions<P>` and `PrincipalMatch<P>` take the app's principal type (default `unknown`), so factories, methods, listeners and tasks narrow on it without casts. Chord invents no principals any more: `createHost({ self })` (required) is the principal of the host's own code, replacing the built-in `hostPrincipal` (`{ host: true }`, removed); `connect(link, { principal })` (required) is what the parent's own requests act as, replacing `{ host: <parent name> }`; `Route.principal` is required, replacing the default `{ host: <host name> }`. `HostOptions.upstream` is `{ link, principal, ...LinkOptions }` (was a link, with `upstreamOptions`). The host's own principal is recognized by `principalKey`, not object identity. The `Principal` type is gone; `ConnectOptions` and `PrincipalPattern` are new
+- `serve(type, factory, { lifetime: "host" })` compiles only for a local type whose input has no required fields, and without `linger`; `serve` still refuses the rest at runtime. `ServeOptions` is a union of `ReferencedServeOptions` and `HostServeOptions`, and `serve` takes `ServeOptionsFor<C>`
+- An awaited reference has its state, local or remote. `ctx.get` and `host.get` are async: they resolve once the reference is live and every state member of its variant has its first snapshot, and reject with the activation error, `aborted` (the ctx aborted or its call settled; `host.get`'s `signal`) or `unavailable/ready_timeout` after `HostOptions.readyTimeout` (default 60000 ms), releasing only that reference. `host.hold` is the synchronous form (possibly `loading`) for UI runtimes; `ref.ready` stays. `self.get` stays synchronous: an object goes live only once its references are ready and hydrated, and the state it exposes or derives from (also forwarded from a remote reference held another way) has its values; activation and reload prepare wait at most `readyTimeout` (a reference cycle across hosts fails with a hint instead of hanging)
+- State members are typed `T` (was `T | undefined`) and `StateSource<T>` is `Readable<T>`. Reading state before the first hydration throws `not_ready`, outside the current variant `not_in_variant`, after the reference ended its end error. A remote reference is a union discriminated by `variant`: another variant's members are reachable only after narrowing. `MembersOf` is gone. A listener added before a member is readable gets its snapshot then (no `undefined` snapshot first)
+- A remote reference stays subscribed to its variant's state while held, with or without listeners (it no longer forgets its value when the last listener leaves). `GetOptions.state: false` makes a method-only reference: no state unless another reference to the object wants it, ready once live
+- `Shape.codeVersion` and the `shape` frame's `codeVersion` are gone
+- `PROTOCOL_VERSION` is 4: a `hold` implies the state of its variant (`state: false` opts out until `sub`; `unsub` stops it); the provider answers with units, a `shape` listing the members the consumer lacks (`state`) followed by their snapshots; `state` frames are addressed by hold and member (`hold`, `m`) with `as: "snap" | "reset" | "ops" | "error"` and `value` (absent: `undefined`); `sub`/`unsub` take a hold; `resync` asks for a member again; `again` marks a re-hold after a link loss; `origin` (replacing `client`) names the client connection a hold comes from
+
+### Added
+
+- `@earendil-works/chord/output`: `OutputBuffer`, which keeps a head or tail window of a stream at a cost proportional to each chunk, `Progress`, which paces commits of a changing value by their size, plus `boundOutput`, `sanitizeOutput`, `characterEnd`, `utf8ByteLength`, and the `OutputLimits`, `BoundedOutput`, `OutputSlice`, and `OutputSkip` types. Moved from `@earendil-works/pi-durable`, which now uses them from here.
+- Remote references to one object share one binding per host and key (type, normalized input identity, principal key, contract fingerprint): one hold, one stream per state member, calls over the same hold; every reference keeps its own status, observers and `release`. `HostOptions.linger` (`{ types: { [typeName]: ms }, cap }`, cap default 4) keeps a binding held and hydrated after its last reference is released, so a reference taken again meanwhile costs nothing on the link
+- Holds from clients carry an opaque `origin`: the id the accepting host gave the client connection, forwarded by relays and honored only from the parent link, so a host can tell client connections apart; a disconnect releases that client's holds at once
+- Flow control by units: the first unit of a new reference passes the window, so a `get` never waits behind other references' state; units for reloads and re-holds wait, built lazily from the current values; waiting ops are capped per link (`LinkOptions.pendingCap`, default four windows), beyond which the oldest streams become resets (a relay asks downstream with `resync`)
+- `StateOptions`, `EventOf`, `ValueOf` and `Lifetime` types
+- `self.state(name, schema, { init }, options?)`: a cell whose first value comes from its source. `init(ctx)` (may be async) runs once the object's resources are open and its references live, before the object goes live, so no method, listener, task or subscriber sees another value; a throw or an invalid value fails the activation. A reload keeps the cell without running `init`; a cell a reload adds runs it while the reload prepares (a failure refuses the reload). Until then the cell's `value` throws `not_ready`. `StateInit` type
+- Links are flow controlled end to end: peers acknowledge what they processed (`ack` frames, announced with `acks` in `hello`), and while a window of frames is unacknowledged (`window` in `LinkOptions`, default 256 KiB), state frames wait at the sender, coalesced per subscription, instead of queuing in front of call results. A stalled peer costs a bounded slot per subscription; a slot that outgrows it becomes a reset. Calls, results and control frames are never held back, so under load a result can arrive before state changes made before it
+- `maxCalls` in `AcceptOptions` limits the calls a peer may have in progress on a link; further ones are answered at once with `unavailable` (reason `too_many_calls`) and the link stays open
+- `FacetApi.signal` aborts once that run of the facet is no longer installed: a committed reload replaced or removed it, the reload that loaded it aborted, or the host closed. While a reload prepares, the installed and the candidate run are both live
+- `HostOptions.taskStopDeadline` (default 5000 ms) bounds how long a reload waits for aborted tasks before it starts their replacements
+- Links deflate call arguments, results and state snapshots whose JSON exceeds `PACK_THRESHOLD` (64K characters): over IPC as a base64 field, over WebSockets as a binary message. Relaying hosts forward the deflated bytes unread; the host that uses the payload inflates it. `webSocketLink(socket, { compress, acceptPacked })` (`WebSocketLinkOptions`) controls sending and accepting packed frames (servers should refuse them from untrusted clients), and `inflateMessage` turns a packed WebSocket message back into a text frame
+
+### Changed
+
+- `Link.send` returns the encoded frame's size as sent (deflated payloads count as sent) when the transport knows it (memory and WebSocket links); flow control counts these sizes, so links that return nothing (IPC, custom links) are not windowed
+- A reload starts an object's new tasks only after its aborted ones finished (at most `taskStopDeadline`, then anyway, reported); before, the old and the new run of a task worked side by side
+- When a reload forces the retirement of the previous code version, it first aborts the roots still running on it (their `ctx.signal`, reason `superseded`) and gives them up to 1 s to stop before it closes what only that code used; a call with such a ctx is `superseded`. Before, resources were closed under running roots, which were never told
+
+### Fixed
+
+- `nodeLoader` registers every facet's directory before importing any, so a facet that imports a file of a facet listed after it gets the same module copy as that facet; before, the load order could produce duplicates.
+- A link that is already closed when a host accepts or routes to it is no longer kept as a connection: before, a route that returned a dead link (a child process that exited before its link was wrapped) made every later call to that host name fail with `unavailable` until restart, and leaked the connection's ping timer.
+- Fixed `processLock()` failing with `listen EINVAL` on macOS and the BSDs when the temporary directory is too deep for a socket path (sun_path holds 104 bytes); the lock socket then lives in a private per-user directory, `/tmp/chord2-<uid>`
+- A child host whose hello arrived while a cluster reload ran was marked in step without taking part, so it stayed on the old code version and every call to it failed `superseded` until it reconnected. It is now synced or reconciled when the reload ends; a child already behind is fenced at once, so its roots' calls up are admitted meanwhile. A reconciliation that is running when a reload starts likewise syncs its child only after that reload, against the committed code version
+- A child host retired its previous code version as soon as a cluster reload's `prepare` arrived, before its parent did, so the parent's old roots got `superseded` on it. The coordinator now retires before it sends `prepare`, a child waits for its parent's `retire` (at most `retireDeadline`), and a child coming in step (or about to be reconciled) is told which code versions the parent retired before
+- Disposed objects stayed reachable from the host until an object with the same address was created again (every distinct guest, session or input leaked one object, its references and the code they bind)
+- References kept every code version's services, and with them the factory code of every reload, reachable for as long as they lived (held references, objects of lifetime `"host"`); old code generations could never be collected
+- Call, task and root contexts were linked to long-lived signals with `AbortSignal.any`; Node keeps such dependants reachable while they have abort listeners, so a listener on `ctx.signal` kept its closure (and its code generation) alive for the object's lifetime. Contexts now detach when they close
+- IPC links and the host manager's control channel wrote to a peer process that had exited without a callback, so the `EPIPE` Node reports for a write in the gap between the exit and `disconnect` (an `ack` sent just after a worker shut down) became an unhandled `error` event that crashed the process. The link now ends on a failed write (reason `ipc send failed: EPIPE`), and control messages to a gone peer are dropped
+- A relayed call ran under the origin's cancel signal only, so a forced retirement of the relaying host could not cancel it before closing the old code's resources; it now follows its root's signal
+- A resource kept across a reload closed with the `close` of the factory run that first opened it, and kept that run's code reachable; it now adopts the newest declaration at commit
+- `forkDriver` passed its own `CHORD2_LOCK` to forked children, so a child host that forked its own children made those without a lock of their own fail with `locked`
+- A call through a remote reference accepted a ctx from another host, or an object not made by Chord, and carried its root over the link; it now rejects it with `invalid/foreign_ctx` like a local reference ([#10959](https://github.com/earendil-works/pi/issues/10959))
+
 ## [1.2.0] - 2026-10-12
 
 ### Breaking Changes

package/README.md

@@ -2,8 +2,8 @@
 
 Chord builds applications out of **objects** that live in several processes (a server, workers, browser tabs) and can be **hot reloaded** while they run.
 
-- An **object** is state plus code at an address. It is created on demand and lives while someone holds it.
-- Everyone gets a **handle**, never the object. Handles work the same locally and across processes, and survive reloads.
+- An **object** is state plus code at an address. It is created on demand and lives while someone references it.
+- Everyone gets a **reference**, never the object. References work the same locally and across processes, and survive reloads.
 - Every object knows its **principal**: an owner and a guest get different objects, with different methods.
 - **State** is observable JSON. Remote viewers get a snapshot followed by deltas.
 - **Hot reload** swaps code while it runs. Work in flight finishes on the code it started with, state is kept, and incompatible changes migrate at a safe point.
@@ -14,45 +14,50 @@ Contracts are runtime values described with [TypeBox](https://github.com/sinclai
 
 | Import | Contents | Runs in |
 |--------|----------|---------|
-| `@earendil-works/chord` | Contracts (`local`, `remote`, `method`, `opaque`), declarations (`cell`, `derivation`, `listener`, `resource`), hosts (`createHost`, `defineFacet`, `defineRegistry`), links (`memoryLinkPair`, `ipcLink`, `webSocketLink`, `acceptWebSockets`), errors (`ChordError`, `isChordError`, `forbidden`, `invalid`). Also the shared base: `Context`, `JsonValue`, `JsonRepresentation`, `Draft`, `copyJson`, `isJsonValue`, and `replicatedState` with its types. | Node and browsers |
+| `@earendil-works/chord` | Contracts (`local`, `remote`, `method`, `opaque`), declarations (through the factory's `self`: `state`, `derive`, `resource`, `on`, `task`), hosts (`createHost`, `defineFacet`, `defineRegistry`), links (`memoryLinkPair`, `ipcLink`, `webSocketLink`, `acceptWebSockets`), errors (`ChordError`, `isChordError`, `forbidden`, `invalid`). Also the shared base: `Context`, `JsonValue`, `JsonRepresentation`, `Draft`, `copyJson`, `isJsonValue`, and `replicatedState` with its types. | Node and browsers |
 | `@earendil-works/chord/node` | Child host processes: `createHostManager`, `forkDriver`, `childControl`, `processLock`; the facet module loader `nodeLoader`. | Node |
-| `@earendil-works/chord/context` | Explicit cancellation and invocation values: `BACKGROUND_CONTEXT`, `withCancel`, `withAbortSignal`, `withoutAbortSignal`, `withContextValue`, `awaitWithContext`. | Node and browsers |
+| `@earendil-works/chord/context` | Explicit cancellation, telemetry, and invocation values: `BACKGROUND_CONTEXT`, `withCancel`, `withAbortSignal`, `withoutAbortSignal`, `withTelemetry`, `traceIn`, `withContextValue`, `awaitWithContext`. | Node and browsers |
 | `@earendil-works/chord/delta` | The transactional JSON tracker, structural diff, immutable apply, and the wire encoder/decoder for operation batches. | Node and browsers |
+| `@earendil-works/chord/output` | Bounded output streams and paced progress: `OutputBuffer` (head or tail window of a stream, `OutputLimits`, `OutputSkip`), `boundOutput`, `sanitizeOutput`, `utf8ByteLength`, and `Progress` (adaptive commits of a changing value). | Node and browsers |
+| `@earendil-works/chord/telemetry-sqlite` | `createSqliteTelemetry(db, { retentionMs?, maxQueuedSpans? })`: buffered recording and backend-independent `TelemetryStore` queries. | Any SQLite adapter |
+| `@earendil-works/chord/sqlite` | Portable `SqliteDatabase`, `SqliteExecutor`, and `SqliteValue`, atomic `applySqliteMigrations(database, migrations, { table })`, and `validateSqliteSchemaPrefix`. The metadata table must be a valid, non-reserved SQLite identifier; migration versions start at 1 and are contiguous. | Any SQLite adapter |
+| `@earendil-works/chord/sqlite/node` | `NodeSqliteDatabase`, `openNodeSqliteDatabase`, and `NodeSqliteDatabaseOptions`. | Node |
+| `@earendil-works/chord/sqlite/cloudflare` | `DurableObjectSqliteDatabase` and the structural `DurableObjectSqliteStorage` binding type. | Cloudflare Durable Objects |
 
 ## Quick start
 
 ```ts
 import { Type } from "typebox";
-import { cell, createHost, method, remote } from "@earendil-works/chord";
+import { createHost, hostNamed, method, remote } from "@earendil-works/chord";
 
 // contract.ts: shared by provider and consumers
 export const Counter = remote("demo.counter", {
 	version: 1,
 	input: Type.Object({ name: Type.String() }),
+	host: hostNamed("server"), // where its objects live; callers never name a host
 	variants: {
 		default: {
 			state: { count: Type.Number() },
-			methods: { increment: method(Type.Object({ by: Type.Number() }), Type.Null()) },
+			methods: { increment: method(Type.Object({ by: Type.Number() })) },
 		},
 	},
 });
 
-const host = createHost({ name: "server", principalKey: (p) => p.kind });
+const host = createHost({ name: "server", self: { kind: "server" } });
 
 host.serve(Counter, ({ name }, _principal, self) => {
-	const state = self.state({ count: cell(Type.Number(), 0) });
+	const count = self.state("count", Type.Number(), 0);
 	return {
-		kind: "default",
-		count: state.count,
+		variant: "default",
+		count,
 		increment: async ({ by }, ctx) => {
-			state.count.change(ctx, (n) => n + by);
-			return null;
+			count.change(ctx, (n) => n + by);
 		},
 	};
 });
 
 await host.root(async (ctx) => {
-	const clicks = ctx.get(Counter, { name: "clicks" }); // a handle; held until this root ends
+	const clicks = await ctx.get(Counter, { name: "clicks" }); // ready, with its state; released when this root ends
 	clicks.count.subscribe((n) => console.log("count", n));
 	await clicks.increment({ by: 2 }, ctx); // logs 0, then 2
 });
@@ -65,6 +70,56 @@ await host.root(async (ctx) => {
 - [Specification](docs/spec.md): compatibility, lifetime, and reload semantics, plus known limitations and implementation decisions.
 - [Delta guide](src/delta/README.md): ownership, lifecycle, operation, and replica contracts of `@earendil-works/chord/delta`.
 
+## Explicit Context telemetry
+
+`Context` always carries a `telemetry: TelemetrySpan`, alongside `abortSignal`. `BACKGROUND_CONTEXT` and `TODO_CONTEXT` use the shared no-op span `NOOP_TELEMETRY_CONTEXT`. Adapters (`TelemetryContext`) belong to hosts and start root spans; adapters are never placed in a `Context`.
+
+```ts
+import { BACKGROUND_CONTEXT, traceIn, withTelemetry } from '@earendil-works/chord/context';
+import { InMemoryTelemetryContext } from '@earendil-works/pi-telemetry';
+
+const telemetry = new InMemoryTelemetryContext();
+await telemetry.startSpan({ name: 'app.request' }, async (span) => {
+  const context = withTelemetry(span, BACKGROUND_CONTEXT);
+  await traceIn(context, { name: 'app.load' }, async (child) => {
+    child.telemetry.addEvent('cache.miss');
+    return traceIn(child, { name: 'app.read' }, (nested) => readAccount(nested));
+  });
+});
+```
+
+`withTelemetry(span, context)` derives a new context; it never changes its parent, cancellation, or typed values. `traceIn(context, options, fn)` creates a callback-managed child span, and `fn` receives its derived context. Every context already supports `telemetry.addEvent()` and `telemetry.addLink()`. Values, cancellation, callback results, and rejection identities are preserved. Concurrent calls keep independent parents; there is no ambient current span. `value()`, `ContextKey`, and `withContextValue()` remain supported.
+
+These helpers operate on the standalone `Context` API. They do not yet instrument Chord hosts, methods, or network frames.
+
+## SQLite telemetry
+
+```ts
+import { createSqliteTelemetry } from '@earendil-works/chord/telemetry-sqlite';
+import { openNodeSqliteDatabase } from '@earendil-works/chord/sqlite/node';
+import { renderTrace } from '@earendil-works/pi-telemetry/render';
+
+const db = await openNodeSqliteDatabase('telemetry.db');
+const telemetry = await createSqliteTelemetry(db);
+try {
+  await telemetry.startSpan({ name: 'app.request' }, async (span) => {
+    span.addEvent('request.accepted');
+    await span.startSpan({ name: 'app.read' }, () => readAccount());
+  });
+  await telemetry.flush();
+  const { traces } = await telemetry.findTraces({ name: 'app.request', limit: 10 });
+  for (const trace of traces) console.log(renderTrace(trace.spans));
+} finally {
+  try { await telemetry.close(); } finally { await db.close(); }
+}
+```
+
+The adapter is portable over `SqliteDatabase` and owns no connection. Recording performs no SQL. A one-second timer flushes settled spans and completed ten-second metric intervals in one transaction, including retention cleanup. Metrics retain count, sum, minimum, and maximum per name/kind/unit/attribute series, not raw samples, buckets, or exemplars. `close()` stops recording and drains partial metric intervals without waiting for business callbacks or closing the database. Late span completions are ignored.
+
+Retention defaults to seven days. `maxQueuedSpans` defaults to 10,000 and counts settled spans awaiting commit, including an in-flight batch. The same limit independently bounds pending metric interval/series pairs. Overflow increments `droppedSpans` or `droppedMeasurements`; the limits bound counts, not bytes or active spans. A write failure stops recording permanently: `flush()` and `close()` reject with the original error without retrying.
+
+The adapter implements `TelemetryStore`: `findTraces()`, `getTrace()`, and `findMetrics()` read committed rows, including after adapter close while the database remains open. See [stored telemetry](../telemetry/README.md#stored-telemetry) for filters, pagination, and cross-process trace assembly. Schema tables are `telemetry_spans`, `telemetry_metrics`, and `telemetry_schema`.
+
 ## Tracking JSON deltas
 
 Import the standalone transactional tracker from `@earendil-works/chord/delta`:
@@ -112,7 +167,7 @@ status.change(context, (draft) => {
 ```
 
 A successful `change()` publishes exactly one atomic revision. If its callback
-throws, the original value and sequence remain unchanged. Draft handles become
+throws, the original value and sequence remain unchanged. Draft references become
 unusable when the callback returns. The tracker emits string append and
 front-truncate operations, array splices and permutations, sets, and deletes; large
 edit sets may fold into a complete replacement.

package/dist/cell.d.ts

@@ -6,7 +6,7 @@ export interface SourceOptions {
     readonly dev: boolean;
     readonly report: (error: unknown) => void;
 }
-/** Checks that `ctx` may write a record's cells now; throws otherwise. */
+/** Checks that `ctx` may write an object's cells now; throws otherwise. */
 export type WriteGuard = (ctx: Ctx) => void;
 /** Fans out values and delta events; listener errors are reported, not thrown to the writer. */
 declare class Fanout<T> {
@@ -20,7 +20,21 @@ declare class Fanout<T> {
      */
     emit(event: StateEvent<T>): void;
 }
-/** A record-owned state source (cell or derivation). Writes recompute dependents atomically. */
+/**
+ * Whether a state source has its value (entry 8): a remote reference's member before its first snapshot has none, and
+ * neither has anything derived from or forwarding it. Sources without this symbol always have their value.
+ */
+export declare const HYDRATION: unique symbol;
+export interface Hydration {
+    readonly hydrated: boolean;
+    /** Resolves once hydrated; rejects if the source ends first. */
+    whenHydrated(): Promise<void>;
+}
+/** The hydration of a readable, or undefined for a source that always has its value. */
+export declare function hydrationOf(value: unknown): Hydration | undefined;
+/** The hydrations of `sources` that are not hydrated yet. */
+export declare const unhydrated: (sources: Iterable<unknown>) => Hydration[];
+/** An object-owned state source (cell or derivation). Writes recompute dependents atomically. */
 export declare abstract class Source<T> implements Readable<T> {
     readonly key: string;
     readonly seq: number;
@@ -42,8 +56,15 @@ export declare class Cell<T> extends Source<T> {
     #private;
     /** Replaced at a reload commit that changes the schema (state-version bump). */
     schema: TSchema;
-    /** `initial` is always validated against `schema`; ownership moves to the cell. */
-    constructor(key: string, schema: TSchema, initial: T, guard: WriteGuard, options: SourceOptions);
+    /**
+     * `initial` is always validated against `schema`; ownership moves to the cell. Without `initial`, the cell has no
+     * value until `initialize` (a cell declared with `init`, filled before its object goes live).
+     */
+    constructor(key: string, schema: TSchema, initial: {
+        readonly value: T;
+    } | undefined, guard: WriteGuard, options: SourceOptions);
+    /** Sets the first value of a cell declared with `init` (validated; ownership moves to the cell). Publishes nothing. */
+    initialize(value: T): void;
     protected ownSchemas(): readonly TSchema[];
     get value(): T;
     /**
@@ -73,23 +94,23 @@ export type SourceValues<S extends Sources> = {
     [K in keyof S]: S[K] extends Readable<infer T> ? T : never;
 };
 /**
- * A synchronous derivation. Sources are record cells/derivations (recomputed atomically with the write) or other
- * readables such as handle state members (recomputed when they publish). Subscribers receive diffs.
+ * A synchronous derivation. Sources are object cells/derivations (recomputed atomically with the write) or other
+ * readables such as reference state members (recomputed when they publish). Subscribers receive diffs.
  */
 export declare class Derived<T> extends Source<T> {
     #private;
     readonly sources: readonly Readable<unknown>[];
     constructor(key: string, sources: Sources, fn: (...values: never[]) => unknown, options: SourceOptions);
     get value(): T;
+    /** Hydrated once every source is (a derivation over a remote member waits for its snapshot). */
+    get [HYDRATION](): Hydration | undefined;
     /**
      * Computes the first value (or takes it from `precomputed`, a reload's validated dry run) and starts following
      * the sources (at install, never inside a factory).
      */
     attach(precomputed?: ReadonlyMap<unknown, unknown>): void;
     detach(): void;
-    compute(read: (source: Readable<unknown>) => unknown, fn?: (...values: never[]) => unknown): T;
-    /** Replaces the function without recomputing (reload commit, before migrated cells are installed). */
-    setFn(fn: (...values: never[]) => unknown): void;
+    compute(read: (source: Readable<unknown>) => unknown): T;
     /** Recomputes and republishes, including dependents. Errors are reported (the source write already happened). */
     refresh(): void;
     install(next: T): void;

package/dist/cell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cell.d.ts","sourceRoot":"","sources":["../src/cell.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cell.d.ts","sourceRoot":"","sources":["../src/cell.ts"],"names":[],"mappings":"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"}

package/dist/cell.js

@@ -46,7 +46,20 @@ class Fanout {
         }
     }
 }
-/** A record-owned state source (cell or derivation). Writes recompute dependents atomically. */
+/**
+ * Whether a state source has its value (entry 8): a remote reference's member before its first snapshot has none, and
+ * neither has anything derived from or forwarding it. Sources without this symbol always have their value.
+ */
+export const HYDRATION = Symbol("chord.hydration");
+/** The hydration of a readable, or undefined for a source that always has its value. */
+export function hydrationOf(value) {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    return value[HYDRATION];
+}
+/** The hydrations of `sources` that are not hydrated yet. */
+export const unhydrated = (sources) => [...sources].map(hydrationOf).filter((hydration) => hydration?.hydrated === false);
+/** An object-owned state source (cell or derivation). Writes recompute dependents atomically. */
 export class Source {
     key;
     seq = ++sequence;
@@ -110,22 +123,41 @@ export class Cell extends Source {
     schema;
     #tracker;
     #guard;
-    /** `initial` is always validated against `schema`; ownership moves to the cell. */
+    /** False until `initialize` for a cell declared with `init`: reads and writes throw `not_ready`. */
+    #initialized;
+    /**
+     * `initial` is always validated against `schema`; ownership moves to the cell. Without `initial`, the cell has no
+     * value until `initialize` (a cell declared with `init`, filled before its object goes live).
+     */
     constructor(key, schema, initial, guard, options) {
         super(key, options);
-        assertValid("state", `initial value of state ${key}`, schema, initial);
+        if (initial !== undefined)
+            assertValid("state", `initial value of state ${key}`, schema, initial.value);
         this.schema = schema;
-        this.#tracker = track({ v: initial });
+        this.#tracker = track({ v: (initial?.value ?? null) });
         this.#guard = guard;
+        this.#initialized = initial !== undefined;
+    }
+    /** Sets the first value of a cell declared with `init` (validated; ownership moves to the cell). Publishes nothing. */
+    initialize(value) {
+        if (this.#initialized)
+            throw new Error(`state ${this.key} is already initialized`);
+        assertValid("state", `initial value of state ${this.key}`, this.schema, value);
+        this.#tracker = track({ v: value });
+        this.#initialized = true;
     }
     ownSchemas() {
         return [this.schema];
     }
     get value() {
+        if (!this.#initialized)
+            throw notReady(`state ${this.key} (its init has not run)`);
         return this.#tracker.value.v;
     }
     change(ctx, fn) {
         this.#guard(ctx);
+        if (!this.#initialized)
+            throw notReady(`state ${this.key} (its init has not run)`);
         const change = this.#tracker.beginChange();
         let prepared;
         try {
@@ -155,6 +187,8 @@ export class Cell extends Source {
      */
     replace(ctx, value, options = {}) {
         this.#guard(ctx);
+        if (!this.#initialized)
+            throw notReady(`state ${this.key} (its init has not run)`);
         const before = this.value;
         const diff = options.diff ?? sharesStructure(before, value);
         const ops = diff ? diffRevisions(before, value) : undefined;
@@ -234,8 +268,8 @@ const isReadable = (value) => value !== null &&
     typeof value.subscribe === "function" &&
     "value" in value;
 /**
- * A synchronous derivation. Sources are record cells/derivations (recomputed atomically with the write) or other
- * readables such as handle state members (recomputed when they publish). Subscribers receive diffs.
+ * A synchronous derivation. Sources are object cells/derivations (recomputed atomically with the write) or other
+ * readables such as reference state members (recomputed when they publish). Subscribers receive diffs.
  */
 export class Derived extends Source {
     sources;
@@ -255,6 +289,16 @@ export class Derived extends Source {
     get value() {
         return this.#value;
     }
+    /** Hydrated once every source is (a derivation over a remote member waits for its snapshot). */
+    get [HYDRATION]() {
+        const pending = unhydrated(this.sources);
+        if (pending.length === 0)
+            return undefined;
+        return {
+            hydrated: false,
+            whenHydrated: () => Promise.all(pending.map((hydration) => hydration.whenHydrated())).then(() => { }),
+        };
+    }
     /**
      * Computes the first value (or takes it from `precomputed`, a reload's validated dry run) and starts following
      * the sources (at install, never inside a factory).
@@ -275,16 +319,12 @@ export class Derived extends Source {
         for (const unsubscribe of this.#external.splice(0))
             unsubscribe();
     }
-    compute(read, fn = this.#fn) {
-        const result = fn(...this.sources.map(read));
+    compute(read) {
+        const result = this.#fn(...this.sources.map(read));
         if (result instanceof Promise)
             throw new TypeError(`derive ${this.key}: fn must be synchronous`);
         return result;
     }
-    /** Replaces the function without recomputing (reload commit, before migrated cells are installed). */
-    setFn(fn) {
-        this.#fn = fn;
-    }
     /** Recomputes and republishes, including dependents. Errors are reported (the source write already happened). */
     refresh() {
         try {

package/dist/cell.js.map

@@ -1 +1 @@
-{"version":3,"file":"cell.js","sourceRoot":"","sources":["../src/cell.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TSchema } from \"typebox\";\nimport { type Draft, diffRevisions, type JsonValue, type Op, type Tracker, track } from \"./delta/index.ts\";\nimport { ChordError } from \"./errors.ts\";\nimport { enqueue, holdPublications } from \"./publish.ts\";\nimport { assertValid } from \"./schema.ts\";\nimport type { Ctx, Readable, StateEvent } from \"./types.ts\";\n\nexport interface SourceOptions {\n\treadonly dev: boolean;\n\treadonly report: (error: unknown) => void;\n}\n\n/** Checks that `ctx` may write a record's cells now; throws otherwise. */\nexport type WriteGuard = (ctx: Ctx) => void;\n\nlet sequence = 0;\n\n/** Fans out values and delta events; listener errors are reported, not thrown to the writer. */\nclass Fanout<T> {\n\treadonly #values = new Set<(value: T) => void>();\n\treadonly #events = new Set<(event: StateEvent<T>) => void>();\n\treadonly #report: (error: unknown) => void;\n\n\tconstructor(report: (error: unknown) => void) {\n\t\tthis.#report = report;\n\t}\n\n\tsubscribe(listener: (value: T) => void, current: T): () => void {\n\t\tthis.#values.add(listener);\n\t\tthis.#call(listener, current);\n\t\treturn () => this.#values.delete(listener);\n\t}\n\n\tevents(listener: (event: StateEvent<T>) => void, current: T): () => void {\n\t\tthis.#events.add(listener);\n\t\tthis.#call(listener, { type: \"snap\", value: current });\n\t\treturn () => this.#events.delete(listener);\n\t}\n\n\t/**\n\t * Queues delivery to the listeners subscribed now. A listener that subscribes later already got this revision in\n\t * its snapshot; one that unsubscribes before delivery is skipped.\n\t */\n\temit(event: StateEvent<T>): void {\n\t\tconst events = [...this.#events];\n\t\tconst values = [...this.#values];\n\t\tenqueue(() => {\n\t\t\tfor (const listener of events) if (this.#events.has(listener)) this.#call(listener, event);\n\t\t\tfor (const listener of values) if (this.#values.has(listener)) this.#call(listener, event.value);\n\t\t});\n\t}\n\n\t#call<V>(listener: (value: V) => void, value: V): void {\n\t\ttry {\n\t\t\tlistener(value);\n\t\t} catch (error) {\n\t\t\tthis.#report(error);\n\t\t}\n\t}\n}\n\n/** A record-owned state source (cell or derivation). Writes recompute dependents atomically. */\nexport abstract class Source<T> implements Readable<T> {\n\treadonly key: string;\n\treadonly seq = ++sequence;\n\treadonly dependents = new Set<Derived<unknown>>();\n\t/** Schemas of remote state members currently exposing this source (checked per write in dev mode). */\n\tschemas: readonly TSchema[] = [];\n\tprotected readonly options: SourceOptions;\n\tprotected readonly fanout: Fanout<T>;\n\n\tconstructor(key: string, options: SourceOptions) {\n\t\tthis.key = key;\n\t\tthis.options = options;\n\t\tthis.fanout = new Fanout(options.report);\n\t}\n\n\tabstract get value(): T;\n\n\tsubscribe(listener: (value: T) => void): () => void {\n\t\treturn this.fanout.subscribe(listener, this.value);\n\t}\n\n\tevents(listener: (event: StateEvent<T>) => void): () => void {\n\t\treturn this.fanout.events(listener, this.value);\n\t}\n\n\t/** Per-write validation, dev mode only. */\n\tvalidate(value: unknown): void {\n\t\tif (!this.options.dev) return;\n\t\tfor (const schema of this.ownSchemas()) assertValid(\"state\", `state ${this.key}`, schema, value);\n\t\tfor (const schema of this.schemas) assertValid(\"state\", `state ${this.key}`, schema, value);\n\t}\n\n\tprotected ownSchemas(): readonly TSchema[] {\n\t\treturn [];\n\t}\n}\n\n/** The tracker tracks containers, so a cell tracks `{ v: value }` and strips the box from published ops. */\ninterface Box<T> {\n\tv: T;\n}\n\nfunction unbox(ops: readonly Op[], value: unknown): Op[] {\n\tconst result: Op[] = [];\n\tfor (const op of ops) {\n\t\tif (op[0] === \"r\" || op[1].length === 0) return [[\"r\", value as JsonValue]];\n\t\tconst path = op[1].slice(1);\n\t\tswitch (op[0]) {\n\t\t\tcase \"p\":\n\t\t\t\tresult.push([\"p\", path, op[2], op[3], op[4]]);\n\t\t\t\tbreak;\n\t\t\tcase \"m\":\n\t\t\t\tresult.push([\"m\", path, op[2]]);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\t// s/d/a/t on the value itself replace it.\n\t\t\t\tif (path.length === 0) return [[\"r\", value as JsonValue]];\n\t\t\t\tif (op[0] === \"d\") result.push([\"d\", path as [string | number, ...(string | number)[]]]);\n\t\t\t\telse result.push([op[0], path as [string | number, ...(string | number)[]], op[2]] as Op);\n\t\t}\n\t}\n\treturn result;\n}\n\n/** A state cell holding any JSON value, validated against its schema at creation and (dev mode) on writes. */\nexport class Cell<T> extends Source<T> {\n\t/** Replaced at a reload commit that changes the schema (state-version bump). */\n\tschema: TSchema;\n\treadonly #tracker: Tracker<Box<T>>;\n\treadonly #guard: WriteGuard;\n\n\t/** `initial` is always validated against `schema`; ownership moves to the cell. */\n\tconstructor(key: string, schema: TSchema, initial: T, guard: WriteGuard, options: SourceOptions) {\n\t\tsuper(key, options);\n\t\tassertValid(\"state\", `initial value of state ${key}`, schema, initial);\n\t\tthis.schema = schema;\n\t\tthis.#tracker = track<Box<T>>({ v: initial });\n\t\tthis.#guard = guard;\n\t}\n\n\tprotected override ownSchemas(): readonly TSchema[] {\n\t\treturn [this.schema];\n\t}\n\n\tget value(): T {\n\t\treturn this.#tracker.value.v;\n\t}\n\n\t/**\n\t * Mutates a draft (only mutated paths are published), or returns a new value (`n => n + 1`). A returned value is\n\t * always validated against the schema. The draft is unusable after `fn` returns.\n\t */\n\tchange(ctx: Ctx, fn: (draft: Draft<T>) => T): void;\n\tchange(ctx: Ctx, fn: (draft: Draft<T>) => void): void;\n\tchange(ctx: Ctx, fn: (draft: Draft<T>) => unknown): void {\n\t\tthis.#guard(ctx);\n\t\tconst change = this.#tracker.beginChange();\n\t\tlet prepared: ReturnType<typeof change.prepare>;\n\t\ttry {\n\t\t\tconst draft = change.state as Draft<Box<T>>;\n\t\t\tconst result: unknown = fn(draft.v as Draft<T>);\n\t\t\tif (result instanceof Promise) throw new TypeError(\"cell.change callbacks must be synchronous\");\n\t\t\tif (result !== undefined) {\n\t\t\t\tif (result !== draft.v) assertValid(\"state\", `state ${this.key}`, this.schema, result);\n\t\t\t\tdraft.v = result as Draft<T>;\n\t\t\t}\n\t\t\tprepared = change.prepare();\n\t\t} catch (error) {\n\t\t\tchange.abort();\n\t\t\tthrow error;\n\t\t}\n\t\tthis.#publish(prepared, \"ops\");\n\t}\n\n\t/**\n\t * Replaces the whole value. Ownership of `value` moves to the cell: never mutate it afterwards.\n\t *\n\t * Subscribers get a structural diff (`diffRevisions`) when `diff` is true, or by default when the new value shares\n\t * containers with the old one (a new immutable revision of the same state, e.g. mirrored from another store);\n\t * otherwise a single `r` op. The resulting value is the same either way; only the ops differ.\n\t */\n\treplace(ctx: Ctx, value: T, options: { readonly diff?: boolean } = {}): void {\n\t\tthis.#guard(ctx);\n\t\tconst before = this.value;\n\t\tconst diff = options.diff ?? sharesStructure(before, value);\n\t\tconst ops = diff ? diffRevisions(before as JsonValue, value as JsonValue) : undefined;\n\t\tthis.#publish(this.#tracker.prepareReplace({ v: value }), \"ops\", true, ops);\n\t}\n\n\t/**\n\t * Installs a migrated value and its schema (reload commit). The caller validated the value and the derivations\n\t * over it against every schema that will apply, so nothing is checked here. Subscribers receive a reset.\n\t */\n\treset(value: T, schema: TSchema): void {\n\t\tthis.schema = schema;\n\t\tthis.#publish(this.#tracker.prepareReplace({ v: value }), \"reset\", false);\n\t}\n\n\t/** Adopts this revision and every derived one, then queues all notifications (cell first, then derivations). */\n\t#publish(\n\t\tprepared: ReturnType<Tracker<Box<T>>[\"prepareReplace\"]>,\n\t\ttype: \"ops\" | \"reset\",\n\t\tvalidate = true,\n\t\tops?: readonly Op[],\n\t): void {\n\t\tif (prepared.ops.length === 0 && type === \"ops\") {\n\t\t\tthis.#tracker.adopt(prepared);\n\t\t\treturn;\n\t\t}\n\t\tconst value = prepared.value.v;\n\t\tlet candidates: Map<Derived<unknown>, unknown>;\n\t\ttry {\n\t\t\tif (validate) this.validate(value);\n\t\t\tcandidates = computeDependents(this as Source<unknown>, value, validate);\n\t\t} catch (error) {\n\t\t\tprepared.abort();\n\t\t\tthrow error;\n\t\t}\n\t\tholdPublications(() => {\n\t\t\tthis.#tracker.adopt(prepared);\n\t\t\tconst published = ops !== undefined && ops.length > 0 ? ops : unbox(prepared.ops, value);\n\t\t\tthis.fanout.emit(type === \"reset\" ? { type, value } : { type, ops: published, value });\n\t\t\tfor (const [derived, next] of candidates) derived.install(next);\n\t\t});\n\t}\n}\n\n/** True if `b` reuses at least one container of `a` at the same key: a new revision of the same state. */\nfunction sharesStructure(a: unknown, b: unknown): boolean {\n\tif (a === null || b === null || typeof a !== \"object\" || typeof b !== \"object\" || a === b) return false;\n\tif (Array.isArray(a) !== Array.isArray(b)) return false;\n\tfor (const [key, child] of Object.entries(b)) {\n\t\tif (child !== null && typeof child === \"object\" && (a as Record<string, unknown>)[key] === child) return true;\n\t}\n\treturn false;\n}\n\n/** Recomputes every transitive dependent of `changed` against candidate values and validates them. */\nfunction computeDependents(changed: Source<unknown>, value: unknown, validate = true): Map<Derived<unknown>, unknown> {\n\tconst pending = new Set<Derived<unknown>>();\n\tconst visit = (source: Source<unknown>): void => {\n\t\tfor (const derived of source.dependents) {\n\t\t\tif (pending.has(derived)) continue;\n\t\t\tpending.add(derived);\n\t\t\tvisit(derived);\n\t\t}\n\t};\n\tvisit(changed);\n\tconst values = new Map<Readable<unknown>, unknown>([[changed, value]]);\n\tconst result = new Map<Derived<unknown>, unknown>();\n\tfor (const derived of [...pending].sort((a, b) => a.seq - b.seq)) {\n\t\tconst next = derived.compute((source) => (values.has(source) ? values.get(source) : source.value));\n\t\tif (validate) derived.validate(next);\n\t\tvalues.set(derived, next);\n\t\tresult.set(derived, next);\n\t}\n\treturn result;\n}\n\nexport type Sources = readonly Readable<unknown>[];\nexport type SourceValues<S extends Sources> = { [K in keyof S]: S[K] extends Readable<infer T> ? T : never };\n\nconst isReadable = (value: unknown): value is Readable<unknown> =>\n\tvalue !== null &&\n\ttypeof value === \"object\" &&\n\ttypeof (value as Readable<unknown>).subscribe === \"function\" &&\n\t\"value\" in value;\n\n/**\n * A synchronous derivation. Sources are record cells/derivations (recomputed atomically with the write) or other\n * readables such as handle state members (recomputed when they publish). Subscribers receive diffs.\n */\nexport class Derived<T> extends Source<T> {\n\treadonly sources: readonly Readable<unknown>[];\n\t#fn: (...values: never[]) => unknown;\n\t#value: T;\n\t#external: (() => void)[] = [];\n\n\tconstructor(key: string, sources: Sources, fn: (...values: never[]) => unknown, options: SourceOptions) {\n\t\tsuper(key, options);\n\t\tthis.sources = sources.map((source) => {\n\t\t\tif (!isReadable(source)) throw new TypeError(`derive ${key}: sources must be readables`);\n\t\t\treturn source;\n\t\t});\n\t\tthis.#fn = fn;\n\t\tthis.#value = undefined as T;\n\t}\n\n\tget value(): T {\n\t\treturn this.#value;\n\t}\n\n\t/**\n\t * Computes the first value (or takes it from `precomputed`, a reload's validated dry run) and starts following\n\t * the sources (at install, never inside a factory).\n\t */\n\tattach(precomputed?: ReadonlyMap<unknown, unknown>): void {\n\t\tthis.#value = precomputed?.has(this) ? (precomputed.get(this) as T) : this.compute((source) => source.value);\n\t\tfor (const source of this.sources) {\n\t\t\tif (source instanceof Source) source.dependents.add(this as Derived<unknown>);\n\t\t\telse this.#external.push(source.subscribe(() => this.refresh()));\n\t\t}\n\t}\n\n\tdetach(): void {\n\t\tfor (const source of this.sources)\n\t\t\tif (source instanceof Source) source.dependents.delete(this as Derived<unknown>);\n\t\tfor (const unsubscribe of this.#external.splice(0)) unsubscribe();\n\t}\n\n\tcompute(read: (source: Readable<unknown>) => unknown, fn: (...values: never[]) => unknown = this.#fn): T {\n\t\tconst result: unknown = fn(...(this.sources.map(read) as never[]));\n\t\tif (result instanceof Promise) throw new TypeError(`derive ${this.key}: fn must be synchronous`);\n\t\treturn result as T;\n\t}\n\n\t/** Replaces the function without recomputing (reload commit, before migrated cells are installed). */\n\tsetFn(fn: (...values: never[]) => unknown): void {\n\t\tthis.#fn = fn;\n\t}\n\n\t/** Recomputes and republishes, including dependents. Errors are reported (the source write already happened). */\n\trefresh(): void {\n\t\ttry {\n\t\t\tconst next = this.compute((source) => source.value);\n\t\t\tconst dependents = computeDependents(this as Derived<unknown>, next);\n\t\t\tholdPublications(() => {\n\t\t\t\tthis.install(next);\n\t\t\t\tfor (const [derived, value] of dependents) derived.install(value);\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tthis.options.report(error);\n\t\t}\n\t}\n\n\tinstall(next: T): void {\n\t\tconst before = this.#value;\n\t\tthis.#value = next;\n\t\tconst ops: Op[] =\n\t\t\tbefore === undefined || next === undefined\n\t\t\t\t? [[\"r\", (next ?? null) as JsonValue]]\n\t\t\t\t: diffRevisions(before as JsonValue, next as JsonValue);\n\t\tif (ops.length > 0) this.fanout.emit({ type: \"ops\", ops, value: next });\n\t}\n}\n\nexport const isSource = (value: unknown): value is Cell<unknown> | Derived<unknown> => value instanceof Source;\n\n/** Thrown by placeholders used before activation finished. */\nexport const notReady = (what: string): ChordError => new ChordError(\"not_ready\", `${what} is not ready`);\n"]}
+{"version":3,"file":"cell.js","sourceRoot":"","sources":["../src/cell.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TSchema } from \"typebox\";\nimport { type Draft, diffRevisions, type JsonValue, type Op, type Tracker, track } from \"./delta/index.ts\";\nimport { ChordError } from \"./errors.ts\";\nimport { enqueue, holdPublications } from \"./publish.ts\";\nimport { assertValid } from \"./schema.ts\";\nimport type { Ctx, Readable, StateEvent } from \"./types.ts\";\n\nexport interface SourceOptions {\n\treadonly dev: boolean;\n\treadonly report: (error: unknown) => void;\n}\n\n/** Checks that `ctx` may write an object's cells now; throws otherwise. */\nexport type WriteGuard = (ctx: Ctx) => void;\n\nlet sequence = 0;\n\n/** Fans out values and delta events; listener errors are reported, not thrown to the writer. */\nclass Fanout<T> {\n\treadonly #values = new Set<(value: T) => void>();\n\treadonly #events = new Set<(event: StateEvent<T>) => void>();\n\treadonly #report: (error: unknown) => void;\n\n\tconstructor(report: (error: unknown) => void) {\n\t\tthis.#report = report;\n\t}\n\n\tsubscribe(listener: (value: T) => void, current: T): () => void {\n\t\tthis.#values.add(listener);\n\t\tthis.#call(listener, current);\n\t\treturn () => this.#values.delete(listener);\n\t}\n\n\tevents(listener: (event: StateEvent<T>) => void, current: T): () => void {\n\t\tthis.#events.add(listener);\n\t\tthis.#call(listener, { type: \"snap\", value: current });\n\t\treturn () => this.#events.delete(listener);\n\t}\n\n\t/**\n\t * Queues delivery to the listeners subscribed now. A listener that subscribes later already got this revision in\n\t * its snapshot; one that unsubscribes before delivery is skipped.\n\t */\n\temit(event: StateEvent<T>): void {\n\t\tconst events = [...this.#events];\n\t\tconst values = [...this.#values];\n\t\tenqueue(() => {\n\t\t\tfor (const listener of events) if (this.#events.has(listener)) this.#call(listener, event);\n\t\t\tfor (const listener of values) if (this.#values.has(listener)) this.#call(listener, event.value);\n\t\t});\n\t}\n\n\t#call<V>(listener: (value: V) => void, value: V): void {\n\t\ttry {\n\t\t\tlistener(value);\n\t\t} catch (error) {\n\t\t\tthis.#report(error);\n\t\t}\n\t}\n}\n\n/**\n * Whether a state source has its value (entry 8): a remote reference's member before its first snapshot has none, and\n * neither has anything derived from or forwarding it. Sources without this symbol always have their value.\n */\nexport const HYDRATION: unique symbol = Symbol(\"chord.hydration\");\n\nexport interface Hydration {\n\treadonly hydrated: boolean;\n\t/** Resolves once hydrated; rejects if the source ends first. */\n\twhenHydrated(): Promise<void>;\n}\n\n/** The hydration of a readable, or undefined for a source that always has its value. */\nexport function hydrationOf(value: unknown): Hydration | undefined {\n\tif (value === null || typeof value !== \"object\") return undefined;\n\treturn (value as { readonly [HYDRATION]?: Hydration })[HYDRATION];\n}\n\n/** The hydrations of `sources` that are not hydrated yet. */\nexport const unhydrated = (sources: Iterable<unknown>): Hydration[] =>\n\t[...sources].map(hydrationOf).filter((hydration): hydration is Hydration => hydration?.hydrated === false);\n\n/** An object-owned state source (cell or derivation). Writes recompute dependents atomically. */\nexport abstract class Source<T> implements Readable<T> {\n\treadonly key: string;\n\treadonly seq = ++sequence;\n\treadonly dependents = new Set<Derived<unknown>>();\n\t/** Schemas of remote state members currently exposing this source (checked per write in dev mode). */\n\tschemas: readonly TSchema[] = [];\n\tprotected readonly options: SourceOptions;\n\tprotected readonly fanout: Fanout<T>;\n\n\tconstructor(key: string, options: SourceOptions) {\n\t\tthis.key = key;\n\t\tthis.options = options;\n\t\tthis.fanout = new Fanout(options.report);\n\t}\n\n\tabstract get value(): T;\n\n\tsubscribe(listener: (value: T) => void): () => void {\n\t\treturn this.fanout.subscribe(listener, this.value);\n\t}\n\n\tevents(listener: (event: StateEvent<T>) => void): () => void {\n\t\treturn this.fanout.events(listener, this.value);\n\t}\n\n\t/** Per-write validation, dev mode only. */\n\tvalidate(value: unknown): void {\n\t\tif (!this.options.dev) return;\n\t\tfor (const schema of this.ownSchemas()) assertValid(\"state\", `state ${this.key}`, schema, value);\n\t\tfor (const schema of this.schemas) assertValid(\"state\", `state ${this.key}`, schema, value);\n\t}\n\n\tprotected ownSchemas(): readonly TSchema[] {\n\t\treturn [];\n\t}\n}\n\n/** The tracker tracks containers, so a cell tracks `{ v: value }` and strips the box from published ops. */\ninterface Box<T> {\n\tv: T;\n}\n\nfunction unbox(ops: readonly Op[], value: unknown): Op[] {\n\tconst result: Op[] = [];\n\tfor (const op of ops) {\n\t\tif (op[0] === \"r\" || op[1].length === 0) return [[\"r\", value as JsonValue]];\n\t\tconst path = op[1].slice(1);\n\t\tswitch (op[0]) {\n\t\t\tcase \"p\":\n\t\t\t\tresult.push([\"p\", path, op[2], op[3], op[4]]);\n\t\t\t\tbreak;\n\t\t\tcase \"m\":\n\t\t\t\tresult.push([\"m\", path, op[2]]);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\t// s/d/a/t on the value itself replace it.\n\t\t\t\tif (path.length === 0) return [[\"r\", value as JsonValue]];\n\t\t\t\tif (op[0] === \"d\") result.push([\"d\", path as [string | number, ...(string | number)[]]]);\n\t\t\t\telse result.push([op[0], path as [string | number, ...(string | number)[]], op[2]] as Op);\n\t\t}\n\t}\n\treturn result;\n}\n\n/** A state cell holding any JSON value, validated against its schema at creation and (dev mode) on writes. */\nexport class Cell<T> extends Source<T> {\n\t/** Replaced at a reload commit that changes the schema (state-version bump). */\n\tschema: TSchema;\n\t#tracker: Tracker<Box<T>>;\n\treadonly #guard: WriteGuard;\n\t/** False until `initialize` for a cell declared with `init`: reads and writes throw `not_ready`. */\n\t#initialized: boolean;\n\n\t/**\n\t * `initial` is always validated against `schema`; ownership moves to the cell. Without `initial`, the cell has no\n\t * value until `initialize` (a cell declared with `init`, filled before its object goes live).\n\t */\n\tconstructor(\n\t\tkey: string,\n\t\tschema: TSchema,\n\t\tinitial: { readonly value: T } | undefined,\n\t\tguard: WriteGuard,\n\t\toptions: SourceOptions,\n\t) {\n\t\tsuper(key, options);\n\t\tif (initial !== undefined) assertValid(\"state\", `initial value of state ${key}`, schema, initial.value);\n\t\tthis.schema = schema;\n\t\tthis.#tracker = track<Box<T>>({ v: (initial?.value ?? null) as T });\n\t\tthis.#guard = guard;\n\t\tthis.#initialized = initial !== undefined;\n\t}\n\n\t/** Sets the first value of a cell declared with `init` (validated; ownership moves to the cell). Publishes nothing. */\n\tinitialize(value: T): void {\n\t\tif (this.#initialized) throw new Error(`state ${this.key} is already initialized`);\n\t\tassertValid(\"state\", `initial value of state ${this.key}`, this.schema, value);\n\t\tthis.#tracker = track<Box<T>>({ v: value });\n\t\tthis.#initialized = true;\n\t}\n\n\tprotected override ownSchemas(): readonly TSchema[] {\n\t\treturn [this.schema];\n\t}\n\n\tget value(): T {\n\t\tif (!this.#initialized) throw notReady(`state ${this.key} (its init has not run)`);\n\t\treturn this.#tracker.value.v;\n\t}\n\n\t/**\n\t * Mutates a draft (only mutated paths are published), or returns a new value (`n => n + 1`). A returned value is\n\t * always validated against the schema. The draft is unusable after `fn` returns.\n\t */\n\tchange(ctx: Ctx, fn: (draft: Draft<T>) => T): void;\n\tchange(ctx: Ctx, fn: (draft: Draft<T>) => void): void;\n\tchange(ctx: Ctx, fn: (draft: Draft<T>) => unknown): void {\n\t\tthis.#guard(ctx);\n\t\tif (!this.#initialized) throw notReady(`state ${this.key} (its init has not run)`);\n\t\tconst change = this.#tracker.beginChange();\n\t\tlet prepared: ReturnType<typeof change.prepare>;\n\t\ttry {\n\t\t\tconst draft = change.state as Draft<Box<T>>;\n\t\t\tconst result: unknown = fn(draft.v as Draft<T>);\n\t\t\tif (result instanceof Promise) throw new TypeError(\"cell.change callbacks must be synchronous\");\n\t\t\tif (result !== undefined) {\n\t\t\t\tif (result !== draft.v) assertValid(\"state\", `state ${this.key}`, this.schema, result);\n\t\t\t\tdraft.v = result as Draft<T>;\n\t\t\t}\n\t\t\tprepared = change.prepare();\n\t\t} catch (error) {\n\t\t\tchange.abort();\n\t\t\tthrow error;\n\t\t}\n\t\tthis.#publish(prepared, \"ops\");\n\t}\n\n\t/**\n\t * Replaces the whole value. Ownership of `value` moves to the cell: never mutate it afterwards.\n\t *\n\t * Subscribers get a structural diff (`diffRevisions`) when `diff` is true, or by default when the new value shares\n\t * containers with the old one (a new immutable revision of the same state, e.g. mirrored from another store);\n\t * otherwise a single `r` op. The resulting value is the same either way; only the ops differ.\n\t */\n\treplace(ctx: Ctx, value: T, options: { readonly diff?: boolean } = {}): void {\n\t\tthis.#guard(ctx);\n\t\tif (!this.#initialized) throw notReady(`state ${this.key} (its init has not run)`);\n\t\tconst before = this.value;\n\t\tconst diff = options.diff ?? sharesStructure(before, value);\n\t\tconst ops = diff ? diffRevisions(before as JsonValue, value as JsonValue) : undefined;\n\t\tthis.#publish(this.#tracker.prepareReplace({ v: value }), \"ops\", true, ops);\n\t}\n\n\t/**\n\t * Installs a migrated value and its schema (reload commit). The caller validated the value and the derivations\n\t * over it against every schema that will apply, so nothing is checked here. Subscribers receive a reset.\n\t */\n\treset(value: T, schema: TSchema): void {\n\t\tthis.schema = schema;\n\t\tthis.#publish(this.#tracker.prepareReplace({ v: value }), \"reset\", false);\n\t}\n\n\t/** Adopts this revision and every derived one, then queues all notifications (cell first, then derivations). */\n\t#publish(\n\t\tprepared: ReturnType<Tracker<Box<T>>[\"prepareReplace\"]>,\n\t\ttype: \"ops\" | \"reset\",\n\t\tvalidate = true,\n\t\tops?: readonly Op[],\n\t): void {\n\t\tif (prepared.ops.length === 0 && type === \"ops\") {\n\t\t\tthis.#tracker.adopt(prepared);\n\t\t\treturn;\n\t\t}\n\t\tconst value = prepared.value.v;\n\t\tlet candidates: Map<Derived<unknown>, unknown>;\n\t\ttry {\n\t\t\tif (validate) this.validate(value);\n\t\t\tcandidates = computeDependents(this as Source<unknown>, value, validate);\n\t\t} catch (error) {\n\t\t\tprepared.abort();\n\t\t\tthrow error;\n\t\t}\n\t\tholdPublications(() => {\n\t\t\tthis.#tracker.adopt(prepared);\n\t\t\tconst published = ops !== undefined && ops.length > 0 ? ops : unbox(prepared.ops, value);\n\t\t\tthis.fanout.emit(type === \"reset\" ? { type, value } : { type, ops: published, value });\n\t\t\tfor (const [derived, next] of candidates) derived.install(next);\n\t\t});\n\t}\n}\n\n/** True if `b` reuses at least one container of `a` at the same key: a new revision of the same state. */\nfunction sharesStructure(a: unknown, b: unknown): boolean {\n\tif (a === null || b === null || typeof a !== \"object\" || typeof b !== \"object\" || a === b) return false;\n\tif (Array.isArray(a) !== Array.isArray(b)) return false;\n\tfor (const [key, child] of Object.entries(b)) {\n\t\tif (child !== null && typeof child === \"object\" && (a as Record<string, unknown>)[key] === child) return true;\n\t}\n\treturn false;\n}\n\n/** Recomputes every transitive dependent of `changed` against candidate values and validates them. */\nfunction computeDependents(changed: Source<unknown>, value: unknown, validate = true): Map<Derived<unknown>, unknown> {\n\tconst pending = new Set<Derived<unknown>>();\n\tconst visit = (source: Source<unknown>): void => {\n\t\tfor (const derived of source.dependents) {\n\t\t\tif (pending.has(derived)) continue;\n\t\t\tpending.add(derived);\n\t\t\tvisit(derived);\n\t\t}\n\t};\n\tvisit(changed);\n\tconst values = new Map<Readable<unknown>, unknown>([[changed, value]]);\n\tconst result = new Map<Derived<unknown>, unknown>();\n\tfor (const derived of [...pending].sort((a, b) => a.seq - b.seq)) {\n\t\tconst next = derived.compute((source) => (values.has(source) ? values.get(source) : source.value));\n\t\tif (validate) derived.validate(next);\n\t\tvalues.set(derived, next);\n\t\tresult.set(derived, next);\n\t}\n\treturn result;\n}\n\nexport type Sources = readonly Readable<unknown>[];\nexport type SourceValues<S extends Sources> = { [K in keyof S]: S[K] extends Readable<infer T> ? T : never };\n\nconst isReadable = (value: unknown): value is Readable<unknown> =>\n\tvalue !== null &&\n\ttypeof value === \"object\" &&\n\ttypeof (value as Readable<unknown>).subscribe === \"function\" &&\n\t\"value\" in value;\n\n/**\n * A synchronous derivation. Sources are object cells/derivations (recomputed atomically with the write) or other\n * readables such as reference state members (recomputed when they publish). Subscribers receive diffs.\n */\nexport class Derived<T> extends Source<T> {\n\treadonly sources: readonly Readable<unknown>[];\n\treadonly #fn: (...values: never[]) => unknown;\n\t#value: T;\n\t#external: (() => void)[] = [];\n\n\tconstructor(key: string, sources: Sources, fn: (...values: never[]) => unknown, options: SourceOptions) {\n\t\tsuper(key, options);\n\t\tthis.sources = sources.map((source) => {\n\t\t\tif (!isReadable(source)) throw new TypeError(`derive ${key}: sources must be readables`);\n\t\t\treturn source;\n\t\t});\n\t\tthis.#fn = fn;\n\t\tthis.#value = undefined as T;\n\t}\n\n\tget value(): T {\n\t\treturn this.#value;\n\t}\n\n\t/** Hydrated once every source is (a derivation over a remote member waits for its snapshot). */\n\tget [HYDRATION](): Hydration | undefined {\n\t\tconst pending = unhydrated(this.sources);\n\t\tif (pending.length === 0) return undefined;\n\t\treturn {\n\t\t\thydrated: false,\n\t\t\twhenHydrated: () => Promise.all(pending.map((hydration) => hydration.whenHydrated())).then(() => {}),\n\t\t};\n\t}\n\n\t/**\n\t * Computes the first value (or takes it from `precomputed`, a reload's validated dry run) and starts following\n\t * the sources (at install, never inside a factory).\n\t */\n\tattach(precomputed?: ReadonlyMap<unknown, unknown>): void {\n\t\tthis.#value = precomputed?.has(this) ? (precomputed.get(this) as T) : this.compute((source) => source.value);\n\t\tfor (const source of this.sources) {\n\t\t\tif (source instanceof Source) source.dependents.add(this as Derived<unknown>);\n\t\t\telse this.#external.push(source.subscribe(() => this.refresh()));\n\t\t}\n\t}\n\n\tdetach(): void {\n\t\tfor (const source of this.sources)\n\t\t\tif (source instanceof Source) source.dependents.delete(this as Derived<unknown>);\n\t\tfor (const unsubscribe of this.#external.splice(0)) unsubscribe();\n\t}\n\n\tcompute(read: (source: Readable<unknown>) => unknown): T {\n\t\tconst result: unknown = this.#fn(...(this.sources.map(read) as never[]));\n\t\tif (result instanceof Promise) throw new TypeError(`derive ${this.key}: fn must be synchronous`);\n\t\treturn result as T;\n\t}\n\n\t/** Recomputes and republishes, including dependents. Errors are reported (the source write already happened). */\n\trefresh(): void {\n\t\ttry {\n\t\t\tconst next = this.compute((source) => source.value);\n\t\t\tconst dependents = computeDependents(this as Derived<unknown>, next);\n\t\t\tholdPublications(() => {\n\t\t\t\tthis.install(next);\n\t\t\t\tfor (const [derived, value] of dependents) derived.install(value);\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tthis.options.report(error);\n\t\t}\n\t}\n\n\tinstall(next: T): void {\n\t\tconst before = this.#value;\n\t\tthis.#value = next;\n\t\tconst ops: Op[] =\n\t\t\tbefore === undefined || next === undefined\n\t\t\t\t? [[\"r\", (next ?? null) as JsonValue]]\n\t\t\t\t: diffRevisions(before as JsonValue, next as JsonValue);\n\t\tif (ops.length > 0) this.fanout.emit({ type: \"ops\", ops, value: next });\n\t}\n}\n\nexport const isSource = (value: unknown): value is Cell<unknown> | Derived<unknown> => value instanceof Source;\n\n/** Thrown by placeholders used before activation finished. */\nexport const notReady = (what: string): ChordError => new ChordError(\"not_ready\", `${what} is not ready`);\n"]}

package/dist/cluster.d.ts

@@ -4,9 +4,10 @@ import { type ReloadOptions, type ReloadReport } from "./reload.ts";
 import { type Frame } from "./wire.ts";
 export declare function runClusterReload(host: HostImpl, plugins: readonly PluginRef[], options: ReloadOptions): Promise<ReloadReport>;
 /**
- * Brings a child that connected behind this host's epoch up to it: a reload of the child's modules (the ones
- * cluster reloads gave its name) to this host's current epoch, prepared, voted and committed like a cluster reload.
- * Until then the child is fenced: nothing is routed to it. The child's old code is never relabeled as a newer epoch.
+ * Brings a child that connected behind this host's code version up to it: a reload of the child's modules (the ones
+ * cluster reloads gave its name) to this host's current code version, prepared, voted and committed like a cluster
+ * reload. Until then the child is fenced: nothing is routed to it. The child's old code is never relabeled as a newer
+ * code version.
  */
 export declare function reconcileChild(host: HostImpl, connection: Connection): Promise<void>;
 /**

package/dist/cluster.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../src/cluster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAuC,KAAK,aAAa,EAAE,KAAK,YAAY,EAAe,MAAM,aAAa,CAAC;AACtH,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,WAAW,CAAC;AAkCpD,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAkEvB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CA0B1F;AAUD;;;;GAIG;AACH,qBAAa,YAAY;;IAIxB,YAAY,IAAI,EAAE,QAAQ,EAEzB;IAED,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;QAAE,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;KAAE,CAAC,GAAG,IAAI,CAyBjG;IAED,kGAAkG;IAClG,UAAU,IAAI,IAAI,CAEjB;CAwCD"}
+{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../src/cluster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAuC,KAAK,aAAa,EAAE,KAAK,YAAY,EAAe,MAAM,aAAa,CAAC;AACtH,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,WAAW,CAAC;AAkCpD,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,CAAC,CAwEvB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC1F;AAUD;;;;GAIG;AACH,qBAAa,YAAY;;IAIxB,YAAY,IAAI,EAAE,QAAQ,EAEzB;IAED,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;QAAE,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;KAAE,CAAC,GAAG,IAAI,CAyBjG;IAED,kGAAkG;IAClG,UAAU,IAAI,IAAI,CAEjB;CAwCD"}