@demlik/tea 0.1.0

package/dist/do/index.d.ts

@@ -0,0 +1,135 @@
+import { Store, SubId, Sub } from '../index.js';
+
+/**
+ * @demlik/tea/do — Durable Object adapter for `@demlik/tea`.
+ *
+ * Two exports drive the integration:
+ *
+ *   1. `doStore<S>(storage, parse, key?)` — `Store<S>` impl backed by
+ *      `DurableObjectStorage`. JSON-stringifies on save, JSON-parses on load
+ *      and returns `unknown` (invariant-8 boundary); the substrate then calls
+ *      `migrate(raw)` (which forwards to `parse`) to turn it into `S | null`.
+ *      Returns `null` (typed as `unknown`) when the key is absent. Structural
+ *      JSON malformation throws at load — `run()`'s boot path surfaces that
+ *      (PRD throw-semantics table: "store.load throw at boot → run() throws
+ *      synchronously"). Shape mismatch is NOT a throw — `parse` returns
+ *      `null` and the substrate boots fresh.
+ *
+ *   2. `doSubscribe<M, Ctx>()` — handler registry for the two DO-native sub
+ *      types this package owns:
+ *        - `do_alarm` — schedules a real DO alarm via `state.storage.setAlarm`;
+ *          the cooperating DO's `alarm()` lifecycle method dispatches the sub's
+ *          msg. Cleanup clears the alarm.
+ *        - `do_ws`   — registers a WebSocket-id'd listener in a per-DO registry
+ *          that the cooperating DO's `webSocketMessage()` consults. Cleanup
+ *          deregisters.
+ *
+ * BOTH `do_alarm` and `do_ws` rely on the host DO cooperating: alarm and
+ * webSocketMessage are DO lifecycle methods, not JS events the handler can
+ * subscribe to from the outside. The cooperating DO must:
+ *
+ *   - Maintain a `Ctx` that exposes `state: DurableObjectState` AND the
+ *     subscriber registries (`wsRegistry`, `alarmRegistry`). The handlers read
+ *     from `ctx`.
+ *   - Forward `alarm()` callbacks into the alarm registry by id, dispatching
+ *     the registered msg.
+ *   - Forward `webSocketMessage(ws, data)` callbacks into the ws registry,
+ *     dispatching `sub.msg(data)` for matching `socketId`s.
+ *
+ * `src/test-worker.ts` is the canonical example of this cooperation. See
+ * `test/README.md` for the convention.
+ */
+
+/**
+ * `Store<S>` over `DurableObjectStorage`.
+ *
+ * `parse` is REQUIRED because DO storage is a real serialization boundary —
+ * the bytes that come back through `JSON.parse` are structurally `unknown`,
+ * and the caller (the DO that owns `S`) is the only party with enough
+ * information to validate the shape. Returning `null` from `parse` means
+ * "no usable persisted state" — the substrate boots `init` with `loaded =
+ * null`, a known-good fresh-boot path. `parse` must NOT throw per the
+ * `Store<S>.migrate` contract; shape mismatch is a value (null), not a
+ * panic.
+ *
+ * Structural malformations (the stored cell isn't even JSON) still throw at
+ * `load()` — that's an infrastructure error, distinct from a schema
+ * mismatch. The substrate surfaces it via `runtime.ready` rejection.
+ *
+ * Concrete bite this closes: when a `State` variant is renamed between
+ * deploys, the DO's new code previously received a value typed as the new
+ * `S` that held a runtime string from the old `S` — silent undefined
+ * behavior in `init`/`update`. After this, the boundary parse rejects the
+ * old shape (returns null) and the DO boots fresh, picking up its new
+ * schema from the next dispatch onward.
+ */
+declare function doStore<S>(storage: DurableObjectStorage, parse: (raw: unknown) => S | null, key?: string): Store<S>;
+/**
+ * A DO alarm sub: fires `msg` at `firesAt` (epoch ms). The substrate diffs
+ * subs by `id`; same id across transitions = same alarm. To reschedule, emit
+ * a DIFFERENT id (e.g., `audit-timeout-v2`).
+ */
+type DoAlarmSub<M> = {
+    id: SubId;
+    type: "do_alarm";
+    firesAt: number;
+    msg: M;
+};
+/**
+ * A DO WebSocket sub: routes incoming messages on `socketId` through
+ * `sub.msg(data)` to dispatch.
+ */
+type DoWsSub<M> = {
+    id: SubId;
+    type: "do_ws";
+    socketId: string;
+    msg: (data: string) => M;
+};
+type DoSub<M> = DoAlarmSub<M> | DoWsSub<M>;
+type AssertDoSubIsSub<T extends Sub = DoSub<unknown>> = T;
+/**
+ * Registry of pending alarm dispatches keyed by sub `id`. The cooperating DO's
+ * `alarm()` lifecycle method drains this and dispatches each msg.
+ *
+ * One alarm-queue cell at a time per DO (DO has exactly one alarm slot). We
+ * still key by `id` so multiple alarm subs scheduled in the same reconcile
+ * pass don't clobber each other — the earliest `firesAt` wins (DO native
+ * behavior) and `alarm()` drains everything due by the fire time.
+ */
+type DoAlarmRegistry<M> = Map<string, {
+    firesAt: number;
+    msg: M;
+}>;
+/**
+ * Registry of WebSocket message subscribers keyed by sub `id`. The cooperating
+ * DO's `webSocketMessage(ws, data)` consults this and dispatches
+ * `sub.msg(data)` for entries matching the incoming `socketId`.
+ */
+type DoWsRegistry<M> = Map<string, {
+    socketId: string;
+    msg: (data: string) => M;
+}>;
+/**
+ * Minimum shape a cooperating DO must put on its `Ctx` for `doSubscribe`
+ * handlers to wire up. Users may extend with anything else they like.
+ */
+interface DoSubscribeCtx<M> {
+    state: DurableObjectState;
+    alarmRegistry: DoAlarmRegistry<M>;
+    wsRegistry: DoWsRegistry<M>;
+}
+/**
+ * Build the `subscribe` handler registry for `do_alarm` and `do_ws` subs.
+ *
+ * Returned object shape matches `Machine#subscribe`'s `[K in U['type']]:
+ * (sub, ctx, dispatch) => () => void` contract for `U = DoSub<M>`.
+ *
+ * Generic `Ctx` is user-defined and must extend `DoSubscribeCtx<M>` so handlers
+ * can reach `state.storage`, `alarmRegistry`, and `wsRegistry`.
+ */
+declare function doSubscribe<M, Ctx extends DoSubscribeCtx<M>>(): {
+    do_alarm: (sub: DoAlarmSub<M>, ctx: Ctx, dispatch: (msg: M) => void) => () => void;
+    do_ws: (sub: DoWsSub<M>, ctx: Ctx, dispatch: (msg: M) => void) => () => void;
+};
+
+export { type AssertDoSubIsSub, type DoAlarmRegistry, type DoAlarmSub, type DoSub, type DoSubscribeCtx, type DoWsRegistry, type DoWsSub, doStore, doSubscribe };

