@jterrazz/test 17.0.0 → 18.0.0

package/dist/route-coverage.global-setup.d.ts

@@ -39,4 +39,5 @@ export declare function routeCoverageSetup(): string;
 export declare function setupRoutes(project: RouteProject): () => Promise<void>;
 export default function setup(project: TestProject): () => Promise<void>;
 //#endregion
+export {};
 //# sourceMappingURL=route-coverage.global-setup.d.ts.map

package/dist/route-coverage.global-setup.js

@@ -1,2 +1 @@
-import { n as setup, r as setupRoutes, t as routeCoverageSetup } from "./shared-route-coverage.global-setup.js";
-export { setup as default, routeCoverageSetup, setupRoutes };
+export { n as default, t as routeCoverageSetup, r as setupRoutes } from "./shared-route-coverage.global-setup.js";

package/dist/services.global-setup.d.ts

@@ -26,7 +26,6 @@ declare function serveContainers(containers: RunContainers): Promise<ServedConta
 //#endregion
 //#region src/services/containers/services.global-setup.d.ts
 /** Every project's setup joins the one run's containers. Default images are pulled in the background, so the first file waits on a pull at most once; a project declaring no service needs no Docker. */
-export declare const DOCKER_ABSENT = "no Docker daemon answered";
 /** `connect` stands in for the runtime's own client lookup, so the refusal is reachable without a daemon to stop. */
 export declare function prepareDocker(connect?: () => Promise<ContainerRuntimeClient>): Promise<void>;
 export declare function servicesSetup(): string;
@@ -40,4 +39,5 @@ type RunSeams = {
 };
 export default function setup(project: RunProject, seams?: Partial<RunSeams>): Promise<() => Promise<void>>;
 //#endregion
+export {};
 //# sourceMappingURL=services.global-setup.d.ts.map

package/dist/services.global-setup.js

@@ -1,2 +1 @@
-import { i as setup, n as prepareDocker, r as servicesSetup, t as DOCKER_ABSENT } from "./shared-services.global-setup.js";
-export { DOCKER_ABSENT, setup as default, prepareDocker, servicesSetup };
+export { r as default, t as prepareDocker, n as servicesSetup } from "./shared-services.global-setup.js";

package/dist/services.js

@@ -3,7 +3,7 @@ import { n as refusal, t as invariant } from "./shared-refusal.js";
 import { t as pause } from "./shared-pause.js";
 import { n as processService, t as ProcessHandle } from "./shared-process.adapter.js";
 import { n as requireBuiltPeer, t as loadPeer } from "./shared-peer.js";
-import { c as SQLITE_TEMPLATE_DIR } from "./shared-artifacts.js";
+import { l as SQLITE_TEMPLATE_DIR } from "./shared-artifacts.js";
 import { t as SERVICE_IMAGES } from "./shared-service-images.js";
 import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
 import { join, resolve } from "node:path";

package/dist/shared-appium.adapter.js

@@ -1,11 +1,10 @@
 import { n as refusal } from "./shared-refusal.js";
-import { t as pause } from "./shared-pause.js";
-import { u as evidenceDirectory } from "./shared-artifacts.js";
+import { n as untilDeadline } from "./shared-pause.js";
+import { d as evidenceFile } from "./shared-artifacts.js";
 import { n as SERVER_CALL_TIMEOUT_MS } from "./shared-session-ledger.js";
 import { c as scopeChain } from "./shared-landmarks.js";
 import { a as ambiguityError, c as asWrittenUnscoped, i as shortened, s as asWritten, t as scenarioFailure } from "./shared-scenario-failure.js";
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { writeFileSync } from "node:fs";
 //#region src/specifications/mobile/session/driver-session.ts
 const IDLE_SESSION_BUDGET_S = 300;
 const IOS_PREFIX = /^ios\s+/iu;
