@testspectra/react 1.1.8-rc.25 → 1.1.8-rc.29

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);
@@ -80,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));
@@ -101,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 () => {
@@ -121,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 () => {
@@ -345,7 +350,7 @@ 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) => queueMicrotask(r));
       return globalThis.__TS_RUNTIME__.createElementProxy(`#${ROOT_ID}`);
     }
   );
@@ -363,6 +368,11 @@ 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);
@@ -395,15 +405,17 @@ function buildAutoImportManifest(root) {
   };
 }
 function generateVitestConfig(opts) {
-  const req = createRequire(path.join(opts.packageDir, "package.json"));
-  const reactPluginUrl = pathToFileURL(req.resolve("@vitejs/plugin-react")).href;
-  const vitestConfigUrl = pathToFileURL(req.resolve("vitest/config")).href;
+  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(normalizedPackageDir)},
@@ -433,7 +445,10 @@ export default defineConfig({
   test: {
     globals: true,
     setupFiles: [${JSON.stringify(setupFile)}],
-    reporters: ${opts.semanticReporter ? "[]" : "'default'"},
+    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'],
     browser: {
@@ -463,6 +478,12 @@ export default defineConfig({
 
 // src/cli.ts
 async function runComponentTests(options = {}) {
+  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));
@@ -478,12 +499,10 @@ async function runComponentTests(options = {}) {
     stepDelayMs: options.stepDelayMs ?? 0,
     semanticReporter,
     fileParallelism: options.concurrency !== 1,
-    browserExecutable: options.browserExecutablePath
+    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) {
     let specPattern = options.spec.replace(/\\/g, "/");
     if (path2.isAbsolute(options.spec)) {
@@ -520,8 +539,18 @@ async function runComponentTests(options = {}) {
   });
 }
 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;
@@ -532,7 +561,9 @@ 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);
@@ -541,8 +572,11 @@ async function runCli(argv = process.argv.slice(2)) {
   let spec = getFlagValue(argv, "--spec", "-s");
   if (!spec) {
     const flagsWithValues = /* @__PURE__ */ new Set([
+      "--runner",
+      "-r",
       "--step-delay",
       "--delay",
+      "-d",
       "--spec",
       "-s",
       "--output",
@@ -569,12 +603,337 @@ 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";
+var bundleCache = /* @__PURE__ */ new Map();
+var inFlightBuilds = /* @__PURE__ */ new Map();
+async function buildBundle(entrypoint, opts = {}) {
+  const result = await esbuild.build({
+    entryPoints: [entrypoint],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
+    external: opts.external ?? [],
+    minify: false,
+    write: false,
+    // Inline source maps so Chrome DevTools can map errors back to .tsx source lines.
+    sourcemap: "inline",
+    // React 17+ automatic JSX runtime — test files do not need `import React from 'react'`.
+    jsx: "automatic",
+    jsxImportSource: "react"
+  });
+  if (result.errors.length > 0) {
+    const msgs = result.errors.map((e) => e.text).join("\n");
+    throw new Error(`esbuild failed for ${entrypoint}:
+${msgs}`);
+  }
+  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 buildHarnessHtml(manifest, stepDelayMs) {
+  const manifestJson = JSON.stringify(manifest);
+  return `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>Spectra Component Test</title></head>
+<body>
+<script>
+  window.__TESTSPECTRA_AUTO_IMPORT_MANIFEST__ = ${manifestJson};
+  window.__TESTSPECTRA_STEP_DELAY_MS__ = ${JSON.stringify(stepDelayMs)};
+  window.__TESTSPECTRA_SEMANTIC_REPORTER__ = true;
+</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.startsWith("/@fs/")) {
+      const rawFsPath = url.pathname.slice("/@fs/".length);
+      const fsPath = rawFsPath.startsWith("/") ? rawFsPath : `/${rawFsPath}`;
+      const resolved = path3.resolve(fsPath);
+      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) {
+        respond(
+          res,
+          200,
+          "application/javascript",
+          `throw new Error(${JSON.stringify(`Module bundle error for ${fsPath}: ${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);
+      const rootResolved = path3.resolve(testRoot);
+      if (!resolved.startsWith(rootResolved + path3.sep) && resolved !== rootResolved) {
+        respond(res, 403, "text/plain", "Forbidden: path outside test root");
+        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
 };

package/dist/runner.js

@@ -0,0 +1 @@
+var i=[],a=[],T=[];globalThis.it=function(n,t){i.push({title:n,fn:t})};globalThis.beforeEach=function(n){a.push(n)};globalThis.afterEach=function(n){T.push(n)};function _(){let n=globalThis.Spectra;if(typeof n?.unmount=="function")n.unmount();else{let t=document.getElementById("spectra-root");t&&(t.innerHTML="")}}function r(n,t){console.log(`[${n}] ${t}`)}globalThis.__SPECTRA_RUNNER__={async run(n,t){r("TESTSPECTRA_SUITE_START",JSON.stringify({file:n}));let c=globalThis.__bootstrapAutoImports;if(typeof c=="function")try{await c(t)}catch(o){r("TESTSPECTRA_SUITE_ERROR",JSON.stringify({file:n,error:`Failed to bootstrap auto imports: ${String(o)}`}));return}let l=encodeURIComponent(n);try{await import(`/test?file=${l}`)}catch(o){r("TESTSPECTRA_SUITE_ERROR",JSON.stringify({file:n,error:String(o)}));return}let f=0,S=0;for(let{title:o,fn:g}of i){r("TESTSPECTRA_TEST_START",o),globalThis.__CURRENT_TEST_TITLE__=o;let E={task:{name:o}},u=performance.now();try{for(let e of a)await e(E);await g();for(let e of T)await e(E);let s=Math.round(performance.now()-u);r("TESTSPECTRA_TEST_PASS",`${o} (${s}ms)`),f++}catch(s){let e=Math.round(performance.now()-u),R=s instanceof Error?s.message:String(s);r("TESTSPECTRA_TEST_ERROR",R),r("TESTSPECTRA_TEST_FAIL",`${o} (${e}ms)`),S++}finally{_()}}i.length=0,a.length=0,T.length=0,r("TESTSPECTRA_SUITE_END",JSON.stringify({file:n,passed:f,failed:S}))}};