rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptSemanticMutationInitializers.js

@@ -0,0 +1,190 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+const statementPosition = (statement, parents, declarator) => {
+    const parent = parents.get(statement);
+    if (!t.isProgram(parent) && !t.isBlockStatement(parent))
+        return null;
+    const index = parent.body.indexOf(statement);
+    return index < 0
+        ? null
+        : {
+            body: parent.body,
+            index,
+            declaratorIndex: t.isVariableDeclaration(statement) && declarator !== undefined
+                ? statement.declarations.indexOf(declarator)
+                : -1,
+        };
+};
+const positionPrecedes = (left, right) => left.body === right.body &&
+    (left.index < right.index ||
+        (left.index === right.index &&
+            left.declaratorIndex >= 0 &&
+            left.declaratorIndex < right.declaratorIndex));
+const directInitializerPosition = (node, parents) => {
+    const parent = parents.get(node);
+    if (t.isVariableDeclarator(parent) && parent.init === node) {
+        const declaration = parents.get(parent);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents, parent)
+            : null;
+    }
+    if (t.isAssignmentExpression(parent) &&
+        parent.operator === "=" &&
+        parent.right === node &&
+        t.isIdentifier(parent.left)) {
+        const statement = parents.get(parent);
+        return t.isExpressionStatement(statement) && statement.expression === parent
+            ? statementPosition(statement, parents)
+            : null;
+    }
+    return null;
+};
+const directMutationPosition = (node, parents) => {
+    if (t.isForOfStatement(node))
+        return statementPosition(node, parents);
+    if (t.isVariableDeclarator(node)) {
+        const declaration = parents.get(node);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents, node)
+            : null;
+    }
+    if (t.isSpreadElement(node)) {
+        const array = parents.get(node);
+        return t.isArrayExpression(array)
+            ? semanticCapturePosition(array, parents)
+            : null;
+    }
+    if (!t.isAssignmentExpression(node) &&
+        !t.isUpdateExpression(node) &&
+        !t.isUnaryExpression(node, { operator: "delete" }) &&
+        !t.isCallExpression(node) &&
+        !t.isOptionalCallExpression(node) &&
+        !t.isNewExpression(node) &&
+        !t.isTaggedTemplateExpression(node))
+        return null;
+    let current = node;
+    while (true) {
+        const parent = parents.get(current);
+        if (parent === undefined ||
+            t.isFunction(parent) ||
+            (t.isLogicalExpression(parent) && parent.right === current) ||
+            (t.isConditionalExpression(parent) && parent.test !== current))
+            return null;
+        if (t.isStatement(parent))
+            return statementPosition(parent, parents);
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            return t.isVariableDeclaration(declaration)
+                ? statementPosition(declaration, parents, parent)
+                : null;
+        }
+        current = parent;
+    }
+};
+const referenceInitializerPosition = (node, parents) => {
+    // Defaults live inside the declaration pattern rather than its initializer.
+    let current = node;
+    while (true) {
+        const direct = directInitializerPosition(current, parents);
+        if (direct !== null)
+            return direct;
+        const parent = parents.get(current);
+        if (parent === undefined || t.isStatement(parent) || t.isFunction(parent))
+            return null;
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            return t.isVariableDeclaration(declaration)
+                ? statementPosition(declaration, parents, parent)
+                : null;
+        }
+        current = parent;
+    }
+};
+/** Resolve origins at their use or capture, never at a later transitive effect. */
+export const semanticMutationInitializers = (binding, mutation, parents) => {
+    const mutationPosition = directMutationPosition(mutation, parents) ??
+        referenceInitializerPosition(mutation, parents);
+    if (mutationPosition === null)
+        return binding;
+    const origins = [
+        ...binding.initializers.map((initializer) => ({
+            initializer,
+            position: initializer.entryBody === undefined
+                ? directInitializerPosition(initializer.node, parents)
+                : {
+                    body: initializer.entryBody.body,
+                    index: -1,
+                    declaratorIndex: -1,
+                },
+        })),
+        ...binding.referenceInitializers.map((initializer) => ({
+            initializer,
+            position: referenceInitializerPosition(initializer.node, parents),
+        })),
+    ];
+    if (origins.some(({ position }) => position === null || !positionPrecedes(position, mutationPosition)))
+        return binding;
+    const latest = origins.reduce((latest, { position }) => position !== null &&
+        (latest === null || positionPrecedes(latest, position))
+        ? position
+        : latest, null);
+    const retained = new Set(origins
+        .filter(({ position }) => position?.index === latest?.index &&
+        position?.declaratorIndex === latest?.declaratorIndex)
+        .map(({ initializer }) => initializer));
+    return {
+        initializers: binding.initializers.filter((initializer) => retained.has(initializer)),
+        referenceInitializers: binding.referenceInitializers.filter((initializer) => retained.has(initializer)),
+    };
+};
+/** Locate a capture only in an unconditional declaration or literal initializer. */
+export const semanticCapturePosition = (node, parents) => {
+    let current = node;
+    while (true) {
+        const direct = directInitializerPosition(current, parents);
+        if (direct !== null)
+            return direct;
+        const parent = parents.get(current);
+        if (t.isObjectProperty(parent) &&
+            parent.value === current &&
+            semanticStaticPropertyKey(parent.key, parent.computed) !== null)
+            current = parent;
+        else if (t.isObjectExpression(parent) || t.isArrayExpression(parent))
+            current = parent;
+        else
+            return null;
+    }
+};
+/** Intermediate values must themselves have been initialized before capture. */
+export const semanticBindingPrecedesCapture = (binding, capture, parents) => {
+    const initializer = binding.initializers[0];
+    if (binding.initializers.length !== 1 || initializer === undefined)
+        return false;
+    const sourcePosition = directInitializerPosition(initializer.node, parents);
+    const capturePosition = semanticCapturePosition(capture, parents);
+    return (sourcePosition !== null &&
+        capturePosition !== null &&
+        positionPrecedes(sourcePosition, capturePosition));
+};
+/** Ignore later escapes only while reading earlier references in one activation. */
+export const semanticEscapeFollowsCapture = (binding, capture, escape, parents) => {
+    const initializer = binding.initializers[0];
+    if (escape === undefined ||
+        initializer === undefined ||
+        !semanticBindingPrecedesCapture(binding, capture, parents))
+        return false;
+    // A literal allocates here. Aliases are evaluated at the same capture point,
+    // so an outer/persistent origin still receives all of its own escape effects.
+    const origin = unwrapJavaScriptExpression(initializer.node).node;
+    if (!t.isObjectExpression(origin) &&
+        !t.isArrayExpression(origin) &&
+        !t.isIdentifier(origin) &&
+        !t.isMemberExpression(origin) &&
+        !t.isOptionalMemberExpression(origin))
+        return false;
+    const capturePosition = semanticCapturePosition(capture, parents);
+    const escapePosition = directMutationPosition(escape, parents);
+    return (capturePosition !== null &&
+        escapePosition !== null &&
+        positionPrecedes(capturePosition, escapePosition));
+};

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -1,3 +1,24 @@
+import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
+/** Invalidate escaped object references without rewriting their containing slots. */
+export const invalidateSemanticEscapedPath = (value, path) => {
+    if (value.status !== "object" && value.status !== "array")
+        return value;
+    const [key, ...remaining] = path;
+    if (key === undefined)
+        return {
+            status: "unknown",
+            reason: "This object reference may have been mutated by a call.",
+        };
+    const invalidateChild = (property) => semanticPropertyPathKeyMatches(key, property.name)
+        ? {
+            ...property,
+            value: invalidateSemanticEscapedPath(property.value, remaining),
+        }
+        : property;
+    return value.status === "object"
+        ? { ...value, properties: value.properties.map(invalidateChild) }
+        : { ...value, items: value.items.map(invalidateChild) };
+};
 /** Invalidate only slots that an explicit mutation can affect. */
 export const invalidateSemanticMutationPath = (value, path) => {
     const [key, ...remaining] = path;
@@ -7,47 +28,34 @@ export const invalidateSemanticMutationPath = (value, path) => {
     };
     if (key === undefined || key === null)
         return unknown;
-    if (value.status === "object") {
-        const name = String(key);
-        const observed = value.properties.some((property) => property.name === name);
-        const properties = value.properties.map((property) => property.name === name
+    if (value.status === "object" || value.status === "array") {
+        if (value.status === "array" && key === "length")
+            return {
+                status: "array",
+                items: [],
+                unknownItems: true,
+                omittedItems: null,
+            };
+        const slots = value.status === "object" ? value.properties : value.items;
+        const observed = slots.some((property) => semanticPropertyPathKeyMatches(key, property.name));
+        const properties = slots.map((property) => semanticPropertyPathKeyMatches(key, property.name)
             ? {
                 ...property,
+                ...(remaining.length === 0
+                    ? { presence: "unknown-coverage" }
+                    : {}),
                 value: invalidateSemanticMutationPath(property.value, remaining),
             }
             : property);
-        return value.unknownProperties || !observed
-            ? {
-                status: "object",
-                properties,
-                unknownProperties: true,
-                omittedProperties: observed ? value.omittedProperties : null,
-            }
-            : {
-                status: "object",
-                properties,
-                unknownProperties: false,
-                omittedProperties: 0,
-            };
-    }
-    if (value.status === "array") {
-        const index = typeof key === "number" ? key : Number(key);
-        if (!Number.isSafeInteger(index) ||
-            index < 0 ||
-            String(index) !== String(key))
-            return unknown;
-        const observed = value.items[index] !== undefined;
-        const items = value.items.map((item, position) => position === index
-            ? invalidateSemanticMutationPath(item, remaining)
-            : item);
-        return value.unknownItems || !observed
-            ? {
-                status: "array",
-                items,
-                unknownItems: true,
-                omittedItems: observed ? value.omittedItems : null,
-            }
-            : { status: "array", items, unknownItems: false, omittedItems: 0 };
+        if (!observed && typeof key !== "object")
+            properties.push({
+                name: String(key),
+                value: unknown,
+                presence: "unknown-coverage",
+            });
+        return value.status === "object"
+            ? { ...value, properties }
+            : { ...value, items: properties };
     }
     return unknown;
 };

package/dist/domain/javascript/javascriptSemanticObjects.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticReadsBeforeWrite, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReadsBeforeWrite, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -19,16 +20,19 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
                 collectMember(node, parent, ownerCallableId, context);
             else if (t.isSpreadElement(node) &&
                 parent !== null &&
-                t.isObjectExpression(parent))
+                t.isObjectExpression(parent)) {
+                const identity = expressionObjectIdentity(node.argument, state);
                 addObjectOperation({
                     node,
                     kind: "spread",
                     ownerCallableId,
-                    objectBindingId: expressionBindingId(node.argument, state),
+                    objectBindingId: identity.bindingId,
                     targetBindingId: null,
-                    propertyName: null,
+                    propertyPath: identity.path,
                 }, state, output);
-            else if (t.isVariableDeclarator(node) && t.isObjectPattern(node.id))
+            }
+            else if (t.isVariableDeclarator(node) &&
+                (t.isObjectPattern(node.id) || t.isArrayPattern(node.id)))
                 collectDestructuring(node, ownerCallableId, state, output);
         },
         exit: (node) => {
@@ -41,9 +45,12 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
 };
 const collectMember = (node, parent, ownerCallableId, context) => {
     const { state, output } = context;
-    const name = semanticStaticPropertyKey(node.property, node.computed);
-    if (name === null)
+    // A chain is one property access; retaining every prefix duplicates work and
+    // would make full paths quadratic in deeply nested producer expressions.
+    if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
+        parent.object === node)
         return;