@@ -355,15 +354,17 @@ var AppiumAdapter = class {
 	async resolveOne(driver, target, verb) {
 		const chain = scopeChain(target);
 		const anyTarget = verb === "see";
-		const deadline = Date.now() + this.actionTimeoutMs;
 		let tryScroll = true;
-		for (;;) {
-			const resolved = await this.resolveChain(driver, chain, anyTarget, tryScroll);
+		const resolved = await untilDeadline(async () => {
+			const found = await this.resolveChain(driver, chain, anyTarget, tryScroll);
 			tryScroll = false;
-			if (resolved) return resolved;
-			if (Date.now() > deadline) throw await this.timeoutError(driver, target, verb);
-			await pause(POLL_INTERVAL_MS);
-		}
+			return found ?? void 0;
+		}, {
+			interval: POLL_INTERVAL_MS,
+			timeout: this.actionTimeoutMs
+		});
+		if (resolved === void 0) throw await this.timeoutError(driver, target, verb);
+		return resolved;
 	}
 	async resolveChain(driver, chain, anyTarget, tryScroll) {
 		let scope = driver;
@@ -385,11 +386,10 @@ var AppiumAdapter = class {
 		}
 		return element;
 	}
-	/** Screenshot the failing state into a temp file; never masks the original error. */
+	/** Screenshot the failing state into the evidence folder; never masks the original error. */
 	async captureEvidence(driver) {
 		try {
-			const dir = mkdtempSync(evidenceDirectory("mobile-"));
-			const path = resolve(dir, "failure.png");
+			const path = evidenceFile("mobile");
 			writeFileSync(path, Buffer.from(await driver.takeScreenshot(), "base64"));
 			return path;
 		} catch {

package/dist/shared-artifacts.js

@@ -1,4 +1,4 @@
-import { mkdirSync } from "node:fs";
+import { mkdirSync, mkdtempSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 //#region lint/kit/project/artifacts.ts
@@ -11,14 +11,16 @@ const SQLITE_TEMPLATE_DIR = `${VITEST_ARTIFACTS_DIR}/sqlite`;
 const ATTACHMENTS_DIR = `${VITEST_ARTIFACTS_DIR}/attachments`;
 /** Under the project: the run's temp root is gone by the time the error naming the file is read. */
 const EVIDENCE_DIR = `${VITEST_ARTIFACTS_DIR}/evidence`;
-/** Filed under the run's temp root name, `<pid>-...`: the next run's start sweeps every run that is no longer alive. */
-function evidenceDirectory(prefix) {
+/** Where a failing scenario's screenshot goes, in a folder of its own filed under the run's temp root name, `<pid>-...`: the next run's start sweeps every run that is no longer alive. */
+function evidenceFile(kind) {
 	const parent = resolve(EVIDENCE_DIR, basename(tmpdir()));
 	mkdirSync(parent, { recursive: true });
-	return join(parent, prefix);
+	return join(mkdtempSync(join(parent, `${kind}-`)), "failure.png");
 }
 const SCREENSHOTS_DIR = `${VITEST_ARTIFACTS_DIR}/screenshots`;
 const BLOB_DIR = `${VITEST_ARTIFACTS_DIR}/blob`;
+/** Node's compile cache, which every Node process of a run reads and writes: keyed by content, so an edit is never served old code. */
+const NODE_COMPILE_CACHE_DIR = `${ARTIFACTS_DIR}/node-compile-cache`;
 /** Vitest 5's file-writing reporters, each pinned under the artifacts folder. */
 const REPORTER_OUTPUT_FILES = {
 	blob: `${BLOB_DIR}/blob.json`,
@@ -27,6 +29,6 @@ const REPORTER_OUTPUT_FILES = {
 	junit: `${VITEST_ARTIFACTS_DIR}/junit/output.xml`
 };
 //#endregion
-export { EVIDENCE_DIR as a, SQLITE_TEMPLATE_DIR as c, COVERAGE_DIR as i, VITEST_ARTIFACTS_DIR as l, ATTACHMENTS_DIR as n, REPORTER_OUTPUT_FILES as o, BLOB_DIR as r, SCREENSHOTS_DIR as s, ARTIFACTS_DIR as t, evidenceDirectory as u };
+export { EVIDENCE_DIR as a, SCREENSHOTS_DIR as c, evidenceFile as d, COVERAGE_DIR as i, SQLITE_TEMPLATE_DIR as l, ATTACHMENTS_DIR as n, NODE_COMPILE_CACHE_DIR as o, BLOB_DIR as r, REPORTER_OUTPUT_FILES as s, ARTIFACTS_DIR as t, VITEST_ARTIFACTS_DIR as u };
 
 //# sourceMappingURL=shared-artifacts.js.map

package/dist/shared-derived-projects.js

@@ -1,15 +1,17 @@
 import { t as SPECIFICATIONS } from "./shared-specifications.js";
 import { TESTS_FOLDER } from "@jterrazz/typescript/rules";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join } from "node:path";
 //#region lint/kit/project/derived-projects.ts
 const SPECS = "specs";
 const UNIT = "unit";
 const FOLDERED = /* @__PURE__ */ new Set([...SPECIFICATIONS, "component"]);
-const IN_PROCESS = /* @__PURE__ */ new Set([
+const RUNNER_SHARED = /* @__PURE__ */ new Set([
 	"api",
+	"cli",
 	"integration",
-	"job"
+	"job",
+	"website"
 ]);
 const SPECIFICATION_MODULE = ".specification.ts";
 const MODULE_TEST = /\.test\.ts$/u;
@@ -23,14 +25,27 @@ function holds(path, pattern) {
 	});
 }
 const foldersIn = (path) => existsSync(path) ? readdirSync(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !isUnwalked(entry.name)).map(({ name }) => name).toSorted() : [];
+function inImportOrder(directory, modules) {
+	const ordered = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (module) => {
+		if (seen.has(module)) return;
+		seen.add(module);
+		const text = readFileSync(join(directory, module), "utf8");
+		for (const imported of modules.filter((other) => text.includes(`'./${other.slice(0, -2)}js'`))) visit(imported);
+		ordered.push(module);
+	};
+	for (const module of modules) visit(module);
+	return ordered;
+}
 function runnerOf(root, folder, specification) {
-	if (!IN_PROCESS.has(specification)) return {};
-	const modules = readdirSync(join(root, folder)).filter((name) => name.endsWith(SPECIFICATION_MODULE));
-	const own = `${specification}${SPECIFICATION_MODULE}`;
-	return modules.length === 1 && modules[0] === own ? { runner: `./${folder}/${own}` } : {};
+	if (!RUNNER_SHARED.has(specification)) return {};
+	const directory = join(root, folder);
+	const modules = readdirSync(directory).filter((name) => name.endsWith(SPECIFICATION_MODULE)).toSorted();
+	return modules.length === 0 ? {} : { runner: inImportOrder(directory, modules).map((name) => `./${folder}/${name}`) };
 }
 const isSpecsMember = (root) => basename(root) === SPECS && existsSync(join(root, "package.json"));
-/** The projects a tree names, each with the options it derives: one per `specs/<specification>/` folder (an in-process one handed as its `runner` the folder's one specification module, `<specification>.specification.ts`), `unit` over each root holding a module test (`specs/unit/` is one root among them), `component` over each holding a rendered one. */
+/** The projects a tree names, each with the options it derives: one per `specs/<specification>/` folder (one whose spec files meet their subject through a runner handed as its `runner` every specification module of the folder, `*.specification.ts`, a module after those it imports), `unit` over each root holding a module test (`specs/unit/` is one root among them), `component` over each holding a rendered one. */
 function derivedProjects(root) {
 	const member = isSpecsMember(root);
 	const prefix = member ? "" : `${SPECS}/`;

package/dist/shared-in-place.js

@@ -167,6 +167,6 @@ function writeInPlace(site, render, folder = pendingFolder?.()) {
 	save(site.file, source, folder);
 }
 //#endregion
-export { callerFrames as a, writePendingRewrites as i, deferRewritesTo as n, getCallerDir as o, writeInPlace as r, callSiteOf as t };
+export { getCallerDir as a, writePendingRewrites as i, deferRewritesTo as n, writeInPlace as r, callSiteOf as t };
 
 //# sourceMappingURL=shared-in-place.js.map

package/dist/shared-ledger.js

@@ -1,5 +1,5 @@
 import { t as isRecord } from "./shared-json-shape.js";
-import { l as VITEST_ARTIFACTS_DIR } from "./shared-artifacts.js";
+import { u as VITEST_ARTIFACTS_DIR } from "./shared-artifacts.js";
 import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";

package/dist/shared-listened-port.js

@@ -0,0 +1,19 @@
+import { t as invariant } from "./shared-refusal.js";
+//#region src/chain/listened-port.ts
+/** Listens, on `host` when one is named, and answers the port it got; a port another server holds rejects with its error. */
+async function listenedPort(server, { host, port = 0 } = {}) {
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, host, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	const address = server.address();
+	if (address === null || typeof address === "string") throw invariant("a server listening on a TCP port answered no port");
+	return address.port;
+}
+//#endregion
+export { listenedPort as t };
+
+//# sourceMappingURL=shared-listened-port.js.map

package/dist/shared-literate-plugin.js

@@ -1,5 +1,6 @@
 import { n as refusal } from "./shared-refusal.js";
-import { d as isRelativePath, i as readSpecFile, l as SpecSyntaxError, u as dedent } from "./shared-spec-document.js";
+import { c as isRelativePath, s as SpecSyntaxError } from "./shared-spec-grammar.js";
+import { i as readSpecFile, o as dedent } from "./shared-spec-document.js";
 import { readFileSync } from "node:fs";
 import { basename, isAbsolute, resolve } from "node:path";
 //#region src/disk/spec-path.ts

package/dist/shared-pause.js

@@ -5,7 +5,18 @@ async function pause(ms) {
 		setTimeout(resolve, ms);
 	});
 }
+/** Asks `probe` until it answers something other than `undefined`, which it hands back, or answers `undefined` once `timeout` has passed. Measured on `performance.now()`, so `clock.at()`, which fakes `Date`, cannot freeze it. */
+async function untilDeadline(probe, { interval = 0, timeout, wait }) {
+	const deadline = performance.now() + timeout;
+	for (;;) {
+		const answer = await probe();
+		if (answer !== void 0) return answer;
+		const remaining = deadline - performance.now();
+		if (remaining <= 0) return;
+		await (wait === void 0 ? pause(interval) : wait(remaining));
+	}
+}
 //#endregion
-export { pause as t };
+export { untilDeadline as n, pause as t };
 
 //# sourceMappingURL=shared-pause.js.map

package/dist/shared-playwright.adapter.js

@@ -1,10 +1,8 @@
 import { n as refusal } from "./shared-refusal.js";
-import { u as evidenceDirectory } from "./shared-artifacts.js";
+import { n as untilDeadline } from "./shared-pause.js";
+import { d as evidenceFile } from "./shared-artifacts.js";
 import { c as scopeChain } from "./shared-landmarks.js";
 import { n as CANDIDATE_LIMITS, o as ambiguousTargetError, r as candidatesOf, s as asWritten, t as scenarioFailure } from "./shared-scenario-failure.js";
-import { mkdtempSync } from "node:fs";
-import { resolve } from "node:path";
-import { setTimeout } from "node:timers/promises";
 //#region src/specifications/website/browser/page-scripts.ts
 function extractPage() {
 	const links = [...document.querySelectorAll("link")].map((link) => ({
@@ -135,20 +133,21 @@ async function currentValue(locator) {
 		return null;
 	}
 }
-async function waitForValue(locator, target, wanted) {
+async function waitForValue(locator, target, wanted, timeout = VALUE_TIMEOUT_MS) {
 	const value = target.value ?? "";
-	const deadline = Date.now() + VALUE_TIMEOUT_MS;
-	for (;;) {
-		const actual = await currentValue(locator);
-		if (actual === null ? !wanted : actual === value === wanted) return;
-		if (Date.now() >= deadline) throw new Error(refusal({
-			fix: "correct the value the scenario states, or what the page puts in the field",
-			found: `${asWritten(target)} ${wanted ? "never held" : "still holds"} ${JSON.stringify(value)}${actual === null ? " (it is not on the page)" : `, it holds ${JSON.stringify(actual)}`}`,
-			read: "docs/reference/visitor.md#see-and-gone-are-the-synchronization",
-			why: "A verb waits for what it states to hold, within its budget, and never sleeps."
-		}));
-		await setTimeout(VALUE_POLL_MS);
-	}
+	let actual = null;
+	if (await untilDeadline(async () => {
+		actual = await currentValue(locator);
+		return actual === value === wanted || void 0;
+	}, {
+		interval: VALUE_POLL_MS,
+		timeout
+	}) === void 0) throw new Error(refusal({
+		fix: "correct the value the scenario states, or what the page puts in the field",
+		found: `${asWritten(target)} ${wanted ? "never held" : "still holds"} ${JSON.stringify(value)}${actual === null ? " (it is not on the page)" : `, it holds ${JSON.stringify(actual)}`}`,
+		read: "docs/reference/visitor.md#see-and-gone-are-the-synchronization",
+		why: "A verb waits for what it states to hold, within its budget, and never sleeps."
+	}));
 }
 async function settle(page, locator, target, present) {
 	if (target.value !== void 0) {
@@ -312,8 +311,7 @@ var PlaywrightAdapter = class {
 	/** Screenshot the failing state into the evidence folder; never masks the original error. */
 	async captureEvidence(page) {
 		try {
-			const dir = mkdtempSync(evidenceDirectory("website-"));
-			const path = resolve(dir, "failure.png");
+			const path = evidenceFile("website");
 			await page.screenshot({
 				fullPage: true,
 				path

package/dist/shared-process-alive.js

@@ -0,0 +1,13 @@
+//#region src/chain/process-alive.ts
+function processAlive(pid, probe = (target) => process.kill(target, 0)) {
+	try {
+		probe(pid);
+		return true;
+	} catch (error) {
+		return Reflect.get(new Object(error), "code") !== "ESRCH";
+	}
+}
+//#endregion
+export { processAlive as t };
+
+//# sourceMappingURL=shared-process-alive.js.map

package/dist/shared-record-key.js

@@ -0,0 +1,13 @@
+//#region lint/kit/project/record-key.ts
+/** `analyticsDb` gives `analytics-db`. */
+function toKebabCase(key) {
+	return key.replaceAll(/(?<lower>[a-z0-9])(?<upper>[A-Z])/gu, "$<lower>-$<upper>").toLowerCase();
+}
+/** `analyticsDb` gives `ANALYTICS_DB`, `db-main` gives `DB_MAIN`. */
+function toConstantCase(key) {
+	return key.replaceAll(/(?<lower>[a-z0-9])(?<upper>[A-Z])/gu, "$<lower>_$<upper>").replaceAll(/[^A-Za-z0-9]/gu, "_").toUpperCase();
+}
+//#endregion
+export { toKebabCase as n, toConstantCase as t };
+
+//# sourceMappingURL=shared-record-key.js.map

package/dist/shared-serve.js

@@ -1,9 +1,10 @@
-import { n as refusal, t as invariant } from "./shared-refusal.js";
-import { t as pause } from "./shared-pause.js";
+import { n as refusal } from "./shared-refusal.js";
+import { n as untilDeadline } from "./shared-pause.js";
+import { t as listenedPort } from "./shared-listened-port.js";
 import "node:module";
 import { resolve } from "node:path";
 import { execSync, spawn, spawnSync } from "node:child_process";
-import { Socket, createServer } from "node:net";
+import { Socket, connect, createServer } from "node:net";
 import { once } from "node:events";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -19,22 +20,11 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region src/services/process/listening.ts
 async function findFreePort() {
-	return await new Promise((resolve, reject) => {
-		const server = createServer();
-		server.listen(0, () => {
-			const address = server.address();
-			if (address === null || typeof address === "string") {
-				server.close();
-				reject(invariant("a server listening on port 0 answered no port"));
-				return;
-			}
-			const { port } = address;
-			server.close(() => {
-				resolve(port);
-			});
-		});
-		server.on("error", reject);
-	});
+	const server = createServer();
+	const port = await listenedPort(server);
+	server.close();
+	await once(server, "close");
+	return port;
 }
 async function firstAnswering(urls) {
 	return (await Promise.all(urls.map(async (url) => await answers(url) ? url : void 0))).find((url) => url !== void 0);
@@ -47,6 +37,44 @@ async function answers(url) {
 		return false;
 	}
 }
+const LOOPBACK = ["127.0.0.1", "::1"];
+async function holdingHost(port) {
+	return (await Promise.all(LOOPBACK.map(async (host) => await accepts(host, port) ? host : void 0))).find((host) => host !== void 0);
+}
+async function accepts(host, port) {
+	return await new Promise((resolve) => {
+		const socket = connect({
+			host,
+			port
+		});
+		socket.once("connect", () => {
+			socket.destroy();
+			resolve(true);
+		});
+		socket.once("error", () => {
+			resolve(false);
+		});
+	});
+}
+//#endregion
+//#region src/services/process/output-change.ts
+/** Wakes one waiter when the output of a process grows or the process closes. */
+var OutputChange = class {
+	waiting;
+	notify() {
+		this.waiting?.();
+	}
+	/** Resolves on the next change, or after `withinMs` when none comes. */
+	async next(withinMs) {
+		await new Promise((resolve) => {
+			const late = setTimeout(resolve, withinMs);
+			this.waiting = () => {
+				clearTimeout(late);
+				resolve();
+			};
+		});
+	}
+};
 //#endregion
 //#region src/services/process/port-in-use.ts
 const PORT_IN_USE = /EADDRINUSE|address already in use|port \d+ is already in use/iu;
@@ -58,6 +86,17 @@ function lessonOf(reason, output, port) {
 		why: "A process is handed a free port unless `port` pins one, and a port another process holds is not free."
 	};
 }
+async function refuseHeldPort(port, specification, command) {
+	if (port === void 0) return;
+	const host = await holdingHost(port);
+	if (host === void 0) return;
+	throw new Error(refusal({
+		fix: `stop the process holding port ${String(port)}, or drop the \`port\` option so a free one is picked`,
+		found: `specification.${specification}(): port ${String(port)}, which \`port\` pins, is already held: something answers on ${host} before the server is started.\nCommand: ${command}`,
+		read: "docs/reference/services.md#process-the-one-shape-an-external-process-takes",
+		why: "A process pinned to a port is ready once that port answers, and a port another process holds would answer in its place."
+	}));
+}
 //#endregion
 //#region src/services/process/process-group.ts
 const KILL_GRACE_MS = 2e3;
@@ -127,14 +166,11 @@ function groupRunning(group) {
 		return false;
 	}
 }
-async function endedBy(group, deadline) {
-	if (!groupRunning(group)) return true;
-	if (Date.now() >= deadline) return false;
-	await pause(GROUP_SETTLE_MS);
-	return await endedBy(group, deadline);
-}
 async function groupEnded(group, withinMs) {
-	return await endedBy(group, Date.now() + withinMs);
+	return await untilDeadline(() => !groupRunning(group) || void 0, {
+		interval: GROUP_SETTLE_MS,
+		timeout: withinMs
+	}) === true;
 }
 /** Resolves once the child is reaped, at once for one reaped already. */
 async function reaped(child) {
@@ -150,6 +186,13 @@ function signalGroup(child, signal = "SIGTERM") {
 	} catch {}
 	return child.kill(signal);
 }
+async function endGroup(child) {
+	if (child.pid === void 0) return;
+	const leaderReaped = reaped(child);
+	signalGroup(child, "SIGTERM");
+	if (!await groupEnded(-child.pid, 2e3)) signalGroup(child, "SIGKILL");
+	await leaderReaped;
+}
 //#endregion
 //#region src/services/process/serve.ts
 var serve_exports = /* @__PURE__ */ __exportAll({
@@ -157,7 +200,7 @@ var serve_exports = /* @__PURE__ */ __exportAll({
 	runToCompletion: () => runToCompletion
 });
 const DEFAULT_READY_TIMEOUT = 3e4;
-const READY_POLL_INTERVAL_MS = 250;
+const READY_POLL_INTERVAL_MS = 25;
 function watchGroup(groupId, strays) {
 	const args = [
 		"-e",
@@ -202,6 +245,7 @@ function runToCompletion(command, env) {
 var ServedProcess = class {
 	port = null;
 	child = null;
+	change = new OutputChange();
 	extraEnv;
 	specification;
 	options;
@@ -218,12 +262,12 @@ var ServedProcess = class {
 		this.root = root;
 	}
 	async start() {
+		await refuseHeldPort(this.options.port, this.specification, this.options.command);
 		this.runBefore();
 		const banner = this.options.ready instanceof RegExp ? this.options.ready : null;
 		const port = banner ? null : this.options.port ?? await findFreePort();
 		this.spawnServer(port);
-		const deadline = Date.now() + this.timeout();
-		return (banner ? await this.awaitBanner(banner, deadline) : await this.awaitAnswer(port ?? 0, deadline)) ?? await this.refuse({
+		return (banner ? await this.awaitBanner(banner) : await this.awaitAnswer(port ?? 0)) ?? await this.refuse({
 			fix: "run the command by hand and correct what its output names",
 			found: "the server command exited before it was ready",
 			why: "A process is handed to the chain once it is ready, and one that exits never is."
@@ -256,57 +300,62 @@ var ServedProcess = class {
 		if (child.pid !== void 0 && SIGNALS_GROUPS) this.watchdog = watchGroup(child.pid, this.strays);
 		const collect = (data) => {
 			this.output += String(data);
+			this.change.notify();
 		};
 		child.stdout?.on("data", collect);
 		child.stderr?.on("data", collect);
 		child.on("close", () => {
 			this.exited = true;
+			this.change.notify();
 		});
 		child.on("error", (error) => {
 			collect(`${String(error)}\n`);
 		});
 	}
-	async awaitBanner(banner, deadline) {
-		while (!this.exited) {
+	async awaitBanner(banner) {
+		const seen = await untilDeadline(() => {
+			if (this.exited) return "exited";
 			banner.lastIndex = 0;
-			const found = banner.exec(this.output);
-			if (found) return await this.bannerPort(banner, found[1]);
-			if (Date.now() >= deadline) return await this.refuse({
-				fix: "correct the pattern to what the server prints, or raise `timeout`",
-				found: `the server did not print ${String(banner)} within ${this.timeout()}ms`,
-				why: "A process is ready once its output matches `ready`, within `timeout`."
-			});
-			await pause(READY_POLL_INTERVAL_MS);
-		}
-		return null;
+			return banner.exec(this.output) ?? void 0;
+		}, {
+			timeout: this.timeout(),
+			wait: async (remaining) => {
+				await this.change.next(remaining);
+			}
+		});
+		if (seen === "exited") return null;
+		if (seen === void 0) return await this.refuse({
+			fix: "correct the pattern to what the server prints, or raise `timeout`",
+			found: `the server did not print ${String(banner)} within ${this.timeout()}ms`,
+			why: "A process is ready once its output matches `ready`, within `timeout`."
+		});
+		return await this.bannerPort(banner, seen[1]);
 	}
 	async bannerPort(banner, group) {
 		const captured = Number(group);
 		if (!Number.isInteger(captured)) return await this.refuse({
-			fix: "capture the port alone in the pattern's one group, e.g. /listening on (\\d+)/",
+			fix: String.raw`capture the port alone in the pattern's one group, e.g. /listening on (\d+)/`,
 			found: `the ready pattern ${String(banner)} matched, and its capture group is not a port ("${group}")`,
 			why: "A RegExp `ready` is read over the output, and its one capture group is the port."
 		});
 		this.port = captured;
 		return `http://127.0.0.1:${captured}`;
 	}
-	async awaitAnswer(port, deadline) {
+	async awaitAnswer(port) {
 		const baseUrls = [`http://127.0.0.1:${port}`, `http://[::1]:${port}`];
 		const path = typeof this.options.ready === "string" ? this.options.ready : "/";
-		while (!this.exited) {
-			const answering = await firstAnswering(baseUrls.map((baseUrl) => `${baseUrl}${path}`));
-			if (answering !== void 0) {
-				this.port = port;
-				return answering.slice(0, answering.length - path.length);
-			}
-			if (Date.now() >= deadline) return await this.refuse({
-				fix: "correct `ready` to a path the server answers, have it listen on `PORT`, or raise `timeout`",
-				found: `the server did not answer on ${baseUrls.map((baseUrl) => `${baseUrl}${path}`).join(" or ")} within ${this.timeout()}ms, whatever address it printed above`,
-				why: "A process is ready once its `ready` path answers, within `timeout`."
-			});
-			await pause(READY_POLL_INTERVAL_MS);
-		}
-		return null;
+		const seen = await untilDeadline(async () => this.exited ? "exited" : await firstAnswering(baseUrls.map((baseUrl) => `${baseUrl}${path}`)), {
+			interval: READY_POLL_INTERVAL_MS,
+			timeout: this.timeout()
+		});
+		if (seen === "exited") return null;
+		if (seen === void 0) return await this.refuse({
+			fix: "correct `ready` to a path the server answers, have it listen on `PORT`, or raise `timeout`",
+			found: `the server did not answer on ${baseUrls.map((baseUrl) => `${baseUrl}${path}`).join(" or ")} within ${this.timeout()}ms, whatever address it printed above`,
+			why: "A process is ready once its `ready` path answers, within `timeout`."
+		});
+		this.port = port;
+		return seen.slice(0, seen.length - path.length);
 	}
 	timeout() {
 		return this.options.timeout ?? DEFAULT_READY_TIMEOUT;
@@ -352,14 +401,7 @@ var ServedProcess = class {
 		this.watchdog = null;
 	}
 };
-async function endGroup(child) {
-	if (child.pid === void 0) return;
-	const leaderReaped = reaped(child);
-	signalGroup(child, "SIGTERM");
-	if (!await groupEnded(-child.pid, 2e3)) signalGroup(child, "SIGKILL");
-	await leaderReaped;
-}
 //#endregion
-export { signalGroup as a, SIGNALS_GROUPS as i, serve_exports as n, KILL_GRACE_MS as r, ServedProcess as t };
+export { endGroup as a, SIGNALS_GROUPS as i, serve_exports as n, signalGroup as o, KILL_GRACE_MS as r, ServedProcess as t };
 
 //# sourceMappingURL=shared-serve.js.map