rolldown-pnpm-config 1.0.11 → 2.0.0

package/cli/ui/preview-screen.js

@@ -0,0 +1,93 @@
+import { legend, simulatedLegend } from "../render/legend.js";
+import { Doc } from "@effected/cli";
+import { DocView, KeyHelp, KeyTable, Styled, Tabs, Viewport, useKeys, useTerminalSize, useTheme } from "@effected/cli/ui";
+import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/cli/ui/preview-screen.tsx
+const TABS = [
+	{
+		name: "changes",
+		label: "Changes"
+	},
+	{
+		name: "full",
+		label: "Full"
+	},
+	{
+		name: "simulated",
+		label: "Simulated"
+	}
+];
+/** `q` and Enter close the viewer; Esc and Ctrl-C are the host's (the command treats them as a close too). */
+const close = KeyTable.make([{
+	keys: [{ char: "q" }, "enter"],
+	action: "close",
+	help: "close"
+}]);
+/**
+* Lines the viewer's chrome takes besides the scrolling view: tabs, legend and
+* key help, plus one so the frame stays shorter than the terminal (Ink clears
+* the screen and scrollback for a frame as tall as the terminal).
+*/
+const RESERVED = 4;
+function rowsOf(views, name) {
+	return views[name].lines.map((_, i) => ({
+		_tag: "Item",
+		key: String(i)
+	}));
+}
+/**
+* The read-only preview explorer: a tab bar over the Changes / Full /
+* Simulated views, each scrolling in a viewport that fits the terminal, with
+* the matching legend above it. Resolves when the viewer is closed.
+*
+* @internal
+*/
+function makePreviewScreen(views) {
+	return ({ resolve }) => {
+		const Preview = () => {
+			const height = Math.max(1, useTerminalSize().rows - RESERVED);
+			const [tab, setTab] = useState("changes");
+			const [viewport, setViewport] = useState(() => Viewport.init(views.changes.lines.length, height));
+			useEffect(() => setViewport((current) => Viewport.resize(current, height)), [height]);
+			useKeys(Viewport.keys, (move) => setViewport((current) => Viewport.step(current, move)));
+			useKeys(close, () => resolve(void 0));
+			const lines = views[tab].lines;
+			const showLegend = useTheme().color !== "none";
+			return /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [
+					/* @__PURE__ */ jsx(Tabs.View, {
+						tabs: TABS,
+						value: tab,
+						onChange: (name) => {
+							setTab(name);
+							setViewport(Viewport.init(views[name].lines.length, height));
+						}
+					}),
+					showLegend ? /* @__PURE__ */ jsx(DocView, { doc: tab === "simulated" ? simulatedLegend() : legend() }) : /* @__PURE__ */ jsx(Text, { children: " " }),
+					/* @__PURE__ */ jsx(Viewport.View, {
+						rows: rowsOf(views, tab),
+						state: viewport,
+						reserved: RESERVED,
+						renderRow: (row, highlighted) => /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, { children: highlighted ? /* @__PURE__ */ jsx(Styled, {
+							token: "accent",
+							children: "›"
+						}) : " " }), /* @__PURE__ */ jsx(DocView, { doc: Doc.line(row._tag === "Item" ? lines[Number(row.key)] ?? [] : []) })] })
+					}),
+					/* @__PURE__ */ jsx(KeyHelp, { tables: [
+						Viewport.keys,
+						Tabs.keys,
+						close
+					] })
+				]
+			});
+		};
+		return /* @__PURE__ */ jsx(Preview, {});
+	};
+}
+
+//#endregion
+export { makePreviewScreen };

package/cli/ui/progress-view.js

