footprintjs 10.0.1 → 10.2.0

package/dist/lib/scope/ScopeFacade.js

@@ -17,6 +17,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScopeFacade = void 0;
 const foottrace_1 = require("foottrace");
+const call_js_1 = require("../attempt/call.js");
+const effect_js_1 = require("../attempt/effect.js");
+const name_js_1 = require("../attempt/name.js");
+const observed_js_1 = require("../attempt/observed.js");
+const policy_js_1 = require("../attempt/policy.js");
+const retryLoopContext_js_1 = require("../attempt/retryLoopContext.js");
+const runner_js_1 = require("../attempt/runner.js");
 const circular_js_1 = require("../capture/circular.js");
 const spawn_js_1 = require("../detach/spawn.js");
 const devMode_js_1 = require("../devMode.js");
@@ -72,6 +79,28 @@ class ScopeFacade {
      * tree and this stays unset; see {@link rule}.
      */
     _localRule;
+    /**
+     * The run's correlation (10.1), installed by the executor's composed scope factory
+     * (`RunObservers · composeScopeFactory`) — stamped LAST on every scope and emit event this facade fires,
+     * only when present, so a run without one fires byte-identical events.
+     */
+    _correlation;
+    /**
+     * The attempt this facade was built for (P1b) — the runner's, read off the
+     * context at construction. A facade is ONE attempt's handle: once that
+     * attempt ends without an answer (its cap, the deadline, a cancellation, a
+     * throw), the function behind it may still be running, and anything it
+     * touches through this facade is refused ({@link refuseIfAttemptEnded}) —
+     * a write or an emit is also recorded on the stage. Absent for a stage the
+     * runner does not run: nothing is fenced, as before.
+     */
+    _attempt;
+    /** The run's signal, for `$attempt()` of a stage the runner does not run. */
+    _runSignal;
+    /** `$call`s with `of > 1` in flight through this facade — a keyless touching call inside one is refused (P3). */
+    _retryingCalls = 0;
+    /** This attempt's observed reports, grouped into series (P2) — made on the first report. */
+    _observedBook;
     constructor(context, stageName, readOnlyValues, executionEnv) {
         this._stageContext = context;
         this._stageName = stageName;
@@ -80,6 +109,8 @@ class ScopeFacade {
         this._executionEnv = Object.freeze({ ...executionEnv });
         this._hasArgs = Object.keys(this._frozenArgs).length > 0;
         this._hasEnv = Object.keys(this._executionEnv).length > 0;
+        this._attempt = context.attempt;
+        this._runSignal = context.runSignal;
         // The context must carry the rule BEFORE the first write, since the
         // context's write funnel is what marks a per-call redacted key on it.
         // Under an executor the context already has the run's rule (installed on
@@ -136,6 +167,14 @@ class ScopeFacade {
     useRedactionPolicy(policy) {
         this.rule.setPolicy(policy);
     }
+    /**
+     * Install the run's correlation — every scope and emit event this facade fires carries it; `undefined` clears
+     * it. Engine-only (the composed scope factory calls it once per stage), like `useRedactionPolicy`.
+     * @internal
+     */
+    useCorrelation(correlation) {
+        this._correlation = correlation;
+    }
     /** @internal */
     getRedactionPolicy() {
         return this.rule.getPolicy();
@@ -220,11 +259,240 @@ class ScopeFacade {
      * stage the handle came from; the engine's error path attributes the throw
      * to the stage that made the write.
      */
-    assertLive(key) {
+    assertLive(key, channel = 'state') {
+        this.refuseIfAttemptEnded(key, channel);
         if (this._committed) {
             throw new Error((0, borrowedMutation_js_1.deadFrameMessage)(this._stageName, this._stageContext.runtimeStageId, key));
         }
     }
+    /**
+     * The attempt fence (P1b): this facade's attempt has ended, so whatever the
+     * abandoned function does now must not reach the stage — not its buffer, its
+     * reads, its untracked sources or a recorder. Refused; a write or an emit is
+     * recorded on the stage first (`StageSnapshot.lateWrites`, the name only),
+     * a read (`channel` undefined) is not.
+     */
+    refuseIfAttemptEnded(key, channel) {
+        const attempt = this._attempt;
+        if (attempt === undefined || !this._stageContext.hasAttemptEnded(attempt.attempt))
+            return;
+        if (channel !== undefined)
+            this._stageContext.recordLateWrite({ attempt: attempt.attempt, key, channel });
+        throw new Error((0, borrowedMutation_js_1.lateAttemptMessage)(this._stageName, attempt.series, attempt.attempt, key));
+    }
+    /**
+     * The attempt this stage function runs in — `scope.$attempt()` (design
+     * §3.1). Its `signal` aborts when the attempt must stop (its cap, the run's
+     * deadline, a cancellation): pass it to `fetch` and SDK calls. Its
+     * `timeLeftMs()` reads the run's deadline — time is an input the record
+     * cannot replay, so with a deadline the read marks the stage's commit
+     * `untrackedSources: ['env']`, as `getEnv()` does.
+     *
+     * A stage the attempt runner does not run (no retry policy, no `timeoutMs`,
+     * no deadline) is attempt 1 of 1, with the run's signal and `Infinity` left.
+     *
+     * ```typescript
+     * const t = scope.$attempt();
+     * const res = await fetch(url, { signal: t.signal });
+     * if (t.timeLeftMs() < 1_000) scope.summary = 'partial';
+     * ```
+     */
+    getAttempt() {
+        const attempt = this._attempt;
+        const observed = (report) => this.recordObserved(report);
+        if (attempt === undefined) {
+            return Object.freeze({
+                series: this._stageContext.runtimeStageId,
+                attempt: 1,
+                of: 1,
+                signal: this._runSignal ?? NEVER_ABORTED,
+                timeLeftMs: () => Infinity,
+                observed,
+            });
+        }
+        this.refuseIfAttemptEnded('$attempt');
+        const context = this._stageContext;
+        return Object.freeze({
+            ...attempt,
+            timeLeftMs: () => {
+                // Read through a handle held past its attempt, it must not mark a LATER attempt's commit.
+                this.refuseIfAttemptEnded('$attempt');
+                if (attempt.deadline !== undefined)
+                    context.markUntrackedSource('env');
+                return attempt.timeLeftMs();
+            },
+            observed,
+        });
+    }
+    /**
+     * A call to an outside system, made inside this stage — `scope.$call(target, fn, policy?)` (design §3.6, P2).
+     * `fn` runs on the attempt runner under `policy` (none = ONE attempt, still recorded: a single call is evidence
+     * too), and every attempt is an `AttemptRecord` of kind `'call'` on this stage's execution-tree node and on
+     * `onAttempt` — its timing, outcome, failure category and the retry-or-stop decision, its error served under the
+     * run's redaction rule.
+     *
+     * The call lives within this stage attempt: it is capped by the time the attempt has left (its cap, the run's
+     * deadline) and `fn`'s `signal` aborts when the attempt does; once the attempt is over nothing of the call lands
+     * and no further attempt of it starts (`attempt/call.ts`). `target` is a NAME from code — never a value.
+     *
+     * ```typescript
+     * const quote = await scope.$call('stripe.quotes.create', (t) => stripe.quotes.create(body, { signal: t.signal }),
+     *   { attempts: 3, timeoutMs: 10_000, backoffMs: (n) => 500 * n });
+     * ```
+     *
+     * A call that CHANGES an outside system declares it (P3): `options.touches` names the system and
+     * `options.idempotencyKey` the key every attempt is made under (`t.idempotencyKey`) — a value from the stage's
+     * input or state, never from model output. A touching call that may retry without a key is refused here,
+     * before anything is sent; each record says what its attempt did (`effect`), and a call that ends without an answer after any attempt left the
+     * effect unknown rejects with `UnknownEffectError` — reconcile by the key, do not retry blindly.
+     */
+    call(target, fn, policy, options) {
+        const name = (0, name_js_1.admitAttemptName)('$call', 'target', target);
+        const where = `$call('${name}')`;
+        if (typeof fn !== 'function')
+            throw new TypeError(`${where}: fn must be a function`);
+        const admitted = (0, policy_js_1.admitCallPolicy)(where, policy);
+        const touches = (0, effect_js_1.callTouches)(where, options, admitted);
+        // A keyless touching call is sent once only if the stage attempt that makes it never runs again (P3): a stage
+        // that may retry would re-send it without a key — refused here, before anything is sent.
+        // So is one inside an enclosing `$call` that may retry (its function runs once per outer attempt).
+        if (touches !== undefined && touches.idempotencyKey === undefined) {
+            const enclosing = (this._attempt?.of ?? 1) > 1 ? 'a stage' : this._retryingCalls > 0 ? 'a $call' : undefined;
+            if (enclosing !== undefined) {
+                throw new TypeError(`${where}: touches "${touches.system}" with no idempotencyKey, inside ${enclosing} that may retry — a ` +
+                    'retry would send it again without a key. Give the call a key.');
+            }
+            this._stageContext.markKeylessEffect();
+        }
+        // From an ended attempt or a committed frame: refused (and recorded by name) before anything reaches outside.
+        this.refuseLateCall(`call:${name}`);
+        const context = this._stageContext;
+        const stageAttempt = this._attempt?.attempt ?? 1;
+        const signal = this._attempt?.signal ?? this._runSignal;
+        const deadline = (0, runner_js_1.attemptEndsAt)(this._attempt);
+        const ended = context.callsEndedSignal(stageAttempt);
+        // While a call that may retry is in flight, a keyless touching call made inside it is refused (above).
+        const retrying = (0, policy_js_1.attemptCeiling)(admitted.attempts) > 1;
+        if (retrying)
+            this._retryingCalls += 1;
+        let result;
+        try {
+            result = this.startCall(name, fn, admitted, touches, stageAttempt, signal, deadline, ended);
+        }
+        catch (error) {
+            if (retrying)
+                this._retryingCalls -= 1;
+            throw error;
+        }
+        if (!retrying)
+            return result;
+        const release = () => {
+            this._retryingCalls -= 1;
+        };
+        result.then(release, release);
+        return result;
+    }
+    /** `runCall` with this stage attempt as its host (`call`). */
+    startCall(name, fn, admitted, touches, stageAttempt, signal, deadline, ended) {
+        const context = this._stageContext;
+        const loop = (0, retryLoopContext_js_1.takeRetryLoopCall)(this);
+        return (0, call_js_1.runCall)(name, fn, admitted, {
+            openSeries: () => (0, call_js_1.callSeries)(context.runtimeStageId, stageAttempt, context.nextCallOrdinal(stageAttempt)),
+            ...(signal !== undefined && { signal }),
+            ...(deadline !== undefined && { deadline }),
+            ended,
+            ...(touches !== undefined && { effect: this.callEffect(touches) }),
+            // The frame's own commit state (every attempt's facade reads the same), never a facade flag.
+            admits: (cut) => !context.committed && (cut || !(ended.aborted || this.attemptHasEnded())),
+            serve: (error) => this.rule.servedError(error),
+            report: (record, structuredError) => {
+                const served = loop ? Object.freeze({ ...record, retryLoop: loop.identity }) : record;
+                context.reportCallAttempt(served, structuredError);
+                loop?.record(served);
+            },
+            refused: () => context.recordLateWrite({ attempt: stageAttempt, key: `call:${name}`, channel: 'attempt' }),
+            observe: (report, at) => this.recordObserved(report, at.ended),
+        });
+    }
+    /** @internal The explicit retry helper owns this state; the normal write path still owns retention/commit. */
+    writeRetryLoopState(key, state) {
+        const kept = this.serveRetryLoopKey(state.idempotencyKey);
+        if (kept !== state.idempotencyKey)
+            this.rule.inheritFields(key, ['idempotencyKey']);
+        this.setValue(key, state);
+    }
+    /** @internal Exactly the existing P3 key-retention law; operational state keeps the real key. */
+    serveRetryLoopKey(key) {
+        return this.rule.retainIdempotencyKey(key, {
+            input: this._readOnlyValues,
+            selectedReads: this._stageContext.selectedReads + (this._stageContext.effectKeyTainted ? 1 : 0),
+        });
+    }
+    /** @internal Loop state is durable data: never persist the thrown value, stack, cause or payload. */
+    serveRetryLoopError(error) {
+        const served = this.rule.servedError(error);
+        return {
+            message: served.message,
+            ...(served.name !== undefined ? { name: served.name } : {}),
+            ...(served.code !== undefined ? { code: served.code } : {}),
+        };
+    }
+    /** A touching call's target, its key served for the records (`RedactionRule · retainIdempotencyKey`: by name and by its sources). */
+    callEffect(touches) {
+        const key = touches.idempotencyKey;
+        if (key === undefined)
+            return touches;
+        // A key the stage built after reading a selected value — or from an input holding one — is served whole.
+        const recordedKey = this.rule.retainIdempotencyKey(key, {
+            input: this._readOnlyValues,
+            // The stage's own key may be made of a selected value: a key passed on from it is served the same way.
+            selectedReads: this._stageContext.selectedReads + (this._stageContext.effectKeyTainted ? 1 : 0),
+        });
+        return { ...touches, recordedKey };
+    }
+    /**
+     * A `$call` from an ended attempt, or from a frame that has committed: recorded by name (`lateWrites`, channel
+     * `'attempt'`) and refused — before anything reaches outside. The P1b fence first, so its message and record are
+     * the same.
+     */
+    refuseLateCall(key) {
+        this.refuseIfAttemptEnded(key, 'attempt');
+        if (!this._stageContext.committed && !this._committed)
+            return;
+        this._stageContext.recordLateWrite({ attempt: this._attempt?.attempt ?? 1, key, channel: 'attempt' });
+        throw new Error((0, borrowedMutation_js_1.deadFrameMessage)(this._stageName, this._stageContext.runtimeStageId, key));
+    }
+    /**
+     * An outside attempt an adapter reported — `AttemptContext.observed` on this stage's attempt or on one of its
+     * calls' (P2). Read and validated first (a malformed report is the adapter's bug: a `TypeError`, and it never
+     * reaches the record). A report that comes after its attempt ended — the call attempt it was made through, this
+     * stage attempt, or the frame's commit — is recorded by name (`lateWrites`, channel `'attempt'`) and DROPPED,
+     * never thrown: adapters report from an SDK's own callbacks, which may fire after the stage moved on, and an
+     * observed attempt never changes control flow — in either direction. Its series opens at this stage attempt's call
+     * level: an SDK's call is a call the stage attempt made, so a report made through a `$call` is that call's sibling.
+     */
+    recordObserved(report, callAttemptEnded = false) {
+        const read = (0, observed_js_1.readObservedReport)(report);
+        const key = `observed:${read.target}`;
+        const context = this._stageContext;
+        const stageAttempt = this._attempt?.attempt ?? 1;
+        if (callAttemptEnded || this.attemptHasEnded() || context.committed || this._committed) {
+            context.recordLateWrite({ attempt: stageAttempt, key, channel: 'attempt' });
+            return;
+        }
+        const book = (this._observedBook ??= new observed_js_1.ObservedSeriesBook(() => (0, call_js_1.callSeries)(context.runtimeStageId, stageAttempt, context.nextCallOrdinal(stageAttempt))));
+        const { record, structuredError } = (0, observed_js_1.observedRecord)(read, {
+            series: book.seriesFor(read),
+            now: Date.now,
+            serve: (error) => this.rule.servedError(error),
+        });
+        context.reportCallAttempt(record, structuredError);
+    }
+    /** This facade's attempt has ended — the P1b fence is closed. */
+    attemptHasEnded() {
+        const attempt = this._attempt;
+        return attempt !== undefined && this._stageContext.hasAttemptEnded(attempt.attempt);
+    }
     /** Called by StageContext.commit() observer. Converts tracked writes to CommitEvent format.
      *  Errors are caught to prevent recorder issues from aborting the traversal. */
     _onCommitFired(mutations) {
@@ -255,22 +523,27 @@ class ScopeFacade {
     // attached `EmitRecorder` sees them in real time — closing the
     // long-standing gap where `$debug`/`$metric` went to unobserved bags.
     addDebugInfo(key, value) {
+        this.refuseIfAttemptEnded(`log.debug.${key}`, 'emit');
         const kept = this._stageContext.addDiagnostic('logs', key, value);
         this.emitEvent(`log.debug.${key}`, { key, value: kept, level: 'debug' });
     }
     addDebugMessage(value) {
+        this.refuseIfAttemptEnded('log.debug.messages', 'emit');
         const kept = this._stageContext.addDiagnostic('logs', 'messages', [value]);
         this.emitEvent('log.debug.messages', { value: Array.isArray(kept) ? kept[0] : kept, level: 'debug' });
     }
     addErrorInfo(key, value) {
+        this.refuseIfAttemptEnded(`log.error.${key}`, 'emit');
         const kept = this._stageContext.addDiagnostic('errors', key, value);
         this.emitEvent(`log.error.${key}`, { key, value: kept, level: 'error' });
     }
     addMetric(metricName, value) {
+        this.refuseIfAttemptEnded(`metric.${metricName}`, 'emit');
         const kept = this._stageContext.addDiagnostic('metrics', metricName, value);
         this.emitEvent(`metric.${metricName}`, { name: metricName, value: kept });
     }
     addEval(metricName, value) {
+        this.refuseIfAttemptEnded(`eval.${metricName}`, 'emit');
         const kept = this._stageContext.addDiagnostic('evals', metricName, value);
         this.emitEvent(`eval.${metricName}`, { name: metricName, value: kept });
     }
@@ -294,6 +567,9 @@ class ScopeFacade {
      * the method routes here via `createTypedScope`.
      */
     emitEvent(name, payload) {
+        // An ended attempt emits nothing — refused (and recorded) before the fast path, so the record does not depend
+        // on whether a recorder happened to be attached.
+        this.refuseIfAttemptEnded(name, 'emit');
         // Fast-path: zero work when no recorders are attached.
         if (this._recorders.length === 0)
             return;
@@ -318,7 +594,7 @@ class ScopeFacade {
         // Dispatch with error isolation — the same `fire` loop and the same failure routing as
         // every other scope event: a throwing recorder's error reaches onError on the recorders;
         // the emit loop continues unaffected.
-        (0, hooks_js_1.fire)(this._recorders, 'onEmit', event, this._routeFailure);
+        (0, hooks_js_1.fire)(this._recorders, 'onEmit', this._correlated(event), this._routeFailure);
     }
     // ── Detach — fire-and-forget child flowchart execution ─────────────────
     //
@@ -328,10 +604,12 @@ class ScopeFacade {
     // and `scope.$detachAndForget(...)`.
     /** See `ScopeMethods.$detachAndJoinLater`. */
     detachAndJoinLater(driver, child, input) {
+        this.refuseIfAttemptEnded(detachKey(child), 'detach');
         return (0, spawn_js_1.detachAndJoinLater)(driver, child, input, this._stageContext.runtimeStageId);
     }
     /** See `ScopeMethods.$detachAndForget`. */
     detachAndForget(driver, child, input) {
+        this.refuseIfAttemptEnded(detachKey(child), 'detach');
         (0, spawn_js_1.detachAndForget)(driver, child, input, this._stageContext.runtimeStageId);
     }
     /**
@@ -361,6 +639,7 @@ class ScopeFacade {
     // ── Non-Tracking State Inspection (for TypedScope proxy internals) ──────
     /** Returns all state keys without firing onRead. Used by TypedScope ownKeys/has traps. */
     getStateKeys() {
+        this.refuseIfAttemptEnded('*');
         const snapshot = this._stageContext.getValue([], undefined);
         if (!snapshot || typeof snapshot !== 'object')
             return [];
@@ -370,6 +649,7 @@ class ScopeFacade {
      *  Contract: returns false for keys never set OR keys set to undefined.
      *  This matches deleteValue() semantics (sets to undefined = deleted). */
     hasKey(key) {
+        this.refuseIfAttemptEnded(key);
         return this._stageContext.getValue([], key) !== undefined;
     }
     /** Read state without firing onRead. Used by array proxy getCurrent() to avoid
@@ -387,6 +667,7 @@ class ScopeFacade {
      *  array-proxy pattern above) are not flagged: their edge is captured. A
      *  whole-state silent read (no key) is always flagged. */
     getValueSilent(key) {
+        this.refuseIfAttemptEnded(key ?? '*');
         if (key === undefined || !this._trackedReadKeys.has(key)) {
             this._stageContext.markUntrackedSource('silent');
         }
@@ -428,6 +709,7 @@ class ScopeFacade {
      * a literal top-level `'user.ssn'` produce the same event key (same for the writes below).
      */
     getValueAt(path, key) {
+        this.refuseIfAttemptEnded(key === undefined ? path.join('.') || '*' : [...path, key].join('.'));
         const value = this._stageContext.getValue(path, key);
         // RFC-003 D2: remember tracked keys so later SILENT reads of the same
         // key count as shadowed (edge already captured) instead of untracked.
@@ -578,6 +860,7 @@ class ScopeFacade {
      * here. An empty-args read carries no information and is not flagged.
      */
     getArgs() {
+        this.refuseIfAttemptEnded('$args');
         if (this._hasArgs)
             this._stageContext.markUntrackedSource('args');
         return this._frozenArgs;
@@ -586,8 +869,10 @@ class ScopeFacade {
      * Returns the execution environment — read-only infrastructure values
      * that propagate through nested executors (like `process.env` for flowcharts).
      *
-     * Contains: signal (abort), timeoutMs, traceId.
-     * Frozen at construction time. Inherited by subflows automatically.
+     * Contains: signal (abort — the run's one effective signal), timeoutMs, traceId, operationId, traceparent,
+     * deadline (epoch ms) — the run's env as admitted (`attempt/correlation.ts · admitRunEnv`: one own-field
+     * snapshot; `traceparent` is the canonical header the run's correlation carries, never the received bytes), then
+     * armed (`runner/deadline.ts · armRun`). Frozen at construction time. Inherited by subflows automatically.
      *
      * ```typescript
      * const { signal, traceId } = scope.getEnv();
@@ -598,6 +883,7 @@ class ScopeFacade {
      * `untrackedSources: ['env']` — see {@link getArgs}.
      */
     getEnv() {
+        this.refuseIfAttemptEnded('$env');
         if (this._hasEnv)
             this._stageContext.markUntrackedSource('env');
         return this._executionEnv;
@@ -610,7 +896,11 @@ class ScopeFacade {
     _invokeHook(hook, event) {
         // The one per-recorder loop (`recorder/hooks.ts · fire`) — the SAME invoke primitive the
         // deferred tier uses at delivery time, so the inline and deferred paths cannot drift.
-        (0, hooks_js_1.fire)(this._recorders, hook, event, this._routeFailure);
+        (0, hooks_js_1.fire)(this._recorders, hook, this._correlated(event), this._routeFailure);
+    }
+    /** The event as fired: unchanged without a correlation, else with the run's correlation as its last key. */
+    _correlated(event) {
+        return this._correlation === undefined ? event : { ...event, correlation: this._correlation };
     }
     /**
      * The scope channel's isolation: a recorder's throw becomes an `onError` on every recorder
@@ -628,4 +918,11 @@ class ScopeFacade {
     };
 }
 exports.ScopeFacade = ScopeFacade;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ScopeFacade.js","sourceRoot":"","sources":["../../../src/lib/scope/ScopeFacade.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ScopeFacade — Base class that library consumers extend to create custom scope classes\n *\n * Wraps StageContext (from memory/) to provide a consumer-friendly API for\n * state access, debug logging, metrics, and recorder hooks.\n *\n * Consumers extend this class to add domain-specific properties:\n *\n * ```typescript\n * class MyScope extends ScopeFacade {\n *   get userName(): string { return this.getValue('name') as string; }\n *   set userName(value: string) { this.setValue('name', value); }\n * }\n * ```\n */\n\nimport { subflowSegmentsOf } from 'foottrace';\n\nimport { hasCircularReference } from '../capture/circular.js';\nimport {\n  detachAndForget as detachAndForgetSpawn,\n  detachAndJoinLater as detachAndJoinLaterSpawn,\n} from '../detach/spawn.js';\nimport { isDevMode } from '../devMode.js';\nimport type { ExecutionEnv } from '../engine/types.js';\nimport { deadFrameMessage } from '../memory/borrowedMutation.js';\nimport { CLEAR, RedactionRule } from '../memory/redaction.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { HookFailure, HookPayload, ScopeHookName } from '../recorder/hooks.js';\nimport { fire, recorderFailureEvent } from '../recorder/hooks.js';\nimport { assertNotReadonly, createFrozenArgs } from './protection/readonlyInput.js';\nimport { registerScopeRuntime } from './runtime.js';\nimport type { CommitEvent, RedactionPolicy, RedactionReport, ScopeRecorder } from './types.js';\n\nexport class ScopeFacade {\n  public static readonly BRAND = Symbol.for('ScopeFacade@v1');\n\n  /**\n   * Shared sentinel returned by `_getSubflowPath()` for root-level stages\n   * (no subflow nesting). Avoids per-call allocation of a fresh\n   * `Object.freeze([])` on every `emitEvent` in the common no-subflow case.\n   */\n  private static readonly _EMPTY_SUBFLOW_PATH: readonly string[] = Object.freeze([]);\n\n  protected _stageContext: StageContext;\n  protected _stageName: string;\n  protected readonly _readOnlyValues?: unknown;\n\n  /** Cached deeply-frozen copy of readOnlyValues for getArgs(). Created once. */\n  private readonly _frozenArgs: Record<string, unknown>;\n\n  /** Execution environment — read-only, inherited from parent executor. */\n  private readonly _executionEnv: Readonly<ExecutionEnv>;\n\n  /** RFC-003 D2: true when `getArgs()` can return actual data — an empty\n   *  `{}` read carries no information, so it is never flagged. */\n  private readonly _hasArgs: boolean;\n\n  /** RFC-003 D2: true when `getEnv()` can return actual data. */\n  private readonly _hasEnv: boolean;\n\n  /**\n   * RFC-003 D2: keys this stage has TRACKED-read (via `getValue(key)`).\n   * A silent read of a key in this set is SHADOWED — its read→write edge is\n   * already captured, so it is not flagged as an untracked source. This is\n   * what keeps TypedScope array-proxy internals (which always follow a\n   * tracked property read) and `$batchArray` honest-but-quiet.\n   */\n  private readonly _trackedReadKeys = new Set<string>();\n\n  private _recorders: ScopeRecorder[] = [];\n\n  /**\n   * Set by the commit observer: this stage's frame has flushed. A facade is\n   * ONE stage execution's handle — the engine builds a fresh one per stage —\n   * and every proxy the typed scope hands out is bound to it. A write arriving\n   * after the commit comes from a handle held past its stage (a closure, a\n   * module-level `let`) and would land in a buffer nothing ever commits: no\n   * trace row, state unchanged. So it is refused ({@link assertLive}) instead\n   * of lost. Sealing here and not on `StageContext` is deliberate: the frame\n   * stays re-usable after commit by design (#13b — the engine's double-commit\n   * paths and the subflow merge-back into a branch parent need it).\n   */\n  private _committed = false;\n\n  /**\n   * A rule of this facade's own — ONLY when its context carries none (bare\n   * contexts in unit tests). Under an executor the rule lives on the context\n   * tree and this stays unset; see {@link rule}.\n   */\n  private _localRule?: RedactionRule;\n\n  constructor(context: StageContext, stageName: string, readOnlyValues?: unknown, executionEnv?: ExecutionEnv) {\n    this._stageContext = context;\n    this._stageName = stageName;\n    this._readOnlyValues = readOnlyValues;\n    this._frozenArgs = createFrozenArgs(readOnlyValues);\n    this._executionEnv = Object.freeze({ ...executionEnv });\n    this._hasArgs = Object.keys(this._frozenArgs).length > 0;\n    this._hasEnv = Object.keys(this._executionEnv).length > 0;\n    // The context must carry the rule BEFORE the first write, since the\n    // context's write funnel is what marks a per-call redacted key on it.\n    // Under an executor the context already has the run's rule (installed on\n    // the root, inherited down) and this re-installs the same object; on a\n    // bare context it installs a fresh one.\n    this._stageContext.useRedactionRule(this.rule);\n\n    // Register as commit observer so ScopeRecorder.onCommit fires when StageContext.commit() is called\n    this._stageContext.setCommitObserver((mutations) => {\n      this._onCommitFired(mutations);\n    });\n    registerScopeRuntime(this, { target: this, handlesAssignments: false });\n  }\n\n  /**\n   * The redaction rule this facade decides with — the SAME object its\n   * `StageContext` retains with (`memory/redaction.ts`, the one owner). Under\n   * an executor the rule is installed on the runtime root and inherited by\n   * every context, so the facade simply reads it. On a bare context (unit\n   * tests, hand-built scopes) the facade creates one and installs it on the\n   * context, so the context's retention and the facade's recorder views\n   * still share a single verdict.\n   */\n  private get rule(): RedactionRule {\n    const shared = this._stageContext.getRedactionRule();\n    if (shared) return shared;\n    if (!this._localRule) {\n      this._localRule = new RedactionRule();\n      this._stageContext.useRedactionRule(this._localRule);\n    }\n    return this._localRule;\n  }\n\n  /**\n   * Share a redacted-keys set across multiple ScopeFacade instances.\n   * Call this to make redaction persist across stages in the same pipeline.\n   * (Under an executor the run's rule already shares one set; this call is\n   * then a no-op.)\n   * @internal\n   */\n  useSharedRedactedKeys(sharedSet: Set<string>): void {\n    this.rule.useMarkedKeys(sharedSet);\n  }\n\n  /**\n   * Returns the current redacted-keys set (for sharing with other scopes).\n   * @internal\n   */\n  getRedactedKeys(): Set<string> {\n    return this.rule.markedKeys();\n  }\n\n  /**\n   * Apply a declarative redaction policy. The policy is additive —\n   * it works alongside manual `setValue(..., true)` calls.\n   * @internal\n   */\n  useRedactionPolicy(policy: RedactionPolicy): void {\n    this.rule.setPolicy(policy);\n  }\n\n  /** @internal */\n  getRedactionPolicy(): RedactionPolicy | undefined {\n    return this.rule.getPolicy();\n  }\n\n  /**\n   * Returns a compliance-friendly report of all redaction activity.\n   * Never includes actual values — only key names, field names, and patterns.\n   */\n  getRedactionReport(): RedactionReport {\n    return this.rule.report();\n  }\n\n  // ── ScopeRecorder Management ──────────────────────────────────────────────────\n\n  attachScopeRecorder(recorder: ScopeRecorder): void {\n    // Replace existing recorder with same ID (idempotent — prevents double-counting)\n    this._recorders = this._recorders.filter((r) => r.id !== recorder.id);\n    this._recorders.push(recorder);\n  }\n\n  detachScopeRecorder(recorderId: string): void {\n    this._recorders = this._recorders.filter((r) => r.id !== recorderId);\n  }\n\n  getScopeRecorders(): ScopeRecorder[] {\n    return [...this._recorders];\n  }\n\n  /** @internal */\n  notifyStageStart(): void {\n    this._invokeHook('onStageStart', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n    });\n  }\n\n  /** @internal */\n  notifyStageEnd(duration?: number): void {\n    this._invokeHook('onStageEnd', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      duration,\n    });\n  }\n\n  /** @internal */\n  notifyPause(pauseData?: unknown): void {\n    this._invokeHook('onPause', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      pauseData,\n      channel: 'scope' as const,\n    });\n  }\n\n  /** @internal */\n  notifyResume(hasInput: boolean): void {\n    this._invokeHook('onResume', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      hasInput,\n      channel: 'scope' as const,\n    });\n  }\n\n  /** @internal */\n  notifyCommit(mutations: CommitEvent['mutations']): void {\n    this._invokeHook('onCommit', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      mutations,\n    });\n  }\n\n  /**\n   * Refuse a write from a handle held past its stage (9.22.0). Throws with the\n   * stage the handle came from; the engine's error path attributes the throw\n   * to the stage that made the write.\n   */\n  private assertLive(key: string): void {\n    if (this._committed) {\n      throw new Error(deadFrameMessage(this._stageName, this._stageContext.runtimeStageId, key));\n    }\n  }\n\n  /** Called by StageContext.commit() observer. Converts tracked writes to CommitEvent format.\n   *  Errors are caught to prevent recorder issues from aborting the traversal. */\n  private _onCommitFired(mutations: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }>): void {\n    this._committed = true;\n    if (this._recorders.length === 0) return;\n\n    try {\n      // `_stageWrites` already holds the retained form (the context retains\n      // under the same rule); applying the verdict again here is idempotent\n      // and keeps a key marked AFTER its write scrubbed at commit time.\n      const commitMutations: CommitEvent['mutations'] = Object.entries(mutations).map(([key, entry]) => ({\n        key,\n        value: this.rule.retain([key], entry.value),\n        operation: entry.operation,\n      }));\n\n      this.notifyCommit(commitMutations);\n    } catch {\n      // Swallow — recorder errors must not abort the traversal.\n      // Individual recorder errors are already isolated by _invokeHook.\n    }\n  }\n\n  // ── Debug / Diagnostics ──────────────────────────────────────────────────\n  //\n  // These legacy methods still write to the `StageContext` diagnostic\n  // side bags (logContext / errorContext / metricContext / evalContext) for\n  // snapshot inclusion. They ALSO fire through the Emit channel so any\n  // attached `EmitRecorder` sees them in real time — closing the\n  // long-standing gap where `$debug`/`$metric` went to unobserved bags.\n\n  addDebugInfo(key: string, value: unknown) {\n    const kept = this._stageContext.addDiagnostic('logs', key, value);\n    this.emitEvent(`log.debug.${key}`, { key, value: kept, level: 'debug' });\n  }\n\n  addDebugMessage(value: unknown) {\n    const kept = this._stageContext.addDiagnostic('logs', 'messages', [value]);\n    this.emitEvent('log.debug.messages', { value: Array.isArray(kept) ? kept[0] : kept, level: 'debug' });\n  }\n\n  addErrorInfo(key: string, value: unknown) {\n    const kept = this._stageContext.addDiagnostic('errors', key, value);\n    this.emitEvent(`log.error.${key}`, { key, value: kept, level: 'error' });\n  }\n\n  addMetric(metricName: string, value: unknown) {\n    const kept = this._stageContext.addDiagnostic('metrics', metricName, value);\n    this.emitEvent(`metric.${metricName}`, { name: metricName, value: kept });\n  }\n\n  addEval(metricName: string, value: unknown) {\n    const kept = this._stageContext.addDiagnostic('evals', metricName, value);\n    this.emitEvent(`eval.${metricName}`, { name: metricName, value: kept });\n  }\n\n  // ── Emit — Phase 3 primary primitive ─────────────────────────────────────\n\n  /**\n   * Fire a structured event to every attached recorder implementing\n   * `onEmit`. Synchronous, in-order, pass-through — no buffering.\n   *\n   * - **Fast-path**: zero allocation + zero cost when no recorders are\n   *   attached (early return on empty list).\n   * - **Enrichment**: library auto-adds `stageName`, `runtimeStageId`,\n   *   `subflowPath`, `pipelineId`, `timestamp` to the event.\n   * - **Redaction**: `RedactionPolicy.emitPatterns` regexes are matched\n   *   against `name` — matched events have their payload replaced with\n   *   `'[REDACTED]'` before dispatch.\n   * - **Error isolation**: a throwing `onEmit` does not propagate — it is\n   *   caught and routed to `onError` on remaining recorders, matching the\n   *   pattern used by other scope events.\n   *\n   * Consumers call this via the `scope.$emit(name, payload)` scope method;\n   * the method routes here via `createTypedScope`.\n   */\n  emitEvent(name: string, payload: unknown): void {\n    // Fast-path: zero work when no recorders are attached.\n    if (this._recorders.length === 0) return;\n\n    // Redaction: if the event name matches any emitPattern, replace payload\n    // with '[REDACTED]' BEFORE constructing the event (no leak through\n    // copy-on-write, no way for recorders to see the raw value).\n    const finalPayload = this.rule.retainEmit(name, payload);\n    const sourcePosition = this._stageContext.captureEmitPosition();\n\n    // Build the enriched event once; pass the same reference to all\n    // recorders under their read-only contract. Source coordinates are\n    // captured before any inline hook or deferred tap observes the event.\n    const event = {\n      name,\n      payload: finalPayload,\n      stageName: this._stageName,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      subflowPath: this._getSubflowPath(),\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      ...(sourcePosition === undefined ? {} : { sourcePosition }),\n    } as const;\n\n    // Dispatch with error isolation — the same `fire` loop and the same failure routing as\n    // every other scope event: a throwing recorder's error reaches onError on the recorders;\n    // the emit loop continues unaffected.\n    fire(this._recorders, 'onEmit', event, this._routeFailure);\n  }\n\n  // ── Detach — fire-and-forget child flowchart execution ─────────────────\n  //\n  // Delegates to the shared `detach/spawn` helper, which mints a refId\n  // from this stage's `runtimeStageId` and calls `driver.schedule()`.\n  // Routed through `createTypedScope` as `scope.$detachAndJoinLater(...)`\n  // and `scope.$detachAndForget(...)`.\n\n  /** See `ScopeMethods.$detachAndJoinLater`. */\n  detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle {\n    return detachAndJoinLaterSpawn(driver, child, input, this._stageContext.runtimeStageId);\n  }\n\n  /** See `ScopeMethods.$detachAndForget`. */\n  detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void {\n    detachAndForgetSpawn(driver, child, input, this._stageContext.runtimeStageId);\n  }\n\n  /**\n   * Build the subflowPath (outer → inner) for event enrichment.\n   *\n   * Parses from `runtimeStageId` which has the format\n   * `[subflowPath/]stageId#executionIndex` (see `lib/ids/runtimeStageId.ts`).\n   * Subflow isolation prevents walking the parent-chain across boundaries,\n   * so the runtimeStageId — globally unique, includes full path — is the\n   * canonical source of truth for the subflow hierarchy at emit time.\n   *\n   * Examples:\n   *   'seed#0'                 → []                    (root)\n   *   'sf-inner/inner#5'       → ['sf-inner']\n   *   'sf-a/sf-b/stage#3'      → ['sf-a', 'sf-b']      (nested)\n   */\n  private _getSubflowPath(): readonly string[] {\n    const rtid = this._stageContext.runtimeStageId;\n    if (!rtid) return ScopeFacade._EMPTY_SUBFLOW_PATH;\n    // The grammar's one owner reads the path portion (`ids/runtimeStageId.ts`).\n    const segments = subflowSegmentsOf(rtid);\n    if (segments.length === 0) return ScopeFacade._EMPTY_SUBFLOW_PATH;\n    return Object.freeze(segments);\n  }\n\n  // ── Non-Tracking State Inspection (for TypedScope proxy internals) ──────\n\n  /** Returns all state keys without firing onRead. Used by TypedScope ownKeys/has traps. */\n  getStateKeys(): string[] {\n    const snapshot = this._stageContext.getValue([], undefined);\n    if (!snapshot || typeof snapshot !== 'object') return [];\n    return Object.keys(snapshot as Record<string, unknown>);\n  }\n\n  /** Check key existence without firing onRead. Used by TypedScope has trap.\n   *  Contract: returns false for keys never set OR keys set to undefined.\n   *  This matches deleteValue() semantics (sets to undefined = deleted). */\n  hasKey(key: string): boolean {\n    return this._stageContext.getValue([], key) !== undefined;\n  }\n\n  /** Read state without firing onRead. Used by array proxy getCurrent() to avoid\n   *  phantom reads on internal array operations (.length, .has, iteration, etc.).\n   *  The initial property access fires one tracked onRead via getValue(); subsequent\n   *  internal array operations use this method to stay silent.\n   *  NOTE: Like getValue(), returns the raw value to the caller. Redaction applies\n   *  only to recorder dispatch — it does not filter the returned value. This matches\n   *  the existing getValue() contract where user code always receives raw data.\n   *\n   *  RFC-003 D2: a silent read of a key this stage never TRACKED-read marks\n   *  the stage's commit with `untrackedSources: ['silent']` — a causal slice\n   *  built from onRead events would miss this dependency, and consumers must\n   *  be told. Silent reads shadowed by a tracked read of the same key (the\n   *  array-proxy pattern above) are not flagged: their edge is captured. A\n   *  whole-state silent read (no key) is always flagged. */\n  getValueSilent(key?: string): unknown {\n    if (key === undefined || !this._trackedReadKeys.has(key)) {\n      this._stageContext.markUntrackedSource('silent');\n    }\n    return this._stageContext.getValueDirect([], key);\n  }\n\n  // ── State Access ─────────────────────────────────────────────────────────\n\n  getInitialValueFor(key: string) {\n    return this._stageContext.getGlobal?.(key);\n  }\n\n  /**\n   * Tracked read of shared state.\n   *\n   * **Read values are BORROWED — do not mutate them.** Since the lazy buffer\n   * (#13), reads before the stage's first write return references INTO\n   * COMMITTED SHARED STATE, and reads after a write return references into\n   * the stage's private transaction-buffer working copy (the eager engine\n   * returned references into that working copy for ALL reads). Mutating a\n   * returned value in place would corrupt state without a commit record —\n   * write changes back via `setValue`/`updateValue` instead. TypedScope\n   * consumers are safe automatically: the proxy routes every mutation\n   * through `setValue`/`updateValue`/copy-on-write array ops.\n   *\n   * There is deliberately NO dev-mode freeze guard here: deep-freezing a\n   * buffer-served read would freeze the stage's own working copy and make a\n   * legitimate read-then-deep-write throw, and freezing a committed-state\n   * read mutates an object shared with every other consumer of the live\n   * state. See `src/lib/memory/README.md` (\"Read values are borrowed\").\n   *\n   * Recorder note: the `onRead` event below passes the SAME live reference\n   * (no clone) unless field-level redaction scrubs a copy — recorders must\n   * treat event values as read-only too.\n   */\n  getValue(key?: string) {\n    return this.getValueAt([], key);\n  }\n\n  /**\n   * Path-aware adapter access. Segments stay separate from literal dotted keys in STATE;\n   * the recorder event's `key` is only a dot-joined display label, so `['user','ssn']` and\n   * a literal top-level `'user.ssn'` produce the same event key (same for the writes below).\n   */\n  getValueAt(path: string[], key?: string) {\n    const value = this._stageContext.getValue(path, key);\n\n    // RFC-003 D2: remember tracked keys so later SILENT reads of the same\n    // key count as shadowed (edge already captured) instead of untracked.\n    // Only a whole top-level value shadows a later silent read of that value.\n    // Reading one nested field must not claim to have observed its siblings.\n    if (path.length === 0 && key !== undefined) this._trackedReadKeys.add(key);\n    else if (path.length === 1 && key === undefined) this._trackedReadKeys.add(path[0]!);\n\n    if (this._recorders.length > 0) {\n      // A whole-state read (no key) is served with every redacted key inside\n      // it scrubbed; a keyed read is served under the key's verdict.\n      const wholeState = path.length === 0 && key === undefined;\n      const verdict = wholeState ? CLEAR : key === undefined ? this.rule.verdict(path) : this.rule.verdictAt(path, key);\n      const recorderValue = wholeState ? this.rule.retainRecord(value) : RedactionRule.apply(verdict, value);\n      const eventKey = path.length === 0 ? key : (key === undefined ? path : [...path, key]).join('.');\n\n      this._invokeHook('onRead', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key: eventKey,\n        value: recorderValue,\n        redacted: verdict.kind !== 'clear' || undefined,\n      });\n    }\n\n    return value;\n  }\n\n  setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string) {\n    return this.setValueAt([], key, value, shouldRedact, description);\n  }\n\n  /** Path-aware writes share recording, redaction and lifetime policy with flat writes. */\n  setValueAt(path: string[], key: string, value: unknown, shouldRedact?: boolean, description?: string) {\n    const eventKey = path.length === 0 ? key : [...path, key].join('.');\n    assertNotReadonly(this._readOnlyValues, path[0] ?? key, 'write');\n    this.assertLive(eventKey);\n\n    // Dev-mode: warn if the value contains circular references.\n    // Check AFTER assertNotReadonly — don't warn for writes that will be blocked.\n    // Circular values work (terminal proxy handles them) but can produce\n    // surprising behavior in narrative, JSON serialization, and snapshots.\n    if (isDevMode() && value !== null && typeof value === 'object') {\n      if (hasCircularReference(value)) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[footprint] Circular reference detected in setValue('${eventKey}'). ` +\n            'Writes past the cycle depth will use terminal proxy tracking. ' +\n            'Consider flattening the data structure.',\n        );\n      }\n    }\n\n    // The context is the ONE funnel: it decides the verdict (explicit flag,\n    // policy key/pattern, per-run mark, or field-level scrub), stages the\n    // write with the paths the log will scrub, and hands the verdict back so\n    // recorders see the same decision the retained record holds.\n    const verdict = this._stageContext.setObject(path, key, value, shouldRedact, description);\n\n    if (this._recorders.length > 0) {\n      this._invokeHook('onWrite', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key: eventKey,\n        value: RedactionRule.apply(verdict, value),\n        operation: 'set',\n        redacted: verdict.kind !== 'clear' || undefined,\n      });\n    }\n  }\n\n  updateValue(key: string, value: unknown, description?: string) {\n    return this.updateValueAt([], key, value, description);\n  }\n\n  /** Path-aware merges use the same write funnel as replacements. */\n  updateValueAt(path: string[], key: string, value: unknown, description?: string) {\n    const eventKey = path.length === 0 ? key : [...path, key].join('.');\n    assertNotReadonly(this._readOnlyValues, path[0] ?? key, 'write');\n    this.assertLive(eventKey);\n\n    // Dev-mode: same circular check as setValue (merge targets can be circular too)\n    if (isDevMode() && value !== null && typeof value === 'object') {\n      if (hasCircularReference(value)) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[footprint] Circular reference detected in updateValue('${eventKey}'). ` +\n            'Consider flattening the data structure.',\n        );\n      }\n    }\n\n    const verdict = this._stageContext.updateObject(path, key, value, description);\n\n    if (this._recorders.length > 0) {\n      this._invokeHook('onWrite', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key: eventKey,\n        value: RedactionRule.apply(verdict, value),\n        operation: 'update',\n        redacted: verdict.kind !== 'clear' || undefined,\n      });\n    }\n  }\n\n  deleteValue(key: string, description?: string) {\n    assertNotReadonly(this._readOnlyValues, key, 'delete');\n    this.assertLive(key);\n\n    // Deleting a key clears its per-call redaction mark (the context's\n    // funnel does that); a policy verdict on the key survives.\n    this._stageContext.setObject([], key, undefined, false, description ?? `deleted ${key}`, 'delete');\n\n    if (this._recorders.length > 0) {\n      this._invokeHook('onWrite', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key,\n        value: undefined,\n        operation: 'delete',\n      });\n    }\n  }\n\n  /** @internal */\n  setGlobal(key: string, value: unknown, description?: string) {\n    this.assertLive(key);\n    return this._stageContext.setGlobal?.(key, value, description);\n  }\n\n  /** @internal */\n  getGlobal(key: string) {\n    return this._stageContext.getGlobal?.(key);\n  }\n\n  /** @internal */\n  setObjectInRoot(key: string, value: unknown) {\n    this.assertLive(key);\n    return this._stageContext.setRoot?.(key, value);\n  }\n\n  // ── Read-only + misc ─────────────────────────────────────────────────────\n\n  /**\n   * Returns the readonly input values passed to this pipeline, cast to `T`.\n   * Ordinary mutable records/arrays are copied and frozen, not frozen in place.\n   * Opaque capabilities and explicitly frozen wrappers remain borrowed/live;\n   * see `protection/readonlyInput.ts · createFrozenArgs` for the ownership rule.\n   * Cached at construction time for zero-allocation repeated access.\n   *\n   * ```typescript\n   * const { applicantName, income } = scope.getArgs<{ applicantName: string; income: number }>();\n   * ```\n   *\n   * RFC-003 D2: args are untracked BY DESIGN, so calling this (with actual\n   * input present) marks the stage's commit with `untrackedSources: ['args']`\n   * — telling causal-slice consumers the backward slice may be incomplete\n   * here. An empty-args read carries no information and is not flagged.\n   */\n  getArgs<T = Record<string, unknown>>(): T {\n    if (this._hasArgs) this._stageContext.markUntrackedSource('args');\n    return this._frozenArgs as T;\n  }\n\n  /**\n   * Returns the execution environment — read-only infrastructure values\n   * that propagate through nested executors (like `process.env` for flowcharts).\n   *\n   * Contains: signal (abort), timeoutMs, traceId.\n   * Frozen at construction time. Inherited by subflows automatically.\n   *\n   * ```typescript\n   * const { signal, traceId } = scope.getEnv();\n   * ```\n   *\n   * RFC-003 D2: env is untracked BY DESIGN, so calling this (with a\n   * non-empty environment) marks the stage's commit with\n   * `untrackedSources: ['env']` — see {@link getArgs}.\n   */\n  getEnv(): Readonly<ExecutionEnv> {\n    if (this._hasEnv) this._stageContext.markUntrackedSource('env');\n    return this._executionEnv;\n  }\n\n  /** @internal */\n  getPipelineId() {\n    return this._stageContext.runId;\n  }\n\n  // ── Internal ─────────────────────────────────────────────────────────────\n\n  private _invokeHook<K extends ScopeHookName>(hook: K, event: HookPayload<K>): void {\n    // The one per-recorder loop (`recorder/hooks.ts · fire`) — the SAME invoke primitive the\n    // deferred tier uses at delivery time, so the inline and deferred paths cannot drift.\n    fire(this._recorders, hook, event, this._routeFailure);\n  }\n\n  /**\n   * The scope channel's isolation: a recorder's throw becomes an `onError` on every recorder\n   * (stamped with this stage), and a throw from `onError` itself is dropped.\n   */\n  private readonly _routeFailure: HookFailure = (error, _recorder, hook) => {\n    if (hook === 'onError') return;\n    this._invokeHook(\n      'onError',\n      recorderFailureEvent(\n        {\n          stageName: this._stageName,\n          stageId: this._stageContext.stageId,\n          runtimeStageId: this._stageContext.runtimeStageId,\n          pipelineId: this._stageContext.runId,\n        },\n        error,\n        hook,\n      ),\n    );\n  };\n}\n"]}
+/** The signal of a stage outside the runner in a run with no signal: one that never aborts, shared. */
+const NEVER_ABORTED = new AbortController().signal;
+/** The name a late detach is recorded under: the child chart's root id — a name, never its input. */
+function detachKey(child) {
+    const id = child?.root?.id;
+    return typeof id === 'string' ? `detach:${id}` : 'detach';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ScopeFacade.js","sourceRoot":"","sources":["../../../src/lib/scope/ScopeFacade.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ScopeFacade — Base class that library consumers extend to create custom scope classes\n *\n * Wraps StageContext (from memory/) to provide a consumer-friendly API for\n * state access, debug logging, metrics, and recorder hooks.\n *\n * Consumers extend this class to add domain-specific properties:\n *\n * ```typescript\n * class MyScope extends ScopeFacade {\n *   get userName(): string { return this.getValue('name') as string; }\n *   set userName(value: string) { this.setValue('name', value); }\n * }\n * ```\n */\n\nimport { subflowSegmentsOf } from 'foottrace';\n\nimport { callSeries, runCall } from '../attempt/call.js';\nimport { callTouches } from '../attempt/effect.js';\nimport { admitAttemptName } from '../attempt/name.js';\nimport { observedRecord, ObservedSeriesBook, readObservedReport } from '../attempt/observed.js';\nimport { admitCallPolicy, attemptCeiling } from '../attempt/policy.js';\nimport { takeRetryLoopCall } from '../attempt/retryLoopContext.js';\nimport { attemptEndsAt } from '../attempt/runner.js';\nimport type {\n  AttemptContext,\n  AttemptError,\n  CallOptions,\n  LateWrite,\n  ObservedAttempt,\n  RetryPolicy,\n  RunCorrelation,\n} from '../attempt/types.js';\nimport type { FlowChart } from '../builder/types.js';\nimport { hasCircularReference } from '../capture/circular.js';\nimport {\n  detachAndForget as detachAndForgetSpawn,\n  detachAndJoinLater as detachAndJoinLaterSpawn,\n} from '../detach/spawn.js';\nimport type { DetachDriver, DetachHandle } from '../detach/types.js';\nimport { isDevMode } from '../devMode.js';\nimport type { ExecutionEnv } from '../engine/types.js';\nimport { deadFrameMessage, lateAttemptMessage } from '../memory/borrowedMutation.js';\nimport { CLEAR, RedactionRule } from '../memory/redaction.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { HookFailure, HookPayload, ScopeHookName } from '../recorder/hooks.js';\nimport { fire, recorderFailureEvent } from '../recorder/hooks.js';\nimport { assertNotReadonly, createFrozenArgs } from './protection/readonlyInput.js';\nimport { registerScopeRuntime } from './runtime.js';\nimport type { CommitEvent, RedactionPolicy, RedactionReport, ScopeRecorder } from './types.js';\n\nexport class ScopeFacade {\n  public static readonly BRAND = Symbol.for('ScopeFacade@v1');\n\n  /**\n   * Shared sentinel returned by `_getSubflowPath()` for root-level stages\n   * (no subflow nesting). Avoids per-call allocation of a fresh\n   * `Object.freeze([])` on every `emitEvent` in the common no-subflow case.\n   */\n  private static readonly _EMPTY_SUBFLOW_PATH: readonly string[] = Object.freeze([]);\n\n  protected _stageContext: StageContext;\n  protected _stageName: string;\n  protected readonly _readOnlyValues?: unknown;\n\n  /** Cached deeply-frozen copy of readOnlyValues for getArgs(). Created once. */\n  private readonly _frozenArgs: Record<string, unknown>;\n\n  /** Execution environment — read-only, inherited from parent executor. */\n  private readonly _executionEnv: Readonly<ExecutionEnv>;\n\n  /** RFC-003 D2: true when `getArgs()` can return actual data — an empty\n   *  `{}` read carries no information, so it is never flagged. */\n  private readonly _hasArgs: boolean;\n\n  /** RFC-003 D2: true when `getEnv()` can return actual data. */\n  private readonly _hasEnv: boolean;\n\n  /**\n   * RFC-003 D2: keys this stage has TRACKED-read (via `getValue(key)`).\n   * A silent read of a key in this set is SHADOWED — its read→write edge is\n   * already captured, so it is not flagged as an untracked source. This is\n   * what keeps TypedScope array-proxy internals (which always follow a\n   * tracked property read) and `$batchArray` honest-but-quiet.\n   */\n  private readonly _trackedReadKeys = new Set<string>();\n\n  private _recorders: ScopeRecorder[] = [];\n\n  /**\n   * Set by the commit observer: this stage's frame has flushed. A facade is\n   * ONE stage execution's handle — the engine builds a fresh one per stage —\n   * and every proxy the typed scope hands out is bound to it. A write arriving\n   * after the commit comes from a handle held past its stage (a closure, a\n   * module-level `let`) and would land in a buffer nothing ever commits: no\n   * trace row, state unchanged. So it is refused ({@link assertLive}) instead\n   * of lost. Sealing here and not on `StageContext` is deliberate: the frame\n   * stays re-usable after commit by design (#13b — the engine's double-commit\n   * paths and the subflow merge-back into a branch parent need it).\n   */\n  private _committed = false;\n\n  /**\n   * A rule of this facade's own — ONLY when its context carries none (bare\n   * contexts in unit tests). Under an executor the rule lives on the context\n   * tree and this stays unset; see {@link rule}.\n   */\n  private _localRule?: RedactionRule;\n\n  /**\n   * The run's correlation (10.1), installed by the executor's composed scope factory\n   * (`RunObservers · composeScopeFactory`) — stamped LAST on every scope and emit event this facade fires,\n   * only when present, so a run without one fires byte-identical events.\n   */\n  private _correlation?: RunCorrelation;\n\n  /**\n   * The attempt this facade was built for (P1b) — the runner's, read off the\n   * context at construction. A facade is ONE attempt's handle: once that\n   * attempt ends without an answer (its cap, the deadline, a cancellation, a\n   * throw), the function behind it may still be running, and anything it\n   * touches through this facade is refused ({@link refuseIfAttemptEnded}) —\n   * a write or an emit is also recorded on the stage. Absent for a stage the\n   * runner does not run: nothing is fenced, as before.\n   */\n  private readonly _attempt?: AttemptContext;\n\n  /** The run's signal, for `$attempt()` of a stage the runner does not run. */\n  private readonly _runSignal?: AbortSignal;\n\n  /** `$call`s with `of > 1` in flight through this facade — a keyless touching call inside one is refused (P3). */\n  private _retryingCalls = 0;\n\n  /** This attempt's observed reports, grouped into series (P2) — made on the first report. */\n  private _observedBook?: ObservedSeriesBook;\n\n  constructor(context: StageContext, stageName: string, readOnlyValues?: unknown, executionEnv?: ExecutionEnv) {\n    this._stageContext = context;\n    this._stageName = stageName;\n    this._readOnlyValues = readOnlyValues;\n    this._frozenArgs = createFrozenArgs(readOnlyValues);\n    this._executionEnv = Object.freeze({ ...executionEnv });\n    this._hasArgs = Object.keys(this._frozenArgs).length > 0;\n    this._hasEnv = Object.keys(this._executionEnv).length > 0;\n    this._attempt = context.attempt;\n    this._runSignal = context.runSignal;\n    // The context must carry the rule BEFORE the first write, since the\n    // context's write funnel is what marks a per-call redacted key on it.\n    // Under an executor the context already has the run's rule (installed on\n    // the root, inherited down) and this re-installs the same object; on a\n    // bare context it installs a fresh one.\n    this._stageContext.useRedactionRule(this.rule);\n\n    // Register as commit observer so ScopeRecorder.onCommit fires when StageContext.commit() is called\n    this._stageContext.setCommitObserver((mutations) => {\n      this._onCommitFired(mutations);\n    });\n    registerScopeRuntime(this, { target: this, handlesAssignments: false });\n  }\n\n  /**\n   * The redaction rule this facade decides with — the SAME object its\n   * `StageContext` retains with (`memory/redaction.ts`, the one owner). Under\n   * an executor the rule is installed on the runtime root and inherited by\n   * every context, so the facade simply reads it. On a bare context (unit\n   * tests, hand-built scopes) the facade creates one and installs it on the\n   * context, so the context's retention and the facade's recorder views\n   * still share a single verdict.\n   */\n  private get rule(): RedactionRule {\n    const shared = this._stageContext.getRedactionRule();\n    if (shared) return shared;\n    if (!this._localRule) {\n      this._localRule = new RedactionRule();\n      this._stageContext.useRedactionRule(this._localRule);\n    }\n    return this._localRule;\n  }\n\n  /**\n   * Share a redacted-keys set across multiple ScopeFacade instances.\n   * Call this to make redaction persist across stages in the same pipeline.\n   * (Under an executor the run's rule already shares one set; this call is\n   * then a no-op.)\n   * @internal\n   */\n  useSharedRedactedKeys(sharedSet: Set<string>): void {\n    this.rule.useMarkedKeys(sharedSet);\n  }\n\n  /**\n   * Returns the current redacted-keys set (for sharing with other scopes).\n   * @internal\n   */\n  getRedactedKeys(): Set<string> {\n    return this.rule.markedKeys();\n  }\n\n  /**\n   * Apply a declarative redaction policy. The policy is additive —\n   * it works alongside manual `setValue(..., true)` calls.\n   * @internal\n   */\n  useRedactionPolicy(policy: RedactionPolicy): void {\n    this.rule.setPolicy(policy);\n  }\n\n  /**\n   * Install the run's correlation — every scope and emit event this facade fires carries it; `undefined` clears\n   * it. Engine-only (the composed scope factory calls it once per stage), like `useRedactionPolicy`.\n   * @internal\n   */\n  useCorrelation(correlation: RunCorrelation | undefined): void {\n    this._correlation = correlation;\n  }\n\n  /** @internal */\n  getRedactionPolicy(): RedactionPolicy | undefined {\n    return this.rule.getPolicy();\n  }\n\n  /**\n   * Returns a compliance-friendly report of all redaction activity.\n   * Never includes actual values — only key names, field names, and patterns.\n   */\n  getRedactionReport(): RedactionReport {\n    return this.rule.report();\n  }\n\n  // ── ScopeRecorder Management ──────────────────────────────────────────────────\n\n  attachScopeRecorder(recorder: ScopeRecorder): void {\n    // Replace existing recorder with same ID (idempotent — prevents double-counting)\n    this._recorders = this._recorders.filter((r) => r.id !== recorder.id);\n    this._recorders.push(recorder);\n  }\n\n  detachScopeRecorder(recorderId: string): void {\n    this._recorders = this._recorders.filter((r) => r.id !== recorderId);\n  }\n\n  getScopeRecorders(): ScopeRecorder[] {\n    return [...this._recorders];\n  }\n\n  /** @internal */\n  notifyStageStart(): void {\n    this._invokeHook('onStageStart', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n    });\n  }\n\n  /** @internal */\n  notifyStageEnd(duration?: number): void {\n    this._invokeHook('onStageEnd', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      duration,\n    });\n  }\n\n  /** @internal */\n  notifyPause(pauseData?: unknown): void {\n    this._invokeHook('onPause', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      pauseData,\n      channel: 'scope' as const,\n    });\n  }\n\n  /** @internal */\n  notifyResume(hasInput: boolean): void {\n    this._invokeHook('onResume', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      hasInput,\n      channel: 'scope' as const,\n    });\n  }\n\n  /** @internal */\n  notifyCommit(mutations: CommitEvent['mutations']): void {\n    this._invokeHook('onCommit', {\n      stageName: this._stageName,\n      stageId: this._stageContext.stageId,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      mutations,\n    });\n  }\n\n  /**\n   * Refuse a write from a handle held past its stage (9.22.0). Throws with the\n   * stage the handle came from; the engine's error path attributes the throw\n   * to the stage that made the write.\n   */\n  private assertLive(key: string, channel: LateWrite['channel'] = 'state'): void {\n    this.refuseIfAttemptEnded(key, channel);\n    if (this._committed) {\n      throw new Error(deadFrameMessage(this._stageName, this._stageContext.runtimeStageId, key));\n    }\n  }\n\n  /**\n   * The attempt fence (P1b): this facade's attempt has ended, so whatever the\n   * abandoned function does now must not reach the stage — not its buffer, its\n   * reads, its untracked sources or a recorder. Refused; a write or an emit is\n   * recorded on the stage first (`StageSnapshot.lateWrites`, the name only),\n   * a read (`channel` undefined) is not.\n   */\n  private refuseIfAttemptEnded(key: string, channel?: LateWrite['channel']): void {\n    const attempt = this._attempt;\n    if (attempt === undefined || !this._stageContext.hasAttemptEnded(attempt.attempt)) return;\n    if (channel !== undefined) this._stageContext.recordLateWrite({ attempt: attempt.attempt, key, channel });\n    throw new Error(lateAttemptMessage(this._stageName, attempt.series, attempt.attempt, key));\n  }\n\n  /**\n   * The attempt this stage function runs in — `scope.$attempt()` (design\n   * §3.1). Its `signal` aborts when the attempt must stop (its cap, the run's\n   * deadline, a cancellation): pass it to `fetch` and SDK calls. Its\n   * `timeLeftMs()` reads the run's deadline — time is an input the record\n   * cannot replay, so with a deadline the read marks the stage's commit\n   * `untrackedSources: ['env']`, as `getEnv()` does.\n   *\n   * A stage the attempt runner does not run (no retry policy, no `timeoutMs`,\n   * no deadline) is attempt 1 of 1, with the run's signal and `Infinity` left.\n   *\n   * ```typescript\n   * const t = scope.$attempt();\n   * const res = await fetch(url, { signal: t.signal });\n   * if (t.timeLeftMs() < 1_000) scope.summary = 'partial';\n   * ```\n   */\n  getAttempt(): AttemptContext {\n    const attempt = this._attempt;\n    const observed = (report: ObservedAttempt) => this.recordObserved(report);\n    if (attempt === undefined) {\n      return Object.freeze({\n        series: this._stageContext.runtimeStageId,\n        attempt: 1,\n        of: 1,\n        signal: this._runSignal ?? NEVER_ABORTED,\n        timeLeftMs: () => Infinity,\n        observed,\n      });\n    }\n    this.refuseIfAttemptEnded('$attempt');\n    const context = this._stageContext;\n    return Object.freeze({\n      ...attempt,\n      timeLeftMs: () => {\n        // Read through a handle held past its attempt, it must not mark a LATER attempt's commit.\n        this.refuseIfAttemptEnded('$attempt');\n        if (attempt.deadline !== undefined) context.markUntrackedSource('env');\n        return attempt.timeLeftMs();\n      },\n      observed,\n    });\n  }\n\n  /**\n   * A call to an outside system, made inside this stage — `scope.$call(target, fn, policy?)` (design §3.6, P2).\n   * `fn` runs on the attempt runner under `policy` (none = ONE attempt, still recorded: a single call is evidence\n   * too), and every attempt is an `AttemptRecord` of kind `'call'` on this stage's execution-tree node and on\n   * `onAttempt` — its timing, outcome, failure category and the retry-or-stop decision, its error served under the\n   * run's redaction rule.\n   *\n   * The call lives within this stage attempt: it is capped by the time the attempt has left (its cap, the run's\n   * deadline) and `fn`'s `signal` aborts when the attempt does; once the attempt is over nothing of the call lands\n   * and no further attempt of it starts (`attempt/call.ts`). `target` is a NAME from code — never a value.\n   *\n   * ```typescript\n   * const quote = await scope.$call('stripe.quotes.create', (t) => stripe.quotes.create(body, { signal: t.signal }),\n   *   { attempts: 3, timeoutMs: 10_000, backoffMs: (n) => 500 * n });\n   * ```\n   *\n   * A call that CHANGES an outside system declares it (P3): `options.touches` names the system and\n   * `options.idempotencyKey` the key every attempt is made under (`t.idempotencyKey`) — a value from the stage's\n   * input or state, never from model output. A touching call that may retry without a key is refused here,\n   * before anything is sent; each record says what its attempt did (`effect`), and a call that ends without an answer after any attempt left the\n   * effect unknown rejects with `UnknownEffectError` — reconcile by the key, do not retry blindly.\n   */\n  call<T>(\n    target: string,\n    fn: (attempt: AttemptContext) => Promise<T> | T,\n    policy?: RetryPolicy,\n    options?: CallOptions,\n  ): Promise<T> {\n    const name = admitAttemptName('$call', 'target', target);\n    const where = `$call('${name}')`;\n    if (typeof fn !== 'function') throw new TypeError(`${where}: fn must be a function`);\n    const admitted = admitCallPolicy(where, policy);\n    const touches = callTouches(where, options, admitted);\n    // A keyless touching call is sent once only if the stage attempt that makes it never runs again (P3): a stage\n    // that may retry would re-send it without a key — refused here, before anything is sent.\n    // So is one inside an enclosing `$call` that may retry (its function runs once per outer attempt).\n    if (touches !== undefined && touches.idempotencyKey === undefined) {\n      const enclosing = (this._attempt?.of ?? 1) > 1 ? 'a stage' : this._retryingCalls > 0 ? 'a $call' : undefined;\n      if (enclosing !== undefined) {\n        throw new TypeError(\n          `${where}: touches \"${touches.system}\" with no idempotencyKey, inside ${enclosing} that may retry — a ` +\n            'retry would send it again without a key. Give the call a key.',\n        );\n      }\n      this._stageContext.markKeylessEffect();\n    }\n    // From an ended attempt or a committed frame: refused (and recorded by name) before anything reaches outside.\n    this.refuseLateCall(`call:${name}`);\n    const context = this._stageContext;\n    const stageAttempt = this._attempt?.attempt ?? 1;\n    const signal = this._attempt?.signal ?? this._runSignal;\n    const deadline = attemptEndsAt(this._attempt);\n    const ended = context.callsEndedSignal(stageAttempt);\n    // While a call that may retry is in flight, a keyless touching call made inside it is refused (above).\n    const retrying = attemptCeiling(admitted.attempts) > 1;\n    if (retrying) this._retryingCalls += 1;\n    let result: Promise<T>;\n    try {\n      result = this.startCall(name, fn, admitted, touches, stageAttempt, signal, deadline, ended);\n    } catch (error) {\n      if (retrying) this._retryingCalls -= 1;\n      throw error;\n    }\n    if (!retrying) return result;\n    const release = () => {\n      this._retryingCalls -= 1;\n    };\n    result.then(release, release);\n    return result;\n  }\n\n  /** `runCall` with this stage attempt as its host (`call`). */\n  private startCall<T>(\n    name: string,\n    fn: (attempt: AttemptContext) => Promise<T> | T,\n    admitted: RetryPolicy,\n    touches: { readonly system: string; readonly idempotencyKey?: string } | undefined,\n    stageAttempt: number,\n    signal: AbortSignal | undefined,\n    deadline: number | undefined,\n    ended: AbortSignal,\n  ): Promise<T> {\n    const context = this._stageContext;\n    const loop = takeRetryLoopCall(this);\n    return runCall(name, fn, admitted, {\n      openSeries: () => callSeries(context.runtimeStageId, stageAttempt, context.nextCallOrdinal(stageAttempt)),\n      ...(signal !== undefined && { signal }),\n      ...(deadline !== undefined && { deadline }),\n      ended,\n      ...(touches !== undefined && { effect: this.callEffect(touches) }),\n      // The frame's own commit state (every attempt's facade reads the same), never a facade flag.\n      admits: (cut) => !context.committed && (cut || !(ended.aborted || this.attemptHasEnded())),\n      serve: (error) => this.rule.servedError(error),\n      report: (record, structuredError) => {\n        const served = loop ? Object.freeze({ ...record, retryLoop: loop.identity }) : record;\n        context.reportCallAttempt(served, structuredError);\n        loop?.record(served);\n      },\n      refused: () => context.recordLateWrite({ attempt: stageAttempt, key: `call:${name}`, channel: 'attempt' }),\n      observe: (report, at) => this.recordObserved(report, at.ended),\n    });\n  }\n\n  /** @internal The explicit retry helper owns this state; the normal write path still owns retention/commit. */\n  writeRetryLoopState(key: string, state: { readonly idempotencyKey: string }): void {\n    const kept = this.serveRetryLoopKey(state.idempotencyKey);\n    if (kept !== state.idempotencyKey) this.rule.inheritFields(key, ['idempotencyKey']);\n    this.setValue(key, state);\n  }\n\n  /** @internal Exactly the existing P3 key-retention law; operational state keeps the real key. */\n  serveRetryLoopKey(key: string): string {\n    return this.rule.retainIdempotencyKey(key, {\n      input: this._readOnlyValues,\n      selectedReads: this._stageContext.selectedReads + (this._stageContext.effectKeyTainted ? 1 : 0),\n    });\n  }\n\n  /** @internal Loop state is durable data: never persist the thrown value, stack, cause or payload. */\n  serveRetryLoopError(error: unknown): AttemptError {\n    const served = this.rule.servedError(error);\n    return {\n      message: served.message,\n      ...(served.name !== undefined ? { name: served.name } : {}),\n      ...(served.code !== undefined ? { code: served.code } : {}),\n    };\n  }\n\n  /** A touching call's target, its key served for the records (`RedactionRule · retainIdempotencyKey`: by name and by its sources). */\n  private callEffect(touches: { readonly system: string; readonly idempotencyKey?: string }): {\n    readonly system: string;\n    readonly idempotencyKey?: string;\n    readonly recordedKey?: string;\n  } {\n    const key = touches.idempotencyKey;\n    if (key === undefined) return touches;\n    // A key the stage built after reading a selected value — or from an input holding one — is served whole.\n    const recordedKey = this.rule.retainIdempotencyKey(key, {\n      input: this._readOnlyValues,\n      // The stage's own key may be made of a selected value: a key passed on from it is served the same way.\n      selectedReads: this._stageContext.selectedReads + (this._stageContext.effectKeyTainted ? 1 : 0),\n    });\n    return { ...touches, recordedKey };\n  }\n\n  /**\n   * A `$call` from an ended attempt, or from a frame that has committed: recorded by name (`lateWrites`, channel\n   * `'attempt'`) and refused — before anything reaches outside. The P1b fence first, so its message and record are\n   * the same.\n   */\n  private refuseLateCall(key: string): void {\n    this.refuseIfAttemptEnded(key, 'attempt');\n    if (!this._stageContext.committed && !this._committed) return;\n    this._stageContext.recordLateWrite({ attempt: this._attempt?.attempt ?? 1, key, channel: 'attempt' });\n    throw new Error(deadFrameMessage(this._stageName, this._stageContext.runtimeStageId, key));\n  }\n\n  /**\n   * An outside attempt an adapter reported — `AttemptContext.observed` on this stage's attempt or on one of its\n   * calls' (P2). Read and validated first (a malformed report is the adapter's bug: a `TypeError`, and it never\n   * reaches the record). A report that comes after its attempt ended — the call attempt it was made through, this\n   * stage attempt, or the frame's commit — is recorded by name (`lateWrites`, channel `'attempt'`) and DROPPED,\n   * never thrown: adapters report from an SDK's own callbacks, which may fire after the stage moved on, and an\n   * observed attempt never changes control flow — in either direction. Its series opens at this stage attempt's call\n   * level: an SDK's call is a call the stage attempt made, so a report made through a `$call` is that call's sibling.\n   */\n  private recordObserved(report: ObservedAttempt, callAttemptEnded = false): void {\n    const read = readObservedReport(report);\n    const key = `observed:${read.target}`;\n    const context = this._stageContext;\n    const stageAttempt = this._attempt?.attempt ?? 1;\n    if (callAttemptEnded || this.attemptHasEnded() || context.committed || this._committed) {\n      context.recordLateWrite({ attempt: stageAttempt, key, channel: 'attempt' });\n      return;\n    }\n    const book = (this._observedBook ??= new ObservedSeriesBook(() =>\n      callSeries(context.runtimeStageId, stageAttempt, context.nextCallOrdinal(stageAttempt)),\n    ));\n    const { record, structuredError } = observedRecord(read, {\n      series: book.seriesFor(read),\n      now: Date.now,\n      serve: (error) => this.rule.servedError(error),\n    });\n    context.reportCallAttempt(record, structuredError);\n  }\n\n  /** This facade's attempt has ended — the P1b fence is closed. */\n  private attemptHasEnded(): boolean {\n    const attempt = this._attempt;\n    return attempt !== undefined && this._stageContext.hasAttemptEnded(attempt.attempt);\n  }\n\n  /** Called by StageContext.commit() observer. Converts tracked writes to CommitEvent format.\n   *  Errors are caught to prevent recorder issues from aborting the traversal. */\n  private _onCommitFired(mutations: Record<string, { value: unknown; operation: 'set' | 'update' | 'delete' }>): void {\n    this._committed = true;\n    if (this._recorders.length === 0) return;\n\n    try {\n      // `_stageWrites` already holds the retained form (the context retains\n      // under the same rule); applying the verdict again here is idempotent\n      // and keeps a key marked AFTER its write scrubbed at commit time.\n      const commitMutations: CommitEvent['mutations'] = Object.entries(mutations).map(([key, entry]) => ({\n        key,\n        value: this.rule.retain([key], entry.value),\n        operation: entry.operation,\n      }));\n\n      this.notifyCommit(commitMutations);\n    } catch {\n      // Swallow — recorder errors must not abort the traversal.\n      // Individual recorder errors are already isolated by _invokeHook.\n    }\n  }\n\n  // ── Debug / Diagnostics ──────────────────────────────────────────────────\n  //\n  // These legacy methods still write to the `StageContext` diagnostic\n  // side bags (logContext / errorContext / metricContext / evalContext) for\n  // snapshot inclusion. They ALSO fire through the Emit channel so any\n  // attached `EmitRecorder` sees them in real time — closing the\n  // long-standing gap where `$debug`/`$metric` went to unobserved bags.\n\n  addDebugInfo(key: string, value: unknown) {\n    this.refuseIfAttemptEnded(`log.debug.${key}`, 'emit');\n    const kept = this._stageContext.addDiagnostic('logs', key, value);\n    this.emitEvent(`log.debug.${key}`, { key, value: kept, level: 'debug' });\n  }\n\n  addDebugMessage(value: unknown) {\n    this.refuseIfAttemptEnded('log.debug.messages', 'emit');\n    const kept = this._stageContext.addDiagnostic('logs', 'messages', [value]);\n    this.emitEvent('log.debug.messages', { value: Array.isArray(kept) ? kept[0] : kept, level: 'debug' });\n  }\n\n  addErrorInfo(key: string, value: unknown) {\n    this.refuseIfAttemptEnded(`log.error.${key}`, 'emit');\n    const kept = this._stageContext.addDiagnostic('errors', key, value);\n    this.emitEvent(`log.error.${key}`, { key, value: kept, level: 'error' });\n  }\n\n  addMetric(metricName: string, value: unknown) {\n    this.refuseIfAttemptEnded(`metric.${metricName}`, 'emit');\n    const kept = this._stageContext.addDiagnostic('metrics', metricName, value);\n    this.emitEvent(`metric.${metricName}`, { name: metricName, value: kept });\n  }\n\n  addEval(metricName: string, value: unknown) {\n    this.refuseIfAttemptEnded(`eval.${metricName}`, 'emit');\n    const kept = this._stageContext.addDiagnostic('evals', metricName, value);\n    this.emitEvent(`eval.${metricName}`, { name: metricName, value: kept });\n  }\n\n  // ── Emit — Phase 3 primary primitive ─────────────────────────────────────\n\n  /**\n   * Fire a structured event to every attached recorder implementing\n   * `onEmit`. Synchronous, in-order, pass-through — no buffering.\n   *\n   * - **Fast-path**: zero allocation + zero cost when no recorders are\n   *   attached (early return on empty list).\n   * - **Enrichment**: library auto-adds `stageName`, `runtimeStageId`,\n   *   `subflowPath`, `pipelineId`, `timestamp` to the event.\n   * - **Redaction**: `RedactionPolicy.emitPatterns` regexes are matched\n   *   against `name` — matched events have their payload replaced with\n   *   `'[REDACTED]'` before dispatch.\n   * - **Error isolation**: a throwing `onEmit` does not propagate — it is\n   *   caught and routed to `onError` on remaining recorders, matching the\n   *   pattern used by other scope events.\n   *\n   * Consumers call this via the `scope.$emit(name, payload)` scope method;\n   * the method routes here via `createTypedScope`.\n   */\n  emitEvent(name: string, payload: unknown): void {\n    // An ended attempt emits nothing — refused (and recorded) before the fast path, so the record does not depend\n    // on whether a recorder happened to be attached.\n    this.refuseIfAttemptEnded(name, 'emit');\n    // Fast-path: zero work when no recorders are attached.\n    if (this._recorders.length === 0) return;\n\n    // Redaction: if the event name matches any emitPattern, replace payload\n    // with '[REDACTED]' BEFORE constructing the event (no leak through\n    // copy-on-write, no way for recorders to see the raw value).\n    const finalPayload = this.rule.retainEmit(name, payload);\n    const sourcePosition = this._stageContext.captureEmitPosition();\n\n    // Build the enriched event once; pass the same reference to all\n    // recorders under their read-only contract. Source coordinates are\n    // captured before any inline hook or deferred tap observes the event.\n    const event = {\n      name,\n      payload: finalPayload,\n      stageName: this._stageName,\n      runtimeStageId: this._stageContext.runtimeStageId,\n      subflowPath: this._getSubflowPath(),\n      pipelineId: this._stageContext.runId,\n      timestamp: Date.now(),\n      ...(sourcePosition === undefined ? {} : { sourcePosition }),\n    } as const;\n\n    // Dispatch with error isolation — the same `fire` loop and the same failure routing as\n    // every other scope event: a throwing recorder's error reaches onError on the recorders;\n    // the emit loop continues unaffected.\n    fire(this._recorders, 'onEmit', this._correlated(event), this._routeFailure);\n  }\n\n  // ── Detach — fire-and-forget child flowchart execution ─────────────────\n  //\n  // Delegates to the shared `detach/spawn` helper, which mints a refId\n  // from this stage's `runtimeStageId` and calls `driver.schedule()`.\n  // Routed through `createTypedScope` as `scope.$detachAndJoinLater(...)`\n  // and `scope.$detachAndForget(...)`.\n\n  /** See `ScopeMethods.$detachAndJoinLater`. */\n  detachAndJoinLater(driver: DetachDriver, child: FlowChart, input?: unknown): DetachHandle {\n    this.refuseIfAttemptEnded(detachKey(child), 'detach');\n    return detachAndJoinLaterSpawn(driver, child, input, this._stageContext.runtimeStageId);\n  }\n\n  /** See `ScopeMethods.$detachAndForget`. */\n  detachAndForget(driver: DetachDriver, child: FlowChart, input?: unknown): void {\n    this.refuseIfAttemptEnded(detachKey(child), 'detach');\n    detachAndForgetSpawn(driver, child, input, this._stageContext.runtimeStageId);\n  }\n\n  /**\n   * Build the subflowPath (outer → inner) for event enrichment.\n   *\n   * Parses from `runtimeStageId` which has the format\n   * `[subflowPath/]stageId#executionIndex` (see `lib/ids/runtimeStageId.ts`).\n   * Subflow isolation prevents walking the parent-chain across boundaries,\n   * so the runtimeStageId — globally unique, includes full path — is the\n   * canonical source of truth for the subflow hierarchy at emit time.\n   *\n   * Examples:\n   *   'seed#0'                 → []                    (root)\n   *   'sf-inner/inner#5'       → ['sf-inner']\n   *   'sf-a/sf-b/stage#3'      → ['sf-a', 'sf-b']      (nested)\n   */\n  private _getSubflowPath(): readonly string[] {\n    const rtid = this._stageContext.runtimeStageId;\n    if (!rtid) return ScopeFacade._EMPTY_SUBFLOW_PATH;\n    // The grammar's one owner reads the path portion (`ids/runtimeStageId.ts`).\n    const segments = subflowSegmentsOf(rtid);\n    if (segments.length === 0) return ScopeFacade._EMPTY_SUBFLOW_PATH;\n    return Object.freeze(segments);\n  }\n\n  // ── Non-Tracking State Inspection (for TypedScope proxy internals) ──────\n\n  /** Returns all state keys without firing onRead. Used by TypedScope ownKeys/has traps. */\n  getStateKeys(): string[] {\n    this.refuseIfAttemptEnded('*');\n    const snapshot = this._stageContext.getValue([], undefined);\n    if (!snapshot || typeof snapshot !== 'object') return [];\n    return Object.keys(snapshot as Record<string, unknown>);\n  }\n\n  /** Check key existence without firing onRead. Used by TypedScope has trap.\n   *  Contract: returns false for keys never set OR keys set to undefined.\n   *  This matches deleteValue() semantics (sets to undefined = deleted). */\n  hasKey(key: string): boolean {\n    this.refuseIfAttemptEnded(key);\n    return this._stageContext.getValue([], key) !== undefined;\n  }\n\n  /** Read state without firing onRead. Used by array proxy getCurrent() to avoid\n   *  phantom reads on internal array operations (.length, .has, iteration, etc.).\n   *  The initial property access fires one tracked onRead via getValue(); subsequent\n   *  internal array operations use this method to stay silent.\n   *  NOTE: Like getValue(), returns the raw value to the caller. Redaction applies\n   *  only to recorder dispatch — it does not filter the returned value. This matches\n   *  the existing getValue() contract where user code always receives raw data.\n   *\n   *  RFC-003 D2: a silent read of a key this stage never TRACKED-read marks\n   *  the stage's commit with `untrackedSources: ['silent']` — a causal slice\n   *  built from onRead events would miss this dependency, and consumers must\n   *  be told. Silent reads shadowed by a tracked read of the same key (the\n   *  array-proxy pattern above) are not flagged: their edge is captured. A\n   *  whole-state silent read (no key) is always flagged. */\n  getValueSilent(key?: string): unknown {\n    this.refuseIfAttemptEnded(key ?? '*');\n    if (key === undefined || !this._trackedReadKeys.has(key)) {\n      this._stageContext.markUntrackedSource('silent');\n    }\n    return this._stageContext.getValueDirect([], key);\n  }\n\n  // ── State Access ─────────────────────────────────────────────────────────\n\n  getInitialValueFor(key: string) {\n    return this._stageContext.getGlobal?.(key);\n  }\n\n  /**\n   * Tracked read of shared state.\n   *\n   * **Read values are BORROWED — do not mutate them.** Since the lazy buffer\n   * (#13), reads before the stage's first write return references INTO\n   * COMMITTED SHARED STATE, and reads after a write return references into\n   * the stage's private transaction-buffer working copy (the eager engine\n   * returned references into that working copy for ALL reads). Mutating a\n   * returned value in place would corrupt state without a commit record —\n   * write changes back via `setValue`/`updateValue` instead. TypedScope\n   * consumers are safe automatically: the proxy routes every mutation\n   * through `setValue`/`updateValue`/copy-on-write array ops.\n   *\n   * There is deliberately NO dev-mode freeze guard here: deep-freezing a\n   * buffer-served read would freeze the stage's own working copy and make a\n   * legitimate read-then-deep-write throw, and freezing a committed-state\n   * read mutates an object shared with every other consumer of the live\n   * state. See `src/lib/memory/README.md` (\"Read values are borrowed\").\n   *\n   * Recorder note: the `onRead` event below passes the SAME live reference\n   * (no clone) unless field-level redaction scrubs a copy — recorders must\n   * treat event values as read-only too.\n   */\n  getValue(key?: string) {\n    return this.getValueAt([], key);\n  }\n\n  /**\n   * Path-aware adapter access. Segments stay separate from literal dotted keys in STATE;\n   * the recorder event's `key` is only a dot-joined display label, so `['user','ssn']` and\n   * a literal top-level `'user.ssn'` produce the same event key (same for the writes below).\n   */\n  getValueAt(path: string[], key?: string) {\n    this.refuseIfAttemptEnded(key === undefined ? path.join('.') || '*' : [...path, key].join('.'));\n    const value = this._stageContext.getValue(path, key);\n\n    // RFC-003 D2: remember tracked keys so later SILENT reads of the same\n    // key count as shadowed (edge already captured) instead of untracked.\n    // Only a whole top-level value shadows a later silent read of that value.\n    // Reading one nested field must not claim to have observed its siblings.\n    if (path.length === 0 && key !== undefined) this._trackedReadKeys.add(key);\n    else if (path.length === 1 && key === undefined) this._trackedReadKeys.add(path[0]!);\n\n    if (this._recorders.length > 0) {\n      // A whole-state read (no key) is served with every redacted key inside\n      // it scrubbed; a keyed read is served under the key's verdict.\n      const wholeState = path.length === 0 && key === undefined;\n      const verdict = wholeState ? CLEAR : key === undefined ? this.rule.verdict(path) : this.rule.verdictAt(path, key);\n      const recorderValue = wholeState ? this.rule.retainRecord(value) : RedactionRule.apply(verdict, value);\n      const eventKey = path.length === 0 ? key : (key === undefined ? path : [...path, key]).join('.');\n\n      this._invokeHook('onRead', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key: eventKey,\n        value: recorderValue,\n        redacted: verdict.kind !== 'clear' || undefined,\n      });\n    }\n\n    return value;\n  }\n\n  setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string) {\n    return this.setValueAt([], key, value, shouldRedact, description);\n  }\n\n  /** Path-aware writes share recording, redaction and lifetime policy with flat writes. */\n  setValueAt(path: string[], key: string, value: unknown, shouldRedact?: boolean, description?: string) {\n    const eventKey = path.length === 0 ? key : [...path, key].join('.');\n    assertNotReadonly(this._readOnlyValues, path[0] ?? key, 'write');\n    this.assertLive(eventKey);\n\n    // Dev-mode: warn if the value contains circular references.\n    // Check AFTER assertNotReadonly — don't warn for writes that will be blocked.\n    // Circular values work (terminal proxy handles them) but can produce\n    // surprising behavior in narrative, JSON serialization, and snapshots.\n    if (isDevMode() && value !== null && typeof value === 'object') {\n      if (hasCircularReference(value)) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[footprint] Circular reference detected in setValue('${eventKey}'). ` +\n            'Writes past the cycle depth will use terminal proxy tracking. ' +\n            'Consider flattening the data structure.',\n        );\n      }\n    }\n\n    // The context is the ONE funnel: it decides the verdict (explicit flag,\n    // policy key/pattern, per-run mark, or field-level scrub), stages the\n    // write with the paths the log will scrub, and hands the verdict back so\n    // recorders see the same decision the retained record holds.\n    const verdict = this._stageContext.setObject(path, key, value, shouldRedact, description);\n\n    if (this._recorders.length > 0) {\n      this._invokeHook('onWrite', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key: eventKey,\n        value: RedactionRule.apply(verdict, value),\n        operation: 'set',\n        redacted: verdict.kind !== 'clear' || undefined,\n      });\n    }\n  }\n\n  updateValue(key: string, value: unknown, description?: string) {\n    return this.updateValueAt([], key, value, description);\n  }\n\n  /** Path-aware merges use the same write funnel as replacements. */\n  updateValueAt(path: string[], key: string, value: unknown, description?: string) {\n    const eventKey = path.length === 0 ? key : [...path, key].join('.');\n    assertNotReadonly(this._readOnlyValues, path[0] ?? key, 'write');\n    this.assertLive(eventKey);\n\n    // Dev-mode: same circular check as setValue (merge targets can be circular too)\n    if (isDevMode() && value !== null && typeof value === 'object') {\n      if (hasCircularReference(value)) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[footprint] Circular reference detected in updateValue('${eventKey}'). ` +\n            'Consider flattening the data structure.',\n        );\n      }\n    }\n\n    const verdict = this._stageContext.updateObject(path, key, value, description);\n\n    if (this._recorders.length > 0) {\n      this._invokeHook('onWrite', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key: eventKey,\n        value: RedactionRule.apply(verdict, value),\n        operation: 'update',\n        redacted: verdict.kind !== 'clear' || undefined,\n      });\n    }\n  }\n\n  deleteValue(key: string, description?: string) {\n    assertNotReadonly(this._readOnlyValues, key, 'delete');\n    this.assertLive(key);\n\n    // Deleting a key clears its per-call redaction mark (the context's\n    // funnel does that); a policy verdict on the key survives.\n    this._stageContext.setObject([], key, undefined, false, description ?? `deleted ${key}`, 'delete');\n\n    if (this._recorders.length > 0) {\n      this._invokeHook('onWrite', {\n        stageName: this._stageName,\n        stageId: this._stageContext.stageId,\n        runtimeStageId: this._stageContext.runtimeStageId,\n        pipelineId: this._stageContext.runId,\n        timestamp: Date.now(),\n        key,\n        value: undefined,\n        operation: 'delete',\n      });\n    }\n  }\n\n  /** @internal */\n  setGlobal(key: string, value: unknown, description?: string) {\n    this.assertLive(key);\n    return this._stageContext.setGlobal?.(key, value, description);\n  }\n\n  /** @internal */\n  getGlobal(key: string) {\n    return this._stageContext.getGlobal?.(key);\n  }\n\n  /** @internal */\n  setObjectInRoot(key: string, value: unknown) {\n    this.assertLive(key);\n    return this._stageContext.setRoot?.(key, value);\n  }\n\n  // ── Read-only + misc ─────────────────────────────────────────────────────\n\n  /**\n   * Returns the readonly input values passed to this pipeline, cast to `T`.\n   * Ordinary mutable records/arrays are copied and frozen, not frozen in place.\n   * Opaque capabilities and explicitly frozen wrappers remain borrowed/live;\n   * see `protection/readonlyInput.ts · createFrozenArgs` for the ownership rule.\n   * Cached at construction time for zero-allocation repeated access.\n   *\n   * ```typescript\n   * const { applicantName, income } = scope.getArgs<{ applicantName: string; income: number }>();\n   * ```\n   *\n   * RFC-003 D2: args are untracked BY DESIGN, so calling this (with actual\n   * input present) marks the stage's commit with `untrackedSources: ['args']`\n   * — telling causal-slice consumers the backward slice may be incomplete\n   * here. An empty-args read carries no information and is not flagged.\n   */\n  getArgs<T = Record<string, unknown>>(): T {\n    this.refuseIfAttemptEnded('$args');\n    if (this._hasArgs) this._stageContext.markUntrackedSource('args');\n    return this._frozenArgs as T;\n  }\n\n  /**\n   * Returns the execution environment — read-only infrastructure values\n   * that propagate through nested executors (like `process.env` for flowcharts).\n   *\n   * Contains: signal (abort — the run's one effective signal), timeoutMs, traceId, operationId, traceparent,\n   * deadline (epoch ms) — the run's env as admitted (`attempt/correlation.ts · admitRunEnv`: one own-field\n   * snapshot; `traceparent` is the canonical header the run's correlation carries, never the received bytes), then\n   * armed (`runner/deadline.ts · armRun`). Frozen at construction time. Inherited by subflows automatically.\n   *\n   * ```typescript\n   * const { signal, traceId } = scope.getEnv();\n   * ```\n   *\n   * RFC-003 D2: env is untracked BY DESIGN, so calling this (with a\n   * non-empty environment) marks the stage's commit with\n   * `untrackedSources: ['env']` — see {@link getArgs}.\n   */\n  getEnv(): Readonly<ExecutionEnv> {\n    this.refuseIfAttemptEnded('$env');\n    if (this._hasEnv) this._stageContext.markUntrackedSource('env');\n    return this._executionEnv;\n  }\n\n  /** @internal */\n  getPipelineId() {\n    return this._stageContext.runId;\n  }\n\n  // ── Internal ─────────────────────────────────────────────────────────────\n\n  private _invokeHook<K extends ScopeHookName>(hook: K, event: HookPayload<K>): void {\n    // The one per-recorder loop (`recorder/hooks.ts · fire`) — the SAME invoke primitive the\n    // deferred tier uses at delivery time, so the inline and deferred paths cannot drift.\n    fire(this._recorders, hook, this._correlated(event as object) as HookPayload<K>, this._routeFailure);\n  }\n\n  /** The event as fired: unchanged without a correlation, else with the run's correlation as its last key. */\n  private _correlated<E extends object>(event: E): E {\n    return this._correlation === undefined ? event : { ...event, correlation: this._correlation };\n  }\n\n  /**\n   * The scope channel's isolation: a recorder's throw becomes an `onError` on every recorder\n   * (stamped with this stage), and a throw from `onError` itself is dropped.\n   */\n  private readonly _routeFailure: HookFailure = (error, _recorder, hook) => {\n    if (hook === 'onError') return;\n    this._invokeHook(\n      'onError',\n      recorderFailureEvent(\n        {\n          stageName: this._stageName,\n          stageId: this._stageContext.stageId,\n          runtimeStageId: this._stageContext.runtimeStageId,\n          pipelineId: this._stageContext.runId,\n        },\n        error,\n        hook,\n      ),\n    );\n  };\n}\n\n/** The signal of a stage outside the runner in a run with no signal: one that never aborts, shared. */\nconst NEVER_ABORTED: AbortSignal = new AbortController().signal;\n\n/** The name a late detach is recorded under: the child chart's root id — a name, never its input. */\nfunction detachKey(child: FlowChart): string {\n  const id = (child as { root?: { id?: unknown } } | undefined)?.root?.id;\n  return typeof id === 'string' ? `detach:${id}` : 'detach';\n}\n"]}