package/dist/do/index.js

@@ -0,0 +1,54 @@
+// src/do/index.ts
+var DEFAULT_STATE_KEY = "@@state";
+function doStore(storage, parse, key = DEFAULT_STATE_KEY) {
+  return {
+    async load() {
+      const raw = await storage.get(key);
+      if (raw === void 0 || raw === null) return null;
+      return JSON.parse(raw);
+    },
+    async save(state) {
+      await storage.put(key, JSON.stringify(state));
+    },
+    migrate(raw) {
+      return parse(raw);
+    }
+  };
+}
+function doSubscribe() {
+  return {
+    do_alarm: (sub, ctx, _dispatch) => {
+      ctx.alarmRegistry.set(sub.id, { firesAt: sub.firesAt, msg: sub.msg });
+      const earliest = earliestFiresAt(ctx.alarmRegistry);
+      if (earliest !== null) {
+        ctx.state.storage.setAlarm(earliest).catch((err) => console.error("[tea-do] setAlarm failed", err));
+      }
+      return () => {
+        ctx.alarmRegistry.delete(sub.id);
+        const nextEarliest = earliestFiresAt(ctx.alarmRegistry);
+        if (nextEarliest === null) {
+          ctx.state.storage.deleteAlarm().catch((err) => console.error("[tea-do] deleteAlarm failed", err));
+        } else {
+          ctx.state.storage.setAlarm(nextEarliest).catch((err) => console.error("[tea-do] setAlarm failed", err));
+        }
+      };
+    },
+    do_ws: (sub, ctx, _dispatch) => {
+      ctx.wsRegistry.set(sub.id, { socketId: sub.socketId, msg: sub.msg });
+      return () => {
+        ctx.wsRegistry.delete(sub.id);
+      };
+    }
+  };
+}
+function earliestFiresAt(registry) {
+  let earliest = null;
+  for (const { firesAt } of registry.values()) {
+    if (earliest === null || firesAt < earliest) earliest = firesAt;
+  }
+  return earliest;
+}
+
+export { doStore, doSubscribe };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/do/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/do/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/// <reference types=\"@cloudflare/workers-types\" />\n/**\n * @demlik/tea/do — Durable Object adapter for `@demlik/tea`.\n *\n * Two exports drive the integration:\n *\n *   1. `doStore<S>(storage, parse, key?)` — `Store<S>` impl backed by\n *      `DurableObjectStorage`. JSON-stringifies on save, JSON-parses on load\n *      and returns `unknown` (invariant-8 boundary); the substrate then calls\n *      `migrate(raw)` (which forwards to `parse`) to turn it into `S | null`.\n *      Returns `null` (typed as `unknown`) when the key is absent. Structural\n *      JSON malformation throws at load — `run()`'s boot path surfaces that\n *      (PRD throw-semantics table: \"store.load throw at boot → run() throws\n *      synchronously\"). Shape mismatch is NOT a throw — `parse` returns\n *      `null` and the substrate boots fresh.\n *\n *   2. `doSubscribe<M, Ctx>()` — handler registry for the two DO-native sub\n *      types this package owns:\n *        - `do_alarm` — schedules a real DO alarm via `state.storage.setAlarm`;\n *          the cooperating DO's `alarm()` lifecycle method dispatches the sub's\n *          msg. Cleanup clears the alarm.\n *        - `do_ws`   — registers a WebSocket-id'd listener in a per-DO registry\n *          that the cooperating DO's `webSocketMessage()` consults. Cleanup\n *          deregisters.\n *\n * BOTH `do_alarm` and `do_ws` rely on the host DO cooperating: alarm and\n * webSocketMessage are DO lifecycle methods, not JS events the handler can\n * subscribe to from the outside. The cooperating DO must:\n *\n *   - Maintain a `Ctx` that exposes `state: DurableObjectState` AND the\n *     subscriber registries (`wsRegistry`, `alarmRegistry`). The handlers read\n *     from `ctx`.\n *   - Forward `alarm()` callbacks into the alarm registry by id, dispatching\n *     the registered msg.\n *   - Forward `webSocketMessage(ws, data)` callbacks into the ws registry,\n *     dispatching `sub.msg(data)` for matching `socketId`s.\n *\n * `src/test-worker.ts` is the canonical example of this cooperation. See\n * `test/README.md` for the convention.\n */\n\nimport type { Store, Sub, SubId } from \"../index\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// doStore — `Store<S>` over DurableObjectStorage.\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst DEFAULT_STATE_KEY = \"@@state\";\n\n/**\n * `Store<S>` over `DurableObjectStorage`.\n *\n * `parse` is REQUIRED because DO storage is a real serialization boundary —\n * the bytes that come back through `JSON.parse` are structurally `unknown`,\n * and the caller (the DO that owns `S`) is the only party with enough\n * information to validate the shape. Returning `null` from `parse` means\n * \"no usable persisted state\" — the substrate boots `init` with `loaded =\n * null`, a known-good fresh-boot path. `parse` must NOT throw per the\n * `Store<S>.migrate` contract; shape mismatch is a value (null), not a\n * panic.\n *\n * Structural malformations (the stored cell isn't even JSON) still throw at\n * `load()` — that's an infrastructure error, distinct from a schema\n * mismatch. The substrate surfaces it via `runtime.ready` rejection.\n *\n * Concrete bite this closes: when a `State` variant is renamed between\n * deploys, the DO's new code previously received a value typed as the new\n * `S` that held a runtime string from the old `S` — silent undefined\n * behavior in `init`/`update`. After this, the boundary parse rejects the\n * old shape (returns null) and the DO boots fresh, picking up its new\n * schema from the next dispatch onward.\n */\nexport function doStore<S>(\n  storage: DurableObjectStorage,\n  parse: (raw: unknown) => S | null,\n  key: string = DEFAULT_STATE_KEY,\n): Store<S> {\n  return {\n    async load(): Promise<unknown> {\n      const raw = await storage.get<string>(key);\n      if (raw === undefined || raw === null) return null;\n      // JSON.parse throws on malformed — propagate per PRD throw-semantics.\n      // The decoded value is intentionally returned as `unknown`; the\n      // substrate's `migrate` callback (forwarded from `parse`) is the\n      // boundary parse that turns it into `S | null`.\n      return JSON.parse(raw);\n    },\n    async save(state: S): Promise<void> {\n      await storage.put(key, JSON.stringify(state));\n    },\n    migrate(raw: unknown): S | null {\n      return parse(raw);\n    },\n  };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// DoSub — the two DO-native subscription variants, locked in the PRD.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * A DO alarm sub: fires `msg` at `firesAt` (epoch ms). The substrate diffs\n * subs by `id`; same id across transitions = same alarm. To reschedule, emit\n * a DIFFERENT id (e.g., `audit-timeout-v2`).\n */\nexport type DoAlarmSub<M> = { id: SubId; type: \"do_alarm\"; firesAt: number; msg: M };\n\n/**\n * A DO WebSocket sub: routes incoming messages on `socketId` through\n * `sub.msg(data)` to dispatch.\n */\nexport type DoWsSub<M> = {\n  id: SubId;\n  type: \"do_ws\";\n  socketId: string;\n  msg: (data: string) => M;\n};\n\nexport type DoSub<M> = DoAlarmSub<M> | DoWsSub<M>;\n\n// Compile-time guarantee: `DoSub<M>` is structurally a `Sub` (has `id`+`type`).\n// Erased at runtime — the `extends Sub` constraint on the alias's type\n// parameter fails to compile if `DoSub` ever drifts off the `Sub` shape.\nexport type AssertDoSubIsSub<T extends Sub = DoSub<unknown>> = T;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Ctx contract — what the cooperating DO must expose to `doSubscribe`.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Registry of pending alarm dispatches keyed by sub `id`. The cooperating DO's\n * `alarm()` lifecycle method drains this and dispatches each msg.\n *\n * One alarm-queue cell at a time per DO (DO has exactly one alarm slot). We\n * still key by `id` so multiple alarm subs scheduled in the same reconcile\n * pass don't clobber each other — the earliest `firesAt` wins (DO native\n * behavior) and `alarm()` drains everything due by the fire time.\n */\nexport type DoAlarmRegistry<M> = Map<string, { firesAt: number; msg: M }>;\n\n/**\n * Registry of WebSocket message subscribers keyed by sub `id`. The cooperating\n * DO's `webSocketMessage(ws, data)` consults this and dispatches\n * `sub.msg(data)` for entries matching the incoming `socketId`.\n */\nexport type DoWsRegistry<M> = Map<string, { socketId: string; msg: (data: string) => M }>;\n\n/**\n * Minimum shape a cooperating DO must put on its `Ctx` for `doSubscribe`\n * handlers to wire up. Users may extend with anything else they like.\n */\nexport interface DoSubscribeCtx<M> {\n  state: DurableObjectState;\n  alarmRegistry: DoAlarmRegistry<M>;\n  wsRegistry: DoWsRegistry<M>;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// doSubscribe — the handler registry.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Build the `subscribe` handler registry for `do_alarm` and `do_ws` subs.\n *\n * Returned object shape matches `Machine#subscribe`'s `[K in U['type']]:\n * (sub, ctx, dispatch) => () => void` contract for `U = DoSub<M>`.\n *\n * Generic `Ctx` is user-defined and must extend `DoSubscribeCtx<M>` so handlers\n * can reach `state.storage`, `alarmRegistry`, and `wsRegistry`.\n */\nexport function doSubscribe<M, Ctx extends DoSubscribeCtx<M>>(): {\n  do_alarm: (sub: DoAlarmSub<M>, ctx: Ctx, dispatch: (msg: M) => void) => () => void;\n  do_ws: (sub: DoWsSub<M>, ctx: Ctx, dispatch: (msg: M) => void) => () => void;\n} {\n  return {\n    do_alarm: (sub, ctx, _dispatch) => {\n      // Register the msg so the DO's `alarm()` lifecycle method can find it.\n      // `dispatch` itself is not captured here — the DO's alarm() drains the\n      // registry and calls dispatch via the runtime it owns. That keeps the\n      // cleanup race-free: clearing the registry entry is the only thing\n      // cleanup needs to do.\n      ctx.alarmRegistry.set(sub.id, { firesAt: sub.firesAt, msg: sub.msg });\n\n      // Recompute the next alarm wall-clock target. DO supports exactly one\n      // alarm slot; the earliest firesAt across all registered subs wins.\n      const earliest = earliestFiresAt(ctx.alarmRegistry);\n      // `earliestFiresAt` returns null only when the registry is empty, which\n      // cannot happen here (we just inserted). The null branch is for cleanup.\n      if (earliest !== null) {\n        // `setAlarm` is a Promise; we don't await — the substrate's subscribe\n        // signature is sync. Attach `.catch` so an unhandled rejection doesn't\n        // tear down the DO isolate silently (DO isolates terminate on\n        // unhandled rejections — silent failure in an alarm scheduler would\n        // vanish without trace otherwise).\n        ctx.state.storage\n          .setAlarm(earliest)\n          .catch((err) => console.error(\"[tea-do] setAlarm failed\", err));\n      }\n\n      return () => {\n        ctx.alarmRegistry.delete(sub.id);\n        const nextEarliest = earliestFiresAt(ctx.alarmRegistry);\n        if (nextEarliest === null) {\n          // No registered alarms left — clear the slot. `deleteAlarm` returns\n          // a Promise we don't await for the same reason as above; `.catch`\n          // for the same isolate-safety reason.\n          ctx.state.storage\n            .deleteAlarm()\n            .catch((err) => console.error(\"[tea-do] deleteAlarm failed\", err));\n        } else {\n          ctx.state.storage\n            .setAlarm(nextEarliest)\n            .catch((err) => console.error(\"[tea-do] setAlarm failed\", err));\n        }\n      };\n    },\n\n    do_ws: (sub, ctx, _dispatch) => {\n      ctx.wsRegistry.set(sub.id, { socketId: sub.socketId, msg: sub.msg });\n      return () => {\n        ctx.wsRegistry.delete(sub.id);\n      };\n    },\n  };\n}\n\n// Pure utility: lowest `firesAt` in a non-empty alarm registry, or `null`.\nfunction earliestFiresAt<M>(registry: DoAlarmRegistry<M>): number | null {\n  let earliest: number | null = null;\n  for (const { firesAt } of registry.values()) {\n    if (earliest === null || firesAt < earliest) earliest = firesAt;\n  }\n  return earliest;\n}\n"]}

