footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/builder/retryLoop.d.ts

@@ -0,0 +1,56 @@
+import type { RetryLoopBudget } from '../attempt/retryLoopContext.js';
+import type { RetryLoopCall } from '../attempt/retryLoopTypes.js';
+import type { AttemptContext, AttemptEffect, AttemptError, AttemptRecord, IdempotencyKeyContext, RetryPolicy } from '../attempt/types.js';
+import type { DecisionEvidence } from '../decide/types.js';
+export interface RetryLoopContext extends AttemptContext {
+    readonly retryLoop: RetryLoopCall;
+}
+export interface RetryLoopOptions<TScope = any, TValue = unknown> {
+    readonly touches: string;
+    readonly idempotencyKey: (context: IdempotencyKeyContext) => string;
+    readonly retry: RetryPolicy;
+    readonly attempt: (scope: TScope, context: RetryLoopContext) => TValue | Promise<TValue>;
+    /** 'none' must authoritatively establish that the operation was not applied; an empty search is not enough. */
+    readonly reconcile: (scope: TScope, context: RetryLoopContext) => AttemptEffect | Promise<AttemptEffect>;
+    readonly into?: string;
+    readonly onStop?: 'throw' | 'continue';
+    readonly wait?: 'sleep' | 'pause';
+}
+/** Operational state stays real; normal state retention scrubs selected keys and every error is already served. */
+export interface RetryLoopState<TValue = unknown> {
+    readonly id: string;
+    readonly series: string;
+    readonly attempt: number;
+    readonly of: number;
+    readonly idempotencyKey: string;
+    readonly effect: AttemptEffect;
+    readonly reconciled: boolean;
+    readonly outcome?: AttemptRecord['outcome'];
+    readonly category?: AttemptRecord['category'];
+    readonly error?: AttemptError;
+    readonly value?: TValue;
+    readonly delayMs: number;
+    readonly retryOn: boolean;
+    readonly retryOnThrew?: true;
+    readonly decision?: DecisionEvidence;
+    readonly terminal: boolean;
+    readonly resumeAt?: number;
+}
+/** Builder-only composition interface; no runtime engine kind or new scope method. */
+interface Builder {
+    addFunction(name: string, fn: (scope: any) => any, id: string): this;
+    addPausableFunction(name: string, handler: {
+        execute(scope: any): any;
+        resume(scope: any, input: unknown): any;
+    }, id: string): this;
+    addDeciderFunction(name: string, fn: (scope: any) => any, id: string): {
+        addFunctionBranch(branch: string, name: string, fn: (scope: any) => any, id?: string, options?: any): any;
+        end(): Builder;
+    };
+    touches(system: string, options: {
+        idempotencyKey: (context: IdempotencyKeyContext) => string;
+    }): this;
+    tag(...names: string[]): this;
+}
+export declare function appendRetryLoop<TScope>(builder: Builder, id: string, supplied: RetryLoopOptions<TScope>, stamp: (budget: RetryLoopBudget, branch?: string) => void): void;
+export {};

package/dist/esm/lib/builder/retryLoop.js

