rea-agents 6.3.0 → 6.5.0

package/dist/domain/javascript/javascriptSemanticAnalysis.js

@@ -1,17 +1,25 @@
 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, semanticImportEqualsSpecifier, collectSemanticReferences, collectSemanticReferencesSteps, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
+import { semanticObjectPatternKeys, runtimeFunctionParameters, semanticStaticPropertyKey, semanticWriteTargets, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticBindingId, semanticScopeId, semanticStableInitializer, semanticVariableScope, } from "./javascriptSemanticState.js";
+import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
+import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
+import { semanticBundledRequireOrigin } from "./javascriptBundledRequireOrigin.js";
+import { collectSemanticMemberMutationsSteps } from "./javascriptSemanticMemberMutations.js";
+import { indexJavaScriptAmbientWritesSteps } from "./javascriptSemanticAmbientWrites.js";
+import { hasUncertainTypeOnlyModuleSideEffect } from "./javascriptModuleDeclaration.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
-import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
+import { collectJavaScriptDerivedSemanticsSteps } from "./javascriptSemanticDerivedAnalysis.js";
+import { evaluateSemanticProvenance } from "./javascriptSemanticValues.js";
+import { collectJavaScriptIdentityWritesSteps, 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";
+import { createSemanticModuleInterop } from "./javascriptModuleInterop.js";
+import { SemanticPropertyPathCoverage } from "./javascriptSemanticPropertyPaths.js";
 /** Recover lexical bindings, aliases, constants, and module links. */
 export const analyzeJavaScriptSemantics = (source) => {
     const file = parseJavaScriptSource(source);
@@ -22,23 +30,41 @@ 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);
 };
