@demlik/tea 0.15.0 → 0.16.0

package/dist/chunk-CH5KTOEZ.js

@@ -0,0 +1,710 @@
+// 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, value] of Object.entries(obj)) {
+    if (typeof value === "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;
+}
+var Outcome = {
+  ok: (value) => ({ _tag: "Ok", value }),
+  err: (error) => ({ _tag: "Err", error })
+};
+function isOutcome(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const tag = value._tag;
+  return tag === "Ok" && "value" in value || tag === "Err" && "error" in value;
+}
+function malformedResult(issues) {
+  return {
+    _tag: "malformed_result",
+    issues: issues.map((issue) => ({
+      path: (issue.path ?? []).map(
+        (segment) => String(typeof segment === "object" ? segment.key : segment)
+      ).join("."),
+      message: issue.message
+    }))
+  };
+}
+var AsyncSchemaError = class extends Error {
+  constructor(where) {
+    super(
+      `@demlik/tea: ${where} validated asynchronously. tea checks schemas synchronously, so a schema whose \`~standard.validate\` returns a Promise cannot be used here.`
+    );
+    this.where = where;
+  }
+  where;
+  name = "AsyncSchemaError";
+  _tag = "AsyncSchemaError";
+};
+function validateSync(schema, value, where) {
+  const result = schema["~standard"].validate(value);
+  if (result instanceof Promise) {
+    result.catch(() => {
+    });
+    throw new AsyncSchemaError(where);
+  }
+  return result;
+}
+var UndeclaredFailureError = class extends Error {
+  constructor(cmdType, failure, declared) {
+    super(
+      `@demlik/tea: the "${cmdType}" handler failed with ${describeTag(failure)}, which its Cmd.define does not declare (declared: ${declared.length === 0 ? "none" : declared.map((t) => `"${t}"`).join(", ")}). An undeclared failure goes to the error sink, never to "${cmdType}_err".`
+    );
+    this.cmdType = cmdType;
+    this.failure = failure;
+    this.declared = declared;
+  }
+  cmdType;
+  failure;
+  declared;
+  name = "UndeclaredFailureError";
+  _tag = "UndeclaredFailureError";
+};
+function describeTag(failure) {
+  const tag = typeof failure === "object" && failure !== null ? failure._tag : void 0;
+  return typeof tag === "string" ? `_tag "${tag}"` : "a value with no _tag";
+}
+var OutcomeContractError = class extends Error {
+  constructor(cmdType, detail) {
+    super(
+      `@demlik/tea: the "${cmdType}" handler ${detail}. A Cmd.define'd handler returns an outcome \u2014 \`ok(value)\` or \`err({ _tag })\` \u2014 and the engine mints "${cmdType}_ok" / "${cmdType}_err" from it.`
+    );
+    this.cmdType = cmdType;
+  }
+  cmdType;
+  name = "OutcomeContractError";
+  _tag = "OutcomeContractError";
+};
+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, returned) => {
+    const def = byType.get(cmd.type);
+    if (def === void 0) return returned;
+    if (returned === void 0 || returned === null) return void 0;
+    if (isOutcome(returned)) return mint(def, cmd, returned, clock());
+    throw new OutcomeContractError(def.cmdType, describeReturn(def, returned));
+  };
+}
+function describeReturn(def, returned) {
+  const type = typeof returned === "object" ? returned.type : void 0;
+  if (typeof type !== "string") {
+    return "returned a value that is not an outcome";
+  }
+  if (type === def.okType || type === def.errType) {
+    return `returned its own "${type}" Msg`;
+  }
+  return `returned the "${type}" Msg`;
+}
+function mint(def, cmd, outcome, at) {
+  if (outcome._tag === "Err") {
+    const tag = typeof outcome.error === "object" && outcome.error !== null ? outcome.error._tag : void 0;
+    if (typeof tag !== "string" || !def.errTags.includes(tag)) {
+      throw new UndeclaredFailureError(def.cmdType, outcome.error, def.errTags);
+    }
+    return { type: def.errType, cmd, error: outcome.error, at };
+  }
+  const parsed = validateSync(
+    def.schema.ok,
+    outcome.value,
+    `the "${def.cmdType}" Cmd's ok schema`
+  );
+  if (parsed.issues !== void 0) {
+    return {
+      type: def.errType,
+      cmd,
+      error: malformedResult(parsed.issues),
+      at
+    };
+  }
+  return { type: def.okType, cmd, value: parsed.value, at };
+}
+function cmdEdgeOf(ctx) {
+  const edge = typeof ctx === "object" && ctx !== null ? ctx[cmdEdge] : void 0;
+  return edge ?? ((_, returned) => returned);
+}
+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 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, value, at) => stamp({ type: okType, cmd, value }, 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 checkedStep(state, msg, step) {
+  if (__DEV__) deepFreeze(state);
+  const result = step(state, msg);
+  if (__DEV__ && result !== null) assertPureResult(result, msg.type);
+  return result;
+}
+function applyCellChecked(machine, state, msg) {
+  return checkedStep(
+    state,
+    msg,
+    (s, m) => applyCell(machine, s, m)
+  );
+}
+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, 0021). Returns the builder —
+   * `fetch({ url })` yields `{ type: "fetch", url }` — carrying the minted Msg
+   * builders `fetch.ok(cmd, value)` / `fetch.err(cmd, error)` (for replay
+   * logs and tests) 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"],
+   *   });
+   *
+   * `input` and `ok` take any Standard Schema whose `validate` is synchronous:
+   * zod directly, Effect Schema through `Schema.toStandardSchemaV1(...)`. `err`
+   * is the `_tag` list the handler may fail with; the runtime adds
+   * `malformed_result` for an `Ok` value the `ok` schema rejects.
+   *
+   * The handler returns an outcome and the engine mints the Msg:
+   *
+   *   fetch: async (cmd, { ok, err }) =>
+   *     res.status === 404 ? err({ _tag: "not_found" }) : ok(await res.json()),
+   *
+   * A throw or an undeclared tag goes to the error sink, never to `fetch_err`.
+   * The handler reads its services off the plain `ctx` handed to `run` (ADR
+   * 0020).
+   *
+   * A Cmd must not wait; see `DepKeyedSub` for anything that watches.
+   */
+  define: defineCmd,
+  /**
+   * 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: (value, build) => value !== void 0 ? [build(value)] : []
+};
+function subId(s) {
+  return s;
+}
+function subIdOf(type, deps) {
+  return subId(structuralHash({ type, deps }));
+}
+function depsInactive(deps) {
+  return deps === null || deps === void 0;
+}
+function structuralHash(deps) {
+  return stableStringify(deps);
+}
+function stableStringify(value) {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number" || t === "boolean") return String(value);
+  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(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      const ctor = value.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 = value;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).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 subEntriesOf(machine) {
+  return machine.subs ?? [];
+}
+function desiredSub(entry, state) {
+  const deps = entry.deps(state);
+  if (depsInactive(deps)) return null;
+  return { id: subIdOf(entry.type, deps), type: entry.type, 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/runtime-types.ts
+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.`
+    );
+  }
+};
+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 byId = /* @__PURE__ */ new Map();
+  for (const entry of subEntriesOf(machine)) {
+    const sub = desiredSub(entry, state);
+    if (sub !== null && !byId.has(sub.id)) {
+      byId.set(sub.id, sub);
+    }
+  }
+  return { state, cmds, subs: [...byId.values()] };
+}
+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 Outcome.err(
+      new NoCellError(msg.type, found.stateName, found.acceptedTypes)
+    );
+  }
+  return Outcome.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 (stepped._tag === "Err") {
+      return Outcome.err({ index, msg, error: stepped.error });
+    }
+    if (__DEV__) assertPureResult(stepped.value, msg.type);
+    state = stepped.value[0];
+  }
+  return Outcome.ok(state);
+}
+function tryInterpret(work, onOk, onErr) {
+  return async (cmd, ctx) => {
+    let value;
+    try {
+      value = await work(cmd, ctx);
+    } catch (error) {
+      return onErr(error, cmd);
+    }
+    return onOk(value, cmd);
+  };
+}
+
+export { AsyncSchemaError, Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NoCellError, Outcome, OutcomeContractError, PortNameCollisionError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, UndeclaredFailureError, __resetPortRegistry, absurd, acceptedTypes, acceptsOf, applyCell, applyCellChecked, asReducer, checkedStep, cmdEdge, cmdEdgeOf, cmdEdgeOver, defineMachine, definePort, describeMachine, desiredSub, detachWork, detachWorkOf, detectUpdateForm, foldMsgs, foldUpdates, formOf, isFencedStore, malformedResult, msgKeysOf, noop, replay, schemaMigrate, structuralHash, subEntriesOf, subId, subIdOf, tryApplyCell, tryFoldMsgs, tryInterpret, validateSync, without, wrapDetached };
+//# sourceMappingURL=chunk-CH5KTOEZ.js.map
+//# sourceMappingURL=chunk-CH5KTOEZ.js.map