foottrace 1.1.0 → 1.2.0

package/dist/esm/lib/cause/validation.js

@@ -0,0 +1,134 @@
+import { boundedList, boundedName, EvidenceRefusal, ownData } from './admission.js';
+/** Graph-port refusals carry their code through Session; loader refusals are handled at the record boundary. */
+export class AdmissionError extends EvidenceRefusal {
+    code;
+    constructor(code = 'invalid-data') {
+        super(code, 'Invalid cause evidence');
+        this.code = code;
+    }
+}
+/**
+ * Only ordinary native promise wrappers belong to the async host contract.
+ * An own constructor could run an accessor/species during intrinsic then().
+ * Exotic wrappers remain the trusted host's responsibility, including rejection handling.
+ */
+export function observePromise(raw, accept, reject) {
+    if (!raw || typeof raw !== 'object' || Object.getPrototypeOf(raw) !== Promise.prototype)
+        return false;
+    if (Object.getOwnPropertyDescriptor(raw, 'constructor'))
+        throw new AdmissionError();
+    try {
+        Promise.prototype.then.call(raw, accept, reject);
+    }
+    catch {
+        throw new AdmissionError();
+    }
+    return true;
+}
+const refuseGraph = (code) => new AdmissionError(code);
+const graphDescriptors = { translateTrapErrors: false, requireOwnValue: false };
+export function own(value, key) {
+    return ownData(value, key, refuseGraph, graphDescriptors);
+}
+export function plain(value) {
+    if (!value || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        throw new AdmissionError();
+}
+export function name(value, maximum = 2048) {
+    return boundedName(value, maximum, refuseGraph);
+}
+export function list(value, maximum, read, overflow = 'invalid-data') {
+    return boundedList(value, maximum, read, {
+        refuse: refuseGraph,
+        overflow,
+        freeze: true,
+        descriptors: graphDescriptors,
+    });
+}
+const reasons = new Set([
+    'ERROR_RECORDED',
+    'UNKNOWN_EFFECT_RECORDED',
+    'RETRY_STOP_RECORDED',
+    'TIMEOUT_RECORDED',
+    'RETRY_RECORDED',
+    'QUALITY_DROP_RECORDED',
+    'EVIDENCE_NOT_COLLECTED',
+    'OUTLIER_RECORDED',
+    'BUSINESS_RULE_MATCHED',
+]);
+const codes = new Set([
+    'not-collected',
+    'untracked-input',
+    'redacted',
+    'conservative',
+    'scope-boundary',
+    'invalid-data',
+    'unavailable',
+    'timeout',
+    'cancelled',
+    'cycle',
+    'node-limit',
+    'depth-limit',
+    'edge-limit',
+    'call-limit',
+    'truncated',
+    'strategy-failed',
+]);
+export const refs = (value) => list(value, 16, (item) => name(item, 512));
+export function attention(value) {
+    return list(value, 32, (item) => {
+        plain(item);
+        const kind = own(item, 'kind'), reason = own(item, 'reason');
+        if (typeof kind !== 'string' ||
+            !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(kind) ||
+            typeof reason !== 'string' ||
+            !reasons.has(reason))
+            throw new AdmissionError();
+        const evidence = refs(own(item, 'evidence'));
+        if (kind !== 'not-collected' && evidence.length === 0)
+            throw new AdmissionError();
+        return Object.freeze({ kind, reason: reason, evidence });
+    });
+}
+export function gaps(value) {
+    return list(value, 32, (item) => {
+        plain(item);
+        const code = own(item, 'code'), nodeId = own(item, 'nodeId');
+        if (typeof code !== 'string' || !codes.has(code))
+            throw new AdmissionError();
+        return Object.freeze({
+            code: code,
+            ...(nodeId === undefined ? {} : { nodeId: name(nodeId) }),
+            evidence: refs(own(item, 'evidence')),
+        });
+    });
+}
+export function adjacency(value, maximum) {
+    plain(value);
+    const complete = own(value, 'complete');
+    if (typeof complete !== 'boolean')
+        throw new AdmissionError();
+    const edges = list(own(value, 'edges'), maximum, (item) => {
+        plain(item);
+        const nodeId = name(own(item, 'nodeId')), kind = own(item, 'kind'), attribution = own(item, 'attribution');
+        if ((kind !== 'data' && kind !== 'control') ||
+            (attribution !== 'per-write' && attribution !== 'stage' && attribution !== 'recorded-control') ||
+            (kind === 'control' && attribution !== 'recorded-control') ||
+            (kind === 'data' && attribution === 'recorded-control'))
+            throw new AdmissionError();
+        return Object.freeze({ nodeId, kind, attribution, evidence: refs(own(item, 'evidence')) });
+    }, 'edge-limit');
+    return Object.freeze({ edges, complete });
+}
+export const nodeIds = (value, max) => list(value, max, (item) => name(item), 'node-limit');
+export const gap = (code, nodeId) => Object.freeze({ code, ...(nodeId === undefined ? {} : { nodeId }), evidence: Object.freeze([]) });
+export function uniqueGaps(items) {
+    const seen = new Set();
+    return Object.freeze(items.filter((item) => {
+        const key = JSON.stringify(item);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }));
+}

package/dist/esm/lib/cause/walk.d.ts

@@ -0,0 +1,12 @@
+import type { Gap, MarkedNode, NodeId, TraversedEdge } from './types.js';
+import { Session } from './session.js';
+export interface Walk {
+    readonly nodes: readonly NodeId[];
+    readonly marked: readonly MarkedNode[];
+    readonly edges: readonly TraversedEdge[];
+    readonly gaps: readonly Gap[];
+}
+/** BFS discovers the shallowest arrival; a repeated diamond node is not a cycle. */
+export declare function walk(session: Session, seeds: readonly NodeId[], direction: 'parents' | 'children'): Promise<Walk>;
+export declare function frontier(result: Walk): readonly MarkedNode[];
+export declare function pathTo(edges: readonly TraversedEdge[], start: NodeId, target: NodeId): readonly NodeId[];

package/dist/esm/lib/cause/walk.js

@@ -0,0 +1,174 @@
+import { adjacency, attention, gap, gaps, uniqueGaps } from './validation.js';
+/** BFS discovers the shallowest arrival; a repeated diamond node is not a cycle. */
+export async function walk(session, seeds, direction) {
+    const queue = [], seen = new Set(), marks = [], edges = [], missing = [];
+    const enqueue = (id, depth) => {
+        if (seen.has(id))
+            return;
+        const refusal = session.admit(id);
+        if (refusal) {
+            missing.push(refusal);
+            return;
+        }
+        seen.add(id);
+        queue.push([id, depth]);
+    };
+    for (const id of seeds)
+        enqueue(id, 0);
+    for (let index = 0; index < queue.length; index++) {
+        const [id, depth] = queue[index], stopped = session.stopGap(id);
+        if (stopped) {
+            missing.push(stopped);
+            break;
+        }
+        const marked = await session.read('attention', id, attention);
+        if (marked.gap)
+            missing.push(marked.gap);
+        if (marked.value?.length) {
+            marks.push(Object.freeze({ nodeId: id, attention: marked.value }));
+            if (marked.value.some((item) => item.kind === 'not-collected'))
+                missing.push(gap('not-collected', id));
+        }
+        const coverage = await session.read('gaps', id, gaps);
+        if (coverage.gap)
+            missing.push(coverage.gap);
+        if (coverage.value)
+            missing.push(...coverage.value);
+        const page = await session.read(direction, id, (raw) => adjacency(raw, session.limits.maxEdges));
+        if (page.gap) {
+            missing.push(page.gap);
+            continue;
+        }
+        if (!page.value)
+            continue;
+        if (!page.value.complete)
+            missing.push(gap('not-collected', id));
+        if (depth >= session.limits.maxDepth) {
+            if (page.value.edges.length)
+                missing.push(gap('depth-limit', id));
+            continue;
+        }
+        for (const edge of page.value.edges) {
+            if (session.edges >= session.limits.maxEdges) {
+                missing.push(gap('edge-limit', id));
+                break;
+            }
+            session.edges++;
+            const refusal = session.admit(edge.nodeId);
+            if (refusal) {
+                missing.push(refusal);
+                continue;
+            }
+            edges.push(Object.freeze({
+                from: id,
+                to: edge.nodeId,
+                kind: edge.kind,
+                attribution: edge.attribution,
+                evidence: edge.evidence,
+            }));
+            if (edge.attribution === 'stage')
+                missing.push(gap('conservative', id));
+            enqueue(edge.nodeId, depth + 1);
+        }
+    }
+    if (hasCycle(edges))
+        missing.push(gap('cycle'));
+    return Object.freeze({
+        nodes: Object.freeze(queue.map((row) => row[0])),
+        marked: Object.freeze(marks),
+        edges: Object.freeze(edges),
+        gaps: uniqueGaps(missing),
+    });
+}
+/** Iterative three-colour walk; shared nodes remain distinguishable from back edges. */
+function hasCycle(edges) {
+    const next = new Map();
+    for (const edge of edges) {
+        if (!next.has(edge.from))
+            next.set(edge.from, []);
+        next.get(edge.from).push(edge.to);
+    }
+    const state = new Map();
+    for (const seed of next.keys()) {
+        if (state.has(seed))
+            continue;
+        const stack = [[seed, 0]];
+        state.set(seed, 1);
+        while (stack.length) {
+            const frame = stack[stack.length - 1], children = next.get(frame[0]) ?? [];
+            if (frame[1] >= children.length) {
+                state.set(frame[0], 2);
+                stack.pop();
+                continue;
+            }
+            const child = children[frame[1]++];
+            if (state.get(child) === 1)
+                return true;
+            if (!state.has(child)) {
+                state.set(child, 1);
+                stack.push([child, 0]);
+            }
+        }
+    }
+    return false;
+}
+export function frontier(result) {
+    const marked = new Set(result.marked
+        .filter((item) => item.attention.some((mark) => mark.kind !== 'not-collected'))
+        .map((item) => item.nodeId));
+    const pending = new Map(result.nodes.map((id) => [id, 0]));
+    const dependents = new Map();
+    for (const edge of result.edges) {
+        pending.set(edge.from, (pending.get(edge.from) ?? 0) + 1);
+        if (!dependents.has(edge.to))
+            dependents.set(edge.to, []);
+        dependents.get(edge.to).push(edge.from);
+    }
+    // Process causal ancestors first, propagating one boolean through the DAG.
+    // This is O(nodes + edges), rather than a fresh ancestry scan per marked node.
+    const queue = [...pending].filter(([, count]) => count === 0).map(([id]) => id);
+    const earlierMark = new Set(), eligible = new Set();
+    for (let i = 0; i < queue.length; i++) {
+        const id = queue[i];
+        if (marked.has(id) && !earlierMark.has(id))
+            eligible.add(id);
+        for (const dependent of dependents.get(id) ?? []) {
+            if (marked.has(id) || earlierMark.has(id))
+                earlierMark.add(dependent);
+            const count = pending.get(dependent) - 1;
+            pending.set(dependent, count);
+            if (count === 0)
+                queue.push(dependent);
+        }
+    }
+    // Nodes left in a cycle cannot supply a validated earliest ancestor.
+    return result.marked.filter((item) => eligible.has(item.nodeId));
+}
+export function pathTo(edges, start, target) {
+    const queue = [start], previous = new Map([[start, undefined]]);
+    const next = new Map();
+    for (const edge of edges) {
+        if (!next.has(edge.from))
+            next.set(edge.from, []);
+        next.get(edge.from).push(edge.to);
+    }
+    for (let i = 0; i < queue.length; i++) {
+        const id = queue[i];
+        if (id === target)
+            break;
+        for (const child of next.get(id) ?? [])
+            if (!previous.has(child)) {
+                previous.set(child, id);
+                queue.push(child);
+            }
+    }
+    if (!previous.has(target))
+        return Object.freeze([]);
+    const path = [];
+    let id = target;
+    while (id !== undefined) {
+        path.push(id);
+        id = previous.get(id);
+    }
+    return Object.freeze(path.reverse());
+}

package/dist/esm/lib/memory/types.d.ts

@@ -2,10 +2,11 @@
  * types.ts — the record's types: a bundle, its rows, its patches, its encoding, and the
  * execution tree as the record's readers read it.
  *
- * Imports nothing. The standalone record names nothing outside itself: the engine's frame
+ * Imports only the record's leaf attention type. The record names nothing outside itself: the engine's frame
  * types — the stage snapshot, flow messages and retention dials — remain in FootPrint's
  * `frameTypes.ts`. The closed record graph is enforced by scripts/check-layering.mjs.
  */
+import type { Attention } from '../cause/types.js';
 /** A flat key-value bag representing a state patch (overwrite or merge). */
 export interface MemoryPatch {
     [key: string]: any;
@@ -194,6 +195,8 @@ export type CommitValuesMode = 'full' | 'delta';
  * ```
  */
 export interface ExecutionTree {
+    /** Optional recorded business attention; absence does not assert health. */
+    readonly attention?: readonly Attention[];
     /** The stage's id (prefixed inside a subflow). `commitStops` reads the root's to place a subflow's seed. */
     readonly id?: string;
     /** `[subflowPath/]stageId#executionIndex` — what a reader keys on. A node without one is not a stage. */

package/dist/esm/lib/memory/types.js

@@ -2,7 +2,7 @@
  * types.ts — the record's types: a bundle, its rows, its patches, its encoding, and the
  * execution tree as the record's readers read it.
  *
- * Imports nothing. The standalone record names nothing outside itself: the engine's frame
+ * Imports only the record's leaf attention type. The record names nothing outside itself: the engine's frame
  * types — the stage snapshot, flow messages and retention dials — remain in FootPrint's
  * `frameTypes.ts`. The closed record graph is enforced by scripts/check-layering.mjs.
  */

package/dist/lib/cause/admission.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spendFields = exports.boundedList = exports.boundedName = exports.ownData = exports.EvidenceRefusal = void 0;
+/** One refusal representation; subclasses preserve the graph-port and record-loader boundaries. */
+class EvidenceRefusal extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.EvidenceRefusal = EvidenceRefusal;
+/** Read data descriptors only; each boundary keeps its existing treatment of proxy traps. */
+function ownData(value, key, refuse, policy) {
+    if (!value || typeof value !== 'object')
+        throw refuse();
+    let descriptor;
+    if (policy.translateTrapErrors) {
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(value, key);
+        }
+        catch {
+            throw refuse();
+        }
+    }
+    else
+        descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor)
+        return undefined;
+    if (policy.requireOwnValue ? !Object.hasOwn(descriptor, 'value') : !('value' in descriptor))
+        throw refuse();
+    return descriptor.value;
+}
+exports.ownData = ownData;
+/** Names share one grammar, with explicit limits and the record path separator exception. */
+function boundedName(value, maximum, refuse, path = false) {
+    if (typeof value !== 'string' ||
+        !value.length ||
+        value.length > maximum ||
+        (path ? /[\u0000-\u001e\u007f-\u009f]/ : /[\u0000-\u001f\u007f-\u009f]/).test(value))
+        throw refuse();
+    return value;
+}
+exports.boundedName = boundedName;
+/** Bound iteration before reading entries, without invoking element accessors. */
+function boundedList(value, maximum, read, options) {
+    const { refuse, overflow, freeze, descriptors } = options;
+    if (!Array.isArray(value))
+        throw refuse();
+    const length = ownData(value, 'length', refuse, descriptors);
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+        throw refuse();
+    if (length > maximum)
+        throw refuse(overflow);
+    const result = [];
+    for (let index = 0; index < length; index++)
+        result.push(read(ownData(value, String(index), refuse, descriptors)));
+    return freeze ? Object.freeze(result) : result;
+}
+exports.boundedList = boundedList;
+/** Charge retained fields against the same mutable allowance across admission helpers. */
+function spendFields(budget, count, refuse) {
+    budget.left -= count;
+    if (budget.left < 0)
+        throw refuse('node-limit');
+}
+exports.spendFields = spendFields;

package/dist/lib/cause/explain.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attentionList = exports.explain = void 0;
+const session_js_1 = require("./session.js");
+const walk_js_1 = require("./walk.js");
+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);
+    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');
+        if (rank !== undefined) {
+            if (typeof rank !== 'function')
+                throw new TypeError('CAUSE_CONFIGURATION_INVALID');
+            const eligible = backward.marked.filter((item) => item.attention.some((mark) => mark.kind !== 'not-collected'));
+            const selection = await session.invoke(undefined, () => rank(Object.freeze(eligible), session.context), (raw) => (0, ranking_js_1.admitRanking)(raw, new Set(eligible.map((item) => item.nodeId)), {
+                exactPermutation: false,
+                maximum: session.limits.maxNodes,
+            }));
+            if (selection.gap)
+                missing.push(selection.gap, (0, validation_js_1.gap)('strategy-failed'));
+            else
+                candidates = [...(selection.value ?? [])];
+        }
+        const stopped = session.stopGap(nodeId);
+        if (stopped)
+            missing.push(stopped);
+        const causeComplete = missing.length === 0;
+        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');
+        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,
+                maximum: session.limits.maxNodes,
+            }));
+            if (selection.gap)
+                impactGaps.push(selection.gap, (0, validation_js_1.gap)('strategy-failed'));
+            else
+                impactNodes = selection.value ?? impactNodes;
+        }
+        const impact = Object.freeze({
+            nodes: impactNodes,
+            edges: forward.edges,
+            confidence: impactGaps.length ? 'incomplete' : 'complete',
+            gaps: (0, validation_js_1.uniqueGaps)(impactGaps),
+        });
+        const allGaps = (0, validation_js_1.uniqueGaps)([...missing, ...impactGaps]);
+        return Object.freeze({
+            nodeId,
+            attention: backward.marked.find((item) => item.nodeId === nodeId)?.attention ?? Object.freeze([]),
+            ...(rootCause ? { rootCause } : {}),
+            path: rootCause ? (0, walk_js_1.pathTo)(backward.edges, nodeId, rootCause) : Object.freeze([]),
+            alternatives: Object.freeze(rootCause ? [] : candidates),
+            impact,
+            confidence: allGaps.length ? 'incomplete' : 'complete',
+            gaps: allGaps,
+        });
+    }
+    finally {
+        session.dispose();
+    }
+}
+exports.explain = explain;
+/** Discover only bounded host seeds; this is not a global scan of arbitrary storage. */
+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 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');
+            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)));
+            return (0, validation_js_1.nodeIds)(prefix, session.limits.maxNodes);
+        };
+        if (requested !== undefined) {
+            const read = await session.invoke(undefined, () => requested, admitSeeds);
+            if (read.gap)
+                missing.push(read.gap);
+            else
+                seeds = read.value ?? [];
+        }
+        else if (session.hasRoots()) {
+            const read = await session.read('roots', undefined, admitSeeds);
+            if (read.gap)
+                missing.push(read.gap);
+            else
+                seeds = read.value ?? [];
+        }
+        else
+            missing.push((0, validation_js_1.gap)('not-collected'));
+        const result = await (0, walk_js_1.walk)(session, seeds, 'children');
+        missing = [...missing, ...result.gaps];
+        return Object.freeze({
+            nodes: result.marked,
+            confidence: missing.length ? 'incomplete' : 'complete',
+            gaps: (0, validation_js_1.uniqueGaps)(missing),
+        });
+    }
+    finally {
+        session.dispose();
+    }
+}
+exports.attentionList = attentionList;

package/dist/lib/cause/ranking.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.admitRanking = void 0;
+const validation_js_1 = require("./validation.js");
+/** Strategies may only select admitted nodes; impact ranking must preserve the full set. */
+function admitRanking(raw, allowed, options) {
+    const ids = (0, validation_js_1.nodeIds)(raw, options.maximum);
+    if ((options.exactPermutation && ids.length !== allowed.size) ||
+        new Set(ids).size !== ids.length ||
+        ids.some((id) => !allowed.has(id)))
+        throw new TypeError();
+    return ids;
+}
+exports.admitRanking = admitRanking;

package/dist/lib/cause/recordAdapter.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecordGraph = exports.createLazyRecordGraph = exports.recordOptions = void 0;
+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 recordScope_js_1 = require("./recordScope.js");
+const recordValidation_js_1 = require("./recordValidation.js");
+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);
+    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;
+        },
+        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;
+        },
+        async attention(nodeId, context) {
+            return (0, recordCoverage_js_1.attentionForRecordNode)(await resolve(nodeId, context));
+        },
+        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));
+        },
+    });
+}
+exports.createLazyRecordGraph = createLazyRecordGraph;
+/** A finished record already in memory; payload admission is lazy per requested scope. */
+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))
+                return { scope: raw };
+        }
+        throw new recordValidation_js_1.RecordRefusal('unavailable');
+    }, limits);
+}
+exports.createRecordGraph = createRecordGraph;