@demlik/tea 0.12.0 → 0.14.0

package/dist/chunk-RQULHGYH.js

@@ -0,0 +1,1804 @@
+import { Result } from 'better-result';
+
+// src/observability.ts
+function historyTracker(runtime, size) {
+  const buffer = [];
+  let stopped = false;
+  const push = (entry) => {
+    buffer.push(entry);
+    if (buffer.length > size) buffer.shift();
+  };
+  const unobserve = size <= 0 ? () => {
+  } : runtime.observe((msg, state) => {
+    push({ msg, state });
+  });
+  const unboot = size <= 0 ? () => {
+  } : runtime.onBoot((state) => {
+    push({ msg: null, state });
+  });
+  return {
+    snapshot() {
+      return buffer.slice();
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      unobserve();
+      unboot();
+    }
+  };
+}
+
+// src/provide/index.ts
+var providedBrand = /* @__PURE__ */ Symbol("demlik-tea.provided");
+var ProvideFailedError = class extends Error {
+  _tag = "provide_failed";
+  /** The provider key whose `acquire` failed. */
+  provider;
+  constructor(provider, cause) {
+    super(
+      `@demlik/tea: provider ${JSON.stringify(provider)} failed to acquire`,
+      { cause }
+    );
+    this.name = "ProvideFailedError";
+    this.provider = provider;
+  }
+};
+var UnknownProviderError = class extends Error {
+  _tag = "unknown_provider";
+  /** The missing key. */
+  provider;
+  /** The provider that asked for it. */
+  requiredBy;
+  constructor(provider, requiredBy) {
+    super(
+      `@demlik/tea: provider ${JSON.stringify(requiredBy)} depends on ${JSON.stringify(provider)}, which the provider map has no entry for`
+    );
+    this.name = "UnknownProviderError";
+    this.provider = provider;
+    this.requiredBy = requiredBy;
+  }
+};
+var ProviderCycleError = class extends Error {
+  _tag = "provider_cycle";
+  /** The cycle, in the order it was walked, closing on its own first key. */
+  cycle;
+  constructor(cycle) {
+    super(`@demlik/tea: provider dependency cycle \u2014 ${cycle.join(" \u2192 ")}`);
+    this.name = "ProviderCycleError";
+    this.cycle = cycle;
+  }
+};
+function dep() {
+  return (name) => ({ name });
+}
+function layer(first, second, third) {
+  if (typeof first === "function") {
+    return {
+      deps: [],
+      acquire: first,
+      release: second
+    };
+  }
+  return {
+    // Tokens collapse to their names here: `deps` is a name list at runtime
+    // whichever overload wrote it, so the walk in `provide` stays one path and
+    // a graph assembled from tokens journals nothing extra.
+    deps: first.map(
+      (entry) => typeof entry === "string" ? entry : entry.name
+    ),
+    acquire: second,
+    release: third
+  };
+}
+function value(v) {
+  return { deps: [], acquire: () => v };
+}
+function provide(map) {
+  const keys = Object.keys(map);
+  const nodes = map;
+  return {
+    [providedBrand]: true,
+    async open(onReleaseError = defaultOnReleaseError) {
+      const built = /* @__PURE__ */ new Map();
+      const acquired = [];
+      const path = [];
+      async function build(key, requiredBy) {
+        if (built.has(key)) return built.get(key);
+        const provider = nodes[key];
+        if (provider === void 0) {
+          throw new UnknownProviderError(key, requiredBy);
+        }
+        if (path.includes(key)) {
+          throw new ProviderCycleError([...path.slice(path.indexOf(key)), key]);
+        }
+        path.push(key);
+        const deps = {};
+        for (const dep2 of provider.deps) {
+          deps[dep2] = await build(dep2, key);
+        }
+        let acquiredValue;
+        try {
+          acquiredValue = await provider.acquire(deps);
+        } catch (error) {
+          throw new ProvideFailedError(key, error);
+        }
+        path.pop();
+        built.set(key, acquiredValue);
+        acquired.push({ key, provider });
+        return acquiredValue;
+      }
+      let released = false;
+      async function releaseAll() {
+        if (released) return;
+        released = true;
+        for (let i = acquired.length - 1; i >= 0; i--) {
+          const entry = acquired[i];
+          if (entry === void 0) continue;
+          const { key, provider } = entry;
+          const release = provider.release;
+          if (release === void 0) continue;
+          try {
+            await release(built.get(key));
+          } catch (error) {
+            onReleaseError(error, key);
+          }
+        }
+      }
+      try {
+        for (const key of keys) await build(key, key);
+      } catch (error) {
+        await releaseAll();
+        throw error;
+      }
+      const ctx = Object.fromEntries(
+        keys.map((key) => [key, built.get(key)])
+      );
+      return { ctx, release: releaseAll };
+    }
+  };
+}
+function isProvided(candidate) {
+  return typeof candidate === "object" && candidate !== null && candidate[providedBrand] === true;
+}
+function defaultOnReleaseError(error, provider) {
+  console.warn(
+    `@demlik/tea: release of provider ${JSON.stringify(provider)} threw`,
+    error
+  );
+}
+
+// src/pure/core.ts
+var __DEV__ = (() => {
+  try {
+    const meta = import.meta;
+    if (meta.env?.DEV !== void 0) {
+      return meta.env.DEV;
+    }
+  } catch {
+  }
+  try {
+    return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+  } catch {
+    return false;
+  }
+})();
+function deepFreeze(obj, seen) {
+  if (obj === null || typeof obj !== "object") return obj;
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== Array.prototype && proto !== null)
+    return obj;
+  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+  if (visited.has(obj)) return obj;
+  visited.add(obj);
+  Object.freeze(obj);
+  for (const v of Object.values(obj))
+    deepFreeze(v, visited);
+  return obj;
+}
+function hasFunctionValues(obj) {
+  if (obj === null || typeof obj !== "object") return null;
+  for (const [key, value2] of Object.entries(obj)) {
+    if (typeof value2 === "function") return key;
+  }
+  return null;
+}
+function assertPureResult(result, msgType) {
+  if (result && typeof result.then === "function") {
+    throw new Error(
+      `@demlik/tea: update cell "${msgType}" returned a Promise. update must be synchronous. Move async work to interpret.`
+    );
+  }
+  if (!Array.isArray(result) || result.length < 2 || !Array.isArray(result[1])) {
+    throw new Error(
+      `@demlik/tea: update cell "${msgType}" returned a non-tuple. Expected [State, Cmd[]], got ${typeof result}.`
+    );
+  }
+  const cmds = result[1];
+  for (const cmd of cmds) {
+    const fnField = hasFunctionValues(cmd);
+    if (fnField !== null) {
+      throw new Error(
+        `@demlik/tea: Cmd "${cmd.type}" has function field "${fnField}". Cmds must be plain data, not closures.`
+      );
+    }
+  }
+}
+function without(rec, key) {
+  const { [key]: _dropped, ...rest } = rec;
+  return rest;
+}
+function malformedResult(issues) {
+  return {
+    _tag: "malformed_result",
+    issues: issues.map((issue) => ({
+      path: issue.path.map(String).join("."),
+      message: issue.message
+    }))
+  };
+}
+var cmdEdge = /* @__PURE__ */ Symbol("tea.cmdEdge");
+function cmdEdgeOver(defs, clock) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const def of defs) byType.set(def.cmdType, def);
+  return (cmd, follow) => {
+    const def = byType.get(cmd.type);
+    if (def === void 0 || !isSettledShape(follow)) return follow;
+    const at = follow.at ?? clock();
+    if (follow.type === def.okType) {
+      const parsed = def.schema.ok.safeParse(follow.value);
+      if (!parsed.success) {
+        return {
+          type: def.errType,
+          cmd: follow.cmd,
+          error: malformedResult(parsed.error.issues),
+          at
+        };
+      }
+      return { ...follow, value: parsed.data, at };
+    }
+    if (follow.type === def.errType) return { ...follow, at };
+    return follow;
+  };
+}
+function cmdEdgeOf(ctx) {
+  const edge = typeof ctx === "object" && ctx !== null ? ctx[cmdEdge] : void 0;
+  return edge ?? ((_, follow) => follow);
+}
+var detachWork = /* @__PURE__ */ Symbol("tea.detachWork");
+function detachWorkOf(ctx) {
+  const detach = typeof ctx === "object" && ctx !== null ? ctx[detachWork] : void 0;
+  return detach ?? (() => void 0);
+}
+function isSettledShape(follow) {
+  return typeof follow === "object" && follow !== null && typeof follow.type === "string";
+}
+function defineCmd(name, spec) {
+  const okType = `${name}_ok`;
+  const errType = `${name}_err`;
+  const build = (input) => ({ ...input, type: name });
+  return Object.assign(build, {
+    cmdType: name,
+    okType,
+    errType,
+    ok: (cmd, value2, at) => stamp({ type: okType, cmd, value: value2 }, at),
+    err: (cmd, error, at) => stamp({ type: errType, cmd, error }, at),
+    schema: { input: spec.input, ok: spec.ok },
+    errTags: spec.err
+  });
+}
+function stamp(msg, at) {
+  return at === void 0 ? msg : { ...msg, at };
+}
+function detectUpdateForm(update) {
+  const firstKey = Object.keys(update)[0];
+  if (firstKey === void 0) return "reducer";
+  const firstValue = update[firstKey];
+  return typeof firstValue === "function" ? "reducer" : "transitions";
+}
+function formOf(machine) {
+  return machine.__form ?? detectUpdateForm(machine.update);
+}
+var NoCellError = class extends Error {
+  constructor(msgType, stateName, acceptedTypes2) {
+    super(
+      // The pre-#14 text is kept VERBATIM as a prefix: a caller matching on it
+      // keeps matching, and the new clause only ever appends.
+      `@demlik/tea: no update cell for msg.type "${msgType}" in state "${stateName}" \u2014 the machine's update does not handle this Msg (an unknown wire msg.type, or a missing cell reached by bypassing the mapped types).` + (acceptedTypes2.length === 0 ? ` This state accepts no Msg at all.` : ` This state accepts: ${acceptedTypes2.map((t) => `"${t}"`).join(", ")}.`)
+    );
+    this.msgType = msgType;
+    this.stateName = stateName;
+    this.acceptedTypes = acceptedTypes2;
+  }
+  msgType;
+  stateName;
+  acceptedTypes;
+  name = "NoCellError";
+  _tag = "NoCellError";
+};
+function stateNameOf(state) {
+  if (state === void 0 || state === null) return "(no state)";
+  if (typeof state === "object" && "type" in state) {
+    const t = state.type;
+    if (typeof t === "string") return t;
+  }
+  return "(untagged state)";
+}
+function acceptedTypes(machine, state) {
+  if (state === void 0 || state === null) return [];
+  if (formOf(machine) === "reducer") {
+    return cellKeysOf(machine.update);
+  }
+  const table = machine.update;
+  const row = table[state.type];
+  return row === void 0 || row === null ? [] : cellKeysOf(row);
+}
+function cellKeysOf(row) {
+  return Object.keys(row).filter(
+    (key) => typeof row[key] === "function"
+  );
+}
+function lookupCell(machine, state, msg) {
+  if (state === void 0 || state === null) {
+    return {
+      cell: void 0,
+      stateName: stateNameOf(state),
+      acceptedTypes: acceptedTypes(machine, state)
+    };
+  }
+  if (formOf(machine) === "reducer") {
+    const record = machine.update;
+    const cell2 = record[msg.type];
+    const stateName2 = stateNameOf(state);
+    return typeof cell2 === "function" ? { cell: cell2, stateName: stateName2 } : {
+      cell: void 0,
+      stateName: stateName2,
+      acceptedTypes: acceptedTypes(machine, state)
+    };
+  }
+  const table = machine.update;
+  const stateKey = state.type;
+  const cell = table[stateKey]?.[msg.type];
+  const stateName = String(stateKey);
+  return typeof cell === "function" ? { cell, stateName } : {
+    cell: void 0,
+    stateName,
+    acceptedTypes: acceptedTypes(machine, state)
+  };
+}
+function applyCell(machine, state, msg) {
+  const found = lookupCell(machine, state, msg);
+  if (found.cell === void 0) {
+    throw new NoCellError(msg.type, found.stateName, found.acceptedTypes);
+  }
+  return found.cell(state, msg);
+}
+function applyCellChecked(machine, state, msg) {
+  if (__DEV__) deepFreeze(state);
+  const result = applyCell(machine, state, msg);
+  if (__DEV__) assertPureResult(result, msg.type);
+  return result;
+}
+function msgKeysOf(machine) {
+  const keys = Object.keys(machine.update);
+  if (keys.length === 0) return [];
+  if (formOf(machine) === "reducer") return keys;
+  const table = machine.update;
+  const seen = /* @__PURE__ */ new Set();
+  const union = [];
+  for (const stateKey of keys) {
+    const row = table[stateKey];
+    if (row === null || row === void 0) continue;
+    for (const msgKey of Object.keys(row)) {
+      if (seen.has(msgKey)) continue;
+      seen.add(msgKey);
+      union.push(msgKey);
+    }
+  }
+  return union;
+}
+function describeMachine(machine) {
+  const msgs = msgKeysOf(machine);
+  if (formOf(machine) === "reducer") return { form: "reducer", msgs };
+  const table = machine.update;
+  const states = Object.keys(table);
+  const accepts = {};
+  for (const stateKey of states) {
+    const row = table[stateKey];
+    accepts[stateKey] = row === null || row === void 0 ? [] : Object.keys(row);
+  }
+  return { form: "transitions", msgs, states, accepts };
+}
+function acceptsOf(machine, stateType) {
+  const shape = describeMachine(machine);
+  if (shape.form === "reducer") return shape.msgs;
+  return shape.accepts[stateType] ?? [];
+}
+var Cmd = {
+  /**
+   * Declare a typed Cmd constructor (ADR 0014). Returns the builder —
+   * `fetch({ url })` yields `{ type: "fetch", url }` — carrying the minted Msg
+   * builders `fetch.ok(cmd, value)` / `fetch.err(cmd, error)` and the
+   * declaration the runtime edge parses against. `Settled<typeof fetch>` is
+   * the two-arm Msg union it settles with; `defineMachine({ cmds: [fetch] })`
+   * folds that union into the machine's `M`.
+   *
+   *   const fetch = Cmd.define("fetch", {
+   *     input: z.object({ url: z.string() }),
+   *     ok: z.object({ status: z.number(), body: z.string() }),
+   *     err: ["not_found", "timeout"],
+   *     requirements: Cmd.requirements<{ http: Http }>(),
+   *   });
+   *
+   * `err` is the `_tag` list the handler may settle with; the runtime adds
+   * `malformed_result` for an `_ok` value the `ok` schema rejects. `requirements`
+   * names the `Ctx` slice the handler reads — `run` refuses a ctx without it.
+   *
+   * A Cmd must not wait; see `DepKeyedSub` for anything that watches.
+   */
+  define: defineCmd,
+  /**
+   * Name a Cmd's `R` — the `Ctx` slice its handler reads. A phantom: nothing
+   * is built, nothing is checked at runtime; the type is what `run` reads.
+   */
+  requirements: () => ({}),
+  /**
+   * The empty Cmd array. Typed `readonly never[]` so it's assignable to any
+   * `readonly C[]` for any `C extends Cmd`. Use in `init` returns and
+   * Transitions cells that emit zero effects:
+   *
+   *   init: (loaded) => [loaded ?? initial, Cmd.none],
+   *   tick: (state) => [state, Cmd.none],
+   *
+   * Elm's `Cmd.none` analogue. Cultural signal alongside the runtime help:
+   * `[state, Cmd.none]` reads as intent ("this transition emits nothing"),
+   * `[state, []]` reads as "empty array of what".
+   *
+   * Frozen at runtime so a downstream consumer can't `.push()` into the
+   * shared reference.
+   */
+  none: Object.freeze([]),
+  /**
+   * Flat concat of cmd arrays. Use when a cell composes effects from
+   * multiple conditional sources:
+   *
+   *   return [next, Cmd.batch(
+   *     Cmd.whenDefined(state.queueItemId, (id) => ({ type: "complete", id })),
+   *     Cmd.when(state.windowId !== undefined, { type: "close_window", windowId }),
+   *     [{ type: "detach_debugger", tabId: state.tabId }],
+   *   )];
+   *
+   * `<const C>` keeps inline cmd literals' discriminants narrow (same
+   * rationale as `when` / `whenDefined` above).
+   */
+  batch: (...arrs) => {
+    const out = [];
+    for (const arr of arrs) out.push(...arr);
+    return out;
+  },
+  /**
+   * Emit `cmd` wrapped in a single-element array iff `cond` is true.
+   * Otherwise return the empty array. Spreads cleanly into the cmds array
+   * returned by a Transitions cell.
+   *
+   * `const C` (TypeScript 5.0+) keeps the inferred `type:` discriminator
+   * literal narrow when called with an object literal — so `Cmd.when(b,
+   * { type: "x", ... })` infers as `{ type: "x", ... }`, not `{ type:
+   * string, ... }`, and stays assignable to a discriminated-union arm
+   * without `as const` at the call site.
+   */
+  when: (cond, cmd) => cond ? [cmd] : [],
+  /**
+   * If `value` is defined, call `build(value)` and emit the resulting cmd
+   * wrapped in a single-element array. If `value` is `undefined`, return
+   * the empty array. `value` is narrowed to `T` inside `build`.
+   *
+   * `const C` on the return type keeps the callback's object-literal
+   * `type:` field narrow (see `when` above for the full rationale).
+   */
+  whenDefined: (value2, build) => value2 !== void 0 ? [build(value2)] : []
+};
+function subId(s) {
+  return s;
+}
+function depsInactive(deps) {
+  return deps === null || deps === void 0;
+}
+function structuralHash(deps) {
+  return stableStringify(deps);
+}
+function stableStringify(value2) {
+  if (value2 === null) return "null";
+  const t = typeof value2;
+  if (t === "string") return JSON.stringify(value2);
+  if (t === "number" || t === "boolean") return String(value2);
+  if (t === "undefined") return "undefined";
+  if (t === "function") {
+    throw new Error(
+      "@demlik/tea: structuralHash received a function in `deps`. A dep-keyed Sub's `deps` must be a plain state slice (string / number / boolean / null / array / object), not a closure \u2014 see invariant 1."
+    );
+  }
+  if (Array.isArray(value2)) {
+    return `[${value2.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const proto = Object.getPrototypeOf(value2);
+    if (proto !== Object.prototype && proto !== null) {
+      const ctor = value2.constructor;
+      const label = ctor?.name ?? "object";
+      throw new Error(
+        `@demlik/tea: structuralHash received a non-plain object (${label}) in \`deps\`. A \`Date\`, \`Map\`, \`Set\`, \`Error\` or class instance carries no own enumerable properties, so every one of them would hash to the same id as \`{}\` \u2014 a silent collision, not a wrong-looking key. Project it to plain data first (e.g. \`startedAt.toISOString()\`, \`[...set].sort()\`) \u2014 see invariant 1.`
+      );
+    }
+    const obj = value2;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+  }
+  throw new Error(
+    `@demlik/tea: structuralHash received an unsupported \`deps\` value of type "${t}". Use plain JSON-compatible data for a dep-keyed Sub's \`deps\`.`
+  );
+}
+function foldUpdates(machine, initialState, msgs) {
+  let state = initialState;
+  const cmds = [];
+  for (const msg of msgs) {
+    const [next, emitted] = applyCellChecked(machine, state, msg);
+    state = next;
+    cmds.push(...emitted);
+  }
+  return { state, cmds };
+}
+function foldMsgs(machine, base, msgs) {
+  return foldUpdates(machine, base, msgs).state;
+}
+
+// src/internal/prediction/index.ts
+var tagSeq = (seq, value2) => ({ seq, value: value2 });
+var ack = (lastAppliedSeq) => ({ lastAppliedSeq });
+var NO_ACK = -1;
+var initAck = () => ack(NO_ACK);
+var partitionByAck = (buffer, ackOrSeq) => {
+  const lastAppliedSeq = typeof ackOrSeq === "number" ? ackOrSeq : ackOrSeq.lastAppliedSeq;
+  const acked = [];
+  const pending = [];
+  for (const item of buffer) {
+    if (item.seq <= lastAppliedSeq) {
+      acked.push(item);
+    } else {
+      pending.push(item);
+    }
+  }
+  return { acked, pending };
+};
+var nextSeq = (buffer) => buffer.reduce((max, item) => item.seq > max ? item.seq : max, -1) + 1;
+function reconcile(machine, authoritativeState, lastAppliedSeq, pending) {
+  const { pending: unacked } = partitionByAck(pending, lastAppliedSeq);
+  return foldMsgs(
+    machine,
+    authoritativeState,
+    unacked.map((tagged) => tagged.value)
+  );
+}
+function absurd(x) {
+  throw new Error(`unreachable: ${JSON.stringify(x)}`);
+}
+var noop = (state, _msg) => [state, []];
+var definedPortNames = /* @__PURE__ */ new Set();
+var PortNameCollisionError = class extends Error {
+  name = "PortNameCollisionError";
+  _tag = "PortNameCollisionError";
+  constructor(portName) {
+    super(
+      `definePort: a port named "${portName}" was already defined. Each definePort call must use a unique name. If two modules need the same port, export it from one module and import it.`
+    );
+  }
+};
+var SubIdCollisionError = class extends Error {
+  name = "SubIdCollisionError";
+  _tag = "SubIdCollisionError";
+  constructor(id, declaredType, conflictingType) {
+    super(
+      `@demlik/tea: Sub.id collision: id="${id}" declared as type="${declaredType}" and type="${conflictingType}"`
+    );
+  }
+};
+function __resetPortRegistry() {
+  definedPortNames.clear();
+}
+var QuiescenceTimeoutError = class extends Error {
+  constructor(iterations) {
+    super(
+      `@demlik/tea: idle() did not reach quiescence after ${iterations} iterations \u2014 the dispatch tail kept advancing. The machine is likely livelocking (an interpret handler enqueues a follow-up Msg that enqueues another, without end). Bound the follow-up chain in the reducer, or stop the runtime.`
+    );
+    this.iterations = iterations;
+  }
+  iterations;
+  name = "QuiescenceTimeoutError";
+  _tag = "QuiescenceTimeoutError";
+};
+var DriveFailedError = class extends Error {
+  constructor(state) {
+    super(
+      `@demlik/tea: driveToDone ended on a failed State \u2014 the run reached a terminal State the \`failed\` predicate marks as a failure. Read \`error.state\` for the final Model.`
+    );
+    this.state = state;
+  }
+  state;
+  name = "DriveFailedError";
+  _tag = "DriveFailedError";
+};
+var DriveStalledError = class extends Error {
+  constructor(state) {
+    super(
+      `@demlik/tea: driveToDone stalled \u2014 the start chain quiesced on a State that is neither terminal nor failed, with no live Sub and no Cmd in flight to move it further. Read \`error.state\` for the State it parked on; if a later transition was expected, the machine needs a Sub (or a Cmd) that delivers it.`
+    );
+    this.state = state;
+  }
+  state;
+  name = "DriveStalledError";
+  _tag = "DriveStalledError";
+};
+var RuntimeDiscardNotice = class extends Error {
+};
+var RuntimeDiscardedError = class extends RuntimeDiscardNotice {
+  constructor(pendingCmds) {
+    super(
+      `@demlik/tea: runtime stopped with ${pendingCmds} Cmd(s) in flight \u2014 their results will reach no listener. In React this is usually a ctx-identity change rebuilding useMachine's runtime mid-flight: stabilize the ctx (useMemo / useState) so the runtime outlives the Cmds it started. An intentional teardown (unmount, navigation) can silence this with a run({ onError }) sink that ignores phase: "discard".`
+    );
+    this.pendingCmds = pendingCmds;
+  }
+  pendingCmds;
+  name = "RuntimeDiscardedError";
+  _tag = "RuntimeDiscardedError";
+};
+var IdentityDropNotice = class extends RuntimeDiscardNotice {
+  constructor(msgType) {
+    super(
+      `@demlik/tea: Msg "${msgType}" was addressed to a different instance than this state owns and was dropped before \`update\` ran \u2014 the machine's \`identity\` filter working as declared. If this Msg was meant for THIS instance, its \`ofMsg\` projection disagrees with \`ofState\`; if the instance is being reused across runs, route the message to the run that owns it.`
+    );
+    this.msgType = msgType;
+  }
+  msgType;
+  name = "IdentityDropNotice";
+  _tag = "IdentityDropNotice";
+};
+var DisposeTimeoutNotice = class extends RuntimeDiscardNotice {
+  constructor(pendingDisposals, timeoutMs) {
+    super(
+      `@demlik/tea: stop() gave up waiting for ${pendingDisposals} async teardown(s) after ${timeoutMs}ms \u2014 the resources they release may still be open. Make \`release\` / the Sub cleanup settle (bound its own IO), or raise run({ disposeTimeoutMs }).`
+    );
+    this.pendingDisposals = pendingDisposals;
+    this.timeoutMs = timeoutMs;
+  }
+  pendingDisposals;
+  timeoutMs;
+  name = "DisposeTimeoutNotice";
+  _tag = "DisposeTimeoutNotice";
+};
+var DispatchDiscardedError = class extends RuntimeDiscardNotice {
+  constructor(msgType) {
+    super(
+      `@demlik/tea: Msg "${msgType}" arrived while the runtime was stopping and was discarded \u2014 stop() refuses new work so the drain terminates. It is the result of a Cmd that outlived its runtime; keep the runtime alive until the Cmd settles (in React: stabilize useMachine's ctx) if the transition matters.`
+    );
+    this.msgType = msgType;
+  }
+  msgType;
+  name = "DispatchDiscardedError";
+  _tag = "DispatchDiscardedError";
+};
+function definePort(name) {
+  let isHmr = false;
+  try {
+    const meta = import.meta;
+    isHmr = meta?.hot !== void 0 && meta?.hot !== null;
+  } catch {
+    isHmr = false;
+  }
+  if (!isHmr && definedPortNames.has(name)) {
+    throw new PortNameCollisionError(name);
+  }
+  definedPortNames.add(name);
+  return { __brand: "port", name };
+}
+function isFencedStore(store) {
+  return "fenced" in store && store.fenced === true;
+}
+var StoreConflictError = class extends Error {
+  constructor(expectedVersion, actualVersion) {
+    super(
+      `@demlik/tea: store conflict \u2014 expected version ${expectedVersion}, found ${actualVersion}. Another process has written this state; this run is no longer the single writer and has stopped.`
+    );
+    this.expectedVersion = expectedVersion;
+    this.actualVersion = actualVersion;
+  }
+  expectedVersion;
+  actualVersion;
+  name = "StoreConflictError";
+  _tag = "store_conflict";
+};
+function schemaMigrate(schema, upcast = (raw) => raw) {
+  return (raw) => {
+    let migrated;
+    try {
+      migrated = upcast(raw);
+    } catch {
+      return null;
+    }
+    const parsed = schema.safeParse(migrated);
+    return parsed.success ? parsed.data : null;
+  };
+}
+function defineMachine(m) {
+  if (m.__form === void 0) {
+    Object.defineProperty(m, "__form", {
+      value: detectUpdateForm(m.update),
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  }
+  return m;
+}
+function asReducer(reducer) {
+  return reducer;
+}
+function replay(machine, opts) {
+  const loaded = opts.loaded ?? null;
+  const [initialState, initCmds] = machine.init(loaded, opts.ctx);
+  if (loaded !== null && initCmds.length > 0) {
+    throw new Error(
+      "TEA contract violation: machine.init must return [state, []] (no Cmds) when `loaded` is non-null. Init's rehydrate branch is a pure state passthrough \u2014 the migration/parse boundary, not the boot-effect hook.\n\nRoutes for boot effects:\n  - Stateless infrastructure (e.g. chrome.alarms ensure) \u2192 host module top level, outside TEA.\n  - State-conditional resume (e.g. re-attach a session) \u2192 a `boot` Msg dispatched once from the host after `run(...)` returns, handled in update.\n\nSee .patterns/tea/tea-invariants.md (Invariant 2)."
+    );
+  }
+  const { state, cmds: foldedCmds } = foldUpdates(
+    machine,
+    initialState,
+    opts.msgs
+  );
+  const cmds = [...initCmds, ...foldedCmds];
+  const subs = machine.subscriptions ? [...machine.subscriptions(state)] : [];
+  const depSubs = [];
+  if (machine.subs) {
+    for (const [index, entry] of machine.subs.entries()) {
+      const deps = entry.deps(state);
+      if (!depsInactive(deps))
+        depSubs.push({ index, id: structuralHash(deps) });
+    }
+  }
+  return { state, cmds, subs, depSubs };
+}
+function wrapDetached(handler) {
+  return (cmd, ctx, dispatch) => {
+    if (dispatch === void 0) {
+      throw new Error(
+        "@demlik/tea: a wrapDetached handler was invoked without the injected dispatch. The kernel always supplies it; call the handler through the runtime, not directly."
+      );
+    }
+    return handler(cmd, ctx, dispatch);
+  };
+}
+function tryApplyCell(machine, state, msg) {
+  const found = lookupCell(machine, state, msg);
+  if (found.cell === void 0) {
+    return Result.err(
+      new NoCellError(msg.type, found.stateName, found.acceptedTypes)
+    );
+  }
+  return Result.ok(found.cell(state, msg));
+}
+function tryFoldMsgs(machine, base, msgs) {
+  let state = base;
+  for (const [index, msg] of msgs.entries()) {
+    if (__DEV__) deepFreeze(state);
+    const stepped = tryApplyCell(machine, state, msg);
+    if (Result.isError(stepped)) {
+      return Result.err({ index, msg, error: stepped.error });
+    }
+    if (__DEV__) assertPureResult(stepped.value, msg.type);
+    state = stepped.value[0];
+  }
+  return Result.ok(state);
+}
+function settle(def, work) {
+  const builders = def;
+  return async (cmd, ctx) => {
+    const result = await work(cmd, ctx);
+    return result.match({
+      ok: (value2) => builders.ok(cmd, value2),
+      err: (error) => builders.err(cmd, error)
+    });
+  };
+}
+function tryInterpret(work, onOk, onErr) {
+  return async (cmd, ctx) => {
+    const result = await Result.tryPromise({
+      try: () => work(cmd, ctx),
+      catch: (error) => error
+    });
+    return result.match({
+      ok: (value2) => onOk(value2, cmd),
+      err: (error) => onErr(error, cmd)
+    });
+  };
+}
+
+// src/run.ts
+function defaultOnError(error, _context) {
+  if (error instanceof RuntimeDiscardNotice) {
+    console.warn(error);
+    return;
+  }
+  setTimeout(() => {
+    throw error;
+  }, 0);
+}
+function normalizeSupervision(supervision) {
+  if (supervision === void 0) return { strategy: "stop" };
+  if (typeof supervision === "string") return { strategy: supervision };
+  return supervision;
+}
+var liveWork = /* @__PURE__ */ Symbol("demlik-tea.liveWork");
+function run(machine, opts) {
+  const { store } = opts;
+  const fenced = store !== void 0 && isFencedStore(store) ? store : null;
+  let fencedVersion = 0;
+  async function readFenced(from) {
+    const read = await from.loadFenced();
+    fencedVersion = read.version;
+    return read.raw;
+  }
+  async function persist(next) {
+    if (fenced) {
+      fencedVersion = await fenced.saveFenced(next, fencedVersion);
+      return;
+    }
+    if (store) await store.save(next);
+  }
+  const provided = isProvided(
+    opts.ctx
+  ) ? opts.ctx : null;
+  let ctx = provided ? {} : opts.ctx ?? {};
+  let releaseProvided = null;
+  const clock = opts.clock ?? Date.now;
+  const idleCap = opts.__idleCap ?? 1e5;
+  const disposeTimeoutMs = opts.disposeTimeoutMs ?? 5e3;
+  const projectEvents = opts.events ?? (() => []);
+  const isTerminal = opts.terminal ?? (() => false);
+  const onError = opts.onError ?? defaultOnError;
+  const reportError = (error, context) => {
+    try {
+      onError(error, context);
+    } catch (sinkError) {
+      defaultOnError(sinkError);
+    }
+  };
+  function fanout(items, phase, fn) {
+    for (const item of items) {
+      try {
+        fn(item);
+      } catch (err) {
+        reportError(err, { phase });
+      }
+    }
+  }
+  const supervision = normalizeSupervision(opts.supervision);
+  let state;
+  let bootError = null;
+  let gate = "open";
+  let inFlightCmds = 0;
+  const subRegistry = /* @__PURE__ */ new Map();
+  const depSubRegistry = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const observers = /* @__PURE__ */ new Set();
+  const bootHandlers = /* @__PURE__ */ new Set();
+  let booted = false;
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const doneWaiters = /* @__PURE__ */ new Set();
+  const portRegistry = /* @__PURE__ */ new Map();
+  function portEmit(port, value2) {
+    const subscribers = portRegistry.get(port);
+    if (!subscribers || subscribers.size === 0) return;
+    fanout(subscribers, "port-emit", (listener) => listener(value2));
+  }
+  const settleAtEdge = cmdEdgeOver(machine.cmds ?? [], clock);
+  let augmentedCtx = buildAugmentedCtx();
+  function buildAugmentedCtx() {
+    return Object.assign({}, ctx, {
+      emit: portEmit,
+      [cmdEdge]: settleAtEdge,
+      [detachWork]: detachInFlight
+    });
+  }
+  let tail = Promise.resolve();
+  function stopSubs(ids) {
+    for (const id of ids) {
+      const cleanup = subRegistry.get(id);
+      if (cleanup === void 0) continue;
+      try {
+        trackDisposal(cleanup());
+      } catch (err) {
+        reportError(err, { phase: "sub-cleanup" });
+      }
+      subRegistry.delete(id);
+    }
+  }
+  const pendingDisposals = /* @__PURE__ */ new Set();
+  function trackDisposal(result) {
+    if (!(result instanceof Promise)) return;
+    const settling = result.catch((err) => {
+      reportError(err, { phase: "sub-cleanup" });
+    }).finally(() => {
+      pendingDisposals.delete(settling);
+    });
+    pendingDisposals.add(settling);
+  }
+  async function drainDisposals() {
+    if (pendingDisposals.size === 0) return;
+    const outstanding = [...pendingDisposals];
+    let timer;
+    try {
+      const outcome = await Promise.race([
+        Promise.all(outstanding).then(() => "settled"),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve("timeout"), disposeTimeoutMs);
+        })
+      ]);
+      if (outcome === "timeout") {
+        reportError(
+          new DisposeTimeoutNotice(outstanding.length, disposeTimeoutMs),
+          { phase: "discard" }
+        );
+      }
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  function disposeDepSubs(indices) {
+    for (const index of indices) {
+      const running = depSubRegistry.get(index);
+      if (running === void 0) continue;
+      try {
+        trackDisposal(running.dispose());
+      } catch (err) {
+        reportError(err, { phase: "sub-cleanup" });
+      }
+      depSubRegistry.delete(index);
+    }
+  }
+  function reconcileDepSubs() {
+    let firstError = null;
+    const subs = machine.subs;
+    if (!subs) return firstError;
+    for (const [i, entry] of subs.entries()) {
+      let deps;
+      let id;
+      try {
+        deps = entry.deps(state);
+        if (depsInactive(deps)) {
+          disposeDepSubs([i]);
+          continue;
+        }
+        id = structuralHash(deps);
+      } catch (err) {
+        if (firstError === null) firstError = err;
+        continue;
+      }
+      const running = depSubRegistry.get(i);
+      if (running !== void 0 && running.runningId === id) {
+        continue;
+      }
+      disposeDepSubs([i]);
+      try {
+        const dispose = entry.source(state, dispatchUnawaited, ctx);
+        depSubRegistry.set(i, { runningId: id, dispose });
+      } catch (err) {
+        if (firstError === null) firstError = err;
+      }
+    }
+    return firstError;
+  }
+  function reconcileSubs() {
+    const depError = reconcileDepSubs();
+    if (!machine.subscriptions) {
+      if (depError !== null) throw depError;
+      return;
+    }
+    const desired = machine.subscriptions(state);
+    const desiredIds = /* @__PURE__ */ new Set();
+    const desiredTypeById = /* @__PURE__ */ new Map();
+    for (const sub of desired) {
+      const existing = desiredTypeById.get(sub.id);
+      if (existing !== void 0 && existing !== sub.type) {
+        throw new SubIdCollisionError(sub.id, existing, sub.type);
+      }
+      desiredTypeById.set(sub.id, sub.type);
+    }
+    for (const sub of desired) desiredIds.add(sub.id);
+    stopSubs([...subRegistry.keys()].filter((id) => !desiredIds.has(id)));
+    let firstStartError = depError;
+    for (const sub of desired) {
+      if (subRegistry.has(sub.id)) continue;
+      const handler = machine.subscribe?.[sub.type];
+      if (!handler) {
+        continue;
+      }
+      try {
+        const cleanup = handler(
+          sub,
+          ctx,
+          dispatchUnawaited
+        );
+        subRegistry.set(sub.id, cleanup);
+      } catch (err) {
+        if (firstStartError === null) firstStartError = err;
+      }
+    }
+    if (firstStartError !== null) throw firstStartError;
+  }
+  const interpretMap = machine.interpret ?? {};
+  const dispatchUnawaited = (msg) => {
+    enqueueDispatch(msg).catch(reportUndelivered);
+  };
+  function reportUndelivered(error) {
+    reportError(error, {
+      phase: error instanceof DispatchDiscardedError ? "discard" : "follow-up"
+    });
+  }
+  function trackInFlight(work) {
+    inFlightCmds++;
+    return Promise.resolve(work).finally(() => {
+      inFlightCmds--;
+    });
+  }
+  function detachInFlight(work) {
+    const tracked = trackInFlight(work);
+    tracked.catch(reportUndelivered);
+    tail = tail.then(async () => {
+      await tracked;
+    }).catch(() => {
+    });
+  }
+  async function runInterpret(cmds) {
+    for (const cmd of cmds) {
+      const handler = interpretMap[cmd.type];
+      if (!handler) continue;
+      const returned = await trackInFlight(
+        handler(
+          cmd,
+          // The handler's cell demands `Ctx & RequirementsOf<its Cmd>`; the runtime
+          // holds `Ctx & RequiredCtx<C>` — the intersection over EVERY Cmd, so
+          // a superset of any one cell's slice. The widening is sound by
+          // construction; `tsc` cannot see through the generic `C` to prove it.
+          augmentedCtx,
+          dispatchUnawaited
+        )
+      );
+      const follow = settleAtEdge(cmd, returned);
+      if (follow !== void 0 && follow !== null) {
+        enqueueDispatch(follow).catch(reportUndelivered);
+      }
+    }
+  }
+  function fireListeners() {
+    fanout(listeners, "listener", (listener) => listener());
+  }
+  function fireObservers(msg) {
+    if (observers.size === 0 || state === void 0) return;
+    const snapshot = state;
+    fanout(observers, "observer", (observer) => observer(msg, snapshot));
+  }
+  function fireEvents(msg) {
+    if (eventHandlers.size === 0 || state === void 0) return;
+    let events;
+    try {
+      events = projectEvents(msg, state);
+    } catch (err) {
+      reportError(err, { phase: "event" });
+      return;
+    }
+    for (const event of events) {
+      const bucket = eventHandlers.get(event.type);
+      if (bucket === void 0) continue;
+      fanout(bucket, "event", (handler) => handler(event));
+    }
+  }
+  function fireBoot() {
+    booted = true;
+    if (bootHandlers.size === 0 || state === void 0) return;
+    const snapshot = state;
+    fanout(bootHandlers, "boot", (handler) => handler(snapshot));
+  }
+  function settleDoneWaiters() {
+    if (doneWaiters.size === 0 || state === void 0) return;
+    if (!isTerminal(state)) return;
+    const snapshot = state;
+    const parked = [...doneWaiters];
+    doneWaiters.clear();
+    for (const resolve of parked) resolve(snapshot);
+  }
+  async function commit(next, msg, cmds) {
+    state = next;
+    await persist(next);
+    reconcileSubs();
+    await runInterpret(cmds);
+    fireListeners();
+    fireObservers(msg);
+    fireEvents(msg);
+    settleDoneWaiters();
+  }
+  function isMisaddressed(msg, current) {
+    if (machine.identity === void 0) return false;
+    const addressed = machine.identity.ofMsg(msg);
+    if (addressed === void 0) return false;
+    const own = machine.identity.ofState(current);
+    if (own === void 0) return false;
+    return structuralHash(addressed) !== structuralHash(own);
+  }
+  async function stepDispatch(msg) {
+    if (state === void 0) {
+      throw new Error("@demlik/tea: runtime not booted");
+    }
+    let next;
+    let cmds;
+    try {
+      if (isMisaddressed(msg, state)) {
+        reportError(new IdentityDropNotice(msg.type), {
+          phase: "identity-drop"
+        });
+        return;
+      }
+      [next, cmds] = applyCellChecked(machine, state, msg);
+    } catch (reduceError) {
+      reportError(reduceError, { phase: "reduce" });
+      switch (supervision.strategy) {
+        case "restart": {
+          await commit(supervision.rehydrate(state, msg, reduceError), msg, []);
+          return;
+        }
+        case "escalate":
+          throw reduceError;
+        default:
+          gate = "closed";
+          throw reduceError;
+      }
+    }
+    await commit(next, msg, cmds);
+  }
+  let pendingInitCmds = [];
+  if (!store && !provided) {
+    const [initialState, initCmds] = machine.init(null, ctx);
+    state = initialState;
+    pendingInitCmds = initCmds;
+  }
+  async function stepBootEffects() {
+    if (provided) {
+      let scope;
+      try {
+        scope = await provided.open((error, provider) => {
+          reportError(error, { phase: "provide", provider });
+        });
+      } catch (error) {
+        reportError(error, { phase: "provide" });
+        throw error;
+      }
+      ctx = scope.ctx;
+      releaseProvided = scope.release;
+      augmentedCtx = buildAugmentedCtx();
+      if (!store) {
+        const [initialState, initCmds] = machine.init(null, ctx);
+        state = initialState;
+        pendingInitCmds = initCmds;
+      }
+    }
+    try {
+      await bootAfterProvide();
+    } catch (error) {
+      if (releaseProvided) await releaseProvided();
+      throw error;
+    }
+  }
+  async function bootAfterProvide() {
+    if (store) {
+      const raw = fenced ? await readFenced(fenced) : await store.load();
+      const parsed = store.migrate(raw);
+      const [initialState, initCmds] = machine.init(parsed, ctx);
+      state = initialState;
+      pendingInitCmds = initCmds;
+      await persist(state);
+    }
+    reconcileSubs();
+    await runInterpret(pendingInitCmds);
+    fireListeners();
+    fireBoot();
+    settleDoneWaiters();
+  }
+  function enqueueDispatch(msg) {
+    if (gate !== "open") {
+      return Promise.reject(
+        gate === "draining" ? new DispatchDiscardedError(msg.type) : new Error("@demlik/tea: runtime stopped")
+      );
+    }
+    const next = tail.then(() => {
+      if (bootError !== null) throw bootError;
+      return stepDispatch(msg);
+    });
+    tail = next.catch(() => {
+    });
+    return next;
+  }
+  async function drainToQuiescence() {
+    for (let i = 0; i < idleCap; i++) {
+      const observed = tail;
+      await observed;
+      if (tail === observed) return;
+    }
+    throw new QuiescenceTimeoutError(idleCap);
+  }
+  async function dispatchToQuiescence(msg, opts2) {
+    await enqueueDispatch(msg);
+    if (opts2?.settle === "once") return;
+    await drainToQuiescence();
+  }
+  const bootPromise = stepBootEffects();
+  tail = bootPromise.catch((err) => {
+    bootError = err;
+  });
+  const readyPromise = bootPromise.then(
+    () => runtime
+  );
+  const runtime = {
+    [liveWork]: () => ({
+      subs: subRegistry.size + depSubRegistry.size,
+      cmds: inFlightCmds
+    }),
+    dispatch: dispatchToQuiescence,
+    dispatchOnce: enqueueDispatch,
+    getState() {
+      return state;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    observe(observer) {
+      observers.add(observer);
+      return () => {
+        observers.delete(observer);
+      };
+    },
+    onBoot(handler) {
+      if (booted && state !== void 0) {
+        const snapshot = state;
+        fanout([handler], "boot", (h) => h(snapshot));
+        return () => {
+        };
+      }
+      bootHandlers.add(handler);
+      return () => {
+        bootHandlers.delete(handler);
+      };
+    },
+    on(type, handler) {
+      let bucket = eventHandlers.get(type);
+      if (bucket === void 0) {
+        bucket = /* @__PURE__ */ new Set();
+        eventHandlers.set(type, bucket);
+      }
+      const erased = handler;
+      bucket.add(erased);
+      return () => {
+        const set = eventHandlers.get(type);
+        if (set === void 0) return;
+        set.delete(erased);
+        if (set.size === 0) eventHandlers.delete(type);
+      };
+    },
+    subscribePort(port, listener) {
+      const key = port;
+      let bucket = portRegistry.get(key);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        portRegistry.set(key, bucket);
+      }
+      const erased = listener;
+      bucket.add(erased);
+      return () => {
+        const set = portRegistry.get(key);
+        if (!set) return;
+        set.delete(erased);
+        if (set.size === 0) portRegistry.delete(key);
+      };
+    },
+    emitPort(port, value2) {
+      portEmit(port, value2);
+    },
+    ready: readyPromise,
+    idle() {
+      return drainToQuiescence();
+    },
+    result() {
+      const current = state;
+      return isTerminal(current) ? current : void 0;
+    },
+    done() {
+      const current = state;
+      if (isTerminal(current)) return Promise.resolve(current);
+      return new Promise((resolve) => {
+        doneWaiters.add(resolve);
+      });
+    },
+    async stop() {
+      if (gate === "open") gate = "draining";
+      if (inFlightCmds > 0) {
+        reportError(new RuntimeDiscardedError(inFlightCmds), {
+          phase: "discard"
+        });
+      }
+      await tail;
+      gate = "closed";
+      stopSubs([...subRegistry.keys()]);
+      disposeDepSubs([...depSubRegistry.keys()]);
+      await drainDisposals();
+      if (store && state !== void 0 && bootError === null) {
+        try {
+          await persist(state);
+        } catch (error) {
+          reportError(error, { phase: "stop-save" });
+        }
+      }
+      if (releaseProvided) await releaseProvided();
+    }
+  };
+  return runtime;
+}
+function isStalled(runtime) {
+  const probe = runtime[liveWork];
+  if (probe === void 0) return false;
+  const live = probe();
+  return live.subs === 0 && live.cmds === 0;
+}
+async function driveToDone(handle, start, isTerminal, opts = {}) {
+  const failed = opts.failed ?? (() => false);
+  const settles = (state) => isTerminal(state) || failed(state);
+  let detach;
+  let unlisten;
+  try {
+    const runtime = await handle.ready;
+    const booted = runtime.getState();
+    const outcome = (state) => {
+      if (failed(state)) throw new DriveFailedError(state);
+      return state;
+    };
+    if (settles(booted)) return outcome(booted);
+    const terminal = new Promise((resolve) => {
+      detach = runtime.observe((_msg, state) => {
+        if (settles(state)) resolve(state);
+      });
+    });
+    let cancelFailed;
+    if (opts.signal !== void 0) {
+      const { signal, cancel } = opts;
+      let onCancelError;
+      cancelFailed = new Promise((_resolve, reject) => {
+        onCancelError = reject;
+      });
+      const onAbort = () => {
+        try {
+          runtime.dispatchOnce(cancel(runtime.getState())).catch(onCancelError);
+        } catch (error) {
+          onCancelError(error);
+        }
+      };
+      if (signal.aborted) {
+        onAbort();
+        return outcome(await Promise.race([terminal, cancelFailed]));
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+      unlisten = () => signal.removeEventListener("abort", onAbort);
+    }
+    const msg = typeof start === "function" ? start(booted) : start;
+    const started = runtime.dispatch(msg).then(() => {
+      const parked = runtime.getState();
+      if (!settles(parked) && isStalled(runtime)) {
+        throw new DriveStalledError(parked);
+      }
+      return terminal;
+    });
+    const racers = [terminal, started];
+    if (cancelFailed !== void 0) racers.push(cancelFailed);
+    return outcome(await Promise.race(racers));
+  } finally {
+    detach?.();
+    unlisten?.();
+    await handle.stop();
+  }
+}
+
+// src/subs/types.ts
+function dispatchIfPresent(dispatch, msg) {
+  if (msg !== null) dispatch(msg);
+}
+
+// src/subs/define-listener.ts
+function defineListener(target) {
+  return (msgFn) => {
+    return (sub, ctx, dispatch) => {
+      const listener = (...args) => {
+        dispatchIfPresent(dispatch, msgFn(sub, ...args));
+      };
+      target.add(listener, sub, ctx);
+      return () => {
+        target.remove(listener, sub, ctx);
+      };
+    };
+  };
+}
+
+// src/subs/from-broadcast-channel.ts
+function fromBroadcastChannel(msgFn) {
+  return (sub, _ctx, dispatch) => {
+    const channel = new BroadcastChannel(sub.channelName);
+    const listener = (event) => {
+      dispatchIfPresent(dispatch, msgFn(event, sub));
+    };
+    channel.addEventListener("message", listener);
+    return () => {
+      channel.removeEventListener("message", listener);
+      channel.close();
+    };
+  };
+}
+
+// src/subs/from-event-source.ts
+function fromEventSource(opts) {
+  return (sub, _ctx, dispatch) => {
+    const source = new EventSource(sub.url);
+    const messageListener = (event) => {
+      dispatchIfPresent(dispatch, opts.onMessage(event.data, sub));
+    };
+    source.addEventListener("message", messageListener);
+    const onError = opts.onError;
+    const errorListener = onError ? (event) => {
+      dispatchIfPresent(dispatch, onError(event, sub));
+    } : void 0;
+    if (errorListener) source.addEventListener("error", errorListener);
+    const onOpen = opts.onOpen;
+    const openListener = onOpen ? () => {
+      dispatchIfPresent(dispatch, onOpen(sub));
+    } : void 0;
+    if (openListener) source.addEventListener("open", openListener);
+    return () => {
+      source.removeEventListener("message", messageListener);
+      if (errorListener) source.removeEventListener("error", errorListener);
+      if (openListener) source.removeEventListener("open", openListener);
+      source.close();
+    };
+  };
+}
+
+// src/subs/from-event-target.ts
+function fromEventTarget(getTarget, eventName, msgFn) {
+  return (sub, _ctx, dispatch) => {
+    const target = getTarget();
+    const listener = (event) => {
+      dispatchIfPresent(dispatch, msgFn(event, sub));
+    };
+    target.addEventListener(eventName, listener);
+    return () => {
+      target.removeEventListener(eventName, listener);
+    };
+  };
+}
+
+// src/subs/from-interval.ts
+function fromInterval(msgFn) {
+  return (sub, _ctx, dispatch) => {
+    const handle = setInterval(() => {
+      dispatch(msgFn(sub));
+    }, sub.intervalMs);
+    return () => {
+      clearInterval(handle);
+    };
+  };
+}
+
+// src/subs/from-port.ts
+function fromPort(selectRuntime, port, msgFn) {
+  return (sub, ctx, dispatch) => {
+    const runtime = selectRuntime(ctx);
+    return runtime.subscribePort(port, (value2) => {
+      dispatchIfPresent(dispatch, msgFn(value2, sub));
+    });
+  };
+}
+
+// src/subs/from-reconnecting-web-socket.ts
+var defaultConnect = (url) => new WebSocket(url);
+var defaultSchedule = (fn, ms) => {
+  const handle = setTimeout(fn, ms);
+  return () => clearTimeout(handle);
+};
+function fromReconnectingWebSocket(opts) {
+  const backoffBaseMs = opts.backoffBaseMs ?? 250;
+  const backoffMaxMs = opts.backoffMaxMs ?? 5e3;
+  const connect = opts.connect ?? defaultConnect;
+  const schedule = opts.schedule ?? defaultSchedule;
+  const { onMessage, onOpen, onError, onClose, onReconnect } = opts;
+  return (sub, _ctx, dispatch) => {
+    let ws = null;
+    let attempt = 0;
+    let opened = false;
+    let closedByCaller = false;
+    let cancelReconnect = null;
+    const emit = (msg) => dispatchIfPresent(dispatch, msg);
+    const handleClose = (code, reason) => {
+      ws = null;
+      if (onClose) emit(onClose(code, reason, sub));
+      if (closedByCaller) return;
+      const delay = Math.min(backoffBaseMs * 2 ** attempt, backoffMaxMs);
+      attempt += 1;
+      cancelReconnect = schedule(() => {
+        cancelReconnect = null;
+        if (!closedByCaller) open();
+      }, delay);
+    };
+    function open() {
+      const socket = connect(sub.wsUrl);
+      ws = socket;
+      socket.onopen = () => {
+        const reconnected = opened;
+        const reconnectCount = attempt;
+        attempt = 0;
+        opened = true;
+        if (onOpen) emit(onOpen(sub));
+        if (reconnected && onReconnect) emit(onReconnect(reconnectCount, sub));
+      };
+      socket.onmessage = (event) => {
+        emit(onMessage(event.data, sub));
+      };
+      socket.onerror = onError ? (event) => emit(onError(event, sub)) : () => {
+      };
+      socket.onclose = (event) => {
+        handleClose(event.code, event.reason);
+      };
+    }
+    open();
+    return () => {
+      closedByCaller = true;
+      if (cancelReconnect !== null) {
+        cancelReconnect();
+        cancelReconnect = null;
+      }
+      const socket = ws;
+      ws = null;
+      if (socket !== null) {
+        socket.onopen = null;
+        socket.onmessage = null;
+        socket.onerror = null;
+        socket.onclose = null;
+        socket.close(1e3);
+      }
+    };
+  };
+}
+
+// src/subs/from-timeout.ts
+function fromTimeout(msgFn) {
+  return (sub, _ctx, dispatch) => {
+    const handle = setTimeout(() => {
+      dispatch(msgFn(sub));
+    }, sub.delayMs);
+    return () => {
+      clearTimeout(handle);
+    };
+  };
+}
+
+// src/subs/from-web-socket.ts
+function fromWebSocket(opts) {
+  return (sub, _ctx, dispatch) => {
+    const ws = new WebSocket(sub.wsUrl);
+    ws.onmessage = (event) => {
+      dispatchIfPresent(dispatch, opts.onMessage(event.data, sub));
+    };
+    const onOpen = opts.onOpen;
+    if (onOpen) {
+      ws.onopen = () => {
+        dispatchIfPresent(dispatch, onOpen(sub));
+      };
+    }
+    const onError = opts.onError;
+    if (onError) {
+      ws.onerror = (event) => {
+        dispatchIfPresent(dispatch, onError(event, sub));
+      };
+    }
+    const onClose = opts.onClose;
+    if (onClose) {
+      ws.onclose = (event) => {
+        dispatchIfPresent(dispatch, onClose(event.code, event.reason, sub));
+      };
+    }
+    return () => {
+      ws.onmessage = null;
+      ws.onopen = null;
+      ws.onerror = null;
+      ws.onclose = null;
+      ws.close(1e3);
+    };
+  };
+}
+
+// src/subs/managed-resource.ts
+function defineManagedResource(opts) {
+  const held = /* @__PURE__ */ new Map();
+  const keyString = (k) => structuralHash(k);
+  const subIdFor = (key) => subId(`managed:${opts.name}:${keyString(key)}`);
+  const subBuilder = (key) => ({
+    id: subIdFor(key),
+    type: "managed_resource",
+    key
+  });
+  const subscribeHandler = (sub, ctx, _dispatch) => {
+    const handle = opts.acquire(sub.key, ctx);
+    const k = keyString(sub.key);
+    held.set(k, handle);
+    return () => {
+      held.delete(k);
+      return opts.release(handle);
+    };
+  };
+  return {
+    sub: subBuilder,
+    // Pair the battery with a state-gate. `TKey` / `Handle` / `Ctx` are in
+    // scope here, so `subFor` builds the fully-typed sub and `subscribe`
+    // forwards straight to the battery's own typed `subscribe`. The entry
+    // erases ONLY `Handle` for the combinator (`TKey` and `Ctx` stay), so the
+    // substrate's narrowed `ManagedResourceSub<TKey>` flows in with no cast.
+    gated: (when) => ({
+      name: opts.name,
+      owns: (sub) => sub.id === subIdFor(sub.key),
+      subFor: (state) => {
+        const key = when(state);
+        return key === null ? null : subBuilder(key);
+      },
+      subscribe: subscribeHandler
+    }),
+    // Dep-keyed entry. `when` is the gate (the deps = the KEY); the source runs
+    // the SAME `acquire` → hold → `release`-on-dispose lifecycle the `subscribe`
+    // cell does, now driven by the kernel's dep-keyed reconcile. The Msg type is
+    // `never` (a managed resource dispatches nothing); the ignored `_dispatch`
+    // matches the source signature.
+    depKeyed: (when) => ({
+      deps: when,
+      source: (state, _dispatch, ctx) => {
+        const key = when(state);
+        if (key === null) return () => {
+        };
+        return subscribeHandler(subBuilder(key), ctx);
+      }
+    }),
+    subscribe: subscribeHandler,
+    get: (key) => held.get(keyString(key)),
+    subIdFor
+  };
+}
+function combineManagedResources(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.name)) {
+      throw new Error(
+        `[combineManagedResources] duplicate managed-resource name "${entry.name}" \u2014 names must be unique (the Sub id encodes the name; two batteries sharing it collide)`
+      );
+    }
+    seen.add(entry.name);
+  }
+  return {
+    subs: (state) => {
+      const live = [];
+      for (const entry of entries) {
+        const sub = entry.subFor(state);
+        if (sub !== null) live.push(sub);
+      }
+      return live;
+    },
+    subscribe: (sub, ctx, dispatch) => {
+      const owner = entries.find((entry) => entry.owns(sub));
+      if (owner === void 0) {
+        throw new Error(
+          `[combineManagedResources] no battery for sub id ${sub.id}`
+        );
+      }
+      return owner.subscribe(sub, ctx, dispatch);
+    }
+  };
+}
+
+// src/subs/transport.ts
+function fromTransport(opts) {
+  const live = /* @__PURE__ */ new Map();
+  const keyString = (k) => structuralHash(k);
+  const subIdFor = (key) => subId(`${opts.name}:${keyString(key)}`);
+  const sub = (key) => ({
+    id: subIdFor(key),
+    type: "transport",
+    key
+  });
+  const subscribe = (s, ctx, dispatch) => {
+    const t = opts.openTransport(s.key, ctx);
+    const k = keyString(s.key);
+    let offMessage;
+    let offClose;
+    try {
+      offMessage = t.onMessage((raw) => {
+        const parsed = opts.parseInbound(raw, s.key);
+        if (parsed === null) return;
+        const msg = opts.onInbound(parsed, s.key);
+        if (msg === null) return;
+        dispatch(msg);
+      });
+      offClose = t.onClose(() => {
+        dispatch(opts.lostMsg(s.key));
+      });
+    } catch (err) {
+      offMessage?.();
+      offClose?.();
+      try {
+        t.close();
+      } catch (closeErr) {
+        console.warn(
+          `[fromTransport:${opts.name}] close during failed wiring failed`,
+          closeErr
+        );
+      }
+      throw err;
+    }
+    live.set(k, t);
+    return () => {
+      offMessage?.();
+      offClose?.();
+      live.delete(k);
+      try {
+        t.close();
+      } catch (err) {
+        console.warn(`[fromTransport:${opts.name}] close failed`, err);
+      }
+    };
+  };
+  return {
+    sub,
+    subscribe,
+    send: (key, outbound) => {
+      const t = live.get(keyString(key));
+      if (t === void 0) {
+        console.warn(
+          `[fromTransport:${opts.name}] send dropped \u2014 no live transport for key`,
+          keyString(key)
+        );
+        return;
+      }
+      t.send(opts.serializeOutbound(outbound));
+    },
+    subIdFor,
+    // Dep-keyed entry: `when` is the gate (the deps slice → the seam key);
+    // `source` re-runs `when(state)` to recover the typed key and opens the seam
+    // via the battery's own `subscribe`. The kernel only calls `source` when
+    // `deps(state)` was non-null, so `when` is non-null here; the key type never
+    // escapes the entry (cast-free existential).
+    depKeyed: (when) => ({
+      deps: when,
+      source: (state, dispatch, ctx) => {
+        const key = when(state);
+        if (key === null) return () => {
+        };
+        return subscribe(sub(key), ctx, dispatch);
+      }
+    })
+  };
+}
+
+export { Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NO_ACK, NoCellError, PortNameCollisionError, ProvideFailedError, ProviderCycleError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, SubIdCollisionError, UnknownProviderError, __resetPortRegistry, absurd, acceptedTypes, acceptsOf, ack, applyCell, applyCellChecked, asReducer, cmdEdgeOf, combineManagedResources, defineListener, defineMachine, defineManagedResource, definePort, dep, describeMachine, detachWorkOf, detectUpdateForm, dispatchIfPresent, driveToDone, foldMsgs, foldUpdates, formOf, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, isFencedStore, isProvided, layer, malformedResult, msgKeysOf, nextSeq, noop, partitionByAck, provide, reconcile, replay, run, schemaMigrate, settle, structuralHash, subId, tagSeq, tryApplyCell, tryFoldMsgs, tryInterpret, value, without, wrapDetached };
+//# sourceMappingURL=chunk-RQULHGYH.js.map
+//# sourceMappingURL=chunk-RQULHGYH.js.map