rea-agents 2.3.0 → 2.5.0

package/dist/application/JavaScriptSemanticGraphBuilder.js

@@ -1,16 +1,25 @@
 import { createJavaScriptSemanticGraph, } from "../domain/javascriptSemanticGraph.js";
 import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, } from "../domain/javascriptSemanticGraphSchemas.js";
+import { sourceRangesEqual as rangesEqual } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { projectSemanticEvents, projectSemanticTimers, } from "./JavaScriptSemanticGraphAsyncProjection.js";
+import { projectSemanticChildProcesses } from "./JavaScriptSemanticGraphChildProcessProjection.js";
+import { projectSemanticBoundaries, projectSemanticConfiguration, projectSemanticRequests, } from "./JavaScriptSemanticGraphDataProjection.js";
+import { projectSemanticResources } from "./JavaScriptSemanticGraphResourceProjection.js";
+import { projectSemanticObjects } from "./JavaScriptSemanticGraphObjectProjection.js";
+import { projectSemanticValues } from "./JavaScriptSemanticGraphValueProjection.js";
 import { inferredSemanticEvidenceAt } from "./JavaScriptSemanticGraphEvidence.js";
-import { projectSemanticClosureCaptures, projectSemanticFrontiers, projectSemanticReturnValues, semanticRecoveryLimits, } from "./JavaScriptSemanticGraphFlowProjection.js";
-import { owningSemanticCallableNode, semanticFamilyStatus, semanticNodesWithinRange, semanticRangesEqual as rangesEqual, } from "./JavaScriptSemanticGraphProjection.js";
+import { projectSemanticFunctionFingerprints } from "./JavaScriptSemanticGraphFingerprintProjection.js";
+import { projectSemanticClosureCaptures, projectSemanticFrontiers, projectSemanticPromises, projectSemanticReturnValues, semanticRecoveryLimits, } from "./JavaScriptSemanticGraphFlowProjection.js";
+import { owningSemanticCallableNode, semanticFamilyStatus, semanticNodesWithinRange, } from "./JavaScriptSemanticGraphProjection.js";
 import { addSemanticFallbackRoot as addFallbackRoot, addSemanticGraphNode as addNode, addSemanticGraphRelation as addRelation, constructSemanticGraphNode as semanticNode, createSemanticGraphProjectionState as emptyState, MAX_APPLICATION_NODE_IDS_PER_SEMANTIC_NODE, MAX_SEMANTIC_GRAPH_NODES, MAX_SEMANTIC_GRAPH_RELATIONS, MAX_SEMANTIC_GRAPH_UNKNOWNS, } from "./JavaScriptSemanticGraphConstruction.js";
 /** Project bounded per-file semantic IR into an artifact-bound companion graph. */
 export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGraph, analysis, }) => {
     const state = emptyState(applicationGraph);
+    const fingerprints = [];
     for (const analyzed of analysis.files) {
         if (analyzed.semantic === null)
             continue;
-        projectFile(analyzed.file, analyzed.semantic.ir, state);
+        fingerprints.push(...projectFile(analyzed.file, analyzed.semantic.ir, state));
     }
     if (state.roots.size === 0)
         addFallbackRoot(rootArtifactSha256, state);
@@ -25,7 +34,7 @@ export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGr
         root_node_ids: [...state.roots],
         nodes: [...state.nodes.values()],
         relations: [...state.relations.values()],
-        fingerprints: [],
+        fingerprints,
         unknowns,
         coverage: {
             status: truncated ? "partial" : "unknown",
@@ -68,7 +77,15 @@ export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGr
         limitations: [
             "The semantic graph contains static syntax observations and conservative relationship candidates; it does not claim runtime execution.",
             "Local data flow does not claim control-flow-sensitive reaching definitions or arbitrary dynamic property resolution.",
-            "Function fingerprints and promise, event, process, request, boundary, timer, configuration, and resource extraction are not available in this graph version's current extractor coverage.",
+            "Promise ownership covers explicit unshadowed Promise construction, static factories, aggregation, chaining, and await syntax only.",
+            "Function fingerprints are bounded static candidates; equal digests can remain ambiguous and do not prove behavioral equivalence.",
+            "Event extraction covers EventEmitter-style literal registrations, removals, and dispatch candidates; dynamic names remain unknown.",
+            "Timer extraction covers global or node:timers scheduling and exact local-handle cancellation.",
+            "Child-process extraction covers asynchronous node:child_process creation, literal argv/env/stdio options, exit/error listeners, and kill signals.",
+            "Configuration extraction covers process.env, process.argv, node:fs reads, and direct logical defaults.",
+            "Request extraction covers fetch, WebSocket, node:http/node:https construction, direct option fields, and exact local response consumers.",
+            "Boundary extraction covers unshadowed JSON/global coercions plus parse and validation method candidates.",
+            "Resource extraction covers built-in filesystem/network acquisition and exact local close/destroy/end handles.",
             ...(truncated
                 ? [
                     "Semantic graph projection reached one or more explicit hard limits.",
@@ -86,7 +103,7 @@ const projectFile = (file, ir, state) => {
         functionNodeId: null,
     }, state));
     if (moduleNode === null)
-        return;
+        return [];
     state.roots.add(moduleNode.node_id);
     const callableNodes = new Map(ir.callables.flatMap((callable) => {
         const node = addNode(state, semanticNode(file, {
@@ -130,9 +147,20 @@ const projectFile = (file, ir, state) => {
         ])),
     };
     projectDefinitionsAndReferences(context);
+    projectSemanticValues(context);
+    projectSemanticObjects(context);
     projectCalls(context);
+    projectSemanticPromises(context);
+    projectSemanticEvents(context);
+    projectSemanticTimers(context);
+    projectSemanticChildProcesses(context);
+    projectSemanticConfiguration(context);
+    projectSemanticRequests(context);
+    projectSemanticBoundaries(context);
+    projectSemanticResources(context);
     projectSemanticClosureCaptures(context);
     projectSemanticFrontiers(context);
+    return projectSemanticFunctionFingerprints(file, ir, callableNodes);
 };
 const createReturnSiteNodes = (file, ir, callables, state) => {
     const result = new Map();

package/dist/application/JavaScriptSemanticGraphChildProcessProjection.js

@@ -0,0 +1,156 @@
+import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticCallSiteAt, } from "./JavaScriptSemanticGraphFlowProjection.js";
+/** Project child creation, argv/env/stdio, listeners, and signals. */
+export const projectSemanticChildProcesses = (context) => {
+    const processNodes = new Map(context.ir.childProcessSpawns.flatMap((spawn) => {
+        const node = addChildProcessNode(context, spawn);
+        return node === null ? [] : [[spawn.processId, node]];
+    }));
+    for (const spawn of context.ir.childProcessSpawns) {
+        const child = processNodes.get(spawn.processId);
+        if (child === undefined)
+            continue;
+        projectSpawn(context, spawn, child);
+    }
+    for (const interaction of context.ir.childProcessInteractions)
+        projectInteraction(context, interaction, processNodes);
+};
+const addChildProcessNode = (context, spawn) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "child-process",
+    roleKey: spawn.processId,
+    location: spawn.location,
+    label: spawn.command ?? spawn.method,
+    functionNodeId: spawn.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(spawn.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        argv_count: spawn.argvCount,
+        command: spawn.command,
+        environment_supplied: spawn.environmentSupplied,
+        method: spawn.method,
+        stdio_mode: spawn.stdioMode,
+    },
+}, context.state));
+const projectSpawn = (context, spawn, child) => {
+    const callSite = semanticCallSiteAt(context, spawn.location);
+    addSemanticGraphRelation(context.state, {
+        source: callSite,
+        target: child,
+        relation: "spawns",
+        resolution: spawn.resolution === "complete" ? "resolved" : "candidate",
+    });
+    if (spawn.argvCount !== null)
+        addSemanticGraphRelation(context.state, {
+            source: callSite,
+            target: child,
+            relation: "supplies-argv",
+            resolution: "resolved",
+            properties: { argument_count: spawn.argvCount },
+        });
+    if (spawn.environmentSupplied)
+        addSemanticGraphRelation(context.state, {
+            source: callSite,
+            target: child,
+            relation: "supplies-env",
+            resolution: "resolved",
+        });
+    const stdio = addStdioNode(context, spawn, child);
+    addSemanticGraphRelation(context.state, {
+        source: child,
+        target: stdio,
+        relation: "connects-stdio",
+        resolution: spawn.stdioMode === "dynamic" ? "candidate" : "resolved",
+    });
+    if (spawn.resolution !== "complete")
+        addChildUnknown({
+            context,
+            node: child,
+            location: spawn.location,
+            relationKinds: ["spawns"],
+            detail: `Static ${spawn.method} command remains unresolved.`,
+            candidateNodeIds: [],
+        });
+};
+const addStdioNode = (context, spawn, child) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "stdio",
+    roleKey: `stdio:${spawn.processId}`,
+    location: spawn.location,
+    label: spawn.stdioMode,
+    functionNodeId: child.function_node_id,
+    properties: { mode: spawn.stdioMode },
+}, context.state));
+const projectInteraction = (context, interaction, processNodes) => {
+    const children = interaction.linkedProcessIds.flatMap((identifier) => {
+        const child = processNodes.get(identifier);
+        return child === undefined ? [] : [child];
+    });
+    const effect = interaction.kind === "listener"
+        ? addChildListenerNode(context, interaction)
+        : addSignalNode(context, interaction);
+    for (const child of children)
+        addSemanticGraphRelation(context.state, {
+            source: interaction.kind === "listener" ? child : effect,
+            target: interaction.kind === "listener" ? effect : child,
+            relation: interaction.kind === "signal"
+                ? "forwards-signal"
+                : interaction.eventName === "exit"
+                    ? "listens-exit"
+                    : "listens-error",
+            resolution: interaction.resolution === "complete" ? "resolved" : "candidate",
+        });
+    if (interaction.resolution !== "complete")
+        addChildUnknown({
+            context,
+            node: effect,
+            location: interaction.location,
+            relationKinds: [
+                interaction.kind === "signal"
+                    ? "forwards-signal"
+                    : interaction.eventName === "exit"
+                        ? "listens-exit"
+                        : "listens-error",
+            ],
+            detail: `Static child ${interaction.method} ownership is ambiguous.`,
+            candidateNodeIds: children.map(({ node_id: identifier }) => identifier),
+        });
+};
+const addChildListenerNode = (context, interaction) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "listener",
+    roleKey: interaction.interactionId,
+    location: interaction.listenerLocation ?? interaction.location,
+    label: interaction.eventName,
+    functionNodeId: interaction.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(interaction.ownerCallableId)
+            ?.node_id ?? null),
+    properties: {
+        event_name: interaction.eventName,
+        method: interaction.method,
+    },
+}, context.state));
+const addSignalNode = (context, interaction) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "signal",
+    roleKey: interaction.interactionId,
+    location: interaction.location,
+    label: interaction.signalName,
+    functionNodeId: interaction.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(interaction.ownerCallableId)
+            ?.node_id ?? null),
+    properties: { signal_name: interaction.signalName },
+}, context.state));
+const addChildUnknown = (input) => {
+    const { context, node, location, relationKinds, detail, candidateNodeIds } = input;
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: node?.node_id ?? null,
+        family: "child-process",
+        relation_kinds: relationKinds,
+        reason: "ambiguous-target",
+        detail,
+        candidate_node_ids: candidateNodeIds,
+        evidence: unknownSemanticEvidence(context.file, location),
+    }));
+};

package/dist/application/JavaScriptSemanticGraphConstruction.js

@@ -32,7 +32,7 @@ export const constructSemanticGraphNode = (file, input, state) => createJavaScri
     function_node_id: input.functionNodeId,
     application_node_ids: matchingApplicationNodeIds(file, input, state),
     label: input.label,
-    properties: {},
+    properties: input.properties ?? {},
     evidence: observedSemanticEvidence(file, input.location),
 });
 /** Retain one canonical node unless the hard graph bound was reached. */
@@ -60,7 +60,7 @@ export const addSemanticGraphRelation = (state, input) => {
         target_node_id: input.target.node_id,
         relation: input.relation,
         resolution: input.resolution ?? "candidate",
-        properties: {},
+        properties: input.properties ?? {},
         evidence: input.evidence ?? inferredSemanticEvidence(input.source),
     });
     if (state.relations.has(value.relation_id))

package/dist/application/JavaScriptSemanticGraphDataProjection.js

@@ -0,0 +1,203 @@
+import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticCallSiteAt, } from "./JavaScriptSemanticGraphFlowProjection.js";
+/** Project environment, argv, file, default, and precedence candidates. */
+export const projectSemanticConfiguration = (context) => {
+    const configNodes = new Map(context.ir.configurationOperations.flatMap((operation) => {
+        const node = addConfigurationNode(context, operation);
+        return node === null ? [] : [[operation.configId, node]];
+    }));
+    for (const operation of context.ir.configurationOperations) {
+        const config = configNodes.get(operation.configId);
+        if (config === undefined)
+            continue;
+        const target = bindingOrOwner(context, operation.resultBindingId, operation.ownerCallableId);
+        addSemanticGraphRelation(context.state, {
+            source: config,
+            target,
+            relation: configurationRelation(operation),
+            resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+        });
+        if (operation.kind === "default" && operation.sourceConfigId !== null)
+            addSemanticGraphRelation(context.state, {
+                source: configNodes.get(operation.sourceConfigId),
+                target: config,
+                relation: "overrides",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        if (operation.resolution !== "complete")
+            addDataUnknown({
+                context,
+                node: config,
+                family: "configuration",
+                relationKinds: [
+                    configurationRelation(operation),
+                    ...(operation.kind === "default" ? ["overrides"] : []),
+                ],
+                location: operation.location,
+                detail: `Static ${operation.kind} configuration identity is partial.`,
+                candidateNodeIds: [],
+            });
+    }
+};
+const addConfigurationNode = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "config-source",
+    roleKey: operation.configId,
+    location: operation.location,
+    label: operation.key ?? operation.kind,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        key: operation.key,
+        source_kind: operation.kind,
+        value: operation.value,
+    },
+}, context.state));
+const configurationRelation = (operation) => operation.kind === "environment"
+    ? "reads-environment"
+    : operation.kind === "argv"
+        ? "reads-argv"
+        : operation.kind === "file"
+            ? "reads-config"
+            : "defaults";
+/** Project request construction, field provenance, and response consumers. */
+export const projectSemanticRequests = (context) => {
+    const requestNodes = new Map(context.ir.requestOperations.flatMap((operation) => {
+        const node = addRequestNode(context, operation);
+        return node === null ? [] : [[operation.requestId, node]];
+    }));
+    for (const operation of context.ir.requestOperations) {
+        const request = requestNodes.get(operation.requestId);
+        if (request === undefined)
+            continue;
+        if (operation.kind === "request")
+            projectRequestConstruction(context, operation, request);
+        else
+            projectResponseConsumer(context, operation, request);
+        if (operation.resolution !== "complete")
+            addDataUnknown({
+                context,
+                node: request,
+                family: "request",
+                relationKinds: operation.kind === "request"
+                    ? ["constructs-request", "supplies-request-field"]
+                    : ["consumed-by"],
+                location: operation.location,
+                detail: `Static ${operation.method} request resolution was ${operation.resolution}.`,
+                candidateNodeIds: operation.linkedRequestIds.flatMap((identifier) => {
+                    const candidate = requestNodes.get(identifier);
+                    return candidate === undefined ? [] : [candidate.node_id];
+                }),
+            });
+    }
+};
+const addRequestNode = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: operation.kind === "request" ? "request" : "response",
+    roleKey: operation.requestId,
+    location: operation.location,
+    label: operation.endpoint ?? operation.method,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        endpoint: operation.endpoint,
+        method: operation.method,
+        operation_kind: operation.kind,
+    },
+}, context.state));
+const projectRequestConstruction = (context, operation, request) => {
+    const callSite = semanticCallSiteAt(context, operation.location);
+    addSemanticGraphRelation(context.state, {
+        source: callSite,
+        target: request,
+        relation: "constructs-request",
+        resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+    });
+    for (const field of operation.fields)
+        addSemanticGraphRelation(context.state, {
+            source: field.sourceBindingId === null
+                ? callSite
+                : context.bindingNodes.get(field.sourceBindingId),
+            target: request,
+            relation: "supplies-request-field",
+            resolution: field.sourceBindingId === null ? "candidate" : "resolved",
+            properties: { field: field.name },
+        });
+};
+const projectResponseConsumer = (context, operation, response) => {
+    addSemanticGraphRelation(context.state, {
+        source: response,
+        target: semanticCallSiteAt(context, operation.location),
+        relation: "consumed-by",
+        resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+        properties: { method: operation.method },
+    });
+};
+/** Project parse, coercion, and validation consumers as static boundaries. */
+export const projectSemanticBoundaries = (context) => {
+    for (const operation of context.ir.boundaryOperations) {
+        const boundary = addBoundaryNode(context, operation);
+        if (boundary === null)
+            continue;
+        addSemanticGraphRelation(context.state, {
+            source: bindingOrOwner(context, operation.sourceBindingId, operation.ownerCallableId),
+            target: boundary,
+            relation: operation.kind === "parse"
+                ? "parses"
+                : operation.kind === "coerce"
+                    ? "coerces"
+                    : "validates",
+            resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+        });
+        if (operation.resolution !== "complete")
+            addDataUnknown({
+                context,
+                node: boundary,
+                family: "boundary",
+                relationKinds: [
+                    operation.kind === "parse"
+                        ? "parses"
+                        : operation.kind === "coerce"
+                            ? "coerces"
+                            : "validates",
+                ],
+                location: operation.location,
+                detail: `Static ${operation.method} boundary kind is a candidate.`,
+                candidateNodeIds: [],
+            });
+    }
+};
+const addBoundaryNode = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "boundary",
+    roleKey: operation.boundaryId,
+    location: operation.location,
+    label: operation.method,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        boundary_kind: operation.kind,
+        method: operation.method,
+    },
+}, context.state));
+const bindingOrOwner = (context, bindingId, callableId) => (bindingId === null ? undefined : context.bindingNodes.get(bindingId)) ??
+    (callableId === null
+        ? context.moduleNode
+        : (context.callableNodes.get(callableId) ?? context.moduleNode));
+const addDataUnknown = (input) => {
+    const { context, node, family, relationKinds, location, detail, candidateNodeIds, } = input;
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: node.node_id,
+        family,
+        relation_kinds: relationKinds,
+        reason: "ambiguous-target",
+        detail,
+        candidate_node_ids: candidateNodeIds,
+        evidence: unknownSemanticEvidence(context.file, location),
+    }));
+};

