@noego/wood 0.4.9 → 0.5.0

package/dist/testing/browser.cjs

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browser_exports = {};
 __export(browser_exports, {
   browser: () => browser,
-  createBrowserBridgeFixture: () => createBrowserBridgeFixture
+  createBrowserBridgeFixture: () => createBrowserBridgeFixture,
+  startSharedBrowserViteServer: () => startSharedBrowserViteServer
 });
 module.exports = __toCommonJS(browser_exports);
 var import_node_fs = __toESM(require("node:fs"), 1);
@@ -39,6 +40,7 @@ var import_node_path = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
 var import_tracing = require("../tracing/index.js");
 var import_trace_testing = require("../trace-testing/index.js");
+var import_geometry = require("./geometry.js");
 const DEFAULT_VIEWPORT = {
   width: 1280,
   height: 800
@@ -48,6 +50,7 @@ const DEFAULT_RESOURCE_CLOSE_TIMEOUT_MS = 5e3;
 const WORKER_RUNTIME_IDLE_CLOSE_MS = 5e3;
 const browserWorkerRuntimes = /* @__PURE__ */ new Map();
 const browserWorkerCacheDirs = /* @__PURE__ */ new Set();
+const browserConnectWarnings = /* @__PURE__ */ new Set();
 process.on("exit", () => {
   for (const cacheDir of browserWorkerCacheDirs) {
     try {
@@ -211,8 +214,9 @@ function buildBridgeInitScript(manifest, traceConfig, transportMode) {
 })();
 `;
 }
-async function loadPlaywright(browserName) {
-  const playwright = await import("playwright");
+async function loadPlaywright(browserName, rootDir) {
+  const playwrightPath = resolvePackageModule(rootDir, "playwright");
+  const playwright = playwrightPath ? await import((0, import_node_url.pathToFileURL)(playwrightPath).href) : await import("playwright");
   return playwright[browserName];
 }
 async function loadVite() {
@@ -313,7 +317,14 @@ async function createViteServer(rootDir, cacheDir) {
     resolve: {
       dedupe: ["svelte"]
     },
-    server: { port: 0, fs: { allow: [rootDir, import_node_os.default.tmpdir()] } }
+    server: {
+      port: 0,
+      // Browser harnesses write independent HTML/entry files concurrently.
+      // HMR would broadcast another harness's temp-file changes to every page,
+      // causing unrelated mounts to reload; tests only need request-time transforms.
+      hmr: false,
+      fs: { allow: [rootDir, import_node_os.default.tmpdir()] }
+    }
   });
   await server.listen();
   return server;
@@ -322,21 +333,53 @@ function workerRuntimeKey(input) {
   return [
     input.rootDir,
     input.browserName,
-    input.headless ? "headless" : "headed"
+    input.headless ? "headless" : "headed",
+    input.wsEndpoint ?? "local-browser",
+    input.viteUrl ?? "local-vite"
   ].join("::");
 }
 async function createBrowserWorkerRuntime(input) {
-  const cacheRoot = import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "wood-browser-vite-"));
-  browserWorkerCacheDirs.add(cacheRoot);
   let browser2 = null;
+  let cacheRoot = null;
+  let ownedServer = null;
   try {
-    const playwrightBrowser = await loadPlaywright(input.browserName);
-    browser2 = await playwrightBrowser.launch({ headless: input.headless });
-    const server = await createViteServer(input.rootDir, import_node_path.default.join(cacheRoot, ".vite"));
+    const playwrightBrowser = await loadPlaywright(input.browserName, input.rootDir);
+    if (input.wsEndpoint) {
+      try {
+        browser2 = await playwrightBrowser.connect(input.wsEndpoint);
+      } catch (error) {
+        if (!browserConnectWarnings.has(input.wsEndpoint)) {
+          browserConnectWarnings.add(input.wsEndpoint);
+          console.warn(
+            `[wood browser] Could not connect to shared Chromium at "${input.wsEndpoint}"; falling back to a per-worker launch.`,
+            error
+          );
+        }
+      }
+    }
+    if (!browser2) {
+      browser2 = await playwrightBrowser.launch({ headless: input.headless });
+    }
+    let vite;
+    if (input.viteUrl) {
+      vite = {
+        baseUrl: input.viteUrl,
+        ownership: "external"
+      };
+    } else {
+      cacheRoot = import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "wood-browser-vite-"));
+      browserWorkerCacheDirs.add(cacheRoot);
+      ownedServer = await createViteServer(input.rootDir, import_node_path.default.join(cacheRoot, ".vite"));
+      vite = {
+        baseUrl: serverBaseUrl(ownedServer),
+        ownership: "worker",
+        server: ownedServer,
+        cacheDir: cacheRoot
+      };
+    }
     return {
       browser: browser2,
-      server,
-      cacheDir: cacheRoot,
+      vite,
       rootDir: input.rootDir,
       key: input.key,
       activeHarnesses: 0,
@@ -344,18 +387,25 @@ async function createBrowserWorkerRuntime(input) {
       idleCloseTimer: null
     };
   } catch (error) {
-    await browser2?.close().catch(() => void 0);
-    import_node_fs.default.rmSync(cacheRoot, { recursive: true, force: true });
-    browserWorkerCacheDirs.delete(cacheRoot);
+    await Promise.all([
+      browser2?.close().catch(() => void 0),
+      ownedServer?.close().catch(() => void 0)
+    ]);
+    if (cacheRoot) {
+      import_node_fs.default.rmSync(cacheRoot, { recursive: true, force: true });
+      browserWorkerCacheDirs.delete(cacheRoot);
+    }
     throw error;
   }
 }
 async function acquireBrowserWorkerRuntime(input) {
-  const key = workerRuntimeKey(input);
+  const wsEndpoint = input.browserName === "chromium" ? process.env.WOOD_BROWSER_WS_ENDPOINT : void 0;
+  const viteUrl = process.env.WOOD_BROWSER_VITE_URL;
+  const key = workerRuntimeKey({ ...input, wsEndpoint, viteUrl });
   let entry = browserWorkerRuntimes.get(key);
   if (!entry) {
     entry = {
-      promise: createBrowserWorkerRuntime({ ...input, key })
+      promise: createBrowserWorkerRuntime({ ...input, wsEndpoint, viteUrl, key })
     };
     browserWorkerRuntimes.set(key, entry);
   }
@@ -378,12 +428,14 @@ async function closeBrowserWorkerRuntime(runtime) {
   runtime.closing = true;
   try {
     await Promise.all([
-      waitForBoundedClose(runtime.server.close()),
+      ...runtime.vite.ownership === "worker" ? [waitForBoundedClose(runtime.vite.server.close())] : [],
       waitForBoundedClose(runtime.browser.close())
     ]);
   } finally {
-    import_node_fs.default.rmSync(runtime.cacheDir, { recursive: true, force: true });
-    browserWorkerCacheDirs.delete(runtime.cacheDir);
+    if (runtime.vite.ownership === "worker") {
+      import_node_fs.default.rmSync(runtime.vite.cacheDir, { recursive: true, force: true });
+      browserWorkerCacheDirs.delete(runtime.vite.cacheDir);
+    }
     const entry = browserWorkerRuntimes.get(runtime.key);
     const current = entry ? await entry.promise.catch(() => null) : null;
     if (current === runtime) {
@@ -410,6 +462,35 @@ function releaseBrowserWorkerRuntime(runtime) {
 function serverBaseUrl(server) {
   return server.resolvedUrls?.local?.[0] ?? "http://127.0.0.1:5173";
 }
+async function startSharedBrowserViteServer(input) {
+  const rootDir = normalizeRoot(input.rootDir);
+  const cacheRoot = import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "wood-browser-vite-"));
+  browserWorkerCacheDirs.add(cacheRoot);
+  let server = null;
+  try {
+    server = await createViteServer(rootDir, import_node_path.default.join(cacheRoot, ".vite"));
+  } catch (error) {
+    import_node_fs.default.rmSync(cacheRoot, { recursive: true, force: true });
+    browserWorkerCacheDirs.delete(cacheRoot);
+    throw error;
+  }
+  let closed = false;
+  return {
+    url: serverBaseUrl(server),
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      try {
+        await waitForBoundedClose(server.close());
+      } finally {
+        import_node_fs.default.rmSync(cacheRoot, { recursive: true, force: true });
+        browserWorkerCacheDirs.delete(cacheRoot);
+      }
+    }
+  };
+}
 function assertFileExists(filePath, label) {
   if (!import_node_fs.default.existsSync(filePath)) {
     throw new Error(`${label} does not exist: ${filePath}`);
@@ -808,15 +889,6 @@ function collectMaxPaintOrders(snapshot) {
   }
   return paintByBackend;
 }
-function axisEdges(rect, axis) {
-  return axis === "horizontal" ? { leading: rect.left, trailing: rect.right } : { leading: rect.top, trailing: rect.bottom };
-}
-function axisGap(first, second, axis) {
-  const a = axisEdges(first, axis);
-  const b = axisEdges(second, axis);
-  const [earlier, later] = a.leading <= b.leading ? [a, b] : [b, a];
-  return later.leading - earlier.trailing;
-}
 function describeGapConstraint(constraint) {
   const parts = [];
   if (constraint.equals !== void 0) parts.push(`equals ${constraint.equals}`);
@@ -836,11 +908,6 @@ function gapConstraintViolation(gap, constraint, tolerance) {
   }
   return null;
 }
-function rectsOverlap(a, b) {
-  return Boolean(
-    a && b && a.left < b.right && a.right > b.left && a.top < b.bottom && a.bottom > b.top
-  );
-}
 const COVERAGE_STYLE_KEYS = [
   "opacity",
   "visibility",
@@ -858,9 +925,6 @@ function colorAlphaIsZero(color) {
   const parts = match[1].split(",").map((s) => s.trim());
   return parts.length >= 4 && parseFloat(parts[3]) === 0;
 }
-function snapshotRectsOverlap(a, b) {
-  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
-}
 function indexLayoutNodes(doc, strings) {
   const byNode = /* @__PURE__ */ new Map();
   const nodeIndex = doc.layout?.nodeIndex ?? [];
@@ -945,7 +1009,7 @@ function collectCoverageCandidates(doc, strings, targetNodeIndex) {
     if (nodeType[ni] !== 1) continue;
     if (ni === targetNodeIndex) continue;
     if (isSnapshotAncestor(parentIndex, ni, targetNodeIndex) || isSnapshotAncestor(parentIndex, targetNodeIndex, ni)) continue;
-    if (!snapshotRectsOverlap(rec.rect, target.rect)) continue;
+    if (!(0, import_geometry.snapshotRectsOverlap)(rec.rect, target.rect)) continue;
     const hasContent = snapshotNodeHasOwnContent(nodes, strings, ni);
     if (snapshotNodePaintsNothing(rec.styles, hasContent)) continue;
     covers.push({ description: describeSnapshotNode(nodes, strings, ni), paint: rec.paint, rect: rec.rect });
@@ -1040,7 +1104,7 @@ function createExpect(page, outputDir) {
     if (top.paintOrder > lower.paintOrder) return;
     const topRect = await firstRect(page, topSelector);
     const lowerRect = await firstRect(page, lowerSelector);
-    const overlapNote = rectsOverlap(topRect, lowerRect) ? "" : ` (Note: the rects do not overlap, so there is no shared pixel where front/behind is visually observable \u2014 this is a global paint-order verdict.)`;
+    const overlapNote = (0, import_geometry.rectsOverlap)(topRect, lowerRect) ? "" : ` (Note: the rects do not overlap, so there is no shared pixel where front/behind is visually observable \u2014 this is a global paint-order verdict.)`;
     throw new Error(
       `Expected "${topSelector}" (paint order ${top.paintOrder}) to paint in front of "${lowerSelector}" (paint order ${lower.paintOrder}), but it paints at or behind it (higher paint order == on top).${overlapNote}`
     );
@@ -1109,8 +1173,7 @@ function createExpect(page, outputDir) {
       const first = await elementRect(page, firstSelector);
       const second = await elementRect(page, secondSelector);
       if (!first || !second) throw new Error(`Expected both "${firstSelector}" and "${secondSelector}" to exist.`);
-      const overlaps = first.left < second.right && first.right > second.left && first.top < second.bottom && first.bottom > second.top;
-      if (overlaps) {
+      if ((0, import_geometry.rectsOverlap)(first, second)) {
         throw new Error(`Expected "${firstSelector}" not to overlap "${secondSelector}".`);
       }
     },
@@ -1153,8 +1216,9 @@ function createExpect(page, outputDir) {
       const first = await firstRect(page, a);
       const second = await firstRect(page, b);
       if (!first || !second) throw new Error(`Expected both "${a}" and "${b}" to exist.`);
-      const delta = Math.abs(first[edge] - second[edge]);
-      if (delta > tolerance) {
+      const verdict = (0, import_geometry.sharedEdges)([first, second], edge, { tolerance });
+      if (!verdict.pass) {
+        const delta = Number(verdict.details?.maximumDelta);
         throw new Error(
           `Expected "${a}" and "${b}" to share ${edge} edge within ${tolerance}px, but delta was ${delta.toFixed(2)}px ("${a}".${edge}=${first[edge].toFixed(2)}, "${b}".${edge}=${second[edge].toFixed(2)}). Rects: ${a}=${JSON.stringify(first)}, ${b}=${JSON.stringify(second)}`
         );
@@ -1218,7 +1282,7 @@ function createExpect(page, outputDir) {
       const first = await firstRect(page, a);
       const second = await firstRect(page, b);
       if (!first || !second) throw new Error(`Expected both "${a}" and "${b}" to exist.`);
-      const gap = axisGap(first, second, axis);
+      const gap = (0, import_geometry.axisGap)(first, second, axis);
       const allowsNegative = options.equals !== void 0 && options.equals < 0 || options.min !== void 0 && options.min < 0;
       const rectsNote = `Rects: ${a}=${JSON.stringify(first)}, ${b}=${JSON.stringify(second)}`;
       if (gap < -tolerance && !allowsNegative) {
@@ -1245,16 +1309,24 @@ function createExpect(page, outputDir) {
         if (!rect) throw new Error(`Expected "${selector}" to exist.`);
         boxes.push({ selector, rect });
       }
-      const sorted = [...boxes].sort((x, y) => axisEdges(x.rect, axis).leading - axisEdges(y.rect, axis).leading);
-      const gaps = sorted.slice(1).map((box, i) => ({
-        from: sorted[i].selector,
-        to: box.selector,
-        gap: axisGap(sorted[i].rect, box.rect, axis)
-      }));
-      const widest = gaps.reduce((acc, g) => g.gap > acc.gap ? g : acc);
-      const narrowest = gaps.reduce((acc, g) => g.gap < acc.gap ? g : acc);
-      const spread = widest.gap - narrowest.gap;
-      if (spread > tolerance) {
+      const verdict = (0, import_geometry.evenSpacing)(
+        boxes.map((box) => box.rect),
+        axis,
+        { tolerance }
+      );
+      if (!verdict.pass) {
+        const sorted = [...boxes].sort(
+          (x, y) => (0, import_geometry.axisEdges)(x.rect, axis).leading - (0, import_geometry.axisEdges)(y.rect, axis).leading
+        );
+        const measuredGaps = verdict.details?.gaps;
+        const gaps = sorted.slice(1).map((box, i) => ({
+          from: sorted[i].selector,
+          to: box.selector,
+          gap: measuredGaps[i]
+        }));
+        const widest = gaps.reduce((acc, g) => g.gap > acc.gap ? g : acc);
+        const narrowest = gaps.reduce((acc, g) => g.gap < acc.gap ? g : acc);
+        const spread = Number(verdict.details?.spread);
         const list = gaps.map((g) => `${g.from}\u2192${g.to}=${g.gap.toFixed(2)}px`).join(", ");
         throw new Error(
           `Expected elements to be evenly spaced along ${axis} within ${tolerance}px, but gap spread was ${spread.toFixed(2)}px (widest ${widest.from}\u2192${widest.to}=${widest.gap.toFixed(2)}px, narrowest ${narrowest.from}\u2192${narrowest.to}=${narrowest.gap.toFixed(2)}px). Gaps: ${list}`
@@ -1334,7 +1406,7 @@ async function openMountPage(input) {
     ...input.context
   };
   await input.hooks?.beforeMount?.(context);
-  await page.goto(`${serverBaseUrl(input.runtime.server)}${viteImport(htmlPath)}`, {
+  await page.goto(`${input.runtime.baseUrl}${viteImport(htmlPath)}`, {
     waitUntil: "domcontentloaded"
   });
   for (const event of input.bridge.state.initialEvents) {
@@ -1398,7 +1470,7 @@ async function createHarness(config = {}) {
   }
   const runtime = {
     context,
-    server: workerRuntime.server,
+    baseUrl: workerRuntime.vite.baseUrl,
     page,
     tempDir,
     rootDir,
@@ -1568,6 +1640,7 @@ const browser = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   browser,
-  createBrowserBridgeFixture
+  createBrowserBridgeFixture,
+  startSharedBrowserViteServer
 });
 //# sourceMappingURL=browser.cjs.map