footprintjs 10.0.1 → 10.2.0

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

@@ -0,0 +1,41 @@
+/**
+ * attempt/errors.ts — the errors the attempt contract throws (design §3.3).
+ *
+ * - `AttemptTimeoutError` — the attempt's OWN timer ended it (`RetryPolicy.timeoutMs` / the run's deadline). A
+ *   timeout is the absence of an answer, not a failure of the outside system (law 4); `errorCategory` reads it
+ *   as `'timeout'`.
+ * - `UnknownEffectError` — a side-effecting target's last attempt ended with no answer, so nobody knows whether
+ *   the effect happened. "Reconcile, do not retry blindly" is on the error, not in prose.
+ *
+ * The idempotency key is a VALUE: it rides the error as a field (a redaction rule selects it by name) and is
+ * never spelled in a message.
+ */
+/** The attempt's own time cap ran out before it answered. */
+export declare class AttemptTimeoutError extends Error {
+    /** The attempt that ran out of time, 1-based. */
+    readonly attempt: number;
+    /** The cap it ran under, in milliseconds. */
+    readonly timeoutMs: number;
+    constructor(attempt: number, timeoutMs: number, options?: {
+        readonly cause?: unknown;
+    });
+}
+/** What an `UnknownEffectError` names. */
+export interface UnknownEffectInit {
+    /** The outside system the stage touches — a name, never a value. */
+    readonly system: string;
+    /** The key the effect was attempted under — a value, kept as a field and never put in the message. */
+    readonly idempotencyKey?: string;
+    /** How many attempts ran. */
+    readonly attempts: number;
+    /** The last attempt's own error. */
+    readonly cause?: unknown;
+}
+/** A side-effecting target's last attempt ended with no answer: whether the effect happened is unknown. */
+export declare class UnknownEffectError extends Error {
+    readonly system: string;
+    /** Absent (not `undefined`) when no key was given — `declare`, so no class field is emitted for it. */
+    readonly idempotencyKey?: string;
+    readonly attempts: number;
+    constructor(init: UnknownEffectInit);
+}

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