+    const identity = expressionObjectIdentity(node, state);
     const write = (t.isAssignmentExpression(parent) && parent.left === node) ||
         (t.isUpdateExpression(parent) && parent.argument === node);
     const readsBeforeWrite = write && semanticReadsBeforeWrite(node, parent);
@@ -52,42 +59,53 @@ const collectMember = (node, parent, ownerCallableId, context) => {
             node,
             kind: "read",
             ownerCallableId,
-            objectBindingId: expressionBindingId(node.object, state),
+            objectBindingId: identity.bindingId,
             targetBindingId: null,
-            propertyName: name,
+            propertyPath: identity.path,
         }, state, output);
     addObjectOperation({
         node,
         kind: write ? "write" : "read",
         ownerCallableId,
-        objectBindingId: expressionBindingId(node.object, state),
+        objectBindingId: identity.bindingId,
         targetBindingId: null,
-        propertyName: name,
+        propertyPath: identity.path,
     }, state, output);
 };
 const collectDestructuring = (node, ownerCallableId, state, output) => {
-    if (!t.isObjectPattern(node.id))
-        return;
-    const objectBindingId = expressionBindingId(node.init, state);
-    for (const property of node.id.properties) {
-        if (!t.isObjectProperty(property))
-            continue;
-        const name = semanticStaticPropertyKey(property.key, property.computed);
-        if (name === null)
-            continue;
-        const target = bindingIdentifier(property.value);
+    const source = expressionObjectIdentity(node.init, state);
+    const visit = (pattern, path) => {
+        if (t.isObjectPattern(pattern)) {
+            for (const property of pattern.properties) {
+                if (!t.isObjectProperty(property))
+                    continue;
+                const name = semanticStaticPropertyKey(property.key, property.computed);
+                if (name !== null)
+                    visit(property.value, [...path, name]);
+            }
+            return;
+        }
+        if (t.isArrayPattern(pattern)) {
+            pattern.elements.forEach((element, index) => {
+                if (element !== null && !t.isRestElement(element))
+                    visit(element, [...path, String(index)]);
+            });
+            return;
+        }
+        const target = bindingIdentifier(pattern);
+        if (target === null)
+            return;
         addObjectOperation({
-            node: property,
+            node: pattern,
             kind: "destructure",
             ownerCallableId,
-            objectBindingId,
-            targetBindingId: target === null
-                ? null
-                : (resolveSemanticBindingState(state, target, target.name)
-                    ?.bindingId ?? null),
-            propertyName: name,
+            objectBindingId: source.bindingId,
+            targetBindingId: resolveSemanticBindingState(state, target, target.name)?.bindingId ??
+                null,
+            propertyPath: source.path === null ? null : [...source.path, ...path],
         }, state, output);
-    }
+    };
+    visit(node.id, []);
 };
 const addObjectOperation = (input, state, output) => {
     output.push({
@@ -97,21 +115,40 @@ const addObjectOperation = (input, state, output) => {
         ownerCallableId: input.ownerCallableId,
         objectBindingId: input.objectBindingId,
         targetBindingId: input.targetBindingId,
-        propertyName: input.propertyName,
-        resolution: input.kind === "spread"
-            ? input.objectBindingId === null
-                ? "partial"
-                : "complete"
-            : input.objectBindingId === null ||
-                input.propertyName === null ||
-                (input.kind === "destructure" && input.targetBindingId === null)
-                ? "partial"
-                : "complete",
+        propertyPath: input.propertyPath,
+        resolution: input.objectBindingId === null ||
+            input.propertyPath === null ||
+            (input.kind === "destructure" && input.targetBindingId === null)
+            ? "partial"
+            : "complete",
     });
 };
-const expressionBindingId = (node, state) => t.isIdentifier(node)
-    ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
-    : null;
+const expressionObjectIdentity = (node, state) => {
+    const path = [];
+    let current = node;
+    let staticPath = true;
+    while (current !== null && current !== undefined) {
+        current = unwrapJavaScriptExpression(current).node;
+        if (t.isMemberExpression(current) ||
+            t.isOptionalMemberExpression(current)) {
+            const name = semanticStaticPropertyKey(current.property, current.computed);
+            if (name === null)
+                staticPath = false;
+            else
+                path.push(name);
+            current = current.object;
+        }
+        else
+            break;
+    }
+    return {
+        bindingId: t.isIdentifier(current)
+            ? (resolveSemanticBindingState(state, current, current.name)?.bindingId ??
+                null)
+            : null,
+        path: staticPath ? path.reverse() : null,
+    };
+};
 const bindingIdentifier = (node) => {
     if (t.isIdentifier(node))
         return node;

package/dist/domain/javascript/javascriptSemanticPrimitives.js

@@ -1,13 +1,6 @@
-import * as t from "@babel/types";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
-import { readExactJavaScriptLiteral } from "./javascriptAstValues.js";
 import { SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveStringByteBudget, semanticResourceLimitUnknown, } from "./javascriptSemanticResourceLimits.js";
-/**
- * Keep eight independent binary choices exact, while bounding the next
- * exponential expansion before it allocates hundreds more alternatives.
- */
-export const MAX_SEMANTIC_PRIMITIVE_CANDIDATES = SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT;
 /** Normalize one bounded collection of possible primitive values. */
 export const semanticPrimitiveSet = (values) => {
     const uniqueValues = new Set();
@@ -17,15 +10,20 @@ export const semanticPrimitiveSet = (values) => {
                 status: "unknown",
                 reason: "Nonfinite numbers are outside the JSON primitive lattice.",
             };
+        if (typeof value === "number" && Object.is(value, -0))
+            return {
+                status: "unknown",
+                reason: "Negative zero cannot be preserved by JSON primitive evidence.",
+            };
         uniqueValues.add(value);
-        if (uniqueValues.size > MAX_SEMANTIC_PRIMITIVE_CANDIDATES)
+        if (uniqueValues.size > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT)
             return semanticResourceLimitUnknown("primitive-candidates");
     }
     if (exceedsSemanticPrimitiveStringByteBudget([...uniqueValues].flatMap((value) => typeof value === "string" ? [value] : [])))
         return semanticResourceLimitUnknown("primitive-bytes");
     const unique = [...uniqueValues]
         .map((value) => ({ key: semanticPrimitiveKey(value), value }))
-        .sort((left, right) => compareCodePoints(left.key, right.key))
+        .sort((left, right) => compareUnicodeCodePoints(left.key, right.key))
         .map(({ value }) => value);
     const only = unique[0];
     return unique.length === 1 && only !== undefined
@@ -38,7 +36,3 @@ export const semanticPrimitiveCandidates = (value) => value.status === "literal"
     : value.status === "union"
         ? value.values
         : null;
-/** Parse one Babel primitive literal without evaluating code. */
-export const semanticPrimitiveValue = (node) => {
-    return readExactJavaScriptLiteral(node);
-};

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -1,11 +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 { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
-import { propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (input) => {
     const { node, parent, containerScope, bodyScope, state } = input;
@@ -43,7 +43,7 @@ export const collectSemanticModuleLink = (node, state) => {
             localName: null,
             exportedName: "*",
             location: range(node),
-        });
+        }, node);
     else if (t.isExportNamedDeclaration(node))
         collectNamedExports(node, state);
     else if (t.isExportDefaultDeclaration(node))
@@ -55,7 +55,7 @@ export const collectSemanticModuleLink = (node, state) => {
             exportedName: "default",
             callableId: semanticCallableIdForNode(node.declaration),
             location: range(node),
-        });
+        }, node);
     else if (t.isVariableDeclarator(node))
         collectRequireLink(node, state);
     else if (t.isAssignmentExpression(node))
