@jterrazz/test 16.1.0 → 16.1.1

package/dist/appium.adapter.js

@@ -1,4 +1,4 @@
-import { a as formatElement, r as AmbiguousElementError, t as warnSubstringOnly } from "./substring-warning.js";
+import { i as AmbiguousElementError, n as warnSubstringOnly, o as formatElement } from "./substring-warning.js";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { tmpdir } from "node:os";
@@ -430,7 +430,7 @@ var AppiumAdapter = class {
 		const first = matches[0];
 		if (first === void 0 || await matches.length !== 1) return null;
 		const evidence = await captureMatch(first);
-		warnSubstringOnly(level, this.options.udid, evidence.label);
+		await warnSubstringOnly(level, this.options.udid, evidence.label);
 		return loose;
 	}
 	/** Enumerate the candidates' evidence, truncated. */

package/dist/browser/index.js

@@ -1358,6 +1358,45 @@ function describeAmbiguity(options) {
 	].join("\n");
 }
 //#endregion
+//#region src/model/elements/aria-name.ts
+/**
+* The accessible name an ARIA snapshot states.
+*
+* 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.
+*
+* 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.
+*
+* 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.
+*/
+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>");
+}
+/**
+* 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 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/model/elements/substring-warning.ts
 /**
 * The transitional warning for a name that matches only as a SUBSTRING.
@@ -1379,6 +1418,14 @@ function describeAmbiguity(options) {
 */
 /** 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. */
