@specific.dev/spectest 0.59.0 → 0.59.1

package/dist/coverage.d.ts

@@ -102,11 +102,29 @@ export declare const NODE_COVERAGE_HOOK: string;
  * directory (every node process in the container then writes V8
  * coverage JSON when it exits) and `--require`s a hook that lets spectest
  * ask the long-lived server process for a dump at capture time. Nothing
- * for the app to write. Source maps: with `--enable-source-maps` (or a
+ * for the app to write. Each dump is compacted to the app's own scripts
+ * at capture ({@link compactV8Document}). Source maps: with `--enable-source-maps` (or a
  * `sourceMappingURL` next to the file) Node records the map in the
  * report, which is what maps a TypeScript service back to its sources.
  */
 export declare function node(): CoverageAdapter;
+/** A script is the app's own when it is a file outside node_modules. */
+export declare function isAppScriptUrl(url: string): boolean;
+/**
+ * Compact one V8 coverage document to the app's own scripts. What Node
+ * writes is everything the process loaded: `node:` internals, every
+ * `node_modules` file, and — under `--enable-source-maps` — a
+ * `source-map-cache` with each file's full map **and its sources**,
+ * repeated in every dump. Measured on a real project: a 12–20 MiB dump
+ * per capture, of which the app's own coverage was under 0.5 MiB, and a
+ * suite that hit the 64 MiB cap on its third test. Kept: `file://`
+ * scripts outside `node_modules`, the map entries of exactly those
+ * scripts, minus `sourcesContent` (the sources are the repo). Still a V8
+ * document — nothing is converted.
+ */
+export declare function compactV8Document(doc: Record<string, unknown>): Record<string, unknown>;
+/** Compact every not-yet-compacted V8 document in `dir`, in place. */
+export declare function compactV8Reports(dir: string): Promise<void>;
 /**
  * Coverage for the frontend a service serves. The code runs in the guest
  * browser — spectest's own process — so no report can be written by the

package/dist/coverage.js

@@ -151,7 +151,8 @@ if (process.env.NODE_V8_COVERAGE) {
  * directory (every node process in the container then writes V8
  * coverage JSON when it exits) and `--require`s a hook that lets spectest
  * ask the long-lived server process for a dump at capture time. Nothing
- * for the app to write. Source maps: with `--enable-source-maps` (or a
+ * for the app to write. Each dump is compacted to the app's own scripts
+ * at capture ({@link compactV8Document}). Source maps: with `--enable-source-maps` (or a
  * `sourceMappingURL` next to the file) Node records the map in the
  * report, which is what maps a TypeScript service back to its sources.
  */
@@ -193,9 +194,86 @@ export function node() {
             });
             if (reply !== "ok")
                 throw new Error(`the node hook answered: ${reply || "(nothing)"}`);
+            await compactV8Reports(ctx.reportDir);
         },
     };
 }
