@amalgm/live 0.1.0

package/PURPOSE.md

@@ -0,0 +1,103 @@
+# @amalgm/live
+
+## Purpose
+
+`@amalgm/live` is the portable realtime SDK for the Amalgm platform: one
+library that owns every **wire contract** and every **delivery state machine**
+for synchronizing entities, documents, and presence between a machine and the
+cloud authority. A CLI, desktop app, gateway, service, or third-party
+JavaScript host consumes it without inheriting a filesystem watcher, a SQLite
+database, or a user-interface dependency.
+
+The public developer model is `live.bind(surface, channel)` and is specified
+in `docs/realtime-sdk.md`. The shipped wire behavior this package encodes is
+`docs/local-live-protocol.md`. The journal-first write discipline is
+`docs/cloud-mutation-discipline.md`. This repository is where those documents
+become executable and testable; the engine repo keeps read-only copies until
+its cutover.
+
+## Axioms
+
+1. **The SDK owns portable live contracts, not a machine.** Entity-record
+   shapes, resource identifiers, content manifests, checksums, frame shapes,
+   mutation envelopes, and ordering rules belong here; paths, inodes,
+   watchers, services, and local database files do not.
+2. **A host supplies its own effects.** The SDK receives transport, durable
+   journal, content-store, clock, and cryptography adapters. It never reaches
+   into Node globals, user homes, or a product-specific HTTP server to find
+   them. Nothing in `src/` may import `node:fs`, `node:net`, or spawn a
+   process.
+3. **There is one definition of every wire rule.** Client, runtime, and
+   gateway must share the same versioned schemas and integrity checks. A
+   second copy of a protocol or manifest validator is a bug, not a
+   compatibility layer.
+4. **Protocol evolution is additive only.** Every peer treats missing fields
+   and unknown frame types as "the other end is older" and keeps the legacy
+   behavior. A change that breaks a deployed v1 peer is rejected in review.
+5. **One edit, one mutation identity.** A surface edit creates exactly one
+   mutation id, stable across every retry, deduplicated by
+   `(resourceId, mutationId)` at every door. Transport packing never merges
+   mutation identities.
+6. **Journal first, materialize second.** A durable mutation is journaled
+   before local state changes, and that same journal row is the cloud outbox
+   record. There is no second outgoing table and no contract-specific retry
+   loop.
+7. **Lifecycle state is honest.** A socket being open is never `live`.
+   `live` means snapshot applied and ordered delivery confirmed; degraded and
+   reconnecting states are reported as themselves.
+8. **Never a silent winner.** Any merge path that durably discards text
+   preserves the losing side and says so on the event that carried the
+   decision.
+9. **The current runtime remains the single production source until moved.**
+   This package extracts contracts and machines with their tests; it does not
+   create a parallel execution path. The runtime and gateway adopt it module
+   by module, deleting their duplicated copy in the same change.
+10. **Amalgm's own surfaces use this SDK.** A private shortcut in the Amalgm
+    UI or runtime means the SDK is incomplete — fix the SDK, not the caller.
+
+## Five surfaces, one behavior
+
+```
+src/            the SDK — the behavior. Contracts + machines + adapter ports.
+surfaces/api    REST router factory a host mounts (diagnose/validate routes).
+surfaces/cli    `amalgm-live` — inspect frames, derive ids, simulate merges.
+surfaces/mcp    MCP server exposing the same actions to agents.
+skills/live     the skill: teaches an agent this protocol via the CLI/MCP.
+```
+
+Every surface is a thin adapter over `src/`. A surface that implements
+behavior instead of delegating to the SDK is a bug (axiom 3).
+
+## Layout
+
+```
+src/contracts/   value types + validators: events, snapshots, resource ids,
+                 mutation envelopes, content manifests, frames (SSE /
+                 gateway socket / tunnel), doc-write merge outcomes,
+                 presence.
+src/machines/    transport-neutral state machines: sequence ordering + gap
+                 recovery, bootstrap barrier, mutation journal, presence
+                 TTL, slot arbitration, chunk reassembly, backoff.
+src/entities/    the entity model's rule surface: the six-field record,
+                 derived versions, lifecycle laws, move planning, the
+                 cloud and repo-state codecs — behind injected ports.
+src/detection/   the Detect/Watch pure cores: the adapter contract, the
+                 three-channel compare (diff) core, coverage, continuity
+                 verdicts, classification, refusals, enrollment policy.
+src/adapters/    the ports a host injects: transport, journal store,
+                 content store, clock, crypto, logger.
+tests/           unit tests per module, in the engine wall's style: each
+                 exam states a law; mutants convict.
+tests/parity/    golden-vector harness: the same inputs run against this
+                 package and the shipped runtime implementation must produce
+                 identical outputs.
+tests/conformance/  the 10-rule suite from cloud-mutation-discipline.md,
+                 written against the public SDK API only.
+```
+
+## Status
+
+Extraction stage 1–2 (contracts and machines, per
+`docs/extraction-boundary.md`). The runtime and gateway do not consume this
+package yet; parity tests pin behavior until they do. Until both hosts
+consume it, the engine runtime remains the single production source.

