@effected/yaml 0.22.0 → 0.24.0

package/YamlLintRule.js

@@ -1,7 +1,7 @@
 import { YamlEdit } from "./YamlEdit.js";
 import { Schema } from "effect";
 
-//#region src/YamlLintRule.ts
+// src/YamlLintRule.ts
 /**
 * Lint diagnostic severities. `"off"` is a config-level disable only and
 * never reaches a diagnostic — a rule set to `"off"` is not run.
@@ -81,5 +81,4 @@ var StyleFloor = class extends Schema.TaggedClass()("StyleFloor", {
 	value: Schema.Number
 }) {};
 
-//#endregion
 export { StyleFloor, StyleVote, YamlLintDiagnostic, YamlLintSeverity };

package/YamlNode.js

@@ -1,6 +1,6 @@
 import { Option, Schema } from "effect";
 
-//#region src/YamlNode.ts
+// src/YamlNode.ts
 /**
 * YAML scalar presentation styles.
 *
@@ -456,5 +456,4 @@ function nodeToValue(node, anchors, budget, counting = false) {
 	return null;
 }
 
-//#endregion
 export { AliasExpansionBudgetExceeded, CollectionStyle, QuoteCompat, QuoteStyle, ScalarChomp, ScalarStyle, YamlAlias, YamlMap, YamlNode, YamlPair, YamlScalar, YamlSeq, aliasExpansionLimit, nodeToJsValue };

package/YamlToken.js

@@ -1,7 +1,7 @@
 import { lexAll } from "./internal/lexer.js";
 import { Result, Schema, Stream } from "effect";
 
-//#region src/YamlToken.ts
+// src/YamlToken.ts
 /**
 * The 22 lexical token kinds produced by the YAML tokenizer.
 *
@@ -139,5 +139,4 @@ var YamlTokens = class YamlTokens {
 	}
 };
 
-//#endregion
 export { YamlToken, YamlTokenKind, YamlTokens };

package/YamlVisitor.js

@@ -3,7 +3,7 @@ import { composeAllDocuments } from "./internal/composer/document.js";
 import { YamlDiagnostic } from "./YamlDiagnostic.js";
 import { Data, Stream } from "effect";
 
-//#region src/YamlVisitor.ts
+// src/YamlVisitor.ts
 /**
 * Constructors and matchers for the `YamlVisitorEvent` union (e.g.
 * `YamlVisitorEvent.Scalar({ path, depth, value, style })`,
@@ -225,5 +225,4 @@ function* walkPair(pair, parentPath, depth) {
 	if (pair.value !== null) yield* walkNode(pair.value, pairPath, depth + 1);
 }
 
-//#endregion
 export { YamlVisitor, YamlVisitorEvent };

package/index.d.ts

@@ -1,5 +1,4 @@
 import { Data, Effect, Option, Result, Schema, Stream } from "effect";
-//#region src/YamlDiagnostic.d.ts
 /**
  * Error codes emitted by the lexer stage.
  *
@@ -121,8 +120,6 @@ export declare class YamlDiagnostic extends YamlDiagnostic_base {
     readonly length: number;
   }, text: string): YamlDiagnostic;
 }
-//#endregion
-//#region src/Yaml.d.ts
 declare const YamlParseOptions_base: Schema.Class<YamlParseOptions, Schema.Struct<{
   readonly strict: Schema.optionalKey<Schema.Boolean>;
   readonly maxAliasCount: Schema.optionalKey<Schema.Number>;
@@ -620,8 +617,6 @@ export declare class Yaml {
    */
   static bind<T, E, RD = never, RE = never>(target: Schema.Codec<T, E, RD, RE>): YamlBoundCodec<T, RD, RE>;
 }
-//#endregion
-//#region src/YamlEdit.d.ts
 /**
  * A single path segment: a `string` for mapping keys or a `number` for
  * sequence indices.
@@ -678,8 +673,6 @@ export declare class YamlEdit extends YamlEdit_base {
    */
   static applyAll(text: string, edits: ReadonlyArray<YamlEdit>): string;
 }
