@tonalisk-labs/kit 1.0.0 → 1.0.6

package/testing/src/fixtures.ts

@@ -21,16 +21,20 @@ import { CPU_SLOWDOWN } from './network.ts';
 import { type Meter, type Reconnect, startMeter } from './perf/measure.ts';
 import { FAILURE_ATTACHMENT } from './perf/steps.ts';
 import { installVitals } from './perf/vitals.ts';
-import { deviceBudget } from './stack/browsers.ts';
+import { deviceBudget, endpointOf } from './stack/browsers.ts';
 import {
   holdBrowserSeat,
   holdStack,
+  deadlineFrom,
   holdTestTurn,
+  testBegins,
+  waitedFor,
   HOST_ENV,
   LINUX_ENV,
   MEASURE_ENV,
   STACK_ENV,
 } from './stack/control.ts';
+import { announceDeadline } from './stack/hold.ts';
 import { claimPort } from './stack/ports.ts';
 import type { Coordinates } from './stack/stack.ts';
 import { browserTrust, trustCa } from './stack/tls.ts';
@@ -43,7 +47,8 @@ export interface Options {
   /** A visual project's: Chromium in the Linux image, holding screens to their baselines. */
   readonly visual: boolean;
   /** The most browser contexts one of the worker's tests has open at once, its own included: a
-   *  seat each in the Linux image, which a test of several devices declares with `test.use`. */
+   *  seat each in the Linux image while the test runs, which a test of several devices declares
+   *  with `test.use`. */
   readonly browserContexts: number;
 }
 
@@ -56,15 +61,48 @@ const API = '@api';
 interface StackWorkerFixtures {
   /** The target's running stack, from its setup project. */
   readonly stack: Coordinates;
-  /** Whether the worker's browser holds a seat in the Linux image (stack/browsers.ts). */
-  readonly browserSeat: boolean;
 }
 
 interface StackFixtures {
   /** Whether this test owns the stack alone (`@exclusive`), or shares it with every other. */
   readonly stackHold: boolean;
+  /** The test's deadline following its timeout to the servers of its holds. */
+  readonly deadlines: boolean;
 }
 
