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 package and source-map boundary identity (#1939)
morluto14935e4d470b
diff --git a/docs/javascript-artifact-reconstruction.md b/docs/javascript-artifact-reconstruction.mdindex 4f7338366..eb37c6a2b 100644--- a/docs/javascript-artifact-reconstruction.md+++ b/docs/javascript-artifact-reconstruction.md@@ -508,6 +508,12 @@ from unmatched nested targets rather than reporting array indices.For imports and requires, the active Node conditions include `module-sync`;earlier active conditions retain precedence over later ones.+Package self-references use the importer's enclosing package scope before+installed dependencies. ESM requires the parsed package name to equal the+metadata name; a scope-only name such as `@scope` cannot capture `@scope/pkg`.+CommonJS retains Node's raw-request name/prefix matching. Both paths preserve+the original specifier and select exports under their own loader conditions.+Exact package-private `#alias` specifiers resolve against the importer'senclosing `package.json` `imports` map — the nearest same-container packagescope, stopping at a `node_modules` directory so a nested package cannot inherit@@ -523,8 +529,15 @@ URL targets before selecting a later package-local file; an unsupported barepackage or recursive alias keeps its unresolved outcome rather than selectinga later fallback.-ESM relative module paths and selected package exports targets use URL suffix handling-and one percent-decoding pass. CommonJS relative paths and legacy package main+ESM relative module paths, legacy package subpaths without exports, and selected+package exports targets use URL suffix handling and one percent-decoding pass.+Bare specifiers retain their complete query/fragment text for exports key matching.+For dependency lookup, ESM constructs a package metadata URL instead of treating+the parsed package name as a literal directory. A root request such as `legacy?x`+does not load either `node_modules/legacy?x` or `node_modules/legacy`; an exact+self-reference with that metadata name can still select its exports first.+Without an exports map, ESM subpaths select exact files; directory imports and+extension fallback are refused. CommonJS relative paths and legacy package mainfields retain literal filename punctuation. Exports targets must start with`./` and exclude `.`, `..`, and `node_modules` path segments, including theirencoded forms, before URL normalization. Arrays skip invalid exports targetsdiff --git a/src/application/javascript/JavaScriptArtifactAnalysis.ts b/src/application/javascript/JavaScriptArtifactAnalysis.tsindex d28e5a6cc..1e41529b0 100644--- a/src/application/javascript/JavaScriptArtifactAnalysis.ts+++ b/src/application/javascript/JavaScriptArtifactAnalysis.ts@@ -11,7 +11,10 @@ import type { JavaScriptSemanticIr } from "../../domain/javascript/javascriptSemimport { projectJavaScriptModuleSemantics } from "../../domain/javascript/javascriptModuleSemanticIr.js";import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";-import { flattenSourceMapLeaves } from "../../domain/sourceMapEnvelope.js";+import {+ flattenSourceMapLeaves,+ sourceMapJsonText,+} from "../../domain/sourceMapEnvelope.js";import type {JavaScriptSourceRange,JavaScriptSourcePoint,@@ -521,7 +524,7 @@ const parseSourceMap = (if (!file.text.included) return unavailableSourceMap(file);let value: unknown;try {- value = JSON.parse(file.text.value);+ value = JSON.parse(sourceMapJsonText(file.text.value));} catch (cause: unknown) {void cause;return invalidSourceMap(file, "Source map is not valid JSON.");diff --git a/src/application/javascript/JavaScriptArtifactPathResolution.ts b/src/application/javascript/JavaScriptArtifactPathResolution.tsindex bd3bcdaaf..035014370 100644--- a/src/application/javascript/JavaScriptArtifactPathResolution.ts+++ b/src/application/javascript/JavaScriptArtifactPathResolution.ts@@ -176,9 +176,7 @@ const contextualCandidate = (): string | CandidateResolution => {const { context } = input;let declared =- context === "html-reference" ||- context === "url-reference" ||- (context === "module-specifier" && input.moduleKind !== "require")+ context === "html-reference" || context === "url-reference"? stripQueryAndFragment(input.declaredPath): input.declaredPath;if (context === "html-reference") return htmlCandidate(input);@@ -190,9 +188,9 @@ const contextualCandidate = ("URL and Node builtin schemes are outside static artifact module resolution.",]);if (!declared.startsWith(".") && !declared.startsWith("/"))- return bareModuleCandidate(input, declared);+ return bareModuleCandidate(input);if (input.moduleKind !== "require") {- const decoded = decodeModuleUrlPath(declared);+ const decoded = decodeModuleUrlPath(stripQueryAndFragment(declared));if (typeof decoded !== "string") return decoded;declared = decoded;}@@ -237,34 +235,51 @@ const relativeCandidate = (sourcePath: string, declared: string): string =>const bareModuleCandidate = (input: ResolveArtifactPathInput,- declared: string,): CandidateResolution => {- const packageName = barePackageName(declared);- if (packageName === null || isBuiltin(declared))+ const request = parseBarePackageRequest(input.declaredPath, input.moduleKind);+ if (request === null || isBuiltin(input.declaredPath))return unresolvedCandidate("external", ["The bare specifier is a Node builtin or invalid package name.",]);- if (input.moduleKind === "import" && packageName.includes("%"))+ if (input.moduleKind === "import" && request.packageName.includes("%"))return unresolvedCandidate("rejected", ["Percent signs are not admitted in ES module package names.",]);- const self = commonJsSelfCandidate(input, declared);+ const self = packageSelfCandidate(input, request);if (self !== null) return self;- const subpath =- declared === packageName ? "." : `.${declared.slice(packageName.length)}`;+ // ESM constructs a package.json URL; its parsed identity is not a literal+ // dependency directory. Self resolution above still uses the exact name.+ let dependencyDirectory = posix.join("node_modules", request.packageName);+ if (input.moduleKind === "import") {+ const metadataUrl = new URL(+ `./node_modules/${request.packageName}/package.json`,+ PACKAGE_ARTIFACT_ROOT_URL,+ );+ if (!metadataUrl.pathname.endsWith("/package.json"))+ return unresolvedCandidate("external", [+ `ESM package name ${JSON.stringify(request.packageName)} produces a dependency URL whose pathname does not name package.json; no literal or suffix-stripped package directory was searched.`,+ ]);+ const decoded = decodeModuleUrlPath(+ metadataUrl.pathname.slice(PACKAGE_ARTIFACT_ROOT_URL.pathname.length),+ );+ if (typeof decoded !== "string") return decoded;+ const confined = confineCandidate(decoded);+ if (typeof confined !== "string") return confined;+ dependencyDirectory = posix.dirname(confined);+ }const source = input.files.get(input.sourcePath);let directory = posix.dirname(input.sourcePath);while (true) {- const candidate = posix.join(directory, "node_modules", packageName);+ const candidate = posix.join(directory, dependencyDirectory);const metadata = readPackageMetadata(input, candidate);- if (packageExportsEligible(input) && metadata.kind !== "absent")- return resolvePackageSpecifier(input, candidate, subpath, metadata);- if (subpath === ".") {+ if (request.dependencyExportsEligible && metadata.kind !== "absent")+ return resolvePackageDependency(input, candidate, request, metadata);+ if (request.packageSubpath === ".") {const direct = resolveFileCandidates(input, fileCandidates(candidate));if (direct !== null) return direct;}if (hasContainerDirectory(input.files, candidate, source?.container_sha256))- return resolvePackageSpecifier(input, candidate, subpath, metadata);+ return resolvePackageDependency(input, candidate, request, metadata);if (directory === "." || directory === "") break;directory = posix.dirname(directory);}@@ -330,24 +345,25 @@ const resolvePackageImportAlias = (return unresolvedCandidate("external", [`Wildcard package import aliases remain unresolved; package metadata ${metadata.path} has no exact imports key ${specifier}.`,]);- const selected = selectPackageImportTarget(+ const selected = selectExportTarget(lookup.target,- input.moduleKind,- metadata.path,+ packageExportConditions(input.moduleKind),+ packageMetadataUrl(metadata.path),+ "imports",);- if (selected.status === "rejected")+ if (selected.kind === "invalid" || selected.kind === "invalid-config")return unresolvedCandidate("rejected", [`Package metadata ${metadata.path}: ${selected.limitation}`,]);- if (selected.status === "unmatched")+ if (selected.kind === "unmatched")return unresolvedCandidate("external", [`Package metadata ${metadata.path} declares no imports target for alias ${specifier} under the active conditions; it declares ${selected.declared.join(", ") || "no conditions"}.`,]);- if (selected.status === "blocked")+ if (selected.kind === "blocked")return unresolvedCandidate("external", [`Package metadata ${metadata.path} blocks import alias ${specifier} with ${selected.cause === "null" ? "an explicit null imports target" : "an empty imports target array"}.`,]);- if (selected.status === "non-relative") {+ if (selected.kind === "non-relative") {const target = classifyPackageImportTargetString(selected.value);return unresolvedCandidate("external", [target.kind === "recursive"@@ -358,77 +374,44 @@ const resolvePackageImportAlias = (return resolveExportTarget(input, metadata.path, selected, "imports");};-const selectPackageImportTarget = (- value: unknown,- moduleKind: ResolveArtifactPathInput["moduleKind"],- packagePath: string,-):- | ({ readonly status: "value" } & PackageFileTarget)- | { readonly status: "non-relative"; readonly value: string }- | { readonly status: "blocked"; readonly cause: PackageTargetBlockCause }- | { readonly status: "unmatched"; readonly declared: readonly string[] }- | { readonly status: "rejected"; readonly limitation: string } => {- const selected = selectExportTarget(- value,- packageExportConditions(moduleKind),- packageMetadataUrl(packagePath),- "imports",- );- if (selected.kind === "invalid" || selected.kind === "invalid-config")- return { status: "rejected", limitation: selected.limitation };- if (selected.kind === "unmatched")- return {- status: "unmatched",- declared: selected.declared,- };- if (selected.kind === "blocked")- return { status: "blocked", cause: selected.cause };- if (selected.kind === "non-relative")- return { status: "non-relative", value: selected.value };- return {- status: "value",- value: selected.value,- url: selected.url,- };-};-/** Self references use the nearest package scope before dependency lookup. */-const commonJsSelfCandidate = (+const packageSelfCandidate = (input: ResolveArtifactPathInput,- declared: string,+ request: BarePackageRequest,): CandidateResolution | null => {- if (input.moduleKind !== "require" || !input.files.has(input.sourcePath))+ if (input.moduleKind === undefined || !input.files.has(input.sourcePath))return null;const metadata = enclosingPackageMetadata(input);if (metadata.kind === "none") return null;if (metadata.kind === "unavailable")return unresolvedCandidate("unavailable", [metadata.limitation]);- if (- metadata.name === undefined ||- metadata.exports === undefined ||- (declared !== metadata.name && !declared.startsWith(`${metadata.name}/`))- )+ if (metadata.name === undefined || metadata.exports === undefined)return null;- const subpath =- declared === metadata.name- ? "."- : `.${declared.slice(metadata.name.length)}`;+ let subpath: string;+ if (input.moduleKind === "import") {+ if (metadata.name !== request.packageName) return null;+ subpath = request.packageSubpath;+ } else if (input.declaredPath === metadata.name) {+ subpath = ".";+ } else if (input.declaredPath.startsWith(`${metadata.name}/`)) {+ subpath = `.${input.declaredPath.slice(metadata.name.length)}`;+ } else return null;// Self resolution does not apply the CommonJS dependency-name matcher.return resolvePackageExports(input, metadata.path, subpath, metadata.exports);};-/** Package roots and exact subpaths share metadata and exports selection. */-const resolvePackageSpecifier = (+/** Resolve an installed dependency using one parsed request and its metadata. */+const resolvePackageDependency = (input: ResolveArtifactPathInput,directory: string,- subpath: string,+ request: BarePackageRequest,metadata: PackageMetadata,): CandidateResolution => {- const exportsEligible = packageExportsEligible(input);- if (exportsEligible && metadata.kind === "unavailable")+ const subpath = request.packageSubpath;+ if (request.dependencyExportsEligible && metadata.kind === "unavailable")return unresolvedCandidate("unavailable", [metadata.limitation]);const rawExports =- exportsEligible && metadata.kind === "available"+ request.dependencyExportsEligible && metadata.kind === "available"? metadata.exports: undefined;if (rawExports === undefined) {@@ -437,8 +420,17 @@ const resolvePackageSpecifier = (resolveFileCandidates(input, fileCandidates(directory)) ??resolveDirectory(input, directory, metadata, new Set()));- // Preserve the trailing slash for a package directory request.- const candidate = confineCandidate(`${directory}/${subpath.slice(2)}`);+ // Resolve legacy ESM subpaths as URLs: suffixes identify the loaded module+ // but do not belong to its filesystem path. Keep the declared specifier on+ // the relationship; only derive the inventory lookup path here.+ const fileSubpath =+ input.moduleKind === "import"+ ? decodeModuleUrlPath(stripQueryAndFragment(subpath.slice(2)))+ : subpath.slice(2);+ if (typeof fileSubpath !== "string") return fileSubpath;+ const candidate = confineCandidate(`${directory}/${fileSubpath}`);+ if (input.moduleKind === "import" && typeof candidate === "string")+ return resolveLegacyEsmSubpath(input, candidate);return typeof candidate === "string"? resolveCandidate(input, candidate, new Set()): candidate;@@ -451,6 +443,21 @@ const resolvePackageSpecifier = ();};+/** Legacy ESM package subpaths are exact URLs, never extension or directory lookups. */+const resolveLegacyEsmSubpath = (+ input: ResolveArtifactPathInput,+ candidate: string,+): CandidateResolution => {+ const file = resolveFileCandidates(input, [candidate]);+ if (file !== null) return file;+ const source = input.files.get(input.sourcePath);+ if (hasContainerDirectory(input.files, candidate, source?.container_sha256))+ return unresolvedCandidate("rejected", [+ `ESM package subpath ${candidate} names a directory; directory imports are unsupported and package main or index lookup was not attempted.`,+ ]);+ return exactPackageTargetNotFound(candidate, "ESM subpath");+};+const resolvePackageExports = (input: ResolveArtifactPathInput,packagePath: string,@@ -517,23 +524,36 @@ const resolveExportTarget = ();};-const barePackageName = (specifier: string): string | null => {- const segments = specifier.split("/");- if (specifier.startsWith("@"))- return segments.length >= 2 && segments[0] !== "" && segments[1] !== ""- ? `${segments[0]}/${segments[1]}`- : null;- return segments[0] === "" ? null : (segments[0] ?? null);-};+/** Derived package identity and dependency policy; input retains the raw request. */+interface BarePackageRequest {+ readonly packageName: string;+ readonly packageSubpath: string;+ readonly dependencyExportsEligible: boolean;+}-const packageExportsEligible = (input: ResolveArtifactPathInput): boolean => {- if (input.moduleKind !== "require") return true;+const parseBarePackageRequest = (+ specifier: string,+ moduleKind: ResolveArtifactPathInput["moduleKind"],+): BarePackageRequest | null => {+ const segments = specifier.split("/");+ let packageName = segments[0] ?? "";+ if (packageName === "") return null;+ if (specifier.startsWith("@")) {+ const packageSegment = segments[1];+ if (packageSegment === undefined || packageSegment === "") return null;+ packageName = `${packageName}/${packageSegment}`;+ }// Node's CommonJS exports matcher excludes percent-containing package names.// Compare the captured name so a scoped name cannot fall back to its scope.- const match = /^((?:@[^/\\%]+\/)?[^./\\%][^/\\%]*)(\/.*)?$/.exec(- input.declaredPath,- );- return match?.[1] === barePackageName(input.declaredPath);+ const dependencyExportsEligible =+ moduleKind !== "require" ||+ /^((?:@[^/\\%]+\/)?[^./\\%][^/\\%]*)(\/.*)?$/.exec(specifier)?.[1] ===+ packageName;+ return {+ packageName,+ packageSubpath: `.${specifier.slice(packageName.length)}`,+ dependencyExportsEligible,+ };};const hasContainerDirectory = (@@ -1061,12 +1081,12 @@ const notFoundCandidate = (): CandidateResolution => ({const exactPackageTargetNotFound = (path: string,- mapKind: "exports" | "imports",+ targetKind: "exports" | "imports" | "ESM subpath",): CandidateResolution => ({resolvedPath: null,status: "not-found",limitations: [- `The selected package ${mapKind === "imports" ? "import" : "exports"} target ${path} does not exist in the inventoried artifact container; ${mapKind === "imports" ? "import" : "exports"} targets are exact files, so no extension or directory index was tried.`,+ `The selected package ${targetKind === "imports" ? "import" : targetKind} target ${path} does not exist in the inventoried artifact container; ${targetKind === "imports" ? "import" : targetKind} targets are exact files, so no extension or directory index was tried.`,],});diff --git a/src/browser/WebSourceMapFetcher.ts b/src/browser/WebSourceMapFetcher.tsindex 6c74cff6c..3032f20ed 100644--- a/src/browser/WebSourceMapFetcher.ts+++ b/src/browser/WebSourceMapFetcher.ts@@ -20,10 +20,10 @@ import type {import { webSourceMapsSchema } from "../domain/webBundleAnalysis.js";import { createWebTextArtifact } from "../domain/webContentArtifact.js";import { safeParseJson } from "../domain/safeJson.js";+import { sourceMapJsonText } from "../domain/sourceMapEnvelope.js";import { jsonParts } from "../domain/jsonSerialization.js";import {inspectSourceMapValue,- sourceMapJsonText,SourceMapFormatFailure,type SourceMapLeaf,} from "../javascript/sourceMaps/SourceMapFormat.js";diff --git a/src/domain/sourceMapEnvelope.ts b/src/domain/sourceMapEnvelope.tsindex b5c78f1d4..65ac9f9c6 100644--- a/src/domain/sourceMapEnvelope.ts+++ b/src/domain/sourceMapEnvelope.ts@@ -8,6 +8,19 @@*/type SourceMapRecord = Readonly<Record<string, unknown>>;+/**+ * Return the JSON parsing view of retained source-map text. ECMA-426 permits+ * HTTP responses to start with `)]}'`; the first line is transport framing.+ * Keep the original text for artifact identity and Evidence provenance.+ * https://tc39.es/ecma426/#sec-fetchsourcemap+ */+export const sourceMapJsonText = (text: string): string => {+ const withoutBom = text.replace(/^\uFEFF/u, "");+ if (!withoutBom.startsWith(")]}'")) return withoutBom;+ const newline = withoutBom.search(/[\r\n]/u);+ return newline === -1 ? "" : withoutBom.slice(newline);+};+const isRecord = (value: unknown): value is SourceMapRecord =>typeof value === "object" && value !== null && !Array.isArray(value);diff --git a/src/javascript/sourceMaps/SourceMapFormat.ts b/src/javascript/sourceMaps/SourceMapFormat.tsindex 838c1082d..d59c8f3e5 100644--- a/src/javascript/sourceMaps/SourceMapFormat.ts+++ b/src/javascript/sourceMaps/SourceMapFormat.ts@@ -1,6 +1,7 @@import { z } from "zod";import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";+import { sourceMapJsonText } from "../../domain/sourceMapEnvelope.js";const leafSchema = z.object({version: z.literal(3),@@ -279,20 +280,6 @@ const inspectLeaf = (return leaf;};-/**- * Return the JSON view of source-map text without changing the source evidence.- * ECMA-426 §11.2.1 permits HTTP(S) responses to start with `)]}'`; the line- * through the first HTTP newline is transport framing, not map content. Local- * point tracing shares this parser and has historically accepted the same- * framing. https://tc39.es/ecma426/#sec-fetchsourcemap- */-export const sourceMapJsonText = (text: string): string => {- const withoutBom = text.replace(/^\uFEFF/u, "");- if (!withoutBom.startsWith(")]}'")) return withoutBom;- const newline = withoutBom.search(/[\r\n]/u);- return newline === -1 ? "" : withoutBom.slice(newline);-};-/** Validate structure before allocation, retaining raw declarations and section boundaries. */export const inspectSourceMap = (text: string,diff --git a/tests/acceptance/applications/packageImportAliasesCli.test.ts b/tests/acceptance/applications/packageImportAliasesCli.test.tsindex 7d3187a7f..fd52be267 100644--- a/tests/acceptance/applications/packageImportAliasesCli.test.ts+++ b/tests/acceptance/applications/packageImportAliasesCli.test.ts@@ -4,12 +4,10 @@ import { createRequire } from "node:module";import { dirname, join, relative } from "node:path";import { expect } from "vitest";-import { z } from "zod";-import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";-import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";import { cliTest } from "../../support/cli/cliFixture.js";+import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";const literalAliases = ["#/x", "#x%2Fy", "#x%2Ey", "#x\\y", "#x\0y"];const fallbackAliases = {@@ -158,26 +156,7 @@ cliTest.for(["CLI", "stdio MCP"] as const)(expect.objectContaining({ code: "ERR_PACKAGE_IMPORT_NOT_DEFINED" }),);- let document: unknown;- if (surface === "CLI") {- const response = await cli.run({- arguments: ["analyze-javascript-application", root, "--format", "json"],- environment: { REA_LOG_LEVEL: "silent" },- });- expect(response.exitCode, response.stderr).toBe(0);- document = response.json;- } else {- const { call } = await connectLocalToolsMcp();- const response = await call("analyze_javascript_application", {- input_path: root,- format: "directory",- });- expect(response.isError, JSON.stringify(response)).not.toBe(true);- document = response.structuredContent;- }- const { graph } = z- .object({ normalized_result: javascriptApplicationAnalysisResultSchema })- .parse(document).normalized_result;+ const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);for (const specifier of resolvedAliases)for (const [moduleKind, sourcePath, source] of [["require", "main.cjs", mainSource],diff --git a/tests/acceptance/applications/packageRootSuffixCli.test.ts b/tests/acceptance/applications/packageRootSuffixCli.test.tsnew file mode 100644index 000000000..ea8c81bbf--- /dev/null+++ b/tests/acceptance/applications/packageRootSuffixCli.test.ts@@ -0,0 +1,109 @@+import { execFile } from "node:child_process";+import { createHash } from "node:crypto";+import { mkdir, writeFile } from "node:fs/promises";+import { dirname, join } from "node:path";+import { promisify } from "node:util";++import { expect } from "vitest";++import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";+import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";++const requests = [+ { specifier: "legacy?x", plainName: "legacy", exports: false },+ { specifier: "exported#entry", plainName: "exported", exports: true },+ { specifier: "@scope/legacy?x", plainName: "@scope/legacy", exports: false },+ { specifier: "@scope#entry/pkg", plainName: "@scope/pkg", exports: true },+] as const;++// Windows cannot materialize the question-mark directories in this fixture.+cliTest.skipIf(process.platform === "win32").for(["CLI", "stdio MCP"] as const)(+ "keeps ESM root URL suffixes out of dependency filesystem lookup through %s",+ async (surface, { cli }) => {+ const root = await createTestTempDirectory("rea-package-root-suffix-");+ const sources = {+ "main.mjs": requests+ .map(({ specifier }) => `import ${JSON.stringify(specifier)};`)+ .join("\n"),+ "main.cjs": requests+ .map(({ specifier }) => `require(${JSON.stringify(specifier)});`)+ .join("\n"),+ };+ const files: Record<string, string> = { ...sources };+ for (const item of requests)+ for (const name of [item.specifier, item.plainName]) {+ const directory = `node_modules/${name}`;+ files[`${directory}/package.json`] = JSON.stringify(+ item.exports ? { exports: "./entry.cjs" } : { main: "./entry.cjs" },+ );+ files[`${directory}/entry.cjs`] =+ `module.exports = ${JSON.stringify(name)};`;+ }+ await Promise.all(+ Object.entries(files).map(async ([path, text]) => {+ const absolute = join(root, path);+ await mkdir(dirname(absolute), { recursive: true });+ await writeFile(absolute, text);+ }),+ );+ if (surface === "CLI") {+ const native = await promisify(execFile)(+ process.execPath,+ [+ "--input-type=module",+ "--eval",+ `import { createRequire } from "node:module";+const require = createRequire(new URL("./main.cjs", import.meta.url));+const requests = ${JSON.stringify(requests.map(({ specifier }) => specifier))};+const results = await Promise.all(requests.map(async (specifier) => {+ let esm;+ try { esm = { value: (await import(specifier)).default, error: null }; }+ catch (error) { esm = { value: null, error: error.code }; }+ return { esm, require: require(specifier) };+}));+console.log(JSON.stringify(results));`,+ ],+ { cwd: root, timeout: 5_000 },+ );+ expect(JSON.parse(native.stdout)).toEqual(+ requests.map(({ specifier }) => ({+ esm: { value: null, error: "ERR_MODULE_NOT_FOUND" },+ require: specifier,+ })),+ );+ }++ const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);+ for (const { specifier } of requests)+ for (const [moduleKind, sourcePath] of [+ ["import", "main.mjs"],+ ["require", "main.cjs"],+ ] as const)+ expect(graph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ properties: expect.objectContaining({+ module_link_kind: moduleKind,+ specifier,+ resolved_path:+ moduleKind === "import"+ ? null+ : `node_modules/${specifier}/entry.cjs`,+ resolution_status:+ moduleKind === "import" ? "external" : "resolved",+ }),+ evidence: expect.objectContaining({+ artifact: expect.objectContaining({+ sha256: createHash("sha256")+ .update(sources[sourcePath])+ .digest("hex"),+ }),+ location: expect.objectContaining({+ value: expect.objectContaining({ source: sourcePath }),+ }),+ }),+ }),+ );+ },+);diff --git a/tests/acceptance/applications/packageSelfNameBoundaryCli.test.ts b/tests/acceptance/applications/packageSelfNameBoundaryCli.test.tsnew file mode 100644index 000000000..a46b07d51--- /dev/null+++ b/tests/acceptance/applications/packageSelfNameBoundaryCli.test.ts@@ -0,0 +1,207 @@+import { execFile } from "node:child_process";+import { createHash } from "node:crypto";+import { mkdir, writeFile } from "node:fs/promises";+import { dirname, join } from "node:path";+import { promisify } from "node:util";++import { expect } from "vitest";++import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";+import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";++type SelfNameCase = {+ readonly directory: string;+ readonly packageName: string;+ readonly exportKey: string;+ readonly specifier: string;+ readonly selfValue: string;+ readonly dependency?: {+ readonly packagePath: string;+ readonly exportKey: string;+ readonly value: string;+ };+ readonly esmTarget: string;+ readonly requireTarget: string;+ readonly esmValue: string;+ readonly requireValue: string;+};++const cases = [+ {+ directory: "scope-prefix",+ packageName: "@scope",+ exportKey: "./pkg",+ specifier: "@scope/pkg",+ selfValue: "scope self",+ dependency: {+ packagePath: "node_modules/@scope/pkg",+ exportKey: ".",+ value: "scope dependency",+ },+ esmTarget: "scope-prefix/node_modules/@scope/pkg/dependency.cjs",+ requireTarget: "scope-prefix/self.cjs",+ esmValue: "scope dependency",+ requireValue: "scope self",+ },+ {+ directory: "slash-name",+ packageName: "fixture/sub",+ exportKey: "./feature",+ specifier: "fixture/sub/feature",+ selfValue: "slash self",+ dependency: {+ packagePath: "node_modules/fixture",+ exportKey: "./sub/feature",+ value: "slash dependency",+ },+ esmTarget: "slash-name/node_modules/fixture/dependency.cjs",+ requireTarget: "slash-name/self.cjs",+ esmValue: "slash dependency",+ requireValue: "slash self",+ },+ {+ directory: "slash-exact-name",+ packageName: "fixture/sub",+ exportKey: ".",+ specifier: "fixture/sub",+ selfValue: "slash exact self",+ dependency: {+ packagePath: "node_modules/fixture",+ exportKey: "./sub",+ value: "slash exact dependency",+ },+ esmTarget: "slash-exact-name/node_modules/fixture/dependency.cjs",+ requireTarget: "slash-exact-name/self.cjs",+ esmValue: "slash exact dependency",+ requireValue: "slash exact self",+ },+ {+ directory: "valid-scoped",+ packageName: "@scope/pkg",+ exportKey: "./feature",+ specifier: "@scope/pkg/feature",+ selfValue: "valid scoped self",+ esmTarget: "valid-scoped/self.cjs",+ requireTarget: "valid-scoped/self.cjs",+ esmValue: "valid scoped self",+ requireValue: "valid scoped self",+ },+ {+ directory: "query-self-name",+ packageName: "self?x",+ exportKey: ".",+ specifier: "self?x",+ selfValue: "query self",+ esmTarget: "query-self-name/self.cjs",+ requireTarget: "query-self-name/self.cjs",+ esmValue: "query self",+ requireValue: "query self",+ },+ {+ directory: "fragment-self-name",+ packageName: "@scope/self#entry",+ exportKey: ".",+ specifier: "@scope/self#entry",+ selfValue: "fragment self",+ esmTarget: "fragment-self-name/self.cjs",+ requireTarget: "fragment-self-name/self.cjs",+ esmValue: "fragment self",+ requireValue: "fragment self",+ },+] satisfies readonly SelfNameCase[];++const sourceFor = (specifier: string, moduleKind: "import" | "require") =>+ moduleKind === "import"+ ? `import value from ${JSON.stringify(specifier)};\nexport default value;`+ : `const value = require(${JSON.stringify(specifier)});\nmodule.exports = value;`;++const createSelfNameFixture = async () => {+ const root = await createTestTempDirectory("rea-package-self-name-boundary-");+ const files: Record<string, string> = {};+ for (const item of cases) {+ const prefix = item.directory;+ files[`${prefix}/package.json`] = JSON.stringify({+ name: item.packageName,+ exports: { [item.exportKey]: "./self.cjs" },+ });+ files[`${prefix}/main.mjs`] = sourceFor(item.specifier, "import");+ files[`${prefix}/main.cjs`] = sourceFor(item.specifier, "require");+ files[`${prefix}/self.cjs`] =+ `module.exports = ${JSON.stringify(item.selfValue)};`;+ if (item.dependency !== undefined) {+ const dependencyPrefix = `${prefix}/${item.dependency.packagePath}`;+ files[`${dependencyPrefix}/package.json`] = JSON.stringify({+ exports: { [item.dependency.exportKey]: "./dependency.cjs" },+ });+ files[`${dependencyPrefix}/dependency.cjs`] =+ `module.exports = ${JSON.stringify(item.dependency.value)};`;+ }+ }+ files["node-control.mjs"] = `import { createRequire } from "node:module";+const cases = ${JSON.stringify(cases.map(({ directory, specifier }) => ({ directory, specifier })))};+const esm = await Promise.all(+ cases.map(async ({ directory }) =>+ (await import(new URL(directory + "/main.mjs", import.meta.url))).default,+ ),+);+const require = cases.map(({ directory, specifier }) =>+ createRequire(new URL(directory + "/main.cjs", import.meta.url))(specifier),+);+console.log(JSON.stringify({ esm, require }));`;+ await Promise.all(+ Object.entries(files).map(async ([path, content]) => {+ const absolute = join(root, path);+ await mkdir(dirname(absolute), { recursive: true });+ await writeFile(absolute, content);+ }),+ );+ return root;+};++cliTest.for(["CLI", "stdio MCP"] as const)(+ "matches self references by parsed ESM name and preserves CommonJS prefix matching through %s",+ async (surface, { cli }) => {+ const root = await createSelfNameFixture();+ if (surface === "CLI") {+ const native = await promisify(execFile)(+ process.execPath,+ [join(root, "node-control.mjs")],+ { cwd: root, timeout: 5_000 },+ );+ expect(JSON.parse(native.stdout)).toEqual({+ esm: cases.map(({ esmValue }) => esmValue),+ require: cases.map(({ requireValue }) => requireValue),+ });+ }++ const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);+ for (const item of cases)+ for (const [moduleKind, target] of [+ ["import", item.esmTarget],+ ["require", item.requireTarget],+ ] as const) {+ const sourcePath = `${item.directory}/main.${moduleKind === "import" ? "mjs" : "cjs"}`;+ const source = sourceFor(item.specifier, moduleKind);+ expect(graph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ properties: expect.objectContaining({+ module_link_kind: moduleKind,+ specifier: item.specifier,+ resolved_path: target,+ resolution_status: "resolved",+ }),+ evidence: expect.objectContaining({+ artifact: expect.objectContaining({+ sha256: createHash("sha256").update(source).digest("hex"),+ }),+ location: expect.objectContaining({+ value: expect.objectContaining({ source: sourcePath }),+ }),+ }),+ }),+ );+ }+ },+);diff --git a/tests/acceptance/applications/packageSpecifierSuffixCli.test.ts b/tests/acceptance/applications/packageSpecifierSuffixCli.test.tsnew file mode 100644index 000000000..ad175006e--- /dev/null+++ b/tests/acceptance/applications/packageSpecifierSuffixCli.test.ts@@ -0,0 +1,278 @@+import { execFile } from "node:child_process";+import { createHash } from "node:crypto";+import { mkdir, writeFile } from "node:fs/promises";+import { join } from "node:path";+import { promisify } from "node:util";++import { expect } from "vitest";++import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";+import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";++type PackageSpecifierCase = {+ readonly specifier: string;+ readonly target: string | null;+ readonly status: "resolved" | "external" | "rejected" | "not-found";+ readonly value: string | number | null;+ readonly error: string | null;+};++const requests = [+ {+ specifier: "rea-self-fixture",+ target: "root.cjs",+ status: "resolved",+ value: 11,+ error: null,+ },+ {+ specifier: "rea-self-fixture/feature",+ target: "feature.cjs",+ status: "resolved",+ value: 22,+ error: null,+ },+ {+ specifier: "rea-self-fixture/feature?cache=1",+ target: "punctuated.cjs",+ status: "resolved",+ value: 33,+ error: null,+ },+ {+ specifier: "rea-self-fixture/feature?cache=2",+ target: null,+ status: "external",+ value: null,+ error: "ERR_PACKAGE_PATH_NOT_EXPORTED",+ },+ {+ specifier: "rea-self-fixture/feature#entry",+ target: null,+ status: "external",+ value: null,+ error: "ERR_PACKAGE_PATH_NOT_EXPORTED",+ },+ {+ specifier: "fixture/feature?cache=1",+ target: null,+ status: "external",+ value: null,+ error: "ERR_PACKAGE_PATH_NOT_EXPORTED",+ },+ {+ specifier: "fixture/feature#entry",+ target: null,+ status: "external",+ value: null,+ error: "ERR_PACKAGE_PATH_NOT_EXPORTED",+ },+ {+ specifier: "fixture/literal?cache=1",+ target: "node_modules/fixture/literal.cjs",+ status: "resolved",+ value: "literal",+ error: null,+ },+ {+ specifier: "legacy/?cache=1",+ target: null,+ status: "rejected",+ value: null,+ error: "ERR_UNSUPPORTED_DIR_IMPORT",+ },+ {+ specifier: "legacy/#entry",+ target: null,+ status: "rejected",+ value: null,+ error: "ERR_UNSUPPORTED_DIR_IMPORT",+ },+ {+ specifier: "legacy/nested/?cache=1",+ target: null,+ status: "rejected",+ value: null,+ error: "ERR_UNSUPPORTED_DIR_IMPORT",+ },+ {+ specifier: "legacy/nested/#entry",+ target: null,+ status: "rejected",+ value: null,+ error: "ERR_UNSUPPORTED_DIR_IMPORT",+ },+ {+ specifier: "legacy/feature.js",+ target: "node_modules/legacy/feature.js",+ status: "resolved",+ value: "legacy feature",+ error: null,+ },+ {+ specifier: "legacy/feature.js?cache=1",+ target: "node_modules/legacy/feature.js",+ status: "resolved",+ value: "legacy feature",+ error: null,+ },+ {+ specifier: "legacy/feature.js#entry",+ target: "node_modules/legacy/feature.js",+ status: "resolved",+ value: "legacy feature",+ error: null,+ },+ {+ specifier: "legacy/with%20space.js?cache=1",+ target: "node_modules/legacy/with space.js",+ status: "resolved",+ value: "legacy spaced feature",+ error: null,+ },+ {+ specifier: "legacy/feature",+ target: null,+ status: "not-found",+ value: null,+ error: "ERR_MODULE_NOT_FOUND",+ },+] satisfies readonly PackageSpecifierCase[];++const createPackageSpecifierFixture = async (): Promise<{+ readonly root: string;+ readonly source: string;+}> => {+ const root = await createTestTempDirectory("rea-package-specifier-suffix-");+ const packagePath = join(root, "node_modules", "fixture");+ const legacyPackagePath = join(root, "node_modules", "legacy");+ await Promise.all([+ mkdir(packagePath, { recursive: true }),+ mkdir(join(legacyPackagePath, "nested"), { recursive: true }),+ ]);+ await writeFile(+ join(root, "package.json"),+ JSON.stringify({+ name: "rea-self-fixture",+ exports: {+ ".": { import: "./root.cjs", require: "./require.cjs" },+ "./feature": { import: "./feature.cjs", require: "./require.cjs" },+ "./feature?cache=1": {+ import: "./punctuated.cjs",+ require: "./require.cjs",+ },+ },+ }),+ );+ const source = requests+ .map(+ ({ specifier }, index) =>+ `import value${index} from ${JSON.stringify(specifier)};`,+ )+ .join("\n");+ await Promise.all([+ writeFile(join(root, "main.mjs"), source),+ writeFile(join(root, "root.cjs"), "module.exports = 11;"),+ writeFile(join(root, "feature.cjs"), "module.exports = 22;"),+ writeFile(join(root, "punctuated.cjs"), "module.exports = 33;"),+ writeFile(join(root, "require.cjs"), "module.exports = -1;"),+ ]);+ await writeFile(+ join(packagePath, "package.json"),+ JSON.stringify({+ exports: {+ "./feature": "./feature.cjs",+ "./literal?cache=1": "./literal.cjs",+ },+ }),+ );+ await Promise.all([+ writeFile(join(packagePath, "feature.cjs"), 'module.exports = "feature";'),+ writeFile(join(packagePath, "literal.cjs"), 'module.exports = "literal";'),+ writeFile(+ join(legacyPackagePath, "package.json"),+ JSON.stringify({ name: "legacy", main: "./main.cjs" }),+ ),+ writeFile(+ join(legacyPackagePath, "main.cjs"),+ 'module.exports = "legacy root";',+ ),+ writeFile(+ join(legacyPackagePath, "feature.js"),+ 'module.exports = "legacy feature";',+ ),+ writeFile(+ join(legacyPackagePath, "with space.js"),+ 'module.exports = "legacy spaced feature";',+ ),+ writeFile(+ join(legacyPackagePath, "nested", "package.json"),+ JSON.stringify({ main: "./main.cjs" }),+ ),+ writeFile(+ join(legacyPackagePath, "nested", "main.cjs"),+ 'module.exports = "legacy nested";',+ ),+ ]);+ return { root, source };+};++cliTest.for(["CLI", "stdio MCP"] as const)(+ "resolves package self references and suffix keys through %s",+ async (surface, { cli }) => {+ const { root, source } = await createPackageSpecifierFixture();+ if (surface === "CLI") {+ const native = await promisify(execFile)(+ process.execPath,+ [+ "--input-type=module",+ "-e",+ `const requests = ${JSON.stringify(requests.map(({ specifier }) => specifier))};+ const results = await Promise.all(requests.map(async (specifier) => {+ try {+ const result = await import(specifier);+ return { value: result.default, error: null };+ } catch (error) {+ return { value: null, error: error.code };+ }+ }));+ console.log(JSON.stringify(results));`,+ ],+ { cwd: root, timeout: 5_000 },+ );+ expect(JSON.parse(native.stdout)).toEqual(+ requests.map(({ value, error }) => ({ value, error })),+ );+ }++ const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);+ for (const { specifier, target, status } of requests)+ expect(graph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ properties: expect.objectContaining({+ module_link_kind: "import",+ specifier,+ resolved_path: target,+ resolution_status: status,+ }),+ evidence: expect.objectContaining({+ ...(specifier === "legacy/feature"+ ? {+ limitations: expect.arrayContaining([+ "The selected package ESM subpath target node_modules/legacy/feature does not exist in the inventoried artifact container; ESM subpath targets are exact files, so no extension or directory index was tried.",+ ]),+ }+ : {}),+ artifact: expect.objectContaining({+ sha256: createHash("sha256").update(source).digest("hex"),+ }),+ location: expect.objectContaining({+ value: expect.objectContaining({ source: "main.mjs" }),+ }),+ }),+ }),+ );+ },+);diff --git a/tests/acceptance/applications/packageSubpathsCli.test.ts b/tests/acceptance/applications/packageSubpathsCli.test.tsindex 7b192fd66..ab202f03d 100644--- a/tests/acceptance/applications/packageSubpathsCli.test.ts+++ b/tests/acceptance/applications/packageSubpathsCli.test.ts@@ -7,9 +7,9 @@ import { expect } from "vitest";import { z } from "zod";import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";-import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";import { cliTest } from "../../support/cli/cliFixture.js";+import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";const createPackageSubpathFixture = async () => {const root = await createTestTempDirectory("rea-package-subpaths-");@@ -124,26 +124,7 @@ cliTest.for(["CLI", "stdio MCP"] as const)().replaceAll("\\", "/"),).toBe("node_modules/fi%xture/actual.cjs");- let document: unknown;- if (surface === "CLI") {- const response = await cli.run({- arguments: ["analyze-javascript-application", root, "--format", "json"],- environment: { REA_LOG_LEVEL: "silent" },- });- expect(response.exitCode, response.stderr).toBe(0);- document = response.json;- } else {- const { call } = await connectLocalToolsMcp();- const response = await call("analyze_javascript_application", {- input_path: root,- format: "directory",- });- expect(response.isError, JSON.stringify(response)).not.toBe(true);- document = response.structuredContent;- }- const { graph } = z- .object({ normalized_result: javascriptApplicationAnalysisResultSchema })- .parse(document).normalized_result;+ const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);const imports = graph.edges.filter(({ properties }) => properties.module_link_kind === "require",);diff --git a/tests/acceptance/applications/sourceMapPrefixCli.test.ts b/tests/acceptance/applications/sourceMapPrefixCli.test.tsnew file mode 100644index 000000000..4865b0289--- /dev/null+++ b/tests/acceptance/applications/sourceMapPrefixCli.test.ts@@ -0,0 +1,79 @@+import { createHash } from "node:crypto";+import { readFile, writeFile } from "node:fs/promises";+import { join } from "node:path";++import { expect } from "vitest";+import { z } from "zod";++import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";+import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";++cliTest.for(["CLI", "stdio MCP"] as const)(+ "recovers retained prefixed source-map originals and byte identity through %s",+ async (surface, { cli }) => {+ const root = await createTestTempDirectory("rea-retained-map-prefix-");+ const original = "export const answer: number = 42;";+ const mapText = `\uFEFF)]}'retained response\r\n${JSON.stringify({+ version: 3,+ sources: ["original.ts"],+ sourcesContent: [original],+ names: [],+ mappings: "AAAA",+ })}`;+ const mapPath = join(root, "bundle.js.map");+ await writeFile(+ join(root, "bundle.js"),+ "export const answer = 42;\n//# sourceMappingURL=bundle.js.map\n",+ );+ await writeFile(mapPath, mapText);++ let document: unknown;+ if (surface === "CLI") {+ const response = await cli.run({+ arguments: ["analyze-javascript-application", root, "--format", "json"],+ environment: { REA_LOG_LEVEL: "silent" },+ });+ expect(response.exitCode, response.stderr).toBe(0);+ document = response.json;+ } else {+ const { call } = await connectLocalToolsMcp();+ const response = await call("analyze_javascript_application", {+ input_path: root,+ format: "directory",+ });+ expect(response.isError, JSON.stringify(response)).not.toBe(true);+ document = response.structuredContent;+ }+ const { graph } = z+ .object({ normalized_result: javascriptApplicationAnalysisResultSchema })+ .parse(document).normalized_result;+ const mapDigest = createHash("sha256").update(mapText).digest("hex");+ expect(graph.nodes).toContainEqual(+ expect.objectContaining({+ kind: "source-module",+ identity: expect.objectContaining({+ strategy: "source-map-original",+ source_map_sha256: mapDigest,+ original_source: "original.ts",+ source_sha256: createHash("sha256").update(original).digest("hex"),+ }),+ observations: expect.arrayContaining([+ expect.objectContaining({+ source_map_reference: expect.objectContaining({+ source_name: "original.ts",+ map_path: "bundle.js.map",+ }),+ properties: { content_available: true },+ evidence: expect.objectContaining({+ artifact: expect.objectContaining({ sha256: mapDigest }),+ }),+ }),+ ]),+ }),+ );+ expect(graph.coverage.status).toBe("complete");+ expect(await readFile(mapPath, "utf8")).toBe(mapText);+ },+);diff --git a/tests/support/cli/javascriptApplication.ts b/tests/support/cli/javascriptApplication.tsnew file mode 100644index 000000000..085792100--- /dev/null+++ b/tests/support/cli/javascriptApplication.ts@@ -0,0 +1,34 @@+import { expect } from "vitest";+import { z } from "zod";++import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";+import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";+import type { TestCli } from "./cliFixture.js";++/** Analyze a directory through a public adapter and validate its result contract. */+export const analyzeJavaScriptDirectory = async (+ surface: "CLI" | "stdio MCP",+ cli: TestCli,+ root: string,+) => {+ let document: unknown;+ if (surface === "CLI") {+ const response = await cli.run({+ arguments: ["analyze-javascript-application", root, "--format", "json"],+ environment: { REA_LOG_LEVEL: "silent" },+ });+ expect(response.exitCode, response.stderr).toBe(0);+ document = response.json;+ } else {+ const { call } = await connectLocalToolsMcp();+ const response = await call("analyze_javascript_application", {+ input_path: root,+ format: "directory",+ });+ expect(response.isError, JSON.stringify(response)).not.toBe(true);+ document = response.structuredContent;+ }+ return z+ .object({ normalized_result: javascriptApplicationAnalysisResultSchema })+ .parse(document).normalized_result;+};