package/dist/extension/index.d.ts

@@ -0,0 +1,207 @@
+import { Runtime, Store } from '../index.js';
+
+/**
+ * Runtime bridge — expose a `@demlik/tea` runtime running in one chrome context
+ * (typically the background service worker) to consumers in other contexts
+ * (sidepanel, popup, devtools panel) over `chrome.runtime.sendMessage` /
+ * `chrome.runtime.onMessage`.
+ *
+ * Two halves, one channel name string.
+ *
+ *   ┌──── background (host) ────┐               ┌──── react surface ────┐
+ *   │ bridgeRuntime(rt, {ch})   │  chrome.*     │ useBackgroundRuntime  │
+ *   │  ├ observe → broadcast     │ ──────────▶  │  ├ hydrate (initial)  │
+ *   │  └ onMessage(":dispatch") │ ◀──────────  │  └ dispatch (msgs)    │
+ *   │  └ onMessage(":hydrate")  │               │                       │
+ *   └────────────────────────────┘               └───────────────────────┘
+ *
+ * Wire-shape (single `channel` string, three messages):
+ *
+ *   { type: channel,                msg, state }   // background → surfaces (broadcast)
+ *   { type: `${channel}:hydrate`  }                 // surface → background (request)
+ *   { type: `${channel}:dispatch`, msg }            // surface → background (input)
+ *
+ * The `:hydrate` reply is the current `runtime.getState()` snapshot —
+ * lets a newly-opened surface render the right view BEFORE the next
+ * transition broadcast arrives.
+ *
+ * The bridge is intentionally agnostic to `chrome.runtime.sendMessage`
+ * failure modes (no receiver, sender gone, etc.) — every cross-context send
+ * is fire-and-forget with `.catch(() => {})`. Surfaces that need
+ * delivery guarantees should layer their own retry, not bake it here.
+ */
+
+interface BridgeRuntimeOpts<S, V = S> {
+    channel: string;
+    /**
+     * Optional projection from the runtime's live state `S` to a JSON-safe
+     * view `V` that goes over the wire (broadcast + hydrate). Required when
+     * `S` carries non-serializable values (DOM refs, Map, Date, …).
+     *
+     * Identity passthrough by default — existing callers with POJO state pass
+     * `serialize` unset and `V = S`.
+     *
+     * Wire shape with `serialize`:
+     *   { type: channel, msg, state: serialize(currentState) }   // broadcast
+     *   { type: hydrate } → { state: serialize(currentState) }    // hydrate
+     *
+     * Dispatch is NOT affected — it carries `M` end-to-end. Surfaces parse the
+     * `V` they receive (they should pick a type parameter matching the
+     * projection).
+     */
+    serialize?: (state: S) => V;
+    /**
+     * If > 0, the bridge composes a `historyTracker(runtime, size)` over the
+     * runtime and returns the captured `(msg, state)` backlog in every
+     * `:hydrate` reply. Late subscribers receive recent traffic on connect —
+     * the inspector then sees prior tool calls / phase transitions instead
+     * of just the current state snapshot.
+     *
+     * Defaults to 0 (no tracker, empty backlog). Composition stays opt-in:
+     * the substrate is untouched, the dispatch loop is untouched, and the
+     * bridge attaches the tracker only when this opt is set. Cleanup is
+     * the bridge's responsibility — the disposer returned by `bridgeRuntime`
+     * stops the tracker along with the observer.
+     *
+     * Memory cost: ~size × (msg + state) bytes, in-memory only, dies with
+     * the bridge. Privacy: backlog entries flow to every `:hydrate` reply —
+     * any surface that can hydrate sees them. Do not enable on bridges
+     * carrying user secrets.
+     */
+    historySize?: number;
+}
+/**
+ * Install the bridge for a runtime. Returns a cleanup function that removes
+ * the observer and the chrome listener.
+ *
+ * - **Broadcast:** every (msg, state) transition emits
+ *   `{ type: channel, msg, state }` via `chrome.runtime.sendMessage`. The
+ *   send is fire-and-forget — when no surface is listening, chrome.runtime
+ *   rejects with "Could not establish connection. Receiving end does not
+ *   exist." which we swallow. If `serialize` is provided, `state` carries
+ *   `serialize(state)` instead of the raw state.
+ * - **Hydrate:** `{ type: ":hydrate" }` is answered via `sendResponse` with
+ *   the current (optionally projected) `runtime.getState()`. If the runtime
+ *   is mid-boot (store load not yet resolved), `getState()` throws — we
+ *   swallow and reply with `state: null`; surfaces should treat null as
+ *   "not ready yet" and wait for the first broadcast.
+ * - **Dispatch:** `{ type: ":dispatch", msg }` routes to `runtime.dispatch`.
+ *   Returns `true` from the listener so chrome keeps the message channel
+ *   open until dispatch's promise settles (we ack with `{ ok: true }`).
+ */
+declare function bridgeRuntime<S, M extends {
+    type: string;
+}, V = S>(runtime: Runtime<S, M>, { channel, serialize, historySize }: BridgeRuntimeOpts<S, V>): () => void;
+interface BridgeClient<S, M> {
+    /** Send the hydrate request; resolves with the initial snapshot (or null
+     * if the host is still booting OR the response failed to parse). Also
+     * primes `getSnapshot()` so React's `useSyncExternalStore` sees the
+     * hydrated value on the next render. */
+    hydrate(): Promise<S | null>;
+    /** Send a dispatch envelope; resolves once the host's dispatch settles. */
+    dispatch(msg: M): Promise<void>;
+    /** Subscribe to broadcasts. Returns a cleanup function. Broadcasts whose
+     * payload fails `parseState` (or, if provided, `parseMsg`) are dropped
+     * silently — the listener is not called. Each successful broadcast
+     * updates `getSnapshot()`. */
+    subscribe(listener: (msg: M | null, state: S) => void): () => void;
+    /** Synchronous accessor for the latest known state, or `null` until the
+     * first successful hydrate or broadcast lands. Required reference stability
+     * for `useSyncExternalStore`: returns the SAME object reference when the
+     * underlying state hasn't changed since the prior call. */
+    getSnapshot(): S | null;
+}
+interface BridgeClientOpts<S, M> {
+    channel: string;
+    /**
+     * REQUIRED parse for inbound `state` payloads (from `:hydrate` reply AND
+     * every broadcast). Chrome runtime messages are an `unknown` boundary
+     * (Inv 8) — the surface is the only party that knows the domain type `S`,
+     * so it owns the boundary parse. Returning `null` drops the payload
+     * silently (subscriber not called; hydrate resolves to `null`). The
+     * parser MUST NOT throw — model rejection as `null`.
+     */
+    parseState: (raw: unknown) => S | null;
+    /**
+     * Optional parse for inbound `msg` payloads on broadcasts. Defaults to a
+     * pass-through cast — most surfaces only need to gate on state and treat
+     * the msg union as advisory. Provide this when malformed msgs must be
+     * dropped (e.g. when the host's M is a real wire enum, not a local type).
+     * Returning `null` drops the broadcast silently.
+     */
+    parseMsg?: (raw: unknown) => M | null;
+}
+declare function bridgeClient<S, M extends {
+    type: string;
+}>({ channel, parseState, parseMsg, }: BridgeClientOpts<S, M>): BridgeClient<S, M>;
+interface BridgeTabClientOpts<S, M> {
+    tabId: number;
+    channel: string;
+    /**
+     * REQUIRED parse for inbound `state` payloads. See `BridgeClientOpts.parseState`
+     * — same contract, same rationale. Chrome runtime messages from a tab are
+     * an `unknown` boundary; the SW client owns the parse.
+     */
+    parseState: (raw: unknown) => S | null;
+    /**
+     * Optional parse for inbound `msg` payloads. See
+     * `BridgeClientOpts.parseMsg`.
+     */
+    parseMsg?: (raw: unknown) => M | null;
+}
+/**
+ * SW-side client of a `bridgeRuntime` hosted in a content script.
+ *
+ * Identical contract to `bridgeClient` (same `BridgeClient<S, M>` shape).
+ * Differences are confined to transport:
+ *
+ * - `hydrate()` / `dispatch(msg)` send via `chrome.tabs.sendMessage(tabId, …)`.
+ *   If the tab is gone, `chrome.tabs.sendMessage` rejects (same shape as
+ *   `chrome.runtime.sendMessage` with no receiver) — the promise propagates
+ *   the rejection. Callers decide whether to retry, drop, or surface; the
+ *   bridge has no opinion. Fire-and-forget posture matches `bridgeRuntime`.
+ * - `subscribe(listener)` registers a `chrome.runtime.onMessage` listener
+ *   filtered by both `envelope.type === channel` AND `sender.tab?.id === tabId`,
+ *   so broadcasts from other tabs are ignored (no cross-contamination across
+ *   per-tab content-script runtimes).
+ */
+declare function bridgeTabClient<S, M extends {
+    type: string;
+}>({ tabId, channel, parseState, parseMsg, }: BridgeTabClientOpts<S, M>): BridgeClient<S, M>;
+
+/**
+ * @demlik/tea/extension — Chrome service-worker host adapter for @demlik/tea.
+ *
+ * Substrate-level companion to @demlik/tea/do (Durable Objects) and
+ * @demlik/tea/react (React). Lets a chrome service worker run a @demlik/tea
+ * machine with persistence backed by chrome.storage.
+ *
+ * Single export: chromeStorageStore<S>(key, area?). Apps register chrome.*
+ * listeners themselves and call runtime.dispatch from inside the handler —
+ * those wiring patterns are app-specific (different extensions register
+ * different listener sets, with different Msg adapters), so we don't
+ * abstract them here until the shape stabilizes across consumers.
+ */
+
+/**
+ * `Store<S>` backed by `chrome.storage.local` (or any compatible
+ * `StorageArea`). JSON.stringify on save, JSON.parse on load. Returns `null`
+ * (typed as `unknown` per `Store<S>.load` contract) when the key is absent.
+ *
+ * Throws on the structural layer if the stored value is malformed (non-string
+ * at the key, or unparseable JSON) — matches @demlik/tea/do's "throw at boot via
+ * store.load" contract so tea's `run()` surfaces it predictably. The
+ * `parse` callback handles the semantic layer (shape mismatch → return
+ * `null`); it must NOT throw, per the `Store<S>.migrate` contract.
+ *
+ * `parse` is REQUIRED because chrome.storage is a real serialization boundary
+ * — JSON to disk, then back — and the structural type of what comes back is
+ * `unknown`. The caller (extension code that knows `S`) is the only party
+ * with enough information to write the parse. There is no honest default.
+ *
+ * `area` defaults to `chrome.storage.local` for production. Tests pass a
+ * `fakeChrome().storage.local` in.
+ */
+declare function chromeStorageStore<S>(key: string, parse: (raw: unknown) => S | null, area?: chrome.storage.StorageArea): Store<S>;
+
+export { type BridgeClient, type BridgeClientOpts, type BridgeRuntimeOpts, type BridgeTabClientOpts, bridgeClient, bridgeRuntime, bridgeTabClient, chromeStorageStore };