package/README.md

@@ -0,0 +1,45 @@
+# amalgm-live
+
+The portable realtime SDK for the Amalgm platform.
+
+One library owns every wire contract and every delivery state machine for
+synchronizing entities, documents, and presence between a machine and the
+cloud authority — behind adapters the host injects. No filesystem, no
+SQLite, no UI dependency.
+
+```ts
+const binding = live.bind(surface, channel)
+```
+
+Start with [PURPOSE.md](PURPOSE.md) — purpose, axioms, and layout — and
+[ROADMAP.md](ROADMAP.md) for what moves here next. The
+normative specifications live in [docs/](docs/):
+
+| document | owns |
+| --- | --- |
+| [realtime-sdk.md](docs/realtime-sdk.md) | the public `bind(surface, channel)` model |
+| [local-live-protocol.md](docs/local-live-protocol.md) | the shipped local wire protocol (v1/v2) |
+| [cloud-mutation-discipline.md](docs/cloud-mutation-discipline.md) | the journal-first write discipline and conformance rules |
+| [shared-realtime-wave-3.md](docs/shared-realtime-wave-3.md) | the multi-user cloud-authority design |
+| [extraction-boundary.md](docs/extraction-boundary.md) | what moves here from the engine runtime, and in what order |
+
+## Surfaces
+
+| surface | entry | what it is |
+| --- | --- | --- |
+| SDK | `src/` → `@amalgm/live` | the behavior: contracts, machines, adapter ports |
+| API | `surfaces/api/` | REST router factory a host mounts |
+| CLI | `surfaces/cli/` | `amalgm-live` — inspect, derive, validate, simulate |
+| MCP | `surfaces/mcp/` | the same actions, exposed to agents |
+| Skill | `skills/live/` | teaches an agent this protocol via the CLI/MCP |
+
+Every surface delegates to `src/`. One behavior, five doors.
+
+## Develop
+
+```bash
+npm install
+npm test              # build + unit tests
+npm run test:parity   # golden vectors vs the shipped engine runtime
+npm run test:conformance
+```

package/dist/contracts/binding.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The binding — `live.bind(surface, channel)` (realtime-sdk.md).
+ *
+ * The surface knows what the user is looking at and what counts as one
+ * edit. The channel identifies the shared thing and its delivery class.
+ * The binding moves changes both ways and exposes honest lifecycle state:
+ * a socket being open is never `live` (axiom 7).
+ */
+/** Delivery classes (realtime-sdk.md §6). Media setup shares the binding; media packets never ride the durable log. */
+export type DeliveryClass = 'durable' | 'ephemeral' | 'media';
+/** A channel is a stable reference, not a socket. Authority and permissions come from the authenticated resource record — never from client fields. */
+export interface LiveChannelRef {
+    readonly id: string;
+    /** Must match the surface contract, e.g. "text-yjs@1". */
+    readonly contract: string;
+    readonly delivery: DeliveryClass;
+}
+/**
+ * Connection lifecycle vocabulary (realtime-sdk.md §7). `live` means the
+ * snapshot is applied AND ordered delivery is confirmed; `degraded` means
+ * delivery works through a slower fallback (e.g. gateway poll).
+ */
+export declare const BINDING_STATES: readonly ["connecting", "hydrating", "live", "degraded", "reconnecting", "blocked", "revoked"];
+export type BindingState = (typeof BINDING_STATES)[number];
+export interface ApplyContext {
+    /** True while a snapshot install is in progress; surfaces must not echo. */
+    readonly hydrating: boolean;
+}
+export interface SnapshotContext {
+    /** Why the snapshot is being installed: first hydration or gap recovery. */
+    readonly reason: 'hydration' | 'recovery';
+}
+/**
+ * A surface is an adapter over a real interactive UI — not a React
+ * component type, not a transport client (realtime-sdk.md §1). It defines
+ * the edit boundary, emits exactly one operation per edit, applies remote
+ * operations in place, and never echoes a remotely applied operation back
+ * as a new local edit.
+ */
+export interface LiveSurface<Snapshot, Operation, Presence = never> {
+    readonly contract: string;
+    observeEdits(emit: (operation: Operation) => void): () => void;
+    applyRemote(operation: Operation, context: ApplyContext): void;
+    /** Initial hydration or recovery only — never the normal response to a remote edit. */
+    applySnapshot(snapshot: Snapshot, context: SnapshotContext): void;
+    observePresence?(emit: (presence: Presence | null) => void): () => void;
+    applyPresence?(participantId: string, presence: Presence | null): void;
+}
+//# sourceMappingURL=binding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../src/contracts/binding.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,uHAAuH;AACvH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AAE9D,uJAAuJ;AACvJ,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;CAClC;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,gGAQjB,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,GAAG,KAAK;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,YAAY,CAAC,IAAI,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC/D,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC/D,uFAAuF;IACvF,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IAElE,eAAe,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACxE,aAAa,CAAC,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC;CACxE"}

package/dist/contracts/binding.js

@@ -0,0 +1,23 @@
+/**
+ * The binding — `live.bind(surface, channel)` (realtime-sdk.md).
+ *
+ * The surface knows what the user is looking at and what counts as one
+ * edit. The channel identifies the shared thing and its delivery class.
+ * The binding moves changes both ways and exposes honest lifecycle state:
+ * a socket being open is never `live` (axiom 7).
+ */
+/**
+ * Connection lifecycle vocabulary (realtime-sdk.md §7). `live` means the
+ * snapshot is applied AND ordered delivery is confirmed; `degraded` means
+ * delivery works through a slower fallback (e.g. gateway poll).
+ */
+export const BINDING_STATES = [
+    'connecting',
+    'hydrating',
+    'live',
+    'degraded',
+    'reconnecting',
+    'blocked',
+    'revoked',
+];
+//# sourceMappingURL=binding.js.map

package/dist/contracts/binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../src/contracts/binding.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,YAAY;IACZ,WAAW;IACX,MAAM;IACN,UAAU;IACV,cAAc;IACd,SAAS;IACT,SAAS;CACD,CAAC"}

