@jterrazz/test 12.2.0 → 13.0.0

package/dist/match.js

@@ -1,194 +1,74 @@
-//#region src/core/literate/literate-file.ts
-/** The closed set of header keys. Anything else is an error naming the line. */
-const HEADER_KEYS = [
-	"test",
-	"given",
-	"then",
-	"fixture",
-	"env",
-	"serve"
-];
-/** The separator opening a block's stderr section. */
-const STDERR_MARKER = "--- stderr";
-const HEADER_LINE = /^(?<key>[a-z]+):(?<value>.*)$/;
-const EXIT_LINE = /^exit:\s*(?<code>-?\d+)\s*$/;
-const KEY_SET = new Set(HEADER_KEYS);
-/** A refusal from the grammar, carrying where it happened and which rule it is. */
-var LiterateSyntaxError = class extends Error {
-	defect;
-	line;
-	constructor(fileName, line, message, defect) {
-		super(`${fileName}:${line}: ${message}`);
-		this.defect = defect;
-		this.line = line;
-		this.name = "LiterateSyntaxError";
-	}
-};
-function fail(fileName, line, message, defect = "shape") {
-	throw new LiterateSyntaxError(fileName, line, message, defect);
-}
-/** Is this line the start of a block? `$ cmd`, or a bare `$` (no arguments). */
-function isBlockStart(line) {
-	return line === "$" || line.startsWith("$ ");
-}
-function parseEnvTokens(value, fileName, line) {
-	const tokens = [];
-	for (const token of value.split(/\s+/).filter((part) => part.length > 0)) {
-		const separator = token.indexOf("=");
-		if (separator === -1) {
-			tokens.push({
-				kind: "set",
-				name: token
-			});
-			continue;
-		}
-		const key = token.slice(0, separator);
-		if (key.length === 0) fail(fileName, line, `env: "${token}" has no variable name before the "="`);
-		tokens.push({
-			key,
-			kind: "pair",
-			value: token.slice(separator + 1)
-		});
-	}
-	if (tokens.length === 0) fail(fileName, line, "env: needs at least one KEY=value pair or a registered env-set name");
-	return tokens;
-}
-function parseServeEntry(value, fileName, line) {
-	const parts = value.split(/\s+/).filter((part) => part.length > 0);
-	const name = parts.shift();
-	if (name === void 0) fail(fileName, line, "serve: needs the name of a server registered in specification.cli()");
-	if (name.includes("=")) fail(fileName, line, `serve: "${name}" is a KEY=value pair — the server NAME comes first`);
-	const env = {};
-	for (const part of parts) {
-		const separator = part.indexOf("=");
-		if (separator <= 0) fail(fileName, line, `serve: "${part}" is not a KEY=value pair`);
-		env[part.slice(0, separator)] = part.slice(separator + 1);
-	}
-	return {
-		env,
-		line,
-		name
-	};
-}
+import { basename, dirname, resolve } from "node:path";
+//#region src/core/specification/shared/fixtures.ts
 /**
-* Parse the header: every line up to the first blank one. `#` lines are
-* comments; `test:`, `given:` and `then:` are mandatory and single; `fixture:`,
-* `env:` and `serve:` repeat and keep their declaration order.
+* Fixture path resolution + copy semantics for the `cli` facet's `.fixture()`.
+*
+* A fixture path is one of two shapes:
+*
+*  - `$FIXTURES/<rest>` — the shared pool at `<specs-root>/fixtures/<rest>`,
+*    where `<specs-root>` is the nearest ancestor directory named `specs`.
+*  - `<path>` (no marker) — feature-local, at `<test-dir>/fixtures/<path>`.
+*
+* Any other `$`-prefixed marker is a usage error (listed against the known
+* markers). Copy semantics mirror rsync's trailing-slash rule (see
+* {@link copyPlan}).
 */
