@testspectra/react 1.1.8-rc.9 → 1.1.10

package/dist/index.js

@@ -1,16 +1,19 @@
 // src/dom_driver_bridge.ts
-var cachedUser = null;
-async function getUser() {
-  if (!cachedUser) {
-    const { userEvent } = await import("@testing-library/user-event");
-    cachedUser = userEvent.setup();
-  }
-  return cachedUser;
+import { userEvent } from "@testing-library/user-event";
+function getUser() {
+  return userEvent.setup({ delay: null });
 }
 function resolveSelector(selector) {
   const trimmed = selector.trim();
   if (trimmed.startsWith("~")) {
-    return `[aria-label=${JSON.stringify(trimmed.slice(1))}]`;
+    const raw = trimmed.slice(1);
+    const bracketIndex = raw.indexOf("[");
+    if (bracketIndex !== -1) {
+      const label = raw.slice(0, bracketIndex);
+      const rest = raw.slice(bracketIndex);
+      return `[aria-label=${JSON.stringify(label)}]${rest}`;
+    }
+    return `[aria-label=${JSON.stringify(raw)}]`;
   }
   return trimmed;
 }
@@ -34,6 +37,8 @@ var DomDriverBridge = class {
   /** Polls until `selector` resolves to an element, then returns it — shared by every
    * interaction method below (user-event needs a real element handle, not a selector string). */
   async waitForEl(selector, index) {
+    const immediate = resolveEl(selector, index);
+    if (immediate) return immediate;
     let found = null;
     const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
       found = resolveEl(selector, index);
@@ -51,6 +56,14 @@ var DomDriverBridge = class {
       "Spectra.navigate() is not supported in component testing mode. Use Spectra.mount(<Component />) to render a component tree instead of navigating a URL."
     );
   }
+  async setCookies(setCookieHeaders, _url) {
+    const headers = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
+    for (const header of headers) {
+      if (typeof document !== "undefined") {
+        document.cookie = header;
+      }
+    }
+  }
   async back() {
     throw new Error("Spectra.back() is not supported in component testing mode.");
   }
@@ -72,20 +85,20 @@ var DomDriverBridge = class {
   // ─── Element Actions ─────────────────────────────────────────────────────
   async click(selector, index = null) {
     const el = await this.waitForEl(selector, index);
-    await (await getUser()).click(el);
+    await getUser().click(el);
   }
   async doubleClick(selector, index = null) {
     const el = await this.waitForEl(selector, index);
-    await (await getUser()).dblClick(el);
+    await getUser().dblClick(el);
   }
   async rightClick(selector, index = null) {
     const el = await this.waitForEl(selector, index);
-    await (await getUser()).pointer({ keys: "[MouseRight]", target: el });
+    await getUser().pointer({ keys: "[MouseRight]", target: el });
   }
   async setValue(selector, value, index = null) {
     const el = await this.waitForEl(selector, index);
     if (!isFormEl(el)) throw new Error("Element is not a form field: " + JSON.stringify(selector));
-    const u = await getUser();
+    const u = getUser();
     await u.clear(el);
     if (String(value).length > 0) {
       await u.type(el, String(value));
@@ -93,7 +106,7 @@ var DomDriverBridge = class {
   }
   async clearValue(selector, index = null) {
     const el = await this.waitForEl(selector, index);
-    await (await getUser()).clear(el);
+    await getUser().clear(el);
   }
   async select(selector, option, index = null) {
     const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
@@ -113,7 +126,7 @@ var DomDriverBridge = class {
   }
   async hover(selector, index = null) {
     const el = await this.waitForEl(selector, index);
-    await (await getUser()).hover(el);
+    await getUser().hover(el);
   }
   async focus(selector, index = null) {
     const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
@@ -284,7 +297,9 @@ var DomDriverBridge = class {
   }
   async shouldHaveNoConsoleErrors() {
     if (this.consoleErrors.length > 0) {
-      throw new Error(`Expected no console errors, but found ${this.consoleErrors.length}: ${this.consoleErrors.join("; ")}`);
+      throw new Error(
+        `Expected no console errors, but found ${this.consoleErrors.length}: ${this.consoleErrors.join("; ")}`
+      );
     }
   }
   async clearCookies() {
@@ -307,9 +322,27 @@ var DomDriverBridge = class {
 };
 
 // src/mount.ts
-import { createRoot } from "react-dom/client";
 var ROOT_ID = "spectra-root";
 var cachedRoot = null;
+var dynamicCreateRoot = null;
+async function getCreateRoot() {
+  if (typeof window !== "undefined" && window.__TESTSPECTRA_CREATE_ROOT__) {
+    return window.__TESTSPECTRA_CREATE_ROOT__;
+  }
+  if (dynamicCreateRoot) {
+    return dynamicCreateRoot;
+  }
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      "react-dom/client"
+    );
+    dynamicCreateRoot = mod.createRoot || mod.default?.createRoot || mod.default;
+    if (dynamicCreateRoot) return dynamicCreateRoot;
+  } catch {
+  }
+  throw new Error("Could not find react-dom/client createRoot. Ensure react-dom is installed in your project.");
+}
 function ensureContainer() {
   let container = document.getElementById(ROOT_ID);
   if (!container) {
@@ -322,7 +355,8 @@ function ensureContainer() {
 async function mount(element) {
   const container = ensureContainer();
   if (!cachedRoot) {
-    cachedRoot = createRoot(container);
+    const createRootFn = await getCreateRoot();
+    cachedRoot = createRootFn(container);
   }
   const componentName = (typeof element.type === "string" ? element.type : element.type?.displayName || element.type?.name) || "component";
   return globalThis.__TS_RUNTIME__.trackStep(
@@ -330,42 +364,189 @@ async function mount(element) {
     { type: "action", key: "mount", target: componentName, args: [] },
     async () => {
       cachedRoot.render(element);
-      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 20));
       return globalThis.__TS_RUNTIME__.createElementProxy(`#${ROOT_ID}`);
     }
   );
 }
 
 // src/cli.ts
-import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
+import spawn from "cross-spawn";
+
+// src/config_generator.ts
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+function resolveEsmUrl(specifier, packageDir) {
+  const cjsPath = createRequire(path.join(packageDir, "package.json")).resolve(specifier);
+  const esmPath = cjsPath.replace(/\.cjs$/, ".js");
+  return pathToFileURL(existsSync(esmPath) ? esmPath : cjsPath).href;
+}
+function buildAutoImportManifest(root) {
+  function scanEntityDir(subdir, filePattern) {
+    const dir = path.join(root, subdir);
+    if (!existsSync(dir)) return [];
+    const entries = [];
+    for (const name of readdirSync(dir, { withFileTypes: true })) {
+      if (!name.isDirectory()) continue;
+      if (name.name.startsWith(".") || name.name === "node_modules" || name.name === "dist" || name.name === "__screenshots__" || name.name === "coverage") {
+        continue;
+      }
+      for (const platform of ["web", "common"]) {
+        for (const ext of ["tsx", "ts"]) {
+          const candidate = path.join(dir, name.name, filePattern(platform).replace(/\.tsx?$/, `.${ext}`));
+          if (existsSync(candidate)) {
+            entries.push({ name: name.name, path: candidate.replace(/\\/g, "/") });
+            break;
+          }
+        }
+        if (entries.at(-1)?.name === name.name) break;
+      }
+    }
+    return entries;
+  }
+  function scanFixtures() {
+    const dir = path.join(root, "fixtures");
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => ({ name: f.replace(/\.json$/, ""), path: path.join(dir, f).replace(/\\/g, "/") }));
+  }
+  return {
+    pageObjects: scanEntityDir("page-objects", (p) => `${p}.tsx`),
+    steps: scanEntityDir("support/steps", (p) => `${p}.step.tsx`),
+    fixtures: scanFixtures()
+  };
+}
+function generateVitestConfig(opts) {
+  const reactPluginUrl = resolveEsmUrl("@vitejs/plugin-react", opts.packageDir);
+  const vitestConfigUrl = resolveEsmUrl("vitest/config", opts.packageDir);
+  const manifest = buildAutoImportManifest(opts.testRoot);
+  const setupFile = path.join(opts.packageDir, "dist/setup.js").replace(/\\/g, "/");
+  const reporterFile = path.join(opts.packageDir, "dist/vitest_reporter.js").replace(/\\/g, "/");
+  const reporterUrl = pathToFileURL(reporterFile).href;
+  const normalizedPackageDir = opts.packageDir.replace(/\\/g, "/");
+  const normalizedTestRoot = opts.testRoot.replace(/\\/g, "/");
+  const configContent = `import react from '${reactPluginUrl}';
+import { defineConfig } from '${vitestConfigUrl}';
+${opts.semanticReporter ? `import { SpectraVitestReporter } from '${reporterUrl}';` : ""}
+
+export default defineConfig({
+  root: ${JSON.stringify(normalizedTestRoot)},
+  plugins: [react()],
+  define: {
+    __TESTSPECTRA_AUTO_IMPORT_MANIFEST__: ${JSON.stringify(JSON.stringify(manifest))},
+    __TESTSPECTRA_STEP_DELAY_MS__: ${JSON.stringify(opts.stepDelayMs)},
+    __TESTSPECTRA_SEMANTIC_REPORTER__: ${JSON.stringify(opts.semanticReporter)},
+  },
+  optimizeDeps: {
+    include: [
+      'react',
+      'react-dom',
+      'react-dom/client',
+      '@testing-library/react',
+      '@testing-library/user-event',
+    ],
+  },
+  server: {
+    fs: {
+      allow: [
+        ${JSON.stringify(normalizedPackageDir)},
+        ${JSON.stringify(normalizedTestRoot)},
+      ],
+    },
+  },
+  test: {
+    globals: true,
+    setupFiles: [${JSON.stringify(setupFile)}],
+    reporters: ${opts.semanticReporter ? `[
+      new SpectraVitestReporter({ testRoot: ${JSON.stringify(normalizedTestRoot)} }),
+      ${opts.outputFile ? `['json', { outputFile: ${JSON.stringify(opts.outputFile)} }],` : ""}
+    ]` : opts.outputFile ? `['default', ['json', { outputFile: ${JSON.stringify(opts.outputFile)} }]]` : "'default'"},
+    dir: ${JSON.stringify(normalizedTestRoot)},
+    include: [
+      'specs/**/web.test.tsx',
+      'specs/**/*.test.tsx',
+      'specs/**/web.test.ts',
+      'specs/**/*.test.ts',
+    ],
+    exclude: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/__screenshots__/**',
+      '**/.testspectra/**',
+      '**/.git/**',
+      '**/coverage/**',
+    ],
+    browser: {
+      enabled: true,
+      provider: 'playwright',
+      name: 'chromium',
+      headless: ${opts.headless},
+      fileParallelism: ${opts.fileParallelism},
+      ${opts.browserExecutable ? `providerOptions: { launch: { executablePath: ${JSON.stringify(opts.browserExecutable)} } },` : ""}
+    },
+  },
+});
+`;
+  const tmpDir = mkdtempSync(path.join(os.tmpdir(), "testspectra-react-"));
+  const configPath = path.join(tmpDir, "vitest.config.mjs");
+  writeFileSync(configPath, configContent, "utf-8");
+  return {
+    configPath,
+    cleanup: () => {
+      try {
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/cli.ts
 async function runComponentTests(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const configPath = fileURLToPath(new URL("../vitest.config.ts", import.meta.url));
+  const runner = options.runner ?? "vitest";
+  if (runner === "spectra") {
+    console.log("TestSpectra native component testing is orchestrated by the Rust Core Engine.");
+    console.log("Use `spectra test` to run tests with full parallel CDP orchestration.");
+    return true;
+  }
+  const rawCwd = options.cwd ?? process.cwd();
+  const cwd = path2.resolve(rawCwd);
+  const packageDir = fileURLToPath(new URL("..", import.meta.url));
   const ext = process.platform === "win32" ? ".cmd" : "";
-  const vitestBin = fileURLToPath(new URL(`../node_modules/.bin/vitest${ext}`, import.meta.url));
+  const localVitestBin = fileURLToPath(new URL(`../node_modules/.bin/vitest${ext}`, import.meta.url));
+  const consumerVitestBin = path2.join(cwd, `node_modules/.bin/vitest${ext}`);
+  const vitestBin = existsSync2(localVitestBin) ? localVitestBin : consumerVitestBin;
+  const semanticReporter = Boolean(options.onLine);
+  const { configPath, cleanup } = generateVitestConfig({
+    packageDir,
+    testRoot: cwd,
+    headless: options.headless !== false,
+    stepDelayMs: options.stepDelayMs ?? 0,
+    semanticReporter,
+    fileParallelism: options.concurrency !== 1,
+    browserExecutable: options.browserExecutablePath,
+    outputFile: options.outputFile
+  });
   const args = ["run", "--config", configPath];
-  if (options.outputFile) {
-    args.push("--reporter=default", "--reporter=json", `--outputFile.json=${options.outputFile}`);
-  }
   if (options.spec) {
-    args.push(options.spec);
+    let specPattern = options.spec.replace(/\\/g, "/");
+    if (path2.isAbsolute(options.spec)) {
+      specPattern = path2.relative(cwd, options.spec).replace(/\\/g, "/");
+    }
+    args.push(specPattern);
   }
-  const semanticReporter = Boolean(options.onLine);
   return new Promise((resolve) => {
     const child = spawn(vitestBin, args, {
       stdio: semanticReporter ? ["inherit", "pipe", "pipe"] : "inherit",
       cwd,
       env: {
-        ...process.env,
-        TESTSPECTRA_TEST_ROOT: cwd,
-        TESTSPECTRA_HEADLESS: options.headless === false ? "false" : "true",
-        TESTSPECTRA_STEP_DELAY: String(options.stepDelayMs ?? 0),
-        TESTSPECTRA_FILE_PARALLELISM: options.concurrency === 1 ? "false" : "true",
-        ...options.browserExecutablePath ? { TESTSPECTRA_BROWSER_EXECUTABLE: options.browserExecutablePath } : {},
-        TESTSPECTRA_SEMANTIC_REPORTER: semanticReporter ? "1" : "0"
-      },
-      shell: process.platform === "win32"
+        ...process.env
+      }
     });
     if (semanticReporter) {
       const handleData = (buf) => {
@@ -376,16 +557,30 @@ async function runComponentTests(options = {}) {
       child.stdout?.on("data", handleData);
       child.stderr?.on("data", handleData);
     }
-    child.on("exit", (code) => resolve(code === 0));
+    child.on("exit", (code) => {
+      cleanup();
+      resolve(code === 0);
+    });
     child.on("error", (err) => {
+      cleanup();
       console.error(err);
       resolve(false);
     });
   });
 }
 function getFlagValue(argv, ...names) {
-  const index = argv.findIndex((a) => names.includes(a));
-  return index !== -1 ? argv[index + 1] : void 0;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    for (const name of names) {
+      if (arg === name) {
+        return argv[i + 1];
+      }
+      if (arg.startsWith(`${name}=`)) {
+        return arg.slice(name.length + 1);
+      }
+    }
+  }
+  return void 0;
 }
 async function runCli(argv = process.argv.slice(2)) {
   const [command] = argv;
@@ -396,13 +591,40 @@ async function runCli(argv = process.argv.slice(2)) {
   let headless = true;
   if (argv.includes("--headed") || argv.includes("--no-headless")) headless = false;
   else if (argv.includes("--headless")) headless = true;
-  const rawDelay = getFlagValue(argv, "--step-delay", "--delay");
+  const rawRunner = getFlagValue(argv, "--runner", "-r");
+  const runner = rawRunner === "vitest" ? "vitest" : "spectra";
+  const rawDelay = getFlagValue(argv, "--step-delay", "--delay", "-d");
   let stepDelayMs;
   if (rawDelay !== void 0) {
     const parsed = parseInt(String(rawDelay), 10);
     if (!isNaN(parsed) && parsed >= 0) stepDelayMs = parsed;
   }
-  const spec = getFlagValue(argv, "--spec", "-s");
+  let spec = getFlagValue(argv, "--spec", "-s");
+  if (!spec) {
+    const flagsWithValues = /* @__PURE__ */ new Set([
+      "--runner",
+      "-r",
+      "--step-delay",
+      "--delay",
+      "-d",
+      "--spec",
+      "-s",
+      "--output",
+      "-o",
+      "--concurrency",
+      "-c",
+      "--browser-executable"
+    ]);
+    for (let i = 1; i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg.startsWith("-")) {
+        if (flagsWithValues.has(arg)) i++;
+      } else {
+        spec = arg;
+        break;
+      }
+    }
+  }
   const outputFile = getFlagValue(argv, "--output", "-o");
   const rawConcurrency = getFlagValue(argv, "--concurrency", "-c");
   let concurrency;
@@ -411,12 +633,513 @@ async function runCli(argv = process.argv.slice(2)) {
     if (!isNaN(parsed) && parsed >= 1) concurrency = parsed;
   }
   const browserExecutablePath = getFlagValue(argv, "--browser-executable");
-  const ok = await runComponentTests({ headless, stepDelayMs, spec, outputFile, concurrency, browserExecutablePath });
+  const ok = await runComponentTests({
+    runner,
+    headless,
+    stepDelayMs,
+    spec,
+    outputFile,
+    concurrency,
+    browserExecutablePath
+  });
   process.exit(ok ? 0 : 1);
 }
+
+// src/cdp_runner/bundle_server.ts
+import fs from "node:fs";
+import http from "node:http";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import * as esbuild from "esbuild";
+import { createRequire as createRequire2 } from "node:module";
+var bundleCache = /* @__PURE__ */ new Map();
+var inFlightBuilds = /* @__PURE__ */ new Map();
+var cssInjectorPlugin = {
+  name: "spectra-css-injector",
+  setup(build2) {
+    build2.onLoad({ filter: /\.(css|scss|sass|less)$/ }, async (args) => {
+      try {
+        const raw = await fs.promises.readFile(args.path, "utf8");
+        const escaped = JSON.stringify(raw);
+        const sourcePath = JSON.stringify(args.path);
+        return {
+          contents: `
+            if (typeof document !== 'undefined') {
+              const style = document.createElement('style');
+              style.setAttribute('data-spectra-css', ${sourcePath});
+              style.textContent = ${escaped};
+              document.head.appendChild(style);
+            }
+          `,
+          loader: "js"
+        };
+      } catch (e) {
+        return {
+          contents: `/* failed to load css: ${String(e)} */`,
+          loader: "js"
+        };
+      }
+    });
+  }
+};
+var SHARED_REACT_EXTERNALS = [
+  "react",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react/compiler-runtime",
+  "react-dom",
+  "react-dom/client"
+];
+async function buildBundle(entrypoint, opts = {}) {
+  const mergedExternals = opts.skipSharedExternals ? opts.external ?? [] : Array.from(/* @__PURE__ */ new Set([...opts.external ?? [], ...SHARED_REACT_EXTERNALS]));
+  const buildOptions = {
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
+    external: mergedExternals,
+    minify: false,
+    write: false,
+    plugins: [cssInjectorPlugin],
+    loader: {
+      ".png": "dataurl",
+      ".jpg": "dataurl",
+      ".jpeg": "dataurl",
+      ".gif": "dataurl",
+      ".webp": "dataurl",
+      ".svg": "text",
+      ".json": "json",
+      ".woff": "dataurl",
+      ".woff2": "dataurl",
+      ".ttf": "dataurl",
+      ".eot": "dataurl"
+    },
+    logLevel: "error",
+    logOverride: {
+      "ignored-bare-import": "silent"
+    },
+    sourcemap: "inline",
+    jsx: "automatic",
+    jsxImportSource: "react"
+  };
+  if (opts.virtualContents) {
+    buildOptions.stdin = {
+      contents: opts.virtualContents,
+      resolveDir: opts.resolveDir ?? process.cwd(),
+      sourcefile: entrypoint,
+      loader: "ts"
+    };
+  } else {
+    buildOptions.entryPoints = [entrypoint];
+  }
+  const result = await esbuild.build(buildOptions);
+  if (result.errors.length > 0) {
+    const msgs = result.errors.map((e) => e.text).join("\n");
+    throw new Error(`esbuild failed for ${entrypoint}:
+${msgs}`);
+  }
+  if (!result.outputFiles || result.outputFiles.length === 0) {
+    throw new Error(`esbuild produced no output files for ${entrypoint}`);
+  }
+  return result.outputFiles[0].text;
+}
+async function getCachedBundle(cacheKey, entrypoint, opts) {
+  const cached = bundleCache.get(cacheKey);
+  if (cached) return cached;
+  const existingInFlight = inFlightBuilds.get(cacheKey);
+  if (existingInFlight) return existingInFlight;
+  const buildPromise = buildBundle(entrypoint, opts).then(
+    (js) => {
+      bundleCache.set(cacheKey, js);
+      inFlightBuilds.delete(cacheKey);
+      return js;
+    },
+    (err) => {
+      inFlightBuilds.delete(cacheKey);
+      throw err;
+    }
+  );
+  inFlightBuilds.set(cacheKey, buildPromise);
+  return buildPromise;
+}
+function buildCombinedReactBundleCode(testRoot) {
+  let req;
+  try {
+    req = createRequire2(path3.join(testRoot, "package.json"));
+  } catch {
+    req = createRequire2(import.meta.url);
+  }
+  const resolveSafe = (specifier) => {
+    try {
+      return req.resolve(specifier);
+    } catch {
+      try {
+        return createRequire2(import.meta.url).resolve(specifier);
+      } catch {
+        return null;
+      }
+    }
+  };
+  const loadSafe = (specifier) => {
+    try {
+      return req(specifier);
+    } catch {
+      try {
+        return createRequire2(import.meta.url)(specifier);
+      } catch {
+        return null;
+      }
+    }
+  };
+  const reactPath = resolveSafe("react");
+  const jsxPath = resolveSafe("react/jsx-runtime");
+  const compilerPath = resolveSafe("react/compiler-runtime");
+  const domPath = resolveSafe("react-dom");
+  const domClientPath = resolveSafe("react-dom/client");
+  const reactPkg = loadSafe("react") ?? {};
+  const jsxPkg = loadSafe("react/jsx-runtime") ?? {};
+  const compilerPkg = loadSafe("react/compiler-runtime") ?? {};
+  const domPkg = loadSafe("react-dom") ?? {};
+  const domClientPkg = loadSafe("react-dom/client") ?? {};
+  const allKeys = /* @__PURE__ */ new Set();
+  const exportLines = [];
+  const addExports = (varName, pkg) => {
+    const keys = Object.keys(pkg).filter((k) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k));
+    for (const k of keys) {
+      if (!allKeys.has(k)) {
+        allKeys.add(k);
+        exportLines.push(`export const ${k} = (${varName} as any).${k};`);
+      }
+    }
+  };
+  addExports("_react", reactPkg);
+  addExports("_jsx", jsxPkg);
+  addExports("_compiler", compilerPkg);
+  addExports("_dom", domPkg);
+  addExports("_domClient", domClientPkg);
+  const importParts = [];
+  const initParts = [];
+  if (reactPath) {
+    importParts.push(`import * as _rawReact from ${JSON.stringify(reactPath)};`);
+    initParts.push(`const _react: any = (_rawReact as any).default || _rawReact;`);
+  } else {
+    initParts.push(`const _react: any = {};`);
+  }
+  if (jsxPath) {
+    importParts.push(`import * as _rawJsx from ${JSON.stringify(jsxPath)};`);
+    initParts.push(`const _jsx: any = (_rawJsx as any).default || _rawJsx;`);
+  } else {
+    initParts.push(`const _jsx: any = {};`);
+  }
+  if (compilerPath) {
+    importParts.push(`import * as _rawCompiler from ${JSON.stringify(compilerPath)};`);
+    initParts.push(`const _compiler: any = (_rawCompiler as any).default || _rawCompiler;`);
+  } else {
+    initParts.push(`const _compiler: any = {};`);
+  }
+  if (domPath) {
+    importParts.push(`import * as _rawDom from ${JSON.stringify(domPath)};`);
+    initParts.push(`const _dom: any = (_rawDom as any).default || _rawDom;`);
+  } else {
+    initParts.push(`const _dom: any = {};`);
+  }
+  if (domClientPath) {
+    importParts.push(`import * as _rawDomClient from ${JSON.stringify(domClientPath)};`);
+    initParts.push(`const _domClient: any = (_rawDomClient as any).default || _rawDomClient;`);
+  } else {
+    initParts.push(`const _domClient: any = {};`);
+  }
+  return `
+${importParts.join("\n")}
+
+${initParts.join("\n")}
+
+${exportLines.join("\n")}
+
+export default _react;
+`;
+}
+function buildHarnessHtml(manifest, stepDelayMs) {
+  const manifestJson = JSON.stringify(manifest);
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Spectra Component Test</title>
+<script type="importmap">
+{
+  "imports": {
+    "react": "/@modules/react.js",
+    "react/jsx-runtime": "/@modules/react.js",
+    "react/jsx-dev-runtime": "/@modules/react.js",
+    "react/compiler-runtime": "/@modules/react.js",
+    "react-dom": "/@modules/react.js",
+    "react-dom/client": "/@modules/react.js"
+  }
+}
+</script>
+</head>
+<body>
+<script type="module">
+  window.__TESTSPECTRA_AUTO_IMPORT_MANIFEST__ = ${manifestJson};
+  window.__TESTSPECTRA_STEP_DELAY_MS__ = ${JSON.stringify(stepDelayMs)};
+  window.__TESTSPECTRA_SEMANTIC_REPORTER__ = true;
+  try {
+    const rdc = await import('react-dom/client');
+    window.__TESTSPECTRA_CREATE_ROOT__ = rdc.createRoot || rdc.default?.createRoot || rdc.default;
+  } catch (e) {
+    console.warn('[TestSpectra] createRoot pre-load warning:', e);
+  }
+</script>
+<script type="module" src="/runner.js"></script>
+<script type="module" src="/setup.js"></script>
+</body>
+</html>`;
+}
+function respond(res, status, contentType, body) {
+  res.writeHead(status, { "Content-Type": contentType });
+  res.end(body);
+}
+function resolveReactPackageDir() {
+  let curr = path3.dirname(fileURLToPath2(import.meta.url));
+  while (curr !== path3.dirname(curr)) {
+    const pkgPath = path3.join(curr, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@testspectra/react") {
+          return curr;
+        }
+      } catch {
+      }
+    }
+    curr = path3.dirname(curr);
+  }
+  return path3.resolve(path3.dirname(fileURLToPath2(import.meta.url)), "../..");
+}
+function makeHandler(testRoot, packageDir, harnessHtml, setupEntrypoint, runnerEntrypoint) {
+  return async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://127.0.0.1`);
+    if (url.pathname === "/") {
+      respond(res, 200, "text/html; charset=utf-8", harnessHtml);
+      return;
+    }
+    if (url.pathname === "/@modules/react.js" || url.pathname.startsWith("/@modules/react")) {
+      try {
+        const js = await getCachedBundle("module_react_combined", path3.join(testRoot, "__virtual_react_combined.js"), {
+          virtualContents: buildCombinedReactBundleCode(testRoot),
+          resolveDir: testRoot,
+          skipSharedExternals: true
+        });
+        respond(res, 200, "application/javascript; charset=utf-8", js);
+      } catch (err) {
+        respond(
+          res,
+          500,
+          "application/javascript",
+          `throw new Error(${JSON.stringify(`Failed to bundle shared React runtime: ${String(err)}`)});`
+        );
+      }
+      return;
+    }
+    if (url.pathname === "/setup.js") {
+      try {
+        const js = await getCachedBundle("setup", setupEntrypoint);
+        respond(res, 200, "application/javascript; charset=utf-8", js);
+      } catch (err) {
+        respond(res, 500, "application/javascript", `// Bundle error: ${String(err)}`);
+      }
+      return;
+    }
+    if (url.pathname === "/runner.js") {
+      try {
+        const js = await getCachedBundle("runner", runnerEntrypoint);
+        respond(res, 200, "application/javascript; charset=utf-8", js);
+      } catch (err) {
+        respond(res, 500, "application/javascript", `// Bundle error: ${String(err)}`);
+      }
+      return;
+    }
+    if (url.pathname === "/test") {
+      const encodedFile = url.searchParams.get("file");
+      if (!encodedFile) {
+        respond(res, 400, "text/plain", "Missing ?file= parameter");
+        return;
+      }
+      const testFilePath = decodeURIComponent(encodedFile);
+      const resolved = path3.resolve(testFilePath);
+      if (!fs.existsSync(resolved)) {
+        respond(res, 404, "text/plain", `File not found: ${testFilePath}`);
+        return;
+      }
+      if (resolved.endsWith(".json")) {
+        try {
+          const raw = fs.readFileSync(resolved, "utf-8");
+          respond(res, 200, "application/json; charset=utf-8", raw);
+        } catch (err) {
+          respond(res, 500, "application/json", JSON.stringify({ error: String(err) }));
+        }
+        return;
+      }
+      try {
+        const js = await getCachedBundle(resolved, resolved);
+        respond(res, 200, "application/javascript; charset=utf-8", js);
+      } catch (err) {
+        const msg = String(err);
+        respond(res, 200, "application/javascript", `throw new Error(${JSON.stringify(`Test bundle error: ${msg}`)});`);
+      }
+      return;
+    }
+    respond(res, 404, "text/plain", "Not Found");
+  };
+}
+async function startBundleServer(opts = {}) {
+  const testRoot = path3.resolve(opts.testRoot ?? process.cwd());
+  const packageDir = opts.packageDir ?? resolveReactPackageDir();
+  const manifest = opts.manifest ?? { pageObjects: [], steps: [], fixtures: [] };
+  const stepDelayMs = opts.stepDelayMs ?? 0;
+  const setupEntrypoint = path3.join(packageDir, "src", "setup.ts");
+  const runnerEntrypoint = path3.join(packageDir, "src", "cdp_runner", "in_page_runner.ts");
+  const distSetup = path3.join(packageDir, "dist", "setup.js");
+  if (fs.existsSync(distSetup)) {
+    try {
+      bundleCache.set("setup", fs.readFileSync(distSetup, "utf-8"));
+    } catch {
+    }
+  }
+  const distRunner = path3.join(packageDir, "dist", "runner.js");
+  if (fs.existsSync(distRunner)) {
+    try {
+      bundleCache.set("runner", fs.readFileSync(distRunner, "utf-8"));
+    } catch {
+    }
+  }
+  if (!bundleCache.has("setup")) {
+    getCachedBundle("setup", setupEntrypoint).catch(() => {
+    });
+  }
+  if (!bundleCache.has("runner")) {
+    getCachedBundle("runner", runnerEntrypoint).catch(() => {
+    });
+  }
+  const harnessHtml = buildHarnessHtml(manifest, stepDelayMs);
+  const handler = makeHandler(testRoot, packageDir, harnessHtml, setupEntrypoint, runnerEntrypoint);
+  const server = http.createServer(handler);
+  await new Promise((resolve, reject) => {
+    server.listen(0, "127.0.0.1", () => resolve());
+    server.once("error", reject);
+  });
+  const addr = server.address();
+  const baseUrl = `http://127.0.0.1:${addr.port}`;
+  return {
+    url: baseUrl,
+    stop: () => server.close()
+  };
+}
+
+// src/sanitizer.ts
+var VITE_FS_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):\d+\/@fs\/([A-Za-z]:\/)/g;
+var VITE_FS_UNIX_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):\d+\/@fs\//g;
+var VITE_ROOT_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):\d+\//g;
+var URL_QUERY_PATTERN = /(\.[a-zA-Z0-9]+)\?[^:\s'")]*/g;
+var INTERNAL_FRAME_PATTERNS = [
+  /node_modules[\\/]vitest[\\/]/i,
+  /node_modules[\\/]@vitest[\\/]/i,
+  /node_modules[\\/]vite[\\/]/i,
+  /node_modules[\\/]@vitejs[\\/]/i,
+  /node_modules[\\/]playwright[\\/]/i,
+  /node_modules[\\/]@playwright[\\/]/i,
+  /node:internal[\\/]/i,
+  /dist[\\/]setup\.js/i,
+  /dist[\\/]vitest_reporter\.js/i,
+  /tools[\\/]react[\\/]/i,
+  /[\\/]vitest\.config\./i,
+  /@vitest/i,
+  /__vitest__/i
+];
+function sanitizeViteUrl(text) {
+  if (!text) return "";
+  let result = text.replace(VITE_FS_URL_PATTERN, "$1");
+  result = result.replace(VITE_FS_UNIX_URL_PATTERN, "/");
+  result = result.replace(VITE_ROOT_URL_PATTERN, "./");
+  result = result.replace(URL_QUERY_PATTERN, "$1");
+  return result;
+}
+function sanitizeErrorMessage(msg) {
+  if (!msg) return "";
+  let sanitized = sanitizeViteUrl(msg);
+  sanitized = sanitized.replace(/Failed to fetch dynamically imported module:\s*/gi, "Failed to load module: ");
+  sanitized = sanitized.replace(/\[vite\]\s*(?:Internal server error:\s*)?/gi, "[TestSpectra] ");
+  sanitized = sanitized.replace(/@vitest\/browser/gi, "TestSpectra Browser");
+  sanitized = sanitized.replace(/@vitest\/runner/gi, "TestSpectra Runner");
+  sanitized = sanitized.replace(/\bvitest\.config\.[a-z0-9]+/gi, "spectra.config.ts");
+  sanitized = sanitized.replace(/\bVitest\b/g, "TestSpectra");
+  sanitized = sanitized.replace(/\bvitest\b/g, "testspectra");
+  return sanitized;
+}
+function sanitizeStackTrace(stack) {
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  const filtered = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (i === 0) {
+      filtered.push(sanitizeErrorMessage(line));
+      continue;
+    }
+    const isInternal = INTERNAL_FRAME_PATTERNS.some((pattern) => pattern.test(line));
+    if (isInternal) {
+      continue;
+    }
+    filtered.push(sanitizeErrorMessage(line));
+  }
+  return filtered.join("\n").trim();
+}
+function sanitizeError(err) {
+  if (!err) return "";
+  if (typeof err === "string") {
+    return sanitizeStackTrace(err);
+  }
+  if (typeof err === "object") {
+    const errorObj = err;
+    const stack = errorObj.stack;
+    const message = errorObj.message || String(err);
+    if (stack && typeof stack === "string") {
+      const sanitizedStack = sanitizeStackTrace(stack);
+      if (sanitizedStack) return sanitizedStack;
+    }
+    return sanitizeErrorMessage(message);
+  }
+  return sanitizeErrorMessage(String(err));
+}
+function isVitestNoise(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  if (/^RUN\s+v\d+/i.test(trimmed)) return true;
+  if (/^DEV\s+v\d+/i.test(trimmed)) return true;
+  if (/^Test Files\s+\d+/i.test(trimmed)) return true;
+  if (/^Tests\s+\d+/i.test(trimmed)) return true;
+  if (/^Start at\s+\d+/i.test(trimmed)) return true;
+  if (/^Duration\s+[\d.]+/i.test(trimmed)) return true;
+  if (/^⎯{3,}/.test(trimmed)) return true;
+  if (/^Re-optimizing dependencies/i.test(trimmed)) return true;
+  if (/^JSON report written to/i.test(trimmed)) return true;
+  if (/^\(?transform \d+ms/i.test(trimmed)) return true;
+  if (/^[·✓❯⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s+/.test(trimmed)) return true;
+  if (/vite-cjs-node-api-deprecated/i.test(trimmed)) return true;
+  if (/CJS build of Vite's Node API is deprecated/i.test(trimmed)) return true;
+  if (/^\[?vite\]?\s*(deprecation|warning)/i.test(trimmed)) return true;
+  return false;
+}
 export {
   DomDriverBridge,
+  isVitestNoise,
   mount,
   runCli,
-  runComponentTests
+  runComponentTests,
+  sanitizeError,
+  sanitizeErrorMessage,
+  sanitizeStackTrace,
+  sanitizeViteUrl,
+  startBundleServer
 };