package/dist/contracts/content.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Content manifests — the wire shape of immutable entity bytes.
+ *
+ * A file's content travels as bounded, content-addressed chunks named by a
+ * manifest (engine registration/entity-content.js, contract
+ * `amalgm-entity-content@1`). Every writer derives the same manifest from
+ * the same bytes, so manifests are idempotent facts, never negotiations.
+ *
+ * The chunk rule is `bytes <= CHUNK_BYTES`, never an exact size — older,
+ * smaller chunks remain valid forever. Capture, storage, and upload are
+ * host effects; this file owns the shape and its laws.
+ */
+import { type Checked } from './validate.js';
+export declare const CONTENT_CONTRACT = "amalgm-entity-content@1";
+/** One chunk is one WAN round trip; the gateway accepts parts up to this same bound. */
+export declare const CHUNK_BYTES: number;
+export interface ContentChunk {
+    readonly sha256: string;
+    readonly bytes: number;
+}
+export interface ContentManifest {
+    readonly contract: typeof CONTENT_CONTRACT;
+    readonly contentHash: string;
+    readonly bytes: number;
+    readonly chunks: readonly ContentChunk[];
+}
+/**
+ * Validate and normalize a manifest. The laws, in conviction order:
+ * well-formed hashes; every chunk within the bound; chunk bytes sum to the
+ * total; empty content has no chunks. Error phrases match the engine's —
+ * they are the ratified refusal text.
+ */
+export declare function checkContentManifest(input: unknown, expectedHash?: string | null): Checked<ContentManifest>;
+/**
+ * Derive the manifest for already-chunked bytes. The host reads and hashes
+ * (sha256 hex of each part and of the whole); this seals the shape so a
+ * hand-built manifest cannot drift from the derivation rule.
+ */
+export declare function manifestFromChunks(contentHash: string, chunks: readonly ContentChunk[]): Checked<ContentManifest>;
+/** Split a byte count into the chunk sizes capture will produce: full chunks, then the remainder. Zero bytes → zero chunks. */
+export declare function chunkSizes(totalBytes: number): number[];
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/contracts/content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAwB,MAAM,eAAe,CAAC;AAEnE,eAAO,MAAM,gBAAgB,4BAA4B,CAAC;AAE1D,wFAAwF;AACxF,eAAO,MAAM,WAAW,QAAkB,CAAC;AAI3C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;CAC1C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAkCjH;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,OAAO,CAAC,eAAe,CAAC,CAK1B;AAED,+HAA+H;AAC/H,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAOvD"}

package/dist/contracts/content.js

@@ -0,0 +1,72 @@
+/**
+ * Content manifests — the wire shape of immutable entity bytes.
+ *
+ * A file's content travels as bounded, content-addressed chunks named by a
+ * manifest (engine registration/entity-content.js, contract
+ * `amalgm-entity-content@1`). Every writer derives the same manifest from
+ * the same bytes, so manifests are idempotent facts, never negotiations.
+ *
+ * The chunk rule is `bytes <= CHUNK_BYTES`, never an exact size — older,
+ * smaller chunks remain valid forever. Capture, storage, and upload are
+ * host effects; this file owns the shape and its laws.
+ */
+import { pass, fail, isRecord } from './validate.js';
+export const CONTENT_CONTRACT = 'amalgm-entity-content@1';
+/** One chunk is one WAN round trip; the gateway accepts parts up to this same bound. */
+export const CHUNK_BYTES = 4 * 1024 * 1024;
+const HASH = /^[0-9a-f]{64}$/;
+/**
+ * Validate and normalize a manifest. The laws, in conviction order:
+ * well-formed hashes; every chunk within the bound; chunk bytes sum to the
+ * total; empty content has no chunks. Error phrases match the engine's —
+ * they are the ratified refusal text.
+ */
+export function checkContentManifest(input, expectedHash = null) {
+    if (!isRecord(input) ||
+        typeof input.contentHash !== 'string' ||
+        !HASH.test(input.contentHash) ||
+        (expectedHash !== null && input.contentHash !== expectedHash) ||
+        !Number.isSafeInteger(input.bytes) ||
+        input.bytes < 0 ||
+        !Array.isArray(input.chunks) ||
+        input.chunks.some((chunk) => !isRecord(chunk) ||
+            !HASH.test(String(chunk.sha256 ?? '')) ||
+            !Number.isSafeInteger(chunk.bytes) ||
+            chunk.bytes < 1 ||
+            chunk.bytes > CHUNK_BYTES)) {
+        return fail('entity content manifest is invalid');
+    }
+    const bytes = input.bytes;
+    const chunks = input.chunks;
+    if (chunks.reduce((total, chunk) => total + chunk.bytes, 0) !== bytes) {
+        return fail('entity content manifest byte count is invalid');
+    }
+    if (bytes === 0 && chunks.length !== 0) {
+        return fail('empty entity content must have no chunks');
+    }
+    return pass({
+        contract: CONTENT_CONTRACT,
+        contentHash: input.contentHash,
+        bytes,
+        chunks: chunks.map((chunk) => ({ sha256: chunk.sha256, bytes: chunk.bytes })),
+    });
+}
+/**
+ * Derive the manifest for already-chunked bytes. The host reads and hashes
+ * (sha256 hex of each part and of the whole); this seals the shape so a
+ * hand-built manifest cannot drift from the derivation rule.
+ */
+export function manifestFromChunks(contentHash, chunks) {
+    return checkContentManifest({ contract: CONTENT_CONTRACT, contentHash, bytes: chunks.reduce((t, c) => t + c.bytes, 0), chunks }, contentHash);
+}
+/** Split a byte count into the chunk sizes capture will produce: full chunks, then the remainder. Zero bytes → zero chunks. */
+export function chunkSizes(totalBytes) {
+    if (!Number.isSafeInteger(totalBytes) || totalBytes < 0)
+        return [];
+    const sizes = [];
+    for (let remaining = totalBytes; remaining > 0; remaining -= CHUNK_BYTES) {
+        sizes.push(Math.min(remaining, CHUNK_BYTES));
+    }
+    return sizes;
+}
+//# sourceMappingURL=content.js.map

