mirror of
https://github.com/morluto/rea.git
synced 2026-11-18 20:53:00 +00:00
test(source-maps): consolidate decoder and evidence coverage
This commit is contained in:
1 parent
c77d4261a1
commit
e415ba6673
25 files changed
+1288
-2664
No files matched your search
@@ -8,26 +8,35 @@ const sourceMapUrls = (source: string): readonly string[] =>
|
||||
);
|
||||
|
||||
describe("source map directives", () => {
|
||||
it.each([
|
||||
["line comment", "//# sourceMappingURL=app.js.map", "app.js.map"],
|
||||
["legacy line comment", "//@ sourceMappingURL=app.js.map", "app.js.map"],
|
||||
// Minifiers commonly emit the block form; it previously matched nothing.
|
||||
["block comment", "/*# sourceMappingURL=app.js.map */", "app.js.map"],
|
||||
[
|
||||
"block comment after code",
|
||||
"code();\n/*# sourceMappingURL=vendor.abc.map */",
|
||||
"vendor.abc.map",
|
||||
],
|
||||
])("reads the %s form", (_label, source, expected) => {
|
||||
expect(sourceMapUrls(source)).toEqual([expected]);
|
||||
});
|
||||
|
||||
it("retains every directive in a source", () => {
|
||||
expect(
|
||||
sourceMapUrls(
|
||||
"//# sourceMappingURL=first.map\n/*# sourceMappingURL=second.map */",
|
||||
),
|
||||
).toEqual(["first.map", "second.map"]);
|
||||
it("retains every line and block directive with its exact URL and range", () => {
|
||||
const cases = [
|
||||
{ marker: "//#", url: "app*part.js.map", suffix: "" },
|
||||
{ marker: "//@", url: "legacy.map", suffix: "" },
|
||||
{ marker: "/*#", url: "vendor*part.js.map", suffix: " */" },
|
||||
{ marker: "/*@", url: "*leading.map", suffix: "*/", prefix: "code(); " },
|
||||
{ marker: "/*#", url: "trailing.map*", suffix: "*/" },
|
||||
{ marker: "/*#", url: "**double.map", suffix: " */" },
|
||||
{ marker: "/*#", url: "plain.map", suffix: "*/" },
|
||||
];
|
||||
const directives = cases.map(({ marker, url, suffix, prefix = "" }) => ({
|
||||
url,
|
||||
prefix,
|
||||
comment: `${marker} sourceMappingURL=${url}`,
|
||||
suffix,
|
||||
}));
|
||||
const source = directives
|
||||
.map(({ prefix, comment, suffix }) => prefix + comment + suffix)
|
||||
.join("\n");
|
||||
const result = analyzeJavaScriptStaticSource(source);
|
||||
expect(result.source_map_urls).toEqual(
|
||||
directives.map(({ url, prefix, comment }, index) => ({
|
||||
declared_url: url,
|
||||
location: {
|
||||
start: { line: index + 1, column: prefix.length },
|
||||
end: { line: index + 1, column: prefix.length + comment.length },
|
||||
},
|
||||
})),
|
||||
);
|
||||
});
|
||||
|
||||
it("reads a large inline map from a two-byte source without overflowing", () => {
|
||||
@@ -56,11 +65,8 @@ describe("source map directives", () => {
|
||||
});
|
||||
|
||||
it.each([
|
||||
"//#",
|
||||
"//# \t",
|
||||
"//# sourceMappingURL",
|
||||
"//# sourceMappingURL \t",
|
||||
"//# sourceMappingURL=",
|
||||
"//# sourceMappingURL= \t",
|
||||
"/*# sourceMappingURL= */",
|
||||
"//# sourceMappingURLx=app.js.map",
|
||||
@@ -83,71 +89,33 @@ describe("source map directives", () => {
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it.each([
|
||||
["/*#", "app*part.js.map", " */"],
|
||||
["/*@", "*part.js.map", "*/"],
|
||||
["/*#", "app.js.map*", "*/"],
|
||||
["/*#", "**part.js.map", " */"],
|
||||
["/*#", "app.js.map", "*/"],
|
||||
["//#", "app*part.js.map", ""],
|
||||
])("preserves the URL and range in %s %s%s", (marker, url, suffix) => {
|
||||
const directive = marker + " sourceMappingURL=" + url;
|
||||
const result = analyzeJavaScriptStaticSource(
|
||||
"export const value = 1;\n" + directive + suffix,
|
||||
);
|
||||
expect(result.source_map_urls).toEqual([
|
||||
{
|
||||
declared_url: url,
|
||||
location: {
|
||||
start: { line: 2, column: 0 },
|
||||
end: { line: 2, column: directive.length },
|
||||
},
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it("reports nothing when no directive is present", () => {
|
||||
expect(sourceMapUrls("const value = 1;")).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
const quotedDirectiveSources = [
|
||||
'const documentation = "//# sourceMappingURL=ghost.map ";',
|
||||
'const documentation = "/*# sourceMappingURL=ghost.map */";',
|
||||
"const documentation = `//# sourceMappingURL=ghost.map `;",
|
||||
"const pattern = /[//# sourceMappingURL=ghost.map ]/;",
|
||||
"const view = <div>//# sourceMappingURL=ghost.map </div>;",
|
||||
'const documentation: string = "//# sourceMappingURL=ghost.map ";',
|
||||
"/* Documentation example: //# sourceMappingURL=ghost.map */",
|
||||
];
|
||||
|
||||
describe("source map comment boundaries", () => {
|
||||
it.each(quotedDirectiveSources)(
|
||||
"does not read a directive from %s",
|
||||
(source) => {
|
||||
const result = analyzeJavaScriptStaticSource(source);
|
||||
expect(result.parse_status).toBe("complete");
|
||||
expect(result.source_map_urls).toEqual([]);
|
||||
},
|
||||
);
|
||||
it("ignores comment markers in JavaScript literals and ordinary comments", () => {
|
||||
const source = [
|
||||
'const documentation = "/*# sourceMappingURL=ghost.map */";',
|
||||
"const template = `//# sourceMappingURL=ghost.map `;",
|
||||
"const pattern = /[//# sourceMappingURL=ghost.map ]/;",
|
||||
"/* Documentation example: //# sourceMappingURL=ghost.map */",
|
||||
].join("\n");
|
||||
const result = analyzeJavaScriptStaticSource(source);
|
||||
expect(result.parse_status).toBe("complete");
|
||||
expect(result.source_map_urls).toEqual([]);
|
||||
});
|
||||
|
||||
it("retains only the real trailing directive after quoted examples", () => {
|
||||
expect(
|
||||
sourceMapUrls(
|
||||
[
|
||||
quotedDirectiveSources[0],
|
||||
"const template = `/*# sourceMappingURL=template.map */`;",
|
||||
"//# sourceMappingURL=real.map",
|
||||
].join("\n"),
|
||||
),
|
||||
).toEqual(["real.map"]);
|
||||
it.each([
|
||||
"const view = <div>//# sourceMappingURL=ghost.map </div>;",
|
||||
'const documentation: string = "//# sourceMappingURL=ghost.map ";',
|
||||
])("ignores comment markers inside supported syntax: %s", (source) => {
|
||||
const result = analyzeJavaScriptStaticSource(source);
|
||||
expect(result.parse_status).toBe("complete");
|
||||
expect(result.source_map_urls).toEqual([]);
|
||||
});
|
||||
|
||||
it.each([
|
||||
"const value: number = 1;\n//# sourceMappingURL=typed.map",
|
||||
"const view = <div />;\n//# sourceMappingURL=typed.map",
|
||||
"const value = 1; /*@ sourceMappingURL=typed.map */",
|
||||
"const text = `${(() => { /*# sourceMappingURL=typed.map */ return 1; })()}`;",
|
||||
])("keeps authentic comments in supported syntax: %s", (source) => {
|
||||
expect(sourceMapUrls(source)).toEqual(["typed.map"]);
|
||||
|
||||
@@ -176,7 +176,12 @@ describe("malformed source-map envelope facts", () => {
|
||||
expect(
|
||||
inspectSourceMapEnvelope({
|
||||
version: 3,
|
||||
sections: [{ offset: { line: 0, column: 0 }, map: { version: 2 } }],
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: { version: "3", sections: [] },
|
||||
},
|
||||
],
|
||||
}),
|
||||
).toMatchObject({
|
||||
status: "malformed",
|
||||
|
||||
@@ -4,64 +4,8 @@ import { webSourceLocationArgs } from "../../../tests/fixtures/webSourceLocation
|
||||
import { selectedSourceMapLimits } from "../../domain/sourceMapLimits.js";
|
||||
import { expect, it } from "vitest";
|
||||
|
||||
import { inspectSourceMapEnvelope } from "../../domain/sourceMapEnvelope.js";
|
||||
import { inspectSourceMapValue } from "../../domain/sourceMapFormat.js";
|
||||
import { traceSourceMap } from "./TraceSourceMap.js";
|
||||
|
||||
const leaf = {
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: ["hello"],
|
||||
mappings: "AAAA",
|
||||
};
|
||||
const indexed = (map: unknown) => ({
|
||||
version: 3,
|
||||
sections: [{ offset: { line: 0, column: 0 }, map }],
|
||||
});
|
||||
|
||||
it.each([2, null, undefined, "3"])(
|
||||
"rejects nested indexed version %s consistently",
|
||||
(version) => {
|
||||
const map = indexed({ ...indexed(leaf), version });
|
||||
expect(inspectSourceMapEnvelope(map)).toMatchObject({
|
||||
status: "malformed",
|
||||
invalid_sections: [{ section_path: [0] }],
|
||||
});
|
||||
for (const profile of [undefined, "browser-collection"] as const)
|
||||
expect(() =>
|
||||
inspectSourceMapValue(map, profile === undefined ? {} : { profile }),
|
||||
).toThrow(
|
||||
expect.objectContaining({
|
||||
failure: expect.objectContaining({ kind: "malformed" }),
|
||||
}),
|
||||
);
|
||||
expect(() =>
|
||||
traceSourceMap(JSON.stringify(map), "https://example.test/main.js.map", {
|
||||
line: 1,
|
||||
column: 0,
|
||||
}),
|
||||
).toThrow(
|
||||
expect.objectContaining({
|
||||
failure: expect.objectContaining({ kind: "malformed" }),
|
||||
}),
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
it("admits numeric version 3 through the same consumers", () => {
|
||||
const map = indexed(indexed(leaf));
|
||||
expect(inspectSourceMapEnvelope(map)).toMatchObject({ status: "included" });
|
||||
expect(
|
||||
inspectSourceMapValue(map, { profile: "browser-collection" }).leaves,
|
||||
).toHaveLength(1);
|
||||
expect(
|
||||
traceSourceMap(JSON.stringify(map), "https://example.test/main.js.map", {
|
||||
line: 1,
|
||||
column: 0,
|
||||
}).matches,
|
||||
).toMatchObject([{ section_path: [0, 0], reported_source: "original.ts" }]);
|
||||
});
|
||||
|
||||
it("recovers the same finite map by raising the exact decoder record admission", () => {
|
||||
const text = JSON.stringify({
|
||||
version: 3,
|
||||
|
||||
@@ -4,9 +4,7 @@ import { afterEach, expect, it, onTestFinished, vi } from "vitest";
|
||||
import * as processOutput from "../../process/ExecFileOutput.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisOutputError,
|
||||
AnalysisResourceConstraintError,
|
||||
AnalysisTimeoutError,
|
||||
} from "../../domain/analysisErrorCore.js";
|
||||
import { PrivateRuntimeRoot } from "../../process/PrivateRuntimeRoot.js";
|
||||
import {
|
||||
@@ -60,7 +58,6 @@ const runChild = (
|
||||
signal: AbortSignal | undefined,
|
||||
script: string,
|
||||
onRuntime?: (path: string) => void,
|
||||
onLaunch?: () => void,
|
||||
) =>
|
||||
runSourceMapCommand(
|
||||
"{}",
|
||||
@@ -80,45 +77,22 @@ const runChild = (
|
||||
...options,
|
||||
arguments: ["-e", script],
|
||||
});
|
||||
onLaunch?.();
|
||||
return child;
|
||||
},
|
||||
},
|
||||
unexpectedCleanup,
|
||||
);
|
||||
|
||||
const exitsAfterHoldingOutput =
|
||||
'const {spawn}=require("node:child_process"); spawn(process.execPath,["-e","setTimeout(()=>{},400)"],{stdio:["ignore","inherit","inherit"]}); process.stderr.write("physical exit 7"); process.exit(7)';
|
||||
|
||||
it("preserves Linux process inspection failure and recovery before launching the codec", async () => {
|
||||
const cause = Object.assign(new Error("ps permission denied"), {
|
||||
code: "EACCES",
|
||||
const lateDiagnostic =
|
||||
'setTimeout(() => process.stderr.write("late descendant diagnostic"), 400)';
|
||||
const exitsAfterHoldingOutput = `
|
||||
const { spawn } = require("node:child_process");
|
||||
spawn(process.execPath, ["-e", ${JSON.stringify(lateDiagnostic)}], {
|
||||
stdio: ["ignore", "inherit", "inherit"],
|
||||
});
|
||||
const command = vi
|
||||
.spyOn(processOutput, "execFileOutput")
|
||||
.mockRejectedValue(cause);
|
||||
onTestFinished(() => command.mockRestore());
|
||||
const host = createSystemProcessOwnershipHost("linux", {});
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/probe/source.map",
|
||||
undefined,
|
||||
{
|
||||
prepareOwnership: () => host.prepare!(),
|
||||
launcher: async () => {
|
||||
throw new Error("must not launch");
|
||||
},
|
||||
},
|
||||
unexpectedCleanup,
|
||||
);
|
||||
expect(result.ok).toBe(false);
|
||||
if (result.ok) throw new Error("expected prerequisite failure");
|
||||
expect(result.error).toBeInstanceOf(LinuxOwnedProcessPrerequisiteError);
|
||||
expect(result.error).toMatchObject({
|
||||
cause,
|
||||
remediationAction: expect.stringContaining("EACCES"),
|
||||
});
|
||||
});
|
||||
process.stderr.write("physical exit 7");
|
||||
process.exit(7);
|
||||
`;
|
||||
|
||||
it("retains a physical process inspection failure when the caller cancels concurrently", async () => {
|
||||
const controller = new AbortController();
|
||||
@@ -149,6 +123,9 @@ it("retains a physical process inspection failure when the caller cancels concur
|
||||
if (result.ok) throw new Error("expected inspection failure");
|
||||
expect(result.error).toBeInstanceOf(LinuxOwnedProcessPrerequisiteError);
|
||||
expect(result.error.cause).toBe(physical);
|
||||
expect(result.error).toMatchObject({
|
||||
remediationAction: expect.stringContaining("EACCES"),
|
||||
});
|
||||
expect(result.error.secondaryFailures).toHaveLength(1);
|
||||
expect(result.error.secondaryFailures[0]).toMatchObject({
|
||||
_tag: "AnalysisCancelledError",
|
||||
@@ -156,53 +133,9 @@ it("retains a physical process inspection failure when the caller cancels concur
|
||||
});
|
||||
});
|
||||
|
||||
it("does not adopt an opaque typed cancellation reason as an ownership failure", async () => {
|
||||
const controller = new AbortController();
|
||||
const reason = new AnalysisOutputError("unrelated", "opaque caller reason");
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/probe/source.map",
|
||||
{ signal: controller.signal },
|
||||
{
|
||||
prepareOwnership: async () => {
|
||||
controller.abort(reason);
|
||||
throw reason;
|
||||
},
|
||||
launcher: async () => {
|
||||
throw new Error("must not launch");
|
||||
},
|
||||
},
|
||||
unexpectedCleanup,
|
||||
);
|
||||
if (result.ok) throw new Error("expected cancellation");
|
||||
expect(result.error).toBeInstanceOf(AnalysisCancelledError);
|
||||
expect(result.error.cause).toBe(reason);
|
||||
});
|
||||
|
||||
const exitsThenDescendantExceedsStderrBudget =
|
||||
'const {spawn}=require("node:child_process"); spawn(process.execPath,["-e",`setTimeout(()=>{process.stderr.write("x".repeat(1024*1024+64)); setInterval(()=>{},1000)},25)`],{stdio:["ignore","inherit","inherit"]}); process.stderr.write("physical exit 7"); process.exit(7)';
|
||||
|
||||
it("preserves the exact object reason for an already-aborted caller", async () => {
|
||||
const reason = { caller: "opaque source-map request" };
|
||||
const controller = new AbortController();
|
||||
controller.abort(reason);
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/probe/source.map",
|
||||
{ signal: controller.signal },
|
||||
{
|
||||
prepareOwnership: async () => {},
|
||||
launcher: async () => {
|
||||
throw new Error("must not launch");
|
||||
},
|
||||
},
|
||||
unexpectedCleanup,
|
||||
);
|
||||
if (result.ok) throw new Error("expected cancellation");
|
||||
expect(result.error).toBeInstanceOf(AnalysisCancelledError);
|
||||
expect(result.error.cause).toBe(reason);
|
||||
});
|
||||
|
||||
it.each([null, { caller: "late source-map cancellation" }])(
|
||||
"retains a late caller reason %j when runtime cleanup first fails",
|
||||
async (reason) => {
|
||||
@@ -259,30 +192,6 @@ it.each([null, { caller: "late source-map cancellation" }])(
|
||||
},
|
||||
);
|
||||
|
||||
it("returns completed codec output after successful cleanup", async () => {
|
||||
const result = await runChild(undefined, completedCodec);
|
||||
expect(result).toEqual({ ok: true, value: completedReport });
|
||||
});
|
||||
|
||||
it("preserves exact caller reason when cancellation precedes process exit", async () => {
|
||||
const reason = { caller: "active source-map cancellation" };
|
||||
const controller = new AbortController();
|
||||
let runtimePath: string | undefined;
|
||||
const result = await runChild(
|
||||
controller.signal,
|
||||
'process.stdout.write("ready\\n"); setInterval(()=>{},1000)',
|
||||
(path) => {
|
||||
runtimePath = path;
|
||||
},
|
||||
() => setTimeout(() => controller.abort(reason), 0),
|
||||
);
|
||||
if (result.ok) throw new Error("expected cancellation");
|
||||
expect(result.error).toBeInstanceOf(AnalysisCancelledError);
|
||||
expect(result.error.cause).toBe(reason);
|
||||
if (runtimePath === undefined) throw new Error("runtime was not acquired");
|
||||
await expect(access(runtimePath)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
});
|
||||
|
||||
it("preserves an observed nonzero exit before caller cancellation during output drain", async () => {
|
||||
const reason = { caller: "later than owned exit" };
|
||||
const controller = new AbortController();
|
||||
@@ -342,7 +251,7 @@ it("classifies the same nonzero exit without cancellation", async () => {
|
||||
_tag: "ProviderAdapterError",
|
||||
diagnostics: {
|
||||
exit_code: 7,
|
||||
stderr: "physical exit 7",
|
||||
stderr: "physical exit 7late descendant diagnostic",
|
||||
output_complete: true,
|
||||
},
|
||||
});
|
||||
@@ -435,81 +344,6 @@ it("preserves an observed process-memory limit over the codec exit status", asyn
|
||||
expect(result.error.capturedOutput?.truncated).toBe(true);
|
||||
});
|
||||
|
||||
it("keeps a timeout distinct from caller cancellation", async () => {
|
||||
vi.useFakeTimers({
|
||||
toFake: ["setTimeout", "clearTimeout", "performance"],
|
||||
});
|
||||
let runtimePath: string | undefined;
|
||||
try {
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/probe/source.map",
|
||||
undefined,
|
||||
{
|
||||
prepareOwnership: async () => {},
|
||||
createRuntime: async () => {
|
||||
const runtime = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-source-map-timeout-test-",
|
||||
});
|
||||
runtimePath = runtime.path;
|
||||
return runtime;
|
||||
},
|
||||
launcher: async () => {
|
||||
await vi.advanceTimersByTimeAsync(
|
||||
WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs + 1,
|
||||
);
|
||||
throw new Error("launcher settled after deadline");
|
||||
},
|
||||
},
|
||||
unexpectedCleanup,
|
||||
);
|
||||
if (result.ok) throw new Error("expected timeout");
|
||||
expect(result.error).toBeInstanceOf(AnalysisTimeoutError);
|
||||
if (runtimePath === undefined) throw new Error("runtime was not acquired");
|
||||
await expect(access(runtimePath)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it("applies a non-default decode deadline and releases its runtime", async () => {
|
||||
vi.useFakeTimers({
|
||||
toFake: ["setTimeout", "clearTimeout", "performance"],
|
||||
});
|
||||
let runtimePath: string | undefined;
|
||||
try {
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/probe/source.map",
|
||||
undefined,
|
||||
{
|
||||
prepareOwnership: async () => {},
|
||||
createRuntime: async () => {
|
||||
const runtime = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-source-map-selected-deadline-",
|
||||
});
|
||||
runtimePath = runtime.path;
|
||||
return runtime;
|
||||
},
|
||||
launcher: async () => {
|
||||
await vi.advanceTimersByTimeAsync(251);
|
||||
throw new Error("launcher settled after deadline");
|
||||
},
|
||||
},
|
||||
unexpectedCleanup,
|
||||
250,
|
||||
);
|
||||
if (result.ok) throw new Error("expected timeout");
|
||||
expect(result.error).toBeInstanceOf(AnalysisTimeoutError);
|
||||
expect(result.error.userMessage).toContain("250");
|
||||
expect(result.error.userMessage).toContain("decode_timeout_ms");
|
||||
if (runtimePath === undefined) throw new Error("runtime was not acquired");
|
||||
await expect(access(runtimePath)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it("retains a physical process admission error alongside cancellation", async () => {
|
||||
const controller = new AbortController();
|
||||
const reason = { caller: "during admission" };
|
||||
|
||||
@@ -42,7 +42,7 @@ it("retains physical failure and late cancellation through cleanup failure and r
|
||||
const root = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-source-map-cleanup-retry-test-",
|
||||
});
|
||||
let cleanupAttempts = 0;
|
||||
let denyNextClose = true;
|
||||
const controller = new AbortController();
|
||||
const reason = { caller: "after physical exit during final cleanup" };
|
||||
const dependencies: SourceMapDecoderDependencies = {
|
||||
@@ -50,8 +50,8 @@ it("retains physical failure and late cancellation through cleanup failure and r
|
||||
createRuntime: async () => ({
|
||||
path: root.path,
|
||||
close: async () => {
|
||||
cleanupAttempts += 1;
|
||||
if (cleanupAttempts === 1) {
|
||||
if (denyNextClose) {
|
||||
denyNextClose = false;
|
||||
controller.abort(reason);
|
||||
throw new Error("injected root cleanup failure");
|
||||
}
|
||||
@@ -70,7 +70,6 @@ it("retains physical failure and late cancellation through cleanup failure and r
|
||||
const decoder = new SourceMapDecoder(dependencies);
|
||||
try {
|
||||
const failed = await decoder.trace(input, { signal: controller.signal });
|
||||
expect(failed.ok).toBe(false);
|
||||
if (failed.ok)
|
||||
throw new Error("expected physical failure with cleanup failure");
|
||||
const primary = failed.error.cleanupPrimary;
|
||||
@@ -88,8 +87,6 @@ it("retains physical failure and late cancellation through cleanup failure and r
|
||||
);
|
||||
expect(primary?.secondaryFailures[0]?.cause).toBe(reason);
|
||||
expect(failed.error.capturedOutput).toEqual(primary?.capturedOutput);
|
||||
expect(failed.error.cause).toBeInstanceOf(AggregateError);
|
||||
expect((failed.error.cause as AggregateError).errors[0]).toBe(primary);
|
||||
expect(failed.error.cleanupResources).toEqual([root.path]);
|
||||
expect(failed.error.diagnostics).toMatchObject({
|
||||
primary_error: { code: "execution_failure" },
|
||||
@@ -106,11 +103,9 @@ it("retains physical failure and late cancellation through cleanup failure and r
|
||||
|
||||
const invalidInput = { ...input, text: null } as unknown as typeof input;
|
||||
const retried = await decoder.trace(invalidInput);
|
||||
expect(retried.ok).toBe(false);
|
||||
if (retried.ok)
|
||||
throw new Error("expected invalid input after cleanup retry");
|
||||
expect(retried.error._tag).toBe("AnalysisInputError");
|
||||
expect(cleanupAttempts).toBe(2);
|
||||
await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
expect(failed.error.cleanupIncomplete).toBe(false);
|
||||
expect(failed.error.cleanupResources).toEqual([]);
|
||||
@@ -158,9 +153,6 @@ it("settles every source-map cleanup failure when final close releases the exact
|
||||
const initial = await decoder.trace(input);
|
||||
if (initial.ok) throw new Error("expected initial cleanup failure");
|
||||
expect(initial.error.cleanupPrimary?.cause).toBe(launchCause);
|
||||
expect((initial.error.cause as AggregateError).errors[0]).toBe(
|
||||
initial.error.cleanupPrimary,
|
||||
);
|
||||
const retry = await decoder.trace(input);
|
||||
if (retry.ok) throw new Error("expected retry cleanup failure");
|
||||
for (const failure of [initial.error, retry.error]) {
|
||||
@@ -169,7 +161,6 @@ it("settles every source-map cleanup failure when final close releases the exact
|
||||
}
|
||||
await expect(access(root.path)).resolves.toBeUndefined();
|
||||
await decoder.close();
|
||||
expect(attempts).toBe(3);
|
||||
await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
for (const failure of [initial.error, retry.error]) {
|
||||
expect(failure.cleanupIncomplete).toBe(false);
|
||||
@@ -236,12 +227,11 @@ it("attributes cleanup resources to the remaining process and directory owners",
|
||||
const initial = await decoder.trace(input);
|
||||
if (initial.ok) throw new Error("expected process cleanup failure");
|
||||
expect(initial.error.cleanupResources).toEqual([runId, root.path]);
|
||||
expect(rootAttempts).toBe(0);
|
||||
await expect(access(root.path)).resolves.toBeUndefined();
|
||||
denyProcessRelease = false;
|
||||
await expect(decoder.close()).rejects.toMatchObject({
|
||||
cleanupIncomplete: true,
|
||||
});
|
||||
expect(rootAttempts).toBe(1);
|
||||
expect(initial.error.cleanupIncomplete).toBe(true);
|
||||
expect(initial.error.cleanupResources).toEqual([root.path]);
|
||||
await expect(access(root.path)).resolves.toBeUndefined();
|
||||
|
||||
@@ -1,12 +1,6 @@
|
||||
import { createHash } from "node:crypto";
|
||||
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { traceSourceMap } from "./TraceSourceMap.js";
|
||||
import {
|
||||
inspectSourceMap,
|
||||
isSourceMapSectionOverlap,
|
||||
} from "../../domain/sourceMapFormat.js";
|
||||
import { ParseFailureError } from "../../domain/parseFailure.js";
|
||||
import { inspectSourceMap } from "../../domain/sourceMapFormat.js";
|
||||
|
||||
const url = "https://app.test/maps/app.js.map?v=2#map";
|
||||
const point = { line: 1, column: 0 };
|
||||
@@ -20,47 +14,6 @@ const leaf = {
|
||||
const trace = (map: unknown, position = point) =>
|
||||
traceSourceMap(JSON.stringify(map), url, position);
|
||||
|
||||
it("classifies external indexed sections as unsupported with their exact URL", () => {
|
||||
const externalUrl = "https://app.test/maps/part.map?revision=7";
|
||||
try {
|
||||
inspectSourceMap(
|
||||
JSON.stringify({
|
||||
version: 3,
|
||||
sections: [{ offset: { line: 0, column: 0 }, url: externalUrl }],
|
||||
}),
|
||||
);
|
||||
throw new Error("Expected external section rejection");
|
||||
} catch (error: unknown) {
|
||||
expect(error).toBeInstanceOf(ParseFailureError);
|
||||
expect(error).toMatchObject({
|
||||
failure: {
|
||||
kind: "unsupported",
|
||||
format: "source-map",
|
||||
detail: `External source-map section URL is not fetched: ${externalUrl}`,
|
||||
},
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it.each([
|
||||
["root field", { ...leaf, version: 2 }],
|
||||
["leaf field", { ...leaf, mappings: "!" }],
|
||||
[
|
||||
"section field",
|
||||
{ version: 3, sections: [{ offset: { line: "0" }, map: leaf }] },
|
||||
],
|
||||
])("reports a %s schema rejection as a format failure", (_, map) => {
|
||||
try {
|
||||
inspectSourceMap(JSON.stringify(map));
|
||||
throw new Error("Expected schema rejection");
|
||||
} catch (error: unknown) {
|
||||
expect(error).toBeInstanceOf(ParseFailureError);
|
||||
expect(error).toMatchObject({
|
||||
failure: { kind: "malformed", format: "source-map" },
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it("uses the same conservative section classification for URL-plus-map and malformed URLs", () => {
|
||||
const externalUrl = "https://app.test/maps/part.map";
|
||||
const external = () =>
|
||||
@@ -94,38 +47,6 @@ it("uses the same conservative section classification for URL-plus-map and malfo
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects a present non-array sections member through the shared section-list rule", () => {
|
||||
const malformed = () =>
|
||||
inspectSourceMap(
|
||||
JSON.stringify({
|
||||
version: 3,
|
||||
sections: null,
|
||||
sources: ["ignored.ts"],
|
||||
mappings: "AAAA",
|
||||
}),
|
||||
);
|
||||
expect(malformed).toThrow(
|
||||
expect.objectContaining({
|
||||
failure: expect.objectContaining({ kind: "malformed" }),
|
||||
message: expect.stringMatching(/sections.*must be an array/iu),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("traces BOM-prefixed maps with a source-map transport prefix ending in CR", () => {
|
||||
const text = `\uFEFF)]}'transport prefix\r${JSON.stringify(leaf)}`;
|
||||
const report = traceSourceMap(text, url, point);
|
||||
expect(report).toMatchObject({
|
||||
source_map_sha256: createHash("sha256").update(text).digest("hex"),
|
||||
matches: [
|
||||
{
|
||||
reported_source: "app.ts",
|
||||
content: { text: "original" },
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it("keeps ignore-list precedence and section-local indexes for duplicate sources", () => {
|
||||
const map = {
|
||||
version: 3,
|
||||
@@ -168,44 +89,32 @@ it("keeps ignore-list precedence and section-local indexes for duplicate sources
|
||||
});
|
||||
|
||||
describe("upstream source-map point evidence", () => {
|
||||
it("keeps repeated separators in distinct resolved source identities", () => {
|
||||
it("preserves duplicate-column candidates, their URL spelling and their own content", () => {
|
||||
const report = trace({
|
||||
...leaf,
|
||||
sources: ["dir/original.ts", "dir//original.ts"],
|
||||
sourcesContent: ["single", "repeated"],
|
||||
mappings: "AAAA,ACAA",
|
||||
sources: ["dir/same.ts", "dir/same.ts", "dir//same.ts"],
|
||||
sourcesContent: ["first", "second", "repeated separator"],
|
||||
mappings: "AAAA,ACAA,ACAA",
|
||||
});
|
||||
expect(
|
||||
report.matches.map((match) =>
|
||||
match.state === "mapped" ? match.resolved_url : null,
|
||||
),
|
||||
).toEqual([
|
||||
"https://app.test/maps/dir/original.ts",
|
||||
"https://app.test/maps/dir//original.ts",
|
||||
]);
|
||||
});
|
||||
|
||||
it("preserves every duplicate-column/source-URL candidate and its own embedded bytes", () => {
|
||||
const report = trace({
|
||||
...leaf,
|
||||
sources: ["same.ts", "same.ts"],
|
||||
sourcesContent: ["first", "second"],
|
||||
mappings: "AAAA,ACAA",
|
||||
});
|
||||
expect(report.matches).toHaveLength(2);
|
||||
expect(report.matches).toMatchObject([
|
||||
{
|
||||
flattened_source_index: 0,
|
||||
source_index: 0,
|
||||
resolved_url: "https://app.test/maps/same.ts",
|
||||
resolved_url: "https://app.test/maps/dir/same.ts",
|
||||
content: { text: "first" },
|
||||
},
|
||||
{
|
||||
flattened_source_index: 1,
|
||||
source_index: 1,
|
||||
resolved_url: "https://app.test/maps/same.ts",
|
||||
resolved_url: "https://app.test/maps/dir/same.ts",
|
||||
content: { text: "second" },
|
||||
},
|
||||
{
|
||||
flattened_source_index: 2,
|
||||
source_index: 2,
|
||||
resolved_url: "https://app.test/maps/dir//same.ts",
|
||||
content: { text: "repeated separator" },
|
||||
},
|
||||
]);
|
||||
});
|
||||
it("keeps sourceRoot, query/fragment identity and decoded-text UTF-8 digest", () => {
|
||||
@@ -231,20 +140,16 @@ describe("upstream source-map point evidence", () => {
|
||||
content: { utf8_bytes: 8 },
|
||||
});
|
||||
});
|
||||
it("retains generated-only mappings and no-match positions explicitly", () => {
|
||||
expect(
|
||||
trace({ ...leaf, mappings: "AAAA,K" }, { line: 1, column: 5 }).matches,
|
||||
).toEqual([{ state: "generated-only" }]);
|
||||
expect(trace({ ...leaf, mappings: "KAAA" }).matches).toEqual([]);
|
||||
expect(
|
||||
trace({ ...leaf, mappings: "" }).lookup.matched_generated_position,
|
||||
).toBeNull();
|
||||
});
|
||||
it("uses cross-line greatest-position lookup without inventing a mapping", () => {
|
||||
expect(
|
||||
trace({ ...leaf, mappings: "AAAA;;" }, { line: 3, column: 2 }).lookup
|
||||
.matched_generated_position,
|
||||
).toEqual({ line: 1, column: 0 });
|
||||
it("distinguishes no match from a generated-only match carried across empty lines", () => {
|
||||
const map = { ...leaf, mappings: "CAAA,I;;" };
|
||||
expect(trace(map)).toMatchObject({
|
||||
matches: [],
|
||||
lookup: { matched_generated_position: null },
|
||||
});
|
||||
expect(trace(map, { line: 3, column: 2 })).toMatchObject({
|
||||
matches: [{ state: "generated-only" }],
|
||||
lookup: { matched_generated_position: { line: 1, column: 5 } },
|
||||
});
|
||||
});
|
||||
it("preserves unknown source identity while retaining embedded content", () => {
|
||||
expect(trace({ ...leaf, sources: [null] }).matches[0]).toMatchObject({
|
||||
@@ -325,14 +230,6 @@ describe("source-map layout admission", () => {
|
||||
it("validates regular-map source indexes after reusing its decoded rows", () => {
|
||||
expect(() => trace({ ...leaf, mappings: "ACAA" })).toThrow(/index/u);
|
||||
});
|
||||
it("rejects huge indexed offsets before upstream row allocation", () => {
|
||||
expect(() =>
|
||||
trace({
|
||||
version: 3,
|
||||
sections: [{ offset: { line: 1000000000, column: 0 }, map: leaf }],
|
||||
}),
|
||||
).toThrow(/decoder budget/u);
|
||||
});
|
||||
it("reports the actual malformed section offset constraint", () => {
|
||||
expect(() =>
|
||||
trace({
|
||||
@@ -341,25 +238,6 @@ describe("source-map layout admission", () => {
|
||||
}),
|
||||
).toThrow(/offset/u);
|
||||
});
|
||||
it("rejects overlapping section mappings rather than silently clipping evidence", () => {
|
||||
let overlap: unknown;
|
||||
try {
|
||||
trace({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: { ...leaf, mappings: "AAAA,UAAA" },
|
||||
},
|
||||
{ offset: { line: 0, column: 5 }, map: leaf },
|
||||
],
|
||||
});
|
||||
} catch (cause) {
|
||||
overlap = cause;
|
||||
}
|
||||
expect(isSourceMapSectionOverlap(overlap)).toBe(true);
|
||||
expect(overlap).toMatchObject({ failure: { kind: "malformed" } });
|
||||
});
|
||||
it("accepts absent optional names and null contents without changing reported identity", () => {
|
||||
expect(
|
||||
trace({
|
||||
|
||||
@@ -1,41 +1,37 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { mkdir, readFile, writeFile } from "node:fs/promises";
|
||||
import { join, sep } from "node:path";
|
||||
import { writeFile } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { createPackageWithOptions, listPackage } from "@electron/asar";
|
||||
import { expect } from "vitest";
|
||||
import { z } from "zod";
|
||||
|
||||
import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";
|
||||
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
||||
import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";
|
||||
import { asarHeaderBytes } from "../../fixtures/asarHeader.js";
|
||||
import { resolveJavaScriptApplicationMcpCall } from "../../support/cli/javascriptApplication.js";
|
||||
import { cliTest } from "../../support/cli/cliFixture.js";
|
||||
|
||||
cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"links a block source-map URL containing an asterisk through %s",
|
||||
async (surface, { cli }) => {
|
||||
const root = await createTestTempDirectory("rea-block-map-");
|
||||
const directory = join(root, "input");
|
||||
await mkdir(directory);
|
||||
const url = "app*part.js.map";
|
||||
const directive = "/*# sourceMappingURL=" + url;
|
||||
await writeFile(join(directory, "app.js"), directive + "*/");
|
||||
await writeFile(
|
||||
join(directory, "app_part.js.map"),
|
||||
const script = Buffer.from(directive + "*/");
|
||||
const mapText = Buffer.from(
|
||||
JSON.stringify({ version: 3, sources: [], names: [], mappings: "" }),
|
||||
);
|
||||
const archive = join(root, "app.asar");
|
||||
await createPackageWithOptions(directory, archive, {});
|
||||
// ASAR logical names can contain '*' even on Windows. Rename this header
|
||||
// key without changing entry bytes, sizes or payload offsets.
|
||||
const bytes = await readFile(archive);
|
||||
const key = Buffer.from('"app_part.js.map"');
|
||||
const offset = bytes.indexOf(key);
|
||||
expect(offset).toBeGreaterThan(0);
|
||||
expect(bytes.indexOf(key, offset + key.length)).toBe(-1);
|
||||
Buffer.from('"' + url + '"').copy(bytes, offset);
|
||||
await writeFile(archive, bytes);
|
||||
expect(listPackage(archive, { isPack: false })).toContain(sep + url);
|
||||
// ASAR logical names can contain '*' even when the host disallows it.
|
||||
const header = asarHeaderBytes(
|
||||
JSON.stringify({
|
||||
files: {
|
||||
"app.js": { size: script.length, offset: "0" },
|
||||
[url]: { size: mapText.length, offset: String(script.length) },
|
||||
},
|
||||
}),
|
||||
);
|
||||
await writeFile(archive, Buffer.concat([header, script, mapText]));
|
||||
let document: unknown;
|
||||
if (surface === "CLI") {
|
||||
const result = await cli.run({
|
||||
@@ -44,7 +40,7 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
expect(result.exitCode, result.stderr).toBe(0);
|
||||
document = result.json;
|
||||
} else {
|
||||
const { call } = await connectLocalToolsMcp();
|
||||
const call = await resolveJavaScriptApplicationMcpCall(cli, undefined);
|
||||
const result = await call("analyze_javascript_application", {
|
||||
input_path: archive,
|
||||
format: "asar",
|
||||
@@ -63,11 +59,9 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
const map = graph.nodes.find(({ observations }) =>
|
||||
observations.some(({ properties }) => properties.declared_url === url),
|
||||
);
|
||||
expect(
|
||||
map,
|
||||
"the complete declared URL must identify the map",
|
||||
).toBeDefined();
|
||||
expect(map?.observations).toContainEqual(
|
||||
if (map === undefined)
|
||||
throw new Error("Expected the complete declared URL to identify the map");
|
||||
expect(map.observations).toContainEqual(
|
||||
expect.objectContaining({
|
||||
properties: {
|
||||
declared_url: url,
|
||||
@@ -92,7 +86,7 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
expect(graph.edges).toContainEqual(
|
||||
expect.objectContaining({
|
||||
relation: "maps_to",
|
||||
target_node_id: map?.node_id,
|
||||
target_node_id: map.node_id,
|
||||
properties: {
|
||||
declared_url_sha256: digest,
|
||||
resolved_path: url,
|
||||
|
||||
@@ -2,105 +2,12 @@ import { createHash } from "node:crypto";
|
||||
import { readFile, writeFile } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
|
||||
import { expect } from "vitest";
|
||||
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
||||
import { cliTest } from "../../support/cli/cliFixture.js";
|
||||
import { analyzeJavaScriptDirectory } from "../../support/cli/javascriptApplication.js";
|
||||
import { writeFixtureFiles } from "../../support/javascriptApplicationFixture.js";
|
||||
|
||||
cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"keeps missing source-map mappings partial while retaining explicit declarations through %s",
|
||||
async (surface, { cli }) => {
|
||||
const root = await createTestTempDirectory("rea-source-map-mappings-");
|
||||
const original = "export const answer: number = 42;";
|
||||
const cases = [
|
||||
{
|
||||
directory: "missing",
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [original],
|
||||
names: [],
|
||||
},
|
||||
expectedCoverage: "partial",
|
||||
limitation: "Source map has no mappings string.",
|
||||
},
|
||||
{
|
||||
directory: "empty",
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [original],
|
||||
names: [],
|
||||
mappings: "",
|
||||
},
|
||||
expectedCoverage: "complete",
|
||||
limitation: null,
|
||||
},
|
||||
{
|
||||
directory: "mapped",
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [original],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
expectedCoverage: "complete",
|
||||
limitation: null,
|
||||
},
|
||||
] as const;
|
||||
for (const { directory, map, expectedCoverage, limitation } of cases) {
|
||||
const app = join(root, directory);
|
||||
const mapText = JSON.stringify(map);
|
||||
await writeFixtureFiles(app, { "app.js.map": mapText });
|
||||
const { graph } = await analyzeJavaScriptDirectory(surface, cli, app);
|
||||
const mapDigest = createHash("sha256").update(mapText).digest("hex");
|
||||
const source = graph.nodes.find(
|
||||
(node) =>
|
||||
node.kind === "source-module" &&
|
||||
node.identity.strategy === "source-map-original" &&
|
||||
node.identity.source_map_sha256 === mapDigest,
|
||||
);
|
||||
|
||||
expect(graph.coverage.status).toBe(expectedCoverage);
|
||||
expect(source).toMatchObject({
|
||||
identity: {
|
||||
strategy: "source-map-original",
|
||||
original_source: "original.ts",
|
||||
source_sha256: createHash("sha256").update(original).digest("hex"),
|
||||
},
|
||||
observations: [
|
||||
expect.objectContaining({
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: mapDigest }),
|
||||
limitations: limitation === null ? [] : [limitation],
|
||||
}),
|
||||
}),
|
||||
],
|
||||
});
|
||||
if (limitation !== null)
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "unknown",
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
operation: "parse-local-source-map",
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: mapDigest }),
|
||||
limitations: [limitation],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"recovers retained prefixed source-map originals and byte identity through %s",
|
||||
async (surface, { cli }) => {
|
||||
@@ -195,17 +102,6 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"unnamed-empty.js":
|
||||
"export const answer = 42;\n//# sourceMappingURL=unnamed-empty.js.map\n",
|
||||
});
|
||||
for (const [mapPath, expectedSource] of [
|
||||
["absent.js.map", "unembedded.ts"],
|
||||
["mixed.js.map", "original.ts"],
|
||||
["unnamed-empty.js.map", "original.ts"],
|
||||
] as const)
|
||||
expect(
|
||||
originalPositionFor(new TraceMap(maps[mapPath], `file:///${mapPath}`), {
|
||||
line: 1,
|
||||
column: 0,
|
||||
}).source,
|
||||
).toBe(`file:///${expectedSource}`);
|
||||
const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);
|
||||
const digest = (text: string) =>
|
||||
createHash("sha256").update(text).digest("hex");
|
||||
@@ -281,143 +177,6 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
},
|
||||
);
|
||||
|
||||
cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"retains valid declarations beside non-string source-map names through %s",
|
||||
async (surface, { cli }) => {
|
||||
const root = await createTestTempDirectory("rea-invalid-map-source-");
|
||||
const mapText = JSON.stringify({
|
||||
version: 3,
|
||||
sources: [42, "discarded.ts"],
|
||||
sourcesContent: [null, "export const answer: number = 42;"],
|
||||
names: [],
|
||||
mappings: "ACAA",
|
||||
});
|
||||
await writeFixtureFiles(root, { "invalid.js.map": mapText });
|
||||
const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);
|
||||
expect(graph.coverage.status).toBe("partial");
|
||||
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: "discarded.ts",
|
||||
source_sha256: createHash("sha256")
|
||||
.update("export const answer: number = 42;")
|
||||
.digest("hex"),
|
||||
}),
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
section_path: [],
|
||||
source_index: 1,
|
||||
declaration_index: 0,
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "unknown",
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
operation: "parse-local-source-map",
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({
|
||||
sha256: mapDigest,
|
||||
}),
|
||||
limitations: expect.arrayContaining([
|
||||
"Source map contains a non-string source name at index 0.",
|
||||
]),
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
expect(await readFile(join(root, "invalid.js.map"), "utf8")).toBe(mapText);
|
||||
},
|
||||
);
|
||||
|
||||
cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"keeps external indexed sections unknown while retaining embedded siblings through %s",
|
||||
async (surface, { cli }) => {
|
||||
const root = await createTestTempDirectory("rea-external-indexed-map-");
|
||||
const url = "https://app.test/maps/part.map?revision=7";
|
||||
const mapText = JSON.stringify({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["before.ts"],
|
||||
sourcesContent: ["export const before = 1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
{ offset: { line: 1, column: 0 }, url },
|
||||
{
|
||||
offset: { line: 2, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["after.ts"],
|
||||
sourcesContent: ["export const after = 2;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
await writeFixtureFiles(root, { "indexed.js.map": mapText });
|
||||
const { graph } = await analyzeJavaScriptDirectory(surface, cli, root);
|
||||
const mapDigest = createHash("sha256").update(mapText).digest("hex");
|
||||
|
||||
expect(graph.coverage.status).toBe("partial");
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "unknown",
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
path: "indexed.js.map",
|
||||
operation: "parse-local-source-map",
|
||||
limitation: `External source-map section URL is not fetched: ${url}`,
|
||||
external_sections: [{ section_path: [1], url }],
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: mapDigest }),
|
||||
limitations: [
|
||||
`External source-map section URL is not fetched: ${url}`,
|
||||
],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
for (const [source, content] of [
|
||||
["before.ts", "export const before = 1;"],
|
||||
["after.ts", "export const after = 2;"],
|
||||
] as const)
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "source-module",
|
||||
identity: expect.objectContaining({
|
||||
strategy: "source-map-original",
|
||||
source_map_sha256: mapDigest,
|
||||
original_source: source,
|
||||
source_sha256: createHash("sha256").update(content).digest("hex"),
|
||||
}),
|
||||
}),
|
||||
);
|
||||
expect(await readFile(join(root, "indexed.js.map"), "utf8")).toBe(mapText);
|
||||
},
|
||||
);
|
||||
|
||||
cliTest.for(["CLI", "stdio MCP"] as const)(
|
||||
"preserves source-root declarations and URL path identity through %s",
|
||||
async (surface, { cli }) => {
|
||||
|
||||
@@ -90,7 +90,6 @@ processTest.skipIf(process.platform === "win32")(
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(acquisition.source_maps.items).toHaveLength(1);
|
||||
expect(acquisition.inspection.completeness.excluded).toContainEqual({
|
||||
section: "source_maps",
|
||||
reason: "disallowed_origin",
|
||||
|
||||
@@ -46,7 +46,7 @@ it.each(["none", "excluded", "mixed", "redirect", "not-selected"] as const)(
|
||||
"main",
|
||||
mode === "none"
|
||||
? undefined
|
||||
: mode === "redirect"
|
||||
: mode === "redirect" || mode === "not-selected"
|
||||
? "/app.js.map"
|
||||
: "https://outside.example.test/main.js.map",
|
||||
),
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -6,10 +6,7 @@ import { expect, it } from "vitest";
|
||||
|
||||
import { fetchWebSourceMaps } from "../../../src/browser/WebSourceMapFetcher.js";
|
||||
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
||||
import {
|
||||
analyzeWebBundleInputSchema,
|
||||
webSourceMapsSchema,
|
||||
} from "../../../src/domain/webBundleAnalysis.js";
|
||||
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
||||
import { WEB_SOURCE_MAP_LIMITS } from "../../../src/domain/sourceMapLimits.js";
|
||||
|
||||
it.each([
|
||||
@@ -141,11 +138,17 @@ const mapWithSourceBytes = (bytes: Uint8Array) =>
|
||||
Buffer.concat([mapStart, bytes, mapEnd]);
|
||||
|
||||
it.each([
|
||||
{ name: "invalid JSON", body: Buffer.from("not-json"), status: "invalid" },
|
||||
{
|
||||
name: "invalid JSON",
|
||||
body: Buffer.from("not-json"),
|
||||
status: "invalid",
|
||||
diagnostic: "Source-map JSON is not a version 3 map",
|
||||
},
|
||||
{
|
||||
name: "invalid UTF-8",
|
||||
body: mapWithSourceBytes(Uint8Array.of(0xff)),
|
||||
status: "invalid",
|
||||
diagnostic: "Source-map response is not valid UTF-8",
|
||||
},
|
||||
{
|
||||
name: "a valid UTF-8 replacement character",
|
||||
@@ -157,6 +160,7 @@ it.each([
|
||||
body: Buffer.from("service unavailable"),
|
||||
status: "fetch_failed",
|
||||
responseStatus: 503,
|
||||
diagnostic: "Source-map server returned HTTP 503",
|
||||
},
|
||||
{
|
||||
name: "response limit",
|
||||
@@ -211,18 +215,10 @@ it.each([
|
||||
representation: "fetch-response-body-bytes",
|
||||
},
|
||||
});
|
||||
if (scenario.name === "invalid UTF-8")
|
||||
expect(item.limitation).toContain(
|
||||
"Source-map response is not valid UTF-8",
|
||||
);
|
||||
expect(item.limitation).toContain("Response text was not retained");
|
||||
}
|
||||
const { effective_url: _effective, ...withoutEffectiveUrl } = item;
|
||||
expect(
|
||||
webSourceMapsSchema.safeParse({
|
||||
...result,
|
||||
items: [withoutEffectiveUrl],
|
||||
}).success,
|
||||
).toBe(false);
|
||||
if (scenario.diagnostic !== undefined)
|
||||
expect(item.limitation).toContain(scenario.diagnostic);
|
||||
});
|
||||
|
||||
it.each([
|
||||
@@ -318,53 +314,49 @@ it.each([
|
||||
},
|
||||
);
|
||||
|
||||
it("charges complete escaped redirect errors and cancels every discarded response", async () => {
|
||||
it("fits complete malformed redirect diagnostics within the output budget", async () => {
|
||||
const origin = "https://app.example.test";
|
||||
const location = `http://[${'\\"'.repeat(3_000)}`;
|
||||
const request = {
|
||||
scriptKey: "script",
|
||||
declaredUrl: `${origin}/map`,
|
||||
fetchUrl: `${origin}/map`,
|
||||
};
|
||||
const location = `http://[${'\\"'.repeat(400)}`;
|
||||
const requests = ["first", "second", "third", "fourth"].map((name) => ({
|
||||
scriptKey: name,
|
||||
declaredUrl: `${origin}/${name}.map`,
|
||||
fetchUrl: `${origin}/${name}.map`,
|
||||
}));
|
||||
const budget = 9_000;
|
||||
const input = analyzeWebBundleInputSchema.parse({
|
||||
cdp_endpoint: "http://127.0.0.1:9222",
|
||||
target_id: "page",
|
||||
allowed_origins: [origin],
|
||||
fetch_source_maps: true,
|
||||
source_map_limits: { output_bytes: budget },
|
||||
});
|
||||
let calls = 0;
|
||||
let cancelled = 0;
|
||||
const host = {
|
||||
fetch: () => {
|
||||
calls += 1;
|
||||
return Promise.resolve(
|
||||
new Response(
|
||||
new ReadableStream<Uint8Array>({
|
||||
cancel() {
|
||||
cancelled += 1;
|
||||
},
|
||||
}),
|
||||
{ status: 302, headers: { location } },
|
||||
),
|
||||
);
|
||||
},
|
||||
};
|
||||
const control = await fetchWebSourceMapsOk([request], input, undefined, host);
|
||||
expect(control.items[0]?.limitation).toContain(JSON.stringify(location));
|
||||
expect(control.items[0]?.limitation?.length).toBeGreaterThan(512);
|
||||
const result = await fetchWebSourceMapsOk(
|
||||
Array.from({ length: 1_500 }, () => request),
|
||||
input,
|
||||
undefined,
|
||||
host,
|
||||
const cancelled: string[] = [];
|
||||
const result = await fetchWebSourceMapsOk(requests, input, undefined, {
|
||||
fetch: async (url) =>
|
||||
new Response(
|
||||
new ReadableStream<Uint8Array>({
|
||||
cancel() {
|
||||
cancelled.push(String(url));
|
||||
},
|
||||
}),
|
||||
{ status: 302, headers: { location } },
|
||||
),
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
status: "unavailable",
|
||||
requested: 4,
|
||||
processed: 2,
|
||||
items: requests.slice(0, 2).map(({ scriptKey, declaredUrl }) => ({
|
||||
script_key: scriptKey,
|
||||
declared_url: declaredUrl,
|
||||
status: "fetch_failed",
|
||||
limitation: expect.stringContaining(JSON.stringify(location)),
|
||||
})),
|
||||
limitation: expect.stringContaining("2 requested maps"),
|
||||
});
|
||||
expect(Buffer.byteLength(JSON.stringify(result))).toBeLessThanOrEqual(budget);
|
||||
expect(cancelled).toEqual(
|
||||
requests.slice(0, 3).map(({ fetchUrl }) => fetchUrl),
|
||||
);
|
||||
expect(result).toMatchObject({ status: "unavailable", requested: 1_500 });
|
||||
expect(result.processed).toBe(result.items.length);
|
||||
expect(result.processed).toBeLessThan(result.requested);
|
||||
expect(result.limitation).toContain("unknown");
|
||||
expect(Buffer.byteLength(JSON.stringify(result))).toBeLessThanOrEqual(
|
||||
WEB_SOURCE_MAP_LIMITS.outputBytes,
|
||||
);
|
||||
expect(calls).toBeLessThan(1_501);
|
||||
expect(cancelled).toBe(calls);
|
||||
});
|
||||
@@ -1,449 +1,171 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { expect, it } from "vitest";
|
||||
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
||||
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
||||
import { traceSourceMap } from "../../../src/javascript/sourceMaps/TraceSourceMap.js";
|
||||
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
||||
|
||||
const cases = [
|
||||
{
|
||||
name: "later nested line resets outer column",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 5,
|
||||
column: 10,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 1,
|
||||
column: 0,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [[7, 0, "a.ts"]],
|
||||
dedicatedControl: true,
|
||||
},
|
||||
{
|
||||
name: "same line retains summed columns",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 5,
|
||||
column: 10,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 3,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [[6, 13, "a.ts"]],
|
||||
dedicatedControl: true,
|
||||
},
|
||||
{
|
||||
name: "ordinary leaf unchanged",
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA;AACA",
|
||||
},
|
||||
expected: [
|
||||
[1, 0, "a.ts"],
|
||||
[2, 0, "a.ts"],
|
||||
],
|
||||
dedicatedControl: true,
|
||||
},
|
||||
{
|
||||
name: "same-line sibling clipping",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 0,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA,QAAQ,IAAI",
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 10,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["b.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [
|
||||
[1, 0, "a.ts"],
|
||||
[1, 8, "a.ts"],
|
||||
[1, 10, "b.ts"],
|
||||
],
|
||||
dedicatedControl: false,
|
||||
expectedStatus: "invalid",
|
||||
},
|
||||
{
|
||||
name: "nested gap clips previous parent leaf",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 0,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA,QAAQ,IAAI",
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 5,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 3,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["b.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [
|
||||
[1, 0, "a.ts"],
|
||||
[1, 8, "b.ts"],
|
||||
],
|
||||
dedicatedControl: false,
|
||||
expectedStatus: "invalid",
|
||||
},
|
||||
{
|
||||
name: "empty indexed sibling clips previous leaf",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 0,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA,QAAQ,IAAI",
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 5,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [],
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [[1, 0, "a.ts"]],
|
||||
dedicatedControl: false,
|
||||
expectedStatus: "invalid",
|
||||
},
|
||||
{
|
||||
name: "depth-three same-line composition",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 2,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 3,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 4,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [[1, 9, "a.ts"]],
|
||||
dedicatedControl: true,
|
||||
},
|
||||
{
|
||||
name: "multiline inherited sibling stop",
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 0,
|
||||
column: 0,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: {
|
||||
line: 1,
|
||||
column: 3,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA;AACA;AACA;AACA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: {
|
||||
line: 3,
|
||||
column: 1,
|
||||
},
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["b.ts"],
|
||||
sourcesContent: ["export const value=1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
expected: [
|
||||
[2, 3, "a.ts"],
|
||||
[3, 0, "a.ts"],
|
||||
[4, 0, "a.ts"],
|
||||
[4, 1, "b.ts"],
|
||||
],
|
||||
dedicatedControl: false,
|
||||
expectedStatus: "invalid",
|
||||
},
|
||||
] as const;
|
||||
const origin = "https://example.test";
|
||||
const url = `${origin}/app.js.map`;
|
||||
const request = {
|
||||
scriptKey: `scr_${"1".repeat(64)}`,
|
||||
declaredUrl: url,
|
||||
fetchUrl: url,
|
||||
};
|
||||
const input = analyzeWebBundleInputSchema.parse({
|
||||
cdp_endpoint: "http://127.0.0.1:9222",
|
||||
allowed_origins: [origin],
|
||||
target_id: "page-1",
|
||||
fetch_source_maps: true,
|
||||
});
|
||||
|
||||
it.each(cases)(
|
||||
"preserves indexed coordinate contract: $name",
|
||||
async (testCase) => {
|
||||
const { map, expected, dedicatedControl } = testCase;
|
||||
const expectedStatus =
|
||||
"expectedStatus" in testCase ? testCase.expectedStatus : "included";
|
||||
const origin = "https://example.test";
|
||||
const url = origin + "/app.js.map";
|
||||
const text = JSON.stringify(map);
|
||||
// The dedicated decoder already normalizes absolute leaves. Its stricter
|
||||
// overlap profile is compared only for the valid non-overlapping maps.
|
||||
if (dedicatedControl) {
|
||||
for (const [line, column] of expected) {
|
||||
const point = traceSourceMap(text, url, { line, column });
|
||||
expect(point.lookup.matched_generated_position).toEqual({
|
||||
line,
|
||||
column,
|
||||
});
|
||||
expect(point.matches).toHaveLength(1);
|
||||
}
|
||||
}
|
||||
const result = await fetchWebSourceMapsOk(
|
||||
[{ scriptKey: "scr_" + "1".repeat(64), declaredUrl: url, fetchUrl: url }],
|
||||
analyzeWebBundleInputSchema.parse({
|
||||
cdp_endpoint: "http://127.0.0.1:9222",
|
||||
allowed_origins: [origin],
|
||||
target_id: "page-1",
|
||||
fetch_source_maps: true,
|
||||
}),
|
||||
undefined,
|
||||
{ fetch: () => Promise.resolve(new Response(text, { status: 200 })) },
|
||||
);
|
||||
const item = result.items[0];
|
||||
if (expectedStatus === "invalid") {
|
||||
expect(item).toMatchObject({
|
||||
const leaf = (source: string, mappings = "AAAA") => ({
|
||||
version: 3,
|
||||
sources: [source],
|
||||
sourcesContent: ["export const value = 1;"],
|
||||
names: [],
|
||||
mappings,
|
||||
});
|
||||
|
||||
interface Section {
|
||||
offset: { line: number; column: number };
|
||||
map: ReturnType<typeof leaf> | { version: number; sections: Section[] };
|
||||
}
|
||||
|
||||
const section = (
|
||||
line: number,
|
||||
column: number,
|
||||
map: Section["map"],
|
||||
): Section => ({
|
||||
offset: { line, column },
|
||||
map,
|
||||
});
|
||||
|
||||
const indexed = (...sections: Section[]) => ({ version: 3, sections });
|
||||
|
||||
const fetchMap = (text: string) =>
|
||||
fetchWebSourceMapsOk([request], input, undefined, {
|
||||
fetch: async () => new Response(text),
|
||||
});
|
||||
|
||||
it.each([
|
||||
{
|
||||
name: "a later nested line discards the outer column",
|
||||
map: indexed(section(5, 10, indexed(section(1, 3, leaf("a.ts"))))),
|
||||
line: 7,
|
||||
column: 3,
|
||||
},
|
||||
{
|
||||
name: "three offsets on the same line add their columns",
|
||||
map: indexed(
|
||||
section(
|
||||
0,
|
||||
2,
|
||||
indexed(section(0, 3, indexed(section(0, 4, leaf("a.ts"))))),
|
||||
),
|
||||
),
|
||||
line: 1,
|
||||
column: 9,
|
||||
},
|
||||
])("publishes nested coordinates when $name", async ({ map, line, column }) => {
|
||||
const text = JSON.stringify(map);
|
||||
const result = await fetchMap(text);
|
||||
expect(result).toMatchObject({
|
||||
status: "included",
|
||||
items: [
|
||||
{
|
||||
artifact: {
|
||||
sha256: createHash("sha256").update(text).digest("hex"),
|
||||
bytes: Buffer.byteLength(text),
|
||||
},
|
||||
original_sources: [{ source: `${origin}/a.ts` }],
|
||||
mappings: [
|
||||
{
|
||||
generated_line: line,
|
||||
generated_column: column,
|
||||
source: `${origin}/a.ts`,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it.each([
|
||||
{
|
||||
name: "a following indexed section starts before its first child",
|
||||
map: indexed(
|
||||
section(0, 0, leaf("a.ts", "AAAA,QAAQ")),
|
||||
section(0, 5, indexed(section(0, 6, leaf("b.ts")))),
|
||||
),
|
||||
},
|
||||
{
|
||||
name: "a following indexed section is empty",
|
||||
map: indexed(
|
||||
section(0, 0, leaf("a.ts", "AAAA,QAAQ")),
|
||||
section(0, 5, indexed()),
|
||||
),
|
||||
},
|
||||
{
|
||||
name: "a descendant mapping passes its parent's multiline stop",
|
||||
map: indexed(
|
||||
section(
|
||||
0,
|
||||
0,
|
||||
indexed(section(1, 3, leaf("a.ts", "AAAA;AACA;AACA;AACA"))),
|
||||
),
|
||||
section(3, 1, leaf("b.ts")),
|
||||
),
|
||||
},
|
||||
])("rejects an overlap when $name", async ({ map }) => {
|
||||
const text = JSON.stringify(map);
|
||||
expect(await fetchMap(text)).toMatchObject({
|
||||
status: "unavailable",
|
||||
items: [
|
||||
{
|
||||
status: "invalid",
|
||||
artifact: null,
|
||||
mappings: [],
|
||||
limitation: expect.stringContaining("overlap"),
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (item?.status !== "included") throw new Error(JSON.stringify(result));
|
||||
expect(
|
||||
item.mappings.map((entry) => [
|
||||
entry.generated_line,
|
||||
entry.generated_column,
|
||||
entry.source?.replace(origin + "/", "") ?? null,
|
||||
]),
|
||||
).toEqual(expected);
|
||||
expect(item.artifact.sha256).toBe(
|
||||
createHash("sha256").update(text).digest("hex"),
|
||||
);
|
||||
expect(item.artifact.bytes).toBe(Buffer.byteLength(text));
|
||||
// Boundary-only markers must not introduce empty original-source identities.
|
||||
expect(item.original_sources.map(({ source }) => source)).toEqual([
|
||||
...new Set(expected.map(([, , source]) => origin + "/" + source)),
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
it("rejects a source mapping that crosses an indexed section boundary", async () => {
|
||||
const origin = "https://example.test";
|
||||
const url = `${origin}/app.js.map`;
|
||||
const makeMap = (firstMappings: string) => ({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.js"],
|
||||
sourcesContent: ["x();"],
|
||||
names: [],
|
||||
mappings: firstMappings,
|
||||
response_identity: {
|
||||
sha256: createHash("sha256").update(text).digest("hex"),
|
||||
bytes: Buffer.byteLength(text),
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: { line: 0, column: 1 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["b.js"],
|
||||
sourcesContent: ["y();"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
const input = analyzeWebBundleInputSchema.parse({
|
||||
cdp_endpoint: "http://127.0.0.1:9222",
|
||||
allowed_origins: [origin],
|
||||
target_id: "page-1",
|
||||
fetch_source_maps: true,
|
||||
});
|
||||
const request = {
|
||||
scriptKey: "scr_" + "1".repeat(64),
|
||||
declaredUrl: url,
|
||||
fetchUrl: url,
|
||||
};
|
||||
const fetchMap = (map: ReturnType<typeof makeMap>) =>
|
||||
fetchWebSourceMapsOk([request], input, undefined, {
|
||||
fetch: () =>
|
||||
Promise.resolve(new Response(JSON.stringify(map), { status: 200 })),
|
||||
});
|
||||
const overlapping = makeMap("AAAA,EAAA");
|
||||
const overlapText = JSON.stringify(overlapping);
|
||||
expect(() =>
|
||||
traceSourceMap(overlapText, url, { line: 1, column: 2 }),
|
||||
).toThrow(/overlap/u);
|
||||
const overlappingResult = await fetchMap(overlapping);
|
||||
expect(overlappingResult).toMatchObject({
|
||||
status: "unavailable",
|
||||
requested: 1,
|
||||
processed: 1,
|
||||
});
|
||||
expect(overlappingResult.items[0]).toMatchObject({
|
||||
status: "invalid",
|
||||
artifact: null,
|
||||
mappings: [],
|
||||
limitation: expect.stringContaining("overlap"),
|
||||
});
|
||||
|
||||
const controlResult = await fetchMap(makeMap("AAAA"));
|
||||
expect(controlResult.items[0]).toMatchObject({
|
||||
status: "included",
|
||||
limitation: null,
|
||||
mappings: [
|
||||
{ generated_line: 1, generated_column: 0, source: `${origin}/a.js` },
|
||||
{ generated_line: 1, generated_column: 1, source: `${origin}/b.js` },
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it("treats the next section start as an exclusive end for the previous section", async () => {
|
||||
const fetchSiblings = (firstMappings: string) =>
|
||||
fetchMap(
|
||||
JSON.stringify(
|
||||
indexed(
|
||||
section(0, 0, leaf("a.ts", firstMappings)),
|
||||
section(0, 10, leaf("b.ts")),
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
expect(await fetchSiblings("AAAA,QAAQ")).toMatchObject({
|
||||
status: "included",
|
||||
items: [
|
||||
{
|
||||
mappings: [
|
||||
{ generated_line: 1, generated_column: 0, source: `${origin}/a.ts` },
|
||||
{ generated_line: 1, generated_column: 8, source: `${origin}/a.ts` },
|
||||
{ generated_line: 1, generated_column: 10, source: `${origin}/b.ts` },
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(await fetchSiblings("AAAA,UAAA")).toMatchObject({
|
||||
status: "unavailable",
|
||||
items: [
|
||||
{
|
||||
status: "invalid",
|
||||
artifact: null,
|
||||
mappings: [],
|
||||
limitation: expect.stringContaining("overlap"),
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
+27
-9
@@ -6,9 +6,19 @@ import { expect, it } from "vitest";
|
||||
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
||||
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
||||
|
||||
it("retains unshadowed optional require dependencies from HTTP source-map originals", async () => {
|
||||
it("retains literal dependencies from HTTP source-map originals", async () => {
|
||||
const source = [
|
||||
'// import "./comment.js";',
|
||||
String.raw`const quoted = "require(\"./string.js\")";`,
|
||||
"const template = `import './template-comment.js'`;",
|
||||
`export { value } from "./it's-real.js";`,
|
||||
'import "package-name";',
|
||||
'import("./dynamic.js");',
|
||||
"import(`./dep.js`);",
|
||||
"import(`./dep.${name}.js`);",
|
||||
'require("./normal.cjs");',
|
||||
"require(`./templated.cjs`);",
|
||||
"require(`./${name}.cjs`);",
|
||||
'require?.("./optional.cjs");',
|
||||
'function local(require) { require?.("./shadowed.cjs"); }',
|
||||
"require?.(selectedModule);",
|
||||
@@ -48,14 +58,22 @@ it("retains unshadowed optional require dependencies from HTTP source-map origin
|
||||
sha256: createHash("sha256").update(text).digest("hex"),
|
||||
},
|
||||
original_sources: [{ artifact: { text: source } }],
|
||||
original_module_edges: ["./normal.cjs", "./optional.cjs"].map(
|
||||
(specifier) => ({
|
||||
from_source: `${origin}/main.cjs`,
|
||||
kind: "require",
|
||||
specifier,
|
||||
resolved_source: new URL(specifier, origin).href,
|
||||
}),
|
||||
),
|
||||
mappings: [{ generated_line: 1, source: `${origin}/main.cjs` }],
|
||||
original_module_edges: [
|
||||
{ specifier: "./it's-real.js", kind: "static_import" },
|
||||
{ specifier: "package-name", kind: "static_import" },
|
||||
{ specifier: "./dynamic.js", kind: "dynamic_import" },
|
||||
{ specifier: "./dep.js", kind: "dynamic_import" },
|
||||
{ specifier: "./normal.cjs", kind: "require" },
|
||||
{ specifier: "./templated.cjs", kind: "require" },
|
||||
{ specifier: "./optional.cjs", kind: "require" },
|
||||
].map(({ kind, specifier }) => ({
|
||||
from_source: `${origin}/main.cjs`,
|
||||
kind,
|
||||
specifier,
|
||||
resolved_source:
|
||||
specifier === "package-name" ? null : new URL(specifier, origin).href,
|
||||
})),
|
||||
});
|
||||
} finally {
|
||||
server.closeAllConnections();
|
||||
@@ -1,11 +1,8 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { expect, it, onTestFinished, vi } from "vitest";
|
||||
import { expect, it, vi } from "vitest";
|
||||
|
||||
import { fetchWebSourceMaps } from "../../../src/browser/WebSourceMapFetcher.js";
|
||||
import {
|
||||
analyzeWebBundleInputSchema,
|
||||
webSourceMapsSchema,
|
||||
} from "../../../src/domain/webBundleAnalysis.js";
|
||||
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
||||
|
||||
const origin = "https://maps.example.test";
|
||||
const request = (index: number) => ({
|
||||
@@ -23,9 +20,7 @@ const digest = (bytes: Uint8Array | string): string =>
|
||||
createHash("sha256").update(bytes).digest("hex");
|
||||
|
||||
it.each([
|
||||
{ label: "an empty body", body: "" },
|
||||
{ label: "JSON", body: "not-json" },
|
||||
{ label: "BOM and XSSI framing", body: "\uFEFF)]}'\nnot-json" },
|
||||
{ label: "an absent body", body: null },
|
||||
{
|
||||
label: "mapping indices",
|
||||
body: JSON.stringify({
|
||||
@@ -51,8 +46,8 @@ it.each([
|
||||
status: "invalid",
|
||||
artifact: null,
|
||||
response_identity: {
|
||||
sha256: digest(body),
|
||||
bytes: Buffer.byteLength(body),
|
||||
sha256: digest(body ?? ""),
|
||||
bytes: Buffer.byteLength(body ?? ""),
|
||||
representation: "fetch-response-body-bytes",
|
||||
},
|
||||
original_sources: [],
|
||||
@@ -62,64 +57,40 @@ it.each([
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(webSourceMapsSchema.parse(result.value)).toEqual(result.value);
|
||||
},
|
||||
);
|
||||
|
||||
it("retains only completed response bytes when UTF-8 decoding fails", async () => {
|
||||
const body = Uint8Array.of(0x7b, 0x22, 0xc3, 0x28, 0x22, 0x7d);
|
||||
const result = await fetchWebSourceMaps([request(1)], input, undefined, {
|
||||
fetch: () => Promise.resolve(new Response(body, { status: 200 })),
|
||||
});
|
||||
if (!result.ok) throw result.error;
|
||||
expect(result.value).toMatchObject({
|
||||
status: "unavailable",
|
||||
items: [
|
||||
{
|
||||
status: "invalid",
|
||||
artifact: null,
|
||||
response_identity: {
|
||||
sha256: digest(body),
|
||||
bytes: body.byteLength,
|
||||
representation: "fetch-response-body-bytes",
|
||||
},
|
||||
original_sources: [],
|
||||
original_module_edges: [],
|
||||
mappings: [],
|
||||
limitation: expect.stringContaining("Response text was not retained"),
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it("retains completed body identity when map interpretation reaches its deadline", async () => {
|
||||
it("retains completed body identity when the deadline lands as the response stream ends", async () => {
|
||||
const body = JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["a.js"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
});
|
||||
const response = new Response(body, { status: 200 });
|
||||
const realDecode = TextDecoder.prototype.decode;
|
||||
let clock = 0;
|
||||
const clockSpy = vi.spyOn(performance, "now").mockImplementation(() => clock);
|
||||
const decodeSpy = vi
|
||||
.spyOn(TextDecoder.prototype, "decode")
|
||||
.mockImplementation(function (
|
||||
this: TextDecoder,
|
||||
input?: Parameters<TextDecoder["decode"]>[0],
|
||||
options?: Parameters<TextDecoder["decode"]>[1],
|
||||
) {
|
||||
const text = realDecode.call(this, input, options);
|
||||
clock = 1_001;
|
||||
return text;
|
||||
});
|
||||
let sentBody = false;
|
||||
const stream = new ReadableStream<Uint8Array>(
|
||||
{
|
||||
pull(controller) {
|
||||
if (sentBody) {
|
||||
clock = 1_001;
|
||||
controller.close();
|
||||
return;
|
||||
}
|
||||
sentBody = true;
|
||||
controller.enqueue(Buffer.from(body));
|
||||
},
|
||||
},
|
||||
{ highWaterMark: 0 },
|
||||
);
|
||||
|
||||
try {
|
||||
const result = await fetchWebSourceMaps(
|
||||
[request(1)],
|
||||
{ ...input, source_map_fetch_timeout_ms: 1_000 },
|
||||
undefined,
|
||||
{ fetch: () => Promise.resolve(response) },
|
||||
{ fetch: async () => new Response(stream) },
|
||||
);
|
||||
if (!result.ok) throw result.error;
|
||||
expect(result.value).toMatchObject({
|
||||
@@ -145,34 +116,30 @@ it("retains completed body identity when map interpretation reaches its deadline
|
||||
],
|
||||
});
|
||||
} finally {
|
||||
decodeSpy.mockRestore();
|
||||
clockSpy.mockRestore();
|
||||
}
|
||||
});
|
||||
|
||||
it("refuses oversized text before JSON interpretation while retaining body identity and later maps", async () => {
|
||||
// JSON escaping expands these decoded control characters beyond the default
|
||||
// 32 MiB source-map output allowance while the response stays below 64 MiB.
|
||||
const oversized = Buffer.alloc(6 * 1024 * 1024, 1);
|
||||
const oversizedText = oversized.toString("utf8");
|
||||
it("retains body identity and later maps when escaping exceeds the output budget", async () => {
|
||||
const budget = 8_000;
|
||||
const oversized = Buffer.alloc(2_000, 1);
|
||||
expect(oversized.byteLength).toBeLessThan(budget);
|
||||
expect(
|
||||
Buffer.byteLength(JSON.stringify(oversized.toString("utf8"))),
|
||||
).toBeGreaterThan(budget);
|
||||
const valid = JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["a.js"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
});
|
||||
const parseSpy = vi.spyOn(JSON, "parse");
|
||||
onTestFinished(() => parseSpy.mockRestore());
|
||||
let calls = 0;
|
||||
const result = await fetchWebSourceMaps(
|
||||
[request(1), request(2)],
|
||||
input,
|
||||
{ ...input, source_map_limits: { output_bytes: budget } },
|
||||
undefined,
|
||||
{
|
||||
fetch: () =>
|
||||
Promise.resolve(
|
||||
new Response(calls++ === 0 ? oversized : valid, { status: 200 }),
|
||||
),
|
||||
fetch: async (url) =>
|
||||
new Response(String(url) === request(1).fetchUrl ? oversized : valid),
|
||||
},
|
||||
);
|
||||
if (!result.ok) throw result.error;
|
||||
@@ -197,16 +164,9 @@ it("refuses oversized text before JSON interpretation while retaining body ident
|
||||
});
|
||||
const limitation = result.value.items[0]?.limitation;
|
||||
expect(limitation).toMatch(/JSON[- ]escap/i);
|
||||
expect(limitation).toMatch(/metadata/i);
|
||||
expect(limitation).toContain(
|
||||
"source_map_limits.output_bytes is 33554432 bytes",
|
||||
);
|
||||
expect(limitation).toContain("source_map_limits.output_bytes is 8000 bytes");
|
||||
expect(limitation).toContain("Increase that per-call field");
|
||||
expect(Buffer.byteLength(JSON.stringify(result.value))).toBeLessThanOrEqual(
|
||||
32 * 1024 * 1024,
|
||||
budget,
|
||||
);
|
||||
expect(parseSpy.mock.calls.some(([text]) => text === oversizedText)).toBe(
|
||||
false,
|
||||
);
|
||||
expect(calls).toBe(2);
|
||||
});
|
||||
@@ -1,3 +1,4 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { once } from "node:events";
|
||||
import { createServer } from "node:http";
|
||||
|
||||
@@ -7,19 +8,63 @@ import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalys
|
||||
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
||||
|
||||
it("selects original source language from decoded URL paths while retaining URL evidence", async () => {
|
||||
const typescriptContent = 'import "./dep.ts"; const value = <number>1;';
|
||||
const annotatedContent = 'import "./dep.ts"; const value: number = 1;';
|
||||
const javascriptContent = 'import "./dep.ts"; const value = 1;';
|
||||
const declarations = [
|
||||
"plain.ts?revision=2#view.tsx",
|
||||
"escaped%2Ets?revision=2#view.tsx",
|
||||
"escaped.%74s?revision=2#view.tsx",
|
||||
"invalid%.ts?revision=2#view.tsx",
|
||||
{
|
||||
path: "plain.ts?revision=2#view.tsx",
|
||||
mediaType: "text/typescript",
|
||||
content: typescriptContent,
|
||||
},
|
||||
{
|
||||
path: "escaped%2Ets?revision=2#view.tsx",
|
||||
mediaType: "text/typescript",
|
||||
content: typescriptContent,
|
||||
},
|
||||
{
|
||||
path: "escaped.%74s?revision=2#view.tsx",
|
||||
mediaType: "text/typescript",
|
||||
content: typescriptContent,
|
||||
},
|
||||
{
|
||||
path: "invalid%.ts?revision=2#view.tsx",
|
||||
mediaType: "text/typescript",
|
||||
content: typescriptContent,
|
||||
},
|
||||
{
|
||||
path: "view.tsx#original.ts",
|
||||
mediaType: "text/typescript",
|
||||
content: 'import "./dep.ts"; export const view: JSX.Element = <main />;',
|
||||
},
|
||||
{
|
||||
path: "module.mts",
|
||||
mediaType: "text/typescript",
|
||||
content: annotatedContent,
|
||||
},
|
||||
{
|
||||
path: "common.cts",
|
||||
mediaType: "text/typescript",
|
||||
content: annotatedContent,
|
||||
},
|
||||
{
|
||||
path: "main.js?filename=main.ts#original.ts",
|
||||
mediaType: "text/javascript",
|
||||
content: javascriptContent,
|
||||
},
|
||||
{
|
||||
path: "extensionless?revision=2",
|
||||
mediaType: "text/javascript",
|
||||
content: javascriptContent,
|
||||
},
|
||||
];
|
||||
const content = 'import "./dep.ts"; const value = <number>1;';
|
||||
const text = JSON.stringify({
|
||||
version: 3,
|
||||
names: [],
|
||||
sources: declarations,
|
||||
sourcesContent: declarations.map(() => content),
|
||||
mappings: "AAAA,ACAA,ACAA,ACAA",
|
||||
sources: declarations.map(({ path }) => path),
|
||||
sourcesContent: declarations.map(({ content }) => content),
|
||||
// One generated line per source, with the source index advancing each time.
|
||||
mappings: `AAAA${";ACAA".repeat(declarations.length - 1)}`,
|
||||
});
|
||||
const requests: string[] = [];
|
||||
const server = createServer((request, response) => {
|
||||
@@ -44,19 +89,30 @@ it("selects original source language from decoded URL paths while retaining URL
|
||||
fetch_source_maps: true,
|
||||
}),
|
||||
);
|
||||
const sources = declarations.map((source) => `${origin}/maps/${source}`);
|
||||
const sources = declarations.map(({ path, ...artifact }) => ({
|
||||
source: `${origin}/maps/${path}`,
|
||||
...artifact,
|
||||
}));
|
||||
expect(requests).toEqual(["/maps/app.js.map"]);
|
||||
expect(result.status).toBe("included");
|
||||
expect(result.items[0]).toMatchObject({
|
||||
status: "included",
|
||||
limitation: null,
|
||||
artifact: { text },
|
||||
original_sources: sources.map((source) => ({
|
||||
original_sources: sources.map(({ source, content, mediaType }) => ({
|
||||
source,
|
||||
artifact: { media_type: "text/typescript", text: content },
|
||||
artifact: {
|
||||
media_type: mediaType,
|
||||
text: content,
|
||||
bytes: Buffer.byteLength(content),
|
||||
sha256: createHash("sha256").update(content).digest("hex"),
|
||||
},
|
||||
})),
|
||||
mappings: sources.map((source) => ({ source })),
|
||||
original_module_edges: sources.map((source) => ({
|
||||
mappings: sources.map(({ source }, index) => ({
|
||||
generated_line: index + 1,
|
||||
source,
|
||||
})),
|
||||
original_module_edges: sources.map(({ source }) => ({
|
||||
from_source: source,
|
||||
kind: "static_import",
|
||||
specifier: "./dep.ts",
|
||||
|
||||
@@ -5,22 +5,16 @@ import { expect, it } from "vitest";
|
||||
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
||||
import { inventoryArtifact } from "../../fixtures/artifactInventory.js";
|
||||
|
||||
it.each([
|
||||
"directory",
|
||||
"directory-with-child",
|
||||
"file",
|
||||
"directory-map",
|
||||
"missing",
|
||||
])(
|
||||
it.each(["directory-with-child", "file", "directory-map", "missing"] as const)(
|
||||
"admits only a regular mapped file while retaining ZIP containment (%s)",
|
||||
async (target) => {
|
||||
const root = await createTestTempDirectory("rea-map-target-kind-");
|
||||
const path = join(root, "sample.zip");
|
||||
const writer = new ZipWriter(new Uint8ArrayWriter());
|
||||
if (target.startsWith("directory") && target !== "directory-map")
|
||||
if (target === "directory-with-child") {
|
||||
await writer.add("main.js/", undefined, { directory: true });
|
||||
if (target === "directory-with-child")
|
||||
await writer.add("main.js/child.txt", new TextReader("child"));
|
||||
}
|
||||
if (target === "file" || target === "directory-map")
|
||||
await writer.add("main.js", new TextReader("export const answer = 42;"));
|
||||
if (target === "directory-map")
|
||||
@@ -64,7 +58,7 @@ it.each([
|
||||
target === "file" ? main?.artifact_id : carrier.artifact_id,
|
||||
});
|
||||
expect(map.limitations).toEqual([]);
|
||||
if (target.startsWith("directory") && target !== "directory-map") {
|
||||
if (target === "directory-with-child") {
|
||||
expect(main).toMatchObject({
|
||||
entry_kind: "directory",
|
||||
artifact_kind: "container",
|
||||
@@ -77,8 +71,6 @@ it.each([
|
||||
relation: "contains",
|
||||
parent_artifact_id: carrier.artifact_id,
|
||||
});
|
||||
}
|
||||
if (target === "directory-with-child") {
|
||||
const child = inventory.occurrences.find(
|
||||
({ logical_path }) => logical_path === "main.js/child.txt",
|
||||
);
|
||||
|
||||
+35
-258
@@ -26,183 +26,6 @@ const analyzeMaps = async (maps: Readonly<Record<string, string>>) => {
|
||||
return analysis.graph;
|
||||
};
|
||||
|
||||
it("marks missing regular-map mappings unavailable and accepts empty or populated strings", async () => {
|
||||
const original = "export const answer: number = 42;";
|
||||
const maps = {
|
||||
"missing.js.map": JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [original],
|
||||
names: [],
|
||||
}),
|
||||
"empty.js.map": JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [original],
|
||||
names: [],
|
||||
mappings: "",
|
||||
}),
|
||||
"mapped.js.map": JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [original],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
}),
|
||||
};
|
||||
const graph = await analyzeMaps(maps);
|
||||
const missingDigest = createHash("sha256")
|
||||
.update(maps["missing.js.map"])
|
||||
.digest("hex");
|
||||
expect(graph.coverage.status).toBe("partial");
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "unknown",
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
operation: "parse-local-source-map",
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: missingDigest }),
|
||||
limitations: ["Source map has no mappings string."],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
const originals = graph.nodes.filter(
|
||||
(node) => node.identity.strategy === "source-map-original",
|
||||
);
|
||||
expect(originals).toHaveLength(3);
|
||||
expect(originals).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "source-module",
|
||||
identity: expect.objectContaining({
|
||||
source_map_sha256: missingDigest,
|
||||
original_source: "original.ts",
|
||||
source_sha256: createHash("sha256").update(original).digest("hex"),
|
||||
}),
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: missingDigest }),
|
||||
limitations: ["Source map has no mappings string."],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
for (const mapPath of ["empty.js.map", "mapped.js.map"] as const) {
|
||||
const digest = createHash("sha256").update(maps[mapPath]).digest("hex");
|
||||
expect(originals).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "source-module",
|
||||
identity: expect.objectContaining({ source_map_sha256: digest }),
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
evidence: expect.objectContaining({ limitations: [] }),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
it("retains declarations before and after an invalid indexed-map leaf", async () => {
|
||||
const mapText = JSON.stringify({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["before.ts"],
|
||||
sourcesContent: ["export const before = 1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: { line: 1, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["middle.ts"],
|
||||
sourcesContent: ["export const middle = 2;"],
|
||||
names: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: { line: 2, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["after.ts"],
|
||||
sourcesContent: ["export const after = 3;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
const graph = await analyzeMaps({ "indexed.js.map": mapText });
|
||||
const digest = createHash("sha256").update(mapText).digest("hex");
|
||||
expect(graph.coverage.status).toBe("partial");
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "unknown",
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
path: "indexed.js.map",
|
||||
operation: "parse-local-source-map",
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: digest }),
|
||||
limitations: ["Source map has no mappings string in section [1]."],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
const originals = graph.nodes.filter(
|
||||
(node) =>
|
||||
node.identity.strategy === "source-map-original" &&
|
||||
node.identity.source_map_sha256 === digest,
|
||||
);
|
||||
expect(originals).toHaveLength(3);
|
||||
for (const [index, sourceName, content] of [
|
||||
[0, "before.ts", "export const before = 1;"],
|
||||
[1, "middle.ts", "export const middle = 2;"],
|
||||
[2, "after.ts", "export const after = 3;"],
|
||||
] as const) {
|
||||
expect(originals).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "source-module",
|
||||
identity: expect.objectContaining({
|
||||
source_map_sha256: digest,
|
||||
original_source: sourceName,
|
||||
source_sha256: createHash("sha256").update(content).digest("hex"),
|
||||
}),
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
declaration_index: index,
|
||||
source_name_available: true,
|
||||
content_available: true,
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: digest }),
|
||||
limitations: [
|
||||
"Source map has no mappings string in section [1].",
|
||||
],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
it("keeps external indexed sections unsupported while retaining local siblings", async () => {
|
||||
const url = "https://app.test/maps/part.map";
|
||||
const mapText = JSON.stringify({
|
||||
@@ -340,7 +163,7 @@ it("marks non-array sections malformed even when the object has regular-map fiel
|
||||
).toBe(false);
|
||||
});
|
||||
|
||||
it("retains declarations around a semantically invalid indexed leaf", async () => {
|
||||
it("retains safe declarations and section diagnostics across malformed leaves", async () => {
|
||||
const mapText = JSON.stringify({
|
||||
version: 3,
|
||||
sections: [
|
||||
@@ -351,81 +174,7 @@ it("retains declarations around a semantically invalid indexed leaf", async () =
|
||||
sources: ["before.ts"],
|
||||
sourcesContent: ["export const before = 1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: { line: 1, column: 0 },
|
||||
map: { version: 3, sourcesContent: [], names: [], mappings: "AAAA" },
|
||||
},
|
||||
{
|
||||
offset: { line: 2, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["after.ts"],
|
||||
sourcesContent: ["export const after = 2;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
const graph = await analyzeMaps({ "indexed-invalid-leaf.js.map": mapText });
|
||||
const digest = createHash("sha256").update(mapText).digest("hex");
|
||||
const limitation = "Source map has no sources array in section [1].";
|
||||
|
||||
expect(graph.coverage.status).toBe("partial");
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "unknown",
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
path: "indexed-invalid-leaf.js.map",
|
||||
operation: "parse-local-source-map",
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
artifact: expect.objectContaining({ sha256: digest }),
|
||||
limitations: [limitation],
|
||||
}),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
for (const [source, section_path, content] of [
|
||||
["before.ts", [0], "export const before = 1;"],
|
||||
["after.ts", [2], "export const after = 2;"],
|
||||
] as const)
|
||||
expect(graph.nodes).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "source-module",
|
||||
identity: expect.objectContaining({
|
||||
source_map_sha256: digest,
|
||||
original_source: source,
|
||||
source_sha256: createHash("sha256").update(content).digest("hex"),
|
||||
}),
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({ section_path }),
|
||||
evidence: expect.objectContaining({ limitations: [limitation] }),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it("keeps safe declarations across malformed roots, contents, and source entries", async () => {
|
||||
const mapText = JSON.stringify({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["before.ts"],
|
||||
sourcesContent: ["export const before = 1;"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
mappings: "",
|
||||
},
|
||||
},
|
||||
{
|
||||
@@ -461,6 +210,19 @@ it("keeps safe declarations across malformed roots, contents, and source entries
|
||||
},
|
||||
{
|
||||
offset: { line: 4, column: 0 },
|
||||
map: { version: 3, sourcesContent: [], names: [], mappings: "AAAA" },
|
||||
},
|
||||
{
|
||||
offset: { line: 5, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["no-mappings.ts"],
|
||||
sourcesContent: ["export const noMappings = 4;"],
|
||||
names: [],
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: { line: 6, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["after.ts"],
|
||||
@@ -479,6 +241,8 @@ it("keeps safe declarations across malformed roots, contents, and source entries
|
||||
"Source map sourceRoot must be a string or null in section [1].",
|
||||
"Source map sourcesContent must be an array of strings or null entries in section [2].",
|
||||
"Source map contains a non-string source name at index 0 in section [3].",
|
||||
"Source map has no sources array in section [4].",
|
||||
"Source map has no mappings string in section [5].",
|
||||
].join("; ");
|
||||
|
||||
expect(graph.coverage.status).toBe("partial");
|
||||
@@ -495,13 +259,22 @@ it("keeps safe declarations across malformed roots, contents, and source entries
|
||||
]),
|
||||
}),
|
||||
);
|
||||
for (const [source, section_path, content, source_index] of [
|
||||
const originals = graph.nodes.filter(
|
||||
({ identity }) => identity.strategy === "source-map-original",
|
||||
);
|
||||
expect(originals).toHaveLength(5);
|
||||
const retained = [
|
||||
["before.ts", [0], "export const before = 1;", 0],
|
||||
["content.ts", [2], null, 0],
|
||||
["valid-entry.ts", [3], "export const validEntry = 3;", 1],
|
||||
["after.ts", [4], "export const after = 4;", 0],
|
||||
] as const)
|
||||
expect(graph.nodes).toContainEqual(
|
||||
["no-mappings.ts", [5], "export const noMappings = 4;", 0],
|
||||
["after.ts", [6], "export const after = 4;", 0],
|
||||
] as const;
|
||||
for (const [
|
||||
declaration_index,
|
||||
[source, section_path, content, source_index],
|
||||
] of retained.entries())
|
||||
expect(originals).toContainEqual(
|
||||
expect.objectContaining({
|
||||
kind: "source-module",
|
||||
identity: expect.objectContaining({
|
||||
@@ -514,7 +287,11 @@ it("keeps safe declarations across malformed roots, contents, and source entries
|
||||
}),
|
||||
observations: expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({ section_path, source_index }),
|
||||
properties: expect.objectContaining({
|
||||
section_path,
|
||||
source_index,
|
||||
declaration_index,
|
||||
}),
|
||||
evidence: expect.objectContaining({ limitations: [limitation] }),
|
||||
}),
|
||||
]),
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
import { writeFile } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { expect, it } from "vitest";
|
||||
|
||||
import { reconstructJavaScriptArtifact } from "../../support/javascriptApplicationScope.js";
|
||||
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
||||
|
||||
it("creates source-map graph relationships only for real comments", async () => {
|
||||
const root = await createTestTempDirectory("rea-source-map-comments-");
|
||||
const path = join(root, "documentation.js");
|
||||
const quoted = 'const documentation = "//# sourceMappingURL=ghost.map ";';
|
||||
await writeFile(path, quoted);
|
||||
const withoutDirective = await reconstructJavaScriptArtifact({
|
||||
input_path: root,
|
||||
});
|
||||
expect(withoutDirective.statistics.parse_failures).toBe(0);
|
||||
expect(
|
||||
withoutDirective.graph.nodes.filter(({ kind }) => kind === "source-map"),
|
||||
).toEqual([]);
|
||||
expect(
|
||||
withoutDirective.graph.edges.filter(
|
||||
({ relation, target_node_id }) =>
|
||||
relation === "maps_to" &&
|
||||
withoutDirective.graph.nodes.some(
|
||||
({ kind, node_id }) =>
|
||||
kind === "source-map" && node_id === target_node_id,
|
||||
),
|
||||
),
|
||||
).toEqual([]);
|
||||
|
||||
await writeFile(path, `${quoted}\n//# sourceMappingURL=real.map\n`);
|
||||
const withDirective = await reconstructJavaScriptArtifact({
|
||||
input_path: root,
|
||||
});
|
||||
expect(
|
||||
withDirective.graph.nodes.filter(({ kind }) => kind === "source-map"),
|
||||
).toHaveLength(1);
|
||||
const nodes = new Map(
|
||||
withDirective.graph.nodes.map((node) => [node.node_id, node]),
|
||||
);
|
||||
const sourceMapEdge = withDirective.graph.edges.find(
|
||||
({ relation, target_node_id }) =>
|
||||
relation === "maps_to" &&
|
||||
nodes.get(target_node_id)?.kind === "source-map",
|
||||
);
|
||||
expect(
|
||||
nodes
|
||||
.get(sourceMapEdge?.target_node_id ?? "")
|
||||
?.observations.map(({ properties }) => properties.declared_url),
|
||||
).toContain("real.map");
|
||||
});
|
||||
@@ -11,55 +11,65 @@ import {
|
||||
serializeJavaScriptApplicationGraph,
|
||||
} from "../../../src/domain/javascript/javascriptApplicationGraph.js";
|
||||
|
||||
it.each(["\n", "\r\n", "\r", "\u2028", "\u2029"])(
|
||||
"preserves source-map graph evidence coordinates after %j",
|
||||
async (separator) => {
|
||||
const root = await createTestTempDirectory("rea-source-map-locations-");
|
||||
const directive = "//# sourceMappingURL=app.js.map";
|
||||
const source = `const marker = "😀";${separator} ${directive}`;
|
||||
await writeFile(join(root, "app.js"), source);
|
||||
const result = await reconstructJavaScriptArtifact({ input_path: root });
|
||||
expect(result.statistics.parse_failures).toBe(0);
|
||||
const nodes = new Map(
|
||||
result.graph.nodes.map((node) => [node.node_id, node]),
|
||||
);
|
||||
const edge = result.graph.edges.find(
|
||||
({ relation, target_node_id }) =>
|
||||
relation === "maps_to" &&
|
||||
nodes.get(target_node_id)?.kind === "source-map",
|
||||
);
|
||||
expect(edge).toMatchObject({
|
||||
properties: {
|
||||
declared_url_sha256: createHash("sha256")
|
||||
.update("app.js.map")
|
||||
.digest("hex"),
|
||||
resolved_path: null,
|
||||
},
|
||||
evidence: {
|
||||
state: "inferred",
|
||||
artifact: {
|
||||
sha256: createHash("sha256").update(source).digest("hex"),
|
||||
},
|
||||
location: {
|
||||
available: true,
|
||||
value: {
|
||||
kind: "source-range",
|
||||
source: "app.js",
|
||||
start: { line: 2, column: 2 },
|
||||
end: { line: 2, column: directive.length + 2 },
|
||||
it("publishes the location of real source-map comments across JavaScript line breaks", async () => {
|
||||
const root = await createTestTempDirectory("rea-source-map-locations-");
|
||||
const directive = "//# sourceMappingURL=app.js.map";
|
||||
const quoted = [
|
||||
'const marker = "😀 //# sourceMappingURL=ghost.map";',
|
||||
"const template = `/*# sourceMappingURL=template.map */`;",
|
||||
].join(" ");
|
||||
const files = ["\n", "\r\n", "\r", "\u2028", "\u2029"].map(
|
||||
(separator, index) => ({
|
||||
name: `app-${index}.js`,
|
||||
text: `${quoted}${separator} ${directive}`,
|
||||
}),
|
||||
);
|
||||
await Promise.all(
|
||||
files.map(({ name, text }) => writeFile(join(root, name), text)),
|
||||
);
|
||||
|
||||
const result = await reconstructJavaScriptArtifact({ input_path: root });
|
||||
expect(result.statistics.parse_failures).toBe(0);
|
||||
const nodes = new Map(result.graph.nodes.map((node) => [node.node_id, node]));
|
||||
const edges = result.graph.edges.filter(
|
||||
({ relation, target_node_id }) =>
|
||||
relation === "maps_to" &&
|
||||
nodes.get(target_node_id)?.kind === "source-map",
|
||||
);
|
||||
expect(edges).toHaveLength(files.length);
|
||||
for (const { name, text } of files)
|
||||
expect(edges).toContainEqual(
|
||||
expect.objectContaining({
|
||||
properties: expect.objectContaining({
|
||||
declared_url_sha256: createHash("sha256")
|
||||
.update("app.js.map")
|
||||
.digest("hex"),
|
||||
resolved_path: null,
|
||||
}),
|
||||
evidence: expect.objectContaining({
|
||||
state: "inferred",
|
||||
artifact: expect.objectContaining({
|
||||
sha256: createHash("sha256").update(text).digest("hex"),
|
||||
}),
|
||||
location: {
|
||||
available: true,
|
||||
value: {
|
||||
kind: "source-range",
|
||||
source: name,
|
||||
start: { line: 2, column: 2 },
|
||||
end: { line: 2, column: directive.length + 2 },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(
|
||||
nodes
|
||||
.get(edge?.target_node_id ?? "")
|
||||
?.observations.some(
|
||||
({ properties }) => properties.declared_url === "app.js.map",
|
||||
),
|
||||
).toBe(true);
|
||||
},
|
||||
);
|
||||
}),
|
||||
}),
|
||||
);
|
||||
const declaredUrls = result.graph.nodes
|
||||
.filter(({ kind }) => kind === "source-map")
|
||||
.flatMap(({ observations }) =>
|
||||
observations.map(({ properties }) => properties.declared_url),
|
||||
);
|
||||
expect(new Set(declaredUrls)).toEqual(new Set(["app.js.map"]));
|
||||
});
|
||||
|
||||
it("owns an inline source-map URL once and recovers it from the target after JSON roundtrip", async () => {
|
||||
const root = await createTestTempDirectory("rea-inline-source-map-url-");
|
||||
@@ -134,6 +144,8 @@ it("associates each source-map URL with its edge when aliases share one physical
|
||||
);
|
||||
expect(mapEdges).toHaveLength(2);
|
||||
expect(mapEdges[0]?.target_node_id).toBe(mapEdges[1]?.target_node_id);
|
||||
const mapNode = nodes.get(mapEdges[0]?.target_node_id ?? "");
|
||||
expect(mapNode?.identity.strategy).toBe("content-digest");
|
||||
// Edge order follows content-derived edge IDs, so pair each edge with the
|
||||
// script whose comment declared it.
|
||||
const declaredBySource = new Map(
|
||||
@@ -152,6 +164,8 @@ it("associates each source-map URL with its edge when aliases share one physical
|
||||
{
|
||||
declared_url: observation?.properties.declared_url,
|
||||
resolved_path: edge.properties.resolved_path,
|
||||
resolution_status: edge.properties.resolution_status,
|
||||
available: observation?.properties.available,
|
||||
},
|
||||
];
|
||||
}),
|
||||
@@ -160,15 +174,19 @@ it("associates each source-map URL with its edge when aliases share one physical
|
||||
"dist/one.js": {
|
||||
declared_url: "app.js.map",
|
||||
resolved_path: "dist/app.js.map",
|
||||
resolution_status: "resolved",
|
||||
available: true,
|
||||
},
|
||||
"dist/two.js": {
|
||||
declared_url: "./app.js.map",
|
||||
resolved_path: "dist/app.js.map",
|
||||
resolution_status: "resolved",
|
||||
available: true,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it("resolves a bare source-map file name and module worker URL next to the script", async () => {
|
||||
it("resolves a module worker relative to its script while keeping the document base unknown", async () => {
|
||||
const root = await createTestTempDirectory("rea-source-map-relative-");
|
||||
await mkdir(join(root, "dist"));
|
||||
await writeFile(
|
||||
@@ -176,7 +194,6 @@ it("resolves a bare source-map file name and module worker URL next to the scrip
|
||||
[
|
||||
'new Worker(new URL("worker.js", import.meta.url));',
|
||||
'navigator.serviceWorker.register("sw.js");',
|
||||
"//# sourceMappingURL=app.js.map",
|
||||
].join("\n"),
|
||||
);
|
||||
await writeFile(
|
||||
@@ -184,43 +201,8 @@ it("resolves a bare source-map file name and module worker URL next to the scrip
|
||||
"self.onmessage = () => {};",
|
||||
);
|
||||
await writeFile(join(root, "dist", "sw.js"), "self.onfetch = () => {};");
|
||||
await writeFile(
|
||||
join(root, "dist", "app.js.map"),
|
||||
JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["../src/app.js"],
|
||||
sourcesContent: ['new Worker("worker.js");'],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
}),
|
||||
);
|
||||
const result = await reconstructJavaScriptArtifact({ input_path: root });
|
||||
const nodes = new Map(result.graph.nodes.map((node) => [node.node_id, node]));
|
||||
const mapEdge = result.graph.edges.find(
|
||||
({ relation, target_node_id }) =>
|
||||
relation === "maps_to" &&
|
||||
nodes.get(target_node_id)?.kind === "source-map",
|
||||
);
|
||||
expect(mapEdge?.properties).toEqual({
|
||||
declared_url_sha256: createHash("sha256")
|
||||
.update("app.js.map")
|
||||
.digest("hex"),
|
||||
resolved_path: "dist/app.js.map",
|
||||
resolution_status: "resolved",
|
||||
});
|
||||
expect(
|
||||
nodes
|
||||
.get(mapEdge?.target_node_id ?? "")
|
||||
?.observations.some(
|
||||
({ properties }) =>
|
||||
properties.declared_url === "app.js.map" &&
|
||||
properties.resolved_path === "dist/app.js.map" &&
|
||||
properties.available === true,
|
||||
),
|
||||
).toBe(true);
|
||||
expect(nodes.get(mapEdge?.target_node_id ?? "")?.identity.strategy).toBe(
|
||||
"content-digest",
|
||||
);
|
||||
const workerEdge = result.graph.edges.find(
|
||||
({ relation, source_node_id }) =>
|
||||
relation === "maps_to" && nodes.get(source_node_id)?.kind === "worker",
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { access } from "node:fs/promises";
|
||||
import { expect, it, vi } from "vitest";
|
||||
import { AnalysisInputError } from "../../../src/domain/analysisErrorCore.js";
|
||||
import { PrivateRuntimeRootUnavailableError } from "../../../src/domain/privateRuntimeRootUnavailableError.js";
|
||||
import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.js";
|
||||
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
||||
import { webSourceMapReportSchema } from "../../../src/domain/webSourceLocation.js";
|
||||
import { SourceMapDecoder } from "../../../src/javascript/sourceMaps/SourceMapDecoder.js";
|
||||
import type { SourceMapDecoderDependencies } from "../../../src/javascript/sourceMaps/SourceMapCommand.js";
|
||||
import { PrivateRuntimeRoot } from "../../../src/process/PrivateRuntimeRoot.js";
|
||||
@@ -49,32 +50,151 @@ const input = {
|
||||
position: webSourceLocationArgs.generated_position,
|
||||
};
|
||||
|
||||
it("starts the codec deadline after cold ownership preparation", async () => {
|
||||
vi.useFakeTimers();
|
||||
try {
|
||||
let prepared = false;
|
||||
const responsePromise = realDecoder({
|
||||
prepareOwnership: async (signal) => {
|
||||
await vi.advanceTimersByTimeAsync(20_001);
|
||||
expect(signal?.aborted).not.toBe(true);
|
||||
prepared = true;
|
||||
},
|
||||
launcher: (options) => {
|
||||
expect(prepared).toBe(true);
|
||||
expect(options.signal?.aborted).not.toBe(true);
|
||||
return Promise.reject(new Error("observed launch after preparation"));
|
||||
},
|
||||
}).trace(input);
|
||||
const response = await responsePromise;
|
||||
if (response.ok) throw new Error("expected launch failure");
|
||||
expect(response.error).toMatchObject({
|
||||
diagnostics: { error_message: "observed launch after preparation" },
|
||||
it.each([
|
||||
{ name: "null", reason: null },
|
||||
{
|
||||
name: "an opaque cleanup error",
|
||||
reason: new ProviderCleanupError("caller", ["caller-owned-resource"], {}),
|
||||
},
|
||||
])(
|
||||
"preserves cancellation during ownership preparation with $name",
|
||||
async ({ reason }) => {
|
||||
const controller = new AbortController();
|
||||
const createRuntime = vi.fn(async () => {
|
||||
throw new Error("Cancelled preparation must not acquire a runtime");
|
||||
});
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
const launcher = vi.fn(async () => {
|
||||
throw new Error("Cancelled preparation must not launch a codec");
|
||||
});
|
||||
const decoder = realDecoder({
|
||||
prepareOwnership: async (signal) => {
|
||||
controller.abort(reason);
|
||||
signal?.throwIfAborted();
|
||||
},
|
||||
createRuntime,
|
||||
launcher,
|
||||
});
|
||||
const result = await decoder.trace(input, { signal: controller.signal });
|
||||
if (result.ok) throw new Error("Expected preparation cancellation");
|
||||
expect(result.error).toMatchObject({
|
||||
_tag: "AnalysisCancelledError",
|
||||
cleanupIncomplete: false,
|
||||
cleanupResources: [],
|
||||
});
|
||||
expect(result.error.cause).toBe(reason);
|
||||
await decoder.close();
|
||||
if (reason instanceof ProviderCleanupError) {
|
||||
expect(reason.cleanupIncomplete).toBe(true);
|
||||
expect(reason.cleanupResources).toEqual(["caller-owned-resource"]);
|
||||
}
|
||||
expect(createRuntime).not.toHaveBeenCalled();
|
||||
expect(launcher).not.toHaveBeenCalled();
|
||||
},
|
||||
);
|
||||
|
||||
it("retains diagnostics for an unknown ownership preparation failure", async () => {
|
||||
const cause = new Error("unexpected ownership failure");
|
||||
const createRuntime = vi.fn(async () => {
|
||||
throw new Error("Failed preparation must not acquire a runtime");
|
||||
});
|
||||
const decoder = realDecoder({
|
||||
prepareOwnership: async () => {
|
||||
throw cause;
|
||||
},
|
||||
createRuntime,
|
||||
});
|
||||
const result = await decoder.trace(input);
|
||||
if (result.ok) throw new Error("Expected preparation failure");
|
||||
expect(result.error).toMatchObject({
|
||||
_tag: "ProviderAdapterError",
|
||||
cleanupIncomplete: false,
|
||||
diagnostics: {
|
||||
map_path: input.path,
|
||||
error_message: cause.message,
|
||||
phase: "process_ownership_preparation",
|
||||
},
|
||||
});
|
||||
expect(result.error.cause).toBe(cause);
|
||||
expect(createRuntime).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it.each([
|
||||
{ retryable: true, category: "unavailable" },
|
||||
{ retryable: false, category: "unsupported_provider" },
|
||||
])(
|
||||
"preserves private-runtime rejection as $category",
|
||||
async ({ retryable, category }) => {
|
||||
const reason = "Native runtime self-test failed with a sharing violation";
|
||||
const launcher = vi.fn(async () => {
|
||||
throw new Error("A refused runtime must not launch a codec");
|
||||
});
|
||||
const decoder = realDecoder({
|
||||
prepareOwnership: async () => {},
|
||||
createRuntime: async () => {
|
||||
throw new PrivateRuntimeRootUnavailableError(reason, { retryable });
|
||||
},
|
||||
launcher,
|
||||
});
|
||||
const result = await decoder.trace(input);
|
||||
if (result.ok) throw new Error("Expected runtime refusal");
|
||||
expect(projectAnalysisError(result.error)).toMatchObject({
|
||||
code: "capability_unavailable",
|
||||
category,
|
||||
retryable,
|
||||
details: {
|
||||
provider_id: "source-map-decoder",
|
||||
operation: "trace_web_source_location",
|
||||
reason,
|
||||
},
|
||||
});
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
expect(launcher).not.toHaveBeenCalled();
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
{ name: "default", selected: undefined, expectedMs: 20_000 },
|
||||
{ name: "selected", selected: 250, expectedMs: 250 },
|
||||
])(
|
||||
"starts the $name codec deadline after ownership preparation",
|
||||
async ({ selected, expectedMs }) => {
|
||||
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "performance"] });
|
||||
let path: string | undefined;
|
||||
try {
|
||||
const response = await realDecoder({
|
||||
prepareOwnership: async () => {
|
||||
await vi.advanceTimersByTimeAsync(20_001);
|
||||
},
|
||||
createRuntime: async () => {
|
||||
const root = await PrivateRuntimeRoot.create();
|
||||
path = root.path;
|
||||
return root;
|
||||
},
|
||||
launcher: async ({ signal }) => {
|
||||
await vi.advanceTimersByTimeAsync(expectedMs - 1);
|
||||
expect(signal?.aborted).toBe(false);
|
||||
await vi.advanceTimersByTimeAsync(1);
|
||||
expect(signal?.aborted).toBe(true);
|
||||
throw new Error("launcher settled after deadline");
|
||||
},
|
||||
}).trace({
|
||||
...input,
|
||||
...(selected === undefined ? {} : { decodeTimeoutMs: selected }),
|
||||
});
|
||||
if (response.ok) throw new Error("expected decode deadline");
|
||||
expect(response.error).toMatchObject({
|
||||
_tag: "AnalysisTimeoutError",
|
||||
userMessage: expect.stringContaining(String(expectedMs)),
|
||||
});
|
||||
expect(response.error.userMessage).toContain("decode_timeout_ms");
|
||||
if (path === undefined) throw new Error("runtime not acquired");
|
||||
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
{ heap: undefined, effectiveHeap: 192 },
|
||||
{ heap: 384, effectiveHeap: 384 },
|
||||
@@ -101,7 +221,10 @@ it.each([
|
||||
if (!response.ok) throw response.error;
|
||||
expect(response.value).toMatchObject({
|
||||
engine: { id: "jridgewell-trace-mapping", version: "0.3.31" },
|
||||
matches: [{ content: { text: "original" } }],
|
||||
source_map_sha256: fixture.sourceMap.file.sha256,
|
||||
url_context: input.url,
|
||||
lookup: { requested: input.position },
|
||||
matches: [{ state: "mapped", content: { text: "original" } }],
|
||||
});
|
||||
if (process.versions.bun === undefined) {
|
||||
expect(response.value.runtime).toMatchObject({
|
||||
@@ -135,7 +258,6 @@ it.each([
|
||||
);
|
||||
|
||||
it.each([
|
||||
{ cancel: false, denyCleanup: false },
|
||||
{ cancel: true, denyCleanup: false },
|
||||
{ cancel: false, denyCleanup: true },
|
||||
{ cancel: true, denyCleanup: true },
|
||||
@@ -145,7 +267,7 @@ it.each([
|
||||
const controller = new AbortController();
|
||||
const reason = { phase: "source-map root finalization" };
|
||||
let path: string | undefined;
|
||||
let cleanupAttempts = 0;
|
||||
let denyNextClose = denyCleanup;
|
||||
const decoder = realDecoder({
|
||||
createRuntime: async () => {
|
||||
const root = await PrivateRuntimeRoot.create();
|
||||
@@ -153,10 +275,11 @@ it.each([
|
||||
return {
|
||||
path: root.path,
|
||||
close: async () => {
|
||||
cleanupAttempts += 1;
|
||||
if (cancel) controller.abort(reason);
|
||||
if (denyCleanup && cleanupAttempts === 1)
|
||||
if (denyNextClose) {
|
||||
denyNextClose = false;
|
||||
throw new Error("controlled source-map cleanup denial");
|
||||
}
|
||||
await root.close();
|
||||
},
|
||||
};
|
||||
@@ -166,39 +289,33 @@ it.each([
|
||||
const response = await decoder.trace(input, {
|
||||
signal: controller.signal,
|
||||
});
|
||||
expect(response.ok).toBe(!cancel && !denyCleanup);
|
||||
const report = webSourceMapReportSchema.parse(
|
||||
response.ok ? response.value : response.error.partialObservation,
|
||||
);
|
||||
if (response.ok) throw new Error("Expected interrupted finalization");
|
||||
const { error } = response;
|
||||
const report = error.partialObservation;
|
||||
expect(report).toMatchObject({
|
||||
source_map_sha256: fixture.sourceMap.file.sha256,
|
||||
url_context: input.url,
|
||||
lookup: { requested: input.position },
|
||||
matches: [{ state: "mapped", content: { text: "original" } }],
|
||||
});
|
||||
expect(error).toMatchObject({ operation: "trace_web_source_location" });
|
||||
expect(projectAnalysisError(error)).toMatchObject({
|
||||
details: { partial_observation: report },
|
||||
});
|
||||
if (cancel) {
|
||||
const primary = error.cleanupPrimary ?? error;
|
||||
expect(primary._tag).toBe("AnalysisCancelledError");
|
||||
expect(primary.cause).toBe(reason);
|
||||
}
|
||||
if (path === undefined) throw new Error("runtime not acquired");
|
||||
if (!response.ok) {
|
||||
expect(response.error).toMatchObject({
|
||||
operation: "trace_web_source_location",
|
||||
});
|
||||
expect(projectAnalysisError(response.error)).toMatchObject({
|
||||
details: { partial_observation: report },
|
||||
});
|
||||
if (cancel) {
|
||||
const primary = response.error.cleanupPrimary ?? response.error;
|
||||
expect(primary._tag).toBe("AnalysisCancelledError");
|
||||
expect(primary.cause).toBe(reason);
|
||||
}
|
||||
expect(response.error.cleanupIncomplete).toBe(denyCleanup);
|
||||
if (denyCleanup) {
|
||||
expect(response.error.cleanupResources).toEqual([path]);
|
||||
await expect(access(path)).resolves.toBeUndefined();
|
||||
await decoder.close();
|
||||
expect(cleanupAttempts).toBe(2);
|
||||
expect(response.error.cleanupIncomplete).toBe(false);
|
||||
expect(response.error.cleanupResources).toEqual([]);
|
||||
expect(response.error.partialObservation).toEqual(report);
|
||||
}
|
||||
expect(error.cleanupIncomplete).toBe(denyCleanup);
|
||||
if (denyCleanup) {
|
||||
expect(error.cleanupResources).toEqual([path]);
|
||||
await expect(access(path)).resolves.toBeUndefined();
|
||||
await decoder.close();
|
||||
expect(error.cleanupIncomplete).toBe(false);
|
||||
expect(error.cleanupResources).toEqual([]);
|
||||
expect(error.partialObservation).toEqual(report);
|
||||
}
|
||||
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
} finally {
|
||||
@@ -212,17 +329,20 @@ it.each([false, true])(
|
||||
async (denyCleanup) => {
|
||||
const controller = new AbortController();
|
||||
const reason = new Error("cancel after codec refusal");
|
||||
let cleanupAttempts = 0;
|
||||
let path: string | undefined;
|
||||
let denyNextClose = denyCleanup;
|
||||
const decoder = realDecoder({
|
||||
createRuntime: async () => {
|
||||
const root = await PrivateRuntimeRoot.create();
|
||||
path = root.path;
|
||||
return {
|
||||
path: root.path,
|
||||
close: async () => {
|
||||
cleanupAttempts += 1;
|
||||
controller.abort(reason);
|
||||
if (denyCleanup && cleanupAttempts === 1)
|
||||
if (denyNextClose) {
|
||||
denyNextClose = false;
|
||||
throw new Error("controlled refusal cleanup denial");
|
||||
}
|
||||
await root.close();
|
||||
},
|
||||
};
|
||||
@@ -234,15 +354,28 @@ it.each([false, true])(
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
if (response.ok) throw new Error("Expected malformed-map refusal");
|
||||
expect(controller.signal.reason).toBe(reason);
|
||||
expect(response.error.cleanupPrimary ?? response.error).toBeInstanceOf(
|
||||
AnalysisInputError,
|
||||
const { error } = response;
|
||||
const primary = error.cleanupPrimary ?? error;
|
||||
expect(primary).toMatchObject({
|
||||
_tag: "AnalysisInputError",
|
||||
operation: "trace_web_source_location",
|
||||
issues: [{ reason: "invalid_format" }],
|
||||
});
|
||||
const cancellation = primary.secondaryFailures.find(
|
||||
({ _tag }) => _tag === "AnalysisCancelledError",
|
||||
);
|
||||
expect(response.error.partialObservation).toBeUndefined();
|
||||
expect(response.error.cleanupIncomplete).toBe(denyCleanup);
|
||||
await decoder.close();
|
||||
expect(response.error.cleanupIncomplete).toBe(false);
|
||||
expect(cleanupAttempts).toBe(denyCleanup ? 2 : 1);
|
||||
expect(cancellation?.cause).toBe(reason);
|
||||
expect(error.partialObservation).toBeUndefined();
|
||||
if (path === undefined) throw new Error("runtime not acquired");
|
||||
expect(error.cleanupIncomplete).toBe(denyCleanup);
|
||||
if (denyCleanup) {
|
||||
expect(error.cleanupResources).toEqual([path]);
|
||||
await expect(access(path)).resolves.toBeUndefined();
|
||||
await decoder.close();
|
||||
expect(error.cleanupIncomplete).toBe(false);
|
||||
expect(error.cleanupResources).toEqual([]);
|
||||
}
|
||||
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
} finally {
|
||||
await decoder.close();
|
||||
}
|
||||
@@ -250,14 +383,6 @@ it.each([false, true])(
|
||||
);
|
||||
|
||||
it.each([
|
||||
{
|
||||
failure: "malformed JSON",
|
||||
text: "{",
|
||||
error: {
|
||||
_tag: "AnalysisInputError",
|
||||
issues: [{ reason: "invalid_format" }],
|
||||
},
|
||||
},
|
||||
{
|
||||
failure: "external section",
|
||||
text: JSON.stringify({
|
||||
@@ -279,7 +404,12 @@ it.each([
|
||||
failure: "malformed embedded map before row admission",
|
||||
text: JSON.stringify({
|
||||
version: 3,
|
||||
sections: [{ offset: { line: 1000000000, column: 0 }, map: {} }],
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 1000000000, column: 0 },
|
||||
map: { version: "3", sections: [] },
|
||||
},
|
||||
],
|
||||
}),
|
||||
error: {
|
||||
_tag: "AnalysisInputError",
|
||||
@@ -308,6 +438,49 @@ it.each([
|
||||
detail: expect.stringContaining("generated-row decoder budget"),
|
||||
},
|
||||
},
|
||||
{
|
||||
failure: "invalid section list with regular-map fields",
|
||||
text: JSON.stringify({
|
||||
version: 3,
|
||||
sections: null,
|
||||
sources: ["ignored.ts"],
|
||||
mappings: "AAAA",
|
||||
}),
|
||||
error: {
|
||||
_tag: "AnalysisInputError",
|
||||
issues: [
|
||||
{
|
||||
reason: "invalid_format",
|
||||
message: expect.stringContaining("sections"),
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
{
|
||||
failure: "overlapping indexed mappings",
|
||||
text: JSON.stringify({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: { version: 3, sources: ["a.js"], mappings: "AAAA,EAAA" },
|
||||
},
|
||||
{
|
||||
offset: { line: 0, column: 1 },
|
||||
map: { version: 3, sources: ["b.js"], mappings: "AAAA" },
|
||||
},
|
||||
],
|
||||
}),
|
||||
error: {
|
||||
_tag: "AnalysisInputError",
|
||||
issues: [
|
||||
{
|
||||
reason: "invalid_format",
|
||||
message: expect.stringContaining("overlap"),
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
])("preserves actual producer failures: $failure", async ({ text, error }) => {
|
||||
const response = await realDecoder().trace({ ...input, text });
|
||||
if (response.ok) throw new Error("expected failed map");
|
||||
@@ -317,47 +490,8 @@ it.each([
|
||||
});
|
||||
});
|
||||
|
||||
it("keeps indexed section overlap typed as a malformed source map", async () => {
|
||||
const text = JSON.stringify({
|
||||
version: 3,
|
||||
sections: [
|
||||
{
|
||||
offset: { line: 0, column: 0 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["a.js"],
|
||||
sourcesContent: ["x();"],
|
||||
names: [],
|
||||
mappings: "AAAA,EAAA",
|
||||
},
|
||||
},
|
||||
{
|
||||
offset: { line: 0, column: 1 },
|
||||
map: {
|
||||
version: 3,
|
||||
sources: ["b.js"],
|
||||
sourcesContent: ["y();"],
|
||||
names: [],
|
||||
mappings: "AAAA",
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
const response = await realDecoder().trace({ ...input, text });
|
||||
if (response.ok) throw new Error("expected overlapping map rejection");
|
||||
expect(response.error).toBeInstanceOf(AnalysisInputError);
|
||||
if (!(response.error instanceof AnalysisInputError))
|
||||
throw new Error("expected malformed source-map input error");
|
||||
expect(response.error.issues).toEqual(
|
||||
expect.arrayContaining([
|
||||
expect.objectContaining({
|
||||
reason: "invalid_format",
|
||||
message: expect.stringContaining("overlap"),
|
||||
}),
|
||||
]),
|
||||
);
|
||||
});
|
||||
it("cancels a real owned process and removes the runtime request", async () => {
|
||||
const reason = { caller: "cancel active codec" };
|
||||
const controller = new AbortController();
|
||||
let path: string | undefined;
|
||||
const response = await realDecoder({
|
||||
@@ -375,46 +509,57 @@ it("cancels a real owned process and removes the runtime request", async () => {
|
||||
],
|
||||
});
|
||||
await waitForProviderProcessReady(child.process);
|
||||
setImmediate(() => controller.abort());
|
||||
setImmediate(() => controller.abort(reason));
|
||||
return child;
|
||||
},
|
||||
}).trace(input, { signal: controller.signal });
|
||||
if (response.ok) throw new Error("expected cancellation");
|
||||
expect(response.error._tag).toBe("AnalysisCancelledError");
|
||||
expect(response.error.cause).toBe(reason);
|
||||
if (path === undefined) throw new Error("runtime not acquired");
|
||||
await expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });
|
||||
});
|
||||
it("retains final diagnostic bytes for an actual failed codec process", async () => {
|
||||
const response = await realDecoder({
|
||||
launcher: (options) =>
|
||||
spawnOwnedProviderProcess({
|
||||
...options,
|
||||
arguments: [
|
||||
"-e",
|
||||
'process.stderr.write("final diagnostic"); process.exitCode = 7',
|
||||
],
|
||||
}),
|
||||
}).trace(input);
|
||||
if (response.ok) throw new Error("expected exit failure");
|
||||
expect(response.error).toMatchObject({
|
||||
diagnostics: { exit_code: 7, stderr: "final diagnostic" },
|
||||
});
|
||||
});
|
||||
it("reports complete evidence amplification as a resource failure before serializing an oversized reply", async () => {
|
||||
const text = JSON.stringify({
|
||||
it("returns all point matches when they fit and reports output exhaustion otherwise", async () => {
|
||||
const embedded = "a".repeat(1_800);
|
||||
const text = `\uFEFF)]}'transport prefix\r${JSON.stringify({
|
||||
version: 3,
|
||||
sources: ["large.ts"],
|
||||
sourcesContent: ["a".repeat(600000)],
|
||||
sources: ["original.ts"],
|
||||
sourcesContent: [embedded],
|
||||
names: [],
|
||||
mappings: Array.from({ length: 60 }, () => "AAAA").join(","),
|
||||
});
|
||||
const response = await realDecoder().trace({ ...input, text });
|
||||
if (response.ok) throw new Error("expected complete-evidence budget failure");
|
||||
expect(response.error).toMatchObject({
|
||||
mappings: "AAAA,AAAC,AAAC,AAAC",
|
||||
})}`;
|
||||
const trace = (outputBytes: number) =>
|
||||
realDecoder().trace({
|
||||
...input,
|
||||
text,
|
||||
limits: { output_bytes: outputBytes },
|
||||
});
|
||||
|
||||
const complete = await trace(14_000);
|
||||
if (!complete.ok) throw complete.error;
|
||||
expect(complete.value.source_map_sha256).toBe(
|
||||
createHash("sha256").update(text).digest("hex"),
|
||||
);
|
||||
expect(complete.value.matches).toMatchObject(
|
||||
[0, 1, 2, 3].map((column) => ({
|
||||
reported_source: "original.ts",
|
||||
original_position: { line: 1, column },
|
||||
content: { state: "embedded", text: embedded },
|
||||
})),
|
||||
);
|
||||
|
||||
const budget = 5_500;
|
||||
expect(Buffer.byteLength(JSON.stringify(complete.value))).toBeGreaterThan(
|
||||
budget,
|
||||
);
|
||||
const limited = await trace(budget);
|
||||
if (limited.ok) throw new Error("expected complete-evidence budget failure");
|
||||
expect(limited.error).toMatchObject({
|
||||
_tag: "ArtifactOperationError",
|
||||
reason: "limit",
|
||||
detail: expect.stringContaining("no partial"),
|
||||
detail: expect.stringContaining("source_map_limits.output_bytes is 5500"),
|
||||
});
|
||||
expect(limited.error.partialObservation).toBeUndefined();
|
||||
});
|
||||
it("rejects a malformed actual subprocess reply", async () => {
|
||||
const response = await realDecoder({
|
||||
|
||||
@@ -1,88 +0,0 @@
|
||||
import { expect, it, vi } from "vitest";
|
||||
import { AnalysisCancelledError } from "../../../src/domain/analysisErrorCore.js";
|
||||
import { ProviderAdapterError } from "../../../src/domain/providerAdapterError.js";
|
||||
import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.js";
|
||||
import {
|
||||
runSourceMapCommand,
|
||||
type SourceMapCleanupRetention,
|
||||
} from "../../../src/javascript/sourceMaps/SourceMapCommand.js";
|
||||
|
||||
it.each([
|
||||
null,
|
||||
new ProviderCleanupError("caller", ["caller-owned-resource"], {}),
|
||||
])(
|
||||
"preserves opaque cancellation during ownership preparation: %s",
|
||||
async (reason) => {
|
||||
const controller = new AbortController();
|
||||
const retainedCleanup: SourceMapCleanupRetention = {};
|
||||
const createRuntime = vi.fn(async () => {
|
||||
throw new Error("Cancelled preparation must not acquire a runtime");
|
||||
});
|
||||
const launcher = vi.fn(async () => {
|
||||
throw new Error("Cancelled preparation must not launch a codec");
|
||||
});
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/selected.map",
|
||||
{ signal: controller.signal },
|
||||
{
|
||||
prepareOwnership: async (signal) => {
|
||||
controller.abort(reason);
|
||||
signal?.throwIfAborted();
|
||||
},
|
||||
createRuntime,
|
||||
launcher,
|
||||
},
|
||||
retainedCleanup,
|
||||
);
|
||||
expect(retainedCleanup.owner).toBeUndefined();
|
||||
if (result.ok) throw new Error("Preparation must return cancellation");
|
||||
expect(result.error).toBeInstanceOf(AnalysisCancelledError);
|
||||
expect(result.error.cause).toBe(reason);
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
expect(result.error.cleanupResources).toEqual([]);
|
||||
if (reason instanceof ProviderCleanupError) {
|
||||
expect(reason.cleanupIncomplete).toBe(true);
|
||||
expect(reason.cleanupResources).toEqual(["caller-owned-resource"]);
|
||||
}
|
||||
expect(createRuntime).not.toHaveBeenCalled();
|
||||
expect(launcher).not.toHaveBeenCalled();
|
||||
},
|
||||
);
|
||||
|
||||
it("retains diagnostics for an unknown ownership preparation failure", async () => {
|
||||
const cause = new Error("unexpected ownership failure");
|
||||
const retainedCleanup: SourceMapCleanupRetention = {};
|
||||
const createRuntime = vi.fn(async () => {
|
||||
throw new Error("Failed preparation must not acquire a runtime");
|
||||
});
|
||||
const launcher = vi.fn(async () => {
|
||||
throw new Error("Failed preparation must not launch a codec");
|
||||
});
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/selected.map",
|
||||
undefined,
|
||||
{
|
||||
prepareOwnership: async () => {
|
||||
throw cause;
|
||||
},
|
||||
createRuntime,
|
||||
launcher,
|
||||
},
|
||||
retainedCleanup,
|
||||
);
|
||||
expect(retainedCleanup.owner).toBeUndefined();
|
||||
if (result.ok) throw new Error("Preparation must return its failure");
|
||||
expect(result.error).toBeInstanceOf(ProviderAdapterError);
|
||||
expect(result.error.cause).toBe(cause);
|
||||
expect(result.error).toMatchObject({
|
||||
diagnostics: {
|
||||
map_path: "/selected.map",
|
||||
error_message: cause.message,
|
||||
phase: "process_ownership_preparation",
|
||||
},
|
||||
});
|
||||
expect(createRuntime).not.toHaveBeenCalled();
|
||||
expect(launcher).not.toHaveBeenCalled();
|
||||
});
|
||||
@@ -1,46 +0,0 @@
|
||||
import { expect, it } from "vitest";
|
||||
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
||||
import {
|
||||
runSourceMapCommand,
|
||||
type SourceMapCleanupRetention,
|
||||
} from "../../../src/javascript/sourceMaps/SourceMapCommand.js";
|
||||
import { PrivateRuntimeRootUnavailableError } from "../../../src/domain/privateRuntimeRootUnavailableError.js";
|
||||
|
||||
it.each([false, true])(
|
||||
"preserves private-runtime retryable=%s through the source-map operation",
|
||||
async (retryable) => {
|
||||
const reason = "Native runtime self-test failed with a sharing violation";
|
||||
let launches = 0;
|
||||
const retainedCleanup: SourceMapCleanupRetention = {};
|
||||
const result = await runSourceMapCommand(
|
||||
"{}",
|
||||
"/selected.map",
|
||||
undefined,
|
||||
{
|
||||
prepareOwnership: async () => {},
|
||||
createRuntime: async () => {
|
||||
throw new PrivateRuntimeRootUnavailableError(reason, { retryable });
|
||||
},
|
||||
launcher: async () => {
|
||||
launches += 1;
|
||||
throw new Error("A refused runtime must not launch a codec");
|
||||
},
|
||||
},
|
||||
retainedCleanup,
|
||||
);
|
||||
expect(retainedCleanup.owner).toBeUndefined();
|
||||
expect(launches).toBe(0);
|
||||
if (result.ok) throw new Error("Unavailable runtime must refuse decoding");
|
||||
expect(projectAnalysisError(result.error)).toMatchObject({
|
||||
code: "capability_unavailable",
|
||||
category: retryable ? "unavailable" : "unsupported_provider",
|
||||
retryable,
|
||||
details: {
|
||||
provider_id: "source-map-decoder",
|
||||
operation: "trace_web_source_location",
|
||||
reason,
|
||||
},
|
||||
});
|
||||
expect(result.error.cleanupIncomplete).toBe(false);
|
||||
},
|
||||
);
|
||||
@@ -1,21 +1,14 @@
|
||||
import { createHash } from "node:crypto";
|
||||
|
||||
import type { CallToolResult } from "@modelcontextprotocol/server";
|
||||
import { expect, it, onTestFinished, vi } from "vitest";
|
||||
import { z } from "zod";
|
||||
import { expect, it, onTestFinished } from "vitest";
|
||||
|
||||
import { CdpBrowserProvider } from "../../../src/browser/CdpBrowserProvider.js";
|
||||
import { toolContract } from "../../../src/contracts/toolContracts.js";
|
||||
import { parseEvidence } from "../../../src/domain/evidence.js";
|
||||
import { webBundleAcquisitionPartialObservationSchema } from "../../../src/domain/webBundleAnalysis.js";
|
||||
import { ToolResultDelivery } from "../../../src/server/ToolResultDelivery.js";
|
||||
import { startSourceMapCancellationBrowser } from "../../fixtures/browserSourceMapCancellation.js";
|
||||
import { createDeferred } from "../../fixtures/binarySession.js";
|
||||
import {
|
||||
createApplicationMcpHarness,
|
||||
type ApplicationMcpHarness,
|
||||
} from "../../fixtures/applicationMcpHarness.js";
|
||||
import { parseMcpToolError } from "../../fixtures/mcpToolError.js";
|
||||
import { waitFor } from "../../support/testWait.js";
|
||||
|
||||
it("retains completed source maps through MCP cancellation for later Evidence retrieval", async () => {
|
||||
const {
|
||||
@@ -30,7 +23,6 @@ it("retains completed source maps through MCP cancellation for later Evidence re
|
||||
let harness: ApplicationMcpHarness | undefined;
|
||||
onTestFinished(async () => {
|
||||
controller.abort();
|
||||
vi.restoreAllMocks();
|
||||
releasePendingResponse();
|
||||
try {
|
||||
await harness?.close();
|
||||
@@ -43,16 +35,6 @@ it("retains completed source maps through MCP cancellation for later Evidence re
|
||||
});
|
||||
harness = connected;
|
||||
|
||||
const delivered = createDeferred<CallToolResult>();
|
||||
const original = ToolResultDelivery.prototype.toPartialErrorToolResult;
|
||||
vi.spyOn(
|
||||
ToolResultDelivery.prototype,
|
||||
"toPartialErrorToolResult",
|
||||
).mockImplementation(function (this: ToolResultDelivery, ...args) {
|
||||
const result = original.apply(this, args);
|
||||
delivered.resolve(result);
|
||||
return result;
|
||||
});
|
||||
const call = connected.client.callTool(
|
||||
{
|
||||
name: "analyze_web_bundle",
|
||||
@@ -66,7 +48,7 @@ it("retains completed source maps through MCP cancellation for later Evidence re
|
||||
},
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
const pendingMapPath = await Promise.race([
|
||||
await Promise.race([
|
||||
secondRequest,
|
||||
call.then(
|
||||
() => {
|
||||
@@ -78,39 +60,29 @@ it("retains completed source maps through MCP cancellation for later Evidence re
|
||||
),
|
||||
]);
|
||||
const retainedMapPath = await completedMapPath;
|
||||
expect([retainedMapPath, pendingMapPath].sort()).toEqual([
|
||||
"/first.js.map",
|
||||
"/second.js.map",
|
||||
]);
|
||||
controller.abort(new Error("Caller cancelled after the first map"));
|
||||
await expect(call).rejects.toThrow();
|
||||
|
||||
// SDK cancellation suppresses the reply. This is the server's recording boundary.
|
||||
const { error } = parseMcpToolError(await delivered.promise);
|
||||
expect(error.code).toBe("cancelled");
|
||||
const reference = z
|
||||
.object({
|
||||
partial_observation: z.object({
|
||||
kind: z.literal("retained-evidence"),
|
||||
evidence_id: z.string(),
|
||||
}),
|
||||
})
|
||||
.parse(error.details).partial_observation;
|
||||
const reply = await connected.client.callTool({
|
||||
name: "get_evidence_bundle",
|
||||
arguments: { detail: "complete" },
|
||||
// The SDK suppresses the cancelled reply. Wait for the public Evidence bundle
|
||||
// to publish the acquisition after cleanup.
|
||||
const evidence = await waitFor(async () => {
|
||||
const reply = await connected.client.callTool({
|
||||
name: "get_evidence_bundle",
|
||||
arguments: { detail: "complete" },
|
||||
});
|
||||
expect(reply.isError, JSON.stringify(reply.content)).not.toBe(true);
|
||||
const bundle = toolContract("get_evidence_bundle").outputSchema.parse(
|
||||
reply.structuredContent,
|
||||
).result;
|
||||
if ("kind" in bundle) throw new Error("Expected complete Evidence bundle");
|
||||
const records = bundle.records.filter(
|
||||
({ operation }) => operation === "analyze_web_bundle",
|
||||
);
|
||||
expect(records).toHaveLength(1);
|
||||
const record = records[0];
|
||||
if (record === undefined) throw new Error("Expected retained acquisition");
|
||||
return record;
|
||||
});
|
||||
expect(reply.isError, JSON.stringify(reply.content)).not.toBe(true);
|
||||
const bundle = toolContract("get_evidence_bundle").outputSchema.parse(
|
||||
reply.structuredContent,
|
||||
).result;
|
||||
if ("kind" in bundle) throw new Error("Expected complete Evidence bundle");
|
||||
const evidence = parseEvidence(
|
||||
bundle.records.find(
|
||||
(record) => record.evidence_id === reference.evidence_id,
|
||||
),
|
||||
);
|
||||
expect(evidence.operation).toBe("analyze_web_bundle");
|
||||
const acquisition = webBundleAcquisitionPartialObservationSchema.parse(
|
||||
evidence.normalized_result,
|
||||
);
|
||||
@@ -119,32 +91,15 @@ it("retains completed source maps through MCP cancellation for later Evidence re
|
||||
status: "partial",
|
||||
requested: 2,
|
||||
processed: 1,
|
||||
excluded: [
|
||||
{ section: "source_maps", reason: "disallowed_origin", count: 1 },
|
||||
],
|
||||
items: [
|
||||
{
|
||||
status: "included",
|
||||
declared_url: `${browser.allowedOrigin}${retainedMapPath}`,
|
||||
artifact: {
|
||||
text: mapText,
|
||||
sha256: createHash("sha256").update(mapText).digest("hex"),
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
expect(acquisition.source_maps.items).toHaveLength(1);
|
||||
expect(acquisition.inspection.completeness.excluded).toContainEqual({
|
||||
section: "source_maps",
|
||||
reason: "disallowed_origin",
|
||||
count: 1,
|
||||
});
|
||||
expect(JSON.stringify(evidence)).not.toContain("outside.example.test");
|
||||
await expect(connected.client.ping()).resolves.toEqual({});
|
||||
expect(browser.activeConnectionCount()).toBe(0);
|
||||
expect(
|
||||
browser.httpRequests
|
||||
.filter(({ url }) => url.endsWith(".map"))
|
||||
.map(({ url }) => url),
|
||||
).toEqual([retainedMapPath, pendingMapPath]);
|
||||
});
|
||||
@@ -62,27 +62,36 @@ const cases = [
|
||||
},
|
||||
] as const;
|
||||
|
||||
processTest.for(cases)(
|
||||
"resolves $name in an owned subprocess without a native abort",
|
||||
async (scenario, { processes }) => {
|
||||
const sourceRoot = "root" in scenario ? scenario.root : null;
|
||||
// Import the built production helper in a child. A native assertion must
|
||||
// become a failed signal assertion here, never terminate the Vitest worker.
|
||||
processTest(
|
||||
"preserves UNC host resolution and source spelling in an owned subprocess",
|
||||
async ({ processes }) => {
|
||||
const inputs = cases.map((scenario) => ({
|
||||
name: scenario.name,
|
||||
source: scenario.source,
|
||||
root: "root" in scenario ? scenario.root : null,
|
||||
}));
|
||||
const result = await processes.run(process.execPath, [
|
||||
"--input-type=module",
|
||||
"--eval",
|
||||
`import { resolveJavaScriptSourceMapReferences } from "./dist/domain/javascript/javascriptSourceMapPaths.js";
|
||||
const [source, root] = JSON.parse(process.argv[1]);
|
||||
console.log(JSON.stringify(resolveJavaScriptSourceMapReferences([source], root, "maps/main.js.map")[0]));`,
|
||||
JSON.stringify([scenario.source, sourceRoot]),
|
||||
const inputs = JSON.parse(process.argv[1]);
|
||||
const references = inputs.map(({ name, source, root }) => {
|
||||
console.error("Resolving", name);
|
||||
return resolveJavaScriptSourceMapReferences([source], root, "maps/main.js.map")[0];
|
||||
});
|
||||
console.log(JSON.stringify(references));`,
|
||||
JSON.stringify(inputs),
|
||||
]);
|
||||
|
||||
expect(result.signal, result.stderr).toBeNull();
|
||||
expect(result.exitCode, result.stderr).toBe(0);
|
||||
expect(JSON.parse(result.stdout)).toMatchObject({
|
||||
source_name: scenario.source,
|
||||
source_root: sourceRoot,
|
||||
map_path: "maps/main.js.map",
|
||||
resolution: scenario.expected,
|
||||
});
|
||||
expect(JSON.parse(result.stdout)).toMatchObject(
|
||||
cases.map((scenario) => ({
|
||||
source_name: scenario.source,
|
||||
source_root: "root" in scenario ? scenario.root : null,
|
||||
map_path: "maps/main.js.map",
|
||||
resolution: scenario.expected,
|
||||
})),
|
||||
);
|
||||
},
|
||||
);
|
||||
Reference in new issue
Block a user