rea-agents 2.3.0 → 2.5.0

package/dist/domain/javascriptSemanticDerivedAnalysis.js

@@ -0,0 +1,41 @@
+import { collectJavaScriptSemanticAsyncEffects } from "./javascriptSemanticAsyncEffects.js";
+import { collectJavaScriptSemanticCalls } from "./javascriptSemanticCalls.js";
+import { collectJavaScriptSemanticChildProcesses } from "./javascriptSemanticChildProcesses.js";
+import { collectJavaScriptSemanticFingerprints } from "./javascriptSemanticFingerprints.js";
+import { collectJavaScriptSemanticDataEffects } from "./javascriptSemanticDataEffects.js";
+import { collectJavaScriptSemanticPromises } from "./javascriptSemanticPromises.js";
+import { collectJavaScriptSemanticObjects } from "./javascriptSemanticObjects.js";
+import { collectJavaScriptSemanticResources } from "./javascriptSemanticResources.js";
+/** Compose bounded semantic passes after lexical definitions are available. */
+export const collectJavaScriptDerivedSemantics = (program, state, callables, parserPartial) => {
+    const calls = collectJavaScriptSemanticCalls(program, state, callables);
+    const promiseOperations = collectJavaScriptSemanticPromises(program, state, callables);
+    const asyncEffects = collectJavaScriptSemanticAsyncEffects(program, state, callables);
+    const childProcesses = collectJavaScriptSemanticChildProcesses(program, state, callables);
+    const dataEffects = collectJavaScriptSemanticDataEffects(program, state, callables);
+    const resourceOperations = collectJavaScriptSemanticResources(program, state, callables);
+    const objectOperations = collectJavaScriptSemanticObjects(program, state, callables);
+    const functionFingerprints = collectJavaScriptSemanticFingerprints({
+        state,
+        callables,
+        calls,
+        promises: promiseOperations,
+        events: asyncEffects.eventOperations,
+        timers: asyncEffects.timerOperations,
+        childProcessSpawns: childProcesses.childProcessSpawns,
+        childProcessInteractions: childProcesses.childProcessInteractions,
+        requestOperations: dataEffects.requestOperations,
+        resourceOperations,
+        parserPartial,
+    });
+    return {
+        ...calls,
+        promiseOperations,
+        ...asyncEffects,
+        ...childProcesses,
+        ...dataEffects,
+        resourceOperations,
+        objectOperations,
+        functionFingerprints,
+    };
+};

package/dist/domain/javascriptSemanticFingerprints.js

