rolldown-pnpm-config 0.1.0

package/cli/peer-range.js

@@ -0,0 +1,34 @@
+import { Data, Effect } from "effect";
+import { SemVer } from "semver-effect";
+
+//#region src/cli/peer-range.ts
+/**
+* Typed failure raised when a peer range cannot be derived from a range string.
+*
+* @internal
+*/
+var PeerRangeError = class extends Data.TaggedError("PeerRangeError") {};
+/** Splits a simple range into its operator prefix and version (e.g. `^6.5.1`). */
+const PREFIX_RE = /^(\^|~|)(\d.*)$/;
+/**
+* Recompute a materialized peer range from a package range and a strategy.
+* "lock" pins to the exact version; "lock-minor" floors the patch to .0.
+* The operator (^/~/exact) is preserved.
+*
+* Note: expects a release (non-prerelease) version string; a prerelease tag
+* would be dropped by the major.minor.patch reconstruction.
+*
+* @internal
+*/
+function derivePeerRange(range, strategy) {
+	return Effect.gen(function* () {
+		const match = PREFIX_RE.exec(range);
+		if (!match) return yield* Effect.fail(new PeerRangeError({ message: `Cannot derive peer range from "${range}"` }));
+		const [, prefix, version] = match;
+		const parsed = yield* SemVer.parse(version).pipe(Effect.mapError(() => new PeerRangeError({ message: `Invalid version in range "${range}"` })));
+		return strategy === "lock" ? `${prefix}${parsed.major}.${parsed.minor}.${parsed.patch}` : `${prefix}${parsed.major}.${parsed.minor}.0`;
+	});
+}
+
+//#endregion
+export { PeerRangeError, derivePeerRange };

package/cli/plan.js

@@ -0,0 +1,66 @@
+import { derivePeerRange } from "./peer-range.js";
+import { Effect } from "effect";
+import { Range, SemVer } from "semver-effect";
+
+//#region src/cli/plan.ts
+/** Parse a version, returning null instead of failing (filters junk tags). */
+const parseOrNull = (v) => SemVer.parse(v).pipe(Effect.catchAll(() => Effect.succeed(null)));
+/**
+* Compute the candidate versions for one catalog entry against the list of
+* published versions. Order: latest in-range (when newer than current), latest
+* overall stable (when newer than the in-range pick), then keep. Prereleases
+* are excluded. When the entry carries a strategy, each non-keep candidate gets
+* a recomputed `peerRange`.
+*
+* @internal
+*/
+function planEntry(entry, versions) {
+	return Effect.gen(function* () {
+		const range = yield* Range.parse(entry.currentRange).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		const parsed = [];
+		for (const v of versions) {
+			const sv = yield* parseOrNull(v);
+			if (sv?.isStable) parsed.push(sv);
+		}
+		parsed.sort((a, b) => a.compare(b));
+		const maxOf = (list) => list.length ? list[list.length - 1] : null;
+		const current = yield* parseOrNull(entry.currentRange.replace(/^[\^~]/, ""));
+		const currentMajor = current?.major ?? 0;
+		const inRangeMax = range ? maxOf(parsed.filter((v) => range.test(v))) : null;
+		const overallMax = maxOf(parsed);
+		const withPeer = (version) => entry.strategy && entry.strategy !== "interop" ? derivePeerRange(`${entry.operator}${version}`, entry.strategy) : Effect.succeed(void 0);
+		const candidates = [];
+		if (inRangeMax && (current === null || inRangeMax.gt(current))) {
+			const version = inRangeMax.toString();
+			const peerRange = yield* withPeer(version);
+			candidates.push({
+				kind: "in-range",
+				range: `${entry.operator}${version}`,
+				version,
+				isMajor: inRangeMax.major > currentMajor,
+				...peerRange ? { peerRange } : {}
+			});
+		}
+		if (overallMax && (current === null || overallMax.gt(current)) && (!inRangeMax || overallMax.gt(inRangeMax))) {
+			const version = overallMax.toString();
+			const peerRange = yield* withPeer(version);
+			candidates.push({
+				kind: "latest",
+				range: `${entry.operator}${version}`,
+				version,
+				isMajor: overallMax.major > currentMajor,
+				...peerRange ? { peerRange } : {}
+			});
+		}
+		candidates.push({
+			kind: "keep",
+			range: entry.currentRange,
+			version: entry.currentRange.replace(/^[\^~]/, ""),
+			isMajor: false
+		});
+		return candidates;
+	});
+}
+
+//#endregion
+export { planEntry };