package/dist/extension/index.js

@@ -0,0 +1,26 @@
+export { bridgeClient, bridgeRuntime, bridgeTabClient } from '../chunk-PYOCUBQJ.js';
+import '../chunk-CMG2KMWX.js';
+
+// src/extension/index.ts
+var MALFORMED = "chromeStorageStore: stored value is not a string";
+function chromeStorageStore(key, parse, area = chrome.storage.local) {
+  return {
+    async load() {
+      const result = await area.get(key);
+      const raw = result[key];
+      if (raw === void 0 || raw === null) return null;
+      if (typeof raw !== "string") throw new Error(`${MALFORMED} at key "${key}"`);
+      return JSON.parse(raw);
+    },
+    async save(state) {
+      await area.set({ [key]: JSON.stringify(state) });
+    },
+    migrate(raw) {
+      return parse(raw);
+    }
+  };
+}
+
+export { chromeStorageStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/extension/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/extension/index.ts"],"names":[],"mappings":";;;;AA6BA,IAAM,SAAA,GAAY,kDAAA;AAqBX,SAAS,mBACd,GAAA,EACA,KAAA,EACA,IAAA,GAAmC,MAAA,CAAO,QAAQ,KAAA,EACxC;AACV,EAAA,OAAO;AAAA,IACL,MAAM,IAAA,GAAyB;AAC7B,MAAA,MAAM,MAAA,GAAS,MAAM,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA;AACjC,MAAA,MAAM,GAAA,GAAO,OAAmC,GAAG,CAAA;AACnD,MAAA,IAAI,GAAA,KAAQ,MAAA,IAAa,GAAA,KAAQ,IAAA,EAAM,OAAO,IAAA;AAC9C,MAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,EAAU,MAAM,IAAI,MAAM,CAAA,EAAG,SAAS,CAAA,SAAA,EAAY,GAAG,CAAA,CAAA,CAAG,CAAA;AAK3E,MAAA,OAAO,IAAA,CAAK,MAAM,GAAG,CAAA;AAAA,IACvB,CAAA;AAAA,IACA,MAAM,KAAK,KAAA,EAAyB;AAClC,MAAA,MAAM,IAAA,CAAK,GAAA,CAAI,EAAE,CAAC,GAAG,GAAG,IAAA,CAAK,SAAA,CAAU,KAAK,CAAA,EAAG,CAAA;AAAA,IACjD,CAAA;AAAA,IACA,QAAQ,GAAA,EAAwB;AAC9B,MAAA,OAAO,MAAM,GAAG,CAAA;AAAA,IAClB;AAAA,GACF;AACF","file":"index.js","sourcesContent":["/**\n * @demlik/tea/extension — Chrome service-worker host adapter for @demlik/tea.\n *\n * Substrate-level companion to @demlik/tea/do (Durable Objects) and\n * @demlik/tea/react (React). Lets a chrome service worker run a @demlik/tea\n * machine with persistence backed by chrome.storage.\n *\n * Single export: chromeStorageStore<S>(key, area?). Apps register chrome.*\n * listeners themselves and call runtime.dispatch from inside the handler —\n * those wiring patterns are app-specific (different extensions register\n * different listener sets, with different Msg adapters), so we don't\n * abstract them here until the shape stabilizes across consumers.\n */\n\nimport type { Store } from \"../index\";\n\nexport type {\n  BridgeClient,\n  BridgeClientOpts,\n  BridgeRuntimeOpts,\n  BridgeTabClientOpts,\n} from \"./bridge\";\n// Re-export the wire-envelope types — surfaces that test against the\n// bridge can pin the shapes without round-tripping through the runtime.\n// Re-export the runtime bridge primitives. The React adapter lives at\n// `@demlik/tea/extension/react` so the main entry stays react-free for the\n// background service-worker side.\nexport { bridgeClient, bridgeRuntime, bridgeTabClient } from \"./bridge\";\n\nconst MALFORMED = \"chromeStorageStore: stored value is not a string\";\n\n/**\n * `Store<S>` backed by `chrome.storage.local` (or any compatible\n * `StorageArea`). JSON.stringify on save, JSON.parse on load. Returns `null`\n * (typed as `unknown` per `Store<S>.load` contract) when the key is absent.\n *\n * Throws on the structural layer if the stored value is malformed (non-string\n * at the key, or unparseable JSON) — matches @demlik/tea/do's \"throw at boot via\n * store.load\" contract so tea's `run()` surfaces it predictably. The\n * `parse` callback handles the semantic layer (shape mismatch → return\n * `null`); it must NOT throw, per the `Store<S>.migrate` contract.\n *\n * `parse` is REQUIRED because chrome.storage is a real serialization boundary\n * — JSON to disk, then back — and the structural type of what comes back is\n * `unknown`. The caller (extension code that knows `S`) is the only party\n * with enough information to write the parse. There is no honest default.\n *\n * `area` defaults to `chrome.storage.local` for production. Tests pass a\n * `fakeChrome().storage.local` in.\n */\nexport function chromeStorageStore<S>(\n  key: string,\n  parse: (raw: unknown) => S | null,\n  area: chrome.storage.StorageArea = chrome.storage.local,\n): Store<S> {\n  return {\n    async load(): Promise<unknown> {\n      const result = await area.get(key);\n      const raw = (result as Record<string, unknown>)[key];\n      if (raw === undefined || raw === null) return null;\n      if (typeof raw !== \"string\") throw new Error(`${MALFORMED} at key \"${key}\"`);\n      // JSON.parse throws on malformed — propagate per @demlik/tea/do parity.\n      // The decoded value is intentionally returned as `unknown`; the\n      // substrate's `migrate` callback (forwarded from `parse`) is the\n      // boundary parse that turns it into `S | null`.\n      return JSON.parse(raw);\n    },\n    async save(state: S): Promise<void> {\n      await area.set({ [key]: JSON.stringify(state) });\n    },\n    migrate(raw: unknown): S | null {\n      return parse(raw);\n    },\n  };\n}\n"]}