@@ -0,0 +1,174 @@
+import { createHash } from "node:crypto";
+import * as t from "@babel/types";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { compareCodePoints } from "./javascriptStaticAnalysisHelpers.js";
+/** Build bounded rename- and formatting-resistant components per callable. */
+export const collectJavaScriptSemanticFingerprints = (input) => {
+    const { state, callables, calls, promises, events, timers, childProcessSpawns, childProcessInteractions, requestOperations, resourceOperations, parserPartial, } = input;
+    return callables.flatMap((callable) => {
+        if (callable.kind === "class")
+            return [];
+        const node = state.callableNodesById.get(callable.callableId);
+        if (node === undefined)
+            return [];
+        const syntax = fingerprintSyntax(node, callable.callableId);
+        const promiseEffects = promises.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const eventEffects = events.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const timerEffects = timers.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const childProcessEffects = [
+            ...childProcessSpawns,
+            ...childProcessInteractions,
+        ].filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const networkEffects = requestOperations.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const resourceEffects = resourceOperations.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        return [
+            {
+                callableId: callable.callableId,
+                status: parserPartial ||
+                    state.limitsReached.size > 0 ||
+                    callable.returnCoverage.status !== "complete"
+                    ? "partial"
+                    : "complete",
+                components: {
+                    parameterArity: callableParameterArity(node),
+                    normalizedAstSha256: digest(syntax.normalizedTokens),
+                    controlFlowSha256: digest(syntax.controlFlowTokens),
+                    relationShapeSha256: digest(relationShape(callable, calls, promiseEffects)),
+                    literalSetSha256: digest([...new Set(syntax.literals)].sort(compareCodePoints)),
+                    effects: [
+                        ...(isAsyncCallable(node) ? ["async"] : []),
+                        ...(childProcessEffects.length > 0
+                            ? ["child-process"]
+                            : []),
+                        ...(eventEffects.length > 0 ? ["event"] : []),
+                        ...(networkEffects.length > 0 ? ["network"] : []),
+                        ...(promiseEffects.length > 0 ? ["promise"] : []),
+                        ...(resourceEffects.length > 0 ? ["resource"] : []),
+                        ...(timerEffects.length > 0 ? ["timer"] : []),
+                    ],
+                },
+                limitations: [
+                    "The fingerprint is a bounded static candidate and does not prove behavioral equivalence.",
+                    ...(parserPartial || state.limitsReached.size > 0
+                        ? ["Incomplete semantic recovery makes this fingerprint partial."]
+                        : []),
+                ],
+            },
+        ];
+    });
+};
+const fingerprintSyntax = (root, targetCallableId) => {
+    const normalizedTokens = [];
+    const controlFlowTokens = [];
+    const literals = [];
+    const callableStack = [];
+    traverseJavaScriptAst(root, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null)
+                callableStack.push(callableId);
+            if (callableStack.at(-1) !== targetCallableId)
+                return;
+            normalizedTokens.push(normalizedNodeToken(node, parent));
+            const control = controlFlowToken(node);
+            if (control !== null)
+                controlFlowTokens.push(control);
+            const literal = semanticLiteral(node);
+            if (literal !== null)
+                literals.push(literal);
+        },
+        exit: (node) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && callableStack.at(-1) === callableId)
+                callableStack.pop();
+        },
+    });
+    return { normalizedTokens, controlFlowTokens, literals };
+};
+const normalizedNodeToken = (node, parent) => {
+    if (t.isIdentifier(node))
+        return propertyIdentity(node, parent)
+            ? `property:${node.name}`
+            : "identifier";
+    if (t.isStringLiteral(node))
+        return propertyIdentity(node, parent)
+            ? `property:${node.value}`
+            : "string-literal";
+    const attributes = [
+        primitiveAttribute(node, "operator"),
+        primitiveAttribute(node, "kind"),
+        primitiveAttribute(node, "computed"),
+        primitiveAttribute(node, "optional"),
+        primitiveAttribute(node, "async"),
+        primitiveAttribute(node, "generator"),
+    ].filter((value) => value !== null);
+    return [node.type, ...attributes].join(":");
+};
+const primitiveAttribute = (node, key) => {
+    const value = Reflect.get(node, key);
+    return typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+        ? `${key}=${String(value)}`
+        : null;
+};
+const propertyIdentity = (node, parent) => {
+    if (parent === null)
+        return false;
+    if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
+        parent.property === node)
+        return !parent.computed || t.isStringLiteral(node);
+    if ((t.isObjectProperty(parent) ||
+        t.isObjectMethod(parent) ||
+        t.isClassMethod(parent) ||
+        t.isClassProperty(parent)) &&
+        parent.key === node)
+        return !parent.computed || t.isStringLiteral(node);
+    return false;
+};
+const controlFlowToken = (node) => {
+    if (!t.isIfStatement(node) &&
+        !t.isConditionalExpression(node) &&
+        !t.isSwitchStatement(node) &&
+        !t.isSwitchCase(node) &&
+        !t.isLoop(node) &&
+        !t.isTryStatement(node) &&
+        !t.isCatchClause(node) &&
+        !t.isReturnStatement(node) &&
+        !t.isThrowStatement(node) &&
+        !t.isAwaitExpression(node) &&
+        !t.isYieldExpression(node) &&
+        !t.isLogicalExpression(node))
+        return null;
+    const operator = primitiveAttribute(node, "operator");
+    return operator === null ? node.type : `${node.type}:${operator}`;
+};
+const semanticLiteral = (node) => {
+    if (t.isStringLiteral(node))
+        return `string:${node.value}`;
+    if (t.isNumericLiteral(node))
+        return `number:${String(node.value)}`;
+    if (t.isBooleanLiteral(node))
+        return `boolean:${String(node.value)}`;
+    if (t.isNullLiteral(node))
+        return "null";
+    if (t.isBigIntLiteral(node))
+        return `bigint:${node.value}`;
+    if (t.isRegExpLiteral(node))
+        return `regexp:${node.pattern}/${node.flags}`;
+    if (t.isTemplateElement(node))
+        return `template:${node.value.cooked ?? node.value.raw}`;
+    return null;
+};
+const relationShape = (callable, calls, promises) => [
+    `returns:${String(callable.returnSites.length)}:${callable.returnCoverage.status}`,
+    ...calls.callSites
+        .filter(({ callerCallableId }) => callerCallableId === callable.callableId)
+        .map(({ kind, resolution, arguments: args, calleeCallableIds }) => `call:${kind}:${resolution}:${String(args.length)}:${String(calleeCallableIds.length)}`),
+    `captures:${String(calls.closureCaptures.filter(({ callableId }) => callableId === callable.callableId).length)}`,
+    ...promises.map(({ kind, method, ownership, sourceResolution }) => `promise:${kind}:${method}:${ownership}:${sourceResolution}`),
+];
+const callableParameterArity = (node) => t.isFunction(node) ? node.params.length : 0;
+const isAsyncCallable = (node) => t.isFunction(node) && node.async;
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");

