footprintjs 9.3.0 → 9.5.0

package/dist/esm/lib/observer-queue/ring.js

@@ -0,0 +1,122 @@
+/**
+ * observer-queue/ring.ts — RFC-001 Block 2: bounded ring with overflow policies.
+ *
+ * Pattern:  Fixed-capacity circular buffer with explicit, COUNTED overflow
+ *           behavior. The deferred-observer queue must never grow without
+ *           bound (a slow consumer cannot OOM the producer), and must never
+ *           lose an event silently (every loss increments `drops`).
+ * Role:     Storage primitive under the merged queue (Block 3). Pure data
+ *           structure — zero imports, zero engine knowledge, generic over T.
+ *
+ * Overflow policies (RFC-001 §5, with the accepted 'block' resolution):
+ *   - `'drop-oldest'` — evict the oldest queued item to admit the new one.
+ *     The evicted item is LOST (`drops`++) and returned on the push result
+ *     so the caller can account for it. Sequence stamps on surviving items
+ *     keep loss visible as seq gaps (honest loss accounting). DEFAULT
+ *     posture for telemetry-grade delivery.
+ *   - `'sample'` — while saturated, admit 1 in `sampleEvery` arrivals
+ *     (evicting the oldest to make room — that eviction is also a counted
+ *     loss); refuse the rest (each a counted loss). Keeps a thinned,
+ *     still-fresh stream under sustained overload. The saturation counter
+ *     is episode-scoped: it resets whenever a push succeeds through the
+ *     non-full path.
+ *   - `'block'` — the ring REFUSES the new item (`accepted: false`,
+ *     `rejections`++) and drops NOTHING. In a single-threaded runtime a
+ *     queue cannot literally block its producer; the dispatcher (Block 5)
+ *     interprets a refusal as "deliver this event synchronously inline" —
+ *     re-introducing blocking delivery by the consumer's EXPLICIT choice.
+ *     Rejections are NOT losses: the event is still delivered (inline), so
+ *     `drops` stays untouched.
+ *
+ * Conservation invariant (property-tested):
+ *   pushes === delivered + drops + rejections + size
+ *
+ * CURSOR-READY (amendment A2): v1 consumes destructively through ONE cursor
+ * (`shift()` advances `head`). The designed v1.1 path keeps items in the
+ * ring and gives each listener its own read cursor; `head` then advances to
+ * `min(cursors)` (the reclaim watermark) instead of on read. The storage
+ * layout (contiguous circular window, `head` + `count`) already supports
+ * that — only the consumption surface changes. Documented, not implemented.
+ */
+const DEFAULT_SAMPLE_EVERY = 10;
+export class BoundedRing {
+    buffer;
+    policy;
+    sampleEvery;
+    /** Index of the oldest queued item — the single v1 cursor (see header). */
+    head = 0;
+    count = 0;
+    /** Arrivals seen while saturated in the current episode (`'sample'`). */
+    saturatedArrivals = 0;
+    pushes = 0;
+    delivered = 0;
+    drops = 0;
+    rejections = 0;
+    constructor(opts) {
+        if (!Number.isInteger(opts.capacity) || opts.capacity <= 0) {
+            throw new RangeError(`BoundedRing capacity must be a positive integer (got ${opts.capacity})`);
+        }
+        const sampleEvery = opts.sampleEvery ?? DEFAULT_SAMPLE_EVERY;
+        if (!Number.isInteger(sampleEvery) || sampleEvery <= 0) {
+            throw new RangeError(`BoundedRing sampleEvery must be a positive integer (got ${opts.sampleEvery})`);
+        }
+        this.buffer = new Array(opts.capacity);
+        this.policy = opts.policy;
+        this.sampleEvery = sampleEvery;
+    }
+    get size() {
+        return this.count;
+    }
+    get capacity() {
+        return this.buffer.length;
+    }
+    /** Lifetime counters — see {@link RingCounters}. */
+    getCounters() {
+        return { pushes: this.pushes, delivered: this.delivered, drops: this.drops, rejections: this.rejections };
+    }
+    /** Admit, evict-and-admit, refuse, or sample per policy — never throws. */
+    push(item) {
+        this.pushes += 1;
+        if (this.count < this.buffer.length) {
+            this.saturatedArrivals = 0; // new saturation episode starts fresh
+            this.store(item);
+            return { accepted: true };
+        }
+        if (this.policy === 'block') {
+            this.rejections += 1;
+            return { accepted: false };
+        }
+        if (this.policy === 'sample') {
+            this.saturatedArrivals += 1;
+            if (this.saturatedArrivals % this.sampleEvery !== 0) {
+                this.drops += 1; // the incoming item is sampled out — lost
+                return { accepted: false };
+            }
+            // The 1-in-N admission falls through to evict-and-store.
+        }
+        // 'drop-oldest' (and the 'sample' admission): evict the oldest — lost.
+        const evicted = this.buffer[this.head];
+        this.buffer[this.head] = undefined;
+        this.head = (this.head + 1) % this.buffer.length;
+        this.count -= 1;
+        this.drops += 1;
+        this.store(item);
+        return { accepted: true, evicted };
+    }
+    /** Pop the oldest queued item (FIFO). `undefined` when empty. */
+    shift() {
+        if (this.count === 0)
+            return undefined;
+        const item = this.buffer[this.head];
+        this.buffer[this.head] = undefined; // release the reference for GC
+        this.head = (this.head + 1) % this.buffer.length;
+        this.count -= 1;
+        this.delivered += 1;
+        return item;
+    }
+    store(item) {
+        this.buffer[(this.head + this.count) % this.buffer.length] = item;
+        this.count += 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ring.js","sourceRoot":"","sources":["../../../../src/lib/observer-queue/ring.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * observer-queue/ring.ts — RFC-001 Block 2: bounded ring with overflow policies.\n *\n * Pattern:  Fixed-capacity circular buffer with explicit, COUNTED overflow\n *           behavior. The deferred-observer queue must never grow without\n *           bound (a slow consumer cannot OOM the producer), and must never\n *           lose an event silently (every loss increments `drops`).\n * Role:     Storage primitive under the merged queue (Block 3). Pure data\n *           structure — zero imports, zero engine knowledge, generic over T.\n *\n * Overflow policies (RFC-001 §5, with the accepted 'block' resolution):\n *   - `'drop-oldest'` — evict the oldest queued item to admit the new one.\n *     The evicted item is LOST (`drops`++) and returned on the push result\n *     so the caller can account for it. Sequence stamps on surviving items\n *     keep loss visible as seq gaps (honest loss accounting). DEFAULT\n *     posture for telemetry-grade delivery.\n *   - `'sample'` — while saturated, admit 1 in `sampleEvery` arrivals\n *     (evicting the oldest to make room — that eviction is also a counted\n *     loss); refuse the rest (each a counted loss). Keeps a thinned,\n *     still-fresh stream under sustained overload. The saturation counter\n *     is episode-scoped: it resets whenever a push succeeds through the\n *     non-full path.\n *   - `'block'` — the ring REFUSES the new item (`accepted: false`,\n *     `rejections`++) and drops NOTHING. In a single-threaded runtime a\n *     queue cannot literally block its producer; the dispatcher (Block 5)\n *     interprets a refusal as \"deliver this event synchronously inline\" —\n *     re-introducing blocking delivery by the consumer's EXPLICIT choice.\n *     Rejections are NOT losses: the event is still delivered (inline), so\n *     `drops` stays untouched.\n *\n * Conservation invariant (property-tested):\n *   pushes === delivered + drops + rejections + size\n *\n * CURSOR-READY (amendment A2): v1 consumes destructively through ONE cursor\n * (`shift()` advances `head`). The designed v1.1 path keeps items in the\n * ring and gives each listener its own read cursor; `head` then advances to\n * `min(cursors)` (the reclaim watermark) instead of on read. The storage\n * layout (contiguous circular window, `head` + `count`) already supports\n * that — only the consumption surface changes. Documented, not implemented.\n */\n\n/** How the ring treats a push when it is at capacity (RFC-001 §5). */\nexport type OverflowPolicy = 'block' | 'drop-oldest' | 'sample';\n\nexport interface RingOptions {\n  /** Max queued items. Positive integer. */\n  readonly capacity: number;\n  /** Overflow behavior at capacity — see the module header. */\n  readonly policy: OverflowPolicy;\n  /**\n   * `'sample'` only: admit 1 in this many arrivals while saturated.\n   * Positive integer; default 10.\n   */\n  readonly sampleEvery?: number;\n}\n\n/** Outcome of one {@link BoundedRing.push}. */\nexport interface RingPushResult<T> {\n  /** True when the pushed item is now queued. */\n  readonly accepted: boolean;\n  /**\n   * The oldest item, when admitting the new one evicted it\n   * (`'drop-oldest'`, or a `'sample'` admission). Already counted in\n   * `drops` — surfaced so callers can do their own loss accounting.\n   */\n  readonly evicted?: T;\n}\n\n/** Monotonic counters — never reset for the lifetime of the ring. */\nexport interface RingCounters {\n  /** Total `push()` calls. */\n  readonly pushes: number;\n  /** `shift()` calls that returned an item. */\n  readonly delivered: number;\n  /** Items LOST — evictions plus sampled-out refusals. Never silent. */\n  readonly drops: number;\n  /** `'block'` refusals — NOT losses; the caller delivers these inline. */\n  readonly rejections: number;\n}\n\nconst DEFAULT_SAMPLE_EVERY = 10;\n\nexport class BoundedRing<T> {\n  private readonly buffer: Array<T | undefined>;\n  private readonly policy: OverflowPolicy;\n  private readonly sampleEvery: number;\n  /** Index of the oldest queued item — the single v1 cursor (see header). */\n  private head = 0;\n  private count = 0;\n  /** Arrivals seen while saturated in the current episode (`'sample'`). */\n  private saturatedArrivals = 0;\n\n  private pushes = 0;\n  private delivered = 0;\n  private drops = 0;\n  private rejections = 0;\n\n  constructor(opts: RingOptions) {\n    if (!Number.isInteger(opts.capacity) || opts.capacity <= 0) {\n      throw new RangeError(`BoundedRing capacity must be a positive integer (got ${opts.capacity})`);\n    }\n    const sampleEvery = opts.sampleEvery ?? DEFAULT_SAMPLE_EVERY;\n    if (!Number.isInteger(sampleEvery) || sampleEvery <= 0) {\n      throw new RangeError(`BoundedRing sampleEvery must be a positive integer (got ${opts.sampleEvery})`);\n    }\n    this.buffer = new Array<T | undefined>(opts.capacity);\n    this.policy = opts.policy;\n    this.sampleEvery = sampleEvery;\n  }\n\n  get size(): number {\n    return this.count;\n  }\n\n  get capacity(): number {\n    return this.buffer.length;\n  }\n\n  /** Lifetime counters — see {@link RingCounters}. */\n  getCounters(): RingCounters {\n    return { pushes: this.pushes, delivered: this.delivered, drops: this.drops, rejections: this.rejections };\n  }\n\n  /** Admit, evict-and-admit, refuse, or sample per policy — never throws. */\n  push(item: T): RingPushResult<T> {\n    this.pushes += 1;\n\n    if (this.count < this.buffer.length) {\n      this.saturatedArrivals = 0; // new saturation episode starts fresh\n      this.store(item);\n      return { accepted: true };\n    }\n\n    if (this.policy === 'block') {\n      this.rejections += 1;\n      return { accepted: false };\n    }\n\n    if (this.policy === 'sample') {\n      this.saturatedArrivals += 1;\n      if (this.saturatedArrivals % this.sampleEvery !== 0) {\n        this.drops += 1; // the incoming item is sampled out — lost\n        return { accepted: false };\n      }\n      // The 1-in-N admission falls through to evict-and-store.\n    }\n\n    // 'drop-oldest' (and the 'sample' admission): evict the oldest — lost.\n    const evicted = this.buffer[this.head] as T;\n    this.buffer[this.head] = undefined;\n    this.head = (this.head + 1) % this.buffer.length;\n    this.count -= 1;\n    this.drops += 1;\n    this.store(item);\n    return { accepted: true, evicted };\n  }\n\n  /** Pop the oldest queued item (FIFO). `undefined` when empty. */\n  shift(): T | undefined {\n    if (this.count === 0) return undefined;\n    const item = this.buffer[this.head] as T;\n    this.buffer[this.head] = undefined; // release the reference for GC\n    this.head = (this.head + 1) % this.buffer.length;\n    this.count -= 1;\n    this.delivered += 1;\n    return item;\n  }\n\n  private store(item: T): void {\n    this.buffer[(this.head + this.count) % this.buffer.length] = item;\n    this.count += 1;\n  }\n}\n"]}

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