package/dist/extension/react.d.ts

@@ -0,0 +1,121 @@
+import { ReactNode } from 'react';
+
+/**
+ * React adapters for the background TEA runtime.
+ *
+ * Two layers, both built on the same `bridgeClient`:
+ *
+ *   1. `useBackgroundRuntime(opts)` — direct hook. One bridge client per
+ *      call. Surfaces that only have a single consumer mount it inline.
+ *
+ *   2. `createBackgroundRuntimeContext<S, M>()` → `{ Provider, useDispatch,
+ *      useState, useRuntime }` — factory-style React context. Mounts the
+ *      bridge client ONCE inside the Provider; child hooks read `state` /
+ *      `dispatch` from context. Surfaces that drill `dispatch` through
+ *      multiple component layers, or mount `useBackgroundRuntime` more
+ *      than once for the same channel, should use this instead.
+ *
+ * Why a factory (not a single global context):
+ *   - Type safety: each app types it against its own `S` / `M`.
+ *   - Tests can mount fresh contexts per test (no module-level state to
+ *     reset).
+ *   - Multiple-runtimes case: an app COULD theoretically have two
+ *     background-shaped runtimes (e.g. one per channel); the factory
+ *     pattern doesn't preclude it.
+ *
+ * Hook lifecycle (`useBackgroundRuntime`) — preserved from the prior
+ * single-export module:
+ *   1. `useSyncExternalStore` subscribes to broadcasts via
+ *      `bridgeClient.subscribe`, reading the latest state via
+ *      `bridgeClient.getSnapshot`. Reference stability is owned by the
+ *      bridge — `getSnapshot` returns the SAME `S` until a new broadcast
+ *      overwrites it, so React doesn't loop.
+ *   2. A one-shot `hydrate()` call seeds `latestState` before the first
+ *      broadcast arrives. The hydrate side-effect runs in an effect so the
+ *      first render shows `null` and the subsequent render flips to the
+ *      hydrated snapshot (or stays null if the host is still booting).
+ *   3. `dispatch(msg)` sends `:dispatch` envelopes.
+ *
+ * On unmount: `useSyncExternalStore` removes the listener; the host's
+ * bridge stays installed.
+ *
+ * Canon §3.1: React adapters use `useSyncExternalStore`, not
+ * `useState + useEffect`. `useMachine` and `useRuntime` already follow this
+ * — `useBackgroundRuntime` (and by extension the Provider) does too. One
+ * Way to Do Each Thing.
+ *
+ * NOTE: This is a separate entry from the main `index.ts` so apps that
+ * never need React don't drag react into their type graph. The React
+ * adapter peer-depends on react (you must have it installed in the app).
+ */
+
+interface UseBackgroundRuntimeOpts<S> {
+    channel: string;
+    /**
+     * REQUIRED parse for inbound `state` payloads. Forwarded to
+     * `bridgeClient` — see `BridgeClientOpts.parseState`. Surfaces own this
+     * because the chrome.runtime boundary is `unknown` (Inv 8). Returning
+     * `null` drops the payload silently.
+     */
+    parseState: (raw: unknown) => S | null;
+}
+interface UseBackgroundRuntimeResult<S, M> {
+    /** Latest snapshot from the host. `null` until the first hydrate response
+     * or the first broadcast arrives. Surfaces SHOULD render a placeholder
+     * for the null window. */
+    state: S | null;
+    /** Send a msg to the host runtime. Resolves once the host's dispatch
+     * settles. */
+    dispatch(msg: M): Promise<void>;
+}
+declare function useBackgroundRuntime<S, M extends {
+    type: string;
+}>({ channel, parseState, }: UseBackgroundRuntimeOpts<S>): UseBackgroundRuntimeResult<S, M>;
+interface BackgroundRuntimeContext<S, M> {
+    /**
+     * Wrap a subtree to share a single background-runtime bridge client.
+     * `opts` is forwarded verbatim to `useBackgroundRuntime` — same channel,
+     * same parse contract.
+     */
+    Provider: (props: {
+        opts: UseBackgroundRuntimeOpts<S>;
+        children: ReactNode;
+    }) => ReactNode;
+    /**
+     * Returns the dispatch function bound to this Provider's bridge client.
+     * Reference is stable across renders (per `useBackgroundRuntime`'s
+     * `useCallback`), so passing it to memoized children won't churn them.
+     */
+    useDispatch: () => (msg: M) => Promise<void>;
+    /**
+     * Returns a slice of the latest state. `selector` defaults to identity
+     * (returns the whole `S | null` snapshot). Selectors run on every state
+     * change — surfaces with expensive transforms should memoize the
+     * selector at call site.
+     *
+     * Returns `null` until the first hydrate / broadcast lands when the
+     * selector is identity; for non-identity selectors the return type is
+     * `T` and the caller's selector decides how to handle the pre-hydrate
+     * `null` snapshot.
+     */
+    useState: {
+        (): S | null;
+        <T>(selector: (state: S | null) => T): T;
+    };
+    /**
+     * Escape hatch — returns the full `{ state, dispatch }` pair as-is.
+     * Useful for consumers that want both the snapshot and the dispatch
+     * fn in a single hook call (e.g. effects that read state THEN
+     * dispatch in response).
+     *
+     * Not a `@demlik/tea` `Runtime<S, M>` — the bridge surface is a thinner
+     * client. This hook returns the same shape as `useBackgroundRuntime`,
+     * just sourced from context instead of mounting a fresh client.
+     */
+    useRuntime: () => UseBackgroundRuntimeResult<S, M>;
+}
+declare function createBackgroundRuntimeContext<S, M extends {
+    type: string;
+}>(): BackgroundRuntimeContext<S, M>;
+
+export { type BackgroundRuntimeContext, type UseBackgroundRuntimeOpts, type UseBackgroundRuntimeResult, createBackgroundRuntimeContext, useBackgroundRuntime };

