@effected/yaml 0.15.0 → 0.15.1

package/YamlFormat.js

@@ -1,7 +1,7 @@
 import { YamlMap, YamlPair, YamlScalar, YamlSeq } from "./YamlNode.js";
 import { EMPTY_DOCUMENT, composeAllDocuments, composeFirstDocumentCounted } from "./internal/composer/document.js";
 import { isFatalCode } from "./internal/diagnostics.js";
-import { stringifyDocument, stripNodeComments } from "./internal/stringifier.js";
+import { renderDoubleQuoted, renderSingleQuoted, stringifyDocument, stringifyValue, stripNodeComments } from "./internal/stringifier.js";
 import { YamlDiagnostic } from "./YamlDiagnostic.js";
 import { YamlStringifyOptions } from "./Yaml.js";
 import { YamlEdit, YamlRange } from "./YamlEdit.js";
@@ -192,6 +192,17 @@ function toOutputDocument(doc, preserveComments) {
 * A multi-document stream routes to {@link formatStream}, which formats
 * every document and shares the same directive refusal.
 */
+/**
+* Re-attach the source's leading byte-order mark to a whole-document
+* re-emission. The stringifier never emits a BOM (it is framing, not
+* content), so without this every `format` and whole-pipeline `modify` on a
+* BOM-prefixed file would produce a delete-at-offset-0 edit. Preserving it
+* keeps the file's encoding signature the author's business, in line with
+* the fidelity contract that leaves untouched bytes alone.
+*/
+function withSourceBom(text, formatted) {
+	return text.startsWith("") ? `\uFEFF${formatted}` : formatted;
+}
 function formatDocument(text, options) {
 	const { documents, streamErrors } = composeAllDocuments(text, {});
 	if (documents.length > 1) return formatStream(text, documents, streamErrors, options);
@@ -402,6 +413,140 @@ function rebuildSeq(node, items) {
 	});
 }
 /**
+* Whether a value carries characters single-quoted style cannot express (it
+* escapes only `'`): C0 controls — newline, carriage return, tab among them —
+* plus DEL and the C1 range, the same conservative set the requote helper
+* uses. A value carrying any of these keeps the whole-document pipeline
+* rather than switching quote style. Char-code based, mirroring the
+* stringifier's own control-character checks.
+*/
+function isSingleQuoteUnsafe(s) {
+	for (let i = 0; i < s.length; i++) {
+		const code = s.charCodeAt(i);
+		if (code <= 31 || code >= 127 && code <= 159) return true;
+	}
+	return false;
+}
+/**
+* Read-only navigation twin of `modifyNode`: returns the EXISTING node at
+* `path` together with whether its parent collection is flow-styled, or
+* `undefined` whenever the path does not resolve to a node (missing
+* key/index, non-navigable node, empty path, null value mid-path).
+* `undefined` sends `modify` down its normal pipeline, which owns the
+* insert/append/remove semantics and the typed navigation errors — this
+* helper never throws and never guesses.
+*/
+function findExistingTarget(contents, path) {
+	if (contents === null || path.length === 0) return void 0;
+	let current = contents;
+	for (let depth = 0; depth < path.length; depth++) {
+		const segment = path[depth];
+		const isLast = depth === path.length - 1;
+		if (current instanceof YamlMap) {
+			const pair = current.items.find((p) => p.key instanceof YamlScalar && p.key.value === segment);
+			if (pair === void 0) return void 0;
+			if (isLast) return {
+				node: pair.value,
+				inFlow: current.style === "flow"
+			};
+			if (pair.value === null) return void 0;
+			current = pair.value;
+		} else if (current instanceof YamlSeq) {
+			const idx = typeof segment === "number" ? segment : Number(segment);
+			if (Number.isNaN(idx) || idx < 0 || idx >= current.items.length) return void 0;
+			const child = current.items[idx];
+			if (isLast) return {
+				node: child,
+				inFlow: current.style === "flow"
+			};
+			current = child;
+		} else return;
+	}
+}
+/**
+* Render the replacement text for a region-confined splice, or `undefined`
+* to fall back. A string keeps the target's quote style when that style can
+* express it (single-quoted escapes only `'`, so newlines/tabs/controls bail
+* out; double-quoted expresses everything); a non-string into a quoted
+* target renders through `stringifyValue` — quoting it would change the
+* resolved type — as does any plain target, so the stringifier's own
+* plain-safety rules decide whether the text needs quotes — under the
+* target's own context, so a flow indicator inside a value spliced into a
+* flow collection is quoted rather than corrupting the collection (#695). A
+* rendering that spans lines (folding, block styles) bails out: the fast
+* path never introduces a line break inside the spliced region.
+*/
+function renderRegionalScalarText(target, value, inFlow, options) {
+	let rendered;
+	if (typeof value === "string" && target.style === "single-quoted") {
+		if (isSingleQuoteUnsafe(value)) return void 0;
+		rendered = renderSingleQuoted(value);
+	} else if (typeof value === "string" && target.style === "double-quoted") rendered = renderDoubleQuoted(value);
+	else rendered = stringifyValue(value, {
+		...toStringifyInput(options),
+		finalNewline: false,
+		inFlow
+	});
+	if (/[\n\r]/.test(rendered)) return void 0;
+	return rendered;
+}
+/**
+* Prove the rendered text means exactly what the caller asked: re-compose a
+* one-pair probe document and compare the resolved scalar with `Object.is`.
+* The probe mirrors the target's context — `k: [rendered]` for a flow
+* parent, so a rendering that would split or close the collection is caught
+* as a structural surprise rather than a quiet corruption. Any parse error,
+* structural surprise, or value drift (a plain rendering that re-resolves
+* as a bool/timestamp instead of the caller's string, say) bails out to the
+* whole-document pipeline.
+*/
+function regionalRenderPreservesValue(rendered, value, inFlow) {
+	const probeText = inFlow ? `k: [${rendered}]\n` : `k: ${rendered}\n`;
+	const { document: probeDoc } = composeFirstDocumentCounted(probeText, {});
+	if (probeDoc.errors.some((e) => isFatalCode(e.code))) return false;
+	const contents = probeDoc.contents;
+	if (!(contents instanceof YamlMap)) return false;
+	let node = contents.items.find((p) => p.key instanceof YamlScalar && p.key.value === "k")?.value;
+	if (inFlow) {
+		if (!(node instanceof YamlSeq) || node.items.length !== 1) return false;
+		node = node.items[0];
+	}
+	if (!(node instanceof YamlScalar)) return false;
+	return Object.is(node.value, value);
+}
+/**
+* Attempt the region-confined scalar splice for `modify` (#659): replace
+* only the target scalar's byte range, re-emitting its original quote
+* character and leaving line endings (and every other byte) elsewhere
+* untouched. Returns the single edit, an empty array for a no-op
+* replacement, or `undefined` when any precondition fails — the caller then
+* runs the existing compose → replace → re-stringify → diff pipeline
+* unchanged.
+*/
+function tryRegionalScalarEdit(text, doc, path, value, options) {
+	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return;
+	if (options?.defaultScalarStyle !== void 0 || options?.forceDefaultStyles || options?.sortKeys === true || options?.indent !== void 0 || options?.indentSequences !== void 0 || options?.finalNewline !== void 0) return void 0;
+	const found = findExistingTarget(doc.contents, path);
+	if (found === void 0) return void 0;
+	const { node: target, inFlow } = found;
+	if (!(target instanceof YamlScalar)) return void 0;
+	if (target.length <= 0) return void 0;
+	if (target.tag !== void 0 || target.anchor !== void 0) return void 0;
+	if (target.style !== "plain" && target.style !== "single-quoted" && target.style !== "double-quoted") return;
+	if (target.sourceMultiline === true) return void 0;
+	const span = text.slice(target.offset, target.offset + target.length);
+	if (/[\n\r]/.test(span)) return void 0;
+	const rendered = renderRegionalScalarText(target, value, inFlow, options);
+	if (rendered === void 0) return void 0;
+	if (rendered === span) return [];
+	if (!regionalRenderPreservesValue(rendered, value, inFlow)) return void 0;
+	return [{
+		offset: target.offset,
+		length: target.length,
+		content: rendered
+	}];
+}
+/**
 * Formatting and modification statics. Not instantiable.
 *
 * @remarks
@@ -482,7 +627,7 @@ var YamlFormat = class YamlFormat {
 	static format(text, range, options) {
 		const formatted = formatDocument(text, options);
 		if (formatted === void 0) return [];
-		let edits = computeEdits(text, formatted);
+		let edits = computeEdits(text, withSourceBom(text, formatted));
 		const effectiveRange = resolveRange(range, options?.range);
 		if (effectiveRange !== void 0) {
 			const rangeStart = effectiveRange.offset;
@@ -519,10 +664,29 @@ var YamlFormat = class YamlFormat {
 	* `stringify` agree on what a given JavaScript value means. (Before
 	* 0.14.0 only scalars were lowered and a mapping or sequence value was
 	* coerced through `String(value)`, writing the literal text
-	* `[object Object]` into the document — see #642.) Only the surrounding
-	* document is preserved byte-for-byte; the replacement subtree is
-	* synthesized, so it carries no comments and takes the stringifier's
-	* styles.
+	* `[object Object]` into the document — see #642.) For a synthesized
+	* subtree (an object/array value) only the surrounding document is
+	* preserved byte-for-byte; the subtree carries no comments and takes the
+	* stringifier's styles.
+	*
+	* **Scalar replacement is region-confined and quote-preserving (#659).**
+	* When the path resolves to an existing single-line `plain`,
+	* `single-quoted`, or `double-quoted` scalar with no tag or anchor, and
+	* the replacement is a string, number, or boolean, `modify` splices
+	* ONLY the target scalar's source span and emits a single edit: a string
+	* into a quoted scalar keeps the original quote character, a non-string
+	* renders plain (quoting it would change the resolved type), and every
+	* byte outside the span — line endings included, so a CRLF document keeps
+	* its CRLFs and a same-line trailing comment survives — is untouched. The
+	* splice is taken only when the rendered text re-parses to exactly the
+	* caller's value and renders as a single line; a no-op replacement yields
+	* no edits. Anything else — removals (`value === undefined`), nulls,
+	* insertions, object/array values, block or multi-line scalars, tagged or anchored
+	* targets, or any document-shaping / explicit-style option
+	* (`defaultScalarStyle`, `forceDefaultStyles`, `sortKeys`, `indent`,
+	* `indentSequences`, `finalNewline`) — falls back to re-serialising the
+	* whole document, which normalises line endings to LF, applies those
+	* options, and renders the replacement in the stringifier's styles.
 	*
 	* Two replacement values have no finite rendering and fail typed rather
 	* than hanging or overflowing the stack: one containing a circular
@@ -576,6 +740,8 @@ var YamlFormat = class YamlFormat {
 				length: 0
 			}, text)]
 		});
+		const regional = tryRegionalScalarEdit(text, doc, path, value, options);
+		if (regional !== void 0) return regional.map((e) => YamlEdit.make(e));
 		let newContents;
 		try {
 			newContents = modifyDocument(doc, path, value);
@@ -596,7 +762,7 @@ var YamlFormat = class YamlFormat {
 			contents: newContents
 		};
 		const formatted = stringifyDocument(outputDoc, toStringifyInput(options));
-		return computeEdits(text, formatted).map((e) => YamlEdit.make(e));
+		return computeEdits(text, withSourceBom(text, formatted)).map((e) => YamlEdit.make(e));
 	});
 	/**
 	* Modify `text` and apply the resulting edits in one step

package/index.d.ts

@@ -1230,10 +1230,29 @@ export declare class YamlFormat {
    * `stringify` agree on what a given JavaScript value means. (Before
    * 0.14.0 only scalars were lowered and a mapping or sequence value was
    * coerced through `String(value)`, writing the literal text
-   * `[object Object]` into the document — see #642.) Only the surrounding
-   * document is preserved byte-for-byte; the replacement subtree is
-   * synthesized, so it carries no comments and takes the stringifier's
-   * styles.
+   * `[object Object]` into the document — see #642.) For a synthesized
+   * subtree (an object/array value) only the surrounding document is
+   * preserved byte-for-byte; the subtree carries no comments and takes the
+   * stringifier's styles.
+   *
+   * **Scalar replacement is region-confined and quote-preserving (#659).**
+   * When the path resolves to an existing single-line `plain`,
+   * `single-quoted`, or `double-quoted` scalar with no tag or anchor, and
+   * the replacement is a string, number, or boolean, `modify` splices
+   * ONLY the target scalar's source span and emits a single edit: a string
+   * into a quoted scalar keeps the original quote character, a non-string
+   * renders plain (quoting it would change the resolved type), and every
+   * byte outside the span — line endings included, so a CRLF document keeps
+   * its CRLFs and a same-line trailing comment survives — is untouched. The
+   * splice is taken only when the rendered text re-parses to exactly the
+   * caller's value and renders as a single line; a no-op replacement yields
+   * no edits. Anything else — removals (`value === undefined`), nulls,
+   * insertions, object/array values, block or multi-line scalars, tagged or anchored
+   * targets, or any document-shaping / explicit-style option
+   * (`defaultScalarStyle`, `forceDefaultStyles`, `sortKeys`, `indent`,
+   * `indentSequences`, `finalNewline`) — falls back to re-serialising the
+   * whole document, which normalises line endings to LF, applies those
+   * options, and renders the replacement in the stringifier's styles.
    *
    * Two replacement values have no finite rendering and fail typed rather
    * than hanging or overflowing the stack: one containing a circular

package/internal/composer/comments.js

@@ -150,10 +150,17 @@ function rawCommentText(source) {
 function joinComments(a, b) {
 	return a === void 0 ? b : `${a}\n${b}`;
 }
-/** Zero-based column of `offset` within its line. */
+/**
+* Zero-based column of `offset` within its line. A byte-order mark at the
+* line start occupies no column — the lexer's convention (#694) — so a
+* BOM-prefixed root mapping's content column is `0`, not `1`, and its
+* terminal own-line comment is not mistaken for one escaping a nested map.
+*/
 function columnAt(text, offset) {
 	if (offset <= 0) return 0;
-	return offset - (text.lastIndexOf("\n", offset - 1) + 1);
+	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+	const bom = text[lineStart] === "" && offset > lineStart ? 1 : 0;
+	return offset - lineStart - bom;
 }
 /**
 * Rebuild `node` with the given comment fields merged in (existing fields are

package/internal/composer/state.js

@@ -9,6 +9,11 @@ function getLineStarts(text) {
 	lineStartsCache = starts;
 	return starts;
 }
+/**
+* Zero-based line and column of `offset`. A byte-order mark at the line start
+* occupies no column, matching the lexer and `columnAt` (#694), so a
+* diagnostic's `character` behind a BOM equals the BOM-less document's.
+*/
 function lineCol(text, offset) {
 	const starts = getLineStarts(text);
 	const pos = Math.min(Math.max(offset, 0), text.length);
@@ -19,9 +24,11 @@ function lineCol(text, offset) {
 		if (starts[mid] <= pos) lo = mid;
 		else hi = mid - 1;
 	}
+	const lineStart = starts[lo];
+	const bom = text[lineStart] === "" && pos > lineStart ? 1 : 0;
 	return {
 		line: lo,
-		column: pos - starts[lo]
+		column: pos - lineStart - bom
 	};
 }
 /**

package/internal/lexer.js

@@ -665,10 +665,8 @@ function createScanner(text) {
 		const ch = peek();
 		if (ch === "") {
 			const start = pos;
-			const sLine = line;
-			const sCol = col;
-			advance();
-			return makeToken("byte-order-mark", "", start, sLine, sCol);
+			pos++;
+			return makeToken("byte-order-mark", "", start, line, col);
 		}
 		if (isNewline(ch)) return scanNewline();
 		if (isWhitespace(ch)) return scanWhitespace();
@@ -922,7 +920,7 @@ function createScanner(text) {
 				if (text[pos] === "\n") {
 					line++;
 					col = 0;
-				} else col++;
+				} else if (text[pos] !== "") col++;
 				pos++;
 			}
 			lineIndent = 0;

package/internal/stringifier.js

@@ -133,10 +133,17 @@ function wouldBeResolved11(s) {
 * `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.
+*
+* `inFlow` is additive too: inside a flow collection the flow indicators
+* `,[]{}` are plain-unsafe anywhere in the scalar (YAML 1.2 §7.3.3,
+* `ns-plain-safe(flow-in)` excludes `c-flow-indicator`), where block context
+* lets them through. Without it a plain `p, q` rendered into `[x, y]` reads
+* back as three items (#695).
 */
