@jterrazz/test 17.0.0 → 18.0.1

package/dist/shared-serve.js

@@ -1,10 +1,13 @@
-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 "./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 { randomInt } from "node:crypto";
+import { Socket, connect } from "node:net";
 import { once } from "node:events";
+import { createSocket } from "node:dgram";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -18,24 +21,6 @@ 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);
-	});
-}
 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 +32,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 +81,80 @@ 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/port-reservation.ts
+const DRAWN_PORTS = {
+	first: 1e4,
+	last: 32767
+};
+function draw() {
+	return randomInt(DRAWN_PORTS.first, DRAWN_PORTS.last + 1);
+}
+async function claimPort(port) {
+	const socket = createSocket("udp4");
+	const failure = await new Promise((resolve) => {
+		socket.on("error", resolve);
+		socket.bind({
+			address: "127.0.0.1",
+			port
+		}, () => {
+			resolve(void 0);
+		});
+	});
+	if (failure === void 0) {
+		socket.unref();
+		return {
+			port,
+			release: closing(socket)
+		};
+	}
+	socket.close();
+	return failure instanceof Error && "code" in failure && failure.code === "EADDRINUSE" ? void 0 : {
+		port,
+		release: () => void 0
+	};
+}
+function closing(socket) {
+	let open = true;
+	return () => {
+		if (open) {
+			open = false;
+			socket.close();
+		}
+	};
+}
+async function reserveFreePort(pick = draw) {
+	for (let attempt = 0; attempt < 64; attempt += 1) {
+		const reservation = await claimPort(pick());
+		if (reservation === void 0) continue;
+		if (await holdingHost(reservation.port) === void 0) return reservation;
+		reservation.release();
+	}
+}
+/** The port a served process is handed (the one `port` pins, else a drawn one) reserved for it, or the lesson of why none could be. */
+async function reservePort(pinned, pick = draw) {
+	if (pinned !== void 0) return await claimPort(pinned) ?? {
+		fix: "drop the `port` option so each process is handed a free one, or run the specifications that pin it one at a time",
+		found: `port ${String(pinned)}, which \`port\` pins, is reserved by another served process on this machine`,
+		why: "A port is one served process's at a time, and a server sharing it would answer in the other's place."
+	};
+	return await reserveFreePort(pick) ?? {
+		fix: "stop the servers holding the ports of that range, or pin a free one with `port`",
+		found: `no free port in ${String(DRAWN_PORTS.first)}-${String(DRAWN_PORTS.last)} after ${String(64)} draws`,
+		why: "A process is handed a port drawn below the range the OS hands unasked ports from, and one nothing holds."
+	};
+}
 //#endregion
 //#region src/services/process/process-group.ts
 const KILL_GRACE_MS = 2e3;
@@ -127,14 +224,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 +244,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 +258,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",
@@ -198,13 +299,15 @@ function runToCompletion(command, env) {
 		stdio: "pipe"
 	});
 }
-/** Any HTTP status counts as ready. The child runs in its own process group so `stop()` kills a `next start` grandchild too, and a watchdog kills that group when the run dies before `stop()`; both reap the strays it declares, the processes it spawns outside its group. */
+/** Any HTTP status counts as ready, since the port it is handed is reserved for it until `stop()`: no other served process is handed it, and no socket is handed it by chance. The child runs in its own process group so `stop()` kills a `next start` grandchild too, and a watchdog kills that group when the run dies before `stop()`; both reap the strays it declares, the processes it spawns outside its group. */
 var ServedProcess = class {
 	port = null;
 	child = null;
+	change = new OutputChange();
 	extraEnv;
 	specification;
 	options;
+	reservation = null;
 	exited = false;
 	output = "";
 	root;
@@ -218,17 +321,25 @@ 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();
+		const port = banner ? null : await this.reserve();
 		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."
 		});
 	}
