@jterrazz/test 16.1.1 → 18.0.0

package/dist/browser-shared-index.browser.js

@@ -0,0 +1,3233 @@
+import { defineInvariant, refusalBlock } from "@jterrazz/typescript/rules";
+import { TestRunner, chai, expect, inject, onTestFinished, vi } from "vitest";
+import { commands, locators, page, userEvent } from "vitest/browser";
+import { mock, mockDeep } from "vitest-mock-extended";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region lint/kit/catalogue/chapter.ts
+const CATALOGUE_CHAPTER = "docs/reference/linting.md";
+//#endregion
+//#region src/chain/refusals/rows.ts
+const REFUSAL_WHY = {
+	"database-named-only-when-several-at-runtime": "With two SQL databases or more, a seed or a table names the `database:` it reads, and with exactly one it names none.",
+	"route-written-as-template-at-runtime": "A request written as its route template is handed exactly the parameters the template names.",
+	"disk-named-by-relative-path-at-runtime": "A verb that reads the disk takes a `file()` or a `directory()`, whose path starts with `./` or `../` and ends in `/` exactly when it names a directory.",
+	"one-verb-per-meaning": "`toMatch` on a result the framework produced compares the WHOLE result, to a value written in place or to a `file()`/`directory()` golden.",
+	"network-strict-after-first-stub": "From its first stub, a chain's network is strict: every outgoing request matches a declared stub.",
+	"target-matches-one-element": "A verb acts on exactly ONE element: a target that matches several is refused, never settled by the first.",
+	"seam-is-an-optional-peer": "Every seam is an optional peer of @jterrazz/test, installed by the project that specifies through it.",
+	"no-landmark-on-mobile": "An iOS screen has no ARIA landmark: a mobile verb is scoped with `within(testId(...), ...)`."
+};
+`${REFUSAL_WHY["route-written-as-template-at-runtime"]}`, `${REFUSAL_WHY["database-named-only-when-several-at-runtime"]}`, `${REFUSAL_WHY["disk-named-by-relative-path-at-runtime"]}`, `${REFUSAL_WHY["network-strict-after-first-stub"]}`, `${REFUSAL_WHY["one-verb-per-meaning"]}`, `${REFUSAL_WHY["target-matches-one-element"]}`, `${REFUSAL_WHY["no-landmark-on-mobile"]}`, `${REFUSAL_WHY["seam-is-an-optional-peer"]}`;
+//#endregion
+//#region src/chain/refusals/refusal.ts
+const invariant = defineInvariant({
+	bugOf: "the framework",
+	notOf: "the test",
+	package: "@jterrazz/test"
+});
+function refusal(rowOrLesson, teaching) {
+	if (typeof rowOrLesson !== "string") return refusalBlock(rowOrLesson);
+	if (teaching === void 0) throw invariant(`refusal('${rowOrLesson}') was handed no found and no fix for its case`);
+	return refusalBlock({
+		fix: teaching.fix,
+		found: teaching.found,
+		read: `${CATALOGUE_CHAPTER}#${rowOrLesson}`,
+		why: REFUSAL_WHY[rowOrLesson]
+	});
+}
+//#endregion
+//#region src/chain/refusals/node-only.ts
+function refuse(name) {
+	throw new Error(refusal({
+		fix: "specify it from a test collected by a node project (unit/api/job/cli/website/mobile); a rendered thing is a `.test.tsx` in the `__tests__/` of its component's folder",
+		found: `${name} runs under node, and was called in a page`,
+		read: "docs/guides/component-specs.md#what-it-does-not-do",
+		why: "A page has no filesystem, no child process and no socket."
+	}));
+}
+/** A constructible function, never an arrow: `new` on an arrow throws before the refusal runs. */
+function nodeOnlyClass(name) {
+	function NodeOnly() {
+		return refuse(name);
+	}
+	return NodeOnly;
+}
+//#endregion
+//#region src/chain/state.ts
+const EMPTY_STATE = {
+	slices: {},
+	testDir: null
+};
+function readerOf(state) {
+	return (capability) => Object.hasOwn(state.slices, capability.name) ? state.slices[capability.name] : capability.initial;
+}
+function applied(state, capability, args, setup) {
+	const slice = capability.reduce(readerOf(state)(capability), args, setup);
+	return {
+		...state,
+		slices: {
+			...state.slices,
+			[capability.name]: slice
+		}
+	};
+}
+//#endregion
+//#region src/chain/perform.ts
+/** An adapter's recorded violation wins over the action's error and over its success; every armed effect is released in reverse. */
+async function perform(setups, action, args, { config, adapters, state, testDir }) {
+	const read = readerOf(state);
+	const { workDir } = await action.prepare?.(args, read) ?? { workDir: null };
+	const run = {
+		config,
+		testDir,
+		workDir
+	};
+	const armed = [];
+	const violation = () => armed.map((effect) => effect.violation?.() ?? null).find((error) => error !== null) ?? null;
+	try {
+		for (const setup of setups.toSorted((one, other) => one.phase - other.phase)) {
+			const effect = await setup.arm?.(read(setup), adapters, run);
+			armed.push(effect ?? {});
+		}
+		const value = await action.perform(args, read, adapters, run);
+		const failed = violation();
+		if (failed !== null) throw failed;
+		return value;
+	} catch (error) {
+		throw violation() ?? error;
+	} finally {
+		for (const effect of armed.toReversed()) effect.release?.();
+	}
+}
+//#endregion
+//#region src/chain/define-specification.ts
+function withSharedSettings(setups, state, context, setup) {
+	let next = state;
+	for (const capability of setups) {
+		const value = capability.context === void 0 ? void 0 : context[capability.context];
+		if (value !== void 0) next = applied(next, capability, [value], setup);
+	}
+	return next;
+}
+function chainOf(definition, setup, state) {
+	const here = () => state.testDir ?? definition.locate();
+	const setups = definition.capabilities.filter((capability) => capability.kind === "setup");
+	const chain = {};
+	for (const capability of definition.capabilities) chain[capability.name] = capability.kind === "context" ? (context) => chainOf(definition, setup, withSharedSettings(setups, state, context, setup)) : (...args) => chainOf(definition, setup, {
+		...applied(state, capability, args, setup),
+		testDir: here()
+	});
+	for (const action of definition.actions) chain[action.name] = async (...args) => await perform(setups, action, args, {
+		config: setup.config,
+		adapters: setup.adapters,
+		state,
+		testDir: here()
+	});
+	return chain;
+}
+function defineSpecification() {
+	return (definition) => ({
+		composition: definition,
+		open: (config) => {
+			return chainOf(definition, {
+				config,
+				adapters: definition.adapters(config)
+			}, EMPTY_STATE);
+		}
+	});
+}
+//#endregion
+//#region src/chain/capability.ts
+function defineCapability(definition) {
+	return {
+		...definition,
+		kind: "setup"
+	};
+}
+//#endregion
+//#region src/clock/instant.ts
+/** `written` spells the call that stated the instant around a value, so the refusal speaks the words the test wrote. */
+function instantOf(iso, written) {
+	const at = new Date(iso);
+	if (Number.isNaN(at.getTime())) {
+		const stated = written(JSON.stringify(iso));
+		throw new TypeError(refusal({
+			fix: `pass an ISO-8601 string: ${written("'2026-03-04T09:30:00Z'")}`,
+			found: `${stated}, and "${iso}" is not an instant`,
+			read: "docs/reference/time-and-doubles.md#the-clock",
+			why: "A clock is pinned at an instant, written as an ISO-8601 string."
+		}));
+	}
+	return at;
+}
+//#endregion
+//#region src/clock/clock.capability.ts
+/** The instant is judged here, before any adapter sees it, and released when the action settles (`no-sampled-value-in-expectation`); a chain stating none hands the adapter `null`. */
+const clock$1 = defineCapability({
+	arm: (instant, adapters) => {
+		if (instant !== null) instantOf(instant, (value) => `.clock(${value})`);
+		return adapters.clock.pin(instant);
+	},
+	context: "clock",
+	initial: null,
+	name: "clock",
+	phase: 50,
+	reduce: (_pinned, [iso]) => iso,
+	row: {
+		group: "Setup",
+		name: ".clock()",
+		probe: ".clock("
+	}
+});
+//#endregion
+//#region src/stubs/exchange.ts
+/** Each adapter serialises an object as JSON, so a stream declared as a plain value would arrive as `{}`: the tag tells them apart. */
+const STREAM_BODY = "@jterrazz/test:stream";
+function isStreamBody(body) {
+	return typeof body === "object" && body !== null && "kind" in body && body.kind === "@jterrazz/test:stream";
+}
+//#endregion
+//#region src/expectations/tokens/capture-scope.ts
+/** Named captures of `match.ref()` / `{{type#ref}}`, one scope per spec result. */
+var CaptureScope = class CaptureScope {
+	values = /* @__PURE__ */ new Map();
+	/** The spec's working directory when known (cli mode), for `{{workdir}}`. */
+	workdir;
+	constructor(workdir) {
+		this.workdir = workdir;
+	}
+	get(name) {
+		return this.values.get(name);
+	}
+	has(name) {
+		return this.values.has(name);
+	}
+	set(name, value) {
+		this.values.set(name, value);
+	}
+	/** A copy to try a comparison on: its captures stay there until adopted. */
+	fork() {
+		const copy = new CaptureScope(this.workdir);
+		for (const [name, value] of this.values) copy.set(name, value);
+		return copy;
+	}
+	/** Take every capture a fork of this scope recorded. */
+	adopt(fork) {
+		for (const [name, value] of fork.values) this.values.set(name, value);
+	}
+};
+//#endregion
+//#region lint/kit/project/json-shape.ts
+/** `JSON.parse` answers `any`: these read a parsed value field by field, and a field of another shape reads as absent. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region lint/kit/project/tokens.ts
+const TOKEN_KINDS = [
+	"any",
+	"base64",
+	"date",
+	"duration",
+	"email",
+	"float",
+	"hex",
+	"int",
+	"ip",
+	"iso8601",
+	"number",
+	"path",
+	"port",
+	"semver",
+	"sha",
+	"string",
+	"time",
+	"ulid",
+	"url",
+	"uuid",
+	"workdir"
+];
+new Set(TOKEN_KINDS);
+//#endregion
+//#region src/expectations/tokens/any-lines.ts
+function isFramedInLine(expected, start, end) {
+	const before = expected.slice(expected.lastIndexOf("\n", start - 1) + 1, start);
+	const lineEnd = expected.indexOf("\n", end);
+	const after = expected.slice(end, lineEnd === -1 ? void 0 : lineEnd);
+	return before.trim() !== "" && after.trim() !== "";
+}
+function piecesMatch(pieces, text) {
+	const [first = "", ...rest] = pieces;
+	const last = rest.pop();
+	if (last === void 0) return text === first;
+	if (!text.startsWith(first)) return false;
+	let at = first.length;
+	for (const piece of rest) {
+		const found = text.indexOf(piece, at);
+		if (found === -1) return false;
+		at = found + piece.length;
+	}
+	return text.length - last.length >= at && text.endsWith(last);
+}
+//#endregion
+//#region src/expectations/tokens/placeholders.ts
+const UUID_SOURCE = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
+const ULID_SOURCE = "[0-9A-HJKMNP-TV-Z]{26}";
+const ISO8601_SOURCE = String.raw`\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})`;
+const DATE_SOURCE = String.raw`\d{4}-\d{2}-\d{2}`;
+const TIME_SOURCE = String.raw`\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?`;
+const DURATION_SOURCE = String.raw`\d+(?:\.\d+)?(?:ms|s|m|h)`;
+const NUMBER_SOURCE = String.raw`-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?`;
+const INT_SOURCE = String.raw`-?\d+`;
+const FLOAT_SOURCE = String.raw`-?\d+\.\d+`;
+const SEMVER_SOURCE = String.raw`\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?`;
+const SHA_SOURCE = "[0-9a-f]{7,64}";
+const HEX_SOURCE = "[0-9a-fA-F]+";
+const BASE64_SOURCE = "[A-Za-z0-9+/]+={0,2}";
+const PORT_SOURCE = String.raw`(?:6553[0-5]|655[0-2]\d|65[0-4]\d{2}|6[0-4]\d{3}|[1-5]\d{4}|\d{1,4})`;
+const IP_OCTET = String.raw`(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)`;
+const IP_SOURCE = String.raw`(?:${IP_OCTET}\.){3}${IP_OCTET}`;
+const URL_SOURCE = String.raw`https?:\/\/[^\s"'<>]+`;
+const EMBEDDED_SOURCES = {
+	base64: BASE64_SOURCE,
+	date: DATE_SOURCE,
+	duration: DURATION_SOURCE,
+	email: String.raw`[^\s@"'<>]+@[^\s@"'<>]+\.[^\s@"'<>]+`,
+	float: FLOAT_SOURCE,
+	hex: HEX_SOURCE,
+	int: INT_SOURCE,
+	ip: IP_SOURCE,
+	iso8601: ISO8601_SOURCE,
+	number: NUMBER_SOURCE,
+	path: String.raw`\.{0,2}\/[^\s"'<>]*`,
+	port: PORT_SOURCE,
+	semver: SEMVER_SOURCE,
+	sha: SHA_SOURCE,
+	time: TIME_SOURCE,
+	ulid: ULID_SOURCE,
+	url: URL_SOURCE,
+	uuid: UUID_SOURCE
+};
+const wholeRe = (source) => new RegExp(`^(?:${source})$`, "u");
+const WHOLE_RES = Object.fromEntries(Object.entries(EMBEDDED_SOURCES).map(([kind, source]) => [kind, wholeRe(source)]));
+const wholeMatches = (kind, actual) => WHOLE_RES[kind]?.test(actual) === true;
+const PLACEHOLDER_RE = new RegExp(String.raw`\{\{(?<kind>${[...TOKEN_KINDS].toSorted((a, b) => b.length - a.length).join("|")})(?:#(?<ref>[\w.-]+))?\}\}`, "gu");
+function hasPlaceholders(value) {
+	PLACEHOLDER_RE.lastIndex = 0;
+	return PLACEHOLDER_RE.test(value);
+}
+function canonical(value) {
+	if (Array.isArray(value)) return value.map((item) => canonical(item));
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.keys(value).toSorted().map((key) => [key, canonical(value[key])]));
+}
+function capturedEquals(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a === "number" && typeof b === "string" || typeof a === "string" && typeof b === "number") return String(a) === String(b);
+	return typeof a === "object" && typeof b === "object" && JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+}
+function recordRef(name, actual, scope) {
+	if (scope.has(name)) return capturedEquals(scope.get(name), actual);
+	scope.set(name, actual);
+	return true;
+}
+function isPortValue(value) {
+	return Number.isInteger(value) && value >= 0 && value <= 65535;
+}
+const NUMERIC_KINDS = {
+	float: Number.isFinite,
+	int: Number.isInteger,
+	number: Number.isFinite,
+	port: isPortValue
+};
+function kindMatches(kind, actual, scope) {
+	if (kind === "any") return true;
+	if (kind === "workdir") return typeof actual === "string" && actual === scope.workdir;
+	const numeric = NUMERIC_KINDS[kind];
+	if (numeric !== void 0 && typeof actual === "number") return numeric(actual);
+	if (typeof actual !== "string") return false;
+	if (kind === "string") return true;
+	return wholeMatches(kind, actual);
+}
+function matcherMatches(matcher, actual, scope) {
+	if (matcher.kind === "includes") return typeof actual === "string" && matcher.includes !== void 0 && actual.includes(matcher.includes);
+	if (matcher.kind === "regex") return typeof actual === "string" && matcher.regex?.test(actual) === true;
+	if (matcher.kind === "ref") {
+		if (matcher.notRef !== void 0 && scope.has(matcher.notRef) && capturedEquals(scope.get(matcher.notRef), actual)) return false;
+		return matcher.refName !== void 0 && recordRef(matcher.refName, actual, scope);
+	}
+	return kindMatches(matcher.kind, actual, scope);
+}
+function placeholderSource(kind, scope, inLine) {
+	if (kind === "workdir") return scope.workdir === void 0 ? "(?!)" : escapeRegExp(scope.workdir);
+	const source = EMBEDDED_SOURCES[kind];
+	if (source !== void 0) return source;
+	return kind === "any" && !inLine ? String.raw`[\s\S]*?` : String.raw`[^\n]*?`;
+}
+function escapeRegExp(text) {
+	return text.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
+}
+function parsePlaceholderString(expected, scope) {
+	PLACEHOLDER_RE.lastIndex = 0;
+	const tokens = [...expected.matchAll(PLACEHOLDER_RE)].flatMap((found) => {
+		const { kind: written, ref } = found.groups ?? {};
+		const kind = TOKEN_KINDS.find((known) => known === written);
+		return kind === void 0 ? [] : [{
+			found,
+			kind,
+			ref
+		}];
+	});
+	let source = "";
+	let lastIndex = 0;
+	const pieces = [];
+	let framed = false;
+	for (const { found, kind } of tokens) {
+		const inLine = isFramedInLine(expected, found.index, found.index + found[0].length);
+		framed ||= kind === "any" && inLine;
+		pieces.push(expected.slice(lastIndex, found.index));
+		source += `${escapeRegExp(expected.slice(lastIndex, found.index))}(${placeholderSource(kind, scope, inLine)})`;
+		lastIndex = found.index + found[0].length;
+	}
+	pieces.push(expected.slice(lastIndex));
+	source += escapeRegExp(expected.slice(lastIndex));
+	const [only] = tokens;
+	return {
+		pieces: !framed && tokens.every(({ kind, ref }) => kind === "any" && ref === void 0) ? pieces : null,
+		pattern: new RegExp(`^${source}$`, "u"),
+		refs: tokens.map(({ kind, ref }, index) => ({
+			index,
+			kind,
+			ref
+		})),
+		single: only?.found[0] === expected ? {
+			kind: only.kind,
+			ref: only.ref
+		} : null,
+		source
+	};
+}
+function placeholderPatternSource(expected) {
+	return parsePlaceholderString(expected, new CaptureScope()).source;
+}
+function placeholderStringMatches(expected, actual, scope) {
+	const parsed = parsePlaceholderString(expected, scope);
+	if (parsed.single) {
+		if (!kindMatches(parsed.single.kind, actual, scope)) return false;
+		if (parsed.single.ref !== void 0) return recordRef(parsed.single.ref, actual, scope);
+		return true;
+	}
+	if (typeof actual !== "string" && typeof actual !== "number") return false;
+	const text = String(actual);
+	if (parsed.pieces !== null) return piecesMatch(parsed.pieces, text);
+	const found = parsed.pattern.exec(text);
+	if (!found) return false;
+	for (const entry of parsed.refs) {
+		if (entry.ref === void 0) continue;
+		if (!recordRef(entry.ref, found[entry.index + 1], scope)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/expectations/tokens/match.ts
+/** A dynamic-value matcher, created through the `match` factories. */
+var Matcher = class {
+	/** For kind 'includes': the substring the actual value must contain. */
+	includes;
+	kind;
+	/** For kind 'ref': the capture to assert inequality against. */
+	notRef;
+	/** For kind 'ref': the capture name. */
+	refName;
+	/** For kind 'regex': the pattern the actual value must match. */
+	regex;
+	constructor(kind, options = {}) {
+		this.includes = options.includes;
+		this.kind = kind;
+		this.notRef = options.notRef;
+		this.refName = options.refName;
+		this.regex = options.regex;
+	}
+	/** Placeholder-style rendering used in failure diffs and serialization. */
+	toString() {
+		if (this.kind === "includes") return `{{includes:${this.includes}}}`;
+		if (this.kind === "regex") return `{{regex:${this.regex?.source}}}`;
+		if (this.kind === "ref") return this.notRef === void 0 ? `{{ref#${this.refName}}}` : `{{ref#${this.refName}!${this.notRef}}}`;
+		return this.refName === void 0 ? `{{${this.kind}}}` : `{{${this.kind}#${this.refName}}}`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+};
+const typed = (kind) => () => new Matcher(kind);
+const match = {
+	any: typed("any"),
+	base64: typed("base64"),
+	/** Matches a calendar date (`YYYY-MM-DD`). */
+	date: typed("date"),
+	/** Matches a human duration (`12ms`, `1.5s`, `2m`, `3h`). */
+	duration: typed("duration"),
+	email: typed("email"),
+	/** Matches a float: any finite number in JSON; in text the decimal part is required. */
+	float: typed("float"),
+	hex: typed("hex"),
+	/** Matches a string containing the substring; code-only, like `match.regex`. */
+	includes: (substring) => new Matcher("includes", { includes: substring }),
+	/** Matches an integer (or an integer string in text contexts). */
+	int: typed("int"),
+	/** Matches an IPv4 address. */
+	ip: typed("ip"),
+	iso8601: typed("iso8601"),
+	/** Matches a number (or a numeric string in text contexts). */
+	number: typed("number"),
+	/** Matches a filesystem path (`/...` or `./...`). */
+	path: typed("path"),
+	/** Matches a TCP/UDP port number (0-65535). */
+	port: typed("port"),
+	/** Capture-and-compare: the first `ref(name)` captures, every later one must equal it; `{ not }` asserts inequality. */
+	ref: (name, options) => new Matcher("ref", {
+		notRef: options?.not,
+		refName: name
+	}),
+	regex: (regex) => new Matcher("regex", { regex }),
+	/** Matches a semantic version (`1.2.3`, `2.0.0-rc.1`). */
+	semver: typed("semver"),
+	/** Matches a git SHA (7-64 hex chars). */
+	sha: typed("sha"),
+	string: typed("string"),
+	/** Matches a wall-clock time (`HH:MM` or `HH:MM:SS`). */
+	time: typed("time"),
+	ulid: typed("ulid"),
+	/** Matches an http(s) URL. */
+	url: typed("url"),
+	uuid: typed("uuid"),
+	/** Matches the exact working directory of the current spec. */
+	workdir: typed("workdir")
+};
+//#endregion
+//#region src/expectations/tokens/structural.ts
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function structurally(expected, actual, scope, subset) {
+	if (expected instanceof Matcher) return matcherMatches(expected, actual, scope);
+	if (typeof expected === "string" && hasPlaceholders(expected)) return placeholderStringMatches(expected, actual, scope);
+	if (Array.isArray(expected)) return Array.isArray(actual) && actual.length === expected.length && expected.every((item, index) => structurally(item, actual[index], scope, subset));
+	if (isPlainObject(expected)) return isPlainObject(actual) && (subset || Object.keys(actual).length === Object.keys(expected).length) && Object.keys(expected).every((key) => key in actual && structurally(expected[key], actual[key], scope, subset));
+	return Object.is(expected, actual);
+}
+function structuralEquals(expected, actual, scope) {
+	return structurally(expected, actual, scope, false);
+}
+function structuralSubset(expected, actual, scope) {
+	return structurally(expected, actual, scope, true);
+}
+/** A text without tokens reads as itself, every character literal. */
+function textEquals(expected, actual, scope) {
+	return placeholderStringMatches(expected, actual, scope);
+}
+//#endregion
+//#region src/stubs/matching/route.ts
+const RELATIVE_BASE = "http://stub.invalid";
+const UNICODE = "u";
+function splitDeclared(url) {
+	const separator = url.indexOf("?");
+	if (separator === -1) return {
+		base: url,
+		query: new URLSearchParams()
+	};
+	return {
+		base: url.slice(0, separator),
+		query: new URLSearchParams(url.slice(separator + 1))
+	};
+}
+function safeDecode(text) {
+	try {
+		return decodeURIComponent(text);
+	} catch {
+		return text;
+	}
+}
+function wholeUrl(prefix, base) {
+	return new RegExp(String.raw`^${prefix}${placeholderPatternSource(base)}(?:\?[^#]*)?(?:#.*)?$`, UNICODE);
+}
+function valueMatches(declared, observed) {
+	return textEquals(declared, observed, new CaptureScope());
+}
+/** A RegExp tests the full URL, a path form ignores the origin; `{{token}}` segments compare structurally and declared query params are a subset. */
+function urlMatches(declared, observed) {
+	if (declared instanceof RegExp) return declared.test(observed);
+	let url;
+	try {
+		url = new URL(observed, RELATIVE_BASE);
+	} catch {
+		return false;
+	}
+	const { base, query } = splitDeclared(declared);
+	const observedBase = base.startsWith("/") ? url.pathname : `${url.origin}${url.pathname}`;
+	const decodedBase = base.startsWith("/") ? safeDecode(url.pathname) : `${url.origin}${safeDecode(url.pathname)}`;
+	if (!valueMatches(base, observedBase) && !valueMatches(base, decodedBase)) return false;
+	for (const key of new Set(query.keys())) {
+		const observedValues = url.searchParams.getAll(key);
+		if (!query.getAll(key).every((value) => observedValues.some((actual) => valueMatches(value, actual)))) return false;
+	}
+	return true;
+}
+/** No narrower than `stubMatches`, which stays the authority on what matches. */
+function routePatternOf(declared) {
+	if (declared instanceof RegExp) return declared;
+	const { base } = splitDeclared(declared);
+	if (base.startsWith("/")) return wholeUrl(String.raw`https?:\/\/[^/?#]+`, base);
+	if (hasPlaceholders(base)) return wholeUrl("", base);
+	return base;
+}
+function routeKeyOf({ method, url }) {
+	return url instanceof RegExp ? `${method} re:${url.source}` : `${method} str:${url}`;
+}
+function describeAbsent(absentHeaders) {
+	if (absentHeaders === void 0 || absentHeaders.length === 0) return "";
+	return ` (without header${absentHeaders.length > 1 ? "s" : ""} ${absentHeaders.join(", ")})`;
+}
+function describeRoute({ absentHeaders, method, url }) {
+	return `${method === "*" ? "ANY" : method} ${url instanceof RegExp ? String(url) : url}${describeAbsent(absentHeaders)}`;
+}
+//#endregion
+//#region src/stubs/matching/stub-queue.ts
+function stubMatches(stub, request) {
+	const { absentHeaders, match, method, url } = stub.request;
+	if (method !== "*" && method.toUpperCase() !== request.method.toUpperCase()) return false;
+	if (!urlMatches(url, request.url)) return false;
+	if ((absentHeaders ?? []).some((name) => request.headers[name.toLowerCase()] !== void 0)) return false;
+	return match ? match(request) : true;
+}
+function isNever({ required, times }) {
+	return required === true && times === 0;
+}
+function stateOf({ stub, served }) {
+	const { times } = stub;
+	if (isNever(stub)) return served === 0 ? " (never)" : ` (never, reached ${served} time(s))`;
+	if (served >= (times ?? Number.POSITIVE_INFINITY)) return ` (exhausted after ${times})`;
+	return served === 0 ? "" : ` (served ${served} time(s))`;
+}
+/** The first unexhausted stub in declaration order answers; `times: n` is spent after n serves. */
+var StubQueue = class {
+	entries;
+	constructor(stubs) {
+		this.entries = stubs.map((stub) => ({
+			reached: [],
+			stub,
+			served: 0
+		}));
+	}
+	/** Deduped by pattern: two stubs on one URL share one handler and one queue. */
+	get routes() {
+		const routes = /* @__PURE__ */ new Map();
+		for (const { stub } of this.entries) {
+			const url = routePatternOf(stub.request.url);
+			const key = String(url);
+			const route = routes.get(key) ?? {
+				methods: [],
+				url
+			};
+			if (!route.methods.includes(stub.request.method)) route.methods.push(stub.request.method);
+			routes.set(key, route);
+		}
+		return [...routes.values()];
+	}
+	declaredRoutes() {
+		return this.entries.map(({ stub }) => describeRoute(stub.request));
+	}
+	/** `null` when nothing unexhausted matches: the strict-violation signal. */
+	take(request) {
+		for (const entry of this.entries) {
+			if (entry.served >= (entry.stub.times ?? Number.POSITIVE_INFINITY) && !isNever(entry.stub) || !stubMatches(entry.stub, request)) continue;
+			entry.served += 1;
+			entry.reached.push(`${request.method} ${request.url}`);
+			return entry.stub;
+		}
+		return null;
+	}
+	verdict(unmatched = null) {
+		const errors = [
+			this.neverError(),
+			unmatched,
+			this.unmetError()
+		].filter((error) => error !== null);
+		if (errors.length <= 1) return errors[0] ?? null;
+		const reports = errors.map(({ message }) => message).join("\n\n");
+		return new AggregateError(errors, refusal({
+			fix: "correct each outcome in turn, by its own fix",
+			found: `${errors.length} outcomes of one action, each with its own refusal:\n\n${reports}`,
+			read: "docs/reference/stubs.md#strict-by-construction",
+			why: "A reached never stub, an unmatched request and an unmet required stub are independent facts about one action, so all are reported at once."
+		}));
+	}
+	neverError() {
+		const reached = this.entries.filter(({ stub, served }) => isNever(stub) && served > 0);
+		if (reached.length === 0) return null;
+		const lines = reached.map(({ reached: calls, stub }) => `  - ${describeRoute(stub.request)}: reached by ${calls.join(", ")}`);
+		return new Error(refusal({
+			fix: "take the call out of the path under test or, if the call is now intended, replace the never stub with one that answers it",
+			found: `a route the chain declared never requested was reached:\n${lines.join("\n")}`,
+			read: "docs/reference/stubs.md#never-a-call-that-must-not-happen",
+			why: "A never stub states the subject must not reach its route within the chain's terminal action, or the `intercept()` scope, it is declared for."
+		}));
+	}
+	unmetError() {
+		const unmet = [];
+		for (const { stub, served } of this.entries) {
+			if (stub.required !== true || isNever(stub)) continue;
+			const { times } = stub;
+			if (times === void 0) {
+				if (served === 0) unmet.push(`  - ${describeRoute(stub.request)}: declared and required but never requested`);
+			} else if (served !== times) unmet.push(`  - ${describeRoute(stub.request)}: declared required with times: ${times} but was requested ${served} time(s)`);
+		}
+		if (unmet.length === 0) return null;
+		return new Error(refusal({
+			fix: "the code no longer makes the call, or the stub no longer describes it: correct the one that drifted",
+			found: `required stub(s) never satisfied during the chain:\n${unmet.join("\n")}`,
+			read: "docs/reference/stubs.md#required-is-verified-per-terminal-action",
+			why: "A required stub states the call MUST happen, within the terminal action it is declared for."
+		}));
+	}
+	unmatchedError(method, url) {
+		const declared = this.entries.length === 0 ? "  (no stubs declared)" : this.entries.map((entry) => `  - ${describeRoute(entry.stub.request)}${stateOf(entry)}`).join("\n");
+		return new Error(refusal("network-strict-after-first-stub", {
+			fix: `declare a stub for ${method} ${url}, or raise the \`times\` of the one it exhausted`,
+			found: `an unmatched outgoing request, ${method} ${url}; declared:\n${declared}`
+		}));
+	}
+};
+//#endregion
+//#region src/chain/pause.ts
+async function pause(ms) {
+	if (ms <= 0) return;
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+/** Asks `probe` until it answers something other than `undefined`, which it hands back, or answers `undefined` once `timeout` has passed. Measured on `performance.now()`, so `clock.at()`, which fakes `Date`, cannot freeze it. */
+async function untilDeadline(probe, { interval = 0, timeout, wait }) {
+	const deadline = performance.now() + timeout;
+	for (;;) {
+		const answer = await probe();
+		if (answer !== void 0) return answer;
+		const remaining = deadline - performance.now();
+		if (remaining <= 0) return;
+		await (wait === void 0 ? pause(interval) : wait(remaining));
+	}
+}
+//#endregion
+//#region src/stubs/delivery/stream-body.ts
+async function nextTask() {
+	const { port1, port2 } = new MessageChannel();
+	await new Promise((resolve) => {
+		port1.onmessage = () => {
+			port1.close();
+			resolve();
+		};
+		port2.postMessage(null);
+	});
+}
+/** One serialisation for all three deliveries (msw server, msw worker, `node:http` stub). */
+function toReadableStream(body) {
+	const encoder = new TextEncoder();
+	let index = 0;
+	return new ReadableStream({ async pull(controller) {
+		const chunk = body.chunks[index];
+		if (chunk === void 0) {
+			controller.close();
+			return;
+		}
+		if (index > 0) {
+			await pause(body.delayBetweenChunks);
+			await nextTask();
+		}
+		index += 1;
+		controller.enqueue(encoder.encode(chunk));
+	} });
+}
+//#endregion
+//#region src/stubs/delivery/stub-reply.ts
+/** A request's body as a stub's filter reads it: the parsed JSON, the raw text when it is none, `null` when there is none. */
+function requestBody(raw) {
+	if (raw.length === 0) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+/** The reply a matched stub states for this request, once its delay has passed. */
+async function replyOf(response, observed) {
+	const reply = typeof response === "function" ? response(observed) : response;
+	await pause(reply.delay ?? 0);
+	return reply;
+}
+/** The `error` of the 501 every delivery answers a request it refuses, whichever process serves it. */
+function refusedReply(summary) {
+	return `@jterrazz/test strict stubs: ${summary}`;
+}
+function unmatchedSummary(method, url) {
+	return `unmatched request ${method} ${url}`;
+}
+//#endregion
+//#region src/stubs/delivery/msw-handlers.ts
+const NEVER_CACHED = { "cache-control": "no-store" };
+function toMswResponse(msw, response) {
+	const { body, headers, status = 200 } = response;
+	if (response.transport === "network-error") return msw.HttpResponse.error();
+	if (body === null || body === void 0) return new msw.HttpResponse(null, {
+		headers: {
+			...NEVER_CACHED,
+			...headers
+		},
+		status
+	});
+	if (isStreamBody(body)) return new msw.HttpResponse(toReadableStream(body), {
+		headers: {
+			...NEVER_CACHED,
+			"content-type": body.contentType,
+			...headers
+		},
+		status
+	});
+	if (typeof body === "string") return new msw.HttpResponse(body, {
+		headers: {
+			...NEVER_CACHED,
+			"content-type": "text/plain; charset=utf-8",
+			...headers
+		},
+		status
+	});
+	return msw.HttpResponse.json(body, {
+		headers: {
+			...NEVER_CACHED,
+			...headers
+		},
+		status
+	});
+}
+function handlerOf(msw, method) {
+	return {
+		"*": msw.http.all,
+		DELETE: msw.http.delete,
+		GET: msw.http.get,
+		HEAD: msw.http.head,
+		OPTIONS: msw.http.options,
+		PATCH: msw.http.patch,
+		POST: msw.http.post,
+		PUT: msw.http.put
+	}[method.toUpperCase()];
+}
+function buildStubHandlers(msw, stubs, bypass) {
+	const queue = new StubQueue(stubs);
+	let violation = null;
+	const refuse = (error, summary) => {
+		violation ??= error;
+		return msw.HttpResponse.json({ error: refusedReply(summary) }, {
+			headers: NEVER_CACHED,
+			status: 501
+		});
+	};
+	const recordViolation = (method, url) => refuse(queue.unmatchedError(method, url), unmatchedSummary(method, url));
+	const handlers = [];
+	for (const route of queue.routes) for (const method of route.methods) {
+		const handlerFn = handlerOf(msw, method);
+		if (handlerFn === void 0) continue;
+		handlers.push(handlerFn(route.url, async ({ request }) => {
+			const observed = await observe(request);
+			const stub = queue.take(observed);
+			if (!stub) return recordViolation(request.method, request.url);
+			return toMswResponse(msw, await replyOf(stub.response, observed));
+		}));
+	}
+	handlers.push(msw.http.all("*", ({ request }) => bypass?.(request.url) === true ? msw.passthrough() : recordViolation(request.method, request.url)));
+	return {
+		handlers,
+		refuse,
+		violation: () => queue.verdict(violation)
+	};
+}
+async function observe(request) {
+	return {
+		body: requestBody(await request.clone().text()),
+		headers: Object.fromEntries(request.headers),
+		method: request.method.toUpperCase(),
+		url: request.url
+	};
+}
+//#endregion
+//#region src/stubs/delivery/browser-page/msw-worker.adapter.ts
+const RUNNER_PREFIXES = [
+	"/.artifacts/",
+	"/@fs/",
+	"/@id/",
+	"/@vite",
+	"/node_modules/",
+	"/__vitest"
+];
+let workerInstance = null;
+function isRunnerRequest(url) {
+	const { pathname } = new URL(url);
+	return RUNNER_PREFIXES.some((prefix) => pathname.startsWith(prefix));
+}
+/** msw's hook for a frame no handler took: the subject's HTTP request prints msw's error; the runner's own request and a WebSocket frame, which carries none, pass. */
+function onUnhandledFrame({ defaults, frame }) {
+	const { data } = frame;
+	if (typeof data !== "object" || data === null || !("request" in data)) return;
+	if (data.request instanceof Request && !isRunnerRequest(data.request.url)) defaults.error();
+}
+async function ensureStubWorker() {
+	if (workerInstance !== null) return;
+	const { setupWorker } = await import("msw/browser");
+	const worker = setupWorker();
+	workerInstance = worker;
+	await worker.start({
+		onUnhandledFrame,
+		quiet: true,
+		serviceWorker: { url: "/mockServiceWorker.js" }
+	});
+}
+/** Starts even for an empty list: `network-strict-after-first-stub` is total here, a component given no stub has no network. */
+async function registerWorkerStubs(stubs) {
+	await ensureStubWorker();
+	const { handlers, violation } = buildStubHandlers(await import("msw"), stubs, isRunnerRequest);
+	workerInstance?.use(...handlers);
+	return {
+		cleanup: () => {
+			workerInstance?.resetHandlers();
+		},
+		violation
+	};
+}
+function resetWorkerStubs() {
+	if (workerInstance !== null) workerInstance.resetHandlers();
+}
+/** Dropped at test end, not render end: a mounted component keeps fetching after its render resolves. */
+function mswWorker(atTestEnd) {
+	return {
+		accepts: () => {},
+		arm: async (stubs) => {
+			const registration = await registerWorkerStubs(stubs);
+			atTestEnd(resetWorkerStubs);
+			return { violation: registration.violation };
+		}
+	};
+}
+//#endregion
+//#region src/stubs/stub.ts
+function defineStub(stub) {
+	return stub;
+}
+function flatten(items) {
+	const flat = [];
+	for (const item of items) if (Array.isArray(item)) flat.push(...flatten(item));
+	else if ("stubs" in item) flat.push(...item.stubs);
+	else flat.push(item);
+	return flat;
+}
+/** Compose stubs, lists and composites, order preserved; `.with()` derives a scenario. */
+function defineStubs(...items) {
+	const stubs = Object.freeze(flatten(items));
+	return {
+		stubs,
+		with(...overrides) {
+			const added = flatten(overrides);
+			const claimed = new Set(added.map((stub) => routeKeyOf(stub.request)));
+			const kept = stubs.filter((stub) => !claimed.has(routeKeyOf(stub.request)));
+			return defineStubs([...added, ...kept]);
+		}
+	};
+}
+function stubsOf(input) {
+	return flatten([input]);
+}
+//#endregion
+//#region src/stubs/intercept/declared.ts
+function isRequest(value) {
+	return "adapter" in value;
+}
+/** A bare request is refused; the compiler already refuses the form, so only an untyped call reaches the refusal. */
+function declared(call, requestOrStubs, maybeResponse) {
+	if (!isRequest(requestOrStubs)) return stubsOf(requestOrStubs);
+	if (maybeResponse === void 0) throw new Error(refusal({
+		fix: `pass a stub, defineStub({ request, response }), or the inline pair ${call}(request, response)`,
+		found: `${call}(request), a bare request with no response`,
+		read: "docs/reference/stubs.md#using-them-intercept",
+		why: "A stub is a request and its response: a request alone answers nothing."
+	}));
+	return [{
+		request: requestOrStubs,
+		response: maybeResponse
+	}];
+}
+//#endregion
+//#region src/stubs/intercept/intercept.capability.ts
+/** Calls append (`network-strict-after-first-stub`); composition and overriding live in `defineStubs()` / `.with()`. Strict once armed. */
+const intercept$1 = defineCapability({
+	arm: async (stubs, { network }) => await network.arm(stubs),
+	initial: [],
+	name: "intercept",
+	phase: 40,
+	reduce: (stubs, [requestOrStubs, response], { adapters }) => {
+		adapters.network.accepts();
+		return [...stubs, ...declared(".intercept", requestOrStubs, response)];
+	},
+	row: {
+		group: "Setup",
+		name: ".intercept()",
+		probe: ".intercept("
+	}
+});
+//#endregion
+//#region src/specifications/component/page/page-runtime.ts
+function pageDirectory() {
+	return "";
+}
+function afterThisTest(teardown) {
+	onTestFinished(teardown);
+}
+/** `Date` only: faking the page's timers would stop React's scheduler. A chain's instant was judged before the page; the project's is judged here. */
+function pinClock(iso) {
+	vi.useFakeTimers({
+		now: instantOf(iso, (value) => `component({ clock: ${value} })`),
+		toFake: ["Date"]
+	});
+}
+function releaseClock() {
+	vi.useRealTimers();
+}
+function providedClock() {
+	return inject("componentClock");
+}
+function providedViewport() {
+	return inject("componentViewport");
+}
+/** `vitest/browser` loads in a page alone, so it is reached only when a size is set. */
+async function setViewport(size) {
+	const { page } = await import("vitest/browser");
+	await page.viewport(size.width, size.height);
+}
+/** A shared symbol rather than an import: the setup module and this bundle are two graphs in one page. */
+function projectWrapper() {
+	const wrap = globalThis[Symbol.for("@jterrazz/test:component-wrap")];
+	return typeof wrap === "function" ? wrap : void 0;
+}
+//#endregion
+//#region src/specifications/component/page/page-clock.adapter.ts
+/** The chain's instant wins over `component({ clock })`'s; `Date` stays pinned for the rest of the test, since a mounted component keeps running. */
+const pageClock = { pin: (iso) => {
+	const instant = iso ?? providedClock();
+	if (instant !== void 0) pinClock(instant);
+	afterThisTest(releaseClock);
+	return {};
+} };
+//#endregion
+//#region src/specifications/component/page/vitest-browser-page.adapter.ts
+async function adapter() {
+	return await Promise.resolve().then(() => vitest_browser_dom_exports);
+}
+const vitestBrowserPage = {
+	afterThisTest,
+	ariaTree: async () => {
+		return await (await adapter()).ariaTree();
+	},
+	mountDom: async (mount) => {
+		return (await adapter()).mountDom(mount);
+	},
+	mountReact: async (ui) => {
+		return await (await adapter()).mountReact(ui);
+	},
+	projectWrapper: () => projectWrapper(),
+	visitor: async (surface) => {
+		return (await adapter()).componentVerbs(surface);
+	}
+};
+//#endregion
+//#region src/chain/action.ts
+function defineAction(definition) {
+	return {
+		...definition,
+		kind: "action"
+	};
+}
+//#endregion
+//#region src/expectations/text/console.ts
+function consoleOf(lines) {
+	return lines.map((line) => `[${line.type}] ${line.text}`).join("\n");
+}
+function errorsOf(lines) {
+	return lines.filter((line) => line.type === "error").map((line) => line.text).join("\n");
+}
+//#endregion
+//#region src/visitor/matrix.ts
+const EVERY_SURFACE_VERBS = [{
+	group: "Verb",
+	name: "see",
+	probe: ".see("
+}, {
+	group: "Verb",
+	name: "fill",
+	probe: ".fill("
+}];
+const BROWSER_VERBS = [
+	{
+		group: "Verb",
+		name: "click",
+		probe: ".click("
+	},
+	{
+		group: "Verb",
+		name: "gone",
+		probe: ".gone("
+	},
+	{
+		group: "Verb",
+		name: "press",
+		probe: ".press("
+	},
+	{
+		group: "Verb",
+		name: "hover",
+		probe: ".hover("
+	},
+	{
+		group: "Verb",
+		name: "check",
+		probe: ".check("
+	},
+	{
+		group: "Verb",
+		name: "select",
+		probe: ".select("
+	}
+];
+const EVERY_SURFACE_TARGETS = [
+	{
+		group: "Target",
+		name: "button",
+		probe: "button("
+	},
+	{
+		group: "Target",
+		name: "field",
+		probe: "field("
+	},
+	{
+		group: "Target",
+		member: "content",
+		name: "content",
+		probe: "content("
+	},
+	{
+		group: "Target",
+		name: "testId",
+		probe: "testId("
+	}
+];
+const BROWSER_TARGETS = [
+	{
+		group: "Target",
+		name: "heading",
+		probe: "heading("
+	},
+	{
+		group: "Target",
+		name: "link",
+		probe: "link("
+	},
+	{
+		group: "Target",
+		name: "dialog",
+		probe: "dialog("
+	},
+	{
+		group: "Target",
+		name: "status",
+		probe: "status("
+	},
+	{
+		group: "Target",
+		name: "table",
+		probe: "table("
+	},
+	{
+		group: "Target",
+		name: "row",
+		probe: "row("
+	},
+	{
+		group: "Target",
+		name: "listitem",
+		probe: "listitem("
+	},
+	{
+		group: "Target",
+		name: "option",
+		probe: "option("
+	},
+	{
+		group: "Target",
+		name: "banner",
+		probe: "banner("
+	},
+	{
+		group: "Target",
+		name: "complementary",
+		probe: "complementary("
+	},
+	{
+		group: "Target",
+		name: "contentinfo",
+		probe: "contentinfo("
+	},
+	{
+		group: "Target",
+		name: "form",
+		probe: "form("
+	},
+	{
+		group: "Target",
+		name: "main",
+		probe: "main("
+	},
+	{
+		group: "Target",
+		name: "navigation",
+		probe: "navigation("
+	},
+	{
+		group: "Target",
+		name: "region",
+		probe: "region("
+	},
+	{
+		group: "Target",
+		name: "search",
+		probe: "search("
+	}
+];
+const WITHIN = {
+	group: "Target",
+	name: "within",
+	probe: "within("
+};
+const BROWSER_STATES = [
+	{
+		group: "Target",
+		name: "focused",
+		probe: "focused("
+	},
+	{
+		group: "Target",
+		name: "selected",
+		probe: "selected("
+	},
+	{
+		group: "Target",
+		name: "valued",
+		probe: "valued("
+	},
+	{
+		group: "Target",
+		name: "disabled",
+		probe: "disabled("
+	},
+	{
+		group: "Target",
+		name: "enabled",
+		probe: "enabled("
+	}
+];
+//#endregion
+//#region src/specifications/component/render/console-recorder.ts
+const CONSOLE_METHODS = [
+	"debug",
+	"error",
+	"info",
+	"log",
+	"warn"
+];
+function recordConsole() {
+	const entries = [];
+	const originals = /* @__PURE__ */ new Map();
+	for (const method of CONSOLE_METHODS) {
+		const original = console[method];
+		originals.set(method, original);
+		console[method] = (...args) => {
+			const [only] = args;
+			const raised = args.length === 1 && only instanceof Error ? only.message : void 0;
+			entries.push({
+				text: args.map(String).join(" "),
+				type: method,
+				...raised === void 0 ? {} : { raised }
+			});
+			original(...args);
+		};
+	}
+	const onError = (event) => {
+		const last = entries.at(-1);
+		if (last?.type === "error" && last.raised === event.message) entries.pop();
+		entries.push({
+			text: event.message,
+			type: "error"
+		});
+	};
+	globalThis.addEventListener("error", onError);
+	let stopped = false;
+	return {
+		entries,
+		stop: () => {
+			if (stopped) return;
+			stopped = true;
+			for (const method of CONSOLE_METHODS) {
+				const original = originals.get(method);
+				if (original !== void 0) console[method] = original;
+			}
+			globalThis.removeEventListener("error", onError);
+		}
+	};
+}
+//#endregion
+//#region src/expectations/text/ansi.ts
+const ANSI_RE = /\u001B\[[0-9;]*m/gu;
+/** rule `no-transform-duplicating-tokens`: a golden compares the text, never its colour. */
+function stripAnsiCodes(value) {
+	return value.replaceAll(ANSI_RE, "");
+}
+//#endregion
+//#region src/expectations/text/grep.ts
+function grep(output, pattern) {
+	return stripAnsiCodes(output).split(/\n\s*\n/u).filter((block) => block.includes(pattern)).join("\n\n");
+}
+//#endregion
+//#region src/expectations/text/text.ts
+/** The captured text accessor: `.text` is what a golden compares (ANSI stripped, `transform` applied), `.raw` the capture. */
+var TextAccessor = class TextAccessor {
+	/** @internal */
+	captures;
+	/** The stream as it was captured: never transformed, ANSI preserved. */
+	raw;
+	/** @internal */
+	streamName;
+	/** @internal */
+	testDir;
+	/** Normaliser applied before comparisons, never to fixtures. @internal */
+	transform;
+	constructor(value, streamName, testDir, options = {}) {
+		this.raw = value;
+		this.streamName = streamName;
+		this.testDir = testDir;
+		this.transform = options.transform;
+		this.captures = options.captures ?? new CaptureScope();
+	}
+	/** The text a golden compares, and a value matcher reads: ANSI stripped, `transform` applied. */
+	get text() {
+		const stripped = stripAnsiCodes(this.raw);
+		return this.transform ? this.transform(stripped) : stripped;
+	}
+	/** Keep only the blank-line-separated blocks containing `pattern`, as a new `TextAccessor`. */
+	grep(pattern) {
+		return new TextAccessor(grep(this.raw, pattern), this.streamName, this.testDir, {
+			captures: this.captures,
+			transform: this.transform
+		});
+	}
+	toString() {
+		return this.text;
+	}
+	valueOf() {
+		return this.text;
+	}
+};
+//#endregion
+//#region src/specifications/component/render/rendered-text.ts
+/** A stream captured inside the page: its golden lives on the server, so `toMatch` is awaited. */
+var RenderedText = class extends TextAccessor {
+	/** The marker the `toMatch` overload reads. Never asserted on directly. */
+	capturedInPage = true;
+};
+//#endregion
+//#region src/specifications/component/render/render.result.ts
+/** What a render resolves to: the component as the page saw it after the scenario. */
+var RenderResult = class {
+	/** The browser console as a stream: one `[type] text` line per message. */
+	console;
+	/** Rendered text of the whole document body (`innerText`). */
+	content;
+	/** Console messages of type `error` only, plus any uncaught page error. */
+	errors;
+	/** The mounted markup, serialised: the escape hatch for a class or an attribute. */
+	html;
+	/** The ARIA snapshot of the rendered body, the outline a golden pins. */
+	tree;
+	/** Rendered text of the body without the text of an element drawn fully transparent: what a reader sees of an animation, where `content` keeps a node at `opacity: 0`. */
+	visibleContent;
+	constructor(streams) {
+		this.console = new RenderedText(streams.console, "console", "");
+		this.content = new RenderedText(streams.content, "content", "");
+		this.errors = new RenderedText(streams.errors, "errors", "");
+		this.html = new RenderedText(streams.html, "html", "");
+		this.tree = new RenderedText(streams.tree, "tree", "");
+		this.visibleContent = new RenderedText(streams.visibleContent, "visible-content", "");
+	}
+};
+//#endregion
+//#region src/specifications/component/render/visible-text.ts
+/** The rendered text of the body without the text of an element the page draws fully transparent: `innerText` keeps a node at `opacity: 0`, which a reader does not see. */
+function visibleTextOf({ elements, opacityOf, text }) {
+	const hidden = elements.filter((element) => opacityOf(element) === 0).map((element) => ({
+		element,
+		visibility: element.style.visibility
+	}));
+	for (const { element } of hidden) element.style.visibility = "hidden";
+	try {
+		return text();
+	} finally {
+		for (const { element, visibility } of hidden) element.style.visibility = visibility;
+	}
+}
+//#endregion
+//#region src/specifications/component/render/wrap.capability.ts
+/** A later call replaces an earlier one: the wrappers do not nest. */
+const wrap = defineCapability({
+	initial: null,
+	name: "wrap",
+	phase: 30,
+	reduce: (_stated, [wrapper]) => wrapper,
+	row: {
+		group: "Setup",
+		name: ".wrap()",
+		probe: ".wrap("
+	}
+});
+//#endregion
+//#region src/specifications/component/render/render.action.ts
+const PARENT_VERBS = [{
+	group: "Verb",
+	name: "rerender",
+	probe: ".rerender("
+}, {
+	group: "Verb",
+	name: "unmount",
+	probe: ".unmount("
+}];
+let mounted = null;
+async function unmountHeld() {
+	const surface = mounted;
+	mounted = null;
+	if (surface !== null) try {
+		await surface.unmount();
+	} catch {}
+}
+function isDomMount(subject) {
+	return typeof subject === "function";
+}
+async function mount(page, chained, subject) {
+	if (isDomMount(subject)) return await page.mountDom(subject);
+	const outer = page.projectWrapper();
+	const dress = (ui) => {
+		const inner = chained ? chained(ui) : ui;
+		return outer ? outer(inner) : inner;
+	};
+	const surface = await page.mountReact(dress(subject));
+	return {
+		...surface,
+		rerender: async (ui) => {
+			await surface.rerender(dress(ui));
+		}
+	};
+}
+/** A second render replaces the first, taken down before the second arms anything. */
+const render = defineAction({
+	accessors: [
+		{
+			group: "Result accessor",
+			name: ".tree",
+			probe: "result.tree"
+		},
+		{
+			group: "Result accessor",
+			name: ".content",
+			probe: "result.content"
+		},
+		{
+			group: "Result accessor",
+			name: ".visibleContent",
+			probe: "result.visibleContent"
+		},
+		{
+			group: "Result accessor",
+			name: ".console",
+			probe: "result.console"
+		},
+		{
+			group: "Result accessor",
+			name: ".errors",
+			probe: "result.errors"
+		},
+		{
+			group: "Result accessor",
+			name: ".html",
+			probe: "result.html"
+		}
+	],
+	targets: [
+		...EVERY_SURFACE_TARGETS,
+		...BROWSER_TARGETS,
+		WITHIN,
+		...BROWSER_STATES
+	],
+	name: "render",
+	perform: async ([subject, scenario], read, { page }) => {
+		const recorder = recordConsole();
+		page.afterThisTest(async () => {
+			recorder.stop();
+			await unmountHeld();
+		});
+		const surface = await mount(page, read(wrap), subject);
+		mounted = surface;
+		try {
+			if (scenario) await scenario(await page.visitor(surface));
+		} finally {
+			recorder.stop();
+		}
+		const { entries } = recorder;
+		return new RenderResult({
+			console: consoleOf(entries),
+			content: document.body.innerText,
+			errors: errorsOf(entries),
+			html: surface.container.innerHTML,
+			tree: await page.ariaTree(),
+			visibleContent: visibleTextOf({
+				elements: [...document.body.querySelectorAll("*")],
+				opacityOf: (element) => Number(getComputedStyle(element).opacity),
+				text: () => document.body.innerText
+			})
+		});
+	},
+	prepare: async () => {
+		await unmountHeld();
+		return { workDir: null };
+	},
+	row: {
+		group: "Terminal action",
+		name: ".render()",
+		probe: ".render("
+	},
+	verbs: [
+		...EVERY_SURFACE_VERBS,
+		...BROWSER_VERBS,
+		...PARENT_VERBS
+	]
+});
+//#endregion
+//#region src/specifications/component/viewport/page-viewport.adapter.ts
+/** Restored to the project's size when the test ends, so a narrow render never leaks. */
+const pageViewport = { size: async (size) => {
+	await setViewport(size);
+	afterThisTest(async () => {
+		await setViewport(providedViewport());
+	});
+	return {};
+} };
+//#endregion
+//#region src/specifications/component/viewport/viewport.capability.ts
+/** A chain stating none leaves the page at the project's size, unresized. */
+const viewport = defineCapability({
+	arm: async (size, adapters) => size === null ? void 0 : await adapters.viewport.size(size),
+	initial: null,
+	name: "viewport",
+	phase: 30,
+	reduce: (_stated, [size]) => size,
+	row: {
+		group: "Setup",
+		name: ".viewport()",
+		probe: ".viewport("
+	}
+});
+//#endregion
+//#region src/specifications/component/component.composition.ts
+const composition = {
+	actions: [render],
+	capabilities: [
+		clock$1,
+		intercept$1,
+		viewport,
+		wrap
+	],
+	options: {
+		clock: {
+			group: "Constructor option",
+			name: "clock",
+			probe: "clock:"
+		},
+		locale: {
+			group: "Constructor option",
+			name: "locale",
+			probe: "locale:"
+		},
+		root: {
+			group: "Constructor option",
+			name: "root",
+			probe: "root:"
+		},
+		timezone: {
+			group: "Constructor option",
+			name: "timezone",
+			probe: "timezone:"
+		},
+		viewport: {
+			group: "Constructor option",
+			name: "viewport",
+			probe: "viewport:"
+		},
+		vite: {
+			group: "Constructor option",
+			name: "vite",
+			probe: "vite:"
+		},
+		wrap: {
+			group: "Constructor option",
+			name: "wrap",
+			probe: "wrap:"
+		}
+	}
+};
+const componentDefinition = defineSpecification()({
+	...composition,
+	adapters: (_config) => ({
+		clock: pageClock,
+		network: mswWorker(afterThisTest),
+		page: vitestBrowserPage,
+		viewport: pageViewport
+	}),
+	locate: pageDirectory
+});
+//#endregion
+//#region lint/kit/project/dedent.ts
+function indentOf(line) {
+	return /^[\t ]*/u.exec(line)?.[0].length ?? 0;
+}
+/** A text opening on a line break loses that break, the closing line's whitespace and the shared indentation. */
+function dedent(text) {
+	if (!text.startsWith("\n")) return text;
+	const lines = text.slice(1).split("\n");
+	if (lines.at(-1)?.trim() === "") lines[lines.length - 1] = "";
+	const indents = lines.filter((line) => line.trim() !== "").map((line) => indentOf(line));
+	const common = indents.length === 0 ? 0 : Math.min(...indents);
+	return lines.map((line) => line.slice(common)).join("\n");
+}
+//#endregion
+//#region lint/kit/project/relative-path.ts
+function isRelativePath(value) {
+	return value.startsWith("./") || value.startsWith("../");
+}
+const DISK = Symbol.for("@jterrazz/test:disk");
+/** Name one file, by its path from the spec file. */
+function file(path) {
+	requireRelativePath("file", path);
+	if (path.endsWith("/")) {
+		const bare = path.replace(/\/+$/u, "");
+		throw new TypeError(refusal("disk-named-by-relative-path-at-runtime", {
+			fix: `name the directory with directory(${JSON.stringify(path)}), or the file without its /: file(${JSON.stringify(bare)})`,
+			found: `file(${JSON.stringify(path)}), a path ending in /, which is a directory's`
+		}));
+	}
+	return diskValue("file", path);
+}
+function diskValue(brand, path) {
+	const value = {
+		[DISK]: brand,
+		path
+	};
+	Object.defineProperty(value, Symbol.match, { value: () => {
+		throw new TypeError(refusal("one-verb-per-meaning", {
+			fix: `wrap the string to golden it, \`expect(text(value)).toMatch(${brand}(...))\`, or compare it to a value, \`toMatch('...')\``,
+			found: `toMatch(${brand}(${JSON.stringify(path)})) on a string, a value with no golden`
+		}));
+	} });
+	return Object.freeze(value);
+}
+/** Name one directory, by its path from the spec file, ending in `/`. */
+function directory(path) {
+	requireRelativePath("directory", path);
+	if (!path.endsWith("/")) throw new TypeError(refusal("disk-named-by-relative-path-at-runtime", {
+		fix: `end it in /: directory(${JSON.stringify(`${path}/`)}), or name a file with file(${JSON.stringify(path)})`,
+		found: `directory(${JSON.stringify(path)}), a path that does not end in /`
+	}));
+	return diskValue("directory", path);
+}
+function isDiskFile(value) {
+	return brandOf(value) === "file";
+}
+function isDiskDirectory(value) {
+	return brandOf(value) === "directory";
+}
+function isDiskTarget(value) {
+	return brandOf(value) !== void 0;
+}
+function brandOf(value) {
+	if (value === null || typeof value !== "object") return;
+	const brand = Reflect.get(value, DISK);
+	return brand === "file" || brand === "directory" ? brand : void 0;
+}
+function asRelative(path) {
+	const bare = typeof path === "string" ? path.replace(/^\/+/u, "") : "";
+	return `./${bare === "" ? "__expected__/output.txt" : bare}`;
+}
+function requireRelativePath(call, path) {
+	if (typeof path !== "string" || !isRelativePath(path)) throw new TypeError(refusal("disk-named-by-relative-path-at-runtime", {
+		fix: `start it with ./ or ../, from the spec file: ${call}('${asRelative(path)}')`,
+		found: `${call}(${JSON.stringify(path)}), a path that is not relative to the spec file`
+	}));
+}
+//#endregion
+//#region src/expectations/goldens/diff.ts
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const RESET = "\x1B[0m";
+const strictEquals = (expected, actual) => expected === actual;
+function renderLines(expectedLines, actualLines, equals) {
+	const rendered = [];
+	let marked = false;
+	for (let i = 0; i < Math.max(expectedLines.length, actualLines.length); i++) {
+		const exp = expectedLines[i];
+		const act = actualLines[i];
+		if (exp !== void 0 && act !== void 0 && equals(exp, act)) {
+			rendered.push(`  ${exp}`);
+			continue;
+		}
+		marked = true;
+		rendered.push(...exp === void 0 ? [] : [`${GREEN}- ${exp}${RESET}`], ...act === void 0 ? [] : [`${RED}+ ${act}${RESET}`]);
+	}
+	return {
+		marked,
+		rendered
+	};
+}
+/** `equals` is token-aware, so a matched `{{url}}` line shows as equal; if it marks nothing, the strict rendering is used. */
+function formatStdoutDiff(file, expected, actual, options) {
+	const lines = [
+		`Output mismatch (${file})`,
+		"",
+		`${GREEN}- Expected${RESET}`,
+		`${RED}+ Received${RESET}`,
+		""
+	];
+	const expectedLines = expected.split("\n");
+	const actualLines = actual.split("\n");
+	const first = renderLines(expectedLines, actualLines, options?.equals ?? strictEquals);
+	const rendered = first.marked ? first.rendered : renderLines(expectedLines, actualLines, strictEquals).rendered;
+	return [...lines, ...rendered].join("\n");
+}
+//#endregion
+//#region src/expectations/goldens/text-assertions.ts
+/** The golden's path carries its extension: the name IS the file. */
+function requireExtension(name, subject) {
+	if (!/\.[A-Za-z0-9]+$/u.test(name)) throw new Error(refusal({
+		fix: `name the file with its extension: file('./__expected__/help.txt')`,
+		found: `toMatch(file("${name}")) on ${subject}, a golden path with no extension`,
+		read: "docs/reference/assertions.md#one-verb-compares-a-whole-result-and-its-argument-says-where-the-expectation-lives",
+		why: "The extension is part of a golden's path."
+	}));
+}
+/** The diff judges each line through the same token grammar, so a matched token line shows as equal. */
+function compareStreamText(accessor, name, expected) {
+	const actual = accessor.text;
+	if (textEquals(expected, actual, accessor.captures)) return {
+		message: () => `expected ${accessor.streamName} not to match ${name}`,
+		pass: true
+	};
+	return {
+		message: () => formatStdoutDiff(name, expected, actual, { equals: (expectedLine, actualLine) => textEquals(expectedLine, actualLine, new CaptureScope(accessor.captures.workdir)) }),
+		pass: false
+	};
+}
+/** An empty stream is an empty text: `expect(stream.text).toBe('')`. */
+function emptyStreamRefusal(accessor) {
+	return new TypeError(refusal("one-verb-per-meaning", {
+		fix: `compare its text: expect(<result>.${accessor.streamName}.text).toBe('')`,
+		found: `toBeEmpty() on the stream "${accessor.streamName}": an empty stream is an empty text`
+	}));
+}
+const IN_PLACE = "the value in place";
+/** A stream is compared whole to a text in place; a RegExp matches a part, which is vitest's, on `.text`. */
+function streamValueRoute(subject, value) {
+	if (!(subject instanceof TextAccessor)) return;
+	return typeof value === "string" ? "whole" : new TypeError(refusal("one-verb-per-meaning", {
+		fix: `write the whole text in place, toMatch('...'), or match a part with vitest on its text: expect(<result>.${subject.streamName}.text).toMatch(...)`,
+		found: `toMatch(a ${value instanceof RegExp ? "RegExp" : typeof value}) on the stream "${subject.streamName}"`
+	}));
+}
+function compareStreamInPlace(accessor, expected) {
+	return compareStreamText(accessor, IN_PLACE, dedent(expected));
+}
+/** The name the golden comparison is registered under; no member access can spell it. */
+const GOLDEN_MATCHER = "@jterrazz/test:golden";
+const WHOLE_MATCHER = "@jterrazz/test:whole";
+function optionsOf(value) {
+	return value !== null && typeof value === "object" ? {
+		frozen: Reflect.get(value, "frozen") === true,
+		ordered: Reflect.get(value, "ordered") === true
+	} : void 0;
+}
+function directoryOf(location) {
+	const normalized = location.replace(/^file:\/\//u, "").replace(/[?#].*$/u, "");
+	return normalized.slice(0, normalized.lastIndexOf("/"));
+}
+const OWN_DIRECTORY = directoryOf(import.meta.url);
+const FRAME_LINE = /^\s*at\s/u;
+const FRAME_FILE = /at\s+(?:async\s+)?(?:.*?\s+)?\(?(?<file>(?:file:\/\/)?\/[^():]+|https?:\/\/.+?):\d+:\d+\)?\s*$/u;
+function frameDirectoryOf(line) {
+	const file = FRAME_FILE.exec(line)?.groups?.file;
+	return file === void 0 ? void 0 : directoryOf(file);
+}
+/** Every frame under `directory` is cut, not a leading run: vitest's plumbing sits above this router on the stack. */
+function cutFramesUnder(stack, directory) {
+	return stack.split("\n").filter((line) => !FRAME_LINE.test(line) || frameDirectoryOf(line) !== directory).join("\n");
+}
+function rethrowCut(error) {
+	if (error instanceof Error && error.stack !== void 0) error.stack = cutFramesUnder(error.stack, OWN_DIRECTORY);
+	throw error;
+}
+async function awaitedCut(result) {
+	try {
+		return await result;
+	} catch (error) {
+		return rethrowCut(error);
+	}
+}
+function routedThrough(route) {
+	let result;
+	try {
+		result = route();
+	} catch (error) {
+		return rethrowCut(error);
+	}
+	return result instanceof Promise ? awaitedCut(result) : result;
+}
+/** `file()`/`directory()` go to the golden, a value handed to a framework subject to the whole comparison, everything else to vitest untouched. */
+function matchThroughGolden(chai, routeValue) {
+	chai.util.overwriteMethod(chai.Assertion.prototype, "toMatch", (vitestToMatch) => function toMatch(...args) {
+		const golden = this[GOLDEN_MATCHER];
+		if (isDiskTarget(args[0]) && typeof golden === "function") return routedThrough(() => golden.apply(this, args));
+		const route = routeValue(chai.util.flag(this, "object"), args[0]);
+		if (route instanceof TypeError) throw route;
+		const whole = this[WHOLE_MATCHER];
+		if (route === "whole" && typeof whole === "function") {
+			const stack = (/* @__PURE__ */ new Error("toMatch call site")).stack ?? "";
+			const call = {
+				options: optionsOf(args[1]),
+				stack
+			};
+			return routedThrough(() => whole.call(this, args[0], call));
+		}
+		return vitestToMatch.apply(this, args);
+	});
+}
+//#endregion
+//#region src/expectations/in-place/update.ts
+const UPDATE_HINT = "Run with TEST_UPDATE=1 (or vitest -u) to create it.";
+const FROZEN_HINT = "This golden is `{ frozen }`: update mode never writes it. Write the file by hand, or drop `{ frozen }` for one TEST_UPDATE=1 run and put it back.";
+function missingHint(frozen) {
+	return frozen ? FROZEN_HINT : UPDATE_HINT;
+}
+//#endregion
+//#region src/expectations/tokens/update-merge.ts
+const ANY_LINE = /^\s*\{\{any\}\}\s*$/u;
+function anchorOf(lines, from, step) {
+	const side = step === 1 ? lines.slice(from + 1) : lines.slice(0, from).toReversed();
+	const at = side.findIndex((line) => line.trim() !== "" && !hasPlaceholders(line));
+	return at === -1 ? void 0 : {
+		line: String(side[at]),
+		offset: step * (at + 1)
+	};
+}
+const PREFIX = 20;
+function indexOfAnchor(lines, anchor, from) {
+	const exact = lines.indexOf(anchor, from);
+	if (exact !== -1 || anchor.length <= PREFIX) return exact;
+	const prefix = anchor.slice(0, PREFIX);
+	return lines.findIndex((line, index) => index >= from && line.startsWith(prefix));
+}
+function anyRuns(prevLines, actualLines) {
+	const runs = /* @__PURE__ */ new Map();
+	let cursor = 0;
+	for (const [index, line] of prevLines.entries()) {
+		if (!ANY_LINE.test(line)) continue;
+		const before = anchorOf(prevLines, index, -1);
+		const after = anchorOf(prevLines, index, 1);
+		let start = 0;
+		if (before !== void 0) {
+			const found = indexOfAnchor(actualLines, before.line, cursor);
+			if (found === -1) continue;
+			start = found - before.offset;
+		}
+		let end = actualLines.length;
+		if (after !== void 0) end = indexOfAnchor(actualLines, after.line, start) - after.offset + 1;
+		if (end > start) {
+			runs.set(start, {
+				end,
+				line
+			});
+			cursor = end;
+		}
+	}
+	return runs;
+}
+function withAnyRuns(previous, actual, merged) {
+	const runs = anyRuns(previous.split("\n"), actual.split("\n"));
+	const lines = merged.split("\n");
+	const kept = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const run = runs.get(index);
+		if (run === void 0) {
+			kept.push(String(lines[index]));
+			continue;
+		}
+		kept.push(run.line);
+		index = run.end - 1;
+	}
+	return kept.join("\n");
+}
+function mergeTextPreservingPlaceholders(previous, actual, scope) {
+	const merged = mergedLines(previous, actual, scope);
+	return previous === null ? merged : withAnyRuns(previous, actual, merged);
+}
+function mergedLines(previous, actual, scope) {
+	const substituted = scope.workdir === void 0 ? actual : actual.replaceAll(scope.workdir, "{{workdir}}");
+	if (previous === null) return substituted;
+	const prevLines = previous.split("\n");
+	const actualLines = substituted.split("\n");
+	const rawLines = actual.split("\n");
+	const consumed = /* @__PURE__ */ new Set();
+	const covers = (prevIndex, actualIndex) => {
+		const prev = String(prevLines[prevIndex]);
+		return hasPlaceholders(prev) && (textEquals(prev, String(actualLines[actualIndex]), new CaptureScope(scope.workdir)) || textEquals(prev, String(rawLines[actualIndex]), new CaptureScope(scope.workdir)));
+	};
+	const merged = actualLines.map(() => void 0);
+	for (const [index] of actualLines.entries()) if (covers(index, index)) {
+		merged[index] = prevLines[index];
+		consumed.add(index);
+	}
+	for (const [index, line] of actualLines.entries()) {
+		if (merged[index] !== void 0) continue;
+		for (const [prevIndex] of prevLines.entries()) {
+			if (consumed.has(prevIndex) || !covers(prevIndex, index)) continue;
+			merged[index] = prevLines[prevIndex];
+			consumed.add(prevIndex);
+			break;
+		}
+		merged[index] ??= line;
+	}
+	return merged.join("\n");
+}
+//#endregion
+//#region src/visitor/targets/as-written.ts
+const FUNCTION_NAME_OF_KIND = {
+	banner: "banner",
+	button: "button",
+	complementary: "complementary",
+	contentinfo: "contentinfo",
+	dialog: "dialog",
+	field: "field",
+	form: "form",
+	heading: "heading",
+	link: "link",
+	listitem: "listitem",
+	main: "main",
+	navigation: "navigation",
+	option: "option",
+	region: "region",
+	row: "row",
+	search: "search",
+	status: "status",
+	table: "table",
+	testId: "testId",
+	text: "content"
+};
+/** Spoken in the vocabulary the author wrote, never playwright's: an option appears only when the author stated one. */
+function asWritten(target) {
+	const bare = asWrittenUnscoped(target);
+	return target.scope ? `within(${asWritten(target.scope)}, ${bare})` : bare;
+}
+function asWrittenUnscoped(target) {
+	const args = [];
+	if (target.name !== void 0) args.push(JSON.stringify(target.name));
+	if (target.exact !== void 0) args.push(`{ exact: ${String(target.exact)} }`);
+	return `${FUNCTION_NAME_OF_KIND[target.kind]}(${args.join(", ")})`;
+}
+//#endregion
+//#region src/visitor/matching/landmark-of-tag.ts
+const LANDMARK_ELEMENTS = {
+	banner: "header",
+	complementary: "aside",
+	contentinfo: "footer",
+	form: "form",
+	main: "main",
+	navigation: "nav",
+	region: "section",
+	search: "search"
+};
+const LANDMARK_SELECTOR = Object.entries(LANDMARK_ELEMENTS).flatMap(([kind, tag]) => [tag, `[role="${kind}"]`]).join(", ");
+function isLandmarkKind(value) {
+	return Object.hasOwn(LANDMARK_ELEMENTS, value);
+}
+function landmarkOfTagOrRole(value) {
+	const kind = Object.entries(LANDMARK_ELEMENTS).find(([, tag]) => tag === value)?.[0] ?? value;
+	return isLandmarkKind(kind) ? kind : void 0;
+}
+//#endregion
+//#region src/visitor/matching/ambiguous.ts
+function landmarkOf(match) {
+	const kind = landmarkOfTagOrRole(match.context ?? "");
+	if (kind !== "region") return kind === void 0 ? void 0 : `${FUNCTION_NAME_OF_KIND[kind]}()`;
+	return match.contextName === void 0 ? void 0 : `${FUNCTION_NAME_OF_KIND.region}(${JSON.stringify(match.contextName)})`;
+}
+function formatMatch(match, index) {
+	const attribute = match.detail === void 0 ? "" : ` ${quoteDetail(match)}`;
+	const matchedOnLabel = match.accessibleName === void 0 || match.accessibleName === "" ? "" : `  named ${JSON.stringify(match.accessibleName)}`;
+	const context = match.context === void 0 || match.context === "" ? "" : `  in <${match.context}>`;
+	return `  ${index + 1}. <${match.tag}${attribute}>${match.text}</${match.tag}>${matchedOnLabel}${context}`;
+}
+function quoteDetail(match) {
+	return `${match.tag === "a" ? "href" : "name"}=${JSON.stringify(match.detail)}`;
+}
+function landmarkCounts(matches) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const match of matches) {
+		const landmark = landmarkOf(match);
+		if (landmark !== void 0) counts.set(landmark, (counts.get(landmark) ?? 0) + 1);
+	}
+	return [...counts].toSorted(([, a], [, b]) => a - b);
+}
+function formatFixes(target, matches) {
+	const fixes = [];
+	const landmarksThatCutTheSet = landmarkCounts(matches).filter(([, count]) => count < matches.length);
+	if (!target.scope) {
+		const [first, ...rest] = landmarksThatCutTheSet;
+		const alsoHere = rest.length > 0 ? `   [also here: ${rest.map(([name]) => name).join(", ")}]` : "";
+		fixes.push(first === void 0 ? `scope it       within(<a container holding only this one>, ${asWrittenUnscoped(target)})` : `scope it       within(${first[0]}, ${asWrittenUnscoped(target)})   [leaves ${first[1]} of ${matches.length}]${alsoHere}`);
+	}
+	if (target.exact === false) {
+		const remaining = matches.filter((match) => match.text === target.name).length;
+		if (remaining > 0 && remaining < matches.length) fixes.push(`exact name     ${asWrittenUnscoped({
+			...target,
+			exact: true
+		})}   [leaves ${remaining} of ${matches.length}]`);
+	}
+	fixes.push("other element  a heading(), button() or field() may name one thing where this does not");
+	return fixes;
+}
+function ambiguityError(options) {
+	const { target, fixes, lines, where } = options;
+	return new Error(refusal("target-matches-one-element", {
+		fix: ["designate one of them:", ...fixes.map((fix) => `  • ${fix}`)].join("\n"),
+		found: [`Ambiguous element: ${asWritten(target)} matched ${lines.length} elements on ${where}:`, ...lines].join("\n")
+	}));
+}
+function ambiguousTargetError(options) {
+	const { target, matches, url } = options;
+	return ambiguityError({
+		target,
+		fixes: formatFixes(target, matches),
+		lines: matches.map((match, index) => formatMatch(match, index)),
+		where: url
+	});
+}
+const CANDIDATE_LIMITS = {
+	landmarks: LANDMARK_SELECTOR,
+	limit: 10,
+	textLength: 80
+};
+/** Serialized into the page by playwright: it reads nothing from module scope. */
+function candidatesOf(nodes, { landmarks, limit, textLength }) {
+	const landmarkOf = (node) => {
+		const landmark = node.parentElement?.closest(landmarks);
+		if (landmark === null || landmark === void 0) return {
+			context: void 0,
+			contextName: void 0
+		};
+		const labelledBy = (landmark.getAttribute("aria-labelledby") ?? "").split(/\s+/u).filter((id) => id !== "").map((id) => document.querySelector(`#${CSS.escape(id)}`)?.textContent ?? "").join(" ");
+		const name = (landmark.getAttribute("aria-label") ?? labelledBy).replaceAll(/\s+/gu, " ").trim();
+		return {
+			context: landmark.getAttribute("role") ?? landmark.tagName.toLowerCase(),
+			contextName: name === "" ? void 0 : name
+		};
+	};
+	return nodes.slice(0, limit).map((node) => {
+		const detail = node.getAttribute("href") ?? node.getAttribute("name");
+		const text = (node.textContent ?? "").replaceAll(/\s+/gu, " ").trim().slice(0, textLength);
+		const label = node.getAttribute("aria-label")?.trim();
+		const { context, contextName } = landmarkOf(node);
+		return {
+			accessibleName: label === void 0 || label === "" || label === text ? void 0 : label,
+			context,
+			contextName,
+			detail: detail ?? void 0,
+			tag: node.tagName.toLowerCase(),
+			text
+		};
+	});
+}
+//#endregion
+//#region src/visitor/targets/roles.ts
+const stated = (options) => options?.exact === void 0 ? {} : { exact: options.exact };
+const named = (kind) => (name, options) => ({
+	kind,
+	name,
+	...stated(options)
+});
+const optionallyNamed = (kind) => (name, options) => ({
+	kind,
+	...name === void 0 ? {} : { name },
+	...stated(options)
+});
+/** A button (or element with the button role), by accessible name. */
+const button = named("button");
+/** A form field, by label. */
+const field = named("field");
+/** A heading, by accessible name. */
+const heading = named("heading");
+/** A link, by accessible name. */
+const link = named("link");
+/** An element containing the given text. */
+const content = named("text");
+/** An option of a select or listbox, by label; asserted by presence, since a collapsed select's options have no box. */
+const option = named("option");
+/** A modal or non-modal `<dialog>`, by accessible name. A closed one is absent. */
+const dialog = optionallyNamed("dialog");
+/** A live region announcing a result: `role="status"`, an `<output>`. */
+const status = optionallyNamed("status");
+/** A table, by its caption or accessible name. */
+const table = optionallyNamed("table");
+/** A row of a table or grid, by the text of its cells. */
+const row = optionallyNamed("row");
+/** An item of a list, by its text. */
+const listitem = optionallyNamed("listitem");
+/** The escape hatch: an element by `data-testid`. Prefer user-facing targets. */
+const testId = (id) => ({
+	kind: "testId",
+	name: id
+});
+//#endregion
+//#region src/visitor/targets/landmarks.ts
+/** The `banner` landmark: the page header. */
+const banner = optionallyNamed("banner");
+/** The `complementary` landmark: an `<aside>`, a sidebar. */
+const complementary = optionallyNamed("complementary");
+/** The `contentinfo` landmark: the page footer. */
+const contentinfo = optionallyNamed("contentinfo");
+/** The `form` landmark: a form carrying an accessible name. */
+const form = optionallyNamed("form");
+/** The `main` landmark: the primary content of the document. */
+const main = optionallyNamed("main");
+/** The `navigation` landmark: a `<nav>`. Name it when a page has several. */
+const navigation = optionallyNamed("navigation");
+/** The `region` landmark: a `<section>` carrying an accessible name. */
+const region = optionallyNamed("region");
+/** The `search` landmark. */
+const search = optionallyNamed("search");
+/** Restrict a target to the inside of another: `click(within(navigation(), link('Articles')))`. */
+const within = (scope, target) => ({
+	...target,
+	scope: target.scope ? within(scope, target.scope) : scope
+});
+function scopeChain(target) {
+	const chain = [];
+	for (let current = target; current; current = current.scope) chain.unshift(current);
+	return chain;
+}
+//#endregion
+//#region src/specifications/component/page/vitest-browser-dom.ts
+var vitest_browser_dom_exports = /* @__PURE__ */ __exportAll({
+	act: () => act,
+	ariaTree: () => ariaTree,
+	componentVerbs: () => componentVerbs,
+	locate: () => locate,
+	mountDom: () => mountDom,
+	mountReact: () => mountReact,
+	readGolden: () => readGolden,
+	writeGolden: () => writeGolden,
+	writeInPlaceText: () => writeInPlaceText
+});
+const FIELD_ROLES = [
+	"checkbox",
+	"combobox",
+	"radio",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"switch",
+	"textbox"
+];
+const SEARCH_ELEMENT = "css=search:not([role])";
+locators.extend({ getBySearchElement: () => SEARCH_ELEMENT });
+function answersSearch(scope) {
+	return "getBySearchElement" in scope;
+}
+function locateSearch(scope, target, exact) {
+	const byRole = target.name === void 0 ? scope.getByRole("search", { exact }) : scope.getByRole("search", {
+		exact,
+		name: target.name
+	});
+	if (!answersSearch(scope)) return byRole;
+	const byElement = scope.getBySearchElement();
+	return byRole.or(target.name === void 0 ? byElement : byElement.and(scope.getByLabelText(target.name, { exact })));
+}
+/** No `.first()`: taking the first match is the silent wrong-element bug `target-matches-one-element` prevents. */
+function locate(root, target) {
+	const scope = target.scope ? locate(root, target.scope) : root;
+	const exact = target.exact ?? true;
+	const name = target.name ?? "";
+	if (target.kind === "field") {
+		let field = scope.getByLabelText(name, { exact });
+		for (const role of FIELD_ROLES) field = field.or(scope.getByRole(role, {
+			exact,
+			name
+		}));
+		return field;
+	}
+	if (target.kind === "testId") return scope.getByTestId(name);
+	if (target.kind === "text") return scope.getByText(name, { exact });
+	if (target.kind === "search") return locateSearch(scope, target, exact);
+	return scope.getByRole(target.kind, target.name === void 0 ? { exact } : {
+		exact,
+		name: target.name
+	});
+}
+function ambiguousLevel(target) {
+	for (const level of scopeChain(target).slice(0, -1)) if (locate(page, level).elements().length > 1) return level;
+	return target;
+}
+/** The ambiguous level is found first: a scope matching several landmarks is the real fault. */
+async function act(target, action) {
+	const locator = locate(page, target);
+	try {
+		return await action(locator);
+	} catch (error) {
+		if (locator.elements().length <= 1) throw error;
+		const culprit = ambiguousLevel(target);
+		const matches = candidatesOf(locate(page, culprit).elements(), CANDIDATE_LIMITS);
+		const url = globalThis.location.href;
+		throw ambiguousTargetError({
+			target: culprit,
+			matches,
+			url
+		});
+	}
+}
+function byPresence(target) {
+	return target.kind === "option";
+}
+function valueOf(node) {
+	return node instanceof HTMLInputElement || node instanceof HTMLSelectElement || node instanceof HTMLTextAreaElement ? node.value : void 0;
+}
+function isGone(locator, target) {
+	const node = locator.query();
+	if (target.focused === true) return node !== document.activeElement;
+	if (target.disabled !== void 0) return node === null || node.matches(":disabled") !== target.disabled;
+	if (target.selected !== void 0) return node === null || node.matches(":checked") !== target.selected;
+	if (target.value !== void 0) return node === null || valueOf(node) !== target.value;
+	return node === null || (byPresence(target) ? false : !node.checkVisibility());
+}
+function remainingBudget() {
+	const current = TestRunner.getCurrentTest();
+	const started = (current?.result?.startTime ?? NaN) - performance.timeOrigin;
+	if (current === void 0 || Number.isNaN(started)) return;
+	return Math.max(current.timeout - (performance.now() - started) - 100, 0);
+}
+function polling(probe, message) {
+	const timeout = remainingBudget();
+	return expect.poll(probe, {
+		message,
+		...timeout === void 0 ? {} : { timeout }
+	});
+}
+function keystroke(key) {
+	return key.length > 1 ? `{${key}}` : key;
+}
+async function seen(locator, target) {
+	if (target.focused === true) await expect.element(locator).toHaveFocus();
+	else if (target.disabled === true) await expect.element(locator).toBeDisabled();
+	else if (target.disabled === false) await expect.element(locator).toBeEnabled();
+	else if (target.selected !== void 0) await polling(() => locator.query()?.matches(":checked") === true, `${asWritten(target)} is not the selected one`).toBe(target.selected);
+	else if (target.value !== void 0) await expect.element(locator).toHaveValue(target.value);
+	else if (byPresence(target)) await expect.element(locator).toBeInTheDocument();
+	else await expect.element(locator).toBeVisible();
+}
+function componentVerbs(surface) {
+	return {
+		check: async (target) => {
+			await act(target, async (locator) => {
+				const node = locator.element();
+				if (!(node instanceof HTMLInputElement) || !node.checked) await locator.click();
+			});
+		},
+		click: async (target) => {
+			await act(target, async (locator) => {
+				await locator.click();
+			});
+		},
+		fill: async (target, value) => {
+			await act(target, async (locator) => {
+				await locator.fill(value);
+			});
+		},
+		gone: async (target) => {
+			await act(target, async (locator) => {
+				await polling(() => isGone(locator, target), `${asWritten(target)} is still on the screen`).toBeTruthy();
+			});
+		},
+		hover: async (target) => {
+			await act(target, async (locator) => {
+				await locator.hover();
+			});
+		},
+		press: async (key) => {
+			await userEvent.keyboard(keystroke(key));
+		},
+		rerender: surface.rerender,
+		see: async (target) => {
+			await act(target, async (locator) => {
+				await seen(locator, target);
+			});
+		},
+		select: async (target, option) => {
+			await act(target, async (locator) => {
+				await locator.selectOptions(option);
+			});
+		},
+		unmount: surface.unmount
+	};
+}
+async function ariaTree() {
+	return await commands.ariaTree();
+}
+async function readGolden(name) {
+	return await commands.goldenRead(name);
+}
+async function writeGolden(name, content) {
+	return await commands.goldenWrite(name, content);
+}
+async function writeInPlaceText(stack, text) {
+	return await commands.inPlaceWrite(stack, text);
+}
+async function mountReact(ui) {
+	let render;
+	try {
+		({render} = await import("vitest-browser-react"));
+	} catch (error) {
+		throw new Error(refusal("seam-is-an-optional-peer", {
+			fix: "npm install -D vitest-browser-react react react-dom",
+			found: `component.render(<X />) requires \`vitest-browser-react\` and \`react\`, and they do not load (${String(error)})`
+		}), { cause: error });
+	}
+	const rendered = await render(ui);
+	return {
+		container: rendered.container,
+		rerender: rendered.rerender,
+		unmount: rendered.unmount
+	};
+}
+/** The function may return its own teardown; no react is loaded. */
+function mountDom(mount) {
+	const container = document.createElement("div");
+	document.body.append(container);
+	const teardown = mount(container);
+	return {
+		container,
+		rerender: () => {
+			throw new Error(refusal({
+				fix: "render the DOM function again, in a new render()",
+				found: "rerender() on a DOM function",
+				read: "docs/guides/component-specs.md#the-chain",
+				why: "rerender() replaces a React tree, what a parent does with new props."
+			}));
+		},
+		unmount: async () => {
+			teardown?.();
+			container.remove();
+		}
+	};
+}
+//#endregion
+//#region src/specifications/component/golden/golden.ts
+function updating() {
+	return inject("update") === true;
+}
+async function matchGolden(accessor, name, frozen) {
+	requireExtension(name, "stream");
+	const actual = accessor.text;
+	const stored = await readGolden(name);
+	if (stored === null) {
+		if (updating() && !frozen) {
+			const path = await writeGolden(name, actual);
+			return {
+				message: () => `wrote ${path}`,
+				pass: true
+			};
+		}
+		return {
+			message: () => `${accessor.streamName} fixture "${name}" does not exist beside this test.\n${missingHint(frozen)}`,
+			pass: false
+		};
+	}
+	const comparison = compareStreamText(accessor, name, stored);
+	if (!comparison.pass && updating() && !frozen) {
+		await writeGolden(name, actual);
+		return {
+			message: () => `updated ${name}`,
+			pass: true
+		};
+	}
+	return comparison;
+}
+async function toMatchGolden(received, expected, options) {
+	if (!isDiskFile(expected)) throw new TypeError(refusal("one-verb-per-meaning", {
+		fix: "compare the tree under node, or a captured text of the page to its file(...)",
+		found: "toMatch(directory(...)) in a page, which has no working directory"
+	}));
+	if (!(received instanceof TextAccessor)) throw new TypeError(refusal("one-verb-per-meaning", {
+		fix: `compare a captured text (result.tree, result.html, text(...)) to file(${JSON.stringify(expected.path)})`,
+		found: `toMatch(file(${JSON.stringify(expected.path)})) in a page, on a subject that is no captured text`
+	}));
+	return await matchGolden(received, expected.path, options?.frozen === true);
+}
+async function toMatchWhole(received, expected, call) {
+	if (!(received instanceof TextAccessor) || typeof expected !== "string") throw new TypeError(refusal("one-verb-per-meaning", {
+		fix: "compare a captured text (result.tree, result.html, text(...)) to a text written in place",
+		found: "toMatch(<value>) in a page, on a subject or a value that is no text"
+	}));
+	const comparison = compareStreamInPlace(received, expected);
+	const frozen = call?.options?.frozen === true;
+	if (comparison.pass || !updating() || frozen || this.isNot === true) return comparison;
+	const previous = dedent(expected);
+	const merged = mergeTextPreservingPlaceholders(previous === "" ? null : previous, received.text, received.captures);
+	const where = await writeInPlaceText(call?.stack ?? "", merged);
+	return {
+		message: () => `updated the value in place at ${where}`,
+		pass: true
+	};
+}
+async function toBeEmpty(received) {
+	return await Promise.reject(received instanceof TextAccessor ? emptyStreamRefusal(received) : new TypeError(refusal("one-verb-per-meaning", {
+		fix: "compare the stream's text: expect(<result>.<stream>.text).toBe('')",
+		found: "toBeEmpty() in a page, which holds no table"
+	})));
+}
+let registered = false;
+/** Idempotent; the browser entry's import is the registration. */
+function registerBrowserMatchers() {
+	if (registered) return;
+	registered = true;
+	expect.extend({
+		[GOLDEN_MATCHER]: toMatchGolden,
+		[WHOLE_MATCHER]: toMatchWhole,
+		toBeEmpty
+	});
+	matchThroughGolden(chai, streamValueRoute);
+}
+//#endregion
+//#region src/specifications/component/component.face.browser.ts
+/** The component chain, opened once for the page; shared configuration is the project's. */
+const component = componentDefinition.open({});
+registerBrowserMatchers();
+//#endregion
+//#region src/stubs/kinds/http-filter.ts
+function rawOf(body) {
+	return typeof body === "string" ? body : JSON.stringify(body ?? "");
+}
+function matchesBody(body, expected) {
+	if (typeof expected === "string") return rawOf(body).includes(expected);
+	if (expected instanceof RegExp) return expected.test(rawOf(body));
+	return structuralSubset(expected, body, new CaptureScope());
+}
+function matchesEntries(expected, lookup) {
+	return Object.entries(expected).every(([key, value]) => {
+		const actual = lookup(key);
+		if (actual === void 0) return false;
+		return value instanceof RegExp ? value.test(actual) : actual === value;
+	});
+}
+function buildMatch(filter) {
+	if (!filter) return;
+	return (request) => {
+		if (filter.body !== void 0 && !matchesBody(request.body, filter.body)) return false;
+		if (filter.headers && !matchesEntries(filter.headers, (key) => request.headers[key.toLowerCase()])) return false;
+		if (filter.query) {
+			let params;
+			try {
+				params = new URL(request.url, "http://stub.invalid").searchParams;
+			} catch {
+				return false;
+			}
+			if (!matchesEntries(filter.query, (key) => params.get(key) ?? void 0)) return false;
+		}
+		return true;
+	};
+}
+function absentHeadersOf(filter = {}) {
+	const absent = filter.without?.headers?.map((name) => name.toLowerCase()) ?? [];
+	if (absent.length === 0) return;
+	const required = new Set(Object.keys(filter.headers ?? {}).map((name) => name.toLowerCase()));
+	const contradicted = absent.filter((name) => required.has(name));
+	if (contradicted.length > 0) {
+		const names = contradicted.join(", ");
+		throw new Error(refusal({
+			fix: `state ${names} in \`headers\` or in \`without.headers\`, never both`,
+			found: `an http stub filter that both requires and forbids the header(s) ${names}`,
+			read: "docs/reference/stubs.md#http-any-url",
+			why: "A header both required and absent matches no request, so the stub could never fire."
+		}));
+	}
+	return absent;
+}
+//#endregion
+//#region src/stubs/kinds/http.ts
+function wrapJson(data) {
+	return {
+		status: 200,
+		body: data
+	};
+}
+const TEXT_CONTENT_TYPE = "text/plain; charset=utf-8";
+const STREAM_CONTENT_TYPE = "application/octet-stream";
+const SSE_CONTENT_TYPE = "text/event-stream";
+function frameEvent(event) {
+	const lines = [];
+	if (event.event !== void 0) lines.push(`event: ${event.event}`);
+	if (event.id !== void 0) lines.push(`id: ${event.id}`);
+	if (event.retry !== void 0) lines.push(`retry: ${event.retry}`);
+	const payload = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
+	for (const line of payload.split("\n")) lines.push(`data: ${line}`);
+	return `${lines.join("\n")}\n\n`;
+}
+function declare(method, url, filter) {
+	const absentHeaders = absentHeadersOf(filter);
+	return {
+		...absentHeaders && { absentHeaders },
+		adapter: "http",
+		match: buildMatch(filter),
+		method,
+		url,
+		wrap: wrapJson
+	};
+}
+/** Generic HTTP stub helpers: an absolute URL, or a path form (`/articles/{{uuid}}`) matching any origin. */
+const http = {
+	any(url, filter) {
+		return declare("*", url, filter);
+	},
+	delete(url, filter) {
+		return declare("DELETE", url, filter);
+	},
+	get(url, filter) {
+		return declare("GET", url, filter);
+	},
+	patch(url, filter) {
+		return declare("PATCH", url, filter);
+	},
+	post(url, filter) {
+		return declare("POST", url, filter);
+	},
+	put(url, filter) {
+		return declare("PUT", url, filter);
+	},
+	/** A stub the chain fails on if the subject reaches its route: `required` with `times: 0`. */
+	never(request) {
+		return {
+			request,
+			required: true,
+			response: {
+				status: 418,
+				body: { error: `@jterrazz/test: ${describeRoute(request)} is declared never requested` }
+			},
+			times: 0
+		};
+	},
+	/** Response: a body-less reply (204 by default). */
+	empty(status = 204) {
+		return {
+			status,
+			body: null
+		};
+	},
+	/** Response: an error status. Without a body, `{ error: 'HTTP <status>' }`. */
+	error(status, body) {
+		return {
+			status,
+			body: body === void 0 ? { error: `HTTP ${status}` } : body
+		};
+	},
+	/** Response: a JSON body (200 by default). */
+	json(body, init) {
+		return {
+			status: init?.status ?? 200,
+			body,
+			delay: init?.delay,
+			headers: init?.headers
+		};
+	},
+	/** Response: no response at all; `fetch` rejects, as when no server is running. */
+	unreachable() {
+		return {
+			body: null,
+			transport: "network-error"
+		};
+	},
+	/** Response: a body that arrives in pieces, written in order. */
+	stream(chunks, init) {
+		return {
+			status: init?.status ?? 200,
+			body: {
+				chunks: [...chunks],
+				contentType: init?.contentType ?? STREAM_CONTENT_TYPE,
+				delayBetweenChunks: init?.delay ?? 0,
+				kind: STREAM_BODY
+			},
+			headers: init?.headers
+		};
+	},
+	/** Response: a server-sent event stream, served as `text/event-stream`. */
+	sse(events, init) {
+		return {
+			status: init?.status ?? 200,
+			body: {
+				chunks: events.map(frameEvent),
+				contentType: SSE_CONTENT_TYPE,
+				delayBetweenChunks: init?.delay ?? 0,
+				kind: STREAM_BODY
+			},
+			headers: {
+				"cache-control": "no-cache",
+				...init?.headers
+			}
+		};
+	},
+	/** Response: a text body, served as `text/plain` (200 by default). */
+	text(body, init) {
+		return {
+			status: init?.status ?? 200,
+			body,
+			delay: init?.delay,
+			headers: {
+				"content-type": TEXT_CONTENT_TYPE,
+				...init?.headers
+			}
+		};
+	}
+};
+//#endregion
+//#region src/stubs/kinds/text-filter.ts
+function matchesText(filter, actual) {
+	if (filter === void 0) return true;
+	if (typeof filter === "string") return actual === filter;
+	if (filter instanceof RegExp) return filter.test(actual);
+	return structuralEquals(filter, actual, new CaptureScope());
+}
+/** A field of a request body read as JSON: absent wherever the body is not an object holding it. */
+function fieldOf(value, key) {
+	return isRecord(value) ? value[key] : void 0;
+}
+const listOf = (value) => Array.isArray(value) ? value : [];
+const textOf = (value) => typeof value === "string" ? value : "";
+/** The content of the first message of `role`, as text: a structured content is its JSON. */
+function messageText(messages, role) {
+	const content = fieldOf(listOf(messages).find((message) => fieldOf(message, "role") === role), "content");
+	return content === void 0 || typeof content === "string" ? textOf(content) : JSON.stringify(content);
+}
+const namesOf = (tools, read) => listOf(tools).map((tool) => textOf(read(tool))).filter((name) => name !== "");
+//#endregion
+//#region src/stubs/kinds/anthropic.ts
+const ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+function matchesFilter(body, filter) {
+	const names = namesOf(fieldOf(body, "tools"), (tool) => fieldOf(tool, "name"));
+	return matchesText(filter.model, textOf(fieldOf(body, "model"))) && matchesText(filter.system, textOf(fieldOf(body, "system"))) && matchesText(filter.user, messageText(fieldOf(body, "messages"), "user")) && (filter.tools?.every((tool) => names.includes(tool)) ?? true);
+}
+function buildReply(data) {
+	return {
+		status: 200,
+		body: {
+			id: "msg-test",
+			type: "message",
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: typeof data === "string" ? data : JSON.stringify(data)
+			}],
+			model: "claude-sonnet-4-20250514",
+			stop_reason: "end_turn",
+			usage: {
+				input_tokens: 10,
+				output_tokens: 10
+			}
+		}
+	};
+}
+function streamEvents(pieces) {
+	return [
+		{
+			type: "message_start",
+			message: {
+				id: "msg-test",
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: "claude-sonnet-4-20250514",
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: 10,
+					output_tokens: 1
+				}
+			}
+		},
+		{
+			type: "content_block_start",
+			index: 0,
+			content_block: {
+				type: "text",
+				text: ""
+			}
+		},
+		{ type: "ping" },
+		...pieces.map((text) => ({
+			type: "content_block_delta",
+			index: 0,
+			delta: {
+				type: "text_delta",
+				text
+			}
+		})),
+		{
+			type: "content_block_stop",
+			index: 0
+		},
+		{
+			type: "message_delta",
+			delta: {
+				stop_reason: "end_turn",
+				stop_sequence: null
+			},
+			usage: { output_tokens: 10 }
+		},
+		{ type: "message_stop" }
+	].map((data) => ({
+		data,
+		event: data.type
+	}));
+}
+/** Anthropic API stub helpers. */
+const anthropic = {
+	/** Match Messages API calls, optionally through a gateway URL; a string filter is exact equality. */
+	messages(filter, url) {
+		return {
+			adapter: "anthropic",
+			method: "POST",
+			url: url ?? ANTHROPIC_MESSAGES_URL,
+			match: filter ? ({ body }) => matchesFilter(body, filter) : void 0,
+			wrap(data) {
+				if (isRecord(data)) return {
+					status: 200,
+					body: data
+				};
+				return buildReply(data);
+			}
+		};
+	},
+	/** A stub the chain fails on if the subject reaches this endpoint: `http.never()`. */
+	never(request) {
+		return http.never(request);
+	},
+	/** Response: data wrapped in the Messages format. */
+	reply(data) {
+		return buildReply(data);
+	},
+	/** Response: the text streamed as server-sent events, one `text_delta` per piece. */
+	stream(pieces, init) {
+		return http.sse(streamEvents(pieces), { delay: init?.delay ?? 0 });
+	},
+	/** Response: return an Anthropic error. */
+	error(status, message) {
+		return {
+			status,
+			body: {
+				type: "error",
+				error: {
+					type: status === 429 ? "rate_limit_error" : "api_error",
+					message: message ?? `Anthropic error (${status})`
+				}
+			}
+		};
+	},
+	/** Response: simulate a timeout. */
+	timeout() {
+		return {
+			status: 200,
+			body: {},
+			delay: 3e4
+		};
+	}
+};
+//#endregion
+//#region src/stubs/kinds/openai.ts
+const OPENAI_CHAT_URL = "https://api.openai.com/v1/chat/completions";
+const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
+function matchesChatFilter(body, filter) {
+	const messages = fieldOf(body, "messages");
+	const names = namesOf(fieldOf(body, "tools"), (tool) => fieldOf(fieldOf(tool, "function"), "name"));
+	return matchesText(filter.model, textOf(fieldOf(body, "model"))) && matchesText(filter.system, messageText(messages, "system")) && matchesText(filter.user, messageText(messages, "user")) && (filter.tools?.every((tool) => names.includes(tool)) ?? true) && (filter.temperature === void 0 || fieldOf(body, "temperature") === filter.temperature);
+}
+function matchesResponsesFilter(body, filter) {
+	const input = fieldOf(body, "input");
+	const instructions = textOf(fieldOf(body, "instructions"));
+	const userText = listOf(input).filter((message) => fieldOf(message, "role") === "user").map((message) => {
+		const content = fieldOf(message, "content");
+		return typeof content === "string" ? content : JSON.stringify(content);
+	}).join(" ");
+	const names = namesOf(fieldOf(body, "tools"), (tool) => fieldOf(tool, "name") ?? fieldOf(fieldOf(tool, "function"), "name"));
+	return matchesText(filter.model, textOf(fieldOf(body, "model"))) && matchesText(filter.system, instructions === "" ? messageText(input, "system") : instructions) && matchesText(filter.user, userText) && (filter.tools?.every((tool) => names.includes(tool)) ?? true);
+}
+function buildChatReply(data) {
+	const content = typeof data === "string" ? data : JSON.stringify(data);
+	return {
+		status: 200,
+		body: {
+			id: "chatcmpl-test",
+			object: "chat.completion",
+			created: Math.floor(Date.now() / 1e3),
+			model: "gpt-4o-test",
+			choices: [{
+				index: 0,
+				message: {
+					role: "assistant",
+					content
+				},
+				finish_reason: "stop"
+			}],
+			usage: {
+				prompt_tokens: 10,
+				completion_tokens: 10,
+				total_tokens: 20
+			}
+		}
+	};
+}
+function responsesEnvelope(text, usage = DEFAULT_USAGE) {
+	return {
+		id: "resp-test",
+		object: "response",
+		created_at: Math.floor(Date.now() / 1e3),
+		model: "gpt-4o-test",
+		output: [{
+			type: "message",
+			id: "msg-test",
+			role: "assistant",
+			content: [{
+				type: "output_text",
+				text,
+				annotations: []
+			}]
+		}],
+		usage: {
+			input_tokens: usage.promptTokens,
+			output_tokens: usage.completionTokens,
+			total_tokens: usage.promptTokens + usage.completionTokens
+		}
+	};
+}
+function buildResponsesReply(data) {
+	return {
+		status: 200,
+		body: responsesEnvelope(typeof data === "string" ? data : JSON.stringify(data))
+	};
+}
+const DEFAULT_USAGE = {
+	completionTokens: 10,
+	promptTokens: 10
+};
+function chatStreamEvents(pieces, usage) {
+	const created = Math.floor(Date.now() / 1e3);
+	const chunk = (delta, finishReason) => ({ data: {
+		id: "chatcmpl-test",
+		object: "chat.completion.chunk",
+		created,
+		model: "gpt-4o-test",
+		choices: [{
+			index: 0,
+			delta,
+			logprobs: null,
+			finish_reason: finishReason
+		}]
+	} });
+	return [
+		chunk({
+			role: "assistant",
+			content: ""
+		}, null),
+		...pieces.map((piece) => chunk({ content: piece }, null)),
+		chunk({}, "stop"),
+		...usage === void 0 ? [] : [{ data: {
+			id: "chatcmpl-test",
+			object: "chat.completion.chunk",
+			created,
+			model: "gpt-4o-test",
+			choices: [],
+			usage: {
+				prompt_tokens: usage.promptTokens,
+				completion_tokens: usage.completionTokens,
+				total_tokens: usage.promptTokens + usage.completionTokens
+			}
+		} }],
+		{ data: "[DONE]" }
+	];
+}
+function responsesStreamEvents(pieces, usage) {
+	const text = pieces.join("");
+	const part = {
+		type: "output_text",
+		text,
+		annotations: []
+	};
+	const item = {
+		id: "msg-test",
+		type: "message",
+		role: "assistant"
+	};
+	const done = {
+		...item,
+		status: "completed",
+		content: [part]
+	};
+	const completed = {
+		...responsesEnvelope(text, usage),
+		status: "completed"
+	};
+	const at = {
+		item_id: "msg-test",
+		output_index: 0,
+		content_index: 0
+	};
+	return [
+		{
+			type: "response.created",
+			response: {
+				...completed,
+				status: "in_progress",
+				output: [],
+				usage: null
+			}
+		},
+		{
+			type: "response.output_item.added",
+			output_index: 0,
+			item: {
+				...item,
+				status: "in_progress",
+				content: []
+			}
+		},
+		{
+			type: "response.content_part.added",
+			...at,
+			part: {
+				...part,
+				text: ""
+			}
+		},
+		...pieces.map((delta) => ({
+			type: "response.output_text.delta",
+			...at,
+			delta
+		})),
+		{
+			type: "response.output_text.done",
+			...at,
+			text
+		},
+		{
+			type: "response.content_part.done",
+			...at,
+			part
+		},
+		{
+			type: "response.output_item.done",
+			output_index: 0,
+			item: done
+		},
+		{
+			type: "response.completed",
+			response: {
+				...completed,
+				output: [done]
+			}
+		}
+	].map((body, index) => ({
+		data: {
+			...body,
+			sequence_number: index
+		},
+		event: body.type
+	}));
+}
+/** OpenAI API stub helpers. */
+const openai = {
+	/** Match Chat Completions calls, at `url` where the client reaches another host; a string filter is exact equality, a RegExp or `match.includes` loosens it. */
+	chat(filter, url) {
+		return {
+			adapter: "openai",
+			method: "POST",
+			url: url ?? OPENAI_CHAT_URL,
+			match: filter ? ({ body }) => matchesChatFilter(body, filter) : void 0,
+			wrap: buildChatReply
+		};
+	},
+	/** Match Responses API calls; a JSON file is wrapped in the Responses envelope. */
+	responses(filter, url) {
+		return {
+			adapter: "openai",
+			method: "POST",
+			url: url ?? OPENAI_RESPONSES_URL,
+			match: filter ? ({ body }) => matchesResponsesFilter(body, filter) : void 0,
+			wrap: buildResponsesReply
+		};
+	},
+	/** A stub the chain fails on if the subject reaches this endpoint: `http.never()`. */
+	never(request) {
+		return http.never(request);
+	},
+	/** Response: data wrapped in the Chat Completions format. */
+	reply(data) {
+		return buildChatReply(data);
+	},
+	/** Response: the text streamed as server-sent events; `api` picks Chat Completions (default) or Responses. */
+	stream(pieces, init) {
+		const events = init?.api === "responses" ? responsesStreamEvents(pieces, init.usage) : chatStreamEvents(pieces, init?.usage);
+		return http.sse(events, { delay: init?.delay ?? 0 });
+	},
+	/** Response: return an OpenAI error. */
+	error(status, message) {
+		return {
+			status,
+			body: { error: {
+				message: message ?? `OpenAI error (${status})`,
+				type: status === 429 ? "rate_limit_error" : "api_error",
+				code: status === 429 ? "rate_limit_exceeded" : null
+			} }
+		};
+	},
+	/** Response: return malformed content. */
+	malformed(content) {
+		return buildChatReply(content);
+	},
+	/** Response: simulate a timeout. */
+	timeout() {
+		return {
+			status: 200,
+			body: {},
+			delay: 3e4
+		};
+	}
+};
+//#endregion
+//#region src/stubs/intercept/intercept.ts
+function isOptions(value) {
+	return isRecord(value) && "origin" in value;
+}
+function resolveRelativeAgainst(origin) {
+	let base;
+	try {
+		base = new URL(origin);
+	} catch {
+		throw new Error(refusal({
+			fix: "state an absolute URL: intercept(stubs, { origin: 'http://console.test' })",
+			found: `intercept(): \`origin\` is \`${origin}\`, not an absolute URL`,
+			read: "docs/reference/stubs.md#intercept-the-same-double-with-no-chain",
+			why: "`origin` states where a relative request resolves, so it is an absolute URL."
+		}));
+	}
+	return () => {
+		const underlying = globalThis.fetch;
+		globalThis.fetch = async (input, init) => typeof input === "string" ? await underlying(new URL(input, base).toString(), init) : await underlying(input, init);
+		return () => {
+			globalThis.fetch = underlying;
+		};
+	};
+}
+function interceptThrough(register) {
+	async function intercept(requestOrStubs, maybeResponseOrOptions, maybeOptions) {
+		const options = isOptions(maybeOptions) ? maybeOptions : isOptions(maybeResponseOrOptions) ? maybeResponseOrOptions : void 0;
+		const stubs = declared("intercept", requestOrStubs, isOptions(maybeResponseOrOptions) ? void 0 : maybeResponseOrOptions);
+		if (stubs.length === 0) throw new Error(refusal({
+			fix: "declare at least one stub, or drop the intercept: a subject with no network needs none",
+			found: "intercept(), and the list of stubs is empty",
+			read: "docs/reference/stubs.md#intercept-the-same-double-with-no-chain",
+			why: "An empty list guards nothing."
+		}));
+		const installOrigin = options?.origin === void 0 ? void 0 : resolveRelativeAgainst(options.origin);
+		const registration = await register(stubs);
+		const restoreOrigin = installOrigin?.();
+		return { [Symbol.asyncDispose]: async () => {
+			restoreOrigin?.();
+			const violation = registration.violation();
+			registration.cleanup();
+			if (violation) throw violation;
+		} };
+	}
+	return intercept;
+}
+//#endregion
+//#region src/stubs/delivery/browser-page/intercept.ts
+/** The module-scope network double, on msw's worker. */
+const intercept = interceptThrough(registerWorkerStubs);
+//#endregion
+//#region src/disk/packed.ts
+const PACKED = Symbol.for("@jterrazz/test:packed");
+/** Name the package a consumer installs: the project the spec belongs to, or the package a directory holds, packed as `npm pack` packs it. */
+function packed(source) {
+	return Object.freeze({
+		[PACKED]: true,
+		path: isDiskDirectory(source) ? source.path : null
+	});
+}
+//#endregion
+//#region src/clock/clock.ts
+function take(method, options) {
+	if (vi.isFakeTimers()) throw new Error(refusal({
+		fix: "end the first scope before taking another, or state the instant on the chain (`.clock(iso)`) rather than around it",
+		found: `clock.${method}(), and a clock is already pinned`,
+		read: "docs/reference/time-and-doubles.md#the-clock",
+		why: "One clock per test: ending a nested scope would end the outer one too."
+	}));
+	vi.useFakeTimers(options);
+	return { [Symbol.dispose]: () => {
+		vi.useRealTimers();
+	} };
+}
+/** The one time primitive (`no-sampled-value-in-expectation`): `at()` pins the calendar, `run()` the scheduler too. */
+const clock = {
+	/** Move the pinned clock forward; under `clock.run` fire what came due. Refused with no clock taken. */
+	async advance(ms) {
+		if (!vi.isFakeTimers()) throw new Error(refusal({
+			fix: "take one first: `using _ = clock.at('<iso>')` (the calendar) or `using _ = clock.run()` (the scheduler)",
+			found: "clock.advance(), and no clock is pinned",
+			read: "docs/reference/time-and-doubles.md#the-clock",
+			why: "Only a pinned clock moves: the real one holds no time of the test's to advance."
+		}));
+		await vi.advanceTimersByTimeAsync(ms);
+	},
+	/** Pin `Date` at `iso` for the current scope; the scheduler stays real. */
+	at(iso) {
+		return take("at", {
+			now: instantOf(iso, (value) => `clock.at(${value})`),
+			toFake: ["Date"]
+		});
+	},
+	/** Take the scheduler as well as the calendar; `clock.advance` makes timers due. */
+	run(iso) {
+		return take("run", iso === void 0 ? {} : { now: instantOf(iso, (value) => `clock.run(${value})`) });
+	}
+};
+//#endregion
+//#region src/mocks/mock-of.ts
+function mockOf(options) {
+	return options?.deep === false ? mock() : mockDeep();
+}
+//#endregion
+//#region src/visitor/targets/modifiers.ts
+/** Where the keyboard is: `see(focused(button('Open')))`. */
+const focused = (target) => ({
+	...target,
+	focused: true
+});
+/** The element refuses input: `see(disabled(button('Delete')))`. */
+const disabled = (target) => ({
+	...target,
+	disabled: true
+});
+/** The other direction of {@link disabled}: the element takes input. */
+const enabled = (target) => ({
+	...target,
+	disabled: false
+});
+/** The option the field is on: `see(selected(option('LinkedIn')))`. */
+const selected = (target) => ({
+	...target,
+	selected: true
+});
+/** What the field holds, read from its live value: `see(valued(field('Title'), '...'))`. */
+const valued = (target, value) => ({
+	...target,
+	value
+});
+//#endregion
+//#region src/expectations/text/text-subject.browser.ts
+/** `text()` in a page: no anchor, since the golden commands read the test's path server-side. */
+function text(value) {
+	return new TextAccessor(value, "text", "");
+}
+//#endregion
+//#region src/expectations/conditions/required.ts
+/** The value, or a failure naming what was missing and why it mattered. */
+function required(value, why) {
+	if (value === null || value === void 0) throw new Error(refusal({
+		fix: "state it in the Given, or assert on what the subject actually produced",
+		found: `required(): ${why}, got ${value === null ? "null" : "undefined"}`,
+		read: "docs/reference/assertions.md#two-helpers-that-are-not-matchers",
+		why: "`required()` answers a present value, and `null` and `undefined` are the two it refuses."
+	}));
+	return value;
+}
+//#endregion
+//#region src/expectations/conditions/wait-until.ts
+const DEFAULT_TIMEOUT_MS = 5e3;
+const DEFAULT_INTERVAL_MS = 50;
+/** Wait until a condition holds; measured on `performance.now()`, so `clock.at()` cannot freeze it. Under `clock.run()` it never wakes: use `clock.advance()`. */
+async function waitUntil(predicate, options = {}) {
+	const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+	if (await untilDeadline(async () => await predicate() || void 0, {
+		interval: options.interval ?? DEFAULT_INTERVAL_MS,
+		timeout
+	}) === void 0) throw new Error(refusal({
+		fix: "raise the budget if the wait is legitimate, or wait on what actually changes",
+		found: `waitUntil(): ${options.why ?? "the condition"} did not hold within ${timeout}ms`,
+		read: "docs/reference/assertions.md#two-helpers-that-are-not-matchers",
+		why: "`waitUntil()` waits on a condition, within a budget."
+	}));
+}
+//#endregion
+//#region src/index.browser.ts
+/** The seven constructors, present and refusing in a page. */
+const specification = {
+	api: () => refuse("specification.api()"),
+	cli: () => refuse("specification.cli()"),
+	integration: () => refuse("specification.integration()"),
+	job: () => refuse("specification.job()"),
+	lint: () => refuse("specification.lint()"),
+	mobile: () => refuse("specification.mobile()"),
+	website: () => refuse("specification.website()")
+};
+const ruleTester = () => refuse("ruleTester()");
+const process$1 = () => refuse("process()");
+const ProcessHandle = nodeOnlyClass("ProcessHandle");
+const postgres = () => refuse("postgres()");
+const redis = () => refuse("redis()");
+const sqlite = () => refuse("sqlite()");
+//#endregion
+export { region as A, option as B, component as C, form as D, contentinfo as E, dialog as F, directory as G, status as H, field as I, defineStubs as J, file as K, heading as L, within as M, button as N, main as O, content as P, link as R, http as S, complementary as T, table as U, row as V, testId as W, match as X, Matcher as Y, clock as _, ruleTester as a, openai as b, waitUntil as c, disabled as d, enabled as f, mockOf as g, valued as h, redis as i, search as j, navigation as k, required as l, selected as m, postgres as n, specification as o, focused as p, defineStub as q, process$1 as r, sqlite as s, ProcessHandle as t, text as u, packed as v, banner as w, anthropic as x, intercept as y, listitem as z };
+
+//# sourceMappingURL=browser-shared-index.browser.js.map