@specific.dev/spectest 0.119.3 → 0.119.5

package/src/harness/coverage.ts

@@ -64,6 +64,7 @@ export function coverageHostDir(workspace: string, service: string): string {
 export interface CoverageReport {
   name: string;
   content: string;
+  sourceOptions?: import("../coverage.js").CoverageSourceOptions;
 }
 
 /** One service's capture: every report in its directory, verbatim. */
@@ -78,6 +79,8 @@ export interface ServiceCoverageCapture {
   root?: string;
   /** Repository root of the service build/bundler workspace, when explicit. */
   sourceRoot?: string;
+  /** SDK-declared source exclusions, preserved for server-side derivation. */
+  excludeSources?: readonly string[];
   /** Set when the capture failed: the command failed, the directory was
    *  empty, no file held an `SF:` record, or the reports were too large.
    *  A case with an error here fails — a hole in the coverage data must
@@ -471,7 +474,7 @@ export function applyCoverageDelta(
     const prev = prevByName.get(r.name) ?? new Map<string, LcovRecordCounts>();
     prevByName.set(r.name, now);
     const restarted: string[] = [];
-    reports.push({ name: r.name, content: renderLcovCounts(subtractLcovCounts(now, prev, restarted)) });
+    reports.push({ ...r, content: renderLcovCounts(subtractLcovCounts(now, prev, restarted)) });
     if (restarted.length > 0) {
       console.warn(
         `[coverage] service "${capture.service}" report ${r.name}: counters dropped in ${restarted.length} file(s) (${restarted.slice(0, 3).join(", ")}) — a process restarted; those records count whole`,

package/src/index.ts

@@ -176,6 +176,8 @@ export {
   type CoverageAdapter,
   type CoverageCaptureContext,
   type CoverageConfigureInfo,
+  type CoverageSourceOptions,
+  type CoverageSourceContext,
   type CoverageLoadContext,
   type ServiceCoverage,
 } from "./coverage.js";

package/src/next.ts

@@ -0,0 +1,74 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+/** Keep each traced script's map alongside it in standalone output. Turbopack
+ * versions that do not apply outputFileTracingIncludes still emit these traces
+ * before runAfterProductionCompile. No source files or generated code change. */
+async function includeTracedMaps(distDir: string): Promise<void> {
+  async function walk(dir: string): Promise<void> {
+    for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+      const file = path.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "cache" && entry.name !== "standalone") await walk(file);
+      else if (entry.isFile() && entry.name.endsWith(".nft.json")) {
+        const trace = JSON.parse(await fs.readFile(file, "utf8"));
+        if (!Array.isArray(trace.files)) throw new Error(`Invalid Next trace: ${file}`);
+        const scripts = [entry.name.slice(0, -".nft.json".length), ...trace.files];
+        const maps: string[] = [];
+        for (const script of scripts) {
+          if (typeof script !== "string" || !script.endsWith(".js")) continue;
+          const map = script + ".map";
+          try { if ((await fs.stat(path.resolve(dir, map))).isFile()) maps.push(map); }
+          catch (e) { if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e; }
+        }
+        trace.files = [...new Set([...trace.files, ...maps])];
+        await fs.writeFile(file, JSON.stringify(trace));
+      }
+    }
+  }
+  await walk(distDir);
+}
+
+/** Build-time companion for coverage.next(). Import this lightweight module in
+ * next.config; it does not load the Spectest harness or require Next at runtime.
+ * Apply only in the test build if production should not expose source maps. */
+export function withCoverage<T extends object>(config: T): T {
+  const c = config as Record<string, any>;
+  const distDir = c.distDir ?? ".next";
+  const includes = c.outputFileTracingIncludes ?? {};
+  return {
+    ...config,
+    productionBrowserSourceMaps: true,
+    turbopack: c.turbopack ?? {},
+    webpack(webpackConfig: any, context: any) {
+      const configured = c.webpack ? c.webpack(webpackConfig, context) : webpackConfig;
+      configured.plugins ??= [];
+      configured.plugins.push({
+        apply(compiler: any) {
+          compiler.hooks.compilation.tap("SpectestCoverage", (compilation: any) => {
+            compiler.webpack.NormalModule.getCompilationHooks(compilation).loader.tap(
+              "SpectestCoverage", (loader: any, module: any) => {
+                // Keep dependencies identifiable as dependencies. Chaining a
+                // package's published maps can replace node_modules provenance
+                // with ambiguous paths such as ../../src/client/router.ts.
+                if (/[\\/]node_modules[\\/]/.test(module.resource ?? "")) loader.sourceMap = false;
+              },
+            );
+          });
+        },
+      });
+      return configured;
+    },
+    experimental: { ...c.experimental, serverSourceMaps: true },
+    compiler: {
+      ...c.compiler,
+      async runAfterProductionCompile(metadata: { projectDir: string; distDir: string }) {
+        await c.compiler?.runAfterProductionCompile?.(metadata);
+        await includeTracedMaps(metadata.distDir);
+      },
+    },
+    outputFileTracingIncludes: {
+      ...includes,
+      "/**": [...(includes["/**"] ?? []), `./${distDir}/server/**/*.map`],
+    },
+  };
+}