diff --git a/docs/javascript-artifact-reconstruction.md b/docs/javascript-artifact-reconstruction.md index 47eca1e8c..7bdf39959 100644 --- a/docs/javascript-artifact-reconstruction.md +++ b/docs/javascript-artifact-reconstruction.md @@ -231,6 +231,15 @@ Package `exports` fallback arrays are supported both at the top level and under the root `"."` entry. The resolver selects targets in declared order using the same conditional and invalid-entry handling as nested exports arrays. +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 +fields retain literal filename punctuation. Exports targets must start with +`./` and exclude `.`, `..`, and `node_modules` path segments, including their +encoded forms, before URL normalization. Arrays skip invalid exports targets +in declared order; URL decoding and file lookup failures for a selected target +do not select a later entry. Rejected references retain the package metadata +path, original target, failed constraint, and importing source location. + HTML script references resolve to exact inventoried files after applying the document base and query/fragment rules. CommonJS module lookups retain extension and directory resolution. diff --git a/src/application/javascript/JavaScriptArtifactPathResolution.ts b/src/application/javascript/JavaScriptArtifactPathResolution.ts index 53b871efd..143d4503a 100644 --- a/src/application/javascript/JavaScriptArtifactPathResolution.ts +++ b/src/application/javascript/JavaScriptArtifactPathResolution.ts @@ -86,10 +86,11 @@ const resolvePackagePath = ( input: ResolveArtifactPathInput, packageChain: ReadonlySet, mode: "full" | "files-and-index" = "full", + exportsTargetUrl = false, ): ArtifactPathResolution => { const rejected = rejectDeclaration(input); if (rejected !== null) return rejected; - const candidate = contextualCandidate(input); + const candidate = contextualCandidate(input, exportsTargetUrl); if (typeof candidate !== "string") return candidate; const confined = confineCandidate(input, candidate); if (typeof confined !== "string") return confined; @@ -135,11 +136,13 @@ const rejectDeclaration = ( const contextualCandidate = ( input: ResolveArtifactPathInput, + exportsTargetUrl: boolean, ): string | ArtifactPathResolution => { const { context } = input; - const declared = + let declared = context === "html-reference" || context === "url-reference" || + exportsTargetUrl || (context === "module-specifier" && input.moduleKind !== "require") ? stripQueryAndFragment(input.declaredPath) : input.declaredPath; @@ -157,6 +160,24 @@ const contextualCandidate = ( return unresolvedOutcome(input, "external", [ "URL schemes and protocol-relative URLs are outside this local artifact path context.", ]); + // Exports targets use URL paths for both loaders; legacy main fields remain literal. + if ( + exportsTargetUrl || + (context === "module-specifier" && input.moduleKind !== "require") + ) { + try { + declared = decodeURIComponent(declared); + } catch (cause: unknown) { + void cause; + return unresolvedOutcome(input, "rejected", [ + "The module URL path contains malformed percent encoding.", + ]); + } + if (declared.includes("\0")) + return unresolvedOutcome(input, "rejected", [ + "The decoded module URL path contains NUL.", + ]); + } const relative = declared.startsWith("/") ? declared.slice(1) : declared; return declared.startsWith("/") ? relative @@ -328,6 +349,12 @@ const resolveCandidate = ( `Directory package metadata ${packagePath} is not valid package JSON.`, ], }; + if (main.status === "rejected") + return { + resolvedPath: null, + status: "rejected", + limitations: [`Package metadata ${packagePath}: ${main.limitation}`], + }; if (main.status === "unmatched") return { resolvedPath: null, @@ -364,7 +391,9 @@ const resolveCandidate = ( if (index !== null) return index; } // Preserve recursive artifact package lookup only after legacy file/index fallbacks. - return candidateOutcome(resolvePackagePath(entryInput, chain)); + return candidateOutcome( + resolvePackagePath(entryInput, chain, "full", main.source === "exports"), + ); }; const candidateOutcome = ( @@ -419,6 +448,7 @@ const packageEntry = ( } | { readonly status: "missing" } | { readonly status: "invalid" } + | { readonly status: "rejected"; readonly limitation: string } | { readonly status: "unmatched"; readonly declared: readonly string[] } => { try { const value: unknown = JSON.parse(text); @@ -450,24 +480,53 @@ const packageExport = ( value: unknown, moduleKind: ResolveArtifactPathInput["moduleKind"], ): PackageExportOutcome => { - if (typeof value === "string") return packagePathValue(value); - if (typeof value !== "object" || value === null) return { status: "invalid" }; - const root = Reflect.get(value, ".") ?? value; - if (typeof root === "string") return packagePathValue(root); - if (typeof root !== "object" || root === null) return { status: "invalid" }; + const root = + typeof value === "object" && value !== null && Object.hasOwn(value, ".") + ? Reflect.get(value, ".") + : value; const flattened = exportTargets(root, packageExportConditions(moduleKind)); - if (flattened.kind === "invalid") return { status: "invalid" }; + if (flattened.kind === "invalid") + return { status: "rejected", limitation: flattened.limitation }; const first = flattened.kind === "unmatched" ? undefined : flattened.values[0]; return first === undefined - ? { status: "unmatched", declared: Object.keys(root) } + ? { + status: "unmatched", + declared: + typeof root === "object" && root !== null ? Object.keys(root) : [], + } : { status: "value", value: first }; }; type ExportTargets = | { readonly kind: "targets"; readonly values: readonly string[] } | { readonly kind: "unmatched" } - | { readonly kind: "invalid" }; + | { readonly kind: "invalid"; readonly limitation: string }; + +const invalidExportTarget = ( + value: unknown, + reason: string, +): ExportTargets => ({ + kind: "invalid", + limitation: `The package exports target ${JSON.stringify(value) ?? String(value)} ${reason}.`, +}); + +// Node checks raw target segments before URL normalization. Compare encoded +// segment names here; full URL decoding follows array target selection. +const forbiddenExportSegment = (value: string): string | undefined => + value + .slice(2) + .split(/[\\/]/u) + .find((raw) => { + const segment = raw.replace(/%[0-9a-f]{2}/giu, (encoded) => + String.fromCharCode(Number.parseInt(encoded.slice(1), 16)), + ); + return ( + segment === "." || + segment === ".." || + segment.toLowerCase() === "node_modules" + ); + }); /** * Resolve a target in Node's declared order. Explicit null blocks an active @@ -479,26 +538,39 @@ const exportTargets = ( value: unknown, conditions: ReadonlySet, ): ExportTargets => { - if (typeof value === "string") - return value.startsWith("./") + if (typeof value === "string") { + if (!value.startsWith("./")) + return invalidExportTarget(value, 'must start with "./"'); + const forbidden = forbiddenExportSegment(value); + return forbidden === undefined ? { kind: "targets", values: [value] } - : { kind: "invalid" }; + : invalidExportTarget( + value, + `contains forbidden path segment ${JSON.stringify(forbidden)} before URL normalization`, + ); + } if (value === null) return { kind: "targets", values: [] }; if (Array.isArray(value)) { - let invalid = false; + let invalid: string | null = null; for (const entry of value) { const nested = exportTargets(entry, conditions); if (nested.kind === "invalid") { - invalid = true; + invalid = nested.limitation; continue; } if (nested.kind === "unmatched") continue; - invalid = false; + invalid = null; if (nested.values.length > 0) return nested; } - return invalid ? { kind: "invalid" } : { kind: "targets", values: [] }; + return invalid === null + ? { kind: "targets", values: [] } + : { kind: "invalid", limitation: invalid }; } - if (typeof value !== "object") return { kind: "invalid" }; + if (typeof value !== "object") + return invalidExportTarget( + value, + "must be a relative string, object, array, or null", + ); for (const [condition, target] of Object.entries(value)) { if (!conditions.has(condition)) continue; const nested = exportTargets(target, conditions); @@ -525,7 +597,7 @@ const packageExportConditions = ( type PackageExportOutcome = | { readonly status: "value"; readonly value: string } - | { readonly status: "invalid" } + | { readonly status: "rejected"; readonly limitation: string } | { readonly status: "unmatched"; readonly declared: readonly string[] }; const packagePathValue = ( diff --git a/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts b/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts index ee5809771..6d4ac24be 100644 --- a/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts +++ b/src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts @@ -1,7 +1,14 @@ import { describe, expect, it } from "vitest"; +import { execFile } from "node:child_process"; +import { mkdir, writeFile } from "node:fs/promises"; +import { join } from "node:path"; +import { promisify } from "node:util"; +import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js"; import type { JavaScriptArtifactFile } from "../../domain/javascript/javascriptArtifactFiles.js"; import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js"; +import { analyzeJavaScriptApplication } from "./JavaScriptApplicationService.js"; +import { javascriptApplicationAnalysisResultSchema } from "../../domain/javascript/javascriptApplicationAnalysis.js"; const filesFor = (paths: readonly string[]) => new Map( @@ -84,3 +91,241 @@ describe("module specifier punctuation", () => { }, ); }); + +describe("ESM module URL decoding", () => { + it.each([ + ["./plain.mjs", "plain.mjs"], + ["./space%20name.mjs", "space name.mjs"], + ["./pr%C3%A9load.mjs", "préload.mjs"], + ["./name%3F%23.mjs", "name?#.mjs"], + ["./percent%2520.mjs?cache=1#v2", "percent%20.mjs"], + ])( + "points %s imports to the file loaded by Node", + async (specifier, target) => { + const root = await createTestTempDirectory("rea-module-url-"); + const main = join(root, "main.mjs"); + await writeFile( + main, + `import value from ${JSON.stringify(specifier)}; console.log(value);`, + ); + await writeFile( + join(root, target), + `export default ${JSON.stringify(target)};`, + ); + const encoded = specifier.slice(2).split("?", 1)[0]?.split("#", 1)[0]; + if (encoded !== undefined && encoded !== target) + await writeFile(join(root, encoded), 'export default "encoded decoy";'); + const native = await promisify(execFile)(process.execPath, [main], { + timeout: 5_000, + }); + expect(native.stdout.trim()).toBe(target); + + const result = await analyzeJavaScriptApplication({ + input_path: root, + format: "directory", + }); + expect(result.ok).toBe(true); + if (!result.ok) throw result.error; + const { graph } = javascriptApplicationAnalysisResultSchema.parse( + result.value.normalized_result, + ); + const imports = graph.edges.filter( + (edge) => + edge.relation === "imports" && + edge.properties.specifier === specifier, + ); + expect(imports.length).toBeGreaterThan(0); + for (const edge of imports) + expect(edge.properties.resolved_path).toBe(target); + }, + ); + + it("preserves CommonJS literal percent names", () => { + expect( + resolveArtifactPathByContext({ + declaredPath: "./space%20name.cjs", + sourcePath: "app/main.js", + context: "module-specifier", + moduleKind: "require", + files: filesFor(["app/space%20name.cjs", "app/space name.cjs"]), + }), + ).toMatchObject({ + resolved_path: "app/space%20name.cjs", + resolution_status: "resolved", + }); + }); + + it.each(["./invalid%.mjs", "./invalid%C3.mjs", "./nul%00.mjs"])( + "rejects malformed or NUL URL %s", + (declaredPath) => { + expect( + resolveArtifactPathByContext({ + declaredPath, + sourcePath: "app/main.js", + context: "module-specifier", + moduleKind: "import", + files: filesFor([`app/${declaredPath.slice(2)}`]), + }), + ).toMatchObject({ resolved_path: null, resolution_status: "rejected" }); + }, + ); +}); + +const packageEntryUrlCases = [ + ["exports", "./actual%20file.cjs", "actual file.cjs"], + ["exports", "./actual.cjs?variant", "actual.cjs"], + ["exports", "./actual.cjs#variant", "actual.cjs"], + ["exports", "./actual%23file.cjs", "actual#file.cjs"], + ["exports", "./actual%3Ffile.cjs", "actual?file.cjs"], + ["exports", "./actual%252Ffile.cjs", "actual%2Ffile.cjs"], + ["exports", "./actual.cjs", "actual.cjs"], + ["main", "./actual%20file.cjs", "actual%20file.cjs"], + ["main", "./actual?file.cjs", "actual?file.cjs"], + ["main", "./actual#file.cjs", "actual#file.cjs"], +] as const; + +describe("package exports URL paths", () => { + it.each( + (["import", "require"] as const).flatMap((moduleKind) => + packageEntryUrlCases.map(([field, declaredPath, target]) => ({ + moduleKind, + field, + declaredPath, + target, + })), + ), + )( + "matches Node $moduleKind for $field $declaredPath", + async ({ moduleKind, field, declaredPath, target }) => { + const root = await createTestTempDirectory("rea-package-export-url-"); + const packageRoot = join(root, "node_modules", "fixture"); + await mkdir(packageRoot, { recursive: true }); + await writeFile( + join(packageRoot, "package.json"), + JSON.stringify({ + name: "fixture", + [field]: declaredPath, + }), + ); + await writeFile( + join(packageRoot, target), + `module.exports=${JSON.stringify(target)};`, + ); + const literal = declaredPath.slice(2).split("?", 1)[0]?.split("#", 1)[0]; + if (literal !== undefined && literal !== target) + await writeFile( + join(packageRoot, literal), + 'module.exports="literal decoy";', + ); + const main = join( + root, + moduleKind === "import" ? "main.mjs" : "main.cjs", + ); + await writeFile( + main, + moduleKind === "import" + ? 'import value from "fixture"; console.log(value);' + : 'console.log(require("fixture"));', + ); + const native = await promisify(execFile)(process.execPath, [main], { + timeout: 5_000, + }); + expect(native.stdout.trim()).toBe(target); + const result = await analyzeJavaScriptApplication({ + input_path: root, + format: "directory", + }); + expect(result.ok).toBe(true); + if (!result.ok) throw result.error; + const { graph } = javascriptApplicationAnalysisResultSchema.parse( + result.value.normalized_result, + ); + const imports = graph.edges.filter( + (edge) => + edge.relation === "imports" && + edge.properties.specifier === "fixture", + ); + expect(imports.length).toBeGreaterThan(0); + for (const edge of imports) + expect(edge.properties.resolved_path).toBe( + `node_modules/fixture/${target}`, + ); + }, + ); + + it.each( + (["import", "require"] as const).flatMap((moduleKind) => + [ + "./actual%file.cjs", + "./actual%E0%A4file.cjs", + "./actual%00file.cjs", + "./actual%2Ffile.cjs", + "./actual%5Cfile.cjs", + "./actual%2Efile.cjs", + "./../../../../escape.cjs", + ].map((declaredPath) => ({ moduleKind, declaredPath })), + ), + )( + "rejects $moduleKind URL $declaredPath without borrowing a literal decoy", + ({ moduleKind, declaredPath }) => { + const packagePath = "app/node_modules/fixture/package.json"; + const files = filesFor([ + packagePath, + `app/node_modules/fixture/${declaredPath.slice(2)}`, + ]); + const metadata = files.get(packagePath); + if (metadata === undefined) throw new Error("Missing fixture metadata"); + files.set(packagePath, { + ...metadata, + kind: "package-json", + text: { + included: true, + value: JSON.stringify({ exports: declaredPath }), + }, + }); + expect( + resolveArtifactPathByContext({ + declaredPath: "fixture", + sourcePath: "app/main.js", + context: "module-specifier", + moduleKind, + files, + }), + ).toMatchObject({ resolved_path: null, resolution_status: "rejected" }); + }, + ); + + it.each(["import", "require"] as const)( + "keeps %s exports inside their inventoried container", + (moduleKind) => { + const packagePath = "app/node_modules/fixture/package.json"; + const target = "app/node_modules/fixture/actual file.cjs"; + const files = filesFor([packagePath, target]); + const metadata = files.get(packagePath); + const crossContainer = files.get(target); + if (metadata === undefined || crossContainer === undefined) + throw new Error("Missing fixture files"); + files.set(packagePath, { + ...metadata, + kind: "package-json", + text: { + included: true, + value: '{"exports":"./actual%20file.cjs"}', + }, + }); + files.set(target, { + ...crossContainer, + container_sha256: "c".repeat(64), + }); + expect( + resolveArtifactPathByContext({ + declaredPath: "fixture", + sourcePath: "app/main.js", + context: "module-specifier", + moduleKind, + files, + }), + ).toMatchObject({ resolved_path: null, resolution_status: "not-found" }); + }, + ); +}); diff --git a/tests/boundary/filesystem/javascriptPackageExportTargets.test.ts b/tests/boundary/filesystem/javascriptPackageExportTargets.test.ts new file mode 100644 index 000000000..dafd2cba2 --- /dev/null +++ b/tests/boundary/filesystem/javascriptPackageExportTargets.test.ts @@ -0,0 +1,231 @@ +import { execFile } from "node:child_process"; +import { mkdir, writeFile } from "node:fs/promises"; +import { dirname, join } from "node:path"; +import { promisify } from "node:util"; + +import { expect, it } from "vitest"; +import { z } from "zod"; + +import { reconstructJavaScriptArtifact } from "../../../src/application/javascript/JavaScriptArtifactReconstruction.js"; +import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; + +const cases: readonly { + name: string; + exports: unknown; + expected: string | null; + nodeError?: string; + rejectedTarget?: string; +}[] = [ + ...[ + "./../outside.cjs", + "./lib/../actual.cjs", + "././actual.cjs", + "./node_modules/actual.cjs", + "./NODE_MODULES/actual.cjs", + "./%2e%2e/outside.cjs", + "./n%6fde_modules/actual.cjs", + "./lib\\..\\actual.cjs", + "../outside.cjs", + "actual.cjs", + "/actual.cjs", + "file:./actual.cjs", + "", + ].map((target) => ({ + name: `invalid target ${JSON.stringify(target)}`, + exports: target, + expected: null, + nodeError: "ERR_INVALID_PACKAGE_TARGET", + rejectedTarget: target, + })), + { + name: "root subpath rejects a parent segment", + exports: { ".": "./../outside.cjs" }, + expected: null, + nodeError: "ERR_INVALID_PACKAGE_TARGET", + rejectedTarget: "./../outside.cjs", + }, + { + name: "active condition rejects instead of selecting default", + exports: { node: "./../outside.cjs", default: "./actual.cjs" }, + expected: null, + nodeError: "ERR_INVALID_PACKAGE_TARGET", + rejectedTarget: "./../outside.cjs", + }, + { + name: "top-level array skips an invalid target", + exports: ["./../outside.cjs", "./actual.cjs"], + expected: "node_modules/fixture/actual.cjs", + }, + { + name: "root array skips encoded invalid segments", + exports: { ".": ["./%2e%2e/outside.cjs", "./actual.cjs"] }, + expected: "node_modules/fixture/actual.cjs", + }, + { + name: "nested arrays skip invalid package-local segments", + exports: { node: [["./n%6fde_modules/actual.cjs", "./actual.cjs"]] }, + expected: "node_modules/fixture/actual.cjs", + }, + { + name: "last invalid target retains its reason", + exports: ["./../outside.cjs", "././actual.cjs"], + expected: null, + nodeError: "ERR_INVALID_PACKAGE_TARGET", + rejectedTarget: "././actual.cjs", + }, + { + name: "null following an invalid target blocks exports", + exports: ["./../outside.cjs", null], + expected: null, + nodeError: "ERR_PACKAGE_PATH_NOT_EXPORTED", + }, + { + name: "an invalid target following null remains invalid", + exports: [null, "./../outside.cjs"], + expected: null, + nodeError: "ERR_INVALID_PACKAGE_TARGET", + rejectedTarget: "./../outside.cjs", + }, + { + name: "inactive invalid condition does not block default", + exports: { browser: "./../outside.cjs", default: "./actual.cjs" }, + expected: "node_modules/fixture/actual.cjs", + }, + ...["./bad%.cjs", "./bad%C3.cjs"].map((target) => ({ + name: `malformed URL ${target} is selected before URL decoding`, + exports: [target, "./actual.cjs"], + expected: null, + nodeError: "URIError", + })), + { + name: "encoded separator is selected before final path refusal", + exports: ["./lib%2Factual.cjs", "./actual.cjs"], + expected: null, + nodeError: "ERR_INVALID_MODULE_SPECIFIER", + }, + { + name: "missing first target does not select a second file", + exports: ["./missing.cjs", "./actual.cjs"], + expected: null, + nodeError: "MODULE_NOT_FOUND", + }, + { + name: "nested directory is valid", + exports: "./lib/actual.cjs", + expected: "node_modules/fixture/lib/actual.cjs", + }, + { + name: "node_modules substring is not a forbidden segment", + exports: "./node_modules.cjs", + expected: "node_modules/fixture/node_modules.cjs", + }, + { + name: "encoded underscore and letters do not borrow a forbidden directory", + exports: ["./%6eode%5fmodules/actual.cjs", "./actual.cjs"], + expected: "node_modules/fixture/actual.cjs", + }, + { + name: "percent encoding is applied once", + exports: "./literal%252e.cjs", + expected: "node_modules/fixture/literal%2e.cjs", + }, +]; + +const nativeResultSchema = z.object({ + value: z.string().nullable(), + code: z.string().nullable(), +}); + +it.each( + (["import", "require"] as const).flatMap((moduleKind) => + cases.map((testCase) => ({ ...testCase, moduleKind })), + ), +)( + "matches Node $moduleKind target selection for $name", + async ({ + moduleKind, + name, + exports, + expected, + nodeError, + rejectedTarget, + }) => { + const root = await createTestTempDirectory("rea-package-target-"); + const mainPath = moduleKind === "import" ? "main.mjs" : "main.cjs"; + const files = { + [mainPath]: + moduleKind === "import" + ? 'import value from "fixture"; export default value;' + : 'module.exports = require("fixture");', + "node_modules/fixture/package.json": JSON.stringify({ exports }), + ...Object.fromEntries( + [ + "node_modules/fixture/actual.cjs", + "node_modules/outside.cjs", + "node_modules/fixture/lib/actual.cjs", + "node_modules/fixture/node_modules/actual.cjs", + "node_modules/fixture/node_modules.cjs", + "node_modules/fixture/literal%2e.cjs", + ].map((path) => [path, `module.exports = ${JSON.stringify(path)};`]), + ), + }; + await Promise.all( + Object.entries(files).map(async ([path, text]) => { + await mkdir(dirname(join(root, path)), { recursive: true }); + await writeFile(join(root, path), text); + }), + ); + const runner = + moduleKind === "import" + ? 'const load = async () => (await import("fixture")).default;' + : 'const load = async () => require("fixture");'; + const native = await promisify(execFile)( + process.execPath, + [ + "--input-type", + moduleKind === "import" ? "module" : "commonjs", + "--eval", + `${runner} load().then(value => console.log(JSON.stringify({value,code:null})), error => console.log(JSON.stringify({value:null,code:error.code ?? error.name})));`, + ], + { cwd: root, timeout: 5_000 }, + ); + const oracle = nativeResultSchema.parse(JSON.parse(native.stdout)); + expect(oracle.value, name).toBe(expected); + if (nodeError !== undefined) + expect(oracle.code).toBe( + moduleKind === "import" && nodeError === "MODULE_NOT_FOUND" + ? "ERR_MODULE_NOT_FOUND" + : nodeError, + ); + const result = await reconstructJavaScriptArtifact({ + input_path: root, + format: "directory", + }); + const edge = result.graph.edges.find( + ({ properties }) => + properties.specifier === "fixture" && + properties.resolution_status !== undefined && + properties.resolution_status !== null, + ); + expect(edge).toBeDefined(); + expect(edge?.properties.resolved_path).toBe(expected); + if (expected !== null) { + expect(edge?.properties.resolution_status).toBe("resolved"); + } else { + expect(edge?.properties.resolution_status).not.toBe("resolved"); + } + if (rejectedTarget !== undefined) { + expect(edge?.properties.resolution_status).toBe("rejected"); + expect(edge?.evidence.limitations.join(" ")).toContain( + JSON.stringify(rejectedTarget), + ); + expect(edge?.evidence.limitations.join(" ")).toContain("exports target"); + expect(edge?.evidence.limitations.join(" ")).not.toContain( + "not valid package JSON", + ); + expect(edge?.evidence.location).toMatchObject({ + value: { kind: "source-range", source: mainPath }, + }); + } + }, +); diff --git a/tests/boundary/javascript/packageConditionalExports.test.ts b/tests/boundary/javascript/packageConditionalExports.test.ts index 05b4465ef..7c65b6d49 100644 --- a/tests/boundary/javascript/packageConditionalExports.test.ts +++ b/tests/boundary/javascript/packageConditionalExports.test.ts @@ -237,18 +237,23 @@ describe("unmatched package export conditions", () => { }, ); it("does not report valid metadata as malformed", async () => { - const { outcome } = await compareWithNode({ default: 7 }, "import"); - expect(outcome.resolution_status).toBe("unavailable"); - expect(outcome.limitations[0]).toContain("not valid package JSON"); + const { node_error, outcome } = await compareWithNode( + { default: 7 }, + "import", + ); + expect(node_error).toBe("ERR_INVALID_PACKAGE_TARGET"); + expect(outcome.resolution_status).toBe("rejected"); + expect(outcome.limitations[0]).toContain("exports target 7"); + expect(outcome.limitations[0]).not.toContain("not valid package JSON"); }); }); describe("package exports fallback refusal reasons", () => { it.each([ - [{ import: [42, 7] }, "ERR_INVALID_PACKAGE_TARGET", "unavailable"], + [{ import: [42, 7] }, "ERR_INVALID_PACKAGE_TARGET", "rejected"], [{ import: [null, null] }, "ERR_PACKAGE_PATH_NOT_EXPORTED", "external"], [{ import: [42, null] }, "ERR_PACKAGE_PATH_NOT_EXPORTED", "external"], - [{ import: [null, 42] }, "ERR_INVALID_PACKAGE_TARGET", "unavailable"], + [{ import: [null, 42] }, "ERR_INVALID_PACKAGE_TARGET", "rejected"], [ { import: { node: null }, default: "./default.cjs" }, "ERR_PACKAGE_PATH_NOT_EXPORTED", @@ -265,6 +270,10 @@ describe("package exports fallback refusal reasons", () => { expect(node_error).toBe(code); expect(outcome.resolved_path).toBeNull(); expect(outcome.resolution_status).toBe(status); + if (code === "ERR_INVALID_PACKAGE_TARGET") { + expect(outcome.limitations[0]).toContain("exports target"); + expect(outcome.limitations[0]).not.toContain("not valid package JSON"); + } }, ); });