@testspectra/react 1.1.11-rc.5 → 1.1.12

package/dist/cli.js

@@ -41,7 +41,11 @@ function buildAutoImportManifest(root) {
   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 readdirSync(dir).filter((f) => !f.startsWith(".") && !f.endsWith(".d.ts")).map((f) => {
+      const ext = path.extname(f);
+      const name = path.basename(f, ext);
+      return { name, path: path.join(dir, f).replace(/\\/g, "/") };
+    });
   }
   return {
     pageObjects: scanEntityDir("page-objects", (p) => `${p}.tsx`),

package/dist/index.js

@@ -1,30 +1,395 @@
 // src/dom_driver_bridge.ts
 import { userEvent } from "@testing-library/user-event";
-function getUser() {
-  return userEvent.setup({ delay: null });
+
+// ../../core/worker-runtime/src/dsl/mock_intercept.ts
+function matchesUrlPattern(pattern, url) {
+  if (!pattern || pattern === "*" || pattern === "**" || pattern === "ALL") {
+    return true;
+  }
+  if (pattern.startsWith("/") && pattern.endsWith("/")) {
+    try {
+      const regex = new RegExp(pattern.slice(1, -1));
+      return regex.test(url);
+    } catch {
+    }
+  }
+  if (pattern.includes("*")) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    try {
+      const regex = new RegExp(escaped, "i");
+      return regex.test(url);
+    } catch {
+    }
+  }
+  return url.toLowerCase().includes(pattern.toLowerCase());
 }
-function resolveSelector(selector) {
+function createMockHandle(rule) {
+  const handle = {
+    respondWith: async (newFixture, newOptions = {}) => {
+      const newObj = newFixture;
+      rule.response = newObj && newObj.body !== void 0 ? newObj.body : newFixture;
+      if (newOptions.statusCode || newObj && newObj.statusCode) {
+        rule.statusCode = newOptions.statusCode || newObj?.statusCode || 200;
+      }
+      if (newOptions.headers || newObj && newObj.headers) {
+        rule.headers = newOptions.headers || newObj?.headers;
+      }
+      if (newOptions.delayMs !== void 0 || newObj && newObj.delayMs !== void 0) {
+        rule.delayMs = newOptions.delayMs ?? newObj?.delayMs;
+      }
+      rule.aborted = false;
+    },
+    respondOnce: async (newFixture, newOptions = {}) => {
+      const newObj = newFixture;
+      const resp = newObj && newObj.body !== void 0 ? newObj.body : newFixture;
+      const statusCode = newOptions.statusCode || newObj && newObj.statusCode || rule.statusCode || 200;
+      const headers = newOptions.headers || newObj && newObj.headers || rule.headers;
+      const delayMs = newOptions.delayMs ?? (newObj && newObj.delayMs) ?? rule.delayMs;
+      rule.respondOnceQueue.push({ response: resp, statusCode, headers, delayMs });
+      rule.aborted = false;
+    },
+    abort: async (errorCode = "Failed") => {
+      rule.aborted = true;
+      rule.abortReason = errorCode;
+    },
+    waitForCall: async (options = {}) => {
+      const targetCount = options.count ?? 1;
+      const timeoutMs = options.timeout ?? 5e3;
+      if (rule.calls.length >= targetCount) {
+        return rule.calls[targetCount - 1];
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          const idx = rule.waitResolvers.findIndex((w) => w.resolve === resolve);
+          if (idx !== -1) rule.waitResolvers.splice(idx, 1);
+          reject(
+            new Error(
+              `Spectra.intercept waitForCall timed out after ${timeoutMs}ms (expected at least ${targetCount} call(s), received ${rule.calls.length})`
+            )
+          );
+        }, timeoutMs);
+        rule.waitResolvers.push({
+          count: targetCount,
+          resolve: (req) => {
+            clearTimeout(timer);
+            resolve(req);
+          }
+        });
+      });
+    }
+  };
+  const getCount = () => rule.callCount;
+  handle.callCount = Object.assign(getCount, {
+    valueOf: () => rule.callCount,
+    [Symbol.toPrimitive]: () => rule.callCount
+  });
+  Object.defineProperty(handle, "calls", {
+    get: () => rule.calls,
+    enumerable: true
+  });
+  return handle;
+}
+function parseMockRule(patternOrOptions, maybeMethodOrHandler, maybeFixture, maybeOptions) {
+  let pattern;
+  let method;
+  let response;
+  let statusCode;
+  let headers;
+  let delayMs;
+  if (typeof patternOrOptions === "object" && patternOrOptions !== null) {
+    pattern = patternOrOptions.url || patternOrOptions.pattern || "*";
+    method = (patternOrOptions.method || "GET").toUpperCase();
+    response = patternOrOptions.response !== void 0 ? patternOrOptions.response : typeof maybeMethodOrHandler === "object" && maybeMethodOrHandler !== null ? maybeMethodOrHandler : maybeFixture;
+    statusCode = patternOrOptions.statusCode || maybeOptions && maybeOptions.statusCode || 200;
+    headers = patternOrOptions.headers || maybeOptions && maybeOptions.headers;
+    delayMs = patternOrOptions.delayMs ?? (maybeOptions && maybeOptions.delayMs);
+  } else {
+    pattern = String(patternOrOptions || "*");
+    if (typeof maybeMethodOrHandler === "string" && ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "ALL"].includes(maybeMethodOrHandler.toUpperCase())) {
+      method = maybeMethodOrHandler.toUpperCase();
+      const fixtureObj = maybeFixture;
+      response = fixtureObj && fixtureObj.body !== void 0 ? fixtureObj.body : maybeFixture;
+      statusCode = maybeOptions && maybeOptions.statusCode || fixtureObj && fixtureObj.statusCode || 200;
+      headers = maybeOptions && maybeOptions.headers || fixtureObj && fixtureObj.headers;
+      delayMs = (maybeOptions && maybeOptions.delayMs) ?? (fixtureObj && fixtureObj.delayMs);
+    } else {
+      method = "GET";
+      const fixtureObj = maybeMethodOrHandler;
+      response = fixtureObj && fixtureObj.body !== void 0 ? fixtureObj.body : maybeMethodOrHandler;
+      statusCode = maybeFixture && maybeFixture.statusCode || fixtureObj && fixtureObj.statusCode || 200;
+      headers = maybeFixture && maybeFixture.headers || fixtureObj && fixtureObj.headers;
+      delayMs = (maybeFixture && maybeFixture.delayMs) ?? (fixtureObj && fixtureObj.delayMs);
+    }
+  }
+  return {
+    pattern,
+    method,
+    response,
+    statusCode,
+    headers,
+    delayMs,
+    callCount: 0,
+    respondOnceQueue: [],
+    calls: [],
+    waitResolvers: []
+  };
+}
+function findMatchingRule(rules, url, method) {
+  for (const rule of rules) {
+    if (matchesUrlPattern(rule.pattern, url)) {
+      if (!rule.method || rule.method === "ALL" || rule.method.toUpperCase() === method.toUpperCase()) {
+        return rule;
+      }
+    }
+  }
+  return null;
+}
+function recordMockCall(rule, request) {
+  rule.calls.push(request);
+  rule.callCount++;
+  for (let i = rule.waitResolvers.length - 1; i >= 0; i--) {
+    const w = rule.waitResolvers[i];
+    if (rule.callCount >= w.count) {
+      rule.waitResolvers.splice(i, 1);
+      w.resolve(request);
+    }
+  }
+  return request;
+}
+function consumeMockResponse(rule) {
+  if (rule.respondOnceQueue.length > 0) {
+    const queued = rule.respondOnceQueue.shift();
+    return {
+      body: queued.response,
+      statusCode: queued.statusCode || rule.statusCode || 200,
+      headers: { ...rule.headers, ...queued.headers },
+      delayMs: queued.delayMs ?? rule.delayMs
+    };
+  }
+  return {
+    body: rule.response,
+    statusCode: rule.statusCode || 200,
+    headers: { ...rule.headers },
+    delayMs: rule.delayMs
+  };
+}
+var DEFAULT_MOCK_RESPONSE_HEADERS = {
+  "Content-Type": "application/json; charset=utf-8",
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+function mergeMockResponseHeaders(custom) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(DEFAULT_MOCK_RESPONSE_HEADERS)) {
+    merged.set(k.toLowerCase(), { name: k, value: v });
+  }
+  for (const [k, v] of Object.entries(custom || {})) {
+    merged.set(k.toLowerCase(), { name: k, value: String(v) });
+  }
+  return [...merged.values()];
+}
+function mockResponseBodyText(body) {
+  if (typeof body === "string") return body;
+  if (typeof body === "object" && body !== null) return JSON.stringify(body);
+  return String(body ?? "");
+}
+
+// ../../core/worker-runtime/src/dsl/selector_resolver.ts
+function parseA11ySelector(selector) {
   const trimmed = selector.trim();
-  if (trimmed.startsWith("~")) {
-    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}`;
+  if (!trimmed.startsWith("~")) return null;
+  const withoutPrefix = trimmed.slice(1);
+  const bracketIndex = withoutPrefix.indexOf("[");
+  if (bracketIndex !== -1) {
+    return {
+      name: withoutPrefix.slice(0, bracketIndex),
+      chainSuffix: withoutPrefix.slice(bracketIndex)
+    };
+  }
+  return { name: withoutPrefix, chainSuffix: "" };
+}
+function toCssSelectorA11y(selector) {
+  const parsed = parseA11ySelector(selector);
+  if (!parsed) return null;
+  const { name, chainSuffix } = parsed;
+  const q = JSON.stringify(name);
+  return `:is([aria-label=${q}], [title=${q}])${chainSuffix}`;
+}
+function resolveLabelledBy(name, root, index) {
+  const all = Array.from(root.querySelectorAll("[aria-labelledby]"));
+  const matches = all.filter((el) => {
+    const ids = (el.getAttribute("aria-labelledby") ?? "").trim().split(/\s+/);
+    const label = ids.map((id) => {
+      const ref = document.getElementById(id);
+      return ref ? (ref.textContent ?? "").trim() : "";
+    }).filter(Boolean).join(" ").trim();
+    return label === name;
+  });
+  if (index === null) return matches[0] ?? null;
+  if (index >= 0) return matches[index] ?? null;
+  return matches[matches.length + index] ?? null;
+}
+
+// src/network_patch.ts
+var fetchPatched = false;
+var xhrPatched = false;
+var activeGetRules = null;
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function toAbsoluteUrl(input) {
+  try {
+    if (typeof input === "string") return new URL(input, selfURL()).href;
+    if (input instanceof URL) return input.href;
+    if (typeof Request !== "undefined" && input instanceof Request) return input.url;
+  } catch {
+  }
+  return String(input);
+}
+function selfURL() {
+  try {
+    if (typeof location !== "undefined" && location.href) return location.href;
+  } catch {
+  }
+  return "http://localhost/";
+}
+function readMethod(input, init) {
+  if (init?.method) return String(init.method).toUpperCase();
+  try {
+    if (typeof Request !== "undefined" && input instanceof Request && input.method) {
+      return String(input.method).toUpperCase();
     }
-    return `[aria-label=${JSON.stringify(raw)}]`;
+  } catch {
+  }
+  return "GET";
+}
+function readPostData(input, init) {
+  const body = init?.body;
+  if (typeof body === "string") return body;
+  try {
+    if (typeof Request !== "undefined" && input instanceof Request) return void 0;
+  } catch {
+  }
+  return void 0;
+}
+function buildMockResponse(consumed) {
+  const headerPairs = mergeMockResponseHeaders(consumed.headers);
+  const headers = {};
+  for (const h of headerPairs) headers[h.name] = h.value;
+  return new Response(mockResponseBodyText(consumed.body), { status: consumed.statusCode, headers });
+}
+async function patchedFetch(originalFetch, input, init) {
+  const url = toAbsoluteUrl(input);
+  const method = readMethod(input, init);
+  const rule = findMatchingRule(activeGetRules?.() ?? [], url, method);
+  if (!rule) return originalFetch(input, init);
+  const intercepted = {
+    url,
+    method,
+    headers: void 0,
+    postData: readPostData(input, init),
+    timestamp: Date.now()
+  };
+  recordMockCall(rule, intercepted);
+  if (rule.aborted) {
+    throw new TypeError(`Spectra.intercept() aborted ${method} ${url} (${rule.abortReason || "Failed"})`);
+  }
+  const consumed = consumeMockResponse(rule);
+  if (consumed.delayMs && consumed.delayMs > 0) await sleep(consumed.delayMs);
+  return buildMockResponse(consumed);
+}
+function patchXMLHttpRequest() {
+  const OriginalXHR = globalThis.XMLHttpRequest;
+  function PatchedXHR() {
+    const xhr = new OriginalXHR();
+    let method = "GET";
+    let url = "";
+    const origOpen = OriginalXHR.prototype.open.bind(xhr);
+    const origSend = OriginalXHR.prototype.send.bind(xhr);
+    xhr.open = (m, u, ...rest) => {
+      method = String(m).toUpperCase();
+      url = toAbsoluteUrl(u);
+      const [asyncFlag = true, username, password] = rest;
+      return origOpen(m, u, asyncFlag, username, password);
+    };
+    xhr.send = (body) => {
+      const rule = findMatchingRule(activeGetRules?.() ?? [], url, method);
+      if (!rule) return origSend(body);
+      const intercepted = {
+        url,
+        method,
+        headers: void 0,
+        postData: typeof body === "string" ? body : void 0,
+        timestamp: Date.now()
+      };
+      recordMockCall(rule, intercepted);
+      const fireError = () => {
+        xhr.dispatchEvent(new Event("error"));
+      };
+      if (rule.aborted) {
+        setTimeout(fireError, 0);
+        return;
+      }
+      const consumed = consumeMockResponse(rule);
+      const respond2 = () => {
+        const bodyText = mockResponseBodyText(consumed.body);
+        Object.defineProperties(xhr, {
+          status: { value: consumed.statusCode, configurable: true },
+          statusText: {
+            value: consumed.statusCode === 200 ? "OK" : `${consumed.statusCode} Mocked`,
+            configurable: true
+          },
+          responseText: { value: bodyText, configurable: true },
+          response: { value: bodyText, configurable: true },
+          readyState: { value: 4, configurable: true }
+        });
+        xhr.dispatchEvent(new Event("readystatechange"));
+        xhr.dispatchEvent(new Event("load"));
+        xhr.dispatchEvent(new Event("loadend"));
+      };
+      if (consumed.delayMs && consumed.delayMs > 0) setTimeout(respond2, consumed.delayMs);
+      else setTimeout(respond2, 0);
+    };
+    return xhr;
+  }
+  PatchedXHR.prototype = OriginalXHR.prototype;
+  globalThis.XMLHttpRequest = PatchedXHR;
+}
+function ensureNetworkPatch(getRules) {
+  activeGetRules = getRules;
+  if (!fetchPatched && typeof globalThis.fetch === "function") {
+    const originalFetch = globalThis.fetch.bind(globalThis);
+    globalThis.fetch = (input, init) => patchedFetch(originalFetch, input, init);
+    fetchPatched = true;
+  }
+  if (!xhrPatched && typeof globalThis.XMLHttpRequest === "function") {
+    patchXMLHttpRequest();
+    xhrPatched = true;
   }
-  return trimmed;
+}
+
+// src/dom_driver_bridge.ts
+function getUser() {
+  return userEvent.setup({ delay: null });
+}
+function resolveSelector(selector) {
+  const css = toCssSelectorA11y(selector.trim());
+  return css ?? selector.trim();
 }
 function resolveEl(selector, index) {
   const css = resolveSelector(selector);
-  if (index === null) {
-    return document.querySelector(css);
-  }
-  const all = Array.from(document.querySelectorAll(css));
-  if (index >= 0) return all[index] ?? null;
-  return all[all.length + index] ?? null;
+  const fromCss = () => {
+    if (index === null) return document.querySelector(css);
+    const all = Array.from(document.querySelectorAll(css));
+    if (index >= 0) return all[index] ?? null;
+    return all[all.length + index] ?? null;
+  };
+  const el = fromCss();
+  if (el !== null) return el;
+  const parsed = parseA11ySelector(selector.trim());
+  if (parsed) return resolveLabelledBy(parsed.name, document, index);
+  return null;
 }
 function isFormEl(el) {
   const tag = el.tagName;
@@ -98,12 +463,98 @@ var DomDriverBridge = class {
   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));
+    if (el.tagName === "INPUT" && el.type === "file") {
+      return this.upload(selector, value, index);
+    }
     const u = getUser();
     await u.clear(el);
     if (String(value).length > 0) {
       await u.type(el, String(value));
     }
   }
+  async upload(selector, files, index = null) {
+    const el = await this.waitForEl(selector, index);
+    const fileList = Array.isArray(files) ? files : [files];
+    const filesToUpload = [];
+    const MIME_MAP = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      webp: "image/webp",
+      pdf: "application/pdf",
+      json: "application/json",
+      txt: "text/plain",
+      csv: "text/csv"
+    };
+    for (const item of fileList) {
+      if (typeof item === "string") {
+        let fileName = "file.bin";
+        let mimeType = "application/octet-stream";
+        let blob;
+        if (item.startsWith("data:")) {
+          const commaIdx = item.indexOf(",");
+          const header = item.slice(0, commaIdx);
+          const base64Data = item.slice(commaIdx + 1);
+          const mimeMatch = header.match(/data:([^;]+)/);
+          if (mimeMatch) mimeType = mimeMatch[1];
+          const nameMatch = header.match(/(?:name|filename)=([^;]+)/i);
+          if (nameMatch) {
+            fileName = decodeURIComponent(nameMatch[1]);
+          } else {
+            const ext = mimeType.split("/")[1] || "bin";
+            fileName = `fixture.${ext}`;
+          }
+          try {
+            const binaryStr = atob(base64Data);
+            const bytes = new Uint8Array(binaryStr.length);
+            for (let i = 0; i < binaryStr.length; i++) {
+              bytes[i] = binaryStr.charCodeAt(i);
+            }
+            blob = new Blob([bytes], { type: mimeType });
+          } catch {
+            blob = new Blob([base64Data], { type: mimeType });
+          }
+        } else {
+          const cleanPath = item.split("?")[0].split("#")[0];
+          fileName = cleanPath.split("/").pop()?.split("\\").pop() || "fixture.bin";
+          const ext = fileName.split(".").pop()?.toLowerCase() || "";
+          mimeType = MIME_MAP[ext] || "application/octet-stream";
+          blob = new Blob(["Mock file content for " + fileName], { type: mimeType });
+        }
+        filesToUpload.push(new File([blob], fileName, { type: mimeType }));
+      } else if (item instanceof File) {
+        filesToUpload.push(item);
+      } else if (item && typeof item === "object" && "name" in item) {
+        const obj = item;
+        const mimeType = obj.type || "application/octet-stream";
+        let blob;
+        if (obj.base64) {
+          try {
+            const binaryStr = atob(obj.base64);
+            const bytes = new Uint8Array(binaryStr.length);
+            for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+            blob = new Blob([bytes], { type: mimeType });
+          } catch {
+            blob = new Blob([obj.base64], { type: mimeType });
+          }
+        } else {
+          blob = new Blob([obj.content || "Mock content"], { type: mimeType });
+        }
+        filesToUpload.push(new File([blob], obj.name, { type: mimeType }));
+      }
+    }
+    if (filesToUpload.length > 0) {
+      const dt = new DataTransfer();
+      for (const f of filesToUpload) {
+        dt.items.add(f);
+      }
+      el.files = dt.files;
+      el.dispatchEvent(new Event("input", { bubbles: true }));
+      el.dispatchEvent(new Event("change", { bubbles: true }));
+    }
+  }
   async clearValue(selector, index = null) {
     const el = await this.waitForEl(selector, index);
     await getUser().clear(el);
@@ -311,13 +762,15 @@ var DomDriverBridge = class {
   async clearLocalStorage() {
     window.localStorage.clear();
   }
-  // ─── Network Interception (Out of Scope for Component Testing MVP) ─────
-  async intercept(_patternOrOptions, _method, _fixture, _options) {
-    throw new Error(
-      'Spectra.intercept() is not supported in component testing mode \u2014 there is no network boundary between the test and the mounted component to intercept. Mock fetch/HTTP clients directly instead (e.g. `vi.spyOn(global, "fetch")` or MSW).'
-    );
+  // ─── Network Interception (in-page fetch/XHR patch — see network_patch.ts) ──
+  async intercept(patternOrOptions, method, fixture, options) {
+    const rule = parseMockRule(patternOrOptions, method, fixture, options);
+    ensureNetworkPatch(() => this.mockRules);
+    this.mockRules.push(rule);
+    return createMockHandle(rule);
   }
   clearMocks() {
+    this.mockRules = [];
   }
 };
 
@@ -413,7 +866,11 @@ function buildAutoImportManifest(root) {
   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 readdirSync(dir).filter((f) => !f.startsWith(".") && !f.endsWith(".d.ts")).map((f) => {
+      const ext = path.extname(f);
+      const name = path.basename(f, ext);
+      return { name, path: path.join(dir, f).replace(/\\/g, "/") };
+    });
   }
   return {
     pageObjects: scanEntityDir("page-objects", (p) => `${p}.tsx`),
@@ -712,7 +1169,10 @@ async function buildBundle(entrypoint, opts = {}) {
       ".woff": "dataurl",
       ".woff2": "dataurl",
       ".ttf": "dataurl",
-      ".eot": "dataurl"
+      ".eot": "dataurl",
+      ".pdf": "dataurl",
+      ".txt": "text",
+      ".csv": "text"
     },
     logLevel: "error",
     logOverride: {
@@ -981,6 +1441,29 @@ function makeHandler(testRoot, packageDir, harnessHtml, setupEntrypoint, runnerE
         }
         return;
       }
+      const lower = resolved.toLowerCase();
+      if (lower.endsWith(".png") || lower.endsWith(".jpg") || lower.endsWith(".jpeg") || lower.endsWith(".gif") || lower.endsWith(".webp") || lower.endsWith(".svg") || lower.endsWith(".pdf")) {
+        try {
+          const raw = fs.readFileSync(resolved);
+          const ext = path3.extname(lower);
+          const fileName = path3.basename(resolved);
+          const mime = ext === ".pdf" ? "application/pdf" : ext === ".svg" ? "image/svg+xml" : `image/${ext.replace(/^\./, "")}`;
+          const dataUrl = `data:${mime};name=${encodeURIComponent(fileName)};base64,${raw.toString("base64")}`;
+          respond(res, 200, "application/javascript; charset=utf-8", `export default ${JSON.stringify(dataUrl)};`);
+        } catch {
+          respond(res, 500, "application/javascript", `export default ${JSON.stringify(resolved)};`);
+        }
+        return;
+      }
+      if (lower.endsWith(".txt") || lower.endsWith(".csv")) {
+        try {
+          const raw = fs.readFileSync(resolved, "utf-8");
+          respond(res, 200, "application/javascript; charset=utf-8", `export default ${JSON.stringify(raw)};`);
+        } catch {
+          respond(res, 500, "application/javascript", `export default ${JSON.stringify(resolved)};`);
+        }
+        return;
+      }
       try {
         const js = await getCachedBundle(resolved, resolved);
         respond(res, 200, "application/javascript; charset=utf-8", js);

package/dist/runner.js

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