package/dist/application/JavaScriptSemanticGraphFingerprintProjection.js

@@ -0,0 +1,25 @@
+import { createJavaScriptSemanticFingerprint, } from "../domain/javascriptSemanticGraph.js";
+import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+/** Bind domain fingerprint components to exact semantic function nodes. */
+export const projectSemanticFunctionFingerprints = (file, ir, callableNodes) => ir.functionFingerprints.flatMap((fingerprint) => {
+    const callable = callableNodes.get(fingerprint.callableId);
+    if (callable === undefined)
+        return [];
+    return [
+        createJavaScriptSemanticFingerprint({
+            function_node_id: callable.node_id,
+            algorithm: "rea.javascript-semantic-function/v1",
+            status: fingerprint.status,
+            components: {
+                parameter_arity: fingerprint.components.parameterArity,
+                normalized_ast_sha256: fingerprint.components.normalizedAstSha256,
+                control_flow_sha256: fingerprint.components.controlFlowSha256,
+                relation_shape_sha256: fingerprint.components.relationShapeSha256,
+                literal_set_sha256: fingerprint.components.literalSetSha256,
+                effects: fingerprint.components.effects,
+            },
+            limitations: fingerprint.limitations,
+            evidence: observedSemanticEvidence(file, callable.identity.source_range),
+        }),
+    ];
+});

