@effected/yaml 0.10.0 → 0.11.0

package/README.md

@@ -5,7 +5,7 @@
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
 [![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Zero-dependency YAML 1.2 parsing, editing, formatting and linting expressed as Effect schemas and pure functions. Parse a single document or a multi-document stream into plain values or an offset-preserving AST, resolve anchors and aliases, read and preserve per-node comments, strip comments, compute byte-minimal edits, format, modify by path, walk a document as a `Stream` of AST events or positioned tokens, lint it against a rule catalog with surgical autofix, and decode straight into a validated domain schema.
+Zero-dependency YAML 1.2 parsing, editing, formatting and linting expressed as Effect schemas and pure functions. Parse a single document or a multi-document stream into plain values or an offset-preserving AST, resolve anchors and aliases, read and preserve per-node comments, strip comments, compute byte-minimal edits, format, modify by path, walk a document as a `Stream` of AST events or positioned tokens, lint it against a rule catalog with surgical autofix — inferring the lint config from files you already have — and decode straight into a validated domain schema.
 
 > **Pre-release.** This package is part of the `@effected/*` kit, in pre-`1.0.0`
 > development against a single pinned Effect v4 prerelease. Packages graduate to
@@ -156,6 +156,23 @@ console.log(Result.isSuccess(fixed) ? fixed.success : "fatal parse error — not
 
 Positions are zero-based throughout, so the first finding above sits on the second line of the source. Fixes route through `YamlEdit.applyAll` rather than a reformat, so an autofix cannot move a comment it was not asked to touch, and a rule whose repair would need reflowing the document ships without a fix at all. `YamlLintConfig.default` and `YamlLintConfig.relaxed` are the presets; compose your own by spreading a preset's `rules` into `YamlLintConfig.make`. Config validation is rule-aware for the built-in catalog — a misspelled option key on a built-in rule or an attempt to switch off the always-on `parse-validity` rule fails schema validation instead of being quietly ignored — while an unknown (custom) rule id passes through with its options treated as opaque, left for the custom rule itself to validate. Custom rules are plain array concatenation — `YamlLint.run(text, [...YamlLint.builtins, myRule], config)` — and configuring `myRule` in that config works precisely because of the pass-through.
 
+A repo with no lint config yet can infer one from what its files already do. `YamlLint.inferLenient` observes a text's style — quote type, indentation width, document markers and the rest — and returns the config the dominant style implies, plus the residual: the diagnostics that config still produces on the same text.
+
+```ts
+import { YamlLint } from "@effected/yaml";
+
+const workflow = ["---", "name: ci", "on:", "  push:", "    branches: ['main']", "jobs:", "  build:", "    runs-on: ubuntu-latest", ""].join("\n");
+
+const { config, residual } = YamlLint.inferLenient(workflow, YamlLint.builtins);
+console.log(config.rules["quoted-strings"], config.rules["document-start"], config.rules.indentation);
+// { quoteType: 'single' } { present: true } { spaces: 2 }
+
+for (const d of residual) console.log(`${d.line}:${d.character} ${d.rule} ${d.message}`);
+// 2:0 truthy Truthy value "on" is not in the allowed spellings
+```
+
+`YamlLint.inferStrict` is the same step in `Result` form: it fails with a structured `YamlStyleConflictError` — naming every conflicting dimension, all observed spellings, counts and positions — when the observed style disagrees with itself, instead of picking a winner. Across many files, compose the primitives instead of the conveniences: `YamlLint.observe` each file, merge the `StyleEvidence` values with `StyleEvidence.combine` (evidence is a monoid, so the order does not matter), then resolve once with `YamlLint.resolveStrict` or `YamlLint.resolveLenient`. Dimensions never observed fall back to the base config rather than failing. Policy rules with no detectable style — `truthy`, `key-duplicates` — stay default-driven, as do `line-length` and `empty-lines`, whose observations are floor-only: the longest line proves the limit is at least that long, not what it should be, so the evidence is carried but never resolved into config. A custom rule participates by implementing the optional `infer` hook on `YamlRule`.
+
 ## Migrating from Prettier
 
 `YamlFormat.formatToString(text, undefined, options)` replaces a `prettier --write` over YAML files. The option mapping:
@@ -163,14 +180,14 @@ Positions are zero-based throughout, so the first finding above sits on the seco
 | Prettier | `YamlFormattingOptions` |
 | --- | --- |
 | `tabWidth` | `indent` |
-| `singleQuote` | `quoteStyle: "single" \| "double"` |
+| `singleQuote` | `quoteStyle: "single" \| "double"` + `requoteScalars: true` |
 | indented block sequences (always on) | `indentSequences: true` |
 | `printWidth` / `proseWrap` | no analog — see below |
 | comments (best-effort) | `preserveComments: true` (the default) |
 
 Two defaults differ from Prettier's output and are worth setting explicitly. The stringify default is `quoteStyle: "single"` for byte-compatibility with the kit's legacy form, so if you ran Prettier with its own default (`singleQuote: false`), set `quoteStyle: "double"`. Likewise `indentSequences` defaults to `false` — the flat legacy form with the `-` markers at the key's column — while Prettier always indented block sequences one level, so an ex-Prettier consumer almost certainly wants `indentSequences: true`.
 
-One expectation to reset when carrying over `singleQuote`: on the format path, `quoteStyle` governs quotes the stringifier *introduces* — it never re-quotes scalars that already carry quotes in your source. Formatting `a: 'x'` with `quoteStyle: "double"` leaves `'x'` untouched; Prettier would have rewritten it to `"x"`. Existing quote styles are source, and the formatter preserves source. If it looks like the option "does nothing" on an already-quoted corpus, this is why — the same class of format-path inertness as `lineWidth` below.
+The `requoteScalars: true` half of the `singleQuote` row is what buys full parity. By default, `quoteStyle` on the format path governs only quotes the stringifier *introduces* — a scalar already quoted in your source keeps its own quote style, so formatting `a: 'x'` with `quoteStyle: "double"` leaves `'x'` untouched, where Prettier would have rewritten it to `"x"`. With `requoteScalars: true` (default `false`), `quoteStyle` applies to already-quoted source scalars too. A re-quote happens only when it provably preserves the parsed value: single→double applies proper double-quote escaping, and double→single is skipped when the value carries characters single quotes cannot express. Plain scalars stay plain, block scalars stay block, and tagged, anchored and multi-line scalars are never touched. One interaction to watch: `quoteStyle` omitted defaults to `"single"`, so `requoteScalars: true` on its own converts `"x"` to `'x'` — an ex-Prettier consumer who ran with `singleQuote: false` wants `quoteStyle: "double"` alongside it.
 
 `printWidth` and `proseWrap` have no analog here: `lineWidth` folding is a value-path feature only (`Yaml.stringify` / `Yaml.stringifyResult`), and the option is deliberately inert on the format path by contract — `YamlFormat` never reflows scalar content (the `lineWidth` TSDoc on `YamlStringifyOptions` pins this). Comments, which Prettier handled best-effort, are preserved exactly by default.
 
@@ -186,11 +203,11 @@ Multi-document streams — a Kubernetes manifest, or the two-document `pnpm-lock
 - `Yaml.schema` / `Yaml.fromString` / `Yaml.YamlFromString` / `Yaml.allFromString` — string→domain schema factories that decode a single document or a whole stream into a validated Effect `Schema` value.
 - `YamlNode` — an offset-preserving AST (`YamlScalar`, `YamlMap`, `YamlSeq`, `YamlPair`, `YamlAlias`) for locating and reading nodes by position or path; every node class except `YamlPair` carries its own `commentBefore`, `comment` and `spaceBefore`, and a pair is just its `key` and `value`.
 - `YamlDocument` — the full parsed AST plus the recovered `errors` and `warnings` arrays, so a partially valid document is still inspectable, and the header and trailing comment blocks as `commentBefore` / `comment`, the same two names the node classes use.
-- `YamlEdit` / `YamlFormat` — compute byte-minimal edit arrays for formatting and path-based modification, so a change preserves every comment and byte you did not touch; `preserveComments: false` opts out. `format` handles multi-document streams whole, re-emitting every document and its framing; `modify` is single-document by contract (a path names no particular document of a stream) and fails typed with `MultiDocumentStream` rather than guessing.
+- `YamlEdit` / `YamlFormat` — compute byte-minimal edit arrays for formatting and path-based modification, so a change preserves every comment and byte you did not touch; `preserveComments: false` opts out, and opt-in `requoteScalars` applies `quoteStyle` to scalars already quoted in the source, semantics-preserving or skipped. `format` handles multi-document streams whole, re-emitting every document and its framing; `modify` is single-document by contract (a path names no particular document of a stream) and fails typed with `MultiDocumentStream` rather than guessing.
 - `YamlVisitor` — walk a parsed document as a `Stream` of a tagged-enum event union, with `Stream.take` early termination on large inputs and a `placement` on every comment event.
 - `YamlToken` / `YamlTokens` — the positioned token stream the lint rules read: `tokenize` is a synchronous `Result` that always succeeds, surfacing lexical problems as `error`-kind tokens, and `stream` derives an Effect `Stream` from the same walk.
-- `YamlLint` — `run`, `fix` and the `builtins` catalog: 14 rules covering parse validity, line length, trailing whitespace, blank lines, end-of-file newline, document markers, duplicate keys, quoting, truthy spellings, comment and colon and hyphen spacing, and indentation.
-- `YamlLintConfig` / `YamlLintRule` / `YamlLintDiagnostic` — the `default` and `relaxed` presets, a config schema validated against the rule catalog, and the model a custom rule implements.
+- `YamlLint` — `run`, `fix` and the `builtins` catalog: 14 rules covering parse validity, line length, trailing whitespace, blank lines, end-of-file newline, document markers, duplicate keys, quoting, truthy spellings, comment and colon and hyphen spacing, and indentation. Plus config inference for adopting the linter on an existing corpus: `observe` produces mergeable `StyleEvidence`, `resolveStrict` fails typed with `YamlStyleConflictError` on conflicting spellings, `resolveLenient` picks the dominant style, and `inferStrict` / `inferLenient` do it in one step per text.
+- `YamlLintConfig` / `YamlLintRule` / `YamlLintDiagnostic` — the `default` and `relaxed` presets, a config schema validated against the rule catalog, and the model a custom rule implements, including the optional `infer` hook that lets a custom rule participate in config inference.
 - `YamlParseError` / `YamlStringifyError` / `YamlModificationError` — tagged errors carrying structured, positional `YamlDiagnostic` arrays rather than opaque messages.
 
 ## License

package/YamlFormat.js

@@ -6,6 +6,7 @@ import { YamlDiagnostic } from "./YamlDiagnostic.js";
 import { YamlStringifyOptions } from "./Yaml.js";
 import { YamlEdit, YamlRange } from "./YamlEdit.js";
 import { computeEdits } from "./internal/diff.js";
+import { requoteScalarText } from "./internal/requote.js";
 import { Effect, Schema } from "effect";
 
 //#region src/YamlFormat.ts
@@ -13,9 +14,25 @@ import { Effect, Schema } from "effect";
 * Options controlling formatting behavior: every {@link YamlStringifyOptions}
 * field (derived, not hand-duplicated — including `indentSequences` and
 * `quoteStyle`) plus
-* `preserveComments` (default `true`) and `range` (restrict edits to a
+* `preserveComments` (default `true`), `range` (restrict edits to a
 * region; see the module-level remarks on the `range` parameter vs. this
-* field).
+* field) and `requoteScalars` (default `false`).
+*
+* `requoteScalars` makes `quoteStyle` apply to scalars **already quoted in
+* the source** on the format path — by default formatting preserves an
+* existing scalar's own quote style, and `quoteStyle` governs only quotes the
+* stringifier introduces. When enabled, a re-quote happens only when it
+* provably preserves the parsed value: single→double applies proper
+* double-quote escaping, double→single is skipped whenever the value carries
+* characters single quotes cannot express (newlines, tabs, control and other
+* non-printable characters — single-quoted style can escape nothing but
+* `'`). Plain scalars stay plain, block scalars stay block, and scalars
+* carrying a tag or anchor — or spanning multiple source lines — are left
+* untouched. The option exists only where a source quote exists to re-quote:
+* it is read by {@link YamlFormat.format} / {@link YamlFormat.formatToString}
+* and is deliberately absent from `Yaml.stringify` (which serializes plain
+* values) and {@link YamlFormat.modify} (which takes a bare
+* {@link YamlStringifyOptions}).
 *
 * Construct with the validated `YamlFormattingOptions.make({ ... })` static —
 * the kit convention (never `new`). Call sites that take a
@@ -37,7 +54,8 @@ import { Effect, Schema } from "effect";
 var YamlFormattingOptions = class extends Schema.Class("YamlFormattingOptions")({
 	...YamlStringifyOptions.fields,
 	preserveComments: Schema.optionalKey(Schema.Boolean),
-	range: Schema.optionalKey(YamlRange)
+	range: Schema.optionalKey(YamlRange),
+	requoteScalars: Schema.optionalKey(Schema.Boolean)
 }) {};
 /**
 * Raised when `YamlFormat.modify` cannot navigate the requested path against
@@ -104,6 +122,49 @@ function definedFields(fields) {
 	for (const key of Object.keys(fields)) if (fields[key] !== void 0) out[key] = fields[key];
 	return out;
 }
+/**
+* Walk a composed AST and flip the `style` of every scalar the shared
+* escaping-mode helper deems re-quotable to the target quote's style. The
+* stringifier then emits those scalars through the very renderers the helper
+* used to prove the replacement value-preserving, so flip-and-stringify and
+* the helper's replacement text cannot disagree. Everything the helper skips
+* — plain scalars, block scalars, tagged/anchored nodes, multi-line source
+* spans, impossible double→single escapes — keeps its node untouched, and
+* the surrounding diff keeps the edit surgical per scalar span.
+*/
+function requoteNode(node, text, quote) {
+	if (node instanceof YamlScalar) {
+		if (requoteScalarText(text, node, quote, "escaping") === void 0) return node;
+		return YamlScalar.make({
+			value: node.value,
+			style: quote === "\"" ? "double-quoted" : "single-quoted",
+			...definedFields({
+				commentBefore: node.commentBefore,
+				comment: node.comment,
+				spaceBefore: node.spaceBefore,
+				raw: node.raw,
+				sourceMultiline: node.sourceMultiline
+			}),
+			offset: node.offset,
+			length: node.length
+		});
+	}
+	if (node instanceof YamlMap) return rebuildMap(node, node.items.map((pair) => YamlPair.make({
+		key: requoteNode(pair.key, text, quote),
+		value: pair.value === null ? null : requoteNode(pair.value, text, quote)
+	})));
+	if (node instanceof YamlSeq) return rebuildSeq(node, node.items.map((item) => requoteNode(item, text, quote)));
+	return node;
+}
+/** Apply the opt-in re-quoting pass to a composed document's contents. */
+function requoteDocument(doc, text, options) {
+	if (options?.requoteScalars !== true || doc.contents === null) return doc;
+	const quote = (options.quoteStyle ?? "single") === "double" ? "\"" : "'";
+	return {
+		...doc,
+		contents: requoteNode(doc.contents, text, quote)
+	};
+}
 /** Rebuild a composed document for re-emission, stripping comments when asked. */
 function toOutputDocument(doc, preserveComments) {
 	return {
@@ -132,12 +193,12 @@ function toOutputDocument(doc, preserveComments) {
 */
 function formatDocument(text, options) {
 	const { documents, streamErrors } = composeAllDocuments(text, {});
-	if (documents.length > 1) return formatStream(documents, streamErrors, options);
+	if (documents.length > 1) return formatStream(text, documents, streamErrors, options);
 	if (streamErrors.some((e) => isFatalCode(e.code))) return void 0;
 	const doc = documents[0] ?? EMPTY_DOCUMENT;
 	if (doc.errors.some((e) => isFatalCode(e.code))) return void 0;
 	if (doc.directives.length > 0) return void 0;
-	return stringifyDocument(toOutputDocument(doc, options?.preserveComments ?? true), toStringifyInput(options));
+	return stringifyDocument(toOutputDocument(requoteDocument(doc, text, options), options?.preserveComments ?? true), toStringifyInput(options));
 }
 /**
 * Format a multi-document stream: every document is re-emitted in order with
@@ -158,7 +219,7 @@ function formatDocument(text, options) {
 * line while keeping the dependent shorthand tags produced unparseable
 * output (probe-verified downstream against an independent oracle).
 */
-function formatStream(documents, streamErrors, options) {
+function formatStream(text, documents, streamErrors, options) {
 	if (streamErrors.some((e) => isFatalCode(e.code))) return void 0;
 	if (documents.some((d) => d.errors.some((e) => isFatalCode(e.code)))) return void 0;
 	if (documents.some((d) => d.directives.length > 0)) return void 0;
@@ -172,7 +233,7 @@ function formatStream(documents, streamErrors, options) {
 			...base,
 			finalNewline: true
 		} : base;
-		parts.push(stringifyDocument(toOutputDocument(doc, preserveComments), docOptions));
+		parts.push(stringifyDocument(toOutputDocument(requoteDocument(doc, text, options), preserveComments), docOptions));
 	}
 	return parts.join("");
 }
@@ -351,6 +412,12 @@ var YamlFormat = class YamlFormat {
 	* `{ offset, length }` object as well as a {@link YamlRange} instance, so
 	* callers do not need `YamlRange.make(...)` for the common case.
 	*
+	* Formatting preserves an existing scalar's own quote style by default —
+	* `quoteStyle` governs only quotes the stringifier introduces. The opt-in
+	* `options.requoteScalars` makes `quoteStyle` apply to already-quoted
+	* source scalars too, re-quoting only where the parsed value is provably
+	* preserved; see {@link YamlFormattingOptions} for the exact skip rules.
+	*
 	* A plain `<<` mapping key is preserved unquoted, keeping its merge-key
 	* meaning (`tag:yaml.org,2002:merge`) — quoting it to `'<<'` would produce
 	* an ordinary string key that merges nothing, changing what the document

package/YamlLintRule.js

@@ -31,6 +31,55 @@ var YamlLintDiagnostic = class extends Schema.Class("YamlLintDiagnostic")({
 	character: Schema.Number,
 	fix: Schema.optionalKey(YamlEdit)
 }) {};
+/**
+* One categorical style observation (#345): a single occurrence of a style
+* choice in the source, voting a `value` for an inference `dimension`.
+*
+* The `dimension` IS the rule's option key and the `value` IS that option's
+* value (`"double"` for `quoteType`, `2` for `spaces`, `false` for
+* `present`), so the inference resolvers can turn unanimous or dominant
+* votes into a config entry with no per-rule knowledge — which is what lets
+* custom rules participate in inference for free. The position points at the
+* occurrence that voted, so a strict-resolution conflict can name where each
+* spelling was seen.
+*
+* The `_tag` literal is the RUNTIME discriminator between the two
+* observation kinds: class instances are structurally assignable, so a
+* custom rule may yield a plain object shaped like a vote, and the evidence
+* builder must still sort it into the right tally without `instanceof`.
+* `.make` defaults it — construction sites never pass `_tag`.
+*
+* @public
+*/
+var StyleVote = class extends Schema.TaggedClass()("StyleVote", {
+	dimension: Schema.String,
+	value: Schema.Union([
+		Schema.String,
+		Schema.Number,
+		Schema.Boolean
+	]),
+	offset: Schema.Number,
+	length: Schema.Number,
+	line: Schema.Number,
+	character: Schema.Number
+}) {};
+/**
+* One measured style floor (#345): a value the source PROVES is at least
+* `value`, without proving what the configured limit should be — the longest
+* observed line proves `line-length.max` is at least that long, not what it
+* is. Floors are carried in the evidence for callers that want them and are
+* never resolved into config options; fabricating a max from the largest
+* value one happened to see would be lying with a straight face.
+*
+* The `_tag` literal discriminates a floor from a {@link StyleVote} at
+* runtime (see there); `.make` defaults it.
+*
+* @public
+*/
+var StyleFloor = class extends Schema.TaggedClass()("StyleFloor", {
+	dimension: Schema.String,
+	value: Schema.Number
+}) {};
 
 //#endregion
-export { YamlLintDiagnostic, YamlLintSeverity };
+export { StyleFloor, StyleVote, YamlLintDiagnostic, YamlLintSeverity };

package/index.d.ts

@@ -1009,14 +1009,31 @@ declare const YamlFormattingOptions_base: Schema.Class<YamlFormattingOptions, Sc
   readonly forceDefaultStyles: Schema.optionalKey<Schema.Boolean>;
   readonly preserveComments: Schema.optionalKey<Schema.Boolean>;
   readonly range: Schema.optionalKey<typeof YamlRange>;
+  readonly requoteScalars: Schema.optionalKey<Schema.Boolean>;
 }>, {}>;
 /**
  * Options controlling formatting behavior: every {@link YamlStringifyOptions}
  * field (derived, not hand-duplicated — including `indentSequences` and
  * `quoteStyle`) plus
- * `preserveComments` (default `true`) and `range` (restrict edits to a
+ * `preserveComments` (default `true`), `range` (restrict edits to a
  * region; see the module-level remarks on the `range` parameter vs. this
- * field).
+ * field) and `requoteScalars` (default `false`).
+ *
+ * `requoteScalars` makes `quoteStyle` apply to scalars **already quoted in
+ * the source** on the format path — by default formatting preserves an
+ * existing scalar's own quote style, and `quoteStyle` governs only quotes the
+ * stringifier introduces. When enabled, a re-quote happens only when it
+ * provably preserves the parsed value: single→double applies proper
+ * double-quote escaping, double→single is skipped whenever the value carries
+ * characters single quotes cannot express (newlines, tabs, control and other
+ * non-printable characters — single-quoted style can escape nothing but
+ * `'`). Plain scalars stay plain, block scalars stay block, and scalars
+ * carrying a tag or anchor — or spanning multiple source lines — are left
+ * untouched. The option exists only where a source quote exists to re-quote:
+ * it is read by {@link YamlFormat.format} / {@link YamlFormat.formatToString}
+ * and is deliberately absent from `Yaml.stringify` (which serializes plain
+ * values) and {@link YamlFormat.modify} (which takes a bare
+ * {@link YamlStringifyOptions}).
  *
  * Construct with the validated `YamlFormattingOptions.make({ ... })` static —
  * the kit convention (never `new`). Call sites that take a
@@ -1122,6 +1139,12 @@ declare class YamlFormat {
    * `{ offset, length }` object as well as a {@link YamlRange} instance, so
    * callers do not need `YamlRange.make(...)` for the common case.
    *
+   * Formatting preserves an existing scalar's own quote style by default —
+   * `quoteStyle` governs only quotes the stringifier introduces. The opt-in
+   * `options.requoteScalars` makes `quoteStyle` apply to already-quoted
+   * source scalars too, re-quoting only where the parsed value is provably
+   * preserved; see {@link YamlFormattingOptions} for the exact skip rules.
+   *
    * A plain `<<` mapping key is preserved unquoted, keeping its merge-key
    * meaning (`tag:yaml.org,2002:merge`) — quoting it to `'<<'` would produce
    * an ordinary string key that merges nothing, changing what the document
@@ -1337,6 +1360,60 @@ interface LintContext {
   readonly tokens: ReadonlyArray<YamlToken>;
   readonly document: YamlDocument;
 }
+declare const StyleVote_base: Schema.Class<StyleVote, Schema.TaggedStruct<"StyleVote", {
+  readonly dimension: Schema.String;
+  readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+  readonly offset: Schema.Number;
+  readonly length: Schema.Number;
+  readonly line: Schema.Number;
+  readonly character: Schema.Number;
+}>, {}>;
+/**
+ * One categorical style observation (#345): a single occurrence of a style
+ * choice in the source, voting a `value` for an inference `dimension`.
+ *
+ * The `dimension` IS the rule's option key and the `value` IS that option's
+ * value (`"double"` for `quoteType`, `2` for `spaces`, `false` for
+ * `present`), so the inference resolvers can turn unanimous or dominant
+ * votes into a config entry with no per-rule knowledge — which is what lets
+ * custom rules participate in inference for free. The position points at the
+ * occurrence that voted, so a strict-resolution conflict can name where each
+ * spelling was seen.
+ *
+ * The `_tag` literal is the RUNTIME discriminator between the two
+ * observation kinds: class instances are structurally assignable, so a
+ * custom rule may yield a plain object shaped like a vote, and the evidence
+ * builder must still sort it into the right tally without `instanceof`.
+ * `.make` defaults it — construction sites never pass `_tag`.
+ *
+ * @public
+ */
+declare class StyleVote extends StyleVote_base {}
+declare const StyleFloor_base: Schema.Class<StyleFloor, Schema.TaggedStruct<"StyleFloor", {
+  readonly dimension: Schema.String;
+  readonly value: Schema.Number;
+}>, {}>;
+/**
+ * One measured style floor (#345): a value the source PROVES is at least
+ * `value`, without proving what the configured limit should be — the longest
+ * observed line proves `line-length.max` is at least that long, not what it
+ * is. Floors are carried in the evidence for callers that want them and are
+ * never resolved into config options; fabricating a max from the largest
+ * value one happened to see would be lying with a straight face.
+ *
+ * The `_tag` literal discriminates a floor from a {@link StyleVote} at
+ * runtime (see there); `.make` defaults it.
+ *
+ * @public
+ */
+declare class StyleFloor extends StyleFloor_base {}
+/**
+ * What a rule's `infer` hook yields per occurrence: a categorical
+ * {@link StyleVote} or a measured {@link StyleFloor}.
+ *
+ * @public
+ */
+type StyleObservation = StyleVote | StyleFloor;
 /**
  * The public rule interface — built-ins and custom rules are the same
  * shape, and config references either by `id`; there is no privileged
@@ -1347,11 +1424,19 @@ interface LintContext {
  * rules receive options already validated against their exported options
  * schema, custom rules validate their own.
  *
+ * `infer` is the optional config-inference hook (#345): it reports the style
+ * the source already follows as per-occurrence {@link StyleObservation}s, so
+ * detection logic lives beside the check logic that polices the same
+ * dimension (and shares its fixtures). Rules with no detectable style — the
+ * policy rules, whose only evidence is violations — simply omit the hook and
+ * stay default-driven under every resolver.
+ *
  * @public
  */
 interface YamlRule {
   readonly id: string;
   readonly check: (ctx: LintContext, options: unknown) => Iterable<YamlLintDiagnostic>;
+  readonly infer?: (ctx: LintContext) => Iterable<StyleObservation>;
 }
 //#endregion
 //#region src/YamlLint.d.ts
@@ -1399,6 +1484,118 @@ declare class YamlLintConfig extends YamlLintConfig_base {
   /** The relaxed preset: style rules demoted to warnings. */
   static readonly relaxed: YamlLintConfig;
 }
+declare const StyleVoteTally_base: Schema.Class<StyleVoteTally, Schema.Struct<{
+  readonly rule: Schema.String;
+  readonly dimension: Schema.String;
+  readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+  readonly count: Schema.Number;
+  readonly offset: Schema.Number;
+  readonly length: Schema.Number;
+  readonly line: Schema.Number;
+  readonly character: Schema.Number;
+}>, {}>;
+/**
+ * An accumulated tally of one {@link StyleVote} spelling: how many times a
+ * `value` was voted for a `(rule, dimension)` pair, and the position of the
+ * FIRST occurrence seen (merging keeps the left operand's position, so on a
+ * multi-file merge the first file that exhibited the spelling names it).
+ *
+ * @public
+ */
+declare class StyleVoteTally extends StyleVoteTally_base {}
+declare const StyleFloorTally_base: Schema.Class<StyleFloorTally, Schema.Struct<{
+  readonly rule: Schema.String;
+  readonly dimension: Schema.String;
+  readonly value: Schema.Number;
+}>, {}>;
+/**
+ * An accumulated {@link StyleFloor} for a `(rule, dimension)` pair: the
+ * largest value the observed sources prove the limit is AT LEAST. Merging
+ * takes the maximum. Floors are informational — never resolved into config
+ * options (see {@link StyleFloor}).
+ *
+ * @public
+ */
+declare class StyleFloorTally extends StyleFloorTally_base {}
+declare const StyleEvidence_base: Schema.Class<StyleEvidence, Schema.Struct<{
+  readonly votes: Schema.$Array<typeof StyleVoteTally>;
+  readonly floors: Schema.$Array<typeof StyleFloorTally>;
+}>, {}>;
+/**
+ * Per-dimension style evidence (#345): what the observed sources say about
+ * each inferable `(rule, dimension)` — vote histograms with first-seen
+ * positions, and measured floors.
+ *
+ * Evidence is a MONOID: {@link StyleEvidence.empty} is the identity and
+ * {@link StyleEvidence.combine} is associative, so multi-file inference is
+ * observe-per-file, merge, resolve — and the N-file loop stays the caller's
+ * (no IO enters the package). `combine` normalizes: counts of the same
+ * `(rule, dimension, value)` add, the left operand's first-seen position
+ * wins, floors take the maximum, and the result is canonically sorted — so
+ * every value `observe`/`combine`/`fromObservations` produces is canonical
+ * and the monoid laws hold structurally over them.
+ *
+ * @public
+ */
+declare class StyleEvidence extends StyleEvidence_base {
+  /** The monoid identity: no observations. */
+  static readonly empty: StyleEvidence;
+  /**
+   * Merge two bodies of evidence (associative; {@link StyleEvidence.empty}
+   * is the identity). Vote counts add, the left operand's first-seen
+   * position wins per spelling, floors take the maximum.
+   */
+  static combine(a: StyleEvidence, b: StyleEvidence): StyleEvidence;
+  /**
+   * Build canonical evidence from one rule's raw observations — the
+   * homomorphism from observation lists into the monoid
+   * (`fromObservations(r, [...a, ...b])` equals
+   * `combine(fromObservations(r, a), fromObservations(r, b))`). `observe`
+   * uses it per rule; it is public so custom tooling can construct evidence
+   * without a {@link LintContext}.
+   */
+  static fromObservations(rule: string, observations: Iterable<StyleObservation>): StyleEvidence;
+}
+declare const StyleConflict_base: Schema.Class<StyleConflict, Schema.Struct<{
+  readonly rule: Schema.String;
+  readonly dimension: Schema.String;
+  readonly candidates: Schema.$Array<typeof StyleVoteTally>;
+}>, {}>;
+/**
+ * One strict-resolution conflict: a `(rule, dimension)` whose observed
+ * spellings disagree. `candidates` carries every spelling with its count and
+ * first-seen position, ordered by count descending (dominant first).
+ *
+ * @public
+ */
+declare class StyleConflict extends StyleConflict_base {}
+declare const YamlStyleConflictError_base: Schema.Class<YamlStyleConflictError, Schema.TaggedStruct<"YamlStyleConflictError", {
+  readonly conflicts: Schema.$Array<typeof StyleConflict>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised by strict config inference when observed evidence is not unanimous:
+ * carries every conflicting `(rule, dimension)` as a structured
+ * {@link StyleConflict} — dimension, all spellings, counts and positions —
+ * never a collapsed `reason` string (the structure-preserving-errors house
+ * rule). Unobserved dimensions never conflict: they fall back to the base
+ * config's defaults.
+ *
+ * @public
+ */
+declare class YamlStyleConflictError extends YamlStyleConflictError_base {
+  get message(): string;
+}
+/**
+ * A lenient inference report: the inferred config plus the residual — the
+ * diagnostics that config still produces on the observed text ("here is your
+ * config, and the places that do not match it").
+ *
+ * @public
+ */
+interface YamlLintInference {
+  readonly config: YamlLintConfig;
+  readonly residual: ReadonlyArray<YamlLintDiagnostic>;
+}
 /**
  * Linting statics. Not instantiable.
  *
@@ -1447,6 +1644,52 @@ declare class YamlLint {
    * is dropped (its diagnostic remains reported by {@link YamlLint.run}).
    */
   static fix(text: string, rules: ReadonlyArray<YamlRule>, config: YamlLintConfig): Result.Result<string, YamlParseError>;
+  /**
+   * Observe the style `text` already follows (#345): run every rule's
+   * optional `infer` hook over one eagerly-built context and merge the
+   * observations into canonical {@link StyleEvidence}. Pure and total —
+   * strings in, evidence out; observing N files is N `observe` calls merged
+   * with {@link StyleEvidence.combine}, and the N-file loop stays the
+   * caller's (no IO enters the package).
+   */
+  static observe(text: string, rules: ReadonlyArray<YamlRule>): StyleEvidence;
+  /**
+   * Strict resolution: every OBSERVED dimension must be unanimous, and the
+   * unanimous picks overlay `base` (default {@link YamlLintConfig.default})
+   * into an exact config. Conflicting evidence fails with
+   * {@link YamlStyleConflictError} naming every conflicting dimension, all
+   * spellings, counts and first-seen positions. Unobserved is NOT
+   * conflicting: a corpus with no comments says nothing about
+   * `comments-spacing`, so that dimension falls back to `base` rather than
+   * failing. A rule `base` sets to `"off"` stays off — an explicit disable
+   * outranks inference.
+   */
+  static resolveStrict(evidence: StyleEvidence, base?: YamlLintConfig): Result.Result<YamlLintConfig, YamlStyleConflictError>;
+  /**
+   * Lenient resolution: the dominant (plurality) spelling per observed
+   * dimension overlays `base` (default {@link YamlLintConfig.default}); a
+   * tie breaks deterministically to the first candidate in canonical
+   * value order. Total — lenient resolution cannot fail; the places that do
+   * not match the inferred config surface as the residual report (run the
+   * lint with the inferred config, or use {@link YamlLint.inferLenient}).
+   */
+  static resolveLenient(evidence: StyleEvidence, base?: YamlLintConfig): YamlLintConfig;
+  /**
+   * Single-text strict inference: `observe` then {@link YamlLint.resolveStrict}
+   * in one step. Multi-file callers observe each file and merge with
+   * {@link StyleEvidence.combine} before resolving.
+   */
+  static inferStrict(text: string, rules: ReadonlyArray<YamlRule>, base?: YamlLintConfig): Result.Result<YamlLintConfig, YamlStyleConflictError>;
+  /**
+   * Single-text lenient inference: `observe`, resolve dominant picks over
+   * `base`, then run the lint with the inferred config — returning the
+   * config AND the residual diagnostics it still produces ("here is your
+   * config, and the places that do not match it"). One context serves both
+   * the observation and the residual run. Multi-file callers compose the
+   * primitives instead: observe each file, {@link StyleEvidence.combine},
+   * {@link YamlLint.resolveLenient}, then {@link YamlLint.run} per file.
+   */
+  static inferLenient(text: string, rules: ReadonlyArray<YamlRule>, base?: YamlLintConfig): YamlLintInference;
 }
 //#endregion
 //#region src/YamlVisitor.d.ts
@@ -2051,5 +2294,5 @@ declare class YamlVisitor {
   static visit(text: string, options?: YamlParseOptions): Stream.Stream<YamlVisitorEvent>;
 }
 //#endregion
-export { CollectionStyle, type LintContext, type LintLine, QuoteStyle, ScalarChomp, ScalarStyle, Yaml, YamlAlias, type YamlAliasEncoded, type YamlBoundCodec, YamlComposerErrorCode, YamlDiagnostic, YamlDirective, YamlDocument, YamlEdit, YamlErrorCode, YamlFormat, YamlFormattingOptions, YamlLexErrorCode, YamlLint, YamlLintConfig, YamlLintDiagnostic, YamlLintRuleSetting, YamlLintSeverity, YamlMap, type YamlMapEncoded, YamlModificationError, YamlModifyErrorCode, YamlNode, YamlPair, YamlParseError, YamlParseErrorCode, YamlParseOptions, type YamlPath, YamlRange, type YamlRangeLike, type YamlRule, YamlScalar, type YamlScalarEncoded, type YamlSegment, YamlSeq, type YamlSeqEncoded, YamlStringifyError, YamlStringifyErrorCode, YamlStringifyOptions, YamlToken, YamlTokenKind, YamlTokens, YamlVisitor, YamlVisitorEvent };
+export { CollectionStyle, type LintContext, type LintLine, QuoteStyle, ScalarChomp, ScalarStyle, StyleConflict, StyleEvidence, StyleFloor, StyleFloorTally, type StyleObservation, StyleVote, StyleVoteTally, Yaml, YamlAlias, type YamlAliasEncoded, type YamlBoundCodec, YamlComposerErrorCode, YamlDiagnostic, YamlDirective, YamlDocument, YamlEdit, YamlErrorCode, YamlFormat, YamlFormattingOptions, YamlLexErrorCode, YamlLint, YamlLintConfig, YamlLintDiagnostic, type YamlLintInference, YamlLintRuleSetting, YamlLintSeverity, YamlMap, type YamlMapEncoded, YamlModificationError, YamlModifyErrorCode, YamlNode, YamlPair, YamlParseError, YamlParseErrorCode, YamlParseOptions, type YamlPath, YamlRange, type YamlRangeLike, type YamlRule, YamlScalar, type YamlScalarEncoded, type YamlSegment, YamlSeq, type YamlSeqEncoded, YamlStringifyError, YamlStringifyErrorCode, YamlStringifyOptions, YamlStyleConflictError, YamlToken, YamlTokenKind, YamlTokens, YamlVisitor, YamlVisitorEvent };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -4,9 +4,9 @@ import { Yaml, YamlParseError, YamlParseOptions, YamlStringifyError, YamlStringi
 import { YamlDirective, YamlDocument } from "./YamlDocument.js";
 import { YamlEdit, YamlRange } from "./YamlEdit.js";
 import { YamlFormat, YamlFormattingOptions, YamlModificationError } from "./YamlFormat.js";
-import { YamlLintDiagnostic, YamlLintSeverity } from "./YamlLintRule.js";
+import { StyleFloor, StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "./YamlLintRule.js";
 import { YamlToken, YamlTokenKind, YamlTokens } from "./YamlToken.js";
-import { YamlLint, YamlLintConfig, YamlLintRuleSetting } from "./YamlLint.js";
+import { StyleConflict, StyleEvidence, StyleFloorTally, StyleVoteTally, YamlLint, YamlLintConfig, YamlLintRuleSetting, YamlStyleConflictError } from "./YamlLint.js";
 import { YamlVisitor, YamlVisitorEvent } from "./YamlVisitor.js";
 
-export { CollectionStyle, QuoteStyle, ScalarChomp, ScalarStyle, Yaml, YamlAlias, YamlComposerErrorCode, YamlDiagnostic, YamlDirective, YamlDocument, YamlEdit, YamlErrorCode, YamlFormat, YamlFormattingOptions, YamlLexErrorCode, YamlLint, YamlLintConfig, YamlLintDiagnostic, YamlLintRuleSetting, YamlLintSeverity, YamlMap, YamlModificationError, YamlModifyErrorCode, YamlNode, YamlPair, YamlParseError, YamlParseErrorCode, YamlParseOptions, YamlRange, YamlScalar, YamlSeq, YamlStringifyError, YamlStringifyErrorCode, YamlStringifyOptions, YamlToken, YamlTokenKind, YamlTokens, YamlVisitor, YamlVisitorEvent };
+export { CollectionStyle, QuoteStyle, ScalarChomp, ScalarStyle, StyleConflict, StyleEvidence, StyleFloor, StyleFloorTally, StyleVote, StyleVoteTally, Yaml, YamlAlias, YamlComposerErrorCode, YamlDiagnostic, YamlDirective, YamlDocument, YamlEdit, YamlErrorCode, YamlFormat, YamlFormattingOptions, YamlLexErrorCode, YamlLint, YamlLintConfig, YamlLintDiagnostic, YamlLintRuleSetting, YamlLintSeverity, YamlMap, YamlModificationError, YamlModifyErrorCode, YamlNode, YamlPair, YamlParseError, YamlParseErrorCode, YamlParseOptions, YamlRange, YamlScalar, YamlSeq, YamlStringifyError, YamlStringifyErrorCode, YamlStringifyOptions, YamlStyleConflictError, YamlToken, YamlTokenKind, YamlTokens, YamlVisitor, YamlVisitorEvent };

package/internal/requote.js

@@ -0,0 +1,48 @@
+import { isControlChar } from "./fold.js";
+import { renderDoubleQuoted, renderSingleQuoted } from "./stringifier.js";
+
+//#region src/internal/requote.ts
+/**
+* True when `value` can be carried by a single-quoted flow scalar on one
+* line. Single-quoted style has exactly one escape (`''`), so any character
+* double-quote escape sequences exist to encode — newline, carriage return,
+* tab, C0 controls, DEL and the C1 range — has no single-quoted spelling and
+* makes the conversion impossible rather than lossy-but-tempting.
+*/
+function isSingleQuotable(value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code === 9 || code === 10 || code === 13) return false;
+		if (isControlChar(code)) return false;
+		if (code === 127 || code >= 128 && code <= 159) return false;
+	}
+	return true;
+}
+/**
+* The replacement raw text that re-quotes `scalar` with `quote`, or
+* `undefined` when no value-preserving replacement exists under `mode`
+* (skipping is always correct; corrupting never is).
+*/
+function requoteScalarText(text, scalar, quote, mode) {
+	if (scalar.tag !== void 0 || scalar.anchor !== void 0) return void 0;
+	if (typeof scalar.value !== "string") return void 0;
+	const raw = text.slice(scalar.offset, scalar.offset + scalar.length);
+	if (raw.includes("\n") || raw.includes("\r")) return void 0;
+	if (mode === "conservative") {
+		const inner = scalar.style === "plain" ? raw : raw.slice(1, -1);
+		if (inner !== scalar.value) return void 0;
+		if (inner.includes(quote)) return void 0;
+		if (quote === "\"" && inner.includes("\\")) return void 0;
+		return `${quote}${inner}${quote}`;
+	}
+	if (quote === "\"") {
+		if (scalar.style !== "single-quoted") return void 0;
+		return renderDoubleQuoted(scalar.value);
+	}
+	if (scalar.style !== "double-quoted") return void 0;
+	if (!isSingleQuotable(scalar.value)) return void 0;
+	return renderSingleQuoted(scalar.value);
+}
+
+//#endregion
+export { requoteScalarText };

package/internal/rules/comments-spacing.js

@@ -1,5 +1,5 @@
 import { YamlEdit } from "../../YamlEdit.js";
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
@@ -14,6 +14,25 @@ const commentsSpacingOptions = Schema.Struct({
 	minSpacesBefore: Schema.optionalKey(nonNegativeIntegerOption),
 	requireSpaceAfter: Schema.optionalKey(Schema.Boolean)
 });
+/**
+* The horizontal whitespace run directly before a comment token, and whether
+* line content precedes it (a TRAILING comment) — shared by the check and
+* the inference hook so the two cannot disagree about what "before" means.
+*/
+const spacingBefore = (ctx, token) => {
+	let i = token.offset - 1;
+	let spaces = 0;
+	while (i >= 0 && (ctx.text[i] === " " || ctx.text[i] === "	")) {
+		spaces++;
+		i--;
+	}
+	return {
+		spaces,
+		hasContentBefore: i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r"
+	};
+};
+/** Shebang exemption: `#!` at the very start of the stream. */
+const isShebang = (token) => token.offset === 0 && token.text.startsWith("#!");
 /** Comment spacing: after the `#`, and before a trailing comment's `#`. */
 const commentsSpacing = {
 	id: "comments-spacing",
@@ -24,7 +43,7 @@ const commentsSpacing = {
 		const out = [];
 		for (const token of ctx.tokens) {
 			if (token.kind !== "comment") continue;
-			if (token.offset === 0 && token.text.startsWith("#!")) continue;
+			if (isShebang(token)) continue;
 			if (requireAfter && token.text.length > 1 && !/[ \t]/.test(token.text[1])) out.push(new YamlLintDiagnostic({
 				rule: "comments-spacing",
 				severity: "error",
@@ -39,13 +58,8 @@ const commentsSpacing = {
 					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({
+			const { spaces, hasContentBefore } = spacingBefore(ctx, token);
+			if (hasContentBefore && spaces < minBefore) out.push(new YamlLintDiagnostic({
 				rule: "comments-spacing",
 				severity: "error",
 				message: `Too few spaces before comment (${spaces} < ${minBefore})`,
@@ -61,6 +75,31 @@ const commentsSpacing = {
 			}));
 		}
 		return out;
+	},
+	infer: (ctx) => {
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "comment") continue;
+			if (isShebang(token)) continue;
+			if (token.text.length > 1) out.push(StyleVote.make({
+				dimension: "requireSpaceAfter",
+				value: /[ \t]/.test(token.text[1]),
+				offset: token.offset,
+				length: token.length,
+				line: token.line,
+				character: token.character
+			}));
+			const { spaces, hasContentBefore } = spacingBefore(ctx, token);
+			if (hasContentBefore) out.push(StyleVote.make({
+				dimension: "minSpacesBefore",
+				value: spaces,
+				offset: token.offset - spaces,
+				length: spaces,
+				line: token.line,
+				character: token.character - spaces
+			}));
+		}
+		return out;
 	}
 };
 

package/internal/rules/document-end.js

@@ -1,5 +1,5 @@
 import { YamlEdit } from "../../YamlEdit.js";
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { Schema } from "effect";
 
 //#region src/internal/rules/document-end.ts
@@ -14,31 +14,43 @@ const TRIVIA = /* @__PURE__ */ new Set([
 	"comment",
 	"byte-order-mark"
 ]);
+/** The last non-trivia token: it decides whether the stream ends with `...`. */
+const tailToken = (ctx) => [...ctx.tokens].reverse().find((t) => !TRIVIA.has(t.kind));
+/**
+* The end-of-stream position, shared by the missing-marker diagnostic and
+* the absent-marker vote so the two cannot drift apart. `line`/`character`
+* must agree with `offset` (= text length): when the text ends with a
+* newline, that offset sits at the head of the line AFTER the last content
+* line `buildLines` kept.
+*/
+const endOfStreamPosition = (ctx) => {
+	const lastLine = ctx.lines[ctx.lines.length - 1];
+	const trailingNewline = ctx.text.endsWith("\n");
+	return {
+		offset: ctx.text.length,
+		length: 0,
+		line: (lastLine?.number ?? 0) + (trailingNewline ? 1 : 0),
+		character: trailingNewline ? 0 : lastLine?.text.length ?? 0
+	};
+};
 /** The `...` marker at the tail of the stream. */
 const documentEnd = {
 	id: "document-end",
 	check: (ctx, options) => {
 		const present = options?.present ?? true;
-		const tail = [...ctx.tokens].reverse().find((t) => !TRIVIA.has(t.kind));
+		const tail = tailToken(ctx);
 		const ended = tail?.kind === "document-end";
-		if (present && !ended && ctx.text.trim() !== "") {
-			const lastLine = ctx.lines[ctx.lines.length - 1];
-			const trailingNewline = ctx.text.endsWith("\n");
-			return [new YamlLintDiagnostic({
-				rule: "document-end",
-				severity: "error",
-				message: "Missing \"...\" document end marker",
+		if (present && !ended && ctx.text.trim() !== "") return [new YamlLintDiagnostic({
+			rule: "document-end",
+			severity: "error",
+			message: "Missing \"...\" document end marker",
+			...endOfStreamPosition(ctx),
+			fix: YamlEdit.make({
 				offset: ctx.text.length,
 				length: 0,
-				line: (lastLine?.number ?? 0) + (trailingNewline ? 1 : 0),
-				character: trailingNewline ? 0 : lastLine?.text.length ?? 0,
-				fix: YamlEdit.make({
-					offset: ctx.text.length,
-					length: 0,
-					content: ctx.text.endsWith("\n") ? "...\n" : "\n...\n"
-				})
-			})];
-		}
+				content: ctx.text.endsWith("\n") ? "...\n" : "\n...\n"
+			})
+		})];
 		if (!present && tail !== void 0 && tail.kind === "document-end") {
 			const alone = (ctx.lines[tail.line]?.text ?? "").trim() === "...";
 			const terminator = ctx.text.startsWith("\r\n", tail.offset + tail.length) ? 2 : 1;
@@ -58,6 +70,24 @@ const documentEnd = {
 			})];
 		}
 		return [];
+	},
+	infer: (ctx) => {
+		if (ctx.text.trim() === "") return [];
+		const tail = tailToken(ctx);
+		if (tail === void 0) return [];
+		if (tail.kind === "document-end") return [StyleVote.make({
+			dimension: "present",
+			value: true,
+			offset: tail.offset,
+			length: tail.length,
+			line: tail.line,
+			character: tail.character
+		})];
+		return [StyleVote.make({
+			dimension: "present",
+			value: false,
+			...endOfStreamPosition(ctx)
+		})];
 	}
 };
 

package/internal/rules/document-start.js

@@ -1,5 +1,5 @@
 import { YamlEdit } from "../../YamlEdit.js";
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { Schema } from "effect";
 
 //#region src/internal/rules/document-start.ts
@@ -15,13 +15,17 @@ const TRIVIA = /* @__PURE__ */ new Set([
 	"byte-order-mark",
 	"directive"
 ]);
+/** True when the stream carries `%YAML`/`%TAG` directives — which REQUIRE `---`. */
+const hasDirectives = (ctx) => ctx.tokens.some((t) => t.kind === "directive");
+/** The first non-trivia token: it decides whether the stream is headed by `---`. */
+const headToken = (ctx) => ctx.tokens.find((t) => !TRIVIA.has(t.kind));
 /** The `---` marker at the head of the stream. */
 const documentStart = {
 	id: "document-start",
 	check: (ctx, options) => {
 		const present = options?.present ?? true;
-		const hasDirectives = ctx.tokens.some((t) => t.kind === "directive");
-		const first = ctx.tokens.find((t) => !TRIVIA.has(t.kind));
+		const directives = hasDirectives(ctx);
+		const first = headToken(ctx);
 		const headed = first?.kind === "document-start";
 		if (present && !headed && ctx.text.trim() !== "") return [new YamlLintDiagnostic({
 			rule: "document-start",
@@ -31,7 +35,7 @@ const documentStart = {
 			length: 0,
 			line: 0,
 			character: 0,
-			...hasDirectives ? {} : { fix: YamlEdit.make({
+			...directives ? {} : { fix: YamlEdit.make({
 				offset: 0,
 				length: 0,
 				content: "---\n"
@@ -39,7 +43,7 @@ const documentStart = {
 		})];
 		if (!present && headed && first !== void 0) {
 			const lineText = ctx.lines[first.line]?.text ?? "";
-			const alone = !hasDirectives && lineText.trim() === "---";
+			const alone = !directives && lineText.trim() === "---";
 			const terminator = ctx.text.startsWith("\r\n", first.offset + first.length) ? 2 : 1;
 			return [new YamlLintDiagnostic({
 				rule: "document-start",
@@ -57,6 +61,28 @@ const documentStart = {
 			})];
 		}
 		return [];
+	},
+	infer: (ctx) => {
+		if (ctx.text.trim() === "") return [];
+		const first = headToken(ctx);
+		if (first === void 0) return [];
+		const headed = first.kind === "document-start";
+		if (!headed && hasDirectives(ctx)) return [];
+		return [StyleVote.make(headed ? {
+			dimension: "present",
+			value: true,
+			offset: first.offset,
+			length: first.length,
+			line: first.line,
+			character: first.character
+		} : {
+			dimension: "present",
+			value: false,
+			offset: 0,
+			length: 0,
+			line: 0,
+			character: 0
+		})];
 	}
 };
 

package/internal/rules/empty-lines.js

@@ -1,5 +1,5 @@
 import { YamlEdit } from "../../YamlEdit.js";
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { StyleFloor, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { insideScalarSpan, nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
@@ -63,6 +63,26 @@ const emptyLines = {
 			i = end;
 		}
 		return out;
+	},
+	infer: (ctx) => {
+		let longest = 0;
+		const lines = ctx.lines;
+		let i = 0;
+		while (i < lines.length) {
+			const line = lines[i];
+			if (line === void 0 || line.text !== "" || insideScalarSpan(ctx.tokens, line.offset)) {
+				i++;
+				continue;
+			}
+			let end = i;
+			while (end < lines.length && (lines[end]?.text ?? "x") === "") end++;
+			if (i !== 0 && end !== lines.length && end - i > longest) longest = end - i;
+			i = end;
+		}
+		return longest > 0 ? [StyleFloor.make({
+			dimension: "max",
+			value: longest
+		})] : [];
 	}
 };
 

package/internal/rules/indentation.js

@@ -1,4 +1,4 @@
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { coveringToken, isScalarContinuationLine, nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
@@ -30,6 +30,44 @@ const flowDepthAtLineStarts = (ctx) => {
 	}
 	return depths;
 };
+/**
+* The content lines block structure speaks about — shared by the check and
+* the inference hook so the two read the same lines. Skips blanks, comment
+* lines, directives, tab-indented lines (the parser's error), lines inside
+* flow collections, scalar continuations and document markers.
+*/
+const contentLines = (ctx) => {
+	const flowDepths = flowDepthAtLineStarts(ctx);
+	const content = [];
+	for (const line of ctx.lines) {
+		const indent = line.text.length - line.text.trimStart().length;
+		const firstChar = line.text[indent];
+		if (firstChar === void 0) continue;
+		if (firstChar === "#") continue;
+		if (firstChar === "%") continue;
+		if (line.text.slice(0, indent).includes("	")) continue;
+		if ((flowDepths[line.number] ?? 0) > 0) continue;
+		if (isScalarContinuationLine(ctx.tokens, line.offset, line.offset + indent)) continue;
+		if (line.text.slice(indent).startsWith("---") || line.text.slice(indent).startsWith("...")) continue;
+		content.push({
+			line,
+			indent,
+			firstChar
+		});
+	}
+	return content;
+};
+/**
+* True when consecutive content lines `prev` → `curr` are a mapping key
+* followed by a sequence entry — the pair the `indentSequences` policy is
+* about. Shared by the check and the inference hook.
+*/
+const isKeyThenSeqEntry = (ctx, prev, curr, unit) => {
+	if (curr.firstChar !== "-") return false;
+	if (coveringToken(ctx.tokens, curr.line.offset + curr.indent)?.kind !== "block-seq-entry") return false;
+	if (!prev.line.text.replace(/ #.*$/, "").trimEnd().endsWith(":")) return false;
+	return curr.indent === prev.indent || curr.indent === prev.indent + (unit ?? curr.indent - prev.indent);
+};
 /** Block-structure indent style. */
 const indentation = {
 	id: "indentation",
@@ -38,24 +76,7 @@ const indentation = {
 		const spacesOpt = opts.spaces ?? "consistent";
 		const seqOpt = opts.indentSequences ?? "consistent";
 		const out = [];
-		const flowDepths = flowDepthAtLineStarts(ctx);
-		const content = [];
-		for (const line of ctx.lines) {
-			const indent = line.text.length - line.text.trimStart().length;
-			const firstChar = line.text[indent];
-			if (firstChar === void 0) continue;
-			if (firstChar === "#") continue;
-			if (firstChar === "%") continue;
-			if (line.text.slice(0, indent).includes("	")) continue;
-			if ((flowDepths[line.number] ?? 0) > 0) continue;
-			if (isScalarContinuationLine(ctx.tokens, line.offset, line.offset + indent)) continue;
-			if (line.text.slice(indent).startsWith("---") || line.text.slice(indent).startsWith("...")) continue;
-			content.push({
-				line,
-				indent,
-				firstChar
-			});
-		}
+		const content = contentLines(ctx);
 		let unit = typeof spacesOpt === "number" ? spacesOpt : void 0;
 		const stack = [0];
 		for (const { line, indent } of content) {
@@ -79,10 +100,7 @@ const indentation = {
 		for (let i = 1; i < content.length; i++) {
 			const prev = content[i - 1];
 			const curr = content[i];
-			if (curr.firstChar !== "-") continue;
-			if (coveringToken(ctx.tokens, curr.line.offset + curr.indent)?.kind !== "block-seq-entry") continue;
-			if (!prev.line.text.replace(/ #.*$/, "").trimEnd().endsWith(":")) continue;
-			if (curr.indent !== prev.indent && curr.indent !== prev.indent + (unit ?? curr.indent - prev.indent)) continue;
+			if (!isKeyThenSeqEntry(ctx, prev, curr, unit)) continue;
 			const indented = curr.indent > prev.indent;
 			if (seqIndented === void 0) seqIndented = indented;
 			else if (indented !== seqIndented) out.push(new YamlLintDiagnostic({
@@ -96,6 +114,41 @@ const indentation = {
 			}));
 		}
 		return out;
+	},
+	infer: (ctx) => {
+		const out = [];
+		const content = contentLines(ctx);
+		let unit;
+		const stack = [0];
+		for (const { line, indent } of content) {
+			const top = stack[stack.length - 1];
+			if (indent > top) {
+				out.push(StyleVote.make({
+					dimension: "spaces",
+					value: indent - top,
+					offset: line.offset,
+					length: indent,
+					line: line.number,
+					character: 0
+				}));
+				if (unit === void 0) unit = indent - top;
+				stack.push(indent);
+			} else if (indent < top) while (stack.length > 1 && stack[stack.length - 1] > indent) stack.pop();
+		}
+		for (let i = 1; i < content.length; i++) {
+			const prev = content[i - 1];
+			const curr = content[i];
+			if (!isKeyThenSeqEntry(ctx, prev, curr, unit)) continue;
+			out.push(StyleVote.make({
+				dimension: "indentSequences",
+				value: curr.indent > prev.indent,
+				offset: curr.line.offset,
+				length: curr.indent,
+				line: curr.line.number,
+				character: 0
+			}));
+		}
+		return out;
 	}
 };
 

package/internal/rules/line-length.js

@@ -1,4 +1,4 @@
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { StyleFloor, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
@@ -29,6 +29,14 @@ const lineLength = {
 			character: max
 		}));
 		return out;
+	},
+	infer: (ctx) => {
+		let longest = 0;
+		for (const line of ctx.lines) if (line.text.length > longest) longest = line.text.length;
+		return longest > 0 ? [StyleFloor.make({
+			dimension: "max",
+			value: longest
+		})] : [];
 	}
 };
 

package/internal/rules/quoted-strings.js

@@ -1,5 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
-import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { requoteScalarText } from "../requote.js";
+import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { positionAt, walkScalars } from "./util.js";
 import { Schema } from "effect";
 
@@ -14,20 +15,19 @@ const quotedStringsOptions = Schema.Struct({
 	quoteType: Schema.optionalKey(Schema.Literals(["single", "double"])),
 	required: Schema.optionalKey(Schema.Boolean)
 });
-/** A value-preserving requote/wrap edit, or undefined when none is safe. */
+/**
+* A value-preserving requote/wrap edit, or undefined when none is safe.
+* Delegates to the shared helper's CONSERVATIVE mode (#347) — the shipped
+* fix behavior stays exactly as released; the escaping-capable mode belongs
+* to the format path's opt-in `requoteScalars`, not the lint fix.
+*/
 const safeQuoteFix = (ctx, scalar, quote) => {
-	if (scalar.tag !== void 0 || scalar.anchor !== void 0) return void 0;
-	if (typeof scalar.value !== "string") return void 0;
-	const raw = ctx.text.slice(scalar.offset, scalar.offset + scalar.length);
-	if (raw.includes("\n")) return void 0;
-	const inner = scalar.style === "plain" ? raw : raw.slice(1, -1);
-	if (inner !== scalar.value) return void 0;
-	if (inner.includes(quote)) return void 0;
-	if (quote === "\"" && inner.includes("\\")) return void 0;
+	const content = requoteScalarText(ctx.text, scalar, quote, "conservative");
+	if (content === void 0) return void 0;
 	return YamlEdit.make({
 		offset: scalar.offset,
 		length: scalar.length,
-		content: `${quote}${inner}${quote}`
+		content
 	});
 };
 /** Quote-style policy for string value scalars. */
@@ -74,6 +74,24 @@ const quotedStrings = {
 			}
 		});
 		return out;
+	},
+	infer: (ctx) => {
+		const out = [];
+		walkScalars(ctx.document.contents, "root", (scalar, role) => {
+			if (role === "key") return;
+			if (typeof scalar.value !== "string") return;
+			if (scalar.style !== "single-quoted" && scalar.style !== "double-quoted") return;
+			const pos = positionAt(ctx.lines, scalar.offset);
+			out.push(StyleVote.make({
+				dimension: "quoteType",
+				value: scalar.style === "single-quoted" ? "single" : "double",
+				offset: scalar.offset,
+				length: scalar.length,
+				line: pos.line,
+				character: pos.character
+			}));
+		});
+		return out;
 	}
 };
 

package/internal/stringifier.js

@@ -1134,4 +1134,4 @@ function stringifyDocument(doc, options) {
 }
 
 //#endregion
-export { StringifyDepthExceeded, StringifyFailure, stringifyDocument, stringifyValue, stripNodeComments };
+export { StringifyDepthExceeded, StringifyFailure, renderDoubleQuoted, renderSingleQuoted, stringifyDocument, stringifyValue, stripNodeComments };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/yaml",
-	"version": "0.10.0",
+	"version": "0.11.0",
 	"private": false,
 	"description": "Zero-dependency YAML parsing, editing, formatting and linting as Effect schemas.",
 	"keywords": [

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.12"
+      "packageVersion": "7.59.0"
     }
   ]
 }