@jterrazz/test 16.0.0 → 16.1.0

package/dist/oxlint.js

@@ -437,7 +437,7 @@ const RULE_DOCS = {
 	},
 	"d8w-text-bypass": {
 		channel: "statique",
-		convention: "`expect(x.text).toContain/toMatch` short-circuits the typed accessor subject → warning.",
+		convention: "`expect(x.text).toContain/toMatch` short-circuits the typed accessor subject → warning. A RegExp argument is exempt: `toMatch` on an accessor takes a fixture NAME and throws on a regex, so reaching through to `.text` is the sanctioned form for a raw pattern (chapter 14).",
 		facet: "model",
 		family: "D",
 		fix: "Assert on the accessor itself (`expect(x)`), which carries the tokens and the fixture resolution.",
@@ -647,7 +647,7 @@ const RULE_DOCS = {
 	},
 	"i4-no-module-doubles": {
 		channel: "statique",
-		convention: "A test doubles a PORT, never a module: `vi.mock`/`vi.doMock` of a specifier outside the `modules` allow-list (a config comment states why each entry is there), a `__mocks__/` or `__fixtures__/` directory, and — in a `module`-role test — importing a data asset (`.json`, `.sql`, `.yaml`, …) are all errors. A dotted specifier (`./dashboard.post`) is still code. The `vi.stubGlobal` clause moved to M3 in 16.0: one owner per convention.",
+		convention: "A test doubles a PORT, never a module: `vi.mock`/`vi.doMock` of a specifier outside the `modules` allow-list (a config comment states why each entry is there), a `__mocks__/` or `__fixtures__/` directory, and — in a `module`-role test — importing a data asset (`.json`, `.sql`, `.yaml`, …) are all errors. The specifier is read in BOTH spellings — `vi.mock('<spec>')` and the `vi.mock(import('<spec>'))` form `vitest/prefer-import-in-mock` requires — so an allow-listed module has a green spelling under both rules. A dotted specifier (`./dashboard.post`) is still code. The `vi.stubGlobal` clause moved to M3 in 16.0: one owner per convention.",
 		facet: "model",
 		family: "I",
 		fix: "Double the port with `mockOf<Port>()`, keep a payload in a `*.fixtures.ts` neighbour, and allow-list a native module with its reason (chapter 05 § Doubles).",
@@ -657,7 +657,7 @@ const RULE_DOCS = {
 	},
 	"j2-no-sleep": {
 		channel: "statique",
-		convention: "No arbitrary sleep (`setTimeout`/`setInterval`/`Atomics.wait`, or a `node:timers/promises` import) in any test file — synchronisation is `see()`/`gone()` inside a scenario and `waitUntil(predicate)` everywhere else.",
+		convention: "No arbitrary sleep (`setTimeout`/`setInterval`/`Atomics.wait`, or a `node:timers/promises` import) in any test file — synchronisation is `see()`/`gone()` inside a scenario and `waitUntil(predicate)` everywhere else. A timer inside a test DOUBLE's implementation (`vi.fn(…)`, `mockImplementation(…)`, a `mockOf` handler) is out of reach: the double is staging the world, not the test waiting on it.",
 		facet: "model",
 		family: "J",
 		fix: "Wait for the condition, not for a duration.",
@@ -725,10 +725,10 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "A test under `specs/<facet>/`, where the facet root holds a `*.specification.ts(x)`, imports that module or constructs a runner itself.",
+		convention: "A test under `specs/<facet>/`, where the facet root holds a `*.specification.ts(x)`, imports that module or constructs a runner itself. Ground is out of reach — nothing under a leading-underscore folder is a spec, a `.test.ts` under `_expected/` being the GOLDEN a fixer writes. So is any first-level folder that is not a facet: a specification with no module to sit beside and no runner to reach lives in a repository suite there.",
 		facet: "model",
 		family: "C",
-		fix: "Import `{ <facet> }` from `<facet>.specification.js`, or move a module test beside its module.",
+		fix: "Import `{ <facet> }` from `<facet>.specification.js`, move a module test beside its module, or move a repository suite to a first-level folder of its own under `specs/`.",
 		id: "C18",
 		name: "c18-module-test-under-facet",
 		rationale: "A test reaching no runner under a facet is a module test paying the facet's budget and services to prove something that belongs beside its module.",
@@ -802,7 +802,7 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "A member declares no dependency `@jterrazz/test` already carries (`msw`, `vitest-mock-extended`; `yaml` in devDependencies only — as a production dependency it is the product’s own library) and no retired seam (`happy-dom`, `jsdom`, `@testing-library/*`, `@playwright/test`, `mockdate`) — except `@testing-library/react-native` in a member that runs jest, where it is the only vocabulary the runtime has until the React Native answer lands. The optional peers — `playwright`, `vite`, `react`, `better-sqlite3`, `pg`, `redis`, `testcontainers`… — are declared by the consumer, by design.",
+		convention: "A member declares no dependency `@jterrazz/test` already carries (`msw`, `vitest-mock-extended`; `yaml` in devDependencies only — as a production dependency it is the product’s own library) and no retired seam (`happy-dom`, `jsdom`, `@testing-library/*`, `@playwright/test`, `mockdate`) — except `@testing-library/react-native` where jest runs the tests of the member — the only vocabulary that runtime has until the React Native answer lands. Jest runs them when the member DECLARES it (a `jest`/`jest-expo` dependency, a `jest` field, a `test` script calling it) or when a `jest.config.*` elsewhere in the workspace ROOTS into the member, which is the shape a library co-locating its render tests takes when the app beside it owns the only working toolchain. The optional peers — `playwright`, `vite`, `react`, `better-sqlite3`, `pg`, `redis`, `testcontainers`… — are declared by the consumer, by design.",
 		facet: "model",
 		family: "F",
 		fix: "Remove the declaration: a transitive is already resolved by the package; a retired seam has a facet that replaces it (`component()`, `website()`, `clock`, `intercept()`). The diagnostic carries a sentence for each case.",
@@ -879,10 +879,10 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "The suffix says the kind, and the tree agrees with it. A `.spec.ts` — the ASSEMBLED product — lives under `specs/<facet>/`; anywhere else is an error. A `.test.ts` — the UNIT — lives beside its module; under a facet folder (`api`, `cli`, `integration`, `jobs`, `mobile`, `website`) it is an error, fixable by `--fix` (a `git mv`). A `.test.ts` that reaches no runner is C18’s, whose fix is the opposite move, and the mover leaves it alone. A first level that is NOT a facet is a repository suite: it covers a tree, keeps `.test.ts`, and C1’s declared depth is what judges it. A document is named `<case>.spec.yaml`: `<case>` in kebab-case, without the words `test`/`spec`/`cli` the suffix already carries, and never the bare name of its directory.",
+		convention: "The suffix says the kind, and the tree agrees with it. A `.spec.ts` — the ASSEMBLED product — lives under `specs/<facet>/`; anywhere else is an error. A `.test.ts` — the UNIT — lives beside its module; under a facet folder (`api`, `cli`, `integration`, `jobs`, `mobile`, `website`) it is an error, fixable by `--fix` (a `git mv`). A `.test.ts` that reaches no runner is C18’s, whose fix is the opposite move, and the mover leaves it alone. A first level that is NOT a facet is a repository suite: it covers a tree, keeps `.test.ts`, and C1’s declared depth is what judges it — unless the tree carries its `*.specification.ts` at its own ROOT, which makes the whole tree one facet’s and every `.test.ts` below it a spec. A document is named `<case>.spec.yaml`: `<case>` in kebab-case, without the words `test`/`spec`/`cli` the suffix already carries, and never the bare name of its directory.",
 		facet: "model",
 		family: "C",
-		fix: "Move the `.spec.ts` under `specs/<facet>/` (or rename it `.test.ts` beside its module); rename the facet `.test.ts` to `.spec.ts` — `jterrazz-test-check <root> --fix` does it with `git mv`, and names every include glob of the member that still says `.test.ts`.",
+		fix: "Move the `.spec.ts` under `specs/<facet>/` (or rename it `.test.ts` beside its module); rename the facet `.test.ts` to `.spec.ts` — `jterrazz-test-check <root> --fix` does it with `git mv`, and names every `include`/`exclude` entry of the member the rename broke.",
 		id: "C12",
 		name: "c12-spec-file-name",
 		rationale: "With no agreement between the suffix and the tree, a reader cannot say what a test proves without opening it; and the filename is the first sentence they read — `rm/rm.spec.yaml` says nothing twice.",
@@ -1400,7 +1400,7 @@ const RUNTIME_RULES = [
 	},
 	{
 		channel: "runtime",
-		convention: "An element descriptor must designate exactly ONE element when a verb ACTS on it (`click`/`tap`/`fill`): if several match, the action is refused with an error enumerating the candidates and offering the rewrites (`within(...)`, another descriptor). The framework never acts on \"the first\". A name designates the WHOLE accessible name since 16.0 — `{ exact: false }` is the opt-out — and a descriptor that finds nothing whole but would have found something as a substring raises a runtime warning, once per descriptor, through 16.0 and 16.1. It holds on both scenario facets, website and mobile; on mobile, `see()` — which acts on nothing — is satisfied by any visible match (the XCUITest tree legitimately duplicates a label between a container and its child).",
+		convention: "An element descriptor must designate exactly ONE element when a verb ACTS on it (`click`/`tap`/`fill`): if several match, the action is refused with an error enumerating the candidates and offering the rewrites (`within(...)`, another descriptor). The framework never acts on \"the first\". A name designates the WHOLE accessible name since 16.0 — `{ exact: false }` is the opt-out — and a descriptor that finds nothing whole but would have found something as a substring is still RESOLVED as a substring through 16.x, level by level, with a runtime warning naming the whole name to write, once per descriptor; in 17.0 it is simply not found. It holds on both scenario facets, website and mobile; on mobile, `see()` — which acts on nothing — is satisfied by any visible match (the XCUITest tree legitimately duplicates a label between a container and its child).",
 		facet: "model",
 		family: "W",
 		fix: "Scope it with `within(<landmark>, …)`, or name the element with a descriptor that designates one thing.",
@@ -1692,6 +1692,13 @@ function identifierName(node) {
 	const { name } = node;
 	return typeof name === "string" ? name : void 0;
 }
+/** The source end offset of a node or comment (oxlint `end`, else `range[1]`). */
+function nodeEnd(node) {
+	if (node === void 0) return -1;
+	if (typeof node.end === "number") return node.end;
+	const range = node.range;
+	return Array.isArray(range) && typeof range[1] === "number" ? range[1] : -1;
+}
 /** The three words a test narrates with, in the order they may appear. */
 const MARKERS = [
 	"Given",
@@ -3145,8 +3152,8 @@ function testsItsNeighbour(filename) {
 * product command/area with one or more `<aspect>.test.ts` files plus their
 * shared asset dirs.
 *
-* - a `*.test.ts` sits at facet/domain depth — exactly
-*   `specs/<facet>/<domain>/<file>.test.ts`. A test directly at the facet root
+* - a spec sits at facet/domain depth — exactly
+*   `specs/<facet>/<domain>/<aspect>.spec.ts`. A test directly at the facet root
 *   (or nested deeper than a domain) is rejected.
 * - a `*.specification.ts` sits at the facet root — exactly
 *   `specs/<facet>/<file>.specification.ts`, never inside a domain.
@@ -3154,8 +3161,8 @@ function testsItsNeighbour(filename) {
 * `depth: 'facet'`
 *
 * The same facet root, one degree looser: the folder follows the assets. A
-* `*.test.ts` sits EITHER at the facet root (`specs/<facet>/<aspect>.test.ts`)
-* or one domain folder down (`specs/<facet>/<domain>/<aspect>.test.ts`) — a
+* spec sits EITHER at the facet root (`specs/<facet>/<aspect>.spec.ts`)
+* or one domain folder down (`specs/<facet>/<domain>/<aspect>.spec.ts`) — a
 * test earns a domain folder when it carries assets of its own, and sits
 * beside its siblings when it does not. Anything deeper is rejected, and so is
 * a test loose at the specs root. A `*.specification.ts` sits at the facet
@@ -3164,9 +3171,10 @@ function testsItsNeighbour(filename) {
 * `depth: 'mirror'`
 *
 * The tree mirrors something outside itself (a command tree, a source tree), so
-* the depth is that structure's and no fixed number can name it. A `*.test.ts`
+* the depth is that structure's and no fixed number can name it. A spec
 * sits at ANY depth of at least one directory under `specs/`, and is NAMED
-* AFTER the directory holding it — `<dir>/<dir>.test.ts`. That naming is what
+* AFTER the directory holding it — `<dir>/<dir>.spec.ts`, the suffix C12 gives
+* every file of a facet tree. That naming is what
 * keeps the shape checkable: one test per mirrored node, no test loose at the
 * specs root. Specification files are unconstrained: a mirror has no facet
 * level to anchor them to.
@@ -3267,12 +3275,12 @@ const c1DomainStructure = {
 		messages: {
 			specInGround: "A spec must not live under \"{{ground}}/\" — a leading underscore marks GROUND (what the specs of a row stand on: _fixtures/, _expected/, _requests/, _seeds/), never a domain. Ground that is CODE keeps its own unit test: `<module>.test.ts` NEXT to the `<module>.ts` it tests (I2), and nothing else.",
 			specNotAtFacetRoot: "A `*.specification.ts` must sit at the facet root: `specs/<facet>/<name>.specification.ts`.",
-			testAtFacetRoot: "A `*.test.ts` must live in a domain folder: `specs/<facet>/<domain>/<aspect>.test.ts` — tests directly at the facet root are forbidden.",
-			testAtSpecsRoot: "A `*.test.ts` must live in a directory under specs/ — with `depth: \"mirror\"` the tree mirrors a structure, and the specs root mirrors nothing.",
-			testNotMirroringDirectory: "A `*.test.ts` must be named after the directory holding it — `{{directory}}/{{directory}}.test.ts` — with `depth: \"mirror\"`.",
-			testOutsideFacet: "A `*.test.ts` must live in a facet folder — `specs/<facet>/<aspect>.test.ts`, or one domain deeper: with `depth: \"facet\"` the specs root holds facets, not tests.",
-			testTooDeep: "A `*.test.ts` must sit at facet/domain depth: `specs/<facet>/<domain>/<aspect>.test.ts` — no deeper nesting.",
-			testTooDeepForFacet: "A `*.test.ts` must sit at the facet root or one domain folder down — `specs/<facet>/<aspect>.test.ts` or `specs/<facet>/<domain>/<aspect>.test.ts`: with `depth: \"facet\"` nothing nests deeper."
+			testAtFacetRoot: "A spec must live in a domain folder: `specs/<facet>/<domain>/<aspect>.spec.ts` — tests directly at the facet root are forbidden.",
+			testAtSpecsRoot: "A spec must live in a directory under specs/ — with `depth: \"mirror\"` the tree mirrors a structure, and the specs root mirrors nothing.",
+			testNotMirroringDirectory: "A spec must be named after the directory holding it — `{{directory}}/{{directory}}.spec.ts` — with `depth: \"mirror\"`.",
+			testOutsideFacet: "A spec must live in a facet folder — `specs/<facet>/<aspect>.spec.ts`, or one domain deeper: with `depth: \"facet\"` the specs root holds facets, not tests.",
+			testTooDeep: "A spec must sit at facet/domain depth: `specs/<facet>/<domain>/<aspect>.spec.ts` — no deeper nesting.",
+			testTooDeepForFacet: "A spec must sit at the facet root or one domain folder down — `specs/<facet>/<aspect>.spec.ts` or `specs/<facet>/<domain>/<aspect>.spec.ts`: with `depth: \"facet\"` nothing nests deeper."
 		},
 		schema: [{
 			additionalProperties: false,
@@ -4011,11 +4019,22 @@ const d6wTransformTokenEquivalent = {
 //#region src/lint/rules/model/d8w-text-bypass.ts
 /** Text-oriented matchers that tempt a raw `.text` bypass (D8). */
 const TEXT_MATCHERS = /* @__PURE__ */ new Set(["toContain", "toMatch"]);
+/** A regex literal, or `new RegExp(…)` — what an accessor subject refuses. */
+function isRegExp(node) {
+	if (node === void 0) return false;
+	if (node.type === "Literal") return "regex" in node;
+	return node.type === "NewExpression" && identifierName(child(node, "callee")) === "RegExp";
+}
 /**
 * CONVENTIONS D8 (warning) — `.text` is the raw stream escape hatch. Asserting
 * `expect(result.text).toContain(…)` throws away the typed subject (its token
 * grammar, its `toMatch('file.txt')` fixture resolution) for a substring check.
 * Prefer asserting on the accessor subject itself.
+*
+* A RegExp argument is exempt, because it is the one thing the typed subject
+* cannot take: `toMatch` on an accessor resolves a FIXTURE NAME and throws on a
+* regex, and chapter 14 names `expect(x.text).toMatch(/re/)` as the way through.
+* The rule warned on exactly the spelling its own manual prescribes.
 */
 const d8wTextBypass = {
 	create(context) {
@@ -4027,6 +4046,7 @@ const d8wTextBypass = {
 			if (expectCall?.type !== "CallExpression") return;
 			const expectCallee = expectCall.callee;
 			if (expectCallee?.type !== "Identifier" || expectCallee.name !== "expect") return;
+			if (isRegExp(childList(node, "arguments")[0])) return;
 			const subject = expectCall.arguments?.[0];
 			if (subject !== void 0 && memberPropertyName(subject) === "text") context.report({
 				data: { matcher },
@@ -4408,7 +4428,7 @@ const d16wAmbientValue = {
 //#endregion
 //#region src/lint/rules/model/d17w-double-only-oracle.ts
 /** The three ways this vocabulary makes a double. */
-const DOUBLE_FACTORIES = /* @__PURE__ */ new Set([
+const DOUBLE_FACTORIES$1 = /* @__PURE__ */ new Set([
 	"mockOf",
 	"vi.fn",
 	"vi.spyOn"
@@ -4423,7 +4443,7 @@ function makesADouble(init) {
 	if (init.type === "AwaitExpression") return makesADouble(child(init, "argument"));
 	if (init.type !== "CallExpression") return false;
 	const path = memberPath(child(init, "callee"));
-	return path !== void 0 && DOUBLE_FACTORIES.has(path);
+	return path !== void 0 && DOUBLE_FACTORIES$1.has(path);
 }
 /** Every binding in the file whose value is a double this test built. */
 function doubleBindings(root) {
@@ -5494,6 +5514,21 @@ function isModuleDouble(node) {
 	const property = child(callee, "property");
 	return identifierName(object) === "vi" && (identifierName(property) === "mock" || identifierName(property) === "doMock");
 }
+/**
+* The specifier a module double names, in either spelling.
+*
+* `vi.mock('./x.js', …)` states it as a string; `vi.mock(import('./x.js'), …)`
+* states it as a dynamic import, which is the form `vitest/prefer-import-in-mock`
+* requires. Reading only the string left an allow-listed native module with no
+* green spelling: satisfy this rule and the upstream one fires, satisfy that one
+* and this fires.
+*/
+function mockedSpecifier(argument) {
+	const literal = stringValue(argument);
+	if (literal !== void 0) return literal;
+	if (argument?.type !== "ImportExpression") return;
+	return stringValue(child(argument, "source"));
+}
 /** A bundler suffix (`./payload.json?raw`, `./doc.md#frag`) is not part of the extension. */
 function withoutSuffix(source) {
 	return source.replace(/[?#].*$/u, "");
@@ -5536,7 +5571,7 @@ const i4NoModuleDoubles = {
 		const visitor = {
 			CallExpression(node) {
 				if (!isModuleDouble(node)) return;
-				const named = stringValue(childList(node, "arguments")[0]);
+				const named = mockedSpecifier(childList(node, "arguments")[0]);
 				if (named === void 0 || !allowed.has(named)) context.report({
 					messageId: "viMock",
 					node
@@ -5579,6 +5614,26 @@ const i4NoModuleDoubles = {
 };
 //#endregion
 //#region src/lint/rules/model/j2-no-sleep.ts
+/** The doubles whose implementation STAGES the world rather than waits on it. */
+const DOUBLE_FACTORIES = /* @__PURE__ */ new Set([
+	"fn",
+	"mockImplementation",
+	"mockImplementationOnce",
+	"mockOf"
+]);
+/**
+* Is this call a test double taking an implementation — `vi.fn(…)`,
+* `x.mockImplementation(…)`, `mockOf<Port>({ … })`?
+*
+* The member forms are read by their PROPERTY alone, because the object is
+* whatever the test called its double.
+*/
+function isDoubleImplementation(node) {
+	const callee = child(node, "callee");
+	if (callee === void 0) return false;
+	const name = callee.type === "Identifier" ? identifierName(callee) : memberPropertyName(callee);
+	return name !== void 0 && DOUBLE_FACTORIES.has(name);
+}
 /**
 * CONVENTIONS J2 — a test contains no arbitrary sleep, wherever it sits:
 * synchronisation is `see()`/`gone()` inside a scenario and `waitUntil()`
@@ -5588,15 +5643,33 @@ const i4NoModuleDoubles = {
 * The reach is every test file — a sleep in a module test beside `src/` waits
 * exactly as blindly as one under `specs/`, and went unseen while the rule
 * gated on the folder.
+*
+* What it does NOT reach is a timer inside a test DOUBLE's implementation. A
+* `vi.fn(() => setTimeout(…))` is the world being staged — a clone that settles
+* late, a handler that answers out of order — and the assertion that follows is
+* about the ORDER results come back in, which no predicate can state: a
+* `waitUntil` waits for something to become true, while what this test needs is
+* for something to happen late. The test is not the one waiting, so the rule is
+* not about it.
 */
 const j2NoSleep = {
 	create(context) {
 		if (!isTestRole(roleOf(context.filename).role)) return {};
+		const doubles = [];
+		const insideADouble = (node) => doubles.some((span) => nodeStart(node) >= span.start && nodeEnd(node) <= span.end);
 		return {
 			CallExpression(node) {
-				const callee = node.callee;
+				if (isDoubleImplementation(node)) {
+					doubles.push({
+						end: nodeEnd(node),
+						start: nodeStart(node)
+					});
+					return;
+				}
+				if (insideADouble(node)) return;
+				const callee = child(node, "callee");
 				if (callee === void 0) return;
-				const name = callee.type === "Identifier" ? callee.name : memberPropertyName(callee);
+				const name = callee.type === "Identifier" ? identifierName(callee) : memberPropertyName(callee);
 				if (name === "setTimeout" || name === "setInterval") {
 					context.report({
 						messageId: "sleep",
@@ -5604,7 +5677,7 @@ const j2NoSleep = {
 					});
 					return;
 				}
-				if (name === "wait" && callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "Atomics") context.report({
+				if (name === "wait" && callee.type === "MemberExpression" && identifierName(child(callee, "object")) === "Atomics") context.report({
 					messageId: "sleep",
 					node
 				});

package/dist/playwright.adapter.js

@@ -1,49 +1,8 @@
-import { n as describeAmbiguity, r as formatElement, t as AmbiguousElementError } from "./ambiguity.js";
+import { a as formatElement, i as describeAmbiguity, n as widenedForWindow, r as AmbiguousElementError } from "./substring-warning.js";
 import { mkdtempSync } from "node:fs";
 import { resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { setTimeout } from "node:timers/promises";
-//#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 two-release window lasts, stated in the message itself. */
-const WINDOW = "16.0 and 16.1";
-/** 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.
-*/
-function warnSubstringOnly(element, where) {
-	const identity = identityOf(element);
-	if (reported.has(identity)) return false;
-	reported.add(identity);
-	console.warn(`@jterrazz/test: ${element.kind}('${element.name ?? ""}') matched nothing as a whole accessible name, and matched only as a SUBSTRING of a longer one (${where}). Names are exact from 16.0: write the name in full, scope it with \`within(…)\`, or state \`{ exact: false }\` to keep the old behaviour. This warning ships for ${WINDOW}; after that the substring match is gone and this is simply not found.`);
-	return true;
-}
-//#endregion
 //#region src/seams/playwright/playwright.adapter.ts
 /** How many candidates the ambiguity error enumerates before truncating. */
 const MAX_REPORTED_MATCHES = 10;
@@ -130,14 +89,12 @@ async function captureMatches(locator) {
 * would send the author to fix the wrong descriptor.
 */
 async function act(page, element, action) {
+	const target = await widenedForWindow(element, page.url(), probeOf(page)) ?? element;
 	try {
-		return await action(locate(page, element));
+		return await action(locate(page, target));
 	} catch (error) {
-		if (!isStrictViolation(error)) {
-			await reportSubstringOnly(page, element);
-			throw error;
-		}
-		const culprit = await findAmbiguousLevel(page, element);
+		if (!isStrictViolation(error)) throw error;
+		const culprit = await findAmbiguousLevel(page, target);
 		const matches = await captureMatches(locate(page, culprit));
 		throw new AmbiguousElementError(describeAmbiguity({
 			element: culprit,
@@ -146,23 +103,15 @@ async function act(page, element, action) {
 		}));
 	}
 }
-/**
-* Say so when a descriptor found NOTHING as a whole name but would have found
-* something as a substring — the one shape the whole-name default changes.
-*
-* Asked only on the failure path, and only for a descriptor that stated no
-* `exact` of its own: an author who wrote `{ exact: false }` chose the
-* substring, and one who wrote `{ exact: true }` was already exact.
-*/
-async function reportSubstringOnly(page, element) {
-	if (element.exact !== void 0 || element.name === void 0) return;
-	try {
-		if (await locate(page, element).count() > 0) return;
-		if (await locate(page, {
-			...element,
-			exact: false
-		}).count() > 0) warnSubstringOnly(element, page.url());
-	} catch {}
+/** What the transitional window may ask of the page. */
+function probeOf(page) {
+	return {
+		count: async (element) => await locate(page, element).count(),
+		nameOf: async (element) => {
+			const [match] = await captureMatches(locate(page, element));
+			return match?.accessibleName ?? match?.text;
+		}
+	};
 }
 /** Walk the scope chain outside-in; the outermost ambiguous level is the fault. */
 async function findAmbiguousLevel(page, element) {

package/dist/{ambiguity.js → substring-warning.js}

@@ -143,4 +143,102 @@ function describeAmbiguity(options) {
 	].join("\n");
 }
 //#endregion
-export { describeAmbiguity as n, formatElement as r, AmbiguousElementError as t };
+//#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";
+/** 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.
+*/
+function warnSubstringOnly(element, where, found) {
+	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()}'.`;
+	console.warn(`@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;
+}
+/**
+* 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 probes are counts, which wait for
+* nothing, and the common case (the name matches whole) costs one per level.
+*/
+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, or would
+* designate nothing either way.
+*/
+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;
+		warnSubstringOnly(candidate, where, await probe.nameOf(loose));
+		return loose;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { formatElement as a, describeAmbiguity as i, widenedForWindow as n, AmbiguousElementError as r, warnSubstringOnly as t };

package/dist/vitest.js

@@ -214,6 +214,60 @@ function rootDefaults() {
 		}
 	};
 }
+/** A glob list with its repeats taken out, or nothing where there is no list. */
+function eachOnce(globs) {
+	return globs === void 0 ? void 0 : [...new Set(globs)];
+}
+/**
+* The glob lists vite CONCATENATES rather than overrides, each glob kept once.
+*
+* A project built ON the defaults and then merged INTO them by
+* `defineSpecConfig` carried every default twice. Glob matching is idempotent,
+* so nothing collected differently — but the no-tests banner is the one place a
+* consumer ever reads that list, and it read as three merges of the same three
+* globs.
+*/
+function statedOnce(test) {
+	const exclude = eachOnce(test.exclude);
+	const include = eachOnce(test.include);
+	return {
+		...test,
+		...exclude === void 0 ? {} : { exclude },
+		...include === void 0 ? {} : { include }
+	};
+}
+/**
+* Build a project ON the defaults — the ONE way a project is built here.
+*
+* @internal
+*/
+function onProjectDefaults(stated) {
+	const merged = mergeConfig(projectDefaults(), stated);
+	return merged.test === void 0 ? merged : {
+		...merged,
+		test: statedOnce(merged.test)
+	};
+}
+/**
+* Is every project an inline object — one this preset merged its defaults into?
+* A project named by a glob or handed as a promise carries a config this call
+* never saw, and the root's exclusions are the only ones it gets from here.
+*/
+function allInline(projects) {
+	return projects.every((project) => typeof project === "object" && project !== null && !("then" in project));
+}
+/**
+* The root's exclusions, beside projects that already carry them.
+*
+* With `projects`, the root collects nothing itself: its `exclude` only travels
+* INTO each project, where vitest CONCATENATES it with the project's own — so
+* every preset glob reached the banner twice. The preset's own are dropped
+* here, since each inline project states them in full; what the CONSUMER stated
+* at the root stays, because no project holds a copy of that.
+*/
+function rootExcludeBeside(projects, exclude) {
+	return allInline(projects) ? exclude.filter((glob) => !EXCLUDE.includes(glob)) : exclude;
+}
 /**
 * A project inherits NOTHING from the root `test` block — vitest resolves each
 * project as its own config — so the defaults are merged into every inline one.
@@ -222,19 +276,26 @@ function rootDefaults() {
 */
 function withProjectDefaults(project) {
 	if (typeof project !== "object" || project === null || "then" in project) return project;
-	return mergeConfig(projectDefaults(), project);
+	return onProjectDefaults(project);
 }
 function defineSpecConfig(config = {}) {
 	const { literate: literateOptions, ...userConfig } = config;
 	const stated = literateOptions ? mergeConfig({ plugins: [literate(literateOptions)] }, userConfig) : userConfig;
 	const merged = mergeConfig(rootDefaults(), stated);
-	const projects = merged.test?.projects;
-	if (!projects) return merged;
+	const root = merged.test === void 0 ? void 0 : statedOnce(merged.test);
+	if (root === void 0) return merged;
+	const { projects } = root;
+	if (projects === void 0) return {
+		...merged,
+		test: root
+	};
+	const inline = projects.map(withProjectDefaults);
 	return {
 		...merged,
 		test: {
-			...merged.test,
-			projects: projects.map(withProjectDefaults)
+			...root,
+			...root.exclude === void 0 ? {} : { exclude: rootExcludeBeside(inline, root.exclude) },
+			projects: inline
 		}
 	};
 }
@@ -242,7 +303,7 @@ function defineSpecConfig(config = {}) {
 //#region src/runner/facet-project.ts
 /** The globs a node facet collects, and the ones a caller stated instead. */
 function facetProject(facet, options) {
-	return mergeConfig(projectDefaults(), { test: {
+	return onProjectDefaults({ test: {
 		...options.exclude === void 0 ? {} : { exclude: options.exclude },
 		include: options.include ?? [`specs/${facet}/**/*.spec.ts`],
 		...options.serial === true ? { fileParallelism: false } : {},
@@ -578,7 +639,7 @@ async function component(options = {}) {
 	const { playwright } = await import("@vitest/browser-playwright");
 	const pipeline = options.vite === void 0 ? {} : await reroot(options.vite, root);
 	const consumerPlugins = Array.isArray(pipeline.plugins) ? pipeline.plugins : [];
-	const project = {
+	return onProjectDefaults({
 		...pipeline,
 		...jsxPipeline(pipeline),
 		optimizeDeps: { include: SEAM_DEPENDENCIES.filter(resolves) },
@@ -605,8 +666,7 @@ async function component(options = {}) {
 			sequence: { groupOrder: 2 },
 			...options.timeout === void 0 ? {} : { testTimeout: options.timeout }
 		}
-	};
-	return mergeConfig(projectDefaults(), project);
+	});
 }
 //#endregion
 //#region src/facets/integration/integration.project.ts
@@ -638,7 +698,7 @@ function mobile(options = {}) {
 * a 2-vCPU runner.
 */
 function website(options = {}) {
-	return mergeConfig(projectDefaults(), { test: {
+	return onProjectDefaults({ test: {
 		...options.exclude === void 0 ? {} : { exclude: options.exclude },
 		...options.serial === true ? { fileParallelism: false } : {},
 		include: options.include ?? ["specs/website/**/*.spec.ts"],
@@ -660,7 +720,7 @@ function website(options = {}) {
 */
 function unit(options = {}) {
 	const fromRoots = options.roots?.map((root) => `${root.replace(/\/+$/u, "")}/**/*.test.ts`);
-	return mergeConfig(projectDefaults(), { test: {
+	return onProjectDefaults({ test: {
 		exclude: options.exclude ?? ["specs/**", "**/*.test.tsx"],
 		include: options.include ?? fromRoots ?? ["**/*.test.ts"],
 		...options.serial === true ? { fileParallelism: false } : {},