Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

test(javascript): consolidate source analysis and export regressions

morlutof517a5a1d7c0
diff --git a/src/application/EnhancedLiteralTracing.test.ts b/src/application/EnhancedLiteralTracing.test.ts
deleted file mode 100644
index 42e61974e..000000000
--- a/src/application/EnhancedLiteralTracing.test.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { ok } from "../domain/result.js";
-import { traceLiteralFeature } from "./EnhancedLiteralTracing.js";
-
-describe("literal feature tracing", () => {
- it("returns matched procedure and string facts with references", async () => {
- const result = await traceLiteralFeature(
- async (name) => {
- if (name === "search_strings")
- return ok([{ address: "0x1000", value: "launch feature" }]);
- if (name === "search_procedures")
- return ok([{ address: "0x2000", value: "launchFeature" }]);
- if (name === "xrefs") return ok([]);
- if (name === "resolve_containing_procedure") return ok(null);
- throw new Error(`Unexpected analysis call: ${name}`);
- },
- { query: "launch feature", case_sensitive: false },
- );
- expect(result).toMatchObject({
- ok: true,
- value: {
- matches: [
- { type: "string", address: "0x1000", value: "launch feature" },
- { type: "procedure", address: "0x2000", value: "launchFeature" },
- ],
- references: [],
- },
- });
- });
-});
diff --git a/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts b/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts
index 63f44337e..ee5809771 100644
--- a/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts
+++ b/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts
@@ -20,37 +20,46 @@ const filesFor = (paths: readonly string[]) =>
]),
);
-const cases = ["#", "?"].flatMap((punctuation) =>
- (["require", "import", undefined] as const).flatMap((moduleKind) =>
- (["literal", "stripped", "both"] as const).map((layout) => ({
- punctuation,
- moduleKind,
- layout,
- })),
- ),
-);
-
describe("module specifier punctuation", () => {
- it.each(cases)(
- "resolves $moduleKind with $punctuation and $layout files",
- ({ punctuation, moduleKind, layout }) => {
+ it.each(["#", "?"])(
+ "keeps CommonJS punctuation and strips URL suffixes for ESM (%s)",
+ (punctuation) => {
const literal = `app/dep.cjs${punctuation}literal.cjs`;
const stripped = "app/dep.cjs";
- const files = filesFor([
- ...(layout !== "stripped" ? [literal] : []),
- ...(layout !== "literal" ? [stripped] : []),
- ]);
- const expected = moduleKind === "require" ? literal : stripped;
- const result = resolveArtifactPathByContext({
+ const commonJs = resolveArtifactPathByContext({
+ declaredPath: `./dep.cjs${punctuation}literal.cjs`,
+ sourcePath: "app/main.js",
+ context: "module-specifier",
+ files: filesFor([literal, stripped]),
+ moduleKind: "require",
+ });
+ expect(commonJs).toMatchObject({
+ resolution_status: "resolved",
+ resolved_path: literal,
+ });
+
+ const esm = resolveArtifactPathByContext({
+ declaredPath: `./dep.cjs${punctuation}literal.cjs`,
+ sourcePath: "app/main.js",
+ context: "module-specifier",
+ files: filesFor([literal, stripped]),
+ moduleKind: "import",
+ });
+ expect(esm).toMatchObject({
+ resolution_status: "resolved",
+ resolved_path: stripped,
+ });
+
+ const noStrippedTarget = resolveArtifactPathByContext({
declaredPath: `./dep.cjs${punctuation}literal.cjs`,
sourcePath: "app/main.js",
context: "module-specifier",
- files,
- ...(moduleKind === undefined ? {} : { moduleKind }),
+ files: filesFor([literal]),
+ moduleKind: "import",
});
- expect(result).toMatchObject({
- resolution_status: files.has(expected) ? "resolved" : "not-found",
- resolved_path: files.has(expected) ? expected : null,
+ expect(noStrippedTarget).toMatchObject({
+ resolution_status: "not-found",
+ resolved_path: null,
});
},
);
diff --git a/src/application/javascript/JavaScriptReturnShapeProjection.test.ts b/src/application/javascript/JavaScriptReturnShapeProjection.test.ts
deleted file mode 100644
index 11d91c02f..000000000
--- a/src/application/javascript/JavaScriptReturnShapeProjection.test.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
-import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { projectJavaScriptExportReturnShapes } from "./JavaScriptReturnShapeProjection.js";
-
-const projectReturns = (body: string) => {
- const ir = analyzeJavaScriptSemantics(`export function result() { ${body} }`);
- const link = ir.moduleLinks.find(
- ({ exportedName }) => exportedName === "result",
- );
- if (link === undefined) throw new Error("Expected the result export");
- const projected = projectJavaScriptExportReturnShapes({
- ir,
- link,
- modulePath: "fixture.js",
- baseCoverage: completeApplicationCoverage(),
- });
- if (projected === null) throw new Error("Expected exported return shapes");
- return projected;
-};
-
-const unknownBranchField = {
- path: "",
- state: "unknown",
- value: null,
- reason: "Branches have incompatible values.",
-};
-
-describe("exported primitive union return shapes", () => {
- const conditionalCases = [
- "missing",
- "unsupported()",
- '({ key: "value" })',
- '["value"]',
- '+"invalid"',
- ].flatMap((other) => [
- `condition ? (choice ? "one" : "two") : ${other}`,
- `condition ? ${other} : (choice ? "one" : "two")`,
- ]);
- const logicalCases = [
- { operator: "||", known: '(choice ? "" : "one")' },
- { operator: "&&", known: '(choice ? 0 : "one")' },
- { operator: "??", known: '(choice ? null : "one")' },
- ].flatMap(({ operator, known }) => [
- `${known} ${operator} missing`,
- `missing ${operator} ${known}`,
- ]);
-
- it.each([...conditionalCases, ...logicalCases])(
- "projects an unknown field instead of a definite union for %s",
- (expression) => {
- const projected = projectReturns(`return ${expression};`);
-
- expect(projected.properties.static_return_shapes).toEqual([
- {
- source_range: expect.any(Object),
- value_status: "ambiguous",
- fields: [unknownBranchField],
- property_coverage: [],
- },
- ]);
- // Complete return-site collection does not make its values known.
- expect(projected.properties.return_shape_coverage).toEqual({
- status: "complete",
- retained_return_sites: 1,
- omitted_return_sites: 0,
- omitted_fields: 0,
- omitted_property_coverage: 0,
- projection_complete: true,
- });
- expect(projected.coverage).toEqual(completeApplicationCoverage());
- expect(projected.limitations).toContain(
- "Return shapes are inferred from inert syntax and do not prove runtime behavior.",
- );
- },
- );
-
- it("keeps an incompatible object field unknown beside a known literal", () => {
- const projected = projectReturns(`
- return {
- kind: "result",
- value: condition ? (choice ? "one" : "two") : missing,
- };
- `);
- expect(projected.properties.static_return_shapes).toEqual([
- {
- source_range: expect.any(Object),
- value_status: "object",
- fields: [
- { path: "/kind", state: "literal", value: "result", reason: null },
- { ...unknownBranchField, path: "/value" },
- ],
- property_coverage: [{ path: "", status: "complete", omitted: 0 }],
- },
- ]);
- });
-
- it("retains valid nested unions, duplicates, and null alternatives", () => {
- const projected = projectReturns(`
- return condition
- ? (choice ? "two" : "one")
- : (other ? "one" : null);
- `);
- expect(projected.properties.static_return_shapes).toEqual([
- {
- source_range: expect.any(Object),
- value_status: "union",
- fields: [
- {
- path: "",
- state: "union",
- value: [null, "one", "two"],
- reason: null,
- },
- ],
- property_coverage: [],
- },
- ]);
- });
-
- it("preserves three independent direct returns without merging their values", () => {
- const projected = projectReturns(`
- if (condition) return choice ? "one" : "two";
- if (other) return missing;
- return { kind: "object" };
- `);
- expect(projected.properties.static_return_shapes).toEqual([
- {
- source_range: expect.any(Object),
- value_status: "union",
- fields: [
- { path: "", state: "union", value: ["one", "two"], reason: null },
- ],
- property_coverage: [],
- },
- {
- source_range: expect.any(Object),
- value_status: "unknown",
- fields: [
- {
- path: "",
- state: "unknown",
- value: null,
- reason: "Unbound identifier missing.",
- },
- ],
- property_coverage: [],
- },
- {
- source_range: expect.any(Object),
- value_status: "object",
- fields: [
- { path: "/kind", state: "literal", value: "object", reason: null },
- ],
- property_coverage: [{ path: "", status: "complete", omitted: 0 }],
- },
- ]);
- expect(projected.properties.return_shape_coverage).toMatchObject({
- status: "complete",
- retained_return_sites: 3,
- omitted_return_sites: 0,
- projection_complete: true,
- });
- });
-});
diff --git a/src/domain/javascript/electronStaticAnalysisOptions.test.ts b/src/domain/javascript/electronStaticAnalysisOptions.test.ts
index 16569d46f..024df7582 100644
--- a/src/domain/javascript/electronStaticAnalysisOptions.test.ts
+++ b/src/domain/javascript/electronStaticAnalysisOptions.test.ts
@@ -2,156 +2,46 @@ import { describe, expect, it } from "vitest";
import { analyzeJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
-describe.each(["webPreferences", "serviceName"] as const)(
- "Electron %s option lookup",
- (name) => {
- const value =
- name === "webPreferences"
- ? '{ preload: "./kept.js", sandbox: true }'
- : '"kept"';
- const explicit = `${name}: ${value}`;
- const method = `${name}() { return ${value}; }`;
- const getter = `get ${name}() { return ${value}; }`;
- const setter = `set ${name}(value) {}`;
-
- const explicitCases = [
- ["plain key", explicit],
- ["quoted key", `"${name}": ${value}`],
- ["computed string key", `["${name}"]: ${value}`],
- ["duplicate key", `${name}: null, ${explicit}`],
- ["computed duplicate key", `${name}: null, ["${name}"]: ${value}`],
- ["earlier spread", `...options, ${explicit}`],
- ["earlier computed identifier", `[key]: null, ${explicit}`],
- ["earlier computed expression", `[getKey()]: null, ${explicit}`],
- ["earlier getter", `${getter}, ${explicit}`],
- ["earlier method", `${method}, ${explicit}`],
- ["unrelated later key", `${explicit}, title: "title"`],
- ["unrelated computed literal", `${explicit}, ["title"]: null`],
- ["unrelated numeric key", `${explicit}, [1]: null`],
- ["unrelated empty key", `${explicit}, [""]: null`],
- ["unrelated getter", `${explicit}, get title() { return "title"; }`],
- ];
-
- it.each(explicitCases)(
- "retains the explicit value with %s",
- (_, members) => {
- const analysis = analyzeOption(name, `{ ${members} }`);
- expect(analysis.parse_status).toBe("complete");
- if (name === "webPreferences") {
- expect(analysis.electron.browser_windows).toEqual([
- expect.objectContaining({
- options_status: "object-literal",
- web_preferences_status: "object-literal",
- preload_path: "./kept.js",
- preload_resolution_context: "module-specifier",
- web_preferences: [
- { name: "preload", value: literal("./kept.js") },
- { name: "sandbox", value: literal(true) },
- ],
- }),
- ]);
- } else {
- expect(analysis.electron.utility_processes).toEqual([
- expect.objectContaining({ service_name: "kept" }),
- ]);
- }
- },
- );
-
- const dynamicCases = [
- ["same-spelled computed binding", `[${name}]: ${value}`],
- ["different computed binding", `[key]: ${value}`],
- ["computed expression", `[getKey()]: ${value}`],
- ["unevaluated template key", `[\`${name}\`]: ${value}`],
- ["spread only", "...options"],
- ["later spread", `${explicit}, ...options`],
- ["later computed binding", `${explicit}, [key]: null`],
- ["later computed expression", `${explicit}, [getKey()]: null`],
- ["exact getter", getter],
- ["exact setter", setter],
- ["exact method", method],
- ["computed string method", `["${name}"]() { return ${value}; }`],
- ["overriding getter", `${explicit}, ${getter}`],
- ["overriding setter", `${explicit}, ${setter}`],
- ["overriding method", `${explicit}, ${method}`],
- ["dynamic explicit value", `${name}: dynamicValue`],
- ["null explicit value", `${name}: null`],
- ["duplicate null value", `${explicit}, ${name}: null`],
- ];
-
- it.each(dynamicCases)("preserves uncertainty for %s", (_, members) => {
- expectUnknownOption(name, `{ ${members} }`, "object-literal");
+describe("Electron option evidence", () => {
+ it("keeps the final explicit preload and service name with unrelated keys", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ new BrowserWindow({ webPreferences: { preload: "./kept.js", sandbox: true }, title: "App" });
+ utilityProcess.fork("./worker.js", [], { serviceName: "kept", cwd: "/app" });
+ `);
+
+ expect(analysis.parse_status).toBe("complete");
+ expect(analysis.electron.browser_windows[0]).toMatchObject({
+ preload_path: "./kept.js",
+ preload_resolution_context: "module-specifier",
+ web_preferences: [
+ { name: "preload", value: { status: "literal", value: "./kept.js" } },
+ { name: "sandbox", value: { status: "literal", value: true } },
+ ],
});
+ expect(analysis.electron.utility_processes[0]).toMatchObject({
+ module_path: "./worker.js",
+ service_name: "kept",
+ });
+ });
- it.each(["null", "options"])(
- "preserves nonliteral options %s",
- (options) => {
- expectUnknownOption(name, options, "dynamic");
- },
- );
-
- it.each(["", "{}", '{ title: "title", ["other"]: null }'])(
- "reports an omitted option in %s without inventing a default",
- (options) => {
- const analysis = analyzeOption(name, options);
- expect(analysis.parse_status).toBe("complete");
- if (name === "webPreferences")
- expect(analysis.electron.browser_windows[0]).toMatchObject({
- options_status: options === "" ? "missing" : "object-literal",
- web_preferences_status: "missing",
- web_preferences: [],
- preload_path: null,
- preload_resolution_context: null,
- });
- else
- expect(
- analysis.electron.utility_processes[0]?.service_name,
- ).toBeNull();
- },
- );
- },
-);
-
-type OptionName = "webPreferences" | "serviceName";
-
-const analyzeOption = (name: OptionName, options: string) =>
- analyzeJavaScriptStaticSource(`
- const webPreferences = "title";
- const serviceName = "env";
- ${
- name === "webPreferences"
- ? `new BrowserWindow(${options});`
- : `utilityProcess.fork("./worker.js", []${options === "" ? "" : `, ${options}`});`
- }
- `);
-
-const literal = (value: string | boolean) => ({
- status: "literal",
- value,
- expression: null,
-});
+ it("keeps values unknown when a later computed key can override them", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ new BrowserWindow({ webPreferences: { preload: "./maybe.js" }, [key]: null });
+ utilityProcess.fork("./worker.js", [], { serviceName: "maybe", [key]: null });
+ `);
-const expectUnknownOption = (
- name: OptionName,
- options: string,
- optionsStatus: "object-literal" | "dynamic",
-): void => {
- const analysis = analyzeOption(name, options);
- expect(analysis.parse_status).toBe("partial");
- expect(analysis.parse_error_count).toBe(0);
- expect(analysis.limitations.join(" ")).toContain("remain unknown");
- if (name === "webPreferences")
+ expect(analysis.parse_status).toBe("partial");
+ expect(analysis.parse_error_count).toBe(0);
+ expect(analysis.limitations.join(" ")).toContain("remain unknown");
expect(analysis.electron.browser_windows[0]).toMatchObject({
- options_status: optionsStatus,
- web_preferences_status: "dynamic",
- web_preferences: [],
preload_path: null,
preload_resolution_context: null,
+ web_preferences_status: "dynamic",
+ web_preferences: [],
});
- else
expect(analysis.electron.utility_processes[0]).toMatchObject({
module_path: "./worker.js",
- module_expression: null,
service_name: null,
});
-};
+ });
+});
diff --git a/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts b/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts
index acb1fe1f1..3ab413e85 100644
--- a/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts
+++ b/src/domain/javascript/javascriptExportShapeComparisonSchemas.test.ts
@@ -1,9 +1,6 @@
import { expect, it } from "vitest";
-import {
- javaScriptExportShapeComparisonResultSchema,
- projectedExportReturnShapesSchema,
-} from "./javascriptExportShapeComparisonSchemas.js";
+import { projectedExportReturnShapesSchema } from "./javascriptExportShapeComparisonSchemas.js";
const projectionWithField = (field: unknown) => ({
semantic_role: "export-return-shapes",
@@ -54,104 +51,3 @@ it("parses projected fields into literal, union, or unknown values", () => {
).success,
).toBe(true);
});
-
-it("accepts every projected return site and field without presentation caps", () => {
- const fields = Array.from({ length: 65 }, (_, index) => ({
- path: `/field-${String(index)}`,
- state: "literal",
- value: index,
- reason: null,
- }));
- const propertyCoverage = fields.map(({ path }) => ({
- path,
- status: "complete",
- omitted: 0,
- }));
- const shapes = Array.from({ length: 33 }, () => ({
- source_range: {
- start: { line: 1, column: 0 },
- end: { line: 1, column: 10 },
- },
- value_status: "object",
- fields,
- property_coverage: propertyCoverage,
- }));
-
- expect(
- projectedExportReturnShapesSchema.parse({
- ...projectionWithField(fields[0]),
- static_return_shapes: shapes,
- return_shape_coverage: {
- status: "complete",
- retained_return_sites: shapes.length,
- omitted_return_sites: 0,
- omitted_fields: 0,
- omitted_property_coverage: 0,
- projection_complete: true,
- },
- }).static_return_shapes,
- ).toHaveLength(33);
-});
-
-it("accepts complete candidate and change inventories without page ceilings", () => {
- const evidenceId = `ev_${"a".repeat(64)}`;
- const graphId = `jag_${"b".repeat(64)}`;
- const selector = {
- evidence_id: evidenceId,
- graph_id: graphId,
- requested_module_path: "index.js",
- requested_export_name: "render",
- candidates: Array.from({ length: 1_001 }, (_, index) => ({
- node_id: `jag_node_${index.toString(16).padStart(64, "0")}`,
- module_path: "index.js",
- export_name: "render",
- matches_requested_module: true,
- matches_requested_export: true,
- })),
- omitted_candidates: 0,
- status: "missing",
- selected_node_id: null,
- };
- const changes = Array.from({ length: 10_001 }, (_, index) => ({
- change_id: `jesc_change_${index.toString(16).padStart(64, "0")}`,
- status: "unknown",
- path: `/field-${String(index)}`,
- discriminant: null,
- left: { availability: "absent" },
- right: { availability: "absent" },
- left_source_range: null,
- right_source_range: null,
- evidence_links: [evidenceId, `ev_${"c".repeat(64)}`],
- limitations: [],
- }));
-
- expect(
- javaScriptExportShapeComparisonResultSchema.parse({
- comparison_id: `jesc_${"d".repeat(64)}`,
- left: selector,
- right: { ...selector, graph_id: `jag_${"e".repeat(64)}` },
- summary: { added: 0, removed: 0, changed: 0, unknown: changes.length },
- changes,
- coverage: {
- status: "complete-within-inputs",
- left_graph_status: "complete",
- right_graph_status: "complete",
- paired_variants: 0,
- unpaired_left_variants: 0,
- unpaired_right_variants: 0,
- omitted_left_variants: 0,
- omitted_right_variants: 0,
- left_source_omitted_variants: 0,
- right_source_omitted_variants: 0,
- left_omitted_fields: 0,
- right_omitted_fields: 0,
- left_omitted_property_coverage: 0,
- right_omitted_property_coverage: 0,
- omitted_candidates: 0,
- omitted_changes: 0,
- },
- evidence_links: [evidenceId, `ev_${"c".repeat(64)}`],
- limitations: [],
- }).changes,
- ).toHaveLength(10_001);
-});
diff --git a/src/domain/javascript/javascriptFeatureSeed.array_members.test.ts b/src/domain/javascript/javascriptFeatureSeed.array_members.test.ts
index bc3828fb5..15a6f8445 100644
--- a/src/domain/javascript/javascriptFeatureSeed.array_members.test.ts
+++ b/src/domain/javascript/javascriptFeatureSeed.array_members.test.ts
@@ -253,56 +253,58 @@ describe("feature seed selection controls", () => {
});
describe("public feature trace from contextBridge source members", () => {
- it.each(matchingModes)(
- "traces $match / $value / case-sensitive $case_sensitive",
- (mode) => {
- const graph = contextBridgeGraph();
- const before = structuredClone(graph);
- const input = {
- sourceEvidenceId,
- graph,
- nativeEvidence: [],
- direction: "both" as const,
- };
- const generic = traceApplicationFeature({
- ...input,
- seed: { kind: "string", ...mode },
- });
- const typed = traceApplicationFeature({
- ...input,
- seed: { kind: "api", ...mode },
- });
+ it("traces one exact member seed through the public feature workflow", () => {
+ const mode = {
+ value: "openProject",
+ match: "exact" as const,
+ case_sensitive: true,
+ };
+ const graph = contextBridgeGraph();
+ const before = structuredClone(graph);
+ const input = {
+ sourceEvidenceId,
+ graph,
+ nativeEvidence: [],
+ direction: "both" as const,
+ };
+ const generic = traceApplicationFeature({
+ ...input,
+ seed: { kind: "string", ...mode },
+ });
+ const typed = traceApplicationFeature({
+ ...input,
+ seed: { kind: "api", ...mode },
+ });
- expect(typed.coverage).toEqual({
- status: "complete-within-source",
- source_graph_status: "complete",
- total_seed_matches: 1,
- });
- expect(typed.seed_matches).toEqual(generic.seed_matches);
- expect(typed.seed_matches).toEqual([
- {
- node_id: graph.nodes[0]?.node_id,
- kind: "context-bridge-api",
- basis: "property",
- field: "observations[0].properties.members[1]",
- },
- ]);
- expect(typed.graph?.nodes).toEqual(graph.nodes);
- expect(typed.graph?.edges).toEqual([]);
- expect(typed.evidence_links).toEqual([sourceEvidenceId]);
- expect(typed.summary).toMatchObject({
- matched_seeds: 1,
- traced_nodes: 1,
- traced_edges: 0,
- observed_facts: 1,
- inferred_facts: 0,
- unknown_facts: 0,
- unavailable_facts: 0,
- });
- expect(typed.native_handoffs).toEqual([]);
- expect(graph).toEqual(before);
- },
- );
+ expect(typed.coverage).toEqual({
+ status: "complete-within-source",
+ source_graph_status: "complete",
+ total_seed_matches: 1,
+ });
+ expect(typed.seed_matches).toEqual(generic.seed_matches);
+ expect(typed.seed_matches).toEqual([
+ {
+ node_id: graph.nodes[0]?.node_id,
+ kind: "context-bridge-api",
+ basis: "property",
+ field: "observations[0].properties.members[1]",
+ },
+ ]);
+ expect(typed.graph?.nodes).toEqual(graph.nodes);
+ expect(typed.graph?.edges).toEqual([]);
+ expect(typed.evidence_links).toEqual([sourceEvidenceId]);
+ expect(typed.summary).toMatchObject({
+ matched_seeds: 1,
+ traced_nodes: 1,
+ traced_edges: 0,
+ observed_facts: 1,
+ inferred_facts: 0,
+ unknown_facts: 0,
+ unavailable_facts: 0,
+ });
+ expect(typed.native_handoffs).toEqual([]);
+ expect(graph).toEqual(before);
+ });
it("keeps a missing member explicit without changing source coverage", () => {
const graph = contextBridgeGraph();
diff --git a/src/domain/javascript/javascriptRecovery.test.ts b/src/domain/javascript/javascriptRecovery.test.ts
index 5f9a2b687..4a48a44b0 100644
--- a/src/domain/javascript/javascriptRecovery.test.ts
+++ b/src/domain/javascript/javascriptRecovery.test.ts
@@ -2,19 +2,6 @@ import { describe, expect, it } from "vitest";
import { javascriptRecoveryInputSchema } from "./javascriptRecovery.js";
describe("JavaScript recovery requests", () => {
- it("defaults omitted transform metadata without requiring engine confirmations", () => {
- expect(
- javascriptRecoveryInputSchema.parse({
- path: "/tmp/bundle.js",
- output_directory: "/tmp/recovered",
- }),
- ).toEqual({
- path: "/tmp/bundle.js",
- output_directory: "/tmp/recovered",
- extraction_mode: "structural",
- rewrite_level: "standard",
- });
- });
it.each([
{ path: "", output_directory: "/tmp/recovered" },
{ path: "/tmp/bundle.js" },
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.builtin_defaults.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.builtin_defaults.test.ts
index 0e4b2c22a..15a4619c3 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.builtin_defaults.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.builtin_defaults.test.ts
@@ -1,39 +1,15 @@
import { expect, it } from "vitest";
+
import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js";
-it.each(["namespace", "default", "named-default"])(
- "retains Node built-in effects from %s imports",
- (mode) => {
- const imports = ["fs", "child_process", "timers", "http"]
- .map((name, index) => {
- const declaration =
- mode === "namespace"
- ? `* as m${String(index)}`
- : mode === "default"
- ? `m${String(index)}`
- : `{default as m${String(index)}}`;
- return `import ${declaration} from 'node:${name}';`;
- })
- .join("\n");
- const ir = analyzeJavaScriptSemantics(`${imports}
- const text = m0.readFileSync('config.json','utf8');
- const stream = m0.createReadStream('config.json'); stream.destroy();
- const child = m1.spawn('/usr/bin/tool', ['--version']);
- const timer = m2.setTimeout(work,1000); m2.clearTimeout(timer);
- const request = m3.get('http://localhost/');
+it("does not assign built-in APIs to unrelated or shadowed bindings", () => {
+ const ir = analyzeJavaScriptSemantics(`
+ import fs from "./fs.js";
+ import { constants as constantsFs } from "node:fs";
+ fs.createReadStream("config.json");
+ constantsFs.createReadStream("config.json");
+ function run(fs) { fs.createReadStream("config.json"); }
`);
- expect(ir.configurationOperations).toHaveLength(1);
- expect(ir.resourceOperations).toHaveLength(2);
- expect(ir.childProcessSpawns).toHaveLength(1);
- expect(ir.timerOperations).toHaveLength(2);
- expect(ir.requestOperations).toHaveLength(1);
- },
-);
-it.each([
- "import fs from './fs.js'; fs.createReadStream('config.json');",
- "import {constants as fs} from 'node:fs'; fs.createReadStream('config.json');",
- "function run(fs) { fs.createReadStream('config.json'); }",
-])("does not invent a built-in namespace for %s", (source) => {
- expect(analyzeJavaScriptSemantics(source).resourceOperations).toEqual([]);
+ expect(ir.resourceOperations).toEqual([]);
});
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts
index 78fea9845..880aae06c 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts
@@ -155,19 +155,6 @@ describe("JavaScript semantic analysis: calls 2", () => {
]);
});
- it("retains every promise operation found in the finite source", () => {
- const ir = analyzeJavaScriptSemantics(
- `
- Promise.resolve(1);
- Promise.resolve(2);
- Promise.resolve(3);
- `,
- );
-
- expect(ir.promiseOperations).toHaveLength(3);
- expect(ir.coverage.status).toBe("complete");
- });
-
it("fingerprints formatting and local-name changes identically", () => {
const left = analyzeJavaScriptSemantics(`
function calculate(value) {
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts
index 9d27e0ed5..e9f8d8159 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.member_depth.test.ts
@@ -1,67 +1,43 @@
import * as t from "@babel/types";
import { expect, it } from "vitest";
-import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js";
+import {
+ analyzeJavaScriptSemantics,
+ analyzeParsedJavaScriptSemantics,
+} from "./javascriptSemanticAnalysis.js";
import { onlyBinding, origin } from "./javascriptSemanticAnalysis.fixture.js";
import { parseJavaScriptSource } from "./javascriptSourceParser.js";
import { calleeName } from "./javascriptStaticAnalysisHelpers.js";
-import { analyzeJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
+import { analyzeParsedJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
const memberChain = ".next".repeat(12_000);
+const ordinaryMemberChain = ".next".repeat(64);
-it("retains native addon observations through a deep member initializer", () => {
- const analysis = analyzeJavaScriptStaticSource(
- `const value = require("./addon.node")${memberChain}.last[""];`,
+it("preserves a 12,000-member native import through both analyzers", () => {
+ const parsed = parseJavaScriptSource(
+ `const value = require("./addon.node")${memberChain}.last; const ordinary = root.next.last;`,
);
- expect(analysis.electron.native_addon_bindings).toEqual([
+ if (parsed === null) throw new Error("Expected valid JavaScript");
+
+ const staticAnalysis = analyzeParsedJavaScriptStaticSource("", parsed);
+ const ir = analyzeParsedJavaScriptSemantics(parsed);
+ expect(staticAnalysis.parse_status).toBe("complete");
+ expect(staticAnalysis.electron.native_addon_bindings).toEqual([
expect.objectContaining({ specifier: "./addon.node", members: ["last"] }),
]);
- expect(analysis.parse_error_count).toBe(0);
-});
-
-it("keeps a deep non-native initializer outside native addon observations", () => {
- const analysis = analyzeJavaScriptStaticSource(
- `const value = root${memberChain}.last;`,
- );
- expect(analysis.electron.native_addon_bindings).toEqual([]);
- expect(analysis.parse_status).toBe("complete");
-});
-
-it("retains unknown value diagnostics and references after a deep member initializer", () => {
- const ir = analyzeJavaScriptSemantics(
- `const value = root${memberChain}.last;`,
- );
expect(ir.coverage).toEqual({ status: "complete", omittedCount: 0 });
- expect(onlyBinding(ir, "value")).toMatchObject({
- value: { status: "unknown", reason: "Cannot project last from unknown." },
- provenance: { status: "unknown", reason: "Unbound identifier root." },
- });
- expect(ir.references.map(({ name, role }) => ({ name, role }))).toEqual([
- { name: "root", role: "read" },
- ]);
-});
-
-it.each([
- `const value = require("./dependency.js")${memberChain}[""].last;`,
- `const dependency = require("./dependency.js"); const value = dependency${memberChain}[""].last;`,
- `const value = require("./dependency.js")?.next${memberChain}[""].last;`,
-])("preserves the full literal module path (case %#)", (source) => {
- const ir = analyzeJavaScriptSemantics(source);
const path = origin(onlyBinding(ir, "value"));
- expect(path.specifier).toBe("./dependency.js");
+ expect(path.specifier).toBe("./addon.node");
expect(path.importedPath).toEqual([
- ...(source.includes("?.next") ? ["next"] : []),
...Array.from({ length: 12_000 }, () => "next"),
- "",
"last",
]);
- expect(ir.coverage.status).toBe("complete");
});
it("retains a deep CommonJS re-export path without inventing dynamic module links", () => {
const ir = analyzeJavaScriptSemantics(`
- module.exports.result = require("./dependency.js")${memberChain}.last;
- const dynamic = require("./other.js")${memberChain}[key].last;
+ module.exports.result = require("./dependency.js")${ordinaryMemberChain}.last;
+ const dynamic = require("./other.js")${ordinaryMemberChain}[key].last;
`);
expect(ir.moduleLinks).toEqual([
expect.objectContaining({
@@ -80,7 +56,7 @@ it("retains a deep CommonJS re-export path without inventing dynamic module link
it("invalidates a deep mutation while retaining unrelated literal properties", () => {
const ir = analyzeJavaScriptSemantics(`
const root = { untouched: "retained" };
- root${memberChain}.last = 1;
+ root${ordinaryMemberChain}.last = 1;
const value = root.untouched;
`);
expect(onlyBinding(ir, "root").value).toEqual({
@@ -98,7 +74,7 @@ it("invalidates a deep mutation while retaining unrelated literal properties", (
});
it("retains the complete location and unresolved target of a deep call", () => {
- const callee = `root${memberChain}.last`;
+ const callee = `root${ordinaryMemberChain}.last`;
const ir = analyzeJavaScriptSemantics(`${callee}();`);
expect(ir.callSites).toEqual([
expect.objectContaining({
@@ -115,7 +91,7 @@ it("retains the complete location and unresolved target of a deep call", () => {
it("retains deep default values without confusing their reads with parameter bindings", () => {
const ir = analyzeJavaScriptSemantics(
- `export function inspect(value = root${memberChain}.last) { return value; }`,
+ `export function inspect(value = root${ordinaryMemberChain}.last) { return value; }`,
);
expect(ir.references.map(({ name, role }) => ({ name, role }))).toEqual([
{ name: "root", role: "read" },
@@ -126,7 +102,7 @@ it("retains deep default values without confusing their reads with parameter bin
it("keeps a shadowed require local through a deep member initializer", () => {
const ir = analyzeJavaScriptSemantics(
- `function inspect(require) { const value = require("./dependency.js")${memberChain}.last; return value; }`,
+ `function inspect(require) { const value = require("./dependency.js")${ordinaryMemberChain}.last; return value; }`,
);
expect(ir.moduleLinks).toEqual([]);
expect(onlyBinding(ir, "value").provenance.origins).toEqual([]);
@@ -140,7 +116,7 @@ it.each([
["root[0].last()", "root.0.last"],
["root[key].last()", "root.[computed@5].last"],
["root?.first.last()", "root.first.last"],
- [`root${memberChain}.last()`, `root${memberChain}.last`],
+ [`root${ordinaryMemberChain}.last()`, `root${ordinaryMemberChain}.last`],
])("preserves exact callee syntax (case %#)", (source, expected) => {
const file = parseJavaScriptSource(source);
const statement = file?.program.body[0];
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts
index 25e02aefa..e6a06e728 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts
@@ -18,6 +18,19 @@ const valueOf = (expression: string) =>
analyzeJavaScriptSemantics(`const answer = ${expression};`),
"answer",
).value;
+const valuesOf = (expressions: readonly string[]) => {
+ const ir = analyzeJavaScriptSemantics(
+ expressions
+ .map(
+ (expression, index) =>
+ `const candidate${String(index)} = ${expression};`,
+ )
+ .join("\n"),
+ );
+ return expressions.map(
+ (_, index) => topLevelBinding(ir, `candidate${String(index)}`).value,
+ );
+};
describe("conditional primitive unions", () => {
const cases = conditionalCandidates.flatMap((known) =>
@@ -35,11 +48,11 @@ describe("conditional primitive unions", () => {
]),
);
- it.each(cases)("preserves incompatible alternatives in %s", (expression) => {
- expect(valueOf(expression)).toEqual(incompatibleValue);
+ it("preserves incompatible alternatives across conditional expressions", () => {
+ expect(valuesOf(cases)).toEqual(cases.map(() => incompatibleValue));
});
- it.each([
+ const exactCases = [
[
'condition ? (choice ? "two" : "one") : "three"',
{ status: "union", values: ["one", "three", "two"] },
@@ -69,8 +82,12 @@ describe("conditional primitive unions", () => {
{ status: "union", values: [null, "one", "two"] },
],
["condition ? null : null", { status: "literal", value: null }],
- ])("retains exact primitive candidates in %s", (expression, expected) => {
- expect(valueOf(expression)).toEqual(expected);
+ ] as const;
+
+ it("retains exact primitive candidates across conditional expressions", () => {
+ expect(valuesOf(exactCases.map(([expression]) => expression))).toEqual(
+ exactCases.map(([, expected]) => expected),
+ );
});
it("propagates an incompatible nested branch through an outer union", () => {
@@ -119,11 +136,11 @@ describe("logical primitive unions", () => {
),
);
- it.each(cases)("preserves unresolved alternatives in %s", (expression) => {
- expect(valueOf(expression)).toEqual(incompatibleValue);
+ it("preserves unresolved alternatives across logical expressions", () => {
+ expect(valuesOf(cases)).toEqual(cases.map(() => incompatibleValue));
});
- it.each([
+ const exactCases = [
[
'(choice ? "" : "one") || "two"',
{ status: "union", values: ["", "one", "two"] },
@@ -138,19 +155,24 @@ describe("logical primitive unions", () => {
],
['"one" || "one"', { status: "literal", value: "one" }],
["null ?? null", { status: "literal", value: null }],
- ])(
- "retains the conservative primitive union in %s",
- (expression, expected) => {
- expect(valueOf(expression)).toEqual(expected);
- },
- );
+ ] as const;
+
+ it("retains conservative primitive unions across logical expressions", () => {
+ expect(valuesOf(exactCases.map(([expression]) => expression))).toEqual(
+ exactCases.map(([, expected]) => expected),
+ );
+ });
- it.each([
+ const unevaluatedCases = [
'true ? "one" : missing',
'"one" || missing',
"false && missing",
'"one" ?? missing',
- ])("does not introduce short-circuit evaluation for %s", (expression) => {
- expect(valueOf(expression)).toEqual(incompatibleValue);
+ ];
+
+ it("does not introduce short-circuit evaluation", () => {
+ expect(valuesOf(unevaluatedCases)).toEqual(
+ unevaluatedCases.map(() => incompatibleValue),
+ );
});
});
diff --git a/src/domain/javascript/javascriptSemanticQuerySchemas.test.ts b/src/domain/javascript/javascriptSemanticQuerySchemas.test.ts
index a4f334163..ab64cfe00 100644
--- a/src/domain/javascript/javascriptSemanticQuerySchemas.test.ts
+++ b/src/domain/javascript/javascriptSemanticQuerySchemas.test.ts
@@ -1,28 +1,8 @@
import { expect, it } from "vitest";
-import {
- javaScriptSemanticQueryInputSchema,
- javaScriptSemanticQueryResultSchema,
-} from "./javascriptSemanticQuerySchemas.js";
+import { javaScriptSemanticQueryInputSchema } from "./javascriptSemanticQuerySchemas.js";
-it("accepts long selectors and complete relation and class selections", () => {
- const longText = "x".repeat(16_385);
- const result = javaScriptSemanticQueryInputSchema.parse({
- seed: { kind: "endpoint", value: longText },
- direction: "forward-influence",
- allowed_relations: Array(2).fill("calls"),
- expected: {
- role: "sink",
- classes: Array(25).fill("module"),
- },
- });
-
- expect(result.seed).toEqual({ kind: "endpoint", value: longText });
- expect(result.allowed_relations).toHaveLength(2);
- expect(result.expected?.classes).toHaveLength(25);
-});
-
-it("rejects the inert source-map authority setting", () => {
+it("rejects a source-map authority setting that the query does not consume", () => {
expect(
javaScriptSemanticQueryInputSchema.safeParse({
seed: { kind: "endpoint", value: "/api" },
@@ -31,36 +11,3 @@ it("rejects the inert source-map authority setting", () => {
}).success,
).toBe(false);
});
-
-it("accepts every reported limitation without a count ceiling", () => {
- const limitations = Array.from(
- { length: 1_001 },
- (_, index) => `gap-${index}`,
- );
- const id = "a".repeat(64);
-
- const result = javaScriptSemanticQueryResultSchema.parse({
- query_id: `jsrq_${id}`,
- source_graph_id: `jsrg_${id}`,
- seed: { kind: "literal", value: null },
- direction: "forward-influence",
- status: "no-match",
- seed_node_ids: [],
- nodes: [],
- relations: [],
- unknowns: [],
- expected_match_node_ids: [],
- summary: {
- total_seed_matches: 0,
- traversed_nodes: 0,
- traversed_relations: 0,
- traversed_functions: 0,
- traversed_modules: 0,
- relevant_unknowns: 0,
- },
- coverage: { status: "complete" },
- limitations,
- });
-
- expect(result.limitations).toHaveLength(1_001);
-});
diff --git a/src/domain/javascript/javascriptSemanticTraversal.test.ts b/src/domain/javascript/javascriptSemanticTraversal.test.ts
deleted file mode 100644
index 482afe2b9..000000000
--- a/src/domain/javascript/javascriptSemanticTraversal.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import * as t from "@babel/types";
-import { expect, it } from "vitest";
-
-import { parseJavaScriptSource } from "./javascriptSourceParser.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-
-it("preserves source-tree enter/exit order and detached ancestor snapshots", () => {
- const parsed = parseJavaScriptSource("const answer = first + second;");
- if (parsed === null)
- throw new TypeError("Expected a parsed JavaScript fixture");
- const visits: string[] = [];
- const snapshots: (readonly t.Node[])[] = [];
- traverseJavaScriptAst(parsed.program, {
- enter: (node, parent, readAncestors) => {
- visits.push(`enter:${node.type}`);
- const ancestors = readAncestors();
- expect(ancestors.at(-1) ?? null).toBe(parent);
- if (t.isIdentifier(node)) snapshots.push(ancestors);
- },
- exit: (node) => visits.push(`exit:${node.type}`),
- });
- expect(visits).toEqual([
- "enter:Program",
- "enter:VariableDeclaration",
- "enter:VariableDeclarator",
- "enter:Identifier",
- "exit:Identifier",
- "enter:BinaryExpression",
- "enter:Identifier",
- "exit:Identifier",
- "enter:Identifier",
- "exit:Identifier",
- "exit:BinaryExpression",
- "exit:VariableDeclarator",
- "exit:VariableDeclaration",
- "exit:Program",
- ]);
- expect(snapshots.map((nodes) => nodes.map(({ type }) => type))).toEqual([
- ["Program", "VariableDeclaration", "VariableDeclarator"],
- [
- "Program",
- "VariableDeclaration",
- "VariableDeclarator",
- "BinaryExpression",
- ],
- [
- "Program",
- "VariableDeclaration",
- "VariableDeclarator",
- "BinaryExpression",
- ],
- ]);
-});
-
-it("skips sparse child slots without disturbing sibling visit order", () => {
- const parsed = parseJavaScriptSource("const values = [first, , second];");
- if (parsed === null)
- throw new TypeError("Expected a parsed JavaScript fixture");
- const identifiers: string[] = [];
- traverseJavaScriptAst(parsed.program, {
- enter: (node) => {
- if (t.isIdentifier(node)) identifiers.push(node.name);
- },
- });
- expect(identifiers).toEqual(["values", "first", "second"]);
-});
diff --git a/src/domain/javascript/javascriptStaticAnalysis.member_path_depth.test.ts b/src/domain/javascript/javascriptStaticAnalysis.member_path_depth.test.ts
index 6e426c7c6..3d0313301 100644
--- a/src/domain/javascript/javascriptStaticAnalysis.member_path_depth.test.ts
+++ b/src/domain/javascript/javascriptStaticAnalysis.member_path_depth.test.ts
@@ -5,6 +5,7 @@ import { analyzeJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
import { parseJavaScriptSource } from "./javascriptSourceParser.js";
const memberChain = ".next".repeat(12_000);
+const ordinaryMemberChain = ".next".repeat(64);
it("collects a 12,000-member CommonJS export path without recursion", () => {
const file = parseJavaScriptSource(`exports${memberChain}.last = 1;`);
@@ -48,8 +49,8 @@ it("keeps left-first and outer-member-first bundler runtime matches", () => {
).toBe("webpackChunkInner");
});
-it("analyzes a 12,000-member bundler runtime chain without recursion", () => {
- const source = `globalThis.webpackChunkApp${memberChain}.push([[1], { 1: function(module) { module.exports.ok = 42; } }]);`;
+it("recognizes a bundler runtime through nested member names", () => {
+ const source = `globalThis.webpackChunkApp${ordinaryMemberChain}.push([[1], { 1: function(module) { module.exports.ok = 42; } }]);`;
const analysis = analyzeJavaScriptStaticSource(source);
expect(analysis.parse_status).toBe("complete");
expect(analysis.parse_error_count).toBe(0);
diff --git a/src/domain/javascript/javascriptStaticAnalysisSourceMaps.test.ts b/src/domain/javascript/javascriptStaticAnalysisSourceMaps.test.ts
index d9ae95380..93a9ddec9 100644
--- a/src/domain/javascript/javascriptStaticAnalysisSourceMaps.test.ts
+++ b/src/domain/javascript/javascriptStaticAnalysisSourceMaps.test.ts
@@ -22,12 +22,6 @@ describe("source map directives", () => {
expect(sourceMapUrls(source)).toEqual([expected]);
});
- it("keeps the comment terminator out of the declared url", () => {
- expect(sourceMapUrls("/*# sourceMappingURL=app.js.map */")).toEqual([
- "app.js.map",
- ]);
- });
-
it("retains every directive in a source", () => {
expect(
sourceMapUrls(
@@ -84,30 +78,6 @@ describe("source map comment boundaries", () => {
});
describe("source map comment locations and recovery", () => {
- it("keeps exact locations and the first occurrence of duplicate URLs", () => {
- const line = "//# sourceMappingURL=first.map";
- const block = "/*# sourceMappingURL=second.map";
- const result = analyzeJavaScriptStaticSource(
- ['const marker = "😀";', line, `${block} */`, line].join("\r\n"),
- );
- expect(result.source_map_urls).toEqual([
- {
- declared_url: "first.map",
- location: {
- start: { line: 2, column: 0 },
- end: { line: 2, column: line.length },
- },
- },
- {
- declared_url: "second.map",
- location: {
- start: { line: 3, column: 0 },
- end: { line: 3, column: block.length },
- },
- },
- ]);
- });
-
it("keeps real comments when the parser recovers and reports partial syntax", () => {
const result = analyzeJavaScriptStaticSource(
"let value; let value;\n//# sourceMappingURL=recovered.map",
diff --git a/tests/acceptance/applications/applicationEvidenceMcp.test.ts b/tests/acceptance/applications/applicationEvidenceMcp.test.ts
index 3fdba32f4..6b21ac22c 100644
--- a/tests/acceptance/applications/applicationEvidenceMcp.test.ts
+++ b/tests/acceptance/applications/applicationEvidenceMcp.test.ts
@@ -1,9 +1,7 @@
-import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+import type { Client } from "@modelcontextprotocol/client";
import { describe, expect, it } from "vitest";
-import { createTestBinarySession } from "../../fixtures/binarySession.js";
import type { BinarySession } from "../../../src/application/binary/BinarySession.js";
-import { createServer } from "../../../src/server/createServer.js";
import {
JAVASCRIPT_FEATURE_TRACE_FULL_EVIDENCE_EXAMPLE,
JAVASCRIPT_FEATURE_TRACE_EXAMPLE,
@@ -11,39 +9,10 @@ import {
SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE,
} from "../../../src/contracts/javascript/javascriptApplicationWorkflowExamples.js";
import { createEvidence } from "../../../src/domain/evidence.js";
-import { observed } from "../../fixtures/analysisExecution.js";
-
-interface TestHarness {
- readonly client: Client;
- readonly session: BinarySession;
- readonly close: () => Promise<void>;
-}
-
-async function createTestHarness(): Promise<TestHarness> {
- const session = createTestBinarySession(() => ({
- execute: () => Promise.resolve(observed(null)),
- close: () => Promise.resolve(),
- }));
- const server = createServer(session, session);
- const client = new Client({
- name: "application-workflow-test",
- version: "1",
- });
- const [clientTransport, serverTransport] =
- InMemoryTransport.createLinkedPair();
- await server.connect(serverTransport);
- await client.connect(clientTransport);
-
- return {
- client,
- session,
- close: async () => {
- await client.close();
- await server.close();
- await session.close();
- },
- };
-}
+import {
+ createApplicationMcpHarness,
+ type ApplicationMcpHarness,
+} from "./mcpHarness.js";
async function runInlineEvidenceScenarios(
client: Client,
@@ -103,7 +72,9 @@ async function runInlineEvidenceScenarios(
expect(session.exportEvidenceBundle().records.length).toBeGreaterThan(2);
}
-async function runInlineWorkflowScenarios(harness: TestHarness): Promise<void> {
+async function runInlineWorkflowScenarios(
+ harness: ApplicationMcpHarness,
+): Promise<void> {
const tracedInline = await harness.client.callTool({
name: "trace_application_feature",
arguments: {
@@ -250,7 +221,7 @@ async function assertRejectedInlineEvidence(client: Client): Promise<void> {
describe("application workflow MCP parity", () => {
it("traces and compares authenticated graph Evidence in the session", async () => {
- const harness = await createTestHarness();
+ const harness = await createApplicationMcpHarness();
try {
await runInlineEvidenceScenarios(harness.client, harness.session);
await runInlineWorkflowScenarios(harness);
diff --git a/tests/acceptance/applications/applicationExportShapeMcp.test.ts b/tests/acceptance/applications/applicationExportShapeMcp.test.ts
index c104c8012..5258ef2c4 100644
--- a/tests/acceptance/applications/applicationExportShapeMcp.test.ts
+++ b/tests/acceptance/applications/applicationExportShapeMcp.test.ts
@@ -1,15 +1,14 @@
-import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
import { describe, expect, it } from "vitest";
-import { copyFile, mkdir, rm } from "node:fs/promises";
+import { copyFile, mkdir, rm, writeFile } from "node:fs/promises";
import { join, relative, resolve } from "node:path";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
-import { createTestBinarySession } from "../../fixtures/binarySession.js";
-import { createServer } from "../../../src/server/createServer.js";
-import { observed } from "../../fixtures/analysisExecution.js";
import { analyzeJavaScriptApplication } from "../../../src/application/javascript/JavaScriptApplicationService.js";
+import { compareJavaScriptExportShapesEvidence } from "../../../src/application/javascript/JavaScriptApplicationWorkflowService.js";
import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";
+import { javaScriptExportShapeComparisonResultSchema } from "../../../src/domain/javascript/javascriptExportShapeComparisonSchemas.js";
+import { createApplicationMcpHarness } from "./mcpHarness.js";
describe("application workflow MCP parity", () => {
it("compares exact parser export shapes with inline Evidence", async () => {
@@ -40,14 +39,8 @@ describe("application workflow MCP parity", () => {
const leftAnalysis = javascriptApplicationAnalysisResultSchema.parse(
left.value.normalized_result,
);
- const session = createTestBinarySession(() => ({
- execute: () => Promise.resolve(observed(null)),
- close: () => Promise.resolve(),
- }));
- const server = createServer(session, session);
- const client = new Client({ name: "export-shape-test", version: "1" });
- const [clientTransport, serverTransport] =
- InMemoryTransport.createLinkedPair();
+ const harness = await createApplicationMcpHarness();
+ const { client, session } = harness;
const selectors = {
left_module_path: "parser.mjs",
left_export_name: "default",
@@ -55,8 +48,6 @@ describe("application workflow MCP parity", () => {
right_export_name: "default",
};
try {
- await server.connect(serverTransport);
- await client.connect(clientTransport);
const relativeApplication = await client.callTool({
name: "analyze_javascript_application",
arguments: { input_path: relative(process.cwd(), leftRoot) },
@@ -121,10 +112,110 @@ describe("application workflow MCP parity", () => {
},
});
} finally {
- await client.close();
- await server.close();
- await session.close();
+ await harness.close();
await rm(root, { recursive: true, force: true });
}
});
});
+
+describe("source-produced export comparison inventories", () => {
+ it("retains large source-produced export inventories through comparison schemas", async () => {
+ const fields = Array.from(
+ { length: 64 },
+ (_, index) => `field${String(index)}: ${String(index)}`,
+ ).join(", ");
+ const returnSites = Array.from(
+ { length: 33 },
+ (_, index) =>
+ `if (value === ${String(index)}) return { type: "variant-${String(index)}", ${fields} };`,
+ ).join("\n");
+ const extraExports = Array.from(
+ { length: 1_000 },
+ (_, index) =>
+ `export const candidate${String(index)} = ${String(index)};`,
+ ).join("\n");
+ const inventorySource = `export default function parse(value) {\n${returnSites}\n throw new Error("no match");\n}\n${extraExports}`;
+ const [inventoryLeft, inventoryRight] = await Promise.all([
+ analyzeSourceEvidence(inventorySource),
+ analyzeSourceEvidence(inventorySource),
+ ]);
+ const variants = compareEvidence(inventoryLeft, inventoryRight);
+ expect(variants.left).toMatchObject({ status: "selected" });
+ expect(variants.coverage).toMatchObject({
+ paired_variants: 33,
+ unpaired_left_variants: 0,
+ unpaired_right_variants: 0,
+ left_source_omitted_variants: 0,
+ right_source_omitted_variants: 0,
+ left_omitted_fields: 0,
+ right_omitted_fields: 0,
+ });
+
+ const missing = compareEvidence(inventoryLeft, inventoryRight, {
+ leftExportName: "missing",
+ });
+ expect(missing.left).toMatchObject({
+ status: "missing",
+ omitted_candidates: 0,
+ });
+ expect(missing.left.candidates).toHaveLength(1_001);
+
+ const changedFieldsLeft = Array.from(
+ { length: 10_001 },
+ (_, index) => `field${String(index)}: ${String(index)}`,
+ ).join(", ");
+ const changedFieldsRight = Array.from(
+ { length: 10_001 },
+ (_, index) => `field${String(index)}: ${String(index + 1)}`,
+ ).join(", ");
+ const [changeLeft, changeRight] = await Promise.all([
+ analyzeSourceEvidence(
+ `export default () => ({ type: "record", ${changedFieldsLeft} });`,
+ ),
+ analyzeSourceEvidence(
+ `export default () => ({ type: "record", ${changedFieldsRight} });`,
+ ),
+ ]);
+ const changes = compareEvidence(changeLeft, changeRight);
+ expect(changes.changes).toHaveLength(10_001);
+ expect(changes.summary).toEqual({
+ added: 0,
+ removed: 0,
+ changed: 10_001,
+ unknown: 0,
+ });
+ expect(changes.coverage).toMatchObject({
+ status: "complete-within-inputs",
+ omitted_changes: 0,
+ left_omitted_fields: 0,
+ right_omitted_fields: 0,
+ });
+ }, 30_000);
+});
+
+const analyzeSourceEvidence = async (source: string) => {
+ const root = await createTestTempDirectory("rea-export-shape-inventory-");
+ await writeFile(join(root, "parser.mjs"), source);
+ const analyzed = await analyzeJavaScriptApplication({ input_path: root });
+ if (!analyzed.ok) throw analyzed.error;
+ return analyzed.value;
+};
+
+const compareEvidence = (
+ left: Awaited<ReturnType<typeof analyzeSourceEvidence>>,
+ right: Awaited<ReturnType<typeof analyzeSourceEvidence>>,
+ selectors: { readonly leftExportName?: string } = {},
+) => {
+ const compared = compareJavaScriptExportShapesEvidence({
+ left,
+ right,
+ left_module_path: "parser.mjs",
+ left_export_name: selectors.leftExportName ?? "default",
+ right_module_path: "parser.mjs",
+ right_export_name: "default",
+ });
+ if (!compared.ok) throw compared.error;
+ return javaScriptExportShapeComparisonResultSchema.parse(
+ compared.value.normalized_result,
+ );
+};
diff --git a/tests/acceptance/applications/mcpHarness.ts b/tests/acceptance/applications/mcpHarness.ts
new file mode 100644
index 000000000..5f971e477
--- /dev/null
+++ b/tests/acceptance/applications/mcpHarness.ts
@@ -0,0 +1,39 @@
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+
+import { createTestBinarySession } from "../../fixtures/binarySession.js";
+import type { BinarySession } from "../../../src/application/binary/BinarySession.js";
+import { observed } from "../../fixtures/analysisExecution.js";
+import { createServer } from "../../../src/server/createServer.js";
+
+/** Owned MCP SDK session shared by application workflow scenarios. */
+export interface ApplicationMcpHarness {
+ readonly client: Client;
+ readonly session: BinarySession;
+ readonly close: () => Promise<void>;
+}
+
+/** Connect application workflows through the production MCP registration. */
+export async function createApplicationMcpHarness(): Promise<ApplicationMcpHarness> {
+ const session = createTestBinarySession(() => ({
+ execute: () => Promise.resolve(observed(null)),
+ close: () => Promise.resolve(),
+ }));
+ const server = createServer(session, session);
+ const client = new Client({
+ name: "application-workflow-test",
+ version: "1",
+ });
+ const [clientTransport, serverTransport] =
+ InMemoryTransport.createLinkedPair();
+
+ await server.connect(serverTransport);
+ await client.connect(clientTransport);
+
+ return {
+ client,
+ session,
+ close: async () => {
+ await Promise.all([client.close(), server.close(), session.close()]);
+ },
+ };
+}