@@ -0,0 +1,47 @@
+import { initialProgress, reduceProgress } from "./progress.js";
+import { Status } from "@effected/cli";
+import { Styled, useGlyphs, useTheme } from "@effected/cli/ui";
+import { Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/cli/ui/progress-view.tsx
+function Progress({ state, frame }) {
+	const glyphs = useGlyphs();
+	const theme = useTheme();
+	const count = state.total > 0 ? ` ${state.done}/${state.total}` : "";
+	if (state.finished) return /* @__PURE__ */ jsxs(Text, { children: [
+		theme.status(Status.core, "success"),
+		" ",
+		state.label
+	] });
+	return /* @__PURE__ */ jsxs(Text, { children: [
+		/* @__PURE__ */ jsx(Styled, {
+			token: "accent",
+			children: glyphs.spinner[frame % glyphs.spinner.length]
+		}),
+		" ",
+		state.label,
+		count
+	] });
+}
+/**
+* The resolve-progress live view, minus its events: one spinner line naming
+* the phase and its count, committed as a check-marked line carrying the
+* phase's finished label when it ends.
+* Shared by the command and its test so the two never drift.
+*
+* @internal
+*/
+const progressView = {
+	initial: initialProgress,
+	reduce: reduceProgress,
+	render: (state, frame) => /* @__PURE__ */ jsx(Progress, {
+		state,
+		frame
+	}),
+	isStart: (event) => event._tag === "Phase",
+	isTerminal: (event) => event._tag === "Finished"
+};
+
+//#endregion
+export { progressView };

package/cli/ui/progress.js

@@ -0,0 +1,31 @@
+//#region src/cli/ui/progress.ts
+/** The progress fold, kept free of React so it is tested without a terminal. @internal */
+function reduceProgress(state, event) {
+	switch (event._tag) {
+		case "Phase": return {
+			label: event.label,
+			done: 0,
+			total: event.total,
+			finished: false
+		};
+		case "Step": return {
+			...state,
+			done: event.done
+		};
+		case "Finished": return {
+			...state,
+			label: event.label,
+			finished: true
+		};
+	}
+}
+/** The state before any phase begins. @internal */
+const initialProgress = {
+	label: "",
+	done: 0,
+	total: 0,
+	finished: false
+};
+
+//#endregion
+export { initialProgress, reduceProgress };

package/cli/ui/screens.js

@@ -0,0 +1,40 @@
+import { Effect, PubSub } from "effect";
+import { CliInteractive } from "@effected/cli";
+import { CliUi } from "@effected/cli/ui";
+
+//#region src/cli/ui/screens.ts
+/** The interactive upgrade table, loaded on mount. @internal */
+function walkScreen(props) {
+	return CliUi.lazy(async () => ({ default: (await import("./walk-screen.js")).makeWalkScreen(props) }));
+}
+/** The read-only preview explorer, loaded on mount. @internal */
+function previewScreen(views) {
+	return CliUi.lazy(async () => ({ default: (await import("./preview-screen.js")).makePreviewScreen(views) }));
+}
+/**
+* Run `body` with a progress reporter. In an interactive run the reports
+* drive a live spinner view that redraws in place; otherwise the reporter is a
+* no-op and nothing is drawn or loaded, so piped and CI output stay clean. The
+* view is closed — its last frame committed — before this returns, so a
+* screen mounted next never waits on it.
+*
+* @internal
+*/
+function withProgress(body) {
+	return Effect.gen(function* () {
+		if (!(yield* CliInteractive)) return yield* body(() => Effect.void);
+		const { progressView } = yield* Effect.promise(() => import("./progress-view.js"));
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const pubsub = yield* PubSub.unbounded();
+			const events = yield* PubSub.subscribe(pubsub);
+			const view = yield* CliUi.live({
+				...progressView,
+				events
+			});
+			return yield* body((event) => PubSub.publish(pubsub, event).pipe(Effect.asVoid)).pipe(Effect.ensuring(view.close));
+		}));
+	});
+}
+
+//#endregion
+export { previewScreen, walkScreen, withProgress };

package/cli/ui/walk-screen.js

