footprintjs 9.43.0 → 9.44.0

package/dist/esm/lib/runner/checkpoint.d.ts

@@ -6,24 +6,35 @@
  * (`pause/record.ts` · `CHECKPOINT_VERSION` / `decodeCheckpoint`), and
  * detaches it with one `structuredClone`.
  *
- * Clone resilience lives beside it. 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), so:
+ * LEAN (format 2). The checkpoint holds what `resume()` reads and the pause's
+ * own record, nothing else:
  *
- *   - `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.
+ *   read by resume  the cursor (`pausedStageId`, `subflowPath`, `pausedBy`),
+ *                   the state (`sharedState`, and `subflowStates` — one capture
+ *                   per subflow ON the pause path), the counters
+ *                   (`executionCount`, `visitCounts` — one entry per stage id),
+ *                   the waiting siblings (`pendingPauses`), the redaction names
+ *                   (`redactionMarks`), the link (`pausedExecution`);
+ *   the record      `pauseData` (the question), `invokerStageId`, `pausedAt`.
  *
- * Both run ONLY on the clone-failure path of a pause — never on the hot path.
+ * So its size is the state's and the chart's, never the run's length. Format 1
+ * also carried the whole execution tree and the finished subflows' results —
+ * the run's served record, which no resume read and which grew with every
+ * finished iteration (`bench/checkpoint-size.ts`: 19.3 MB after 60 agent
+ * turns whose resumable state — root plus captures — is 0.13 MB; the tree
+ * alone was 97%). That record is `getSnapshot()`'s. Pinned:
+ * test/lib/pause/checkpoint-size.test.ts.
+ *
+ * THE LAW holds: the checkpoint keeps REAL values — no redaction policy ever
+ * touches it (it is what the resumed run computes on); the marks travel as
+ * NAMES only.
+ *
+ * The JSON-safe contract governs what CONSUMERS put into a checkpoint
+ * (`pauseData`, shared state). A value `structuredClone` refuses can only come
+ * from them — shared state is cloned at every commit, so a function never
+ * reaches it, and no diagnostic bag is carried — so a failed clone becomes a
+ * DESCRIPTIVE contract error naming the field (`describeCheckpointCloneFailure`)
+ * instead of a naked `DataCloneError`.
  */
 import type { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';
 import type { FlowchartCheckpoint, PauseSignal, RedactionMarks } from '../pause/types.js';
@@ -36,7 +47,7 @@ export interface PausedRun {
     readonly redactionMarks?: RedactionMarks;
 }
 /**
- * Build a fully DETACHED checkpoint from a caught PauseSignal.
+ * Build a fully DETACHED, lean 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:
@@ -45,27 +56,21 @@ export interface PausedRun {
  *     but (copy-on-write, 9.29.0) every later generation shares its
  *     unchanged subtrees, so a checkpoint that aliased it would alias the
  *     resumed run's state too.
- *   - `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.
+ * must never share structure with the engine.
  *