@@ -121,7 +121,7 @@ export const immutableSemanticScopes = (state) => state.scopes.map((scope) => ({
     bindingsComplete: scope.bindingsComplete,
     bindingIds: [...scope.bindings.values()]
         .map(({ bindingId }) => bindingId)
-        .sort(compareCodePoints),
+        .sort(compareUnicodeCodePoints),
 }));
 /** Evaluate and freeze bindings into deterministic IR order. */
 export const immutableSemanticBindings = (state) => [...state.bindingsById.values()]
@@ -135,8 +135,7 @@ export const immutableSemanticBindings = (state) => [...state.bindingsById.value
     value: evaluateSemanticBinding(binding, state),
     provenance: evaluateSemanticProvenance(binding, state),
 }))
-    .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
-export { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+    .sort((left, right) => compareUnicodeCodePoints(left.bindingId, right.bindingId));
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||
@@ -181,7 +180,7 @@ const collectImports = (node, state) => {
             localName: null,
             exportedName: null,
             location: range(node),
-        });
+        }, node);
     for (const specifier of node.specifiers)
         addModuleLink(state, {
             kind: "import",
@@ -194,7 +193,7 @@ const collectImports = (node, state) => {
             localName: specifier.local.name,
             exportedName: null,
             location: range(specifier),
-        });
+        }, node);
 };
 const collectNamedExports = (node, state) => {
     if (node.declaration !== null && node.declaration !== undefined)
@@ -207,7 +206,7 @@ const collectNamedExports = (node, state) => {
                 exportedName: localName,
                 callableId: declarationCallableId(node.declaration, localName),
                 location: range(node.declaration),
-            });
+            }, node);
     for (const specifier of node.specifiers)
         if (t.isExportSpecifier(specifier))
             addModuleLink(state, {
@@ -217,7 +216,7 @@ const collectNamedExports = (node, state) => {
                 localName: node.source == null ? propertyName(specifier.local) : null,
                 exportedName: propertyName(specifier.exported),
                 location: range(specifier),
-            });
+            }, node);
 };
 const collectRequireLink = (node, state) => {
     const origin = semanticRequireOrigin(node.init, state);
@@ -231,7 +230,7 @@ const collectRequireLink = (node, state) => {
             localName: binding.localName,
             exportedName: null,
             location: range(node),
-        });
+        }, node);
 };
 const requirePatternBindings = (pattern, path) => {
     if (t.isTSParameterProperty(pattern))
@@ -268,10 +267,16 @@ const collectCommonJsExport = (node, state) => {
         exportedName,
         callableId: semanticCallableIdForNode(node.right),
         location: range(node),
-    });
+    }, node);
 };
-const addModuleLink = (state, link) => {
-    state.moduleLinks.push({ ...link, callableId: link.callableId ?? null });
+const addModuleLink = (state, link, referenceNode) => {
+    const collected = { ...link, callableId: link.callableId ?? null };
+    state.moduleLinks.push(collected);
+    if (link.localName !== null) {
+        const binding = resolveSemanticBindingState(state, referenceNode, link.localName);
+        if (binding !== undefined)
+            state.moduleLinkBindings.set(collected, binding);
+    }
 };
 /** Deterministic callable identity shared by collection and return recovery. */
 export const semanticCallableIdForNode = (node) => {