@jterrazz/test 16.1.1 → 17.0.0

package/dist/stream.js

@@ -1,321 +0,0 @@
-import { t as CaptureScope } from "./match.js";
-import { A as placeholderPatternSource, D as hasPlaceholders, P as textEquals } from "./literate.js";
-//#region src/model/contracts/contract.ts
-/**
-* Declare one contract. Identity function — its value is the enforced shape
-* and the naming convention:
-*
-* @example
-*   // specs/api/reports/contracts/openai/classify-article.ts
-*   import { defineContract, openai } from '@jterrazz/test';
-*
-*   export default defineContract({
-*       request: openai.responses({ user: PROMPT, tools: ['classify'] }),
-*       response: openai.reply({ categories: ['TECH'] }),
-*   });
-*
-*   // Dynamic — the response is computed from the observed request:
-*   export default defineContract({
-*       request: http.post('https://api.example.com/echo'),
-*       response: (request) => http.json({ received: request.body }),
-*   });
-*/
-function defineContract(contract) {
-	return contract;
-}
-/** Is this a {@link Contracts} composite (rather than a contract or a list)? */
-function isContracts(value) {
-	return typeof value === "object" && value !== null && Array.isArray(value.contracts) && typeof value.with === "function";
-}
-/** Is this a single {@link Contract} (rather than a bare request half)? */
-function isContract(value) {
-	return typeof value === "object" && value !== null && "request" in value && "response" in value;
-}
-/**
-* The route a contract claims — method + the DECLARED url source. Two
-* contracts share a route when they would be written on the same line of a
-* declaration: same method, same url pattern (`.source` for a RegExp).
-*/
-function routeKeyOf(contract) {
-	const { method, url } = contract.request;
-	return url instanceof RegExp ? `${method} re:${url.source}` : `${method} str:${url}`;
-}
-/** Human-readable route of a contract — used in every failure message. */
-function describeRoute(contract) {
-	const { method, url } = contract.request;
-	return `${method === "*" ? "ANY" : method} ${url instanceof RegExp ? String(url) : url}`;
-}
-/** Flatten contracts, lists, and composites into one ordered list. */
-function flatten(items) {
-	const flat = [];
-	for (const item of items) if (Array.isArray(item)) flat.push(...flatten(item));
-	else if (isContracts(item)) flat.push(...item.contracts);
-	else flat.push(item);
-	return flat;
-}
-/**
-* Compose contracts into the artifact a test imports — it's contracts all the
-* way down: a composite may extend contracts, lists, and other composites,
-* recursively, order preserved.
-*
-* `.with(...)` derives a scenario: contracts whose route the overrides claim
-* are removed from the base, and the overrides are prepended. Under
-* first-match selection a more specific override (`/articles/gone-1`) also
-* wins over a generic base route (`/articles/{{uuid}}`) it does not replace.
-*
-* @example
-*   // contracts/newsroom.contracts.ts
-*   export default defineContracts(events, articleById);
-*   export const withArticleGone = (id: string) =>
-*       newsroom.with(articleGone(id));
-*/
-function defineContracts(...items) {
-	const contracts = Object.freeze(flatten(items));
-	return {
-		contracts,
-		with(...overrides) {
-			const added = flatten(overrides);
-			const claimed = new Set(added.map(routeKeyOf));
-			const kept = contracts.filter((contract) => !claimed.has(routeKeyOf(contract)));
-			return defineContracts([...added, ...kept]);
-		}
-	};
-}
-/** Normalize any accepted input into a flat contract list. */
-function contractsOf(input) {
-	return flatten([input]);
-}
-//#endregion
-//#region src/model/contracts/types.ts
-/**
-* The marker that tells a STREAMED body from a value that happens to be an
-* object. A body reaches three different engines (msw's server, msw's worker,
-* the `node:http` stub) and each of them serialises "an object" as JSON, so a
-* stream declared as a plain value arrives as `{}`. The tag is what each
-* engine recognises before it reaches for `JSON.stringify`.
-*/
-const STREAM_BODY = "@jterrazz/test:stream";
-/** Is this body a declared stream rather than a value to serialise? */
-function isStreamBody(body) {
-	return typeof body === "object" && body !== null && "kind" in body && body.kind === "@jterrazz/test:stream";
-}
-//#endregion
-//#region src/model/timing/pause.ts
-/**
-* One answer to "wait" — the only `setTimeout` the model owns.
-*
-* Two things in the framework genuinely have to wait: the spacing between the
-* pieces of a declared stream, and the poll behind `waitUntil`. Everything
-* else that waits is a spec doing it by hand, which is what J2 refuses. Stated
-* once so there is one place to look when time stops behaving.
-*/
-async function pause(ms) {
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
-//#endregion
-//#region src/model/contracts/queue.ts
-/**
-* The ONE contract queue — pure, engine-agnostic (no MSW, no node:http).
-* Both engines consume it: the MSW integration on api/jobs chains, and the
-* declared stub backend on website/mobile chains.
-*
-* Selection: the FIRST contract in declaration order that matches the observed
-* request and is not exhausted. A contract with no `times` is unlimited (a
-* re-render or a retry replays it); `times: n` is spent after n serves, so an
-* ordered sequence is written as finite contracts before an unlimited tail:
-* `[error500 ×3, ok]`.
-*
-* Strictness (CONVENTIONS D7): when nothing matches — including "everything
-* that matches is exhausted" — the engine answers 501, records the request,
-* and the chain fails with {@link ContractQueue.unmatchedError}. A chain that
-* declared zero contracts is not guarded at all (unchanged boundary).
-*/
-/** Base used to parse origin-relative observed URLs (`/events?x=1`). */
-const RELATIVE_BASE = "http://contract.invalid";
-/** Split a declared url into its base (origin+path, or path) and query halves.
-* Never through `new URL()`, which would percent-encode `{{token}}` braces. */
-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))
-	};
-}
-/** Decode percent-escapes, falling back to the raw text on malformed input. */
-function safeDecode(text) {
-	try {
-		return decodeURIComponent(text);
-	} catch {
-		return text;
-	}
-}
-/** Token-aware comparison of one declared value against an observed one. */
-function valueMatches(declared, observed) {
-	return textEquals(declared, observed, new CaptureScope());
-}
-/**
-* Does an observed URL satisfy a declared one? A RegExp tests the full URL; a
-* PATH FORM (`/articles/{{uuid}}`) ignores the origin; an absolute string
-* compares origin+pathname. In both string forms `{{token}}` segments compare
-* structurally and declared query params are a SUBSET of the observed ones.
-*/
-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;
-}
-/**
-* Does an observed request satisfy a contract? Method (`*` matches any), URL,
-* then the contract's own `match` predicate (headers/query/body filters).
-*/
-function contractMatches(contract, request) {
-	const { match, method, url } = contract.request;
-	if (method !== "*" && method.toUpperCase() !== request.method.toUpperCase()) return false;
-	if (!urlMatches(url, request.url)) return false;
-	return match ? match(request) : true;
-}
-/**
-* The URL pattern an out-of-process router (MSW) must register so the request
-* REACHES the queue. Deliberately no narrower than {@link contractMatches} —
-* the predicate above stays the authority on what actually matches.
-*/
-function routePatternOf(declared) {
-	if (declared instanceof RegExp) return declared;
-	const { base } = splitDeclared(declared);
-	if (base.startsWith("/")) return new RegExp(String.raw`^https?:\/\/[^/?#]+${placeholderPatternSource(base)}(?:\?[^#]*)?(?:#.*)?$`, "u");
-	if (hasPlaceholders(base)) return new RegExp(String.raw`^${placeholderPatternSource(base)}(?:\?[^#]*)?(?:#.*)?$`, "u");
-	return base;
-}
-/** How a declared contract reads in a failure message: spent, served, or silent. */
-function stateOf({ contract, served }) {
-	const { times } = contract;
-	if (times !== void 0 && served >= times) return ` (exhausted after ${times})`;
-	return served === 0 ? "" : ` (served ${served} time(s))`;
-}
-var ContractQueue = class {
-	entries;
-	constructor(contracts) {
-		this.entries = contracts.map((contract) => ({
-			contract,
-			served: 0
-		}));
-	}
-	/** How many contracts the chain declared. */
-	get size() {
-		return this.entries.length;
-	}
-	/**
-	* Routes to register with an out-of-process router, deduped by pattern —
-	* two contracts on the same URL share one handler and one queue.
-	*/
-	get routes() {
-		const routes = /* @__PURE__ */ new Map();
-		for (const { contract } of this.entries) {
-			const url = routePatternOf(contract.request.url);
-			const key = String(url);
-			const route = routes.get(key) ?? {
-				methods: [],
-				url
-			};
-			if (!route.methods.includes(contract.request.method)) route.methods.push(contract.request.method);
-			routes.set(key, route);
-		}
-		return [...routes.values()];
-	}
-	/** The declared routes, in order — the enumeration a 501 body carries. */
-	declaredRoutes() {
-		return this.entries.map(({ contract }) => describeRoute(contract));
-	}
-	/**
-	* Serve the first contract in declaration order that matches and is not
-	* exhausted, or null when nothing matches (including "everything that
-	* matches is spent") — the strict-violation signal.
-	*/
-	take(request) {
-		for (const entry of this.entries) {
-			const { times } = entry.contract;
-			if (times !== void 0 && entry.served >= times) continue;
-			if (!contractMatches(entry.contract, request)) continue;
-			entry.served += 1;
-			return entry.contract;
-		}
-		return null;
-	}
-	/**
-	* The chain-end failure for contracts declared `required: true` that were
-	* never requested (or not exactly `times` times), or null when every
-	* requirement held.
-	*/
-	requiredError() {
-		const unmet = [];
-		for (const { contract, served } of this.entries) {
-			if (!contract.required) continue;
-			const { times } = contract;
-			if (times === void 0) {
-				if (served === 0) unmet.push(`  - ${describeRoute(contract)} — declared and required but never requested`);
-			} else if (served !== times) unmet.push(`  - ${describeRoute(contract)} — declared required with times: ${times} but was requested ${served} time(s)`);
-		}
-		if (unmet.length === 0) return null;
-		return /* @__PURE__ */ new Error(`Required contract(s) never satisfied during the chain:\n${unmet.join("\n")}\nA required contract states the call MUST happen — either the code no longer makes it, or the contract no longer describes it.`);
-	}
-	/**
-	* The strict failure for a request that matched no contract (CONVENTIONS
-	* D7): method + URL of the offending request, plus every declared contract
-	* and how often it was served.
-	*/
-	unmatchedError(method, url) {
-		const declared = this.entries.length === 0 ? "  (no contracts declared)" : this.entries.map((entry) => `  - ${describeRoute(entry.contract)}${stateOf(entry)}`).join("\n");
-		return /* @__PURE__ */ new Error(`Unmatched outgoing HTTP request during spec: ${method} ${url}\nDeclared contracts:\n${declared}\nEvery outgoing request of a chain that declares contracts must match one — add a contract for it (or raise its \`times\` when it is exhausted).`);
-	}
-};
-//#endregion
-//#region src/model/contracts/stream.ts
-/**
-* A declared stream, made real — ONE serialisation for all three engines.
-*
-* msw's server and msw's worker take a `ReadableStream` body verbatim
-* (https://mswjs.io/docs/http/mocking-responses/streaming) and the `node:http`
-* stub pipes one into its response, so what "arriving in pieces" MEANS —
-* the order, the spacing, the close after the last chunk — is stated here and
-* nowhere else. A second copy of it would be a second answer to "what does the
-* subject read", and the facets would drift.
-*/
-/**
-* The pieces of `body`, in order, `delayBetweenChunks` milliseconds apart,
-* closing after the last one.
-*/
-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 (body.delayBetweenChunks > 0 && index > 0) await pause(body.delayBetweenChunks);
-		index += 1;
-		controller.enqueue(encoder.encode(chunk));
-	} });
-}
-//#endregion
-export { isStreamBody as a, defineContracts as c, STREAM_BODY as i, isContract as l, ContractQueue as n, contractsOf as o, pause as r, defineContract as s, toReadableStream as t, isContracts as u };