@@ -0,0 +1,176 @@
+import { TONES } from "../render/tone.js";
+import { computeGroupPeers } from "../interop-live.js";
+import { cellTone, displayCandidates, initTable, peerFor, tableDecisions, tableLayout, tableStep, truncateEnd } from "../walk-reducer.js";
+import { Fmt } from "@effected/cli";
+import { KeyHelp, KeyTable, Styled, useKeys, useTerminalSize } from "@effected/cli/ui";
+import { Box, Text } from "ink";
+import { useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/cli/ui/walk-screen.tsx
+/** The table's keys: arrows (or vim keys) to move and pick, Enter to finish. Esc and Ctrl-C are the host's. */
+function walkKeys(dryRun) {
+	return KeyTable.make([
+		{
+			keys: ["up", { char: "k" }],
+			action: "up",
+			help: "previous"
+		},
+		{
+			keys: ["down", { char: "j" }],
+			action: "down",
+			help: "next"
+		},
+		{
+			keys: ["left", { char: "h" }],
+			action: "left",
+			help: "older"
+		},
+		{
+			keys: ["right", { char: "l" }],
+			action: "right",
+			help: "newer"
+		},
+		{
+			keys: ["enter"],
+			action: "submit",
+			help: dryRun ? "preview" : "update"
+		}
+	]);
+}
+/**
+* Lines the table's chrome takes besides its rows: title, banners, spacer, key
+* help — plus one, because Ink treats a frame as tall as the terminal as
+* fullscreen and clears the screen and its scrollback on every redraw.
+*/
+function chromeHeight(props) {
+	return 4 + (props.dryRun ? 1 : 0) + (props.unresolved.length > 0 ? 1 : 0);
+}
+/**
+* The interactive upgrade table. Every package is one row; each row is a radio
+* group over its candidates with keep (index 0) preselected, so the default
+* state of the table applies nothing. Enter resolves the screen with one
+* decision per row; Esc and Ctrl-C cancel it (the host's `Cancelled`).
+*
+* @internal
+*/
+function makeWalkScreen(props) {
+	const { items, dryRun, unresolved, interopModels } = props;
+	const keys = walkKeys(dryRun);
+	return ({ resolve }) => {
+		const Walk = () => {
+			const table = useRef(initTable(items));
+			const [state, setState] = useState(table.current);
+			const { columns, rows: termRows } = useTerminalSize();
+			useKeys(keys, (key) => {
+				const current = table.current;
+				const next = tableStep(current, items, key);
+				table.current = next;
+				setState(next);
+				if (next.done && !current.done) resolve(tableDecisions(next, items));
+			});
+			if (state.done) return /* @__PURE__ */ jsx(Text, { children: "Done." });
+			const { pkgWidth, cellWidth, maxCells, blankCell, cellText } = tableLayout(items);
+			const fixedPrefix = 2 + (pkgWidth + 2) + maxCells * (cellWidth + 4) + 2;
+			const catalogs = new Set(items.map((i) => i.entry.catalog)).size;
+			const height = Math.max(3, Math.min(items.length, termRows - chromeHeight(props) - catalogs));
+			const start = Math.max(0, Math.min(state.cursor - Math.floor(height / 2), items.length - height));
+			const visible = items.slice(start, start + height);
+			const interopPeers = /* @__PURE__ */ new Map();
+			for (const [catalog, model] of interopModels) {
+				const selected = /* @__PURE__ */ new Map();
+				items.forEach((it, idx) => {
+					if (it.entry.catalog !== catalog) return;
+					const cand = displayCandidates(it)[state.picks[idx] ?? 0];
+					if (cand) selected.set(it.entry.pkg, cand.version);
+				});
+				interopPeers.set(catalog, computeGroupPeers(model, selected));
+			}
+			const rows = [];
+			let lastCatalog = null;
+			visible.forEach((item, offset) => {
+				const i = start + offset;
+				if (item.entry.catalog !== lastCatalog) {
+					lastCatalog = item.entry.catalog;
+					rows.push(/* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx(Styled, {
+						token: "muted",
+						children: `  ── catalog: ${Fmt.sanitize(lastCatalog)} ──`
+					}) }, `cat-${lastCatalog}`));
+				}
+				const onCursor = i === state.cursor;
+				const pick = state.picks[i] ?? 0;
+				const candidates = displayCandidates(item);
+				const chosen = candidates[pick];
+				const gp = interopPeers.get(item.entry.catalog);
+				const peerText = gp?.peer.get(item.entry.pkg) ?? (chosen === void 0 ? "—" : peerFor(item, chosen));
+				const conflict = gp?.conflict.get(item.entry.pkg);
+				const room = Math.max(8, columns - fixedPrefix - peerText.length - 3);
+				rows.push(/* @__PURE__ */ jsxs(Text, {
+					wrap: "truncate-end",
+					children: [
+						onCursor ? /* @__PURE__ */ jsx(Styled, {
+							token: "accent",
+							children: "❯ "
+						}) : "  ",
+						/* @__PURE__ */ jsx(Text, {
+							bold: onCursor,
+							children: Fmt.sanitize(item.entry.pkg).padEnd(pkgWidth + 2)
+						}),
+						candidates.map((c, ci) => {
+							const t = cellTone(c, ci === pick);
+							const text = cellText(c, ci === pick);
+							return t === null ? text : /* @__PURE__ */ jsx(Styled, {
+								token: TONES[t],
+								children: text
+							}, c.kind);
+						}),
+						blankCell.repeat(maxCells - candidates.length),
+						/* @__PURE__ */ jsx(Styled, {
+							token: "muted",
+							children: `│ ${peerText}`
+						}),
+						conflict ? /* @__PURE__ */ jsx(Styled, {
+							token: "failure",
+							children: truncateEnd(`  ⚠ needs ${Fmt.sanitize(conflict)}`, room)
+						}) : null,
+						item.peerWarning ? /* @__PURE__ */ jsx(Styled, {
+							token: "failure",
+							children: truncateEnd(`  ⚠ ${Fmt.sanitize(item.peerWarning.message)}`, room)
+						}) : null
+					]
+				}, `${item.entry.catalog}/${item.entry.pkg}`));
+			});
+			return /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						bold: true,
+						wrap: "truncate-end",
+						children: dryRun ? "Choose versions to preview" : "Choose versions to update"
+					}),
+					dryRun ? /* @__PURE__ */ jsx(Text, {
+						wrap: "truncate-end",
+						children: /* @__PURE__ */ jsx(Styled, {
+							token: "warning",
+							children: "DRY RUN — nothing will be written to the config"
+						})
+					}) : null,
+					unresolved.length > 0 ? /* @__PURE__ */ jsx(Text, {
+						wrap: "truncate-end",
+						children: /* @__PURE__ */ jsx(Styled, {
+							token: "failure",
+							children: `⚠ Could not resolve from the registry — check for a typo: ${unresolved.map(Fmt.sanitize).join(", ")}`
+						})
+					}) : null,
+					/* @__PURE__ */ jsx(Box, { height: 1 }),
+					rows,
+					/* @__PURE__ */ jsx(KeyHelp, { tables: [keys] })
+				]
+			});
+		};
+		return /* @__PURE__ */ jsx(Walk, {});
+	};
+}
+
+//#endregion
+export { makeWalkScreen };