package/cli/preview-views.js

@@ -0,0 +1,34 @@
+import { buildDiff } from "./diff/build.js";
+import { renderExportDiff } from "./diff/render.js";
+import { effectiveManaged, vanillaManaged } from "./effective.js";
+import { canonicalize } from "./workspace-file.js";
+import { overlayWorkspace } from "./workspace-overlay.js";
+import { WORKSPACE_FIELDS } from "./commands/export.js";
+
+//#region src/cli/preview-views.ts
+/**
+* Build the three preview views as styled lines: Changes (parsed→merged, with
+* local + preserve + excludeByRepo), Full (same tree, full verbosity), and
+* Simulated (parsed→vanilla fresh-consumer output, no local/overlay).
+*
+* @internal
+*/
+function buildPreviewViews(input) {
+	const meta = {
+		localKeys: new Set(input.local ? Object.keys(input.local) : []),
+		managedKeys: WORKSPACE_FIELDS
+	};
+	const merged = overlayWorkspace(effectiveManaged(input.managed, input.local, input.parsed, input.manifest, input.rootName), input.parsed);
+	const vanilla = vanillaManaged(input.managed, input.manifest, input.rootName);
+	const before = canonicalize(input.parsed);
+	const changesTree = buildDiff(before, canonicalize(merged), meta);
+	const simulatedTree = buildDiff(before, canonicalize(vanilla), meta);
+	return {
+		changes: renderExportDiff(changesTree, { full: false }),
+		full: renderExportDiff(changesTree, { full: true }),
+		simulated: renderExportDiff(simulatedTree, { full: false })
+	};
+}
+
+//#endregion
+export { buildPreviewViews };

package/cli/release-age.js

@@ -0,0 +1,74 @@
+//#region src/cli/release-age.ts
+/** Combine two sources: strictest age (max), widest exempt set (union). @internal */
+function combineReleaseAge(a, b) {
+	const ages = [a?.ageMinutes, b?.ageMinutes].filter((n) => typeof n === "number");
+	return {
+		ageMinutes: ages.length ? Math.max(0, ...ages) : 0,
+		exclude: [.../* @__PURE__ */ new Set([...a?.exclude ?? [], ...b?.exclude ?? []])]
+	};
+}
+/** Match a package name against exact names or `*`-globs (e.g. `@effect/*`). @internal */
+function matchesExclude(pkg, patterns) {
+	for (const pat of patterns) {
+		if (pat === pkg) return true;
+		if (pat.includes("*")) {
+			if (new RegExp(`^${pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`).test(pkg)) return true;
+		}
+	}
+	return false;
+}
+/**
+* Drop versions younger than the gate's cutoff (and versions with no publish
+* timestamp). No-op when the age is 0 or the package is exempt.
+*
+* @internal
+*/
+function filterByReleaseAge(versions, times, gate, pkg, now) {
+	if (gate.ageMinutes <= 0 || matchesExclude(pkg, gate.exclude)) return [...versions];
+	const cutoff = now - gate.ageMinutes * 6e4;
+	return versions.filter((v) => {
+		const t = times[v];
+		if (t === void 0) return false;
+		const published = Date.parse(t);
+		return Number.isFinite(published) && published <= cutoff;
+	});
+}
+/** Unwrap a managed field that may be a bare value or a `{ value, enforcement }` FieldInput. */
+function fieldValue(raw) {
+	if (raw && typeof raw === "object" && !Array.isArray(raw) && "value" in raw) return raw.value;
+	return raw;
+}
+/** Read the release-age gate declared in a statically-evaluated PnpmConfigPlugin config. @internal */
+function readConfigReleaseAge(config) {
+	if (!config) return null;
+	const age = fieldValue(config.minimumReleaseAge);
+	const exc = fieldValue(config.minimumReleaseAgeExclude);
+	const out = {};
+	if (typeof age === "number" && Number.isFinite(age)) out.ageMinutes = age;
+	if (Array.isArray(exc)) out.exclude = exc.filter((x) => typeof x === "string");
+	return out.ageMinutes === void 0 && out.exclude === void 0 ? null : out;
+}
+/** Parse `pnpm config get minimumReleaseAge[Exclude]` stdout into a PartialGate. @internal */
+function parsePnpmGate(age, exclude) {
+	const out = {};
+	const trimmedAge = age?.trim();
+	if (trimmedAge && trimmedAge !== "undefined") {
+		const n = Number.parseInt(trimmedAge, 10);
+		if (Number.isFinite(n)) out.ageMinutes = n;
+	}
+	const trimmedExc = exclude?.trim();
+	if (trimmedExc && trimmedExc !== "undefined") {
+		let list = [];
+		try {
+			const json = JSON.parse(trimmedExc);
+			list = Array.isArray(json) ? json.map(String) : [String(json)];
+		} catch {
+			list = trimmedExc.split(/[\s,]+/).filter(Boolean);
+		}
+		if (list.length) out.exclude = list;
+	}
+	return out.ageMinutes === void 0 && out.exclude === void 0 ? null : out;
+}
+
+//#endregion
+export { combineReleaseAge, filterByReleaseAge, matchesExclude, parsePnpmGate, readConfigReleaseAge };

