footprintjs 10.0.1 → 10.2.0

package/dist/lib/attempt/call.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * attempt/call.ts — a call made INSIDE a stage attempt: `scope.$call(target, fn, policy?)` (design §3.6, §3.8,
+ * packet P2).
+ *
+ * The same loop as a stage's retry (`runAttempts`, law 1), kind `'call'`, its `target` on every record — and a
+ * record even for a single call (`attempts: 1`): timing and outcome evidence with no retry. Its series is the
+ * call level of foottrace's attempt-id grammar ({@link callSeries}).
+ *
+ * THE LAW — a call lives within the attempt that made it. The host (the stage's scope) hands it that attempt's
+ * signal and its end as the call's deadline, so the call is capped by the time its stage attempt has left, and is
+ * cut when the stage attempt is cut (a time limit, so `'timeout'`; a cancellation, so `'aborted'`); and an `ended`
+ * signal that aborts when the attempt is over however it ended (it returned, threw, or its frame committed), so a
+ * call never outlives it. Following the P1b fence:
+ *   - the record of a call attempt cut BY its stage attempt's own abort lands — the cut is evidence;
+ *   - any other record that arrives once the stage attempt is over is REFUSED: noted by name (`host.refused`), never
+ *     kept, never fired; the call stops (its in-flight attempt is cut, a wait ends) and no further attempt of an
+ *     outside call starts — and the library-made rejection of such an orphan never surfaces as an unhandled one;
+ *   - a call never starts under a signal already aborted, nor past its deadline while that signal is still due (a
+ *     busy event loop fires timers late): no attempt, no record — the host's signal is its ONE deadline source.
+ * What the call's function does after its attempt ended cannot be trapped — it should RETURN its answer, not write
+ * the stage's scope (the scope's own fence still refuses a write from an ended stage attempt).
+ *
+ * A LEAF of the engine (L5): the host is a port, so nothing here names the scope.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCall = exports.callSeries = void 0;
+const anySignal_js_1 = require("./anySignal.js");
+const deadline_js_1 = require("./deadline.js");
+const runner_js_1 = require("./runner.js");
+/**
+ * The series of the `ordinal`-th call (1-based) made during attempt `stageAttempt` of the stage execution
+ * `runtimeStageId`: `<runtimeStageId>@<n>.<k>` — so the id of the call's attempt `m` is `<series>@<m>`, foottrace's
+ * `buildAttemptId(runtimeStageId, n, { ordinal: k, attempt: m })` (design §3.4). Written here, in this one place,
+ * until the engine adopts foottrace 1.1.0's codec (P6); the bytes are the grammar's.
+ */
+function callSeries(runtimeStageId, stageAttempt, ordinal) {
+    return `${runtimeStageId}@${stageAttempt}.${ordinal}`;
+}
+exports.callSeries = callSeries;
+/**
+ * Run `fn` as the call `target` under `policy` (already admitted — `policy.ts · admitCallPolicy`) for `host`.
+ * Resolves with the answer, or rejects with the last attempt's own error.
+ */
+function runCall(target, fn, policy, host) {
+    const hostSignal = host.signal;
+    const now = host.now ?? Date.now;
+    // Started under an aborted signal, or after the attempt that makes it ended: no attempt, no record.
+    for (const signal of [hostSignal, host.ended])
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+    const stop = new AbortController();
+    // ONE deadline source. A host's signal aborts at the host's deadline (its attempt's cap, or the run's deadline),
+    // so a second timer for the same instant could only race it — and, firing first, end the call with a reason of
+    // its own and fail the stage instead of timing it out. A host with a deadline and no signal gets the one timer.
+    const own = hostSignal === undefined
+        ? (0, deadline_js_1.armDeadline)(undefined, host.deadline, lateCallMessage(target, undefined, 'ran out of time'), now)
+        : undefined;
+    const composed = (0, anySignal_js_1.anySignal)([hostSignal, host.ended, own?.signal, stop.signal]);
+    // An orphan — a call still running when the attempt that made it ended — is stopped by the library, so its
+    // rejection must not surface as an unhandled one; whoever awaits it still gets it.
+    let result;
+    const quiet = () => {
+        result?.catch(() => undefined);
+    };
+    host.ended?.addEventListener('abort', quiet, { once: true });
+    const release = () => {
+        host.ended?.removeEventListener('abort', quiet);
+        own?.dispose();
+        composed.dispose();
+    };
+    if (composed.signal.aborted) {
+        release();
+        return Promise.reject(composed.signal.reason);
+    }
+    // Past the deadline while its signal is still due (a busy event loop fires timers late): nothing is sent — the
+    // call ends, with no record, when that signal aborts.
+    if (host.deadline !== undefined && now() >= host.deadline) {
+        result = new Promise((_resolve, reject) => {
+            composed.signal.addEventListener('abort', () => {
+                release();
+                reject(composed.signal.reason);
+            }, { once: true });
+        });
+        return result;
+    }
+    const seriesName = host.openSeries();
+    /** Call attempts ended BY the stage attempt's end — their records are the evidence of the cut. */
+    const cut = new Set();
+    const ended = () => new Error(lateCallMessage(target, seriesName, 'cannot continue'));
+    const series = (0, runner_js_1.runAttempts)((_attempt, context) => {
+        // The attempt that made this call is over: no further attempt of an outside call starts.
+        if (!host.admits(false)) {
+            const reason = ended();
+            stop.abort(reason);
+            throw reason;
+        }
+        return fn(context);
+    }, policy, {
+        series: seriesName,
+        kind: 'call',
+        target,
+        ...(host.effect !== undefined && { effect: host.effect }),
+        signal: composed.signal,
+        ...(host.deadline !== undefined && { deadline: host.deadline }),
+        now,
+        serve: (error) => host.serve(error),
+        // Synchronous at the abort: the stage attempt's signal aborting is what cut this call attempt.
+        onAbandon: (attempt) => {
+            if (hostSignal?.aborted)
+                cut.add(attempt);
+        },
+        onAttempt: (record, structuredError) => {
+            if (host.admits(cut.has(record.attempt))) {
+                host.report(record, structuredError);
+                return;
+            }
+            host.refused();
+            // Nothing follows a refused record: a wait ends now and the series stops `aborted`.
+            if (!stop.signal.aborted)
+                stop.abort(ended());
+        },
+        observe: (report, at) => host.observe(report, at),
+    });
+    result = series.finally(release);
+    return result;
+}
+exports.runCall = runCall;
+/** Why a call stopped or could not go on — its target and series are names; no value is in the message. */
+function lateCallMessage(target, series, what) {
+    return (`[footprint] $call "${target}"${series === undefined ? '' : ` (${series})`} ${what}: the attempt that made this ` +
+        'call has ended — no further attempt of it starts, and nothing it records lands on the stage.');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"call.js","sourceRoot":"","sources":["../../../src/lib/attempt/call.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * attempt/call.ts — a call made INSIDE a stage attempt: `scope.$call(target, fn, policy?)` (design §3.6, §3.8,\n * packet P2).\n *\n * The same loop as a stage's retry (`runAttempts`, law 1), kind `'call'`, its `target` on every record — and a\n * record even for a single call (`attempts: 1`): timing and outcome evidence with no retry. Its series is the\n * call level of foottrace's attempt-id grammar ({@link callSeries}).\n *\n * THE LAW — a call lives within the attempt that made it. The host (the stage's scope) hands it that attempt's\n * signal and its end as the call's deadline, so the call is capped by the time its stage attempt has left, and is\n * cut when the stage attempt is cut (a time limit, so `'timeout'`; a cancellation, so `'aborted'`); and an `ended`\n * signal that aborts when the attempt is over however it ended (it returned, threw, or its frame committed), so a\n * call never outlives it. Following the P1b fence:\n *   - the record of a call attempt cut BY its stage attempt's own abort lands — the cut is evidence;\n *   - any other record that arrives once the stage attempt is over is REFUSED: noted by name (`host.refused`), never\n *     kept, never fired; the call stops (its in-flight attempt is cut, a wait ends) and no further attempt of an\n *     outside call starts — and the library-made rejection of such an orphan never surfaces as an unhandled one;\n *   - a call never starts under a signal already aborted, nor past its deadline while that signal is still due (a\n *     busy event loop fires timers late): no attempt, no record — the host's signal is its ONE deadline source.\n * What the call's function does after its attempt ended cannot be trapped — it should RETURN its answer, not write\n * the stage's scope (the scope's own fence still refuses a write from an ended stage attempt).\n *\n * A LEAF of the engine (L5): the host is a port, so nothing here names the scope.\n */\n\nimport type { StructuredErrorInfo } from '../errors/errorInfo.js';\nimport { anySignal } from './anySignal.js';\nimport { armDeadline } from './deadline.js';\nimport type { EffectTarget } from './effect.js';\nimport { runAttempts } from './runner.js';\nimport type { AttemptContext, AttemptRecord, ObservedAttempt, RetryPolicy } from './types.js';\n\n/**\n * The series of the `ordinal`-th call (1-based) made during attempt `stageAttempt` of the stage execution\n * `runtimeStageId`: `<runtimeStageId>@<n>.<k>` — so the id of the call's attempt `m` is `<series>@<m>`, foottrace's\n * `buildAttemptId(runtimeStageId, n, { ordinal: k, attempt: m })` (design §3.4). Written here, in this one place,\n * until the engine adopts foottrace 1.1.0's codec (P6); the bytes are the grammar's.\n */\nexport function callSeries(runtimeStageId: string, stageAttempt: number, ordinal: number): string {\n  return `${runtimeStageId}@${stageAttempt}.${ordinal}`;\n}\n\n/** What the attempt that makes a call gives it — the scope implements it. */\nexport interface CallHost {\n  /**\n   * The call's series ({@link callSeries}) — asked once, only when the call starts, so a call refused before it\n   * starts takes no ordinal and leaves no gap.\n   */\n  openSeries(): string;\n  /**\n   * The stage attempt's signal: the run's cancellation, the run's deadline and the attempt's own cap. When given, it\n   * is the call's ONE deadline source — it must abort at {@link deadline}, with a time-limit reason\n   * (`deadline.ts · markTimeLimit` / `deadlineReason`); the call arms no timer of its own.\n   */\n  readonly signal?: AbortSignal;\n  /**\n   * When the stage attempt must end, epoch ms — the call's deadline, capping each attempt by the time left. Absent\n   * for an uncapped attempt. Without a {@link signal}, the call arms the one timer that ends it here.\n   */\n  readonly deadline?: number;\n  /** The clock (default `Date.now`). */\n  readonly now?: () => number;\n  /**\n   * Aborts when the attempt that makes the call is over — however it ended — and when its frame commits: the call\n   * stops (its in-flight attempt is cut, a wait ends, no attempt follows) and its records are refused. No call\n   * outlives the attempt that made it.\n   */\n  readonly ended?: AbortSignal;\n  /**\n   * May a record of the call land on the stage now? `cut`: the call attempt was ended BY the stage attempt's own\n   * end, so its record is the evidence of that cut.\n   */\n  admits(cut: boolean): boolean;\n  /** The served form of an attempt's error — the run's redaction rule. */\n  serve(error: unknown): StructuredErrorInfo;\n  /** A record that may land: onto the stage, and the run's `onAttempt`. */\n  report(record: AttemptRecord, structuredError: StructuredErrorInfo | undefined): void;\n  /** A record that may not — the call outlived the attempt that made it. A name is noted; nothing is kept. */\n  refused(): void;\n  /**\n   * The outside system the call touches and its key (P3) — admitted at the call (`effect.ts · callTouches`), the\n   * recorded key served under the run's rule. Every record then carries its `effect`, and a series ended without an answer after an attempt of unknown\n   * effect rejects with `UnknownEffectError`.\n   */\n  readonly effect?: EffectTarget;\n  /** An observed report made through the call's own attempt context (`ended`: that call attempt was over). */\n  observe(report: ObservedAttempt, at: { readonly attempt: number; readonly ended: boolean }): void;\n}\n\n/**\n * Run `fn` as the call `target` under `policy` (already admitted — `policy.ts · admitCallPolicy`) for `host`.\n * Resolves with the answer, or rejects with the last attempt's own error.\n */\nexport function runCall<T>(\n  target: string,\n  fn: (attempt: AttemptContext) => Promise<T> | T,\n  policy: RetryPolicy,\n  host: CallHost,\n): Promise<T> {\n  const hostSignal = host.signal;\n  const now = host.now ?? Date.now;\n  // Started under an aborted signal, or after the attempt that makes it ended: no attempt, no record.\n  for (const signal of [hostSignal, host.ended]) if (signal?.aborted) return Promise.reject(signal.reason);\n  const stop = new AbortController();\n  // ONE deadline source. A host's signal aborts at the host's deadline (its attempt's cap, or the run's deadline),\n  // so a second timer for the same instant could only race it — and, firing first, end the call with a reason of\n  // its own and fail the stage instead of timing it out. A host with a deadline and no signal gets the one timer.\n  const own =\n    hostSignal === undefined\n      ? armDeadline(undefined, host.deadline, lateCallMessage(target, undefined, 'ran out of time'), now)\n      : undefined;\n  const composed = anySignal([hostSignal, host.ended, own?.signal, stop.signal]);\n  // An orphan — a call still running when the attempt that made it ended — is stopped by the library, so its\n  // rejection must not surface as an unhandled one; whoever awaits it still gets it.\n  let result: Promise<T> | undefined;\n  const quiet = () => {\n    result?.catch(() => undefined);\n  };\n  host.ended?.addEventListener('abort', quiet, { once: true });\n  const release = () => {\n    host.ended?.removeEventListener('abort', quiet);\n    own?.dispose();\n    composed.dispose();\n  };\n  if (composed.signal.aborted) {\n    release();\n    return Promise.reject(composed.signal.reason);\n  }\n  // Past the deadline while its signal is still due (a busy event loop fires timers late): nothing is sent — the\n  // call ends, with no record, when that signal aborts.\n  if (host.deadline !== undefined && now() >= host.deadline) {\n    result = new Promise<T>((_resolve, reject) => {\n      composed.signal.addEventListener(\n        'abort',\n        () => {\n          release();\n          reject(composed.signal.reason);\n        },\n        { once: true },\n      );\n    });\n    return result;\n  }\n\n  const seriesName = host.openSeries();\n  /** Call attempts ended BY the stage attempt's end — their records are the evidence of the cut. */\n  const cut = new Set<number>();\n  const ended = () => new Error(lateCallMessage(target, seriesName, 'cannot continue'));\n  const series = runAttempts<T>(\n    (_attempt, context) => {\n      // The attempt that made this call is over: no further attempt of an outside call starts.\n      if (!host.admits(false)) {\n        const reason = ended();\n        stop.abort(reason);\n        throw reason;\n      }\n      return fn(context);\n    },\n    policy,\n    {\n      series: seriesName,\n      kind: 'call',\n      target,\n      ...(host.effect !== undefined && { effect: host.effect }),\n      signal: composed.signal,\n      ...(host.deadline !== undefined && { deadline: host.deadline }),\n      now,\n      serve: (error) => host.serve(error),\n      // Synchronous at the abort: the stage attempt's signal aborting is what cut this call attempt.\n      onAbandon: (attempt) => {\n        if (hostSignal?.aborted) cut.add(attempt);\n      },\n      onAttempt: (record, structuredError) => {\n        if (host.admits(cut.has(record.attempt))) {\n          host.report(record, structuredError);\n          return;\n        }\n        host.refused();\n        // Nothing follows a refused record: a wait ends now and the series stops `aborted`.\n        if (!stop.signal.aborted) stop.abort(ended());\n      },\n      observe: (report, at) => host.observe(report, at),\n    },\n  );\n  result = series.finally(release);\n  return result;\n}\n\n/** Why a call stopped or could not go on — its target and series are names; no value is in the message. */\nfunction lateCallMessage(target: string, series: string | undefined, what: string): string {\n  return (\n    `[footprint] $call \"${target}\"${series === undefined ? '' : ` (${series})`} ${what}: the attempt that made this ` +\n    'call has ended — no further attempt of it starts, and nothing it records lands on the stage.'\n  );\n}\n"]}

