@sdeverywhere/plugin-check 0.3.20 → 0.3.22

package/dist/index.js

@@ -1,12 +1,53 @@
 // src/plugin.ts
 import { existsSync as existsSync3 } from "fs";
-import { copyFile, mkdir } from "fs/promises";
-import { dirname as dirname4, join as joinPath3, relative as relative4 } from "path";
+import { copyFile, mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname5, join as joinPath5, relative as relative5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { build, createServer } from "vite";
-import chokidar from "chokidar";
 import { createConfig } from "@sdeverywhere/check-core";
 
+// src/bundle-file-ops.ts
+import { mkdir, readFile, stat, utimes, writeFile } from "fs/promises";
+import { dirname, join as joinPath } from "path";
+async function downloadBundle(url, name, lastModified, bundlesDir) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const bundleContent = await response.text();
+  const nameParts = name.split("/");
+  const filePath = joinPath(bundlesDir, ...nameParts) + ".js";
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, bundleContent, "utf8");
+  if (lastModified) {
+    const mtime = new Date(lastModified);
+    await utimes(filePath, mtime, mtime);
+  }
+  return filePath;
+}
+async function copyBundle(url, newName, bundlesDir) {
+  let srcPath;
+  if (url === "current") {
+    const sdePrepDir = joinPath(bundlesDir, "..", "sde-prep");
+    srcPath = joinPath(sdePrepDir, "check-bundle.js");
+  } else if (url.startsWith("file://")) {
+    srcPath = new URL(url).pathname;
+  } else {
+    throw new Error(`Cannot copy bundle with URL: ${url}`);
+  }
+  const bundleContent = await readFile(srcPath, "utf8");
+  const stats = await stat(srcPath);
+  const sourceLastModified = stats.mtime;
+  const nameParts = newName.split("/");
+  const filePath = joinPath(bundlesDir, ...nameParts) + ".js";
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, bundleContent, "utf8");
+  if (sourceLastModified) {
+    await utimes(filePath, sourceLastModified, sourceLastModified);
+  }
+  return filePath;
+}
+
 // src/run-suite.ts
 import { performance } from "perf_hooks";
 import pico from "picocolors";
@@ -114,13 +155,13 @@ ${group.name}`);
   context.log("info", "");
   return allPassed;
 }
-function stat(label, n) {
+function stat2(label, n) {
   return `${label}=${n.toFixed(1)}ms`;
 }
 function printPerfReportLine(context, perfReport) {
-  const avg = stat("avg", perfReport.avgTime);
-  const min = stat("min", perfReport.minTime);
-  const max = stat("max", perfReport.maxTime);
+  const avg = stat2("avg", perfReport.avgTime);
+  const min = stat2("min", perfReport.minTime);
+  const max = stat2("max", perfReport.maxTime);
   context.log("info", `    ${avg} ${min} ${max}`);
 }
 function printPerfStats(context, comparisonConfig, report) {
@@ -134,12 +175,12 @@ function printPerfStats(context, comparisonConfig, report) {
 
 // src/vite-config-for-bundle.ts
 import { existsSync, readFileSync, statSync } from "fs";
-import { basename, dirname, join as joinPath, relative, resolve as resolvePath } from "path";
+import { basename, dirname as dirname2, join as joinPath2, relative, resolve as resolvePath } from "path";
 import { fileURLToPath } from "url";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
 import { encodeImplVars } from "@sdeverywhere/check-core";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
+var __dirname2 = dirname2(__filename2);
 function injectModelSpec(context, modelSpec) {
   const prepDir = context.config.prepDir;
   const inputSpecs = [];
@@ -168,7 +209,7 @@ function injectModelSpec(context, modelSpec) {
     };
   });
   function readJsonListing() {
-    const path = joinPath(prepDir, "build", "processed.json");
+    const path = joinPath2(prepDir, "build", "processed.json");
     if (existsSync(path)) {
       const json = readFileSync(path, "utf8");
       return JSON.parse(json);
@@ -180,7 +221,7 @@ function injectModelSpec(context, modelSpec) {
   const varInstances = listing.varInstances || {};
   const encodedImplVars = encodeImplVars(varInstances);
   function stagedFileSize(filename) {
-    const path = joinPath(prepDir, "staged", "model", filename);
+    const path = joinPath2(prepDir, "staged", "model", filename);
     if (existsSync(path)) {
       return statSync(path).size;
     } else {
@@ -235,7 +276,7 @@ async function createViteConfigForBundle(context, modelSpec) {
   const root = resolvePath(__dirname2, "..", "template-bundle");
   const prepDir = context.config.prepDir;
   const outDir = relative(root, prepDir);
-  const modelWorkerPath = joinPath(prepDir, "staged", "model", "worker.js?raw");
+  const modelWorkerPath = joinPath2(prepDir, "staged", "model", "worker.js?raw");
   return {
     // Don't use an external config file
     configFile: false,
@@ -270,7 +311,9 @@ async function createViteConfigForBundle(context, modelSpec) {
           replacement: "threads",
           customResolver: async function(source, importer, options) {
             const customResolver = nodeResolve({ browser: false });
-            const resolved = await customResolver.resolveId.call(this, source, importer, options);
+            const resolveIdHook = customResolver.resolveId;
+            const resolveIdFn = typeof resolveIdHook === "function" ? resolveIdHook : resolveIdHook.handler;
+            const resolved = await resolveIdFn.call(this, source, importer, options);
             if (source === "threads/worker") {
               return resolved.id.replace("worker.mjs", "dist-esm/worker/index.js");
             } else {
@@ -334,29 +377,116 @@ let __non_webpack_require__ = () => {
 }
 
 // src/vite-config-for-report.ts
-import { existsSync as existsSync2, mkdirSync } from "fs";
-import { dirname as dirname2, relative as relative2, join as joinPath2, resolve as resolvePath2 } from "path";
+import { existsSync as existsSync2, mkdirSync, statSync as statSync2 } from "fs";
+import { dirname as dirname3, relative as relative3, join as joinPath4, resolve as resolvePath2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import replace from "@rollup/plugin-replace";
+
+// src/vite-local-bundles-plugin.ts
+import { readdir, stat as stat3 } from "fs/promises";
+import { join as joinPath3, relative as relative2, sep } from "path";
+import { pathToFileURL } from "url";
+import chokidar from "chokidar";
+function localBundlesPlugin(bundlesDir) {
+  return {
+    name: "sde-local-bundles",
+    configureServer(server) {
+      const watcher = chokidar.watch(bundlesDir, {
+        // Don't send initial "file added" events
+        ignoreInitial: true,
+        // XXX: Include a delay, otherwise on macOS we sometimes get multiple
+        // change events when a file is saved just once
+        awaitWriteFinish: {
+          stabilityThreshold: 200
+        },
+        // Watch up to 10 levels deep
+        depth: 10
+      });
+      watcher.on("all", () => {
+        server.ws.send("bundles-changed", {});
+      });
+      server.httpServer?.on("close", () => {
+        watcher.close();
+      });
+      server.ws.on("list-bundles", async (_, client) => {
+        try {
+          const bundles = await scanBundlesRecursively(bundlesDir, bundlesDir);
+          client.send("list-bundles-success", { bundles });
+        } catch (error) {
+          console.error(`[sde-local-bundles] Failed to list bundles:`, error);
+          client.send("list-bundles-error", { error: error.message });
+        }
+      });
+      server.ws.on("download-bundle", async (data, client) => {
+        const { url, name, lastModified } = data;
+        try {
+          console.log(`[sde-local-bundles] Downloading bundle: name=${name} url=${url}`);
+          const filePath = await downloadBundle(url, name, lastModified, bundlesDir);
+          console.log(`[sde-local-bundles] Downloaded bundle to ${filePath}`);
+          client.send("download-bundle-success", { name, filePath: `${name}.js` });
+        } catch (error) {
+          console.error(`[sde-local-bundles] Failed to download bundle:`, error);
+          client.send("download-bundle-error", { name, error: error.message });
+        }
+      });
+      server.ws.on("copy-bundle", async (data, client) => {
+        const { url, name, newName } = data;
+        try {
+          console.log(`[sde-local-bundles] Copying bundle: src=${name} dst=${newName}`);
+          const filePath = await copyBundle(url, newName, bundlesDir);
+          console.log(`[sde-local-bundles] Copied bundle to ${filePath}`);
+          client.send("copy-bundle-success", { name: newName, filePath: `${newName}.js` });
+        } catch (error) {
+          console.error(`[sde-local-bundles] Failed to copy bundle:`, error);
+          client.send("copy-bundle-error", { name, error: error.message });
+        }
+      });
+    }
+  };
+}
+async function scanBundlesRecursively(dir, baseDir) {
+  const bundles = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = joinPath3(dir, entry.name);
+    if (entry.isDirectory()) {
+      const subBundles = await scanBundlesRecursively(fullPath, baseDir);
+      bundles.push(...subBundles);
+    } else if (entry.isFile() && entry.name.endsWith(".js")) {
+      const stats = await stat3(fullPath);
+      const relativePath = relative2(baseDir, fullPath);
+      const name = relativePath.replace(/\.js$/, "").split(sep).join("/");
+      bundles.push({
+        name,
+        url: pathToFileURL(fullPath).toString(),
+        lastModified: stats.mtime.toISOString()
+      });
+    }
+  }
+  return bundles;
+}
+
+// src/vite-config-for-report.ts
 var __filename3 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname2(__filename3);
-function createViteConfigForReport(options, projDir, prepDir, currentBundleName, currentBundlePath, testConfigPath, suiteSummary) {
+var __dirname3 = dirname3(__filename3);
+function createViteConfigForReport(mode, options, projDir, prepDir, currentBundleSpec, baselineBundleSpec, testConfigPath, suiteSummary) {
   const root = resolvePath2(__dirname3, "..", "template-report");
-  const baselinesDir = resolvePath2(projDir, "baselines");
-  if (!existsSync2(baselinesDir)) {
-    mkdirSync(baselinesDir, { recursive: true });
+  const bundlesDir = resolvePath2(projDir, "bundles");
+  if (!existsSync2(bundlesDir)) {
+    mkdirSync(bundlesDir, { recursive: true });
   }
   const templateSrcDir = resolvePath2(root, "src");
-  const relProjDir = relative2(templateSrcDir, projDir);
+  const relProjDir = relative3(templateSrcDir, projDir);
   const relProjDirPath = relProjDir.replaceAll("\\", "/");
-  const baselinesPath = `${relProjDirPath}/baselines/*.js`;
+  const bundlesPath = `${relProjDirPath}/bundles/*.js`;
+  const currentBundleLastModified = statSync2(currentBundleSpec.path).mtime.toISOString();
   let reportPath;
   if (options?.reportPath) {
     reportPath = options.reportPath;
   } else {
-    reportPath = joinPath2(prepDir, "check-report");
+    reportPath = joinPath4(prepDir, "check-report");
   }
-  const outDir = relative2(root, reportPath);
+  const outDir = relative3(root, reportPath);
   const suiteSummaryJson = suiteSummary ? JSON.stringify(suiteSummary) : "";
   const alias = (find, replacement) => {
     return {
@@ -381,7 +511,7 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
     // Use a custom cache directory under `prepDir`, as otherwise Vite will use
     // `packages/plugin-check/template-report/node_modules/.vite`, and we want to
     // avoid generating files in `template-report` (which should be read-only)
-    cacheDir: joinPath2(prepDir, ".vite-check-report"),
+    cacheDir: joinPath4(prepDir, ".vite-check-report"),
     // Load static files from `static` (instead of the default `public`)
     // publicDir: 'static',
     // Don't clear the screen in dev mode so that we can see builder output
@@ -428,9 +558,9 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
       alias: [
         // Use the configured "baseline" bundle if defined, otherwise use the "empty" bundle
         // (which will cause comparison tests to be skipped)
-        alias("@_baseline_bundle_", options?.baseline ? options.baseline.path : "/src/empty-bundle.ts"),
+        alias("@_baseline_bundle_", baselineBundleSpec?.path || "/src/empty-bundle.ts"),
         // Use the configured "current" bundle
-        alias("@_current_bundle_", currentBundlePath),
+        alias("@_current_bundle_", currentBundleSpec.path),
         // Use the configured test config file
         alias("@_test_config_", testConfigPath),
         // Make the overlay use the `messages.html` file that is written to the prep directory
@@ -450,10 +580,14 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
     define: {
       // Inject the summary JSON into the build
       __SUITE_SUMMARY_JSON__: JSON.stringify(suiteSummaryJson),
-      // Inject the baseline branch name
-      __BASELINE_NAME__: JSON.stringify(options?.baseline?.name || ""),
-      // Inject the current branch name
-      __CURRENT_NAME__: JSON.stringify(currentBundleName)
+      // Inject the baseline bundle name
+      __BASELINE_NAME__: JSON.stringify(baselineBundleSpec?.name || ""),
+      // Inject the current bundle name
+      __CURRENT_NAME__: JSON.stringify(currentBundleSpec.name),
+      // Inject the last modified time of the current bundle
+      __CURRENT_BUNDLE_LAST_MODIFIED__: JSON.stringify(currentBundleLastModified),
+      // Inject the remote bundles URL
+      __REMOTE_BUNDLES_URL__: JSON.stringify(options?.remoteBundlesUrl || "")
     },
     plugins: [
       // Inject special values into the generated JS
@@ -465,15 +599,18 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
         delimiters: ["", ""],
         values: {
           // Inject the path for baseline bundles
-          // XXX: Note that we use './baselines/*.txt' instead of something special
+          // XXX: Note that we use './bundles/*.txt' instead of something special
           // like './__BASELINE_BUNDLES_PATH__' because sometimes Vite's dependency
           // scanner sees the latter (instead of the injected path) and reports
           // an error since the path does not exist.  As a workaround, we use
-          // './baselines/*.txt', which gets interpreted as the valid path
-          // '.../template-report/src/baselines/*.txt' (see `baselines/unused.txt`).
-          "./baselines/*.txt": baselinesPath
+          // './bundles/*.txt', which gets interpreted as the valid path
+          // '.../template-report/src/bundles/*.txt' (see `bundles/unused.txt`).
+          "./bundles/*.txt": bundlesPath
         }
-      })
+      }),
+      // When local development mode is active, enable the local bundles plugin that
+      // allows the report app to access the local bundles directory
+      ...mode === "watch" ? [localBundlesPlugin(bundlesDir)] : []
     ],
     build: {
       // Write output files to the configured directory (instead of the default `dist`);
@@ -512,19 +649,19 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
 }
 
 // src/vite-config-for-tests.ts
-import { dirname as dirname3, relative as relative3, resolve as resolvePath3 } from "path";
+import { dirname as dirname4, relative as relative4, resolve as resolvePath3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import replace2 from "@rollup/plugin-replace";
 var __filename4 = fileURLToPath3(import.meta.url);
-var __dirname4 = dirname3(__filename4);
-function createViteConfigForTests(projDir, prepDir, mode) {
+var __dirname4 = dirname4(__filename4);
+function createViteConfigForTests(mode, projDir, prepDir) {
   const root = resolvePath3(__dirname4, "..", "template-tests");
   const templateSrcDir = resolvePath3(root, "src");
-  const relProjDir = relative3(templateSrcDir, projDir);
+  const relProjDir = relative4(templateSrcDir, projDir);
   const relProjDirPath = relProjDir.replaceAll("\\", "/");
   const yamlCheckGlobPatterns = `['${relProjDirPath}/**/checks/*.yaml', '${relProjDirPath}/**/*.check.yaml']`;
   const yamlComparisonGlobPatterns = `['${relProjDirPath}/**/comparisons/*.yaml']`;
