footprintjs 10.2.1 → 10.4.0

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGlzdG9yeVRhcmdldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvY2FwdHVyZS9oaXN0b3J5VGFyZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFMUUsbUZBQW1GO0FBQ25GLE1BQU0sVUFBVSxpQkFBaUIsQ0FBQyxLQUFjO0lBQzlDLElBQUksQ0FBQztRQUNILE1BQU0sUUFBUSxHQUFHLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNyQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsS0FBSyxFQUFFLFlBQVksQ0FBQyxDQUFDO1FBQ2hELE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDeEMsSUFBSSxDQUFDLFFBQVEsSUFBSSxDQUFDLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxJQUFJLE9BQU8sTUFBTSxLQUFLLFFBQVEsSUFBSSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7WUFDN0csT0FBTyxTQUFTLENBQUM7UUFDbkIsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDO1lBQ25CLE9BQU8sRUFBRSxDQUFDO1lBQ1YsVUFBVTtZQUNWLEtBQUssRUFBRSxRQUFRLENBQUMsS0FBSztZQUNyQixNQUFNO1lBQ04sVUFBVSxFQUFFLFFBQVEsQ0FBQyxVQUFVO1lBQy9CLE9BQU8sRUFBRSxRQUFRLENBQUMsT0FBTztTQUMxQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1AsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztBQUNILENBQUM7QUFFRCwyR0FBMkc7QUFDM0csTUFBTSxVQUFVLGtCQUFrQixDQUFDLEtBQWMsRUFBRSxNQUE0QjtJQUM3RSxJQUFJLENBQUM7UUFDSCxNQUFNLE1BQU0sR0FBRyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMsTUFBTSxJQUFJLE9BQU8sQ0FBQyxLQUFLLEVBQUUsWUFBWSxDQUFDLEtBQUssU0FBUyxJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEtBQUssSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUM7WUFDNUcsT0FBTyxTQUFTLENBQUM7UUFDbkIsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxNQUFNLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDN0QsQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDYXB0dXJlSGlzdG9yeVJlY2VpcHQsIENhcHR1cmVIaXN0b3J5VGFyZ2V0IH0gZnJvbSAnLi9oaXN0b3J5VHlwZXMuanMnO1xuaW1wb3J0IHsgY2FwdHVyZUlkZW50aWZpZXIsIGNvcHlJZGVudGl0eSwgb3duRGF0YSB9IGZyb20gJy4vbm90ZVNoYXBlLmpzJztcblxuLyoqIEBpbnRlcm5hbCBCb3VuZGVkIG93bi1kYXRhIHJvb3QgaWRlbnRpdHkuIERvZXMgbm90IGV4ZWN1dGUgc3RvcmVkIGFjY2Vzc29ycy4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb3B5SGlzdG9yeVRhcmdldCh2YWx1ZTogdW5rbm93bik6IENhcHR1cmVIaXN0b3J5VGFyZ2V0IHwgdW5kZWZpbmVkIHtcbiAgdHJ5IHtcbiAgICBjb25zdCBpZGVudGl0eSA9IGNvcHlJZGVudGl0eSh2YWx1ZSk7XG4gICAgY29uc3QgZXZpZGVuY2VJZCA9IG93bkRhdGEodmFsdWUsICdldmlkZW5jZUlkJyk7XG4gICAgY29uc3QgZGlnZXN0ID0gb3duRGF0YSh2YWx1ZSwgJ2RpZ2VzdCcpO1xuICAgIGlmICghaWRlbnRpdHkgfHwgIWNhcHR1cmVJZGVudGlmaWVyKGV2aWRlbmNlSWQpIHx8IHR5cGVvZiBkaWdlc3QgIT09ICdzdHJpbmcnIHx8ICEvXlthLWYwLTldezY0fSQvLnRlc3QoZGlnZXN0KSlcbiAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgcmV0dXJuIE9iamVjdC5mcmVlemUoe1xuICAgICAgdmVyc2lvbjogMSxcbiAgICAgIGV2aWRlbmNlSWQsXG4gICAgICBydW5JZDogaWRlbnRpdHkucnVuSWQsXG4gICAgICBkaWdlc3QsXG4gICAgICBsb2dBZGRyZXNzOiBpZGVudGl0eS5sb2dBZGRyZXNzLFxuICAgICAgY29tbWl0czogaWRlbnRpdHkuY29tbWl0cyxcbiAgICB9KTtcbiAgfSBjYXRjaCB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxufVxuXG4vKiogQGludGVybmFsIEZpeGVkIGZpZWxkcyBvbmx5OyBhbiBhZGFwdGVyIGNhbm5vdCBsZWFrIGl0cyBhZGRpdGlvbmFsIHJlY2VpcHQgZGF0YSBpbnRvIHNhdmVkIG1ldGFkYXRhLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvcHlIaXN0b3J5UmVjZWlwdCh2YWx1ZTogdW5rbm93biwgdGFyZ2V0OiBDYXB0dXJlSGlzdG9yeVRhcmdldCk6IENhcHR1cmVIaXN0b3J5UmVjZWlwdCB8IHVuZGVmaW5lZCB7XG4gIHRyeSB7XG4gICAgY29uc3QgY29waWVkID0gY29weUhpc3RvcnlUYXJnZXQodmFsdWUpO1xuICAgIGlmICghY29waWVkIHx8IG93bkRhdGEodmFsdWUsICdkdXJhYmlsaXR5JykgIT09ICdkdXJhYmxlJyB8fCBKU09OLnN0cmluZ2lmeShjb3BpZWQpICE9PSBKU09OLnN0cmluZ2lmeSh0YXJnZXQpKVxuICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICByZXR1cm4gT2JqZWN0LmZyZWV6ZSh7IC4uLmNvcGllZCwgZHVyYWJpbGl0eTogJ2R1cmFibGUnIH0pO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gdW5kZWZpbmVkO1xuICB9XG59XG4iXX0=

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 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,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

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

