@jterrazz/test 16.0.0 → 16.1.1

package/dist/oxlint.js

@@ -267,7 +267,7 @@ const RULE_DOCS = {
 	},
 	"c1-domain-structure": {
 		channel: "statique",
-		convention: "A specs tree DECLARES its shape through the `depth` option: `facet-domain` (the default — a test at facet/domain depth, a `*.specification.ts` at the facet root), `facet` (a test at the facet root OR one domain folder down, never deeper), `mirror` (a test at any depth ≥ 1, named after its directory), `off`. In every mode, `off` included: a directory with a leading underscore is GROUND, never a domain — no spec lives inside one. One exception, and only one: ground may be CODE, and a `<module>.test.ts` sitting BESIDE the `<module>.ts` it tests is legal there (that is I2). A test with no neighbouring module, or a `*.specification.ts`, is still a violation. A `.test.tsx` is out of reach: a rendered unit is specified beside its component, never in a facet/domain tree — I2 holds its neighbourhood.",
+		convention: "A specs tree DECLARES its shape through the `depth` option: `facet-domain` (the default — a test at facet/domain depth, a `*.specification.ts` at the facet root), `facet` (a test at the facet root OR one domain folder down, never deeper), `mirror` (a test at any depth ≥ 1, named after its directory), `off`. A first-level folder that is no facet — a repository suite, `surface/` or `lint/` — is judged by the same depth as a facet is. In every mode, `off` included: a directory with a leading underscore is GROUND, never a domain — no spec lives inside one. One exception, and only one: ground may be CODE, and a `<module>.test.ts` sitting BESIDE the `<module>.ts` it tests is legal there (that is I2). A test with no neighbouring module, or a `*.specification.ts`, is still a violation. A `.test.tsx` is out of reach: a rendered unit is specified beside its component, never in a facet/domain tree — I2 holds its neighbourhood.",
 		facet: "model",
 		family: "C",
 		fix: "Move the file to the depth the tree declares, or declare the depth the tree actually has.",
@@ -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 is out of reach: the double is staging the world, not the test waiting on it. A double is a factory call (`vi.fn(…)`, `mockImplementation(…)`, a `mockOf` handler) or a function-valued PROPERTY of an object literal, which is the plainest double there is — `const git: GitGateway = { cloneRepository: async () => … }`, where the object itself is the double.",
 		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,40 @@ 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);
+}
+/**
+* The FUNCTION a property of an object literal holds, or `undefined`.
+*
+* A double is not always built by a factory: the plainest one there is, in a
+* test file, is an object literal whose properties are the port's methods —
+* `const git: GitGateway = { cloneRepository: async () => … }`. The object IS
+* the double, so a timer in one of its methods stages the world exactly as
+* `vi.fn(() => setTimeout(…))` does, and judging it as the test sleeping asked
+* an author to remove the very thing under test.
+*/
+function implementationOf(node) {
+	const value = child(node, "value");
+	return value?.type === "ArrowFunctionExpression" || value?.type === "FunctionExpression" ? value : void 0;
+}
 /**
 * CONVENTIONS J2 — a test contains no arbitrary sleep, wherever it sits:
 * synchronisation is `see()`/`gone()` inside a scenario and `waitUntil()`
@@ -5588,15 +5657,41 @@ 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. A double written as a plain object literal is the same thing
+* said without a factory, and it counts too.
 */
 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 {
+			Property(node) {
+				const implementation = implementationOf(node);
+				if (implementation !== void 0) doubles.push({
+					end: nodeEnd(implementation),
+					start: nodeStart(implementation)
+				});
+			},
 			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 +5699,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,47 +1,45 @@
-import { n as describeAmbiguity, r as formatElement, t as AmbiguousElementError } from "./ambiguity.js";
+import { a as describeAmbiguity, i as AmbiguousElementError, o as formatElement, r as widenedForWindow, t as WINDOW_SETTLE_MS } 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
+//#region src/model/elements/aria-name.ts
 /**
-* The transitional warning for a name that matches only as a SUBSTRING.
+* The accessible name an ARIA snapshot states.
 *
-* 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 descriptor matches the name the BROWSER computes, and that name is not the
+* element's text: `<button><span>Experiments</span><span>9</span></button>`
+* reads as `Experiments9` through `textContent` and is named "Experiments 9",
+* a field's name comes from its label and is nowhere in its text at all, and a
+* name cut at eighty characters resolves to nothing. Reading the name off the
+* snapshot is what makes the spelling the window prints a spelling that can be
+* written back into a spec.
 *
-* 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.
+* The dialect is the one both surfaces already speak — playwright's, on the
+* page directly and through `server.commands` for a mounted component — so the
+* projection is stated once, here, and neither adapter computes a name itself.
+*/
+/**
+* The name of the FIRST node a snapshot describes: `- button "Experiments 9"`,
+* optionally followed by `:` and its children.
 *
-* 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.
+* A quote must follow the role across a SPACE. `- paragraph: "…"` is a node
+* with text and no name, and reading that text as a name would hand the author
+* a spelling no role descriptor matches on.
 */
-/** 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}`;
+const NAMED = /^-\s+[\w-]+\s+"(?<name>(?:[^"\\]|\\.)*)"/u;
+/** Undo the escaping the snapshot applies to a quote or a backslash inside a name. */
+function unescaped(name) {
+	return name.replaceAll(/\\(?<char>.)/gu, "$<char>");
 }
 /**
-* 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.
+* The accessible name the snapshot gives the node it describes, or `undefined`
+* when that node has none — an unnamed landmark, a paragraph of text.
 */
-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;
+function accessibleNameIn(snapshot) {
+	const [first] = snapshot.split("\n");
+	const name = (first === void 0 ? null : NAMED.exec(first.trim()))?.groups?.name;
+	return name === void 0 ? void 0 : unescaped(name);
 }
 //#endregion
 //#region src/seams/playwright/playwright.adapter.ts
@@ -130,14 +128,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 +142,65 @@ async function act(page, element, action) {
 		}));
 	}
 }