+/** V8 files already compacted, by path. Module memory: forks with the
+ *  environment, so a child never re-parses its ancestors' dumps. */
+const COMPACTED_V8_REPORTS = new Set();
+/** A script is the app's own when it is a file outside node_modules. */
+export function isAppScriptUrl(url) {
+    return url.startsWith("file://") && !url.includes("/node_modules/");
+}
+/**
+ * Compact one V8 coverage document to the app's own scripts. What Node
+ * writes is everything the process loaded: `node:` internals, every
+ * `node_modules` file, and — under `--enable-source-maps` — a
+ * `source-map-cache` with each file's full map **and its sources**,
+ * repeated in every dump. Measured on a real project: a 12–20 MiB dump
+ * per capture, of which the app's own coverage was under 0.5 MiB, and a
+ * suite that hit the 64 MiB cap on its third test. Kept: `file://`
+ * scripts outside `node_modules`, the map entries of exactly those
+ * scripts, minus `sourcesContent` (the sources are the repo). Still a V8
+ * document — nothing is converted.
+ */
+export function compactV8Document(doc) {
+    const result = Array.isArray(doc.result) ? doc.result : [];
+    const kept = result.filter((s) => typeof s.url === "string" && isAppScriptUrl(s.url));
+    const out = { ...doc, result: kept };
+    const cache = doc["source-map-cache"];
+    if (cache && typeof cache === "object") {
+        const urls = new Set(kept.map((s) => s.url));
+        const slim = {};
+        for (const [url, entry] of Object.entries(cache)) {
+            if (!urls.has(url) || !entry || typeof entry !== "object")
+                continue;
+            const e = { ...entry };
+            if (e.data && typeof e.data === "object") {
+                const { sourcesContent: _dropped, ...data } = e.data;
+                e.data = data;
+            }
+            slim[url] = e;
+        }
+        if (Object.keys(slim).length > 0)
+            out["source-map-cache"] = slim;
+        else
+            delete out["source-map-cache"];
+    }
+    return out;
+}
+/** Compact every not-yet-compacted V8 document in `dir`, in place. */
+export async function compactV8Reports(dir) {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!name.startsWith("coverage-") || !name.endsWith(".json"))
+            continue;
+        const file = path.join(dir, name);
+        if (COMPACTED_V8_REPORTS.has(file))
+            continue;
+        let doc;
+        try {
+            doc = JSON.parse(await fs.readFile(file, "utf8"));
+        }
+        catch {
+            continue; // a dump mid-write, or not ours; the read path judges it
+        }
+        if (!Array.isArray(doc.result))
+            continue;
+        const tmp = path.join(dir, `.${name}.compact`);
+        await fs.writeFile(tmp, JSON.stringify(compactV8Document(doc)));
+        await fs.rename(tmp, file);
+        COMPACTED_V8_REPORTS.add(file);
+    }
+}
 // ── browser ───────────────────────────────────────────────────────
 /**
  * Coverage for the frontend a service serves. The code runs in the guest

package/package.json

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

package/src/coverage.test.ts

@@ -11,6 +11,8 @@ import {
   appendEnvFlag,
   browser,
   command,
+  compactV8Document,
+  compactV8Reports,
   node,
   validateCoverage,
   type CoverageCaptureContext,
@@ -68,6 +70,45 @@ describe("applyCoverageAdapters", () => {
   });
 });
 
+describe("compactV8Document", () => {
+  const doc = {
+    result: [
+      { scriptId: "1", url: "file:///app/src/a.ts", functions: [] },
+      { scriptId: "2", url: "file:///app/node_modules/x/index.js", functions: [] },
+      { scriptId: "3", url: "node:fs", functions: [] },
+      { scriptId: "4", url: "", functions: [] },
+    ],
+    "source-map-cache": {
+      "file:///app/src/a.ts": { lineLengths: [1], data: { mappings: "AAAA", sources: ["a.ts"], sourcesContent: ["x"] }, url: null },
+      "file:///app/node_modules/x/index.js": { lineLengths: [1], data: { mappings: "AAAA" }, url: null },
+    },
+  };
+  test("keeps app scripts and their maps, drops the rest and sourcesContent", () => {
+    const out = compactV8Document(doc) as typeof doc;
+    expect(out.result.map((s) => s.url)).toEqual(["file:///app/src/a.ts"]);
+    expect(Object.keys(out["source-map-cache"])).toEqual(["file:///app/src/a.ts"]);
+    expect(out["source-map-cache"]["file:///app/src/a.ts"].data).toEqual({ mappings: "AAAA", sources: ["a.ts"] });
+  });
+  test("a dump with no app script keeps an empty result and no cache", () => {
+    const out = compactV8Document({ result: [doc.result[2]], "source-map-cache": doc["source-map-cache"] });
+    expect(out.result).toEqual([]);
+    expect("source-map-cache" in out).toBe(false);
+  });
+  test("compactV8Reports rewrites coverage-*.json once and leaves other files alone", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-cov-"));
+    await fs.writeFile(path.join(dir, "coverage-1-2-0.json"), JSON.stringify(doc));
+    await fs.writeFile(path.join(dir, "browser.lcov"), "TN:\n");
+    await compactV8Reports(dir);
+    const back = JSON.parse(await fs.readFile(path.join(dir, "coverage-1-2-0.json"), "utf8")) as { result: unknown[] };
+    expect(back.result.length).toBe(1);
+    expect(await fs.readFile(path.join(dir, "browser.lcov"), "utf8")).toBe("TN:\n");
+    // Idempotent and cheap: a second pass is a no-op on the same file.
+    await fs.writeFile(path.join(dir, "coverage-1-2-0.json"), "not json");
+    await compactV8Reports(dir);
+    expect(await fs.readFile(path.join(dir, "coverage-1-2-0.json"), "utf8")).toBe("not json");
+  });
+});
+
 /** A capture context over a real directory, no container. */
 function fakeCtx(dir: string, signal = new AbortController().signal): CoverageCaptureContext {
   return {

package/src/coverage.ts

@@ -235,7 +235,8 @@ if (process.env.NODE_V8_COVERAGE) {
  * directory (every node process in the container then writes V8
  * coverage JSON when it exits) and `--require`s a hook that lets spectest
  * ask the long-lived server process for a dump at capture time. Nothing
- * for the app to write. Source maps: with `--enable-source-maps` (or a
+ * for the app to write. Each dump is compacted to the app's own scripts
+ * at capture ({@link compactV8Document}). Source maps: with `--enable-source-maps` (or a
  * `sourceMappingURL` next to the file) Node records the map in the
  * report, which is what maps a TypeScript service back to its sources.
  */
@@ -280,10 +281,83 @@ export function node(): CoverageAdapter {
         });
       });
       if (reply !== "ok") throw new Error(`the node hook answered: ${reply || "(nothing)"}`);
+      await compactV8Reports(ctx.reportDir);
     },
   };
 }
 
