Files
reverse-engineering-anything/tests/boundary/browser/webSourceMapFetcher.test.ts
T

1974 lines
60 KiB
TypeScript

import { createHash } from "node:crypto";
import { createServer } from "node:http";
import { describe, expect, it } from "vitest";
import { phaseArrival } from "../../support/lifecycleHarness.js";
import { withVerifierCleanup } from "../../../scripts/lib/verifier-cleanup.mjs";
import { fetchWebSourceMaps } from "../../../src/browser/WebSourceMapFetcher.js";
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
import { AnalysisCancelledError } from "../../../src/domain/analysisErrorCore.js";
import {
analyzeWebBundleInputSchema,
webSourceMapsSchema,
type WebSourceMaps,
} from "../../../src/domain/webBundleAnalysis.js";
const origin = "https://app.example.test";
const request = {
scriptKey: `scr_${"1".repeat(64)}`,
declaredUrl: `${origin}/assets/app.js.map?token=secret&v=2#source-map`,
fetchUrl: `${origin}/assets/app.js.map?token=secret`,
};
const expectInvalidSourceMaps = (value: unknown): void => {
expect(webSourceMapsSchema.safeParse(value).success).toBe(false);
};
const expectInvalidIncludedSourceMaps = (result: WebSourceMaps): void => {
expectInvalidSourceMaps({
...result,
items: [{ ...result.items[0], artifact: null }],
});
expectInvalidSourceMaps({ ...result, status: "unavailable" });
};
it.each(["regular", "indexed"])(
"retains declaration identity for duplicate source URLs in HTTP %s maps",
async (format) => {
const contents = [
null,
'import "./shared.js"; import "./shared.js"; import "./first.js";',
'import "./shared.js"; import "./second.js";',
];
const leaf = (sourcesContent: (string | null)[]) => ({
version: 3,
sources: sourcesContent.map(() => "same.ts"),
sourcesContent,
names: [],
mappings: "",
});
const map =
format === "regular"
? leaf(contents)
: {
version: 3,
sections: contents.map((content, line) => ({
offset: { line, column: 0 },
map: leaf([content]),
})),
};
const server = createServer((_incoming, response) => {
response.setHeader("content-type", "application/source-map+json");
response.end(JSON.stringify(map));
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const url = `${localOrigin}/app.js.map`;
const result = await fetchWebSourceMapsOk(
[{ ...request, fetchUrl: url, declaredUrl: url }],
input({ allowed_origins: [localOrigin] }),
);
const item = result.items[0];
if (item?.status !== "included") throw new Error("map not included");
expect(item.limitation).toBeNull();
expect(
item.original_sources.map((source) => ({
declaration_index: source.declaration_index,
source_index: source.source_index,
source: source.source,
text: source.artifact?.text ?? null,
})),
).toEqual(
contents.map((text, declaration_index) => ({
declaration_index,
source_index: format === "regular" ? declaration_index : 0,
source: `${localOrigin}/same.ts`,
text,
})),
);
expect(item.original_module_edges).toEqual(
[
[1, "./shared.js"],
[1, "./first.js"],
[2, "./shared.js"],
[2, "./second.js"],
].map(([declaration_index, specifier]) => ({
declaration_index,
from_source: `${localOrigin}/same.ts`,
kind: "static_import",
specifier,
resolved_source: new URL(String(specifier), url).href,
})),
);
expect(webSourceMapsSchema.parse(result)).toEqual(result);
expectInvalidSourceMaps({
...result,
items: [
{
...item,
original_module_edges: item.original_module_edges.map(
({ declaration_index: _index, ...edge }) => edge,
),
},
],
});
for (const omit of ["source_index", "declaration_index"] as const)
expectInvalidSourceMaps({
...result,
items: [
{
...item,
original_sources: item.original_sources.map((source) =>
Object.fromEntries(
Object.entries(source).filter(([key]) => key !== omit),
),
),
},
],
});
expectInvalidSourceMaps({
...result,
items: [
{
...item,
original_module_edges: [
{
...item.original_module_edges[0],
declaration_index: -1,
},
],
},
],
});
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
},
);
it.each(["regular", "indexed"])(
"collects an HTTP %s source map with omitted names without accepting invalid names",
async (format) => {
const leaf = {
version: 3,
sources: ["src/main.ts"],
sourcesContent: ["import './dependency.ts';"],
mappings: "AAAA",
};
const texts = [
leaf,
{ ...leaf, names: [] },
{ ...leaf, names: null },
{ ...leaf, names: 42 },
{ ...leaf, names: [42] },
{ ...leaf, mappings: "AAAAA" },
].map((map) =>
JSON.stringify(
format === "indexed"
? {
version: 3,
sections: [{ offset: { line: 2, column: 5 }, map }],
}
: map,
),
);
const server = createServer((incoming, response) => {
response.setHeader("content-type", "application/source-map+json");
response.end(texts[Number(incoming.url?.slice(1))]);
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const result = await fetchWebSourceMapsOk(
texts.map((_, index) => ({
...request,
fetchUrl: `${localOrigin}/${index}`,
declaredUrl: `${localOrigin}/${index}`,
})),
input({ allowed_origins: [localOrigin] }),
);
expect(result.items.map(({ status }) => status)).toEqual([
"included",
"included",
"invalid",
"invalid",
"invalid",
"invalid",
]);
for (const [index, text] of texts.slice(0, 2).entries())
expect(result.items[index]).toMatchObject({
artifact: {
text,
bytes: Buffer.byteLength(text),
sha256: createHash("sha256").update(text).digest("hex"),
},
original_sources: [{ source: `${localOrigin}/src/main.ts` }],
mappings: [
{
generated_line: format === "indexed" ? 3 : 1,
generated_column: format === "indexed" ? 5 : 0,
source: `${localOrigin}/src/main.ts`,
original_line: 1,
original_column: 0,
name: null,
},
],
original_module_edges: [
{
from_source: `${localOrigin}/src/main.ts`,
resolved_source: `${localOrigin}/src/dependency.ts`,
},
],
});
for (const item of result.items.slice(2))
expect(item).toMatchObject({
artifact: null,
mappings: [],
original_sources: [],
});
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
},
);
it("parses ECMA-426 HTTP source-map prefixes while retaining exact response evidence", async () => {
const map = JSON.stringify({
version: 3,
names: [],
sources: ["src/main.ts"],
sourcesContent: ["import './dependency.ts';"],
mappings: "AAAA",
});
const prefix = ")]}'transport prefix";
const included = [
`\uFEFF${prefix}\n${map}`,
`${prefix}\r\n${map}`,
`${prefix}\r${map}`,
];
const invalid = [`${prefix}${map}`, `\uFEFF${prefix}\n{`];
const texts = [...included, ...invalid];
const server = createServer((incoming, response) => {
const index = Number(incoming.url?.slice(1));
response.setHeader("content-type", "application/source-map+json");
response.end(texts[index]);
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const result = await fetchWebSourceMapsOk(
texts.map((_, index) => ({
...request,
fetchUrl: `${localOrigin}/${index}`,
declaredUrl: `${localOrigin}/${index}`,
})),
input({ allowed_origins: [localOrigin] }),
);
expect(result.items.map(({ status }) => status)).toEqual([
"included",
"included",
"included",
"invalid",
"invalid",
]);
for (const [index, text] of included.entries())
expect(result.items[index]).toMatchObject({
artifact: {
text,
bytes: Buffer.byteLength(text),
sha256: createHash("sha256").update(text).digest("hex"),
},
original_sources: [{ source: `${localOrigin}/src/main.ts` }],
mappings: [
{
generated_line: 1,
generated_column: 0,
source: `${localOrigin}/src/main.ts`,
original_line: 1,
original_column: 0,
},
],
original_module_edges: [
{
from_source: `${localOrigin}/src/main.ts`,
specifier: "./dependency.ts",
resolved_source: `${localOrigin}/src/dependency.ts`,
},
],
});
expect(result.items.slice(included.length)).toMatchObject(
invalid.map((text) => ({
artifact: null,
mappings: [],
original_sources: [],
response_identity: {
bytes: Buffer.byteLength(text),
sha256: createHash("sha256").update(text).digest("hex"),
representation: "fetch-response-body-bytes",
},
})),
);
const without = (value: object, omit: string) =>
Object.fromEntries(Object.entries(value).filter(([key]) => key !== omit));
for (const omit of ["source_index", "declaration_index"])
expectInvalidSourceMaps({
...result,
items: result.items.map((item) => ({
...item,
mappings: item.mappings.map((row) => without(row, omit)),
})),
});
// An invalid map was read in full, so its body identity is required.
expectInvalidSourceMaps({
...result,
items: result.items.map((item) =>
item.status === "invalid" ? without(item, "response_identity") : item,
),
});
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
});
describe("source-map redirect URL resolution", () => {
const deliveredPath =
"/assets/v2/app.js.map?revision=2&token=public-selection";
it.each(["/maps/current", deliveredPath])(
"resolves relative sources against the delivered map at %s",
async (initialPath) => {
const calls: string[] = [];
const text = JSON.stringify({
version: 3,
names: [],
sources: ["../src/main.ts"],
sourcesContent: ["import './dependency.ts';"],
mappings: "AAAA",
});
const server = createServer((incoming, response) => {
calls.push(incoming.url ?? "");
if (incoming.url === "/maps/current") {
response.writeHead(302, { location: deliveredPath }).end();
return;
}
response.setHeader("content-type", "application/json");
response.end(text);
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const declaredUrl = `${localOrigin}${initialPath}`;
const result = await fetchWebSourceMapsOk(
[{ ...request, fetchUrl: declaredUrl, declaredUrl }],
input({ allowed_origins: [localOrigin] }),
);
expect(calls).toEqual(
initialPath === "/maps/current"
? [initialPath, deliveredPath]
: [initialPath],
);
expect(result).toMatchObject({
status: "included",
items: [
{
declared_url: declaredUrl,
effective_url: `${localOrigin}${deliveredPath}`,
artifact: {
text,
bytes: Buffer.byteLength(text),
sha256: createHash("sha256").update(text).digest("hex"),
},
original_sources: [
{ source: `${localOrigin}/assets/src/main.ts` },
],
mappings: [{ source: `${localOrigin}/assets/src/main.ts` }],
original_module_edges: [
{
from_source: `${localOrigin}/assets/src/main.ts`,
resolved_source: `${localOrigin}/assets/src/dependency.ts`,
},
],
},
],
});
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
},
);
it("retains the last observed response URL when the next redirect fetch rejects", async () => {
const nextUrl = `${origin}${deliveredPath}`;
const calls: string[] = [];
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: (url) => {
calls.push(String(url));
return calls.length === 1
? Promise.resolve(
new Response(null, {
status: 302,
headers: { location: nextUrl },
}),
)
: Promise.reject(new TypeError("fixture connection failed"));
},
});
expect(calls).toEqual([request.fetchUrl, nextUrl]);
expect(result.items[0]).toMatchObject({
status: "fetch_failed",
declared_url: request.declaredUrl,
effective_url: request.fetchUrl,
artifact: null,
});
});
it("represents the effective URL as null when no response was observed", async () => {
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () => Promise.reject(new TypeError("fixture connection failed")),
});
const item = result.items[0];
if (item === undefined) throw new Error("Expected a fetch failure");
expect(item).toMatchObject({
status: "fetch_failed",
declared_url: request.declaredUrl,
effective_url: null,
artifact: null,
});
const { effective_url: _effective, ...withoutEffectiveUrl } = item;
expectInvalidSourceMaps({ ...result, items: [withoutEffectiveUrl] });
});
});
describe("web source-map fetching and validation: fetching maps and following redirects", () => {
it("fetches without credentials and derives mappings and original modules", async () => {
const calls: Array<{ url: string; init: RequestInit | undefined }> = [];
const map = JSON.stringify({
version: 3,
file: "app.js",
names: ["entry"],
sources: ["../src/main.ts"],
sourcesContent: ["import './dependency.ts';\nexport const entry = 1;"],
mappings: "AAAAA",
});
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: (url, init) => {
calls.push({ url: String(url), init });
return Promise.resolve(
new Response(map, {
status: 200,
headers: { "content-type": "application/json" },
}),
);
},
});
expect(calls).toHaveLength(1);
expect(calls[0]).toMatchObject({
url: request.fetchUrl,
init: {
credentials: "omit",
redirect: "manual",
referrerPolicy: "no-referrer",
},
});
expect(JSON.stringify(calls[0]?.init)).not.toContain("secret");
expect(result).toMatchObject({
status: "included",
requested: 1,
processed: 1,
items: [
{
status: "included",
artifact: { media_type: "application/source-map+json" },
original_sources: [
{
source: `${origin}/src/main.ts`,
artifact: { media_type: "text/typescript" },
},
],
original_module_edges: [
{
kind: "static_import",
specifier: "./dependency.ts",
resolved_source: `${origin}/src/dependency.ts`,
},
],
mappings: [
{
generated_line: 1,
generated_column: 0,
original_line: 1,
original_column: 0,
},
],
},
],
});
expectInvalidIncludedSourceMaps(result);
});
it.each([
["another origin", "https://private.example.test/map"],
["same-origin credentials", "https://user:secret@app.example.test/map"],
])("reauthorizes a redirect with %s", async (_case, location) => {
const calls: string[] = [];
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: (url) => {
calls.push(String(url));
return Promise.resolve(
new Response(null, {
status: 302,
headers: { location },
}),
);
},
});
expect(calls).toEqual([request.fetchUrl]);
expect(JSON.stringify(result)).not.toContain("user:secret");
expect(result).toMatchObject({
status: "unavailable",
items: [
{
status: "policy_filtered",
effective_url: request.fetchUrl,
limitation:
"Each source-map redirect must be a credential-free HTTP(S) URL on an approved exact origin.",
},
],
});
expectInvalidSourceMaps({
...result,
items: [{ ...result.items[0], limitation: null }],
});
});
});
describe("source-map declared URL policy", () => {
it.each([
["embedded credentials", "https://user:secret@app.example.test/a.map"],
["a different scheme on the same host", "http://app.example.test/a.map"],
["another origin", "https://private.example.test/a.map"],
["a non-http(s) scheme", "ftp://app.example.test/a.map"],
["a file URL", "file:///tmp/a.map"],
["an unparseable URL", "not a url"],
])(
"filters a declared fetch URL with %s before any request",
async (_description, fetchUrl) => {
const calls: string[] = [];
const result = await fetchWebSourceMapsOk(
[{ ...request, fetchUrl }],
input(),
undefined,
{
fetch: (url) => {
calls.push(String(url));
return Promise.resolve(new Response("{}", { status: 200 }));
},
},
);
expect(calls).toEqual([]);
expect(result).toMatchObject({
status: "unavailable",
items: [
{
status: "policy_filtered",
effective_url: null,
limitation:
"Declared source-map URL must be a credential-free HTTP(S) URL on an approved exact origin.",
},
],
});
},
);
it("follows an approved redirect chain without an arbitrary hop ceiling", async () => {
const calls: string[] = [];
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: (url) => {
const current = String(url);
calls.push(current);
const hop = Number(new URL(current).searchParams.get("hop") ?? "0");
return Promise.resolve(
hop < 7
? new Response(null, {
status: 302,
headers: {
location: `${origin}/assets/app.js.map?hop=${String(hop + 1)}`,
},
})
: validMapResponse(),
);
},
});
expect(calls).toHaveLength(8);
expect(result.items[0]?.status).toBe("included");
});
});
describe("web source-map fetching and validation: enforcing fetch limits and validating responses", () => {
it("settles an endless unique-URL redirect chain at the operation deadline", async () => {
let calls = 0;
const server = createServer((incoming, response) => {
calls += 1;
const next =
Number(
new URL(incoming.url ?? "/", "http://local").searchParams.get("n") ??
"0",
) + 1;
response.writeHead(302, { location: `/map?n=${String(next)}` }).end();
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const url = `${localOrigin}/map?n=0`;
const result = await fetchWebSourceMapsOk(
[{ ...request, fetchUrl: url, declaredUrl: url }],
input({
allowed_origins: [localOrigin],
source_map_fetch_timeout_ms: 100,
}),
undefined,
{ fetch },
);
expect(calls).toBeGreaterThan(1);
expect(result).toMatchObject({
status: "unavailable",
processed: 1,
items: [
{
status: "fetch_failed",
artifact: null,
limitation: expect.stringContaining("source_map_fetch_timeout_ms"),
},
],
});
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
});
it("cancels a streamed response when its retained-byte budget is exceeded", async () => {
let responseClosed = false;
let markResponseClosed: (() => void) | undefined;
const responseClosedPromise = new Promise<void>((resolve) => {
markResponseClosed = resolve;
});
const server = createServer((_incoming, response) => {
response.on("close", () => {
responseClosed = true;
markResponseClosed?.();
});
response.writeHead(200, { "content-type": "application/json" });
response.write("x".repeat(1_024));
const interval = setInterval(() => response.write("x".repeat(1_024)), 2);
response.on("close", () => clearInterval(interval));
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const url = `${localOrigin}/map`;
const result = await fetchWebSourceMapsOk(
[{ ...request, fetchUrl: url, declaredUrl: url }],
input({
allowed_origins: [localOrigin],
source_map_limits: { fetch_bytes: 512 },
}),
undefined,
{ fetch },
);
let timeout: ReturnType<typeof setTimeout> | undefined;
const closeConfirmed = await Promise.race([
responseClosedPromise.then(() => true),
new Promise<boolean>((resolve) => {
timeout = setTimeout(() => resolve(false), 500);
}),
]);
if (timeout !== undefined) clearTimeout(timeout);
expect(closeConfirmed).toBe(true);
expect(responseClosed).toBe(true);
expect(result).toMatchObject({
status: "unavailable",
items: [
{
status: "fetch_failed",
artifact: null,
limitation: expect.stringContaining("retained budget"),
},
],
});
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
});
});
describe("source-map response cancellation", () => {
it("cancels a pending response reader on caller abort", async () => {
const pullStart = phaseArrival();
let cancelled = false;
const body = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(new TextEncoder().encode("{"));
},
pull() {
pullStart.arrive();
},
cancel() {
cancelled = true;
},
});
const controller = new AbortController();
const abortReason = new Error("caller stopped source-map fetch");
const pending = fetchWebSourceMaps([request], input(), controller.signal, {
fetch: async () => new Response(body),
});
await withVerifierCleanup(async () => {
await pullStart.reached(pending, "source-map response pull");
controller.abort(abortReason);
const result = await pending;
expect(result.ok).toBe(false);
if (!result.ok) expect(result.error.cause).toBe(abortReason);
await expect.poll(() => cancelled).toBe(true);
}, [
() => controller.abort(),
async () => {
await pending;
},
]);
});
});
describe("completed source-map cancellation", () => {
it.each([null, { stopped: "caller" }, new AnalysisCancelledError("test")])(
"retains a completed map when a later response is cancelled with reason %s",
async (reason) => {
const pullStart = phaseArrival();
let cancelled = false;
const secondBody = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(new TextEncoder().encode("{"));
},
pull() {
pullStart.arrive();
},
cancel() {
cancelled = true;
},
});
const firstBody = JSON.stringify({
version: 3,
sources: ["src/first.ts"],
names: [],
mappings: "AAAA",
});
const first = {
...request,
declaredUrl: `${origin}/first.map`,
fetchUrl: `${origin}/first.map`,
};
const second = {
...request,
declaredUrl: `${origin}/second.map`,
fetchUrl: `${origin}/second.map`,
};
let fetches = 0;
const controller = new AbortController();
const pending = fetchWebSourceMaps(
[first, second],
input(),
controller.signal,
{
fetch: async () => {
fetches += 1;
return fetches === 1
? new Response(firstBody, { status: 200 })
: new Response(secondBody, { status: 200 });
},
},
);
await withVerifierCleanup(async () => {
await pullStart.reached(pending, "second source-map response pull");
controller.abort(reason);
const result = await pending;
expect(result.ok).toBe(false);
if (result.ok) return;
const failure = result.error;
expect(failure).toBeInstanceOf(AnalysisCancelledError);
expect(failure.cause).toBe(reason);
expect(failure.partialObservation).toMatchObject({
kind: "web-source-map-fetch",
source_maps: {
requested: 2,
processed: 1,
items: [
{
status: "included",
artifact: {
text: firstBody,
sha256: createHash("sha256").update(firstBody).digest("hex"),
},
},
],
},
});
await expect.poll(() => cancelled).toBe(true);
}, [
() => controller.abort(),
async () => {
await pending;
},
]);
},
);
});
describe("selected source-map fetch deadline", () => {
it("applies a non-default source_map_fetch_timeout_ms from the public input", async () => {
let calls = 0;
let closed = 0;
const server = createServer((incoming, response) => {
calls += 1;
incoming.on("close", () => {
closed += 1;
});
const next =
Number(
new URL(incoming.url ?? "/", "http://local").searchParams.get("n") ??
"0",
) + 1;
response.writeHead(302, { location: `/map?n=${String(next)}` }).end();
});
try {
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", resolve);
});
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected a TCP listener address");
const localOrigin = `http://127.0.0.1:${String(address.port)}`;
const url = `${localOrigin}/map?n=0`;
const result = await fetchWebSourceMapsOk(
[{ ...request, fetchUrl: url, declaredUrl: url }],
input({
source_map_fetch_timeout_ms: 150,
allowed_origins: [localOrigin],
}),
undefined,
{ fetch },
);
expect(calls).toBeGreaterThan(1);
expect(closed).toBeGreaterThan(0);
expect(result.items[0]?.limitation).toContain("150");
expect(result.items[0]?.limitation).toContain(
"source_map_fetch_timeout_ms",
);
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) => {
server.close((error) =>
error === undefined ? resolve() : reject(error),
);
});
}
});
});
describe("browser map decoded validation", () => {
it("keeps decoded-index and coordinate failures local to their map", async () => {
const maps = [
{ version: 3, names: [], sources: ["ok.js"], mappings: "AAAA" },
{ version: 3, names: [], sources: ["bad.js"], mappings: "ACAA" },
{ version: 3, names: [], sources: ["bad.js"], mappings: "AADA" },
{ version: 3, names: [], sources: ["bad.js"], mappings: "DAAA" },
{ version: 3, names: [], sources: ["bad.js"], mappings: "AAAAD" },
{
version: 3,
sections: [
{
offset: { line: 0, column: Number.MAX_SAFE_INTEGER },
map: {
version: 3,
names: [],
sources: ["bad.js"],
mappings: "CAAA",
},
},
],
},
{ version: 3, names: [], sources: ["ok.js"], mappings: "AAAA" },
];
let index = 0;
const requests = maps.map((_, requestIndex) => ({
...request,
scriptKey: `scr_${String(requestIndex + 1).padStart(64, "0")}`,
}));
const result = await fetchWebSourceMapsOk(requests, input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(JSON.stringify(maps[index++]), { status: 200 }),
),
});
expect(result.status).toBe("partial");
expect(result.items.map(({ status }) => status)).toEqual([
"included",
"invalid",
"invalid",
"invalid",
"invalid",
"invalid",
"included",
]);
expect(result.items[0]?.mappings).toHaveLength(1);
expect(result.items[6]?.mappings).toHaveLength(1);
});
});
describe("source-map operation deadline observations", () => {
it("keeps completed maps when a later request times out", async () => {
let calls = 0;
const requests = [
request,
{ ...request, scriptKey: `scr_${"2".repeat(64)}` },
];
const result = await fetchWebSourceMapsOk(
requests,
input({ source_map_fetch_timeout_ms: 100 }),
undefined,
{
fetch: (_url, options) => {
calls += 1;
return calls === 1
? Promise.resolve(validMapResponse())
: new Promise<Response>((_resolve, reject) => {
const signal = options?.signal;
signal?.addEventListener("abort", () => reject(signal.reason), {
once: true,
});
});
},
},
);
expect(result.status).toBe("partial");
expect(result.items.map(({ status }) => status)).toEqual([
"included",
"fetch_failed",
]);
expect(result.items[0]?.original_sources).toHaveLength(1);
});
});
it("shares the caller's fetch byte budget across completed map responses", async () => {
const body = JSON.stringify({
version: 3,
sources: [],
names: [],
mappings: "",
});
const requests = [
request,
{ ...request, scriptKey: `scr_${"2".repeat(64)}` },
];
let calls = 0;
const result = await fetchWebSourceMapsOk(
requests,
input({ source_map_limits: { fetch_bytes: Buffer.byteLength(body) } }),
undefined,
{
fetch: () => {
calls += 1;
return Promise.resolve(new Response(body));
},
},
);
expect(calls).toBe(2);
expect(result.items.map(({ status }) => status)).toEqual([
"included",
"fetch_failed",
]);
expect(result.items[1]?.limitation).toContain("retained budget");
});
it.each([
{ line: 0, column: -1 },
{ line: -1, column: 0 },
{ line: "0", column: 0 },
{ line: 0, column: 0.5 },
{ line: 0 },
{ line: 0, column: Number.MAX_SAFE_INTEGER + 1 },
])("retains an invalid-map item for malformed offset %j", async (offset) => {
const text = JSON.stringify({
version: 3,
sections: [
{
offset,
map: {
version: 3,
sources: ["original.js"],
names: [],
mappings: "AAAA",
},
},
],
});
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: async () => new Response(text),
});
expect(result).toMatchObject({
status: "unavailable",
items: [{ status: "invalid", artifact: null, mappings: [] }],
});
});
describe("web source-map sourcesContent validation", () => {
it.each([
["a scalar sourcesContent value", { sourcesContent: "source" }],
["a non-string, non-null source entry", { sourcesContent: [42] }],
])("reports %s as invalid", async (_description, content) => {
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(
JSON.stringify({
version: 3,
sources: ["source.ts"],
names: [],
mappings: "",
...content,
}),
{ status: 200 },
),
),
});
expect(result).toMatchObject({
status: "unavailable",
items: [
{
status: "invalid",
artifact: null,
original_sources: [],
limitation: expect.stringContaining("Source-map JSON"),
},
],
});
});
it.each([
["shorter", ["import './a.ts';"]],
["longer", ["import './a.ts';", null, "unused trailing content"]],
])(
"keeps every source declaration when sourcesContent is %s than sources",
async (_length, sourcesContent) => {
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(
JSON.stringify({
version: 3,
sources: ["a.ts", "b.ts"],
sourcesContent,
names: [],
mappings: "",
}),
{ status: 200 },
),
),
});
expect(result.items[0]).toMatchObject({
status: "included",
limitation: null,
original_sources: [
{
source_index: 0,
declaration_index: 0,
source: `${origin}/assets/a.ts`,
artifact: { text: "import './a.ts';" },
},
{
source_index: 1,
declaration_index: 1,
source: `${origin}/assets/b.ts`,
artifact: null,
},
],
});
expect(result.items[0]?.original_sources).toHaveLength(2);
},
);
it("accepts null source-map source contents", async () => {
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(
JSON.stringify({
version: 3,
sources: ["source.ts"],
sourcesContent: null,
names: [],
mappings: "",
}),
{ status: 200 },
),
),
});
expect(result.items[0]).toMatchObject({
status: "included",
original_sources: [
{
source_index: 0,
declaration_index: 0,
source: `${origin}/assets/source.ts`,
artifact: null,
},
],
});
});
it("keeps unnamed source slots and mapping indices", async () => {
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(
JSON.stringify({
version: 3,
sources: [null, "source.ts"],
sourcesContent: ["unknown source text", "named source text"],
names: [],
mappings: "ACAA",
}),
{ status: 200 },
),
),
});
expect(result.items[0]).toMatchObject({
status: "partial",
original_sources: [
{
source_index: 0,
declaration_index: 0,
source: null,
artifact: { text: "unknown source text" },
},
{
source_index: 1,
declaration_index: 1,
source: `${origin}/assets/source.ts`,
artifact: { text: "named source text" },
},
],
mappings: [
{
source_index: 1,
declaration_index: 1,
source: `${origin}/assets/source.ts`,
},
],
});
expect(result.items[0]?.limitation).toContain(
"unnamed source at declaration 0",
);
});
});
describe("source-map dependency coverage of hard-to-parse sources", () => {
const fetchWithSources = (sources: readonly string[]) =>
fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(
JSON.stringify({
version: 3,
names: [],
sources: sources.map((_, index) => `source-${String(index)}.ts`),
sourcesContent: [...sources],
mappings: "AAAA",
}),
),
),
});
it.each([
[
"decorated classes and parameters",
'@Component({ selector: "app" })\nexport class A { @Inject() b: C; constructor(@Optional() private s: S) {} }\nimport "./a.js";',
["./a.js"],
],
[
"legacy class decorators",
'class A { @dec method() {} }\nimport "./a.js";',
["./a.js"],
],
[
"TypeScript import equals",
'import lib = require("./lib.js");',
["./lib.js"],
],
[
"type-only import equals",
'import type Types = require("./types.js");\nimport lib = require("./lib.js");',
["./lib.js"],
],
[
"whole-statement type-only import",
'import type { Value } from "./types.js";',
[],
],
[
"whole-statement type-only export",
'export type { Value } from "./types.js";',
[],
],
[
"inline type import retains module side effects",
'import { type Value } from "./types.js";',
["./types.js"],
],
[
"a local import alias",
'import lib = localAlias;\nimport "./a.js";',
["./a.js"],
],
])("recovers dependencies from %s", async (_label, text, expected) => {
const result = await fetchWithSources([text]);
expect(result.items[0]?.status).toBe("included");
expect(
result.items[0]?.original_module_edges.map(({ specifier }) => specifier),
).toEqual(expected);
});
it("keeps recovered edges from a partly recovered source and reports them as partial", async () => {
const result = await fetchWithSources([
'with (scope) { require("./c.js"); }\nrequire("./b.js");\nimport "./a.js";',
]);
expect(result.status).toBe("partial");
expect(result.items[0]?.status).toBe("partial");
expect(result.items[0]?.limitation).toContain(
"could not be parsed in full",
);
expect(
result.items[0]?.original_module_edges.map(({ specifier }) => specifier),
).toEqual(["./b.js", "./a.js"]);
});
it("distinguishes an unparsable source from a source with no imports", async () => {
const broken = await fetchWithSources(['import "./a.js"; const s = "oops']);
expect(broken.items[0]?.status).toBe("partial");
expect(broken.items[0]?.original_module_edges).toEqual([]);
const clean = await fetchWithSources(["export const value = 1;"]);
expect(clean.status).toBe("included");
expect(clean.items[0]?.status).toBe("included");
expect(clean.items[0]?.original_module_edges).toEqual([]);
});
});
describe("web source-map collection", () => {
it("rejects a map above the default decoded segment limit", async () => {
const mapText = JSON.stringify({
version: 3,
names: [],
sources: [],
mappings: Array.from({ length: 262_145 }, () => "A").join(","),
});
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: async () => new Response(mapText),
});
expect(result.status).toBe("unavailable");
expect(result.items[0]).toMatchObject({
status: "fetch_failed",
artifact: null,
limitation: expect.stringContaining(
"source_map_limits.decoded_segments is 262144",
),
});
});
it("rejects deeply nested indexed maps before recursive flattening", async () => {
let map: unknown = {
version: 3,
names: [],
sources: [],
mappings: "",
};
for (let index = 0; index < 65; index += 1)
map = {
version: 3,
sections: [{ offset: { line: 0, column: 0 }, map }],
};
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(new Response(JSON.stringify(map), { status: 200 })),
});
expect(result.status).toBe("unavailable");
expect(result.items[0]).toMatchObject({
status: "fetch_failed",
artifact: null,
});
expect(result.items[0]?.limitation).toContain(
"source_map_limits.section_depth is 64",
);
});
it("retains every mapping from a sectioned source map", async () => {
const segmentCount = 10_001;
const regular = {
version: 3,
names: [],
sources: ["a.js"],
sourcesContent: ["export const a = 1"],
mappings: Array.from({ length: segmentCount }, () => "AAAA").join(","),
};
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () =>
Promise.resolve(
new Response(
JSON.stringify({
version: 3,
sections: [{ offset: { line: 0, column: 0 }, map: regular }],
}),
{ status: 200 },
),
),
});
expect(result.status).toBe("included");
expect(result.items[0]?.status).toBe("included");
expect(result.items[0]?.mappings).toHaveLength(segmentCount);
});
it("fetches and returns every requested map inline", async () => {
const calls: string[] = [];
const requests = Array.from({ length: 101 }, (_, index) => ({
...request,
scriptKey: `scr_${String(index + 1).padStart(64, "0")}`,
fetchUrl: `${origin}/assets/${String(index)}.js.map`,
}));
const result = await fetchWebSourceMapsOk(requests, input(), undefined, {
fetch: (url) => {
calls.push(String(url));
return Promise.resolve(validMapResponse());
},
});
expect(calls.toSorted()).toEqual(
requests.map(({ fetchUrl }) => fetchUrl).toSorted(),
);
expect(result).toMatchObject({
status: "included",
requested: requests.length,
processed: requests.length,
});
expect(result.items).toHaveLength(requests.length);
});
it("includes source-map text above 8 MiB", async () => {
const content = "x".repeat(8 * 1_024 * 1_024 + 1);
const map = JSON.stringify({
version: 3,
names: [],
sources: ["large.ts"],
sourcesContent: [content],
mappings: "AAAA",
});
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: () => Promise.resolve(new Response(map, { status: 200 })),
});
expect(result.status).toBe("included");
expect(result.items[0]?.status).toBe("included");
if (result.items[0]?.status !== "included") throw new Error("not included");
expect(result.items[0].original_sources[0]?.artifact?.bytes).toBe(
Buffer.byteLength(content),
);
});
});
it("shares the selected decoded record limit across maps", async () => {
// Each map consumes one structural record, two rows and two segments.
const mapText = JSON.stringify({
version: 3,
names: [],
sources: [],
mappings: "A;A",
});
const second = { ...request, scriptKey: `scr_${"2".repeat(64)}` };
const fetchMaps = (decodedRecords: number) =>
fetchWebSourceMapsOk(
[request, second],
input({ source_map_limits: { decoded_records: decodedRecords } }),
undefined,
{ fetch: async () => new Response(mapText) },
);
expect(await fetchMaps(10)).toMatchObject({
status: "included",
requested: 2,
processed: 2,
items: [
{ script_key: request.scriptKey, status: "included" },
{ script_key: second.scriptKey, status: "included" },
],
});
expect(await fetchMaps(9)).toMatchObject({
status: "partial",
requested: 2,
processed: 2,
items: [
{ script_key: request.scriptKey, status: "included" },
{
script_key: second.scriptKey,
status: "fetch_failed",
limitation: expect.stringContaining(
"source_map_limits.decoded_records is 9",
),
},
],
});
});
it("charges the escaped effective URL before reading the redirected response", async () => {
const effectiveUrl = `${origin}/delivered.map?selection=${"\\".repeat(6_000)}`;
const second = {
scriptKey: `scr_${"2".repeat(64)}`,
declaredUrl: `${origin}/redirect.map`,
fetchUrl: `${origin}/redirect.map`,
};
const fetchMaps = async (outputBytes: number) => {
let read = false;
let cancelled = false;
const result = await fetchWebSourceMapsOk(
[request, second],
input({ source_map_limits: { output_bytes: outputBytes } }),
undefined,
{
fetch: async (url) => {
if (String(url) === request.fetchUrl) return validMapResponse();
if (String(url) === second.fetchUrl)
return new Response(null, {
status: 302,
headers: { location: effectiveUrl },
});
expect(String(url)).toBe(effectiveUrl);
const body = new ReadableStream<Uint8Array>(
{
pull(controller) {
read = true;
controller.enqueue(Buffer.from("not-json"));
controller.close();
},
cancel() {
cancelled = true;
},
},
{ highWaterMark: 0 },
);
return new Response(body);
},
},
);
return { result, read, cancelled };
};
const admitted = await fetchMaps(16_000);
expect(admitted.result).toMatchObject({
status: "partial",
requested: 2,
processed: 2,
items: [
{ script_key: request.scriptKey, status: "included" },
{
script_key: second.scriptKey,
status: "invalid",
declared_url: second.declaredUrl,
effective_url: effectiveUrl,
},
],
});
expect(admitted.read).toBe(true);
const budget = 10_000;
expect(Buffer.byteLength(effectiveUrl)).toBeLessThan(budget);
expect(Buffer.byteLength(JSON.stringify(effectiveUrl))).toBeGreaterThan(
budget,
);
const excluded = await fetchMaps(budget);
expect(excluded.result).toMatchObject({
status: "partial",
requested: 2,
processed: 1,
items: [{ script_key: request.scriptKey, status: "included" }],
limitation: expect.stringContaining("1 requested map"),
});
expect(excluded.cancelled).toBe(true);
expect(excluded.read).toBe(false);
});
describe("source-map set output admission", () => {
it("retains only the maps that fit the selected aggregate output budget", async () => {
const requests = ["first", "second", "third"].map((name, index) => ({
scriptKey: `scr_${String(index + 1).repeat(64)}`,
declaredUrl: `${origin}/${name}.map${
name === "third" ? `?revision=${"r".repeat(3_000)}` : ""
}`,
fetchUrl: `${origin}/${name}.map`,
}));
const map = JSON.stringify({
version: 3,
names: [],
sources: ["source.ts"],
sourcesContent: [`// ${"x".repeat(4096)}`],
mappings: "AAAA",
});
const fetchMaps = (outputBytes: number) =>
fetchWebSourceMapsOk(
requests,
input({ source_map_limits: { output_bytes: outputBytes } }),
undefined,
{ fetch: async () => new Response(map) },
);
const complete = await fetchMaps(32_000);
const includedItems = requests.map(({ scriptKey, declaredUrl }) => ({
script_key: scriptKey,
declared_url: declaredUrl,
status: "included",
}));
expect(complete).toMatchObject({
status: "included",
requested: 3,
processed: 3,
items: includedItems,
});
const outputBytes = 21_000;
const limited = await fetchMaps(outputBytes);
expect(limited).toMatchObject({
status: "partial",
requested: 3,
processed: 2,
items: includedItems.slice(0, 2),
limitation: expect.stringContaining("1 requested map"),
});
expect(limited.limitation).toContain(
"source_map_limits.output_bytes is 21000",
);
expect(Buffer.byteLength(JSON.stringify(limited))).toBeLessThanOrEqual(
outputBytes,
);
expect(Buffer.byteLength(JSON.stringify(complete))).toBeGreaterThan(
outputBytes,
);
});
it("reserves large failure contexts and reports unprocessed requests as unknown", async () => {
const largeDeclaredUrl = `${origin}/${"u".repeat(8 * 1_024 * 1_024)}`;
const requests = [
request,
...Array.from({ length: 5 }, (_, index) => ({
...request,
scriptKey: `scr_${String(index + 2).padStart(64, "0")}`,
declaredUrl: largeDeclaredUrl,
fetchUrl: `${origin}/invalid-${String(index)}.map`,
})),
];
let calls = 0;
const result = await fetchWebSourceMapsOk(requests, input(), undefined, {
fetch: () => {
calls += 1;
return Promise.resolve(
calls === 1
? validMapResponse()
: new Response("not-json", { status: 200 }),
);
},
});
expect(calls).toBe(4);
expect(result).toMatchObject({
status: "partial",
requested: 6,
processed: 4,
limitation: expect.stringContaining("2 requested maps"),
});
expect(result.items.map(({ status }) => status)).toEqual([
"included",
"invalid",
"invalid",
"invalid",
]);
expect(
result.items.slice(1).map(({ declared_url }) => declared_url),
).toEqual([largeDeclaredUrl, largeDeclaredUrl, largeDeclaredUrl]);
expect(Buffer.byteLength(JSON.stringify(result))).toBeLessThanOrEqual(
32 * 1_024 * 1_024,
);
});
});
describe("expanded source-map evidence budget", () => {
it("includes a declared source whose serialized evidence fits", async () => {
const source = "x".repeat(4_000);
const map = JSON.stringify({
version: 3,
names: [],
sources: [source],
mappings: "",
});
const budget = 11_500;
const result = await fetchWebSourceMapsOk(
[request],
input({ source_map_limits: { output_bytes: budget } }),
undefined,
{ fetch: async () => new Response(map) },
);
expect(result).toMatchObject({
status: "included",
items: [
{
artifact: { text: map },
original_sources: [{ source: `${origin}/assets/${source}` }],
},
],
});
expect(Buffer.byteLength(JSON.stringify(result))).toBeLessThanOrEqual(
budget,
);
});
it("bounds expanded mapping evidence across individually valid maps", async () => {
const source = `https://sources.example.test/${"x".repeat(1_000)}.ts`;
const map = JSON.stringify({
version: 3,
names: [],
sources: [source],
mappings: "AAAA,CAAA,CAAA,CAAA",
});
const second = { ...request, scriptKey: `scr_${"2".repeat(64)}` };
const result = await fetchWebSourceMapsOk(
[request, second],
input({ source_map_limits: { output_bytes: 11_000 } }),
undefined,
{ fetch: async () => new Response(map) },
);
expect(result).toMatchObject({
status: "partial",
requested: 2,
processed: 2,
items: [
{
script_key: request.scriptKey,
status: "included",
mappings: [0, 1, 2, 3].map((generated_column) => ({
generated_column,
source,
})),
},
{
script_key: second.scriptKey,
status: "fetch_failed",
artifact: null,
mappings: [],
limitation: expect.stringContaining("Expanded source-map evidence"),
},
],
});
});
it("applies the output budget to resolved sources after path normalization", async () => {
const fetchMap = (sourceRoot: string) =>
fetchWebSourceMapsOk(
[request],
input({ source_map_limits: { output_bytes: 16_000 } }),
undefined,
{
fetch: async () =>
new Response(
JSON.stringify({
version: 3,
names: [],
sourceRoot,
sources: ["main.ts"],
mappings: "AAAA,CAAA,CAAA",
}),
),
},
);
const source = `${origin}/assets/main.ts`;
expect(await fetchMap("a/../".repeat(1_900))).toMatchObject({
status: "included",
items: [
{
original_sources: [{ source }],
mappings: [0, 1, 2].map((generated_column) => ({
generated_column,
source,
})),
},
],
});
expect(await fetchMap("x".repeat(9_500))).toMatchObject({
status: "unavailable",
items: [
{
status: "fetch_failed",
artifact: null,
original_sources: [],
mappings: [],
limitation: expect.stringContaining("Expanded source-map evidence"),
},
],
});
});
});
it("bounds resolved identities even when public URLs omit credentials", async () => {
const userinfo = "u".repeat(1_500);
const map = JSON.stringify({
version: 3,
names: [],
sourceRoot: `https://${userinfo}@sources.example.test/`,
sources: ["a.ts", "b.ts", "c.ts", "d.ts"],
mappings: "",
});
const fetchMaps = (fetchBytes: number) =>
fetchWebSourceMapsOk(
[request],
input({ source_map_limits: { fetch_bytes: fetchBytes } }),
undefined,
{ fetch: async () => new Response(map) },
);
expect(await fetchMaps(7_000)).toMatchObject({
status: "included",
items: [
{
original_sources: [
{ source: "https://sources.example.test/a.ts" },
{ source: "https://sources.example.test/b.ts" },
{ source: "https://sources.example.test/c.ts" },
{ source: "https://sources.example.test/d.ts" },
],
},
],
});
expect(await fetchMaps(5_000)).toMatchObject({
status: "unavailable",
items: [
{
status: "fetch_failed",
artifact: null,
original_sources: [],
limitation: expect.stringContaining(
"source_map_limits.fetch_bytes is 5000",
),
response_identity: {
bytes: Buffer.byteLength(map),
sha256: createHash("sha256").update(map).digest("hex"),
},
},
],
});
});
it("reports the source inventory limit before malformed entries", async () => {
const map = JSON.stringify({
version: 3,
names: [],
sources: [42, "source.js", "other.js"],
mappings: "",
});
const fetchMap = (decodedRecords: number) =>
fetchWebSourceMapsOk(
[request],
input({ source_map_limits: { decoded_records: decodedRecords } }),
undefined,
{ fetch: async () => new Response(map) },
);
expect(await fetchMap(3)).toMatchObject({
status: "unavailable",
items: [
{
status: "fetch_failed",
artifact: null,
limitation: expect.stringContaining(
"source_map_limits.decoded_records is 3",
),
},
],
});
expect(await fetchMap(10)).toMatchObject({
status: "unavailable",
items: [
{
status: "invalid",
artifact: null,
limitation: expect.stringContaining("Source-map JSON"),
},
],
});
});
const validMapResponse = () =>
new Response(
JSON.stringify({
version: 3,
names: [],
sources: ["a.js"],
sourcesContent: ["export const a = 1"],
mappings: "AAAA",
}),
{ status: 200 },
);
const input = (overrides: Record<string, unknown> = {}) => {
return analyzeWebBundleInputSchema.parse({
cdp_endpoint: "http://127.0.0.1:9222",
allowed_origins: [origin],
target_id: "page-1",
fetch_source_maps: true,
...overrides,
});
};
describe("deep source-map original syntax", () => {
it("retains valid source maps and native/CommonJS evidence after a parser-admitted deep property chain", async () => {
const source = `const value = root${".next".repeat(12_000)};\nimport "./last.js";\nrequire("./common.js");\nfunction local(require) { require("./shadowed.js"); }`;
const text = JSON.stringify({
version: 3,
names: [],
sources: ["../src/main.js"],
sourcesContent: [source],
mappings: "AAAA",
});
const result = await fetchWebSourceMapsOk([request], input(), undefined, {
fetch: async () => new Response(text),
});
expect(result).toMatchObject({
status: "included",
items: [
{
status: "included",
limitation: null,
artifact: { text },
original_sources: [{ artifact: { text: source } }],
original_module_edges: [
{
from_source: `${origin}/src/main.js`,
kind: "static_import",
specifier: "./last.js",
resolved_source: `${origin}/src/last.js`,
},
{
from_source: `${origin}/src/main.js`,
kind: "require",
specifier: "./common.js",
resolved_source: `${origin}/src/common.js`,
},
],
mappings: [
{
generated_line: 1,
generated_column: 0,
original_line: 1,
original_column: 0,
},
],
},
],
});
});
});