+/** The last move of a deadline on its way, so the next follows it and the servers hear them in
+ *  the order the test made them. */
+const announcing = { last: Promise.resolve(true) };
+
+/** Tells the servers of the running test's holds its deadline, as its timeout now stands; a server
+ *  that can't be told keeps the deadline it had. */
+const announceTimeout = (timeout: number): void => {
+  const deadline = deadlineFrom(timeout);
+  announcing.last = announcing.last.then(async () =>
+    announceDeadline(deadline).then(
+      () => true,
+      () => false,
+    ),
+  );
+};
+
+/** `type.slow()` moves the running test's deadline with its timeout, as `testInfo.slow()` does: it
+ *  triples the timeout without `setTimeout`, so a hold's deadline would stay a third of it. */
+const followingSlow = <Type extends object>(type: Type): Type => {
+  const slow: unknown = Reflect.get(type, 'slow');
+  if (typeof slow === 'function') {
+    Reflect.set(type, 'slow', (...args: unknown[]): void => {
+      Reflect.apply(slow, type, args);
+      try {
+        announceTimeout(base.info().timeout);
+      } catch {
+        // Called while the file loads, for every test in it: no test runs, so none holds anything.
+      }
+    });
+  }
+  return type;
+};
+
 interface WorkerFixtures {
   /** Chromium's DevTools port, which Lighthouse connects to; no other engine has one. */
   readonly cdpPort: number | undefined;
@@ -76,6 +114,11 @@ export interface Devices {
 }
 
 interface TestFixtures {
+  /** Whether the test holds seats in the Linux image (stack/browsers.ts), one per context it may
+   *  have open. */
+  readonly browserSeat: boolean;
+  /** The test's CPU turn, held for its own work. */
+  readonly cpuTurn: boolean;
   readonly invariants: Watch;
   readonly devices: Devices;
   /** Live sockets' channels by path, for a metered page's frame counts. */
@@ -122,60 +165,67 @@ type BaseWorker = PlaywrightWorkerArgs & PlaywrightWorkerOptions;
 export const apiTest: TestType<
   BaseTest & StackFixtures,
   BaseWorker & Options & StackWorkerFixtures
-> = base.extend<StackFixtures, Options & StackWorkerFixtures>({
-  site: ['', { option: true, scope: 'worker' }],
-  browserContexts: [1, { option: true, scope: 'worker' }],
-  row: [undefined, { option: true, scope: 'worker' }],
-  visual: [false, { option: true, scope: 'worker' }],
-  /** Taken before any stack hold, so a worker waiting for a seat holds nothing another waits on. */
-  browserSeat: [
-    async ({ browserName, browserContexts, visual }, provide): Promise<void> => {
-      if (!servedByImage(browserName, visual) || process.env[HOST_ENV] === undefined) {
-        await provide(false);
-        return;
-      }
-      const release = await holdBrowserSeat(browserContexts);
-      try {
+> = followingSlow(
+  base.extend<StackFixtures, Options & StackWorkerFixtures>({
+    /** A test sets its timeout as it starts, past the holds its fixtures took, or makes itself slow:
+     *  each change moves the deadline its holds' servers bound their waits by (stack/stall.ts). */
+    deadlines: [
+      async ({ site: _site }, provide, testInfo): Promise<void> => {
+        testBegins();
+        const set = testInfo.setTimeout.bind(testInfo);
+        const slow = testInfo.slow.bind(testInfo);
+        Object.assign(testInfo, {
+          setTimeout: (timeout: number): void => {
+            set(timeout);
+            announceTimeout(testInfo.timeout);
+          },
+          slow: (...args: Parameters<typeof slow>): void => {
+            slow(...args);
+            announceTimeout(testInfo.timeout);
+          },
+        });
         await provide(true);
-      } finally {
-        release();
-      }
-    },
-    // Unbounded, as each seat's holder is a worker whose tests run under their own timeouts.
-    { scope: 'worker', timeout: 0 },
-  ],
-  stack: [
-    async ({ site }, provide): Promise<void> => {
-      const handoff = process.env[STACK_ENV];
-      const parsed: unknown = handoff === undefined ? undefined : JSON.parse(handoff);
-      if (!isCoordinates(parsed)) {
-        throw new Error(`${site} has no running stack: its setup project starts one`);
-      }
-      // Node's own clients (fetch, WebSocket) reach the edge over TLS too.
-      trustCa(parsed.trust.ca);
-      await provide(parsed);
-    },
-    { scope: 'worker' },
-  ],
-  stackHold: [
-    async ({ site, browserSeat: _seated }, provide, testInfo): Promise<void> => {
-      const owns = testInfo.tags.includes(EXCLUSIVE);
-      if (site === '' || process.env[HOST_ENV] === undefined) {
-        await provide(owns);
-        return;
-      }
-      const release = await holdStack(owns ? 'own' : 'share', site);
-      try {
-        await provide(owns);
-      } finally {
-        release();
-      }
-    },
-    // Unbounded, and out of the test's own time: the grant always comes, as each holder is a test
-    // under its own timeout, whose end gives the hold back.
-    { auto: true, timeout: 0 },
-  ],
-});
+      },
+      { auto: true },
+    ],
+    site: ['', { option: true, scope: 'worker' }],
+    browserContexts: [1, { option: true, scope: 'worker' }],
+    row: [undefined, { option: true, scope: 'worker' }],
+    visual: [false, { option: true, scope: 'worker' }],
+    stack: [
+      async ({ site }, provide): Promise<void> => {
+        const handoff = process.env[STACK_ENV];
+        const parsed: unknown = handoff === undefined ? undefined : JSON.parse(handoff);
+        if (!isCoordinates(parsed)) {
+          throw new Error(`${site} has no running stack: its setup project starts one`);
+        }
+        // Node's own clients (fetch, WebSocket) reach the edge over TLS too.
+        trustCa(parsed.trust.ca);
+        await provide(parsed);
+      },
+      { scope: 'worker' },
+    ],
+    stackHold: [
+      async ({ site }, provide, testInfo): Promise<void> => {
+        const owns = testInfo.tags.includes(EXCLUSIVE);
+        if (site === '' || process.env[HOST_ENV] === undefined) {
+          await provide(owns);
+          return;
+        }
+        const release = await waitedFor(async () => holdStack(owns ? 'own' : 'share', site));
+        announceTimeout(testInfo.timeout);
+        try {
+          await provide(owns);
+        } finally {
+          release();
+        }
+      },
+      // Unbounded, and out of the test's own time: the grant always comes, as each holder is a test
+      // under its own timeout, whose end gives the hold back.
+      { auto: true, timeout: 0 },
+    ],
+  }),
+);
 
 /** A browser the Linux image's server runs, where the stack host started one. */
 const servedByImage = (browserName: string, visual: boolean): boolean =>
@@ -185,152 +235,182 @@ const servedByImage = (browserName: string, visual: boolean): boolean =>
 export const test: TestType<
   BaseTest & StackFixtures & TestFixtures,
   BaseWorker & Options & StackWorkerFixtures & WorkerFixtures
-> = apiTest.extend<TestFixtures, WorkerFixtures>({
-  cdpPort: [
-    async ({ browserName, visual }, provide): Promise<void> => {
-      // The visual projects' Chromium runs in the container, its DevTools port out of reach.
-      const claim = browserName === 'chromium' && !visual ? await claimPort() : undefined;
-      await provide(claim === undefined ? undefined : claim.port);
-      if (claim !== undefined) {
-        await claim.stop();
-      }
+> = followingSlow(
+  apiTest.extend<TestFixtures, WorkerFixtures>({
+    cdpPort: [
+      async ({ browserName, visual }, provide): Promise<void> => {
+        // The visual projects' Chromium runs in the container, its DevTools port out of reach.
+        const claim = browserName === 'chromium' && !visual ? await claimPort() : undefined;
+        await provide(claim === undefined ? undefined : claim.port);
+        if (claim !== undefined) {
+          await claim.stop();
+        }
+      },
+      { scope: 'worker' },
+    ],
+    /**
+     * WebKit on macOS, and every visual project's browser, is Playwright's own Linux build in the
+     * container the stack host starts; baselines match only the architecture that drew them.
+     */
+    connectOptions: [
+      async ({ browserName, visual }, provide): Promise<void> => {
+        if (visual && arch() !== BASELINE_ARCH) {
+          throw new Error(
+            `The baselines were drawn on ${BASELINE_ARCH} and this machine is ${arch()}: its Linux image renders differently, so the visual projects run on ${BASELINE_ARCH} alone`,
+          );
+        }
+        const remote = visual || browserName === 'webkit';
+        const wsEndpoint = remote ? endpointOf(browserName, process.env[LINUX_ENV]) : undefined;
+        if (remote && (visual || platform() === 'darwin') && wsEndpoint === undefined) {
+          throw new Error(
+            'WebKit on macOS and the visual projects run only in the Linux image: its setup project starts it',
+          );
+        }
+        // The image's browser reaches the host's loopback through the host's proxy (stack/socks.ts).
+        await provide(wsEndpoint === undefined ? undefined : { wsEndpoint });
+      },
+      { scope: 'worker' },
+    ],
+    /** The browser trusts the edge as every other harness browser does (browserTrust). */
+    launchOptions: [
+      async ({ launchOptions, cdpPort, browserName, stack }, provide): Promise<void> => {
+        const debugging =
+          cdpPort === undefined ? [] : [`--remote-debugging-port=${String(cdpPort)}`];
+        const trusting = browserTrust(stack.trust, browserName).args;
+        const args = [...(launchOptions.args ?? []), ...debugging, ...trusting];
+        await provide(Object.assign(structuredClone(launchOptions), { args }));
+      },
+      { scope: 'worker' },
+    ],
+    ignoreHTTPSErrors: async ({ browserName, connectOptions, stack }, provide): Promise<void> => {
+      const contained = connectOptions !== undefined;
+      await provide(browserTrust(stack.trust, browserName, contained).ignoreHTTPSErrors);
     },
-    { scope: 'worker' },
-  ],
-  /**
-   * WebKit on macOS, and every visual project's browser, is Playwright's own Linux build in the
-   * container the stack host starts; baselines match only the architecture that drew them.
-   */
-  connectOptions: [
-    async ({ browserName, visual, browserSeat: _seated }, provide): Promise<void> => {
-      if (visual && arch() !== BASELINE_ARCH) {
-        throw new Error(
-          `The baselines were drawn on ${BASELINE_ARCH} and this machine is ${arch()}: its Linux image renders differently, so the visual projects run on ${BASELINE_ARCH} alone`,
-        );
-      }
-      const remote = visual || browserName === 'webkit';
-      const wsEndpoint = remote ? process.env[LINUX_ENV] : undefined;
-      if (remote && (visual || platform() === 'darwin') && wsEndpoint === undefined) {
-        throw new Error(
-          'WebKit on macOS and the visual projects run only in the Linux image: its setup project starts it',
-        );
-      }
-      await provide(
-        wsEndpoint === undefined ? undefined : { wsEndpoint, exposeNetwork: '<loopback>' },
-      );
+    baseURL: async ({ stack }, provide): Promise<void> => {
+      await provide(stack.baseURL);
     },
-    { scope: 'worker' },
-  ],
-  /** The browser trusts the edge as every other harness browser does (browserTrust). */
-  launchOptions: [
-    async ({ launchOptions, cdpPort, browserName, stack }, provide): Promise<void> => {
-      const debugging = cdpPort === undefined ? [] : [`--remote-debugging-port=${String(cdpPort)}`];
-      const trusting = browserTrust(stack.trust, browserName).args;
-      const args = [...(launchOptions.args ?? []), ...debugging, ...trusting];
-      await provide(Object.assign(structuredClone(launchOptions), { args }));
+    /** The test's context, made once its stack hold, seats and CPU turn are held; named to the edge. */
+    context: async ({ cpuTurn: _turn, context, row, stack }, provide, testInfo): Promise<void> => {
+      if (testInfo.tags.includes(API)) {
+        throw new Error(`an ${API} test makes no page: it is written with apiTest`);
+      }
+      await joinEdge(context, stack.baseURL, row === undefined ? 'wired' : row.network);
+      await provide(context);
     },
-    { scope: 'worker' },
-  ],
-  ignoreHTTPSErrors: async ({ browserName, connectOptions, stack }, provide): Promise<void> => {
-    const contained = connectOptions !== undefined;
-    await provide(browserTrust(stack.trust, browserName, contained).ignoreHTTPSErrors);
-  },
-  baseURL: async ({ stack }, provide): Promise<void> => {
-    await provide(stack.baseURL);
-  },
-  /** The test's context, used once its stack hold and CPU turn are held; named to the edge. */
-  context: async ({ stackHold: _held, context, row, stack }, provide, testInfo): Promise<void> => {
-    if (testInfo.tags.includes(API)) {
-      throw new Error(`an ${API} test makes no page: it is written with apiTest`);
-    }
-    await joinEdge(context, stack.baseURL, row === undefined ? 'wired' : row.network);
-    await provide(context);
-  },
-  devices: async (
-    { context: _context, browser, browserContexts, ignoreHTTPSErrors, row, stack, visual },
-    provide,
-  ): Promise<void> => {
-    const opened: BrowserContext[] = [];
-    const reserve = deviceBudget(browserContexts);
-    const newDevice = async (options: BrowserContextOptions = {}): Promise<Page> => {
-      const giveBack = reserve();
-      const settings = Object.assign(
-        structuredClone(options),
-        {
-          baseURL: options.baseURL ?? stack.baseURL,
-          ignoreHTTPSErrors: options.ignoreHTTPSErrors ?? ignoreHTTPSErrors,
-        },
-        visual && !('reducedMotion' in options) ? { reducedMotion: VISUAL_MOTION } : {},
-      );
-      const device = await browser.newContext(settings).catch((error: unknown) => {
-        giveBack();
-        throw error;
-      });
-      opened.push(device);
-      device.once('close', giveBack);
-      await joinEdge(device, stack.baseURL, row === undefined ? 'wired' : row.network);
-      return device.newPage();
-    };
-    try {
-      await provide({ newDevice });
-    } finally {
-      await Promise.all(opened.map(async (device) => device.close()));
-    }
-  },
-  /** Measures every document, and slows the CPU on Chromium's low tier (DevTools protocol). */
-  page: async ({ page, row, browserName, stack }, provide): Promise<void> => {
-    await installVitals(page, stack.apiPrefix);
-    const rate = slowdownOf(row, browserName);
-    if (rate > 1) {
-      const session = await page.context().newCDPSession(page);
-      await session.send('Emulation.setCPUThrottlingRate', { rate });
-    }
-    await provide(page);
-  },
-  channels: [{}, { option: true }],
-  reconnect: [undefined, { option: true }],
-  keyboardOnly: [false, { option: true }],
-  /** A CPU turn, taken after the stack hold as every turn is, spans the test's own work; the
-   *  override keeps the hold's own timeout, so none of the wait is charged to the test's. */
-  stackHold: async ({ stackHold }, provide): Promise<void> => {
-    const release = await holdTestTurn();
-    try {
-      await provide(stackHold);
-    } finally {
-      release();
-    }
-  },
-  meter: [
-    async ({ page, stack, channels, reconnect }, provide): Promise<void> => {
-      const options = { apiPrefix: stack.apiPrefix, channels, vitals: false, reconnect };
-      const meter = process.env[MEASURE_ENV] === '1' ? await startMeter(page, options) : undefined;
-      await provide(meter);
-      if (meter !== undefined) {
-        meter.traffic.stop();
+    devices: async (
+      { context: _context, browser, browserContexts, ignoreHTTPSErrors, row, stack, visual },
+      provide,
+    ): Promise<void> => {
+      const opened: BrowserContext[] = [];
+      const reserve = deviceBudget(browserContexts);
+      const newDevice = async (options: BrowserContextOptions = {}): Promise<Page> => {
+        const giveBack = reserve();
+        const settings = Object.assign(
+          structuredClone(options),
+          {
+            baseURL: options.baseURL ?? stack.baseURL,
+            ignoreHTTPSErrors: options.ignoreHTTPSErrors ?? ignoreHTTPSErrors,
+          },
+          visual && !('reducedMotion' in options) ? { reducedMotion: VISUAL_MOTION } : {},
+        );
+        const device = await browser.newContext(settings).catch((error: unknown) => {
+          giveBack();
+          throw error;
+        });
+        opened.push(device);
+        device.once('close', giveBack);
+        await joinEdge(device, stack.baseURL, row === undefined ? 'wired' : row.network);
+        return device.newPage();
+      };
+      try {
+        await provide({ newDevice });
+      } finally {
+        await Promise.all(opened.map(async (device) => device.close()));
       }
     },
-    { auto: true },
-  ],
-  /** The report is waited for by an event on its folder, within a bound of its own, outside the
-   *  test's time: macOS writes it some seconds after the crash. */
-  browserCrash: [browserWatch(), { auto: true, timeout: REPORT_WAIT_MS + 30_000 }],
-  invariants: [
-    async ({ page, stack, keyboardOnly, browserName }, provide, testInfo): Promise<void> => {
-      const { origin } = new URL(stack.baseURL);
-      const { apiPrefix, notices, cspExceptions } = stack;
-      const today = new Date().toISOString().slice(0, 10);
-      const exceptions = { list: cspExceptions ?? [], engine: browserName, today };
-      const watched = await watch(page, { origin, apiPrefix, notices, keyboardOnly, exceptions });
-      await provide(watched);
-      const problems = await watched.take();
-      if (testInfo.status !== testInfo.expectedStatus) {
-        const body = failureReport(page, problems, watched.recentApi());
-        await testInfo.attach(FAILURE_ATTACHMENT, { body, contentType: 'text/plain' });
+    /** Measures every document, and slows the CPU on Chromium's low tier (DevTools protocol). */
+    page: async ({ page, row, browserName, stack }, provide): Promise<void> => {
+      await installVitals(page, stack.apiPrefix);
+      const rate = slowdownOf(row, browserName);
+      if (rate > 1) {
+        const session = await page.context().newCDPSession(page);
+        await session.send('Emulation.setCPUThrottlingRate', { rate });
       }
-      expect(problems, 'the page held every invariant').toEqual([]);
+      await provide(page);
     },
-    { auto: true },
-  ],
-});
+    channels: [{}, { option: true }],
+    reconnect: [undefined, { option: true }],
+    keyboardOnly: [false, { option: true }],
+    /** Taken after the stack hold, so every holder is a test with its stack, and before the CPU
+     *  turn, which a holder may wait on: a test waiting for seats holds no turn. The wait is not the
+     *  test's, and fails should the seats stand still (stack/lock.ts). */
+    browserSeat: [
+      async (
+        { stackHold: _held, browserName, browserContexts, visual },
+        provide,
+        testInfo,
+      ): Promise<void> => {
+        if (!servedByImage(browserName, visual) || process.env[HOST_ENV] === undefined) {
+          await provide(false);
+          return;
+        }
+        const release = await waitedFor(async () => holdBrowserSeat(browserContexts));
+        announceTimeout(testInfo.timeout);
+        try {
+          await provide(true);
+        } finally {
+          release();
+        }
+      },
+      { timeout: 0 },
+    ],
+    /** A CPU turn, taken last as every turn is, spans the test's own work; its wait is not the
+     *  test's. */
+    cpuTurn: [
+      async ({ browserSeat: _seated }, provide, testInfo): Promise<void> => {
+        const release = await waitedFor(holdTestTurn);
+        announceTimeout(testInfo.timeout);
+        try {
+          await provide(true);
+        } finally {
+          release();
+        }
+      },
+      { auto: true, timeout: 0 },
+    ],
+    meter: [
+      async ({ page, stack, channels, reconnect }, provide): Promise<void> => {
+        const options = { apiPrefix: stack.apiPrefix, channels, vitals: false, reconnect };
+        const meter =
+          process.env[MEASURE_ENV] === '1' ? await startMeter(page, options) : undefined;
+        await provide(meter);
+        if (meter !== undefined) {
+          meter.traffic.stop();
+        }
+      },
+      { auto: true },
+    ],
+    /** The report is waited for by an event on its folder, within a bound of its own, outside the
+     *  test's time: macOS writes it some seconds after the crash. */
+    browserCrash: [browserWatch(), { auto: true, timeout: REPORT_WAIT_MS + 30_000 }],
+    invariants: [
+      async ({ page, stack, keyboardOnly, browserName }, provide, testInfo): Promise<void> => {
+        const { origin } = new URL(stack.baseURL);
+        const { apiPrefix, notices, cspExceptions } = stack;
+        const today = new Date().toISOString().slice(0, 10);
+        const exceptions = { list: cspExceptions ?? [], engine: browserName, today };
+        const watched = await watch(page, { origin, apiPrefix, notices, keyboardOnly, exceptions });
+        await provide(watched);
+        const problems = await watched.take();
+        if (testInfo.status !== testInfo.expectedStatus) {
+          const body = failureReport(page, problems, watched.recentApi());
+          await testInfo.attach(FAILURE_ATTACHMENT, { body, contentType: 'text/plain' });
+        }
+        expect(problems, 'the page held every invariant').toEqual([]);
+      },
+      { auto: true },
+    ],
+  }),
+);
 
 export { expect } from '@playwright/test';

package/testing/src/floors/node.ts

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 // A workspace's tests as `node --test` runs them (its arguments: globs and `--import <module>`),
-// those timing code then alone, one at a time; the rest under coverage, held to its floors.
-// KIT_TEST_PHASE=untimed or timed takes one phase, so the timed run can have the machine alone.
+// those timing code then alone, one at a time, holding the machine's CPU gate whole; the rest
+// under coverage, held to its floors. KIT_TEST_PHASE=untimed or timed takes one phase, so the
+// timed run can have the machine alone.
 import { finished, pipeline } from 'node:stream/promises';
 import { run, type RunOptions } from 'node:test';
 import { spec as SpecReporter } from 'node:test/reporters';
 import { parseArgs } from 'node:util';
 
+import { inWholeTurn } from '../stack/gate-member.ts';
+import { GATE_PORT } from '../stack/gate-server.ts';
 import { holdFloors, type Measured } from './hold.ts';
 import { measuredOnce } from './instances.ts';
 import { PHASE_ENV, phaseOf, testFiles } from './timed.ts';
@@ -60,6 +63,19 @@ const measure = async (): Promise<Measured> => {
 };
 
 const name = process.env['npm_package_name'] ?? cwd;
+
+/** The CPU gate's port: the machine's own, or the one a test of this runner serves. */
+const GATE_PORT_ENV = 'KIT_CPU_GATE_PORT';
+
+/** Runs the timed files one at a time, holding every slot of the machine's CPU gate: the tests of
+ *  other runs, which take their turns there, wait, so none shares the cores they're timed on. */
+const timedPass = async (files: string[]): Promise<boolean> =>
+  inWholeTurn(
+    async () => passes(files, false),
+    `the timed tests of ${name} (pid ${String(process.pid)})`,
+    Number(process.env[GATE_PORT_ENV] ?? GATE_PORT),
+  );
+
 const phase = phaseOf(process.env[PHASE_ENV]);
 const untimed = phase !== 'timed';
 const timedToo = phase !== 'untimed';
@@ -75,5 +91,5 @@ if (!untimed) {
 // A timed test shares no CPU with the others: it runs once they are done, and on its own.
 const passed =
   (!untimed || (await passes(parallel, true))) &&
-  (!timedToo || timed.length === 0 || (await passes(timed, false)));
+  (!timedToo || timed.length === 0 || (await timedPass(timed)));
 process.exitCode = passed && (!untimed || holdFloors(name, cwd, await measure())) ? 0 : 1;