rea-agents 6.2.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticObjectReferences.js

@@ -0,0 +1,381 @@
+import * as t from "@babel/types";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { semanticCallableResultExpressions } from "./javascriptSemanticCallableResults.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+export const semanticClassCandidates = (root, state) => {
+    const pending = [root];
+    const seenNodes = new Set();
+    const seenBindings = new Set();
+    const classes = [];
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const node = pending[cursor];
+        if (node === undefined)
+            continue;
+        const expression = unwrapJavaScriptExpression(node).node;
+        if (seenNodes.has(expression))
+            continue;
+        seenNodes.add(expression);
+        if (t.isClass(expression)) {
+            classes.push(expression);
+        }
+        else if (t.isIdentifier(expression)) {
+            const binding = resolveSemanticBindingState(state, expression, expression.name);
+            if (binding === undefined || seenBindings.has(binding.bindingId))
+                continue;
+            seenBindings.add(binding.bindingId);
+            for (const initializer of binding.initializers)
+                pending.push(initializer.node);
+        }
+        else if (t.isConditionalExpression(expression) ||
+            t.isLogicalExpression(expression)) {
+            pending.push(t.isConditionalExpression(expression)
+                ? expression.consequent
+                : expression.left, t.isConditionalExpression(expression)
+                ? expression.alternate
+                : expression.right);
+        }
+        else if (t.isSequenceExpression(expression)) {
+            const last = expression.expressions.at(-1);
+            if (last !== undefined)
+                pending.push(last);
+        }
+    }
+    return classes;
+};
+const instanceFieldReferences = (root, propertyName, path, state) => {
+    const references = [];
+    const pending = [{ klass: root, excluded: new Set() }];
+    const selections = new Map();
+    let definiteNames;
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const current = pending[cursor];
+        if (current === undefined)
+            continue;
+        const previous = selections.get(current.klass);
+        // A shared base can be reached through different derived classes. Only
+        // exclusions common to those paths can suppress a field in that base.
+        const excluded = previous === undefined
+            ? current.excluded
+            : new Set([...previous].filter((name) => current.excluded.has(name)));
+        if (previous !== undefined && previous.size === excluded.size)
+            continue;
+        selections.set(current.klass, excluded);
+        const shadowed = new Set(excluded);
+        for (const member of [...current.klass.body.body].reverse()) {
+            if (!t.isClassProperty(member) || member.static)
+                continue;
+            const key = semanticStaticPropertyKey(member.key, member.computed);
+            if (key !== null && shadowed.has(key))
+                continue;
+            if (key !== null)
+                shadowed.add(key);
+            if ((propertyName === null || key === null || key === propertyName) &&
+                member.value != null)
+                references.push({ node: member.value, path });
+        }
+        const bases = current.klass.superClass == null
+            ? []
+            : semanticClassCandidates(current.klass.superClass, state);
+        if (bases.length === 0)
+            definiteNames =
+                definiteNames === undefined
+                    ? shadowed
+                    : new Set([...definiteNames].filter((name) => shadowed.has(name)));
+        for (const klass of bases)
+            pending.push({ klass, excluded: shadowed });
+    }
+    return { references, definiteNames: definiteNames ?? new Set() };
+};
+const classPropertyDescriptors = (klass, propertyName, kind) => {
+    const isStatic = kind === "static";
+    const selectedGetters = [];
+    const fields = [];
+    const indexedMembers = [];
+    klass.body.body.forEach((member, index) => {
+        if ((t.isClassMethod(member) ||
+            (kind === "static" && t.isClassProperty(member))) &&
+            member.static === isStatic)
+            indexedMembers.push({
+                member,
+                index,
+                key: semanticStaticPropertyKey(member.key, member.computed),
+            });
+    });
+    const matchingMembers = propertyName === null
+        ? []
+        : indexedMembers.filter(({ key }) => key === propertyName);
+    const uncertainGetters = indexedMembers.filter((entry) => {
+        const { member, key } = entry;
+        return (t.isClassMethod(member) &&
+            member.kind === "get" &&
+            (propertyName === null || (member.computed && key === null)));
+    });
+    const getters = matchingMembers.filter((entry) => t.isClassMethod(entry.member) && entry.member.kind === "get");
+    const getter = getters.at(-1);
+    const getterIndex = getter?.index ?? -1;
+    const laterDataMember = matchingMembers.some(({ member, index }) => t.isClassProperty(member) ||
+        (t.isClassMethod(member) &&
+            member.kind === "method" &&
+            index > getterIndex));
+    const seenFields = new Set();
+    for (const { member, key } of [...indexedMembers].reverse()) {
+        if (!t.isClassProperty(member))
+            continue;
+        if (key !== null && seenFields.has(key))
+            continue;
+        if (key !== null)
+            seenFields.add(key);
+        if (propertyName === null || key === null || key === propertyName)
+            fields.push(member);
+    }
+    if (getters.length > 0 && !laterDataMember && getter !== undefined)
+        selectedGetters.push(getter.member);
+    for (const { member, index } of uncertainGetters)
+        if (!matchingMembers.some(({ member: matching, index: matchingIndex }) => (t.isClassProperty(matching) ||
+            (t.isClassMethod(matching) &&
+                (matching.kind === "method" || matching.kind === "get"))) &&
+            matchingIndex > index))
+            selectedGetters.push(member);
+    return {
+        getters: selectedGetters,
+        fields,
+        inherits: matchingMembers.length === 0,
+    };
+};
+export const semanticClassPropertyReferences = (lookup, selection, state, activeGetters = new Map()) => {
+    const root = lookup.owner;
+    const receiver = lookup.receiver ?? root;
+    const [key, ...path] = selection;
+    const propertyName = key == null || typeof key === "object" ? null : String(key);
+    const pending = [root];
+    const seen = new Set();
+    const possibleResults = [];
+    // Instance fields are own properties, including fields initialized by base
+    // constructors. They take precedence over every prototype descriptor.
+    let instanceFields = new Set();
+    if (lookup.kind === "instance") {
+        const fields = instanceFieldReferences(root, propertyName, path, state);
+        possibleResults.push(...fields.references);
+        instanceFields = fields.definiteNames;
+        if (propertyName !== null && instanceFields.has(propertyName))
+            return possibleResults;
+    }
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const klass = pending[cursor];
+        if (klass === undefined || seen.has(klass))
+            continue;
+        seen.add(klass);
+        const descriptors = classPropertyDescriptors(klass, propertyName, lookup.kind);
+        for (const field of descriptors.fields)
+            if (field.value != null)
+                possibleResults.push({ node: field.value, path });
+        for (const getter of descriptors.getters) {
+            const key = semanticStaticPropertyKey(getter.key, getter.computed);
+            if (key !== null && instanceFields.has(key))
+                continue;
+            possibleResults.push(...getterResultReferences({ getter, owner: klass, receiver }, path, state, activeGetters));
+        }
+        // An exact own descriptor suppresses inherited lookup. Dynamic computed
+        // descriptors may or may not match, so retain possible superclass results.
+        if (descriptors.inherits &&
+            klass.superClass !== null &&
+            klass.superClass !== undefined)
+            pending.push(...semanticClassCandidates(klass.superClass, state));
+    }
+    return possibleResults;
+};
+const objectReceiverReference = (object, path, state) => {
+    // A literal's enclosing binding owns its slots. Returning the literal
+    // itself would bypass invalidation of that binding's observed properties.
+    let current = object;
+    const projection = [];
+    while (true) {
+        const parent = state.parentsByNode.get(current);
+        if (t.isVariableDeclarator(parent) &&
+            parent.init === current &&
+            t.isIdentifier(parent.id))
+            return [{ node: parent.id, path: [...projection, ...path] }];
+        if (t.isObjectProperty(parent) && parent.value === current) {
+            projection.unshift(semanticStaticPropertyKey(parent.key, parent.computed));
+            const container = state.parentsByNode.get(parent);
+            if (t.isObjectExpression(container)) {
+                current = container;
+                continue;
+            }
+        }
+        break;
+    }
+    return [{ node: object, path }];
+};
+const getterResultReferences = (invocation, path, state, activeGetters = new Map()) => {
+    const { getter, owner, receiver = owner } = invocation;
+    const previousLength = activeGetters.get(getter);
+    if (previousLength !== undefined && previousLength <= path.length)
+        return [];
+    // Repeated receiver reads may revisit a getter while consuming a finite
+    // path; recursive getters that preserve or grow that path cannot progress.
+    const active = new Map(activeGetters).set(getter, path.length);
+    const isStatic = t.isClassMethod(getter) && getter.static;
+    const resolve = (node, remaining) => {
+        const expression = unwrapJavaScriptExpression(node).node;
+        if (t.isThisExpression(expression)) {
+            if (t.isClass(receiver)) {
+                return semanticClassPropertyReferences({ owner: receiver, kind: isStatic ? "static" : "instance" }, remaining, state, active);
+            }
+            return objectReceiverReference(receiver, remaining, state);
+        }
+        if (t.isMemberExpression(expression) ||
+            t.isOptionalMemberExpression(expression)) {
+            if (t.isPrivateName(expression.property) &&
+                t.isThisExpression(expression.object) &&
+                t.isClass(owner)) {
+                const privateName = expression.property.id.name;
+                return owner.body.body.flatMap((member) => t.isClassPrivateProperty(member) &&
+                    member.static === isStatic &&
+                    member.key.id.name === privateName &&
+                    member.value != null
+                    ? [{ node: member.value, path: remaining }]
+                    : []);
+            }
+            const key = semanticStaticPropertyKey(expression.property, expression.computed);
+            if (t.isSuper(expression.object) &&
+                t.isClass(owner) &&
+                owner.superClass != null) {
+                return semanticClassCandidates(owner.superClass, state).flatMap((base) => semanticClassPropertyReferences({
+                    owner: base,
+                    receiver: t.isClass(receiver) ? receiver : owner,
+                    kind: isStatic ? "static" : "prototype",
+                }, [key, ...remaining], state, active));
+            }
+            return resolve(expression.object, [key, ...remaining]);
+        }
+        if (t.isConditionalExpression(expression))
+            return [
+                ...resolve(expression.consequent, remaining),
+                ...resolve(expression.alternate, remaining),
+            ];
+        if (t.isLogicalExpression(expression))
+            return [
+                ...resolve(expression.left, remaining),
+                ...resolve(expression.right, remaining),
+            ];
+        if (t.isSequenceExpression(expression)) {
+            const last = expression.expressions.at(-1);
+            return last === undefined ? [] : resolve(last, remaining);
+        }
+        return [{ node: expression, path: remaining }];
+    };
+    return semanticCallableResultExpressions(getter).flatMap(({ node }) => node === null ? [] : resolve(node, path));
+};
+export const semanticObjectPropertyReferences = (node, path, state) => {
+    const [key, ...remaining] = path;
+    const references = [];
+    const overwritten = new Set();
+    const dataOverwritten = new Set();
+    const accessorNames = new Set();
+    const getterNames = new Set();
+    const setterNames = new Set();
+    for (const property of [...node.properties].reverse()) {
+        if (t.isSpreadElement(property)) {
+            const selected = key ?? null;
+            if (typeof selected !== "object" && overwritten.has(String(selected)))
+                continue;
+            references.push({
+                node: property.argument,
+                path: [
+                    typeof selected === "object"
+                        ? {
+                            ...selected,
+                            excludedKeys: [
+                                ...new Set([
+                                    ...(selected?.excludedKeys ?? []),
+                                    ...overwritten,
+                                ]),
+                            ].sort(compareUnicodeCodePoints),
+                        }
+                        : selected,
+                    ...remaining,
+                ],
+            });
+            if (selected !== null &&
+                typeof selected !== "object" &&
+                t.isObjectExpression(property.argument) &&
+                objectExpressionDefinesKey(property.argument, String(selected))) {
+                overwritten.add(String(selected));
+                dataOverwritten.add(String(selected));
+            }
+            continue;
+        }
+        const name = semanticStaticPropertyKey(property.key, property.computed);
+        const isGetter = t.isObjectMethod(property) && property.kind === "get";
+        const isSetter = t.isObjectMethod(property) && property.kind === "set";
+        if (name !== null &&
+            (isGetter || isSetter
+                ? dataOverwritten.has(name) ||
+                    (isGetter ? getterNames.has(name) : setterNames.has(name))
+                : dataOverwritten.has(name) || accessorNames.has(name)))
+            continue;
+        if (name === null || semanticPropertyPathKeyMatches(key ?? null, name)) {
+            if (t.isObjectMethod(property) && property.kind === "get") {
+                references.push(...getterResultReferences({ getter: property, owner: node }, remaining, state));
+            }
+            else if (t.isObjectMethod(property) && property.kind === "set") {
+                // A setter contributes no readable reference. A paired getter is
+                // handled independently when it appears earlier in this object.
+            }
+            else {
+                references.push({
+                    node: t.isObjectProperty(property) ? property.value : property,
+                    path: remaining,
+                });
+            }
+        }
+        if (name !== null) {
+            if (isGetter) {
+                getterNames.add(name);
+                accessorNames.add(name);
+                overwritten.add(name);
+            }
+            else if (isSetter) {
+                setterNames.add(name);
+                accessorNames.add(name);
+                overwritten.add(name);
+            }
+            else if (!(t.isObjectProperty(property) &&
+                !property.computed &&
+                !property.shorthand &&
+                name === "__proto__")) {
+                overwritten.add(name);
+                dataOverwritten.add(name);
+            }
+        }
+    }
+    return references;
+};
+const objectExpressionDefinesKey = (root, key) => {
+    const pending = [root];
+    const seen = new Set();
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const object = pending[cursor];
+        if (object === undefined || seen.has(object))
+            continue;
+        seen.add(object);
+        for (const property of object.properties) {
+            if (t.isSpreadElement(property)) {
+                if (t.isObjectExpression(property.argument))
+                    pending.push(property.argument);
+                continue;
+            }
+            const name = semanticStaticPropertyKey(property.key, property.computed);
+            if (name === key &&
+                !(t.isObjectProperty(property) &&
+                    !property.computed &&
+                    !property.shorthand &&
+                    name === "__proto__"))
+                return true;
+        }
+    }
+    return false;
+};

