@ultimat3/testing 27.10.1 → 27.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/testing",
-  "version": "27.10.1",
+  "version": "27.10.2",
   "description": "Test harness: cloned template DBs per worker, frozen clock, sealed network, 6 test types",
   "license": "MIT",
   "type": "module",
@@ -36,20 +36,20 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "27.10.1",
-    "@ultimat3/cache": "27.10.1",
-    "@ultimat3/core": "27.10.1",
-    "@ultimat3/db": "27.10.1",
-    "@ultimat3/entity": "27.10.1",
-    "@ultimat3/http": "27.10.1",
-    "@ultimat3/i18n": "27.10.1",
-    "@ultimat3/jobs": "27.10.1",
-    "@ultimat3/mail": "27.10.1",
-    "@ultimat3/policy": "27.10.1",
-    "@ultimat3/pwa": "27.10.1",
-    "@ultimat3/query": "27.10.1",
-    "@ultimat3/realtime": "27.10.1",
-    "@ultimat3/render": "27.10.1",
-    "@ultimat3/time": "27.10.1"
+    "@ultimat3/action": "27.10.2",
+    "@ultimat3/cache": "27.10.2",
+    "@ultimat3/core": "27.10.2",
+    "@ultimat3/db": "27.10.2",
+    "@ultimat3/entity": "27.10.2",
+    "@ultimat3/http": "27.10.2",
+    "@ultimat3/i18n": "27.10.2",
+    "@ultimat3/jobs": "27.10.2",
+    "@ultimat3/mail": "27.10.2",
+    "@ultimat3/policy": "27.10.2",
+    "@ultimat3/pwa": "27.10.2",
+    "@ultimat3/query": "27.10.2",
+    "@ultimat3/realtime": "27.10.2",
+    "@ultimat3/render": "27.10.2",
+    "@ultimat3/time": "27.10.2"
   }
 }

package/src/cdp-e2e-page.ts

@@ -30,6 +30,20 @@ const evaluated = (result: Record<string, unknown> | undefined): unknown => {
   return (remote as Record<string, unknown>)['value'];
 };
 
+/**
+ * What Chrome answers a `Runtime.evaluate` that was in flight when the document committed (#774):
+ * the call is refused at the protocol level, not thrown in the page. The same first text is also
+ * what a CLOSED tab answers, which is why `waitFor` asks for the target before it polls again.
+ */
+const NAVIGATED_AWAY = [
+  'Inspected target navigated or closed',
+  'Execution context was destroyed',
+  'Cannot find context with specified id',
+] as const;
+
+const navigatedAway = (error: unknown): error is CdpCallFailedError =>
+  error instanceof CdpCallFailedError && NAVIGATED_AWAY.some((text) => error.cause.includes(text));
+
 /** One tab: the port the driver drives, plus what a multi-tab acceptance suite asks of one. */
 export interface E2eTab extends E2eBrowserPage {
   readonly targetId: string;
@@ -96,11 +110,33 @@ export function cdpE2eTab(options: CdpE2eTabOptions): E2eTab {
   // leaves the next poll reading a document whose `<body>` is not parsed, and
   // `document.body.textContent` throws there once and holds a poll later. The last throw is kept
   // and named at the deadline, so an expression that can never evaluate still says why.
+  //
+  // A poll the browser REFUSED because the document committed under it is the same "not yet"
+  // (#774) — but only while the tab is still there: a closed tab answers with the same text, and
+  // still refuses at once. Any other refusal (a dead connection) refuses at once too.
+  const tabOpen = (): Promise<boolean> =>
+    send('Target.getTargetInfo', { targetId: options.targetId }).then(
+      () => true,
+      () => false,
+    );
+  const poll = async (expression: string): Promise<Record<string, unknown> | 'navigated'> => {
+    try {
+      return (await evaluateRaw(`Boolean(${expression})`)).result ?? {};
+    } catch (error) {
+      if (navigatedAway(error) && (await tabOpen())) return 'navigated';
+      throw error;
+    }
+  };
   const waitFor = async (expression: string, what: string, timeoutMs = options.loadTimeoutMs) => {
     // Only the PAGE's throw is swallowed: a connection that died still refuses at once.
     let threw: string | undefined;
     for (let waited = 0; waited < timeoutMs; waited += POLL_MS) {
-      const answer = (await evaluateRaw(`Boolean(${expression})`)).result;
+      const answer = await poll(expression);
+      if (answer === 'navigated') {
+        threw = 'the document committed while the poll was in flight';
+        await Bun.sleep(POLL_MS);
+        continue;
+      }
       threw = thrownIn(answer);
       if (threw === undefined && evaluated(answer) === true) return;
       await Bun.sleep(POLL_MS);

package/src/e2e-spawn.ts

@@ -10,7 +10,7 @@ import { get } from 'node:http';
 import { dirname, join } from 'node:path';
 import { assert, DRAIN_DEADLINE_DEFAULT_MS, READINESS_GRACE_DEFAULT_MS } from '@ultimat3/core';
 import { E2eAppFailedError } from './e2e-errors';
-import { freePort } from './free-port';
+import { freePort, freePortApartFrom } from './free-port';
 
 /** `x dev` (sync included), or the production entry `apps/web/server.ts` under `ROLE=web`. */
 export type E2eAppMode = 'dev' | 'serve';
@@ -116,7 +116,9 @@ export async function spawnE2eApp(options: SpawnE2eAppOptions): Promise<SpawnedE
   const port = freePort();
   // Its own scrape port too: every role opens one, the default is a fixed 9090, and a second app —
   // or a developer's `x dev` — already holding it is an app that dies at boot with X_PORT_IN_USE.
-  const metricsPort = freePort();
+  // Apart from the web port AND its neighbour, which `x dev` binds the sync node on: the OS may hand
+  // a just-released port straight back (`freePortApartFrom`).
+  const metricsPort = freePortApartFrom([port, port + 1]);
   const base = `http://localhost:${String(port)}`;
   const command =
     options.mode === 'serve'

package/src/free-port.ts

@@ -28,19 +28,32 @@ const listenOnAnyPort = (): PortProbe => {
  * open. A refused port is KEPT listening while the next is asked for, so the OS cannot answer with
  * it again: the walk ends after at most one ask per refused port, with no counter and no retry.
  */
-export const freePort = (listen: () => PortProbe = listenOnAnyPort): number => {
-  const refused: PortProbe[] = [];
+export const freePort = (listen: () => PortProbe = listenOnAnyPort): number =>
+  freePortApartFrom([], listen);
+
+/**
+ * The same, and none of `taken` — the ports this caller already handed out and RELEASED, which the
+ * OS is free to answer with again. Two bare `freePort()` calls for one app gave its web role and
+ * its scrape listener the same number (CI, 2026-10-14). Both bound it — `localhost` names `::1` and
+ * `127.0.0.1` there — and the browser's requests reached `/metrics`'s `not found` instead of the
+ * app. Held like a refused port, so the walk still ends.
+ */
+export const freePortApartFrom = (
+  taken: readonly number[],
+  listen: () => PortProbe = listenOnAnyPort,
+): number => {
+  const held: PortProbe[] = [];
   try {
     for (;;) {
       const probe = listen();
-      if (BROWSER_REFUSED_PORTS.has(probe.port)) {
-        refused.push(probe);
+      if (BROWSER_REFUSED_PORTS.has(probe.port) || taken.includes(probe.port)) {
+        held.push(probe);
         continue;
       }
       probe.stop();
       return probe.port;
     }
   } finally {
-    for (const probe of refused) probe.stop();
+    for (const probe of held) probe.stop();
   }
 };