@demlik/tea 0.7.0 → 0.8.0

package/dist/chunk-ZCL7SCBK.js

@@ -0,0 +1,685 @@
+import { inspectState, describeChart } from './chunk-ZD6PNZBK.js';
+import { foldLane, phaseStandings, trippedTasks, statesOf, RETRY_BUDGET, timeline, walkedEdgeKey, walkedEdges, initialOf, waitingOn, endPolarityOf, laneTerminalReached, bareEvent, drawTask, originOf } from './chunk-5KJKJOFC.js';
+import { compileTable } from './chunk-E6GEDSF4.js';
+
+// src/chart/lane/inspect.ts
+var describe = (chart) => describeChart(chart);
+function stuckAt(chart, state) {
+  const node = statesOf(chart).get(state.type);
+  const polarity = endPolarityOf(node);
+  if (polarity === "error") return { kind: "tripped", state: state.type };
+  if (polarity === true) return null;
+  const edges = Object.entries(node?.on ?? {});
+  if (edges.length === 0) return { kind: "dead-end", state: state.type };
+  if (state.retries >= state.maxRetries) {
+    for (const [event, edge] of edges) {
+      if ("when" in edge) {
+        return {
+          kind: "budget-spent",
+          state: state.type,
+          event,
+          landsOn: edge.otherwise
+        };
+      }
+    }
+  }
+  const origins = edges.map(([event]) => ({
+    event,
+    origin: originOf(chart, event)
+  }));
+  const started = state.type !== initialOf(chart);
+  if (started && origins.length > 0 && origins.every((o) => typeof o.origin === "object" && o.origin !== null)) {
+    const roles = [];
+    for (const { origin } of origins) {
+      const role = origin.world;
+      if (!roles.includes(role)) roles.push(role);
+    }
+    return {
+      kind: "awaiting-world",
+      state: state.type,
+      roles,
+      events: origins.map((o) => o.event)
+    };
+  }
+  return null;
+}
+function inspectLane(lane, entries, optsFor) {
+  return inspectLaneStates(lane, foldLane(lane, entries), optsFor);
+}
+function inspectLaneStates(lane, states, optsFor) {
+  const stands = phaseStandings(lane, states);
+  const active = stands.find((stand) => stand.standing === "active");
+  const trippedPhase = stands.find((stand) => stand.standing === "tripped");
+  const stuck = [];
+  const inspectTask = (stand, taskId) => {
+    const chart = lane.charts[taskId];
+    const state = states[taskId];
+    if (chart === void 0 || state === void 0) return null;
+    const desc = describe(chart);
+    const events = inspectState(desc, { ...state }, optsFor?.(taskId));
+    const reason = stuckAt(chart, state);
+    if (reason !== null) stuck.push({ task: taskId, reason });
+    return {
+      task: taskId,
+      phase: stand.name,
+      state: state.type,
+      endPolarity: endPolarityOf(statesOf(chart).get(state.type)),
+      ...state.was === void 0 ? {} : { was: state.was },
+      retries: state.retries,
+      maxRetries: state.maxRetries,
+      waitingOn: waitingOn(chart, state.type),
+      stuck: reason,
+      events,
+      refusals: events.flatMap(
+        (preview) => preview.status === "refused" && preview.reason !== void 0 ? [{ from: state.type, event: preview.event, reason: preview.reason }] : []
+      ),
+      legal: events.filter((preview) => preview.status === "legal").map((preview) => preview.event)
+    };
+  };
+  const phases = stands.map((stand) => ({
+    name: stand.name,
+    index: stand.index,
+    standing: stand.standing,
+    tripped: stand.tripped,
+    tasks: stand.tasks.flatMap((taskId) => inspectTask(stand, taskId) ?? [])
+  }));
+  return {
+    ...lane.id === void 0 ? {} : { id: lane.id },
+    status: active === void 0 ? "done" : "active",
+    terminal: active !== void 0 ? null : trippedPhase !== void 0 ? lane.terminals.tripped : lane.terminals.complete,
+    activePhase: active?.name ?? null,
+    phases,
+    tripped: trippedTasks(lane, states),
+    stuck
+  };
+}
+
+// src/chart/lane/structure.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var lowerEdge = (edge) => {
+  if (typeof edge === "string") return { target: edge };
+  if (!isRecord(edge)) return void 0;
+  if (isRecord(edge.resume) && typeof edge.resume.fallback === "string") {
+    return { resume: { fallback: edge.resume.fallback } };
+  }
+  if (typeof edge.target !== "string") return void 0;
+  const target = edge.target;
+  const cmds = {
+    ...edge.cmd === void 0 ? {} : { cmd: edge.cmd },
+    ...edge.otherwiseCmd === void 0 ? {} : { otherwiseCmd: edge.otherwiseCmd }
+  };
+  return typeof edge.when === "string" && typeof edge.otherwise === "string" ? { target, when: edge.when, otherwise: edge.otherwise, ...cmds } : { target, ...cmds };
+};
+var isString = (v) => typeof v === "string";
+var scopeList = (scope) => typeof scope === "string" ? [scope] : Array.isArray(scope) ? scope.filter(isString) : ["edges"];
+var refusalsAt = (region, group, node, routed) => {
+  const ignored = new Set(
+    Array.isArray(node.ignore) ? node.ignore.filter(isString) : []
+  );
+  const isFinal = node.end !== void 0;
+  const out = [];
+  for (const [event, decl] of Object.entries(region.events)) {
+    if (routed.has(event)) continue;
+    const scope = scopeList(isRecord(decl) ? decl.scope : void 0);
+    const broadcast = scope.some((s) => s !== "edges");
+    const live = scope.some((s) => s === "all" || s === group);
+    if (ignored.has(event) || broadcast && (!live || isFinal)) {
+      out.push(event);
+    }
+  }
+  return out;
+};
+var lowerRegion = (taskId, region, defects) => {
+  const states = {};
+  const refusals = {};
+  for (const [group, nodes] of Object.entries(region.states)) {
+    const lowered = {};
+    for (const [name, node] of Object.entries(nodes)) {
+      if (!isRecord(node)) {
+        defects.push(`task "${taskId}": state "${name}" is not an object`);
+        continue;
+      }
+      const on = {};
+      if (isRecord(node.on)) {
+        for (const [event, edge] of Object.entries(node.on)) {
+          const low = lowerEdge(edge);
+          if (low === void 0) {
+            defects.push(
+              `task "${taskId}": "${name}.${event}" delegates its target to a cell \u2014 a lane region routes to targets it DECLARES, because nothing here runs a cell to pick one`
+            );
+            continue;
+          }
+          on[event] = low;
+        }
+      }
+      const refused = refusalsAt(region, group, node, new Set(Object.keys(on)));
+      if (refused.length > 0) refusals[name] = refused;
+      lowered[name] = {
+        ...node.initial === true ? { initial: true } : {},
+        ...Object.keys(on).length > 0 ? { on } : {},
+        ...node.end === true ? { end: true } : node.end === "error" ? { end: "error" } : {}
+      };
+    }
+    states[group] = lowered;
+  }
+  const events = {};
+  for (const [name, decl] of Object.entries(region.events)) {
+    const from = isRecord(decl) ? decl.from : void 0;
+    events[name] = {
+      scope: "edges",
+      ...from === void 0 ? {} : { from }
+    };
+  }
+  return {
+    events,
+    states,
+    ...Object.keys(refusals).length > 0 ? { refusals } : {}
+  };
+};
+var LaneShapeError = class extends Error {
+  constructor(defects) {
+    super(
+      `@demlik/tea: this lane does not hold together \u2014
+` + defects.map((d) => `  \u2022 ${d}`).join("\n")
+    );
+    this.defects = defects;
+  }
+  defects;
+  name = "LaneShapeError";
+  _tag = "LaneShapeError";
+};
+function defineLane(spec) {
+  const defects = [];
+  const phases = [];
+  const charts = {};
+  const context = {};
+  if (spec.terminals.complete === spec.terminals.tripped) {
+    defects.push(
+      `both terminals are "${spec.terminals.complete}" \u2014 a lane that ended cannot say which ending it reached`
+    );
+  }
+  for (const [phaseName, tasks] of Object.entries(spec.phases)) {
+    const ids = [];
+    for (const [taskId, region] of Object.entries(tasks)) {
+      ids.push(taskId);
+      const chart = lowerRegion(taskId, region, defects);
+      charts[taskId] = chart;
+      const nodes = [...statesOf(chart).values()];
+      const initials = nodes.filter((node) => node.initial === true).length;
+      if (initials === 0) {
+        defects.push(
+          `task "${taskId}": its chart marks no state \`initial: true\` \u2014 the fold has no zero to start from`
+        );
+      }
+      if (initials > 1) {
+        defects.push(
+          `task "${taskId}": its chart marks ${initials} states \`initial: true\` \u2014 a fold has one zero, and which one it picks would be an accident of key order`
+        );
+      }
+      if (!nodes.some((node) => node.end !== void 0)) {
+        defects.push(
+          `task "${taskId}": its chart declares no final \u2014 phase "${phaseName}" could never complete, so the lane could never advance`
+        );
+      }
+      context[taskId] = {
+        maxRetries: spec.retries?.[taskId] ?? RETRY_BUDGET,
+        extras: spec.extras?.[taskId] ?? {}
+      };
+    }
+    phases.push({ name: phaseName, tasks: ids });
+  }
+  if (phases.length === 0) defects.push("the lane declares no phase");
+  if (defects.length > 0) throw new LaneShapeError(defects);
+  return {
+    ...spec.id === void 0 ? {} : { id: spec.id },
+    ...spec.trigger === void 0 ? {} : { trigger: spec.trigger },
+    phases,
+    terminals: spec.terminals,
+    charts,
+    context,
+    spec
+  };
+}
+var finalsOf = (chart, want) => {
+  const out = [];
+  for (const [name, node] of statesOf(chart)) {
+    if (endPolarityOf(node) === want) out.push(name);
+  }
+  return out;
+};
+function laneShape(lane) {
+  const phases = lane.phases.map((phase, index) => ({
+    name: phase.name,
+    index,
+    tasks: phase.tasks,
+    // The `onDone` chain, as a reader sees it: every phase but the last hands
+    // off to the next one, and the last hands off to the lane's own ending.
+    next: lane.phases[index + 1]?.name ?? lane.terminals.complete
+  }));
+  const tasks = [];
+  const cannotTrip = [];
+  for (const phase of phases) {
+    for (const taskId of phase.tasks) {
+      const chart = lane.charts[taskId];
+      if (chart === void 0) continue;
+      const errorFinals = finalsOf(chart, "error");
+      if (errorFinals.length === 0) cannotTrip.push(taskId);
+      let initial = "";
+      for (const [name, node] of statesOf(chart)) {
+        if (node.initial === true && initial === "") initial = name;
+      }
+      tasks.push({
+        id: taskId,
+        phase: phase.name,
+        phaseIndex: phase.index,
+        initial,
+        maxRetries: lane.context[taskId]?.maxRetries ?? RETRY_BUDGET,
+        successFinals: finalsOf(chart, true),
+        errorFinals,
+        siblings: phase.tasks.filter((other) => other !== taskId)
+      });
+    }
+  }
+  return {
+    ...lane.id === void 0 ? {} : { id: lane.id },
+    ...lane.trigger === void 0 ? {} : { trigger: lane.trigger },
+    phases,
+    tasks,
+    terminals: lane.terminals,
+    cannotTrip
+  };
+}
+
+// src/chart/lane/run.ts
+var isForeign = (event) => typeof event === "object" && event !== null && "foreign" in event && event.foreign === true;
+var DOT = "a dispatch key is the task id, a dot, then the event name \u2014 and every reader splits it at the FIRST dot, so a dot here makes two different messages one key";
+var bare = (taskId, key) => key.startsWith(`${taskId}.`) ? key.slice(taskId.length + 1) : key;
+var carryWas = (leaf, was) => {
+  if (was !== void 0) return { ...leaf, was };
+  const { was: _dropped, ...rest } = leaf;
+  return rest;
+};
+function runLane(lane, hands) {
+  const byTask = hands;
+  const defects = [];
+  const tables = /* @__PURE__ */ new Map();
+  const boots = /* @__PURE__ */ new Map();
+  const resumes = /* @__PURE__ */ new Map();
+  for (const phase of lane.phases) {
+    for (const taskId of phase.tasks) {
+      const region = lane.spec.phases[phase.name]?.[taskId];
+      const hand = byTask[taskId];
+      const chart = lane.charts[taskId];
+      if (region === void 0 || hand === void 0 || chart === void 0) {
+        defects.push(
+          `task "${taskId}": the lane declares it but ${region === void 0 ? "its spec holds no chart" : chart === void 0 ? "the lane's `charts` hold none for it" : "no hand was given for it"}`
+        );
+        continue;
+      }
+      if (taskId.includes(".")) {
+        defects.push(
+          `task "${taskId}": a task id may not carry a dot \u2014 ${DOT}`
+        );
+      }
+      for (const [name, event] of Object.entries(region.events)) {
+        if (isForeign(event)) {
+          defects.push(
+            `task "${taskId}": its chart declares "${name}" foreign \u2014 a foreign event keeps its BARE name under a namespace, so a lane message carrying it addresses no region in particular`
+          );
+        }
+        if (name.includes(".")) {
+          defects.push(
+            `task "${taskId}": its chart declares the event "${name}" \u2014 an event name may not carry a dot, ${DOT}`
+          );
+        }
+      }
+      tables.set(taskId, compileTable(region, hand.parts, taskId));
+      boots.set(taskId, hand.boot);
+      const sites = /* @__PURE__ */ new Set();
+      for (const [name, node] of statesOf(chart)) {
+        for (const [event, edge] of Object.entries(node.on ?? {})) {
+          if ("resume" in edge) sites.add(`${name}.${event}`);
+        }
+      }
+      resumes.set(taskId, sites);
+    }
+  }
+  if (defects.length > 0) throw new LaneShapeError(defects);
+  const standingOf = (regions) => laneTerminalReached(phaseStandings(lane, regions), lane.terminals) ?? "running";
+  const budgetOf = (taskId) => lane.context[taskId]?.maxRetries ?? RETRY_BUDGET;
+  const check = (regions, origin) => {
+    const bad = [];
+    for (const taskId of Object.keys(regions)) {
+      if (!boots.has(taskId)) {
+        bad.push(
+          `${origin}: it names task "${taskId}", which this lane does not run \u2014 a state written by an older build of the lane is not a state this one can load`
+        );
+      }
+    }
+    for (const taskId of boots.keys()) {
+      const chart = lane.charts[taskId];
+      if (chart === void 0) continue;
+      const raw = regions[taskId];
+      const leaf = typeof raw === "object" && raw !== null ? raw : void 0;
+      if (leaf === void 0 || typeof leaf.type !== "string") {
+        bad.push(
+          `${origin}: it holds no leaf for task "${taskId}" \u2014 every region of the lane has to be standing somewhere`
+        );
+        continue;
+      }
+      const states = statesOf(chart);
+      if (!states.has(leaf.type)) {
+        bad.push(
+          `${origin}: task "${taskId}" stands in "${leaf.type}", which its chart does not declare`
+        );
+      }
+      if (leaf.was !== void 0 && !states.has(leaf.was)) {
+        bad.push(
+          `${origin}: task "${taskId}" carries \`was: "${leaf.was}"\`, which its chart does not declare \u2014 a resume would walk it to a state that does not exist`
+        );
+      }
+      const budget = budgetOf(taskId);
+      if (typeof leaf.maxRetries === "number" && leaf.maxRetries !== budget) {
+        bad.push(
+          `task "${taskId}": its \`maxRetries\` is ${leaf.maxRetries} and the lane's budget for it is ${budget} \u2014 the lane's \`retries\` is the one source of that number (\`lane.context\`, which \`foldLane\` reads), so a run carrying a second one reports a different task than the one it ran`
+        );
+      }
+    }
+    return bad;
+  };
+  const init = (loaded) => {
+    if (loaded !== null) {
+      const bad2 = check(
+        loaded.regions ?? {},
+        "this lane cannot resume the state it was handed"
+      );
+      if (bad2.length > 0) throw new LaneShapeError(bad2);
+      return [
+        { regions: loaded.regions, lane: standingOf(loaded.regions) },
+        []
+      ];
+    }
+    const regions = {};
+    for (const [taskId, boot] of boots) regions[taskId] = boot();
+    const bad = check(regions, "this lane cannot boot");
+    if (bad.length > 0) throw new LaneShapeError(bad);
+    return [{ regions, lane: standingOf(regions) }, []];
+  };
+  const update = {};
+  for (const [taskId, table] of tables) {
+    const chart = lane.charts[taskId];
+    const resumeSites = resumes.get(taskId) ?? /* @__PURE__ */ new Set();
+    if (chart === void 0) continue;
+    for (const event of Object.keys(chart.events)) {
+      update[`${taskId}.${event}`] = (state, msg) => {
+        const leaf = state.regions[taskId];
+        const cell = leaf === void 0 ? void 0 : table[leaf.type]?.[msg.type];
+        if (leaf === void 0 || cell === void 0) {
+          throw new LaneShapeError([
+            `task "${taskId}": no cell for "${msg.type}" in state "${leaf?.type ?? "<none>"}"`
+          ]);
+        }
+        const [moved, cmds] = cell(leaf, msg);
+        const next = resumeSites.has(`${leaf.type}.${bare(taskId, msg.type)}`) ? carryWas(moved, leaf.was) : moved;
+        const regions = { ...state.regions, [taskId]: next };
+        return [
+          { regions, lane: standingOf(regions) },
+          // the cmds leave wearing their task, under the namespace the replies
+          // will come back in — BESIDE the payload, never over it.
+          cmds.map((cmd) => ({
+            ...cmd,
+            lane: { task: taskId },
+            type: `${taskId}.${cmd.type}`
+          }))
+        ];
+      };
+    }
+  }
+  return { init, update };
+}
+
+// src/chart/lane/view.ts
+var draw = (chart, current, walked) => drawTask(chart, { current, walked });
+function declaresEdge(chart, from, event) {
+  if (chart === void 0) return true;
+  return statesOf(chart).get(from)?.on?.[bareEvent(event)] !== void 0;
+}
+function parksHere(chart, state) {
+  if (chart === void 0) return false;
+  const on = statesOf(chart).get(state)?.on ?? {};
+  return Object.values(on).some(
+    (edge) => edge !== void 0 && "resume" in edge
+  );
+}
+var NO_DISPATCH = {
+  answerable: false,
+  question: "dispatch",
+  why: "this lane is a workflow document and its event log \u2014 the code bodies that would run an edge do not exist here, so no control can be sent. The log is the only thing that moves it."
+};
+var NO_CLOCK = {
+  answerable: false,
+  question: "clock",
+  why: "a recorded tape carries the ORDER of the msgs and no wall-clock \u2014 an events log stamps every line, a running machine does not"
+};
+var NO_RETRIES = {
+  answerable: false,
+  question: "retries",
+  why: "this region's own state carries no `retries` \u2014 the retry budget is a fact of the state a chart chose to keep, and this one keeps none"
+};
+var noSample = (event) => ({
+  answerable: false,
+  question: "dispatch",
+  why: `no sample for \`${event}\`'s payload \u2014 \`ty<T>()\` is \`{}\` at runtime, so the shape cannot be derived and the msg cannot be built`
+});
+function replayFeed(lane, entries) {
+  const steps = timeline(lane, entries);
+  return {
+    kind: "replay",
+    lane,
+    total: entries.length,
+    leavesAt: (n) => foldLane(lane, entries.slice(0, n)),
+    // NEVER REFUSED, and that is a property of this source rather than of this
+    // log: `foldLane` throws `UnreplayableLogError` on a line the chart routes
+    // nowhere, so a log holding a refused msg does not produce a lane view at
+    // all. A recorded TAPE is the opposite — a click that no-ops is a msg like
+    // any other — which is where the mark earns its keep.
+    steps: steps.map(({ at: _at, ...rest }) => ({ ...rest, refused: false })),
+    clock: steps.map((s) => s.at),
+    budget: (task, leaves) => {
+      const leaf = leaves[task];
+      return leaf === void 0 ? NO_RETRIES : { retries: leaf.retries, maxRetries: leaf.maxRetries };
+    },
+    // No `optsFor`: a document carries no guard bodies and no payload samples,
+    // and the previews degrade to exactly that.
+    send: () => NO_DISPATCH,
+    noDispatch: NO_DISPATCH
+  };
+}
+var numberAt = (leaf, key) => typeof leaf[key] === "number" ? leaf[key] : void 0;
+function liveFeed(lane, input) {
+  const prefixes = [];
+  for (let n = 0; n <= input.msgs.length; n += 1) {
+    prefixes.push(input.regionsAt(n));
+  }
+  const tasks = Object.keys(lane.charts);
+  const address = (type) => {
+    for (const task of tasks) {
+      if (type.startsWith(`${task}.`)) {
+        return { task, event: type.slice(task.length + 1) };
+      }
+    }
+    return void 0;
+  };
+  const carriesRetries = /* @__PURE__ */ new Set();
+  for (const [task, leaf] of Object.entries(prefixes[0] ?? {})) {
+    if (numberAt(leaf, "retries") !== void 0) carriesRetries.add(task);
+  }
+  const steps = [];
+  for (const [index, msg] of input.msgs.entries()) {
+    const at = address(msg.type);
+    const chart = at === void 0 ? void 0 : lane.charts[at.task];
+    const before = at === void 0 ? void 0 : prefixes[index]?.[at.task];
+    const after = at === void 0 ? void 0 : prefixes[index + 1]?.[at.task];
+    if (at === void 0 || chart === void 0) continue;
+    if (before === void 0 || after === void 0) continue;
+    steps.push({
+      index,
+      task: at.task,
+      event: at.event,
+      from: before.type,
+      to: after.type,
+      edge: walkedEdgeKey(chart, before.type, at.event, after.type),
+      refused: !declaresEdge(chart, before.type, at.event)
+    });
+  }
+  const leavesAt = (n) => {
+    const regions = prefixes[Math.max(0, Math.min(n, prefixes.length - 1))] ?? {};
+    const out = {};
+    for (const [task, leaf] of Object.entries(regions)) {
+      out[task] = {
+        // THE REGION'S OWN CTX, CARRIED. `TaskState` names the four fields the
+        // FOLD needs, and a running region is a whole state: the guards a live
+        // preview evaluates are `(state, msg) => …` over that state, so a leaf
+        // narrowed to its four bookkeeping fields makes every guard read
+        // `undefined` and answer with its `otherwise` arm. The extra keys are
+        // invisible to a `TaskState` reader and exactly what a guard came for.
+        ...leaf,
+        type: leaf.type,
+        retries: numberAt(leaf, "retries") ?? 0,
+        maxRetries: numberAt(leaf, "maxRetries") ?? lane.context[task]?.maxRetries ?? RETRY_BUDGET,
+        ...typeof leaf.was === "string" ? { was: leaf.was } : {}
+      };
+    }
+    return out;
+  };
+  return {
+    kind: "live",
+    lane,
+    total: input.msgs.length,
+    leavesAt,
+    steps,
+    clock: NO_CLOCK,
+    budget: (task, leaves) => {
+      const leaf = leaves[task];
+      if (leaf === void 0 || !carriesRetries.has(task)) return NO_RETRIES;
+      return { retries: leaf.retries, maxRetries: leaf.maxRetries };
+    },
+    ...input.optsFor === void 0 ? {} : { optsFor: input.optsFor },
+    // The code bodies exist, so the only thing that can stop a click is a
+    // payload nobody could derive.
+    send: (task, preview) => preview.msg === void 0 ? noSample(preview.event) : { ...preview.msg, type: `${task}.${preview.event}` }
+  };
+}
+function laneView(feed, cursor, title) {
+  const total = feed.total;
+  const at = Math.max(0, Math.min(cursor, total));
+  const leaves = feed.leavesAt(at);
+  const seen = feed.steps.filter((s) => s.index < at);
+  const inspection = inspectLaneStates(feed.lane, leaves, feed.optsFor);
+  const lastRan = inspection.phases.reduce(
+    (last, p, i) => p.standing === "waiting" ? last : i,
+    -1
+  );
+  const endsAt = inspection.terminal === null ? -1 : lastRan;
+  const phases = inspection.phases.map((phase, index) => {
+    const tasks = phase.tasks.map((task) => {
+      const chart = feed.lane.charts[task.task];
+      const walked = walkedEdges(seen.filter((s) => s.task === task.task));
+      return {
+        task: task.task,
+        phase: task.phase,
+        state: task.state,
+        endPolarity: task.endPolarity,
+        ...task.was === void 0 || !parksHere(chart, task.state) ? {} : { was: task.was },
+        waitingOn: task.waitingOn,
+        stuck: task.stuck,
+        moved: chart === void 0 ? true : task.state !== initialOf(chart),
+        budget: feed.budget(task.task, leaves),
+        controls: task.events.map(
+          (preview) => control(feed, task.task, preview)
+        ),
+        diagram: chart === void 0 ? "" : draw(chart, task.state, walked)
+      };
+    });
+    return {
+      name: phase.name,
+      index: phase.index,
+      standing: phase.standing,
+      tripped: phase.tripped,
+      tasks,
+      expanded: expandedIn(phase.standing, tasks, index === endsAt)
+    };
+  });
+  const phaseOf = (task) => phases.find((p) => p.tasks.some((t) => t.task === task))?.name ?? "";
+  return {
+    source: feed.kind,
+    title: title ?? feed.lane.id ?? "lane",
+    status: inspection.status,
+    terminal: inspection.terminal,
+    activePhase: inspection.activePhase,
+    tripped: inspection.tripped,
+    stuck: inspection.stuck.map((s) => ({
+      task: s.task,
+      phase: phaseOf(s.task),
+      reason: s.reason
+    })),
+    phases,
+    steps: seen,
+    clock: feed.clock,
+    cursor: at,
+    total,
+    scrubbed: at < total,
+    ...feed.noDispatch === void 0 ? {} : { noDispatch: feed.noDispatch }
+  };
+}
+function expandedIn(standing, tasks, ending) {
+  if (standing === "tripped") {
+    return tasks.filter((t) => t.endPolarity === "error").map((t) => t.task);
+  }
+  if (standing !== "active" && !ending) return [];
+  const moved = tasks.filter((t) => t.moved).map((t) => t.task);
+  if (moved.length > 0) return moved;
+  const first = tasks[0];
+  return first === void 0 ? [] : [first.task];
+}
+function control(feed, task, preview) {
+  const refused = preview.status === "refused";
+  return {
+    task,
+    event: preview.event,
+    kind: refused ? preview.reason?.kind ?? "undeclared" : "legal",
+    refused,
+    ...preview.why === void 0 ? {} : { why: preview.why },
+    outcome: outcomeOf(preview),
+    send: refused ? NO_DISPATCH_REFUSED : feed.send(task, preview)
+  };
+}
+var NO_DISPATCH_REFUSED = {
+  answerable: false,
+  question: "dispatch",
+  why: "this event is refused at this state \u2014 see the refusal for which mechanism refused it"
+};
+function guardUnknownLine(why) {
+  switch (why) {
+    case "no-guard-bag":
+      return "cannot say which \u2014 this lane came from a workflow document, so the guard bodies that would decide do not exist here";
+    case "no-implementation":
+      return "cannot say which \u2014 no implementation was supplied for this guard";
+    case "no-sample":
+      return "cannot say which \u2014 the guard reads the message payload and no sample was given for this event";
+    default:
+      return `cannot say which \u2014 evaluating the guard threw (${why})`;
+  }
+}
+function outcomeOf(v) {
+  const cmds = v.cmds.length > 0 ? ` / ${v.cmds.join(", ")}` : "";
+  if (v.guard !== void 0) {
+    return v.guard.branch === "unknown" ? `${v.targets.join(" | ")} \u2014 ${guardUnknownLine(v.guard.why ?? "")}` : `\u2192 ${v.guard.target} [${v.guard.branch === "then" ? "" : "!"}${v.guard.guard}]${cmds}`;
+  }
+  if (v.resolved !== void 0) return `\u2192 ${v.resolved}${cmds}`;
+  return `${v.targets.join(" | ")}${cmds}`;
+}
+
+export { LaneShapeError, defineLane, inspectLane, inspectLaneStates, laneShape, laneView, liveFeed, replayFeed, runLane };
+//# sourceMappingURL=chunk-ZCL7SCBK.js.map
+//# sourceMappingURL=chunk-ZCL7SCBK.js.map