footprintjs 9.24.0 → 9.26.0

package/dist/esm/index.d.ts

@@ -219,3 +219,4 @@ export { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';
  * `enableDevMode` for the full list and usage example.
  */
 export { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';
+export { stringifySnapshot } from './lib/runner/stringifySnapshot.js';

package/dist/esm/index.js

@@ -83,4 +83,7 @@ export { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCirc
 // `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in
 // `footprintjs/zod` entry — keeping zod out of the core load path (it is an
 // optional peer). Import them from 'footprintjs/zod'.
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA6BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAYvD,oBAAoB;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAqBnD,+BAA+B;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,oCAAoC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAmC5D,qEAAqE;AACrE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAiDjC,+BAA+B;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,+BAA+B;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAEvE,+BAA+B;AAC/B,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAEzE,+BAA+B;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEpE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAyBtE,uCAAuC;AACvC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAoB5D,6BAA6B;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAiEjD,sCAAsC;AACtC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE3E,sCAAsC;AACtC,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASrG,gCAAgC;AAChC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE1E,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAEzF,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'summary'` default / `'clone'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `footprintjs/trace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\nexport type { CommitValuesMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n"]}
+// A run's record as JSON without the engine's recursion limit (9.26.0): the
+// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.
+export { stringifySnapshot } from './lib/runner/stringifySnapshot.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA6BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAYvD,oBAAoB;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAqBnD,+BAA+B;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,oCAAoC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAmC5D,qEAAqE;AACrE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAiDjC,+BAA+B;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,+BAA+B;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAEvE,+BAA+B;AAC/B,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAEzE,+BAA+B;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEpE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAyBtE,uCAAuC;AACvC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAoB5D,6BAA6B;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAiEjD,sCAAsC;AACtC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE3E,sCAAsC;AACtC,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASrG,gCAAgC;AAChC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE1E,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAEzF,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD;AACtD,4EAA4E;AAC5E,6EAA6E;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'summary'` default / `'clone'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `footprintjs/trace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\nexport type { CommitValuesMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n// A run's record as JSON without the engine's recursion limit (9.26.0): the\n// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.\nexport { stringifySnapshot } from './lib/runner/stringifySnapshot.js';\n"]}

package/dist/esm/lib/memory/utils.d.ts

@@ -221,4 +221,14 @@ export declare function supersededByNextSet(rows: readonly {
  * here; there is no second replay loop to keep in step.
  */
 export declare function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any;
+/**
+ * The same replay, INTO `target` — the one verb switch, no clone of its own.
+ * For a caller that already holds a private working copy (the read-side fold
+ * in `time-travel/stateAt.ts`, which clones its base ONCE and then applies
+ * every bundle here), so a fold over N bundles costs N row applications, not
+ * N clones of the whole state. Never hand it committed state: it mutates.
+ * The values it writes are its own (`set`/`append` clone the recorded value;
+ * `merge` builds new containers), so `target` never aliases the log.
+ */
+export declare function applySmartMergeInto(target: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any;
 export {};

package/dist/esm/lib/memory/utils.js

@@ -416,7 +416,19 @@ export function supersededByNextSet(rows, i) {
  * here; there is no second replay loop to keep in step.
  */
 export function applySmartMerge(base, updates, overwrite, trace) {
-    const out = structuredClone(base);
+    return applySmartMergeInto(structuredClone(base), updates, overwrite, trace);
+}
+/**
+ * The same replay, INTO `target` — the one verb switch, no clone of its own.
+ * For a caller that already holds a private working copy (the read-side fold
+ * in `time-travel/stateAt.ts`, which clones its base ONCE and then applies
+ * every bundle here), so a fold over N bundles costs N row applications, not
+ * N clones of the whole state. Never hand it committed state: it mutates.
+ * The values it writes are its own (`set`/`append` clone the recorded value;
+ * `merge` builds new containers), so `target` never aliases the log.
+ */
+export function applySmartMergeInto(target, updates, overwrite, trace) {
+    const out = target;
     for (let i = 0; i < trace.length; i++) {
         if (supersededByNextSet(trace, i))
             continue;
@@ -440,4 +452,4 @@ export function applySmartMerge(base, updates, overwrite, trace) {
     }
     return out;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,SAAS,IAAI,IAAI,EAAE,SAAS,IAAI,IAAI,EAAE,SAAS,IAAI,IAAI,EAAE,MAAM,cAAc,CAAC;AAGrG;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,QAAQ,CAAC;AAI9B;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc,EAAE,OAA4B,EAAE;IACjF,OAAO;QACL,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS;QACrD,UAAU,EAAE,CAAC,GAAG,IAAI,CAAC;KACtB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAC5B,GAAiB,EACjB,KAAa,EACb,KAAe,EACf,KAAa,EACb,KAAQ,EACR,aAAuB;IAEvB,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,oBAAoB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACnE,MAAM,IAAI,GAAG,OAAO,IAAI,UAAU,CAAC;IACnC,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3B,IAAI,OAAO,GAAiB,GAAG,CAAC;IAChC,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,EAAY,CAAC;QACvC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC;YACxD,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;QACrE,CAAC;QACD,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IACvB,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAC/B,GAAQ,EACR,KAAyB,EACzB,KAA0B,EAC1B,KAAsB,EACtB,KAAQ,EACR,aAAuB;IAEvB,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,oBAAoB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACnE,MAAM,IAAI,GAAG,OAAO,IAAI,UAAU,CAAC;IACnC,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3B,IAAI,OAAO,GAAiB,GAAG,CAAC;IAChC,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,EAAY,CAAC;QACvC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC;YACxD,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;QACrE,CAAC;QACD,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACnC,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CAAC,MAAW,EAAE,GAAoB,EAAE,KAAU;IACvE,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,wCAAwC;QAC/D,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAQ,CAAC;YAC/B,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;SAAM,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QAC3E,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAQ,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;IACjE,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACtB,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,IAAS,EAAE,IAAyB,EAAE,KAAuB;IAC1F,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/D,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC3D,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;QACnG,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,KAAkB,EAAE,WAAwB;IACtE,MAAM,GAAG,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YAChC,IAAI,OAAO,IAAI,KAAK,WAAW,EAAE,CAAC;gBAChC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,IAAyB;IACrD,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,UAAU,SAAS,CAAC,CAAM,EAAE,CAAM;IACtC,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;AACrC,CAAC;AAWD,SAAS,UAAU,CAAC,CAAM,EAAE,CAAM,EAAE,IAA2B;IAC7D,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,wCAAwC;IAClE,IAAI,OAAO,CAAC,KAAK,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IACxC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,+BAA+B;IAC7E,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,6BAA6B;IAEhF,uEAAuE;IACvE,4DAA4D;IAC5D,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACzC,IAAI,KAAK,KAAK,MAAM;QAAE,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAEjE,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,QAAQ,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC,CAAC,wBAAwB;IAEzE,qEAAqE;IACrE,IAAI,KAAK,IAAI,OAAO,EAAE,CAAC;IACvB,IAAI,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAI,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAClC,IAAI,CAAC,QAAQ;QAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,QAAQ,GAAG,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAEhB,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;IAClD,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;IAElD,IAAI,QAAQ,EAAE,CAAC;QACb,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAClC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;QAClD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,2EAA2E;IAC3E,yEAAyE;IACzE,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QACjC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,SAAS;YAAE,SAAS;QACnC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QAChE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;IACtD,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,SAAS;YAAE,KAAK,EAAE,CAAC;IACpE,OAAO,KAAK,KAAK,KAAK,CAAC;AACzB,CAAC;AAED,gFAAgF;AAChF,SAAS,SAAS,CAAC,KAAa;IAC9B,IAAI,KAAK,YAAY,IAAI;QAAE,OAAO,MAAM,CAAC;IACzC,IAAI,KAAK,YAAY,GAAG;QAAE,OAAO,KAAK,CAAC;IACvC,IAAI,KAAK,YAAY,GAAG;QAAE,OAAO,KAAK,CAAC;IACvC,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,SAAS,CAAC,CAAwB,EAAE,CAAwB,EAAE,IAAe;IACpF,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACpC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;IACzD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,SAAS,SAAS,CAAC,CAAe,EAAE,CAAe,EAAE,IAAe;IAClE,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACpC,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,KAAK,MAAM,MAAM,IAAI,CAAC,EAAE,CAAC;QACvB,qEAAqE;QACrE,uEAAuE;QACvE,4CAA4C;QAC5C,MAAM,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACrC,MAAM,KAAK,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;QACrG,IAAI,KAAK,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5B,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,cAAc,CAAC,GAAQ,EAAE,GAAQ;IAC/C,OAAO,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,YAAY,CAAC,GAAQ,EAAE,GAAQ,EAAE,QAA0C;IAClF,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC;IAExD,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC,CAAC,+BAA+B;QAChE,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;YAAE,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9D,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;IAClB,CAAC;IAED,IAAI,QAAQ,EAAE,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,yCAAyC;IAE3F,MAAM,GAAG,GAAQ,EAAE,GAAG,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IACpE,CAAC,QAAQ,KAAK,IAAI,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC3C,8EAA8E;IAC9E,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,GAAG,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;IACD,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAA+C,EAAE,CAAS;IAC5F,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,IAAI,GAAG,CAAC,IAAI,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IACrC,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,eAAe,CAAC,IAAS,EAAE,OAAoB,EAAE,SAAsB,EAAE,KAAmB;IAC1G,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IAClC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,mBAAmB,CAAC,KAAK,EAAE,CAAC,CAAC;YAAE,SAAS;QAC5C,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC;aAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YAChC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChG,CAAC;aAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;YACtC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * utils.ts — Helper functions for nested object manipulation\n *\n * Provides consistent path traversal and value manipulation for the memory system.\n * Zero external dependencies.\n */\n\nimport { nativeDelete, nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\n\n/**\n * The separator that joins path SEGMENTS into a `TraceEntry.path`.\n *\n * WHY NOT `'.'` — the ambiguity this exists to prevent: a state key may itself\n * CONTAIN a dot, and this library creates such keys routinely. `$setValue`\n * takes a KEY, not a path, so `$setValue('a.b', v)` makes one top-level key\n * literally named `a.b`. With a dot separator that key's path and the nested\n * path `['a', 'b']` would both encode as `\"a.b\"`, and every reader of the\n * commit log — `applySmartMerge`, `commitValueAt`, `redactPatch`,\n * `findLastWriter`, the slice layer — would have to guess which one a bundle\n * meant. Splitting the wrong way writes into (or reads from) the wrong place.\n *\n * ASCII Unit-Separator is the choice because it cannot appear in a JS\n * identifier and is vanishingly unlikely in a hand-written key, so the\n * encoding stays unambiguous. It is NOT a display character: a path rendered\n * straight to a UI or a log looks like one broken word. Split it with\n * {@link pathSegments} — that, not this constant, is the contract consumers\n * should hold.\n */\nexport const DELIM = '\\u001F';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n\n/**\n * Redacts sensitive values in a patch for logging/debugging.\n */\nexport function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch {\n  const out = structuredClone(patch);\n  for (const flat of redactedSet) {\n    const pathArr = flat.split(DELIM);\n    if (_has(out, pathArr)) {\n      const curr = _get(out, pathArr);\n      if (typeof curr !== 'undefined') {\n        _set(out, pathArr, 'REDACTED');\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Normalises an array path into a stable string key using DELIM.\n */\nexport function normalisePath(path: (string | number)[]): string {\n  return path.map(String).join(DELIM);\n}\n\n/**\n * The inverse of {@link normalisePath}: the SEGMENTS of a `TraceEntry.path`.\n *\n * A path in the commit log is DELIM-joined (see {@link DELIM}), which is not a\n * display encoding — printing one verbatim shows a single broken-looking word,\n * as a consumer rendering a path discovered. This is the supported way to take\n * it apart; the delimiter itself stays an implementation detail, so a path can\n * be read, rendered or re-joined without anyone hard-coding a control\n * character.\n *\n * A single-segment path (the common case — a top-level state key) returns a\n * one-element array, so callers need no special case.\n *\n * ```ts\n * import { pathSegments } from 'footprintjs/trace';\n *\n * for (const entry of bundle.trace) {\n *   console.log(pathSegments(entry.path).join(' › ')); // 'order › lines'\n * }\n * ```\n */\nexport function pathSegments(path: string): string[] {\n  return path.split(DELIM);\n}\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"), and by `borrowedMutation.firstDifferingPath` to find where a\n * borrowed read moved. Committed state must survive `structuredClone`, and\n * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state\n * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must\n * tell two of them apart. Before 9.22.0 it compared them as plain objects, and\n * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was \"equal\", so\n * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —\n * no trace row, state unchanged — and a `setFullYear` in place slipped past\n * the dev-mode guard.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - `Date`: same `getTime()` (two invalid dates are equal)\n *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —\n *     keys by `Map` identity (`SameValueZero`), values deep\n *   - `Set`: same size AND every member of `a` is deep-equal to SOME member\n *     of `b` (order-insensitive — a Set has no order to compare by)\n *   - a typed value against a plain value, or two different typed kinds → not\n *     equal (a `Date` is never `{}`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical set of keys that HOLD a value AND deep-equal per key.\n *     An own key whose value is `undefined` counts as ABSENT: it is this\n *     library's other spelling of a deleted key (`'full'` mode flattens\n *     `delete` into `key: undefined`; `'delta'` mode's `delete` verb removes\n *     the key), and every consumer — JSON, the fold, `commitValueAt`, the\n *     mirror — reads the two spellings as one state. So must the net-change\n *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays\n *     are untouched — a slot holding `undefined` is still a slot.\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  return equalPairs(a, b, undefined);\n}\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  // Typed arms first — a Date/Map/Set has no own enumerable keys, so the\n  // plain-object walk below would call any two of them equal.\n  const aKind = typedKind(a);\n  if (aKind !== typedKind(b)) return false;\n  if (aKind === 'date') return Object.is(a.getTime(), b.getTime());\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (aKind === 'map') return equalMaps(a, b, seen);\n  if (aKind === 'set') return equalSets(a, b, seen);\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen)) return false;\n    }\n    return true;\n  }\n\n  // Objects: only keys that HOLD a value take part — an own `undefined` is a\n  // deleted key, the same state as an absent one (see the contract above).\n  let aHeld = 0;\n  for (const key of Object.keys(a)) {\n    if (a[key] === undefined) continue;\n    aHeld++;\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen)) return false;\n  }\n  let bHeld = 0;\n  for (const key of Object.keys(b)) if (b[key] !== undefined) bHeld++;\n  return aHeld === bHeld;\n}\n\n/** The typed state values `structuredClone` keeps and a key walk cannot see. */\nfunction typedKind(value: object): 'date' | 'map' | 'set' | undefined {\n  if (value instanceof Date) return 'date';\n  if (value instanceof Map) return 'map';\n  if (value instanceof Set) return 'set';\n  return undefined;\n}\n\nfunction equalMaps(a: Map<unknown, unknown>, b: Map<unknown, unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  for (const [key, value] of a) {\n    if (!b.has(key)) return false;\n    if (!equalPairs(value, b.get(key), seen)) return false;\n  }\n  return true;\n}\n\n/**\n * Order-insensitive, deep per member. Quadratic in the worst case for sets of\n * objects — a set of primitives (the common shape) is one `has` per member.\n */\nfunction equalSets(a: Set<unknown>, b: Set<unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  const unmatched = [...b];\n  for (const member of a) {\n    // SameValueZero first — primitives and shared references, one `has`.\n    // Each match retires its slot so two structurally-equal members of `a`\n    // cannot both claim the same member of `b`.\n    const at = unmatched.indexOf(member);\n    const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen));\n    if (found < 0) return false;\n    unmatched.splice(found, 1);\n  }\n  return true;\n}\n\n/**\n * Deep union merge helper.\n * - Arrays (non-empty): union without duplicates (encounter order preserved)\n * - Arrays (empty):     replace — src `[]` clears the destination array.\n *   Rationale: writing `scope.tags = []` means \"clear tags\", not \"append nothing\".\n *   Without this rule, an empty-array write silently becomes a no-op which is\n *   impossible to distinguish from a bug.\n * - Objects: recursive merge\n * - Primitives: source wins\n *\n * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a\n * state value survives `structuredClone`, which preserves cycles). A `src`\n * object re-entered while it is still being merged higher up the stack hands\n * back the output being built for it, so the merged value mirrors the cycle\n * instead of unrolling it forever. Only the ancestors on the stack are\n * guarded — a shared (acyclic) `src` reference met again at a different\n * `dst` merges against THAT `dst`, exactly as before.\n */\nexport function deepSmartMerge(dst: any, src: any): any {\n  return mergeGuarded(dst, src, undefined);\n}\n\nfunction mergeGuarded(dst: any, src: any, inFlight: WeakMap<object, any> | undefined): any {\n  if (src === null || typeof src !== 'object') return src;\n\n  if (Array.isArray(src)) {\n    if (src.length === 0) return []; // empty src = clear, not no-op\n    if (Array.isArray(dst)) return [...new Set([...dst, ...src])];\n    return [...src];\n  }\n\n  if (inFlight?.has(src)) return inFlight.get(src); // cycle — re-enter the value being built\n\n  const out: any = { ...(dst && typeof dst === 'object' ? dst : {}) };\n  (inFlight ??= new WeakMap()).set(src, out);\n  // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.\n  for (const k of Object.keys(src)) {\n    out[k] = mergeGuarded(out[k], src[k], inFlight);\n  }\n  inFlight.delete(src);\n  return out;\n}\n\n/**\n * Is row `i` a `set` that the NEXT row sets again — same path, same verb — so\n * that applying it is work the next row redoes?\n *\n * The one skip every replay iterator shares (9.22.1). A `set` row writes a\n * clone of the recorded value at its path; the next row, a `set` of the same\n * path, writes a clone of the SAME recorded value over it (the bundle's patch\n * tree is fixed), and nothing runs in between — so the first write is\n * unobservable, container creation and key order included. Only CONSECUTIVE\n * rows qualify: a row in between (an ancestor `merge`, a sibling `set` that\n * creates a container) can see the intermediate value, and a `merge`,\n * `append` or `delete` next row depends on what is there. Rows are never\n * dropped from the log — the 9.22.0 element-write funnel records N\n * whole-array `set` rows on one path, and this is what makes replaying them\n * O(N) instead of O(N × rows).\n *\n * Shared by {@link applySmartMerge} (live state, `EventLog.materialise`,\n * `stateAt`, the redacted mirror) and `TransactionBuffer.replayFamilyVerbs`\n * (the delta encoder's per-family fold) — the two loops that clone per row.\n * `commitValueAt` needs no skip: it anchors at the LAST `set` by construction.\n */\nexport function supersededByNextSet(rows: readonly { path: string; verb: string }[], i: number): boolean {\n  const row = rows[i];\n  if (row.verb !== 'set') return false;\n  const next = rows[i + 1];\n  return next !== undefined && next.verb === 'set' && next.path === row.path;\n}\n\n/**\n * Applies a commit bundle to a base state by replaying operations in order.\n * Guarantees \"last writer wins\" semantics.\n *\n * The single replay primitive — three consumers inherit every verb from it:\n * live state (`SharedMemory.applyPatch`), time travel\n * (`EventLog.materialise`), and the redacted mirror\n * (`StageContext.commit`'s second `applyPatch`).\n *\n * Verb arms:\n *   - `'set'`    — overwrite with `overwrite[path]` (the full final value).\n *   - `'merge'`  — `deepSmartMerge` the accumulated `updates[path]` delta in.\n *   - `'append'` — (#13c-B delta mode) `overwrite[path]` holds ONLY the tail;\n *     reconstruct by concatenating it onto the current array. When the\n *     current value or the recorded tail is not an array (out-of-order\n *     replay base, or a REDACTED tail — `redactPatch` replaces matched\n *     payloads with the `'REDACTED'` string), degrade to a direct set of the\n *     recorded value — the same terminal value a redacted/corrupt `'set'`\n *     produces.\n *   - `'delete'` — (#13c-B delta mode) remove the key (`nativeDelete`,\n *     prototype-pollution-safe). The path stays enumerated in `overwrite`\n *     (value `undefined`) for key-set consumers; replay ignores that value.\n *\n * Work, not bytes (9.22.1): a `set` row the NEXT row re-sets is skipped\n * ({@link supersededByNextSet}) — the rows stay in the log, only the clone\n * each would have paid is not. Every consumer above inherits the skip from\n * here; there is no second replay loop to keep in step.\n */\nexport function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any {\n  const out = structuredClone(base);\n  for (let i = 0; i < trace.length; i++) {\n    if (supersededByNextSet(trace, i)) continue;\n    const { path, verb } = trace[i];\n    const segs = path.split(DELIM);\n    if (verb === 'set') {\n      _set(out, segs, structuredClone(_get(overwrite, segs)));\n    } else if (verb === 'append') {\n      const tail = structuredClone(_get(overwrite, segs));\n      const current = _get(out, segs);\n      _set(out, segs, Array.isArray(current) && Array.isArray(tail) ? [...current, ...tail] : tail);\n    } else if (verb === 'delete') {\n      nativeDelete(out, segs);\n    } else {\n      const current = _get(out, segs) ?? {};\n      _set(out, segs, deepSmartMerge(current, _get(updates, segs)));\n    }\n  }\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — Helper functions for nested object manipulation\n *\n * Provides consistent path traversal and value manipulation for the memory system.\n * Zero external dependencies.\n */\n\nimport { nativeDelete, nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\n\n/**\n * The separator that joins path SEGMENTS into a `TraceEntry.path`.\n *\n * WHY NOT `'.'` — the ambiguity this exists to prevent: a state key may itself\n * CONTAIN a dot, and this library creates such keys routinely. `$setValue`\n * takes a KEY, not a path, so `$setValue('a.b', v)` makes one top-level key\n * literally named `a.b`. With a dot separator that key's path and the nested\n * path `['a', 'b']` would both encode as `\"a.b\"`, and every reader of the\n * commit log — `applySmartMerge`, `commitValueAt`, `redactPatch`,\n * `findLastWriter`, the slice layer — would have to guess which one a bundle\n * meant. Splitting the wrong way writes into (or reads from) the wrong place.\n *\n * ASCII Unit-Separator is the choice because it cannot appear in a JS\n * identifier and is vanishingly unlikely in a hand-written key, so the\n * encoding stays unambiguous. It is NOT a display character: a path rendered\n * straight to a UI or a log looks like one broken word. Split it with\n * {@link pathSegments} — that, not this constant, is the contract consumers\n * should hold.\n */\nexport const DELIM = '\\u001F';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n\n/**\n * Redacts sensitive values in a patch for logging/debugging.\n */\nexport function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch {\n  const out = structuredClone(patch);\n  for (const flat of redactedSet) {\n    const pathArr = flat.split(DELIM);\n    if (_has(out, pathArr)) {\n      const curr = _get(out, pathArr);\n      if (typeof curr !== 'undefined') {\n        _set(out, pathArr, 'REDACTED');\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Normalises an array path into a stable string key using DELIM.\n */\nexport function normalisePath(path: (string | number)[]): string {\n  return path.map(String).join(DELIM);\n}\n\n/**\n * The inverse of {@link normalisePath}: the SEGMENTS of a `TraceEntry.path`.\n *\n * A path in the commit log is DELIM-joined (see {@link DELIM}), which is not a\n * display encoding — printing one verbatim shows a single broken-looking word,\n * as a consumer rendering a path discovered. This is the supported way to take\n * it apart; the delimiter itself stays an implementation detail, so a path can\n * be read, rendered or re-joined without anyone hard-coding a control\n * character.\n *\n * A single-segment path (the common case — a top-level state key) returns a\n * one-element array, so callers need no special case.\n *\n * ```ts\n * import { pathSegments } from 'footprintjs/trace';\n *\n * for (const entry of bundle.trace) {\n *   console.log(pathSegments(entry.path).join(' › ')); // 'order › lines'\n * }\n * ```\n */\nexport function pathSegments(path: string): string[] {\n  return path.split(DELIM);\n}\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"), and by `borrowedMutation.firstDifferingPath` to find where a\n * borrowed read moved. Committed state must survive `structuredClone`, and\n * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state\n * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must\n * tell two of them apart. Before 9.22.0 it compared them as plain objects, and\n * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was \"equal\", so\n * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —\n * no trace row, state unchanged — and a `setFullYear` in place slipped past\n * the dev-mode guard.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - `Date`: same `getTime()` (two invalid dates are equal)\n *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —\n *     keys by `Map` identity (`SameValueZero`), values deep\n *   - `Set`: same size AND every member of `a` is deep-equal to SOME member\n *     of `b` (order-insensitive — a Set has no order to compare by)\n *   - a typed value against a plain value, or two different typed kinds → not\n *     equal (a `Date` is never `{}`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical set of keys that HOLD a value AND deep-equal per key.\n *     An own key whose value is `undefined` counts as ABSENT: it is this\n *     library's other spelling of a deleted key (`'full'` mode flattens\n *     `delete` into `key: undefined`; `'delta'` mode's `delete` verb removes\n *     the key), and every consumer — JSON, the fold, `commitValueAt`, the\n *     mirror — reads the two spellings as one state. So must the net-change\n *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays\n *     are untouched — a slot holding `undefined` is still a slot.\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  return equalPairs(a, b, undefined);\n}\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  // Typed arms first — a Date/Map/Set has no own enumerable keys, so the\n  // plain-object walk below would call any two of them equal.\n  const aKind = typedKind(a);\n  if (aKind !== typedKind(b)) return false;\n  if (aKind === 'date') return Object.is(a.getTime(), b.getTime());\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (aKind === 'map') return equalMaps(a, b, seen);\n  if (aKind === 'set') return equalSets(a, b, seen);\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen)) return false;\n    }\n    return true;\n  }\n\n  // Objects: only keys that HOLD a value take part — an own `undefined` is a\n  // deleted key, the same state as an absent one (see the contract above).\n  let aHeld = 0;\n  for (const key of Object.keys(a)) {\n    if (a[key] === undefined) continue;\n    aHeld++;\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen)) return false;\n  }\n  let bHeld = 0;\n  for (const key of Object.keys(b)) if (b[key] !== undefined) bHeld++;\n  return aHeld === bHeld;\n}\n\n/** The typed state values `structuredClone` keeps and a key walk cannot see. */\nfunction typedKind(value: object): 'date' | 'map' | 'set' | undefined {\n  if (value instanceof Date) return 'date';\n  if (value instanceof Map) return 'map';\n  if (value instanceof Set) return 'set';\n  return undefined;\n}\n\nfunction equalMaps(a: Map<unknown, unknown>, b: Map<unknown, unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  for (const [key, value] of a) {\n    if (!b.has(key)) return false;\n    if (!equalPairs(value, b.get(key), seen)) return false;\n  }\n  return true;\n}\n\n/**\n * Order-insensitive, deep per member. Quadratic in the worst case for sets of\n * objects — a set of primitives (the common shape) is one `has` per member.\n */\nfunction equalSets(a: Set<unknown>, b: Set<unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  const unmatched = [...b];\n  for (const member of a) {\n    // SameValueZero first — primitives and shared references, one `has`.\n    // Each match retires its slot so two structurally-equal members of `a`\n    // cannot both claim the same member of `b`.\n    const at = unmatched.indexOf(member);\n    const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen));\n    if (found < 0) return false;\n    unmatched.splice(found, 1);\n  }\n  return true;\n}\n\n/**\n * Deep union merge helper.\n * - Arrays (non-empty): union without duplicates (encounter order preserved)\n * - Arrays (empty):     replace — src `[]` clears the destination array.\n *   Rationale: writing `scope.tags = []` means \"clear tags\", not \"append nothing\".\n *   Without this rule, an empty-array write silently becomes a no-op which is\n *   impossible to distinguish from a bug.\n * - Objects: recursive merge\n * - Primitives: source wins\n *\n * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a\n * state value survives `structuredClone`, which preserves cycles). A `src`\n * object re-entered while it is still being merged higher up the stack hands\n * back the output being built for it, so the merged value mirrors the cycle\n * instead of unrolling it forever. Only the ancestors on the stack are\n * guarded — a shared (acyclic) `src` reference met again at a different\n * `dst` merges against THAT `dst`, exactly as before.\n */\nexport function deepSmartMerge(dst: any, src: any): any {\n  return mergeGuarded(dst, src, undefined);\n}\n\nfunction mergeGuarded(dst: any, src: any, inFlight: WeakMap<object, any> | undefined): any {\n  if (src === null || typeof src !== 'object') return src;\n\n  if (Array.isArray(src)) {\n    if (src.length === 0) return []; // empty src = clear, not no-op\n    if (Array.isArray(dst)) return [...new Set([...dst, ...src])];\n    return [...src];\n  }\n\n  if (inFlight?.has(src)) return inFlight.get(src); // cycle — re-enter the value being built\n\n  const out: any = { ...(dst && typeof dst === 'object' ? dst : {}) };\n  (inFlight ??= new WeakMap()).set(src, out);\n  // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.\n  for (const k of Object.keys(src)) {\n    out[k] = mergeGuarded(out[k], src[k], inFlight);\n  }\n  inFlight.delete(src);\n  return out;\n}\n\n/**\n * Is row `i` a `set` that the NEXT row sets again — same path, same verb — so\n * that applying it is work the next row redoes?\n *\n * The one skip every replay iterator shares (9.22.1). A `set` row writes a\n * clone of the recorded value at its path; the next row, a `set` of the same\n * path, writes a clone of the SAME recorded value over it (the bundle's patch\n * tree is fixed), and nothing runs in between — so the first write is\n * unobservable, container creation and key order included. Only CONSECUTIVE\n * rows qualify: a row in between (an ancestor `merge`, a sibling `set` that\n * creates a container) can see the intermediate value, and a `merge`,\n * `append` or `delete` next row depends on what is there. Rows are never\n * dropped from the log — the 9.22.0 element-write funnel records N\n * whole-array `set` rows on one path, and this is what makes replaying them\n * O(N) instead of O(N × rows).\n *\n * Shared by {@link applySmartMerge} (live state, `EventLog.materialise`,\n * `stateAt`, the redacted mirror) and `TransactionBuffer.replayFamilyVerbs`\n * (the delta encoder's per-family fold) — the two loops that clone per row.\n * `commitValueAt` needs no skip: it anchors at the LAST `set` by construction.\n */\nexport function supersededByNextSet(rows: readonly { path: string; verb: string }[], i: number): boolean {\n  const row = rows[i];\n  if (row.verb !== 'set') return false;\n  const next = rows[i + 1];\n  return next !== undefined && next.verb === 'set' && next.path === row.path;\n}\n\n/**\n * Applies a commit bundle to a base state by replaying operations in order.\n * Guarantees \"last writer wins\" semantics.\n *\n * The single replay primitive — three consumers inherit every verb from it:\n * live state (`SharedMemory.applyPatch`), time travel\n * (`EventLog.materialise`), and the redacted mirror\n * (`StageContext.commit`'s second `applyPatch`).\n *\n * Verb arms:\n *   - `'set'`    — overwrite with `overwrite[path]` (the full final value).\n *   - `'merge'`  — `deepSmartMerge` the accumulated `updates[path]` delta in.\n *   - `'append'` — (#13c-B delta mode) `overwrite[path]` holds ONLY the tail;\n *     reconstruct by concatenating it onto the current array. When the\n *     current value or the recorded tail is not an array (out-of-order\n *     replay base, or a REDACTED tail — `redactPatch` replaces matched\n *     payloads with the `'REDACTED'` string), degrade to a direct set of the\n *     recorded value — the same terminal value a redacted/corrupt `'set'`\n *     produces.\n *   - `'delete'` — (#13c-B delta mode) remove the key (`nativeDelete`,\n *     prototype-pollution-safe). The path stays enumerated in `overwrite`\n *     (value `undefined`) for key-set consumers; replay ignores that value.\n *\n * Work, not bytes (9.22.1): a `set` row the NEXT row re-sets is skipped\n * ({@link supersededByNextSet}) — the rows stay in the log, only the clone\n * each would have paid is not. Every consumer above inherits the skip from\n * here; there is no second replay loop to keep in step.\n */\nexport function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any {\n  return applySmartMergeInto(structuredClone(base), updates, overwrite, trace);\n}\n\n/**\n * The same replay, INTO `target` — the one verb switch, no clone of its own.\n * For a caller that already holds a private working copy (the read-side fold\n * in `time-travel/stateAt.ts`, which clones its base ONCE and then applies\n * every bundle here), so a fold over N bundles costs N row applications, not\n * N clones of the whole state. Never hand it committed state: it mutates.\n * The values it writes are its own (`set`/`append` clone the recorded value;\n * `merge` builds new containers), so `target` never aliases the log.\n */\nexport function applySmartMergeInto(\n  target: any,\n  updates: MemoryPatch,\n  overwrite: MemoryPatch,\n  trace: TraceEntry[],\n): any {\n  const out = target;\n  for (let i = 0; i < trace.length; i++) {\n    if (supersededByNextSet(trace, i)) continue;\n    const { path, verb } = trace[i];\n    const segs = path.split(DELIM);\n    if (verb === 'set') {\n      _set(out, segs, structuredClone(_get(overwrite, segs)));\n    } else if (verb === 'append') {\n      const tail = structuredClone(_get(overwrite, segs));\n      const current = _get(out, segs);\n      _set(out, segs, Array.isArray(current) && Array.isArray(tail) ? [...current, ...tail] : tail);\n    } else if (verb === 'delete') {\n      nativeDelete(out, segs);\n    } else {\n      const current = _get(out, segs) ?? {};\n      _set(out, segs, deepSmartMerge(current, _get(updates, segs)));\n    }\n  }\n  return out;\n}\n"]}

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

@@ -0,0 +1,21 @@
+/**
+ * stringifySnapshot — `JSON.stringify` for a run's record, without the
+ * engine's recursion limit.
+ *
+ * WHY. A run's `executionTree` links stages by `next`, one level per stage,
+ * so a long linear run is a deep chain. V8's `JSON.parse` reads a chain ten
+ * thousand levels deep (measured), but `JSON.stringify` is recursive and
+ * throws `RangeError: Maximum call stack size exceeded` well before that —
+ * the record of such a run could not be saved as one artifact. This encoder
+ * walks with its own stack and emits the SAME bytes `JSON.stringify` would
+ * (pinned byte-for-byte by test/lib/runner/stringifySnapshot.test.ts, on real
+ * snapshots and on a fast-check property over JSON values), so nothing that
+ * reads a record changes: the shape stays nested, `JSON.parse` reads it.
+ *
+ * Same contract as `JSON.stringify(value)` with no replacer and no indent:
+ * `toJSON` is honoured, `undefined` / functions / symbols vanish from objects
+ * and become `null` in arrays, non-finite numbers become `null`, a BigInt or
+ * a cycle throws the same `TypeError`. Use it wherever a record is written —
+ * a recording, an artifact, a fixture — in place of `JSON.stringify`.
+ */
+export declare function stringifySnapshot(root: unknown): string;

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

@@ -0,0 +1,122 @@
+/**
+ * stringifySnapshot — `JSON.stringify` for a run's record, without the
+ * engine's recursion limit.
+ *
+ * WHY. A run's `executionTree` links stages by `next`, one level per stage,
+ * so a long linear run is a deep chain. V8's `JSON.parse` reads a chain ten
+ * thousand levels deep (measured), but `JSON.stringify` is recursive and
+ * throws `RangeError: Maximum call stack size exceeded` well before that —
+ * the record of such a run could not be saved as one artifact. This encoder
+ * walks with its own stack and emits the SAME bytes `JSON.stringify` would
+ * (pinned byte-for-byte by test/lib/runner/stringifySnapshot.test.ts, on real
+ * snapshots and on a fast-check property over JSON values), so nothing that
+ * reads a record changes: the shape stays nested, `JSON.parse` reads it.
+ *
+ * Same contract as `JSON.stringify(value)` with no replacer and no indent:
+ * `toJSON` is honoured, `undefined` / functions / symbols vanish from objects
+ * and become `null` in arrays, non-finite numbers become `null`, a BigInt or
+ * a cycle throws the same `TypeError`. Use it wherever a record is written —
+ * a recording, an artifact, a fixture — in place of `JSON.stringify`.
+ */
+/** `value` as JSON.stringify would see it at `key`: after `toJSON`, or absent. */
+function seen(value, key) {
+    if (value !== null && (typeof value === 'object' || typeof value === 'function')) {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function')
+            value = toJSON.call(value, key);
+    }
+    return value;
+}
+function absent(value) {
+    return value === undefined || typeof value === 'function' || typeof value === 'symbol';
+}
+export function stringifySnapshot(root) {
+    const out = [];
+    const stack = [];
+    const ancestors = new Set();
+    // Emit a scalar, or open a container and push its frame. `value` is already `seen`.
+    const emit = (value) => {
+        if (value === null) {
+            out.push('null');
+            return;
+        }
+        switch (typeof value) {
+            case 'string':
+                out.push(JSON.stringify(value));
+                return;
+            case 'number':
+                out.push(Number.isFinite(value) ? String(value) : 'null');
+                return;
+            case 'boolean':
+                out.push(value ? 'true' : 'false');
+                return;
+            case 'bigint':
+                throw new TypeError('Do not know how to serialize a BigInt');
+            case 'object': {
+                if (ancestors.has(value))
+                    throw new TypeError('Converting circular structure to JSON');
+                ancestors.add(value);
+                if (Array.isArray(value)) {
+                    out.push('[');
+                    stack.push({ kind: 'array', value, index: 0 });
+                }
+                else {
+                    out.push('{');
+                    stack.push({
+                        kind: 'object',
+                        value: value,
+                        keys: Object.keys(value),
+                        index: 0,
+                        first: true,
+                    });
+                }
+                return;
+            }
+            default:
+                // undefined / function / symbol at a place that must hold a value
+                out.push('null');
+        }
+    };
+    const top = seen(root, '');
+    if (absent(top))
+        return undefined;
+    emit(top);
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        if (frame.kind === 'array') {
+            if (frame.index >= frame.value.length) {
+                out.push(']');
+                ancestors.delete(frame.value);
+                stack.pop();
+                continue;
+            }
+            if (frame.index > 0)
+                out.push(',');
+            const element = seen(frame.value[frame.index], String(frame.index));
+            frame.index += 1;
+            emit(absent(element) ? null : element);
+            continue;
+        }
+        // object
+        let advanced = false;
+        while (frame.index < frame.keys.length) {
+            const key = frame.keys[frame.index];
+            frame.index += 1;
+            const value = seen(frame.value[key], key);
+            if (absent(value))
+                continue;
+            out.push(frame.first ? JSON.stringify(key) + ':' : ',' + JSON.stringify(key) + ':');
+            frame.first = false;
+            emit(value);
+            advanced = true;
+            break;
+        }
+        if (!advanced) {
+            out.push('}');
+            ancestors.delete(frame.value);
+            stack.pop();
+        }
+    }
+    return out.join('');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stringifySnapshot.js","sourceRoot":"","sources":["../../../../src/lib/runner/stringifySnapshot.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * stringifySnapshot — `JSON.stringify` for a run's record, without the\n * engine's recursion limit.\n *\n * WHY. A run's `executionTree` links stages by `next`, one level per stage,\n * so a long linear run is a deep chain. V8's `JSON.parse` reads a chain ten\n * thousand levels deep (measured), but `JSON.stringify` is recursive and\n * throws `RangeError: Maximum call stack size exceeded` well before that —\n * the record of such a run could not be saved as one artifact. This encoder\n * walks with its own stack and emits the SAME bytes `JSON.stringify` would\n * (pinned byte-for-byte by test/lib/runner/stringifySnapshot.test.ts, on real\n * snapshots and on a fast-check property over JSON values), so nothing that\n * reads a record changes: the shape stays nested, `JSON.parse` reads it.\n *\n * Same contract as `JSON.stringify(value)` with no replacer and no indent:\n * `toJSON` is honoured, `undefined` / functions / symbols vanish from objects\n * and become `null` in arrays, non-finite numbers become `null`, a BigInt or\n * a cycle throws the same `TypeError`. Use it wherever a record is written —\n * a recording, an artifact, a fixture — in place of `JSON.stringify`.\n */\n\ntype Frame =\n  | { readonly kind: 'array'; readonly value: readonly unknown[]; index: number }\n  | {\n      readonly kind: 'object';\n      readonly value: Record<string, unknown>;\n      readonly keys: readonly string[];\n      index: number;\n      first: boolean;\n    };\n\n/** `value` as JSON.stringify would see it at `key`: after `toJSON`, or absent. */\nfunction seen(value: unknown, key: string): unknown {\n  if (value !== null && (typeof value === 'object' || typeof value === 'function')) {\n    const toJSON = (value as { toJSON?: unknown }).toJSON;\n    if (typeof toJSON === 'function') value = (toJSON as (k: string) => unknown).call(value, key);\n  }\n  return value;\n}\n\nfunction absent(value: unknown): boolean {\n  return value === undefined || typeof value === 'function' || typeof value === 'symbol';\n}\n\nexport function stringifySnapshot(root: unknown): string {\n  const out: string[] = [];\n  const stack: Frame[] = [];\n  const ancestors = new Set<object>();\n\n  // Emit a scalar, or open a container and push its frame. `value` is already `seen`.\n  const emit = (value: unknown): void => {\n    if (value === null) {\n      out.push('null');\n      return;\n    }\n    switch (typeof value) {\n      case 'string':\n        out.push(JSON.stringify(value));\n        return;\n      case 'number':\n        out.push(Number.isFinite(value) ? String(value) : 'null');\n        return;\n      case 'boolean':\n        out.push(value ? 'true' : 'false');\n        return;\n      case 'bigint':\n        throw new TypeError('Do not know how to serialize a BigInt');\n      case 'object': {\n        if (ancestors.has(value as object)) throw new TypeError('Converting circular structure to JSON');\n        ancestors.add(value as object);\n        if (Array.isArray(value)) {\n          out.push('[');\n          stack.push({ kind: 'array', value, index: 0 });\n        } else {\n          out.push('{');\n          stack.push({\n            kind: 'object',\n            value: value as Record<string, unknown>,\n            keys: Object.keys(value as object),\n            index: 0,\n            first: true,\n          });\n        }\n        return;\n      }\n      default:\n        // undefined / function / symbol at a place that must hold a value\n        out.push('null');\n    }\n  };\n\n  const top = seen(root, '');\n  if (absent(top)) return undefined as unknown as string;\n  emit(top);\n\n  while (stack.length > 0) {\n    const frame = stack[stack.length - 1]!;\n    if (frame.kind === 'array') {\n      if (frame.index >= frame.value.length) {\n        out.push(']');\n        ancestors.delete(frame.value);\n        stack.pop();\n        continue;\n      }\n      if (frame.index > 0) out.push(',');\n      const element = seen(frame.value[frame.index], String(frame.index));\n      frame.index += 1;\n      emit(absent(element) ? null : element);\n      continue;\n    }\n    // object\n    let advanced = false;\n    while (frame.index < frame.keys.length) {\n      const key = frame.keys[frame.index]!;\n      frame.index += 1;\n      const value = seen(frame.value[key], key);\n      if (absent(value)) continue;\n      out.push(frame.first ? JSON.stringify(key) + ':' : ',' + JSON.stringify(key) + ':');\n      frame.first = false;\n      emit(value);\n      advanced = true;\n      break;\n    }\n    if (!advanced) {\n      out.push('}');\n      ancestors.delete(frame.value);\n      stack.pop();\n    }\n  }\n  return out.join('');\n}\n"]}

package/dist/esm/lib/time-travel/stateAt.d.ts

@@ -35,6 +35,32 @@ export declare function readSource(source: FoldSource | undefined): ReadSource;
  * With a single leg this is the 9.17.0 fold, unchanged.
  */
 export declare function foldLegs(legs: readonly ReadSource[], legIdx: number, through: number): FoldedState;
+/**
+ * What a fold leaves behind for the NEXT one (9.25.0): the private working
+ * copy and the facts accumulated so far. A cursor stepping forward on the
+ * same leg hands it back and only the bundles after `through` are applied —
+ * one bundle per step instead of a replay from the base. Any other ask (an
+ * earlier stop, another leg) folds from scratch; the memo is never a claim.
+ */
+export interface FoldMemo {
+    readonly legIdx: number;
+    readonly through: number;
+    readonly out: Record<string, unknown>;
+    readonly based: boolean;
+    readonly redactedPaths: ReadonlySet<string>;
+    readonly skipped: readonly LogGap[] | undefined;
+}
+/**
+ * The fold, resumable. ONE clone per fold: the base is cloned once (or `{}`
+ * stands in), every bundle is applied INTO that copy, and the state handed
+ * out is one more clone, frozen — so the working copy stays private and a
+ * later step can continue from it. Same answer as the 9.17.0 fold, pinned by
+ * test/lib/time-travel/fold-memo.test.ts against a fresh fold at every stop.
+ */
+export declare function foldLegsFrom(legs: readonly ReadSource[], legIdx: number, through: number, memo?: FoldMemo): {
+    readonly folded: FoldedState;
+    readonly memo: FoldMemo;
+};
 /**
  * Fold `source`'s log from its base up to and including `commitIdx`.
  *