@bdsqqq/pi 0.0.1

package/dist/chunk-DsIazq42.js

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };

package/dist/command-palette-B97yKqne.js

@@ -0,0 +1,406 @@
+import { boxBottom, boxRow, boxTop } from "./core/box-chrome.js";
+import { CURSOR_MARKER, Key, fuzzyFilter, matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+//#region packages/extensions/command-palette/adapters.ts
+function buildModelView(pi, ctx) {
+	return {
+		title: "Select Model",
+		items: ctx.modelRegistry.getAvailable().map((model) => ({
+			id: `model:${model.provider}:${model.id}`,
+			label: model.name,
+			category: model.provider,
+			onSelect: async (actx) => {
+				if (!await actx.pi.setModel(model)) actx.ctx.ui.notify("No API key for this model", "error");
+				actx.close();
+			}
+		}))
+	};
+}
+function buildThinkingView(pi) {
+	const levels = [
+		"off",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	];
+	const current = pi.getThinkingLevel();
+	return {
+		title: "Thinking Level",
+		items: levels.map((level) => ({
+			id: `thinking:${level}`,
+			label: `${level === current ? "✓ " : "  "}${level}`,
+			category: "setting",
+			onSelect: (actx) => {
+				actx.pi.setThinkingLevel(level);
+				actx.close();
+			}
+		})),
+		searchable: false
+	};
+}
+function buildToolsView(pi) {
+	const all = pi.getAllTools();
+	const active = new Set(pi.getActiveTools());
+	return {
+		title: "Toggle Tools",
+		items: all.map((tool) => ({
+			id: `tool:${tool.name}`,
+			label: `${active.has(tool.name) ? "✓" : "○"} ${tool.name}`,
+			description: tool.description,
+			category: "tool",
+			onSelect: (actx) => {
+				const currentActive = new Set(actx.pi.getActiveTools());
+				if (currentActive.has(tool.name)) currentActive.delete(tool.name);
+				else currentActive.add(tool.name);
+				actx.pi.setActiveTools([...currentActive]);
+				actx.push(buildToolsView(actx.pi));
+			}
+		}))
+	};
+}
+function fireAndForget(id, label, description, action) {
+	return {
+		id,
+		label,
+		description,
+		category: "cmd",
+		onSelect: async (actx) => {
+			await action(actx);
+			actx.close();
+		}
+	};
+}
+function delegate(name, description) {
+	return {
+		id: `builtin:${name}`,
+		label: name,
+		description,
+		category: "cmd",
+		delegate: true,
+		onSelect: (actx) => {
+			actx.close();
+			actx.pi.sendUserMessage(`/${name}`);
+		}
+	};
+}
+function drillDown(id, label, description, viewFn) {
+	return {
+		id,
+		label,
+		description,
+		category: "cmd",
+		onSelect: (actx) => {
+			actx.push(viewFn());
+		}
+	};
+}
+function buildRootView(pi, ctx) {
+	const items = [];
+	items.push(fireAndForget("builtin:new", "new", "Start a new session", (actx) => {
+		actx.pi.sendUserMessage("/new");
+	}), fireAndForget("builtin:fork", "fork", "Fork current session", (actx) => {
+		actx.pi.sendUserMessage("/fork");
+	}), fireAndForget("builtin:copy", "copy", "Copy last message to clipboard", (actx) => {
+		actx.pi.sendUserMessage("/copy");
+	}), fireAndForget("builtin:reload", "reload", "Reload extensions, skills, prompts", (actx) => {
+		actx.pi.sendUserMessage("/reload");
+	}), fireAndForget("builtin:quit", "quit", "Quit pi", (actx) => {
+		actx.ctx.shutdown();
+	}), fireAndForget("builtin:exit", "exit", "Quit pi", (actx) => {
+		actx.ctx.shutdown();
+	}));
+	items.push(drillDown("builtin:model", "model", "Switch models", () => buildModelView(pi, ctx)), drillDown("setting:thinking", "thinking", "Set thinking level", () => buildThinkingView(pi)), drillDown("setting:tools", "tools", "Toggle active tools", () => buildToolsView(pi)));
+	items.push(delegate("name", "Set session display name"), delegate("compact", "Manually compact context"), delegate("export", "Export session to HTML file"));
+	items.push(delegate("login", "OAuth authentication"), delegate("logout", "OAuth authentication"), delegate("scoped-models", "Enable/disable models for Ctrl+P cycling"), delegate("settings", "Thinking level, theme, message delivery, transport"), delegate("resume", "Pick from previous sessions"), delegate("session", "Show session info"), delegate("tree", "Jump to any point in the session"), delegate("share", "Upload as private GitHub gist"), delegate("hotkeys", "Show all keyboard shortcuts"), delegate("changelog", "Display version history"));
+	const commands = pi.getCommands();
+	const sourceCategory = {
+		extension: "ext",
+		skill: "skill",
+		prompt: "tpl"
+	};
+	for (const cmd of commands) {
+		if (cmd.name === "palette") continue;
+		const cat = sourceCategory[cmd.source] ?? "ext";
+		items.push({
+			id: `${cmd.source}:${cmd.name}`,
+			label: cmd.name,
+			description: cmd.description,
+			category: cat,
+			onSelect: (actx) => {
+				actx.pi.sendUserMessage(`/${cmd.name}`);
+				actx.close();
+			}
+		});
+	}
+	const order = {
+		cmd: 0,
+		setting: 0,
+		ext: 1,
+		tpl: 2,
+		skill: 3
+	};
+	items.sort((a, b) => {
+		const so = (order[a.category ?? ""] ?? 99) - (order[b.category ?? ""] ?? 99);
+		if (so !== 0) return so;
+		return a.label.localeCompare(b.label);
+	});
+	return {
+		title: "Command Palette",
+		items
+	};
+}
+//#endregion
+//#region packages/extensions/command-palette/palette.ts
+const MAX_VISIBLE = 12;
+/**
+* Stack-based generic list overlay.
+* Renders whichever PaletteView sits on top of the stack.
+* Items control navigation via the PaletteActionContext passed to onSelect.
+*/
+var StackPalette = class {
+	stack;
+	searchText = "";
+	filtered;
+	highlightedIndex = 0;
+	scrollOffset = 0;
+	cachedLines;
+	cachedWidth;
+	_focused = false;
+	get focused() {
+		return this._focused;
+	}
+	set focused(value) {
+		this._focused = value;
+	}
+	constructor(initialView, theme, pi, extensionCtx, done) {
+		this.initialView = initialView;
+		this.theme = theme;
+		this.pi = pi;
+		this.extensionCtx = extensionCtx;
+		this.done = done;
+		this.stack = [initialView];
+		this.filtered = [...initialView.items];
+	}
+	handleInput(data) {
+		if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+			if (this.stack.length > 1) {
+				this.stack.pop();
+				this.resetView();
+				this.invalidate();
+			} else this.done();
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			const item = this.filtered[this.highlightedIndex];
+			if (item) {
+				const actionCtx = {
+					pi: this.pi,
+					ctx: this.extensionCtx,
+					push: (view) => {
+						this.stack.push(view);
+						this.resetView();
+						this.invalidate();
+					},
+					close: () => this.done()
+				};
+				item.onSelect(actionCtx);
+			}
+			return;
+		}
+		if (matchesKey(data, Key.up) || matchesKey(data, Key.ctrl("p"))) {
+			this.highlightedIndex = Math.max(0, this.highlightedIndex - 1);
+			this.ensureVisible();
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.down) || matchesKey(data, Key.ctrl("n"))) {
+			this.highlightedIndex = Math.min(this.filtered.length - 1, this.highlightedIndex + 1);
+			this.ensureVisible();
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.backspace)) {
+			if (this.searchText.length > 0) {
+				this.searchText = this.searchText.slice(0, -1);
+				this.applyFilter();
+				this.invalidate();
+			}
+			return;
+		}
+		if (data.length >= 1 && !data.startsWith("\x1B") && data.charCodeAt(0) >= 32) {
+			this.searchText += data;
+			this.applyFilter();
+			this.invalidate();
+		}
+	}
+	render(width) {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		const th = this.theme;
+		const view = this.currentView();
+		const innerW = Math.min(width, 72) - 2;
+		const lines = [];
+		const dim = (s) => th.fg("dim", s);
+		const pad = (s, len) => {
+			const vis = visibleWidth(s);
+			return s + " ".repeat(Math.max(0, len - vis));
+		};
+		const chrome = { dim };
+		const row = (content) => boxRow({
+			variant: "closed",
+			style: chrome,
+			inner: pad(content, innerW)
+		});
+		const showTitle = this.stack.length > 1;
+		const headerText = showTitle ? dim(`[${view.title}]`) : void 0;
+		const headerWidth = showTitle ? visibleWidth(`[${view.title}]`) : 0;
+		lines.push(boxTop({
+			variant: "closed",
+			style: chrome,
+			innerWidth: innerW,
+			header: showTitle ? {
+				text: headerText,
+				width: headerWidth
+			} : void 0
+		}));
+		if (view.searchable !== false) {
+			const prompt = dim(" > ");
+			const searchDisplay = th.fg("text", this.searchText);
+			const cursor = this._focused ? CURSOR_MARKER + th.fg("accent", "▏") : dim("▏");
+			const placeholder = this.searchText.length === 0 ? dim("type to search…") : "";
+			lines.push(row(prompt + searchDisplay + cursor + placeholder));
+			lines.push(row(""));
+		}
+		if (this.filtered.length === 0) lines.push(row(dim("  no matches")));
+		else {
+			const visibleEnd = Math.min(this.scrollOffset + MAX_VISIBLE, this.filtered.length);
+			const maxBadgeW = this.filtered.reduce((max, item) => {
+				return Math.max(max, item.category ? visibleWidth(item.category) : 0);
+			}, 0);
+			if (this.scrollOffset > 0) lines.push(row(dim(`  ↑ ${this.scrollOffset} more`)));
+			for (let i = this.scrollOffset; i < visibleEnd; i++) {
+				const item = this.filtered[i];
+				if (!item) continue;
+				const isHl = i === this.highlightedIndex;
+				let badge = "";
+				if (maxBadgeW > 0) {
+					const cat = item.category ?? "";
+					const padLen = maxBadgeW - visibleWidth(cat);
+					badge = " ".repeat(padLen) + dim(cat) + "  ";
+				}
+				const label = isHl ? th.bold(item.label) : th.fg("text", item.label);
+				const delegateMarker = item.delegate ? dim(" *") : "";
+				let desc = "";
+				if (item.description) desc = "  " + dim(item.description);
+				let shortcut = "";
+				if (item.shortcut) shortcut = "  " + th.fg("muted", item.shortcut);
+				let line = ` ${badge}${label}${delegateMarker}${desc}${shortcut}`;
+				line = truncateToWidth(line, innerW);
+				if (isHl) line = th.bg("selectedBg", pad(line, innerW));
+				lines.push(boxRow({
+					variant: "closed",
+					style: chrome,
+					inner: isHl ? line : pad(line, innerW)
+				}));
+			}
+			const remaining = this.filtered.length - visibleEnd;
+			if (remaining > 0) lines.push(row(dim(`  ↓ ${remaining} more`)));
+		}
+		const escHint = this.stack.length > 1 ? "esc back" : "esc close";
+		const hasDelegates = this.filtered.some((item) => item.delegate);
+		const footerParts = [
+			`↑↓ navigate`,
+			`enter select`,
+			escHint
+		];
+		if (hasDelegates) footerParts.push("* opens native ui");
+		const footerStr = dim(footerParts.join(" • "));
+		const footerWidth = visibleWidth(footerStr);
+		lines.push(boxBottom({
+			variant: "closed",
+			style: chrome,
+			innerWidth: innerW,
+			footer: {
+				text: footerStr,
+				width: footerWidth
+			}
+		}));
+		this.cachedLines = lines;
+		this.cachedWidth = width;
+		return lines;
+	}
+	invalidate() {
+		this.cachedLines = void 0;
+		this.cachedWidth = void 0;
+	}
+	currentView() {
+		const view = this.stack[this.stack.length - 1];
+		if (!view) throw new Error("No view in stack");
+		return view;
+	}
+	resetView() {
+		this.searchText = "";
+		this.highlightedIndex = 0;
+		this.scrollOffset = 0;
+		this.filtered = [...this.currentView().items];
+	}
+	applyFilter() {
+		const view = this.currentView();
+		if (this.searchText === "" || view.searchable === false) this.filtered = [...view.items];
+		else this.filtered = fuzzyFilter(view.items, this.searchText, (item) => `${item.label} ${item.description ?? ""} ${item.category ?? ""}`);
+		this.highlightedIndex = 0;
+		this.scrollOffset = 0;
+	}
+	ensureVisible() {
+		if (this.highlightedIndex < this.scrollOffset) this.scrollOffset = this.highlightedIndex;
+		else if (this.highlightedIndex >= this.scrollOffset + MAX_VISIBLE) this.scrollOffset = this.highlightedIndex - MAX_VISIBLE + 1;
+	}
+};
+//#endregion
+//#region packages/extensions/command-palette/index.ts
+function commandPaletteExtension(pi) {
+	async function openPalette(ctx) {
+		if (!ctx.hasUI) return;
+		const rootView = buildRootView(pi, ctx);
+		await ctx.ui.custom((tui, theme, _kb, done) => {
+			const palette = new StackPalette(rootView, theme, pi, ctx, done);
+			return {
+				render: (w) => palette.render(w),
+				handleInput: (data) => {
+					palette.handleInput(data);
+					tui.requestRender();
+				},
+				invalidate: () => palette.invalidate(),
+				get focused() {
+					return palette.focused;
+				},
+				set focused(v) {
+					palette.focused = v;
+				}
+			};
+		}, {
+			overlay: true,
+			overlayOptions: {
+				anchor: "top-center",
+				width: 72,
+				minWidth: 40,
+				maxHeight: "60%",
+				offsetY: 2
+			}
+		});
+	}
+	pi.registerShortcut("ctrl+p", {
+		description: "Open command palette",
+		handler: async (ctx) => {
+			await openPalette(ctx);
+		}
+	});
+	pi.registerCommand("palette", {
+		description: "Open command palette",
+		handler: async (_args, ctx) => {
+			await openPalette(ctx);
+		}
+	});
+}
+//#endregion
+export { commandPaletteExtension as t };

