foottrace 1.0.3 → 1.2.0

package/dist/lib/cause/recordParents.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectRecordNode = void 0;
+const backtrack_js_1 = require("../memory/backtrack.js");
+const commitLogUtils_js_1 = require("../memory/commitLogUtils.js");
+const sliceForKey_js_1 = require("../slice/sliceForKey.js");
+const recordControl_js_1 = require("./recordControl.js");
+const recordCoverage_js_1 = require("./recordCoverage.js");
+const recordIdentity_js_1 = require("./recordIdentity.js");
+const recordScope_js_1 = require("./recordScope.js");
+/** Anchor writers before the execution so later commits cannot rewrite the recorded causal edge. */
+function projectParentEdges(scope, parentEdges, firstCommitIndex, precise, maximumEdges, addGap) {
+    const edges = [];
+    for (const edge of parentEdges) {
+        if (edges.length >= maximumEdges) {
+            addGap('edge-limit');
+            break;
+        }
+        const writer = edge.kind === 'data' && edge.key
+            ? (0, commitLogUtils_js_1.findLastWriter)(scope.log, edge.key, firstCommitIndex)
+            : scope.log.find((bundle) => bundle.runtimeStageId === edge.parent.runtimeStageId);
+        if (!writer) {
+            addGap('untracked-input');
+            continue;
+        }
+        const writerIndex = scope.log.indexOf(writer);
+        edges.push({
+            nodeId: (0, recordIdentity_js_1.nodeIdFor)(scope.address, {
+                runtimeStageId: writer.runtimeStageId,
+                commitIdx: writerIndex,
+                ...(edge.kind === 'data' && edge.key ? { key: edge.key } : {}),
+            }),
+            kind: edge.kind,
+            attribution: edge.kind === 'control' ? 'recorded-control' : precise ? 'per-write' : 'stage',
+            evidence: ['commit:' + writerIndex],
+        });
+        if (edge.basis)
+            addGap('conservative');
+    }
+    return edges;
+}
+/** Derive parent adjacency and its ordered gaps together from the same bounded canonical query. */
+function inspectRecordNode(node, maximumEdges, extraGapCodes) {
+    const { scope, identity, commitIndex } = node;
+    const bundle = scope.log[commitIndex], firstCommitIndex = scope.log.findIndex((entry) => entry.runtimeStageId === identity.runtimeStageId), coverage = (0, recordCoverage_js_1.recordGapCollector)();
+    (0, recordCoverage_js_1.collectScopeCoverage)(scope, bundle, extraGapCodes, coverage.addGap);
+    const lookup = (runtimeStageId) => (0, recordScope_js_1.readKeysForStage)(scope, runtimeStageId);
+    (0, recordCoverage_js_1.collectForwardCoverage)(scope, identity, commitIndex, firstCommitIndex, maximumEdges, coverage.addGap);
+    const precise = (0, recordCoverage_js_1.readAttributionIsPrecise)(scope, identity, bundle);
+    (0, recordCoverage_js_1.collectReadCoverage)(scope, identity, precise, coverage.addGap);
+    (0, recordControl_js_1.collectControlParentCoverage)(scope, identity, firstCommitIndex, coverage.addGap);
+    const control = (0, recordControl_js_1.controlParentLookup)(scope);
+    const slice = identity.key === undefined || identity.read
+        ? undefined
+        : (0, sliceForKey_js_1.sliceForKey)(scope.log, identity.key, lookup, {
+            before: commitIndex + 1,
+            maxDepth: 1,
+            maxNodes: maximumEdges + 1,
+            controlDeps: control,
+        });
+    if (identity.key !== undefined &&
+        !identity.read &&
+        (!slice?.writer || scope.log.indexOf(slice.writer) !== commitIndex)) {
+        coverage.addGap('invalid-data');
+        return { adjacency: { edges: [], complete: false }, gaps: coverage.gaps };
+    }
+    // Read-only identities retain both the read's data writer and the execution's recorded control parent.
+    const root = identity.read && identity.key !== undefined
+        ? (0, backtrack_js_1.causalChain)(scope.log, identity.runtimeStageId, (runtimeStageId) => (runtimeStageId === identity.runtimeStageId ? [identity.key] : lookup(runtimeStageId)), { maxDepth: 1, maxNodes: maximumEdges + 1, controlDeps: control })
+        : slice?.root ??
+            (identity.key === undefined
+                ? (0, backtrack_js_1.causalChain)(scope.log, identity.runtimeStageId, lookup, {
+                    maxDepth: 1,
+                    maxNodes: maximumEdges + 1,
+                    controlDeps: control,
+                })
+                : undefined);
+    if (root?.preRunReads?.keys.length)
+        coverage.addGap('untracked-input');
+    if (root?.truncated?.byNodes)
+        coverage.addGap('edge-limit');
+    for (const note of slice?.notes ?? [])
+        if (note.code === 'redacted')
+            coverage.addGap('redacted');
+        else if (note.code === 'nested-rows' || note.code === 'from-initial-state')
+            coverage.addGap('conservative');
+    const edges = projectParentEdges(scope, root?.parentEdges ?? [], firstCommitIndex, precise, maximumEdges, coverage.addGap);
+    return { adjacency: { edges, complete: coverage.gaps.length === 0 }, gaps: coverage.gaps };
+}
+exports.inspectRecordNode = inspectRecordNode;