-  const outDir = relative3(root, prepDir);
+  const outDir = relative4(root, prepDir);
   return {
     // Don't use an external config file
     configFile: false,
@@ -588,26 +725,12 @@ var CheckPlugin = class {
   }
   async watch(config) {
     if (this.options?.testConfigPath === void 0) {
-      await this.genTestConfig(config, "watch");
+      await this.genTestConfig("watch", config);
     }
-    const testOptions = this.resolveTestOptions(config);
-    const viteConfig = this.createViteConfigForReport(config, testOptions, void 0);
+    const testOptions = await this.resolveTestOptions("watch", config);
+    const viteConfig = await this.createViteConfigForReport("watch", config, testOptions, void 0);
     const server = await createServer(viteConfig);
     await server.listen();
-    const baselinesDir = "baselines";
-    const watcher = chokidar.watch(baselinesDir, {
-      // Watch paths are resolved relative to the project root directory
-      cwd: config.rootDir,
-      // Don't send initial "file added" events
-      ignoreInitial: true,
-      // XXX: Include a delay, otherwise on macOS we sometimes get multiple
-      // change events when a file is saved just once
-      awaitWriteFinish: {
-        stabilityThreshold: 200
-      }
-    });
-    watcher.on("add", () => server.restart());
-    watcher.on("unlink", () => server.restart());
   }
   // TODO: Note that this plugin runs as a `postBuild` step because it currently
   // needs to run after other plugins, and those plugins need to run after the
@@ -617,7 +740,7 @@ var CheckPlugin = class {
   async postBuild(context, modelSpec) {
     const firstBuild = this.firstBuild;
     this.firstBuild = false;
-    if (this.options?.current === void 0) {
+    if (this.options?.current?.path === void 0 && this.options?.current?.url === void 0) {
       if (context.config.mode === "development") {
         await this.copyPreviousBundle(context.config);
       }
@@ -627,24 +750,24 @@ var CheckPlugin = class {
     if (this.options?.testConfigPath === void 0) {
       if (context.config.mode === "production" || firstBuild) {
         context.log("info", "Generating model check test configuration...");
-        await this.genTestConfig(context.config, "build");
+        await this.genTestConfig("bundle", context.config);
       }
     }
     if (context.config.mode === "production") {
-      const testOptions = this.resolveTestOptions(context.config);
+      const testOptions = await this.resolveTestOptions("bundle", context.config);
       return this.runChecks(context, testOptions);
     } else {
       return true;
     }
   }
   async copyPreviousBundle(config) {
-    const currentBundleFile = joinPath3(config.prepDir, "check-bundle.js");
+    const currentBundleFile = joinPath5(config.prepDir, "check-bundle.js");
     if (existsSync3(currentBundleFile)) {
-      const baselinesDir = joinPath3(config.rootDir, "baselines");
-      if (!existsSync3(baselinesDir)) {
-        await mkdir(baselinesDir, { recursive: true });
+      const bundlesDir = joinPath5(config.rootDir, "bundles");
+      if (!existsSync3(bundlesDir)) {
+        await mkdir2(bundlesDir, { recursive: true });
       }
-      const previousBundleFile = joinPath3(baselinesDir, "previous.js");
+      const previousBundleFile = joinPath5(bundlesDir, "previous.js");
       await copyFile(currentBundleFile, previousBundleFile);
     }
   }
@@ -652,25 +775,32 @@ var CheckPlugin = class {
     const viteConfig = await createViteConfigForBundle(context, modelSpec);
     await build(viteConfig);
   }
-  async genTestConfig(config, mode) {
+  async genTestConfig(mode, config) {
     const rootDir = config.rootDir;
     const prepDir = config.prepDir;
-    const viteConfig = createViteConfigForTests(rootDir, prepDir, mode);
+    const viteConfig = createViteConfigForTests(mode, rootDir, prepDir);
     await build(viteConfig);
   }
   async runChecks(context, testOptions) {
     context.log("info", "Running model checks...");
-    const moduleR = await import(relativeToSourcePath(testOptions.currentBundlePath));
+    async function importBundleModule(bundleSpec) {
+      return import(relativeToSourcePath(bundleSpec.path));
+    }
+    const moduleR = await importBundleModule(testOptions.currentBundleSpec);
     const bundleR = moduleR.createBundle();
-    const bundleNameR = testOptions.currentBundleName;
+    const bundleNameR = testOptions.currentBundleSpec.name;
     let bundleL;
     let bundleNameL;
-    if (this.options?.baseline) {
-      const moduleL = await import(relativeToSourcePath(this.options.baseline.path));
+    if (testOptions.baselineBundleSpec !== void 0) {
+      const moduleL = await importBundleModule(testOptions.baselineBundleSpec);
       const rawBundleL = moduleL.createBundle();
       if (rawBundleL.version === bundleR.version) {
         bundleL = rawBundleL;
-        bundleNameL = this.options.baseline.name;
+        bundleNameL = testOptions.baselineBundleSpec.name || "base";
+      } else {
+        console.warn(
+          `WARNING: Bundle version mismatch (baseline=${rawBundleL.version} current=${bundleR.version}); check tests will be run but comparisons will be skipped`
+        );
       }
     }
     const testConfigModule = await import(relativeToSourcePath(testOptions.testConfigPath));
@@ -687,47 +817,79 @@ var CheckPlugin = class {
       false
     );
     context.log("info", "Building model check report");
-    const viteConfig = this.createViteConfigForReport(context.config, testOptions, result.suiteSummary);
+    const viteConfig = await this.createViteConfigForReport("bundle", context.config, testOptions, result.suiteSummary);
     await build(viteConfig);
     return result.allChecksPassed;
   }
-  resolveTestOptions(config) {
-    let currentBundleName;
-    let currentBundlePath;
-    if (this.options?.current === void 0) {
-      currentBundleName = "current";
-      currentBundlePath = joinPath3(config.prepDir, "check-bundle.js");
-    } else {
-      currentBundleName = this.options.current.name;
-      currentBundlePath = this.options.current.path;
+  async resolveTestOptions(mode, config) {
+    async function resolveBundle(bundle) {
+      if (bundle?.url !== void 0) {
+        const localBundlePath = await downloadBundle(
+          bundle.url,
+          bundle.name,
+          // TODO: We don't know the last modified time of the remote bundle here, so we use
+          // undefined (which means the local file will be created with the current timestamp)
+          void 0,
+          joinPath5(config.rootDir, "bundles")
+        );
+        return {
+          name: bundle.name,
+          path: localBundlePath
+        };
+      } else if (bundle?.path !== void 0) {
+        return {
+          name: bundle.name,
+          path: bundle.path
+        };
+      } else {
+        return {
+          name: bundle?.name || "current",
+          path: joinPath5(config.prepDir, "check-bundle.js")
+        };
+      }
+    }
+    const currentBundleSpec = await resolveBundle(this.options?.current);
+    let baselineBundleSpec;
+    if (mode === "bundle" && this.options?.baseline) {
+      try {
+        baselineBundleSpec = await resolveBundle(this.options.baseline);
+      } catch (e) {
+        const name = this.options.baseline.name;
+        const loc = this.options.baseline.url || this.options.baseline.path;
+        console.warn(
+          `WARNING: Failed to load '${name}' bundle from '${loc}'; check tests will be run but comparisons will be skipped. Cause:`,
+          e
+        );
+      }
     }
     let testConfigPath;
     if (this.options?.testConfigPath === void 0) {
-      testConfigPath = joinPath3(config.prepDir, "check-tests.js");
+      testConfigPath = joinPath5(config.prepDir, "check-tests.js");
     } else {
       testConfigPath = this.options.testConfigPath;
     }
     return {
-      currentBundleName,
-      currentBundlePath,
+      currentBundleSpec,
+      baselineBundleSpec,
       testConfigPath
     };
   }
-  createViteConfigForReport(config, testOptions, suiteSummary) {
+  async createViteConfigForReport(mode, config, testOptions, suiteSummary) {
     return createViteConfigForReport(
+      mode,
       this.options,
       config.rootDir,
       config.prepDir,
-      testOptions.currentBundleName,
-      testOptions.currentBundlePath,
+      testOptions.currentBundleSpec,
+      testOptions.baselineBundleSpec,
       testOptions.testConfigPath,
       suiteSummary
     );
   }
 };
 function relativeToSourcePath(filePath) {
-  const srcDir = dirname4(fileURLToPath4(import.meta.url));
-  const relPath = relative4(srcDir, filePath);
+  const srcDir = dirname5(fileURLToPath4(import.meta.url));
+  const relPath = relative5(srcDir, filePath);
   return relPath.replaceAll("\\", "/");
 }
 export {