@specific.dev/spectest 0.81.0 → 0.81.1

package/dist/coverage.d.ts

@@ -145,7 +145,7 @@ export declare const NODE_COVERAGE_HOOK: string;
  * `sourceMappingURL` (it caches maps under NODE_V8_COVERAGE with or
  * without `--enable-source-maps`), else from `<script>.map` next to the
  * script, read out of the container once
- * ({@link resolveSourceMapFromContainer}). The second way is the one to
+ * ({@link resolveSourceMapsFromContainer}). The second way is the one to
  * build a short-lived bundled process in: a map Node finds is serialized
  * whole into every exit dump — 12 MB per invocation for a bundled CLI,
  * inside the test's own time — and parsed again by the harness; a map
@@ -224,33 +224,49 @@ export interface SourceMapEntry {
     data: Record<string, unknown>;
     lineLengths: number[];
 }
-/** Finds the source map of a script the dump carries no map for.
- *  `null` when there is none. */
-export type SourceMapResolver = (scriptUrl: string) => Promise<SourceMapEntry | null>;
+/** Finds the source maps of the scripts a dump carries no map for, in
+ *  one go. A script absent from the result has none. */
+export type SourceMapResolver = (scriptUrls: string[]) => Promise<Map<string, SourceMapEntry>>;
+/**
+ * The probe {@link resolveSourceMapsFromContainer} runs in the container:
+ * one `sh` loop over every script path, printing `<path>\t<ref>` — the
+ * last `sourceMappingURL` value in the file, else `<path>.map` when that
+ * file exists, else `-`; `!` for a script that is not there. One exec per
+ * capture per service, whatever the number of scripts: a Next.js server
+ * loads hundreds of chunk scripts with no map, and a `docker cp` per
+ * script (the first cut) took a capture past its budget on a busy host.
+ */
+export declare function sourceMapProbeCommand(scriptPaths: string[]): string;
 /** The length of every line of `text`, the way Node computes it for
  *  `source-map-cache`: split on `\n` (and U+2028/2029), `\r` kept, the
  *  last line included. Lengths in UTF-16 units, which is what V8's byte
  *  offsets count in. */
 export declare function lineLengthsOf(text: string): number[];
-/** The last `sourceMappingURL` comment of a script, or `null`. */
-export declare function sourceMappingUrlOf(script: string): string | null;
 /**
- * The source map of `scriptUrl`, read out of the container: the script
- * itself (for its `sourceMappingURL` and its line lengths), then the map
- * — inline as a `data:` URL, a file the comment names, or, with no
- * comment, `<script>.map` next to it. `null` when the script is not a
- * `file://` URL, cannot be read, or the map is not there or not JSON; a
- * map's `sourcesContent` is dropped.
- * One read per script per branch: the caller remembers the outcome.
+ * The source maps of `scriptUrls`, read out of the container. One probe
+ * exec ({@link sourceMapProbeCommand}) finds, per script, the map a
+ * `sourceMappingURL` comment names or `<script>.map` next to it; only a
+ * script that has one is then read (`docker cp`, the script for its line
+ * lengths and the map file, or the inline `data:` map decoded). A map's
+ * `sourcesContent` is dropped. Scripts that are not `file://` URLs, have
+ * no map, or whose map is not there or not JSON are absent from the
+ * result. The caller remembers every outcome, so this runs once per
+ * script per branch.
+ *
+ * With no comment the map next to the script is the shape to build a
+ * short-lived bundled process in: Node caches a map it finds through a
+ * comment into every dump it writes under NODE_V8_COVERAGE, flag or no
+ * flag, and a bundled CLI's map is tens of MB per exit; a map it does not
+ * find costs nothing there.
  */
