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 import-equals declaration and export evidence (#2062)
hhang86fab11fbe00
diff --git a/src/application/javascript/JavaScriptArtifactAnalysis.ts b/src/application/javascript/JavaScriptArtifactAnalysis.tsindex 58bbce3f9..e52ba04dd 100644--- a/src/application/javascript/JavaScriptArtifactAnalysis.ts+++ b/src/application/javascript/JavaScriptArtifactAnalysis.ts@@ -1,4 +1,6 @@import { createHash } from "node:crypto";++import { moduleKindForJavaScriptReference } from "./JavaScriptArtifactPathResolution.js";import { setImmediate } from "node:timers/promises";import { resolveJavaScriptSourceMapReference } from "../../domain/javascript/javascriptSourceMapPaths.js";@@ -380,7 +382,10 @@ function* analyzeArtifactFileSteps<yield;const semantics =analysis.parse_status === "complete" || analysis.parse_status === "partial"- ? yield* analyzeParsedJavaScriptSemanticsSteps(parsed)+ ? yield* analyzeParsedJavaScriptSemanticsSteps(+ parsed,+ moduleKindForJavaScriptReference(file.path, "static-import"),+ ): null;const projected =semantics === nulldiff --git a/src/application/javascript/JavaScriptArtifactPathResolution.ts b/src/application/javascript/JavaScriptArtifactPathResolution.tsindex 2f1539eb2..f8530f7f0 100644--- a/src/application/javascript/JavaScriptArtifactPathResolution.ts+++ b/src/application/javascript/JavaScriptArtifactPathResolution.ts@@ -68,12 +68,20 @@ export interface ResolveArtifactPathInput {export const moduleKindForJavaScriptReference = (sourcePath: string,referenceKind: "static-import" | "dynamic-import" | "require",+ resolutionMode?: "import" | "require",): "import" | "require" =>- referenceKind === "require" ||+ resolutionMode ??+ (referenceKind === "require" ||(referenceKind === "static-import" &&posix.extname(sourcePath).toLowerCase() === ".cts")? "require"- : "import";+ : "import");++/** Preserve an explicitly retained loader mode on graph relationships. */+export const moduleResolutionModeProperties = (+ mode: "import" | "require" | undefined,+): Readonly<Record<string, "import" | "require">> =>+ mode === undefined ? {} : { resolution_mode: mode };const EXTENSIONS = [".js",diff --git a/src/application/javascript/JavaScriptModuleRelationships.ts b/src/application/javascript/JavaScriptModuleRelationships.tsindex 3468762f4..874377810 100644--- a/src/application/javascript/JavaScriptModuleRelationships.ts+++ b/src/application/javascript/JavaScriptModuleRelationships.ts@@ -31,6 +31,7 @@ import {} from "./JavaScriptArtifactGraphEvidence.js";import {moduleKindForJavaScriptReference,+ moduleResolutionModeProperties,resolveArtifactPathByContext,type ArtifactPathResolution,} from "./JavaScriptArtifactPathResolution.js";@@ -281,6 +282,7 @@ const resolveModuleTarget = (input.link.kind === "require" || input.link.kind === "commonjs-export"? "require": "static-import",+ input.link.resolutionMode,),});if (resolution.resolution_status !== "resolved")@@ -373,6 +375,7 @@ const relationshipProperties = (origin?: JavaScriptModuleOrigin,) => ({module_link_kind: link.kind,+ ...moduleResolutionModeProperties(link.resolutionMode),specifier: origin?.specifier ?? link.specifier,imported_name: origin?.importedPath.at(-1) ?? link.importedName,imported_path: origin?.importedPath ?? [],diff --git a/src/composition/javascriptAnalysisWorkerProcess.ts b/src/composition/javascriptAnalysisWorkerProcess.tsindex 5c66f4afa..09a9c9bc3 100644--- a/src/composition/javascriptAnalysisWorkerProcess.ts+++ b/src/composition/javascriptAnalysisWorkerProcess.ts@@ -1,3 +1,4 @@+import { moduleKindForJavaScriptReference } from "../application/javascript/JavaScriptArtifactPathResolution.js";import { parseJavaScriptSource } from "../domain/javascript/javascriptSourceParser.js";import { analyzeParsedJavaScriptStaticSourceSteps } from "../domain/javascript/javascriptStaticAnalysis.js";import {@@ -53,7 +54,10 @@ const analyze: JavaScriptSourceWorkerAnalyzer = async ();await callbacks.phase("semantic");const ir = await completeJavaScriptAnalysisSteps(- analyzeParsedJavaScriptSemanticsSteps(parsed),+ analyzeParsedJavaScriptSemanticsSteps(+ parsed,+ moduleKindForJavaScriptReference(file.path, "static-import"),+ ),);parsed = null;const module = projectJavaScriptModuleSemantics(ir);diff --git a/src/domain/javascript/javascriptSemanticAnalysis.require_links.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.require_links.test.tsindex 19e7b2fd2..333ad4f9c 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.require_links.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.require_links.test.ts@@ -52,6 +52,36 @@ describe("TypeScript import-equals links", () => {});describe("CommonJS dependency links", () => {+ it("retains an import-equals binding and its module origin", () => {+ const ir = analyzeJavaScriptSemantics(`+ import typed = require("dependency");+ import type TypeOnly = require("type-only");+ namespace Local { export class Marker {} }+ import Alias = Local.Marker;+ void typed;+ `);+ expect(topLevelBinding(ir, "typed")).toMatchObject({+ kind: "import",+ mutable: false,+ provenance: {+ origins: [{ specifier: "dependency", importedPath: [] }],+ },+ });+ expect(+ ir.moduleLinks.filter(({ specifier }) => specifier !== null),+ ).toEqual([+ expect.objectContaining({+ kind: "require",+ specifier: "dependency",+ importedName: null,+ localName: "typed",+ }),+ ]);+ expect(ir.references.filter(({ name }) => name === "typed")).toHaveLength(+ 1,+ );+ });+it.each(['require("dependency");','void require("dependency");',@@ -148,7 +178,9 @@ describe("CommonJS dependency links", () => {]);expect(ir.bindings.find(({ name }) => name === "bound")?.provenance.origins,- ).toEqual([{ specifier: "bound", importedPath: [] }]);+ ).toEqual([+ { specifier: "bound", importedPath: [], resolutionMode: "require" },+ ]);});it.each([@@ -179,6 +211,7 @@ it("preserves unshadowed require origins through aliases and assignments", () =>expect(origin(topLevelBinding(ir, name))).toEqual({specifier: "electron",importedPath: ["ipcMain"],+ resolutionMode: "require",});expect(topLevelBinding(ir, "assigned").provenance).toMatchObject({status: "ambiguous",diff --git a/src/domain/javascript/javascriptSemanticAnalysis.structure.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.structure.test.tsindex 7405bf60e..2cd9fba80 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.structure.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.structure.test.ts@@ -38,10 +38,12 @@ describe("JavaScript semantic analysis: structure 1", () => {expect(origin(topLevelBinding(ir, "bus"))).toEqual({specifier: "electron",importedPath: ["ipcMain"],+ resolutionMode: "require",});expect(origin(topLevelBinding(ir, "forwarded"))).toEqual({specifier: "electron",importedPath: ["ipcMain"],+ resolutionMode: "require",});expect(topLevelBinding(ir, "assigned").provenance).toMatchObject({status: "ambiguous",@@ -66,6 +68,7 @@ describe("JavaScript semantic analysis: structure 1", () => {expect(origin(innerBus)).toEqual({specifier: "./local-bus.js",importedPath: [],+ resolutionMode: "require",});const shadow = onlyBinding(ir, "ipcRenderer");expect(shadow.provenance).toEqual({diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.tsindex cff8d0458..66776180a 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts@@ -134,8 +134,11 @@ export function* indexJavaScriptBindingsSteps(/** Recover semantics from an already parsed JavaScript artifact. */export const analyzeParsedJavaScriptSemantics = (file: ParsedJavaScriptSource,+ staticImportResolutionMode: "import" | "require" = "import",): JavaScriptSemanticIr =>- completeSemanticSteps(analyzeParsedJavaScriptSemanticsSteps(file));+ completeSemanticSteps(+ analyzeParsedJavaScriptSemanticsSteps(file, staticImportResolutionMode),+ );/*** Recover semantics from a parsed artifact with a yield between analysis@@ -145,8 +148,9 @@ export const analyzeParsedJavaScriptSemantics = (*/export function* analyzeParsedJavaScriptSemanticsSteps(file: ParsedJavaScriptSource,+ staticImportResolutionMode: "import" | "require" = "import",): Generator<void, JavaScriptSemanticIr> {- const state = createState(file.program);+ const state = createState(file.program, staticImportResolutionMode);yield* collectDefinitionsSteps(file.program, state);yield* collectSemanticMemberMutationsSteps(file.program, state);yield* traverseJavaScriptAstSteps(file.program, {@@ -159,7 +163,11 @@ export function* analyzeParsedJavaScriptSemanticsSteps(yield;const callables = collectSemanticReturns(state, parserPartial);yield;- const moduleLinks = resolveSemanticModuleCallables(state, callables);+ const moduleLinks = resolveSemanticModuleCallables(+ state,+ callables,+ bindings,+ );const derived = yield* collectJavaScriptDerivedSemanticsSteps(file.program,state,@@ -517,7 +525,10 @@ const bindingOrigin = (: { ...origin, importedPath: [...origin.importedPath, ...projection] };};-const createState = (program: t.Program): JavaScriptSemanticAnalysisState => {+const createState = (+ program: t.Program,+ staticImportResolutionMode: "import" | "require" = "import",+): JavaScriptSemanticAnalysisState => {const root: JavaScriptSemanticScopeState = {scopeId: semanticScopeId("program", program),parentScopeId: null,@@ -527,6 +538,7 @@ const createState = (program: t.Program): JavaScriptSemanticAnalysisState => {bindings: new Map(),};return {+ staticImportResolutionMode,parentsByNode: new WeakMap(),scopes: [root],scopesById: new Map([[root.scopeId, root]]),@@ -803,7 +815,7 @@ const bindImportEquals = (mutable: false,definitionNode: node.id,initializer: null,- directOrigin: { specifier, importedPath: [] },+ directOrigin: { specifier, importedPath: [], resolutionMode: "require" },});};@@ -1181,7 +1193,13 @@ const addBinding = (input: AddBindingInput): void => {binding.definitions.push({ kind, location: range(definitionNode) });if (initializer !== null)binding.initializers.push({ node: initializer, projection });- if (directOrigin !== undefined) binding.directOrigins.push(directOrigin);+ if (directOrigin !== undefined)+ binding.directOrigins.push(+ directOrigin.resolutionMode === undefined &&+ state.staticImportResolutionMode === "require"+ ? { ...directOrigin, resolutionMode: "require" }+ : directOrigin,+ );};const createBinding = (diff --git a/src/domain/javascript/javascriptSemanticIr.ts b/src/domain/javascript/javascriptSemanticIr.tsindex 0e547f155..18f1eb485 100644--- a/src/domain/javascript/javascriptSemanticIr.ts+++ b/src/domain/javascript/javascriptSemanticIr.ts@@ -7,6 +7,7 @@ import type {/** One exact module origin followed through imports, requires, or aliases. */export interface JavaScriptModuleOrigin {+ readonly resolutionMode?: "import" | "require";readonly specifier: string;readonly importedPath: readonly string[];}@@ -392,8 +393,10 @@ export interface JavaScriptSemanticFrontier {/** Static import/export relationship retained for cross-file composition. */export interface JavaScriptSemanticModuleLink {+ readonly resolutionMode?: "import" | "require";readonly kind:| "import"+ | "type-import"| "require"| "export"| "re-export"diff --git a/src/domain/javascript/javascriptSemanticProjection.ts b/src/domain/javascript/javascriptSemanticProjection.tsindex 42601888a..7e4663efe 100644--- a/src/domain/javascript/javascriptSemanticProjection.ts+++ b/src/domain/javascript/javascriptSemanticProjection.ts@@ -669,19 +669,26 @@ export const semanticReferenceRole = (return "read";};-const isDeclarationIdentifier = (node: t.Identifier, parent: t.Node): boolean =>- (t.isVariableDeclarator(parent) && patternContains(parent.id, node)) ||- ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent)) &&- parent.id === node) ||- (t.isFunction(parent) &&- parent.params.some((value) => patternContains(value, node))) ||- ((t.isClassDeclaration(parent) || t.isClassExpression(parent)) &&- parent.id === node) ||- (t.isImportSpecifier(parent) &&- (parent.local === node || parent.imported === node)) ||- (t.isImportDefaultSpecifier(parent) && parent.local === node) ||- (t.isImportNamespaceSpecifier(parent) && parent.local === node) ||- (t.isCatchClause(parent) && parent.param === node);+const isDeclarationIdentifier = (+ node: t.Identifier,+ parent: t.Node,+): boolean => {+ if (t.isTSImportEqualsDeclaration(parent)) return parent.id === node;+ return (+ (t.isVariableDeclarator(parent) && patternContains(parent.id, node)) ||+ ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent)) &&+ parent.id === node) ||+ (t.isFunction(parent) &&+ parent.params.some((value) => patternContains(value, node))) ||+ ((t.isClassDeclaration(parent) || t.isClassExpression(parent)) &&+ parent.id === node) ||+ (t.isImportSpecifier(parent) &&+ (parent.local === node || parent.imported === node)) ||+ (t.isImportDefaultSpecifier(parent) && parent.local === node) ||+ (t.isImportNamespaceSpecifier(parent) && parent.local === node) ||+ (t.isCatchClause(parent) && parent.param === node)+ );+};const isNonReferenceKey = (node: t.Identifier, parent: t.Node): boolean =>((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&diff --git a/src/domain/javascript/javascriptSemanticProvenance.ts b/src/domain/javascript/javascriptSemanticProvenance.tsindex ab56a1488..3272b2ab9 100644--- a/src/domain/javascript/javascriptSemanticProvenance.ts+++ b/src/domain/javascript/javascriptSemanticProvenance.ts@@ -48,7 +48,11 @@ export const uniqueSemanticOrigins = ();const semanticOriginKey = (origin: JavaScriptModuleOrigin): string =>- JSON.stringify([origin.specifier, origin.importedPath]);+ JSON.stringify([+ origin.specifier,+ origin.importedPath,+ origin.resolutionMode ?? "import",+ ]);/** Canonically distinguish primitive values across type boundaries. */export const semanticPrimitiveKey = (diff --git a/src/domain/javascript/javascriptSemanticRequireOrigin.ts b/src/domain/javascript/javascriptSemanticRequireOrigin.tsindex 00f0805ba..63fde3a95 100644--- a/src/domain/javascript/javascriptSemanticRequireOrigin.ts+++ b/src/domain/javascript/javascriptSemanticRequireOrigin.ts@@ -54,7 +54,11 @@ export const semanticRequireOrigin = (return specifier === undefined? undefined: {- origin: { specifier, importedPath: members.reverse() },+ origin: {+ specifier,+ importedPath: members.reverse(),+ resolutionMode: "require",+ },call: current,};};diff --git a/src/domain/javascript/javascriptSemanticReturns.ts b/src/domain/javascript/javascriptSemanticReturns.tsindex b6ce1540b..189a1385e 100644--- a/src/domain/javascript/javascriptSemanticReturns.ts+++ b/src/domain/javascript/javascriptSemanticReturns.ts@@ -6,6 +6,7 @@ import {} from "./javascriptSemanticSlots.js";import type {+ JavaScriptSemanticBinding,JavaScriptSemanticCallable,JavaScriptSemanticModuleLink,JavaScriptSemanticReturnSite,@@ -89,12 +90,16 @@ const semanticReturnSiteId = (String(location.end.column),].join(":");-/** Link exports to callables only when lexical resolution is unique and exact. */+/** Finalize exported bindings only when lexical resolution is unique and exact. */export const resolveSemanticModuleCallables = (state: JavaScriptSemanticAnalysisState,callables: readonly JavaScriptSemanticCallable[],+ bindings: readonly JavaScriptSemanticBinding[],): JavaScriptSemanticModuleLink[] => {const callableIds = new Set(callables.map(({ callableId }) => callableId));+ const provenanceByBinding = new Map(+ bindings.map(({ bindingId, provenance }) => [bindingId, provenance]),+ );return state.moduleLinks.map((link) => {// Named exports follow their lexical binding, including every assignment.// A declaration's ID or a callable's display name cannot prove that link.@@ -107,8 +112,19 @@ export const resolveSemanticModuleCallables = (binding === undefined? []: callableIdsForBinding(binding, state, callableIds, new Set());+ const provenance =+ binding === undefined || link.specifier !== null+ ? undefined+ : provenanceByBinding.get(binding.bindingId);+ const resolutionMode =+ provenance?.status === "module"+ ? provenance.origins[0].resolutionMode+ : undefined;return {...link,+ ...(resolutionMode === "import" || resolutionMode === "require"+ ? { resolutionMode }+ : {}),callableId: resolved.length === 1 ? (resolved[0] ?? null) : null,};});diff --git a/src/domain/javascript/javascriptSemanticState.ts b/src/domain/javascript/javascriptSemanticState.tsindex e07caad99..29f798f36 100644--- a/src/domain/javascript/javascriptSemanticState.ts+++ b/src/domain/javascript/javascriptSemanticState.ts@@ -57,6 +57,8 @@ export interface JavaScriptSemanticScopeState {/** Shared state for semantic collection and evaluation. */export interface JavaScriptSemanticAnalysisState {+ /** Effective loader for static imports in this source artifact. */+ readonly staticImportResolutionMode: "import" | "require";readonly parentsByNode: WeakMap<t.Node, t.Node>;readonly scopes: JavaScriptSemanticScopeState[];readonly scopesById: Map<string, JavaScriptSemanticScopeState>;diff --git a/src/domain/javascript/javascriptStaticAnalysis.ts b/src/domain/javascript/javascriptStaticAnalysis.tsindex ea712f658..cbbd57b77 100644--- a/src/domain/javascript/javascriptStaticAnalysis.ts+++ b/src/domain/javascript/javascriptStaticAnalysis.ts@@ -52,6 +52,7 @@ import {} from "./javascriptSourceParser.js";import { createJavaScriptRpcScan } from "./javascriptRpcEndpoints.js";+import { semanticImportEqualsSpecifier } from "./javascriptSemanticProjection.js";/** Parse one JavaScript artifact and recover static structure only. */export const analyzeJavaScriptStaticSource = (@@ -238,7 +239,11 @@ const inspectNode = (} else if (t.isOptionalCallExpression(node)) {inspectCall(source, node, findings);} else if (t.isNewExpression(node)) inspectCall(source, node, findings);- if (+ if (t.isTSImportEqualsDeclaration(node)) {+ const specifier = semanticImportEqualsSpecifier(node);+ if (specifier !== null)+ addReference(findings, { node, kind: "require", specifier });+ } else if ((t.isImportDeclaration(node) || t.isExportAllDeclaration(node)) &&node.source !== undefined)diff --git a/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts b/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.tsindex 196c8b7b9..b666cfa9b 100644--- a/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts+++ b/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts@@ -471,7 +471,16 @@ const semanticValue: z.ZodType<JavaScriptSemanticValue> = z.lazy(() =>};}),);-const origin = z.strictObject({ specifier: z.string(), importedPath: strings });+const origin = z+ .strictObject({+ specifier: z.string(),+ importedPath: strings,+ resolutionMode: z.enum(["import", "require"]).optional(),+ })+ .transform(({ resolutionMode, ...rest }) => ({+ ...rest,+ ...(resolutionMode === undefined ? {} : { resolutionMode }),+ }));const provenance = z.discriminatedUnion("status", [z.strictObject({status: z.literal("module"),@@ -519,15 +528,28 @@ const coverage = z...(resourceLimits === undefined ? {} : { resourceLimits }),};});-const moduleLink = z.strictObject({- kind: z.enum(["import", "require", "export", "re-export", "commonjs-export"]),- specifier: z.string().nullable(),- importedName: z.string().nullable(),- localName: z.string().nullable(),- exportedName: z.string().nullable(),- callableId: z.string().nullable(),- location: range,-});+const moduleLink = z+ .strictObject({+ resolutionMode: z.enum(["import", "require"]).optional(),+ kind: z.enum([+ "import",+ "type-import",+ "require",+ "export",+ "re-export",+ "commonjs-export",+ ]),+ specifier: z.string().nullable(),+ importedName: z.string().nullable(),+ localName: z.string().nullable(),+ exportedName: z.string().nullable(),+ callableId: z.string().nullable(),+ location: range,+ })+ .transform(({ resolutionMode, ...rest }) => ({+ ...rest,+ ...(resolutionMode === undefined ? {} : { resolutionMode }),+ }));const definitionKind = z.enum(["import","variable",diff --git a/tests/acceptance/applications/unboundRequires.test.ts b/tests/acceptance/applications/unboundRequires.test.tsindex a9f66e1b1..0e85f0a9a 100644--- a/tests/acceptance/applications/unboundRequires.test.ts+++ b/tests/acceptance/applications/unboundRequires.test.ts@@ -1,7 +1,9 @@+import { execFile } from "node:child_process";import { createHash } from "node:crypto";-import { writeFile } from "node:fs/promises";+import { readFile, writeFile } from "node:fs/promises";import { createRequire } from "node:module";-import { join, relative } from "node:path";+import { dirname, join, relative } from "node:path";+import { promisify } from "node:util";import { expect } from "vitest";@@ -10,6 +12,318 @@ import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/jimport { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";import { cliTest } from "../../support/cli/cliFixture.js";+import { writeFixtureFiles } from "../../support/javascriptApplicationFixture.js";++const execute = promisify(execFile);+const compiler = join(+ dirname(createRequire(import.meta.url).resolve("typescript/package.json")),+ "bin",+ "tsc",+);++const typedLines = [+ 'export import typed = require("typed-package");',+ 'import type TypeOnly = require("./type-only.cjs");',+] as const;+const typedSource = typedLines.join("\n");+const aliasSource = [+ 'import raw = require("typed-package");',+ "const alias = raw;",+ "export { alias };",+].join("\n");+const mixedSource = [+ 'import { value as imported } from "mixed-package";',+ 'import required = require("mixed-package");',+ "const mixed = Date.now() > 0 ? imported : required.value;",+ "export { imported as staticChoice, mixed };",+ "export const requireChoice = required.value;",+].join("\n");+const typescriptSourceFiles = {+ "typed.cts": typedSource,+ "typed.mts": typedSource,+ "alias.cts": aliasSource,+ "alias.mts": aliasSource,+ "mixed.cts": mixedSource,+ "mixed.mts": mixedSource,+};+const typedPackageFiles = {+ "node_modules/typed-package/package.json": JSON.stringify({+ exports: { require: "./actual.cjs", import: "./decoy.mjs" },+ }),+ "node_modules/typed-package/actual.cjs": "module.exports = 42;",+ "node_modules/typed-package/actual.d.cts":+ "declare const value: number; export = value;",+ "node_modules/typed-package/decoy.mjs": "export default 99;",+ "node_modules/typed-package/decoy.d.mts":+ "declare const value: number; export default value;",+ "node_modules/mixed-package/package.json": JSON.stringify({+ exports: { require: "./actual.cjs", import: "./decoy.mjs" },+ }),+ "node_modules/mixed-package/actual.cjs": "exports.value = 42;",+ "node_modules/mixed-package/actual.d.cts":+ "export declare const value: number;",+ "node_modules/mixed-package/decoy.mjs": "export const value = 99;",+ "node_modules/mixed-package/decoy.d.mts":+ "export declare const value: number;",+};++const expectNativeModuleControls = async (root: string): Promise<void> => {+ const emitted = await createTestTempDirectory("rea-import-equals-output-");+ await writeFixtureFiles(emitted, typedPackageFiles);+ await execute(+ process.execPath,+ [+ compiler,+ "--module",+ "NodeNext",+ "--moduleResolution",+ "NodeNext",+ "--target",+ "ES2022",+ "--skipLibCheck",+ "--allowJs",+ "--outDir",+ emitted,+ join(root, "typed.cts"),+ join(root, "typed.mts"),+ join(root, "alias.cts"),+ join(root, "alias.mts"),+ join(root, "mixed.cts"),+ join(root, "mixed.mts"),+ ],+ { cwd: root, timeout: 10_000 },+ );+ for (const [filename, script] of [+ [+ "typed.cjs",+ 'console.log(require("./typed.cjs").typed, require("./alias.cjs").alias);',+ ],+ [+ "typed.mjs",+ 'Promise.all([import("./typed.mjs"), import("./alias.mjs")]).then(([first, second]) => console.log(first.typed, second.alias));',+ ],+ ] as const) {+ const typedControl = await execute(process.execPath, ["-e", script], {+ cwd: emitted,+ timeout: 5_000,+ });+ expect(typedControl.stdout.trim()).toBe("42 42");+ expect(await readFile(join(emitted, filename), "utf8")).not.toContain(+ "./type-only.cjs",+ );+ }+ for (const [filename, expected] of [+ ["mixed.cjs", "42 42 42"],+ ["mixed.mjs", "99 42 99"],+ ] as const) {+ const control = await execute(+ process.execPath,+ [+ "-e",+ `import("./${filename}").then(({staticChoice, requireChoice, mixed}) => console.log(staticChoice, requireChoice, mixed));`,+ ],+ { cwd: emitted, timeout: 5_000 },+ );+ expect(control.stdout.trim()).toBe(expected);+ }+ const nativeRequire = createRequire(join(root, "main.cjs"));+ for (const name of ["dependency", "nested"])+ expect(+ relative(root, nativeRequire.resolve(`./${name}.cjs`)).replaceAll(+ "\\",+ "/",+ ),+ ).toBe(`${name}.cjs`);+};++const expectAliasRelationships = (+ graph: ReturnType<+ typeof javascriptApplicationAnalysisResultSchema.parse+ >["graph"],+): void => {+ for (const source of ["alias.cts", "alias.mts"]) {+ expect(graph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ properties: expect.objectContaining({+ module_link_kind: "export",+ local_name: "alias",+ exported_name: "alias",+ resolution_mode: "require",+ resolved_path: "node_modules/typed-package/actual.cjs",+ resolution_status: "resolved",+ }),+ evidence: expect.objectContaining({+ artifact: expect.objectContaining({+ sha256: createHash("sha256").update(aliasSource).digest("hex"),+ }),+ location: expect.objectContaining({+ value: expect.objectContaining({ source }),+ }),+ }),+ }),+ );+ }+};++const expectMixedRelationships = (+ graph: ReturnType<+ typeof javascriptApplicationAnalysisResultSchema.parse+ >["graph"],+): void => {+ const exported = (source: string, name: string) =>+ graph.edges.filter(+ ({ relation, properties, evidence }) =>+ relation === "imports" &&+ properties.module_link_kind === "export" &&+ properties.exported_name === name &&+ evidence.location.available &&+ evidence.location.value.kind === "source-range" &&+ evidence.location.value.source === source,+ );+ for (const source of ["mixed.cts", "mixed.mts"]) {+ for (const [name, target] of [+ ["staticChoice", source.endsWith(".cts") ? "actual.cjs" : "decoy.mjs"],+ ["requireChoice", "actual.cjs"],+ ] as const)+ expect(exported(source, name)).toMatchObject([+ {+ properties: {+ resolved_path: `node_modules/mixed-package/${target}`,+ resolution_status: "resolved",+ },+ evidence: {+ artifact: {+ sha256: createHash("sha256").update(mixedSource).digest("hex"),+ },+ },+ },+ ]);+ }+ expect(exported("mixed.cts", "mixed")).toMatchObject([+ {+ properties: {+ resolved_path: "node_modules/mixed-package/actual.cjs",+ resolution_status: "resolved",+ },+ evidence: {+ artifact: {+ sha256: createHash("sha256").update(mixedSource).digest("hex"),+ },+ },+ },+ ]);+ expect(exported("mixed.mts", "mixed")).toEqual([]);+};++const expectImportEqualsRelationships = (+ graph: ReturnType<+ typeof javascriptApplicationAnalysisResultSchema.parse+ >["graph"],+): void => {+ for (const [sourcePath, format] of [+ ["typed.cts", "commonjs"],+ ["typed.mts", "esm"],+ ] as const) {+ const typedLinks = graph.edges.filter(+ ({ relation, properties, evidence: edgeEvidence }) =>+ relation === "imports" &&+ properties.module_link_kind === "require" &&+ edgeEvidence.location.available &&+ edgeEvidence.location.value.kind === "source-range" &&+ edgeEvidence.location.value.source === sourcePath,+ );+ expect(typedLinks).toHaveLength(1);+ expect(typedLinks[0]).toMatchObject({+ properties: {+ specifier: "typed-package",+ imported_name: null,+ local_name: "typed",+ resolved_path: "node_modules/typed-package/actual.cjs",+ resolution_status: "resolved",+ },+ evidence: {+ artifact: {+ available: true,+ sha256: createHash("sha256").update(typedSource).digest("hex"),+ },+ location: {+ available: true,+ value: {+ source: sourcePath,+ start: { line: 1, column: 7 },+ end: { line: 1, column: typedLines[0].length },+ },+ },+ },+ });+ expect(graph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ properties: expect.objectContaining({+ module_link_kind: "export",+ local_name: "typed",+ resolution_mode: "require",+ resolved_path: "node_modules/typed-package/actual.cjs",+ }),+ evidence: expect.objectContaining({+ location: expect.objectContaining({+ value: expect.objectContaining({ source: sourcePath }),+ }),+ }),+ }),+ );+ expect(+ graph.nodes.flatMap(({ observations }) => observations),+ ).toContainEqual(+ expect.objectContaining({+ properties: expect.objectContaining({+ semantic_role: "source-module",+ path: sourcePath,+ export_names: ["typed"],+ export_relationships: 1,+ }),+ }),+ );+ expect(+ graph.edges.filter(+ ({ relation, evidence: edgeEvidence }) =>+ relation === "exposes" &&+ edgeEvidence.location.available &&+ edgeEvidence.location.value.kind === "source-range" &&+ edgeEvidence.location.value.source === sourcePath,+ ),+ ).toHaveLength(1);+ expect(graph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ properties: expect.objectContaining({+ kind: "require",+ specifier: "typed-package",+ resolved_path: "node_modules/typed-package/actual.cjs",+ }),+ }),+ );+ expect(+ graph.nodes.flatMap(({ observations }) => observations),+ ).toContainEqual(+ expect.objectContaining({+ properties: expect.objectContaining({+ semantic_role: "source-module",+ path: sourcePath,+ module_format: format,+ import_relationships: 1,+ }),+ }),+ );+ }+ expect(+ graph.edges.filter(+ ({ relation, properties }) =>+ relation === "imports" && properties.specifier === "./type-only.cjs",+ ),+ ).toHaveLength(0);+};cliTest.for(["CLI", "stdio MCP"] as const)("retains unbound CommonJS semantic relationships through %s",@@ -34,20 +348,16 @@ cliTest.for(["CLI", "stdio MCP"] as const)("imports.mjs": 'import "./dependency.cjs";',"dependency.cjs": 'throw new Error("fixture must not execute");',"nested.cjs": 'throw new Error("fixture must not execute");',+ ...typescriptSourceFiles,+ "type-only.d.cts": "declare const value: unknown; export = value;",};await Promise.all(Object.entries(files).map(([path, text]) =>writeFile(join(root, path), text),),);- const nativeRequire = createRequire(join(root, "main.cjs"));- for (const name of ["dependency", "nested"])- expect(- relative(root, nativeRequire.resolve(`./${name}.cjs`)).replaceAll(- "\\",- "/",- ),- ).toBe(`${name}.cjs`);+ await writeFixtureFiles(root, typedPackageFiles);+ await expectNativeModuleControls(root);let document: unknown;if (surface === "CLI") {@@ -70,6 +380,9 @@ cliTest.for(["CLI", "stdio MCP"] as const)(const { graph } = javascriptApplicationAnalysisResultSchema.parse(evidence.normalized_result,);+ expectImportEqualsRelationships(graph);+ expectAliasRelationships(graph);+ expectMixedRelationships(graph);const links = graph.edges.filter(({ relation, properties, evidence: edgeEvidence }) =>relation === "imports" &&