footprintjs 8.1.0 → 8.3.0

package/dist/lib/runner/checkpointSanitize.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * checkpointSanitize — clone-resilience helpers for `buildPauseCheckpoint`.
+ *
+ * The pause checkpoint is detached via one `structuredClone` of the assembled
+ * checkpoint. The JSON-safe contract governs what CONSUMERS put into a
+ * checkpoint (pauseData, shared state) — but the execution tree's diagnostic
+ * bags (`logs`/`errors`/`metrics`/`evals`) accept ANY value at write time
+ * without cloning (`$debug`/`$error`/`$metric`/`$eval` route through
+ * `DiagnosticCollector`, which stores raw references). A `$debug`'d function
+ * in any stage of a pausing run would make the whole-checkpoint clone throw
+ * `DataCloneError` — swallowing the pause.
+ *
+ * That violates the library's error-isolation grain: observability side-bags
+ * never abort traversal anywhere else. These helpers restore the grain:
+ *
+ *   - `sanitizeDiagnosticBags` — replace non-cloneable diagnostic values with
+ *     marker strings (`'[non-serializable: function]'`) so the pause survives.
+ *   - `describeCheckpointCloneFailure` — when the clone STILL fails after
+ *     sanitization (the non-cloneable lives in consumer-owned data, e.g.
+ *     `pauseData`), name the offending checkpoint field(s) and point at the
+ *     JSON-safe contract instead of letting a naked `DataCloneError` escape.
+ *
+ * Both run ONLY on the clone-failure path of a pause — never on the hot path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeCheckpointCloneFailure = exports.sanitizeDiagnosticBags = void 0;
+/** The StageSnapshot fields written by `$debug`/`$error`/`$metric`/`$eval`. */
+const DIAGNOSTIC_BAGS = ['logs', 'errors', 'metrics', 'evals'];
+/** `true` when `structuredClone` accepts the value as-is. */
+function isCloneable(value) {
+    try {
+        structuredClone(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Human-readable kind for the `[non-serializable: …]` marker. */
+function describeKind(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value !== 'object')
+        return typeof value;
+    return value.constructor?.name ?? 'object';
+}
+/** Plain data container we can rebuild entry-by-entry without lying about the type. */
+function isPlainObject(value) {
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Deep-replace non-cloneable values with `'[non-serializable: <kind>]'`
+ * marker strings, preserving everything `structuredClone` accepts.
+ *
+ * Fast path: a cloneable value is returned AS-IS (no copy — the caller
+ * clones the whole checkpoint right after). Only containers that actually
+ * hold a non-cloneable leaf are rebuilt, and only KNOWN container shapes
+ * (array / Map / Set / plain object) are rebuilt entry-by-entry — exotic
+ * non-cloneables (Promise, WeakMap, class instances holding a function, …)
+ * become a typed marker rather than a misleading empty shell. Pure cycles
+ * pass the fast path untouched (`structuredClone` supports them); a cycle
+ * is only broken — with a marker — when it shares a container with a
+ * non-cloneable value.
+ */
+function sanitizeValue(value, seen) {
+    if (isCloneable(value))
+        return value;
+    if (value !== null && typeof value === 'object') {
+        if (seen.has(value))
+            return '[non-serializable: circular]';
+        seen.add(value);
+        if (Array.isArray(value)) {
+            return value.map((v) => sanitizeValue(v, seen));
+        }
+        if (value instanceof Map) {
+            return new Map([...value].map(([k, v]) => [sanitizeValue(k, seen), sanitizeValue(v, seen)]));
+        }
+        if (value instanceof Set) {
+            return new Set([...value].map((v) => sanitizeValue(v, seen)));
+        }
+        if (isPlainObject(value)) {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, sanitizeValue(v, seen)]));
+        }
+    }
+    return `[non-serializable: ${describeKind(value)}]`;
+}
+/**
+ * Walk a `StageSnapshot` tree (via `next` + `children`) and sanitize the four
+ * diagnostic bags on every node IN PLACE.
+ *
+ * In-place is safe and intentional: `StageContext.getSnapshot()` builds fresh
+ * node objects on every call, but the bag fields on those fresh nodes ALIAS
+ * the live `DiagnosticCollector` bags. We replace the node's bag REFERENCE
+ * with a sanitized copy — the live engine bags are never mutated, so a
+ * same-executor resume keeps the original diagnostic values.
+ */
+function sanitizeDiagnosticBags(tree) {
+    const seen = new WeakSet();
+    const visit = (node) => {
+        for (const bag of DIAGNOSTIC_BAGS) {
+            const bagValue = node[bag];
+            if (bagValue !== undefined && !isCloneable(bagValue)) {
+                node[bag] = sanitizeValue(bagValue, seen);
+            }
+        }
+        if (node.next)
+            visit(node.next);
+        if (node.children)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(tree);
+    return tree;
+}
+exports.sanitizeDiagnosticBags = sanitizeDiagnosticBags;
+/**
+ * Build the DESCRIPTIVE error for a checkpoint that still cannot be cloned
+ * after diagnostic-bag sanitization — i.e. the non-cloneable value lives in
+ * consumer-owned data (a genuine JSON-safe contract violation). Probes each
+ * top-level checkpoint field individually so the message names the offending
+ * field family. Never lets a naked `DataCloneError` escape.
+ */
+function describeCheckpointCloneFailure(checkpoint, cause) {
+    const failing = Object.entries(checkpoint)
+        .filter(([, value]) => !isCloneable(value))
+        .map(([field]) => field);
+    const fields = failing.length > 0 ? failing.join(', ') : 'unknown';
+    return new Error('FlowChartExecutor: cannot build the pause checkpoint — non-serializable value(s) in ' +
+        `checkpoint field(s): ${fields}. The checkpoint contract is JSON-safe (no functions, no ` +
+        "class instances). Check the pauseData returned by the pausable stage's execute(), and any " +
+        'subflow state captured at the pause. Diagnostic values from $debug/$metric/$error/$eval ' +
+        'are sanitized automatically and never cause this error. ' +
+        'See docs/guides/execution-model.md ("Pause / resume — what a checkpoint captures").', { cause });
+}
+exports.describeCheckpointCloneFailure = describeCheckpointCloneFailure;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkpointSanitize.js","sourceRoot":"","sources":["../../../src/lib/runner/checkpointSanitize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * checkpointSanitize — clone-resilience helpers for `buildPauseCheckpoint`.\n *\n * The pause checkpoint is detached via one `structuredClone` of the assembled\n * checkpoint. The JSON-safe contract governs what CONSUMERS put into a\n * checkpoint (pauseData, shared state) — but the execution tree's diagnostic\n * bags (`logs`/`errors`/`metrics`/`evals`) accept ANY value at write time\n * without cloning (`$debug`/`$error`/`$metric`/`$eval` route through\n * `DiagnosticCollector`, which stores raw references). A `$debug`'d function\n * in any stage of a pausing run would make the whole-checkpoint clone throw\n * `DataCloneError` — swallowing the pause.\n *\n * That violates the library's error-isolation grain: observability side-bags\n * never abort traversal anywhere else. These helpers restore the grain:\n *\n *   - `sanitizeDiagnosticBags` — replace non-cloneable diagnostic values with\n *     marker strings (`'[non-serializable: function]'`) so the pause survives.\n *   - `describeCheckpointCloneFailure` — when the clone STILL fails after\n *     sanitization (the non-cloneable lives in consumer-owned data, e.g.\n *     `pauseData`), name the offending checkpoint field(s) and point at the\n *     JSON-safe contract instead of letting a naked `DataCloneError` escape.\n *\n * Both run ONLY on the clone-failure path of a pause — never on the hot path.\n */\n\nimport type { StageSnapshot } from '../memory/types.js';\n\n/** The StageSnapshot fields written by `$debug`/`$error`/`$metric`/`$eval`. */\nconst DIAGNOSTIC_BAGS = ['logs', 'errors', 'metrics', 'evals'] as const;\n\n/** `true` when `structuredClone` accepts the value as-is. */\nfunction isCloneable(value: unknown): boolean {\n  try {\n    structuredClone(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Human-readable kind for the `[non-serializable: …]` marker. */\nfunction describeKind(value: unknown): string {\n  if (value === null) return 'null';\n  if (typeof value !== 'object') return typeof value;\n  return value.constructor?.name ?? 'object';\n}\n\n/** Plain data container we can rebuild entry-by-entry without lying about the type. */\nfunction isPlainObject(value: object): boolean {\n  const proto = Object.getPrototypeOf(value) as object | null;\n  return proto === Object.prototype || proto === null;\n}\n\n/**\n * Deep-replace non-cloneable values with `'[non-serializable: <kind>]'`\n * marker strings, preserving everything `structuredClone` accepts.\n *\n * Fast path: a cloneable value is returned AS-IS (no copy — the caller\n * clones the whole checkpoint right after). Only containers that actually\n * hold a non-cloneable leaf are rebuilt, and only KNOWN container shapes\n * (array / Map / Set / plain object) are rebuilt entry-by-entry — exotic\n * non-cloneables (Promise, WeakMap, class instances holding a function, …)\n * become a typed marker rather than a misleading empty shell. Pure cycles\n * pass the fast path untouched (`structuredClone` supports them); a cycle\n * is only broken — with a marker — when it shares a container with a\n * non-cloneable value.\n */\nfunction sanitizeValue(value: unknown, seen: WeakSet<object>): unknown {\n  if (isCloneable(value)) return value;\n  if (value !== null && typeof value === 'object') {\n    if (seen.has(value)) return '[non-serializable: circular]';\n    seen.add(value);\n    if (Array.isArray(value)) {\n      return value.map((v) => sanitizeValue(v, seen));\n    }\n    if (value instanceof Map) {\n      return new Map([...value].map(([k, v]) => [sanitizeValue(k, seen), sanitizeValue(v, seen)]));\n    }\n    if (value instanceof Set) {\n      return new Set([...value].map((v) => sanitizeValue(v, seen)));\n    }\n    if (isPlainObject(value)) {\n      return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, sanitizeValue(v, seen)]));\n    }\n  }\n  return `[non-serializable: ${describeKind(value)}]`;\n}\n\n/**\n * Walk a `StageSnapshot` tree (via `next` + `children`) and sanitize the four\n * diagnostic bags on every node IN PLACE.\n *\n * In-place is safe and intentional: `StageContext.getSnapshot()` builds fresh\n * node objects on every call, but the bag fields on those fresh nodes ALIAS\n * the live `DiagnosticCollector` bags. We replace the node's bag REFERENCE\n * with a sanitized copy — the live engine bags are never mutated, so a\n * same-executor resume keeps the original diagnostic values.\n */\nexport function sanitizeDiagnosticBags(tree: StageSnapshot): StageSnapshot {\n  const seen = new WeakSet<object>();\n  const visit = (node: StageSnapshot): void => {\n    for (const bag of DIAGNOSTIC_BAGS) {\n      const bagValue = node[bag];\n      if (bagValue !== undefined && !isCloneable(bagValue)) {\n        node[bag] = sanitizeValue(bagValue, seen) as Record<string, unknown>;\n      }\n    }\n    if (node.next) visit(node.next);\n    if (node.children) for (const child of node.children) visit(child);\n  };\n  visit(tree);\n  return tree;\n}\n\n/**\n * Build the DESCRIPTIVE error for a checkpoint that still cannot be cloned\n * after diagnostic-bag sanitization — i.e. the non-cloneable value lives in\n * consumer-owned data (a genuine JSON-safe contract violation). Probes each\n * top-level checkpoint field individually so the message names the offending\n * field family. Never lets a naked `DataCloneError` escape.\n */\nexport function describeCheckpointCloneFailure(checkpoint: Record<string, unknown>, cause: unknown): Error {\n  const failing = Object.entries(checkpoint)\n    .filter(([, value]) => !isCloneable(value))\n    .map(([field]) => field);\n  const fields = failing.length > 0 ? failing.join(', ') : 'unknown';\n  return new Error(\n    'FlowChartExecutor: cannot build the pause checkpoint — non-serializable value(s) in ' +\n      `checkpoint field(s): ${fields}. The checkpoint contract is JSON-safe (no functions, no ` +\n      \"class instances). Check the pauseData returned by the pausable stage's execute(), and any \" +\n      'subflow state captured at the pause. Diagnostic values from $debug/$metric/$error/$eval ' +\n      'are sanitized automatically and never cause this error. ' +\n      'See docs/guides/execution-model.md (\"Pause / resume — what a checkpoint captures\").',\n    { cause },\n  );\n}\n"]}

package/dist/types/lib/engine/handlers/NodeResolver.d.ts

@@ -11,7 +11,15 @@ import type { HandlerDeps } from '../types.js';
 export declare class NodeResolver<TOut = any, TScope = any> {
     private deps;
     private readonly nodeIdMap;
-    constructor(deps: HandlerDeps<TOut, TScope>, nodeIdMap?: Map<string, StageNode<TOut, TScope>>);
+    private readonly getEffectiveChildren?;
+    constructor(deps: HandlerDeps<TOut, TScope>, nodeIdMap?: Map<string, StageNode<TOut, TScope>>, 
+    /**
+     * Overlay-aware children accessor injected by the traverser. The DFS
+     * fallback resolves loop targets against the LIVE runtime shape — a node
+     * patched by a dynamic StageNode return carries its children in the
+     * traverser-local overlay, not on the shared built-chart node.
+     */
+    getEffectiveChildren?: (node: StageNode<TOut, TScope>) => StageNode<TOut, TScope>[] | undefined);
     /**
      * O(1) node lookup via pre-built ID map.
      * Falls back to DFS from startNode (for dynamic nodes added at runtime

package/dist/types/lib/engine/traversal/FlowchartTraverser.d.ts

@@ -21,7 +21,7 @@
 import type { ScopeProtectionMode } from '../../scope/protection/types.js';
 import { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';
 import type { FlowRecorder, IControlFlowNarrative } from '../narrative/types.js';
-import type { IExecutionRuntime, ILogger, ScopeFactory, SerializedPipelineStructure, StageFunction, StageNode, StreamHandlers, SubflowResult, TraversalResult } from '../types.js';
+import type { IExecutionRuntime, ILogger, ScopeFactory, Selector, SerializedPipelineStructure, StageFunction, StageNode, StreamHandlers, SubflowMountOptions, SubflowResult, TraversalResult } from '../types.js';
 export interface TraverserOptions<TOut = any, TScope = any> {
     root: StageNode<TOut, TScope>;
     stageMap: Map<string, StageFunction<TOut, TScope>>;
@@ -78,6 +78,37 @@ export interface TraverserOptions<TOut = any, TScope = any> {
      */
     runId: string;
 }
+/**
+ * Traverser-local overlay entry for a node whose stage function returned a
+ * StageNode (dynamic continuation). Holds the dynamic values that earlier
+ * versions wrote DIRECTLY onto the shared built-chart node — which leaked the
+ * dynamic shape into every later run of the same built chart and raced
+ * concurrent executors. The overlay keeps the built graph immutable: patches
+ * live in a per-traverser Map keyed by `node.id` and die with the run.
+ *
+ * `next` is intentionally ABSENT: a dynamic `next` only ever applies to the
+ * visit that produced it (the old code wrote `node.next` and restored it
+ * before anything could observe the write), so it stays a local variable in
+ * `executeNode` and is routed through `ContinuationResolver` directly.
+ */
+export interface DynamicNodePatch<TOut = any, TScope = any> {
+    /**
+     * Subflow mount metadata from a dynamic-subflow return. Grouped so the
+     * merged view reproduces the old field-wise overwrite exactly — including
+     * `subflowName`/`subflowMountOptions` becoming undefined when the dynamic
+     * return omitted them.
+     */
+    subflowMeta?: {
+        isSubflowRoot: true;
+        subflowId: string;
+        subflowName: string | undefined;
+        subflowMountOptions: SubflowMountOptions | undefined;
+    };
+    /** Dynamic fork children (replaces the built node's children for this run). */
+    children?: StageNode<TOut, TScope>[];
+    /** Dynamic output-based selector accompanying dynamic children. */
+    nextNodeSelector?: Selector;
+}
 export declare class FlowchartTraverser<TOut = any, TScope = any> {
     private readonly root;
     private stageMap;
@@ -111,6 +142,21 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
      * resolver before another traverser has finished using it.
      */
     private readonly resolvedLazySubflows;
+    /**
+     * Per-traverser overlay of dynamic StageNode returns, keyed by `node.id`.
+     * Phase 4 writes patches HERE instead of mutating the shared built-chart
+     * node objects (same isolation convention as `resolvedLazySubflows`).
+     * All engine reads of the patched fields go through the `eff*` accessors
+     * below. The map dies with the traverser — one run, one overlay — so a
+     * fresh executor over the same built chart always sees the original graph.
+     *
+     * Keyed by the node OBJECT (WeakMap), not `node.id`: a dynamic child that
+     * reuses a built node's id must NOT make the built node inherit the patch
+     * (id-keyed lookup caused phantom double-execution). `patchCount` is the
+     * fast-path check — WeakMap has no `size`.
+     */
+    private readonly dynamicPatches;
+    private patchCount;
     /**
      * Recursion depth counter for executeNode.
      * Each recursive executeNode call increments this; decrements on exit (try/finally).
@@ -203,6 +249,24 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
      */
     private buildNodeIdMap;
     private getStageFn;
+    private getPatch;
+    private getOrCreatePatch;
+    /** Effective children: dynamic patch first, then the built node's children. */
+    private effChildren;
+    /** Effective output-based selector: dynamic patch first, then the built node's. */
+    private effSelector;
+    /** Effective subflow-root marker (true when a dynamic subflow was patched on). */
+    private effIsSubflowRoot;
+    /** Effective subflow id (patched verbatim by a dynamic subflow return). */
+    private effSubflowId;
+    /**
+     * Materialize the effective view of a node — field-identical to what the
+     * pre-overlay code produced by mutating the shared node. Used where a node
+     * is handed to a helper executor (NodeResolver / SubflowExecutor /
+     * ChildrenExecutor) so helpers never read stale built fields. Returns the
+     * node itself (no allocation) when it carries no patch.
+     */
+    private effNode;
     private executeStage;
     /**
      * Pre-order DFS traversal — the core algorithm.

package/dist/types/lib/runner/FlowChartExecutor.d.ts

@@ -153,6 +153,11 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      *
      * The checkpoint is JSON-serializable — store it in Redis, Postgres, localStorage, etc.
      *
+     * It is fully DETACHED from engine state: every field was deep-copied at
+     * pause time (see `buildPauseCheckpoint`). Holding, mutating, or persisting
+     * it cannot affect the executor, and a later same-executor resume cannot
+     * mutate a checkpoint you already stored.
+     *
      * @example
      * ```typescript
      * const result = await executor.run({ input });
@@ -208,6 +213,47 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      * ```
      */
     resume(checkpoint: FlowchartCheckpoint, resumeInput?: unknown, options?: Pick<RunOptions, 'signal' | 'env' | 'maxDepth'>): Promise<ExecutorResult>;
+    /**
+     * Build a fully DETACHED checkpoint from a caught PauseSignal.
+     *
+     * Every field is deep-copied via one `structuredClone` of the assembled
+     * checkpoint, because the raw pieces alias live engine state:
+     *
+     *   - `sharedState` IS `SharedMemory`'s internal context object — the alias
+     *     only detaches at the next commit (`applySmartMerge` rebuilds it), and
+     *     after a pause there is no next commit until resume.
+     *   - `executionTree` nodes are fresh, but their `logs`/`errors`/`metrics`/
+     *     `evals`/`stageReads`/`flowMessages` fields reference live
+     *     `DiagnosticCollector` bags that keep accumulating on same-executor
+     *     resume.
+     *   - `subflowStates` values are shallow copies whose NESTED objects alias
+     *     subflow memory, and they get seeded back into live runtimes on resume.
+     *   - `subflowResults` values stay referenced by the traverser's results map.
+     *
+     * The checkpoint is persisted by contract ("store in Redis/Postgres") — it
+     * must never share structure with the engine. Pause is not a hot path; the
+     * clone cost is irrelevant.
+     *
+     * The JSON-safe checkpoint contract (no functions, no class instances)
+     * governs CONSUMER-owned data — but the executionTree's diagnostic bags
+     * accept ANY value at write time without cloning ($debug/$error/$metric/
+     * $eval store raw references), so a contract-compliant run can still carry
+     * a non-cloneable diagnostic. Observability side-bags never abort traversal
+     * anywhere else in the library, so they must not abort the pause either:
+     * on clone failure we sanitize the diagnostic bags (non-cloneable values
+     * become '[non-serializable: …]' markers — the live engine bags are never
+     * touched) and retry. If the retry STILL fails, the violation is in
+     * consumer-owned data (realistically `pauseData` — a function in shared
+     * state already rejects at stage entry when TransactionBuffer clones the
+     * context) and we throw a DESCRIPTIVE contract error naming the offending
+     * checkpoint field(s). A naked DataCloneError never escapes.
+     *
+     * Subflow scope capture (`subflowStates`) survives ONLY on the signal — the
+     * nested runtimes are GC'd as the stack unwinds. Promoting it onto the
+     * checkpoint here lets cross-executor resume restore pre-pause subflow
+     * scope (e.g. an Agent's `scope.history`). Empty `{}` for root-level pauses.
+     */
+    private buildPauseCheckpoint;
     /**
      * Find a StageNode in the compiled graph by ID.
      * Handles subflow paths by drilling into registered subflows.
@@ -405,6 +451,11 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      *
      *   The commit log is already redacted at write-time regardless of this
      *   flag, and the execution tree carries only structural metadata.
+     *
+     * **Treat `sharedState` as READ-ONLY.** In production it is a live view of
+     * the engine's working memory (zero copy cost) — mutating it corrupts
+     * engine state. In dev mode (`enableDevMode()`) it is a deep-frozen CLONE,
+     * so any consumer mutation throws loudly instead of corrupting silently.
      */
     getSnapshot(options?: {
         redact?: boolean;

package/dist/types/lib/runner/checkpointSanitize.d.ts

@@ -0,0 +1,44 @@
+/**
+ * checkpointSanitize — clone-resilience helpers for `buildPauseCheckpoint`.
+ *
+ * The pause checkpoint is detached via one `structuredClone` of the assembled
+ * checkpoint. The JSON-safe contract governs what CONSUMERS put into a
+ * checkpoint (pauseData, shared state) — but the execution tree's diagnostic
+ * bags (`logs`/`errors`/`metrics`/`evals`) accept ANY value at write time
+ * without cloning (`$debug`/`$error`/`$metric`/`$eval` route through
+ * `DiagnosticCollector`, which stores raw references). A `$debug`'d function
+ * in any stage of a pausing run would make the whole-checkpoint clone throw
+ * `DataCloneError` — swallowing the pause.
+ *
+ * That violates the library's error-isolation grain: observability side-bags
+ * never abort traversal anywhere else. These helpers restore the grain:
+ *
+ *   - `sanitizeDiagnosticBags` — replace non-cloneable diagnostic values with
+ *     marker strings (`'[non-serializable: function]'`) so the pause survives.
+ *   - `describeCheckpointCloneFailure` — when the clone STILL fails after
+ *     sanitization (the non-cloneable lives in consumer-owned data, e.g.
+ *     `pauseData`), name the offending checkpoint field(s) and point at the
+ *     JSON-safe contract instead of letting a naked `DataCloneError` escape.
+ *
+ * Both run ONLY on the clone-failure path of a pause — never on the hot path.
+ */
+import type { StageSnapshot } from '../memory/types.js';
+/**
+ * Walk a `StageSnapshot` tree (via `next` + `children`) and sanitize the four
+ * diagnostic bags on every node IN PLACE.
+ *
+ * In-place is safe and intentional: `StageContext.getSnapshot()` builds fresh
+ * node objects on every call, but the bag fields on those fresh nodes ALIAS
+ * the live `DiagnosticCollector` bags. We replace the node's bag REFERENCE
+ * with a sanitized copy — the live engine bags are never mutated, so a
+ * same-executor resume keeps the original diagnostic values.
+ */
+export declare function sanitizeDiagnosticBags(tree: StageSnapshot): StageSnapshot;
+/**
+ * Build the DESCRIPTIVE error for a checkpoint that still cannot be cloned
+ * after diagnostic-bag sanitization — i.e. the non-cloneable value lives in
+ * consumer-owned data (a genuine JSON-safe contract violation). Probes each
+ * top-level checkpoint field individually so the message names the offending
+ * field family. Never lets a naked `DataCloneError` escape.
+ */
+export declare function describeCheckpointCloneFailure(checkpoint: Record<string, unknown>, cause: unknown): Error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "8.1.0",
+  "version": "8.3.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -53,7 +53,11 @@
     "lint:fix": "eslint '{src,test}/**/*.ts' --ext .ts --fix",
     "format:fix": "prettier --config .prettierrc.js --write '{src,test}/**/*.ts'",
     "format": "prettier --config .prettierrc.js --list-different '{src,test}/**/*.ts'",
-    "bench": "npx tsx bench/run.ts",
+    "bench": "npm run bench:micro && npm run bench:baseline && npm run bench:depth",
+    "bench:micro": "npx tsx bench/run.ts",
+    "bench:baseline": "npx tsx bench/baseline.ts",
+    "bench:depth": "npx tsx bench/depth-probe.ts",
+    "bench:typecheck": "tsc -p bench/tsconfig.json",
     "docs": "typedoc",
     "docs:serve": "typedoc && npx serve docs",
     "test:coverage": "vitest run --coverage --coverage.reporter=json-summary --coverage.reporter=text-summary --coverage.reportsDirectory=coverage",