-function parseHeader(lines, fileName) {
-	const fixtures = [];
-	const env = [];
-	const serve = [];
-	const singles = /* @__PURE__ */ new Map();
-	let index = 0;
-	for (; index < lines.length; index++) {
-		const raw = lines[index];
-		if (raw.trim() === "") break;
-		const number = index + 1;
-		if (raw.trimStart().startsWith("#")) continue;
-		if (isBlockStart(raw)) fail(fileName, number, "a \"$\" block starts before the header is closed — separate the header from the blocks with a blank line");
-		const found = HEADER_LINE.exec(raw);
-		if (!found?.groups) fail(fileName, number, `"${raw}" is not a header line — expected "<key>: <value>" (keys: ${HEADER_KEYS.join(", ")})`);
-		const key = found.groups.key;
-		const value = found.groups.value.trim();
-		if (!KEY_SET.has(key)) fail(fileName, number, `unknown header key "${key}:" — known keys: ${HEADER_KEYS.join(", ")}`);
-		if (key === "fixture" || key === "env" || key === "serve") {
-			if (value.length === 0) fail(fileName, number, `${key}: is empty`);
-			if (key === "fixture") fixtures.push(value);
-			else if (key === "env") env.push(...parseEnvTokens(value, fileName, number));
-			else serve.push(parseServeEntry(value, fileName, number));
-			continue;
-		}
-		if (singles.has(key)) fail(fileName, number, `${key}: is declared twice — it takes exactly one line`);
-		if (value.length === 0) fail(fileName, number, `${key}: is empty`);
-		singles.set(key, value);
+/**
+* Markers understood in a `.fixture()` path. Extend here + in
+* {@link resolveFixtureSource}. Exported so the lint layer (rule
+* `jterrazz/b2-known-fixture-marker`) validates literals against the same list.
+*/
+const KNOWN_FIXTURE_MARKERS = ["$FIXTURES"];
+/**
+* Walk up from `startDir` to the nearest ancestor directory named `specs`.
+* Throws with guidance if none is found up to the filesystem root — the
+* `$FIXTURES` marker is meaningless without a specs root.
+*/
+function discoverSpecsRoot(startDir) {
+	let dir = startDir;
+	for (;;) {
+		if (basename(dir) === "specs") return dir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
 	}
-	for (const key of [
-		"test",
-		"given",
-		"then"
-	]) if (!singles.has(key)) fail(fileName, 1, `missing "${key}:" in the header — test, given and then are mandatory`, "narrative");
-	const header = {
-		env,
-		fixtures,
-		given: singles.get("given"),
-		serve,
-		test: singles.get("test"),
-		then: singles.get("then")
-	};
-	return {
-		end: index,
-		header
-	};
+	throw new Error(`.fixture(): the $FIXTURES marker resolves to <specs-root>/fixtures, but no directory named "specs" was found walking up from ${startDir}. Move the specification under a specs/ directory, or use a feature-local fixtures/ path (no $FIXTURES marker).`);
 }
 /**
-* Split a block's stream section at `--- stderr`, dropping the ONE blank line
-* that separates the block from the next `$` (that line belongs to the
-* separator, not to the stream).
+* Resolve the absolute source path of a fixture, applying marker resolution.
+* The trailing slash (spread semantics) is preserved by callers via
+* {@link copyPlan} — it is irrelevant to source resolution.
 */
-function parseStreams(section, trailingSeparator) {
-	const lines = [...section];
-	if (trailingSeparator && lines.at(-1) === "") lines.pop();
-	const marker = lines.indexOf(STDERR_MARKER);
-	if (marker === -1) return {
-		stderr: null,
-		stdout: lines.join("\n")
-	};
-	return {
-		stderr: lines.slice(marker + 1).join("\n"),
-		stdout: lines.slice(0, marker).join("\n")
-	};
-}
-/** Parse the blocks: everything after the header's blank line. */
-function parseBlocks(lines, start, fileName) {
-	const starts = [];
-	for (let index = start; index < lines.length; index++) if (isBlockStart(lines[index])) starts.push(index);
-	if (starts.length === 0) fail(fileName, start + 1, "no \"$ <command>\" block — a literate spec runs at least one command");
-	for (let index = start; index < starts[0]; index++) if (lines[index].trim() !== "") fail(fileName, index + 1, `"${lines[index]}" sits outside a block — the first line after the header must be "$ <command>"`);
-	return starts.map((blockStart, position) => {
-		const next = starts[position + 1] ?? lines.length;
-		const argv = lines[blockStart].slice(1).trim();
-		const exitLine = lines[blockStart + 1];
-		const exit = exitLine === void 0 ? null : EXIT_LINE.exec(exitLine);
-		if (!exit?.groups) fail(fileName, blockStart + 2, `the line after "$ ${argv}" must be "exit: <integer>", got ${exitLine === void 0 ? "(end of file)" : `"${exitLine}"`}`);
-		const streams = parseStreams(lines.slice(blockStart + 2, next), position + 1 < starts.length);
-		return {
-			argv,
-			exitCode: Number(exit.groups.code),
-			line: blockStart + 1,
-			stderr: streams.stderr,
-			stdout: streams.stdout
-		};
-	});
+function resolveFixtureSource(path, testDir) {
+	const clean = path.replace(/\/+$/, "");
+	if (clean === "$FIXTURES" || path.startsWith("$FIXTURES/")) {
+		const rest = clean.slice(9).replace(/^\/+/, "");
+		return resolve(discoverSpecsRoot(testDir), "fixtures", rest);
+	}
+	if (path.startsWith("$")) {
+		const marker = clean.split("/")[0];
+		throw new Error(`.fixture("${path}"): unknown marker "${marker}". Known markers: ${KNOWN_FIXTURE_MARKERS.join(", ")}. A path without a marker is feature-local (resolved under <test-dir>/fixtures/).`);
+	}
+	return resolve(testDir, "fixtures", clean);
 }
 /**
-* Parse a `<case>.cli` file. `fileName` is used verbatim in error messages, so
-* pass the path the reader would open (`specs/cli/no-estate.cli`).
+* Compute the source + destination for copying a fixture into the working
+* directory. Copy semantics follow rsync's trailing-slash rule:
+*
+*  - `dir/` (trailing slash) — the CONTENTS are spread into the cwd.
+*  - `dir`  (no slash, a directory) — the directory is copied as `<cwd>/<basename>`.
+*  - `file` — copied as `<cwd>/<basename>`.
+*
+* Chained `.fixture()` calls layer in order: a later fixture overwrites files
+* written by an earlier one.
 */
-function parseLiterateFile(content, fileName) {
-	const lines = content.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
-	const { end, header } = parseHeader(lines, fileName);
+function copyPlan(path, testDir, workDir) {
+	const src = resolveFixtureSource(path, testDir);
 	return {
-		blocks: parseBlocks(lines, end + 1, fileName),
-		header,
-		headerText: `${lines.slice(0, end).join("\n")}\n`
+		dest: /\/+$/.test(path) ? workDir : resolve(workDir, basename(src)),
+		src
 	};
 }
-/** Render one block back to its source form (the update-mode inverse of the parser). */
-function serializeLiterateBlock(block) {
-	const lines = [`$ ${block.argv}`.trimEnd(), `exit: ${block.exitCode}`];
-	if (block.stdout.length > 0) lines.push(block.stdout);
-	if (block.stderr !== null && block.stderr.length > 0) lines.push(STDERR_MARKER, block.stderr);
-	return lines.join("\n");
-}
-/**
-* Rebuild a `.cli` file from its VERBATIM header text and a fresh set of
-* blocks. Update mode rewrites only what follows each `$` — the header comes
-* back byte-identical, comments and all.
-*/
-function serializeLiterateFile(headerText, blocks) {
-	return `${headerText}\n${blocks.map((block) => serializeLiterateBlock(block)).join("\n\n")}\n`;
-}
 //#endregion
 //#region src/core/matching/match.ts
 /** Every kind usable as a `{{token}}` in fixture files (all but ref/regex/includes). */
@@ -353,4 +233,4 @@ var CaptureScope = class {
 	}
 };
 //#endregion
-export { LiterateSyntaxError as a, match as i, Matcher as n, parseLiterateFile as o, TOKEN_KINDS as r, serializeLiterateFile as s, CaptureScope as t };
+export { copyPlan as a, match as i, Matcher as n, resolveFixtureSource as o, TOKEN_KINDS as r, CaptureScope as t };

package/dist/oxlint.cjs

@@ -306,7 +306,7 @@ const RULE_DOCS = {
 	},
 	"b4-given-then": {
 		channel: "statique",
-		convention: "Chaque test contient `// Given -` puis `// Then -` (les deux, dans cet ordre) ; Given déclaré après Then est une erreur. Dans un spec littéraire `<cas>.cli`, les deux marqueurs sont les lignes `given:` et `then:` de l’en-tête (passe checker `b4-cli-header`).",
+		convention: "Chaque test contient `// Given -` puis `// Then -` (les deux, dans cet ordre) ; Given déclaré après Then est une erreur. Un document `<cas>.spec.yaml` n’a pas de commentaires : sa narration est sa `description:`.",
 		family: "B",
 		id: "B4",
 		rationale: "La narration Given/Then rend l’intention du test lisible sans lire les assertions."
@@ -567,7 +567,7 @@ const RULE_DOCS = {
 const CHECKER_PASSES = [
 	{
 		channel: "checker",
-		convention: "Tout `{{token}}` dans une fixture `expected/` — ou dans les blocs d’un spec littéraire `<cas>.cli` — appartient au vocabulaire figé ; un token inconnu est une erreur.",
+		convention: "Tout `{{token}}` dans une fixture `expected/` — ou dans un flux attendu d’un document `<cas>.spec.yaml` — appartient au vocabulaire figé ; un token inconnu est une erreur.",
 		family: "D",
 		id: "D4",
 		name: "d4-unknown-token",
@@ -591,19 +591,91 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "Un spec littéraire `<cas>.cli` respecte sa grammaire : clés d’en-tête fermées (`test`, `given`, `then`, `fixture`, `env`, `serve`), première ligne de corps en `$ <commande>`, `exit: <entier>` juste après.",
+		convention: "Un document `<cas>.spec.yaml` respecte sa grammaire : clés fermées au niveau du document (`kind`, `description`, `fixture`, `env`, `serve`, `runs`) comme dans un run (`command`, `stdin`, `timeout`, `waitFor`, `exit`, `stdout`, `stderr`, `files`), `description:` et `runs:` obligatoires, `command:` et `exit:` obligatoires dans chaque run, `exit:` entier littéral, `waitFor:` seulement sur le dernier run et jamais avec `stdin:`, chemin `files:` relatif et sous le workdir.",
 		family: "D",
 		id: "D4b",
-		name: "d4b-cli-shape",
-		rationale: "La grammaire est lue par le parseur du runner lui-même : le fichier que le lint accepte est exactement celui que le runner exécute."
+		name: "d4b-spec-shape",
+		rationale: "La grammaire est lue par le parseur du runner lui-même : le document que le lint accepte est exactement celui que le runner exécute."
 	},
 	{
 		channel: "checker",
-		convention: "Un spec littéraire `<cas>.cli` porte les trois lignes narratives `test:`, `given:` et `then:` ; il en manque une est une erreur.",
-		family: "B",
-		id: "B4",
-		name: "b4-cli-header",
-		rationale: "Le format littéraire est un test : la narration Given/Then y vit dans l’en-tête, pas dans des commentaires."
+		convention: "Les clés d’un `<cas>.spec.yaml` suivent l’ordre canonique — `kind, description, fixture, env, serve, runs` au niveau du document, `command, stdin, timeout, waitFor, exit, stdout, stderr, files` dans un run. Corrigeable (`--fix`).",
+		family: "D",
+		id: "D4b",
+		name: "d4b-spec-key-order",
+		rationale: "Le décor avant la session, l’entrée avant la sortie : un ordre unique rend les documents comparables et supprime les diffs qui ne changent rien."
+	},
+	{
+		channel: "checker",
+		convention: "`stdout`, `stderr`, `stdin` et `files.*.equals` d’un `<cas>.spec.yaml` s’écrivent en scalaire bloc (`|` garde le saut de ligne final, `|-` le supprime), jamais en chaîne entre guillemets avec des `\\n`. Corrigeable (`--fix`).",
+		family: "D",
+		id: "D4b",
+		name: "d4b-spec-block-scalar",
+		rationale: "Une sortie attendue doit ressembler à une sortie — une golden sur une ligne est illisible et aucun diff ne peut la montrer."
+	},
+	{
+		channel: "checker",
+		convention: "Un document se nomme `<cas>.spec.yaml` : `<cas>` en kebab-case, sans les mots `test`/`spec`/`cli` que le suffixe porte déjà, et jamais le nom nu de son dossier.",
+		family: "C",
+		id: "C12",
+		name: "c12-spec-file-name",
+		rationale: "Le nom du fichier est la première phrase que le lecteur lit ; `rm/rm.spec.yaml` ne dit rien deux fois."
+	},
+	{
+		channel: "checker",
+		convention: "La `description:` d’un document est un titre : une seule ligne, initiale minuscule (identifiant tout en majuscules exempté), sans point final, moins de 100 caractères.",
+		family: "J",
+		id: "J5",
+		name: "j5-spec-description",
+		rationale: "La description EST le titre vitest — les règles du titre s’y appliquent, pas celles d’un paragraphe."
+	},
+	{
+		channel: "checker",
+		convention: "Deux `<cas>.spec.yaml` d’un même dossier ne partagent pas leur `description:`.",
+		family: "J",
+		id: "J4",
+		name: "j4-spec-description-unique",
+		rationale: "Le rapporteur nomme le titre : deux titres identiques laissent deux fichiers à ouvrir."
+	},
+	{
+		channel: "checker",
+		convention: "Un flux attendu ne contient pas de valeur volatile littérale : origine loopback avec port (`127.0.0.1:8080`, `localhost:3000`), chemin temporaire absolu (`/tmp/`, `/private/tmp/`, `/var/folders/`) ou chemin home (`/Users/…`, `/home/…`). Le message nomme le token à écrire.",
+		family: "D",
+		id: "D5",
+		name: "d5-spec-volatile-literal",
+		rationale: "C’est exactement la forme qu’un `TEST_UPDATE` aurait tokenisée : en trouver une signifie qu’un token a été écrasé à la main."
+	},
+	{
+		channel: "checker",
+		convention: "Un horodatage ISO-8601 ou un uuid littéral dans un flux attendu → warning, sauf si la même valeur apparaît dans un `fixture:` ou un `stdin:` du même document (elle est alors fixée, pas volatile).",
+		family: "D",
+		id: "D5",
+		name: "d5w-spec-pinned-value",
+		rationale: "Le défaut n’est pas le littéral : c’est le littéral que rien n’a fixé."
+	},
+	{
+		channel: "checker",
+		convention: "Un flux attendu dont tout le contenu est `{{any}}` → warning : le run s’exécute et ne prouve rien.",
+		family: "J",
+		id: "J3",
+		name: "j3w-spec-empty-assertion",
+		rationale: "Le miroir de J3 pour les documents — une assertion qui accepte tout est une assertion absente."
+	},
+	{
+		channel: "checker",
+		convention: "Un run dont `exit:` est non nul sans `stdout:` ni `stderr:` → warning : le document ne dit pas pourquoi la commande a refusé.",
+		family: "D",
+		id: "D11",
+		name: "d11w-spec-silent-refusal",
+		rationale: "Un refus muet est soit un défaut du produit, soit une golden qui a oublié que les mots partaient sur stderr."
+	},
+	{
+		channel: "checker",
+		convention: "Les mots nus d’`env:` et les noms de `serve:` d’un document sont des clés des objets `env`/`serve` d’un `specification.cli(…)` du plus proche dossier portant des `*.specification.ts` (lecture statique des littéraux ; ignoré sinon).",
+		family: "C",
+		id: "C8",
+		name: "c8-spec-registered-name",
+		rationale: "Une faute de frappe (`serve: dashbord`) échoue aujourd’hui à l’exécution, un fichier de test plus tard ; ici c’est une ligne de lint."
 	},
 	{
 		channel: "checker",
@@ -615,7 +687,7 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		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` ni `*.cli` est orphelin (warning si argument non littéral). Un `<cas>.cli` référence les fixtures nommées par ses lignes `fixture:`.",
+		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` ni `*.spec.yaml` est orphelin (warning si argument non littéral). Un `<cas>.spec.yaml` référence les fixtures nommées par ses entrées `fixture:`.",
 		family: "C",
 		id: "C9",
 		name: "c9-dead-fixtures",

package/dist/oxlint.js

@@ -302,7 +302,7 @@ const RULE_DOCS = {
 	},
 	"b4-given-then": {
 		channel: "statique",
-		convention: "Chaque test contient `// Given -` puis `// Then -` (les deux, dans cet ordre) ; Given déclaré après Then est une erreur. Dans un spec littéraire `<cas>.cli`, les deux marqueurs sont les lignes `given:` et `then:` de l’en-tête (passe checker `b4-cli-header`).",
+		convention: "Chaque test contient `// Given -` puis `// Then -` (les deux, dans cet ordre) ; Given déclaré après Then est une erreur. Un document `<cas>.spec.yaml` n’a pas de commentaires : sa narration est sa `description:`.",
 		family: "B",
 		id: "B4",
 		rationale: "La narration Given/Then rend l’intention du test lisible sans lire les assertions."
@@ -563,7 +563,7 @@ const RULE_DOCS = {
 const CHECKER_PASSES = [
 	{
 		channel: "checker",
-		convention: "Tout `{{token}}` dans une fixture `expected/` — ou dans les blocs d’un spec littéraire `<cas>.cli` — appartient au vocabulaire figé ; un token inconnu est une erreur.",
+		convention: "Tout `{{token}}` dans une fixture `expected/` — ou dans un flux attendu d’un document `<cas>.spec.yaml` — appartient au vocabulaire figé ; un token inconnu est une erreur.",
 		family: "D",
 		id: "D4",
 		name: "d4-unknown-token",
@@ -587,19 +587,91 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "Un spec littéraire `<cas>.cli` respecte sa grammaire : clés d’en-tête fermées (`test`, `given`, `then`, `fixture`, `env`, `serve`), première ligne de corps en `$ <commande>`, `exit: <entier>` juste après.",
+		convention: "Un document `<cas>.spec.yaml` respecte sa grammaire : clés fermées au niveau du document (`kind`, `description`, `fixture`, `env`, `serve`, `runs`) comme dans un run (`command`, `stdin`, `timeout`, `waitFor`, `exit`, `stdout`, `stderr`, `files`), `description:` et `runs:` obligatoires, `command:` et `exit:` obligatoires dans chaque run, `exit:` entier littéral, `waitFor:` seulement sur le dernier run et jamais avec `stdin:`, chemin `files:` relatif et sous le workdir.",
 		family: "D",
 		id: "D4b",
-		name: "d4b-cli-shape",
-		rationale: "La grammaire est lue par le parseur du runner lui-même : le fichier que le lint accepte est exactement celui que le runner exécute."
+		name: "d4b-spec-shape",
+		rationale: "La grammaire est lue par le parseur du runner lui-même : le document que le lint accepte est exactement celui que le runner exécute."
 	},
 	{
 		channel: "checker",
-		convention: "Un spec littéraire `<cas>.cli` porte les trois lignes narratives `test:`, `given:` et `then:` ; il en manque une est une erreur.",
-		family: "B",
-		id: "B4",
-		name: "b4-cli-header",
-		rationale: "Le format littéraire est un test : la narration Given/Then y vit dans l’en-tête, pas dans des commentaires."
+		convention: "Les clés d’un `<cas>.spec.yaml` suivent l’ordre canonique — `kind, description, fixture, env, serve, runs` au niveau du document, `command, stdin, timeout, waitFor, exit, stdout, stderr, files` dans un run. Corrigeable (`--fix`).",
+		family: "D",
+		id: "D4b",
+		name: "d4b-spec-key-order",
+		rationale: "Le décor avant la session, l’entrée avant la sortie : un ordre unique rend les documents comparables et supprime les diffs qui ne changent rien."
+	},
+	{
+		channel: "checker",
+		convention: "`stdout`, `stderr`, `stdin` et `files.*.equals` d’un `<cas>.spec.yaml` s’écrivent en scalaire bloc (`|` garde le saut de ligne final, `|-` le supprime), jamais en chaîne entre guillemets avec des `\\n`. Corrigeable (`--fix`).",
+		family: "D",
+		id: "D4b",
+		name: "d4b-spec-block-scalar",
+		rationale: "Une sortie attendue doit ressembler à une sortie — une golden sur une ligne est illisible et aucun diff ne peut la montrer."
+	},
+	{
+		channel: "checker",
+		convention: "Un document se nomme `<cas>.spec.yaml` : `<cas>` en kebab-case, sans les mots `test`/`spec`/`cli` que le suffixe porte déjà, et jamais le nom nu de son dossier.",
+		family: "C",
+		id: "C12",
+		name: "c12-spec-file-name",
+		rationale: "Le nom du fichier est la première phrase que le lecteur lit ; `rm/rm.spec.yaml` ne dit rien deux fois."
+	},
+	{
+		channel: "checker",
+		convention: "La `description:` d’un document est un titre : une seule ligne, initiale minuscule (identifiant tout en majuscules exempté), sans point final, moins de 100 caractères.",
+		family: "J",
+		id: "J5",
+		name: "j5-spec-description",
+		rationale: "La description EST le titre vitest — les règles du titre s’y appliquent, pas celles d’un paragraphe."
+	},
+	{
+		channel: "checker",
+		convention: "Deux `<cas>.spec.yaml` d’un même dossier ne partagent pas leur `description:`.",
+		family: "J",
+		id: "J4",
+		name: "j4-spec-description-unique",
+		rationale: "Le rapporteur nomme le titre : deux titres identiques laissent deux fichiers à ouvrir."
+	},
+	{
+		channel: "checker",
+		convention: "Un flux attendu ne contient pas de valeur volatile littérale : origine loopback avec port (`127.0.0.1:8080`, `localhost:3000`), chemin temporaire absolu (`/tmp/`, `/private/tmp/`, `/var/folders/`) ou chemin home (`/Users/…`, `/home/…`). Le message nomme le token à écrire.",
+		family: "D",
+		id: "D5",
+		name: "d5-spec-volatile-literal",
+		rationale: "C’est exactement la forme qu’un `TEST_UPDATE` aurait tokenisée : en trouver une signifie qu’un token a été écrasé à la main."
+	},
+	{
+		channel: "checker",
+		convention: "Un horodatage ISO-8601 ou un uuid littéral dans un flux attendu → warning, sauf si la même valeur apparaît dans un `fixture:` ou un `stdin:` du même document (elle est alors fixée, pas volatile).",
+		family: "D",
+		id: "D5",
+		name: "d5w-spec-pinned-value",
+		rationale: "Le défaut n’est pas le littéral : c’est le littéral que rien n’a fixé."
+	},
+	{
+		channel: "checker",
+		convention: "Un flux attendu dont tout le contenu est `{{any}}` → warning : le run s’exécute et ne prouve rien.",
+		family: "J",
+		id: "J3",
+		name: "j3w-spec-empty-assertion",
+		rationale: "Le miroir de J3 pour les documents — une assertion qui accepte tout est une assertion absente."
+	},
+	{
+		channel: "checker",
+		convention: "Un run dont `exit:` est non nul sans `stdout:` ni `stderr:` → warning : le document ne dit pas pourquoi la commande a refusé.",
+		family: "D",
+		id: "D11",
+		name: "d11w-spec-silent-refusal",
+		rationale: "Un refus muet est soit un défaut du produit, soit une golden qui a oublié que les mots partaient sur stderr."
+	},
+	{
+		channel: "checker",
+		convention: "Les mots nus d’`env:` et les noms de `serve:` d’un document sont des clés des objets `env`/`serve` d’un `specification.cli(…)` du plus proche dossier portant des `*.specification.ts` (lecture statique des littéraux ; ignoré sinon).",
+		family: "C",
+		id: "C8",
+		name: "c8-spec-registered-name",
+		rationale: "Une faute de frappe (`serve: dashbord`) échoue aujourd’hui à l’exécution, un fichier de test plus tard ; ici c’est une ligne de lint."
 	},
 	{
 		channel: "checker",
@@ -611,7 +683,7 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		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` ni `*.cli` est orphelin (warning si argument non littéral). Un `<cas>.cli` référence les fixtures nommées par ses lignes `fixture:`.",
+		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` ni `*.spec.yaml` est orphelin (warning si argument non littéral). Un `<cas>.spec.yaml` référence les fixtures nommées par ses entrées `fixture:`.",
 		family: "C",
 		id: "C9",
 		name: "c9-dead-fixtures",

package/dist/queue.js

@@ -1,5 +1,5 @@
 import { t as CaptureScope } from "./match.js";
-import { F as textEquals, O as hasPlaceholders, j as placeholderPatternSource } from "./literate.js";
+import { A as placeholderPatternSource, D as hasPlaceholders, P as textEquals } from "./literate.js";
 //#region src/core/contracts/contract.ts
 /**
 * Declare one contract. Identity function — its value is the enforced shape