@effected/yaml 0.6.1 → 0.8.0

package/internal/composer/scalars.js

@@ -1,5 +1,6 @@
 import { YamlScalar } from "../../YamlNode.js";
 import { registerAnchor } from "./anchors.js";
+import { rawCommentText } from "./comments.js";
 import { lineCol } from "./state.js";
 import { resolveTagHandle } from "./tags.js";
 
@@ -98,13 +99,42 @@ function getScalarStyle(node) {
 */
 function getBlockChomp(node) {
 	if (node.type !== "block-scalar") return void 0;
-	const src = node.source.trimStart();
-	const headerEnd = src.indexOf("\n");
-	const header = headerEnd === -1 ? src : src.slice(0, headerEnd);
-	if (header.includes("+")) return "keep";
-	if (header.includes("-")) return "strip";
+	const indicators = node.source.trimStart().match(/^[|>]([0-9+-]*)/)?.[1] ?? "";
+	if (indicators.includes("+")) return "keep";
+	if (indicators.includes("-")) return "strip";
 	return "clip";
 }
+/**
+* Extracts the EXPLICIT indentation-indicator digit from a block scalar's
+* header (`|2`, `>1+`), or undefined when the header carries none (the
+* reader auto-detects) or the node is not a block scalar. Inspects only the
+* indicator run — see {@link getBlockChomp} for why the rest of the header
+* line (a comment can contain digits) must not be read.
+*/
+function getBlockIndent(node) {
+	if (node.type !== "block-scalar") return void 0;
+	const digit = (node.source.trimStart().match(/^[|>]([0-9+-]*)/)?.[1] ?? "").match(/[1-9]/)?.[0];
+	return digit === void 0 ? void 0 : Number(digit);
+}
+/**
+* The trailing comment on a block scalar's HEADER line (`key: | # c`,
+* `- >-2 # c`) as stored raw-slice text, or `undefined` when the header
+* carries none. The header is the only line of a block scalar that can carry
+* a `#` comment — body lines absorb `#` as content — and the lexer packs the
+* whole scalar (header comment included) into one CST token, so the comment
+* never surfaces as a sibling comment token for the ordinary attribution
+* pass (#341).
+*/
+function blockScalarHeaderComment(cst) {
+	const src = cst.source.trimStart();
+	const nl = src.search(/[\r\n]/);
+	const header = nl < 0 ? src : src.slice(0, nl);
+	const hash = header.indexOf("#");
+	if (hash < 1) return void 0;
+	const before = header[hash - 1];
+	if (before !== " " && before !== "	") return void 0;
+	return rawCommentText(header.slice(hash));
+}
 function getScalarValue(node, fullText) {
 	if (node.type === "block-scalar") return decodeBlockScalar(node.source, fullText, node.offset);
 	const style = getScalarStyle(node);
@@ -265,10 +295,11 @@ function foldFlowLines(text) {
 		}
 		const isLast = i === lines.length - 1;
 		const trimmed = isLast ? line.trimStart() : line.trim();
-		if (trimmed === "") if (isLast) {
-			if (result.length === 0 || result[result.length - 1] !== "\n") result += " ";
-		} else result += "\n";
-		else {
+		if (trimmed === "") {
+			if (isLast) {
+				if (result.length === 0 || result[result.length - 1] !== "\n") result += " ";
+			} else result += "\n";
+		} else {
 			if (result.length > 0 && result[result.length - 1] !== "\n") result += " ";
 			result += trimmed;
 		}
@@ -681,8 +712,10 @@ function decodeBlockScalar(raw, fullText, nodeOffset) {
 		} else break;
 	}
 	while (i < raw.length && raw[i] !== "\n" && raw[i] !== "\r") i++;
-	if (i < raw.length) if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
-	else i++;
+	if (i < raw.length) {
+		if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
+		else i++;
+	}
 	let contentIndent = explicitIndent;
 	let foundContent = explicitIndent > 0;
 	if (explicitIndent > 0 && fullText !== void 0 && nodeOffset !== void 0) {
@@ -745,8 +778,10 @@ function decodeBlockScalar(raw, fullText, nodeOffset) {
 				trailingNewlines.length = 0;
 				lines.push(" ".repeat(spaces - contentIndent));
 			} else trailingNewlines.push("");
-			if (i < raw.length) if (raw[i] === "\r" && i + 1 < raw.length && raw[i + 1] === "\n") i += 2;
-			else i++;
+			if (i < raw.length) {
+				if (raw[i] === "\r" && i + 1 < raw.length && raw[i + 1] === "\n") i += 2;
+				else i++;
+			}
 			continue;
 		}
 		if (spaces < contentIndent) break;
@@ -756,8 +791,10 @@ function decodeBlockScalar(raw, fullText, nodeOffset) {
 		const contentStart = i;
 		while (i < raw.length && raw[i] !== "\n" && raw[i] !== "\r") i++;
 		lines.push(extra + raw.slice(contentStart, i));
-		if (i < raw.length) if (raw[i] === "\r" && i + 1 < raw.length && raw[i + 1] === "\n") i += 2;
-		else i++;
+		if (i < raw.length) {
+			if (raw[i] === "\r" && i + 1 < raw.length && raw[i + 1] === "\n") i += 2;
+			else i++;
+		}
 	}
 	let value;
 	if (isFolded) {
@@ -773,27 +810,32 @@ function decodeBlockScalar(raw, fullText, nodeOffset) {
 				prevMoreIndented = isMoreIndented;
 				hadContent = true;
 			} else {
-				if (result[result.length - 1] === "\n") if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
-				else result += ln;
-				else if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
+				if (result[result.length - 1] === "\n") {
+					if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
+					else result += ln;
+				} else if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
 				else result += ` ${ln}`;
 				prevMoreIndented = isMoreIndented;
 			}
 		}
 		if (hadContent || trailingNewlines.length > 0) {
 			if (chomp === "keep") {
-				result += "\n";
+				if (hadContent) result += "\n";
 				for (const _nl of trailingNewlines) result += "\n";
-			} else if (chomp !== "strip") result += "\n";
+			} else if (chomp !== "strip") {
+				if (hadContent) result += "\n";
+			}
 		}
 		value = result;
 	} else {
 		value = lines.join("\n");
 		if (lines.length > 0 || trailingNewlines.length > 0) {
 			if (chomp === "keep") {
-				value += "\n";
+				if (lines.length > 0) value += "\n";
 				for (const _nl of trailingNewlines) value += "\n";
-			} else if (chomp !== "strip") value += "\n";
+			} else if (chomp !== "strip") {
+				if (lines.length > 0) value += "\n";
+			}
 		}
 	}
 	return value;
