rea-agents 4.0.1 → 5.0.0

package/dist/domain/{javascriptSemanticProjection.js → javascript/javascriptSemanticProjection.js}

@@ -1,9 +1,11 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, semanticResolutionBlocked, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
+import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
-import { compareCodePoints, propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+import { propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (input) => {
     const { node, parent, containerScope, bodyScope, state } = input;
@@ -59,15 +61,22 @@ export const collectSemanticModuleLink = (node, state) => {
     else if (t.isAssignmentExpression(node))
         collectCommonJsExport(node, state);
 };
-/** Collect bounded lexical identifier references after definitions exist. */
-export const collectSemanticReferences = (program, state) => {
+/** Collect lexical references after definitions exist, optionally for one name. */
+export const collectSemanticReferences = (program, state, name) => {
     const output = [];
     const seen = new Set();
+    const patterns = [];
     traverseJavaScriptAst(program, {
-        enter: (node, parent, ancestors) => {
-            if (!t.isIdentifier(node) || parent === null)
+        enter: (node, parent, readAncestors) => {
+            if (isPatternNode(node))
+                patterns.push(node);
+            if (!t.isIdentifier(node) ||
+                parent === null ||
+                (name !== undefined && node.name !== name) ||
+                (isNonReferenceKey(node, parent) &&
+                    !patterns.some((pattern) => bindsIdentifier(pattern, parent, node))))
                 return;
-            const role = semanticIdentifierRole(node, parent, ancestors);
+            const role = semanticIdentifierRole(node, parent, readAncestors());
             if (role === null)
                 return;
             // A compound assignment or update reads before it writes; emit both so
@@ -96,6 +105,10 @@ export const collectSemanticReferences = (program, state) => {
                 });
             }
         },
+        exit: (node) => {
+            if (isPatternNode(node))
+                patterns.pop();
+        },
     });
     return output;
 };
@@ -123,32 +136,7 @@ export const immutableSemanticBindings = (state) => [...state.bindingsById.value
     provenance: evaluateSemanticProvenance(binding, state),
 }))
     .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
-/** Recover a literal require origin plus an optional member chain. */
-const semanticModuleOrigin = (node, projection, state) => {
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const nested = t.isNode(node.object)
-            ? semanticModuleOrigin(node.object, projection, state)
-            : undefined;
-        const member = semanticStaticPropertyName(node.property, node.computed);
-        return nested === undefined || member === ""
-            ? undefined
-            : { ...nested, importedPath: [...nested.importedPath, member] };
-    }
-    if (!t.isCallExpression(node) ||
-        !t.isIdentifier(node.callee, { name: "require" }))
-        return undefined;
-    if (resolveSemanticBindingState(state, node.callee, "require") !== undefined ||
-        semanticResolutionBlocked(state, node.callee, "require"))
-        return undefined;
-    const specifier = stringValue(node.arguments[0]);
-    return specifier === undefined || projection.includes(null)
-        ? undefined
-        : {
-            specifier,
-            importedPath: projection.map((segment) => String(segment)),
-        };
-};
-export { semanticStaticPropertyName } from "./javascriptAstValues.js";
+export { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||
@@ -173,8 +161,9 @@ const callableName = (node, parent) => {
         if (t.isPrivateName(node.key))
             return `#${node.key.id.name}`;
         // `{[key]() {}}` names nothing statically; reading `key` off the key node
-        // would report the variable name as the method name.
-        return (semanticStaticPropertyName(node.key, node.computed) ||
+        // would report the variable name as the method name. `{[""]() {}}` names
+        // the exact empty key, which is retained rather than replaced.
+        return (semanticStaticPropertyKey(node.key, node.computed) ??
             `[computed@${String(node.start ?? -1)}]`);
     }
     if (parent !== null &&
@@ -231,7 +220,7 @@ const collectNamedExports = (node, state) => {
             });
 };
 const collectRequireLink = (node, state) => {
-    const origin = semanticModuleOrigin(node.init, [], state);
+    const origin = semanticRequireOrigin(node.init, state);
     if (origin === undefined)
         return;
     for (const binding of requirePatternBindings(node.id, origin.importedPath))
@@ -255,8 +244,8 @@ const requirePatternBindings = (pattern, path) => {
         return pattern.properties.flatMap((property) => {
             if (t.isRestElement(property))
                 return [];
-            const name = semanticStaticPropertyName(property.key, property.computed);
-            return name === ""
+            const name = semanticStaticPropertyKey(property.key, property.computed);
+            return name === null
                 ? []
                 : requirePatternBindings(property.value, [...path, name]);
         });
@@ -270,7 +259,7 @@ const collectCommonJsExport = (node, state) => {
     const exportedName = commonJsExportName(node.left, state);
     if (exportedName === undefined)
         return;
-    const origin = semanticModuleOrigin(node.right, [], state);
+    const origin = semanticRequireOrigin(node.right, state);
     addModuleLink(state, {
         kind: "commonjs-export",
         specifier: origin?.specifier ?? null,
@@ -467,7 +456,7 @@ const commonJsExportName = (node, state) => {
         return "default";
     if (!t.isMemberExpression(node) && !t.isOptionalMemberExpression(node))
         return undefined;
-    const key = memberKey(node);
+    const key = semanticStaticPropertyKey(node.property, node.computed);
     // `exports[key]`/`module.exports[key]` assign an export whose name is not
     // knowable. Report the wildcard rather than the variable name, and never
     // collapse it into `default`, which would claim a real default export.
@@ -475,12 +464,11 @@ const commonJsExportName = (node, state) => {
         return key === null ? "*" : key || "*";
     if (t.isMemberExpression(node.object) &&
         isUnshadowedGlobal(node.object.object, state, "module") &&
-        memberKey(node.object) === "exports")
+        semanticStaticPropertyKey(node.object.property, node.object.computed) ===
+            "exports")
         return key === null ? "*" : key || "default";
     if (isUnshadowedGlobal(node.object, state, "module") &&
-        memberKey(node) === "exports")
+        semanticStaticPropertyKey(node.property, node.computed) === "exports")
         return "default";
     return undefined;
 };
-/** Exact member key, or null when a computed key commits no name. */
-const memberKey = (node) => semanticStaticPropertyName(node.property, node.computed) || null;

package/dist/domain/{javascriptSemanticPromises.js → javascript/javascriptSemanticPromises.js}

@@ -1,17 +1,19 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { compareCodePoints, range, sourceRangesEqual, } from "./javascriptStaticAnalysisHelpers.js";
-import { assignedSemanticResultBindings, containsSemanticNode, dataEffectMemberCallee, scalarAssignedResultBinding, } from "./javascriptSemanticDataEffectHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { assignedSemanticResultBindings, dataEffectMemberCallee, scalarAssignedResultBinding, } from "./javascriptSemanticDataEffectHelpers.js";
 /** Recover explicit Promise construction, chaining, aggregation, and ownership. */
 export const collectJavaScriptSemanticPromises = (program, state, callables) => {
     const candidates = collectCandidates(program, state, callables);
+    const returnSiteIdFor = createReturnSiteLookup(callables);
     const candidateByNode = new WeakMap();
     for (const candidate of candidates)
         candidateByNode.set(candidate.node, candidate);
     return candidates.map((candidate) => {
-        const ownership = promiseOwnership(candidate, candidateByNode, state, callables);
+        const ownership = promiseOwnership(candidate, candidateByNode, state, returnSiteIdFor);
         const sources = promiseSources(candidate, candidateByNode, state);
         return {
             promiseId: candidate.promiseId,
@@ -84,14 +86,14 @@ const isUnshadowedGlobalPromise = (node, state) => resolveSemanticBindingState(s
     !semanticResolutionBlocked(state, node, "Promise");
 const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapExpression(node), state) !== null;
 const semanticPromiseId = (kind, node) => `promise:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
-const promiseOwnership = (candidate, candidateByNode, state, callables) => {
+const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) => {
     if (candidate.kind === "awaited-expression")
         return emptyOwnership("awaited");
     const context = {
         candidate,
         candidateByNode,
         state,
-        callables,
+        returnSiteIdFor,
     };
     for (let index = candidate.ancestors.length - 1; index >= 0; index -= 1) {
         const ancestor = candidate.ancestors[index];
@@ -106,9 +108,11 @@ const promiseOwnership = (candidate, candidateByNode, state, callables) => {
     return emptyOwnership("unknown");
 };
 const ownershipAtAncestor = (ancestor, context) => {
-    const { candidate, candidateByNode, state, callables } = context;
+    const { candidate, candidateByNode, state, returnSiteIdFor } = context;
     if (t.isAwaitExpression(ancestor))
-        return emptyOwnership("awaited");
+        return unwrapExpression(ancestor.argument) === candidate.node
+            ? emptyOwnership("awaited")
+            : "boundary";
     const outer = candidateByNode.get(ancestor);
     if (outer !== undefined &&
         outer.ownerCallableId === candidate.ownerCallableId &&
@@ -116,26 +120,38 @@ const ownershipAtAncestor = (ancestor, context) => {
         return outer.kind === "chain"
             ? emptyOwnership("chained")
             : emptyOwnership("aggregated");
-    const assigned = assignedPromiseBinding(ancestor, state);
+    if (isUnmodeledCall(ancestor, outer))
+        return "boundary";
+    const assigned = assignedPromiseBinding(ancestor, candidate.node, state);
     if (assigned !== undefined)
         return {
             ownership: "assigned",
             ownerBindingId: assigned,
             returnSiteId: null,
         };
-    if (t.isReturnStatement(ancestor))
-        return returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor), callables);
+    if (t.isReturnStatement(ancestor)) {
+        if (ancestor.argument == null ||
+            unwrapExpression(ancestor.argument) !== candidate.node)
+            return "boundary";
+        return returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor), returnSiteIdFor);
+    }
     if (t.isExpressionStatement(ancestor))
-        return emptyOwnership("detached");
+        return unwrapExpression(ancestor.expression) === candidate.node
+            ? emptyOwnership("detached")
+            : "boundary";
     const callableId = semanticCallableIdForNode(ancestor);
     if (callableId === null || callableId !== candidate.ownerCallableId)
         return null;
     return t.isArrowFunctionExpression(ancestor) &&
-        ancestor.body === candidate.node
-        ? returnedPromiseOwnership(candidate.ownerCallableId, range(candidate.node), callables)
+        unwrapExpression(ancestor.body) === candidate.node
+        ? returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor.body), returnSiteIdFor)
         : "boundary";
 };
-const assignedPromiseBinding = (ancestor, state) => {
+const isUnmodeledCall = (node, candidate) => candidate === undefined &&
+    (t.isCallExpression(node) ||
+        t.isOptionalCallExpression(node) ||
+        t.isNewExpression(node));
+const assignedPromiseBinding = (ancestor, candidate, state) => {
     if (!t.isVariableDeclarator(ancestor) && !t.isAssignmentExpression(ancestor))
         return undefined;
     const source = t.isVariableDeclarator(ancestor)
@@ -143,23 +159,28 @@ const assignedPromiseBinding = (ancestor, state) => {
         : ancestor.right;
     if (source == null)
         return undefined;
+    if (unwrapExpression(source) !== candidate)
+        return undefined;
     return scalarAssignedResultBinding(assignedSemanticResultBindings(source, [ancestor], state));
 };
-const returnedPromiseOwnership = (callableId, location, callables) => ({
+const returnedPromiseOwnership = (callableId, location, returnSiteIdFor) => ({
     ownership: "returned",
     ownerBindingId: null,
-    returnSiteId: matchingReturnSite(callableId, location, callables),
+    returnSiteId: returnSiteIdFor(callableId, location),
 });
 const outerConsumesCandidate = (outer, candidate) => {
     if (outer.kind === "chain" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
         const member = dataEffectMemberCallee(outer.node);
-        return (member !== null && containsSemanticNode(member.object, candidate.node));
+        return (member !== null && unwrapExpression(member.object) === candidate.node);
     }
     if (outer.kind === "aggregate" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
         const input = outer.node.arguments[0];
-        return t.isNode(input) && containsSemanticNode(input, candidate.node);
+        return (t.isArrayExpression(input) &&
+            input.elements.some((element) => element !== null &&
+                !t.isSpreadElement(element) &&
+                unwrapExpression(element) === candidate.node));
     }
     return false;
 };
@@ -168,9 +189,44 @@ const emptyOwnership = (ownership) => ({
     ownerBindingId: null,
     returnSiteId: null,
 });
-const matchingReturnSite = (callableId, location, callables) => callables
-    .find(({ callableId: candidate }) => candidate === callableId)
-    ?.returnSites.find(({ location: candidate }) => sourceRangesEqual(candidate, location))?.returnSiteId ?? null;
+const indexReturnSites = (callable) => {
+    const output = new Map();
+    for (const site of callable.returnSites) {
+        const key = returnSiteKey(site.location);
+        if (!output.has(key))
+            output.set(key, site.returnSiteId);
+    }
+    return output;
+};
+const createReturnSiteLookup = (callables) => {
+    let callablesById;
+    let returnSiteIdsByCallable;
+    return (callableId, location) => {
+        if (callableId === null)
+            return null;
+        callablesById ??= indexCallablesById(callables);
+        const callable = callablesById.get(callableId);
+        if (callable === undefined)
+            return null;
+        returnSiteIdsByCallable ??= new Map();
+        let returnSiteIds = returnSiteIdsByCallable.get(callableId);
+        if (returnSiteIds === undefined) {
+            returnSiteIds = indexReturnSites(callable);
+            returnSiteIdsByCallable.set(callableId, returnSiteIds);
+        }
+        return returnSiteIds.get(returnSiteKey(location)) ?? null;
+    };
+};
+const indexCallablesById = (callables) => {
+    const output = new Map();
+    for (const callable of callables) {
+        if (output.has(callable.callableId))
+            continue;
+        output.set(callable.callableId, callable);
+    }
+    return output;
+};
+const returnSiteKey = (location) => `${location.start.line}:${location.start.column}:${location.end.line}:${location.end.column}`;
 const promiseSources = (candidate, candidateByNode, state) => {
     if (candidate.kind === "chain") {
         const member = t.isCallExpression(candidate.node) ||

package/dist/domain/{javascriptSemanticProvenance.js → javascript/javascriptSemanticProvenance.js}

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./javascriptStaticAnalysisHelpers.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 /** Construct exact local provenance without inventing module origins. */
 export const semanticLocalProvenance = () => ({
     status: "local",
@@ -24,3 +24,6 @@ export const uniqueSemanticOrigins = (origins) => [
 const semanticOriginKey = (origin) => `${origin.specifier}\0${origin.importedPath.join("\0")}`;
 /** 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. */
+export const semanticBuiltinNamespacePath = (importedPath) => importedPath.length === 0 ||
+    (importedPath.length === 1 && importedPath[0] === "default");

package/dist/domain/{javascriptSemanticQuery.js → javascript/javascriptSemanticQuery.js}

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { isJavaScriptSemanticOwnershipRelation as ownershipRelation } from "./javascriptSemanticQueryRelations.js";
 import { javaScriptSemanticQueryInputSchema, javaScriptSemanticQueryResultSchema, } from "./javascriptSemanticQuerySchemas.js";
 import { assessJavaScriptSemanticQuery } from "./javascriptSemanticQueryAssessment.js";
@@ -153,13 +153,12 @@ const relevantUnknownFrontiers = (graph, nodeIds, input) => {
             unknown.relation_kinds.some((relation) => allowed.has(relation))));
 };
 const relevantCandidateRelationCount = (graph, nodeIds, input) => {
-    const allowed = input.allowed_relations === undefined
-        ? null
-        : new Set(input.allowed_relations);
-    return graph.relations.filter((relation) => relation.resolution === "candidate" &&
-        (allowed === null || allowed.has(relation.relation)) &&
-        (nodeIds.has(relation.source_node_id) ||
-            nodeIds.has(relation.target_node_id))).length;
+    const adjacency = buildAdjacency(graph.relations.filter(({ resolution }) => resolution === "candidate"), { ...input, include_ambiguous_dynamic_edges: true });
+    const relevant = new Set();
+    for (const nodeId of nodeIds)
+        for (const { relation } of adjacency.get(nodeId) ?? [])
+            relevant.add(relation.relation_id);
+    return relevant.size;
 };
 const expectedMatchesFor = (nodes, relations, input) => {
     if (input.expected === null)

package/dist/domain/{javascriptSemanticQueryAssessment.js → javascript/javascriptSemanticQueryAssessment.js}

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
 /** Classify a complete semantic traversal without promoting unknowns to absence. */
 export const assessJavaScriptSemanticQuery = (input) => ({
     status: queryStatus(input),
@@ -43,4 +43,3 @@ const queryLimitations = (input) => uniqueSorted([
             "Candidate relations remain ambiguous and do not establish a resolved semantic path.",
         ]),
 ]);
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

package/dist/domain/{javascriptSemanticQueryIdentity.js → javascript/javascriptSemanticQueryIdentity.js}

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Canonical JSON used by semantic query commitments and ordering. */
 export const canonicalJavaScriptSemanticQueryJson = (value) => {
     const encoded = canonicalize(value);
@@ -11,7 +11,6 @@ export const canonicalJavaScriptSemanticQueryJson = (value) => {
 const digest = (value) => createHash("sha256")
     .update(canonicalJavaScriptSemanticQueryJson(value))
     .digest("hex");
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);
 /** Derive the stable identity for one graph-bound query. */
 export const javaScriptSemanticQueryIdentifier = (graph, input) => {
     const semantic = input;

package/dist/domain/{javascriptSemanticQuerySchemas.js → javascript/javascriptSemanticQuerySchemas.js}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
-import { jsonValueSchema } from "./jsonValue.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { jsonValueSchema } from "../jsonValue.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
 const literalSeedSchema = z.strictObject({
     kind: z.literal("literal"),

package/dist/domain/javascript/javascriptSemanticRequireOrigin.js

@@ -0,0 +1,25 @@
+import * as t from "@babel/types";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { semanticStaticPropertyKey } 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))
+            return undefined;
+        members.push(member);
+        node = node.object;
+    }
+    if (!t.isCallExpression(node) ||
+        !t.isIdentifier(node.callee, { name: "require" }))
+        return undefined;
+    if (resolveSemanticBindingState(state, node.callee, "require") !== undefined ||
+        semanticResolutionBlocked(state, node.callee, "require"))
+        return undefined;
+    const specifier = stringValue(node.arguments[0]);
+    return specifier === undefined
+        ? undefined
+        : { specifier, importedPath: members.reverse() };
+};

package/dist/domain/{javascriptSemanticResources.js → javascript/javascriptSemanticResources.js}

@@ -1,4 +1,5 @@
 import * as t from "@babel/types";
+import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
 import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { dataEffectMemberCallee, outerDataEffectBinding, traverseDataEffects, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -114,7 +115,7 @@ const methodFromBinding = (binding) => {
     }
     return null;
 };
-const resourceNamespace = (binding) => binding?.directOrigins.some(({ specifier, importedPath }) => resourceModule(specifier) && importedPath.length === 0) ?? false;
+const resourceNamespace = (binding) => binding?.directOrigins.some(({ specifier, importedPath }) => resourceModule(specifier) && semanticBuiltinNamespacePath(importedPath)) ?? false;
 const resourceModule = (specifier) => [
     "fs",
     "fs/promises",

package/dist/domain/{javascriptSemanticReturns.js → javascript/javascriptSemanticReturns.js}

@@ -1,8 +1,9 @@
 import * as t from "@babel/types";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { evaluateSemanticExpression } from "./javascriptSemanticValues.js";
-import { compareCodePoints, range } from "./javascriptStaticAnalysisHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { semanticReturnCoverage } from "./javascriptSemanticCoverage.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 /** Evaluate direct returns while excluding every nested callable. */

package/dist/domain/{javascriptSemanticTraceSchemas.js → javascript/javascriptSemanticTraceSchemas.js}

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { evidenceSchema } from "./evidence.js";
+import { evidenceSchema } from "../evidence.js";
 import { javaScriptSemanticQueryInputSchema, javaScriptSemanticQueryResultSchema, } from "./javascriptSemanticQuerySchemas.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 /** Authenticated application Evidence plus one bounded semantic query. */
 export const traceJavaScriptSemanticsInputSchema = z.strictObject({

package/dist/domain/javascript/javascriptSemanticTraversal.js

@@ -0,0 +1,55 @@
+import * as t from "@babel/types";
+/**
+ * Visit every Babel AST node in deterministic source-tree order.
+ *
+ * `readAncestors` returns a snapshot during `enter`, outermost-first and
+ * ending with the direct parent. Callers
+ * need it whenever meaning depends on where a node sits, not just what its
+ * immediate parent is — a binding inside `catch ({message})` or `({a} = o)`
+ * has an ObjectProperty parent, so the parent alone cannot say whether the
+ * identifier declares a binding or is assigned to.
+ */
+export const traverseJavaScriptAst = (root, visitor) => {
+    const ancestors = [];
+    const enter = (node, parent) => {
+        visitor.enter(node, parent, () => [...ancestors]);
+        ancestors.push(node);
+        return { node, parent, children: childNodes(node), nextIndex: 0 };
+    };
+    const pending = [enter(root, null)];
+    while (pending.length > 0) {
+        const current = pending.at(-1);
+        if (current === undefined)
+            break;
+        const child = current.children[current.nextIndex];
+        if (child !== undefined) {
+            current.nextIndex += 1;
+            pending.push(enter(child, current.node));
+        }
+        else {
+            visitor.exit?.(current.node, current.parent);
+            ancestors.pop();
+            pending.pop();
+        }
+    }
+};
+const childNodes = (node) => {
+    const keys = t.VISITOR_KEYS[node.type];
+    if (keys === undefined)
+        return [];
+    const children = [];
+    for (const key of keys) {
+        const value = Reflect.get(node, key);
+        if (t.isNode(value)) {
+            children.push(value);
+            continue;
+        }
+        if (!Array.isArray(value))
+            continue;
+        for (const item of value) {
+            if (t.isNode(item))
+                children.push(item);
+        }
+    }
+    return children;
+};

package/dist/domain/javascript/javascriptSemanticValueTypes.js

@@ -0,0 +1 @@
+export {};