@demlik/tea 0.13.0 → 0.15.0

package/dist/chunk-NR7BU22N.js

@@ -1,758 +0,0 @@
-import { chartMermaid, edgeKey } from './chunk-YWIKDKHY.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-NR7BU22N.js.map
-//# sourceMappingURL=chunk-NR7BU22N.js.map