@@ -0,0 +1,283 @@
+/** Explicit retry workflow: ordinary attempt → reconcile → decide → wait/loop nodes, one rule table. */
+import { parseRuntimeStageId } from 'foottrace';
+import { decideAttempt, retryRules } from '../attempt/decision.js';
+import { admitIdempotencyKey, touchesProblem } from '../attempt/effect.js';
+import { UnknownEffectError } from '../attempt/errors.js';
+import { cappedWaitMs, retryPolicyProblem } from '../attempt/policy.js';
+import { registerRetryLoopCall } from '../attempt/retryLoopContext.js';
+import { resolveBackoffMs, sleep } from '../attempt/runner.js';
+import { DECISION_RESULT } from '../decide/types.js';
+import { interrupt, isInterruptSignal } from '../pause/interrupt.js';
+import { isPauseSignal } from '../pause/types.js';
+import { requireScopeRuntime } from '../scope/runtime.js';
+const fail = (field) => {
+    throw new TypeError(`addRetryLoop: invalid ${field}`);
+};
+export function appendRetryLoop(builder, id, supplied, stamp) {
+    // Snapshot named configuration once; never retain arbitrary caller fields or invoke a policy callback at build.
+    if (supplied === null || typeof supplied !== 'object')
+        fail('options');
+    const { touches, idempotencyKey, retry: given, attempt, reconcile, into = id, onStop = 'throw', wait = 'sleep', } = supplied;
+    if (given === null || typeof given !== 'object')
+        fail('retry');
+    const { attempts, timeoutMs, backoffMs, maxBackoffMs, retryOn } = given;
+    const retry = Object.freeze({ attempts, timeoutMs, backoffMs, maxBackoffMs, retryOn });
+    if (retryPolicyProblem(retry) || !Number.isSafeInteger(attempts))
+        fail('retry policy');
+    if (touchesProblem({ system: touches, idempotencyKey }, retry) || typeof idempotencyKey !== 'function')
+        fail('key rule or system');
+    if (typeof attempt !== 'function' || typeof reconcile !== 'function')
+        fail('attempt or reconciliation callback');
+    if (typeof into !== 'string' ||
+        !into ||
+        into.startsWith('$') ||
+        ['__proto__', 'constructor', 'prototype'].includes(into))
+        fail('state key');
+    if (onStop !== 'throw' && onStop !== 'continue')
+        fail('onStop');
+    if (wait !== 'sleep' && wait !== 'pause')
+        fail('wait');
+    const tag = `retry-loop:${id}`;
+    const callbackBudget = { role: 'callback', timeoutMs };
+    const waitBudget = {
+        role: 'wait',
+        waitMs: typeof backoffMs === 'function' ? maxBackoffMs : cappedWaitMs(resolveBackoffMs(backoffMs, 1), maxBackoffMs),
+    };
+    const controlBudget = { role: 'control' };
+    const hostOf = (scope) => {
+        const host = requireScopeRuntime(scope).target;
+        if (typeof host.writeRetryLoopState !== 'function')
+            fail('scope capability (use a registered ScopeFacade target)');
+        return host;
+    };
+    const checked = (value) => {
+        if (value === undefined)
+            return undefined;
+        if (value === null || typeof value !== 'object')
+            fail('restored loop state');
+        const state = value;
+        if (state.error !== undefined &&
+            (state.error === null ||
+                typeof state.error !== 'object' ||
+                typeof state.error.message !== 'string' ||
+                Object.keys(state.error).some((key) => !['message', 'name', 'code'].includes(key))))
+            fail('restored loop error');
+        if (state.resumeAt !== undefined && (typeof state.resumeAt !== 'number' || !Number.isFinite(state.resumeAt)))
+            fail('restored wait time');
+        if (state.id !== id ||
+            state.of !== attempts ||
+            !Number.isInteger(state.attempt) ||
+            state.attempt < 1 ||
+            state.attempt > attempts ||
+            typeof state.idempotencyKey !== 'string' ||
+            state.idempotencyKey.trim() === '' ||
+            typeof state.series !== 'string' ||
+            typeof state.terminal !== 'boolean' ||
+            !['none', 'unknown', 'applied'].includes(state.effect) ||
+            typeof state.reconciled !== 'boolean' ||
+            typeof state.retryOn !== 'boolean' ||
+            !Number.isFinite(state.delayMs) ||
+            state.delayMs < 0)
+            fail('restored loop state');
+        try {
+            const parsed = parseRuntimeStageId(state.series);
+            if (!/#\d+$/.test(state.series) || parsed.stageId !== id)
+                fail('restored loop series');
+            admitIdempotencyKey('addRetryLoop', state.idempotencyKey);
+        }
+        catch {
+            fail('restored loop series');
+        }
+        return state;
+    };
+    const read = (host) => checked(host.getValue(into));
+    const identity = (state, phase) => Object.freeze({ id, series: state.series, attempt: state.attempt, of: attempts, phase });
+    const call = async (scope, host, state, phase, fn) => {
+        let record;
+        const logical = identity(state, phase);
+        const clear = registerRetryLoopCall(host, {
+            identity: logical,
+            record: (entry) => {
+                record = entry;
+            },
+        });
+        try {
+            const value = await host.call(phase === 'attempt' ? touches : `${touches}.reconcile`, (context) => fn(scope, Object.freeze({ ...context, idempotencyKey: state.idempotencyKey, retryLoop: logical })), { attempts: 1, ...(timeoutMs === undefined ? {} : { timeoutMs }) }, phase === 'attempt' ? { touches, idempotencyKey: state.idempotencyKey } : undefined);
+            return { value, record };
+        }
+        catch (error) {
+            if (isPauseSignal(error) || isInterruptSignal(error))
+                throw error;
+            return { error, record };
+        }
+        finally {
+            clear();
+        }
+    };
+    builder
+        .addFunction(`Attempt ${id}`, async (scope) => {
+        const host = hostOf(scope);
+        const previous = read(host);
+        let state = previous && !previous.terminal
+            ? { ...previous, reconciled: false }
+            : {
+                id,
+                series: host.getAttempt().series,
+                attempt: 1,
+                of: attempts,
+                idempotencyKey: host.getAttempt().idempotencyKey,
+                effect: 'none',
+                reconciled: false,
+                delayMs: 0,
+                retryOn: true,
+                terminal: false,
+            };
+        host.writeRetryLoopState(into, state); // a pause re-runs from this committed operational key, never recomputes it
+        const result = await call(scope, host, state, 'attempt', attempt);
+        const record = result.record;
+        const failed = Object.hasOwn(result, 'error');
+        let allows = true;
+        let threw = false;
+        let delayMs = 0;
+        if (failed && state.attempt < attempts) {
+            const original = result.error instanceof UnknownEffectError ? result.error.cause : result.error;
+            if (retryOn) {
+                try {
+                    allows = retryOn(original) === true;
+                }
+                catch {
+                    allows = false;
+                    threw = true;
+                }
+            }
+            if (allows)
+                delayMs = cappedWaitMs(resolveBackoffMs(backoffMs, state.attempt, original), maxBackoffMs);
+        }
+        state = {
+            ...state,
+            outcome: record?.outcome ?? (failed ? 'failed' : 'ok'),
+            effect: record?.effect ?? (failed ? 'unknown' : 'applied'),
+            category: record?.category,
+            ...(failed ? { error: host.serveRetryLoopError(result.error) } : { value: result.value }),
+            retryOn: allows,
+            ...(threw ? { retryOnThrew: true } : {}),
+            delayMs,
+        };
+        host.writeRetryLoopState(into, state);
+    }, id)
+        .touches(touches, {
+        idempotencyKey: (context) => {
+            const previous = checked(context.getState(into));
+            return previous && !previous.terminal ? previous.idempotencyKey : idempotencyKey(context);
+        },
+    })
+        .tag(tag);
+    stamp({ ...callbackBudget, passes: attempts });
+    builder
+        .addFunction(`Reconcile ${id}`, async (scope) => {
+        const host = hostOf(scope);
+        const state = read(host);
+        if (state.effect !== 'unknown')
+            return;
+        const result = await call(scope, host, state, 'reconcile', reconcile);
+        const valid = result.value === 'applied' || result.value === 'none' || result.value === 'unknown';
+        const effect = valid ? result.value : 'unknown';
+        host.writeRetryLoopState(into, {
+            ...state,
+            effect,
+            reconciled: true,
+            ...(Object.hasOwn(result, 'error')
+                ? { error: host.serveRetryLoopError(result.error) }
+                : !valid
+                    ? { error: { name: 'TypeError', message: 'retry loop: invalid reconciliation outcome' } }
+                    : {}),
+        });
+    }, `${id}-reconcile`)
+        .tag(tag);
+    stamp(callbackBudget);
+    const decider = builder.addDeciderFunction(`Decide ${id}`, (scope) => {
+        const host = hostOf(scope);
+        const state = read(host);
+        const context = host.getAttempt();
+        const left = context.timeLeftMs();
+        const inputs = {
+            outcome: state.effect === 'applied' ? 'ok' : state.outcome ?? 'failed',
+            category: state.category,
+            aborted: context.signal.aborted,
+            attempt: state.attempt,
+            of: attempts,
+            timeLeftMs: left,
+            delayMs: state.delayMs,
+            timeLeftAfterWaitMs: left - state.delayMs,
+            retryOn: state.retryOn && state.effect !== 'unknown',
+            keyPresent: true,
+        };
+        const decision = decideAttempt(retryRules(retry), (key) => inputs[key]);
+        const evidence = {
+            ...decision.evidence,
+            retryLoop: Object.freeze({
+                id,
+                series: state.series,
+                attempt: state.attempt,
+                of: attempts,
+                effect: state.effect,
+                reconciled: state.reconciled,
+                next: decision.next,
+                reason: decision.reason,
+            }),
+        };
+        host.writeRetryLoopState(into, { ...state, decision: evidence, terminal: decision.next !== 'retry' });
+        return { branch: `${id}-${decision.next}`, [DECISION_RESULT]: true, evidence };
+    }, `${id}-decide`);
+    builder.tag(tag);
+    stamp(controlBudget);
+    const waitScope = async (scope) => {
+        const host = hostOf(scope);
+        const state = read(host);
+        const delay = state.resumeAt === undefined ? state.delayMs : Math.max(0, state.resumeAt - Date.now());
+        const signal = host.getAttempt().signal;
+        await sleep(delay, signal);
+        if (signal.aborted)
+            throw signal.reason ?? new Error('retry loop aborted');
+        host.writeRetryLoopState(into, { ...state, attempt: state.attempt + 1, decision: undefined, resumeAt: undefined });
+    };
+    // Branch-list methods keep their builder cursor on the decider. The wait callback is an ordinary branch;
+    // pause mode uses interrupt semantics in that callback so its own stage resumes before it loops back.
+    const waitFn = wait === 'pause'
+        ? async (scope) => {
+            const host = hostOf(scope);
+            const state = read(host);
+            if (state.resumeAt === undefined)
+                host.writeRetryLoopState(into, { ...state, resumeAt: Date.now() + state.delayMs });
+            interrupt(scope, { reason: `Retry ${id}`, expects: { resumeAt: read(host).resumeAt } });
+            await waitScope(scope);
+        }
+        : waitScope;
+    decider
+        .addFunctionBranch(`${id}-retry`, `Wait ${id}`, waitFn, undefined, { loopTo: id, tags: [tag] })
+        .addFunctionBranch(`${id}-done`, `Done ${id}`, () => undefined, undefined, { tags: [tag] })
+        .addFunctionBranch(`${id}-stop`, `Stop ${id}`, (scope) => {
+        if (onStop === 'continue')
+            return;
+        const host = hostOf(scope);
+        const state = read(host);
+        const cause = Object.assign(new Error(state.error?.message ?? 'retry loop stopped'), {
+            name: state.error?.name ?? 'Error',
+            ...(state.error?.code ? { code: state.error.code } : {}),
+        });
+        if (state.effect === 'unknown')
+            throw new UnknownEffectError({
+                system: touches,
+                idempotencyKey: host.serveRetryLoopKey(state.idempotencyKey),
+                attempts: state.attempt,
+                cause,
+            });
+        throw cause;
+    }, undefined, { tags: [tag] })
+        .end();
+    // Branch nodes are assigned their bounded helper costs by the builder after construction.
+    stamp(waitBudget, `${id}-retry`);
+    stamp(controlBudget, `${id}-done`);
+    stamp(controlBudget, `${id}-stop`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retryLoop.js","sourceRoot":"","sources":["../../../../src/lib/builder/retryLoop.ts"],"names":[],"mappings":"AAAA,wGAAwG;AACxG,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAY/D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAyE1D,MAAM,IAAI,GAAG,CAAC,KAAa,EAAS,EAAE;IACpC,MAAM,IAAI,SAAS,CAAC,yBAAyB,KAAK,EAAE,CAAC,CAAC;AACxD,CAAC,CAAC;AAEF,MAAM,UAAU,eAAe,CAC7B,OAAgB,EAChB,EAAU,EACV,QAAkC,EAClC,KAAyD;IAEzD,gHAAgH;IAChH,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IACvE,MAAM,EACJ,OAAO,EACP,cAAc,EACd,KAAK,EAAE,KAAK,EACZ,OAAO,EACP,SAAS,EACT,IAAI,GAAG,EAAE,EACT,MAAM,GAAG,OAAO,EAChB,IAAI,GAAG,OAAO,GACf,GAAG,QAAQ,CAAC;IACb,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/D,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IACxE,MAAM,KAAK,GAAgB,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC;IACpG,IAAI,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;QAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IACvF,IAAI,cAAc,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,KAAK,CAAC,IAAI,OAAO,cAAc,KAAK,UAAU;QACpG,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC7B,IAAI,OAAO,OAAO,KAAK,UAAU,IAAI,OAAO,SAAS,KAAK,UAAU;QAAE,IAAI,CAAC,oCAAoC,CAAC,CAAC;IACjH,IACE,OAAO,IAAI,KAAK,QAAQ;QACxB,CAAC,IAAI;QACL,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QACpB,CAAC,WAAW,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;QAExD,IAAI,CAAC,WAAW,CAAC,CAAC;IACpB,IAAI,MAAM,KAAK,OAAO,IAAI,MAAM,KAAK,UAAU;QAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChE,IAAI,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,OAAO;QAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACvD,MAAM,GAAG,GAAG,cAAc,EAAE,EAAE,CAAC;IAC/B,MAAM,cAAc,GAAoB,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;IACxE,MAAM,UAAU,GAAoB;QAClC,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,OAAO,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,CAAC;KACpH,CAAC;IACF,MAAM,aAAa,GAAoB,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAE3D,MAAM,MAAM,GAAG,CAAC,KAAc,EAAQ,EAAE;QACtC,MAAM,IAAI,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC,MAAyB,CAAC;QAClE,IAAI,OAAO,IAAI,CAAC,mBAAmB,KAAK,UAAU;YAAE,IAAI,CAAC,wDAAwD,CAAC,CAAC;QACnH,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IACF,MAAM,OAAO,GAAG,CAAC,KAAc,EAA8B,EAAE;QAC7D,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC1C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC7E,MAAM,KAAK,GAAG,KAAuB,CAAC;QACtC,IACE,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI;gBACnB,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;gBAC/B,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,KAAK,QAAQ;gBACvC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YAErF,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC9B,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,OAAO,KAAK,CAAC,QAAQ,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC1G,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC7B,IACE,KAAK,CAAC,EAAE,KAAK,EAAE;YACf,KAAK,CAAC,EAAE,KAAK,QAAQ;YACrB,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC;YAChC,KAAK,CAAC,OAAO,GAAG,CAAC;YACjB,KAAK,CAAC,OAAO,GAAG,QAAQ;YACxB,OAAO,KAAK,CAAC,cAAc,KAAK,QAAQ;YACxC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE;YAClC,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ;YAChC,OAAO,KAAK,CAAC,QAAQ,KAAK,SAAS;YACnC,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC;YACtD,OAAO,KAAK,CAAC,UAAU,KAAK,SAAS;YACrC,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS;YAClC,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC;YAC/B,KAAK,CAAC,OAAO,GAAG,CAAC;YAEjB,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC9B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YACjD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,KAAK,EAAE;gBAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;YACvF,mBAAmB,CAAC,cAAc,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QAC5D,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,IAAU,EAA8B,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACtF,MAAM,QAAQ,GAAG,CAAC,KAAqB,EAAE,KAA6B,EAAiB,EAAE,CACvF,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3F,MAAM,IAAI,GAAG,KAAK,EAChB,KAAa,EACb,IAAU,EACV,KAAqB,EACrB,KAA6B,EAC7B,EAAgE,EACC,EAAE;QACnE,IAAI,MAAiC,CAAC;QACtC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACvC,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,EAAE;YACxC,QAAQ,EAAE,OAAO;YACjB,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChB,MAAM,GAAG,KAAK,CAAC;YACjB,CAAC;SACF,CAAC,CAAC;QACH,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,CAC3B,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,YAAY,EACtD,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,EAC/G,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAClE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CACpF,CAAC;YACF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,aAAa,CAAC,KAAK,CAAC,IAAI,iBAAiB,CAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC;YAClE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAC3B,CAAC;gBAAS,CAAC;YACT,KAAK,EAAE,CAAC;QACV,CAAC;IACH,CAAC,CAAC;IAEF,OAAO;SACJ,WAAW,CACV,WAAW,EAAE,EAAE,EACf,KAAK,EAAE,KAAa,EAAE,EAAE;QACtB,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,KAAK,GACP,QAAQ,IAAI,CAAC,QAAQ,CAAC,QAAQ;YAC5B,CAAC,CAAC,EAAE,GAAG,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE;YACpC,CAAC,CAAC;gBACE,EAAE;gBACF,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM;gBAChC,OAAO,EAAE,CAAC;gBACV,EAAE,EAAE,QAAQ;gBACZ,cAAc,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,cAAwB;gBAC1D,MAAM,EAAE,MAAM;gBACd,UAAU,EAAE,KAAK;gBACjB,OAAO,EAAE,CAAC;gBACV,OAAO,EAAE,IAAI;gBACb,QAAQ,EAAE,KAAK;aAChB,CAAC;QACR,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,2EAA2E;QAClH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC9C,IAAI,MAAM,GAAG,IAAI,CAAC;QAClB,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,MAAM,IAAI,KAAK,CAAC,OAAO,GAAG,QAAQ,EAAE,CAAC;YACvC,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,YAAY,kBAAkB,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;YAChG,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,CAAC;oBACH,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;gBACtC,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,GAAG,KAAK,CAAC;oBACf,KAAK,GAAG,IAAI,CAAC;gBACf,CAAC;YACH,CAAC;YACD,IAAI,MAAM;gBAAE,OAAO,GAAG,YAAY,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,YAAY,CAAC,CAAC;QACzG,CAAC;QACD,KAAK,GAAG;YACN,GAAG,KAAK;YACR,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;YACtD,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1D,QAAQ,EAAE,MAAM,EAAE,QAAQ;YAC1B,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;YACzF,OAAO,EAAE,MAAM;YACf,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxC,OAAO;SACR,CAAC;QACF,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC,EACD,EAAE,CACH;SACA,OAAO,CAAC,OAAO,EAAE;QAChB,cAAc,EAAE,CAAC,OAAO,EAAE,EAAE;YAC1B,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;YACjD,OAAO,QAAQ,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC5F,CAAC;KACF,CAAC;SACD,GAAG,CAAC,GAAG,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,GAAG,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IAE/C,OAAO;SACJ,WAAW,CACV,aAAa,EAAE,EAAE,EACjB,KAAK,EAAE,KAAa,EAAE,EAAE;QACtB,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAmB,CAAC;QAC3C,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO;QACvC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QACtE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,MAAM,CAAC,KAAK,KAAK,MAAM,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC;QAClG,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAE,MAAM,CAAC,KAAuB,CAAC,CAAC,CAAC,SAAS,CAAC;QACnE,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE;YAC7B,GAAG,KAAK;YACR,MAAM;YACN,UAAU,EAAE,IAAI;YAChB,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAChC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;gBACnD,CAAC,CAAC,CAAC,KAAK;oBACR,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,4CAA4C,EAAE,EAAE;oBACzF,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAC;IACL,CAAC,EACD,GAAG,EAAE,YAAY,CAClB;SACA,GAAG,CAAC,GAAG,CAAC,CAAC;IACZ,KAAK,CAAC,cAAc,CAAC,CAAC;IAEtB,MAAM,OAAO,GAAG,OAAO,CAAC,kBAAkB,CACxC,UAAU,EAAE,EAAE,EACd,CAAC,KAAa,EAAE,EAAE;QAChB,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAmB,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,MAAM,GAAkB;YAC5B,OAAO,EAAE,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,QAAQ;YACtE,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO;YAC/B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,EAAE,EAAE,QAAQ;YACZ,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,mBAAmB,EAAE,IAAI,GAAG,KAAK,CAAC,OAAO;YACzC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YACpD,UAAU,EAAE,IAAI;SACjB,CAAC;QACF,MAAM,QAAQ,GAAG,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,GAA0B,CAAC,CAAC,CAAC;QAC/F,MAAM,QAAQ,GAAqB;YACjC,GAAG,QAAQ,CAAC,QAAQ;YACpB,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC;gBACvB,EAAE;gBACF,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,EAAE,EAAE,QAAQ;gBACZ,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,MAAM,EAAE,QAAQ,CAAC,MAAM;aACxB,CAAC;SACH,CAAC;QACF,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;QACtG,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjF,CAAC,EACD,GAAG,EAAE,SAAS,CACf,CAAC;IACF,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjB,KAAK,CAAC,aAAa,CAAC,CAAC;IAErB,MAAM,SAAS,GAAG,KAAK,EAAE,KAAa,EAAiB,EAAE;QACvD,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAmB,CAAC;QAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QACtG,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC;QACxC,MAAM,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC3B,IAAI,MAAM,CAAC,OAAO;YAAE,MAAM,MAAM,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QAC3E,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;IACrH,CAAC,CAAC;IACF,yGAAyG;IACzG,sGAAsG;IACtG,MAAM,MAAM,GACV,IAAI,KAAK,OAAO;QACd,CAAC,CAAC,KAAK,EAAE,KAAa,EAAE,EAAE;YACtB,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAmB,CAAC;YAC3C,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS;gBAC9B,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACrF,SAAS,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAG,IAAI,CAAC,IAAI,CAAoB,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC5G,MAAM,SAAS,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;QACH,CAAC,CAAC,SAAS,CAAC;IAChB,OAAO;SACJ,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;SAC9F,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;SAC1F,iBAAiB,CAChB,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,EAAE,EACZ,CAAC,KAAa,EAAE,EAAE;QAChB,IAAI,MAAM,KAAK,UAAU;YAAE,OAAO;QAClC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAmB,CAAC;QAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,IAAI,oBAAoB,CAAC,EAAE;YACnF,IAAI,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,IAAI,OAAO;YAClC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACzD,CAAC,CAAC;QACH,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAC5B,MAAM,IAAI,kBAAkB,CAAC;gBAC3B,MAAM,EAAE,OAAO;gBACf,cAAc,EAAE,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,cAAc,CAAC;gBAC5D,QAAQ,EAAE,KAAK,CAAC,OAAO;gBACvB,KAAK;aACN,CAAC,CAAC;QACL,MAAM,KAAK,CAAC;IACd,CAAC,EACD,SAAS,EACT,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAChB;SACA,GAAG,EAAE,CAAC;IACT,0FAA0F;IAC1F,KAAK,CAAC,UAAU,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IACjC,KAAK,CAAC,aAAa,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;IACnC,KAAK,CAAC,aAAa,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;AACrC,CAAC","sourcesContent":["/** Explicit retry workflow: ordinary attempt → reconcile → decide → wait/loop nodes, one rule table. */\nimport { parseRuntimeStageId } from 'foottrace';\n\nimport { decideAttempt, retryRules } from '../attempt/decision.js';\nimport { admitIdempotencyKey, touchesProblem } from '../attempt/effect.js';\nimport { UnknownEffectError } from '../attempt/errors.js';\nimport { cappedWaitMs, retryPolicyProblem } from '../attempt/policy.js';\nimport type { RetryLoopBudget } from '../attempt/retryLoopContext.js';\nimport { registerRetryLoopCall } from '../attempt/retryLoopContext.js';\nimport type { RetryLoopCall } from '../attempt/retryLoopTypes.js';\nimport { resolveBackoffMs, sleep } from '../attempt/runner.js';\nimport type {\n  AttemptContext,\n  AttemptEffect,\n  AttemptError,\n  AttemptInputs,\n  AttemptRecord,\n  CallOptions,\n  IdempotencyKeyContext,\n  RetryPolicy,\n} from '../attempt/types.js';\nimport type { DecisionEvidence } from '../decide/types.js';\nimport { DECISION_RESULT } from '../decide/types.js';\nimport { interrupt, isInterruptSignal } from '../pause/interrupt.js';\nimport { isPauseSignal } from '../pause/types.js';\nimport { requireScopeRuntime } from '../scope/runtime.js';\n\nexport interface RetryLoopContext extends AttemptContext {\n  readonly retryLoop: RetryLoopCall;\n}\n\nexport interface RetryLoopOptions<TScope = any, TValue = unknown> {\n  readonly touches: string;\n  readonly idempotencyKey: (context: IdempotencyKeyContext) => string;\n  readonly retry: RetryPolicy;\n  readonly attempt: (scope: TScope, context: RetryLoopContext) => TValue | Promise<TValue>;\n  /** 'none' must authoritatively establish that the operation was not applied; an empty search is not enough. */\n  readonly reconcile: (scope: TScope, context: RetryLoopContext) => AttemptEffect | Promise<AttemptEffect>;\n  readonly into?: string;\n  readonly onStop?: 'throw' | 'continue';\n  readonly wait?: 'sleep' | 'pause';\n}\n\n/** Operational state stays real; normal state retention scrubs selected keys and every error is already served. */\nexport interface RetryLoopState<TValue = unknown> {\n  readonly id: string;\n  readonly series: string;\n  readonly attempt: number;\n  readonly of: number;\n  readonly idempotencyKey: string;\n  readonly effect: AttemptEffect;\n  readonly reconciled: boolean;\n  readonly outcome?: AttemptRecord['outcome'];\n  readonly category?: AttemptRecord['category'];\n  readonly error?: AttemptError;\n  readonly value?: TValue;\n  readonly delayMs: number;\n  readonly retryOn: boolean;\n  readonly retryOnThrew?: true;\n  readonly decision?: DecisionEvidence;\n  readonly terminal: boolean;\n  readonly resumeAt?: number;\n}\n\ninterface Host {\n  getValue(key: string): unknown;\n  getAttempt(): AttemptContext;\n  call<T>(\n    target: string,\n    fn: (context: AttemptContext) => T | Promise<T>,\n    policy: RetryPolicy,\n    options?: CallOptions,\n  ): Promise<T>;\n  writeRetryLoopState(key: string, state: RetryLoopState): void;\n  serveRetryLoopKey(key: string): string;\n  serveRetryLoopError(error: unknown): AttemptError;\n}\n\n/** Builder-only composition interface; no runtime engine kind or new scope method. */\ninterface Builder {\n  addFunction(name: string, fn: (scope: any) => any, id: string): this;\n  addPausableFunction(\n    name: string,\n    handler: { execute(scope: any): any; resume(scope: any, input: unknown): any },\n    id: string,\n  ): this;\n  addDeciderFunction(\n    name: string,\n    fn: (scope: any) => any,\n    id: string,\n  ): {\n    addFunctionBranch(branch: string, name: string, fn: (scope: any) => any, id?: string, options?: any): any;\n    end(): Builder;\n  };\n  touches(system: string, options: { idempotencyKey: (context: IdempotencyKeyContext) => string }): this;\n  tag(...names: string[]): this;\n}\n\nconst fail = (field: string): never => {\n  throw new TypeError(`addRetryLoop: invalid ${field}`);\n};\n\nexport function appendRetryLoop<TScope>(\n  builder: Builder,\n  id: string,\n  supplied: RetryLoopOptions<TScope>,\n  stamp: (budget: RetryLoopBudget, branch?: string) => void,\n): void {\n  // Snapshot named configuration once; never retain arbitrary caller fields or invoke a policy callback at build.\n  if (supplied === null || typeof supplied !== 'object') fail('options');\n  const {\n    touches,\n    idempotencyKey,\n    retry: given,\n    attempt,\n    reconcile,\n    into = id,\n    onStop = 'throw',\n    wait = 'sleep',\n  } = supplied;\n  if (given === null || typeof given !== 'object') fail('retry');\n  const { attempts, timeoutMs, backoffMs, maxBackoffMs, retryOn } = given;\n  const retry: RetryPolicy = Object.freeze({ attempts, timeoutMs, backoffMs, maxBackoffMs, retryOn });\n  if (retryPolicyProblem(retry) || !Number.isSafeInteger(attempts)) fail('retry policy');\n  if (touchesProblem({ system: touches, idempotencyKey }, retry) || typeof idempotencyKey !== 'function')\n    fail('key rule or system');\n  if (typeof attempt !== 'function' || typeof reconcile !== 'function') fail('attempt or reconciliation callback');\n  if (\n    typeof into !== 'string' ||\n    !into ||\n    into.startsWith('$') ||\n    ['__proto__', 'constructor', 'prototype'].includes(into)\n  )\n    fail('state key');\n  if (onStop !== 'throw' && onStop !== 'continue') fail('onStop');\n  if (wait !== 'sleep' && wait !== 'pause') fail('wait');\n  const tag = `retry-loop:${id}`;\n  const callbackBudget: RetryLoopBudget = { role: 'callback', timeoutMs };\n  const waitBudget: RetryLoopBudget = {\n    role: 'wait',\n    waitMs: typeof backoffMs === 'function' ? maxBackoffMs : cappedWaitMs(resolveBackoffMs(backoffMs, 1), maxBackoffMs),\n  };\n  const controlBudget: RetryLoopBudget = { role: 'control' };\n\n  const hostOf = (scope: unknown): Host => {\n    const host = requireScopeRuntime(scope).target as unknown as Host;\n    if (typeof host.writeRetryLoopState !== 'function') fail('scope capability (use a registered ScopeFacade target)');\n    return host;\n  };\n  const checked = (value: unknown): RetryLoopState | undefined => {\n    if (value === undefined) return undefined;\n    if (value === null || typeof value !== 'object') fail('restored loop state');\n    const state = value as RetryLoopState;\n    if (\n      state.error !== undefined &&\n      (state.error === null ||\n        typeof state.error !== 'object' ||\n        typeof state.error.message !== 'string' ||\n        Object.keys(state.error).some((key) => !['message', 'name', 'code'].includes(key)))\n    )\n      fail('restored loop error');\n    if (state.resumeAt !== undefined && (typeof state.resumeAt !== 'number' || !Number.isFinite(state.resumeAt)))\n      fail('restored wait time');\n    if (\n      state.id !== id ||\n      state.of !== attempts ||\n      !Number.isInteger(state.attempt) ||\n      state.attempt < 1 ||\n      state.attempt > attempts ||\n      typeof state.idempotencyKey !== 'string' ||\n      state.idempotencyKey.trim() === '' ||\n      typeof state.series !== 'string' ||\n      typeof state.terminal !== 'boolean' ||\n      !['none', 'unknown', 'applied'].includes(state.effect) ||\n      typeof state.reconciled !== 'boolean' ||\n      typeof state.retryOn !== 'boolean' ||\n      !Number.isFinite(state.delayMs) ||\n      state.delayMs < 0\n    )\n      fail('restored loop state');\n    try {\n      const parsed = parseRuntimeStageId(state.series);\n      if (!/#\\d+$/.test(state.series) || parsed.stageId !== id) fail('restored loop series');\n      admitIdempotencyKey('addRetryLoop', state.idempotencyKey);\n    } catch {\n      fail('restored loop series');\n    }\n    return state;\n  };\n  const read = (host: Host): RetryLoopState | undefined => checked(host.getValue(into));\n  const identity = (state: RetryLoopState, phase: RetryLoopCall['phase']): RetryLoopCall =>\n    Object.freeze({ id, series: state.series, attempt: state.attempt, of: attempts, phase });\n  const call = async <T>(\n    scope: TScope,\n    host: Host,\n    state: RetryLoopState,\n    phase: RetryLoopCall['phase'],\n    fn: (scope: TScope, context: RetryLoopContext) => T | Promise<T>,\n  ): Promise<{ value?: T; error?: unknown; record?: AttemptRecord }> => {\n    let record: AttemptRecord | undefined;\n    const logical = identity(state, phase);\n    const clear = registerRetryLoopCall(host, {\n      identity: logical,\n      record: (entry) => {\n        record = entry;\n      },\n    });\n    try {\n      const value = await host.call(\n        phase === 'attempt' ? touches : `${touches}.reconcile`,\n        (context) => fn(scope, Object.freeze({ ...context, idempotencyKey: state.idempotencyKey, retryLoop: logical })),\n        { attempts: 1, ...(timeoutMs === undefined ? {} : { timeoutMs }) },\n        phase === 'attempt' ? { touches, idempotencyKey: state.idempotencyKey } : undefined,\n      );\n      return { value, record };\n    } catch (error) {\n      if (isPauseSignal(error) || isInterruptSignal(error)) throw error;\n      return { error, record };\n    } finally {\n      clear();\n    }\n  };\n\n  builder\n    .addFunction(\n      `Attempt ${id}`,\n      async (scope: TScope) => {\n        const host = hostOf(scope);\n        const previous = read(host);\n        let state: RetryLoopState =\n          previous && !previous.terminal\n            ? { ...previous, reconciled: false }\n            : {\n                id,\n                series: host.getAttempt().series,\n                attempt: 1,\n                of: attempts,\n                idempotencyKey: host.getAttempt().idempotencyKey as string,\n                effect: 'none',\n                reconciled: false,\n                delayMs: 0,\n                retryOn: true,\n                terminal: false,\n              };\n        host.writeRetryLoopState(into, state); // a pause re-runs from this committed operational key, never recomputes it\n        const result = await call(scope, host, state, 'attempt', attempt);\n        const record = result.record;\n        const failed = Object.hasOwn(result, 'error');\n        let allows = true;\n        let threw = false;\n        let delayMs = 0;\n        if (failed && state.attempt < attempts) {\n          const original = result.error instanceof UnknownEffectError ? result.error.cause : result.error;\n          if (retryOn) {\n            try {\n              allows = retryOn(original) === true;\n            } catch {\n              allows = false;\n              threw = true;\n            }\n          }\n          if (allows) delayMs = cappedWaitMs(resolveBackoffMs(backoffMs, state.attempt, original), maxBackoffMs);\n        }\n        state = {\n          ...state,\n          outcome: record?.outcome ?? (failed ? 'failed' : 'ok'),\n          effect: record?.effect ?? (failed ? 'unknown' : 'applied'),\n          category: record?.category,\n          ...(failed ? { error: host.serveRetryLoopError(result.error) } : { value: result.value }),\n          retryOn: allows,\n          ...(threw ? { retryOnThrew: true } : {}),\n          delayMs,\n        };\n        host.writeRetryLoopState(into, state);\n      },\n      id,\n    )\n    .touches(touches, {\n      idempotencyKey: (context) => {\n        const previous = checked(context.getState(into));\n        return previous && !previous.terminal ? previous.idempotencyKey : idempotencyKey(context);\n      },\n    })\n    .tag(tag);\n  stamp({ ...callbackBudget, passes: attempts });\n\n  builder\n    .addFunction(\n      `Reconcile ${id}`,\n      async (scope: TScope) => {\n        const host = hostOf(scope);\n        const state = read(host) as RetryLoopState;\n        if (state.effect !== 'unknown') return;\n        const result = await call(scope, host, state, 'reconcile', reconcile);\n        const valid = result.value === 'applied' || result.value === 'none' || result.value === 'unknown';\n        const effect = valid ? (result.value as AttemptEffect) : 'unknown';\n        host.writeRetryLoopState(into, {\n          ...state,\n          effect,\n          reconciled: true,\n          ...(Object.hasOwn(result, 'error')\n            ? { error: host.serveRetryLoopError(result.error) }\n            : !valid\n            ? { error: { name: 'TypeError', message: 'retry loop: invalid reconciliation outcome' } }\n            : {}),\n        });\n      },\n      `${id}-reconcile`,\n    )\n    .tag(tag);\n  stamp(callbackBudget);\n\n  const decider = builder.addDeciderFunction(\n    `Decide ${id}`,\n    (scope: TScope) => {\n      const host = hostOf(scope);\n      const state = read(host) as RetryLoopState;\n      const context = host.getAttempt();\n      const left = context.timeLeftMs();\n      const inputs: AttemptInputs = {\n        outcome: state.effect === 'applied' ? 'ok' : state.outcome ?? 'failed',\n        category: state.category,\n        aborted: context.signal.aborted,\n        attempt: state.attempt,\n        of: attempts,\n        timeLeftMs: left,\n        delayMs: state.delayMs,\n        timeLeftAfterWaitMs: left - state.delayMs,\n        retryOn: state.retryOn && state.effect !== 'unknown',\n        keyPresent: true,\n      };\n      const decision = decideAttempt(retryRules(retry), (key) => inputs[key as keyof AttemptInputs]);\n      const evidence: DecisionEvidence = {\n        ...decision.evidence,\n        retryLoop: Object.freeze({\n          id,\n          series: state.series,\n          attempt: state.attempt,\n          of: attempts,\n          effect: state.effect,\n          reconciled: state.reconciled,\n          next: decision.next,\n          reason: decision.reason,\n        }),\n      };\n      host.writeRetryLoopState(into, { ...state, decision: evidence, terminal: decision.next !== 'retry' });\n      return { branch: `${id}-${decision.next}`, [DECISION_RESULT]: true, evidence };\n    },\n    `${id}-decide`,\n  );\n  builder.tag(tag);\n  stamp(controlBudget);\n\n  const waitScope = async (scope: TScope): Promise<void> => {\n    const host = hostOf(scope);\n    const state = read(host) as RetryLoopState;\n    const delay = state.resumeAt === undefined ? state.delayMs : Math.max(0, state.resumeAt - Date.now());\n    const signal = host.getAttempt().signal;\n    await sleep(delay, signal);\n    if (signal.aborted) throw signal.reason ?? new Error('retry loop aborted');\n    host.writeRetryLoopState(into, { ...state, attempt: state.attempt + 1, decision: undefined, resumeAt: undefined });\n  };\n  // Branch-list methods keep their builder cursor on the decider. The wait callback is an ordinary branch;\n  // pause mode uses interrupt semantics in that callback so its own stage resumes before it loops back.\n  const waitFn =\n    wait === 'pause'\n      ? async (scope: TScope) => {\n          const host = hostOf(scope);\n          const state = read(host) as RetryLoopState;\n          if (state.resumeAt === undefined)\n            host.writeRetryLoopState(into, { ...state, resumeAt: Date.now() + state.delayMs });\n          interrupt(scope, { reason: `Retry ${id}`, expects: { resumeAt: (read(host) as RetryLoopState).resumeAt } });\n          await waitScope(scope);\n        }\n      : waitScope;\n  decider\n    .addFunctionBranch(`${id}-retry`, `Wait ${id}`, waitFn, undefined, { loopTo: id, tags: [tag] })\n    .addFunctionBranch(`${id}-done`, `Done ${id}`, () => undefined, undefined, { tags: [tag] })\n    .addFunctionBranch(\n      `${id}-stop`,\n      `Stop ${id}`,\n      (scope: TScope) => {\n        if (onStop === 'continue') return;\n        const host = hostOf(scope);\n        const state = read(host) as RetryLoopState;\n        const cause = Object.assign(new Error(state.error?.message ?? 'retry loop stopped'), {\n          name: state.error?.name ?? 'Error',\n          ...(state.error?.code ? { code: state.error.code } : {}),\n        });\n        if (state.effect === 'unknown')\n          throw new UnknownEffectError({\n            system: touches,\n            idempotencyKey: host.serveRetryLoopKey(state.idempotencyKey),\n            attempts: state.attempt,\n            cause,\n          });\n        throw cause;\n      },\n      undefined,\n      { tags: [tag] },\n    )\n    .end();\n  // Branch nodes are assigned their bounded helper costs by the builder after construction.\n  stamp(waitBudget, `${id}-retry`);\n  stamp(controlBudget, `${id}-done`);\n  stamp(controlBudget, `${id}-stop`);\n}\n"]}

package/dist/esm/lib/builder/types.d.ts

@@ -9,7 +9,7 @@
  * The builder remains standalone at runtime.
  */
 import type { StageNode } from '../engine/graph/StageNode.js';
-import type { ILogger, RetryPolicy, ScopeFactory, StageFunction } from '../engine/types.js';
+import type { ILogger, RetryPolicy, ScopeFactory, StageFunction, StageTouches } from '../engine/types.js';
 import type { ScopeProtectionMode } from '../scope/protection/types.js';
 import type { StructureRecorder } from './structure/StructureRecorder.js';
 export type { ResumeFn, StageNode } from '../engine/graph/StageNode.js';
@@ -71,6 +71,26 @@ export interface SerializedPipelineStructure {
      * be `undefined` at fire time for exactly the stages that have a policy.
      */
     retryAttempts?: number;
+    /**
+     * The cap on ONE attempt of this stage, from its declared {@link RetryPolicy}
+     * (`timeoutMs`). Present only when declared. With `retryAttempts` it is what
+     * bounds the stage in time: at most `retryAttempts × timeoutMs` plus the
+     * waits between attempts (`timeBudget`). Same read-it-from-the-built-spec
+     * caveat as `retryAttempts`.
+     */
+    timeoutMs?: number;
+    /**
+     * The chart's declared time budget (`.budget(ms)`), on the ROOT spec only —
+     * the most milliseconds a caller gives one run. `build()` refused the chart
+     * if its declared policies could already take longer. Absent when undeclared.
+     */
+    budgetMs?: number;
+    /**
+     * The outside system this stage changes (`.touches(system, …)`, 10.1) — the
+     * NAME only; the key rule is a function and stays on the node. Present only
+     * when declared. Same read-it-from-the-built-spec caveat as `retryAttempts`.
+     */
+    touches?: string;
     /**
      * Declared tags (9.21.0) — the NAMES the author put on this stage at build
      * time, copied as-is (JSON-safe, free strings; footprintjs owns no
@@ -118,6 +138,12 @@ export interface FlowChartSpec {
     /** Total attempts allowed by this stage's declared retry policy — the count
      *  only (see `SerializedPipelineStructure.retryAttempts`). */
     retryAttempts?: number;
+    /** The cap on one attempt (see `SerializedPipelineStructure.timeoutMs`). */
+    timeoutMs?: number;
+    /** The chart's declared time budget, on the root only (see `SerializedPipelineStructure.budgetMs`). */
+    budgetMs?: number;
+    /** The outside system this stage changes, by name (see `SerializedPipelineStructure.touches`). */
+    touches?: string;
     /** Declared tags on this stage, as-is (see `SerializedPipelineStructure.tags`). */
     tags?: readonly string[];
 }
@@ -154,6 +180,12 @@ export interface FlowChartOptions {
      * at their own declaration site. See {@link RetryPolicy}.
      */
     retry?: RetryPolicy;
+    /**
+     * The outside system the chart's FIRST stage changes, and its idempotency-key
+     * rule (10.1). Later stages use the `.touches()` modifier, or the `touches`
+     * option at their own declaration site. See {@link StageTouches}.
+     */
+    touches?: StageTouches;
     /**
      * Declared tags for the chart's FIRST stage. Later stages use the `.tag()`
      * modifier, or the `tags` option at their own declaration site. A tag is a
@@ -190,6 +222,8 @@ export type SimplifiedParallelSpec<TOut = any, TScope = any> = {
     /** Declarative retry policy for this fork child. Fork branches are where
      *  flaky I/O usually lives, so each child declares its own. */
     retry?: RetryPolicy;
+    /** The outside system this fork child changes, and its key rule (10.1). */
+    touches?: StageTouches;
     /** Declared tags for this fork child — each child's bundle carries its own. */
     tags?: readonly string[];
 };

package/dist/esm/lib/builder/types.js

@@ -9,4 +9,4 @@
  * The builder remains standalone at runtime.
  */
 export { ArrayMergeMode } from '../engine/types.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/builder/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAwBH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC","sourcesContent":["/**\n * builder/types.ts — All types used by the builder library.\n *\n * Shared types (StageNode, StageFunction, etc.) are imported from the engine.\n * Builder-specific types (FlowChartSpec, FlowChart, SerializedPipelineStructure)\n * are defined locally — they carry builder-only fields (description, outputMapper, etc.).\n *\n * NOTE: All engine imports are `import type` — zero runtime dependency.\n * The builder remains standalone at runtime.\n */\n\nimport type { StageNode } from '../engine/graph/StageNode.js';\nimport type { ILogger, RetryPolicy, ScopeFactory, StageFunction } from '../engine/types.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport type { StructureRecorder } from './structure/StructureRecorder.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Re-exports from engine (canonical definitions)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ResumeFn, StageNode } from '../engine/graph/StageNode.js';\nexport type {\n  BranchChart,\n  ILogger,\n  ParallelForEachConfig,\n  RetryPolicy,\n  StageFunction,\n  StreamCallback,\n  StreamHandlers,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n} from '../engine/types.js';\nexport { ArrayMergeMode } from '../engine/types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Aliases\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Relaxed-generic alias for builder ergonomics. */\nexport type StageFn = StageFunction<any, any>;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Scope Protection — canonical definition in scope/protection/types.ts\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ScopeProtectionMode };\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Serialized Pipeline Structure (JSON-safe, for visualization)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SerializedPipelineStructure {\n  name: string;\n  id: string;\n  type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: SerializedPipelineStructure[];\n  next?: SerializedPipelineStructure;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /**\n   * Nested pipeline structure for a subflow node.\n   * WARNING: Any future walker that traverses this field recursively must apply its own\n   * depth and cycle guards across both the `next` chain and this nested structure.\n   * Chart OpenAPI generation reads the builder-prepared description, not this graph.\n   */\n  subflowStructure?: SerializedPipelineStructure;\n  iterationCount?: number;\n  /** True when this subflow uses lazy resolution (deferred until execution). */\n  isLazy?: boolean;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n  /**\n   * True for an `addParallelForEach` fan-out — one branch per item, count\n   * decided at runtime. A flag, not a type: `type` stays `'fork'` so existing\n   * consumers keep rendering it as the fan-out it is.\n   */\n  isDynamicParallel?: boolean;\n  /**\n   * Total attempts this stage's function may run, from its declared\n   * {@link RetryPolicy}. Present only when a policy was declared — the COUNT\n   * only, because `backoffMs` and `retryOn` can be functions and a JSON-safe\n   * spec cannot carry those.\n   *\n   * Read it from the BUILT spec (`chart.buildTimeStructure` / `toSpec()`), not\n   * from a `StructureRecorder.onStageAdded` event: the `.retry()` modifier is\n   * chained AFTER the stage is added, so the event fires first. That is why\n   * there is no `retryAttempts` discriminator on the event payload — it would\n   * be `undefined` at fire time for exactly the stages that have a policy.\n   */\n  retryAttempts?: number;\n  /**\n   * Declared tags (9.21.0) — the NAMES the author put on this stage at build\n   * time, copied as-is (JSON-safe, free strings; footprintjs owns no\n   * vocabulary). The Map advertises what a chart CAN produce; the commit\n   * bundle (`CommitBundle.tags`) records which a run DID hit. Absent when the\n   * stage declares none. Same read-it-from-the-built-spec caveat as\n   * `retryAttempts`: `.tag()` is chained AFTER `onStageAdded` fires.\n   */\n  tags?: readonly string[];\n  /**\n   * STRUCTURE-ONLY: for a fork/selector/decider branch, the downstream stage\n   * id its convergence `next` edge points to, instead of the shared next-stage\n   * its siblings converge at. Set from `SubflowMountOptions.convergeAt`; read by\n   * `_fireNextEdgeFromParent` to express an unequal-depth merge (e.g. tools →\n   * call-llm, bypassing message-api). Visualization-only — runtime convergence\n   * is unchanged.\n   */\n  convergeAt?: string;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChartSpec (pure JSON, no functions — for FE→BE transport)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface FlowChartSpec {\n  name: string;\n  id: string;\n  /** Node type — matches `SerializedPipelineStructure.type` for visualization alignment. */\n  type?: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: FlowChartSpec[];\n  next?: FlowChartSpec;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n  /** True for an `addParallelForEach` fan-out (`type` stays `'fork'`). */\n  isDynamicParallel?: boolean;\n  /** Total attempts allowed by this stage's declared retry policy — the count\n   *  only (see `SerializedPipelineStructure.retryAttempts`). */\n  retryAttempts?: number;\n  /** Declared tags on this stage, as-is (see `SerializedPipelineStructure.tags`). */\n  tags?: readonly string[];\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// flowChart() options bag\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Options-bag argument shape for the `flowChart()` factory.\n */\nexport interface FlowChartOptions {\n  /**\n   * Build-time recorders to attach BEFORE `start()` fires. Equivalent\n   * to chaining `.attachStructureRecorder(rec)` immediately after the\n   * factory returns — but registered EARLIER, so even the seed event\n   * fires through the dispatcher without needing the seed-replay path.\n   *\n   * Multiple recorders attach in array order (same as\n   * `.attachStructureRecorder` repeated). See `StructureRecorder` JSDoc\n   * for event semantics, ordering invariants, and the trust model.\n   */\n  structureRecorders?: StructureRecorder[];\n  /** Free-form description shown on the root spec node. */\n  description?: string;\n  /**\n   * Only meaningful for `flowChartSelector` (a root selector). When the\n   * selector picks ≥2 branches they fan out in parallel: `failFast: true`\n   * uses `Promise.all` (first branch error rejects + aborts), the default\n   * uses `Promise.allSettled` (best-effort — all branches run even if some\n   * fail). Use fail-fast when all selected branches are REQUIRED. Ignored for\n   * non-selector charts. Same flag `addSelectorFunction` / `addListOfFunction`\n   * expose.\n   */\n  failFast?: boolean;\n  /**\n   * Declarative retry policy for the chart's FIRST stage (the one this factory\n   * declares). Later stages use the `.retry()` modifier, or the `retry` option\n   * at their own declaration site. See {@link RetryPolicy}.\n   */\n  retry?: RetryPolicy;\n  /**\n   * Declared tags for the chart's FIRST stage. Later stages use the `.tag()`\n   * modifier, or the `tags` option at their own declaration site. A tag is a\n   * NAME declared at build time — never a value — and is stamped on every\n   * commit bundle the stage records (`CommitBundle.tags`), so a stored\n   * recording carries its own milestones. See `FlowChartBuilder.tag`.\n   */\n  tags?: readonly string[];\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChart — compiled output of build()\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type FlowChart<TOut = any, TScope = any> = {\n  root: StageNode<TOut, TScope>;\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  buildTimeStructure: SerializedPipelineStructure;\n  enableNarrative?: boolean;\n  logger?: ILogger;\n  description: string;\n  stageDescriptions: Map<string, string>;\n  /** Input schema (Zod or JSON Schema) — declared via setInputSchema() or .contract(). */\n  inputSchema?: unknown;\n  /** Output schema (Zod or JSON Schema) — declared via setOutputSchema() or .contract(). */\n  outputSchema?: unknown;\n  /** Output mapper — extracts response from final scope. */\n  outputMapper?: (finalScope: Record<string, unknown>) => unknown;\n  /** Scope factory — auto-embedded by flowChart<T>(). Executor reads this if no factory param. */\n  scopeFactory?: ScopeFactory<TScope>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Simplified Parallel Spec (for addListOfFunction)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SimplifiedParallelSpec<TOut = any, TScope = any> = {\n  id: string;\n  name: string;\n  fn?: StageFunction<TOut, TScope>;\n  /** Declarative retry policy for this fork child. Fork branches are where\n   *  flaky I/O usually lives, so each child declares its own. */\n  retry?: RetryPolicy;\n  /** Declared tags for this fork child — each child's bundle carries its own. */\n  tags?: readonly string[];\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// ExecOptions (for execute() convenience — used by runner layer)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type ExecOptions = {\n  defaults?: unknown;\n  initial?: unknown;\n  readOnly?: unknown;\n  throttlingErrorChecker?: (e: unknown) => boolean;\n  scopeProtectionMode?: ScopeProtectionMode;\n  enableNarrative?: boolean;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// SubflowRef\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SubflowRef {\n  $ref: string;\n  mountId: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/builder/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAwBH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC","sourcesContent":["/**\n * builder/types.ts — All types used by the builder library.\n *\n * Shared types (StageNode, StageFunction, etc.) are imported from the engine.\n * Builder-specific types (FlowChartSpec, FlowChart, SerializedPipelineStructure)\n * are defined locally — they carry builder-only fields (description, outputMapper, etc.).\n *\n * NOTE: All engine imports are `import type` — zero runtime dependency.\n * The builder remains standalone at runtime.\n */\n\nimport type { StageNode } from '../engine/graph/StageNode.js';\nimport type { ILogger, RetryPolicy, ScopeFactory, StageFunction, StageTouches } from '../engine/types.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport type { StructureRecorder } from './structure/StructureRecorder.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Re-exports from engine (canonical definitions)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ResumeFn, StageNode } from '../engine/graph/StageNode.js';\nexport type {\n  BranchChart,\n  ILogger,\n  ParallelForEachConfig,\n  RetryPolicy,\n  StageFunction,\n  StreamCallback,\n  StreamHandlers,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n} from '../engine/types.js';\nexport { ArrayMergeMode } from '../engine/types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Aliases\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Relaxed-generic alias for builder ergonomics. */\nexport type StageFn = StageFunction<any, any>;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Scope Protection — canonical definition in scope/protection/types.ts\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ScopeProtectionMode };\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Serialized Pipeline Structure (JSON-safe, for visualization)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SerializedPipelineStructure {\n  name: string;\n  id: string;\n  type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: SerializedPipelineStructure[];\n  next?: SerializedPipelineStructure;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /**\n   * Nested pipeline structure for a subflow node.\n   * WARNING: Any future walker that traverses this field recursively must apply its own\n   * depth and cycle guards across both the `next` chain and this nested structure.\n   * Chart OpenAPI generation reads the builder-prepared description, not this graph.\n   */\n  subflowStructure?: SerializedPipelineStructure;\n  iterationCount?: number;\n  /** True when this subflow uses lazy resolution (deferred until execution). */\n  isLazy?: boolean;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n  /**\n   * True for an `addParallelForEach` fan-out — one branch per item, count\n   * decided at runtime. A flag, not a type: `type` stays `'fork'` so existing\n   * consumers keep rendering it as the fan-out it is.\n   */\n  isDynamicParallel?: boolean;\n  /**\n   * Total attempts this stage's function may run, from its declared\n   * {@link RetryPolicy}. Present only when a policy was declared — the COUNT\n   * only, because `backoffMs` and `retryOn` can be functions and a JSON-safe\n   * spec cannot carry those.\n   *\n   * Read it from the BUILT spec (`chart.buildTimeStructure` / `toSpec()`), not\n   * from a `StructureRecorder.onStageAdded` event: the `.retry()` modifier is\n   * chained AFTER the stage is added, so the event fires first. That is why\n   * there is no `retryAttempts` discriminator on the event payload — it would\n   * be `undefined` at fire time for exactly the stages that have a policy.\n   */\n  retryAttempts?: number;\n  /**\n   * The cap on ONE attempt of this stage, from its declared {@link RetryPolicy}\n   * (`timeoutMs`). Present only when declared. With `retryAttempts` it is what\n   * bounds the stage in time: at most `retryAttempts × timeoutMs` plus the\n   * waits between attempts (`timeBudget`). Same read-it-from-the-built-spec\n   * caveat as `retryAttempts`.\n   */\n  timeoutMs?: number;\n  /**\n   * The chart's declared time budget (`.budget(ms)`), on the ROOT spec only —\n   * the most milliseconds a caller gives one run. `build()` refused the chart\n   * if its declared policies could already take longer. Absent when undeclared.\n   */\n  budgetMs?: number;\n  /**\n   * The outside system this stage changes (`.touches(system, …)`, 10.1) — the\n   * NAME only; the key rule is a function and stays on the node. Present only\n   * when declared. Same read-it-from-the-built-spec caveat as `retryAttempts`.\n   */\n  touches?: string;\n  /**\n   * Declared tags (9.21.0) — the NAMES the author put on this stage at build\n   * time, copied as-is (JSON-safe, free strings; footprintjs owns no\n   * vocabulary). The Map advertises what a chart CAN produce; the commit\n   * bundle (`CommitBundle.tags`) records which a run DID hit. Absent when the\n   * stage declares none. Same read-it-from-the-built-spec caveat as\n   * `retryAttempts`: `.tag()` is chained AFTER `onStageAdded` fires.\n   */\n  tags?: readonly string[];\n  /**\n   * STRUCTURE-ONLY: for a fork/selector/decider branch, the downstream stage\n   * id its convergence `next` edge points to, instead of the shared next-stage\n   * its siblings converge at. Set from `SubflowMountOptions.convergeAt`; read by\n   * `_fireNextEdgeFromParent` to express an unequal-depth merge (e.g. tools →\n   * call-llm, bypassing message-api). Visualization-only — runtime convergence\n   * is unchanged.\n   */\n  convergeAt?: string;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChartSpec (pure JSON, no functions — for FE→BE transport)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface FlowChartSpec {\n  name: string;\n  id: string;\n  /** Node type — matches `SerializedPipelineStructure.type` for visualization alignment. */\n  type?: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: FlowChartSpec[];\n  next?: FlowChartSpec;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n  /** True for an `addParallelForEach` fan-out (`type` stays `'fork'`). */\n  isDynamicParallel?: boolean;\n  /** Total attempts allowed by this stage's declared retry policy — the count\n   *  only (see `SerializedPipelineStructure.retryAttempts`). */\n  retryAttempts?: number;\n  /** The cap on one attempt (see `SerializedPipelineStructure.timeoutMs`). */\n  timeoutMs?: number;\n  /** The chart's declared time budget, on the root only (see `SerializedPipelineStructure.budgetMs`). */\n  budgetMs?: number;\n  /** The outside system this stage changes, by name (see `SerializedPipelineStructure.touches`). */\n  touches?: string;\n  /** Declared tags on this stage, as-is (see `SerializedPipelineStructure.tags`). */\n  tags?: readonly string[];\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// flowChart() options bag\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Options-bag argument shape for the `flowChart()` factory.\n */\nexport interface FlowChartOptions {\n  /**\n   * Build-time recorders to attach BEFORE `start()` fires. Equivalent\n   * to chaining `.attachStructureRecorder(rec)` immediately after the\n   * factory returns — but registered EARLIER, so even the seed event\n   * fires through the dispatcher without needing the seed-replay path.\n   *\n   * Multiple recorders attach in array order (same as\n   * `.attachStructureRecorder` repeated). See `StructureRecorder` JSDoc\n   * for event semantics, ordering invariants, and the trust model.\n   */\n  structureRecorders?: StructureRecorder[];\n  /** Free-form description shown on the root spec node. */\n  description?: string;\n  /**\n   * Only meaningful for `flowChartSelector` (a root selector). When the\n   * selector picks ≥2 branches they fan out in parallel: `failFast: true`\n   * uses `Promise.all` (first branch error rejects + aborts), the default\n   * uses `Promise.allSettled` (best-effort — all branches run even if some\n   * fail). Use fail-fast when all selected branches are REQUIRED. Ignored for\n   * non-selector charts. Same flag `addSelectorFunction` / `addListOfFunction`\n   * expose.\n   */\n  failFast?: boolean;\n  /**\n   * Declarative retry policy for the chart's FIRST stage (the one this factory\n   * declares). Later stages use the `.retry()` modifier, or the `retry` option\n   * at their own declaration site. See {@link RetryPolicy}.\n   */\n  retry?: RetryPolicy;\n  /**\n   * The outside system the chart's FIRST stage changes, and its idempotency-key\n   * rule (10.1). Later stages use the `.touches()` modifier, or the `touches`\n   * option at their own declaration site. See {@link StageTouches}.\n   */\n  touches?: StageTouches;\n  /**\n   * Declared tags for the chart's FIRST stage. Later stages use the `.tag()`\n   * modifier, or the `tags` option at their own declaration site. A tag is a\n   * NAME declared at build time — never a value — and is stamped on every\n   * commit bundle the stage records (`CommitBundle.tags`), so a stored\n   * recording carries its own milestones. See `FlowChartBuilder.tag`.\n   */\n  tags?: readonly string[];\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChart — compiled output of build()\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type FlowChart<TOut = any, TScope = any> = {\n  root: StageNode<TOut, TScope>;\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  buildTimeStructure: SerializedPipelineStructure;\n  enableNarrative?: boolean;\n  logger?: ILogger;\n  description: string;\n  stageDescriptions: Map<string, string>;\n  /** Input schema (Zod or JSON Schema) — declared via setInputSchema() or .contract(). */\n  inputSchema?: unknown;\n  /** Output schema (Zod or JSON Schema) — declared via setOutputSchema() or .contract(). */\n  outputSchema?: unknown;\n  /** Output mapper — extracts response from final scope. */\n  outputMapper?: (finalScope: Record<string, unknown>) => unknown;\n  /** Scope factory — auto-embedded by flowChart<T>(). Executor reads this if no factory param. */\n  scopeFactory?: ScopeFactory<TScope>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Simplified Parallel Spec (for addListOfFunction)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SimplifiedParallelSpec<TOut = any, TScope = any> = {\n  id: string;\n  name: string;\n  fn?: StageFunction<TOut, TScope>;\n  /** Declarative retry policy for this fork child. Fork branches are where\n   *  flaky I/O usually lives, so each child declares its own. */\n  retry?: RetryPolicy;\n  /** The outside system this fork child changes, and its key rule (10.1). */\n  touches?: StageTouches;\n  /** Declared tags for this fork child — each child's bundle carries its own. */\n  tags?: readonly string[];\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// ExecOptions (for execute() convenience — used by runner layer)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type ExecOptions = {\n  defaults?: unknown;\n  initial?: unknown;\n  readOnly?: unknown;\n  throttlingErrorChecker?: (e: unknown) => boolean;\n  scopeProtectionMode?: ScopeProtectionMode;\n  enableNarrative?: boolean;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// SubflowRef\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SubflowRef {\n  $ref: string;\n  mountId: string;\n}\n"]}