-//#endregion
-//#region src/YamlNode.d.ts
 /**
  * YAML scalar presentation styles.
  *
@@ -990,8 +983,6 @@ export declare class YamlSeq extends YamlSeq_base {
   /** See `YamlScalar.toValue`. Pure and total. */
   toValue(anchors?: Map<string, YamlNode>): unknown;
 }
-//#endregion
-//#region src/YamlDocument.d.ts
 declare const YamlDirective_base: Schema.Class<YamlDirective, Schema.Struct<{
   readonly name: Schema.String;
   readonly parameters: Schema.$Array<Schema.String>;
@@ -1045,11 +1036,39 @@ declare const YamlDocument_base: Schema.Class<YamlDocument, Schema.Struct<{
  * @public
  */
 export declare class YamlDocument extends YamlDocument_base {
+  /**
+   * Synchronous single-document parse, returning a `Result` instead of an
+   * `Effect`. This is the primitive {@link YamlDocument.parse} is defined in
+   * terms of — a synchronous host can call it without an Effect runtime.
+   * Keeps the full AST, directives and recovered diagnostics; fails with the
+   * aggregate {@link YamlParseError} when any fatal-code diagnostic is
+   * present, and non-fatal diagnostics are data on the returned document.
+   *
+   * @example
+   * ```ts
+   * import { YamlDocument } from "@effected/yaml";
+   * import { Result } from "effect";
+   *
+   * const result = YamlDocument.parseResult("name: Alice\n");
+   * if (Result.isSuccess(result)) {
+   *   console.log(result.success.toValue()); // => { name: "Alice" }
+   * }
+   * ```
+   *
+   * @param text - The YAML source to parse.
+   * @param options - Optional {@link YamlParseOptions}; defaults apply for
+   *   omitted fields.
+   * @returns A `Result` succeeding with the {@link YamlDocument}, or failing
+   *   with {@link YamlParseError}.
+   */
+  static parseResult(text: string, options?: YamlParseOptions): Result.Result<YamlDocument, YamlParseError>;
   /**
    * Parse a single YAML document, keeping the full AST, directives and
    * recovered diagnostics. Fails with the aggregate {@link YamlParseError}
    * when any fatal-code diagnostic is present; non-fatal diagnostics are
-   * data on the returned document.
+   * data on the returned document. Defined in terms of
+   * {@link YamlDocument.parseResult} — synchronous callers can use that
+   * variant directly.
    *
    * @param text - The YAML source to parse.
    * @param options - Optional {@link YamlParseOptions}; defaults apply for
@@ -1058,10 +1077,37 @@ export declare class YamlDocument extends YamlDocument_base {
    *   with {@link YamlParseError}.
    */
   static readonly parse: (text: string, options?: YamlParseOptions | undefined) => Effect.Effect<YamlDocument, YamlParseError, never>;
+  /**
+   * Synchronous multi-document parse, returning a `Result` instead of an
+   * `Effect` — the primitive {@link YamlDocument.parseAll} is defined in
+   * terms of. Any fatal diagnostic in any document — or a stream-level
+   * directive-placement error — fails the whole parse with one aggregate
+   * {@link YamlParseError}.
+   *
+   * @example
+   * ```ts
+   * import { YamlDocument } from "@effected/yaml";
+   * import { Result } from "effect";
+   *
+   * const result = YamlDocument.parseAllResult("a: 1\n---\nb: 2\n");
+   * if (Result.isSuccess(result)) {
+   *   console.log(result.success.length); // => 2
+   * }
+   * ```
+   *
+   * @param text - The YAML stream to parse.
+   * @param options - Optional {@link YamlParseOptions}; defaults apply for
+   *   omitted fields.
+   * @returns A `Result` succeeding with one {@link YamlDocument} per
+   *   document, or failing with {@link YamlParseError}.
+   */
+  static parseAllResult(text: string, options?: YamlParseOptions): Result.Result<ReadonlyArray<YamlDocument>, YamlParseError>;
   /**
    * Parse a multi-document YAML stream into one {@link YamlDocument} per
    * document. Any fatal diagnostic in any document — or a stream-level
-   * directive-placement error — fails the whole Effect.
+   * directive-placement error — fails the whole Effect. Defined in terms of
+   * {@link YamlDocument.parseAllResult} — synchronous callers can use that
+   * variant directly.
    *
    * @param text - The YAML stream to parse.
    * @param options - Optional {@link YamlParseOptions}; defaults apply for
@@ -1085,11 +1131,16 @@ export declare class YamlDocument extends YamlDocument_base {
   static schema(options?: YamlParseOptions): Schema.Codec<YamlDocument, string>;
   /**
    * Stringify this document (contents, directives and framing) as YAML.
-   * Fails with {@link YamlStringifyError} on circular references introduced
-   * into a synthetic AST (`CircularReference`) or on a synthetic AST nested
-   * deeper than the stringifier's recursion budget (`NestingDepthExceeded`)
-   * — both surface through the typed error channel rather than as an
-   * unhandled stack-overflow defect.
+   * Fails with {@link YamlStringifyError} (`NestingDepthExceeded`) on a
+   * synthetic AST nested deeper than the stringifier's recursion budget. A
+   * cycle introduced into a synthetic AST fails the same way: the node path
+   * keeps no ancestor set, so the cycle is caught by the depth cap rather
+   * than reported as `CircularReference`. Either way the failure surfaces
+   * through the typed error channel, never as an unhandled stack-overflow
+   * defect.
+   * Defined in terms of {@link YamlDocument.stringifyResult} behind a
+   * `YamlDocument.stringify` span — synchronous callers can use that variant
+   * directly.
    *
    * @remarks
    * `YamlStringifyOptions.lineWidth` is not honored here: column-based
@@ -1108,6 +1159,39 @@ export declare class YamlDocument extends YamlDocument_base {
    *   {@link YamlStringifyError}.
    */
   stringify(options?: YamlStringifyOptions): Effect.Effect<string, YamlStringifyError>;
+  /**
+   * Synchronous stringify, returning a `Result` instead of an `Effect` — the
+   * primitive {@link YamlDocument.stringify} is defined in terms of, so a
+   * synchronous host can round-trip a document parsed with
+   * {@link YamlDocument.parseResult} without an Effect runtime. Fails with
+   * {@link YamlStringifyError} exactly where `stringify` does: a synthetic
+   * AST nested deeper than the stringifier's recursion budget, or one
+   * containing a cycle, both as `NestingDepthExceeded` (the node path keeps
+   * no ancestor set, so a cycle is caught by the depth cap, not reported as
+   * `CircularReference`).
+   *
+   * @remarks
+   * `YamlStringifyOptions.lineWidth` is not honored here, for the reason
+   * given on {@link YamlDocument.stringify}.
+   *
+   * @example
+   * ```ts
+   * import { YamlDocument } from "@effected/yaml";
+   * import { Result } from "effect";
+   *
+   * const parsed = YamlDocument.parseResult("# keep\nname: Alice\n");
+   * if (Result.isSuccess(parsed)) {
+   *   const text = parsed.success.stringifyResult();
+   *   if (Result.isSuccess(text)) console.log(text.success); // => "# keep\nname: Alice\n"
+   * }
+   * ```
+   *
+   * @param options - Optional {@link YamlStringifyOptions}; defaults apply for
+   *   omitted fields.
+   * @returns A `Result` succeeding with the YAML text, or failing with
+   *   {@link YamlStringifyError}.
+   */
+  stringifyResult(options?: YamlStringifyOptions): Result.Result<string, YamlStringifyError>;
   /**
    * Reconstruct the plain JavaScript value of this document's contents,
    * resolving anchors and aliases. `null` for an empty document. Pure and
@@ -1115,8 +1199,6 @@ export declare class YamlDocument extends YamlDocument_base {
    */
   toValue(): unknown;
 }
-//#endregion
-//#region src/YamlFormat.d.ts
 /**
  * A range accepted at the `format`/`formatToString`/etc. call sites: either a
  * {@link YamlRange} instance or a plain `{ offset, length }` literal (the two
@@ -1326,7 +1408,9 @@ export declare class YamlFormat {
    */
   static formatToString(text: string, range?: YamlRangeLike, options?: YamlFormattingOptions): string;
   /**
-   * Compute the edits that insert, replace, or remove a value at `path`.
+   * Compute the edits that insert, replace, or remove a value at `path`,
+   * synchronously — the primitive {@link YamlFormat.modify} is defined in
+   * terms of, so a synchronous host can call it without an Effect runtime.
    * Passing `value === undefined` removes the target key/element; a missing
    * insertion target appends after the last pair/element. Fails with
    * {@link YamlModificationError} on a fatal parse error or a structural
@@ -1362,8 +1446,10 @@ export declare class YamlFormat {
    *
    * Two replacement values have no finite rendering and fail typed rather
    * than hanging or overflowing the stack: one containing a circular
-   * reference (`CircularReference`) and one nesting deeper than 256 levels
-   * (`NestingDepthExceeded`).
+   * reference (`CircularReference`) and one that would sit deeper than 256
+   * levels in the output document (`NestingDepthExceeded`). The depth is
+   * counted from the document root, so the same value can fit at `[]` and
+   * fail a few keys down.
    *
    * **Single-document contract.** A `path` carries no document index, so on
    * a multi-document stream there is no rule for which document it names —
@@ -1388,15 +1474,60 @@ export declare class YamlFormat {
    *   target instead.
    * @param options - Optional {@link YamlStringifyOptions} for the
    *   re-stringify step.
-   * @returns An `Effect` that succeeds with the edits to apply (via
-   *   `YamlEdit.applyAll`), or fails with {@link YamlModificationError}.
+   * @returns A `Result` succeeding with the edits to apply (via
+   *   `YamlEdit.applyAll`), or failing with {@link YamlModificationError}.
    *
    * @remarks
    * `options` is a bare {@link YamlStringifyOptions} — it controls only the
    * internal re-stringify step, not a range (there is no range to restrict
    * for a path-targeted modification).
    */
+  static modifyResult(text: string, path: YamlPath, value: unknown, options?: YamlStringifyOptions): Result.Result<ReadonlyArray<YamlEdit>, YamlModificationError>;
+  /**
+   * Compute the edits that insert, replace, or remove a value at `path`.
+   * Defined in terms of {@link YamlFormat.modifyResult}, which carries the
+   * full contract — value lowering, region-confined scalar replacement, the
+   * single-document contract and the directive refusal — behind a
+   * `YamlFormat.modify` span; synchronous callers can use that variant
+   * directly.
+   *
+   * @param text - The YAML source to modify.
+   * @param path - The location to insert, replace or remove.
+   * @param value - The JavaScript value to write; `undefined` removes the
+   *   target instead.
+   * @param options - Optional {@link YamlStringifyOptions} for the
+   *   re-stringify step.
+   * @returns An `Effect` that succeeds with the edits to apply (via
+   *   `YamlEdit.applyAll`), or fails with {@link YamlModificationError}.
+   */
   static readonly modify: (text: string, path: YamlPath, value: unknown, options?: YamlStringifyOptions | undefined) => Effect.Effect<readonly YamlEdit[], YamlModificationError, never>;
+  /**
+   * Synchronous {@link YamlFormat.modifyToString}: modify `text` and apply the
+   * resulting edits in one step (`YamlEdit.applyAll ∘ modifyResult`),
+   * returning a `Result`. Inherits the {@link YamlFormat.modifyResult} error
+   * channel.
+   *
+   * @example
+   * ```ts
+   * import { YamlFormat } from "@effected/yaml";
+   * import { Result } from "effect";
+   *
+   * const result = YamlFormat.modifyToStringResult("port: 3000 # dev\n", ["port"], 8080);
+   * if (Result.isSuccess(result)) {
+   *   console.log(result.success); // => "port: 8080 # dev\n"
+   * }
+   * ```
+   *
+   * @param text - The YAML source to modify.
+   * @param path - The location to insert, replace or remove.
+   * @param value - The JavaScript value to write; `undefined` removes the
+   *   target instead.
+   * @param options - Optional {@link YamlStringifyOptions} for the
+   *   re-stringify step.
+   * @returns A `Result` succeeding with the modified text, or failing with
+   *   {@link YamlModificationError}.
+   */
+  static modifyToStringResult(text: string, path: YamlPath, value: unknown, options?: YamlStringifyOptions): Result.Result<string, YamlModificationError>;
   /**
    * Modify `text` and apply the resulting edits in one step
    * (`YamlEdit.applyAll ∘ modify`). Inherits the {@link YamlFormat.modify}
@@ -1412,11 +1543,13 @@ export declare class YamlFormat {
    *   re-stringify step.
    * @returns An `Effect` that succeeds with the modified text, or fails with
    *   {@link YamlModificationError}.
+   *
+   * @remarks
+   * Defined in terms of {@link YamlFormat.modifyToStringResult}; it opens its
+   * own span, with no nested `YamlFormat.modify` child span.
    */
   static readonly modifyToString: (text: string, path: YamlPath, value: unknown, options?: YamlStringifyOptions | undefined) => Effect.Effect<string, YamlModificationError, never>;
 }
-//#endregion
-//#region src/YamlToken.d.ts
 /**
  * The 22 lexical token kinds produced by the YAML tokenizer.
  *
@@ -1500,8 +1633,6 @@ export declare class YamlTokens {
    */
   static stream(text: string): Stream.Stream<YamlToken>;
 }
-//#endregion
-//#region src/YamlLintRule.d.ts
 /**
  * Lint diagnostic severities. `"off"` is a config-level disable only and
  * never reaches a diagnostic — a rule set to `"off"` is not run.
@@ -1650,8 +1781,6 @@ interface YamlRule {
   readonly check: (ctx: LintContext, options: unknown) => Iterable<YamlLintDiagnostic>;
   readonly infer?: (ctx: LintContext) => Iterable<StyleObservation>;
 }
-//#endregion
-//#region src/YamlLint.d.ts
 /**
  * One entry of the config `rules` map: a bare severity literal (the common
  * case), `"off"` to disable, or a typed per-rule options object (the tuning
@@ -1938,8 +2067,6 @@ export declare class YamlLint {
    */
   static inferLenient(text: string, rules: ReadonlyArray<YamlRule>, base?: YamlLintConfig): YamlLintInference;
 }
-//#endregion
-//#region src/YamlVisitor.d.ts
 /**
  * The discriminated union of YAML AST visitor events. Every variant carries
  * `path` (segments from the document root) and `depth` (zero-based nesting
@@ -2561,6 +2688,5 @@ export declare class YamlVisitor {
    */
   static visit(text: string, options?: YamlParseOptions): Stream.Stream<YamlVisitorEvent>;
 }
-//#endregion
 export type { LintContext, LintLine, StyleObservation, YamlAliasEncoded, YamlBoundCodec, YamlLintInference, YamlMapEncoded, YamlPath, YamlRangeLike, YamlRule, YamlScalarEncoded, YamlSegment, YamlSeqEncoded };
 //# sourceMappingURL=index.d.ts.map

package/internal/composer/anchors.js

@@ -1,6 +1,6 @@
 import { YamlAlias } from "../../YamlNode.js";
 
-//#region src/internal/composer/anchors.ts
+// src/internal/composer/anchors.ts
 /**
 * Check if a pending anchor is being applied to an alias node (invalid in YAML 1.2 §3.2.2).
 * Aliases represent references to existing anchored nodes and cannot have their own anchors.
@@ -68,5 +68,4 @@ function scanName(text, start) {
 	return text.slice(start, end);
 }
 
-//#endregion
 export { checkAnchorOnAlias, getAliasName, getAnchorName, makeAlias, registerAnchor, scanName };

package/internal/composer/block.js

@@ -4,7 +4,7 @@ import { blankAboveIsKeepChompContent, columnAt, hasBlankLineAbove, isAfterIndic
 import { enterNesting, exitNesting, hasMeta, hasNonWhitespaceBeforeOnLine, lineCol, lineIndentColumn, sameLine } from "./state.js";
 import { blockMapStartsWithValueSep, classifyPlainNumeric, collectMultilineKey, collectMultilinePlainScalar, findFirstContent, findLastContent, findNextContentInList, findNextSignificantChild, findValueSepOffset, getScalarStyle, hasValueSepAfterInList, hasValueSepBetween, hasValueSepThroughPlainScalars, makeScalar, resolveScalar, shouldPreserveRaw } from "./scalars.js";
 
-//#region src/internal/composer/block.ts
+// src/internal/composer/block.ts
 /**
 * Compose a block map from its CST children, with an optional external first key.
 *
@@ -1429,5 +1429,4 @@ function composeFlatBlockMap(children, startIdx, parentCst, state, externalFirst
 	return map;
 }
 
-//#endregion
 export { buildPairs, checkDuplicateKeys, checkMultilineImplicitKeys, checkTrailingContentOnSameLine, composeBlockMap, composeBlockSeq, composeFlatBlockMap, flattenBlockMapChildren, keyIdentity };

package/internal/composer/comments.js

@@ -1,6 +1,6 @@
 import { YamlAlias, YamlMap, YamlScalar, YamlSeq } from "../../YamlNode.js";
 
-//#region src/internal/composer/comments.ts
+// src/internal/composer/comments.ts
 /** True when there is no line break between `start` and `end` in `text`. */
 function sameLineSpan(text, start, end) {
 	if (start < 0) return false;
@@ -220,5 +220,4 @@ function mergedCommentFields(existing, incoming) {
 	};
 }
 
-//#endregion
 export { blankAboveIsKeepChompContent, blankLineAboveStart, columnAt, hasBlankLineAbove, hasBlankLineBelow, isAfterIndicatorOnly, isOwnLineAt, joinComments, rawCommentText, sameLineSpan, withCommentFields };

package/internal/composer/document.js

@@ -8,7 +8,7 @@ import { collectMultilinePlainScalar, findNextContentChild, getScalarStyle, hasB
 import { composeBlockMap, composeBlockSeq, composeFlatBlockMap } from "./block.js";
 import { composeFlowMap, composeFlowSeq } from "./flow.js";
 
-//#region src/internal/composer/document.ts
+// src/internal/composer/document.ts
 /** The flow-composer dispatch wired into every state this module creates. */
 const FLOW = {
 	composeFlowMap,
@@ -798,5 +798,4 @@ function stripOwnComment(node) {
 	});
 }
 
-//#endregion
 export { EMPTY_DOCUMENT, composeAllDocuments, composeDocument, composeFirstDocument, composeFirstDocumentCounted, validateCrossDocumentDirectives };

package/internal/composer/flow.js

@@ -5,7 +5,7 @@ import { enterNesting, exitNesting, hasMeta } from "./state.js";
 import { collectMultilineKey, collectMultilinePlainScalar, getScalarStyle, hasValueSepThroughPlainScalars, makeScalar, resolveScalar } from "./scalars.js";
 import { buildPairs, checkDuplicateKeys, checkMultilineImplicitKeys } from "./block.js";
 
-//#region src/internal/composer/flow.ts
+// src/internal/composer/flow.ts
 /**
 * Validate that flow collection entries are separated by commas.
 *
@@ -495,5 +495,4 @@ function composeFlowSeqInner(cst, state, meta, parentBlockColumn) {
 	return seq;
 }
 
-//#endregion
 export { composeFlowMap, composeFlowSeq, flattenFlowChildren };

package/internal/composer/scalars.js

@@ -4,7 +4,7 @@ import { rawCommentText } from "./comments.js";
 import { lineCol } from "./state.js";
 import { resolveTagHandle } from "./tags.js";
 
-//#region src/internal/composer/scalars.ts
+// src/internal/composer/scalars.ts
 const NULL_RE = /^(?:null|Null|NULL|~)$/;
 const TRUE_RE = /^(?:true|True|TRUE)$/;
 const FALSE_RE = /^(?:false|False|FALSE)$/;
@@ -930,5 +930,4 @@ function shouldPreserveRaw(rawValue, value) {
 	return false;
 }
 
-//#endregion
 export { blockMapStartsWithValueSep, classifyPlainNumeric, collectMultilineKey, collectMultilinePlainScalar, findFirstContent, findLastContent, findNextContentChild, findNextContentInList, findNextSignificantChild, findValueSepOffset, foldFlowLines, getBlockChomp, getBlockIndent, getScalarStyle, getScalarValue, hasBlockMapAfterInList, hasValueSepAfter, hasValueSepAfterInList, hasValueSepBetween, hasValueSepThroughPlainScalars, indexOfChild, makeScalar, resolveScalar, shouldPreserveRaw };

package/internal/composer/state.js

@@ -1,4 +1,4 @@
-//#region src/internal/composer/state.ts
+// src/internal/composer/state.ts
 let lineStartsText;
 let lineStartsCache = [];
 function getLineStarts(text) {
@@ -134,5 +134,4 @@ function exitNesting(state) {
 	state.depth--;
 }
 
-//#endregion
 export { clearMeta, commentProps, createState, enterNesting, exitNesting, getLineStarts, hasMeta, hasNonWhitespaceBeforeOnLine, lineCol, lineIndentColumn, sameLine };

package/internal/composer/tags.js

@@ -1,4 +1,4 @@
-//#region src/internal/composer/tags.ts
+// src/internal/composer/tags.ts
 /**
 * Resolve a tag shorthand using the document's %TAG directives.
 * For example, with `%TAG !! tag:example.com,2000:app/`, the tag `!!int`
@@ -84,5 +84,4 @@ function validateTagHandlesInDocument(docCst, state) {
 	}
 }
 
-//#endregion
 export { parseDirective, resolveTagHandle, validateTagHandlesInDocument };

package/internal/cst-parser.js

@@ -1,6 +1,6 @@
 import { lexAll } from "./lexer.js";
 
-//#region src/internal/cst-parser.ts
+// src/internal/cst-parser.ts
 /**
 * Hardening: cap CST nesting so hostile inputs cannot overflow the stack
 * while the tree is being BUILT. Set slightly above the composer's
@@ -721,5 +721,4 @@ function parseCSTAll(text) {
 	return parseDocuments(lexAll(text), text);
 }
 
-//#endregion
 export { parseCSTAll };

package/internal/diagnostics.js

@@ -1,4 +1,4 @@
-//#region src/internal/diagnostics.ts
+// src/internal/diagnostics.ts
 /** Error codes emitted by the lexer stage. */
 const YAML_LEX_ERROR_CODES = [
 	"UnexpectedCharacter",
@@ -93,5 +93,4 @@ function isFatalCode(code) {
 	return FATAL_CODES.has(code);
 }
 
-//#endregion
 export { FATAL_CODES, YAML_COMPOSE_ERROR_CODES, YAML_LEX_ERROR_CODES, YAML_MODIFY_ERROR_CODES, YAML_PARSE_ERROR_CODES, YAML_STRINGIFY_ERROR_CODES, isFatalCode };

package/internal/diff.js

@@ -1,4 +1,4 @@
-//#region src/internal/diff.ts
+// src/internal/diff.ts
 /**
 * Compute edits by diffing two strings character by character.
 *
@@ -52,5 +52,4 @@ function computeEdits(original, modified) {
 	}];
 }
 
-//#endregion
 export { computeEdits };

package/internal/fold.js

@@ -1,4 +1,4 @@
-//#region src/internal/fold.ts
+// src/internal/fold.ts
 /**
 * Column-based line folding for a single logical scalar line (YAML 1.2 flow
 * folding, §7.3 / §8.2.1). Breaks the content at "safe" single-space
@@ -246,5 +246,4 @@ function renderBlockFolded(s, indent, explicitChomp, explicitIndent) {
 	return `>${indentIndicator}${chomp}\n${outputLines.join("\n")}`;
 }
 
-//#endregion
 export { foldRenderedScalar, foldScalarLine, hasInteriorTrailingWhitespace, hasNewlineSpacesTab, isControlChar, renderBlockFolded, renderBlockLiteral, renderSingleQuotedMultiline };

package/internal/lexer.js

@@ -1,4 +1,4 @@
-//#region src/internal/lexer.ts
+// src/internal/lexer.ts
 /**
 * Create a new YAML scanner for the given source text.
 *
@@ -959,5 +959,4 @@ function lexAll(text) {
 	return tokens;
 }
 
-//#endregion
 export { createScanner, lexAll };

package/internal/requote.js

@@ -1,7 +1,7 @@
 import { isControlChar } from "./fold.js";
 import { renderDoubleQuoted, renderSingleQuoted } from "./stringifier.js";
 
-//#region src/internal/requote.ts
+// 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
@@ -44,5 +44,4 @@ function requoteScalarText(text, scalar, quote, mode) {
 	return renderSingleQuoted(scalar.value);
 }
 
-//#endregion
 export { requoteScalarText };

package/internal/rules/catalog.js

@@ -13,7 +13,7 @@ import { quotedStrings, quotedStringsOptions } from "./quoted-strings.js";
 import { trailingSpaces, trailingSpacesOptions } from "./trailing-spaces.js";
 import { truthy, truthyOptions } from "./truthy.js";
 
-//#region src/internal/rules/catalog.ts
+// src/internal/rules/catalog.ts
 const catalog = [
 	[parseValidity, parseValidityOptions],
 	[lineLength, lineLengthOptions],
@@ -35,5 +35,4 @@ const builtinRules = catalog.map(([rule]) => rule);
 /** Per-rule options schemas — the rule-aware half of config validation. */
 const builtinOptionsSchemas = new Map(catalog.map(([rule, options]) => [rule.id, options]));
 
-//#endregion
 export { builtinOptionsSchemas, builtinRules };

package/internal/rules/colon-spacing.js

@@ -3,7 +3,7 @@ import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { nonNegativeIntegerOption, positiveIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
-//#region src/internal/rules/colon-spacing.ts
+// src/internal/rules/colon-spacing.ts
 /**
 * Options for `colon-spacing`: `maxSpacesBefore` (default 0) and
 * `maxSpacesAfter` (default 1) around the `:` indicator. `maxSpacesBefore: 0`
@@ -73,5 +73,4 @@ const colonSpacing = {
 	}
 };
 
-//#endregion
 export { colonSpacing, colonSpacingOptions };

package/internal/rules/comments-spacing.js

@@ -3,7 +3,7 @@ import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintR
 import { nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
-//#region src/internal/rules/comments-spacing.ts
+// src/internal/rules/comments-spacing.ts
 /**
 * Options for `comments-spacing`: `minSpacesBefore` between content and a
 * trailing `#` (default 1 — the kit's own emission spelling) and
@@ -103,5 +103,4 @@ const commentsSpacing = {
 	}
 };
 
-//#endregion
 export { commentsSpacing, commentsSpacingOptions };

package/internal/rules/document-end.js

@@ -2,7 +2,7 @@ import { YamlEdit } from "../../YamlEdit.js";
 import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
 import { Schema } from "effect";
 
-//#region src/internal/rules/document-end.ts
+// src/internal/rules/document-end.ts
 /** Options for `document-end`: require (`true`, default) or forbid the marker. */
 const documentEndOptions = Schema.Struct({
 	severity: Schema.optionalKey(YamlLintSeverity),
@@ -91,5 +91,4 @@ const documentEnd = {
 	}
 };
 
-//#endregion
 export { documentEnd, documentEndOptions };