@effected/yaml 0.11.0 → 0.13.0

package/README.md

@@ -193,10 +193,29 @@ The `requoteScalars: true` half of the `singleQuote` row is what buys full parit
 
 Multi-document streams — a Kubernetes manifest, or the two-document `pnpm-lock.yaml` pnpm 11 writes under `configDependencies` — format whole: every document is re-emitted in order with its own `---`/`...` framing and comments, so no document is ever dropped. Document detection is CST-level, so a `---` inside a block scalar or quoted string is content and formats normally. The formatter leaves input byte-identical rather than corrupting it in exactly two cases: a fatal parse error in any document, and a stream carrying `%YAML`/`%TAG` directives (which the emitter cannot re-emit faithfully). Validate a whole stream with `Yaml.parseAllResult`, which fails typed when any document carries a fatal diagnostic; `YamlFormat.modify` stays single-document, since a path names no particular document of a stream.
 
+## Emitting for a YAML 1.1 consumer
+
+YAML 1.2's Core Schema resolves fewer plain scalars to non-strings than YAML 1.1 does. A plain `on` or `yes` round-trips as a string under this package's own parser but becomes a boolean the moment a YAML 1.1 consumer — js-yaml, PyYAML, libyaml, the `yaml` npm package's YAML 1.1 schema, most CI systems' native YAML support — reads it back: the "Norway problem". `quoteCompat: "yaml-1.1"` closes that gap on the way out, quoting every plain scalar a 1.1 resolver would re-type: the extended booleans (`y`/`yes`/`no`/`on`/`off` and case variants), 1.1 timestamps, sexagesimal numbers (`1:30`), underscore-grouped numbers (`1_000`) and the octal/hex/binary integer forms (`0777`, `0x_FF`, `0b1010_0111`). It is strictly additive — nothing the 1.2 rules already quote loses a quote, and no string outside that list gains one — and composes with `quoteStyle` for the quote character and `lineWidth` for folding:
+
+```ts
+import { Yaml, YamlStringifyOptions } from "@effected/yaml";
+import { Effect } from "effect";
+
+const frontmatter = { node: "on", released: "2024-01-15", port: "yes" };
+const options = YamlStringifyOptions.make({ lineWidth: 0, quoteCompat: "yaml-1.1", quoteStyle: "double" });
+
+Effect.runPromise(Yaml.stringify(frontmatter, options)).then(console.log);
+// node: "on"
+// released: "2024-01-15"
+// port: "yes"
+```
+
+That combination — `lineWidth: 0` (no folding), `quoteCompat: "yaml-1.1"`, `quoteStyle: "double"` — is the shape to reach for when stringifying frontmatter destined for YAML-1.1 tooling: Markdown frontmatter parsers and most static-site generators still resolve on the older rules. The option applies on both the value path (`Yaml.stringify`, `Yaml.stringifyResult`) and the node path (`YamlDocument#stringify`, `YamlFormat`), and scalars carrying an explicit tag are exempt, exactly like the 1.2 type-conflict check it extends.
+
 ## Features
 
 - `Yaml.parse` / `Yaml.parseAll` — error-recovery parsing of a single document or a `---`-separated stream into plain values, resolving anchors and aliases and aggregating every diagnostic into one `YamlParseError`.
-- `Yaml.stringify` — serialize a plain value back to YAML, failing typed with `YamlStringifyError` on circular references or on excessively deep nesting; a block-mapping key too long to render on one line spills into explicit-key form (`? key` / `: value`) so strict parsers still accept the output.
+- `Yaml.stringify` — serialize a plain value back to YAML, failing typed with `YamlStringifyError` on circular references or on excessively deep nesting; a block-mapping key too long to render on one line spills into explicit-key form (`? key` / `: value`) so strict parsers still accept the output; `quoteCompat: "yaml-1.1"` additionally quotes plain scalars a YAML 1.1 resolver would re-type.
 - `Yaml.parseResult` / `Yaml.parseAllResult` / `Yaml.stringifyResult` — the pure synchronous counterparts, returning a `Result` instead of an `Effect` for config-time callers that cannot await; each runs the same engine call as its `Effect` variant, so the two forms cannot diverge, and a fatal diagnostic, a duplicate key, an alias bomb or a circular reference still fails typed rather than throwing. `parseAllResult` doubles as a whole-stream validity check: it fails when any document in the stream is invalid.
 - `Yaml.stripComments` — quote-aware comment removal that keeps line numbers stable, or every byte offset stable when given a replacement character.
 - `Yaml.equals` / `Yaml.equalsValue` — semantic equality that ignores comments, whitespace, formatting and mapping key order while keeping sequence order significant.

package/Yaml.js

@@ -1,4 +1,4 @@
-import { AliasExpansionBudgetExceeded, CollectionStyle, QuoteStyle, ScalarStyle, nodeToJsValue } from "./YamlNode.js";
+import { AliasExpansionBudgetExceeded, CollectionStyle, QuoteCompat, QuoteStyle, ScalarStyle, nodeToJsValue } from "./YamlNode.js";
 import { composeAllDocuments, composeFirstDocument } from "./internal/composer/document.js";
 import { isFatalCode } from "./internal/diagnostics.js";
 import { StringifyDepthExceeded, StringifyFailure, stringifyValue } from "./internal/stringifier.js";
@@ -35,8 +35,9 @@ var YamlParseOptions = class extends Schema.Class("YamlParseOptions")({
 * Options controlling stringify behavior. All fields are omissible; absent
 * fields resolve to `indent` `2`, `lineWidth` `0`, `defaultScalarStyle`
 * `"plain"`, `defaultCollectionStyle` `"block"`, `sortKeys` `false`,
-* `indentSequences` `false`, `quoteStyle` `"single"`, `finalNewline` `true`
-* and `forceDefaultStyles` `false`.
+* `indentSequences` `false`, `quoteStyle` `"single"`, `quoteCompat` absent
+* (no dialect-compat quoting), `finalNewline` `true` and `forceDefaultStyles`
+* `false`.
 *
 * `lineWidth` controls column-based scalar folding. The default `0` (and any
 * value `<= 0`) never wraps, emitting byte-identical output to the historic
@@ -114,6 +115,33 @@ var YamlStringifyOptions = class extends Schema.Class("YamlStringifyOptions")({
 	* `"double-quoted"` is unaffected.
 	*/
 	quoteStyle: Schema.optionalKey(QuoteStyle),
+	/**
+	* Additionally quote plain scalars a foreign resolution dialect would
+	* coerce to a non-string. Absent (the default) adds no quoting beyond the
+	* YAML 1.2 Core Schema rules — byte-identical to the released output.
+	*
+	* `"yaml-1.1"` quotes every plain scalar a YAML 1.1 parser (js-yaml,
+	* PyYAML, libyaml, and the `yaml` npm package's YAML 1.1 schema, whose
+	* lenient resolvers set the outer bound) would implicitly resolve to a
+	* non-string: the extended
+	* boolean spellings (`y`/`yes`/`on`/`off` and case variants — the "Norway
+	* problem"), timestamps (`2024-01-15`, `2001-12-15T02:59:43.1Z`, the
+	* space-separated 1.1 forms), sexagesimal numbers (`1:30`,
+	* `190:20:30.15`), underscore-separated numbers (`1_000`) and the
+	* base-2/8/16 integer forms (`0b1010_0111`, `0777`, `0x_FF`). Use it when
+	* emitted output is parsed downstream by a YAML 1.1 consumer and blanket
+	* `defaultScalarStyle` quoting is too noisy.
+	*
+	* Strictly additive: it never un-quotes anything the 1.2 rules require
+	* quoted, strings no 1.1 parser coerces stay plain, and the quote
+	* character stays governed by `quoteStyle`. Scalars carrying an explicit
+	* tag are exempt, exactly like the 1.2 type-conflict check. Applies
+	* wherever the plain fallback renders — values, mapping keys, flow items —
+	* on both the value path ({@link Yaml.stringify},
+	* {@link Yaml.stringifyResult}) and the node path (`YamlDocument#stringify`
+	* and the `YamlFormat` helpers).
+	*/
+	quoteCompat: Schema.optionalKey(QuoteCompat),
 	finalNewline: Schema.optionalKey(Schema.Boolean),
 	forceDefaultStyles: Schema.optionalKey(Schema.Boolean)
 }) {};
@@ -167,6 +195,7 @@ const toStringifyInput = (options) => options === void 0 ? {} : {
 	sortKeys: options.sortKeys,
 	indentSequences: options.indentSequences,
 	quoteStyle: options.quoteStyle,
+	quoteCompat: options.quoteCompat,
 	finalNewline: options.finalNewline,
 	forceDefaultStyles: options.forceDefaultStyles
 };

package/YamlDocument.js

@@ -163,6 +163,8 @@ const toStringifyInput = (options) => options === void 0 ? {} : {
 	defaultCollectionStyle: options.defaultCollectionStyle,
 	sortKeys: options.sortKeys,
 	indentSequences: options.indentSequences,
+	quoteStyle: options.quoteStyle,
+	quoteCompat: options.quoteCompat,
 	finalNewline: options.finalNewline,
 	forceDefaultStyles: options.forceDefaultStyles
 };

package/YamlFormat.js

@@ -12,8 +12,8 @@ import { Effect, Schema } from "effect";
 //#region src/YamlFormat.ts
 /**
 * Options controlling formatting behavior: every {@link YamlStringifyOptions}
-* field (derived, not hand-duplicated — including `indentSequences` and
-* `quoteStyle`) plus
+* field (derived, not hand-duplicated — including `indentSequences`,
+* `quoteStyle` and `quoteCompat`) plus
 * `preserveComments` (default `true`), `range` (restrict edits to a
 * region; see the module-level remarks on the `range` parameter vs. this
 * field) and `requoteScalars` (default `false`).
@@ -105,6 +105,7 @@ const toStringifyInput = (options) => options === void 0 ? {} : {
 	sortKeys: options.sortKeys,
 	indentSequences: options.indentSequences,
 	quoteStyle: options.quoteStyle,
+	quoteCompat: options.quoteCompat,
 	finalNewline: options.finalNewline,
 	forceDefaultStyles: options.forceDefaultStyles
 };

package/YamlNode.js

@@ -30,6 +30,21 @@ const CollectionStyle = Schema.Literals(["block", "flow"]);
 */
 const QuoteStyle = Schema.Literals(["single", "double"]);
 /**
+* Foreign resolution dialects the stringifier's plain-scalar fallback can
+* defend against: setting the `quoteCompat` field of `YamlStringifyOptions`
+* to `"yaml-1.1"` additionally quotes every plain scalar a YAML 1.1 parser
+* (js-yaml, PyYAML, libyaml, and the `yaml` npm package's YAML 1.1 schema,
+* whose lenient resolvers set the outer bound) would implicitly resolve to a
+* non-string —
+* `yes`/`no`/`on`/`off` booleans, ISO 8601 and space-separated timestamps,
+* sexagesimal `1:30`, underscored `1_000` and base-2/8/16 numbers. Like
+* `QuoteStyle` it is a stringify-option vocabulary, never a property of a
+* composed node.
+*
+* @public
+*/
+const QuoteCompat = Schema.Literals(["yaml-1.1"]);
+/**
 * Block-scalar chomping indicators (`-` strip, default clip, `+` keep).
 * Referenced by the {@link YamlScalar} `chomp` field schema.
 *
@@ -442,4 +457,4 @@ function nodeToValue(node, anchors, budget, counting = false) {
 }
 
 //#endregion
-export { AliasExpansionBudgetExceeded, CollectionStyle, QuoteStyle, ScalarChomp, ScalarStyle, YamlAlias, YamlMap, YamlNode, YamlPair, YamlScalar, YamlSeq, aliasExpansionLimit, nodeToJsValue };
+export { AliasExpansionBudgetExceeded, CollectionStyle, QuoteCompat, QuoteStyle, ScalarChomp, ScalarStyle, YamlAlias, YamlMap, YamlNode, YamlPair, YamlScalar, YamlSeq, aliasExpansionLimit, nodeToJsValue };

package/index.d.ts

@@ -5,75 +5,75 @@ import { Data, Effect, Option, Result, Schema, Stream } from "effect";
  *
  * @public
  */
-declare const YamlLexErrorCode: Schema.Literals<readonly ["UnexpectedCharacter", "UnterminatedString", "InvalidEscapeSequence", "InvalidUnicode", "UnterminatedBlockScalar", "UnterminatedFlowCollection", "InvalidDirective", "InvalidTagHandle", "InvalidAnchorName", "UnexpectedByteOrderMark"]>;
+export declare const YamlLexErrorCode: Schema.Literals<readonly ["UnexpectedCharacter", "UnterminatedString", "InvalidEscapeSequence", "InvalidUnicode", "UnterminatedBlockScalar", "UnterminatedFlowCollection", "InvalidDirective", "InvalidTagHandle", "InvalidAnchorName", "UnexpectedByteOrderMark"]>;
 /**
  * The union of all lexer-stage error code string literals.
  *
  * @public
  */
-type YamlLexErrorCode = typeof YamlLexErrorCode.Type;
+export type YamlLexErrorCode = typeof YamlLexErrorCode.Type;
 /**
  * Error codes emitted by the CST-parser stage.
  *
  * @public
  */
-declare const YamlParseErrorCode: Schema.Literals<readonly ["InvalidIndentation", "DuplicateKey", "UnexpectedToken", "MissingValue", "MissingKey", "TabIndentation", "InvalidBlockStructure", "MalformedFlowCollection", "NestingDepthExceeded"]>;
+export declare const YamlParseErrorCode: Schema.Literals<readonly ["InvalidIndentation", "DuplicateKey", "UnexpectedToken", "MissingValue", "MissingKey", "TabIndentation", "InvalidBlockStructure", "MalformedFlowCollection", "NestingDepthExceeded"]>;
 /**
  * The union of all parser-stage error code string literals.
  *
  * @public
  */
-type YamlParseErrorCode = typeof YamlParseErrorCode.Type;
+export type YamlParseErrorCode = typeof YamlParseErrorCode.Type;
 /**
  * Error codes emitted by the composer stage.
  *
  * @public
  */
-declare const YamlComposerErrorCode: Schema.Literals<readonly ["UndefinedAlias", "DuplicateAnchor", "CircularAlias", "UnresolvedTag", "InvalidTagValue", "AliasCountExceeded", "InvalidDirective"]>;
+export declare const YamlComposerErrorCode: Schema.Literals<readonly ["UndefinedAlias", "DuplicateAnchor", "CircularAlias", "UnresolvedTag", "InvalidTagValue", "AliasCountExceeded", "InvalidDirective"]>;
 /**
  * The union of all composer-stage error code string literals.
  *
  * @public
  */
-type YamlComposerErrorCode = typeof YamlComposerErrorCode.Type;
+export type YamlComposerErrorCode = typeof YamlComposerErrorCode.Type;
 /**
  * Error codes emitted by the stringifier (the circular-reference guard).
  *
  * @public
  */
-declare const YamlStringifyErrorCode: Schema.Literals<readonly ["CircularReference"]>;
+export declare const YamlStringifyErrorCode: Schema.Literals<readonly ["CircularReference"]>;
 /**
  * The union of all stringifier-stage error code string literals.
  *
  * @public
  */
-type YamlStringifyErrorCode = typeof YamlStringifyErrorCode.Type;
+export type YamlStringifyErrorCode = typeof YamlStringifyErrorCode.Type;
 /**
  * Error codes emitted by `YamlFormat.modify`'s path navigation against an
  * already-composed AST — not raised by the parser/composer/stringifier.
  *
  * @public
  */
-declare const YamlModifyErrorCode: Schema.Literals<readonly ["EmptyDocument", "PathNotFound", "InvalidIndex", "NotNavigable", "MultiDocumentStream", "DirectiveCarryingDocument"]>;
+export declare const YamlModifyErrorCode: Schema.Literals<readonly ["EmptyDocument", "PathNotFound", "InvalidIndex", "NotNavigable", "MultiDocumentStream", "DirectiveCarryingDocument"]>;
 /**
  * The union of all modify-stage error code string literals.
  *
  * @public
  */
-type YamlModifyErrorCode = typeof YamlModifyErrorCode.Type;
+export type YamlModifyErrorCode = typeof YamlModifyErrorCode.Type;
 /**
  * Union of all YAML error codes across all pipeline stages. Stage
  * discrimination lives here (in the code), not in separate error classes.
  *
  * @public
  */
-declare const YamlErrorCode: Schema.Union<readonly [Schema.Literals<readonly ["UnexpectedCharacter", "UnterminatedString", "InvalidEscapeSequence", "InvalidUnicode", "UnterminatedBlockScalar", "UnterminatedFlowCollection", "InvalidDirective", "InvalidTagHandle", "InvalidAnchorName", "UnexpectedByteOrderMark"]>, Schema.Literals<readonly ["InvalidIndentation", "DuplicateKey", "UnexpectedToken", "MissingValue", "MissingKey", "TabIndentation", "InvalidBlockStructure", "MalformedFlowCollection", "NestingDepthExceeded"]>, Schema.Literals<readonly ["UndefinedAlias", "DuplicateAnchor", "CircularAlias", "UnresolvedTag", "InvalidTagValue", "AliasCountExceeded", "InvalidDirective"]>, Schema.Literals<readonly ["CircularReference"]>, Schema.Literals<readonly ["EmptyDocument", "PathNotFound", "InvalidIndex", "NotNavigable", "MultiDocumentStream", "DirectiveCarryingDocument"]>]>;
+export declare const YamlErrorCode: Schema.Union<readonly [Schema.Literals<readonly ["UnexpectedCharacter", "UnterminatedString", "InvalidEscapeSequence", "InvalidUnicode", "UnterminatedBlockScalar", "UnterminatedFlowCollection", "InvalidDirective", "InvalidTagHandle", "InvalidAnchorName", "UnexpectedByteOrderMark"]>, Schema.Literals<readonly ["InvalidIndentation", "DuplicateKey", "UnexpectedToken", "MissingValue", "MissingKey", "TabIndentation", "InvalidBlockStructure", "MalformedFlowCollection", "NestingDepthExceeded"]>, Schema.Literals<readonly ["UndefinedAlias", "DuplicateAnchor", "CircularAlias", "UnresolvedTag", "InvalidTagValue", "AliasCountExceeded", "InvalidDirective"]>, Schema.Literals<readonly ["CircularReference"]>, Schema.Literals<readonly ["EmptyDocument", "PathNotFound", "InvalidIndex", "NotNavigable", "MultiDocumentStream", "DirectiveCarryingDocument"]>]>;
 /**
  * The union of all YAML error code string literals.
  *
  * @public
  */
-type YamlErrorCode = typeof YamlErrorCode.Type;
+export type YamlErrorCode = typeof YamlErrorCode.Type;
 declare const YamlDiagnostic_base: Schema.Class<YamlDiagnostic, Schema.Struct<{
   readonly code: Schema.Union<readonly [Schema.Literals<readonly ["UnexpectedCharacter", "UnterminatedString", "InvalidEscapeSequence", "InvalidUnicode", "UnterminatedBlockScalar", "UnterminatedFlowCollection", "InvalidDirective", "InvalidTagHandle", "InvalidAnchorName", "UnexpectedByteOrderMark"]>, Schema.Literals<readonly ["InvalidIndentation", "DuplicateKey", "UnexpectedToken", "MissingValue", "MissingKey", "TabIndentation", "InvalidBlockStructure", "MalformedFlowCollection", "NestingDepthExceeded"]>, Schema.Literals<readonly ["UndefinedAlias", "DuplicateAnchor", "CircularAlias", "UnresolvedTag", "InvalidTagValue", "AliasCountExceeded", "InvalidDirective"]>, Schema.Literals<readonly ["CircularReference"]>, Schema.Literals<readonly ["EmptyDocument", "PathNotFound", "InvalidIndex", "NotNavigable", "MultiDocumentStream", "DirectiveCarryingDocument"]>]>;
   readonly message: Schema.String;
@@ -95,7 +95,7 @@ declare const YamlDiagnostic_base: Schema.Class<YamlDiagnostic, Schema.Struct<{
  *
  * @public
  */
-declare class YamlDiagnostic extends YamlDiagnostic_base {
+export declare class YamlDiagnostic extends YamlDiagnostic_base {
   /**
    * The single fatal-code predicate: whether diagnostics with this code
    * abort a parse (vs. being recoverable warnings-as-data). Declared once,
@@ -142,7 +142,7 @@ declare const YamlParseOptions_base: Schema.Class<YamlParseOptions, Schema.Struc
  *
  * @public
  */
-declare class YamlParseOptions extends YamlParseOptions_base {}
+export declare class YamlParseOptions extends YamlParseOptions_base {}
 declare const YamlStringifyOptions_base: Schema.Class<YamlStringifyOptions, Schema.Struct<{
   readonly indent: Schema.optionalKey<Schema.Number>;
   /**
@@ -175,6 +175,33 @@ declare const YamlStringifyOptions_base: Schema.Class<YamlStringifyOptions, Sche
    * `"double-quoted"` is unaffected.
    */
   readonly quoteStyle: Schema.optionalKey<Schema.Literals<readonly ["single", "double"]>>;
+  /**
+   * Additionally quote plain scalars a foreign resolution dialect would
+   * coerce to a non-string. Absent (the default) adds no quoting beyond the
+   * YAML 1.2 Core Schema rules — byte-identical to the released output.
+   *
+   * `"yaml-1.1"` quotes every plain scalar a YAML 1.1 parser (js-yaml,
+   * PyYAML, libyaml, and the `yaml` npm package's YAML 1.1 schema, whose
+   * lenient resolvers set the outer bound) would implicitly resolve to a
+   * non-string: the extended
+   * boolean spellings (`y`/`yes`/`on`/`off` and case variants — the "Norway
+   * problem"), timestamps (`2024-01-15`, `2001-12-15T02:59:43.1Z`, the
+   * space-separated 1.1 forms), sexagesimal numbers (`1:30`,
+   * `190:20:30.15`), underscore-separated numbers (`1_000`) and the
+   * base-2/8/16 integer forms (`0b1010_0111`, `0777`, `0x_FF`). Use it when
+   * emitted output is parsed downstream by a YAML 1.1 consumer and blanket
+   * `defaultScalarStyle` quoting is too noisy.
+   *
+   * Strictly additive: it never un-quotes anything the 1.2 rules require
+   * quoted, strings no 1.1 parser coerces stay plain, and the quote
+   * character stays governed by `quoteStyle`. Scalars carrying an explicit
+   * tag are exempt, exactly like the 1.2 type-conflict check. Applies
+   * wherever the plain fallback renders — values, mapping keys, flow items —
+   * on both the value path ({@link Yaml.stringify},
+   * {@link Yaml.stringifyResult}) and the node path (`YamlDocument#stringify`
+   * and the `YamlFormat` helpers).
+   */
+  readonly quoteCompat: Schema.optionalKey<Schema.Literals<readonly ["yaml-1.1"]>>;
   readonly finalNewline: Schema.optionalKey<Schema.Boolean>;
   readonly forceDefaultStyles: Schema.optionalKey<Schema.Boolean>;
 }>, {}>;
@@ -182,8 +209,9 @@ declare const YamlStringifyOptions_base: Schema.Class<YamlStringifyOptions, Sche
  * Options controlling stringify behavior. All fields are omissible; absent
  * fields resolve to `indent` `2`, `lineWidth` `0`, `defaultScalarStyle`
  * `"plain"`, `defaultCollectionStyle` `"block"`, `sortKeys` `false`,
- * `indentSequences` `false`, `quoteStyle` `"single"`, `finalNewline` `true`
- * and `forceDefaultStyles` `false`.
+ * `indentSequences` `false`, `quoteStyle` `"single"`, `quoteCompat` absent
+ * (no dialect-compat quoting), `finalNewline` `true` and `forceDefaultStyles`
+ * `false`.
  *
  * `lineWidth` controls column-based scalar folding. The default `0` (and any
  * value `<= 0`) never wraps, emitting byte-identical output to the historic
@@ -229,7 +257,7 @@ declare const YamlStringifyOptions_base: Schema.Class<YamlStringifyOptions, Sche
  *
  * @public
  */
-declare class YamlStringifyOptions extends YamlStringifyOptions_base {}
+export declare class YamlStringifyOptions extends YamlStringifyOptions_base {}
 declare const YamlParseError_base: Schema.Class<YamlParseError, Schema.TaggedStruct<"YamlParseError", {
   readonly diagnostics: Schema.$Array<typeof YamlDiagnostic>;
   readonly input: Schema.String;
@@ -244,7 +272,7 @@ declare const YamlParseError_base: Schema.Class<YamlParseError, Schema.TaggedStr
  *
  * @public
  */
-declare class YamlParseError extends YamlParseError_base {
+export declare class YamlParseError extends YamlParseError_base {
   get message(): string;
 }
 declare const YamlStringifyError_base: Schema.Class<YamlStringifyError, Schema.TaggedStruct<"YamlStringifyError", {
@@ -260,7 +288,7 @@ declare const YamlStringifyError_base: Schema.Class<YamlStringifyError, Schema.T
  *
  * @public
  */
-declare class YamlStringifyError extends YamlStringifyError_base {
+export declare class YamlStringifyError extends YamlStringifyError_base {
   get message(): string;
 }
 /**
@@ -303,7 +331,7 @@ interface YamlBoundCodec<T, RD = never, RE = never> {
  *
  * @public
  */
-declare class Yaml {
+export declare class Yaml {
   private constructor();
   /**
    * Parse a single YAML document into a plain JavaScript value, resolving
@@ -573,7 +601,7 @@ declare const YamlRange_base: Schema.Class<YamlRange, Schema.Struct<{
  *
  * @public
  */
-declare class YamlRange extends YamlRange_base {}
+export declare class YamlRange extends YamlRange_base {}
 declare const YamlEdit_base: Schema.Class<YamlEdit, Schema.Struct<{
   readonly offset: Schema.Number;
   readonly length: Schema.Number;
@@ -590,7 +618,7 @@ declare const YamlEdit_base: Schema.Class<YamlEdit, Schema.Struct<{
  *
  * @public
  */
-declare class YamlEdit extends YamlEdit_base {
+export declare class YamlEdit extends YamlEdit_base {
   /**
    * Apply `edits` to `text`, producing a new string. Edits are applied in
    * reverse-offset order so earlier offsets stay valid; the input `edits`
@@ -606,25 +634,25 @@ declare class YamlEdit extends YamlEdit_base {
  *
  * @public
  */
-declare const ScalarStyle: Schema.Literals<readonly ["plain", "single-quoted", "double-quoted", "block-literal", "block-folded"]>;
+export declare const ScalarStyle: Schema.Literals<readonly ["plain", "single-quoted", "double-quoted", "block-literal", "block-folded"]>;
 /**
  * The union of all scalar style string literals.
  *
  * @public
  */
-type ScalarStyle = typeof ScalarStyle.Type;
+export type ScalarStyle = typeof ScalarStyle.Type;
 /**
  * YAML collection presentation styles.
  *
  * @public
  */
-declare const CollectionStyle: Schema.Literals<readonly ["block", "flow"]>;
+export declare const CollectionStyle: Schema.Literals<readonly ["block", "flow"]>;
 /**
  * The union of all collection style string literals.
  *
  * @public
  */
-type CollectionStyle = typeof CollectionStyle.Type;
+export type CollectionStyle = typeof CollectionStyle.Type;
 /**
  * Quote characters available to the stringifier's plain-scalar fallback: the
  * style a `plain`-styled scalar is rendered in when it turns out to require
@@ -634,26 +662,47 @@ type CollectionStyle = typeof CollectionStyle.Type;
  *
  * @public
  */
-declare const QuoteStyle: Schema.Literals<readonly ["single", "double"]>;
+export declare const QuoteStyle: Schema.Literals<readonly ["single", "double"]>;
 /**
  * The union of all fallback quote style string literals.
  *
  * @public
  */
-type QuoteStyle = typeof QuoteStyle.Type;
+export type QuoteStyle = typeof QuoteStyle.Type;
+/**
+ * Foreign resolution dialects the stringifier's plain-scalar fallback can
+ * defend against: setting the `quoteCompat` field of `YamlStringifyOptions`
+ * to `"yaml-1.1"` additionally quotes every plain scalar a YAML 1.1 parser
+ * (js-yaml, PyYAML, libyaml, and the `yaml` npm package's YAML 1.1 schema,
+ * whose lenient resolvers set the outer bound) would implicitly resolve to a
+ * non-string —
+ * `yes`/`no`/`on`/`off` booleans, ISO 8601 and space-separated timestamps,
+ * sexagesimal `1:30`, underscored `1_000` and base-2/8/16 numbers. Like
+ * `QuoteStyle` it is a stringify-option vocabulary, never a property of a
+ * composed node.
+ *
+ * @public
+ */
+export declare const QuoteCompat: Schema.Literals<readonly ["yaml-1.1"]>;
+/**
+ * The union of all quote-compat dialect string literals.
+ *
+ * @public
+ */
+export type QuoteCompat = typeof QuoteCompat.Type;
 /**
  * Block-scalar chomping indicators (`-` strip, default clip, `+` keep).
  * Referenced by the {@link YamlScalar} `chomp` field schema.
  *
  * @public
  */
-declare const ScalarChomp: Schema.Literals<readonly ["strip", "clip", "keep"]>;
+export declare const ScalarChomp: Schema.Literals<readonly ["strip", "clip", "keep"]>;
 /**
  * The union of all block-scalar chomping indicator string literals.
  *
  * @public
  */
-type ScalarChomp = typeof ScalarChomp.Type;
+export type ScalarChomp = typeof ScalarChomp.Type;
 declare const YamlScalar_base: Schema.Class<YamlScalar, Schema.TaggedStruct<"YamlScalar", {
   readonly value: Schema.Unknown;
   readonly tag: Schema.optionalKey<Schema.String>;
@@ -697,7 +746,7 @@ declare const YamlScalar_base: Schema.Class<YamlScalar, Schema.TaggedStruct<"Yam
  *
  * @public
  */
-declare class YamlScalar extends YamlScalar_base {
+export declare class YamlScalar extends YamlScalar_base {
   /**
    * Navigate to a descendant by path (string segments for mapping keys,
    * numbers for sequence indices). `Option.none()` when any segment cannot
@@ -741,7 +790,7 @@ declare const YamlAlias_base: Schema.Class<YamlAlias, Schema.TaggedStruct<"YamlA
  *
  * @public
  */
-declare class YamlAlias extends YamlAlias_base {
+export declare class YamlAlias extends YamlAlias_base {
   /** See `YamlScalar.find`. Pure. */
   find(path: YamlPath): Option.Option<YamlNode>;
   /** See `YamlScalar.findAtOffset`. Pure. */
@@ -794,13 +843,13 @@ interface YamlAliasEncoded extends Schema.Codec.Encoded<typeof YamlAlias> {}
  *
  * @public
  */
-declare const YamlNode: Schema.Codec<YamlScalar | YamlMap | YamlSeq | YamlAlias, YamlScalarEncoded | YamlMapEncoded | YamlSeqEncoded | YamlAliasEncoded>;
+export declare const YamlNode: Schema.Codec<YamlScalar | YamlMap | YamlSeq | YamlAlias, YamlScalarEncoded | YamlMapEncoded | YamlSeqEncoded | YamlAliasEncoded>;
 /**
  * The union of all YAML AST value node types.
  *
  * @public
  */
-type YamlNode = YamlScalar | YamlMap | YamlSeq | YamlAlias;
+export type YamlNode = YamlScalar | YamlMap | YamlSeq | YamlAlias;
 declare const YamlPair_base: Schema.Class<YamlPair, Schema.TaggedStruct<"YamlPair", {
   readonly key: Schema.suspend<Schema.Codec<YamlAlias | YamlMap | YamlScalar | YamlSeq, YamlAliasEncoded | YamlMapEncoded | YamlScalarEncoded | YamlSeqEncoded, never, never>>;
   readonly value: Schema.NullOr<Schema.suspend<Schema.Codec<YamlAlias | YamlMap | YamlScalar | YamlSeq, YamlAliasEncoded | YamlMapEncoded | YamlScalarEncoded | YamlSeqEncoded, never, never>>>;
@@ -818,7 +867,7 @@ declare const YamlPair_base: Schema.Class<YamlPair, Schema.TaggedStruct<"YamlPai
  *
  * @public
  */
-declare class YamlPair extends YamlPair_base {}
+export declare class YamlPair extends YamlPair_base {}
 declare const YamlMap_base: Schema.Class<YamlMap, Schema.TaggedStruct<"YamlMap", {
   readonly items: Schema.$Array<Schema.suspend<typeof YamlPair>>;
   readonly tag: Schema.optionalKey<Schema.String>;
@@ -846,7 +895,7 @@ declare const YamlMap_base: Schema.Class<YamlMap, Schema.TaggedStruct<"YamlMap",
  *
  * @public
  */
-declare class YamlMap extends YamlMap_base {
+export declare class YamlMap extends YamlMap_base {
   /** See `YamlScalar.find`. Pure. */
   find(path: YamlPath): Option.Option<YamlNode>;
   /** See `YamlScalar.findAtOffset`. Pure. */
@@ -880,7 +929,7 @@ declare const YamlSeq_base: Schema.Class<YamlSeq, Schema.TaggedStruct<"YamlSeq",
  *
  * @public
  */
-declare class YamlSeq extends YamlSeq_base {
+export declare class YamlSeq extends YamlSeq_base {
   /** See `YamlScalar.find`. Pure. */
   find(path: YamlPath): Option.Option<YamlNode>;
   /** See `YamlScalar.findAtOffset`. Pure. */
@@ -904,7 +953,7 @@ declare const YamlDirective_base: Schema.Class<YamlDirective, Schema.Struct<{
  *
  * @public
  */
-declare class YamlDirective extends YamlDirective_base {}
+export declare class YamlDirective extends YamlDirective_base {}
 declare const YamlDocument_base: Schema.Class<YamlDocument, Schema.Struct<{
   readonly contents: Schema.NullOr<Schema.suspend<Schema.Schema<YamlNode>>>;
   readonly errors: Schema.$Array<typeof YamlDiagnostic>;
@@ -933,7 +982,7 @@ declare const YamlDocument_base: Schema.Class<YamlDocument, Schema.Struct<{
  *
  * @public
  */
-declare class YamlDocument extends YamlDocument_base {
+export declare class YamlDocument extends YamlDocument_base {
   /**
    * Parse a single YAML document, keeping the full AST, directives and
    * recovered diagnostics. Fails with the aggregate {@link YamlParseError}
@@ -1005,6 +1054,7 @@ declare const YamlFormattingOptions_base: Schema.Class<YamlFormattingOptions, Sc
   readonly sortKeys: Schema.optionalKey<Schema.Boolean>;
   readonly indentSequences: Schema.optionalKey<Schema.Boolean>;
   readonly quoteStyle: Schema.optionalKey<Schema.Literals<readonly ["single", "double"]>>;
+  readonly quoteCompat: Schema.optionalKey<Schema.Literals<readonly ["yaml-1.1"]>>;
   readonly finalNewline: Schema.optionalKey<Schema.Boolean>;
   readonly forceDefaultStyles: Schema.optionalKey<Schema.Boolean>;
   readonly preserveComments: Schema.optionalKey<Schema.Boolean>;
@@ -1013,8 +1063,8 @@ declare const YamlFormattingOptions_base: Schema.Class<YamlFormattingOptions, Sc
 }>, {}>;
 /**
  * Options controlling formatting behavior: every {@link YamlStringifyOptions}
- * field (derived, not hand-duplicated — including `indentSequences` and
- * `quoteStyle`) plus
+ * field (derived, not hand-duplicated — including `indentSequences`,
+ * `quoteStyle` and `quoteCompat`) plus
  * `preserveComments` (default `true`), `range` (restrict edits to a
  * region; see the module-level remarks on the `range` parameter vs. this
  * field) and `requoteScalars` (default `false`).
@@ -1052,7 +1102,7 @@ declare const YamlFormattingOptions_base: Schema.Class<YamlFormattingOptions, Sc
  *
  * @public
  */
-declare class YamlFormattingOptions extends YamlFormattingOptions_base {}
+export declare class YamlFormattingOptions extends YamlFormattingOptions_base {}
 declare const YamlModificationError_base: Schema.Class<YamlModificationError, Schema.TaggedStruct<"YamlModificationError", {
   readonly path: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Number]>>;
   readonly diagnostics: Schema.$Array<typeof YamlDiagnostic>;
@@ -1072,7 +1122,7 @@ declare const YamlModificationError_base: Schema.Class<YamlModificationError, Sc
  *
  * @public
  */
-declare class YamlModificationError extends YamlModificationError_base {
+export declare class YamlModificationError extends YamlModificationError_base {
   get message(): string;
 }
 /**
@@ -1107,7 +1157,7 @@ declare class YamlModificationError extends YamlModificationError_base {
  *
  * @public
  */
-declare class YamlFormat {
+export declare class YamlFormat {
   private constructor();
   /**
    * Compute formatting edits for a YAML document. Non-mutating — apply the
@@ -1214,13 +1264,13 @@ declare class YamlFormat {
  *
  * @public
  */
-declare const YamlTokenKind: Schema.Literals<readonly ["document-start", "document-end", "directive", "tag", "anchor", "alias", "scalar", "block-map-start", "block-map-key", "block-map-value", "block-seq-start", "block-seq-entry", "flow-map-start", "flow-map-end", "flow-seq-start", "flow-seq-end", "flow-separator", "newline", "whitespace", "comment", "byte-order-mark", "error"]>;
+export declare const YamlTokenKind: Schema.Literals<readonly ["document-start", "document-end", "directive", "tag", "anchor", "alias", "scalar", "block-map-start", "block-map-key", "block-map-value", "block-seq-start", "block-seq-entry", "flow-map-start", "flow-map-end", "flow-seq-start", "flow-seq-end", "flow-separator", "newline", "whitespace", "comment", "byte-order-mark", "error"]>;
 /**
  * The union of all lexical token kind string literals.
  *
  * @public
  */
-type YamlTokenKind = typeof YamlTokenKind.Type;
+export type YamlTokenKind = typeof YamlTokenKind.Type;
 declare const YamlToken_base: Schema.Class<YamlToken, Schema.Struct<{
   readonly kind: Schema.Literals<readonly ["document-start", "document-end", "directive", "tag", "anchor", "alias", "scalar", "block-map-start", "block-map-key", "block-map-value", "block-seq-start", "block-seq-entry", "flow-map-start", "flow-map-end", "flow-seq-start", "flow-seq-end", "flow-separator", "newline", "whitespace", "comment", "byte-order-mark", "error"]>;
   readonly text: Schema.String;
@@ -1241,13 +1291,13 @@ declare const YamlToken_base: Schema.Class<YamlToken, Schema.Struct<{
  *
  * @public
  */
-declare class YamlToken extends YamlToken_base {}
+export declare class YamlToken extends YamlToken_base {}
 /**
  * Tokenizer statics. Not instantiable.
  *
  * @public
  */
-declare class YamlTokens {
+export declare class YamlTokens {
   private constructor();
   /**
    * Tokenize YAML text into the full positioned token array — the sync
@@ -1296,13 +1346,13 @@ declare class YamlTokens {
  *
  * @public
  */
-declare const YamlLintSeverity: Schema.Literals<readonly ["error", "warning"]>;
+export declare const YamlLintSeverity: Schema.Literals<readonly ["error", "warning"]>;
 /**
  * The union of lint severity string literals.
  *
  * @public
  */
-type YamlLintSeverity = typeof YamlLintSeverity.Type;
+export type YamlLintSeverity = typeof YamlLintSeverity.Type;
 declare const YamlLintDiagnostic_base: Schema.Class<YamlLintDiagnostic, Schema.Struct<{
   readonly rule: Schema.String;
   readonly severity: Schema.Literals<readonly ["error", "warning"]>;
@@ -1325,7 +1375,7 @@ declare const YamlLintDiagnostic_base: Schema.Class<YamlLintDiagnostic, Schema.S
  *
  * @public
  */
-declare class YamlLintDiagnostic extends YamlLintDiagnostic_base {}
+export declare class YamlLintDiagnostic extends YamlLintDiagnostic_base {}
 /**
  * One source line of the linted document: its text (without the line
  * terminator — the `\n`, and for CRLF input the `\r\n` pair), the offset of
@@ -1388,7 +1438,7 @@ declare const StyleVote_base: Schema.Class<StyleVote, Schema.TaggedStruct<"Style
  *
  * @public
  */
-declare class StyleVote extends StyleVote_base {}
+export declare class StyleVote extends StyleVote_base {}
 declare const StyleFloor_base: Schema.Class<StyleFloor, Schema.TaggedStruct<"StyleFloor", {
   readonly dimension: Schema.String;
   readonly value: Schema.Number;
@@ -1406,7 +1456,7 @@ declare const StyleFloor_base: Schema.Class<StyleFloor, Schema.TaggedStruct<"Sty
  *
  * @public
  */
-declare class StyleFloor extends StyleFloor_base {}
+export declare class StyleFloor extends StyleFloor_base {}
 /**
  * What a rule's `infer` hook yields per occurrence: a categorical
  * {@link StyleVote} or a measured {@link StyleFloor}.
@@ -1447,13 +1497,13 @@ interface YamlRule {
  *
  * @public
  */
-declare const YamlLintRuleSetting: Schema.Union<readonly [Schema.Literals<readonly ["error", "warning", "off"]>, Schema.$Record<Schema.String, Schema.Unknown>]>;
+export declare const YamlLintRuleSetting: Schema.Union<readonly [Schema.Literals<readonly ["error", "warning", "off"]>, Schema.$Record<Schema.String, Schema.Unknown>]>;
 /**
  * The union type of one `rules`-map entry.
  *
  * @public
  */
-type YamlLintRuleSetting = typeof YamlLintRuleSetting.Type;
+export type YamlLintRuleSetting = typeof YamlLintRuleSetting.Type;
 declare const YamlLintConfig_base: Schema.Class<YamlLintConfig, Schema.Struct<{
   readonly rules: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Literals<readonly ["error", "warning", "off"]>, Schema.$Record<Schema.String, Schema.Unknown>]>>;
 }>, {}>;
@@ -1474,7 +1524,7 @@ declare const YamlLintConfig_base: Schema.Class<YamlLintConfig, Schema.Struct<{
  *
  * @public
  */
-declare class YamlLintConfig extends YamlLintConfig_base {
+export declare class YamlLintConfig extends YamlLintConfig_base {
   /**
    * The default preset. Rule entries accrete as built-ins land; the
    * `quoted-strings` rule defaults to DOUBLE quotes here (the one taste
@@ -1502,7 +1552,7 @@ declare const StyleVoteTally_base: Schema.Class<StyleVoteTally, Schema.Struct<{
  *
  * @public
  */
-declare class StyleVoteTally extends StyleVoteTally_base {}
+export declare class StyleVoteTally extends StyleVoteTally_base {}
 declare const StyleFloorTally_base: Schema.Class<StyleFloorTally, Schema.Struct<{
   readonly rule: Schema.String;
   readonly dimension: Schema.String;
@@ -1516,7 +1566,7 @@ declare const StyleFloorTally_base: Schema.Class<StyleFloorTally, Schema.Struct<
  *
  * @public
  */
-declare class StyleFloorTally extends StyleFloorTally_base {}
+export 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>;
@@ -1537,7 +1587,7 @@ declare const StyleEvidence_base: Schema.Class<StyleEvidence, Schema.Struct<{
  *
  * @public
  */
-declare class StyleEvidence extends StyleEvidence_base {
+export declare class StyleEvidence extends StyleEvidence_base {
   /** The monoid identity: no observations. */
   static readonly empty: StyleEvidence;
   /**
@@ -1568,7 +1618,7 @@ declare const StyleConflict_base: Schema.Class<StyleConflict, Schema.Struct<{
  *
  * @public
  */
-declare class StyleConflict extends StyleConflict_base {}
+export 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>;
@@ -1582,7 +1632,7 @@ declare const YamlStyleConflictError_base: Schema.Class<YamlStyleConflictError,
  *
  * @public
  */
-declare class YamlStyleConflictError extends YamlStyleConflictError_base {
+export declare class YamlStyleConflictError extends YamlStyleConflictError_base {
   get message(): string;
 }
 /**
@@ -1606,7 +1656,7 @@ interface YamlLintInference {
  *
  * @public
  */
-declare class YamlLint {
+export declare class YamlLint {
   private constructor();
   /**
    * The built-in rule catalog. Custom usage is array concatenation:
@@ -1702,7 +1752,7 @@ declare class YamlLint {
  *
  * @public
  */
-type YamlVisitorEvent = Data.TaggedEnum<{
+export type YamlVisitorEvent = Data.TaggedEnum<{
   DocumentStart: {
     readonly path: YamlPath;
     readonly depth: number;
@@ -1782,7 +1832,7 @@ type YamlVisitorEvent = Data.TaggedEnum<{
  *
  * @public
  */
-declare const YamlVisitorEvent: {
+export declare const YamlVisitorEvent: {
   readonly $is: <Tag extends "Alias" | "Comment" | "Directive" | "DocumentEnd" | "DocumentStart" | "Error" | "MapEnd" | "MapStart" | "Pair" | "Scalar" | "SeqEnd" | "SeqStart">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Alias";
     readonly path: YamlPath;
@@ -2276,7 +2326,7 @@ declare const YamlVisitorEvent: {
  *
  * @public
  */
-declare class YamlVisitor {
+export declare class YamlVisitor {
   private constructor();
   /**
    * Create a lazy `Stream` of `YamlVisitorEvent` from YAML text, in document
@@ -2294,5 +2344,5 @@ declare class YamlVisitor {
   static visit(text: string, options?: YamlParseOptions): Stream.Stream<YamlVisitorEvent>;
 }
 //#endregion
-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 };
+export type { LintContext, LintLine, StyleObservation, YamlAliasEncoded, YamlBoundCodec, YamlLintInference, YamlMapEncoded, YamlPath, YamlRangeLike, YamlRule, YamlScalarEncoded, YamlSegment, YamlSeqEncoded };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,4 +1,4 @@
-import { CollectionStyle, QuoteStyle, ScalarChomp, ScalarStyle, YamlAlias, YamlMap, YamlNode, YamlPair, YamlScalar, YamlSeq } from "./YamlNode.js";
+import { CollectionStyle, QuoteCompat, QuoteStyle, ScalarChomp, ScalarStyle, YamlAlias, YamlMap, YamlNode, YamlPair, YamlScalar, YamlSeq } from "./YamlNode.js";
 import { YamlComposerErrorCode, YamlDiagnostic, YamlErrorCode, YamlLexErrorCode, YamlModifyErrorCode, YamlParseErrorCode, YamlStringifyErrorCode } from "./YamlDiagnostic.js";
 import { Yaml, YamlParseError, YamlParseOptions, YamlStringifyError, YamlStringifyOptions } from "./Yaml.js";
 import { YamlDirective, YamlDocument } from "./YamlDocument.js";
@@ -9,4 +9,4 @@ import { YamlToken, YamlTokenKind, YamlTokens } from "./YamlToken.js";
 import { StyleConflict, StyleEvidence, StyleFloorTally, StyleVoteTally, YamlLint, YamlLintConfig, YamlLintRuleSetting, YamlStyleConflictError } from "./YamlLint.js";
 import { YamlVisitor, YamlVisitorEvent } from "./YamlVisitor.js";
 
-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 };
+export { CollectionStyle, QuoteCompat, 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/stringifier.js

@@ -105,6 +105,23 @@ function wouldBeResolved(s) {
 	if (FLOAT_RE.test(s)) return true;
 	return false;
 }
+const BOOL_11_RE = /^(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/;
+const INT_11_RE = /^[-+]?(?:0b[0-1_]+|0o?[0-7_]+|[0-9][0-9_]*|0x[0-9a-fA-F_]+|[1-9][0-9_]*(?::[0-5]?[0-9])+)$/;
+const FLOAT_11_RE = /^[-+]?(?:[0-9][0-9_]*(?:\.[0-9_]*(?:[eE][-+]?[0-9]+)?|[eE][-+]?[0-9]+)|\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/;
+const TIMESTAMP_11_RE = /^[0-9][0-9][0-9][0-9]-[0-9][0-9]?-[0-9][0-9]?(?:(?:[Tt]|[ \t]+)[0-9][0-9]?:[0-9][0-9]:[0-9][0-9](?:\.[0-9]*)?(?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::?[0-9][0-9])?))?)?$/;
+/**
+* Returns true if a string value would be resolved as a non-string type by a
+* YAML 1.1 parser. The delta over {@link wouldBeResolved}: null spellings are
+* identical in both editions (and already covered), so only the boolean,
+* integer, float and timestamp families are tested here.
+*/
+function wouldBeResolved11(s) {
+	if (BOOL_11_RE.test(s)) return true;
+	if (INT_11_RE.test(s)) return true;
+	if (FLOAT_11_RE.test(s)) return true;
+	if (TIMESTAMP_11_RE.test(s)) return true;
+	return false;
+}
 /**
 * Returns true if a string requires quoting to be safely represented as a plain scalar.
 *
@@ -112,11 +129,16 @@ function wouldBeResolved(s) {
 * embedded newlines, leading indicator characters or whitespace, and inline
 * comment/mapping-value patterns (`: `, ` #`). This is the single gate that
 * decides whether a plain scalar is safe or must be wrapped in quotes.
+*
+* `quoteCompat` is strictly additive: `"yaml-1.1"` additionally quotes
+* strings a YAML 1.1 parser would coerce ({@link wouldBeResolved11}) and can
+* never un-quote anything the 1.2 rules require quoted.
 */
-function requiresQuoting(s, ignoreType = false) {
+function requiresQuoting(s, ignoreType = false, quoteCompat) {
 	if (s === "") return true;
 	if (s.includes("\n")) return true;
 	if (!ignoreType && wouldBeResolved(s)) return true;
+	if (!ignoreType && quoteCompat === "yaml-1.1" && wouldBeResolved11(s)) return true;
 	const first = s[0];
 	if (first === " " || first === "	") return true;
 	if (first !== void 0 && INDICATOR_CHARS.has(first)) {
@@ -197,7 +219,7 @@ function renderSingleQuoted(s) {
 * Block literal and block folded styles are always accepted for single-line
 * strings even though the output is unusual.
 */
-function renderString(s, style, indent, ignoreType = false, canonical = false, explicitChomp, parentPosition, quoteStyle = "single", explicitIndent) {
+function renderString(s, style, indent, ignoreType = false, canonical = false, explicitChomp, parentPosition, quoteStyle = "single", explicitIndent, quoteCompat) {
 	const fidelity = !canonical;
 	const fidelityIndent = fidelity ? explicitIndent : void 0;
 	if (s.includes("\n")) {
@@ -230,7 +252,7 @@ function renderString(s, style, indent, ignoreType = false, canonical = false, e
 	if (s === "" && (style === "block-literal" || style === "block-folded")) return renderDoubleQuoted(s, canonical);
 	switch (style) {
 		case "plain":
-			if (requiresQuoting(s, ignoreType)) {
+			if (requiresQuoting(s, ignoreType, quoteCompat)) {
 				if (s.includes("	") || s.includes("\r")) return renderDoubleQuoted(s, canonical);
 				for (let i = 0; i < s.length; i++) if (isControlChar(s.charCodeAt(i))) return renderDoubleQuoted(s, canonical);
 				return quoteStyle === "double" ? renderDoubleQuoted(s, canonical) : renderSingleQuoted(s);
@@ -289,6 +311,7 @@ function createContext(options) {
 		sortKeys: options?.sortKeys ?? false,
 		indentSequences: options?.indentSequences ?? false,
 		quoteStyle: options?.quoteStyle ?? "single",
+		quoteCompat: options?.quoteCompat,
 		forceDefaultStyles: options?.forceDefaultStyles ?? false,
 		seen: /* @__PURE__ */ new Set()
 	};
@@ -308,7 +331,7 @@ function stringifyLines(value, ctx, depth, allowFold = true) {
 	if (typeof value === "bigint") return [value.toString()];
 	if (typeof value === "string") {
 		const indentStr = " ".repeat(ctx.indent);
-		const rendered = renderString(value, ctx.defaultScalarStyle, indentStr, false, ctx.forceDefaultStyles, void 0, void 0, ctx.quoteStyle);
+		const rendered = renderString(value, ctx.defaultScalarStyle, indentStr, false, ctx.forceDefaultStyles, void 0, void 0, ctx.quoteStyle, void 0, ctx.quoteCompat);
 		return (allowFold && ctx.lineWidth > 0 ? foldRenderedScalar(rendered, indentStr, ctx.lineWidth) : rendered).split("\n");
 	}
 	if (Array.isArray(value)) {
@@ -373,7 +396,7 @@ function stringifyObjectLines(obj, ctx, depth) {
 	const keys = Object.keys(obj);
 	if (keys.length === 0) return ["{}"];
 	if (ctx.sortKeys) keys.sort();
-	const renderPlainKey = (k) => renderString(k, "plain", "", false, false, void 0, void 0, ctx.quoteStyle);
+	const renderPlainKey = (k) => renderString(k, "plain", "", false, false, void 0, void 0, ctx.quoteStyle, void 0, ctx.quoteCompat);
 	if (ctx.defaultCollectionStyle === "flow") return [`{${keys.map((k) => {
 		return `${renderPlainKey(k)}: ${stringifyLines(obj[k], ctx, depth + 1, false).join(" ")}`;
 	}).join(", ")}}`];
@@ -584,7 +607,7 @@ function stringifyScalarNodeLines(node, ctx) {
 		else lines = ["null"];
 	} else if (typeof val === "boolean") lines = [val ? "true" : "false"];
 	else if (typeof val === "number") lines = [node.raw !== void 0 ? node.raw : renderNumber(val)];
-	else if (typeof val === "string") lines = renderString(val, style, " ".repeat(ctx.indent), !!node.tag, ctx.forceDefaultStyles, node.chomp, ctx.parentPosition, ctx.quoteStyle, node.blockIndent).split("\n");
+	else if (typeof val === "string") lines = renderString(val, style, " ".repeat(ctx.indent), !!node.tag, ctx.forceDefaultStyles, node.chomp, ctx.parentPosition, ctx.quoteStyle, node.blockIndent, ctx.quoteCompat).split("\n");
 	else lines = [renderDoubleQuoted(String(val))];
 	if (node.tag) lines[0] = `${node.tag} ${lines[0]}`;
 	if (node.anchor) lines[0] = `&${node.anchor} ${lines[0]}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/yaml",
-	"version": "0.11.0",
+	"version": "0.13.0",
 	"private": false,
 	"description": "Zero-dependency YAML parsing, editing, formatting and linting as Effect schemas.",
 	"keywords": [
@@ -41,7 +41,7 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.109"
+		"effect": "4.0.0-rc.112"
 	},
 	"engines": {
 		"node": ">=24.11.0"