footprintjs 10.3.0 → 10.5.0

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,49 @@
+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", "source-address-unsupported", "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?;
+    private retired;
+    get observing(): boolean;
+    get active(): 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;
+/** One status rule shared by native observations and stored admission; storage cannot upgrade coverage. */
+export declare function readSourceStatus(record: ReadSourceSnapshot | undefined, limitations: number): CaptureChannelStatus;
+/** Redacted exports withhold every reference, including those captured before a later privacy mark. */
+export declare function redactReadSources(source: EngineReadSources): EngineReadSources;

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

@@ -0,0 +1,99 @@
+/** 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',
+    'source-address-unsupported',
+    '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;
+    retired = false;
+    get observing() {
+        return this.book !== undefined;
+    }
+    get active() {
+        return this.observing && !this.retired;
+    }
+    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.retired = true;
+        this.book?.retire();
+    }
+    seal(to) {
+        if (this.sealed)
+            return;
+        this.sealed = this.snapshot(to);
+        this.retire();
+    }
+    snapshot(to, redact = false) {
+        if (redact)
+            return redactReadSources(this.snapshot(to));
+        if (this.sealed && !redact)
+            return this.sealed;
+        const gaps = new Set(this.gaps);
+        const record = this.book?.snapshot();
+        const status = readSourceStatus(record, gaps.size);
+        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')),
+    });
+}
+/** One status rule shared by native observations and stored admission; storage cannot upgrade coverage. */
+export function readSourceStatus(record, limitations) {
+    return !record
+        ? 'unknown'
+        : record.status === 'failed'
+            ? 'failed'
+            : record.status !== 'captured' || limitations > 0
+                ? 'partial'
+                : 'captured';
+}
+/** Redacted exports withhold every reference, including those captured before a later privacy mark. */
+export function redactReadSources(source) {
+    return Object.freeze({
+        version: source.version,
+        runId: source.runId,
+        persistence: source.persistence,
+        commits: source.commits,
+        status: 'unknown',
+        limitations: Object.freeze([...new Set([...source.limitations, 'redacted-source-export'])]),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readSources.js","sourceRoot":"","sources":["../../../../src/lib/capture/readSources.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ReadSourceRecord, ReadSourceSnapshot } from 'foottrace/write';\n\nimport type { CaptureChannelStatus, NativeCaptureNote } from './nativeCoverage.js';\n\n/** Engine coverage only. Source descriptors and their codec belong to foottrace/write. */\nexport const SOURCE_LIMITATIONS = Object.freeze([\n  'privacy-active',\n  'identity-unavailable',\n  'untracked-read',\n  'custom-scope',\n  'child-source-ownership',\n  'source-address-unsupported',\n  'resumed-source-ownership',\n  'sink-source-unsupported',\n  'source-history-not-included',\n  'source-capture-failed',\n  'redacted-source-export',\n] as const);\nexport type SourceLimitation = (typeof SOURCE_LIMITATIONS)[number];\n\n/** Packet 3 is an in-memory observation, not a stored-history acknowledgement. */\nexport interface EngineReadSources {\n  readonly version: 1;\n  readonly runId: string;\n  readonly persistence: 'memory-only';\n  readonly commits: { readonly from: number; readonly to: number };\n  readonly status: CaptureChannelStatus;\n  readonly limitations: readonly SourceLimitation[];\n  /** Absent means unknown ownership, never an observed-empty book. */\n  readonly record?: ReadSourceSnapshot;\n}\n\n/** A new discriminant prevents strict v1 readers from accepting new completeness claims. */\nexport interface NativeReadCaptureNote extends Omit<NativeCaptureNote, 'version' | 'channels'> {\n  readonly version: 2;\n  readonly channels: Omit<NativeCaptureNote['channels'], 'readSources'> & {\n    readonly readSources: CaptureChannelStatus;\n  };\n}\nexport type NativeCaptureObservation = NativeCaptureNote | NativeReadCaptureNote;\n\n/** One owner per runtime/leg; propagated only to frames in that log. Never reads values or scans commits. */\nexport class EngineReadSourceCapture {\n  private readonly gaps = new Set<SourceLimitation>();\n  private sealed?: EngineReadSources;\n  private retired = false;\n  get observing(): boolean {\n    return this.book !== undefined;\n  }\n\n  get active(): boolean {\n    return this.observing && !this.retired;\n  }\n\n  constructor(\n    readonly runId: string,\n    private readonly book?: ReadSourceRecord,\n    gap?: SourceLimitation,\n    readonly from = 0,\n  ) {\n    if (gap) this.gaps.add(gap);\n  }\n\n  limit(gap: SourceLimitation): void {\n    if (!this.sealed) this.gaps.add(gap);\n  }\n\n  retire(): void {\n    this.retired = true;\n    this.book?.retire();\n  }\n\n  seal(to: number): void {\n    if (this.sealed) return;\n    this.sealed = this.snapshot(to);\n    this.retire();\n  }\n\n  snapshot(to: number, redact = false): EngineReadSources {\n    if (redact) return redactReadSources(this.snapshot(to));\n    if (this.sealed && !redact) return this.sealed;\n    const gaps = new Set(this.gaps);\n    const record = this.book?.snapshot();\n    const status = readSourceStatus(record, gaps.size);\n    return Object.freeze({\n      version: 1,\n      runId: this.runId,\n      persistence: 'memory-only',\n      commits: Object.freeze({ from: this.from, to }),\n      status,\n      limitations: Object.freeze([...gaps]),\n      ...(record && { record }),\n    });\n  }\n}\n\n/** Keep the v1 producer unchanged. Only explicitly enabled source observations acquire v2. */\nexport function withReadSources(note: NativeCaptureNote, sources: EngineReadSources): NativeReadCaptureNote {\n  return Object.freeze({\n    ...note,\n    version: 2,\n    channels: Object.freeze({ ...note.channels, readSources: sources.status }),\n    limitations: Object.freeze(note.limitations.filter((gap) => gap !== 'read-sources-not-collected')),\n  });\n}\n\n/** One status rule shared by native observations and stored admission; storage cannot upgrade coverage. */\nexport function readSourceStatus(record: ReadSourceSnapshot | undefined, limitations: number): CaptureChannelStatus {\n  return !record\n    ? 'unknown'\n    : record.status === 'failed'\n    ? 'failed'\n    : record.status !== 'captured' || limitations > 0\n    ? 'partial'\n    : 'captured';\n}\n\n/** Redacted exports withhold every reference, including those captured before a later privacy mark. */\nexport function redactReadSources(source: EngineReadSources): EngineReadSources {\n  return Object.freeze({\n    version: source.version,\n    runId: source.runId,\n    persistence: source.persistence,\n    commits: source.commits,\n    status: 'unknown',\n    limitations: Object.freeze([...new Set([...source.limitations, 'redacted-source-export' as const])]),\n  });\n}\n"]}

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

@@ -0,0 +1,6 @@
+/**
+ * `value`, settled ONCE into `onValue` / `onError` — never through the value's own `then`: a native promise is
+ * watched through the real `Promise.prototype.then` (an own `then` on it is not trusted, so its rejection is always
+ * handled), any other thenable adopted into a fresh promise. A plain value is a fulfilment.
+ */
+export declare function settleOnce<T>(value: unknown, onValue: () => T, onError: (error: unknown) => T): Promise<T>;

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

@@ -0,0 +1,10 @@
+/**
+ * `value`, settled ONCE into `onValue` / `onError` — never through the value's own `then`: a native promise is
+ * watched through the real `Promise.prototype.then` (an own `then` on it is not trusted, so its rejection is always
+ * handled), any other thenable adopted into a fresh promise. A plain value is a fulfilment.
+ */
+export function settleOnce(value, onValue, onError) {
+    const adopted = value instanceof Promise ? value : new Promise((resolve) => resolve(value));
+    return Promise.prototype.then.call(adopted, onValue, onError);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lua1NldHRsZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NhcHR1cmUvc2lua1NldHRsZW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUksS0FBYyxFQUFFLE9BQWdCLEVBQUUsT0FBOEI7SUFDNUYsTUFBTSxPQUFPLEdBQXFCLEtBQUssWUFBWSxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQzlHLE9BQU8sT0FBTyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFlLENBQUM7QUFDOUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogYHZhbHVlYCwgc2V0dGxlZCBPTkNFIGludG8gYG9uVmFsdWVgIC8gYG9uRXJyb3JgIOKAlCBuZXZlciB0aHJvdWdoIHRoZSB2YWx1ZSdzIG93biBgdGhlbmA6IGEgbmF0aXZlIHByb21pc2UgaXNcbiAqIHdhdGNoZWQgdGhyb3VnaCB0aGUgcmVhbCBgUHJvbWlzZS5wcm90b3R5cGUudGhlbmAgKGFuIG93biBgdGhlbmAgb24gaXQgaXMgbm90IHRydXN0ZWQsIHNvIGl0cyByZWplY3Rpb24gaXMgYWx3YXlzXG4gKiBoYW5kbGVkKSwgYW55IG90aGVyIHRoZW5hYmxlIGFkb3B0ZWQgaW50byBhIGZyZXNoIHByb21pc2UuIEEgcGxhaW4gdmFsdWUgaXMgYSBmdWxmaWxtZW50LlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2V0dGxlT25jZTxUPih2YWx1ZTogdW5rbm93biwgb25WYWx1ZTogKCkgPT4gVCwgb25FcnJvcjogKGVycm9yOiB1bmtub3duKSA9PiBUKTogUHJvbWlzZTxUPiB7XG4gIGNvbnN0IGFkb3B0ZWQ6IFByb21pc2U8dW5rbm93bj4gPSB2YWx1ZSBpbnN0YW5jZW9mIFByb21pc2UgPyB2YWx1ZSA6IG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiByZXNvbHZlKHZhbHVlKSk7XG4gIHJldHVybiBQcm9taXNlLnByb3RvdHlwZS50aGVuLmNhbGwoYWRvcHRlZCwgb25WYWx1ZSwgb25FcnJvcikgYXMgUHJvbWlzZTxUPjtcbn1cbiJdfQ==

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

@@ -0,0 +1,18 @@
+import type { ReadSource } from 'foottrace/write';
+/** Native per-execution totals, independent of last-value retention and the bounded source book. */
+export interface SourceReadCounts {
+    readonly observed: number;
+    readonly retained: number;
+    /** Counts the native writer's returned kinds, never classifies values or chooses sources. */
+    readonly kinds: Readonly<Record<ReadSource['kind'], number>>;
+}
+export declare const EMPTY_SOURCE_READ_COUNTS: SourceReadCounts;
+/** Fixed scalar counters only; discarded attempts remain part of this execution's history. */
+export declare class SourceReadCounter {
+    private observed;
+    private retained;
+    private kinds;
+    observe(): boolean;
+    retain(kind: ReadSource['kind']): void;
+    snapshot(): SourceReadCounts;
+}

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

@@ -0,0 +1,27 @@
+export const EMPTY_SOURCE_READ_COUNTS = Object.freeze({
+    observed: 0,
+    retained: 0,
+    kinds: Object.freeze({ base: 0, committed: 0, staged: 0, unavailable: 0 }),
+});
+/** Fixed scalar counters only; discarded attempts remain part of this execution's history. */
+export class SourceReadCounter {
+    observed = 0;
+    retained = 0;
+    kinds = { ...EMPTY_SOURCE_READ_COUNTS.kinds };
+    observe() {
+        if (this.observed === Number.MAX_SAFE_INTEGER)
+            return false;
+        this.observed++;
+        return true;
+    }
+    retain(kind) {
+        if (this.retained < this.observed) {
+            this.retained++;
+            this.kinds[kind]++;
+        }
+    }
+    snapshot() {
+        return Object.freeze({ observed: this.observed, retained: this.retained, kinds: Object.freeze({ ...this.kinds }) });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import type { CommitBundle } from 'foottrace';
+/** Conservative work cap before each distinct public value query, including shared-root replay/cloning. */
+export declare class SourceReferenceBudget {
+    private rows;
+    private bytes;
+    private readonly queryRows;
+    private readonly queryBytes;
+    constructor(commitLog: readonly CommitBundle[], initialState?: Record<string, unknown>);
+    spend(): void;
+}

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

@@ -0,0 +1,21 @@
+import { HistoryDataError } from './historyData.js';
+/** Conservative work cap before each distinct public value query, including shared-root replay/cloning. */
+export class SourceReferenceBudget {
+    rows = 0;
+    bytes = 0;
+    queryRows;
+    queryBytes;
+    constructor(commitLog, initialState) {
+        this.queryRows = 1 + commitLog.length + commitLog.reduce((count, bundle) => count + bundle.trace.length, 0);
+        this.queryBytes = new TextEncoder().encode(JSON.stringify({ commitLog, initialState })).length;
+    }
+    spend() {
+        // The entire admitted basis is an upper estimate for each query; repeat (commit,key) hits spend nothing.
+        // Refuse before calling the reader, never after doing unaccounted work or silently cutting evidence.
+        if (this.queryRows > 1_000_000 - this.rows || this.queryBytes > 64 * 1024 * 1024 - this.bytes)
+            throw new HistoryDataError('source-validation-limit');
+        this.rows += this.queryRows;
+        this.bytes += this.queryBytes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+import type { ReadSourceSnapshot } from 'foottrace/write';
+/** Already inert, byte-bounded evidence. Check native counts; never reconstruct read occurrences. */
+export declare function storedReadSourceCounts(record: ReadSourceSnapshot, executionTree: unknown, committedOwners: ReadonlyMap<string, number>): boolean;

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

@@ -0,0 +1,78 @@
+import { EMPTY_SOURCE_READ_COUNTS } from './sourceReadCounts.js';
+const KINDS = Object.keys(EMPTY_SOURCE_READ_COUNTS.kinds);
+function countsOf(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const counts = value;
+    if (Object.keys(value).length !== 3 ||
+        !Number.isSafeInteger(counts.observed) ||
+        !Number.isSafeInteger(counts.retained) ||
+        counts.observed < 0 ||
+        counts.retained < 0 ||
+        counts.retained > counts.observed)
+        return undefined;
+    if (!counts.kinds || typeof counts.kinds !== 'object' || Array.isArray(counts.kinds))
+        return undefined;
+    if (Object.keys(counts.kinds).length !== KINDS.length)
+        return undefined;
+    let sum = 0;
+    for (const kind of KINDS) {
+        const count = counts.kinds[kind];
+        if (!Number.isSafeInteger(count) || count < 0)
+            return undefined;
+        sum += count;
+        if (sum > counts.retained)
+            return undefined;
+    }
+    if (sum !== counts.retained)
+        return undefined;
+    return counts;
+}
+/** Already inert, byte-bounded evidence. Check native counts; never reconstruct read occurrences. */
+export function storedReadSourceCounts(record, executionTree, committedOwners) {
+    const owners = new Map();
+    const pending = [executionTree];
+    let visited = 0;
+    while (pending.length) {
+        if (++visited > 100_000)
+            return false;
+        const value = pending.pop();
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return false;
+        const node = value;
+        const id = node.runtimeStageId;
+        if (Object.hasOwn(node, 'readSourceCounts')) {
+            const counts = countsOf(node.readSourceCounts);
+            if (!counts || (record.status === 'captured' && counts.observed !== counts.retained))
+                return false;
+            if (typeof id !== 'string' || !id) {
+                if (counts.observed || counts.retained)
+                    return false;
+            }
+            else {
+                if (owners.has(id))
+                    return false;
+                owners.set(id, counts);
+            }
+        }
+        else if (typeof id === 'string' && committedOwners.has(id))
+            return false;
+        if (Object.hasOwn(node, 'next'))
+            pending.push(node.next);
+        if (Object.hasOwn(node, 'children')) {
+            if (!Array.isArray(node.children) || node.children.length > 100_000 - visited - pending.length)
+                return false;
+            for (const child of node.children)
+                pending.push(child);
+        }
+    }
+    const remaining = new Map([...owners].map(([id, counts]) => [id, { ...counts.kinds }]));
+    for (const row of record.occurrences) {
+        const counts = remaining.get(row.runtimeStageId);
+        if (!counts || counts[row.source.kind] === 0)
+            return false;
+        counts[row.source.kind]--;
+    }
+    return [...remaining.values()].every((counts) => KINDS.every((kind) => counts[kind] === 0));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storedReadSourceCounts.js","sourceRoot":"","sources":["../../../../src/lib/capture/storedReadSourceCounts.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ReadSourceSnapshot } from 'foottrace/write';\n\nimport type { SourceReadCounts } from './sourceReadCounts.js';\nimport { EMPTY_SOURCE_READ_COUNTS } from './sourceReadCounts.js';\n\nconst KINDS = Object.keys(EMPTY_SOURCE_READ_COUNTS.kinds) as (keyof SourceReadCounts['kinds'])[];\n\nfunction countsOf(value: unknown): SourceReadCounts | undefined {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;\n  const counts = value as SourceReadCounts;\n  if (\n    Object.keys(value).length !== 3 ||\n    !Number.isSafeInteger(counts.observed) ||\n    !Number.isSafeInteger(counts.retained) ||\n    counts.observed < 0 ||\n    counts.retained < 0 ||\n    counts.retained > counts.observed\n  )\n    return undefined;\n  if (!counts.kinds || typeof counts.kinds !== 'object' || Array.isArray(counts.kinds)) return undefined;\n  if (Object.keys(counts.kinds).length !== KINDS.length) return undefined;\n  let sum = 0;\n  for (const kind of KINDS) {\n    const count = counts.kinds[kind];\n    if (!Number.isSafeInteger(count) || count < 0) return undefined;\n    sum += count;\n    if (sum > counts.retained) return undefined;\n  }\n  if (sum !== counts.retained) return undefined;\n  return counts;\n}\n\n/** Already inert, byte-bounded evidence. Check native counts; never reconstruct read occurrences. */\nexport function storedReadSourceCounts(\n  record: ReadSourceSnapshot,\n  executionTree: unknown,\n  committedOwners: ReadonlyMap<string, number>,\n): boolean {\n  const owners = new Map<string, SourceReadCounts>();\n  const pending = [executionTree];\n  let visited = 0;\n  while (pending.length) {\n    if (++visited > 100_000) return false;\n    const value = pending.pop();\n    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;\n    const node = value as Record<string, unknown>;\n    const id = node.runtimeStageId;\n    if (Object.hasOwn(node, 'readSourceCounts')) {\n      const counts = countsOf(node.readSourceCounts);\n      if (!counts || (record.status === 'captured' && counts.observed !== counts.retained)) return false;\n      if (typeof id !== 'string' || !id) {\n        if (counts.observed || counts.retained) return false;\n      } else {\n        if (owners.has(id)) return false;\n        owners.set(id, counts);\n      }\n    } else if (typeof id === 'string' && committedOwners.has(id)) return false;\n    if (Object.hasOwn(node, 'next')) pending.push(node.next);\n    if (Object.hasOwn(node, 'children')) {\n      if (!Array.isArray(node.children) || node.children.length > 100_000 - visited - pending.length) return false;\n      for (const child of node.children) pending.push(child);\n    }\n  }\n  const remaining = new Map([...owners].map(([id, counts]) => [id, { ...counts.kinds }]));\n  for (const row of record.occurrences) {\n    const counts = remaining.get(row.runtimeStageId);\n    if (!counts || counts[row.source.kind] === 0) return false;\n    counts[row.source.kind]--;\n  }\n  return [...remaining.values()].every((counts) => KINDS.every((kind) => counts[kind] === 0));\n}\n"]}

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

@@ -0,0 +1,4 @@
+import type { CommitBundle } from 'foottrace';
+import type { EngineReadSources, NativeReadCaptureNote } from './readSources.js';
+/** After inert JSON admission: the record's codec owns descriptors; the engine binds its root observation. */
+export declare function storedReadSources(value: unknown, capture: NativeReadCaptureNote, commitLog: readonly CommitBundle[], initialState?: Record<string, unknown>, executionTree?: unknown): EngineReadSources | undefined;