rea-agents 6.4.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -1,11 +1,13 @@
 import * as t from "@babel/types";
-import { resolveSemanticBindingState, semanticResolutionBlocked, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
-import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { propertyName, semanticFinalObjectProperty, semanticStaticPropertyKey, semanticWrappedWriteSite, semanticWriteSiteReadsFirst, semanticWriteSiteTarget, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { isTypeOnlyExportDeclaration, isTypeOnlyExportSpecifier, isTypeOnlyImportDeclaration, isTypeOnlyImportSpecifier, semanticImportEqualsSpecifier, } from "./javascriptModuleDeclaration.js";
+import { commonJsDefinedExport, commonJsExportName, } from "./javascriptCommonJsExportReceivers.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (input) => {
     const { node, parent, containerScope, bodyScope, state } = input;
@@ -32,12 +34,14 @@ export const collectSemanticCallable = (input) => {
     state.callableNodesById.set(callableId, node);
 };
 /** Collect one static import/export relationship for later composition. */
-export const collectSemanticModuleLink = (node, state) => {
-    if (t.isImportDeclaration(node))
+export const collectSemanticModuleLink = (node, state, commonJsReceivers) => {
+    if (t.isTSImportEqualsDeclaration(node))
+        collectImportEquals(node, state);
+    else if (t.isImportDeclaration(node))
         collectImports(node, state);
     else if (t.isExportAllDeclaration(node))
         addModuleLink(state, {
-            kind: "re-export",
+            kind: isTypeOnlyExportDeclaration(node) ? "type-import" : "re-export",
             specifier: node.source.value,
             importedName: "*",
             localName: null,
@@ -51,7 +55,7 @@ export const collectSemanticModuleLink = (node, state) => {
             kind: "export",
             specifier: null,
             importedName: null,
-            localName: defaultDeclarationName(node.declaration),
+            localName: defaultExportLocalName(node.declaration),
             exportedName: "default",
             callableId: semanticCallableIdForNode(node.declaration),
             location: range(node),
@@ -59,7 +63,30 @@ export const collectSemanticModuleLink = (node, state) => {
     else if (t.isVariableDeclarator(node))
         collectRequireLink(node, state);
     else if (t.isAssignmentExpression(node))
-        collectCommonJsExport(node, state);
+        collectCommonJsExport(node, state, commonJsReceivers.get(node));
+    else if (t.isCallExpression(node)) {
+        collectDefinedCommonJsExport(node, state, commonJsReceivers.get(node));
+        collectUnboundRequireLink(node, state);
+    }
+};
+const collectImportEquals = (node, state) => {
+    const moduleReference = node.moduleReference;
+    const specifier = semanticImportEqualsSpecifier(node) ??
+        (node.importKind === "type" &&
+            t.isTSExternalModuleReference(moduleReference) &&
+            t.isStringLiteral(moduleReference.expression)
+            ? moduleReference.expression.value
+            : null);
+    if (specifier === null)
+        return;
+    addModuleLink(state, {
+        kind: node.importKind === "type" ? "type-import" : "require",
+        specifier,
+        importedName: null,
+        localName: node.id.name,
+        exportedName: null,
+        location: range(node),
+    }, node);
 };
 /** Collect lexical references after definitions exist, optionally for one name. */
 export const collectSemanticReferences = (program, state, name) => completeSemanticSteps(collectSemanticReferencesSteps(program, state, name));
@@ -78,12 +105,14 @@ export function* collectSemanticReferencesSteps(program, state, name) {
                 (isNonReferenceKey(node, parent) &&
                     !patterns.some((pattern) => bindsIdentifier(pattern, parent, node))))
                 return;
-            const role = semanticIdentifierRole(node, parent, readAncestors());
+            const ancestors = readAncestors();
+            const role = semanticIdentifierRole(node, parent, ancestors);
             if (role === null)
                 return;
             // A compound assignment or update reads before it writes; emit both so
             // reference consumers see the read they actually execute.
-            const roles = role === "write" && semanticReadsBeforeWrite(node, parent)
+            const roles = role === "write" &&
+                semanticReadsBeforeWrite(node, semanticWrappedWriteSite(node, parent, ancestors) ?? parent)
                 ? ["read", "write"]
                 : [role];
             for (const resolvedRole of roles) {
@@ -176,7 +205,7 @@ const callableName = (node, parent) => {
 const collectImports = (node, state) => {
     if (node.specifiers.length === 0)
         addModuleLink(state, {
-            kind: "import",
+            kind: isTypeOnlyImportDeclaration(node) ? "type-import" : "import",
             specifier: node.source.value,
             importedName: null,
             localName: null,
@@ -185,7 +214,11 @@ const collectImports = (node, state) => {
         }, node);
     for (const specifier of node.specifiers)
         addModuleLink(state, {
-            kind: "import",
+            kind: isTypeOnlyImportDeclaration(node) ||
+                (t.isImportSpecifier(specifier) &&
+                    isTypeOnlyImportSpecifier(specifier))
+                ? "type-import"
+                : "import",
             specifier: node.source.value,
             importedName: t.isImportDefaultSpecifier(specifier)
                 ? "default"
@@ -198,10 +231,11 @@ const collectImports = (node, state) => {
         }, node);
 };
 const collectNamedExports = (node, state) => {
+    const declarationTypeOnly = isTypeOnlyExportDeclaration(node);
     if (node.declaration !== null && node.declaration !== undefined)
         for (const localName of declarationNames(node.declaration))
             addModuleLink(state, {
-                kind: "export",
+                kind: declarationTypeOnly ? "type-import" : "export",
                 specifier: null,
                 importedName: null,
                 localName,
@@ -210,21 +244,34 @@ const collectNamedExports = (node, state) => {
                 location: range(node.declaration),
             }, node);
     for (const specifier of node.specifiers)
-        if (t.isExportSpecifier(specifier))
+        if (t.isExportSpecifier(specifier) ||
+            (t.isExportNamespaceSpecifier(specifier) && node.exportKind !== "type"))
             addModuleLink(state, {
-                kind: node.source == null ? "export" : "re-export",
+                kind: declarationTypeOnly ||
+                    (t.isExportSpecifier(specifier) &&
+                        isTypeOnlyExportSpecifier(specifier))
+                    ? "type-import"
+                    : node.source == null
+                        ? "export"
+                        : "re-export",
                 specifier: node.source?.value ?? null,
-                importedName: propertyName(specifier.local),
-                localName: node.source == null ? propertyName(specifier.local) : null,
+                importedName: t.isExportNamespaceSpecifier(specifier)
+                    ? "*"
+                    : propertyName(specifier.local),
+                localName: node.source == null && t.isExportSpecifier(specifier)
+                    ? propertyName(specifier.local)
+                    : null,
                 exportedName: propertyName(specifier.exported),
                 location: range(specifier),
             }, node);
 };
 const collectRequireLink = (node, state) => {
-    const origin = semanticRequireOrigin(node.init, state);
-    if (origin === undefined)
+    const required = semanticRequireOrigin(node.init, state);
+    if (required === undefined)
         return;
-    for (const binding of requirePatternBindings(node.id, origin.importedPath))
+    const { origin, call } = required;
+    const bindings = requirePatternBindings(node.id, origin.importedPath);
+    for (const binding of bindings)
         addModuleLink(state, {
             kind: "require",
             specifier: origin.specifier,
@@ -233,6 +280,24 @@ const collectRequireLink = (node, state) => {
             exportedName: null,
             location: range(node),
         }, node);
+    if (bindings.length > 0)
+        state.linkedRequireCalls.add(call);
+};
+const collectUnboundRequireLink = (node, state) => {
+    if (state.linkedRequireCalls.has(node))
+        return;
+    const required = semanticRequireOrigin(node, state);
+    if (required === undefined)
+        return;
+    addModuleLink(state, {
+        kind: "require",
+        specifier: required.origin.specifier,
+        importedName: null,
+        localName: null,
+        exportedName: null,
+        location: range(node),
+    }, node);
+    state.linkedRequireCalls.add(node);
 };
 const requirePatternBindings = (pattern, path) => {
     if (t.isTSParameterProperty(pattern))
@@ -256,21 +321,35 @@ const requirePatternBindings = (pattern, path) => {
             : requirePatternBindings(element, [...path, String(index)]));
     return [];
 };
-const collectCommonJsExport = (node, state) => {
+const collectCommonJsExport = (node, state, receiverEffect) => {
     const exportedName = commonJsExportName(node.left, state);
     if (exportedName === undefined)
         return;
-    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;
+    // Compound and logical writes also depend on the previous value, so remain
+    // unknown.
+    const value = node.operator === "=" && receiverEffect !== "uncertain" ? node.right : null;
+    addCommonJsExport(node, state, exportedName, value);
+};
+const collectDefinedCommonJsExport = (node, state, receiverEffect) => {
+    const defined = commonJsDefinedExport(node, state);
+    if (defined === undefined || receiverEffect === "detached")
+        return;
+    // A data descriptor exports its value; an accessor's result stays unknown.
+    const descriptor = unwrapJavaScriptExpression(defined.descriptor).node;
+    const value = receiverEffect !== "uncertain" && t.isObjectExpression(descriptor)
+        ? (semanticFinalObjectProperty(descriptor, "value") ?? null)
+        : null;
+    addCommonJsExport(node, state, defined.exportedName, value);
+};
+const addCommonJsExport = (node, state, exportedName, exported) => {
+    // Simple assignment chains yield their rightmost assigned value.
+    let value = exported;
     while (t.isAssignmentExpression(value, { operator: "=" }))
         value = value.right;
-    const origin = value === null ? undefined : semanticRequireOrigin(value, state);
+    const required = value === null ? undefined : semanticRequireOrigin(value, state);
+    const origin = required?.origin;
     addModuleLink(state, {
         kind: "commonjs-export",
         specifier: origin?.specifier ?? null,
@@ -280,37 +359,27 @@ const collectCommonJsExport = (node, state) => {
         callableId: value === null ? null : semanticCallableIdForNode(value),
         location: range(node),
     }, node);
-};
-/**
- * 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));
+    if (required !== undefined)
+        state.linkedRequireCalls.add(required.call);
 };
 const addModuleLink = (state, link, referenceNode) => {
-    const collected = { ...link, callableId: link.callableId ?? null };
+    const resolutionMode = link.resolutionMode ??
+        (link.kind === "import" ||
+            link.kind === "re-export" ||
+            link.kind === "type-import"
+            ? state.staticImportResolutionMode
+            : link.kind === "require"
+                ? "require"
+                : undefined);
+    const collected = {
+        ...link,
+        ...(resolutionMode === undefined ? {} : { resolutionMode }),
+        callableId: link.callableId ?? null,
+    };
     state.moduleLinks.push(collected);
+    if (t.isExportDefaultDeclaration(referenceNode) &&
+        t.isExpression(referenceNode.declaration))
+        state.defaultExportExpressions.set(collected, referenceNode.declaration);
     if (link.localName !== null) {
         const binding = resolveSemanticBindingState(state, referenceNode, link.localName);
         if (binding !== undefined)
@@ -343,10 +412,12 @@ const declarationCallableId = (declaration, localName) => {
  * One predicate serves both member operations and identifier references so the
  * two can never disagree about what counts as a read-modify-write.
  */
-export const semanticReadsBeforeWrite = (node, parent) => (t.isAssignmentExpression(parent) &&
-    parent.left === node &&
-    parent.operator !== "=") ||
-    (t.isUpdateExpression(parent) && parent.argument === node);
+export const semanticReadsBeforeWrite = (node, site) => {
+    const target = semanticWriteSiteTarget(site);
+    return (target !== null &&
+        unwrapJavaScriptExpression(target).node === node &&
+        semanticWriteSiteReadsFirst(site));
+};
 /**
  * Role of one identifier occurrence, given the node's ancestry.
  *
@@ -363,6 +434,9 @@ export const semanticIdentifierRole = (node, parent, ancestors) => {
             return null;
         return "write";
     }
+    const site = semanticWrappedWriteSite(node, parent, ancestors);
+    if (site !== null && site !== parent && !isDeleteSite(site))
+        return "write";
     return semanticReferenceRole(node, parent);
 };
 /**
@@ -416,7 +490,9 @@ const isPatternNode = (node) => t.isObjectPattern(node) ||
     t.isArrayPattern(node) ||
     t.isAssignmentPattern(node) ||
     t.isRestElement(node);
-const isPatternOwnerDeclaration = (node) => (t.isVariableDeclarator(node) && t.isPattern(node.id)) ||
+const isDeleteSite = (site) => t.isUnaryExpression(site, { operator: "delete" });
+const isPatternOwnerDeclaration = (node) => t.isTSParameterProperty(node) ||
+    (t.isVariableDeclarator(node) && t.isPattern(node.id)) ||
     (t.isFunction(node) &&
         node.params.some((value) => t.isPattern(value))) ||
     (t.isCatchClause(node) && node.param !== null && t.isPattern(node.param));
@@ -433,18 +509,24 @@ export const semanticReferenceRole = (node, parent) => {
         return "export";
     return "read";
 };
-const isDeclarationIdentifier = (node, parent) => (t.isVariableDeclarator(parent) && patternContains(parent.id, node)) ||
-    ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent)) &&
-        parent.id === node) ||
-    (t.isFunction(parent) &&
-        parent.params.some((value) => patternContains(value, node))) ||
-    ((t.isClassDeclaration(parent) || t.isClassExpression(parent)) &&
-        parent.id === node) ||
-    (t.isImportSpecifier(parent) &&
-        (parent.local === node || parent.imported === node)) ||
-    (t.isImportDefaultSpecifier(parent) && parent.local === node) ||
-    (t.isImportNamespaceSpecifier(parent) && parent.local === node) ||
-    (t.isCatchClause(parent) && parent.param === node);
+const isDeclarationIdentifier = (node, parent) => {
+    if (t.isTSImportEqualsDeclaration(parent))
+        return parent.id === node;
+    return ((t.isTSParameterProperty(parent) &&
+        patternContains(parent.parameter, node)) ||
+        (t.isVariableDeclarator(parent) && patternContains(parent.id, node)) ||
+        ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent)) &&
+            parent.id === node) ||
+        (t.isFunction(parent) &&
+            parent.params.some((value) => patternContains(value, node))) ||
+        ((t.isClassDeclaration(parent) || t.isClassExpression(parent)) &&
+            parent.id === node) ||
+        (t.isImportSpecifier(parent) &&
+            (parent.local === node || parent.imported === node)) ||
+        (t.isImportDefaultSpecifier(parent) && parent.local === node) ||
+        (t.isImportNamespaceSpecifier(parent) && parent.local === node) ||
+        (t.isCatchClause(parent) && parent.param === node));
+};
 const isNonReferenceKey = (node, parent) => ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
     parent.property === node &&
     !parent.computed) ||
@@ -452,10 +534,18 @@ const isNonReferenceKey = (node, parent) => ((t.isMemberExpression(parent) || t.
         parent.key === node &&
         !parent.computed &&
         !(t.isObjectProperty(parent) && parent.shorthand)) ||
+    isNoncomputedClassMemberKey(node, parent) ||
+    t.isPrivateName(parent) ||
     (t.isExportSpecifier(parent) && parent.exported === node) ||
     t.isLabeledStatement(parent) ||
     t.isBreakStatement(parent) ||
     t.isContinueStatement(parent);
+/** A noncomputed class member name is a property key, never a lexical read. */
+const isNoncomputedClassMemberKey = (node, parent) => (t.isClassMethod(parent) ||
+    t.isClassProperty(parent) ||
+    t.isTSDeclareMethod(parent)) &&
+    parent.key === node &&
+    !parent.computed;
 const patternNames = (pattern) => {
     if (t.isTSParameterProperty(pattern))
         return patternNames(pattern.parameter);
@@ -474,6 +564,8 @@ const patternNames = (pattern) => {
     return [];
 };
 const patternContains = (pattern, target) => pattern === target ||
+    (t.isTSParameterProperty(pattern) &&
+        patternContains(pattern.parameter, target)) ||
     (t.isAssignmentPattern(pattern) && patternContains(pattern.left, target)) ||
     (t.isRestElement(pattern) && patternContains(pattern.argument, target)) ||
     (t.isObjectPattern(pattern) &&
@@ -489,29 +581,22 @@ const declarationNames = (declaration) => {
         t.isClassDeclaration(declaration)) &&
         t.isIdentifier(declaration.id))
         return [declaration.id.name];
+    if ((t.isTSInterfaceDeclaration(declaration) ||
+        t.isTSTypeAliasDeclaration(declaration) ||
+        t.isTSDeclareFunction(declaration)) &&
+        t.isIdentifier(declaration.id))
+        return [declaration.id.name];
+    if (t.isTSImportEqualsDeclaration(declaration) &&
+        semanticImportEqualsSpecifier(declaration) !== null)
+        return [declaration.id.name];
     return [];
 };
-const defaultDeclarationName = (declaration) => (t.isFunctionDeclaration(declaration) || t.isClassDeclaration(declaration)) &&
-    t.isIdentifier(declaration.id)
-    ? declaration.id.name
-    : null;
-const commonJsExportName = (node, state) => {
-    // 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);
-    // `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.
-    if (isUnshadowedGlobal(node.object, state, "exports"))
-        return key === null ? "*" : key || "*";
-    if (t.isMemberExpression(node.object) &&
-        isCommonJsModuleExports(node.object, state))
-        return key === null ? "*" : key || "default";
-    if (isCommonJsModuleExports(node, state))
-        return "default";
-    return undefined;
+const defaultExportLocalName = (declaration) => {
+    const value = unwrapJavaScriptExpression(declaration).node;
+    if (t.isIdentifier(value))
+        return value.name;
+    return (t.isFunctionDeclaration(value) || t.isClassDeclaration(value)) &&
+        t.isIdentifier(value.id)
+        ? value.id.name
+        : null;
 };
-const isCommonJsModuleExports = (node, state) => (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
-    isUnshadowedGlobal(node.object, state, "module") &&
-    semanticStaticPropertyKey(node.property, node.computed) === "exports";

package/dist/domain/javascript/javascriptSemanticPromises.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";
 import { semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
@@ -31,20 +32,18 @@ export const collectJavaScriptSemanticPromises = (program, state, callables) =>
 const collectCandidates = (program, state, callables) => {
     const output = [];
     const admittedCallables = new Set(callables.map(({ callableId }) => callableId));
-    const callableStack = [];
+    const callableStack = createSemanticCallableIdStack(admittedCallables);
     const ancestors = [];
     traverseJavaScriptAst(program, {
-        enter: (node) => {
-            const callableId = semanticCallableIdForNode(node);
-            if (callableId !== null && admittedCallables.has(callableId))
-                callableStack.push(callableId);
+        enter: (node, parent) => {
+            callableStack.enter(node, parent);
             const details = promiseCandidateDetails(node, state);
             if (details !== null) {
                 output.push({
                     node,
                     ...details,
                     promiseId: semanticPromiseId(details.kind, node),
-                    ownerCallableId: callableStack.at(-1) ?? null,
+                    ownerCallableId: callableStack.callables.at(-1) ?? null,
                     ancestors: [...ancestors],
                 });
             }
@@ -52,9 +51,7 @@ const collectCandidates = (program, state, callables) => {
         },
         exit: (node) => {
             ancestors.pop();
-            const callableId = semanticCallableIdForNode(node);
-            if (callableId !== null && callableStack.at(-1) === callableId)
-                callableStack.pop();
+            callableStack.exit(node);
         },
     });
     return output;

package/dist/domain/javascript/javascriptSemanticProvenance.js

@@ -21,7 +21,11 @@ export const semanticOriginsProvenance = (origins) => {
 export const uniqueSemanticOrigins = (origins) => [
     ...new Map(origins.map((origin) => [semanticOriginKey(origin), origin])).values(),
 ].sort((left, right) => compareUnicodeCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
-const semanticOriginKey = (origin) => JSON.stringify([origin.specifier, origin.importedPath]);
+const semanticOriginKey = (origin) => JSON.stringify([
+    origin.specifier,
+    origin.importedPath,
+    origin.resolutionMode ?? "import",
+]);
 /** 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

@@ -138,9 +138,14 @@ const relevantUnknownFrontiers = (graph, nodeIds, input) => {
         ? null
         : new Set(input.allowed_relations);
     return graph.unknowns.filter((unknown) => (unknown.node_id === null || nodeIds.has(unknown.node_id)) &&
-        (allowed === null ||
-            unknown.relation_kinds.some((relation) => allowed.has(relation))));
+        unknown.relation_kinds.some((relation) => directionAllowsRelation(input.direction, relation) &&
+            (allowed === null || allowed.has(relation))));
 };
+const directionAllowsRelation = (direction, relation) => direction === "callers"
+    ? relation === "calls"
+    : direction === "ownership"
+        ? ownershipRelation(relation)
+        : true;
 const relevantCandidateRelationCount = (graph, nodeIds, input) => {
     const allowed = input.allowed_relations === undefined
         ? null

package/dist/domain/javascript/javascriptSemanticQueryIdentity.js

@@ -55,7 +55,8 @@ const seedMatches = (node, input, fingerprintFunctions) => {
     if (seed.kind === "property")
         return node.kind === "property-slot" && node.properties.name === seed.name;
     if (seed.kind === "endpoint")
-        return node.kind === "request" && node.properties.endpoint === seed.value;
+        return ((node.kind === "request" || node.kind === "response") &&
+            node.properties.endpoint === seed.value);
     if (seed.kind === "event")
         return (["event", "listener"].includes(node.kind) &&
             node.properties.event_name === seed.name);

package/dist/domain/javascript/javascriptSemanticQuerySchemas.js

@@ -30,7 +30,7 @@ export const javaScriptSemanticQuerySeedSchema = z.discriminatedUnion("kind", [
     }),
     z.strictObject({
         kind: z.literal("property"),
-        name: z.string().min(1),
+        name: z.string(),
     }),
     z.strictObject({
         kind: z.literal("endpoint"),

package/dist/domain/javascript/javascriptSemanticReferenceSources.js

@@ -0,0 +1,25 @@
+import { evaluateSemanticExpression } from "./javascriptSemanticValues.js";
+import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";
+/** Exclude references whose source slot or destructuring fallback is absent. */
+export const semanticReferenceSourcesInactive = (reference, state) => reference.requiredSources?.some((source) => semanticSelectedReferenceSlot(source, state, source.node)?.presence ===
+    "absent") === true ||
+    reference.fallbackSources?.some((source) => {
+        // Selection precedes effects through the chosen reference. A later escape
+        // cannot make a fallback that was excluded at destructuring reachable.
+        const slot = semanticSelectedReferenceSlot(source, state, source.node);
+        return (slot?.presence === "present" &&
+            (slot.value.status === "literal" ||
+                slot.value.status === "union" ||
+                slot.value.status === "object" ||
+                slot.value.status === "array"));
+    }) === true;
+/** Select a retained source slot at its capture, before later effects. */
+export const semanticSelectedReferenceSlot = (source, state, capturePoint) => {
+    const path = [];
+    for (const key of source.projection) {
+        if (key === null || typeof key === "object")
+            return undefined;
+        path.push(String(key));
+    }
+    return semanticSlotAtPath(evaluateSemanticExpression(source.node, state, capturePoint), path);
+};