agentflow-core 0.8.0 → 0.8.1

package/dist/index.js

@@ -2,6 +2,7 @@ import {
   auditProcesses,
   createGraphBuilder,
   createTraceStore,
+  discoverAllProcessConfigs,
   discoverProcessConfig,
   findWaitingOn,
   formatAuditReport,
@@ -23,11 +24,11 @@ import {
   stitchTrace,
   toAsciiTree,
   toTimeline
-} from "./chunk-6X5HU5LB.js";
+} from "./chunk-NVFWBTAZ.js";
 import {
   graphToJson,
   loadGraph
-} from "./chunk-DY7YHFIB.js";
+} from "./chunk-BYWLDTZK.js";
 
 // src/process-mining.ts
 function getPathSignature(graph) {
@@ -93,7 +94,7 @@ function discoverProcess(graphs) {
     steps: [...steps].sort(),
     transitions,
     totalGraphs: graphs.length,
-    agentId: graphs[0].agentId
+    agentId: graphs[0]?.agentId ?? ""
   };
 }
 function findVariants(graphs) {
@@ -125,13 +126,13 @@ function findVariants(graphs) {
 }
 function percentile(sorted, p) {
   if (sorted.length === 0) return 0;
-  if (sorted.length === 1) return sorted[0];
+  if (sorted.length === 1) return sorted[0] ?? 0;
   const index = p / 100 * (sorted.length - 1);
   const lower = Math.floor(index);
   const upper = Math.ceil(index);
-  if (lower === upper) return sorted[lower];
+  if (lower === upper) return sorted[lower] ?? 0;
   const weight = index - lower;
-  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+  return (sorted[lower] ?? 0) * (1 - weight) + (sorted[upper] ?? 0) * weight;
 }
 function getBottlenecks(graphs) {
   if (graphs.length === 0) return [];
@@ -158,8 +159,8 @@ function getBottlenecks(graphs) {
         median: percentile(sorted, 50),
         p95: percentile(sorted, 95),
         p99: percentile(sorted, 99),
-        min: sorted[0],
-        max: sorted[sorted.length - 1]
+        min: sorted[0] ?? 0,
+        max: sorted[sorted.length - 1] ?? 0
       },
       percentOfGraphs: sorted.length / total * 100
     });
@@ -342,6 +343,256 @@ function createEventEmitter(config) {
   };
 }
 
