@demlik/tea 0.6.0 → 0.8.0

package/dist/chunk-E6GEDSF4.js

@@ -0,0 +1,307 @@
+import { safeId, safeLabel } from './chunk-UOC2PL46.js';
+import { Cmd, NoCellError } from './chunk-B5VXOFMZ.js';
+
+// src/chart/compile.ts
+var CellTargetError = class extends Error {
+  constructor(at, cell, returned, declared) {
+    super(
+      `@demlik/tea: cell "${cell}" at edge "${at}" returned state "${returned}", which is not among that edge's declared targets [${declared.map((t) => `"${t}"`).join(", ")}] \u2014 either the cell is wrong, or the edge's \`to\` is missing a target the code can reach (in which case add it, so the chart still draws the whole fan-out).`
+    );
+    this.at = at;
+    this.cell = cell;
+    this.returned = returned;
+    this.declared = declared;
+  }
+  at;
+  cell;
+  returned;
+  declared;
+  name = "CellTargetError";
+  _tag = "CellTargetError";
+};
+function cmdNames(ref) {
+  if (ref === void 0) return [];
+  return typeof ref === "string" ? [ref] : ref;
+}
+function flatten(c) {
+  const out = /* @__PURE__ */ new Map();
+  for (const group of Object.keys(c.states)) {
+    const members = c.states[group] ?? {};
+    for (const s of Object.keys(members)) {
+      const node = members[s];
+      if (node !== void 0) out.set(s, { node, group });
+    }
+  }
+  return out;
+}
+function scopeList(scope) {
+  return typeof scope === "string" ? [scope] : scope;
+}
+function rtParts(parts) {
+  const p = parts;
+  return {
+    assign: p.assign ?? {},
+    guards: p.guards ?? {},
+    cmds: p.cmds ?? {},
+    cells: p.cells ?? {}
+  };
+}
+function buildCell(spec, bare, at, p, parking) {
+  const edge = typeof spec === "string" ? { target: spec } : spec;
+  const cell = p.assign[at];
+  if (edge.cell !== void 0) {
+    const name = edge.cell;
+    const impl = p.cells[name];
+    if (impl === void 0) {
+      throw new Error(
+        `@demlik/tea: edge "${at}" names cell "${name}" with no implementation`
+      );
+    }
+    const hand = typeof impl === "function" ? impl : impl[at];
+    if (hand === void 0) {
+      throw new Error(
+        `@demlik/tea: cell "${name}" is written in the per-site form but has no entry for edge "${at}"`
+      );
+    }
+    const to = edge.to ?? [];
+    return (st, nsMsg) => {
+      const out = hand(st, { ...nsMsg, type: bare }, at);
+      if (!to.includes(out[0].type)) {
+        throw new CellTargetError(at, name, out[0].type, to);
+      }
+      return out;
+    };
+  }
+  const guard = edge.when === void 0 ? void 0 : p.guards[edge.when];
+  if (edge.when !== void 0 && guard === void 0) {
+    throw new Error(
+      `@demlik/tea: edge "${at}" names guard "${edge.when}" with no implementation`
+    );
+  }
+  return (st, nsMsg) => {
+    const msg = { ...nsMsg, type: bare };
+    let target;
+    let payloadFn;
+    let fired = true;
+    if (edge.resume !== void 0) {
+      target = st.was ?? edge.resume.fallback;
+      payloadFn = cell;
+    } else if (guard !== void 0) {
+      fired = guard(st, msg, at) === true;
+      const branch = cell;
+      target = fired ? edge.target : edge.otherwise;
+      payloadFn = fired ? branch.then : branch.else;
+    } else {
+      target = edge.target;
+      payloadFn = cell;
+    }
+    const data = payloadFn(st, msg);
+    const next = parking.has(target) ? { ...data, type: target, was: st.type } : { ...data, type: target };
+    const emitted = cmdNames(fired ? edge.cmd : edge.otherwiseCmd).map(
+      (n) => {
+        const build = p.cmds[n];
+        if (build === void 0) {
+          throw new Error(
+            `@demlik/tea: edge "${at}" names cmd "${n}" with no builder`
+          );
+        }
+        return { ...build(st, msg, at), type: n };
+      }
+    );
+    return [next, emitted];
+  };
+}
+function keyOf(c, e, ns) {
+  return ns === void 0 || c.events[e]?.foreign === true ? e : `${ns}.${e}`;
+}
+var NO_PARKING = /* @__PURE__ */ new Set();
+function compileTable(chart, parts, ns) {
+  const c = chart;
+  const p = rtParts(parts);
+  const flat = flatten(c);
+  const events = Object.keys(c.events);
+  const parking = /* @__PURE__ */ new Set();
+  for (const [s, { node }] of flat) {
+    for (const spec of Object.values(node.on ?? {})) {
+      if (typeof spec === "object" && spec.resume !== void 0) parking.add(s);
+    }
+  }
+  const table = {};
+  for (const [s, { node, group }] of flat) {
+    const row = {};
+    const on = node.on ?? {};
+    for (const e of events) {
+      const key = keyOf(c, e, ns);
+      const spec = on[e];
+      if (spec === void 0) {
+        const scope = scopeList(c.events[e]?.scope ?? "edges");
+        const live = scope.includes("all") || scope.includes(group);
+        const refused = node.end !== void 0 || !live || (node.ignore ?? []).includes(e);
+        row[key] = refused ? (st) => [st, []] : () => {
+          throw new NoCellError(key, s);
+        };
+        continue;
+      }
+      row[key] = buildCell(spec, e, `${s}.${e}`, p, parking);
+    }
+    table[s] = row;
+  }
+  return table;
+}
+function compile(chart, parts, ns) {
+  return compileTable(chart, parts, ns);
+}
+function compileReducer(chart, parts, ns) {
+  const c = chart;
+  const p = rtParts(parts);
+  const out = {};
+  for (const e of Object.keys(c.events)) {
+    const spec = c.on[e];
+    if (spec === void 0) {
+      throw new Error(`@demlik/tea: reducer chart declares no edge for "${e}"`);
+    }
+    out[keyOf(c, e, ns)] = buildCell(spec, e, e, p, NO_PARKING);
+  }
+  return out;
+}
+function reducerInitFrom(chart, boot) {
+  const type = chart.initial;
+  return (loaded) => [
+    loaded ?? { ...boot(), type },
+    Cmd.none
+  ];
+}
+function reducerMermaid(chart) {
+  const c = chart;
+  const lines = [
+    "stateDiagram-v2",
+    "  direction TB",
+    `  [*] --> ${safeId(c.initial)}`
+  ];
+  for (const [e, spec] of Object.entries(c.on)) {
+    lines.push(...edgeLines("any", "any", e, spec, NO_MARKS));
+  }
+  return lines.join("\n");
+}
+function initialStateOf(chart) {
+  const flat = flatten(chart);
+  const marked = [...flat].filter(([, f]) => f.node.initial === true);
+  const only = marked[0];
+  if (marked.length !== 1 || only === void 0) {
+    throw new Error(
+      `@demlik/tea: chart must mark exactly one state \`initial: true\` (found ${marked.length})`
+    );
+  }
+  return only[0];
+}
+function initFrom(chart, boot) {
+  const type = initialStateOf(chart);
+  return (loaded) => [
+    // The one cast this helper needs: `{ ...InitialData, type: <the initial
+    // name> }` IS `Extract<S, { type: InitialState<C> }>`, but tsc cannot
+    // rebuild a union member from a spread plus a `string`-typed discriminant.
+    loaded ?? { ...boot(), type },
+    Cmd.none
+  ];
+}
+var edgeKey = (from, event, to) => `${from}|${event}|${to}`;
+var ACTIVE_CLASS = "teaActive";
+var ACTIVE_ERROR_CLASS = "teaActiveError";
+var TRIPPED_CLASS = "teaTripped";
+var SHIPPED_CLASS = "teaShipped";
+function nodeDecl(raw, indent) {
+  const id = safeId(raw);
+  return id === raw ? void 0 : `${indent}${id} : ${safeLabel(raw)}`;
+}
+function edgeLines(from, at, e, spec, mark) {
+  const edge = typeof spec === "string" ? { target: spec } : spec;
+  const out = [];
+  const arrow = (to, label) => {
+    out.push(
+      `  ${from} --> ${safeId(to)} : ${safeLabel(`${label}${mark(at, e, to)}`)}`
+    );
+  };
+  if (edge.cell !== void 0) {
+    for (const t of edge.to ?? []) arrow(t, `${e} / ${edge.cell}()`);
+    return out;
+  }
+  if (edge.resume !== void 0) {
+    arrow(edge.resume.fallback, `${e} (resume)`);
+    return out;
+  }
+  const guard = edge.when === void 0 ? "" : ` [${edge.when}]`;
+  if (edge.target !== void 0) arrow(edge.target, `${e}${guard}`);
+  if (edge.otherwise !== void 0)
+    arrow(edge.otherwise, `${e} [!${edge.when ?? ""}]`);
+  return out;
+}
+var NO_MARKS = () => "";
+function chartMermaid(chart, opts = {}) {
+  const c = chart;
+  const flat = flatten(c);
+  const lines = [];
+  if (opts.title !== void 0)
+    lines.push("---", `title: ${opts.title}`, "---");
+  lines.push("stateDiagram-v2", `  direction ${opts.direction ?? "TB"}`);
+  const walked = opts.walked;
+  const mark = (from, event, to) => {
+    const n = walked?.get(edgeKey(from, event, to)) ?? 0;
+    return n === 0 ? "" : n === 1 ? " \xBB" : ` \xBB\xD7${n}`;
+  };
+  if (opts.phases === true) {
+    for (const [group, members] of Object.entries(c.states)) {
+      lines.push(`  state ${safeId(group)} {`);
+      for (const s of Object.keys(members)) {
+        lines.push(nodeDecl(s, "    ") ?? `    ${safeId(s)}`);
+      }
+      lines.push("  }");
+    }
+  }
+  for (const [s, { node }] of flat) {
+    const from = safeId(s);
+    if (opts.phases !== true) {
+      const decl = nodeDecl(s, "  ");
+      if (decl !== void 0) lines.push(decl);
+    }
+    if (node.initial === true) lines.push(`  [*] --> ${from}`);
+    for (const [e, spec] of Object.entries(node.on ?? {})) {
+      lines.push(...edgeLines(from, s, e, spec, mark));
+    }
+    if (node.end !== void 0) lines.push(`  ${from} --> [*]`);
+  }
+  if (opts.polarity === true) {
+    const tripped = [];
+    const shipped = [];
+    for (const [s, { node }] of flat) {
+      if (node.end === "error") tripped.push(safeId(s));
+      if (node.end === true) shipped.push(safeId(s));
+    }
+    if (tripped.length > 0) {
+      lines.push(
+        `  classDef ${TRIPPED_CLASS} stroke-dasharray:4 4`,
+        `  class ${tripped.join(",")} ${TRIPPED_CLASS}`
+      );
+    }
+    if (shipped.length > 0) {
+      lines.push(
+        `  classDef ${SHIPPED_CLASS} stroke-width:2px`,
+        `  class ${shipped.join(",")} ${SHIPPED_CLASS}`
+      );
+    }
+  }
+  if (opts.highlight !== void 0 && flat.has(opts.highlight)) {
+    const lit = flat.get(opts.highlight)?.node;
+    const died = opts.polarity === true && lit?.end === "error";
+    const cls = died ? ACTIVE_ERROR_CLASS : ACTIVE_CLASS;
+    const paint = died ? "#f85149" : "#2f81f7";
+    lines.push(
+      `  classDef ${cls} fill:${paint},stroke:${paint},color:#fff,font-weight:bold`,
+      `  class ${safeId(opts.highlight)} ${cls}`
+    );
+  }
+  return lines.join("\n");
+}
+
+export { CellTargetError, chartMermaid, compile, compileReducer, compileTable, edgeKey, initFrom, initialStateOf, reducerInitFrom, reducerMermaid };
+//# sourceMappingURL=chunk-E6GEDSF4.js.map
+//# sourceMappingURL=chunk-E6GEDSF4.js.map