package/dist/lib/cause/recordScope.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readKeysForStage = exports.prepareRecordScope = exports.recordOptions = void 0;
+const recordValidation_js_1 = require("./recordValidation.js");
+/** Refuse an invalid limit before loading a scope or allocating its preparation budget. */
+function boundedOption(value, defaultValue, maximum) {
+    const configuredValue = value ?? defaultValue;
+    if (typeof configuredValue !== 'number' ||
+        !Number.isSafeInteger(configuredValue) ||
+        configuredValue < 1 ||
+        configuredValue > maximum)
+        throw new TypeError('cause: invalid record configuration');
+    return configuredValue;
+}
+/** Read configuration as data so option accessors cannot execute during adapter construction. */
+function recordOptions(options) {
+    try {
+        const prototype = Object.getPrototypeOf(options);
+        if (prototype !== Object.prototype && prototype !== null)
+            throw new TypeError();
+        return Object.freeze({
+            maxCommits: boundedOption((0, recordValidation_js_1.own)(options, 'maxCommits'), 256, 4096),
+            maxFields: boundedOption((0, recordValidation_js_1.own)(options, 'maxFields'), 20000, 1000000),
+            maxEdges: boundedOption((0, recordValidation_js_1.own)(options, 'maxEdges'), 64, 256),
+            maxScopes: boundedOption((0, recordValidation_js_1.own)(options, 'maxScopes'), 32, 256),
+            loadTimeoutMs: boundedOption((0, recordValidation_js_1.own)(options, 'loadTimeoutMs'), 1000, 30000),
+        });
+    }
+    catch {
+        throw new TypeError('cause: invalid record configuration');
+    }
+}
+exports.recordOptions = recordOptions;
+/** Spend one shared field budget before canonical readers see any untrusted scope data. */
+function prepareRecordScope(value, address, maximumCommits, maximumFields) {
+    if ((0, recordValidation_js_1.addressKey)((0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.own)(value, 'address'))) !== (0, recordValidation_js_1.addressKey)(address))
+        throw new recordValidation_js_1.RecordRefusal();
+    const rawLog = (0, recordValidation_js_1.list)((0, recordValidation_js_1.own)(value, 'commitLog'), maximumCommits), budget = { left: maximumFields };
+    const log = rawLog.map((_, commitIndex) => (0, recordValidation_js_1.bundleOf)((0, recordValidation_js_1.own)(rawLog, String(commitIndex)), commitIndex, budget));
+    const reads = (0, recordValidation_js_1.mapOf)((0, recordValidation_js_1.own)(value, 'reads'), maximumCommits, (value) => {
+        const readKeys = (0, recordValidation_js_1.names)(value, 128, true);
+        (0, recordValidation_js_1.spend)(budget, readKeys.length);
+        return readKeys;
+    }, budget);
+    const control = (0, recordValidation_js_1.mapOf)((0, recordValidation_js_1.own)(value, 'controlDeps'), maximumCommits, (value) => ({ deciderId: (0, recordValidation_js_1.name)((0, recordValidation_js_1.own)(value, 'deciderId')) }), budget);
+    const marks = (0, recordValidation_js_1.mapOf)((0, recordValidation_js_1.own)(value, 'attention'), maximumCommits, (value) => {
+        const attention = (0, recordValidation_js_1.marksOf)(value);
+        (0, recordValidation_js_1.spend)(budget, attention.length + attention.reduce((count, mark) => count + mark.evidence.length, 0));
+        return attention;
+    }, budget);
+    return { address, log, reads, control, marks, complete: (0, recordValidation_js_1.own)(value, 'complete') === true };
+}
+exports.prepareRecordScope = prepareRecordScope;
+/** Preserve both stage reads and stronger per-write prefixes, including their original encounter order. */
+function readKeysForStage(scope, runtimeStageId) {
+    // Captured per-write prefixes remain evidence even when a supplied stage-read map omits them.
+    return [
+        ...new Set([
+            ...(scope.reads?.get(runtimeStageId) ?? []),
+            ...scope.log
+                .filter((bundle) => bundle.runtimeStageId === runtimeStageId)
+                .flatMap((bundle) => bundle.trace.flatMap((entry) => entry.readKeys ?? [])),
+        ]),
+    ];
+}
+exports.readKeysForStage = readKeysForStage;

