@jterrazz/test 12.2.0 → 13.0.1

package/dist/spec-document.js

@@ -0,0 +1,536 @@
+import { LineCounter, Scalar, Scalar as Scalar$1, isMap, isScalar, isSeq, parseDocument } 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]*:/;
+/**
+* The indentation step the file was written with, read from the shallowest
+* mapping key it carries. A rewrite must come back in the author's style — a
+* formatter that indents by four and a writer that indents by two would fight
+* over every updated document. Two is YAML's own default, and the fallback.
+*/
+function detectIndent(text) {
+	let smallest = 0;
+	for (const line of text.split("\n")) {
+		const found = KEY_LINE.exec(line);
+		if (found?.groups && (smallest === 0 || found.groups.indent.length < smallest)) smallest = found.groups.indent.length;
+	}
+	return smallest === 0 ? 2 : smallest;
+}
+/** Parse a YAML file into its document form, keeping comments and key order. */
+function parseYamlSource(text) {
+	const lineCounter = new LineCounter();
+	return {
+		document: parseDocument(text, {
+			keepSourceTokens: true,
+			lineCounter
+		}),
+		indent: detectIndent(text),
+		lineAt: (offset) => lineCounter.linePos(offset).line
+	};
+}
+/** The YAML parser's own errors, with their line — an empty list when it parsed. */
+function yamlSyntaxErrors(source) {
+	return source.document.errors.map((error) => ({
+		line: error.linePos?.[0]?.line ?? source.lineAt(error.pos[0]),
+		message: error.message
+	}));
+}
+/**
+* A literal block scalar. The `yaml` writer picks the chomping indicator from
+* the value itself — `|` when the text ends with a newline, `|-` when it does
+* not — and adds the indentation indicator (`|2`) when the first line starts
+* with a space, which is exactly the byte-exactness the format promises.
+*/
+function blockScalar(text) {
+	const scalar = new Scalar(text);
+	scalar.type = Scalar.BLOCK_LITERAL;
+	return scalar;
+}
+/**
+* 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.
+*/
+function renderYamlSource(source) {
+	return source.document.toString({
+		indent: source.indent,
+		lineWidth: 0
+	});
+}
+//#endregion
+//#region src/core/literate/spec-document.ts
+/**
+* The `<case>.spec.yaml` document — one scenario, written as data.
+*
+* A spec document states the ground a session stands on (`fixture:`, `env:`,
+* `serve:`) and then the session itself (`runs:`), each run carrying its
+* command, its exit code, its streams and what it left on disk:
+*
+*     description: removes a post and names what is gone
+*     fixture: $FIXTURES/posts-stub/
+*     env:
+*       - frozen
+*     runs:
+*       - command: posts rm post-recap --yes
+*         exit: 0
+*         stdout: |
+*           Removed post-recap.
+*
+* This module owns the grammar and NOTHING else: it resolves no path, runs no
+* command, and knows no filesystem. It is read by the runner and by the lint
+* checker alike, so the document the lint accepts is exactly the document the
+* runner executes. The JSON Schema editors validate against is built from the
+* same constants, a few lines down — one vocabulary, three readers.
+*/
+/** The extension that makes a file a spec document. */
+const SPEC_EXTENSION = ".spec.yaml";
+/**
+* The facets a document may describe. `cli` is the only one implemented; the
+* key exists so a second facet can arrive without a second grammar.
+*/
+const SPEC_KINDS = ["cli"];
+/**
+* Top-level keys, IN THE ORDER a document is written in: what the session
+* stands on first, the session last. The order is the canonical one the
+* `d4b-spec-key-order` lint pass enforces and rewrites.
+*/
+const DOCUMENT_KEYS = [
+	"kind",
+	"description",
+	"fixture",
+	"env",
+	"serve",
+	"runs"
+];
+/** The keys of one run, in the canonical order: what is given, then what came back. */
+const RUN_KEYS = [
+	"command",
+	"stdin",
+	"timeout",
+	"waitFor",
+	"exit",
+	"stdout",
+	"stderr",
+	"files"
+];
+/** The keys of a `files:` content assertion. */
+const FILE_CONTENT_KEYS = ["contains", "equals"];
+/** The bare states a `files:` entry may name instead of a content assertion. */
+const FILE_STATES = ["absent", "exists"];
+/** A refusal from the grammar, carrying the line it happened on. */
+var SpecSyntaxError = class extends Error {
+	line;
+	constructor(fileName, line, message) {
+		super(`${fileName}:${line}: ${message}`);
+		this.line = line;
+		this.name = "SpecSyntaxError";
+	}
+};
+function fail(context, node, message) {
+	throw new SpecSyntaxError(context.fileName, lineOf(context, node), message);
+}
+function lineOf(context, node) {
+	const range = node === void 0 || node === null ? void 0 : nodeRange(node);
+	return range === void 0 ? 1 : context.source.lineAt(range[0]);
+}
+function nodeRange(node) {
+	if ("range" in node && Array.isArray(node.range)) return node.range;
+	const key = node.key;
+	return key !== null && typeof key === "object" && "range" in key ? key.range ?? void 0 : void 0;
+}
+/** The line a scalar's CONTENT starts on — one past the `|` for a block scalar. */
+function contentLine(context, node) {
+	const start = lineOf(context, node);
+	return isScalar(node) && String(node.type ?? "").startsWith("BLOCK") ? start + 1 : start;
+}
+function requireMap(context, node, what) {
+	if (!isMap(node)) fail(context, node ?? void 0, `${what} must be a mapping of keys to values`);
+	return node;
+}
+/** The pairs of a mapping, refusing any key outside the closed set. */
+function closedPairs(context, map, allowed, what) {
+	const pairs = [];
+	for (const pair of map.items) {
+		const key = scalarString(pair.key);
+		if (key === null) fail(context, pair, `${what}: a key must be a plain word`);
+		if (!allowed.includes(key)) fail(context, pair, `unknown key "${key}:" in ${what} — known keys: ${allowed.join(", ")}`);
+		if (pairs.some((seen) => scalarString(seen.key) === key)) fail(context, pair, `"${key}:" is declared twice in ${what}`);
+		pairs.push(pair);
+	}
+	return pairs;
+}
+function scalarString(node) {
+	return isScalar(node) && typeof node.value === "string" ? node.value : null;
+}
+function requireString(context, node, what) {
+	const value = scalarString(node);
+	if (value === null) fail(context, node, `${what} must be text`);
+	return value;
+}
+function requireInteger(context, node, what) {
+	if (!isScalar(node) || typeof node.value !== "number" || !Number.isInteger(node.value)) fail(context, node, `${what} must be a literal integer`);
+	return node.value;
+}
+/** A `string | list of strings` field, flattened to its entries with their lines. */
+function stringList(context, node, what) {
+	if (isSeq(node)) return node.items.map((item) => ({
+		line: lineOf(context, item),
+		value: requireString(context, item, `each entry of ${what}`)
+	}));
+	return [{
+		line: lineOf(context, node),
+		value: requireString(context, node, what)
+	}];
+}
+function readStream(context, node, what) {
+	return {
+		line: contentLine(context, node),
+		text: requireString(context, node, what)
+	};
+}
+function readEnv(context, node) {
+	return stringList(context, node, "env:").map(({ line, value }) => {
+		const separator = value.indexOf("=");
+		if (separator === -1) return {
+			kind: "set",
+			line,
+			name: value
+		};
+		if (separator === 0) throw new SpecSyntaxError(context.fileName, line, `env: "${value}" has no variable name before the "="`);
+		return {
+			key: value.slice(0, separator),
+			kind: "pair",
+			line,
+			value: value.slice(separator + 1)
+		};
+	});
+}
+function readServeEntry(context, node) {
+	const name = scalarString(node);
+	if (name !== null) return {
+		env: {},
+		line: lineOf(context, node),
+		name
+	};
+	const map = requireMap(context, node, "a serve: entry");
+	if (map.items.length !== 1) fail(context, node, "a serve: entry names ONE server: `- <name>: { KEY: value }`");
+	const pair = map.items[0];
+	const serverName = scalarString(pair.key);
+	if (serverName === null) fail(context, pair, "a serve: entry must name its server with a plain word");
+	const env = {};
+	const envMap = requireMap(context, pair.value, `serve: ${serverName}`);
+	for (const entry of envMap.items) {
+		const key = scalarString(entry.key);
+		if (key === null) fail(context, entry, `serve: ${serverName} — a variable name must be a plain word`);
+		env[key] = requireString(context, entry.value, `serve: ${serverName}.${key}`);
+	}
+	return {
+		env,
+		line: lineOf(context, pair),
+		name: serverName
+	};
+}
+function readServe(context, node) {
+	return (isSeq(node) ? node.items : [node]).map((item) => readServeEntry(context, item));
+}
+function readFiles(context, node) {
+	return requireMap(context, node, "files:").items.map((pair) => {
+		const path = scalarString(pair.key);
+		if (path === null) fail(context, pair, "files: each key is a path relative to the working directory");
+		const line = lineOf(context, pair);
+		const state = scalarString(pair.value);
+		if (state !== null) {
+			if (!FILE_STATES.includes(state)) fail(context, pair, `files: "${path}: ${state}" is not a state — write ${FILE_STATES.join(" or ")}, or a { ${FILE_CONTENT_KEYS.join(", ")} } assertion`);
+			return {
+				kind: state,
+				line,
+				path
+			};
+		}
+		const pairs = closedPairs(context, requireMap(context, pair.value, `files: ${path}`), FILE_CONTENT_KEYS, `files: ${path}`);
+		if (pairs.length === 0) fail(context, pair, `files: ${path} asserts nothing — give it contains: or equals:`);
+		const contains = [];
+		let equals = null;
+		for (const entry of pairs) {
+			if (scalarString(entry.key) === "contains") {
+				if (isSeq(entry.value)) for (const item of entry.value.items) contains.push(readStream(context, item, `files: ${path}.contains`));
+				else contains.push(readStream(context, entry.value, `files: ${path}.contains`));
+				continue;
+			}
+			equals = readStream(context, entry.value, `files: ${path}.equals`);
+		}
+		return {
+			contains,
+			equals,
+			kind: "content",
+			line,
+			path
+		};
+	});
+}
+function readRun(context, node, isLast) {
+	const pairs = closedPairs(context, requireMap(context, node, "each entry of runs:"), RUN_KEYS, "a run");
+	const found = /* @__PURE__ */ new Map();
+	for (const pair of pairs) found.set(scalarString(pair.key), pair);
+	for (const key of ["command", "exit"]) if (!found.has(key)) fail(context, node, `a run is missing "${key}:" — command and exit are mandatory`);
+	const commandPair = found.get("command");
+	const command = requireString(context, commandPair.value, "command:");
+	const waitForPair = found.get("waitFor");
+	if (waitForPair !== void 0 && !isLast) fail(context, waitForPair, "waitFor: is only allowed on the LAST run — a long-running command ends the session");
+	if (waitForPair !== void 0 && found.has("stdin")) fail(context, waitForPair, "waitFor: and stdin: cannot share a run — the pattern is watched on a process nobody closed the input of");
+	const stdout = found.get("stdout");
+	const stderr = found.get("stderr");
+	const stdin = found.get("stdin");
+	const timeout = found.get("timeout");
+	const files = found.get("files");
+	return {
+		command,
+		commandLine: lineOf(context, commandPair),
+		exitCode: requireInteger(context, found.get("exit").value, "exit:"),
+		files: files === void 0 ? [] : readFiles(context, files.value),
+		stderr: stderr === void 0 ? null : readStream(context, stderr.value, "stderr:"),
+		stdin: stdin === void 0 ? null : requireString(context, stdin.value, "stdin:"),
+		stdout: stdout === void 0 ? null : readStream(context, stdout.value, "stdout:"),
+		timeout: timeout === void 0 ? null : requireInteger(context, timeout.value, "timeout:"),
+		waitFor: waitForPair === void 0 ? null : requireString(context, waitForPair.value, "waitFor:")
+	};
+}
+/**
+* Read a `<case>.spec.yaml`. `fileName` is used verbatim in refusals, so pass
+* the path a reader would open. The YAML source comes back beside the document:
+* update mode rewrites THAT, never a re-serialisation of this structure.
+*/
+function readSpecFile(content, fileName) {
+	const source = parseYamlSource(content);
+	const syntax = yamlSyntaxErrors(source);
+	if (syntax.length > 0) throw new SpecSyntaxError(fileName, syntax[0].line, syntax[0].message);
+	const context = {
+		fileName,
+		source
+	};
+	const root = source.document.contents;
+	if (root === null || isScalar(root) && root.value === null) throw new SpecSyntaxError(fileName, 1, "the document is empty");
+	const map = requireMap(context, root, "a spec document");
+	const pairs = closedPairs(context, map, DOCUMENT_KEYS, "a spec document");
+	const found = /* @__PURE__ */ new Map();
+	for (const pair of pairs) found.set(scalarString(pair.key), pair);
+	for (const key of ["description", "runs"]) if (!found.has(key)) fail(context, map, `missing "${key}:" — description and runs are mandatory`);
+	const kindPair = found.get("kind");
+	const kind = kindPair === void 0 ? "cli" : requireString(context, kindPair.value, "kind:");
+	if (!SPEC_KINDS.includes(kind)) fail(context, kindPair, `kind: "${kind}" is not a facet — known kinds: ${SPEC_KINDS.join(", ")}`);
+	const runsNode = found.get("runs");
+	if (!isSeq(runsNode.value) || runsNode.value.items.length === 0) fail(context, runsNode, "runs: is a list of at least one run");
+	const runItems = runsNode.value.items;
+	const fixturePair = found.get("fixture");
+	const envPair = found.get("env");
+	const servePair = found.get("serve");
+	return {
+		document: {
+			description: requireString(context, found.get("description").value, "description:"),
+			descriptionLine: lineOf(context, found.get("description")),
+			env: envPair === void 0 ? [] : readEnv(context, envPair.value),
+			fixtures: fixturePair === void 0 ? [] : stringList(context, fixturePair.value, "fixture:").map(({ line, value }) => ({
+				line,
+				path: value
+			})),
+			kind,
+			runs: runItems.map((item, index) => readRun(context, item, index === runItems.length - 1)),
+			serve: servePair === void 0 ? [] : readServe(context, servePair.value)
+		},
+		source
+	};
+}
+/**
+* Every text of a document the `{{token}}` grammar governs: the streams a
+* comparison judges, and the `files:` texts it judges them with. `stdin:` is an
+* INPUT — like a `requests/` fixture, it is never matched — and a description or
+* a command is prose, so neither appears here.
+*/
+function assertedStreams(document) {
+	const streams = [];
+	for (const run of document.runs) {
+		if (run.stdout !== null) streams.push(run.stdout);
+		if (run.stderr !== null) streams.push(run.stderr);
+		for (const assertion of run.files) {
+			if (assertion.kind !== "content") continue;
+			streams.push(...assertion.contains);
+			if (assertion.equals !== null) streams.push(assertion.equals);
+		}
+	}
+	return streams;
+}
+/** Read a `<case>.spec.yaml` for its content alone — the shape passes and C9's scan. */
+function parseSpecDocument(content, fileName) {
+	return readSpecFile(content, fileName).document;
+}
+/** Insert (or replace) a key at its canonical position in a mapping. */
+function setOrdered(map, key, value, order) {
+	const items = map.items;
+	if (items.findIndex((pair) => scalarString(pair.key) === key) !== -1) {
+		map.set(key, value);
+		return;
+	}
+	const rank = order.indexOf(key);
+	const at = items.findIndex((pair) => {
+		const seen = scalarString(pair.key);
+		return seen !== null && order.indexOf(seen) > rank;
+	});
+	map.set(key, value);
+	if (at !== -1) {
+		const added = map.items.pop();
+		map.items.splice(at, 0, added);
+	}
+}
+/**
+* Rewrite the runs of a spec file from what the commands actually did — exit
+* code and both streams, and nothing else. `files:`, the commands and the
+* header come back byte-identical, comments and key order included, because
+* the YAML DOCUMENT is edited rather than re-emitted from the parsed shape.
+*
+* An empty stream removes its key: absence already asserts emptiness, so a
+* rewritten document says the same thing in fewer words and still passes.
+*/
+function updateSpecFile(file, updates) {
+	const runs = file.source.document.contents.get("runs", true);
+	if (!isSeq(runs)) return renderYamlSource(file.source);
+	for (const [index, update] of updates.entries()) {
+		const run = runs.items[index];
+		if (!isMap(run)) continue;
+		setOrdered(run, "exit", update.exitCode, RUN_KEYS);
+		for (const [key, text] of [["stdout", update.stdout], ["stderr", update.stderr]]) {
+			if (text.length === 0) {
+				run.delete(key);
+				continue;
+			}
+			setOrdered(run, key, blockScalar(text), RUN_KEYS);
+		}
+	}
+	return renderYamlSource(file.source);
+}
+const STRING_OR_LIST = { oneOf: [{ type: "string" }, {
+	items: { type: "string" },
+	minItems: 1,
+	type: "array"
+}] };
+/**
+* The JSON Schema editors validate a `<case>.spec.yaml` against, built from the
+* constants above so it cannot describe a grammar the parser does not read. It
+* is committed as `schema/spec.schema.json` by `npm run docs` and published as
+* the `@jterrazz/test/schema` export.
+*
+* A schema states which keys exist, not which ORDER they come in — JSON Schema
+* has no vocabulary for the sequence of an object's members. The canonical
+* order is the `d4b-spec-key-order` lint pass's, which also rewrites it.
+*/
+const SPEC_SCHEMA = {
+	$defs: {
+		fileAssertion: { oneOf: [{
+			enum: [...FILE_STATES],
+			type: "string"
+		}, {
+			additionalProperties: false,
+			minProperties: 1,
+			properties: {
+				contains: STRING_OR_LIST,
+				equals: { type: "string" }
+			},
+			type: "object"
+		}] },
+		run: {
+			additionalProperties: false,
+			properties: {
+				command: {
+					description: "The argv line, run through the shell.",
+					type: "string"
+				},
+				exit: {
+					description: "The exit code the command must return.",
+					type: "integer"
+				},
+				files: {
+					additionalProperties: { $ref: "#/$defs/fileAssertion" },
+					description: "On-disk assertions, keyed by a path under the working directory.",
+					type: "object"
+				},
+				stderr: {
+					description: "Expected stderr, byte-exact. Absent asserts an empty stream.",
+					type: "string"
+				},
+				stdin: {
+					description: "Written to the child, then closed.",
+					type: "string"
+				},
+				stdout: {
+					description: "Expected stdout, byte-exact. Absent asserts an empty stream.",
+					type: "string"
+				},
+				timeout: {
+					description: "Milliseconds before the run is killed.",
+					type: "integer"
+				},
+				waitFor: {
+					description: "Resolve when this text appears. Only on the last run.",
+					type: "string"
+				}
+			},
+			required: ["command", "exit"],
+			type: "object"
+		},
+		serveEntry: { oneOf: [{ type: "string" }, {
+			additionalProperties: {
+				additionalProperties: { type: "string" },
+				type: "object"
+			},
+			maxProperties: 1,
+			minProperties: 1,
+			type: "object"
+		}] }
+	},
+	$id: "https://jterrazz.com/schema/jterrazz-test/spec.schema.json",
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	additionalProperties: false,
+	description: "One scenario of the @jterrazz/test literate format: the ground a session stands on, then the session itself.",
+	properties: {
+		description: {
+			description: "The vitest test title — one lowercase line, no trailing period.",
+			type: "string"
+		},
+		env: {
+			...STRING_OR_LIST,
+			description: "A bare word names an env set registered in code; KEY=value is inline. $WORKDIR expands."
+		},
+		fixture: {
+			...STRING_OR_LIST,
+			description: "Fixture paths copied into the working directory, layering in order."
+		},
+		kind: {
+			default: "cli",
+			description: "The facet this document describes.",
+			enum: [...SPEC_KINDS],
+			type: "string"
+		},
+		runs: {
+			description: "The session: one or more runs, sequential, sharing one working directory.",
+			items: { $ref: "#/$defs/run" },
+			minItems: 1,
+			type: "array"
+		},
+		serve: {
+			description: "Servers registered in code, started once per file.",
+			oneOf: [{ type: "string" }, {
+				items: { $ref: "#/$defs/serveEntry" },
+				minItems: 1,
+				type: "array"
+			}]
+		}
+	},
+	required: ["description", "runs"],
+	title: "@jterrazz/test spec document",
+	type: "object"
+};
+/** {@link SPEC_SCHEMA} in the exact form `schema/spec.schema.json` is committed in. */
+function renderSchema() {
+	return `${JSON.stringify(SPEC_SCHEMA, null, 4)}\n`;
+}
+//#endregion
+export { assertedStreams as a, renderSchema as c, isMap as d, isScalar as f, SpecSyntaxError as i, updateSpecFile as l, renderYamlSource as m, RUN_KEYS as n, parseSpecDocument as o, isSeq as p, SPEC_EXTENSION as r, readSpecFile as s, DOCUMENT_KEYS as t, Scalar$1 as u };