package/dist/domain/javascript/javascriptSemanticObjects.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode, semanticReadsBeforeWrite, } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -109,7 +109,13 @@ const collectDestructuring = (node, ownerCallableId, state, output) => {
 };
 const addObjectOperation = (input, state, output) => {
     output.push({
-        objectOperationId: `object:${input.kind}:${String(input.node.start ?? -1)}:${String(input.node.end ?? -1)}`,
+        // These high-volume IDs must not retain intermediate concatenations.
+        objectOperationId: [
+            "object",
+            input.kind,
+            String(input.node.start ?? -1),
+            String(input.node.end ?? -1),
+        ].join(":"),
         kind: input.kind,
         location: range(input.node),
         ownerCallableId: input.ownerCallableId,
@@ -128,6 +134,7 @@ const expressionObjectIdentity = (node, state) => {
     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);
@@ -137,11 +144,6 @@ const expressionObjectIdentity = (node, state) => {
                 path.push(name);
             current = current.object;
         }
-        else if (t.isTSAsExpression(current) ||
-            t.isTSTypeAssertion(current) ||
-            t.isTSNonNullExpression(current) ||
-            t.isTSSatisfiesExpression(current))
-            current = current.expression;
         else
             break;
     }

package/dist/domain/javascript/javascriptSemanticPrimitives.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
 import { SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveStringByteBudget, semanticResourceLimitUnknown, } from "./javascriptSemanticResourceLimits.js";
 /** Normalize one bounded collection of possible primitive values. */
@@ -10,6 +10,11 @@ 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 > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT)
             return semanticResourceLimitUnknown("primitive-candidates");
@@ -18,7 +23,7 @@ export const semanticPrimitiveSet = (values) => {
         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

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -1,10 +1,10 @@
 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 { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
-import { range, stringValue } from "./javascriptStaticAnalysisHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (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,18 +55,20 @@ 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))
         collectCommonJsExport(node, state);
 };
 /** Collect lexical references after definitions exist, optionally for one name. */
-export const collectSemanticReferences = (program, state, name) => {
+export const collectSemanticReferences = (program, state, name) => completeSemanticSteps(collectSemanticReferencesSteps(program, state, name));
+/** Collect lexical references in steps while preserving resolution and visit order. */
+export function* collectSemanticReferencesSteps(program, state, name) {
     const output = [];
     const seen = new Set();
     const patterns = [];
-    traverseJavaScriptAst(program, {
+    yield* traverseJavaScriptAstSteps(program, {
         enter: (node, parent, readAncestors) => {
             if (isPatternNode(node))
                 patterns.push(node);
@@ -111,7 +113,7 @@ export const collectSemanticReferences = (program, state, name) => {
         },
     });
     return output;
-};
+}
 /** Freeze collected scopes into deterministic IR order. */
 export const immutableSemanticScopes = (state) => state.scopes.map((scope) => ({
     scopeId: scope.scopeId,
@@ -121,7 +123,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,7 +137,7 @@ export const immutableSemanticBindings = (state) => [...state.bindingsById.value
     value: evaluateSemanticBinding(binding, state),
     provenance: evaluateSemanticProvenance(binding, state),
 }))
-    .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
+    .sort((left, right) => compareUnicodeCodePoints(left.bindingId, right.bindingId));
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||
@@ -180,7 +182,7 @@ const collectImports = (node, state) => {
             localName: null,
             exportedName: null,
             location: range(node),
-        });
+        }, node);
     for (const specifier of node.specifiers)
         addModuleLink(state, {
             kind: "import",
@@ -193,7 +195,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)
@@ -206,7 +208,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, {
@@ -216,7 +218,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);
@@ -230,7 +232,7 @@ const collectRequireLink = (node, state) => {
             localName: binding.localName,
             exportedName: null,
             location: range(node),
-        });
+        }, node);
 };
 const requirePatternBindings = (pattern, path) => {
     if (t.isTSParameterProperty(pattern))
@@ -258,19 +260,62 @@ const collectCommonJsExport = (node, state) => {
     const exportedName = commonJsExportName(node.left, state);
     if (exportedName === undefined)
         return;
-    const origin = semanticRequireOrigin(node.right, state);
+    const receiverEffect = isCommonJsModuleExports(node.left, state)
+        ? null
+        : commonJsExportReceiverEffect(node.right, state);
+    if (receiverEffect === "detached")
+        return;
+    // Simple assignment chains yield their rightmost assigned value. Compound
+    // and logical writes also depend on the previous value, so remain unknown.
+    let value = node.operator === "=" && receiverEffect !== "uncertain" ? node.right : null;
+    while (t.isAssignmentExpression(value, { operator: "=" }))
+        value = value.right;
+    const origin = value === null ? undefined : semanticRequireOrigin(value, state);
     addModuleLink(state, {
         kind: "commonjs-export",
         specifier: origin?.specifier ?? null,
         importedName: origin?.importedPath.at(-1) ?? null,
-        localName: t.isIdentifier(node.right) ? node.right.name : null,
+        localName: value !== null && t.isIdentifier(value) ? value.name : null,
         exportedName,
-        callableId: semanticCallableIdForNode(node.right),
+        callableId: value === null ? null : semanticCallableIdForNode(value),
         location: range(node),
-    });
+    }, node);
 };
