@jterrazz/test 10.0.0 → 11.0.0

package/dist/oxlint.cjs

@@ -166,7 +166,7 @@ const RULE_DOCS = {
 	},
 	"a2-known-constructors": {
 		channel: "statique",
-		convention: "Quatre constructeurs et seulement quatre : `specification.api()`, `specification.jobs()`, `specification.cli(bin)`, `specification.website()` ; tout autre membre (`.app`, `.http`, `.stack`…) est une erreur.",
+		convention: "Cinq constructeurs et seulement cinq : `specification.api()`, `specification.jobs()`, `specification.cli(bin)`, `specification.website()`, `specification.mobile()` ; tout autre membre (`.app`, `.http`, `.stack`…) est une erreur.",
 		family: "A",
 		id: "A2",
 		rationale: "Une surface fermée empêche l’invention de constructeurs parallèles et garde l’API mémorisable."
@@ -255,6 +255,20 @@ const RULE_DOCS = {
 		id: "C1",
 		rationale: "Une profondeur fixe rend la place de chaque fichier prévisible et détectable statiquement."
 	},
+	"c10-contracts-boundary": {
+		channel: "statique",
+		convention: "Hors de `specs/**/contracts/`, un import qui résout dans un dossier de provider (`contracts/{http,openai,anthropic}/…`) est une erreur : un test n’importe que les façades `*.contracts.ts`.",
+		family: "C",
+		id: "C10",
+		rationale: "Les contrats unitaires sont des détails de composition ; passer par la façade garde chaque scénario nommé au même endroit que le monde dont il dérive."
+	},
+	"c11-contract-data-pairing": {
+		channel: "statique",
+		convention: "Dans un dossier de provider, tout `*.response.json` et tout `*.request.ts` a un frère `<souche>.ts` — la souche est le nom jusqu’au PREMIER point (`events.fr.response.json` → `events.ts`) ; une donnée orpheline est une erreur.",
+		family: "C",
+		id: "C11",
+		rationale: "Une donnée n’existe que servie par un contrat — un fichier sans propriétaire est du poids mort qu’aucun test ne charge."
+	},
 	"c2-http-only-requests": {
 		channel: "statique",
 		convention: "`requests/` ne contient que des fichiers `.http` ; toute autre extension est une erreur.",
@@ -264,10 +278,10 @@ const RULE_DOCS = {
 	},
 	"c4-contract-shape": {
 		channel: "statique",
-		convention: "Un fichier de `contracts/` respecte `<nom>.<provider>.ts` (provider ∈ openai|anthropic|http), à plat, `export default defineContract(...)`, imports depuis le point d’entrée public.",
+		convention: "Sous `specs/**/contracts/` : la RACINE ne porte que des façades `*.contracts.ts` (export default construit par `defineContracts(...)` ou une re-export de composition ; exports nommés = scénarios) et les dossiers de provider `http` | `openai` | `anthropic`. Un contrat unitaire est `<provider>/<nom-kebab>.ts` avec un `export default defineContract(...)` (ou une factory qui en retourne un), et son builder de `request` doit désigner le provider de son dossier. Un dossier de provider est plat et ne contient que des `*.ts` et des `*.response.json`.",
 		family: "C",
 		id: "C4",
-		rationale: "Une forme figée rend les contrats découvrables et typables sans convention locale."
+		rationale: "Une arborescence figée sépare la façade publique des unités internes et fait porter le provider par le DOSSIER — les noms de fichiers redeviennent du métier, et la donnée volumineuse se range à côté du contrat qui la sert."
 	},
 	"c6-tomatch-extension": {
 		channel: "statique",
@@ -439,16 +453,16 @@ const RULE_DOCS = {
 	},
 	"w1-scenario-pure": {
 		channel: "statique",
-		convention: "Un scénario de visite est le When : le visiteur agit, la capture reflète l’état final ; aucun `expect()` dans le callback — les assertions vivent dans le Then, sur le résultat retourné.",
-		facet: "website",
+		convention: "Un scénario (`.visit()` website, `.open()` mobile) est le When : le visiteur agit, la capture reflète l’état final ; aucun `expect()` dans le callback — les assertions vivent dans le Then, sur le résultat retourné.",
+		facet: "shared",
 		family: "W",
 		id: "W1",
 		rationale: "Séparer l’interaction de l’assertion garde la grammaire setup → action → résultat intacte et les scénarios rejouables."
 	},
 	"w2w-user-facing-elements": {
 		channel: "statique",
-		convention: "Les éléments d’un scénario sont user-facing (`button`, `link`, `field`, `heading`, `content`) ; `testId()` est l’unique échappatoire et déclenche un avertissement.",
-		facet: "website",
+		convention: "Les éléments d’un scénario sont user-facing (`button`, `link`, `field`, `heading`, `content` ; côté mobile `button`, `field`, `content`) ; `testId()` est l’unique échappatoire et déclenche un avertissement.",
+		facet: "shared",
 		family: "W",
 		id: "W2",
 		rationale: "Tester ce que l’utilisateur voit (rôles, labels) rend les specs robustes aux refontes DOM ; un test-id contourne cette garantie."
@@ -494,7 +508,7 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "Aucune fixture morte : tout fichier sous `seeds/`/`requests/`/`intercepts/`/`fixtures/` et toute entrée de premier niveau de `expected/` doit être référencée ; un dossier de feature sans `*.test.ts` est orphelin (warning si argument non littéral).",
+		convention: "Aucune fixture morte : tout fichier sous `seeds/`/`requests/`/`fixtures/` et toute entrée de premier niveau de `expected/` doit être référencée ; un dossier de feature sans `*.test.ts` est orphelin (warning si argument non littéral).",
 		family: "C",
 		id: "C9",
 		name: "c9-dead-fixtures",
@@ -573,13 +587,22 @@ const RUNTIME_RULES = [
 	},
 	{
 		channel: "runtime",
-		convention: "Un descripteur d’élément doit désigner exactement UN élément : si plusieurs correspondent, l’action est refusée avec une erreur qui énumère les candidats et propose les réécritures (`within(...)`, `{ exact: true }`). Le framework n’agit jamais sur « le premier ».",
-		facet: "website",
+		convention: "Un descripteur d’élément doit désigner exactement UN élément quand un verbe AGIT dessus (`click`/`tap`/`fill`) : si plusieurs correspondent, l’action est refusée avec une erreur qui énumère les candidats et propose les réécritures (`within(...)`, `{ exact: true }`). Le framework n’agit jamais sur « le premier ». Vaut pour les deux facettes à scénario : website et mobile ; sur mobile, `see()` — qui n’agit sur rien — est satisfait par n’importe quel match visible (l’arbre XCUITest duplique légitimement un label entre conteneur et enfant).",
+		facet: "shared",
 		family: "W",
 		id: "W3",
 		name: "w3-unambiguous-element",
 		rationale: "Agir sur le premier match rend le spec vert alors que le visiteur clique autre chose, et rien ne le signale jamais — une ambiguïté est une faute d’écriture, pas un cas à arbitrer par l’ordre du DOM. Le comptage n’existe qu’à l’exécution : aucune analyse statique ne peut le faire, d’où le canal runtime."
 	},
+	{
+		channel: "runtime",
+		convention: "Le vocabulaire d’éléments est UNIQUE entre les facettes website et mobile ; un landmark ARIA (`main()`, `navigation()`…) passé à un verbe mobile est refusé à l’exécution — un écran iOS n’a pas de régions ARIA ; scoper avec `within(testId(…), …)`.",
+		facet: "mobile",
+		family: "W",
+		id: "W4",
+		name: "w4-no-landmarks-on-mobile",
+		rationale: "Un seul vocabulaire garde l’API mémorisable ; refuser explicitement la partie sans équivalent iOS évite une approximation silencieuse."
+	},
 	{
 		channel: "runtime",
 		convention: "`.intercept()` n’existe que sur `api`/`jobs` et lève immédiatement en mode compose (MSW est in-process).",
@@ -765,18 +788,19 @@ const a10DuplicateBinding = {
 };
 //#endregion
 //#region src/lint/rules/a2-known-constructors.ts
-/** The four constructors, and only four (A2 — see docs/10-linting.md). */
+/** The five constructors, and only five (A2 — see docs/10-linting.md). */
 const KNOWN_CONSTRUCTORS = /* @__PURE__ */ new Set([
 	"api",
 	"cli",
 	"jobs",
+	"mobile",
 	"website"
 ]);
 /**
 * CONVENTIONS A2 — `specification.api()`, `specification.jobs()`,
-* `specification.cli()` and `specification.website()` are the only members.
-* Any other access (`specification.app`, `.http`, `.stack`, …) is flagged at
-* the member site.
+* `specification.cli()`, `specification.website()` and
+* `specification.mobile()` are the only members. Any other access
+* (`specification.app`, `.http`, `.stack`, …) is flagged at the member site.
 */
 const a2KnownConstructors = {
 	create(context) {
@@ -793,7 +817,7 @@ const a2KnownConstructors = {
 	},
 	meta: {
 		docs: RULE_DOCS["a2-known-constructors"],
-		messages: { unknownConstructor: "specification.{{member}} does not exist — the only constructors are specification.api(), specification.jobs(), specification.cli() and specification.website() (A2 — see docs/10-linting.md)." },
+		messages: { unknownConstructor: "specification.{{member}} does not exist — the only constructors are specification.api(), specification.jobs(), specification.cli(), specification.website() and specification.mobile() (A2 — see docs/10-linting.md)." },
 		type: "problem"
 	}
 };
@@ -1426,8 +1450,94 @@ const c1DomainStructure = {
 	}
 };
 //#endregion
+//#region src/lint/rules/c10-contracts-boundary.ts
+/** A specifier reaching into a provider folder — the internal half of contracts/. */
+const INTERNAL_UNIT = /(?:^|\/)contracts\/(?:anthropic|http|openai)\//u;
+/**
+* CONVENTIONS C10 — the contracts boundary. A feature's `contracts/` folder has
+* a PUBLIC half (`*.contracts.ts` facades: the default export is the world, the
+* named exports are its scenarios) and an INTERNAL half (the `http/`, `openai/`
+* and `anthropic/` unit contracts the facades compose). Outside `contracts/`,
+* importing a unit is an error — a test routes through the facade, so a
+* scenario is named once, next to the world it derives from.
+*/
+const c10ContractsBoundary = {
+	create(context) {
+		const parts = segments(context.physicalFilename);
+		if (!parts.includes("specs")) return {};
+		if (parts.slice(0, -1).includes("contracts")) return {};
+		return importSourceVisitor(({ node, source }) => {
+			if (INTERNAL_UNIT.test(source)) context.report({
+				data: { source },
+				messageId: "internal",
+				node
+			});
+		});
+	},
+	meta: {
+		docs: RULE_DOCS["c10-contracts-boundary"],
+		messages: { internal: "Import \"{{source}}\" reaches into a provider folder — only contracts/*.contracts.ts is importable from a test; add a named scenario export there instead (C10 — see docs/10-linting.md)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/c11-contract-data-pairing.ts
+const TEST_FILE$11 = /\.test\.[cm]?[jt]sx?$/;
+/** The provider folders that may carry data files. */
+const PROVIDERS$1 = [
+	"anthropic",
+	"http",
+	"openai"
+];
+/** Data files: served payloads and matched inputs, both owned by a contract. */
+const DATA_SUFFIXES = [".request.ts", ".response.json"];
+/** The owning contract of a data file: its name up to the FIRST dot, `.ts`. */
+function ownerOf(entry) {
+	return `${entry.slice(0, entry.indexOf("."))}.ts`;
+}
+/**
+* CONVENTIONS C11 — data is owned by a contract. Inside a provider folder every
+* `*.response.json` (served payload) and `*.request.ts` (matched prompt/body)
+* pairs with the sibling `<stem>.ts` that serves it, where the stem is the name
+* up to the FIRST dot: `events.fr.response.json` belongs to `events.ts`. A data
+* file with no owner is dead weight no test can reach — reported on the feature's
+* test file, since oxlint never visits a `.json`.
+*/
+const c11ContractDataPairing = {
+	create(context) {
+		const file = context.physicalFilename;
+		if (!TEST_FILE$11.test(file) || !segments(file).includes("specs")) return {};
+		return { Program(node) {
+			const contractsDir = (0, node_path.join)((0, node_path.dirname)(file), "contracts");
+			for (const provider of PROVIDERS$1) {
+				const entries = listDirectory((0, node_path.join)(contractsDir, provider));
+				if (entries === null) continue;
+				const present = new Set(entries);
+				for (const entry of entries) {
+					if (!DATA_SUFFIXES.some((suffix) => entry.endsWith(suffix))) continue;
+					const owner = ownerOf(entry);
+					if (!present.has(owner)) context.report({
+						data: {
+							entry,
+							owner,
+							provider
+						},
+						messageId: "orphan",
+						node
+					});
+				}
+			}
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["c11-contract-data-pairing"],
+		messages: { orphan: "contracts/{{provider}}/{{entry}} has no owning contract — data pairs with the sibling {{owner}} (stem = name up to the first dot) (C11 — see docs/10-linting.md)." },
+		type: "problem"
+	}
+};
+//#endregion
 //#region src/lint/rules/c2-http-only-requests.ts
-const TEST_FILE$9 = /\.test\.[cm]?[jt]sx?$/;
+const TEST_FILE$10 = /\.test\.[cm]?[jt]sx?$/;
 /**
 * CONVENTIONS C2 — `requests/` contains only `.http` files (a request file is
 * a COMPLETE request: method, path, headers, body). Anchored on the feature's
@@ -1438,7 +1548,7 @@ const TEST_FILE$9 = /\.test\.[cm]?[jt]sx?$/;
 const c2HttpOnlyRequests = {
 	create(context) {
 		const file = context.physicalFilename;
-		if (!TEST_FILE$9.test(file) || !segments(file).includes("specs")) return {};
+		if (!TEST_FILE$10.test(file) || !segments(file).includes("specs")) return {};
 		return { Program(node) {
 			const requestsDir = (0, node_path.join)((0, node_path.dirname)(file), "requests");
 			for (const entry of listDirectory(requestsDir) ?? []) if (!entry.endsWith(".http")) context.report({
@@ -1456,65 +1566,217 @@ const c2HttpOnlyRequests = {
 };
 //#endregion
 //#region src/lint/rules/c4-contract-shape.ts
-/** Providers a contract file may declare (C4 — see docs/10-linting.md). */
+/** The only directories a `contracts/` root may hold — the provider carriers. */
 const PROVIDERS = /* @__PURE__ */ new Set([
 	"anthropic",
 	"http",
 	"openai"
 ]);
-const CONTRACT_NAME = /^[A-Za-z0-9][\w-]*\.(?<provider>[a-z]+)\.[cm]?ts$/;
-/** Is the import source the framework's public entry (`@jterrazz/test` / `src/index`)? */
-function isPublicEntry(source) {
-	return source === "@jterrazz/test" || source.endsWith("/src/index.js") || source.endsWith("/src/index.ts");
+const TEST_FILE$9 = /\.test\.[cm]?[jt]sx?$/;
+/** A file oxlint itself visits — the AST half of the rule reports on those. */
+const SOURCE_FILE = /\.[cm]?[jt]sx?$/;
+/** The public facade of a feature: `contracts/<kebab>.contracts.ts`. */
+const COMPOSITE_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.contracts\.[cm]?ts$/u;
+/** An internal unit contract: `contracts/<provider>/<kebab>.ts`. */
+const UNIT_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.[cm]?ts$/u;
+/** Matched data next to its contract: `contracts/<provider>/<stem>.request.ts`. */
+const REQUEST_DATA_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.request\.[cm]?ts$/u;
+/** Served data next to its contract: `contracts/<provider>/<stem>[.<qualifier>].response.json`. */
+const RESPONSE_DATA_FILE = /\.response\.json$/;
+/** The name a specifier/declaration exports under, when it is `default`. */
+function exportsDefault(node) {
+	return (node.specifiers ?? []).some((specifier) => {
+		const exported = specifier.exported;
+		return exported?.type === "Identifier" && exported.name === "default" || stringValue(exported) === "default";
+	});
+}
+/** Is this node a `defineContract(...)` call? */
+function isDefineContract(node) {
+	const callee = node.callee;
+	return node.type === "CallExpression" && callee?.type === "Identifier" && callee.name === "defineContract";
+}
+/** A default export that may legitimately produce a contract (value or factory). */
+function producesContract(declaration) {
+	if (declaration === void 0) return false;
+	return isDefineContract(declaration) || declaration.type === "ArrowFunctionExpression" || declaration.type === "FunctionDeclaration" || declaration.type === "FunctionExpression" || declaration.type === "Identifier";
 }
 /**
-* CONVENTIONS C4 — a contract file (`contracts/<name>.<provider>.ts`) has a
-* rigid shape: flat under `contracts/` (no subfolders), `provider ∈ { openai,
-* anthropic, http }`, a single `export default defineContract(...)`, no named
-* exports, and imports only from the public entry. The runtime channel (the
-* loader) only catches a bad default export; this rule closes the rest.
+* The provider a `request:` value implies, when the builder is written as
+* `<provider>.<verb>(…)` — the only statically decidable form.
 */
-const c4ContractShape = {
-	create(context) {
-		const parts = segments(context.physicalFilename);
-		const contractsIndex = parts.lastIndexOf("contracts");
-		if (contractsIndex === -1 || contractsIndex >= parts.length - 1 || !parts.includes("specs")) return {};
-		const base = parts.at(-1) ?? "";
-		return { Program(node) {
-			if (contractsIndex !== parts.length - 2) context.report({
-				data: { base },
-				messageId: "subfolder",
+function requestProvider(request) {
+	if (request?.type !== "CallExpression") return;
+	const callee = request.callee;
+	if (callee?.type !== "MemberExpression") return;
+	const object = callee.object;
+	return object?.type === "Identifier" ? object.name : void 0;
+}
+/**
+* The layout half — walks the feature's `contracts/` tree from the test file
+* that owns it. Covers what oxlint never visits: a stray `.json` at the root,
+* a directory that is not a provider, a nested folder or a foreign extension
+* inside a provider folder.
+*/
+function checkLayout(context, node, contractsDir) {
+	const entries = listDirectory(contractsDir);
+	if (entries === null) return;
+	for (const entry of entries) {
+		const path = (0, node_path.join)(contractsDir, entry);
+		if (!isDirectory(path)) {
+			if (!SOURCE_FILE.test(entry)) context.report({
+				data: { entry },
+				messageId: "rootEntry",
 				node
 			});
-			const match = CONTRACT_NAME.exec(base);
-			if (match === null || !PROVIDERS.has(match.groups?.provider ?? "")) context.report({
-				data: { base },
-				messageId: "badName",
+			continue;
+		}
+		if (!PROVIDERS.has(entry)) {
+			context.report({
+				data: { entry },
+				messageId: "badProviderDir",
 				node
 			});
-			let hasDefault = false;
-			for (const statement of node.body ?? []) if (statement.type === "ImportDeclaration") {
-				const source = stringValue(statement.source);
-				if (source !== void 0 && !isPublicEntry(source)) context.report({
-					data: { source },
-					messageId: "foreignImport",
-					node: statement
-				});
-			} else if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") context.report({
-				messageId: "namedExport",
-				node: statement
-			});
-			else if (statement.type === "ExportDefaultDeclaration") {
+			continue;
+		}
+		for (const child of listDirectory(path) ?? []) if (isDirectory((0, node_path.join)(path, child))) context.report({
+			data: {
+				child,
+				provider: entry
+			},
+			messageId: "providerSubfolder",
+			node
+		});
+		else if (!/\.[cm]?ts$/u.test(child) && !RESPONSE_DATA_FILE.test(child)) context.report({
+			data: {
+				child,
+				provider: entry
+			},
+			messageId: "providerEntry",
+			node
+		});
+	}
+}
+/** The facade: `<kebab>.contracts.ts`, default-exporting a composition. */
+function checkComposite(context, program, base) {
+	if (!COMPOSITE_FILE.test(base)) {
+		context.report({
+			data: { base },
+			messageId: "rootFile",
+			node: program
+		});
+		return;
+	}
+	let hasDefault = false;
+	let composed = false;
+	walk(program, (node) => {
+		if (node.type === "ExportDefaultDeclaration") hasDefault = true;
+		else if (node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") {
+			if (exportsDefault(node)) {
 				hasDefault = true;
-				const declaration = statement.declaration;
-				const callee = declaration?.type === "CallExpression" ? declaration.callee : void 0;
-				if (callee?.type !== "Identifier" || callee.name !== "defineContract") context.report({
-					messageId: "notDefineContract",
-					node: statement
-				});
+				composed = stringValue(node.source) !== void 0 || composed;
 			}
-			if (!hasDefault) context.report({
-				messageId: "missingDefault",
+		} else if (node.type === "CallExpression") {
+			const callee = node.callee;
+			if (callee?.type === "Identifier" && callee.name === "defineContracts" || callee !== void 0 && memberPropertyName(callee) === "with") composed = true;
+		}
+	});
+	if (!hasDefault) context.report({
+		data: { base },
+		messageId: "missingComposite",
+		node: program
+	});
+	else if (!composed) context.report({
+		data: { base },
+		messageId: "notDefineContracts",
+		node: program
+	});
+}
+/** A unit contract under its provider folder. */
+function checkUnit(context, program, base, provider) {
+	if (REQUEST_DATA_FILE.test(base)) return;
+	if (!UNIT_FILE.test(base)) {
+		context.report({
+			data: { base },
+			messageId: "badName",
+			node: program
+		});
+		return;
+	}
+	let hasDefault = false;
+	let wellFormed = false;
+	walk(program, (node) => {
+		if (node.type === "ExportDefaultDeclaration") {
+			hasDefault = true;
+			wellFormed = producesContract(node.declaration) || wellFormed;
+		} else if (node.type === "ExportNamedDeclaration" && exportsDefault(node)) {
+			hasDefault = true;
+			wellFormed = true;
+		}
+		if (isDefineContract(node)) {
+			const argument = node.arguments?.[0];
+			const declared = requestProvider(argument === void 0 ? void 0 : findProperty(argument, "request")?.value);
+			if (declared !== void 0 && PROVIDERS.has(declared) && declared !== provider) context.report({
+				data: {
+					declared,
+					provider
+				},
+				messageId: "providerMismatch",
+				node
+			});
+		}
+	});
+	if (!hasDefault) context.report({
+		data: { base },
+		messageId: "missingDefault",
+		node: program
+	});
+	else if (!wellFormed) context.report({
+		data: { base },
+		messageId: "notDefineContract",
+		node: program
+	});
+}
+/**
+* CONVENTIONS C4 — the structure of a feature's `contracts/` tree. The ROOT
+* holds only `*.contracts.ts` facades (default export = a `defineContracts`
+* composition, named exports = scenario factories) and the provider
+* directories `http` / `openai` / `anthropic`. A provider directory holds
+* `<kebab>.ts` unit contracts (default export = `defineContract(...)` or a
+* factory returning one) plus their sibling data (`*.response.json`,
+* `*.request.ts`) — the FOLDER carries the provider, so a unit whose `request`
+* builder names another provider is an error.
+*
+* Two halves: the AST half reports on each contract file it visits, the layout
+* half walks the tree from the feature's test file (oxlint never visits a
+* `.json` fixture or an empty directory).
+*/
+const c4ContractShape = {
+	create(context) {
+		const file = context.physicalFilename;
+		const parts = segments(file);
+		if (!parts.includes("specs")) return {};
+		const contractsIndex = parts.lastIndexOf("contracts");
+		if (contractsIndex === -1) {
+			if (!TEST_FILE$9.test(file)) return {};
+			return { Program(node) {
+				checkLayout(context, node, (0, node_path.join)((0, node_path.dirname)(file), "contracts"));
+			} };
+		}
+		const base = parts.at(-1) ?? "";
+		const depth = parts.length - 1 - contractsIndex;
+		if (depth === 1) return { Program(node) {
+			checkComposite(context, node, base);
+		} };
+		if (depth === 2) {
+			const provider = parts[contractsIndex + 1];
+			return PROVIDERS.has(provider) ? { Program(node) {
+				checkUnit(context, node, base, provider);
+			} } : {};
+		}
+		return { Program(node) {
+			context.report({
+				data: { base },
+				messageId: "tooDeep",
 				node
 			});
 		} };
@@ -1522,12 +1784,18 @@ const c4ContractShape = {
 	meta: {
 		docs: RULE_DOCS["c4-contract-shape"],
 		messages: {
-			badName: "Contract file \"{{base}}\" must be named <name>.<provider>.ts with provider ∈ openai | anthropic | http (C4 — see docs/10-linting.md).",
-			foreignImport: "Contract imports \"{{source}}\" — a contract imports only from the public entry (@jterrazz/test) (C4 — see docs/10-linting.md).",
-			missingDefault: "Contract file has no `export default defineContract(...)` (C4 — see docs/10-linting.md).",
-			namedExport: "Contract files have no named exports — only `export default defineContract(...)` (C4 — see docs/10-linting.md).",
-			notDefineContract: "The default export of a contract file must be `defineContract(...)` syntactically (C4 — see docs/10-linting.md).",
-			subfolder: "Contract file \"{{base}}\" is nested — contracts/ is flat, no subfolders (C4 — see docs/10-linting.md)."
+			badName: "Contract unit \"{{base}}\" must be named <kebab-name>.ts — the folder already carries the provider (C4 — see docs/10-linting.md).",
+			badProviderDir: "contracts/{{entry}}/ is not a provider directory — a contracts/ root holds only http/, openai/, anthropic/ and *.contracts.ts files (C4 — see docs/10-linting.md).",
+			missingComposite: "Contract facade \"{{base}}\" has no default export — it must default-export the composed world (C4 — see docs/10-linting.md).",
+			missingDefault: "Contract unit \"{{base}}\" has no default export — a unit default-exports `defineContract(...)` or a factory returning one (C4 — see docs/10-linting.md).",
+			notDefineContract: "The default export of a contract unit must be `defineContract(...)` or a factory returning a contract (C4 — see docs/10-linting.md).",
+			notDefineContracts: "The default export of \"{{base}}\" must be built from `defineContracts(...)` (or a composition re-export) (C4 — see docs/10-linting.md).",
+			providerEntry: "contracts/{{provider}}/{{child}} is neither a *.ts contract nor a *.response.json payload (C4 — see docs/10-linting.md).",
+			providerMismatch: "This contract lives in contracts/{{provider}}/ but its request is a `{{declared}}.*` builder — the folder carries the provider (C4 — see docs/10-linting.md).",
+			providerSubfolder: "contracts/{{provider}}/{{child}}/ is nested — a provider folder is flat (C4 — see docs/10-linting.md).",
+			rootEntry: "contracts/{{entry}} is not a *.contracts.ts facade — data files live in a provider folder next to their contract (C4 — see docs/10-linting.md).",
+			rootFile: "Contract file \"{{base}}\" sits at the contracts/ root, which holds only *.contracts.ts facades — a unit contract belongs in http/, openai/ or anthropic/ (C4 — see docs/10-linting.md).",
+			tooDeep: "Contract file \"{{base}}\" is nested deeper than contracts/<provider>/ (C4 — see docs/10-linting.md)."
 		},
 		type: "problem"
 	}
@@ -2430,6 +2698,7 @@ const f5FixturesOnlyFromTests = {
 */
 const INTEGRATION_DEPS = {
 	anthropic: ["@anthropic-ai/sdk"],
+	appium: ["webdriverio"],
 	compose: ["yaml"],
 	docker: [],
 	hono: ["hono", "@hono/node-server"],
@@ -2507,6 +2776,7 @@ const i1LayerBoundaries = {
 				if (target.startsWith("core/") || target.startsWith("integrations/docker/") || target.startsWith("integrations/hono/") || withoutExtension(target) === "vitest/matchers") return null;
 				if (target.startsWith("integrations/msw/") && inside === "core/specification/shared/builder.ts") return null;
 				if (target.startsWith("integrations/playwright/") && inside === "core/specification/website/start-website.ts") return null;
+				if (target.startsWith("integrations/appium/") && inside === "core/specification/mobile/start-mobile.ts") return null;
 				return "crossLayer";
 			}
 			if (layer === "integrations") return target.startsWith("core/") || target.startsWith(`integrations/${integrationFolder}/`) ? null : "crossLayer";
@@ -2832,6 +3102,82 @@ const TITLED = /* @__PURE__ */ new Set([
 * `HTTP`, `DI`. Such a word names a symbol verbatim — lowercasing it would
 * misspell it — so it is exempt. A prose word (`Rejects`, `Builds`) is not. */
 const ALL_CAPS_IDENTIFIER = /^[A-Z][A-Z0-9_]*$/u;
+/**
+* CONVENTIONS J5 — the first character of a `test('…')` / `describe('…')` title
+* literal must be lowercase.
+*
+* The test name is the sole description of behaviour (B3): a sentence fragment,
+* lowercase-led like prose (`'rejects an unknown job'`). Exempt are titles
+* whose first WORD is an identifier-shaped all-caps/underscored token
+* (`'VALID_CATEGORIES is rejected'`, `'HTTP is upgraded'`, `'DI wires …'`) —
+* lowercasing a named symbol would misspell it — and titles opening on a
+* non-letter (a `$`, a `{`, a `%s` placeholder). Only lowercase-able prose
+* first words are enforced. Covers the modifier and parametrized forms
+* (`test.only`, `describe.each(...)(...)`) via the chain root.
+*/
+const j5LowercaseTitle = {
+	create(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			const root = chainRootName(callee);
+			if (root === void 0 || !TITLED.has(root)) return;
+			const title = stringValue(node.arguments?.[0]);
+			if (title === void 0) return;
+			const first = [...title][0];
+			if (first === void 0 || !/\p{L}/u.test(first)) return;
+			const firstWord = title.split(/\s+/u)[0];
+			if (ALL_CAPS_IDENTIFIER.test(firstWord)) return;
+			if (first !== first.toLocaleLowerCase()) context.report({
+				data: { runner: root },
+				messageId: "uppercase",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["j5-lowercase-title"],
+		messages: { uppercase: "A {{runner}}() title must start lowercase — the test name is a prose fragment, not a sentence (J5 — see docs/10-linting.md)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/w1-scenario-pure.ts
+/** The scenario-carrying terminal actions: `.visit()` (website) and `.open()` (mobile). */
+const SCENARIO_ACTIONS$1 = /* @__PURE__ */ new Set(["open", "visit"]);
+/**
+* CONVENTIONS W1 — a visit (or mobile open) scenario is the When: the
+* visitor interacts, the capture reflects the final state, and assertions
+* live in the Then on the returned result. An `expect()` inside the scenario
+* callback is flagged.
+*/
+const w1ScenarioPure = {
+	create(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			const member = callee ? memberPropertyName(callee) : void 0;
+			if (member === void 0 || !SCENARIO_ACTIONS$1.has(member)) return;
+			const scenario = node.arguments?.[1];
+			if (scenario?.type !== "ArrowFunctionExpression" && scenario?.type !== "FunctionExpression") return;
+			walk(scenario, (inner) => {
+				if (inner.type !== "CallExpression") return;
+				const innerCallee = inner.callee;
+				if (innerCallee?.type === "Identifier" && innerCallee.name === "expect") context.report({
+					messageId: "expectInScenario",
+					node: inner
+				});
+			});
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["w1-scenario-pure"],
+		messages: { expectInScenario: "No expect() inside a scenario — the scenario is the When; assert the final state on the returned result in the Then (W1 — see docs/10-linting.md)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/w2w-user-facing-elements.ts
+/** The scenario-carrying terminal actions: `.visit()` (website) and `.open()` (mobile). */
+const SCENARIO_ACTIONS = /* @__PURE__ */ new Set(["open", "visit"]);
 //#endregion
 //#region src/lint/plugin.ts
 /**
@@ -2866,6 +3212,8 @@ const plugin = {
 		"b8-kebab-trigger": b8KebabTrigger,
 		"b9w-product-command": b9wProductCommand,
 		"c1-domain-structure": c1DomainStructure,
+		"c10-contracts-boundary": c10ContractsBoundary,
+		"c11-contract-data-pairing": c11ContractDataPairing,
 		"c2-http-only-requests": c2HttpOnlyRequests,
 		"c4-contract-shape": c4ContractShape,
 		"c6-tomatch-extension": c6ToMatchExtension,
@@ -2891,59 +3239,14 @@ const plugin = {
 		"j2-no-sleep-in-specs": j2NoSleepInSpecs,
 		"j3-no-expectless-test": j3NoExpectlessTest,
 		"j4-unique-test-names": j4UniqueTestNames,
-		"j5-lowercase-title": {
-			create(context) {
-				return { CallExpression(node) {
-					const callee = node.callee;
-					const root = chainRootName(callee);
-					if (root === void 0 || !TITLED.has(root)) return;
-					const title = stringValue(node.arguments?.[0]);
-					if (title === void 0) return;
-					const first = [...title][0];
-					if (first === void 0 || !/\p{L}/u.test(first)) return;
-					const firstWord = title.split(/\s+/u)[0];
-					if (ALL_CAPS_IDENTIFIER.test(firstWord)) return;
-					if (first !== first.toLocaleLowerCase()) context.report({
-						data: { runner: root },
-						messageId: "uppercase",
-						node
-					});
-				} };
-			},
-			meta: {
-				docs: RULE_DOCS["j5-lowercase-title"],
-				messages: { uppercase: "A {{runner}}() title must start lowercase — the test name is a prose fragment, not a sentence (J5 — see docs/10-linting.md)." },
-				type: "problem"
-			}
-		},
-		"w1-scenario-pure": {
-			create(context) {
-				return { CallExpression(node) {
-					const callee = node.callee;
-					if (!callee || memberPropertyName(callee) !== "visit") return;
-					const scenario = node.arguments?.[1];
-					if (scenario?.type !== "ArrowFunctionExpression" && scenario?.type !== "FunctionExpression") return;
-					walk(scenario, (inner) => {
-						if (inner.type !== "CallExpression") return;
-						const innerCallee = inner.callee;
-						if (innerCallee?.type === "Identifier" && innerCallee.name === "expect") context.report({
-							messageId: "expectInScenario",
-							node: inner
-						});
-					});
-				} };
-			},
-			meta: {
-				docs: RULE_DOCS["w1-scenario-pure"],
-				messages: { expectInScenario: "No expect() inside a visit scenario — the scenario is the When; assert the final state on the returned result in the Then (W1 — see docs/10-linting.md)." },
-				type: "problem"
-			}
-		},
+		"j5-lowercase-title": j5LowercaseTitle,
+		"w1-scenario-pure": w1ScenarioPure,
 		"w2w-user-facing-elements": {
 			create(context) {
 				return { CallExpression(node) {
 					const callee = node.callee;
-					if (!callee || memberPropertyName(callee) !== "visit") return;
+					const member = callee ? memberPropertyName(callee) : void 0;
+					if (member === void 0 || !SCENARIO_ACTIONS.has(member)) return;
 					const scenario = node.arguments?.[1];
 					if (scenario?.type !== "ArrowFunctionExpression" && scenario?.type !== "FunctionExpression") return;
 					walk(scenario, (inner) => {