package/dist/contracts/content.js.map

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

package/dist/contracts/docs.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Versioned document writes — the contract for whole-text writers.
+ *
+ * `POST /state/docs/write` (local-live-protocol.md §8) exists so a writer
+ * that read a file, thought, and wrote back does not clobber live edits
+ * that landed in between. `baseHash` is the lowercase sha256 hex of the
+ * EXACT text the writer read; every response's `sha256` chains into the
+ * next write.
+ *
+ * The governing invariant — never a silent winner: any path that durably
+ * discards text preserves it in a sidecar first and surfaces the decision
+ * on the doc event.
+ */
+import { type Checked } from './validate.js';
+/** Text over this limit is refused with 413. */
+export declare const MAX_DOC_BYTES: number;
+/** Bases resolve against a ring of recent disk-sync states, per doc. */
+export declare const RETENTION_RING: {
+    readonly states: 8;
+    readonly maxTotalBytes: number;
+    readonly maxAgeMs: number;
+};
+export interface DocWriteRequest {
+    readonly path: string;
+    /** Full new file contents — this is a whole-text contract. */
+    readonly text: string;
+    /** sha256 hex of the exact text the writer read. Prefer this over baseSeq. */
+    readonly baseHash?: string;
+    /** Exact-match lookup hint, consulted only when no baseHash was sent. */
+    readonly baseSeq?: number;
+}
+/**
+ * Every outcome states what happens to the losing text in the same breath.
+ *
+ * | outcome        | when                                   | losing text            |
+ * |----------------|----------------------------------------|------------------------|
+ * | `noop`         | incoming === live                      | none exists            |
+ * | `clean`        | base === live                          | none exists            |
+ * | `merged`       | base in retention, no overlapping hunks| both sides land        |
+ * | `conflict`     | overlapping hunks                      | full incoming → sidecar|
+ * | `base-unknown` | base outside the retention window      | live text → sidecar    |
+ * | `overwrite`    | no base sent                           | replaced text → sidecar unless nothing was deleted |
+ */
+export declare const MERGE_OUTCOMES: readonly ["noop", "clean", "merged", "conflict", "base-unknown", "overwrite"];
+export type MergeOutcome = (typeof MERGE_OUTCOMES)[number];
+export declare const CONFLICT_REASONS: readonly ["overlapping-hunks", "unversioned-overwrite", "base-unknown"];
+export type ConflictReason = (typeof CONFLICT_REASONS)[number];
+/** Travels on the write response and on the doc event (`patch.conflict`, source `doc:write`). */
+export interface DocConflict {
+    readonly reason: ConflictReason;
+    readonly sidecarPath: string;
+    readonly hunks?: number;
+    readonly at: number;
+}
+export interface DocWriteResponse {
+    readonly merge: MergeOutcome;
+    readonly seq: number;
+    /** Hash of the resulting text — hold it as the next write's baseHash. */
+    readonly sha256: string;
+    readonly conflict: DocConflict | null;
+}
+export declare const isSha256Hex: (value: unknown) => value is string;
+export declare function checkDocWriteRequest(input: unknown): Checked<DocWriteRequest>;
+//# sourceMappingURL=docs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/contracts/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAsD,MAAM,eAAe,CAAC;AAEjG,gDAAgD;AAChD,eAAO,MAAM,aAAa,QAAkB,CAAC;AAE7C,wEAAwE;AACxE,eAAO,MAAM,cAAc;;;;CAAgF,CAAC;AAE5G,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,+EAAgF,CAAC;AAC5G,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,eAAO,MAAM,gBAAgB,yEAA0E,CAAC;AACxG,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,iGAAiG;AACjG,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;CACvC;AAID,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACK,CAAC;AAE5D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,CAa7E"}