-const addModuleLink = (state, link) => {
-    state.moduleLinks.push({ ...link, callableId: link.callableId ?? null });
+/**
+ * An outer property assignment captures its receiver before evaluating the
+ * RHS. When that chain assigns a freshly created identity to `module.exports`,
+ * the outer write targets the old exports object and cannot define an export
+ * on the value ultimately returned by the CommonJS module. Reassignments from
+ * existing bindings may preserve identity, so this guard leaves them as
+ * export candidates.
+ */
+const commonJsExportReceiverEffect = (node, state) => {
+    let value = node;
+    while (t.isAssignmentExpression(value, { operator: "=" })) {
+        if (isCommonJsModuleExports(value.left, state))
+            return isFreshAssignmentResult(value.right) ? "detached" : "uncertain";
+        value = value.right;
+    }
+    return null;
+};
+const isFreshAssignmentResult = (node) => {
+    let value = node;
+    while (t.isAssignmentExpression(value, { operator: "=" }))
+        value = value.right;
+    return (t.isArrowFunctionExpression(value) ||
+        t.isFunctionExpression(value) ||
+        t.isClassExpression(value) ||
+        t.isObjectExpression(value) ||
+        t.isArrayExpression(value));
+};
+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) => {
@@ -451,8 +496,7 @@ const defaultDeclarationName = (declaration) => (t.isFunctionDeclaration(declara
     ? declaration.id.name
     : null;
 const commonJsExportName = (node, state) => {
-    if (isUnshadowedGlobal(node, state, "exports"))
-        return "default";
+    // Rebinding the CommonJS `exports` alias does not replace `module.exports`.
     if (!t.isMemberExpression(node) && !t.isOptionalMemberExpression(node))
         return undefined;
     const key = semanticStaticPropertyKey(node.property, node.computed);
@@ -462,12 +506,12 @@ const commonJsExportName = (node, state) => {
     if (isUnshadowedGlobal(node.object, state, "exports"))
         return key === null ? "*" : key || "*";
     if (t.isMemberExpression(node.object) &&
-        isUnshadowedGlobal(node.object.object, state, "module") &&
-        semanticStaticPropertyKey(node.object.property, node.object.computed) ===
-            "exports")
+        isCommonJsModuleExports(node.object, state))
         return key === null ? "*" : key || "default";
-    if (isUnshadowedGlobal(node.object, state, "module") &&
-        semanticStaticPropertyKey(node.property, node.computed) === "exports")
+    if (isCommonJsModuleExports(node, state))
         return "default";
     return undefined;
 };
+const isCommonJsModuleExports = (node, state) => (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
+    isUnshadowedGlobal(node.object, state, "module") &&
+    semanticStaticPropertyKey(node.property, node.computed) === "exports";