+// src/guards.ts
+function explainMessage(explanation) {
+  const sourceLabel = explanation.source === "static" ? "static config" : explanation.source === "soma-policy" ? `soma-policy${explanation.evidence ? ` (${explanation.evidence})` : ""}` : explanation.source === "assertion" ? "assertion" : "adaptive";
+  return `This run was stopped because ${explanation.rule} reached ${explanation.actual}, which exceeds the limit of ${explanation.threshold}. Source: ${sourceLabel}.`;
+}
+var DEFAULT_TIMEOUTS = {
+  tool: 3e4,
+  // 30s
+  agent: 3e5,
+  // 5m
+  subagent: 3e5,
+  // 5m
+  wait: 6e5,
+  // 10m
+  decision: 3e4,
+  // 30s
+  custom: 3e4
+  // 30s
+};
+function checkGuards(graph, config) {
+  const violations = [];
+  const now = Date.now();
+  const timeouts = { ...DEFAULT_TIMEOUTS, ...config?.timeouts };
+  const maxReasoningSteps = config?.maxReasoningSteps ?? 25;
+  const maxDepth = config?.maxDepth ?? 10;
+  const maxAgentSpawns = config?.maxAgentSpawns ?? 50;
+  for (const node of graph.nodes.values()) {
+    if (node.status === "running" && node.endTime === null) {
+      const timeoutThreshold = timeouts[node.type];
+      const elapsed = now - node.startTime;
+      if (elapsed > timeoutThreshold) {
+        const explanation = {
+          rule: "timeout",
+          threshold: timeoutThreshold,
+          actual: elapsed,
+          source: "static"
+        };
+        violations.push({
+          type: "timeout",
+          nodeId: node.id,
+          message: explainMessage(explanation),
+          timestamp: now,
+          explanation
+        });
+      }
+    }
+  }
+  const depth = getDepth(graph);
+  if (depth > maxDepth) {
+    const explanation = {
+      rule: "max-depth",
+      threshold: maxDepth,
+      actual: depth,
+      source: "static"
+    };
+    violations.push({
+      type: "spawn-explosion",
+      nodeId: graph.rootNodeId,
+      message: explainMessage(explanation),
+      timestamp: now,
+      explanation
+    });
+  }
+  let agentCount = 0;
+  for (const node of graph.nodes.values()) {
+    if (node.type === "agent" || node.type === "subagent") {
+      agentCount++;
+    }
+  }
+  if (agentCount > maxAgentSpawns) {
+    const explanation = {
+      rule: "max-agent-spawns",
+      threshold: maxAgentSpawns,
+      actual: agentCount,
+      source: "static"
+    };
+    violations.push({
+      type: "spawn-explosion",
+      nodeId: graph.rootNodeId,
+      message: explainMessage(explanation),
+      timestamp: now,
+      explanation
+    });
+  }
+  violations.push(...detectReasoningLoops(graph, maxReasoningSteps, now));
+  if (config?.policySource) {
+    violations.push(
+      ...checkPolicyViolations(graph, config.policySource, config.policyThresholds, now)
+    );
+  }
+  return violations;
+}
+function detectReasoningLoops(graph, maxSteps, timestamp) {
+  const violations = [];
+  const reported = /* @__PURE__ */ new Set();
+  function walk(nodeId, consecutiveCount, consecutiveType) {
+    const node = getNode(graph, nodeId);
+    if (!node) return;
+    let newCount;
+    let newType;
+    if (node.type === consecutiveType) {
+      newCount = consecutiveCount + 1;
+      newType = node.type;
+    } else {
+      newCount = 1;
+      newType = node.type;
+    }
+    if (newCount > maxSteps && !reported.has(newType)) {
+      reported.add(newType);
+      const explanation = {
+        rule: "max-reasoning-steps",
+        threshold: maxSteps,
+        actual: newCount,
+        source: "static"
+      };
+      violations.push({
+        type: "reasoning-loop",
+        nodeId: node.id,
+        message: explainMessage(explanation),
+        timestamp,
+        explanation
+      });
+    }
+    const children = getChildren(graph, nodeId);
+    for (const child of children) {
+      walk(child.id, newCount, newType);
+    }
+  }
+  walk(graph.rootNodeId, 0, null);
+  return violations;
+}
+function checkPolicyViolations(graph, policySource, thresholds, timestamp) {
+  const violations = [];
+  const maxFailureRate = thresholds?.maxFailureRate ?? 0.5;
+  const minConformance = thresholds?.minConformance ?? 0.7;
+  const failureRate = policySource.recentFailureRate(graph.agentId);
+  if (failureRate > maxFailureRate) {
+    const explanation = {
+      rule: "max-failure-rate",
+      threshold: maxFailureRate,
+      actual: failureRate,
+      source: "soma-policy"
+    };
+    violations.push({
+      type: "high-failure-rate",
+      nodeId: graph.rootNodeId,
+      message: explainMessage(explanation),
+      timestamp,
+      explanation
+    });
+  }
+  const conformanceScore = policySource.lastConformanceScore(graph.agentId);
+  if (conformanceScore !== null && conformanceScore < minConformance) {
+    const explanation = {
+      rule: "min-conformance",
+      threshold: minConformance,
+      actual: conformanceScore,
+      source: "soma-policy"
+    };
+    violations.push({
+      type: "conformance-drift",
+      nodeId: graph.rootNodeId,
+      message: explainMessage(explanation),
+      timestamp,
+      explanation
+    });
+  }
+  for (const node of graph.nodes.values()) {
+    if (node.status === "running" && policySource.isKnownBottleneck(node.name)) {
+      const explanation = {
+        rule: "known-bottleneck",
+        threshold: "flagged",
+        actual: "running",
+        source: "soma-policy"
+      };
+      violations.push({
+        type: "known-bottleneck",
+        nodeId: node.id,
+        message: explainMessage(explanation),
+        timestamp,
+        explanation
+      });
+    }
+  }
+  return violations;
+}
+function withGuards(builder, config) {
+  const logger = config?.logger ?? ((msg) => console.warn(`[AgentFlow Guard] ${msg}`));
+  const onViolation = config?.onViolation ?? "warn";
+  function handleViolations(violations) {
+    if (violations.length === 0) return;
+    for (const violation of violations) {
+      const message = `Guard violation: ${violation.message}`;
+      switch (onViolation) {
+        case "warn":
+          logger(message);
+          break;
+        case "error":
+          logger(message);
+          builder.pushEvent({
+            eventType: "custom",
+            nodeId: violation.nodeId,
+            data: {
+              guardViolation: violation.type,
+              message: violation.message,
+              severity: "error"
+            }
+          });
+          break;
+        case "abort":
+          throw new Error(`AgentFlow guard violation: ${violation.message}`);
+        default:
+          logger(message);
+      }
+    }
+  }
+  return {
+    get graphId() {
+      return builder.graphId;
+    },
+    get traceContext() {
+      return builder.traceContext;
+    },
+    startNode: (opts) => builder.startNode(opts),
+    endNode: (nodeId, status) => {
+      builder.endNode(nodeId, status);
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+    },
+    failNode: (nodeId, error) => {
+      builder.failNode(nodeId, error);
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+    },
+    addEdge: (from, to, type) => builder.addEdge(from, to, type),
+    pushEvent: (event) => builder.pushEvent(event),
+    updateState: (nodeId, state) => builder.updateState(nodeId, state),
+    withParent: (parentId, fn) => builder.withParent(parentId, fn),
+    getSnapshot: () => builder.getSnapshot(),
+    build: () => {
+      const snapshot = builder.getSnapshot();
+      const violations = checkGuards(snapshot, config);
+      handleViolations(violations);
+      return builder.build();
+    }
+  };
+}
+
 // src/prompt-builder.ts
 var ROLE = "You are analyzing execution data for an AI agent system. Provide clear, actionable analysis based on the data below.";
 function fmtDuration(ms) {
@@ -672,201 +923,6 @@ function createInsightEngine(store, analysisFn, config) {
   };
 }
 
