footprintjs 10.0.1 → 10.2.0

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

@@ -0,0 +1,83 @@
+/**
+ * attempt/policy.ts — the ONE reading of a `RetryPolicy`'s ceiling, and the ONE rule for a valid policy.
+ *
+ * `attemptCeiling` is how many attempts a policy allows. Three readers ask it, so they can never disagree about a
+ * stage: the engine's gate (`FlowchartTraverser · executeStage` — does this stage retry at all?), the runner
+ * (`runAttempts` — every record's `of`) and the rule table (`retryRules` — rule 4's threshold).
+ *
+ * `retryPolicyProblem` says why a declared policy is refused. Two doors ask it, with the same words: the builder
+ * at build (`FlowChartBuilder · applyRetryPolicy`), and the traverser for a StageNode a stage returns at run time
+ * (`FlowchartTraverser · admitDynamicNodes`), which the builder never saw.
+ */
+/**
+ * The attempts a policy allows: its whole number (a fraction is floored, as the 9.15 loop read it), and never
+ * fewer than one. Anything that is not a finite number of at least one — `NaN`, `Infinity`, `0`, a negative, a
+ * non-number — is `1`: a broken ceiling never loops.
+ */
+export function attemptCeiling(attempts) {
+    const whole = typeof attempts === 'number' ? Math.floor(attempts) : NaN;
+    return Number.isFinite(whole) && whole >= 1 ? whole : 1;
+}
+/**
+ * Why `retry` is refused, or `undefined` when it is a valid policy: `attempts` must be a whole number ≥ 1, a
+ * declared `timeoutMs` a finite number > 0, and a declared `maxBackoffMs` a finite number ≥ 0. `attempts: 1` is
+ * valid on purpose — a policy declared but switched off (or, with a `timeoutMs`, a timeout with no retry).
+ */
+export function retryPolicyProblem(retry) {
+    const { attempts, timeoutMs, maxBackoffMs } = retry;
+    if (!(typeof attempts === 'number' && Number.isInteger(attempts) && attempts >= 1)) {
+        return (`retry.attempts must be a whole number >= 1 (got ${String(attempts)}). ` +
+            'It counts TOTAL runs including the first, so `attempts: 3` means one run plus up to two retries; ' +
+            '`attempts: 1` means the policy is declared but currently off.');
+    }
+    if (timeoutMs !== undefined && attemptTimeoutMs(timeoutMs) === undefined) {
+        return (`retry.timeoutMs must be a finite number of milliseconds > 0 (got ${String(timeoutMs)}). ` +
+            'It caps ONE attempt; leave it out for an uncapped attempt.');
+    }
+    if (maxBackoffMs !== undefined && backoffCeilingMs(maxBackoffMs) === undefined) {
+        return (`retry.maxBackoffMs must be a finite number of milliseconds >= 0 (got ${String(maxBackoffMs)}). ` +
+            'It caps every wait between attempts; leave it out for an uncapped wait.');
+    }
+    return undefined;
+}
+/**
+ * The ceiling a policy puts on ONE wait (`maxBackoffMs`): a finite number ≥ 0, else none. The runner caps every
+ * wait at it (`waitAfter`), and the static budget check counts each wait at it — one reading, so the check's bound
+ * is the runner's law.
+ */
+export function backoffCeilingMs(maxBackoffMs) {
+    return typeof maxBackoffMs === 'number' && Number.isFinite(maxBackoffMs) && maxBackoffMs >= 0
+        ? maxBackoffMs
+        : undefined;
+}
+/** A wait the policy's `backoffMs` answered (already defended, `resolveBackoffMs`), capped at its declared ceiling. */
+export function cappedWaitMs(waitMs, maxBackoffMs) {
+    const ceiling = backoffCeilingMs(maxBackoffMs);
+    return ceiling === undefined ? waitMs : Math.min(waitMs, ceiling);
+}
+/**
+ * The cap a policy puts on one attempt: a finite number > 0, else none. The one reading the engine's gate and the
+ * runner share (the builder refuses any other declared value, `retryPolicyProblem`).
+ */
+export function attemptTimeoutMs(timeoutMs) {
+    return typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+}
+/** The policy of a call made with none: one attempt — still recorded (a single call is evidence too). */
+export const SINGLE_CALL = Object.freeze({ attempts: 1 });
+/**
+ * A `$call` / `attempt()` policy as the caller handed it: absent means {@link SINGLE_CALL}; anything else must be a
+ * valid `RetryPolicy` (`retryPolicyProblem`) or it is refused with a `TypeError` naming `where` — at the call,
+ * before anything runs.
+ */
+export function admitCallPolicy(where, policy) {
+    if (policy === undefined)
+        return SINGLE_CALL;
+    if (policy === null || typeof policy !== 'object') {
+        throw new TypeError(`${where}: the policy must be a RetryPolicy object ({ attempts, timeoutMs?, backoffMs?, retryOn? })`);
+    }
+    const problem = retryPolicyProblem(policy);
+    if (problem !== undefined)
+        throw new TypeError(`${where}: ${problem}`);
+    return policy;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../../../src/lib/attempt/policy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/policy.ts — the ONE reading of a `RetryPolicy`'s ceiling, and the ONE rule for a valid policy.\n *\n * `attemptCeiling` is how many attempts a policy allows. Three readers ask it, so they can never disagree about a\n * stage: the engine's gate (`FlowchartTraverser · executeStage` — does this stage retry at all?), the runner\n * (`runAttempts` — every record's `of`) and the rule table (`retryRules` — rule 4's threshold).\n *\n * `retryPolicyProblem` says why a declared policy is refused. Two doors ask it, with the same words: the builder\n * at build (`FlowChartBuilder · applyRetryPolicy`), and the traverser for a StageNode a stage returns at run time\n * (`FlowchartTraverser · admitDynamicNodes`), which the builder never saw.\n */\n\nimport type { RetryPolicy } from './types.js';\n\n/**\n * The attempts a policy allows: its whole number (a fraction is floored, as the 9.15 loop read it), and never\n * fewer than one. Anything that is not a finite number of at least one — `NaN`, `Infinity`, `0`, a negative, a\n * non-number — is `1`: a broken ceiling never loops.\n */\nexport function attemptCeiling(attempts: unknown): number {\n  const whole = typeof attempts === 'number' ? Math.floor(attempts) : NaN;\n  return Number.isFinite(whole) && whole >= 1 ? whole : 1;\n}\n\n/**\n * Why `retry` is refused, or `undefined` when it is a valid policy: `attempts` must be a whole number ≥ 1, a\n * declared `timeoutMs` a finite number > 0, and a declared `maxBackoffMs` a finite number ≥ 0. `attempts: 1` is\n * valid on purpose — a policy declared but switched off (or, with a `timeoutMs`, a timeout with no retry).\n */\nexport function retryPolicyProblem(\n  retry: Pick<RetryPolicy, 'attempts' | 'timeoutMs' | 'maxBackoffMs'>,\n): string | undefined {\n  const { attempts, timeoutMs, maxBackoffMs } = retry;\n  if (!(typeof attempts === 'number' && Number.isInteger(attempts) && attempts >= 1)) {\n    return (\n      `retry.attempts must be a whole number >= 1 (got ${String(attempts)}). ` +\n      'It counts TOTAL runs including the first, so `attempts: 3` means one run plus up to two retries; ' +\n      '`attempts: 1` means the policy is declared but currently off.'\n    );\n  }\n  if (timeoutMs !== undefined && attemptTimeoutMs(timeoutMs) === undefined) {\n    return (\n      `retry.timeoutMs must be a finite number of milliseconds > 0 (got ${String(timeoutMs)}). ` +\n      'It caps ONE attempt; leave it out for an uncapped attempt.'\n    );\n  }\n  if (maxBackoffMs !== undefined && backoffCeilingMs(maxBackoffMs) === undefined) {\n    return (\n      `retry.maxBackoffMs must be a finite number of milliseconds >= 0 (got ${String(maxBackoffMs)}). ` +\n      'It caps every wait between attempts; leave it out for an uncapped wait.'\n    );\n  }\n  return undefined;\n}\n\n/**\n * The ceiling a policy puts on ONE wait (`maxBackoffMs`): a finite number ≥ 0, else none. The runner caps every\n * wait at it (`waitAfter`), and the static budget check counts each wait at it — one reading, so the check's bound\n * is the runner's law.\n */\nexport function backoffCeilingMs(maxBackoffMs: unknown): number | undefined {\n  return typeof maxBackoffMs === 'number' && Number.isFinite(maxBackoffMs) && maxBackoffMs >= 0\n    ? maxBackoffMs\n    : undefined;\n}\n\n/** A wait the policy's `backoffMs` answered (already defended, `resolveBackoffMs`), capped at its declared ceiling. */\nexport function cappedWaitMs(waitMs: number, maxBackoffMs: unknown): number {\n  const ceiling = backoffCeilingMs(maxBackoffMs);\n  return ceiling === undefined ? waitMs : Math.min(waitMs, ceiling);\n}\n\n/**\n * The cap a policy puts on one attempt: a finite number > 0, else none. The one reading the engine's gate and the\n * runner share (the builder refuses any other declared value, `retryPolicyProblem`).\n */\nexport function attemptTimeoutMs(timeoutMs: unknown): number | undefined {\n  return typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;\n}\n\n/** The policy of a call made with none: one attempt — still recorded (a single call is evidence too). */\nexport const SINGLE_CALL: RetryPolicy = Object.freeze({ attempts: 1 });\n\n/**\n * A `$call` / `attempt()` policy as the caller handed it: absent means {@link SINGLE_CALL}; anything else must be a\n * valid `RetryPolicy` (`retryPolicyProblem`) or it is refused with a `TypeError` naming `where` — at the call,\n * before anything runs.\n */\nexport function admitCallPolicy(where: string, policy: unknown): RetryPolicy {\n  if (policy === undefined) return SINGLE_CALL;\n  if (policy === null || typeof policy !== 'object') {\n    throw new TypeError(\n      `${where}: the policy must be a RetryPolicy object ({ attempts, timeoutMs?, backoffMs?, retryOn? })`,\n    );\n  }\n  const problem = retryPolicyProblem(policy as RetryPolicy);\n  if (problem !== undefined) throw new TypeError(`${where}: ${problem}`);\n  return policy as RetryPolicy;\n}\n"]}

package/dist/esm/lib/attempt/record.d.ts

@@ -0,0 +1,11 @@
+/**
+ * attempt/record.ts — how an `AttemptRecord` holds what it holds: frozen to its leaves, and an error only as the run
+ * SERVES it, named fields only. One owner, so a record the runner makes (`runner.ts`) and a record an adapter
+ * reports (`observed.ts`) can never differ in what they keep.
+ */
+import type { StructuredErrorInfo } from '../errors/errorInfo.js';
+import type { AttemptError } from './types.js';
+/** The record's copy of a served error: its named fields only — never `raw`, never an extra own key. */
+export declare function recordedError(served: StructuredErrorInfo): AttemptError;
+/** Freeze a record built of plain objects and arrays, to its leaves. */
+export declare function freezeDeep<T>(value: T): T;

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

@@ -0,0 +1,24 @@
+/**
+ * attempt/record.ts — how an `AttemptRecord` holds what it holds: frozen to its leaves, and an error only as the run
+ * SERVES it, named fields only. One owner, so a record the runner makes (`runner.ts`) and a record an adapter
+ * reports (`observed.ts`) can never differ in what they keep.
+ */
+/** The record's copy of a served error: its named fields only — never `raw`, never an extra own key. */
+export function recordedError(served) {
+    return {
+        message: served.message,
+        ...(served.name !== undefined && { name: served.name }),
+        ...(served.code !== undefined && { code: served.code }),
+        ...(served.issues !== undefined && { issues: served.issues.map((issue) => ({ ...issue, path: [...issue.path] })) }),
+    };
+}
+/** Freeze a record built of plain objects and arrays, to its leaves. */
+export function freezeDeep(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const key of Object.keys(value))
+            freezeDeep(value[key]);
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/attempt/retryLoopContext.d.ts

@@ -0,0 +1,18 @@
+/** Internal one-call port: the builder declares logical identity; the call owner stamps it before dispatch. */
+import type { RetryLoopCall } from './retryLoopTypes.js';
+import type { AttemptRecord } from './types.js';
+export interface RetryLoopCallPort {
+    readonly identity: RetryLoopCall;
+    readonly record: (record: AttemptRecord) => void;
+}
+export declare function registerRetryLoopCall(target: object, port: RetryLoopCallPort): () => void;
+/** Claimed once, so nested calls made by the user's callback do not inherit the outer call's logical identity. */
+export declare function takeRetryLoopCall(target: object): RetryLoopCallPort | undefined;
+export interface RetryLoopBudget {
+    readonly passes?: number;
+    readonly role: 'callback' | 'control' | 'wait';
+    readonly timeoutMs?: number;
+    readonly waitMs?: number;
+}
+export declare function declareRetryLoopBudget(node: object, budget: RetryLoopBudget): void;
+export declare function retryLoopBudget(node: object): RetryLoopBudget | undefined;

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

@@ -0,0 +1,24 @@
+const calls = new WeakMap();
+export function registerRetryLoopCall(target, port) {
+    if (calls.has(target))
+        throw new Error('retry loop: another call is already being prepared on this scope');
+    calls.set(target, port);
+    return () => {
+        if (calls.get(target) === port)
+            calls.delete(target);
+    };
+}
+/** Claimed once, so nested calls made by the user's callback do not inherit the outer call's logical identity. */
+export function takeRetryLoopCall(target) {
+    const port = calls.get(target);
+    calls.delete(target);
+    return port;
+}
+const budgets = new WeakMap();
+export function declareRetryLoopBudget(node, budget) {
+    budgets.set(node, Object.freeze({ ...budget }));
+}
+export function retryLoopBudget(node) {
+    return budgets.get(node);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/attempt/retryLoopTypes.d.ts

@@ -0,0 +1,18 @@
+/** Logical identity of an explicit retry workflow. Physical attempt identities remain unchanged. */
+export interface RetryLoopIdentity {
+    readonly id: string;
+    readonly series: string;
+    readonly attempt: number;
+    readonly of: number;
+}
+/** The role of one physical call inside a logical pass. */
+export interface RetryLoopCall extends RetryLoopIdentity {
+    readonly phase: 'attempt' | 'reconcile';
+}
+/** The explicit chart decision, after reconciliation; never rewrites a physical call's outcome. */
+export interface RetryLoopDecision extends RetryLoopIdentity {
+    readonly effect: 'applied' | 'none' | 'unknown';
+    readonly reconciled: boolean;
+    readonly next: 'retry' | 'done' | 'stop';
+    readonly reason: string;
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cnlMb29wVHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2F0dGVtcHQvcmV0cnlMb29wVHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBMb2dpY2FsIGlkZW50aXR5IG9mIGFuIGV4cGxpY2l0IHJldHJ5IHdvcmtmbG93LiBQaHlzaWNhbCBhdHRlbXB0IGlkZW50aXRpZXMgcmVtYWluIHVuY2hhbmdlZC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmV0cnlMb29wSWRlbnRpdHkge1xuICByZWFkb25seSBpZDogc3RyaW5nO1xuICByZWFkb25seSBzZXJpZXM6IHN0cmluZztcbiAgcmVhZG9ubHkgYXR0ZW1wdDogbnVtYmVyO1xuICByZWFkb25seSBvZjogbnVtYmVyO1xufVxuXG4vKiogVGhlIHJvbGUgb2Ygb25lIHBoeXNpY2FsIGNhbGwgaW5zaWRlIGEgbG9naWNhbCBwYXNzLiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZXRyeUxvb3BDYWxsIGV4dGVuZHMgUmV0cnlMb29wSWRlbnRpdHkge1xuICByZWFkb25seSBwaGFzZTogJ2F0dGVtcHQnIHwgJ3JlY29uY2lsZSc7XG59XG5cbi8qKiBUaGUgZXhwbGljaXQgY2hhcnQgZGVjaXNpb24sIGFmdGVyIHJlY29uY2lsaWF0aW9uOyBuZXZlciByZXdyaXRlcyBhIHBoeXNpY2FsIGNhbGwncyBvdXRjb21lLiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZXRyeUxvb3BEZWNpc2lvbiBleHRlbmRzIFJldHJ5TG9vcElkZW50aXR5IHtcbiAgcmVhZG9ubHkgZWZmZWN0OiAnYXBwbGllZCcgfCAnbm9uZScgfCAndW5rbm93bic7XG4gIHJlYWRvbmx5IHJlY29uY2lsZWQ6IGJvb2xlYW47XG4gIHJlYWRvbmx5IG5leHQ6ICdyZXRyeScgfCAnZG9uZScgfCAnc3RvcCc7XG4gIHJlYWRvbmx5IHJlYXNvbjogc3RyaW5nO1xufVxuIl19

package/dist/esm/lib/attempt/runner.d.ts

@@ -0,0 +1,157 @@
+/**
+ * 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 type { StructuredErrorInfo } from '../errors/errorInfo.js';
+import type { EffectTarget } from './effect.js';
+import type { AttemptCategory, AttemptContext, AttemptKind, AttemptRecord, AttemptSummary, ObservedAttempt, RetryPolicy } from './types.js';
+/** What a series reports, and the engine's between-attempt step. Every member is optional. */
+export interface AttemptRunOptions {
+    /** The series every record names — for a stage attempt, its execution's `runtimeStageId`. */
+    readonly series: string;
+    /** Default `'stage'`. */
+    readonly kind?: AttemptKind;
+    /** The outside target every record names — a call's (`$call`, `attempt()`); absent for a stage attempt. */
+    readonly target?: string;
+    /**
+     * The run's signal. Once it has aborted (other than at the deadline), rule 3 stops the series
+     * (`reason: 'aborted'`); it cuts a wait short. An attempt that threw its reason is recorded `'aborted'` — or
+     * `'timeout'` when the reason is the deadline's (`attempt/deadline.ts`).
+     */
+    readonly signal?: AbortSignal;
+    /**
+     * The run's deadline, epoch milliseconds. Every attempt is capped by the time left; rule 6 stops a series whose
+     * next wait would outlast it (`no-time-left`). Absent (or not finite) = no deadline: the time left is `Infinity`.
+     */
+    readonly deadline?: number;
+    /** The clock, epoch milliseconds. Default `Date.now`. */
+    readonly now?: () => number;
+    /** The served form of a failed attempt's error. Default `extractErrorInfo` (no redaction rule). */
+    readonly serve?: (error: unknown) => StructuredErrorInfo;
+    /** Between a failed attempt and the next, before `backoffMs`: the engine discards the attempt's staged writes. */
+    readonly between?: (attempt: number) => void;
+    /** Every attempt, at its end, with its served error (`undefined` for `'ok'` and `'paused'`). */
+    readonly onAttempt?: (record: AttemptRecord, structuredError: StructuredErrorInfo | undefined) => void;
+    /** A failed attempt that WILL be retried — after `between` and `onAttempt`, before the wait. */
+    readonly onRetry?: (attempt: number, of: number, delayMs: number, structuredError: StructuredErrorInfo) => void;
+    /** The series ended: called once, before the last `onAttempt` (or after a wait the run's signal cut). */
+    readonly onEnd?: (summary: AttemptSummary) => void;
+    /** @internal Native owner only: the exact escaping value and category, before its stage serves the error. */
+    readonly onFailure?: (error: unknown, category: AttemptCategory) => void;
+    /** `retryOn` threw — the attempt is treated as declined; the engine logs the throw here. */
+    readonly onRetryOnThrew?: (thrown: unknown) => void;
+    /**
+     * The attempt ended without an answer — called SYNCHRONOUSLY the moment its signal aborts (its cap, the deadline,
+     * a cancellation), else as soon as it failed. Whatever the abandoned function does afterwards is not this
+     * series': the engine fences its scope here. Once per attempt; never for `'ok'` or `'paused'` — except an attempt
+     * that STARTED under an already-aborted signal, fenced once its synchronous part has run (nobody waits for it).
+     */
+    readonly onAbandon?: (attempt: number) => void;
+    /**
+     * The caller races `run`'s promise against the attempt's signal itself — the engine does, at the stage boundary
+     * (`StageRunner`), so a stage keeps its one await per attempt. Otherwise the runner races it: the series never
+     * waits on an attempt past its cap.
+     */
+    readonly raced?: boolean;
+    /**
+     * What an attempt's `observed(report)` does (P2) — the owner of the attempt records the report: `runCall` hands
+     * a call's reports to the scope, `attempt()` keeps its own. `ended` says the attempt had already ended when the
+     * report came (the owner drops it). Absent — a stage attempt's context, whose `observed` the scope's
+     * `$attempt()` replaces — `observed` is refused with a `TypeError`.
+     */
+    readonly observe?: (report: ObservedAttempt, at: {
+        readonly attempt: number;
+        readonly ended: boolean;
+    }) => void;
+    /**
+     * The outside system the target touches (P3, design §3.3). Every record then says what its attempt did to it
+     * (`effect`) and names the system and the RECORDED key; every attempt's context carries the REAL key. A series
+     * that ends without an answer after any attempt of unknown effect fails with `UnknownEffectError` (its `cause` the attempt's own error) —
+     * except a pause, which stays a pause. A touching series that may retry without a key is refused before anything
+     * runs: the law's last door.
+     */
+    readonly effect?: EffectTarget;
+}
+/**
+ * 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 declare function attemptEndsAt(context: AttemptContext | undefined): number | undefined;
+/**
+ * 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 declare function runAttempts<T>(run: (attempt: number, context: AttemptContext) => Promise<T> | T, policy: RetryPolicy, options: AttemptRunOptions): Promise<T>;
+/**
+ * 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 declare function resolveBackoffMs(backoffMs: RetryPolicy['backoffMs'], attempt: number, error?: unknown): number;
+/**
+ * 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 declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;