@jterrazz/test 8.0.0 → 9.1.0

package/dist/index.cjs

@@ -1,2264 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./chunk.cjs");
-const require_sqlite = require("./sqlite.cjs");
-const require_mock_of = require("./mock-of.cjs");
-let node_child_process = require("node:child_process");
-let node_path = require("node:path");
-let node_fs = require("node:fs");
-let yaml = require("yaml");
-let node_os = require("node:os");
-let node_fs_promises = require("node:fs/promises");
-//#region src/infra/docker/docker-assertion.ts
-/**
-* Fluent assertion builder for Docker containers.
-* Chain async assertions like `toBeRunning()`, `toHaveFile()`, `toHaveMount()`.
-*/
-var DockerAssertion = class {
-	container;
-	constructor(container) {
-		this.container = container;
-	}
-	/** Assert the container is running */
-	async toBeRunning() {
-		if (!await this.container.isRunning()) throw new Error("Expected container to be running");
-		return this;
-	}
-	/** Assert the container is NOT running / doesn't exist */
-	async toNotExist() {
-		if (await this.container.isRunning()) throw new Error("Expected container to not exist or not be running");
-		return this;
-	}
-	/** Assert a file exists inside the container */
-	async toHaveFile(path, opts) {
-		const file = await this.container.file(path);
-		if (!file.exists) throw new Error(`Expected file ${path} to exist in container`);
-		if (opts?.containing && !file.content.includes(opts.containing)) throw new Error(`Expected file ${path} to contain "${opts.containing}", got: ${file.content.slice(0, 200)}`);
-		return this;
-	}
-	/** Assert a file does NOT exist */
-	async toNotHaveFile(path) {
-		if (await this.container.exists(path)) throw new Error(`Expected ${path} to not exist in container`);
-		return this;
-	}
-	/** Assert a directory exists */
-	async toHaveDirectory(path) {
-		if (!await this.container.exists(path)) throw new Error(`Expected directory ${path} to exist in container`);
-		return this;
-	}
-	/** Assert a mount exists */
-	async toHaveMount(destination) {
-		const info = await this.container.inspect();
-		if (!info.hostConfig.mounts.find((m) => m.destination === destination)) {
-			const available = info.hostConfig.mounts.map((m) => m.destination).join(", ");
-			throw new Error(`Expected mount at ${destination}, found: [${available}]`);
-		}
-		return this;
-	}
-	/** Assert network mode */
-	async toHaveNetwork(mode) {
-		const info = await this.container.inspect();
-		if (!info.hostConfig.networkMode.includes(mode)) throw new Error(`Expected network mode "${mode}", got "${info.hostConfig.networkMode}"`);
-		return this;
-	}
-	/** Assert memory limit */
-	async toHaveMemoryLimit(bytes) {
-		const info = await this.container.inspect();
-		if (info.hostConfig.memory !== bytes) throw new Error(`Expected memory limit ${bytes}, got ${info.hostConfig.memory}`);
-		return this;
-	}
-	/** Assert CPU quota */
-	async toHaveCpuQuota(quota) {
-		const info = await this.container.inspect();
-		if (info.hostConfig.cpuQuota !== quota) throw new Error(`Expected CPU quota ${quota}, got ${info.hostConfig.cpuQuota}`);
-		return this;
-	}
-	/** Execute a command and return output for custom assertions */
-	async exec(cmd) {
-		return this.container.exec(cmd);
-	}
-	/** Read a file for custom assertions */
-	async readFile(path) {
-		const file = await this.container.file(path);
-		if (!file.exists) throw new Error(`File ${path} does not exist`);
-		return file.content;
-	}
-	/** Get logs for custom assertions */
-	async getLogs(tail) {
-		return this.container.logs(tail);
-	}
-};
-//#endregion
-//#region src/infra/docker/docker.ts
-/**
-* Implements {@link DockerContainerPort} by shelling out to the Docker CLI.
-* Each instance is bound to a single container ID.
-*/
-var DockerAdapter = class {
-	containerId;
-	constructor(containerId) {
-		this.containerId = containerId;
-	}
-	async exec(cmd) {
-		return (0, node_child_process.execSync)(`docker exec ${this.containerId} ${cmd.map((c) => `'${c}'`).join(" ")}`, {
-			encoding: "utf8",
-			timeout: 1e4
-		}).trim();
-	}
-	async file(path) {
-		try {
-			return {
-				exists: true,
-				content: await this.exec(["cat", path])
-			};
-		} catch {
-			return {
-				exists: false,
-				content: ""
-			};
-		}
-	}
-	async isRunning() {
-		try {
-			return (0, node_child_process.execSync)(`docker inspect --format='{{.State.Running}}' ${this.containerId}`, {
-				encoding: "utf8",
-				timeout: 5e3
-			}).trim() === "true";
-		} catch {
-			return false;
-		}
-	}
-	async logs(tail) {
-		return (0, node_child_process.execSync)(`docker logs ${tail ? `--tail ${tail}` : ""} ${this.containerId}`, {
-			encoding: "utf8",
-			timeout: 1e4
-		});
-	}
-	async inspect() {
-		const raw = (0, node_child_process.execSync)(`docker inspect ${this.containerId}`, {
-			encoding: "utf8",
-			timeout: 5e3
-		});
-		const data = JSON.parse(raw)[0];
-		return {
-			id: data.Id,
-			name: data.Name,
-			state: {
-				running: data.State.Running,
-				exitCode: data.State.ExitCode,
-				status: data.State.Status
-			},
-			config: {
-				image: data.Config.Image,
-				env: data.Config.Env || []
-			},
-			hostConfig: {
-				memory: data.HostConfig.Memory || 0,
-				cpuQuota: data.HostConfig.CpuQuota || 0,
-				networkMode: data.HostConfig.NetworkMode || "",
-				mounts: (data.Mounts || []).map((m) => ({
-					source: m.Source,
-					destination: m.Destination,
-					type: m.Type
-				}))
-			},
-			networkSettings: { networks: Object.fromEntries(Object.entries(data.NetworkSettings.Networks || {}).map(([name, net]) => [name, {
-				gateway: net.Gateway,
-				ipAddress: net.IPAddress
-			}])) }
-		};
-	}
-	async exists(path) {
-		try {
-			await this.exec([
-				"test",
-				"-e",
-				path
-			]);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-};
-/** Create a {@link DockerContainerPort} bound to an existing container by ID. */
-function dockerContainer(containerId) {
-	return new DockerAdapter(containerId);
-}
-//#endregion
-//#region src/spec/reporter.ts
-const GREEN = "\x1B[32m";
-const RED = "\x1B[31m";
-const DIM = "\x1B[2m";
-const BOLD = "\x1B[1m";
-const RESET = "\x1B[0m";
-const BG_CYAN = "\x1B[46m";
-const BLACK = "\x1B[30m";
-const CHECK = "✓";
-const CROSS = "×";
-const ARROW = "→";
-function formatStartupReport(mode, services, app) {
-	const lines = [];
-	lines.push("");
-	lines.push(`${BG_CYAN}${BLACK}${BOLD} INFRA ${RESET} Starting infrastructure...`);
-	lines.push("");
-	for (const service of services) if (service.error) {
-		lines.push(`  ${RED}${CROSS}${RESET} ${service.type} (${service.name})  ${RED}${service.error}${RESET}  ${DIM}${service.durationMs}ms${RESET}`);
-		if (service.logs) {
-			const logLines = service.logs.trim().split("\n").slice(-10);
-			for (const logLine of logLines) lines.push(`    ${DIM}${logLine}${RESET}`);
-		}
-	} else {
-		const conn = service.connectionString ? `${DIM}${service.connectionString}${RESET}` : "";
-		lines.push(`  ${GREEN}${CHECK}${RESET} ${service.type} (${service.name})  ${conn}  ${DIM}${service.durationMs}ms${RESET}`);
-	}
-	if (app) {
-		lines.push("");
-		if (app.type === "in-process") lines.push(`  ${DIM}${ARROW} app: in-process (Hono)${RESET}`);
-		else lines.push(`  ${DIM}${ARROW} app: ${app.url}${RESET}`);
-	}
-	lines.push("");
-	return lines.join("\n");
-}
-function formatTableDiff(table, columns, expected, actual) {
-	const lines = [];
-	lines.push(`Table "${table}" mismatch`);
-	lines.push(`${DIM}  query: ${columns.join(", ")}${RESET}`);
-	lines.push(`${DIM}  expected: ${rowLabel(expected.length)}${RESET}`);
-	lines.push(`${DIM}  received: ${rowLabel(actual.length)}${RESET}`);
-	lines.push("");
-	lines.push(`${GREEN}- Expected${RESET}`);
-	lines.push(`${RED}+ Received${RESET}`);
-	lines.push("");
-	const header = columns.join("  |  ");
-	lines.push(`${DIM}  ${header}${RESET}`);
-	const maxRows = Math.max(expected.length, actual.length);
-	for (let i = 0; i < maxRows; i++) {
-		const exp = expected[i];
-		const act = actual[i];
-		if (exp && !act) lines.push(`${GREEN}- ${formatRow(exp)}${RESET}`);
-		else if (!exp && act) lines.push(`${RED}+ ${formatRow(act)}${RESET}`);
-		else if (exp && act) if (JSON.stringify(exp) === JSON.stringify(act)) lines.push(`  ${formatRow(act)}`);
-		else {
-			lines.push(`${GREEN}- ${formatRow(exp)}${RESET}`);
-			lines.push(`${RED}+ ${formatRow(act)}${RESET}`);
-		}
-	}
-	if (expected.length === 0 && actual.length === 0) lines.push(`  (empty)`);
-	return lines.join("\n");
-}
-function formatResponseDiff(file, expected, actual) {
-	const lines = [];
-	lines.push(`Response mismatch (${file})`);
-	lines.push("");
-	lines.push(`${GREEN}- Expected${RESET}`);
-	lines.push(`${RED}+ Received${RESET}`);
-	lines.push("");
-	const expectedLines = JSON.stringify(expected, null, 2).split("\n");
-	const actualLines = JSON.stringify(actual, null, 2).split("\n");
-	const maxLines = Math.max(expectedLines.length, actualLines.length);
-	for (let i = 0; i < maxLines; i++) {
-		const exp = expectedLines[i];
-		const act = actualLines[i];
-		if (exp === act) lines.push(`  ${exp}`);
-		else {
-			if (exp !== void 0) lines.push(`${GREEN}- ${exp}${RESET}`);
-			if (act !== void 0) lines.push(`${RED}+ ${act}${RESET}`);
-		}
-	}
-	return lines.join("\n");
-}
-function formatStdoutDiff(file, expected, actual) {
-	const lines = [];
-	lines.push(`Output mismatch (${file})`);
-	lines.push("");
-	lines.push(`${GREEN}- Expected${RESET}`);
-	lines.push(`${RED}+ Received${RESET}`);
-	lines.push("");
-	const expectedLines = expected.split("\n");
-	const actualLines = actual.split("\n");
-	const maxLines = Math.max(expectedLines.length, actualLines.length);
-	for (let i = 0; i < maxLines; i++) {
-		const exp = expectedLines[i];
-		const act = actualLines[i];
-		if (exp === act) lines.push(`  ${exp}`);
-		else {
-			if (exp !== void 0) lines.push(`${GREEN}- ${exp}${RESET}`);
-			if (act !== void 0) lines.push(`${RED}+ ${act}${RESET}`);
-		}
-	}
-	return lines.join("\n");
-}
-function formatDirectoryDiff(fixtureName, diff, hint) {
-	const lines = [];
-	const total = diff.added.length + diff.removed.length + diff.changed.length;
-	lines.push(`Directory mismatch: ${BOLD}${fixtureName}${RESET}`);
-	lines.push(`${DIM}  ${total} difference${total === 1 ? "" : "s"}: ${diff.added.length} added, ${diff.removed.length} removed, ${diff.changed.length} changed${RESET}`);
-	lines.push("");
-	lines.push(`${GREEN}- Expected (fixture)${RESET}`);
-	lines.push(`${RED}+ Received (generated)${RESET}`);
-	lines.push("");
-	for (const path of diff.added) lines.push(`${RED}+ added    ${path}${RESET}  ${DIM}(not in fixture)${RESET}`);
-	for (const path of diff.removed) lines.push(`${GREEN}- removed  ${path}${RESET}  ${DIM}(in fixture, not generated)${RESET}`);
-	for (const { path, expected, actual } of diff.changed) {
-		const expectedLines = expected.split("\n");
-		const actualLines = actual.split("\n");
-		const changedCount = countLineDifferences(expectedLines, actualLines);
-		lines.push(`${BOLD}~ changed  ${path}${RESET}  ${DIM}(${changedCount} line${changedCount === 1 ? "" : "s"} differ)${RESET}`);
-		let shown = 0;
-		const maxShown = 5;
-		const maxLines = Math.max(expectedLines.length, actualLines.length);
-		for (let i = 0; i < maxLines && shown < maxShown; i++) {
-			const exp = expectedLines[i];
-			const act = actualLines[i];
-			if (exp !== act) {
-				lines.push(`${DIM}    line ${i + 1}:${RESET}`);
-				if (exp !== void 0) lines.push(`    ${GREEN}- ${exp}${RESET}`);
-				if (act !== void 0) lines.push(`    ${RED}+ ${act}${RESET}`);
-				shown++;
-			}
-		}
-		if (changedCount > maxShown) lines.push(`    ${DIM}... ${changedCount - maxShown} more line(s)${RESET}`);
-	}
-	lines.push("");
-	lines.push(`${DIM}${hint}${RESET}`);
-	return lines.join("\n");
-}
-function countLineDifferences(expected, actual) {
-	let count = 0;
-	const max = Math.max(expected.length, actual.length);
-	for (let i = 0; i < max; i++) if (expected[i] !== actual[i]) count++;
-	return count;
-}
-function rowLabel(n) {
-	return n === 1 ? "1 row" : `${n} rows`;
-}
-function formatRow(row) {
-	return row.map((v) => String(v ?? "null")).join("  |  ");
-}
-//#endregion
-//#region src/infra/containers/compose-parser.ts
-/**
-* Detect the service type from the image name.
-*/
-function detectServiceType(image) {
-	if (!image) return "app";
-	const lower = image.toLowerCase();
-	if (lower.startsWith("postgres")) return "postgres";
-	if (lower.startsWith("redis")) return "redis";
-	return "unknown";
-}
-/**
-* Find the compose file in the project.
-* Looks for docker/compose.test.yaml or docker-compose.test.yaml.
-*/
-function findComposeFile(projectRoot) {
-	const candidates = [
-		(0, node_path.resolve)(projectRoot, "docker/compose.test.yaml"),
-		(0, node_path.resolve)(projectRoot, "docker/compose.test.yml"),
-		(0, node_path.resolve)(projectRoot, "docker-compose.test.yaml"),
-		(0, node_path.resolve)(projectRoot, "docker-compose.test.yml")
-	];
-	for (const candidate of candidates) if ((0, node_fs.existsSync)(candidate)) return candidate;
-	return null;
-}
-/**
-* Parse a docker-compose file and extract service definitions.
-*/
-function parseComposeFile(filePath) {
-	const doc = (0, yaml.parse)((0, node_fs.readFileSync)(filePath, "utf8"));
-	if (!doc?.services) return {
-		services: [],
-		appService: null,
-		infraServices: []
-	};
-	const services = Object.entries(doc.services).map(([name, def]) => {
-		const ports = [];
-		if (def.ports) for (const port of def.ports) {
-			const str = String(port);
-			if (str.includes(":")) {
-				const [host, container] = str.split(":");
-				ports.push({
-					container: Number(container),
-					host: Number(host)
-				});
-			} else ports.push({ container: Number(str) });
-		}
-		const environment = {};
-		if (def.environment) if (Array.isArray(def.environment)) for (const env of def.environment) {
-			const [key, ...rest] = String(env).split("=");
-			environment[key] = rest.join("=");
-		}
-		else Object.assign(environment, def.environment);
-		const volumes = def.volumes ? def.volumes.map((v) => String(v)) : [];
-		let dependsOn = [];
-		if (def.depends_on) dependsOn = Array.isArray(def.depends_on) ? def.depends_on : Object.keys(def.depends_on);
-		return {
-			name,
-			image: def.image,
-			build: def.build,
-			ports,
-			environment,
-			volumes,
-			dependsOn
-		};
-	});
-	return {
-		services,
-		appService: services.find((s) => s.build !== void 0) ?? null,
-		infraServices: services.filter((s) => s.build === void 0)
-	};
-}
-//#endregion
-//#region src/infra/containers/compose.ts
-/**
-* Start the full compose stack and stop it all on cleanup.
-* Supports per-worker project names for parallel execution.
-*/
-var ComposeStackAdapter = class {
-	composeFile;
-	projectName;
-	started = false;
-	constructor(composeFile, projectName) {
-		this.composeFile = composeFile;
-		this.projectName = projectName ?? null;
-	}
-	get projectFlag() {
-		return this.projectName ? `-p ${this.projectName}` : "";
-	}
-	run(command) {
-		try {
-			return (0, node_child_process.execSync)(command, {
-				cwd: (0, node_path.dirname)(this.composeFile),
-				encoding: "utf8",
-				timeout: 12e4
-			}).trim();
-		} catch (error) {
-			const stderr = error.stderr?.toString().trim() ?? error.message;
-			throw new Error(`docker compose failed: ${stderr}`, { cause: error });
-		}
-	}
-	async start() {
-		if (this.started) return;
-		this.run(`docker compose ${this.projectFlag} -f ${this.composeFile} up -d --wait`);
-		this.started = true;
-	}
-	async stop() {
-		if (!this.started) return;
-		this.run(`docker compose ${this.projectFlag} -f ${this.composeFile} down -v`);
-		this.started = false;
-	}
-	getMappedPort(serviceName, containerPort) {
-		const port = this.run(`docker compose ${this.projectFlag} -f ${this.composeFile} port ${serviceName} ${containerPort}`).split(":").pop();
-		return Number(port);
-	}
-	getHost() {
-		return "localhost";
-	}
-};
-//#endregion
-//#region src/infra/containers/testcontainers.ts
-/**
-* Container adapter using testcontainers.
-* Wraps a GenericContainer for programmatic container lifecycle.
-*/
-var TestcontainersAdapter = class {
-	image;
-	containerPort;
-	env;
-	reuse;
-	container = null;
-	constructor(options) {
-		this.image = options.image;
-		this.containerPort = options.port;
-		this.env = options.env ?? {};
-		this.reuse = options.reuse ?? false;
-	}
-	async start() {
-		const { GenericContainer, Wait } = await import("testcontainers");
-		let builder = new GenericContainer(this.image).withExposedPorts(this.containerPort);
-		for (const [key, value] of Object.entries(this.env)) builder = builder.withEnvironment({ [key]: value });
-		if (this.image.startsWith("postgres")) builder = builder.withWaitStrategy(Wait.forLogMessage(/database system is ready to accept connections/, 2));
-		if (this.reuse) builder = builder.withReuse();
-		this.container = await builder.start();
-	}
-	async stop() {
-		if (this.container && !this.reuse) {
-			await this.container.stop();
-			this.container = null;
-		}
-	}
-	getMappedPort(containerPort) {
-		if (!this.container) throw new Error("Container not started");
-		return this.container.getMappedPort(containerPort);
-	}
-	getHost() {
-		if (!this.container) throw new Error("Container not started");
-		return this.container.getHost();
-	}
-	getConnectionString() {
-		return `${this.getHost()}:${this.getMappedPort(this.containerPort)}`;
-	}
-	async getLogs() {
-		if (!this.container) return "";
-		const stream = await this.container.logs();
-		return new Promise((resolve) => {
-			let output = "";
-			stream.on("data", (chunk) => {
-				output += chunk.toString();
-			});
-			stream.on("end", () => {
-				resolve(output);
-			});
-			setTimeout(() => {
-				resolve(output);
-			}, 1e3);
-		});
-	}
-};
-//#endregion
-//#region src/infra/orchestrator.ts
-/**
-* Orchestrator for test infrastructure.
-* Integration: starts services via testcontainers.
-* E2E: runs full docker compose up.
-*/
-var Orchestrator = class {
-	services;
-	mode;
-	root;
-	projectName;
-	running = [];
-	composeStack = null;
-	composeHandles = [];
-	started = false;
-	constructor(options) {
-		this.services = options.services;
-		this.mode = options.mode;
-		this.root = options.root ?? process.cwd();
-		this.projectName = options.projectName;
-	}
-	/**
-	* Start declared services via testcontainers (integration mode).
-	* Phase 1: start all containers in parallel (the slow part).
-	* Phase 2: wire connections, healthcheck, and init sequentially (fast).
-	*/
-	async start() {
-		if (this.started) return;
-		const composePath = findComposeFile(this.root);
-		const composeDir = composePath ? (0, node_path.dirname)(composePath) : this.root;
-		const composeConfig = composePath ? parseComposeFile(composePath) : null;
-		const containerServices = [];
-		const embeddedServices = [];
-		for (const handle of this.services) {
-			if (handle.defaultPort === 0) {
-				embeddedServices.push(handle);
-				continue;
-			}
-			let image = handle.defaultImage;
-			let env = { ...handle.environment };
-			if (handle.composeName && composeConfig) {
-				const composeService = composeConfig.services.find((s) => s.name === handle.composeName);
-				if (composeService) {
-					image = composeService.image ?? image;
-					env = {
-						...env,
-						...composeService.environment
-					};
-					Object.assign(handle.environment, composeService.environment);
-				}
-			}
-			const container = new TestcontainersAdapter({
-				image,
-				port: handle.defaultPort,
-				env
-			});
-			containerServices.push({
-				container,
-				handle
-			});
-		}
-		await Promise.all([...containerServices.map(({ container }) => container.start()), ...embeddedServices.map(async (handle) => {
-			await handle.initialize(composeDir);
-			handle.started = true;
-			this.running.push({
-				handle,
-				container: null
-			});
-		})]);
-		const reports = [];
-		for (const { container, handle } of containerServices) {
-			const serviceStartTime = Date.now();
-			try {
-				const host = container.getHost();
-				const port = container.getMappedPort(handle.defaultPort);
-				handle.connectionString = handle.buildConnectionString(host, port);
-				await handle.healthcheck();
-				await handle.initialize(composeDir);
-				handle.started = true;
-				reports.push({
-					name: handle.composeName ?? handle.type,
-					type: handle.type,
-					connectionString: handle.connectionString,
-					durationMs: Date.now() - serviceStartTime
-				});
-				this.running.push({
-					handle,
-					container
-				});
-			} catch (error) {
-				let logs = "";
-				try {
-					logs = await container.getLogs();
-				} catch {}
-				try {
-					await container.stop();
-				} catch {}
-				reports.push({
-					name: handle.composeName ?? handle.type,
-					type: handle.type,
-					durationMs: Date.now() - serviceStartTime,
-					error: error.message,
-					logs
-				});
-				const output = formatStartupReport("integration", reports, { type: "in-process" });
-				console.error(output);
-				throw error;
-			}
-		}
-		this.started = true;
-		const output = formatStartupReport("integration", reports, { type: "in-process" });
-		console.log(output);
-	}
-	/**
-	* Stop testcontainers (integration mode).
-	*/
-	async stop() {
-		for (const { container } of this.running) if (container) await container.stop();
-		this.running = [];
-		this.started = false;
-	}
-	/**
-	* Start full docker compose stack (e2e mode).
-	* Auto-detects infra services and creates handles for them.
-	*/
-	async startCompose() {
-		const composePath = findComposeFile(this.root);
-		if (!composePath) throw new Error(`E2E: no compose file found in ${this.root}`);
-		const startTime = Date.now();
-		const composeDir = (0, node_path.dirname)(composePath);
-		const composeConfig = parseComposeFile(composePath);
-		this.composeStack = new ComposeStackAdapter(composePath, this.projectName);
-		await this.composeStack.start();
-		for (const service of composeConfig.infraServices) {
-			const type = detectServiceType(service.image);
-			if (type === "postgres") {
-				const handle = require_sqlite.postgres({
-					compose: service.name,
-					env: service.environment
-				});
-				const port = this.composeStack.getMappedPort(service.name, 5432);
-				handle.connectionString = handle.buildConnectionString("localhost", port);
-				await handle.initialize(composeDir);
-				handle.started = true;
-				this.composeHandles.push(handle);
-			} else if (type === "redis") {
-				const handle = require_sqlite.redis({ compose: service.name });
-				const port = this.composeStack.getMappedPort(service.name, 6379);
-				handle.connectionString = handle.buildConnectionString("localhost", port);
-				handle.started = true;
-				this.composeHandles.push(handle);
-			}
-		}
-		const durationMs = Date.now() - startTime;
-		const output = formatStartupReport("e2e", this.composeHandles.map((h) => ({
-			name: h.composeName ?? h.type,
-			type: h.type,
-			connectionString: h.connectionString,
-			durationMs
-		})), {
-			type: "http",
-			url: this.getAppUrl() ?? void 0
-		});
-		console.log(output);
-	}
-	/**
-	* Stop docker compose stack (e2e mode).
-	*/
-	async stopCompose() {
-		if (this.composeStack) {
-			await this.composeStack.stop();
-			this.composeStack = null;
-		}
-		this.composeHandles = [];
-	}
-	/**
-	* Get a database service by compose name, or the first one if no name given.
-	*/
-	getDatabase(serviceName) {
-		for (const handle of [...this.services, ...this.composeHandles]) {
-			if (serviceName && handle.composeName !== serviceName) continue;
-			const adapter = handle.createDatabaseAdapter();
-			if (adapter) return adapter;
-		}
-		return null;
-	}
-	/**
-	* Get all database services keyed by compose name.
-	*/
-	getDatabases() {
-		const map = /* @__PURE__ */ new Map();
-		for (const handle of [...this.services, ...this.composeHandles]) {
-			const adapter = handle.createDatabaseAdapter();
-			if (adapter && handle.composeName) map.set(handle.composeName, adapter);
-		}
-		return map;
-	}
-	/**
-	* Get app URL from compose (e2e mode).
-	*/
-	getAppUrl() {
-		const composePath = findComposeFile(this.root);
-		if (!composePath || !this.composeStack) return null;
-		const appService = parseComposeFile(composePath).appService;
-		if (!appService || appService.ports.length === 0) return null;
-		return `http://localhost:${this.composeStack.getMappedPort(appService.name, appService.ports[0].container)}`;
-	}
-};
-//#endregion
-//#region src/spec/result/directory.ts
-const DEFAULT_IGNORES = [
-	".git",
-	".DS_Store",
-	"node_modules",
-	".next",
-	"dist",
-	".turbo",
-	".cache"
-];
-/**
-* Recursively walk a directory, returning sorted relative paths of files only.
-*/
-async function walkDirectory(root, options = {}) {
-	const ignores = new Set([...DEFAULT_IGNORES, ...options.ignore ?? []]);
-	const out = [];
-	async function walk(current) {
-		let entries;
-		try {
-			entries = await (0, node_fs_promises.readdir)(current);
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			if (ignores.has(entry)) continue;
-			const abs = (0, node_path.resolve)(current, entry);
-			const stat = (0, node_fs.statSync)(abs);
-			if (stat.isDirectory()) await walk(abs);
-			else if (stat.isFile()) out.push((0, node_path.relative)(root, abs).split(node_path.sep).join("/"));
-		}
-	}
-	await walk(root);
-	out.sort();
-	return out;
-}
-/**
-* Compare two directory trees file-by-file.
-*/
-async function diffDirectories(expectedRoot, actualRoot, options = {}) {
-	const expectedFiles = await walkDirectory(expectedRoot, options);
-	const actualFiles = await walkDirectory(actualRoot, options);
-	const expectedSet = new Set(expectedFiles);
-	const actualSet = new Set(actualFiles);
-	const added = actualFiles.filter((f) => !expectedSet.has(f));
-	const removed = expectedFiles.filter((f) => !actualSet.has(f));
-	const changed = [];
-	for (const file of expectedFiles) {
-		if (!actualSet.has(file)) continue;
-		const expected = (0, node_fs.readFileSync)((0, node_path.resolve)(expectedRoot, file), "utf8");
-		const actual = (0, node_fs.readFileSync)((0, node_path.resolve)(actualRoot, file), "utf8");
-		if (expected !== actual) changed.push({
-			actual,
-			expected,
-			path: file
-		});
-	}
-	return {
-		added,
-		changed,
-		removed
-	};
-}
-function shouldUpdateSnapshots$3() {
-	if (process.env.JTERRAZZ_TEST_UPDATE === "1") return true;
-	if (process.env.UPDATE_SNAPSHOTS === "1") return true;
-	if (process.argv.includes("-u") || process.argv.includes("--update")) return true;
-	return false;
-}
-var DirectoryAccessor = class {
-	absPath;
-	testDir;
-	constructor(absPath, testDir) {
-		this.absPath = absPath;
-		this.testDir = testDir;
-	}
-	async toMatchFixture(name, options = {}) {
-		const fixtureDir = (0, node_path.resolve)(this.testDir, "expected", name);
-		if (options.update ?? shouldUpdateSnapshots$3()) {
-			(0, node_fs.rmSync)(fixtureDir, {
-				force: true,
-				recursive: true
-			});
-			(0, node_fs.mkdirSync)(fixtureDir, { recursive: true });
-			(0, node_fs.cpSync)(this.absPath, fixtureDir, { recursive: true });
-			return;
-		}
-		if (!(0, node_fs.existsSync)(fixtureDir)) throw new Error(`Directory fixture "${name}" does not exist at ${fixtureDir}.\nRun with JTERRAZZ_TEST_UPDATE=1 (or vitest -u) to create it.`);
-		const diff = await diffDirectories(fixtureDir, this.absPath, { ignore: options.ignore });
-		if (diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0) return;
-		throw new Error(formatDirectoryDiff(name, diff, "Run with JTERRAZZ_TEST_UPDATE=1 to update the fixture."));
-	}
-	async files(options = {}) {
-		return walkDirectory(this.absPath, options);
-	}
-};
-//#endregion
-//#region src/spec/result/filesystem.ts
-function shouldUpdateSnapshots$2() {
-	if (process.env.JTERRAZZ_TEST_UPDATE === "1") return true;
-	if (process.env.UPDATE_SNAPSHOTS === "1") return true;
-	if (process.argv.includes("-u") || process.argv.includes("--update")) return true;
-	return false;
-}
-/**
-* Accessor for the whole temporary working directory used by a CLI spec.
-*
-* Generalization of {@link DirectoryAccessor} that snapshots the entire CLI
-* working directory into `<test-file-dir>/expected/filesystem/<name>/`.
-*/
-var FilesystemAccessor = class {
-	/** The absolute path of the temporary working directory. */
-	cwd;
-	testDir;
-	constructor(cwd, testDir) {
-		this.cwd = cwd;
-		this.testDir = testDir;
-	}
-	/** List all files (recursively) under the working directory, sorted. */
-	async files(options = {}) {
-		return walkDirectory(this.cwd, options);
-	}
-	/**
-	* Assert the working directory matches a convention-based fixture tree:
-	* `<test-file-dir>/expected/filesystem/<name>/`.
-	*/
-	async toMatch(name, options = {}) {
-		const fixtureDir = (0, node_path.resolve)(this.testDir, "expected", "filesystem", name);
-		if (options.update ?? shouldUpdateSnapshots$2()) {
-			(0, node_fs.rmSync)(fixtureDir, {
-				force: true,
-				recursive: true
-			});
-			(0, node_fs.mkdirSync)(fixtureDir, { recursive: true });
-			(0, node_fs.cpSync)(this.cwd, fixtureDir, { recursive: true });
-			return;
-		}
-		if (!(0, node_fs.existsSync)(fixtureDir)) throw new Error(`Filesystem fixture "${name}" does not exist at ${fixtureDir}.\nRun with JTERRAZZ_TEST_UPDATE=1 (or vitest -u) to create it.`);
-		const diff = await diffDirectories(fixtureDir, this.cwd, { ignore: options.ignore });
-		if (diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0) return;
-		throw new Error(formatDirectoryDiff(`filesystem/${name}`, diff, "Run with JTERRAZZ_TEST_UPDATE=1 to update the fixture."));
-	}
-};
-//#endregion
-//#region src/spec/result/grep.ts
-/**
-* Extract text blocks from output that contain a pattern.
-* Splits by blank lines (how linter/compiler output is structured),
-* returns only blocks matching the pattern.
-*
-* @example
-* expect(grep(result.stdout, "unused-var.ts")).toContain("no-unused-vars")
-* expect(grep(result.stdout, "valid/sorted.ts")).not.toContain("sort-imports")
-*/
-function grep(output, pattern) {
-	return output.replace(/\x1b\[[0-9;]*m/g, "").split(/\n\s*\n/).filter((block) => block.includes(pattern)).join("\n\n");
-}
-//#endregion
-//#region src/spec/result/json.ts
-function shouldUpdateSnapshots$1() {
-	if (process.env.JTERRAZZ_TEST_UPDATE === "1") return true;
-	if (process.env.UPDATE_SNAPSHOTS === "1") return true;
-	if (process.argv.includes("-u") || process.argv.includes("--update")) return true;
-	return false;
-}
-function formatJson(value) {
-	return `${JSON.stringify(value, null, 4)}\n`;
-}
-/**
-* Accessor for a JSON payload parsed from a text stream (stdout).
-*
-* Lazily parses the JSON on first use; parse errors are deferred until an
-* assertion is performed so that callers can still read the raw stream text
-* without triggering a throw.
-*
-* When a `transform` is configured on the spec runner, it is applied to the
-* raw stdout text BEFORE `JSON.parse`. This lets consumers strip ANSI codes,
-* scrub machine-specific paths, etc. before structural comparison.
-*/
-var JsonAccessor = class {
-	rawText;
-	testDir;
-	transform;
-	constructor(rawText, testDir, transform) {
-		this.rawText = rawText;
-		this.testDir = testDir;
-		this.transform = transform;
-	}
-	/** The parsed JSON value. Throws if the text is not valid JSON. */
-	get value() {
-		return this.parse();
-	}
-	/**
-	* Assert the parsed JSON deep-equals the JSON in the given file on disk.
-	*
-	* Path is resolved relative to the test file directory unless absolute.
-	* If `JTERRAZZ_TEST_UPDATE=1` (or vitest `-u`), the file is (re)written
-	* with the pretty-printed parsed value.
-	*/
-	toMatchFile(path, options = {}) {
-		const absPath = (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(this.testDir, path);
-		const update = options.update ?? shouldUpdateSnapshots$1();
-		const actual = this.parse();
-		if (update) {
-			(0, node_fs.mkdirSync)((0, node_path.dirname)(absPath), { recursive: true });
-			(0, node_fs.writeFileSync)(absPath, formatJson(actual));
-			return;
-		}
-		if (!(0, node_fs.existsSync)(absPath)) throw new Error(`JSON fixture "${path}" does not exist at ${absPath}.\nRun with JTERRAZZ_TEST_UPDATE=1 (or vitest -u) to create it.`);
-		const expected = JSON.parse((0, node_fs.readFileSync)(absPath, "utf8"));
-		if (JSON.stringify(expected) !== JSON.stringify(actual)) throw new Error(formatResponseDiff(path, expected, actual));
-	}
-	/**
-	* Assert the parsed JSON matches a convention-based fixture:
-	* `<test-file-dir>/expected/json/<name>`.
-	*
-	* The extension is part of the name and must be included by the caller —
-	* e.g. `toMatch('error.json')`, not `toMatch('error')`. Explicit extensions
-	* are clearer at the call site and remove magic from the resolution.
-	*/
-	toMatch(name, options = {}) {
-		const absPath = (0, node_path.resolve)(this.testDir, "expected", "json", name);
-		this.toMatchFile(absPath, options);
-	}
-	parse() {
-		const source = this.transform ? this.transform(this.rawText) : this.rawText;
-		try {
-			return JSON.parse(source);
-		} catch {
-			const preview = source.slice(0, 200);
-			throw new Error(`stdout is not valid JSON: ${preview}`);
-		}
-	}
-};
-//#endregion
-//#region src/spec/result/table.ts
-/** Assertion helper for verifying database table contents after a specification run. */
-var TableAssertion = class {
-	tableName;
-	db;
-	constructor(tableName, db) {
-		this.tableName = tableName;
-		this.db = db;
-	}
-	/**
-	* Assert that the table contains exactly the expected rows for the given columns.
-	*
-	* @example
-	*   await result.table("users").toMatch({
-	*     columns: ["name", "email"],
-	*     rows: [["Alice", "alice@example.com"]],
-	*   });
-	*/
-	async toMatch(expected) {
-		const actual = await this.db.query(this.tableName, expected.columns);
-		if (JSON.stringify(actual) !== JSON.stringify(expected.rows)) throw new Error(formatTableDiff(this.tableName, expected.columns, expected.rows, actual));
-	}
-	/** Assert that the table has zero rows. */
-	async toBeEmpty() {
-		const actual = await this.db.query(this.tableName, ["*"]);
-		if (actual.length !== 0) throw new Error(`Expected table "${this.tableName}" to be empty, but it has ${actual.length} rows`);
-	}
-};
-//#endregion
-//#region src/spec/result/result.ts
-/**
-* Base result - common accessors available after any action type.
-* Extended by HttpResult, CliResult, and used directly by JobResult.
-*/
-var BaseResult = class {
-	config;
-	testDir;
-	workDir;
-	constructor(options) {
-		this.config = options.config;
-		this.testDir = options.testDir;
-		this.workDir = options.workDir;
-	}
-	/** Access a directory (relative to the working directory) for snapshot assertions. */
-	directory(path = ".") {
-		return new DirectoryAccessor((0, node_path.resolve)(this.workDir ?? this.testDir, path), this.testDir);
-	}
-	/** Access a single file (relative to the working directory) for content assertions. */
-	file(path) {
-		const resolvedPath = (0, node_path.resolve)(this.workDir ?? this.testDir, path);
-		const exists = (0, node_fs.existsSync)(resolvedPath);
-		return {
-			get content() {
-				if (!exists) throw new Error(`File not found: ${path}`);
-				return (0, node_fs.readFileSync)(resolvedPath, "utf8");
-			},
-			exists
-		};
-	}
-	/** Access a database table for row-level assertions. */
-	table(tableName, options) {
-		const db = this.resolveDatabase(options?.service);
-		if (!db) throw new Error(options?.service ? `table("${tableName}") requires database "${options.service}" but it was not found` : `table("${tableName}") requires a database adapter`);
-		return new TableAssertion(tableName, db);
-	}
-	resolveDatabase(serviceName) {
-		if (serviceName && this.config.databases) return this.config.databases.get(serviceName);
-		return this.config.database;
-	}
-};
-//#endregion
-//#region src/spec/result/stream.ts
-function shouldUpdateSnapshots() {
-	if (process.env.JTERRAZZ_TEST_UPDATE === "1") return true;
-	if (process.env.UPDATE_SNAPSHOTS === "1") return true;
-	if (process.argv.includes("-u") || process.argv.includes("--update")) return true;
-	return false;
-}
-/**
-* Accessor for a captured text stream (stdout/stderr) with file-based
-* assertion support.
-*
-* Backed by a primitive string, exposed via {@link text}, but also provides
-* `toString()` / `valueOf()` for string coercion, so common patterns like
-* `String(result.stdout)` and template-literal interpolation still work.
-*/
-var StreamAccessor = class {
-	streamName;
-	testDir;
-	transform;
-	text;
-	constructor(text, streamName, testDir, transform) {
-		this.text = text;
-		this.streamName = streamName;
-		this.testDir = testDir;
-		this.transform = transform;
-	}
-	/**
-	* Assert the captured text matches the given file on disk.
-	*
-	* Path is resolved relative to the test file directory unless absolute.
-	* If `JTERRAZZ_TEST_UPDATE=1` (or vitest `-u`), the file is (re)written
-	* with the actual text.
-	*
-	* When a `transform` is configured on the spec runner, it is applied to
-	* the actual text before comparison (and before writing in update mode).
-	* The fixture file is treated as authoritative and is NOT transformed.
-	*/
-	toMatchFile(path, options = {}) {
-		const absPath = (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(this.testDir, path);
-		const update = options.update ?? shouldUpdateSnapshots();
-		const actual = this.transform ? this.transform(this.text) : this.text;
-		if (update) {
-			(0, node_fs.mkdirSync)((0, node_path.dirname)(absPath), { recursive: true });
-			(0, node_fs.writeFileSync)(absPath, actual);
-			return;
-		}
-		if (!(0, node_fs.existsSync)(absPath)) throw new Error(`${this.streamName} fixture "${path}" does not exist at ${absPath}.\nRun with JTERRAZZ_TEST_UPDATE=1 (or vitest -u) to create it.`);
-		const expected = (0, node_fs.readFileSync)(absPath, "utf8");
-		if (expected !== actual) throw new Error(formatStdoutDiff(path, expected, actual));
-	}
-	/**
-	* Assert the captured text matches a convention-based fixture:
-	* `<test-file-dir>/expected/<stream>/<name>`.
-	*
-	* The extension is part of the name and must be included by the caller —
-	* e.g. `toMatch('valid.txt')`, not `toMatch('valid')`. Explicit extensions
-	* are clearer at the call site and remove magic from the resolution.
-	*/
-	toMatch(name, options = {}) {
-		const absPath = (0, node_path.resolve)(this.testDir, "expected", this.streamName, name);
-		this.toMatchFile(absPath, options);
-	}
-	/**
-	* Assert the captured text contains the given substring. The runner's
-	* `transform` (if any) is applied before the check so callers can rely
-	* on the same normalised view as {@link toMatch}.
-	*
-	* Throws with a tight diff-style error on miss so tests read uniformly
-	* with the other accessor assertions (no reaching through `.text` into
-	* `expect(...).toContain(...)`).
-	*/
-	toContain(substring) {
-		const actual = this.transform ? this.transform(this.text) : this.text;
-		if (actual.includes(substring)) return;
-		throw new Error(`${this.streamName} does not contain expected substring.\n  expected to contain: ${JSON.stringify(substring)}\n  actual: ${JSON.stringify(actual.length > 500 ? `${actual.slice(0, 500)}…` : actual)}`);
-	}
-	toString() {
-		return this.text;
-	}
-	valueOf() {
-		return this.text;
-	}
-};
-//#endregion
-//#region src/spec/modes/cli/container-accessor.ts
-const EXEC_TIMEOUT = 1e4;
-function readInspectState(inspect) {
-	const state = inspect?.State ?? inspect?.state;
-	if (!state) return {
-		running: false,
-		status: "unknown"
-	};
-	return {
-		running: Boolean(state.Running ?? state.running ?? false),
-		status: String(state.Status ?? state.status ?? "unknown")
-	};
-}
-/**
-* Assertion accessor for a single Docker container captured by the docker()
-* spec mode. Mirrors the shape of {@link CliResult} so tests use the same
-* vocabulary (`stdout.toContain`, `file(...).content`, etc.) regardless of
-* where output came from.
-*
-* Sync state (`exists`, `running`, `status`) is derived from the `docker
-* inspect` payload captured at result-construction time. Logs are fetched
-* lazily on first access to `stdout`/`stderr`.
-*/
-var ContainerAccessor = class {
-	cachedLogs = null;
-	containerId;
-	exists;
-	inspectData;
-	running;
-	status;
-	testDir;
-	transform;
-	/**
-	* Underlying Docker container ID, or `null` if no container was captured
-	* for this name. Useful when a follow-up CLI command needs to reference
-	* the container by id (e.g. `spwn world inspect <id>`). Prefer the other
-	* accessors for common reads — pulling the raw id is the escape hatch.
-	*/
-	get id() {
-		return this.containerId;
-	}
-	constructor(containerId, inspectData, testDir, transform) {
-		this.containerId = containerId;
-		this.inspectData = inspectData;
-		this.testDir = testDir;
-		this.transform = transform;
-		this.exists = containerId !== null;
-		if (this.exists) {
-			const state = readInspectState(inspectData);
-			this.running = state.running;
-			this.status = state.status;
-		} else {
-			this.running = false;
-			this.status = "absent";
-		}
-	}
-	/**
-	* Raw `docker inspect` object for this container. Throws if the container
-	* was not captured (i.e. `.exists === false`).
-	*/
-	get inspect() {
-		this.requireExists("inspect");
-		return new JsonAccessor(JSON.stringify(this.inspectData), this.testDir, this.transform);
-	}
-	/** Captured logs (stdout+stderr combined for v1). */
-	get stdout() {
-		this.requireExists("stdout");
-		return new StreamAccessor(this.loadLogs(), "stdout", this.testDir, this.transform);
-	}
-	/** Captured logs (stdout+stderr combined for v1). */
-	get stderr() {
-		this.requireExists("stderr");
-		return new StreamAccessor(this.loadLogs(), "stderr", this.testDir, this.transform);
-	}
-	/**
-	* Read a file from inside the container via `docker exec cat`. The
-	* returned object satisfies the same {@link FileAccessor} shape used by
-	* the host filesystem accessor, so tests do not need to learn a new API.
-	*/
-	file(path) {
-		this.requireExists("file");
-		const id = this.containerId;
-		const exists = this.containerExec(id, [
-			"test",
-			"-e",
-			path
-		]).exitCode === 0;
-		return {
-			get content() {
-				if (!exists) throw new Error(`File not found in container: ${path}`);
-				return (0, node_child_process.execSync)(`docker exec ${id} cat ${JSON.stringify(path)}`, {
-					encoding: "utf8",
-					timeout: EXEC_TIMEOUT
-				});
-			},
-			exists
-		};
-	}
-	/**
-	* Run a shell command inside the container and get back the same
-	* {@link CliResult} used for host-side executions.
-	*/
-	async exec(cmd) {
-		this.requireExists("exec");
-		return new CliResult({
-			commandResult: this.containerExec(this.containerId, [
-				"sh",
-				"-c",
-				cmd
-			]),
-			config: {},
-			testDir: this.testDir,
-			transform: this.transform,
-			workDir: this.testDir
-		});
-	}
-	requireExists(member) {
-		if (!this.exists) throw new Error(`ContainerAccessor.${member}: container does not exist (check .exists first)`);
-	}
-	loadLogs() {
-		if (this.cachedLogs !== null) return this.cachedLogs;
-		try {
-			this.cachedLogs = (0, node_child_process.execSync)(`docker logs ${this.containerId}`, {
-				encoding: "utf8",
-				stdio: [
-					"ignore",
-					"pipe",
-					"pipe"
-				],
-				timeout: EXEC_TIMEOUT
-			});
-		} catch (error) {
-			this.cachedLogs = typeof error?.stdout === "string" ? error.stdout : String(error?.stderr ?? "");
-		}
-		return this.cachedLogs ?? "";
-	}
-	containerExec(id, argv) {
-		try {
-			return {
-				exitCode: 0,
-				stderr: "",
-				stdout: (0, node_child_process.execSync)(`docker exec ${id} ${argv.map((a) => JSON.stringify(a)).join(" ")}`, {
-					encoding: "utf8",
-					stdio: [
-						"ignore",
-						"pipe",
-						"pipe"
-					],
-					timeout: EXEC_TIMEOUT
-				})
-			};
-		} catch (error) {
-			return {
-				exitCode: typeof error?.status === "number" ? error.status : 1,
-				stderr: typeof error?.stderr === "string" ? error.stderr : String(error?.message ?? ""),
-				stdout: typeof error?.stdout === "string" ? error.stdout : ""
-			};
-		}
-	}
-};
-//#endregion
-//#region src/spec/modes/cli/docker-lookup.ts
-/**
-* Thin synchronous wrappers around the `docker` CLI used by the docker() spec
-* mode. Sync is deliberate — the calls are fast, run only on the host, and
-* keep the dispose path straightforward (`Symbol.asyncDispose` can still be
-* async without needing these to be).
-*/
-const DEFAULT_TIMEOUT = 1e4;
-/** Return all container IDs (running or stopped) that carry `key=value`. */
-function findContainersByLabel(key, value) {
-	try {
-		return (0, node_child_process.execSync)(`docker ps -aq -f label=${key}=${value}`, {
-			encoding: "utf8",
-			timeout: DEFAULT_TIMEOUT
-		}).split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-	} catch {
-		return [];
-	}
-}
-/** Return the raw `docker inspect` payload (object, not array) for a container. */
-function inspectContainer(id) {
-	const raw = (0, node_child_process.execSync)(`docker inspect ${id}`, {
-		encoding: "utf8",
-		timeout: DEFAULT_TIMEOUT
-	});
-	const parsed = JSON.parse(raw);
-	return Array.isArray(parsed) ? parsed[0] : parsed;
-}
-/** Force-remove the given container IDs in a single call. Errors are swallowed. */
-function removeContainers(ids) {
-	if (ids.length === 0) return;
-	try {
-		(0, node_child_process.execSync)(`docker rm -f ${ids.join(" ")}`, {
-			encoding: "utf8",
-			stdio: "pipe",
-			timeout: DEFAULT_TIMEOUT
-		});
-	} catch {}
-}
-//#endregion
-//#region src/spec/modes/cli/result.ts
-/**
-* Result from a CLI action (.exec(), .spawn()).
-*
-* When the runner was configured with a `docker` option, the result also
-* exposes container accessors and participates in `Symbol.asyncDispose`
-* cleanup. The Docker shell-outs are **lazy**: a test that never calls
-* `.container(...)` never queries the Docker daemon, so CLI-only tests
-* pay zero Docker cost even when the runner is Docker-aware.
-*
-* Dispose always runs one final label-filtered `docker ps` to catch
-* containers that were spawned during `.exec` but never asserted on —
-* tests still get leak-free cleanup even if they forget to reach into
-* a container.
-*/
-var CliResult = class extends BaseResult {
-	commandResult;
-	containersCache = null;
-	dockerConfig;
-	testRunId;
-	transform;
-	constructor(options) {
-		super(options);
-		this.commandResult = options.commandResult;
-		this.dockerConfig = options.dockerConfig;
-		this.testRunId = options.testRunId;
-		this.transform = options.transform;
-	}
-	/** The process exit code. */
-	get exitCode() {
-		return this.commandResult.exitCode;
-	}
-	/** Accessor for the captured standard output with file-based assertions. */
-	get stdout() {
-		return new StreamAccessor(this.commandResult.stdout, "stdout", this.testDir, this.transform);
-	}
-	/** Accessor for the captured standard error with file-based assertions. */
-	get stderr() {
-		return new StreamAccessor(this.commandResult.stderr, "stderr", this.testDir, this.transform);
-	}
-	/** Accessor for parsing stdout as JSON and asserting against JSON fixtures. */
-	get json() {
-		return new JsonAccessor(this.commandResult.stdout, this.testDir, this.transform);
-	}
-	/** Accessor for the temporary working directory the command ran in. */
-	get filesystem() {
-		if (!this.workDir) throw new Error("CliResult.filesystem requires a working directory");
-		return new FilesystemAccessor(this.workDir, this.testDir);
-	}
-	/**
-	* Look up a container the CLI spawned during this run by the value of
-	* its name-label (as declared in `SpecOptions.docker.nameLabel`).
-	* First access triggers a one-shot `docker ps` + `docker inspect`
-	* query and caches the result for the rest of the result's lifetime.
-	* Tests that don't call this never touch Docker.
-	*
-	* Returns an accessor with `.exists === false` when no container
-	* carries that name — callers can still assert absence without a try.
-	*/
-	container(name) {
-		this.ensureDockerAware("container");
-		this.loadContainers();
-		const captured = this.containersCache.get(name);
-		if (!captured) return new ContainerAccessor(null, null, this.testDir, this.transform);
-		return new ContainerAccessor(captured.id, captured.inspect, this.testDir, this.transform);
-	}
-	/** All captured container IDs. Triggers the same lazy query as `container()`. */
-	get containerIds() {
-		this.ensureDockerAware("containerIds");
-		this.loadContainers();
-		return [...this.containersCache.values()].map((c) => c.id);
-	}
-	async [Symbol.asyncDispose]() {
-		if (!this.dockerConfig || !this.testRunId) return;
-		removeContainers(this.containersCache !== null ? [...this.containersCache.values()].map((c) => c.id) : findContainersByLabel(this.dockerConfig.testRunLabel, this.testRunId));
-	}
-	/**
-	* Extract text blocks from stdout that contain a pattern.
-	*
-	* @example
-	*   expect(result.grep('error.ts')).toContain('no-unused-vars');
-	*/
-	grep(pattern) {
-		return grep(this.commandResult.stdout, pattern);
-	}
-	ensureDockerAware(member) {
-		if (!this.dockerConfig || !this.testRunId) throw new Error(`CliResult.${member}: runner was not configured with a docker option. Pass \`docker: { envVar, nameLabel, testRunLabel }\` in SpecOptions.`);
-	}
-	loadContainers() {
-		if (this.containersCache !== null) return;
-		const ids = findContainersByLabel(this.dockerConfig.testRunLabel, this.testRunId);
-		const map = /* @__PURE__ */ new Map();
-		for (const id of ids) {
-			let inspect;
-			try {
-				inspect = inspectContainer(id);
-			} catch {
-				continue;
-			}
-			const nameValue = (inspect?.Config?.Labels ?? inspect?.config?.labels ?? {})[this.dockerConfig.nameLabel];
-			const key = typeof nameValue === "string" && nameValue.length > 0 ? nameValue : id;
-			map.set(key, {
-				id,
-				inspect
-			});
-		}
-		this.containersCache = map;
-	}
-};
-//#endregion
-//#region src/spec/result/response.ts
-/** Accessor for an HTTP response body with file-based assertion support. */
-var ResponseAccessor = class {
-	body;
-	testDir;
-	constructor(body, testDir) {
-		this.body = body;
-		this.testDir = testDir;
-	}
-	/**
-	* Assert that the response body matches the JSON in `responses/{file}`.
-	*
-	* @example
-	*   result.response.toMatchFile("expected-items.json");
-	*/
-	toMatchFile(file) {
-		const expected = JSON.parse((0, node_fs.readFileSync)((0, node_path.resolve)(this.testDir, "responses", file), "utf8"));
-		if (JSON.stringify(this.body) !== JSON.stringify(expected)) throw new Error(formatResponseDiff(file, expected, this.body));
-	}
-};
-//#endregion
-//#region src/spec/modes/http/result.ts
-/** Result from an HTTP action (.get(), .post(), .put(), .delete()). */
-var HttpResult = class extends BaseResult {
-	responseData;
-	constructor(options) {
-		super(options);
-		this.responseData = options.response;
-	}
-	/** The HTTP response status code. */
-	get status() {
-		return this.responseData.status;
-	}
-	/** Access the HTTP response body for assertions. */
-	get response() {
-		return new ResponseAccessor(this.responseData.body, this.testDir);
-	}
-};
-//#endregion
-//#region src/spec/builder.ts
-/**
-* Fluent builder for declaring a single test specification.
-*
-* Chain setup methods ({@link seed}, {@link fixture}, {@link env}), an action
-* ({@link get}, {@link post}, {@link exec}), then call {@link run} to execute
-* and receive a {@link SpecificationResult} for assertions.
-*/
-var SpecificationBuilder = class {
-	commandArgs = null;
-	commandEnv = {};
-	config;
-	fixtures = [];
-	intercepts = [];
-	jobName = null;
-	label;
-	mocks = [];
-	projectName = null;
-	request = null;
-	requestHeaders = {};
-	seeds = [];
-	spawnConfig = null;
-	testDir;
-	constructor(config, testDir, label) {
-		this.config = config;
-		this.testDir = testDir;
-		this.label = label;
-	}
-	/**
-	* Queue a SQL seed file to run before the action.
-	*
-	* @example
-	*   spec("creates user").seed("users.sql").exec("list-users").run();
-	*/
-	seed(file, options) {
-		this.seeds.push({
-			file,
-			service: options?.service
-		});
-		return this;
-	}
-	/** Copy a file or directory from `fixtures/` into the working directory before execution. */
-	fixture(file) {
-		this.fixtures.push({ file });
-		return this;
-	}
-	/** Copy an entire project fixture from `fixturesRoot` into the working directory. */
-	project(name) {
-		this.projectName = name;
-		return this;
-	}
-	/** Register an MSW mock definition file from `mock/` to intercept HTTP calls. */
-	mock(file) {
-		this.mocks.push({ file });
-		return this;
-	}
-	/**
-	* Set environment variables for the CLI process. Merged on top of process.env.
-	* Use `null` to unset a variable. Multiple calls merge.
-	*
-	* The token `$WORKDIR` (in any value) is replaced with the actual working
-	* directory at run-time — useful for tests that need a fully isolated `HOME`.
-	*
-	* @example
-	*   spec("...").env({ HOME: "$WORKDIR", TZ: "UTC" }).exec("status").run();
-	*/
-	env(env) {
-		this.commandEnv = {
-			...this.commandEnv,
-			...env
-		};
-		return this;
-	}
-	/**
-	* Set HTTP headers for the request. Multiple calls merge.
-	*
-	* @example
-	*   spec("french").headers({ 'Accept-Language': 'fr' }).get("/articles").run();
-	*/
-	headers(headers) {
-		this.requestHeaders = {
-			...this.requestHeaders,
-			...headers
-		};
-		return this;
-	}
-	/**
-	* Intercept an outgoing HTTP request and return a controlled response.
-	* Uses MSW under the hood. Intercepts are queued — multiple calls with the
-	* same trigger fire sequentially (first match consumed first).
-	*
-	* @param trigger - What to match (use openai.agent(), http.get(), etc.)
-	* @param response - What to return: an InterceptResponse object, or a filename
-	*   from `intercepts/` (JSON loaded and auto-wrapped by the trigger).
-	*
-	* @example
-	*   // With inline response
-	*   .intercept(openai.agent({...}), openai.reply({ categories: ['TECH'] }))
-	*
-	*   // With JSON fixture file (loaded from intercepts/ directory)
-	*   .intercept(openai.agent({...}), 'ingest-tech.json')
-	*   .intercept(http.get(url), 'world-news-tech.json')
-	*/
-	intercept(trigger, response) {
-		if (typeof response === "string") {
-			const slashIndex = response.indexOf("/");
-			if (slashIndex === -1) throw new Error(`.intercept(): file path must be 'adapter/filename.json' (e.g. 'openai/ingest-tech.json'), got '${response}'`);
-			const adapterName = response.slice(0, slashIndex);
-			if (adapterName !== trigger.adapter) throw new Error(`.intercept(): adapter mismatch - trigger uses '${trigger.adapter}' but file path starts with '${adapterName}/'`);
-			const filePath = (0, node_path.resolve)(this.testDir, "intercepts", response);
-			const data = JSON.parse((0, node_fs.readFileSync)(filePath, "utf8"));
-			const resolved = trigger.wrap(data);
-			this.intercepts.push({
-				trigger,
-				response: resolved
-			});
-		} else this.intercepts.push({
-			trigger,
-			response
-		});
-		return this;
-	}
-	/**
-	* Send a GET request to the server adapter.
-	*
-	* @example
-	*   spec("list items").get("/api/items").run();
-	*/
-	get(path) {
-		this.request = {
-			method: "GET",
-			path
-		};
-		return this;
-	}
-	/**
-	* Send a POST request to the server adapter.
-	*
-	* @param bodyFile - Optional JSON file from `requests/` to use as the request body.
-	* @example
-	*   spec("create item").post("/api/items", "new-item.json").run();
-	*/
-	post(path, bodyFile) {
-		this.request = {
-			bodyFile,
-			method: "POST",
-			path
-		};
-		return this;
-	}
-	/** Send a PUT request to the server adapter. */
-	put(path, bodyFile) {
-		this.request = {
-			bodyFile,
-			method: "PUT",
-			path
-		};
-		return this;
-	}
-	/** Send a DELETE request to the server adapter. */
-	delete(path) {
-		this.request = {
-			method: "DELETE",
-			path
-		};
-		return this;
-	}
-	/**
-	* Execute a CLI command (or a sequence of commands) in an isolated working directory.
-	* When an array is passed, commands run sequentially and stop on the first non-zero exit code.
-	*
-	* @example
-	*   spec("init project").exec("init --name demo").run();
-	*   spec("multi-step").exec(["init", "build"]).run();
-	*/
-	exec(args) {
-		this.commandArgs = args;
-		return this;
-	}
-	/** Spawn a long-running CLI process with custom spawn options (e.g. timeout, signal). */
-	spawn(args, options) {
-		this.spawnConfig = {
-			args,
-			options
-		};
-		return this;
-	}
-	/**
-	* Execute a named job registered via the app() factory.
-	*
-	* @param name - The job name to trigger (must match a registered JobHandle.name).
-	*
-	* @example
-	*   spec('pipeline').intercept(openai.chat(), openai.response({...})).job('report-refresh').run();
-	*/
-	job(name) {
-		this.jobName = name;
-		return this;
-	}
-	/**
-	* Execute the specification: run seeds, copy fixtures, then perform the
-	* configured action (HTTP or CLI).
-	*
-	* @returns The result object used for assertions.
-	* @example
-	*   const result = await spec("test").exec("status").run();
-	*   expect(result.exitCode).toBe(0);
-	*/
-	async run() {
-		const hasHttpAction = this.request !== null;
-		const hasCliAction = this.commandArgs !== null || this.spawnConfig !== null;
-		const hasJobAction = this.jobName !== null;
-		const actionCount = [
-			hasHttpAction,
-			hasCliAction,
-			hasJobAction
-		].filter(Boolean).length;
-		if (actionCount === 0) throw new Error(`Specification "${this.label}": no action defined. Call .get(), .post(), .exec(), .job(), etc. before .run()`);
-		if (actionCount > 1) throw new Error(`Specification "${this.label}": cannot mix action types (.get/.post, .exec/.spawn, .job)`);
-		let workDir = null;
-		if (hasCliAction) workDir = this.prepareWorkDir();
-		if (this.config.databases) for (const db of this.config.databases.values()) await db.reset();
-		else if (this.config.database) await this.config.database.reset();
-		for (const entry of this.seeds) {
-			const handler = this.resolveSeedHandler(entry.file);
-			if (handler) {
-				if (!workDir) throw new Error(`seed("${entry.file}"): pluggable seed handlers require a CLI working directory`);
-				const fragmentPath = (0, node_path.resolve)(this.testDir, "seeds", entry.file);
-				await handler({
-					cwd: workDir,
-					testDir: this.testDir
-				}, fragmentPath);
-				continue;
-			}
-			let db;
-			if (entry.service && this.config.databases) {
-				db = this.config.databases.get(entry.service);
-				if (!db) throw new Error(`seed() targets database "${entry.service}" but it was not found. Available: ${[...this.config.databases.keys()].join(", ")}`);
-			} else db = this.config.database;
-			if (!db) throw new Error("seed() requires a database adapter");
-			const sql = (0, node_fs.readFileSync)((0, node_path.resolve)(this.testDir, "seeds", entry.file), "utf8");
-			await db.seed(sql);
-		}
-		if (this.fixtures.length > 0 && workDir) for (const entry of this.fixtures) (0, node_fs.cpSync)((0, node_path.resolve)(this.testDir, "fixtures", entry.file), (0, node_path.resolve)(workDir, entry.file), { recursive: true });
-		let cleanupIntercepts = null;
-		if (this.intercepts.length > 0) {
-			const { registerIntercepts } = await Promise.resolve().then(() => require("./intercept2.cjs"));
-			cleanupIntercepts = await registerIntercepts(this.intercepts);
-		}
-		try {
-			if (hasHttpAction) return await this.runHttpAction();
-			if (hasJobAction) return await this.runJobAction();
-			return await this.runCliAction(workDir);
-		} finally {
-			if (cleanupIntercepts) cleanupIntercepts();
-		}
-	}
-	resolveSeedHandler(file) {
-		const handlers = this.config.seedHandlers;
-		if (!handlers) return;
-		const normalized = file.replaceAll("\\", "/");
-		let bestKey;
-		for (const key of Object.keys(handlers)) {
-			const prefix = key.endsWith("/") ? key : `${key}/`;
-			if (normalized === key || normalized.startsWith(prefix)) {
-				if (!bestKey || key.length > bestKey.length) bestKey = key;
-			}
-		}
-		return bestKey ? handlers[bestKey] : void 0;
-	}
-	resolveEnv(workDir) {
-		const keys = Object.keys(this.commandEnv);
-		if (keys.length === 0) return;
-		const resolved = {};
-		for (const key of keys) {
-			const value = this.commandEnv[key];
-			resolved[key] = typeof value === "string" ? value.replace(/\$WORKDIR/g, workDir) : value;
-		}
-		return resolved;
-	}
-	prepareWorkDir() {
-		const tempDir = (0, node_fs.mkdtempSync)((0, node_path.resolve)((0, node_os.tmpdir)(), "spec-cli-"));
-		if (this.projectName && this.config.fixturesRoot) {
-			const projectDir = (0, node_path.resolve)(this.config.fixturesRoot, this.projectName);
-			if (!(0, node_fs.existsSync)(projectDir)) throw new Error(`project("${this.projectName}"): fixture project not found at ${projectDir}`);
-			(0, node_fs.cpSync)(projectDir, tempDir, { recursive: true });
-		}
-		return tempDir;
-	}
-	async runHttpAction() {
-		if (!this.config.server) throw new Error("HTTP actions require a server adapter (use integration() or e2e())");
-		let body;
-		if (this.request.bodyFile) body = JSON.parse((0, node_fs.readFileSync)((0, node_path.resolve)(this.testDir, "requests", this.request.bodyFile), "utf8"));
-		const headers = Object.keys(this.requestHeaders).length > 0 ? this.requestHeaders : void 0;
-		const response = await this.config.server.request(this.request.method, this.request.path, body, headers);
-		return new HttpResult({
-			config: this.config,
-			response,
-			testDir: this.testDir
-		});
-	}
-	async runJobAction() {
-		if (!this.config.jobs?.length) throw new Error("Job actions require jobs registered via app(() => ({ server, jobs }))");
-		const job = this.config.jobs.find((j) => j.name === this.jobName);
-		if (!job) {
-			const available = this.config.jobs.map((j) => j.name).join(", ");
-			throw new Error(`job("${this.jobName}"): not found. Available: ${available}`);
-		}
-		await job.execute();
-		return new BaseResult({
-			config: this.config,
-			testDir: this.testDir
-		});
-	}
-	async runCliAction(workDir) {
-		if (!this.config.command) throw new Error("CLI actions require a command adapter (use cli())");
-		const dockerConfig = this.config.dockerConfig;
-		const testRunId = this.config.dockerTestRunId;
-		let env = this.resolveEnv(workDir);
-		if (dockerConfig && testRunId) env = {
-			[dockerConfig.envVar]: testRunId,
-			...env
-		};
-		let commandResult;
-		if (this.spawnConfig) commandResult = await this.config.command.spawn(this.spawnConfig.args, workDir, this.spawnConfig.options, env);
-		else if (Array.isArray(this.commandArgs)) {
-			commandResult = {
-				exitCode: 0,
-				stderr: "",
-				stdout: ""
-			};
-			for (const args of this.commandArgs) {
-				commandResult = await this.config.command.exec(args, workDir, env);
-				if (commandResult.exitCode !== 0) break;
-			}
-		} else commandResult = await this.config.command.exec(this.commandArgs, workDir, env);
-		return new CliResult({
-			commandResult,
-			config: this.config,
-			dockerConfig: dockerConfig ?? void 0,
-			testDir: this.testDir,
-			testRunId: testRunId ?? void 0,
-			transform: this.config.transform,
-			workDir
-		});
-	}
-};
-function getCallerDir() {
-	const stack = (/* @__PURE__ */ new Error("caller detection")).stack;
-	if (!stack) throw new Error("Cannot detect caller directory: no stack trace");
-	const lines = stack.split("\n");
-	for (const line of lines) {
-		const match = line.match(/at\s+(?:.*?\()?(?:file:\/\/)?([^:)]+):\d+:\d+/);
-		if (!match) continue;
-		const filePath = match[1];
-		if (filePath.includes("node_modules")) continue;
-		if (filePath.includes("/src/builder/") || filePath.includes("/src/spec/")) continue;
-		return (0, node_path.resolve)(filePath, "..");
-	}
-	throw new Error("Cannot detect caller directory from stack trace");
-}
-/**
-* Create a {@link SpecificationRunner} bound to the given adapter configuration.
-* The test file directory is auto-detected from the call stack.
-*/
-function createSpecificationRunner(config) {
-	const resolved = config.dockerConfig && !config.dockerTestRunId ? {
-		...config,
-		dockerTestRunId: `t-${Math.random().toString(36).slice(2, 10)}-${Date.now().toString(36)}`
-	} : config;
-	return (label) => {
-		return new SpecificationBuilder(resolved, getCallerDir(), label);
-	};
-}
-//#endregion
-//#region src/spec/modes/cli/adapters/exec.adapter.ts
-/**
-* Build a child-process env from the parent env plus user overrides.
-* `null` overrides delete keys (e.g. `INIT_CWD: null`).
-*/
-function buildEnv(extra) {
-	const env = {
-		...process.env,
-		INIT_CWD: void 0
-	};
-	if (extra) for (const [key, value] of Object.entries(extra)) if (value === null) delete env[key];
-	else env[key] = value;
-	return env;
-}
-/**
-* Executes CLI commands via Node.js child_process.
-* Uses `spawnSync` for one-shot commands and `spawn` for long-running processes.
-* Used by the command() specification runner.
-*
-* `spawnSync` is used (over the simpler `execSync`) so stdout AND stderr are
-* captured regardless of exit code. Many CLIs follow the Unix convention of
-* writing status banners to stderr on success — `execSync` would silently
-* discard them, leaving snapshot tests with no output to assert on.
-*/
-var ExecAdapter = class {
-	command;
-	constructor(command) {
-		this.command = command;
-	}
-	async exec(args, cwd, extraEnv) {
-		const env = buildEnv(extraEnv);
-		const result = (0, node_child_process.spawnSync)(`${this.command} ${args}`, [], {
-			cwd,
-			encoding: "utf8",
-			env,
-			shell: true,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
-		return {
-			exitCode: result.status ?? 1,
-			stdout: result.stdout ?? "",
-			stderr: result.stderr ?? ""
-		};
-	}
-	async spawn(args, cwd, options, extraEnv) {
-		const env = buildEnv(extraEnv);
-		return new Promise((resolve) => {
-			let stdout = "";
-			let stderr = "";
-			let resolved = false;
-			const child = (0, node_child_process.spawn)(this.command, args.split(/\s+/).filter(Boolean), {
-				cwd,
-				env,
-				stdio: [
-					"pipe",
-					"pipe",
-					"pipe"
-				]
-			});
-			const finish = (exitCode) => {
-				if (resolved) return;
-				resolved = true;
-				child.kill("SIGTERM");
-				resolve({
-					exitCode,
-					stdout,
-					stderr
-				});
-			};
-			let patternMatched = false;
-			const checkPattern = () => {
-				if (!patternMatched && (stdout.includes(options.waitFor) || stderr.includes(options.waitFor))) {
-					patternMatched = true;
-					finish(0);
-				}
-			};
-			child.stdout?.on("data", (data) => {
-				stdout += data.toString();
-				checkPattern();
-			});
-			child.stderr?.on("data", (data) => {
-				stderr += data.toString();
-				checkPattern();
-			});
-			child.on("exit", (code) => {
-				if (!patternMatched) finish(code === 0 ? 1 : code ?? 1);
-			});
-			setTimeout(() => finish(124), options.timeout);
-		});
-	}
-};
-//#endregion
-//#region src/spec/modes/http/adapters/fetch.adapter.ts
-/**
-* Server adapter that sends real HTTP requests via the Fetch API.
-* Used by the `e2e()` specification runner to hit a live server.
-*/
-var FetchAdapter = class {
-	baseUrl;
-	constructor(url) {
-		this.baseUrl = url.replace(/\/$/, "");
-	}
-	async request(method, path, body, headers) {
-		const init = {
-			method,
-			headers: {
-				"Content-Type": "application/json",
-				...headers
-			}
-		};
-		if (body !== void 0) init.body = JSON.stringify(body);
-		const response = await fetch(`${this.baseUrl}${path}`, init);
-		const responseBody = await response.json().catch(() => null);
-		const responseHeaders = {};
-		response.headers.forEach((value, key) => {
-			responseHeaders[key] = value;
-		});
-		return {
-			status: response.status,
-			body: responseBody,
-			headers: responseHeaders
-		};
-	}
-};
-//#endregion
-//#region src/spec/modes/http/adapters/hono.adapter.ts
-/**
-* Server adapter that dispatches requests in-process through a Hono app instance.
-* Used by the `integration()` specification runner -- no network overhead.
-*/
-var HonoAdapter = class {
-	app;
-	constructor(app) {
-		this.app = app;
-	}
-	async request(method, path, body, headers) {
-		const init = {
-			method,
-			headers: {
-				"Content-Type": "application/json",
-				...headers
-			}
-		};
-		if (body !== void 0) init.body = JSON.stringify(body);
-		const response = await this.app.request(path, init);
-		const responseBody = await response.json().catch(() => null);
-		const responseHeaders = {};
-		response.headers.forEach((value, key) => {
-			responseHeaders[key] = value;
-		});
-		return {
-			status: response.status,
-			body: responseBody,
-			headers: responseHeaders
-		};
-	}
-};
-//#endregion
-//#region src/spec/resolve.ts
-/**
-* Resolve root — if relative, resolves from the caller's directory.
-*/
-function resolveProjectRoot(root) {
-	if (!root) return process.cwd();
-	if ((0, node_path.isAbsolute)(root)) return root;
-	const stack = (/* @__PURE__ */ new Error("resolve root")).stack;
-	if (stack) {
-		const lines = stack.split("\n");
-		for (const line of lines) {
-			const match = line.match(/at\s+(?:.*?\()?(?:file:\/\/)?([^:)]+):\d+:\d+/);
-			if (!match) continue;
-			const filePath = match[1];
-			if (filePath.includes("node_modules") || filePath.includes("/src/spec/")) continue;
-			return (0, node_path.resolve)(filePath, "..", root);
-		}
-	}
-	return (0, node_path.resolve)(process.cwd(), root);
-}
-/**
-* Resolve a CLI command — checks node_modules/.bin, then treats as absolute/PATH.
-*/
-function resolveCommand(command, root) {
-	if ((0, node_path.isAbsolute)(command)) return command;
-	const binPath = (0, node_path.resolve)(root, "node_modules/.bin", command);
-	if ((0, node_fs.existsSync)(binPath)) return binPath;
-	const cwdBinPath = (0, node_path.resolve)(process.cwd(), "node_modules/.bin", command);
-	if ((0, node_fs.existsSync)(cwdBinPath)) return cwdBinPath;
-	return command;
-}
-//#endregion
-//#region src/spec/spec.ts
-/**
-* Create a specification runner for the given target.
-*
-* @param target - What to test against: {@link app}, {@link stack}, or {@link command}.
-* @param options - Shared options: root directory, infrastructure services.
-*
-* @example
-*   // HTTP — in-process app with testcontainers
-*   const s = await spec(app(() => createApp(db)), { services: [db] });
-*
-*   // HTTP — full docker compose stack
-*   const s = await spec(stack('../../'));
-*
-*   // CLI — command binary
-*   const s = await spec(command('my-cli'), { root: '../fixtures' });
-*/
-async function spec(target, options = {}) {
-	switch (target.kind) {
-		case "app": return startApp(target, options);
-		case "stack": return startStack(target, options);
-		case "command": return startCommand(target, options);
-	}
-}
-function getWorkerId() {
-	return process.env.VITEST_POOL_ID ?? "0";
-}
-async function acquireIsolation(services) {
-	const workerId = getWorkerId();
-	for (const service of services) await service.isolation().acquire(workerId);
-}
-async function releaseIsolation(services) {
-	for (const service of services) await service.isolation().release();
-}
-async function startApp(target, options) {
-	const services = options.services ?? [];
-	const orchestrator = new Orchestrator({
-		mode: "integration",
-		root: resolveProjectRoot(options.root),
-		services
-	});
-	await orchestrator.start();
-	await acquireIsolation(services);
-	const servicesMap = {};
-	for (const svc of services) {
-		const key = svc.composeName ?? svc.type;
-		servicesMap[key] = svc;
-	}
-	const factoryResult = target.factory(servicesMap);
-	const isComposite = Array.isArray(factoryResult.jobs);
-	const honoApp = isComposite ? factoryResult.server : factoryResult;
-	const jobs = isComposite ? factoryResult.jobs : void 0;
-	const database = orchestrator.getDatabase() ?? void 0;
-	const databases = orchestrator.getDatabases();
-	const runner = createSpecificationRunner({
-		database,
-		databases: databases.size > 0 ? databases : void 0,
-		jobs,
-		server: new HonoAdapter(honoApp)
-	});
-	runner.cleanup = async () => {
-		await releaseIsolation(services);
-		await orchestrator.stop();
-	};
-	runner.docker = (id) => new DockerAssertion(dockerContainer(id));
-	runner.orchestrator = orchestrator;
-	return runner;
-}
-async function startStack(target, options) {
-	const root = resolveProjectRoot(target.root ?? options.root);
-	const projectName = `test-worker-${getWorkerId()}`;
-	const orchestrator = new Orchestrator({
-		mode: "e2e",
-		root,
-		services: options.services ?? [],
-		projectName
-	});
-	await orchestrator.startCompose();
-	const appUrl = orchestrator.getAppUrl();
-	if (!appUrl) throw new Error("stack(): could not detect app URL from compose. Ensure an app service with ports is defined.");
-	const database = orchestrator.getDatabase() ?? void 0;
-	const databases = orchestrator.getDatabases();
-	const runner = createSpecificationRunner({
-		database,
-		databases: databases.size > 0 ? databases : void 0,
-		server: new FetchAdapter(appUrl)
-	});
-	runner.cleanup = () => orchestrator.stopCompose();
-	runner.docker = (id) => new DockerAssertion(dockerContainer(id));
-	runner.orchestrator = orchestrator;
-	return runner;
-}
-async function startCommand(target, options) {
-	const root = resolveProjectRoot(options.root);
-	const bin = resolveCommand(target.bin, root);
-	const services = options.services ?? [];
-	let orchestrator = null;
-	let database;
-	let databases;
-	if (services.length) {
-		orchestrator = new Orchestrator({
-			mode: "integration",
-			root,
-			services
-		});
-		await orchestrator.start();
-		await acquireIsolation(services);
-		database = orchestrator.getDatabase() ?? void 0;
-		const dbMap = orchestrator.getDatabases();
-		databases = dbMap.size > 0 ? dbMap : void 0;
-	}
-	const runner = createSpecificationRunner({
-		command: new ExecAdapter(bin),
-		database,
-		databases,
-		dockerConfig: options.docker,
-		fixturesRoot: root,
-		seedHandlers: options.seedHandlers,
-		transform: options.transform
-	});
-	runner.cleanup = async () => {
-		await releaseIsolation(services);
-		if (orchestrator) await orchestrator.stop();
-	};
-	runner.docker = (id) => new DockerAssertion(dockerContainer(id));
-	runner.orchestrator = orchestrator;
-	return runner;
-}
-//#endregion
-//#region src/spec/targets.ts
-/**
-* Test against an in-process Hono app. The factory receives started services
-* so you can wire connection strings into your app/DI container.
-*
-* @param factory - Function that receives services and returns a Hono app instance.
-*
-* @example
-*   const db = postgres({ compose: 'db' });
-*   await spec(
-*       app((services) => createApp({ databaseUrl: services.db.connectionString })),
-*       { services: [db] },
-*   );
-*/
-function app(factory) {
-	return {
-		kind: "app",
-		factory
-	};
-}
-/**
-* Test against a full docker compose stack. The stack is started with
-* `docker compose up` and real HTTP requests are sent to the app service.
-*
-* @param root - Project root containing `docker/compose.test.yaml`.
-*
-* @example
-*   await spec(stack('../../'));
-*/
-function stack(root) {
-	return {
-		kind: "stack",
-		root
-	};
-}
-/**
-* Test a CLI binary. Each spec runs in a fresh temp directory.
-*
-* Pass a `docker: { envVar, nameLabel, testRunLabel }` option on
-* {@link SpecOptions} to make the runner Docker-aware — the runner
-* stamps a unique test-run id into `envVar`, and results expose
-* `.container(name)` accessors that lazily query Docker. Tests that
-* never call `.container(...)` pay zero Docker cost.
-*
-* @param bin - Path to the CLI binary or command name (resolved from node_modules/.bin or PATH).
-*
-* @example
-*   // CLI-only
-*   await spec(command('my-cli'), { root: '../fixtures' });
-*
-*   // CLI binary that also spawns containers — same runner, just
-*   // opt into container accessors via the docker option:
-*   await spec(command('my-cli'), {
-*       root: '../fixtures',
-*       docker: {
-*           envVar: 'MYCLI_TEST_LABEL',
-*           nameLabel: 'com.mycli.world.name',
-*           testRunLabel: 'com.mycli.test.run',
-*       },
-*   });
-*/
-function command(bin) {
-	return {
-		kind: "command",
-		bin
-	};
-}
-//#endregion
-exports.BaseResult = BaseResult;
-exports.CliResult = CliResult;
-exports.ContainerAccessor = ContainerAccessor;
-exports.DirectoryAccessor = DirectoryAccessor;
-exports.DockerAssertion = DockerAssertion;
-exports.ExecAdapter = ExecAdapter;
-exports.FetchAdapter = FetchAdapter;
-exports.FilesystemAccessor = FilesystemAccessor;
-exports.HonoAdapter = HonoAdapter;
-exports.HttpResult = HttpResult;
-exports.JsonAccessor = JsonAccessor;
-exports.Orchestrator = Orchestrator;
-exports.ResponseAccessor = ResponseAccessor;
-exports.SpecificationBuilder = SpecificationBuilder;
-exports.StreamAccessor = StreamAccessor;
-exports.TableAssertion = TableAssertion;
-exports.app = app;
-exports.command = command;
-exports.createSpecificationRunner = createSpecificationRunner;
-exports.dockerContainer = dockerContainer;
-exports.findContainersByLabel = findContainersByLabel;
-exports.inspectContainer = inspectContainer;
-exports.mockOf = require_mock_of.mockOf;
-exports.mockOfDate = require_mock_of.mockOfDate;
-exports.postgres = require_sqlite.postgres;
-exports.redis = require_sqlite.redis;
-exports.removeContainers = removeContainers;
-exports.spec = spec;
-exports.sqlite = require_sqlite.sqlite;
-exports.stack = stack;
-
-//# sourceMappingURL=index.cjs.map