@@ -0,0 +1,44 @@
+/**
+ * attempt/errors.ts — the errors the attempt contract throws (design §3.3).
+ *
+ * - `AttemptTimeoutError` — the attempt's OWN timer ended it (`RetryPolicy.timeoutMs` / the run's deadline). A
+ *   timeout is the absence of an answer, not a failure of the outside system (law 4); `errorCategory` reads it
+ *   as `'timeout'`.
+ * - `UnknownEffectError` — a side-effecting target's last attempt ended with no answer, so nobody knows whether
+ *   the effect happened. "Reconcile, do not retry blindly" is on the error, not in prose.
+ *
+ * The idempotency key is a VALUE: it rides the error as a field (a redaction rule selects it by name) and is
+ * never spelled in a message.
+ */
+/** The attempt's own time cap ran out before it answered. */
+export class AttemptTimeoutError extends Error {
+    /** The attempt that ran out of time, 1-based. */
+    attempt;
+    /** The cap it ran under, in milliseconds. */
+    timeoutMs;
+    constructor(attempt, timeoutMs, options) {
+        super(`attempt ${attempt} ran out of its ${timeoutMs}ms before it answered`);
+        this.name = 'AttemptTimeoutError';
+        this.attempt = attempt;
+        this.timeoutMs = timeoutMs;
+        if (options && Object.prototype.hasOwnProperty.call(options, 'cause'))
+            this.cause = options.cause;
+    }
+}
+/** A side-effecting target's last attempt ended with no answer: whether the effect happened is unknown. */
+export class UnknownEffectError extends Error {
+    system;
+    attempts;
+    constructor(init) {
+        super(`"${init.system}": the effect of attempt ${init.attempts} is unknown — reconcile with the system ` +
+            '(look the operation up by its idempotency key) before trying again');
+        this.name = 'UnknownEffectError';
+        this.system = init.system;
+        if (init.idempotencyKey !== undefined)
+            this.idempotencyKey = init.idempotencyKey;
+        this.attempts = init.attempts;
+        if (Object.prototype.hasOwnProperty.call(init, 'cause'))
+            this.cause = init.cause;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+/**
+ * attempt/ — one runner, one record: every attempt the library runs is an `AttemptRecord` with the
+ * retry-or-stop decision that followed it (design docs/design/2026-10-time-and-failure-evidence.md).
+ *
+ * Public: the record's vocabulary, the one failure classifier, the one rule table, the two errors, and `attempt()`
+ * — the runner for code that is not a stage (P2). The loop itself (`runAttempts`), `runCall`, the evidence builder
+ * and `anySignal` are the engine's. `RetryPolicy` is declared in
+ * `./types.ts` and published through the builder's barrel, where it always was.
+ */
+export { errorCategory } from './category.js';
+export type { ParsedTraceparent, TraceparentFields, TraceparentRefusal } from './correlation.js';
+export { formatTraceparent, parseTraceparent, TraceparentError } from './correlation.js';
+export { retryRules } from './decision.js';
+export type { UnknownEffectInit } from './errors.js';
+export { AttemptTimeoutError, UnknownEffectError } from './errors.js';
+export type { AttemptOptions } from './standalone.js';
+export { attempt } from './standalone.js';
+export type { AttemptCategory, AttemptContext, AttemptEffect, AttemptError, AttemptInputs, AttemptKind, AttemptNext, AttemptOutcome, AttemptReason, AttemptRecord, AttemptSummary, CallOptions, IdempotencyKeyContext, LateWrite, ObservedAttempt, RunCorrelation, StageTouches, } from './types.js';

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

@@ -0,0 +1,15 @@
+/**
+ * attempt/ — one runner, one record: every attempt the library runs is an `AttemptRecord` with the
+ * retry-or-stop decision that followed it (design docs/design/2026-10-time-and-failure-evidence.md).
+ *
+ * Public: the record's vocabulary, the one failure classifier, the one rule table, the two errors, and `attempt()`
+ * — the runner for code that is not a stage (P2). The loop itself (`runAttempts`), `runCall`, the evidence builder
+ * and `anySignal` are the engine's. `RetryPolicy` is declared in
+ * `./types.ts` and published through the builder's barrel, where it always was.
+ */
+export { errorCategory } from './category.js';
+export { formatTraceparent, parseTraceparent, TraceparentError } from './correlation.js';
+export { retryRules } from './decision.js';
+export { AttemptTimeoutError, UnknownEffectError } from './errors.js';
+export { attempt } from './standalone.js';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+/**
+ * attempt/name.ts — the ONE rule for a name an attempt record carries (design §3.6, threat model, packet P2): the
+ * target of a `$call` / `attempt()`, a standalone series, and an observed report's target and source.
+ *
+ * A target is a NAME from code — `'stripe.quotes.create'` — never from a model and never a value. It rides every
+ * record, narrative line, recorder row and metric key exactly as given, so a name is refused unless it is a string
+ * of 1–{@link MAX_NAME_LENGTH} characters, not blank, with no control (C0, DEL, C1), format (zero-width, bidi
+ * overrides), surrogate, line/paragraph-separator, private-use or noncharacter code point:
+ *   - an empty or blank name names nothing;
+ *   - an overlong one is a value, or a flood of one;
+ *   - a control or separator character forges a narrative line or a log record, and a bidi override hides what a
+ *     line says.
+ * The refusal names the FIELD, never the value (P4's precedent): a rejected name may be exactly what must not be
+ * echoed. A `TypeError`, because a malformed name is the caller's code breaking its contract.
+ */
+/** The longest name an attempt record carries. */
+export declare const MAX_NAME_LENGTH = 128;
+/** Why `value` is not a name, or `undefined` when it is one. */
+export declare function attemptNameProblem(value: unknown): string | undefined;
+/** `value` as a name, or a `TypeError` that names `where` and `field` (never the value). */
+export declare function admitAttemptName(where: string, field: string, value: unknown): string;

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

@@ -0,0 +1,43 @@
+/**
+ * attempt/name.ts — the ONE rule for a name an attempt record carries (design §3.6, threat model, packet P2): the
+ * target of a `$call` / `attempt()`, a standalone series, and an observed report's target and source.
+ *
+ * A target is a NAME from code — `'stripe.quotes.create'` — never from a model and never a value. It rides every
+ * record, narrative line, recorder row and metric key exactly as given, so a name is refused unless it is a string
+ * of 1–{@link MAX_NAME_LENGTH} characters, not blank, with no control (C0, DEL, C1), format (zero-width, bidi
+ * overrides), surrogate, line/paragraph-separator, private-use or noncharacter code point:
+ *   - an empty or blank name names nothing;
+ *   - an overlong one is a value, or a flood of one;
+ *   - a control or separator character forges a narrative line or a log record, and a bidi override hides what a
+ *     line says.
+ * The refusal names the FIELD, never the value (P4's precedent): a rejected name may be exactly what must not be
+ * echoed. A `TypeError`, because a malformed name is the caller's code breaking its contract.
+ */
+/** The longest name an attempt record carries. */
+export const MAX_NAME_LENGTH = 128;
+/**
+ * Control, format, surrogate, line/paragraph-separator, private-use and noncharacter code points — none may sit in a
+ * name.
+ */
+const FORBIDDEN = /[\p{Cc}\p{Cf}\p{Cs}\p{Zl}\p{Zp}\p{Co}\p{Noncharacter_Code_Point}]/u;
+/** Why `value` is not a name, or `undefined` when it is one. */
+export function attemptNameProblem(value) {
+    if (typeof value !== 'string')
+        return 'must be a string';
+    if (value.trim().length === 0)
+        return 'must not be empty or blank';
+    if (value.length > MAX_NAME_LENGTH)
+        return `must be at most ${MAX_NAME_LENGTH} characters`;
+    if (FORBIDDEN.test(value))
+        return 'must not contain control, format or line-separator characters';
+    return undefined;
+}
+/** `value` as a name, or a `TypeError` that names `where` and `field` (never the value). */
+export function admitAttemptName(where, field, value) {
+    const problem = attemptNameProblem(value);
+    if (problem !== undefined) {
+        throw new TypeError(`${where}: ${field} ${problem} — it is a name from code, never a value`);
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,66 @@
+/**
+ * attempt/observed.ts — an attempt the library did NOT run: an outside system's own retry (an SDK's), reported by an
+ * adapter through `AttemptContext.observed` (design §3.6, packet P2). Same record shape, kind `'observed'`.
+ *
+ * WHY: the incident behind this design was four 40 s attempts inside an SDK that the record called "one stage, one
+ * error". The best fix is one loop — the SDK's retries off, the call under `scope.$call`. Where an SDK must keep its
+ * retries, its adapter reports each one here, so the record says what happened rather than nothing.
+ *
+ * THREE LAWS.
+ *   - A report is read, never trusted. Only the named fields are read, each ONCE (a getter cannot answer twice);
+ *     a name is held to the one name rule (`name.ts`); numbers must be what they say. Anything else on the
+ *     object — a request body, headers — is never read, so it can never reach a record ({@link readObservedReport}).
+ *   - The error is served under the run's redaction rule (the owner's `serve`), like every attempt's error; the
+ *     record keeps its named fields, and no hook is handed the adapter's error object (`raw` is dropped: the
+ *     library never threw it, and an SDK error can carry its request).
+ *   - An observed attempt never changes control flow. Its `decision` is the ONE rule table read over what the
+ *     report states, under the default policy (every error retryable, no deadline) — the library's reading of the
+ *     SDK's attempt, never the SDK's own decision, which the record cannot know. A report without `of` stands for
+ *     the SDK's whole call: it is its last attempt, so a failure reads `exhausted`.
+ *
+ * SERIES. Reports are grouped by {@link ObservedSeriesBook}, owned by whoever owns the attempt they were reported
+ * on: a growing attempt number continues its target's series; a number that does not grow opens a new one (the
+ * SDK started another call).
+ */
+import type { StructuredErrorInfo } from '../errors/errorInfo.js';
+import type { AttemptOutcome, AttemptRecord } from './types.js';
+/** A report as read: every field once, validated, defaults applied. */
+export interface ObservedReport {
+    readonly target: string;
+    readonly source: string;
+    readonly attempt: number;
+    readonly of?: number;
+    readonly outcome: Exclude<AttemptOutcome, 'paused'>;
+    readonly durationMs: number;
+    readonly startedAt?: number;
+    readonly error?: unknown;
+}
+/**
+ * Read an adapter's report: the named fields only, each once. A malformed report is refused with a `TypeError`
+ * naming the field (never its value).
+ */
+export declare function readObservedReport(report: unknown): ObservedReport;
+/** What turns a report into a record — the owner's series, clock and served-error rule. */
+export interface ObservedRecordInit {
+    readonly series: string;
+    readonly now: () => number;
+    readonly serve: (error: unknown) => StructuredErrorInfo;
+}
+/** The frozen record of a report, and the served error (with `raw`) the `onAttempt` hook carries. */
+export declare function observedRecord(report: ObservedReport, init: ObservedRecordInit): {
+    record: AttemptRecord;
+    structuredError?: StructuredErrorInfo;
+};
+/** How many distinct target/source pairs one attempt's book remembers — past it, each report opens its own series. */
+export declare const MAX_OPEN_OBSERVED_SERIES = 256;
+/**
+ * Groups one attempt's observed reports into series. A report continues the open series of its target and source
+ * while its attempt number grows; otherwise it opens a new one through `open` (the owner's next call-level series).
+ * Bounded: it remembers at most {@link MAX_OPEN_OBSERVED_SERIES} names.
+ */
+export declare class ObservedSeriesBook {
+    private readonly openSeries;
+    private readonly open;
+    constructor(openSeries: () => string);
+    seriesFor(report: Pick<ObservedReport, 'target' | 'source' | 'attempt'>): string;
+}

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

@@ -0,0 +1,171 @@
+/**
+ * attempt/observed.ts — an attempt the library did NOT run: an outside system's own retry (an SDK's), reported by an
+ * adapter through `AttemptContext.observed` (design §3.6, packet P2). Same record shape, kind `'observed'`.
+ *
+ * WHY: the incident behind this design was four 40 s attempts inside an SDK that the record called "one stage, one
+ * error". The best fix is one loop — the SDK's retries off, the call under `scope.$call`. Where an SDK must keep its
+ * retries, its adapter reports each one here, so the record says what happened rather than nothing.
+ *
+ * THREE LAWS.
+ *   - A report is read, never trusted. Only the named fields are read, each ONCE (a getter cannot answer twice);
+ *     a name is held to the one name rule (`name.ts`); numbers must be what they say. Anything else on the
+ *     object — a request body, headers — is never read, so it can never reach a record ({@link readObservedReport}).
+ *   - The error is served under the run's redaction rule (the owner's `serve`), like every attempt's error; the
+ *     record keeps its named fields, and no hook is handed the adapter's error object (`raw` is dropped: the
+ *     library never threw it, and an SDK error can carry its request).
+ *   - An observed attempt never changes control flow. Its `decision` is the ONE rule table read over what the
+ *     report states, under the default policy (every error retryable, no deadline) — the library's reading of the
+ *     SDK's attempt, never the SDK's own decision, which the record cannot know. A report without `of` stands for
+ *     the SDK's whole call: it is its last attempt, so a failure reads `exhausted`.
+ *
+ * SERIES. Reports are grouped by {@link ObservedSeriesBook}, owned by whoever owns the attempt they were reported
+ * on: a growing attempt number continues its target's series; a number that does not grow opens a new one (the
+ * SDK started another call).
+ */
+import { errorCategory } from './category.js';
+import { decideAttempt, retryRules } from './decision.js';
+import { admitAttemptName } from './name.js';
+import { freezeDeep, recordedError } from './record.js';
+/** The outcomes a report may state — an SDK cannot pause a flowchart. */
+const OUTCOMES = new Set(['ok', 'failed', 'timeout', 'aborted']);
+const WHERE = 'observed()';
+/**
+ * Read an adapter's report: the named fields only, each once. A malformed report is refused with a `TypeError`
+ * naming the field (never its value).
+ */
+export function readObservedReport(report) {
+    if (report === null || typeof report !== 'object')
+        throw new TypeError(`${WHERE}: the report must be an object`);
+    const field = (name) => {
+        try {
+            return report[name];
+        }
+        catch (cause) {
+            throw new TypeError(`${WHERE}: the report's ${name} could not be read`, { cause });
+        }
+    };
+    const target = admitAttemptName(WHERE, 'target', field('target'));
+    const rawSource = field('source');
+    const source = rawSource === undefined ? 'sdk' : admitAttemptName(WHERE, 'source', rawSource);
+    const rawAttempt = field('attempt');
+    const attempt = rawAttempt === undefined ? 1 : count('attempt', rawAttempt);
+    const rawOf = field('of');
+    const of = rawOf === undefined ? undefined : count('of', rawOf);
+    if (of !== undefined && of < attempt)
+        throw new TypeError(`${WHERE}: of must be at least attempt`);
+    const outcome = field('outcome');
+    if (typeof outcome !== 'string' || !OUTCOMES.has(outcome)) {
+        throw new TypeError(`${WHERE}: outcome must be one of 'ok', 'failed', 'timeout', 'aborted'`);
+    }
+    const durationMs = field('durationMs');
+    if (typeof durationMs !== 'number' || !Number.isFinite(durationMs) || durationMs < 0) {
+        throw new TypeError(`${WHERE}: durationMs must be a finite number >= 0`);
+    }
+    const startedAt = field('startedAt');
+    if (startedAt !== undefined && (typeof startedAt !== 'number' || !Number.isFinite(startedAt))) {
+        throw new TypeError(`${WHERE}: startedAt must be a finite number (epoch ms)`);
+    }
+    const error = field('error');
+    return {
+        target,
+        source,
+        attempt,
+        ...(of !== undefined && { of }),
+        outcome: outcome,
+        durationMs,
+        ...(startedAt !== undefined && { startedAt: startedAt }),
+        ...(error !== undefined && { error }),
+    };
+}
+function count(name, value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
+        throw new TypeError(`${WHERE}: ${name} must be a whole number >= 1`);
+    }
+    return value;
+}
+/** The frozen record of a report, and the served error (with `raw`) the `onAttempt` hook carries. */
+export function observedRecord(report, init) {
+    const failed = report.outcome !== 'ok';
+    const category = failed ? errorCategory(report.error, report.outcome) : undefined;
+    const served = failed && report.error !== undefined ? withoutRaw(init.serve(report.error)) : undefined;
+    const decision = decideAttempt(retryRules({ attempts: report.of ?? report.attempt }), (key) => readInput(report, category, key));
+    const record = freezeDeep({
+        series: init.series,
+        kind: 'observed',
+        target: report.target,
+        source: report.source,
+        attempt: report.attempt,
+        ...(report.of !== undefined && { of: report.of }),
+        startedAt: report.startedAt ?? init.now() - report.durationMs,
+        durationMs: report.durationMs,
+        outcome: report.outcome,
+        ...(category !== undefined && { category }),
+        decision: decision.evidence,
+        next: decision.next,
+        reason: decision.reason,
+        ...(served !== undefined && { error: recordedError(served) }),
+    });
+    return { record, ...(served !== undefined && { structuredError: served }) };
+}
+/**
+ * The served error without `raw`: the library never threw an adapter's error, and an SDK error can carry its
+ * request (headers, body) — so no hook is handed the value itself, only its served, named fields.
+ */
+function withoutRaw(served) {
+    return { ...served, raw: undefined };
+}
+/** The rule table's inputs as the report states them, under the default policy (no deadline, every error retryable). */
+function readInput(report, category, key) {
+    switch (key) {
+        case 'outcome':
+            return report.outcome;
+        case 'category':
+            return category;
+        case 'aborted':
+            return report.outcome === 'aborted';
+        case 'attempt':
+            return report.attempt;
+        case 'of':
+            return report.of ?? report.attempt;
+        case 'timeLeftMs':
+        case 'timeLeftAfterWaitMs':
+            return Infinity;
+        case 'delayMs':
+            return 0;
+        case 'retryOn':
+            return true;
+        case 'keyPresent':
+            return false;
+        default:
+            return undefined;
+    }
+}
+/** How many distinct target/source pairs one attempt's book remembers — past it, each report opens its own series. */
+export const MAX_OPEN_OBSERVED_SERIES = 256;
+/**
+ * Groups one attempt's observed reports into series. A report continues the open series of its target and source
+ * while its attempt number grows; otherwise it opens a new one through `open` (the owner's next call-level series).
+ * Bounded: it remembers at most {@link MAX_OPEN_OBSERVED_SERIES} names.
+ */
+export class ObservedSeriesBook {
+    openSeries;
+    open = new Map();
+    constructor(openSeries) {
+        this.openSeries = openSeries;
+    }
+    seriesFor(report) {
+        // Names hold no control character, so NUL cannot occur in either: the key is unambiguous.
+        const key = `${report.source}\u0000${report.target}`;
+        const current = this.open.get(key);
+        if (current !== undefined && report.attempt > current.last) {
+            current.last = report.attempt;
+            return current.series;
+        }
+        const series = this.openSeries();
+        if (current !== undefined || this.open.size < MAX_OPEN_OBSERVED_SERIES) {
+            this.open.set(key, { series, last: report.attempt });
+        }
+        return series;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observed.js","sourceRoot":"","sources":["../../../../src/lib/attempt/observed.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/observed.ts — an attempt the library did NOT run: an outside system's own retry (an SDK's), reported by an\n * adapter through `AttemptContext.observed` (design §3.6, packet P2). Same record shape, kind `'observed'`.\n *\n * WHY: the incident behind this design was four 40 s attempts inside an SDK that the record called \"one stage, one\n * error\". The best fix is one loop — the SDK's retries off, the call under `scope.$call`. Where an SDK must keep its\n * retries, its adapter reports each one here, so the record says what happened rather than nothing.\n *\n * THREE LAWS.\n *   - A report is read, never trusted. Only the named fields are read, each ONCE (a getter cannot answer twice);\n *     a name is held to the one name rule (`name.ts`); numbers must be what they say. Anything else on the\n *     object — a request body, headers — is never read, so it can never reach a record ({@link readObservedReport}).\n *   - The error is served under the run's redaction rule (the owner's `serve`), like every attempt's error; the\n *     record keeps its named fields, and no hook is handed the adapter's error object (`raw` is dropped: the\n *     library never threw it, and an SDK error can carry its request).\n *   - An observed attempt never changes control flow. Its `decision` is the ONE rule table read over what the\n *     report states, under the default policy (every error retryable, no deadline) — the library's reading of the\n *     SDK's attempt, never the SDK's own decision, which the record cannot know. A report without `of` stands for\n *     the SDK's whole call: it is its last attempt, so a failure reads `exhausted`.\n *\n * SERIES. Reports are grouped by {@link ObservedSeriesBook}, owned by whoever owns the attempt they were reported\n * on: a growing attempt number continues its target's series; a number that does not grow opens a new one (the\n * SDK started another call).\n */\n\nimport type { StructuredErrorInfo } from '../errors/errorInfo.js';\nimport { errorCategory } from './category.js';\nimport { decideAttempt, retryRules } from './decision.js';\nimport { admitAttemptName } from './name.js';\nimport { freezeDeep, recordedError } from './record.js';\nimport type { AttemptCategory, AttemptOutcome, AttemptRecord } from './types.js';\n\n/** The outcomes a report may state — an SDK cannot pause a flowchart. */\nconst OUTCOMES: ReadonlySet<string> = new Set<AttemptOutcome>(['ok', 'failed', 'timeout', 'aborted']);\n\nconst WHERE = 'observed()';\n\n/** A report as read: every field once, validated, defaults applied. */\nexport interface ObservedReport {\n  readonly target: string;\n  readonly source: string;\n  readonly attempt: number;\n  readonly of?: number;\n  readonly outcome: Exclude<AttemptOutcome, 'paused'>;\n  readonly durationMs: number;\n  readonly startedAt?: number;\n  readonly error?: unknown;\n}\n\n/**\n * Read an adapter's report: the named fields only, each once. A malformed report is refused with a `TypeError`\n * naming the field (never its value).\n */\nexport function readObservedReport(report: unknown): ObservedReport {\n  if (report === null || typeof report !== 'object') throw new TypeError(`${WHERE}: the report must be an object`);\n  const field = (name: string): unknown => {\n    try {\n      return (report as Record<string, unknown>)[name];\n    } catch (cause) {\n      throw new TypeError(`${WHERE}: the report's ${name} could not be read`, { cause });\n    }\n  };\n  const target = admitAttemptName(WHERE, 'target', field('target'));\n  const rawSource = field('source');\n  const source = rawSource === undefined ? 'sdk' : admitAttemptName(WHERE, 'source', rawSource);\n  const rawAttempt = field('attempt');\n  const attempt = rawAttempt === undefined ? 1 : count('attempt', rawAttempt);\n  const rawOf = field('of');\n  const of = rawOf === undefined ? undefined : count('of', rawOf);\n  if (of !== undefined && of < attempt) throw new TypeError(`${WHERE}: of must be at least attempt`);\n  const outcome = field('outcome');\n  if (typeof outcome !== 'string' || !OUTCOMES.has(outcome)) {\n    throw new TypeError(`${WHERE}: outcome must be one of 'ok', 'failed', 'timeout', 'aborted'`);\n  }\n  const durationMs = field('durationMs');\n  if (typeof durationMs !== 'number' || !Number.isFinite(durationMs) || durationMs < 0) {\n    throw new TypeError(`${WHERE}: durationMs must be a finite number >= 0`);\n  }\n  const startedAt = field('startedAt');\n  if (startedAt !== undefined && (typeof startedAt !== 'number' || !Number.isFinite(startedAt))) {\n    throw new TypeError(`${WHERE}: startedAt must be a finite number (epoch ms)`);\n  }\n  const error = field('error');\n  return {\n    target,\n    source,\n    attempt,\n    ...(of !== undefined && { of }),\n    outcome: outcome as ObservedReport['outcome'],\n    durationMs,\n    ...(startedAt !== undefined && { startedAt: startedAt as number }),\n    ...(error !== undefined && { error }),\n  };\n}\n\nfunction count(name: string, value: unknown): number {\n  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {\n    throw new TypeError(`${WHERE}: ${name} must be a whole number >= 1`);\n  }\n  return value;\n}\n\n/** What turns a report into a record — the owner's series, clock and served-error rule. */\nexport interface ObservedRecordInit {\n  readonly series: string;\n  readonly now: () => number;\n  readonly serve: (error: unknown) => StructuredErrorInfo;\n}\n\n/** The frozen record of a report, and the served error (with `raw`) the `onAttempt` hook carries. */\nexport function observedRecord(\n  report: ObservedReport,\n  init: ObservedRecordInit,\n): { record: AttemptRecord; structuredError?: StructuredErrorInfo } {\n  const failed = report.outcome !== 'ok';\n  const category: AttemptCategory | undefined = failed ? errorCategory(report.error, report.outcome) : undefined;\n  const served = failed && report.error !== undefined ? withoutRaw(init.serve(report.error)) : undefined;\n  const decision = decideAttempt(retryRules({ attempts: report.of ?? report.attempt }), (key) =>\n    readInput(report, category, key),\n  );\n  const record = freezeDeep<AttemptRecord>({\n    series: init.series,\n    kind: 'observed',\n    target: report.target,\n    source: report.source,\n    attempt: report.attempt,\n    ...(report.of !== undefined && { of: report.of }),\n    startedAt: report.startedAt ?? init.now() - report.durationMs,\n    durationMs: report.durationMs,\n    outcome: report.outcome,\n    ...(category !== undefined && { category }),\n    decision: decision.evidence,\n    next: decision.next,\n    reason: decision.reason,\n    ...(served !== undefined && { error: recordedError(served) }),\n  });\n  return { record, ...(served !== undefined && { structuredError: served }) };\n}\n\n/**\n * The served error without `raw`: the library never threw an adapter's error, and an SDK error can carry its\n * request (headers, body) — so no hook is handed the value itself, only its served, named fields.\n */\nfunction withoutRaw(served: StructuredErrorInfo): StructuredErrorInfo {\n  return { ...served, raw: undefined };\n}\n\n/** The rule table's inputs as the report states them, under the default policy (no deadline, every error retryable). */\nfunction readInput(report: ObservedReport, category: AttemptCategory | undefined, key: string): unknown {\n  switch (key) {\n    case 'outcome':\n      return report.outcome;\n    case 'category':\n      return category;\n    case 'aborted':\n      return report.outcome === 'aborted';\n    case 'attempt':\n      return report.attempt;\n    case 'of':\n      return report.of ?? report.attempt;\n    case 'timeLeftMs':\n    case 'timeLeftAfterWaitMs':\n      return Infinity;\n    case 'delayMs':\n      return 0;\n    case 'retryOn':\n      return true;\n    case 'keyPresent':\n      return false;\n    default:\n      return undefined;\n  }\n}\n\n/** How many distinct target/source pairs one attempt's book remembers — past it, each report opens its own series. */\nexport const MAX_OPEN_OBSERVED_SERIES = 256;\n\n/**\n * Groups one attempt's observed reports into series. A report continues the open series of its target and source\n * while its attempt number grows; otherwise it opens a new one through `open` (the owner's next call-level series).\n * Bounded: it remembers at most {@link MAX_OPEN_OBSERVED_SERIES} names.\n */\nexport class ObservedSeriesBook {\n  private readonly open = new Map<string, { series: string; last: number }>();\n\n  constructor(private readonly openSeries: () => string) {}\n\n  seriesFor(report: Pick<ObservedReport, 'target' | 'source' | 'attempt'>): string {\n    // Names hold no control character, so NUL cannot occur in either: the key is unambiguous.\n    const key = `${report.source}\\u0000${report.target}`;\n    const current = this.open.get(key);\n    if (current !== undefined && report.attempt > current.last) {\n      current.last = report.attempt;\n      return current.series;\n    }\n    const series = this.openSeries();\n    if (current !== undefined || this.open.size < MAX_OPEN_OBSERVED_SERIES) {\n      this.open.set(key, { series, last: report.attempt });\n    }\n    return series;\n  }\n}\n"]}

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

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+import type { RetryPolicy } from './types.js';
+/**
+ * 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 declare function attemptCeiling(attempts: unknown): number;
+/**
+ * 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 declare function retryPolicyProblem(retry: Pick<RetryPolicy, 'attempts' | 'timeoutMs' | 'maxBackoffMs'>): string | 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 declare function backoffCeilingMs(maxBackoffMs: unknown): number | undefined;
+/** A wait the policy's `backoffMs` answered (already defended, `resolveBackoffMs`), capped at its declared ceiling. */
+export declare function cappedWaitMs(waitMs: number, maxBackoffMs: unknown): number;
+/**
+ * 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 declare function attemptTimeoutMs(timeoutMs: unknown): number | undefined;
+/** The policy of a call made with none: one attempt — still recorded (a single call is evidence too). */
+export declare const SINGLE_CALL: RetryPolicy;
+/**
+ * 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 declare function admitCallPolicy(where: string, policy: unknown): RetryPolicy;