package/dist/application/JavaScriptSemanticGraphFlowProjection.js

@@ -1,7 +1,134 @@
 import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
-import { addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { sourceRangesEqual } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
 import { inferredSemanticEvidenceAt, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticNodesWithinRange } from "./JavaScriptSemanticGraphProjection.js";
+/** Find the retained call-site node at one exact semantic source range. */
+export const semanticCallSiteAt = (context, location) => {
+    const call = context.ir.callSites.find(({ location: candidate }) => sourceRangesEqual(candidate, location));
+    return call === undefined
+        ? undefined
+        : context.callSiteNodes.get(call.callSiteId);
+};
+/** Project explicit static Promise/task ownership without runtime claims. */
+export const projectSemanticPromises = (context) => {
+    const promiseNodes = new Map(context.ir.promiseOperations.flatMap((operation) => {
+        const owner = operation.ownerCallableId === null
+            ? undefined
+            : context.callableNodes.get(operation.ownerCallableId);
+        const node = addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+            kind: operation.kind === "awaited-expression" ? "task" : "promise",
+            roleKey: operation.promiseId,
+            location: operation.location,
+            label: promiseLabel(operation),
+            functionNodeId: owner?.node_id ?? null,
+            properties: {
+                method: operation.method,
+                operation_kind: operation.kind,
+                ownership: operation.ownership,
+                source_resolution: operation.sourceResolution,
+            },
+        }, context.state));
+        return node === null ? [] : [[operation.promiseId, node]];
+    }));
+    for (const operation of context.ir.promiseOperations) {
+        const promise = promiseNodes.get(operation.promiseId);
+        if (promise === undefined)
+            continue;
+        projectPromiseCreation(context, operation, promise);
+        projectPromiseSources(context, operation, promise, promiseNodes);
+        projectPromiseOwnership(context, operation, promise);
+        if (operation.sourceResolution !== "complete" &&
+            ["chain", "aggregate", "awaited-expression"].includes(operation.kind))
+            addPromiseUnknown(context, operation, promise, promiseNodes);
+    }
+};
+const promiseLabel = (operation) => operation.kind === "awaited-expression"
+    ? "awaited expression"
+    : `Promise.${operation.method}`;
+const projectPromiseCreation = (context, operation, promise) => {
+    if (operation.kind === "awaited-expression")
+        return;
+    addSemanticGraphRelation(context.state, {
+        source: semanticCallSiteAt(context, operation.location),
+        target: promise,
+        relation: "creates-promise",
+        resolution: operation.kind === "chain" || operation.sourceResolution !== "complete"
+            ? "candidate"
+            : "resolved",
+    });
+};
+const projectPromiseSources = (context, operation, promise, promiseNodes) => {
+    for (const sourceId of operation.sourcePromiseIds) {
+        const source = promiseNodes.get(sourceId);
+        if (operation.kind === "aggregate")
+            addSemanticGraphRelation(context.state, {
+                source: promise,
+                target: source,
+                relation: "aggregates",
+                resolution: operation.sourceResolution === "complete" ? "resolved" : "candidate",
+            });
+        else
+            addSemanticGraphRelation(context.state, {
+                source,
+                target: promise,
+                relation: "chains",
+                resolution: operation.sourceResolution === "complete" ? "resolved" : "candidate",
+            });
+    }
+};
+const projectPromiseOwnership = (context, operation, promise) => {
+    const owner = operation.ownerCallableId === null
+        ? context.moduleNode
+        : context.callableNodes.get(operation.ownerCallableId);
+    if (operation.ownership === "awaited")
+        addSemanticGraphRelation(context.state, {
+            source: owner,
+            target: promise,
+            relation: "awaits",
+            resolution: "resolved",
+        });
+    else if (operation.ownership === "assigned")
+        addSemanticGraphRelation(context.state, {
+            source: operation.ownerBindingId === null
+                ? undefined
+                : context.bindingNodes.get(operation.ownerBindingId),
+            target: promise,
+            relation: "owns",
+            resolution: "resolved",
+        });
+    else if (operation.ownership === "returned")
+        addSemanticGraphRelation(context.state, {
+            source: operation.returnSiteId === null
+                ? undefined
+                : context.returnSiteNodes.get(operation.returnSiteId),
+            target: promise,
+            relation: "returns-task",
+            resolution: "resolved",
+        });
+    else if (operation.ownership === "detached")
+        addSemanticGraphRelation(context.state, {
+            source: owner,
+            target: promise,
+            relation: "detaches-task",
+            resolution: "resolved",
+        });
+};
+const addPromiseUnknown = (context, operation, promise, promiseNodes) => {
+    const relation = operation.kind === "aggregate" ? "aggregates" : "chains";
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: promise.node_id,
+        family: "promise-ownership",
+        relation_kinds: [relation],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.method} source resolution was ${operation.sourceResolution}.`,
+        candidate_node_ids: operation.sourcePromiseIds.flatMap((identifier) => {
+            const candidate = promiseNodes.get(identifier);
+            return candidate === undefined ? [] : [candidate.node_id];
+        }),
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }));
+};
 /** Link direct return expressions to their retained semantic references. */
 export const projectSemanticReturnValues = (context) => {
     for (const callable of context.ir.callables)
@@ -14,18 +141,12 @@ export const projectSemanticReturnValues = (context) => {
                     target: returnNode,
                     relation: "aliases",
                     resolution: site.identityReferenceLocation !== null &&
-                        rangesEqual(reference.identity.source_range, site.identityReferenceLocation)
+                        sourceRangesEqual(reference.identity.source_range, site.identityReferenceLocation)
                         ? "resolved"
                         : "candidate",
                 });
         }
 };
-const rangesEqual = (left, right) => left !== null &&
-    right !== null &&
-    left.start.line === right.start.line &&
-    left.start.column === right.start.column &&
-    left.end.line === right.end.line &&
-    left.end.column === right.end.column;
 /** Link each captured binding to the callable at the exact reference site. */
 export const projectSemanticClosureCaptures = (context) => {
     for (const capture of context.ir.closureCaptures)