footprintjs 10.0.1 → 10.2.0

package/dist/lib/attempt/name.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.admitAttemptName = exports.attemptNameProblem = exports.MAX_NAME_LENGTH = void 0;
+/** The longest name an attempt record carries. */
+exports.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. */
+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 > exports.MAX_NAME_LENGTH)
+        return `must be at most ${exports.MAX_NAME_LENGTH} characters`;
+    if (FORBIDDEN.test(value))
+        return 'must not contain control, format or line-separator characters';
+    return undefined;
+}
+exports.attemptNameProblem = attemptNameProblem;
+/** `value` as a name, or a `TypeError` that names `where` and `field` (never the value). */
+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;
+}
+exports.admitAttemptName = admitAttemptName;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/attempt/observed.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservedSeriesBook = exports.MAX_OPEN_OBSERVED_SERIES = exports.observedRecord = exports.readObservedReport = void 0;
+const category_js_1 = require("./category.js");
+const decision_js_1 = require("./decision.js");
+const name_js_1 = require("./name.js");
+const record_js_1 = require("./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).
+ */
+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 = (0, name_js_1.admitAttemptName)(WHERE, 'target', field('target'));
+    const rawSource = field('source');
+    const source = rawSource === undefined ? 'sdk' : (0, name_js_1.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 }),
+    };
+}
+exports.readObservedReport = readObservedReport;
+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. */
+function observedRecord(report, init) {
+    const failed = report.outcome !== 'ok';
+    const category = failed ? (0, category_js_1.errorCategory)(report.error, report.outcome) : undefined;
+    const served = failed && report.error !== undefined ? withoutRaw(init.serve(report.error)) : undefined;
+    const decision = (0, decision_js_1.decideAttempt)((0, decision_js_1.retryRules)({ attempts: report.of ?? report.attempt }), (key) => readInput(report, category, key));
+    const record = (0, record_js_1.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: (0, record_js_1.recordedError)(served) }),
+    });
+    return { record, ...(served !== undefined && { structuredError: served }) };
+}
+exports.observedRecord = observedRecord;
+/**
+ * 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. */
+exports.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.
+ */
+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 < exports.MAX_OPEN_OBSERVED_SERIES) {
+            this.open.set(key, { series, last: report.attempt });
+        }
+        return series;
+    }
+}
+exports.ObservedSeriesBook = ObservedSeriesBook;
+//# 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/lib/attempt/policy.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.admitCallPolicy = exports.SINGLE_CALL = exports.attemptTimeoutMs = exports.cappedWaitMs = exports.backoffCeilingMs = exports.retryPolicyProblem = exports.attemptCeiling = void 0;
+/**
+ * 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.
+ */
+function attemptCeiling(attempts) {
+    const whole = typeof attempts === 'number' ? Math.floor(attempts) : NaN;
+    return Number.isFinite(whole) && whole >= 1 ? whole : 1;
+}
+exports.attemptCeiling = attemptCeiling;
+/**
+ * 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).
+ */
+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;
+}
+exports.retryPolicyProblem = retryPolicyProblem;
+/**
+ * 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.
+ */
+function backoffCeilingMs(maxBackoffMs) {
+    return typeof maxBackoffMs === 'number' && Number.isFinite(maxBackoffMs) && maxBackoffMs >= 0
+        ? maxBackoffMs
+        : undefined;
+}
+exports.backoffCeilingMs = backoffCeilingMs;
+/** A wait the policy's `backoffMs` answered (already defended, `resolveBackoffMs`), capped at its declared ceiling. */
+function cappedWaitMs(waitMs, maxBackoffMs) {
+    const ceiling = backoffCeilingMs(maxBackoffMs);
+    return ceiling === undefined ? waitMs : Math.min(waitMs, ceiling);
+}
+exports.cappedWaitMs = cappedWaitMs;
+/**
+ * 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`).
+ */
+function attemptTimeoutMs(timeoutMs) {
+    return typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+}
+exports.attemptTimeoutMs = attemptTimeoutMs;
+/** The policy of a call made with none: one attempt — still recorded (a single call is evidence too). */
+exports.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.
+ */
+function admitCallPolicy(where, policy) {
+    if (policy === undefined)
+        return exports.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;
+}
+exports.admitCallPolicy = admitCallPolicy;
+//# 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/lib/attempt/record.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freezeDeep = exports.recordedError = void 0;
+/** The record's copy of a served error: its named fields only — never `raw`, never an extra own key. */
+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] })) }),
+    };
+}
+exports.recordedError = recordedError;
+/** Freeze a record built of plain objects and arrays, to its leaves. */
+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;
+}
+exports.freezeDeep = freezeDeep;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/attempt/retryLoopContext.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryLoopBudget = exports.declareRetryLoopBudget = exports.takeRetryLoopCall = exports.registerRetryLoopCall = void 0;
+const calls = new WeakMap();
+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);
+    };
+}
+exports.registerRetryLoopCall = registerRetryLoopCall;
+/** Claimed once, so nested calls made by the user's callback do not inherit the outer call's logical identity. */
+function takeRetryLoopCall(target) {
+    const port = calls.get(target);
+    calls.delete(target);
+    return port;
+}
+exports.takeRetryLoopCall = takeRetryLoopCall;
+const budgets = new WeakMap();
+function declareRetryLoopBudget(node, budget) {
+    budgets.set(node, Object.freeze({ ...budget }));
+}
+exports.declareRetryLoopBudget = declareRetryLoopBudget;
+function retryLoopBudget(node) {
+    return budgets.get(node);
+}
+exports.retryLoopBudget = retryLoopBudget;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/attempt/retryLoopTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cnlMb29wVHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2F0dGVtcHQvcmV0cnlMb29wVHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBMb2dpY2FsIGlkZW50aXR5IG9mIGFuIGV4cGxpY2l0IHJldHJ5IHdvcmtmbG93LiBQaHlzaWNhbCBhdHRlbXB0IGlkZW50aXRpZXMgcmVtYWluIHVuY2hhbmdlZC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmV0cnlMb29wSWRlbnRpdHkge1xuICByZWFkb25seSBpZDogc3RyaW5nO1xuICByZWFkb25seSBzZXJpZXM6IHN0cmluZztcbiAgcmVhZG9ubHkgYXR0ZW1wdDogbnVtYmVyO1xuICByZWFkb25seSBvZjogbnVtYmVyO1xufVxuXG4vKiogVGhlIHJvbGUgb2Ygb25lIHBoeXNpY2FsIGNhbGwgaW5zaWRlIGEgbG9naWNhbCBwYXNzLiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZXRyeUxvb3BDYWxsIGV4dGVuZHMgUmV0cnlMb29wSWRlbnRpdHkge1xuICByZWFkb25seSBwaGFzZTogJ2F0dGVtcHQnIHwgJ3JlY29uY2lsZSc7XG59XG5cbi8qKiBUaGUgZXhwbGljaXQgY2hhcnQgZGVjaXNpb24sIGFmdGVyIHJlY29uY2lsaWF0aW9uOyBuZXZlciByZXdyaXRlcyBhIHBoeXNpY2FsIGNhbGwncyBvdXRjb21lLiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZXRyeUxvb3BEZWNpc2lvbiBleHRlbmRzIFJldHJ5TG9vcElkZW50aXR5IHtcbiAgcmVhZG9ubHkgZWZmZWN0OiAnYXBwbGllZCcgfCAnbm9uZScgfCAndW5rbm93bic7XG4gIHJlYWRvbmx5IHJlY29uY2lsZWQ6IGJvb2xlYW47XG4gIHJlYWRvbmx5IG5leHQ6ICdyZXRyeScgfCAnZG9uZScgfCAnc3RvcCc7XG4gIHJlYWRvbmx5IHJlYXNvbjogc3RyaW5nO1xufVxuIl19