footprintjs 8.1.0 → 8.2.0

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

@@ -0,0 +1,133 @@
+/**
+ * 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.
+ */
+/** 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.
+ */
+export 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.
+ */
+export 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 });
+}
+//# 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"]}