package/cli/resolve.js

@@ -0,0 +1,109 @@
+import { Context, Data, Effect, Layer } from "effect";
+import { Command, CommandExecutor } from "@effect/platform";
+
+//#region src/cli/resolve.ts
+/**
+* Typed failure raised when a package's versions cannot be resolved.
+*
+* @internal
+*/
+var ResolveError = class extends Data.TaggedError("ResolveError") {};
+/**
+* Resolves the published versions of a package from the registry. The Live
+* implementation shells out to `pnpm view`, reusing the user's .npmrc, scoped
+* registries, and auth tokens.
+*
+* @internal
+*/
+var RegistryResolver = class extends Context.Tag("RegistryResolver")() {};
+/** Parse `pnpm view ... versions --json` stdout: a JSON array, or a single JSON string. */
+function parseVersions(pkg, stdout) {
+	return Effect.try({
+		try: () => {
+			const json = JSON.parse(stdout);
+			if (Array.isArray(json)) return json.map(String);
+			if (typeof json === "string") return [json];
+			throw new Error("unexpected shape");
+		},
+		catch: () => new ResolveError({
+			pkg,
+			message: `Could not parse versions for ${pkg}`
+		})
+	});
+}
+/** Parse `pnpm view <pkg> time --json` stdout: an object of version → ISO date. @internal */
+function parseTimes(pkg, stdout) {
+	return Effect.try({
+		try: () => {
+			const json = JSON.parse(stdout);
+			if (json && typeof json === "object" && !Array.isArray(json)) {
+				const out = {};
+				for (const [k, v] of Object.entries(json)) out[k] = String(v);
+				return out;
+			}
+			throw new Error("unexpected shape");
+		},
+		catch: () => new ResolveError({
+			pkg,
+			message: `Could not parse times for ${pkg}`
+		})
+	});
+}
+/** Parse `pnpm view <pkg>@<version> peerDependencies --json`; empty stdout → {}. @internal */
+function parsePeerDeps(pkg, stdout) {
+	const trimmed = stdout.trim();
+	if (trimmed === "") return Effect.succeed({});
+	return Effect.try({
+		try: () => {
+			const json = JSON.parse(trimmed);
+			if (json && typeof json === "object" && !Array.isArray(json)) {
+				const out = {};
+				for (const [k, v] of Object.entries(json)) out[k] = String(v);
+				return out;
+			}
+			throw new Error("unexpected shape");
+		},
+		catch: () => new ResolveError({
+			pkg,
+			message: `Could not parse peerDependencies for ${pkg}`
+		})
+	});
+}
+/**
+* Live RegistryResolver backed by `pnpm view <pkg> versions --json`.
+*
+* @internal
+*/
+const RegistryResolverLive = Layer.effect(RegistryResolver, Effect.gen(function* () {
+	const executor = yield* CommandExecutor.CommandExecutor;
+	return {
+		versions: (pkg) => Effect.gen(function* () {
+			const cmd = Command.make("pnpm", "view", pkg, "versions", "--json");
+			return yield* parseVersions(pkg, yield* executor.string(cmd).pipe(Effect.mapError((e) => new ResolveError({
+				pkg,
+				message: String(e)
+			}))));
+		}),
+		times: (pkg) => Effect.gen(function* () {
+			const cmd = Command.make("pnpm", "view", pkg, "time", "--json");
+			return yield* parseTimes(pkg, yield* executor.string(cmd).pipe(Effect.mapError((e) => new ResolveError({
+				pkg,
+				message: String(e)
+			}))));
+		}),
+		peerDependencies: (pkg, version) => Effect.gen(function* () {
+			const cmd = Command.make("pnpm", "view", `${pkg}@${version}`, "peerDependencies", "--json");
+			return yield* parsePeerDeps(pkg, yield* executor.string(cmd).pipe(Effect.mapError((e) => new ResolveError({
+				pkg,
+				message: String(e)
+			}))));
+		}),
+		pnpmConfig: (key) => Effect.gen(function* () {
+			const cmd = Command.make("pnpm", "config", "get", key);
+			return yield* executor.string(cmd).pipe(Effect.map((s) => s.trim()), Effect.catchAll(() => Effect.succeed(null)));
+		})
+	};
+}));
+
+//#endregion
+export { RegistryResolver, RegistryResolverLive, ResolveError, parsePeerDeps, parseTimes, parseVersions };