package/dist/chunk-E6GEDSF4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chart/compile.ts"],"names":[],"mappings":"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","file":"chunk-E6GEDSF4.js","sourcesContent":["// ═══════════════════════════════════════════════════════════════════════════\n// RUNTIME — the chart walk that emits a real `Transitions<S, M, C>`.\n// ═══════════════════════════════════════════════════════════════════════════\nimport { safeId, safeLabel } from \"../machine-viz/mermaid-id\";\nimport { Cmd, NoCellError, type Reducer, type Transitions } from \"../pure/core\";\nimport type {\n  Assigns,\n  CellName,\n  Cells,\n  Chart,\n  CmdOf,\n  Cmds,\n  GuardName,\n  Guards,\n  InitialData,\n  InitialState,\n  MsgIn,\n  MsgOf,\n  RAssigns,\n  RCellName,\n  RCells,\n  RCmds,\n  ReducerChart,\n  RGuardName,\n  RGuards,\n  RStateOf,\n  RUsedCmdName,\n  StateOf,\n  UsedCmdName,\n} from \"./graph\";\n\n/**\n * A cell returned a state OUTSIDE its edge's declared `to`.\n *\n * The escape hatch's bargain is that code may pick the target but only from the\n * set the chart admits — otherwise the drawing stops being a truthful picture\n * of the machine. For a SINGLE-site cell, and for the per-site form of a\n * multi-site one, the clamp is a compile error and this never fires. For the\n * function form of a MULTI-SITE cell it is the only enforcement there is: the\n * return of one rest signature over a union of tuples cannot be made to depend\n * on `at`, so the union of every site's `to` is the tightest static clamp\n * available and this closes the difference at the moment it is violated.\n *\n * It sits inside `buildCell`, so BOTH chart forms — the grid and the reducer —\n * get the same net from the same three lines.\n */\nexport class CellTargetError extends Error {\n  override readonly name = \"CellTargetError\";\n  readonly _tag = \"CellTargetError\" as const;\n  constructor(\n    public readonly at: string,\n    public readonly cell: string,\n    public readonly returned: string,\n    public readonly declared: readonly string[],\n  ) {\n    super(\n      `@demlik/tea: cell \"${cell}\" at edge \"${at}\" returned state ` +\n        `\"${returned}\", which is not among that edge's declared targets ` +\n        `[${declared.map((t) => `\"${t}\"`).join(\", \")}] — either the cell is ` +\n        `wrong, or the edge's \\`to\\` is missing a target the code can reach ` +\n        `(in which case add it, so the chart still draws the whole fan-out).`,\n    );\n  }\n}\n\n/** `undefined` → none; `\"x\"` → one; `[\"x\",\"y\"]` → both, in order. */\nfunction cmdNames(\n  ref: string | readonly string[] | undefined,\n): readonly string[] {\n  if (ref === undefined) return [];\n  return typeof ref === \"string\" ? [ref] : ref;\n}\n\n// There is no `unhandled` policy any more. A pair is DECLARED (an edge), or\n// REFUSED — by the event's `scope`, or by this state's `ignore`, or by\n// `end: true` — and `Total<C>` refuses to compile on any third case. The\n// refusal is a self-loop with no cmds; the throw below is the safety net under\n// the compile-time refusal (`.decisions/0011`), reached only when the mapped\n// types were bypassed with a cast.\nexport type Parts<C, S extends { type: string }, M extends { type: string }> = {\n  readonly assign: Assigns<C, S, M>;\n} & ([GuardName<C>] extends [never]\n  ? { readonly guards?: undefined }\n  : { readonly guards: Guards<C, S, M> }) &\n  ([UsedCmdName<C>] extends [never]\n    ? { readonly cmds?: undefined }\n    : { readonly cmds: Cmds<C, S, M> }) &\n  // the escape hatch's bag — demanded exactly when an edge names a cell.\n  ([CellName<C>] extends [never]\n    ? { readonly cells?: undefined }\n    : { readonly cells: Cells<C, S, M> });\n\n// ── runtime views of the chart (the shapes the walk actually reads) ────────\ntype RtEdge =\n  | string\n  | {\n      readonly target?: string;\n      readonly when?: string;\n      readonly otherwise?: string;\n      readonly cmd?: string | readonly string[];\n      readonly otherwiseCmd?: string | readonly string[];\n      readonly resume?: { readonly fallback: string };\n      readonly to?: readonly string[];\n      readonly cell?: string;\n    };\ntype RtNode = {\n  readonly initial?: true;\n  readonly on?: Record<string, RtEdge>;\n  readonly ignore?: readonly string[];\n  // BOTH polarities, because both are final and only one of them is a success.\n  // The walk reads `!== undefined` (either is terminal); the drawing reads the\n  // value, which is the whole reason it is not narrowed to `true` here.\n  readonly end?: true | \"error\";\n};\ntype RtChart = {\n  readonly events: Record<\n    string,\n    { readonly scope: string | readonly string[]; readonly foreign?: true }\n  >;\n  readonly states: Record<string, Record<string, RtNode>>;\n};\ntype RtState = { readonly type: string; readonly was?: string };\ntype RtMsg = { readonly type: string };\ntype RtCell = (s: RtState, m: RtMsg) => readonly [RtState, readonly Cmd[]];\ntype RtCellFn = (\n  s: RtState,\n  m: RtMsg,\n  at: string,\n) => readonly [RtState, readonly Cmd[]];\n/** Either form: one body for every site, or one body PER site keyed by `at`. */\ntype RtCellImpl = RtCellFn | Record<string, RtCellFn | undefined>;\ntype RtFn = (s: RtState, m: RtMsg) => object;\ntype RtGuard = (s: RtState, m: RtMsg, at: string) => boolean;\ntype RtAssign = RtFn | { readonly then: RtFn; readonly else: RtFn };\n\n/** State name → its node and its phase, flattened out of the grouped shape. */\ntype Flat = { readonly node: RtNode; readonly group: string };\n\nfunction flatten(c: RtChart): Map<string, Flat> {\n  const out = new Map<string, Flat>();\n  for (const group of Object.keys(c.states)) {\n    const members = c.states[group] ?? {};\n    for (const s of Object.keys(members)) {\n      const node = members[s];\n      if (node !== undefined) out.set(s, { node, group });\n    }\n  }\n  return out;\n}\n\nfunction scopeList(scope: string | readonly string[]): readonly string[] {\n  return typeof scope === \"string\" ? [scope] : scope;\n}\n\n/** The code parts, after the type layer has been erased. Shared by both forms. */\ntype RtParts = {\n  readonly assign: Record<string, RtAssign | undefined>;\n  readonly guards: Record<string, RtGuard | undefined>;\n  readonly cmds: Record<\n    string,\n    ((s: RtState, m: RtMsg, at: string) => object) | undefined\n  >;\n  readonly cells: Record<string, RtCellImpl | undefined>;\n};\n\nfunction rtParts(parts: object): RtParts {\n  const p = parts as Record<string, object | undefined>;\n  return {\n    assign: (p.assign ?? {}) as RtParts[\"assign\"],\n    guards: (p.guards ?? {}) as RtParts[\"guards\"],\n    cmds: (p.cmds ?? {}) as RtParts[\"cmds\"],\n    cells: (p.cells ?? {}) as RtParts[\"cells\"],\n  };\n}\n\n/**\n * ONE edge → one transition cell. This is the whole walk, and it is shared\n * verbatim by both chart forms: a `Transitions` cell and a `Reducer` cell\n * differ only in what `at` is (`\"state.event\"` vs `\"event\"`) and in whether a\n * parking set exists to inject `was` from — both parameters here, not branches.\n *\n * `bare` is the un-namespaced event name the author's parts are written\n * against; the compiled cell restores it before calling them.\n */\nfunction buildCell(\n  spec: RtEdge,\n  bare: string,\n  at: string,\n  p: RtParts,\n  parking: ReadonlySet<string>,\n): RtCell {\n  const edge = typeof spec === \"string\" ? { target: spec } : spec;\n  const cell = p.assign[at];\n\n  // ── THE ESCAPE HATCH ────────────────────────────────────────────────────\n  // A `{ to, cell }` edge is the whole transition: the cell picks the target\n  // from `to` and returns its own cmds, so there is no assign to call, no\n  // guard to evaluate, no cmd list to rebuild and no `was` to inject (a cell\n  // landing on a parking state supplies `was` itself — its return type demands\n  // it). The other fields are compile errors beside `cell`, so this branch is\n  // not silently skipping anything.\n  if (edge.cell !== undefined) {\n    const name = edge.cell;\n    const impl = p.cells[name];\n    if (impl === undefined) {\n      throw new Error(\n        `@demlik/tea: edge \"${at}\" names cell \"${name}\" with no implementation`,\n      );\n    }\n    // the two forms: one body for every site, or one body per site. A\n    // multi-site cell may be written either way (`Cells`/`RCells` offer both);\n    // a single-site one is always the plain function.\n    const hand = typeof impl === \"function\" ? impl : impl[at];\n    if (hand === undefined) {\n      throw new Error(\n        `@demlik/tea: cell \"${name}\" is written in the per-site form but has no entry for edge \"${at}\"`,\n      );\n    }\n    const to = edge.to ?? [];\n    return (st, nsMsg) => {\n      const out = hand(st, { ...nsMsg, type: bare }, at);\n      // the runtime half of the `to` clamp — see `CellTargetError`.\n      if (!to.includes(out[0].type)) {\n        throw new CellTargetError(at, name, out[0].type, to);\n      }\n      return out;\n    };\n  }\n\n  // A guarded edge is resolved HERE, not at dispatch — same as `cell` above and\n  // for the same reason: an unimplemented name is a wiring mistake, and a\n  // wiring mistake should surface when the chart is compiled rather than on the\n  // first message that happens to reach this edge.\n  //\n  // It is the only one of the three that ever read a missing part as a VALUE.\n  // A missing cmd builder throws, a missing cell throws, and a missing guard\n  // used to quietly evaluate to `false` — which is not an error, it is the\n  // `otherwise` arm. On the imported door (`chart/lane`) the guard alphabet is\n  // `string`, so no type ever checked the name either: a typo in an operator's\n  // parts routed the whole lane down its failure arm in silence.\n  const guard = edge.when === undefined ? undefined : p.guards[edge.when];\n  if (edge.when !== undefined && guard === undefined) {\n    throw new Error(\n      `@demlik/tea: edge \"${at}\" names guard \"${edge.when}\" with no implementation`,\n    );\n  }\n\n  return (st, nsMsg) => {\n    // strip the namespace so the author's parts see the bare event.\n    const msg: RtMsg = { ...nsMsg, type: bare };\n\n    let target: string;\n    let payloadFn: RtFn;\n    let fired = true;\n\n    if (edge.resume !== undefined) {\n      target = st.was ?? edge.resume.fallback;\n      payloadFn = cell as RtFn;\n    } else if (guard !== undefined) {\n      fired = guard(st, msg, at) === true;\n      const branch = cell as { then: RtFn; else: RtFn };\n      target = fired ? (edge.target as string) : (edge.otherwise as string);\n      payloadFn = fired ? branch.then : branch.else;\n    } else {\n      target = edge.target as string;\n      payloadFn = cell as RtFn;\n    }\n\n    const data = payloadFn(st, msg);\n    // `was` is INJECTED, never authored: entering a parking state records where\n    // you came from. The type of `was` is `ResumeTargets<C, target>`, and\n    // `st.type` is in that set by construction.\n    const next: RtState = parking.has(target)\n      ? { ...data, type: target, was: st.type }\n      : { ...data, type: target };\n\n    // 0..n Cmds, in declaration order. A guarded edge picks its arm's list —\n    // `Cmd.when` lifted onto the edge, so which effects fire is visible in the\n    // chart rather than buried in a cell body.\n    const emitted = cmdNames(fired ? edge.cmd : edge.otherwiseCmd).map(\n      (n): Cmd => {\n        const build = p.cmds[n];\n        if (build === undefined) {\n          throw new Error(\n            `@demlik/tea: edge \"${at}\" names cmd \"${n}\" with no builder`,\n          );\n        }\n        return { ...build(st, msg, at), type: n };\n      },\n    );\n\n    return [next, emitted];\n  };\n}\n\n/** `undefined` → bare; a foreign event → bare; otherwise `${ns}.${event}`. */\nfunction keyOf(\n  c: {\n    readonly events: Record<string, { readonly foreign?: true } | undefined>;\n  },\n  e: string,\n  ns: string | undefined,\n): string {\n  return ns === undefined || c.events[e]?.foreign === true ? e : `${ns}.${e}`;\n}\n\nconst NO_PARKING: ReadonlySet<string> = new Set<string>();\n\n/**\n * One compiled table, BEFORE the typed boundary — `state.type` → the event key\n * → the cell.\n *\n * The shape `compile` builds and then declares as a `Transitions<S, M, C>`. It\n * is named because a second caller needs the walk without the declaration:\n * `chart/lane/run` compiles ONE region per task and the tables it holds are\n * keyed by task id, so the per-region `Transitions` type is never the type of\n * anything it stores.\n */\nexport type CompiledTable = Readonly<\n  Record<string, Readonly<Record<string, RtCell | undefined>> | undefined>\n>;\n\n/**\n * THE WALK, with no type layer over it — `compile`'s body, callable by a second\n * compiler that has already done its own type checking.\n *\n * `chart`/`parts` are `object` rather than the F-bounded `Chart<C>`/`Parts<…>`\n * because this entry is not where the checking happens; it is where the\n * checking has ALREADY happened. The erasing cast lives here, exactly once, at\n * the top of the walk — which is where it lived before this function had a\n * name, so nothing gained a cast by being reachable from two places.\n */\nexport function compileTable(\n  chart: object,\n  parts: object,\n  ns: string | undefined,\n): CompiledTable {\n  const c = chart as unknown as RtChart;\n  const p = rtParts(parts);\n\n  const flat = flatten(c);\n  const events = Object.keys(c.events);\n  const parking = new Set<string>();\n  for (const [s, { node }] of flat) {\n    for (const spec of Object.values(node.on ?? {})) {\n      if (typeof spec === \"object\" && spec.resume !== undefined) parking.add(s);\n    }\n  }\n\n  const table: Record<string, Record<string, RtCell>> = {};\n\n  for (const [s, { node, group }] of flat) {\n    const row: Record<string, RtCell> = {};\n    const on = node.on ?? {};\n\n    for (const e of events) {\n      // the one runtime consequence of per-event namespacing.\n      const key = keyOf(c, e, ns);\n      const spec = on[e];\n\n      if (spec === undefined) {\n        // the mirror of `MissingAt<C, S>`: live-but-undecided is the only case\n        // the type layer forbids, so it is the only case that throws.\n        const scope = scopeList(c.events[e]?.scope ?? \"edges\");\n        const live = scope.includes(\"all\") || scope.includes(group);\n        // `end` is `true` (success) or `\"error\"`; BOTH are final, and the type\n        // layer's `IsEndOf` reads both. Testing `=== true` here would put an\n        // error final back under the totality obligation at runtime only.\n        const refused =\n          node.end !== undefined || !live || (node.ignore ?? []).includes(e);\n        row[key] = refused\n          ? (st) => [st, []]\n          : () => {\n              throw new NoCellError(key, s);\n            };\n        continue;\n      }\n\n      // the site tag, passed to guards/cmds/cells as their last argument — it is\n      // what lets a multi-site helper discriminate (see `SiteArgs` in graph.ts).\n      row[key] = buildCell(spec, e, `${s}.${e}`, p, parking);\n    }\n    table[s] = row;\n  }\n\n  return table;\n}\n\n/**\n * Compile a chart + the code parts into a genuine `Transitions<S, M, C>`.\n *\n * `ns` is OPTIONAL and PER-EVENT. Omitted, nothing is decorated and the table\n * is keyed by the bare event names — a single-instance machine carries no\n * namespace and passes no dummy string. Given, the author's own events are\n * keyed `${ns}.${event}` (so N instances share one dispatch surface with\n * genuinely disjoint literal unions), while every event the chart marks\n * `foreign: true` keeps its BARE name: a library-minted Msg like\n * `deadline_exceeded` is the same event for every instance, and its name was\n * never the author's to rename.\n *\n * The returned type is `Transitions<S, MsgIn<C, NS>, K>` — literal keys, never\n * `string`. The parts are authored against the BARE msg union; the compiled\n * cell restores the bare event name before calling them.\n *\n * `S`/`M`/`K` DEFAULT to the chart's own derivations, so the common call is\n * `compile(chart, parts)` with no type arguments at all.\n */\nexport function compile<\n  const C extends Chart<C>,\n  S extends { type: string } = StateOf<C>,\n  M extends { type: string } = MsgOf<C>,\n  K extends Cmd = CmdOf<C>,\n  const NS extends string | undefined = undefined,\n>(chart: C, parts: Parts<C, S, M>, ns?: NS): Transitions<S, MsgIn<C, NS>, K> {\n  // ── THE ONE CAST ────────────────────────────────────────────────────────\n  // Inside the library, at the construction boundary. `Transitions` is a\n  // mapped type over `S[\"type\"] × M[\"type\"]`; the walk builds the same keys\n  // from the flattened chart × the per-event keys, but tsc cannot see that a\n  // string-keyed record built in a loop is total over those unions.\n  return compileTable(chart, parts, ns) as unknown as Transitions<\n    S,\n    MsgIn<C, NS>,\n    K\n  >;\n}\n\n// ═══════════════════════════════════════════════════════════════════════════\n// REDUCER FORM — the same walk, one loop shallower.\n// ═══════════════════════════════════════════════════════════════════════════\n\n/**\n * The reducer form's parts bag. Structurally identical to `Parts`, over the\n * reducer chart's derivations — `assign` is total over the DECLARATIVE events\n * (a cell event owes none), and each of `guards`/`cmds`/`cells` is demanded\n * exactly when the chart names one.\n */\nexport type RParts<\n  C,\n  S extends { type: string },\n  M extends { type: string },\n> = {\n  readonly assign: RAssigns<C, S, M>;\n} & ([RGuardName<C>] extends [never]\n  ? { readonly guards?: undefined }\n  : { readonly guards: RGuards<C, S, M> }) &\n  ([RUsedCmdName<C>] extends [never]\n    ? { readonly cmds?: undefined }\n    : { readonly cmds: RCmds<C, S, M> }) &\n  ([RCellName<C>] extends [never]\n    ? { readonly cells?: undefined }\n    : { readonly cells: RCells<C, S, M> });\n\ntype RtReducerChart = {\n  readonly events: Record<string, { readonly foreign?: true }>;\n  readonly initial: string;\n  readonly on: Record<string, RtEdge>;\n};\n\n/**\n * Compile a reducer-form chart into a genuine `Reducer<S, M, K>` — the flat,\n * msg-keyed `update` shape `defineMachine` already accepts (`src/pure/core.ts`).\n *\n * There is no `NoCellError` branch and no refusal branch here, and that is not\n * an omission: `on` is a TOTAL mapped type over the event alphabet, so an\n * undeclared event cannot exist to be missing. The safety the grid form buys\n * with `scope` + `ignore` + `Total<C>`, this form gets from the mapped type.\n *\n * `ns` behaves exactly as in `compile`: per-event, optional, and never applied\n * to an event the chart marks `foreign`.\n */\nexport function compileReducer<\n  const C extends ReducerChart<C>,\n  S extends { type: string } = RStateOf<C>,\n  M extends { type: string } = MsgOf<C>,\n  K extends Cmd = CmdOf<C>,\n  const NS extends string | undefined = undefined,\n>(chart: C, parts: RParts<C, S, M>, ns?: NS): Reducer<S, MsgIn<C, NS>, K> {\n  const c = chart as unknown as RtReducerChart;\n  const p = rtParts(parts);\n  const out: Record<string, RtCell> = {};\n\n  for (const e of Object.keys(c.events)) {\n    const spec = c.on[e];\n    if (spec === undefined) {\n      // unreachable through the typed door — `on` is total over `events`. The\n      // safety net under the compile-time obligation, as `NoCellError` is\n      // under `Total<C>`.\n      throw new Error(`@demlik/tea: reducer chart declares no edge for \"${e}\"`);\n    }\n    // the site tag IS the event: one dimension, so `SiteArgs`'s `at` is the\n    // bare name and a multi-site cell discriminates on it exactly as before.\n    out[keyOf(c, e, ns)] = buildCell(spec, e, e, p, NO_PARKING);\n  }\n\n  // The same one cast, for the same reason: a string-keyed record built in a\n  // loop is total over `M[\"type\"]`, and tsc cannot see it.\n  return out as unknown as Reducer<S, MsgIn<C, NS>, K>;\n}\n\n/**\n * `init` for a reducer chart. The entry state is the chart's `initial` field —\n * one word, still never repeated by the author — and `boot()` supplies `ctx`,\n * which for this form IS the whole state minus its tag.\n */\nexport function reducerInitFrom<\n  const C extends ReducerChart<C>,\n  S extends { type: string } = RStateOf<C>,\n  K extends Cmd = CmdOf<C>,\n>(\n  chart: C,\n  boot: () => Omit<RStateOf<C>, \"type\">,\n): (loaded: S | null) => readonly [S, readonly K[]] {\n  const type: string = (chart as unknown as RtReducerChart).initial;\n  return (loaded) => [\n    loaded ?? ({ ...boot(), type } as unknown as S),\n    Cmd.none,\n  ];\n}\n\n/**\n * The reducer chart, drawn. There is no per-state routing to show, so the\n * honest picture is one `any` node — every edge is reachable from every state,\n * which is what having no phase dimension MEANS — plus each event's full\n * fan-out, cell edges included.\n */\nexport function reducerMermaid<const C extends ReducerChart<C>>(\n  chart: C,\n): string {\n  const c = chart as unknown as RtReducerChart;\n  const lines = [\n    \"stateDiagram-v2\",\n    \"  direction TB\",\n    `  [*] --> ${safeId(c.initial)}`,\n  ];\n  // The SAME edge grammar `chartMermaid` draws — see {@link edgeLines}. The one\n  // difference this form has is `from`, which is `any` at every edge, because\n  // having no phase dimension MEANS every edge is reachable from every state.\n  for (const [e, spec] of Object.entries(c.on)) {\n    lines.push(...edgeLines(\"any\", \"any\", e, spec, NO_MARKS));\n  }\n  return lines.join(\"\\n\");\n}\n\n// ═══════════════════════════════════════════════════════════════════════════\n// `init`, DERIVED FROM THE CHART\n// ═══════════════════════════════════════════════════════════════════════════\n\n/**\n * The name of the state marked `initial: true`. Throws unless EXACTLY one is\n * marked — the runtime half of what `InitialData`'s marker types say at the\n * type level.\n */\nexport function initialStateOf<const C extends Chart<C>>(\n  chart: C,\n): InitialState<C> {\n  const flat = flatten(chart as unknown as RtChart);\n  const marked = [...flat].filter(([, f]) => f.node.initial === true);\n  const only = marked[0];\n  if (marked.length !== 1 || only === undefined) {\n    throw new Error(\n      `@demlik/tea: chart must mark exactly one state \\`initial: true\\` (found ${marked.length})`,\n    );\n  }\n  // `Object.keys` yields `string`; the type-level answer is the same key.\n  return only[0] as InitialState<C>;\n}\n\n/**\n * Build a `Machine[\"init\"]` from the chart's declared entry state plus a\n * `boot()` that supplies ONLY that state's data. The state NAME is never\n * repeated by the author — it comes from the same `initial: true` that\n * `machine-viz` reads to draw the `[*] -->` edge.\n *\n * Rehydrate is honoured verbatim: a non-null `loaded` is returned untouched\n * with NO cmds, which is exactly Invariant 2's contract.\n */\nexport function initFrom<\n  const C extends Chart<C>,\n  S extends { type: string },\n  K extends Cmd,\n>(\n  chart: C,\n  boot: () => InitialData<C, S>,\n): (loaded: S | null) => readonly [S, readonly K[]] {\n  const type: string = initialStateOf(chart);\n  return (loaded) => [\n    // The one cast this helper needs: `{ ...InitialData, type: <the initial\n    // name> }` IS `Extract<S, { type: InitialState<C> }>`, but tsc cannot\n    // rebuild a union member from a spread plus a `string`-typed discriminant.\n    loaded ?? ({ ...boot(), type } as unknown as S),\n    Cmd.none,\n  ];\n}\n\n// ═══════════════════════════════════════════════════════════════════════════\n// DRAWING THE CHART — every declared edge, including a cell edge's fan-out.\n//\n// `machine-viz`'s `toMermaid` works on a COMPILED machine and resolves a cell\n// by executing it against a sample, so it draws the ONE edge that sample takes\n// — true of a guarded edge before the escape hatch existed, and equally true\n// of a `{ to, cell }` edge now. The chart, though, still knows every possible\n// target, which is the whole point of declaring `to`. This reads the chart\n// directly and draws the full fan-out, no samples and no execution needed.\n//\n// THIS IS THE ONLY CHART RENDERER. `chart/report/draw.ts` used to carry a\n// second one, written in parallel against the same mermaid grammar while this\n// one was growing its options bag; the two diverged before the swap its banner\n// promised ever happened (a guarded then-arm drawn bare here and labelled\n// there, two spellings of the highlight class, sanitizing on one side only).\n// How a chart is drawn is ONE fact, so there is one body and the report enters\n// it through `drawTask`, which is now nothing but a translation of its option\n// names into these.\n//\n// WHAT MERMAID CAN AND CANNOT DO, stated so `walked` is judged fairly:\n// `stateDiagram-v2` supports `classDef`/`class`, so LIGHTING A NODE is real\n// styling. It supports no per-edge styling at all — there is no `linkStyle` for\n// a state diagram — so a walked edge is marked ON ITS LABEL (`»`, plus the\n// visit count) rather than thickened. Still true as of mermaid 11.\n// ═══════════════════════════════════════════════════════════════════════════\n\n/** How many times each {@link edgeKey} was walked. */\nexport type WalkCounts = ReadonlyMap<string, number>;\n\n/**\n * The key a {@link ChartMermaidOptions.walked} map is read by.\n *\n * One spelling, shared by whoever counts the walk and the drawing that marks\n * it — the names are the chart's OWN, unsanitized, because the counter reads\n * them off a log and has no business knowing what mermaid can spell.\n *\n * NOT `EdgeKey<C>` (`graph.ts`), despite the casing. That one is the SITE tag\n * — `\"state.event\"` — which is what a guard or a cmd builder is keyed by,\n * because a site is where code hangs. This one names a drawn ARROW, and a\n * guarded site draws two of them, so it needs the target as well.\n */\nexport const edgeKey = (from: string, event: string, to: string): string =>\n  `${from}|${event}|${to}`;\n\n/**\n * Options for {@link chartMermaid}. Every field is optional and every default\n * reproduces the drawing this function emitted before options existed — a flat\n * node set, `direction TB`, no title, no highlight, no polarity and no walk —\n * so an existing caller is untouched.\n *\n * Shaped after `MachineVizOptions` (`../machine-viz`) where the two overlap\n * (`direction`, `title`), because the two drawings are read side by side and a\n * second spelling of the same knob is a fact said twice. What is NOT shared is\n * `samples`: `toMermaid` needs them because it must EXECUTE a compiled cell to\n * learn a target; the chart declares its targets, so there is nothing to\n * resolve and nothing to sample.\n */\nexport interface ChartMermaidOptions {\n  /**\n   * Draw this state as the ACTIVE node — a `classDef`/`class` pair Mermaid\n   * renders with the highlight fill. Pass the live `state.type`. A name that is\n   * not in the chart is ignored rather than drawn as a phantom node.\n   */\n  readonly highlight?: string;\n  /**\n   * Draw each phase as a Mermaid COMPOSITE state (`state working { … }`).\n   *\n   * The chart groups its states into named phases and the flat drawing throws\n   * that away — which is the one structural fact `chartMermaid` knew and did\n   * not show. Off by default: turning it on changes the emitted text, and the\n   * drawing is something a reviewer approves rather than something that moves\n   * under them.\n   */\n  readonly phases?: boolean;\n  /**\n   * Draw the two ENDINGS differently — a dashed outline on every `end:\n   * \"error\"` final, a heavier one on every `end: true`.\n   *\n   * A success final and an error final both terminate, so both draw the `[*]`\n   * edge, and a picture that stopped there paints `shipped` and `frozen` alike\n   * in the one place a reader looks first. Off by default for the same reason\n   * `phases` is: it changes the emitted text.\n   */\n  readonly polarity?: boolean;\n  /**\n   * Edges the caller actually WALKED, keyed by {@link edgeKey} — each drawn\n   * edge that has a count picks up a `»` (or `»×N`) on its label.\n   *\n   * A missing or zero count marks nothing, so a chart nobody has run through\n   * draws exactly as it does without this option.\n   */\n  readonly walked?: WalkCounts;\n  /** Mermaid layout direction. Default `\"TB\"`. */\n  readonly direction?: \"TB\" | \"LR\";\n  /** Optional title, emitted as a Mermaid front-matter `title:` block. */\n  readonly title?: string;\n}\n\n/** The CSS class Mermaid applies to the highlighted node. */\nconst ACTIVE_CLASS = \"teaActive\";\n/** The highlighted node when it is where a task DIED — see `chartMermaid`. */\nconst ACTIVE_ERROR_CLASS = \"teaActiveError\";\n/** …and to the two endings, when `polarity` asks for them. */\nconst TRIPPED_CLASS = \"teaTripped\";\nconst SHIPPED_CLASS = \"teaShipped\";\n\n/**\n * A node's declaration line, or `undefined` when the sanitized id already IS\n * the name and the bare id carries the whole fact. Emitting the label only for\n * a renamed node is what keeps the default drawing byte-identical for charts\n * whose names were already Mermaid-safe.\n */\nfunction nodeDecl(raw: string, indent: string): string | undefined {\n  const id = safeId(raw);\n  return id === raw ? undefined : `${indent}${id} : ${safeLabel(raw)}`;\n}\n\n/**\n * ONE edge, as the arrows that draw it — the whole edge grammar, in one place.\n *\n * Both drawings in this file come through here: the grid form draws it from\n * each state, the reducer form from the single `any` node, and the two forms\n * differ in what `from` is and in nothing else. That is not tidiness — the\n * guarded arm's labelling was wrong in both of them, in the same way, and one\n * of them was fixed once already without the other moving.\n *\n * `at` is the UNSANITIZED source-state name the walk counter keyed by; `from`\n * is what mermaid will read.\n */\nfunction edgeLines(\n  from: string,\n  at: string,\n  e: string,\n  spec: RtEdge,\n  mark: (from: string, event: string, to: string) => string,\n): readonly string[] {\n  const edge = typeof spec === \"string\" ? { target: spec } : spec;\n  const out: string[] = [];\n  // ONE arrow-writer for every edge form, so the walk mark cannot be\n  // remembered on three of the four and forgotten on the fourth.\n  const arrow = (to: string, label: string): void => {\n    out.push(\n      `  ${from} --> ${safeId(to)} : ${safeLabel(`${label}${mark(at, e, to)}`)}`,\n    );\n  };\n  if (edge.cell !== undefined) {\n    // one real edge per DECLARED target — the fan-out, labelled with the cell\n    // that picks among them.\n    for (const t of edge.to ?? []) arrow(t, `${e} / ${edge.cell}()`);\n    return out;\n  }\n  if (edge.resume !== undefined) {\n    arrow(edge.resume.fallback, `${e} (resume)`);\n    return out;\n  }\n  // A GUARDED edge labels BOTH arms. Drawing the then-arm bare — `review -->\n  // build : FAIL` beside `review --> frozen : FAIL [!retriesRemaining]` —\n  // reads as an unconditional edge racing a conditional one, which is not what\n  // the chart says: the then-arm is exactly as conditional as the else-arm,\n  // and the reader is left to infer its guard from a sibling arrow.\n  const guard = edge.when === undefined ? \"\" : ` [${edge.when}]`;\n  if (edge.target !== undefined) arrow(edge.target, `${e}${guard}`);\n  if (edge.otherwise !== undefined)\n    arrow(edge.otherwise, `${e} [!${edge.when ?? \"\"}]`);\n  return out;\n}\n\n/** No walk to mark — the drawings that take no `walked` map. */\nconst NO_MARKS = (): string => \"\";\n\nexport function chartMermaid<const C extends Chart<C>>(\n  chart: C,\n  opts: ChartMermaidOptions = {},\n): string {\n  const c = chart as unknown as RtChart;\n  const flat = flatten(c);\n  const lines: string[] = [];\n  if (opts.title !== undefined)\n    lines.push(\"---\", `title: ${opts.title}`, \"---\");\n  lines.push(\"stateDiagram-v2\", `  direction ${opts.direction ?? \"TB\"}`);\n\n  // The walk mark, keyed by the chart's OWN names — `walked` is counted off a\n  // log, so it never saw a sanitized id.\n  const walked = opts.walked;\n  const mark = (from: string, event: string, to: string): string => {\n    const n = walked?.get(edgeKey(from, event, to)) ?? 0;\n    return n === 0 ? \"\" : n === 1 ? \" »\" : ` »×${n}`;\n  };\n\n  // Phases, as composite states. Declared BEFORE the edges so every node is\n  // already inside its phase by the time an arrow references it — Mermaid\n  // otherwise hoists the first mention to the top level.\n  if (opts.phases === true) {\n    for (const [group, members] of Object.entries(c.states)) {\n      lines.push(`  state ${safeId(group)} {`);\n      for (const s of Object.keys(members)) {\n        lines.push(nodeDecl(s, \"    \") ?? `    ${safeId(s)}`);\n      }\n      lines.push(\"  }\");\n    }\n  }\n\n  for (const [s, { node }] of flat) {\n    const from = safeId(s);\n    // A renamed node needs its human name shown once. In `phases` mode the\n    // declaration already went inside the composite block.\n    if (opts.phases !== true) {\n      const decl = nodeDecl(s, \"  \");\n      if (decl !== undefined) lines.push(decl);\n    }\n    if (node.initial === true) lines.push(`  [*] --> ${from}`);\n    for (const [e, spec] of Object.entries(node.on ?? {})) {\n      lines.push(...edgeLines(from, s, e, spec, mark));\n    }\n    // Both polarities terminate, so both draw the `[*]` edge — an error final\n    // that stopped drawing one would read as a state the machine can leave.\n    if (node.end !== undefined) lines.push(`  ${from} --> [*]`);\n  }\n\n  // The classes, last: a `classDef` must exist before the `class` line that\n  // uses it, and both must sit outside any composite block. Each pair is\n  // emitted only when something wears it, so an unused `classDef` never lands.\n  if (opts.polarity === true) {\n    const tripped: string[] = [];\n    const shipped: string[] = [];\n    for (const [s, { node }] of flat) {\n      if (node.end === \"error\") tripped.push(safeId(s));\n      if (node.end === true) shipped.push(safeId(s));\n    }\n    if (tripped.length > 0) {\n      lines.push(\n        `  classDef ${TRIPPED_CLASS} stroke-dasharray:4 4`,\n        `  class ${tripped.join(\",\")} ${TRIPPED_CLASS}`,\n      );\n    }\n    if (shipped.length > 0) {\n      lines.push(\n        `  classDef ${SHIPPED_CLASS} stroke-width:2px`,\n        `  class ${shipped.join(\",\")} ${SHIPPED_CLASS}`,\n      );\n    }\n  }\n  if (opts.highlight !== undefined && flat.has(opts.highlight)) {\n    // The lit node carries POLARITY too, when polarity is on. `polarity` draws\n    // the two endings apart by STROKE and the highlight then painted a fill\n    // over the top, so an error final and a success final were the same picture\n    // at the exact moment one of them is where a task DIED. Every other surface\n    // — the chip, the badge, the stuck panel — says which; the drawing is the\n    // thing a reader looks at first and it was the one saying nothing.\n    const lit = flat.get(opts.highlight)?.node;\n    const died = opts.polarity === true && lit?.end === \"error\";\n    const cls = died ? ACTIVE_ERROR_CLASS : ACTIVE_CLASS;\n    const paint = died ? \"#f85149\" : \"#2f81f7\";\n    lines.push(\n      `  classDef ${cls} fill:${paint},stroke:${paint},color:#fff,font-weight:bold`,\n      `  class ${safeId(opts.highlight)} ${cls}`,\n    );\n  }\n  return lines.join(\"\\n\");\n}\n"]}