- * On clone failure the diagnostic bags are sanitized (the live engine bags
- * are never touched) and the clone retried; if the retry STILL fails, the
- * violation is in consumer-owned data (realistically `pauseData` — a function
- * can never reach shared state: the record's clone at commit refuses it) and a
- * DESCRIPTIVE contract error names the offending checkpoint field(s).
+ * The state is read straight off the root runtime's store — no snapshot is
+ * built (a snapshot would build the execution tree and copy the commit log,
+ * work proportional to the run's length, only to throw both away).
  *
  * 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.
+ * scope (e.g. an Agent's `scope.history`). The signal captures a subflow only
+ * as it bubbles through that subflow's boundary, so the keys are exactly the
+ * pause path's. Empty `{}` for root-level pauses.
  */
 export declare function buildPauseCheckpoint(signal: PauseSignal, traverser: FlowchartTraverser<any, any>, run: PausedRun): FlowchartCheckpoint;

package/dist/esm/lib/runner/checkpoint.js

@@ -6,29 +6,39 @@
  * (`pause/record.ts` · `CHECKPOINT_VERSION` / `decodeCheckpoint`), and
  * detaches it with one `structuredClone`.
  *
- * Clone resilience lives beside it. 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), so:
+ * LEAN (format 2). The checkpoint holds what `resume()` reads and the pause's
+ * own record, nothing else:
  *
- *   - `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.
+ *   read by resume  the cursor (`pausedStageId`, `subflowPath`, `pausedBy`),
+ *                   the state (`sharedState`, and `subflowStates` — one capture
+ *                   per subflow ON the pause path), the counters
+ *                   (`executionCount`, `visitCounts` — one entry per stage id),
+ *                   the waiting siblings (`pendingPauses`), the redaction names
+ *                   (`redactionMarks`), the link (`pausedExecution`);
+ *   the record      `pauseData` (the question), `invokerStageId`, `pausedAt`.
  *
- * Both run ONLY on the clone-failure path of a pause — never on the hot path.
+ * So its size is the state's and the chart's, never the run's length. Format 1
+ * also carried the whole execution tree and the finished subflows' results —
+ * the run's served record, which no resume read and which grew with every
+ * finished iteration (`bench/checkpoint-size.ts`: 19.3 MB after 60 agent
+ * turns whose resumable state — root plus captures — is 0.13 MB; the tree
+ * alone was 97%). That record is `getSnapshot()`'s. Pinned:
+ * test/lib/pause/checkpoint-size.test.ts.
+ *
+ * THE LAW holds: the checkpoint keeps REAL values — no redaction policy ever
+ * touches it (it is what the resumed run computes on); the marks travel as
+ * NAMES only.
+ *
+ * The JSON-safe contract governs what CONSUMERS put into a checkpoint
+ * (`pauseData`, shared state). A value `structuredClone` refuses can only come
+ * from them — shared state is cloned at every commit, so a function never
+ * reaches it, and no diagnostic bag is carried — so a failed clone becomes a
+ * DESCRIPTIVE contract error naming the field (`describeCheckpointCloneFailure`)
+ * instead of a naked `DataCloneError`.
  */
-import { isExecutionKey } from '../ids/runtimeStageId.js';
 import { CHECKPOINT_VERSION } from '../pause/record.js';
 /**
- * Build a fully DETACHED checkpoint from a caught PauseSignal.
+ * Build a fully DETACHED, lean 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:
@@ -37,40 +47,31 @@ import { CHECKPOINT_VERSION } from '../pause/record.js';
  *     but (copy-on-write, 9.29.0) every later generation shares its
  *     unchanged subtrees, so a checkpoint that aliased it would alias the
  *     resumed run's state too.
- *   - `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.
+ * must never share structure with the engine.
  *
- * On clone failure the diagnostic bags are sanitized (the live engine bags
- * are never touched) and the clone retried; if the retry STILL fails, the
- * violation is in consumer-owned data (realistically `pauseData` — a function
- * can never reach shared state: the record's clone at commit refuses it) and a
- * DESCRIPTIVE contract error names the offending checkpoint field(s).
+ * The state is read straight off the root runtime's store — no snapshot is
+ * built (a snapshot would build the execution tree and copy the commit log,
+ * work proportional to the run's length, only to throw both away).
  *
  * 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.
+ * scope (e.g. an Agent's `scope.history`). The signal captures a subflow only
+ * as it bubbles through that subflow's boundary, so the keys are exactly the
+ * pause path's. Empty `{}` for root-level pauses.
  */
 export function buildPauseCheckpoint(signal, traverser, run) {
     // Every pause that paused in THIS run is named by it; a sibling raised again
     // on resume keeps the run it originally paused in.
     signal.completeExecution(run.runId);
-    const snapshot = traverser.getSnapshot();
-    const leanSubflowResults = leanSubflowResultsOf(traverser.getSubflowResults());
     const checkpoint = {
-        // The format (9.39.0) — read back by `pause/record.ts · decodeCheckpoint`.
+        // The format — read back by `pause/record.ts · decodeCheckpoint`.
         checkpointVersion: CHECKPOINT_VERSION,
-        sharedState: snapshot.sharedState,
-        executionTree: snapshot.executionTree,
+        sharedState: traverser.getRuntime().globalStore.getState(),
         pausedStageId: signal.stageId,
         // The paused EXECUTION (9.37.0) — a queued sibling raised on resume
         // carries the run it ORIGINALLY paused in.
@@ -84,7 +85,6 @@ export function buildPauseCheckpoint(signal, traverser, run) {
         // below untouched). See test/lib/pause/resume-execution-counter-continuity.test.ts.
         executionCount: run.executionCount,
         visitCounts: Object.fromEntries(run.visitCounts),
-        ...(Object.keys(leanSubflowResults).length > 0 && { subflowResults: leanSubflowResults }),
         // Invoker context — collected during traversal bubble-up (not tree-walked).
         // (`continuationStageId` is legacy-only since 9.39.0: no longer written.)
         ...(signal.invokerStageId && { invokerStageId: signal.invokerStageId }),
@@ -105,49 +105,11 @@ export function buildPauseCheckpoint(signal, traverser, run) {
     try {
         return structuredClone(checkpoint);
     }
-    catch {
-        // Non-cloneable diagnostics must not swallow the pause — sanitize the
-        // executionTree's bags (markers replace the offenders) and retry.
-        try {
-            checkpoint.executionTree = sanitizeDiagnosticBags(checkpoint.executionTree);
-            return structuredClone(checkpoint);
-        }
-        catch (retryError) {
-            // Genuine JSON-safe contract violation in consumer-owned data.
-            throw describeCheckpointCloneFailure(checkpoint, retryError);
-        }
-    }
-}
-/**
- * Lean subflowResults for the checkpoint (design: docs/design/subflow-commit-visibility.md):
- *   - DROP the per-iteration mount-runtimeStageId keys ('#') that the snapshot dual-keys —
- *     they would DOUBLE the checkpoint, and resume restores scope from `subflowStates`, not these.
- *   - STRIP each subflow's `treeContext.history` — resume NEVER reads `subflowResults` (it
- *     restores from `subflowStates` + `sharedState`), so the per-subflow commit log is pure
- *     checkpoint bloat. The flat agent's checkpoint carries no commit history either → symmetric.
- */
-function leanSubflowResultsOf(sfResults) {
-    const leanSubflowResults = {};
-    for (const [key, value] of sfResults) {
-        if (isExecutionKey(key))
-            continue; // per-iteration keys are snapshot-only
-        const v = value;
-        if (v?.treeContext) {
-            const treeCtxRest = {};
-            for (const ck of Object.keys(v.treeContext)) {
-                if (ck !== 'history')
-                    treeCtxRest[ck] = v.treeContext[ck]; // strip the per-subflow commit log
-            }
-            leanSubflowResults[key] = { ...value, treeContext: treeCtxRest };
-        }
-        else {
-            leanSubflowResults[key] = value;
-        }
+    catch (error) {
+        // Genuine JSON-safe contract violation in consumer-owned data.
+        throw describeCheckpointCloneFailure(checkpoint, error);
     }
-    return leanSubflowResults;
 }
-/** 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 {
@@ -158,89 +120,12 @@ function isCloneable(value) {
         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;
-}
 /**
- * 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.
+ * Build the DESCRIPTIVE error for a checkpoint that cannot be cloned — 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)
@@ -251,7 +136,7 @@ function describeCheckpointCloneFailure(checkpoint, cause) {
         `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. ' +
+        'are never part of a checkpoint and never cause this error. ' +
         'See docs/guides/execution-model.md ("Pause / resume — what a checkpoint captures").', { cause });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkpoint.js","sourceRoot":"","sources":["../../../../src/lib/runner/checkpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAYxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAmB,EACnB,SAAuC,EACvC,GAAc;IAEd,6EAA6E;IAC7E,mDAAmD;IACnD,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;IACzC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAC/E,MAAM,UAAU,GAAG;QACjB,2EAA2E;QAC3E,iBAAiB,EAAE,kBAAkB;QACrC,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,aAAa,EAAE,QAAQ,CAAC,aAAa;QACrC,aAAa,EAAE,MAAM,CAAC,OAAO;QAC7B,oEAAoE;QACpE,2CAA2C;QAC3C,GAAG,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,eAAe,EAAE,CAAC;QAC1E,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,uEAAuE;QACvE,0EAA0E;QAC1E,yEAAyE;QACzE,oFAAoF;QACpF,cAAc,EAAE,GAAG,CAAC,cAAc;QAClC,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC;QAChD,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;QACzF,4EAA4E;QAC5E,0EAA0E;QAC1E,GAAG,CAAC,MAAM,CAAC,cAAc,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC;QACvE,sEAAsE;QACtE,gEAAgE;QAChE,0BAA0B;QAC1B,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC;QAC/E,qEAAqE;QACrE,yEAAyE;QACzE,wEAAwE;QACxE,uEAAuE;QACvE,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;QACrD,0FAA0F;QAC1F,0FAA0F;QAC1F,GAAG,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,cAAc,EAAE,GAAG,CAAC,cAAc,EAAE,CAAC;QACjE,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE;KACrB,CAAC;IACF,IAAI,CAAC;QACH,OAAO,eAAe,CAAC,UAAU,CAAC,CAAC;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,sEAAsE;QACtE,kEAAkE;QAClE,IAAI,CAAC;YACH,UAAU,CAAC,aAAa,GAAG,sBAAsB,CAAC,UAAU,CAAC,aAA8B,CAAC,CAAC;YAC7F,OAAO,eAAe,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,UAAU,EAAE,CAAC;YACpB,+DAA+D;YAC/D,MAAM,8BAA8B,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,oBAAoB,CAAC,SAAqC;IACjE,MAAM,kBAAkB,GAA4B,EAAE,CAAC;IACvD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,SAAS,EAAE,CAAC;QACrC,IAAI,cAAc,CAAC,GAAG,CAAC;YAAE,SAAS,CAAC,uCAAuC;QAC1E,MAAM,CAAC,GAAG,KAA6D,CAAC;QACxE,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC;YACnB,MAAM,WAAW,GAA4B,EAAE,CAAC;YAChD,KAAK,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC5C,IAAI,EAAE,KAAK,SAAS;oBAAE,WAAW,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,mCAAmC;YAChG,CAAC;YACD,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,GAAI,KAA4C,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;QAC3G,CAAC;aAAM,CAAC;YACN,kBAAkB,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QAClC,CAAC;IACH,CAAC;IACD,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED,+EAA+E;AAC/E,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAU,CAAC;AAExE,6DAA6D;AAC7D,SAAS,WAAW,CAAC,KAAc;IACjC,IAAI,CAAC;QACH,eAAe,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,kEAAkE;AAClE,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IAClC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,OAAO,KAAK,CAAC;IACnD,OAAO,KAAK,CAAC,WAAW,EAAE,IAAI,IAAI,QAAQ,CAAC;AAC7C,CAAC;AAED,uFAAuF;AACvF,SAAS,aAAa,CAAC,KAAa;IAClC,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAkB,CAAC;IAC5D,OAAO,KAAK,KAAK,MAAM,CAAC,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,aAAa,CAAC,KAAc,EAAE,IAAqB;IAC1D,IAAI,WAAW,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,8BAA8B,CAAC;QAC3D,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,KAAK,YAAY,GAAG,EAAE,CAAC;YACzB,OAAO,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/F,CAAC;QACD,IAAI,KAAK,YAAY,GAAG,EAAE,CAAC;YACzB,OAAO,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAChG,CAAC;IACH,CAAC;IACD,OAAO,sBAAsB,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;AACtD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,sBAAsB,CAAC,IAAmB;IACjD,MAAM,IAAI,GAAG,IAAI,OAAO,EAAU,CAAC;IACnC,MAAM,KAAK,GAAG,CAAC,IAAmB,EAAQ,EAAE;QAC1C,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;YAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrD,IAAI,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,QAAQ,EAAE,IAAI,CAA4B,CAAC;YACvE,CAAC;QACH,CAAC;QACD,IAAI,IAAI,CAAC,IAAI;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,IAAI,CAAC,QAAQ;YAAE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ;gBAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACrE,CAAC,CAAC;IACF,KAAK,CAAC,IAAI,CAAC,CAAC;IACZ,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,SAAS,8BAA8B,CAAC,UAAmC,EAAE,KAAc;IACzF,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC;SACvC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;SAC1C,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,OAAO,IAAI,KAAK,CACd,sFAAsF;QACpF,wBAAwB,MAAM,2DAA2D;QACzF,4FAA4F;QAC5F,0FAA0F;QAC1F,0DAA0D;QAC1D,qFAAqF,EACvF,EAAE,KAAK,EAAE,CACV,CAAC;AACJ,CAAC","sourcesContent":["/**\n * checkpoint — the pause checkpoint, built ONCE at the pause (F9).\n *\n * `buildPauseCheckpoint` assembles the checkpoint from a caught `PauseSignal`\n * and the paused run, stamped with the format the ONE codec reads back\n * (`pause/record.ts` · `CHECKPOINT_VERSION` / `decodeCheckpoint`), and\n * detaches it with one `structuredClone`.\n *\n * Clone resilience lives beside it. The JSON-safe contract governs what\n * CONSUMERS put into a checkpoint (pauseData, shared state) — but the\n * execution tree's diagnostic bags (`logs`/`errors`/`metrics`/`evals`) accept\n * ANY value at write time without cloning (`$debug`/`$error`/`$metric`/`$eval`\n * route through `DiagnosticCollector`, which stores raw references). A\n * `$debug`'d function in any stage of a pausing run would make the\n * whole-checkpoint clone throw `DataCloneError` — swallowing the pause. That\n * violates the library's error-isolation grain (observability side-bags never\n * abort traversal anywhere else), so:\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 { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';\nimport type { SubflowResult } from '../engine/types.js';\nimport { isExecutionKey } from '../ids/runtimeStageId.js';\nimport type { StageSnapshot } from '../memory/types.js';\nimport { CHECKPOINT_VERSION } from '../pause/record.js';\nimport type { FlowchartCheckpoint, PauseSignal, RedactionMarks } from '../pause/types.js';\n\n/** The paused run's counters, as the executor holds them at the pause. */\nexport interface PausedRun {\n  readonly runId: string;\n  readonly executionCount: number;\n  readonly visitCounts: ReadonlyMap<string, number>;\n  /** The run's redaction marks — names only (`RedactionRule · marksForCheckpoint`); absent when none. */\n  readonly redactionMarks?: RedactionMarks;\n}\n\n/**\n * Build a fully DETACHED checkpoint from a caught PauseSignal.\n *\n * Every field is deep-copied via one `structuredClone` of the assembled\n * checkpoint, because the raw pieces alias live engine state:\n *\n *   - `sharedState` IS `SharedMemory`'s current generation — never edited,\n *     but (copy-on-write, 9.29.0) every later generation shares its\n *     unchanged subtrees, so a checkpoint that aliased it would alias the\n *     resumed run's state too.\n *   - `executionTree` nodes are fresh, but their `logs`/`errors`/`metrics`/\n *     `evals`/`stageReads`/`flowMessages` fields reference live\n *     `DiagnosticCollector` bags that keep accumulating on same-executor\n *     resume.\n *   - `subflowStates` values are shallow copies whose NESTED objects alias\n *     subflow memory, and they get seeded back into live runtimes on resume.\n *   - `subflowResults` values stay referenced by the traverser's results map.\n *\n * The checkpoint is persisted by contract (\"store in Redis/Postgres\") — it\n * must never share structure with the engine. Pause is not a hot path; the\n * clone cost is irrelevant.\n *\n * On clone failure the diagnostic bags are sanitized (the live engine bags\n * are never touched) and the clone retried; if the retry STILL fails, the\n * violation is in consumer-owned data (realistically `pauseData` — a function\n * can never reach shared state: the record's clone at commit refuses it) and a\n * DESCRIPTIVE contract error names the offending checkpoint field(s).\n *\n * Subflow scope capture (`subflowStates`) survives ONLY on the signal — the\n * nested runtimes are GC'd as the stack unwinds. Promoting it onto the\n * checkpoint here lets cross-executor resume restore pre-pause subflow\n * scope (e.g. an Agent's `scope.history`). Empty `{}` for root-level pauses.\n */\nexport function buildPauseCheckpoint(\n  signal: PauseSignal,\n  traverser: FlowchartTraverser<any, any>,\n  run: PausedRun,\n): FlowchartCheckpoint {\n  // Every pause that paused in THIS run is named by it; a sibling raised again\n  // on resume keeps the run it originally paused in.\n  signal.completeExecution(run.runId);\n  const snapshot = traverser.getSnapshot();\n  const leanSubflowResults = leanSubflowResultsOf(traverser.getSubflowResults());\n  const checkpoint = {\n    // The format (9.39.0) — read back by `pause/record.ts · decodeCheckpoint`.\n    checkpointVersion: CHECKPOINT_VERSION,\n    sharedState: snapshot.sharedState,\n    executionTree: snapshot.executionTree,\n    pausedStageId: signal.stageId,\n    // The paused EXECUTION (9.37.0) — a queued sibling raised on resume\n    // carries the run it ORIGINALLY paused in.\n    ...(signal.pausedExecution && { pausedExecution: signal.pausedExecution }),\n    subflowPath: signal.subflowPath,\n    pauseData: signal.pauseData,\n    subflowStates: signal.subflowStates,\n    // Counter continuity — seeded back in resume() so runtimeStageIds stay\n    // unique and loopIteration stays monotonic across a CROSS-executor resume\n    // (both are plain number/record, so they ride the single structuredClone\n    // below untouched). See test/lib/pause/resume-execution-counter-continuity.test.ts.\n    executionCount: run.executionCount,\n    visitCounts: Object.fromEntries(run.visitCounts),\n    ...(Object.keys(leanSubflowResults).length > 0 && { subflowResults: leanSubflowResults }),\n    // Invoker context — collected during traversal bubble-up (not tree-walked).\n    // (`continuationStageId` is legacy-only since 9.39.0: no longer written.)\n    ...(signal.invokerStageId && { invokerStageId: signal.invokerStageId }),\n    // Parallel siblings' pauses from the same fan-out, waiting their turn\n    // (9.28.0). Absent when only one child paused — the shape every\n    // earlier checkpoint has.\n    ...(signal.pendingPauses.length > 0 && { pendingPauses: signal.pendingPauses }),\n    // HOW the pause was raised. One checkpoint shape, one extra optional\n    // field — an interrupt() pause is not a second kind of checkpoint, it is\n    // the same checkpoint that resume() re-enters differently (stage top vs\n    // resumeFn). Absent for every pre-9.14.0 checkpoint, which is correct.\n    ...(signal.pausedBy && { pausedBy: signal.pausedBy }),\n    // The redaction the paused run had made — NAMES only (marks, a mapper's taints, inherited\n    // fields). Resume seeds the resumed run's rule with them. Absent when nothing was marked.\n    ...(run.redactionMarks && { redactionMarks: run.redactionMarks }),\n    pausedAt: Date.now(),\n  };\n  try {\n    return structuredClone(checkpoint);\n  } catch {\n    // Non-cloneable diagnostics must not swallow the pause — sanitize the\n    // executionTree's bags (markers replace the offenders) and retry.\n    try {\n      checkpoint.executionTree = sanitizeDiagnosticBags(checkpoint.executionTree as StageSnapshot);\n      return structuredClone(checkpoint);\n    } catch (retryError) {\n      // Genuine JSON-safe contract violation in consumer-owned data.\n      throw describeCheckpointCloneFailure(checkpoint, retryError);\n    }\n  }\n}\n\n/**\n * Lean subflowResults for the checkpoint (design: docs/design/subflow-commit-visibility.md):\n *   - DROP the per-iteration mount-runtimeStageId keys ('#') that the snapshot dual-keys —\n *     they would DOUBLE the checkpoint, and resume restores scope from `subflowStates`, not these.\n *   - STRIP each subflow's `treeContext.history` — resume NEVER reads `subflowResults` (it\n *     restores from `subflowStates` + `sharedState`), so the per-subflow commit log is pure\n *     checkpoint bloat. The flat agent's checkpoint carries no commit history either → symmetric.\n */\nfunction leanSubflowResultsOf(sfResults: Map<string, SubflowResult>): Record<string, unknown> {\n  const leanSubflowResults: Record<string, unknown> = {};\n  for (const [key, value] of sfResults) {\n    if (isExecutionKey(key)) continue; // per-iteration keys are snapshot-only\n    const v = value as unknown as { treeContext?: Record<string, unknown> };\n    if (v?.treeContext) {\n      const treeCtxRest: Record<string, unknown> = {};\n      for (const ck of Object.keys(v.treeContext)) {\n        if (ck !== 'history') treeCtxRest[ck] = v.treeContext[ck]; // strip the per-subflow commit log\n      }\n      leanSubflowResults[key] = { ...(value as unknown as Record<string, unknown>), treeContext: treeCtxRest };\n    } else {\n      leanSubflowResults[key] = value;\n    }\n  }\n  return leanSubflowResults;\n}\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 */\nfunction 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 */\nfunction 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkpoint.js","sourceRoot":"","sources":["../../../../src/lib/runner/checkpoint.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * checkpoint — the pause checkpoint, built ONCE at the pause (F9).\n *\n * `buildPauseCheckpoint` assembles the checkpoint from a caught `PauseSignal`\n * and the paused run, stamped with the format the ONE codec reads back\n * (`pause/record.ts` · `CHECKPOINT_VERSION` / `decodeCheckpoint`), and\n * detaches it with one `structuredClone`.\n *\n * LEAN (format 2). The checkpoint holds what `resume()` reads and the pause's\n * own record, nothing else:\n *\n *   read by resume  the cursor (`pausedStageId`, `subflowPath`, `pausedBy`),\n *                   the state (`sharedState`, and `subflowStates` — one capture\n *                   per subflow ON the pause path), the counters\n *                   (`executionCount`, `visitCounts` — one entry per stage id),\n *                   the waiting siblings (`pendingPauses`), the redaction names\n *                   (`redactionMarks`), the link (`pausedExecution`);\n *   the record      `pauseData` (the question), `invokerStageId`, `pausedAt`.\n *\n * So its size is the state's and the chart's, never the run's length. Format 1\n * also carried the whole execution tree and the finished subflows' results —\n * the run's served record, which no resume read and which grew with every\n * finished iteration (`bench/checkpoint-size.ts`: 19.3 MB after 60 agent\n * turns whose resumable state — root plus captures — is 0.13 MB; the tree\n * alone was 97%). That record is `getSnapshot()`'s. Pinned:\n * test/lib/pause/checkpoint-size.test.ts.\n *\n * THE LAW holds: the checkpoint keeps REAL values — no redaction policy ever\n * touches it (it is what the resumed run computes on); the marks travel as\n * NAMES only.\n *\n * The JSON-safe contract governs what CONSUMERS put into a checkpoint\n * (`pauseData`, shared state). A value `structuredClone` refuses can only come\n * from them — shared state is cloned at every commit, so a function never\n * reaches it, and no diagnostic bag is carried — so a failed clone becomes a\n * DESCRIPTIVE contract error naming the field (`describeCheckpointCloneFailure`)\n * instead of a naked `DataCloneError`.\n */\n\nimport type { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';\nimport { CHECKPOINT_VERSION } from '../pause/record.js';\nimport type { FlowchartCheckpoint, PauseSignal, RedactionMarks } from '../pause/types.js';\n\n/** The paused run's counters, as the executor holds them at the pause. */\nexport interface PausedRun {\n  readonly runId: string;\n  readonly executionCount: number;\n  readonly visitCounts: ReadonlyMap<string, number>;\n  /** The run's redaction marks — names only (`RedactionRule · marksForCheckpoint`); absent when none. */\n  readonly redactionMarks?: RedactionMarks;\n}\n\n/**\n * Build a fully DETACHED, lean checkpoint from a caught PauseSignal.\n *\n * Every field is deep-copied via one `structuredClone` of the assembled\n * checkpoint, because the raw pieces alias live engine state:\n *\n *   - `sharedState` IS `SharedMemory`'s current generation — never edited,\n *     but (copy-on-write, 9.29.0) every later generation shares its\n *     unchanged subtrees, so a checkpoint that aliased it would alias the\n *     resumed run's state too.\n *   - `subflowStates` values are shallow copies whose NESTED objects alias\n *     subflow memory, and they get seeded back into live runtimes on resume.\n *\n * The checkpoint is persisted by contract (\"store in Redis/Postgres\") — it\n * must never share structure with the engine.\n *\n * The state is read straight off the root runtime's store — no snapshot is\n * built (a snapshot would build the execution tree and copy the commit log,\n * work proportional to the run's length, only to throw both away).\n *\n * Subflow scope capture (`subflowStates`) survives ONLY on the signal — the\n * nested runtimes are GC'd as the stack unwinds. Promoting it onto the\n * checkpoint here lets cross-executor resume restore pre-pause subflow\n * scope (e.g. an Agent's `scope.history`). The signal captures a subflow only\n * as it bubbles through that subflow's boundary, so the keys are exactly the\n * pause path's. Empty `{}` for root-level pauses.\n */\nexport function buildPauseCheckpoint(\n  signal: PauseSignal,\n  traverser: FlowchartTraverser<any, any>,\n  run: PausedRun,\n): FlowchartCheckpoint {\n  // Every pause that paused in THIS run is named by it; a sibling raised again\n  // on resume keeps the run it originally paused in.\n  signal.completeExecution(run.runId);\n  const checkpoint = {\n    // The format — read back by `pause/record.ts · decodeCheckpoint`.\n    checkpointVersion: CHECKPOINT_VERSION,\n    sharedState: traverser.getRuntime().globalStore.getState(),\n    pausedStageId: signal.stageId,\n    // The paused EXECUTION (9.37.0) — a queued sibling raised on resume\n    // carries the run it ORIGINALLY paused in.\n    ...(signal.pausedExecution && { pausedExecution: signal.pausedExecution }),\n    subflowPath: signal.subflowPath,\n    pauseData: signal.pauseData,\n    subflowStates: signal.subflowStates,\n    // Counter continuity — seeded back in resume() so runtimeStageIds stay\n    // unique and loopIteration stays monotonic across a CROSS-executor resume\n    // (both are plain number/record, so they ride the single structuredClone\n    // below untouched). See test/lib/pause/resume-execution-counter-continuity.test.ts.\n    executionCount: run.executionCount,\n    visitCounts: Object.fromEntries(run.visitCounts),\n    // Invoker context — collected during traversal bubble-up (not tree-walked).\n    // (`continuationStageId` is legacy-only since 9.39.0: no longer written.)\n    ...(signal.invokerStageId && { invokerStageId: signal.invokerStageId }),\n    // Parallel siblings' pauses from the same fan-out, waiting their turn\n    // (9.28.0). Absent when only one child paused — the shape every\n    // earlier checkpoint has.\n    ...(signal.pendingPauses.length > 0 && { pendingPauses: signal.pendingPauses }),\n    // HOW the pause was raised. One checkpoint shape, one extra optional\n    // field — an interrupt() pause is not a second kind of checkpoint, it is\n    // the same checkpoint that resume() re-enters differently (stage top vs\n    // resumeFn). Absent for every pre-9.14.0 checkpoint, which is correct.\n    ...(signal.pausedBy && { pausedBy: signal.pausedBy }),\n    // The redaction the paused run had made — NAMES only (marks, a mapper's taints, inherited\n    // fields). Resume seeds the resumed run's rule with them. Absent when nothing was marked.\n    ...(run.redactionMarks && { redactionMarks: run.redactionMarks }),\n    pausedAt: Date.now(),\n  };\n  try {\n    return structuredClone(checkpoint);\n  } catch (error) {\n    // Genuine JSON-safe contract violation in consumer-owned data.\n    throw describeCheckpointCloneFailure(checkpoint, error);\n  }\n}\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/**\n * Build the DESCRIPTIVE error for a checkpoint that cannot be cloned — the\n * non-cloneable value lives in consumer-owned data (a genuine JSON-safe\n * contract violation). Probes each top-level checkpoint field individually so\n * the message names the offending field family. Never lets a naked\n * `DataCloneError` escape.\n */\nfunction 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 never part of a checkpoint and never cause this error. ' +\n      'See docs/guides/execution-model.md (\"Pause / resume — what a checkpoint captures\").',\n    { cause },\n  );\n}\n"]}