@@ -0,0 +1,69 @@
+import type { LogAddress } from 'foottrace';
+import type { TerminalFailureContext } from '../errors/terminalFailure.js';
+/** @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: (typeof RECORDER_CONTROL_STATUSES)[number];
+}
+/** Engine observation of ONE root-log segment. Never a durable or whole-workflow completeness claim. */
+export interface NativeCaptureNote {
+    readonly version: 1;
+    readonly runId: string;
+    readonly scope: 'root-log';
+    readonly logAddress: LogAddress;
+    /** Half-open offsets in this log. A same-executor resume starts at the previous end. */
+    readonly commits: {
+        readonly from: number;
+        readonly to: number;
+    };
+    readonly boundary: {
+        readonly status: 'running' | 'completed' | 'paused' | 'failed' | 'cancelled';
+        readonly failure?: TerminalFailureContext;
+    };
+    readonly modes: {
+        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;
+        readonly writes: CaptureChannelStatus;
+        readonly attention: CaptureChannelStatus;
+        readonly control: CaptureChannelStatus;
+        readonly readSources: 'not-collected';
+    };
+    readonly persistence: 'memory-only';
+    readonly limitations: readonly CaptureLimitation[];
+}
+/** @internal Bounded facts collected at native funnels; no values, key names, recorder discovery or tree walk. */
+export declare class NativeCapture {
+    readonly runId: string;
+    readonly logAddress: LogAddress;
+    readonly from: number;
+    private readonly gaps;
+    private boundary;
+    private readonly modes;
+    constructor(runId: string, logAddress: LogAddress, from: number, modes: NativeCaptureNote['modes']);
+    limit(gap: CaptureLimitation): void;
+    end(status: NativeCaptureNote['boundary']['status'], failure?: TerminalFailureContext): void;
+    snapshot(to: number, control?: CaptureChannelStatus, redacted?: boolean): NativeCaptureNote;
+}
+/** 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

@@ -0,0 +1,140 @@
+/** @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(CAPTURE_BASE_LIMITATIONS);
+    boundary = { status: 'running' };
+    modes;
+    constructor(runId, logAddress, from, modes) {
+        this.runId = runId;
+        this.logAddress = logAddress;
+        this.from = from;
+        const retention = (value) => (isCaptureValue(value, CAPTURE_RETENTION_MODES) ? value : 'unknown');
+        this.modes = {
+            readTracking: retention(modes.readTracking),
+            writeTracking: retention(modes.writeTracking),
+            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');
+    }
+    limit(gap) {
+        this.gaps.add(gap);
+    }
+    end(status, failure) {
+        if (this.boundary.status !== 'running')
+            return;
+        if (failure?.stage && failure.stage.runtimeStageId.length > 1024) {
+            this.limit('identity-omitted');
+            failure = Object.freeze({ category: failure.category });
+        }
+        this.boundary = { status, ...(failure && { failure }) };
+    }
+    snapshot(to, control = 'unknown', redacted = false) {
+        const gaps = new Set(this.gaps);
+        if (redacted)
+            gaps.add('redacted-export');
+        const failed = gaps.has('commit-retention-failed');
+        const custom = gaps.has('custom-scope') || gaps.has('modes-unavailable');
+        return Object.freeze({
+            version: 1,
+            runId: this.runId,
+            scope: 'root-log',
+            logAddress: Object.freeze({
+                logRunId: this.logAddress.logRunId,
+                drillPath: Object.freeze([...this.logAddress.drillPath]),
+            }),
+            commits: Object.freeze({ from: this.from, to }),
+            boundary: Object.freeze({ ...this.boundary }),
+            modes: Object.freeze({
+                readTracking: this.modes.readTracking,
+                writeTracking: this.modes.writeTracking,
+                commitValues: this.modes.commitValues,
+                writeProvenance: this.modes.writeProvenance,
+            }),
+            channels: Object.freeze({
+                reads: this.modes.readTracking === 'off'
+                    ? 'disabled'
+                    : gaps.has('read-retention-failed')
+                        ? 'failed'
+                        : custom
+                            ? 'unknown'
+                            : 'captured',
+                writes: this.modes.writeTracking === 'off' ? 'disabled' : failed ? 'failed' : custom ? 'unknown' : 'captured',
+                attention: failed || gaps.has('attention-omitted') ? 'partial' : custom ? 'unknown' : 'captured',
+                control: gaps.has('recorder-snapshot-failed') ? 'failed' : control,
+                readSources: 'not-collected',
+            }),
+            persistence: 'memory-only',
+            limitations: Object.freeze([...gaps]),
+        });
+    }
+}
+/** Stored/recorder metadata is untrusted. Read data properties only, never getters or arbitrary strings. */
+export function copyCaptureAcknowledgement(value) {
+    try {
+        if (!value || typeof value !== 'object' || Object.getPrototypeOf(value) !== Object.prototype)
+            return undefined;
+        const data = (key) => Object.getOwnPropertyDescriptor(value, key)?.value;
+        const version = data('version');
+        const runId = data('runId');
+        const control = data('control');
+        if (version !== 1 ||
+            typeof runId !== 'string' ||
+            runId.length === 0 ||
+            runId.length > 2048 ||
+            !isCaptureValue(control, RECORDER_CONTROL_STATUSES))
+            return undefined;
+        return Object.freeze({ version, runId, control });
+    }
+    catch {
+        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\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/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;

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

@@ -0,0 +1,93 @@
+import { CAPTURE_CHANNEL_STATUSES, CAPTURE_COMMIT_VALUE_MODES, CAPTURE_LIMITATIONS, CAPTURE_PROVENANCE_MODES, CAPTURE_RETENTION_MODES, isCaptureValue, } from './nativeCoverage.js';
+/** @internal One inert-data boundary for checkpoint and history capture codecs. */
+export function ownData(record, key) {
+    if (!record || typeof record !== 'object' || Object.getPrototypeOf(record) !== Object.prototype)
+        return undefined;
+    return Object.getOwnPropertyDescriptor(record, key)?.value;
+}
+export function captureIdentifier(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 2048;
+}
+function count(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+/** Exact history shapes refuse extras; checkpoints deliberately project known fields. */
+function shapeKeys(value, fields, exact) {
+    return !exact || (!!value && typeof value === 'object' && Object.keys(value).length === fields.length);
+}
+export function copyIdentity(value, exact = false, version = 1) {
+    const runId = ownData(value, 'runId');
+    const address = ownData(value, 'logAddress');
+    const logRunId = ownData(address, 'logRunId');
+    const drill = ownData(address, 'drillPath');
+    const commits = ownData(value, 'commits');
+    const from = ownData(commits, 'from');
+    const to = ownData(commits, 'to');
+    if (ownData(value, 'version') !== version ||
+        !captureIdentifier(runId) ||
+        !captureIdentifier(logRunId) ||
+        !Array.isArray(drill) ||
+        Object.getPrototypeOf(drill) !== Array.prototype ||
+        Object.getOwnPropertyDescriptor(drill, 'length')?.value !== 0 ||
+        !count(from) ||
+        !count(to) ||
+        from > to ||
+        !shapeKeys(address, ['logRunId', 'drillPath'], exact) ||
+        !shapeKeys(commits, ['from', 'to'], exact))
+        return undefined;
+    return {
+        runId,
+        logAddress: Object.freeze({ logRunId, drillPath: Object.freeze([]) }),
+        commits: Object.freeze({ from, to }),
+    };
+}
+export function copyModes(value, exact = false) {
+    const readTracking = ownData(value, 'readTracking');
+    const writeTracking = ownData(value, 'writeTracking');
+    const commitValues = ownData(value, 'commitValues');
+    const writeProvenance = ownData(value, 'writeProvenance');
+    if (!isCaptureValue(readTracking, CAPTURE_RETENTION_MODES) ||
+        !isCaptureValue(writeTracking, CAPTURE_RETENTION_MODES) ||
+        !isCaptureValue(commitValues, CAPTURE_COMMIT_VALUE_MODES) ||
+        !isCaptureValue(writeProvenance, CAPTURE_PROVENANCE_MODES) ||
+        !shapeKeys(value, ['readTracking', 'writeTracking', 'commitValues', 'writeProvenance'], exact))
+        return undefined;
+    return Object.freeze({ readTracking, writeTracking, commitValues, writeProvenance });
+}
+export function copyChannels(value, exact = false) {
+    const observed = copyObservedChannels(value);
+    if (!observed ||
+        ownData(value, 'readSources') !== 'not-collected' ||
+        !shapeKeys(value, ['reads', 'writes', 'attention', 'control', 'readSources'], exact))
+        return undefined;
+    return Object.freeze({ ...observed, readSources: 'not-collected' });
+}
+/** Shared native statuses; source version admission remains explicit at each codec boundary. */
+export function copyObservedChannels(value) {
+    const reads = ownData(value, 'reads');
+    const writes = ownData(value, 'writes');
+    const attention = ownData(value, 'attention');
+    const control = ownData(value, 'control');
+    if (!isCaptureValue(reads, CAPTURE_CHANNEL_STATUSES) ||
+        !isCaptureValue(writes, CAPTURE_CHANNEL_STATUSES) ||
+        !isCaptureValue(attention, CAPTURE_CHANNEL_STATUSES) ||
+        !isCaptureValue(control, CAPTURE_CHANNEL_STATUSES))
+        return undefined;
+    return Object.freeze({ reads, writes, attention, control });
+}
+export function copyLimitations(value) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype)
+        return undefined;
+    const length = Object.getOwnPropertyDescriptor(value, 'length')?.value;
+    if (!count(length) || length > 32)
+        return undefined;
+    const limitations = [];
+    for (let index = 0; index < length; index++) {
+        const entry = Object.getOwnPropertyDescriptor(value, String(index))?.value;
+        if (!isCaptureValue(entry, CAPTURE_LIMITATIONS))
+            return undefined;
+        limitations.push(entry);
+    }
+    return Object.freeze(limitations);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"noteShape.js","sourceRoot":"","sources":["../../../../src/lib/capture/noteShape.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CaptureLimitation, NativeCaptureNote } from './nativeCoverage.js';\nimport {\n  CAPTURE_CHANNEL_STATUSES,\n  CAPTURE_COMMIT_VALUE_MODES,\n  CAPTURE_LIMITATIONS,\n  CAPTURE_PROVENANCE_MODES,\n  CAPTURE_RETENTION_MODES,\n  isCaptureValue,\n} from './nativeCoverage.js';\n\n/** @internal One inert-data boundary for checkpoint and history capture codecs. */\nexport function ownData(record: unknown, key: string): unknown {\n  if (!record || typeof record !== 'object' || Object.getPrototypeOf(record) !== Object.prototype) return undefined;\n  return Object.getOwnPropertyDescriptor(record, key)?.value;\n}\n\nexport function captureIdentifier(value: unknown): value is string {\n  return typeof value === 'string' && value.length > 0 && value.length <= 2048;\n}\n\nfunction count(value: unknown): value is number {\n  return Number.isSafeInteger(value) && (value as number) >= 0;\n}\n\n/** Exact history shapes refuse extras; checkpoints deliberately project known fields. */\nfunction shapeKeys(value: unknown, fields: readonly string[], exact: boolean): boolean {\n  return !exact || (!!value && typeof value === 'object' && Object.keys(value).length === fields.length);\n}\n\nexport function copyIdentity(\n  value: unknown,\n  exact = false,\n  version: 1 | 2 = 1,\n): Pick<NativeCaptureNote, 'runId' | 'logAddress' | 'commits'> | undefined {\n  const runId = ownData(value, 'runId');\n  const address = ownData(value, 'logAddress');\n  const logRunId = ownData(address, 'logRunId');\n  const drill = ownData(address, 'drillPath');\n  const commits = ownData(value, 'commits');\n  const from = ownData(commits, 'from');\n  const to = ownData(commits, 'to');\n  if (\n    ownData(value, 'version') !== version ||\n    !captureIdentifier(runId) ||\n    !captureIdentifier(logRunId) ||\n    !Array.isArray(drill) ||\n    Object.getPrototypeOf(drill) !== Array.prototype ||\n    Object.getOwnPropertyDescriptor(drill, 'length')?.value !== 0 ||\n    !count(from) ||\n    !count(to) ||\n    from > to ||\n    !shapeKeys(address, ['logRunId', 'drillPath'], exact) ||\n    !shapeKeys(commits, ['from', 'to'], exact)\n  )\n    return undefined;\n  return {\n    runId,\n    logAddress: Object.freeze({ logRunId, drillPath: Object.freeze([]) }),\n    commits: Object.freeze({ from, to }),\n  };\n}\n\nexport function copyModes(value: unknown, exact = false): NativeCaptureNote['modes'] | undefined {\n  const readTracking = ownData(value, 'readTracking');\n  const writeTracking = ownData(value, 'writeTracking');\n  const commitValues = ownData(value, 'commitValues');\n  const writeProvenance = ownData(value, 'writeProvenance');\n  if (\n    !isCaptureValue(readTracking, CAPTURE_RETENTION_MODES) ||\n    !isCaptureValue(writeTracking, CAPTURE_RETENTION_MODES) ||\n    !isCaptureValue(commitValues, CAPTURE_COMMIT_VALUE_MODES) ||\n    !isCaptureValue(writeProvenance, CAPTURE_PROVENANCE_MODES) ||\n    !shapeKeys(value, ['readTracking', 'writeTracking', 'commitValues', 'writeProvenance'], exact)\n  )\n    return undefined;\n  return Object.freeze({ readTracking, writeTracking, commitValues, writeProvenance });\n}\n\nexport function copyChannels(value: unknown, exact = false): NativeCaptureNote['channels'] | undefined {\n  const observed = copyObservedChannels(value);\n  if (\n    !observed ||\n    ownData(value, 'readSources') !== 'not-collected' ||\n    !shapeKeys(value, ['reads', 'writes', 'attention', 'control', 'readSources'], exact)\n  )\n    return undefined;\n  return Object.freeze({ ...observed, readSources: 'not-collected' });\n}\n\n/** Shared native statuses; source version admission remains explicit at each codec boundary. */\nexport function copyObservedChannels(value: unknown): Omit<NativeCaptureNote['channels'], 'readSources'> | undefined {\n  const reads = ownData(value, 'reads');\n  const writes = ownData(value, 'writes');\n  const attention = ownData(value, 'attention');\n  const control = ownData(value, 'control');\n  if (\n    !isCaptureValue(reads, CAPTURE_CHANNEL_STATUSES) ||\n    !isCaptureValue(writes, CAPTURE_CHANNEL_STATUSES) ||\n    !isCaptureValue(attention, CAPTURE_CHANNEL_STATUSES) ||\n    !isCaptureValue(control, CAPTURE_CHANNEL_STATUSES)\n  )\n    return undefined;\n  return Object.freeze({ reads, writes, attention, control });\n}\n\nexport function copyLimitations(value: unknown): readonly CaptureLimitation[] | undefined {\n  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;\n  const length = Object.getOwnPropertyDescriptor(value, 'length')?.value;\n  if (!count(length) || length > 32) return undefined;\n  const limitations: CaptureLimitation[] = [];\n  for (let index = 0; index < length; index++) {\n    const entry = Object.getOwnPropertyDescriptor(value, String(index))?.value;\n    if (!isCaptureValue(entry, CAPTURE_LIMITATIONS)) return undefined;\n    limitations.push(entry);\n  }\n  return Object.freeze(limitations);\n}\n"]}

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

@@ -0,0 +1,43 @@
+import type { ReadSourceRecord, ReadSourceSnapshot } from 'foottrace/write';
+import type { CaptureChannelStatus, NativeCaptureNote } from './nativeCoverage.js';
+/** Engine coverage only. Source descriptors and their codec belong to foottrace/write. */
+export declare const SOURCE_LIMITATIONS: readonly ["privacy-active", "identity-unavailable", "untracked-read", "custom-scope", "child-source-ownership", "resumed-source-ownership", "sink-source-unsupported", "source-history-not-included", "source-capture-failed", "redacted-source-export"];
+export type SourceLimitation = (typeof SOURCE_LIMITATIONS)[number];
+/** Packet 3 is an in-memory observation, not a stored-history acknowledgement. */
+export interface EngineReadSources {
+    readonly version: 1;
+    readonly runId: string;
+    readonly persistence: 'memory-only';
+    readonly commits: {
+        readonly from: number;
+        readonly to: number;
+    };
+    readonly status: CaptureChannelStatus;
+    readonly limitations: readonly SourceLimitation[];
+    /** Absent means unknown ownership, never an observed-empty book. */
+    readonly record?: ReadSourceSnapshot;
+}
+/** A new discriminant prevents strict v1 readers from accepting new completeness claims. */
+export interface NativeReadCaptureNote extends Omit<NativeCaptureNote, 'version' | 'channels'> {
+    readonly version: 2;
+    readonly channels: Omit<NativeCaptureNote['channels'], 'readSources'> & {
+        readonly readSources: CaptureChannelStatus;
+    };
+}
+export type NativeCaptureObservation = NativeCaptureNote | NativeReadCaptureNote;
+/** One owner per runtime/leg; propagated only to frames in that log. Never reads values or scans commits. */
+export declare class EngineReadSourceCapture {
+    readonly runId: string;
+    private readonly book?;
+    readonly from: number;
+    private readonly gaps;
+    private sealed?;
+    get observing(): boolean;
+    constructor(runId: string, book?: ReadSourceRecord | undefined, gap?: SourceLimitation, from?: number);
+    limit(gap: SourceLimitation): void;
+    retire(): void;
+    seal(to: number): void;
+    snapshot(to: number, redact?: boolean): EngineReadSources;
+}
+/** Keep the v1 producer unchanged. Only explicitly enabled source observations acquire v2. */
+export declare function withReadSources(note: NativeCaptureNote, sources: EngineReadSources): NativeReadCaptureNote;

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

@@ -0,0 +1,78 @@
+/** Engine coverage only. Source descriptors and their codec belong to foottrace/write. */
+export const SOURCE_LIMITATIONS = Object.freeze([
+    'privacy-active',
+    'identity-unavailable',
+    'untracked-read',
+    'custom-scope',
+    'child-source-ownership',
+    'resumed-source-ownership',
+    'sink-source-unsupported',
+    'source-history-not-included',
+    'source-capture-failed',
+    'redacted-source-export',
+]);
+/** One owner per runtime/leg; propagated only to frames in that log. Never reads values or scans commits. */
+export class EngineReadSourceCapture {
+    runId;
+    book;
+    from;
+    gaps = new Set();
+    sealed;
+    get observing() {
+        return this.book !== undefined;
+    }
+    constructor(runId, book, gap, from = 0) {
+        this.runId = runId;
+        this.book = book;
+        this.from = from;
+        if (gap)
+            this.gaps.add(gap);
+    }
+    limit(gap) {
+        if (!this.sealed)
+            this.gaps.add(gap);
+    }
+    retire() {
+        this.book?.retire();
+    }
+    seal(to) {
+        if (this.sealed)
+            return;
+        this.sealed = this.snapshot(to);
+        this.retire();
+    }
+    snapshot(to, redact = false) {
+        if (this.sealed && !redact)
+            return this.sealed;
+        const gaps = new Set(this.gaps);
+        if (redact)
+            gaps.add('redacted-source-export');
+        const record = redact ? undefined : this.book?.snapshot();
+        const status = !record
+            ? 'unknown'
+            : record.status === 'failed'
+                ? 'failed'
+                : record.status !== 'captured' || gaps.size > 0
+                    ? 'partial'
+                    : 'captured';
+        return Object.freeze({
+            version: 1,
+            runId: this.runId,
+            persistence: 'memory-only',
+            commits: Object.freeze({ from: this.from, to }),
+            status,
+            limitations: Object.freeze([...gaps]),
+            ...(record && { record }),
+        });
+    }
+}
+/** Keep the v1 producer unchanged. Only explicitly enabled source observations acquire v2. */
+export function withReadSources(note, sources) {
+    return Object.freeze({
+        ...note,
+        version: 2,
+        channels: Object.freeze({ ...note.channels, readSources: sources.status }),
+        limitations: Object.freeze(note.limitations.filter((gap) => gap !== 'read-sources-not-collected')),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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