@jterrazz/test 15.1.1 → 15.2.0

package/dist/oxlint.js

@@ -169,9 +169,6 @@ function walk(root, visit) {
 		} else if (isNode(value)) walk(value, visit);
 	}
 }
-function isNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
 /** The source start offset of a node or comment (oxlint `start`, else `range[0]`). */
 function nodeStart(node) {
 	if (node === void 0) return -1;
@@ -218,6 +215,27 @@ function importSourceVisitor(onSource) {
 		ImportExpression: fromSourceField
 	};
 }
+/** Is this value an AST node — an object carrying a `type` string? */
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+/**
+* A node's child by key, or `undefined` when the key holds something else.
+*
+* Every rule reaches for `node.parent`, `node.id`, `node.value`; the node shape
+* types them as `unknown`, so each reach was an assertion of its own. One
+* guarded read is the same answer, checked once.
+*/
+function child(node, key) {
+	const value = node?.[key];
+	return isNode(value) ? value : void 0;
+}
+/** The name of an identifier node, or `undefined` for anything else. */
+function identifierName(node) {
+	if (node?.type !== "Identifier") return;
+	const { name } = node;
+	return typeof name === "string" ? name : void 0;
+}
 //#endregion
 //#region src/lint/manifest.ts
 /**
@@ -346,7 +364,7 @@ const RULE_DOCS = {
 	},
 	"c1-domain-structure": {
 		channel: "statique",
-		convention: "La forme de l’arbre `specs/` se déclare via l’option `depth` : `facet-domain` (défaut — `*.test.ts` à la profondeur facet/domain, `*.specification.ts` au root de la facette), `facet` (test au root de la facette OU un dossier domaine plus bas, jamais plus profond), `mirror` (test à toute profondeur ≥ 1, nommé d’après son dossier), `off`. Dans tous les modes, `off` compris : un dossier à underscore initial est du SOL, jamais un domaine — aucune spec ne vit dedans. Une exception, et une seule : le sol peut être du CODE, et un `<module>.test.ts` posé À CÔTÉ du `<module>.ts` qu’il teste y est légal (c’est la loi I2) ; un test sans module voisin, ou un `*.specification.ts`, reste une violation.",
+		convention: "La forme de l’arbre `specs/` se déclare via l’option `depth` : `facet-domain` (défaut — `*.test.ts` à la profondeur facet/domain, `*.specification.ts` au root de la facette), `facet` (test au root de la facette OU un dossier domaine plus bas, jamais plus profond), `mirror` (test à toute profondeur ≥ 1, nommé d’après son dossier), `off`. Dans tous les modes, `off` compris : un dossier à underscore initial est du SOL, jamais un domaine — aucune spec ne vit dedans. Une exception, et une seule : le sol peut être du CODE, et un `<module>.test.ts` posé À CÔTÉ du `<module>.ts` qu’il teste y est légal (c’est la loi I2) ; un test sans module voisin, ou un `*.specification.ts`, reste une violation. Un `.test.tsx` est hors de portée : une unité rendue se spécifie à côté de son composant, jamais dans un arbre facette/domaine — c’est I2 qui tient son voisinage.",
 		family: "C",
 		id: "C1",
 		rationale: "Une profondeur fixe rend la place de chaque fichier prévisible et détectable statiquement."
@@ -463,6 +481,36 @@ const RULE_DOCS = {
 		id: "D15",
 		rationale: "Un statut isolé ne fige que le code de réponse et jette tout le reste du payload ; le golden complet capture la forme entière et sa grammaire de tokens (complète d12w, qui exige un amas de sondes de corps et manque le cas de la sonde de statut solitaire)."
 	},
+	"e5-no-simulated-dom": {
+		channel: "statique",
+		convention: "Un fichier de test ne déclare pas de DOM simulé : la pragma `@vitest-environment happy-dom|jsdom` est une erreur. Portée : les rôles qui EXÉCUTENT un test (`module`, `component`, `specification`) — une config de projet est le domaine de E5b.",
+		facet: "component",
+		family: "E",
+		fix: "Déplacer le test à côté de son composant en `.test.tsx` et le faire collecter par le projet `component()`.",
+		id: "E5",
+		rationale: "Un DOM simulé se comporte PRESQUE comme un navigateur, et ce qui est livré est jugé par un vrai : la facette component rend dans le Chromium que la facette website pilote déjà.",
+		reach: "tests"
+	},
+	"e5b-no-simulated-dom-config": {
+		channel: "statique",
+		convention: "Une config vitest ne déclare pas de DOM simulé : `environment: 'happy-dom'|'jsdom'` est une erreur ; `'node'` et `'edge-runtime'` nomment un vrai runtime et restent hors de portée.",
+		facet: "component",
+		family: "E",
+		fix: "Supprimer `environment` et collecter le rendu avec `component()` ; les tests de module restent sous node.",
+		id: "E5b",
+		rationale: "La pragma (E5) n’engage qu’un fichier ; la config engage tout ce que le projet collecte — c’est ainsi qu’un dépôt hérite d’un DOM simulé que personne n’a choisi test par test.",
+		reach: "config"
+	},
+	"e6-component-project-helper": {
+		channel: "statique",
+		convention: "Un projet navigateur vient de `component()` : dans une config vitest, une clé `browser` sous `test` qui n'est pas dans un appel à `component(...)` est une erreur. Une clé `browser` ailleurs (un `define`, un enregistrement d'env) n'est pas un bloc de projet et reste hors de portée.",
+		facet: "component",
+		family: "E",
+		fix: "Remplacer le bloc par `component({ vite })` et ne garder que ce qui appartient au projet.",
+		id: "E6",
+		rationale: "Le provider épinglé à la version exacte du runner, le service worker servi depuis l’installation du framework, la transformation JSX du Vite courant, le pré-bundling d’un cache froid et les dossiers d’artefacts sont autant de runs qui passent ici et échouent sur la machine suivante.",
+		reach: "config"
+	},
 	"f1-no-subpath-import": {
 		channel: "statique",
 		convention: "Tout s’importe depuis `@jterrazz/test` ; un import de `@jterrazz/test/<subpath>` est une erreur, sauf les subpaths que la map `exports` du paquet publie — `@jterrazz/test/oxlint` (plugin de lint) et `@jterrazz/test/vitest` (surface de configuration du runner) — exemptés partout. La liste est LUE du manifeste, jamais recopiée dans la règle.",
@@ -498,6 +546,26 @@ const RULE_DOCS = {
 		id: "F5",
 		rationale: "Cantonner les fixtures aux tests empêche la donnée de test de fuir dans le code de prod."
 	},
+	"f6-no-foreign-test-runtime": {
+		channel: "statique",
+		convention: "Un fichier de test n’importe pas de second runtime de test : `@testing-library/*`, `happy-dom`, `jsdom`, `vitest/browser`, `vitest-browser-*` et `@vitest/browser*` sont des erreurs. Portée : les rôles qui EXÉCUTENT un test (`module`, `component`, `specification`) — la config d’un projet fixture et un module de providers sous `specs/` nomment légitimement l’adaptateur.",
+		facet: "component",
+		family: "F",
+		fix: "Passer par la facette qui remplace le seam : `component.render()`, le vocabulaire d’éléments et le visiteur.",
+		id: "F6",
+		rationale: "Un test qui importe l’adaptateur parle le dialecte de l’adaptateur : un dépôt finit avec autant de vocabulaires que de seams. Les groupes livrés sont ceux que la facette component REMPLACE ; le reste de la famille suit la vague de règles.",
+		reach: "tests"
+	},
+	"g4-no-dom-in-module-test": {
+		channel: "statique",
+		convention: "Un test de module ne touche aucun global du DOM : `document`, `window`, `navigator`, `HTMLElement` référencés en position de VALEUR dans un fichier de rôle `module` HORS de `specs/` sont une erreur. Un nom en position de type (`x as HTMLElement`) et un garde `typeof window` n’atteignent aucun document et restent hors de portée ; tant que le rôle `spec` n’existe pas, `module` couvre aussi les `.test.ts` de `specs/`, que la règle laisse donc passer.",
+		facet: "component",
+		family: "G",
+		fix: "Renommer le test en `.test.tsx` à côté du composant qu’il rend, et le faire collecter par `component()`.",
+		id: "G4",
+		rationale: "Un test de module tourne sous node, où `document` n’existe pas : un test qui en réclame un ne teste pas un module, il rend quelque chose — et il a désormais un endroit où aller.",
+		reach: "module"
+	},
 	"i1-layer-boundaries": {
 		channel: "statique",
 		convention: "Le projet DÉCLARE ses couches sous `src/` via l’option `layers` (paquets autorisés, imports internes, un dossier = une dépendance, seams) ; tout import hors des arêtes déclarées est une erreur. Sans carte de couches, la règle est inerte.",
@@ -507,9 +575,11 @@ const RULE_DOCS = {
 	},
 	"i2-sibling-test-naming": {
 		channel: "statique",
-		convention: "Le test de `<fichier>.ts` est `<fichier>.test.ts` à côté de lui ; un `.test.ts` mal nommé, ou un dossier `__tests__/`, est une erreur.",
+		convention: "Le test de `<fichier>.ts` est `<fichier>.test.ts` à côté de lui ; un `.test.ts` mal nommé, ou un dossier `__tests__/`, est une erreur. Une unité RENDUE obéit à la même loi où qu’elle vive : un `.test.tsx` est voisin du `.tsx` qu’il rend, ou du `.ts` du hook ou de la fonction DOM dont il porte l’hôte.",
 		family: "I",
+		fix: "Poser le test à côté de l’unité qu’il couvre, sous le même basename.",
 		id: "I2",
+		reach: "tests",
 		rationale: "Des tests voisins (parité avec le `foo_test.go` de Go) gardent test et code ensemble et découvrables."
 	},
 	"i4-no-vi-mock-in-src": {
@@ -840,14 +910,19 @@ function sortKey(entry) {
 	];
 }
 [
-	...Object.entries(RULE_DOCS).map(([name, doc]) => ({
-		channel: doc.channel,
-		convention: doc.convention,
-		family: doc.family,
-		id: doc.id,
-		name,
-		rationale: doc.rationale
-	})),
+	...Object.entries(RULE_DOCS).map(([name, doc]) => {
+		const entry = {
+			channel: doc.channel,
+			convention: doc.convention,
+			family: doc.family,
+			id: doc.id,
+			name,
+			rationale: doc.rationale
+		};
+		if ("fix" in doc) entry.fix = doc.fix;
+		if ("reach" in doc) entry.reach = doc.reach;
+		return entry;
+	}),
 	...CHECKER_PASSES,
 	...RUNTIME_RULES,
 	...PROCESS_RULES
@@ -859,6 +934,55 @@ function sortKey(entry) {
 	return av.localeCompare(bv);
 });
 //#endregion
+//#region src/lint/role.ts
+/** The four ground names — what the specs of a row stand ON, never a spec. */
+const GROUND = /* @__PURE__ */ new Set([
+	"_expected",
+	"_fixtures",
+	"_requests",
+	"_seeds"
+]);
+/** A vitest config, whatever extension the project writes it in. */
+const CONFIG = /^vitest\.config\.[cm]?[jt]s$/u;
+/**
+* The kind of file this path names.
+*
+* The suffix decides, and the order matters: a `*.specification.ts` is a
+* specification wherever it sits, ground swallows anything under it that is not
+* a test of its own module, and `.tsx` versus `.ts` is what tells a RENDERED
+* unit from a plain one — the same distinction the two project helpers collect
+* on, so a file is judged by the rules of the project that actually runs it.
+*/
+function roleOf(filename) {
+	const parts = segments(filename);
+	const base = parts.at(-1) ?? "";
+	const inSpecs = isUnderSpecs(filename);
+	if (base.endsWith(".specification.ts") || base.endsWith(".specification.tsx")) return {
+		inSpecs,
+		role: "specification"
+	};
+	if (CONFIG.test(base)) return {
+		inSpecs,
+		role: "config"
+	};
+	if (base.endsWith(".test.tsx")) return {
+		inSpecs,
+		role: "component"
+	};
+	if (base.endsWith(".test.ts")) return {
+		inSpecs,
+		role: "module"
+	};
+	if (parts.slice(0, -1).some((segment) => GROUND.has(segment))) return {
+		inSpecs,
+		role: "ground"
+	};
+	return {
+		inSpecs,
+		role: "other"
+	};
+}
+//#endregion
 //#region src/lint/rules/a1-specification-file.ts
 const SPECIFICATION_SUFFIX$2 = ".specification.ts";
 /**
@@ -869,10 +993,15 @@ const SPECIFICATION_SUFFIX$2 = ".specification.ts";
 * Framework-internal unit tests of the constructors themselves (this repo's
 * `src/**\/*.test.ts`) disable the rule via a config override — for consumers
 * the rule is universal.
+*
+* The A family does not reach a `component`-role file. A rendered unit has no
+* runner to create: no server to start, no database to isolate, no binary to
+* find — which is why the component facet has no constructor and no
+* specification file for A1 to point at.
 */
 const a1SpecificationFile = {
 	create(context) {
-		if (context.filename.endsWith(SPECIFICATION_SUFFIX$2)) return {};
+		if (context.filename.endsWith(SPECIFICATION_SUFFIX$2) || roleOf(context.physicalFilename).role === "component") return {};
 		return { CallExpression(node) {
 			const member = specificationMember(node);
 			if (member !== void 0) context.report({
@@ -2839,6 +2968,122 @@ const d15wStatusOnlyProbe = {
 	}
 };
 //#endregion
+//#region src/lint/rules/e5-no-simulated-dom.ts
+/** The pragma vitest reads to swap a test file's environment. */
+const PRAGMA = /@vitest-environment\s+(?<environment>[\w-]+)/u;
+/** The two simulated DOMs. */
+const SIMULATED$1 = /* @__PURE__ */ new Set(["happy-dom", "jsdom"]);
+/** The roles that RUN a test file — the only ones a pragma steers. */
+const REACHED$1 = /* @__PURE__ */ new Set([
+	"component",
+	"module",
+	"specification"
+]);
+/**
+* CONVENTIONS E5 — no simulated DOM, stated per file.
+*
+* `@vitest-environment happy-dom` buys a document that behaves almost like a
+* browser's: almost is the whole problem, because what ships is judged by a
+* real one. The component facet renders in the Chromium the website facet
+* already drives, so the pragma has nothing left to buy.
+*/
+const e5NoSimulatedDom = {
+	create(context) {
+		if (!REACHED$1.has(roleOf(context.physicalFilename).role)) return {};
+		return { Program(node) {
+			for (const comment of context.sourceCode.getAllComments()) {
+				const environment = PRAGMA.exec(comment.value)?.groups?.environment;
+				if (environment !== void 0 && SIMULATED$1.has(environment)) context.report({
+					data: { environment },
+					messageId: "pragma",
+					node
+				});
+			}
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["e5-no-simulated-dom"],
+		messages: { pragma: "`@vitest-environment {{environment}}` simulates a browser this framework can open for real — a rendered thing is a `.test.tsx` beside its component, collected by the `component()` project (E5 — docs/13-linting.md#e5-no-simulated-dom)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/e5b-no-simulated-dom-config.ts
+/** The two simulated DOMs. */
+const SIMULATED = /* @__PURE__ */ new Set(["happy-dom", "jsdom"]);
+/**
+* CONVENTIONS E5b — the same ban, where a project states it for a whole tree.
+*
+* The pragma (E5) is one file's; `environment: 'happy-dom'` in a config is
+* every file the project collects, which is how a repository ends up with a
+* simulated DOM nobody ever chose per test. `'node'` and `'edge-runtime'` are
+* out of reach: they name a real runtime, not a drawing of one.
+*/
+const e5bNoSimulatedDomConfig = {
+	create(context) {
+		if (roleOf(context.physicalFilename).role !== "config") return {};
+		return { Program(node) {
+			walk(node, (candidate) => {
+				if (candidate.type !== "Property" || propertyKeyName(candidate) !== "environment") return;
+				const environment = stringValue(child(candidate, "value"));
+				if (environment !== void 0 && SIMULATED.has(environment)) context.report({
+					data: { environment },
+					messageId: "configured",
+					node: candidate
+				});
+			});
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["e5b-no-simulated-dom-config"],
+		messages: { configured: "`environment: '{{environment}}'` gives every file of this project a drawing of a browser — a rendered thing is a `.test.tsx` beside its component, collected by `component()` (E5b — docs/13-linting.md#e5b-no-simulated-dom-config)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/e6-component-project-helper.ts
+/** Is this property the RUNNER's browser block, rather than a key that shares its name? */
+function isRunnerBrowserBlock(node) {
+	for (let current = child(node, "parent"); current !== void 0; current = child(current, "parent")) if (current.type === "Property" && propertyKeyName(current) === "test") return true;
+	return false;
+}
+/** Is this node inside a call to `component(...)`? */
+function insideComponentCall(node) {
+	for (let current = child(node, "parent"); current !== void 0; current = child(current, "parent")) if (current.type === "CallExpression" && identifierName(child(current, "callee")) === "component") return true;
+	return false;
+}
+/**
+* CONVENTIONS E6 — a browser project comes from `component()`.
+*
+* A hand-rolled `browser: { … }` block is a project that has to rediscover
+* everything the seam already knows: the provider pinned to the runner's exact
+* version, the service worker served from the framework's own install, the JSX
+* transform the current Vite actually uses, the dependencies a cold cache must
+* pre-bundle, and the artefact directories Browser Mode otherwise leaks at the
+* repository root. Every one of those is a run that fails on the second
+* machine, so the helper owns them and a config states only what is its own.
+*/
+const e6ComponentProjectHelper = {
+	create(context) {
+		if (roleOf(context.physicalFilename).role !== "config") return {};
+		return { Program(node) {
+			walk(node, (candidate) => {
+				if (candidate.type !== "Property" || propertyKeyName(candidate) !== "browser") return;
+				if (!isRunnerBrowserBlock(candidate)) return;
+				if (!insideComponentCall(candidate)) context.report({
+					messageId: "handRolled",
+					node: candidate
+				});
+			});
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["e6-component-project-helper"],
+		messages: { handRolled: "Use `component({ vite })` — the provider, the worker and the pipeline are its, and a hand-rolled `browser:` block is the run that passes here and fails on the next machine (E6 — docs/13-linting.md#e6-component-project-helper)." },
+		type: "problem"
+	}
+};
+//#endregion
 //#region src/lint/package-exports.ts
 /**
 * The subpaths this package actually publishes, read from its OWN
@@ -3110,6 +3355,164 @@ const f5FixturesOnlyFromTests = {
 	}
 };
 //#endregion
+//#region src/lint/rules/f6-no-foreign-test-runtime.ts
+const GROUPS = [
+	{
+		fix: "`component.render()` and the element vocabulary render in a real browser — the queries are the same nouns, and they run against what ships",
+		matches: (source) => source === "@testing-library" || source.startsWith("@testing-library/")
+	},
+	{
+		fix: "a drawing of a browser proves what a browser does not — a rendered thing is a `.test.tsx` beside its component, collected by `component()`",
+		matches: (source) => source === "happy-dom" || source === "jsdom"
+	},
+	{
+		fix: "Browser Mode is the seam, not the surface — `component.render()` owns the locators, the visitor and the ARIA tree",
+		matches: (source) => source === "vitest/browser" || source.startsWith("vitest-browser-") || source.startsWith("@vitest/browser")
+	}
+];
+/**
+* The roles that RUN a test — never a fixture app's config or a provider module
+* that happens to sit under `specs/`. A fixture project's own `vitest.config.ts`
+* has to name the provider, and a `providers.tsx` has to import the adapter it
+* wraps: neither is a spec speaking a second dialect.
+*/
+const REACHED = /* @__PURE__ */ new Set([
+	"component",
+	"module",
+	"specification"
+]);
+/**
+* CONVENTIONS F6 — a test file imports no second test runtime.
+*
+* Every seam the framework owns is one a spec must not reach around: a test
+* that imports the adapter speaks the adapter's dialect, and a repository ends
+* up with as many vocabularies as it has seams. The groups the rule carries are
+* the ones the component facet REPLACES.
+*/
+const f6NoForeignTestRuntime = {
+	create(context) {
+		if (!REACHED.has(roleOf(context.physicalFilename).role)) return {};
+		return { ...importSourceVisitor(({ node, source }) => {
+			const group = GROUPS.find((candidate) => candidate.matches(source));
+			if (group !== void 0) context.report({
+				data: {
+					fix: group.fix,
+					source
+				},
+				messageId: "foreignRuntime",
+				node
+			});
+		}) };
+	},
+	meta: {
+		docs: RULE_DOCS["f6-no-foreign-test-runtime"],
+		messages: { foreignRuntime: "`{{source}}` is a second test runtime in a test file: {{fix}} (F6 — docs/13-linting.md#f6-no-foreign-test-runtime)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/g4-no-dom-in-module-test.ts
+/** The globals that only exist where a document does. */
+const DOM_GLOBALS = /* @__PURE__ */ new Set([
+	"document",
+	"HTMLElement",
+	"navigator",
+	"window"
+]);
+/** The node kinds that BIND a name, and the key each one binds it under. */
+const BINDINGS = {
+	CatchClause: "param",
+	ClassDeclaration: "id",
+	FunctionDeclaration: "id",
+	ImportDefaultSpecifier: "local",
+	ImportNamespaceSpecifier: "local",
+	ImportSpecifier: "local",
+	VariableDeclarator: "id"
+};
+/**
+* Every name this file declares for itself.
+*
+* A file-wide set rather than a scope chain: the rule only needs to know that
+* `document` is the test's own binding somewhere, and a name shadowed in one
+* scope is not a global in another. It can only under-report, which is the
+* right direction for a guard.
+*/
+function declaredNames(root) {
+	const names = /* @__PURE__ */ new Set();
+	const add = (node) => {
+		const name = identifierName(node);
+		if (name !== void 0) names.add(name);
+	};
+	walk(root, (node) => {
+		const key = BINDINGS[node.type];
+		if (key !== void 0) add(child(node, key));
+		const { params } = node;
+		if (Array.isArray(params)) {
+			for (const parameter of params) if (isNode(parameter)) add(parameter);
+		}
+	});
+	return names;
+}
+/** The node kinds a name sits in when it is a TYPE, not a value the test reaches. */
+const TYPE_POSITIONS = /* @__PURE__ */ new Set([
+	"TSInterfaceHeritage",
+	"TSQualifiedName",
+	"TSTypeQuery",
+	"TSTypeReference"
+]);
+/** Is this identifier read as a value, rather than named as a property, a key or a type? */
+function isValueReference(node) {
+	const parent = child(node, "parent");
+	if (parent === void 0) return true;
+	if (TYPE_POSITIONS.has(parent.type)) return false;
+	if (parent.type === "UnaryExpression" && parent.operator === "typeof") return false;
+	if (parent.type === "MemberExpression") return child(parent, "property") !== node || parent.computed === true;
+	if (parent.type === "Property") return child(parent, "value") === node || parent.computed === true;
+	return true;
+}
+/**
+* CONVENTIONS G4 — a module test touches no DOM.
+*
+* A module test runs under node, where `document` does not exist: a test that
+* reaches for one is not testing a module, it is rendering something, and the
+* place for that is a `.test.tsx` beside the component.
+*
+* Reach is the `module` role OUTSIDE `specs/`: a `.test.tsx` is the rendered
+* kind and lives in a page, where those globals are what it is there to use;
+* and under `specs/` an api or cli spec is a `.test.ts` too until the `spec`
+* role exists, so the guard stops at the tree it can judge.
+*
+* A name in a TYPE position (`x as HTMLElement`) and a `typeof window` guard
+* name no document: neither reaches one, and a module that must run in both
+* runtimes is tested by exactly that guard.
+*/
+const g4NoDomInModuleTest = {
+	create(context) {
+		const identity = roleOf(context.physicalFilename);
+		if (identity.role !== "module" || identity.inSpecs) return {};
+		let declared = /* @__PURE__ */ new Set();
+		return {
+			Identifier(node) {
+				const name = identifierName(node);
+				if (name === void 0 || !DOM_GLOBALS.has(name) || declared.has(name) || !isValueReference(node)) return;
+				context.report({
+					data: { name },
+					messageId: "domGlobal",
+					node
+				});
+			},
+			Program(node) {
+				declared = declaredNames(node);
+			}
+		};
+	},
+	meta: {
+		docs: RULE_DOCS["g4-no-dom-in-module-test"],
+		messages: { domGlobal: "`{{name}}` does not exist where a module test runs — a rendered thing is a `.test.tsx` beside its component, collected by the `component()` project (G4 — docs/13-linting.md#g4-no-dom-in-module-test)." },
+		type: "problem"
+	}
+};
+//#endregion
 //#region src/lint/rules/i1-layer-boundaries.ts
 const TEST_OR_FIXTURES = /\.(?:test|fixtures)\.[cm]?[jt]sx?$/u;
 function matchesPackage(source, packages) {
@@ -3242,21 +3645,25 @@ const i1LayerBoundaries = {
 //#region src/lint/rules/i2-sibling-test-naming.ts
 const TEST_FILE$1 = /\.test\.[cm]?[jt]sx?$/u;
 /**
-* CONVENTIONS I2 — module tests are NEIGHBOURS: the test of `<file>.ts` is
-* `<file>.test.ts` next to it (Go's `foo_test.go` parity). Flags, on visited
-* files:
+* CONVENTIONS I2 — a unit's test is its NEIGHBOUR: the test of `<file>.ts` is
+* `<file>.test.ts` next to it (Go's `foo_test.go` parity). A rendered unit
+* answers to the same law wherever it lives: a `.test.tsx` sits beside the
+* `.tsx` it renders, or the `.ts` of the hook or DOM function it hosts. Flags,
+* on visited files:
 *
 * - a `src/**` test whose neighbour module `<file>.ts` does not exist;
+* - a `component`-role test (`*.test.tsx`) with no neighbour of any tree;
 * - any file living in a `__tests__/` directory under `src/`;
 * - any file under a root-level `tests/` directory (the only test roots are
-*   sibling module tests under `src/` and product specifications in `specs/`).
+*   sibling tests under `src/` and product specifications in `specs/`).
 */
 const i2SiblingTestNaming = {
 	create(context) {
 		const file = context.physicalFilename;
 		const parts = segments(file);
 		return { Program(node) {
-			if (parts.includes("src")) {
+			const rendered = roleOf(file).role === "component";
+			if (parts.includes("src") || rendered) {
 				if (parts.includes("__tests__")) context.report({
 					messageId: "testsDir",
 					node
@@ -3268,8 +3675,8 @@ const i2SiblingTestNaming = {
 						".js"
 					].map((extension) => file.replace(TEST_FILE$1, extension));
 					if (!neighbours.some(isFile)) context.report({
-						data: { expected: neighbours[0]?.split(/[/\\]/u).at(-1) ?? "" },
-						messageId: "orphanTest",
+						data: { expected: neighbours[rendered ? 1 : 0]?.split(/[/\\]/u).at(-1) ?? "" },
+						messageId: rendered ? "orphanComponent" : "orphanTest",
 						node
 					});
 				}
@@ -3286,6 +3693,7 @@ const i2SiblingTestNaming = {
 	meta: {
 		docs: RULE_DOCS["i2-sibling-test-naming"],
 		messages: {
+			orphanComponent: "A component test must sit NEXT to what it renders — no neighbour \"{{expected}}\" found (I2 — see docs/13-linting.md). A hook or a DOM function is the `.ts` of the same basename, with its Host in the test file.",
 			orphanTest: "A src/ module test must sit NEXT to the module it tests — no neighbour \"{{expected}}\" found (I2 — see docs/13-linting.md). A test needing more than its module is a specification: move it to specs/.",
 			rootTests: "A root-level tests/ directory is banned — module tests are siblings under src/, product specifications live in specs/ (I2 — see docs/13-linting.md).",
 			testsDir: "__tests__/ directories are banned under src/ — the test of <file>.ts is its neighbour <file>.test.ts (I2 — see docs/13-linting.md)."
@@ -3528,11 +3936,16 @@ const plugin = {
 		"d12w-response-body-probe": d12wResponseBodyProbe,
 		"d13w-unfrozen-negative-fixture": d13wUnfrozenNegativeFixture,
 		"d15w-status-only-probe": d15wStatusOnlyProbe,
+		"e5-no-simulated-dom": e5NoSimulatedDom,
+		"e5b-no-simulated-dom-config": e5bNoSimulatedDomConfig,
+		"e6-component-project-helper": e6ComponentProjectHelper,
 		"f1-no-subpath-import": f1NoSubpathImport,
 		"f2-no-test-imports-in-prod": f2NoTestImportsInProd,
 		"f3-specs-public-entry": f3SpecsPublicEntry,
 		"f4-no-test-to-test-import": f4NoTestToTestImport,
 		"f5-fixtures-only-from-tests": f5FixturesOnlyFromTests,
+		"f6-no-foreign-test-runtime": f6NoForeignTestRuntime,
+		"g4-no-dom-in-module-test": g4NoDomInModuleTest,
 		"i1-layer-boundaries": i1LayerBoundaries,
 		"i2-sibling-test-naming": i2SiblingTestNaming,
 		"i4-no-vi-mock-in-src": i4NoViMockInSrc,