@sdeverywhere/plugin-check 0.3.36 → 0.3.38

package/dist/index.js

@@ -1,938 +1,699 @@
-// src/plugin.ts
-import { existsSync as existsSync3 } from "fs";
-import { copyFile, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname5, join as joinPath5, relative as relative5 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { existsSync, mkdirSync } from "node:fs";
+import { copyFile, mkdir, readFile, readdir, stat, utimes, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "url";
 import { build, createServer } from "vite";
-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";
+import { createConfig, datasetMessage, encodeImplVars, predicateMessage, runSuite, scenarioMessage, suiteSummaryFromReport } from "@sdeverywhere/check-core";
+import { performance } from "perf_hooks";
+import pico from "picocolors";
+import { existsSync as existsSync$1, readFileSync, statSync } from "fs";
+import { dirname as dirname$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
+import { fileURLToPath as fileURLToPath$1, pathToFileURL } from "node:url";
+import chokidar from "chokidar";
+//#region src/bundle-file-ops.ts
+/**
+* Download a bundle from a remote URL and save it to the local bundles directory.
+*
+* @param url The remote URL to download the bundle from.
+* @param name The bundle name (may contain slashes for subdirectories).
+* @param lastModified The last modified timestamp from the remote bundle.
+* @param bundlesDir The bundles directory path.
+* @param fetchRemoteBundle Optional custom function for fetching remote bundle files.
+* @returns The file path where the bundle was saved.
+*/
 async function downloadBundle(url, name, lastModified, bundlesDir, fetchRemoteBundle) {
-  const fullUrl = `${url}?cb=${Date.now()}`;
-  let bundleContent;
-  if (fetchRemoteBundle) {
-    bundleContent = await fetchRemoteBundle(fullUrl);
-  } else {
-    const response = await fetch(fullUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch bundle: HTTP ${response.status} ${response.statusText}`);
-    }
-    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;
+	const fullUrl = `${url}?cb=${Date.now()}`;
+	let bundleContent;
+	if (fetchRemoteBundle) bundleContent = await fetchRemoteBundle(fullUrl);
+	else {
+		const response = await fetch(fullUrl);
+		if (!response.ok) throw new Error(`Failed to fetch bundle: HTTP ${response.status} ${response.statusText}`);
+		bundleContent = await response.text();
+	}
+	const nameParts = name.split("/");
+	const filePath = join(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;
 }
+/**
+* Copy a bundle from a source URL and save it with a new name to the local bundles directory.
+*
+* @param url The source URL to copy the bundle from (can be 'current' or file:// URLs).
+* @param newName The new bundle name (may contain slashes for subdirectories).
+* @param bundlesDir The bundles directory path.
+* @returns The file path where the bundle was saved.
+*/
 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;
+	let srcPath;
+	if (url === "current") {
+		const sdePrepDir = join(bundlesDir, "..", "sde-prep");
+		srcPath = 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 readFile(srcPath, "utf8");
+	const sourceLastModified = (await stat(srcPath)).mtime;
+	const nameParts = newName.split("/");
+	const filePath = join(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";
-import {
-  datasetMessage,
-  predicateMessage,
-  runSuite,
-  scenarioMessage,
-  suiteSummaryFromReport
-} from "@sdeverywhere/check-core";
+//#endregion
+//#region src/run-suite.ts
+/**
+* Runs the test suite.
+*/
 async function runTestSuite(context, config, verbose) {
-  return new Promise((resolve, reject) => {
-    const t0 = performance.now();
-    let lastPctByInc;
-    const callbacks = {
-      onProgress: (progress) => {
-        const pct = Math.round(progress * 100);
-        const pctByInc = Math.floor(pct / 5) * 5;
-        if (lastPctByInc === void 0 || pctByInc > lastPctByInc) {
-          lastPctByInc = pctByInc;
-          context.log("info", `${pctByInc}%`);
-        }
-      },
-      onComplete: (report) => {
-        try {
-          const t1 = performance.now();
-          const elapsedMillis = t1 - t0;
-          const elapsedSeconds = (elapsedMillis / 1e3).toFixed(1);
-          context.log("info", `
-Test suite completed in ${elapsedSeconds}s`);
-          const allChecksPassed = printCheckSummary(context, report.checkReport, verbose);
-          if (report.comparisonReport) {
-            printPerfStats(context, config.comparison, report.comparisonReport);
-          }
-          const suiteSummary = suiteSummaryFromReport(report, elapsedMillis);
-          resolve({
-            allChecksPassed,
-            suiteSummary
-          });
-        } catch (e) {
-          reject(e);
-        }
-      },
-      onError: (error) => {
-        reject(error);
-      }
-    };
-    runSuite(config, callbacks);
-  });
+	return new Promise((resolve, reject) => {
+		const t0 = performance.now();
+		let lastPctByInc;
+		runSuite(config, {
+			onProgress: (progress) => {
+				const pct = Math.round(progress * 100);
+				const pctByInc = Math.floor(pct / 5) * 5;
+				if (lastPctByInc === void 0 || pctByInc > lastPctByInc) {
+					lastPctByInc = pctByInc;
+					context.log("info", `${pctByInc}%`);
+				}
+			},
+			onComplete: (report) => {
+				try {
+					const elapsedMillis = performance.now() - t0;
+					const elapsedSeconds = (elapsedMillis / 1e3).toFixed(1);
+					context.log("info", `\nTest suite completed in ${elapsedSeconds}s`);
+					const allChecksPassed = printCheckSummary(context, report.checkReport, verbose);
+					if (report.comparisonReport) printPerfStats(context, config.comparison, report.comparisonReport);
+					resolve({
+						allChecksPassed,
+						suiteSummary: suiteSummaryFromReport(report, elapsedMillis)
+					});
+				} catch (e) {
+					reject(e);
+				}
+			},
+			onError: (error) => {
+				reject(error);
+			}
+		});
+	});
 }
 function printCheckSummary(context, checkReport, verbose) {
-  function printResult(indent, status, text) {
-    if (!verbose && status === "passed" && indent > 1) {
-      return;
-    }
-    let statusChar;
-    switch (status) {
-      case "passed":
-        statusChar = "\u2713";
-        break;
-      case "failed":
-        statusChar = "\u2717";
-        break;
-      case "error":
-        statusChar = "\u203C";
-        break;
-      case "skipped":
-        statusChar = "\u2013";
-        break;
-      default:
-        statusChar = "";
-        break;
-    }
-    const msg = `${"  ".repeat(indent)}${statusChar} ${text}`;
-    context.log("info", status === "passed" ? pico.green(msg) : pico.red(msg));
-  }
-  function bold(s) {
-    return pico.bold(s);
-  }
-  function printTest(test) {
-    const msg = `${test.name}${verbose || test.status !== "passed" ? ":" : ""}`;
-    printResult(1, test.status, msg);
-  }
-  let allPassed = true;
-  context.log("info", "\nCheck results:");
-  for (const group of checkReport.groups) {
-    context.log("info", `
-${group.name}`);
-    for (const test of group.tests) {
-      if (test.status !== "passed") {
-        allPassed = false;
-      }
-      printTest(test);
-      for (const scenario of test.scenarios) {
-        printResult(3, scenario.status, scenarioMessage(scenario, bold));
-        for (const dataset of scenario.datasets) {
-          printResult(5, dataset.status, datasetMessage(dataset, bold));
-          for (const predicate of dataset.predicates) {
-            printResult(7, predicate.result.status, predicateMessage(predicate, bold));
-          }
-        }
-      }
-    }
-  }
-  context.log("info", "");
-  return allPassed;
+	function printResult(indent, status, text) {
+		if (!verbose && status === "passed" && indent > 1) return;
+		let statusChar;
+		switch (status) {
+			case "passed":
+				statusChar = "✓";
+				break;
+			case "failed":
+				statusChar = "✗";
+				break;
+			case "error":
+				statusChar = "‼";
+				break;
+			case "skipped":
+				statusChar = "–";
+				break;
+			default: statusChar = "";
+		}
+		const msg = `${"  ".repeat(indent)}${statusChar} ${text}`;
+		context.log("info", status === "passed" ? pico.green(msg) : pico.red(msg));
+	}
+	function bold(s) {
+		return pico.bold(s);
+	}
+	function printTest(test) {
+		const msg = `${test.name}${verbose || test.status !== "passed" ? ":" : ""}`;
+		printResult(1, test.status, msg);
+	}
+	let allPassed = true;
+	context.log("info", "\nCheck results:");
+	for (const group of checkReport.groups) {
+		context.log("info", `\n${group.name}`);
+		for (const test of group.tests) {
+			if (test.status !== "passed") allPassed = false;
+			printTest(test);
+			for (const scenario of test.scenarios) {
+				printResult(3, scenario.status, scenarioMessage(scenario, bold));
+				for (const dataset of scenario.datasets) {
+					printResult(5, dataset.status, datasetMessage(dataset, bold));
+					for (const predicate of dataset.predicates) printResult(7, predicate.result.status, predicateMessage(predicate, bold));
+				}
+			}
+		}
+	}
+	context.log("info", "");
+	return allPassed;
 }
-function stat2(label, n) {
-  return `${label}=${n.toFixed(1)}ms`;
+function stat$1(label, n) {
+	return `${label}=${n.toFixed(1)}ms`;
 }
 function printPerfReportLine(context, perfReport) {
-  const avg = stat2("avg", perfReport.avgTime);
-  const min = stat2("min", perfReport.minTime);
-  const max = stat2("max", perfReport.maxTime);
-  context.log("info", `    ${avg} ${min} ${max}`);
+	const avg = stat$1("avg", perfReport.avgTime);
+	const min = stat$1("min", perfReport.minTime);
+	const max = stat$1("max", perfReport.maxTime);
+	context.log("info", `    ${avg} ${min} ${max}`);
 }
 function printPerfStats(context, comparisonConfig, report) {
-  context.log("info", "\nPerformance stats:");
-  context.log("info", `  ${comparisonConfig.bundleL.name}:`);
-  printPerfReportLine(context, report.perfReportL);
-  context.log("info", `  ${comparisonConfig.bundleR.name}:`);
-  printPerfReportLine(context, report.perfReportR);
-  context.log("info", "");
+	context.log("info", "\nPerformance stats:");
+	context.log("info", `  ${comparisonConfig.bundleL.name}:`);
+	printPerfReportLine(context, report.perfReportL);
+	context.log("info", `  ${comparisonConfig.bundleR.name}:`);
+	printPerfReportLine(context, report.perfReportR);
+	context.log("info", "");
 }
-
-// src/vite-config-for-bundle.ts
-import { existsSync, readFileSync, statSync } from "fs";
-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 = dirname2(__filename2);
+//#endregion
+//#region src/vite-config-for-bundle.ts
+const __filename$2 = fileURLToPath(import.meta.url);
+const __dirname$2 = dirname$1(__filename$2);
+/**
+* This is a virtual module plugin used to inject model-specific configuration
+* values into the generated worker bundle.
+*
+* This follows the "Virtual Modules Convention" described here:
+*   https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+*
+* TODO: This could be simplified by using `vite-plugin-virtual` but that
+* doesn't seem to be working correctly in an ESM setting
+*/
 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) {
-      let msg = "";
-      msg += `WARNING: The {defaultValue,minValue,maxValue} properties are required by plugin-check, `;
-      msg += `but are undefined in the InputSpec for '${modelInputSpec.varName}'. `;
-      msg += `This input variable will be excluded from the model-check bundle until those properties `;
-      msg += `are defined.`;
-      console.warn(msg);
-      continue;
-    }
-    const varId = context.canonicalVarId(modelInputSpec.varName);
-    const inputId = modelInputSpec.inputId || varId;
-    inputSpecs.push({
-      inputId,
-      varId,
-      ...modelInputSpec
-    });
-  }
-  const outputSpecs = modelSpec.outputs.map((o) => {
-    return {
-      varId: context.canonicalVarId(o.varName),
-      ...o
-    };
-  });
-  function readJsonListing() {
-    const path = joinPath2(prepDir, "build", "processed.json");
-    if (existsSync(path)) {
-      const json = readFileSync(path, "utf8");
-      return JSON.parse(json);
-    } else {
-      return {};
-    }
-  }
-  const listing = readJsonListing();
-  const varInstances = listing.varInstances || {};
-  const encodedImplVars = encodeImplVars(varInstances);
-  function stagedFileSize(filename) {
-    const path = joinPath2(prepDir, "staged", "model", filename);
-    if (existsSync(path)) {
-      return statSync(path).size;
-    } else {
-      return 0;
-    }
-  }
-  const modelSizeInBytes = stagedFileSize("generated-model.js");
-  const dataSizeInBytes = stagedFileSize("static-data.ts");
-  const moduleSrc = `
+	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) {
+			let msg = "";
+			msg += `WARNING: The {defaultValue,minValue,maxValue} properties are required by plugin-check, `;
+			msg += `but are undefined in the InputSpec for '${modelInputSpec.varName}'. `;
+			msg += `This input variable will be excluded from the model-check bundle until those properties `;
+			msg += `are defined.`;
+			console.warn(msg);
+			continue;
+		}
+		const varId = context.canonicalVarId(modelInputSpec.varName);
+		const inputId = modelInputSpec.inputId || varId;
+		inputSpecs.push({
+			inputId,
+			varId,
+			...modelInputSpec
+		});
+	}
+	const outputSpecs = modelSpec.outputs.map((o) => {
+		return {
+			varId: context.canonicalVarId(o.varName),
+			...o
+		};
+	});
+	function readJsonListing() {
+		const path = join$1(prepDir, "build", "processed.json");
+		if (existsSync$1(path)) {
+			const json = readFileSync(path, "utf8");
+			return JSON.parse(json);
+		} else return {};
+	}
+	const varInstances = readJsonListing().varInstances || {};
+	const encodedImplVars = encodeImplVars(varInstances);
+	function stagedFileSize(filename) {
+		const path = join$1(prepDir, "staged", "model", filename);
+		if (existsSync$1(path)) return statSync(path).size;
+		else return 0;
+	}
+	const modelSizeInBytes = stagedFileSize("generated-model.js");
+	const dataSizeInBytes = stagedFileSize("static-data.ts");
+	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};
 `;
-  const virtualModuleId = "virtual:model-spec";
-  const resolvedVirtualModuleId = "\0" + virtualModuleId;
-  return {
-    name: "vite-plugin-virtual-custom",
-    resolveId(id) {
-      if (id === virtualModuleId) {
-        return resolvedVirtualModuleId;
-      }
-    },
-    load(id) {
-      if (id === resolvedVirtualModuleId) {
-        return moduleSrc;
-      }
-    }
-  };
-}
-function overrideViteResolvePlugin(viteConfig) {
-  const resolvePlugin = viteConfig.plugins.find((p) => p.name === "vite:resolve");
-  if (resolvePlugin === void 0) {
-    throw new Error("Failed to locate the built-in vite:resolve plugin");
-  }
-  const originalResolveId = resolvePlugin.resolveId;
-  resolvePlugin.resolveId = async function resolveId(id, importer, options) {
-    if (id.startsWith("./implementation") && importer.includes("threads/dist-esm")) {
-      const idFileName = id.replace("./", "");
-      const importerFileName = basename(importer);
-      const resolvedId = importer.replace(importerFileName, `${idFileName}.js`);
-      return {
-        id: resolvedId,
-        moduleSideEffects: false
-      };
-    }
-    return await originalResolveId.handler.call(this, id, importer, options);
-  };
+	const virtualModuleId = "virtual:model-spec";
+	const resolvedVirtualModuleId = "\0" + virtualModuleId;
+	return {
+		name: "vite-plugin-virtual-custom",
+		resolveId(id) {
+			if (id === virtualModuleId) return resolvedVirtualModuleId;
+		},
+		load(id) {
+			if (id === resolvedVirtualModuleId) return moduleSrc;
+		}
+	};
 }
 async function createViteConfigForBundle(context, modelSpec) {
-  const root = resolvePath(__dirname2, "..", "template-bundle");
-  const prepDir = context.config.prepDir;
-  const outDir = relative(root, prepDir);
-  const modelWorkerPath = joinPath2(prepDir, "staged", "model", "worker.js?raw");
-  return {
-    // Don't use an external config file
-    configFile: false,
-    // Use the root directory configured above
-    root,
-    // Don't clear the screen in dev mode so that we can see builder output
-    clearScreen: false,
-    // TODO: Disable vite output by default?
-    // logLevel: 'silent',
-    // Configure path aliases
-    resolve: {
-      alias: [
-        // Inject the configured model worker
-        {
-          find: "@_model_worker_",
-          replacement: modelWorkerPath
-        },
-        // XXX: Prevent Vite from using the `browser` section of `threads/package.json`
-        // since we want to force the use of the general module (under dist-esm) that chooses
-        // the correct implementation (Web Worker vs worker_threads) at runtime.  Currently
-        // Vite's library mode is browser focused and generally chooses the right imports,
-        // except in the case of the threads package where we want to use the generic
-        // `implementation.js` that chooses between Web Worker and worker_threads at runtime.
-        // Note that we could in theory set `resolve.browserField` to false, but that would
-        // make Vite not use the browser field for all other packages, and there is not
-        // currently a way to tell Vite to use the browser field on a case-by-case basis.
-        // So for now we need this workaround here to make it resolve to `dist-esm`, and then
-        // a second workaround in `overrideViteResolvePlugin` to prevent the resolver from
-        // using the browser field when resolving the threads package.
-        {
-          find: "threads",
-          replacement: "threads",
-          customResolver: async function(source, importer, options) {
-            const customResolver = nodeResolve({ browser: false });
-            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 {
-              return resolved.id.replace("index.mjs", "dist-esm/index.js");
-            }
-          }
-        }
-      ]
-    },
-    plugins: [
-      // Use a virtual module plugin to inject the model spec values
-      injectModelSpec(context, modelSpec),
-      // XXX: Install a wrapper around the built-in `vite:resolve` plugin so that we can
-      // override the default resolver behavior that tries to resolve the `browser` section
-      // of the `package.json` for the threads package.
-      {
-        name: "vite-plugin-override-resolve",
-        configResolved(viteConfig) {
-          overrideViteResolvePlugin(viteConfig);
-        }
-      }
-    ],
-    build: {
-      // Write output files to the configured directory (instead of the default `dist`);
-      // note that this must be relative to the project `root`
-      outDir,
-      emptyOutDir: false,
-      // Uncomment for debugging purposes
-      // minify: false,
-      lib: {
-        entry: "./src/index.ts",
-        formats: ["es"],
-        fileName: () => "check-bundle.js"
-      },
-      rollupOptions: {
-        // Don't transform Node imports used by threads.js
-        external: ["events", "os", "path", "url"],
-        // XXX: Insert custom code at the top of the generated bundle that defines
-        // the special `__non_webpack_require__` function that is used by threads.js
-        // in its Node implementation.  This import ensures that threads.js uses
-        // the native `worker_threads` implementation when using the bundle in a
-        // Node environment.  When importing the bundle for use in the browser,
-        // Vite will transform this import into an empty module due to the empty
-        // polyfill that is configured in `vite-config-for-report.ts`.
-        output: {
-          banner: `
-import * as worker_threads from 'worker_threads'
-let __non_webpack_require__ = () => {
-  return worker_threads;
-};
-`
-        },
-        onwarn: (warning, warn) => {
-          if (warning.code !== "EVAL") {
-            warn(warning);
-          }
-        }
-      }
-    }
-  };
+	const root = resolve$1(__dirname$2, "..", "template-bundle");
+	const prepDir = context.config.prepDir;
+	const outDir = relative$1(root, prepDir);
+	return {
+		configFile: false,
+		root,
+		clearScreen: false,
+		resolve: { alias: [{
+			find: "@_model_worker_",
+			replacement: join$1(prepDir, "staged", "model", "worker.js?raw")
+		}] },
+		plugins: [injectModelSpec(context, modelSpec)],
+		build: {
+			outDir,
+			emptyOutDir: false,
+			lib: {
+				entry: "./src/index.ts",
+				formats: ["es"],
+				fileName: () => "check-bundle.js"
+			}
+		}
+	};
 }
-
-// src/vite-config-for-report.ts
-import { existsSync as existsSync2, mkdirSync } from "fs";
-import { dirname as dirname3, relative as relative3, join as joinPath4, resolve as resolvePath2 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import replace from "@rollup/plugin-replace";
-
-// src/vite-local-bundles-plugin.ts
-import { readdir, readFile as readFile2, stat as stat3 } from "fs/promises";
-import { join as joinPath3, relative as relative2, sep } from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
-import chokidar from "chokidar";
+//#endregion
+//#region src/vite-local-bundles-plugin.ts
+/**
+* Vite plugin that provides a bridge to the model-check report app to allow access
+* to the local bundles directory when running in local development mode.
+*
+* This plugin adds an HMR (Hot Module Replacement) event handler that listens for
+* 'list-bundles' and 'download-bundle' events from the client.
+*
+* Note that when a request fails, the handlers below log only the error message (along
+* with the bundle name and URL) instead of the raw error object, since the latter can
+* produce a long and unhelpful stack trace in the console.  The full message is sent
+* back to the client, which reports it in the browser console.
+*
+* @param bundlesDir The absolute path to the bundles directory.
+* @param currentBundlePath The absolute path to the current bundle file.
+* @param fetchRemoteBundle Optional function for fetching remote bundle files.
+*/
 function localBundlesPlugin(bundlesDir, currentBundlePath, fetchRemoteBundle) {
-  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", (event) => {
-        if (event === "add" || event === "unlink") {
-          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);
-          const currentBundleStats = await stat3(currentBundlePath);
-          bundles.push({
-            name: "current",
-            url: "current",
-            lastModified: currentBundleStats.mtime.toISOString()
-          });
-          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("load-bundle", async (data, client) => {
-        const { url, name } = data;
-        try {
-          let sourceCode;
-          if (url.startsWith("file://")) {
-            const filePath = fileURLToPath2(url);
-            sourceCode = await readFile2(filePath, "utf-8");
-          } else if (url.startsWith("https://") || url.startsWith("http://")) {
-            const fullUrl = `${url}?cb=${Date.now()}`;
-            if (fetchRemoteBundle) {
-              sourceCode = await fetchRemoteBundle(fullUrl);
-            } else {
-              const response = await fetch(fullUrl);
-              if (!response.ok) {
-                throw new Error(`Failed to fetch bundle: ${response.status} ${response.statusText}`);
-              }
-              sourceCode = await response.text();
-            }
-          } else {
-            throw new Error(`Unsupported URL scheme: ${url}`);
-          }
-          client.send("load-bundle-success", { name, url, sourceCode });
-        } catch (error) {
-          console.error(`[sde-local-bundles] Failed to load bundle:`, error);
-          client.send("load-bundle-error", { name, url, 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, fetchRemoteBundle);
-          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 });
-        }
-      });
-    }
-  };
+	return {
+		name: "sde-local-bundles",
+		configureServer(server) {
+			const watcher = chokidar.watch(bundlesDir, {
+				ignoreInitial: true,
+				awaitWriteFinish: { stabilityThreshold: 200 },
+				depth: 10
+			});
+			watcher.on("all", (event) => {
+				if (event === "add" || event === "unlink") 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);
+					const currentBundleStats = await stat(currentBundlePath);
+					bundles.push({
+						name: "current",
+						url: "current",
+						lastModified: currentBundleStats.mtime.toISOString()
+					});
+					client.send("list-bundles-success", { bundles });
+				} catch (error) {
+					console.error(`[sde-local-bundles] Failed to list bundles in ${bundlesDir}: ${error.message}`);
+					client.send("list-bundles-error", { error: error.message });
+				}
+			});
+			server.ws.on("load-bundle", async (data, client) => {
+				const { url, name } = data;
+				try {
+					let sourceCode;
+					if (url.startsWith("file://")) {
+						const filePath = fileURLToPath$1(url);
+						sourceCode = await readFile(filePath, "utf-8");
+					} else if (url.startsWith("https://") || url.startsWith("http://")) {
+						const fullUrl = `${url}?cb=${Date.now()}`;
+						if (fetchRemoteBundle) sourceCode = await fetchRemoteBundle(fullUrl);
+						else {
+							const response = await fetch(fullUrl);
+							if (!response.ok) throw new Error(`Failed to fetch bundle: ${response.status} ${response.statusText}`);
+							sourceCode = await response.text();
+						}
+					} else throw new Error(`Unsupported URL scheme: ${url}`);
+					client.send("load-bundle-success", {
+						name,
+						url,
+						sourceCode
+					});
+				} catch (error) {
+					console.error(`[sde-local-bundles] Failed to load bundle '${name}' from ${url}: ${error.message}`);
+					client.send("load-bundle-error", {
+						name,
+						url,
+						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, fetchRemoteBundle);
+					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 '${name}' from ${url}: ${error.message}`);
+					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 '${name}' to '${newName}': ${error.message}`);
+					client.send("copy-bundle-error", {
+						name,
+						error: error.message
+					});
+				}
+			});
+		}
+	};
 }
+/**
+* Recursively scan a directory for .js files.
+*
+* @param dir The directory to scan.
+* @param baseDir The base directory (used for calculating relative paths).
+* @returns An array of bundle information.
+*/
 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;
+	const bundles = [];
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = 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 stat(fullPath);
+			const name = relative(baseDir, fullPath).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 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname3(__filename3);
+//#endregion
+//#region src/vite-config-for-report.ts
+const __filename$1 = fileURLToPath$1(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+/**
+* NOTE: This function currently only supports creating a Vite config for the
+* model-check report when the current/baseline bundles are local files.  If
+* you want to use remote bundles, you must first download them to the local
+* `bundles` directory and then pass `LocalBundleSpec` instances that include
+* the local bundle file paths.
+*/
 function createViteConfigForReport(mode, options, projDir, prepDir, currentBundleSpec, baselineBundleSpec, testConfigPath, suiteSummary) {
-  const root = resolvePath2(__dirname3, "..", "template-report");
-  const bundlesDir = resolvePath2(projDir, "bundles");
-  if (!existsSync2(bundlesDir)) {
-    mkdirSync(bundlesDir, { recursive: true });
-  }
-  const templateSrcDir = resolvePath2(root, "src");
-  const relProjDir = relative3(templateSrcDir, projDir);
-  const relProjDirPath = relProjDir.replaceAll("\\", "/");
-  const bundlesPath = `${relProjDirPath}/bundles/**/*.js`;
-  let reportPath;
-  if (options?.reportPath) {
-    reportPath = options.reportPath;
-  } else {
-    reportPath = joinPath4(prepDir, "check-report");
-  }
-  const outDir = relative3(root, reportPath);
-  const suiteSummaryJson = suiteSummary ? JSON.stringify(suiteSummary) : "";
-  const alias = (find, replacement) => {
-    return {
-      find,
-      replacement
-    };
-  };
-  const noopPolyfillAlias = (find) => {
-    return {
-      find,
-      replacement: "/polyfills/noop-polyfills.ts"
-    };
-  };
-  return {
-    // Don't use an external config file
-    configFile: false,
-    // Use the root directory configured above
-    root,
-    // Use `.` as the base directory (instead of the default `/`); this controls
-    // how the path to the js/css files are generated in `index.html`
-    base: "",
-    // 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: 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
-    clearScreen: false,
-    // TODO
-    // logLevel: 'silent',
-    optimizeDeps: {
-      // Prevent Vite from examining other html files when scanning entrypoints
-      // for dependency optimization
-      entries: ["index.html"],
-      // XXX: When plugin-check is installed via pnpm, the Vite dev server seems
-      // to have no trouble resolving other dependencies using the optimizeDeps
-      // mechanism.  However, this fails when the package is installed via yarn
-      // or npm (probably due to the fact that the `template-report` directory
-      // is located under the top-level `node_modules` directory); in the browser,
-      // there will be "import not found" errors for the packages referenced below.
-      // As a terrible workaround, explicitly include the direct dependencies so
-      // that Vite optimizes them; this works for pnpm, yarn, and npm.  We should
-      // find a less fragile solution.
-      include: [
-        // from check-core
-        "@sdeverywhere/check-core > assert-never",
-        "@sdeverywhere/check-core > ajv",
-        "@sdeverywhere/check-core > neverthrow",
-        "@sdeverywhere/check-core > yaml",
-        // from check-ui-shell
-        "@sdeverywhere/check-ui-shell > fontfaceobserver",
-        "@sdeverywhere/check-ui-shell > copy-text-to-clipboard",
-        "@sdeverywhere/check-ui-shell > chart.js"
-      ],
-      exclude: [
-        // XXX: The threads.js implementation references `tiny-worker` as an optional
-        // dependency, but it doesn't get used at runtime, so we can just exclude it
-        // so that Vite doesn't complain in dev mode
-        "tiny-worker"
-        // XXX: Similarly, chart.js treats `moment` as an optional dependency, but we
-        // don't use it at runtime; we need to exclude it here, otherwise Vite will
-        // complain about missing dependencies in dev mode
-        // 'moment'
-      ]
-    },
-    // Configure path aliases
-    resolve: {
-      alias: [
-        // Use the configured "baseline" bundle if defined, otherwise use the "empty" bundle
-        // (which will cause comparison tests to be skipped)
-        alias("@_baseline_bundle_", baselineBundleSpec?.path || "/src/empty-bundle.ts"),
-        // Use the configured "current" bundle
-        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
-        alias("@_prep_", prepDir),
-        // XXX: Include no-op polyfills for these modules that are used in the Node-specific
-        // implementation of threads.js; this allows us to use one bundle that works in both
-        // Node and browser environments
-        noopPolyfillAlias("events"),
-        noopPolyfillAlias("fs"),
-        noopPolyfillAlias("os"),
-        noopPolyfillAlias("path"),
-        noopPolyfillAlias("url"),
-        noopPolyfillAlias("worker_threads")
-      ]
-    },
-    // Inject special values into the generated JS
-    define: {
-      // Inject the summary JSON into the build
-      __SUITE_SUMMARY_JSON__: JSON.stringify(suiteSummaryJson),
-      // Inject the baseline bundle name
-      __BASELINE_NAME__: JSON.stringify(baselineBundleSpec?.name || ""),
-      // Inject the current bundle name
-      __CURRENT_NAME__: JSON.stringify(currentBundleSpec.name),
-      // Inject the remote bundles URL
-      __REMOTE_BUNDLES_URL__: JSON.stringify(options?.remoteBundlesUrl || "")
-    },
-    plugins: [
-      // Inject special values into the generated JS
-      // TODO: We currently have to use `@rollup/plugin-replace` instead of Vite's
-      // built-in `define` feature because the latter does not seem to run before
-      // the glob handler (which requires the glob to be injected as a literal)
-      replace({
-        preventAssignment: true,
-        delimiters: ["", ""],
-        values: {
-          // Inject the path for baseline bundles
-          // 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
-          // './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, currentBundleSpec.path, options?.fetchRemoteBundle)] : []
-    ],
-    build: {
-      // Write output files to the configured directory (instead of the default `dist`);
-      // note that this must be relative to the project `root`
-      outDir,
-      // Write js/css files to `public` (instead of the default `<outDir>/assets`)
-      assetsDir: "",
-      rollupOptions: {
-        output: {
-          // XXX: Prevent vite from creating a separate `vendor.js` file
-          manualChunks: void 0
-        },
-        onwarn: (warning, warn) => {
-          if (warning.code !== "EVAL") {
-            warn(warning);
-          }
-        }
-      }
-    },
-    server: {
-      // Run the dev server at `localhost:8081` by default
-      port: options?.serverPort || 8081,
-      // Open the app in the browser by default
-      open: "/index.html",
-      // XXX: Add a small delay, otherwise on macOS we sometimes get multiple
-      // change events when a file is saved just once.  That is a relatively
-      // harmless issue except that it causes redundant messages in the console
-      // and can cause extra churn when refreshing the app.
-      watch: {
-        awaitWriteFinish: {
-          stabilityThreshold: 100
-        }
-      }
-    }
-  };
+	const root = resolve(__dirname$1, "..", "template-report");
+	const bundlesDir = resolve(projDir, "bundles");
+	if (!existsSync(bundlesDir)) mkdirSync(bundlesDir, { recursive: true });
+	let reportPath;
+	if (options?.reportPath) reportPath = options.reportPath;
+	else reportPath = join(prepDir, "check-report");
+	const outDir = relative(root, reportPath);
+	const suiteSummaryJson = suiteSummary ? JSON.stringify(suiteSummary) : "";
+	const alias = (find, replacement) => {
+		return {
+			find,
+			replacement
+		};
+	};
+	const noopPolyfillAlias = (find) => {
+		return {
+			find,
+			replacement: "/polyfills/noop-polyfills.ts"
+		};
+	};
+	return {
+		configFile: false,
+		root,
+		base: "",
+		cacheDir: join(prepDir, ".vite-check-report"),
+		clearScreen: false,
+		optimizeDeps: {
+			entries: ["index.html"],
+			include: [
+				"@sdeverywhere/check-core > assert-never",
+				"@sdeverywhere/check-core > ajv",
+				"@sdeverywhere/check-core > neverthrow",
+				"@sdeverywhere/check-core > yaml",
+				"@sdeverywhere/check-ui-shell > fontfaceobserver",
+				"@sdeverywhere/check-ui-shell > copy-text-to-clipboard",
+				"@sdeverywhere/check-ui-shell > chart.js"
+			],
+			exclude: []
+		},
+		resolve: { alias: [
+			alias("@_baseline_bundle_", baselineBundleSpec?.path || "/src/empty-bundle.ts"),
+			alias("@_current_bundle_", currentBundleSpec.path),
+			alias("@_test_config_", testConfigPath),
+			alias("@_prep_", prepDir),
+			noopPolyfillAlias("events"),
+			noopPolyfillAlias("fs"),
+			noopPolyfillAlias("os"),
+			noopPolyfillAlias("path"),
+			noopPolyfillAlias("url"),
+			noopPolyfillAlias("worker_threads"),
+			noopPolyfillAlias("tiny-worker")
+		] },
+		define: {
+			__SUITE_SUMMARY_JSON__: JSON.stringify(suiteSummaryJson),
+			__BASELINE_NAME__: JSON.stringify(baselineBundleSpec?.name || ""),
+			__CURRENT_NAME__: JSON.stringify(currentBundleSpec.name),
+			__REMOTE_BUNDLES_URL__: JSON.stringify(options?.remoteBundlesUrl || "")
+		},
+		plugins: [...mode === "watch" ? [localBundlesPlugin(bundlesDir, currentBundleSpec.path, options?.fetchRemoteBundle)] : []],
+		build: {
+			outDir,
+			assetsDir: "",
+			rolldownOptions: { checks: { eval: false } }
+		},
+		server: {
+			port: options?.serverPort || 8081,
+			open: "/index.html",
+			watch: { awaitWriteFinish: { stabilityThreshold: 100 } }
+		}
+	};
 }
-
-// src/vite-config-for-tests.ts
-import { dirname as dirname4, relative as relative4, resolve as resolvePath3 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import replace2 from "@rollup/plugin-replace";
-var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname4(__filename4);
+//#endregion
+//#region src/vite-inject-literals-plugin.ts
+/**
+* Return a Vite plugin that replaces literal strings in source files before
+* Vite's own transforms run.
+*
+* This is a minimal replacement for `@rollup/plugin-replace` (as previously
+* configured with empty delimiters, i.e., plain string substitution).  We use
+* this instead of Vite's built-in `define` feature because `define`
+* replacements are not applied before Vite's `import.meta.glob` handler runs,
+* and the glob handler requires the glob pattern to appear as a literal in
+* the source.
+*
+* @param values A map of literal search strings to their replacement strings.
+*/
+function injectLiteralsPlugin(values) {
+	const entries = Object.entries(values);
+	return {
+		name: "vite-plugin-inject-literals",
+		transform(code) {
+			let transformed = code;
+			let changed = false;
+			for (const [find, replacement] of entries) if (transformed.includes(find)) {
+				transformed = transformed.replaceAll(find, replacement);
+				changed = true;
+			}
+			if (changed) return {
+				code: transformed,
+				map: null
+			};
+			else return;
+		}
+	};
+}
+//#endregion
+//#region src/vite-config-for-tests.ts
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname$1(__filename);
 function createViteConfigForTests(mode, projDir, prepDir) {
-  const root = resolvePath3(__dirname4, "..", "template-tests");
-  const templateSrcDir = resolvePath3(root, "src");
-  const relProjDir = relative4(templateSrcDir, projDir);
-  const relProjDirPath = relProjDir.replaceAll("\\", "/");
-  const yamlCheckGlobPatterns = `['${relProjDirPath}/**/checks/*.yaml', '${relProjDirPath}/**/*.check.yaml']`;
-  const yamlComparisonGlobPatterns = `['${relProjDirPath}/**/comparisons/*.yaml']`;
-  const outDir = relative4(root, prepDir);
-  return {
-    // Don't use an external config file
-    configFile: false,
-    // Use the root directory configured above
-    root,
-    // Don't clear the screen in dev mode so that we can see builder output
-    clearScreen: false,
-    // TODO: Disable vite output by default?
-    // logLevel: 'silent',
-    plugins: [
-      // Inject special values into the generated JS
-      // TODO: We currently have to use `@rollup/plugin-replace` instead of Vite's
-      // built-in `define` feature because the latter does not seem to run before
-      // the glob handler (which requires the glob to be injected as a literal)
-      replace2({
-        preventAssignment: true,
-        delimiters: ["", ""],
-        values: {
-          // Inject the glob patterns for matching model check yaml files
-          '"./__YAML_CHECK_GLOB_PATTERNS__"': yamlCheckGlobPatterns,
-          // Inject the glob patterns for matching model comparison yaml files
-          '"./__YAML_COMPARISON_GLOB_PATTERNS__"': yamlComparisonGlobPatterns
-        }
-      })
-    ],
-    build: {
-      // Write output files to the configured directory (instead of the default `dist`);
-      // note that this must be relative to the project `root`
-      outDir,
-      emptyOutDir: false,
-      lib: {
-        entry: "./src/index.ts",
-        formats: ["es"],
-        fileName: () => "check-tests.js"
-      },
-      // Enable watch mode if requested
-      watch: mode === "watch" && {},
-      rollupOptions: {
-        // Prevent dependencies from being included in packaged library
-        // TODO: For now we include check-core in the packaged library so that its
-        // dependencies are correctly resolved at runtime.  Ideally this would only
-        // include a couple functions that are used for defining tests, but Vite 2.x
-        // does not implement tree shaking for ES libraries, which means the generated
-        // library is much larger than it needs to be.  Once we upgrade to Vite 3.x,
-        // the generated library should be smaller; see related fix:
-        //   https://github.com/vitejs/vite/pull/8737
-        // external: Object.keys(pkg.dependencies)
-      }
-    }
-  };
+	const root = resolve$1(__dirname, "..", "template-tests");
+	const templateSrcDir = resolve$1(root, "src");
+	const relProjDirPath = relative$1(templateSrcDir, projDir).replaceAll("\\", "/");
+	const yamlCheckGlobPatterns = `['${relProjDirPath}/**/checks/*.yaml', '${relProjDirPath}/**/*.check.yaml']`;
+	const yamlComparisonGlobPatterns = `['${relProjDirPath}/**/comparisons/*.yaml']`;
+	const outDir = relative$1(root, prepDir);
+	return {
+		configFile: false,
+		root,
+		clearScreen: false,
+		plugins: [injectLiteralsPlugin({
+			"\"./__YAML_CHECK_GLOB_PATTERNS__\"": yamlCheckGlobPatterns,
+			"\"./__YAML_COMPARISON_GLOB_PATTERNS__\"": yamlComparisonGlobPatterns
+		})],
+		build: {
+			outDir,
+			emptyOutDir: false,
+			lib: {
+				entry: "./src/index.ts",
+				formats: ["es"],
+				fileName: () => "check-tests.js"
+			},
+			watch: mode === "watch" && {}
+		}
+	};
 }
-
-// src/plugin.ts
+//#endregion
+//#region src/plugin.ts
 function checkPlugin(options) {
-  return new CheckPlugin(options);
+	return new CheckPlugin(options);
 }
 var CheckPlugin = class {
-  constructor(options) {
-    this.options = options;
-    this.firstBuild = true;
-  }
-  async watch(config) {
-    if (this.options?.testConfigPath === void 0) {
-      await this.genTestConfig("watch", config);
-    }
-    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();
-  }
-  // 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
-  // staged files are copied to their final destination(s).  We should probably
-  // make it configurable so that it can either be run as a `postGenerate` or a
-  // `postBuild` step.
-  async postBuild(context, modelSpec) {
-    const firstBuild = this.firstBuild;
-    this.firstBuild = false;
-    if (this.options?.current?.path === void 0 && this.options?.current?.url === void 0) {
-      if (context.config.mode === "development") {
-        await this.copyPreviousBundle(context.config);
-      }
-      context.log("info", "Generating model check bundle...");
-      await this.genCurrentBundle(context, modelSpec);
-    }
-    if (this.options?.testConfigPath === void 0) {
-      if (context.config.mode === "production" || firstBuild) {
-        context.log("info", "Generating model check test configuration...");
-        await this.genTestConfig("bundle", context.config);
-      }
-    }
-    if (context.config.mode === "production") {
-      const testOptions = await this.resolveTestOptions("bundle", context.config);
-      return this.runChecks(context, testOptions);
-    } else {
-      return true;
-    }
-  }
-  async copyPreviousBundle(config) {
-    const currentBundleFile = joinPath5(config.prepDir, "check-bundle.js");
-    if (existsSync3(currentBundleFile)) {
-      const bundlesDir = joinPath5(config.rootDir, "bundles");
-      if (!existsSync3(bundlesDir)) {
-        await mkdir2(bundlesDir, { recursive: true });
-      }
-      const previousBundleFile = joinPath5(bundlesDir, "previous.js");
-      await copyFile(currentBundleFile, previousBundleFile);
-    }
-  }
-  async genCurrentBundle(context, modelSpec) {
-    const viteConfig = await createViteConfigForBundle(context, modelSpec);
-    await build(viteConfig);
-  }
-  async genTestConfig(mode, config) {
-    const rootDir = config.rootDir;
-    const prepDir = config.prepDir;
-    const viteConfig = createViteConfigForTests(mode, rootDir, prepDir);
-    await build(viteConfig);
-  }
-  async runChecks(context, testOptions) {
-    context.log("info", "Running model checks...");
-    async function importBundleModule(bundleSpec) {
-      return import(relativeToSourcePath(bundleSpec.path));
-    }
-    const moduleR = await importBundleModule(testOptions.currentBundleSpec);
-    const bundleR = moduleR.createBundle();
-    const bundleNameR = testOptions.currentBundleSpec.name;
-    let bundleL;
-    let bundleNameL;
-    if (testOptions.baselineBundleSpec !== void 0) {
-      const moduleL = await importBundleModule(testOptions.baselineBundleSpec);
-      const rawBundleL = moduleL.createBundle();
-      if (rawBundleL.version === bundleR.version) {
-        bundleL = rawBundleL;
-        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));
-    const configInitOptions = {
-      bundleNameL,
-      bundleNameR
-    };
-    const configOptions = await testConfigModule.getConfigOptions(bundleL, bundleR, configInitOptions);
-    const checkConfig = await createConfig(configOptions);
-    const result = await runTestSuite(
-      context,
-      checkConfig,
-      /*verbose=*/
-      false
-    );
-    context.log("info", "Building model check report");
-    const viteConfig = await this.createViteConfigForReport("bundle", context.config, testOptions, result.suiteSummary);
-    await build(viteConfig);
-    return result.allChecksPassed;
-  }
-  async resolveTestOptions(mode, config) {
-    const fetchRemoteBundle = this.options?.fetchRemoteBundle;
-    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"),
-          fetchRemoteBundle
-        );
-        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 = joinPath5(config.prepDir, "check-tests.js");
-    } else {
-      testConfigPath = this.options.testConfigPath;
-    }
-    return {
-      currentBundleSpec,
-      baselineBundleSpec,
-      testConfigPath
-    };
-  }
-  async createViteConfigForReport(mode, config, testOptions, suiteSummary) {
-    return createViteConfigForReport(
-      mode,
-      this.options,
-      config.rootDir,
-      config.prepDir,
-      testOptions.currentBundleSpec,
-      testOptions.baselineBundleSpec,
-      testOptions.testConfigPath,
-      suiteSummary
-    );
-  }
+	constructor(options) {
+		this.options = options;
+		this.firstBuild = true;
+	}
+	async watch(config) {
+		if (this.options?.testConfigPath === void 0) await this.genTestConfig("watch", config);
+		const testOptions = await this.resolveTestOptions("watch", config);
+		const viteConfig = await this.createViteConfigForReport("watch", config, testOptions, void 0);
+		await (await createServer(viteConfig)).listen();
+	}
+	async postBuild(context, modelSpec) {
+		const firstBuild = this.firstBuild;
+		this.firstBuild = false;
+		if (this.options?.current?.path === void 0 && this.options?.current?.url === void 0) {
+			if (context.config.mode === "development") await this.copyPreviousBundle(context.config);
+			context.log("info", "Generating model check bundle...");
+			await this.genCurrentBundle(context, modelSpec);
+		}
+		if (this.options?.testConfigPath === void 0) {
+			if (context.config.mode === "production" || firstBuild) {
+				context.log("info", "Generating model check test configuration...");
+				await this.genTestConfig("bundle", context.config);
+			}
+		}
+		if (context.config.mode === "production") {
+			const testOptions = await this.resolveTestOptions("bundle", context.config);
+			return this.runChecks(context, testOptions);
+		} else return true;
+	}
+	async copyPreviousBundle(config) {
+		const currentBundleFile = join(config.prepDir, "check-bundle.js");
+		if (existsSync(currentBundleFile)) {
+			const bundlesDir = join(config.rootDir, "bundles");
+			if (!existsSync(bundlesDir)) await mkdir(bundlesDir, { recursive: true });
+			const previousBundleFile = join(bundlesDir, "previous.js");
+			await copyFile(currentBundleFile, previousBundleFile);
+		}
+	}
+	async genCurrentBundle(context, modelSpec) {
+		const viteConfig = await createViteConfigForBundle(context, modelSpec);
+		await build(viteConfig);
+	}
+	async genTestConfig(mode, config) {
+		const rootDir = config.rootDir;
+		const prepDir = config.prepDir;
+		const viteConfig = createViteConfigForTests(mode, rootDir, prepDir);
+		await build(viteConfig);
+	}
+	async runChecks(context, testOptions) {
+		context.log("info", "Running model checks...");
+		async function importBundleModule(bundleSpec) {
+			return import(relativeToSourcePath(bundleSpec.path));
+		}
+		const bundleR = (await importBundleModule(testOptions.currentBundleSpec)).createBundle();
+		const bundleNameR = testOptions.currentBundleSpec.name;
+		let bundleL;
+		let bundleNameL;
+		if (testOptions.baselineBundleSpec !== void 0) {
+			const rawBundleL = (await importBundleModule(testOptions.baselineBundleSpec)).createBundle();
+			if (rawBundleL.version === bundleR.version) {
+				bundleL = rawBundleL;
+				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));
+		const configInitOptions = {
+			bundleNameL,
+			bundleNameR
+		};
+		const configOptions = await testConfigModule.getConfigOptions(bundleL, bundleR, configInitOptions);
+		const result = await runTestSuite(context, await createConfig(configOptions), false);
+		context.log("info", "Building model check report");
+		const viteConfig = await this.createViteConfigForReport("bundle", context.config, testOptions, result.suiteSummary);
+		await build(viteConfig);
+		return result.allChecksPassed;
+	}
+	async resolveTestOptions(mode, config) {
+		const fetchRemoteBundle = this.options?.fetchRemoteBundle;
+		async function resolveBundle(bundle) {
+			if (bundle?.url !== void 0) {
+				const localBundlePath = await downloadBundle(bundle.url, bundle.name, void 0, join(config.rootDir, "bundles"), fetchRemoteBundle);
+				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: join(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 = join(config.prepDir, "check-tests.js");
+		else testConfigPath = this.options.testConfigPath;
+		return {
+			currentBundleSpec,
+			baselineBundleSpec,
+			testConfigPath
+		};
+	}
+	async createViteConfigForReport(mode, config, testOptions, suiteSummary) {
+		return createViteConfigForReport(mode, this.options, config.rootDir, config.prepDir, testOptions.currentBundleSpec, testOptions.baselineBundleSpec, testOptions.testConfigPath, suiteSummary);
+	}
 };
+/**
+* Return a Unix-style path (e.g. '../../foo.js') that is relative to the directory of
+* the current source file.  This can be used to construct a path that is safe for
+* dynamic import on either Unix or Windows.
+*
+* @param filePath The path to make relative.
+*/
 function relativeToSourcePath(filePath) {
-  const srcDir = dirname5(fileURLToPath5(import.meta.url));
-  const relPath = relative5(srcDir, filePath);
-  return relPath.replaceAll("\\", "/");
+	const srcDir = dirname(fileURLToPath(import.meta.url));
+	return relative(srcDir, filePath).replaceAll("\\", "/");
 }
-export {
-  checkPlugin
-};
+//#endregion
+export { checkPlugin };
+
 //# sourceMappingURL=index.js.map