Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(javascript)!: preserve property paths and uncertain slot presence
morluto475a0f84dac6
diff --git a/src/application/javascript/JavaScriptApplicationEmptyLiterals.test.ts b/src/application/javascript/JavaScriptApplicationEmptyLiterals.test.tsindex 1503bf634..b200b91ea 100644--- a/src/application/javascript/JavaScriptApplicationEmptyLiterals.test.ts+++ b/src/application/javascript/JavaScriptApplicationEmptyLiterals.test.ts@@ -106,6 +106,8 @@ it("keeps exact values for empty literals without synthetic application labels",it.each([{ version: 3, sources: [""], names: [], mappings: "AAAA" },+ { version: 3, sourceRoot: null, sources: [""], names: [], mappings: "AAAA" },+ { version: 3, sourceRoot: "", sources: [""], names: [], mappings: "AAAA" },{version: 3,sections: [@@ -126,7 +128,9 @@ it.each([identity.strategy === "source-map-original"? identity.original_source: null,- sources: observations.map(({ properties }) => properties.source),+ sources: observations.map(+ ({ source_map_reference }) => source_map_reference?.source_name,+ ),}));expect(originals).toEqual([{ originalSource: "", sources: [""] }]);});@@ -267,3 +271,75 @@ it("selects an empty context-bridge API with an exact empty seed", async () => {});expect(matches.map(({ node_id: nodeId }) => apis.get(nodeId))).toEqual([""]);});++it("pairs indexed source-map leaves by raw source name and root", async () => {+ const map = (value: number) =>+ JSON.stringify({+ version: 3,+ sections: ["one", "two"].map((name, line) => ({+ offset: { line, column: 0 },+ map: {+ version: 3,+ sourceRoot: `../${name}`,+ sources: ["same.js"],+ sourcesContent: [`export const value = ${String(value)};`],+ names: [],+ mappings: "AAAA",+ },+ })),+ });+ const left = await analyzeSource("//# sourceMappingURL=app.js.map", {+ "app.js.map": map(1),+ });+ const right = await analyzeSource("//# sourceMappingURL=app.js.map", {+ "app.js.map": map(2),+ });+ const matching = matchJavaScriptApplicationVersions(+ left.graph.nodes,+ right.graph.nodes,+ );+ const originals = matching.pairs.filter(+ ({ left: node }) => node.kind === "source-module",+ );+ expect(originals).toHaveLength(2);+ for (const pair of originals) {+ expect(pair).toMatchObject({+ basis: "source-map-identity",+ confidence: "high",+ });+ expect(pair.left.identity).toMatchObject({+ original_source: "same.js",+ source_root: expect.any(String),+ });+ if (pair.left.identity.strategy !== "source-map-original")+ throw new Error("Expected source identity");+ expect(pair.right.identity).toMatchObject({+ source_root: pair.left.identity.source_root,+ });+ }+});++it("reports malformed source roots without manufacturing an original path", async () => {+ const output = await analyzeSource("//# sourceMappingURL=app.js.map", {+ "app.js.map": JSON.stringify({+ version: 3,+ sourceRoot: 42,+ sources: ["a.js"],+ names: [],+ mappings: "AAAA",+ }),+ });+ expect(+ output.graph.nodes.filter(({ kind }) => kind === "source-module"),+ ).toEqual([]);+ expect(+ output.graph.nodes.flatMap(({ observations }) => observations),+ ).toContainEqual(+ expect.objectContaining({+ properties: expect.objectContaining({+ limitation: "Source map sourceRoot must be a string or null.",+ }),+ evidence: expect.objectContaining({ state: "unavailable" }),+ }),+ );+});diff --git a/src/application/javascript/JavaScriptSemanticGraphBuilder.test.ts b/src/application/javascript/JavaScriptSemanticGraphBuilder.test.tsindex 03a8231dc..c8a63e944 100644--- a/src/application/javascript/JavaScriptSemanticGraphBuilder.test.ts+++ b/src/application/javascript/JavaScriptSemanticGraphBuilder.test.ts@@ -147,7 +147,9 @@ it("retains resource-limit reasons at nested object property slots", () => {expect.objectContaining({family: "object-flow",reason: "resource-limit",- detail: expect.stringMatching(/Unknown value at property:value/u),+ detail: expect.stringMatching(+ /Unknown value at property:\/nested\/value/u,+ ),}),);});@@ -625,3 +627,242 @@ it("only records node loss when the budget rejects a new identity", () => {expect(blocked).toBeNull();expect(state.fileNodesDropped).toBe(true);});++it("keeps full static property identities distinct through backward provenance", () => {+ const graph = graphFor(`+ const root = { a: { id: 'left' }, b: { id: 'right' }, 'a.id': 'dotted', '': { 'a/b~c': 'escaped' } };+ const left = root.a.id;+ const right = root['b']['id'];+ const missing = root.id;+ const dotted = root['a.id'];+ const escaped = root['']['a/b~c'];+ `);+ const slots = graph.nodes.filter(({ kind }) => kind === "property-slot");+ for (const [pointer, literal] of [+ ["/a/id", "left"],+ ["/b/id", "right"],+ ["/a.id", "dotted"],+ ["//a~1b~0c", "escaped"],+ ["/id", null],+ ]) {+ const slot = slots.find(+ ({ properties }) => properties.property_pointer === pointer,+ );+ if (slot === undefined) throw new Error(`Missing slot ${pointer}`);+ expect(slot.properties.presence).toBe(+ literal === null ? "absent" : "present",+ );+ const trace = queryJavaScriptSemanticGraph(graph, {+ seed: { kind: "semantic-node", node_id: slot.node_id },+ direction: "backward-provenance",+ allowed_relations: ["defines"],+ });+ expect(+ trace.nodes+ .filter(({ kind }) => kind === "literal")+ .map(({ properties }) => properties.value),+ ).toEqual(literal === null ? [] : [literal]);+ const reads = graph.relations.filter(+ ({ source_node_id, relation }) =>+ source_node_id === slot.node_id && relation === "reads-property",+ );+ expect(reads).toHaveLength(1);+ expect(reads[0]?.resolution).toBe(+ literal === null ? "candidate" : "resolved",+ );+ }+});++it("targets nested writes and destructuring without inventing leaf-level root slots", () => {+ const graph = graphFor(`+ const root = { left: { id: 'before' }, right: { id: 'untouched' } };+ root.left.id = produce();+ const { right: { id: selected } } = root;+ const [first, missing] = [1, , 3];+ `);+ const rootSlots = graph.nodes.filter(+ ({ kind, properties }) =>+ kind === "property-slot" && properties.name === "id",+ );+ expect(+ rootSlots.map(({ properties }) => properties.property_pointer).sort(),+ ).toEqual(["/left/id", "/right/id"]);+ const left = rootSlots.find(+ ({ properties }) => properties.property_pointer === "/left/id",+ );+ const right = rootSlots.find(+ ({ properties }) => properties.property_pointer === "/right/id",+ );+ expect(left?.properties.presence).toBe("unknown-coverage");+ const write = graph.nodes.find(+ ({ kind, properties }) =>+ kind === "expression" && properties.operation_kind === "write",+ );+ expect(graph.relations).toContainEqual(+ expect.objectContaining({+ source_node_id: write?.node_id,+ target_node_id: left?.node_id,+ relation: "writes-property",+ resolution: "resolved",+ }),+ );+ const selected = graph.nodes.find(+ ({ kind, label }) => kind === "binding" && label === "selected",+ );+ expect(graph.relations).toContainEqual(+ expect.objectContaining({+ source_node_id: right?.node_id,+ target_node_id: selected?.node_id,+ relation: "destructures",+ resolution: "resolved",+ }),+ );+});++it("keeps dynamic intermediate receivers unresolved instead of selecting a static leaf", () => {+ const graph = graphFor(`+ const root = { id: 'root', a: { id: 'nested' } };+ const selected = root[key].id;+ `);+ expect(+ graph.relations.filter(({ relation }) => relation === "reads-property"),+ ).toEqual([]);+ expect(graph.unknowns).toContainEqual(+ expect.objectContaining({+ family: "object-flow",+ relation_kinds: ["reads-property"],+ }),+ );+ const selected = graph.nodes.find(+ ({ kind, label }) => kind === "binding" && label === "selected",+ );+ if (selected === undefined) throw new Error("Missing selected binding");+ const trace = queryJavaScriptSemanticGraph(graph, {+ seed: { kind: "semantic-node", node_id: selected.node_id },+ direction: "backward-provenance",+ allowed_relations: ["defines"],+ });+ expect(trace.nodes.filter(({ kind }) => kind === "literal")).toEqual([]);+});++it.each([+ {+ initializer: "{}",+ path: "missing.id",+ pointer: "/missing/id",+ resolved: false,+ },+ {+ initializer: "{ a: null }",+ path: "a.id",+ pointer: "/a/id",+ resolved: false,+ },+ { initializer: "{ a: 1 }", path: "a.id", pointer: "/a/id", resolved: false },+ { initializer: "{ a: {} }", path: "a.id", pointer: "/a/id", resolved: true },+ { initializer: "{ a: [] }", path: "a[0]", pointer: "/a/0", resolved: true },+])(+ "admits a write only through a retained container receiver: $initializer.$path",+ ({ initializer, path, pointer, resolved }) => {+ const graph = graphFor(+ `const root = ${initializer}; root.${path} = produce();`,+ );+ const write = graph.nodes.find(+ ({ kind, properties }) =>+ kind === "expression" && properties.operation_kind === "write",+ );+ const slot = graph.nodes.find(+ ({ kind, properties }) =>+ kind === "property-slot" && properties.property_pointer === pointer,+ );+ if (write === undefined || slot === undefined)+ throw new Error("Expected write and target slot");+ expect(graph.relations).toContainEqual(+ expect.objectContaining({+ source_node_id: write.node_id,+ target_node_id: slot.node_id,+ relation: "writes-property",+ resolution: resolved ? "resolved" : "candidate",+ }),+ );+ const trace = queryJavaScriptSemanticGraph(graph, {+ seed: { kind: "semantic-node", node_id: write.node_id },+ direction: "forward-influence",+ allowed_relations: ["writes-property"],+ });+ expect(trace.nodes.some(({ node_id }) => node_id === slot.node_id)).toBe(+ resolved,+ );+ if (!resolved)+ expect(graph.unknowns).toContainEqual(+ expect.objectContaining({+ node_id: slot.node_id,+ relation_kinds: ["writes-property"],+ detail: expect.stringContaining(+ "receiver is unresolved or not a retained container",+ ),+ }),+ );+ },+);++it("retains array length presence without inventing an exact length", () => {+ const graph = graphFor("const root = [, 1]; const length = root.length;");+ const slot = graph.nodes.find(+ ({ kind, properties }) =>+ kind === "property-slot" && properties.property_pointer === "/length",+ );+ expect(slot?.properties).toMatchObject({+ name: "length",+ presence: "present",+ value_status: "unknown",+ });+ const trace = queryJavaScriptSemanticGraph(graph, {+ seed: { kind: "property", name: "length" },+ direction: "forward-influence",+ allowed_relations: ["reads-property"],+ });+ expect(trace.seed_node_ids).toEqual([slot?.node_id]);+ expect(trace.relations).toContainEqual(+ expect.objectContaining({+ source_node_id: slot?.node_id,+ relation: "reads-property",+ resolution: "resolved",+ }),+ );+ expect(+ graph.relations.some(+ ({ target_node_id, relation }) =>+ target_node_id === slot?.node_id && relation === "defines",+ ),+ ).toBe(false);+});++it.each(["{}", "unknownRoot", "{ a: null }"])(+ "preserves the requested deep leaf name after a blocked prefix: %s",+ (initializer) => {+ const graph = graphFor(+ `const root = ${initializer}; const selected = root.a.b.c;`,+ );+ const slot = graph.nodes.find(+ ({ kind, properties }) =>+ kind === "property-slot" && properties.property_pointer === "/a/b/c",+ );+ expect(slot).toMatchObject({+ label: "c",+ properties: {+ name: "c",+ property_path: ["a", "b", "c"],+ presence: "unknown-coverage",+ value_status: "unknown",+ },+ });+ const trace = queryJavaScriptSemanticGraph(graph, {+ seed: { kind: "property", name: "c" },+ direction: "backward-provenance",+ allowed_relations: ["defines"],+ });+ expect(trace.seed_node_ids).toEqual([slot?.node_id]);+ expect(trace.nodes.filter(({ kind }) => kind === "literal")).toEqual([]);+ },+);diff --git a/src/application/javascript/JavaScriptSemanticGraphObjectProjection.ts b/src/application/javascript/JavaScriptSemanticGraphObjectProjection.tsindex e0e3b78e8..cf301dc68 100644--- a/src/application/javascript/JavaScriptSemanticGraphObjectProjection.ts+++ b/src/application/javascript/JavaScriptSemanticGraphObjectProjection.ts@@ -1,3 +1,12 @@+import {+ semanticSlotAtPath,+ semanticContainer,+ semanticPropertyPointer,+} from "../../domain/javascript/javascriptSemanticSlots.js";+import type {+ JavaScriptSemanticSlotPresence,+ JavaScriptSemanticValue,+} from "../../domain/javascript/javascriptSemanticValueTypes.js";import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";import type { JavaScriptSemanticGraphNode } from "../../domain/javascript/javascriptSemanticGraph.js";import type { JavaScriptSemanticObjectOperation } from "../../domain/javascript/javascriptSemanticIr.js";@@ -14,56 +23,115 @@ import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.jexport const projectSemanticObjects = (context: SemanticFlowProjectionContext,): void => {+ const values = new Map(+ context.ir.bindings.map((binding) => [binding.bindingId, binding.value]),+ );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,+ 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",+} as const;++interface ObjectTarget {+ readonly objectNode: JavaScriptSemanticGraphNode | null | undefined;+ readonly slot: JavaScriptSemanticGraphNode | null;+ readonly presence: JavaScriptSemanticSlotPresence;+ readonly receiverResolved: boolean;+}++const objectTarget = (+ context: SemanticFlowProjectionContext,+ values: ReadonlyMap<string, JavaScriptSemanticValue>,+ operation: JavaScriptSemanticObjectOperation,+): ObjectTarget => {+ 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: SemanticFlowProjectionContext,+ operation: JavaScriptSemanticObjectOperation,+ occurrence: JavaScriptSemanticGraphNode | null,+ target: ObjectTarget,+) => {+ 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),- 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);+ };+ case "spread":+ return { source: target.objectNode, target: occurrence };}};@@ -76,9 +144,9 @@ const addObjectOccurrence = (roleKey: operation.objectOperationId,location: operation.location,label:- operation.propertyName === null+ operation.propertyPath === null? operation.kind- : `${operation.kind}:${operation.propertyName}`,+ : `${operation.kind}:${semanticPropertyPointer(operation.propertyPath)}`,functionNodeId:operation.ownerCallableId === null? null@@ -86,7 +154,8 @@ const addObjectOccurrence = (null),properties: {operation_kind: operation.kind,- property_name: operation.propertyName,+ property_path:+ operation.propertyPath === null ? null : [...operation.propertyPath],},});@@ -94,15 +163,9 @@ const addObjectUnknown = (context: SemanticFlowProjectionContext,operation: JavaScriptSemanticObjectOperation,node: JavaScriptSemanticGraphNode | null,+ target: Pick<ObjectTarget, "presence" | "receiverResolved">,): void => {- const relation =- operation.kind === "read"- ? "reads-property"- : operation.kind === "write"- ? "writes-property"- : operation.kind === "spread"- ? "spreads"- : "destructures";+ const relation = OBJECT_RELATIONS[operation.kind];addSemanticGraphUnknown(context.state,createJavaScriptSemanticGraphUnknown({@@ -110,7 +173,7 @@ const addObjectUnknown = (family: "object-flow",relation_kinds: [relation],reason: "ambiguous-target",- detail: `Static ${operation.kind} object identity is partial.`,+ 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),}),diff --git a/src/application/javascript/JavaScriptSemanticGraphProjection.test.ts b/src/application/javascript/JavaScriptSemanticGraphProjection.test.tsdeleted file mode 100644index 086319bdc..000000000--- a/src/application/javascript/JavaScriptSemanticGraphProjection.test.ts+++ /dev/null@@ -1,259 +0,0 @@-import { expect, it } from "vitest";--import { compareCodePoints } from "../../domain/canonicalOrdering.js";-import type { JavaScriptArtifactFile } from "../../domain/javascript/javascriptArtifactFiles.js";-import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";-import type { JavaScriptSemanticGraphNode } from "../../domain/javascript/javascriptSemanticGraph.js";-import type { JavaScriptSemanticIr } from "../../domain/javascript/javascriptSemanticIr.js";-import type { JavaScriptSourceRange } from "../../domain/javascript/javascriptStaticAnalysisTypes.js";-import {- constructSemanticGraphNode,- createSemanticGraphProjectionState,-} from "./JavaScriptSemanticGraphConstruction.js";-import {- createSemanticCallableOwnerLookup,- createSemanticNodeRangeLookup,- createSemanticCallSiteLookup,-} from "./JavaScriptSemanticGraphProjection.js";-import { sourceRangesEqual } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";--const fixtureFile: JavaScriptArtifactFile = {- path: "app.js",- container_sha256: "a".repeat(64),- sha256: "b".repeat(64),- bytes: 0,- inventory_artifact_id: "fixture-app",- kind: "javascript",- unpacked: false,- text: { included: true, value: "" },-};--const nodesFor = (ir: JavaScriptSemanticIr) => {- const state = createSemanticGraphProjectionState({ nodes: [] });-- return new Map(- ir.callables.map((callable) => [- callable.callableId,- constructSemanticGraphNode(- fixtureFile,- {- kind: "function",- roleKey: callable.callableId,- label: callable.name,- location: callable.location,- functionNodeId: null,- },- state,- ),- ]),- );-};--// Reference behavior before the optimization, including stable ties and-// fallback when the most deeply nested callable has no retained graph node.-const previousOwner = (- location: JavaScriptSourceRange | null,- ir: JavaScriptSemanticIr,- nodes: ReadonlyMap<string, JavaScriptSemanticGraphNode>,-) => {- if (location === null) return undefined;- const compare = (- left: JavaScriptSourceRange["start"],- right: JavaScriptSourceRange["start"],- ) => left.line - right.line || left.column - right.column;- const key = (range: JavaScriptSourceRange) =>- `${String(range.start.line).padStart(12, "0")}:${String(range.start.column).padStart(12, "0")}`;- return ir.callables- .filter(- (callable) =>- compare(callable.location.start, location.start) <= 0 &&- compare(callable.location.end, location.end) >= 0,- )- .sort((left, right) =>- compareCodePoints(key(right.location), key(left.location)),- )- .map((callable) => nodes.get(callable.callableId))- .find((node) => node !== undefined);-};--const rangesFor = (ir: JavaScriptSemanticIr) => [- null,- ...ir.callables.map((callable) => callable.location),- ...ir.bindings.flatMap((binding) =>- binding.definitions.map((definition) => definition.location),- ),- ...ir.references.map((reference) => reference.location),- { start: { line: 999, column: 0 }, end: { line: 999, column: 1 } },-];--it("matches the prior owner selection across nested functions, arrows and methods", () => {- const ir = analyzeJavaScriptSemantics(`- const outside = 1;- function outer(parameter) {- function inner(value) { return value + parameter; }- const callback = argument => inner(argument);- return callback(outside);- }- class Example { method(value) { return () => outer(value); } }- `);- const nodes = nodesFor(ir);- const lookup = createSemanticCallableOwnerLookup(ir, nodes);- for (const range of rangesFor(ir))- expect(lookup(range)).toBe(previousOwner(range, ir, nodes));-});--it("reads retained node membership at query time and keeps file indexes independent", () => {- const ir = analyzeJavaScriptSemantics(- "function outer() { function inner() { return 1; } return inner(); }",- );- const inner = ir.callables.find((callable) => callable.name === "inner");- if (inner === undefined) throw new Error("Missing inner fixture callable");- const nodes = nodesFor(ir);- const otherNodes = nodesFor(ir);- const lookup = createSemanticCallableOwnerLookup(ir, nodes);- const otherLookup = createSemanticCallableOwnerLookup(ir, otherNodes);- const before = lookup(inner.location);- expect(before?.label).toBe("inner");- nodes.delete(inner.callableId);- expect(lookup(inner.location)?.label).toBe("outer");- expect(otherLookup(inner.location)?.label).toBe("inner");- if (before === undefined) throw new Error("Missing retained fixture node");- nodes.set(inner.callableId, before);- expect(lookup(inner.location)).toBe(before);-});--it("preserves stable ties and non-nested overlapping ranges", () => {- const original = analyzeJavaScriptSemantics(- "function first() { return 1; } function second() { return 2; } function third() { return 3; }",- );- const range = (start: number, end: number): JavaScriptSourceRange => ({- start: { line: 1, column: start },- end: { line: 1, column: end },- });- const ir = {- ...original,- callables: original.callables.map((callable, index) => ({- ...callable,- location: index === 0 ? range(0, 90) : range(20, index === 1 ? 60 : 80),- })),- };- const nodes = nodesFor(ir);- const lookup = createSemanticCallableOwnerLookup(ir, nodes);- for (const query of [- range(25, 30),- range(25, 70),- range(0, 80),- range(80, 90),- range(91, 92),- ])- expect(lookup(query)).toBe(previousOwner(query, ir, nodes));-});--it("matches the prior result across a compiled-style collection of sibling callables", () => {- const ir = analyzeJavaScriptSemantics(- Array.from(- { length: 300 },- (_, index) =>- `function f${String(index)}(value) { return value + ${String(index)}; }`,- ).join(""),- );- const nodes = nodesFor(ir);- const lookup = createSemanticCallableOwnerLookup(ir, nodes);- for (const range of rangesFor(ir))- expect(lookup(range)).toBe(previousOwner(range, ir, nodes));-});--it("returns contained nodes in original order, including repeated and overlapping entries", () => {- const ir = analyzeJavaScriptSemantics(`- function outer(value) { function inner() { return value; } return inner(); }- const sibling = () => outer(1);- `);- const nodes = [...nodesFor(ir).values()].reverse();- const repeated = nodes[0];- if (repeated === undefined) throw new Error("Missing range fixture node");- nodes.push(- repeated,- constructSemanticGraphNode(- fixtureFile,- {- kind: "module",- roleKey: "module",- location: null,- label: "module",- functionNodeId: null,- },- createSemanticGraphProjectionState({ nodes: [] }),- ),- );- const lookup = createSemanticNodeRangeLookup(nodes);- const compare = (- left: JavaScriptSourceRange["start"],- right: JavaScriptSourceRange["start"],- ) => left.line - right.line || left.column - right.column;- for (const range of rangesFor(ir)) {- if (range === null) continue;- const expected = nodes.filter(- ({ identity }) =>- identity.source_range !== null &&- compare(range.start, identity.source_range.start) <= 0 &&- compare(range.end, identity.source_range.end) >= 0,- );- expect(lookup(range)).toEqual(expected);- }- expect(- createSemanticNodeRangeLookup([])(- repeated.identity.source_range ?? {- start: { line: 1, column: 0 },- end: { line: 1, column: 1 },- },- ),- ).toEqual([]);-});--it("keeps first-call matching and current retained membership for exact locations", () => {- const original = analyzeJavaScriptSemantics(- "function target(value) { return value; } target(1); target(2);",- );- const first = original.callSites[0];- const node = [...nodesFor(original).values()][0];- if (first === undefined || node === undefined)- throw new Error("Missing call fixture");- const duplicate = { ...first, callSiteId: `${first.callSiteId}:duplicate` };- const ir = {- ...original,- callSites: [first, duplicate, ...original.callSites.slice(1)],- };- const nodes = new Map(- ir.callSites.map((call) => [- call.callSiteId,- constructSemanticGraphNode(- fixtureFile,- {- kind: "call-site",- roleKey: call.callSiteId,- location: call.location,- label: call.callSiteId,- functionNodeId: null,- },- createSemanticGraphProjectionState({ nodes: [] }),- ),- ]),- );- const lookup = createSemanticCallSiteLookup(ir, nodes);- const previous = (range: JavaScriptSourceRange) => {- const call = ir.callSites.find((candidate) =>- sourceRangesEqual(candidate.location, range),- );- return call === undefined ? undefined : nodes.get(call.callSiteId);- };- for (const call of ir.callSites)- expect(lookup(call.location)).toBe(previous(call.location));- nodes.delete(first.callSiteId);- expect(lookup(first.location)).toBeUndefined();- expect(nodes.has(duplicate.callSiteId)).toBe(true);- nodes.set(first.callSiteId, node);- expect(lookup(first.location)).toBe(node);- expect(- lookup({ start: { line: 99, column: 0 }, end: { line: 99, column: 1 } }),- ).toBeUndefined();-});diff --git a/src/application/javascript/JavaScriptSemanticGraphValueProjection.ts b/src/application/javascript/JavaScriptSemanticGraphValueProjection.tsindex 93bd79ca7..dc3c72d5f 100644--- a/src/application/javascript/JavaScriptSemanticGraphValueProjection.ts+++ b/src/application/javascript/JavaScriptSemanticGraphValueProjection.ts@@ -1,4 +1,8 @@-import type { JsonValue } from "../../domain/jsonValue.js";+import {+ semanticContainer,+ semanticPropertyPointer,+ type JavaScriptSemanticSlot,+} from "../../domain/javascript/javascriptSemanticSlots.js";import type {JavaScriptSemanticBinding,JavaScriptSemanticValue,@@ -24,7 +28,7 @@ export const projectSemanticValues = (binding,value: binding.value,target: bindingNode,- role: "binding",+ path: [],});}};@@ -34,11 +38,13 @@ interface ValueProjectionInput {readonly binding: JavaScriptSemanticBinding;readonly value: JavaScriptSemanticValue;readonly target: ReturnType<typeof semanticPropertySlot>;- readonly role: string;+ readonly path: readonly string[];}const projectValue = (input: ValueProjectionInput): void => {- const { context, binding, value, target, role } = 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);@@ -58,31 +64,33 @@ const projectValue = (input: ValueProjectionInput): void => {resolution: "candidate",});}- else if (value.status === "object")- for (const property of value.properties) {+ 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,- property.name,+ propertyPath,+ property,);+ if (property.presence === "absent") continue;addSemanticGraphRelation(context.state, {source: target,target: slot,relation: "writes-property",- resolution:- value.unknownProperties || property.presence === "unknown-coverage"- ? "candidate"- : "resolved",- });- projectValue({- context,- binding,- value: property.value,- target: slot,- role: `property:${property.name}`,+ resolution: property.presence === "present" ? "resolved" : "candidate",});+ if (property.presence === "present")+ projectValue({+ context,+ binding,+ value: property.value,+ target: slot,+ path: propertyPath,+ });}- else if (value.status === "unknown" && value.resourceLimit !== undefined) {+ } else if (value.status === "unknown" && value.resourceLimit !== undefined) {const location = binding.definitions[0]?.location ?? null;const evidence = observedSemanticEvidence(context.file, location);const isPropertyValue = role.startsWith("property:");@@ -123,21 +131,27 @@ const addLiteralNode = (properties: { value },});-/** Create one canonical property slot for a binding/property identity. */+/** Create one canonical slot for a root binding and exact static property path. */export const semanticPropertySlot = (context: SemanticFlowProjectionContext,objectBindingId: string,- name: string,+ path: readonly string[],+ fact: JavaScriptSemanticSlot,) =>retainSemanticGraphNode(context.state, context.file, {kind: "property-slot",- roleKey: `property:${objectBindingId}:${name}`,+ roleKey: `property:${JSON.stringify([objectBindingId, path])}`,location: null,- label: name,+ label: fact.name,functionNodeId:context.bindingNodes.get(objectBindingId)?.function_node_id ?? null,properties: {- name,+ name: fact.name,+ property_path: [...path],+ property_pointer: semanticPropertyPointer(path),object_binding_id: objectBindingId,- } satisfies Readonly<Record<string, JsonValue>>,+ presence: fact.presence,+ value_status: fact.value.status,+ value_coverage: semanticContainer(fact.value)?.coverage ?? null,+ },});diff --git a/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts b/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.tsindex b8ab01aea..067452b7e 100644--- a/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts+++ b/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts@@ -71,6 +71,7 @@ it("parses projected fields into literal, union, or unknown values", () => {projectedExportReturnShapesSchema.safeParse(projectionWithField({path: "/kind",+ presence: "present",state: "unknown",value: "invented",reason: "Dynamic property",@@ -81,6 +82,7 @@ it("parses projected fields into literal, union, or unknown values", () => {projectedExportReturnShapesSchema.safeParse(projectionWithField({path: "/kind",+ presence: "present",state: "union",value: ["success", "failure"],reason: null,@@ -88,3 +90,16 @@ it("parses projected fields into literal, union, or unknown values", () => {).success,).toBe(true);});++it("rejects return fields that omit slot presence", () => {+ expect(+ projectedExportReturnShapesSchema.safeParse(+ projectionWithField({+ path: "/kind",+ state: "literal",+ value: "result",+ reason: null,+ }),+ ).success,+ ).toBe(false);+});diff --git a/src/domain/javascript/javascriptExportShapeComparisonSchemas.ts b/src/domain/javascript/javascriptExportShapeComparisonSchemas.tsindex 9a1fae67c..9e0671d2b 100644--- a/src/domain/javascript/javascriptExportShapeComparisonSchemas.ts+++ b/src/domain/javascript/javascriptExportShapeComparisonSchemas.ts@@ -75,7 +75,7 @@ export const compareJavaScriptExportShapesInputSchema = zconst projectedReturnFieldShape = {path: jsonPointerSchema,- presence: z.enum(["present", "absent", "unknown-coverage"]).optional(),+ presence: z.enum(["present", "absent", "unknown-coverage"]),};const projectedReturnFieldSchema = z.discriminatedUnion("state", [z.strictObject({diff --git a/src/domain/javascript/javascriptExportShapeSelection.ts b/src/domain/javascript/javascriptExportShapeSelection.tsindex c20df16bd..6a0ecc120 100644--- a/src/domain/javascript/javascriptExportShapeSelection.ts+++ b/src/domain/javascript/javascriptExportShapeSelection.ts@@ -10,9 +10,6 @@ import {import { compareCodePoints } from "../canonicalOrdering.js";type Shape = ProjectedExportReturnShapes["static_return_shapes"][number];-type Field = Shape["fields"][number];-type NormalizedField = Field & { presence: NonNullable<Field["presence"]> };-type NormalizedShape = Omit<Shape, "fields"> & { fields: NormalizedField[] };type SelectorResult = JavaScriptExportShapeComparisonResult["left"];type SelectorBase = Omit<SelectorResult, "status" | "selected_node_id">;type ReturnShapeSelection =@@ -58,7 +55,7 @@ export type SelectedJavaScriptExport =/** Complete return-shape inventory retained from an authenticated projection. */export interface RetainedJavaScriptExportShapes {- readonly shapes: readonly NormalizedShape[];+ readonly shapes: readonly Shape[];readonly omitted: number;}@@ -129,24 +126,13 @@ export const selectJavaScriptExport = (};};-/** Retain every variant and normalize legacy presence on comparison-owned copies. */+/** Retain every authenticated variant with its explicit slot presence. */export const retainJavaScriptExportShapes = (selection: SelectedJavaScriptExport,-): RetainedJavaScriptExportShapes => {- const shapes = (- selection.projection?.static_return_shapes ?? []- ).map<NormalizedShape>((shape) => ({- ...shape,- fields: shape.fields.map<NormalizedField>((field) => ({- ...field,- // Legacy unknown fields did not distinguish values from uncertain slots.- presence:- field.presence ??- (field.state === "unknown" ? "unknown-coverage" : "present"),- })),- }));- return { shapes, omitted: 0 };-};+): RetainedJavaScriptExportShapes => ({+ shapes: selection.projection?.static_return_shapes ?? [],+ omitted: 0,+});const selectorBase = (side: JavaScriptExportShapeSideInput,diff --git a/src/domain/javascript/javascriptSemanticAnalysis.dataflow.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.dataflow.test.tsindex ba8351c45..55ce3705a 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.dataflow.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.dataflow.test.ts@@ -17,21 +17,21 @@ describe("JavaScript semantic analysis: dataflow 1", () => {`);expect(- ir.objectOperations.map(({ kind, propertyName, resolution }) => ({+ ir.objectOperations.map(({ kind, propertyPath, resolution }) => ({kind,- propertyName,+ propertyPath,resolution,})),).toEqual(expect.arrayContaining([{kind: "destructure",- propertyName: "token",+ propertyPath: ["token"],resolution: "complete",},- { kind: "spread", propertyName: null, resolution: "complete" },- { kind: "write", propertyName: "count", resolution: "complete" },- { kind: "read", propertyName: "token", resolution: "complete" },+ { kind: "spread", propertyPath: [], resolution: "complete" },+ { kind: "write", propertyPath: ["count"], resolution: "complete" },+ { kind: "read", propertyPath: ["token"], resolution: "complete" },]),);});@@ -50,11 +50,11 @@ describe("JavaScript semantic analysis: dataflow 1", () => {({ kind }) => kind === "destructure",);- expect(destructures.map(({ propertyName }) => propertyName)).toEqual([- "token",- "token",- "token",- "1",+ expect(destructures.map(({ propertyPath }) => propertyPath)).toEqual([+ ["token"],+ ["token"],+ ["token"],+ ["1"],]);expect(destructures.every(({ resolution }) => resolution === "complete"),@@ -127,10 +127,19 @@ describe("JavaScript semantic analysis: dataflow 1", () => {unknownProperties: false,omittedProperties: 0,properties: expect.arrayContaining([- { name: "depth", value: { status: "literal", value: 1 } },- { name: "type", value: { status: "literal", value: "heading" } },+ {+ name: "depth",+ presence: "present",+ value: { status: "literal", value: 1 },+ },+ {+ name: "type",+ presence: "present",+ value: { status: "literal", value: "heading" },+ },{name: "text",+ presence: "present",value: {status: "unknown",reason: "Unsupported CallExpression value.",diff --git a/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.tsindex 59d153a8f..fa2eafa8e 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts@@ -62,7 +62,11 @@ it("invalidates a deep mutation while retaining unrelated literal properties", (expect(onlyBinding(ir, "root").value).toEqual({status: "object",properties: [- { name: "untouched", value: { status: "literal", value: "retained" } },+ {+ name: "untouched",+ presence: "present",+ value: { status: "literal", value: "retained" },+ },{name: "next",presence: "unknown-coverage",diff --git a/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.tsindex 8b040144a..c0d3066a3 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.member_mutations.test.ts@@ -93,6 +93,9 @@ const unchangedProperties = ['const source = { nested: { token: "TOKEN", count: 1 } }; const { nested } = source; nested.count = 2; return source.nested.token;','const child = { token: "TOKEN", count: 1 }; const source = { child }; source.child.count = 2; return child.token;','const source = ["TOKEN", 1]; source[1] = 2; return source[0];',+ 'const source = ["TOKEN"]; source.extra = 2; return source[0];',+ 'const source = ["TOKEN"]; source["01"] = 2; return source[0];',+ 'const source = ["TOKEN"]; source[1000000000] = 2; return source[0];','const child = { token: "TOKEN", count: 1 }; const source = [child]; source[0].count = 2; return child.token;','const source = { token: "TOKEN" }; source.added = 2; return source.token;','const source = { token: "TOKEN", count: 1, other: 1 }; source.count = 2; source.other = 2; return source.token;',diff --git a/src/domain/javascript/javascriptSemanticAnalysis.rejection.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.rejection.test.tsindex 0df194a05..0c8495767 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.rejection.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.rejection.test.ts@@ -144,7 +144,11 @@ describe("JavaScript semantic analysis: rejection 1", () => {expect(recovered.returnSites[0]?.value).toMatchObject({status: "object",properties: expect.arrayContaining([- { name: "type", value: { status: "literal", value: "item" } },+ {+ name: "type",+ presence: "present",+ value: { status: "literal", value: "item" },+ },expect.objectContaining({name: "text",value: expect.objectContaining({ status: "unknown" }),diff --git a/src/domain/javascript/javascriptSemanticIr.ts b/src/domain/javascript/javascriptSemanticIr.tsindex 38a55ef41..14ce12d12 100644--- a/src/domain/javascript/javascriptSemanticIr.ts+++ b/src/domain/javascript/javascriptSemanticIr.ts@@ -380,7 +380,7 @@ export interface JavaScriptSemanticObjectOperation {readonly ownerCallableId: string | null;readonly objectBindingId: string | null;readonly targetBindingId: string | null;- readonly propertyName: string | null;+ readonly propertyPath: readonly string[] | null;readonly resolution: "complete" | "partial";}diff --git a/src/domain/javascript/javascriptSemanticMemberMutations.ts b/src/domain/javascript/javascriptSemanticMemberMutations.tsindex 325e48169..2c6ebe9e8 100644--- a/src/domain/javascript/javascriptSemanticMemberMutations.ts+++ b/src/domain/javascript/javascriptSemanticMemberMutations.ts@@ -6,10 +6,7 @@ import {} from "./javascriptSemanticState.js";import { evaluateSemanticBinding } from "./javascriptSemanticValues.js";import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";-import {- semanticStaticPropertyKey,- semanticStaticPropertyName,-} from "./javascriptAstValues.js";+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";type PropertyPath = readonly (string | number | null)[];@@ -105,13 +102,11 @@ const referencedValues = (if (t.isSpreadElement(property))return [{ node: property.argument, path }];if (!t.isObjectProperty(property)) return [];- const name = semanticStaticPropertyName(+ const name = semanticStaticPropertyKey(property.key,property.computed,);- return key === null ||- (name === "" && !t.isStringLiteral(property.key, { value: "" })) ||- String(key) === name+ return key === null || name === null || String(key) === name? [{ node: property.value, path: remaining }]: [];});diff --git a/src/domain/javascript/javascriptSemanticMutationValues.ts b/src/domain/javascript/javascriptSemanticMutationValues.tsindex d9946ff3a..46127f614 100644--- a/src/domain/javascript/javascriptSemanticMutationValues.ts+++ b/src/domain/javascript/javascriptSemanticMutationValues.ts@@ -32,25 +32,26 @@ export const invalidateSemanticMutationPath = (return { ...value, properties };}if (value.status === "array") {- const index = typeof key === "number" ? key : Number(key);- if (- !Number.isSafeInteger(index) ||- index < 0 ||- String(index) !== String(key)- )- return unknown;- const items = value.items.map((item, position) =>- position === index- ? invalidateSemanticMutationPath(item, remaining)+ const name = String(key);+ // Array length writes can remove every index; ordinary named properties+ // and sparse indices affect only their own slot.+ if (name === "length") return unknown;+ const observed = value.items.some((item) => item.name === name);+ const items = value.items.map((item) =>+ item.name === name+ ? {+ ...item,+ presence:+ remaining.length === 0+ ? ("unknown-coverage" as const)+ : item.presence,+ value: invalidateSemanticMutationPath(item.value, remaining),+ }: item,);- const itemPresence = {- ...value.itemPresence,- ...(remaining.length === 0 || value.items[index] === undefined- ? { [index]: "unknown-coverage" as const }- : {}),- };- return { ...value, items, itemPresence };+ if (!observed)+ items.push({ name, presence: "unknown-coverage", value: unknown });+ return { ...value, items };}return unknown;};diff --git a/src/domain/javascript/javascriptSemanticObjects.ts b/src/domain/javascript/javascriptSemanticObjects.tsindex 63a001c47..3a8414776 100644--- a/src/domain/javascript/javascriptSemanticObjects.ts+++ b/src/domain/javascript/javascriptSemanticObjects.ts@@ -38,20 +38,24 @@ export const collectJavaScriptSemanticObjects = (t.isSpreadElement(node) &&parent !== null &&t.isObjectExpression(parent)- )+ ) {+ const identity = expressionObjectIdentity(node.argument, state);addObjectOperation({node,kind: "spread",ownerCallableId,- objectBindingId: expressionBindingId(node.argument, state),+ objectBindingId: identity.bindingId,targetBindingId: null,- propertyName: null,+ propertyPath: identity.path,},state,output,);- else if (t.isVariableDeclarator(node) && t.isObjectPattern(node.id))+ } else if (+ t.isVariableDeclarator(node) &&+ (t.isObjectPattern(node.id) || t.isArrayPattern(node.id))+ )collectDestructuring(node, ownerCallableId, state, output);},exit: (node) => {@@ -75,8 +79,14 @@ const collectMember = (context: ObjectCollectionContext,): void => {const { state, output } = context;- const name = semanticStaticPropertyKey(node.property, node.computed);- if (name === null) return;+ // A chain is one property access; retaining every prefix duplicates work and+ // would make full paths quadratic in deeply nested producer expressions.+ if (+ (t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&+ parent.object === node+ )+ return;+ const identity = expressionObjectIdentity(node, state);const write =(t.isAssignmentExpression(parent) && parent.left === node) ||(t.isUpdateExpression(parent) && parent.argument === node);@@ -87,9 +97,9 @@ const collectMember = (node,kind: "read",ownerCallableId,- objectBindingId: expressionBindingId(node.object, state),+ objectBindingId: identity.bindingId,targetBindingId: null,- propertyName: name,+ propertyPath: identity.path,},state,output,@@ -99,9 +109,9 @@ const collectMember = (node,kind: write ? "write" : "read",ownerCallableId,- objectBindingId: expressionBindingId(node.object, state),+ objectBindingId: identity.bindingId,targetBindingId: null,- propertyName: name,+ propertyPath: identity.path,},state,output,@@ -114,30 +124,41 @@ const collectDestructuring = (state: JavaScriptSemanticAnalysisState,output: JavaScriptSemanticObjectOperation[],): void => {- if (!t.isObjectPattern(node.id)) return;- const objectBindingId = expressionBindingId(node.init, state);- for (const property of node.id.properties) {- if (!t.isObjectProperty(property)) continue;- const name = semanticStaticPropertyKey(property.key, property.computed);- if (name === null) continue;- const target = bindingIdentifier(property.value);+ const source = expressionObjectIdentity(node.init, state);+ const visit = (pattern: t.Node, path: readonly string[]): void => {+ if (t.isObjectPattern(pattern)) {+ for (const property of pattern.properties) {+ if (!t.isObjectProperty(property)) continue;+ const name = semanticStaticPropertyKey(property.key, property.computed);+ if (name !== null) visit(property.value, [...path, name]);+ }+ return;+ }+ if (t.isArrayPattern(pattern)) {+ pattern.elements.forEach((element, index) => {+ if (element !== null && !t.isRestElement(element))+ visit(element, [...path, String(index)]);+ });+ return;+ }+ const target = bindingIdentifier(pattern);+ if (target === null) return;addObjectOperation({- node: property,+ node: pattern,kind: "destructure",ownerCallableId,- objectBindingId,+ objectBindingId: source.bindingId,targetBindingId:- target === null- ? null- : (resolveSemanticBindingState(state, target, target.name)- ?.bindingId ?? null),- propertyName: name,+ resolveSemanticBindingState(state, target, target.name)?.bindingId ??+ null,+ propertyPath: source.path === null ? null : [...source.path, ...path],},state,output,);- }+ };+ visit(node.id, []);};interface AddObjectOperationInput {@@ -146,7 +167,7 @@ interface AddObjectOperationInput {readonly ownerCallableId: string | null;readonly objectBindingId: string | null;readonly targetBindingId: string | null;- readonly propertyName: string | null;+ readonly propertyPath: readonly string[] | null;}const addObjectOperation = (@@ -161,27 +182,57 @@ const addObjectOperation = (ownerCallableId: input.ownerCallableId,objectBindingId: input.objectBindingId,targetBindingId: input.targetBindingId,- propertyName: input.propertyName,+ propertyPath: input.propertyPath,resolution:- input.kind === "spread"- ? input.objectBindingId === null- ? "partial"- : "complete"- : input.objectBindingId === null ||- input.propertyName === null ||- (input.kind === "destructure" && input.targetBindingId === null)- ? "partial"- : "complete",+ input.objectBindingId === null ||+ input.propertyPath === null ||+ (input.kind === "destructure" && input.targetBindingId === null)+ ? "partial"+ : "complete",});};-const expressionBindingId = (+interface ObjectIdentity {+ readonly bindingId: string | null;+ readonly path: readonly string[] | null;+}++const expressionObjectIdentity = (node: t.Node | null | undefined,state: JavaScriptSemanticAnalysisState,-): string | null =>- t.isIdentifier(node)- ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)- : null;+): ObjectIdentity => {+ const path: string[] = [];+ let current = node;+ let staticPath = true;+ while (current !== null && current !== undefined) {+ if (+ t.isMemberExpression(current) ||+ t.isOptionalMemberExpression(current)+ ) {+ const name = semanticStaticPropertyKey(+ current.property,+ current.computed,+ );+ if (name === null) staticPath = false;+ else path.push(name);+ current = current.object;+ } else if (+ t.isTSAsExpression(current) ||+ t.isTSTypeAssertion(current) ||+ t.isTSNonNullExpression(current) ||+ t.isTSSatisfiesExpression(current)+ )+ current = current.expression;+ else break;+ }+ return {+ bindingId: t.isIdentifier(current)+ ? (resolveSemanticBindingState(state, current, current.name)?.bindingId ??+ null)+ : null,+ path: staticPath ? path.reverse() : null,+ };+};const bindingIdentifier = (node: t.Node): t.Identifier | null => {if (t.isIdentifier(node)) return node;diff --git a/src/domain/javascript/javascriptSemanticResourceLimits.ts b/src/domain/javascript/javascriptSemanticResourceLimits.tsindex 32155e339..5e2ae5a96 100644--- a/src/domain/javascript/javascriptSemanticResourceLimits.ts+++ b/src/domain/javascript/javascriptSemanticResourceLimits.ts@@ -91,7 +91,7 @@ export const semanticResourceLimitsIn = (else if (value.status === "object")for (const property of value.properties) pending.push(property.value);else if (value.status === "array")- for (const item of value.items) pending.push(item);+ for (const item of value.items) pending.push(item.value);}return [...found].sort();};diff --git a/src/domain/javascript/javascriptSemanticReturns.ts b/src/domain/javascript/javascriptSemanticReturns.tsindex 74183f357..d9b84a24b 100644--- a/src/domain/javascript/javascriptSemanticReturns.ts+++ b/src/domain/javascript/javascriptSemanticReturns.ts@@ -1,5 +1,10 @@import * as t from "@babel/types";+import {+ semanticContainer,+ semanticPropertyPointer,+} from "./javascriptSemanticSlots.js";+import type {JavaScriptSemanticCallable,JavaScriptSemanticModuleLink,@@ -244,54 +249,24 @@ const flattenValue = (});return;}- if (value.status === "object") {- coverage.push(- value.unknownProperties- ? { path, status: "partial", omitted: value.omittedProperties }- : { path, status: "complete", omitted: 0 },- );- for (const property of value.properties)- flattenValue(- property.value,- `${path}/${escapePointer(property.name)}`,- fields,- coverage,- property.presence ?? "present",- );+ if ("reason" in value) {+ fields.push({+ path,+ presence,+ state: "unknown",+ value: null,+ reason: value.reason,+ });return;}- if (value.status === "array") {- coverage.push(- value.unknownItems- ? { path, status: "partial", omitted: value.omittedItems }- : { path, status: "complete", omitted: 0 },- );- value.items.forEach((item, index) =>- flattenValue(- item,- `${path}/${String(index)}`,- fields,- coverage,- value.itemPresence?.[index] ?? "present",- ),+ const container = semanticContainer(value);+ coverage.push({ path, ...container.coverage });+ for (const slot of container.slots)+ flattenValue(+ slot.value,+ `${path}${semanticPropertyPointer([slot.name])}`,+ fields,+ coverage,+ slot.presence,);- // Sparse mutation metadata retains uncertain slots without expanding arrays.- for (const [index, itemPresence] of Object.entries(- value.itemPresence ?? {},- )) {- if (Number(index) < value.items.length) continue;- flattenValue(value, `${path}/${index}`, fields, coverage, itemPresence);- }- return;- }- fields.push({- path,- presence,- state: "unknown",- value: null,- reason: value.reason,- });};--const escapePointer = (value: string): string =>- value.replaceAll("~", "~0").replaceAll("/", "~1");diff --git a/src/domain/javascript/javascriptSemanticSlots.ts b/src/domain/javascript/javascriptSemanticSlots.tsnew file mode 100644index 000000000..61b61041d--- /dev/null+++ b/src/domain/javascript/javascriptSemanticSlots.ts@@ -0,0 +1,108 @@+import type {+ JavaScriptSemanticProperty,+ JavaScriptSemanticValue,+} from "./javascriptSemanticValueTypes.js";++/** A container's own slot, using the value lattice's canonical presence model. */+export type JavaScriptSemanticSlot = JavaScriptSemanticProperty;++/** Static container inventory; partial siblings do not weaken retained slots. */+export interface JavaScriptSemanticContainer {+ readonly slots: readonly JavaScriptSemanticSlot[];+ readonly coverage:+ | { readonly status: "complete"; readonly omitted: 0 }+ | { readonly status: "partial"; readonly omitted: number | null };+}++/** Read the same slot inventory for object, array, and return projections. */+export function semanticContainer(+ value: Extract<+ JavaScriptSemanticValue,+ { readonly status: "object" | "array" }+ >,+): JavaScriptSemanticContainer;+export function semanticContainer(+ value: JavaScriptSemanticValue,+): JavaScriptSemanticContainer | null;+export function semanticContainer(+ value: JavaScriptSemanticValue,+): JavaScriptSemanticContainer | null {+ if (value.status === "object")+ return {+ slots: value.properties,+ coverage: value.unknownProperties+ ? { status: "partial", omitted: value.omittedProperties }+ : { status: "complete", omitted: 0 },+ };+ if (value.status === "array")+ return {+ slots: value.items,+ coverage: value.unknownItems+ ? { status: "partial", omitted: value.omittedItems }+ : { status: "complete", omitted: 0 },+ };+ return null;+}++/** Resolve a full static own-property path without conflating missing siblings. */+export const semanticSlotAtPath = (+ value: JavaScriptSemanticValue,+ path: readonly string[],+): JavaScriptSemanticSlot => {+ const leafName = path.at(-1) ?? "";+ let current: JavaScriptSemanticSlot = {+ name: "",+ presence: "present",+ value,+ };+ for (const [index, name] of path.entries()) {+ const container = semanticContainer(current.value);+ if (current.presence !== "present" || container === null)+ return {+ name: leafName,+ presence: "unknown-coverage",+ value:+ "reason" in current.value+ ? {+ ...current.value,+ reason: `${current.value.reason} Cannot continue ${semanticPropertyPointer(path)} through receiver ${semanticPropertyPointer(path.slice(0, index))}.`,+ }+ : {+ status: "unknown",+ reason: `Cannot resolve ${semanticPropertyPointer(path)} through ${current.value.status} receiver ${semanticPropertyPointer(path.slice(0, index))}.`,+ },+ };+ // Array position inventories omit the intrinsic non-enumerable length slot.+ // Its own presence is guaranteed even when no exact length is retained.+ if (current.value.status === "array" && name === "length") {+ current = {+ name,+ presence: "present",+ value: {+ status: "unknown",+ reason: "Array length is present but its value is not retained.",+ },+ };+ continue;+ }+ const observed = container.slots.find((slot) => slot.name === name);+ current = observed ?? {+ name,+ presence:+ container.coverage.status === "complete"+ ? "absent"+ : "unknown-coverage",+ value: {+ status: "unknown",+ reason: `Own property ${name} was not observed.`,+ },+ };+ }+ return current;+};++/** Encode path segments as an unambiguous JSON Pointer, preserving empty keys. */+export const semanticPropertyPointer = (path: readonly string[]): string =>+ path+ .map((key) => `/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`)+ .join("");diff --git a/src/domain/javascript/javascriptSemanticValueTypes.ts b/src/domain/javascript/javascriptSemanticValueTypes.tsindex 9d4917b64..67d4ee06f 100644--- a/src/domain/javascript/javascriptSemanticValueTypes.ts+++ b/src/domain/javascript/javascriptSemanticValueTypes.ts@@ -23,10 +23,7 @@ type JavaScriptSemanticObjectValue = {type JavaScriptSemanticArrayValue = {readonly status: "array";- readonly items: readonly JavaScriptSemanticValue[];- readonly itemPresence?: Readonly<- Record<number, "absent" | "unknown-coverage">- >;+ readonly items: readonly JavaScriptSemanticProperty[];} & (| {readonly unknownItems: false;@@ -56,9 +53,15 @@ export type JavaScriptSemanticValue =readonly resourceLimit?: JavaScriptSemanticResourceLimit;};-/** One statically named object-literal property. */+/** One statically named own slot in an object or array. */export interface JavaScriptSemanticProperty {readonly name: string;readonly value: JavaScriptSemanticValue;- readonly presence?: "unknown-coverage";+ readonly presence: JavaScriptSemanticSlotPresence;}++/** Own-slot presence, independent of its value and sibling coverage. */+export type JavaScriptSemanticSlotPresence =+ | "present"+ | "absent"+ | "unknown-coverage";diff --git a/src/domain/javascript/javascriptSemanticValues.ts b/src/domain/javascript/javascriptSemanticValues.tsindex cf8ca5288..84db35553 100644--- a/src/domain/javascript/javascriptSemanticValues.ts+++ b/src/domain/javascript/javascriptSemanticValues.ts@@ -1,5 +1,7 @@import * as t from "@babel/types";+import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";+import { invalidateSemanticMutationPath } from "./javascriptSemanticMutationValues.js";import type {@@ -195,9 +197,12 @@ const evaluateTemplate = (let candidates = [""];for (let index = 0; index < node.quasis.length; index += 1) {const quasi = node.quasis[index];- // Semantic template evaluation retains its established raw fallback for- // synthetic AST inputs; exact atom readers remain cooked-only.- const text = quasi?.value.cooked ?? quasi?.value.raw ?? "";+ const text = quasi?.value.cooked;+ if (text === undefined || text === null)+ return {+ status: "unknown",+ reason: "Template text has no cooked representation.",+ };if (exceedsSemanticTemplateByteBudget(candidates, [text]))return semanticResourceLimitUnknown("primitive-bytes");candidates = candidates.map((prefix) => `${prefix}${text}`);@@ -235,6 +240,7 @@ const evaluateObject = (for (const [name] of propertiesByName)propertiesByName.set(name, {name,+ presence: "present",value: {status: "unknown",reason: "A later property may overwrite this value.",@@ -268,6 +274,7 @@ const evaluateObject = (}propertiesByName.set(name, {name,+ presence: "present",value: t.isObjectProperty(property)? evaluateExpression(property.value, nestedContext(context)): {@@ -298,8 +305,7 @@ const evaluateArray = (node: t.ArrayExpression,context: EvaluationContext,): JavaScriptSemanticValue => {- const items: JavaScriptSemanticValue[] = [];- const itemPresence: Record<number, "absent"> = {};+ const items: JavaScriptSemanticProperty[] = [];let unknownItems = false;let omittedItems: number | null = 0;for (const element of node.elements) {@@ -310,21 +316,24 @@ const evaluateArray = (break;}if (element === null) {- itemPresence[items.length] = "absent";items.push({- status: "unknown",- reason: "Array hole has no primitive value.",+ name: String(items.length),+ presence: "absent",+ value: { status: "unknown", reason: "Array hole has no own value." },});continue;}- items.push(evaluateExpression(element, nestedContext(context)));+ items.push({+ name: String(items.length),+ presence: "present",+ value: evaluateExpression(element, nestedContext(context)),+ });}return unknownItems- ? { status: "array", items, itemPresence, unknownItems: true, omittedItems }+ ? { status: "array", items, unknownItems: true, omittedItems }: {status: "array",items,- itemPresence,unknownItems: false,omittedItems: 0,};@@ -436,46 +445,16 @@ const projectValue = (value: JavaScriptSemanticValue,projection: readonly (string | number | null)[],): JavaScriptSemanticValue => {- let current = value;- for (const key of projection) {- if (key === null)- return {- status: "unknown",- reason: "Cannot project a dynamic property.",- };- if (current.status === "object" && typeof key === "string") {- const property = current.properties.find(({ name }) => name === key);- if (property === undefined)- return {- status: current.unknownProperties ? "unknown" : "unknown",- reason: `Object property ${key} was not observed.`,- };- current = property.value;- } else if (current.status === "array") {- const index = typeof key === "number" ? key : Number(key);- if (- !Number.isSafeInteger(index) ||- index < 0 ||- String(index) !== String(key)- )- return {- status: "unknown",- reason: `Array property ${String(key)} is not a canonical index.`,- };- const item = current.items[index];- if (item === undefined)- return {- status: "unknown",- reason: `Array item ${String(key)} missing.`,- };- current = item;- } else- return {+ if (projection.includes(null))+ return { status: "unknown", reason: "Cannot project a dynamic property." };+ const path = projection.map((key) => String(key));+ const slot = semanticSlotAtPath(value, path);+ return slot.presence === "present"+ ? slot.value+ : {status: "unknown",- reason: `Cannot project ${String(key)} from ${current.status}.`,+ reason: `Own property ${path.join("/")} is ${slot.presence}.`,};- }- return current;};const provenanceForBinding = (diff --git a/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts b/tests/boundary/filesystem/javascriptExportShapeComparison.test.tsindex 5b1b260e7..5be94b62d 100644--- a/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts+++ b/tests/boundary/filesystem/javascriptExportShapeComparison.test.ts@@ -463,7 +463,7 @@ describe("JavaScript export localized mutation uncertainty", () => {});describe("JavaScript export property presence boundaries", () => {- it("normalizes omitted legacy presence before comparing identical literals and unions", async () => {+ it("rejects return-shape observations that omit required slot presence", async () => {const source ='export default () => ({ kind: "result", count: flag ? 1 : 2, nested: { enabled: true } });';const [left, right] = await analyzeSources({ left: source, right: source });@@ -513,9 +513,14 @@ describe("JavaScript export property presence boundaries", () => {[right, { ...left, graph }],] as const) {const result = compare(sides[0], sides[1]);- expect(result.coverage.paired_variants).toBe(1);- expect(result.changes).toEqual([]);- expect(result.coverage.status).toBe("complete-within-inputs");+ expect(result.coverage.paired_variants).toBe(0);+ expect([result.left.status, result.right.status]).toContain(+ "unavailable",+ );+ expect(result.changes).toEqual([+ expect.objectContaining({ status: "unknown", path: "" }),+ ]);+ expect(result.coverage.status).toBe("partial");}});diff --git a/tests/boundary/mcp/applicationExportShapeMcp.test.ts b/tests/boundary/mcp/applicationExportShapeMcp.test.tsindex 17a0dc22d..a35b92abc 100644--- a/tests/boundary/mcp/applicationExportShapeMcp.test.ts+++ b/tests/boundary/mcp/applicationExportShapeMcp.test.ts@@ -41,7 +41,7 @@ it("executes the advertised export presence example with matching analyzed Evide});expect(response.isError).not.toBe(true);expect(response.structuredContent).toMatchObject({- result: {+ normalized_result: {left: { status: "selected" },right: { status: "selected" },summary: { added: 1, removed: 1, changed: 0, unknown: 0 },@@ -102,7 +102,7 @@ it("traces example semantic modules with their parsed artifact digests", async (});expect(response.isError).not.toBe(true);expect(response.structuredContent).toMatchObject({- result: {+ normalized_result: {nodes: expect.arrayContaining([expect.objectContaining({node_id: module.node_id,@@ -161,10 +161,8 @@ describe("application workflow MCP parity", () => {expect(relativeApplication.isError).not.toBe(true);expect(relativeApplication.structuredContent).toMatchObject({evidence_id: left.value.evidence_id,- result: { input_path: leftAnalysis.input_path },- evidence: {- subject: { local_path: left.value.subject?.local_path },- },+ normalized_result: { input_path: leftAnalysis.input_path },+ subject: { local_path: left.value.subject?.local_path },});const full = await client.callTool({name: "compare_javascript_export_shapes",@@ -172,7 +170,7 @@ describe("application workflow MCP parity", () => {});expect(full.isError).not.toBe(true);expect(full.structuredContent).toMatchObject({- result: {+ normalized_result: {summary: { added: 1, removed: 0, changed: 0, unknown: 0 },property_inventories: expect.arrayContaining([expect.objectContaining({@@ -231,7 +229,7 @@ describe("application workflow MCP parity", () => {});expect(semantic.isError).not.toBe(true);expect(semantic.structuredContent).toMatchObject({- result: {+ normalized_result: {source_evidence_id: left.value.evidence_id,source_graph_id: analyzed.semantic_graph.graph_id,summary: { total_seed_matches: 1 },