+/** Share the lexical index with bounded, demand-driven boundary analyses. */
+export function* indexJavaScriptBindingsSteps(program) {
+    const state = createState(program);
+    yield* collectDefinitionsSteps(program, state);
+    yield* indexJavaScriptAmbientWritesSteps(program, state);
+    return state;
+}
 /** Recover semantics from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptSemantics = (file) => {
-    const state = createState(file.program);
-    collectDefinitions(file.program, state);
-    collectSemanticMemberMutations(file.program, state);
-    traverseJavaScriptAst(file.program, {
+export const analyzeParsedJavaScriptSemantics = (file, staticImportResolutionMode = "import") => completeSemanticSteps(analyzeParsedJavaScriptSemanticsSteps(file, staticImportResolutionMode));
+/**
+ * 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, staticImportResolutionMode = "import") {
+    const state = createState(file.program, staticImportResolutionMode);
+    yield* collectDefinitionsSteps(file.program, state);
+    yield* indexJavaScriptAmbientWritesSteps(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);
-    const callables = collectSemanticReturns(file.program, state, parserPartial);
-    const moduleLinks = resolveSemanticModuleCallables(state, callables);
-    const derived = collectJavaScriptDerivedSemantics(file.program, state, callables, parserPartial);
+    yield;
+    const callables = collectSemanticReturns(state, parserPartial);
+    yield;
+    const moduleLinks = resolveSemanticModuleCallables(state, callables, bindings);
+    const derived = yield* collectJavaScriptDerivedSemanticsSteps(file.program, state, callables, parserPartial);
     return {
         schema: "JavaScriptSemanticIR",
         scopes: immutableSemanticScopes(state),
@@ -57,6 +83,11 @@ export const analyzeParsedJavaScriptSemantics = (file) => {
                     "The parser recovered from syntax errors; affected bindings are partial.",
                 ]
                 : []),
+            ...(hasUncertainTypeOnlyModuleSideEffect(file.program)
+                ? [
+                    "Compiler options are unavailable; inline type-only imports or re-exports may preserve a module side-effect dependency.",
+                ]
+                : []),
             "Values and aliases were recovered from inert syntax only; no JavaScript was executed.",
             "Return sites include only direct callable returns; nested callable returns remain separate.",
             "Local call, argument, return, and closure relations are static candidates and do not prove runtime invocation.",
@@ -64,23 +95,66 @@ 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 = semanticStableInitializer(binding, state);
+                client =
+                    initializer !== undefined &&
+                        initializer.projection.length === 0 &&
+                        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.
+ * `window.open` from XHR and global storage `.open` calls, and configuration
+ * `.get` reads from HTTP client 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, {
+    const extensionStateReads = [];
+    yield* traverseJavaScriptAstSteps(file.program, {
         enter: (node) => {
             if ((!t.isCallExpression(node) && !t.isOptionalCallExpression(node)) ||
                 (!t.isMemberExpression(node.callee) &&
-                    !t.isOptionalMemberExpression(node.callee)) ||
-                semanticStaticPropertyKey(node.callee.property, node.callee.computed) !== "open" ||
-                !t.isIdentifier(node.callee.object))
+                    !t.isOptionalMemberExpression(node.callee)))
+                return;
+            const method = semanticStaticPropertyKey(node.callee.property, node.callee.computed);
+            if (method === "get") {
+                if (isConfigurationReceiver(state, node.callee.object))
+                    facts.set(node.start ?? -1, "configuration");
+                else if (isExtensionStateMember(node.callee.object))
+                    extensionStateReads.push(node.start ?? -1);
+                return;
+            }
+            if (method !== "open" || !t.isIdentifier(node.callee.object))
                 return;
             const receiver = node.callee.object.name;
             const binding = resolveSemanticBindingState(state, node, receiver);
@@ -132,7 +206,84 @@ export const classifyParsedJavaScriptOpenReceivers = (file) => {
                 facts.set(node.start ?? -1, aliasFact);
         },
     });
+    if (extensionStateReads.length > 0 && importsVsCodeModule(state))
+        for (const start of extensionStateReads)
+            facts.set(start, "extension-state");
     return facts;
+}
+/** VS Code passes extension state through ExtensionContext, not an import. */
+const isExtensionStateMember = (receiver) => (t.isMemberExpression(receiver) || t.isOptionalMemberExpression(receiver)) &&
+    (() => {
+        const key = semanticStaticPropertyKey(receiver.property, receiver.computed);
+        return key === "globalState" || key === "workspaceState";
+    })();
+/** Require module evidence before treating a familiar member as VS Code state. */
+const importsVsCodeModule = (state) => [...state.bindingsById.values()].some((binding) => binding.directOrigins.some(({ specifier }) => specifier === "vscode") ||
+    semanticRequireOrigin(semanticStableInitializer(binding, state)?.node, state)?.origin.specifier === "vscode");
+/**
+ * Whether a call spells VS Code's `workspace.getConfiguration(section)`, whose
+ * result `.get` reads setting keys rather than request paths. The `workspace`
+ * member is required: a bare or differently scoped `getConfiguration` may be
+ * an application's own HTTP client factory. Minifiers keep property names, so
+ * bundled `x.workspace.getConfiguration` still matches.
+ */
+const isConfigurationAccessorCall = (state, node) => {
+    if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+        return false;
+    const callee = node.callee;
+    if ((!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) ||
+        semanticStaticPropertyKey(callee.property, callee.computed) !==
+            "getConfiguration")
+        return false;
+    const host = callee.object;
+    const matchesSpelling = t.isIdentifier(host)
+        ? host.name === "workspace"
+        : (t.isMemberExpression(host) || t.isOptionalMemberExpression(host)) &&
+            semanticStaticPropertyKey(host.property, host.computed) === "workspace";
+    if (!matchesSpelling)
+        return false;
+    const root = t.isIdentifier(host)
+        ? host
+        : t.isMemberExpression(host) || t.isOptionalMemberExpression(host)
+            ? host.object
+            : undefined;
+    if (!t.isIdentifier(root))
+        return false;
+    const binding = resolveSemanticBindingState(state, root, root.name);
+    if (binding === undefined)
+        return !semanticResolutionBlocked(state, root, root.name);
+    const initializer = semanticStableInitializer(binding, state);
+    const origins = [
+        ...binding.directOrigins,
+        ...(initializer === undefined
+            ? []
+            : [semanticRequireOrigin(initializer.node, state)?.origin]),
+    ];
+    return origins.some((origin) => origin?.specifier === "vscode" &&
+        (t.isIdentifier(host)
+            ? origin.importedPath.at(-1) === "workspace" ||
+                initializer?.projection.at(-1) === "workspace"
+            : origin.importedPath.length === 0 ||
+                (origin.importedPath.length === 1 &&
+                    (origin.importedPath[0] === "*" ||
+                        origin.importedPath[0] === "default"))));
+};
+/**
+ * Whether a `.get` receiver is a configuration accessor result, either inline
+ * or through a binding whose only visible write is one unconditional
+ * initializer. Minifiers emit `let` for such bindings, so declaration kind
+ * alone does not decide.
+ */
+const isConfigurationReceiver = (state, receiver) => {
+    if (isConfigurationAccessorCall(state, receiver))
+        return true;
+    if (!t.isIdentifier(receiver))
+        return false;
+    const binding = resolveSemanticBindingState(state, receiver, receiver.name);
+    const initializer = semanticStableInitializer(binding, state);
+    return (initializer !== undefined &&
+        initializer.projection.length === 0 &&
+        isConfigurationAccessorCall(state, initializer.node));
 };
 const openGlobalFact = (name) => {
     if (name === "window" ||
@@ -156,7 +307,127 @@ const resolveGlobalAliasFact = (state, node, name) => {
         return undefined;
     return openGlobalFact(name);
 };
-const createState = (program) => {
+/**
+ * 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 state = createState(file.program);
+    yield* collectDefinitionsSteps(file.program, state);
+    return (yield* indexJavaScriptElectronIdentitySteps(file.program, state))
+        .bindings;
+}
+export function* indexJavaScriptElectronIdentitySteps(program, state) {
+    const facts = new Map();
+    const interop = createSemanticModuleInterop(state);
+    const writes = new SemanticPropertyPathCoverage();
+    let collectedWrites = false;
+    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, interop);
+                exportsByBinding.set(binding.bindingId, exported);
+            }
+            return collectedWrites && interop.invalidated(binding)
+                ? undefined
+                : (exported ?? undefined);
+        }
+        const wrapped = interop.callOrigin(root);
+        const origin = wrapped === undefined
+            ? electronRequireOrigin(root, state)?.origin
+            : collectedWrites && interop.invalidatedCall(root)
+                ? undefined
+                : wrapped.origin;
+        return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)
+            ? electronExportPath(origin.importedPath)
+            : undefined;
+    };
+    yield* collectJavaScriptIdentityWritesSteps(program, (node, kind) => {
+        if (kind === "opaque-call")
+            return [interop.opaqueMutationPath(node)];
+        const { root, members } = electronMemberPath(node);
+        const exported = kind === "binding" ? undefined : rootExport(root);
+        const path = exported === undefined
+            ? (interop.intrinsicPath(root) ??
+                (kind === "member"
+                    ? interop.boundIntrinsic(root)?.path
+                    : undefined))
+            : ["electron", ...exported];
+        return path === undefined ? [] : [[...path, ...members]];
+    }, interop.intrinsicInvocation, interop.staticString, interop.isFreshObject, (node, path) => {
+        if (path[0] === "electron")
+            writes.retain(path);
+        else
+            interop.retainWrite(node, path);
+    });
+    collectedWrites = true;
+    const intactExport = (path) => ELECTRON_MODULE.test(path[0] ?? "") &&
+        !writes.covers(["electron", ...path.slice(1)]);
+    yield* traverseJavaScriptAstSteps(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 &&
+                intactExport(["electron", ...exported, ...members]))
+                facts.set(root.start ?? -1, exported);
+        },
+    });
+    return { bindings: facts, intactExport, exportPath: rootExport };
+}
+// Read import and require origins directly; general value evaluation is
+// unnecessary here and costly across large vendor bundles.
+const electronExport = (binding, state, interop) => {
+    const reassigned = binding.definitions.some(({ kind }) => kind === "assignment");
+    const converted = interop.origin(binding);
+    if (reassigned && converted === undefined)
+        return null;
+    const directOrigin = converted?.origin ?? bindingOrigin(binding, state);
+    const initializer = semanticStableInitializer(binding, state);
+    if (directOrigin === undefined && initializer === undefined)
+        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 electronRequireOrigin = (node, state) => semanticRequireOrigin(node, state) ??
+    semanticBundledRequireOrigin(node, state);
+const bindingOrigin = (binding, state) => {
+    if (binding.directOrigins.length > 0)
+        return binding.directOrigins.length === 1
+            ? binding.directOrigins[0]
+            : undefined;
+    const initializer = semanticStableInitializer(binding, state);
+    if (initializer === undefined)
+        return undefined;
+    const origin = electronRequireOrigin(initializer.node, state)?.origin;
+    const projection = initializer.projection;
+    return origin === undefined ||
+        !projection.every((key) => typeof key === "string")
+        ? undefined
+        : { ...origin, importedPath: [...origin.importedPath, ...projection] };
+};
+const createState = (program, staticImportResolutionMode = "import") => {
     const root = {
         scopeId: semanticScopeId("program", program),
         parentScopeId: null,
@@ -166,6 +437,8 @@ const createState = (program) => {
         bindings: new Map(),
     };
     return {
+        program,
+        staticImportResolutionMode,
         parentsByNode: new WeakMap(),
         scopes: [root],
         scopesById: new Map([[root.scopeId, root]]),
@@ -174,19 +447,27 @@ const createState = (program) => {
         callables: [],
         callableNodesById: new Map(),
         moduleLinks: [],
+        linkedRequireCalls: new WeakSet(),
         moduleLinkBindings: new WeakMap(),
-        conditionalInitializers: new WeakSet(),
+        defaultExportExpressions: new WeakMap(),
+        conditionallySkippedExpressions: new WeakSet(),
+        requiredModuleEffects: new Map(),
+        ambientBindingWrites: new Map(),
+        ambientWrites: new SemanticPropertyPathCoverage(),
+        ambientWriteEffects: [],
     };
 };
-const collectDefinitions = (program, state) => {
+function* collectDefinitionsSteps(program, state) {
     const stack = [
         currentSemanticScope(state.scopes),
     ];
     const openedScopes = new WeakMap();
     const assignments = [];
     const functionBodies = [];
-    traverseJavaScriptAst(program, {
+    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)) &&
@@ -228,11 +509,14 @@ const collectDefinitions = (program, state) => {
                     functionBodies.push({
                         body: node,
                         scope: nested,
-                        parameters: parent.params,
+                        parameters: runtimeFunctionParameters(parent),
                     });
             }
             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,
@@ -245,13 +529,19 @@ const collectDefinitions = (program, state) => {
                 node.init != null &&
                 parent !== null &&
                 t.isVariableDeclaration(parent, { kind: "var" }) &&
-                hasConditionalInitializer(readAncestors()))
-                state.conditionalInitializers.add(node.init);
+                writeMayBeSkipped(node, readAncestors()))
+                state.conditionallySkippedExpressions.add(node.init);
             if (t.isAssignmentExpression(node) ||
                 t.isUpdateExpression(node) ||
                 t.isForOfStatement(node) ||
                 t.isForInStatement(node))
-                assignments.push({ node, scope });
+                assignments.push({
+                    node,
+                    scope,
+                    conditionallySkipped: t.isForOfStatement(node) ||
+                        t.isForInStatement(node) ||
+                        writeMayBeSkipped(node, readAncestors()),
+                });
         },
         exit: (node) => {
             for (let count = openedScopes.get(node) ?? 0; count > 0; count--)
@@ -260,13 +550,20 @@ const collectDefinitions = (program, state) => {
     });
     // All declarations must exist before resolving writes, including hoisted
     // functions and local declarations that shadow an outer binding.
-    for (const { node, scope } of assignments)
-        bindAssignment(node, scope, state);
-    for (const { body, scope, parameters } of functionBodies)
+    for (const [index, { node, scope, conditionallySkipped },] of assignments.entries()) {
+        if (index % 64 === 0)
+            yield;
+        bindAssignment(node, scope, state, conditionallySkipped);
+    }
+    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 });
-};
+            for (const identifier of semanticWriteTargets(t.isTSParameterProperty(parameter) ? parameter.parameter : parameter))
+                if (t.isIdentifier(identifier))
+                    copyParameterToBody({ identifier, body, scope, state });
+    }
+}
 const copyParameterToBody = (input) => {
     const { identifier, body, scope, state } = input;
     const binding = scope.bindings.get(identifier.name);
@@ -294,21 +591,74 @@ const copyParameterToBody = (input) => {
             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.
+const writeMayBeSkipped = (node, ancestors) => {
+    let child = node;
     for (let index = ancestors.length - 1; index >= 0; index -= 1) {
-        const node = ancestors[index];
-        if (t.isFunction(node) || t.isProgram(node) || t.isStaticBlock(node))
+        const parent = ancestors[index];
+        if (parent === undefined ||
+            t.isFunction(parent) ||
+            t.isProgram(parent) ||
+            t.isStaticBlock(parent))
             return false;
-        if (t.isIfStatement(node) ||
-            t.isLoop(node) ||
-            t.isSwitchCase(node) ||
-            t.isTryStatement(node))
+        if (isSkippedBranch(parent, child))
             return true;
+        child = parent;
     }
     return false;
 };
+const isSkippedBranch = (parent, child) => {
+    if (t.isIfStatement(parent))
+        return child === parent.consequent || child === parent.alternate;
+    if (t.isSwitchCase(parent))
+        return true;
+    if (t.isTryStatement(parent))
+        return child === parent.block || child === parent.handler;
+    if (t.isForStatement(parent))
+        return child === parent.body || child === parent.update;
+    if (t.isWhileStatement(parent))
+        return child === parent.body;
+    if (t.isDoWhileStatement(parent))
+        return false;
+    if (t.isForInStatement(parent) || t.isForOfStatement(parent))
+        return child === parent.left || child === parent.body;
+    if (t.isLogicalExpression(parent))
+        return child === parent.right;
+    if (t.isConditionalExpression(parent))
+        return child === parent.consequent || child === parent.alternate;
+    if (t.isOptionalCallExpression(parent) || t.isCallExpression(parent))
+        return (parent.arguments.includes(child) &&
+            optionalCallArgumentsMayBeSkipped(parent));
+    if (t.isOptionalMemberExpression(parent))
+        return parent.optional && parent.computed && child === parent.property;
+    return false;
+};
+const optionalCallArgumentsMayBeSkipped = (call) => {
+    if (t.isOptionalCallExpression(call) && call.optional)
+        return true;
+    let callee = call.callee;
+    while (true) {
+        // Parentheses terminate optional-chain short-circuiting. In particular,
+        // `(foo?.bar)(arg)` evaluates arg before attempting the call.
+        if (callee.extra?.parenthesized === true)
+            return false;
+        if (t.isOptionalMemberExpression(callee)) {
+            if (callee.optional)
+                return true;
+            callee = callee.object;
+        }
+        else if (t.isMemberExpression(callee))
+            callee = callee.object;
+        else if (t.isOptionalCallExpression(callee)) {
+            if (callee.optional)
+                return true;
+            callee = callee.callee;
+        }
+        else if (t.isCallExpression(callee))
+            callee = callee.callee;
+        else
+            return false;
+    }
+};
 const bindOuterDeclaration = (node, scope, state) => {
     if (t.isFunctionDeclaration(node) && t.isIdentifier(node.id))
         addBinding({
@@ -334,6 +684,8 @@ const bindOuterDeclaration = (node, scope, state) => {
 const bindInnerDeclaration = (node, parent, scope, state) => {
     if (t.isImportDeclaration(node))
         bindImports(node, scope, state);
+    else if (t.isTSImportEqualsDeclaration(node))
+        bindImportEquals(node, scope, state);
     else if (t.isVariableDeclarator(node))
         bindPattern({
             pattern: node.id,
@@ -343,6 +695,9 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
             mutable: parent !== null && t.isVariableDeclaration(parent)
                 ? parent.kind !== "const"
                 : true,
+            ...(parent !== null && t.isVariableDeclaration(parent)
+                ? { declarationKind: parent.kind }
+                : {}),
         });
     else if (t.isClassExpression(node) && t.isIdentifier(node.id))
         addBinding({
@@ -366,51 +721,65 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
             kind: "catch",
         });
 };
-const bindAssignment = (node, scope, state) => {
+const bindImportEquals = (node, scope, state) => {
+    const specifier = semanticImportEqualsSpecifier(node);
+    if (specifier === null)
+        return;
+    addBinding({
+        state,
+        scope,
+        name: node.id.name,
+        kind: "import",
+        mutable: false,
+        definitionNode: node.id,
+        initializer: null,
+        directOrigin: { specifier, importedPath: [], resolutionMode: "require" },
+    });
+};
+// A parameter or catch binding starts with a caller-supplied value that a
+// conditional logical assignment can retain, so its RHS is not exact.
+const hasIncomingValue = (identifier, scope, state) => {
+    const kind = resolveSemanticBindingFromScope(scope, identifier.name, state)?.kind;
+    return kind === "parameter" || kind === "catch";
+};
+const bindAssignment = (node, scope, state, conditionallySkipped) => {
     if (t.isAssignmentExpression(node)) {
-        if (t.isIdentifier(node.left))
-            addAssignment(node.left, node.operator === "=" ||
-                node.operator === "||=" ||
-                node.operator === "??="
+        const left = unwrapJavaScriptExpression(node.left).node;
+        if (t.isIdentifier(left))
+            addAssignment(left, node.operator === "=" ||
+                ((node.operator === "||=" || node.operator === "??=") &&
+                    !hasIncomingValue(left, scope, state))
                 ? node.right
-                : node, scope, state);
+                : node, scope, state, conditionallySkipped);
         else
-            for (const identifier of assignedPatternIdentifiers(node.left))
-                addAssignment(identifier, node, scope, state);
+            for (const identifier of semanticWriteTargets(node.left))
+                if (t.isIdentifier(identifier))
+                    addAssignment(identifier, node, scope, state, conditionallySkipped);
+    }
+    else if (t.isUpdateExpression(node)) {
+        const argument = unwrapJavaScriptExpression(node.argument).node;
+        if (t.isIdentifier(argument))
+            addAssignment(argument, node, scope, state, conditionallySkipped);
     }
-    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 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);
-};
-const assignedPatternIdentifiers = (pattern) => {
-    const identifiers = [];
-    const pending = [pattern];
-    while (pending.length > 0) {
-        const node = pending.pop();
-        if (node === undefined)
-            continue;
-        if (t.isIdentifier(node))
-            identifiers.push(node);
-        else if (t.isRestElement(node))
-            pending.push(node.argument);
-        else if (t.isAssignmentPattern(node))
-            pending.push(node.left);
-        else if (t.isArrayPattern(node)) {
-            for (const element of node.elements)
-                if (element !== null)
-                    pending.push(element);
-        }
-        else if (t.isObjectPattern(node)) {
-            for (const property of node.properties)
-                pending.push(t.isRestElement(property) ? property.argument : property.value);
+            : [node.left]) {
+            for (const identifier of semanticWriteTargets(pattern))
+                if (t.isIdentifier(identifier))
+                    addAssignment(identifier, node, scope, state, conditionallySkipped);
+            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,
+                });
         }
-    }
-    return identifiers;
 };
 const nestedScope = (node, parent, parentScope, state) => {
     const switchOwner = t.isSwitchCase(node) && parent !== null && t.isSwitchStatement(parent)
@@ -496,7 +865,7 @@ const scopeKind = (node, parent) => {
     return undefined;
 };
 const functionParametersHaveExpressions = (node) => {
-    const pending = [...node.params];
+    const pending = [...runtimeFunctionParameters(node)];
     while (pending.length > 0) {
         const parameter = pending.pop();
         if (t.isAssignmentPattern(parameter))
@@ -530,7 +899,7 @@ const bindImports = (node, scope, state) => {
             ? ["default"]
             : t.isImportNamespaceSpecifier(specifier)
                 ? []
-                : [propertyName(specifier.imported) || "[dynamic]"];
+                : [semanticStaticPropertyKey(specifier.imported, false) ?? "[dynamic]"];
         addBinding({
             state,
             scope,
@@ -540,11 +909,16 @@ const bindImports = (node, scope, state) => {
             definitionNode: specifier.local,
             initializer: null,
             directOrigin: { specifier: node.source.value, importedPath },
+            runtimeImport: node.importKind !== "type" &&
+                node.importKind !== "typeof" &&
+                (!t.isImportSpecifier(specifier) ||
+                    (specifier.importKind !== "type" &&
+                        specifier.importKind !== "typeof")),
         });
     }
 };
 const bindFunctionLocals = (node, scope, state) => {
-    for (const parameter of node.params)
+    for (const parameter of runtimeFunctionParameters(node))
         bindPattern({
             pattern: t.isTSParameterProperty(parameter)
                 ? parameter.parameter
@@ -557,14 +931,14 @@ const bindFunctionLocals = (node, scope, state) => {
         });
 };
 const bindPattern = (input) => {
-    const { pattern, initializer, scope, state, mutable, kind = "variable", projection = [], referenceOnly = false, copyKind, copyProjectionOffset, copyExcludedKeys, copyStartIndex, fallbackSources, requiredSources, } = input;
+    const { pattern, initializer, scope, state, mutable, declarationKind, 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 = scope.bindings.get(pattern.name);
+            const binding = resolveSemanticBindingFromScope(scope, pattern.name, state);
             if (binding !== undefined && initializer !== null)
                 binding.referenceInitializers.push({
                     node: initializer,
@@ -586,6 +960,7 @@ const bindPattern = (input) => {
             name: pattern.name,
             kind,
             mutable,
+            ...(declarationKind === undefined ? {} : { declarationKind }),
             definitionNode: pattern,
             initializer,
             projection,
@@ -647,12 +1022,7 @@ const bindPattern = (input) => {
                     referenceOnly: true,
                     copyKind: "object-rest",
                     copyProjectionOffset: projection.length,
-                    copyExcludedKeys: pattern.properties.flatMap((property) => {
-                        if (t.isRestElement(property))
-                            return [];
-                        const key = semanticStaticPropertyKey(property.key, property.computed);
-                        return key === null ? [] : [key];
-                    }),
+                    copyExcludedKeys: semanticObjectPatternKeys(pattern),
                 });
             }
             else {
@@ -686,7 +1056,7 @@ const bindPattern = (input) => {
         });
 };
 const addBinding = (input) => {
-    const { state, scope, name, kind, mutable, definitionNode, initializer, directOrigin, projection = [], } = input;
+    const { state, scope, name, kind, mutable, declarationKind, definitionNode, initializer, directOrigin, runtimeImport, projection = [], } = input;
     let binding = scope.bindings.get(name);
     if (binding === undefined) {
         if (!scope.bindingsComplete)
@@ -696,30 +1066,49 @@ const addBinding = (input) => {
         state.bindingsById.set(binding.bindingId, binding);
     }
     binding.mutable ||= mutable;
+    if (declarationKind !== undefined)
+        binding.declarationKinds.add(declarationKind);
     binding.definitions.push({ kind, location: range(definitionNode) });
     if (initializer !== null)
         binding.initializers.push({ node: initializer, projection });
     if (directOrigin !== undefined)
-        binding.directOrigins.push(directOrigin);
+        binding.directOrigins.push(directOrigin.resolutionMode === undefined &&
+            state.staticImportResolutionMode !== "import"
+            ? {
+                ...directOrigin,
+                resolutionMode: state.staticImportResolutionMode,
+            }
+            : directOrigin);
+    binding.runtimeImport ||= runtimeImport === true;
 };
 const createBinding = (scope, name, kind, mutable) => ({
-    bindingId: `${scope.scopeId}:binding:${encodeURIComponent(name)}`,
+    bindingId: semanticBindingId(scope.scopeId, name),
     scopeId: scope.scopeId,
     name,
     kind,
     mutable,
-    mutatedPaths: [],
+    declarationKinds: new Set(),
+    memberWrites: [],
     escapedPaths: [],
     definitions: [],
     initializers: [],
     referenceInitializers: [],
     directOrigins: [],
+    runtimeImport: false,
 });
-const addAssignment = (identifier, initializer, scope, state) => {
+const addAssignment = (identifier, initializer, scope, state, conditionallySkipped) => {
     const binding = resolveSemanticBindingFromScope(scope, identifier.name, state);
-    if (binding === undefined)
+    if (binding === undefined) {
+        // Unbound identifiers can denote host wrapper bindings (such as require),
+        // which are separate from properties written through the global object.
+        const writes = state.ambientBindingWrites.get(identifier.name) ?? [];
+        writes.push(identifier);
+        state.ambientBindingWrites.set(identifier.name, writes);
         return;
+    }
     binding.mutable = true;
     binding.definitions.push({ kind: "assignment", location: range(identifier) });
     binding.initializers.push({ node: initializer, projection: [] });
+    if (conditionallySkipped)
+        state.conditionallySkippedExpressions.add(initializer);
 };