@jterrazz/test 16.0.0 → 16.1.1

package/dist/index.js

@@ -66,6 +66,12 @@ function isOptions(value) {
 * The framework owns the seam so a test never has to: this is the one place
 * `fetch` is wrapped, it is put back when the scope ends, and what it does is
 * the one thing a page would have done for free — turn `/api/posts` into a URL.
+*
+* Validating the origin and INSTALLING the wrapper are two steps because they
+* happen at two moments: the refusal of a bad origin belongs before anything
+* starts, while the wrapper may only go on once the engine is listening — it
+* has to sit ON TOP of whatever `fetch` the engine installed, and be taken off
+* before the engine takes its own back.
 */
 function resolveRelativeAgainst(origin) {
 	let base;
@@ -74,10 +80,12 @@ function resolveRelativeAgainst(origin) {
 	} catch {
 		throw new Error(`intercept(): \`origin\` states where a relative request resolves — \`${origin}\` is not an absolute URL (e.g. 'http://console.test').`);
 	}
-	const original = globalThis.fetch;
-	globalThis.fetch = async (input, init) => typeof input === "string" && input.startsWith("/") ? await original(new URL(input, base).toString(), init) : await original(input, init);
 	return () => {
-		globalThis.fetch = original;
+		const engine = globalThis.fetch;
+		globalThis.fetch = async (input, init) => typeof input === "string" && input.startsWith("/") ? await engine(new URL(input, base).toString(), init) : await engine(input, init);
+		return () => {
+			globalThis.fetch = engine;
+		};
 	};
 }
 /**
@@ -92,18 +100,13 @@ function interceptThrough(register) {
 		const options = isOptions(maybeOptions) ? maybeOptions : isOptions(maybeResponseOrOptions) ? maybeResponseOrOptions : void 0;
 		const contracts = declared(requestOrContracts, options === maybeResponseOrOptions ? void 0 : maybeResponseOrOptions);
 		if (contracts.length === 0) throw new Error("intercept(): declare at least one contract — an empty list guards nothing, and a subject with no network needs no intercept at all.");
-		const restoreOrigin = options?.origin === void 0 ? void 0 : resolveRelativeAgainst(options.origin);
-		let registration;
-		try {
-			registration = await register(contracts);
-		} catch (error) {
-			restoreOrigin?.();
-			throw error;
-		}
+		const installOrigin = options?.origin === void 0 ? void 0 : resolveRelativeAgainst(options.origin);
+		const registration = await register(contracts);
+		const restoreOrigin = installOrigin?.();
 		return { [Symbol.asyncDispose]: async () => {
+			restoreOrigin?.();
 			const violation = registration.violation();
 			registration.cleanup();
-			restoreOrigin?.();
 			await Promise.resolve();
 			if (violation) throw violation;
 		} };
@@ -2012,10 +2015,14 @@ var CallResult = class extends BaseResult {
 	/**
 	* What the call RETURNED. A string reads as a stream (`<name>.txt`),
 	* anything else as JSON (`<name>.json`) — the same two subjects every
-	* other facet's results are built from.
+	* other facet's results are built from, chosen on the value in hand and
+	* typed by {@link CallValue}, which answers for the three ways a type can
+	* relate to `string`.
 	*
-	* A call that threw returns the empty value: what it produced is
-	* {@link CallResult.error}.
+	* A call that threw has no value to choose an accessor on, so `value` is
+	* the JSON reading of `null` whatever the declared type promises: what a
+	* refusal produced is {@link CallResult.error}, and that is where a spec
+	* reads it.
 	*/
 	get value() {
 		const produced = this.outcome.threw ? null : this.outcome.value;
@@ -2063,7 +2070,10 @@ var FetchResult = class extends BaseResult {
 	}
 	/** The response body as a text accessor (`toMatch('robots.txt')`, `.grep()`). */
 	get body() {
-		return new TextAccessor(this.exchange.body, "body", this.testDir, { captures: this.captures });
+		return new TextAccessor(this.exchange.body, "body", this.testDir, {
+			captures: this.captures,
+			transform: this.config.transform
+		});
 	}
 	/** Response headers as a flat, lower-cased key-value map. */
 	get headers() {
@@ -2071,7 +2081,7 @@ var FetchResult = class extends BaseResult {
 	}
 	/** The response body parsed as JSON. */
 	get json() {
-		return new JsonAccessor(this.exchange.body, this.testDir, void 0, this.captures);
+		return new JsonAccessor(this.exchange.body, this.testDir, this.config.transform, this.captures);
 	}
 	/** The `location` header of a redirect response, or undefined. */
 	get location() {
@@ -2106,7 +2116,10 @@ var PageResult = class extends BaseResult {
 	*/
 	get console() {
 		const lines = this.page.consoleMessages.map((m) => `[${m.type}] ${m.text}`).join("\n");
-		return new TextAccessor(lines, "console", this.testDir, { captures: this.captures });
+		return new TextAccessor(lines, "console", this.testDir, {
+			captures: this.captures,
+			transform: this.config.transform
+		});
 	}
 	/**
 	* Console messages of type `error` only — the stream you usually want
@@ -2115,7 +2128,10 @@ var PageResult = class extends BaseResult {
 	*/
 	get errors() {
 		const lines = this.page.consoleMessages.filter((m) => m.type === "error").map((m) => m.text).join("\n");
-		return new TextAccessor(lines, "errors", this.testDir, { captures: this.captures });
+		return new TextAccessor(lines, "errors", this.testDir, {
+			captures: this.captures,
+			transform: this.config.transform
+		});
 	}
 	/**
 	* The document-head projection as a JSON accessor — title, canonical,
@@ -2129,11 +2145,14 @@ var PageResult = class extends BaseResult {
 			metas: namedMetas(this.page.metas),
 			title: this.page.title
 		};
-		return new JsonAccessor(JSON.stringify(summary), this.testDir, void 0, this.captures);
+		return new JsonAccessor(JSON.stringify(summary), this.testDir, this.config.transform, this.captures);
 	}
 	/** The rendered DOM serialization as a text accessor. */
 	get html() {
-		return new TextAccessor(this.page.html, "html", this.testDir, { captures: this.captures });
+		return new TextAccessor(this.page.html, "html", this.testDir, {
+			captures: this.captures,
+			transform: this.config.transform
+		});
 	}
 	/**
 	* Every `application/ld+json` block of the page, parsed, as one JSON
@@ -2141,7 +2160,7 @@ var PageResult = class extends BaseResult {
 	*/
 	get jsonLd() {
 		const combined = `[${this.page.jsonLdBlocks.join(",")}]`;
-		return new JsonAccessor(combined, this.testDir, void 0, this.captures);
+		return new JsonAccessor(combined, this.testDir, this.config.transform, this.captures);
 	}
 	/** `<link>` elements of the head, in DOM order. */
 	get links() {
@@ -2157,7 +2176,10 @@ var PageResult = class extends BaseResult {
 	}
 	/** Rendered body text as a text accessor. */
 	get content() {
-		return new TextAccessor(this.page.text, "text", this.testDir, { captures: this.captures });
+		return new TextAccessor(this.page.text, "text", this.testDir, {
+			captures: this.captures,
+			transform: this.config.transform
+		});
 	}
 	/**
 	* The ARIA snapshot of the rendered `<body>` — the page's outline, as the
@@ -3613,7 +3635,8 @@ async function startWebsite(options) {
 			backendUrl,
 			baseUrl,
 			browser: getBrowser,
-			external: options.external ?? (options.server ? "block" : "allow")
+			external: options.external ?? (options.server ? "block" : "allow"),
+			transform: options.transform
 		})
 	};
 }

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