package/dist/substring-warning.js

@@ -1,282 +0,0 @@
-//#region src/model/elements/ambiguity.ts
-/**
-* The ambiguity refusal — CONVENTIONS W3.
-*
-* A visit descriptor must designate exactly one element. Acting on "the
-* first match" is the failure mode this module exists to prevent: the spec
-* keeps passing while the visitor clicks something else, and nothing ever
-* reports it. So when a descriptor matches several elements the framework
-* refuses, and the refusal has to carry everything needed to fix it without
-* opening a browser — the descriptor in the caller's own vocabulary, every
-* candidate, and the concrete rewrites that would resolve it.
-*
-* Pure string building: it takes captured data and returns a message, so the
-* wording is unit-testable and the browser integration stays a thin adapter.
-*/
-/** `kind` → the constructor that builds it, so errors echo the caller's source. */
-const CONSTRUCTORS = {
-	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"
-};
-/** The landmark a context string maps back to, for a copy-pasteable suggestion. */
-const CONTEXT_LANDMARKS = {
-	aside: "complementary()",
-	banner: "banner()",
-	complementary: "complementary()",
-	contentinfo: "contentinfo()",
-	footer: "contentinfo()",
-	form: "form()",
-	header: "banner()",
-	main: "main()",
-	nav: "navigation()",
-	navigation: "navigation()",
-	search: "search()"
-};
-/**
-* Render a descriptor as the source that would build it — `link('Articles')`,
-* `within(navigation(), link('Articles', { exact: false }))`. The error speaks
-* the vocabulary the author wrote, never playwright's — so the option appears
-* only when the AUTHOR stated one, whichever way.
-*/
-function formatElement(element) {
-	const bare = formatBare(element);
-	return element.scope ? `within(${formatElement(element.scope)}, ${bare})` : bare;
-}
-function formatBare(element) {
-	const args = [];
-	if (element.name !== void 0) args.push(JSON.stringify(element.name));
-	if (element.exact !== void 0) args.push(`{ exact: ${String(element.exact)} }`);
-	return `${CONSTRUCTORS[element.kind]}(${args.join(", ")})`;
-}
-/** `1. <a href="/articles">Articles</a>  in <nav>` — one evidence line per candidate. */
-function formatMatch(match, index) {
-	const attribute = match.detail ? ` ${quoteDetail(match)}` : "";
-	const named = match.accessibleName ? `  named ${JSON.stringify(match.accessibleName)}` : "";
-	const context = match.context ? `  in <${match.context}>` : "";
-	return `  ${index + 1}. <${match.tag}${attribute}>${match.text}</${match.tag}>${named}${context}`;
-}
-function quoteDetail(match) {
-	return `${match.tag === "a" ? "href" : "name"}=${JSON.stringify(match.detail)}`;
-}
-/** Each landmark the candidates sit in, and how many of them it holds. */
-function landmarkCounts(matches) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const match of matches) {
-		const landmark = match.context === void 0 ? void 0 : CONTEXT_LANDMARKS[match.context];
-		if (landmark !== void 0) counts.set(landmark, (counts.get(landmark) ?? 0) + 1);
-	}
-	return [...counts].toSorted(([, a], [, b]) => a - b);
-}
-/**
-* The rewrites worth offering, in the order they should be tried. Scoping is
-* always available; `exact` only when it would actually narrow the set, and
-* the count it would leave is stated so a still-ambiguous suggestion never
-* reads as a fix.
-*/
-function formatFixes(element, matches) {
-	const fixes = [];
-	const narrowing = landmarkCounts(matches).filter(([, count]) => count < matches.length);
-	if (!element.scope) {
-		const [first, ...rest] = narrowing;
-		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>, ${formatBare(element)})` : `scope it       within(${first[0]}, ${formatBare(element)})   [leaves ${first[1]} of ${matches.length}]${alsoHere}`);
-	}
-	if (element.exact === false && element.name !== void 0) {
-		const remaining = matches.filter((match) => match.text === element.name).length;
-		if (remaining > 0 && remaining < matches.length) fixes.push(`exact name     ${formatBare({
-			...element,
-			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;
-}
-/**
-* The W3 refusal. A distinct class so the visit wrapper can recognize an
-* already-complete message and let it through instead of nesting it inside
-* `visit scenario failed: …`, which would print the whole thing twice.
-*/
-var AmbiguousElementError = class extends Error {
-	name = "AmbiguousElementError";
-};
-/**
-* Build the refusal thrown when a descriptor matches more than one element.
-*
-* @param options.element The descriptor as the caller wrote it.
-* @param options.matches Every candidate, in DOM order (already truncated).
-* @param options.url The page the visitor was on when it happened.
-*/
-function describeAmbiguity(options) {
-	const { element, matches, url } = options;
-	const fixes = formatFixes(element, matches).map((fix) => `  • ${fix}`);
-	return [
-		`Ambiguous element: ${formatElement(element)} matched ${matches.length} elements on ${url}.`,
-		"",
-		"A spec must designate exactly one element. Acting on the first match would let",
-		"this test keep passing while the visitor interacts with something else.",
-		"",
-		"Matched:",
-		...matches.map((match, index) => formatMatch(match, index)),
-		"",
-		"Disambiguate with one of:",
-		...fixes,
-		"",
-		"Docs: docs/13-elements.md#designating-exactly-one-element (CONVENTIONS W3)"
-	].join("\n");
-}
-//#endregion
-//#region src/model/elements/substring-warning.ts
-/**
-* The transitional warning for a name that matches only as a SUBSTRING.
-*
-* Until 16.0 a descriptor's name matched any element whose accessible name
-* CONTAINED it, so `link('Articles')` also designated "Read Articles" — and a
-* test could pass for years against the wrong element without anyone noticing,
-* because the wrong element was usually next to the right one. Exact is the
-* default now.
-*
-* A lint rule cannot carry this: whether a name matched whole or in part is a
-* fact about a RUN, and a verdict fed by a previous run's artefact is not
-* deterministic. So it is a runtime warning, printed by the adapter that did
-* the looking, at the moment it has both answers in hand — nothing found under
-* exact, something found under substring.
-*
-* It is printed ONCE per descriptor per process: a scenario that clicks the
-* same link in ten tests has one thing to fix, not ten lines to read.
-*/
-/** How long the window lasts, stated in the message itself. */
-const WINDOW = "through 16.x";
-/** The node side's printer — the default every adapter but the page's uses. */
-function toStandardError(line) {
-	if (typeof process === "undefined") {
-		console.warn(line);
-		return;
-	}
-	process.stderr.write(`${line}\n`);
-}
-/** Descriptors already reported in this process. */
-const reported = /* @__PURE__ */ new Set();
-/** The identity a descriptor is deduplicated by — kind, name, and its scope chain. */
-function identityOf(element) {
-	const own = `${element.kind}:${element.name ?? ""}`;
-	return element.scope === void 0 ? own : `${identityOf(element.scope)}>${own}`;
-}
-/**
-* Report that `element` designated nothing as a whole name, but would have
-* designated something as a substring. Returns whether a line was printed,
-* which is what the adapters' own tests assert on.
-*/
-async function warnSubstringOnly(element, where, found, print = toStandardError) {
-	const identity = identityOf(element);
-	if (reported.has(identity)) return false;
-	reported.add(identity);
-	const spelling = found === void 0 ? "" : ` The name to write is '${found.replaceAll(/\s+/gu, " ").trim()}'.`;
-	await print(`@jterrazz/test: ${element.kind}('${element.name ?? ""}') matched nothing as a whole accessible name, and matched only as a SUBSTRING of a longer one (${where}).${spelling} Names are exact from 16.0: write the name in full, scope it with \`within(…)\`, or state \`{ exact: false }\` to keep the old behaviour. The substring is still resolved, with this warning, ${WINDOW}; gone in 17.0, where the same descriptor is simply not found.`);
-	return true;
-}
-/**
-* How long a descriptor is given to ARRIVE before the window concludes it is
-* absent — the budget `settles` spends and no more.
-*
-* A count is one observation, and a verb called right after a navigating
-* `click()` takes it on the page being LEFT. The window may not decide
-* "nothing matches this whole name" on that reading: the destination has not
-* been parsed yet. Long enough for a navigation to commit, far short of the
-* verb's own 30 s, and paid only when there is a substring to widen to.
-*/
-const WINDOW_SETTLE_MS = 5e3;
-/**
-* The descriptor to retry with, LEVEL by level, or `undefined` when nothing
-* would change.
-*
-* Every level of the chain is asked the same question the target is asked —
-* `within(button('Proof of authorship'), content('Verified'))` against a
-* button named "Proof of authorship Verified" failed on the SCOPE, and a
-* warning that only ever widened the target printed nothing at all. The chain
-* is walked outside-in and rebuilt as it goes, since an inner level's answer
-* is meaningless under a scope that designates nothing.
-*
-* A level that states an `exact` of its own is left alone: an author who wrote
-* `{ exact: false }` chose the substring, and one who wrote `{ exact: true }`
-* was already exact.
-*
-* Asked BEFORE the action, not after it fails: a verb waits its whole
-* actionability budget, which is the test's own budget, so a retry afterwards
-* never runs — the test is already over. The common case (the name matches
-* whole) costs one count per level, which waits for nothing.
-*/
-async function widenedForWindow(element, where, probe) {
-	const chain = [];
-	for (let level = element; level; level = level.scope) chain.unshift(level);
-	let rebuilt;
-	let widened = false;
-	for (const level of chain) {
-		const candidate = {
-			...level,
-			...rebuilt === void 0 ? {} : { scope: rebuilt }
-		};
-		const loose = await widenedLevel(candidate, where, probe);
-		widened ||= loose !== void 0;
-		rebuilt = loose ?? candidate;
-	}
-	return widened ? rebuilt : void 0;
-}
-/**
-* The one level, widened and warned about, or `undefined` when it designates
-* something already, states its own `exact`, carries no name, would designate
-* nothing either way, or turns out to be exact on the surface that ARRIVES.
-*
-* The last is the navigation case, and it is the reason the verdict is not two
-* counts: a `see()` fired right after a navigating `click()` counts the page
-* being left, so a descriptor that is perfectly exact on the DESTINATION read
-* as substring-only — non-deterministically, since which page each count
-* landed on was a race. A widening is therefore only decided once the exact
-* descriptor has been given the settle budget and still designates nothing.
-* The tell of the old fault was the printed name equalling the name written.
-*/
-async function widenedLevel(candidate, where, probe) {
-	if (candidate.exact !== void 0 || candidate.name === void 0) return;
-	try {
-		if (await probe.count(candidate) > 0) return;
-		const loose = {
-			...candidate,
-			exact: false
-		};
-		if (await probe.count(loose) !== 1) return;
-		if (!alreadyJudged(candidate) && await probe.settles(candidate)) return;
-		await warnSubstringOnly(candidate, where, await probe.nameOf(loose), probe.print);
-		return loose;
-	} catch {
-		return;
-	}
-}
-/**
-* Has this descriptor already been judged substring-only in this run?
-*
-* The verdict is made once: a scenario that clicks the same link in ten tests
-* pays the settle budget on the first of them and is widened straight away on
-* the nine after it.
-*/
-function alreadyJudged(element) {
-	return reported.has(identityOf(element));
-}
-//#endregion
-export { describeAmbiguity as a, AmbiguousElementError as i, warnSubstringOnly as n, formatElement as o, widenedForWindow as r, WINDOW_SETTLE_MS as t };