footprintjs 8.0.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"]}

package/dist/lib/memory/StageContext.js

@@ -82,7 +82,9 @@ class StageContext {
     getRedactedSharedMemory() {
         return this.redactedSharedMemory;
     }
-    /** Lazily creates the transaction buffer (pay clone cost only if stage writes). */
+    /** Lazily creates the transaction buffer on the stage's FIRST state access —
+     *  reads included, so read-only stages currently pay the clone cost too.
+     *  (Truly lazy-on-write is backlog Phase-3 #13.) */
     getTransactionBuffer() {
         if (!this.buffer) {
             this.buffer = new TransactionBuffer_js_1.TransactionBuffer(this.sharedMemory.getState());
@@ -332,4 +334,4 @@ class StageContext {
     }
 }
 exports.StageContext = StageContext;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StageContext.js","sourceRoot":"","sources":["../../../src/lib/memory/StageContext.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * StageContext — Execution context for a single stage in a flowchart run\n *\n * Like a stack frame in a compiler/runtime:\n * - Reference to SharedMemory (accessing heap memory)\n * - TransactionBuffer for staging mutations (transaction buffer)\n * - Links to parent/child/next contexts (call stack frames)\n * - DiagnosticCollector for logs, errors, metrics\n */\n\nimport { DiagnosticCollector } from './DiagnosticCollector.js';\nimport { EventLog } from './EventLog.js';\nimport { SharedMemory } from './SharedMemory.js';\nimport { TransactionBuffer } from './TransactionBuffer.js';\nimport type { FlowControlType, FlowMessage, StageSnapshot } from './types.js';\nimport { redactPatch } from './utils.js';\n\nexport class StageContext {\n  private sharedMemory: SharedMemory;\n  /**\n   * Parallel redacted mirror of `sharedMemory`. Populated in `commit()` with\n   * the already-computed redacted patches (the same ones fed to `eventLog`).\n   * Present **only** when the executor has been told to maintain a redacted\n   * view — i.e. when a `RedactionPolicy` is configured. Otherwise undefined,\n   * zero extra work per commit.\n   *\n   * The mirror is read via `FlowChartExecutor.getSnapshot({ redact: true })`\n   * and is the foundation for the \"export trace\" / paste-into-viewer feature\n   * — consumers share the redacted view externally without leaking raw PII\n   * through `sharedState`.\n   */\n  private redactedSharedMemory?: SharedMemory;\n  private buffer?: TransactionBuffer;\n  private eventLog?: EventLog;\n\n  public stageName = '';\n  /** Unique stage identifier from the builder (matches spec node id). */\n  public stageId: string;\n  /** Unique per-execution-step identifier. Set by traverser before stage execution. */\n  public runtimeStageId = '';\n  public runId: string;\n  public branchId?: string;\n  public isDecider: boolean;\n  public isFork: boolean;\n  /** Human-readable description from builder (set by traverser before execution). */\n  public description?: string;\n  /** Subflow identifier (set by traverser when this is a subflow entry point). */\n  public subflowId?: string;\n\n  public parent?: StageContext;\n  public next?: StageContext;\n  public children?: StageContext[];\n\n  public debug: DiagnosticCollector = new DiagnosticCollector();\n\n  /** Tracks user-level writes (pre-namespace) for the memory view and onCommit. */\n  private _stageWrites: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }> = {};\n\n  /** Tracks user-level reads (pre-namespace) for the memory view. */\n  private _stageReads: Record<string, unknown> = {};\n\n  /** Observer called after commit() — used by ScopeFacade to fire ScopeRecorder.onCommit. */\n  private _commitObserver?: (\n    mutations: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }>,\n  ) => void;\n\n  constructor(\n    runId: string,\n    name: string,\n    stageId: string,\n    sharedMemory: SharedMemory,\n    branchId?: string,\n    eventLog?: EventLog,\n    isDecider?: boolean,\n  ) {\n    this.runId = runId;\n    this.stageName = name;\n    this.stageId = stageId;\n    this.sharedMemory = sharedMemory;\n    this.branchId = branchId;\n    this.eventLog = eventLog;\n    this.isDecider = !!isDecider;\n    this.isFork = false;\n  }\n\n  /** Returns the SharedMemory instance (needed by scope layer). */\n  getSharedMemory(): SharedMemory {\n    return this.sharedMemory;\n  }\n\n  /**\n   * Install a parallel redacted mirror. Subsequent `commit()` calls will\n   * apply the already-computed redacted patches to this mirror in addition\n   * to the raw `sharedMemory` + `eventLog`. Child / next contexts inherit\n   * the mirror via `createNext` / `createChild`.\n   *\n   * Called once at the root context by `ExecutionRuntime.enableRedactedMirror()`.\n   */\n  useRedactedMirror(mirror: SharedMemory): void {\n    this.redactedSharedMemory = mirror;\n  }\n\n  /** Returns the redacted mirror if installed, else undefined. */\n  getRedactedSharedMemory(): SharedMemory | undefined {\n    return this.redactedSharedMemory;\n  }\n\n  /** Lazily creates the transaction buffer (pay clone cost only if stage writes). */\n  getTransactionBuffer(): TransactionBuffer {\n    if (!this.buffer) {\n      this.buffer = new TransactionBuffer(this.sharedMemory.getState());\n    }\n    return this.buffer;\n  }\n\n  /** Builds an absolute path inside the shared memory (run namespace). */\n  private withNamespace(path: string[], key: string): string[] {\n    if (!this.runId || this.runId === '') {\n      return [...path, key];\n    }\n    return ['runs', this.runId, ...path, key];\n  }\n\n  // ── Write operations ───────────────────────────────────────────────────\n\n  patch(path: string[], key: string, value: unknown, shouldRedact = false) {\n    this.getTransactionBuffer().set(this.withNamespace(path, key), value, shouldRedact);\n  }\n\n  set(path: string[], key: string, value: unknown) {\n    this.patch(path, key, value);\n  }\n\n  merge(path: string[], key: string, value: unknown) {\n    this.getTransactionBuffer().merge(this.withNamespace(path, key), value);\n  }\n\n  setObject(\n    path: string[],\n    key: string,\n    value: unknown,\n    shouldRedact?: boolean,\n    description?: string,\n    operationOverride?: 'set' | 'delete',\n  ) {\n    this.patch(path, key, value, shouldRedact ?? false);\n    // Track user-level write (pre-namespace) for memory view + onCommit\n    const userKey = path.length > 0 ? [...path, key].join('.') : key;\n    this._stageWrites[userKey] = {\n      value: shouldRedact ? '[REDACTED]' : structuredClone(value),\n      operation: operationOverride ?? 'set',\n    };\n    if (description) {\n      const tagged = description.startsWith('[') ? description : `[WRITE] ${description}`;\n      this.debug.addLog('message', tagged);\n    }\n  }\n\n  updateObject(path: string[], key: string, value: unknown, description?: string, shouldRedact?: boolean) {\n    this.merge(path, key, value);\n    // Track user-level write (pre-namespace) for memory view + onCommit\n    const userKey = path.length > 0 ? [...path, key].join('.') : key;\n    this._stageWrites[userKey] = {\n      value: shouldRedact ? '[REDACTED]' : structuredClone(value),\n      operation: 'update',\n    };\n    if (description) {\n      this.debug.addLog('message', description);\n    }\n  }\n\n  setRoot(key: string, value: unknown) {\n    this.patch([], key, value);\n  }\n\n  setGlobal(key: string, value: unknown, description?: string) {\n    this.getTransactionBuffer().set([key], value);\n    if (description) {\n      this.debug.addLog('message', description);\n    }\n  }\n\n  updateGlobalContext(key: string, value: unknown) {\n    this.getTransactionBuffer().set([key], value);\n  }\n\n  appendToArray(path: string[], key: string, items: unknown[], description?: string) {\n    const existing = this.getValue(path, key);\n    const merged = Array.isArray(existing) ? [...existing, ...items] : [...items];\n    this.setObject(path, key, merged, false, description);\n  }\n\n  mergeObject(path: string[], key: string, obj: Record<string, unknown>, description?: string) {\n    const existing = this.getValue(path, key);\n    const merged =\n      existing && typeof existing === 'object' && !Array.isArray(existing)\n        ? { ...(existing as Record<string, unknown>), ...obj }\n        : { ...obj };\n    this.setObject(path, key, merged, false, description);\n  }\n\n  // ── Read operations ────────────────────────────────────────────────────\n\n  getValue(path: string[], key?: string, description?: string) {\n    const buf = this.getTransactionBuffer();\n    const fromPatch = buf.get(this.withNamespace(path, key as string));\n    const value = typeof fromPatch !== 'undefined' ? fromPatch : this.sharedMemory.getValue(this.runId, path, key);\n    // Track user-level read (pre-namespace) for memory view\n    if (key !== undefined) {\n      const userKey = path.length > 0 ? [...path, key].join('.') : key;\n      this._stageReads[userKey] = value !== undefined ? structuredClone(value) : undefined;\n    }\n    if (description) {\n      this.debug.addLog('message', `[READ] ${description}`);\n    }\n    return value;\n  }\n\n  /** Read state without tracking in _stageReads or paying structuredClone cost.\n   *  Used by ScopeFacade.getValueSilent() for array proxy internal operations. */\n  getValueDirect(path: string[], key?: string): unknown {\n    const buf = this.getTransactionBuffer();\n    const fromPatch = buf.get(this.withNamespace(path, key as string));\n    return typeof fromPatch !== 'undefined' ? fromPatch : this.sharedMemory.getValue(this.runId, path, key);\n  }\n\n  getRoot(key: string) {\n    return this.sharedMemory.getValue(this.runId, [], key);\n  }\n\n  getGlobal(key: string) {\n    return this.sharedMemory.getValue('', [], key);\n  }\n\n  getScope(): Record<string, unknown> {\n    return this.sharedMemory.getState();\n  }\n\n  getRunId(): string {\n    return this.runId;\n  }\n\n  // ── Commit ─────────────────────────────────────────────────────────────\n\n  /** Register an observer that fires after commit() applies patches.\n   *  Used by ScopeFacade to dispatch ScopeRecorder.onCommit events. */\n  setCommitObserver(\n    observer: (mutations: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }>) => void,\n  ): void {\n    this._commitObserver = observer;\n  }\n\n  commit(): void {\n    const buf = this.getTransactionBuffer();\n    const bundle = buf.commit();\n    const commitBundle = {\n      ...bundle,\n      stage: this.stageName,\n      stageId: this.stageId,\n      runtimeStageId: this.runtimeStageId,\n    };\n\n    this.sharedMemory.applyPatch(commitBundle.overwrite, commitBundle.updates, commitBundle.trace);\n\n    // Already-computed redacted patches feed three consumers:\n    //   1. the parallel redacted mirror (if enabled)\n    //   2. the event log (persisted trace)\n    //   3. (future) anything else that wants a scrubbed view at commit time\n    // Computing once keeps cost linear in the commit size; no post-pass walk.\n    const redactedOverwrite = redactPatch(commitBundle.overwrite, commitBundle.redactedPaths);\n    const redactedUpdates = redactPatch(commitBundle.updates, commitBundle.redactedPaths);\n\n    this.redactedSharedMemory?.applyPatch(redactedOverwrite, redactedUpdates, commitBundle.trace);\n\n    this.eventLog?.record({\n      ...commitBundle,\n      redactedPaths: Array.from(commitBundle.redactedPaths.values()),\n      overwrite: redactedOverwrite,\n      updates: redactedUpdates,\n    });\n\n    // Notify observer (ScopeFacade) with tracked mutations\n    if (this._commitObserver) {\n      this._commitObserver({ ...this._stageWrites });\n    }\n  }\n\n  // ── Tree navigation ────────────────────────────────────────────────────\n\n  createNext(path: string, stageName: string, stageId: string, isDecider = false): StageContext {\n    if (!this.next) {\n      this.next = new StageContext(path, stageName, stageId, this.sharedMemory, '', this.eventLog, isDecider);\n      this.next.parent = this;\n      // Propagate the redacted mirror down the context tree so every commit\n      // in the run writes to both views.\n      if (this.redactedSharedMemory) this.next.redactedSharedMemory = this.redactedSharedMemory;\n    }\n    return this.next;\n  }\n\n  createChild(runId: string, branchId: string, stageName: string, stageId: string, isDecider = false): StageContext {\n    if (!this.children) {\n      this.children = [];\n    }\n    const child = new StageContext(runId, stageName, stageId, this.sharedMemory, branchId, this.eventLog, isDecider);\n    child.parent = this;\n    if (this.redactedSharedMemory) child.redactedSharedMemory = this.redactedSharedMemory;\n    this.children.push(child);\n    return child;\n  }\n\n  createDecider(path: string, stageName: string, stageId: string): StageContext {\n    return this.createNext(path, stageName, stageId, true);\n  }\n\n  setAsDecider(): StageContext {\n    this.isDecider = true;\n    return this;\n  }\n\n  setAsFork(): StageContext {\n    this.isFork = true;\n    return this;\n  }\n\n  // ── Diagnostics delegation ─────────────────────────────────────────────\n\n  addLog(key: string, value: unknown, path?: string[]) {\n    this.debug.addLog(key, value, path);\n  }\n\n  setLog(key: string, value: unknown, path?: string[]) {\n    this.debug.setLog(key, value, path);\n  }\n\n  addMetric(key: string, value: unknown, path?: string[]) {\n    this.debug.addMetric(key, value, path);\n  }\n\n  setMetric(key: string, value: unknown, path?: string[]) {\n    this.debug.setMetric(key, value, path);\n  }\n\n  addEval(key: string, value: unknown, path?: string[]) {\n    this.debug.addEval(key, value, path);\n  }\n\n  setEval(key: string, value: unknown, path?: string[]) {\n    this.debug.setEval(key, value, path);\n  }\n\n  addError(key: string, value: unknown, path?: string[]) {\n    this.debug.addError(key, value, path);\n  }\n\n  addFlowDebugMessage(\n    type: FlowControlType,\n    description: string,\n    options?: { targetStage?: string | string[]; rationale?: string; count?: number; iteration?: number },\n  ) {\n    const flowMessage: FlowMessage = { type, description, timestamp: Date.now(), ...options };\n    this.debug.addFlowMessage(flowMessage);\n  }\n\n  // ── Snapshot ───────────────────────────────────────────────────────────\n\n  getStageId(): string {\n    if (!this.runId || this.runId === '') return this.stageName;\n    return `${this.runId}.${this.stageName}`;\n  }\n\n  getSnapshot(): StageSnapshot {\n    const snapshot: StageSnapshot = {\n      id: this.stageId,\n      runtimeStageId: this.runtimeStageId || undefined,\n      name: this.stageName,\n      isDecider: this.isDecider,\n      isFork: this.isFork,\n      logs: this.debug.logContext,\n      errors: this.debug.errorContext,\n      metrics: this.debug.metricContext,\n      evals: this.debug.evalContext,\n    };\n    if (Object.keys(this._stageWrites).length > 0) {\n      // Extract values only for the snapshot (strip operation metadata)\n      const writes: Record<string, unknown> = {};\n      for (const [k, entry] of Object.entries(this._stageWrites)) {\n        writes[k] = entry.value;\n      }\n      snapshot.stageWrites = writes;\n    }\n    if (Object.keys(this._stageReads).length > 0) {\n      snapshot.stageReads = this._stageReads;\n    }\n    if (this.description) {\n      snapshot.description = this.description;\n    }\n    if (this.subflowId) {\n      snapshot.subflowId = this.subflowId;\n    }\n    if (this.debug.flowMessages.length > 0) {\n      snapshot.flowMessages = this.debug.flowMessages;\n    }\n    if (this.next) {\n      snapshot.next = this.next.getSnapshot();\n    }\n    if (this.children) {\n      snapshot.children = this.children.map((c) => c.getSnapshot());\n    }\n    return snapshot;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StageContext.js","sourceRoot":"","sources":["../../../src/lib/memory/StageContext.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * StageContext — Execution context for a single stage in a flowchart run\n *\n * Like a stack frame in a compiler/runtime:\n * - Reference to SharedMemory (accessing heap memory)\n * - TransactionBuffer for staging mutations (transaction buffer)\n * - Links to parent/child/next contexts (call stack frames)\n * - DiagnosticCollector for logs, errors, metrics\n */\n\nimport { DiagnosticCollector } from './DiagnosticCollector.js';\nimport { EventLog } from './EventLog.js';\nimport { SharedMemory } from './SharedMemory.js';\nimport { TransactionBuffer } from './TransactionBuffer.js';\nimport type { FlowControlType, FlowMessage, StageSnapshot } from './types.js';\nimport { redactPatch } from './utils.js';\n\nexport class StageContext {\n  private sharedMemory: SharedMemory;\n  /**\n   * Parallel redacted mirror of `sharedMemory`. Populated in `commit()` with\n   * the already-computed redacted patches (the same ones fed to `eventLog`).\n   * Present **only** when the executor has been told to maintain a redacted\n   * view — i.e. when a `RedactionPolicy` is configured. Otherwise undefined,\n   * zero extra work per commit.\n   *\n   * The mirror is read via `FlowChartExecutor.getSnapshot({ redact: true })`\n   * and is the foundation for the \"export trace\" / paste-into-viewer feature\n   * — consumers share the redacted view externally without leaking raw PII\n   * through `sharedState`.\n   */\n  private redactedSharedMemory?: SharedMemory;\n  private buffer?: TransactionBuffer;\n  private eventLog?: EventLog;\n\n  public stageName = '';\n  /** Unique stage identifier from the builder (matches spec node id). */\n  public stageId: string;\n  /** Unique per-execution-step identifier. Set by traverser before stage execution. */\n  public runtimeStageId = '';\n  public runId: string;\n  public branchId?: string;\n  public isDecider: boolean;\n  public isFork: boolean;\n  /** Human-readable description from builder (set by traverser before execution). */\n  public description?: string;\n  /** Subflow identifier (set by traverser when this is a subflow entry point). */\n  public subflowId?: string;\n\n  public parent?: StageContext;\n  public next?: StageContext;\n  public children?: StageContext[];\n\n  public debug: DiagnosticCollector = new DiagnosticCollector();\n\n  /** Tracks user-level writes (pre-namespace) for the memory view and onCommit. */\n  private _stageWrites: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }> = {};\n\n  /** Tracks user-level reads (pre-namespace) for the memory view. */\n  private _stageReads: Record<string, unknown> = {};\n\n  /** Observer called after commit() — used by ScopeFacade to fire ScopeRecorder.onCommit. */\n  private _commitObserver?: (\n    mutations: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }>,\n  ) => void;\n\n  constructor(\n    runId: string,\n    name: string,\n    stageId: string,\n    sharedMemory: SharedMemory,\n    branchId?: string,\n    eventLog?: EventLog,\n    isDecider?: boolean,\n  ) {\n    this.runId = runId;\n    this.stageName = name;\n    this.stageId = stageId;\n    this.sharedMemory = sharedMemory;\n    this.branchId = branchId;\n    this.eventLog = eventLog;\n    this.isDecider = !!isDecider;\n    this.isFork = false;\n  }\n\n  /** Returns the SharedMemory instance (needed by scope layer). */\n  getSharedMemory(): SharedMemory {\n    return this.sharedMemory;\n  }\n\n  /**\n   * Install a parallel redacted mirror. Subsequent `commit()` calls will\n   * apply the already-computed redacted patches to this mirror in addition\n   * to the raw `sharedMemory` + `eventLog`. Child / next contexts inherit\n   * the mirror via `createNext` / `createChild`.\n   *\n   * Called once at the root context by `ExecutionRuntime.enableRedactedMirror()`.\n   */\n  useRedactedMirror(mirror: SharedMemory): void {\n    this.redactedSharedMemory = mirror;\n  }\n\n  /** Returns the redacted mirror if installed, else undefined. */\n  getRedactedSharedMemory(): SharedMemory | undefined {\n    return this.redactedSharedMemory;\n  }\n\n  /** Lazily creates the transaction buffer on the stage's FIRST state access —\n   *  reads included, so read-only stages currently pay the clone cost too.\n   *  (Truly lazy-on-write is backlog Phase-3 #13.) */\n  getTransactionBuffer(): TransactionBuffer {\n    if (!this.buffer) {\n      this.buffer = new TransactionBuffer(this.sharedMemory.getState());\n    }\n    return this.buffer;\n  }\n\n  /** Builds an absolute path inside the shared memory (run namespace). */\n  private withNamespace(path: string[], key: string): string[] {\n    if (!this.runId || this.runId === '') {\n      return [...path, key];\n    }\n    return ['runs', this.runId, ...path, key];\n  }\n\n  // ── Write operations ───────────────────────────────────────────────────\n\n  patch(path: string[], key: string, value: unknown, shouldRedact = false) {\n    this.getTransactionBuffer().set(this.withNamespace(path, key), value, shouldRedact);\n  }\n\n  set(path: string[], key: string, value: unknown) {\n    this.patch(path, key, value);\n  }\n\n  merge(path: string[], key: string, value: unknown) {\n    this.getTransactionBuffer().merge(this.withNamespace(path, key), value);\n  }\n\n  setObject(\n    path: string[],\n    key: string,\n    value: unknown,\n    shouldRedact?: boolean,\n    description?: string,\n    operationOverride?: 'set' | 'delete',\n  ) {\n    this.patch(path, key, value, shouldRedact ?? false);\n    // Track user-level write (pre-namespace) for memory view + onCommit\n    const userKey = path.length > 0 ? [...path, key].join('.') : key;\n    this._stageWrites[userKey] = {\n      value: shouldRedact ? '[REDACTED]' : structuredClone(value),\n      operation: operationOverride ?? 'set',\n    };\n    if (description) {\n      const tagged = description.startsWith('[') ? description : `[WRITE] ${description}`;\n      this.debug.addLog('message', tagged);\n    }\n  }\n\n  updateObject(path: string[], key: string, value: unknown, description?: string, shouldRedact?: boolean) {\n    this.merge(path, key, value);\n    // Track user-level write (pre-namespace) for memory view + onCommit\n    const userKey = path.length > 0 ? [...path, key].join('.') : key;\n    this._stageWrites[userKey] = {\n      value: shouldRedact ? '[REDACTED]' : structuredClone(value),\n      operation: 'update',\n    };\n    if (description) {\n      this.debug.addLog('message', description);\n    }\n  }\n\n  setRoot(key: string, value: unknown) {\n    this.patch([], key, value);\n  }\n\n  setGlobal(key: string, value: unknown, description?: string) {\n    this.getTransactionBuffer().set([key], value);\n    if (description) {\n      this.debug.addLog('message', description);\n    }\n  }\n\n  updateGlobalContext(key: string, value: unknown) {\n    this.getTransactionBuffer().set([key], value);\n  }\n\n  appendToArray(path: string[], key: string, items: unknown[], description?: string) {\n    const existing = this.getValue(path, key);\n    const merged = Array.isArray(existing) ? [...existing, ...items] : [...items];\n    this.setObject(path, key, merged, false, description);\n  }\n\n  mergeObject(path: string[], key: string, obj: Record<string, unknown>, description?: string) {\n    const existing = this.getValue(path, key);\n    const merged =\n      existing && typeof existing === 'object' && !Array.isArray(existing)\n        ? { ...(existing as Record<string, unknown>), ...obj }\n        : { ...obj };\n    this.setObject(path, key, merged, false, description);\n  }\n\n  // ── Read operations ────────────────────────────────────────────────────\n\n  getValue(path: string[], key?: string, description?: string) {\n    const buf = this.getTransactionBuffer();\n    const fromPatch = buf.get(this.withNamespace(path, key as string));\n    const value = typeof fromPatch !== 'undefined' ? fromPatch : this.sharedMemory.getValue(this.runId, path, key);\n    // Track user-level read (pre-namespace) for memory view\n    if (key !== undefined) {\n      const userKey = path.length > 0 ? [...path, key].join('.') : key;\n      this._stageReads[userKey] = value !== undefined ? structuredClone(value) : undefined;\n    }\n    if (description) {\n      this.debug.addLog('message', `[READ] ${description}`);\n    }\n    return value;\n  }\n\n  /** Read state without tracking in _stageReads or paying structuredClone cost.\n   *  Used by ScopeFacade.getValueSilent() for array proxy internal operations. */\n  getValueDirect(path: string[], key?: string): unknown {\n    const buf = this.getTransactionBuffer();\n    const fromPatch = buf.get(this.withNamespace(path, key as string));\n    return typeof fromPatch !== 'undefined' ? fromPatch : this.sharedMemory.getValue(this.runId, path, key);\n  }\n\n  getRoot(key: string) {\n    return this.sharedMemory.getValue(this.runId, [], key);\n  }\n\n  getGlobal(key: string) {\n    return this.sharedMemory.getValue('', [], key);\n  }\n\n  getScope(): Record<string, unknown> {\n    return this.sharedMemory.getState();\n  }\n\n  getRunId(): string {\n    return this.runId;\n  }\n\n  // ── Commit ─────────────────────────────────────────────────────────────\n\n  /** Register an observer that fires after commit() applies patches.\n   *  Used by ScopeFacade to dispatch ScopeRecorder.onCommit events. */\n  setCommitObserver(\n    observer: (mutations: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }>) => void,\n  ): void {\n    this._commitObserver = observer;\n  }\n\n  commit(): void {\n    const buf = this.getTransactionBuffer();\n    const bundle = buf.commit();\n    const commitBundle = {\n      ...bundle,\n      stage: this.stageName,\n      stageId: this.stageId,\n      runtimeStageId: this.runtimeStageId,\n    };\n\n    this.sharedMemory.applyPatch(commitBundle.overwrite, commitBundle.updates, commitBundle.trace);\n\n    // Already-computed redacted patches feed three consumers:\n    //   1. the parallel redacted mirror (if enabled)\n    //   2. the event log (persisted trace)\n    //   3. (future) anything else that wants a scrubbed view at commit time\n    // Computing once keeps cost linear in the commit size; no post-pass walk.\n    const redactedOverwrite = redactPatch(commitBundle.overwrite, commitBundle.redactedPaths);\n    const redactedUpdates = redactPatch(commitBundle.updates, commitBundle.redactedPaths);\n\n    this.redactedSharedMemory?.applyPatch(redactedOverwrite, redactedUpdates, commitBundle.trace);\n\n    this.eventLog?.record({\n      ...commitBundle,\n      redactedPaths: Array.from(commitBundle.redactedPaths.values()),\n      overwrite: redactedOverwrite,\n      updates: redactedUpdates,\n    });\n\n    // Notify observer (ScopeFacade) with tracked mutations\n    if (this._commitObserver) {\n      this._commitObserver({ ...this._stageWrites });\n    }\n  }\n\n  // ── Tree navigation ────────────────────────────────────────────────────\n\n  createNext(path: string, stageName: string, stageId: string, isDecider = false): StageContext {\n    if (!this.next) {\n      this.next = new StageContext(path, stageName, stageId, this.sharedMemory, '', this.eventLog, isDecider);\n      this.next.parent = this;\n      // Propagate the redacted mirror down the context tree so every commit\n      // in the run writes to both views.\n      if (this.redactedSharedMemory) this.next.redactedSharedMemory = this.redactedSharedMemory;\n    }\n    return this.next;\n  }\n\n  createChild(runId: string, branchId: string, stageName: string, stageId: string, isDecider = false): StageContext {\n    if (!this.children) {\n      this.children = [];\n    }\n    const child = new StageContext(runId, stageName, stageId, this.sharedMemory, branchId, this.eventLog, isDecider);\n    child.parent = this;\n    if (this.redactedSharedMemory) child.redactedSharedMemory = this.redactedSharedMemory;\n    this.children.push(child);\n    return child;\n  }\n\n  createDecider(path: string, stageName: string, stageId: string): StageContext {\n    return this.createNext(path, stageName, stageId, true);\n  }\n\n  setAsDecider(): StageContext {\n    this.isDecider = true;\n    return this;\n  }\n\n  setAsFork(): StageContext {\n    this.isFork = true;\n    return this;\n  }\n\n  // ── Diagnostics delegation ─────────────────────────────────────────────\n\n  addLog(key: string, value: unknown, path?: string[]) {\n    this.debug.addLog(key, value, path);\n  }\n\n  setLog(key: string, value: unknown, path?: string[]) {\n    this.debug.setLog(key, value, path);\n  }\n\n  addMetric(key: string, value: unknown, path?: string[]) {\n    this.debug.addMetric(key, value, path);\n  }\n\n  setMetric(key: string, value: unknown, path?: string[]) {\n    this.debug.setMetric(key, value, path);\n  }\n\n  addEval(key: string, value: unknown, path?: string[]) {\n    this.debug.addEval(key, value, path);\n  }\n\n  setEval(key: string, value: unknown, path?: string[]) {\n    this.debug.setEval(key, value, path);\n  }\n\n  addError(key: string, value: unknown, path?: string[]) {\n    this.debug.addError(key, value, path);\n  }\n\n  addFlowDebugMessage(\n    type: FlowControlType,\n    description: string,\n    options?: { targetStage?: string | string[]; rationale?: string; count?: number; iteration?: number },\n  ) {\n    const flowMessage: FlowMessage = { type, description, timestamp: Date.now(), ...options };\n    this.debug.addFlowMessage(flowMessage);\n  }\n\n  // ── Snapshot ───────────────────────────────────────────────────────────\n\n  getStageId(): string {\n    if (!this.runId || this.runId === '') return this.stageName;\n    return `${this.runId}.${this.stageName}`;\n  }\n\n  getSnapshot(): StageSnapshot {\n    const snapshot: StageSnapshot = {\n      id: this.stageId,\n      runtimeStageId: this.runtimeStageId || undefined,\n      name: this.stageName,\n      isDecider: this.isDecider,\n      isFork: this.isFork,\n      logs: this.debug.logContext,\n      errors: this.debug.errorContext,\n      metrics: this.debug.metricContext,\n      evals: this.debug.evalContext,\n    };\n    if (Object.keys(this._stageWrites).length > 0) {\n      // Extract values only for the snapshot (strip operation metadata)\n      const writes: Record<string, unknown> = {};\n      for (const [k, entry] of Object.entries(this._stageWrites)) {\n        writes[k] = entry.value;\n      }\n      snapshot.stageWrites = writes;\n    }\n    if (Object.keys(this._stageReads).length > 0) {\n      snapshot.stageReads = this._stageReads;\n    }\n    if (this.description) {\n      snapshot.description = this.description;\n    }\n    if (this.subflowId) {\n      snapshot.subflowId = this.subflowId;\n    }\n    if (this.debug.flowMessages.length > 0) {\n      snapshot.flowMessages = this.debug.flowMessages;\n    }\n    if (this.next) {\n      snapshot.next = this.next.getSnapshot();\n    }\n    if (this.children) {\n      snapshot.children = this.children.map((c) => c.getSnapshot());\n    }\n    return snapshot;\n  }\n}\n"]}