rea-agents 2.3.0 → 2.5.0

package/dist/domain/javascriptSemanticChildProcesses.js

@@ -0,0 +1,237 @@
+import * as t from "@babel/types";
+import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+const CHILD_PROCESS_METHODS = ["spawn", "exec", "execFile", "fork"];
+const CHILD_LISTENER_METHODS = ["on", "once", "addListener"];
+/** Recover explicit asynchronous node:child_process ownership candidates. */
+export const collectJavaScriptSemanticChildProcesses = (program, state, callables) => {
+    const candidates = collectSpawns(program, state, callables);
+    const childProcessSpawns = candidates.map((candidate) => immutableSpawn(candidate));
+    return {
+        childProcessSpawns,
+        childProcessInteractions: collectInteractions(program, state, callables, candidates),
+    };
+};
+const collectSpawns = (program, state, callables) => {
+    const output = [];
+    const admittedCallables = new Set(callables.map(({ callableId }) => callableId));
+    const callableStack = [];
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && admittedCallables.has(callableId))
+                callableStack.push(callableId);
+            if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+                return;
+            const method = childProcessMethod(node.callee, state);
+            if (method === null)
+                return;
+            if (operationLimitReached(output.length, state))
+                return;
+            output.push({
+                node,
+                method,
+                ownerCallableId: callableStack.at(-1) ?? null,
+                resultBindingId: assignedBindingId(parent, node, state),
+            });
+        },
+        exit: (node) => popCallable(node, callableStack),
+    });
+    return output;
+};
+const immutableSpawn = (candidate) => {
+    const options = spawnOptions(candidate);
+    const command = literalString(candidate.node.arguments[0]);
+    return {
+        processId: spawnId(candidate),
+        method: candidate.method,
+        location: range(candidate.node),
+        ownerCallableId: candidate.ownerCallableId,
+        resultBindingId: candidate.resultBindingId,
+        command,
+        argvCount: spawnArgvCount(candidate),
+        environmentSupplied: objectHasProperty(options, "env"),
+        stdioMode: stdioMode(options),
+        resolution: command === null ? "partial" : "complete",
+    };
+};
+const collectInteractions = (program, state, callables, spawns) => {
+    const output = [];
+    const callableIds = new Set(callables.map(({ callableId }) => callableId));
+    const callableStack = [];
+    const spawnByNode = new WeakMap();
+    const spawnsByBinding = new Map();
+    for (const spawn of spawns) {
+        spawnByNode.set(spawn.node, spawn);
+        if (spawn.resultBindingId === null)
+            continue;
+        const existing = spawnsByBinding.get(spawn.resultBindingId) ?? [];
+        existing.push(spawn);
+        spawnsByBinding.set(spawn.resultBindingId, existing);
+    }
+    const context = {
+        state,
+        spawnByNode,
+        spawnsByBinding,
+    };
+    traverseJavaScriptAst(program, {
+        enter: (node) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && callableIds.has(callableId))
+                callableStack.push(callableId);
+            if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+                return;
+            const interaction = childInteraction(node, callableStack.at(-1) ?? null, context);
+            if (interaction === null)
+                return;
+            if (operationLimitReached(spawns.length + output.length, state))
+                return;
+            output.push(interaction);
+        },
+        exit: (node) => popCallable(node, callableStack),
+    });
+    return output;
+};
+const childInteraction = (node, ownerCallableId, context) => {
+    const { state, spawnByNode, spawnsByBinding } = context;
+    const member = memberCallee(node);
+    if (member === null)
+        return null;
+    const method = semanticStaticPropertyName(member.property, member.computed);
+    const binding = objectBinding(member.object, state);
+    const linked = resolveChildCandidates(member.object, binding, spawnByNode, spawnsByBinding);
+    if (linked.length === 0)
+        return null;
+    const classification = classifyInteraction(method, node.arguments[0]);
+    if (classification === null)
+        return null;
+    const { kind, interactionMethod, eventName } = classification;
+    const listener = node.arguments[1];
+    return {
+        interactionId: `child:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+        kind,
+        method: interactionMethod,
+        location: range(node),
+        ownerCallableId,
+        processBindingId: binding?.bindingId ?? null,
+        linkedProcessIds: linked
+            .map((candidate) => spawnId(candidate))
+            .sort(compareCodePoints),
+        eventName: kind === "listener" ? eventName : null,
+        signalName: kind === "signal"
+            ? (literalString(node.arguments[0]) ?? "SIGTERM")
+            : null,
+        listenerLocation: kind === "listener" && t.isNode(listener) ? range(listener) : null,
+        resolution: linked.length === 1 ? "complete" : "partial",
+    };
+};
+const classifyInteraction = (method, argument) => {
+    if (method === "kill")
+        return { kind: "signal", interactionMethod: "kill", eventName: null };
+    const listenerMethod = CHILD_LISTENER_METHODS.find((candidate) => candidate === method);
+    const eventName = literalString(argument);
+    return listenerMethod !== undefined &&
+        (eventName === "exit" || eventName === "error")
+        ? { kind: "listener", interactionMethod: listenerMethod, eventName }
+        : null;
+};
+const childProcessMethod = (callee, state) => {
+    if (t.isIdentifier(callee)) {
+        const binding = resolveSemanticBindingState(state, callee, callee.name);
+        return binding === undefined ? null : methodFromBinding(binding);
+    }
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee))
+        return null;
+    const method = admittedChildMethod(semanticStaticPropertyName(callee.property, callee.computed));
+    if (method === null || !t.isIdentifier(callee.object))
+        return null;
+    const binding = resolveSemanticBindingState(state, callee.object, callee.object.name);
+    return childProcessNamespace(binding) ? method : null;
+};
+const methodFromBinding = (binding) => {
+    for (const { specifier, importedPath } of binding.directOrigins) {
+        if (!childProcessModule(specifier))
+            continue;
+        const method = admittedChildMethod(importedPath.at(-1) ?? "");
+        if (method !== null)
+            return method;
+    }
+    return null;
+};
+const admittedChildMethod = (value) => CHILD_PROCESS_METHODS.find((candidate) => candidate === value) ?? null;
+const childProcessNamespace = (binding) => binding?.directOrigins.some(({ specifier, importedPath }) => childProcessModule(specifier) && importedPath.length === 0) ?? false;
+const childProcessModule = (specifier) => specifier === "child_process" || specifier === "node:child_process";
+const resolveChildCandidates = (node, binding, spawnByNode, spawnsByBinding) => {
+    const direct = spawnByNode.get(node);
+    if (direct !== undefined)
+        return [direct];
+    return binding === undefined
+        ? []
+        : (spawnsByBinding.get(binding.bindingId) ?? []);
+};
+const spawnOptions = (candidate) => {
+    const index = candidate.method === "exec" ? 1 : 2;
+    const value = candidate.node.arguments[index];
+    return t.isObjectExpression(value) ? value : null;
+};
+const spawnArgvCount = (candidate) => {
+    if (candidate.method === "exec")
+        return null;
+    const args = candidate.node.arguments[1];
+    return t.isArrayExpression(args) ? args.elements.length : null;
+};
+const objectHasProperty = (object, name) => objectProperty(object, name) !== null;
+const stdioMode = (options) => {
+    const property = objectProperty(options, "stdio");
+    if (property === null || !t.isObjectProperty(property))
+        return "default";
+    if (t.isStringLiteral(property.value))
+        return property.value.value;
+    if (t.isArrayExpression(property.value))
+        return "array";
+    return "dynamic";
+};
+const objectProperty = (object, name) => object?.properties.find((property) => (t.isObjectMethod(property) || t.isObjectProperty(property)) &&
+    propertyName(property.key) === name) ?? null;
+const objectBinding = (node, state) => t.isIdentifier(node)
+    ? resolveSemanticBindingState(state, node, node.name)
+    : undefined;
+const assignedBindingId = (parent, node, state) => {
+    const identifier = t.isVariableDeclarator(parent) &&
+        parent.init === node &&
+        t.isIdentifier(parent.id)
+        ? parent.id
+        : t.isAssignmentExpression(parent) &&
+            parent.right === node &&
+            t.isIdentifier(parent.left)
+            ? parent.left
+            : null;
+    return identifier === null
+        ? null
+        : (resolveSemanticBindingState(state, identifier, identifier.name)
+            ?.bindingId ?? null);
+};
+const literalString = (node) => {
+    if (t.isStringLiteral(node))
+        return node.value;
+    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
+        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
+    return null;
+};
+const operationLimitReached = (retained, state) => {
+    if (retained < state.limits.maxChildProcessOperations)
+        return false;
+    reachSemanticLimit(state, "maxChildProcessOperations");
+    return true;
+};
+const popCallable = (node, stack) => {
+    const callableId = semanticCallableIdForNode(node);
+    if (callableId !== null && stack.at(-1) === callableId)
+        stack.pop();
+};
+const spawnId = (candidate) => `child:spawn:${String(candidate.node.start ?? -1)}:${String(candidate.node.end ?? -1)}`;
+const memberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
+    ? node.callee
+    : null;

package/dist/domain/javascriptSemanticDataEffectHelpers.js

@@ -0,0 +1,125 @@
+import * as t from "@babel/types";
+import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+/** Resolve a direct or namespace-imported built-in method. */
+export const builtinDataEffectMethod = (callee, state, specifiers) => {
+    if (t.isIdentifier(callee)) {
+        const binding = resolveSemanticBindingState(state, callee, callee.name);
+        return moduleMethod(binding, specifiers);
+    }
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee))
+        return null;
+    if (!t.isIdentifier(callee.object))
+        return null;
+    const binding = resolveSemanticBindingState(state, callee.object, callee.object.name);
+    const namespace = binding?.directOrigins.some(({ specifier, importedPath }) => specifiers.includes(specifier) && importedPath.length === 0);
+    return namespace
+        ? semanticStaticPropertyName(callee.property, callee.computed)
+        : null;
+};
+const moduleMethod = (binding, specifiers) => {
+    for (const { specifier, importedPath } of binding?.directOrigins ?? []) {
+        if (!specifiers.includes(specifier))
+            continue;
+        return importedPath.at(-1) ?? null;
+    }
+    return null;
+};
+/** Recognize global or node:process aliases without accepting shadowing. */
+export const isSemanticProcessObject = (node, state) => {
+    if (!t.isIdentifier(node))
+        return false;
+    const binding = resolveSemanticBindingState(state, node, node.name);
+    if (binding === undefined)
+        return (node.name === "process" &&
+            !semanticResolutionBlocked(state, node, node.name));
+    return binding.directOrigins.some(({ specifier }) => specifier === "process" || specifier === "node:process");
+};
+/** Resolve the nearest direct variable/assignment owner before a callable. */
+export const outerDataEffectBinding = (node, context) => {
+    for (let index = context.ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = context.ancestors[index];
+        if (ancestor === undefined)
+            continue;
+        if (t.isVariableDeclarator(ancestor) &&
+            t.isNode(ancestor.init) &&
+            containsSemanticNode(ancestor.init, node) &&
+            t.isIdentifier(ancestor.id))
+            return (resolveSemanticBindingState(context.state, ancestor.id, ancestor.id.name)?.bindingId ?? null);
+        if (t.isAssignmentExpression(ancestor) &&
+            containsSemanticNode(ancestor.right, node) &&
+            t.isIdentifier(ancestor.left))
+            return (resolveSemanticBindingState(context.state, ancestor.left, ancestor.left.name)?.bindingId ?? null);
+        if (semanticCallableIdForNode(ancestor) !== null)
+            return null;
+    }
+    return null;
+};
+/** Traverse with exact callable and ancestor stacks. */
+export const traverseDataEffects = (program, context, visit) => {
+    context.callableStack.length = 0;
+    context.ancestors.length = 0;
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && context.callableIds.has(callableId))
+                context.callableStack.push(callableId);
+            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();
+        },
+    });
+};
+/** Resolve one direct identifier argument to a lexical binding. */
+export const dataEffectArgumentBindingId = (node, state) => t.isIdentifier(node)
+    ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
+    : null;
+/** Read one JSON primitive default without evaluating code. */
+export const dataEffectPrimitive = (node) => {
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
+        return node.value;
+    if (t.isBooleanLiteral(node))
+        return node.value;
+    return null;
+};
+/** Read one static string or expression-free template. */
+export const dataEffectLiteralString = (node) => {
+    if (t.isStringLiteral(node))
+        return node.value;
+    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
+        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
+    return null;
+};
+/** Read a member callee from call or construction syntax. */
+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;
+/** Compare Babel source offsets for exact containment. */
+export const containsSemanticNode = (outer, inner) => outer.start !== null &&
+    outer.start !== undefined &&
+    outer.end !== null &&
+    outer.end !== undefined &&
+    inner.start !== null &&
+    inner.start !== undefined &&
+    inner.end !== null &&
+    inner.end !== undefined &&
+    outer.start <= inner.start &&
+    outer.end >= inner.end;
+/** Record one bounded data-effect frontier. */
+export const dataEffectLimitReached = (retained, limit, name, state) => {
+    if (retained < limit)
+        return false;
+    reachSemanticLimit(state, name);
+    return true;
+};

package/dist/domain/javascriptSemanticDataEffects.js

@@ -0,0 +1,284 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLimitReached as limitReached, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+/** Recover configuration, request, and boundary candidates from inert syntax. */
+export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
+    const context = {
+        state,
+        callableIds: new Set(callables.map(({ callableId }) => callableId)),
+        callableStack: [],
+        ancestors: [],
+    };
+    const configuration = collectConfigurations(program, context);
+    const requests = collectRequests(program, context);
+    return {
+        configurationOperations: [
+            ...configuration.map(({ operation }) => operation),
+            ...collectDefaults(program, context, configuration),
+        ],
+        requestOperations: [
+            ...requests.map(({ operation }) => operation),
+            ...collectResponseConsumers(program, context, requests),
+        ],
+        boundaryOperations: collectBoundaries(program, context),
+    };
+};
+const collectConfigurations = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node, parent) => {
+        const details = configurationDetails(node, parent, context);
+        if (details === null)
+            return;
+        if (limitReached(output.length, context.state.limits.maxConfigurationOperations, "maxConfigurationOperations", context.state))
+            return;
+        const operation = {
+            configId: `config:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: details.kind,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            key: details.key,
+            sourceConfigId: null,
+            value: null,
+            resolution: details.resolution,
+        };
+        output.push({ node, operation });
+    });
+    return output;
+};
+const configurationDetails = (node, parent, context) => {
+    if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
+        !(memberObject(parent) === node)) {
+        const processMember = processConfigurationMember(node, context.state);
+        if (processMember !== null)
+            return processMember;
+    }
+    if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+        return null;
+    const fileMethod = builtinMethod(node.callee, context.state, [
+        "fs",
+        "node:fs",
+    ]);
+    return fileMethod === "readFile" || fileMethod === "readFileSync"
+        ? {
+            kind: "file",
+            key: literalString(node.arguments[0]),
+            resolution: literalString(node.arguments[0]) === null ? "partial" : "complete",
+        }
+        : null;
+};
+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;
+    const key = semanticStaticPropertyName(node.property, node.computed) || null;
+    return {
+        kind: family === "env" ? "environment" : "argv",
+        key,
+        resolution: key === null ? "partial" : "complete",
+    };
+};
+const collectDefaults = (program, context, configurations) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isLogicalExpression(node) ||
+            (node.operator !== "??" && node.operator !== "||"))
+            return;
+        const sources = configurations.filter(({ node: source }) => containsNode(node.left, source));
+        if (sources.length !== 1 || sources[0] === undefined)
+            return;
+        if (limitReached(configurations.length + output.length, context.state.limits.maxConfigurationOperations, "maxConfigurationOperations", context.state))
+            return;
+        output.push({
+            configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: "default",
+            location: range(node.right),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            key: sources[0].operation.key,
+            sourceConfigId: sources[0].operation.configId,
+            value: primitiveValue(node.right),
+            resolution: primitiveValue(node.right) === null ? "partial" : "complete",
+        });
+    });
+    return output;
+};
+const collectRequests = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) &&
+            !t.isOptionalCallExpression(node) &&
+            !t.isNewExpression(node))
+            return;
+        const method = requestMethod(node, context.state);
+        if (method === null)
+            return;
+        if (limitReached(output.length, context.state.limits.maxRequestOperations, "maxRequestOperations", context.state))
+            return;
+        const endpoint = requestEndpoint(node);
+        output.push({
+            node,
+            operation: {
+                requestId: `request:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+                kind: "request",
+                method,
+                location: range(node),
+                ownerCallableId: context.callableStack.at(-1) ?? null,
+                resultBindingId: outerAssignedBinding(node, context),
+                linkedRequestIds: [],
+                endpoint,
+                fields: requestFields(node, method, context.state),
+                resolution: endpoint === null ? "partial" : "complete",
+            },
+        });
+    });
+    return output;
+};
+const collectResponseConsumers = (program, context, requests) => {
+    const requestsByBinding = new Map();
+    for (const request of requests) {
+        const bindingId = request.operation.resultBindingId;
+        if (bindingId === null)
+            continue;
+        const existing = requestsByBinding.get(bindingId) ?? [];
+        existing.push(request);
+        requestsByBinding.set(bindingId, existing);
+    }
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+            return;
+        const member = memberCallee(node);
+        if (member === null || !t.isIdentifier(member.object))
+            return;
+        const method = semanticStaticPropertyName(member.property, member.computed);
+        if (method !== "json" && method !== "text" && method !== "arrayBuffer")
+            return;
+        const binding = resolveSemanticBindingState(context.state, member.object, member.object.name);
+        const linked = binding === undefined
+            ? []
+            : (requestsByBinding.get(binding.bindingId) ?? []);
+        if (linked.length === 0)
+            return;
+        if (limitReached(requests.length + output.length, context.state.limits.maxRequestOperations, "maxRequestOperations", context.state))
+            return;
+        output.push({
+            requestId: `response:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: "response-consumer",
+            method,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            linkedRequestIds: linked
+                .map(({ operation }) => operation.requestId)
+                .sort(compareCodePoints),
+            endpoint: null,
+            fields: [],
+            resolution: linked.length === 1 ? "complete" : "partial",
+        });
+    });
+    return output;
+};
+const collectBoundaries = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+            return;
+        const details = boundaryDetails(node, context.state);
+        if (details === null)
+            return;
+        if (limitReached(output.length, context.state.limits.maxBoundaryOperations, "maxBoundaryOperations", context.state))
+            return;
+        output.push({
+            boundaryId: `boundary:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: details.kind,
+            method: details.method,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            sourceBindingId: argumentBindingId(node.arguments[0], context.state),
+            resultBindingId: outerAssignedBinding(node, context),
+            resolution: details.resolution,
+        });
+    });
+    return output;
+};
+const boundaryDetails = (node, state) => {
+    if (t.isIdentifier(node.callee)) {
+        const name = node.callee.name;
+        const unbound = resolveSemanticBindingState(state, node.callee, name) === undefined &&
+            !semanticResolutionBlocked(state, node.callee, name);
+        if (unbound &&
+            ["String", "Number", "Boolean", "parseInt", "parseFloat"].includes(name))
+            return { kind: "coerce", method: name, resolution: "complete" };
+    }
+    const member = memberCallee(node);
+    if (member === null)
+        return null;
+    const method = semanticStaticPropertyName(member.property, member.computed);
+    if (method === "parse" &&
+        t.isIdentifier(member.object, { name: "JSON" }) &&
+        resolveSemanticBindingState(state, member.object, "JSON") === undefined &&
+        !semanticResolutionBlocked(state, member.object, "JSON"))
+        return { kind: "parse", method: "JSON.parse", resolution: "complete" };
+    if (method === "parse" || method === "safeParse")
+        return { kind: "parse", method, resolution: "partial" };
+    if (method === "validate" || method === "assert" || method === "is")
+        return { kind: "validate", method, resolution: "partial" };
+    return null;
+};
+const requestMethod = (node, state) => {
+    if (t.isIdentifier(node.callee)) {
+        const name = node.callee.name;
+        const unbound = resolveSemanticBindingState(state, node.callee, name) === undefined &&
+            !semanticResolutionBlocked(state, node.callee, name);
+        if (!t.isNewExpression(node) && unbound && name === "fetch")
+            return "fetch";
+        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) &&
+        importedPath.length === 0)
+        ? method
+        : null;
+};
+const requestFields = (node, method, state) => {
+    const candidate = method === "fetch" || method === "WebSocket"
+        ? node.arguments[1]
+        : t.isObjectExpression(node.arguments[0])
+            ? node.arguments[0]
+            : node.arguments[1];
+    if (!t.isObjectExpression(candidate))
+        return [];
+    return candidate.properties.flatMap((property) => {
+        if (!t.isObjectProperty(property))
+            return [];
+        const name = propertyName(property.key);
+        if (name.length === 0)
+            return [];
+        return [
+            {
+                name,
+                sourceBindingId: t.isIdentifier(property.value)
+                    ? (resolveSemanticBindingState(state, property.value, property.value.name)?.bindingId ?? null)
+                    : null,
+            },
+        ];
+    });
+};
+const requestEndpoint = (node) => t.isObjectExpression(node.arguments[0])
+    ? null
+    : literalString(node.arguments[0]);