@demlik/tea 0.13.0 → 0.14.0

package/dist/chunk-ZSUUOEPL.js

@@ -1,731 +0,0 @@
-import { detectUpdateForm, foldUpdates, depsInactive, structuralHash, lookupCell, NoCellError, __DEV__, deepFreeze, assertPureResult, applyCellChecked, malformedResult } from './chunk-OOYD44JI.js';
-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();
-    }
-  };
-}
-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 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 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 { cell, stateName } = lookupCell(machine, state, msg);
-  if (cell === void 0) {
-    return Result.err(new NoCellError(msg.type, stateName));
-  }
-  return Result.ok(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: (value) => builders.ok(cmd, value),
-      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: (value) => onOk(value, 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;
-}
-function run(machine, opts) {
-  const { store } = opts;
-  const ctx = opts.ctx ?? {};
-  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, value) {
-    const subscribers = portRegistry.get(port);
-    if (!subscribers || subscribers.size === 0) return;
-    fanout(subscribers, "port-emit", (listener) => listener(value));
-  }
-  const augmentedCtx = Object.assign(
-    {},
-    ctx,
-    { emit: portEmit }
-  );
-  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 cmdDefs = new Map(
-    (machine.cmds ?? []).map((def) => [def.cmdType, def])
-  );
-  function settleAtEdge(cmd, follow) {
-    const def = cmdDefs.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 isSettledShape(follow) {
-    return typeof follow === "object" && follow !== null && typeof follow.type === "string";
-  }
-  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--;
-    });
-  }
-  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 & NeedsOf<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;
-    if (store) await store.save(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) {
-    const [initialState, initCmds] = machine.init(null, ctx);
-    state = initialState;
-    pendingInitCmds = initCmds;
-  }
-  async function stepBootEffects() {
-    if (store) {
-      const raw = await store.load();
-      const parsed = store.migrate(raw);
-      const [initialState, initCmds] = machine.init(parsed, ctx);
-      state = initialState;
-      pendingInitCmds = initCmds;
-      await store.save(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 = {
-    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, value) {
-      portEmit(port, value);
-    },
-    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 store.save(state);
-        } catch (error) {
-          reportError(error, { phase: "stop-save" });
-        }
-      }
-    }
-  };
-  return runtime;
-}
-
-export { DispatchDiscardedError, DisposeTimeoutNotice, IdentityDropNotice, PortNameCollisionError, QuiescenceTimeoutError, RuntimeDiscardNotice, RuntimeDiscardedError, SubIdCollisionError, __resetPortRegistry, absurd, asReducer, defineMachine, definePort, historyTracker, noop, replay, run, schemaMigrate, settle, tryApplyCell, tryFoldMsgs, tryInterpret, wrapDetached };
-//# sourceMappingURL=chunk-ZSUUOEPL.js.map
-//# sourceMappingURL=chunk-ZSUUOEPL.js.map