foottrace 1.2.0 → 1.3.0

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. */

package/dist/lib/cause/session.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Session = void 0;
 const validation_js_1 = require("./validation.js");
+const queryMemo_js_1 = require("./queryMemo.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. */
@@ -24,7 +25,7 @@ class Session {
             (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);
+                const value = (0, validation_js_1.graphOwn)(options, key);
                 if (value !== undefined) {
                     if (typeof value !== 'number' ||
                         !Number.isSafeInteger(value) ||
@@ -35,13 +36,13 @@ class Session {
                 }
             }
             this.limits = Object.freeze(limits);
-            const rank = (0, validation_js_1.own)(options, 'rankRoots');
+            const rank = (0, validation_js_1.graphOwn)(options, 'rankRoots');
             if (rank !== undefined && typeof rank !== 'function')
                 throw new TypeError();
-            const impactRank = (0, validation_js_1.own)(options, 'rankImpact');
+            const impactRank = (0, validation_js_1.graphOwn)(options, 'rankImpact');
             if (impactRank !== undefined && typeof impactRank !== 'function')
                 throw new TypeError();
-            const signal = (0, validation_js_1.own)(options, 'signal');
+            const signal = (0, validation_js_1.graphOwn)(options, 'signal');
             if (signal !== undefined && !(signal instanceof AbortSignal))
                 throw new TypeError();
             this.external = signal;
@@ -74,8 +75,10 @@ class Session {
             this.timedOut = true;
             this.controller.abort();
         }, this.limits.timeoutMs);
+        (0, queryMemo_js_1.beginQueryMemo)(this.context, this.limits.maxNodes);
     }
     dispose() {
+        (0, queryMemo_js_1.endQueryMemo)(this.context);
         clearTimeout(this.timer);
         this.external?.removeEventListener('abort', this.onAbort);
     }
@@ -88,7 +91,7 @@ class Session {
         return this.controller.signal.aborted ? (0, validation_js_1.gap)(this.timedOut ? 'timeout' : 'cancelled', id) : undefined;
     }
     admit(id) {
-        (0, validation_js_1.name)(id);
+        (0, validation_js_1.graphName)(id);
         if (this.nodes.has(id))
             return undefined;
         if (this.nodes.size >= this.limits.maxNodes)

package/dist/lib/cause/storedRecordAdapter.js

@@ -9,26 +9,32 @@ 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 = [];
+        const raw = (0, recordValidation_js_1.recordList)((0, recordValidation_js_1.recordOwn)(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'));
+            const entry = (0, recordValidation_js_1.recordOwn)(raw, String(i)), a = (0, recordValidation_js_1.addressOf)((0, recordValidation_js_1.recordOwn)(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');
+            const kind = (0, recordValidation_js_1.recordOwn)(entry, 'kind'), at = (0, recordValidation_js_1.recordOwn)(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');
+                const b = (0, recordValidation_js_1.recordOwn)(entry, 'bundle'), idx = (0, recordValidation_js_1.recordOwn)(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) });
+                entries.push({ kind, address: a, at, initialState: (0, recordValidation_js_1.dataCopy)((0, recordValidation_js_1.recordOwn)(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') });
+                entries.push({
+                    kind,
+                    address: a,
+                    at,
+                    outcome: (0, recordValidation_js_1.recordOwn)(entry, 'outcome'),
+                    commits: (0, recordValidation_js_1.recordOwn)(entry, 'commits'),
+                });
             else if (kind === 'note') {
                 /* opaque note bodies never enter dependency projection */
             }
@@ -49,9 +55,9 @@ function createStoredRecordGraph(host, options = {}) {
             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'),
+                reads: (0, recordValidation_js_1.recordOwn)(loaded, 'reads'),
+                controlDeps: (0, recordValidation_js_1.recordOwn)(loaded, 'controlDeps'),
+                attention: (0, recordValidation_js_1.recordOwn)(loaded, 'attention'),
                 complete: log.complete,
             },
             gaps: record.unread.length || log.gaps.length ? ['not-collected'] : [],