package/cli/version.js

@@ -0,0 +1,12 @@
+//#region src/cli/version.ts
+/**
+* The CLI's version. The bundler substitutes `__PACKAGE_VERSION__` at build
+* time, so this is not a runtime environment read; source runs report
+* `0.0.0`.
+*
+* @internal
+*/
+const CLI_VERSION = "2.0.0";
+
+//#endregion
+export { CLI_VERSION };

package/cli/walk-reducer.js

@@ -69,15 +69,14 @@ function initTable(items) {
 	return {
 		cursor: first === -1 ? 0 : first,
 		picks: items.map(() => 0),
-		done: false,
-		cancelled: false
+		done: false
 	};
 }
 const clamp = (n, max) => n < 0 ? 0 : n > max ? max : n;
 /**
 * Advance the table by a key. up/down move between rows; left/right move the
-* radio selection within the row under the cursor; submit applies; cancel exits
-* without applying. Both axes clamp at their ends rather than wrapping.
+* radio selection within the row under the cursor; submit applies. Both axes
+* clamp at their ends rather than wrapping.
 *
 * @internal
 */
@@ -87,11 +86,6 @@ function tableStep(state, items, key) {
 		...state,
 		done: true
 	};
-	if (key === "cancel") return {
-		...state,
-		done: true,
-		cancelled: true
-	};
 	if (items.length === 0) return state;
 	if (key === "up") return {
 		...state,
@@ -111,13 +105,11 @@ function tableStep(state, items, key) {
 	};
 }
 /**
-* Project the table's selections into decisions. A cancelled table yields none,
-* so nothing is written.
+* Project the table's selections into decisions, one per row.
 *
 * @internal
 */
 function tableDecisions(state, items) {
-	if (state.cancelled) return [];
 	return items.map((item, i) => ({
 		item,
 		chosen: displayCandidates(item)[state.picks[i] ?? 0]
@@ -139,23 +131,20 @@ function peerFor(item, chosen) {
 	return item.entry.peer?.value ?? "—";
 }
 /**
-* The Ink color for one candidate cell, or null for the terminal's default.
-*
-* Only a SELECTED UPGRADE is colored — green in-range, yellow for a major. A
-* selected KEEP is deliberately left uncolored: it is the current value, not a
-* change, and coloring it dim made the column the eye lands on first read as
-* disabled. Unselected cells are always default.
+* The tone of one candidate cell, or null for the default (untoned) text.
 *
-* Extracted from the render so it can be unit-tested: `ink-testing-library`
-* strips ANSI from `lastFrame()`, so a color assertion is impossible against
-* the rendered output.
+* Only a SELECTED UPGRADE is toned — `added` for in-range, `changed` for a
+* major. A selected KEEP is deliberately left untoned in the interactive
+* table: it is the current value, not a change, and dimming it made the column
+* the eye lands on first read as disabled. Unselected cells are always
+* default. Shared by the table and its summary mirror so the two agree.
 *
 * @internal
 */
-function cellColor(candidate, selected) {
+function cellTone(candidate, selected) {
 	if (!selected || candidate.kind === "keep") return null;
-	return candidate.isMajor ? "yellow" : "green";
+	return candidate.isMajor ? "changed" : "added";
 }
 
 //#endregion
-export { MAJOR_SUFFIX, cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableLayout, tableStep, truncateEnd };
+export { MAJOR_SUFFIX, cellTone, displayCandidates, initTable, peerFor, tableDecisions, tableLayout, tableStep, truncateEnd };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rolldown-pnpm-config",
-	"version": "1.0.11",
+	"version": "2.0.0",
 	"private": false,
 	"description": "A dogfooding example of our plugin",
 	"repository": {
@@ -36,16 +36,18 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "^4.0.0",
+		"@effected/cli": "^0.11.0",
+		"@effected/env": "^0.1.0",
+		"@effected/glob": "^0.10.0",
 		"@effected/npm": "^0.20.0",
 		"@effected/semver": "^0.11.0",
+		"@effected/walker": "^0.15.0",
 		"@effected/workspaces": "^0.31.0",
 		"@effected/yaml": "^0.19.0",
 		"effect": "^4.0.0",
 		"ink": "^7.1.1",
-		"ink-tab": "^5.2.0",
 		"oxc-parser": "^0.152.0",
-		"react": "^19.3.0",
-		"std-env": "^4.3.0"
+		"react": "^19.3.0"
 	},
 	"peerDependencies": {
 		"rolldown": "^1.2.0"

package/cli/ui/Preview.js

@@ -1,65 +0,0 @@
-import { legendLines, simulatedLegendLines } from "./legend.js";
-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_PROPS = {
-	added: { color: "green" },
-	removed: { color: "red" },
-	changed: { color: "yellow" },
-	warn: { color: "red" },
-	local: { color: "magenta" },
-	unmanaged: { color: "#585858" },
-	unchanged: { dimColor: true },
-	plain: {},
-	merge: { color: "cyan" },
-	overwrite: { color: "magenta" }
-};
-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 === "local" ? "  (local)" : "";
-		const body = l.segments.map((s, j) => {
-			const props = INK_PROPS[s.style] ?? {};
-			return createElement(Text, {
-				key: j,
-				...props
-			}, 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 || key.return) {
-			onExit();
-			app.exit();
-		}
-	});
-	const tabs = 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"));
-	const legend = renderLines(active === "simulated" ? simulatedLegendLines() : legendLines());
-	return createElement(Box, { flexDirection: "column" }, tabs, legend, renderLines(views[active]));
-}
-
-//#endregion
-export { Preview };

package/cli/ui/Walk.js

@@ -1,89 +0,0 @@
-import { computeGroupPeers } from "../interop-live.js";
-import { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableLayout, tableStep, truncateEnd } from "../walk-reducer.js";
-import { Box, Text, useApp, useInput } from "ink";
-import { createElement, useEffect, useState } from "react";
-
-//#region src/cli/ui/Walk.ts
-/** Rows visible at once before the viewport scrolls. */
-const VIEWPORT = 20;
-/**
-* Interactive upgrade table rendered with Ink. Every package is one row; each
-* row is a radio group over its candidates with keep (index 0) preselected, so
-* the default state of the table applies nothing.
-*
-* Written with React.createElement (no JSX) so the file can be plain .ts
-* without requiring TSX transform configuration.
-*
-* @internal
-*/
-function Walk({ items, onDone, dryRun = false, unresolved = [], interopModels = /* @__PURE__ */ new Map() }) {
-	const app = useApp();
-	const [state, setState] = useState(() => initTable(items));
-	useEffect(() => {
-		if (items.length === 0) {
-			onDone([]);
-			app.exit();
-		}
-	}, []);
-	useInput((_input, key) => {
-		if (state.done) return;
-		const which = key.upArrow ? "up" : key.downArrow ? "down" : key.leftArrow ? "left" : key.rightArrow ? "right" : key.return ? "submit" : key.escape ? "cancel" : null;
-		if (!which) return;
-		const next = tableStep(state, items, which);
-		setState(next);
-		if (next.done) {
-			onDone(tableDecisions(next, items));
-			app.exit();
-		}
-	});
-	if (state.done || items.length === 0) return createElement(Text, null, "Done.");
-	const { pkgWidth, cellWidth, maxCells, blankCell, cellText } = tableLayout(items);
-	const termCols = process.stdout.columns ?? 100;
-	const fixedPrefix = 2 + (pkgWidth + 2) + maxCells * (cellWidth + 4) + 2;
-	const start = Math.max(0, Math.min(state.cursor - Math.floor(VIEWPORT / 2), items.length - VIEWPORT));
-	const visible = items.slice(Math.max(0, start), Math.max(0, start) + VIEWPORT);
-	const interopPeers = /* @__PURE__ */ new Map();
-	for (const [catalog, model] of interopModels) {
-		const selected = /* @__PURE__ */ new Map();
-		items.forEach((it, idx) => {
-			if (it.entry.catalog !== catalog) return;
-			const cand = displayCandidates(it)[state.picks[idx] ?? 0];
-			if (cand) selected.set(it.entry.pkg, cand.version);
-		});
-		interopPeers.set(catalog, computeGroupPeers(model, selected));
-	}
-	const rows = [];
-	let lastCatalog = null;
-	visible.forEach((item, offset) => {
-		const i = Math.max(0, start) + offset;
-		if (item.entry.catalog !== lastCatalog) {
-			lastCatalog = item.entry.catalog;
-			rows.push(createElement(Text, {
-				key: `cat-${item.entry.catalog}`,
-				dimColor: true
-			}, `  ── catalog: ${lastCatalog} ──`));
-		}
-		const onCursor = i === state.cursor;
-		const pick = state.picks[i] ?? 0;
-		const candidates = displayCandidates(item);
-		const cells = candidates.map((c, ci) => {
-			const selected = ci === pick;
-			const color = cellColor(c, selected);
-			return createElement(Text, {
-				key: c.kind,
-				...color ? { color } : {}
-			}, cellText(c, selected));
-		});
-		for (let ci = candidates.length; ci < maxCells; ci++) cells.push(createElement(Text, { key: `blank-${ci}` }, blankCell));
-		const chosen = candidates[pick];
-		const gp = interopPeers.get(item.entry.catalog);
-		const peerText = gp?.peer.get(item.entry.pkg) ?? (chosen === void 0 ? "—" : peerFor(item, chosen));
-		const conflict = gp?.conflict.get(item.entry.pkg);
-		const room = Math.max(8, termCols - fixedPrefix - peerText.length - 3);
-		rows.push(createElement(Box, { key: `${item.entry.catalog}/${item.entry.pkg}` }, createElement(Text, { ...onCursor ? { color: "cyan" } : {} }, onCursor ? "❯ " : "  "), createElement(Text, { bold: onCursor }, item.entry.pkg.padEnd(pkgWidth + 2)), ...cells, createElement(Text, { dimColor: true }, `│ ${peerText}`), conflict ? createElement(Text, { color: "red" }, truncateEnd(`  ⚠ needs ${conflict}`, room)) : null, item.peerWarning ? createElement(Text, { color: "red" }, truncateEnd(`  ⚠ ${item.peerWarning.message}`, room)) : null));
-	});
-	return createElement(Box, { flexDirection: "column" }, createElement(Text, { bold: true }, dryRun ? "Enter to preview • Esc to cancel" : "Enter to update • Esc to cancel"), dryRun ? createElement(Text, { color: "yellow" }, "DRY RUN — nothing will be written to the config") : null, unresolved.length > 0 ? createElement(Text, { color: "red" }, `⚠ Could not resolve from the registry — check for a typo: ${unresolved.join(", ")}`) : null, createElement(Box, { height: 1 }), ...rows);
-}
-
-//#endregion
-export { Walk };