package/dist/lib/cause/recordTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/cause/recordValidation.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectLoaded = exports.mapOf = exports.bundleOf = exports.dataCopy = exports.addressKey = exports.spend = exports.addressOf = exports.list = exports.name = exports.names = exports.own = exports.RecordRefusal = exports.marksOf = void 0;
+const validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "marksOf", { enumerable: true, get: function () { return validation_js_1.attention; } });
+const admission_js_1 = require("./admission.js");
+/** Loader refusals stay distinct from graph-port refusals so a failed host load keeps its original classification. */
+class RecordRefusal extends admission_js_1.EvidenceRefusal {
+    code;
+    constructor(code = 'invalid-data') {
+        super(code, 'cause: record unavailable');
+        this.code = code;
+    }
+}
+exports.RecordRefusal = RecordRefusal;
+const refuseRecord = (code) => new RecordRefusal(code);
+const recordDescriptors = { translateTrapErrors: true, requireOwnValue: true };
+function own(value, key) {
+    return (0, admission_js_1.ownData)(value, key, refuseRecord, recordDescriptors);
+}
+exports.own = own;
+function names(value, maximum = 128, path = false) {
+    return list(value, maximum).map((item) => name(item, path));
+}
+exports.names = names;
+function name(value, path = false) {
+    return (0, admission_js_1.boundedName)(value, 1024, refuseRecord, path);
+}
+exports.name = name;
+function list(value, maximum) {
+    return (0, admission_js_1.boundedList)(value, maximum, (item) => item, {
+        refuse: refuseRecord,
+        overflow: 'node-limit',
+        freeze: false,
+        descriptors: recordDescriptors,
+    });
+}
+exports.list = list;
+function addressOf(value) {
+    const logRunId = name(own(value, 'logRunId')), drillPath = names(own(value, 'drillPath'), 16);
+    if (logRunId.length + drillPath.reduce((n, s) => n + s.length, 0) > 1536)
+        throw new RecordRefusal();
+    return Object.freeze({ logRunId, drillPath: Object.freeze(drillPath) });
+}
+exports.addressOf = addressOf;
+function spend(budget, count) {
+    (0, admission_js_1.spendFields)(budget, count, refuseRecord);
+}
+exports.spend = spend;
+const addressKey = (a) => JSON.stringify([a.logRunId, ...a.drillPath]);
+exports.addressKey = addressKey;
+/** Iterative bounded copy: data descriptors only, no getters/toJSON/prototypes or opaque class instances. */
+function dataCopy(value, budget) {
+    const leaf = (v) => v === null || typeof v !== 'object';
+    const check = (v) => {
+        spend(budget, 1);
+        if (typeof v === 'function' || typeof v === 'symbol' || (typeof v === 'string' && v.length > 65536))
+            throw new RecordRefusal();
+    };
+    check(value);
+    if (leaf(value))
+        return value;
+    const make = (v) => {
+        let p;
+        try {
+            p = Object.getPrototypeOf(v);
+        }
+        catch {
+            throw new RecordRefusal();
+        }
+        if (!Array.isArray(v) && p !== Object.prototype && p !== null)
+            throw new RecordRefusal();
+        if (Array.isArray(v)) {
+            const length = own(v, 'length');
+            if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+                throw new RecordRefusal();
+            spend(budget, length);
+            const array = [];
+            array.length = length;
+            return array;
+        }
+        return Object.create(null);
+    };
+    const root = make(value), seen = new Set([value]), work = [{ from: value, to: root }];
+    while (work.length) {
+        const { from, to } = work.pop();
+        let keys;
+        try {
+            keys = Object.keys(from);
+        }
+        catch {
+            throw new RecordRefusal();
+        }
+        if (keys.length > budget.left)
+            throw new RecordRefusal('node-limit');
+        for (const key of keys) {
+            if (key.length > 1024)
+                throw new RecordRefusal('node-limit');
+            const v = own(from, key);
+            check(v);
+            let copy = v;
+            if (!leaf(v)) {
+                if (seen.has(v))
+                    throw new RecordRefusal();
+                seen.add(v);
+                copy = make(v);
+                work.push({ from: v, to: copy });
+            }
+            Object.defineProperty(to, key, { value: copy, enumerable: true, writable: true, configurable: true });
+        }
+    }
+    return root;
+}
+exports.dataCopy = dataCopy;
+function bundleOf(value, idx, budget) {
+    const runtimeStageId = name(own(value, 'runtimeStageId')), stageId = name(own(value, 'stageId'));
+    const trace = list(own(value, 'trace'), 128).map((_, i) => {
+        const t = own(own(value, 'trace'), String(i)), path = name(own(t, 'path'), true), verb = own(t, 'verb');
+        if (!['set', 'merge', 'append', 'delete'].includes(verb))
+            throw new RecordRefusal();
+        const readKeys = own(t, 'readKeys');
+        return { path, verb: verb, ...(readKeys === undefined ? {} : { readKeys: names(readKeys, 128, true) }) };
+    });
+    spend(budget, trace.length + trace.reduce((n, t) => n + (t.readKeys?.length ?? 0), 0) + 1);
+    const overwrite = dataCopy(own(value, 'overwrite'), budget), updates = dataCopy(own(value, 'updates'), budget);
+    if (!overwrite ||
+        typeof overwrite !== 'object' ||
+        Array.isArray(overwrite) ||
+        !updates ||
+        typeof updates !== 'object' ||
+        Array.isArray(updates))
+        throw new RecordRefusal();
+    const redactedPaths = names(own(value, 'redactedPaths') ?? [], 128, true);
+    const untracked = own(value, 'untrackedSources'), phase = own(value, 'phase');
+    spend(budget, redactedPaths.length + (untracked === undefined ? 0 : list(untracked, 128).length));
+    return {
+        idx,
+        stage: stageId,
+        stageId,
+        runtimeStageId,
+        trace,
+        overwrite,
+        updates,
+        redactedPaths,
+        ...(untracked === undefined
+            ? {}
+            : {
+                untrackedSources: names(untracked).map((s) => {
+                    if (!['args', 'env', 'silent'].includes(s))
+                        throw new RecordRefusal();
+                    return s;
+                }),
+            }),
+        ...(phase === undefined
+            ? {}
+            : {
+                phase: (() => {
+                    if (phase !== 'exit' && phase !== 'repeat')
+                        throw new RecordRefusal();
+                    return phase;
+                })(),
+            }),
+    };
+}
+exports.bundleOf = bundleOf;
+function mapOf(value, limit, read, budget) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new RecordRefusal();
+    let keys;
+    try {
+        keys = Object.keys(value);
+    }
+    catch {
+        throw new RecordRefusal();
+    }
+    if (keys.length > limit)
+        throw new RecordRefusal('node-limit');
+    if (budget)
+        spend(budget, keys.length);
+    return new Map(keys.map((k) => [name(k), read(own(value, k))]));
+}
+exports.mapOf = mapOf;
+/** Observe native promises by intrinsic without assimilating a data object's then accessor. */
+function projectLoaded(work, project) {
+    return new Promise((resolve, reject) => {
+        const accept = (value) => {
+            try {
+                resolve(project(value));
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        let returned;
+        try {
+            returned = work();
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        try {
+            if (!(0, validation_js_1.observePromise)(returned, (value) => accept(value), reject))
+                accept(returned);
+        }
+        catch (error) {
+            reject(error instanceof validation_js_1.AdmissionError ? new RecordRefusal(error.code) : error);
+        }
+    });
+}
+exports.projectLoaded = projectLoaded;

package/dist/lib/cause/session.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const validation_js_1 = require("./validation.js");
+const defaults = { maxNodes: 100, maxDepth: 20, maxEdges: 1000, maxCalls: 1000, timeoutMs: 1000 };
+const ceilings = { maxNodes: 10000, maxDepth: 1000, maxEdges: 100000, maxCalls: 100000, timeoutMs: 30000 };
+/** One deadline, memo table and work budget per public query, never per graph or store. */
+class Session {
+    limits;
+    context;
+    nodes = new Set();
+    controller = new AbortController();
+    cache = new Map();
+    calls = 0;
+    edges = 0;
+    timedOut = false;
+    deadline;
+    timer;
+    external;
+    onAbort = () => this.controller.abort();
+    methods = {};
+    constructor(graph, options = {}) {
+        try {
+            (0, validation_js_1.plain)(options);
+            const limits = { ...defaults };
+            for (const key of Object.keys(defaults)) {
+                const value = (0, validation_js_1.own)(options, key);
+                if (value !== undefined) {
+                    if (typeof value !== 'number' ||
+                        !Number.isSafeInteger(value) ||
+                        value < (key === 'maxDepth' ? 0 : 1) ||
+                        value > ceilings[key])
+                        throw new TypeError();
+                    limits[key] = value;
+                }
+            }
+            this.limits = Object.freeze(limits);
+            const rank = (0, validation_js_1.own)(options, 'rankRoots');
+            if (rank !== undefined && typeof rank !== 'function')
+                throw new TypeError();
+            const impactRank = (0, validation_js_1.own)(options, 'rankImpact');
+            if (impactRank !== undefined && typeof impactRank !== 'function')
+                throw new TypeError();
+            const signal = (0, validation_js_1.own)(options, 'signal');
+            if (signal !== undefined && !(signal instanceof AbortSignal))
+                throw new TypeError();
+            this.external = signal;
+            for (const key of ['parents', 'children', 'attention', 'gaps', 'roots']) {
+                let cursor = graph, method;
+                for (let depth = 0; cursor && cursor !== Object.prototype && depth < 8; depth++, cursor = Object.getPrototypeOf(cursor)) {
+                    const field = Object.getOwnPropertyDescriptor(cursor, key);
+                    if (field) {
+                        if (!('value' in field))
+                            throw new TypeError();
+                        method = field.value;
+                        break;
+                    }
+                }
+                if (typeof method !== 'function' && key !== 'roots')
+                    throw new TypeError();
+                if (typeof method === 'function')
+                    this.methods[key] = method.bind(graph);
+            }
+        }
+        catch {
+            throw new TypeError('CAUSE_CONFIGURATION_INVALID');
+        }
+        this.context = Object.freeze({ signal: this.controller.signal });
+        this.deadline = performance.now() + this.limits.timeoutMs;
+        this.external?.addEventListener('abort', this.onAbort, { once: true });
+        if (this.external?.aborted)
+            this.onAbort();
+        this.timer = setTimeout(() => {
+            this.timedOut = true;
+            this.controller.abort();
+        }, this.limits.timeoutMs);
+    }
+    dispose() {
+        clearTimeout(this.timer);
+        this.external?.removeEventListener('abort', this.onAbort);
+    }
+    stopGap(id) {
+        // Resolved Promise chains can starve timers. Check the monotonic deadline too.
+        if (!this.controller.signal.aborted && performance.now() >= this.deadline) {
+            this.timedOut = true;
+            this.controller.abort();
+        }
+        return this.controller.signal.aborted ? (0, validation_js_1.gap)(this.timedOut ? 'timeout' : 'cancelled', id) : undefined;
+    }
+    admit(id) {
+        (0, validation_js_1.name)(id);
+        if (this.nodes.has(id))
+            return undefined;
+        if (this.nodes.size >= this.limits.maxNodes)
+            return (0, validation_js_1.gap)('node-limit', id);
+        this.nodes.add(id);
+        return undefined;
+    }
+    hasRoots() {
+        return !!this.methods.roots;
+    }
+    read(method, id, project) {
+        const key = JSON.stringify([method, id]);
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const pending = this.invoke(id, () => {
+            const fn = this.methods[method];
+            if (!fn)
+                throw new validation_js_1.AdmissionError('not-collected');
+            return id === undefined ? fn(this.context) : fn(id, this.context);
+        }, project);
+        this.cache.set(key, pending);
+        return pending;
+    }
+    invoke(id, work, project) {
+        const stopped = this.stopGap(id);
+        if (stopped)
+            return Promise.resolve({ gap: stopped });
+        if (++this.calls > this.limits.maxCalls)
+            return Promise.resolve({ gap: (0, validation_js_1.gap)('call-limit', id) });
+        return new Promise((resolve) => {
+            let finished = false;
+            const finish = (result) => {
+                if (finished)
+                    return;
+                finished = true;
+                this.controller.signal.removeEventListener('abort', abort);
+                resolve(result);
+            };
+            const abort = () => finish({ gap: this.stopGap(id) ?? (0, validation_js_1.gap)('cancelled', id) });
+            const accept = (raw) => {
+                if (finished)
+                    return;
+                const stopped = this.stopGap(id);
+                if (stopped) {
+                    finish({ gap: stopped });
+                    return;
+                }
+                try {
+                    const value = project(raw), expired = this.stopGap(id);
+                    finish(expired ? { gap: expired } : { value });
+                }
+                catch (error) {
+                    finish({ gap: (0, validation_js_1.gap)(error instanceof validation_js_1.AdmissionError ? error.code : 'invalid-data', id) });
+                }
+            };
+            this.controller.signal.addEventListener('abort', abort, { once: true });
+            if (this.controller.signal.aborted) {
+                abort();
+                return;
+            }
+            try {
+                const returned = work();
+                // Observe native Promises by intrinsic, never assimilate a payload's `then` getter.
+                if (!(0, validation_js_1.observePromise)(returned, accept, () => finish({ gap: (0, validation_js_1.gap)('unavailable', id) })))
+                    accept(returned);
+            }
+            catch (error) {
+                finish({ gap: (0, validation_js_1.gap)(error instanceof validation_js_1.AdmissionError ? error.code : 'unavailable', id) });
+            }
+        });
+    }
+}
+exports.Session = Session;

package/dist/lib/cause/storedRecordAdapter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStoredRecordGraph = void 0;
+const storedRecord_js_1 = require("../time-travel/storedRecord.js");
+const recordAdapter_js_1 = require("./recordAdapter.js");
+const recordValidation_js_1 = require("./recordValidation.js");
+/** Load one address only. The host owns auth/storage; cancellation is forwarded and waiting is independently bounded. */
+function createStoredRecordGraph(host, options = {}) {
+    const limits = (0, recordAdapter_js_1.recordOptions)(options);
+    return (0, recordAdapter_js_1.createLazyRecordGraph)((address, context) => (0, recordValidation_js_1.projectLoaded)(() => host.loadLog(address, context), (loaded) => {
+        const max = limits.maxCommits, budget = { left: limits.maxFields };
+        const raw = (0, recordValidation_js_1.list)((0, recordValidation_js_1.own)(loaded, 'entries'), max * 4 + 16), entries = [];
+        for (let i = 0; i < raw.length; i++) {
+            if (context.signal.aborted)
+                throw new recordValidation_js_1.RecordRefusal('cancelled');
+            const entry = (0, recordValidation_js_1.own)(raw, String(i)), a = (0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.own)(entry, 'address'));
+            if ((0, recordValidation_js_1.addressKey)(a) !== (0, recordValidation_js_1.addressKey)(address))
+                throw new recordValidation_js_1.RecordRefusal();
+            const kind = (0, recordValidation_js_1.own)(entry, 'kind'), at = (0, recordValidation_js_1.own)(entry, 'at');
+            if (typeof at !== 'number' || !Number.isFinite(at))
+                throw new recordValidation_js_1.RecordRefusal();
+            if (kind === 'commit') {
+                const b = (0, recordValidation_js_1.own)(entry, 'bundle'), idx = (0, recordValidation_js_1.own)(b, 'idx');
+                if (!Number.isSafeInteger(idx) || idx < 0 || idx >= max)
+                    throw new recordValidation_js_1.RecordRefusal('node-limit');
+                entries.push({ kind, address: a, at, bundle: (0, recordValidation_js_1.bundleOf)(b, idx, budget) });
+            }
+            else if (kind === 'opened')
+                entries.push({ kind, address: a, at, initialState: (0, recordValidation_js_1.dataCopy)((0, recordValidation_js_1.own)(entry, 'initialState'), budget) });
+            else if (kind === 'closed')
+                entries.push({ kind, address: a, at, outcome: (0, recordValidation_js_1.own)(entry, 'outcome'), commits: (0, recordValidation_js_1.own)(entry, 'commits') });
+            else if (kind === 'note') {
+                /* opaque note bodies never enter dependency projection */
+            }
+            else
+                throw new recordValidation_js_1.RecordRefusal();
+        }
+        const record = (0, storedRecord_js_1.readStoredRecord)(entries, {
+            entries: max * 4 + 16,
+            missingCommits: max,
+            drillDepth: 16,
+            addressLength: 1536,
+        }), log = record.log(address);
+        if (!log)
+            throw new recordValidation_js_1.RecordRefusal();
+        if (log.gaps.length)
+            throw new recordValidation_js_1.RecordRefusal('not-collected');
+        return {
+            scope: {
+                address,
+                commitLog: log.commitLog,
+                reads: (0, recordValidation_js_1.own)(loaded, 'reads'),
+                controlDeps: (0, recordValidation_js_1.own)(loaded, 'controlDeps'),
+                attention: (0, recordValidation_js_1.own)(loaded, 'attention'),
+                complete: log.complete,
+            },
+            gaps: record.unread.length || log.gaps.length ? ['not-collected'] : [],
+        };
+    }), limits);
+}
+exports.createStoredRecordGraph = createStoredRecordGraph;

package/dist/lib/cause/strategies.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mostAffected = exports.largestDrop = void 0;
+/** Host-computed quality drops or impact counts: scores rank recorded candidates, never create evidence. */
+function maximum(scores) {
+    return (candidates) => {
+        let best = -Infinity;
+        const tied = [];
+        for (const candidate of candidates) {
+            const score = scores.get(candidate.nodeId);
+            if (score === undefined || !Number.isFinite(score))
+                throw new TypeError('CAUSE_STRATEGY_EVIDENCE_MISSING');
+            if (score > best) {
+                best = score;
+                tied.length = 0;
+            }
+            if (score === best)
+                tied.push(candidate.nodeId);
+        }
+        return Object.freeze(tied);
+    };
+}
+const largestDrop = (scores) => maximum(scores);
+exports.largestDrop = largestDrop;
+const mostAffected = (counts) => maximum(counts);
+exports.mostAffected = mostAffected;

package/dist/lib/cause/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });