rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptSemanticPromises.js

@@ -1,7 +1,8 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { assignedSemanticResultBindings, dataEffectMemberCallee, scalarAssignedResultBinding, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -22,7 +23,7 @@ export const collectJavaScriptSemanticPromises = (program, state, callables) =>
             location: range(candidate.node),
             ownerCallableId: candidate.ownerCallableId,
             ...ownership,
-            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareCodePoints),
+            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareUnicodeCodePoints),
             sourceResolution: sources.status,
         };
     });
@@ -84,7 +85,8 @@ const promiseCandidateDetails = (node, state) => {
 };
 const isUnshadowedGlobalPromise = (node, state) => resolveSemanticBindingState(state, node, "Promise") === undefined &&
     !semanticResolutionBlocked(state, node, "Promise");
-const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapExpression(node), state) !== null;
+const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapJavaScriptExpression(node).node, state) !==
+    null;
 const semanticPromiseId = (kind, node) => `promise:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
 const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) => {
     if (candidate.kind === "awaited-expression")
@@ -110,7 +112,7 @@ const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) =>
 const ownershipAtAncestor = (ancestor, context) => {
     const { candidate, candidateByNode, state, returnSiteIdFor } = context;
     if (t.isAwaitExpression(ancestor))
-        return unwrapExpression(ancestor.argument) === candidate.node
+        return unwrapJavaScriptExpression(ancestor.argument).node === candidate.node
             ? emptyOwnership("awaited")
             : "boundary";
     const outer = candidateByNode.get(ancestor);
@@ -131,19 +133,20 @@ const ownershipAtAncestor = (ancestor, context) => {
         };
     if (t.isReturnStatement(ancestor)) {
         if (ancestor.argument == null ||
-            unwrapExpression(ancestor.argument) !== candidate.node)
+            unwrapJavaScriptExpression(ancestor.argument).node !== candidate.node)
             return "boundary";
         return returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor), returnSiteIdFor);
     }
     if (t.isExpressionStatement(ancestor))
-        return unwrapExpression(ancestor.expression) === candidate.node
+        return unwrapJavaScriptExpression(ancestor.expression).node ===
+            candidate.node
             ? emptyOwnership("detached")
             : "boundary";
     const callableId = semanticCallableIdForNode(ancestor);
     if (callableId === null || callableId !== candidate.ownerCallableId)
         return null;
     return t.isArrowFunctionExpression(ancestor) &&
-        unwrapExpression(ancestor.body) === candidate.node
+        unwrapJavaScriptExpression(ancestor.body).node === candidate.node
         ? returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor.body), returnSiteIdFor)
         : "boundary";
 };
@@ -159,7 +162,7 @@ const assignedPromiseBinding = (ancestor, candidate, state) => {
         : ancestor.right;
     if (source == null)
         return undefined;
-    if (unwrapExpression(source) !== candidate)
+    if (unwrapJavaScriptExpression(source).node !== candidate)
         return undefined;
     return scalarAssignedResultBinding(assignedSemanticResultBindings(source, [ancestor], state));
 };
@@ -172,7 +175,8 @@ const outerConsumesCandidate = (outer, candidate) => {
     if (outer.kind === "chain" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
         const member = dataEffectMemberCallee(outer.node);
-        return (member !== null && unwrapExpression(member.object) === candidate.node);
+        return (member !== null &&
+            unwrapJavaScriptExpression(member.object).node === candidate.node);
     }
     if (outer.kind === "aggregate" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
@@ -180,7 +184,7 @@ const outerConsumesCandidate = (outer, candidate) => {
         return (t.isArrayExpression(input) &&
             input.elements.some((element) => element !== null &&
                 !t.isSpreadElement(element) &&
-                unwrapExpression(element) === candidate.node));
+                unwrapJavaScriptExpression(element).node === candidate.node));
     }
     return false;
 };
@@ -265,7 +269,7 @@ const aggregateSources = (candidate, candidateByNode, state) => {
 };
 const resolvePromiseExpression = (rawNode, context) => {
     const { current, candidateByNode, state, seenBindings } = context;
-    const node = unwrapExpression(rawNode);
+    const node = unwrapJavaScriptExpression(rawNode).node;
     const direct = candidateByNode.get(node);
     if (direct !== undefined && direct.promiseId !== current.promiseId)
         return { promiseIds: [direct.promiseId], status: "complete" };
@@ -293,15 +297,6 @@ const promiseResolutionContext = (current, candidateByNode, state) => ({
     state,
     seenBindings: new Set(),
 });
-const unwrapExpression = (node) => {
-    if (t.isParenthesizedExpression(node) ||
-        t.isTSAsExpression(node) ||
-        t.isTSSatisfiesExpression(node) ||
-        t.isTSNonNullExpression(node) ||
-        t.isTypeCastExpression(node))
-        return unwrapExpression(node.expression);
-    return node;
-};
 const combinePromiseResolutions = (resolutions) => ({
     promiseIds: resolutions.flatMap(({ promiseIds }) => promiseIds),
     status: resolutions.some(({ status }) => status === "unresolved")

package/dist/domain/javascript/javascriptSemanticPropertyPaths.js

@@ -0,0 +1,23 @@
+/** Read only canonical JavaScript array indices, excluding named properties. */
+export const semanticArrayIndex = (key) => {
+    const index = Number(key);
+    return Number.isInteger(index) &&
+        index >= 0 &&
+        index < 4_294_967_295 &&
+        String(index) === String(key)
+        ? index
+        : null;
+};
+/** Test an exact key, wildcard, or copied-slot selection against an own key. */
+export const semanticPropertyPathKeyMatches = (key, name) => {
+    if (key === null)
+        return true;
+    if (typeof key !== "object")
+        return String(key) === name;
+    if (key.excludedKeys.includes(name))
+        return false;
+    if (key.startIndex === undefined)
+        return true;
+    const index = semanticArrayIndex(name);
+    return index !== null && index >= key.startIndex;
+};

package/dist/domain/javascript/javascriptSemanticProvenance.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Construct exact local provenance without inventing module origins. */
 export const semanticLocalProvenance = () => ({
     status: "local",
@@ -20,8 +20,8 @@ export const semanticOriginsProvenance = (origins) => {
 /** Deduplicate and canonically order module origins. */
 export const uniqueSemanticOrigins = (origins) => [
     ...new Map(origins.map((origin) => [semanticOriginKey(origin), origin])).values(),
-].sort((left, right) => compareCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
-const semanticOriginKey = (origin) => `${origin.specifier}\0${origin.importedPath.join("\0")}`;
+].sort((left, right) => compareUnicodeCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
+const semanticOriginKey = (origin) => JSON.stringify([origin.specifier, origin.importedPath]);
 /** Canonically distinguish primitive values across type boundaries. */
 export const semanticPrimitiveKey = (value) => `${value === null ? "null" : typeof value}:${JSON.stringify(value)}`;
 /** Match namespace paths only after the caller has identified a Node built-in. */

package/dist/domain/javascript/javascriptSemanticQuery.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { isJavaScriptSemanticOwnershipRelation as ownershipRelation } from "./javascriptSemanticQueryRelations.js";
 import { javaScriptSemanticQueryInputSchema, javaScriptSemanticQueryResultSchema, } from "./javascriptSemanticQuerySchemas.js";
 import { assessJavaScriptSemanticQuery } from "./javascriptSemanticQueryAssessment.js";
@@ -17,6 +17,11 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
     const relevantUnknowns = allRelevantUnknowns;
     const candidateRelations = relevantCandidateRelationCount(graph, traversal.nodeIds, input);
     const expectedMatches = expectedMatchesFor(result.retainedNodes, result.retainedRelations, input);
+    const retainedContextIds = new Set([
+        ...result.retainedNodes.map(({ evidence }) => evidence.context_id),
+        ...result.retainedRelations.map(({ evidence }) => evidence.context_id),
+        ...relevantUnknowns.map(({ evidence }) => evidence.context_id),
+    ]);
     const assessment = assessJavaScriptSemanticQuery({
         graph,
         totalSeeds: seeds.length,
@@ -32,6 +37,7 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
         direction: input.direction,
         status: assessment.status,
         seed_node_ids: retainedSeeds,
+        evidence_contexts: graph.evidence_contexts.filter(({ context_id }) => retainedContextIds.has(context_id)),
         nodes: result.retainedNodes,
         relations: result.retainedRelations,
         unknowns: relevantUnknowns,
@@ -78,7 +84,7 @@ const buildAdjacency = (relations, input) => {
         addDirectedEntries(adjacency, relation, input.direction);
     }
     for (const entries of adjacency.values())
-        entries.sort((left, right) => compareCodePoints(`${left.relation.relation_id}\0${left.nextNodeId}`, `${right.relation.relation_id}\0${right.nextNodeId}`));
+        entries.sort((left, right) => compareUnicodeCodePoints(`${left.relation.relation_id}\0${left.nextNodeId}`, `${right.relation.relation_id}\0${right.nextNodeId}`));
     return adjacency;
 };
 const addDirectedEntries = (adjacency, relation, direction) => {

package/dist/domain/javascript/javascriptSemanticQueryIdentity.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Canonical JSON used by semantic query commitments and ordering. */
 export const canonicalJavaScriptSemanticQueryJson = (value) => {
     const encoded = canonicalize(value);
@@ -39,7 +40,7 @@ export const resolveJavaScriptSemanticQuerySeeds = (graph, input) => {
     return graph.nodes
         .filter((node) => seedMatches(node, input, fingerprintFunctions))
         .map(({ node_id }) => node_id)
-        .sort(compareCodePoints);
+        .sort(compareUnicodeCodePoints);
 };
 const seedMatches = (node, input, fingerprintFunctions) => {
     const seed = input.seed;

package/dist/domain/javascript/javascriptSemanticQuerySchemas.js

@@ -1,16 +1,14 @@
 import { z } from "zod";
-import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
-import { jsonValueSchema } from "../jsonValue.js";
+import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
 import { digestSchema } from "../digests.js";
 import { prefixedDigestSchema } from "../digests.js";
 const semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
-const literalValueSchema = jsonValueSchema.refine((value) => value === null ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean", "Literal seeds accept only JSON primitive values");
-// Zod derivations drop the shared schema's JSON Schema projection override;
-// re-apply it so MCP catalog generation keeps projecting `{}`.
-literalValueSchema._zod.toJSONSchema = () => ({});
+const literalValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
 const literalSeedSchema = z.strictObject({
     kind: z.literal("literal"),
     value: literalValueSchema,
@@ -77,6 +75,7 @@ export const javaScriptSemanticQueryResultSchema = z.strictObject({
     direction: javaScriptSemanticQueryInputSchema.shape.direction,
     status: z.enum(["found", "no-match", "ambiguous", "partial", "unsupported"]),
     seed_node_ids: z.array(semanticNodeIdSchema),
+    evidence_contexts: z.array(javaScriptSemanticEvidenceContextSchema),
     nodes: z.array(javaScriptSemanticNodeSchema),
     relations: z.array(javaScriptSemanticRelationSchema),
     unknowns: z.array(javaScriptSemanticUnknownSchema),

package/dist/domain/javascript/javascriptSemanticRequireOrigin.js

@@ -1,24 +1,30 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover an unshadowed literal require origin and its exact member path. */
 export const semanticRequireOrigin = (node, state) => {
     const members = [];
-    while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const member = semanticStaticPropertyKey(node.property, node.computed);
-        if (member === null || !t.isNode(node.object))
+    let current = node;
+    while (current !== null && current !== undefined) {
+        current = unwrapJavaScriptExpression(current).node;
+        if (!t.isMemberExpression(current) &&
+            !t.isOptionalMemberExpression(current))
+            break;
+        const member = semanticStaticPropertyKey(current.property, current.computed);
+        if (member === null || !t.isNode(current.object))
             return undefined;
         members.push(member);
-        node = node.object;
+        current = current.object;
     }
-    if (!t.isCallExpression(node) ||
-        !t.isIdentifier(node.callee, { name: "require" }))
+    if (!t.isCallExpression(current) ||
+        !t.isIdentifier(current.callee, { name: "require" }))
         return undefined;
-    if (resolveSemanticBindingState(state, node.callee, "require") !== undefined ||
-        semanticResolutionBlocked(state, node.callee, "require"))
+    if (resolveSemanticBindingState(state, current.callee, "require") !==
+        undefined ||
+        semanticResolutionBlocked(state, current.callee, "require"))
         return undefined;
-    const specifier = stringValue(node.arguments[0]);
+    const specifier = stringValue(current.arguments[0]);
     return specifier === undefined
         ? undefined
         : { specifier, importedPath: members.reverse() };

package/dist/domain/javascript/javascriptSemanticResourceLimits.js

@@ -69,7 +69,7 @@ export const semanticResourceLimitsIn = (values) => {
                 pending.push(property.value);
         else if (value.status === "array")
             for (const item of value.items)
-                pending.push(item);
+                pending.push(item.value);
     }
     return [...found].sort();
 };

package/dist/domain/javascript/javascriptSemanticResources.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { dataEffectMemberCallee, outerDataEffectBinding, traverseDataEffects, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";

package/dist/domain/javascript/javascriptSemanticReturns.js

@@ -1,11 +1,13 @@
 import * as t from "@babel/types";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { semanticContainer, semanticPropertyPointer, } from "./javascriptSemanticSlots.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { unwrapJavaScriptExpression } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { evaluateSemanticExpression } from "./javascriptSemanticValues.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { semanticReturnCoverage } from "./javascriptSemanticCoverage.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { childNodes, traverseJavaScriptAst, } from "./javascriptSemanticTraversal.js";
 /** Evaluate direct returns while excluding every nested callable. */
 export const collectSemanticReturns = (program, state, parserPartial) => {
     const nodes = callableNodes(program);
@@ -45,16 +47,14 @@ const semanticReturnSiteId = (callableId, location) => `${callableId}:return:${S
 /** Link exports to callables only when lexical resolution is unique and exact. */
 export const resolveSemanticModuleCallables = (state, callables) => {
     const callableIds = new Set(callables.map(({ callableId }) => callableId));
-    const root = state.scopes.find(({ kind }) => kind === "program");
     return state.moduleLinks.map((link) => {
-        if (link.callableId !== null && callableIds.has(link.callableId))
-            return link;
-        if (link.localName === null || root === undefined)
-            return { ...link, callableId: null };
-        const named = callables.filter(({ name, containerScopeId }) => name === link.localName && containerScopeId === root.scopeId);
-        if (named.length === 1)
-            return { ...link, callableId: named[0]?.callableId ?? null };
-        const binding = root.bindings.get(link.localName);
+        // Named exports follow their lexical binding, including every assignment.
+        // A declaration's ID or a callable's display name cannot prove that link.
+        if (link.localName === null)
+            return link.callableId !== null && callableIds.has(link.callableId)
+                ? link
+                : { ...link, callableId: null };
+        const binding = state.moduleLinkBindings.get(link);
         const resolved = binding === undefined
             ? []
             : callableIdsForBinding(binding, state, callableIds, new Set());
@@ -96,23 +96,24 @@ const directReturnExpressions = (callable) => {
         visit(child);
     return output;
 };
-const childNodes = (node) => (t.VISITOR_KEYS[node.type] ?? []).flatMap((key) => {
-    const value = Reflect.get(node, key);
-    if (t.isNode(value))
-        return [value];
-    return Array.isArray(value)
-        ? value.filter((item) => t.isNode(item))
-        : [];
-});
 const callableIdsForBinding = (binding, state, admitted, seen) => {
-    if (seen.has(binding.bindingId) || binding.initializers.length !== 1)
+    // A single initializer does not prove an assignment executes or replace
+    // the unknown incoming value of a parameter/catch binding.
+    if (seen.has(binding.bindingId) ||
+        binding.initializers.length !== 1 ||
+        binding.definitions.some(({ kind }) => kind === "assignment" || kind === "parameter" || kind === "catch"))
         return [];
     const initializer = binding.initializers[0];
-    if (initializer === undefined || initializer.projection.length > 0)
+    if (initializer === undefined ||
+        initializer.projection.length > 0 ||
+        state.conditionalInitializers.has(initializer.node))
         return [];
     return callableIdsForNode(initializer.node, state, admitted, new Set([...seen, binding.bindingId]));
 };
 const callableIdsForNode = (node, state, admitted, seen) => {
+    const unwrapped = unwrapJavaScriptExpression(node).node;
+    if (unwrapped !== node)
+        return callableIdsForNode(unwrapped, state, admitted, seen);
     const direct = semanticCallableIdForNode(node);
     if (direct !== null && admitted.has(direct))
         return [direct];
@@ -122,10 +123,6 @@ const callableIdsForNode = (node, state, admitted, seen) => {
             ? []
             : callableIdsForBinding(binding, state, admitted, seen);
     }
-    if (t.isTSAsExpression(node) ||
-        t.isTSTypeAssertion(node) ||
-        t.isTSNonNullExpression(node))
-        return callableIdsForNode(node.expression, state, admitted, seen);
     return [];
 };
 /** Flatten a semantic value to bounded JSON-pointer leaves for graph projection. */
@@ -133,39 +130,53 @@ export const flattenSemanticReturnValue = (value) => {
     const fields = [];
     const propertyCoverage = [];
     flattenValue(value, "", fields, propertyCoverage);
-    fields.sort((left, right) => compareCodePoints(left.path, right.path));
-    propertyCoverage.sort((left, right) => compareCodePoints(left.path, right.path));
+    fields.sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
+    propertyCoverage.sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
     return { fields, propertyCoverage };
 };
-const flattenValue = (value, path, fields, coverage) => {
+const flattenValue = (value, path, fields, coverage, presence = "present") => {
+    if (presence !== "present") {
+        fields.push({
+            path,
+            presence,
+            state: "unknown",
+            value: null,
+            reason: "reason" in value ? value.reason : "Property presence is uncertain.",
+        });
+        return;
+    }
     if (value.status === "literal") {
-        fields.push({ path, state: "literal", value: value.value, reason: null });
+        fields.push({
+            path,
+            presence,
+            state: "literal",
+            value: value.value,
+            reason: null,
+        });
         return;
     }
     if (value.status === "union") {
         fields.push({
             path,
+            presence,
             state: "union",
             value: [...value.values],
             reason: null,
         });
         return;
     }
-    if (value.status === "object") {
-        coverage.push(value.unknownProperties
-            ? { path, status: "partial", omitted: value.omittedProperties }
-            : { path, status: "complete", omitted: 0 });
-        for (const property of value.properties)
-            flattenValue(property.value, `${path}/${escapePointer(property.name)}`, fields, coverage);
-        return;
-    }
-    if (value.status === "array") {
-        coverage.push(value.unknownItems
-            ? { path, status: "partial", omitted: value.omittedItems }
-            : { path, status: "complete", omitted: 0 });
-        value.items.forEach((item, index) => flattenValue(item, `${path}/${String(index)}`, fields, coverage));
+    if ("reason" in value) {
+        fields.push({
+            path,
+            presence,
+            state: "unknown",
+            value: null,
+            reason: value.reason,
+        });
         return;
     }
-    fields.push({ path, state: "unknown", value: null, reason: value.reason });
+    const container = semanticContainer(value);
+    coverage.push({ path, ...container.coverage });
+    for (const slot of container.slots)
+        flattenValue(slot.value, `${path}${semanticPropertyPointer([slot.name])}`, fields, coverage, slot.presence);
 };
-const escapePointer = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");

package/dist/domain/javascript/javascriptSemanticSlots.js

@@ -0,0 +1,72 @@
+export function semanticContainer(value) {
+    if (value.status === "object")
+        return {
+            slots: value.properties,
+            coverage: value.unknownProperties
+                ? { status: "partial", omitted: value.omittedProperties }
+                : { status: "complete", omitted: 0 },
+        };
+    if (value.status === "array")
+        return {
+            slots: value.items,
+            coverage: value.unknownItems
+                ? { status: "partial", omitted: value.omittedItems }
+                : { status: "complete", omitted: 0 },
+        };
+    return null;
+}
+/** Resolve a full static own-property path without conflating missing siblings. */
+export const semanticSlotAtPath = (value, path) => {
+    const leafName = path.at(-1) ?? "";
+    let current = {
+        name: "",
+        presence: "present",
+        value,
+    };
+    for (const [index, name] of path.entries()) {
+        const container = semanticContainer(current.value);
+        if (current.presence !== "present" || container === null)
+            return {
+                name: leafName,
+                presence: "unknown-coverage",
+                value: "reason" in current.value
+                    ? {
+                        ...current.value,
+                        reason: `${current.value.reason} Cannot continue ${semanticPropertyPointer(path)} through receiver ${semanticPropertyPointer(path.slice(0, index))}.`,
+                    }
+                    : {
+                        status: "unknown",
+                        reason: `Cannot resolve ${semanticPropertyPointer(path)} through ${current.value.status} receiver ${semanticPropertyPointer(path.slice(0, index))}.`,
+                    },
+            };
+        // Array position inventories omit the intrinsic non-enumerable length slot.
+        // Its own presence is guaranteed even when no exact length is retained.
+        if (current.value.status === "array" && name === "length") {
+            current = {
+                name,
+                presence: "present",
+                value: {
+                    status: "unknown",
+                    reason: "Array length is present but its value is not retained.",
+                },
+            };
+            continue;
+        }
+        const observed = container.slots.find((slot) => slot.name === name);
+        current = observed ?? {
+            name,
+            presence: container.coverage.status === "complete"
+                ? "absent"
+                : "unknown-coverage",
+            value: {
+                status: "unknown",
+                reason: `Own property ${name} was not observed.`,
+            },
+        };
+    }
+    return current;
+};
+/** Encode path segments as an unambiguous JSON Pointer, preserving empty keys. */
+export const semanticPropertyPointer = (path) => path
+    .map((key) => `/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`)
+    .join("");

package/dist/domain/javascript/javascriptSemanticTraversal.js

@@ -33,7 +33,12 @@ export const traverseJavaScriptAst = (root, visitor) => {
         }
     }
 };
-const childNodes = (node) => {
+/**
+ * Child Babel nodes in `VISITOR_KEYS` order. Single owner for AST child
+ * expansion; bespoke `Object.values` / duplicated `childNodes` walkers must
+ * not be reintroduced (they diverge on loc/comment fields and ordering).
+ */
+export const childNodes = (node) => {
     const keys = t.VISITOR_KEYS[node.type];
     if (keys === undefined)
         return [];