@sdeverywhere/plugin-check 0.3.19 → 0.3.21

package/bin/sde-check.js

@@ -11,8 +11,7 @@ import { join as joinPath } from 'path'
 function printUsage() {
   console.log()
   console.log('Usage:')
-  console.log('  sim-check baseline --save\t\tcopy the latest bundle to the `baselines` directory')
-  // console.log('  sim-check baseline --clear-all\tremove all bundles from the `baselines` directory')
+  console.log('  sde-check save-current-bundle\t\tcopy the latest bundle to the `bundles` directory')
   console.log()
 }
 
@@ -31,19 +30,14 @@ function timestamp() {
 }
 
 const args = process.argv.slice(2)
-if (args.length !== 2 || args[0] !== 'baseline') {
-  printUsage()
-  process.exit(1)
-}
-
-if (args[1] !== '--save') {
+if (args.length !== 2 || args[0] !== 'save-current-bundle') {
   printUsage()
   process.exit(1)
 }
 
 // TODO: For now we make a number of assumptions (e.g., that the bundle will be copied to
-// the `baselines` directory under the current working directory, that the bundle filename
-// will contain the current timestamp); should make these configurable
+// the `bundles` directory under the current working directory, that the bundle filename
+// will contain the current timestamp); we should make these configurable
 const prepDir = joinPath(process.cwd(), 'sde-prep')
 const srcBundleFile = joinPath(prepDir, 'check-bundle.js')
 if (!existsSync(srcBundleFile)) {
@@ -51,10 +45,10 @@ if (!existsSync(srcBundleFile)) {
   process.exit(1)
 }
 
-const baselinesDir = joinPath(process.cwd(), 'baselines')
-if (!existsSync(baselinesDir)) {
-  mkdirSync(baselinesDir, { recursive: true })
+const bundlesDir = joinPath(process.cwd(), 'bundles')
+if (!existsSync(bundlesDir)) {
+  mkdirSync(bundlesDir, { recursive: true })
 }
 
-const dstBundleFile = joinPath(baselinesDir, `${timestamp()}.js`)
+const dstBundleFile = joinPath(bundlesDir, `${timestamp()}.js`)
 copyFileSync(srcBundleFile, dstBundleFile)

package/dist/index.cjs

@@ -27,24 +27,65 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   checkPlugin: () => checkPlugin
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/tsup@8.2.4_postcss@8.5.6_typescript@5.2.2/node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.2.2/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/plugin.ts
-var import_fs3 = require("fs");
-var import_promises = require("fs/promises");
-var import_path4 = require("path");
-var import_url4 = require("url");
+var import_node_fs2 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path4 = require("path");
+var import_url3 = require("url");
 var import_vite = require("vite");
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_check_core2 = require("@sdeverywhere/check-core");
+var import_check_core3 = require("@sdeverywhere/check-core");
+
+// src/bundle-file-ops.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("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 = (0, import_node_path.join)(bundlesDir, ...nameParts) + ".js";
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(filePath), { recursive: true });
+  await (0, import_promises.writeFile)(filePath, bundleContent, "utf8");
+  if (lastModified) {
+    const mtime = new Date(lastModified);
+    await (0, import_promises.utimes)(filePath, mtime, mtime);
+  }
+  return filePath;
+}
+async function copyBundle(url, newName, bundlesDir) {
+  let srcPath;
+  if (url === "current") {
+    const sdePrepDir = (0, import_node_path.join)(bundlesDir, "..", "sde-prep");
+    srcPath = (0, import_node_path.join)(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 (0, import_promises.readFile)(srcPath, "utf8");
+  const stats = await (0, import_promises.stat)(srcPath);
+  const sourceLastModified = stats.mtime;
+  const nameParts = newName.split("/");
+  const filePath = (0, import_node_path.join)(bundlesDir, ...nameParts) + ".js";
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(filePath), { recursive: true });
+  await (0, import_promises.writeFile)(filePath, bundleContent, "utf8");
+  if (sourceLastModified) {
+    await (0, import_promises.utimes)(filePath, sourceLastModified, sourceLastModified);
+  }
+  return filePath;
+}
 
 // src/run-suite.ts
 var import_perf_hooks = require("perf_hooks");
@@ -66,14 +107,15 @@ async function runTestSuite(context, config, verbose) {
       onComplete: (report) => {
         try {
           const t1 = import_perf_hooks.performance.now();
-          const elapsed = ((t1 - t0) / 1e3).toFixed(1);
+          const elapsedMillis = t1 - t0;
+          const elapsedSeconds = (elapsedMillis / 1e3).toFixed(1);
           context.log("info", `
-Test suite completed in ${elapsed}s`);
+Test suite completed in ${elapsedSeconds}s`);
           const allChecksPassed = printCheckSummary(context, report.checkReport, verbose);
           if (report.comparisonReport) {
             printPerfStats(context, config.comparison, report.comparisonReport);
           }
-          const suiteSummary = (0, import_check_core.suiteSummaryFromReport)(report);
+          const suiteSummary = (0, import_check_core.suiteSummaryFromReport)(report, elapsedMillis);
           resolve({
             allChecksPassed,
             suiteSummary
@@ -105,6 +147,9 @@ function printCheckSummary(context, checkReport, verbose) {
       case "error":
         statusChar = "\u203C";
         break;
+      case "skipped":
+        statusChar = "\u2013";
+        break;
       default:
         statusChar = "";
         break;
@@ -143,13 +188,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) {
@@ -166,9 +211,11 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_url = require("url");
 var import_plugin_node_resolve = require("@rollup/plugin-node-resolve");
+var import_check_core2 = require("@sdeverywhere/check-core");
 var __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
 var __dirname = (0, import_path.dirname)(__filename2);
 function injectModelSpec(context, modelSpec) {
+  const prepDir = context.config.prepDir;
   const inputSpecs = [];
   for (const modelInputSpec of modelSpec.inputs) {
     if (modelInputSpec.defaultValue === void 0 || modelInputSpec.minValue === void 0 || modelInputSpec.maxValue === void 0) {
@@ -194,8 +241,19 @@ function injectModelSpec(context, modelSpec) {
       ...o
     };
   });
+  function readJsonListing() {
+    const path = (0, import_path.join)(prepDir, "build", "processed.json");
+    if ((0, import_fs.existsSync)(path)) {
+      const json = (0, import_fs.readFileSync)(path, "utf8");
+      return JSON.parse(json);
+    } else {
+      return {};
+    }
+  }
+  const listing = readJsonListing();
+  const varInstances = listing.varInstances || {};
+  const encodedImplVars = (0, import_check_core2.encodeImplVars)(varInstances);
   function stagedFileSize(filename) {
-    const prepDir = context.config.prepDir;
     const path = (0, import_path.join)(prepDir, "staged", "model", filename);
     if ((0, import_fs.existsSync)(path)) {
       return (0, import_fs.statSync)(path).size;
@@ -208,6 +266,7 @@ function injectModelSpec(context, modelSpec) {
   const moduleSrc = `
 export const inputSpecs = ${JSON.stringify(inputSpecs)};
 export const outputSpecs = ${JSON.stringify(outputSpecs)};
+export const encodedImplVars = ${JSON.stringify(encodedImplVars)};
 export const modelSizeInBytes = ${modelSizeInBytes};
 export const dataSizeInBytes = ${dataSizeInBytes};
 `;
@@ -285,7 +344,9 @@ async function createViteConfigForBundle(context, modelSpec) {
           replacement: "threads",
           customResolver: async function(source, importer, options) {
             const customResolver = (0, import_plugin_node_resolve.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 {
@@ -349,29 +410,116 @@ let __non_webpack_require__ = () => {
 }
 
 // src/vite-config-for-report.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_url2 = require("url");
+var import_node_fs = require("fs");
+var import_node_path3 = require("path");
+var import_node_url2 = require("url");
 var import_plugin_replace = __toESM(require("@rollup/plugin-replace"), 1);
-var __filename3 = (0, import_url2.fileURLToPath)(importMetaUrl);
-var __dirname2 = (0, import_path2.dirname)(__filename3);
-function createViteConfigForReport(options, projDir, prepDir, currentBundleName, currentBundlePath, testConfigPath, suiteSummary) {
-  const root = (0, import_path2.resolve)(__dirname2, "..", "template-report");
-  const baselinesDir = (0, import_path2.resolve)(projDir, "baselines");
-  if (!(0, import_fs2.existsSync)(baselinesDir)) {
-    (0, import_fs2.mkdirSync)(baselinesDir, { recursive: true });
+
+// src/vite-local-bundles-plugin.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+var import_chokidar = __toESM(require("chokidar"), 1);
+function localBundlesPlugin(bundlesDir) {
+  return {
+    name: "sde-local-bundles",
+    configureServer(server) {
+      const watcher = import_chokidar.default.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 (0, import_promises2.readdir)(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = (0, import_node_path2.join)(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 (0, import_promises2.stat)(fullPath);
+      const relativePath = (0, import_node_path2.relative)(baseDir, fullPath);
+      const name = relativePath.replace(/\.js$/, "").split(import_node_path2.sep).join("/");
+      bundles.push({
+        name,
+        url: (0, import_node_url.pathToFileURL)(fullPath).toString(),
+        lastModified: stats.mtime.toISOString()
+      });
+    }
   }
-  const templateSrcDir = (0, import_path2.resolve)(root, "src");
-  const relProjDir = (0, import_path2.relative)(templateSrcDir, projDir);
+  return bundles;
+}
+
+// src/vite-config-for-report.ts
+var __filename3 = (0, import_node_url2.fileURLToPath)(importMetaUrl);
+var __dirname2 = (0, import_node_path3.dirname)(__filename3);
+function createViteConfigForReport(mode, options, projDir, prepDir, currentBundleSpec, baselineBundleSpec, testConfigPath, suiteSummary) {
+  const root = (0, import_node_path3.resolve)(__dirname2, "..", "template-report");
+  const bundlesDir = (0, import_node_path3.resolve)(projDir, "bundles");
+  if (!(0, import_node_fs.existsSync)(bundlesDir)) {
+    (0, import_node_fs.mkdirSync)(bundlesDir, { recursive: true });
+  }
+  const templateSrcDir = (0, import_node_path3.resolve)(root, "src");
+  const relProjDir = (0, import_node_path3.relative)(templateSrcDir, projDir);
   const relProjDirPath = relProjDir.replaceAll("\\", "/");
-  const baselinesPath = `${relProjDirPath}/baselines/*.js`;
+  const bundlesPath = `${relProjDirPath}/bundles/*.js`;
+  const currentBundleLastModified = (0, import_node_fs.statSync)(currentBundleSpec.path).mtime.toISOString();
   let reportPath;
   if (options?.reportPath) {
     reportPath = options.reportPath;
   } else {
-    reportPath = (0, import_path2.join)(prepDir, "check-report");
+    reportPath = (0, import_node_path3.join)(prepDir, "check-report");
   }
-  const outDir = (0, import_path2.relative)(root, reportPath);
+  const outDir = (0, import_node_path3.relative)(root, reportPath);
   const suiteSummaryJson = suiteSummary ? JSON.stringify(suiteSummary) : "";
   const alias = (find, replacement) => {
     return {
@@ -396,7 +544,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: (0, import_path2.join)(prepDir, ".vite-check-report"),
+    cacheDir: (0, import_node_path3.join)(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
@@ -443,9 +591,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
@@ -465,10 +613,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
@@ -480,15 +632,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`);
@@ -527,19 +682,19 @@ function createViteConfigForReport(options, projDir, prepDir, currentBundleName,
 }
 
 // src/vite-config-for-tests.ts
-var import_path3 = require("path");
-var import_url3 = require("url");
+var import_path2 = require("path");
+var import_url2 = require("url");
 var import_plugin_replace2 = __toESM(require("@rollup/plugin-replace"), 1);
-var __filename4 = (0, import_url3.fileURLToPath)(importMetaUrl);
-var __dirname3 = (0, import_path3.dirname)(__filename4);
-function createViteConfigForTests(projDir, prepDir, mode) {
-  const root = (0, import_path3.resolve)(__dirname3, "..", "template-tests");
-  const templateSrcDir = (0, import_path3.resolve)(root, "src");
-  const relProjDir = (0, import_path3.relative)(templateSrcDir, projDir);
+var __filename4 = (0, import_url2.fileURLToPath)(importMetaUrl);
+var __dirname3 = (0, import_path2.dirname)(__filename4);
+function createViteConfigForTests(mode, projDir, prepDir) {
+  const root = (0, import_path2.resolve)(__dirname3, "..", "template-tests");
+  const templateSrcDir = (0, import_path2.resolve)(root, "src");
+  const relProjDir = (0, import_path2.relative)(templateSrcDir, projDir);
   const relProjDirPath = relProjDir.replaceAll("\\", "/");
   const yamlCheckGlobPatterns = `['${relProjDirPath}/**/checks/*.yaml', '${relProjDirPath}/**/*.check.yaml']`;
   const yamlComparisonGlobPatterns = `['${relProjDirPath}/**/comparisons/*.yaml']`;
-  const outDir = (0, import_path3.relative)(root, prepDir);
+  const outDir = (0, import_path2.relative)(root, prepDir);
   return {
     // Don't use an external config file
     configFile: false,
@@ -603,26 +758,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 (0, import_vite.createServer)(viteConfig);
     await server.listen();
-    const baselinesDir = "baselines";
-    const watcher = import_chokidar.default.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
@@ -632,7 +773,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);
       }
@@ -642,50 +783,57 @@ 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 = (0, import_path4.join)(config.prepDir, "check-bundle.js");
-    if ((0, import_fs3.existsSync)(currentBundleFile)) {
-      const baselinesDir = (0, import_path4.join)(config.rootDir, "baselines");
-      if (!(0, import_fs3.existsSync)(baselinesDir)) {
-        await (0, import_promises.mkdir)(baselinesDir, { recursive: true });
+    const currentBundleFile = (0, import_node_path4.join)(config.prepDir, "check-bundle.js");
+    if ((0, import_node_fs2.existsSync)(currentBundleFile)) {
+      const bundlesDir = (0, import_node_path4.join)(config.rootDir, "bundles");
+      if (!(0, import_node_fs2.existsSync)(bundlesDir)) {
+        await (0, import_promises3.mkdir)(bundlesDir, { recursive: true });
       }
-      const previousBundleFile = (0, import_path4.join)(baselinesDir, "previous.js");
-      await (0, import_promises.copyFile)(currentBundleFile, previousBundleFile);
+      const previousBundleFile = (0, import_node_path4.join)(bundlesDir, "previous.js");
+      await (0, import_promises3.copyFile)(currentBundleFile, previousBundleFile);
     }
   }
   async genCurrentBundle(context, modelSpec) {
     const viteConfig = await createViteConfigForBundle(context, modelSpec);
     await (0, import_vite.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 (0, import_vite.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));
@@ -694,7 +842,7 @@ var CheckPlugin = class {
       bundleNameR
     };
     const configOptions = await testConfigModule.getConfigOptions(bundleL, bundleR, configInitOptions);
-    const checkConfig = await (0, import_check_core2.createConfig)(configOptions);
+    const checkConfig = await (0, import_check_core3.createConfig)(configOptions);
     const result = await runTestSuite(
       context,
       checkConfig,
@@ -702,47 +850,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 (0, import_vite.build)(viteConfig);
     return result.allChecksPassed;
   }
-  resolveTestOptions(config) {
-    let currentBundleName;
-    let currentBundlePath;
-    if (this.options?.current === void 0) {
-      currentBundleName = "current";
-      currentBundlePath = (0, import_path4.join)(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,
+          (0, import_node_path4.join)(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: (0, import_node_path4.join)(config.prepDir, "check-bundle.js")
+        };
+      }
+    }
+    const currentBundleSpec = await resolveBundle(mode === "bundle" ? this.options?.current : void 0);
+    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 = (0, import_path4.join)(config.prepDir, "check-tests.js");
+      testConfigPath = (0, import_node_path4.join)(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 = (0, import_path4.dirname)((0, import_url4.fileURLToPath)(importMetaUrl));
-  const relPath = (0, import_path4.relative)(srcDir, filePath);
+  const srcDir = (0, import_node_path4.dirname)((0, import_url3.fileURLToPath)(importMetaUrl));
+  const relPath = (0, import_node_path4.relative)(srcDir, filePath);
   return relPath.replaceAll("\\", "/");
 }
 // Annotate the CommonJS export names for ESM import in node: