@jterrazz/test 14.3.0 → 15.1.0

package/dist/artifacts.js

@@ -4,9 +4,271 @@ import { cpSync, existsSync, readFileSync, realpathSync, statSync, writeFileSync
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { execSync, spawn } from "node:child_process";
 import { readdir } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
 import { createServer } from "node:net";
-//#region src/core/matching/structural.ts
+//#region src/specification/facets/_common/caller.ts
+/** Sibling module tests are callers, not internals (CONVENTIONS I2). */
+const TEST_FILE = /\.test\.[cm]?[jt]s$/u;
+/** Where this very module sits inside the framework's SOURCE tree. */
+const SOURCE_LOCATION = join("specification", "facets", "_common");
+/** The real path of `path`, or `path` itself when it cannot be resolved. */
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+/**
+* Directory of the running framework module itself. From the built package
+* this is `<package root>/dist`, whatever the resolution path — including a
+* `file:` link, where the real path carries neither `node_modules` nor
+* `/src/…` and would otherwise be mistaken for a caller frame.
+*/
+const FRAMEWORK_DIR = realPath(import.meta.dirname);
+/**
+* The directory holding the framework's OWN modules: `<package>/dist` for a
+* built install (everything is bundled there), `<repo>/src` when the framework
+* runs from source — this module's known location inside that tree is what
+* tells the two apart.
+*/
+const FRAMEWORK_TREE = FRAMEWORK_DIR.endsWith(`${sep}${SOURCE_LOCATION}`) ? resolve(FRAMEWORK_DIR, "../../..") : FRAMEWORK_DIR;
+/** Is `path` inside `directory` (strictly — a directory is not inside itself)? */
+function isInside(directory, path) {
+	const rest = relative(directory, path);
+	return rest !== "" && !rest.startsWith("..") && !isAbsolute(rest);
+}
+/**
+* Is this stack frame a module of the framework itself, rather than of the code
+* calling it?
+*
+* Answered by IDENTITY: the frame is inside the framework's own directory.
+* Answering it by substring — `/src/core/`, `/src/integrations/`, `/src/vitest/`
+* — was answering a different question, "does this path look like the framework's
+* layout", and a consumer that happens to have its own `src/core/` matched it.
+* Its files were then skipped as framework internals, and fixture resolution
+* anchored on the wrong directory (or fell through to the cwd) with nothing
+* reported.
+*
+* @internal
+*/
+function isFrameworkFrame(filePath, frameworkTree = FRAMEWORK_TREE) {
+	if (TEST_FILE.test(filePath)) return false;
+	return isInside(realPath(frameworkTree), realPath(filePath));
+}
+/**
+* Detect the directory of the first stack frame that lives outside this
+* package. Used to anchor fixture resolution (`_seeds/`, `_requests/`,
+* `_expected/`, …) on the calling test / specification file.
+*
+* @internal
+*/
+function getCallerDir() {
+	const { stack } = /* @__PURE__ */ new Error("caller detection");
+	if (!stack) throw new Error("Cannot detect caller directory: no stack trace");
+	const lines = stack.split("\n");
+	for (const line of lines) {
+		const match = /at\s+(?:.*?\()?(?:file:\/\/)?(?<filePath>[^:)]+):\d+:\d+/u.exec(line);
+		if (!match?.groups?.filePath) continue;
+		const { filePath } = match.groups;
+		if (filePath.includes("node_modules")) continue;
+		if (isFrameworkFrame(filePath)) continue;
+		return resolve(filePath, "..");
+	}
+	return process.cwd();
+}
+//#endregion
+//#region src/specification/facets/_common/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.replaceAll(/\u001B\[[0-9;]*m/gu, "").split(/\n\s*\n/u).filter((block) => block.includes(pattern)).join("\n\n");
+}
+//#endregion
+//#region src/specification/facets/_common/result/text.ts
+const ANSI_RE = /\u001B\[[0-9;]*m/gu;
+/** Strip ANSI escape sequences from a string. */
+function stripAnsiCodes(value) {
+	return value.replace(ANSI_RE, "");
+}
+/**
+* Read-only accessor for a captured text handle — THE universal one: stdout,
+* stderr, container logs, and file text all surface as a `TextAccessor`.
+*
+* 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.
+*
+* ANSI escape sequences are stripped by default before every comparison
+* (CONVENTIONS D6) — `.text` stays raw. The runner `transform` option remains
+* an escape hatch for application noise not covered by the `{{token}}`
+* grammar.
+*
+* Text operations are **closed** over the type: `.grep(pattern)` returns a
+* `TextAccessor` (not a bare string), preserving the `_expected/`-resolution
+* context and the `transform`, so results are chainable
+* (`result.stdout.grep(a).grep(b)`) and snapshot-able
+* (`expect(result.stdout.grep('users.ts')).toMatch('block.txt')`).
+*
+* Assertions go through `expect()` matchers: `expect(result.stdout).toContain(...)`
+* and `expect(result.stdout).toMatch('name.txt')` (resolved against
+* `_expected/<name>`, flat — with `{{token}}` support, CONVENTIONS D4).
+*/
+var TextAccessor = class TextAccessor {
+	/** @internal Ref-capture scope shared by the current spec execution. */
+	captures;
+	/** @internal Stream label used in failure messages ("stdout" / "stderr"). */
+	streamName;
+	/** @internal Test-file directory — fixture resolution root for matchers. */
+	testDir;
+	/** The raw captured text (never transformed, ANSI preserved). */
+	text;
+	/** @internal Normaliser applied before comparisons, never to fixtures. */
+	transform;
+	constructor(value, streamName, testDir, options = {}) {
+		this.text = value;
+		this.streamName = streamName;
+		this.testDir = testDir;
+		this.transform = options.transform;
+		this.captures = options.captures ?? new CaptureScope();
+	}
+	/** @internal The text as compared by matchers — ANSI stripped, transform applied. */
+	get comparableText() {
+		const stripped = stripAnsiCodes(this.text);
+		return this.transform ? this.transform(stripped) : stripped;
+	}
+	/**
+	* Keep only the blank-line-separated blocks of the text that contain
+	* `pattern` (how linter/compiler output is structured), returned as a new
+	* `TextAccessor` — the same subject type, so the result is chainable and
+	* snapshot-able. The scalpel for probing large tool outputs; snapshot the
+	* whole surface by default, reach for `.grep()` for targeted checks.
+	*/
+	grep(pattern) {
+		return new TextAccessor(grep(this.text, pattern), this.streamName, this.testDir, {
+			captures: this.captures,
+			transform: this.transform
+		});
+	}
+	toString() {
+		return this.text;
+	}
+	valueOf() {
+		return this.text;
+	}
+};
+/**
+* Wrap an arbitrary string into a {@link TextAccessor} anchored on the calling
+* test's directory — the same caller-detection the builders use.
+*
+* The product surface of a test framework is its own error messages, checker
+* output, and reports; those deserve the same goldening as any other output.
+* `text()` makes an ad-hoc string a first-class snapshot subject:
+*
+* ```typescript
+* const message = await catchMessage(() => expect(result.response).toMatch('wrong-body.http'));
+* expect(text(message)).toMatch('wrong-body-error.txt'); // resolves to _expected/
+* ```
+*
+* ANSI is stripped before every comparison (the raw form stays on `.text`),
+* the `{{token}}` grammar applies to the fixture, and `.grep()` composition
+* works exactly as on any stream accessor.
+*/
+function text(value) {
+	return new TextAccessor(value, "text", getCallerDir());
+}
+//#endregion
+//#region src/specification/facets/_common/result/json.ts
+/**
+* Read-only accessor for a JSON payload parsed from a text stream (stdout).
+*
+* Lazily parses the JSON on first use; parse errors are deferred until the
+* value is read so that callers can still read the raw stream text without
+* triggering a throw.
+*
+* ANSI escape sequences are stripped by default before `JSON.parse`
+* (CONVENTIONS D6). When a `transform` is configured on the spec runner, it
+* runs on the stripped text — an escape hatch for application noise not
+* covered by the `{{token}}` grammar.
+*
+* Assertions go through `expect()`: `expect(result.json).toMatch('name.json')`
+* (deep-equal against `_expected/<name>`, with `{{placeholder}}` support).
+*/
+var JsonAccessor = class {
+	/** @internal Ref-capture scope shared by the current spec execution. */
+	captures;
+	/** @internal */
+	rawText;
+	/** @internal Test-file directory — fixture resolution root for matchers. */
+	testDir;
+	/** @internal */
+	transform;
+	constructor(rawText, testDir, transform, captures) {
+		this.rawText = rawText;
+		this.testDir = testDir;
+		this.transform = transform;
+		this.captures = captures ?? new CaptureScope();
+	}
+	/** The parsed JSON value. Throws if the text is not valid JSON. */
+	get value() {
+		const stripped = stripAnsiCodes(this.rawText);
+		const source = this.transform ? this.transform(stripped) : stripped;
+		try {
+			return JSON.parse(source);
+		} catch {
+			const preview = source.slice(0, 200);
+			throw new Error(`stdout is not valid JSON: ${preview}`);
+		}
+	}
+};
+//#endregion
+//#region src/integrations/docker/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 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 = 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 {
+		execSync(`docker rm -f ${ids.join(" ")}`, {
+			encoding: "utf8",
+			stdio: "pipe",
+			timeout: DEFAULT_TIMEOUT
+		});
+	} catch {}
+}
+//#endregion
+//#region src/specification/matching/structural.ts
 /**
 * Structural comparison engine shared by every fixture matcher.
 *
@@ -59,9 +321,9 @@ const EMBEDDED_SOURCES = {
 	url: URL_SOURCE,
 	uuid: UUID_SOURCE
 };
-const wholeRe = (source) => new RegExp(`^(?:${source})$`);
+const wholeRe = (source) => new RegExp(`^(?:${source})$`, "u");
 const WHOLE_RES = Object.fromEntries(Object.entries(EMBEDDED_SOURCES).map(([kind, source]) => [kind, wholeRe(source)]));
-const PLACEHOLDER_RE = new RegExp(String.raw`\{\{(?<kind>${[...TOKEN_KINDS].sort((a, b) => b.length - a.length).join("|")})(?:#(?<ref>[\w.-]+))?\}\}`, "g");
+const PLACEHOLDER_RE = new RegExp(String.raw`\{\{(?<kind>${[...TOKEN_KINDS].sort((a, b) => b.length - a.length).join("|")})(?:#(?<ref>[\w.-]+))?\}\}`, "gu");
 /** Whether a fixture string contains at least one `{{placeholder}}`. */
 function hasPlaceholders(value) {
 	PLACEHOLDER_RE.lastIndex = 0;
@@ -126,7 +388,7 @@ function placeholderSource(kind, scope) {
 	return kind === "any" ? String.raw`[\s\S]*?` : String.raw`[^\n]*?`;
 }
 function escapeRegExp(text) {
-	return text.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+	return text.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
 }
 function parsePlaceholderString(expected, scope) {
 	PLACEHOLDER_RE.lastIndex = 0;
@@ -137,7 +399,7 @@ function parsePlaceholderString(expected, scope) {
 	let count = 0;
 	for (const found of expected.matchAll(PLACEHOLDER_RE)) {
 		const kind = found.groups.kind;
-		const ref = found.groups.ref;
+		const { ref } = found.groups;
 		source += escapeRegExp(expected.slice(lastIndex, found.index));
 		source += `(${placeholderSource(kind, scope)})`;
 		refs.push({
@@ -154,7 +416,7 @@ function parsePlaceholderString(expected, scope) {
 	}
 	source += escapeRegExp(expected.slice(lastIndex));
 	return {
-		pattern: new RegExp(`^${source}$`),
+		pattern: new RegExp(`^${source}$`, "u"),
 		refs,
 		single,
 		source
@@ -248,7 +510,7 @@ function textEquals(expected, actual, scope) {
 function textContains(expected, actual, scope) {
 	if (!hasPlaceholders(expected)) return actual.includes(expected);
 	const parsed = parsePlaceholderString(expected, scope);
-	const found = new RegExp(parsed.source).exec(actual);
+	const found = new RegExp(parsed.source, "u").exec(actual);
 	if (!found) return false;
 	return parsed.refs.every((entry) => !entry.ref || recordRef(entry.ref, found[entry.index + 1], scope));
 }
@@ -322,6 +584,7 @@ function mergeTextPreservingPlaceholders(previous, actual, scope) {
 		const prev = prevLines[prevIndex];
 		if (prev === void 0 || !hasPlaceholders(prev)) return false;
 		const line = actualLines[actualIndex];
+		if (line === void 0) return false;
 		return textEquals(prev, line, new CaptureScope(scope.workdir)) || textEquals(prev, rawLines[actualIndex] ?? line, new CaptureScope(scope.workdir));
 	};
 	const merged = actualLines.map(() => void 0);
@@ -342,187 +605,7 @@ function mergeTextPreservingPlaceholders(previous, actual, scope) {
 	return merged.join("\n");
 }
 //#endregion
-//#region src/core/specification/shared/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");
-}
-const strictEquals = (expected, actual) => expected === actual;
-function renderLines(expectedLines, actualLines, equals) {
-	const rendered = [];
-	let marked = 0;
-	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 !== void 0 && act !== void 0 && equals(exp, act)) {
-			rendered.push(`  ${exp}`);
-			continue;
-		}
-		marked++;
-		if (exp !== void 0) rendered.push(`${GREEN}- ${exp}${RESET}`);
-		if (act !== void 0) rendered.push(`${RED}+ ${act}${RESET}`);
-	}
-	return {
-		marked,
-		rendered
-	};
-}
-/**
-* Render an expected/received diff over two texts.
-*
-* `equals` is how a line is judged EQUAL. Callers that compare through the
-* `{{token}}` grammar pass a token-aware predicate, so a `{{url}}` line that
-* matched is shown as equal — with its token, not as a `-`/`+` pair against
-* the concrete URL. Marking a line the comparison ACCEPTED buries the one it
-* rejected: the reader then has to work out which of the differences is the
-* actual cause.
-*
-* Safety net: if the token-aware pass marks nothing at all, the whole diff
-* would render as a clean block against a failure that really happened (a
-* `#ref` captured inconsistently across lines, say). The strict rendering is
-* used instead, so a diff always shows the reader something.
-*/
-function formatStdoutDiff(file, expected, actual, options) {
-	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 equals = options?.equals ?? strictEquals;
-	const first = renderLines(expectedLines, actualLines, equals);
-	const rendered = first.marked === 0 && equals !== strictEquals ? renderLines(expectedLines, actualLines, strictEquals).rendered : first.rendered;
-	return [...lines, ...rendered].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/core/specification/shared/result/directory.ts
+//#region src/specification/facets/_common/result/directory.ts
 const DEFAULT_IGNORES = [
 	".git",
 	".DS_Store",
@@ -599,340 +682,47 @@ var DirectoryAccessor = class {
 	captures;
 	/** @internal Absolute path of the directory under assertion. */
 	root;
-	/** @internal Test-file directory — fixture resolution root for matchers. */
-	testDir;
-	constructor(absPath, testDir, captures) {
-		this.root = absPath;
-		this.testDir = testDir;
-		this.captures = captures ?? new CaptureScope();
-	}
-	/** List all files (recursively) under the directory, sorted. */
-	async files(options = {}) {
-		return walkDirectory(this.root, options);
-	}
-};
-//#endregion
-//#region src/core/specification/shared/result/filesystem.ts
-/**
-* Read-only accessor for the whole temporary working directory used by a
-* command spec.
-*
-* Assertions go through `expect()` (async — they walk the disk):
-* `await expect(result.filesystem).toMatch('scaffolded')` compares the
-* tree against the fixture directory `_expected/<name>/`.
-*/
-var FilesystemAccessor = class {
-	/** @internal Ref-capture scope shared by the current spec execution. */
-	captures;
-	/** The absolute path of the temporary working directory. */
-	cwd;
-	/** @internal Test-file directory — fixture resolution root for matchers. */
-	testDir;
-	constructor(cwd, testDir, captures) {
-		this.cwd = cwd;
-		this.testDir = testDir;
-		this.captures = captures ?? new CaptureScope();
-	}
-	/** List all files (recursively) under the working directory, sorted. */
-	async files(options = {}) {
-		return walkDirectory(this.cwd, options);
-	}
-};
-//#endregion
-//#region src/core/specification/shared/caller.ts
-/** Sibling module tests are callers, not internals (CONVENTIONS I2). */
-const TEST_FILE = /\.test\.[cm]?[jt]s$/;
-/** Where this very module sits inside the framework's SOURCE tree. */
-const SOURCE_LOCATION = join("core", "specification", "shared");
-/** The real path of `path`, or `path` itself when it cannot be resolved. */
-function realPath(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
-	}
-}
-/**
-* Directory of the running framework module itself. From the built package
-* this is `<package root>/dist`, whatever the resolution path — including a
-* `file:` link, where the real path carries neither `node_modules` nor
-* `/src/…` and would otherwise be mistaken for a caller frame.
-*/
-const FRAMEWORK_DIR = realPath(dirname(fileURLToPath(import.meta.url)));
-/**
-* The directory holding the framework's OWN modules: `<package>/dist` for a
-* built install (everything is bundled there), `<repo>/src` when the framework
-* runs from source — this module's known location inside that tree is what
-* tells the two apart.
-*/
-const FRAMEWORK_TREE = FRAMEWORK_DIR.endsWith(`${sep}${SOURCE_LOCATION}`) ? resolve(FRAMEWORK_DIR, "../../..") : FRAMEWORK_DIR;
-/** Is `path` inside `directory` (strictly — a directory is not inside itself)? */
-function isInside(directory, path) {
-	const rest = relative(directory, path);
-	return rest !== "" && !rest.startsWith("..") && !isAbsolute(rest);
-}
-/**
-* Is this stack frame a module of the framework itself, rather than of the code
-* calling it?
-*
-* Answered by IDENTITY: the frame is inside the framework's own directory.
-* Answering it by substring — `/src/core/`, `/src/integrations/`, `/src/vitest/`
-* — was answering a different question, "does this path look like the framework's
-* layout", and a consumer that happens to have its own `src/core/` matched it.
-* Its files were then skipped as framework internals, and fixture resolution
-* anchored on the wrong directory (or fell through to the cwd) with nothing
-* reported.
-*
-* @internal
-*/
-function isFrameworkFrame(filePath, frameworkTree = FRAMEWORK_TREE) {
-	if (TEST_FILE.test(filePath)) return false;
-	return isInside(realPath(frameworkTree), realPath(filePath));
-}
-/**
-* Detect the directory of the first stack frame that lives outside this
-* package. Used to anchor fixture resolution (`_seeds/`, `_requests/`,
-* `_expected/`, …) on the calling test / specification file.
-*
-* @internal
-*/
-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:\/\/)?(?<filePath>[^:)]+):\d+:\d+/);
-		if (!match?.groups?.filePath) continue;
-		const filePath = match.groups.filePath;
-		if (filePath.includes("node_modules")) continue;
-		if (isFrameworkFrame(filePath)) continue;
-		return resolve(filePath, "..");
-	}
-	return process.cwd();
-}
-//#endregion
-//#region src/core/specification/shared/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/core/specification/shared/result/text.ts
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-/** Strip ANSI escape sequences from a string. */
-function stripAnsiCodes(value) {
-	return value.replace(ANSI_RE, "");
-}
-/**
-* Read-only accessor for a captured text handle — THE universal one: stdout,
-* stderr, container logs, and file text all surface as a `TextAccessor`.
-*
-* 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.
-*
-* ANSI escape sequences are stripped by default before every comparison
-* (CONVENTIONS D6) — `.text` stays raw. The runner `transform` option remains
-* an escape hatch for application noise not covered by the `{{token}}`
-* grammar.
-*
-* Text operations are **closed** over the type: `.grep(pattern)` returns a
-* `TextAccessor` (not a bare string), preserving the `_expected/`-resolution
-* context and the `transform`, so results are chainable
-* (`result.stdout.grep(a).grep(b)`) and snapshot-able
-* (`expect(result.stdout.grep('users.ts')).toMatch('block.txt')`).
-*
-* Assertions go through `expect()` matchers: `expect(result.stdout).toContain(...)`
-* and `expect(result.stdout).toMatch('name.txt')` (resolved against
-* `_expected/<name>`, flat — with `{{token}}` support, CONVENTIONS D4).
-*/
-var TextAccessor = class TextAccessor {
-	/** @internal Ref-capture scope shared by the current spec execution. */
-	captures;
-	/** @internal Stream label used in failure messages ("stdout" / "stderr"). */
-	streamName;
-	/** @internal Test-file directory — fixture resolution root for matchers. */
-	testDir;
-	/** The raw captured text (never transformed, ANSI preserved). */
-	text;
-	/** @internal Normaliser applied before comparisons, never to fixtures. */
-	transform;
-	constructor(value, streamName, testDir, options = {}) {
-		this.text = value;
-		this.streamName = streamName;
-		this.testDir = testDir;
-		this.transform = options.transform;
-		this.captures = options.captures ?? new CaptureScope();
-	}
-	/** @internal The text as compared by matchers — ANSI stripped, transform applied. */
-	get comparableText() {
-		const stripped = stripAnsiCodes(this.text);
-		return this.transform ? this.transform(stripped) : stripped;
-	}
-	/**
-	* Keep only the blank-line-separated blocks of the text that contain
-	* `pattern` (how linter/compiler output is structured), returned as a new
-	* `TextAccessor` — the same subject type, so the result is chainable and
-	* snapshot-able. The scalpel for probing large tool outputs; snapshot the
-	* whole surface by default, reach for `.grep()` for targeted checks.
-	*/
-	grep(pattern) {
-		return new TextAccessor(grep(this.text, pattern), this.streamName, this.testDir, {
-			captures: this.captures,
-			transform: this.transform
-		});
-	}
-	toString() {
-		return this.text;
-	}
-	valueOf() {
-		return this.text;
-	}
-};
-/**
-* Wrap an arbitrary string into a {@link TextAccessor} anchored on the calling
-* test's directory — the same caller-detection the builders use.
-*
-* The product surface of a test framework is its own error messages, checker
-* output, and reports; those deserve the same goldening as any other output.
-* `text()` makes an ad-hoc string a first-class snapshot subject:
-*
-* ```typescript
-* const message = await catchMessage(() => expect(result.response).toMatch('wrong-body.http'));
-* expect(text(message)).toMatch('wrong-body-error.txt'); // resolves to _expected/
-* ```
-*
-* ANSI is stripped before every comparison (the raw form stays on `.text`),
-* the `{{token}}` grammar applies to the fixture, and `.grep()` composition
-* works exactly as on any stream accessor.
-*/
-function text(value) {
-	return new TextAccessor(value, "text", getCallerDir());
-}
-//#endregion
-//#region src/core/specification/shared/result/json.ts
-/**
-* Read-only accessor for a JSON payload parsed from a text stream (stdout).
-*
-* Lazily parses the JSON on first use; parse errors are deferred until the
-* value is read so that callers can still read the raw stream text without
-* triggering a throw.
-*
-* ANSI escape sequences are stripped by default before `JSON.parse`
-* (CONVENTIONS D6). When a `transform` is configured on the spec runner, it
-* runs on the stripped text — an escape hatch for application noise not
-* covered by the `{{token}}` grammar.
-*
-* Assertions go through `expect()`: `expect(result.json).toMatch('name.json')`
-* (deep-equal against `_expected/<name>`, with `{{placeholder}}` support).
-*/
-var JsonAccessor = class {
-	/** @internal Ref-capture scope shared by the current spec execution. */
-	captures;
-	/** @internal */
-	rawText;
-	/** @internal Test-file directory — fixture resolution root for matchers. */
-	testDir;
-	/** @internal */
-	transform;
-	constructor(rawText, testDir, transform, captures) {
-		this.rawText = rawText;
-		this.testDir = testDir;
-		this.transform = transform;
-		this.captures = captures ?? new CaptureScope();
-	}
-	/** The parsed JSON value. Throws if the text is not valid JSON. */
-	get value() {
-		const stripped = stripAnsiCodes(this.rawText);
-		const source = this.transform ? this.transform(stripped) : stripped;
-		try {
-			return JSON.parse(source);
-		} catch {
-			const preview = source.slice(0, 200);
-			throw new Error(`stdout is not valid JSON: ${preview}`);
-		}
+	/** @internal Test-file directory — fixture resolution root for matchers. */
+	testDir;
+	constructor(absPath, testDir, captures) {
+		this.root = absPath;
+		this.testDir = testDir;
+		this.captures = captures ?? new CaptureScope();
+	}
+	/** List all files (recursively) under the directory, sorted. */
+	async files(options = {}) {
+		return await walkDirectory(this.root, options);
 	}
 };
 //#endregion
-//#region src/core/specification/shared/result/table.ts
+//#region src/specification/facets/_common/result/filesystem.ts
 /**
-* Read-only accessor for a database table after a specification run.
-*
-* Assertions go through `expect()` (async — they query the database):
+* Read-only accessor for the whole temporary working directory used by a
+* command spec.
 *
-*     await expect(result.table('users', { database: 'db' })).toMatchRows({
-*         columns: ['name'],
-*         rows: [['Alice']],
-*     });
-*     await expect(result.table('users', { database: 'db' })).toBeEmpty();
+* Assertions go through `expect()` (async — they walk the disk):
+* `await expect(result.filesystem).toMatch('scaffolded')` compares the
+* tree against the fixture directory `_expected/<name>/`.
 */
-var TableAccessor = class {
+var FilesystemAccessor = class {
 	/** @internal Ref-capture scope shared by the current spec execution. */
 	captures;
-	/** @internal */
-	db;
-	/** The table name this accessor reads. */
-	name;
-	constructor(name, db, captures) {
-		this.name = name;
-		this.db = db;
+	/** The absolute path of the temporary working directory. */
+	cwd;
+	/** @internal Test-file directory — fixture resolution root for matchers. */
+	testDir;
+	constructor(cwd, testDir, captures) {
+		this.cwd = cwd;
+		this.testDir = testDir;
 		this.captures = captures ?? new CaptureScope();
 	}
-	/** @internal Query the table — used by the toMatchRows / toBeEmpty matchers. */
-	query(columns) {
-		return this.db.query(this.name, columns);
+	/** List all files (recursively) under the working directory, sorted. */
+	async files(options = {}) {
+		return await walkDirectory(this.cwd, options);
 	}
 };
 //#endregion
-//#region src/integrations/docker/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 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 = 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 {
-		execSync(`docker rm -f ${ids.join(" ")}`, {
-			encoding: "utf8",
-			stdio: "pipe",
-			timeout: DEFAULT_TIMEOUT
-		});
-	} catch {}
-}
-//#endregion
-//#region src/core/specification/shared/resolve.ts
+//#region src/specification/facets/_common/resolve.ts
 /** What makes a directory a project root — a manifest, or a test stack. */
 const ROOT_MARKERS = ["package.json", "docker/compose.test.yaml"];
 /**
@@ -1017,11 +807,41 @@ function safeRealpath(path) {
 function expandWorkdir(env, workDir) {
 	const workdir = safeRealpath(workDir);
 	const expanded = {};
-	for (const [key, value] of Object.entries(env)) expanded[key] = typeof value === "string" ? value.replace(/\$WORKDIR/g, workdir) : value;
+	for (const [key, value] of Object.entries(env)) expanded[key] = typeof value === "string" ? value.replaceAll("$WORKDIR", workdir) : value;
 	return expanded;
 }
 //#endregion
-//#region src/core/specification/shared/result/result.ts
+//#region src/specification/facets/_common/result/table.ts
+/**
+* Read-only accessor for a database table after a specification run.
+*
+* Assertions go through `expect()` (async — they query the database):
+*
+*     await expect(result.table('users', { database: 'db' })).toMatchRows({
+*         columns: ['name'],
+*         rows: [['Alice']],
+*     });
+*     await expect(result.table('users', { database: 'db' })).toBeEmpty();
+*/
+var TableAccessor = class {
+	/** @internal Ref-capture scope shared by the current spec execution. */
+	captures;
+	/** @internal */
+	db;
+	/** The table name this accessor reads. */
+	name;
+	constructor(name, db, captures) {
+		this.name = name;
+		this.db = db;
+		this.captures = captures ?? new CaptureScope();
+	}
+	/** @internal Query the table — used by the toMatchRows / toBeEmpty matchers. */
+	async query(columns) {
+		return await this.db.query(this.name, columns);
+	}
+};
+//#endregion
+//#region src/specification/facets/_common/result/result.ts
 /**
 * Base result - common accessors available after any action type.
 * Extended by HttpResult, CliResult, and used directly by job results.
@@ -1088,7 +908,7 @@ function validateDatabaseOption(method, config, database) {
 	if (keys.length === 1 && database) throw new Error(`${method}(): redundant database option — "${keys[0]}" is the only declared database.`);
 }
 //#endregion
-//#region src/core/specification/cli/result.ts
+//#region src/specification/facets/cli/result.ts
 /**
 * Result from a command action (`.exec()`).
 *
@@ -1169,7 +989,7 @@ var CliResult = class extends BaseResult {
 	}
 	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));
+		removeContainers(this.containersCache === null ? findContainersByLabel(this.dockerConfig.testRunLabel, this.testRunId) : [...this.containersCache.values()].map((c) => c.id));
 	}
 	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 the specification.cli() options.`);
@@ -1365,6 +1185,160 @@ var ContainerAccessor = class {
 	}
 };
 //#endregion
+//#region src/specification/facets/_common/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("", `${BG_CYAN}${BLACK}${BOLD} INFRA ${RESET} Starting infrastructure...`, "");
+	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`, `${DIM}  query: ${columns.join(", ")}${RESET}`, `${DIM}  expected: ${rowLabel(expected.length)}${RESET}`, `${DIM}  received: ${rowLabel(actual.length)}${RESET}`, "", `${GREEN}- Expected${RESET}`, `${RED}+ Received${RESET}`, "");
+	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}`, `${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})`, "", `${GREEN}- Expected${RESET}`, `${RED}+ Received${RESET}`, "");
+	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");
+}
+const strictEquals = (expected, actual) => expected === actual;
+function renderLines(expectedLines, actualLines, equals) {
+	const rendered = [];
+	let marked = 0;
+	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 !== void 0 && act !== void 0 && equals(exp, act)) {
+			rendered.push(`  ${exp}`);
+			continue;
+		}
+		marked++;
+		if (exp !== void 0) rendered.push(`${GREEN}- ${exp}${RESET}`);
+		if (act !== void 0) rendered.push(`${RED}+ ${act}${RESET}`);
+	}
+	return {
+		marked,
+		rendered
+	};
+}
+/**
+* Render an expected/received diff over two texts.
+*
+* `equals` is how a line is judged EQUAL. Callers that compare through the
+* `{{token}}` grammar pass a token-aware predicate, so a `{{url}}` line that
+* matched is shown as equal — with its token, not as a `-`/`+` pair against
+* the concrete URL. Marking a line the comparison ACCEPTED buries the one it
+* rejected: the reader then has to work out which of the differences is the
+* actual cause.
+*
+* Safety net: if the token-aware pass marks nothing at all, the whole diff
+* would render as a clean block against a failure that really happened (a
+* `#ref` captured inconsistently across lines, say). The strict rendering is
+* used instead, so a diff always shows the reader something.
+*/
+function formatStdoutDiff(file, expected, actual, options) {
+	const lines = [];
+	lines.push(`Output mismatch (${file})`, "", `${GREEN}- Expected${RESET}`, `${RED}+ Received${RESET}`, "");
+	const expectedLines = expected.split("\n");
+	const actualLines = actual.split("\n");
+	const equals = options?.equals ?? strictEquals;
+	const first = renderLines(expectedLines, actualLines, equals);
+	const rendered = first.marked === 0 && equals !== strictEquals ? renderLines(expectedLines, actualLines, strictEquals).rendered : first.rendered;
+	return [...lines, ...rendered].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}`, `${DIM}  ${total} difference${total === 1 ? "" : "s"}: ${diff.added.length} added, ${diff.removed.length} removed, ${diff.changed.length} changed${RESET}`, "", `${GREEN}- Expected (fixture)${RESET}`, `${RED}+ Received (generated)${RESET}`, "");
+	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("", `${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/vitest/update.ts
 /**
 * Snapshot update-mode detection. `TEST_UPDATE=1` (framework convention, see
@@ -1378,15 +1352,17 @@ function shouldUpdateSnapshots() {
 /** Standard hint appended to missing-fixture errors. */
 const UPDATE_HINT = "Run with TEST_UPDATE=1 (or vitest -u) to create it.";
 //#endregion
-//#region src/core/specification/website/serve.adapter.ts
+//#region src/specification/facets/website/serve.adapter.ts
 /** Grace period between SIGTERM and the SIGKILL escalation. */
 const KILL_GRACE_MS = 2e3;
 const DEFAULT_READY_TIMEOUT = 3e4;
 const READY_POLL_INTERVAL_MS = 250;
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const delay = async (ms) => {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+};
 /** Ask the OS for a free TCP port. */
-function findFreePort() {
-	return new Promise((resolve, reject) => {
+async function findFreePort() {
+	return await new Promise((resolve, reject) => {
 		const server = createServer();
 		server.listen(0, () => {
 			const address = server.address();
@@ -1396,7 +1372,9 @@ function findFreePort() {
 				return;
 			}
 			const { port } = address;
-			server.close(() => resolve(port));
+			server.close(() => {
+				resolve(port);
+			});
 		});
 		server.on("error", reject);
 	});
@@ -1500,7 +1478,7 @@ var ServeAdapter = class {
 	}
 	/** Terminate the server process group (idempotent). */
 	async stop() {
-		const child = this.child;
+		const { child } = this;
 		if (!child) return;
 		this.child = null;
 		await new Promise((resolve) => {
@@ -1532,7 +1510,7 @@ var ServeAdapter = class {
 	}
 };
 //#endregion
-//#region src/core/specification/cli/literate.ts
+//#region src/specification/facets/cli/literate.ts
 /**
 * The form a stream is compared in: ANSI stripped (rule D6) and the runner's
 * `transform` applied. Nothing else — a block scalar states its own final
@@ -1636,7 +1614,7 @@ function assertRun(document, outcome, context, workDir, scope) {
 		...outcome.stderr.length > 0 ? [
 			"",
 			"stderr was:",
-			outcome.stderr.replace(/\n$/, "")
+			outcome.stderr.replace(/\n$/u, "")
 		] : []
 	].join("\n")]);
 	const equals = tokenAwareEquals(scope);
@@ -1754,8 +1732,8 @@ async function runSpecDocument(options) {
 	} catch (error) {
 		throw error instanceof SpecSyntaxError ? atLine(error, filePath, error.line) : error;
 	}
-	const document = file.document;
-	const fileDir = filePath.replace(/[/\\][^/\\]*$/, "");
+	const { document } = file;
+	const fileDir = filePath.replace(/[/\\][^/\\]*$/u, "");
 	for (const fixture of document.fixtures) {
 		const { dest, src } = copyPlan(fixture.path, fileDir, workDir);
 		cpSync(src, dest, { recursive: true });
@@ -1816,4 +1794,4 @@ const COVERAGE_DIR = `${VITEST_ARTIFACTS_DIR}/coverage`;
 /** Where `sqlite()` caches the schema template it copies per worker. */
 const SQLITE_TEMPLATE_DIR = `${VITEST_ARTIFACTS_DIR}/sqlite`;
 //#endregion
-export { formatResponseDiff as A, structuralSubset as B, text as C, diffDirectories as D, DirectoryAccessor as E, mergePreservingPlaceholders as F, mergeTextPreservingPlaceholders as I, placeholderPatternSource as L, formatStdoutDiff as M, formatTableDiff as N, walkDirectory as O, hasPlaceholders as P, renderExpected as R, TextAccessor as S, FilesystemAccessor as T, textEquals as V, findContainersByLabel as _, specDescription as a, TableAccessor as b, shouldUpdateSnapshots as c, BaseResult as d, validateDatabaseOption as f, resolveRoot as g, resolveCommand as h, runSpecDocument as i, formatStartupReport as j, formatDirectoryDiff as k, ContainerAccessor as l, expandWorkdir as m, SQLITE_TEMPLATE_DIR as n, ServeAdapter as o, discoverRoot as p, VITEST_ARTIFACTS_DIR as r, UPDATE_HINT as s, COVERAGE_DIR as t, CliResult as u, inspectContainer as v, getCallerDir as w, JsonAccessor as x, removeContainers as y, structuralEquals as z };
+export { placeholderPatternSource as A, text as B, FilesystemAccessor as C, hasPlaceholders as D, walkDirectory as E, findContainersByLabel as F, inspectContainer as I, removeContainers as L, structuralEquals as M, structuralSubset as N, mergePreservingPlaceholders as O, textEquals as P, JsonAccessor as R, resolveRoot as S, diffDirectories as T, getCallerDir as V, validateDatabaseOption as _, specDescription as a, expandWorkdir as b, shouldUpdateSnapshots as c, formatStartupReport as d, formatStdoutDiff as f, BaseResult as g, CliResult as h, runSpecDocument as i, renderExpected as j, mergeTextPreservingPlaceholders as k, formatDirectoryDiff as l, ContainerAccessor as m, SQLITE_TEMPLATE_DIR as n, ServeAdapter as o, formatTableDiff as p, VITEST_ARTIFACTS_DIR as r, UPDATE_HINT as s, COVERAGE_DIR as t, formatResponseDiff as u, TableAccessor as v, DirectoryAccessor as w, resolveCommand as x, discoverRoot as y, TextAccessor as z };