footprintjs 10.0.1 → 10.2.0

package/dist/lib/attempt/deadline.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * attempt/deadline.ts — what the run's deadline IS, to everything that reads time (design §3.1, law 3).
+ *
+ * The deadline is one number, epoch milliseconds (`env.deadline`); the executor arms the run's signal to abort when
+ * it passes (`runner/deadline.ts · armRun`). Reaching it is NOT a cancellation: an attempt the deadline cuts short
+ * timed out (it had no answer in the time it had — law 4), and the series stops `no-time-left`, not `aborted`. So
+ * the reason the run's signal aborts with at the deadline is BRANDED here, and the attempt runner tells the two
+ * apart by the brand — never by the message, never by the clock.
+ *
+ * The brand is a module-private WeakSet: an ordinary `Error` (same message, same name a run with `timeoutMs` always
+ * rejected with), recognisable only by identity.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.armDeadline = exports.isAbortSignal = exports.setLongTimeout = exports.readDeadline = exports.isCancelled = exports.isDeadlineReason = exports.markTimeLimit = exports.deadlineReason = void 0;
+const anySignal_js_1 = require("./anySignal.js");
+const DEADLINE_REASONS = new WeakSet();
+/** The reason the run's signal aborts with when its deadline passes — an `Error`, branded as the deadline's. */
+function deadlineReason(message) {
+    const reason = new Error(message);
+    DEADLINE_REASONS.add(reason);
+    return reason;
+}
+exports.deadlineReason = deadlineReason;
+/**
+ * Brand `reason` as a time limit — what an attempt's own cap aborts with (P2). An attempt's cap is the deadline of
+ * every call made inside it (`attempt/call.ts`), so a call it cuts ran out of time: `'timeout'`, never `'aborted'`.
+ * The run's own signal never aborts with it, so a stage attempt reads nothing new.
+ */
+function markTimeLimit(reason) {
+    DEADLINE_REASONS.add(reason);
+    return reason;
+}
+exports.markTimeLimit = markTimeLimit;
+/** Whether `reason` is the run's deadline or an attempt's cap — a time limit, not a cancellation. */
+function isDeadlineReason(reason) {
+    return typeof reason === 'object' && reason !== null && DEADLINE_REASONS.has(reason);
+}
+exports.isDeadlineReason = isDeadlineReason;
+/** Whether the signal aborted for a reason OTHER than a time limit — a cancellation. */
+function isCancelled(signal) {
+    return signal?.aborted === true && !isDeadlineReason(signal.reason);
+}
+exports.isCancelled = isCancelled;
+/** A deadline as the engine reads one: a finite number (epoch ms), else none. */
+function readDeadline(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+exports.readDeadline = readDeadline;
+/** The longest delay a host timer honours (2^31 − 1 ms, ~24.8 days); a longer one fires at once. */
+const MAX_TIMER_MS = 2_147_483_647;
+/**
+ * `setTimeout` for any delay: a delay past the host's limit is waited in chunks, so a 30-day deadline does not fire
+ * in a millisecond. Returns the one call that cancels it.
+ */
+function setLongTimeout(fn, ms) {
+    let timer;
+    let cancelled = false;
+    const arm = (left) => {
+        timer = setTimeout(() => {
+            if (cancelled)
+                return;
+            if (left > MAX_TIMER_MS)
+                arm(left - MAX_TIMER_MS);
+            else
+                fn();
+        }, Math.min(left, MAX_TIMER_MS));
+    };
+    arm(Math.max(0, ms));
+    return () => {
+        cancelled = true;
+        if (timer !== undefined)
+            clearTimeout(timer);
+    };
+}
+exports.setLongTimeout = setLongTimeout;
+/** Whether `value` is an AbortSignal (structurally — a signal from another realm counts). */
+function isAbortSignal(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.aborted === 'boolean' &&
+        typeof value.addEventListener === 'function' &&
+        typeof value.removeEventListener === 'function');
+}
+exports.isAbortSignal = isAbortSignal;
+/**
+ * Compose `signal` with a timer that aborts at `deadline` (epoch ms) with a branded {@link deadlineReason} — so the
+ * attempt runner's reading holds: the signal it is handed aborts at the deadline, as the run's does (`armRun`). A
+ * deadline already past aborts at once; without a deadline the signal is handed back as it is.
+ */
+function armDeadline(signal, deadline, message, now = Date.now) {
+    if (deadline === undefined)
+        return { signal, dispose: () => undefined };
+    const timer = new AbortController();
+    const composed = (0, anySignal_js_1.anySignal)([signal, timer.signal]);
+    const reason = deadlineReason(message);
+    const left = deadline - now();
+    let cancel = () => undefined;
+    if (left <= 0)
+        timer.abort(reason);
+    else
+        cancel = setLongTimeout(() => timer.abort(reason), left);
+    return {
+        signal: composed.signal,
+        dispose: () => {
+            cancel();
+            composed.dispose();
+        },
+    };
+}
+exports.armDeadline = armDeadline;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deadline.js","sourceRoot":"","sources":["../../../src/lib/attempt/deadline.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/deadline.ts — what the run's deadline IS, to everything that reads time (design §3.1, law 3).\n *\n * The deadline is one number, epoch milliseconds (`env.deadline`); the executor arms the run's signal to abort when\n * it passes (`runner/deadline.ts · armRun`). Reaching it is NOT a cancellation: an attempt the deadline cuts short\n * timed out (it had no answer in the time it had — law 4), and the series stops `no-time-left`, not `aborted`. So\n * the reason the run's signal aborts with at the deadline is BRANDED here, and the attempt runner tells the two\n * apart by the brand — never by the message, never by the clock.\n *\n * The brand is a module-private WeakSet: an ordinary `Error` (same message, same name a run with `timeoutMs` always\n * rejected with), recognisable only by identity.\n */\n\nimport { anySignal } from './anySignal.js';\n\nconst DEADLINE_REASONS = new WeakSet<object>();\n\n/** The reason the run's signal aborts with when its deadline passes — an `Error`, branded as the deadline's. */\nexport function deadlineReason(message: string): Error {\n  const reason = new Error(message);\n  DEADLINE_REASONS.add(reason);\n  return reason;\n}\n\n/**\n * Brand `reason` as a time limit — what an attempt's own cap aborts with (P2). An attempt's cap is the deadline of\n * every call made inside it (`attempt/call.ts`), so a call it cuts ran out of time: `'timeout'`, never `'aborted'`.\n * The run's own signal never aborts with it, so a stage attempt reads nothing new.\n */\nexport function markTimeLimit<T extends object>(reason: T): T {\n  DEADLINE_REASONS.add(reason);\n  return reason;\n}\n\n/** Whether `reason` is the run's deadline or an attempt's cap — a time limit, not a cancellation. */\nexport function isDeadlineReason(reason: unknown): boolean {\n  return typeof reason === 'object' && reason !== null && DEADLINE_REASONS.has(reason);\n}\n\n/** Whether the signal aborted for a reason OTHER than a time limit — a cancellation. */\nexport function isCancelled(signal: AbortSignal | undefined): boolean {\n  return signal?.aborted === true && !isDeadlineReason(signal.reason);\n}\n\n/** A deadline as the engine reads one: a finite number (epoch ms), else none. */\nexport function readDeadline(value: unknown): number | undefined {\n  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n}\n\n/** The longest delay a host timer honours (2^31 − 1 ms, ~24.8 days); a longer one fires at once. */\nconst MAX_TIMER_MS = 2_147_483_647;\n\n/**\n * `setTimeout` for any delay: a delay past the host's limit is waited in chunks, so a 30-day deadline does not fire\n * in a millisecond. Returns the one call that cancels it.\n */\nexport function setLongTimeout(fn: () => void, ms: number): () => void {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  let cancelled = false;\n  const arm = (left: number) => {\n    timer = setTimeout(() => {\n      if (cancelled) return;\n      if (left > MAX_TIMER_MS) arm(left - MAX_TIMER_MS);\n      else fn();\n    }, Math.min(left, MAX_TIMER_MS));\n  };\n  arm(Math.max(0, ms));\n  return () => {\n    cancelled = true;\n    if (timer !== undefined) clearTimeout(timer);\n  };\n}\n\n/** Whether `value` is an AbortSignal (structurally — a signal from another realm counts). */\nexport function isAbortSignal(value: unknown): value is AbortSignal {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as AbortSignal).aborted === 'boolean' &&\n    typeof (value as AbortSignal).addEventListener === 'function' &&\n    typeof (value as AbortSignal).removeEventListener === 'function'\n  );\n}\n\n/** A signal that aborts at a deadline (or with its input), and the one call that releases both. */\nexport interface ArmedDeadline {\n  readonly signal: AbortSignal | undefined;\n  dispose(): void;\n}\n\n/**\n * Compose `signal` with a timer that aborts at `deadline` (epoch ms) with a branded {@link deadlineReason} — so the\n * attempt runner's reading holds: the signal it is handed aborts at the deadline, as the run's does (`armRun`). A\n * deadline already past aborts at once; without a deadline the signal is handed back as it is.\n */\nexport function armDeadline(\n  signal: AbortSignal | undefined,\n  deadline: number | undefined,\n  message: string,\n  now: () => number = Date.now,\n): ArmedDeadline {\n  if (deadline === undefined) return { signal, dispose: () => undefined };\n  const timer = new AbortController();\n  const composed = anySignal([signal, timer.signal]);\n  const reason = deadlineReason(message);\n  const left = deadline - now();\n  let cancel: () => void = () => undefined;\n  if (left <= 0) timer.abort(reason);\n  else cancel = setLongTimeout(() => timer.abort(reason), left);\n  return {\n    signal: composed.signal,\n    dispose: () => {\n      cancel();\n      composed.dispose();\n    },\n  };\n}\n"]}

