footprintjs 10.0.1 → 10.2.0

package/dist/lib/builder/retryLoop.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendRetryLoop = void 0;
+/** Explicit retry workflow: ordinary attempt → reconcile → decide → wait/loop nodes, one rule table. */
+const foottrace_1 = require("foottrace");
+const decision_js_1 = require("../attempt/decision.js");
+const effect_js_1 = require("../attempt/effect.js");
+const errors_js_1 = require("../attempt/errors.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 types_js_1 = require("../decide/types.js");
+const interrupt_js_1 = require("../pause/interrupt.js");
+const types_js_2 = require("../pause/types.js");
+const runtime_js_1 = require("../scope/runtime.js");
+const fail = (field) => {
+    throw new TypeError(`addRetryLoop: invalid ${field}`);
+};
+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 ((0, policy_js_1.retryPolicyProblem)(retry) || !Number.isSafeInteger(attempts))
+        fail('retry policy');
+    if ((0, effect_js_1.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 : (0, policy_js_1.cappedWaitMs)((0, runner_js_1.resolveBackoffMs)(backoffMs, 1), maxBackoffMs),
+    };
+    const controlBudget = { role: 'control' };
+    const hostOf = (scope) => {
+        const host = (0, runtime_js_1.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 = (0, foottrace_1.parseRuntimeStageId)(state.series);
+            if (!/#\d+$/.test(state.series) || parsed.stageId !== id)
+                fail('restored loop series');
+            (0, effect_js_1.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 = (0, retryLoopContext_js_1.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 ((0, types_js_2.isPauseSignal)(error) || (0, interrupt_js_1.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 errors_js_1.UnknownEffectError ? result.error.cause : result.error;
+            if (retryOn) {
+                try {
+                    allows = retryOn(original) === true;
+                }
+                catch {
+                    allows = false;
+                    threw = true;
+                }
+            }
+            if (allows)
+                delayMs = (0, policy_js_1.cappedWaitMs)((0, runner_js_1.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 = (0, decision_js_1.decideAttempt)((0, decision_js_1.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}`, [types_js_1.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 (0, runner_js_1.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 });
+            (0, interrupt_js_1.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 errors_js_1.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`);
+}
+exports.appendRetryLoop = appendRetryLoop;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retryLoop.js","sourceRoot":"","sources":["../../../src/lib/builder/retryLoop.ts"],"names":[],"mappings":"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","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/lib/builder/types.js

@@ -13,4 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayMergeMode = void 0;
 var types_js_1 = require("../engine/types.js");
 Object.defineProperty(exports, "ArrayMergeMode", { enumerable: true, get: function () { return types_js_1.ArrayMergeMode; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/builder/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAwBH,+CAAoD;AAA3C,0GAAA,cAAc,OAAA","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,+CAAoD;AAA3C,0GAAA,cAAc,OAAA","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"]}

package/dist/lib/decide/decide.js

@@ -12,8 +12,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.select = exports.decide = void 0;
 const devMode_js_1 = require("../devMode.js");
+const evaluator_js_1 = require("../filter/evaluator.js");
 const runtime_js_1 = require("../scope/runtime.js");
-const evaluator_js_1 = require("./evaluator.js");
 const evidence_js_1 = require("./evidence.js");
 const types_js_1 = require("./types.js");
 // -- Scope accessor helpers --------------------------------------------------
@@ -211,4 +211,4 @@ function select(scope, rules) {
     return { branches: selectedBranches, [types_js_1.DECISION_RESULT]: true, evidence };
 }
 exports.select = select;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decide.js","sourceRoot":"","sources":["../../../src/lib/decide/decide.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/decide -- Core decide() and select() helper functions.\n *\n * decide() evaluates rules in order (first-match) and returns a DecisionResult.\n * select() evaluates ALL rules and returns a SelectionResult with all matches.\n *\n * Each rule's `when` can be:\n * - A function: (s) => s.creditScore > 700  (auto-captures reads via temp recorder)\n * - A filter:   { creditScore: { gt: 700 } } (captures reads + operators + thresholds)\n */\n\nimport { isDevMode } from '../devMode.js';\nimport { requireDecisionScopeRuntime } from '../scope/runtime.js';\nimport type { ScopeRecorder } from '../scope/types.js';\nimport { evaluateFilter } from './evaluator.js';\nimport { EvidenceCollector } from './evidence.js';\nimport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterCondition,\n  FilterRuleEvidence,\n  FunctionRuleEvidence,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhereFilter,\n} from './types.js';\nimport { DECISION_RESULT } from './types.js';\n\n// -- Scope accessor helpers --------------------------------------------------\n\nfunction scopeAccessors(scope: unknown) {\n  const { target } = requireDecisionScopeRuntime(scope);\n  const keys = target.getRedactedKeys?.();\n  return {\n    attachFn: target.attachScopeRecorder?.bind(target),\n    detachFn: target.detachScopeRecorder?.bind(target),\n    valueFn: target.getValue?.bind(target) ?? (() => undefined),\n    redactedFn: (key: string) => keys?.has(key) ?? false,\n  };\n}\n\n// -- evaluate a single rule --------------------------------------------------\n\nfunction evaluateRule<S extends object>(\n  scope: S,\n  rule: DecideRule<S>,\n  index: number,\n  attachFn?: (r: ScopeRecorder) => void,\n  detachFn?: (id: string) => void,\n  valueFn?: (key: string) => unknown,\n  redactedFn?: (key: string) => boolean,\n): RuleEvidence {\n  if (typeof rule.when === 'function') {\n    // FUNCTION PATH: temp recorder captures reads (lazy — skip if no recorder support)\n    const hasRecorderSupport = Boolean(attachFn);\n    const collector = hasRecorderSupport ? new EvidenceCollector() : undefined;\n    if (collector && attachFn) attachFn(collector);\n\n    let matched: boolean;\n    let matchError: string | undefined;\n    try {\n      matched = rule.when(scope);\n    } catch (e) {\n      matched = false;\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    } finally {\n      if (collector && detachFn) detachFn(collector.id);\n    }\n\n    const evidence: FunctionRuleEvidence = {\n      type: 'function',\n      ruleIndex: index,\n      branch: rule.then,\n      matched,\n      label: rule.label,\n      // Partial reads: if rule threw after some getValue() calls, collector holds reads up to the throw point\n      inputs: collector?.getInputs() ?? [],\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  } else {\n    // FILTER PATH: reads values directly via callbacks (no recorder); exceptions treated as non-match\n    const resolvedValueFn = valueFn ?? (() => undefined);\n    const resolvedRedactedFn = redactedFn ?? (() => false);\n    let filterMatched = false;\n    let filterConditions: FilterCondition[] = [];\n    let matchError: string | undefined;\n    try {\n      const result = evaluateFilter(resolvedValueFn, resolvedRedactedFn, rule.when as WhereFilter<S>);\n      filterMatched = result.matched;\n      filterConditions = result.conditions;\n    } catch (e) {\n      filterMatched = false;\n      filterConditions = [];\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() filter rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    }\n\n    const evidence: FilterRuleEvidence = {\n      type: 'filter',\n      ruleIndex: index,\n      branch: rule.then,\n      matched: filterMatched,\n      label: rule.label,\n      conditions: filterConditions,\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  }\n}\n\n// -- default branch normalization --------------------------------------------\n\n/**\n * Collapses both {@link DefaultBranch} forms to one shape, once, at the top of\n * `decide()`. A bare string yields `label: undefined`, which every downstream\n * spread then omits — so the string call site produces exactly the evidence it\n * produced before this parameter was widened.\n *\n * ONLY the object form is unwrapped; every other value passes through as the\n * branch, untouched. That is deliberate: JavaScript callers reach `decide()`\n * with the third argument MISSING (a rule set that covers every case never\n * consults a default), and before the parameter widened that `undefined`\n * simply landed on `evidence.default`. It still does — a normalization that\n * only understood strings would turn those call sites into a TypeError.\n */\nfunction normalizeDefaultBranch(defaultBranch: DefaultBranch): { branch: string; label?: string } {\n  return typeof defaultBranch === 'object' && defaultBranch !== null\n    ? defaultBranch\n    : { branch: defaultBranch as string };\n}\n\n// -- decide() ----------------------------------------------------------------\n\n/**\n * Evaluates rules in order (first-match). Returns a branded DecisionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n * @param defaultBranch - Branch taken when no rule matches. Either the branch\n *   id (`'rejected'`) or the id plus what falling back to it MEANS\n *   (`{ branch: 'rejected', label: 'No rule fired' }`). The label lands on\n *   `evidence.defaultLabel` — the default is chosen by no rule, so it is the\n *   one branch that `rules[].label` can never describe.\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Execution continues with\n * subsequent rules; errors do not propagate to the caller.\n *\n * **Empty-filter behavior (anti-vacuous-truth):** a filter rule whose `when` is\n * `{}` (no evaluable conditions) NEVER matches. This deliberately inverts the\n * Prisma/SQL `where: {}` intuition (\"match everything\") — a rule that asserts\n * nothing must not win a branch on vacuous truth. Use `defaultBranch` for the\n * catch-all instead. Unknown filter operators also never match (dev mode warns).\n */\nexport function decide<S extends object>(\n  scope: S,\n  rules: DecideRule<S>[],\n  defaultBranch: DefaultBranch,\n): DecisionResult {\n  const { attachFn, detachFn, valueFn, redactedFn } = scopeAccessors(scope);\n\n  const { branch: defaultBranchId, label: defaultLabel } = normalizeDefaultBranch(defaultBranch);\n  // Declared once, spread into BOTH exits below — deliberately. A default's\n  // meaning is a property of the DECIDER, not of the run: it must be in the\n  // evidence of the run where a rule won just as much as in the run that fell\n  // through. Emit it only on the fallthrough and any consumer harvesting branch\n  // meanings would watch them appear and disappear with the data.\n  const defaultMeaning = defaultLabel !== undefined ? { defaultLabel } : undefined;\n\n  const evaluatedRules: RuleEvidence[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      const evidence: DecisionEvidence = {\n        rules: evaluatedRules,\n        chosen: rule.then,\n        default: defaultBranchId,\n        ...defaultMeaning,\n      };\n      return { branch: rule.then, [DECISION_RESULT]: true, evidence };\n    }\n  }\n\n  // Default: no rule matched\n  const evidence: DecisionEvidence = {\n    rules: evaluatedRules,\n    chosen: defaultBranchId,\n    default: defaultBranchId,\n    ...defaultMeaning,\n  };\n  return { branch: defaultBranchId, [DECISION_RESULT]: true, evidence };\n}\n\n// -- select() ----------------------------------------------------------------\n\n/**\n * Evaluates ALL rules (not first-match). Returns a branded SelectionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Evaluation continues with\n * remaining rules; errors do not propagate to the caller.\n *\n * **Empty-filter behavior (anti-vacuous-truth):** a filter rule whose `when` is\n * `{}` (no evaluable conditions) NEVER matches — same rule as `decide()`; an\n * always-selected branch must be expressed explicitly, not via an empty filter.\n * Unknown filter operators also never match (dev mode warns).\n */\nexport function select<S extends object>(scope: S, rules: DecideRule<S>[]): SelectionResult {\n  const { attachFn, detachFn, valueFn, redactedFn } = scopeAccessors(scope);\n\n  const evaluatedRules: RuleEvidence[] = [];\n  const selectedBranches: string[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      selectedBranches.push(rule.then);\n    }\n  }\n\n  const evidence: SelectionEvidence = {\n    rules: evaluatedRules,\n    selected: selectedBranches,\n  };\n  return { branches: selectedBranches, [DECISION_RESULT]: true, evidence };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decide.js","sourceRoot":"","sources":["../../../src/lib/decide/decide.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/decide -- Core decide() and select() helper functions.\n *\n * decide() evaluates rules in order (first-match) and returns a DecisionResult.\n * select() evaluates ALL rules and returns a SelectionResult with all matches.\n *\n * Each rule's `when` can be:\n * - A function: (s) => s.creditScore > 700  (auto-captures reads via temp recorder)\n * - A filter:   { creditScore: { gt: 700 } } (captures reads + operators + thresholds)\n */\n\nimport { isDevMode } from '../devMode.js';\nimport { evaluateFilter } from '../filter/evaluator.js';\nimport { requireDecisionScopeRuntime } from '../scope/runtime.js';\nimport type { ScopeRecorder } from '../scope/types.js';\nimport { EvidenceCollector } from './evidence.js';\nimport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterCondition,\n  FilterRuleEvidence,\n  FunctionRuleEvidence,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhereFilter,\n} from './types.js';\nimport { DECISION_RESULT } from './types.js';\n\n// -- Scope accessor helpers --------------------------------------------------\n\nfunction scopeAccessors(scope: unknown) {\n  const { target } = requireDecisionScopeRuntime(scope);\n  const keys = target.getRedactedKeys?.();\n  return {\n    attachFn: target.attachScopeRecorder?.bind(target),\n    detachFn: target.detachScopeRecorder?.bind(target),\n    valueFn: target.getValue?.bind(target) ?? (() => undefined),\n    redactedFn: (key: string) => keys?.has(key) ?? false,\n  };\n}\n\n// -- evaluate a single rule --------------------------------------------------\n\nfunction evaluateRule<S extends object>(\n  scope: S,\n  rule: DecideRule<S>,\n  index: number,\n  attachFn?: (r: ScopeRecorder) => void,\n  detachFn?: (id: string) => void,\n  valueFn?: (key: string) => unknown,\n  redactedFn?: (key: string) => boolean,\n): RuleEvidence {\n  if (typeof rule.when === 'function') {\n    // FUNCTION PATH: temp recorder captures reads (lazy — skip if no recorder support)\n    const hasRecorderSupport = Boolean(attachFn);\n    const collector = hasRecorderSupport ? new EvidenceCollector() : undefined;\n    if (collector && attachFn) attachFn(collector);\n\n    let matched: boolean;\n    let matchError: string | undefined;\n    try {\n      matched = rule.when(scope);\n    } catch (e) {\n      matched = false;\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    } finally {\n      if (collector && detachFn) detachFn(collector.id);\n    }\n\n    const evidence: FunctionRuleEvidence = {\n      type: 'function',\n      ruleIndex: index,\n      branch: rule.then,\n      matched,\n      label: rule.label,\n      // Partial reads: if rule threw after some getValue() calls, collector holds reads up to the throw point\n      inputs: collector?.getInputs() ?? [],\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  } else {\n    // FILTER PATH: reads values directly via callbacks (no recorder); exceptions treated as non-match\n    const resolvedValueFn = valueFn ?? (() => undefined);\n    const resolvedRedactedFn = redactedFn ?? (() => false);\n    let filterMatched = false;\n    let filterConditions: FilterCondition[] = [];\n    let matchError: string | undefined;\n    try {\n      const result = evaluateFilter(resolvedValueFn, resolvedRedactedFn, rule.when as WhereFilter<S>);\n      filterMatched = result.matched;\n      filterConditions = result.conditions;\n    } catch (e) {\n      filterMatched = false;\n      filterConditions = [];\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() filter rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    }\n\n    const evidence: FilterRuleEvidence = {\n      type: 'filter',\n      ruleIndex: index,\n      branch: rule.then,\n      matched: filterMatched,\n      label: rule.label,\n      conditions: filterConditions,\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  }\n}\n\n// -- default branch normalization --------------------------------------------\n\n/**\n * Collapses both {@link DefaultBranch} forms to one shape, once, at the top of\n * `decide()`. A bare string yields `label: undefined`, which every downstream\n * spread then omits — so the string call site produces exactly the evidence it\n * produced before this parameter was widened.\n *\n * ONLY the object form is unwrapped; every other value passes through as the\n * branch, untouched. That is deliberate: JavaScript callers reach `decide()`\n * with the third argument MISSING (a rule set that covers every case never\n * consults a default), and before the parameter widened that `undefined`\n * simply landed on `evidence.default`. It still does — a normalization that\n * only understood strings would turn those call sites into a TypeError.\n */\nfunction normalizeDefaultBranch(defaultBranch: DefaultBranch): { branch: string; label?: string } {\n  return typeof defaultBranch === 'object' && defaultBranch !== null\n    ? defaultBranch\n    : { branch: defaultBranch as string };\n}\n\n// -- decide() ----------------------------------------------------------------\n\n/**\n * Evaluates rules in order (first-match). Returns a branded DecisionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n * @param defaultBranch - Branch taken when no rule matches. Either the branch\n *   id (`'rejected'`) or the id plus what falling back to it MEANS\n *   (`{ branch: 'rejected', label: 'No rule fired' }`). The label lands on\n *   `evidence.defaultLabel` — the default is chosen by no rule, so it is the\n *   one branch that `rules[].label` can never describe.\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Execution continues with\n * subsequent rules; errors do not propagate to the caller.\n *\n * **Empty-filter behavior (anti-vacuous-truth):** a filter rule whose `when` is\n * `{}` (no evaluable conditions) NEVER matches. This deliberately inverts the\n * Prisma/SQL `where: {}` intuition (\"match everything\") — a rule that asserts\n * nothing must not win a branch on vacuous truth. Use `defaultBranch` for the\n * catch-all instead. Unknown filter operators also never match (dev mode warns).\n */\nexport function decide<S extends object>(\n  scope: S,\n  rules: DecideRule<S>[],\n  defaultBranch: DefaultBranch,\n): DecisionResult {\n  const { attachFn, detachFn, valueFn, redactedFn } = scopeAccessors(scope);\n\n  const { branch: defaultBranchId, label: defaultLabel } = normalizeDefaultBranch(defaultBranch);\n  // Declared once, spread into BOTH exits below — deliberately. A default's\n  // meaning is a property of the DECIDER, not of the run: it must be in the\n  // evidence of the run where a rule won just as much as in the run that fell\n  // through. Emit it only on the fallthrough and any consumer harvesting branch\n  // meanings would watch them appear and disappear with the data.\n  const defaultMeaning = defaultLabel !== undefined ? { defaultLabel } : undefined;\n\n  const evaluatedRules: RuleEvidence[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      const evidence: DecisionEvidence = {\n        rules: evaluatedRules,\n        chosen: rule.then,\n        default: defaultBranchId,\n        ...defaultMeaning,\n      };\n      return { branch: rule.then, [DECISION_RESULT]: true, evidence };\n    }\n  }\n\n  // Default: no rule matched\n  const evidence: DecisionEvidence = {\n    rules: evaluatedRules,\n    chosen: defaultBranchId,\n    default: defaultBranchId,\n    ...defaultMeaning,\n  };\n  return { branch: defaultBranchId, [DECISION_RESULT]: true, evidence };\n}\n\n// -- select() ----------------------------------------------------------------\n\n/**\n * Evaluates ALL rules (not first-match). Returns a branded SelectionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Evaluation continues with\n * remaining rules; errors do not propagate to the caller.\n *\n * **Empty-filter behavior (anti-vacuous-truth):** a filter rule whose `when` is\n * `{}` (no evaluable conditions) NEVER matches — same rule as `decide()`; an\n * always-selected branch must be expressed explicitly, not via an empty filter.\n * Unknown filter operators also never match (dev mode warns).\n */\nexport function select<S extends object>(scope: S, rules: DecideRule<S>[]): SelectionResult {\n  const { attachFn, detachFn, valueFn, redactedFn } = scopeAccessors(scope);\n\n  const evaluatedRules: RuleEvidence[] = [];\n  const selectedBranches: string[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      selectedBranches.push(rule.then);\n    }\n  }\n\n  const evidence: SelectionEvidence = {\n    rules: evaluatedRules,\n    selected: selectedBranches,\n  };\n  return { branches: selectedBranches, [DECISION_RESULT]: true, evidence };\n}\n"]}

package/dist/lib/decide/index.js

@@ -16,9 +16,9 @@ var decide_js_1 = require("./decide.js");
 Object.defineProperty(exports, "decide", { enumerable: true, get: function () { return decide_js_1.decide; } });
 Object.defineProperty(exports, "select", { enumerable: true, get: function () { return decide_js_1.select; } });
 // Evaluator (for advanced use)
-var evaluator_js_1 = require("./evaluator.js");
+var evaluator_js_1 = require("../filter/evaluator.js");
 Object.defineProperty(exports, "evaluateFilter", { enumerable: true, get: function () { return evaluator_js_1.evaluateFilter; } });
 // Evidence collector (for advanced use)
 var evidence_js_1 = require("./evidence.js");
 Object.defineProperty(exports, "EvidenceCollector", { enumerable: true, get: function () { return evidence_js_1.EvidenceCollector; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2RlY2lkZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFvQkgsb0JBQW9CO0FBQ3BCLHVDQUE2QztBQUFwQywyR0FBQSxlQUFlLE9BQUE7QUFFeEIsaUJBQWlCO0FBQ2pCLHlDQUE2QztBQUFwQyxtR0FBQSxNQUFNLE9BQUE7QUFBRSxtR0FBQSxNQUFNLE9BQUE7QUFFdkIsK0JBQStCO0FBQy9CLCtDQUFnRDtBQUF2Qyw4R0FBQSxjQUFjLE9BQUE7QUFFdkIsd0NBQXdDO0FBQ3hDLDZDQUFrRDtBQUF6QyxnSEFBQSxpQkFBaUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogZGVjaWRlLyAtLSBEZWNpc2lvbiByZWFzb25pbmcgY2FwdHVyZSBmb3IgZm9vdHByaW50anMuXG4gKlxuICogZGVjaWRlKCkgYW5kIHNlbGVjdCgpIGF1dG8tY2FwdHVyZSBldmlkZW5jZSBmcm9tIGRlY2lkZXIvc2VsZWN0b3IgZnVuY3Rpb25zOlxuICogLSBGdW5jdGlvbiB3aGVuOiAocykgPT4gcy5jcmVkaXRTY29yZSA+IDcwMCAgKGF1dG8tY2FwdHVyZXMgcmVhZHMpXG4gKiAtIEZpbHRlciB3aGVuOiAgeyBjcmVkaXRTY29yZTogeyBndDogNzAwIH0gfSAgKGNhcHR1cmVzIHJlYWRzICsgb3BlcmF0b3JzICsgdGhyZXNob2xkcylcbiAqL1xuXG4vLyBUeXBlc1xuZXhwb3J0IHR5cGUge1xuICBEZWNpZGVSdWxlLFxuICBEZWNpc2lvbkV2aWRlbmNlLFxuICBEZWNpc2lvblJlc3VsdCxcbiAgRGVmYXVsdEJyYW5jaCxcbiAgRmlsdGVyQ29uZGl0aW9uLFxuICBGaWx0ZXJPcHMsXG4gIEZpbHRlclJ1bGVFdmlkZW5jZSxcbiAgRnVuY3Rpb25SdWxlRXZpZGVuY2UsXG4gIFJlYWRJbnB1dCxcbiAgUnVsZUV2aWRlbmNlLFxuICBTZWxlY3Rpb25FdmlkZW5jZSxcbiAgU2VsZWN0aW9uUmVzdWx0LFxuICBXaGVuQ2xhdXNlLFxuICBXaGVyZUZpbHRlcixcbn0gZnJvbSAnLi90eXBlcy5qcyc7XG5cbi8vIFJ1bnRpbWUgY29uc3RhbnRzXG5leHBvcnQgeyBERUNJU0lPTl9SRVNVTFQgfSBmcm9tICcuL3R5cGVzLmpzJztcblxuLy8gQ29yZSBmdW5jdGlvbnNcbmV4cG9ydCB7IGRlY2lkZSwgc2VsZWN0IH0gZnJvbSAnLi9kZWNpZGUuanMnO1xuXG4vLyBFdmFsdWF0b3IgKGZvciBhZHZhbmNlZCB1c2UpXG5leHBvcnQgeyBldmFsdWF0ZUZpbHRlciB9IGZyb20gJy4vZXZhbHVhdG9yLmpzJztcblxuLy8gRXZpZGVuY2UgY29sbGVjdG9yIChmb3IgYWR2YW5jZWQgdXNlKVxuZXhwb3J0IHsgRXZpZGVuY2VDb2xsZWN0b3IgfSBmcm9tICcuL2V2aWRlbmNlLmpzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2RlY2lkZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFvQkgsb0JBQW9CO0FBQ3BCLHVDQUE2QztBQUFwQywyR0FBQSxlQUFlLE9BQUE7QUFFeEIsaUJBQWlCO0FBQ2pCLHlDQUE2QztBQUFwQyxtR0FBQSxNQUFNLE9BQUE7QUFBRSxtR0FBQSxNQUFNLE9BQUE7QUFFdkIsK0JBQStCO0FBQy9CLHVEQUF3RDtBQUEvQyw4R0FBQSxjQUFjLE9BQUE7QUFFdkIsd0NBQXdDO0FBQ3hDLDZDQUFrRDtBQUF6QyxnSEFBQSxpQkFBaUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogZGVjaWRlLyAtLSBEZWNpc2lvbiByZWFzb25pbmcgY2FwdHVyZSBmb3IgZm9vdHByaW50anMuXG4gKlxuICogZGVjaWRlKCkgYW5kIHNlbGVjdCgpIGF1dG8tY2FwdHVyZSBldmlkZW5jZSBmcm9tIGRlY2lkZXIvc2VsZWN0b3IgZnVuY3Rpb25zOlxuICogLSBGdW5jdGlvbiB3aGVuOiAocykgPT4gcy5jcmVkaXRTY29yZSA+IDcwMCAgKGF1dG8tY2FwdHVyZXMgcmVhZHMpXG4gKiAtIEZpbHRlciB3aGVuOiAgeyBjcmVkaXRTY29yZTogeyBndDogNzAwIH0gfSAgKGNhcHR1cmVzIHJlYWRzICsgb3BlcmF0b3JzICsgdGhyZXNob2xkcylcbiAqL1xuXG4vLyBUeXBlc1xuZXhwb3J0IHR5cGUge1xuICBEZWNpZGVSdWxlLFxuICBEZWNpc2lvbkV2aWRlbmNlLFxuICBEZWNpc2lvblJlc3VsdCxcbiAgRGVmYXVsdEJyYW5jaCxcbiAgRmlsdGVyQ29uZGl0aW9uLFxuICBGaWx0ZXJPcHMsXG4gIEZpbHRlclJ1bGVFdmlkZW5jZSxcbiAgRnVuY3Rpb25SdWxlRXZpZGVuY2UsXG4gIFJlYWRJbnB1dCxcbiAgUnVsZUV2aWRlbmNlLFxuICBTZWxlY3Rpb25FdmlkZW5jZSxcbiAgU2VsZWN0aW9uUmVzdWx0LFxuICBXaGVuQ2xhdXNlLFxuICBXaGVyZUZpbHRlcixcbn0gZnJvbSAnLi90eXBlcy5qcyc7XG5cbi8vIFJ1bnRpbWUgY29uc3RhbnRzXG5leHBvcnQgeyBERUNJU0lPTl9SRVNVTFQgfSBmcm9tICcuL3R5cGVzLmpzJztcblxuLy8gQ29yZSBmdW5jdGlvbnNcbmV4cG9ydCB7IGRlY2lkZSwgc2VsZWN0IH0gZnJvbSAnLi9kZWNpZGUuanMnO1xuXG4vLyBFdmFsdWF0b3IgKGZvciBhZHZhbmNlZCB1c2UpXG5leHBvcnQgeyBldmFsdWF0ZUZpbHRlciB9IGZyb20gJy4uL2ZpbHRlci9ldmFsdWF0b3IuanMnO1xuXG4vLyBFdmlkZW5jZSBjb2xsZWN0b3IgKGZvciBhZHZhbmNlZCB1c2UpXG5leHBvcnQgeyBFdmlkZW5jZUNvbGxlY3RvciB9IGZyb20gJy4vZXZpZGVuY2UuanMnO1xuIl19