-// src/guards.ts
-var DEFAULT_TIMEOUTS = {
-  tool: 3e4,
-  // 30s
-  agent: 3e5,
-  // 5m
-  subagent: 3e5,
-  // 5m
-  wait: 6e5,
-  // 10m
-  decision: 3e4,
-  // 30s
-  custom: 3e4
-  // 30s
-};
-function checkGuards(graph, config) {
-  const violations = [];
-  const now = Date.now();
-  const timeouts = { ...DEFAULT_TIMEOUTS, ...config?.timeouts };
-  const maxReasoningSteps = config?.maxReasoningSteps ?? 25;
-  const maxDepth = config?.maxDepth ?? 10;
-  const maxAgentSpawns = config?.maxAgentSpawns ?? 50;
-  for (const node of graph.nodes.values()) {
-    if (node.status === "running" && node.endTime === null) {
-      const timeoutThreshold = timeouts[node.type];
-      const elapsed = now - node.startTime;
-      if (elapsed > timeoutThreshold) {
-        violations.push({
-          type: "timeout",
-          nodeId: node.id,
-          message: `Node ${node.id} (${node.type}: ${node.name}) has been running for ${elapsed}ms, exceeding timeout of ${timeoutThreshold}ms`,
-          timestamp: now
-        });
-      }
-    }
-  }
-  const depth = getDepth(graph);
-  if (depth > maxDepth) {
-    violations.push({
-      type: "spawn-explosion",
-      nodeId: graph.rootNodeId,
-      message: `Graph depth ${depth} exceeds maximum depth of ${maxDepth}`,
-      timestamp: now
-    });
-  }
-  let agentCount = 0;
-  for (const node of graph.nodes.values()) {
-    if (node.type === "agent" || node.type === "subagent") {
-      agentCount++;
-    }
-  }
-  if (agentCount > maxAgentSpawns) {
-    violations.push({
-      type: "spawn-explosion",
-      nodeId: graph.rootNodeId,
-      message: `Total agent/subagent count ${agentCount} exceeds maximum of ${maxAgentSpawns}`,
-      timestamp: now
-    });
-  }
-  violations.push(...detectReasoningLoops(graph, maxReasoningSteps, now));
-  if (config?.policySource) {
-    violations.push(...checkPolicyViolations(graph, config.policySource, config.policyThresholds, now));
-  }
-  return violations;
-}
-function detectReasoningLoops(graph, maxSteps, timestamp) {
-  const violations = [];
-  const reported = /* @__PURE__ */ new Set();
-  function walk(nodeId, consecutiveCount, consecutiveType) {
-    const node = getNode(graph, nodeId);
-    if (!node) return;
-    let newCount;
-    let newType;
-    if (node.type === consecutiveType) {
-      newCount = consecutiveCount + 1;
-      newType = node.type;
-    } else {
-      newCount = 1;
-      newType = node.type;
-    }
-    if (newCount > maxSteps && !reported.has(newType)) {
-      reported.add(newType);
-      violations.push({
-        type: "reasoning-loop",
-        nodeId: node.id,
-        message: `Detected ${newCount} consecutive ${newType} nodes along path to ${node.name}`,
-        timestamp
-      });
-    }
-    const children = getChildren(graph, nodeId);
-    for (const child of children) {
-      walk(child.id, newCount, newType);
-    }
-  }
-  walk(graph.rootNodeId, 0, null);
-  return violations;
-}
-function checkPolicyViolations(graph, policySource, thresholds, timestamp) {
-  const violations = [];
-  const maxFailureRate = thresholds?.maxFailureRate ?? 0.5;
-  const minConformance = thresholds?.minConformance ?? 0.7;
-  const failureRate = policySource.recentFailureRate(graph.agentId);
-  if (failureRate > maxFailureRate) {
-    violations.push({
-      type: "high-failure-rate",
-      nodeId: graph.rootNodeId,
-      message: `Agent ${graph.agentId} has a recent failure rate of ${(failureRate * 100).toFixed(0)}% (threshold: ${(maxFailureRate * 100).toFixed(0)}%)`,
-      timestamp
-    });
-  }
-  const conformanceScore = policySource.lastConformanceScore(graph.agentId);
-  if (conformanceScore !== null && conformanceScore < minConformance) {
-    violations.push({
-      type: "conformance-drift",
-      nodeId: graph.rootNodeId,
-      message: `Agent ${graph.agentId} conformance score ${(conformanceScore * 100).toFixed(0)}% is below threshold ${(minConformance * 100).toFixed(0)}%`,
-      timestamp
-    });
-  }
-  for (const node of graph.nodes.values()) {
-    if (node.status === "running" && policySource.isKnownBottleneck(node.name)) {
-      violations.push({
-        type: "known-bottleneck",
-        nodeId: node.id,
-        message: `Node ${node.name} (${node.type}) is a known bottleneck`,
-        timestamp
-      });
-    }
-  }
-  return violations;
-}
-function withGuards(builder, config) {
-  const logger = config?.logger ?? ((msg) => console.warn(`[AgentFlow Guard] ${msg}`));
-  const onViolation = config?.onViolation ?? "warn";
-  function handleViolations(violations) {
-    if (violations.length === 0) return;
-    for (const violation of violations) {
-      const message = `Guard violation: ${violation.message}`;
-      switch (onViolation) {
-        case "warn":
-          logger(message);
-          break;
-        case "error":
-          logger(message);
-          builder.pushEvent({
-            eventType: "custom",
-            nodeId: violation.nodeId,
-            data: {
-              guardViolation: violation.type,
-              message: violation.message,
-              severity: "error"
-            }
-          });
-          break;
-        case "abort":
-          throw new Error(`AgentFlow guard violation: ${violation.message}`);
-        default:
-          logger(message);
-      }
-    }
-  }
-  return {
-    get graphId() {
-      return builder.graphId;
-    },
-    get traceContext() {
-      return builder.traceContext;
-    },
-    startNode: (opts) => builder.startNode(opts),
-    endNode: (nodeId, status) => {
-      builder.endNode(nodeId, status);
-      const snapshot = builder.getSnapshot();
-      const violations = checkGuards(snapshot, config);
-      handleViolations(violations);
-    },
-    failNode: (nodeId, error) => {
-      builder.failNode(nodeId, error);
-      const snapshot = builder.getSnapshot();
-      const violations = checkGuards(snapshot, config);
-      handleViolations(violations);
-    },
-    addEdge: (from, to, type) => builder.addEdge(from, to, type),
-    pushEvent: (event) => builder.pushEvent(event),
-    updateState: (nodeId, state) => builder.updateState(nodeId, state),
-    withParent: (parentId, fn) => builder.withParent(parentId, fn),
-    getSnapshot: () => builder.getSnapshot(),
-    build: () => {
-      const snapshot = builder.getSnapshot();
-      const violations = checkGuards(snapshot, config);
-      handleViolations(violations);
-      return builder.build();
-    }
-  };
-}
-
 // src/json-event-writer.ts
 import { mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
@@ -980,7 +1036,8 @@ function createKnowledgeStore(config) {
     mkdirSync2(dir, { recursive: true });
   }
   function profilePath(agentId) {
-    return join2(profilesDir, `${agentId}.json`);
+    const safe = agentId.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+    return join2(profilesDir, `${safe}.json`);
   }
   function appendExecutionEvent(event) {
     const dateDir = join2(eventsDir, event.agentId, toDateDir(event.timestamp));
@@ -1105,7 +1162,7 @@ function createKnowledgeStore(config) {
             continue;
           }
           for (const file of files) {
-            const ts = Number.parseInt(file.split("-")[0], 10);
+            const ts = Number.parseInt(file.split("-")[0] ?? "", 10);
             if (!Number.isNaN(ts) && ts < options.olderThan) {
               try {
                 rmSync(join2(agentPatternDir, file));
@@ -1193,7 +1250,7 @@ function createPolicySource(store) {
       }
       for (const agentId of agentIds) {
         const profile = store.getAgentProfile(agentId);
-        if (profile && profile.knownBottlenecks.includes(nodeName)) {
+        if (profile?.knownBottlenecks.includes(nodeName)) {
           return true;
         }
       }
@@ -1209,6 +1266,118 @@ function createPolicySource(store) {
   };
 }
 
+// src/receipts.ts
+function extractTokenCost(node) {
+  const semantic = node.metadata?.semantic;
+  if (semantic?.tokenCost !== void 0 && semantic.tokenCost !== null) {
+    return semantic.tokenCost;
+  }
+  if (node.state?.tokenCost !== void 0 && node.state.tokenCost !== null) {
+    return node.state.tokenCost;
+  }
+  return null;
+}
+function extractError(node) {
+  if (node.state?.error !== void 0 && node.state.error !== null) {
+    return String(node.state.error);
+  }
+  if (node.metadata?.error !== void 0 && node.metadata.error !== null) {
+    return String(node.metadata.error);
+  }
+  return null;
+}
+function nodeDuration(node) {
+  if (node.endTime === null) return null;
+  return node.endTime - node.startTime;
+}
+function toReceipt(graph) {
+  const nodes = [...graph.nodes.values()];
+  nodes.sort((a, b) => a.startTime - b.startTime);
+  const steps = nodes.map((node) => ({
+    nodeId: node.id,
+    name: node.name,
+    type: node.type,
+    status: node.status,
+    durationMs: nodeDuration(node),
+    tokenCost: extractTokenCost(node),
+    error: extractError(node)
+  }));
+  let succeeded = 0;
+  let failed = 0;
+  const skipped = 0;
+  for (const node of nodes) {
+    if (node.status === "completed") {
+      succeeded++;
+    } else if (node.status === "failed" || node.status === "hung" || node.status === "timeout") {
+      failed++;
+    }
+  }
+  const attempted = nodes.length;
+  let totalTokenCost = null;
+  for (const step of steps) {
+    if (step.tokenCost !== null) {
+      totalTokenCost = (totalTokenCost ?? 0) + step.tokenCost;
+    }
+  }
+  const totalDurationMs = graph.endTime !== null ? graph.endTime - graph.startTime : null;
+  return {
+    runId: graph.id,
+    agentId: graph.agentId,
+    status: graph.status,
+    startTime: graph.startTime,
+    endTime: graph.endTime,
+    totalDurationMs,
+    totalTokenCost,
+    steps,
+    summary: { attempted, succeeded, failed, skipped }
+  };
+}
+function formatReceipt(receipt) {
+  const lines = [];
+  lines.push("=== Run Receipt ===");
+  lines.push(`Run:      ${receipt.runId}`);
+  lines.push(`Agent:    ${receipt.agentId}`);
+  lines.push(`Status:   ${receipt.status}`);
+  lines.push(
+    `Duration: ${receipt.totalDurationMs !== null ? `${receipt.totalDurationMs}ms` : "\u2014"}`
+  );
+  lines.push("");
+  const s = receipt.summary;
+  lines.push(
+    `Summary: ${s.attempted} attempted, ${s.succeeded} succeeded, ${s.failed} failed, ${s.skipped} skipped`
+  );
+  lines.push("");
+  const nameWidth = Math.max(4, ...receipt.steps.map((st) => st.name.length));
+  const typeWidth = Math.max(4, ...receipt.steps.map((st) => st.type.length));
+  const pad = (str, width) => str.padEnd(width);
+  const padNum = (str, width) => str.padStart(width);
+  const idxWidth = Math.max(2, String(receipt.steps.length).length);
+  const statusWidth = 9;
+  const durWidth = 10;
+  const tokWidth = 8;
+  lines.push(
+    ` ${padNum("#", idxWidth)} | ${pad("Step", nameWidth)} | ${pad("Type", typeWidth)} | ${pad("Status", statusWidth)} | ${padNum("Duration", durWidth)} | ${padNum("Tokens", tokWidth)}`
+  );
+  lines.push(
+    `${"-".repeat(idxWidth + 1)}|${"-".repeat(nameWidth + 2)}|${"-".repeat(typeWidth + 2)}|${"-".repeat(statusWidth + 2)}|${"-".repeat(durWidth + 2)}|${"-".repeat(tokWidth + 2)}`
+  );
+  for (let i = 0; i < receipt.steps.length; i++) {
+    const step = receipt.steps[i];
+    const durStr = step.durationMs !== null ? `${step.durationMs}ms` : "\u2014";
+    const tokStr = step.tokenCost !== null ? String(step.tokenCost) : "\u2014";
+    lines.push(
+      ` ${padNum(String(i + 1), idxWidth)} | ${pad(step.name, nameWidth)} | ${pad(step.type, typeWidth)} | ${pad(step.status, statusWidth)} | ${padNum(durStr, durWidth)} | ${padNum(tokStr, tokWidth)}`
+    );
+  }
+  lines.push("");
+  if (receipt.totalTokenCost !== null) {
+    lines.push(`Total token cost: ${receipt.totalTokenCost}`);
+  } else {
+    lines.push("Total token cost: no cost data");
+  }
+  return lines.join("\n");
+}
+
 // src/soma-event-writer.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join4 } from "path";
@@ -1241,11 +1410,7 @@ function formatDuration(ms) {
 function executionEventToMarkdown(event) {
   const isCompleted = event.eventType === "execution.completed";
   const subtype = isCompleted ? "completed" : "failed";
-  const tags = [
-    "agentflow/execution",
-    `agent/${event.agentId}`,
-    `status/${subtype}`
-  ];
+  const tags = ["agentflow/execution", `agent/${event.agentId}`, `status/${subtype}`];
   if (event.processContext?.isAnomaly) {
     tags.push("agentflow/anomaly");
   }
@@ -1303,10 +1468,7 @@ ${body.join("\n")}`;
 }
 function patternEventToMarkdown(event) {
   const { pattern } = event;
-  const tags = [
-    "agentflow/pattern",
-    `agent/${event.agentId}`
-  ];
+  const tags = ["agentflow/pattern", `agent/${event.agentId}`];
   const frontmatter = {
     type: "synthesis",
     subtype: "pattern-discovery",
@@ -1393,11 +1555,13 @@ export {
   createPolicySource,
   createSomaEventWriter,
   createTraceStore,
+  discoverAllProcessConfigs,
   discoverProcess,
   discoverProcessConfig,
   findVariants,
   findWaitingOn,
   formatAuditReport,
+  formatReceipt,
   getBottlenecks,
   getChildren,
   getCriticalPath,
@@ -1419,6 +1583,7 @@ export {
   startWatch,
   stitchTrace,
   toAsciiTree,
+  toReceipt,
   toTimeline,
   withGuards
 };

package/dist/{loader-LYRR6LMM.js → loader-JMFEFI3Q.js}

@@ -1,7 +1,7 @@
 import {
   graphToJson,
   loadGraph
-} from "./chunk-DY7YHFIB.js";
+} from "./chunk-BYWLDTZK.js";
 export {
   graphToJson,
   loadGraph