+/** What the transitional window may ask of the page. */
+function probeOf(page) {
+	return {
+		count: async (element) => await locate(page, element).count(),
+		nameOf: async (element) => await wholeNameOf(page, element),
+		settles: async (element) => await settles(page, element)
+	};
+}
 /**
-* 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.
+* Does the descriptor arrive if the page is given the settle budget?
 *
-* 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.
+* A poll rather than `waitFor`, for the reason the rest of this adapter has no
+* `.first()`: waiting on the locator itself would have to narrow a strict
+* locator to one element, and a count answers the same question without
+* touching the mechanism W3 rests on. The locator is rebuilt every round, so a
+* navigation that replaced the document is read on the new one.
 */
-async function reportSubstringOnly(page, element) {
-	if (element.exact !== void 0 || element.name === void 0) return;
+async function settles(page, element) {
+	const deadline = Date.now() + WINDOW_SETTLE_MS;
+	for (;;) {
+		if (await countOrZero(page, element) > 0) return true;
+		if (Date.now() >= deadline) return false;
+		await setTimeout(VALUE_POLL_MS);
+	}
+}
+/** A count taken mid-navigation throws; the page is simply not answering yet. */
+async function countOrZero(page, element) {
 	try {
-		if (await locate(page, element).count() > 0) return;
-		if (await locate(page, {
-			...element,
-			exact: false
-		}).count() > 0) warnSubstringOnly(element, page.url());
+		return await locate(page, element).count();
+	} catch {
+		return 0;
+	}
+}
+/**
+* The name to WRITE for this descriptor — the whole one, never truncated.
+*
+* A role descriptor matches the accessible name the browser computed, so the
+* name is read off the ARIA snapshot, which is that same computation: the text
+* content glues inline children with no separator (`Experiments9` for a button
+* named "Experiments 9") and a field's name is its label, which its text never
+* carries at all. A `text` descriptor matches text, so text is what it is told
+* to write.
+*/
+async function wholeNameOf(page, element) {
+	const locator = locate(page, element);
+	if (element.kind !== "text") try {
+		const named = accessibleNameIn(await locator.ariaSnapshot());
+		if (named !== void 0) return named;
 	} catch {}
+	return await wholeTextOf(locator);
+}
+/** The element's text, whitespace-collapsed and WHOLE — a name cut mid-word resolves to nothing. */
+async function wholeTextOf(locator) {
+	try {
+		const collapsed = (await locator.evaluate((node) => node.textContent ?? "")).replaceAll(/\s+/gu, " ").trim();
+		return collapsed === "" ? void 0 : collapsed;
+	} catch {
+		return;
+	}
 }
 /** Walk the scope chain outside-in; the outermost ambiguous level is the fault. */
 async function findAmbiguousLevel(page, element) {