package/dist/domain/javascriptSemanticIr.js

@@ -11,6 +11,15 @@ export const DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS = {
     maxArgumentFlows: 100_000,
     maxCallReturnFlows: 100_000,
     maxClosureCaptures: 100_000,
+    maxPromiseOperations: 100_000,
+    maxEventOperations: 100_000,
+    maxTimerOperations: 100_000,
+    maxChildProcessOperations: 100_000,
+    maxConfigurationOperations: 100_000,
+    maxRequestOperations: 100_000,
+    maxBoundaryOperations: 100_000,
+    maxResourceOperations: 100_000,
+    maxObjectOperations: 100_000,
     maxFrontiers: 20_000,
     maxValueDepth: 16,
     maxUnionValues: 32,
@@ -23,7 +32,7 @@ export const semanticBinding = (ir, bindingId) => ir.bindings.find(({ bindingId:
 /** Fail-closed result when Babel cannot produce an inert syntax tree. */
 export const failedJavaScriptSemanticIr = () => ({
     schema: "JavaScriptSemanticIR",
-    schemaVersion: 3,
+    schemaVersion: 4,
     scopes: [],
     bindings: [],
     callables: [],
@@ -34,6 +43,17 @@ export const failedJavaScriptSemanticIr = () => ({
     callReturnFlows: [],
     callResultFlows: [],
     closureCaptures: [],
+    promiseOperations: [],
+    eventOperations: [],
+    timerOperations: [],
+    childProcessSpawns: [],
+    childProcessInteractions: [],
+    configurationOperations: [],
+    requestOperations: [],
+    boundaryOperations: [],
+    resourceOperations: [],
+    objectOperations: [],
+    functionFingerprints: [],
     frontiers: [],
     coverage: { status: "failed", omittedCount: null, limitsReached: [] },
     limitations: [

package/dist/domain/javascriptSemanticObjects.js

@@ -0,0 +1,115 @@
+import * as t from "@babel/types";
+import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { propertyName, range } from "./javascriptStaticAnalysisHelpers.js";
+/** Recover bounded static property reads, writes, spreads, and destructuring. */
+export const collectJavaScriptSemanticObjects = (program, state, callables) => {
+    const output = [];
+    const callableIds = new Set(callables.map(({ callableId }) => callableId));
+    const callableStack = [];
+    const context = { state, output };
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && callableIds.has(callableId))
+                callableStack.push(callableId);
+            const ownerCallableId = callableStack.at(-1) ?? null;
+            if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
+                collectMember(node, parent, ownerCallableId, context);
+            else if (t.isSpreadElement(node) &&
+                parent !== null &&
+                t.isObjectExpression(parent))
+                addObjectOperation({
+                    node,
+                    kind: "spread",
+                    ownerCallableId,
+                    objectBindingId: expressionBindingId(node.argument, state),
+                    targetBindingId: null,
+                    propertyName: null,
+                }, state, output);
+            else if (t.isVariableDeclarator(node) && t.isObjectPattern(node.id))
+                collectDestructuring(node, ownerCallableId, state, output);
+        },
+        exit: (node) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && callableStack.at(-1) === callableId)
+                callableStack.pop();
+        },
+    });
+    return output;
+};
+const collectMember = (node, parent, ownerCallableId, context) => {
+    const { state, output } = context;
+    const name = semanticStaticPropertyName(node.property, node.computed);
+    if (name.length === 0)
+        return;
+    const write = (t.isAssignmentExpression(parent) && parent.left === node) ||
+        (t.isUpdateExpression(parent) && parent.argument === node);
+    addObjectOperation({
+        node,
+        kind: write ? "write" : "read",
+        ownerCallableId,
+        objectBindingId: expressionBindingId(node.object, state),
+        targetBindingId: null,
+        propertyName: name,
+    }, state, output);
+};
+const collectDestructuring = (node, ownerCallableId, state, output) => {
+    if (!t.isObjectPattern(node.id))
+        return;
+    const objectBindingId = expressionBindingId(node.init, state);
+    for (const property of node.id.properties) {
+        if (!t.isObjectProperty(property))
+            continue;
+        const name = propertyName(property.key);
+        if (name.length === 0)
+            continue;
+        const target = bindingIdentifier(property.value);
+        addObjectOperation({
+            node: property,
+            kind: "destructure",
+            ownerCallableId,
+            objectBindingId,
+            targetBindingId: target === null
+                ? null
+                : (resolveSemanticBindingState(state, target, target.name)
+                    ?.bindingId ?? null),
+            propertyName: name,
+        }, state, output);
+    }
+};
+const addObjectOperation = (input, state, output) => {
+    if (output.length >= state.limits.maxObjectOperations) {
+        reachSemanticLimit(state, "maxObjectOperations");
+        return;
+    }
+    output.push({
+        objectOperationId: `object:${input.kind}:${String(input.node.start ?? -1)}:${String(input.node.end ?? -1)}`,
+        kind: input.kind,
+        location: range(input.node),
+        ownerCallableId: input.ownerCallableId,
+        objectBindingId: input.objectBindingId,
+        targetBindingId: input.targetBindingId,
+        propertyName: input.propertyName,
+        resolution: input.kind === "spread"
+            ? input.objectBindingId === null
+                ? "partial"
+                : "complete"
+            : input.objectBindingId === null ||
+                input.propertyName === null ||
+                (input.kind === "destructure" && input.targetBindingId === null)
+                ? "partial"
+                : "complete",
+    });
+};
+const expressionBindingId = (node, state) => t.isIdentifier(node)
+    ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
+    : null;
+const bindingIdentifier = (node) => {
+    if (t.isIdentifier(node))
+        return node;
+    if (t.isAssignmentPattern(node) && t.isIdentifier(node.left))
+        return node.left;
+    return null;
+};

package/dist/domain/javascriptSemanticPromises.js

@@ -0,0 +1,290 @@
+import * as t from "@babel/types";
+import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { compareCodePoints, range, sourceRangesEqual, } from "./javascriptStaticAnalysisHelpers.js";
+/** Recover explicit Promise construction, chaining, aggregation, and ownership. */
+export const collectJavaScriptSemanticPromises = (program, state, callables) => {
+    const candidates = collectCandidates(program, state, callables);
+    const candidateByNode = new WeakMap();
+    for (const candidate of candidates)
+        candidateByNode.set(candidate.node, candidate);
+    return candidates.map((candidate) => {
+        const ownership = promiseOwnership(candidate, candidateByNode, state, callables);
+        const sources = promiseSources(candidate, candidateByNode, state);
+        return {
+            promiseId: candidate.promiseId,
+            kind: candidate.kind,
+            method: candidate.method,
+            location: range(candidate.node),
+            ownerCallableId: candidate.ownerCallableId,
+            ...ownership,
+            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareCodePoints),
+            sourceResolution: sources.status,
+        };
+    });
+};
+const collectCandidates = (program, state, callables) => {
+    const output = [];
+    const admittedCallables = new Set(callables.map(({ callableId }) => callableId));
+    const callableStack = [];
+    const ancestors = [];
+    traverseJavaScriptAst(program, {
+        enter: (node) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && admittedCallables.has(callableId))
+                callableStack.push(callableId);
+            const details = promiseCandidateDetails(node, state);
+            if (details !== null) {
+                if (output.length >= state.limits.maxPromiseOperations)
+                    reachSemanticLimit(state, "maxPromiseOperations");
+                else
+                    output.push({
+                        node,
+                        ...details,
+                        promiseId: semanticPromiseId(details.kind, node),
+                        ownerCallableId: callableStack.at(-1) ?? null,
+                        ancestors: [...ancestors],
+                    });
+            }
+            ancestors.push(node);
+        },
+        exit: (node) => {
+            ancestors.pop();
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && callableStack.at(-1) === callableId)
+                callableStack.pop();
+        },
+    });
+    return output;
+};
+const promiseCandidateDetails = (node, state) => {
+    if (t.isNewExpression(node) &&
+        t.isIdentifier(node.callee, { name: "Promise" }) &&
+        isUnshadowedGlobalPromise(node.callee, state))
+        return { kind: "constructor", method: "new" };
+    if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+        const member = memberCallee(node);
+        if (member === null)
+            return null;
+        const method = semanticStaticPropertyName(member.property, member.computed);
+        if (t.isIdentifier(member.object, { name: "Promise" }) &&
+            isUnshadowedGlobalPromise(member.object, state)) {
+            if (method === "all" || method === "allSettled")
+                return { kind: "aggregate", method };
+            if (method === "resolve" || method === "reject")
+                return { kind: "static", method };
+        }
+        if (method === "then" || method === "catch" || method === "finally")
+            return { kind: "chain", method };
+    }
+    if (t.isAwaitExpression(node) && !isPromiseProducer(node.argument, state))
+        return { kind: "awaited-expression", method: "await" };
+    return null;
+};
+const isUnshadowedGlobalPromise = (node, state) => resolveSemanticBindingState(state, node, "Promise") === undefined &&
+    !semanticResolutionBlocked(state, node, "Promise");
+const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapExpression(node), state) !== null;
+const semanticPromiseId = (kind, node) => `promise:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
+const memberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
+    ? node.callee
+    : null;
+const promiseOwnership = (candidate, candidateByNode, state, callables) => {
+    if (candidate.kind === "awaited-expression")
+        return emptyOwnership("awaited");
+    const context = {
+        candidate,
+        candidateByNode,
+        state,
+        callables,
+    };
+    for (let index = candidate.ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = candidate.ancestors[index];
+        if (ancestor === undefined)
+            continue;
+        const ownership = ownershipAtAncestor(ancestor, context);
+        if (ownership === "boundary")
+            break;
+        if (ownership !== null)
+            return ownership;
+    }
+    return emptyOwnership("unknown");
+};
+const ownershipAtAncestor = (ancestor, context) => {
+    const { candidate, candidateByNode, state, callables } = context;
+    if (t.isAwaitExpression(ancestor))
+        return emptyOwnership("awaited");
+    const outer = candidateByNode.get(ancestor);
+    if (outer !== undefined &&
+        outer.ownerCallableId === candidate.ownerCallableId &&
+        outerConsumesCandidate(outer, candidate))
+        return outer.kind === "chain"
+            ? emptyOwnership("chained")
+            : emptyOwnership("aggregated");
+    const assigned = assignedPromiseBinding(ancestor, state);
+    if (assigned !== undefined)
+        return {
+            ownership: "assigned",
+            ownerBindingId: assigned,
+            returnSiteId: null,
+        };
+    if (t.isReturnStatement(ancestor))
+        return returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor), callables);
+    if (t.isExpressionStatement(ancestor))
+        return emptyOwnership("detached");
+    const callableId = semanticCallableIdForNode(ancestor);
+    if (callableId === null || callableId !== candidate.ownerCallableId)
+        return null;
+    return t.isArrowFunctionExpression(ancestor) &&
+        ancestor.body === candidate.node
+        ? returnedPromiseOwnership(candidate.ownerCallableId, range(candidate.node), callables)
+        : "boundary";
+};
+const assignedPromiseBinding = (ancestor, state) => {
+    if (t.isVariableDeclarator(ancestor) &&
+        ancestor.init !== null &&
+        t.isIdentifier(ancestor.id))
+        return (resolveSemanticBindingState(state, ancestor.id, ancestor.id.name)
+            ?.bindingId ?? null);
+    if (t.isAssignmentExpression(ancestor) && t.isIdentifier(ancestor.left))
+        return (resolveSemanticBindingState(state, ancestor.left, ancestor.left.name)
+            ?.bindingId ?? null);
+    return undefined;
+};
+const returnedPromiseOwnership = (callableId, location, callables) => ({
+    ownership: "returned",
+    ownerBindingId: null,
+    returnSiteId: matchingReturnSite(callableId, location, callables),
+});
+const outerConsumesCandidate = (outer, candidate) => {
+    if (outer.kind === "chain" &&
+        (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
+        const member = memberCallee(outer.node);
+        return member !== null && containsNode(member.object, candidate.node);
+    }
+    if (outer.kind === "aggregate" &&
+        (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
+        const input = outer.node.arguments[0];
+        return t.isNode(input) && containsNode(input, candidate.node);
+    }
+    return false;
+};
+const containsNode = (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;
+const emptyOwnership = (ownership) => ({
+    ownership,
+    ownerBindingId: null,
+    returnSiteId: null,
+});
+const matchingReturnSite = (callableId, location, callables) => callables
+    .find(({ callableId: candidate }) => candidate === callableId)
+    ?.returnSites.find(({ location: candidate }) => sourceRangesEqual(candidate, location))?.returnSiteId ?? null;
+const promiseSources = (candidate, candidateByNode, state) => {
+    if (candidate.kind === "chain") {
+        const member = t.isCallExpression(candidate.node) ||
+            t.isOptionalCallExpression(candidate.node)
+            ? memberCallee(candidate.node)
+            : null;
+        return member === null
+            ? unresolvedPromise()
+            : resolvePromiseExpression(member.object, promiseResolutionContext(candidate, candidateByNode, state));
+    }
+    if (candidate.kind === "aggregate")
+        return aggregateSources(candidate, candidateByNode, state);
+    if (candidate.kind === "awaited-expression")
+        return t.isAwaitExpression(candidate.node)
+            ? resolvePromiseExpression(candidate.node.argument, promiseResolutionContext(candidate, candidateByNode, state))
+            : unresolvedPromise();
+    return { promiseIds: [], status: "complete" };
+};
+const aggregateSources = (candidate, candidateByNode, state) => {
+    if (!t.isCallExpression(candidate.node) &&
+        !t.isOptionalCallExpression(candidate.node))
+        return unresolvedPromise();
+    const input = candidate.node.arguments[0];
+    if (!t.isArrayExpression(input))
+        return unresolvedPromise();
+    const resolutions = input.elements.map((element) => {
+        if (element === null)
+            return completePromise();
+        if (t.isSpreadElement(element))
+            return unresolvedPromise();
+        if (isObviouslyNonPromise(element))
+            return completePromise();
+        return resolvePromiseExpression(element, promiseResolutionContext(candidate, candidateByNode, state));
+    });
+    return combinePromiseResolutions(resolutions);
+};
+const resolvePromiseExpression = (rawNode, context) => {
+    const { current, candidateByNode, state, seenBindings, depth } = context;
+    if (depth >= state.limits.maxValueDepth)
+        return unresolvedPromise();
+    const node = unwrapExpression(rawNode);
+    const direct = candidateByNode.get(node);
+    if (direct !== undefined && direct.promiseId !== current.promiseId)
+        return { promiseIds: [direct.promiseId], status: "complete" };
+    if (!t.isIdentifier(node))
+        return unresolvedPromise();
+    const binding = resolveSemanticBindingState(state, node, node.name);
+    if (binding === undefined ||
+        binding.mutable ||
+        binding.initializers.length !== 1 ||
+        seenBindings.has(binding.bindingId))
+        return unresolvedPromise();
+    const initializer = binding.initializers[0];
+    if (initializer === undefined || initializer.projection.length > 0)
+        return unresolvedPromise();
+    const nestedSeen = new Set(seenBindings);
+    nestedSeen.add(binding.bindingId);
+    return resolvePromiseExpression(initializer.node, {
+        ...context,
+        seenBindings: nestedSeen,
+        depth: depth + 1,
+    });
+};
+const promiseResolutionContext = (current, candidateByNode, state) => ({
+    current,
+    candidateByNode,
+    state,
+    seenBindings: new Set(),
+    depth: 0,
+});
+const unwrapExpression = (node) => {
+    if (t.isParenthesizedExpression(node) ||
+        t.isTSAsExpression(node) ||
+        t.isTSSatisfiesExpression(node) ||
+        t.isTSNonNullExpression(node) ||
+        t.isTypeCastExpression(node))
+        return unwrapExpression(node.expression);
+    return node;
+};
+const combinePromiseResolutions = (resolutions) => ({
+    promiseIds: resolutions.flatMap(({ promiseIds }) => promiseIds),
+    status: resolutions.some(({ status }) => status === "unresolved")
+        ? resolutions.some(({ status }) => status === "complete")
+            ? "partial"
+            : "unresolved"
+        : resolutions.some(({ status }) => status === "partial")
+            ? "partial"
+            : "complete",
+});
+const completePromise = () => ({
+    promiseIds: [],
+    status: "complete",
+});
+const unresolvedPromise = () => ({
+    promiseIds: [],
+    status: "unresolved",
+});
+const isObviouslyNonPromise = (node) => t.isLiteral(node) ||
+    t.isObjectExpression(node) ||
+    t.isFunction(node) ||
+    t.isClassExpression(node);