@jterrazz/test 16.1.1 → 18.0.0

package/dist/shared-device.port.d.ts

@@ -0,0 +1,189 @@
+import { Scalar } from "yaml";
+//#region lint/kit/project/spec-grammar.d.ts
+/** One `env:` entry: a bare word naming a registered set, or a `KEY=value` pair. */
+type SpecEnvToken = {
+  key: string;
+  kind: 'pair';
+  line: number;
+  value: string;
+} | {
+  kind: 'set';
+  line: number;
+  name: string;
+};
+/** One `serve:` entry: a registered server plus the extra env it is started with. */
+type SpecServeEntry = {
+  env: Record<string, string>;
+  line: number;
+  name: string;
+};
+/** One `fixture:` entry: a path with the line it was declared on. */
+type SpecFixture = {
+  line: number;
+  path: string;
+};
+/** An expected stream: its text, and the first line of that text in the file. */
+type SpecStream = {
+  /** 1-based line the scalar's content starts on, where a token defect is reported. */
+  line: number;
+  text: string;
+};
+/** One `files:` assertion, keyed by a workdir-relative path. */
+type SpecFileAssertion = {
+  contains: SpecStream[];
+  equals: null | SpecStream;
+  kind: 'content';
+  line: number;
+  path: string;
+} | {
+  kind: 'absent';
+  line: number;
+  path: string;
+} | {
+  kind: 'exists';
+  line: number;
+  path: string;
+};
+/** One run: a command, what it must exit with, and what it must have produced. */
+type SpecRun = {
+  command: string;
+  /** 1-based line of the `command:` key, the frame a failure points at. */
+  commandLine: number;
+  exitCode: number;
+  files: SpecFileAssertion[];
+  /** `null` when the key is absent, which asserts an empty stream. */
+  stderr: null | SpecStream;
+  /** Written to the child then closed; `null` keeps the empty-pipe EOF. */
+  stdin: null | string;
+  stdout: null | SpecStream;
+  timeout: null | number;
+  /** Only on the last run: a long-running command ends the session. */
+  waitFor: null | string;
+};
+/** A parsed `<case>.spec.yaml`. */
+type SpecDocument = {
+  /** The vitest test title. */
+  description: string;
+  /** 1-based line of the `description:` key. */
+  descriptionLine: number;
+  env: SpecEnvToken[];
+  fixtures: SpecFixture[];
+  runs: SpecRun[];
+  serve: SpecServeEntry[];
+};
+//#endregion
+//#region src/visitor/targets/target.d.ts
+/** The ARIA landmark roles: the containers a refusal can offer by name as a scope. */
+type LandmarkKind = 'banner' | 'complementary' | 'contentinfo' | 'form' | 'main' | 'navigation' | 'region' | 'search';
+/** The element kinds a visitor acts on. */
+type ElementKind = 'button' | 'dialog' | 'field' | 'heading' | 'link' | 'listitem' | 'option' | 'row' | 'status' | 'table' | 'testId' | 'text';
+/** What a visitor acts on, named as its user sees it; it must designate exactly one element (`target-matches-one-element`). */
+type Target = {
+  /** Match the accessible name whole; absent means the default, exact. */
+  exact?: boolean;
+  /** Assert focus rather than presence, built by `focused(target)`. */
+  focused?: boolean;
+  /** Accepting input or not, built by `disabled(x)` / `enabled(x)`. */
+  disabled?: boolean;
+  kind: ElementKind | LandmarkKind;
+  name?: string;
+  /** The chosen option or not, built by `selected(x)`; read from `:checked`. */
+  selected?: boolean;
+  /** The field's live value, built by `valued(field, value)`. */
+  value?: string;
+  /** Search inside another target, built by `within(scope, target)`. */
+  scope?: Target;
+};
+/** Options accepted by every named target. */
+type TargetOptions = {
+  /** Match the accessible name whole; `true` by default, `{ exact: false }` for a name with a variable part. */
+  exact?: boolean;
+};
+type NamedTargetFactory = (name: string, options?: TargetOptions) => Target;
+type OptionallyNamedTargetFactory = (name?: string, options?: TargetOptions) => Target;
+//#endregion
+//#region src/visitor/verbs.d.ts
+/** The verbs a page is acted on through; every action auto-waits, and `see()` and `gone()` are the synchronization. */
+type VisitorVerbs = {
+  check: (target: Target) => Promise<void>;
+  click: (target: Target) => Promise<void>;
+  fill: (target: Target, value: string) => Promise<void>;
+  /** Wait until the element is gone, hidden or never in the document. */
+  gone: (target: Target) => Promise<void>;
+  hover: (target: Target) => Promise<void>;
+  /** Press a key (e.g. `Enter`). */
+  press: (key: string) => Promise<void>;
+  /** Wait until the element is visible. */
+  see: (target: Target) => Promise<void>;
+  select: (target: Target, option: string) => Promise<void>;
+};
+//#endregion
+//#region src/specifications/mobile/device/device.port.d.ts
+type MobileDevice = {
+  /** Simulator name, matched exactly (`iPhone 17`). */
+  name: string;
+  /** OS narrowing when the name exists on several runtimes: `'26.5'` or `'iOS 26.5'`. */
+  os?: string;
+  /** Explicit UDID; skips name/os resolution entirely. */
+  udid?: string;
+};
+/** The element kinds a mobile screen designates, each compiled to an iOS predicate; every other kind is refused. */
+type MobileElementKind = 'button' | 'field' | 'testId' | 'text';
+/** One candidate of an ambiguous target, as the refusal lists it. */
+type MobileElementMatch = {
+  /** The accessibility identifier (`testId()` target), when one is set. */
+  identifier?: string;
+  /** The accessible label, whitespace-collapsed and truncated. */
+  label?: string;
+  /** Element type without the `XCUIElementType` prefix: `Button`, `StaticText`. */
+  type: string;
+  /** The element value (text-field content, adjustable value), when present. */
+  value?: string;
+};
+/** The verbs a mobile scenario is handed: a page's `see` and `fill`, and a `tap`; each polls until a visible match exists. */
+type MobileVisitor = Pick<VisitorVerbs, 'fill' | 'see'> & {
+  tap: VisitorVerbs['click'];
+};
+/** The behavior of an open, the When of the spec; assertions stay in the Then. */
+type MobileScenario = (visitor: MobileVisitor) => Promise<void>;
+/** One node of the projected accessibility tree: noise wrappers dropped, `XCUIElementType` prefix removed. */
+type ScreenNode = {
+  children?: ScreenNode[];
+  /** The accessibility identifier, only when it differs from the label. */
+  identifier?: string;
+  label?: string;
+  /** Element type without the `XCUIElementType` prefix: `Button`, `StaticText`. */
+  type: string;
+  value?: string;
+};
+/** The screen captured by an open, final state: the projected tree and the visible texts. */
+type DeviceScreen = {
+  texts: string[];
+  tree: ScreenNode;
+};
+/** Per-open options forwarded to the device session. */
+type DeviceOpenOptions = {
+  /** The app under test, terminated and relaunched for a fresh, deterministic state. */
+  bundleId: string;
+  /** Deep link applied after the relaunch (`news://events`); absent opens the app plainly. */
+  deepLink?: string | undefined;
+  /** The interaction scenario to run after launch; the capture reflects the final state. */
+  scenario?: MobileScenario | undefined;
+};
+/** How long a device session waits, in milliseconds; each field falls back to the default. */
+type DeviceTimeouts = {
+  /** How long every verb polls for a visible match. Default `30_000`. */
+  action?: number | undefined;
+  /** How long the first session waits for WebDriverAgent to build and launch. Default `240_000`. */
+  launch?: number | undefined;
+};
+/** The device a mobile runner drives: one driver session, each open relaunching the app. */
+type DevicePort = {
+  /** End the driver session, unless it is the run's (idempotent). */
+  close: () => Promise<void>;
+  /** Relaunch the app, apply the deep link, run the scenario, capture the final screen. */
+  open: (options: DeviceOpenOptions) => Promise<DeviceScreen>;
+};
+//#endregion
+export { SpecServeEntry as C, SpecRun as S, TargetOptions as _, MobileDevice as a, SpecFileAssertion as b, MobileScenario as c, VisitorVerbs as d, ElementKind as f, Target as g, OptionallyNamedTargetFactory as h, DeviceTimeouts as i, MobileVisitor as l, NamedTargetFactory as m, DevicePort as n, MobileElementKind as o, LandmarkKind as p, DeviceScreen as r, MobileElementMatch as s, DeviceOpenOptions as t, ScreenNode as u, SpecDocument as v, SpecStream as w, SpecFixture as x, SpecEnvToken as y };
+//# sourceMappingURL=shared-device.port.d.ts.map