-export declare function resolveSourceMapFromContainer(ctx: CoverageCaptureContext, scriptUrl: string): Promise<SourceMapEntry | null>;
+export declare function resolveSourceMapsFromContainer(ctx: CoverageCaptureContext, scriptUrls: string[]): Promise<Map<string, SourceMapEntry>>;
 /**
  * Give every kept script of a compacted document a `source-map-cache`
  * entry it lacks: a stub when the map shipped earlier on this branch,
- * else the map `resolve` finds (shipped whole, with its hash, and
- * remembered), else nothing — and that outcome is remembered too, so a
- * script with no map is looked up once per branch. Returns how many maps
- * `resolve` supplied.
+ * else the map `resolve` finds (asked once for all such scripts; shipped
+ * whole, with its hash, and remembered), else nothing — and that outcome
+ * is remembered too, so a script with no map is looked up once per
+ * branch. Returns how many maps `resolve` supplied.
  */
 export declare function attachSourceMaps(doc: Record<string, unknown>, resolve: SourceMapResolver, shipped?: Map<string, string>, missing?: Set<string>): Promise<number>;
 /**

package/dist/coverage.js

@@ -189,7 +189,7 @@ if (process.env.NODE_V8_COVERAGE && require("node:worker_threads").isMainThread)
  * `sourceMappingURL` (it caches maps under NODE_V8_COVERAGE with or
  * without `--enable-source-maps`), else from `<script>.map` next to the
  * script, read out of the container once
- * ({@link resolveSourceMapFromContainer}). The second way is the one to
+ * ({@link resolveSourceMapsFromContainer}). The second way is the one to
  * build a short-lived bundled process in: a map Node finds is serialized
  * whole into every exit dump — 12 MB per invocation for a bundled CLI,
  * inside the test's own time — and parsed again by the harness; a map
@@ -234,7 +234,7 @@ export function node() {
             await removeShippedV8Reports(ctx.reportDir);
             const live = await dumpAllNodeProcesses(ctx.reportDir, ctx.signal);
             const t1 = performance.now();
-            const stats = await prepareV8Reports(ctx.reportDir, (url) => resolveSourceMapFromContainer(ctx, url));
+            const stats = await prepareV8Reports(ctx.reportDir, (urls) => resolveSourceMapsFromContainer(ctx, urls));
             if (stats.dumps === 0) {
                 await ctx.writeReport(NODE_COVERAGE_EMPTY_REPORT, '{"result":[]}\n');
                 SHIPPED_V8_REPORTS.add((await import("node:path")).join(ctx.reportDir, NODE_COVERAGE_EMPTY_REPORT));
@@ -397,6 +397,30 @@ export function compactV8Document(doc, shipped) {
     }
     return out;
 }
+/** Shell-quote one argument for `sh -c`. */
+function shQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * The probe {@link resolveSourceMapsFromContainer} runs in the container:
+ * one `sh` loop over every script path, printing `<path>\t<ref>` — the
+ * last `sourceMappingURL` value in the file, else `<path>.map` when that
+ * file exists, else `-`; `!` for a script that is not there. One exec per
+ * capture per service, whatever the number of scripts: a Next.js server
+ * loads hundreds of chunk scripts with no map, and a `docker cp` per
+ * script (the first cut) took a capture past its budget on a busy host.
+ */
+export function sourceMapProbeCommand(scriptPaths) {
+    const script = 'for f in "$@"; do ' +
+        'if [ -f "$f" ]; then ' +
+        "ref=$(grep -o 'sourceMappingURL=[^[:space:]]*' -- \"$f\" 2>/dev/null | tail -n 1 | cut -c18-); " +
+        'if [ -n "$ref" ]; then printf \'%s\\t%s\\n\' "$f" "$ref"; ' +
+        'elif [ -f "$f.map" ]; then printf \'%s\\t%s.map\\n\' "$f" "$f"; ' +
+        'else printf \'%s\\t-\\n\' "$f"; fi; ' +
+        'else printf \'%s\\t!\\n\' "$f"; fi; ' +
+        "done";
+    return `sh -c ${shQuote(script)} sh ${scriptPaths.map(shQuote).join(" ")}`;
+}
 /** The length of every line of `text`, the way Node computes it for
  *  `source-map-cache`: split on `\n` (and U+2028/2029), `\r` kept, the
  *  last line included. Lengths in UTF-16 units, which is what V8's byte
@@ -414,96 +438,119 @@ export function lineLengthsOf(text) {
     out.push(len);
     return out;
 }
-/** The last `sourceMappingURL` comment of a script, or `null`. */
-export function sourceMappingUrlOf(script) {
-    const re = /\/\/[#@]\s*sourceMappingURL=(\S+)/g;
-    let last = null;
-    let m;
-    while ((m = re.exec(script)) !== null)
-        last = m[1];
-    return last;
-}
 /**
- * The source map of `scriptUrl`, read out of the container: the script
- * itself (for its `sourceMappingURL` and its line lengths), then the map
- * — inline as a `data:` URL, a file the comment names, or, with no
- * comment, `<script>.map` next to it. `null` when the script is not a
- * `file://` URL, cannot be read, or the map is not there or not JSON; a
- * map's `sourcesContent` is dropped.
- * One read per script per branch: the caller remembers the outcome.
+ * The source maps of `scriptUrls`, read out of the container. One probe
+ * exec ({@link sourceMapProbeCommand}) finds, per script, the map a
+ * `sourceMappingURL` comment names or `<script>.map` next to it; only a
+ * script that has one is then read (`docker cp`, the script for its line
+ * lengths and the map file, or the inline `data:` map decoded). A map's
+ * `sourcesContent` is dropped. Scripts that are not `file://` URLs, have
+ * no map, or whose map is not there or not JSON are absent from the
+ * result. The caller remembers every outcome, so this runs once per
+ * script per branch.
+ *
+ * With no comment the map next to the script is the shape to build a
+ * short-lived bundled process in: Node caches a map it finds through a
+ * comment into every dump it writes under NODE_V8_COVERAGE, flag or no
+ * flag, and a bundled CLI's map is tens of MB per exit; a map it does not
+ * find costs nothing there.
  */
-export async function resolveSourceMapFromContainer(ctx, scriptUrl) {
-    if (!ctx.readContainerFile || !scriptUrl.startsWith("file://"))
-        return null;
+export async function resolveSourceMapsFromContainer(ctx, scriptUrls) {
+    const out = new Map();
+    if (!ctx.readContainerFile)
+        return out;
     const { fileURLToPath, pathToFileURL } = await import("node:url");
     const path = await import("node:path");
-    let scriptPath;
-    try {
-        scriptPath = fileURLToPath(scriptUrl);
-    }
-    catch {
-        return null;
-    }
-    const script = await ctx.readContainerFile(scriptPath);
-    if (!script)
-        return null;
-    const text = script.toString("utf8");
-    // No comment: the map next to the script, by convention (`x.js.map`).
-    // That is the shape to build a short-lived bundled process in: Node
-    // caches a map it finds through a comment into every dump it writes
-    // under NODE_V8_COVERAGE, flag or no flag, and a bundled CLI's map is
-    // tens of MB per exit; a map it does not find costs nothing there and
-    // is read here once per branch.
-    const ref = sourceMappingUrlOf(text) ?? `${path.basename(scriptPath)}.map`;
-    let mapText;
-    let mapUrl;
-    if (ref.startsWith("data:")) {
-        const comma = ref.indexOf(",");
-        if (comma < 0)
-            return null;
-        const head = ref.slice(5, comma);
-        const body = ref.slice(comma + 1);
+    const byPath = new Map();
+    for (const url of scriptUrls) {
+        if (!url.startsWith("file://"))
+            continue;
         try {
-            mapText = /;base64$/i.test(head) ? Buffer.from(body, "base64").toString("utf8") : decodeURIComponent(body);
+            byPath.set(fileURLToPath(url), url);
         }
         catch {
-            return null;
+            // not a path
         }
-        mapUrl = null;
     }
-    else {
-        let mapPath;
-        if (ref.startsWith("file://")) {
+    if (byPath.size === 0)
+        return out;
+    let probe;
+    try {
+        probe = (await ctx.exec(sourceMapProbeCommand([...byPath.keys()]))).stdout;
+    }
+    catch {
+        return out; // no shell, no grep: no maps from this container
+    }
+    for (const line of probe.split("\n")) {
+        const tab = line.indexOf("\t");
+        if (tab < 0)
+            continue;
+        const scriptPath = line.slice(0, tab);
+        const ref = line.slice(tab + 1).trim();
+        const url = byPath.get(scriptPath);
+        if (!url || ref === "-" || ref === "!" || ref === "")
+            continue;
+        let mapText;
+        let mapUrl;
+        if (ref.startsWith("data:")) {
+            const comma = ref.indexOf(",");
+            if (comma < 0)
+                continue;
+            const head = ref.slice(5, comma);
+            const body = ref.slice(comma + 1);
             try {
-                mapPath = fileURLToPath(ref);
+                mapText = /;base64$/i.test(head) ? Buffer.from(body, "base64").toString("utf8") : decodeURIComponent(body);
             }
             catch {
-                return null;
+                continue;
             }
-        }
-        else if (/^[a-z]+:/i.test(ref)) {
-            return null; // an http(s) map is not in the container
+            mapUrl = null;
         }
         else {
-            mapPath = path.resolve(path.dirname(scriptPath), decodeURIComponent(ref));
+            let mapPath;
+            if (ref.startsWith("file://")) {
+                try {
+                    mapPath = fileURLToPath(ref);
+                }
+                catch {
+                    continue;
+                }
+            }
+            else if (/^[a-z]+:/i.test(ref)) {
+                continue; // an http(s) map is not in the container
+            }
+            else {
+                let rel = ref;
+                try {
+                    rel = decodeURIComponent(ref);
+                }
+                catch {
+                    // keep as written
+                }
+                mapPath = path.resolve(path.dirname(scriptPath), rel);
+            }
+            const map = await ctx.readContainerFile(mapPath);
+            if (!map)
+                continue;
+            mapText = map.toString("utf8");
+            mapUrl = pathToFileURL(mapPath).href;
         }
-        const map = await ctx.readContainerFile(mapPath);
-        if (!map)
-            return null;
-        mapText = map.toString("utf8");
-        mapUrl = pathToFileURL(mapPath).href;
-    }
-    let data;
-    try {
-        data = JSON.parse(mapText);
-    }
-    catch {
-        return null;
+        let data;
+        try {
+            data = JSON.parse(mapText);
+        }
+        catch {
+            continue;
+        }
+        if (!data || typeof data !== "object" || !("mappings" in data))
+            continue;
+        const script = await ctx.readContainerFile(scriptPath);
+        if (!script)
+            continue;
+        const { sourcesContent: _dropped, ...slim } = data;
+        out.set(url, { url: mapUrl, data: slim, lineLengths: lineLengthsOf(script.toString("utf8")) });
     }
-    if (!data || typeof data !== "object" || !("mappings" in data))
-        return null;
-    const { sourcesContent: _dropped, ...slim } = data;
-    return { url: mapUrl, data: slim, lineLengths: lineLengthsOf(text) };
+    return out;
 }
 /** The content hash of a map entry, over its JSON with the spectest
  *  keys removed. */
@@ -516,15 +563,15 @@ function sourceMapEntryHash(entry) {
 /**
  * Give every kept script of a compacted document a `source-map-cache`
  * entry it lacks: a stub when the map shipped earlier on this branch,
- * else the map `resolve` finds (shipped whole, with its hash, and
- * remembered), else nothing — and that outcome is remembered too, so a
- * script with no map is looked up once per branch. Returns how many maps
- * `resolve` supplied.
+ * else the map `resolve` finds (asked once for all such scripts; shipped
+ * whole, with its hash, and remembered), else nothing — and that outcome
+ * is remembered too, so a script with no map is looked up once per
+ * branch. Returns how many maps `resolve` supplied.
  */
 export async function attachSourceMaps(doc, resolve, shipped = SHIPPED_SOURCE_MAPS, missing = NO_SOURCE_MAP) {
     const result = Array.isArray(doc.result) ? doc.result : [];
     const cache = (doc["source-map-cache"] ?? {});
-    let found = 0;
+    const unknown = [];
     for (const s of result) {
         const url = s.url;
         if (typeof url !== "string" || url in cache)
@@ -534,17 +581,24 @@ export async function attachSourceMaps(doc, resolve, shipped = SHIPPED_SOURCE_MA
             cache[url] = { [SOURCE_MAP_REF_KEY]: prior };
             continue;
         }
-        if (missing.has(url))
-            continue;
-        const entry = await resolve(url);
-        if (!entry) {
-            missing.add(url);
+        if (missing.has(url) || unknown.includes(url))
             continue;
+        unknown.push(url);
+    }
+    let found = 0;
+    if (unknown.length > 0) {
+        const entries = await resolve(unknown);
+        for (const url of unknown) {
+            const entry = entries.get(url);
+            if (!entry) {
+                missing.add(url);
+                continue;
+            }
+            const hash = sourceMapEntryHash(entry);
+            cache[url] = { ...entry, [SOURCE_MAP_HASH_KEY]: hash };
+            shipped.set(url, hash);
+            found++;
         }
-        const hash = sourceMapEntryHash(entry);
-        cache[url] = { ...entry, [SOURCE_MAP_HASH_KEY]: hash };
-        shipped.set(url, hash);
-        found++;
     }
     if (Object.keys(cache).length > 0)
         doc["source-map-cache"] = cache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.81.0",
+  "version": "0.81.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/coverage.test.ts

@@ -14,8 +14,8 @@ import {
   appendEnvFlag,
   attachSourceMaps,
   lineLengthsOf,
-  resolveSourceMapFromContainer,
-  sourceMappingUrlOf,
+  resolveSourceMapsFromContainer,
+  sourceMapProbeCommand,
   browser,
   command,
   coverageReportsMode,
@@ -191,8 +191,17 @@ function fakeCtx(dir: string, signal = new AbortController().signal): CoverageCa
     service: "api",
     reportDir: dir,
     signal,
-    async exec() {
-      throw new Error("no container");
+    // The probe runs through a real shell; the "container" paths are
+    // this directory's own.
+    async exec(command: string) {
+      return new Promise((resolve, reject) => {
+        const p = spawn("sh", ["-c", command], { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        p.stdout!.on("data", (b: Buffer) => (stdout += b));
+        p.stderr!.on("data", (b: Buffer) => (stderr += b));
+        p.on("exit", (code) => (code === 0 ? resolve({ stdout, stderr }) : reject(new Error(stderr || `exit ${code}`))));
+      });
     },
     async writeReport(name, content) {
       await fs.writeFile(path.join(dir, name), content);
@@ -209,10 +218,21 @@ describe("source maps by reference", () => {
     expect(lineLengthsOf("")).toEqual([0]);
     expect(lineLengthsOf("x\n")).toEqual([1, 0]);
   });
-  test("sourceMappingUrlOf takes the last comment", () => {
-    expect(sourceMappingUrlOf("a\n//# sourceMappingURL=a.js.map\nb\n//# sourceMappingURL=b.js.map\n")).toBe("b.js.map");
-    expect(sourceMappingUrlOf("//@ sourceMappingURL=old.map")).toBe("old.map");
-    expect(sourceMappingUrlOf("no map here")).toBeNull();
+  test("the probe: one exec, one line per script — the last comment's ref, the .map next to it, or none", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covprobe-"));
+    await fs.writeFile(path.join(dir, "a.js"), "x\n//# sourceMappingURL=old.map\ny\n//# sourceMappingURL=maps/a.map\n");
+    await fs.writeFile(path.join(dir, "b.js"), "x();\n");
+    await fs.writeFile(path.join(dir, "b.js.map"), "{}");
+    await fs.writeFile(path.join(dir, "it's.js"), "x();\n");
+    const r = await fakeCtx(dir).exec(
+      sourceMapProbeCommand([path.join(dir, "a.js"), path.join(dir, "b.js"), path.join(dir, "it's.js"), path.join(dir, "gone.js")]),
+    );
+    expect(r.stdout).toBe(
+      `${path.join(dir, "a.js")}\tmaps/a.map\n` +
+        `${path.join(dir, "b.js")}\t${path.join(dir, "b.js.map")}\n` +
+        `${path.join(dir, "it's.js")}\t-\n` +
+        `${path.join(dir, "gone.js")}\t!\n`,
+    );
   });
   test("resolves the map a comment names, drops sourcesContent, computes line lengths", async () => {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covmap-"));
@@ -222,46 +242,46 @@ describe("source maps by reference", () => {
       path.join(dir, "maps", "cli.map"),
       JSON.stringify({ version: 3, sources: ["../src/cli.ts"], mappings: "AAAA;AACA", names: [], sourcesContent: ["x"] }),
     );
-    const entry = await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "cli.js")}`);
-    expect(entry).not.toBeNull();
-    expect(entry!.url).toBe(`file://${path.join(dir, "maps", "cli.map")}`);
-    expect(entry!.data).toEqual({ version: 3, sources: ["../src/cli.ts"], mappings: "AAAA;AACA", names: [] });
-    expect(entry!.lineLengths).toEqual([12, 15, 33, 0]);
+    const url = `file://${path.join(dir, "cli.js")}`;
+    const out = await resolveSourceMapsFromContainer(fakeCtx(dir), [url, "node:fs"]);
+    expect([...out.keys()]).toEqual([url]);
+    const entry = out.get(url)!;
+    expect(entry.url).toBe(`file://${path.join(dir, "maps", "cli.map")}`);
+    expect(entry.data).toEqual({ version: 3, sources: ["../src/cli.ts"], mappings: "AAAA;AACA", names: [] });
+    expect(entry.lineLengths).toEqual([12, 15, 33, 0]);
   });
-  test("with no comment, <script>.map next to the script is the map", async () => {
+  test("with no comment, <script>.map next to the script is the map; inline data: maps decode; the rest is absent", async () => {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covmap-"));
     await fs.writeFile(path.join(dir, "cli.js"), "x();\n");
     await fs.writeFile(path.join(dir, "cli.js.map"), JSON.stringify({ version: 3, sources: ["cli.ts"], mappings: "AAAA" }));
-    const entry = await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "cli.js")}`);
-    expect(entry!.url).toBe(`file://${path.join(dir, "cli.js.map")}`);
-    expect(entry!.data).toEqual({ version: 3, sources: ["cli.ts"], mappings: "AAAA" });
-  });
-  test("resolves an inline data: URL map; no map, no file, or a foreign URL is null", async () => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covmap-"));
     const map = JSON.stringify({ version: 3, sources: ["a.ts"], mappings: "AAAA" });
     await fs.writeFile(
       path.join(dir, "inline.js"),
       `x();\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(map).toString("base64")}\n`,
     );
-    const inline = await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "inline.js")}`);
-    expect(inline!.url).toBeNull();
-    expect(inline!.data).toEqual({ version: 3, sources: ["a.ts"], mappings: "AAAA" });
     await fs.writeFile(path.join(dir, "bare.js"), "x();\n");
-    expect(await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "bare.js")}`)).toBeNull();
     await fs.writeFile(path.join(dir, "gone.js"), "x();\n//# sourceMappingURL=gone.js.map\n");
-    expect(await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "gone.js")}`)).toBeNull();
     await fs.writeFile(path.join(dir, "http.js"), "x();\n//# sourceMappingURL=https://cdn.test/x.map\n");
-    expect(await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "http.js")}`)).toBeNull();
-    expect(await resolveSourceMapFromContainer(fakeCtx(dir), "node:fs")).toBeNull();
+    await fs.writeFile(path.join(dir, "notjson.js"), "x();\n");
+    await fs.writeFile(path.join(dir, "notjson.js.map"), "nope");
+    const u = (n: string) => `file://${path.join(dir, n)}`;
+    const out = await resolveSourceMapsFromContainer(fakeCtx(dir), [
+      u("cli.js"), u("inline.js"), u("bare.js"), u("gone.js"), u("http.js"), u("notjson.js"), u("missing.js"),
+    ]);
+    expect([...out.keys()].sort()).toEqual([u("cli.js"), u("inline.js")].sort());
+    expect(out.get(u("cli.js"))!.url).toBe(`file://${path.join(dir, "cli.js.map")}`);
+    expect(out.get(u("cli.js"))!.data).toEqual({ version: 3, sources: ["cli.ts"], mappings: "AAAA" });
+    expect(out.get(u("inline.js"))!.url).toBeNull();
+    expect(out.get(u("inline.js"))!.data).toEqual({ version: 3, sources: ["a.ts"], mappings: "AAAA" });
     const noRead = { ...fakeCtx(dir), readContainerFile: undefined };
-    expect(await resolveSourceMapFromContainer(noRead, `file://${path.join(dir, "inline.js")}`)).toBeNull();
+    expect((await resolveSourceMapsFromContainer(noRead, [u("cli.js")])).size).toBe(0);
   });
-  test("attachSourceMaps: a map once, a stub after, a missing map looked up once", async () => {
-    const calls: string[] = [];
+  test("attachSourceMaps: one batched lookup, a map once, a stub after, a missing map looked up once", async () => {
+    const calls: string[][] = [];
     const entry = { url: null, data: { version: 3, sources: ["a.ts"], mappings: "AAAA" }, lineLengths: [4] };
-    const resolve = async (url: string) => {
-      calls.push(url);
-      return url.endsWith("/a.js") ? entry : null;
+    const resolve = async (urls: string[]) => {
+      calls.push(urls);
+      return new Map(urls.filter((u) => u.endsWith("/a.js")).map((u) => [u, entry]));
     };
     const shipped = new Map<string, string>();
     const missing = new Set<string>();
@@ -277,16 +297,16 @@ describe("source maps by reference", () => {
     expect(c1["file:///app/a.js"][SOURCE_MAP_HASH_KEY]).toMatch(/^sha256:/);
     expect(c1["file:///app/a.js"].lineLengths).toEqual([4]);
     expect("file:///app/b.js" in c1).toBe(false);
-    expect(calls).toEqual(["file:///app/a.js", "file:///app/b.js"]);
+    expect(calls).toEqual([["file:///app/a.js", "file:///app/b.js"]]);
     const second = dump() as Record<string, unknown>;
     expect(await attachSourceMaps(second, resolve, shipped, missing)).toBe(0);
     const c2 = second["source-map-cache"] as Record<string, Record<string, unknown>>;
     expect(c2["file:///app/a.js"]).toEqual({ [SOURCE_MAP_REF_KEY]: c1["file:///app/a.js"][SOURCE_MAP_HASH_KEY] });
-    expect(calls.length).toBe(2); // b.js is not asked again
+    expect(calls.length).toBe(1); // b.js is not asked again
     // A dump that carries its own entry is left alone.
     const own = { ...dump(), "source-map-cache": { "file:///app/b.js": { data: { mappings: "" }, lineLengths: [1] } } } as Record<string, unknown>;
     expect(await attachSourceMaps(own, resolve, shipped, missing)).toBe(0);
-    expect(calls.length).toBe(2);
+    expect(calls.length).toBe(1);
   });
 });
 

package/src/coverage.ts

@@ -292,7 +292,7 @@ if (process.env.NODE_V8_COVERAGE && require("node:worker_threads").isMainThread)
  * `sourceMappingURL` (it caches maps under NODE_V8_COVERAGE with or
  * without `--enable-source-maps`), else from `<script>.map` next to the
  * script, read out of the container once
- * ({@link resolveSourceMapFromContainer}). The second way is the one to
+ * ({@link resolveSourceMapsFromContainer}). The second way is the one to
  * build a short-lived bundled process in: a map Node finds is serialized
  * whole into every exit dump — 12 MB per invocation for a bundled CLI,
  * inside the test's own time — and parsed again by the harness; a map
@@ -337,7 +337,7 @@ export function node(): CoverageAdapter {
       await removeShippedV8Reports(ctx.reportDir);
       const live = await dumpAllNodeProcesses(ctx.reportDir, ctx.signal);
       const t1 = performance.now();
-      const stats = await prepareV8Reports(ctx.reportDir, (url) => resolveSourceMapFromContainer(ctx, url));
+      const stats = await prepareV8Reports(ctx.reportDir, (urls) => resolveSourceMapsFromContainer(ctx, urls));
       if (stats.dumps === 0) {
         await ctx.writeReport(NODE_COVERAGE_EMPTY_REPORT, '{"result":[]}\n');
         SHIPPED_V8_REPORTS.add((await import("node:path")).join(ctx.reportDir, NODE_COVERAGE_EMPTY_REPORT));
@@ -537,9 +537,36 @@ export interface SourceMapEntry {
   lineLengths: number[];
 }
 
-/** Finds the source map of a script the dump carries no map for.
- *  `null` when there is none. */
-export type SourceMapResolver = (scriptUrl: string) => Promise<SourceMapEntry | null>;
+/** Finds the source maps of the scripts a dump carries no map for, in
+ *  one go. A script absent from the result has none. */
+export type SourceMapResolver = (scriptUrls: string[]) => Promise<Map<string, SourceMapEntry>>;
+
+/** Shell-quote one argument for `sh -c`. */
+function shQuote(s: string): string {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * The probe {@link resolveSourceMapsFromContainer} runs in the container:
+ * one `sh` loop over every script path, printing `<path>\t<ref>` — the
+ * last `sourceMappingURL` value in the file, else `<path>.map` when that
+ * file exists, else `-`; `!` for a script that is not there. One exec per
+ * capture per service, whatever the number of scripts: a Next.js server
+ * loads hundreds of chunk scripts with no map, and a `docker cp` per
+ * script (the first cut) took a capture past its budget on a busy host.
+ */
+export function sourceMapProbeCommand(scriptPaths: string[]): string {
+  const script =
+    'for f in "$@"; do ' +
+    'if [ -f "$f" ]; then ' +
+    "ref=$(grep -o 'sourceMappingURL=[^[:space:]]*' -- \"$f\" 2>/dev/null | tail -n 1 | cut -c18-); " +
+    'if [ -n "$ref" ]; then printf \'%s\\t%s\\n\' "$f" "$ref"; ' +
+    'elif [ -f "$f.map" ]; then printf \'%s\\t%s.map\\n\' "$f" "$f"; ' +
+    'else printf \'%s\\t-\\n\' "$f"; fi; ' +
+    'else printf \'%s\\t!\\n\' "$f"; fi; ' +
+    "done";
+  return `sh -c ${shQuote(script)} sh ${scriptPaths.map(shQuote).join(" ")}`;
+}
 
 /** The length of every line of `text`, the way Node computes it for
  *  `source-map-cache`: split on `\n` (and U+2028/2029), `\r` kept, the
@@ -559,87 +586,104 @@ export function lineLengthsOf(text: string): number[] {
   return out;
 }
 
-/** The last `sourceMappingURL` comment of a script, or `null`. */
-export function sourceMappingUrlOf(script: string): string | null {
-  const re = /\/\/[#@]\s*sourceMappingURL=(\S+)/g;
-  let last: string | null = null;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(script)) !== null) last = m[1]!;
-  return last;
-}
-
 /**
- * The source map of `scriptUrl`, read out of the container: the script
- * itself (for its `sourceMappingURL` and its line lengths), then the map
- * — inline as a `data:` URL, a file the comment names, or, with no
- * comment, `<script>.map` next to it. `null` when the script is not a
- * `file://` URL, cannot be read, or the map is not there or not JSON; a
- * map's `sourcesContent` is dropped.
- * One read per script per branch: the caller remembers the outcome.
+ * The source maps of `scriptUrls`, read out of the container. One probe
+ * exec ({@link sourceMapProbeCommand}) finds, per script, the map a
+ * `sourceMappingURL` comment names or `<script>.map` next to it; only a
+ * script that has one is then read (`docker cp`, the script for its line
+ * lengths and the map file, or the inline `data:` map decoded). A map's
+ * `sourcesContent` is dropped. Scripts that are not `file://` URLs, have
+ * no map, or whose map is not there or not JSON are absent from the
+ * result. The caller remembers every outcome, so this runs once per
+ * script per branch.
+ *
+ * With no comment the map next to the script is the shape to build a
+ * short-lived bundled process in: Node caches a map it finds through a
+ * comment into every dump it writes under NODE_V8_COVERAGE, flag or no
+ * flag, and a bundled CLI's map is tens of MB per exit; a map it does not
+ * find costs nothing there.
  */
-export async function resolveSourceMapFromContainer(
+export async function resolveSourceMapsFromContainer(
   ctx: CoverageCaptureContext,
-  scriptUrl: string,
-): Promise<SourceMapEntry | null> {
-  if (!ctx.readContainerFile || !scriptUrl.startsWith("file://")) return null;
+  scriptUrls: string[],
+): Promise<Map<string, SourceMapEntry>> {
+  const out = new Map<string, SourceMapEntry>();
+  if (!ctx.readContainerFile) return out;
   const { fileURLToPath, pathToFileURL } = await import("node:url");
   const path = await import("node:path");
-  let scriptPath: string;
-  try {
-    scriptPath = fileURLToPath(scriptUrl);
-  } catch {
-    return null;
-  }
-  const script = await ctx.readContainerFile(scriptPath);
-  if (!script) return null;
-  const text = script.toString("utf8");
-  // No comment: the map next to the script, by convention (`x.js.map`).
-  // That is the shape to build a short-lived bundled process in: Node
-  // caches a map it finds through a comment into every dump it writes
-  // under NODE_V8_COVERAGE, flag or no flag, and a bundled CLI's map is
-  // tens of MB per exit; a map it does not find costs nothing there and
-  // is read here once per branch.
-  const ref = sourceMappingUrlOf(text) ?? `${path.basename(scriptPath)}.map`;
-  let mapText: string;
-  let mapUrl: string | null;
-  if (ref.startsWith("data:")) {
-    const comma = ref.indexOf(",");
-    if (comma < 0) return null;
-    const head = ref.slice(5, comma);
-    const body = ref.slice(comma + 1);
+  const byPath = new Map<string, string>();
+  for (const url of scriptUrls) {
+    if (!url.startsWith("file://")) continue;
     try {
-      mapText = /;base64$/i.test(head) ? Buffer.from(body, "base64").toString("utf8") : decodeURIComponent(body);
+      byPath.set(fileURLToPath(url), url);
     } catch {
-      return null;
+      // not a path
     }
-    mapUrl = null;
-  } else {
-    let mapPath: string;
-    if (ref.startsWith("file://")) {
+  }
+  if (byPath.size === 0) return out;
+  let probe: string;
+  try {
+    probe = (await ctx.exec(sourceMapProbeCommand([...byPath.keys()]))).stdout;
+  } catch {
+    return out; // no shell, no grep: no maps from this container
+  }
+  for (const line of probe.split("\n")) {
+    const tab = line.indexOf("\t");
+    if (tab < 0) continue;
+    const scriptPath = line.slice(0, tab);
+    const ref = line.slice(tab + 1).trim();
+    const url = byPath.get(scriptPath);
+    if (!url || ref === "-" || ref === "!" || ref === "") continue;
+    let mapText: string;
+    let mapUrl: string | null;
+    if (ref.startsWith("data:")) {
+      const comma = ref.indexOf(",");
+      if (comma < 0) continue;
+      const head = ref.slice(5, comma);
+      const body = ref.slice(comma + 1);
       try {
-        mapPath = fileURLToPath(ref);
+        mapText = /;base64$/i.test(head) ? Buffer.from(body, "base64").toString("utf8") : decodeURIComponent(body);
       } catch {
-        return null;
+        continue;
       }
-    } else if (/^[a-z]+:/i.test(ref)) {
-      return null; // an http(s) map is not in the container
+      mapUrl = null;
     } else {
-      mapPath = path.resolve(path.dirname(scriptPath), decodeURIComponent(ref));
+      let mapPath: string;
+      if (ref.startsWith("file://")) {
+        try {
+          mapPath = fileURLToPath(ref);
+        } catch {
+          continue;
+        }
+      } else if (/^[a-z]+:/i.test(ref)) {
+        continue; // an http(s) map is not in the container
+      } else {
+        let rel = ref;
+        try {
+          rel = decodeURIComponent(ref);
+        } catch {
+          // keep as written
+        }
+        mapPath = path.resolve(path.dirname(scriptPath), rel);
+      }
+      const map = await ctx.readContainerFile(mapPath);
+      if (!map) continue;
+      mapText = map.toString("utf8");
+      mapUrl = pathToFileURL(mapPath).href;
     }
-    const map = await ctx.readContainerFile(mapPath);
-    if (!map) return null;
-    mapText = map.toString("utf8");
-    mapUrl = pathToFileURL(mapPath).href;
-  }
-  let data: Record<string, unknown>;
-  try {
-    data = JSON.parse(mapText) as Record<string, unknown>;
-  } catch {
-    return null;
+    let data: Record<string, unknown>;
+    try {
+      data = JSON.parse(mapText) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    if (!data || typeof data !== "object" || !("mappings" in data)) continue;
+    const script = await ctx.readContainerFile(scriptPath);
+    if (!script) continue;
+    const { sourcesContent: _dropped, ...slim } = data;
+    out.set(url, { url: mapUrl, data: slim, lineLengths: lineLengthsOf(script.toString("utf8")) });
   }
-  if (!data || typeof data !== "object" || !("mappings" in data)) return null;
-  const { sourcesContent: _dropped, ...slim } = data;
-  return { url: mapUrl, data: slim, lineLengths: lineLengthsOf(text) };
+  return out;
 }
 
 /** The content hash of a map entry, over its JSON with the spectest
@@ -654,10 +698,10 @@ function sourceMapEntryHash(entry: Record<string, unknown>): string {
 /**
  * Give every kept script of a compacted document a `source-map-cache`
  * entry it lacks: a stub when the map shipped earlier on this branch,
- * else the map `resolve` finds (shipped whole, with its hash, and
- * remembered), else nothing — and that outcome is remembered too, so a
- * script with no map is looked up once per branch. Returns how many maps
- * `resolve` supplied.
+ * else the map `resolve` finds (asked once for all such scripts; shipped
+ * whole, with its hash, and remembered), else nothing — and that outcome
+ * is remembered too, so a script with no map is looked up once per
+ * branch. Returns how many maps `resolve` supplied.
  */
 export async function attachSourceMaps(
   doc: Record<string, unknown>,
@@ -667,7 +711,7 @@ export async function attachSourceMaps(
 ): Promise<number> {
   const result = Array.isArray(doc.result) ? (doc.result as V8Script[]) : [];
   const cache = ((doc["source-map-cache"] as Record<string, unknown> | undefined) ?? {}) as Record<string, unknown>;
-  let found = 0;
+  const unknown: string[] = [];
   for (const s of result) {
     const url = s.url;
     if (typeof url !== "string" || url in cache) continue;
@@ -676,16 +720,23 @@ export async function attachSourceMaps(
       cache[url] = { [SOURCE_MAP_REF_KEY]: prior };
       continue;
     }
-    if (missing.has(url)) continue;
-    const entry = await resolve(url);
-    if (!entry) {
-      missing.add(url);
-      continue;
+    if (missing.has(url) || unknown.includes(url)) continue;
+    unknown.push(url);
+  }
+  let found = 0;
+  if (unknown.length > 0) {
+    const entries = await resolve(unknown);
+    for (const url of unknown) {
+      const entry = entries.get(url);
+      if (!entry) {
+        missing.add(url);
+        continue;
+      }
+      const hash = sourceMapEntryHash(entry as unknown as Record<string, unknown>);
+      cache[url] = { ...entry, [SOURCE_MAP_HASH_KEY]: hash };
+      shipped.set(url, hash);
+      found++;
     }
-    const hash = sourceMapEntryHash(entry as unknown as Record<string, unknown>);
-    cache[url] = { ...entry, [SOURCE_MAP_HASH_KEY]: hash };
-    shipped.set(url, hash);
-    found++;
   }
   if (Object.keys(cache).length > 0) doc["source-map-cache"] = cache;
   return found;