@@ -809,8 +851,10 @@ function validateBlockScalarLeadingEmpties(cst, state) {
 	const raw = cst.source;
 	let i = 0;
 	while (i < raw.length && raw[i] !== "\n" && raw[i] !== "\r") i++;
-	if (i < raw.length) if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
-	else i++;
+	if (i < raw.length) {
+		if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
+		else i++;
+	}
 	const emptyIndents = [];
 	while (i < raw.length) {
 		const lineStart = i;
@@ -824,8 +868,10 @@ function validateBlockScalarLeadingEmpties(cst, state) {
 				indent: spaces,
 				offsetInRaw: lineStart
 			});
-			if (i < raw.length) if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
-			else i++;
+			if (i < raw.length) {
+				if (raw[i] === "\r" && raw[i + 1] === "\n") i += 2;
+				else i++;
+			}
 			continue;
 		}
 		const contentIndent = spaces;
@@ -848,6 +894,8 @@ function makeScalar(cst, state, meta) {
 	const rawValue = getScalarValue(cst, state.text);
 	const value = resolveScalar(rawValue, style, meta?.tag, state);
 	const chomp = getBlockChomp(cst);
+	const blockIndent = getBlockIndent(cst);
+	const comment = (style === "block-literal" || style === "block-folded" ? blockScalarHeaderComment(cst) : void 0) ?? meta?.comment;
 	const needsRaw = style === "plain" && typeof value !== "string" && value !== void 0 && shouldPreserveRaw(rawValue, value);
 	const scalar = new YamlScalar({
 		value,
@@ -856,8 +904,9 @@ function makeScalar(cst, state, meta) {
 		length: cst.length,
 		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
 		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
-		...meta?.comment !== void 0 ? { comment: meta.comment } : {},
+		...comment !== void 0 ? { comment } : {},
 		...chomp !== void 0 ? { chomp } : {},
+		...blockIndent !== void 0 ? { blockIndent } : {},
 		...needsRaw ? { raw: rawValue } : {}
 	});
 	if (meta?.anchor) registerAnchor(scalar, meta.anchor, state, cst.offset);
@@ -882,4 +931,4 @@ function shouldPreserveRaw(rawValue, value) {
 }
 
 //#endregion
-export { blockMapStartsWithValueSep, classifyPlainNumeric, collectMultilineKey, collectMultilinePlainScalar, findFirstContent, findLastContent, findNextContentChild, findNextContentInList, findNextSignificantChild, findValueSepOffset, foldFlowLines, getBlockChomp, getScalarStyle, getScalarValue, hasBlockMapAfterInList, hasValueSepAfter, hasValueSepAfterInList, hasValueSepBetween, hasValueSepThroughPlainScalars, indexOfChild, makeScalar, resolveScalar, shouldPreserveRaw };
+export { blockMapStartsWithValueSep, classifyPlainNumeric, collectMultilineKey, collectMultilinePlainScalar, findFirstContent, findLastContent, findNextContentChild, findNextContentInList, findNextSignificantChild, findValueSepOffset, foldFlowLines, getBlockChomp, getBlockIndent, getScalarStyle, getScalarValue, hasBlockMapAfterInList, hasValueSepAfter, hasValueSepAfterInList, hasValueSepBetween, hasValueSepThroughPlainScalars, indexOfChild, makeScalar, resolveScalar, shouldPreserveRaw };

package/internal/composer/state.js

@@ -63,6 +63,19 @@ function clearMeta(m) {
 	delete m.tag;
 	delete m.comment;
 }
+/**
+* The comment-fidelity field triple carried by the four public node classes
+* (and `YamlPair`). Conditional-spread helper so AST rebuild sites copy all
+* three without hand-maintaining the list — and never emit an explicit
+* `undefined` into a v4 `optionalKey` field.
+*/
+function commentProps(n) {
+	return {
+		...n.commentBefore !== void 0 ? { commentBefore: n.commentBefore } : {},
+		...n.comment !== void 0 ? { comment: n.comment } : {},
+		...n.spaceBefore !== void 0 ? { spaceBefore: n.spaceBefore } : {}
+	};
+}
 function createState(text, flow, options) {
 	return {
 		text,
@@ -77,7 +90,8 @@ function createState(text, flow, options) {
 		},
 		tagMap: /* @__PURE__ */ new Map(),
 		flow,
-		depth: 0
+		depth: 0,
+		escapedComments: []
 	};
 }
 /**
@@ -114,4 +128,4 @@ function exitNesting(state) {
 }
 
 //#endregion
-export { clearMeta, createState, enterNesting, exitNesting, getLineStarts, hasMeta, hasNonWhitespaceBeforeOnLine, lineCol, lineIndentColumn, sameLine };
+export { clearMeta, commentProps, createState, enterNesting, exitNesting, getLineStarts, hasMeta, hasNonWhitespaceBeforeOnLine, lineCol, lineIndentColumn, sameLine };

package/internal/cst-parser.js

@@ -286,12 +286,14 @@ function parseBlockMappingInner(state, indent) {
 			continue;
 		}
 		if (token.kind === "block-map-key") {
+			if (token.column < indent && children.length > 0) break;
 			sawExplicitKey = true;
 			const leaf = consumeLeafToken(state);
 			if (leaf) children.push(leaf);
 			continue;
 		}
 		if (token.kind === "block-map-value") {
+			if (token.column < indent && children.length > 0) break;
 			const leaf = consumeLeafToken(state);
 			if (leaf) children.push(leaf);
 			children.push(...parseBlockValue(state, indent, sawExplicitKey));
@@ -357,13 +359,14 @@ function parseBlockMappingInner(state, indent) {
 /**
 * Parse the value part after a ":" in a block mapping.
 */
-function parseBlockValue(state, _parentIndent, explicitKey = false) {
+function parseBlockValue(state, parentIndent, explicitKey = false) {
 	const nodes = [];
 	while (!atEnd(state)) {
 		const token = peek(state);
 		if (!token) break;
 		if (token.kind === "whitespace") {
-			nodes.push(...consumeTrivia(state));
+			advance(state);
+			nodes.push(makeLeafNode("whitespace", token, state.text));
 			continue;
 		}
 		if (token.kind === "newline") break;
@@ -385,6 +388,10 @@ function parseBlockValue(state, _parentIndent, explicitKey = false) {
 			nodes.push(parseBlockSequence(state, seqIndent));
 			break;
 		}
+		if (explicitKey && token.kind === "scalar" && !isBlockScalarToken(state) && hasImplicitMapAhead(state, parentIndent)) {
+			nodes.push(parseImplicitBlockMapping(state, parentIndent));
+			break;
+		}
 		if (token.kind === "scalar" || token.kind === "anchor" || token.kind === "alias" || token.kind === "tag") {
 			const leaf = consumeLeafToken(state);
 			if (leaf) nodes.push(leaf);
@@ -540,11 +547,13 @@ function parseImplicitBlockMappingInner(state, seqIndent) {
 		if (!token) break;
 		if (isDocumentBoundary(token)) break;
 		if (token.kind === "block-seq-entry" && token.column <= seqIndent) break;
+		if (token.kind === "block-map-key" && token.column <= seqIndent) break;
 		if (isTrivia(token)) {
 			children.push(...consumeTrivia(state));
 			continue;
 		}
 		if (token.kind === "block-map-value") {
+			if (token.column <= seqIndent && children.length > 0) break;
 			const leaf = consumeLeafToken(state);
 			if (leaf) children.push(leaf);
 			children.push(...parseBlockValue(state, seqIndent));

package/internal/diagnostics.js

@@ -43,14 +43,23 @@ const YAML_COMPOSE_ERROR_CODES = [
 */
 const YAML_STRINGIFY_ERROR_CODES = ["CircularReference"];
 /**
-* Error codes for the modify stage (`YamlFormat.modify`'s path navigation
-* against an already-composed AST). Not raised by the parser/composer.
+* Error codes for the modify stage (`YamlFormat.modify`'s guards and path
+* navigation against an already-composed AST). Not raised by the
+* parser/composer. `MultiDocumentStream` is the single-document-contract
+* refusal: `modify` re-emits exactly one document, so a multi-document
+* stream fails typed rather than silently truncating documents 2..n.
+* `DirectiveCarryingDocument` is the directive refusal: the stringifier does
+* not re-emit `%YAML`/`%TAG` directive lines, and re-emitting a document
+* without its `%TAG` orphans every shorthand tag that depends on it — the
+* output would be unparseable — so modify fails typed rather than corrupting.
 */
 const YAML_MODIFY_ERROR_CODES = [
 	"EmptyDocument",
 	"PathNotFound",
 	"InvalidIndex",
-	"NotNavigable"
+	"NotNavigable",
+	"MultiDocumentStream",
+	"DirectiveCarryingDocument"
 ];
 /**
 * The single source of truth for which diagnostic codes are fatal to a

package/internal/fold.js

@@ -174,12 +174,18 @@ function renderSingleQuotedMultiline(s, indent) {
 * @param explicitChomp - Original chomp indicator from the AST, when known.
 * `keep` (`+`) and `strip` (`-`) preserve trailing-newline semantics that
 * cannot be inferred from the resolved value alone.
+* @param preserveKeep - Re-emit a REDUNDANT explicit `+` (a keep header whose
+* value ends in exactly one newline, where clip would read identically) —
+* fidelity-path header preservation; canonical mode passes false.
+* @param explicitIndent - Explicit indentation-indicator digit from the AST,
+* re-emitted only when it matches the rendered indent (fidelity path).
 */
-function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
+function renderBlockLiteral(s, indent, explicitChomp, parentPosition, preserveKeep = false, explicitIndent) {
 	let chomp = "";
 	const onlyNewlines = s.length > 0 && /^\n+$/.test(s);
 	if (s.endsWith("\n\n") || onlyNewlines && explicitChomp === "keep") chomp = "+";
 	else if (!s.endsWith("\n")) chomp = "-";
+	else if (preserveKeep && explicitChomp === "keep") chomp = "+";
 	const lines = s.split("\n");
 	if (s.endsWith("\n")) lines.pop();
 	let indentIndicator = "";
@@ -187,6 +193,7 @@ function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
 	const hasContent = firstContent !== void 0;
 	if (firstContent?.startsWith(" ") || lines.length > 0 && lines[0] === "" && hasContent) indentIndicator = String(indent.length);
 	else if (!hasContent && chomp === "+" && parentPosition === "block-map-value" && indent.length > 0) indentIndicator = String(indent.length);
+	else if (explicitIndent !== void 0 && explicitIndent === indent.length) indentIndicator = String(explicitIndent);
 	return `|${indentIndicator}${chomp}\n${lines.map((l) => l === "" ? "" : `${indent}${l}`).join("\n")}`;
 }
 /**
@@ -197,34 +204,39 @@ function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
 * the output must contain an empty line (double newline). Each empty line
 * in the value already produces the correct number of blank lines.
 */
-function renderBlockFolded(s, indent) {
+function renderBlockFolded(s, indent, explicitChomp, explicitIndent) {
 	let chomp = "";
 	if (s.endsWith("\n\n")) chomp = "+";
 	else if (!s.endsWith("\n")) chomp = "-";
+	else if (explicitChomp === "keep") chomp = "+";
 	const valueLines = s.split("\n");
 	if (s.endsWith("\n")) valueLines.pop();
 	let indentIndicator = "";
 	const firstContent = valueLines.find((l) => l !== "");
 	if (firstContent?.startsWith(" ") || valueLines.length >= 2 && valueLines[0] === "" && valueLines[1] === "" && firstContent !== void 0) indentIndicator = String(indent.length);
+	else if (explicitIndent !== void 0 && explicitIndent === indent.length) indentIndicator = String(explicitIndent);
 	const outputLines = [];
+	let lastContentIdx = -1;
+	for (let i = valueLines.length - 1; i >= 0; i--) if (valueLines[i] !== "") {
+		lastContentIdx = i;
+		break;
+	}
 	let prevNonEmpty = false;
 	let prevMoreIndented = false;
+	let pendingCompensation = false;
 	for (let i = 0; i < valueLines.length; i++) {
 		const line = valueLines[i];
 		if (line === "") {
-			if (prevNonEmpty && !prevMoreIndented) {
-				let nextContentMoreIndented = false;
-				for (let j = i + 1; j < valueLines.length; j++) if (valueLines[j] !== "") {
-					nextContentMoreIndented = valueLines[j].startsWith(" ") || valueLines[j].startsWith("	");
-					break;
-				}
-				if (!nextContentMoreIndented) outputLines.push("");
-			}
+			if (prevNonEmpty && !prevMoreIndented && i < lastContentIdx) pendingCompensation = true;
 			outputLines.push("");
 			prevNonEmpty = false;
 			prevMoreIndented = false;
 		} else {
 			const isMoreIndented = line.startsWith(" ") || line.startsWith("	");
+			if (pendingCompensation) {
+				if (!isMoreIndented) outputLines.push("");
+				pendingCompensation = false;
+			}
 			if (prevNonEmpty && !isMoreIndented) outputLines.push("");
 			outputLines.push(`${indent}${line}`);
 			prevNonEmpty = true;

package/internal/lexer.js

@@ -216,14 +216,15 @@ function createScanner(text) {
 		let value = "";
 		while (pos < text.length) {
 			const ch = peek();
-			if (ch === "'") if (peek(1) === "'") {
-				value += "'";
-				advance(2);
-			} else {
-				advance();
-				return makeToken("scalar", value, start, sLine, sCol, pos - start);
-			}
-			else if (ch === "\n" || ch === "\r" && peek(1) === "\n") {
+			if (ch === "'") {
+				if (peek(1) === "'") {
+					value += "'";
+					advance(2);
+				} else {
+					advance();
+					return makeToken("scalar", value, start, sLine, sCol, pos - start);
+				}
+			} else if (ch === "\n" || ch === "\r" && peek(1) === "\n") {
 				value += " ";
 				if (ch === "\r") advance(2);
 				else advance();
@@ -402,13 +403,17 @@ function createScanner(text) {
 			hadHeaderWhitespace = true;
 			advance();
 		}
-		if (pos < text.length && !isNewline(peek()) && peek() !== "") if (peek() === "#" && hadHeaderWhitespace) while (pos < text.length && !isNewline(peek())) advance();
-		else {
-			while (pos < text.length && !isNewline(peek())) advance();
-			return makeToken("error", text.slice(start, pos), start, sLine, sCol);
+		if (pos < text.length && !isNewline(peek()) && peek() !== "") {
+			if (peek() === "#" && hadHeaderWhitespace) while (pos < text.length && !isNewline(peek())) advance();
+			else {
+				while (pos < text.length && !isNewline(peek())) advance();
+				return makeToken("error", text.slice(start, pos), start, sLine, sCol);
+			}
+		}
+		if (pos < text.length && isNewline(peek())) {
+			if (peek() === "\r" && peek(1) === "\n") advance(2);
+			else advance();
 		}
-		if (pos < text.length && isNewline(peek())) if (peek() === "\r" && peek(1) === "\n") advance(2);
-		else advance();
 		let contentIndent = explicitIndent;
 		let foundContent = explicitIndent > 0;
 		if (explicitIndent > 0) {
@@ -564,9 +569,10 @@ function createScanner(text) {
 					prevMoreIndented = isMoreIndented;
 					hadContent = true;
 				} else {
-					if (result[result.length - 1] === "\n") if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
-					else result += ln;
-					else if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
+					if (result[result.length - 1] === "\n") {
+						if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
+						else result += ln;
+					} else if (isMoreIndented || prevMoreIndented) result += `\n${ln}`;
 					else result += ` ${ln}`;
 					prevMoreIndented = isMoreIndented;
 				}

package/internal/rules/catalog.js

@@ -0,0 +1,39 @@
+import { colonSpacing, colonSpacingOptions } from "./colon-spacing.js";
+import { commentsSpacing, commentsSpacingOptions } from "./comments-spacing.js";
+import { documentEnd, documentEndOptions } from "./document-end.js";
+import { documentStart, documentStartOptions } from "./document-start.js";
+import { emptyLines, emptyLinesOptions } from "./empty-lines.js";
+import { eofNewline, eofNewlineOptions } from "./eof-newline.js";
+import { hyphenSpacing, hyphenSpacingOptions } from "./hyphen-spacing.js";
+import { indentation, indentationOptions } from "./indentation.js";
+import { keyDuplicates, keyDuplicatesOptions } from "./key-duplicates.js";
+import { lineLength, lineLengthOptions } from "./line-length.js";
+import { parseValidity, parseValidityOptions } from "./parse-validity.js";
+import { quotedStrings, quotedStringsOptions } from "./quoted-strings.js";
+import { trailingSpaces, trailingSpacesOptions } from "./trailing-spaces.js";
+import { truthy, truthyOptions } from "./truthy.js";
+
+//#region src/internal/rules/catalog.ts
+const catalog = [
+	[parseValidity, parseValidityOptions],
+	[lineLength, lineLengthOptions],
+	[trailingSpaces, trailingSpacesOptions],
+	[emptyLines, emptyLinesOptions],
+	[eofNewline, eofNewlineOptions],
+	[documentStart, documentStartOptions],
+	[documentEnd, documentEndOptions],
+	[keyDuplicates, keyDuplicatesOptions],
+	[quotedStrings, quotedStringsOptions],
+	[truthy, truthyOptions],
+	[commentsSpacing, commentsSpacingOptions],
+	[colonSpacing, colonSpacingOptions],
+	[hyphenSpacing, hyphenSpacingOptions],
+	[indentation, indentationOptions]
+];
+/** The built-in rules, in catalog order (parse-validity is rule `#1`). */
+const builtinRules = catalog.map(([rule]) => rule);
+/** Per-rule options schemas — the rule-aware half of config validation. */
+const builtinOptionsSchemas = new Map(catalog.map(([rule, options]) => [rule.id, options]));
+
+//#endregion
+export { builtinOptionsSchemas, builtinRules };

package/internal/rules/colon-spacing.js

@@ -0,0 +1,77 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { nonNegativeIntegerOption, positiveIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/colon-spacing.ts
+/**
+* Options for `colon-spacing`: `maxSpacesBefore` (default 0) and
+* `maxSpacesAfter` (default 1) around the `:` indicator. `maxSpacesBefore: 0`
+* is legal (`key:` needs no space before the colon), but at least one
+* separation space must FOLLOW it — `0` would make the fix emit `a:val`, a
+* plain scalar, not a mapping entry.
+*/
+const colonSpacingOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	maxSpacesBefore: Schema.optionalKey(nonNegativeIntegerOption),
+	maxSpacesAfter: Schema.optionalKey(positiveIntegerOption)
+});
+/** Spacing around the block-mapping `:` indicator. */
+const colonSpacing = {
+	id: "colon-spacing",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const maxBefore = opts.maxSpacesBefore ?? 0;
+		const maxAfter = Math.max(1, opts.maxSpacesAfter ?? 1);
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "block-map-value") continue;
+			let i = token.offset - 1;
+			let before = 0;
+			while (i >= 0 && ctx.text[i] === " ") {
+				before++;
+				i--;
+			}
+			if (i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r" && ctx.text[i] !== "	" && before > maxBefore) out.push(new YamlLintDiagnostic({
+				rule: "colon-spacing",
+				severity: "error",
+				message: `Too many spaces before ":" (${before} > ${maxBefore})`,
+				offset: token.offset - before,
+				length: before,
+				line: token.line,
+				character: token.character - before,
+				fix: YamlEdit.make({
+					offset: token.offset - before,
+					length: before - maxBefore,
+					content: ""
+				})
+			}));
+			let j = token.offset + token.length;
+			let after = 0;
+			while (j < ctx.text.length && ctx.text[j] === " ") {
+				after++;
+				j++;
+			}
+			const next = ctx.text[j];
+			if (next === void 0 || next === "\n" || next === "\r" || next === "#") continue;
+			if (after > maxAfter) out.push(new YamlLintDiagnostic({
+				rule: "colon-spacing",
+				severity: "error",
+				message: `Too many spaces after ":" (${after} > ${maxAfter})`,
+				offset: token.offset + token.length,
+				length: after,
+				line: token.line,
+				character: token.character + token.length,
+				fix: YamlEdit.make({
+					offset: token.offset + token.length,
+					length: after - maxAfter,
+					content: ""
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { colonSpacing, colonSpacingOptions };

package/internal/rules/comments-spacing.js

@@ -0,0 +1,68 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { nonNegativeIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/comments-spacing.ts
+/**
+* Options for `comments-spacing`: `minSpacesBefore` between content and a
+* trailing `#` (default 1 — the kit's own emission spelling) and
+* `requireSpaceAfter` the `#` (default `true`).
+*/
+const commentsSpacingOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	minSpacesBefore: Schema.optionalKey(nonNegativeIntegerOption),
+	requireSpaceAfter: Schema.optionalKey(Schema.Boolean)
+});
+/** Comment spacing: after the `#`, and before a trailing comment's `#`. */
+const commentsSpacing = {
+	id: "comments-spacing",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const minBefore = opts.minSpacesBefore ?? 1;
+		const requireAfter = opts.requireSpaceAfter ?? true;
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "comment") continue;
+			if (token.offset === 0 && token.text.startsWith("#!")) continue;
+			if (requireAfter && token.text.length > 1 && !/[ \t]/.test(token.text[1])) out.push(new YamlLintDiagnostic({
+				rule: "comments-spacing",
+				severity: "error",
+				message: "Missing space after \"#\"",
+				offset: token.offset,
+				length: 1,
+				line: token.line,
+				character: token.character,
+				fix: YamlEdit.make({
+					offset: token.offset + 1,
+					length: 0,
+					content: " "
+				})
+			}));
+			let i = token.offset - 1;
+			let spaces = 0;
+			while (i >= 0 && (ctx.text[i] === " " || ctx.text[i] === "	")) {
+				spaces++;
+				i--;
+			}
+			if (i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r" && spaces < minBefore) out.push(new YamlLintDiagnostic({
+				rule: "comments-spacing",
+				severity: "error",
+				message: `Too few spaces before comment (${spaces} < ${minBefore})`,
+				offset: token.offset - spaces,
+				length: spaces,
+				line: token.line,
+				character: token.character - spaces,
+				fix: YamlEdit.make({
+					offset: token.offset,
+					length: 0,
+					content: " ".repeat(minBefore - spaces)
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { commentsSpacing, commentsSpacingOptions };