footprintjs 10.0.1 → 10.2.0

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

@@ -0,0 +1,131 @@
+/**
+ * attempt/category.ts — `errorCategory`, the ONE failure classifier (design §3.9).
+ *
+ * Seven fixed values, so every recorder — the narrative, the metric layer, an agent's own — breaks failures down
+ * the same way; a recorder never invents a category of its own. Borrowed from agentfootprint's
+ * `classifyRetryReason` and widened, so its decorators adopt this one rather than keep theirs.
+ *
+ * Category is EVIDENCE, never policy: the default `retryOn` retries every category. A chart that wants "never
+ * retry a permanent failure" says so: `retryOn: (e) => errorCategory(e) !== 'permanent'`.
+ *
+ * Precedence — what the failure LOOKED like wins over what it declares:
+ *   1. the attempt's own timer (outcome `'timeout'`, or our `AttemptTimeoutError`)  → timeout
+ *   2. the run's signal ended it (outcome `'aborted'`)                              → unknown
+ *   3. status 429, or a declared `retryAfterMs` / `retryAfterSeconds`               → rate-limited
+ *   4. status 5xx                                                                   → server
+ *   5. status 401 / 403                                                             → auth
+ *   6. any other 4xx                                                                → permanent
+ *   7. `retryable: false`, or a validation error                                    → permanent
+ *   8. a transport failure (a socket code on the error or its cause, a fetch
+ *      `TypeError`, an `AbortError` / `TimeoutError` that was not the run's)        → network
+ *   9. anything else                                                                → unknown
+ *
+ * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Total: a value whose
+ * reads throw (a hostile Proxy) is `'unknown'`, never a second throw from an error path.
+ */
+import { InputValidationError } from '../schema/errors.js';
+import { AttemptTimeoutError, UnknownEffectError } from './errors.js';
+/** Socket-level codes a transport failure carries (Node's `errno` names). */
+const NETWORK_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'ETIMEDOUT',
+    'EAI_AGAIN',
+    'EPIPE',
+]);
+/** The messages runtimes give a `fetch` that never reached the server (Node, Chromium, Firefox, Safari). */
+const FETCH_FAILURE = /^(fetch failed|failed to fetch|networkerror when attempting to fetch resource\.?|load failed)$/i;
+/** Error names that say a validation failed — retrying the same input cannot succeed. */
+const VALIDATION_NAMES = new Set(['ValidationError', 'ZodError', 'InputValidationError']);
+/** Error names of an abort or a timeout that some OTHER signal raised (the run's own ends as outcome `'aborted'`). */
+const TRANSPORT_ABORT_NAMES = new Set(['AbortError', 'TimeoutError']);
+/**
+ * The category of an attempt's failure. `outcome` is how the attempt ended (default `'failed'`): it decides
+ * `'timeout'` (the attempt's own timer) and `'unknown'` (the run's signal) before the error is read.
+ */
+export function errorCategory(error, outcome = 'failed') {
+    if (outcome === 'timeout')
+        return 'timeout';
+    if (outcome === 'aborted')
+        return 'unknown';
+    try {
+        return categoryOf(error);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * @internal Terminal ownership preserves a producer's known category. An
+ * unresolved effect is unknown, never the category of its physical cause.
+ * This does not rewrite historical attempt categories or re-read a known one.
+ */
+export function terminalCategory(error, known) {
+    try {
+        if (error instanceof UnknownEffectError)
+            return 'unknown';
+        // CJS and ESM have distinct constructors. A declared own DATA name may
+        // only reduce certainty to unknown; never execute an error's name getter
+        // or promote its physical cause to a known outcome across module copies.
+        if (error !== null && (typeof error === 'object' || typeof error === 'function')) {
+            const name = Object.getOwnPropertyDescriptor(error, 'name');
+            if (name && Object.prototype.hasOwnProperty.call(name, 'value') && name.value === 'UnknownEffectError') {
+                return 'unknown';
+            }
+        }
+    }
+    catch {
+        return known ?? 'unknown';
+    }
+    return known ?? errorCategory(error);
+}
+function categoryOf(error) {
+    if (error instanceof AttemptTimeoutError)
+        return 'timeout';
+    if (error === null || (typeof error !== 'object' && typeof error !== 'function'))
+        return 'unknown';
+    const fields = error;
+    const status = numberField(fields, 'status') ?? numberField(fields, 'statusCode');
+    const declaresRetryAfter = isWait(fields.retryAfterMs) || isWait(fields.retryAfterSeconds);
+    if (status === 429 || declaresRetryAfter)
+        return 'rate-limited';
+    if (status !== undefined && status >= 500 && status <= 599)
+        return 'server';
+    if (status === 401 || status === 403)
+        return 'auth';
+    if (status !== undefined && status >= 400 && status <= 499)
+        return 'permanent';
+    if (fields.retryable === false)
+        return 'permanent';
+    if (error instanceof InputValidationError)
+        return 'permanent';
+    const name = typeof fields.name === 'string' ? fields.name : undefined;
+    if (name !== undefined && VALIDATION_NAMES.has(name))
+        return 'permanent';
+    if (status === undefined && isTransportFailure(fields, name))
+        return 'network';
+    return 'unknown';
+}
+function isTransportFailure(fields, name) {
+    if (hasNetworkCode(fields.code))
+        return true;
+    const cause = fields.cause;
+    if (cause !== null && typeof cause === 'object' && hasNetworkCode(cause.code)) {
+        return true;
+    }
+    if (name !== undefined && TRANSPORT_ABORT_NAMES.has(name))
+        return true;
+    return fields instanceof TypeError && typeof fields.message === 'string' && FETCH_FAILURE.test(fields.message);
+}
+function hasNetworkCode(code) {
+    return typeof code === 'string' && NETWORK_CODES.has(code);
+}
+function numberField(fields, key) {
+    const value = fields[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function isWait(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.js","sourceRoot":"","sources":["../../../../src/lib/attempt/category.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/category.ts — `errorCategory`, the ONE failure classifier (design §3.9).\n *\n * Seven fixed values, so every recorder — the narrative, the metric layer, an agent's own — breaks failures down\n * the same way; a recorder never invents a category of its own. Borrowed from agentfootprint's\n * `classifyRetryReason` and widened, so its decorators adopt this one rather than keep theirs.\n *\n * Category is EVIDENCE, never policy: the default `retryOn` retries every category. A chart that wants \"never\n * retry a permanent failure\" says so: `retryOn: (e) => errorCategory(e) !== 'permanent'`.\n *\n * Precedence — what the failure LOOKED like wins over what it declares:\n *   1. the attempt's own timer (outcome `'timeout'`, or our `AttemptTimeoutError`)  → timeout\n *   2. the run's signal ended it (outcome `'aborted'`)                              → unknown\n *   3. status 429, or a declared `retryAfterMs` / `retryAfterSeconds`               → rate-limited\n *   4. status 5xx                                                                   → server\n *   5. status 401 / 403                                                             → auth\n *   6. any other 4xx                                                                → permanent\n *   7. `retryable: false`, or a validation error                                    → permanent\n *   8. a transport failure (a socket code on the error or its cause, a fetch\n *      `TypeError`, an `AbortError` / `TimeoutError` that was not the run's)        → network\n *   9. anything else                                                                → unknown\n *\n * A status is a NUMBER (`status` or `statusCode`); a numeric string is not read as one. Total: a value whose\n * reads throw (a hostile Proxy) is `'unknown'`, never a second throw from an error path.\n */\n\nimport { InputValidationError } from '../schema/errors.js';\nimport { AttemptTimeoutError, UnknownEffectError } from './errors.js';\nimport type { AttemptCategory, AttemptOutcome } from './types.js';\n\n/** Socket-level codes a transport failure carries (Node's `errno` names). */\nconst NETWORK_CODES: ReadonlySet<string> = new Set([\n  'ECONNRESET',\n  'ECONNREFUSED',\n  'ENOTFOUND',\n  'ETIMEDOUT',\n  'EAI_AGAIN',\n  'EPIPE',\n]);\n\n/** The messages runtimes give a `fetch` that never reached the server (Node, Chromium, Firefox, Safari). */\nconst FETCH_FAILURE = /^(fetch failed|failed to fetch|networkerror when attempting to fetch resource\\.?|load failed)$/i;\n\n/** Error names that say a validation failed — retrying the same input cannot succeed. */\nconst VALIDATION_NAMES: ReadonlySet<string> = new Set(['ValidationError', 'ZodError', 'InputValidationError']);\n\n/** Error names of an abort or a timeout that some OTHER signal raised (the run's own ends as outcome `'aborted'`). */\nconst TRANSPORT_ABORT_NAMES: ReadonlySet<string> = new Set(['AbortError', 'TimeoutError']);\n\n/**\n * The category of an attempt's failure. `outcome` is how the attempt ended (default `'failed'`): it decides\n * `'timeout'` (the attempt's own timer) and `'unknown'` (the run's signal) before the error is read.\n */\nexport function errorCategory(error: unknown, outcome: AttemptOutcome = 'failed'): AttemptCategory {\n  if (outcome === 'timeout') return 'timeout';\n  if (outcome === 'aborted') return 'unknown';\n  try {\n    return categoryOf(error);\n  } catch {\n    return 'unknown';\n  }\n}\n\n/**\n * @internal Terminal ownership preserves a producer's known category. An\n * unresolved effect is unknown, never the category of its physical cause.\n * This does not rewrite historical attempt categories or re-read a known one.\n */\nexport function terminalCategory(error: unknown, known?: AttemptCategory): AttemptCategory {\n  try {\n    if (error instanceof UnknownEffectError) return 'unknown';\n    // CJS and ESM have distinct constructors. A declared own DATA name may\n    // only reduce certainty to unknown; never execute an error's name getter\n    // or promote its physical cause to a known outcome across module copies.\n    if (error !== null && (typeof error === 'object' || typeof error === 'function')) {\n      const name = Object.getOwnPropertyDescriptor(error, 'name');\n      if (name && Object.prototype.hasOwnProperty.call(name, 'value') && name.value === 'UnknownEffectError') {\n        return 'unknown';\n      }\n    }\n  } catch {\n    return known ?? 'unknown';\n  }\n  return known ?? errorCategory(error);\n}\n\nfunction categoryOf(error: unknown): AttemptCategory {\n  if (error instanceof AttemptTimeoutError) return 'timeout';\n  if (error === null || (typeof error !== 'object' && typeof error !== 'function')) return 'unknown';\n  const fields = error as Record<string, unknown>;\n\n  const status = numberField(fields, 'status') ?? numberField(fields, 'statusCode');\n  const declaresRetryAfter = isWait(fields.retryAfterMs) || isWait(fields.retryAfterSeconds);\n  if (status === 429 || declaresRetryAfter) return 'rate-limited';\n  if (status !== undefined && status >= 500 && status <= 599) return 'server';\n  if (status === 401 || status === 403) return 'auth';\n  if (status !== undefined && status >= 400 && status <= 499) return 'permanent';\n\n  if (fields.retryable === false) return 'permanent';\n  if (error instanceof InputValidationError) return 'permanent';\n  const name = typeof fields.name === 'string' ? fields.name : undefined;\n  if (name !== undefined && VALIDATION_NAMES.has(name)) return 'permanent';\n\n  if (status === undefined && isTransportFailure(fields, name)) return 'network';\n  return 'unknown';\n}\n\nfunction isTransportFailure(fields: Record<string, unknown>, name: string | undefined): boolean {\n  if (hasNetworkCode(fields.code)) return true;\n  const cause = fields.cause;\n  if (cause !== null && typeof cause === 'object' && hasNetworkCode((cause as Record<string, unknown>).code)) {\n    return true;\n  }\n  if (name !== undefined && TRANSPORT_ABORT_NAMES.has(name)) return true;\n  return fields instanceof TypeError && typeof fields.message === 'string' && FETCH_FAILURE.test(fields.message);\n}\n\nfunction hasNetworkCode(code: unknown): boolean {\n  return typeof code === 'string' && NETWORK_CODES.has(code);\n}\n\nfunction numberField(fields: Record<string, unknown>, key: 'status' | 'statusCode'): number | undefined {\n  const value = fields[key];\n  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n}\n\nfunction isWait(value: unknown): boolean {\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0;\n}\n"]}

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

@@ -0,0 +1,95 @@
+/**
+ * attempt/correlation.ts — the run's correlation: the W3C `traceparent` codec and the ONE resolution of the env
+ * into a `RunCorrelation` (design docs/design/2026-10-time-and-failure-evidence.md §3.4, packet P4).
+ *
+ * THREAT MODEL. A `traceparent` comes from whoever sent the request. So:
+ *   - it is read STRICTLY to the W3C Trace Context grammar (`version-traceid-parentid-flags`, lowercase hex) and
+ *     anything else is refused by a NAMED reason (`TraceparentError.reason`) — the message never repeats the
+ *     header, and the error holds no copy of it;
+ *   - what the run keeps is the canonical form of what was parsed (`formatTraceparent`), never the received
+ *     bytes — a future version's tail is dropped;
+ *   - it is correlation only: a name the record carries so a run can be found from a trace. Nothing in the
+ *     library treats it as identity or authorisation.
+ *
+ * W3C forward compatibility: a version other than `00` (and never `ff`) is read by its first four fields; a
+ * longer header must continue with `-`. Version `00` is exactly 55 characters. A header longer than
+ * {@link MAX_HEADER_LENGTH} is refused before it is scanned.
+ */
+import type { RunCorrelation } from './types.js';
+/** Why a `traceparent` was refused — a NAME, so a caller can branch on it without reading a message. */
+export type TraceparentRefusal = 'not-a-string' | 'length' | 'version' | 'characters' | 'zero-trace-id' | 'zero-parent-id';
+/** A parsed `traceparent`: the W3C trace-id, the parent-id (the caller's unit of work), and its trace-flags. */
+export interface ParsedTraceparent {
+    /** 32 lowercase hex, not all zeros. */
+    readonly traceId: string;
+    /** The W3C parent-id — 16 lowercase hex, not all zeros. The library's word for it is "operation". */
+    readonly operationId: string;
+    /** Bit 0 of `flags`. */
+    readonly sampled: boolean;
+    /** The trace-flags byte as received — 2 lowercase hex — so a re-format keeps every bit (W3C level 2's random). */
+    readonly flags: string;
+}
+/**
+ * What `formatTraceparent` writes from. `flags` (2 lowercase hex) is the trace-flags byte, `'00'` when absent;
+ * `sampled`, when given, sets or clears its bit 0.
+ */
+export interface TraceparentFields {
+    readonly traceId: string;
+    readonly operationId: string;
+    readonly sampled?: boolean;
+    readonly flags?: string;
+}
+/** The longest header read at all (a future version may append fields; nothing legitimate is near this). */
+export declare const MAX_HEADER_LENGTH = 256;
+/** A `traceparent` the library will not read. The header itself is never in the message or on the error. */
+export declare class TraceparentError extends Error {
+    readonly reason: TraceparentRefusal;
+    constructor(reason: TraceparentRefusal);
+}
+/**
+ * Parse a W3C `traceparent` header strictly. Returns a frozen {@link ParsedTraceparent}; throws a
+ * {@link TraceparentError} naming the first rule the header breaks.
+ *
+ * @example
+ * parseTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01');
+ * // { traceId: '4bf92f3577b34da6a3ce929d0e0e4736', operationId: '00f067aa0ba902b7', sampled: true, flags: '01' }
+ */
+export declare function parseTraceparent(header: unknown): ParsedTraceparent;
+/**
+ * Write a version-00 `traceparent` — for an outbound call that continues this run's trace. Both ids must be W3C
+ * ids and `flags` a byte of 2 lowercase hex (refused by name otherwise, like a parse); `sampled`, when given,
+ * sets or clears bit 0 of the flags. `formatTraceparent(parseTraceparent(h))` is `h` for any valid version-00 `h`.
+ *
+ * @example
+ * formatTraceparent({ traceId, operationId: mySpanId, sampled: true }); // '00-<traceId>-<mySpanId>-01'
+ */
+export declare function formatTraceparent(fields: TraceparentFields): string;
+/** The env fields correlation reads — structural, so this L5 file names nothing of the engine's `ExecutionEnv`. */
+export interface CorrelationEnv {
+    readonly traceparent?: unknown;
+    readonly traceId?: unknown;
+    readonly operationId?: unknown;
+}
+/**
+ * Admit a leg's env ONCE (called by `FlowChartExecutor · run` / `resume` before anything moves): a single
+ * own-property snapshot of it — every getter runs once, nothing is read off the prototype — and the correlation
+ * resolved from that snapshot. In the snapshot the stages see (`$getEnv()`), `traceparent` is exactly
+ * `correlation.traceparent` — the canonical header of the effective ids, or no key when the run's correlation has
+ * none — so stage code never holds the received bytes, nor a header naming another trace than the record.
+ * `env` is `undefined` exactly when none was given.
+ */
+export declare function admitRunEnv<E extends object>(env: E | undefined): {
+    readonly env: E | undefined;
+    readonly correlation: RunCorrelation | undefined;
+};
+/**
+ * The ONE resolution of a leg's correlation from its env. Only OWN fields count. `traceparent` is parsed once (a
+ * bad header refuses the leg — explicit ids do not rescue it); explicit `traceId` / `operationId` win over the
+ * header's and must be 1–256 printable ASCII characters (refused by field name, never echoed); an empty one is
+ * no id. Everything of the header — its parent-id as the operation, `sampled`, `traceparent` — rides only while
+ * the trace IS the header's, and `traceparent` is rebuilt from the EFFECTIVE ids with the header's flags
+ * (omitted when the operation is not a W3C parent-id), so the record never names one trace and files or
+ * propagates another's. Returns `undefined` when there is no trace id at all — and refuses
+ * an `operationId` with no trace to belong to.
+ */
+export declare function resolveCorrelation(env: CorrelationEnv | undefined): RunCorrelation | undefined;

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

@@ -0,0 +1,178 @@
+/**
+ * attempt/correlation.ts — the run's correlation: the W3C `traceparent` codec and the ONE resolution of the env
+ * into a `RunCorrelation` (design docs/design/2026-10-time-and-failure-evidence.md §3.4, packet P4).
+ *
+ * THREAT MODEL. A `traceparent` comes from whoever sent the request. So:
+ *   - it is read STRICTLY to the W3C Trace Context grammar (`version-traceid-parentid-flags`, lowercase hex) and
+ *     anything else is refused by a NAMED reason (`TraceparentError.reason`) — the message never repeats the
+ *     header, and the error holds no copy of it;
+ *   - what the run keeps is the canonical form of what was parsed (`formatTraceparent`), never the received
+ *     bytes — a future version's tail is dropped;
+ *   - it is correlation only: a name the record carries so a run can be found from a trace. Nothing in the
+ *     library treats it as identity or authorisation.
+ *
+ * W3C forward compatibility: a version other than `00` (and never `ff`) is read by its first four fields; a
+ * longer header must continue with `-`. Version `00` is exactly 55 characters. A header longer than
+ * {@link MAX_HEADER_LENGTH} is refused before it is scanned.
+ */
+/** The longest header read at all (a future version may append fields; nothing legitimate is near this). */
+export const MAX_HEADER_LENGTH = 256;
+/** A version-00 header, exactly. */
+const V00_LENGTH = 55;
+const WHY = {
+    'not-a-string': 'it is not a string',
+    length: 'its length is not a W3C traceparent length (55 characters for version 00)',
+    version: 'its version is not two lowercase hex digits other than ff',
+    characters: 'it is not lowercase hex fields in the W3C layout version-traceid-parentid-flags',
+    'zero-trace-id': 'its trace-id is all zeros',
+    'zero-parent-id': 'its parent-id is all zeros',
+};
+/** A `traceparent` the library will not read. The header itself is never in the message or on the error. */
+export class TraceparentError extends Error {
+    reason;
+    constructor(reason) {
+        super(`traceparent refused (${reason}): ${WHY[reason]}`);
+        this.name = 'TraceparentError';
+        this.reason = reason;
+    }
+}
+const HEX2 = /^[0-9a-f]{2}$/;
+const HEX16 = /^[0-9a-f]{16}$/;
+const HEX32 = /^[0-9a-f]{32}$/;
+const ZEROS = /^0+$/;
+/**
+ * Parse a W3C `traceparent` header strictly. Returns a frozen {@link ParsedTraceparent}; throws a
+ * {@link TraceparentError} naming the first rule the header breaks.
+ *
+ * @example
+ * parseTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01');
+ * // { traceId: '4bf92f3577b34da6a3ce929d0e0e4736', operationId: '00f067aa0ba902b7', sampled: true, flags: '01' }
+ */
+export function parseTraceparent(header) {
+    if (typeof header !== 'string')
+        throw new TraceparentError('not-a-string');
+    if (header.length < V00_LENGTH || header.length > MAX_HEADER_LENGTH)
+        throw new TraceparentError('length');
+    const version = header.slice(0, 2);
+    if (!HEX2.test(version) || version === 'ff')
+        throw new TraceparentError('version');
+    if (version === '00' && header.length !== V00_LENGTH)
+        throw new TraceparentError('length');
+    const traceId = header.slice(3, 35);
+    const operationId = header.slice(36, 52);
+    const flags = header.slice(53, 55);
+    const laidOut = header[2] === '-' && header[35] === '-' && header[52] === '-';
+    const tailOk = header.length === V00_LENGTH || header[V00_LENGTH] === '-';
+    if (!laidOut || !tailOk || !HEX32.test(traceId) || !HEX16.test(operationId) || !HEX2.test(flags)) {
+        throw new TraceparentError('characters');
+    }
+    if (ZEROS.test(traceId))
+        throw new TraceparentError('zero-trace-id');
+    if (ZEROS.test(operationId))
+        throw new TraceparentError('zero-parent-id');
+    return Object.freeze({ traceId, operationId, sampled: (parseInt(flags, 16) & 1) === 1, flags });
+}
+/**
+ * Write a version-00 `traceparent` — for an outbound call that continues this run's trace. Both ids must be W3C
+ * ids and `flags` a byte of 2 lowercase hex (refused by name otherwise, like a parse); `sampled`, when given,
+ * sets or clears bit 0 of the flags. `formatTraceparent(parseTraceparent(h))` is `h` for any valid version-00 `h`.
+ *
+ * @example
+ * formatTraceparent({ traceId, operationId: mySpanId, sampled: true }); // '00-<traceId>-<mySpanId>-01'
+ */
+export function formatTraceparent(fields) {
+    const { traceId, operationId } = fields;
+    if (typeof traceId !== 'string' || typeof operationId !== 'string')
+        throw new TraceparentError('not-a-string');
+    if (!HEX32.test(traceId) || !HEX16.test(operationId))
+        throw new TraceparentError('characters');
+    if (ZEROS.test(traceId))
+        throw new TraceparentError('zero-trace-id');
+    if (ZEROS.test(operationId))
+        throw new TraceparentError('zero-parent-id');
+    return `00-${traceId}-${operationId}-${flagsOf(fields)}`;
+}
+/** The trace-flags byte to write: the given one (or `00`), bit 0 set or cleared by `sampled` when it is given. */
+function flagsOf(fields) {
+    const { flags = '00', sampled } = fields;
+    if (typeof flags !== 'string')
+        throw new TraceparentError('not-a-string');
+    if (!HEX2.test(flags))
+        throw new TraceparentError('characters');
+    if (sampled === undefined)
+        return flags;
+    const byte = sampled ? parseInt(flags, 16) | 1 : parseInt(flags, 16) & 0xfe;
+    return byte.toString(16).padStart(2, '0');
+}
+/** An explicit id: 1–256 printable ASCII characters, no space — a name a log line or an exporter can carry. */
+const EXPLICIT_ID = /^[\x21-\x7e]{1,256}$/;
+/**
+ * Admit a leg's env ONCE (called by `FlowChartExecutor · run` / `resume` before anything moves): a single
+ * own-property snapshot of it — every getter runs once, nothing is read off the prototype — and the correlation
+ * resolved from that snapshot. In the snapshot the stages see (`$getEnv()`), `traceparent` is exactly
+ * `correlation.traceparent` — the canonical header of the effective ids, or no key when the run's correlation has
+ * none — so stage code never holds the received bytes, nor a header naming another trace than the record.
+ * `env` is `undefined` exactly when none was given.
+ */
+export function admitRunEnv(env) {
+    if (env === undefined || env === null)
+        return { env: undefined, correlation: undefined };
+    const snapshot = { ...env };
+    const correlation = resolveParsed(snapshot);
+    if (correlation?.traceparent !== undefined)
+        snapshot.traceparent = correlation.traceparent;
+    else if (snapshot.traceparent !== undefined)
+        delete snapshot.traceparent; // a header the record does not carry
+    return { env: snapshot, correlation };
+}
+/**
+ * The ONE resolution of a leg's correlation from its env. Only OWN fields count. `traceparent` is parsed once (a
+ * bad header refuses the leg — explicit ids do not rescue it); explicit `traceId` / `operationId` win over the
+ * header's and must be 1–256 printable ASCII characters (refused by field name, never echoed); an empty one is
+ * no id. Everything of the header — its parent-id as the operation, `sampled`, `traceparent` — rides only while
+ * the trace IS the header's, and `traceparent` is rebuilt from the EFFECTIVE ids with the header's flags
+ * (omitted when the operation is not a W3C parent-id), so the record never names one trace and files or
+ * propagates another's. Returns `undefined` when there is no trace id at all — and refuses
+ * an `operationId` with no trace to belong to.
+ */
+export function resolveCorrelation(env) {
+    if (env === undefined || env === null)
+        return undefined;
+    return resolveParsed({ ...env });
+}
+/** {@link resolveCorrelation} over an env already snapshotted (each field read once). */
+function resolveParsed(env) {
+    const raw = own(env, 'traceparent');
+    const header = raw === undefined ? undefined : parseTraceparent(raw);
+    const traceId = explicitId(own(env, 'traceId'), 'traceId') ?? header?.traceId;
+    const sameTrace = header !== undefined && traceId === header.traceId;
+    const operationId = explicitId(own(env, 'operationId'), 'operationId') ?? (sameTrace ? header.operationId : undefined);
+    if (traceId === undefined) {
+        if (operationId !== undefined) {
+            throw new TypeError('env.operationId needs a trace to belong to: give env.traceId or env.traceparent');
+        }
+        return undefined;
+    }
+    const propagable = sameTrace && operationId !== undefined && HEX16.test(operationId) && !ZEROS.test(operationId);
+    return Object.freeze({
+        traceId,
+        ...(operationId !== undefined && { operationId }),
+        ...(sameTrace && { sampled: header.sampled }),
+        ...(propagable && { traceparent: formatTraceparent({ traceId, operationId, flags: header.flags }) }),
+    });
+}
+/** An own field's value — a value inherited through the prototype is not the caller's. */
+function own(env, field) {
+    return Object.prototype.hasOwnProperty.call(env, field) ? env[field] : undefined;
+}
+function explicitId(value, field) {
+    if (value === undefined || value === '')
+        return undefined;
+    if (typeof value !== 'string')
+        throw new TypeError(`env.${field} must be a string`);
+    if (!EXPLICIT_ID.test(value)) {
+        throw new TypeError(`env.${field} refused: an id is 1–256 printable ASCII characters with no space`);
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correlation.js","sourceRoot":"","sources":["../../../../src/lib/attempt/correlation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/correlation.ts — the run's correlation: the W3C `traceparent` codec and the ONE resolution of the env\n * into a `RunCorrelation` (design docs/design/2026-10-time-and-failure-evidence.md §3.4, packet P4).\n *\n * THREAT MODEL. A `traceparent` comes from whoever sent the request. So:\n *   - it is read STRICTLY to the W3C Trace Context grammar (`version-traceid-parentid-flags`, lowercase hex) and\n *     anything else is refused by a NAMED reason (`TraceparentError.reason`) — the message never repeats the\n *     header, and the error holds no copy of it;\n *   - what the run keeps is the canonical form of what was parsed (`formatTraceparent`), never the received\n *     bytes — a future version's tail is dropped;\n *   - it is correlation only: a name the record carries so a run can be found from a trace. Nothing in the\n *     library treats it as identity or authorisation.\n *\n * W3C forward compatibility: a version other than `00` (and never `ff`) is read by its first four fields; a\n * longer header must continue with `-`. Version `00` is exactly 55 characters. A header longer than\n * {@link MAX_HEADER_LENGTH} is refused before it is scanned.\n */\n\nimport type { RunCorrelation } from './types.js';\n\n/** Why a `traceparent` was refused — a NAME, so a caller can branch on it without reading a message. */\nexport type TraceparentRefusal =\n  | 'not-a-string'\n  | 'length'\n  | 'version'\n  | 'characters'\n  | 'zero-trace-id'\n  | 'zero-parent-id';\n\n/** A parsed `traceparent`: the W3C trace-id, the parent-id (the caller's unit of work), and its trace-flags. */\nexport interface ParsedTraceparent {\n  /** 32 lowercase hex, not all zeros. */\n  readonly traceId: string;\n  /** The W3C parent-id — 16 lowercase hex, not all zeros. The library's word for it is \"operation\". */\n  readonly operationId: string;\n  /** Bit 0 of `flags`. */\n  readonly sampled: boolean;\n  /** The trace-flags byte as received — 2 lowercase hex — so a re-format keeps every bit (W3C level 2's random). */\n  readonly flags: string;\n}\n\n/**\n * What `formatTraceparent` writes from. `flags` (2 lowercase hex) is the trace-flags byte, `'00'` when absent;\n * `sampled`, when given, sets or clears its bit 0.\n */\nexport interface TraceparentFields {\n  readonly traceId: string;\n  readonly operationId: string;\n  readonly sampled?: boolean;\n  readonly flags?: string;\n}\n\n/** The longest header read at all (a future version may append fields; nothing legitimate is near this). */\nexport const MAX_HEADER_LENGTH = 256;\n/** A version-00 header, exactly. */\nconst V00_LENGTH = 55;\n\nconst WHY: Readonly<Record<TraceparentRefusal, string>> = {\n  'not-a-string': 'it is not a string',\n  length: 'its length is not a W3C traceparent length (55 characters for version 00)',\n  version: 'its version is not two lowercase hex digits other than ff',\n  characters: 'it is not lowercase hex fields in the W3C layout version-traceid-parentid-flags',\n  'zero-trace-id': 'its trace-id is all zeros',\n  'zero-parent-id': 'its parent-id is all zeros',\n};\n\n/** A `traceparent` the library will not read. The header itself is never in the message or on the error. */\nexport class TraceparentError extends Error {\n  readonly reason: TraceparentRefusal;\n\n  constructor(reason: TraceparentRefusal) {\n    super(`traceparent refused (${reason}): ${WHY[reason]}`);\n    this.name = 'TraceparentError';\n    this.reason = reason;\n  }\n}\n\nconst HEX2 = /^[0-9a-f]{2}$/;\nconst HEX16 = /^[0-9a-f]{16}$/;\nconst HEX32 = /^[0-9a-f]{32}$/;\nconst ZEROS = /^0+$/;\n\n/**\n * Parse a W3C `traceparent` header strictly. Returns a frozen {@link ParsedTraceparent}; throws a\n * {@link TraceparentError} naming the first rule the header breaks.\n *\n * @example\n * parseTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01');\n * // { traceId: '4bf92f3577b34da6a3ce929d0e0e4736', operationId: '00f067aa0ba902b7', sampled: true, flags: '01' }\n */\nexport function parseTraceparent(header: unknown): ParsedTraceparent {\n  if (typeof header !== 'string') throw new TraceparentError('not-a-string');\n  if (header.length < V00_LENGTH || header.length > MAX_HEADER_LENGTH) throw new TraceparentError('length');\n  const version = header.slice(0, 2);\n  if (!HEX2.test(version) || version === 'ff') throw new TraceparentError('version');\n  if (version === '00' && header.length !== V00_LENGTH) throw new TraceparentError('length');\n\n  const traceId = header.slice(3, 35);\n  const operationId = header.slice(36, 52);\n  const flags = header.slice(53, 55);\n  const laidOut = header[2] === '-' && header[35] === '-' && header[52] === '-';\n  const tailOk = header.length === V00_LENGTH || header[V00_LENGTH] === '-';\n  if (!laidOut || !tailOk || !HEX32.test(traceId) || !HEX16.test(operationId) || !HEX2.test(flags)) {\n    throw new TraceparentError('characters');\n  }\n  if (ZEROS.test(traceId)) throw new TraceparentError('zero-trace-id');\n  if (ZEROS.test(operationId)) throw new TraceparentError('zero-parent-id');\n\n  return Object.freeze({ traceId, operationId, sampled: (parseInt(flags, 16) & 1) === 1, flags });\n}\n\n/**\n * Write a version-00 `traceparent` — for an outbound call that continues this run's trace. Both ids must be W3C\n * ids and `flags` a byte of 2 lowercase hex (refused by name otherwise, like a parse); `sampled`, when given,\n * sets or clears bit 0 of the flags. `formatTraceparent(parseTraceparent(h))` is `h` for any valid version-00 `h`.\n *\n * @example\n * formatTraceparent({ traceId, operationId: mySpanId, sampled: true }); // '00-<traceId>-<mySpanId>-01'\n */\nexport function formatTraceparent(fields: TraceparentFields): string {\n  const { traceId, operationId } = fields;\n  if (typeof traceId !== 'string' || typeof operationId !== 'string') throw new TraceparentError('not-a-string');\n  if (!HEX32.test(traceId) || !HEX16.test(operationId)) throw new TraceparentError('characters');\n  if (ZEROS.test(traceId)) throw new TraceparentError('zero-trace-id');\n  if (ZEROS.test(operationId)) throw new TraceparentError('zero-parent-id');\n  return `00-${traceId}-${operationId}-${flagsOf(fields)}`;\n}\n\n/** The trace-flags byte to write: the given one (or `00`), bit 0 set or cleared by `sampled` when it is given. */\nfunction flagsOf(fields: TraceparentFields): string {\n  const { flags = '00', sampled } = fields;\n  if (typeof flags !== 'string') throw new TraceparentError('not-a-string');\n  if (!HEX2.test(flags)) throw new TraceparentError('characters');\n  if (sampled === undefined) return flags;\n  const byte = sampled ? parseInt(flags, 16) | 1 : parseInt(flags, 16) & 0xfe;\n  return byte.toString(16).padStart(2, '0');\n}\n\n/** The env fields correlation reads — structural, so this L5 file names nothing of the engine's `ExecutionEnv`. */\nexport interface CorrelationEnv {\n  readonly traceparent?: unknown;\n  readonly traceId?: unknown;\n  readonly operationId?: unknown;\n}\n\n/** An explicit id: 1–256 printable ASCII characters, no space — a name a log line or an exporter can carry. */\nconst EXPLICIT_ID = /^[\\x21-\\x7e]{1,256}$/;\n\n/**\n * Admit a leg's env ONCE (called by `FlowChartExecutor · run` / `resume` before anything moves): a single\n * own-property snapshot of it — every getter runs once, nothing is read off the prototype — and the correlation\n * resolved from that snapshot. In the snapshot the stages see (`$getEnv()`), `traceparent` is exactly\n * `correlation.traceparent` — the canonical header of the effective ids, or no key when the run's correlation has\n * none — so stage code never holds the received bytes, nor a header naming another trace than the record.\n * `env` is `undefined` exactly when none was given.\n */\nexport function admitRunEnv<E extends object>(\n  env: E | undefined,\n): { readonly env: E | undefined; readonly correlation: RunCorrelation | undefined } {\n  if (env === undefined || env === null) return { env: undefined, correlation: undefined };\n  const snapshot = { ...env } as E & { traceparent?: unknown };\n  const correlation = resolveParsed(snapshot);\n  if (correlation?.traceparent !== undefined) snapshot.traceparent = correlation.traceparent;\n  else if (snapshot.traceparent !== undefined) delete snapshot.traceparent; // a header the record does not carry\n  return { env: snapshot, correlation };\n}\n\n/**\n * The ONE resolution of a leg's correlation from its env. Only OWN fields count. `traceparent` is parsed once (a\n * bad header refuses the leg — explicit ids do not rescue it); explicit `traceId` / `operationId` win over the\n * header's and must be 1–256 printable ASCII characters (refused by field name, never echoed); an empty one is\n * no id. Everything of the header — its parent-id as the operation, `sampled`, `traceparent` — rides only while\n * the trace IS the header's, and `traceparent` is rebuilt from the EFFECTIVE ids with the header's flags\n * (omitted when the operation is not a W3C parent-id), so the record never names one trace and files or\n * propagates another's. Returns `undefined` when there is no trace id at all — and refuses\n * an `operationId` with no trace to belong to.\n */\nexport function resolveCorrelation(env: CorrelationEnv | undefined): RunCorrelation | undefined {\n  if (env === undefined || env === null) return undefined;\n  return resolveParsed({ ...env });\n}\n\n/** {@link resolveCorrelation} over an env already snapshotted (each field read once). */\nfunction resolveParsed(env: CorrelationEnv): RunCorrelation | undefined {\n  const raw = own(env, 'traceparent');\n  const header = raw === undefined ? undefined : parseTraceparent(raw);\n  const traceId = explicitId(own(env, 'traceId'), 'traceId') ?? header?.traceId;\n  const sameTrace = header !== undefined && traceId === header.traceId;\n  const operationId =\n    explicitId(own(env, 'operationId'), 'operationId') ?? (sameTrace ? header.operationId : undefined);\n  if (traceId === undefined) {\n    if (operationId !== undefined) {\n      throw new TypeError('env.operationId needs a trace to belong to: give env.traceId or env.traceparent');\n    }\n    return undefined;\n  }\n  const propagable = sameTrace && operationId !== undefined && HEX16.test(operationId) && !ZEROS.test(operationId);\n  return Object.freeze({\n    traceId,\n    ...(operationId !== undefined && { operationId }),\n    ...(sameTrace && { sampled: header.sampled }),\n    ...(propagable && { traceparent: formatTraceparent({ traceId, operationId, flags: header.flags }) }),\n  });\n}\n\n/** An own field's value — a value inherited through the prototype is not the caller's. */\nfunction own(env: CorrelationEnv, field: keyof CorrelationEnv): unknown {\n  return Object.prototype.hasOwnProperty.call(env, field) ? env[field] : undefined;\n}\n\nfunction explicitId(value: unknown, field: 'traceId' | 'operationId'): string | undefined {\n  if (value === undefined || value === '') return undefined;\n  if (typeof value !== 'string') throw new TypeError(`env.${field} must be a string`);\n  if (!EXPLICIT_ID.test(value)) {\n    throw new TypeError(`env.${field} refused: an id is 1–256 printable ASCII characters with no space`);\n  }\n  return value;\n}\n"]}

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

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+/** The reason the run's signal aborts with when its deadline passes — an `Error`, branded as the deadline's. */
+export declare function deadlineReason(message: string): Error;
+/**
+ * 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 declare function markTimeLimit<T extends object>(reason: T): T;
+/** Whether `reason` is the run's deadline or an attempt's cap — a time limit, not a cancellation. */
+export declare function isDeadlineReason(reason: unknown): boolean;
+/** Whether the signal aborted for a reason OTHER than a time limit — a cancellation. */
+export declare function isCancelled(signal: AbortSignal | undefined): boolean;
+/** A deadline as the engine reads one: a finite number (epoch ms), else none. */
+export declare function readDeadline(value: unknown): number | undefined;
+/**
+ * `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 declare function setLongTimeout(fn: () => void, ms: number): () => void;
+/** Whether `value` is an AbortSignal (structurally — a signal from another realm counts). */
+export declare function isAbortSignal(value: unknown): value is AbortSignal;
+/** A signal that aborts at a deadline (or with its input), and the one call that releases both. */
+export interface ArmedDeadline {
+    readonly signal: AbortSignal | undefined;
+    dispose(): void;
+}
+/**
+ * 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 declare function armDeadline(signal: AbortSignal | undefined, deadline: number | undefined, message: string, now?: () => number): ArmedDeadline;