package/cli/rewrite.js

@@ -0,0 +1,22 @@
+//#region src/cli/rewrite.ts
+/**
+* Apply span replacements to a source string. Edits are applied in descending
+* start order so each edit's offsets remain valid as later text shifts. Throws
+* a RangeError if any two edits overlap.
+*
+* @internal
+*/
+function applyEdits(source, edits) {
+	const sorted = [...edits].sort((a, b) => b.span[0] - a.span[0]);
+	for (let i = 1; i < sorted.length; i++) {
+		const prev = sorted[i - 1];
+		const cur = sorted[i];
+		if (cur.span[1] > prev.span[0]) throw new RangeError(`Overlapping edits at [${cur.span[0]}, ${cur.span[1]}) and [${prev.span[0]}, ${prev.span[1]})`);
+	}
+	let out = source;
+	for (const edit of sorted) out = out.slice(0, edit.span[0]) + edit.text + out.slice(edit.span[1]);
+	return out;
+}
+
+//#endregion
+export { applyEdits };

package/cli/select-file.js

@@ -0,0 +1,64 @@
+import { discoverCatalogEntries } from "./discover.js";
+import { Effect } from "effect";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/cli/select-file.ts
+/**
+* Scan a directory for top-level `.ts` files whose source contains a usable
+* `PnpmConfigPlugin(...)` catalog (discovery yields at least one entry). Read
+* or parse failures are skipped silently. Returns absolute-or-joined paths.
+*
+* @internal
+*/
+function findConfigFiles(dir) {
+	return Effect.sync(() => {
+		let names;
+		try {
+			names = readdirSync(dir);
+		} catch {
+			return [];
+		}
+		const matches = [];
+		for (const name of names) {
+			if (!name.endsWith(".ts") || name.endsWith(".d.ts")) continue;
+			const path = join(dir, name);
+			try {
+				const { entries } = discoverCatalogEntries(readFileSync(path, "utf8"), path);
+				if (entries.length > 0) matches.push(path);
+			} catch {}
+		}
+		return matches;
+	});
+}
+/**
+* Choose the config file to operate on from a set of candidate paths. Exactly
+* one is required; zero or many is an error the caller surfaces.
+*
+* @internal
+*/
+function pickConfigCandidate(matches) {
+	if (matches.length === 1) return {
+		ok: true,
+		file: matches[0]
+	};
+	if (matches.length === 0) return {
+		ok: false,
+		message: "No config file found. Pass a file path explicitly."
+	};
+	return {
+		ok: false,
+		message: `Multiple config files found; pass one explicitly: ${matches.join(", ")}`
+	};
+}
+/**
+* Restrict entries to a single catalog by name, or return all when undefined.
+*
+* @internal
+*/
+function filterEntriesByCatalog(entries, catalog) {
+	return catalog === void 0 ? [...entries] : entries.filter((e) => e.catalog === catalog);
+}
+
+//#endregion
+export { filterEntriesByCatalog, findConfigFiles, pickConfigCandidate };

package/cli/summary.js