package/dist/core/agents-md.d.ts

@@ -0,0 +1,22 @@
+//#region packages/core/agents-md/index.d.ts
+interface AgentsGuidance {
+  /** absolute path to the AGENTS.md file */
+  path: string;
+  /** file contents */
+  content: string;
+  /** human-readable scope: "global", "project", or relative dir path */
+  scope: string;
+}
+/**
+* discover AGENTS.md files relevant to `filePath`, from broadest to
+* most specific scope. walks from workspace root down to the file's
+* directory, prepending the global config if it exists.
+*/
+declare function discoverAgentsMd(filePath: string, workspaceRoot: string): AgentsGuidance[];
+/**
+* format discovered guidance for injection into tool results.
+* output format: header with scope, then content.
+*/
+declare function formatGuidance(guidance: AgentsGuidance[]): string;
+//#endregion
+export { AgentsGuidance, discoverAgentsMd, formatGuidance };

package/dist/core/agents-md.js

@@ -0,0 +1,174 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+//#region packages/core/agents-md/index.ts
+/**
+* AGENTS.md discovery — walks directory hierarchy to find guidance files.
+*
+* injects AGENTS.md contents into tool results after file reads/writes
+* so the LLM sees directory-specific instructions. guidance files closer
+* to the target file take precedence (returned last in array).
+*
+* also checks the user's global AGENTS.md at ~/.config/pi/AGENTS.md.
+*/
+const FILENAME = "AGENTS.md";
+const GLOBAL_PATH = path.join(os.homedir(), ".config", "pi", FILENAME);
+/**
+* discover AGENTS.md files relevant to `filePath`, from broadest to
+* most specific scope. walks from workspace root down to the file's
+* directory, prepending the global config if it exists.
+*/
+function discoverAgentsMd(filePath, workspaceRoot) {
+	const results = [];
+	const root = path.resolve(workspaceRoot);
+	if (fs.existsSync(GLOBAL_PATH)) try {
+		results.push({
+			path: GLOBAL_PATH,
+			content: fs.readFileSync(GLOBAL_PATH, "utf-8"),
+			scope: "global"
+		});
+	} catch {}
+	const dirResults = [];
+	let dir = path.dirname(path.resolve(filePath));
+	while (dir.startsWith(root) || dir === root) {
+		const candidate = path.join(dir, FILENAME);
+		if (fs.existsSync(candidate)) try {
+			const content = fs.readFileSync(candidate, "utf-8");
+			const scope = dir === root ? "project" : path.relative(root, dir);
+			dirResults.push({
+				path: candidate,
+				content,
+				scope
+			});
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	results.push(...dirResults.reverse());
+	return results;
+}
+/**
+* format discovered guidance for injection into tool results.
+* output format: header with scope, then content.
+*/
+function formatGuidance(guidance) {
+	if (guidance.length === 0) return "";
+	return guidance.map((g) => {
+		return `${`Contents of ${g.path} (directory-specific instructions for ${g.scope}):`}\n\n<instructions>\n${g.content}\n</instructions>`;
+	}).join("\n\n");
+}
+if (import.meta.vitest) {
+	const { describe, it, expect, beforeEach, afterEach } = import.meta.vitest;
+	let tmpDir;
+	let projectDir;
+	beforeEach(() => {
+		tmpDir = path.join(os.tmpdir(), `pi-agents-md-test-${Date.now()}`);
+		projectDir = path.join(tmpDir, "project");
+		fs.mkdirSync(path.join(projectDir, "src", "components"), { recursive: true });
+		fs.writeFileSync(path.join(projectDir, "AGENTS.md"), "# Project Root\nGeneral project guidance.", "utf-8");
+		fs.writeFileSync(path.join(projectDir, "src", "AGENTS.md"), "# Src\nSource code guidance.", "utf-8");
+		fs.writeFileSync(path.join(projectDir, "src", "components", "AGENTS.md"), "# Components\nUI component guidance.", "utf-8");
+	});
+	afterEach(() => {
+		try {
+			fs.rmSync(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	});
+	describe("discoverAgentsMd", () => {
+		it("finds all AGENTS.md from file dir up to workspace root", () => {
+			const guidance = discoverAgentsMd(path.join(projectDir, "src", "components", "Button.tsx"), projectDir);
+			expect(guidance.length).toBeGreaterThanOrEqual(3);
+			const scopes = guidance.map((g) => g.scope);
+			expect(scopes).toContain("project");
+			expect(scopes).toContain("src");
+			expect(scopes).toContain("src/components");
+		});
+		it("returns empty array when no AGENTS.md files exist", () => {
+			const emptyDir = path.join(tmpDir, "empty");
+			fs.mkdirSync(emptyDir, { recursive: true });
+			expect(discoverAgentsMd(path.join(emptyDir, "test.ts"), emptyDir).filter((g) => g.scope !== "global")).toHaveLength(0);
+		});
+		it("includes file content in guidance", () => {
+			const componentsGuidance = discoverAgentsMd(path.join(projectDir, "src", "components", "Button.tsx"), projectDir).find((g) => g.scope === "src/components");
+			expect(componentsGuidance).toBeDefined();
+			expect(componentsGuidance?.content).toContain("Components");
+			expect(componentsGuidance?.content).toContain("UI component guidance");
+		});
+		it("returns absolute paths for guidance files", () => {
+			const guidance = discoverAgentsMd(path.join(projectDir, "src", "components", "Button.tsx"), projectDir);
+			for (const g of guidance) expect(path.isAbsolute(g.path)).toBe(true);
+		});
+		it("handles file at workspace root", () => {
+			expect(discoverAgentsMd(path.join(projectDir, "README.md"), projectDir).some((g) => g.scope === "project")).toBe(true);
+		});
+		it("handles file in nested directory correctly", () => {
+			const deepDir = path.join(projectDir, "src", "components", "ui", "buttons");
+			fs.mkdirSync(deepDir, { recursive: true });
+			const scopes = discoverAgentsMd(path.join(deepDir, "IconButton.tsx"), projectDir).map((g) => g.scope);
+			expect(scopes).toContain("project");
+			expect(scopes).toContain("src");
+			expect(scopes).toContain("src/components");
+		});
+		it("stops at workspace root", () => {
+			const paths = discoverAgentsMd(path.join(projectDir, "src", "test.ts"), projectDir).map((g) => g.path);
+			for (const p of paths) expect(p.startsWith(tmpDir) || p.includes(".config")).toBe(true);
+		});
+	});
+	describe("formatGuidance", () => {
+		it("returns empty string for empty array", () => {
+			expect(formatGuidance([])).toBe("");
+		});
+		it("formats single guidance with scope header", () => {
+			const result = formatGuidance([{
+				path: "/project/AGENTS.md",
+				content: "# Rules\nBe helpful.",
+				scope: "project"
+			}]);
+			expect(result).toContain("Contents of /project/AGENTS.md");
+			expect(result).toContain("(directory-specific instructions for project)");
+			expect(result).toContain("<instructions>");
+			expect(result).toContain("Be helpful.");
+			expect(result).toContain("</instructions>");
+		});
+		it("formats multiple guidance entries", () => {
+			const result = formatGuidance([{
+				path: "/project/AGENTS.md",
+				content: "Project rules.",
+				scope: "project"
+			}, {
+				path: "/project/src/AGENTS.md",
+				content: "Src rules.",
+				scope: "src"
+			}]);
+			expect(result).toContain("Project rules.");
+			expect(result).toContain("Src rules.");
+			expect(result).toContain("directory-specific instructions for project");
+			expect(result).toContain("directory-specific instructions for src");
+		});
+		it("preserves content exactly", () => {
+			const content = "```typescript\nconst x = 1;\n```\n\n- rule 1\n- rule 2";
+			expect(formatGuidance([{
+				path: "/test/AGENTS.md",
+				content,
+				scope: "test"
+			}])).toContain(content);
+		});
+		it("separates entries with double newline", () => {
+			expect(formatGuidance([{
+				path: "/a",
+				content: "A",
+				scope: "a"
+			}, {
+				path: "/b",
+				content: "B",
+				scope: "b"
+			}])).toMatch(/<\/instructions>\n\nContents of/);
+		});
+	});
+}
+//#endregion
+export { discoverAgentsMd, formatGuidance };

package/dist/core/box-chrome.d.ts

@@ -0,0 +1,56 @@
+//#region packages/core/box-chrome/index.d.ts
+/**
+* box-chrome — shared box-drawing primitives for open and closed frames.
+*
+* "open" (tool output style):   ╭─[header] / │ content / ╰────
+* "closed" (overlay style):     ╭─[header]──╮ / │content│ / ╰──footer──╯
+*
+* only concern is layout chrome. callers own content rendering,
+* truncation, and interactivity. styling is injected via BoxChromeStyle
+* so both raw ANSI (box-format) and theme functions (palette) work.
+*/
+type BoxChromeVariant = "open" | "closed";
+type BoxChromeStyle = {
+  dim: (s: string) => string;
+};
+type MeasuredText = {
+  text: string;
+  width: number;
+};
+declare function boxTop(args: {
+  variant: BoxChromeVariant;
+  style: BoxChromeStyle;
+  innerWidth?: number;
+  header?: MeasuredText;
+}): string;
+declare function boxRow(args: {
+  variant: BoxChromeVariant;
+  style: BoxChromeStyle;
+  inner: string;
+}): string;
+/**
+* Border line with left AND right labels, separated by ─ fill.
+* Used by the editor for: ╭─ left ──── right ─╮ / ╰─ left ──── right ─╯
+*
+* Always renders a ─ after the left corner and before the right corner
+* (the "edge dashes"), so labels never touch the corners directly.
+* innerWidth is the space between the two corner characters.
+*/
+declare function boxBorderLR(args: {
+  corner: {
+    left: string;
+    right: string;
+  };
+  style: BoxChromeStyle;
+  innerWidth: number;
+  left?: MeasuredText;
+  right?: MeasuredText;
+}): string;
+declare function boxBottom(args: {
+  variant: BoxChromeVariant;
+  style: BoxChromeStyle;
+  innerWidth?: number;
+  footer?: MeasuredText;
+}): string;
+//#endregion
+export { BoxChromeStyle, BoxChromeVariant, MeasuredText, boxBorderLR, boxBottom, boxRow, boxTop };