package/dist/contracts/docs.js

@@ -0,0 +1,51 @@
+/**
+ * Versioned document writes — the contract for whole-text writers.
+ *
+ * `POST /state/docs/write` (local-live-protocol.md §8) exists so a writer
+ * that read a file, thought, and wrote back does not clobber live edits
+ * that landed in between. `baseHash` is the lowercase sha256 hex of the
+ * EXACT text the writer read; every response's `sha256` chains into the
+ * next write.
+ *
+ * The governing invariant — never a silent winner: any path that durably
+ * discards text preserves it in a sidecar first and surfaces the decision
+ * on the doc event.
+ */
+import { pass, failShape, isRecord, isNonEmptyString, isSeq } from './validate.js';
+/** Text over this limit is refused with 413. */
+export const MAX_DOC_BYTES = 2 * 1024 * 1024;
+/** Bases resolve against a ring of recent disk-sync states, per doc. */
+export const RETENTION_RING = { states: 8, maxTotalBytes: 4 * 1024 * 1024, maxAgeMs: 10 * 60_000 };
+/**
+ * Every outcome states what happens to the losing text in the same breath.
+ *
+ * | outcome        | when                                   | losing text            |
+ * |----------------|----------------------------------------|------------------------|
+ * | `noop`         | incoming === live                      | none exists            |
+ * | `clean`        | base === live                          | none exists            |
+ * | `merged`       | base in retention, no overlapping hunks| both sides land        |
+ * | `conflict`     | overlapping hunks                      | full incoming → sidecar|
+ * | `base-unknown` | base outside the retention window      | live text → sidecar    |
+ * | `overwrite`    | no base sent                           | replaced text → sidecar unless nothing was deleted |
+ */
+export const MERGE_OUTCOMES = ['noop', 'clean', 'merged', 'conflict', 'base-unknown', 'overwrite'];
+export const CONFLICT_REASONS = ['overlapping-hunks', 'unversioned-overwrite', 'base-unknown'];
+const REQUEST_EXAMPLE = '{ path: "notes.md", text: "full new contents", baseHash: "9f86d0…" }';
+export const isSha256Hex = (value) => typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
+export function checkDocWriteRequest(input) {
+    if (!isRecord(input))
+        return failShape(REQUEST_EXAMPLE, `got ${input === null ? 'null' : typeof input}`);
+    if (!isNonEmptyString(input.path)) {
+        return failShape(REQUEST_EXAMPLE, `path was ${JSON.stringify(input.path)}, not a non-empty string`);
+    }
+    if (typeof input.text !== 'string')
+        return failShape(REQUEST_EXAMPLE, 'text was missing — this is a whole-text write');
+    if (input.baseHash !== undefined && !isSha256Hex(input.baseHash)) {
+        return failShape(REQUEST_EXAMPLE, `baseHash was ${JSON.stringify(input.baseHash)}, not lowercase sha256 hex`);
+    }
+    if (input.baseSeq !== undefined && !isSeq(input.baseSeq)) {
+        return failShape(REQUEST_EXAMPLE, `baseSeq was ${JSON.stringify(input.baseSeq)}, not a non-negative integer`);
+    }
+    return pass(input);
+}
+//# sourceMappingURL=docs.js.map

