footprintjs 10.4.0 → 10.6.0

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

@@ -1,3 +1,4 @@
+import { redactSourceOwnership, SourceOwnershipCollector } from './sourceOwnership.js';
 /** Engine coverage only. Source descriptors and their codec belong to foottrace/write. */
 export const SOURCE_LIMITATIONS = Object.freeze([
     'privacy-active',
@@ -5,6 +6,7 @@ export const SOURCE_LIMITATIONS = Object.freeze([
     'untracked-read',
     'custom-scope',
     'child-source-ownership',
+    'source-address-unsupported',
     'resumed-source-ownership',
     'sink-source-unsupported',
     'source-history-not-included',
@@ -16,23 +18,31 @@ export class EngineReadSourceCapture {
     runId;
     book;
     from;
+    ownership;
     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);
+        if (book?.log.address)
+            this.ownership = new SourceOwnershipCollector(runId, book.log.address, from);
     }
     limit(gap) {
         if (!this.sealed)
             this.gaps.add(gap);
     }
     retire() {
+        this.retired = true;
         this.book?.retire();
     }
     seal(to) {
@@ -42,21 +52,17 @@ export class EngineReadSourceCapture {
         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);
-        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';
+        const record = this.book?.snapshot();
+        const status = readSourceStatus(record, gaps.size);
         return Object.freeze({
-            version: 1,
+            ...(record && this.ownership
+                ? { version: 2, ownership: this.ownership.snapshot(to, record.segment) }
+                : { version: 1 }),
             runId: this.runId,
             persistence: 'memory-only',
             commits: Object.freeze({ from: this.from, to }),
@@ -75,4 +81,27 @@ export function withReadSources(note, sources) {
         limitations: Object.freeze(note.limitations.filter((gap) => gap !== 'read-sources-not-collected')),
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZFNvdXJjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NhcHR1cmUvcmVhZFNvdXJjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsMEZBQTBGO0FBQzFGLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDOUMsZ0JBQWdCO0lBQ2hCLHNCQUFzQjtJQUN0QixnQkFBZ0I7SUFDaEIsY0FBYztJQUNkLHdCQUF3QjtJQUN4QiwwQkFBMEI7SUFDMUIseUJBQXlCO0lBQ3pCLDZCQUE2QjtJQUM3Qix1QkFBdUI7SUFDdkIsd0JBQXdCO0NBQ2hCLENBQUMsQ0FBQztBQXdCWiw2R0FBNkc7QUFDN0csTUFBTSxPQUFPLHVCQUF1QjtJQVF2QjtJQUNRO0lBRVI7SUFWTSxJQUFJLEdBQUcsSUFBSSxHQUFHLEVBQW9CLENBQUM7SUFDNUMsTUFBTSxDQUFxQjtJQUNuQyxJQUFJLFNBQVM7UUFDWCxPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssU0FBUyxDQUFDO0lBQ2pDLENBQUM7SUFFRCxZQUNXLEtBQWEsRUFDTCxJQUF1QixFQUN4QyxHQUFzQixFQUNiLE9BQU8sQ0FBQztRQUhSLFVBQUssR0FBTCxLQUFLLENBQVE7UUFDTCxTQUFJLEdBQUosSUFBSSxDQUFtQjtRQUUvQixTQUFJLEdBQUosSUFBSSxDQUFJO1FBRWpCLElBQUksR0FBRztZQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzlCLENBQUM7SUFFRCxLQUFLLENBQUMsR0FBcUI7UUFDekIsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNO1lBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVELE1BQU07UUFDSixJQUFJLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ3RCLENBQUM7SUFFRCxJQUFJLENBQUMsRUFBVTtRQUNiLElBQUksSUFBSSxDQUFDLE1BQU07WUFBRSxPQUFPO1FBQ3hCLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNoQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDaEIsQ0FBQztJQUVELFFBQVEsQ0FBQyxFQUFVLEVBQUUsTUFBTSxHQUFHLEtBQUs7UUFDakMsSUFBSSxJQUFJLENBQUMsTUFBTSxJQUFJLENBQUMsTUFBTTtZQUFFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUMvQyxNQUFNLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDaEMsSUFBSSxNQUFNO1lBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO1FBQy9DLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsRUFBRSxDQUFDO1FBQzFELE1BQU0sTUFBTSxHQUFHLENBQUMsTUFBTTtZQUNwQixDQUFDLENBQUMsU0FBUztZQUNYLENBQUMsQ0FBQyxNQUFNLENBQUMsTUFBTSxLQUFLLFFBQVE7Z0JBQzVCLENBQUMsQ0FBQyxRQUFRO2dCQUNWLENBQUMsQ0FBQyxNQUFNLENBQUMsTUFBTSxLQUFLLFVBQVUsSUFBSSxJQUFJLENBQUMsSUFBSSxHQUFHLENBQUM7b0JBQy9DLENBQUMsQ0FBQyxTQUFTO29CQUNYLENBQUMsQ0FBQyxVQUFVLENBQUM7UUFDZixPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUM7WUFDbkIsT0FBTyxFQUFFLENBQUM7WUFDVixLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUs7WUFDakIsV0FBVyxFQUFFLGFBQWE7WUFDMUIsT0FBTyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQztZQUMvQyxNQUFNO1lBQ04sV0FBVyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO1lBQ3JDLEdBQUcsQ0FBQyxNQUFNLElBQUksRUFBRSxNQUFNLEVBQUUsQ0FBQztTQUMxQixDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUFFRCw4RkFBOEY7QUFDOUYsTUFBTSxVQUFVLGVBQWUsQ0FBQyxJQUF1QixFQUFFLE9BQTBCO0lBQ2pGLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUNuQixHQUFHLElBQUk7UUFDUCxPQUFPLEVBQUUsQ0FBQztRQUNWLFFBQVEsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLFdBQVcsRUFBRSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDMUUsV0FBVyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsS0FBSyw0QkFBNEIsQ0FBQyxDQUFDO0tBQ25HLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJlYWRTb3VyY2VSZWNvcmQsIFJlYWRTb3VyY2VTbmFwc2hvdCB9IGZyb20gJ2Zvb3R0cmFjZS93cml0ZSc7XG5cbmltcG9ydCB0eXBlIHsgQ2FwdHVyZUNoYW5uZWxTdGF0dXMsIE5hdGl2ZUNhcHR1cmVOb3RlIH0gZnJvbSAnLi9uYXRpdmVDb3ZlcmFnZS5qcyc7XG5cbi8qKiBFbmdpbmUgY292ZXJhZ2Ugb25seS4gU291cmNlIGRlc2NyaXB0b3JzIGFuZCB0aGVpciBjb2RlYyBiZWxvbmcgdG8gZm9vdHRyYWNlL3dyaXRlLiAqL1xuZXhwb3J0IGNvbnN0IFNPVVJDRV9MSU1JVEFUSU9OUyA9IE9iamVjdC5mcmVlemUoW1xuICAncHJpdmFjeS1hY3RpdmUnLFxuICAnaWRlbnRpdHktdW5hdmFpbGFibGUnLFxuICAndW50cmFja2VkLXJlYWQnLFxuICAnY3VzdG9tLXNjb3BlJyxcbiAgJ2NoaWxkLXNvdXJjZS1vd25lcnNoaXAnLFxuICAncmVzdW1lZC1zb3VyY2Utb3duZXJzaGlwJyxcbiAgJ3Npbmstc291cmNlLXVuc3VwcG9ydGVkJyxcbiAgJ3NvdXJjZS1oaXN0b3J5LW5vdC1pbmNsdWRlZCcsXG4gICdzb3VyY2UtY2FwdHVyZS1mYWlsZWQnLFxuICAncmVkYWN0ZWQtc291cmNlLWV4cG9ydCcsXG5dIGFzIGNvbnN0KTtcbmV4cG9ydCB0eXBlIFNvdXJjZUxpbWl0YXRpb24gPSAodHlwZW9mIFNPVVJDRV9MSU1JVEFUSU9OUylbbnVtYmVyXTtcblxuLyoqIFBhY2tldCAzIGlzIGFuIGluLW1lbW9yeSBvYnNlcnZhdGlvbiwgbm90IGEgc3RvcmVkLWhpc3RvcnkgYWNrbm93bGVkZ2VtZW50LiAqL1xuZXhwb3J0IGludGVyZmFjZSBFbmdpbmVSZWFkU291cmNlcyB7XG4gIHJlYWRvbmx5IHZlcnNpb246IDE7XG4gIHJlYWRvbmx5IHJ1bklkOiBzdHJpbmc7XG4gIHJlYWRvbmx5IHBlcnNpc3RlbmNlOiAnbWVtb3J5LW9ubHknO1xuICByZWFkb25seSBjb21taXRzOiB7IHJlYWRvbmx5IGZyb206IG51bWJlcjsgcmVhZG9ubHkgdG86IG51bWJlciB9O1xuICByZWFkb25seSBzdGF0dXM6IENhcHR1cmVDaGFubmVsU3RhdHVzO1xuICByZWFkb25seSBsaW1pdGF0aW9uczogcmVhZG9ubHkgU291cmNlTGltaXRhdGlvbltdO1xuICAvKiogQWJzZW50IG1lYW5zIHVua25vd24gb3duZXJzaGlwLCBuZXZlciBhbiBvYnNlcnZlZC1lbXB0eSBib29rLiAqL1xuICByZWFkb25seSByZWNvcmQ/OiBSZWFkU291cmNlU25hcHNob3Q7XG59XG5cbi8qKiBBIG5ldyBkaXNjcmltaW5hbnQgcHJldmVudHMgc3RyaWN0IHYxIHJlYWRlcnMgZnJvbSBhY2NlcHRpbmcgbmV3IGNvbXBsZXRlbmVzcyBjbGFpbXMuICovXG5leHBvcnQgaW50ZXJmYWNlIE5hdGl2ZVJlYWRDYXB0dXJlTm90ZSBleHRlbmRzIE9taXQ8TmF0aXZlQ2FwdHVyZU5vdGUsICd2ZXJzaW9uJyB8ICdjaGFubmVscyc+IHtcbiAgcmVhZG9ubHkgdmVyc2lvbjogMjtcbiAgcmVhZG9ubHkgY2hhbm5lbHM6IE9taXQ8TmF0aXZlQ2FwdHVyZU5vdGVbJ2NoYW5uZWxzJ10sICdyZWFkU291cmNlcyc+ICYge1xuICAgIHJlYWRvbmx5IHJlYWRTb3VyY2VzOiBDYXB0dXJlQ2hhbm5lbFN0YXR1cztcbiAgfTtcbn1cbmV4cG9ydCB0eXBlIE5hdGl2ZUNhcHR1cmVPYnNlcnZhdGlvbiA9IE5hdGl2ZUNhcHR1cmVOb3RlIHwgTmF0aXZlUmVhZENhcHR1cmVOb3RlO1xuXG4vKiogT25lIG93bmVyIHBlciBydW50aW1lL2xlZzsgcHJvcGFnYXRlZCBvbmx5IHRvIGZyYW1lcyBpbiB0aGF0IGxvZy4gTmV2ZXIgcmVhZHMgdmFsdWVzIG9yIHNjYW5zIGNvbW1pdHMuICovXG5leHBvcnQgY2xhc3MgRW5naW5lUmVhZFNvdXJjZUNhcHR1cmUge1xuICBwcml2YXRlIHJlYWRvbmx5IGdhcHMgPSBuZXcgU2V0PFNvdXJjZUxpbWl0YXRpb24+KCk7XG4gIHByaXZhdGUgc2VhbGVkPzogRW5naW5lUmVhZFNvdXJjZXM7XG4gIGdldCBvYnNlcnZpbmcoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuYm9vayAhPT0gdW5kZWZpbmVkO1xuICB9XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcmVhZG9ubHkgcnVuSWQ6IHN0cmluZyxcbiAgICBwcml2YXRlIHJlYWRvbmx5IGJvb2s/OiBSZWFkU291cmNlUmVjb3JkLFxuICAgIGdhcD86IFNvdXJjZUxpbWl0YXRpb24sXG4gICAgcmVhZG9ubHkgZnJvbSA9IDAsXG4gICkge1xuICAgIGlmIChnYXApIHRoaXMuZ2Fwcy5hZGQoZ2FwKTtcbiAgfVxuXG4gIGxpbWl0KGdhcDogU291cmNlTGltaXRhdGlvbik6IHZvaWQge1xuICAgIGlmICghdGhpcy5zZWFsZWQpIHRoaXMuZ2Fwcy5hZGQoZ2FwKTtcbiAgfVxuXG4gIHJldGlyZSgpOiB2b2lkIHtcbiAgICB0aGlzLmJvb2s/LnJldGlyZSgpO1xuICB9XG5cbiAgc2VhbCh0bzogbnVtYmVyKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuc2VhbGVkKSByZXR1cm47XG4gICAgdGhpcy5zZWFsZWQgPSB0aGlzLnNuYXBzaG90KHRvKTtcbiAgICB0aGlzLnJldGlyZSgpO1xuICB9XG5cbiAgc25hcHNob3QodG86IG51bWJlciwgcmVkYWN0ID0gZmFsc2UpOiBFbmdpbmVSZWFkU291cmNlcyB7XG4gICAgaWYgKHRoaXMuc2VhbGVkICYmICFyZWRhY3QpIHJldHVybiB0aGlzLnNlYWxlZDtcbiAgICBjb25zdCBnYXBzID0gbmV3IFNldCh0aGlzLmdhcHMpO1xuICAgIGlmIChyZWRhY3QpIGdhcHMuYWRkKCdyZWRhY3RlZC1zb3VyY2UtZXhwb3J0Jyk7XG4gICAgY29uc3QgcmVjb3JkID0gcmVkYWN0ID8gdW5kZWZpbmVkIDogdGhpcy5ib29rPy5zbmFwc2hvdCgpO1xuICAgIGNvbnN0IHN0YXR1cyA9ICFyZWNvcmRcbiAgICAgID8gJ3Vua25vd24nXG4gICAgICA6IHJlY29yZC5zdGF0dXMgPT09ICdmYWlsZWQnXG4gICAgICA/ICdmYWlsZWQnXG4gICAgICA6IHJlY29yZC5zdGF0dXMgIT09ICdjYXB0dXJlZCcgfHwgZ2Fwcy5zaXplID4gMFxuICAgICAgPyAncGFydGlhbCdcbiAgICAgIDogJ2NhcHR1cmVkJztcbiAgICByZXR1cm4gT2JqZWN0LmZyZWV6ZSh7XG4gICAgICB2ZXJzaW9uOiAxLFxuICAgICAgcnVuSWQ6IHRoaXMucnVuSWQsXG4gICAgICBwZXJzaXN0ZW5jZTogJ21lbW9yeS1vbmx5JyxcbiAgICAgIGNvbW1pdHM6IE9iamVjdC5mcmVlemUoeyBmcm9tOiB0aGlzLmZyb20sIHRvIH0pLFxuICAgICAgc3RhdHVzLFxuICAgICAgbGltaXRhdGlvbnM6IE9iamVjdC5mcmVlemUoWy4uLmdhcHNdKSxcbiAgICAgIC4uLihyZWNvcmQgJiYgeyByZWNvcmQgfSksXG4gICAgfSk7XG4gIH1cbn1cblxuLyoqIEtlZXAgdGhlIHYxIHByb2R1Y2VyIHVuY2hhbmdlZC4gT25seSBleHBsaWNpdGx5IGVuYWJsZWQgc291cmNlIG9ic2VydmF0aW9ucyBhY3F1aXJlIHYyLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHdpdGhSZWFkU291cmNlcyhub3RlOiBOYXRpdmVDYXB0dXJlTm90ZSwgc291cmNlczogRW5naW5lUmVhZFNvdXJjZXMpOiBOYXRpdmVSZWFkQ2FwdHVyZU5vdGUge1xuICByZXR1cm4gT2JqZWN0LmZyZWV6ZSh7XG4gICAgLi4ubm90ZSxcbiAgICB2ZXJzaW9uOiAyLFxuICAgIGNoYW5uZWxzOiBPYmplY3QuZnJlZXplKHsgLi4ubm90ZS5jaGFubmVscywgcmVhZFNvdXJjZXM6IHNvdXJjZXMuc3RhdHVzIH0pLFxuICAgIGxpbWl0YXRpb25zOiBPYmplY3QuZnJlZXplKG5vdGUubGltaXRhdGlvbnMuZmlsdGVyKChnYXApID0+IGdhcCAhPT0gJ3JlYWQtc291cmNlcy1ub3QtY29sbGVjdGVkJykpLFxuICB9KTtcbn1cbiJdfQ==
+/** 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({
+        ...(source.version === 2
+            ? { version: 2, ownership: redactSourceOwnership(source.ownership) }
+            : { version: 1 }),
+        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';\nimport { redactSourceOwnership, SourceOwnershipCollector } from './sourceOwnership.js';\nimport type { SourceOwnershipWitness } from './sourceOwnershipFormat.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. */\ninterface EngineReadSourcesBase {\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/** Legacy observations remain readable; only v2 contains independently collected ownership. */\nexport type EngineReadSources = EngineReadSourcesBase &\n  (\n    | { readonly version: 1; readonly ownership?: never }\n    | { readonly version: 2; readonly ownership: SourceOwnershipWitness }\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  readonly ownership?: SourceOwnershipCollector;\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    if (book?.log.address) this.ownership = new SourceOwnershipCollector(runId, book.log.address, from);\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      ...(record && this.ownership\n        ? { version: 2 as const, ownership: this.ownership.snapshot(to, record.segment) }\n        : { version: 1 as const }),\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    ...(source.version === 2\n      ? { version: 2 as const, ownership: redactSourceOwnership(source.ownership) }\n      : { version: 1 as const }),\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/sourceOwnership.d.ts

@@ -0,0 +1,21 @@
+import type { LogAddress } from 'foottrace';
+import type { SourceOwnershipGap, SourceOwnershipWitness } from './sourceOwnershipFormat.js';
+/** Collect at the existing native funnels, independently of source rows and retained read values. */
+export declare class SourceOwnershipCollector {
+    private readonly runId;
+    private readonly logAddress;
+    private readonly from;
+    private readonly executions;
+    private readonly gaps;
+    private attempts;
+    private bytes;
+    constructor(runId: string, logAddress: LogAddress, from: number);
+    limit(gap: SourceOwnershipGap): void;
+    begin(runId: string, runtimeStageId: string, stateAddress: readonly string[]): void;
+    attempt(runtimeStageId: string, attempt: number): string | undefined;
+    commit(runtimeStageId: string, index: number): void;
+    checkSelectedAddress(runtimeStageId: string, selected: readonly string[]): void;
+    snapshot(to: number, segment: number): SourceOwnershipWitness;
+    private charge;
+}
+export declare function redactSourceOwnership(witness: SourceOwnershipWitness): SourceOwnershipWitness;

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

@@ -0,0 +1,133 @@
+import { buildAttemptId } from 'foottrace';
+import { isNativeSourceExecution, SOURCE_OWNERSHIP_GAPS, SOURCE_OWNERSHIP_V1_LIMITS } from './sourceOwnershipFormat.js';
+/** Collect at the existing native funnels, independently of source rows and retained read values. */
+export class SourceOwnershipCollector {
+    runId;
+    logAddress;
+    from;
+    executions = new Map();
+    gaps = new Set();
+    attempts = 0;
+    bytes = 0;
+    constructor(runId, logAddress, from) {
+        this.runId = runId;
+        this.logAddress = logAddress;
+        this.from = from;
+        // Reserve the largest header before entries. Native identifiers may need JSON escapes.
+        this.bytes = encodedBytes({
+            version: 1,
+            runId,
+            logAddress,
+            segment: Number.MAX_SAFE_INTEGER,
+            commits: { from, to: Number.MAX_SAFE_INTEGER },
+            status: 'captured',
+            limitations: SOURCE_OWNERSHIP_GAPS,
+            executions: [],
+        });
+        if (this.bytes > SOURCE_OWNERSHIP_V1_LIMITS.bytes)
+            this.limit('bytes-limit');
+    }
+    limit(gap) {
+        this.gaps.add(gap);
+    }
+    begin(runId, runtimeStageId, stateAddress) {
+        if (runId !== this.runId ||
+            runtimeStageId.length > SOURCE_OWNERSHIP_V1_LIMITS.name ||
+            !isNativeSourceExecution(runtimeStageId)) {
+            this.limit('identity-unavailable');
+            return;
+        }
+        if (this.executions.has(runtimeStageId)) {
+            this.limit('identity-unavailable');
+            return;
+        }
+        if (this.executions.size >= SOURCE_OWNERSHIP_V1_LIMITS.executions) {
+            this.limit('execution-limit');
+            return;
+        }
+        if (stateAddress.length > SOURCE_OWNERSHIP_V1_LIMITS.depth ||
+            stateAddress.some((part) => typeof part !== 'string' || part.length > SOURCE_OWNERSHIP_V1_LIMITS.name)) {
+            this.limit('identity-unavailable');
+            return;
+        }
+        if (!this.charge(encodedBytes({ runtimeStageId, stateAddress, firstCommit: Number.MAX_SAFE_INTEGER, attemptIds: [] }) + 1))
+            return;
+        this.executions.set(runtimeStageId, {
+            runtimeStageId,
+            stateAddress: Object.freeze([...stateAddress]),
+            attemptIds: [],
+        });
+    }
+    attempt(runtimeStageId, attempt) {
+        const owner = this.executions.get(runtimeStageId);
+        if (!owner || !Number.isSafeInteger(attempt) || attempt < 1 || attempt !== owner.attemptIds.length + 1) {
+            this.limit('attempt-unavailable');
+            return undefined;
+        }
+        if (this.attempts >= SOURCE_OWNERSHIP_V1_LIMITS.attempts) {
+            this.limit('attempt-limit');
+            return undefined;
+        }
+        const id = buildAttemptId(runtimeStageId, attempt);
+        if (id.length > SOURCE_OWNERSHIP_V1_LIMITS.name) {
+            this.limit('attempt-unavailable');
+            return undefined;
+        }
+        if (!this.charge(encodedBytes(id) + 1))
+            return undefined;
+        owner.attemptIds.push(id);
+        this.attempts++;
+        return id;
+    }
+    commit(runtimeStageId, index) {
+        const owner = this.executions.get(runtimeStageId);
+        if (!owner || !Number.isSafeInteger(index) || index < this.from) {
+            this.limit('commit-unavailable');
+            return;
+        }
+        owner.firstCommit ??= index;
+    }
+    checkSelectedAddress(runtimeStageId, selected) {
+        const address = this.executions.get(runtimeStageId)?.stateAddress;
+        // A native fallback is real evidence, but it cannot authorize its own address.
+        if (address && (address.length !== selected.length || address.some((part, index) => part !== selected[index])))
+            this.limit('source-address-unproven');
+    }
+    snapshot(to, segment) {
+        return Object.freeze({
+            version: 1,
+            runId: this.runId,
+            logAddress: this.logAddress,
+            segment,
+            commits: Object.freeze({ from: this.from, to }),
+            status: this.gaps.size ? 'unknown' : 'captured',
+            limitations: Object.freeze([...this.gaps]),
+            executions: Object.freeze([...this.executions.values()].map((owner) => Object.freeze({
+                runtimeStageId: owner.runtimeStageId,
+                stateAddress: owner.stateAddress,
+                ...(owner.firstCommit !== undefined && { firstCommit: owner.firstCommit }),
+                attemptIds: Object.freeze([...owner.attemptIds]),
+            }))),
+        });
+    }
+    charge(bytes) {
+        if (bytes > SOURCE_OWNERSHIP_V1_LIMITS.bytes - this.bytes) {
+            this.limit('bytes-limit');
+            return false;
+        }
+        this.bytes += bytes;
+        return true;
+    }
+}
+function encodedBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+export function redactSourceOwnership(witness) {
+    return Object.freeze({
+        ...witness,
+        status: 'unknown',
+        executions: Object.freeze([]),
+        limitations: Object.freeze(['redacted-export']),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sourceOwnership.js","sourceRoot":"","sources":["../../../../src/lib/capture/sourceOwnership.ts"],"names":[],"mappings":"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","sourcesContent":["import type { LogAddress } from 'foottrace';\nimport { buildAttemptId } from 'foottrace';\n\nimport type { SourceOwnershipGap, SourceOwnershipWitness } from './sourceOwnershipFormat.js';\nimport { isNativeSourceExecution, SOURCE_OWNERSHIP_GAPS, SOURCE_OWNERSHIP_V1_LIMITS } from './sourceOwnershipFormat.js';\n\ntype MutableOwner = {\n  runtimeStageId: string;\n  stateAddress: readonly string[];\n  firstCommit?: number;\n  attemptIds: string[];\n};\n\n/** Collect at the existing native funnels, independently of source rows and retained read values. */\nexport class SourceOwnershipCollector {\n  private readonly executions = new Map<string, MutableOwner>();\n  private readonly gaps = new Set<SourceOwnershipGap>();\n  private attempts = 0;\n  private bytes = 0;\n\n  constructor(private readonly runId: string, private readonly logAddress: LogAddress, private readonly from: number) {\n    // Reserve the largest header before entries. Native identifiers may need JSON escapes.\n    this.bytes = encodedBytes({\n      version: 1,\n      runId,\n      logAddress,\n      segment: Number.MAX_SAFE_INTEGER,\n      commits: { from, to: Number.MAX_SAFE_INTEGER },\n      status: 'captured',\n      limitations: SOURCE_OWNERSHIP_GAPS,\n      executions: [],\n    });\n    if (this.bytes > SOURCE_OWNERSHIP_V1_LIMITS.bytes) this.limit('bytes-limit');\n  }\n\n  limit(gap: SourceOwnershipGap): void {\n    this.gaps.add(gap);\n  }\n\n  begin(runId: string, runtimeStageId: string, stateAddress: readonly string[]): void {\n    if (\n      runId !== this.runId ||\n      runtimeStageId.length > SOURCE_OWNERSHIP_V1_LIMITS.name ||\n      !isNativeSourceExecution(runtimeStageId)\n    ) {\n      this.limit('identity-unavailable');\n      return;\n    }\n    if (this.executions.has(runtimeStageId)) {\n      this.limit('identity-unavailable');\n      return;\n    }\n    if (this.executions.size >= SOURCE_OWNERSHIP_V1_LIMITS.executions) {\n      this.limit('execution-limit');\n      return;\n    }\n    if (\n      stateAddress.length > SOURCE_OWNERSHIP_V1_LIMITS.depth ||\n      stateAddress.some((part) => typeof part !== 'string' || part.length > SOURCE_OWNERSHIP_V1_LIMITS.name)\n    ) {\n      this.limit('identity-unavailable');\n      return;\n    }\n    if (\n      !this.charge(\n        encodedBytes({ runtimeStageId, stateAddress, firstCommit: Number.MAX_SAFE_INTEGER, attemptIds: [] }) + 1,\n      )\n    )\n      return;\n    this.executions.set(runtimeStageId, {\n      runtimeStageId,\n      stateAddress: Object.freeze([...stateAddress]),\n      attemptIds: [],\n    });\n  }\n\n  attempt(runtimeStageId: string, attempt: number): string | undefined {\n    const owner = this.executions.get(runtimeStageId);\n    if (!owner || !Number.isSafeInteger(attempt) || attempt < 1 || attempt !== owner.attemptIds.length + 1) {\n      this.limit('attempt-unavailable');\n      return undefined;\n    }\n    if (this.attempts >= SOURCE_OWNERSHIP_V1_LIMITS.attempts) {\n      this.limit('attempt-limit');\n      return undefined;\n    }\n    const id = buildAttemptId(runtimeStageId, attempt);\n    if (id.length > SOURCE_OWNERSHIP_V1_LIMITS.name) {\n      this.limit('attempt-unavailable');\n      return undefined;\n    }\n    if (!this.charge(encodedBytes(id) + 1)) return undefined;\n    owner.attemptIds.push(id);\n    this.attempts++;\n    return id;\n  }\n\n  commit(runtimeStageId: string, index: number): void {\n    const owner = this.executions.get(runtimeStageId);\n    if (!owner || !Number.isSafeInteger(index) || index < this.from) {\n      this.limit('commit-unavailable');\n      return;\n    }\n    owner.firstCommit ??= index;\n  }\n\n  checkSelectedAddress(runtimeStageId: string, selected: readonly string[]): void {\n    const address = this.executions.get(runtimeStageId)?.stateAddress;\n    // A native fallback is real evidence, but it cannot authorize its own address.\n    if (address && (address.length !== selected.length || address.some((part, index) => part !== selected[index])))\n      this.limit('source-address-unproven');\n  }\n\n  snapshot(to: number, segment: number): SourceOwnershipWitness {\n    return Object.freeze({\n      version: 1,\n      runId: this.runId,\n      logAddress: this.logAddress,\n      segment,\n      commits: Object.freeze({ from: this.from, to }),\n      status: this.gaps.size ? 'unknown' : 'captured',\n      limitations: Object.freeze([...this.gaps]),\n      executions: Object.freeze(\n        [...this.executions.values()].map((owner) =>\n          Object.freeze({\n            runtimeStageId: owner.runtimeStageId,\n            stateAddress: owner.stateAddress,\n            ...(owner.firstCommit !== undefined && { firstCommit: owner.firstCommit }),\n            attemptIds: Object.freeze([...owner.attemptIds]),\n          }),\n        ),\n      ),\n    });\n  }\n\n  private charge(bytes: number): boolean {\n    if (bytes > SOURCE_OWNERSHIP_V1_LIMITS.bytes - this.bytes) {\n      this.limit('bytes-limit');\n      return false;\n    }\n    this.bytes += bytes;\n    return true;\n  }\n}\n\nfunction encodedBytes(value: unknown): number {\n  return new TextEncoder().encode(JSON.stringify(value)).length;\n}\n\nexport function redactSourceOwnership(witness: SourceOwnershipWitness): SourceOwnershipWitness {\n  return Object.freeze({\n    ...witness,\n    status: 'unknown',\n    executions: Object.freeze([]),\n    limitations: Object.freeze(['redacted-export' as const]),\n  });\n}\n"]}

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

@@ -0,0 +1,35 @@
+import type { LogAddress } from 'foottrace';
+/** Immutable format-v1 ceilings, not writer tuning. Changing these requires another wire version. */
+export declare const SOURCE_OWNERSHIP_V1_LIMITS: Readonly<{
+    executions: 4096;
+    attempts: 16384;
+    bytes: 524288;
+    depth: 64;
+    name: 2048;
+}>;
+export declare const SOURCE_OWNERSHIP_GAPS: readonly ["identity-unavailable", "namespace-changed", "execution-limit", "attempt-limit", "bytes-limit", "attempt-unavailable", "commit-unavailable", "source-address-unproven", "redacted-export"];
+export type SourceOwnershipGap = (typeof SOURCE_OWNERSHIP_GAPS)[number];
+/** Native execution identity and actual stage-function invocations. No values, timings or outcomes. */
+export interface SourceExecutionOwnership {
+    readonly runtimeStageId: string;
+    readonly stateAddress: readonly string[];
+    /** First real commit of this execution; absent while it has not committed. */
+    readonly firstCommit?: number;
+    readonly attemptIds: readonly string[];
+}
+/** One native source-book segment. A storage receipt does not authenticate this observation. */
+export interface SourceOwnershipWitness {
+    readonly version: 1;
+    readonly runId: string;
+    readonly logAddress: LogAddress;
+    readonly segment: number;
+    readonly commits: {
+        readonly from: number;
+        readonly to: number;
+    };
+    readonly status: 'captured' | 'unknown';
+    readonly limitations: readonly SourceOwnershipGap[];
+    readonly executions: readonly SourceExecutionOwnership[];
+}
+/** Compose the public codec; its permissive legacy parse alone does not prove a native execution. */
+export declare function isNativeSourceExecution(id: string): boolean;

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

@@ -0,0 +1,31 @@
+import { buildRuntimeStageId, isExecutionKey, parseRuntimeStageId } from 'foottrace';
+/** Immutable format-v1 ceilings, not writer tuning. Changing these requires another wire version. */
+export const SOURCE_OWNERSHIP_V1_LIMITS = Object.freeze({
+    executions: 4096,
+    attempts: 16384,
+    bytes: 524288,
+    depth: 64,
+    name: 2048,
+});
+export const SOURCE_OWNERSHIP_GAPS = Object.freeze([
+    'identity-unavailable',
+    'namespace-changed',
+    'execution-limit',
+    'attempt-limit',
+    'bytes-limit',
+    'attempt-unavailable',
+    'commit-unavailable',
+    'source-address-unproven',
+    'redacted-export',
+]);
+/** Compose the public codec; its permissive legacy parse alone does not prove a native execution. */
+export function isNativeSourceExecution(id) {
+    if (!isExecutionKey(id))
+        return false;
+    const parsed = parseRuntimeStageId(id);
+    return (!!parsed.stageId &&
+        Number.isSafeInteger(parsed.executionIndex) &&
+        parsed.executionIndex >= 0 &&
+        buildRuntimeStageId(parsed.stageId, parsed.executionIndex, parsed.subflowPath) === id);
+}
+//# sourceMappingURL=data:application/json;base64,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

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,7 @@
+import type { ReadSourceSnapshot } from 'foottrace/write';
+import type { SourceReadCounts } from './sourceReadCounts.js';
+export type StoredSourceCounts = SourceReadCounts & {
+    readonly invocations?: number;
+};
+/** Already inert, byte-bounded evidence. Check native counts; never reconstruct read occurrences. */
+export declare function storedReadSourceCounts(record: ReadSourceSnapshot, executionTree: unknown, committedOwners: ReadonlyMap<string, number>): ReadonlyMap<string, StoredSourceCounts> | undefined;

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

@@ -0,0 +1,82 @@
+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 undefined;
+        const value = pending.pop();
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return undefined;
+        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 undefined;
+            if (typeof id !== 'string' || !id) {
+                if (counts.observed || counts.retained)
+                    return undefined;
+            }
+            else {
+                if (owners.has(id))
+                    return undefined;
+                const invocations = node.readSourceInvocations;
+                if (Object.hasOwn(node, 'readSourceInvocations') &&
+                    (!Number.isSafeInteger(invocations) || invocations < 0))
+                    return undefined;
+                owners.set(id, { ...counts, ...(invocations !== undefined && { invocations: invocations }) });
+            }
+        }
+        else if (typeof id === 'string' && committedOwners.has(id))
+            return undefined;
+        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 undefined;
+            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 undefined;
+        counts[row.source.kind]--;
+    }
+    return [...remaining.values()].every((counts) => KINDS.every((kind) => counts[kind] === 0)) ? owners : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storedReadSourceCounts.js","sourceRoot":"","sources":["../../../../src/lib/capture/storedReadSourceCounts.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAwC,CAAC;AAGjG,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAClF,MAAM,MAAM,GAAG,KAAyB,CAAC;IACzC,IACE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC;QAC/B,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC;QACtC,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC;QACtC,MAAM,CAAC,QAAQ,GAAG,CAAC;QACnB,MAAM,CAAC,QAAQ,GAAG,CAAC;QACnB,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ;QAEjC,OAAO,SAAS,CAAC;IACnB,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACvG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IACxE,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QAChE,GAAG,IAAI,KAAK,CAAC;QACb,IAAI,GAAG,GAAG,MAAM,CAAC,QAAQ;YAAE,OAAO,SAAS,CAAC;IAC9C,CAAC;IACD,IAAI,GAAG,KAAK,MAAM,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAC;IAC9C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,qGAAqG;AACrG,MAAM,UAAU,sBAAsB,CACpC,MAA0B,EAC1B,aAAsB,EACtB,eAA4C;IAE5C,MAAM,MAAM,GAAG,IAAI,GAAG,EAA8B,CAAC;IACrD,MAAM,OAAO,GAAG,CAAC,aAAa,CAAC,CAAC;IAChC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC;QACtB,IAAI,EAAE,OAAO,GAAG,OAAO;YAAE,OAAO,SAAS,CAAC;QAC1C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAClF,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC;QAC/B,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,EAAE,CAAC;YAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YAC/C,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,IAAI,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,QAAQ,CAAC;gBAAE,OAAO,SAAS,CAAC;YACvG,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,EAAE,EAAE,CAAC;gBAClC,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ;oBAAE,OAAO,SAAS,CAAC;YAC3D,CAAC;iBAAM,CAAC;gBACN,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;oBAAE,OAAO,SAAS,CAAC;gBACrC,MAAM,WAAW,GAAG,IAAI,CAAC,qBAAqB,CAAC;gBAC/C,IACE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,uBAAuB,CAAC;oBAC5C,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,IAAK,WAAsB,GAAG,CAAC,CAAC;oBAEnE,OAAO,SAAS,CAAC;gBACnB,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,WAAW,KAAK,SAAS,IAAI,EAAE,WAAW,EAAE,WAAqB,EAAE,CAAC,EAAE,CAAC,CAAC;YAC1G,CAAC;QACH,CAAC;aAAM,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO,SAAS,CAAC;QAC/E,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC;YACpC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC,MAAM;gBAAE,OAAO,SAAS,CAAC;YACjH,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ;gBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IACxF,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;QACrC,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC/D,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAC5B,CAAC;IACD,OAAO,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACnH,CAAC","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'])[];\nexport type StoredSourceCounts = SourceReadCounts & { readonly invocations?: number };\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): ReadonlyMap<string, StoredSourceCounts> | undefined {\n  const owners = new Map<string, StoredSourceCounts>();\n  const pending = [executionTree];\n  let visited = 0;\n  while (pending.length) {\n    if (++visited > 100_000) return undefined;\n    const value = pending.pop();\n    if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;\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 undefined;\n      if (typeof id !== 'string' || !id) {\n        if (counts.observed || counts.retained) return undefined;\n      } else {\n        if (owners.has(id)) return undefined;\n        const invocations = node.readSourceInvocations;\n        if (\n          Object.hasOwn(node, 'readSourceInvocations') &&\n          (!Number.isSafeInteger(invocations) || (invocations as number) < 0)\n        )\n          return undefined;\n        owners.set(id, { ...counts, ...(invocations !== undefined && { invocations: invocations as number }) });\n      }\n    } else if (typeof id === 'string' && committedOwners.has(id)) return undefined;\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 undefined;\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 undefined;\n    counts[row.source.kind]--;\n  }\n  return [...remaining.values()].every((counts) => KINDS.every((kind) => counts[kind] === 0)) ? owners : undefined;\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;