reverseport 0.0.0-stage → 1.2.0

package/dist/application/javascript/JavaScriptSemanticGraphFingerprintProjection.js

@@ -0,0 +1,25 @@
+import { createJavaScriptSemanticFingerprint, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+/** Bind domain fingerprint components to exact semantic function nodes. */
+export const projectSemanticFunctionFingerprints = (file, ir, callableNodes, evidenceContexts) => 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",
+            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),
+        }, evidenceContexts),
+    ];
+});

package/dist/application/javascript/JavaScriptSemanticGraphFlowProjection.js

@@ -0,0 +1,183 @@
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { sourceRangesEqual } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { inferredSemanticEvidenceAt, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
+/** 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 = retainSemanticGraphNode(context.state, 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,
+            },
+        });
+        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: context.callSiteAt(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),
+    }, context.state.evidenceContexts));
+};
+/** Link direct return expressions to their retained semantic references. */
+export const projectSemanticReturnValues = (context) => {
+    for (const callable of context.ir.callables)
+        for (const site of callable.returnSites) {
+            const returnNode = context.returnSiteNodes.get(site.returnSiteId);
+            const references = context.referenceNodesWithin(site.location);
+            for (const reference of references)
+                addSemanticGraphRelation(context.state, {
+                    source: reference,
+                    target: returnNode,
+                    relation: "aliases",
+                    resolution: site.identityReferenceLocation !== null &&
+                        sourceRangesEqual(reference.identity.source_range, site.identityReferenceLocation)
+                        ? "resolved"
+                        : "candidate",
+                });
+        }
+};
+/** Link each captured binding to the callable at the exact reference site. */
+export const projectSemanticClosureCaptures = (context) => {
+    for (const capture of context.ir.closureCaptures)
+        addSemanticGraphRelation(context.state, {
+            source: context.bindingNodes.get(capture.bindingId),
+            target: context.callableNodes.get(capture.callableId),
+            relation: "captures",
+            resolution: "resolved",
+            evidence: inferredSemanticEvidenceAt(context.file, capture.referenceLocation),
+        });
+};
+/** Retain bounded unresolved dynamic-call, dynamic-property and dynamic-scope frontiers. */
+export function* projectSemanticFrontiers(context) {
+    for (const [index, frontier] of context.ir.frontiers.entries()) {
+        if (index % 64 === 0)
+            yield;
+        // Dynamic environments leave identifier reads and writes unresolved.
+        const family = frontier.kind === "dynamic-call"
+            ? "call-flow"
+            : frontier.kind === "dynamic-scope"
+                ? "data-flow"
+                : "object-flow";
+        const relationKinds = frontier.kind === "dynamic-call"
+            ? ["calls"]
+            : frontier.kind === "dynamic-scope"
+                ? ["reads", "writes"]
+                : ["reads-property", "writes-property"];
+        const unknown = createJavaScriptSemanticGraphUnknown({
+            node_id: frontier.callableId === null
+                ? context.moduleNode.node_id
+                : (context.callableNodes.get(frontier.callableId)?.node_id ??
+                    context.moduleNode.node_id),
+            family,
+            relation_kinds: [...relationKinds],
+            reason: frontier.kind,
+            detail: frontier.reason,
+            candidate_node_ids: [],
+            evidence: unknownSemanticEvidence(context.file, frontier.location),
+        }, context.state.evidenceContexts);
+        addSemanticGraphUnknown(context.state, unknown);
+    }
+}

package/dist/application/javascript/JavaScriptSemanticGraphObjectProjection.js

@@ -0,0 +1,112 @@
+import { semanticSlotAtPath, semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
+/** Project static object reads, writes, spreads, and destructuring. */
+export function* projectSemanticObjects(context) {
+    const values = new Map(context.ir.bindings.map((binding) => [binding.bindingId, binding.value]));
+    for (const [index, operation] of context.ir.objectOperations.entries()) {
+        if (index % 64 === 0)
+            yield;
+        const occurrence = addObjectOccurrence(context, operation);
+        const target = objectTarget(context, values, operation);
+        const ends = objectRelationEnds(context, operation, occurrence, target);
+        const resolved = operation.resolution === "complete" &&
+            (operation.kind === "write"
+                ? target.receiverResolved
+                : target.presence === "present");
+        addSemanticGraphRelation(context.state, {
+            ...ends,
+            relation: OBJECT_RELATIONS[operation.kind],
+            resolution: resolved ? "resolved" : "candidate",
+        });
+        if (!resolved)
+            addObjectUnknown(context, operation, target.slot ?? occurrence, target);
+    }
+}
+const OBJECT_RELATIONS = {
+    read: "reads-property",
+    write: "writes-property",
+    destructure: "destructures",
+    spread: "spreads",
+};
+const objectTarget = (context, values, operation) => {
+    const binding = operation.objectBindingId === null
+        ? undefined
+        : context.bindingNodes.get(operation.objectBindingId);
+    const value = operation.objectBindingId === null
+        ? undefined
+        : values.get(operation.objectBindingId);
+    if (operation.objectBindingId === null ||
+        operation.propertyPath === null ||
+        value === undefined)
+        return {
+            objectNode: binding,
+            slot: null,
+            presence: "unknown-coverage",
+            receiverResolved: false,
+        };
+    const fact = semanticSlotAtPath(value, operation.propertyPath);
+    if (operation.propertyPath.length === 0)
+        return {
+            objectNode: binding,
+            slot: null,
+            presence: fact.presence,
+            receiverResolved: semanticContainer(value) !== null,
+        };
+    const slot = semanticPropertySlot(context, operation.objectBindingId, operation.propertyPath, fact);
+    const receiver = semanticSlotAtPath(value, operation.propertyPath.slice(0, -1));
+    return {
+        objectNode: slot,
+        slot,
+        presence: fact.presence,
+        receiverResolved: receiver.presence === "present" &&
+            semanticContainer(receiver.value) !== null,
+    };
+};
+const objectRelationEnds = (context, operation, occurrence, target) => {
+    switch (operation.kind) {
+        case "read":
+            return { source: target.slot, target: occurrence };
+        case "write":
+            return { source: occurrence, target: target.slot };
+        case "destructure":
+            return {
+                source: target.slot,
+                target: operation.targetBindingId === null
+                    ? undefined
+                    : context.bindingNodes.get(operation.targetBindingId),
+            };
+        case "spread":
+            return { source: target.objectNode, target: occurrence };
+    }
+};
+const addObjectOccurrence = (context, operation) => retainSemanticGraphNode(context.state, context.file, {
+    kind: "expression",
+    roleKey: operation.objectOperationId,
+    location: operation.location,
+    label: operation.propertyPath === null
+        ? operation.kind
+        : `${operation.kind}:${semanticPropertyPointer(operation.propertyPath)}`,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: {
+        operation_kind: operation.kind,
+        property_path: operation.propertyPath === null ? null : [...operation.propertyPath],
+    },
+});
+const addObjectUnknown = (context, operation, node, target) => {
+    const relation = OBJECT_RELATIONS[operation.kind];
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: node?.node_id ?? null,
+        family: "object-flow",
+        relation_kinds: [relation],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.kind} property ${operation.propertyPath === null ? "path is unresolved" : semanticPropertyPointer(operation.propertyPath)} has ${target.presence} presence; its receiver is ${target.receiverResolved ? "a retained container" : "unresolved or not a retained container"}; object identity is ${operation.resolution}.`,
+        candidate_node_ids: [],
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }, context.state.evidenceContexts));
+};

package/dist/application/javascript/JavaScriptSemanticGraphProjection.js

@@ -0,0 +1,144 @@
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
+import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
+/** Index one immutable file IR; read retained callable membership at query time. */
+export const createSemanticCallableOwnerLookup = (ir, nodes) => {
+    const entries = ir.callables
+        .map((callable, order) => ({
+        callableId: callable.callableId,
+        range: callable.location,
+        order,
+        priority: positionKey(callable.location),
+    }))
+        .sort((left, right) => pointCompare(left.range.start, right.range.start) ||
+        left.order - right.order);
+    const tree = buildSourceIntervalTree(entries, 0, entries.length);
+    return (location) => {
+        if (location === null || tree === null || nodes.size === 0)
+            return undefined;
+        const pending = [tree];
+        let best;
+        let result;
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (current === undefined ||
+                pointCompare(current.minimumStart, location.start) > 0 ||
+                pointCompare(current.maximumEnd, location.end) < 0)
+                continue;
+            const candidate = current.entry;
+            if (contains(candidate.range, location)) {
+                const node = nodes.get(candidate.callableId);
+                const rank = best === undefined
+                    ? 1
+                    : compareUnicodeCodePoints(candidate.priority, best.priority) ||
+                        best.order - candidate.order;
+                if (node !== undefined && rank > 0) {
+                    best = candidate;
+                    result = node;
+                }
+            }
+            if (current.left !== null)
+                pending.push(current.left);
+            if (current.right !== null)
+                pending.push(current.right);
+        }
+        return result;
+    };
+};
+const buildSourceIntervalTree = (entries, start, end) => {
+    if (start >= end)
+        return null;
+    const middle = Math.floor((start + end) / 2);
+    const entry = entries[middle];
+    if (entry === undefined)
+        return null;
+    // This recursion follows a balanced index, not the producer's nesting depth.
+    const left = buildSourceIntervalTree(entries, start, middle);
+    const right = buildSourceIntervalTree(entries, middle + 1, end);
+    let minimumEnd = entry.range.end;
+    let maximumEnd = entry.range.end;
+    for (const child of [left, right]) {
+        if (child !== null && pointCompare(child.minimumEnd, minimumEnd) < 0)
+            minimumEnd = child.minimumEnd;
+        if (child !== null && pointCompare(child.maximumEnd, maximumEnd) > 0)
+            maximumEnd = child.maximumEnd;
+    }
+    return {
+        entry,
+        minimumStart: left?.minimumStart ?? entry.range.start,
+        maximumStart: right?.maximumStart ?? entry.range.start,
+        minimumEnd,
+        maximumEnd,
+        left,
+        right,
+    };
+};
+/** Index an immutable node list; return contained ranges in producer order. */
+export const createSemanticNodeRangeLookup = (nodes) => {
+    const entries = nodes
+        .flatMap((node, order) => {
+        const range = node.identity.source_range;
+        return range === null ? [] : [{ node, range, order }];
+    })
+        .sort((left, right) => pointCompare(left.range.start, right.range.start) ||
+        left.order - right.order);
+    const tree = buildSourceIntervalTree(entries, 0, entries.length);
+    return (range) => {
+        if (tree === null)
+            return [];
+        const pending = [tree];
+        const matches = [];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (current === undefined ||
+                pointCompare(current.maximumStart, range.start) < 0 ||
+                pointCompare(current.minimumEnd, range.end) > 0)
+                continue;
+            if (contains(range, current.entry.range))
+                matches.push(current.entry);
+            if (current.left !== null)
+                pending.push(current.left);
+            if (current.right !== null)
+                pending.push(current.right);
+        }
+        return matches
+            .sort((left, right) => left.order - right.order)
+            .map(({ node }) => node);
+    };
+};
+/** Index exact call ranges, preserving the first producer occurrence. */
+export const createSemanticCallSiteLookup = (ir, nodes) => {
+    const identifiers = new Map();
+    for (const call of ir.callSites) {
+        const key = rangeKey(call.location);
+        if (!identifiers.has(key))
+            identifiers.set(key, call.callSiteId);
+    }
+    return (range) => {
+        const identifier = identifiers.get(rangeKey(range));
+        return identifier === undefined ? undefined : nodes.get(identifier);
+    };
+};
+const rangeKey = (range) => `${range.start.line}:${range.start.column}-${range.end.line}:${range.end.column}`;
+/** Report extractor support without treating missing families as absence. */
+export const semanticFamilyStatus = (family) => {
+    if (![
+        "call-flow",
+        "boundary",
+        "child-process",
+        "closure",
+        "configuration",
+        "data-flow",
+        "event",
+        "object-flow",
+        "promise-ownership",
+        "request",
+        "resource-lifecycle",
+        "timer",
+    ].includes(family))
+        return "unsupported";
+    return "partial";
+};
+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;
+const positionKey = (range) => `${String(range.start.line).padStart(12, "0")}:${String(range.start.column).padStart(12, "0")}`;

package/dist/application/javascript/JavaScriptSemanticGraphResourceProjection.js

@@ -0,0 +1,58 @@
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+/** Project built-in resource acquisition and exact local release handles. */
+export const projectSemanticResources = (context) => {
+    const resourceNodes = new Map(context.ir.resourceOperations.flatMap((operation) => {
+        if (operation.kind !== "acquire")
+            return [];
+        const node = addResourceNode(context, operation);
+        return node === null ? [] : [[operation.resourceId, node]];
+    }));
+    for (const operation of context.ir.resourceOperations)
+        if (operation.kind === "acquire")
+            addSemanticGraphRelation(context.state, {
+                source: context.callSiteAt(operation.location),
+                target: resourceNodes.get(operation.resourceId),
+                relation: "acquires",
+                resolution: "resolved",
+            });
+        else
+            projectRelease(context, operation, resourceNodes);
+};
+const addResourceNode = (context, operation) => retainSemanticGraphNode(context.state, context.file, {
+    kind: "resource",
+    roleKey: operation.resourceId,
+    location: operation.location,
+    label: operation.method,
+    functionNodeId: operation.ownerCallableId === null
+        ? null
+        : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
+            null),
+    properties: { method: operation.method },
+});
+const projectRelease = (context, operation, resourceNodes) => {
+    const callSite = context.callSiteAt(operation.location);
+    const resources = operation.linkedResourceIds.flatMap((identifier) => {
+        const resource = resourceNodes.get(identifier);
+        return resource === undefined ? [] : [resource];
+    });
+    for (const resource of resources)
+        addSemanticGraphRelation(context.state, {
+            source: callSite,
+            target: resource,
+            relation: "releases",
+            resolution: operation.resolution === "complete" ? "resolved" : "candidate",
+        });
+    if (operation.resolution === "complete")
+        return;
+    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        node_id: callSite?.node_id ?? null,
+        family: "resource-lifecycle",
+        relation_kinds: ["releases"],
+        reason: "ambiguous-target",
+        detail: `Static ${operation.method} resource ownership is ambiguous.`,
+        candidate_node_ids: resources.map(({ node_id: identifier }) => identifier),
+        evidence: unknownSemanticEvidence(context.file, operation.location),
+    }, context.state.evidenceContexts));
+};

package/dist/application/javascript/JavaScriptSemanticGraphValueProjection.js

@@ -0,0 +1,136 @@
+import { semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
+import { digestCanonicalValue } from "../../domain/canonicalDigest.js";
+import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
+import { observedSemanticEvidence, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
+/** Project bounded literal values and object slots for exact query seeds. */
+export const projectSemanticValues = (context) => {
+    for (const binding of context.ir.bindings) {
+        const bindingNode = context.bindingNodes.get(binding.bindingId);
+        if (bindingNode === undefined)
+            continue;
+        projectValue({
+            context,
+            binding,
+            value: binding.value,
+            target: bindingNode,
+            path: [],
+        });
+    }
+};
+const projectValue = (input) => {
+    const { context, binding, value, target, path } = input;
+    const role = path.length === 0 ? "binding" : `property:${semanticPropertyPointer(path)}`;
+    if (target === null)
+        return;
+    if (value.status === "literal") {
+        const literal = addLiteralNode(context, binding, value.value, role);
+        addSemanticGraphRelation(context.state, {
+            source: literal,
+            target,
+            relation: "defines",
+            resolution: "resolved",
+        });
+    }
+    else if (value.status === "union")
+        for (const primitive of value.values) {
+            const literal = addLiteralNode(context, binding, primitive, role);
+            addSemanticGraphRelation(context.state, {
+                source: literal,
+                target,
+                relation: "defines",
+                resolution: "candidate",
+            });
+        }
+    else if (value.status === "object" || value.status === "array") {
+        const container = semanticContainer(value);
+        for (const property of container.slots) {
+            const propertyPath = [...path, property.name];
+            const slot = semanticPropertySlot(context, binding.bindingId, propertyPath, property);
+            if (property.presence === "absent")
+                continue;
+            addSemanticGraphRelation(context.state, {
+                source: target,
+                target: slot,
+                relation: "writes-property",
+                resolution: property.presence === "present" ? "resolved" : "candidate",
+            });
+            if (property.presence === "present")
+                projectValue({
+                    context,
+                    binding,
+                    value: property.value,
+                    target: slot,
+                    path: propertyPath,
+                });
+        }
+        if (container.coverage.status === "partial")
+            addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+                node_id: target.node_id,
+                family: "object-flow",
+                relation_kinds: ["writes-property"],
+                reason: "ambiguous-target",
+                detail: `Initializer container has unknown ${value.status === "object" ? "properties" : "items"}${container.coverage.omitted === null ? " with an unknown omitted count" : `; ${container.coverage.omitted} omitted`}.`,
+                candidate_node_ids: [target.node_id],
+                evidence: unknownSemanticEvidence(context.file, binding.definitions[0]?.location ?? null),
+            }, context.state.evidenceContexts));
+    }
+    else if (value.status === "unknown" ||
+        value.status === "ambiguous" ||
+        value.status === "cycle") {
+        const location = binding.definitions[0]?.location ?? null;
+        const evidence = observedSemanticEvidence(context.file, location);
+        addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+            node_id: target.node_id,
+            family: "data-flow",
+            relation_kinds: ["defines"],
+            reason: value.resourceLimit === undefined
+                ? "unknown-value"
+                : "resource-limit",
+            detail: `${value.reason} Unknown value at ${role}.`,
+            candidate_node_ids: [target.node_id],
+            evidence: {
+                ...evidence,
+                authority: "unknown",
+                state: "unknown",
+                confidence: "unknown",
+                limitations: [value.reason],
+            },
+        }, context.state.evidenceContexts));
+    }
+};
+const addLiteralNode = (context, binding, value, role) => {
+    const encodedValue = JSON.stringify(value);
+    const valueDigest = `value-sha256:${digestCanonicalValue(value, "Semantic literal")}`;
+    const valueKey = encodedValue.length <= valueDigest.length ? encodedValue : valueDigest;
+    const stringLabel = "string literal";
+    return retainSemanticGraphNode(context.state, context.file, {
+        kind: "literal",
+        // Identity needs an exact value commitment, not another payload copy.
+        // Keep the complete literal in properties for queries and Evidence export.
+        roleKey: `literal:${binding.bindingId}:${role}:${valueKey}`,
+        location: binding.definitions[0]?.location ?? null,
+        label: typeof value === "string" && encodedValue.length > stringLabel.length
+            ? stringLabel
+            : encodedValue,
+        functionNodeId: context.bindingNodes.get(binding.bindingId)?.function_node_id ?? null,
+        properties: { value },
+    });
+};
+/** Create one canonical slot for a root binding and exact static property path. */
+export const semanticPropertySlot = (context, objectBindingId, path, fact) => retainSemanticGraphNode(context.state, context.file, {
+    kind: "property-slot",
+    roleKey: `property:${JSON.stringify([objectBindingId, path])}`,
+    location: null,
+    label: fact.name,
+    functionNodeId: context.bindingNodes.get(objectBindingId)?.function_node_id ?? null,
+    properties: {
+        name: fact.name,
+        property_path: [...path],
+        property_pointer: semanticPropertyPointer(path),
+        object_binding_id: objectBindingId,
+        presence: fact.presence,
+        value_status: fact.value.status,
+        value_coverage: semanticContainer(fact.value)?.coverage ?? null,
+    },
+});