package/dist/contracts/docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.js","sourceRoot":"","sources":["../../src/contracts/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAgB,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEjG,gDAAgD;AAChD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAE7C,wEAAwE;AACxE,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,MAAM,EAAW,CAAC;AAY5G;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,CAAU,CAAC;AAG5G,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,mBAAmB,EAAE,uBAAuB,EAAE,cAAc,CAAU,CAAC;AAmBxG,MAAM,eAAe,GAAG,sEAAsE,CAAC;AAE/F,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAc,EAAmB,EAAE,CAC7D,OAAO,KAAK,KAAK,QAAQ,IAAI,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAE5D,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC,eAAe,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC;IACzG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAClC,OAAO,SAAS,CAAC,eAAe,EAAE,YAAY,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;IACtG,CAAC;IACD,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC,eAAe,EAAE,+CAA+C,CAAC,CAAC;IACvH,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjE,OAAO,SAAS,CAAC,eAAe,EAAE,gBAAgB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,4BAA4B,CAAC,CAAC;IAChH,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACzD,OAAO,SAAS,CAAC,eAAe,EAAE,eAAe,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;IAChH,CAAC;IACD,OAAO,IAAI,CAAC,KAAmC,CAAC,CAAC;AACnD,CAAC"}

package/dist/contracts/events.d.ts

@@ -0,0 +1,45 @@
+/**
+ * State events — the unit of change on the local wire.
+ *
+ * Every change is an event (local-live-protocol.md §1). Tables and disk are
+ * truth; the event log is a bounded (~15 min) delivery buffer, so a client
+ * that falls off the buffer re-snapshots rather than asking for history.
+ *
+ * `seq` is a strictly increasing integer per runtime. The two optional
+ * Wave 3 fields (`mutationId`, `sharedResourceId`) are additive: legacy
+ * rows omit both keys exactly as before, and validation here accepts both
+ * generations (axiom: additive-only evolution).
+ */
+import { type Checked } from './validate.js';
+import type { ResourceName } from './resources.js';
+/** The shipped wire operations. `move`/`delta` (realtime-sdk.md §3) ride as contract-specific patches until a wire rev adds them. */
+export declare const WIRE_OPS: readonly ["insert", "update", "delete", "replace", "invalidate"];
+export type WireOp = (typeof WIRE_OPS)[number];
+export interface StateEvent {
+    readonly seq: number;
+    readonly ts: number;
+    readonly resource: ResourceName;
+    readonly op: WireOp;
+    /** Addressed item within the resource, when the op targets one. */
+    readonly id?: string;
+    readonly value?: unknown;
+    readonly patch?: unknown;
+    /** Provenance, e.g. 'doc:write'. */
+    readonly source?: string;
+    /** Echo of the client-supplied mutation id, for optimistic reconciliation. */
+    readonly clientMutationId?: string;
+    readonly version?: number;
+    /** Wave 3, additive: durable mutation identity. */
+    readonly mutationId?: string;
+    /** Wave 3, additive: the cloud id of the shared resource this event belongs to. */
+    readonly sharedResourceId?: string;
+}
+export declare const isWireOp: (value: unknown) => value is WireOp;
+/**
+ * Validate one wire event. Unknown extra keys are preserved untouched —
+ * a newer peer may be speaking an additive extension we do not know yet.
+ */
+export declare function checkStateEvent(input: unknown): Checked<StateEvent>;
+/** Events apply in seq order; equal or older seq means already applied (client obligation, protocol §6). */
+export declare const isNewerThan: (event: StateEvent, appliedSeq: number) => boolean;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/contracts/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAsD,MAAM,eAAe,CAAC;AACjG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,qIAAqI;AACrI,eAAO,MAAM,QAAQ,kEAAmE,CAAC;AACzF,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,oCAAoC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAID,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAC2B,CAAC;AAE/E;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CASnE;AAED,4GAA4G;AAC5G,eAAO,MAAM,WAAW,GAAI,OAAO,UAAU,EAAE,YAAY,MAAM,KAAG,OAAiC,CAAC"}

