@demlik/tea 0.6.0 → 0.8.0

package/dist/chunk-5KJKJOFC.js

@@ -0,0 +1,758 @@
+import { chartMermaid, edgeKey } from './chunk-E6GEDSF4.js';
+
+// src/chart/report/draw.ts
+function drawTask(chart, opts = {}) {
+  return chartMermaid(chart, {
+    polarity: true,
+    ...opts.current === void 0 ? {} : { highlight: opts.current },
+    ...opts.walked === void 0 ? {} : { walked: opts.walked }
+  });
+}
+function walkedEdges(steps) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    counts.set(step.edge, (counts.get(step.edge) ?? 0) + 1);
+  }
+  return counts;
+}
+
+// src/chart/report/workflow.ts
+var bareEvent = (event) => {
+  const dot = event.indexOf(".");
+  return dot === -1 ? event : event.slice(dot + 1);
+};
+var WorkflowImportError = class extends Error {
+  constructor(defects) {
+    super(
+      `@demlik/tea: this workflow.json does not compile to charts \u2014
+` + defects.map((d) => `  \u2022 ${d}`).join("\n")
+    );
+    this.defects = defects;
+  }
+  defects;
+  name = "WorkflowImportError";
+  _tag = "WorkflowImportError";
+};
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var nodeType = (node) => isRecord(node) && typeof node.type === "string" ? node.type : void 0;
+var RETRY_BUDGET = 2;
+var DEFAULT_GUARD = "retries remain";
+function importRegion(taskId, region) {
+  const defects = [];
+  if (!isRecord(region) || !isRecord(region.states) || typeof region.initial !== "string") {
+    return {
+      defects: [
+        `task "${taskId}": region must carry string \`initial\` and \`states\``
+      ]
+    };
+  }
+  const states = region.states;
+  const initialState = region.initial;
+  if (states[initialState] === void 0) {
+    defects.push(
+      `task "${taskId}": initial state "${initialState}" is not in \`states\``
+    );
+  }
+  const finals = /* @__PURE__ */ new Set();
+  for (const [name, node] of Object.entries(states)) {
+    if (nodeType(node) === "final") finals.add(name);
+  }
+  const errorFinals = /* @__PURE__ */ new Set();
+  const on = {};
+  for (const [stateName, node] of Object.entries(states)) {
+    if (nodeType(node) === "history") continue;
+    const edges = {};
+    on[stateName] = edges;
+    if (!isRecord(node)) {
+      defects.push(`task "${taskId}": state "${stateName}" is not an object`);
+      continue;
+    }
+    const raw = node.on ?? {};
+    if (!isRecord(raw)) {
+      defects.push(
+        `task "${taskId}": state "${stateName}" carries a non-object \`on\``
+      );
+      continue;
+    }
+    const spelledAs = /* @__PURE__ */ new Map();
+    for (const [eventName, transition] of Object.entries(raw)) {
+      const event = bareEvent(eventName);
+      if (event === "") {
+        defects.push(
+          `task "${taskId}": state "${stateName}" listens for "${eventName}", which names no event once its namespace is stripped`
+        );
+        continue;
+      }
+      const already = spelledAs.get(event);
+      if (already !== void 0) {
+        defects.push(
+          `task "${taskId}": state "${stateName}" spells the same event twice \u2014 "${already}" and "${eventName}" are both \`${event}\`, and a state routes each event once`
+        );
+        continue;
+      }
+      spelledAs.set(event, eventName);
+      if (Array.isArray(transition)) {
+        const arms = transition.map(
+          (arm) => isRecord(arm) && typeof arm.target === "string" ? arm.target : void 0
+        );
+        const [retry, fallthrough] = arms;
+        if (transition.length !== 2 || retry === void 0 || fallthrough === void 0) {
+          defects.push(
+            `task "${taskId}": guarded "${eventName}" must be a two-arm array of \`{target}\` \u2014 [retry-while-retries-remain, else-fallthrough]`
+          );
+          continue;
+        }
+        for (const target of [retry, fallthrough]) {
+          if (states[target] === void 0) {
+            defects.push(
+              `task "${taskId}": "${eventName}" targets unknown state "${target}"`
+            );
+          }
+        }
+        if (finals.has(fallthrough)) errorFinals.add(fallthrough);
+        const head = transition[0];
+        const when = isRecord(head) && typeof head.guard === "string" ? head.guard : DEFAULT_GUARD;
+        edges[event] = { target: retry, when, otherwise: fallthrough };
+        continue;
+      }
+      if (typeof transition !== "string") {
+        defects.push(
+          `task "${taskId}": "${eventName}" is neither a target nor a guarded array`
+        );
+        continue;
+      }
+      if (states[transition] === void 0) {
+        defects.push(
+          `task "${taskId}": "${eventName}" targets unknown state "${transition}"`
+        );
+        continue;
+      }
+      edges[event] = nodeType(states[transition]) === "history" ? { resume: { fallback: initialState } } : { target: transition };
+    }
+  }
+  if (defects.length > 0) return { defects };
+  const out = {};
+  for (const [name, node] of Object.entries(states)) {
+    if (nodeType(node) === "history") continue;
+    const edges = on[name] ?? {};
+    const isFinal = finals.has(name);
+    out[name] = {
+      ...name === initialState ? { initial: true } : {},
+      ...Object.keys(edges).length > 0 ? { on: edges } : {},
+      ...isFinal ? { end: errorFinals.has(name) ? "error" : true } : {}
+    };
+  }
+  return { node: out, defects: [] };
+}
+function onDoneTargets(phaseName, onDone) {
+  const defect = `phase "${phaseName}": \`onDone\` must be a two-arm array of \`{target}\` \u2014 [{target, guard}, {target}]`;
+  if (!Array.isArray(onDone) || onDone.length !== 2) return { defect };
+  const [success, trip] = onDone.map(
+    (arm) => isRecord(arm) && typeof arm.target === "string" ? arm.target : void 0
+  );
+  return success === void 0 || trip === void 0 ? { defect } : { targets: [success, trip] };
+}
+function chartFromWorkflow(document, options = {}) {
+  const defects = [];
+  const machineDef = isRecord(document) ? document.machine : void 0;
+  if (!isRecord(machineDef) || !isRecord(machineDef.states)) {
+    throw new WorkflowImportError([
+      "document must carry a `machine.states` object"
+    ]);
+  }
+  const documentContext = isRecord(machineDef.context) ? machineDef.context : {};
+  const declaredTrigger = isRecord(document) ? document.trigger : void 0;
+  if (declaredTrigger !== void 0 && typeof declaredTrigger !== "string") {
+    defects.push(
+      "document `trigger` must be a string naming what fires this lane"
+    );
+  }
+  const machineStates = machineDef.states;
+  const charts = {};
+  const context = {};
+  const phases = [];
+  const gateTargets = /* @__PURE__ */ new Set();
+  let terminals;
+  for (const [phaseName, node] of Object.entries(machineStates)) {
+    if (nodeType(node) !== "parallel" || !isRecord(node)) continue;
+    const regions = node.states;
+    if (!isRecord(regions) || Object.keys(regions).length === 0) {
+      defects.push(
+        `phase "${phaseName}": a parallel phase must carry task regions in \`states\``
+      );
+      continue;
+    }
+    const phaseTasks = [];
+    for (const [taskId, region] of Object.entries(regions)) {
+      const imported = importRegion(taskId, region);
+      defects.push(...imported.defects);
+      if (imported.node !== void 0) {
+        const events = {};
+        for (const edges of Object.values(imported.node)) {
+          for (const event of Object.keys(edges.on ?? {})) {
+            const origin = options.from?.[event];
+            events[event] = origin === void 0 ? { scope: "edges" } : { scope: "edges", from: origin };
+          }
+        }
+        charts[taskId] = { events, states: { [phaseName]: imported.node } };
+      }
+      const ctx = documentContext[taskId];
+      const bag = isRecord(ctx) ? ctx : {};
+      const { maxRetries: rawMax, retries: _retries, ...extras } = bag;
+      context[taskId] = {
+        maxRetries: typeof rawMax === "number" ? rawMax : RETRY_BUDGET,
+        extras
+      };
+      phaseTasks.push(taskId);
+    }
+    phases.push({ name: phaseName, tasks: phaseTasks });
+    const gate = onDoneTargets(phaseName, node.onDone);
+    if (gate.defect !== void 0) defects.push(gate.defect);
+    if (gate.targets !== void 0) {
+      for (const target of gate.targets) {
+        gateTargets.add(target);
+        if (machineStates[target] === void 0) {
+          defects.push(
+            `phase "${phaseName}": \`onDone\` targets unknown machine-level state "${target}"`
+          );
+        }
+      }
+      terminals = { complete: gate.targets[0], tripped: gate.targets[1] };
+    }
+  }
+  for (const [name, node] of Object.entries(machineStates)) {
+    if (nodeType(node) === "parallel" && isRecord(node)) continue;
+    if (nodeType(node) !== "final") {
+      defects.push(
+        `machine-level state "${name}" is neither a \`parallel\` phase nor a \`final\` terminal`
+      );
+    } else if (!gateTargets.has(name)) {
+      defects.push(
+        `machine-level final "${name}" is targeted by no phase's \`onDone\` pair`
+      );
+    }
+  }
+  if (phases.length === 0)
+    defects.push("machine holds no `parallel` phase state");
+  if (defects.length > 0) throw new WorkflowImportError(defects);
+  if (terminals === void 0) {
+    throw new WorkflowImportError([
+      "no phase carried a readable `onDone` pair"
+    ]);
+  }
+  const id = isRecord(document) && typeof document.id === "string" ? document.id : void 0;
+  const lane = {
+    ...id === void 0 ? {} : { id },
+    ...typeof declaredTrigger === "string" ? { trigger: declaredTrigger } : {},
+    phases,
+    terminals,
+    charts,
+    context
+  };
+  if (options.strictFrom === true) {
+    const declared = new Set(eventAlphabet(lane));
+    const strays = Object.keys(options.from ?? {}).filter(
+      (event) => !declared.has(event)
+    );
+    if (strays.length > 0) {
+      throw new WorkflowImportError(
+        strays.map(
+          (event) => `\`from\` names "${event}", which no state in this document routes \u2014 the map is keyed by the BARE event name`
+        )
+      );
+    }
+  }
+  return lane;
+}
+function chartFromWorkflowText(text, options = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new WorkflowImportError(["the document is not JSON"]);
+  }
+  return chartFromWorkflow(parsed, options);
+}
+function statesOf(chart) {
+  const out = /* @__PURE__ */ new Map();
+  for (const group of Object.values(chart.states)) {
+    for (const [name, node] of Object.entries(group)) out.set(name, node);
+  }
+  return out;
+}
+function initialOf(chart) {
+  for (const [name, node] of statesOf(chart)) {
+    if (node.initial === true) return name;
+  }
+  throw new Error("@demlik/tea: imported chart marks no initial state");
+}
+function eventAlphabet(lane) {
+  const out = /* @__PURE__ */ new Set();
+  for (const chart of Object.values(lane.charts)) {
+    for (const event of Object.keys(chart.events)) out.add(event);
+  }
+  return [...out];
+}
+function originOf(chart, event) {
+  return chart.events[event]?.from;
+}
+function endPolarityOf(node) {
+  if (node?.end === void 0) return false;
+  return node.end;
+}
+
+// src/chart/report/fold.ts
+function walkedEdgeKey(chart, from, event, to) {
+  const declared = statesOf(chart).get(from)?.on?.[event];
+  const drawn = declared !== void 0 && "resume" in declared ? declared.resume.fallback : to;
+  return edgeKey(from, event, drawn);
+}
+var UnreplayableLogError = class extends Error {
+  constructor(defects) {
+    super(
+      `@demlik/tea: this events log does not replay against this workflow \u2014
+` + defects.map((d) => `  \u2022 ${d}`).join("\n")
+    );
+    this.defects = defects;
+  }
+  defects;
+  name = "UnreplayableLogError";
+  _tag = "UnreplayableLogError";
+};
+function parseEventsJsonl(text) {
+  const defects = [];
+  const entries = [];
+  for (const [index, line] of text.split("\n").entries()) {
+    if (line.trim() === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      defects.push(`line ${index + 1} is not JSON`);
+      continue;
+    }
+    const entry = asLogEntry(parsed);
+    if (entry === void 0) {
+      defects.push(
+        `line ${index + 1} does not carry string \`task\`/\`event\`/\`at\``
+      );
+      continue;
+    }
+    entries.push(entry);
+  }
+  if (defects.length > 0) throw new UnreplayableLogError(defects);
+  return entries;
+}
+function asLogEntry(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  if (typeof record.task !== "string" || typeof record.event !== "string" || typeof record.at !== "string") {
+    return void 0;
+  }
+  return { task: record.task, event: record.event, at: record.at };
+}
+function parseHistoryJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new UnreplayableLogError(["`lane history` output is not JSON"]);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new UnreplayableLogError([
+      "`lane history` output is not a JSON array of entries"
+    ]);
+  }
+  const entries = [];
+  for (const [index, raw] of parsed.entries()) {
+    const entry = asLogEntry(raw);
+    if (entry === void 0) {
+      throw new UnreplayableLogError([
+        `history entry ${index} does not carry string \`task\`/\`event\`/\`at\``
+      ]);
+    }
+    entries.push(entry);
+  }
+  return entries;
+}
+var unknownTaskDefects = (lane, entries) => {
+  const seen = /* @__PURE__ */ new Set();
+  const defects = [];
+  for (const entry of entries) {
+    if (lane.charts[entry.task] !== void 0 || seen.has(entry.task)) continue;
+    seen.add(entry.task);
+    defects.push(
+      `log names task "${entry.task}", which is not in this lane's machine`
+    );
+  }
+  return defects;
+};
+var chartOf = (lane, taskId) => {
+  const chart = lane.charts[taskId];
+  if (chart === void 0) {
+    throw new UnreplayableLogError([
+      `log names task "${taskId}", which is not in this lane's machine`
+    ]);
+  }
+  return chart;
+};
+function initialStates(lane) {
+  const out = {};
+  for (const [taskId, chart] of Object.entries(lane.charts)) {
+    out[taskId] = {
+      type: initialOf(chart),
+      retries: 0,
+      maxRetries: lane.context[taskId]?.maxRetries ?? RETRY_BUDGET
+    };
+  }
+  return out;
+}
+function stepTask(chart, state, event, taskId) {
+  const node = statesOf(chart).get(state.type);
+  const edge = node?.on?.[event];
+  if (edge === void 0) {
+    if (chart.refusals?.[state.type]?.includes(event) === true) return state;
+    throw new UnreplayableLogError([
+      `${taskId === void 0 ? "" : `task "${taskId}": `}state "${state.type}" holds no cell for "${event}"`
+    ]);
+  }
+  if ("resume" in edge) {
+    return { ...state, type: state.was ?? edge.resume.fallback };
+  }
+  if ("when" in edge) {
+    return state.retries < state.maxRetries ? {
+      ...state,
+      type: edge.target,
+      retries: state.retries + 1,
+      was: state.type
+    } : { ...state, type: edge.otherwise, was: state.type };
+  }
+  return { ...state, type: edge.target, was: state.type };
+}
+function foldLane(lane, entries) {
+  const unknown = unknownTaskDefects(lane, entries);
+  if (unknown.length > 0) throw new UnreplayableLogError(unknown);
+  const states = { ...initialStates(lane) };
+  for (const entry of entries) {
+    const chart = chartOf(lane, entry.task);
+    const current = states[entry.task];
+    if (current === void 0) {
+      throw new UnreplayableLogError([
+        `log names task "${entry.task}", which is not in this lane's machine`
+      ]);
+    }
+    states[entry.task] = stepTask(
+      chart,
+      current,
+      bareEvent(entry.event),
+      entry.task
+    );
+  }
+  return states;
+}
+function timeline(lane, entries) {
+  const unknown = unknownTaskDefects(lane, entries);
+  if (unknown.length > 0) throw new UnreplayableLogError(unknown);
+  const states = { ...initialStates(lane) };
+  const steps = [];
+  for (const [index, entry] of entries.entries()) {
+    const chart = chartOf(lane, entry.task);
+    const before = states[entry.task];
+    if (before === void 0) {
+      throw new UnreplayableLogError([
+        `log names task "${entry.task}", which is not in this lane's machine`
+      ]);
+    }
+    const event = bareEvent(entry.event);
+    const after = stepTask(chart, before, event, entry.task);
+    states[entry.task] = after;
+    steps.push({
+      index,
+      at: entry.at,
+      task: entry.task,
+      event: entry.event,
+      from: before.type,
+      to: after.type,
+      edge: walkedEdgeKey(chart, before.type, event, after.type)
+    });
+  }
+  return steps;
+}
+function trippedTasks(lane, states) {
+  return Object.keys(states).filter(
+    (taskId) => endPolarityOf(nodeOf(lane, taskId, states)) === "error"
+  );
+}
+function phaseStandings(lane, states) {
+  const isFinal = (taskId) => endPolarityOf(nodeOf(lane, taskId, states)) !== false;
+  const errors = trippedTasks(lane, states);
+  let stopped = false;
+  return lane.phases.map((phase, index) => {
+    const tripped = phase.tasks.filter((taskId) => errors.includes(taskId));
+    const base = { name: phase.name, index, tasks: phase.tasks, tripped };
+    if (stopped) return { ...base, standing: "waiting" };
+    if (!phase.tasks.every(isFinal)) {
+      stopped = true;
+      return { ...base, standing: "active" };
+    }
+    if (tripped.length > 0) {
+      stopped = true;
+      return { ...base, standing: "tripped" };
+    }
+    return { ...base, standing: "complete" };
+  });
+}
+function laneTerminalReached(stands, terminals) {
+  if (stands.some((stand) => stand.standing === "tripped"))
+    return terminals.tripped;
+  if (stands.some((stand) => stand.standing === "active")) return void 0;
+  return terminals.complete;
+}
+function deriveLaneStatus(lane, states) {
+  const errors = trippedTasks(lane, states);
+  const context = {};
+  for (const [taskId, state] of Object.entries(states)) {
+    context[taskId] = {
+      retries: state.retries,
+      maxRetries: state.maxRetries,
+      ...lane.context[taskId]?.extras ?? {}
+    };
+  }
+  context.errors = errors;
+  const stands = phaseStandings(lane, states);
+  const terminal = laneTerminalReached(stands, lane.terminals);
+  if (terminal !== void 0) {
+    return { stateValue: terminal, status: "done", context };
+  }
+  const active = stands.find((stand) => stand.standing === "active");
+  if (active === void 0) {
+    return { stateValue: lane.terminals.complete, status: "done", context };
+  }
+  const stateValue = {
+    [active.name]: Object.fromEntries(
+      active.tasks.map((taskId) => [taskId, states[taskId]?.type ?? "?"])
+    )
+  };
+  for (const stand of stands.slice(active.index + 1)) {
+    stateValue[stand.name] = "waiting";
+  }
+  return { stateValue, status: "active", context };
+}
+function nodeOf(lane, taskId, states) {
+  const chart = lane.charts[taskId];
+  const state = states[taskId];
+  if (chart === void 0 || state === void 0) return void 0;
+  return statesOf(chart).get(state.type);
+}
+function parseStatusJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new UnreplayableLogError(["`lane status` output is not JSON"]);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new UnreplayableLogError(["`lane status` output is not an object"]);
+  }
+  const record = parsed;
+  if (record.status !== "active" && record.status !== "done") {
+    throw new UnreplayableLogError([
+      '`lane status` output carries no `status` of "active" | "done"'
+    ]);
+  }
+  if (record.stateValue === void 0) {
+    throw new UnreplayableLogError([
+      "`lane status` output carries no `stateValue`"
+    ]);
+  }
+  return {
+    stateValue: record.stateValue,
+    status: record.status,
+    context: typeof record.context === "object" && record.context !== null ? record.context : {}
+  };
+}
+
+// src/chart/report/report.ts
+var isImportedLane = (v) => typeof v === "object" && v !== null && Array.isArray(v.phases) && typeof v.charts === "object";
+function activePhaseName(status) {
+  if (typeof status.stateValue === "string") return void 0;
+  for (const [name, value] of Object.entries(status.stateValue)) {
+    if (typeof value === "object") return name;
+  }
+  return void 0;
+}
+var listed = (events) => events.map((e) => `\`${e}\``).join(", ");
+function phrase(origin, state, events) {
+  if (origin === "cmd") {
+    return `the work \`${state}\` dispatched \u2014 ${listed(events)}`;
+  }
+  if (origin === "sub") {
+    return `the source \`${state}\` is subscribed to \u2014 ${listed(events)}`;
+  }
+  return `${origin.world}'s ${listed(events)}`;
+}
+var originKey = (origin) => typeof origin === "string" ? origin : `world:${origin.world}`;
+function waitingOn(chart, state) {
+  const node = statesOf(chart).get(state);
+  if (node?.end !== void 0) return null;
+  const events = Object.keys(node?.on ?? {});
+  if (events.length === 0) {
+    return `\`${state}\` accepts no events, and it is not a final`;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  const undeclared = [];
+  for (const event of events) {
+    const origin = originOf(chart, event);
+    if (origin === void 0) {
+      undeclared.push(event);
+      continue;
+    }
+    const key = originKey(origin);
+    const group = groups.get(key);
+    if (group === void 0) groups.set(key, { origin, events: [event] });
+    else group.events.push(event);
+  }
+  if (groups.size === 0) return `\`${state}\` accepts ${listed(events)}`;
+  const parts = [...groups.values()].map(
+    (g) => phrase(g.origin, state, g.events)
+  );
+  if (undeclared.length > 0) {
+    parts.push(`${listed(undeclared)}, from somewhere the chart does not say`);
+  }
+  return parts.join(" \xB7 ");
+}
+function retryLine(chart, state) {
+  if (state.retries <= 0) return null;
+  const budget = `${state.retries}/${state.maxRetries}`;
+  if (state.retries < state.maxRetries) return `**retries:** ${budget}`;
+  const node = statesOf(chart).get(state.type);
+  for (const [event, edge] of Object.entries(node?.on ?? {})) {
+    if ("when" in edge) {
+      return `**retries:** ${budget} \u2014 spent; one \`${event}\` from \`${edge.otherwise}\``;
+    }
+  }
+  return `**retries:** ${budget} \u2014 spent`;
+}
+function phaseLine(stand, states) {
+  const count = `${stand.tasks.length} task${stand.tasks.length === 1 ? "" : "s"}`;
+  if (stand.standing === "waiting") {
+    return `**${stand.name}:** waiting \u2014 ${count}, not started.`;
+  }
+  const leaves = stand.tasks.map(
+    (taskId) => `\`${taskId}\` = \`${states[taskId]?.type ?? "?"}\`${stand.tripped.includes(taskId) ? " **(tripped)**" : ""}`
+  ).join(", ");
+  return `**${stand.name}:** ${stand.standing} \u2014 ${count}: ${leaves}`;
+}
+function timelineTable(steps) {
+  if (steps.length === 0)
+    return "_no events yet \u2014 the lane is at its initial state._";
+  const rows = steps.map(
+    (s) => `| ${s.index + 1} | ${s.at} | \`${s.task}\` | \`${s.event}\` | \`${s.from}\` \u2192 \`${s.to}\` |`
+  );
+  return [
+    "| # | at | task | event | from \u2192 to |",
+    "|---|---|---|---|---|",
+    ...rows
+  ].join("\n");
+}
+function laneReport(input) {
+  const lane = isImportedLane(input.workflow) ? input.workflow : chartFromWorkflow(input.workflow);
+  const entries = input.entries;
+  const states = foldLane(lane, entries);
+  const status = input.status ?? deriveLaneStatus(lane, states);
+  const steps = timeline(lane, entries);
+  const title = input.title ?? lane.id ?? "lane";
+  const out = [`## ${title} \u2014 ${status.status}`, ""];
+  out.push(`**where it is:** ${describeStateValue(status.stateValue)}`);
+  if (lane.trigger !== void 0) out.push(`**fired by:** \`${lane.trigger}\``);
+  const errors = status.context.errors;
+  if (Array.isArray(errors) && errors.length > 0) {
+    out.push(
+      `**tripped:** ${errors.map((t) => `\`${String(t)}\``).join(", ")} \u2014 the lane lands on \`${lane.terminals.tripped}\``
+    );
+  }
+  out.push("");
+  const stands = phaseStandings(lane, states);
+  const named = activePhaseName(status);
+  const active = stands.find((s) => s.name === named) ?? stands.find((s) => s.standing === "active");
+  for (const stand of stands) {
+    if (stand === active) {
+      const untouched = [];
+      for (const taskId of stand.tasks) {
+        const chart = lane.charts[taskId];
+        const state = states[taskId];
+        if (chart === void 0 || state === void 0) continue;
+        if (state.type === initialOf(chart)) untouched.push(taskId);
+      }
+      if (untouched.length === stand.tasks.length) untouched.shift();
+      for (const taskId of stand.tasks) {
+        const chart = lane.charts[taskId];
+        const state = states[taskId];
+        if (chart === void 0 || state === void 0) continue;
+        if (untouched.includes(taskId)) continue;
+        const polarity = endPolarityOf(statesOf(chart).get(state.type));
+        out.push(
+          `### ${taskId} \u2014 \`${state.type}\`${polarity === "error" ? " \u2014 TRIPPED" : ""}`
+        );
+        const waiting = waitingOn(chart, state.type);
+        out.push(
+          waiting !== null ? `**waiting on:** ${waiting}` : polarity === "error" ? (
+            // The distinction `end: "error"` bought, spent where it is worth
+            // something: this task is as finished as a shipped one, and the
+            // phase it is in is going to trip the lane when its siblings
+            // finish. A report that said "final" for both would bury that.
+            `**waiting on:** nothing \u2014 this task landed on the error final \`${state.type}\`, and \`${stand.name}\` will trip the lane when its siblings finish.`
+          ) : "**waiting on:** nothing \u2014 this task is final."
+        );
+        const retries = retryLine(chart, state);
+        if (retries !== null) out.push(retries);
+        out.push("");
+        out.push("```mermaid");
+        out.push(
+          drawTask(chart, {
+            current: state.type,
+            walked: walkedEdges(steps.filter((s) => s.task === taskId))
+          })
+        );
+        out.push("```");
+        out.push("");
+      }
+      if (untouched.length > 0) {
+        const chart = lane.charts[untouched[0]];
+        const at = chart === void 0 ? "their entry state" : `\`${initialOf(chart)}\``;
+        out.push(
+          `**not started yet:** ${untouched.map((t) => `\`${t}\``).join(", ")} \u2014 still at ${at}.`
+        );
+        out.push("");
+      }
+      continue;
+    }
+    out.push(phaseLine(stand, states));
+    out.push("");
+  }
+  out.push("### timeline");
+  out.push("");
+  out.push(timelineTable(steps));
+  out.push("");
+  return {
+    markdown: `${out.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}
+`
+  };
+}
+function describeStateValue(value) {
+  if (typeof value === "string") return `\`${value}\` \u2014 the workflow is done.`;
+  const parts = [];
+  for (const [phase, leaf] of Object.entries(value)) {
+    if (typeof leaf === "string") {
+      parts.push(`\`${phase}\`: ${leaf}`);
+      continue;
+    }
+    const inner = Object.entries(leaf).map(([task, state]) => `\`${task}\` = \`${state}\``).join(", ");
+    parts.push(`\`${phase}\` \u2192 ${inner}`);
+  }
+  return parts.join(" \xB7 ");
+}
+
+export { RETRY_BUDGET, UnreplayableLogError, WorkflowImportError, bareEvent, chartFromWorkflow, chartFromWorkflowText, deriveLaneStatus, drawTask, endPolarityOf, eventAlphabet, foldLane, initialOf, initialStates, laneReport, laneTerminalReached, originOf, parseEventsJsonl, parseHistoryJson, parseStatusJson, phaseStandings, statesOf, stepTask, timeline, trippedTasks, waitingOn, walkedEdgeKey, walkedEdges };
+//# sourceMappingURL=chunk-5KJKJOFC.js.map
+//# sourceMappingURL=chunk-5KJKJOFC.js.map