+	async reserve() {
+		const reserved = await reservePort(this.options.port);
+		if ("release" in reserved) {
+			this.reservation = reserved;
+			return reserved.port;
+		}
+		return await this.refuse(reserved);
+	}
 	environment(port) {
 		return {
 			...process.env,
@@ -256,57 +367,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;
@@ -343,6 +459,8 @@ var ServedProcess = class {
 		}));
 	}
 	async stop() {
+		this.reservation?.release();
+		this.reservation = null;
 		const { child } = this;
 		if (!child) return;
 		this.child = null;
@@ -352,14 +470,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

package/dist/shared-services.global-setup.js

@@ -1,8 +1,9 @@
 import { n as refusal } from "./shared-refusal.js";
-import { a as field, i as RunContainers, o as serveContainers, r as TestcontainersAdapter, t as OWNER_LABEL } from "./shared-testcontainers.adapter.js";
+import { a as field, i as RunContainers, o as serveContainers, r as TestcontainersAdapter, s as DOCKER_ABSENT, t as OWNER_LABEL } from "./shared-testcontainers.adapter.js";
 import { t as loadPeer } from "./shared-peer.js";
 import { t as SERVICE_IMAGES } from "./shared-service-images.js";
 import { t as setupEntry } from "./shared-setup-entry.js";
+import { t as processAlive } from "./shared-process-alive.js";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { hostname } from "node:os";
@@ -15,12 +16,7 @@ function ownerAlive(owner, host = hostname(), probe = (pid) => process.kill(pid,
 	const separator = owner.lastIndexOf(":");
 	const pid = Number(owner.slice(separator + 1));
 	if (separator === -1 || owner.slice(0, separator) !== host || !Number.isSafeInteger(pid) || pid <= 0) return true;
-	try {
-		probe(pid);
-		return true;
-	} catch (error) {
-		return Reflect.get(new Object(error), "code") !== "ESRCH";
-	}
+	return processAlive(pid, probe);
 }
 function orphans(containers, alive) {
 	const reaped = new Set(containers.filter((container) => container.State === "running" && container.Labels[REAPER_LABEL] === "true").map((reaper) => reaper.Labels[SESSION_LABEL]));
@@ -50,7 +46,6 @@ async function sweepOrphans(runtime, alive = ownerAlive) {
 //#endregion
 //#region src/services/containers/services.global-setup.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. */
-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. */
 async function prepareDocker(connect) {
 	const { getContainerRuntimeClient, ImageName } = await loadPeer("testcontainers", "a declared service", async () => await import("testcontainers"));
@@ -174,6 +169,6 @@ async function setup(project, seams = {}) {
 	return joined.leave;
 }
 //#endregion
-export { setup as i, prepareDocker as n, servicesSetup as r, DOCKER_ABSENT as t };
+export { servicesSetup as n, setup as r, prepareDocker as t };
 
 //# sourceMappingURL=shared-services.global-setup.js.map

package/dist/shared-session-ledger.js

@@ -1,7 +1,7 @@
 import { t as ServedProcess } from "./shared-serve.js";
 import { t as isRecord } from "./shared-json-shape.js";
 import { n as refusal } from "./shared-refusal.js";
-import { l as VITEST_ARTIFACTS_DIR } from "./shared-artifacts.js";
+import { u as VITEST_ARTIFACTS_DIR } from "./shared-artifacts.js";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { execFile } from "node:child_process";
@@ -227,9 +227,13 @@ async function reachAppium({ appium: declared, device }, root, run) {
 //#region src/specifications/mobile/session/session-ledger.ts
 const SERVER_CALL_TIMEOUT_MS = 1e4;
 const MOBILE_SESSIONS_DIR = `${VITEST_ARTIFACTS_DIR}/mobile-sessions`;
-function keyOf(serverUrl, requested) {
+function keyOf(serverUrl, requested, worker) {
 	const sorted = Object.entries(requested).toSorted(([a], [b]) => a.localeCompare(b));
-	return JSON.stringify([serverUrl, sorted]);
+	return JSON.stringify([
+		serverUrl,
+		sorted,
+		worker
+	]);
 }
 function isEntry(value) {
 	return isRecord(value) && [
@@ -249,13 +253,13 @@ function entries(directory) {
 	const parsed = (name) => JSON.parse(readFileSync(join(directory, name), "utf8"));
 	return entryFiles(directory).map((name) => parsed(name)).filter((entry) => isEntry(entry));
 }
-function sessionLedger(directory) {
+function sessionLedger(directory, worker = process.env.VITEST_POOL_ID ?? "") {
 	return {
 		forget: (sessionId) => {
 			rmSync(join(directory, `${sessionId}.json`), { force: true });
 		},
 		lookup: (serverUrl, requested) => {
-			const key = keyOf(serverUrl, requested);
+			const key = keyOf(serverUrl, requested, worker);
 			return entries(directory).filter((entry) => entry.key === key).map(({ capabilities, serverUrl: url, sessionId }) => ({
 				capabilities,
 				serverUrl: url,
@@ -265,7 +269,7 @@ function sessionLedger(directory) {
 		record: (requested, session) => {
 			const entry = {
 				...session,
-				key: keyOf(session.serverUrl, requested)
+				key: keyOf(session.serverUrl, requested, worker)
 			};
 			mkdirSync(directory, { recursive: true });
 			writeFileSync(join(directory, `${session.sessionId}.json`), `${JSON.stringify(entry)}\n`);

package/dist/shared-spec-document.js

@@ -1,10 +1,6 @@
+import { a as RUN_KEYS, c as isRelativePath, i as PRESENCE, n as FILE_CONTENT_KEYS, r as FILE_STATES, s as SpecSyntaxError, t as DOCUMENT_KEYS } from "./shared-spec-grammar.js";
 import { a as isPair, c as nodeItems, f as yamlSyntaxErrors, i as isNode, l as nodePairs, o as isScalar, r as isMap, s as isSeq, u as parseYamlSource } from "./shared-yaml-document.js";
 import { GROUND_FIXTURES, isGroundFolder } from "@jterrazz/typescript/rules";
-//#region lint/kit/project/relative-path.ts
-function isRelativePath(value) {
-	return value.startsWith("./") || value.startsWith("../");
-}
-//#endregion
 //#region lint/kit/project/dedent.ts
 function indentOf(line) {
 	return /^[\t ]*/u.exec(line)?.[0].length ?? 0;
@@ -19,64 +15,6 @@ function dedent(text) {
 	return lines.map((line) => line.slice(common)).join("\n");
 }
 //#endregion
-//#region lint/kit/project/spec-grammar.ts
-const SPEC_EXTENSION = ".spec.yaml";
-const DOCUMENT_KEYS = [
-	"description",
-	"fixture",
-	"env",
-	"serve",
-	"runs"
-];
-const RUN_KEYS = [
-	"command",
-	"stdin",
-	"timeout",
-	"waitFor",
-	"exit",
-	"stdout",
-	"stderr",
-	"files"
-];
-const FILE_CONTENT_KEYS = ["contains", "equals"];
-const FILE_STATES = ["absent", "exists"];
-const PRESENCE = {
-	document: [{
-		keys: ["description"],
-		law: "each",
-		refusal: () => "missing \"description:\": every document is one test, and this is its title"
-	}, {
-		keys: ["runs"],
-		law: "each",
-		refusal: () => "missing \"runs:\": description and runs are mandatory"
-	}],
-	files: [{
-		keys: FILE_CONTENT_KEYS,
-		law: "some",
-		refusal: (path) => `files: ${path} asserts nothing: give it contains: or equals:`
-	}],
-	run: [{
-		keys: ["command", "exit"],
-		law: "each",
-		refusal: (_subject, key) => `a run is missing "${key}:": command and exit are mandatory`
-	}, {
-		keys: ["waitFor"],
-		law: "apart",
-		refusal: () => "waitFor: and stdin: cannot share a run: the pattern is watched on a process nobody closed the input of",
-		with: "stdin"
-	}]
-};
-var SpecSyntaxError = class extends Error {
-	line;
-	reason;
-	constructor(fileName, line, message) {
-		super(`${fileName}:${line}: ${message}`);
-		this.line = line;
-		this.reason = message;
-		this.name = "SpecSyntaxError";
-	}
-};
-//#endregion
 //#region lint/kit/project/spec-node.ts
 function fail(context, node, message) {
 	throw new SpecSyntaxError(context.fileName, lineOf(context, node), message);
@@ -360,6 +298,6 @@ function parseSpecDocument(content, fileName) {
 	return readSpecFile(content, fileName).document;
 }
 //#endregion
-export { scalarString as a, SPEC_EXTENSION as c, isRelativePath as d, readSpecFile as i, SpecSyntaxError as l, documentPaths as n, DOCUMENT_KEYS as o, parseSpecDocument as r, RUN_KEYS as s, assertedStreams as t, dedent as u };
+export { scalarString as a, readSpecFile as i, documentPaths as n, dedent as o, parseSpecDocument as r, assertedStreams as t };
 
 //# sourceMappingURL=shared-spec-document.js.map

package/dist/shared-spec-grammar.js

@@ -0,0 +1,66 @@
+//#region lint/kit/project/relative-path.ts
+function isRelativePath(value) {
+	return value.startsWith("./") || value.startsWith("../");
+}
+//#endregion
+//#region lint/kit/project/spec-grammar.ts
+const SPEC_EXTENSION = ".spec.yaml";
+const DOCUMENT_KEYS = [
+	"description",
+	"fixture",
+	"env",
+	"serve",
+	"runs"
+];
+const RUN_KEYS = [
+	"command",
+	"stdin",
+	"timeout",
+	"waitFor",
+	"exit",
+	"stdout",
+	"stderr",
+	"files"
+];
+const FILE_CONTENT_KEYS = ["contains", "equals"];
+const FILE_STATES = ["absent", "exists"];
+const PRESENCE = {
+	document: [{
+		keys: ["description"],
+		law: "each",
+		refusal: () => "missing \"description:\": every document is one test, and this is its title"
+	}, {
+		keys: ["runs"],
+		law: "each",
+		refusal: () => "missing \"runs:\": description and runs are mandatory"
+	}],
+	files: [{
+		keys: FILE_CONTENT_KEYS,
+		law: "some",
+		refusal: (path) => `files: ${path} asserts nothing: give it contains: or equals:`
+	}],
+	run: [{
+		keys: ["command", "exit"],
+		law: "each",
+		refusal: (_subject, key) => `a run is missing "${key}:": command and exit are mandatory`
+	}, {
+		keys: ["waitFor"],
+		law: "apart",
+		refusal: () => "waitFor: and stdin: cannot share a run: the pattern is watched on a process nobody closed the input of",
+		with: "stdin"
+	}]
+};
+var SpecSyntaxError = class extends Error {
+	line;
+	reason;
+	constructor(fileName, line, message) {
+		super(`${fileName}:${line}: ${message}`);
+		this.line = line;
+		this.reason = message;
+		this.name = "SpecSyntaxError";
+	}
+};
+//#endregion
+export { RUN_KEYS as a, isRelativePath as c, PRESENCE as i, FILE_CONTENT_KEYS as n, SPEC_EXTENSION as o, FILE_STATES as r, SpecSyntaxError as s, DOCUMENT_KEYS as t };
+
+//# sourceMappingURL=shared-spec-grammar.js.map