-function requiresQuoting(s, ignoreType = false, quoteCompat) {
+function requiresQuoting(s, ignoreType = false, quoteCompat, inFlow = false) {
 	if (s === "") return true;
 	if (s.includes("\n")) return true;
+	if (inFlow && /[,[\]{}]/.test(s)) return true;
 	if (!ignoreType && wouldBeResolved(s)) return true;
 	if (!ignoreType && quoteCompat === "yaml-1.1" && wouldBeResolved11(s)) return true;
 	const first = s[0];
@@ -219,7 +226,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, quoteCompat) {
+function renderString(s, style, indent, ignoreType = false, canonical = false, explicitChomp, parentPosition, quoteStyle = "single", explicitIndent, quoteCompat, inFlow = false) {
 	const fidelity = !canonical;
 	const fidelityIndent = fidelity ? explicitIndent : void 0;
 	if (s.includes("\n")) {
@@ -252,7 +259,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, quoteCompat)) {
+			if (requiresQuoting(s, ignoreType, quoteCompat, inFlow)) {
 				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);
@@ -313,7 +320,8 @@ function createContext(options) {
 		quoteStyle: options?.quoteStyle ?? "single",
 		quoteCompat: options?.quoteCompat,
 		forceDefaultStyles: options?.forceDefaultStyles ?? false,
-		seen: /* @__PURE__ */ new Set()
+		seen: /* @__PURE__ */ new Set(),
+		inFlow: options?.inFlow ?? false
 	};
 }
 /**
@@ -331,7 +339,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, void 0, ctx.quoteCompat);
+		const rendered = renderString(value, ctx.defaultScalarStyle, indentStr, false, ctx.forceDefaultStyles, void 0, void 0, ctx.quoteStyle, void 0, ctx.quoteCompat, ctx.inFlow);
 		return (allowFold && ctx.lineWidth > 0 ? foldRenderedScalar(rendered, indentStr, ctx.lineWidth) : rendered).split("\n");
 	}
 	if (Array.isArray(value)) {
@@ -359,7 +367,13 @@ function stringifyLines(value, ctx, depth, allowFold = true) {
 */
 function stringifyArrayLines(arr, ctx, depth) {
 	if (arr.length === 0) return ["[]"];
-	if (ctx.defaultCollectionStyle === "flow") return [`[${arr.map((item) => stringifyLines(item, ctx, depth + 1, false).join(" ")).join(", ")}]`];
+	if (ctx.defaultCollectionStyle === "flow") {
+		const flowCtx = {
+			...ctx,
+			inFlow: true
+		};
+		return [`[${arr.map((item) => stringifyLines(item, flowCtx, depth + 1, false).join(" ")).join(", ")}]`];
+	}
 	const pad = " ".repeat(ctx.indent);
 	const lines = [];
 	for (const item of arr) {
@@ -396,10 +410,16 @@ 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, void 0, ctx.quoteCompat);
-	if (ctx.defaultCollectionStyle === "flow") return [`{${keys.map((k) => {
-		return `${renderPlainKey(k)}: ${stringifyLines(obj[k], ctx, depth + 1, false).join(" ")}`;
-	}).join(", ")}}`];
+	const renderPlainKey = (k, inFlow = false) => renderString(k, "plain", "", false, false, void 0, void 0, ctx.quoteStyle, void 0, ctx.quoteCompat, inFlow);
+	if (ctx.defaultCollectionStyle === "flow") {
+		const flowCtx = {
+			...ctx,
+			inFlow: true
+		};
+		return [`{${keys.map((k) => {
+			return `${renderPlainKey(k, true)}: ${stringifyLines(obj[k], flowCtx, depth + 1, false).join(" ")}`;
+		}).join(", ")}}`];
+	}
 	const renderKey = (k) => k.includes("\n") ? renderDoubleQuoted(k, ctx.forceDefaultStyles) : renderPlainKey(k);
 	const pad = " ".repeat(ctx.indent);
 	const lines = [];
@@ -607,7 +627,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, ctx.quoteCompat).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, ctx.inFlow).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]}`;
@@ -797,6 +817,10 @@ function stringifyMapNodeLines(node, ctx, depth) {
 	}
 	if (style === "flow") {
 		const flowPrefix = buildMetadataPrefix(node.tag, node.anchor);
+		const flowCtx = {
+			...ctx,
+			inFlow: true
+		};
 		if (!ctx.forceDefaultStyles && (items.some((p) => pairLeading(p) !== void 0 || pairTrailing(p) !== void 0 || pairSpaceBefore(p) === true) || node.comment !== void 0 && node.sourceMultiline === true)) {
 			const flowPad = " ".repeat(ctx.indent);
 			const flowLines = [flowPrefix ? `${flowPrefix} {` : "{"];
@@ -805,8 +829,8 @@ function stringifyMapNodeLines(node, ctx, depth) {
 				if (pairSpaceBefore(pair) === true) flowLines.push("");
 				const flowLeading = pairLeading(pair);
 				if (flowLeading !== void 0) for (const cl of commentBlockLines(flowLeading)) flowLines.push(cl === "" ? "" : `${flowPad}${cl}`);
-				const keyStr = pair.key ? stringifyMappingKeyLines(pair.key, ctx, depth + 1).join(" ") : "null";
-				const valStr = pair.value ? stringifyNodeLines(pair.value, ctx, depth + 1).join(" ") : "null";
+				const keyStr = pair.key ? stringifyMappingKeyLines(pair.key, flowCtx, depth + 1).join(" ") : "null";
+				const valStr = pair.value ? stringifyNodeLines(pair.value, flowCtx, depth + 1).join(" ") : "null";
 				const comma = fi < items.length - 1 ? "," : "";
 				const flowTrailing = pairTrailing(pair);
 				const trailing = flowTrailing !== void 0 ? renderTrailingComment(flowTrailing) : "";
@@ -817,7 +841,7 @@ function stringifyMapNodeLines(node, ctx, depth) {
 			return flowLines;
 		}
 		let line = `{${items.map((pair) => {
-			return `${pair.key ? stringifyMappingKeyLines(pair.key, ctx, depth + 1).join(" ") : "null"}: ${pair.value ? stringifyNodeLines(pair.value, ctx, depth + 1).join(" ") : "null"}`;
+			return `${pair.key ? stringifyMappingKeyLines(pair.key, flowCtx, depth + 1).join(" ") : "null"}: ${pair.value ? stringifyNodeLines(pair.value, flowCtx, depth + 1).join(" ") : "null"}`;
 		}).join(", ")}}`;
 		if (flowPrefix) line = `${flowPrefix} ${line}`;
 		return [line];
@@ -1006,6 +1030,10 @@ function stringifySeqNodeLines(node, ctx, depth) {
 	};
 	if (style === "flow") {
 		const flowPrefix = buildMetadataPrefix(node.tag, node.anchor);
+		const flowCtx = {
+			...ctx,
+			inFlow: true
+		};
 		if (emitComments && (items.some((it) => itemFields(it) !== void 0) || node.comment !== void 0 && node.sourceMultiline === true)) {
 			const flowPad = " ".repeat(ctx.indent);
 			const flowLines = [flowPrefix ? `${flowPrefix} [` : "["];
@@ -1014,7 +1042,7 @@ function stringifySeqNodeLines(node, ctx, depth) {
 				const fields = itemFields(item);
 				if (fields?.spaceBefore === true) flowLines.push("");
 				if (fields?.commentBefore !== void 0) for (const cl of commentBlockLines(fields.commentBefore)) flowLines.push(cl === "" ? "" : `${flowPad}${cl}`);
-				const itemStr = stringifyNodeLines(item, ctx, depth + 1).join(" ");
+				const itemStr = stringifyNodeLines(item, flowCtx, depth + 1).join(" ");
 				const comma = fi < items.length - 1 ? "," : "";
 				const trailing = fields?.comment !== void 0 ? renderTrailingComment(fields.comment) : "";
 				flowLines.push(`${flowPad}${itemStr}${comma}${trailing}`);
@@ -1023,7 +1051,7 @@ function stringifySeqNodeLines(node, ctx, depth) {
 			flowLines.push("]");
 			return flowLines;
 		}
-		let line = `[${items.map((item) => stringifyNodeLines(item, ctx, depth + 1).join(" ")).join(", ")}]`;
+		let line = `[${items.map((item) => stringifyNodeLines(item, flowCtx, depth + 1).join(" ")).join(", ")}]`;
 		if (flowPrefix) line = `${flowPrefix} ${line}`;
 		return [line];
 	}

package/package.json

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