package/dist/lib/attempt/decision.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * attempt/decision.ts — the ONE retry rule table and the runner's evidence builder (design §3.1, §3.8, law 9).
+ *
+ * `retryRules(policy)` is the retry-or-stop decision as ordinary `decide()` rules over `AttemptInputs`, first
+ * match wins, default `retry` ("retryable"):
+ *
+ *   1  outcome = ok                    → done  succeeded
+ *   2  outcome = paused                → stop  paused
+ *   3  aborted = true                  → stop  aborted        (the run's signal — the attempt's outcome stays its own)
+ *   4  attempt ≥ of                    → stop  exhausted
+ *   5  retryOn = false                 → stop  declined       (a function rule: it shows the verdict it saw)
+ *   6  timeLeftAfterWaitMs ≤ 0         → stop  no-time-left
+ *      default                         → retry retryable
+ *
+ * Each rule's `label` IS the reason it names, so `reason` is a projection of the evidence, never a second
+ * vocabulary. The ceiling is `attempt/policy.ts · attemptCeiling`, the one reading the engine and the runner
+ * share.
+ *
+ * `decideAttempt` evaluates that table WITHOUT a scope (the runner has none — `decide()` needs a registered
+ * one) and builds the evidence `decide()` would build: the filter rows come from `decide()`'s own evaluator
+ * (`filter/evaluator.ts · evaluateFilter`), the function rows and the first-match loop mirror
+ * `decide/decide.ts` field for field and key for key. A property test pins that both paths give equal evidence
+ * for equal inputs (test/lib/attempt/property).
+ *
+ * Inputs are READ, one key at a time, only when a rule reaches them — so the user's `retryOn` and `backoffMs`
+ * run exactly when a retry needs them, as they did before the record existed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideAttempt = exports.retryRules = exports.RETRY_DEFAULT = void 0;
+const summarize_js_1 = require("../capture/summarize.js");
+const evaluator_js_1 = require("../filter/evaluator.js");
+const policy_js_1 = require("./policy.js");
+/** The table's default: no rule stopped the series, so it retries. */
+exports.RETRY_DEFAULT = Object.freeze({ branch: 'retry', label: 'retryable' });
+/** `decide()`'s summary length for an evidence value (filter/evaluator.ts, decide/evidence.ts). */
+const MAX_VALUE_LEN = 80;
+/**
+ * The retry rule table for `policy` — six `decide()` rules, then {@link RETRY_DEFAULT}. The ceiling is the
+ * whole number of attempts the policy allows, never fewer than one (`attemptCeiling`): a ceiling of `NaN` or
+ * `Infinity` cannot make rule 4 unreachable.
+ */
+function retryRules(policy) {
+    return [
+        { when: { outcome: { eq: 'ok' } }, then: 'done', label: 'succeeded' },
+        { when: { outcome: { eq: 'paused' } }, then: 'stop', label: 'paused' },
+        { when: { aborted: { eq: true } }, then: 'stop', label: 'aborted' },
+        { when: { attempt: { gte: (0, policy_js_1.attemptCeiling)(policy.attempts) } }, then: 'stop', label: 'exhausted' },
+        { when: (inputs) => inputs.retryOn === false, then: 'stop', label: 'declined' },
+        { when: { timeLeftAfterWaitMs: { lte: 0 } }, then: 'stop', label: 'no-time-left' },
+    ];
+}
+exports.retryRules = retryRules;
+/**
+ * Evaluate `rules` (a `retryRules` table) over `read` — first match wins — and build the evidence `decide()`
+ * would record with the default {@link RETRY_DEFAULT}. `read(key)` returns one input; it is called only for the
+ * keys the evaluated rules touch, in rule order.
+ */
+function decideAttempt(rules, read) {
+    const evaluated = [];
+    for (const [index, rule] of rules.entries()) {
+        const evidence = evaluateRule(rule, index, read);
+        evaluated.push(evidence);
+        if (evidence.matched)
+            return decided(evaluated, rule.then, rule.label);
+    }
+    return decided(evaluated, exports.RETRY_DEFAULT.branch, exports.RETRY_DEFAULT.label);
+}
+exports.decideAttempt = decideAttempt;
+function decided(rules, chosen, label) {
+    // decide()'s key order: rules, chosen, default, defaultLabel.
+    const evidence = {
+        rules,
+        chosen,
+        default: exports.RETRY_DEFAULT.branch,
+        defaultLabel: exports.RETRY_DEFAULT.label,
+    };
+    return { evidence, next: chosen, reason: label };
+}
+/** One rule, as `decide/decide.ts · evaluateRule` evaluates it — minus the scope. */
+function evaluateRule(rule, index, read) {
+    if (typeof rule.when === 'function') {
+        const inputs = [];
+        let matched;
+        let matchError;
+        try {
+            matched = rule.when(readingView(read, inputs));
+        }
+        catch (error) {
+            matched = false;
+            matchError = error instanceof Error ? error.message : String(error);
+        }
+        const evidence = {
+            type: 'function',
+            ruleIndex: index,
+            branch: rule.then,
+            matched,
+            label: rule.label,
+            inputs,
+            ...(matchError !== undefined && { matchError }),
+        };
+        return evidence;
+    }
+    let matched = false;
+    let conditions = [];
+    let matchError;
+    try {
+        ({ matched, conditions } = (0, evaluator_js_1.evaluateFilter)(read, () => false, rule.when));
+    }
+    catch (error) {
+        matchError = error instanceof Error ? error.message : String(error);
+    }
+    const evidence = {
+        type: 'filter',
+        ruleIndex: index,
+        branch: rule.then,
+        matched,
+        label: rule.label,
+        conditions,
+        ...(matchError !== undefined && { matchError }),
+    };
+    return evidence;
+}
+/**
+ * The inputs as a function rule sees them: each string-keyed read is recorded the way `decide()`'s evidence
+ * collector records a scope read (key, summary, not redacted — every input is a number, a name or a flag).
+ */
+function readingView(read, inputs) {
+    return new Proxy({}, {
+        get(_target, key) {
+            if (typeof key !== 'string')
+                return undefined;
+            const value = read(key);
+            inputs.push({ key, valueSummary: (0, summarize_js_1.summarizeValue)(value, MAX_VALUE_LEN), redacted: false });
+            return value;
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decision.js","sourceRoot":"","sources":["../../../src/lib/attempt/decision.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/decision.ts — the ONE retry rule table and the runner's evidence builder (design §3.1, §3.8, law 9).\n *\n * `retryRules(policy)` is the retry-or-stop decision as ordinary `decide()` rules over `AttemptInputs`, first\n * match wins, default `retry` (\"retryable\"):\n *\n *   1  outcome = ok                    → done  succeeded\n *   2  outcome = paused                → stop  paused\n *   3  aborted = true                  → stop  aborted        (the run's signal — the attempt's outcome stays its own)\n *   4  attempt ≥ of                    → stop  exhausted\n *   5  retryOn = false                 → stop  declined       (a function rule: it shows the verdict it saw)\n *   6  timeLeftAfterWaitMs ≤ 0         → stop  no-time-left\n *      default                         → retry retryable\n *\n * Each rule's `label` IS the reason it names, so `reason` is a projection of the evidence, never a second\n * vocabulary. The ceiling is `attempt/policy.ts · attemptCeiling`, the one reading the engine and the runner\n * share.\n *\n * `decideAttempt` evaluates that table WITHOUT a scope (the runner has none — `decide()` needs a registered\n * one) and builds the evidence `decide()` would build: the filter rows come from `decide()`'s own evaluator\n * (`filter/evaluator.ts · evaluateFilter`), the function rows and the first-match loop mirror\n * `decide/decide.ts` field for field and key for key. A property test pins that both paths give equal evidence\n * for equal inputs (test/lib/attempt/property).\n *\n * Inputs are READ, one key at a time, only when a rule reaches them — so the user's `retryOn` and `backoffMs`\n * run exactly when a retry needs them, as they did before the record existed.\n */\n\nimport { summarizeValue } from '../capture/summarize.js';\nimport type {\n  DecideRule,\n  DecisionEvidence,\n  FilterRuleEvidence,\n  FunctionRuleEvidence,\n  ReadInput,\n  RuleEvidence,\n  WhereFilter,\n} from '../decide/types.js';\nimport { evaluateFilter } from '../filter/evaluator.js';\nimport { attemptCeiling } from './policy.js';\nimport type { AttemptInputs, AttemptNext, AttemptReason, RetryPolicy } from './types.js';\n\n/** The table's default: no rule stopped the series, so it retries. */\nexport const RETRY_DEFAULT = Object.freeze({ branch: 'retry', label: 'retryable' } as const);\n\n/** `decide()`'s summary length for an evidence value (filter/evaluator.ts, decide/evidence.ts). */\nconst MAX_VALUE_LEN = 80;\n\n/**\n * The retry rule table for `policy` — six `decide()` rules, then {@link RETRY_DEFAULT}. The ceiling is the\n * whole number of attempts the policy allows, never fewer than one (`attemptCeiling`): a ceiling of `NaN` or\n * `Infinity` cannot make rule 4 unreachable.\n */\nexport function retryRules(policy: Pick<RetryPolicy, 'attempts'>): DecideRule<AttemptInputs>[] {\n  return [\n    { when: { outcome: { eq: 'ok' } }, then: 'done', label: 'succeeded' },\n    { when: { outcome: { eq: 'paused' } }, then: 'stop', label: 'paused' },\n    { when: { aborted: { eq: true } }, then: 'stop', label: 'aborted' },\n    { when: { attempt: { gte: attemptCeiling(policy.attempts) } }, then: 'stop', label: 'exhausted' },\n    { when: (inputs) => inputs.retryOn === false, then: 'stop', label: 'declined' },\n    { when: { timeLeftAfterWaitMs: { lte: 0 } }, then: 'stop', label: 'no-time-left' },\n  ];\n}\n\n/** A decision: the evidence, and its compact projection. */\nexport interface AttemptDecision {\n  readonly evidence: DecisionEvidence;\n  readonly next: AttemptNext;\n  readonly reason: AttemptReason;\n}\n\n/**\n * Evaluate `rules` (a `retryRules` table) over `read` — first match wins — and build the evidence `decide()`\n * would record with the default {@link RETRY_DEFAULT}. `read(key)` returns one input; it is called only for the\n * keys the evaluated rules touch, in rule order.\n */\nexport function decideAttempt(\n  rules: readonly DecideRule<AttemptInputs>[],\n  read: (key: string) => unknown,\n): AttemptDecision {\n  const evaluated: RuleEvidence[] = [];\n  for (const [index, rule] of rules.entries()) {\n    const evidence = evaluateRule(rule, index, read);\n    evaluated.push(evidence);\n    if (evidence.matched) return decided(evaluated, rule.then, rule.label);\n  }\n  return decided(evaluated, RETRY_DEFAULT.branch, RETRY_DEFAULT.label);\n}\n\nfunction decided(rules: RuleEvidence[], chosen: string, label: string | undefined): AttemptDecision {\n  // decide()'s key order: rules, chosen, default, defaultLabel.\n  const evidence: DecisionEvidence = {\n    rules,\n    chosen,\n    default: RETRY_DEFAULT.branch,\n    defaultLabel: RETRY_DEFAULT.label,\n  };\n  return { evidence, next: chosen as AttemptNext, reason: label as AttemptReason };\n}\n\n/** One rule, as `decide/decide.ts · evaluateRule` evaluates it — minus the scope. */\nfunction evaluateRule(rule: DecideRule<AttemptInputs>, index: number, read: (key: string) => unknown): RuleEvidence {\n  if (typeof rule.when === 'function') {\n    const inputs: ReadInput[] = [];\n    let matched: boolean;\n    let matchError: string | undefined;\n    try {\n      matched = rule.when(readingView(read, inputs));\n    } catch (error) {\n      matched = false;\n      matchError = error instanceof Error ? error.message : String(error);\n    }\n    const evidence: FunctionRuleEvidence = {\n      type: 'function',\n      ruleIndex: index,\n      branch: rule.then,\n      matched,\n      label: rule.label,\n      inputs,\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  }\n  let matched = false;\n  let conditions: FilterRuleEvidence['conditions'] = [];\n  let matchError: string | undefined;\n  try {\n    ({ matched, conditions } = evaluateFilter(read, () => false, rule.when as WhereFilter<AttemptInputs>));\n  } catch (error) {\n    matchError = error instanceof Error ? error.message : String(error);\n  }\n  const evidence: FilterRuleEvidence = {\n    type: 'filter',\n    ruleIndex: index,\n    branch: rule.then,\n    matched,\n    label: rule.label,\n    conditions,\n    ...(matchError !== undefined && { matchError }),\n  };\n  return evidence;\n}\n\n/**\n * The inputs as a function rule sees them: each string-keyed read is recorded the way `decide()`'s evidence\n * collector records a scope read (key, summary, not redacted — every input is a number, a name or a flag).\n */\nfunction readingView(read: (key: string) => unknown, inputs: ReadInput[]): AttemptInputs {\n  return new Proxy({} as AttemptInputs, {\n    get(_target, key) {\n      if (typeof key !== 'string') return undefined;\n      const value = read(key);\n      inputs.push({ key, valueSummary: summarizeValue(value, MAX_VALUE_LEN), redacted: false });\n      return value;\n    },\n  });\n}\n"]}

package/dist/lib/attempt/effect.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * attempt/effect.ts — side-effect safety (design §3.3, packet P3): the ONE reading of what an attempt did to an
+ * outside system, and the ONE rule for a touching target.
+ *
+ *   - `touchesProblem` — the build law, asked at every door a touching declaration enters: the builder
+ *     (`FlowChartBuilder · applyTouches` / `applyRetryPolicy`), the traverser for a StageNode a stage returns at run
+ *     time (`FlowchartTraverser · admitDynamicNodes`), and the stage itself (`FlowchartTraverser · executeStage`, for
+ *     a chart edited after `build()`). A touching target that may retry without an idempotency key is refused: a
+ *     retry of a non-idempotent effect without one can apply it twice.
+ *   - `callTouches` — the same law for `scope.$call(target, fn, policy, { touches, idempotencyKey })`.
+ *   - `admitIdempotencyKey` — the key's format: 1–255 printable ASCII characters, no space. It travels in a request
+ *     header (`Idempotency-Key`), so a control character could forge one; the refusal names the field, never the
+ *     value.
+ *   - `effectOf` — `ok → 'applied'`; a failure whose error declares `effect: 'none'` → `'none'`; anything else →
+ *     `'unknown'`. A timeout is the absence of an answer (law 4), so it is never `'none'`.
+ *   - `unknownEffectError` — what a series that ends without an answer after ANY attempt of unknown effect fails
+ *     with, in place of the attempt's own error (its `cause`).
+ *   - `interruptProblem` — a keyless touching stage may not be re-run by an `interrupt()` resume.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCarriedTouches = exports.carriedTouches = exports.interruptProblem = exports.refuseKeylessRetry = exports.recordedKeyOf = exports.unknownEffectError = exports.effectOf = exports.callTouches = exports.admitIdempotencyKey = exports.touchesProblem = exports.MAX_IDEMPOTENCY_KEY_LENGTH = void 0;
+const idempotencyKey_js_1 = require("../ids/idempotencyKey.js");
+const errors_js_1 = require("./errors.js");
+const name_js_1 = require("./name.js");
+const policy_js_1 = require("./policy.js");
+var idempotencyKey_js_2 = require("../ids/idempotencyKey.js");
+Object.defineProperty(exports, "MAX_IDEMPOTENCY_KEY_LENGTH", { enumerable: true, get: function () { return idempotencyKey_js_2.MAX_IDEMPOTENCY_KEY_LENGTH; } });
+/** Why `retry` with `touches` breaks the law — the shared words of every door. */
+function retriedWithoutKey(system, attempts) {
+    return (`touches "${system}" and may retry (attempts: ${attempts}) but declares no idempotencyKey — a retry of an ` +
+        'outside effect without a key can apply it twice. Declare the key rule ' +
+        `(.touches('${system}', { idempotencyKey: ({ args }) => \`order-\${args.orderId}\` })), or retry once.`);
+}
+/**
+ * Why a touching declaration is refused, or `undefined` when it is admitted: `touches` must be `{ system,
+ * idempotencyKey? }` with `system` a name and the key rule a function; and a target that may retry (`retry`'s
+ * ceiling above 1) must declare the key rule.
+ */
+function touchesProblem(touches, retry) {
+    if (touches === null || typeof touches !== 'object') {
+        return 'touches must be { system, idempotencyKey? } — the outside system and the key rule';
+    }
+    const { system, idempotencyKey } = touches;
+    const nameProblem = (0, name_js_1.attemptNameProblem)(system);
+    if (nameProblem !== undefined)
+        return `touches.system ${nameProblem} — it is a name from code, never a value`;
+    if (idempotencyKey !== undefined && typeof idempotencyKey !== 'function') {
+        return ('touches.idempotencyKey must be a function of the execution ((ctx) => string) — a constant key would make ' +
+            'every run one operation');
+    }
+    const attempts = (0, policy_js_1.attemptCeiling)(retry?.attempts);
+    if (attempts > 1 && idempotencyKey === undefined)
+        return retriedWithoutKey(system, attempts);
+    return undefined;
+}
+exports.touchesProblem = touchesProblem;
+/** `value` as an idempotency key (`ids/idempotencyKey.ts`, the one rule), or a `TypeError` that names `where`. */
+function admitIdempotencyKey(where, value) {
+    const problem = (0, idempotencyKey_js_1.idempotencyKeyProblem)(value);
+    if (problem !== undefined) {
+        throw new TypeError(`${where}: idempotencyKey ${problem} (derive it from the input or the state, never from model output)`);
+    }
+    return value;
+}
+exports.admitIdempotencyKey = admitIdempotencyKey;
+/**
+ * A `$call`'s side-effect declaration, admitted: `undefined` when it touches nothing; otherwise the system and the
+ * key, refused with a `TypeError` naming `where` when malformed, when a key comes without a system, or when the
+ * call may retry with no key — before anything is sent.
+ */
+function callTouches(where, options, policy) {
+    if (options === undefined)
+        return undefined;
+    if (options === null || typeof options !== 'object') {
+        throw new TypeError(`${where}: options must be { touches?, idempotencyKey? }`);
+    }
+    const { touches, idempotencyKey } = options;
+    if (touches === undefined) {
+        if (idempotencyKey !== undefined) {
+            throw new TypeError(`${where}: an idempotencyKey names an effect — declare the system it touches (touches)`);
+        }
+        return undefined;
+    }
+    const nameProblem = (0, name_js_1.attemptNameProblem)(touches);
+    if (nameProblem !== undefined) {
+        throw new TypeError(`${where}: touches ${nameProblem} — it is a name from code, never a value`);
+    }
+    const key = idempotencyKey === undefined ? undefined : admitIdempotencyKey(where, idempotencyKey);
+    const attempts = (0, policy_js_1.attemptCeiling)(policy.attempts);
+    if (attempts > 1 && key === undefined)
+        throw new TypeError(`${where}: ${retriedWithoutKey(touches, attempts)}`);
+    return { system: touches, ...(key !== undefined && { idempotencyKey: key }) };
+}
+exports.callTouches = callTouches;
+/** What an attempt that ended `outcome` (with `error`, when it failed) did to the outside system. */
+function effectOf(outcome, error) {
+    if (outcome === 'ok')
+        return 'applied';
+    if (outcome === 'failed' && declaresNoEffect(error))
+        return 'none';
+    return 'unknown';
+}
+exports.effectOf = effectOf;
+/** The error itself says nothing was sent — `effect: 'none'`, read once; a value that cannot be read says nothing. */
+function declaresNoEffect(error) {
+    if (error === null || typeof error !== 'object')
+        return false;
+    try {
+        return error.effect === 'none';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * What a touching series fails with when any of its attempts left the effect unknown — never the attempt's own error,
+ * which a caller would read as a failure and retry. The key is the RECORDED one: under a redaction rule that names
+ * it, the error carries the placeholder, as every record does.
+ */
+function unknownEffectError(target, record, cause) {
+    return new errors_js_1.UnknownEffectError({
+        system: target.system,
+        ...(recordedKeyOf(target) !== undefined && { idempotencyKey: recordedKeyOf(target) }),
+        attempts: record.attempt,
+        cause,
+    });
+}
+exports.unknownEffectError = unknownEffectError;
+/** The key as records carry it: the served form when the caller gave one, else the key itself. */
+function recordedKeyOf(target) {
+    return target.recordedKey ?? target.idempotencyKey;
+}
+exports.recordedKeyOf = recordedKeyOf;
+/** The runner's refusal of a touching series that may retry with no key — the law, at the last door. */
+function refuseKeylessRetry(target, attempts) {
+    if (attempts > 1 && target.idempotencyKey === undefined) {
+        throw new TypeError(`[footprint] ${retriedWithoutKey(target.system, attempts)}`);
+    }
+}
+exports.refuseKeylessRetry = refuseKeylessRetry;
+/**
+ * Why a touching stage may not be RE-RUN by an `interrupt()` resume, or `undefined` when it may (P3). A resume
+ * re-runs the stage's function from its top — a second attempt of its effect — so the law that refuses a keyless
+ * retry refuses a keyless re-run too. Asked when the stage interrupts (`StageRunner`) and when a checkpoint is
+ * resumed (`runner/resume.ts · planResume`, for a checkpoint made by another version of the chart).
+ */
+function interruptProblem(touches) {
+    if (touches === undefined || touches.idempotencyKey !== undefined)
+        return undefined;
+    return (`touches "${touches.system}" with no idempotencyKey, and a resume after interrupt() re-runs the stage from its ` +
+        'top — a second attempt of the effect without a key. Declare the key rule, or interrupt in a stage of its own.');
+}
+exports.interruptProblem = interruptProblem;
+/** The touching declarations `resume()` builds around a key a checkpoint carried (`carriedTouches`). */
+const CARRIED = new WeakSet();
+/**
+ * The stand-in's declaration on a resume (P3): the paused stage's system, answering the key its checkpoint carried —
+ * the OPERATIONAL value, real (checkpoints are exempt from redaction by law). It is marked, so the run serves it
+ * like a key of unknown sources: under any state rule the records carry the placeholder (`isCarriedTouches`) — the
+ * resumed leg no longer holds the input the key was made of, so it cannot tell whether the key was masked.
+ */
+function carriedTouches(system, key) {
+    const touches = Object.freeze({ system, idempotencyKey: () => key });
+    CARRIED.add(touches);
+    return touches;
+}
+exports.carriedTouches = carriedTouches;
+/** The declaration answers a key a checkpoint carried ({@link carriedTouches}). */
+function isCarriedTouches(touches) {
+    return typeof touches === 'object' && touches !== null && CARRIED.has(touches);
+}
+exports.isCarriedTouches = isCarriedTouches;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effect.js","sourceRoot":"","sources":["../../../src/lib/attempt/effect.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/effect.ts — side-effect safety (design §3.3, packet P3): the ONE reading of what an attempt did to an\n * outside system, and the ONE rule for a touching target.\n *\n *   - `touchesProblem` — the build law, asked at every door a touching declaration enters: the builder\n *     (`FlowChartBuilder · applyTouches` / `applyRetryPolicy`), the traverser for a StageNode a stage returns at run\n *     time (`FlowchartTraverser · admitDynamicNodes`), and the stage itself (`FlowchartTraverser · executeStage`, for\n *     a chart edited after `build()`). A touching target that may retry without an idempotency key is refused: a\n *     retry of a non-idempotent effect without one can apply it twice.\n *   - `callTouches` — the same law for `scope.$call(target, fn, policy, { touches, idempotencyKey })`.\n *   - `admitIdempotencyKey` — the key's format: 1–255 printable ASCII characters, no space. It travels in a request\n *     header (`Idempotency-Key`), so a control character could forge one; the refusal names the field, never the\n *     value.\n *   - `effectOf` — `ok → 'applied'`; a failure whose error declares `effect: 'none'` → `'none'`; anything else →\n *     `'unknown'`. A timeout is the absence of an answer (law 4), so it is never `'none'`.\n *   - `unknownEffectError` — what a series that ends without an answer after ANY attempt of unknown effect fails\n *     with, in place of the attempt's own error (its `cause`).\n *   - `interruptProblem` — a keyless touching stage may not be re-run by an `interrupt()` resume.\n */\n\nimport { idempotencyKeyProblem } from '../ids/idempotencyKey.js';\nimport { UnknownEffectError } from './errors.js';\nimport { attemptNameProblem } from './name.js';\nimport { attemptCeiling } from './policy.js';\nimport type { AttemptEffect, AttemptOutcome, AttemptRecord, CallOptions, RetryPolicy, StageTouches } from './types.js';\n\nexport { MAX_IDEMPOTENCY_KEY_LENGTH } from '../ids/idempotencyKey.js';\n\n/**\n * What a touching runner series is told (`AttemptRunOptions.effect`): the system, the REAL key the attempts are made\n * under, and the key as records carry it (the run's served form; the real one when no rule applies).\n */\nexport interface EffectTarget {\n  readonly system: string;\n  readonly idempotencyKey?: string;\n  readonly recordedKey?: string;\n}\n\n/** Why `retry` with `touches` breaks the law — the shared words of every door. */\nfunction retriedWithoutKey(system: string, attempts: number): string {\n  return (\n    `touches \"${system}\" and may retry (attempts: ${attempts}) but declares no idempotencyKey — a retry of an ` +\n    'outside effect without a key can apply it twice. Declare the key rule ' +\n    `(.touches('${system}', { idempotencyKey: ({ args }) => \\`order-\\${args.orderId}\\` })), or retry once.`\n  );\n}\n\n/**\n * Why a touching declaration is refused, or `undefined` when it is admitted: `touches` must be `{ system,\n * idempotencyKey? }` with `system` a name and the key rule a function; and a target that may retry (`retry`'s\n * ceiling above 1) must declare the key rule.\n */\nexport function touchesProblem(touches: unknown, retry: Pick<RetryPolicy, 'attempts'> | undefined): string | undefined {\n  if (touches === null || typeof touches !== 'object') {\n    return 'touches must be { system, idempotencyKey? } — the outside system and the key rule';\n  }\n  const { system, idempotencyKey } = touches as Partial<StageTouches>;\n  const nameProblem = attemptNameProblem(system);\n  if (nameProblem !== undefined) return `touches.system ${nameProblem} — it is a name from code, never a value`;\n  if (idempotencyKey !== undefined && typeof idempotencyKey !== 'function') {\n    return (\n      'touches.idempotencyKey must be a function of the execution ((ctx) => string) — a constant key would make ' +\n      'every run one operation'\n    );\n  }\n  const attempts = attemptCeiling(retry?.attempts);\n  if (attempts > 1 && idempotencyKey === undefined) return retriedWithoutKey(system as string, attempts);\n  return undefined;\n}\n\n/** `value` as an idempotency key (`ids/idempotencyKey.ts`, the one rule), or a `TypeError` that names `where`. */\nexport function admitIdempotencyKey(where: string, value: unknown): string {\n  const problem = idempotencyKeyProblem(value);\n  if (problem !== undefined) {\n    throw new TypeError(\n      `${where}: idempotencyKey ${problem} (derive it from the input or the state, never from model output)`,\n    );\n  }\n  return value as string;\n}\n\n/**\n * A `$call`'s side-effect declaration, admitted: `undefined` when it touches nothing; otherwise the system and the\n * key, refused with a `TypeError` naming `where` when malformed, when a key comes without a system, or when the\n * call may retry with no key — before anything is sent.\n */\nexport function callTouches(\n  where: string,\n  options: unknown,\n  policy: Pick<RetryPolicy, 'attempts'>,\n): { readonly system: string; readonly idempotencyKey?: string } | undefined {\n  if (options === undefined) return undefined;\n  if (options === null || typeof options !== 'object') {\n    throw new TypeError(`${where}: options must be { touches?, idempotencyKey? }`);\n  }\n  const { touches, idempotencyKey } = options as CallOptions;\n  if (touches === undefined) {\n    if (idempotencyKey !== undefined) {\n      throw new TypeError(`${where}: an idempotencyKey names an effect — declare the system it touches (touches)`);\n    }\n    return undefined;\n  }\n  const nameProblem = attemptNameProblem(touches);\n  if (nameProblem !== undefined) {\n    throw new TypeError(`${where}: touches ${nameProblem} — it is a name from code, never a value`);\n  }\n  const key = idempotencyKey === undefined ? undefined : admitIdempotencyKey(where, idempotencyKey);\n  const attempts = attemptCeiling(policy.attempts);\n  if (attempts > 1 && key === undefined) throw new TypeError(`${where}: ${retriedWithoutKey(touches, attempts)}`);\n  return { system: touches, ...(key !== undefined && { idempotencyKey: key }) };\n}\n\n/** What an attempt that ended `outcome` (with `error`, when it failed) did to the outside system. */\nexport function effectOf(outcome: AttemptOutcome, error: unknown): AttemptEffect {\n  if (outcome === 'ok') return 'applied';\n  if (outcome === 'failed' && declaresNoEffect(error)) return 'none';\n  return 'unknown';\n}\n\n/** The error itself says nothing was sent — `effect: 'none'`, read once; a value that cannot be read says nothing. */\nfunction declaresNoEffect(error: unknown): boolean {\n  if (error === null || typeof error !== 'object') return false;\n  try {\n    return (error as { effect?: unknown }).effect === 'none';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * What a touching series fails with when any of its attempts left the effect unknown — never the attempt's own error,\n * which a caller would read as a failure and retry. The key is the RECORDED one: under a redaction rule that names\n * it, the error carries the placeholder, as every record does.\n */\nexport function unknownEffectError(target: EffectTarget, record: AttemptRecord, cause: unknown): UnknownEffectError {\n  return new UnknownEffectError({\n    system: target.system,\n    ...(recordedKeyOf(target) !== undefined && { idempotencyKey: recordedKeyOf(target) }),\n    attempts: record.attempt,\n    cause,\n  });\n}\n\n/** The key as records carry it: the served form when the caller gave one, else the key itself. */\nexport function recordedKeyOf(target: EffectTarget): string | undefined {\n  return target.recordedKey ?? target.idempotencyKey;\n}\n\n/** The runner's refusal of a touching series that may retry with no key — the law, at the last door. */\nexport function refuseKeylessRetry(target: EffectTarget, attempts: number): void {\n  if (attempts > 1 && target.idempotencyKey === undefined) {\n    throw new TypeError(`[footprint] ${retriedWithoutKey(target.system, attempts)}`);\n  }\n}\n\n/**\n * Why a touching stage may not be RE-RUN by an `interrupt()` resume, or `undefined` when it may (P3). A resume\n * re-runs the stage's function from its top — a second attempt of its effect — so the law that refuses a keyless\n * retry refuses a keyless re-run too. Asked when the stage interrupts (`StageRunner`) and when a checkpoint is\n * resumed (`runner/resume.ts · planResume`, for a checkpoint made by another version of the chart).\n */\nexport function interruptProblem(touches: StageTouches | undefined): string | undefined {\n  if (touches === undefined || touches.idempotencyKey !== undefined) return undefined;\n  return (\n    `touches \"${touches.system}\" with no idempotencyKey, and a resume after interrupt() re-runs the stage from its ` +\n    'top — a second attempt of the effect without a key. Declare the key rule, or interrupt in a stage of its own.'\n  );\n}\n\n/** The touching declarations `resume()` builds around a key a checkpoint carried (`carriedTouches`). */\nconst CARRIED = new WeakSet<object>();\n\n/**\n * The stand-in's declaration on a resume (P3): the paused stage's system, answering the key its checkpoint carried —\n * the OPERATIONAL value, real (checkpoints are exempt from redaction by law). It is marked, so the run serves it\n * like a key of unknown sources: under any state rule the records carry the placeholder (`isCarriedTouches`) — the\n * resumed leg no longer holds the input the key was made of, so it cannot tell whether the key was masked.\n */\nexport function carriedTouches(system: string, key: string): StageTouches {\n  const touches = Object.freeze({ system, idempotencyKey: () => key });\n  CARRIED.add(touches);\n  return touches;\n}\n\n/** The declaration answers a key a checkpoint carried ({@link carriedTouches}). */\nexport function isCarriedTouches(touches: unknown): boolean {\n  return typeof touches === 'object' && touches !== null && CARRIED.has(touches);\n}\n"]}

package/dist/lib/attempt/errors.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownEffectError = exports.AttemptTimeoutError = void 0;
+/** The attempt's own time cap ran out before it answered. */
+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;
+    }
+}
+exports.AttemptTimeoutError = AttemptTimeoutError;
+/** A side-effecting target's last attempt ended with no answer: whether the effect happened is unknown. */
+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;
+    }
+}
+exports.UnknownEffectError = UnknownEffectError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/attempt/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attempt = exports.UnknownEffectError = exports.AttemptTimeoutError = exports.retryRules = exports.TraceparentError = exports.parseTraceparent = exports.formatTraceparent = exports.errorCategory = void 0;
+var category_js_1 = require("./category.js");
+Object.defineProperty(exports, "errorCategory", { enumerable: true, get: function () { return category_js_1.errorCategory; } });
+var correlation_js_1 = require("./correlation.js");
+Object.defineProperty(exports, "formatTraceparent", { enumerable: true, get: function () { return correlation_js_1.formatTraceparent; } });
+Object.defineProperty(exports, "parseTraceparent", { enumerable: true, get: function () { return correlation_js_1.parseTraceparent; } });
+Object.defineProperty(exports, "TraceparentError", { enumerable: true, get: function () { return correlation_js_1.TraceparentError; } });
+var decision_js_1 = require("./decision.js");
+Object.defineProperty(exports, "retryRules", { enumerable: true, get: function () { return decision_js_1.retryRules; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "AttemptTimeoutError", { enumerable: true, get: function () { return errors_js_1.AttemptTimeoutError; } });
+Object.defineProperty(exports, "UnknownEffectError", { enumerable: true, get: function () { return errors_js_1.UnknownEffectError; } });
+var standalone_js_1 = require("./standalone.js");
+Object.defineProperty(exports, "attempt", { enumerable: true, get: function () { return standalone_js_1.attempt; } });
+//# sourceMappingURL=data:application/json;base64,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