envprism 0.3.0 → 0.3.1

package/dist/chunks/app-Bp7QXiLx.mjs

@@ -0,0 +1,1965 @@
+import { d as resolveThemeHex, f as findKvEntry, g as DEFAULT_CONFIG, h as truncate, l as DEFAULT_THEME_HEX, m as matchesFilter, p as formatValue, t as buildMatrix, u as resolveHeuristics } from "./matrix-CG1Msljr.mjs";
+import { n as serializeEnv, t as rebuildKvLine } from "./serialize-DWF9VxrS.mjs";
+import { writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "pathe";
+import { BoxRenderable, RGBA, ScrollBoxRenderable, TextRenderable, createCliRenderer } from "@opentui/core";
+//#region src/tui/grouping.ts
+var SECTION_COLLAPSE_KEY = "__other__";
+function prefixSection(key) {
+	const idx = key.indexOf("_");
+	if (idx <= 0) return void 0;
+	return key.slice(0, idx);
+}
+/**
+* Sort by first-underscore-prefix while preserving the relative order each
+* prefix first appeared in. Keys without an underscore land in a trailing
+* "Other" group keeping their authored order.
+*/
+function groupByPrefix(keys) {
+	const groups = /* @__PURE__ */ new Map();
+	const order = [];
+	const OTHER = SECTION_COLLAPSE_KEY;
+	for (const k of keys) {
+		const p = prefixSection(k) ?? OTHER;
+		let bucket = groups.get(p);
+		if (!bucket) {
+			bucket = [];
+			groups.set(p, bucket);
+			if (p !== OTHER) order.push(p);
+		}
+		bucket.push(k);
+	}
+	if (groups.has(OTHER)) order.push(OTHER);
+	return order.flatMap((p) => groups.get(p));
+}
+/**
+* Move row focus by `delta` while skipping section dividers that are not
+* collapsed. The user only needs to land on a divider when its section is
+* folded — that's the only context in which 'c' on the divider does work
+* the focused-key path doesn't already cover.
+*/
+function stepRow(state, delta) {
+	const items = state.visibleItems;
+	if (items.length === 0) return 0;
+	const canFocus = (i) => {
+		const it = items[i];
+		if (!it) return false;
+		if (it.kind === "key") return true;
+		return state.collapsed.has(it.ref);
+	};
+	let i = state.rowIdx + delta;
+	while (i >= 0 && i < items.length) {
+		if (canFocus(i)) return i;
+		i += delta;
+	}
+	return state.rowIdx;
+}
+function orderedKeys(matrix, state, sectionOf) {
+	const filtered = matrix.keys.filter((k) => {
+		if (!matchesFilter(k, state.filter)) return false;
+		if (state.driftOnly && !keyDrifts(matrix, k)) return false;
+		return true;
+	});
+	return state.grouping === "prefix" ? groupByPrefix(filtered) : filtered;
+}
+function sectionMetadata(matrix, sectionOf, state) {
+	const out = /* @__PURE__ */ new Map();
+	for (const key of orderedKeys(matrix, state, sectionOf)) {
+		const k = sectionOf(key) ?? "__other__";
+		const bucket = out.get(k) ?? {
+			drift: 0,
+			missing: 0,
+			total: 0
+		};
+		bucket.total += 1;
+		let drifts = false;
+		let missing = false;
+		for (const file of matrix.files) {
+			if (file === matrix.base) continue;
+			const s = matrix.cell(key, file).state;
+			if (s === "missing") missing = true;
+			if (s === "differs" || s === "missing" || s === "extra") drifts = true;
+		}
+		if (drifts) bucket.drift += 1;
+		if (missing) bucket.missing += 1;
+		out.set(k, bucket);
+	}
+	return out;
+}
+function keyDrifts(matrix, key) {
+	for (const file of matrix.files) {
+		if (file === matrix.base) continue;
+		const s = matrix.cell(key, file).state;
+		if (s === "differs" || s === "missing" || s === "extra") return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/tui/envfile.ts
+function isValidEnvFileName(name) {
+	if (!name.startsWith(".env")) return false;
+	if (name.includes("/") || name.includes("\\")) return false;
+	if (name.endsWith(".swp") || name.endsWith("~") || name.endsWith(".bak")) return false;
+	return true;
+}
+function createEmptyEnvFile(path) {
+	return {
+		path,
+		entries: [{
+			kind: "comment",
+			raw: `# ${basename(path)}`
+		}],
+		trailingNewline: true
+	};
+}
+function appendKv(file, key, value) {
+	const entry = {
+		kind: "kv",
+		key,
+		rawValue: "",
+		value,
+		quoting: "none",
+		exportPrefix: false,
+		inlineComment: "",
+		raw: ""
+	};
+	rebuildKvLine(entry);
+	file.entries.push(entry);
+	file.trailingNewline = true;
+	return entry;
+}
+//#endregion
+//#region src/tui/state/visible.ts
+function cellKey(key, file) {
+	return `${key}|${file.path}`;
+}
+function markModified(ctx, key, file) {
+	ctx.state.modified.add(cellKey(key, file));
+}
+function pushUndo(ctx, entry) {
+	ctx.state.undo.push(entry);
+	if (ctx.state.undo.length > ctx.config.tui.undoLimit) ctx.state.undo.shift();
+}
+function focusedKey(ctx) {
+	const item = ctx.state.visibleItems[ctx.state.rowIdx];
+	return item && item.kind === "key" ? item.ref : null;
+}
+function focusKey(ctx, key) {
+	const idx = ctx.state.visibleKeys.indexOf(key);
+	if (idx >= 0) ctx.state.rowIdx = idx;
+}
+function recomputeVisibleKeys(ctx) {
+	const { state } = ctx;
+	const visibleKeys = [];
+	const items = [];
+	const orderedAll = orderedKeys(ctx.matrix, state, ctx.sectionOf);
+	const seen = /* @__PURE__ */ new Set();
+	const focusedRef = state.visibleItems[state.rowIdx]?.ref;
+	for (const k of orderedAll) {
+		if (!matchesFilter(k, state.filter)) continue;
+		if (state.driftOnly && !keyDrifts(ctx.matrix, k)) continue;
+		const secKey = ctx.sectionOf(k) ?? "__other__";
+		if (!seen.has(secKey)) {
+			seen.add(secKey);
+			items.push({
+				kind: "divider",
+				ref: secKey
+			});
+		}
+		if (state.collapsed.has(secKey)) continue;
+		items.push({
+			kind: "key",
+			ref: k
+		});
+		visibleKeys.push(k);
+	}
+	state.visibleKeys = visibleKeys;
+	state.visibleItems = items;
+	if (focusedRef) {
+		const i = items.findIndex((it) => it.ref === focusedRef);
+		if (i >= 0) state.rowIdx = i;
+	}
+	if (state.rowIdx >= items.length) state.rowIdx = Math.max(0, items.length - 1);
+	if (items[state.rowIdx]?.kind === "divider" && !state.collapsed.has(items[state.rowIdx].ref)) {
+		const next = stepRow(state, 1);
+		const prev = stepRow(state, -1);
+		state.rowIdx = next !== state.rowIdx ? next : prev;
+	}
+}
+function rebuildMatrix(ctx) {
+	const { state } = ctx;
+	const enabledList = ctx.allFiles.filter((f) => state.enabled.has(f));
+	if (!state.enabled.has(ctx.currentBase)) {
+		const next = enabledList[0];
+		if (next) ctx.currentBase = next;
+	}
+	ctx.matrix = buildMatrix(enabledList, ctx.currentBase);
+	if (state.colIdx >= ctx.matrix.files.length) state.colIdx = Math.max(0, ctx.matrix.files.length - 1);
+	if (state.sidebarIdx >= ctx.allFiles.length) state.sidebarIdx = Math.max(0, ctx.allFiles.length - 1);
+	recomputeVisibleKeys(ctx);
+}
+//#endregion
+//#region src/tui/actions/batch.ts
+function applyToAllFiles(ctx, key, value) {
+	const { state } = ctx;
+	let touched = 0;
+	for (const file of ctx.matrix.files) {
+		const existing = findKvEntry(file, key);
+		if (existing) {
+			if (existing.value === value) continue;
+			pushUndo(ctx, {
+				kind: "edit",
+				file,
+				entry: existing,
+				prevValue: existing.value,
+				prevRaw: existing.raw
+			});
+			existing.value = value;
+			rebuildKvLine(existing);
+		} else pushUndo(ctx, {
+			kind: "add-kv",
+			file,
+			entry: appendKv(file, key, value)
+		});
+		state.dirty.add(file);
+		markModified(ctx, key, file);
+		touched++;
+	}
+	return touched;
+}
+function syncToAll(ctx) {
+	const { state } = ctx;
+	const key = focusedKey(ctx);
+	const file = ctx.matrix.files[state.colIdx];
+	if (!key || !file) {
+		state.message = "Move onto a variable row to sync.";
+		ctx.refresh();
+		return;
+	}
+	const entry = findKvEntry(file, key);
+	if (!entry) {
+		state.message = `${key} has no value in ${basename(file.path)} to sync.`;
+		ctx.refresh();
+		return;
+	}
+	const touched = applyToAllFiles(ctx, key, entry.value);
+	rebuildMatrix(ctx);
+	state.message = touched > 0 ? `Synced ${key} to ${touched} file(s). Ctrl-S to save.` : `${key} is already in sync.`;
+	ctx.refresh();
+}
+function undo(ctx) {
+	const { state } = ctx;
+	const last = state.undo.pop();
+	if (!last) {
+		state.message = "Nothing to undo.";
+		ctx.refresh();
+		return;
+	}
+	switch (last.kind) {
+		case "edit":
+			last.entry.value = last.prevValue;
+			last.entry.raw = last.prevRaw;
+			state.dirty.add(last.file);
+			state.message = `Undid edit on ${last.entry.key} in ${basename(last.file.path)}.`;
+			break;
+		case "add-kv": {
+			const i = last.file.entries.indexOf(last.entry);
+			if (i >= 0) last.file.entries.splice(i, 1);
+			state.dirty.add(last.file);
+			state.message = `Undid add of ${last.entry.key} in ${basename(last.file.path)}.`;
+			break;
+		}
+		case "delete-kv":
+			last.file.entries.splice(last.idx, 0, last.entry);
+			state.dirty.add(last.file);
+			state.message = `Undid delete of ${last.entry.key} in ${basename(last.file.path)}.`;
+			break;
+	}
+	rebuildMatrix(ctx);
+	ctx.refresh();
+}
+function toggleEnabled(ctx) {
+	const { state } = ctx;
+	const file = ctx.allFiles[state.sidebarIdx];
+	if (!file) return;
+	if (state.enabled.has(file)) {
+		if (state.enabled.size === 1) {
+			state.message = "At least one file must stay enabled.";
+			ctx.refresh();
+			return;
+		}
+		state.enabled.delete(file);
+		state.message = `Hidden ${basename(file.path)} from the matrix.`;
+	} else {
+		state.enabled.add(file);
+		state.message = `Showing ${basename(file.path)} in the matrix.`;
+	}
+	rebuildMatrix(ctx);
+	ctx.refresh();
+}
+function setBase(ctx) {
+	const { state } = ctx;
+	const file = ctx.allFiles[state.sidebarIdx];
+	if (!file) return;
+	if (file === ctx.currentBase) {
+		state.message = `${basename(file.path)} is already the base.`;
+		ctx.refresh();
+		return;
+	}
+	const wasDisabled = !state.enabled.has(file);
+	if (wasDisabled) state.enabled.add(file);
+	ctx.currentBase = file;
+	rebuildMatrix(ctx);
+	state.message = wasDisabled ? `${basename(file.path)} is now the base (re-enabled).` : `${basename(file.path)} is now the base.`;
+	ctx.refresh();
+}
+//#endregion
+//#region src/tui/actions/io.ts
+async function saveDirty(ctx) {
+	const { state } = ctx;
+	if (state.dirty.size === 0) {
+		state.message = "Nothing to save.";
+		ctx.refresh();
+		return;
+	}
+	const count = state.dirty.size;
+	const errors = [];
+	for (const file of state.dirty) try {
+		await writeFile(file.path, serializeEnv(file), "utf8");
+	} catch (err) {
+		errors.push(`${basename(file.path)}: ${err.message ?? String(err)}`);
+	}
+	if (errors.length === 0) {
+		state.dirty.clear();
+		state.modified.clear();
+		state.message = `Saved ${count} file${count === 1 ? "" : "s"}.`;
+	} else state.message = `Save failed: ${errors.join("; ")}`;
+	ctx.refresh();
+}
+//#endregion
+//#region src/tui/types.ts
+var KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+//#endregion
+//#region src/tui/actions/prompt.ts
+function openPrompt(ctx, prompt, value = "") {
+	const { state } = ctx;
+	state.prompt = prompt;
+	state.mode = "prompt";
+	state.message = null;
+	state.promptInput = value;
+	ctx.refresh();
+}
+function closePrompt(ctx, msg = null) {
+	const { state } = ctx;
+	state.prompt = null;
+	state.mode = "browse";
+	state.promptInput = "";
+	state.message = msg;
+	ctx.refresh();
+}
+function cancelPrompt(ctx) {
+	closePrompt(ctx, "Cancelled.");
+}
+function startEdit(ctx) {
+	const { state } = ctx;
+	const key = focusedKey(ctx);
+	const file = ctx.matrix.files[state.colIdx];
+	if (!key || !file) {
+		state.message = "Move onto a variable row to edit.";
+		ctx.refresh();
+		return;
+	}
+	const entry = findKvEntry(file, key);
+	openPrompt(ctx, {
+		kind: "edit",
+		key,
+		file
+	}, entry?.value ?? "");
+}
+function startAdd(ctx) {
+	const file = ctx.matrix.files[ctx.state.colIdx];
+	if (!file) return;
+	openPrompt(ctx, {
+		kind: "add-key",
+		file
+	});
+}
+function startNewFile(ctx) {
+	openPrompt(ctx, { kind: "new-file" });
+}
+function startDelete(ctx) {
+	const { state } = ctx;
+	const key = focusedKey(ctx);
+	const file = ctx.matrix.files[state.colIdx];
+	if (!key || !file) {
+		state.message = "Move onto a variable row to delete.";
+		ctx.refresh();
+		return;
+	}
+	const entry = findKvEntry(file, key);
+	if (!entry) {
+		state.message = `${key} is not present in ${basename(file.path)}.`;
+		ctx.refresh();
+		return;
+	}
+	const idx = file.entries.indexOf(entry);
+	if (idx >= 0) {
+		pushUndo(ctx, {
+			kind: "delete-kv",
+			file,
+			entry,
+			idx
+		});
+		file.entries.splice(idx, 1);
+	}
+	state.dirty.add(file);
+	markModified(ctx, key, file);
+	rebuildMatrix(ctx);
+	state.message = `Deleted ${key} from ${basename(file.path)}. Ctrl-S to save.`;
+	ctx.refresh();
+}
+function commitPrompt(ctx) {
+	const { state } = ctx;
+	if (!state.prompt) return;
+	const p = state.prompt;
+	const raw = state.promptInput;
+	if (p.kind === "edit") {
+		const existing = findKvEntry(p.file, p.key);
+		if (existing) {
+			pushUndo(ctx, {
+				kind: "edit",
+				file: p.file,
+				entry: existing,
+				prevValue: existing.value,
+				prevRaw: existing.raw
+			});
+			existing.value = raw;
+			rebuildKvLine(existing);
+			state.dirty.add(p.file);
+			markModified(ctx, p.key, p.file);
+			rebuildMatrix(ctx);
+			closePrompt(ctx, `Edited ${p.key} in ${basename(p.file.path)}. Ctrl-S to save.`);
+		} else {
+			const added = appendKv(p.file, p.key, raw);
+			pushUndo(ctx, {
+				kind: "add-kv",
+				file: p.file,
+				entry: added
+			});
+			state.dirty.add(p.file);
+			markModified(ctx, p.key, p.file);
+			rebuildMatrix(ctx);
+			closePrompt(ctx, `Added ${p.key} to ${basename(p.file.path)}. Ctrl-S to save.`);
+		}
+		return;
+	}
+	if (p.kind === "add-key") {
+		const key = raw.trim();
+		if (!KEY_RE.test(key)) {
+			state.message = `Invalid key "${key}". Must match ${KEY_RE.source}.`;
+			ctx.refresh();
+			return;
+		}
+		if (findKvEntry(p.file, key)) {
+			state.message = `${key} already exists in ${basename(p.file.path)}. Use edit instead.`;
+			ctx.refresh();
+			return;
+		}
+		openPrompt(ctx, {
+			kind: "add-value",
+			key,
+			file: p.file
+		});
+		return;
+	}
+	if (p.kind === "add-value") {
+		const added = appendKv(p.file, p.key, raw);
+		pushUndo(ctx, {
+			kind: "add-kv",
+			file: p.file,
+			entry: added
+		});
+		state.dirty.add(p.file);
+		markModified(ctx, p.key, p.file);
+		rebuildMatrix(ctx);
+		focusKey(ctx, p.key);
+		state.colIdx = ctx.matrix.files.indexOf(p.file);
+		closePrompt(ctx, `Added ${p.key} to ${basename(p.file.path)}. Ctrl-S to save.`);
+		return;
+	}
+	if (p.kind === "new-file") {
+		const name = raw.trim();
+		if (!isValidEnvFileName(name)) {
+			state.message = name.length === 0 ? "Filename cannot be empty." : !name.startsWith(".env") ? `Filename must start with ".env" (got "${name}").` : `"${name}" is not a valid env filename.`;
+			ctx.refresh();
+			return;
+		}
+		const newPath = join(dirname(ctx.currentBase.path), name);
+		if (ctx.allFiles.some((f) => f.path === newPath)) {
+			state.message = `${name} already exists.`;
+			ctx.refresh();
+			return;
+		}
+		const newFile = createEmptyEnvFile(newPath);
+		ctx.allFiles.push(newFile);
+		state.enabled.add(newFile);
+		state.dirty.add(newFile);
+		rebuildMatrix(ctx);
+		state.colIdx = ctx.matrix.files.indexOf(newFile);
+		closePrompt(ctx, `Created ${name}. Ctrl-S to write to disk.`);
+		return;
+	}
+}
+//#endregion
+//#region src/tui/keys/browse.ts
+function handleBrowseKey(ctx, key, cleanup) {
+	const { state } = ctx;
+	const refresh = ctx.refresh;
+	if (key.ctrl && key.name === "c") return cleanup();
+	if (key.ctrl && key.name === "s") {
+		state.confirmQuit = false;
+		saveDirty(ctx);
+		return;
+	}
+	if (key.ctrl && key.name === "z") {
+		state.confirmQuit = false;
+		return undo(ctx);
+	}
+	if (key.ctrl && key.name === "t") {
+		state.showSecrets = !state.showSecrets;
+		state.message = state.showSecrets ? "Showing secret values in plain text." : "Masking secret values.";
+		return refresh();
+	}
+	const tryQuit = () => {
+		if (state.dirty.size > 0 && !state.confirmQuit) {
+			state.confirmQuit = true;
+			state.message = `${state.dirty.size} unsaved file(s). Press 'q' again to quit without saving, or Ctrl-S to save first.`;
+			refresh();
+			return;
+		}
+		cleanup();
+	};
+	if (state.confirmQuit && key.name !== "q") {
+		state.confirmQuit = false;
+		state.message = null;
+	}
+	if (state.pane === "sidebar") {
+		switch (key.name) {
+			case "q": return tryQuit();
+			case "tab":
+				state.pane = "matrix";
+				return refresh();
+			case "right":
+				state.pane = "matrix";
+				return refresh();
+			case "up":
+				state.sidebarIdx = Math.max(0, state.sidebarIdx - 1);
+				return refresh();
+			case "down":
+				state.sidebarIdx = Math.min(ctx.allFiles.length - 1, state.sidebarIdx + 1);
+				return refresh();
+			case "space": return toggleEnabled(ctx);
+			case "b": return setBase(ctx);
+		}
+		if (key.sequence === " ") return toggleEnabled(ctx);
+		if (key.sequence === "?" || key.sequence === "ß") {
+			state.helpOpen = true;
+			return refresh();
+		}
+		return;
+	}
+	switch (key.name) {
+		case "q": return tryQuit();
+		case "tab":
+			state.pane = "sidebar";
+			return refresh();
+		case "up":
+			state.rowIdx = stepRow(state, -1);
+			return refresh();
+		case "down":
+			state.rowIdx = stepRow(state, 1);
+			return refresh();
+		case "left":
+			if (state.colIdx === 0) {
+				state.pane = "sidebar";
+				return refresh();
+			}
+			state.colIdx = Math.max(0, state.colIdx - 1);
+			return refresh();
+		case "right":
+			state.colIdx = Math.min(ctx.matrix.files.length - 1, state.colIdx + 1);
+			return refresh();
+		case "e":
+		case "return": return startEdit(ctx);
+		case "a": return startAdd(ctx);
+		case "d": return startDelete(ctx);
+		case "n": return startNewFile(ctx);
+		case "v":
+			state.driftOnly = !state.driftOnly;
+			state.message = state.driftOnly ? "Drift-only view (only keys with differences)." : "Full view.";
+			recomputeVisibleKeys(ctx);
+			return refresh();
+		case "c": {
+			if (key.shift) {
+				if (state.collapsed.size === 0) {
+					state.message = "Nothing collapsed.";
+					return refresh();
+				}
+				const count = state.collapsed.size;
+				state.collapsed.clear();
+				state.message = `Expanded ${count} section(s).`;
+				recomputeVisibleKeys(ctx);
+				return refresh();
+			}
+			const item = state.visibleItems[state.rowIdx];
+			if (!item) return;
+			const sectionKey = item.kind === "divider" ? item.ref : ctx.sectionOf(item.ref) ?? "__other__";
+			const label = sectionKey === "__other__" ? "(other)" : sectionKey;
+			if (state.collapsed.has(sectionKey)) {
+				state.collapsed.delete(sectionKey);
+				state.message = `Expanded "${label}".`;
+			} else {
+				state.collapsed.add(sectionKey);
+				state.message = `Collapsed "${label}". Press Shift-C to expand all.`;
+			}
+			recomputeVisibleKeys(ctx);
+			return refresh();
+		}
+		case "g":
+			state.grouping = state.grouping === "banner" ? "prefix" : "banner";
+			recomputeVisibleKeys(ctx);
+			state.message = state.grouping === "banner" ? "Group by comment banners." : "Group by key prefix (first underscore segment).";
+			return refresh();
+	}
+	if (key.sequence === "/" || key.name === "slash") {
+		state.mode = "filter";
+		state.message = null;
+		refresh();
+		return;
+	}
+	if (key.sequence === "=") return syncToAll(ctx);
+	if (key.sequence === "?" || key.sequence === "ß") {
+		state.helpOpen = true;
+		refresh();
+	}
+}
+//#endregion
+//#region src/tui/keys/filter.ts
+function handleFilterKey(ctx, key) {
+	const { state } = ctx;
+	if (key.name === "escape") {
+		state.filter = "";
+		state.mode = "browse";
+		recomputeVisibleKeys(ctx);
+		ctx.refresh();
+		return;
+	}
+	if (key.name === "return") {
+		state.mode = "browse";
+		ctx.refresh();
+		return;
+	}
+	if (key.name === "backspace") {
+		if (state.filter.length > 0) {
+			state.filter = state.filter.slice(0, -1);
+			recomputeVisibleKeys(ctx);
+			ctx.refresh();
+		}
+		return;
+	}
+	const seq = key.sequence ?? "";
+	if (seq.length === 1 && seq >= " " && seq !== "") {
+		state.filter += seq;
+		recomputeVisibleKeys(ctx);
+		ctx.refresh();
+	}
+}
+//#endregion
+//#region src/tui/keys/help.ts
+function handleHelpKey(ctx, key) {
+	if (key.name === "escape" || key.sequence === "?" || key.sequence === "ß" || key.name === "q") {
+		ctx.state.helpOpen = false;
+		ctx.refresh();
+	}
+}
+//#endregion
+//#region src/tui/keys/prompt.ts
+function handlePromptKey(ctx, key) {
+	const { state } = ctx;
+	if (key.name === "escape") {
+		cancelPrompt(ctx);
+		return;
+	}
+	if (key.name === "return") {
+		commitPrompt(ctx);
+		return;
+	}
+	if (key.name === "backspace") {
+		if (state.promptInput.length > 0) {
+			state.promptInput = state.promptInput.slice(0, -1);
+			ctx.refresh();
+		}
+		return;
+	}
+	if (key.ctrl && key.name === "t") {
+		state.showSecrets = !state.showSecrets;
+		ctx.refresh();
+		return;
+	}
+	if (key.ctrl && key.name === "a" && state.prompt) {
+		const p = state.prompt;
+		if (p.kind === "edit" || p.kind === "add-value") {
+			const touched = applyToAllFiles(ctx, p.key, state.promptInput);
+			rebuildMatrix(ctx);
+			closePrompt(ctx, touched > 0 ? `Set ${p.key} in ${touched} file(s). Ctrl-S to save.` : `${p.key} already had that value everywhere.`);
+		}
+		return;
+	}
+	const seq = key.sequence ?? "";
+	if (!key.ctrl && seq.length === 1 && seq >= " " && seq !== "") {
+		state.promptInput += seq;
+		ctx.refresh();
+	}
+}
+//#endregion
+//#region src/tui/keys/onKey.ts
+/**
+* Build the global keypress handler. Dispatches by current mode; `cleanup`
+* tears down the renderer and resolves the run promise (used by Ctrl-C and
+* the quit-confirm path in browse mode).
+*/
+function createOnKey(ctx, cleanup) {
+	return (key) => {
+		if (ctx.state.helpOpen) return handleHelpKey(ctx, key);
+		if (ctx.state.mode === "prompt") return handlePromptKey(ctx, key);
+		if (ctx.state.mode === "filter") return handleFilterKey(ctx, key);
+		handleBrowseKey(ctx, key, cleanup);
+	};
+}
+//#endregion
+//#region src/tui/render/layout.ts
+/**
+* Build the static element tree once and return stable handles. Content is
+* (re)populated later by the refreshers; this only establishes the layout
+* skeleton and parent/child wiring.
+*/
+function buildLayout(renderer, theme, layout) {
+	const root = new BoxRenderable(renderer, {
+		id: "root",
+		flexDirection: "column",
+		width: "100%",
+		height: "100%"
+	});
+	renderer.root.add(root);
+	const body = new BoxRenderable(renderer, {
+		id: "body",
+		flexDirection: "row",
+		flexGrow: 1
+	});
+	root.add(body);
+	const sidebar = new BoxRenderable(renderer, {
+		id: "sidebar",
+		border: true,
+		borderStyle: "rounded",
+		title: "",
+		flexDirection: "column",
+		width: layout.SIDEBAR_WIDTH,
+		flexShrink: 0,
+		paddingX: 1
+	});
+	body.add(sidebar);
+	const matrixBox = new BoxRenderable(renderer, {
+		id: "matrix",
+		border: true,
+		borderStyle: "rounded",
+		title: "",
+		flexDirection: "column",
+		flexGrow: 1,
+		paddingX: 1,
+		paddingBottom: 1
+	});
+	body.add(matrixBox);
+	const headerHost = new BoxRenderable(renderer, {
+		id: "header-host",
+		flexDirection: "column",
+		flexShrink: 0,
+		paddingRight: 1
+	});
+	matrixBox.add(headerHost);
+	const scrollBox = new ScrollBoxRenderable(renderer, {
+		id: "matrix-scroll",
+		flexGrow: 1,
+		scrollX: true,
+		scrollY: true,
+		viewportOptions: {
+			paddingRight: 1,
+			paddingBottom: 1
+		},
+		contentOptions: {
+			flexDirection: "column",
+			rowGap: layout.ROW_GAP
+		}
+	});
+	matrixBox.add(scrollBox);
+	const footer = new BoxRenderable(renderer, {
+		id: "footer",
+		flexDirection: "column",
+		flexShrink: 0,
+		paddingX: 1
+	});
+	root.add(footer);
+	const hintA = new BoxRenderable(renderer, {
+		id: "hint-a",
+		flexDirection: "row",
+		height: 1,
+		flexShrink: 0
+	});
+	footer.add(hintA);
+	const hintB = new BoxRenderable(renderer, {
+		id: "hint-b",
+		flexDirection: "row",
+		height: 1,
+		flexShrink: 0
+	});
+	footer.add(hintB);
+	const status = new TextRenderable(renderer, {
+		id: "status",
+		content: "",
+		fg: theme.fgDim,
+		wrapMode: "none",
+		height: 1
+	});
+	footer.add(status);
+	const filterBox = new BoxRenderable(renderer, {
+		id: "filter-box",
+		position: "absolute",
+		top: "15%",
+		left: "20%",
+		right: "20%",
+		height: "auto",
+		zIndex: 60,
+		border: true,
+		borderStyle: "rounded",
+		title: " Filter keys ",
+		paddingX: 2,
+		paddingY: 1,
+		visible: false,
+		backgroundColor: RGBA.fromHex("#1a1a1a"),
+		flexDirection: "column"
+	});
+	const filterField = new TextRenderable(renderer, {
+		id: "filter-field",
+		content: "",
+		fg: theme.fg,
+		height: 1,
+		wrapMode: "none"
+	});
+	const filterStatus = new TextRenderable(renderer, {
+		id: "filter-status",
+		content: "",
+		fg: theme.fgDim,
+		height: 1,
+		marginTop: 1,
+		wrapMode: "none"
+	});
+	const filterHint = new TextRenderable(renderer, {
+		id: "filter-hint",
+		content: "Enter · keep filter    Esc · clear & close",
+		fg: theme.fg,
+		height: 1,
+		marginTop: 1,
+		wrapMode: "none"
+	});
+	filterBox.add(filterField);
+	filterBox.add(filterStatus);
+	filterBox.add(filterHint);
+	renderer.root.add(filterBox);
+	const promptBox = new BoxRenderable(renderer, {
+		id: "prompt-box",
+		position: "absolute",
+		top: "20%",
+		left: "15%",
+		right: "15%",
+		height: "auto",
+		zIndex: 50,
+		border: true,
+		borderStyle: "rounded",
+		title: "",
+		paddingX: 2,
+		paddingY: 1,
+		visible: false,
+		backgroundColor: RGBA.fromHex("#1a1a1a"),
+		flexDirection: "column"
+	});
+	const promptBody = new BoxRenderable(renderer, {
+		id: "prompt-body",
+		flexDirection: "column",
+		flexGrow: 1
+	});
+	const promptHint = new TextRenderable(renderer, {
+		id: "prompt-hint",
+		content: "",
+		fg: theme.fg,
+		height: 1,
+		marginTop: 2,
+		wrapMode: "none"
+	});
+	promptBox.add(promptBody);
+	promptBox.add(promptHint);
+	renderer.root.add(promptBox);
+	const dimOverlay = new BoxRenderable(renderer, {
+		id: "dim-overlay",
+		position: "absolute",
+		top: 0,
+		left: 0,
+		right: 0,
+		bottom: 0,
+		zIndex: 40,
+		backgroundColor: RGBA.fromHex("#000000"),
+		opacity: .6,
+		visible: false
+	});
+	renderer.root.add(dimOverlay);
+	const helpBox = new BoxRenderable(renderer, {
+		id: "help-overlay",
+		position: "absolute",
+		top: 2,
+		bottom: 2,
+		left: "8%",
+		right: "8%",
+		zIndex: 100,
+		border: true,
+		borderStyle: "rounded",
+		title: " Keybindings — press ? or Esc to close ",
+		paddingX: 2,
+		paddingY: 1,
+		visible: false,
+		backgroundColor: RGBA.fromHex("#1a1a1a"),
+		flexDirection: "column"
+	});
+	renderer.root.add(helpBox);
+	return {
+		root,
+		body,
+		sidebar,
+		matrixBox,
+		headerHost,
+		scrollBox,
+		footer,
+		hintA,
+		hintB,
+		status,
+		filterBox,
+		filterField,
+		filterStatus,
+		promptBox,
+		promptBody,
+		promptHint,
+		helpBox,
+		dimOverlay
+	};
+}
+//#endregion
+//#region src/tui/render/filter.ts
+function refreshFilter(ctx) {
+	const { el: { filterBox, filterField, filterStatus }, matrix, state } = ctx;
+	const open = state.mode === "filter";
+	filterBox.visible = open;
+	if (!open) return;
+	filterField.content = `▸ ${state.filter}▏`;
+	const matches = state.visibleKeys.length;
+	const total = matrix.keys.length;
+	filterStatus.content = state.filter.length === 0 ? "Type to filter the keys list." : `Matching ${matches} of ${total} keys.`;
+}
+//#endregion
+//#region src/tui/render/dom.ts
+function removeAllChildren(node) {
+	const children = [...node.getChildren()];
+	for (const child of children) node.remove(child);
+}
+//#endregion
+//#region src/tui/render/footer.ts
+function bindings(specs, theme) {
+	const out = [];
+	specs.forEach((spec, i) => {
+		if (i > 0) out.push({
+			text: " · ",
+			fg: theme.fgDim
+		});
+		out.push({
+			text: "[",
+			fg: theme.fgDim
+		});
+		out.push({
+			text: spec.key,
+			fg: theme.fg
+		});
+		out.push({
+			text: "] ",
+			fg: theme.fgDim
+		});
+		out.push({
+			text: spec.label,
+			fg: theme.fg
+		});
+	});
+	return out;
+}
+function renderHintBox(box, renderer, segs) {
+	removeAllChildren(box);
+	segs.forEach((seg, i) => {
+		box.add(new TextRenderable(renderer, {
+			id: `${box.id}-seg-${i}`,
+			content: seg.text,
+			fg: seg.fg,
+			height: 1,
+			wrapMode: "none"
+		}));
+	});
+}
+function refreshFooter(ctx) {
+	const { el: { hintA, hintB, status }, renderer, state, theme } = ctx;
+	const dirty = state.dirty.size;
+	const dirtyTail = dirty > 0 ? [
+		{
+			text: "   ",
+			fg: theme.fgDim
+		},
+		{
+			text: "●",
+			fg: theme.modified
+		},
+		{
+			text: ` ${dirty} unsaved`,
+			fg: theme.fg
+		}
+	] : [];
+	if (state.mode === "filter") {
+		renderHintBox(hintA, renderer, [...bindings([{
+			key: "Enter",
+			label: "keep filter"
+		}, {
+			key: "Esc",
+			label: "clear"
+		}], theme), ...dirtyTail]);
+		renderHintBox(hintB, renderer, [{
+			text: " Filter:",
+			fg: theme.fgDim
+		}]);
+	} else if (state.mode === "prompt") {
+		renderHintBox(hintA, renderer, []);
+		renderHintBox(hintB, renderer, []);
+	} else if (state.pane === "sidebar") {
+		renderHintBox(hintA, renderer, [...bindings([
+			{
+				key: "↑↓",
+				label: "move"
+			},
+			{
+				key: "Space",
+				label: "toggle"
+			},
+			{
+				key: "b",
+				label: "set base"
+			},
+			{
+				key: "Tab/→",
+				label: "matrix"
+			},
+			{
+				key: "^S",
+				label: "save"
+			},
+			{
+				key: "?",
+				label: "help"
+			},
+			{
+				key: "q",
+				label: "quit"
+			}
+		], theme), ...dirtyTail]);
+		renderHintBox(hintB, renderer, [{
+			text: "Files pane",
+			fg: theme.fgDim
+		}]);
+	} else {
+		renderHintBox(hintA, renderer, [...bindings([
+			{
+				key: "↑↓←→",
+				label: "move"
+			},
+			{
+				key: "Tab",
+				label: "files"
+			},
+			{
+				key: "e",
+				label: "edit"
+			},
+			{
+				key: "a",
+				label: "add var"
+			},
+			{
+				key: "d",
+				label: "del var"
+			},
+			{
+				key: "n",
+				label: "new file"
+			},
+			{
+				key: "=",
+				label: "sync to all"
+			},
+			{
+				key: "c",
+				label: "collapse"
+			},
+			{
+				key: "^T",
+				label: "secrets"
+			},
+			{
+				key: "^Z",
+				label: "undo"
+			},
+			{
+				key: "^S",
+				label: "save"
+			},
+			{
+				key: "/",
+				label: "filter"
+			},
+			{
+				key: "?/ß",
+				label: "help"
+			},
+			{
+				key: "q",
+				label: "quit"
+			}
+		], theme), ...dirtyTail]);
+		renderHintBox(hintB, renderer, [
+			{
+				text: "view: ",
+				fg: theme.fgDim
+			},
+			{
+				text: state.driftOnly ? "drift" : "all",
+				fg: theme.fg
+			},
+			{
+				text: "  ·  group: ",
+				fg: theme.fgDim
+			},
+			{
+				text: state.grouping,
+				fg: theme.fg
+			},
+			{
+				text: "  ·  secrets: ",
+				fg: theme.fgDim
+			},
+			{
+				text: state.showSecrets ? "shown" : "masked",
+				fg: theme.fg
+			}
+		]);
+	}
+	status.content = state.message ?? "";
+}
+//#endregion
+//#region src/tui/help.ts
+function buildHelpLines() {
+	return [
+		{
+			kind: "header",
+			text: "Panes"
+		},
+		{
+			kind: "entry",
+			text: "  Tab               Switch matrix ↔ files sidebar"
+		},
+		{
+			kind: "entry",
+			text: "  ← (leftmost col)  Hop from matrix into the sidebar"
+		},
+		{ kind: "blank" },
+		{
+			kind: "header",
+			text: "Matrix navigation"
+		},
+		{
+			kind: "entry",
+			text: "  ↑ ↓ ← →           Move focused cell"
+		},
+		{
+			kind: "entry",
+			text: "  Mouse wheel       Scroll (both axes)"
+		},
+		{ kind: "blank" },
+		{
+			kind: "header",
+			text: "Files sidebar"
+		},
+		{
+			kind: "entry",
+			text: "  ↑ ↓               Move selection"
+		},
+		{
+			kind: "entry",
+			text: "  Space             Enable / disable file"
+		},
+		{
+			kind: "entry",
+			text: "  b                 Make selected file the base"
+		},
+		{
+			kind: "entry",
+			text: "  Tab / →           Back to matrix"
+		},
+		{ kind: "blank" },
+		{
+			kind: "header",
+			text: "Editing"
+		},
+		{
+			kind: "entry",
+			text: "  e / Enter         Edit focused cell value"
+		},
+		{
+			kind: "entry",
+			text: "  a                 Add a new variable here"
+		},
+		{
+			kind: "entry",
+			text: "  d                 Delete the variable from this file"
+		},
+		{
+			kind: "entry",
+			text: "  n                 Create a new .env* file"
+		},
+		{
+			kind: "entry",
+			text: "  =                 Sync focused value to every file"
+		},
+		{
+			kind: "entry",
+			text: "  Ctrl-A (in edit)  Apply typed value to every file"
+		},
+		{
+			kind: "entry",
+			text: "  Ctrl-Z            Undo last edit/add/delete"
+		},
+		{
+			kind: "entry",
+			text: "  Ctrl-S            Write all dirty files"
+		},
+		{
+			kind: "entry",
+			text: "  c                 Collapse / expand focused section"
+		},
+		{
+			kind: "entry",
+			text: "  Shift-C           Expand every collapsed section"
+		},
+		{ kind: "blank" },
+		{
+			kind: "header",
+			text: "View"
+		},
+		{
+			kind: "entry",
+			text: "  /                 Filter keys"
+		},
+		{
+			kind: "entry",
+			text: "  v                 All keys ↔ drift-only"
+		},
+		{
+			kind: "entry",
+			text: "  g                 Group by prefix ↔ banner"
+		},
+		{
+			kind: "entry",
+			text: "  Ctrl-T            Show / mask secret values"
+		},
+		{ kind: "blank" },
+		{
+			kind: "header",
+			text: "Help & exit"
+		},
+		{
+			kind: "entry",
+			text: "  ? / ß             Toggle this overlay"
+		},
+		{
+			kind: "entry",
+			text: "  q                 Quit (twice if dirty)"
+		},
+		{
+			kind: "entry",
+			text: "  Ctrl-C            Force quit"
+		},
+		{ kind: "blank" },
+		{
+			kind: "header",
+			text: "Cell icons"
+		},
+		{
+			kind: "legend",
+			symbol: "≠ value",
+			color: RGBA.fromHex("#ffd866"),
+			description: "value differs from base"
+		},
+		{
+			kind: "legend",
+			symbol: "✗ missing",
+			color: RGBA.fromHex("#ff6b6b"),
+			description: "this file has no value for the key"
+		},
+		{
+			kind: "legend",
+			symbol: "★ value",
+			color: RGBA.fromHex("#ffd866"),
+			description: "key is not in the base"
+		},
+		{
+			kind: "legend",
+			symbol: "•••• (N)",
+			color: RGBA.fromHex("#cccccc"),
+			description: "secret-suspect value masked by length"
+		},
+		{
+			kind: "legend",
+			symbol: "⚠ TODO",
+			color: RGBA.fromHex("#ffd866"),
+			description: "placeholder value (TODO, CHANGEME, xxx, …)"
+		},
+		{
+			kind: "legend",
+			symbol: "value ●",
+			color: RGBA.fromHex("#7fce6a"),
+			description: "modified in this session — Ctrl-S to persist"
+		}
+	];
+}
+//#endregion
+//#region src/tui/render/builders.ts
+function buildValueCell(cell, secret, width, focused, modified, theme, isPlaceholder) {
+	const bg = focused ? theme.focusBg : void 0;
+	const trailing = modified ? {
+		char: "●",
+		fg: theme.modified
+	} : void 0;
+	if (cell.state === "missing") return {
+		text: "missing",
+		fg: theme.fgDim,
+		width,
+		bg,
+		icon: {
+			char: "✗",
+			fg: theme.missing
+		},
+		trailing
+	};
+	const value = cell.value ?? "";
+	if (value !== "" && isPlaceholder(value)) return {
+		text: value,
+		fg: theme.fg,
+		width,
+		bg,
+		icon: {
+			char: "⚠",
+			fg: theme.placeholder
+		},
+		trailing
+	};
+	const isEmpty = value === "" && !secret;
+	const displayText = isEmpty ? "(empty)" : formatValue(value, secret);
+	const displayFg = isEmpty ? theme.fgDim : theme.fg;
+	if (cell.state === "differs") return {
+		text: displayText,
+		fg: displayFg,
+		width,
+		bg,
+		icon: {
+			char: "≠",
+			fg: theme.differs
+		},
+		trailing
+	};
+	if (cell.state === "extra") return {
+		text: displayText,
+		fg: displayFg,
+		width,
+		bg,
+		icon: {
+			char: "★",
+			fg: theme.extra
+		},
+		trailing
+	};
+	return {
+		text: displayText,
+		fg: displayFg,
+		width,
+		bg,
+		trailing
+	};
+}
+function buildHelpRow(renderer, id, line, theme) {
+	const row = new BoxRenderable(renderer, {
+		id,
+		flexDirection: "row",
+		height: 1,
+		flexShrink: 0
+	});
+	if (line.kind === "header") row.add(new TextRenderable(renderer, {
+		id: `${id}-t`,
+		content: line.text,
+		fg: theme.fgSection,
+		wrapMode: "none",
+		height: 1
+	}));
+	else if (line.kind === "entry") row.add(new TextRenderable(renderer, {
+		id: `${id}-t`,
+		content: line.text,
+		fg: theme.fg,
+		wrapMode: "none",
+		height: 1
+	}));
+	else if (line.kind === "legend") {
+		row.add(new TextRenderable(renderer, {
+			id: `${id}-sym`,
+			content: `  ${line.symbol.padEnd(12)}`,
+			fg: line.color,
+			wrapMode: "none",
+			height: 1
+		}));
+		row.add(new TextRenderable(renderer, {
+			id: `${id}-desc`,
+			content: line.description,
+			fg: theme.fgDim,
+			wrapMode: "none",
+			height: 1
+		}));
+	}
+	return row;
+}
+function buildSectionDivider(renderer, id, name, width, meta, theme) {
+	const baseName = name ?? "(other)";
+	const segs = [
+		{
+			text: ` ${meta.collapsed ? "▸" : "▾"} `,
+			fg: theme.fgDim
+		},
+		{
+			text: baseName,
+			fg: theme.fg
+		},
+		{
+			text: "  ",
+			fg: theme.fgDim
+		}
+	];
+	if (meta.missing > 0) {
+		segs.push({
+			text: "✗ ",
+			fg: theme.missing
+		});
+		segs.push({
+			text: `${meta.missing}`,
+			fg: theme.missing
+		});
+		segs.push({
+			text: " missing  ",
+			fg: theme.fg
+		});
+	}
+	if (meta.drift > 0) {
+		segs.push({
+			text: "≠ ",
+			fg: theme.differs
+		});
+		segs.push({
+			text: `${meta.drift}`,
+			fg: theme.differs
+		});
+		segs.push({
+			text: "/",
+			fg: theme.fgDim
+		});
+		segs.push({
+			text: `${meta.total}`,
+			fg: theme.differs
+		});
+		segs.push({
+			text: " drift  ",
+			fg: theme.fg
+		});
+	}
+	if (meta.missing === 0 && meta.drift === 0) {
+		segs.push({
+			text: `${meta.total}`,
+			fg: theme.fgDim
+		});
+		segs.push({
+			text: " keys  ",
+			fg: theme.fg
+		});
+	}
+	segs.push({
+		text: " ",
+		fg: theme.fgDim
+	});
+	const labelLength = segs.reduce((sum, s) => sum + s.text.length, 0);
+	const rule = "─";
+	const visible = Math.max(0, width - 2);
+	const beforeLen = Math.max(2, Math.floor((visible - labelLength) / 2));
+	const afterLen = Math.max(0, visible - beforeLen - labelLength);
+	const box = new BoxRenderable(renderer, {
+		id,
+		flexDirection: "row",
+		flexShrink: 0,
+		height: 1,
+		paddingX: 1,
+		...meta.focused ? { backgroundColor: theme.focusBg } : {}
+	});
+	box.add(new TextRenderable(renderer, {
+		id: `${id}-lead`,
+		content: rule.repeat(beforeLen),
+		fg: theme.fgDim,
+		height: 1,
+		wrapMode: "none"
+	}));
+	segs.forEach((seg, i) => {
+		box.add(new TextRenderable(renderer, {
+			id: `${id}-seg-${i}`,
+			content: seg.text,
+			fg: seg.fg,
+			height: 1,
+			wrapMode: "none"
+		}));
+	});
+	box.add(new TextRenderable(renderer, {
+		id: `${id}-trail`,
+		content: rule.repeat(afterLen),
+		fg: theme.fgDim,
+		height: 1,
+		wrapMode: "none"
+	}));
+	return box;
+}
+function buildRow(renderer, idPrefix, cells, padX) {
+	const row = new BoxRenderable(renderer, {
+		id: idPrefix,
+		flexDirection: "row",
+		flexShrink: 0,
+		height: 1
+	});
+	cells.forEach((cell, i) => {
+		const cellOpts = {
+			id: `${idPrefix}-c${i}`,
+			width: cell.width,
+			height: 1,
+			flexDirection: "row",
+			flexShrink: 0,
+			paddingX: padX
+		};
+		if (cell.bg) cellOpts.backgroundColor = cell.bg;
+		const cellBox = new BoxRenderable(renderer, cellOpts);
+		const innerWidth = Math.max(0, cell.width - padX * 2);
+		const iconLen = cell.icon ? cell.icon.char.length + 1 : 0;
+		const trailingLen = cell.trailing ? cell.trailing.char.length + 1 : 0;
+		const textWidth = Math.max(0, innerWidth - iconLen - trailingLen);
+		if (cell.icon) cellBox.add(new TextRenderable(renderer, {
+			id: `${idPrefix}-c${i}-icon`,
+			content: `${cell.icon.char} `,
+			fg: cell.icon.fg,
+			height: 1,
+			wrapMode: "none"
+		}));
+		cellBox.add(new TextRenderable(renderer, {
+			id: `${idPrefix}-c${i}-t`,
+			content: truncate(cell.text, textWidth),
+			fg: cell.fg,
+			height: 1,
+			flexGrow: 1,
+			wrapMode: "none"
+		}));
+		if (cell.trailing) cellBox.add(new TextRenderable(renderer, {
+			id: `${idPrefix}-c${i}-trail`,
+			content: ` ${cell.trailing.char}`,
+			fg: cell.trailing.fg,
+			height: 1,
+			wrapMode: "none"
+		}));
+		row.add(cellBox);
+	});
+	return row;
+}
+//#endregion
+//#region src/tui/render/help.ts
+function refreshHelp(ctx) {
+	const { el: { helpBox }, renderer, state, theme } = ctx;
+	helpBox.visible = state.helpOpen;
+	if (!state.helpOpen) return;
+	removeAllChildren(helpBox);
+	const lines = buildHelpLines();
+	const narrow = renderer.terminalWidth < 100;
+	const short = renderer.terminalHeight < 36;
+	if (narrow || short) {
+		const scroll = new ScrollBoxRenderable(renderer, {
+			id: "help-scroll",
+			flexGrow: 1,
+			scrollX: false,
+			scrollY: true,
+			viewportOptions: { paddingRight: 1 },
+			contentOptions: { flexDirection: "column" }
+		});
+		helpBox.add(scroll);
+		lines.forEach((line, i) => {
+			scroll.content.add(buildHelpRow(renderer, `help-${i}`, line, theme));
+		});
+		return;
+	}
+	const grid = new BoxRenderable(renderer, {
+		id: "help-grid",
+		flexDirection: "row",
+		flexGrow: 1,
+		columnGap: 3
+	});
+	const left = new BoxRenderable(renderer, {
+		id: "help-left",
+		flexDirection: "column",
+		flexGrow: 1,
+		flexBasis: 0
+	});
+	const right = new BoxRenderable(renderer, {
+		id: "help-right",
+		flexDirection: "column",
+		flexGrow: 1,
+		flexBasis: 0
+	});
+	const half = Math.floor(lines.length / 2);
+	let splitIdx = half;
+	for (let i = half; i < lines.length; i++) if (lines[i]?.kind === "blank") {
+		splitIdx = i + 1;
+		break;
+	}
+	lines.slice(0, splitIdx).forEach((line, i) => left.add(buildHelpRow(renderer, `help-l-${i}`, line, theme)));
+	lines.slice(splitIdx).forEach((line, i) => right.add(buildHelpRow(renderer, `help-r-${i}`, line, theme)));
+	grid.add(left);
+	grid.add(right);
+	helpBox.add(grid);
+}
+//#endregion
+//#region src/tui/render/matrix.ts
+function matrixTitle(matrix, state) {
+	const visible = state.visibleKeys.length;
+	const total = matrix.keys.length;
+	const parts = [`${total} keys`];
+	if (state.driftOnly) parts.push(`drift ${visible}/${total}`);
+	else if (state.filter && visible !== total) parts.push(`"${state.filter}" ${visible}/${total}`);
+	return ` Matrix · ${parts.join(" · ")} `;
+}
+/**
+* Available width inside the matrix box (subtract sidebar, both borders and the
+* matrix's horizontal padding). If columns would shrink below VALUE_COL_MIN to
+* fit, keep them at the minimum and let the ScrollBox handle the overflow.
+*/
+function computeValueColWidth(ctx) {
+	const { renderer, matrix, layout } = ctx;
+	const available = Math.max(0, renderer.terminalWidth - layout.SIDEBAR_WIDTH - 6 - layout.KEY_COL_WIDTH);
+	const fair = matrix.files.length ? Math.floor(available / matrix.files.length) : layout.VALUE_COL_MIN;
+	return Math.max(layout.VALUE_COL_MIN, fair);
+}
+function refreshMatrix(ctx) {
+	const { el: { matrixBox, headerHost, scrollBox }, renderer, matrix, state, theme, layout, heuristics } = ctx;
+	const sectionOf = ctx.sectionOf;
+	const valueColWidth = computeValueColWidth(ctx);
+	matrixBox.title = matrixTitle(matrix, state);
+	removeAllChildren(headerHost);
+	removeAllChildren(scrollBox.content);
+	headerHost.add(buildRow(renderer, "header", [{
+		text: "KEY",
+		fg: theme.fgHeader,
+		width: layout.KEY_COL_WIDTH
+	}, ...matrix.files.map((f) => ({
+		text: basename(f.path),
+		fg: theme.fgHeader,
+		width: valueColWidth
+	}))], layout.CELL_PAD_X));
+	const totalWidth = layout.KEY_COL_WIDTH + valueColWidth * matrix.files.length;
+	const sectionStats = sectionMetadata(matrix, sectionOf, state);
+	for (let r = 0; r < state.visibleItems.length; r++) {
+		const item = state.visibleItems[r];
+		if (item.kind === "divider") {
+			const sectionKey = item.ref;
+			const sectionName = sectionKey === "__other__" ? void 0 : sectionKey;
+			const meta = sectionStats.get(sectionKey) ?? {
+				drift: 0,
+				missing: 0,
+				total: 0
+			};
+			const focused = state.mode === "browse" && r === state.rowIdx;
+			scrollBox.content.add(buildSectionDivider(renderer, `row-${r}`, sectionName, totalWidth, {
+				...meta,
+				collapsed: state.collapsed.has(sectionKey),
+				focused
+			}, theme));
+			continue;
+		}
+		const key = item.ref;
+		const secret = heuristics.isSecretKey(key) && !state.showSecrets;
+		const cells = [{
+			text: key,
+			fg: theme.fg,
+			width: layout.KEY_COL_WIDTH
+		}];
+		for (let c = 0; c < matrix.files.length; c++) {
+			const file = matrix.files[c];
+			const cell = matrix.cell(key, file);
+			const focused = state.mode === "browse" && r === state.rowIdx && c === state.colIdx;
+			const isModified = state.modified.has(`${key}|${file.path}`);
+			cells.push(buildValueCell(cell, secret, valueColWidth, focused, isModified, theme, heuristics.isPlaceholderValue));
+		}
+		scrollBox.content.add(buildRow(renderer, `row-${r}`, cells, layout.CELL_PAD_X));
+	}
+	if (state.mode === "browse" && state.visibleItems.length > 0) {
+		const target = `row-${state.rowIdx}`;
+		setImmediate(() => {
+			try {
+				scrollBox.scrollChildIntoView(target);
+			} catch {}
+		});
+	}
+}
+//#endregion
+//#region src/tui/render/prompt.ts
+function promptLabelText(p) {
+	switch (p.kind) {
+		case "edit": return ` Edit ${p.key} in ${basename(p.file.path)}:`;
+		case "add-key": return ` Add new key to ${basename(p.file.path)}:`;
+		case "add-value": return ` Value for ${p.key} in ${basename(p.file.path)}:`;
+		case "new-file": return " New env file name (e.g. .env.local):";
+	}
+}
+function refreshPrompt(ctx) {
+	const { el: { promptBox, promptBody, promptHint }, renderer, matrix, state, theme, heuristics } = ctx;
+	const open = state.mode === "prompt" && state.prompt !== null;
+	promptBox.visible = open;
+	if (!open || !state.prompt) return;
+	promptBox.title = promptLabelText(state.prompt);
+	const p = state.prompt;
+	if (p.kind === "edit" || p.kind === "add-value") promptHint.content = "Enter · confirm    Ctrl-A · apply to all    Ctrl-T · show/mask secrets    Esc · cancel";
+	else promptHint.content = "Enter · confirm    Esc · cancel";
+	removeAllChildren(promptBody);
+	promptBody.add(new TextRenderable(renderer, {
+		id: "prompt-input-text",
+		content: `▸ ${state.promptInput}▏`,
+		fg: theme.fg,
+		height: 1,
+		wrapMode: "none"
+	}));
+	if (state.message) promptBody.add(new TextRenderable(renderer, {
+		id: "prompt-error",
+		content: `! ${state.message}`,
+		fg: theme.missing,
+		height: 1,
+		marginTop: 1,
+		wrapMode: "none"
+	}));
+	if (p.kind === "edit" || p.kind === "add-value") {
+		const secret = heuristics.isSecretKey(p.key) && !state.showSecrets;
+		const nameWidth = Math.min(26, Math.max(...matrix.files.map((f) => basename(f.path).length + 2)));
+		promptBody.add(new TextRenderable(renderer, {
+			id: "prompt-table-header",
+			content: "Current values",
+			fg: theme.fgSection,
+			wrapMode: "none",
+			height: 1,
+			marginTop: 1
+		}));
+		for (const file of matrix.files) {
+			const isTarget = file === p.file;
+			const row = new BoxRenderable(renderer, {
+				id: `prompt-row-${file.path}`,
+				flexDirection: "row",
+				height: 1,
+				flexShrink: 0
+			});
+			row.add(new TextRenderable(renderer, {
+				id: `prompt-row-${file.path}-name`,
+				content: `${isTarget ? "▸" : " "} ${basename(file.path)}`.padEnd(nameWidth),
+				fg: isTarget ? theme.fgBase : theme.fgDim,
+				height: 1,
+				wrapMode: "none"
+			}));
+			const entry = findKvEntry(file, p.key);
+			const current = entry ? formatValue(entry.value, secret) : "✗ missing";
+			row.add(new TextRenderable(renderer, {
+				id: `prompt-row-${file.path}-value`,
+				content: current,
+				fg: !entry ? theme.missing : isTarget ? theme.fg : theme.fgDim,
+				height: 1,
+				wrapMode: "none"
+			}));
+			promptBody.add(row);
+		}
+	}
+}
+//#endregion
+//#region src/tui/render/sidebar.ts
+function refreshSidebar(ctx) {
+	const { el: { sidebar }, renderer, matrix, allFiles, state, theme } = ctx;
+	const total = allFiles.length;
+	const enabled = state.enabled.size;
+	sidebar.title = state.pane === "sidebar" ? ` Files ${enabled}/${total} • focused ` : ` Files ${enabled}/${total} `;
+	removeAllChildren(sidebar);
+	for (let i = 0; i < allFiles.length; i++) {
+		const file = allFiles[i];
+		const isBase = file === matrix.base;
+		const isDirty = state.dirty.has(file);
+		const isEnabled = state.enabled.has(file);
+		const matrixIdx = matrix.files.indexOf(file);
+		const isFocusCol = isEnabled && matrixIdx === state.colIdx;
+		const isPaneFocus = state.pane === "sidebar" && i === state.sidebarIdx;
+		const nameFg = !isEnabled ? theme.fgDim : isBase ? theme.fgBase : theme.fg;
+		const row = new BoxRenderable(renderer, {
+			id: `file-${file.path}`,
+			flexDirection: "row",
+			height: 1,
+			flexShrink: 0,
+			...isPaneFocus ? { backgroundColor: theme.focusBg } : {}
+		});
+		const span = (id, text, fg) => new TextRenderable(renderer, {
+			id: `${row.id}-${id}`,
+			content: text,
+			fg,
+			height: 1,
+			wrapMode: "none"
+		});
+		row.add(span("focus", `${isPaneFocus ? "▶" : " "} `, theme.fg));
+		row.add(span("dirty", `${isDirty ? "●" : " "} `, isDirty ? theme.fgDirty : theme.fgDim));
+		row.add(span("base", `${isBase ? "★" : " "} `, isBase ? theme.fgBase : theme.fgDim));
+		row.add(span("col", `${isFocusCol ? "▸" : " "} `, theme.fgDim));
+		row.add(span("enabled", `${isEnabled ? "✓" : "☐"} `, theme.fgDim));
+		row.add(span("name", basename(file.path), nameFg));
+		sidebar.add(row);
+	}
+}
+//#endregion
+//#region src/tui/render/index.ts
+/**
+* Full synchronous render of every region. Reads `ctx.matrix` fresh so a
+* `rebuildMatrix` that ran between scheduling and this flush is reflected.
+*/
+function refreshAll(ctx) {
+	const { state } = ctx;
+	refreshSidebar(ctx);
+	refreshMatrix(ctx);
+	refreshFooter(ctx);
+	refreshPrompt(ctx);
+	refreshHelp(ctx);
+	refreshFilter(ctx);
+	ctx.el.dimOverlay.visible = state.helpOpen || state.mode === "prompt" || state.mode === "filter";
+}
+//#endregion
+//#region src/tui/theme.ts
+/** Resolve a partial hex theme into RGBA values (gaps + invalid → defaults). */
+function resolveTheme(theme = {}, warn) {
+	const hex = resolveThemeHex(theme, warn);
+	const out = {};
+	for (const key of Object.keys(DEFAULT_THEME_HEX)) out[key] = RGBA.fromHex(hex[key]);
+	return out;
+}
+resolveTheme();
+function resolveLayout(layout) {
+	return {
+		KEY_COL_WIDTH: layout.keyColWidth,
+		VALUE_COL_MIN: layout.valueColMin,
+		SIDEBAR_WIDTH: layout.sidebarWidth,
+		ROW_GAP: layout.rowGap,
+		CELL_PAD_X: layout.cellPadX
+	};
+}
+//#endregion
+//#region src/tui/app.ts
+async function runMatrixTui(initialMatrix, config = DEFAULT_CONFIG) {
+	const renderer = await createCliRenderer({ useMouse: true });
+	const theme = resolveTheme(config.tui.theme);
+	const layout = resolveLayout(config.tui.layout);
+	const heuristics = resolveHeuristics(config);
+	const allFiles = initialMatrix.files.slice();
+	const hasBanners = initialMatrix.keys.some((k) => initialMatrix.sectionOf(k) !== void 0);
+	const grouping = heuristics.grouping === "auto" ? hasBanners ? "banner" : "prefix" : heuristics.grouping;
+	const state = {
+		mode: "browse",
+		filter: "",
+		rowIdx: 0,
+		colIdx: 0,
+		prompt: null,
+		dirty: /* @__PURE__ */ new Set(),
+		visibleKeys: initialMatrix.keys.slice(),
+		visibleItems: [],
+		message: null,
+		driftOnly: false,
+		confirmQuit: false,
+		grouping,
+		helpOpen: false,
+		undo: [],
+		pane: "matrix",
+		sidebarIdx: 0,
+		enabled: new Set(allFiles),
+		showSecrets: !config.tui.maskSecrets,
+		collapsed: /* @__PURE__ */ new Set(),
+		modified: /* @__PURE__ */ new Set(),
+		promptInput: ""
+	};
+	const el = buildLayout(renderer, theme, layout);
+	let refreshScheduled = false;
+	const ctx = {
+		renderer,
+		state,
+		allFiles,
+		el,
+		config,
+		theme,
+		layout,
+		heuristics,
+		matrix: initialMatrix,
+		currentBase: initialMatrix.base,
+		refresh: () => {
+			if (refreshScheduled) return;
+			refreshScheduled = true;
+			queueMicrotask(() => {
+				refreshScheduled = false;
+				refreshAll(ctx);
+			});
+		},
+		refreshNow: () => refreshAll(ctx),
+		sectionOf: (key) => state.grouping === "banner" ? ctx.matrix.sectionOf(key) : prefixSection(key)
+	};
+	recomputeVisibleKeys(ctx);
+	ctx.refreshNow();
+	return new Promise((resolve) => {
+		const cleanup = () => {
+			renderer._internalKeyInput.offInternal("keypress", onKey);
+			renderer.destroy?.();
+			resolve();
+		};
+		const onKey = createOnKey(ctx, cleanup);
+		renderer._internalKeyInput.onInternal("keypress", onKey);
+		renderer.on("resize", ctx.refresh);
+	});
+}
+//#endregion
+export { runMatrixTui };
+
+//# sourceMappingURL=app-Bp7QXiLx.mjs.map