package/dist/vitest.d.ts

@@ -1,9 +1,9 @@
 //#region src/vitest/literate-plugin.d.ts
 interface LiterateOptions {
   /**
-   * Globs added to the project's test include. Default: every `.cli` file.
-   * Narrow it when a tree holds `.cli` files that are INPUTS to other specs
-   * (a deliberately-broken header) rather than scenarios to run.
+   * Globs added to the project's test include. Default: every `.spec.yaml`
+   * file. Narrow it when a tree holds documents that are INPUTS to other
+   * specs (a deliberately-wrong golden) rather than scenarios to run.
    */
   include?: string[];
   /**

package/dist/vitest.js

@@ -1,15 +1,16 @@
-import { t as literateTitle } from "./literate.js";
+import { n as specDescription } from "./literate.js";
 import { readFileSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 //#region src/vitest/literate-plugin.ts
 /**
-* The `literate()` vite plugin — door one of the literate format.
+* The `literate()` vite plugin — door one of the spec-document format.
 *
-* It makes a `<case>.cli` file a TEST FILE: the glob joins the project's test
-* include, and each `.cli` is transformed into a one-test module that runs the
-* file through the registered `cli` runner. The runner shows the `.cli` path as
-* the file and the header's `test:` line as the title, so a failing scenario is
-* opened where it is written — not in a `.test.ts` that merely points at it.
+* It makes a `<case>.spec.yaml` file a TEST FILE: the glob joins the project's
+* test include, and each document is transformed into a one-test module that
+* runs the file through the registered `cli` runner. The runner shows the
+* document's path as the file and its `description:` as the title, so a failing
+* scenario is opened where it is written — not in a `.test.ts` that merely
+* points at it.
 *
 * ```typescript
 * // vitest.config.ts
@@ -21,17 +22,17 @@ import { isAbsolute, resolve } from "node:path";
 * });
 * ```
 */
-/** The `.cli` extension, matched on the id vite hands the plugin. */
-const CLI_FILE = /\.cli(?:\?.*)?$/;
+/** The `.spec.yaml` extension, matched on the id vite hands the plugin. */
+const SPEC_FILE = /\.spec\.yaml(?:\?.*)?$/;
 /**
-* The module a `.cli` file becomes: one `test()` whose title is the header's
-* `test:` line and whose body runs the whole file — header, servers, every
-* block asserted.
+* The module a `<case>.spec.yaml` becomes: one `test()` whose title is the
+* document's `description:` and whose body runs the whole file — its ground,
+* its servers, every run asserted.
 *
 * @internal Exported for unit tests.
 */
 function literateModule(content, filePath, specificationPath) {
-	const title = literateTitle(content, filePath);
+	const title = specDescription(content, filePath);
 	return [
 		"import { test } from 'vitest';",
 		`import { cli } from ${JSON.stringify(specificationPath)};`,
@@ -47,7 +48,7 @@ function cleanId(id) {
 	return id.split("?")[0];
 }
 function literate(options) {
-	const include = options.include ?? ["**/*.cli"];
+	const include = options.include ?? ["**/*.spec.yaml"];
 	let root = process.cwd();
 	return {
 		config: () => ({ test: { include } }),
@@ -56,7 +57,7 @@ function literate(options) {
 		},
 		enforce: "pre",
 		load: (id) => {
-			if (!CLI_FILE.test(id)) return null;
+			if (!SPEC_FILE.test(id)) return null;
 			const filePath = cleanId(id);
 			const specificationPath = isAbsolute(options.specification) ? options.specification : resolve(root, options.specification);
 			return literateModule(readFileSync(filePath, "utf8"), filePath, specificationPath);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/test",
-    "version": "12.2.0",
+    "version": "13.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",
@@ -27,7 +27,8 @@
     },
     "files": [
         "dist",
-        "!dist/catalog.*"
+        "!dist/catalog.*",
+        "schema"
     ],
     "type": "module",
     "exports": {
@@ -43,7 +44,8 @@
             "types": "./dist/oxlint.d.ts",
             "import": "./dist/oxlint.js",
             "require": "./dist/oxlint.cjs"
-        }
+        },
+        "./schema": "./schema/spec.schema.json"
     },
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
@@ -52,7 +54,7 @@
         "build": "tsdown --config tsdown.config.ts",
         "docs": "npm run build && node dist/catalog.js && typescript docs",
         "lint": "typescript check && node dist/checker.js specs",
-        "lint:fix": "typescript fix",
+        "lint:fix": "typescript fix && node dist/checker.js specs --fix",
         "test": "vitest --run"
     },
     "dependencies": {