footprintjs 10.3.0 → 10.5.0

package/dist/esm/lib/capture/historyData.js

@@ -0,0 +1,96 @@
+/** @internal Fixed diagnostic only; never carries source values, paths or adapter errors. */
+export class HistoryDataError extends Error {
+    code;
+    constructor(code) {
+        super(code === 'too-large' ? 'Capture history data too large' : 'Capture history data refused');
+        this.code = code;
+    }
+}
+/** Fixed boundary reasons; no untrusted error text leaves the engine. */
+export function historyFailureReason(error, boundary) {
+    if (error instanceof HistoryDataError) {
+        if (error.code === 'source-validation-limit')
+            return 'source-validation-limit';
+        if (error.code === 'too-large')
+            return `${boundary}-too-large`;
+    }
+    return `${boundary}-refused`;
+}
+/** @internal Copy bounded inert JSON data without invoking accessors, toJSON or application coercion. */
+export function copyHistoryData(value, maxBytes, onOmitted) {
+    let bytes = 0;
+    let nodes = 0;
+    const ancestors = new Set();
+    const encoder = new TextEncoder();
+    const charge = (text) => {
+        if (text.length > maxBytes - bytes)
+            throw new HistoryDataError('too-large');
+        bytes += encoder.encode(text).length;
+        if (bytes > maxBytes)
+            throw new HistoryDataError('too-large');
+    };
+    const copy = (item, depth, path) => {
+        if (++nodes > 100_000 || depth > 256)
+            throw new HistoryDataError('invalid-data');
+        if (item === null || typeof item === 'string' || typeof item === 'boolean' || typeof item === 'number') {
+            if (typeof item === 'number' && (!Number.isFinite(item) || Object.is(item, -0)))
+                throw new HistoryDataError('invalid-data');
+            charge(JSON.stringify(item));
+            return item;
+        }
+        if (!item || typeof item !== 'object' || ancestors.has(item))
+            throw new HistoryDataError('invalid-data');
+        const array = Array.isArray(item);
+        if (Object.getPrototypeOf(item) !== (array ? Array.prototype : Object.prototype))
+            throw new HistoryDataError('invalid-data');
+        ancestors.add(item);
+        charge(array ? '[]' : '{}');
+        const output = array ? [] : {};
+        const keys = Object.keys(item);
+        if (keys.length > 100_000 - nodes)
+            throw new HistoryDataError('invalid-data');
+        // Arrays must be dense JSON arrays without extra properties. No silent dropping of holes or expandos.
+        if (array && Object.getOwnPropertyDescriptor(item, 'length')?.value !== keys.length)
+            throw new HistoryDataError('invalid-data');
+        let written = 0;
+        for (const key of keys) {
+            const property = Object.getOwnPropertyDescriptor(item, key);
+            if (!property || !Object.hasOwn(property, 'value'))
+                throw new HistoryDataError('invalid-data');
+            if (array && key !== String(written))
+                throw new HistoryDataError('invalid-data');
+            // Ordinary JSON object omission. Arrays/root undefined remain refused; no snapshot-field allow-list.
+            if (property.value === undefined && !array) {
+                onOmitted?.([...path, key]);
+                continue;
+            }
+            if (written++)
+                charge(',');
+            if (!array)
+                charge(JSON.stringify(key) + ':');
+            Object.defineProperty(output, key, {
+                value: copy(property.value, depth + 1, [...path, key]),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+        ancestors.delete(item);
+        return Object.freeze(output);
+    };
+    return copy(value, 0, []);
+}
+/** @internal Integrity of this JSON representation, not a value fingerprint or an authenticity signature. */
+export async function historyDigest(value) {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(digest), (n) => n.toString(16).padStart(2, '0')).join('');
+}
+/** One field order for both sides of the evidence digest; optional source/absence fields cannot drift. */
+export function historyEvidence(value) {
+    const fields = ['capture', 'executionTree', 'recorders', 'readSources', 'absent'];
+    if (Object.keys(value).some((key) => key !== 'target' && !fields.includes(key)))
+        throw new HistoryDataError('invalid-data');
+    return Object.fromEntries(fields.filter((key) => Object.hasOwn(value, key)).map((key) => [key, value[key]]));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"historyData.js","sourceRoot":"","sources":["../../../../src/lib/capture/historyData.ts"],"names":[],"mappings":"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","sourcesContent":["/** @internal Fixed diagnostic only; never carries source values, paths or adapter errors. */\nexport class HistoryDataError extends Error {\n  constructor(readonly code: 'too-large' | 'invalid-data' | 'source-validation-limit') {\n    super(code === 'too-large' ? 'Capture history data too large' : 'Capture history data refused');\n  }\n}\n\n/** Fixed boundary reasons; no untrusted error text leaves the engine. */\nexport function historyFailureReason(error: unknown, boundary: 'evidence' | 'history'): string {\n  if (error instanceof HistoryDataError) {\n    if (error.code === 'source-validation-limit') return 'source-validation-limit';\n    if (error.code === 'too-large') return `${boundary}-too-large`;\n  }\n  return `${boundary}-refused`;\n}\n\n/** @internal Copy bounded inert JSON data without invoking accessors, toJSON or application coercion. */\nexport function copyHistoryData(\n  value: unknown,\n  maxBytes: number,\n  onOmitted?: (path: readonly string[]) => void,\n): unknown {\n  let bytes = 0;\n  let nodes = 0;\n  const ancestors = new Set<object>();\n  const encoder = new TextEncoder();\n  const charge = (text: string): void => {\n    if (text.length > maxBytes - bytes) throw new HistoryDataError('too-large');\n    bytes += encoder.encode(text).length;\n    if (bytes > maxBytes) throw new HistoryDataError('too-large');\n  };\n  const copy = (item: unknown, depth: number, path: string[]): unknown => {\n    if (++nodes > 100_000 || depth > 256) throw new HistoryDataError('invalid-data');\n    if (item === null || typeof item === 'string' || typeof item === 'boolean' || typeof item === 'number') {\n      if (typeof item === 'number' && (!Number.isFinite(item) || Object.is(item, -0)))\n        throw new HistoryDataError('invalid-data');\n      charge(JSON.stringify(item));\n      return item;\n    }\n    if (!item || typeof item !== 'object' || ancestors.has(item)) throw new HistoryDataError('invalid-data');\n    const array = Array.isArray(item);\n    if (Object.getPrototypeOf(item) !== (array ? Array.prototype : Object.prototype))\n      throw new HistoryDataError('invalid-data');\n    ancestors.add(item);\n    charge(array ? '[]' : '{}');\n    const output: Record<string, unknown> | unknown[] = array ? [] : {};\n    const keys = Object.keys(item);\n    if (keys.length > 100_000 - nodes) throw new HistoryDataError('invalid-data');\n    // Arrays must be dense JSON arrays without extra properties. No silent dropping of holes or expandos.\n    if (array && Object.getOwnPropertyDescriptor(item, 'length')?.value !== keys.length)\n      throw new HistoryDataError('invalid-data');\n    let written = 0;\n    for (const key of keys) {\n      const property = Object.getOwnPropertyDescriptor(item, key);\n      if (!property || !Object.hasOwn(property, 'value')) throw new HistoryDataError('invalid-data');\n      if (array && key !== String(written)) throw new HistoryDataError('invalid-data');\n      // Ordinary JSON object omission. Arrays/root undefined remain refused; no snapshot-field allow-list.\n      if (property.value === undefined && !array) {\n        onOmitted?.([...path, key]);\n        continue;\n      }\n      if (written++) charge(',');\n      if (!array) charge(JSON.stringify(key) + ':');\n      Object.defineProperty(output, key, {\n        value: copy(property.value, depth + 1, [...path, key]),\n        enumerable: true,\n        writable: true,\n        configurable: true,\n      });\n    }\n    ancestors.delete(item);\n    return Object.freeze(output);\n  };\n  return copy(value, 0, []);\n}\n\n/** @internal Integrity of this JSON representation, not a value fingerprint or an authenticity signature. */\nexport async function historyDigest(value: unknown): Promise<string> {\n  const bytes = new TextEncoder().encode(JSON.stringify(value));\n  const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);\n  return Array.from(new Uint8Array(digest), (n) => n.toString(16).padStart(2, '0')).join('');\n}\n\n/** One field order for both sides of the evidence digest; optional source/absence fields cannot drift. */\nexport function historyEvidence(value: Record<string, unknown>): Record<string, unknown> {\n  const fields = ['capture', 'executionTree', 'recorders', 'readSources', 'absent'];\n  if (Object.keys(value).some((key) => key !== 'target' && !fields.includes(key)))\n    throw new HistoryDataError('invalid-data');\n  return Object.fromEntries(fields.filter((key) => Object.hasOwn(value, key)).map((key) => [key, value[key]]));\n}\n"]}

package/dist/esm/lib/capture/historyNote.d.ts

@@ -0,0 +1,4 @@
+import type { CaptureHistoryTarget } from './historyTypes.js';
+import type { NativeCaptureObservation } from './readSources.js';
+/** @internal Called only after the bounded inert-data copier. Retains native observations, not storage authority. */
+export declare function historyNote(value: unknown, target: CaptureHistoryTarget): NativeCaptureObservation | undefined;

package/dist/esm/lib/capture/historyNote.js

@@ -0,0 +1,57 @@
+import { CAPTURE_BASE_LIMITATIONS, CAPTURE_CHANNEL_STATUSES, isCaptureValue } from './nativeCoverage.js';
+import { copyChannels, copyIdentity, copyLimitations, copyModes, copyObservedChannels, ownData } from './noteShape.js';
+/** @internal Called only after the bounded inert-data copier. Retains native observations, not storage authority. */
+export function historyNote(value, target) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const v = value;
+    const version = ownData(v, 'version') === 2 ? 2 : 1;
+    const identity = copyIdentity(v, true, version);
+    const limitations = copyLimitations(v.limitations);
+    if (!identity ||
+        JSON.stringify(identity) !== JSON.stringify(copyIdentity(target)) ||
+        v.scope !== 'root-log' ||
+        v.persistence !== 'memory-only' ||
+        !v.boundary ||
+        !['completed', 'failed', 'paused', 'cancelled'].includes(v.boundary.status) ||
+        !v.modes ||
+        !v.channels ||
+        !limitations ||
+        !CAPTURE_BASE_LIMITATIONS.filter((g) => version === 1 || g !== 'read-sources-not-collected').every((g) => limitations.includes(g)) ||
+        !copyModes(v.modes, true) ||
+        !(version === 1 ? copyChannels(v.channels, true) : copyObservedChannels(v.channels)) ||
+        (version === 2 &&
+            (!isCaptureValue(v.channels.readSources, CAPTURE_CHANNEL_STATUSES) ||
+                Object.keys(v.channels).length !== 5 ||
+                limitations.includes('read-sources-not-collected'))))
+        return undefined;
+    // Reject extra metadata rather than handing arbitrary stored fields out as native facts.
+    if (Object.keys(v).some((k) => ![
+        'version',
+        'runId',
+        'scope',
+        'logAddress',
+        'commits',
+        'boundary',
+        'modes',
+        'channels',
+        'persistence',
+        'limitations',
+    ].includes(k)))
+        return undefined;
+    const failure = v.boundary.failure;
+    if (Object.keys(v.boundary).some((k) => k !== 'status' && k !== 'failure'))
+        return undefined;
+    if (failure &&
+        (!['failed', 'cancelled'].includes(v.boundary.status) ||
+            !['timeout', 'rate-limited', 'server', 'network', 'auth', 'permanent', 'unknown'].includes(failure.category) ||
+            Object.keys(failure).some((k) => k !== 'category' && k !== 'stage') ||
+            (failure.stage &&
+                (Object.keys(failure.stage).some((k) => k !== 'runId' && k !== 'runtimeStageId') ||
+                    failure.stage.runId !== v.runId ||
+                    typeof failure.stage.runtimeStageId !== 'string' ||
+                    failure.stage.runtimeStageId.length > 1024))))
+        return undefined;
+    return v;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/capture/historyTarget.d.ts

@@ -0,0 +1,5 @@
+import type { CaptureHistoryReceipt, CaptureHistoryTarget } from './historyTypes.js';
+/** @internal Bounded own-data root identity. Does not execute stored accessors. */
+export declare function copyHistoryTarget(value: unknown): CaptureHistoryTarget | undefined;
+/** @internal Fixed fields only; an adapter cannot leak its additional receipt data into saved metadata. */
+export declare function copyHistoryReceipt(value: unknown, target: CaptureHistoryTarget): CaptureHistoryReceipt | undefined;

package/dist/esm/lib/capture/historyTarget.js

@@ -0,0 +1,35 @@
+import { captureIdentifier, copyIdentity, ownData } from './noteShape.js';
+/** @internal Bounded own-data root identity. Does not execute stored accessors. */
+export function copyHistoryTarget(value) {
+    try {
+        const identity = copyIdentity(value);
+        const evidenceId = ownData(value, 'evidenceId');
+        const digest = ownData(value, 'digest');
+        if (!identity || !captureIdentifier(evidenceId) || typeof digest !== 'string' || !/^[a-f0-9]{64}$/.test(digest))
+            return undefined;
+        return Object.freeze({
+            version: 1,
+            evidenceId,
+            runId: identity.runId,
+            digest,
+            logAddress: identity.logAddress,
+            commits: identity.commits,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+/** @internal Fixed fields only; an adapter cannot leak its additional receipt data into saved metadata. */
+export function copyHistoryReceipt(value, target) {
+    try {
+        const copied = copyHistoryTarget(value);
+        if (!copied || ownData(value, 'durability') !== 'durable' || JSON.stringify(copied) !== JSON.stringify(target))
+            return undefined;
+        return Object.freeze({ ...copied, durability: 'durable' });
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/capture/historyTypes.d.ts

@@ -0,0 +1,39 @@
+import type { LogAddress } from 'foottrace';
+/** Exact root segment and evidence entry acknowledged by a storage adapter. */
+export interface CaptureHistoryTarget {
+    readonly version: 1;
+    readonly evidenceId: string;
+    readonly runId: string;
+    /** SHA-256 of the exact inert JSON evidence (including opted-in source metadata) plus canonical commit log and served starting state. */
+    readonly digest: string;
+    readonly logAddress: LogAddress;
+    readonly commits: {
+        readonly from: number;
+        readonly to: number;
+    };
+}
+/** Adapter assertion about the preceding evidence and end entry, not about this receipt's delivery. */
+export interface CaptureHistoryReceipt extends CaptureHistoryTarget {
+    readonly durability: 'durable';
+}
+/** Explicit host-owned durability capability. A normal RecordSink.flush is not this promise. */
+export interface CaptureHistoryOptions {
+    /** Resolve only after this target's evidence, commits and end entry are durably stored together. */
+    readonly acknowledge: (target: CaptureHistoryTarget, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<CaptureHistoryReceipt>;
+    /** Maximum UTF-8 bytes of the evidence payload and target. Default 1 MiB, maximum 8 MiB. */
+    readonly maxBytes?: number;
+    /** Total time allowed for evidence delivery, acknowledgement and receipt delivery. Default 10s, maximum 30s. */
+    readonly timeoutMs?: number;
+}
+/** Persistence result only. An acknowledged failed/paused prefix is not a completed business workflow. */
+export type CaptureHistoryStatus = {
+    readonly status: 'acknowledged';
+} | {
+    readonly status: 'unknown';
+    readonly reason: string;
+};
+/** @internal Opaque note names; Foottrace keeps them without interpreting engine metadata. */
+export declare const CAPTURE_HISTORY_NOTE = "capture-history";
+export declare const CAPTURE_RECEIPT_NOTE = "capture-receipt";

package/dist/esm/lib/capture/historyTypes.js

@@ -0,0 +1,4 @@
+/** @internal Opaque note names; Foottrace keeps them without interpreting engine metadata. */
+export const CAPTURE_HISTORY_NOTE = 'capture-history';
+export const CAPTURE_RECEIPT_NOTE = 'capture-receipt';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGlzdG9yeVR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9jYXB0dXJlL2hpc3RvcnlUeXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFvQ0EsOEZBQThGO0FBQzlGLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLGlCQUFpQixDQUFDO0FBQ3RELE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBMb2dBZGRyZXNzIH0gZnJvbSAnZm9vdHRyYWNlJztcblxuLyoqIEV4YWN0IHJvb3Qgc2VnbWVudCBhbmQgZXZpZGVuY2UgZW50cnkgYWNrbm93bGVkZ2VkIGJ5IGEgc3RvcmFnZSBhZGFwdGVyLiAqL1xuZXhwb3J0IGludGVyZmFjZSBDYXB0dXJlSGlzdG9yeVRhcmdldCB7XG4gIHJlYWRvbmx5IHZlcnNpb246IDE7XG4gIHJlYWRvbmx5IGV2aWRlbmNlSWQ6IHN0cmluZztcbiAgcmVhZG9ubHkgcnVuSWQ6IHN0cmluZztcbiAgLyoqIFNIQS0yNTYgb2YgdGhlIGV4YWN0IGluZXJ0IEpTT04gZXZpZGVuY2UgKGluY2x1ZGluZyBvcHRlZC1pbiBzb3VyY2UgbWV0YWRhdGEpIHBsdXMgY2Fub25pY2FsIGNvbW1pdCBsb2cgYW5kIHNlcnZlZCBzdGFydGluZyBzdGF0ZS4gKi9cbiAgcmVhZG9ubHkgZGlnZXN0OiBzdHJpbmc7XG4gIHJlYWRvbmx5IGxvZ0FkZHJlc3M6IExvZ0FkZHJlc3M7XG4gIHJlYWRvbmx5IGNvbW1pdHM6IHsgcmVhZG9ubHkgZnJvbTogbnVtYmVyOyByZWFkb25seSB0bzogbnVtYmVyIH07XG59XG5cbi8qKiBBZGFwdGVyIGFzc2VydGlvbiBhYm91dCB0aGUgcHJlY2VkaW5nIGV2aWRlbmNlIGFuZCBlbmQgZW50cnksIG5vdCBhYm91dCB0aGlzIHJlY2VpcHQncyBkZWxpdmVyeS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ2FwdHVyZUhpc3RvcnlSZWNlaXB0IGV4dGVuZHMgQ2FwdHVyZUhpc3RvcnlUYXJnZXQge1xuICByZWFkb25seSBkdXJhYmlsaXR5OiAnZHVyYWJsZSc7XG59XG5cbi8qKiBFeHBsaWNpdCBob3N0LW93bmVkIGR1cmFiaWxpdHkgY2FwYWJpbGl0eS4gQSBub3JtYWwgUmVjb3JkU2luay5mbHVzaCBpcyBub3QgdGhpcyBwcm9taXNlLiAqL1xuZXhwb3J0IGludGVyZmFjZSBDYXB0dXJlSGlzdG9yeU9wdGlvbnMge1xuICAvKiogUmVzb2x2ZSBvbmx5IGFmdGVyIHRoaXMgdGFyZ2V0J3MgZXZpZGVuY2UsIGNvbW1pdHMgYW5kIGVuZCBlbnRyeSBhcmUgZHVyYWJseSBzdG9yZWQgdG9nZXRoZXIuICovXG4gIHJlYWRvbmx5IGFja25vd2xlZGdlOiAoXG4gICAgdGFyZ2V0OiBDYXB0dXJlSGlzdG9yeVRhcmdldCxcbiAgICBjb250ZXh0OiB7IHJlYWRvbmx5IHNpZ25hbDogQWJvcnRTaWduYWwgfSxcbiAgKSA9PiBQcm9taXNlPENhcHR1cmVIaXN0b3J5UmVjZWlwdD47XG4gIC8qKiBNYXhpbXVtIFVURi04IGJ5dGVzIG9mIHRoZSBldmlkZW5jZSBwYXlsb2FkIGFuZCB0YXJnZXQuIERlZmF1bHQgMSBNaUIsIG1heGltdW0gOCBNaUIuICovXG4gIHJlYWRvbmx5IG1heEJ5dGVzPzogbnVtYmVyO1xuICAvKiogVG90YWwgdGltZSBhbGxvd2VkIGZvciBldmlkZW5jZSBkZWxpdmVyeSwgYWNrbm93bGVkZ2VtZW50IGFuZCByZWNlaXB0IGRlbGl2ZXJ5LiBEZWZhdWx0IDEwcywgbWF4aW11bSAzMHMuICovXG4gIHJlYWRvbmx5IHRpbWVvdXRNcz86IG51bWJlcjtcbn1cblxuLyoqIFBlcnNpc3RlbmNlIHJlc3VsdCBvbmx5LiBBbiBhY2tub3dsZWRnZWQgZmFpbGVkL3BhdXNlZCBwcmVmaXggaXMgbm90IGEgY29tcGxldGVkIGJ1c2luZXNzIHdvcmtmbG93LiAqL1xuZXhwb3J0IHR5cGUgQ2FwdHVyZUhpc3RvcnlTdGF0dXMgPVxuICB8IHsgcmVhZG9ubHkgc3RhdHVzOiAnYWNrbm93bGVkZ2VkJyB9XG4gIHwgeyByZWFkb25seSBzdGF0dXM6ICd1bmtub3duJzsgcmVhZG9ubHkgcmVhc29uOiBzdHJpbmcgfTtcblxuLyoqIEBpbnRlcm5hbCBPcGFxdWUgbm90ZSBuYW1lczsgRm9vdHRyYWNlIGtlZXBzIHRoZW0gd2l0aG91dCBpbnRlcnByZXRpbmcgZW5naW5lIG1ldGFkYXRhLiAqL1xuZXhwb3J0IGNvbnN0IENBUFRVUkVfSElTVE9SWV9OT1RFID0gJ2NhcHR1cmUtaGlzdG9yeSc7XG5leHBvcnQgY29uc3QgQ0FQVFVSRV9SRUNFSVBUX05PVEUgPSAnY2FwdHVyZS1yZWNlaXB0JztcbiJdfQ==

package/dist/esm/lib/capture/nativeCoverage.d.ts

@@ -1,12 +1,24 @@
 import type { LogAddress } from 'foottrace';
 import type { TerminalFailureContext } from '../errors/terminalFailure.js';
-export type CaptureChannelStatus = 'captured' | 'disabled' | 'partial' | 'failed' | 'unknown';
-export type CaptureLimitation = 'tracked-state-only' | 'final-attempt-views' | 'read-sources-not-collected' | 'child-scopes-not-attested' | 'storage-not-attested' | 'resumed-segment' | 'redacted-export' | 'redaction-active' | 'custom-scope' | 'read-retention-failed' | 'commit-retention-failed' | 'attention-omitted' | 'recorder-snapshot-failed' | 'identity-omitted' | 'execution-broken' | 'modes-unavailable';
+/** @internal Shared observation vocabularies; producer, types and checkpoint reader use the same values. */
+export declare const CAPTURE_RETENTION_MODES: readonly ["full", "summary", "off", "unknown"];
+export declare const CAPTURE_COMMIT_VALUE_MODES: readonly ["full", "delta", "unknown"];
+export declare const CAPTURE_PROVENANCE_MODES: readonly ["off", "reads-prefix", "unknown"];
+export declare const CAPTURE_CHANNEL_STATUSES: readonly ["captured", "disabled", "partial", "failed", "unknown"];
+declare const RECORDER_CONTROL_STATUSES: readonly ["captured", "partial", "unknown"];
+export type CaptureChannelStatus = (typeof CAPTURE_CHANNEL_STATUSES)[number];
+/** @internal Exact membership without coercing stored values. */
+export declare function isCaptureValue<T extends string>(value: unknown, vocabulary: readonly T[]): value is T;
+/** @internal Limitations inherent in every version-1 observation. */
+export declare const CAPTURE_BASE_LIMITATIONS: readonly ["tracked-state-only", "final-attempt-views", "read-sources-not-collected", "child-scopes-not-attested", "storage-not-attested"];
+/** @internal One vocabulary for native observation and its stored checkpoint codec. */
+export declare const CAPTURE_LIMITATIONS: readonly ["tracked-state-only", "final-attempt-views", "read-sources-not-collected", "child-scopes-not-attested", "storage-not-attested", "resumed-segment", "redacted-export", "redaction-active", "custom-scope", "read-retention-failed", "commit-retention-failed", "attention-omitted", "recorder-snapshot-failed", "identity-omitted", "execution-broken", "modes-unavailable", "checkpoint-history-not-included", "source-history-not-included"];
+export type CaptureLimitation = (typeof CAPTURE_LIMITATIONS)[number];
 /** A producer acknowledgement, not engine inspection of a recorder's implementation. */
 export interface RecorderCaptureAcknowledgement {
     readonly version: 1;
     readonly runId: string;
-    readonly control: 'captured' | 'partial' | 'unknown';
+    readonly control: (typeof RECORDER_CONTROL_STATUSES)[number];
 }
 /** Engine observation of ONE root-log segment. Never a durable or whole-workflow completeness claim. */
 export interface NativeCaptureNote {
@@ -24,10 +36,10 @@ export interface NativeCaptureNote {
         readonly failure?: TerminalFailureContext;
     };
     readonly modes: {
-        readonly readTracking: 'full' | 'summary' | 'off' | 'unknown';
-        readonly writeTracking: 'full' | 'summary' | 'off' | 'unknown';
-        readonly commitValues: 'full' | 'delta' | 'unknown';
-        readonly writeProvenance: 'off' | 'reads-prefix' | 'unknown';
+        readonly readTracking: (typeof CAPTURE_RETENTION_MODES)[number];
+        readonly writeTracking: (typeof CAPTURE_RETENTION_MODES)[number];
+        readonly commitValues: (typeof CAPTURE_COMMIT_VALUE_MODES)[number];
+        readonly writeProvenance: (typeof CAPTURE_PROVENANCE_MODES)[number];
     };
     readonly channels: {
         readonly reads: CaptureChannelStatus;
@@ -54,3 +66,4 @@ export declare class NativeCapture {
 }
 /** Stored/recorder metadata is untrusted. Read data properties only, never getters or arbitrary strings. */
 export declare function copyCaptureAcknowledgement(value: unknown): RecorderCaptureAcknowledgement | undefined;
+export {};

package/dist/esm/lib/capture/nativeCoverage.js

@@ -1,27 +1,65 @@
+/** @internal Shared observation vocabularies; producer, types and checkpoint reader use the same values. */
+export const CAPTURE_RETENTION_MODES = Object.freeze(['full', 'summary', 'off', 'unknown']);
+export const CAPTURE_COMMIT_VALUE_MODES = Object.freeze(['full', 'delta', 'unknown']);
+export const CAPTURE_PROVENANCE_MODES = Object.freeze(['off', 'reads-prefix', 'unknown']);
+export const CAPTURE_CHANNEL_STATUSES = Object.freeze([
+    'captured',
+    'disabled',
+    'partial',
+    'failed',
+    'unknown',
+]);
+// Recorder acknowledgements are narrower than the native per-channel observation vocabulary.
+const RECORDER_CONTROL_STATUSES = Object.freeze(['captured', 'partial', 'unknown']);
+/** @internal Exact membership without coercing stored values. */
+export function isCaptureValue(value, vocabulary) {
+    return typeof value === 'string' && vocabulary.includes(value);
+}
+/** @internal Limitations inherent in every version-1 observation. */
+export const CAPTURE_BASE_LIMITATIONS = Object.freeze([
+    'tracked-state-only',
+    'final-attempt-views',
+    'read-sources-not-collected',
+    'child-scopes-not-attested',
+    'storage-not-attested',
+]);
+/** @internal One vocabulary for native observation and its stored checkpoint codec. */
+export const CAPTURE_LIMITATIONS = Object.freeze([
+    ...CAPTURE_BASE_LIMITATIONS,
+    'resumed-segment',
+    'redacted-export',
+    'redaction-active',
+    'custom-scope',
+    'read-retention-failed',
+    'commit-retention-failed',
+    'attention-omitted',
+    'recorder-snapshot-failed',
+    'identity-omitted',
+    'execution-broken',
+    'modes-unavailable',
+    'checkpoint-history-not-included',
+    'source-history-not-included',
+]);
 /** @internal Bounded facts collected at native funnels; no values, key names, recorder discovery or tree walk. */
 export class NativeCapture {
     runId;
     logAddress;
     from;
-    gaps = new Set([
-        'tracked-state-only',
-        'final-attempt-views',
-        'read-sources-not-collected',
-        'child-scopes-not-attested',
-        'storage-not-attested',
-    ]);
+    gaps = new Set(CAPTURE_BASE_LIMITATIONS);
     boundary = { status: 'running' };
     modes;
     constructor(runId, logAddress, from, modes) {
         this.runId = runId;
         this.logAddress = logAddress;
         this.from = from;
-        const retention = (value) => value === 'full' || value === 'summary' || value === 'off' ? value : 'unknown';
+        const retention = (value) => (isCaptureValue(value, CAPTURE_RETENTION_MODES) ? value : 'unknown');
         this.modes = {
             readTracking: retention(modes.readTracking),
             writeTracking: retention(modes.writeTracking),
-            commitValues: modes.commitValues === 'full' || modes.commitValues === 'delta' ? modes.commitValues : 'unknown',
-            writeProvenance: modes.writeProvenance === 'off' || modes.writeProvenance === 'reads-prefix' ? modes.writeProvenance : 'unknown',
+            commitValues: isCaptureValue(modes.commitValues, CAPTURE_COMMIT_VALUE_MODES) ? modes.commitValues : 'unknown',
+            writeProvenance: isCaptureValue(modes.writeProvenance, CAPTURE_PROVENANCE_MODES)
+                ? modes.writeProvenance
+                : 'unknown',
         };
         if (Object.values(this.modes).includes('unknown'))
             this.limit('modes-unavailable');
@@ -91,7 +129,7 @@ export function copyCaptureAcknowledgement(value) {
             typeof runId !== 'string' ||
             runId.length === 0 ||
             runId.length > 2048 ||
-            !['captured', 'partial', 'unknown'].includes(control))
+            !isCaptureValue(control, RECORDER_CONTROL_STATUSES))
             return undefined;
         return Object.freeze({ version, runId, control });
     }
@@ -99,4 +137,4 @@ export function copyCaptureAcknowledgement(value) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nativeCoverage.js","sourceRoot":"","sources":["../../../../src/lib/capture/nativeCoverage.ts"],"names":[],"mappings":"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","sourcesContent":["import type { LogAddress } from 'foottrace';\n\nimport type { TerminalFailureContext } from '../errors/terminalFailure.js';\n\nexport type CaptureChannelStatus = 'captured' | 'disabled' | 'partial' | 'failed' | 'unknown';\nexport type CaptureLimitation =\n  | 'tracked-state-only'\n  | 'final-attempt-views'\n  | 'read-sources-not-collected'\n  | 'child-scopes-not-attested'\n  | 'storage-not-attested'\n  | 'resumed-segment'\n  | 'redacted-export'\n  | 'redaction-active'\n  | 'custom-scope'\n  | 'read-retention-failed'\n  | 'commit-retention-failed'\n  | 'attention-omitted'\n  | 'recorder-snapshot-failed'\n  | 'identity-omitted'\n  | 'execution-broken'\n  | 'modes-unavailable';\n\n/** A producer acknowledgement, not engine inspection of a recorder's implementation. */\nexport interface RecorderCaptureAcknowledgement {\n  readonly version: 1;\n  readonly runId: string;\n  readonly control: 'captured' | 'partial' | 'unknown';\n}\n\n/** Engine observation of ONE root-log segment. Never a durable or whole-workflow completeness claim. */\nexport interface NativeCaptureNote {\n  readonly version: 1;\n  readonly runId: string;\n  readonly scope: 'root-log';\n  readonly logAddress: LogAddress;\n  /** Half-open offsets in this log. A same-executor resume starts at the previous end. */\n  readonly commits: { readonly from: number; readonly to: number };\n  readonly boundary: {\n    readonly status: 'running' | 'completed' | 'paused' | 'failed' | 'cancelled';\n    readonly failure?: TerminalFailureContext;\n  };\n  readonly modes: {\n    readonly readTracking: 'full' | 'summary' | 'off' | 'unknown';\n    readonly writeTracking: 'full' | 'summary' | 'off' | 'unknown';\n    readonly commitValues: 'full' | 'delta' | 'unknown';\n    readonly writeProvenance: 'off' | 'reads-prefix' | 'unknown';\n  };\n  readonly channels: {\n    readonly reads: CaptureChannelStatus;\n    readonly writes: CaptureChannelStatus;\n    readonly attention: CaptureChannelStatus;\n    readonly control: CaptureChannelStatus;\n    readonly readSources: 'not-collected';\n  };\n  readonly persistence: 'memory-only';\n  readonly limitations: readonly CaptureLimitation[];\n}\n\n/** @internal Bounded facts collected at native funnels; no values, key names, recorder discovery or tree walk. */\nexport class NativeCapture {\n  private readonly gaps = new Set<CaptureLimitation>([\n    'tracked-state-only',\n    'final-attempt-views',\n    'read-sources-not-collected',\n    'child-scopes-not-attested',\n    'storage-not-attested',\n  ]);\n\n  private boundary: NativeCaptureNote['boundary'] = { status: 'running' };\n  private readonly modes: NativeCaptureNote['modes'];\n\n  constructor(\n    readonly runId: string,\n    readonly logAddress: LogAddress,\n    readonly from: number,\n    modes: NativeCaptureNote['modes'],\n  ) {\n    const retention = (value: unknown) =>\n      value === 'full' || value === 'summary' || value === 'off' ? value : 'unknown';\n    this.modes = {\n      readTracking: retention(modes.readTracking),\n      writeTracking: retention(modes.writeTracking),\n      commitValues: modes.commitValues === 'full' || modes.commitValues === 'delta' ? modes.commitValues : 'unknown',\n      writeProvenance:\n        modes.writeProvenance === 'off' || modes.writeProvenance === 'reads-prefix' ? modes.writeProvenance : 'unknown',\n    };\n    if (Object.values(this.modes).includes('unknown')) this.limit('modes-unavailable');\n  }\n\n  limit(gap: CaptureLimitation): void {\n    this.gaps.add(gap);\n  }\n\n  end(status: NativeCaptureNote['boundary']['status'], failure?: TerminalFailureContext): void {\n    if (this.boundary.status !== 'running') return;\n    if (failure?.stage && failure.stage.runtimeStageId.length > 1024) {\n      this.limit('identity-omitted');\n      failure = Object.freeze({ category: failure.category });\n    }\n    this.boundary = { status, ...(failure && { failure }) };\n  }\n\n  snapshot(to: number, control: CaptureChannelStatus = 'unknown', redacted = false): NativeCaptureNote {\n    const gaps = new Set(this.gaps);\n    if (redacted) gaps.add('redacted-export');\n    const failed = gaps.has('commit-retention-failed');\n    const custom = gaps.has('custom-scope') || gaps.has('modes-unavailable');\n    return Object.freeze({\n      version: 1,\n      runId: this.runId,\n      scope: 'root-log',\n      logAddress: Object.freeze({\n        logRunId: this.logAddress.logRunId,\n        drillPath: Object.freeze([...this.logAddress.drillPath]),\n      }),\n      commits: Object.freeze({ from: this.from, to }),\n      boundary: Object.freeze({ ...this.boundary }),\n      modes: Object.freeze({\n        readTracking: this.modes.readTracking,\n        writeTracking: this.modes.writeTracking,\n        commitValues: this.modes.commitValues,\n        writeProvenance: this.modes.writeProvenance,\n      }),\n      channels: Object.freeze({\n        reads:\n          this.modes.readTracking === 'off'\n            ? 'disabled'\n            : gaps.has('read-retention-failed')\n            ? 'failed'\n            : custom\n            ? 'unknown'\n            : 'captured',\n        writes: this.modes.writeTracking === 'off' ? 'disabled' : failed ? 'failed' : custom ? 'unknown' : 'captured',\n        attention: failed || gaps.has('attention-omitted') ? 'partial' : custom ? 'unknown' : 'captured',\n        control: gaps.has('recorder-snapshot-failed') ? 'failed' : control,\n        readSources: 'not-collected',\n      }),\n      persistence: 'memory-only',\n      limitations: Object.freeze([...gaps]),\n    });\n  }\n}\n\n/** Stored/recorder metadata is untrusted. Read data properties only, never getters or arbitrary strings. */\nexport function copyCaptureAcknowledgement(value: unknown): RecorderCaptureAcknowledgement | undefined {\n  try {\n    if (!value || typeof value !== 'object' || Object.getPrototypeOf(value) !== Object.prototype) return undefined;\n    const data = (key: string) => Object.getOwnPropertyDescriptor(value, key)?.value;\n    const version = data('version');\n    const runId = data('runId');\n    const control = data('control');\n    if (\n      version !== 1 ||\n      typeof runId !== 'string' ||\n      runId.length === 0 ||\n      runId.length > 2048 ||\n      !['captured', 'partial', 'unknown'].includes(control)\n    )\n      return undefined;\n    return Object.freeze({ version, runId, control });\n  } catch {\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nativeCoverage.js","sourceRoot":"","sources":["../../../../src/lib/capture/nativeCoverage.ts"],"names":[],"mappings":"AAIA,4GAA4G;AAC5G,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAU,CAAC,CAAC;AACrG,MAAM,CAAC,MAAM,0BAA0B,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAU,CAAC,CAAC;AAC/F,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAU,CAAC,CAAC;AACnG,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,CAAC;IACpD,UAAU;IACV,UAAU;IACV,SAAS;IACT,QAAQ;IACR,SAAS;CACD,CAAC,CAAC;AACZ,6FAA6F;AAC7F,MAAM,yBAAyB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,CAAU,CAAC,CAAC;AAG7F,iEAAiE;AACjE,MAAM,UAAU,cAAc,CAAmB,KAAc,EAAE,UAAwB;IACvF,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,UAAgC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACxF,CAAC;AACD,qEAAqE;AACrE,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,CAAC;IACpD,oBAAoB;IACpB,qBAAqB;IACrB,4BAA4B;IAC5B,2BAA2B;IAC3B,sBAAsB;CACd,CAAC,CAAC;AAEZ,uFAAuF;AACvF,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC;IAC/C,GAAG,wBAAwB;IAC3B,iBAAiB;IACjB,iBAAiB;IACjB,kBAAkB;IAClB,cAAc;IACd,uBAAuB;IACvB,yBAAyB;IACzB,mBAAmB;IACnB,0BAA0B;IAC1B,kBAAkB;IAClB,kBAAkB;IAClB,mBAAmB;IACnB,iCAAiC;IACjC,6BAA6B;CACrB,CAAC,CAAC;AAuCZ,kHAAkH;AAClH,MAAM,OAAO,aAAa;IAOb;IACA;IACA;IARM,IAAI,GAAG,IAAI,GAAG,CAAoB,wBAAwB,CAAC,CAAC;IAErE,QAAQ,GAAkC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IACvD,KAAK,CAA6B;IAEnD,YACW,KAAa,EACb,UAAsB,EACtB,IAAY,EACrB,KAAiC;QAHxB,UAAK,GAAL,KAAK,CAAQ;QACb,eAAU,GAAV,UAAU,CAAY;QACtB,SAAI,GAAJ,IAAI,CAAQ;QAGrB,MAAM,SAAS,GAAG,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,cAAc,CAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAC3G,IAAI,CAAC,KAAK,GAAG;YACX,YAAY,EAAE,SAAS,CAAC,KAAK,CAAC,YAAY,CAAC;YAC3C,aAAa,EAAE,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC;YAC7C,YAAY,EAAE,cAAc,CAAC,KAAK,CAAC,YAAY,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;YAC7G,eAAe,EAAE,cAAc,CAAC,KAAK,CAAC,eAAe,EAAE,wBAAwB,CAAC;gBAC9E,CAAC,CAAC,KAAK,CAAC,eAAe;gBACvB,CAAC,CAAC,SAAS;SACd,CAAC;QACF,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC;YAAE,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACrF,CAAC;IAED,KAAK,CAAC,GAAsB;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IAED,GAAG,CAAC,MAA+C,EAAE,OAAgC;QACnF,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO;QAC/C,IAAI,OAAO,EAAE,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;YACjE,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;YAC/B,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC1D,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAC1D,CAAC;IAED,QAAQ,CAAC,EAAU,EAAE,UAAgC,SAAS,EAAE,QAAQ,GAAG,KAAK;QAC9E,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,QAAQ;YAAE,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;QACnD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QACzE,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,OAAO,EAAE,CAAC;YACV,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,UAAU;YACjB,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC;gBACxB,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ;gBAClC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;aACzD,CAAC;YACF,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC;YAC/C,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC;gBACnB,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY;gBACrC,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa;gBACvC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY;gBACrC,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe;aAC5C,CAAC;YACF,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC;gBACtB,KAAK,EACH,IAAI,CAAC,KAAK,CAAC,YAAY,KAAK,KAAK;oBAC/B,CAAC,CAAC,UAAU;oBACZ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,uBAAuB,CAAC;wBACnC,CAAC,CAAC,QAAQ;wBACV,CAAC,CAAC,MAAM;4BACR,CAAC,CAAC,SAAS;4BACX,CAAC,CAAC,UAAU;gBAChB,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;gBAC7G,SAAS,EAAE,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;gBAChG,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO;gBAClE,WAAW,EAAE,eAAe;aAC7B,CAAC;YACF,WAAW,EAAE,aAAa;YAC1B,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;SACtC,CAAC,CAAC;IACL,CAAC;CACF;AAED,4GAA4G;AAC5G,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,IAAI,CAAC;QACH,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS;YAAE,OAAO,SAAS,CAAC;QAC/G,MAAM,IAAI,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC;QACjF,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,IACE,OAAO,KAAK,CAAC;YACb,OAAO,KAAK,KAAK,QAAQ;YACzB,KAAK,CAAC,MAAM,KAAK,CAAC;YAClB,KAAK,CAAC,MAAM,GAAG,IAAI;YACnB,CAAC,cAAc,CAAC,OAAO,EAAE,yBAAyB,CAAC;YAEnD,OAAO,SAAS,CAAC;QACnB,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC","sourcesContent":["import type { LogAddress } from 'foottrace';\n\nimport type { TerminalFailureContext } from '../errors/terminalFailure.js';\n\n/** @internal Shared observation vocabularies; producer, types and checkpoint reader use the same values. */\nexport const CAPTURE_RETENTION_MODES = Object.freeze(['full', 'summary', 'off', 'unknown'] as const);\nexport const CAPTURE_COMMIT_VALUE_MODES = Object.freeze(['full', 'delta', 'unknown'] as const);\nexport const CAPTURE_PROVENANCE_MODES = Object.freeze(['off', 'reads-prefix', 'unknown'] as const);\nexport const CAPTURE_CHANNEL_STATUSES = Object.freeze([\n  'captured',\n  'disabled',\n  'partial',\n  'failed',\n  'unknown',\n] as const);\n// Recorder acknowledgements are narrower than the native per-channel observation vocabulary.\nconst RECORDER_CONTROL_STATUSES = Object.freeze(['captured', 'partial', 'unknown'] as const);\nexport type CaptureChannelStatus = (typeof CAPTURE_CHANNEL_STATUSES)[number];\n\n/** @internal Exact membership without coercing stored values. */\nexport function isCaptureValue<T extends string>(value: unknown, vocabulary: readonly T[]): value is T {\n  return typeof value === 'string' && (vocabulary as readonly string[]).includes(value);\n}\n/** @internal Limitations inherent in every version-1 observation. */\nexport const CAPTURE_BASE_LIMITATIONS = Object.freeze([\n  'tracked-state-only',\n  'final-attempt-views',\n  'read-sources-not-collected',\n  'child-scopes-not-attested',\n  'storage-not-attested',\n] as const);\n\n/** @internal One vocabulary for native observation and its stored checkpoint codec. */\nexport const CAPTURE_LIMITATIONS = Object.freeze([\n  ...CAPTURE_BASE_LIMITATIONS,\n  'resumed-segment',\n  'redacted-export',\n  'redaction-active',\n  'custom-scope',\n  'read-retention-failed',\n  'commit-retention-failed',\n  'attention-omitted',\n  'recorder-snapshot-failed',\n  'identity-omitted',\n  'execution-broken',\n  'modes-unavailable',\n  'checkpoint-history-not-included',\n  'source-history-not-included',\n] as const);\nexport type CaptureLimitation = (typeof CAPTURE_LIMITATIONS)[number];\n\n/** A producer acknowledgement, not engine inspection of a recorder's implementation. */\nexport interface RecorderCaptureAcknowledgement {\n  readonly version: 1;\n  readonly runId: string;\n  readonly control: (typeof RECORDER_CONTROL_STATUSES)[number];\n}\n\n/** Engine observation of ONE root-log segment. Never a durable or whole-workflow completeness claim. */\nexport interface NativeCaptureNote {\n  readonly version: 1;\n  readonly runId: string;\n  readonly scope: 'root-log';\n  readonly logAddress: LogAddress;\n  /** Half-open offsets in this log. A same-executor resume starts at the previous end. */\n  readonly commits: { readonly from: number; readonly to: number };\n  readonly boundary: {\n    readonly status: 'running' | 'completed' | 'paused' | 'failed' | 'cancelled';\n    readonly failure?: TerminalFailureContext;\n  };\n  readonly modes: {\n    readonly readTracking: (typeof CAPTURE_RETENTION_MODES)[number];\n    readonly writeTracking: (typeof CAPTURE_RETENTION_MODES)[number];\n    readonly commitValues: (typeof CAPTURE_COMMIT_VALUE_MODES)[number];\n    readonly writeProvenance: (typeof CAPTURE_PROVENANCE_MODES)[number];\n  };\n  readonly channels: {\n    readonly reads: CaptureChannelStatus;\n    readonly writes: CaptureChannelStatus;\n    readonly attention: CaptureChannelStatus;\n    readonly control: CaptureChannelStatus;\n    readonly readSources: 'not-collected';\n  };\n  readonly persistence: 'memory-only';\n  readonly limitations: readonly CaptureLimitation[];\n}\n\n/** @internal Bounded facts collected at native funnels; no values, key names, recorder discovery or tree walk. */\nexport class NativeCapture {\n  private readonly gaps = new Set<CaptureLimitation>(CAPTURE_BASE_LIMITATIONS);\n\n  private boundary: NativeCaptureNote['boundary'] = { status: 'running' };\n  private readonly modes: NativeCaptureNote['modes'];\n\n  constructor(\n    readonly runId: string,\n    readonly logAddress: LogAddress,\n    readonly from: number,\n    modes: NativeCaptureNote['modes'],\n  ) {\n    const retention = (value: unknown) => (isCaptureValue(value, CAPTURE_RETENTION_MODES) ? value : 'unknown');\n    this.modes = {\n      readTracking: retention(modes.readTracking),\n      writeTracking: retention(modes.writeTracking),\n      commitValues: isCaptureValue(modes.commitValues, CAPTURE_COMMIT_VALUE_MODES) ? modes.commitValues : 'unknown',\n      writeProvenance: isCaptureValue(modes.writeProvenance, CAPTURE_PROVENANCE_MODES)\n        ? modes.writeProvenance\n        : 'unknown',\n    };\n    if (Object.values(this.modes).includes('unknown')) this.limit('modes-unavailable');\n  }\n\n  limit(gap: CaptureLimitation): void {\n    this.gaps.add(gap);\n  }\n\n  end(status: NativeCaptureNote['boundary']['status'], failure?: TerminalFailureContext): void {\n    if (this.boundary.status !== 'running') return;\n    if (failure?.stage && failure.stage.runtimeStageId.length > 1024) {\n      this.limit('identity-omitted');\n      failure = Object.freeze({ category: failure.category });\n    }\n    this.boundary = { status, ...(failure && { failure }) };\n  }\n\n  snapshot(to: number, control: CaptureChannelStatus = 'unknown', redacted = false): NativeCaptureNote {\n    const gaps = new Set(this.gaps);\n    if (redacted) gaps.add('redacted-export');\n    const failed = gaps.has('commit-retention-failed');\n    const custom = gaps.has('custom-scope') || gaps.has('modes-unavailable');\n    return Object.freeze({\n      version: 1,\n      runId: this.runId,\n      scope: 'root-log',\n      logAddress: Object.freeze({\n        logRunId: this.logAddress.logRunId,\n        drillPath: Object.freeze([...this.logAddress.drillPath]),\n      }),\n      commits: Object.freeze({ from: this.from, to }),\n      boundary: Object.freeze({ ...this.boundary }),\n      modes: Object.freeze({\n        readTracking: this.modes.readTracking,\n        writeTracking: this.modes.writeTracking,\n        commitValues: this.modes.commitValues,\n        writeProvenance: this.modes.writeProvenance,\n      }),\n      channels: Object.freeze({\n        reads:\n          this.modes.readTracking === 'off'\n            ? 'disabled'\n            : gaps.has('read-retention-failed')\n            ? 'failed'\n            : custom\n            ? 'unknown'\n            : 'captured',\n        writes: this.modes.writeTracking === 'off' ? 'disabled' : failed ? 'failed' : custom ? 'unknown' : 'captured',\n        attention: failed || gaps.has('attention-omitted') ? 'partial' : custom ? 'unknown' : 'captured',\n        control: gaps.has('recorder-snapshot-failed') ? 'failed' : control,\n        readSources: 'not-collected',\n      }),\n      persistence: 'memory-only',\n      limitations: Object.freeze([...gaps]),\n    });\n  }\n}\n\n/** Stored/recorder metadata is untrusted. Read data properties only, never getters or arbitrary strings. */\nexport function copyCaptureAcknowledgement(value: unknown): RecorderCaptureAcknowledgement | undefined {\n  try {\n    if (!value || typeof value !== 'object' || Object.getPrototypeOf(value) !== Object.prototype) return undefined;\n    const data = (key: string) => Object.getOwnPropertyDescriptor(value, key)?.value;\n    const version = data('version');\n    const runId = data('runId');\n    const control = data('control');\n    if (\n      version !== 1 ||\n      typeof runId !== 'string' ||\n      runId.length === 0 ||\n      runId.length > 2048 ||\n      !isCaptureValue(control, RECORDER_CONTROL_STATUSES)\n    )\n      return undefined;\n    return Object.freeze({ version, runId, control });\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/dist/esm/lib/capture/nativeSourceAddress.d.ts

@@ -0,0 +1,3 @@
+import type { LogAddress } from 'foottrace';
+/** Native structural admission only: no user heap, options, sink or source selection participates. */
+export declare function supportsNativeSourceAddress(address: LogAddress): boolean;

package/dist/esm/lib/capture/nativeSourceAddress.js

@@ -0,0 +1,15 @@
+import { createReadSourceRecord, decodeReadSourceSnapshot, SharedMemory } from 'foottrace/write';
+let emptyNativeBook;
+/** Native structural admission only: no user heap, options, sink or source selection participates. */
+export function supportsNativeSourceAddress(address) {
+    if (!emptyNativeBook) {
+        // Let the published writer supply its own wire version, limits and empty envelope.
+        // Lazy: default-off executions never allocate this inert validation fixture.
+        const book = createReadSourceRecord(new SharedMemory(), { logRunId: 'source-address-admission', drillPath: [] });
+        emptyNativeBook = book.snapshot();
+        book.retire();
+    }
+    // The native codec owns all address bounds. This candidate is never served as observed evidence.
+    return decodeReadSourceSnapshot({ ...emptyNativeBook, address }) !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/capture/noteShape.d.ts

@@ -0,0 +1,10 @@
+import type { CaptureLimitation, NativeCaptureNote } from './nativeCoverage.js';
+/** @internal One inert-data boundary for checkpoint and history capture codecs. */
+export declare function ownData(record: unknown, key: string): unknown;
+export declare function captureIdentifier(value: unknown): value is string;
+export declare function copyIdentity(value: unknown, exact?: boolean, version?: 1 | 2): Pick<NativeCaptureNote, 'runId' | 'logAddress' | 'commits'> | undefined;
+export declare function copyModes(value: unknown, exact?: boolean): NativeCaptureNote['modes'] | undefined;
+export declare function copyChannels(value: unknown, exact?: boolean): NativeCaptureNote['channels'] | undefined;
+/** Shared native statuses; source version admission remains explicit at each codec boundary. */
+export declare function copyObservedChannels(value: unknown): Omit<NativeCaptureNote['channels'], 'readSources'> | undefined;
+export declare function copyLimitations(value: unknown): readonly CaptureLimitation[] | undefined;