footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/budget/timeBudget.js

@@ -0,0 +1,666 @@
+/**
+ * budget/timeBudget.ts — `timeBudget(chart)`: the slowest a chart can take, from what it declares (design
+ * docs/design/2026-10-time-and-failure-evidence.md §3.2, packet P5).
+ *
+ * WHY: a retry policy is a promise about time. `{ attempts: 4, timeoutMs: 40_000, backoffMs: 1_000 }` allows
+ * 4 × 40 000 + 3 × 1 000 = 163 000 ms, and a caller who gave the chart 120 s is not served by it — which is
+ * knowable before a single stage runs. `.budget(ms)` declares the caller's contract on the chart; `build()` refuses
+ * a chart whose declared policies already allow longer (owner ruling Q2) and warns, by name, about every stage it
+ * cannot bound. An unbounded stage is never guessed around: it is counted as 0 and named.
+ *
+ * THE RULES (one walk of the built StageNode graph; each chain of `next` pointers is computed once per start):
+ *   - a stage with a function: `attempts × timeoutMs` plus the waits between its attempts, as the runner waits them
+ *     (`attempt/policy.ts`). A number `backoffMs` is arithmetic, under `maxBackoffMs` when declared. A FUNCTION is
+ *     never asked: it may read the error (a stated `Retry-After`) and no error exists here, so asking it with none
+ *     could UNDERESTIMATE. It counts at its declared ceiling, `maxBackoffMs` per wait (the runner enforces it); with
+ *     no ceiling the stage is unbounded `'backoff'`. No `timeoutMs` → unbounded `'no-timeout'`;
+ *   - a sequence: the sum. A decider, a selector, a fork: the node's own stage plus its slowest child (a fork's
+ *     children, and a selector's picks, run at once);
+ *   - a mounted subflow: its chart, walked the same way, under the ids the run gives its stages (`pay/charge`);
+ *     a lazy one is unbounded `'lazy-subflow'` unless `assume.lazy[subflowId]` names the chart it resolves to;
+ *   - `parallelForEach`: ONE branch — the branches run at once and `maxBranches` truncates, so the item count never
+ *     adds time. The branch chart is built at run time, so it is unbounded `'items'` unless
+ *     `assume.branches[stageId]` names it (its stages are reported under the first branch, `review~0/score`);
+ *   - a loop is NEVER iterated. With no assumption it is unbounded `'loop'`, named by its target, and counted once.
+ *     `assume.loops[targetId] = n` bounds it: each time the chart reaches the loop, every stage from the target to
+ *     the loop's furthest source runs at most `n` times, each at its slowest. Nested loops multiply; two loops that
+ *     overlap without nesting are one region bounded by the product of their passes (each can re-enter the other).
+ *
+ * TWO NUMBERS. `knownMs` counts what is bounded (an unbounded stage as 0, an unassumed loop once). Without
+ * assumptions it is a time the declared policies ALLOW a run to take (`retryOn` is not read: it may only end a series
+ * sooner), so a budget below it cannot be promised — `over` and the build refusal read it, on an unbounded path too.
+ * `worstCaseMs` is `knownMs` when every path is bounded, `null` otherwise; with an assumed loop it is an upper bound
+ * under that assumption (every pass is counted at its slowest branch).
+ *
+ * THREAT MODEL. The walk terminates on any graph: a chain is walked with a visited set (a `next` that closes on
+ * itself is a loop), nesting is an explicit stack (no recursion — a 5 000-deep subflow nesting walks), a chain that
+ * reaches itself through its children or a subflow is a loop, and every chain is computed once per start however
+ * often it is mounted. The walk is CAPPED: past `MAX_WALK` node visits it stops with a `RangeError` — a builder chart
+ * visits each node at most twice, but a hand-built graph whose chains share their tails is walked once per chain.
+ * Sums and products saturate at `Number.MAX_SAFE_INTEGER` — never `Infinity` or `NaN`. Assumptions are copied ONCE,
+ * own enumerable properties only, into fresh null-prototype records, and only that copy is read.
+ *
+ * What it does NOT count: the engine's own work between stages, a stage function that blocks the thread (a timeout
+ * stops the WAITING, see the attempt runner), and a StageNode a stage returns at run time — any stage may grow the
+ * graph that way, so the budget is of the graph the chart DECLARES.
+ */
+import { joinPath } from 'foottrace';
+import { attemptCeiling, attemptTimeoutMs, backoffCeilingMs, cappedWaitMs } from '../attempt/policy.js';
+import { retryLoopBudget } from '../attempt/retryLoopContext.js';
+import { resolveBackoffMs } from '../attempt/runner.js';
+import { isDevMode } from '../devMode.js';
+import { buildBranchSegment } from '../ids/branchSegment.js';
+/**
+ * The most node visits one walk makes. A builder chart visits each node at most twice, so 250 000 is far past any
+ * real chart; a hand-built graph whose chains share their tails can need more (each chain walks the shared tail),
+ * and the check stops there with a `RangeError` rather than grow without bound.
+ */
+export const MAX_WALK = 250_000;
+// ─────────────────────────────────────────────────────────────────────────────
+// The entry points
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * The slowest the chart can take, computed from its declared retry policies — and every stage that makes a path
+ * unbounded, by name. See the module header for the rules.
+ *
+ * @example
+ * ```ts
+ * const report = timeBudget(chart, { budgetMs: 120_000, assume: { loops: { 'ask-again': 3 } } });
+ * report.worstCaseMs;  // number, or null when a path is unbounded
+ * report.criticalPath; // [{ stageId, attempts, timeoutMs, backoffMs, worstMs, passes }]
+ * report.unbounded;    // [{ stageId, why: 'no-timeout' | 'backoff' | 'loop' | 'lazy-subflow' | 'items' }]
+ * report.over;         // true when the declared policies allow longer than budgetMs
+ * ```
+ */
+export function timeBudget(chart, options) {
+    if (!isChart(chart)) {
+        throw new TypeError('timeBudget(chart): pass a built chart — the result of flowChart(...).build().');
+    }
+    if (options?.budgetMs !== undefined && !isPositiveMs(options.budgetMs)) {
+        throw new TypeError('timeBudget: budgetMs must be a number of milliseconds > 0, at most Number.MAX_SAFE_INTEGER ' +
+            `(got ${shown(options.budgetMs)}).`);
+    }
+    const budgetMs = options?.budgetMs ?? declaredBudget(chart);
+    const walk = new BudgetWalk(admitAssumptions(options?.assume));
+    const ctx = walk.ctxOf(chart, '');
+    const root = walk.evaluate({ ctx, start: chart.root });
+    // A loop whose target the chart does not hold cannot be bounded by any assumption.
+    const rootFlags = [...root.open].map((target) => ({ stageId: reported(ctx, target), why: 'loop' }));
+    const bounded = root.bounded && root.open.size === 0;
+    return Object.freeze({
+        worstCaseMs: bounded ? root.known : null,
+        knownMs: root.known,
+        criticalPath: Object.freeze(criticalPathOf(root, walk.computed)),
+        unbounded: Object.freeze(unboundedOf(root, rootFlags)),
+        ...(budgetMs !== undefined && { budgetMs }),
+        over: budgetMs !== undefined && root.known > budgetMs,
+    });
+}
+/** The chart's declared budget (`.budget(ms)`, the spec root's `budgetMs`), or `undefined`. */
+export function declaredBudget(chart) {
+    const budgetMs = chart.buildTimeStructure?.budgetMs;
+    return isPositiveMs(budgetMs) ? budgetMs : undefined;
+}
+/** `build()`'s refusal for a declared budget the chart can already exceed, or `undefined` when it can keep it. */
+export function budgetRefusal(report) {
+    if (!report.over || report.budgetMs === undefined)
+        return undefined;
+    const counted = report.criticalPath.filter((step) => contribution(step) > 0);
+    const shownSteps = slowestInPathOrder(counted, 5).map(stepText);
+    const more = counted.length > shownSteps.length ? `, and ${counted.length - shownSteps.length} more` : '';
+    const uncounted = report.unbounded.length > 0 ? ` Not counted, having no bound: ${unboundedText(report.unbounded)}.` : '';
+    return (`budget(${report.budgetMs}): its declared policies allow ${report.knownMs} ms, over its budget by ` +
+        `${report.knownMs - report.budgetMs} ms. Slowest path: ${shownSteps.join('; ')}${more}. Lower attempts or ` +
+        `timeoutMs on these stages, or raise the budget.${uncounted}`);
+}
+/** `build()`'s dev-mode warning for a declared budget it cannot check on every path, or `undefined`. */
+export function budgetWarning(report, chartName) {
+    if (report.budgetMs === undefined || report.unbounded.length === 0)
+        return undefined;
+    return (`[footprint] chart '${chartName}' declares a budget of ${report.budgetMs} ms, but the check cannot bound ` +
+        `every path: ${unboundedText(report.unbounded)}. Give a stage a retry({ timeoutMs }) and a function backoff a ` +
+        'maxBackoffMs; bound a loop, a lazy subflow or a parallelForEach with timeBudget(chart, { assume }).');
+}
+/** Charts already warned at run start — the warning is said once per chart. */
+const warnedAtRunStart = new WeakSet();
+/**
+ * The run-start warning (dev mode, once per chart): the run's deadline leaves the chart less time than its declared
+ * budget, so a run that takes the time the chart declares will be cut short. `startedAt` is read BEFORE the run's
+ * deadline is armed, so `timeoutMs` equal to the budget never warns.
+ */
+export function warnDeadlineUnderBudget(chart, deadline, startedAt) {
+    if (deadline === undefined || !isDevMode())
+        return;
+    const budgetMs = declaredBudget(chart);
+    if (budgetMs === undefined)
+        return;
+    const leftMs = deadline - startedAt;
+    if (leftMs >= budgetMs || warnedAtRunStart.has(chart))
+        return;
+    warnedAtRunStart.add(chart);
+    // eslint-disable-next-line no-console
+    console.warn(`[footprint] this run's deadline leaves ${Math.max(0, leftMs)} ms, less than the chart's declared budget of ` +
+        `${budgetMs} ms ('${chart.root.name}'): a run that takes the time the chart declares will be cut short. Give ` +
+        'the run its budget, or declare a smaller one.');
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// The walk
+// ─────────────────────────────────────────────────────────────────────────────
+const IN_PROGRESS = Symbol('in-progress');
+const NONE = { kind: 'none' };
+const EMPTY = new Set();
+class BudgetWalk {
+    assume;
+    /** Every chain, in the order computed: each one after every chain it runs inside itself. */
+    computed = [];
+    ctxs = new Map();
+    /** Node visits so far — capped at `MAX_WALK`. */
+    walked = 0;
+    constructor(assume) {
+        this.assume = assume;
+    }
+    /** The chain from `start` — every node visit counted against `MAX_WALK`. */
+    chainOf(start) {
+        const nodes = [];
+        const seen = new Set();
+        let cur = start;
+        while (isNode(cur)) {
+            if (cur.isLoopRef)
+                return { nodes, backId: String(cur.id) };
+            if (seen.has(cur))
+                return { nodes, backTo: cur };
+            if (++this.walked > MAX_WALK) {
+                throw new RangeError(`timeBudget: the walk passed ${MAX_WALK} node visits and stopped. A builder chart visits each node at ` +
+                    'most twice; a hand-built graph whose chains share their tails walks the shared tail once per chain. ' +
+                    'The budget of this graph cannot be computed.');
+            }
+            seen.add(cur);
+            nodes.push(cur);
+            cur = cur.next;
+        }
+        return { nodes };
+    }
+    ctxOf(owner, prefix) {
+        let byPrefix = this.ctxs.get(owner);
+        if (byPrefix === undefined) {
+            byPrefix = new Map();
+            this.ctxs.set(owner, byPrefix);
+        }
+        let ctx = byPrefix.get(prefix);
+        if (ctx === undefined) {
+            ctx = { subflows: owner.subflows, stageMap: owner.stageMap, prefix, memo: new Map() };
+            byPrefix.set(prefix, ctx);
+        }
+        return ctx;
+    }
+    /**
+     * Compute `root` and every chain it runs — an explicit stack, never recursion. A chain is marked in progress on
+     * its first visit and pushes the chains it needs; it is computed on its second, when they are done. A chain that
+     * needs one still in progress needs itself: an object cycle, counted as a loop.
+     */
+    evaluate(root) {
+        const stack = [root];
+        while (stack.length > 0) {
+            const ref = stack[stack.length - 1];
+            const state = ref.ctx.memo.get(ref.start);
+            if (state !== undefined && state !== IN_PROGRESS) {
+                stack.pop();
+                continue;
+            }
+            const nodes = this.chainOf(ref.start);
+            const insides = nodes.nodes.map((node) => this.insideOf(node, ref.ctx));
+            if (state === undefined) {
+                ref.ctx.memo.set(ref.start, IN_PROGRESS);
+                const before = stack.length;
+                for (const inside of insides) {
+                    if (inside.kind !== 'chains')
+                        continue;
+                    for (const dep of inside.refs)
+                        if (!dep.ctx.memo.has(dep.start))
+                            stack.push(dep);
+                }
+                if (stack.length > before)
+                    continue;
+            }
+            stack.pop();
+            const chain = this.chainResult(ref.ctx, nodes, insides);
+            ref.ctx.memo.set(ref.start, chain);
+            this.computed.push(chain);
+        }
+        return root.ctx.memo.get(root.start);
+    }
+    insideOf(node, ctx) {
+        if (node.isDynamicParallel) {
+            const stageId = reported(ctx, node.id);
+            const chart = own(this.assume.branches, stageId);
+            if (chart === undefined)
+                return { kind: 'unbounded', why: 'items', stageId };
+            const branch = buildBranchSegment(stageId, 0);
+            return { kind: 'chains', refs: [{ ctx: this.ctxOf(chart, branch), start: chart.root }], boundary: true };
+        }
+        if (isMount(node))
+            return this.mountOf(node, ctx);
+        const children = childrenOf(node);
+        if (children.length > 0)
+            return { kind: 'chains', refs: children.map((start) => ({ ctx, start })), boundary: false };
+        return NONE;
+    }
+    /** A subflow mount — resolved the way the engine resolves it (`NodeResolver · resolveSubflowReference`). */
+    mountOf(node, ctx) {
+        const subflowId = reported(ctx, String(node.subflowId));
+        if (node.subflowResolver !== undefined) {
+            const chart = own(this.assume.lazy, subflowId);
+            if (chart === undefined)
+                return { kind: 'unbounded', why: 'lazy-subflow', stageId: subflowId };
+            return { kind: 'chains', refs: [{ ctx: this.ctxOf(chart, subflowId), start: chart.root }], boundary: true };
+        }
+        const inline = node.subflowDef;
+        if (inline?.root !== undefined) {
+            return {
+                kind: 'chains',
+                refs: [{ ctx: this.ctxOf(inline, ctx.prefix), start: inline.root }],
+                boundary: true,
+            };
+        }
+        const def = subflowDefOf(ctx.subflows, node);
+        return def === undefined ? NONE : { kind: 'chains', refs: [{ ctx, start: def.root }], boundary: true };
+    }
+    chainResult(ctx, shape, insides) {
+        const { nodes } = shape;
+        const at = new Map();
+        nodes.forEach((node, i) => {
+            if (!at.has(node.id))
+                at.set(node.id, i);
+        });
+        const backEdges = [];
+        const open = new Set();
+        // A jump to a target this chain holds at or before `from` is a loop over [target, from]; a forward jump repeats
+        // nothing; a target the chain does not hold is the enclosing chain's to resolve.
+        const jump = (target, from) => {
+            const j = at.get(target);
+            if (j === undefined)
+                open.add(target);
+            else if (j <= from)
+                backEdges.push([j, from]);
+        };
+        let bounded = true;
+        const positions = nodes.map((node, q) => {
+            const stageId = reported(ctx, node.id);
+            const flags = [];
+            // A mount runs its subflow in place of a function of its own (the engine never asks its stage map).
+            const cost = !isMount(node) && hasFunction(node, ctx) ? helperCost(retryLoopBudget(node), node.retry) : undefined;
+            if (cost?.why !== undefined)
+                flags.push({ stageId, why: cost.why });
+            const inner = this.innerOf(insides[q], flags);
+            for (const target of inner.open)
+                jump(target, q);
+            if (cost?.worstMs === null || !inner.bounded)
+                bounded = false;
+            return {
+                stageId,
+                cost,
+                innerKnown: inner.known,
+                via: inner.via,
+                deps: inner.deps,
+                flags,
+                multiplier: 1,
+                declaredPasses: retryLoopBudget(node)?.passes,
+            };
+        });
+        if (shape.backTo !== undefined)
+            backEdges.push([nodes.indexOf(shape.backTo), nodes.length - 1]);
+        if (shape.backId !== undefined)
+            jump(shape.backId, nodes.length - 1);
+        if (!this.applyLoops(positions, backEdges))
+            bounded = false;
+        let known = 0;
+        for (const p of positions)
+            known = add(known, mul(p.multiplier, add(p.cost?.knownMs ?? 0, p.innerKnown)));
+        return { known, bounded, open, positions };
+    }
+    /** The slowest of the chains a node runs inside itself (they are alternatives, or run at once). */
+    innerOf(inside, flags) {
+        if (inside.kind === 'none')
+            return { known: 0, bounded: true, deps: [], open: EMPTY };
+        if (inside.kind === 'unbounded') {
+            flags.push({ stageId: inside.stageId, why: inside.why });
+            return { known: 0, bounded: false, deps: [], open: EMPTY };
+        }
+        let via;
+        let bounded = true;
+        const deps = [];
+        const open = new Set();
+        for (const ref of inside.refs) {
+            const chain = ref.ctx.memo.get(ref.start);
+            if (chain === undefined || chain === IN_PROGRESS) {
+                flags.push({ stageId: reported(ref.ctx, ref.start.id), why: 'loop' });
+                bounded = false;
+                continue;
+            }
+            deps.push(chain);
+            if (!chain.bounded)
+                bounded = false;
+            for (const target of chain.open) {
+                if (!inside.boundary) {
+                    open.add(target);
+                    continue;
+                }
+                // A subflow's own traverser looks its loop targets up in its own chart: one it does not hold never resolves.
+                flags.push({ stageId: reported(ref.ctx, target), why: 'loop' });
+                bounded = false;
+            }
+            if (via === undefined || chain.known > via.known)
+                via = chain;
+        }
+        return { known: via?.known ?? 0, bounded, ...(via !== undefined && { via }), deps, open };
+    }
+    /**
+     * Turn a chain's back-edges into each position's multiplier. One loop per target, spanning to its furthest
+     * source. Loops are taken in start order on a stack of nested ones; a loop that overlaps the one it starts inside
+     * without nesting merges with it (the product of their passes — each can re-enter the other), so what is left is
+     * laminar, and one sweep multiplies every position by the loops around it. Returns false when a loop has no
+     * assumed passes (it is flagged on its target and counted once).
+     */
+    applyLoops(positions, backEdges) {
+        if (backEdges.length === 0)
+            return true;
+        const ends = new Map();
+        for (const [target, source] of backEdges)
+            ends.set(target, Math.max(ends.get(target) ?? target, source));
+        let bounded = true;
+        const done = [];
+        const active = [];
+        for (const [start, end] of [...ends].sort((a, b) => a[0] - b[0])) {
+            const target = positions[start];
+            const assumed = own(this.assume.loops, target.stageId);
+            const passes = target.declaredPasses === undefined ? assumed : Math.max(target.declaredPasses, assumed ?? 1);
+            if (passes === undefined) {
+                target.flags.push({ stageId: target.stageId, why: 'loop' });
+                bounded = false;
+            }
+            // The active loops nest (each inside the one below it): the innermost ends first.
+            let top = lastOf(active);
+            while (top !== undefined && top.end < start) {
+                done.push(top);
+                active.pop();
+                top = lastOf(active);
+            }
+            // Starts inside `top` and ends past it: they overlap without nesting — one region, the product of passes.
+            let loop = { start, end, passes: passes ?? 1 };
+            while (top !== undefined && top.end < loop.end) {
+                active.pop();
+                loop = { start: top.start, end: loop.end, passes: mul(top.passes, loop.passes) };
+                top = lastOf(active);
+            }
+            active.push(loop);
+        }
+        done.push(...active);
+        done.sort((a, b) => a.start - b.start || b.end - a.end);
+        const around = [];
+        let next = 0;
+        for (let q = 0; q < positions.length; q++) {
+            while (around.length > 0 && around[around.length - 1].end < q)
+                around.pop();
+            while (next < done.length && done[next].start === q) {
+                const outer = around.length > 0 ? around[around.length - 1].product : 1;
+                around.push({ end: done[next].end, product: mul(outer, done[next].passes) });
+                next++;
+            }
+            positions[q].multiplier = around.length > 0 ? around[around.length - 1].product : 1;
+        }
+        return bounded;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// One stage
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * The engine's mount test (`FlowchartTraverser` Phase 0 with `NodeResolver · resolveSubflowReference`): a subflow
+ * root with a subflow id runs its subflow — a lazy one always, an eager one when it has no function of its OWN and no
+ * children (the resolver never asks the stage map). Anything else is a node like any other.
+ */
+function isMount(node) {
+    if (node.isSubflowRoot !== true || typeof node.subflowId !== 'string' || node.subflowId === '')
+        return false;
+    return node.subflowResolver !== undefined || (typeof node.fn !== 'function' && childrenOf(node).length === 0);
+}
+/** A node's children that are nodes — a hand-built `null` is skipped, never dereferenced. */
+function childrenOf(node) {
+    return Array.isArray(node.children) ? node.children.filter(isNode) : [];
+}
+const isNode = (value) => value !== null && typeof value === 'object';
+/** The engine's lookup (`FlowchartTraverser · getStageFn`): the node's own function, else the map's by id or name. */
+function hasFunction(node, ctx) {
+    if (typeof node.fn === 'function')
+        return true;
+    const map = ctx.stageMap;
+    return map !== undefined && (map.get(node.id) !== undefined || map.get(node.name) !== undefined);
+}
+/** A stage's worst case under its policy — read by the engine's own readings of it (`attempt/policy.ts`). */
+function helperCost(budget, policy) {
+    if (budget === undefined)
+        return stageCost(policy);
+    if (budget.role === 'callback')
+        return stageCost({ attempts: 1, timeoutMs: budget.timeoutMs });
+    const ms = budget.role === 'control' ? 0 : budget.waitMs;
+    return {
+        attempts: 1,
+        timeoutMs: ms ?? 0,
+        backoffMs: 0,
+        knownMs: ms ?? 0,
+        worstMs: ms ?? null,
+        ...(ms === undefined ? { why: 'backoff' } : {}),
+    };
+}
+function stageCost(policy) {
+    const attempts = policy === undefined ? 1 : attemptCeiling(policy.attempts);
+    const timeoutMs = policy === undefined ? undefined : attemptTimeoutMs(policy.timeoutMs);
+    const waits = waitsOf(policy, attempts);
+    const knownMs = add(timeoutMs === undefined ? 0 : mul(attempts, timeoutMs), waits.ms);
+    const why = timeoutMs === undefined ? 'no-timeout' : waits.known ? undefined : 'backoff';
+    return {
+        attempts,
+        ...(timeoutMs !== undefined && { timeoutMs }),
+        backoffMs: waits.ms,
+        knownMs,
+        worstMs: why === undefined ? knownMs : null,
+        ...(why !== undefined && { why }),
+    };
+}
+/**
+ * The waits between `attempts` attempts, as the runner waits them (`attempt/policy.ts · cappedWaitMs`). A number
+ * backoff is arithmetic, under the declared ceiling. A function backoff is NEVER asked — its answer may depend on the
+ * error, and no error exists here — so it counts at its declared ceiling per wait, or, with none, is not known
+ * (its waits count 0 and the stage is unbounded).
+ */
+function waitsOf(policy, attempts) {
+    const waits = attempts - 1;
+    const backoffMs = policy?.backoffMs;
+    if (waits <= 0 || backoffMs === undefined)
+        return { ms: 0, known: true };
+    if (typeof backoffMs === 'function') {
+        const ceiling = backoffCeilingMs(policy?.maxBackoffMs);
+        return ceiling === undefined ? { ms: 0, known: false } : { ms: mul(waits, ceiling), known: true };
+    }
+    return { ms: mul(waits, cappedWaitMs(resolveBackoffMs(backoffMs, 1), policy?.maxBackoffMs)), known: true };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// The report
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * The slowest path: how many times each chain on it runs (parents before children — the reverse of the order they
+ * were computed in), then its stages in the order a run first reaches them. Each chain is visited once, so a
+ * definition mounted twice at every level of a deep nesting is one step with its passes multiplied.
+ */
+function criticalPathOf(root, computed) {
+    const runs = new Map([[root, 1]]);
+    for (let i = computed.length - 1; i >= 0; i--) {
+        const chain = computed[i];
+        const count = runs.get(chain);
+        if (count === undefined)
+            continue;
+        for (const p of chain.positions) {
+            if (p.via !== undefined)
+                runs.set(p.via, add(runs.get(p.via) ?? 0, mul(count, p.multiplier)));
+        }
+    }
+    const steps = new Map();
+    walkPositions(root, (p) => p.via, (chain, p) => {
+        if (p.cost === undefined)
+            return;
+        const passes = mul(runs.get(chain) ?? 0, p.multiplier);
+        const step = steps.get(p.stageId);
+        if (step !== undefined) {
+            step.passes = add(step.passes, passes);
+            return;
+        }
+        steps.set(p.stageId, {
+            stageId: p.stageId,
+            attempts: p.cost.attempts,
+            ...(p.cost.timeoutMs !== undefined && { timeoutMs: p.cost.timeoutMs }),
+            backoffMs: p.cost.backoffMs,
+            worstMs: p.cost.worstMs,
+            passes,
+        });
+    });
+    return [...steps.values()].map((step) => Object.freeze(step));
+}
+/** Every unbounded stage, once, in the order a walk of the whole chart reaches it. */
+function unboundedOf(root, rootFlags) {
+    const out = [];
+    const seen = new Set();
+    const note = (flag) => {
+        const key = `${flag.why}\u0000${flag.stageId}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push(Object.freeze({ stageId: flag.stageId, why: flag.why }));
+    };
+    walkPositions(root, (p) => p.deps, (_chain, p) => p.flags.forEach(note));
+    rootFlags.forEach(note);
+    return out;
+}
+/** A preorder walk of positions, descending into each chain `next` names the first time it is reached. */
+function walkPositions(root, next, visit) {
+    const visited = new Set([root]);
+    const stack = [{ chain: root, q: 0 }];
+    while (stack.length > 0) {
+        const top = stack[stack.length - 1];
+        if (top.q >= top.chain.positions.length) {
+            stack.pop();
+            continue;
+        }
+        const p = top.chain.positions[top.q++];
+        visit(top.chain, p);
+        const inner = next(p);
+        const chains = inner === undefined ? [] : Array.isArray(inner) ? inner : [inner];
+        for (let i = chains.length - 1; i >= 0; i--) {
+            if (visited.has(chains[i]))
+                continue;
+            visited.add(chains[i]);
+            stack.push({ chain: chains[i], q: 0 });
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Words
+// ─────────────────────────────────────────────────────────────────────────────
+const contribution = (s) => mul(s.passes, add(mul(s.attempts, s.timeoutMs ?? 0), s.backoffMs));
+/** The `limit` largest contributors, kept in path order. */
+function slowestInPathOrder(steps, limit) {
+    const keep = new Set([...steps]
+        .sort((a, b) => contribution(b) - contribution(a))
+        .slice(0, limit)
+        .map((s) => s.stageId));
+    return steps.filter((s) => keep.has(s.stageId));
+}
+function stepText(s) {
+    const own = s.timeoutMs === undefined
+        ? `${s.backoffMs} ms of waits (no timeoutMs)`
+        : `${s.attempts} × ${s.timeoutMs} ms + ${s.backoffMs} ms of waits = ${add(mul(s.attempts, s.timeoutMs), s.backoffMs)} ms`;
+    return `${s.stageId}: ${own}${s.passes > 1 ? `, ${s.passes} passes` : ''}`;
+}
+function unboundedText(stages) {
+    const listed = stages.slice(0, 10).map((s) => `${s.stageId} (${s.why})`);
+    return stages.length > listed.length
+        ? `${listed.join(', ')}, and ${stages.length - listed.length} more`
+        : listed.join(', ');
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Small laws
+// ─────────────────────────────────────────────────────────────────────────────
+/** Saturating arithmetic on non-negative milliseconds: never past `Number.MAX_SAFE_INTEGER`, never `NaN`. */
+const CEILING = Number.MAX_SAFE_INTEGER;
+const add = (a, b) => Math.min(a + b, CEILING);
+const mul = (a, b) => (a === 0 || b === 0 ? 0 : Math.min(a * b, CEILING));
+const lastOf = (items) => items[items.length - 1];
+/** A budget: a number of milliseconds > 0 and no more than the saturated sums can be compared against. */
+const isPositiveMs = (value) => typeof value === 'number' && value > 0 && value <= Number.MAX_SAFE_INTEGER;
+const shown = (value) => (typeof value === 'number' ? String(value) : typeof value);
+/** An id as the run names it: under the prefix of the chart it lives in (a lazy or branch chart's mount path). */
+const reported = (ctx, id) => (ctx.prefix === '' ? id : joinPath(ctx.prefix, id));
+function isChart(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const root = value.root;
+    return root !== null && typeof root === 'object';
+}
+/** An own property only — a prototype member is never an assumption or a subflow. */
+function own(record, key) {
+    return record !== undefined && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
+/** The engine's subflow lookup: by subflow id, then subflow name, then node name. */
+function subflowDefOf(subflows, node) {
+    for (const key of [node.subflowId, node.subflowName, node.name]) {
+        if (key === undefined || key === '')
+            continue;
+        const def = own(subflows, key);
+        if (def !== undefined && def !== null && typeof def.root === 'object' && def.root !== null)
+            return def;
+    }
+    return undefined;
+}
+/**
+ * Validate the assumptions and COPY them: each own enumerable key is read exactly once, into a fresh null-prototype
+ * record. A getter that changes between reads, a Proxy, or a non-enumerable key can therefore never hand the walk
+ * a value that was not validated, and no prototype member is ever an assumption.
+ */
+function admitAssumptions(assume) {
+    if (assume !== undefined && (assume === null || typeof assume !== 'object')) {
+        throw new TypeError('timeBudget: assume must be an object ({ loops?, lazy?, branches? }).');
+    }
+    const given = (assume ?? {});
+    return {
+        loops: snapshot(given.loops, 'loops', (key, passes) => {
+            if (typeof passes === 'number' && Number.isInteger(passes) && passes >= 1)
+                return passes;
+            throw new TypeError(`timeBudget: assume.loops['${key}'] must be a whole number of passes >= 1 (got ${shown(passes)}).`);
+        }),
+        lazy: snapshot(given.lazy, 'lazy', (key, chart) => assumedChart('lazy', key, chart)),
+        branches: snapshot(given.branches, 'branches', (key, chart) => assumedChart('branches', key, chart)),
+    };
+}
+function snapshot(record, field, admit) {
+    const copy = Object.create(null);
+    if (record === undefined)
+        return copy;
+    if (record === null || typeof record !== 'object') {
+        throw new TypeError(`timeBudget: assume.${field} must be an object keyed by id.`);
+    }
+    for (const key of Object.keys(record))
+        copy[key] = admit(key, record[key]);
+    return Object.freeze(copy);
+}
+function assumedChart(field, key, chart) {
+    const root = isChart(chart) ? chart.root : undefined;
+    if (!isNode(root)) {
+        throw new TypeError(`timeBudget: assume.${field}['${key}'] must be a built chart (flowChart(...).build()).`);
+    }
+    const { subflows, stageMap } = chart;
+    return Object.freeze({
+        root,
+        ...(subflows !== undefined && { subflows: subflows }),
+        ...(stageMap instanceof Map && { stageMap }),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timeBudget.js","sourceRoot":"","sources":["../../../../src/lib/budget/timeBudget.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * budget/timeBudget.ts — `timeBudget(chart)`: the slowest a chart can take, from what it declares (design\n * docs/design/2026-10-time-and-failure-evidence.md §3.2, packet P5).\n *\n * WHY: a retry policy is a promise about time. `{ attempts: 4, timeoutMs: 40_000, backoffMs: 1_000 }` allows\n * 4 × 40 000 + 3 × 1 000 = 163 000 ms, and a caller who gave the chart 120 s is not served by it — which is\n * knowable before a single stage runs. `.budget(ms)` declares the caller's contract on the chart; `build()` refuses\n * a chart whose declared policies already allow longer (owner ruling Q2) and warns, by name, about every stage it\n * cannot bound. An unbounded stage is never guessed around: it is counted as 0 and named.\n *\n * THE RULES (one walk of the built StageNode graph; each chain of `next` pointers is computed once per start):\n *   - a stage with a function: `attempts × timeoutMs` plus the waits between its attempts, as the runner waits them\n *     (`attempt/policy.ts`). A number `backoffMs` is arithmetic, under `maxBackoffMs` when declared. A FUNCTION is\n *     never asked: it may read the error (a stated `Retry-After`) and no error exists here, so asking it with none\n *     could UNDERESTIMATE. It counts at its declared ceiling, `maxBackoffMs` per wait (the runner enforces it); with\n *     no ceiling the stage is unbounded `'backoff'`. No `timeoutMs` → unbounded `'no-timeout'`;\n *   - a sequence: the sum. A decider, a selector, a fork: the node's own stage plus its slowest child (a fork's\n *     children, and a selector's picks, run at once);\n *   - a mounted subflow: its chart, walked the same way, under the ids the run gives its stages (`pay/charge`);\n *     a lazy one is unbounded `'lazy-subflow'` unless `assume.lazy[subflowId]` names the chart it resolves to;\n *   - `parallelForEach`: ONE branch — the branches run at once and `maxBranches` truncates, so the item count never\n *     adds time. The branch chart is built at run time, so it is unbounded `'items'` unless\n *     `assume.branches[stageId]` names it (its stages are reported under the first branch, `review~0/score`);\n *   - a loop is NEVER iterated. With no assumption it is unbounded `'loop'`, named by its target, and counted once.\n *     `assume.loops[targetId] = n` bounds it: each time the chart reaches the loop, every stage from the target to\n *     the loop's furthest source runs at most `n` times, each at its slowest. Nested loops multiply; two loops that\n *     overlap without nesting are one region bounded by the product of their passes (each can re-enter the other).\n *\n * TWO NUMBERS. `knownMs` counts what is bounded (an unbounded stage as 0, an unassumed loop once). Without\n * assumptions it is a time the declared policies ALLOW a run to take (`retryOn` is not read: it may only end a series\n * sooner), so a budget below it cannot be promised — `over` and the build refusal read it, on an unbounded path too.\n * `worstCaseMs` is `knownMs` when every path is bounded, `null` otherwise; with an assumed loop it is an upper bound\n * under that assumption (every pass is counted at its slowest branch).\n *\n * THREAT MODEL. The walk terminates on any graph: a chain is walked with a visited set (a `next` that closes on\n * itself is a loop), nesting is an explicit stack (no recursion — a 5 000-deep subflow nesting walks), a chain that\n * reaches itself through its children or a subflow is a loop, and every chain is computed once per start however\n * often it is mounted. The walk is CAPPED: past `MAX_WALK` node visits it stops with a `RangeError` — a builder chart\n * visits each node at most twice, but a hand-built graph whose chains share their tails is walked once per chain.\n * Sums and products saturate at `Number.MAX_SAFE_INTEGER` — never `Infinity` or `NaN`. Assumptions are copied ONCE,\n * own enumerable properties only, into fresh null-prototype records, and only that copy is read.\n *\n * What it does NOT count: the engine's own work between stages, a stage function that blocks the thread (a timeout\n * stops the WAITING, see the attempt runner), and a StageNode a stage returns at run time — any stage may grow the\n * graph that way, so the budget is of the graph the chart DECLARES.\n */\n\nimport { joinPath } from 'foottrace';\n\nimport { attemptCeiling, attemptTimeoutMs, backoffCeilingMs, cappedWaitMs } from '../attempt/policy.js';\nimport type { RetryLoopBudget } from '../attempt/retryLoopContext.js';\nimport { retryLoopBudget } from '../attempt/retryLoopContext.js';\nimport { resolveBackoffMs } from '../attempt/runner.js';\nimport type { RetryPolicy } from '../attempt/types.js';\nimport type { FlowChart } from '../builder/types.js';\nimport { isDevMode } from '../devMode.js';\nimport type { StageNode } from '../engine/graph/StageNode.js';\nimport { buildBranchSegment } from '../ids/branchSegment.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Public shapes\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Why a stage keeps a path unbounded: no per-attempt cap (`'no-timeout'`); a function backoff with no declared\n * `maxBackoffMs` (`'backoff'` — its waits may depend on an error that does not exist at build); a loop with no\n * assumed passes (`'loop'`, named by its target); a lazy subflow whose chart is unknown at build (`'lazy-subflow'`);\n * a `parallelForEach` whose branch chart is built at run time (`'items'`).\n */\nexport type UnboundedReason = 'no-timeout' | 'backoff' | 'loop' | 'lazy-subflow' | 'items';\n\n/** A stage on the slowest path, with what it declares and how many times the path runs it. */\nexport interface BudgetStep {\n  /** The stage id as the run names it — a subflow's stages under their mount (`pay/charge`). */\n  readonly stageId: string;\n  /** How many attempts its policy allows (1 without one). */\n  readonly attempts: number;\n  /** The cap on one attempt; absent when the stage declares none (then `worstMs` is `null`). */\n  readonly timeoutMs?: number;\n  /** The waits between its attempts, in total. */\n  readonly backoffMs: number;\n  /** `attempts × timeoutMs + backoffMs` — `null` when the stage is unbounded. */\n  readonly worstMs: number | null;\n  /** How many times the path runs it — more than 1 only inside an assumed loop. */\n  readonly passes: number;\n}\n\n/** A stage the check cannot bound, and why. */\nexport interface UnboundedStage {\n  readonly stageId: string;\n  readonly why: UnboundedReason;\n}\n\n/** What the caller knows that the chart does not declare. Keys are ids as the run names them. */\nexport interface BudgetAssumptions {\n  /** A loop's TARGET id (what `loopTo` names) → the most passes through it each time the chart reaches it (≥ 1). */\n  readonly loops?: Readonly<Record<string, number>>;\n  /** A lazy mount's subflow id → the chart it resolves to. */\n  readonly lazy?: Readonly<Record<string, FlowChart>>;\n  /** A `parallelForEach` stage id → the chart one branch runs. */\n  readonly branches?: Readonly<Record<string, FlowChart>>;\n}\n\nexport interface TimeBudgetOptions {\n  /** The budget to check against. Defaults to the chart's declared `.budget(ms)`. A finite number > 0. */\n  readonly budgetMs?: number;\n  readonly assume?: BudgetAssumptions;\n}\n\n/** What `timeBudget(chart)` reports. JSON-safe and frozen. */\nexport interface TimeBudgetReport {\n  /** The worst case of the slowest path — `null` when any path is unbounded (see `unbounded`). */\n  readonly worstCaseMs: number | null;\n  /** The worst case of what IS bounded: an unbounded stage counts 0, an unassumed loop one pass. */\n  readonly knownMs: number;\n  /** The stages of the slowest path, in the order a run first reaches them — the path that makes `worstCaseMs`,\n   *  or `knownMs` when a path is unbounded. `knownMs = Σ passes × (attempts × (timeoutMs ?? 0) + backoffMs)`. */\n  readonly criticalPath: readonly BudgetStep[];\n  /** Every stage that keeps a path unbounded, each named once, in chart order. */\n  readonly unbounded: readonly UnboundedStage[];\n  /** The budget checked against — absent when there is none. */\n  readonly budgetMs?: number;\n  /** `knownMs > budgetMs`: the declared policies allow longer than the budget. Always `false` without one. */\n  readonly over: boolean;\n}\n\n/**\n * The most node visits one walk makes. A builder chart visits each node at most twice, so 250 000 is far past any\n * real chart; a hand-built graph whose chains share their tails can need more (each chain walks the shared tail),\n * and the check stops there with a `RangeError` rather than grow without bound.\n */\nexport const MAX_WALK = 250_000;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// The entry points\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * The slowest the chart can take, computed from its declared retry policies — and every stage that makes a path\n * unbounded, by name. See the module header for the rules.\n *\n * @example\n * ```ts\n * const report = timeBudget(chart, { budgetMs: 120_000, assume: { loops: { 'ask-again': 3 } } });\n * report.worstCaseMs;  // number, or null when a path is unbounded\n * report.criticalPath; // [{ stageId, attempts, timeoutMs, backoffMs, worstMs, passes }]\n * report.unbounded;    // [{ stageId, why: 'no-timeout' | 'backoff' | 'loop' | 'lazy-subflow' | 'items' }]\n * report.over;         // true when the declared policies allow longer than budgetMs\n * ```\n */\nexport function timeBudget(chart: FlowChart, options?: TimeBudgetOptions): TimeBudgetReport {\n  if (!isChart(chart)) {\n    throw new TypeError('timeBudget(chart): pass a built chart — the result of flowChart(...).build().');\n  }\n  if (options?.budgetMs !== undefined && !isPositiveMs(options.budgetMs)) {\n    throw new TypeError(\n      'timeBudget: budgetMs must be a number of milliseconds > 0, at most Number.MAX_SAFE_INTEGER ' +\n        `(got ${shown(options.budgetMs)}).`,\n    );\n  }\n  const budgetMs = options?.budgetMs ?? declaredBudget(chart);\n  const walk = new BudgetWalk(admitAssumptions(options?.assume));\n  const ctx = walk.ctxOf(chart, '');\n  const root = walk.evaluate({ ctx, start: chart.root });\n\n  // A loop whose target the chart does not hold cannot be bounded by any assumption.\n  const rootFlags = [...root.open].map((target) => ({ stageId: reported(ctx, target), why: 'loop' as const }));\n  const bounded = root.bounded && root.open.size === 0;\n  return Object.freeze({\n    worstCaseMs: bounded ? root.known : null,\n    knownMs: root.known,\n    criticalPath: Object.freeze(criticalPathOf(root, walk.computed)),\n    unbounded: Object.freeze(unboundedOf(root, rootFlags)),\n    ...(budgetMs !== undefined && { budgetMs }),\n    over: budgetMs !== undefined && root.known > budgetMs,\n  });\n}\n\n/** The chart's declared budget (`.budget(ms)`, the spec root's `budgetMs`), or `undefined`. */\nexport function declaredBudget(chart: FlowChart): number | undefined {\n  const budgetMs = chart.buildTimeStructure?.budgetMs;\n  return isPositiveMs(budgetMs) ? budgetMs : undefined;\n}\n\n/** `build()`'s refusal for a declared budget the chart can already exceed, or `undefined` when it can keep it. */\nexport function budgetRefusal(report: TimeBudgetReport): string | undefined {\n  if (!report.over || report.budgetMs === undefined) return undefined;\n  const counted = report.criticalPath.filter((step) => contribution(step) > 0);\n  const shownSteps = slowestInPathOrder(counted, 5).map(stepText);\n  const more = counted.length > shownSteps.length ? `, and ${counted.length - shownSteps.length} more` : '';\n  const uncounted =\n    report.unbounded.length > 0 ? ` Not counted, having no bound: ${unboundedText(report.unbounded)}.` : '';\n  return (\n    `budget(${report.budgetMs}): its declared policies allow ${report.knownMs} ms, over its budget by ` +\n    `${report.knownMs - report.budgetMs} ms. Slowest path: ${shownSteps.join('; ')}${more}. Lower attempts or ` +\n    `timeoutMs on these stages, or raise the budget.${uncounted}`\n  );\n}\n\n/** `build()`'s dev-mode warning for a declared budget it cannot check on every path, or `undefined`. */\nexport function budgetWarning(report: TimeBudgetReport, chartName: string): string | undefined {\n  if (report.budgetMs === undefined || report.unbounded.length === 0) return undefined;\n  return (\n    `[footprint] chart '${chartName}' declares a budget of ${report.budgetMs} ms, but the check cannot bound ` +\n    `every path: ${unboundedText(report.unbounded)}. Give a stage a retry({ timeoutMs }) and a function backoff a ` +\n    'maxBackoffMs; bound a loop, a lazy subflow or a parallelForEach with timeBudget(chart, { assume }).'\n  );\n}\n\n/** Charts already warned at run start — the warning is said once per chart. */\nconst warnedAtRunStart = new WeakSet<object>();\n\n/**\n * The run-start warning (dev mode, once per chart): the run's deadline leaves the chart less time than its declared\n * budget, so a run that takes the time the chart declares will be cut short. `startedAt` is read BEFORE the run's\n * deadline is armed, so `timeoutMs` equal to the budget never warns.\n */\nexport function warnDeadlineUnderBudget(chart: FlowChart, deadline: number | undefined, startedAt: number): void {\n  if (deadline === undefined || !isDevMode()) return;\n  const budgetMs = declaredBudget(chart);\n  if (budgetMs === undefined) return;\n  const leftMs = deadline - startedAt;\n  if (leftMs >= budgetMs || warnedAtRunStart.has(chart)) return;\n  warnedAtRunStart.add(chart);\n  // eslint-disable-next-line no-console\n  console.warn(\n    `[footprint] this run's deadline leaves ${Math.max(0, leftMs)} ms, less than the chart's declared budget of ` +\n      `${budgetMs} ms ('${chart.root.name}'): a run that takes the time the chart declares will be cut short. Give ` +\n      'the run its budget, or declare a smaller one.',\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// The walk\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst IN_PROGRESS = Symbol('in-progress');\n\n/** Where a chain's ids live: its chart's subflow dictionary and stage map, and the prefix the run gives them. */\ninterface Ctx {\n  readonly subflows: Readonly<Record<string, { root: StageNode }>> | undefined;\n  readonly stageMap: ReadonlyMap<string, unknown> | undefined;\n  readonly prefix: string;\n  readonly memo: Map<StageNode, Chain | typeof IN_PROGRESS>;\n}\n\ninterface ChainRef {\n  readonly ctx: Ctx;\n  readonly start: StageNode;\n}\n\n/** What a node runs inside itself, besides its own function. */\ntype Inside =\n  | { readonly kind: 'none' }\n  | { readonly kind: 'unbounded'; readonly why: UnboundedReason; readonly stageId: string }\n  /** `boundary`: the chains are another chart (a subflow) — a loop cannot leave them. */\n  | { readonly kind: 'chains'; readonly refs: readonly ChainRef[]; readonly boundary: boolean };\n\ninterface StageCost {\n  readonly attempts: number;\n  readonly timeoutMs?: number;\n  readonly backoffMs: number;\n  readonly knownMs: number;\n  readonly worstMs: number | null;\n  readonly why?: UnboundedReason;\n}\n\n/** One node of a chain. `multiplier` is how many times the chain runs it per pass of the chain. */\ninterface Position {\n  readonly stageId: string;\n  readonly cost: StageCost | undefined;\n  readonly innerKnown: number;\n  /** The slowest chain it runs inside itself — the critical path goes through it. */\n  readonly via: Chain | undefined;\n  /** Every chain it runs inside itself, in order. */\n  readonly deps: readonly Chain[];\n  readonly flags: UnboundedStage[];\n  multiplier: number;\n  readonly declaredPasses?: number;\n}\n\n/** A computed chain: a run of `next` pointers, and what the nodes on it run inside themselves. */\ninterface Chain {\n  readonly known: number;\n  readonly bounded: boolean;\n  /** Loop targets (raw ids) this chain jumps back to and does not hold — the enclosing chain resolves them. */\n  readonly open: ReadonlySet<string>;\n  readonly positions: readonly Position[];\n}\n\ninterface Loop {\n  readonly start: number;\n  readonly end: number;\n  readonly passes: number;\n}\n\nconst NONE: Inside = { kind: 'none' };\nconst EMPTY: ReadonlySet<string> = new Set();\n\nclass BudgetWalk {\n  /** Every chain, in the order computed: each one after every chain it runs inside itself. */\n  readonly computed: Chain[] = [];\n  private readonly ctxs = new Map<object, Map<string, Ctx>>();\n\n  /** Node visits so far — capped at `MAX_WALK`. */\n  private walked = 0;\n\n  constructor(private readonly assume: AdmittedAssumptions) {}\n\n  /** The chain from `start` — every node visit counted against `MAX_WALK`. */\n  private chainOf(start: StageNode): ChainShape {\n    const nodes: StageNode[] = [];\n    const seen = new Set<StageNode>();\n    let cur: StageNode | undefined = start;\n    while (isNode(cur)) {\n      if (cur.isLoopRef) return { nodes, backId: String(cur.id) };\n      if (seen.has(cur)) return { nodes, backTo: cur };\n      if (++this.walked > MAX_WALK) {\n        throw new RangeError(\n          `timeBudget: the walk passed ${MAX_WALK} node visits and stopped. A builder chart visits each node at ` +\n            'most twice; a hand-built graph whose chains share their tails walks the shared tail once per chain. ' +\n            'The budget of this graph cannot be computed.',\n        );\n      }\n      seen.add(cur);\n      nodes.push(cur);\n      cur = cur.next;\n    }\n    return { nodes };\n  }\n\n  ctxOf(\n    owner: {\n      readonly subflows?: Record<string, { root: StageNode }>;\n      readonly stageMap?: ReadonlyMap<string, unknown>;\n    },\n    prefix: string,\n  ): Ctx {\n    let byPrefix = this.ctxs.get(owner);\n    if (byPrefix === undefined) {\n      byPrefix = new Map();\n      this.ctxs.set(owner, byPrefix);\n    }\n    let ctx = byPrefix.get(prefix);\n    if (ctx === undefined) {\n      ctx = { subflows: owner.subflows, stageMap: owner.stageMap, prefix, memo: new Map() };\n      byPrefix.set(prefix, ctx);\n    }\n    return ctx;\n  }\n\n  /**\n   * Compute `root` and every chain it runs — an explicit stack, never recursion. A chain is marked in progress on\n   * its first visit and pushes the chains it needs; it is computed on its second, when they are done. A chain that\n   * needs one still in progress needs itself: an object cycle, counted as a loop.\n   */\n  evaluate(root: ChainRef): Chain {\n    const stack: ChainRef[] = [root];\n    while (stack.length > 0) {\n      const ref = stack[stack.length - 1];\n      const state = ref.ctx.memo.get(ref.start);\n      if (state !== undefined && state !== IN_PROGRESS) {\n        stack.pop();\n        continue;\n      }\n      const nodes = this.chainOf(ref.start);\n      const insides = nodes.nodes.map((node) => this.insideOf(node, ref.ctx));\n      if (state === undefined) {\n        ref.ctx.memo.set(ref.start, IN_PROGRESS);\n        const before = stack.length;\n        for (const inside of insides) {\n          if (inside.kind !== 'chains') continue;\n          for (const dep of inside.refs) if (!dep.ctx.memo.has(dep.start)) stack.push(dep);\n        }\n        if (stack.length > before) continue;\n      }\n      stack.pop();\n      const chain = this.chainResult(ref.ctx, nodes, insides);\n      ref.ctx.memo.set(ref.start, chain);\n      this.computed.push(chain);\n    }\n    return root.ctx.memo.get(root.start) as Chain;\n  }\n\n  private insideOf(node: StageNode, ctx: Ctx): Inside {\n    if (node.isDynamicParallel) {\n      const stageId = reported(ctx, node.id);\n      const chart = own(this.assume.branches, stageId);\n      if (chart === undefined) return { kind: 'unbounded', why: 'items', stageId };\n      const branch = buildBranchSegment(stageId, 0);\n      return { kind: 'chains', refs: [{ ctx: this.ctxOf(chart, branch), start: chart.root }], boundary: true };\n    }\n    if (isMount(node)) return this.mountOf(node, ctx);\n    const children = childrenOf(node);\n    if (children.length > 0)\n      return { kind: 'chains', refs: children.map((start) => ({ ctx, start })), boundary: false };\n    return NONE;\n  }\n\n  /** A subflow mount — resolved the way the engine resolves it (`NodeResolver · resolveSubflowReference`). */\n  private mountOf(node: StageNode, ctx: Ctx): Inside {\n    const subflowId = reported(ctx, String(node.subflowId));\n    if (node.subflowResolver !== undefined) {\n      const chart = own(this.assume.lazy, subflowId);\n      if (chart === undefined) return { kind: 'unbounded', why: 'lazy-subflow', stageId: subflowId };\n      return { kind: 'chains', refs: [{ ctx: this.ctxOf(chart, subflowId), start: chart.root }], boundary: true };\n    }\n    const inline = node.subflowDef;\n    if (inline?.root !== undefined) {\n      return {\n        kind: 'chains',\n        refs: [{ ctx: this.ctxOf(inline as Parameters<BudgetWalk['ctxOf']>[0], ctx.prefix), start: inline.root }],\n        boundary: true,\n      };\n    }\n    const def = subflowDefOf(ctx.subflows, node);\n    return def === undefined ? NONE : { kind: 'chains', refs: [{ ctx, start: def.root }], boundary: true };\n  }\n\n  private chainResult(ctx: Ctx, shape: ChainShape, insides: readonly Inside[]): Chain {\n    const { nodes } = shape;\n    const at = new Map<string, number>();\n    nodes.forEach((node, i) => {\n      if (!at.has(node.id)) at.set(node.id, i);\n    });\n    const backEdges: Array<readonly [number, number]> = [];\n    const open = new Set<string>();\n    // A jump to a target this chain holds at or before `from` is a loop over [target, from]; a forward jump repeats\n    // nothing; a target the chain does not hold is the enclosing chain's to resolve.\n    const jump = (target: string, from: number) => {\n      const j = at.get(target);\n      if (j === undefined) open.add(target);\n      else if (j <= from) backEdges.push([j, from]);\n    };\n\n    let bounded = true;\n    const positions: Position[] = nodes.map((node, q) => {\n      const stageId = reported(ctx, node.id);\n      const flags: UnboundedStage[] = [];\n      // A mount runs its subflow in place of a function of its own (the engine never asks its stage map).\n      const cost = !isMount(node) && hasFunction(node, ctx) ? helperCost(retryLoopBudget(node), node.retry) : undefined;\n      if (cost?.why !== undefined) flags.push({ stageId, why: cost.why });\n      const inner = this.innerOf(insides[q], flags);\n      for (const target of inner.open) jump(target, q);\n      if (cost?.worstMs === null || !inner.bounded) bounded = false;\n      return {\n        stageId,\n        cost,\n        innerKnown: inner.known,\n        via: inner.via,\n        deps: inner.deps,\n        flags,\n        multiplier: 1,\n        declaredPasses: retryLoopBudget(node)?.passes,\n      };\n    });\n    if (shape.backTo !== undefined) backEdges.push([nodes.indexOf(shape.backTo), nodes.length - 1]);\n    if (shape.backId !== undefined) jump(shape.backId, nodes.length - 1);\n\n    if (!this.applyLoops(positions, backEdges)) bounded = false;\n    let known = 0;\n    for (const p of positions) known = add(known, mul(p.multiplier, add(p.cost?.knownMs ?? 0, p.innerKnown)));\n    return { known, bounded, open, positions };\n  }\n\n  /** The slowest of the chains a node runs inside itself (they are alternatives, or run at once). */\n  private innerOf(\n    inside: Inside,\n    flags: UnboundedStage[],\n  ): { known: number; bounded: boolean; via?: Chain; deps: Chain[]; open: ReadonlySet<string> } {\n    if (inside.kind === 'none') return { known: 0, bounded: true, deps: [], open: EMPTY };\n    if (inside.kind === 'unbounded') {\n      flags.push({ stageId: inside.stageId, why: inside.why });\n      return { known: 0, bounded: false, deps: [], open: EMPTY };\n    }\n    let via: Chain | undefined;\n    let bounded = true;\n    const deps: Chain[] = [];\n    const open = new Set<string>();\n    for (const ref of inside.refs) {\n      const chain = ref.ctx.memo.get(ref.start);\n      if (chain === undefined || chain === IN_PROGRESS) {\n        flags.push({ stageId: reported(ref.ctx, ref.start.id), why: 'loop' });\n        bounded = false;\n        continue;\n      }\n      deps.push(chain);\n      if (!chain.bounded) bounded = false;\n      for (const target of chain.open) {\n        if (!inside.boundary) {\n          open.add(target);\n          continue;\n        }\n        // A subflow's own traverser looks its loop targets up in its own chart: one it does not hold never resolves.\n        flags.push({ stageId: reported(ref.ctx, target), why: 'loop' });\n        bounded = false;\n      }\n      if (via === undefined || chain.known > via.known) via = chain;\n    }\n    return { known: via?.known ?? 0, bounded, ...(via !== undefined && { via }), deps, open };\n  }\n\n  /**\n   * Turn a chain's back-edges into each position's multiplier. One loop per target, spanning to its furthest\n   * source. Loops are taken in start order on a stack of nested ones; a loop that overlaps the one it starts inside\n   * without nesting merges with it (the product of their passes — each can re-enter the other), so what is left is\n   * laminar, and one sweep multiplies every position by the loops around it. Returns false when a loop has no\n   * assumed passes (it is flagged on its target and counted once).\n   */\n  private applyLoops(positions: Position[], backEdges: ReadonlyArray<readonly [number, number]>): boolean {\n    if (backEdges.length === 0) return true;\n    const ends = new Map<number, number>();\n    for (const [target, source] of backEdges) ends.set(target, Math.max(ends.get(target) ?? target, source));\n\n    let bounded = true;\n    const done: Loop[] = [];\n    const active: Loop[] = [];\n    for (const [start, end] of [...ends].sort((a, b) => a[0] - b[0])) {\n      const target = positions[start];\n      const assumed = own(this.assume.loops, target.stageId);\n      const passes = target.declaredPasses === undefined ? assumed : Math.max(target.declaredPasses, assumed ?? 1);\n      if (passes === undefined) {\n        target.flags.push({ stageId: target.stageId, why: 'loop' });\n        bounded = false;\n      }\n      // The active loops nest (each inside the one below it): the innermost ends first.\n      let top = lastOf(active);\n      while (top !== undefined && top.end < start) {\n        done.push(top);\n        active.pop();\n        top = lastOf(active);\n      }\n      // Starts inside `top` and ends past it: they overlap without nesting — one region, the product of passes.\n      let loop: Loop = { start, end, passes: passes ?? 1 };\n      while (top !== undefined && top.end < loop.end) {\n        active.pop();\n        loop = { start: top.start, end: loop.end, passes: mul(top.passes, loop.passes) };\n        top = lastOf(active);\n      }\n      active.push(loop);\n    }\n    done.push(...active);\n\n    done.sort((a, b) => a.start - b.start || b.end - a.end);\n    const around: Array<{ readonly end: number; readonly product: number }> = [];\n    let next = 0;\n    for (let q = 0; q < positions.length; q++) {\n      while (around.length > 0 && around[around.length - 1].end < q) around.pop();\n      while (next < done.length && done[next].start === q) {\n        const outer = around.length > 0 ? around[around.length - 1].product : 1;\n        around.push({ end: done[next].end, product: mul(outer, done[next].passes) });\n        next++;\n      }\n      positions[q].multiplier = around.length > 0 ? around[around.length - 1].product : 1;\n    }\n    return bounded;\n  }\n}\n\n/** A run of `next` pointers from `start`: its nodes, and where it jumps back to (a loop stub's id, or a cycle). */\ninterface ChainShape {\n  readonly nodes: readonly StageNode[];\n  readonly backId?: string;\n  readonly backTo?: StageNode;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// One stage\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * The engine's mount test (`FlowchartTraverser` Phase 0 with `NodeResolver · resolveSubflowReference`): a subflow\n * root with a subflow id runs its subflow — a lazy one always, an eager one when it has no function of its OWN and no\n * children (the resolver never asks the stage map). Anything else is a node like any other.\n */\nfunction isMount(node: StageNode): boolean {\n  if (node.isSubflowRoot !== true || typeof node.subflowId !== 'string' || node.subflowId === '') return false;\n  return node.subflowResolver !== undefined || (typeof node.fn !== 'function' && childrenOf(node).length === 0);\n}\n\n/** A node's children that are nodes — a hand-built `null` is skipped, never dereferenced. */\nfunction childrenOf(node: StageNode): StageNode[] {\n  return Array.isArray(node.children) ? node.children.filter(isNode) : [];\n}\n\nconst isNode = (value: unknown): value is StageNode => value !== null && typeof value === 'object';\n\n/** The engine's lookup (`FlowchartTraverser · getStageFn`): the node's own function, else the map's by id or name. */\nfunction hasFunction(node: StageNode, ctx: Ctx): boolean {\n  if (typeof node.fn === 'function') return true;\n  const map = ctx.stageMap;\n  return map !== undefined && (map.get(node.id) !== undefined || map.get(node.name) !== undefined);\n}\n\n/** A stage's worst case under its policy — read by the engine's own readings of it (`attempt/policy.ts`). */\nfunction helperCost(budget: RetryLoopBudget | undefined, policy: RetryPolicy | undefined): StageCost {\n  if (budget === undefined) return stageCost(policy);\n  if (budget.role === 'callback') return stageCost({ attempts: 1, timeoutMs: budget.timeoutMs });\n  const ms = budget.role === 'control' ? 0 : budget.waitMs;\n  return {\n    attempts: 1,\n    timeoutMs: ms ?? 0,\n    backoffMs: 0,\n    knownMs: ms ?? 0,\n    worstMs: ms ?? null,\n    ...(ms === undefined ? { why: 'backoff' as const } : {}),\n  };\n}\n\nfunction stageCost(policy: RetryPolicy | undefined): StageCost {\n  const attempts = policy === undefined ? 1 : attemptCeiling(policy.attempts);\n  const timeoutMs = policy === undefined ? undefined : attemptTimeoutMs(policy.timeoutMs);\n  const waits = waitsOf(policy, attempts);\n  const knownMs = add(timeoutMs === undefined ? 0 : mul(attempts, timeoutMs), waits.ms);\n  const why: UnboundedReason | undefined = timeoutMs === undefined ? 'no-timeout' : waits.known ? undefined : 'backoff';\n  return {\n    attempts,\n    ...(timeoutMs !== undefined && { timeoutMs }),\n    backoffMs: waits.ms,\n    knownMs,\n    worstMs: why === undefined ? knownMs : null,\n    ...(why !== undefined && { why }),\n  };\n}\n\n/**\n * The waits between `attempts` attempts, as the runner waits them (`attempt/policy.ts · cappedWaitMs`). A number\n * backoff is arithmetic, under the declared ceiling. A function backoff is NEVER asked — its answer may depend on the\n * error, and no error exists here — so it counts at its declared ceiling per wait, or, with none, is not known\n * (its waits count 0 and the stage is unbounded).\n */\nfunction waitsOf(policy: RetryPolicy | undefined, attempts: number): { ms: number; known: boolean } {\n  const waits = attempts - 1;\n  const backoffMs = policy?.backoffMs;\n  if (waits <= 0 || backoffMs === undefined) return { ms: 0, known: true };\n  if (typeof backoffMs === 'function') {\n    const ceiling = backoffCeilingMs(policy?.maxBackoffMs);\n    return ceiling === undefined ? { ms: 0, known: false } : { ms: mul(waits, ceiling), known: true };\n  }\n  return { ms: mul(waits, cappedWaitMs(resolveBackoffMs(backoffMs, 1), policy?.maxBackoffMs)), known: true };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// The report\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * The slowest path: how many times each chain on it runs (parents before children — the reverse of the order they\n * were computed in), then its stages in the order a run first reaches them. Each chain is visited once, so a\n * definition mounted twice at every level of a deep nesting is one step with its passes multiplied.\n */\nfunction criticalPathOf(root: Chain, computed: readonly Chain[]): BudgetStep[] {\n  const runs = new Map<Chain, number>([[root, 1]]);\n  for (let i = computed.length - 1; i >= 0; i--) {\n    const chain = computed[i];\n    const count = runs.get(chain);\n    if (count === undefined) continue;\n    for (const p of chain.positions) {\n      if (p.via !== undefined) runs.set(p.via, add(runs.get(p.via) ?? 0, mul(count, p.multiplier)));\n    }\n  }\n\n  const steps = new Map<string, { -readonly [K in keyof BudgetStep]: BudgetStep[K] }>();\n  walkPositions(\n    root,\n    (p) => p.via,\n    (chain, p) => {\n      if (p.cost === undefined) return;\n      const passes = mul(runs.get(chain) ?? 0, p.multiplier);\n      const step = steps.get(p.stageId);\n      if (step !== undefined) {\n        step.passes = add(step.passes, passes);\n        return;\n      }\n      steps.set(p.stageId, {\n        stageId: p.stageId,\n        attempts: p.cost.attempts,\n        ...(p.cost.timeoutMs !== undefined && { timeoutMs: p.cost.timeoutMs }),\n        backoffMs: p.cost.backoffMs,\n        worstMs: p.cost.worstMs,\n        passes,\n      });\n    },\n  );\n  return [...steps.values()].map((step) => Object.freeze(step));\n}\n\n/** Every unbounded stage, once, in the order a walk of the whole chart reaches it. */\nfunction unboundedOf(root: Chain, rootFlags: readonly UnboundedStage[]): UnboundedStage[] {\n  const out: UnboundedStage[] = [];\n  const seen = new Set<string>();\n  const note = (flag: UnboundedStage) => {\n    const key = `${flag.why}\\u0000${flag.stageId}`;\n    if (seen.has(key)) return;\n    seen.add(key);\n    out.push(Object.freeze({ stageId: flag.stageId, why: flag.why }));\n  };\n  walkPositions(\n    root,\n    (p) => p.deps,\n    (_chain, p) => p.flags.forEach(note),\n  );\n  rootFlags.forEach(note);\n  return out;\n}\n\n/** A preorder walk of positions, descending into each chain `next` names the first time it is reached. */\nfunction walkPositions(\n  root: Chain,\n  next: (p: Position) => Chain | readonly Chain[] | undefined,\n  visit: (chain: Chain, p: Position) => void,\n): void {\n  const visited = new Set<Chain>([root]);\n  const stack: Array<{ chain: Chain; q: number }> = [{ chain: root, q: 0 }];\n  while (stack.length > 0) {\n    const top = stack[stack.length - 1];\n    if (top.q >= top.chain.positions.length) {\n      stack.pop();\n      continue;\n    }\n    const p = top.chain.positions[top.q++];\n    visit(top.chain, p);\n    const inner = next(p);\n    const chains = inner === undefined ? [] : Array.isArray(inner) ? inner : [inner as Chain];\n    for (let i = chains.length - 1; i >= 0; i--) {\n      if (visited.has(chains[i])) continue;\n      visited.add(chains[i]);\n      stack.push({ chain: chains[i], q: 0 });\n    }\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Words\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst contribution = (s: BudgetStep) => mul(s.passes, add(mul(s.attempts, s.timeoutMs ?? 0), s.backoffMs));\n\n/** The `limit` largest contributors, kept in path order. */\nfunction slowestInPathOrder(steps: readonly BudgetStep[], limit: number): BudgetStep[] {\n  const keep = new Set(\n    [...steps]\n      .sort((a, b) => contribution(b) - contribution(a))\n      .slice(0, limit)\n      .map((s) => s.stageId),\n  );\n  return steps.filter((s) => keep.has(s.stageId));\n}\n\nfunction stepText(s: BudgetStep): string {\n  const own =\n    s.timeoutMs === undefined\n      ? `${s.backoffMs} ms of waits (no timeoutMs)`\n      : `${s.attempts} × ${s.timeoutMs} ms + ${s.backoffMs} ms of waits = ${add(\n          mul(s.attempts, s.timeoutMs),\n          s.backoffMs,\n        )} ms`;\n  return `${s.stageId}: ${own}${s.passes > 1 ? `, ${s.passes} passes` : ''}`;\n}\n\nfunction unboundedText(stages: readonly UnboundedStage[]): string {\n  const listed = stages.slice(0, 10).map((s) => `${s.stageId} (${s.why})`);\n  return stages.length > listed.length\n    ? `${listed.join(', ')}, and ${stages.length - listed.length} more`\n    : listed.join(', ');\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Small laws\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Saturating arithmetic on non-negative milliseconds: never past `Number.MAX_SAFE_INTEGER`, never `NaN`. */\nconst CEILING = Number.MAX_SAFE_INTEGER;\nconst add = (a: number, b: number): number => Math.min(a + b, CEILING);\nconst mul = (a: number, b: number): number => (a === 0 || b === 0 ? 0 : Math.min(a * b, CEILING));\n\nconst lastOf = <T>(items: readonly T[]): T | undefined => items[items.length - 1];\n\n/** A budget: a number of milliseconds > 0 and no more than the saturated sums can be compared against. */\nconst isPositiveMs = (value: unknown): value is number =>\n  typeof value === 'number' && value > 0 && value <= Number.MAX_SAFE_INTEGER;\n\nconst shown = (value: unknown): string => (typeof value === 'number' ? String(value) : typeof value);\n\n/** An id as the run names it: under the prefix of the chart it lives in (a lazy or branch chart's mount path). */\nconst reported = (ctx: Ctx, id: string): string => (ctx.prefix === '' ? id : joinPath(ctx.prefix, id));\n\nfunction isChart(value: unknown): value is FlowChart {\n  if (value === null || typeof value !== 'object') return false;\n  const root = (value as { root?: unknown }).root;\n  return root !== null && typeof root === 'object';\n}\n\n/** An own property only — a prototype member is never an assumption or a subflow. */\nfunction own<T>(record: Readonly<Record<string, T>> | undefined, key: string): T | undefined {\n  return record !== undefined && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;\n}\n\n/** The engine's subflow lookup: by subflow id, then subflow name, then node name. */\nfunction subflowDefOf(\n  subflows: Readonly<Record<string, { root: StageNode }>> | undefined,\n  node: StageNode,\n): { root: StageNode } | undefined {\n  for (const key of [node.subflowId, node.subflowName, node.name]) {\n    if (key === undefined || key === '') continue;\n    const def = own(subflows, key);\n    if (def !== undefined && def !== null && typeof def.root === 'object' && def.root !== null) return def;\n  }\n  return undefined;\n}\n\n/** What a chart assumed for a lazy mount or a branch is, read once: its root, its subflows, its stage map. */\ninterface AssumedChart {\n  readonly root: StageNode;\n  readonly subflows?: Record<string, { root: StageNode }>;\n  readonly stageMap?: ReadonlyMap<string, unknown>;\n}\n\n/** The caller's assumptions, validated and copied once — the walk reads only these null-prototype records. */\ninterface AdmittedAssumptions {\n  readonly loops: Readonly<Record<string, number>>;\n  readonly lazy: Readonly<Record<string, AssumedChart>>;\n  readonly branches: Readonly<Record<string, AssumedChart>>;\n}\n\n/**\n * Validate the assumptions and COPY them: each own enumerable key is read exactly once, into a fresh null-prototype\n * record. A getter that changes between reads, a Proxy, or a non-enumerable key can therefore never hand the walk\n * a value that was not validated, and no prototype member is ever an assumption.\n */\nfunction admitAssumptions(assume: unknown): AdmittedAssumptions {\n  if (assume !== undefined && (assume === null || typeof assume !== 'object')) {\n    throw new TypeError('timeBudget: assume must be an object ({ loops?, lazy?, branches? }).');\n  }\n  const given = (assume ?? {}) as Record<'loops' | 'lazy' | 'branches', unknown>;\n  return {\n    loops: snapshot(given.loops, 'loops', (key, passes) => {\n      if (typeof passes === 'number' && Number.isInteger(passes) && passes >= 1) return passes;\n      throw new TypeError(\n        `timeBudget: assume.loops['${key}'] must be a whole number of passes >= 1 (got ${shown(passes)}).`,\n      );\n    }),\n    lazy: snapshot(given.lazy, 'lazy', (key, chart) => assumedChart('lazy', key, chart)),\n    branches: snapshot(given.branches, 'branches', (key, chart) => assumedChart('branches', key, chart)),\n  };\n}\n\nfunction snapshot<T>(record: unknown, field: string, admit: (key: string, value: unknown) => T): Record<string, T> {\n  const copy = Object.create(null) as Record<string, T>;\n  if (record === undefined) return copy;\n  if (record === null || typeof record !== 'object') {\n    throw new TypeError(`timeBudget: assume.${field} must be an object keyed by id.`);\n  }\n  for (const key of Object.keys(record)) copy[key] = admit(key, (record as Record<string, unknown>)[key]);\n  return Object.freeze(copy);\n}\n\nfunction assumedChart(field: string, key: string, chart: unknown): AssumedChart {\n  const root = isChart(chart) ? (chart as { root: unknown }).root : undefined;\n  if (!isNode(root)) {\n    throw new TypeError(`timeBudget: assume.${field}['${key}'] must be a built chart (flowChart(...).build()).`);\n  }\n  const { subflows, stageMap } = chart as FlowChart;\n  return Object.freeze({\n    root,\n    ...(subflows !== undefined && { subflows: subflows as Record<string, { root: StageNode }> }),\n    ...(stageMap instanceof Map && { stageMap }),\n  });\n}\n"]}