+/** V8 files already compacted, by path. Module memory: forks with the
+ *  environment, so a child never re-parses its ancestors' dumps. */
+const COMPACTED_V8_REPORTS = new Set<string>();
+
+/** A script is the app's own when it is a file outside node_modules. */
+export function isAppScriptUrl(url: string): boolean {
+  return url.startsWith("file://") && !url.includes("/node_modules/");
+}
+
+/**
+ * Compact one V8 coverage document to the app's own scripts. What Node
+ * writes is everything the process loaded: `node:` internals, every
+ * `node_modules` file, and — under `--enable-source-maps` — a
+ * `source-map-cache` with each file's full map **and its sources**,
+ * repeated in every dump. Measured on a real project: a 12–20 MiB dump
+ * per capture, of which the app's own coverage was under 0.5 MiB, and a
+ * suite that hit the 64 MiB cap on its third test. Kept: `file://`
+ * scripts outside `node_modules`, the map entries of exactly those
+ * scripts, minus `sourcesContent` (the sources are the repo). Still a V8
+ * document — nothing is converted.
+ */
+export function compactV8Document(doc: Record<string, unknown>): Record<string, unknown> {
+  const result = Array.isArray(doc.result) ? (doc.result as { url?: unknown }[]) : [];
+  const kept = result.filter((s) => typeof s.url === "string" && isAppScriptUrl(s.url));
+  const out: Record<string, unknown> = { ...doc, result: kept };
+  const cache = doc["source-map-cache"];
+  if (cache && typeof cache === "object") {
+    const urls = new Set(kept.map((s) => s.url as string));
+    const slim: Record<string, unknown> = {};
+    for (const [url, entry] of Object.entries(cache as Record<string, unknown>)) {
+      if (!urls.has(url) || !entry || typeof entry !== "object") continue;
+      const e = { ...(entry as Record<string, unknown>) };
+      if (e.data && typeof e.data === "object") {
+        const { sourcesContent: _dropped, ...data } = e.data as Record<string, unknown>;
+        e.data = data;
+      }
+      slim[url] = e;
+    }
+    if (Object.keys(slim).length > 0) out["source-map-cache"] = slim;
+    else delete out["source-map-cache"];
+  }
+  return out;
+}
+
+/** Compact every not-yet-compacted V8 document in `dir`, in place. */
+export async function compactV8Reports(dir: string): Promise<void> {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  let names: string[];
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.startsWith("coverage-") || !name.endsWith(".json")) continue;
+    const file = path.join(dir, name);
+    if (COMPACTED_V8_REPORTS.has(file)) continue;
+    let doc: Record<string, unknown>;
+    try {
+      doc = JSON.parse(await fs.readFile(file, "utf8")) as Record<string, unknown>;
+    } catch {
+      continue; // a dump mid-write, or not ours; the read path judges it
+    }
+    if (!Array.isArray(doc.result)) continue;
+    const tmp = path.join(dir, `.${name}.compact`);
+    await fs.writeFile(tmp, JSON.stringify(compactV8Document(doc)));
+    await fs.rename(tmp, file);
+    COMPACTED_V8_REPORTS.add(file);
+  }
+}
+
 // ── browser ───────────────────────────────────────────────────────
 
 /**