@@ -0,0 +1,137 @@
+import { toAnsi } from "./ui/ansi.js";
+
+//#region src/cli/summary.ts
+/**
+* Build the pending-decisions summary as styled lines: one line per real
+* change, peer changes indented, a dim tally, then interop adjustments and
+* conflicts. Pure; color is applied by `renderSummary`/`toAnsi`.
+*
+* @internal
+*/
+function summaryLines(decisions, interop) {
+	const lines = [];
+	let toUpdate = 0;
+	let major = 0;
+	let resync = 0;
+	let materialize = 0;
+	let upToDate = 0;
+	for (const { item, chosen } of decisions) {
+		const { entry } = item;
+		if (chosen.kind !== "keep") {
+			toUpdate++;
+			if (chosen.isMajor) major++;
+			lines.push({
+				indent: 0,
+				gutter: "~",
+				segments: [{
+					text: `${entry.catalog} › ${entry.pkg}  ${entry.currentRange} → ${chosen.range}`,
+					style: "changed"
+				}]
+			});
+			if (entry.peer && chosen.peerRange && chosen.peerRange !== entry.peer.value) lines.push({
+				indent: 1,
+				gutter: "~",
+				segments: [{
+					text: `↳ peer  ${entry.peer.value} → ${chosen.peerRange}`,
+					style: "changed"
+				}]
+			});
+			else if (!entry.peer && entry.strategy && chosen.peerRange) {
+				lines.push({
+					indent: 1,
+					gutter: "+",
+					segments: [{
+						text: `↳ peer (new)  → ${chosen.peerRange}`,
+						style: "added"
+					}]
+				});
+				materialize++;
+			}
+		} else if (entry.peer && item.driftPeer) {
+			resync++;
+			lines.push({
+				indent: 0,
+				gutter: "~",
+				segments: [{
+					text: `${entry.catalog} › ${entry.pkg}  (resync peer)`,
+					style: "changed"
+				}]
+			});
+			lines.push({
+				indent: 1,
+				gutter: "~",
+				segments: [{
+					text: `↳ peer  ${entry.peer.value} → ${item.driftPeer}`,
+					style: "changed"
+				}]
+			});
+		} else if (!entry.peer && item.materializePeer) {
+			materialize++;
+			lines.push({
+				indent: 0,
+				gutter: "+",
+				segments: [{
+					text: `${entry.catalog} › ${entry.pkg}  (materialize peer)`,
+					style: "added"
+				}]
+			});
+			lines.push({
+				indent: 1,
+				gutter: "+",
+				segments: [{
+					text: `↳ peer (new)  → ${item.materializePeer}`,
+					style: "added"
+				}]
+			});
+		} else upToDate++;
+	}
+	lines.push({
+		indent: 0,
+		gutter: " ",
+		segments: [{
+			text: `${toUpdate} to update · ${major} major · ${resync} resync · ${materialize} new peer · ${upToDate} up to date`,
+			style: "unchanged"
+		}]
+	});
+	if (interop) {
+		for (const a of interop.adjustments) {
+			lines.push({
+				indent: 0,
+				gutter: "~",
+				segments: [{
+					text: `↓ ${a.pkg}  ${a.from} → ${a.to}`,
+					style: "changed"
+				}]
+			});
+			lines.push({
+				indent: 1,
+				gutter: "~",
+				segments: [{
+					text: `↳ peer  → ${a.peer}`,
+					style: "changed"
+				}]
+			});
+		}
+		for (const c of interop.conflicts) lines.push({
+			indent: 0,
+			gutter: "⚠",
+			segments: [{
+				text: `${c.pkg} (kept ${c.ceiling}) blocked by ${c.blockedBy}`,
+				style: "warn"
+			}]
+		});
+	}
+	return lines;
+}
+/**
+* Render the summary to a string. Color defaults off so non-TTY/test callers
+* get clean text; the upgrade command passes the detected color flag.
+*
+* @internal
+*/
+function renderSummary(decisions, interop, opts) {
+	return toAnsi(summaryLines(decisions, interop), { color: opts?.color ?? false });
+}
+
+//#endregion
+export { renderSummary, summaryLines };

package/cli/ui/Preview.js