package/dist/lib/attempt/category.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminalCategory = exports.errorCategory = void 0;
+const errors_js_1 = require("../schema/errors.js");
+const errors_js_2 = require("./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.
+ */
+function errorCategory(error, outcome = 'failed') {
+    if (outcome === 'timeout')
+        return 'timeout';
+    if (outcome === 'aborted')
+        return 'unknown';
+    try {
+        return categoryOf(error);
+    }
+    catch {
+        return 'unknown';
+    }
+}
+exports.errorCategory = errorCategory;
+/**
+ * @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.
+ */
+function terminalCategory(error, known) {
+    try {
+        if (error instanceof errors_js_2.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);
+}
+exports.terminalCategory = terminalCategory;
+function categoryOf(error) {
+    if (error instanceof errors_js_2.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 errors_js_1.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/lib/attempt/correlation.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCorrelation = exports.admitRunEnv = exports.formatTraceparent = exports.parseTraceparent = exports.TraceparentError = exports.MAX_HEADER_LENGTH = void 0;
+/** The longest header read at all (a future version may append fields; nothing legitimate is near this). */
+exports.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. */
+class TraceparentError extends Error {
+    reason;
+    constructor(reason) {
+        super(`traceparent refused (${reason}): ${WHY[reason]}`);
+        this.name = 'TraceparentError';
+        this.reason = reason;
+    }
+}
+exports.TraceparentError = TraceparentError;
+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' }
+ */
+function parseTraceparent(header) {
+    if (typeof header !== 'string')
+        throw new TraceparentError('not-a-string');
+    if (header.length < V00_LENGTH || header.length > exports.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 });
+}
+exports.parseTraceparent = parseTraceparent;
+/**
+ * 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'
+ */
+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)}`;
+}
+exports.formatTraceparent = formatTraceparent;
+/** 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.
+ */
+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 };
+}
+exports.admitRunEnv = admitRunEnv;
+/**
+ * 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.
+ */
+function resolveCorrelation(env) {
+    if (env === undefined || env === null)
+        return undefined;
+    return resolveParsed({ ...env });
+}
+exports.resolveCorrelation = resolveCorrelation;
+/** {@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"]}