@jterrazz/test 14.0.0 → 14.0.1

package/dist/index.d.ts

@@ -948,8 +948,9 @@ declare class HttpResult extends BaseResult {
  * for each run, {@link ServeAdapter} for `serve:`, the `{{token}}` engine for
  * every comparison, and {@link mergeTextPreservingPlaceholders} for the
  * rewrite. What is new here is only the ORCHESTRATION the chain cannot express:
- * several commands sharing one working directory, each asserted, none stopping
- * the run.
+ * several commands sharing one working directory, each judged the moment it
+ * ends — so what a run states about that directory is what IT left there, and
+ * the first run to disagree is the one the failure names.
  */
 /**
  * A server a document may start by name (`serve: mcp`), registered once per app

package/dist/literate.js

@@ -1547,7 +1547,11 @@ function atLine(error, filePath, line) {
 	error.stack = `${error.name}: ${error.message}\n    at ${filePath}:${line}:1`;
 	return error;
 }
-/** Compare one run against what the command actually did. */
+/**
+* Compare one run against what the command actually did — its exit code, its
+* streams and its `files:`, all read at the same instant: the moment that
+* command returned.
+*/
 function assertRun(document, outcome, context, workDir, scope) {
 	const { actual, run } = outcome;
 	if (actual.exitCode !== run.exitCode) throw failure(document, run, context, [[
@@ -1682,9 +1686,9 @@ async function runSpecDocument(options) {
 		...servers.env,
 		...documentEnv(document, config, displayPath)
 	}, workDir);
-	let outcomes;
+	const rewriting = shouldUpdateSnapshots() && options.frozen !== true;
+	const outcomes = [];
 	try {
-		outcomes = [];
 		for (const run of document.runs) {
 			const actual = run.waitFor === null ? await config.command.exec(run.command, workDir, env, {
 				stdin: run.stdin ?? void 0,
@@ -1693,21 +1697,22 @@ async function runSpecDocument(options) {
 				timeout: run.timeout ?? void 0,
 				waitFor: run.waitFor
 			}, env);
-			outcomes.push({
+			const outcome = {
 				actual,
 				run,
 				stderr: comparable(actual.stderr, config.transform),
 				stdout: comparable(actual.stdout, config.transform)
-			});
+			};
+			outcomes.push(outcome);
+			if (!rewriting) assertRun(document, outcome, {
+				displayPath,
+				filePath
+			}, workDir, scope);
 		}
 	} finally {
 		await servers.stop();
 	}
-	if (shouldUpdateSnapshots() && options.frozen !== true) writeFileSync(filePath, updateSpecFile(file, updates(outcomes, scope)));
-	else for (const outcome of outcomes) assertRun(document, outcome, {
-		displayPath,
-		filePath
-	}, workDir, scope);
+	if (rewriting) writeFileSync(filePath, updateSpecFile(file, updates(outcomes, scope)));
 	return new CliResult({
 		commandOutput: outcomes.at(-1).actual,
 		config,

package/dist/oxlint.cjs

@@ -341,7 +341,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.",
+		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.",
 		family: "C",
 		id: "C1",
 		rationale: "Une profondeur fixe rend la place de chaque fichier prévisible et détectable statiquement."
@@ -1604,6 +1604,14 @@ const TEST_SUFFIX = ".test.ts";
 const SPECIFICATION_SUFFIX = ".specification.ts";
 const DEFAULT_DEPTH = "facet-domain";
 /**
+* Whether a file is the unit test of the module it sits beside — `x.test.ts`
+* next to `x.ts`, which is the whole of I2's pairing. This is what tells a
+* ground MODULE's test from a spec that wandered into the ground.
+*/
+function testsItsNeighbour(filename) {
+	return filename.endsWith(TEST_SUFFIX) && isFile(`${filename.slice(0, -8)}.ts`);
+}
+/**
 * CONVENTIONS C1' — the shape of a spec tree, DECLARED by the consumer.
 *
 * A project states which shape its `specs/` tree has; the rule checks that one.
@@ -1649,9 +1657,15 @@ const DEFAULT_DEPTH = "facet-domain";
 *
 * The ground clause holds in every mode, `off` included: a directory whose name
 * carries a LEADING UNDERSCORE is ground — what the specs of a row stand on —
-* and never a domain, so no spec may live inside one. That is not a question of
+* and never a domain, so no SPEC may live inside one. That is not a question of
 * depth, which is why no project's declared shape switches it off.
 *
+* Ground is not always inert, though: it may be CODE the specs stand on — the
+* build of the subject under test, a harness the runner spawns. A `<module>.ts`
+* there keeps its own unit test under I2's law, `<module>.test.ts` NEXT to it,
+* and the clause lets that one pair through. Nothing else: a test with no module
+* beside it, or a `*.specification.ts`, is a spec that wandered into the ground.
+*
 * Module tests under `src/` follow the neighbour rule (I2) and are out of scope
 * in every mode.
 */
@@ -1666,7 +1680,7 @@ const c1DomainStructure = {
 			if (base.endsWith(TEST_SUFFIX) || base.endsWith(SPECIFICATION_SUFFIX)) {
 				const ground = anchor.relative.slice(0, -1).find((segment) => segment.startsWith("_"));
 				if (ground !== void 0) {
-					context.report({
+					if (!testsItsNeighbour(context.filename)) context.report({
 						data: { ground },
 						messageId: "specInGround",
 						node
@@ -1733,7 +1747,7 @@ const c1DomainStructure = {
 		defaultOptions: [{ depth: DEFAULT_DEPTH }],
 		docs: RULE_DOCS["c1-domain-structure"],
 		messages: {
-			specInGround: "A spec must not live under \"{{ground}}/\" — a leading underscore marks GROUND (what the specs of a row stand on: _fixtures/, _expected/, _requests/, _seeds/), never a domain (C1 — see docs/10-linting.md).",
+			specInGround: "A spec must not live under \"{{ground}}/\" — a leading underscore marks GROUND (what the specs of a row stand on: _fixtures/, _expected/, _requests/, _seeds/), never a domain (C1 — see docs/10-linting.md). Ground that is CODE keeps its own unit test: `<module>.test.ts` NEXT to the `<module>.ts` it tests (I2), and nothing else.",
 			specNotAtFacetRoot: "A `*.specification.ts` must sit at the facet root: `specs/<facet>/<name>.specification.ts` (C1 — see docs/10-linting.md).",
 			testAtFacetRoot: "A `*.test.ts` must live in a domain folder: `specs/<facet>/<domain>/<aspect>.test.ts` — tests directly at the facet root are forbidden (C1 — see docs/10-linting.md).",
 			testAtSpecsRoot: "A `*.test.ts` must live in a directory under specs/ — with `depth: \"mirror\"` the tree mirrors a structure, and the specs root mirrors nothing (C1 — see docs/10-linting.md).",

package/dist/oxlint.js

@@ -337,7 +337,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.",
+		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.",
 		family: "C",
 		id: "C1",
 		rationale: "Une profondeur fixe rend la place de chaque fichier prévisible et détectable statiquement."
@@ -1600,6 +1600,14 @@ const TEST_SUFFIX = ".test.ts";
 const SPECIFICATION_SUFFIX = ".specification.ts";
 const DEFAULT_DEPTH = "facet-domain";
 /**
+* Whether a file is the unit test of the module it sits beside — `x.test.ts`
+* next to `x.ts`, which is the whole of I2's pairing. This is what tells a
+* ground MODULE's test from a spec that wandered into the ground.
+*/
+function testsItsNeighbour(filename) {
+	return filename.endsWith(TEST_SUFFIX) && isFile(`${filename.slice(0, -8)}.ts`);
+}
+/**
 * CONVENTIONS C1' — the shape of a spec tree, DECLARED by the consumer.
 *
 * A project states which shape its `specs/` tree has; the rule checks that one.
@@ -1645,9 +1653,15 @@ const DEFAULT_DEPTH = "facet-domain";
 *
 * The ground clause holds in every mode, `off` included: a directory whose name
 * carries a LEADING UNDERSCORE is ground — what the specs of a row stand on —
-* and never a domain, so no spec may live inside one. That is not a question of
+* and never a domain, so no SPEC may live inside one. That is not a question of
 * depth, which is why no project's declared shape switches it off.
 *
+* Ground is not always inert, though: it may be CODE the specs stand on — the
+* build of the subject under test, a harness the runner spawns. A `<module>.ts`
+* there keeps its own unit test under I2's law, `<module>.test.ts` NEXT to it,
+* and the clause lets that one pair through. Nothing else: a test with no module
+* beside it, or a `*.specification.ts`, is a spec that wandered into the ground.
+*
 * Module tests under `src/` follow the neighbour rule (I2) and are out of scope
 * in every mode.
 */
@@ -1662,7 +1676,7 @@ const c1DomainStructure = {
 			if (base.endsWith(TEST_SUFFIX) || base.endsWith(SPECIFICATION_SUFFIX)) {
 				const ground = anchor.relative.slice(0, -1).find((segment) => segment.startsWith("_"));
 				if (ground !== void 0) {
-					context.report({
+					if (!testsItsNeighbour(context.filename)) context.report({
 						data: { ground },
 						messageId: "specInGround",
 						node
@@ -1729,7 +1743,7 @@ const c1DomainStructure = {
 		defaultOptions: [{ depth: DEFAULT_DEPTH }],
 		docs: RULE_DOCS["c1-domain-structure"],
 		messages: {
-			specInGround: "A spec must not live under \"{{ground}}/\" — a leading underscore marks GROUND (what the specs of a row stand on: _fixtures/, _expected/, _requests/, _seeds/), never a domain (C1 — see docs/10-linting.md).",
+			specInGround: "A spec must not live under \"{{ground}}/\" — a leading underscore marks GROUND (what the specs of a row stand on: _fixtures/, _expected/, _requests/, _seeds/), never a domain (C1 — see docs/10-linting.md). Ground that is CODE keeps its own unit test: `<module>.test.ts` NEXT to the `<module>.ts` it tests (I2), and nothing else.",
 			specNotAtFacetRoot: "A `*.specification.ts` must sit at the facet root: `specs/<facet>/<name>.specification.ts` (C1 — see docs/10-linting.md).",
 			testAtFacetRoot: "A `*.test.ts` must live in a domain folder: `specs/<facet>/<domain>/<aspect>.test.ts` — tests directly at the facet root are forbidden (C1 — see docs/10-linting.md).",
 			testAtSpecsRoot: "A `*.test.ts` must live in a directory under specs/ — with `depth: \"mirror\"` the tree mirrors a structure, and the specs root mirrors nothing (C1 — see docs/10-linting.md).",

package/dist/spec-document.js

@@ -1,4 +1,4 @@
-import { LineCounter, Scalar, Scalar as Scalar$1, isMap, isScalar, isSeq, parseDocument } from "yaml";
+import { LineCounter, Scalar, Scalar as Scalar$1, isMap, isScalar, isSeq, parseDocument, visit } from "yaml";
 //#region src/integrations/yaml/document.ts
 /** A line that opens a mapping key — `  key:` or `  - key:`, never block-scalar text. */
 const KEY_LINE = /^(?<indent> +)(?:- )?[A-Za-z_$'"][^\n]*:/;
@@ -65,7 +65,8 @@ function parseYamlSource(text) {
 			lineCounter
 		}),
 		indent: detectIndent(text),
-		lineAt: (offset) => lineCounter.linePos(offset).line
+		lineAt: (offset) => lineCounter.linePos(offset).line,
+		text
 	};
 }
 /** The YAML parser's own errors, with their line — an empty list when it parsed. */
@@ -88,16 +89,94 @@ function blockScalar(text) {
 	scalar.type = Scalar.BLOCK_LITERAL;
 	return scalar;
 }
+/** The first offset of the line `offset` sits on. */
+function lineStart(text, offset) {
+	return text.lastIndexOf("\n", offset - 1) + 1;
+}
+/** Back over the whitespace before `offset`, to just past the `:` or `-` that owns it. */
+function afterOwner(text, offset) {
+	let at = offset;
+	while (at > 0 && /\s/.test(text[at - 1])) at -= 1;
+	return at;
+}
+/** How many spaces a line opens with. */
+function indentOf(text, offset) {
+	const start = lineStart(text, offset);
+	return /^ */.exec(text.slice(start))[0].length;
+}
+/**
+* Every OUTERMOST flow collection of a document, in source order. A nested one
+* is part of its parent's text and is restored with it, so descending past a
+* flow collection would splice the same span twice.
+*/
+function flowCollections(text) {
+	const found = [];
+	const take = (node) => {
+		if (node.flow !== true || !node.range) return;
+		const from = afterOwner(text, node.range[0]);
+		found.push({
+			ownerIndent: indentOf(text, from === 0 ? 0 : from - 1),
+			range: [from, node.range[1]],
+			text: text.slice(from, node.range[1]),
+			value: JSON.stringify(node.toJSON())
+		});
+		return visit.SKIP;
+	};
+	visit(parseDocument(text), {
+		Map: (_key, node) => take(node),
+		Seq: (_key, node) => take(node)
+	});
+	return found;
+}
+/**
+* Give every flow collection the rewrite did not change back exactly as it was
+* written — padding, quotes and line breaks included.
+*
+* The `yaml` writer has ONE house style for `{ … }` and `[ … ]`, and it is not
+* the repository formatter's: oxfmt pads a flow mapping and not a flow sequence,
+* and explodes a long one over several lines, while the writer emits `[ 'a' ]`
+* on one line whatever its width. Re-emitting an untouched collection therefore
+* hands the formatter something to undo, and `check --fix` and `oxfmt` rewrite
+* each other for ever. A collection nobody touched belongs to its author, not to
+* either tool.
+*
+* A rendered collection is matched to a source one by VALUE and by the
+* INDENTATION of the line that owns it: the same content under the same key is
+* the same collection, and the indentation guard is what keeps the inner lines
+* of a multi-line spelling true where a fix moved that key. Anything unmatched
+* — added, removed, edited — keeps the writer's rendering.
+*/
+function restoreUntouchedFlow(rendered, text) {
+	const sources = flowCollections(text);
+	if (sources.length === 0) return rendered;
+	const taken = /* @__PURE__ */ new Set();
+	const splices = [];
+	for (const target of flowCollections(rendered)) {
+		const at = sources.findIndex((candidate, index) => !taken.has(index) && candidate.value === target.value && candidate.ownerIndent === target.ownerIndent);
+		if (at === -1) continue;
+		taken.add(at);
+		splices.push({
+			range: target.range,
+			text: sources[at].text
+		});
+	}
+	let out = rendered;
+	for (const splice of splices.toReversed()) out = out.slice(0, splice.range[0]) + splice.text + out.slice(splice.range[1]);
+	return out;
+}
 /**
 * Render a document back to text, in the indentation it was read with.
 * `lineWidth: 0` disables the folding of long lines — a golden is compared byte
 * for byte, so nothing may decide on its own where to break one.
+*
+* What the caller did not change comes back as it was written — see
+* {@link restoreUntouchedFlow} for the one construct the writer restyles.
 */
 function renderYamlSource(source) {
-	return source.document.toString({
+	return restoreUntouchedFlow(source.document.toString({
 		indent: source.indent,
 		lineWidth: 0
-	});
+	}), source.text);
 }
 //#endregion
 //#region src/core/literate/spec-document.ts

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/test",
-    "version": "14.0.0",
+    "version": "14.0.1",
     "description": "Declarative testing framework for HTTP APIs, CLIs, and background jobs — one entry point, real infrastructure, golden-file assertions, plus an oxlint convention plugin.",
     "keywords": [
         "api-testing",