rea-agents 6.4.0 → 6.5.0

package/dist/domain/javascript/javascriptSemanticDataEffectHelpers.js

@@ -1,9 +1,15 @@
 import * as t from "@babel/types";
+import { BUILTIN_RESOURCE_METHODS } from "./javascriptBuiltinResourceMethods.js";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
+import { semanticRequireOrigin, semanticRequireExportsIdentity, semanticGlobalProcessOrigin, semanticMutableBuiltinOrigin, } from "./javascriptSemanticRequireOrigin.js";
+import { evaluateSemanticProvenance, evaluateSemanticProvenanceAtRead, } from "./javascriptSemanticValues.js";
+import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
-import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { semanticTopLevelEffectFollowsCapture } from "./javascriptSemanticMutationInitializers.js";
+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 /** Resolve bindings written by the nearest variable or assignment owner. */
 export const assignedSemanticResultBindings = (node, ancestors, state) => {
     for (let index = ancestors.length - 1; index >= 0; index -= 1) {
@@ -89,40 +95,439 @@ export const semanticProjectedBindingFacts = (bindings) => bindings.map(({ ident
 export const scalarAssignedResultBinding = (bindings) => bindings.length === 1 && bindings[0]?.projectionPath.length === 0
     ? (bindings[0]?.bindingId ?? null)
     : null;
-/** Resolve a direct or namespace-imported built-in method. */
+/** Resolve built-in methods from the shared, unambiguous binding provenance. */
 export const builtinDataEffectMethod = (callee, state, specifiers) => {
+    const expression = unwrapJavaScriptExpression(callee).node;
+    if (expression !== callee)
+        return builtinDataEffectMethod(expression, state, specifiers);
+    if (t.isSequenceExpression(expression)) {
+        const final = expression.expressions.at(-1);
+        return final === undefined
+            ? null
+            : builtinDataEffectMethod(final, state, specifiers);
+    }
+    const required = semanticRequireOrigin(callee, state);
+    if (required !== undefined) {
+        const origin = builtinNamespaceOrigin(required.origin);
+        return origin.importedPath.length === 1 &&
+            specifiers.some((specifier) => specifier.replace(/^node:/u, "") === origin.specifier) &&
+            !requiredModuleChanged(required.origin.specifier, required.origin.importedPath, callee, state, true)
+            ? (origin.importedPath[0] ?? null)
+            : null;
+    }
     if (t.isIdentifier(callee)) {
         const binding = resolveSemanticBindingState(state, callee, callee.name);
-        return moduleMethod(binding, specifiers);
+        const path = builtinBindingPath(binding, state, specifiers, callee, [], true);
+        return path?.length === 1 ? (path[0] ?? null) : null;
     }
     if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee))
         return null;
-    if (!t.isIdentifier(callee.object))
-        return null;
+    if (!t.isIdentifier(callee.object)) {
+        const method = semanticStaticPropertyKey(callee.property, callee.computed);
+        const receiver = semanticBoundMemberPath(callee.object, state);
+        if (method !== null && receiver !== undefined) {
+            const provenance = evaluateSemanticProvenance(receiver.binding, state);
+            if (provenance.status === "module") {
+                const origin = builtinNamespaceOrigin({
+                    ...provenance.origins[0],
+                    importedPath: [
+                        ...provenance.origins[0].importedPath,
+                        ...receiver.path,
+                    ],
+                });
+                if (specifiers.some((specifier) => specifier.replace(/^node:/u, "") === origin.specifier))
+                    return builtinBindingPath(receiver.binding, state, specifiers, callee, [...receiver.path, method], true)?.length === 0
+                        ? method
+                        : null;
+            }
+        }
+        const source = semanticExpressionModuleOrigin(callee.object, state);
+        if (method === null || source === undefined)
+            return null;
+        const origin = builtinNamespaceOrigin(source);
+        return origin.importedPath.length === 0 &&
+            specifiers.some((specifier) => specifier.replace(/^node:/u, "") === origin.specifier) &&
+            !requiredModuleChanged(origin.specifier, [...origin.importedPath, method], callee, state, true, callee.object)
+            ? method
+            : null;
+    }
     const binding = resolveSemanticBindingState(state, callee.object, callee.object.name);
-    const namespace = binding?.directOrigins.some(({ specifier, importedPath }) => specifiers.includes(specifier) &&
-        semanticBuiltinNamespacePath(importedPath));
-    return namespace
-        ? semanticStaticPropertyName(callee.property, callee.computed)
+    const method = semanticStaticPropertyKey(callee.property, callee.computed);
+    if (method === null)
+        return null;
+    const resolvedPath = builtinBindingPath(binding, state, specifiers, callee, [method], true);
+    if (resolvedPath?.length === 0)
+        return method;
+    const initializer = binding?.initializers[0];
+    if (initializer === undefined ||
+        binding?.initializers.length !== 1 ||
+        (!t.isMemberExpression(initializer.node) &&
+            !t.isOptionalMemberExpression(initializer.node))) {
+        return null;
+    }
+    const provenance = evaluateSemanticProvenance(binding, state);
+    if (provenance.status !== "module")
+        return null;
+    const origin = builtinNamespaceOrigin(provenance.origins[0]);
+    const selected = [...origin.importedPath, method];
+    return specifiers.some((specifier) => specifier.replace(/^node:/u, "") === origin.specifier) &&
+        builtinBindingPath(binding, state, specifiers, initializer.node, [method], true)?.length === 0 &&
+        !requiredModuleChanged(provenance.origins[0].specifier, selected, callee, state, true, initializer.node)
+        ? method
         : null;
 };
-const moduleMethod = (binding, specifiers) => {
-    for (const { specifier, importedPath } of binding?.directOrigins ?? []) {
-        if (!specifiers.includes(specifier))
-            continue;
-        return importedPath.at(-1) ?? null;
+const semanticBoundMemberPath = (node, state) => {
+    const path = [];
+    let current = unwrapJavaScriptExpression(node).node;
+    while (t.isMemberExpression(current) ||
+        t.isOptionalMemberExpression(current)) {
+        const key = semanticStaticPropertyKey(current.property, current.computed);
+        if (key === null || !t.isNode(current.object))
+            return undefined;
+        path.unshift(key);
+        current = unwrapJavaScriptExpression(current.object).node;
     }
-    return null;
+    if (!t.isIdentifier(current))
+        return undefined;
+    const binding = resolveSemanticBindingState(state, current, current.name);
+    return binding === undefined ? undefined : { binding, path };
+};
+const builtinBindingPath = (binding, state, specifiers, capture, selectedPath = [], callableValue = false, visited = new Set(), memo = new Map(), provenanceCapture, savedObjectCapture) => {
+    if (binding === undefined)
+        return null;
+    const key = JSON.stringify([
+        binding.bindingId,
+        selectedPath,
+        callableValue,
+        provenanceCapture?.start,
+        provenanceCapture?.end,
+        savedObjectCapture?.start,
+        savedObjectCapture?.end,
+    ]);
+    let captured = memo.get(capture);
+    if (captured?.has(key))
+        return captured.get(key) ?? null;
+    if (visited.has(binding.bindingId))
+        return null;
+    if (captured === undefined) {
+        captured = new Map();
+        memo.set(capture, captured);
+    }
+    const result = computeBuiltinBindingPath(binding, state, specifiers, capture, selectedPath, callableValue, visited, memo, provenanceCapture, savedObjectCapture);
+    captured.set(key, result);
+    return result;
+};
+const computeBuiltinBindingPath = (binding, state, specifiers, capture, selectedPath = [], callableValue = false, visited, memo, provenanceCapture, savedObjectCapture) => {
+    if (binding === undefined || visited.has(binding.bindingId))
+        return null;
+    // Provenance identifies the module, independently of whether a selected slot
+    // still refers to its original built-in after member mutation or escape.
+    if (binding.memberWrites.some(({ path, node }) => affectsBuiltinPath(path, selectedPath) &&
+        !(semanticTopLevelEffectFollowsCapture(path.length === 0 && provenanceCapture !== undefined
+            ? provenanceCapture
+            : capture, node, state.parentsByNode) ||
+            (savedObjectCapture !== undefined &&
+                path.length < selectedPath.length &&
+                semanticTopLevelEffectFollowsCapture(savedObjectCapture, node, state.parentsByNode)))) ||
+        builtinEscapes(binding, state).some(({ path, node }) => affectsBuiltinPath(path, selectedPath) &&
+            // A function-value escape cannot replace its native [[Call]]. An
+            // escaped containing object can still replace the selected method.
+            (!callableValue || path.length < selectedPath.length) &&
+            !semanticTopLevelEffectFollowsCapture(capture, node, state.parentsByNode)))
+        return null;
+    const provenance = provenanceCapture === undefined
+        ? evaluateSemanticProvenance(binding, state)
+        : evaluateSemanticProvenanceAtRead(binding, provenanceCapture, state);
+    if (provenance.status !== "module")
+        return null;
+    const { importedPath } = provenance.origins[0];
+    const namespace = builtinNamespaceOrigin(provenance.origins[0]);
+    if (!specifiers.some((item) => {
+        const name = item.replace(/^node:/u, "");
+        return (name === namespace.specifier ||
+            (namespace.specifier === "fs" &&
+                selectedPath[0] === "promises" &&
+                name === "fs/promises"));
+    }))
+        return null;
+    let resolvedPath = importedPath;
+    for (const origin of binding.directOrigins) {
+        const shared = semanticMutableBuiltinOrigin(origin, selectedPath);
+        if (shared !== undefined &&
+            requiredModuleChanged(shared.specifier, shared.path, capture, state, callableValue))
+            return null;
+    }
+    const ancestors = new Set([...visited, binding.bindingId]);
+    for (const initializer of binding.initializers) {
+        const pending = [
+            {
+                node: initializer.node,
+                path: [...initializer.projection.map(String), ...selectedPath],
+                savedObjectCapture: selectedPath.length > 0 &&
+                    (t.isMemberExpression(initializer.node) ||
+                        t.isOptionalMemberExpression(initializer.node))
+                    ? initializer.node
+                    : savedObjectCapture,
+                capture: callableValue &&
+                    selectedPath.length === 0 &&
+                    initializer.projection.length > 0
+                    ? initializer.node
+                    : capture,
+            },
+        ];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            const node = unwrapJavaScriptExpression(current.node).node;
+            if (t.isIdentifier(node)) {
+                const source = resolveSemanticBindingState(state, node, node.name);
+                const sourcePath = builtinBindingPath(source, state, specifiers, current.capture, current.path, callableValue, ancestors, memo, node, current.savedObjectCapture);
+                if (sourcePath === null)
+                    return null;
+                // Normalize ESM default namespaces at their owner before projecting an alias.
+                resolvedPath = [...sourcePath, ...current.path].slice(0, sourcePath.length + current.path.length - selectedPath.length);
+            }
+            else if (t.isMemberExpression(node) ||
+                t.isOptionalMemberExpression(node)) {
+                const key = semanticStaticPropertyKey(node.property, node.computed);
+                if (key === null)
+                    return null;
+                pending.push({
+                    node: node.object,
+                    path: [key, ...current.path],
+                    savedObjectCapture: current.savedObjectCapture,
+                    // Freeze a selected function, not later member reads through a saved object.
+                    capture: callableValue && selectedPath.length === 0 ? node : current.capture,
+                });
+            }
+            else if (t.isSequenceExpression(node)) {
+                const final = node.expressions.at(-1);
+                if (final === undefined)
+                    return null;
+                pending.push({ ...current, node: final });
+            }
+            else if (t.isAssignmentExpression(node) && node.operator === "=") {
+                pending.push({ ...current, node: node.right });
+            }
+            else if (t.isConditionalExpression(node)) {
+                pending.push({ ...current, node: node.consequent }, { ...current, node: node.alternate });
+            }
+            else if (t.isLogicalExpression(node)) {
+                pending.push({ ...current, node: node.left }, { ...current, node: node.right });
+            }
+            else {
+                const required = semanticRequireOrigin(node, state);
+                if (required !== undefined &&
+                    requiredModuleChanged(required.origin.specifier, [...required.origin.importedPath, ...current.path], current.capture, state, callableValue, current.savedObjectCapture))
+                    return null;
+            }
+        }
+    }
+    // Only a direct ESM default import denotes the built-in namespace;
+    // require("node:fs").default is a literal property, not interop syntax.
+    return binding.directOrigins.length > 0 &&
+        semanticBuiltinNamespacePath(importedPath)
+        ? []
+        : builtinNamespaceOrigin({
+            ...provenance.origins[0],
+            importedPath: resolvedPath,
+        }).importedPath;
+};
+/** Interpret known Node namespace aliases without changing source provenance. */
+const builtinNamespaceOrigin = (origin) => {
+    const specifier = origin.specifier.replace(/^node:/u, "");
+    const importedPath = origin.resolutionMode !== "require" && origin.importedPath[0] === "default"
+        ? origin.importedPath.slice(1)
+        : origin.importedPath;
+    return specifier === "fs" && importedPath[0] === "promises"
+        ? {
+            ...origin,
+            specifier: "fs/promises",
+            importedPath: importedPath.slice(1),
+        }
+        : { ...origin, specifier, importedPath };
+};
+const affectsBuiltinPath = (path, selected) => path.length <= selected.length &&
+    path.every((key, index) => semanticPropertyPathKeyMatches(key, selected[index]));
+const BUILTIN_RECEIVER_METHODS = {
+    fs: new Set([
+        "readFile",
+        "readFileSync",
+        "writeFile",
+        "writeFileSync",
+        "close",
+        "closeSync",
+        "existsSync",
+        ...BUILTIN_RESOURCE_METHODS.fs,
+    ]),
+    "fs/promises": new Set([
+        "readFile",
+        "writeFile",
+        ...BUILTIN_RESOURCE_METHODS["fs/promises"],
+    ]),
+    net: new Set(BUILTIN_RESOURCE_METHODS.net),
+    tls: new Set(BUILTIN_RESOURCE_METHODS.tls),
+    http: new Set(["request", "get"]),
+    https: new Set(["request", "get"]),
+    child_process: new Set(["spawn", "exec", "execFile", "fork"]),
+    process: new Set(["cwd", "uptime", "hrtime", "nextTick"]),
+    timers: new Set([
+        "setTimeout",
+        "setInterval",
+        "setImmediate",
+        "clearTimeout",
+        "clearInterval",
+        "clearImmediate",
+    ]),
+};
+// Derived passes run after mutation collection. These indexes share that state's
+// lifetime and never cache facts while its mutation owner is still producing them.
+const builtinEffectIndexes = new WeakMap();
+const builtinEffectIndex = (state) => {
+    let index = builtinEffectIndexes.get(state);
+    if (index === undefined) {
+        index = {
+            writesByModule: new Map([...state.requiredModuleEffects].map(([name, effects]) => [
+                name,
+                effects.filter(({ kind }) => kind === "write"),
+            ])),
+            moduleEffects: new Map(),
+            bindingEscapes: new Map(),
+            receivers: new WeakMap(),
+        };
+        builtinEffectIndexes.set(state, index);
+    }
+    return index;
+};
+const builtinEscapes = (binding, state) => {
+    const cache = builtinEffectIndex(state).bindingEscapes;
+    let effects = cache.get(binding.bindingId);
+    if (effects === undefined) {
+        effects = binding.escapedPaths.filter(({ node }) => !originalBuiltinReceiver(node, state));
+        cache.set(binding.bindingId, effects);
+    }
+    return effects;
+};
+const builtinModuleEffects = (specifier, state) => {
+    const cache = builtinEffectIndex(state).moduleEffects;
+    let effects = cache.get(specifier);
+    if (effects === undefined) {
+        effects = (state.requiredModuleEffects.get(specifier) ?? []).filter(({ kind, node }) => kind === "write" || !originalBuiltinReceiver(node, state));
+        if (specifier === "fs/promises") {
+            const sharedFsEscapes = (state.requiredModuleEffects.get("fs") ?? [])
+                .filter(({ kind, path, node }) => kind === "escape" &&
+                (path.length === 0 || path[0] === "promises") &&
+                !originalBuiltinReceiver(node, state))
+                .map((effect) => ({
+                ...effect,
+                path: effect.path[0] === "promises" ? effect.path.slice(1) : effect.path,
+            }));
+            effects = [...effects, ...sharedFsEscapes];
+        }
+        cache.set(specifier, effects);
+    }
+    return effects;
+};
+/** Check shared exports at the use or method-capture point, not at every later call. */
+const requiredModuleChanged = (specifier, selected, capture, state, callableValue = false, savedObjectCapture) => {
+    const identity = semanticRequireExportsIdentity(specifier, selected);
+    return builtinModuleEffects(identity.specifier, state).some(({ path, node, kind }) => !(savedObjectCapture !== undefined &&
+        path.length < identity.path.length &&
+        semanticTopLevelEffectFollowsCapture(savedObjectCapture, node, state.parentsByNode)) &&
+        affectsBuiltinPath(path, identity.path) &&
+        !semanticTopLevelEffectFollowsCapture(capture, node, state.parentsByNode) &&
+        (kind === "write" ||
+            !callableValue ||
+            path.length < identity.path.length));
+};
+/** Calling an unchanged built-in as a member is not an escape to unknown code. */
+const originalBuiltinReceiver = (node, state) => {
+    if (node === undefined)
+        return false;
+    const receivers = builtinEffectIndex(state).receivers;
+    const previous = receivers.get(node);
+    if (previous !== undefined)
+        return previous;
+    const result = computeOriginalBuiltinReceiver(node, state);
+    receivers.set(node, result);
+    return result;
+};
+const computeOriginalBuiltinReceiver = (node, state) => {
+    if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+        return false;
+    const callee = node.callee;
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee))
+        return false;
+    const receiver = t.isIdentifier(callee.object)
+        ? resolveSemanticBindingState(state, callee.object, callee.object.name)
+        : undefined;
+    const provenance = receiver === undefined
+        ? undefined
+        : evaluateSemanticProvenance(receiver, state);
+    const sourceOrigin = provenance?.status === "module"
+        ? provenance.origins[0]
+        : (semanticExpressionModuleOrigin(callee.object, state) ??
+            semanticRequireOrigin(callee.object, state)?.origin ??
+            semanticGlobalProcessOrigin(callee.object, state));
+    if (sourceOrigin === undefined)
+        return false;
+    const origin = builtinNamespaceOrigin(sourceOrigin);
+    if (origin.importedPath.length !== 0)
+        return false;
+    const method = semanticStaticPropertyKey(callee.property, callee.computed);
+    const identity = semanticRequireExportsIdentity(origin.specifier, [
+        method ?? "",
+    ]);
+    if (method === null ||
+        !BUILTIN_RECEIVER_METHODS[origin.specifier]?.has(method) ||
+        receiver?.memberWrites.some(({ path, node: write }) => affectsBuiltinPath(path, [method]) &&
+            !semanticTopLevelEffectFollowsCapture(node, write, state.parentsByNode)) ||
+        (builtinEffectIndex(state).writesByModule.get(identity.specifier) ?? []).some(({ path, node: write }) => affectsBuiltinPath(path, identity.path) &&
+            !semanticTopLevelEffectFollowsCapture(node, write, state.parentsByNode)))
+        return false;
+    return !node.arguments.some((argument) => {
+        if (!t.isIdentifier(argument))
+            return false;
+        const passed = resolveSemanticBindingState(state, argument, argument.name);
+        if (passed === undefined)
+            return false;
+        const passedOrigin = evaluateSemanticProvenance(passed, state);
+        return (passedOrigin.status === "module" &&
+            builtinNamespaceOrigin(passedOrigin.origins[0]).specifier ===
+                origin.specifier &&
+            builtinNamespaceOrigin(passedOrigin.origins[0]).importedPath.length === 0);
+    });
+};
+const semanticExpressionModuleOrigin = (expression, state, visited = new Set()) => {
+    const node = unwrapJavaScriptExpression(expression).node;
+    const required = semanticRequireOrigin(node, state);
+    if (required !== undefined)
+        return required.origin;
+    if (t.isIdentifier(node)) {
+        const binding = resolveSemanticBindingState(state, node, node.name);
+        if (binding === undefined || visited.has(binding.bindingId))
+            return undefined;
+        const provenance = evaluateSemanticProvenance(binding, state);
+        return provenance.status === "module" ? provenance.origins[0] : undefined;
+    }
+    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+        const base = semanticExpressionModuleOrigin(node.object, state, visited);
+        const key = semanticStaticPropertyKey(node.property, node.computed);
+        return base === undefined || key === null
+            ? undefined
+            : { ...base, importedPath: [...base.importedPath, key] };
+    }
+    return undefined;
 };
 /** Recognize global or node:process aliases without accepting shadowing. */
-export const isSemanticProcessObject = (node, state) => {
+export const isSemanticProcessObject = (node, state, family, key) => {
     if (!t.isIdentifier(node))
         return false;
     const binding = resolveSemanticBindingState(state, node, node.name);
+    const selected = key === undefined || key === null ? [family] : [family, key];
     if (binding === undefined)
-        return (node.name === "process" &&
-            !semanticResolutionBlocked(state, node, node.name));
-    return binding.directOrigins.some(({ specifier }) => specifier === "process" || specifier === "node:process");
+        return (semanticGlobalProcessOrigin(node, state) !== undefined &&
+            !requiredModuleChanged("process", selected, node, state));
+    return (builtinBindingPath(binding, state, ["process", "node:process"], node, selected)?.length === 0);
 };
 /** Resolve the nearest direct variable/assignment owner before a callable. */
 export const outerDataEffectBinding = (node, context) => {
@@ -130,21 +535,17 @@ export const outerDataEffectBinding = (node, context) => {
 };
 /** Traverse with exact callable and ancestor stacks. */
 export const traverseDataEffects = (program, context, visit) => {
-    context.callableStack.length = 0;
+    const callableStack = createSemanticCallableIdStack(context.callableIds, context.callableStack);
     context.ancestors.length = 0;
     traverseJavaScriptAst(program, {
         enter: (node, parent) => {
-            const callableId = semanticCallableIdForNode(node);
-            if (callableId !== null && context.callableIds.has(callableId))
-                context.callableStack.push(callableId);
+            callableStack.enter(node, parent);
             visit(node, parent);
             context.ancestors.push(node);
         },
         exit: (node) => {
             context.ancestors.pop();
-            const callableId = semanticCallableIdForNode(node);
-            if (callableId !== null && context.callableStack.at(-1) === callableId)
-                context.callableStack.pop();
+            callableStack.exit(node);
         },
     });
 };
@@ -175,8 +576,3 @@ export const dataEffectLiteralString = (node) => {
 export const dataEffectMemberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
     ? node.callee
     : null;
-/** Read a parent member's object when present. */
-export const dataEffectMemberObject = (node) => node !== null &&
-    (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
-    ? node.object
-    : null;

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -1,9 +1,8 @@
 import * as t from "@babel/types";
-import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
@@ -29,8 +28,8 @@ export const collectJavaScriptSemanticDataEffects = (program, state, callables)
 };
 const collectConfigurations = (program, context) => {
     const output = [];
-    traverseWithContext(program, context, (node, parent) => {
-        const details = configurationDetails(node, parent, context);
+    traverseWithContext(program, context, (node) => {
+        const details = configurationDetails(node, context);
         if (details === null)
             return;
         const operation = {
@@ -48,9 +47,8 @@ const collectConfigurations = (program, context) => {
     });
     return output;
 };
-const configurationDetails = (node, parent, context) => {
-    if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
-        !(memberObject(parent) === node)) {
+const configurationDetails = (node, context) => {
+    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
         const processMember = processConfigurationMember(node, context.state);
         if (processMember !== null)
             return processMember;
@@ -73,8 +71,6 @@ const processConfigurationMember = (node, state) => {
     const object = node.object;
     if (!t.isMemberExpression(object) && !t.isOptionalMemberExpression(object))
         return null;
-    if (!isProcessObject(object.object, state))
-        return null;
     const family = semanticStaticPropertyName(object.property, object.computed);
     if (family !== "env" && family !== "argv")
         return null;
@@ -82,6 +78,8 @@ const processConfigurationMember = (node, state) => {
     const key = semanticStaticPropertyKey(node.property, node.computed);
     if (family === "argv" && key !== null && !isArrayIndexKey(key))
         return null;
+    if (!isProcessObject(object.object, state, family, key))
+        return null;
     return {
         kind: family === "env" ? "environment" : "argv",
         key,
@@ -256,17 +254,13 @@ const requestMethod = (node, state) => {
         if (t.isNewExpression(node) && unbound && name === "WebSocket")
             return "WebSocket";
     }
-    const member = memberCallee(node);
-    if (member === null || !t.isIdentifier(member.object))
-        return null;
-    const method = semanticStaticPropertyName(member.property, member.computed);
-    if (method !== "request" && method !== "get")
-        return null;
-    const binding = resolveSemanticBindingState(state, member.object, member.object.name);
-    return binding?.directOrigins.some(({ specifier, importedPath }) => ["http", "https", "node:http", "node:https"].includes(specifier) &&
-        semanticBuiltinNamespacePath(importedPath))
-        ? method
-        : null;
+    const method = builtinMethod(node.callee, state, [
+        "http",
+        "https",
+        "node:http",
+        "node:https",
+    ]);
+    return method === "request" || method === "get" ? method : null;
 };
 const requestFields = (node, method, state) => {
     const candidate = method === "fetch" || method === "WebSocket"

package/dist/domain/javascript/javascriptSemanticDependencies.js

@@ -0,0 +1,69 @@
+/**
+ * Identity layout belongs to the indexed state, not to a query or its effects.
+ * Every proof has the same height. Union shares unchanged branches, so aliases
+ * add a path rather than copying their dependency's transitive membership set.
+ */
+export class SemanticDependencyProofs {
+    indices = new Map();
+    singletons = new Map();
+    height;
+    constructor(bindings) {
+        for (const binding of bindings)
+            this.indices.set(binding, this.indices.size);
+        this.height = Math.ceil(Math.log2(Math.max(1, this.indices.size)));
+    }
+    binding(binding) {
+        const prior = this.singletons.get(binding);
+        if (prior !== undefined)
+            return prior;
+        const index = this.index(binding);
+        let proof = true;
+        for (let bit = 0; bit < this.height; bit++) {
+            const one = Math.floor(index / 2 ** bit) % 2 === 1;
+            proof = Object.freeze({
+                zero: one ? undefined : proof,
+                one: one ? proof : undefined,
+            });
+        }
+        this.singletons.set(binding, proof);
+        return proof;
+    }
+    union(first, second) {
+        if (first === second || second === undefined)
+            return first;
+        if (first === undefined)
+            return second;
+        if (first === true || second === true)
+            return true;
+        const zero = this.union(first.zero, second.zero);
+        const one = this.union(first.one, second.one);
+        if (zero === first.zero && one === first.one)
+            return first;
+        if (zero === second.zero && one === second.one)
+            return second;
+        return Object.freeze({ zero, one });
+    }
+    intersects(proof, active) {
+        for (const binding of active.keys())
+            if (this.has(proof, binding))
+                return true;
+        return false;
+    }
+    has(proof, binding) {
+        const index = this.index(binding);
+        for (let bit = this.height - 1; bit >= 0; bit--) {
+            if (proof === undefined)
+                return false;
+            if (proof === true)
+                return true;
+            proof = Math.floor(index / 2 ** bit) % 2 === 1 ? proof.one : proof.zero;
+        }
+        return proof === true;
+    }
+    index(binding) {
+        const index = this.indices.get(binding);
+        if (index === undefined)
+            throw new TypeError(`Unindexed semantic dependency: ${binding}`);
+        return index;
+    }
+}