rea-agents 6.2.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticAnalysis.js

@@ -1,17 +1,21 @@
 import * as t from "@babel/types";
 import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
-import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { collectSemanticMemberMutations } from "./javascriptSemanticMemberMutations.js";
+import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, collectSemanticReferencesSteps, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
+import { semanticObjectPatternKeys, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticBindingId, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
+import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
+import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
+import { collectSemanticMemberMutationsSteps } from "./javascriptSemanticMemberMutations.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
-import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
+import { collectJavaScriptDerivedSemanticsSteps } from "./javascriptSemanticDerivedAnalysis.js";
+import { evaluateSemanticProvenance } from "./javascriptSemanticValues.js";
+import { collectElectronMemberWritesSteps, electronExportPath, electronMemberPath, ELECTRON_MODULE, } from "./javascriptElectronMemberWrites.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { propertyName } from "./javascriptAstValues.js";
 import { semanticCoverage } from "./javascriptSemanticCoverage.js";
 import { semanticResourceLimitsIn } from "./javascriptSemanticResourceLimits.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
+import { isJavaScriptRpcClientFactory } from "./javascriptRpcEndpoints.js";
 /** Recover lexical bindings, aliases, constants, and module links. */
 export const analyzeJavaScriptSemantics = (source) => {
     const file = parseJavaScriptSource(source);
@@ -22,23 +26,33 @@ export const analyzeJavaScriptSemantics = (source) => {
 /** Recover lexical references, optionally for one name, without evaluating values or provenance. */
 export const analyzeParsedJavaScriptReferences = (file, name) => {
     const state = createState(file.program);
-    collectDefinitions(file.program, state);
+    completeSemanticSteps(collectDefinitionsSteps(file.program, state));
     return collectSemanticReferences(file.program, state, name);
 };
 /** Recover semantics from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptSemantics = (file) => {
+export const analyzeParsedJavaScriptSemantics = (file) => completeSemanticSteps(analyzeParsedJavaScriptSemanticsSteps(file));
+/**
+ * Recover semantics from a parsed artifact with a yield between analysis
+ * phases, so a caller can serve control messages within one large file.
+ * Each phase completes before the next starts; results equal the synchronous
+ * form.
+ */
+export function* analyzeParsedJavaScriptSemanticsSteps(file) {
     const state = createState(file.program);
-    collectDefinitions(file.program, state);
-    collectSemanticMemberMutations(file.program, state);
-    traverseJavaScriptAst(file.program, {
+    yield* collectDefinitionsSteps(file.program, state);
+    yield* collectSemanticMemberMutationsSteps(file.program, state);
+    yield* traverseJavaScriptAstSteps(file.program, {
         enter: (node) => collectSemanticModuleLink(node, state),
     });
-    const references = collectSemanticReferences(file.program, state);
+    yield;
+    const references = yield* collectSemanticReferencesSteps(file.program, state);
     const parserPartial = file.errors.length > 0;
     const bindings = immutableSemanticBindings(state);
+    yield;
     const callables = collectSemanticReturns(file.program, state, parserPartial);
+    yield;
     const moduleLinks = resolveSemanticModuleCallables(state, callables);
-    const derived = collectJavaScriptDerivedSemantics(file.program, state, callables, parserPartial);
+    const derived = yield* collectJavaScriptDerivedSemanticsSteps(file.program, state, callables, parserPartial);
     return {
         schema: "JavaScriptSemanticIR",
         scopes: immutableSemanticScopes(state),
@@ -64,17 +78,53 @@ export const analyzeParsedJavaScriptSemantics = (file) => {
             "Cross-function mutation and dynamic property resolution remain unknown.",
         ],
     };
-};
+}
+/** Resolve tRPC client roots by lexical identity, excluding overwritten bindings. */
+export function* classifyParsedJavaScriptRpcClientRootsSteps(file) {
+    const state = createState(file.program);
+    yield* collectDefinitionsSteps(file.program, state);
+    const roots = new Set();
+    const clients = new Map();
+    yield* traverseJavaScriptAstSteps(file.program, {
+        enter: (node) => {
+            if (!t.isMemberExpression(node) && !t.isOptionalMemberExpression(node))
+                return;
+            const root = node.object;
+            if (!t.isIdentifier(root))
+                return;
+            const binding = resolveSemanticBindingState(state, root, root.name);
+            if (binding === undefined)
+                return;
+            let client = clients.get(binding.bindingId);
+            if (client === undefined) {
+                const [initializer] = binding.initializers;
+                client =
+                    initializer !== undefined &&
+                        initializer.projection.length === 0 &&
+                        binding.initializers.length === 1 &&
+                        !binding.definitions.some(({ kind }) => kind === "assignment") &&
+                        !state.conditionalInitializers.has(initializer.node) &&
+                        isJavaScriptRpcClientFactory(initializer.node);
+                clients.set(binding.bindingId, client);
+            }
+            if (client)
+                roots.add(root);
+        },
+    });
+    return roots;
+}
 /**
  * Resolve only the lexical receiver identity needed to distinguish browser
  * `window.open` from XHR and global storage `.open` calls. This deliberately
  * builds definitions without running semantic value or provenance analysis.
  */
-export const classifyParsedJavaScriptOpenReceivers = (file) => {
+export const classifyParsedJavaScriptOpenReceivers = (file) => completeSemanticSteps(classifyParsedJavaScriptOpenReceiversSteps(file));
+/** Classify `.open` receivers while yielding during lexical and AST scans. */
+export function* classifyParsedJavaScriptOpenReceiversSteps(file) {
     const state = createState(file.program);
-    collectDefinitions(file.program, state);
+    yield* collectDefinitionsSteps(file.program, state);
     const facts = new Map();
-    traverseJavaScriptAst(file.program, {
+    yield* traverseJavaScriptAstSteps(file.program, {
         enter: (node) => {
             if ((!t.isCallExpression(node) && !t.isOptionalCallExpression(node)) ||
                 (!t.isMemberExpression(node.callee) &&
@@ -133,7 +183,7 @@ export const classifyParsedJavaScriptOpenReceivers = (file) => {
         },
     });
     return facts;
-};
+}
 const openGlobalFact = (name) => {
     if (name === "window" ||
         name === "self" ||
@@ -156,6 +206,95 @@ const resolveGlobalAliasFact = (state, node, name) => {
         return undefined;
     return openGlobalFact(name);
 };
+/**
+ * Proven Electron export path segments for call and construction roots, keyed by
+ * root offset. Only proven Electron origins are present; callers must not
+ * infer an Electron export from an absent entry or familiar local name.
+ */
+export const classifyParsedJavaScriptElectronBindings = (file) => completeSemanticSteps(classifyParsedJavaScriptElectronBindingsSteps(file));
+/** Resolve Electron aliases while yielding during lexical and AST scans. */
+export function* classifyParsedJavaScriptElectronBindingsSteps(file) {
+    const facts = new Map();
+    const state = createState(file.program);
+    yield* collectDefinitionsSteps(file.program, state);
+    const exportsByBinding = new Map();
+    const rootExport = (root) => {
+        if (t.isIdentifier(root)) {
+            if (semanticResolutionBlocked(state, root, root.name))
+                return undefined;
+            const binding = resolveSemanticBindingState(state, root, root.name);
+            if (binding === undefined)
+                return undefined;
+            let exported = exportsByBinding.get(binding.bindingId);
+            if (exported === undefined) {
+                exported = electronExport(binding, state);
+                exportsByBinding.set(binding.bindingId, exported);
+            }
+            return exported ?? undefined;
+        }
+        const origin = semanticRequireOrigin(root, state);
+        return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)
+            ? electronExportPath(origin.importedPath)
+            : undefined;
+    };
+    const writes = yield* collectElectronMemberWritesSteps(file.program, rootExport);
+    yield* traverseJavaScriptAstSteps(file.program, {
+        enter: (node) => {
+            if (!t.isCallExpression(node) &&
+                !t.isOptionalCallExpression(node) &&
+                !t.isNewExpression(node))
+                return;
+            const { root, members } = electronMemberPath(node.callee);
+            const exported = rootExport(root);
+            if (exported !== undefined && !writes.covers([...exported, ...members]))
+                facts.set(root.start ?? -1, exported);
+        },
+    });
+    return facts;
+}
+// Read import and require origins directly; general value evaluation is
+// unnecessary here and costly across large vendor bundles.
+const electronExport = (binding, state) => {
+    if (binding.definitions.some(({ kind }) => kind === "assignment"))
+        return null;
+    const directOrigin = bindingOrigin(binding, state);
+    const [initializer] = binding.initializers;
+    if (directOrigin === undefined &&
+        (initializer === undefined ||
+            binding.initializers.length !== 1 ||
+            state.conditionalInitializers.has(initializer.node)))
+        return null;
+    const provenance = directOrigin === undefined
+        ? evaluateSemanticProvenance(binding, state)
+        : undefined;
+    const origin = directOrigin ??
+        (provenance?.status === "module" && provenance.origins.length === 1
+            ? provenance.origins[0]
+            : undefined);
+    return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)
+        ? electronExportPath(origin.importedPath)
+        : null;
+};
+const bindingOrigin = (binding, state) => {
+    if (binding.directOrigins.length > 0)
+        return binding.directOrigins.length === 1
+            ? binding.directOrigins[0]
+            : undefined;
+    const [initializer] = binding.initializers;
+    // A var/let declaration permits writes without proving one occurred.
+    // Require one unconditional initializer and no actual binding writes.
+    if (initializer === undefined ||
+        binding.initializers.length !== 1 ||
+        binding.definitions.some(({ kind }) => kind === "assignment") ||
+        state.conditionalInitializers.has(initializer.node))
+        return undefined;
+    const origin = semanticRequireOrigin(initializer.node, state);
+    const projection = initializer.projection;
+    return origin === undefined ||
+        !projection.every((key) => typeof key === "string")
+        ? undefined
+        : { ...origin, importedPath: [...origin.importedPath, ...projection] };
+};
 const createState = (program) => {
     const root = {
         scopeId: semanticScopeId("program", program),
@@ -166,6 +305,7 @@ const createState = (program) => {
         bindings: new Map(),
     };
     return {
+        parentsByNode: new WeakMap(),
         scopes: [root],
         scopesById: new Map([[root.scopeId, root]]),
         scopeByNode: new WeakMap([[program, root]]),
@@ -173,16 +313,36 @@ const createState = (program) => {
         callables: [],
         callableNodesById: new Map(),
         moduleLinks: [],
+        moduleLinkBindings: new WeakMap(),
+        conditionalInitializers: new WeakSet(),
     };
 };
-const collectDefinitions = (program, state) => {
+function* collectDefinitionsSteps(program, state) {
     const stack = [
         currentSemanticScope(state.scopes),
     ];
     const openedScopes = new WeakMap();
-    traverseJavaScriptAst(program, {
-        enter: (node, parent) => {
+    const assignments = [];
+    const functionBodies = [];
+    yield* traverseJavaScriptAstSteps(program, {
+        enter: (node, parent, readAncestors) => {
+            if (parent !== null)
+                state.parentsByNode.set(node, parent);
             let parentScope = currentSemanticScope(stack);
+            if (parent !== null &&
+                (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&
+                parent.computed &&
+                parent.key === node &&
+                parentScope.parentScopeId !== null) {
+                // A computed method key is evaluated before entering the method's
+                // parameter and body environments.
+                const keyScope = state.scopesById.get(parentScope.parentScopeId);
+                if (keyScope !== undefined) {
+                    stack.push(keyScope);
+                    openedScopes.set(node, 1);
+                    parentScope = keyScope;
+                }
+            }
             if (parent !== null &&
                 t.isWithStatement(parent) &&
                 parent.body === node) {
@@ -205,9 +365,18 @@ const collectDefinitions = (program, state) => {
             if (nested !== undefined) {
                 stack.push(nested);
                 openedScopes.set(node, (openedScopes.get(node) ?? 0) + 1);
+                if (t.isBlockStatement(node) && t.isFunction(parent))
+                    functionBodies.push({
+                        body: node,
+                        scope: nested,
+                        parameters: parent.params,
+                    });
             }
             const scope = currentSemanticScope(stack);
-            state.scopeByNode.set(node, scope);
+            // Other nodes inherit the nearest boundary through their AST parents.
+            // Avoid a second full-tree index for the same lexical relationship.
+            if (parent === null || openedScopes.has(node))
+                state.scopeByNode.set(node, scope);
             collectSemanticCallable({
                 node,
                 parent,
@@ -216,12 +385,79 @@ const collectDefinitions = (program, state) => {
                 state,
             });
             bindInnerDeclaration(node, parent, scope, state);
+            if (t.isVariableDeclarator(node) &&
+                node.init != null &&
+                parent !== null &&
+                t.isVariableDeclaration(parent, { kind: "var" }) &&
+                hasConditionalInitializer(readAncestors()))
+                state.conditionalInitializers.add(node.init);
+            if (t.isAssignmentExpression(node) ||
+                t.isUpdateExpression(node) ||
+                t.isForOfStatement(node) ||
+                t.isForInStatement(node))
+                assignments.push({ node, scope });
         },
         exit: (node) => {
             for (let count = openedScopes.get(node) ?? 0; count > 0; count--)
                 stack.pop();
         },
     });
+    // All declarations must exist before resolving writes, including hoisted
+    // functions and local declarations that shadow an outer binding.
+    for (const [index, { node, scope }] of assignments.entries()) {
+        if (index % 64 === 0)
+            yield;
+        bindAssignment(node, scope, state);
+    }
+    for (const [index, { body, scope, parameters }] of functionBodies.entries()) {
+        if (index % 64 === 0)
+            yield;
+        for (const parameter of parameters)
+            for (const identifier of assignedPatternIdentifiers(t.isTSParameterProperty(parameter) ? parameter.parameter : parameter))
+                copyParameterToBody({ identifier, body, scope, state });
+    }
+}
+const copyParameterToBody = (input) => {
+    const { identifier, body, scope, state } = input;
+    const binding = scope.bindings.get(identifier.name);
+    if (binding === undefined ||
+        binding.kind !== "variable" ||
+        binding.definitions.some(({ kind }) => kind === "function"))
+        return;
+    // A separate body var environment starts with the parameter's value. The
+    // real parameter identifier retains its scope and source location; entryBody
+    // records when the copy occurs without inventing an expression in the AST.
+    binding.initializers.unshift({
+        node: identifier,
+        projection: [],
+        entryBody: body,
+    });
+    for (let index = binding.initializers.length - 1; index >= 0; index -= 1) {
+        const initializer = binding.initializers[index];
+        if (initializer !== undefined &&
+            initializer.entryBody === undefined &&
+            initializer.projection.length === 0 &&
+            t.isIdentifier(initializer.node) &&
+            resolveSemanticBindingState(state, initializer.node, initializer.node.name) === binding)
+            // Direct self-initialization preserves the prior value, including any
+            // actual overwrite before it. Keep the source definition/reference facts.
+            binding.initializers.splice(index, 1);
+    }
+};
+const hasConditionalInitializer = (ancestors) => {
+    // A hoisted var can remain undefined when control flow skips its initializer.
+    // Conditions outside the owning callable/static block do not govern its body.
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const node = ancestors[index];
+        if (t.isFunction(node) || t.isProgram(node) || t.isStaticBlock(node))
+            return false;
+        if (t.isIfStatement(node) ||
+            t.isLoop(node) ||
+            t.isSwitchCase(node) ||
+            t.isTryStatement(node))
+            return true;
+    }
+    return false;
 };
 const bindOuterDeclaration = (node, scope, state) => {
     if (t.isFunctionDeclaration(node) && t.isIdentifier(node.id))
@@ -279,7 +515,9 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
             mutable: true,
             kind: "catch",
         });
-    else if (t.isAssignmentExpression(node)) {
+};
+const bindAssignment = (node, scope, state) => {
+    if (t.isAssignmentExpression(node)) {
         if (t.isIdentifier(node.left))
             addAssignment(node.left, node.operator === "=" ||
                 node.operator === "||=" ||
@@ -293,8 +531,23 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
     else if (t.isUpdateExpression(node) && t.isIdentifier(node.argument))
         addAssignment(node.argument, node, scope, state);
     else if (t.isForOfStatement(node) || t.isForInStatement(node))
-        for (const identifier of assignedPatternIdentifiers(node.left))
-            addAssignment(identifier, node, scope, state);
+        for (const pattern of t.isVariableDeclaration(node.left)
+            ? node.left.declarations.map(({ id }) => id)
+            : [node.left]) {
+            for (const identifier of assignedPatternIdentifiers(pattern))
+                addAssignment(identifier, node, scope, state);
+            if (t.isForOfStatement(node))
+                // Keep the loop value unknown, but preserve references yielded into
+                // each bound slot so writes/escapes can reach their iterable origins.
+                bindPattern({
+                    pattern,
+                    initializer: node,
+                    scope,
+                    state,
+                    mutable: true,
+                    referenceOnly: true,
+                });
+        }
 };
 const assignedPatternIdentifiers = (pattern) => {
     const identifiers = [];
@@ -392,10 +645,47 @@ const scopeKind = (node, parent) => {
     if (t.isStaticBlock(node))
         return "static-block";
     if (t.isBlockStatement(node) &&
-        !(parent !== null && t.isFunction(parent) && parent.body === node))
+        parent !== null &&
+        t.isFunction(parent) &&
+        parent.body === node) {
+        // Parameter expressions cannot see declarations in the function body.
+        // Retain the outer function scope for parameters and callable ownership;
+        // body declarations belong to a separate variable environment.
+        return functionParametersHaveExpressions(parent) ? "function" : undefined;
+    }
+    if (t.isBlockStatement(node))
         return "block";
     return undefined;
 };
+const functionParametersHaveExpressions = (node) => {
+    const pending = [...node.params];
+    while (pending.length > 0) {
+        const parameter = pending.pop();
+        if (t.isAssignmentPattern(parameter))
+            return true;
+        if (t.isTSParameterProperty(parameter))
+            pending.push(parameter.parameter);
+        else if (t.isRestElement(parameter))
+            pending.push(parameter.argument);
+        else if (t.isArrayPattern(parameter)) {
+            for (const element of parameter.elements)
+                if (element !== null)
+                    pending.push(element);
+        }
+        else if (t.isObjectPattern(parameter)) {
+            for (const property of parameter.properties) {
+                if (t.isRestElement(property))
+                    pending.push(property.argument);
+                else {
+                    if (property.computed)
+                        return true;
+                    pending.push(property.value);
+                }
+            }
+        }
+    }
+    return false;
+};
 const bindImports = (node, scope, state) => {
     for (const specifier of node.specifiers) {
         const importedPath = t.isImportDefaultSpecifier(specifier)
@@ -429,12 +719,29 @@ const bindFunctionLocals = (node, scope, state) => {
         });
 };
 const bindPattern = (input) => {
-    const { pattern, initializer, scope, state, mutable, kind = "variable", projection = [], } = input;
+    const { pattern, initializer, scope, state, mutable, kind = "variable", projection = [], referenceOnly = false, copyKind, copyProjectionOffset, copyExcludedKeys, copyStartIndex, fallbackSources, requiredSources, } = input;
     if (t.isTSParameterProperty(pattern)) {
         bindPattern({ ...input, pattern: pattern.parameter });
         return;
     }
     if (t.isIdentifier(pattern)) {
+        if (referenceOnly) {
+            const binding = resolveSemanticBindingFromScope(scope, pattern.name, state);
+            if (binding !== undefined && initializer !== null)
+                binding.referenceInitializers.push({
+                    node: initializer,
+                    projection,
+                    ...(copyKind === undefined ? {} : { copyKind }),
+                    ...(copyProjectionOffset === undefined
+                        ? {}
+                        : { copyProjectionOffset }),
+                    ...(copyExcludedKeys === undefined ? {} : { copyExcludedKeys }),
+                    ...(copyStartIndex === undefined ? {} : { copyStartIndex }),
+                    ...(fallbackSources === undefined ? {} : { fallbackSources }),
+                    ...(requiredSources === undefined ? {} : { requiredSources }),
+                });
+            return;
+        }
         addBinding({
             state,
             scope,
@@ -454,6 +761,25 @@ const bindPattern = (input) => {
             initializer: kind === "parameter" || kind === "catch"
                 ? initializer
                 : (initializer ?? pattern.right),
+            requiredSources: [
+                ...(requiredSources ?? []),
+                ...(initializer === null ? [] : [{ node: initializer, projection }]),
+            ],
+        });
+        bindPattern({
+            state,
+            scope,
+            mutable,
+            kind,
+            pattern: pattern.left,
+            initializer: pattern.right,
+            projection: [],
+            referenceOnly: true,
+            fallbackSources: [
+                ...(fallbackSources ?? []),
+                ...(initializer === null ? [] : [{ node: initializer, projection }]),
+            ],
+            ...(requiredSources === undefined ? {} : { requiredSources }),
         });
         return;
     }
@@ -468,7 +794,7 @@ const bindPattern = (input) => {
     }
     if (t.isObjectPattern(pattern))
         for (const property of pattern.properties) {
-            if (t.isRestElement(property))
+            if (t.isRestElement(property)) {
                 bindPattern({
                     ...input,
                     pattern: property.argument,
@@ -476,6 +802,16 @@ const bindPattern = (input) => {
                     mutable: true,
                     projection: [],
                 });
+                bindPattern({
+                    ...input,
+                    pattern: property.argument,
+                    projection: [...projection, null],
+                    referenceOnly: true,
+                    copyKind: "object-rest",
+                    copyProjectionOffset: projection.length,
+                    copyExcludedKeys: semanticObjectPatternKeys(pattern),
+                });
+            }
             else {
                 const name = semanticStaticPropertyKey(property.key, property.computed);
                 bindPattern({
@@ -487,12 +823,23 @@ const bindPattern = (input) => {
         }
     else if (t.isArrayPattern(pattern))
         pattern.elements.forEach((element, index) => {
-            if (element !== null)
+            if (element !== null) {
                 bindPattern({
                     ...input,
                     pattern: element,
                     projection: [...projection, index],
                 });
+                if (t.isRestElement(element))
+                    bindPattern({
+                        ...input,
+                        pattern: element.argument,
+                        projection: [...projection, null],
+                        referenceOnly: true,
+                        copyKind: "array-rest",
+                        copyProjectionOffset: projection.length,
+                        copyStartIndex: index,
+                    });
+            }
         });
 };
 const addBinding = (input) => {
@@ -513,14 +860,16 @@ const addBinding = (input) => {
         binding.directOrigins.push(directOrigin);
 };
 const createBinding = (scope, name, kind, mutable) => ({
-    bindingId: `${scope.scopeId}:binding:${encodeURIComponent(name)}`,
+    bindingId: semanticBindingId(scope.scopeId, name),
     scopeId: scope.scopeId,
     name,
     kind,
     mutable,
     mutatedPaths: [],
+    escapedPaths: [],
     definitions: [],
     initializers: [],
+    referenceInitializers: [],
     directOrigins: [],
 });
 const addAssignment = (identifier, initializer, scope, state) => {

package/dist/domain/javascript/javascriptSemanticCallResolution.js

@@ -1,6 +1,7 @@
 import * as t from "@babel/types";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { unwrapJavaScriptExpression } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 /** Resolve local callable candidates without following dynamic properties. */
@@ -11,6 +12,11 @@ export const resolveLocalCallables = (input) => resolveCallables(input.node, {
     bindingCache: input.bindingCache,
 });
 const resolveCallables = (node, context) => {
+    // `unwrapJavaScriptExpression` strips all transparent layers iteratively,
+    // so a single recursion step suffices (no per-layer stack growth).
+    const unwrapped = unwrapJavaScriptExpression(node).node;
+    if (unwrapped !== node)
+        return resolveCallables(unwrapped, context);
     const direct = semanticCallableIdForNode(node);
     if (direct !== null && context.callableById.has(direct))
         return {
@@ -20,10 +26,6 @@ const resolveCallables = (node, context) => {
         };
     if (t.isIdentifier(node))
         return resolveIdentifier(node, context);
-    if (t.isTSAsExpression(node) ||
-        t.isTSTypeAssertion(node) ||
-        t.isTSNonNullExpression(node))
-        return resolveCallables(node.expression, context);
     if (t.isConditionalExpression(node) || t.isLogicalExpression(node))
         return resolveAlternatives(t.isConditionalExpression(node) ? node.consequent : node.left, t.isConditionalExpression(node) ? node.alternate : node.right, context);
     return {
@@ -103,7 +105,7 @@ export const parameterBindings = (callable, index, state) => {
         .filter((binding) => binding.kind === "parameter" &&
         binding.definitions.some(({ kind, location }) => kind === "parameter" &&
             parameterAcceptsArgument(callable, location, index, state)))
-        .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
+        .sort((left, right) => compareUnicodeCodePoints(left.bindingId, right.bindingId));
 };
 const parameterAcceptsArgument = (callable, location, argumentIndex, state) => {
     const node = state.callableNodesById.get(callable.callableId);
@@ -122,4 +124,4 @@ const rangeContains = (outer, inner) => (outer.start.line < inner.start.line ||
     (outer.end.line > inner.end.line ||
         (outer.end.line === inner.end.line &&
             outer.end.column >= inner.end.column));
-const uniqueCallableIds = (values) => [...new Set(values)].sort(compareCodePoints);
+const uniqueCallableIds = (values) => [...new Set(values)].sort(compareUnicodeCodePoints);

package/dist/domain/javascript/javascriptSemanticCallableResults.js

@@ -0,0 +1,42 @@
+import * as t from "@babel/types";
+import { childNodes } from "./javascriptSemanticTraversal.js";
+/** Collect direct result syntax without executing or evaluating a callable. */
+export const semanticCallableResultExpressions = (callable) => {
+    if (t.isArrowFunctionExpression(callable) &&
+        !t.isBlockStatement(callable.body))
+        return [
+            {
+                node: callable.body,
+                site: callable.body,
+                kind: "return",
+                delegated: false,
+            },
+        ];
+    if (!t.isFunction(callable))
+        return [];
+    const output = [];
+    const pending = childNodes(callable.body).reverse();
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node === undefined || t.isFunction(node) || t.isClass(node))
+            continue;
+        if (t.isReturnStatement(node)) {
+            output.push({
+                node: node.argument ?? null,
+                site: node,
+                kind: "return",
+                delegated: false,
+            });
+        }
+        if (t.isYieldExpression(node))
+            output.push({
+                node: node.argument ?? null,
+                site: node,
+                kind: "yield",
+                delegated: node.delegate,
+            });
+        for (const child of childNodes(node).reverse())
+            pending.push(child);
+    }
+    return output;
+};