package/dist/contracts/events.js

@@ -0,0 +1,38 @@
+/**
+ * State events — the unit of change on the local wire.
+ *
+ * Every change is an event (local-live-protocol.md §1). Tables and disk are
+ * truth; the event log is a bounded (~15 min) delivery buffer, so a client
+ * that falls off the buffer re-snapshots rather than asking for history.
+ *
+ * `seq` is a strictly increasing integer per runtime. The two optional
+ * Wave 3 fields (`mutationId`, `sharedResourceId`) are additive: legacy
+ * rows omit both keys exactly as before, and validation here accepts both
+ * generations (axiom: additive-only evolution).
+ */
+import { pass, failShape, isRecord, isNonEmptyString, isSeq } from './validate.js';
+/** The shipped wire operations. `move`/`delta` (realtime-sdk.md §3) ride as contract-specific patches until a wire rev adds them. */
+export const WIRE_OPS = ['insert', 'update', 'delete', 'replace', 'invalidate'];
+const EXAMPLE = '{ seq: 42, ts: 1719000000000, resource: "tasks", op: "update", id: "t1", patch: {...} }';
+export const isWireOp = (value) => typeof value === 'string' && WIRE_OPS.includes(value);
+/**
+ * Validate one wire event. Unknown extra keys are preserved untouched —
+ * a newer peer may be speaking an additive extension we do not know yet.
+ */
+export function checkStateEvent(input) {
+    if (!isRecord(input))
+        return failShape(EXAMPLE, `got ${input === null ? 'null' : typeof input}`);
+    if (!isSeq(input.seq))
+        return failShape(EXAMPLE, `seq was ${JSON.stringify(input.seq)}, not a non-negative integer`);
+    if (typeof input.ts !== 'number')
+        return failShape(EXAMPLE, `ts was ${JSON.stringify(input.ts)}, not a number`);
+    if (!isNonEmptyString(input.resource))
+        return failShape(EXAMPLE, `resource was ${JSON.stringify(input.resource)}, not a name`);
+    if (!isWireOp(input.op)) {
+        return failShape(EXAMPLE, `op was ${JSON.stringify(input.op)}, not one of ${WIRE_OPS.join('|')}`);
+    }
+    return pass(input);
+}
+/** Events apply in seq order; equal or older seq means already applied (client obligation, protocol §6). */
+export const isNewerThan = (event, appliedSeq) => event.seq > appliedSeq;
+//# sourceMappingURL=events.js.map

package/dist/contracts/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/contracts/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAgB,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAGjG,qIAAqI;AACrI,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAU,CAAC;AAuBzF,MAAM,OAAO,GAAG,yFAAyF,CAAC;AAE1G,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAmB,EAAE,CAC1D,OAAO,KAAK,KAAK,QAAQ,IAAK,QAA8B,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAE/E;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC,OAAO,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC;IACjG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC,OAAO,EAAE,WAAW,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;IACrH,IAAI,OAAO,KAAK,CAAC,EAAE,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC,OAAO,EAAE,UAAU,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAAC,CAAC;IAChH,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC;QAAE,OAAO,SAAS,CAAC,OAAO,EAAE,gBAAgB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;IAC/H,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC,OAAO,EAAE,UAAU,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACpG,CAAC;IACD,OAAO,IAAI,CAAC,KAA8B,CAAC,CAAC;AAC9C,CAAC;AAED,4GAA4G;AAC5G,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAiB,EAAE,UAAkB,EAAW,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,UAAU,CAAC"}