package/dist/shared-exchange.js

@@ -0,0 +1,447 @@
+import { t as isRecord } from "./shared-json-shape.js";
+import { n as refusal } from "./shared-refusal.js";
+import { t as TOKEN_KINDS } from "./shared-tokens.js";
+//#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 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/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/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);
+}
+const UNICODE$1 = "u";
+/** The fixture text becomes an unanchored pattern, a text without tokens a literal one. */
+function textContains(expected, actual, scope) {
+	const parsed = parsePlaceholderString(expected, scope);
+	const found = new RegExp(parsed.source, UNICODE$1).exec(actual);
+	if (!found) return false;
+	return parsed.refs.every((entry) => entry.ref === void 0 || recordRef(entry.ref, found[entry.index + 1], scope));
+}
+function renderExpected(value) {
+	if (value instanceof Matcher) return value.toString();
+	if (Array.isArray(value)) return value.map((item) => renderExpected(item));
+	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, renderExpected(item)]));
+	return value;
+}
+//#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/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/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
+export { Matcher as _, defineStubs as a, urlMatches as c, structuralEquals as d, structuralSubset as f, placeholderStringMatches as g, hasPlaceholders as h, defineStub as i, isPlainObject as l, textEquals as m, isStreamBody as n, describeRoute as o, textContains as p, declared as r, routePatternOf as s, STREAM_BODY as t, renderExpected as u, match as v, CaptureScope as y };
+
+//# sourceMappingURL=shared-exchange.js.map