package/dist/extension/react.js

@@ -0,0 +1,69 @@
+import { bridgeClient } from '../chunk-PYOCUBQJ.js';
+import '../chunk-CMG2KMWX.js';
+import { useRef, useSyncExternalStore, useEffect, useCallback, createContext, useMemo, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function useBackgroundRuntime({
+  channel,
+  parseState
+}) {
+  const clientRef = useRef(null);
+  if (clientRef.current === null) {
+    clientRef.current = bridgeClient({ channel, parseState });
+  }
+  const client = clientRef.current;
+  const state = useSyncExternalStore(
+    client.subscribe,
+    client.getSnapshot,
+    client.getSnapshot
+  );
+  useEffect(() => {
+    client.hydrate().catch(() => {
+    });
+  }, [client]);
+  const dispatch = useCallback(
+    async (msg) => {
+      await client.dispatch(msg);
+    },
+    [client]
+  );
+  return { state, dispatch };
+}
+var PROVIDER_ERROR = "createBackgroundRuntimeContext: hook used outside its Provider. Wrap the consumer in <BackgroundRuntime.Provider opts={...}>.";
+function createBackgroundRuntimeContext() {
+  const Ctx = createContext(null);
+  function Provider({
+    opts,
+    children
+  }) {
+    const result = useBackgroundRuntime(opts);
+    const value = useMemo(
+      () => ({ state: result.state, dispatch: result.dispatch }),
+      [result.state, result.dispatch]
+    );
+    return /* @__PURE__ */ jsx(Ctx.Provider, { value, children });
+  }
+  function useRuntime() {
+    const ctx = useContext(Ctx);
+    if (ctx === null) throw new Error(PROVIDER_ERROR);
+    return ctx;
+  }
+  function useDispatch() {
+    return useRuntime().dispatch;
+  }
+  function useStateHook(selector) {
+    const { state } = useRuntime();
+    if (selector === void 0) return state;
+    return selector(state);
+  }
+  return {
+    Provider,
+    useDispatch,
+    useState: useStateHook,
+    useRuntime
+  };
+}
+
+export { createBackgroundRuntimeContext, useBackgroundRuntime };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map