rolldown-pnpm-config 0.1.0

package/cli/commands/upgrade.js

@@ -0,0 +1,437 @@
+import { evaluatePluginConfig } from "../evaluate.js";
+import { discoverCatalogEntries } from "../discover.js";
+import { filterEntriesByCatalog, findConfigFiles, pickConfigCandidate } from "../select-file.js";
+import { detectCapabilities } from "../ui/env.js";
+import { derivePeerRange } from "../peer-range.js";
+import { detectPeerDrift } from "../drift.js";
+import { buildEdits } from "../edits.js";
+import { buildInteropEdits, capVersions, interopEntryChanged, reentryCandidates, runInterop } from "../interop.js";
+import { planEntry } from "../plan.js";
+import { combineReleaseAge, filterByReleaseAge, parsePnpmGate, readConfigReleaseAge } from "../release-age.js";
+import { RegistryResolver, RegistryResolverLive } from "../resolve.js";
+import { applyEdits } from "../rewrite.js";
+import { renderSummary } from "../summary.js";
+import { runWalk } from "../ui/run-walk.js";
+import { buildWalkItems } from "../walk-plan.js";
+import { Data, Effect, Option } from "effect";
+import { readFileSync, writeFileSync } from "node:fs";
+import { Args, Command, Options } from "@effect/cli";
+import { NodeContext } from "@effect/platform-node";
+
+//#region src/cli/commands/upgrade.ts
+/**
+* Typed failure raised when the upgrade run cannot complete.
+*
+* @internal
+*/
+var UpgradeError = class extends Data.TaggedError("UpgradeError") {};
+/** Combine the config-declared and pnpm-resolved release-age gates (strictest of both). @internal */
+function computeGate(source, file, resolver) {
+	return Effect.gen(function* () {
+		const { config } = yield* Effect.try(() => evaluatePluginConfig(source, file)).pipe(Effect.catchAll(() => Effect.succeed({ config: null })));
+		const cfg = readConfigReleaseAge(config);
+		const [age, exc] = yield* Effect.all([resolver.pnpmConfig("minimumReleaseAge").pipe(Effect.catchAll(() => Effect.succeed(null))), resolver.pnpmConfig("minimumReleaseAgeExclude").pipe(Effect.catchAll(() => Effect.succeed(null)))], { concurrency: "unbounded" });
+		return combineReleaseAge(cfg, parsePnpmGate(age, exc));
+	});
+}
+/** Maximum number of per-package version+times fetches to issue concurrently. @internal */
+const RESOLVE_CONCURRENCY = 12;
+/**
+* Fetch and age-gate the version list for each unique package.
+*
+* @param onProgress - Optional callback invoked after each package resolves with
+*   `(resolved, total)`. Useful for emitting CLI progress feedback. Called with
+*   `(0, total)` before any work starts so callers can emit the initial banner.
+*
+* @internal
+*/
+function resolveGatedVersions(entries, resolver, gate, now, onProgress) {
+	const uniquePkgs = [...new Set(entries.map((e) => e.pkg))];
+	const total = uniquePkgs.length;
+	let resolved = 0;
+	onProgress?.(0, total);
+	return Effect.forEach(uniquePkgs, (pkg) => Effect.gen(function* () {
+		const vr = yield* resolver.versions(pkg).pipe(Effect.either);
+		if (vr._tag === "Left") {
+			onProgress?.(++resolved, total);
+			return [pkg, []];
+		}
+		const times = gate.ageMinutes > 0 ? yield* resolver.times(pkg).pipe(Effect.catchAll(() => Effect.succeed({}))) : {};
+		onProgress?.(++resolved, total);
+		return [pkg, filterByReleaseAge(vr.right, times, gate, pkg, now)];
+	}), { concurrency: 12 }).pipe(Effect.map((pairs) => new Map(pairs)));
+}
+/**
+* Write a resolve-progress line to stderr. Overwrites the previous line with
+* ANSI carriage return so the terminal shows a single updating counter instead
+* of a flood of lines. The initial call (resolved === 0) writes a newline so
+* the first subsequent overwrite lands on its own line.
+*
+* Only call when caps.interactive is true; this function is not gated itself.
+*
+* @internal
+*/
+function writeResolveProgress(resolved, total) {
+	if (resolved === 0) process.stderr.write(`Resolving ${total} package${total === 1 ? "" : "s"}...\n`);
+	else if (resolved === total) process.stderr.write(`\r  Resolved ${resolved}/${total}      \n`);
+	else process.stderr.write(`\r  Resolved ${resolved}/${total}`);
+}
+/**
+* Non-interactive upgrade core: read the config, discover catalog entries,
+* resolve + plan each, build edits for the latest-IN-RANGE candidate (and its
+* recomputed peer literal), and write the file. Never selects a major bump.
+*
+* A package whose version list gates to empty (fetch failure / fully age-gated)
+* is treated as a skip, except that a strategy entry can still resync or
+* materialize its managed peer offline from the current range.
+*
+* @internal
+*/
+function runUpgrade(opts) {
+	return Effect.gen(function* () {
+		const source = yield* Effect.try({
+			try: () => readFileSync(opts.file, "utf8"),
+			catch: () => new UpgradeError({ message: `Cannot read ${opts.file}` })
+		});
+		const { entries, skipped } = yield* Effect.try({
+			try: () => discoverCatalogEntries(source, opts.file),
+			catch: (e) => new UpgradeError({ message: String(e) })
+		});
+		const gate = yield* computeGate(source, opts.file, opts.resolver);
+		const versionsByPkg = yield* resolveGatedVersions(entries, opts.resolver, gate, Date.now(), opts.onProgress);
+		const edits = [];
+		const changedSpans = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			if (entry.strategy === "interop") continue;
+			const versions = versionsByPkg.get(entry.pkg) ?? [];
+			if (versions.length === 0) {
+				const at = entry.rangeSpan[1];
+				if (entry.peer && entry.strategy) {
+					const expected = yield* detectPeerDrift(entry).pipe(Effect.catchAll(() => Effect.succeed(null)));
+					if (expected !== null) {
+						edits.push({
+							span: entry.peer.span,
+							text: JSON.stringify(expected)
+						});
+						changedSpans.add(entry.rangeSpan[0]);
+						continue;
+					}
+				} else if (!entry.peer && entry.strategy) {
+					const peerRange = yield* derivePeerRange(entry.currentRange, entry.strategy).pipe(Effect.catchAll(() => Effect.succeed(null)));
+					if (peerRange !== null) {
+						edits.push({
+							span: [at, at],
+							text: `, peer: ${JSON.stringify(peerRange)}`
+						});
+						changedSpans.add(entry.rangeSpan[0]);
+						continue;
+					}
+				}
+				skipped.push(`${entry.catalog}.${entry.pkg}`);
+				continue;
+			}
+			const inRange = (yield* planEntry(entry, versions).pipe(Effect.catchAll(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
+			const at = entry.rangeSpan[1];
+			if (inRange) {
+				edits.push({
+					span: entry.rangeSpan,
+					text: JSON.stringify(inRange.range)
+				});
+				changedSpans.add(entry.rangeSpan[0]);
+				if (entry.peer && inRange.peerRange) edits.push({
+					span: entry.peer.span,
+					text: JSON.stringify(inRange.peerRange)
+				});
+				else if (!entry.peer && entry.strategy && inRange.peerRange) edits.push({
+					span: [at, at],
+					text: `, peer: ${JSON.stringify(inRange.peerRange)}`
+				});
+			} else if (!entry.peer && entry.strategy) {
+				const peerRange = yield* derivePeerRange(entry.currentRange, entry.strategy).pipe(Effect.catchAll(() => Effect.succeed(null)));
+				if (peerRange !== null) {
+					edits.push({
+						span: [at, at],
+						text: `, peer: ${JSON.stringify(peerRange)}`
+					});
+					changedSpans.add(entry.rangeSpan[0]);
+				}
+			} else if (entry.peer && entry.strategy) {
+				const expected = yield* detectPeerDrift(entry).pipe(Effect.catchAll(() => Effect.succeed(null)));
+				if (expected !== null) {
+					edits.push({
+						span: entry.peer.span,
+						text: JSON.stringify(expected)
+					});
+					changedSpans.add(entry.rangeSpan[0]);
+				}
+			}
+		}
+		const interopEntries = entries.filter((e) => e.strategy === "interop");
+		const conflicts = [];
+		const byCatalog = /* @__PURE__ */ new Map();
+		for (const e of interopEntries) {
+			const list = byCatalog.get(e.catalog) ?? [];
+			list.push(e);
+			byCatalog.set(e.catalog, list);
+		}
+		for (const [, group] of byCatalog) {
+			const members = [];
+			for (const e of group) {
+				const versions = versionsByPkg.get(e.pkg) ?? [];
+				const inRange = (yield* planEntry(e, versions).pipe(Effect.catchAll(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
+				const ceiling = inRange ? inRange.version : e.currentRange.replace(/^[\^~]/, "");
+				members.push({
+					pkg: e.pkg,
+					ceiling,
+					candidates: versions
+				});
+			}
+			const result = yield* runInterop(members, opts.resolver);
+			edits.push(...buildInteropEdits(group, result));
+			for (const e of group) if (interopEntryChanged(e, result)) changedSpans.add(e.rangeSpan[0]);
+			conflicts.push(...result.conflicts);
+		}
+		if (edits.length > 0) {
+			const next = applyEdits(source, edits);
+			yield* Effect.try({
+				try: () => writeFileSync(opts.file, next, "utf8"),
+				catch: () => new UpgradeError({ message: `Cannot write ${opts.file}` })
+			});
+		}
+		return {
+			updated: changedSpans.size,
+			skipped,
+			conflicts
+		};
+	});
+}
+/**
+* Apply the interactive result when interop members are present: the
+* non-interop decisions go through `buildEdits`, the interop members through
+* their separately-computed span edits. Interop members are EXCLUDED from
+* `buildEdits` so the two never emit a range edit over the same span (which
+* `applyEdits` would reject as overlapping).
+*
+* @internal
+*/
+function applyInteropAndDecisions(file, source, nonInteropDecisions, interopEdits) {
+	return Effect.gen(function* () {
+		const edits = [...buildEdits(nonInteropDecisions), ...interopEdits];
+		if (edits.length === 0) return;
+		const next = applyEdits(source, edits);
+		yield* Effect.try({
+			try: () => writeFileSync(file, next, "utf8"),
+			catch: () => new UpgradeError({ message: `Cannot write ${file}` })
+		});
+	});
+}
+/** Project walk items to the non-interactive default decisions (latest-in-range, plus peer-only keeps). @internal */
+function projectDecisions(items, full) {
+	const out = [];
+	for (const i of items) {
+		const inRange = i.candidates.find((c) => c.kind === "in-range");
+		if (inRange) {
+			out.push({
+				item: i,
+				chosen: inRange
+			});
+			continue;
+		}
+		if (i.driftPeer !== null || i.materializePeer !== null) {
+			const keep = i.candidates.find((c) => c.kind === "keep");
+			if (keep) {
+				out.push({
+					item: i,
+					chosen: keep
+				});
+				continue;
+			}
+		}
+		if (full) {
+			const keep = i.candidates.find((c) => c.kind === "keep");
+			if (keep) out.push({
+				item: i,
+				chosen: keep
+			});
+		}
+	}
+	return out;
+}
+/** Build the colored preview summary string without writing. @internal */
+function runUpgradePreview(opts) {
+	return Effect.gen(function* () {
+		const source = yield* Effect.try({
+			try: () => readFileSync(opts.file, "utf8"),
+			catch: () => new UpgradeError({ message: `Cannot read ${opts.file}` })
+		});
+		const discovered = yield* Effect.try({
+			try: () => discoverCatalogEntries(source, opts.file),
+			catch: (e) => new UpgradeError({ message: String(e) })
+		});
+		const gate = yield* computeGate(source, opts.file, opts.resolver);
+		const versions = yield* resolveGatedVersions(discovered.entries, opts.resolver, gate, Date.now());
+		return renderSummary(projectDecisions(yield* buildWalkItems(discovered.entries, versions).pipe(Effect.catchAll((e) => Effect.fail(new UpgradeError({ message: e.message })))), opts.full), void 0, { color: opts.color ?? false });
+	});
+}
+/**
+* Resolve the target file: the passed path, or autodetect in cwd.
+*
+* @internal
+*/
+function resolveTargetFile(fileOpt) {
+	return Effect.gen(function* () {
+		const explicit = Option.getOrUndefined(fileOpt);
+		if (explicit !== void 0) return explicit;
+		const picked = pickConfigCandidate(yield* findConfigFiles(process.cwd()));
+		if (!picked.ok) return yield* Effect.fail(new UpgradeError({ message: picked.message }));
+		return picked.file;
+	});
+}
+const fileArg = Args.file({
+	name: "file",
+	exists: "yes"
+}).pipe(Args.optional);
+const yesFlag = Options.boolean("yes").pipe(Options.withAlias("y"), Options.withDefault(false));
+const dryRunFlag = Options.boolean("dry-run").pipe(Options.withDefault(false));
+const catalogOption = Options.text("catalog").pipe(Options.optional);
+const previewFlag = Options.boolean("preview").pipe(Options.withDefault(false));
+const fullFlag = Options.boolean("full").pipe(Options.withDefault(false));
+/**
+* The "upgrade" command. The default path runs the interactive walk;
+* --yes applies latest-in-range non-interactively; --dry-run prints the
+* summary without writing; --catalog restricts to a single catalog by name.
+*
+* @internal
+*/
+const upgradeCommand = Command.make("upgrade", {
+	file: fileArg,
+	yes: yesFlag,
+	dryRun: dryRunFlag,
+	catalog: catalogOption,
+	preview: previewFlag,
+	full: fullFlag
+}, ({ file: fileOpt, yes, dryRun, catalog, preview, full }) => Effect.gen(function* () {
+	const file = yield* resolveTargetFile(fileOpt);
+	const resolver = yield* RegistryResolver;
+	const caps = detectCapabilities();
+	if (preview) {
+		const text = yield* runUpgradePreview({
+			file,
+			resolver,
+			full,
+			color: caps.color
+		});
+		yield* Effect.sync(() => process.stdout.write(`${text}\n`));
+		return;
+	}
+	if (yes) {
+		const result = yield* runUpgrade({
+			file,
+			resolver,
+			...caps.interactive ? { onProgress: writeResolveProgress } : {}
+		});
+		yield* Effect.sync(() => process.stdout.write(`Updated ${result.updated} package(s); skipped ${result.skipped.length}.\n`));
+		if (result.conflicts.length > 0) {
+			const lines = result.conflicts.map((c) => `  ${c.pkg} (kept ${c.ceiling}) blocked by ${c.blockedBy}`).join("\n");
+			yield* Effect.sync(() => process.stdout.write(`Interop conflicts (left at your pick):\n${lines}\n`));
+		}
+		return;
+	}
+	const source = yield* Effect.try({
+		try: () => readFileSync(file, "utf8"),
+		catch: () => new UpgradeError({ message: `Cannot read ${file}` })
+	});
+	const discovered = yield* Effect.try({
+		try: () => discoverCatalogEntries(source, file),
+		catch: (e) => new UpgradeError({ message: String(e) })
+	});
+	const catalogName = Option.getOrUndefined(catalog);
+	const entries = filterEntriesByCatalog(discovered.entries, catalogName);
+	const versions = yield* resolveGatedVersions(entries, resolver, yield* computeGate(source, file, resolver), Date.now(), caps.interactive ? writeResolveProgress : void 0);
+	const items = yield* buildWalkItems(entries, versions).pipe(Effect.catchAll((e) => Effect.fail(new UpgradeError({ message: e.message }))));
+	if (dryRun) {
+		const decisions = projectDecisions(items, false);
+		yield* Effect.sync(() => process.stdout.write(`${renderSummary(decisions, void 0, { color: caps.color })}\n`));
+		return;
+	}
+	if (!caps.interactive) {
+		const text = renderSummary(projectDecisions(items, full), void 0, { color: caps.color });
+		yield* Effect.sync(() => process.stdout.write(`${text}\n\n(non-interactive terminal — run with --yes to apply, or in a TTY to choose)\n`));
+		return;
+	}
+	const decisions = yield* runWalk(items);
+	const interopByCatalog = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		if (e.strategy !== "interop") continue;
+		const list = interopByCatalog.get(e.catalog) ?? [];
+		list.push(e);
+		interopByCatalog.set(e.catalog, list);
+	}
+	const nonInteropDecisions = decisions.filter((d) => d.item.entry.strategy !== "interop");
+	const interopEdits = [];
+	const adjustments = [];
+	const allConflicts = [];
+	let interopChanged = 0;
+	for (const [, group] of interopByCatalog) {
+		const pickOf = (pkg) => {
+			const d = decisions.find((dd) => dd.item.entry.pkg === pkg);
+			if (d) return d.chosen.version;
+			const ge = group.find((g) => g.pkg === pkg);
+			return ge ? ge.currentRange.replace(/^[\^~]/, "") : "";
+		};
+		let members = group.map((e) => ({
+			pkg: e.pkg,
+			ceiling: pickOf(e.pkg),
+			candidates: versions.get(e.pkg) ?? []
+		}));
+		const originalPick = new Map(members.map((m) => [m.pkg, m.ceiling]));
+		const peerCache = /* @__PURE__ */ new Map();
+		let result = yield* runInterop(members, resolver, peerCache);
+		for (let round = 0; round < members.length + 1; round++) {
+			const reentry = reentryCandidates(members, result);
+			if (reentry.length === 0) break;
+			const capEntries = group.filter((e) => reentry.some((rc) => rc.pkg === e.pkg));
+			const cappedVersions = /* @__PURE__ */ new Map();
+			for (const rc of reentry) {
+				const all = versions.get(rc.pkg) ?? [];
+				cappedVersions.set(rc.pkg, rc.cap === null ? all : yield* capVersions(all, rc.cap));
+			}
+			const reDecisions = yield* runWalk(yield* buildWalkItems(capEntries, cappedVersions).pipe(Effect.catchAll((err) => Effect.fail(new UpgradeError({ message: err.message })))));
+			const before = new Map(members.map((m) => [m.pkg, m.ceiling]));
+			members = members.map((m) => {
+				const rd = reDecisions.find((d) => d.item.entry.pkg === m.pkg);
+				return rd ? {
+					...m,
+					ceiling: rd.chosen.version
+				} : m;
+			});
+			if (!members.some((m) => before.get(m.pkg) !== m.ceiling)) break;
+			result = yield* runInterop(members, resolver, peerCache);
+		}
+		interopEdits.push(...buildInteropEdits(group, result));
+		allConflicts.push(...result.conflicts);
+		for (const e of group) {
+			if (interopEntryChanged(e, result)) interopChanged++;
+			const version = result.resolved.get(e.pkg);
+			const original = originalPick.get(e.pkg);
+			if (version === void 0 || original === void 0 || version === original) continue;
+			adjustments.push({
+				catalog: e.catalog,
+				pkg: e.pkg,
+				from: `${e.operator}${original}`,
+				to: `${e.operator}${version}`,
+				peer: result.peers.get(e.pkg) ?? `^${version}`
+			});
+		}
+	}
+	yield* Effect.sync(() => process.stdout.write(`${renderSummary(decisions, {
+		adjustments,
+		conflicts: allConflicts
+	}, { color: caps.color })}\n`));
+	yield* applyInteropAndDecisions(file, source, nonInteropDecisions, interopEdits);
+	const nonInteropChanged = nonInteropDecisions.filter((d) => d.chosen.kind !== "keep" || d.item.entry.peer !== void 0 && d.item.driftPeer !== null || d.item.entry.peer === void 0 && d.item.materializePeer !== null).length;
+	yield* Effect.sync(() => process.stdout.write(`Applied ${nonInteropChanged + interopChanged} change(s).\n`));
+}).pipe(Effect.provide(RegistryResolverLive), Effect.provide(NodeContext.layer))).pipe(Command.withDescription("Upgrade catalog versions in a config file"));
+
+//#endregion
+export { UpgradeError, applyInteropAndDecisions, computeGate, projectDecisions, resolveGatedVersions, resolveTargetFile, runUpgrade, runUpgradePreview, upgradeCommand, writeResolveProgress };

package/cli/diff/build.js

@@ -0,0 +1,122 @@
+//#region src/cli/diff/build.ts
+function isObject(v) {
+	return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+/** Worst kind among children: changed if any differs, added/removed if uniform, else unchanged. */
+function rollup(children) {
+	if (children.length === 0) return "unchanged";
+	if (children.every((c) => c.kind === "added")) return "added";
+	if (children.every((c) => c.kind === "removed")) return "removed";
+	return children.some((c) => c.kind !== "unchanged") ? "changed" : "unchanged";
+}
+/** Build every node under a value that exists only on one side (added or removed). */
+function uniform(key, path, value, kind, tag) {
+	const here = [...path, key];
+	const side = kind === "added" ? { after: value } : { before: value };
+	if (isObject(value)) {
+		const children = Object.keys(value).map((k) => uniform(k, here, value[k], kind));
+		return {
+			key,
+			path: here,
+			kind,
+			...tag ? { tag } : {},
+			children
+		};
+	}
+	if (Array.isArray(value)) {
+		const children = value.map((el) => ({
+			...uniform(String(el), here, el, kind),
+			arrayElement: true
+		}));
+		return {
+			key,
+			path: here,
+			kind,
+			...tag ? { tag } : {},
+			children
+		};
+	}
+	return {
+		key,
+		path: here,
+		kind,
+		...tag ? { tag } : {},
+		...side
+	};
+}
+/** Diff two arrays as sets keyed by stringified element. */
+function diffArray(key, path, before, after, tag) {
+	const here = [...path, key];
+	const b = new Set(before.map(String));
+	const a = new Set(after.map(String));
+	const children = [.../* @__PURE__ */ new Set([...b, ...a])].sort((x, y) => x.localeCompare(y)).map((el) => {
+		const inB = b.has(el);
+		const inA = a.has(el);
+		const kind = inB && inA ? "unchanged" : inA ? "added" : "removed";
+		const side = inA ? { after: el } : { before: el };
+		return {
+			key: el,
+			path: [...here, el],
+			kind,
+			arrayElement: true,
+			...side
+		};
+	});
+	return {
+		key,
+		path: here,
+		kind: rollup(children),
+		...tag ? { tag } : {},
+		children
+	};
+}
+function diffValue(key, path, before, after, tag) {
+	const here = [...path, key];
+	if (isObject(before) && isObject(after)) {
+		const children = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort((x, y) => x.localeCompare(y)).map((k) => {
+			if (!(k in before)) return uniform(k, here, after[k], "added");
+			if (!(k in after)) return uniform(k, here, before[k], "removed");
+			return diffValue(k, here, before[k], after[k]);
+		});
+		return {
+			key,
+			path: here,
+			kind: rollup(children),
+			...tag ? { tag } : {},
+			children
+		};
+	}
+	if (Array.isArray(before) && Array.isArray(after)) return diffArray(key, path, before, after, tag);
+	return {
+		key,
+		path: here,
+		kind: JSON.stringify(before) === JSON.stringify(after) ? "unchanged" : "changed",
+		...tag ? { tag } : {},
+		before,
+		after
+	};
+}
+/**
+* Compare two canonicalized workspace objects into a diff tree. Top-level keys
+* carry a `tag`: `local` when the key was sourced from `config.local`,
+* `unmanaged` when the key is not in the plugin-managed set.
+*
+* @internal
+*/
+function buildDiff(before, after, meta) {
+	const children = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort((x, y) => x.localeCompare(y)).map((k) => {
+		const tag = meta.localKeys.has(k) ? "local" : meta.managedKeys.has(k) ? void 0 : "unmanaged";
+		if (!(k in before)) return uniform(k, [], after[k], "added", tag);
+		if (!(k in after)) return uniform(k, [], before[k], "removed", tag);
+		return diffValue(k, [], before[k], after[k], tag);
+	});
+	return {
+		key: "",
+		path: [],
+		kind: rollup(children),
+		children
+	};
+}
+
+//#endregion
+export { buildDiff };

package/cli/diff/render.js

@@ -0,0 +1,103 @@
+//#region src/cli/diff/render.ts
+const CONTEXT = 2;
+const GUTTER = {
+	added: "+",
+	removed: "-",
+	changed: "~",
+	unchanged: " "
+};
+const STYLE = {
+	added: "added",
+	removed: "removed",
+	changed: "changed",
+	unchanged: "unchanged"
+};
+function scalarText(v) {
+	return typeof v === "string" ? v : JSON.stringify(v);
+}
+function flatten(node, depth) {
+	const indent = depth;
+	const gutter = GUTTER[node.kind];
+	const style = STYLE[node.kind];
+	const tag = node.tag;
+	const changed = node.kind !== "unchanged";
+	const isArrayEl = node.arrayElement === true;
+	if (node.children) return [{
+		line: {
+			indent,
+			gutter,
+			segments: [{
+				text: `${node.key}:`,
+				style
+			}],
+			...tag ? { tag } : {}
+		},
+		changed
+	}, ...node.children.flatMap((c) => flatten(c, depth + 1))];
+	let text;
+	if (node.kind === "changed") text = `${node.key}: ${scalarText(node.before)} → ${scalarText(node.after)}`;
+	else if (isArrayEl) text = `- ${node.key}`;
+	else text = `${node.key}: ${scalarText(node.after ?? node.before)}`;
+	return [{
+		line: {
+			indent,
+			gutter,
+			segments: [{
+				text,
+				style
+			}],
+			...tag ? { tag } : {}
+		},
+		changed
+	}];
+}
+/**
+* Render a diff tree to styled lines in canonical-YAML shape. Default collapses
+* unchanged lines outside a 2-line window around changes into a single
+* "… N unchanged" marker; `full` keeps every line.
+*
+* @internal
+*/
+function renderExportDiff(root, opts) {
+	const flats = (root.children ?? []).flatMap((c) => flatten(c, 0));
+	if (opts.full) return flats.map((f) => f.line);
+	const keep = new Array(flats.length).fill(false);
+	flats.forEach((f, i) => {
+		if (!f.changed) return;
+		for (let j = Math.max(0, i - CONTEXT); j <= Math.min(flats.length - 1, i + CONTEXT); j++) keep[j] = true;
+	});
+	for (let i = 0; i < flats.length; i++) {
+		if (!keep[i]) continue;
+		let depth = flats[i].line.indent;
+		for (let j = i - 1; j >= 0 && depth > 0; j--) if (flats[j].line.indent < depth) {
+			keep[j] = true;
+			depth = flats[j].line.indent;
+		}
+	}
+	const out = [];
+	let dropped = 0;
+	const flushDropped = () => {
+		if (dropped > 0) {
+			out.push({
+				indent: 0,
+				gutter: " ",
+				segments: [{
+					text: `… ${dropped} unchanged`,
+					style: "unchanged"
+				}]
+			});
+			dropped = 0;
+		}
+	};
+	flats.forEach((f, i) => {
+		if (keep[i]) {
+			flushDropped();
+			out.push(f.line);
+		} else dropped++;
+	});
+	flushDropped();
+	return out;
+}
+
+//#endregion
+export { renderExportDiff };