package/dist/{chunk-EC6FO42Q.js → chunk-EUF7XOEE.js}

@@ -1,11 +1,11 @@
 import { MsgType } from './chunk-JELSZN25.js';
-import { deadlineSub } from './chunk-ASX7PL2K.js';
+import { deadlineSub } from './chunk-JGVL3WPL.js';
 import { asRng, recordFailure, shouldRetry, nextDelayMs, initRetry } from './chunk-Q2UM7BXU.js';
 import { initBucket, tryConsume } from './chunk-S2EGRPCM.js';
 import { initCircuit, onSuccess, onFailure, canPass } from './chunk-UF4MZSLT.js';
-import { initCache, set, get } from './chunk-WF46FABO.js';
-import { tryInterpret } from './chunk-ZH454CR5.js';
-import { without } from './chunk-O7ED34JH.js';
+import { initCache, set, get } from './chunk-7SVIRMC6.js';
+import { tryInterpret } from './chunk-5EHLEUTL.js';
+import { without } from './chunk-B5VXOFMZ.js';
 
 // src/resilient-call/index.ts
 function circuitPolicy(config) {
@@ -219,5 +219,5 @@ function liftResilience(state, [slice, cmds]) {
 }
 
 export { createResilientCall, liftResilience };
-//# sourceMappingURL=chunk-EC6FO42Q.js.map
-//# sourceMappingURL=chunk-EC6FO42Q.js.map
+//# sourceMappingURL=chunk-EUF7XOEE.js.map
+//# sourceMappingURL=chunk-EUF7XOEE.js.map