@@ -69,6 +69,18 @@ export class ExecutionRuntime {
     useReadTracking(mode) {
         this.rootStageContext.useReadTracking(mode);
     }
+    /**
+     * Set the write-tracking policy (#13c-A) on the root stage context — the
+     * sibling of {@link useReadTracking}, with identical plumbing: descendant
+     * contexts inherit via `createNext`/`createChild`; subflow root contexts
+     * inherit from their parent-mount context via `SubflowExecutor`. Called by
+     * `FlowChartExecutor.createTraverser()` when the executor's policy is not
+     * the default `'full'` — including the resume path, where it is applied to
+     * the freshly-created continuation root.
+     */
+    useWriteTracking(mode) {
+        this.rootStageContext.useWriteTracking(mode);
+    }
     /** Preserve the current rootStageContext for snapshots before changing it for resume. */
     preserveSnapshotRoot() {
         if (!this._snapshotRoot) {
@@ -109,4 +121,4 @@ export class ExecutionRuntime {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionRuntime.js","sourceRoot":"","sources":["../../../../src/lib/runner/ExecutionRuntime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAwBzD,MAAM,OAAO,gBAAgB;IACpB,WAAW,CAAe;IACjC;;;;;;;;OAQG;IACI,aAAa,CAAgB;IAC7B,gBAAgB,CAAe;IAC/B,gBAAgB,CAAW;IAClC,oFAAoF;IAC5E,aAAa,CAAgB;IAC7B,aAAa,CAAU;IACvB,cAAc,CAAU;IAEhC,YAAY,QAAgB,EAAE,MAAc,EAAE,aAAuB,EAAE,YAAsB;QAC3F,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;QACnD,IAAI,CAAC,WAAW,GAAG,IAAI,YAAY,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QACjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC9G,CAAC;IAED;;;;;;;;;;OAUG;IACH,oBAAoB;QAClB,IAAI,IAAI,CAAC,aAAa;YAAE,OAAO,CAAC,aAAa;QAC7C,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CACnC,IAAI,CAAC,cAAc;QACnB,kEAAkE;QAClE,oEAAoE;QACpE,+BAA+B;QAC/B,IAAI,CAAC,aAAa,CACnB,CAAC;QACF,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,IAAsB;QACpC,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED,yFAAyF;IACzF,oBAAoB;QAClB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,YAAY;QACV,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC1C,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAoC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxF,CAAC;IAED,aAAa,CAAC,IAAc,EAAE,GAAW,EAAE,KAAc;QACvD,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,OAA8B;QACxC,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,gBAAgB,CAAC;QACjE,MAAM,WAAW,GAAG,OAAO,EAAE,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC;QACjF,OAAO;YACL,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,aAAc,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;YACvF,aAAa,EAAE,YAAY,CAAC,WAAW,EAAE;YACzC,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE;SACxC,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * ExecutionRuntime — The runtime environment for one flowchart execution.\n *\n * Wires up the three memory primitives into a single container:\n *   - SharedMemory (the heap — shared state across all stages)\n *   - StageContext  (the call stack — per-stage execution tree)\n *   - EventLog      (the transaction log — commit history for replay)\n *\n * The engine (FlowchartTraverser) receives this as its runtime parameter.\n * After execution, consumers query it for the full execution state.\n */\n\nimport { EventLog } from '../memory/EventLog.js';\nimport { SharedMemory } from '../memory/SharedMemory.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { CommitBundle, ReadTrackingMode, StageSnapshot } from '../memory/types.js';\n\n/** Snapshot of a single recorder's collected data. */\nexport interface RecorderSnapshot {\n  id: string;\n  name: string;\n  /** ScopeRecorder type and pattern description (e.g., \"Translator (KeyedStore) — per-step token usage\"). */\n  description?: string;\n  /** Preferred read-time operation — hints the UI about which view to show prominently. */\n  preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n  data: unknown;\n}\n\nexport type RuntimeSnapshot = {\n  sharedState: Record<string, unknown>;\n  executionTree: StageSnapshot;\n  commitLog: CommitBundle[];\n  /** Per-subflow execution results (keyed by subflowId). */\n  subflowResults?: Record<string, unknown>;\n  /** Snapshot data from recorders that implement toSnapshot(). */\n  recorders?: RecorderSnapshot[];\n};\n\nexport class ExecutionRuntime {\n  public globalStore: SharedMemory;\n  /**\n   * Parallel redacted mirror of `globalStore`. Populated during traversal via\n   * `StageContext.commit()` using the already-computed redacted patches.\n   * Only exists when `enableRedactedMirror()` has been called — typically by\n   * `FlowChartExecutor` when a `RedactionPolicy` is configured. Otherwise\n   * undefined and zero cost.\n   *\n   * Read via `getSnapshot({ redact: true })`.\n   */\n  public redactedStore?: SharedMemory;\n  public rootStageContext: StageContext;\n  public executionHistory: EventLog;\n  /** Original root for getSnapshot() — set before resume changes rootStageContext. */\n  private _snapshotRoot?: StageContext;\n  private _initialState: unknown;\n  private _defaultValues: unknown;\n\n  constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown) {\n    this._initialState = initialState;\n    this._defaultValues = defaultValues;\n    this.executionHistory = new EventLog(initialState);\n    this.globalStore = new SharedMemory(defaultValues, initialState);\n    this.rootStageContext = new StageContext('', rootName, rootId, this.globalStore, '', this.executionHistory);\n  }\n\n  /**\n   * Opt in to maintaining a parallel redacted mirror of `globalStore`. After\n   * this call, every `StageContext.commit()` in the run writes the redacted\n   * patches (the same ones fed to the event log) into `redactedStore` in\n   * addition to the raw ones written to `globalStore`.\n   *\n   * The mirror is created lazily and propagated into all child / next\n   * contexts, so it correctly reflects subflow-scope writes. When no\n   * `RedactionPolicy` is configured, callers should skip this — unused\n   * allocation, no functional difference in the snapshot.\n   */\n  enableRedactedMirror(): void {\n    if (this.redactedStore) return; // idempotent\n    this.redactedStore = new SharedMemory(\n      this._defaultValues,\n      // Seed with the same initial state as the raw store so the mirror\n      // starts from a scrubbed-nothing baseline; subsequent commits apply\n      // the redacted patches on top.\n      this._initialState,\n    );\n    this.rootStageContext.useRedactedMirror(this.redactedStore);\n  }\n\n  /**\n   * Set the read-tracking policy (#14) on the root stage context. Descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useReadTracking(mode: ReadTrackingMode): void {\n    this.rootStageContext.useReadTracking(mode);\n  }\n\n  /** Preserve the current rootStageContext for snapshots before changing it for resume. */\n  preserveSnapshotRoot(): void {\n    if (!this._snapshotRoot) {\n      this._snapshotRoot = this.rootStageContext;\n    }\n  }\n\n  getPipelines(): string[] {\n    const state = this.globalStore.getState();\n    return state.pipelines ? Object.keys(state.pipelines as Record<string, unknown>) : [];\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.rootStageContext.setObject(path, key, value);\n  }\n\n  /**\n   * Return the runtime snapshot.\n   *\n   * @param options.redact  When `true`, returns `sharedState` from the\n   *   parallel redacted mirror (if one was enabled). This is the safe view\n   *   for sharing traces externally — paste into a viewer, ship to support,\n   *   etc. When the mirror was never enabled, falls back to raw `globalStore`\n   *   and a dev-mode warning is emitted (silent in production).\n   *\n   *   Default `false` preserves the runtime view — necessary for pause /\n   *   resume (resumption must replay against the real values, not\n   *   '[REDACTED]').\n   *\n   * Other fields (`executionTree`, `commitLog`) are the same either way —\n   * the commit log is already redacted at write-time, and the execution\n   * tree only carries structural metadata.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshotRoot = this._snapshotRoot ?? this.rootStageContext;\n    const useRedacted = options?.redact === true && this.redactedStore !== undefined;\n    return {\n      sharedState: useRedacted ? this.redactedStore!.getState() : this.globalStore.getState(),\n      executionTree: snapshotRoot.getSnapshot(),\n      commitLog: this.executionHistory.list(),\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionRuntime.js","sourceRoot":"","sources":["../../../../src/lib/runner/ExecutionRuntime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ExecutionRuntime — The runtime environment for one flowchart execution.\n *\n * Wires up the three memory primitives into a single container:\n *   - SharedMemory (the heap — shared state across all stages)\n *   - StageContext  (the call stack — per-stage execution tree)\n *   - EventLog      (the transaction log — commit history for replay)\n *\n * The engine (FlowchartTraverser) receives this as its runtime parameter.\n * After execution, consumers query it for the full execution state.\n */\n\nimport { EventLog } from '../memory/EventLog.js';\nimport { SharedMemory } from '../memory/SharedMemory.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { CommitBundle, ReadTrackingMode, StageSnapshot, WriteTrackingMode } from '../memory/types.js';\n\n/** Snapshot of a single recorder's collected data. */\nexport interface RecorderSnapshot {\n  id: string;\n  name: string;\n  /** ScopeRecorder type and pattern description (e.g., \"Translator (KeyedStore) — per-step token usage\"). */\n  description?: string;\n  /** Preferred read-time operation — hints the UI about which view to show prominently. */\n  preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n  data: unknown;\n}\n\nexport type RuntimeSnapshot = {\n  sharedState: Record<string, unknown>;\n  executionTree: StageSnapshot;\n  commitLog: CommitBundle[];\n  /** Per-subflow execution results (keyed by subflowId). */\n  subflowResults?: Record<string, unknown>;\n  /** Snapshot data from recorders that implement toSnapshot(). */\n  recorders?: RecorderSnapshot[];\n};\n\nexport class ExecutionRuntime {\n  public globalStore: SharedMemory;\n  /**\n   * Parallel redacted mirror of `globalStore`. Populated during traversal via\n   * `StageContext.commit()` using the already-computed redacted patches.\n   * Only exists when `enableRedactedMirror()` has been called — typically by\n   * `FlowChartExecutor` when a `RedactionPolicy` is configured. Otherwise\n   * undefined and zero cost.\n   *\n   * Read via `getSnapshot({ redact: true })`.\n   */\n  public redactedStore?: SharedMemory;\n  public rootStageContext: StageContext;\n  public executionHistory: EventLog;\n  /** Original root for getSnapshot() — set before resume changes rootStageContext. */\n  private _snapshotRoot?: StageContext;\n  private _initialState: unknown;\n  private _defaultValues: unknown;\n\n  constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown) {\n    this._initialState = initialState;\n    this._defaultValues = defaultValues;\n    this.executionHistory = new EventLog(initialState);\n    this.globalStore = new SharedMemory(defaultValues, initialState);\n    this.rootStageContext = new StageContext('', rootName, rootId, this.globalStore, '', this.executionHistory);\n  }\n\n  /**\n   * Opt in to maintaining a parallel redacted mirror of `globalStore`. After\n   * this call, every `StageContext.commit()` in the run writes the redacted\n   * patches (the same ones fed to the event log) into `redactedStore` in\n   * addition to the raw ones written to `globalStore`.\n   *\n   * The mirror is created lazily and propagated into all child / next\n   * contexts, so it correctly reflects subflow-scope writes. When no\n   * `RedactionPolicy` is configured, callers should skip this — unused\n   * allocation, no functional difference in the snapshot.\n   */\n  enableRedactedMirror(): void {\n    if (this.redactedStore) return; // idempotent\n    this.redactedStore = new SharedMemory(\n      this._defaultValues,\n      // Seed with the same initial state as the raw store so the mirror\n      // starts from a scrubbed-nothing baseline; subsequent commits apply\n      // the redacted patches on top.\n      this._initialState,\n    );\n    this.rootStageContext.useRedactedMirror(this.redactedStore);\n  }\n\n  /**\n   * Set the read-tracking policy (#14) on the root stage context. Descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useReadTracking(mode: ReadTrackingMode): void {\n    this.rootStageContext.useReadTracking(mode);\n  }\n\n  /**\n   * Set the write-tracking policy (#13c-A) on the root stage context — the\n   * sibling of {@link useReadTracking}, with identical plumbing: descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useWriteTracking(mode: WriteTrackingMode): void {\n    this.rootStageContext.useWriteTracking(mode);\n  }\n\n  /** Preserve the current rootStageContext for snapshots before changing it for resume. */\n  preserveSnapshotRoot(): void {\n    if (!this._snapshotRoot) {\n      this._snapshotRoot = this.rootStageContext;\n    }\n  }\n\n  getPipelines(): string[] {\n    const state = this.globalStore.getState();\n    return state.pipelines ? Object.keys(state.pipelines as Record<string, unknown>) : [];\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.rootStageContext.setObject(path, key, value);\n  }\n\n  /**\n   * Return the runtime snapshot.\n   *\n   * @param options.redact  When `true`, returns `sharedState` from the\n   *   parallel redacted mirror (if one was enabled). This is the safe view\n   *   for sharing traces externally — paste into a viewer, ship to support,\n   *   etc. When the mirror was never enabled, falls back to raw `globalStore`\n   *   and a dev-mode warning is emitted (silent in production).\n   *\n   *   Default `false` preserves the runtime view — necessary for pause /\n   *   resume (resumption must replay against the real values, not\n   *   '[REDACTED]').\n   *\n   * Other fields (`executionTree`, `commitLog`) are the same either way —\n   * the commit log is already redacted at write-time, and the execution\n   * tree only carries structural metadata.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshotRoot = this._snapshotRoot ?? this.rootStageContext;\n    const useRedacted = options?.redact === true && this.redactedStore !== undefined;\n    return {\n      sharedState: useRedacted ? this.redactedStore!.getState() : this.globalStore.getState(),\n      executionTree: snapshotRoot.getSnapshot(),\n      commitLog: this.executionHistory.list(),\n    };\n  }\n}\n"]}