@jterrazz/test 10.1.0 → 11.0.0

package/dist/intercept.js

@@ -1,3 +1,4 @@
+import { t as ContractQueue } from "./queue.js";
 //#region src/integrations/msw/intercept.ts
 let mswModule = null;
 let mswHttp = null;
@@ -15,100 +16,54 @@ let serverInstance = null;
 /**
 * Start the MSW server (once per process).
 */
-async function ensureInterceptServer() {
+async function ensureContractServer() {
 	if (serverInstance) return;
 	const { node } = await loadMsw();
 	serverInstance = node.setupServer();
 	serverInstance.listen({ onUnhandledRequest: "bypass" });
 }
-function describeTrigger(entry) {
-	return `${entry.trigger.method === "*" ? "ANY" : entry.trigger.method} ${String(entry.trigger.url)}`;
-}
-/**
-* Pure FIFO queue over the chain's intercept entries. Each observed request
-* consumes the first unconsumed entry whose URL, method, and optional body
-* matcher accept it. Exported for unit tests — MSW never reaches this class.
-*/
-var InterceptQueue = class {
-	consumed;
-	entries;
-	constructor(entries) {
-		this.entries = entries;
-		this.consumed = entries.map(() => false);
-	}
-	/**
-	* Unique trigger URLs, preserving RegExp/string identity for MSW routing.
-	* Deduped by string form — two RegExp objects with the same source are
-	* one trigger (and get one handler).
-	*/
-	get urls() {
-		const urls = /* @__PURE__ */ new Map();
-		for (const entry of this.entries) {
-			const key = String(entry.trigger.url);
-			if (!urls.has(key)) urls.set(key, entry.trigger.url);
-		}
-		return [...urls.values()];
-	}
-	/** Methods declared for a given trigger URL. */
-	methodsFor(url) {
-		const methods = /* @__PURE__ */ new Set();
-		for (const entry of this.entries) if (sameUrl(entry.trigger.url, url)) methods.add(entry.trigger.method);
-		return [...methods];
-	}
-	/**
-	* Consume and return the first unconsumed entry registered for
-	* `handlerUrl`/`method` that accepts the request, or null when the queue
-	* for that trigger is exhausted (or no matcher accepts).
-	*/
-	take(handlerUrl, method, request) {
-		for (let i = 0; i < this.entries.length; i++) {
-			if (this.consumed[i]) continue;
-			const entry = this.entries[i];
-			if (!sameUrl(entry.trigger.url, handlerUrl)) continue;
-			if (entry.trigger.method !== method && entry.trigger.method !== "*") continue;
-			if (entry.trigger.match && !entry.trigger.match(request)) continue;
-			this.consumed[i] = true;
-			return entry;
-		}
-		return null;
-	}
-	/**
-	* Build the strict-intercept failure for a request that matched no
-	* registered intercept (CONVENTIONS D7): method + URL of the offending
-	* request, plus every registered trigger and its consumption state.
-	*/
-	unmatchedError(method, url) {
-		const triggers = this.entries.length === 0 ? "  (no intercepts registered)" : this.entries.map((entry, i) => `  - ${describeTrigger(entry)}${this.consumed[i] ? " (already consumed)" : ""}`).join("\n");
-		return /* @__PURE__ */ new Error(`Unmatched outgoing HTTP request during spec: ${method} ${url}\nRegistered intercepts:\n${triggers}\nEvery outgoing request of a chain that declares intercepts must match one — add an .intercept() for it (or one more if its queue is exhausted).`);
-	}
-};
-function sameUrl(a, b) {
-	return a === b || String(a) === String(b);
+/** Turn a contract response into the MSW reply, body kind by body kind. */
+function toMswResponse(msw, response) {
+	const { body, headers, status = 200 } = response;
+	if (body === null || body === void 0) return new msw.HttpResponse(null, {
+		headers,
+		status
+	});
+	if (typeof body === "string") return new msw.HttpResponse(body, {
+		headers: {
+			"content-type": "text/plain; charset=utf-8",
+			...headers
+		},
+		status
+	});
+	return msw.HttpResponse.json(body, {
+		headers,
+		status
+	});
 }
 /**
-* Register intercept entries as MSW handlers for one chain. A trailing
-* catch-all handler records any request that no entry accepted — the
-* builder rethrows it as the spec failure (rejecting the action promise,
-* never an unhandled rejection).
+* Register a chain's contracts as MSW handlers. A trailing catch-all handler
+* records any request no contract accepted — the builder rethrows it as the
+* spec failure (rejecting the action promise, never an unhandled rejection).
 */
-async function registerIntercepts(entries) {
-	if (entries.length === 0) return {
+async function registerContracts(contracts) {
+	if (contracts.length === 0) return {
 		cleanup: () => {},
 		violation: () => null
 	};
-	await ensureInterceptServer();
+	await ensureContractServer();
 	const { msw } = await loadMsw();
-	const queue = new InterceptQueue(entries);
+	const queue = new ContractQueue(contracts);
 	let violation = null;
 	const recordViolation = (method, url) => {
 		violation ??= queue.unmatchedError(method, url);
-		return msw.HttpResponse.json({ error: `@jterrazz/test strict intercepts: unmatched request ${method} ${url}` }, { status: 501 });
+		return msw.HttpResponse.json({ error: `@jterrazz/test strict contracts: unmatched request ${method} ${url}` }, { status: 501 });
 	};
 	const handlers = [];
-	for (const url of queue.urls) for (const method of queue.methodsFor(url)) {
+	for (const route of queue.routes) for (const method of route.methods) {
 		const handlerFn = method === "*" ? msw.http.all : msw.http[method.toLowerCase()];
 		if (!handlerFn) continue;
-		const handler = handlerFn(url, async ({ request }) => {
+		const handler = handlerFn(route.url, async ({ request }) => {
 			let body = null;
 			const rawText = await request.clone().text();
 			if (rawText) try {
@@ -123,16 +78,14 @@ async function registerIntercepts(entries) {
 			const observed = {
 				body,
 				headers,
+				method: request.method.toUpperCase(),
 				url: request.url
 			};
-			const entry = queue.take(url, request.method, observed);
-			if (!entry) return recordViolation(request.method, request.url);
-			const response = typeof entry.response === "function" ? entry.response(observed) : entry.response;
+			const contract = queue.take(observed);
+			if (!contract) return recordViolation(request.method, request.url);
+			const response = typeof contract.response === "function" ? contract.response(observed) : contract.response;
 			if (response.delay) await new Promise((r) => setTimeout(r, response.delay));
-			return msw.HttpResponse.json(response.body, {
-				status: response.status ?? 200,
-				headers: response.headers
-			});
+			return toMswResponse(msw, response);
 		});
 		handlers.push(handler);
 	}
@@ -142,8 +95,8 @@ async function registerIntercepts(entries) {
 		cleanup: () => {
 			serverInstance.resetHandlers();
 		},
-		violation: () => violation
+		violation: () => violation ?? queue.requiredError()
 	};
 }
 //#endregion
-export { registerIntercepts };
+export { registerContracts };

package/dist/match.js

@@ -1,5 +1,5 @@
 //#region src/core/matching/match.ts
-/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex). */
+/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex/includes). */
 const TOKEN_KINDS = [
 	"any",
 	"base64",
@@ -28,6 +28,8 @@ const TOKEN_KINDS = [
 * constructed directly by user code.
 */
 var Matcher = class {
+	/** For kind 'includes': the substring the actual value must contain. */
+	includes;
 	kind;
 	/** For kind 'ref': the capture to assert inequality against. */
 	notRef;
@@ -36,6 +38,7 @@ var Matcher = class {
 	/** For kind 'regex': the pattern the actual value must match. */
 	regex;
 	constructor(kind, options = {}) {
+		this.includes = options.includes;
 		this.kind = kind;
 		this.notRef = options.notRef;
 		this.refName = options.refName;
@@ -44,6 +47,7 @@ var Matcher = class {
 	/** Placeholder-style rendering used in failure diffs and serialization. */
 	toString() {
 		switch (this.kind) {
+			case "includes": return `{{includes:${this.includes}}}`;
 			case "ref": return this.notRef ? `{{ref#${this.refName}!${this.notRef}}}` : `{{ref#${this.refName}}}`;
 			case "regex": return `{{regex:${this.regex?.source}}}`;
 			default: return this.refName ? `{{${this.kind}#${this.refName}}}` : `{{${this.kind}}}`;
@@ -83,6 +87,13 @@ const match = {
 	float: typed("float"),
 	/** Matches a hexadecimal string. */
 	hex: typed("hex"),
+	/**
+	* Matches a string CONTAINING the given substring. Code-only, like
+	* {@link match.regex} — the `{{token}}` fixture vocabulary does not grow.
+	* The explicit escape hatch now that contract string filters
+	* (`openai.chat({ user })`) mean exact equality.
+	*/
+	includes: (substring) => new Matcher("includes", { includes: substring }),
 	/** Matches an integer (or an integer string in text contexts). */
 	int: typed("int"),
 	/** Matches an IPv4 address. */

package/dist/oxlint.cjs

@@ -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",
@@ -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",
@@ -1436,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
@@ -1448,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({
@@ -1466,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
 			});
 		} };
@@ -1532,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"
 	}
@@ -2954,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,