@@ -1391,15 +1438,26 @@ function identityOf(element) {
 * 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) {
+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()}'.`;
-	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.`);
+	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.
 *
@@ -1416,8 +1474,8 @@ function warnSubstringOnly(element, where, found) {
 *
 * 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.
+* 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 = [];
@@ -1437,8 +1495,16 @@ async function widenedForWindow(element, where, probe) {
 }
 /**
 * 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.
+* 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;
@@ -1449,12 +1515,23 @@ async function widenedLevel(candidate, where, probe) {
 			exact: false
 		};
 		if (await probe.count(loose) !== 1) return;
-		warnSubstringOnly(candidate, where, await probe.nameOf(loose));
+		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
 //#region src/seams/vitest-browser/vitest-browser.adapter.ts
 /**
@@ -1549,13 +1626,49 @@ function ambiguousLevel(element) {
 	for (const level of chain.slice(0, -1)) if (locate(page, level).elements().length > 1) return level;
 	return element;
 }
+/**
+* The name to WRITE for this descriptor — the whole one, never truncated.
+*
+* A role descriptor matches the accessible name the browser computed, and a
+* page cannot compute one: the snapshot comes back from the node side, of the
+* one node the locator's own selector names. Text content would be the wrong
+* answer — it glues inline children with no separator and carries nothing of a
+* field's label — except for a `text` descriptor, which matches text.
+*/
+async function wholeNameOf(element) {
+	const locator = locate(page, element);
+	if (element.kind !== "text") try {
+		const named = accessibleNameIn(await commands.ariaNode(locator.selector));
+		if (named !== void 0) return named;
+	} catch {}
+	const collapsed = (locator.query()?.textContent ?? "").replaceAll(/\s+/gu, " ").trim();
+	return collapsed === "" ? void 0 : collapsed;
+}
+/**
+* Does the descriptor arrive if the subject is given the settle budget?
+*
+* A mounted component never navigates, but it does re-render: a subject whose
+* name arrives with the state after a click is the same question a page asks
+* across a navigation, and one window answers both. The poll is vitest's own,
+* with the window's budget rather than the test's — what is being waited for
+* here is a surface settling, not an assertion coming true.
+*/
+async function settles(element) {
+	try {
+		await expect.poll(() => locate(page, element).elements().length, { timeout: WINDOW_SETTLE_MS }).toBeGreaterThan(0);
+		return true;
+	} catch {
+		return false;
+	}
+}
 /** What the transitional window may ask of the mounted page. */
 const PROBE = {
 	count: async (element) => await Promise.resolve(locate(page, element).elements().length),
-	nameOf: async (element) => {
-		const [match] = candidates(locate(page, element));
-		return await Promise.resolve(match?.accessibleName ?? match?.text);
-	}
+	nameOf: async (element) => await wholeNameOf(element),
+	print: async (line) => {
+		await commands.notify(line);
+	},
+	settles: async (element) => await settles(element)
 };
 /**
 * Run one visitor action, turning "more than one match" into the W3 refusal.
@@ -2849,7 +2962,7 @@ const specification = {
 	mobile: () => refuse("specification.mobile()"),
 	website: () => refuse("specification.website()")
 };
-const process = () => refuse("process()");
+const process$1 = () => refuse("process()");
 const ProcessHandle = nodeOnlyClass("ProcessHandle");
 const postgres = () => refuse("postgres()");
 const redis = () => refuse("redis()");
@@ -2864,4 +2977,4 @@ function text(value) {
 	return new TextAccessor(value, "text", "");
 }
 //#endregion
-export { Matcher, ProcessHandle, anthropic, banner, button, clock, complementary, component, content, contentinfo, defineContract, defineContracts, dialog, disabled, enabled, field, focused, form, heading, http, intercept, link, listitem, main, match, mockOf, navigation, openai, option, postgres, process, redis, region, required, row, search, selected, specification, sqlite, status, table, testId, text, valued, waitUntil, within };
+export { Matcher, ProcessHandle, anthropic, banner, button, clock, complementary, component, content, contentinfo, defineContract, defineContracts, dialog, disabled, enabled, field, focused, form, heading, http, intercept, link, listitem, main, match, mockOf, navigation, openai, option, postgres, process$1 as process, redis, region, required, row, search, selected, specification, sqlite, status, table, testId, text, valued, waitUntil, within };

package/dist/checker.js

@@ -1370,6 +1370,40 @@ const JEST_CONFIG = /^jest\.config\.[cm]?[jt]s$/u;
 const JEST_REACH = /\b(?:roots|testMatch|testPathDirs|testPathIgnorePatterns)\s*:\s*\[(?<paths>[^\]]*)\]/gu;
 /** One quoted entry of such a list. */
 const JEST_PATH = /['"`](?<path>[^'"`\n]*)['"`]/gu;
+/** The file a pnpm workspace is declared in, whichever spelling the repository uses. */
+const PNPM_WORKSPACE = ["pnpm-workspace.yaml", "pnpm-workspace.yml"];
+/** Does this directory DECLARE a workspace — npm/bun `workspaces`, or pnpm's own file? */
+function declaresWorkspace(dir) {
+	if (PNPM_WORKSPACE.some((name) => existsSync(join(dir, name)))) return true;
+	const manifest = readManifest(dir);
+	return manifest !== null && workspacePatterns(manifest).length > 0;
+}
+/**
+* The workspace a member belongs to, found by walking UP from the member.
+*
+* The jest config that collects a member's tests is not always below it: in the
+* layout the allowance was written for, the app owning the only working React
+* Native toolchain roots into the library BESIDE it. Read from the member's own
+* anchor, the walk below it found nothing, so `cd packages/native &&
+* jterrazz-test-check` — which is what that member's own gate runs — reported
+* F8 while the root-anchored run cleared it. Two directions, two verdicts, on
+* one member: the chapter's contract is that a path-less run reports what the
+* per-root and per-member runs report.
+*
+* The walk stops at the first directory that declares a workspace, and never
+* leaves the checkout: a `.git` is where this repository ends and somebody
+* else's tree begins — a directory in a clone, a FILE in a worktree, so its
+* kind is never asked.
+*/
+function workspaceRootOf(memberDir) {
+	let current = memberDir;
+	for (;;) {
+		if (declaresWorkspace(current) || existsSync(join(current, ".git"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return memberDir;
+		current = parent;
+	}
+}
 /** Every `jest.config.*` under `rootDir`, by absolute path — read once per root. */
 const jestConfigs = /* @__PURE__ */ new Map();
 /** Find them, bounded by the same skips and depth the member walk uses. */
@@ -1550,8 +1584,8 @@ function simulatedDom(config, rootDir) {
 * test can see, while dropping a retired seam means writing its facet.
 */
 function seamDependencies(member) {
-	const { label, manifest, memberDir, rootDir, subject } = member;
-	return declaredSeams(manifest, declaresJest(manifest) || jestReachesMember(memberDir, rootDir)).map((seam) => ({
+	const { label, manifest, memberDir, subject } = member;
+	return declaredSeams(manifest, declaresJest(manifest) || jestReachesMember(memberDir, workspaceRootOf(memberDir))).map((seam) => ({
 		file: join(label, "package.json"),
 		line: lineOfKey(memberDir, seam.name),
 		message: seam.kind === "carried" ? `${subject}: \`${seam.name}\` is a transitive of \`@jterrazz/test\` — remove the declaration (F8 — see docs/19-linting.md#f8-no-seam-dependency)` : `${subject}: \`${seam.name}\` is a seam \`@jterrazz/test\` replaced — the facet is \`component()\`, \`website()\`, \`clock\` or \`intercept()\`; remove the declaration (F8 — see docs/19-linting.md#f8-no-seam-dependency)`,
@@ -1590,7 +1624,6 @@ function checkMember(memberDir, rootDir) {
 			label,
 			manifest,
 			memberDir,
-			rootDir,
 			subject
 		}),
 		...anchoredToRoot(checkSpecOutsideSpecs(memberDir), label)

package/dist/index.d.ts

@@ -1730,9 +1730,11 @@ type DomMount = (container: HTMLElement) => (() => void) | void;
  */
 declare module 'vitest/browser' {
   interface BrowserCommands {
+    ariaNode: (selector: string) => Promise<string>;
     ariaTree: () => Promise<string>;
     goldenRead: (name: string) => Promise<null | string>;
     goldenWrite: (name: string, content: string) => Promise<string>;
+    notify: (line: string) => Promise<void>;
   }
 }
 //#endregion

package/dist/oxlint.cjs

@@ -271,7 +271,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.",
@@ -661,7 +661,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. 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.",
+		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.",
@@ -5639,6 +5639,20 @@ function isDoubleImplementation(node) {
 	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()`
 * everywhere else. Flags `setTimeout(…)` calls (bare or as a member, e.g.
@@ -5654,7 +5668,8 @@ function isDoubleImplementation(node) {
 * 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.
+* 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) {
@@ -5662,6 +5677,13 @@ const j2NoSleep = {
 		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) {
 				if (isDoubleImplementation(node)) {
 					doubles.push({

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.",
@@ -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. 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.",
+		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.",
@@ -5635,6 +5635,20 @@ function isDoubleImplementation(node) {
 	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()`
 * everywhere else. Flags `setTimeout(…)` calls (bare or as a member, e.g.
@@ -5650,7 +5664,8 @@ function isDoubleImplementation(node) {
 * 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.
+* 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) {
@@ -5658,6 +5673,13 @@ const j2NoSleep = {
 		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) {
 				if (isDoubleImplementation(node)) {
 					doubles.push({

package/dist/playwright.adapter.js

@@ -1,8 +1,47 @@
-import { a as formatElement, i as describeAmbiguity, n as widenedForWindow, r as AmbiguousElementError } from "./substring-warning.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/aria-name.ts
+/**
+* The accessible name an ARIA snapshot states.
+*
+* 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.
+*
+* 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.
+*
+* 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.
+*/
+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>");
+}
+/**
+* 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 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
 /** How many candidates the ambiguity error enumerates before truncating. */
 const MAX_REPORTED_MATCHES = 10;
@@ -107,12 +146,62 @@ async function act(page, element, action) {
 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;
-		}
+		nameOf: async (element) => await wholeNameOf(page, element),
+		settles: async (element) => await settles(page, element)
 	};
 }
+/**
+* Does the descriptor arrive if the page is given the settle budget?
+*
+* 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 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 {
+		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) {
 	const chain = [];

package/dist/substring-warning.js

@@ -164,6 +164,14 @@ function describeAmbiguity(options) {
 */
 /** 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. */
@@ -176,15 +184,26 @@ function identityOf(element) {
 * 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) {
+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()}'.`;
-	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.`);
+	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.
 *
@@ -201,8 +220,8 @@ function warnSubstringOnly(element, where, found) {
 *
 * 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.
+* 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 = [];
@@ -222,8 +241,16 @@ async function widenedForWindow(element, where, probe) {
 }
 /**
 * 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.
+* 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;
@@ -234,11 +261,22 @@ async function widenedLevel(candidate, where, probe) {
 			exact: false
 		};
 		if (await probe.count(loose) !== 1) return;
-		warnSubstringOnly(candidate, where, await probe.nameOf(loose));
+		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 { formatElement as a, describeAmbiguity as i, widenedForWindow as n, AmbiguousElementError as r, warnSubstringOnly as t };
+export { describeAmbiguity as a, AmbiguousElementError as i, warnSubstringOnly as n, formatElement as o, widenedForWindow as r, WINDOW_SETTLE_MS as t };

package/dist/vitest.js

@@ -350,6 +350,23 @@ function goldenPath(testPath, name) {
 const ariaTree = async (context) => {
 	return await (await context.frame()).locator("body").ariaSnapshot();
 };
+/**
+* The ARIA snapshot of ONE node, named by the selector the page's locator
+* carries — the accessible name, as the browser computed it, for a page that
+* cannot compute one itself.
+*/
+const ariaNode = async (context, selector) => {
+	return await (await context.frame()).locator(selector).ariaSnapshot();
+};
+/**
+* A line the page has for whoever is running the suite, written on the node
+* side's stderr — the one channel vitest's default reporter passes through.
+* The console is captured and dropped, so a page that printed to it printed to
+* nobody.
+*/
+const notify = (_context, line) => {
+	process.stderr.write(`${line}\n`);
+};
 /** The golden's current content, or `null` when it does not exist yet. */
 const goldenRead = (context, name) => {
 	const path = goldenPath(context.testPath, name);
@@ -367,9 +384,11 @@ const goldenWrite = (context, name, content) => {
 * page calls and the names the project registers cannot drift.
 */
 const COMPONENT_COMMANDS = {
+	ariaNode,
 	ariaTree,
 	goldenRead,
-	goldenWrite
+	goldenWrite,
+	notify
 };
 //#endregion
 //#region src/facets/component/component.project.ts

package/docs/03-testing.md

@@ -108,9 +108,9 @@ The package proves itself in five layers, and they are meant to be read from the
 
 | Layer                   | Where                                                   | What it judges                                                           | Files |
 | ----------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------ | ----- |
-| Module tests            | `src/**/*.test.ts` beside the module                    | one module, through its own exports, with nothing started                | 52    |
+| Module tests            | `src/**/*.test.ts` beside the module                    | one module, through its own exports, with nothing started                | 54    |
 | Rule tests              | `src/lint/rules/<facet>/<rule>.test.ts` beside the rule | one rule: what it flags, what it leaves alone, and the message it prints | 56    |
-| The package’s own specs | `specs/<facet>/`                                        | the framework's own facets, each met through its constructor             | 65    |
+| The package’s own specs | `specs/<facet>/`                                        | the framework's own facets, each met through its constructor             | 67    |
 | The lint suite          | `specs/lint/**`                                         | the built binary end to end, over fixture projects                       | 88    |
 | Meta-tests              | `src/lint/*.test.ts`                                    | the corpus itself: the catalogue, the matrix, the cards, the floor       | 18    |
 
@@ -185,7 +185,7 @@ suite on the day it lands.
 
 <!-- GENERATED:siblings — do not edit by hand; run `npm run docs`. Source: src/lint/siblings.ts -->
 
-Today **81 modules** have no sibling test, and every one of them is claimed:
+Today **80 modules** have no sibling test, and every one of them is claimed:
 
 | Kind                                    | Proven instead by                                                                                                                                                                                                                              |
 | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -197,7 +197,7 @@ Today **81 modules** have no sibling test, and every one of them is claimed:
 | a mobile module that needs a device (2) | the mobile facet has no tree under `specs/` and cannot have one here (M1); what a device is NOT needed for — resolving the simulator, projecting the page source, wording the ambiguity — has its own sibling test, and these two are the rest |
 | a facet module (8)                      | the facet is proven end to end by its own tree under `specs/<facet>/`, which is what the constructor exists to make possible                                                                                                                   |
 | a result accessor (7)                   | an accessor is what a terminal action hands back: it is exercised by every spec that asserts on a result, and `result.test.ts` holds the base                                                                                                  |
-| a seam adapter (13)                     | a seam is proven through the facet that drives it — a probe that could only reach it directly is an integration spec under `specs/integration/<seam>/` (chapter 03)                                                                            |
+| a seam adapter (12)                     | a seam is proven through the facet that drives it — a probe that could only reach it directly is an integration spec under `specs/integration/<seam>/` (chapter 03)                                                                            |
 | a bundled CLI entry (3)                 | it is argument parsing over a module that has its own tests, and `specs/lint/` runs the built binary end to end                                                                                                                                |
 | a lint-layer module (4)                 | the lint layer is proven by the rule tests beside each rule and by `specs/lint/`, which runs the real oxlint binary and the real checker over fixture projects                                                                                 |
 | a chain or runner internal (7)          | it is reached through the chain, so its proof is the facet specs that drive the chain — a direct test would assert on a seam nothing else speaks to                                                                                            |
@@ -275,18 +275,18 @@ What the framework can do, and how many of this package’s own test FILES carry
 | `.call()`    | —   | —    | —   | 6           | —       | —      | —         | —      |
 | `.exec()`    | —   | —    | 7   | —           | —       | —      | —         | —      |
 | `.run()`     | —   | —    | 2   | —           | —       | —      | —         | —      |
-| `.visit()`   | —   | —    | —   | —           | 10      | —      | —         | —      |
+| `.visit()`   | —   | —    | —   | —           | 11      | —      | —         | —      |
 | `.fetch()`   | —   | —    | —   | —           | 2       | —      | —         | —      |
 | `.open()`    | —   | —    | —   | —           | —       | 0      | —         | —      |
-| `.render()`  | —   | —    | —   | —           | —       | —      | 14        | —      |
+| `.render()`  | —   | —    | —   | —           | —       | —      | 15        | —      |
 
 ### Verb
 
 | Capability | api | jobs | cli | integration | website | mobile | component | module |
 | ---------- | --- | ---- | --- | ----------- | ------- | ------ | --------- | ------ |
-| `see`      | —   | —    | —   | —           | 5       | 0      | 14        | —      |
+| `see`      | —   | —    | —   | —           | 6       | 0      | 15        | —      |
 | `fill`     | —   | —    | —   | —           | 3       | 0      | 2         | —      |
-| `click`    | —   | —    | —   | —           | 3       | —      | 4         | —      |
+| `click`    | —   | —    | —   | —           | 4       | —      | 5         | —      |
 | `gone`     | —   | —    | —   | —           | 2       | —      | 4         | —      |
 | `press`    | —   | —    | —   | —           | 0       | —      | 2         | —      |
 | `hover`    | —   | —    | —   | —           | 0       | —      | 1         | —      |
@@ -301,14 +301,14 @@ What the framework can do, and how many of this package’s own test FILES carry
 
 | Capability      | api | jobs | cli | integration | website | mobile | component | module |
 | --------------- | --- | ---- | --- | ----------- | ------- | ------ | --------- | ------ |
-| `button`        | —   | —    | —   | —           | 3       | 0      | 4         | —      |
-| `field`         | —   | —    | —   | —           | 3       | 0      | 3         | —      |
+| `button`        | —   | —    | —   | —           | 4       | 0      | 5         | —      |
+| `field`         | —   | —    | —   | —           | 4       | 0      | 3         | —      |
 | `content`       | —   | —    | —   | —           | 3       | 0      | 10        | —      |
 | `testId`        | —   | —    | —   | —           | 0       | 0      | 1         | —      |
-| `heading`       | —   | —    | —   | —           | 0       | —      | 1         | —      |
-| `link`          | —   | —    | —   | —           | 2       | —      | 2         | —      |
+| `heading`       | —   | —    | —   | —           | 1       | —      | 1         | —      |
+| `link`          | —   | —    | —   | —           | 3       | —      | 2         | —      |
 | `dialog`        | —   | —    | —   | —           | 0       | —      | 1         | —      |
-| `status`        | —   | —    | —   | —           | 0       | —      | 2         | —      |
+| `status`        | —   | —    | —   | —           | 0       | —      | 3         | —      |
 | `table`         | —   | —    | —   | —           | 0       | —      | 1         | —      |
 | `row`           | —   | —    | —   | —           | 0       | —      | 1         | —      |
 | `listitem`      | —   | —    | —   | —           | 0       | —      | 1         | —      |
@@ -345,8 +345,8 @@ What the framework can do, and how many of this package’s own test FILES carry
 | `.containerIds` | —   | —    | 1   | —           | —       | —      | —         | —      |
 | `.value`        | —   | —    | —   | 6           | —       | —      | —         | —      |
 | `.error`        | —   | —    | —   | 5           | —       | —      | —         | —      |
-| `.tree`         | —   | —    | —   | —           | 2       | —      | 3         | —      |
-| `.content`      | —   | —    | —   | —           | 4       | 0      | 11        | —      |
+| `.tree`         | —   | —    | —   | —           | 2       | —      | 4         | —      |
+| `.content`      | —   | —    | —   | —           | 4       | 0      | 12        | —      |
 | `.console`      | —   | —    | —   | —           | 1       | —      | 3         | —      |
 | `.errors`       | —   | —    | —   | —           | 4       | —      | 5         | —      |
 | `.html`         | —   | —    | —   | —           | 0       | —      | 5         | —      |
@@ -414,7 +414,7 @@ What the framework can do, and how many of this package’s own test FILES carry
 ### Exemptions
 
 - no mobile tree: an iOS simulator is not something CI provisions (M1) — `services`·mobile, `root`·mobile, `backend`·mobile, `device`·mobile, `app`·mobile, `timeouts`·mobile, `.intercept()`·mobile, `.open()`·mobile, `see`·mobile, `fill`·mobile, `tap`·mobile, `button`·mobile, `field`·mobile, `content`·mobile, `testId`·mobile, `.content`·mobile, `.screen`·mobile
-- the surface ships and this package does not specify it here yet — `root`·cli, `root`·website, `root`·component, `backend`·website, `external`·website, `clock`·component, `locale`·component, `timezone`·component, `viewport`·component, `.clock()`·jobs, `.intercept()`·website, `press`·website, `hover`·website, `check`·website, `goto`·website, `testId`·website, `heading`·website, `dialog`·website, `status`·website, `table`·website, `row`·website, `listitem`·website, `banner`·website, `banner`·component, `complementary`·website, `complementary`·component, `contentinfo`·component, `form`·website, `form`·component, `search`·website, `search`·component, `.file()`·api, `.file()`·integration, `.directory()`·api, `.directory()`·integration, `.html`·website, `.title`·website, `.links`·website, `toMatchRows()`·component, `.json body`·api
+- the surface ships and this package does not specify it here yet — `root`·cli, `root`·website, `root`·component, `backend`·website, `external`·website, `clock`·component, `locale`·component, `timezone`·component, `viewport`·component, `.clock()`·jobs, `.intercept()`·website, `press`·website, `hover`·website, `check`·website, `goto`·website, `testId`·website, `dialog`·website, `status`·website, `table`·website, `row`·website, `listitem`·website, `banner`·website, `banner`·component, `complementary`·website, `complementary`·component, `contentinfo`·component, `form`·website, `form`·component, `search`·website, `search`·component, `.file()`·api, `.file()`·integration, `.directory()`·api, `.directory()`·integration, `.html`·website, `.title`·website, `.links`·website, `toMatchRows()`·component, `.json body`·api
 - the package serves its own fixture site, so `server` is what it proves; `url` targets an already-running deployment, which is a consumer shape (A11 states the XOR) — `url`·website
 - a job's oracle is the table it wrote (`toMatchRows`): its result carries no file and no directory — `toMatch('<name>')`·jobs
 - the engine owns the family (proven in the module column); a facet uses the ones its goldens need — `{{any}}`·api, `{{any}}`·integration, `{{any}}`·website, `{{base64}}`·api, `{{base64}}`·cli, `{{base64}}`·integration, `{{base64}}`·website, `{{date}}`·api, `{{date}}`·cli, `{{date}}`·integration, `{{date}}`·website, `{{duration}}`·api, `{{duration}}`·integration, `{{duration}}`·website, `{{email}}`·api, `{{email}}`·cli, `{{email}}`·integration, `{{email}}`·website, `{{float}}`·api, `{{float}}`·cli, `{{float}}`·integration, `{{float}}`·website, `{{hex}}`·api, `{{hex}}`·cli, `{{hex}}`·integration, `{{hex}}`·website, `{{int}}`·api, `{{int}}`·cli, `{{int}}`·integration, `{{int}}`·website, `{{ip}}`·api, `{{ip}}`·cli, `{{ip}}`·integration, `{{ip}}`·website, `{{iso8601}}`·api, `{{iso8601}}`·cli, `{{iso8601}}`·integration, `{{iso8601}}`·website, `{{number}}`·api, `{{number}}`·cli, `{{number}}`·integration, `{{number}}`·website, `{{path}}`·api, `{{path}}`·cli, `{{path}}`·integration, `{{path}}`·website, `{{port}}`·api, `{{port}}`·cli, `{{port}}`·integration, `{{port}}`·website, `{{semver}}`·api, `{{semver}}`·integration, `{{semver}}`·website, `{{sha}}`·api, `{{sha}}`·cli, `{{sha}}`·integration, `{{sha}}`·website, `{{string}}`·api, `{{string}}`·integration, `{{string}}`·website, `{{time}}`·api, `{{time}}`·cli, `{{time}}`·integration, `{{time}}`·website, `{{ulid}}`·api, `{{ulid}}`·cli, `{{ulid}}`·integration, `{{ulid}}`·website, `{{url}}`·api, `{{url}}`·integration, `{{url}}`·website, `{{uuid}}`·api, `{{uuid}}`·cli, `{{uuid}}`·integration, `{{uuid}}`·website, `{{workdir}}`·api, `{{workdir}}`·integration, `{{workdir}}`·website
@@ -436,7 +436,7 @@ The table is GENERATED from the files, because the channel grows faster than a h
 | `src/lint/ast.test.ts`                      | specsAnchor                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 7     |
 | `src/lint/cards.test.ts`                    | signature cards — generation freshness (meta-test) · signature cards — completeness against the facet declaration (meta-test) · the skill routes to the cards (meta-test) · signature cards — what a card says                                                                                                                                                                                                                                                                                       | 15    |
 | `src/lint/checker-crossfile.test.ts`        | checker suppression — suppressedLines (checker-disable comments)                                                                                                                                                                                                                                                                                                                                                                                                                                     | 9     |
-| `src/lint/checker-member.test.ts`           | the member pass — what a workspace member owes                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 17    |
+| `src/lint/checker-member.test.ts`           | the member pass — what a workspace member owes                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 18    |
 | `src/lint/checker-spec.test.ts`             | fixSpecDocument — key order and block scalars                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 5     |
 | `src/lint/checker.test.ts`                  | conventions checker — findUnknownTokens (D4) · conventions checker — findKnownTokens (D10) · conventions checker — checkConventionFiles (D4)                                                                                                                                                                                                                                                                                                                                                         | 8     |
 | `src/lint/coverage.test.ts`                 | the coverage ratchet                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 8     |

package/docs/13-elements.md

@@ -214,8 +214,14 @@ The window reaches every LEVEL of a chain, not the target alone: `within(button(
 
 The window is asked BEFORE the verb acts, 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. What it costs on the ordinary path is one count per level of the chain, which waits for nothing.
 
+**A widening is decided on a SETTLED surface.** A count is one observation, and a `see()` fired right after a navigating `click()` takes it on the page being left: a descriptor that is perfectly exact on the destination read as substring-only, non-deterministically, and the tell was the printed name coming back equal to the name already written. So a level that designates nothing and has exactly one substring match is given five seconds to arrive before anything is printed, and the verdict is reached once per descriptor per run — a scenario that clicks the same link in ten tests waits on the first of them. Nothing else waits: a descriptor with no substring match at all, which is every ordinary `gone()`, is still two counts and no pause.
+
 It widens on exactly one match, never on several: a name two elements carry in part is the ambiguity the old default hid, and the window may not resolve it by guessing which one the author meant. That descriptor designates nothing, as W3 says, and the refusal is the one to read.
 
+**The name it prints is the ACCESSIBLE name, and the whole of it.** It is read off the element's ARIA snapshot — the browser's own name computation, which is what the descriptor matched on — and never off the text content: a button holding two inline children reads as `Experiments9` through its text and is named "Experiments 9", and a field's name is its label, which its text carries nothing of. Nor is it truncated: a name cut at eighty characters, mid-word, designates nothing when it is written back. The one descriptor whose printed name is TEXT is `content()`, because text is what it matches. On a device the name is what the device reports as the element's label.
+
+**The line goes to stderr**, and never to the console. Vitest CAPTURES the console and its default reporter prints nothing of what it captured, so a warning written with `console.warn` is invisible in the very run that fired it — `npm test` showed zero lines on a run that had one, and a deadline nobody can see is a deadline nobody meets. The node-side adapters write the line to the runner's own stderr; a mounted component, which runs IN the page and has no stderr, hands it back to the node side through `server.commands`. Nothing but a plain `vitest --run` is needed to read it.
+
 ## `testId()` — the one escape hatch
 
 `testId(id)` reads `data-testid` on the web and the accessibility identifier on a device. It is the ONLY descriptor that names something a user cannot perceive, and rule W2 is an error on it: a `testId()` carries a same-line comment naming what the element lacks.

package/docs/18-conventions.md

@@ -46,6 +46,8 @@ covers (`<file>.test.ts`, I2), and the ASSEMBLED product sits under
 C12 and C18). A few specifications have neither address, and they are not
 mistakes.
 
+### What has no address of its own
+
 What they specify is a REPOSITORY's own surface: the subpaths its
 `package.json` publishes, a `.d.ts` beside every `.js` it ships, the lint guards
 a tree owes, the files a build is expected to write. There is no one module to
@@ -55,14 +57,39 @@ runner"); put beside a module under `src/`, I2 refuses them ("no neighbour
 `exports.ts` found"). Both refusals are right, and a legitimate file shape with
 no green position is a hole in the conventions, not a defect in the file.
 
+### The door, and the depth it is judged by
+
 **The third door is a FIRST-LEVEL folder under `specs/` that is not a facet
 name.** It is a repository suite: it covers a TREE rather than a product served
 through an entry. C12's rename clause does not reach it, C18 and C20 do not
-reach it, and C1's declared depth is what judges its shape. This package's own
-`specs/lint/` is one; a package whose product IS its published tree writes the
-same shape — a suite folder named for what it covers, holding one test that
-resolves every subpath the manifest publishes and one that holds each `.d.ts`
-to the `.js` beside it.
+reach it, and C1's declared depth is what judges its shape.
+
+**C1 judges a suite exactly as it judges a facet.** The suite folder is the
+first level and the tests sit one level down, in a folder named for what they
+cover: at the default depth, `specs/<suite>/<domain>/<aspect>.test.ts`. A test
+written straight into the suite folder is refused for the same reason one at a
+facet root is — the level that says what a file covers would be missing. This
+package's own `specs/lint/` is two levels deep for that reason.
+
+### The two names the estate shares
+
+Two suites carry names the whole estate shares, because two repositories
+inventing two names for one idea is the drift a vocabulary exists to stop: a
+package's own published SURFACE is `surface/`, and a repository's own lint
+guards are `lint/`. Every other suite is named for what it covers.
+
+```
+specs/
+├── surface/                      # what the package publishes
+│   └── package/
+│       ├── exports.test.ts       # every subpath the manifest resolves
+│       └── types.test.ts         # a `.d.ts` beside each `.js` it ships
+└── lint/                         # the guards the repository's own tree owes
+    └── <family>/
+        └── <rule>.test.ts
+```
+
+### The suffix, and the one thing the door does not license
 
 The files there carry `.test.ts` — the UNIT's word — because what they prove is
 read without assembling anything, and `unit()` is what collects them (`roots`,

package/docs/19-linting.md

@@ -141,26 +141,26 @@ Every rule the framework enforces, across its enforcement channels — **statiqu
 
 ### C — Files & folders
 
-| Code | Implementation                                                          | Channel  | Reach    | Convention                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Fix                                                                                                                                                                                                                                                                     | Rationale                                                                                                                                                                                                                                                                                                                                                         |
-| ---- | ----------------------------------------------------------------------- | -------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| C1   | <a id="c1-domain-structure"></a>`c1-domain-structure`                   | statique | specs    | 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.                                                                                          | Move the file to the depth the tree declares, or declare the depth the tree actually has.                                                                                                                                                                               | A fixed depth makes every file's place predictable and statically checkable.                                                                                                                                                                                                                                                                                      |
-| C4   | <a id="c4-contract-shape"></a>`c4-contract-shape`                       | statique | contract | Under `specs/**/contracts/`: the ROOT carries only `*.contracts.ts` facades (a default export built by `defineContracts(...)` or a composition re-export; named exports are scenarios) and the provider folders `http` \| `openai` \| `anthropic`. A unit contract is `<provider>/<kebab-name>.ts` with an `export default defineContract(...)` (or a factory returning one), and its `request` builder must name the provider of its own folder. A provider folder is flat and holds only `*.ts` and `*.response.json`.                                                                                                                                                                                                                                                                                                                                                                                                    | Move the file to the half it belongs to: a facade at the root, a unit under its provider.                                                                                                                                                                               | A fixed tree separates the public facade from the internal units and makes the FOLDER carry the provider — filenames go back to being domain words, and bulky data sits beside the contract that serves it.                                                                                                                                                       |
-| C6   | <a id="c6-tomatch-extension"></a>`c6-tomatch-extension`                 | statique | tests    | `toMatch`'s argument carries its extension (`'help.txt'`, `'<case>.aria.yaml'` for a tree golden), except for a directory snapshot; a file subject with no extension is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Write the fixture's full name, extension included.                                                                                                                                                                                                                      | The extension is part of the expected file's name — dropping it breaks `_expected/` resolution.                                                                                                                                                                                                                                                                   |
-| C7   | <a id="c7-seeds-sql-only"></a>`c7-seeds-sql-only`                       | statique | ground   | `_seeds/` holds `*.sql` files only; any other file is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Write the seed as SQL, or move the file to `_fixtures/` as the material it is.                                                                                                                                                                                          | `.seed()` carries database state only — no seed handlers, no prefix dispatch.                                                                                                                                                                                                                                                                                     |
-| C8   | <a id="c8-referenced-fixture-exists"></a>`c8-referenced-fixture-exists` | statique | tests    | A literal passed to `.request`/`.seed`/`.fixture`/`toMatch` must exist on disk under its conventional root; a missing path is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Create the file, or fix the name — the message prints the path it looked for.                                                                                                                                                                                           | Catching a typo statically avoids a failure that would only surface at run time.                                                                                                                                                                                                                                                                                  |
-| C10  | <a id="c10-contracts-boundary"></a>`c10-contracts-boundary`             | statique | tests    | Outside `specs/**/contracts/`, an import resolving into a provider folder (`contracts/{http,openai,anthropic}/…`) is an error: a test imports only the `*.contracts.ts` facades.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Add a named scenario export to the facade and import that instead.                                                                                                                                                                                                      | Unit contracts are composition details; going through the facade keeps each scenario named in the same place as the world it derives from.                                                                                                                                                                                                                        |
-| C11  | <a id="c11-contract-data-pairing"></a>`c11-contract-data-pairing`       | statique | contract | Inside a provider folder, every `*.response.json` and every `*.request.ts` has a `<stem>.ts` sibling — the stem is the name up to the FIRST dot (`events.fr.response.json` → `events.ts`). Orphan data is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Write the contract that serves the payload, or delete the payload.                                                                                                                                                                                                      | Data exists only as served by a contract — a file with no owner is dead weight no test ever loads.                                                                                                                                                                                                                                                                |
-| C13  | <a id="c13-underscored-ground"></a>`c13-underscored-ground`             | statique | specs    | Under `specs/`, a spec's ground carries a leading underscore: `_fixtures/`, `_expected/`, `_requests/`, `_seeds/`. A `fixtures/`, `expected/`, `requests/` or `seeds/` directory is a pre-14 name — an error naming the rename.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Rename the directory with the leading underscore the resolvers read.                                                                                                                                                                                                    | No resolver reads the underscore-less name any more: left as is, the tree goes invisible rather than wrong, and the failure lands one step past its cause.                                                                                                                                                                                                        |
-| C9   | <a id="c9-dead-fixtures"></a>`c9-dead-fixtures`                         | checker  | ground   | No dead fixtures: every file under `_seeds/`/`_requests/`/`_fixtures/` and every top-level entry of `_expected/` must be referenced; a feature directory with no test file and no `*.spec.yaml` is an orphan (a warning when the argument is not a literal). A `<case>.spec.yaml` references the fixtures its `fixture:` entries name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Reference it from the spec it stands under, or delete it.                                                                                                                                                                                                               | The C8 mirror — a fixture nothing references is dead weight that misleads the reader.                                                                                                                                                                                                                                                                             |
-| C12  | <a id="c12-spec-file-name"></a>`c12-spec-file-name`                     | checker  | specs    | 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. | 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. | 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.                                                                                                                                                            |
-| C14  | <a id="c14-pool-fixture-shared"></a>`c14-pool-fixture-shared`           | checker  | ground   | A pool fixture is SHARED, or it is local: a directory of `<specs>/_fixtures/` referenced (`$FIXTURES/<name>`) from a single spec directory — two documents of one leaf count as one — must live beside that leaf, at `<leaf>/_fixtures/<name>/`, referenced by the relative form. Zero references is the dead-fixture error (C9). Fixed by `--fix`: the directory is moved and the literals rewritten.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Run `jterrazz-test-check <root> --fix`; it moves the directory and rewrites what named it.                                                                                                                                                                              | A single scenario's fixture parked in the pool reads as shared ground: everyone assumes someone else depends on it and nobody dares touch it.                                                                                                                                                                                                                     |
-| C15  | <a id="c15-local-fixture-reach"></a>`c15-local-fixture-reach`           | checker  | ground   | A local fixture is read only from its own directory: a `fixture:`/`.fixture()` path containing `..`, or whose target leaves the `_fixtures/` of the spec naming it, is an error — ground shared by several leaves goes in the `$FIXTURES` pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Copy it under this leaf's own `_fixtures/`, or promote it to the pool.                                                                                                                                                                                                  | A leaf reaching into a neighbour's fixtures is the pool through another door, without the pool's visibility: the neighbour breaks a spec two folders away without knowing.                                                                                                                                                                                        |
-| C18  | <a id="c18-module-test-under-facet"></a>`c18-module-test-under-facet`   | checker  | specs    | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 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/`.                                                                                               | 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.                                                                                                                                                                                                                |
-| C20  | <a id="c20-facet-folder"></a>`c20-facet-folder`                         | checker  | specs    | A first-level folder named for one of the six facets holds a `*.specification.ts(x)` calling `specification.<facet>(`. Positive-only: any other first-level name is a repository suite, judged by C1's declared depth alone.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Create the specification the folder promises, or rename the folder.                                                                                                                                                                                                     | Folder = constructor is the law the fork rests on; a facet folder with no runner tells the reader something false before they open a file.                                                                                                                                                                                                                        |
-| C21  | <a id="c21w-ground-owned-by-one"></a>`c21w-ground-owned-by-one`         | checker  | ground   | Ground in a leaf holding ≥ 2 node tests (`.test.ts`, `.spec.ts`) that a single one of them reads is a warning. A `.test.tsx` tree is out of reach, as it is for C1.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Give that spec its own domain folder, with the ground beside it.                                                                                                                                                                                                        | Ground one spec reads, parked where several sit, reads as shared: everyone assumes someone else depends on it and nobody dares touch it.                                                                                                                                                                                                                          |
-| C23  | <a id="c23-seed-no-clock-read"></a>`c23-seed-no-clock-read`             | checker  | ground   | A `_seeds/**/*.sql` states absolute timestamps: `CURRENT_TIMESTAMP`/`CURRENT_DATE`/`CURRENT_TIME`, `NOW()` and the quoted `'now'` SQLite's date functions take (`datetime('now')`, `strftime(…, 'now')`, `date('now', '-1 day')`) are refused. A comment is not state, so a clock read inside one is not a finding.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Write the instant the case is about, and pin the run's clock with `.clock()` on the chain.                                                                                                                                                                              | A seed that reads the clock makes the row's date the date the suite happened to run: a case about "published yesterday" proves something different every day, and under SQLite `datetime('now')` writes a space-separated text where an ORM writes ISO `T`, so the two misorder across a calendar day. The R8 dry run counts 36, every one of them signews-api's. |
-| C5   | <a id="c5-slash-is-a-subfolder"></a>`c5-slash-is-a-subfolder`           | runtime  | ground   | A slash in a fixture name is a SUBFOLDER of `_expected/`: `toMatch('build/verbose.txt')` resolves to `_expected/build/verbose.txt`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Name the subfolder in the fixture name; the resolver creates it under `_expected/`.                                                                                                                                                                                     | A flat `_expected/` stops being readable at a dozen files, and the alternative — a second option naming a directory — would be a second way to say where a golden lives.                                                                                                                                                                                          |
-| C1   | <a id="c1-asset-grouping"></a>`c1-asset-grouping`                       | process  | specs    | The folder follows the assets: a test with asset directories of its own gets its own domain; tests with no local assets group as sibling `<aspect>` files. The static rule only checks the depth.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Read what the assets say: a test that stands on its own ground earns a folder.                                                                                                                                                                                          | It is the assets that settle the grouping — a criterion no channel can decide alone.                                                                                                                                                                                                                                                                              |
+| Code | Implementation                                                          | Channel  | Reach    | Convention                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Fix                                                                                                                                                                                                                                                                     | Rationale                                                                                                                                                                                                                                                                                                                                                         |
+| ---- | ----------------------------------------------------------------------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| C1   | <a id="c1-domain-structure"></a>`c1-domain-structure`                   | statique | specs    | 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. | Move the file to the depth the tree declares, or declare the depth the tree actually has.                                                                                                                                                                               | A fixed depth makes every file's place predictable and statically checkable.                                                                                                                                                                                                                                                                                      |
+| C4   | <a id="c4-contract-shape"></a>`c4-contract-shape`                       | statique | contract | Under `specs/**/contracts/`: the ROOT carries only `*.contracts.ts` facades (a default export built by `defineContracts(...)` or a composition re-export; named exports are scenarios) and the provider folders `http` \| `openai` \| `anthropic`. A unit contract is `<provider>/<kebab-name>.ts` with an `export default defineContract(...)` (or a factory returning one), and its `request` builder must name the provider of its own folder. A provider folder is flat and holds only `*.ts` and `*.response.json`.                                                                                                                                                                                                                                                                                                                                                                                                                                          | Move the file to the half it belongs to: a facade at the root, a unit under its provider.                                                                                                                                                                               | A fixed tree separates the public facade from the internal units and makes the FOLDER carry the provider — filenames go back to being domain words, and bulky data sits beside the contract that serves it.                                                                                                                                                       |
+| C6   | <a id="c6-tomatch-extension"></a>`c6-tomatch-extension`                 | statique | tests    | `toMatch`'s argument carries its extension (`'help.txt'`, `'<case>.aria.yaml'` for a tree golden), except for a directory snapshot; a file subject with no extension is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Write the fixture's full name, extension included.                                                                                                                                                                                                                      | The extension is part of the expected file's name — dropping it breaks `_expected/` resolution.                                                                                                                                                                                                                                                                   |
+| C7   | <a id="c7-seeds-sql-only"></a>`c7-seeds-sql-only`                       | statique | ground   | `_seeds/` holds `*.sql` files only; any other file is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Write the seed as SQL, or move the file to `_fixtures/` as the material it is.                                                                                                                                                                                          | `.seed()` carries database state only — no seed handlers, no prefix dispatch.                                                                                                                                                                                                                                                                                     |
+| C8   | <a id="c8-referenced-fixture-exists"></a>`c8-referenced-fixture-exists` | statique | tests    | A literal passed to `.request`/`.seed`/`.fixture`/`toMatch` must exist on disk under its conventional root; a missing path is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Create the file, or fix the name — the message prints the path it looked for.                                                                                                                                                                                           | Catching a typo statically avoids a failure that would only surface at run time.                                                                                                                                                                                                                                                                                  |
+| C10  | <a id="c10-contracts-boundary"></a>`c10-contracts-boundary`             | statique | tests    | Outside `specs/**/contracts/`, an import resolving into a provider folder (`contracts/{http,openai,anthropic}/…`) is an error: a test imports only the `*.contracts.ts` facades.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Add a named scenario export to the facade and import that instead.                                                                                                                                                                                                      | Unit contracts are composition details; going through the facade keeps each scenario named in the same place as the world it derives from.                                                                                                                                                                                                                        |
+| C11  | <a id="c11-contract-data-pairing"></a>`c11-contract-data-pairing`       | statique | contract | Inside a provider folder, every `*.response.json` and every `*.request.ts` has a `<stem>.ts` sibling — the stem is the name up to the FIRST dot (`events.fr.response.json` → `events.ts`). Orphan data is an error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Write the contract that serves the payload, or delete the payload.                                                                                                                                                                                                      | Data exists only as served by a contract — a file with no owner is dead weight no test ever loads.                                                                                                                                                                                                                                                                |
+| C13  | <a id="c13-underscored-ground"></a>`c13-underscored-ground`             | statique | specs    | Under `specs/`, a spec's ground carries a leading underscore: `_fixtures/`, `_expected/`, `_requests/`, `_seeds/`. A `fixtures/`, `expected/`, `requests/` or `seeds/` directory is a pre-14 name — an error naming the rename.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Rename the directory with the leading underscore the resolvers read.                                                                                                                                                                                                    | No resolver reads the underscore-less name any more: left as is, the tree goes invisible rather than wrong, and the failure lands one step past its cause.                                                                                                                                                                                                        |
+| C9   | <a id="c9-dead-fixtures"></a>`c9-dead-fixtures`                         | checker  | ground   | No dead fixtures: every file under `_seeds/`/`_requests/`/`_fixtures/` and every top-level entry of `_expected/` must be referenced; a feature directory with no test file and no `*.spec.yaml` is an orphan (a warning when the argument is not a literal). A `<case>.spec.yaml` references the fixtures its `fixture:` entries name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Reference it from the spec it stands under, or delete it.                                                                                                                                                                                                               | The C8 mirror — a fixture nothing references is dead weight that misleads the reader.                                                                                                                                                                                                                                                                             |
+| C12  | <a id="c12-spec-file-name"></a>`c12-spec-file-name`                     | checker  | specs    | 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.                                       | 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. | 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.                                                                                                                                                            |
+| C14  | <a id="c14-pool-fixture-shared"></a>`c14-pool-fixture-shared`           | checker  | ground   | A pool fixture is SHARED, or it is local: a directory of `<specs>/_fixtures/` referenced (`$FIXTURES/<name>`) from a single spec directory — two documents of one leaf count as one — must live beside that leaf, at `<leaf>/_fixtures/<name>/`, referenced by the relative form. Zero references is the dead-fixture error (C9). Fixed by `--fix`: the directory is moved and the literals rewritten.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Run `jterrazz-test-check <root> --fix`; it moves the directory and rewrites what named it.                                                                                                                                                                              | A single scenario's fixture parked in the pool reads as shared ground: everyone assumes someone else depends on it and nobody dares touch it.                                                                                                                                                                                                                     |
+| C15  | <a id="c15-local-fixture-reach"></a>`c15-local-fixture-reach`           | checker  | ground   | A local fixture is read only from its own directory: a `fixture:`/`.fixture()` path containing `..`, or whose target leaves the `_fixtures/` of the spec naming it, is an error — ground shared by several leaves goes in the `$FIXTURES` pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Copy it under this leaf's own `_fixtures/`, or promote it to the pool.                                                                                                                                                                                                  | A leaf reaching into a neighbour's fixtures is the pool through another door, without the pool's visibility: the neighbour breaks a spec two folders away without knowing.                                                                                                                                                                                        |
+| C18  | <a id="c18-module-test-under-facet"></a>`c18-module-test-under-facet`   | checker  | specs    | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 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/`.                                                                                               | 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.                                                                                                                                                                                                                |
+| C20  | <a id="c20-facet-folder"></a>`c20-facet-folder`                         | checker  | specs    | A first-level folder named for one of the six facets holds a `*.specification.ts(x)` calling `specification.<facet>(`. Positive-only: any other first-level name is a repository suite, judged by C1's declared depth alone.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Create the specification the folder promises, or rename the folder.                                                                                                                                                                                                     | Folder = constructor is the law the fork rests on; a facet folder with no runner tells the reader something false before they open a file.                                                                                                                                                                                                                        |
+| C21  | <a id="c21w-ground-owned-by-one"></a>`c21w-ground-owned-by-one`         | checker  | ground   | Ground in a leaf holding ≥ 2 node tests (`.test.ts`, `.spec.ts`) that a single one of them reads is a warning. A `.test.tsx` tree is out of reach, as it is for C1.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Give that spec its own domain folder, with the ground beside it.                                                                                                                                                                                                        | Ground one spec reads, parked where several sit, reads as shared: everyone assumes someone else depends on it and nobody dares touch it.                                                                                                                                                                                                                          |
+| C23  | <a id="c23-seed-no-clock-read"></a>`c23-seed-no-clock-read`             | checker  | ground   | A `_seeds/**/*.sql` states absolute timestamps: `CURRENT_TIMESTAMP`/`CURRENT_DATE`/`CURRENT_TIME`, `NOW()` and the quoted `'now'` SQLite's date functions take (`datetime('now')`, `strftime(…, 'now')`, `date('now', '-1 day')`) are refused. A comment is not state, so a clock read inside one is not a finding.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Write the instant the case is about, and pin the run's clock with `.clock()` on the chain.                                                                                                                                                                              | A seed that reads the clock makes the row's date the date the suite happened to run: a case about "published yesterday" proves something different every day, and under SQLite `datetime('now')` writes a space-separated text where an ORM writes ISO `T`, so the two misorder across a calendar day. The R8 dry run counts 36, every one of them signews-api's. |
+| C5   | <a id="c5-slash-is-a-subfolder"></a>`c5-slash-is-a-subfolder`           | runtime  | ground   | A slash in a fixture name is a SUBFOLDER of `_expected/`: `toMatch('build/verbose.txt')` resolves to `_expected/build/verbose.txt`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Name the subfolder in the fixture name; the resolver creates it under `_expected/`.                                                                                                                                                                                     | A flat `_expected/` stops being readable at a dozen files, and the alternative — a second option naming a directory — would be a second way to say where a golden lives.                                                                                                                                                                                          |
+| C1   | <a id="c1-asset-grouping"></a>`c1-asset-grouping`                       | process  | specs    | The folder follows the assets: a test with asset directories of its own gets its own domain; tests with no local assets group as sibling `<aspect>` files. The static rule only checks the depth.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Read what the assets say: a test that stands on its own ground earns a folder.                                                                                                                                                                                          | It is the assets that settle the grouping — a criterion no channel can decide alone.                                                                                                                                                                                                                                                                              |
 
 ### D — Assertions
 
@@ -226,12 +226,12 @@ Every rule the framework enforces, across its enforcement channels — **statiqu
 
 ### J — Hygiene
 
-| Code | Implementation                                                            | Channel  | Reach | Convention                                                                                                                                                                                                                                                                                                                                                                                                                  | Fix                                                                                                  | Rationale                                                                                                                                                                                                                                                       |
-| ---- | ------------------------------------------------------------------------- | -------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| J2   | <a id="j2-no-sleep"></a>`j2-no-sleep`                                     | statique | tests | 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.               | Wait for the condition, not for a duration.                                                          | A fixed sleep makes tests slow and flaky; waiting on a condition is deterministic.                                                                                                                                                                              |
-| J6   | <a id="j6w-given-in-the-test"></a>`j6w-given-in-the-test`                 | statique | tests | A `beforeEach`/`beforeAll` in a test file is a warning, and so is an `afterEach`/`afterAll` whose body does more than restore (`cleanup`, `vi.useRealTimers`, `vi.restoreAllMocks`, `vi.resetAllMocks`, `vi.unstubAllGlobals`, `vi.unstubAllEnvs`) — handed over by name (`afterEach(vi.restoreAllMocks)`) or called in the body. `afterAll(cleanup)` in a `*.specification.ts` is A4's own idiom and out of reach by role. | Call a function from each test instead of a hook; `clock.at()` and `intercept()` restore themselves. | A hook moves the setup out of the only place a reader looks, shares it with every test in the file, and half of them come to depend on it quietly.                                                                                                              |
-| J10  | <a id="j10-one-describe-level"></a>`j10-one-describe-level`               | upstream | tests | At most one level of `describe` — `vitest/max-nested-describe` with `{ max: 1 }`, set by the `testing` fragment.                                                                                                                                                                                                                                                                                                            | Flatten the nesting: the test name is the sentence, and one level groups the file.                   | A tree of contexts is state a reader has to hold in their head to know what a test is about, and the name of the test stops being the sentence it was.                                                                                                          |
-| J9   | <a id="j9-checker-suppression-reason"></a>`j9-checker-suppression-reason` | checker  | specs | Every `checker-disable-next-line` / `checker-disable-line` directive carries ` -- <reason>`, wherever a checker pass can be silenced: a test, a document, a fixture under ground. The word inside a string is prose, not a directive.                                                                                                                                                                                       | Write `checker-disable-next-line <id> -- <reason>`.                                                  | A suppression with no reason is a rule turned off by someone no longer here: the next reader cannot tell whether the pass was wrong or simply in the way, so the line survives every review. The toolchain's own gate reads `oxlint-disable*` and nothing else. |
+| Code | Implementation                                                            | Channel  | Reach | Convention                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Fix                                                                                                  | Rationale                                                                                                                                                                                                                                                       |
+| ---- | ------------------------------------------------------------------------- | -------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| J2   | <a id="j2-no-sleep"></a>`j2-no-sleep`                                     | statique | tests | 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. | Wait for the condition, not for a duration.                                                          | A fixed sleep makes tests slow and flaky; waiting on a condition is deterministic.                                                                                                                                                                              |
+| J6   | <a id="j6w-given-in-the-test"></a>`j6w-given-in-the-test`                 | statique | tests | A `beforeEach`/`beforeAll` in a test file is a warning, and so is an `afterEach`/`afterAll` whose body does more than restore (`cleanup`, `vi.useRealTimers`, `vi.restoreAllMocks`, `vi.resetAllMocks`, `vi.unstubAllGlobals`, `vi.unstubAllEnvs`) — handed over by name (`afterEach(vi.restoreAllMocks)`) or called in the body. `afterAll(cleanup)` in a `*.specification.ts` is A4's own idiom and out of reach by role.                                                                                                                                                                                                               | Call a function from each test instead of a hook; `clock.at()` and `intercept()` restore themselves. | A hook moves the setup out of the only place a reader looks, shares it with every test in the file, and half of them come to depend on it quietly.                                                                                                              |
+| J10  | <a id="j10-one-describe-level"></a>`j10-one-describe-level`               | upstream | tests | At most one level of `describe` — `vitest/max-nested-describe` with `{ max: 1 }`, set by the `testing` fragment.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Flatten the nesting: the test name is the sentence, and one level groups the file.                   | A tree of contexts is state a reader has to hold in their head to know what a test is about, and the name of the test stops being the sentence it was.                                                                                                          |
+| J9   | <a id="j9-checker-suppression-reason"></a>`j9-checker-suppression-reason` | checker  | specs | Every `checker-disable-next-line` / `checker-disable-line` directive carries ` -- <reason>`, wherever a checker pass can be silenced: a test, a document, a fixture under ground. The word inside a string is prose, not a directive.                                                                                                                                                                                                                                                                                                                                                                                                     | Write `checker-disable-next-line <id> -- <reason>`.                                                  | A suppression with no reason is a rule turned off by someone no longer here: the next reader cannot tell whether the pass was wrong or simply in the way, so the line survives every review. The toolchain's own gate reads `oxlint-disable*` and nothing else. |
 
 ### K — Retro-propagation
 
@@ -442,6 +442,8 @@ F8 says which of the two it found: a carried dependency is "a transitive of `@jt
 
 **The jest allowance follows the tests, not the manifest.** `@testing-library/react-native` stands where jest runs the member's tests, and jest is not always the member's own: a library co-locating its render tests in `src/` while the app beside it owns the only working React Native toolchain runs them from THAT app's `jest.config.*`. So the pass reads two sources — the member's own declaration (a `jest`/`jest-expo` dependency, a `jest` field, a `test` script calling it), and a `jest.config.*` anywhere in the workspace whose `roots`/`testMatch` resolve INTO the member (`<rootDir>` is jest's own token for the config's directory). A config that reaches another member clears nothing here: the allowance is about the files jest collects.
 
+The workspace it searches is walked UP to, from the member, and never taken from the anchor the run was started at: the app that runs the member's tests sits BESIDE it, which is above the member and never below it. `cd packages/native && jterrazz-test-check` — the run that member's own gate makes — otherwise found no jest at all and reported F8 while the root-anchored run cleared the same member. The walk stops at the first directory declaring a workspace (`workspaces` in its manifest, or a `pnpm-workspace.yaml`) and at the checkout's own boundary, since a `.git` is where this repository ends.
+
 `jterrazz-test-check --member <dir>` runs them over one member. `jterrazz-test-check` with NO path runs both halves over the whole project: every `specs/` root discovered from the root manifest's `workspaces`, and every member. That is the run the toolchain's ratchet rests on, so the contract is exactly "a path-less run reports what the per-root and per-member runs report" — and the discovery is the toolchain's, to the segment: a `workspaces` glob expands with `*` for one segment and `**` for any depth (bounded at six), and each member is walked for the spec roots it owns, a nested `web/specs` included. A shape `@jterrazz/typescript` reaches and this run did not would be a finding the ratchet could neither record nor clear.
 
 `--format json` prints `[{ code, file, line, severity, message }]` on stdout and nothing else. `code` is `jterrazz-check(<id>)` — `jterrazz-check(d4)`, `jterrazz-check(f8)` — which is the namespace `@jterrazz/typescript`'s ratchet records the counts under, flat, in `oxlint.baseline.json` beside the oxlint ones. Severity travels but is never read by the ratchet: a finding a release ships at `warn` is exactly the debt a ratchet exists to hold down.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/test",
-    "version": "16.1.0",
+    "version": "16.1.1",
     "description": "Declarative testing framework for HTTP APIs, CLIs, background jobs, websites, mobile apps and rendered components — one entry point, real infrastructure and a real browser, golden-file assertions, plus an oxlint convention plugin.",
     "keywords": [
         "api-testing",
@@ -77,7 +77,7 @@
     },
     "devDependencies": {
         "@hono/node-server": "^2.0.8",
-        "@jterrazz/typescript": "^10.2.1",
+        "@jterrazz/typescript": "^10.3.1",
         "@types/better-sqlite3": "^7.6.13",
         "@types/node": "^26.1.1",
         "@types/pg": "^8.20.0",