// Per-checkout port derivation: every checkout (main repo, agent worktree,// /tmp rig) hashes its repo root into a PREFERRED block of e2e ports, so// concurrent suites normally never fight over a shared default. The hash is// only a preference, not a guarantee (28 checkouts over 400 blocks is// birthday-paradox territory) — the globalsetups call `claimPorts`, which// probes the preferred block and walks forward to the next fully-free one,// then publishes the claimed ports via the E2E_*_PORT env vars so vitest's// test workers (spawned after globalsetup) compute the same URLs. The// collision failure mode this kills is brutal: vite's --strictPort exit is// swallowed by the boot glue and waitForHttp happily attaches to the OTHER// checkout's server, failing dozens of scenarios with baffling auth errors// instead of one clear bind error. Individual E2E_*_PORT env vars still// override everything, and E2E_<TARGET>_URL still attaches to a running// instance.import { connect, createServer, type Server } from "node:net";import { resolve } from "node:path";import { fileURLToPath } from "node:url"; /** The repo root identifies the checkout (stable regardless of process cwd). */export const repoRoot = resolve(fileURLToPath(new URL("../..", import.meta.url))); // FNV-1a — tiny, deterministic, and the same value in every process of this// checkout (globalsetup and test workers must agree on the ports).const hash = (text: string): number => {  let h = 2166136261;  for (let i = 0; i < text.length; i++) {    h ^= text.charCodeAt(i);    h = Math.imul(h, 16777619);  }  return h >>> 0;}; // 400 blocks of 10 ports in 42000..45999: unprivileged, clear of common dev// servers, and below macOS's ephemeral range (49152+). Offsets 0-8 are// claimable; offset 9 is the block's lock port (held for the suite's// lifetime to make claims atomic across concurrent suites).const BLOCK_BASE = 42000;const BLOCK_SIZE = 10;const BLOCK_COUNT = 400;const LOCK_OFFSET = BLOCK_SIZE - 1;export const portBlock = BLOCK_BASE + (hash(repoRoot) % BLOCK_COUNT) * BLOCK_SIZE; export const e2ePort = (envVar: string, offset: number): number => {  const fromEnv = process.env[envVar];  return fromEnv ? Number(fromEnv) : portBlock + offset;}; const isListening = (port: number): Promise<boolean> =>  new Promise((done) => {    const socket = connect({ port, host: "127.0.0.1" });    socket.once("connect", () => {      socket.destroy();      done(true);    });    socket.once("error", () => done(false));    socket.setTimeout(1_000, () => {      socket.destroy();      done(false);    });  }); export interface PortClaim {  readonly envVar: string;  readonly offset: number;  readonly label: string;} export interface ClaimedPorts {  readonly ports: Record<string, number>;  /** Releases the block's lock port — call from the suite teardown. */  readonly release: () => Promise<void>;} // Binding is atomic where probing is not: holding the block's lock port for// the suite's lifetime means two suites racing for the same block can never// both win (the second bind EADDRINUSEs and walks on).const tryLockBlock = (block: number): Promise<Server | undefined> =>  new Promise((done) => {    const server = createServer();    server.once("error", () => done(undefined));    server.listen(block + LOCK_OFFSET, "127.0.0.1", () => done(server));  }); /** * Claim a free set of ports for a target and publish them via env. Starts at * this checkout's preferred block and walks forward block-by-block until it * can atomically lock a block whose requested ports are all free — so two * checkouts whose hashes collide (or a leaked server squatting the preferred * block) degrade to "boot one block over" instead of attaching to a foreign * server. Explicit env overrides win and are never probed or locked: if you * pin a port and it's busy, vite's --strictPort fails visibly. A target * re-claiming inside an already-locked process (cloud + selfhost projects in * one vitest run) shares the block via disjoint offsets. */export const claimPorts = async (claims: ReadonlyArray<PortClaim>): Promise<ClaimedPorts> => {  const ports: Record<string, number> = {};  const unpinned = claims.filter((claim) => {    const pinned = process.env[claim.envVar];    if (pinned) ports[claim.envVar] = Number(pinned);    return !pinned;  });  if (unpinned.length === 0) return { ports, release: async () => {} };   for (let attempt = 0; attempt < BLOCK_COUNT; attempt++) {    const block =      BLOCK_BASE + ((portBlock - BLOCK_BASE + attempt * BLOCK_SIZE) % (BLOCK_COUNT * BLOCK_SIZE));    // This process may already hold the block's lock (the other target's    // globalsetup in the same vitest run); reuse it instead of re-locking.    let lock = heldLocks.get(block);    if (!lock) {      lock = await tryLockBlock(block);      if (!lock) {        console.warn(`[e2e] port block ${block} is locked by another suite; trying next block`);        continue;      }      heldLocks.set(block, lock);    }    const busy = await Promise.all(unpinned.map((claim) => isListening(block + claim.offset)));    if (busy.some(Boolean)) {      const taken = unpinned        .filter((_, index) => busy[index])        .map((claim) => `${block + claim.offset} (${claim.label})`);      console.warn(        `[e2e] port block ${block} has squatters — ${taken.join(", ")}; trying next block`,      );      continue; // Keep the lock: a half-busy block is still ours, just unusable now.    }    for (const claim of unpinned) {      const port = block + claim.offset;      ports[claim.envVar] = port;      // Workers spawn after globalsetup, so they inherit these and agree.      process.env[claim.envVar] = String(port);    }    return {      ports,      release: async () => {        const held = heldLocks.get(block);        if (!held) return;        heldLocks.delete(block);        await new Promise<void>((done) => held.close(() => done()));      },    };  }  throw new Error("e2e: no free port block found — the 42000-45999 range is exhausted?");}; const heldLocks = new Map<number, Server>();