footprintjs 10.0.1 → 10.2.0

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

@@ -0,0 +1,523 @@
+/**
+ * attempt/runner.ts — `runAttempts`, THE retry loop (design §3.1, law 1: one runner, one record).
+ *
+ * Runs a function under a policy and records every try: one frozen `AttemptRecord` per attempt, carrying its
+ * timing, outcome, failure category and the retry-or-stop decision (`attempt/decision.ts`), and one
+ * `AttemptSummary` when the series ends. The engine's stage retry (`FlowchartTraverser · executeStage`) runs on
+ * it; later packets run in-stage calls and standalone `attempt()` on it too.
+ *
+ * The loop, per attempt n — for a failed attempt, the 9.15 loop's order, step for step:
+ *
+ *   start → run(n) → outcome (ok | failed | aborted [it threw the run's abort reason] | paused [a PauseSignal])
+ *         → decide over the inputs, first match wins (`retryRules`) — retryOn is asked here (rule 5)
+ *         → the run's signal aborted inside retryOn? decide again: rule 3 stops the series here, before the
+ *           discard and before backoffMs, as the 9.15 abort check did
+ *         → retry: between(n) — the discard — and THEN backoffMs(n), the wait's length
+ *         → the error's served form and category, read after retryOn and backoffMs ran → the record
+ *         → onEnd(summary)                                               only when the series ends here
+ *         → onAttempt(record, served error)
+ *         → done: return the value · stop: rethrow the attempt's OWN error
+ *         → retry: onRetry(n, of, delay, served error) → wait (cut short by the signal) → aborted? stop
+ *
+ * WHAT IT PRESERVES (the 9.15 loop's behaviour, moved here unchanged): the function runs the same number of
+ * times; `retryOn` is asked only for a failed, non-final attempt; `backoffMs` only when a retry follows, after
+ * the discard; a throwing predicate is "do not retry", a throwing or non-finite backoff is "no wait"; a pause is
+ * never retried; the attempt's own error is rethrown, never a wrapper; and a failed attempt's order —
+ * `retryOn` → the abort check → the discard (`between`) → `backoffMs` → the served error → the retry event →
+ * the wait → the abort check. So an abort inside `retryOn` stops before the discard and never asks `backoffMs`;
+ * an abort inside `backoffMs` comes after the discard, still fires the retry event, then ends at the wait; and
+ * the served error shows what `retryOn` did to the thrown value. The one difference: when the run's signal has
+ * ALREADY aborted as the attempt fails, the series stops without asking `retryOn` (the abort decides first —
+ * rule 3 before rule 5).
+ *
+ * WHAT IT ADDS: the record and the summary. A record is frozen to its leaves and holds only clone-safe data —
+ * the error as the run SERVES it (`serve`, the redaction rule's form) without `raw`. The hook gets the served
+ * `StructuredErrorInfo` whole, `raw` included, as `onStageRetry` always has. A record never rewrites what the
+ * attempt did: an attempt that threw its own error is `failed`, with its category, even when the run aborted
+ * around it — the abort is the series' stop reason (`reason: 'aborted'`); a throwing `retryOn` is `declined`
+ * with `retryOnThrew: true`, apart from a real `false`.
+ *
+ * TIME (P1b). Each attempt runs under `min(policy.timeoutMs, time left before options.deadline)` and gets an
+ * `AttemptContext` — its signal, composed from the run's and its own cap's timer (`LiveAttempt`). The cap's timer
+ * aborts with an `AttemptTimeoutError`; the run's deadline aborts the run's signal with a branded reason
+ * (`attempt/deadline.ts`). Either way the attempt is `'timeout'`, never `'aborted'`: the deadline is not a
+ * cancellation, so rule 3 does not match and rule 6 (`timeLeftAfterWaitMs ≤ 0`) stops a series whose next wait
+ * would outlast it. Under a deadline rule 6 needs the wait's length, so `backoffMs(n, error)` is asked DURING the
+ * decision — before the discard; without one the 9.15 order above holds unchanged. No attempt starts at or past
+ * the deadline: a wait the deadline cut ends the series `no-time-left`, recording no further attempt.
+ *
+ * THE FENCE. The moment an attempt ends without an answer — its signal aborts (synchronously, before any listener
+ * the function added) or it throws — `onAbandon(n)` fires once, and the engine closes that attempt's scope: the
+ * function may still be running, and nothing it does afterwards may land beside a later attempt.
+ *
+ * ONE async frame with ONE await per attempt: the engine relies on that to keep a retried stage's microtask
+ * shape, so parallel siblings settle in the order they always did. The engine races the attempt's signal itself,
+ * at the stage boundary (`raced: true`); any other caller gets the race here, so the series never waits on an
+ * attempt past its cap.
+ *
+ * CALLS (P2). The same loop runs a call a stage makes (`attempt/call.ts · runCall`, kind `'call'`, its `target` on
+ * every record) and the standalone `attempt()`. An attempt's cap is the DEADLINE of every call made inside it, so
+ * the cap's reason is branded a time limit (`attempt/deadline.ts · markTimeLimit`): a call cut by its stage
+ * attempt's cap timed out, it was not cancelled. `attemptEndsAt` says when an attempt must end; an `interrupt()`
+ * thrown inside a call is a pause, like a `PauseSignal` — never retried.
+ */
+import { extractErrorInfo } from '../errors/errorInfo.js';
+import { isInterruptSignal } from '../pause/interrupt.js';
+import { isPauseSignal } from '../pause/types.js';
+import { anySignal } from './anySignal.js';
+import { errorCategory, terminalCategory } from './category.js';
+import { isCancelled, isDeadlineReason, markTimeLimit, readDeadline, setLongTimeout } from './deadline.js';
+import { decideAttempt, retryRules } from './decision.js';
+import { effectOf, recordedKeyOf, refuseKeylessRetry, unknownEffectError } from './effect.js';
+import { AttemptTimeoutError } from './errors.js';
+import { attemptCeiling, attemptTimeoutMs, cappedWaitMs } from './policy.js';
+import { freezeDeep, recordedError } from './record.js';
+/** When each live attempt must end, epoch ms — `startedAt + cap`, for an attempt that has a cap (`attemptEndsAt`). */
+const ATTEMPT_ENDS = new WeakMap();
+/**
+ * When the attempt behind `context` must end, epoch milliseconds — its start plus its cap (`min(timeoutMs, time
+ * left)`, so never past the run's deadline) — or `undefined` for an uncapped attempt. A call made inside the
+ * attempt runs under it as its deadline (`attempt/call.ts`). Only the runner's own contexts are known.
+ */
+export function attemptEndsAt(context) {
+    return context === undefined ? undefined : ATTEMPT_ENDS.get(context);
+}
+/**
+ * Run `run` until it succeeds or the policy stops it; resolve with its value or reject with the LAST attempt's
+ * own error. `run(n)` is called with the attempt number, 1-based.
+ */
+export async function runAttempts(run, policy, options) {
+    const of = attemptCeiling(policy.attempts);
+    const rules = retryRules({ attempts: of });
+    const now = options.now ?? Date.now;
+    const deadline = readDeadline(options.deadline);
+    const ownCap = attemptTimeoutMs(policy.timeoutMs);
+    const tally = new SeriesTally();
+    if (options.effect)
+        refuseKeylessRetry(options.effect, of);
+    /** An earlier attempt of this touching series left the effect unknown — a later answer of `none` cannot clear it. */
+    let unknownSoFar = false;
+    for (let attempt = 1;; attempt++) {
+        const startedAt = now();
+        const live = new LiveAttempt(options, attempt, of, startedAt, deadline, ownCap, now);
+        let value;
+        let failure;
+        try {
+            const pending = run(attempt, live.context);
+            // Started under a signal that had ALREADY aborted (a decider entered after a cancel): its synchronous part
+            // ran as it always did; from here on nobody waits for it, so nothing it does after its first await lands.
+            if (live.context.signal.aborted)
+                live.abandonStarted();
+            value = await (options.raced ? pending : live.race(pending));
+        }
+        catch (error) {
+            failure = { error };
+        }
+        const durationMs = Math.max(0, now() - startedAt);
+        const outcome = outcomeOf(failure, options.signal, live.timeoutReason);
+        live.end(outcome);
+        const inputs = new AttemptInputReader(policy, options, attempt, of, outcome, failure, deadline, now);
+        let decision = decideAttempt(rules, inputs.read);
+        // 9.15 asked retryOn, THEN checked the signal. Deciding again reads the signal afresh: rule 3 now matches,
+        // ahead of every user function, so none is asked twice — and nothing is discarded, nothing waited for.
+        if (decision.next === 'retry' && isCancelled(options.signal))
+            decision = decideAttempt(rules, inputs.read);
+        // The discard comes BEFORE the wait's length is asked for, as it did in 9.15 — without a deadline. Under one,
+        // rule 6 needs the wait's length to decide, so `backoffMs` was asked during the decision, before the discard.
+        if (decision.next === 'retry')
+            options.between?.(attempt);
+        const delayMs = decision.next === 'retry' ? inputs.delayMs() : inputs.delayIfAsked();
+        const timeLeftMs = deadline === undefined ? undefined : inputs.timeLeft();
+        const category = inputs.category();
+        // Private terminal semantics are fixed before serving or observer fan-out.
+        // An already-unresolved call wrapper must not become its physical cause
+        // if a consumer later changes the raw error's properties or prototype.
+        const terminal = options.onFailure && failure ? terminalCategory(failure.error, category) : category ?? 'unknown';
+        const served = inputs.failed ? (options.serve ?? extractErrorInfo)(inputs.failed.error) : undefined;
+        const effect = options.effect ? effectOf(inputs.outcome, failure?.error) : undefined;
+        const recordedKey = options.effect ? recordedKeyOf(options.effect) : undefined;
+        const record = freezeDeep({
+            series: options.series,
+            kind: options.kind ?? 'stage',
+            ...(options.target !== undefined && { target: options.target }),
+            attempt,
+            of,
+            startedAt,
+            durationMs,
+            outcome: inputs.outcome,
+            ...(category !== undefined && { category }),
+            decision: decision.evidence,
+            next: decision.next,
+            reason: decision.reason,
+            ...(inputs.retryOnThrew && { retryOnThrew: true }),
+            ...(delayMs !== undefined && { delayMs }),
+            ...(live.capMs !== undefined && { timeoutMs: live.capMs }),
+            ...(timeLeftMs !== undefined && { timeLeftMs }),
+            ...(served !== undefined && { error: recordedError(served) }),
+            ...(options.effect !== undefined && { system: options.effect.system }),
+            ...(recordedKey !== undefined && { idempotencyKey: recordedKey }),
+            ...(effect !== undefined && { effect }),
+        });
+        tally.add(record);
+        if (record.effect === 'unknown')
+            unknownSoFar = true;
+        if (record.next !== 'retry')
+            options.onEnd?.(tally.summary(lastOf(record, unknownSoFar)));
+        options.onAttempt?.(record, served);
+        if (record.next === 'done')
+            return value;
+        if (record.next === 'stop')
+            throw stoppedFailure(options, record, failure, unknownSoFar, terminal);
+        options.onRetry?.(attempt, of, delayMs ?? 0, served);
+        if (delayMs !== undefined && delayMs > 0) {
+            try {
+                await sleep(delayMs, options.signal);
+            }
+            catch (error) {
+                options.onFailure?.(error, 'unknown');
+                throw error;
+            }
+        }
+        // No attempt follows a cut wait, so none is recorded: the summary says how the series ended. No attempt
+        // STARTS at or past the deadline either — rule 6 decided with the clock, and the clock may have moved on.
+        const cut = isCancelled(options.signal)
+            ? 'aborted'
+            : options.signal?.aborted || (deadline !== undefined && now() >= deadline)
+                ? 'no-time-left'
+                : undefined;
+        if (cut !== undefined) {
+            options.onEnd?.(tally.summary({ ...lastOf(record, unknownSoFar), next: 'stop', reason: cut }));
+            throw stoppedFailure(options, record, failure, unknownSoFar, terminal);
+        }
+    }
+}
+/** The final physical attempt owns its category; a wrapper or cut wait has no such category. */
+function stoppedFailure(options, record, failure, unknownSoFar, terminal) {
+    const error = stopError(options.effect, record, failure, unknownSoFar);
+    if (record.outcome !== 'paused') {
+        const category = record.next === 'stop' && Object.is(error, failure?.error) ? terminal : 'unknown';
+        options.onFailure?.(error, category);
+    }
+    return error;
+}
+/**
+ * What a stopped series throws: the last attempt's own error — or, on a touching target where ANY attempt left the
+ * effect unknown, `UnknownEffectError` with the last attempt's error as its cause. An earlier timeout may have
+ * applied the effect; a later attempt that says "nothing was sent" speaks for itself only, so it cannot turn the
+ * series into a plain failure. A pause is never converted: it is control flow.
+ */
+function stopError(effect, record, failure, unknownSoFar) {
+    if (effect === undefined || !unknownSoFar || record.outcome === 'paused')
+        return failure?.error;
+    return unknownEffectError(effect, record, failure?.error);
+}
+/**
+ * One attempt in flight: its cap, its signal (the run's, composed with its own timer), and the fence. Its own
+ * timer is armed when the policy's cap is SHORTER than the time left; at the deadline the run's own signal aborts,
+ * with the deadline's reason (so a run rejects with the reason it always did). Everything it arms is released
+ * when the attempt ends.
+ */
+class LiveAttempt {
+    options;
+    attempt;
+    context;
+    /** The cap this attempt runs under — `min(timeoutMs, time left)`, never negative; absent when uncapped. */
+    capMs;
+    /** The reason the attempt's OWN timer aborted with — set only if it fired. */
+    timeoutReason;
+    cancelTimer;
+    composed;
+    abandoned = false;
+    /** The attempt is over, however it ended — an `observed` report after this is the owner's to refuse. */
+    ended = false;
+    onAbort = () => this.abandon();
+    constructor(options, attempt, of, startedAt, deadline, ownCap, now) {
+        this.options = options;
+        this.attempt = attempt;
+        const left = deadline === undefined ? Infinity : Math.max(0, deadline - startedAt);
+        const cap = Math.min(ownCap ?? Infinity, left);
+        this.capMs = Number.isFinite(cap) ? cap : undefined;
+        // Its own timer when its own cap is the shorter, or when no run signal will abort at the deadline (a caller
+        // with a deadline and no signal). Otherwise the run's signal ends it at the deadline, with the deadline's reason.
+        const ownTimer = this.capMs !== undefined && ((ownCap !== undefined && ownCap < left) || !options.signal);
+        const own = ownTimer ? new AbortController() : undefined;
+        if (own) {
+            const capMs = this.capMs;
+            this.cancelTimer = setLongTimeout(() => {
+                // A time limit, branded like the run's deadline: a call made inside this attempt that it cuts timed out.
+                this.timeoutReason = markTimeLimit(new AttemptTimeoutError(attempt, capMs));
+                own.abort(this.timeoutReason);
+            }, capMs);
+        }
+        this.composed = anySignal([options.signal, own?.signal]);
+        // Registered BEFORE the function runs, so the fence closes before any listener the function adds. A signal
+        // ALREADY aborted (a decider entered after a cancel — no abort check precedes it) does not fence the attempt
+        // before it runs: it runs as it did before the fence existed, and is fenced when it ends without an answer.
+        this.composed.signal.addEventListener('abort', this.onAbort, { once: true });
+        const signal = this.composed.signal;
+        const capMs = this.capMs;
+        this.context = Object.freeze({
+            series: options.series,
+            attempt,
+            of,
+            signal,
+            ...(deadline !== undefined && { deadline }),
+            ...(capMs !== undefined && { timeoutMs: capMs }),
+            ...(options.effect !== undefined && { system: options.effect.system }),
+            ...(options.effect?.idempotencyKey !== undefined && { idempotencyKey: options.effect.idempotencyKey }),
+            timeLeftMs: () => (deadline === undefined ? Infinity : deadline - now()),
+            observed: (report) => {
+                if (!options.observe) {
+                    throw new TypeError('observed(): report an outside attempt through `scope.$attempt().observed(...)`');
+                }
+                options.observe(report, { attempt, ended: this.ended });
+            },
+        });
+        if (capMs !== undefined)
+            ATTEMPT_ENDS.set(this.context, startedAt + capMs);
+    }
+    /** `value`, or the attempt signal's reason the moment it aborts first — the engine stops waiting at the cap. */
+    race(value) {
+        if (!(value instanceof Promise))
+            return value;
+        const signal = this.composed.signal;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => reject(signal.reason);
+            value.then((v) => {
+                signal.removeEventListener('abort', onAbort);
+                resolve(v);
+            }, (e) => {
+                signal.removeEventListener('abort', onAbort);
+                reject(e);
+            });
+            // Already aborted (the function aborted it as it ran): a value that already settled still wins — its
+            // reaction was queued above, first — and a pending one is cut on the next microtask.
+            if (signal.aborted)
+                queueMicrotask(onAbort);
+            else
+                signal.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    /** The attempt is over: release the timer and the listeners; fence it if it ended without an answer. */
+    end(outcome) {
+        this.ended = true;
+        this.cancelTimer?.();
+        this.composed.signal.removeEventListener('abort', this.onAbort);
+        this.composed.dispose();
+        if (outcome !== 'ok' && outcome !== 'paused')
+            this.abandon();
+    }
+    /** Fence an attempt that started under an already-aborted signal, once its synchronous part has run. */
+    abandonStarted() {
+        this.abandon();
+    }
+    abandon() {
+        if (this.abandoned)
+            return;
+        this.abandoned = true;
+        this.options.onAbandon?.(this.attempt);
+    }
+}
+/** The signal aborted at a time limit — the run's deadline, or a call's attempt cap — not by a cancellation. */
+function timedOut(signal) {
+    return signal?.aborted === true && isDeadlineReason(signal.reason);
+}
+/**
+ * How the attempt itself ended. A thrown value is the attempt's own failure unless it IS what a signal aborted
+ * with (StageRunner's race rejects with it; a stage may rethrow it): its own cap's `AttemptTimeoutError` or the
+ * run's deadline → `'timeout'`; the run's cancellation → `'aborted'`.
+ */
+function outcomeOf(failure, signal, timeoutReason) {
+    if (!failure)
+        return 'ok';
+    // An `interrupt()` thrown inside a call is converted to a pause at the stage boundary, past this runner.
+    if (isPauseSignal(failure.error) || isInterruptSignal(failure.error))
+        return 'paused';
+    // Its own cap ran out — the attempt's timer is the one that fired, and the attempt threw what it aborted with.
+    if (timeoutReason !== undefined && failure.error === timeoutReason)
+        return 'timeout';
+    if (signal?.aborted !== true || failure.error !== signal.reason)
+        return 'failed';
+    // The run's signal ended it: at the deadline the attempt ran out of time (law 4); otherwise it was cancelled.
+    return isDeadlineReason(signal.reason) ? 'timeout' : 'aborted';
+}
+/**
+ * One attempt's decision inputs, each read only when a rule reaches it (`decideAttempt`'s reader): the user's
+ * `retryOn` and `backoffMs` run at most once each, and only when the 9.15 loop would have run them.
+ */
+class AttemptInputReader {
+    policy;
+    options;
+    attempt;
+    of;
+    outcome;
+    deadline;
+    now;
+    /** The failure a category and a served error are read from — none for `'ok'` and `'paused'`. */
+    failed;
+    /** `true` once `retryOn` threw (its verdict is then `false`). */
+    retryOnThrew = false;
+    retryOnVerdict;
+    wait;
+    failureCategory;
+    categoryRead = false;
+    left;
+    constructor(policy, options, attempt, of, outcome, failure, deadline, now) {
+        this.policy = policy;
+        this.options = options;
+        this.attempt = attempt;
+        this.of = of;
+        this.outcome = outcome;
+        this.deadline = deadline;
+        this.now = now;
+        this.failed = failure && outcome !== 'paused' ? failure : undefined;
+    }
+    /** One input by its `AttemptInputs` key. */
+    read = (key) => {
+        switch (key) {
+            case 'outcome':
+                return this.outcome;
+            case 'category':
+                return this.category();
+            case 'aborted':
+                // Live: a decision taken again after `retryOn` sees an abort raised inside it. The deadline is not a
+                // cancellation — rule 6 owns it.
+                return isCancelled(this.options.signal);
+            case 'attempt':
+                return this.attempt;
+            case 'of':
+                return this.of;
+            case 'timeLeftMs':
+                return this.timeLeft();
+            case 'timeLeftAfterWaitMs':
+                // Without a deadline the time left is unbounded, before any wait and after it — so deciding needs no
+                // wait, and `backoffMs` is asked after the discard, as in 9.15. Under one, the wait's length decides.
+                return this.unbounded() ? Infinity : this.timeLeft() - this.delayMs();
+            case 'delayMs':
+                return this.delayMs();
+            case 'retryOn':
+                return this.retryOn();
+            case 'keyPresent':
+                return this.options.effect?.idempotencyKey !== undefined;
+            default:
+                return undefined;
+        }
+    };
+    /** The failure's category, read once — at the first rule that asks, or after the decision. */
+    category() {
+        if (!this.categoryRead) {
+            this.categoryRead = true;
+            this.failureCategory = this.failed ? errorCategory(this.failed.error, this.outcome) : undefined;
+        }
+        return this.failureCategory;
+    }
+    /** The policy's wait after this attempt (`resolveBackoffMs`), asked once — capped at its `maxBackoffMs`. */
+    delayMs() {
+        return (this.wait ??= cappedWaitMs(resolveBackoffMs(this.policy.backoffMs, this.attempt, this.failed?.error), this.policy.maxBackoffMs));
+    }
+    /** The wait, if the decision already asked for it (rule 6 under a deadline); never asks `backoffMs` itself. */
+    delayIfAsked() {
+        return this.wait;
+    }
+    /** Milliseconds before the deadline at the decision, read once (`Infinity` without one). */
+    timeLeft() {
+        if (this.unbounded())
+            return Infinity;
+        if (this.left === undefined) {
+            const clock = this.deadline === undefined ? Infinity : this.deadline - this.now();
+            // A time limit already reached — the signal aborted at the deadline (or, for a call, at its attempt's cap) —
+            // leaves no time, whatever the clock says: a host timer may fire a millisecond before the clock gets there.
+            this.left = timedOut(this.options.signal) ? Math.min(clock, 0) : clock;
+        }
+        return this.left;
+    }
+    /** No deadline and no time limit reached: the time left is `Infinity`, and no wait need be asked for. */
+    unbounded() {
+        return this.deadline === undefined && !timedOut(this.options.signal);
+    }
+    /** The `retryOn` gate, asked once. A throwing predicate is "do not retry" — a broken one never loops. */
+    retryOn() {
+        if (this.retryOnVerdict === undefined)
+            this.retryOnVerdict = this.askRetryOn();
+        return this.retryOnVerdict;
+    }
+    askRetryOn() {
+        if (!this.policy.retryOn)
+            return true;
+        try {
+            return this.policy.retryOn(this.failed?.error) === true;
+        }
+        catch (thrown) {
+            this.retryOnThrew = true;
+            this.options.onRetryOnThrew?.(thrown);
+            return false;
+        }
+    }
+}
+/**
+ * Resolve a policy's `backoffMs` for the attempt that just failed (1-based) and its error. Anything that is not a finite,
+ * positive number — a missing dial, a negative value, a `NaN` from a consumer's arithmetic, or a throwing
+ * function — becomes `0`, i.e. retry immediately. A backoff dial must never be able to crash a run or park it
+ * forever.
+ */
+export function resolveBackoffMs(backoffMs, attempt, error) {
+    if (backoffMs === undefined)
+        return 0;
+    let value;
+    if (typeof backoffMs === 'function') {
+        try {
+            value = backoffMs(attempt, error);
+        }
+        catch {
+            return 0;
+        }
+    }
+    else {
+        value = backoffMs;
+    }
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+ * Await `ms`, cut short by an abort. Resolves either way — the caller re-checks `signal.aborted` and rethrows
+ * the attempt's own error, so a cancelled run never sits out a long backoff and never loses the failure that
+ * caused it. The timer and the listener are always cleaned up.
+ */
+export function sleep(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const done = () => {
+            cancel();
+            signal?.removeEventListener('abort', done);
+            resolve();
+        };
+        const cancel = setLongTimeout(done, ms);
+        signal?.addEventListener('abort', done, { once: true });
+    });
+}
+/**
+ * How a record ended its series, as the summary's `last` says it. On a touching target the effect is the SERIES'
+ * (`unknownSoFar`): unknown once any attempt left it unknown, unless the series ended with an answer.
+ */
+function lastOf(record, unknownSoFar = false) {
+    const effect = record.effect !== undefined && unknownSoFar && record.outcome !== 'ok' ? 'unknown' : record.effect;
+    return {
+        next: record.next,
+        reason: record.reason,
+        ...(record.category !== undefined && { category: record.category }),
+        ...(record.retryOnThrew && { retryOnThrew: true }),
+        ...(effect !== undefined && { effect }),
+    };
+}
+/** Per-outcome counts of a series, for its summary. */
+class SeriesTally {
+    counts = { count: 0, ok: 0, failed: 0, timeout: 0, aborted: 0, paused: 0 };
+    add(record) {
+        this.counts.count += 1;
+        this.counts[record.outcome] += 1;
+    }
+    summary(last) {
+        return freezeDeep({ ...this.counts, last });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../../../src/lib/attempt/runner.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/runner.ts — `runAttempts`, THE retry loop (design §3.1, law 1: one runner, one record).\n *\n * Runs a function under a policy and records every try: one frozen `AttemptRecord` per attempt, carrying its\n * timing, outcome, failure category and the retry-or-stop decision (`attempt/decision.ts`), and one\n * `AttemptSummary` when the series ends. The engine's stage retry (`FlowchartTraverser · executeStage`) runs on\n * it; later packets run in-stage calls and standalone `attempt()` on it too.\n *\n * The loop, per attempt n — for a failed attempt, the 9.15 loop's order, step for step:\n *\n *   start → run(n) → outcome (ok | failed | aborted [it threw the run's abort reason] | paused [a PauseSignal])\n *         → decide over the inputs, first match wins (`retryRules`) — retryOn is asked here (rule 5)\n *         → the run's signal aborted inside retryOn? decide again: rule 3 stops the series here, before the\n *           discard and before backoffMs, as the 9.15 abort check did\n *         → retry: between(n) — the discard — and THEN backoffMs(n), the wait's length\n *         → the error's served form and category, read after retryOn and backoffMs ran → the record\n *         → onEnd(summary)                                               only when the series ends here\n *         → onAttempt(record, served error)\n *         → done: return the value · stop: rethrow the attempt's OWN error\n *         → retry: onRetry(n, of, delay, served error) → wait (cut short by the signal) → aborted? stop\n *\n * WHAT IT PRESERVES (the 9.15 loop's behaviour, moved here unchanged): the function runs the same number of\n * times; `retryOn` is asked only for a failed, non-final attempt; `backoffMs` only when a retry follows, after\n * the discard; a throwing predicate is \"do not retry\", a throwing or non-finite backoff is \"no wait\"; a pause is\n * never retried; the attempt's own error is rethrown, never a wrapper; and a failed attempt's order —\n * `retryOn` → the abort check → the discard (`between`) → `backoffMs` → the served error → the retry event →\n * the wait → the abort check. So an abort inside `retryOn` stops before the discard and never asks `backoffMs`;\n * an abort inside `backoffMs` comes after the discard, still fires the retry event, then ends at the wait; and\n * the served error shows what `retryOn` did to the thrown value. The one difference: when the run's signal has\n * ALREADY aborted as the attempt fails, the series stops without asking `retryOn` (the abort decides first —\n * rule 3 before rule 5).\n *\n * WHAT IT ADDS: the record and the summary. A record is frozen to its leaves and holds only clone-safe data —\n * the error as the run SERVES it (`serve`, the redaction rule's form) without `raw`. The hook gets the served\n * `StructuredErrorInfo` whole, `raw` included, as `onStageRetry` always has. A record never rewrites what the\n * attempt did: an attempt that threw its own error is `failed`, with its category, even when the run aborted\n * around it — the abort is the series' stop reason (`reason: 'aborted'`); a throwing `retryOn` is `declined`\n * with `retryOnThrew: true`, apart from a real `false`.\n *\n * TIME (P1b). Each attempt runs under `min(policy.timeoutMs, time left before options.deadline)` and gets an\n * `AttemptContext` — its signal, composed from the run's and its own cap's timer (`LiveAttempt`). The cap's timer\n * aborts with an `AttemptTimeoutError`; the run's deadline aborts the run's signal with a branded reason\n * (`attempt/deadline.ts`). Either way the attempt is `'timeout'`, never `'aborted'`: the deadline is not a\n * cancellation, so rule 3 does not match and rule 6 (`timeLeftAfterWaitMs ≤ 0`) stops a series whose next wait\n * would outlast it. Under a deadline rule 6 needs the wait's length, so `backoffMs(n, error)` is asked DURING the\n * decision — before the discard; without one the 9.15 order above holds unchanged. No attempt starts at or past\n * the deadline: a wait the deadline cut ends the series `no-time-left`, recording no further attempt.\n *\n * THE FENCE. The moment an attempt ends without an answer — its signal aborts (synchronously, before any listener\n * the function added) or it throws — `onAbandon(n)` fires once, and the engine closes that attempt's scope: the\n * function may still be running, and nothing it does afterwards may land beside a later attempt.\n *\n * ONE async frame with ONE await per attempt: the engine relies on that to keep a retried stage's microtask\n * shape, so parallel siblings settle in the order they always did. The engine races the attempt's signal itself,\n * at the stage boundary (`raced: true`); any other caller gets the race here, so the series never waits on an\n * attempt past its cap.\n *\n * CALLS (P2). The same loop runs a call a stage makes (`attempt/call.ts · runCall`, kind `'call'`, its `target` on\n * every record) and the standalone `attempt()`. An attempt's cap is the DEADLINE of every call made inside it, so\n * the cap's reason is branded a time limit (`attempt/deadline.ts · markTimeLimit`): a call cut by its stage\n * attempt's cap timed out, it was not cancelled. `attemptEndsAt` says when an attempt must end; an `interrupt()`\n * thrown inside a call is a pause, like a `PauseSignal` — never retried.\n */\n\nimport type { StructuredErrorInfo } from '../errors/errorInfo.js';\nimport { extractErrorInfo } from '../errors/errorInfo.js';\nimport { isInterruptSignal } from '../pause/interrupt.js';\nimport { isPauseSignal } from '../pause/types.js';\nimport { anySignal } from './anySignal.js';\nimport { errorCategory, terminalCategory } from './category.js';\nimport { isCancelled, isDeadlineReason, markTimeLimit, readDeadline, setLongTimeout } from './deadline.js';\nimport { decideAttempt, retryRules } from './decision.js';\nimport type { EffectTarget } from './effect.js';\nimport { effectOf, recordedKeyOf, refuseKeylessRetry, unknownEffectError } from './effect.js';\nimport { AttemptTimeoutError } from './errors.js';\nimport { attemptCeiling, attemptTimeoutMs, cappedWaitMs } from './policy.js';\nimport { freezeDeep, recordedError } from './record.js';\nimport type {\n  AttemptCategory,\n  AttemptContext,\n  AttemptKind,\n  AttemptOutcome,\n  AttemptRecord,\n  AttemptSummary,\n  ObservedAttempt,\n  RetryPolicy,\n} from './types.js';\n\n/** What a series reports, and the engine's between-attempt step. Every member is optional. */\nexport interface AttemptRunOptions {\n  /** The series every record names — for a stage attempt, its execution's `runtimeStageId`. */\n  readonly series: string;\n  /** Default `'stage'`. */\n  readonly kind?: AttemptKind;\n  /** The outside target every record names — a call's (`$call`, `attempt()`); absent for a stage attempt. */\n  readonly target?: string;\n  /**\n   * The run's signal. Once it has aborted (other than at the deadline), rule 3 stops the series\n   * (`reason: 'aborted'`); it cuts a wait short. An attempt that threw its reason is recorded `'aborted'` — or\n   * `'timeout'` when the reason is the deadline's (`attempt/deadline.ts`).\n   */\n  readonly signal?: AbortSignal;\n  /**\n   * The run's deadline, epoch milliseconds. Every attempt is capped by the time left; rule 6 stops a series whose\n   * next wait would outlast it (`no-time-left`). Absent (or not finite) = no deadline: the time left is `Infinity`.\n   */\n  readonly deadline?: number;\n  /** The clock, epoch milliseconds. Default `Date.now`. */\n  readonly now?: () => number;\n  /** The served form of a failed attempt's error. Default `extractErrorInfo` (no redaction rule). */\n  readonly serve?: (error: unknown) => StructuredErrorInfo;\n  /** Between a failed attempt and the next, before `backoffMs`: the engine discards the attempt's staged writes. */\n  readonly between?: (attempt: number) => void;\n  /** Every attempt, at its end, with its served error (`undefined` for `'ok'` and `'paused'`). */\n  readonly onAttempt?: (record: AttemptRecord, structuredError: StructuredErrorInfo | undefined) => void;\n  /** A failed attempt that WILL be retried — after `between` and `onAttempt`, before the wait. */\n  readonly onRetry?: (attempt: number, of: number, delayMs: number, structuredError: StructuredErrorInfo) => void;\n  /** The series ended: called once, before the last `onAttempt` (or after a wait the run's signal cut). */\n  readonly onEnd?: (summary: AttemptSummary) => void;\n  /** @internal Native owner only: the exact escaping value and category, before its stage serves the error. */\n  readonly onFailure?: (error: unknown, category: AttemptCategory) => void;\n  /** `retryOn` threw — the attempt is treated as declined; the engine logs the throw here. */\n  readonly onRetryOnThrew?: (thrown: unknown) => void;\n  /**\n   * The attempt ended without an answer — called SYNCHRONOUSLY the moment its signal aborts (its cap, the deadline,\n   * a cancellation), else as soon as it failed. Whatever the abandoned function does afterwards is not this\n   * series': the engine fences its scope here. Once per attempt; never for `'ok'` or `'paused'` — except an attempt\n   * that STARTED under an already-aborted signal, fenced once its synchronous part has run (nobody waits for it).\n   */\n  readonly onAbandon?: (attempt: number) => void;\n  /**\n   * The caller races `run`'s promise against the attempt's signal itself — the engine does, at the stage boundary\n   * (`StageRunner`), so a stage keeps its one await per attempt. Otherwise the runner races it: the series never\n   * waits on an attempt past its cap.\n   */\n  readonly raced?: boolean;\n  /**\n   * What an attempt's `observed(report)` does (P2) — the owner of the attempt records the report: `runCall` hands\n   * a call's reports to the scope, `attempt()` keeps its own. `ended` says the attempt had already ended when the\n   * report came (the owner drops it). Absent — a stage attempt's context, whose `observed` the scope's\n   * `$attempt()` replaces — `observed` is refused with a `TypeError`.\n   */\n  readonly observe?: (report: ObservedAttempt, at: { readonly attempt: number; readonly ended: boolean }) => void;\n  /**\n   * The outside system the target touches (P3, design §3.3). Every record then says what its attempt did to it\n   * (`effect`) and names the system and the RECORDED key; every attempt's context carries the REAL key. A series\n   * that ends without an answer after any attempt of unknown effect fails with `UnknownEffectError` (its `cause` the attempt's own error) —\n   * except a pause, which stays a pause. A touching series that may retry without a key is refused before anything\n   * runs: the law's last door.\n   */\n  readonly effect?: EffectTarget;\n}\n\n/** When each live attempt must end, epoch ms — `startedAt + cap`, for an attempt that has a cap (`attemptEndsAt`). */\nconst ATTEMPT_ENDS = new WeakMap<AttemptContext, number>();\n\n/**\n * When the attempt behind `context` must end, epoch milliseconds — its start plus its cap (`min(timeoutMs, time\n * left)`, so never past the run's deadline) — or `undefined` for an uncapped attempt. A call made inside the\n * attempt runs under it as its deadline (`attempt/call.ts`). Only the runner's own contexts are known.\n */\nexport function attemptEndsAt(context: AttemptContext | undefined): number | undefined {\n  return context === undefined ? undefined : ATTEMPT_ENDS.get(context);\n}\n\n/** A failed attempt's thrown value, boxed: `undefined` is a value a stage may throw. */\ninterface Failure {\n  readonly error: unknown;\n}\n\n/**\n * Run `run` until it succeeds or the policy stops it; resolve with its value or reject with the LAST attempt's\n * own error. `run(n)` is called with the attempt number, 1-based.\n */\nexport async function runAttempts<T>(\n  run: (attempt: number, context: AttemptContext) => Promise<T> | T,\n  policy: RetryPolicy,\n  options: AttemptRunOptions,\n): Promise<T> {\n  const of = attemptCeiling(policy.attempts);\n  const rules = retryRules({ attempts: of });\n  const now = options.now ?? Date.now;\n  const deadline = readDeadline(options.deadline);\n  const ownCap = attemptTimeoutMs(policy.timeoutMs);\n  const tally = new SeriesTally();\n  if (options.effect) refuseKeylessRetry(options.effect, of);\n  /** An earlier attempt of this touching series left the effect unknown — a later answer of `none` cannot clear it. */\n  let unknownSoFar = false;\n\n  for (let attempt = 1; ; attempt++) {\n    const startedAt = now();\n    const live = new LiveAttempt(options, attempt, of, startedAt, deadline, ownCap, now);\n    let value: T | undefined;\n    let failure: Failure | undefined;\n    try {\n      const pending = run(attempt, live.context);\n      // Started under a signal that had ALREADY aborted (a decider entered after a cancel): its synchronous part\n      // ran as it always did; from here on nobody waits for it, so nothing it does after its first await lands.\n      if (live.context.signal.aborted) live.abandonStarted();\n      value = await (options.raced ? pending : live.race(pending));\n    } catch (error: unknown) {\n      failure = { error };\n    }\n    const durationMs = Math.max(0, now() - startedAt);\n    const outcome = outcomeOf(failure, options.signal, live.timeoutReason);\n    live.end(outcome);\n    const inputs = new AttemptInputReader(policy, options, attempt, of, outcome, failure, deadline, now);\n\n    let decision = decideAttempt(rules, inputs.read);\n    // 9.15 asked retryOn, THEN checked the signal. Deciding again reads the signal afresh: rule 3 now matches,\n    // ahead of every user function, so none is asked twice — and nothing is discarded, nothing waited for.\n    if (decision.next === 'retry' && isCancelled(options.signal)) decision = decideAttempt(rules, inputs.read);\n\n    // The discard comes BEFORE the wait's length is asked for, as it did in 9.15 — without a deadline. Under one,\n    // rule 6 needs the wait's length to decide, so `backoffMs` was asked during the decision, before the discard.\n    if (decision.next === 'retry') options.between?.(attempt);\n    const delayMs = decision.next === 'retry' ? inputs.delayMs() : inputs.delayIfAsked();\n    const timeLeftMs = deadline === undefined ? undefined : inputs.timeLeft();\n\n    const category = inputs.category();\n    // Private terminal semantics are fixed before serving or observer fan-out.\n    // An already-unresolved call wrapper must not become its physical cause\n    // if a consumer later changes the raw error's properties or prototype.\n    const terminal = options.onFailure && failure ? terminalCategory(failure.error, category) : category ?? 'unknown';\n    const served = inputs.failed ? (options.serve ?? extractErrorInfo)(inputs.failed.error) : undefined;\n    const effect = options.effect ? effectOf(inputs.outcome, failure?.error) : undefined;\n    const recordedKey = options.effect ? recordedKeyOf(options.effect) : undefined;\n    const record = freezeDeep<AttemptRecord>({\n      series: options.series,\n      kind: options.kind ?? 'stage',\n      ...(options.target !== undefined && { target: options.target }),\n      attempt,\n      of,\n      startedAt,\n      durationMs,\n      outcome: inputs.outcome,\n      ...(category !== undefined && { category }),\n      decision: decision.evidence,\n      next: decision.next,\n      reason: decision.reason,\n      ...(inputs.retryOnThrew && { retryOnThrew: true as const }),\n      ...(delayMs !== undefined && { delayMs }),\n      ...(live.capMs !== undefined && { timeoutMs: live.capMs }),\n      ...(timeLeftMs !== undefined && { timeLeftMs }),\n      ...(served !== undefined && { error: recordedError(served) }),\n      ...(options.effect !== undefined && { system: options.effect.system }),\n      ...(recordedKey !== undefined && { idempotencyKey: recordedKey }),\n      ...(effect !== undefined && { effect }),\n    });\n    tally.add(record);\n    if (record.effect === 'unknown') unknownSoFar = true;\n    if (record.next !== 'retry') options.onEnd?.(tally.summary(lastOf(record, unknownSoFar)));\n    options.onAttempt?.(record, served);\n\n    if (record.next === 'done') return value as T;\n    if (record.next === 'stop') throw stoppedFailure(options, record, failure, unknownSoFar, terminal);\n\n    options.onRetry?.(attempt, of, delayMs ?? 0, served as StructuredErrorInfo);\n    if (delayMs !== undefined && delayMs > 0) {\n      try {\n        await sleep(delayMs, options.signal);\n      } catch (error: unknown) {\n        options.onFailure?.(error, 'unknown');\n        throw error;\n      }\n    }\n    // No attempt follows a cut wait, so none is recorded: the summary says how the series ended. No attempt\n    // STARTS at or past the deadline either — rule 6 decided with the clock, and the clock may have moved on.\n    const cut = isCancelled(options.signal)\n      ? 'aborted'\n      : options.signal?.aborted || (deadline !== undefined && now() >= deadline)\n      ? 'no-time-left'\n      : undefined;\n    if (cut !== undefined) {\n      options.onEnd?.(tally.summary({ ...lastOf(record, unknownSoFar), next: 'stop', reason: cut }));\n      throw stoppedFailure(options, record, failure, unknownSoFar, terminal);\n    }\n  }\n}\n\n/** The final physical attempt owns its category; a wrapper or cut wait has no such category. */\nfunction stoppedFailure(\n  options: AttemptRunOptions,\n  record: AttemptRecord,\n  failure: Failure | undefined,\n  unknownSoFar: boolean,\n  terminal: AttemptCategory,\n): unknown {\n  const error = stopError(options.effect, record, failure, unknownSoFar);\n  if (record.outcome !== 'paused') {\n    const category = record.next === 'stop' && Object.is(error, failure?.error) ? terminal : 'unknown';\n    options.onFailure?.(error, category);\n  }\n  return error;\n}\n\n/**\n * What a stopped series throws: the last attempt's own error — or, on a touching target where ANY attempt left the\n * effect unknown, `UnknownEffectError` with the last attempt's error as its cause. An earlier timeout may have\n * applied the effect; a later attempt that says \"nothing was sent\" speaks for itself only, so it cannot turn the\n * series into a plain failure. A pause is never converted: it is control flow.\n */\nfunction stopError(\n  effect: EffectTarget | undefined,\n  record: AttemptRecord,\n  failure: Failure | undefined,\n  unknownSoFar: boolean,\n): unknown {\n  if (effect === undefined || !unknownSoFar || record.outcome === 'paused') return failure?.error;\n  return unknownEffectError(effect, record, failure?.error);\n}\n\n/**\n * One attempt in flight: its cap, its signal (the run's, composed with its own timer), and the fence. Its own\n * timer is armed when the policy's cap is SHORTER than the time left; at the deadline the run's own signal aborts,\n * with the deadline's reason (so a run rejects with the reason it always did). Everything it arms is released\n * when the attempt ends.\n */\nclass LiveAttempt {\n  readonly context: AttemptContext;\n  /** The cap this attempt runs under — `min(timeoutMs, time left)`, never negative; absent when uncapped. */\n  readonly capMs: number | undefined;\n  /** The reason the attempt's OWN timer aborted with — set only if it fired. */\n  timeoutReason: AttemptTimeoutError | undefined;\n  private readonly cancelTimer: (() => void) | undefined;\n  private readonly composed: { readonly signal: AbortSignal; dispose(): void };\n  private abandoned = false;\n  /** The attempt is over, however it ended — an `observed` report after this is the owner's to refuse. */\n  private ended = false;\n  private readonly onAbort = () => this.abandon();\n\n  constructor(\n    private readonly options: AttemptRunOptions,\n    private readonly attempt: number,\n    of: number,\n    startedAt: number,\n    deadline: number | undefined,\n    ownCap: number | undefined,\n    now: () => number,\n  ) {\n    const left = deadline === undefined ? Infinity : Math.max(0, deadline - startedAt);\n    const cap = Math.min(ownCap ?? Infinity, left);\n    this.capMs = Number.isFinite(cap) ? cap : undefined;\n    // Its own timer when its own cap is the shorter, or when no run signal will abort at the deadline (a caller\n    // with a deadline and no signal). Otherwise the run's signal ends it at the deadline, with the deadline's reason.\n    const ownTimer = this.capMs !== undefined && ((ownCap !== undefined && ownCap < left) || !options.signal);\n    const own = ownTimer ? new AbortController() : undefined;\n    if (own) {\n      const capMs = this.capMs as number;\n      this.cancelTimer = setLongTimeout(() => {\n        // A time limit, branded like the run's deadline: a call made inside this attempt that it cuts timed out.\n        this.timeoutReason = markTimeLimit(new AttemptTimeoutError(attempt, capMs));\n        own.abort(this.timeoutReason);\n      }, capMs);\n    }\n    this.composed = anySignal([options.signal, own?.signal]);\n    // Registered BEFORE the function runs, so the fence closes before any listener the function adds. A signal\n    // ALREADY aborted (a decider entered after a cancel — no abort check precedes it) does not fence the attempt\n    // before it runs: it runs as it did before the fence existed, and is fenced when it ends without an answer.\n    this.composed.signal.addEventListener('abort', this.onAbort, { once: true });\n    const signal = this.composed.signal;\n    const capMs = this.capMs;\n    this.context = Object.freeze({\n      series: options.series,\n      attempt,\n      of,\n      signal,\n      ...(deadline !== undefined && { deadline }),\n      ...(capMs !== undefined && { timeoutMs: capMs }),\n      ...(options.effect !== undefined && { system: options.effect.system }),\n      ...(options.effect?.idempotencyKey !== undefined && { idempotencyKey: options.effect.idempotencyKey }),\n      timeLeftMs: () => (deadline === undefined ? Infinity : deadline - now()),\n      observed: (report: ObservedAttempt) => {\n        if (!options.observe) {\n          throw new TypeError('observed(): report an outside attempt through `scope.$attempt().observed(...)`');\n        }\n        options.observe(report, { attempt, ended: this.ended });\n      },\n    });\n    if (capMs !== undefined) ATTEMPT_ENDS.set(this.context, startedAt + capMs);\n  }\n\n  /** `value`, or the attempt signal's reason the moment it aborts first — the engine stops waiting at the cap. */\n  race<T>(value: Promise<T> | T): Promise<T> | T {\n    if (!(value instanceof Promise)) return value;\n    const signal = this.composed.signal;\n    return new Promise<T>((resolve, reject) => {\n      const onAbort = () => reject(signal.reason);\n      value.then(\n        (v) => {\n          signal.removeEventListener('abort', onAbort);\n          resolve(v);\n        },\n        (e: unknown) => {\n          signal.removeEventListener('abort', onAbort);\n          reject(e);\n        },\n      );\n      // Already aborted (the function aborted it as it ran): a value that already settled still wins — its\n      // reaction was queued above, first — and a pending one is cut on the next microtask.\n      if (signal.aborted) queueMicrotask(onAbort);\n      else signal.addEventListener('abort', onAbort, { once: true });\n    });\n  }\n\n  /** The attempt is over: release the timer and the listeners; fence it if it ended without an answer. */\n  end(outcome: AttemptOutcome): void {\n    this.ended = true;\n    this.cancelTimer?.();\n    this.composed.signal.removeEventListener('abort', this.onAbort);\n    this.composed.dispose();\n    if (outcome !== 'ok' && outcome !== 'paused') this.abandon();\n  }\n\n  /** Fence an attempt that started under an already-aborted signal, once its synchronous part has run. */\n  abandonStarted(): void {\n    this.abandon();\n  }\n\n  private abandon(): void {\n    if (this.abandoned) return;\n    this.abandoned = true;\n    this.options.onAbandon?.(this.attempt);\n  }\n}\n\n/** The signal aborted at a time limit — the run's deadline, or a call's attempt cap — not by a cancellation. */\nfunction timedOut(signal: AbortSignal | undefined): boolean {\n  return signal?.aborted === true && isDeadlineReason(signal.reason);\n}\n\n/**\n * How the attempt itself ended. A thrown value is the attempt's own failure unless it IS what a signal aborted\n * with (StageRunner's race rejects with it; a stage may rethrow it): its own cap's `AttemptTimeoutError` or the\n * run's deadline → `'timeout'`; the run's cancellation → `'aborted'`.\n */\nfunction outcomeOf(\n  failure: Failure | undefined,\n  signal: AbortSignal | undefined,\n  timeoutReason: AttemptTimeoutError | undefined,\n): AttemptOutcome {\n  if (!failure) return 'ok';\n  // An `interrupt()` thrown inside a call is converted to a pause at the stage boundary, past this runner.\n  if (isPauseSignal(failure.error) || isInterruptSignal(failure.error)) return 'paused';\n  // Its own cap ran out — the attempt's timer is the one that fired, and the attempt threw what it aborted with.\n  if (timeoutReason !== undefined && failure.error === timeoutReason) return 'timeout';\n  if (signal?.aborted !== true || failure.error !== signal.reason) return 'failed';\n  // The run's signal ended it: at the deadline the attempt ran out of time (law 4); otherwise it was cancelled.\n  return isDeadlineReason(signal.reason) ? 'timeout' : 'aborted';\n}\n\n/**\n * One attempt's decision inputs, each read only when a rule reaches it (`decideAttempt`'s reader): the user's\n * `retryOn` and `backoffMs` run at most once each, and only when the 9.15 loop would have run them.\n */\nclass AttemptInputReader {\n  /** The failure a category and a served error are read from — none for `'ok'` and `'paused'`. */\n  readonly failed: Failure | undefined;\n  /** `true` once `retryOn` threw (its verdict is then `false`). */\n  retryOnThrew = false;\n  private retryOnVerdict: boolean | undefined;\n  private wait: number | undefined;\n  private failureCategory: AttemptCategory | undefined;\n  private categoryRead = false;\n\n  private left: number | undefined;\n\n  constructor(\n    private readonly policy: RetryPolicy,\n    private readonly options: AttemptRunOptions,\n    private readonly attempt: number,\n    private readonly of: number,\n    readonly outcome: AttemptOutcome,\n    failure: Failure | undefined,\n    private readonly deadline: number | undefined,\n    private readonly now: () => number,\n  ) {\n    this.failed = failure && outcome !== 'paused' ? failure : undefined;\n  }\n\n  /** One input by its `AttemptInputs` key. */\n  readonly read = (key: string): unknown => {\n    switch (key) {\n      case 'outcome':\n        return this.outcome;\n      case 'category':\n        return this.category();\n      case 'aborted':\n        // Live: a decision taken again after `retryOn` sees an abort raised inside it. The deadline is not a\n        // cancellation — rule 6 owns it.\n        return isCancelled(this.options.signal);\n      case 'attempt':\n        return this.attempt;\n      case 'of':\n        return this.of;\n      case 'timeLeftMs':\n        return this.timeLeft();\n      case 'timeLeftAfterWaitMs':\n        // Without a deadline the time left is unbounded, before any wait and after it — so deciding needs no\n        // wait, and `backoffMs` is asked after the discard, as in 9.15. Under one, the wait's length decides.\n        return this.unbounded() ? Infinity : this.timeLeft() - this.delayMs();\n      case 'delayMs':\n        return this.delayMs();\n      case 'retryOn':\n        return this.retryOn();\n      case 'keyPresent':\n        return this.options.effect?.idempotencyKey !== undefined;\n      default:\n        return undefined;\n    }\n  };\n\n  /** The failure's category, read once — at the first rule that asks, or after the decision. */\n  category(): AttemptCategory | undefined {\n    if (!this.categoryRead) {\n      this.categoryRead = true;\n      this.failureCategory = this.failed ? errorCategory(this.failed.error, this.outcome) : undefined;\n    }\n    return this.failureCategory;\n  }\n\n  /** The policy's wait after this attempt (`resolveBackoffMs`), asked once — capped at its `maxBackoffMs`. */\n  delayMs(): number {\n    return (this.wait ??= cappedWaitMs(\n      resolveBackoffMs(this.policy.backoffMs, this.attempt, this.failed?.error),\n      this.policy.maxBackoffMs,\n    ));\n  }\n\n  /** The wait, if the decision already asked for it (rule 6 under a deadline); never asks `backoffMs` itself. */\n  delayIfAsked(): number | undefined {\n    return this.wait;\n  }\n\n  /** Milliseconds before the deadline at the decision, read once (`Infinity` without one). */\n  timeLeft(): number {\n    if (this.unbounded()) return Infinity;\n    if (this.left === undefined) {\n      const clock = this.deadline === undefined ? Infinity : this.deadline - this.now();\n      // A time limit already reached — the signal aborted at the deadline (or, for a call, at its attempt's cap) —\n      // leaves no time, whatever the clock says: a host timer may fire a millisecond before the clock gets there.\n      this.left = timedOut(this.options.signal) ? Math.min(clock, 0) : clock;\n    }\n    return this.left;\n  }\n\n  /** No deadline and no time limit reached: the time left is `Infinity`, and no wait need be asked for. */\n  private unbounded(): boolean {\n    return this.deadline === undefined && !timedOut(this.options.signal);\n  }\n\n  /** The `retryOn` gate, asked once. A throwing predicate is \"do not retry\" — a broken one never loops. */\n  private retryOn(): boolean {\n    if (this.retryOnVerdict === undefined) this.retryOnVerdict = this.askRetryOn();\n    return this.retryOnVerdict;\n  }\n\n  private askRetryOn(): boolean {\n    if (!this.policy.retryOn) return true;\n    try {\n      return this.policy.retryOn(this.failed?.error) === true;\n    } catch (thrown) {\n      this.retryOnThrew = true;\n      this.options.onRetryOnThrew?.(thrown);\n      return false;\n    }\n  }\n}\n\n/**\n * Resolve a policy's `backoffMs` for the attempt that just failed (1-based) and its error. Anything that is not a finite,\n * positive number — a missing dial, a negative value, a `NaN` from a consumer's arithmetic, or a throwing\n * function — becomes `0`, i.e. retry immediately. A backoff dial must never be able to crash a run or park it\n * forever.\n */\nexport function resolveBackoffMs(backoffMs: RetryPolicy['backoffMs'], attempt: number, error?: unknown): number {\n  if (backoffMs === undefined) return 0;\n  let value: unknown;\n  if (typeof backoffMs === 'function') {\n    try {\n      value = backoffMs(attempt, error);\n    } catch {\n      return 0;\n    }\n  } else {\n    value = backoffMs;\n  }\n  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;\n}\n\n/**\n * Await `ms`, cut short by an abort. Resolves either way — the caller re-checks `signal.aborted` and rethrows\n * the attempt's own error, so a cancelled run never sits out a long backoff and never loses the failure that\n * caused it. The timer and the listener are always cleaned up.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  if (signal?.aborted) return Promise.resolve();\n  return new Promise<void>((resolve) => {\n    const done = () => {\n      cancel();\n      signal?.removeEventListener('abort', done);\n      resolve();\n    };\n    const cancel = setLongTimeout(done, ms);\n    signal?.addEventListener('abort', done, { once: true });\n  });\n}\n\n/**\n * How a record ended its series, as the summary's `last` says it. On a touching target the effect is the SERIES'\n * (`unknownSoFar`): unknown once any attempt left it unknown, unless the series ended with an answer.\n */\nfunction lastOf(record: AttemptRecord, unknownSoFar = false): AttemptSummary['last'] {\n  const effect = record.effect !== undefined && unknownSoFar && record.outcome !== 'ok' ? 'unknown' : record.effect;\n  return {\n    next: record.next as AttemptSummary['last']['next'],\n    reason: record.reason,\n    ...(record.category !== undefined && { category: record.category }),\n    ...(record.retryOnThrew && { retryOnThrew: true as const }),\n    ...(effect !== undefined && { effect }),\n  };\n}\n\n/** Per-outcome counts of a series, for its summary. */\nclass SeriesTally {\n  private readonly counts = { count: 0, ok: 0, failed: 0, timeout: 0, aborted: 0, paused: 0 };\n\n  add(record: AttemptRecord): void {\n    this.counts.count += 1;\n    this.counts[record.outcome] += 1;\n  }\n\n  summary(last: AttemptSummary['last']): AttemptSummary {\n    return freezeDeep<AttemptSummary>({ ...this.counts, last });\n  }\n}\n"]}