foottrace 1.2.0 → 1.4.0

package/dist/esm/lib/evidence/requirements.js

@@ -0,0 +1,185 @@
+import { boundedList, boundedName, EvidenceRefusal, ownData, spendFields } from './admission.js';
+import { isRequirementReason } from './codes.js';
+/** Fixed per-call ceilings; characters are UTF-16 code units, not serialized transport bytes. */
+export const REQUIREMENT_RESULT_LIMITS = Object.freeze({
+    results: 512,
+    checks: 16,
+    affects: 32,
+    refs: 16,
+    name: 512,
+    fields: 32768,
+    characters: 1048576,
+});
+/** No input, field value or originating exception is retained on a refusal. */
+export class RequirementValidationError extends EvidenceRefusal {
+    constructor(code = 'invalid-data') {
+        super(code, 'REQUIREMENT_RESULTS_INVALID');
+    }
+}
+const refuse = (code) => new RequirementValidationError(code);
+const descriptors = { translateTrapErrors: true, requireOwnValue: true };
+const own = (value, key) => ownData(value, key, refuse, descriptors);
+const resultKeys = new Set([
+    'id',
+    'requirementRef',
+    'findingRef',
+    'windowRef',
+    'affects',
+    'state',
+    'reason',
+    'detail',
+    'evidenceRefs',
+    'checks',
+    'actionRefs',
+    'validTimeRef',
+    'learnedTimeRef',
+]);
+const checkKeys = new Set(['checkRef', 'disposition', 'reason', 'detail', 'evidenceRefs', 'attemptRefs']);
+const dispositions = new Set([
+    'checked-pass',
+    'checked-fail',
+    'unreachable',
+    'not-applicable',
+]);
+/** Closed objects expose no unknown payloads. Never invoke data accessors, iterators or toJSON. */
+function object(value, keys, budget) {
+    if (!value || typeof value !== 'object')
+        throw refuse();
+    let prototype;
+    let fields;
+    try {
+        prototype = Object.getPrototypeOf(value);
+        fields = Reflect.ownKeys(value);
+    }
+    catch {
+        throw refuse();
+    }
+    if (prototype !== Object.prototype && prototype !== null)
+        throw refuse();
+    if (fields.length > keys.size || fields.some((field) => typeof field !== 'string' || !keys.has(field)))
+        throw refuse();
+    spendFields(budget, fields.length, refuse);
+    // Including optional own fields: an own accessor is never treated as an absent field.
+    for (const field of fields)
+        own(value, field);
+}
+function list(value, maximum, read, budget) {
+    try {
+        if (!Array.isArray(value))
+            throw refuse();
+    }
+    catch {
+        throw refuse();
+    }
+    const length = own(value, 'length');
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+        throw refuse();
+    if (length > maximum)
+        throw refuse('node-limit');
+    let prototype;
+    let keys;
+    try {
+        prototype = Object.getPrototypeOf(value);
+        keys = Reflect.ownKeys(value);
+    }
+    catch {
+        throw refuse();
+    }
+    if (prototype !== Array.prototype)
+        throw refuse();
+    if (keys.length !== length + 1 ||
+        keys.some((key) => key !== 'length' && (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= length)))
+        throw refuse();
+    spendFields(budget, length + 1, refuse);
+    return boundedList(value, maximum, read, {
+        refuse,
+        overflow: 'node-limit',
+        freeze: true,
+        descriptors,
+        expectedLength: length,
+        translateArrayErrors: true,
+    });
+}
+function name(value, budget) {
+    const result = boundedName(value, REQUIREMENT_RESULT_LIMITS.name, refuse);
+    if (/\s/u.test(result))
+        throw refuse();
+    budget.characters -= result.length;
+    if (budget.characters < 0)
+        throw refuse('node-limit');
+    return result;
+}
+function unique(items, key) {
+    if (new Set(items.map(key)).size !== items.length)
+        throw refuse();
+    return items;
+}
+function refs(value, budget, maximum = REQUIREMENT_RESULT_LIMITS.refs) {
+    return unique(list(value, maximum, (item) => name(item, budget), budget), (item) => item);
+}
+function reason(value) {
+    if (!isRequirementReason(value))
+        throw refuse();
+    return value;
+}
+function optionalName(value, key, budget) {
+    const raw = own(value, key);
+    return raw === undefined ? undefined : name(raw, budget);
+}
+function detail(value, budget) {
+    const id = optionalName(value, 'detail', budget);
+    if (id !== undefined && !/^[A-Za-z][A-Za-z0-9_.-]*:.+$/.test(id))
+        throw refuse();
+    return id;
+}
+function check(value, budget) {
+    object(value, checkKeys, budget);
+    const checkRef = name(own(value, 'checkRef'), budget), disposition = own(value, 'disposition');
+    if (typeof disposition !== 'string' || !dispositions.has(disposition))
+        throw refuse();
+    const rawReason = own(value, 'reason'), detailId = detail(value, budget);
+    return Object.freeze({
+        checkRef,
+        disposition: disposition,
+        ...(rawReason === undefined ? {} : { reason: reason(rawReason) }),
+        ...(detailId === undefined ? {} : { detail: detailId }),
+        evidenceRefs: refs(own(value, 'evidenceRefs'), budget),
+        attemptRefs: refs(own(value, 'attemptRefs'), budget),
+    });
+}
+function result(value, budget) {
+    object(value, resultKeys, budget);
+    const id = name(own(value, 'id'), budget), requirementRef = name(own(value, 'requirementRef'), budget), findingRef = name(own(value, 'findingRef'), budget), windowRef = name(own(value, 'windowRef'), budget), state = own(value, 'state'), rawReason = own(value, 'reason');
+    if (state !== 'satisfied' && state !== 'unresolved')
+        throw refuse();
+    if (state === 'satisfied' && rawReason !== undefined)
+        throw refuse();
+    const affects = refs(own(value, 'affects'), budget, REQUIREMENT_RESULT_LIMITS.affects);
+    if (!affects.length)
+        throw refuse();
+    const evidenceRefs = refs(own(value, 'evidenceRefs'), budget), checks = unique(list(own(value, 'checks'), REQUIREMENT_RESULT_LIMITS.checks, (item) => check(item, budget), budget), (item) => item.checkRef), actionRefs = refs(own(value, 'actionRefs'), budget), detailId = detail(value, budget), validTimeRef = optionalName(value, 'validTimeRef', budget), learnedTimeRef = optionalName(value, 'learnedTimeRef', budget);
+    const binding = {
+        id,
+        requirementRef,
+        findingRef,
+        windowRef,
+        affects,
+        evidenceRefs,
+        checks,
+        actionRefs,
+        ...(detailId === undefined ? {} : { detail: detailId }),
+        ...(validTimeRef === undefined ? {} : { validTimeRef }),
+        ...(learnedTimeRef === undefined ? {} : { learnedTimeRef }),
+    };
+    return Object.freeze(state === 'unresolved' ? { ...binding, state, reason: reason(rawReason) } : { ...binding, state });
+}
+/**
+ * Atomically project detached, frozen reference-only records. This is structural admission only.
+ * The host must authenticate producers, resolve authorized artifacts, verify current query/run/scope and
+ * domain validity, and enforce every unresolved affects reference before rendering any factual claim.
+ * Identifier grammar does not classify secrets; producers must supply non-secret identifiers only.
+ */
+export function readRequirementResults(value) {
+    const budget = { left: REQUIREMENT_RESULT_LIMITS.fields, characters: REQUIREMENT_RESULT_LIMITS.characters };
+    return unique(list(value, REQUIREMENT_RESULT_LIMITS.results, (item) => result(item, budget), budget), (item) => item.id);
+}

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.idPathSegments = exports.joinPath = exports.isExecutionKey = exports.PATH_DELIMITER = exports.EXECUTION_DELIMITER = exports.CommitRangeIndex = exports.HONESTY_CODES = exports.sliceToJSON = exports.sliceForKey = exports.resolveKeysReadSource = exports.keyTimeline = exports.keysReadFromMap = exports.keysReadFromExecutionTree = exports.forwardSliceToJSON = exports.forwardSliceForKey = exports.formatTimeline = exports.formatSlice = exports.formatForwardSlice = exports.elementProvenance = exports.arrayProvenance = exports.formatCausalChain = exports.flattenCausalDAG = exports.causalChain = exports.timeTravel = exports.tagStops = exports.stateAt = exports.splitAxis = exports.readStoredRecord = exports.isCommitBundle = exports.filterStops = exports.commitStopsStrategy = exports.commitStops = exports.recordsPhases = exports.inferLegacyPhases = exports.findLastWriterWithBasis = exports.findLastWriter = exports.findCommits = exports.findCommit = exports.commitValueAtWithBasis = exports.commitValueAt = exports.commitIndexOf = exports.buildCommitIndex = exports.applySmartMerge = exports.UnknownVerbError = exports.parseAttemptId = exports.buildAttemptId = exports.splitStageId = exports.parseRuntimeStageId = exports.createExecutionCounter = exports.buildRuntimeStageId = void 0;
-exports.serveRecord = exports.deepEqual = exports.subflowSegmentsOf = exports.stageIdOf = void 0;
+exports.REQUIREMENT_RESULT_LIMITS = exports.RequirementValidationError = exports.readRequirementResults = exports.serveRecord = exports.deepEqual = exports.subflowSegmentsOf = exports.stageIdOf = void 0;
 var runtimeStageId_js_1 = require("./lib/ids/runtimeStageId.js");
 Object.defineProperty(exports, "buildRuntimeStageId", { enumerable: true, get: function () { return runtimeStageId_js_1.buildRuntimeStageId; } });
 Object.defineProperty(exports, "createExecutionCounter", { enumerable: true, get: function () { return runtimeStageId_js_1.createExecutionCounter; } });
@@ -69,3 +69,7 @@ var equality_js_1 = require("./lib/memory/equality.js");
 Object.defineProperty(exports, "deepEqual", { enumerable: true, get: function () { return equality_js_1.deepEqual; } });
 var freeze_js_1 = require("./lib/capture/freeze.js");
 Object.defineProperty(exports, "serveRecord", { enumerable: true, get: function () { return freeze_js_1.serveRecord; } });
+var requirements_js_1 = require("./lib/evidence/requirements.js");
+Object.defineProperty(exports, "readRequirementResults", { enumerable: true, get: function () { return requirements_js_1.readRequirementResults; } });
+Object.defineProperty(exports, "RequirementValidationError", { enumerable: true, get: function () { return requirements_js_1.RequirementValidationError; } });
+Object.defineProperty(exports, "REQUIREMENT_RESULT_LIMITS", { enumerable: true, get: function () { return requirements_js_1.REQUIREMENT_RESULT_LIMITS; } });

package/dist/lib/cause/explain.js

@@ -7,13 +7,13 @@ const validation_js_1 = require("./validation.js");
 const ranking_js_1 = require("./ranking.js");
 /** Read-only deterministic cause localisation and impact. No inference from timestamps or structural ancestry. */
 async function explain(graph, nodeId, options = {}) {
-    (0, validation_js_1.name)(nodeId);
+    (0, validation_js_1.graphName)(nodeId);
     const session = new session_js_1.Session(graph, options);
     try {
         const backward = await (0, walk_js_1.walk)(session, [nodeId], 'parents');
         const missing = [...backward.gaps];
         let candidates = (0, walk_js_1.frontier)(backward).map((item) => item.nodeId);
-        const rank = (0, validation_js_1.own)(options, 'rankRoots');
+        const rank = (0, validation_js_1.graphOwn)(options, 'rankRoots');
         if (rank !== undefined) {
             if (typeof rank !== 'function')
                 throw new TypeError('CAUSE_CONFIGURATION_INVALID');
@@ -34,7 +34,7 @@ async function explain(graph, nodeId, options = {}) {
         const rootCause = causeComplete && candidates.length === 1 ? candidates[0] : undefined;
         const forward = await (0, walk_js_1.walk)(session, [nodeId], 'children');
         let impactNodes = Object.freeze(forward.nodes.filter((id) => id !== nodeId));
-        const impactGaps = [...forward.gaps], rankImpact = (0, validation_js_1.own)(options, 'rankImpact');
+        const impactGaps = [...forward.gaps], rankImpact = (0, validation_js_1.graphOwn)(options, 'rankImpact');
         if (typeof rankImpact === 'function') {
             const selection = await session.invoke(undefined, () => rankImpact(impactNodes, session.context), (raw) => (0, ranking_js_1.admitRanking)(raw, new Set(impactNodes), {
                 exactPermutation: true,
@@ -73,19 +73,19 @@ async function attentionList(graph, options = {}) {
     const session = new session_js_1.Session(graph, options);
     try {
         let seeds = [], missing = [];
-        const requested = (0, validation_js_1.own)(options, 'nodeIds');
+        const requested = (0, validation_js_1.graphOwn)(options, 'nodeIds');
         const admitSeeds = (raw) => {
             // Only inspect the bounded prefix; the unread tail is explicitly incomplete.
             if (!Array.isArray(raw))
                 return (0, validation_js_1.nodeIds)(raw, session.limits.maxNodes);
-            const length = (0, validation_js_1.own)(raw, 'length');
+            const length = (0, validation_js_1.graphOwn)(raw, 'length');
             if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
                 return (0, validation_js_1.nodeIds)(raw, session.limits.maxNodes);
             if (length > session.limits.maxNodes)
                 missing.push((0, validation_js_1.gap)('node-limit'));
             const prefix = [];
             for (let i = 0; i < Math.min(length, session.limits.maxNodes); i++)
-                prefix.push((0, validation_js_1.own)(raw, String(i)));
+                prefix.push((0, validation_js_1.graphOwn)(raw, String(i)));
             return (0, validation_js_1.nodeIds)(prefix, session.limits.maxNodes);
         };
         if (requested !== undefined) {

package/dist/lib/cause/queryMemo.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endQueryMemo = exports.queryMemo = exports.beginQueryMemo = void 0;
+/** Share bounded derived work within one query without retaining it in the graph's storage cache. */
+class QueryMemo {
+    maximumEntries;
+    owners = new Map();
+    entries = 0;
+    closed = false;
+    constructor(maximumEntries) {
+        this.maximumEntries = maximumEntries;
+    }
+    remember(owner, key, create) {
+        const previous = this.owners.get(owner);
+        if (previous?.has(key))
+            return previous.get(key);
+        if (this.closed || this.entries >= this.maximumEntries)
+            return create();
+        const value = create();
+        // Creation can finish after disposal or re-enter other readers; neither may refill a closed/full memo.
+        if (!this.closed && this.entries < this.maximumEntries) {
+            const bucket = this.owners.get(owner) ?? new Map();
+            if (!bucket.has(key))
+                this.entries++;
+            bucket.set(key, value);
+            this.owners.set(owner, bucket);
+        }
+        return value;
+    }
+    close() {
+        this.closed = true;
+        this.owners.clear();
+        this.entries = 0;
+    }
+}
+const queries = new WeakMap();
+/** Reserve one resolution and one inspection per admitted node, shared across all adapter owners. */
+function beginQueryMemo(context, maximumNodes) {
+    queries.set(context, new QueryMemo(maximumNodes * 2));
+}
+exports.beginQueryMemo = beginQueryMemo;
+/** Direct graph calls have no managed query lifetime and deliberately remain uncached. */
+function queryMemo(context) {
+    return queries.get(context);
+}
+exports.queryMemo = queryMemo;
+/** Clear synchronously without aborting an otherwise successful query's public signal. */
+function endQueryMemo(context) {
+    queries.get(context)?.close();
+    queries.delete(context);
+}
+exports.endQueryMemo = endQueryMemo;

package/dist/lib/cause/recordAdapter.js

@@ -5,38 +5,31 @@ const recordChildren_js_1 = require("./recordChildren.js");
 const recordCoverage_js_1 = require("./recordCoverage.js");
 const recordIdentity_js_1 = require("./recordIdentity.js");
 const recordLoading_js_1 = require("./recordLoading.js");
-const recordParents_js_1 = require("./recordParents.js");
+const recordQuery_js_1 = require("./recordQuery.js");
 const recordScope_js_1 = require("./recordScope.js");
 const recordValidation_js_1 = require("./recordValidation.js");
+/** Give each failed port its own incomplete page rather than sharing a mutable edge array. */
+const unavailableAdjacency = () => ({ edges: [], complete: false });
 var recordScope_js_2 = require("./recordScope.js");
 Object.defineProperty(exports, "recordOptions", { enumerable: true, get: function () { return recordScope_js_2.recordOptions; } });
 /** Common engine for memory and one-scope-at-a-time host storage. Loader functions are trusted executable code. */
 function createLazyRecordGraph(load, options = {}) {
     const limits = (0, recordScope_js_1.recordOptions)(options), loader = (0, recordLoading_js_1.createRecordScopeLoader)(load, limits);
-    const resolve = (nodeId, context) => (0, recordIdentity_js_1.resolveRecordNode)(nodeId, context, loader);
+    const query = (0, recordQuery_js_1.createRecordQuery)(loader, limits.maxEdges);
     return Object.freeze({
         nodeId: (address, node) => (0, recordIdentity_js_1.nodeIdFor)(address, node),
         openScope: (address, context) => (0, recordLoading_js_1.openRecordScope)(address, context, loader),
         async parents(nodeId, context) {
-            const node = await resolve(nodeId, context);
-            return 'failure' in node
-                ? { edges: [], complete: false }
-                : (0, recordParents_js_1.inspectRecordNode)(node, limits.maxEdges, loader.extraGapCodes(node.scope)).adjacency;
+            return (0, recordQuery_js_1.whenResolved)(await query.resolve(nodeId, context), (node) => query.inspect(node, context).adjacency, unavailableAdjacency);
         },
         async gaps(nodeId, context) {
-            const node = await resolve(nodeId, context);
-            return 'failure' in node
-                ? (0, recordCoverage_js_1.gapForRecordFailure)(node.failure)
-                : (0, recordParents_js_1.inspectRecordNode)(node, limits.maxEdges, loader.extraGapCodes(node.scope)).gaps;
+            return (0, recordQuery_js_1.whenResolved)(await query.resolve(nodeId, context), (node) => query.inspect(node, context).gaps, (failure) => (0, recordCoverage_js_1.gapForRecordFailure)(failure.failure));
         },
         async attention(nodeId, context) {
-            return (0, recordCoverage_js_1.attentionForRecordNode)(await resolve(nodeId, context));
+            return (0, recordQuery_js_1.whenResolved)(await query.resolve(nodeId, context), recordCoverage_js_1.attentionForRecordNode, () => []);
         },
         async children(nodeId, context) {
-            const node = await resolve(nodeId, context);
-            return 'failure' in node
-                ? { edges: [], complete: false }
-                : (0, recordChildren_js_1.childrenForRecordNode)(node, limits.maxEdges, loader.extraGapCodes(node.scope));
+            return (0, recordQuery_js_1.whenResolved)(await query.resolve(nodeId, context), (node) => (0, recordChildren_js_1.childrenForRecordNode)(node, limits.maxEdges, query.inspect(node, context)), unavailableAdjacency);
         },
     });
 }
@@ -45,8 +38,8 @@ exports.createLazyRecordGraph = createLazyRecordGraph;
 function createRecordGraph(scopes, options = {}) {
     const limits = (0, recordScope_js_1.recordOptions)(options);
     return createLazyRecordGraph((address) => {
-        for (const raw of (0, recordValidation_js_1.list)(scopes, limits.maxScopes)) {
-            if ((0, recordValidation_js_1.addressKey)((0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.own)(raw, 'address'))) === (0, recordValidation_js_1.addressKey)(address))
+        for (const raw of (0, recordValidation_js_1.recordList)(scopes, limits.maxScopes)) {
+            if ((0, recordValidation_js_1.addressKey)((0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.recordOwn)(raw, 'address'))) === (0, recordValidation_js_1.addressKey)(address))
                 return { scope: raw };
         }
         throw new recordValidation_js_1.RecordRefusal('unavailable');

package/dist/lib/cause/recordChildren.js

@@ -5,7 +5,6 @@ const forwardSliceForKey_js_1 = require("../slice/forwardSliceForKey.js");
 const recordControl_js_1 = require("./recordControl.js");
 const recordCoverage_js_1 = require("./recordCoverage.js");
 const recordIdentity_js_1 = require("./recordIdentity.js");
-const recordParents_js_1 = require("./recordParents.js");
 const recordScope_js_1 = require("./recordScope.js");
 /** Keep per-write and conservative fed edges distinct while retaining existing cap and deduplication order. */
 function appendFedChildren(scope, root, maximumEdges, edges) {
@@ -70,10 +69,10 @@ function appendDataChildren(scope, identity, commitIndex, maximumEdges, edges) {
     return complete;
 }
 /** Share parent-side coverage checks before appending data then control children in their established order. */
-function childrenForRecordNode(node, maximumEdges, extraGapCodes) {
+function childrenForRecordNode(node, maximumEdges, inspection) {
     const { scope, identity, commitIndex } = node;
-    const base = (0, recordParents_js_1.inspectRecordNode)(node, maximumEdges, extraGapCodes), edges = [];
-    let complete = base.gaps.length === 0;
+    const edges = [];
+    let complete = inspection.gaps.length === 0;
     if (!(0, recordCoverage_js_1.allStageReadsCollected)(scope))
         complete = false;
     complete = appendDataChildren(scope, identity, commitIndex, maximumEdges, edges) && complete;

package/dist/lib/cause/recordCoverage.js

@@ -25,7 +25,7 @@ exports.gapForRecordFailure = gapForRecordFailure;
 /** Return captured mark references without treating an omitted attention map as collected evidence. */
 function attentionForRecordNode(node) {
     // An omitted map stays unknown coverage; it is never replaced by an affirmative empty map.
-    return 'failure' in node ? [] : node.scope.marks?.get(node.identity.runtimeStageId) ?? [];
+    return node.scope.marks?.get(node.identity.runtimeStageId) ?? [];
 }
 exports.attentionForRecordNode = attentionForRecordNode;
 /** Emit host and capture gaps before query-derived gaps so existing evidence order stays stable. */

package/dist/lib/cause/recordIdentity.js

@@ -14,7 +14,7 @@ function readNodeIdentity(nodeId) {
     catch {
         throw new recordValidation_js_1.RecordRefusal();
     }
-    const address = (0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.own)(fields, 'address')), runtimeStageId = (0, recordValidation_js_1.name)((0, recordValidation_js_1.own)(fields, 'runtimeStageId')), commitIndex = (0, recordValidation_js_1.own)(fields, 'commitIdx'), key = (0, recordValidation_js_1.own)(fields, 'key'), read = (0, recordValidation_js_1.own)(fields, 'read');
+    const address = (0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.recordOwn)(fields, 'address')), runtimeStageId = (0, recordValidation_js_1.recordName)((0, recordValidation_js_1.recordOwn)(fields, 'runtimeStageId')), commitIndex = (0, recordValidation_js_1.recordOwn)(fields, 'commitIdx'), key = (0, recordValidation_js_1.recordOwn)(fields, 'key'), read = (0, recordValidation_js_1.recordOwn)(fields, 'read');
     if (commitIndex !== undefined && (!Number.isSafeInteger(commitIndex) || commitIndex < 0))
         throw new recordValidation_js_1.RecordRefusal();
     if ((read !== undefined && read !== true) || (read === true && key === undefined))
@@ -23,7 +23,7 @@ function readNodeIdentity(nodeId) {
         address,
         runtimeStageId,
         ...(commitIndex === undefined ? {} : { commitIdx: commitIndex }),
-        ...(key === undefined ? {} : { key: (0, recordValidation_js_1.name)(key, true) }),
+        ...(key === undefined ? {} : { key: (0, recordValidation_js_1.recordName)(key, true) }),
         ...(read === true ? { read: true } : {}),
     };
 }
@@ -31,7 +31,7 @@ exports.readNodeIdentity = readNodeIdentity;
 /** Stable field order preserves existing address/execution/key IDs across storage and memory readers. */
 function nodeIdFor(addressInput, node, read) {
     try {
-        const address = (0, recordValidation_js_1.addressOf)(addressInput), runtimeStageId = (0, recordValidation_js_1.name)((0, recordValidation_js_1.own)(node, 'runtimeStageId')), commitIndex = (0, recordValidation_js_1.own)(node, 'commitIdx'), key = (0, recordValidation_js_1.own)(node, 'key');
+        const address = (0, recordValidation_js_1.addressOf)(addressInput), runtimeStageId = (0, recordValidation_js_1.recordName)((0, recordValidation_js_1.recordOwn)(node, 'runtimeStageId')), commitIndex = (0, recordValidation_js_1.recordOwn)(node, 'commitIdx'), key = (0, recordValidation_js_1.recordOwn)(node, 'key');
         if (commitIndex !== undefined && (!Number.isSafeInteger(commitIndex) || commitIndex < 0))
             throw new recordValidation_js_1.RecordRefusal();
         const nodeId = 'record:' +
@@ -39,7 +39,7 @@ function nodeIdFor(addressInput, node, read) {
                 address,
                 runtimeStageId,
                 ...(commitIndex === undefined ? {} : { commitIdx: commitIndex }),
-                ...(key === undefined ? {} : { key: (0, recordValidation_js_1.name)(key, true) }),
+                ...(key === undefined ? {} : { key: (0, recordValidation_js_1.recordName)(key, true) }),
                 ...(read ? { read: true } : {}),
             });
         return nodeId.length <= 2048 ? nodeId : 'record:invalid';

package/dist/lib/cause/recordLoading.js

@@ -13,8 +13,8 @@ function admitLoadedScope(result, request, limits, state) {
     }
     let prepared;
     try {
-        prepared = (0, recordScope_js_1.prepareRecordScope)((0, recordValidation_js_1.own)(result, 'scope'), request.address, limits.maxCommits, limits.maxFields);
-        const extra = (0, recordValidation_js_1.list)((0, recordValidation_js_1.own)(result, 'gaps') ?? [], 32);
+        prepared = (0, recordScope_js_1.prepareRecordScope)((0, recordValidation_js_1.recordOwn)(result, 'scope'), request.address, limits.maxCommits, limits.maxFields);
+        const extra = (0, recordValidation_js_1.recordList)((0, recordValidation_js_1.recordOwn)(result, 'gaps') ?? [], 32);
         // Coverage belongs to this admitted object, so cached scopes retain the same gap ordering and ownership.
         state.extraGaps.set(prepared, (0, validation_js_1.gaps)(extra.map((code) => ({ code, evidence: [] }))).map((gap) => gap.code));
     }

package/dist/lib/cause/recordQuery.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whenResolved = exports.createRecordQuery = void 0;
+const queryMemo_js_1 = require("./queryMemo.js");
+const recordIdentity_js_1 = require("./recordIdentity.js");
+const recordInspection_js_1 = require("./recordInspection.js");
+/** Both dependency directions share the same admitted node and canonical inspection within a query. */
+function createRecordQuery(loader, maximumEdges) {
+    const resolutionOwner = {}, inspectionOwner = {};
+    return {
+        resolve(nodeId, context) {
+            const resolve = () => (0, recordIdentity_js_1.resolveRecordNode)(nodeId, context, loader), memo = (0, queryMemo_js_1.queryMemo)(context);
+            // A retained success must never bypass the loader's existing cancellation check.
+            return memo && !context.signal.aborted ? memo.remember(resolutionOwner, nodeId, resolve) : resolve();
+        },
+        inspect(node, context) {
+            const inspect = () => (0, recordInspection_js_1.inspectRecordNode)(node, maximumEdges, loader.extraGapCodes(node.scope));
+            return (0, queryMemo_js_1.queryMemo)(context)?.remember(inspectionOwner, node, inspect) ?? inspect();
+        },
+    };
+}
+exports.createRecordQuery = createRecordQuery;
+/** Every port maps the same fixed loading failure while projecting only admitted nodes. */
+function whenResolved(node, onNode, onFailure) {
+    return 'failure' in node ? onFailure(node) : onNode(node);
+}
+exports.whenResolved = whenResolved;

package/dist/lib/cause/recordScope.js

@@ -19,11 +19,11 @@ function recordOptions(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),
+            maxCommits: boundedOption((0, recordValidation_js_1.recordOwn)(options, 'maxCommits'), 256, 4096),
+            maxFields: boundedOption((0, recordValidation_js_1.recordOwn)(options, 'maxFields'), 20000, 1000000),
+            maxEdges: boundedOption((0, recordValidation_js_1.recordOwn)(options, 'maxEdges'), 64, 256),
+            maxScopes: boundedOption((0, recordValidation_js_1.recordOwn)(options, 'maxScopes'), 32, 256),
+            loadTimeoutMs: boundedOption((0, recordValidation_js_1.recordOwn)(options, 'loadTimeoutMs'), 1000, 30000),
         });
     }
     catch {
@@ -33,22 +33,22 @@ function recordOptions(options) {
 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))
+    if ((0, recordValidation_js_1.addressKey)((0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.recordOwn)(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 rawLog = (0, recordValidation_js_1.recordList)((0, recordValidation_js_1.recordOwn)(value, 'commitLog'), maximumCommits), budget = { left: maximumFields };
+    const log = rawLog.map((_, commitIndex) => (0, recordValidation_js_1.bundleOf)((0, recordValidation_js_1.recordOwn)(rawLog, String(commitIndex)), commitIndex, budget));
+    const reads = (0, recordValidation_js_1.mapOf)((0, recordValidation_js_1.recordOwn)(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 control = (0, recordValidation_js_1.mapOf)((0, recordValidation_js_1.recordOwn)(value, 'controlDeps'), maximumCommits, (value) => ({ deciderId: (0, recordValidation_js_1.recordName)((0, recordValidation_js_1.recordOwn)(value, 'deciderId')) }), budget);
+    const marks = (0, recordValidation_js_1.mapOf)((0, recordValidation_js_1.recordOwn)(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 };
+    return { address, log, reads, control, marks, complete: (0, recordValidation_js_1.recordOwn)(value, 'complete') === true };
 }
 exports.prepareRecordScope = prepareRecordScope;
 /** Preserve both stage reads and stronger per-write prefixes, including their original encounter order. */

package/dist/lib/cause/recordValidation.js

@@ -1,9 +1,9 @@
 "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;
+exports.projectLoaded = exports.mapOf = exports.bundleOf = exports.dataCopy = exports.addressKey = exports.spend = exports.addressOf = exports.recordList = exports.recordName = exports.names = exports.recordOwn = 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");
+const admission_js_1 = require("../evidence/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;
@@ -15,19 +15,19 @@ class RecordRefusal extends admission_js_1.EvidenceRefusal {
 exports.RecordRefusal = RecordRefusal;
 const refuseRecord = (code) => new RecordRefusal(code);
 const recordDescriptors = { translateTrapErrors: true, requireOwnValue: true };
-function own(value, key) {
+function recordOwn(value, key) {
     return (0, admission_js_1.ownData)(value, key, refuseRecord, recordDescriptors);
 }
-exports.own = own;
+exports.recordOwn = recordOwn;
 function names(value, maximum = 128, path = false) {
-    return list(value, maximum).map((item) => name(item, path));
+    return recordList(value, maximum).map((item) => recordName(item, path));
 }
 exports.names = names;
-function name(value, path = false) {
+function recordName(value, path = false) {
     return (0, admission_js_1.boundedName)(value, 1024, refuseRecord, path);
 }
-exports.name = name;
-function list(value, maximum) {
+exports.recordName = recordName;
+function recordList(value, maximum) {
     return (0, admission_js_1.boundedList)(value, maximum, (item) => item, {
         refuse: refuseRecord,
         overflow: 'node-limit',
@@ -35,9 +35,9 @@ function list(value, maximum) {
         descriptors: recordDescriptors,
     });
 }
-exports.list = list;
+exports.recordList = recordList;
 function addressOf(value) {
-    const logRunId = name(own(value, 'logRunId')), drillPath = names(own(value, 'drillPath'), 16);
+    const logRunId = recordName(recordOwn(value, 'logRunId')), drillPath = names(recordOwn(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) });
@@ -71,7 +71,7 @@ function dataCopy(value, budget) {
         if (!Array.isArray(v) && p !== Object.prototype && p !== null)
             throw new RecordRefusal();
         if (Array.isArray(v)) {
-            const length = own(v, 'length');
+            const length = recordOwn(v, 'length');
             if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
                 throw new RecordRefusal();
             spend(budget, length);
@@ -96,7 +96,7 @@ function dataCopy(value, budget) {
         for (const key of keys) {
             if (key.length > 1024)
                 throw new RecordRefusal('node-limit');
-            const v = own(from, key);
+            const v = recordOwn(from, key);
             check(v);
             let copy = v;
             if (!leaf(v)) {
@@ -113,16 +113,16 @@ function dataCopy(value, budget) {
 }
 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');
+    const runtimeStageId = recordName(recordOwn(value, 'runtimeStageId')), stageId = recordName(recordOwn(value, 'stageId'));
+    const trace = recordList(recordOwn(value, 'trace'), 128).map((_, i) => {
+        const t = recordOwn(recordOwn(value, 'trace'), String(i)), path = recordName(recordOwn(t, 'path'), true), verb = recordOwn(t, 'verb');
         if (!['set', 'merge', 'append', 'delete'].includes(verb))
             throw new RecordRefusal();
-        const readKeys = own(t, 'readKeys');
+        const readKeys = recordOwn(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);
+    const overwrite = dataCopy(recordOwn(value, 'overwrite'), budget), updates = dataCopy(recordOwn(value, 'updates'), budget);
     if (!overwrite ||
         typeof overwrite !== 'object' ||
         Array.isArray(overwrite) ||
@@ -130,9 +130,9 @@ function bundleOf(value, idx, budget) {
         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));
+    const redactedPaths = names(recordOwn(value, 'redactedPaths') ?? [], 128, true);
+    const untracked = recordOwn(value, 'untrackedSources'), phase = recordOwn(value, 'phase');
+    spend(budget, redactedPaths.length + (untracked === undefined ? 0 : recordList(untracked, 128).length));
     return {
         idx,
         stage: stageId,
@@ -179,7 +179,7 @@ function mapOf(value, limit, read, budget) {
         throw new RecordRefusal('node-limit');
     if (budget)
         spend(budget, keys.length);
-    return new Map(keys.map((k) => [name(k), read(own(value, k))]));
+    return new Map(keys.map((k) => [recordName(k), read(recordOwn(value, k))]));
 }
 exports.mapOf = mapOf;
 /** Observe native promises by intrinsic without assimilating a data object's then accessor. */