@effected/yaml 0.13.0 → 0.14.0

package/YamlFormat.js

@@ -238,8 +238,56 @@ function formatStream(text, documents, streamErrors, options) {
 	}
 	return parts.join("");
 }
-/** Convert a plain JS scalar value into a synthetic `YamlScalar` (offset/length are irrelevant — immediately re-stringified). */
-function jsValueToNode(value) {
+/**
+* Lower a plain JavaScript value into synthetic AST nodes (offset/length are
+* irrelevant — the result is immediately re-stringified).
+*
+* Recursive by design: an array becomes a block {@link YamlSeq} and any other
+* non-null object a block {@link YamlMap} over its own enumerable string keys,
+* matching what `Yaml.stringify` does with the same value on the value path.
+* Before this was recursive, a mapping or sequence value fell through to the
+* node stringifier's `String(value)` fallback and landed in the document as
+* the literal text `[object Object]` — a silent corruption that only surfaced
+* on the next read (#642).
+*
+* The two conditions with no finite rendering fail typed rather than hanging
+* or overflowing the stack: a cycle raises `CircularReference` and a graph
+* deeper than `MAX_NESTING_DEPTH` raises `NestingDepthExceeded`. `seen` holds
+* the ancestors of the value being lowered, so a value repeated across
+* siblings (a shared, acyclic sub-object) is lowered twice rather than
+* rejected.
+*/
+function jsValueToNode(value, seen, depth) {
+	if (depth > 256) throw new ModifyFailure("NestingDepthExceeded", `Replacement value nests deeper than the maximum of ${256}`, 0, 0);
+	if (typeof value === "object" && value !== null) {
+		if (seen.has(value)) throw new ModifyFailure("CircularReference", "Replacement value contains a circular reference", 0, 0);
+		seen.add(value);
+		try {
+			if (Array.isArray(value)) return YamlSeq.make({
+				items: value.map((item) => jsValueToNode(item, seen, depth + 1)),
+				style: "block",
+				offset: 0,
+				length: 0
+			});
+			const record = value;
+			return YamlMap.make({
+				items: Object.keys(record).map((key) => YamlPair.make({
+					key: YamlScalar.make({
+						value: key,
+						style: "plain",
+						offset: 0,
+						length: 0
+					}),
+					value: jsValueToNode(record[key], seen, depth + 1)
+				})),
+				style: "block",
+				offset: 0,
+				length: 0
+			});
+		} finally {
+			seen.delete(value);
+		}
+	}
 	return YamlScalar.make({
 		value,
 		style: "plain",
@@ -247,8 +295,12 @@ function jsValueToNode(value) {
 		length: 0
 	});
 }
+/** Entry point for {@link jsValueToNode}: one `seen` set per lowering. */
+function lowerValue(value) {
+	return jsValueToNode(value, /* @__PURE__ */ new Set(), 0);
+}
 function modifyDocument(doc, path, value) {
-	if (path.length === 0) return value === void 0 ? null : jsValueToNode(value);
+	if (path.length === 0) return value === void 0 ? null : lowerValue(value);
 	if (doc.contents === null) throw new ModifyFailure("EmptyDocument", "Cannot navigate path in empty document", 0, 0);
 	return modifyNode(doc.contents, path, 0, value);
 }
@@ -264,7 +316,7 @@ function modifyNode(node, path, depth, value) {
 				newItems.splice(pairIndex, 1);
 				return rebuildMap(node, newItems);
 			}
-			const newValueNode = jsValueToNode(value);
+			const newValueNode = lowerValue(value);
 			if (pairIndex >= 0) {
 				const newItems = [...node.items];
 				const oldPair = newItems[pairIndex];
@@ -304,8 +356,8 @@ function modifyNode(node, path, depth, value) {
 			const newItems = [...node.items];
 			if (value === void 0) {
 				if (idx < newItems.length) newItems.splice(idx, 1);
-			} else if (idx < newItems.length) newItems[idx] = jsValueToNode(value);
-			else newItems.push(jsValueToNode(value));
+			} else if (idx < newItems.length) newItems[idx] = lowerValue(value);
+			else newItems.push(lowerValue(value));
 			return rebuildSeq(node, newItems);
 		}
 		if (idx >= node.items.length) throw new ModifyFailure("InvalidIndex", `Index ${idx} out of bounds`, node.offset, node.length);
@@ -456,12 +508,27 @@ var YamlFormat = class YamlFormat {
 	/**
 	* Compute the edits that insert, replace, or remove a value at `path`.
 	* Passing `value === undefined` removes the target key/element; a missing
-	* insertion target appends after the last pair/element. Only
-	* scalar-compatible values are supported (matching v3 — arbitrary object
-	* graphs are not recursively lowered into AST nodes). Fails with
+	* insertion target appends after the last pair/element. Fails with
 	* {@link YamlModificationError} on a fatal parse error or a structural
 	* navigation mismatch.
 	*
+	* **`value` may be a whole object graph.** An array is written as a block
+	* sequence and any other non-null object as a block mapping over its own
+	* enumerable string keys, recursively — the same lowering
+	* {@link Yaml.stringify} applies to the same value, so `modify` and
+	* `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.
+	*
+	* 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`).
+	*
 	* **Single-document contract.** A `path` carries no document index, so on
 	* a multi-document stream there is no rule for which document it names —
 	* `modify` fails with {@link YamlModificationError} carrying a

package/index.d.ts

@@ -54,7 +54,7 @@ export type YamlStringifyErrorCode = typeof YamlStringifyErrorCode.Type;
  *
  * @public
  */
-export 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", "CircularReference", "NestingDepthExceeded"]>;
 /**
  * The union of all modify-stage error code string literals.
  *
@@ -67,7 +67,7 @@ export type YamlModifyErrorCode = typeof YamlModifyErrorCode.Type;
  *
  * @public
  */
-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"]>]>;
+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", "CircularReference", "NestingDepthExceeded"]>]>;
 /**
  * The union of all YAML error code string literals.
  *
@@ -75,7 +75,7 @@ export declare const YamlErrorCode: Schema.Union<readonly [Schema.Literals<reado
  */
 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 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", "CircularReference", "NestingDepthExceeded"]>]>;
   readonly message: Schema.String;
   readonly offset: Schema.Number;
   readonly length: Schema.Number;
@@ -1219,12 +1219,27 @@ export declare class YamlFormat {
   /**
    * Compute the edits that insert, replace, or remove a value at `path`.
    * Passing `value === undefined` removes the target key/element; a missing
-   * insertion target appends after the last pair/element. Only
-   * scalar-compatible values are supported (matching v3 — arbitrary object
-   * graphs are not recursively lowered into AST nodes). Fails with
+   * insertion target appends after the last pair/element. Fails with
    * {@link YamlModificationError} on a fatal parse error or a structural
    * navigation mismatch.
    *
+   * **`value` may be a whole object graph.** An array is written as a block
+   * sequence and any other non-null object as a block mapping over its own
+   * enumerable string keys, recursively — the same lowering
+   * {@link Yaml.stringify} applies to the same value, so `modify` and
+   * `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.
+   *
+   * 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`).
+   *
    * **Single-document contract.** A `path` carries no document index, so on
    * a multi-document stream there is no rule for which document it names —
    * `modify` fails with {@link YamlModificationError} carrying a

package/internal/composer/block.js

@@ -40,7 +40,7 @@ function composeBlockMapInner(blockMapCst, state, externalFirstKey, meta) {
 	if (state.options.uniqueKeys) checkDuplicateKeys(pairs, state);
 	checkMultilineImplicitKeys(pairs, state);
 	const offset = externalFirstKey ? "offset" in externalFirstKey ? externalFirstKey.offset : blockMapCst.offset : blockMapCst.offset;
-	const length = blockMapCst.offset + blockMapCst.length - offset;
+	const length = trimDisownedTrailingComments(state.text, offset, blockMapCst.offset + blockMapCst.length, state.escapedComments) - offset;
 	const mapComment = meta?.comment !== void 0 ? trailingComment !== void 0 ? `${meta.comment}\n${trailingComment}` : meta.comment : trailingComment;
 	const map = new YamlMap({
 		items: pairs,
@@ -54,6 +54,49 @@ function composeBlockMapInner(blockMapCst, state, externalFirstKey, meta) {
 	if (meta?.anchor) registerAnchor(map, meta.anchor, state, offset);
 	return map;
 }
+/**
+* Narrow a block collection's raw CST span so it stops before any trailing
+* comment line the collection's own comment model has already DISOWNED.
+*
+* The CST length of a block map/seq runs to the end of the last physical line
+* the parser consumed, which includes a floating comment sitting at a column
+* shallower than the collection's content. The comment model deliberately
+* does not give that comment to the collection — `buildPairs` and the block-seq
+* terminal partition push it onto `state.escapedComments`, where the enclosing
+* scope re-attributes it (see `EscapedComment` in `comments.ts`: "it belongs to
+* an outer scope"). The span was the one place that disagreed, reporting an
+* `offset`/`length` whose end lay past a comment the node does not own — so a
+* caller splicing text at the end of the collection inserted AFTER the comment
+* (#642's sibling, #643).
+*
+* The disowned set is the input rather than a re-derived column test, so the
+* span and the comment model cannot drift apart: whatever the partition threw
+* out, the span excludes.
+*
+* Blank lines immediately above a trimmed run go with the run, not with the
+* last entry — but only when something was trimmed, so a collection whose span
+* merely ends in blank lines keeps the end it has always reported.
+*
+* Composition is bottom-up, so a nested collection's own span has already been
+* trimmed by the time its parent's items are read.
+*/
+function trimDisownedTrailingComments(text, offset, end, disowned) {
+	let cut = end;
+	for (const ec of disowned) {
+		if (ec.offset < offset || ec.offset >= cut) continue;
+		const lineStart = text.lastIndexOf("\n", ec.offset - 1) + 1;
+		if (lineStart <= offset || lineStart >= cut) continue;
+		cut = lineStart;
+	}
+	if (cut === end) return end;
+	while (cut > offset && text[cut - 1] === "\n") {
+		const prevLineStart = text.lastIndexOf("\n", cut - 2) + 1;
+		if (prevLineStart <= offset) break;
+		if (text.slice(prevLineStart, cut - 1).trim() !== "") break;
+		cut = prevLineStart;
+	}
+	return cut;
+}
 function flattenBlockMapChildren(children, state, externalKeyColumn, externalKeyOffset) {
 	const items = [];
 	let pendingMeta = {};
@@ -1344,11 +1387,12 @@ function composeBlockSeqInner(cst, state, meta) {
 		} else seqTrailing = withLeadingBlank(pending);
 	}
 	const seqComment = meta?.comment !== void 0 ? seqTrailing !== void 0 ? `${meta.comment}\n${seqTrailing}` : meta.comment : seqTrailing;
+	const seqEnd = trimDisownedTrailingComments(state.text, cst.offset, cst.offset + cst.length, state.escapedComments);
 	const seq = new YamlSeq({
 		items: rawItems,
 		style: "block",
 		offset: cst.offset,
-		length: cst.length,
+		length: seqEnd - cst.offset,
 		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
 		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
 		...seqComment !== void 0 ? { comment: seqComment } : {}
@@ -1371,7 +1415,7 @@ function composeFlatBlockMap(children, startIdx, parentCst, state, externalFirst
 	if (state.options.uniqueKeys) checkDuplicateKeys(pairs, state);
 	checkMultilineImplicitKeys(pairs, state);
 	const offset = "offset" in externalFirstKey ? externalFirstKey.offset : parentCst.offset;
-	const end = parentCst.offset + parentCst.length;
+	const end = trimDisownedTrailingComments(state.text, offset, parentCst.offset + parentCst.length, state.escapedComments);
 	const mapComment = meta?.comment !== void 0 ? trailingComment !== void 0 ? `${meta.comment}\n${trailingComment}` : meta.comment : trailingComment;
 	const map = new YamlMap({
 		items: pairs,

package/internal/diagnostics.js

@@ -52,6 +52,13 @@ const YAML_STRINGIFY_ERROR_CODES = ["CircularReference"];
 * not re-emit `%YAML`/`%TAG` directive lines, and re-emitting a document
 * without its `%TAG` orphans every shorthand tag that depends on it — the
 * output would be unparseable — so modify fails typed rather than corrupting.
+*
+* `CircularReference` and `NestingDepthExceeded` are the two limits on the
+* replacement value itself: `modify` lowers a plain JavaScript value into
+* AST nodes, and an object graph that points back at itself or nests deeper
+* than `MAX_NESTING_DEPTH` has no finite YAML rendering. Both names are
+* deliberately the ones the stringify and compose stages already use for the
+* same conditions, so `YamlErrorCode` gains no member.
 */
 const YAML_MODIFY_ERROR_CODES = [
 	"EmptyDocument",
@@ -59,7 +66,9 @@ const YAML_MODIFY_ERROR_CODES = [
 	"InvalidIndex",
 	"NotNavigable",
 	"MultiDocumentStream",
-	"DirectiveCarryingDocument"
+	"DirectiveCarryingDocument",
+	"CircularReference",
+	"NestingDepthExceeded"
 ];
 /**
 * The single source of truth for which diagnostic codes are fatal to a

package/package.json

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