@@ -0,0 +1,60 @@
+import { Box, Text, useApp, useInput } from "ink";
+import { createElement, useState } from "react";
+import { Tab, Tabs } from "ink-tab";
+
+//#region src/cli/ui/Preview.ts
+const INK_COLOR = {
+	added: "green",
+	removed: "red",
+	changed: "yellow",
+	warn: "red",
+	local: "magenta",
+	unmanaged: "gray",
+	unchanged: "gray",
+	plain: void 0
+};
+const TabC = Tab;
+const TabsC = Tabs;
+function renderLines(lines) {
+	return createElement(Box, { flexDirection: "column" }, ...lines.map((l, i) => {
+		const indent = "  ".repeat(l.indent);
+		const tag = l.tag ? `  (${l.tag})` : "";
+		const body = l.segments.map((s, j) => {
+			const color = INK_COLOR[s.style];
+			return createElement(Text, {
+				key: j,
+				...color ? { color } : {}
+			}, s.text);
+		});
+		return createElement(Text, { key: i }, `${l.gutter} ${indent}`, ...body, tag);
+	}));
+}
+/**
+* Interactive export preview: an ink-tab bar over the Changes / Full /
+* Simulated views. `q`/Esc exits. Written with React.createElement (no JSX).
+*
+* @internal
+*/
+function Preview({ views, onExit }) {
+	const app = useApp();
+	const [active, setActive] = useState("changes");
+	useInput((input, key) => {
+		if (input === "q" || key.escape) {
+			onExit();
+			app.exit();
+		}
+	});
+	return createElement(Box, { flexDirection: "column" }, createElement(TabsC, { onChange: (name) => setActive(name) }, createElement(TabC, {
+		name: "changes",
+		key: "changes"
+	}, "Changes"), createElement(TabC, {
+		name: "full",
+		key: "full"
+	}, "Full"), createElement(TabC, {
+		name: "simulated",
+		key: "simulated"
+	}, "Simulated")), renderLines(views[active]));
+}
+
+//#endregion
+export { Preview };

package/cli/ui/Walk.js

@@ -0,0 +1,55 @@
+import { initWalk, walkStep } from "../walk-reducer.js";
+import { Box, Text, useApp, useInput } from "ink";
+import { createElement, useEffect, useState } from "react";
+
+//#region src/cli/ui/Walk.ts
+/**
+* Interactive per-package upgrade selector rendered with Ink.
+*
+* Written with React.createElement (no JSX) so the file can be plain .ts
+* without requiring TSX transform configuration.
+*
+* @internal
+*/
+function Walk({ items, onDone }) {
+	const app = useApp();
+	const [state, setState] = useState(() => initWalk(items));
+	useEffect(() => {
+		if (state.done) {
+			onDone(state.decisions);
+			app.exit();
+		}
+	}, []);
+	useInput((_input, key) => {
+		if (state.done) return;
+		const which = key.upArrow ? "up" : key.downArrow ? "down" : key.return ? "enter" : null;
+		if (!which) return;
+		const next = walkStep(state, items, which);
+		setState(next);
+		if (next.done) {
+			onDone(next.decisions);
+			app.exit();
+		}
+	});
+	if (state.done || state.index >= items.length) return createElement(Text, null, "Done.");
+	const item = items[state.index];
+	const e = item.entry;
+	return createElement(Box, { flexDirection: "column" }, createElement(Text, null, [
+		`${e.catalog} › ${e.pkg}   current ${e.currentRange}`,
+		e.peer ? `   peer ${e.peer.value}` : "",
+		e.strategy ? `   strategy: ${e.strategy}` : ""
+	].join("")), ...item.candidates.map((c, i) => {
+		const selected = i === state.cursor;
+		const cursor = selected ? "❯ " : "  ";
+		const base = c.kind === "keep" ? `keep ${c.range}` : `${c.range}   ${c.kind}`;
+		const colorProps = selected ? { color: "cyan" } : c.isMajor ? { color: "yellow" } : {};
+		const text = c.kind === "keep" ? `${cursor}${base}` : `${cursor}${base}${c.isMajor ? "  ⚠ major" : ""}`;
+		return createElement(Text, {
+			key: c.kind,
+			...colorProps
+		}, text);
+	}));
+}
+
+//#endregion
+export { Walk };

package/cli/ui/ansi.js

@@ -0,0 +1,20 @@
+import { paint, tagSuffix } from "./styled.js";
+
+//#region src/cli/ui/ansi.ts
+/**
+* Render styled lines to a string. Each line is
+* `<gutter><space><2-space-indent><painted segments><tag>`.
+* Pure: color is decided by the caller, never read from the environment.
+*
+* @internal
+*/
+function toAnsi(lines, opts) {
+	return lines.map((l) => {
+		const indent = "  ".repeat(l.indent);
+		const body = l.segments.map((s) => paint(s.text, s.style, opts.color)).join("");
+		return `${l.gutter} ${indent}${body}${tagSuffix(l.tag)}`;
+	}).join("\n");
+}
+
+//#endregion
+export { toAnsi };