footprintjs 10.0.1 → 10.2.0

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

@@ -0,0 +1,101 @@
+/**
+ * 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.
+ */
+import { anySignal } from './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. */
+export function deadlineReason(message) {
+    const reason = new Error(message);
+    DEADLINE_REASONS.add(reason);
+    return reason;
+}
+/**
+ * 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.
+ */
+export function markTimeLimit(reason) {
+    DEADLINE_REASONS.add(reason);
+    return reason;
+}
+/** Whether `reason` is the run's deadline or an attempt's cap — a time limit, not a cancellation. */
+export function isDeadlineReason(reason) {
+    return typeof reason === 'object' && reason !== null && DEADLINE_REASONS.has(reason);
+}
+/** Whether the signal aborted for a reason OTHER than a time limit — a cancellation. */
+export function isCancelled(signal) {
+    return signal?.aborted === true && !isDeadlineReason(signal.reason);
+}
+/** A deadline as the engine reads one: a finite number (epoch ms), else none. */
+export function readDeadline(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/** 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.
+ */
+export 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);
+    };
+}
+/** Whether `value` is an AbortSignal (structurally — a signal from another realm counts). */
+export function isAbortSignal(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.aborted === 'boolean' &&
+        typeof value.addEventListener === 'function' &&
+        typeof value.removeEventListener === 'function');
+}
+/**
+ * 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.
+ */
+export function armDeadline(signal, deadline, message, now = Date.now) {
+    if (deadline === undefined)
+        return { signal, dispose: () => undefined };
+    const timer = new AbortController();
+    const composed = 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();
+        },
+    };
+}
+//# 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/esm/lib/attempt/decision.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+import type { DecideRule, DecisionEvidence } from '../decide/types.js';
+import type { AttemptInputs, AttemptNext, AttemptReason, RetryPolicy } from './types.js';
+/** The table's default: no rule stopped the series, so it retries. */
+export declare const RETRY_DEFAULT: Readonly<{
+    readonly branch: "retry";
+    readonly label: "retryable";
+}>;
+/**
+ * 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.
+ */
+export declare function retryRules(policy: Pick<RetryPolicy, 'attempts'>): DecideRule<AttemptInputs>[];
+/** A decision: the evidence, and its compact projection. */
+export interface AttemptDecision {
+    readonly evidence: DecisionEvidence;
+    readonly next: AttemptNext;
+    readonly reason: AttemptReason;
+}
+/**
+ * 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.
+ */
+export declare function decideAttempt(rules: readonly DecideRule<AttemptInputs>[], read: (key: string) => unknown): AttemptDecision;

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

