@earendil-works/chord 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## [1.5.1] - 2026-11-09
+
+### Breaking Changes
+
+- Chord v2 is the package's root: `@earendil-works/chord` exports v2 (was `@earendil-works/chord/next`). Chord v1 moved unchanged to `@earendil-works/chord/old` (was the root) and `@earendil-works/chord/old/node` (was `/node`); it stays until p2 runs on v2. The foundations v1's root re-exported have their own subpaths: `@earendil-works/chord/json` (`JsonValue`, `JsonRepresentation`, `copyJson`, `isJsonValue`) and `@earendil-works/chord/watch` (`Watch`, `NativeWatch` and the watch types), beside `/context` and `/delta`. Migration: imports of `@earendil-works/chord/next` drop `/next`; v1's imports of `@earendil-works/chord` become `@earendil-works/chord/old`, and `/node` becomes `/old/node`; imports of `Context`, `Draft`, `JsonValue`, `copyJson` or the watch types from the root move to `/context`, `/delta`, `/json` and `/watch`. In the repository, v2's `src/next` is now `src`, `src/next-node` is `src/node`, `src/next-web`, `src/next-react` and `src/next-tui` are `src/web`, `src/react` and `src/tui`, v1 is in `src/old`, and tests and docs moved likewise (`test/next` to `test`, `docs/next` to `docs`, v1's to `test/old` and `docs/old`).
+- Chord v1 (`@earendil-works/chord/old`, `@earendil-works/chord/old/node`) removed, with its tests and docs (`src/old`, `test/old`, `docs/old`). Apps still on v1 pin `@earendil-works/chord@1.5.0`.
+- Chord v2's `startWorker` no longer takes `telemetry` (it was added unreleased in slice 9): with a telemetry store on the server, the kit's workers send their spans and metrics to it, and no worker opens the store's file. `startServer`'s `telemetry` is a store with `ingest` (`createSqliteTelemetry`'s). Migration: drop `telemetry` from `startWorker` and the store's path from the worker's environment.
+- Chord v2's `createWorkers` returns a promise and rejects when the worker base does not build (decision "Workers start from the base code the server booted with"): it bundles the worker kind's `entry` and the base code it imports once with esbuild (`--conditions` from `execArgv`; Node builtins and packages resolved under `node_modules` external, by their files; workspace packages linked into `node_modules` inlined; `import.meta.url` and `__dirname` naming each source file; split at each dynamic `import()` esbuild can follow, so a lazily imported module and the packages it imports load only when the worker imports it; inline source maps, forked with `--enable-source-maps`) into a private temporary directory removed at `close`, and forks every worker from that snapshot: an edit of the app's source while the server runs (an agent half way through a change) no longer reaches workers forked later, which kept failing to start until the edit was fixed; a server restart applies it. `workers.inputs` lists the files the base was built from; the app kit's `startServer` builds each worker kind's base before loading (a broken one rejects the start, everything closed) and marks `base` when one of those files changes (it marked only the entry).
+- Chord v2's `host.reload` restarts every live object of a changed plugin; the pure swap in place is removed (decision "Reload restarts every affected object; old work finishes on old code"). `ReloadReport.objects` no longer has the kind `swapped`: a live object is `restarted`, or `parked { cause }` when its successor's recorded requests find a failure. Old work (the calls running at the commit and every call they cause through their `ctx`, and calls marked `old` over a trusted link) runs on the object's open old attempt; new calls wait at the gate for the new code. The old attempt is sealed once that work drained and its successor's requests are ready, bounded by the new host option `reloadDrainTimeout` (default 5 s, at most `closeTimeout`; the app kit's `timeouts.reloadDrainTimeout` reaches the server and every worker): a method still running then is cut `released` and reported `drain_timeout`. A wait of old work that its own old attempt blocks fails at once with `unavailable/reload_cycle`; a getter of old work for a version the new code dropped binds the open old attempt or fails at once. `call` gains `old` (binary flag `0x20`, the text codec's seventh element; a relay drops it from untrusted links; `PROTOCOL_VERSION` stays 1); `waiting` causes keep the reason `unavailable/version`. Consequences: a reference shows `loading` briefly after every reload of its object (it stayed bound across a swap); a value read right after `host.reload` resolves may still be the old code's; an in-memory job run ends `aborted { reload }` at every reload of its object (it finished on its old code across a swap); routines restart when the successor goes live. Migration: drop `swapped` from code reading the report; open a root inside a method with `withoutAbortSignal(ctx)`, not a fresh context, so its calls are old work; move work longer than `reloadDrainTimeout` into jobs.
+
+### Added
+
+- The sync layer (experimental): `@earendil-works/chord/sync` moves a store between devices through a remote, from the store's outbox (`openStore(backend, ctx, { outbox: true })`). Every device continues a store as its own: `uploadSession()` uploads the outbox commits after the last sequence the copy shares with the remote as one gzip batch into a slot the remote creates once per start sequence, trims the outbox through what the remote acknowledged, and reports a copy as `diverged` when another device's upload created that slot first, or `behind` when its head fell below what it had uploaded. A store whose outbox does not reach back to its first commit starts with an archive slot (`store.export()`). `pullSession()` catches a copy up through `applyBatch()`, resumes an interrupted pull, or restores into an empty backend (`importStore()` for an archive); `foldSession()` folds the history into a snapshot archive, keeping folded slots taken. `FlushScheduler` decides when to upload. `FileSystemSyncRemote`, a remote in a directory, and `FileSyncStateStore`, sync state in a directory, are for development and tests; they take their file operations as a `SyncFileSystem` (Pi Durable's environments fit it as they are).
+- Chord v2's Node components and client surfaces are exported: `@earendil-works/chord/http`, `/workers`, `/workers/child` (the worker's side, `workerMain` and `processLock`, without esbuild), `/plugins`, `/plugins/runtime` and `/app`; `/surfaces` (the web and terminal surfaces' server side), `/web`, `/react`, `/tui` and `/tui/launcher`.
+- Chord v2's plugins component gains the plugin model (slice 12): `createPlugins({ api: { name, versions } })` checks every import of the app's versioned API (`@acme/app/v3`, per-kind modules such as `@acme/app/v3/web`): an unlisted version, another kind's module, two versions in one facet and a direct import of Chord are build errors naming the file and line. Roots may be `{ path, required }`: a required root's plugin failing at `load` rejects it with a `PluginError` after the load settled. Files named `<name>.<kind>.<ext>` (`contract.web.tsx`) are of that kind, refused in facets of another kind with the chain of imports named. Single-file plugins (`hello.server.ts` at a root's top, grouped by name, host packages only). `installPlugin({ git, ref } | { npm, version }, root, ctx)` installs plugins from git (a shallow clone of a branch, tag or commit; a repository of several plugins too) or npm; a package lists the plugin folders it provides in its `package.json` (`"chord": { "plugins": ["./notes", "plugins/*", "!plugins/draft"] }`), used by discovery and `installPlugin` (without it: one plugin when the package's top has facet files, else its subfolders with a `package.json`). `testPlugin(dir, { kind, modules, stubs, principal }, ctx)` builds a plugin as production does and loads it on an in-memory host beside stub facets, collecting its contributions to registries nobody serves and listing the contracts it waits for. Agents' guide: `docs/plugin-authoring.md`.
+- Chord v2 gains the app kit (slice 13, `@earendil-works/chord/app`): `startServer<P>({ name, dataDir?, root?, listen?, api, kinds, principal: { server, worker?, owner }, workers?, files?, install?, onError }, ctx)` lays out the data directory (`server/store.sqlite`, `workers/<kind>/<address>/`, `plugins/`, `logs/`, `owner-token`; one server per data directory), creates the server's store and host, HTTP, one workers component per worker kind and the plugins component over the app's required root and the user's root, and loads the server's plugins with the kit's objects; `startWorker({ api, kinds, busy?, onError })` is a worker's entry (its directory and store, the link to the server first, its plugins). The start-data objects `AppInfo` (with the owner) and `WorkerInfo` serve process values to plugins. Sessions (`Sessions`: `issue`, `verify`, `revoke`, `list`; tokens kept as SHA-256 hashes, compared in constant time; persisted ones end after 400 days unused and their browser cookie is renewed daily while used, ephemeral ones live in memory, at most `limits.ephemeralSessions`) authenticate a signed `HttpOnly`, `SameSite=Strict` cookie or `Authorization: Bearer`; a one-time owner link per start (`app.ownerLink()`, the token in the URL's fragment, single use, 10 minutes), an owner token file (mode 0600, written atomically) and device pairing (`POST /_chord/pair`, owner approval, a poll returning the token once; bounded in all and per client address) sign the owner in: `principal.owner`, any principal of the app (strict JSON, not the server's), recognized by canonical JSON. The data directory, its stores and secret files are made private (0700, 0600) at every start; the home directory, a file system's root and another user's directory are refused. `Files` per host: small and chunked writes at a stored offset, ranged reads, a watchable index, caps, at most `limits.uploads` uploads under way. `app.exportData(address, path, ctx)` and `app.importData(archive, address, ctx)` move the data a worker created (its store and files) as a tar without stopping anything: a running worker writes its own store at one consistent point, else the server reads it under the worker's process lock (import refusing an existing address, another app's archive, every path leaving the target, and archives past `limits.importBytes` or `limits.importEntries`). `app.applyChanges(ctx)` and `app.plugins.install(source, ctx)`. Optional plugins as exported facets: `defineUsers(profile)`, `inviteFacet()`, `ephemeralLoginFacet()`.
+- Chord v2 gains web and terminal surfaces (slice 11): `webSurface` and `tuiSurface` (`@earendil-works/chord/surfaces`) build a client kind's base bundle from the app's entry at start (content-hashed, served forever) and publish its plugins' facets as scripts that register themselves (`chordFacet("<plugin>", "<digest>", function (require, module, exports) {…})`) and one combined file, with `WebScripts` and `TuiScripts` showing the current set (a rollout step publishes without waiting for clients) and the page served through the app's own template (`PageAssets`, `pageScripts`). `startPage` (`@earendil-works/chord/web`) runs a page's client host: the connection loop (`keepConnected`: 250 ms doubling to 5 s, wakes, silent sockets, `canRetry`), plugins applied in place on a new set (a failed one keeps its old facet), a reload when the server's base bundle changed, and the active theme as CSS variables. React bindings (`@earendil-works/chord/react`): `HostProvider`, `useHold`, `useWatch`, `useRegistry`, `useRefState` (React is an optional peer dependency). The terminal: `startTerminal` (`@earendil-works/chord/tui/launcher`) signs in with a token, a token file or device pairing and runs the app's terminal code always in a sandbox (a child process on pipes with Node's permission model: no file system, terminal, processes, workers, network or SQLite; Node 26.5.1 or later), filtering its output, relaying its link and confirming its actions (copy, open a URL, attach a file the user names); `startTerminalRuntime` and `TuiScope` (`@earendil-works/chord/tui`) inside it. Themes: the `Themes` registry, `ThemeChoice` (one dark and one light pick per principal), `followActiveTheme`, `themeVariables`, `terminalColor`. `startServer` gains `web` and `tui`. Plugin builds scope `*.module.css` files per plugin and file. Ephemeral sessions end with their client's last link (after a minute). The HTTP component's links endpoint gains an `opened` hook.
+- Chord v2's `HttpRequest` gains `remoteAddress`, the peer's address as the listener knows it (for limits per client).
+- Chord v2's HTTP component gains `readSignedCookie(request, name, secret)`: `readCookie`'s value with its signed expiry, for renewing a cookie before it expires.
+- Chord v2's root exports `invalid(reason, message, details?)` and the new `forbidden(message, details?)`, the `ChordError`s a plugin throws for arguments or params it refuses (`invalid/args`, `invalid/params`) and for a principal it refuses (`forbidden`); an app's API re-exports them, and the caller gets the same `{ code, reason }` as from Chord's own checks.
+- Chord v2's React bindings gain `usePageState(key, initial)`, `useState`'s pair with the value kept by the page's host under `key` instead of the component: a component of a reloaded web plugin is a new function and remounts (its `useState` starts over), and page state is what survives (a half-typed message, a scroll position); any value, never on the wire, gone with the page. `TuiScope` gains `pageState(key, initial)` on the same per-host store, its changes calling the scope's `changed`.
+- Chord v2 reports mistakes that waited silently through `onError` (decision "Mistakes that wait are reported at once"): `unbound_long { waitingFor, error, since }`, a request waiting unbound (a type or registry not served here, not at its version, a registry whose first `compose` threw) once after 5 s, on one timer per host (it keeps waiting until its `readyTimeout`); `registry_undeclared { registry, plugins }`, a registry with contributions and no provider at a publication (`load`, a reload's commit) or when a host-lifetime object's contributions enter, naming the contributing plugins, again only once they change; `transaction_cancelled { object, error }`, a document change or transaction that did not commit because the context it was started with ended first (a root whose `fn` returned, a caller that cancelled, its object's end), besides rejecting.
+- Chord v2 gains live queries: `self.query(table, q, limit)` in the factory of a table's owner is a watchable of the query's rows (at most `limit`, in its order), usable as a state member and a derive source. Chord runs it before the object goes live and again inside the commit step of every commit of the object that writes the table, publishing only the diff in that commit's batch; a commit writing no table with a live query runs nothing (`chord.query.runs` counts the runs). Only the object's own tables; the limit is required (`invalid/args` at declaration). A run that fails (a row the code cannot read) is a failed member, reported once as the new `HostError` `query_failed { object, table, error }`, and heals at the next good run. Each touching commit runs the query once (100 rows: about 60 µs, 80 µs watched): not for tables written hundreds of times a second.
+- Chord v2 gains messages and languages in the app kit (design §23): `defineMessages(namespace, { en: {...}, de: {...} })` returns a typed `t(key, ...args)` (the first catalog types the others: a missing key, an unknown one or a wrong argument is a type error; values are strings or functions), `t.message(key, ...args)` builds a message as data (`MessageData`, `{ namespace, key, params }`, for state members typed with `MessageSchema`), `t.render(message)` renders one (a foreign namespace or an unknown key from a link shows the key), `t.translations` lists its catalogs, and `MessagesOf<typeof t>` types a translation. The `Translations` registry takes a list of `{ namespace, locale, messages, override? }` per contributor (one catalog per namespace and locale: the first by plugin name wins, reported; `override: true` wins); a missing key falls back down the locale's chain (`pt-BR`, `pt`) to the first catalog, reported once. `LocaleChoice` keeps one locale per principal on the server (the theme choice's store, now shared as one preference); a client follows it with `followActiveLanguage`, defaulting to `navigator.languages` on a page and the system locale in the terminal (`startTerminal`'s `locales`), matched against the catalogs, switched live. `useMessages(t)` (`/react`) and `TuiScope.messages(t)` (`/tui`) render in the host's language and re-render or redraw on a change; `startPage` sets `lang` and `dir` on the page (`followLanguage`, `/web`); `formatTime` and `formatNumber` use `Intl` in the language being rendered. The kit serves `Translations` on the server, workers, pages and terminals and `LocaleChoice` on the server; client errors gain `{ kind: "messages", report }`.
+
+- Chord v2 gains telemetry across hosts (slice 9): `CHORD_TELEMETRY_SCHEMA` (root export) types every span, event and metric Chord records. With a host adapter (`createHost({ telemetry })`), calls (`chord.call`), methods (`chord.method`, local and remote), relays (`chord.relay`), holds (`chord.hold`), activations (`chord.activate`, ending `live`, `failed`, `parked` or `ended`, with `chord.retry` and `chord.park` events), natives' opens and closes, `load`, `reload` (a `chord.reload.fate` event per object), resolves (a worker start included), revocations, routine calls, job phases (`intent`, `run`, `finish`: a persisted run resumed in a new attempt or process stays under its stored carrier) and HTTP requests (`chord.http`: method, route pattern, status, never the path) are spans; failures carry a fixed category and the message cut at 500 characters, a cancel is no error; commits are `chord.commit { documents, ops, rows, duration }` events of the span they ran under. `hold` and `call` carry the caller's trace carrier (`trace`, at most 8 keys, keys and values of at most 256 characters of printable ASCII, else the message fails the message schema and the link closes; the binary codec's kind byte flag `0x40`), relays forward their own span's, and the provider runs the method under it (an absent or unknown carrier: the adapter's root); a reference's carrier rides on its first hold only, a re-hold after a reconnect being a fresh root linked to it. A hold's `type` and its address's `kind` are bounded at 256 characters by the message schema, and span attributes a peer chose at 256 characters. `ctx.trace(name, attributes, fn)` runs `fn` in a child span with a child ctx. Host-wide metrics: `chord.link.bytes`, `chord.link.state_messages`, `chord.commit.duration`, `chord.calls.in_flight`, `chord.holds.active`, `chord.links.open`, `chord.park.duration`, `chord.backpressure.wait`. Without an adapter nothing is started, built or sent: a call over a link costs what it did before. `createHttp`, `startServer` and `startWorker` take a `telemetry` adapter (`createHttp` continues a W3C `traceparent` only from a request a contributed relay verified: an app's proxy must strip it from browsers). A host with an adapter counts the cost counters of its links' and root scopes' work on it also when the app passed a context without a span. The SQLite telemetry store keeps spans of one microsecond in the order they started.
+- Chord v2's telemetry closes four gaps found writing the tutorial: `chord.commit` counts the table rows a commit's writes changed (`rows`; a commit writing only rows no longer reads `documents=0 ops=0`); every span Chord starts, `ctx.trace`'s too, carries `chord.host`, the host's address key or `client` without an address (`Host` gains `address`); the SQLite telemetry store keeps span times in whole microseconds from pi-telemetry's `telemetryNow` (store version 2: a recorder migrates a version 1 file in place, its rows kept); and `openTelemetryStore(path)` (new subpath `@earendil-works/chord/telemetry-sqlite/node`) reads a store file read-only, implementing `TelemetryStore` only, refusing a file without a store or with one of another version. `openNodeSqliteDatabase` takes `mode: "read-only"`.
+- Chord v2's telemetry is stored in one place, the server (decisions "Telemetry from browser pages", "The server is the one place telemetry is stored", "Who a span was for"). Pages and workers record in memory with Chord's `TelemetryRecorder` (the SQLite store's own recorder too) and send finished spans in batches over their link to the server's `PageTelemetry` and `WorkerTelemetry` (`ingest(batch)`), which the app kit serves when `startServer` has a telemetry store; the store gains `ingest` (never replacing a stored span). `startPage({ telemetry: true })` records the page and sends its spans every 3 s and when hidden; the server checks a page's batch strictly (at most 100 spans, every field bounded, ids printable ASCII, no control characters), keeps only spans under the page's own ids (`browser:<its incarnation>:<n>`), caps them at 1,200 per page and minute, marks them `chord.host: browser` and stamps them with the principal of their link (a page's own `chord.*` attributes are dropped). A worker sends its spans and metrics every second, stamped with its host. `host.root(fn, ctx, { trace: { name, attributes } })` runs `fn` in a new root span (a click). Method and call spans record whom they were for: `chord.principal` (the principal key) by default, or what the host's new `principalAttributes` hook returns (`createHost`, `startServer`, `startWorker`). `ServeOptions.untraced` serves a type whose calls start no method span. `Host` gains `incarnation` and `principalAttributes`.
+- Chord v2's `TuiScope` gains `optimistic(read)`: the reader and `show(value, call)`, which shows `value` in place of the reader's until every call shown settled (React's `useOptimistic` for terminal UIs). The guide's "Optimistic UI" shows React's `useOptimistic` and `startTransition` over a Chord call, what it relies on and what it does not cover; example `63-optimistic-answers.ts`.
+
+### Changed
+
+- Chord v2's HTTP component denies by default (slice 13): a request or plugin socket without a principal gets 401 before plugin code runs unless its route or socket is marked `public: true` (`{ handler, public: true }`; a `crossSite` route is public), and the `/chord` links endpoint refuses requests without a principal.
+- Chord v2's `host.get`, `host.hold`, `host.registry` and a root's `ctx.get` on a host whose `load` was not called throw `not_ready` at once ("call host.load first") instead of waiting for a publication; a client with nothing to load calls `load([])`. Holds arriving on the host's links before `load` still wait for its publication. The HTTP component answers a request before `load` 503 at once.
+- Chord v2's `host.load` and `host.reload` throw for a plugin name that is no npm package name, before they change anything (it was listed in the report's `failed`).
+- Chord v2 plugins import each other by relative path within a root (copied into the importer's script) and across repositories by package name through the package's `exports`, pinned in `dependencies`; slice 10's imports by plugin name (`@app/notes/contract`) are removed, and a relative path leaving the root is a build error.
+- Chord v2's `host.reload` starts the objects' fates dependents first: removals, then the other fates in the reverse of the order the objects went live (the report keeps its order). A pure dependent reloaded with its provider (a view over a store in one plugin) binds the provider while it is still live and swaps instead of parking until the provider's new instance is live: its contributions are replaced in one batch and its holds over links never show `loading`. A dependent still parks when its new code needs the provider's new version, when its provider went live after it, or when it needs something not live.
+- Chord v2 keeps calls over a link across a `loading` unbind (decision "Calls in flight survive a `loading` unbind"): a hold whose object restarts, whose swap parks or whose live failure retries no longer answers its calls in flight `unavailable`; each is answered by the instance it already runs on or by the new instance once it is live (or by its failure, `readyTimeout`, its end), and calls a consumer sent by the old names before it saw the `loading` wait the same way instead of `not_ready`. A `failed` unbind (a removed type, a dropped version, a swap parked on a failed dependency) still rejects them.
+- Chord v2's store writes the commits queued behind a running commit step in one backend transaction (group commit, decision S18): each keeps its own seq, outbox commit and adoption in queue order, the metadata is written once; a refusal in a group rolls it back and runs its commits one by one, so only the refusing commit is refused.
+- Chord v2 sends a call's answer after its state (decision "A call's answer follows its state"): before a host sends a `result` or `error`, its own or one it forwards as a relay, it sends the origin's state still waiting for a slot of the window (one `state` message, past the window if it is full; acknowledged like any other). A call settling in a page now finds every change its answering host, and a relaying host, committed before answering, so an optimistic value is replaced by the real one instead of flickering back to the old value. Nothing extra is sent when nothing waits.
+
+### Fixed
+
+- Chord v2's workers on macOS and the BSDs: a worker killed by a signal (the grace's or the start timer's SIGKILL) left its lock's socket file, and every later start of its address failed with `... is a stale lock file`, `retry` too, until the file was removed by hand. The workers component now removes a lock socket file nobody accepts on before each start and after a child's exit by a signal.
+- Chord v2's `processLock` on macOS spun until its context ended when a regular file sat at the lock's path (`ENOTSOCK`); it now fails closed naming the file, as for a socket file nobody listens on.
+- Chord v2's heartbeat closed every link after the process had slept (a laptop's sleep) or blocked its event loop, before reading what the peer had sent meanwhile. Time the process did not run no longer counts as silence: after such a pause each open link pings at once and closes only if its peer stays silent for `close - ping` (15 s by default).
+- Chord v2's workers no longer leave an address failed when a running worker loses its link (the heartbeat, a protocol error, the worker closing its own link): the worker is stopped, `worker_link_lost { address, error }` is reported, and its holders get a new worker. A second lost link within a minute of the last recovery still fails the address (public error `worker lost its link`). Crashes, `fatal`s and failed starts still stay failed until `retry` or a rollout.
+- Chord v2's objects no longer answer a call `not_ready` during a reload while the caller sees them `live`: a call over a link to an object whose swap had parked (its new code waiting for a dependency) or whose restart had drained, sent while its hold was still bound to the old instance, got `not_ready: ... not live yet`. Such a call now waits for the object's new attempt (live, failed or ended), bounded by `readyTimeout` (`unavailable/park_timeout`); a parked attempt showing `failed { waiting }` rejects it with that cause; it stays when the hold then leaves the old instance with `loading`.
+- Fixed oversized WebSocket frames sometimes closing with code `1006` instead of `1009`, notably on macOS. Protocol errors now finish their close handshake instead of having the socket terminated before the close frame reaches the peer.
+- Fixed terminal sandbox startup when the temporary directory has a symlinked ancestor, including macOS's default temporary directory, without expanding its file permissions.
+
 ## [1.5.0] - 2026-11-02
 
 ### Breaking Changes

package/README.md

@@ -1,74 +1,83 @@
 # @earendil-works/chord
 
-Chord builds applications out of **objects** that live in several processes (a server, workers, browser tabs) and can be **hot reloaded** while they run.
+Chord builds applications out of **objects** that live in several processes (a server, workers, browser tabs) and keep running while their plugins are **reloaded**.
 
-- 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.
+- An **object type** is a contract: a name, params that select the instance, the host it lives on, its members (state and methods) and a version. Contracts are runtime values described with JSON Schema, written with the builders of `@earendil-works/pi-schema`.
+- A **facet** is a plugin's declarations for one host: the types it serves and its contributions to registries. A factory only declares; Chord activates.
+- Everyone gets a **reference**, never the object. A reference is live and hydrated once its `get` resolves, works the same locally and across links, and keeps its object alive.
+- **Documents** are named JSON values an object owns, written in transactions and persisted in Chord's store; **derives** compute values from watchables; **jobs** are owned work that outlives the call that started it.
+- Every call has a **principal**: links stamp it, the app types it, and objects are kept per principal key.
+- A **reload** swaps a plugin's code inside the running app, rolled out host by host: hosts keep running, data, connections and running work survive where they can.
 
-Contracts are runtime values described with JSON Schema, written with the builders of `@earendil-works/pi-schema` (any JSON Schema object works; `format` is an annotation, never checked). Hosts exchange JSON frames over links: in memory, a Node IPC channel, or a WebSocket.
+The design, the rule book for all of this, is [docs/design.md](docs/design.md).
 
 ## Entry points
 
 | Import | Contents | Runs in |
 |--------|----------|---------|
-| `@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`, `replicatedState` with its types, and the watch types `WatchHandle`, `NativeWatchHandle`, `WatchCall`, `NativeWatchCall`, and `WatchEnd` with their implementations `Watch` and `NativeWatch`. | Node and browsers |
-| `@earendil-works/chord/node` | Child host processes: `createHostManager`, `forkDriver`, `childControl`, `processLock`; the facet module loader `nodeLoader`. | Node |
+| `@earendil-works/chord` | Contracts (`local`, `remote`, `method`, the schema builders), errors (`ChordError`, `isChordError`), hosts and facets (`createHost`, `defineFacet`), documents (`defineState`), derives and natives (`constant`, `mapShared`), routines and jobs (`defineJob`), links (`memoryLinkPair`, `ipcLink`, `webSocketLink`), registries (`defineRegistry`), the store (`openStore`, `defineTable`, queries, export and import), and the client surfaces' shared part (`Themes`, `ThemeChoice`, `WebScripts`, `TuiScripts`, messages and languages: `defineMessages`, `Translations`, `LocaleChoice`, `formatTime`, `formatNumber`). | Node and browsers |
+| `@earendil-works/chord/http` | HTTP: a Web-standard `fetch` handler (`createHttp`) built from the routes, wraps and sockets plugins contribute to the registry `Http`, authenticators (`Authenticators`), responses as descriptions, a security baseline on by default, Chord's Node listener and `nodeRequest`, the links endpoint. | Node |
+| `@earendil-works/chord/workers` | Workers: `createWorkers` runs a forked worker per address of a host kind, started on demand and stopped when idle; `workerMain` is a worker's entry; `processLock`. | Node |
+| `@earendil-works/chord/workers/child` | The worker's side alone: `workerMain` and `processLock`, without esbuild (a worker entry imports this). | Node |
+| `@earendil-works/chord/plugins` | Plugins: discovery, builds with esbuild (`buildFacet`), evaluation, the watcher, rollouts, `createPlugins`, `installPlugin`, `testPlugin`, `pluginFile`. | Node |
+| `@earendil-works/chord/plugins/runtime` | `createPluginRuntime`: loads built plugins without esbuild (a worker's side). | Node |
+| `@earendil-works/chord/app` | The app kit: `startServer`, `startWorker`, the start-data objects, sessions and the owner's sign-in, device pairing, files, export and import per address, optional plugins (users, invites, ephemeral login). | Node |
+| `@earendil-works/chord/surfaces` | The client surfaces' server side: `webSurface` (base bundle, plugin scripts, the page) and `tuiSurface` (the terminal surface). | Node |
+| `@earendil-works/chord/web` | The web surface's browser side: `startPage` in the app's web entry, `followThemes`, `followLanguage`. | Browsers |
+| `@earendil-works/chord/react` | Optional React bindings: `HostProvider`, `useHold`, `useWatch`, `useRefState`, `useRegistry`, `usePageState`, `useMessages`, `watchStore`. | Browsers |
+| `@earendil-works/chord/tui` | The terminal surface's sandbox side: `startTerminalRuntime` in the app's terminal entry, `BridgeTerminal`, `TerminalTheme`, `TuiScope`. | Node (sandboxed) |
+| `@earendil-works/chord/tui/launcher` | The terminal launcher, the trusted side of a terminal client: `startTerminal`, `requireSandboxNode`. | Node |
 | `@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/json` | `JsonValue`, `JsonRepresentation`, `copyJson`, `isJsonValue`. | Node and browsers |
+| `@earendil-works/chord/watch` | The watch types `Watchable`, `WatchHandle`, `NativeWatchable`, `NativeWatchHandle`, `WatchCall`, `NativeWatchCall`, and `WatchEnd`, with their implementations `Watch` and `NativeWatch`. | 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 |
+| `@earendil-works/chord/sync` | Sync (experimental): a store's outbox commits uploaded to a remote into slots created once (`uploadSession`), applied on another copy (`pullSession`), folded into snapshots (`foldSession`); `FlushScheduler`; the remote and sync-state interfaces, and directory-backed ones over a `SyncFileSystem` for development and tests. | Node and browsers |
+
+`esbuild` (for `/plugins`, `/surfaces` and `/workers`), `ws` (for `/http` and `/tui/launcher`) and `react` (for `/react`) are optional peer dependencies, imported only there; `/app` uses all but `react`.
 
 ## Quick start
 
 ```ts
-import { num, obj, str } from "@earendil-works/pi-schema";
-import { createHost, hostNamed, method, remote } from "@earendil-works/chord";
+import { createHost, defineFacet, local, method, obj, str, constant } from "@earendil-works/chord";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+
+const context = BACKGROUND_CONTEXT; // every call takes a context, used for cancellation
 
-// contract.ts: shared by provider and consumers
-export const Counter = remote("demo.counter", {
+// A contract: params select the instance (one object per language), members are state and methods.
+const Greeter = local("example.greeter", {
 	version: 1,
-	input: obj({ name: str() }),
-	host: hostNamed("server"), // where its objects live; callers never name a host
-	variants: {
-		default: {
-			state: { count: num() },
-			methods: { increment: method(obj({ by: num() })) },
-		},
-	},
+	params: { language: str() },
+	members: { language: str(), greet: method(obj({ name: str() }), str()) },
 });
 
-const host = createHost({ name: "server", self: { kind: "server" } });
-
-host.serve(Counter, ({ name }, _principal, self) => {
-	const count = self.state("count", num(), 0);
-	return {
-		variant: "default",
-		count,
-		increment: async ({ by }, ctx) => {
-			count.change(ctx, (n) => n + by);
-		},
-	};
+// A facet serves types with factories; a factory only declares and returns the implementation.
+const facet = defineFacet((host) => {
+	host.serve(Greeter, ({ language }) => ({
+		language: constant(language),
+		greet: async ({ name }) => (language === "de" ? `Hallo ${name}` : `Hello ${name}`),
+	}));
 });
 
-await host.root(async (ctx) => {
-	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
-});
+const host = createHost({ onError: (error) => console.error(error) });
+await host.load([{ name: "@example/greeter", facet }], context);
+
+const german = await host.get(Greeter, { language: "de" }, context); // live: state has values, methods can be called
+console.log(german.language.value, await german.greet({ name: "Mario" }, context)); // de Hallo Mario
+german.release(); // the last reference released ends the object
+await host.close(context);
 ```
 
 ## Documentation
 
-- [Tutorial](docs/tutorial.md): a shared todo list, built up section by section. Every example runs as `test/tutorial.test.ts`.
-- [Usage guide](docs/guide.md): API reference for contracts, objects, state, roots, lifetime, plugins, hot reload, hosts, and links.
-- [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`.
+- [Design](docs/design.md): the target design, the one current statement of every rule; [decisions](docs/decisions.md): the decision log; [slices](docs/slices.md): the build plan and its carry-over.
+- [Plugins and hosts](docs/guide-plugins-hosts/book.md): a tutorial building a notes app with plugins, HTTP and workers; [plugin authoring](docs/plugin-authoring.md): the guide for agents writing plugins.
+- [Examples](test/examples/): runnable references, one topic each. Run from `packages/chord`: `node --conditions=source --experimental-strip-types test/examples/01-objects.ts`.
+- Each layer's README in `src/*/README.md` and `src/node/*/README.md`; the [delta guide](src/delta/README.md): ownership, lifecycle, operation, and replica contracts of `@earendil-works/chord/delta`.
 
 ## Explicit Context telemetry
 
@@ -155,55 +164,6 @@ the draft changes. Published values are not frozen. In-process consumers may sha
 their containers with the provider; mutating a consumed value violates the contract
 and can corrupt authority. Clone or serialize at any mutable trust boundary.
 
-Replicated state provides the same model through a callback. `replicatedState` is a
-standalone observable value, independent of hosts:
-
-```ts
-import { replicatedState } from "@earendil-works/chord";
-
-const initial = { output: "", count: 0 };
-const status = replicatedState(initial); // transfers ownership of initial
-status.change(context, (draft) => {
-	draft.output += "done\n";
-	draft.count += 1;
-});
-```
-
-A successful `change()` publishes exactly one atomic revision. If its callback
-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.
-
-`replicatedState(source, { onError })` instead attaches a publication-only state to
-an authoritative revision source (`ReplicatedStateSource`): it captures a snapshot,
-then publishes every committed frame in cursor order.
-
-### Public state subscriptions
-
-`state.subscribe(async (value, context, delivery) => { ... })` serializes callbacks
-independently for each subscription. Hydration starts immediately when a value is
-available, and its returned promise must settle before updates start. Synchronous
-callbacks still run synchronously. Read the captured `value` inside an asynchronous
-callback: `state.value` may already refer to a later revision.
-
-Each subscription retains at most 100 pending complete-value deliveries, excluding
-the running callback. On overflow, only the newest pending value, context, and
-delivery metadata are retained; a not-yet-started initial hydration is preserved.
-Thus public delivery sequences may skip. This is a frame-count policy, not a byte
-limit.
-
-The returned unsubscribe function immediately discards pending work and prevents
-new callbacks. It neither aborts nor waits for the running callback. Synchronous
-throws and promise rejections are observed, reported, and do not stop other
-subscriptions or subsequent callbacks. Attached sources use their `onError`
-handler; mutable states (and attached sources without a handler) report failures
-by throwing in a microtask. Unsubscribing does not hide a later rejection from the
-running callback.
-
-Cells of Chord objects and their remote readables have their own subscription
-model; see [State](docs/guide.md#state) in the usage guide.
-
 ### Watches
 
 `WatchHandle<T>` is the one watch interface, implemented by watch sources such as

package/dist/contracts/accepts.d.ts

@@ -0,0 +1,81 @@
+import type { Context } from "../context/index.ts";
+import { type Contract, type ContractShape, type Kind, LOCAL, type ShapeOf } from "./contract.ts";
+import type { Change, ChangesAfter, CurrentStep, MemberNames, MethodAt, OlderVersions, StepAt, VariantShape, Variants, VariantsWith } from "./history.ts";
+import type { Method, Static } from "./schema.ts";
+/** Per accepted older version, exactly the mappings its later edits require (direct: old to current). */
+export type AcceptsTable<C extends Contract> = AcceptsOf<ShapeOf<C>>;
+type AcceptsOf<S extends ContractShape> = {
+    readonly [V in OlderVersions<S["history"]>]?: VersionMappings<S["kind"], StepAt<S["history"], V>["variants"], CurrentStep<S["history"]>["variants"], ChangesAfter<S["history"], V>>;
+};
+type VersionMappings<K extends Kind, Old extends Variants, Current extends Variants, C extends Change> = Section<"state", K extends "local" ? StateMappings<Old[Local], Current[Local], Local, C> : RemoteStateMappings<Old, Current, C>> & Section<"methods", MethodMappings<Old, Current, C>> & Section<"keyed", K extends "local" ? KeyedMappings<Old[Local], Current[Local], C> : Record<never, never>>;
+/**
+ * A local contract's keyed members (slice 7b): a changed one maps each document of the current version back, or
+ * refuses; a removed one refuses (no document maps from the whole state).
+ */
+type KeyedMappings<Old extends VariantShape, Current extends VariantShape, C extends Change> = OmitNever<{
+    [S in keyof NonNullable<Old["keyed"]>]: S extends keyof NonNullable<Current["keyed"]> ? [Local, S, "keyed"] extends C ? ((current: Static<NonNullable<Current["keyed"]>[S]>) => Static<NonNullable<Old["keyed"]>[S]>) | "refuse" : never : "refuse";
+}>;
+type Local = typeof LOCAL;
+/** A section is required when it holds a required mapping; otherwise it may be absent or empty. */
+type Section<Key extends string, T> = [keyof T] extends [never] ? {
+    readonly [K in Key]?: {
+        readonly [member: string]: never;
+    };
+} : {
+    readonly [K in Key]: T;
+};
+/** `T` without its `never` properties: the members that need no mapping. */
+type OmitNever<T> = {
+    readonly [K in keyof T as [T[K]] extends [never] ? never : K]: T[K];
+};
+type RemoteStateMappings<Old extends Variants, Current extends Variants, C extends Change> = OmitNever<{
+    [X in keyof Old & keyof Current]: [keyof StateMappings<Old[X], Current[X], X, C>] extends [never] ? never : StateMappings<Old[X], Current[X], X, C>;
+}>;
+type StateMappings<Old extends VariantShape, Current extends VariantShape, X, C extends Change> = OmitNever<{
+    [S in keyof Old["state"]]: StateMapping<Old, Current, X, S, C>;
+}>;
+/** A changed member maps the current member back; a removed one maps the variant's whole current state, or refuses. */
+type StateMapping<Old extends VariantShape, Current extends VariantShape, X, S extends keyof Old["state"], C> = S extends keyof Current["state"] ? [X, S, "state"] extends C ? (current: Static<Current["state"][S]>) => Static<Old["state"][S]> : never : ((state: {
+    [M in keyof Current["state"]]: Static<Current["state"][M]>;
+}) => Static<Old["state"][S]>) | "refuse";
+type MethodMappings<Old extends Variants, Current extends Variants, C extends Change> = OmitNever<{
+    [M in MemberNames<Old, "methods">]: [RemovedFrom<Current, VariantsWith<Old, M>, M>] extends [never] ? ChangedMethod<Changed<C, VariantsWith<Old, M>, M, "args">, Changed<C, VariantsWith<Old, M>, M, "result">, MethodAt<Old, M>, MethodAt<Current, M>> : Replacement<MethodAt<Old, M>>;
+}>;
+/** The variants among `Xs` that no longer have method `M`. */
+type RemovedFrom<Current extends Variants, Xs extends keyof Current, M> = {
+    [X in Xs]: M extends keyof Current[X]["methods"] ? never : X;
+}[Xs];
+/** `true` when an edit changed `Side` of `M` in one of `Xs`. */
+type Changed<C, Xs, M, Side> = Xs extends unknown ? ([Xs, M, Side] extends C ? true : never) : never;
+/** Mappings for the changed sides of a method (`A`, `R` are `true` when changed), or a replacement. */
+type ChangedMethod<A, R, Old extends Method, Current extends Method> = [A | R] extends [never] ? never : ({
+    readonly call?: never;
+} & ([A] extends [never] ? {
+    readonly args?: never;
+} : {
+    readonly args: (old: Static<Old["args"]>) => Static<Current["args"]>;
+}) & ([R] extends [never] ? {
+    readonly result?: never;
+} : {
+    readonly result: (current: Static<Current["result"]>) => Static<Old["result"]>;
+})) | Replacement<Old>;
+/** A removed (or changed) method served by the provider's own function, or refused. */
+type Replacement<Old extends Method> = {
+    readonly call: (args: Static<Old["args"]>, context: Context) => Promise<Static<Old["result"]>>;
+    readonly args?: never;
+    readonly result?: never;
+} | "refuse";
+/** An accepted older version and its fingerprint. */
+export type AcceptedVersion = {
+    readonly version: number;
+    readonly fingerprint: string;
+};
+/**
+ * Validates an accepts table without calling any mapping: known older versions only, exactly the required mappings
+ * with the right shapes. Fails with an Error naming the path (`notes accepts[1].methods.add`).
+ */
+export declare function checkAccepts<C extends Contract>(contract: C, accepts: AcceptsTable<C>): {
+    readonly versions: readonly AcceptedVersion[];
+};
+export {};
+//# sourceMappingURL=accepts.d.ts.map

package/dist/contracts/accepts.d.ts.map

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

package/dist/contracts/accepts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accepts.js","sourceRoot":"","sources":["../../src/contracts/accepts.ts"],"names":[],"mappings":"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","sourcesContent":["// Accepted versions: the older versions a provider still serves, with the direct mappings their edits require.\n\nimport type { Context } from \"../context/index.ts\";\nimport {\n\ttype Contract,\n\ttype ContractData,\n\ttype ContractShape,\n\tcontractData,\n\ttype Kind,\n\tLOCAL,\n\ttype ShapeOf,\n} from \"./contract.ts\";\nimport { checkKeys, entriesOf } from \"./declare.ts\";\nimport type {\n\tChange,\n\tChangesAfter,\n\tCurrentStep,\n\tMemberNames,\n\tMethodAt,\n\tOlderVersions,\n\tStepAt,\n\tVariantShape,\n\tVariants,\n\tVariantsWith,\n} from \"./history.ts\";\nimport type { Method, Static } from \"./schema.ts\";\n\n/** Per accepted older version, exactly the mappings its later edits require (direct: old to current). */\nexport type AcceptsTable<C extends Contract> = AcceptsOf<ShapeOf<C>>;\n\ntype AcceptsOf<S extends ContractShape> = {\n\treadonly [V in OlderVersions<S[\"history\"]>]?: VersionMappings<\n\t\tS[\"kind\"],\n\t\tStepAt<S[\"history\"], V>[\"variants\"],\n\t\tCurrentStep<S[\"history\"]>[\"variants\"],\n\t\tChangesAfter<S[\"history\"], V>\n\t>;\n};\n\ntype VersionMappings<K extends Kind, Old extends Variants, Current extends Variants, C extends Change> = Section<\n\t\"state\",\n\tK extends \"local\" ? StateMappings<Old[Local], Current[Local], Local, C> : RemoteStateMappings<Old, Current, C>\n> &\n\tSection<\"methods\", MethodMappings<Old, Current, C>> &\n\tSection<\"keyed\", K extends \"local\" ? KeyedMappings<Old[Local], Current[Local], C> : Record<never, never>>;\n\n/**\n * A local contract's keyed members (slice 7b): a changed one maps each document of the current version back, or\n * refuses; a removed one refuses (no document maps from the whole state).\n */\ntype KeyedMappings<Old extends VariantShape, Current extends VariantShape, C extends Change> = OmitNever<{\n\t[S in keyof NonNullable<Old[\"keyed\"]>]: S extends keyof NonNullable<Current[\"keyed\"]>\n\t\t? [Local, S, \"keyed\"] extends C\n\t\t\t? ((current: Static<NonNullable<Current[\"keyed\"]>[S]>) => Static<NonNullable<Old[\"keyed\"]>[S]>) | \"refuse\"\n\t\t\t: never\n\t\t: \"refuse\";\n}>;\n\ntype Local = typeof LOCAL;\n\n/** A section is required when it holds a required mapping; otherwise it may be absent or empty. */\ntype Section<Key extends string, T> = [keyof T] extends [never]\n\t? { readonly [K in Key]?: { readonly [member: string]: never } }\n\t: { readonly [K in Key]: T };\n\n/** `T` without its `never` properties: the members that need no mapping. */\ntype OmitNever<T> = { readonly [K in keyof T as [T[K]] extends [never] ? never : K]: T[K] };\n\ntype RemoteStateMappings<Old extends Variants, Current extends Variants, C extends Change> = OmitNever<{\n\t[X in keyof Old & keyof Current]: [keyof StateMappings<Old[X], Current[X], X, C>] extends [never]\n\t\t? never\n\t\t: StateMappings<Old[X], Current[X], X, C>;\n}>;\n\ntype StateMappings<Old extends VariantShape, Current extends VariantShape, X, C extends Change> = OmitNever<{\n\t[S in keyof Old[\"state\"]]: StateMapping<Old, Current, X, S, C>;\n}>;\n\n/** A changed member maps the current member back; a removed one maps the variant's whole current state, or refuses. */\ntype StateMapping<\n\tOld extends VariantShape,\n\tCurrent extends VariantShape,\n\tX,\n\tS extends keyof Old[\"state\"],\n\tC,\n> = S extends keyof Current[\"state\"]\n\t? [X, S, \"state\"] extends C\n\t\t? (current: Static<Current[\"state\"][S]>) => Static<Old[\"state\"][S]>\n\t\t: never\n\t: ((state: { [M in keyof Current[\"state\"]]: Static<Current[\"state\"][M]> }) => Static<Old[\"state\"][S]>) | \"refuse\";\n\ntype MethodMappings<Old extends Variants, Current extends Variants, C extends Change> = OmitNever<{\n\t[M in MemberNames<Old, \"methods\">]: [RemovedFrom<Current, VariantsWith<Old, M>, M>] extends [never]\n\t\t? ChangedMethod<\n\t\t\t\tChanged<C, VariantsWith<Old, M>, M, \"args\">,\n\t\t\t\tChanged<C, VariantsWith<Old, M>, M, \"result\">,\n\t\t\t\tMethodAt<Old, M>,\n\t\t\t\tMethodAt<Current, M>\n\t\t\t>\n\t\t: Replacement<MethodAt<Old, M>>;\n}>;\n\n/** The variants among `Xs` that no longer have method `M`. */\ntype RemovedFrom<Current extends Variants, Xs extends keyof Current, M> = {\n\t[X in Xs]: M extends keyof Current[X][\"methods\"] ? never : X;\n}[Xs];\n\n/** `true` when an edit changed `Side` of `M` in one of `Xs`. */\ntype Changed<C, Xs, M, Side> = Xs extends unknown ? ([Xs, M, Side] extends C ? true : never) : never;\n\n/** Mappings for the changed sides of a method (`A`, `R` are `true` when changed), or a replacement. */\ntype ChangedMethod<A, R, Old extends Method, Current extends Method> = [A | R] extends [never]\n\t? never\n\t:\n\t\t\t| ({ readonly call?: never } & ([A] extends [never]\n\t\t\t\t\t? { readonly args?: never }\n\t\t\t\t\t: { readonly args: (old: Static<Old[\"args\"]>) => Static<Current[\"args\"]> }) &\n\t\t\t\t\t([R] extends [never]\n\t\t\t\t\t\t? { readonly result?: never }\n\t\t\t\t\t\t: { readonly result: (current: Static<Current[\"result\"]>) => Static<Old[\"result\"]> }))\n\t\t\t| Replacement<Old>;\n\n/** A removed (or changed) method served by the provider's own function, or refused. */\ntype Replacement<Old extends Method> =\n\t| {\n\t\t\treadonly call: (args: Static<Old[\"args\"]>, context: Context) => Promise<Static<Old[\"result\"]>>;\n\t\t\treadonly args?: never;\n\t\t\treadonly result?: never;\n\t  }\n\t| \"refuse\";\n\n/** An accepted older version and its fingerprint. */\nexport type AcceptedVersion = { readonly version: number; readonly fingerprint: string };\n\n/**\n * Validates an accepts table without calling any mapping: known older versions only, exactly the required mappings\n * with the right shapes. Fails with an Error naming the path (`notes accepts[1].methods.add`).\n */\nexport function checkAccepts<C extends Contract>(\n\tcontract: C,\n\taccepts: AcceptsTable<C>,\n): { readonly versions: readonly AcceptedVersion[] } {\n\tconst data = contractData(contract);\n\t// Declaration policy: JavaScript callers reach every check below.\n\tconst versions = entriesOf(accepts, `${data.name} accepts`).map(([key, mappings]) => {\n\t\tconst path = `${data.name} accepts[${key}]`;\n\t\tconst index = data.versions.findIndex(({ version }) => String(version) === key);\n\t\tif (index === -1 || index === data.versions.length - 1) throw new Error(`${path}: not an older version`);\n\t\tcheckMappings(mappings, needs(data, index), data.kind, path);\n\t\tconst { version, fingerprint } = data.versions[index]!;\n\t\treturn { version, fingerprint };\n\t});\n\treturn { versions };\n}\n\n/** What an accepted version needs, by edit and never by schema comparison. */\ntype Needs = {\n\t/** Per variant, per state member. */\n\treadonly state: ReadonlyMap<string, ReadonlyMap<string, StateNeed>>;\n\treadonly methods: ReadonlyMap<string, MethodNeed>;\n\t/** Per keyed member (local contracts). */\n\treadonly keyed: ReadonlyMap<string, StateNeed>;\n};\n\ntype StateNeed = \"changed\" | \"removed\";\n\ntype MethodNeed =\n\t| { readonly kind: \"removed\" }\n\t| { readonly kind: \"changed\"; readonly args: boolean; readonly result: boolean };\n\nfunction needs(data: ContractData, index: number): Needs {\n\tconst old = data.versions[index]!;\n\tconst current = data.versions.at(-1)!;\n\tconst changes = new Set(data.versions.slice(index + 1).flatMap((version) => version.changes.map(changeKey)));\n\tconst changed = (...change: Change) => changes.has(changeKey(change));\n\tconst state = new Map<string, Map<string, StateNeed>>();\n\tconst methods = new Map<string, { removed: boolean; args: boolean; result: boolean }>();\n\tconst keyed = new Map<string, StateNeed>();\n\tfor (const [variant, { state: oldState, methods: oldMethods, keyed: oldKeyed }] of old.variants) {\n\t\tconst now = current.variants.get(variant)!;\n\t\tfor (const member of oldKeyed.keys()) {\n\t\t\tif (!now.keyed.has(member)) keyed.set(member, \"removed\");\n\t\t\telse if (changed(variant, member, \"keyed\")) keyed.set(member, \"changed\");\n\t\t}\n\t\tconst variantNeeds = new Map<string, StateNeed>();\n\t\tfor (const member of oldState.keys()) {\n\t\t\tif (!now.state.has(member)) variantNeeds.set(member, \"removed\");\n\t\t\telse if (changed(variant, member, \"state\")) variantNeeds.set(member, \"changed\");\n\t\t}\n\t\tif (variantNeeds.size > 0) state.set(variant, variantNeeds);\n\t\tfor (const member of oldMethods.keys()) {\n\t\t\tconst need = methods.get(member) ?? { removed: false, args: false, result: false };\n\t\t\tneed.removed ||= !now.methods.has(member);\n\t\t\tneed.args ||= changed(variant, member, \"args\");\n\t\t\tneed.result ||= changed(variant, member, \"result\");\n\t\t\tmethods.set(member, need);\n\t\t}\n\t}\n\tconst methodNeeds = new Map<string, MethodNeed>();\n\tfor (const [member, { removed, args, result }] of methods) {\n\t\tif (removed) methodNeeds.set(member, { kind: \"removed\" });\n\t\telse if (args || result) methodNeeds.set(member, { kind: \"changed\", args, result });\n\t}\n\treturn { state, methods: methodNeeds, keyed };\n}\n\nfunction changeKey(change: Change): string {\n\treturn JSON.stringify(change);\n}\n\nfunction checkMappings(mappings: unknown, needs: Needs, kind: Kind, path: string): void {\n\tcheckKeys(mappings, [\"state\", \"methods\", \"keyed\"], path);\n\tconst { state, methods, keyed } = mappings as {\n\t\treadonly state?: unknown;\n\t\treadonly methods?: unknown;\n\t\treadonly keyed?: unknown;\n\t};\n\tconst checkVariant = (variantMappings: unknown, variantNeeds: ReadonlyMap<string, StateNeed>, at: string) =>\n\t\tcheckSection(variantMappings, variantNeeds, at, checkStateMapping);\n\t// A local table is flat: its state section is the one variant's.\n\tif (kind === \"local\") checkVariant(state, needs.state.get(LOCAL) ?? new Map(), `${path}.state`);\n\telse checkSection(state, needs.state, `${path}.state`, checkVariant);\n\tcheckSection(methods, needs.methods, `${path}.methods`, checkMethodMapping);\n\tcheckSection(keyed, needs.keyed, `${path}.keyed`, checkKeyedMapping);\n}\n\n/** Exactly the needed keys: no missing and no unnecessary mapping; absent only when nothing is needed. */\nfunction checkSection<N>(\n\tsection: unknown,\n\tneeds: ReadonlyMap<string, N>,\n\tpath: string,\n\tcheck: (mapping: unknown, need: N, path: string) => void,\n): void {\n\tconst mappings = new Map(section === undefined ? [] : entriesOf(section, path));\n\tfor (const key of mappings.keys()) if (!needs.has(key)) throw new Error(`${path}.${key}: unnecessary mapping`);\n\tfor (const [key, need] of needs) {\n\t\tif (!mappings.has(key)) throw new Error(`${path}.${key}: missing mapping`);\n\t\tcheck(mappings.get(key), need, `${path}.${key}`);\n\t}\n}\n\nfunction checkStateMapping(mapping: unknown, need: StateNeed, path: string): void {\n\tif (typeof mapping === \"function\" || (need === \"removed\" && mapping === \"refuse\")) return;\n\tthrow new Error(`${path}: expected ${need === \"removed\" ? 'a function or \"refuse\"' : \"a function\"}`);\n}\n\nfunction checkKeyedMapping(mapping: unknown, need: StateNeed, path: string): void {\n\tif (mapping === \"refuse\" || (need === \"changed\" && typeof mapping === \"function\")) return;\n\tthrow new Error(`${path}: expected ${need === \"changed\" ? 'a function or \"refuse\"' : '\"refuse\"'}`);\n}\n\nfunction checkMethodMapping(mapping: unknown, need: MethodNeed, path: string): void {\n\tif (mapping === \"refuse\") return;\n\tcheckKeys(mapping, [\"args\", \"result\", \"call\"], path);\n\tconst { args, result, call } = mapping as {\n\t\treadonly args?: unknown;\n\t\treadonly result?: unknown;\n\t\treadonly call?: unknown;\n\t};\n\tif (call !== undefined || need.kind === \"removed\") {\n\t\tif (typeof call !== \"function\" || args !== undefined || result !== undefined) {\n\t\t\tthrow new Error(`${path}: expected { call } or \"refuse\"`);\n\t\t}\n\t\treturn;\n\t}\n\tcheckSide(args, need.args, `${path}.args`);\n\tcheckSide(result, need.result, `${path}.result`);\n}\n\nfunction checkSide(mapping: unknown, needed: boolean, path: string): void {\n\tif (!needed && mapping !== undefined) throw new Error(`${path}: unnecessary mapping`);\n\tif (needed && mapping === undefined) throw new Error(`${path}: missing mapping`);\n\tif (needed && typeof mapping !== \"function\") throw new Error(`${path}: expected a function`);\n}\n"]}

package/dist/contracts/contract.d.ts

@@ -0,0 +1,121 @@
+import type { Context } from "../context/index.ts";
+import type { Watchable, WatchHandle } from "../watch.ts";
+import type { Change, CurrentStep, History, VariantShape } from "./history.ts";
+import type { Address } from "./host-kind.ts";
+import type { Params, ParamsData } from "./params.ts";
+import type { Method, NullSchema, Static } from "./schema.ts";
+import type { Snapshot } from "./snapshot.ts";
+export type Kind = "remote" | "local";
+/** The variant name of a local contract's members. */
+export declare const LOCAL = "members";
+/** Everything the types know about a contract: kind, name, params and the whole history. */
+export type ContractShape = {
+    readonly kind: Kind;
+    readonly name: string;
+    readonly params: Params;
+    readonly history: History;
+};
+/** A declared contract: a branded handle, immutable by convention. Spread or hand-built copies are refused. */
+export interface Contract<S extends ContractShape = ContractShape> {
+    readonly kind: S["kind"];
+    readonly name: S["name"];
+    readonly version: number;
+    readonly fingerprint: string;
+    /** Type only: absent at runtime. */
+    readonly "~shape"?: S;
+}
+export type ShapeOf<C extends Contract> = NonNullable<C["~shape"]>;
+/** The variants of a contract's current version. */
+export type CurrentVariants<C extends Contract> = CurrentStep<ShapeOf<C>["history"]>["variants"];
+/** The params object of a contract. */
+export type ParamsOf<C extends Contract> = {
+    [F in keyof ShapeOf<C>["params"]]: Static<ShapeOf<C>["params"][F]>;
+};
+/**
+ * What a factory returns: for `local`, a `Watchable` per state member and a function per method, `(args, context)`,
+ * or `(context)` when the method takes no arguments; for `remote`, one variant `{ variant, members }` with exactly
+ * that variant's members. `X` is the context the methods get.
+ */
+export type Implementation<C extends Contract, X extends Context = Context> = ImplementationOf<ShapeOf<C>["kind"], CurrentVariants<C>, X>;
+type ImplementationOf<K extends Kind, V extends {
+    readonly [variant: string]: VariantShape;
+}, X extends Context> = K extends "local" ? VariantImplementation<V[typeof LOCAL], X> : {
+    [N in keyof V]: {
+        readonly variant: N;
+        readonly members: VariantImplementation<V[N], X>;
+    };
+}[keyof V];
+/**
+ * One variant's members: a `Watchable` per state member, a function per method and, in a local contract, a
+ * `KeyedWatchable` per keyed member.
+ */
+export type VariantImplementation<V extends VariantShape, X extends Context = Context> = {
+    [M in keyof V["state"] | keyof V["methods"] | keyof NonNullable<V["keyed"]>]: M extends keyof V["methods"] ? MethodFunction<V["methods"][M], X> : M extends keyof V["state"] ? Watchable<Static<V["state"][M]>> : M extends keyof NonNullable<V["keyed"]> ? KeyedWatchable<Static<NonNullable<V["keyed"]>[M]>> : never;
+};
+/**
+ * A keyed state member (slice 6a §12): documents by key, each watchable on its own; a keyed document handle
+ * provides it. `at(key)` is valid only in a factory (it pins the key while that attempt lives).
+ */
+export interface KeyedWatchable<T> {
+    /** The document at `key`, `undefined` when absent. */
+    get(key: string, context: Context): Promise<T | undefined>;
+    /** A watch of the document at `key` that follows its address, `undefined` when absent. */
+    watch(key: string, context: Context): Promise<WatchHandle<T> | undefined>;
+    /** In a factory only: the document at `key` as a watchable, `initial()` while absent. */
+    at(key: string): Watchable<T>;
+}
+/** A method as a function: without the argument when its argument schema is `null` (`null` stays the wire form). */
+type MethodFunction<M extends Method, X extends Context = Context> = M["args"] extends NullSchema ? (context: X) => Promise<Static<M["result"]>> : (args: Static<M["args"]>, context: X) => Promise<Static<M["result"]>>;
+/** The Chord-owned data behind a contract handle. */
+export type ContractData = {
+    readonly kind: Kind;
+    readonly name: string;
+    readonly params: ParamsData;
+    /** A remote contract's host address: the address of the host serving an object for its params; none for local. */
+    readonly hostAddress: HostAddress | undefined;
+    /** Every version of the history, oldest first; the last is current. */
+    readonly versions: readonly VersionData[];
+    /** The kind of every member name ever declared in the history. */
+    readonly kinds: ReadonlyMap<string, MemberKind>;
+};
+export type MemberKind = "state" | "method" | "keyed";
+/** A `hostAddress` as Chord calls it: with checked params. Plugin code: what it returns is checked where routed. */
+export type HostAddress = (params: ParamsOf<Contract>) => Address;
+export type VersionData = {
+    readonly version: number;
+    readonly fingerprint: string;
+    readonly variants: ReadonlyMap<string, VariantData>;
+    /** The changes that produced this version; empty for a base. */
+    readonly changes: readonly Change[];
+};
+export type VariantData = {
+    readonly state: ReadonlyMap<string, Snapshot>;
+    readonly methods: ReadonlyMap<string, MethodData>;
+    /** Keyed state members (slice 6a §12): only a local contract has any. */
+    readonly keyed: ReadonlyMap<string, Snapshot>;
+};
+export type MethodData = {
+    readonly args: Snapshot;
+    readonly result: Snapshot;
+};
+/** The data behind a contract handle; refuses spread and hand-built copies. */
+export declare function contractData(contract: Contract): ContractData;
+/** Whether a method takes no arguments: its argument schema is `null`, so its functions omit the argument. */
+export declare function takesNoArgs(method: MethodData): boolean;
+/** The variants of a contract's current version; a local contract has the one variant `LOCAL`. */
+export declare function currentVariants(contract: Contract): ReadonlyMap<string, VariantData>;
+/** The variants of version `version` of a contract's history (an older consumer's binding, Q10). */
+export declare function variantsAt(contract: Contract, version: number): ReadonlyMap<string, VariantData>;
+/** A variant's names as links index them (2b): its state members and its methods, each sorted. */
+export type VariantNames = {
+    readonly state: readonly string[];
+    readonly methods: readonly string[];
+};
+/** The current version's variant names in the order links index them: sorted. */
+export declare function variantOrder(contract: Contract): readonly string[];
+/** A variant's state members and methods in the order links index them: each sorted. */
+export declare function variantNames(variant: VariantData): VariantNames;
+/** A new contract handle for `data`; the caller states the type-level shape. */
+export declare function createContract<C extends Contract>(data: ContractData): C;
+export {};
+//# sourceMappingURL=contract.d.ts.map

package/dist/contracts/contract.d.ts.map

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