rea-agents 2.4.0 → 2.5.0

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)

package/dist/application/JavaScriptSemanticGraphObjectProjection.js

@@ -0,0 +1,81 @@
+import { createJavaScriptSemanticGraphUnknown } from "../domain/javascriptSemanticGraph.js";
+import { addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, constructSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
+/** Project static object reads, writes, spreads, and destructuring. */
+export const projectSemanticObjects = (context) => {
+    for (const operation of context.ir.objectOperations) {
+        const occurrence = addObjectOccurrence(context, operation);
+        const slot = operation.objectBindingId === null || operation.propertyName === null
+            ? null
+            : semanticPropertySlot(context, operation.objectBindingId, operation.propertyName);
+        if (operation.kind === "read")
+            addSemanticGraphRelation(context.state, {
+                source: slot,
+                target: occurrence,
+                relation: "reads-property",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else if (operation.kind === "write")
+            addSemanticGraphRelation(context.state, {
+                source: occurrence,
+                target: slot,
+                relation: "writes-property",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else if (operation.kind === "destructure")
+            addSemanticGraphRelation(context.state, {
+                source: slot,
+                target: operation.targetBindingId === null
+                    ? undefined
+                    : context.bindingNodes.get(operation.targetBindingId),
+                relation: "destructures",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        else
+            addSemanticGraphRelation(context.state, {
+                source: operation.objectBindingId === null
+                    ? undefined
+                    : context.bindingNodes.get(operation.objectBindingId),
+                target: occurrence,
+                relation: "spreads",
+                resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+            });
+        if (operation.resolution !== "complete")
+            addObjectUnknown(context, operation, slot ?? occurrence);
+    }
+};
+const addObjectOccurrence = (context, operation) => addSemanticGraphNode(context.state, constructSemanticGraphNode(context.file, {
+    kind: "expression",
+    roleKey: operation.objectOperationId,
+    location: operation.location,
+    label: operation.propertyName === null
+        ? operation.kind
+        : `${operation.kind}:${operation.propertyName}`,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        operation_kind: operation.kind,
+        property_name: operation.propertyName,
+    },
+}, context.state));
+const addObjectUnknown = (context, operation, node) => {
+    const relation = operation.kind === "read"
+        ? "reads-property"
+        : operation.kind === "write"
+            ? "writes-property"
+            : operation.kind === "spread"
+                ? "spreads"
+                : "destructures";
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: node?.node_id ?? null,
+        family: "object-flow",
+        relation_kinds: [relation],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.kind} object identity is partial.`,
+        candidate_node_ids: [],
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }));
+};

package/dist/application/JavaScriptSemanticGraphProjection.js

@@ -15,18 +15,25 @@ export const semanticNodesWithinRange = (nodes, range) => nodes.filter((node) =>
     contains(range, node.identity.source_range));
 /** Report extractor support without treating missing families as absence. */
 export const semanticFamilyStatus = (family, analysis, truncated) => {
-    if (!["call-flow", "closure", "data-flow", "object-flow"].includes(family))
+    if (![
+        "call-flow",
+        "boundary",
+        "child-process",
+        "closure",
+        "configuration",
+        "data-flow",
+        "event",
+        "object-flow",
+        "promise-ownership",
+        "request",
+        "resource-lifecycle",
+        "timer",
+    ].includes(family))
         return "unsupported";
     if (truncated)
         return "unknown";
     return analysis.truncated_scopes === 0 ? "partial" : "unknown";
 };
-/** Compare two exact semantic source ranges. */
-export const semanticRangesEqual = (left, right) => left !== 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;
 const contains = (outer, inner) => pointCompare(outer.start, inner.start) <= 0 &&
     pointCompare(outer.end, inner.end) >= 0;
 const pointCompare = (left, right) => left.line - right.line || left.column - right.column;