@@ -0,0 +1,134 @@
+/**
+ * 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.
+ */
+import { summarizeValue } from '../capture/summarize.js';
+import { evaluateFilter } from '../filter/evaluator.js';
+import { attemptCeiling } from './policy.js';
+/** The table's default: no rule stopped the series, so it retries. */
+export const 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.
+ */
+export 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: 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' },
+    ];
+}
+/**
+ * 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.
+ */
+export 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, RETRY_DEFAULT.branch, RETRY_DEFAULT.label);
+}
+function decided(rules, chosen, label) {
+    // decide()'s key order: rules, chosen, default, defaultLabel.
+    const evidence = {
+        rules,
+        chosen,
+        default: RETRY_DEFAULT.branch,
+        defaultLabel: 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 } = 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: 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/esm/lib/attempt/effect.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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.
+ */
+import { UnknownEffectError } from './errors.js';
+import type { AttemptEffect, AttemptOutcome, AttemptRecord, RetryPolicy, StageTouches } from './types.js';
+export { MAX_IDEMPOTENCY_KEY_LENGTH } from '../ids/idempotencyKey.js';
+/**
+ * What a touching runner series is told (`AttemptRunOptions.effect`): the system, the REAL key the attempts are made
+ * under, and the key as records carry it (the run's served form; the real one when no rule applies).
+ */
+export interface EffectTarget {
+    readonly system: string;
+    readonly idempotencyKey?: string;
+    readonly recordedKey?: string;
+}
+/**
+ * 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.
+ */
+export declare function touchesProblem(touches: unknown, retry: Pick<RetryPolicy, 'attempts'> | undefined): string | undefined;
+/** `value` as an idempotency key (`ids/idempotencyKey.ts`, the one rule), or a `TypeError` that names `where`. */
+export declare function admitIdempotencyKey(where: string, value: unknown): string;
+/**
+ * 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.
+ */
+export declare function callTouches(where: string, options: unknown, policy: Pick<RetryPolicy, 'attempts'>): {
+    readonly system: string;
+    readonly idempotencyKey?: string;
+} | undefined;
+/** What an attempt that ended `outcome` (with `error`, when it failed) did to the outside system. */
+export declare function effectOf(outcome: AttemptOutcome, error: unknown): AttemptEffect;
+/**
+ * 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.
+ */
+export declare function unknownEffectError(target: EffectTarget, record: AttemptRecord, cause: unknown): UnknownEffectError;
+/** The key as records carry it: the served form when the caller gave one, else the key itself. */
+export declare function recordedKeyOf(target: EffectTarget): string | undefined;
+/** The runner's refusal of a touching series that may retry with no key — the law, at the last door. */
+export declare function refuseKeylessRetry(target: EffectTarget, attempts: number): void;
+/**
+ * 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).
+ */
+export declare function interruptProblem(touches: StageTouches | undefined): string | undefined;
+/**
+ * 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.
+ */
+export declare function carriedTouches(system: string, key: string): StageTouches;
+/** The declaration answers a key a checkpoint carried ({@link carriedTouches}). */
+export declare function isCarriedTouches(touches: unknown): boolean;

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

@@ -0,0 +1,160 @@
+/**
+ * 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.
+ */
+import { idempotencyKeyProblem } from '../ids/idempotencyKey.js';
+import { UnknownEffectError } from './errors.js';
+import { attemptNameProblem } from './name.js';
+import { attemptCeiling } from './policy.js';
+export { MAX_IDEMPOTENCY_KEY_LENGTH } from '../ids/idempotencyKey.js';
+/** 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.
+ */
+export 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 = 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 = attemptCeiling(retry?.attempts);
+    if (attempts > 1 && idempotencyKey === undefined)
+        return retriedWithoutKey(system, attempts);
+    return undefined;
+}
+/** `value` as an idempotency key (`ids/idempotencyKey.ts`, the one rule), or a `TypeError` that names `where`. */
+export function admitIdempotencyKey(where, value) {
+    const problem = 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;
+}
+/**
+ * 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.
+ */
+export 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 = 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 = attemptCeiling(policy.attempts);
+    if (attempts > 1 && key === undefined)
+        throw new TypeError(`${where}: ${retriedWithoutKey(touches, attempts)}`);
+    return { system: touches, ...(key !== undefined && { idempotencyKey: key }) };
+}
+/** What an attempt that ended `outcome` (with `error`, when it failed) did to the outside system. */
+export function effectOf(outcome, error) {
+    if (outcome === 'ok')
+        return 'applied';
+    if (outcome === 'failed' && declaresNoEffect(error))
+        return 'none';
+    return 'unknown';
+}
+/** 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.
+ */
+export function unknownEffectError(target, record, cause) {
+    return new UnknownEffectError({
+        system: target.system,
+        ...(recordedKeyOf(target) !== undefined && { idempotencyKey: recordedKeyOf(target) }),
+        attempts: record.attempt,
+        cause,
+    });
+}
+/** The key as records carry it: the served form when the caller gave one, else the key itself. */
+export function recordedKeyOf(target) {
+    return target.recordedKey ?? target.idempotencyKey;
+}
+/** The runner's refusal of a touching series that may retry with no key — the law, at the last door. */
+export function refuseKeylessRetry(target, attempts) {
+    if (attempts > 1 && target.idempotencyKey === undefined) {
+        throw new TypeError(`[footprint] ${retriedWithoutKey(target.system, attempts)}`);
+    }
+}
+/**
+ * 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).
+ */
+export 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.');
+}
+/** 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.
+ */
+export function carriedTouches(system, key) {
+    const touches = Object.freeze({ system, idempotencyKey: () => key });
+    CARRIED.add(touches);
+    return touches;
+}
+/** The declaration answers a key a checkpoint carried ({@link carriedTouches}). */
+export function isCarriedTouches(touches) {
+    return typeof touches === 'object' && touches !== null && CARRIED.has(touches);
+}
+//# 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"]}