my-pi 0.0.7 → 0.0.9

package/dist/{api-DtthDVIa.js → api-Dcq2JalY.js}

@@ -1,11 +1,13 @@
 import { InteractiveMode as InteractiveMode$1, SessionManager, SettingsManager, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, defineTool, getAgentDir, parseFrontmatter, runPrintMode as runPrintMode$1 } from "@mariozechner/pi-coding-agent";
 import { cpSync, existsSync, globSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { Type } from "@sinclair/typebox";
 import { execFileSync, spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { Container, SettingsList, Text } from "@mariozechner/pi-tui";
+import { Container, SettingsList, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { readFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
 //#region src/extensions/chain.ts
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -399,6 +401,13 @@ const BUILTIN_EXTENSIONS = [
 			"preset",
 			"presets"
 		]
+	},
+	{
+		key: "lsp",
+		label: "LSP",
+		description: "Language Server Protocol tools (diagnostics, hover, definition, references)",
+		cli_flag: "--no-lsp",
+		aliases: ["lsp", "language-server"]
 	}
 ];
 function get_builtin_extensions_config_path() {
@@ -814,47 +823,752 @@ ${task || "Continue from where the previous session left off."}
 	});
 }
 //#endregion
-//#region src/mcp/client.ts
-var McpClient = class {
+//#region src/lsp/client.ts
+var LspClient = class extends EventEmitter {
 	#proc = null;
-	#config;
-	#nextId = 1;
+	#options;
+	#next_id = 1;
 	#pending = /* @__PURE__ */ new Map();
-	#buffer = "";
-	constructor(config) {
-		this.#config = config;
+	#buffer = Buffer.alloc(0);
+	#initialized = false;
+	#open_docs = /* @__PURE__ */ new Map();
+	#diagnostics_by_uri = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super();
+		this.#options = options;
 	}
-	async connect() {
-		const { command, args = [], env } = this.#config;
-		this.#proc = spawn(command, args, {
+	async start() {
+		this.#proc = spawn(this.#options.command, this.#options.args, {
 			stdio: [
 				"pipe",
 				"pipe",
 				"pipe"
 			],
-			env: {
-				...process.env,
-				...env
+			env: process.env
+		});
+		this.#proc.on("error", (err) => {
+			this.emit("error", err);
+		});
+		this.#proc.on("close", () => {
+			for (const pending of this.#pending.values()) {
+				clearTimeout(pending.timer);
+				pending.reject(/* @__PURE__ */ new Error("LSP server closed"));
 			}
+			this.#pending.clear();
+			this.#initialized = false;
+			this.#proc = null;
 		});
-		this.#proc.stdout.setEncoding("utf8");
+		this.#proc.stderr?.on("data", () => {});
 		this.#proc.stdout.on("data", (chunk) => {
-			this.#buffer += chunk;
-			const lines = this.#buffer.split("\n");
-			this.#buffer = lines.pop() || "";
-			for (const line of lines) {
-				if (!line.trim()) continue;
-				try {
-					const msg = JSON.parse(line);
-					if (msg.id != null && this.#pending.has(msg.id)) {
-						const p = this.#pending.get(msg.id);
-						this.#pending.delete(msg.id);
-						if (msg.error) p.reject(/* @__PURE__ */ new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
-						else p.resolve(msg.result);
-					}
-				} catch {}
+			this.#buffer = Buffer.concat([this.#buffer, chunk]);
+			this.#drain_buffer();
+		});
+		await this.#request("initialize", {
+			processId: process.pid,
+			rootUri: this.#options.root_uri,
+			capabilities: {
+				textDocument: {
+					publishDiagnostics: { relatedInformation: true },
+					hover: { contentFormat: ["markdown", "plaintext"] },
+					definition: { linkSupport: false },
+					references: {},
+					documentSymbol: { hierarchicalDocumentSymbolSupport: true }
+				},
+				workspace: {
+					workspaceFolders: true,
+					symbol: {}
+				}
+			},
+			workspaceFolders: [{
+				uri: this.#options.root_uri,
+				name: "workspace"
+			}]
+		});
+		this.#notify("initialized", {});
+		this.#initialized = true;
+	}
+	is_ready() {
+		return this.#initialized;
+	}
+	async ensure_document_open(uri, text) {
+		const existing = this.#open_docs.get(uri);
+		if (existing) {
+			if (existing.text === text) return;
+			const next_version = existing.version + 1;
+			this.#open_docs.set(uri, {
+				version: next_version,
+				text
+			});
+			this.#notify("textDocument/didChange", {
+				textDocument: {
+					uri,
+					version: next_version
+				},
+				contentChanges: [{ text }]
+			});
+			return;
+		}
+		const language_id = this.#options.language_id_for_uri(uri) ?? "plaintext";
+		this.#open_docs.set(uri, {
+			version: 1,
+			text
+		});
+		this.#notify("textDocument/didOpen", { textDocument: {
+			uri,
+			languageId: language_id,
+			version: 1,
+			text
+		} });
+	}
+	async hover(uri, position) {
+		return await this.#request("textDocument/hover", {
+			textDocument: { uri },
+			position
+		}) ?? null;
+	}
+	async definition(uri, position) {
+		return normalize_location_result(await this.#request("textDocument/definition", {
+			textDocument: { uri },
+			position
+		}));
+	}
+	async references(uri, position, include_declaration) {
+		return await this.#request("textDocument/references", {
+			textDocument: { uri },
+			position,
+			context: { includeDeclaration: include_declaration }
+		}) ?? [];
+	}
+	async document_symbols(uri) {
+		return normalize_document_symbol_result(await this.#request("textDocument/documentSymbol", { textDocument: { uri } }));
+	}
+	get_diagnostics(uri) {
+		return this.#diagnostics_by_uri.get(uri) ?? [];
+	}
+	get_all_diagnostics() {
+		return new Map(this.#diagnostics_by_uri);
+	}
+	async wait_for_diagnostics(uri, timeout_ms = 1500) {
+		if (this.#diagnostics_by_uri.has(uri)) return this.get_diagnostics(uri);
+		return new Promise((resolve) => {
+			const handler = (event_uri) => {
+				if (event_uri !== uri) return;
+				this.off("diagnostics", handler);
+				clearTimeout(timer);
+				resolve(this.get_diagnostics(uri));
+			};
+			const timer = setTimeout(() => {
+				this.off("diagnostics", handler);
+				resolve(this.get_diagnostics(uri));
+			}, timeout_ms);
+			this.on("diagnostics", handler);
+		});
+	}
+	async stop() {
+		if (this.#initialized) try {
+			await this.#request("shutdown", null, 1e3);
+			this.#notify("exit", null);
+		} catch {}
+		for (const pending of this.#pending.values()) {
+			clearTimeout(pending.timer);
+			pending.reject(/* @__PURE__ */ new Error("LSP client stopped"));
+		}
+		this.#pending.clear();
+		if (this.#proc) {
+			this.#proc.kill();
+			this.#proc = null;
+		}
+		this.#initialized = false;
+	}
+	#request(method, params, timeout_override) {
+		return new Promise((resolve, reject) => {
+			const id = this.#next_id++;
+			const timeout_ms = timeout_override ?? this.#options.request_timeout_ms ?? 3e4;
+			const timer = setTimeout(() => {
+				if (this.#pending.has(id)) {
+					this.#pending.delete(id);
+					reject(/* @__PURE__ */ new Error(`LSP request ${method} timed out`));
+				}
+			}, timeout_ms);
+			this.#pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+			try {
+				this.#send({
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				});
+			} catch (error) {
+				clearTimeout(timer);
+				this.#pending.delete(id);
+				reject(error);
 			}
 		});
+	}
+	#notify(method, params) {
+		this.#send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	#send(message) {
+		if (!this.#proc?.stdin?.writable) throw new Error("LSP server not connected");
+		const body = Buffer.from(JSON.stringify(message), "utf8");
+		const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii");
+		this.#proc.stdin.write(Buffer.concat([header, body]));
+	}
+	#drain_buffer() {
+		while (true) {
+			const header_end = this.#buffer.indexOf("\r\n\r\n");
+			if (header_end === -1) return;
+			const match = this.#buffer.subarray(0, header_end).toString("ascii").match(/Content-Length:\s*(\d+)/i);
+			if (!match) {
+				this.#buffer = this.#buffer.subarray(header_end + 4);
+				continue;
+			}
+			const length = Number(match[1]);
+			const body_start = header_end + 4;
+			if (this.#buffer.length < body_start + length) return;
+			const body = this.#buffer.subarray(body_start, body_start + length);
+			this.#buffer = this.#buffer.subarray(body_start + length);
+			try {
+				this.#handle_message(JSON.parse(body.toString("utf8")));
+			} catch (error) {
+				this.emit("error", error);
+			}
+		}
+	}
+	#handle_message(message) {
+		if (message.id != null && this.#pending.has(Number(message.id))) {
+			const pending = this.#pending.get(Number(message.id));
+			this.#pending.delete(Number(message.id));
+			clearTimeout(pending.timer);
+			if (message.error) pending.reject(/* @__PURE__ */ new Error(`LSP error ${message.error.code}: ${message.error.message}`));
+			else pending.resolve(message.result);
+			return;
+		}
+		if (message.method === "textDocument/publishDiagnostics" && message.params) {
+			const params = message.params;
+			this.#diagnostics_by_uri.set(params.uri, params.diagnostics);
+			this.emit("diagnostics", params.uri);
+			return;
+		}
+		if (message.method && message.id != null) this.#send({
+			jsonrpc: "2.0",
+			id: message.id,
+			result: null
+		});
+	}
+};
+function normalize_location_result(result) {
+	if (!result) return [];
+	return (Array.isArray(result) ? result : [result]).map((entry) => {
+		if ("uri" in entry) return entry;
+		return {
+			uri: entry.targetUri,
+			range: entry.targetSelectionRange ?? entry.targetRange
+		};
+	});
+}
+function normalize_document_symbol_result(result) {
+	if (!result) return [];
+	if (result.length === 0 || "range" in result[0] && "selectionRange" in result[0]) return result;
+	return result.map((entry) => ({
+		name: entry.name,
+		kind: entry.kind,
+		range: entry.location.range,
+		selectionRange: entry.location.range,
+		containerName: entry.containerName,
+		uri: entry.location.uri
+	}));
+}
+function file_path_to_uri(file_path) {
+	return pathToFileURL(file_path).href;
+}
+//#endregion
+//#region src/lsp/servers.ts
+const EXTENSION_LANGUAGES = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".mts": "typescript",
+	".cts": "typescript",
+	".js": "typescript",
+	".jsx": "typescript",
+	".mjs": "typescript",
+	".cjs": "typescript",
+	".py": "python",
+	".rs": "rust",
+	".go": "go",
+	".rb": "ruby",
+	".java": "java",
+	".lua": "lua",
+	".svelte": "svelte"
+};
+const LANGUAGE_SERVERS = {
+	typescript: {
+		language: "typescript",
+		command: "typescript-language-server",
+		args: ["--stdio"]
+	},
+	python: {
+		language: "python",
+		command: "pylsp",
+		args: []
+	},
+	rust: {
+		language: "rust",
+		command: "rust-analyzer",
+		args: []
+	},
+	go: {
+		language: "go",
+		command: "gopls",
+		args: ["serve"]
+	},
+	ruby: {
+		language: "ruby",
+		command: "solargraph",
+		args: ["stdio"]
+	},
+	java: {
+		language: "java",
+		command: "jdtls",
+		args: []
+	},
+	lua: {
+		language: "lua",
+		command: "lua-language-server",
+		args: []
+	},
+	svelte: {
+		language: "svelte",
+		command: "svelteserver",
+		args: ["--stdio"]
+	}
+};
+function detect_language(file_path) {
+	return EXTENSION_LANGUAGES[extname(file_path).toLowerCase()];
+}
+function list_supported_languages() {
+	return Object.keys(LANGUAGE_SERVERS).sort();
+}
+function resolve_server_command(command, cwd = process.cwd()) {
+	if (!command) return command;
+	if (isAbsolute(command) || command.includes("/") || command.includes("\\")) return command;
+	for (const dir of ancestor_directories(cwd)) {
+		const local_bin = resolve_local_binary(dir, command);
+		if (local_bin) return local_bin;
+	}
+	return command;
+}
+function get_server_config(language, cwd = process.cwd()) {
+	const base = LANGUAGE_SERVERS[language];
+	if (!base) return void 0;
+	return {
+		...base,
+		command: resolve_server_command(base.command, cwd)
+	};
+}
+function language_id_for_file(file_path) {
+	return detect_language(file_path);
+}
+function ancestor_directories(start) {
+	const dirs = [];
+	let current = resolve(start);
+	while (true) {
+		dirs.push(current);
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+function resolve_local_binary(directory, command) {
+	return [join(directory, "node_modules", ".bin", command), join(directory, "node_modules", ".bin", `${command}.cmd`)].find((candidate) => existsSync(candidate));
+}
+//#endregion
+//#region src/extensions/lsp.ts
+function create_lsp_extension(options = {}) {
+	const create_client = options.create_client ?? ((client_options) => new LspClient(client_options));
+	const read_file = options.read_file ?? ((path) => readFile(path, "utf-8"));
+	return async function lsp(pi) {
+		const cwd = options.cwd?.() ?? process.cwd();
+		const root_uri = file_path_to_uri(cwd);
+		const clients_by_language = /* @__PURE__ */ new Map();
+		const failed_languages = /* @__PURE__ */ new Map();
+		const resolve_abs = (file) => isAbsolute(file) ? file : resolve(cwd, file);
+		const clear_language_state = async (language) => {
+			if (language) {
+				const state = clients_by_language.get(language);
+				if (state) {
+					await state.client.stop();
+					clients_by_language.delete(language);
+				}
+				failed_languages.delete(language);
+				return;
+			}
+			await Promise.allSettled(Array.from(clients_by_language.values()).map((state) => state.client.stop()));
+			clients_by_language.clear();
+			failed_languages.clear();
+		};
+		const get_or_start_client = async (file_path) => {
+			const language = detect_language(file_path);
+			if (!language) return void 0;
+			const existing = clients_by_language.get(language);
+			if (existing) return existing;
+			if (failed_languages.has(language)) throw new Error(failed_languages.get(language));
+			const server_config = get_server_config(language, cwd);
+			if (!server_config) return void 0;
+			const client = create_client({
+				command: server_config.command,
+				args: server_config.args,
+				root_uri,
+				language_id_for_uri: (uri) => language_id_for_file(uri)
+			});
+			try {
+				await client.start();
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				const failure = `Failed to start ${server_config.command} for ${language}: ${message}. Install the language server and ensure it is available.`;
+				failed_languages.set(language, failure);
+				throw new Error(failure);
+			}
+			const state = {
+				client,
+				language,
+				root_uri,
+				command: server_config.command
+			};
+			clients_by_language.set(language, state);
+			failed_languages.delete(language);
+			return state;
+		};
+		const open_file = async (state, abs_path) => {
+			const text = await read_file(abs_path);
+			const uri = file_path_to_uri(abs_path);
+			await state.client.ensure_document_open(uri, text);
+			return uri;
+		};
+		const get_file_state = async (file) => {
+			const abs = resolve_abs(file);
+			const state = await get_or_start_client(abs);
+			if (!state) return void 0;
+			return {
+				abs,
+				uri: await open_file(state, abs),
+				state
+			};
+		};
+		pi.registerTool(defineTool({
+			name: "lsp_diagnostics",
+			label: "LSP: diagnostics",
+			description: "Get language server diagnostics (errors, warnings, hints) for a file. Uses the project language server and returns empty output if the file is clean.",
+			parameters: Type.Object({
+				file: Type.String({ description: "Path to the file to check (relative to cwd or absolute)." }),
+				wait_ms: Type.Optional(Type.Number({ description: "Max ms to wait for diagnostics after opening the file. Default 1500." }))
+			}),
+			execute: async (_id, params) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				const diagnostics = await result.state.client.wait_for_diagnostics(result.uri, params.wait_ms ?? 1500);
+				return {
+					content: [{
+						type: "text",
+						text: format_diagnostics(result.abs, diagnostics)
+					}],
+					details: {}
+				};
+			}
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_hover",
+			label: "LSP: hover",
+			description: "Get hover info (types, docs) at a position in a file. Positions are zero-based.",
+			parameters: Type.Object({
+				file: Type.String(),
+				line: Type.Number({ description: "Zero-based line number." }),
+				character: Type.Number({ description: "Zero-based character offset." })
+			}),
+			execute: async (_id, params) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: format_hover(await result.state.client.hover(result.uri, {
+							line: params.line,
+							character: params.character
+						}))
+					}],
+					details: {}
+				};
+			}
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_definition",
+			label: "LSP: go to definition",
+			description: "Find definition locations for the symbol at a position. Positions are zero-based.",
+			parameters: Type.Object({
+				file: Type.String(),
+				line: Type.Number(),
+				character: Type.Number()
+			}),
+			execute: async (_id, params) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: format_locations(await result.state.client.definition(result.uri, {
+							line: params.line,
+							character: params.character
+						}), "No definition found.")
+					}],
+					details: {}
+				};
+			}
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_references",
+			label: "LSP: find references",
+			description: "Find references to the symbol at a position. Positions are zero-based.",
+			parameters: Type.Object({
+				file: Type.String(),
+				line: Type.Number(),
+				character: Type.Number(),
+				include_declaration: Type.Optional(Type.Boolean())
+			}),
+			execute: async (_id, params) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: format_locations(await result.state.client.references(result.uri, {
+							line: params.line,
+							character: params.character
+						}, params.include_declaration ?? true), "No references found.")
+					}],
+					details: {}
+				};
+			}
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_document_symbols",
+			label: "LSP: document symbols",
+			description: "List symbols in a file (functions, classes, variables) using the language server.",
+			parameters: Type.Object({ file: Type.String() }),
+			execute: async (_id, params) => {
+				const result = await get_file_state(params.file);
+				if (!result) return {
+					content: [{
+						type: "text",
+						text: `No language server configured for ${resolve_abs(params.file)}`
+					}],
+					details: {}
+				};
+				const symbols = await result.state.client.document_symbols(result.uri);
+				return {
+					content: [{
+						type: "text",
+						text: format_document_symbols(result.abs, symbols)
+					}],
+					details: {}
+				};
+			}
+		}));
+		pi.registerCommand("lsp", {
+			description: "Show or manage language server state",
+			getArgumentCompletions: (prefix) => {
+				const parts = prefix.trim().split(/\s+/);
+				const subcommands = [
+					"status",
+					"list",
+					"restart"
+				];
+				if (!prefix.trim()) return subcommands.map((value) => ({
+					value,
+					label: value
+				}));
+				if (parts.length <= 1) return subcommands.filter((value) => value.startsWith(parts[0])).map((value) => ({
+					value,
+					label: value
+				}));
+				if (parts[0] === "restart") {
+					const candidate = parts[1] ?? "";
+					return ["all", ...list_supported_languages()].filter((value) => value.startsWith(candidate)).map((value) => ({
+						value: `restart ${value}`,
+						label: value
+					}));
+				}
+				return null;
+			},
+			handler: async (args, ctx) => {
+				await handle_lsp_command(args, ctx, cwd, clients_by_language, failed_languages, clear_language_state);
+			}
+		});
+		pi.on("session_shutdown", async () => {
+			await clear_language_state();
+		});
+	};
+}
+var lsp_default = create_lsp_extension();
+async function handle_lsp_command(args, ctx, cwd, clients_by_language, failed_languages, clear_language_state) {
+	const [subcommand = "status", target] = args.trim() ? args.trim().split(/\s+/, 2) : [];
+	switch (subcommand) {
+		case "status":
+		case "list":
+			ctx.ui.notify(format_status_lines(cwd, clients_by_language, failed_languages).join("\n"));
+			return;
+		case "restart":
+			if (!target || target === "all") {
+				await clear_language_state();
+				ctx.ui.notify("Restarted all language server state.");
+				return;
+			}
+			if (!list_supported_languages().includes(target)) {
+				ctx.ui.notify(`Unknown language: ${target}. Use one of: ${list_supported_languages().join(", ")}`, "warning");
+				return;
+			}
+			await clear_language_state(target);
+			ctx.ui.notify(`Restarted ${target} language server state.`);
+			return;
+		default: ctx.ui.notify(`Unknown subcommand: ${subcommand}. Use: status, list, restart`, "warning");
+	}
+}
+function format_status_lines(cwd, clients_by_language, failed_languages) {
+	const lines = [];
+	for (const language of list_supported_languages()) {
+		const running = clients_by_language.get(language);
+		if (running) {
+			lines.push(`${language}: running (ready=${running.client.is_ready()}) — ${running.command}`);
+			continue;
+		}
+		const failed = failed_languages.get(language);
+		if (failed) {
+			lines.push(`${language}: failed — ${failed}`);
+			continue;
+		}
+		const config = get_server_config(language, cwd);
+		if (config) lines.push(`${language}: idle — ${config.command}`);
+	}
+	return lines.length > 0 ? lines : ["No language servers configured for this project."];
+}
+function severity_label(severity) {
+	switch (severity) {
+		case 1: return "error";
+		case 2: return "warning";
+		case 3: return "info";
+		case 4: return "hint";
+		default: return "info";
+	}
+}
+function format_diagnostics(file, diagnostics) {
+	if (diagnostics.length === 0) return `${file}: no diagnostics`;
+	const lines = [`${file}: ${diagnostics.length} diagnostic(s)`];
+	for (const d of diagnostics) {
+		const position = `${d.range.start.line + 1}:${d.range.start.character + 1}`;
+		const source = d.source ? ` [${d.source}]` : "";
+		const code = d.code != null ? ` (${d.code})` : "";
+		lines.push(`  ${position} ${severity_label(d.severity)}${source}${code}: ${d.message}`);
+	}
+	return lines.join("\n");
+}
+function format_hover(hover) {
+	if (!hover) return "No hover info.";
+	const contents = hover.contents;
+	const extract = (item) => typeof item === "string" ? item : item.value ?? "";
+	if (Array.isArray(contents)) return contents.map(extract).join("\n\n").trim() || "No hover info.";
+	return extract(contents).trim() || "No hover info.";
+}
+function format_locations(locations, empty_message) {
+	if (locations.length === 0) return empty_message;
+	return locations.map((loc) => {
+		return `${file_url_to_path_or_value(loc.uri)}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+	}).join("\n");
+}
+function format_document_symbols(file, symbols) {
+	if (symbols.length === 0) return `${file}: no symbols`;
+	const lines = [`${file}: ${symbols.length} top-level symbol(s)`];
+	append_symbol_lines(lines, symbols, 1);
+	return lines.join("\n");
+}
+function append_symbol_lines(lines, symbols, depth) {
+	for (const symbol of symbols) {
+		const indent = "  ".repeat(depth);
+		const detail = symbol.detail ? ` — ${symbol.detail}` : "";
+		const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
+		lines.push(`${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`);
+		if (symbol.children?.length) append_symbol_lines(lines, symbol.children, depth + 1);
+	}
+}
+function symbol_kind_label(kind) {
+	return {
+		2: "module",
+		3: "namespace",
+		5: "class",
+		6: "method",
+		7: "property",
+		8: "field",
+		9: "constructor",
+		11: "interface",
+		12: "function",
+		13: "variable",
+		14: "constant",
+		23: "struct",
+		24: "event"
+	}[kind] ?? "symbol";
+}
+function file_url_to_path_or_value(uri) {
+	try {
+		return uri.startsWith("file:") ? fileURLToPath(uri) : uri;
+	} catch {
+		return uri;
+	}
+}
+//#endregion
+//#region src/mcp/client.ts
+var McpClient = class {
+	#proc = null;
+	#config;
+	#nextId = 1;
+	#pending = /* @__PURE__ */ new Map();
+	#buffer = "";
+	#sessionId;
+	constructor(config) {
+		this.#config = config;
+	}
+	async connect() {
+		if (this.#config.transport === "stdio") await this.#connect_stdio();
 		await this.#request("initialize", {
 			protocolVersion: "2024-11-05",
 			capabilities: {},
@@ -863,7 +1577,7 @@ var McpClient = class {
 				version: "0.0.1"
 			}
 		});
-		this.#send({
+		await this.#send({
 			jsonrpc: "2.0",
 			method: "notifications/initialized"
 		});
@@ -878,12 +1592,39 @@ var McpClient = class {
 		});
 	}
 	async disconnect() {
+		if (this.#config.transport === "http") await this.#disconnect_http();
 		if (this.#proc) {
 			this.#proc.kill();
 			this.#proc = null;
 		}
 		this.#pending.clear();
 	}
+	async #connect_stdio() {
+		const { command, args = [], env } = this.#config;
+		this.#proc = spawn(command, args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				...env
+			}
+		});
+		this.#proc.stdout.setEncoding("utf8");
+		this.#proc.stdout.on("data", (chunk) => {
+			this.#buffer += chunk;
+			const lines = this.#buffer.split("\n");
+			this.#buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					this.#handle_message(JSON.parse(line));
+				} catch {}
+			}
+		});
+	}
 	#request(method, params) {
 		return new Promise((resolve, reject) => {
 			const id = this.#nextId++;
@@ -896,6 +1637,11 @@ var McpClient = class {
 				id,
 				method,
 				params
+			}).catch((error) => {
+				if (this.#pending.has(id)) {
+					this.#pending.delete(id);
+					reject(error);
+				}
 			});
 			setTimeout(() => {
 				if (this.#pending.has(id)) {
@@ -905,13 +1651,156 @@ var McpClient = class {
 			}, 3e4);
 		});
 	}
-	#send(msg) {
+	async #send(msg) {
+		if (this.#config.transport === "http") {
+			await this.#send_http(msg);
+			return;
+		}
 		if (!this.#proc?.stdin?.writable) throw new Error("MCP server not connected");
 		this.#proc.stdin.write(JSON.stringify(msg) + "\n");
 	}
+	async #send_http(msg) {
+		const config = this.#config;
+		const headers = new Headers(config.headers ?? {});
+		headers.set("content-type", "application/json");
+		headers.set("accept", "application/json, text/event-stream");
+		if (this.#sessionId) headers.set("mcp-session-id", this.#sessionId);
+		const response = await fetch(config.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(msg)
+		});
+		const sessionId = response.headers.get("mcp-session-id");
+		if (sessionId) this.#sessionId = sessionId;
+		if (!response.ok) {
+			const body = await response.text().catch(() => "");
+			throw new Error(`MCP HTTP ${response.status}${body ? `: ${body}` : ""}`);
+		}
+		if (response.status === 204) return;
+		if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+			await this.#consume_sse_response(response, config.name);
+			return;
+		}
+		const body = await response.text();
+		if (!body.trim()) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(body);
+		} catch {
+			throw new Error(`Invalid MCP HTTP response from ${config.name}: ${body.slice(0, 200)}`);
+		}
+		this.#dispatch_message(parsed);
+	}
+	async #disconnect_http() {
+		const config = this.#config;
+		if (!this.#sessionId) return;
+		const headers = new Headers(config.headers ?? {});
+		headers.set("mcp-session-id", this.#sessionId);
+		const response = await fetch(config.url, {
+			method: "DELETE",
+			headers
+		});
+		if (response.status !== 405 && !response.ok) {
+			const body = await response.text().catch(() => "");
+			throw new Error(`MCP HTTP disconnect ${response.status}${body ? `: ${body}` : ""}`);
+		}
+		this.#sessionId = void 0;
+	}
+	async #consume_sse_response(response, server_name) {
+		if (!response.body) return;
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let event_lines = [];
+		const flush_event = () => {
+			if (event_lines.length === 0) return;
+			const data_lines = event_lines.filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+			event_lines = [];
+			if (data_lines.length === 0) return;
+			const payload = data_lines.join("\n").trim();
+			if (!payload) return;
+			try {
+				this.#dispatch_message(JSON.parse(payload));
+			} catch {
+				throw new Error(`Invalid MCP SSE payload from ${server_name}: ${payload.slice(0, 200)}`);
+			}
+		};
+		while (true) {
+			const { done, value } = await reader.read();
+			buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
+			const lines = buffer.replace(/\r\n/g, "\n").split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				if (line === "") {
+					flush_event();
+					continue;
+				}
+				if (line.startsWith(":")) continue;
+				event_lines.push(line);
+			}
+			if (done) break;
+		}
+		if (buffer.trim()) event_lines.push(buffer.trim());
+		flush_event();
+	}
+	#dispatch_message(message) {
+		if (Array.isArray(message)) {
+			for (const item of message) this.#dispatch_message(item);
+			return;
+		}
+		if (!message || typeof message !== "object") return;
+		this.#handle_message(message);
+	}
+	#handle_message(msg) {
+		if (msg.id == null || !this.#pending.has(msg.id)) return;
+		const pending = this.#pending.get(msg.id);
+		this.#pending.delete(msg.id);
+		if (msg.error) {
+			pending.reject(/* @__PURE__ */ new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+			return;
+		}
+		pending.resolve(msg.result);
+	}
 };
 //#endregion
 //#region src/mcp/config.ts
+function is_string_record(value, label, name) {
+	if (value === void 0) return true;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid MCP server "${name}": ${label} must be an object of string values`);
+	for (const [key, entry] of Object.entries(value)) if (typeof entry !== "string") throw new Error(`Invalid MCP server "${name}": ${label}.${key} must be a string`);
+	return true;
+}
+function parse_server(name, entry) {
+	const type = typeof entry.type === "string" ? entry.type.trim().toLowerCase() : "";
+	if (type && ![
+		"stdio",
+		"http",
+		"streamable-http"
+	].includes(type)) throw new Error(`Invalid MCP server "${name}": unsupported transport type "${type}"`);
+	if (type === "http" || type === "streamable-http" || entry.url !== void 0) {
+		if (typeof entry.url !== "string" || !entry.url.trim()) throw new Error(`Invalid MCP server "${name}": http transport requires a url`);
+		is_string_record(entry.headers, "headers", name);
+		const headers = entry.headers;
+		return {
+			name,
+			transport: "http",
+			url: entry.url.trim(),
+			...headers ? { headers } : {}
+		};
+	}
+	if (typeof entry.command !== "string" || !entry.command.trim()) throw new Error(`Invalid MCP server "${name}": stdio transport requires a command`);
+	if (entry.args !== void 0 && (!Array.isArray(entry.args) || entry.args.some((value) => typeof value !== "string"))) throw new Error(`Invalid MCP server "${name}": args must be an array of strings`);
+	is_string_record(entry.env, "env", name);
+	const args = entry.args;
+	const env = entry.env;
+	return {
+		name,
+		transport: "stdio",
+		command: entry.command.trim(),
+		...args ? { args } : {},
+		...env ? { env } : {}
+	};
+}
 function read_config(path) {
 	if (!existsSync(path)) return {};
 	const raw = readFileSync(path, "utf-8");
@@ -924,12 +1813,7 @@ function load_mcp_config(cwd) {
 		...global_servers,
 		...project_servers
 	};
-	return Object.entries(merged).map(([name, server]) => ({
-		name,
-		command: server.command,
-		args: server.args,
-		env: server.env
-	}));
+	return Object.entries(merged).map(([name, server]) => parse_server(name, server));
 }
 //#endregion
 //#region src/extensions/mcp.ts
@@ -1144,6 +2028,9 @@ function get_global_presets_path() {
 function get_project_presets_path(cwd) {
 	return join(cwd, ".pi", "presets.json");
 }
+function get_persisted_prompt_state_path() {
+	return join(getAgentDir(), "prompt-preset-state.json");
+}
 function read_prompt_presets_file(path) {
 	if (!existsSync(path)) return {};
 	try {
@@ -1195,6 +2082,61 @@ function remove_project_prompt_preset(cwd, name) {
 		remaining
 	};
 }
+function normalize_prompt_preset_state(input) {
+	if (!input || typeof input !== "object") return void 0;
+	const candidate = input;
+	return {
+		base_name: typeof candidate.base_name === "string" && candidate.base_name.trim() ? candidate.base_name.trim() : null,
+		layer_names: Array.isArray(candidate.layer_names) ? [...new Set(candidate.layer_names.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim()))].sort() : []
+	};
+}
+function read_persisted_prompt_states(path = get_persisted_prompt_state_path()) {
+	if (!existsSync(path)) return {
+		version: 1,
+		projects: {}
+	};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		const raw_projects = parsed.projects && typeof parsed.projects === "object" ? parsed.projects : {};
+		const projects = {};
+		for (const [cwd, value] of Object.entries(raw_projects)) {
+			const normalized = normalize_prompt_preset_state(value);
+			if (!normalized) continue;
+			projects[cwd] = normalized;
+		}
+		return {
+			version: typeof parsed.version === "number" ? parsed.version : 1,
+			projects
+		};
+	} catch {
+		return {
+			version: 1,
+			projects: {}
+		};
+	}
+}
+function load_persisted_prompt_state(cwd, path = get_persisted_prompt_state_path()) {
+	return read_persisted_prompt_states(path).projects[cwd];
+}
+function save_persisted_prompt_state(cwd, state, path = get_persisted_prompt_state_path()) {
+	const persisted = read_persisted_prompt_states(path);
+	persisted.projects[cwd] = normalize_prompt_preset_state(state) ?? {
+		base_name: null,
+		layer_names: []
+	};
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${path}.tmp-${Date.now()}`;
+	writeFileSync(tmp, JSON.stringify({
+		version: 1,
+		projects: Object.fromEntries(Object.entries(persisted.projects).sort(([a], [b]) => a.localeCompare(b)))
+	}, null, "	") + "\n", { mode: 384 });
+	renameSync(tmp, path);
+	return path;
+}
 function get_last_preset_state(ctx) {
 	const entries = ctx.sessionManager.getEntries();
 	for (let i = entries.length - 1; i >= 0; i--) {
@@ -1258,16 +2200,129 @@ function format_active_details(active_base_name, active_layers, presets) {
 	}
 	return parts.join("\n") || "No preset or layers active";
 }
+function get_footer_prompt_status(active_base_name, active_layers) {
+	if (!active_base_name && active_layers.size === 0) return;
+	return `prompt:${active_base_name ?? "none"}${active_layers.size > 0 ? ` +${active_layers.size}` : ""}`;
+}
+function sanitize_status_text(text) {
+	return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+function format_token_count(count) {
+	if (count < 1e3) return count.toString();
+	if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+	if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+	if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
+	return `${Math.round(count / 1e6)}M`;
+}
+function get_current_thinking_level(ctx) {
+	const entries = ctx.sessionManager.getEntries();
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry.type === "thinking_level_change" && typeof entry.thinkingLevel === "string") return entry.thinkingLevel;
+	}
+	return ctx.model?.reasoning ? "high" : "off";
+}
+function render_footer_lines(ctx, theme, footer_data, width, active_base_name, active_layers) {
+	let total_input = 0;
+	let total_output = 0;
+	let total_cache_read = 0;
+	let total_cache_write = 0;
+	let total_cost = 0;
+	for (const entry of ctx.sessionManager.getEntries()) if (entry.type === "message" && entry.message.role === "assistant") {
+		total_input += entry.message.usage.input;
+		total_output += entry.message.usage.output;
+		total_cache_read += entry.message.usage.cacheRead;
+		total_cache_write += entry.message.usage.cacheWrite;
+		total_cost += entry.message.usage.cost.total;
+	}
+	const context_usage = ctx.getContextUsage();
+	const context_window = context_usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+	const context_percent_value = context_usage?.percent ?? 0;
+	const context_percent = context_usage?.percent !== null ? context_percent_value.toFixed(1) : "?";
+	let pwd = ctx.cwd;
+	const home = process.env.HOME || process.env.USERPROFILE;
+	if (home && pwd.startsWith(home)) pwd = `~${pwd.slice(home.length)}`;
+	const branch = footer_data.getGitBranch();
+	if (branch) pwd = `${pwd} (${branch})`;
+	const session_name = ctx.sessionManager.getSessionName();
+	if (session_name) pwd = `${pwd} • ${session_name}`;
+	const stats_parts = [];
+	if (total_input) stats_parts.push(`↑${format_token_count(total_input)}`);
+	if (total_output) stats_parts.push(`↓${format_token_count(total_output)}`);
+	if (total_cache_read) stats_parts.push(`R${format_token_count(total_cache_read)}`);
+	if (total_cache_write) stats_parts.push(`W${format_token_count(total_cache_write)}`);
+	const using_subscription = ctx.model ? ctx.modelRegistry.isUsingOAuth(ctx.model) : false;
+	if (total_cost || using_subscription) stats_parts.push(`$${total_cost.toFixed(3)}${using_subscription ? " (sub)" : ""}`);
+	const context_percent_display = context_percent === "?" ? `?/${format_token_count(context_window)}` : `${context_percent}%/${format_token_count(context_window)}`;
+	let context_percent_str = context_percent_display;
+	if (context_percent_value > 90) context_percent_str = theme.fg("error", context_percent_display);
+	else if (context_percent_value > 70) context_percent_str = theme.fg("warning", context_percent_display);
+	stats_parts.push(context_percent_str);
+	let stats_left = stats_parts.join(" ");
+	let stats_left_width = visibleWidth(stats_left);
+	if (stats_left_width > width) {
+		stats_left = truncateToWidth(stats_left, width, "...");
+		stats_left_width = visibleWidth(stats_left);
+	}
+	const model_name = ctx.model?.id || "no-model";
+	const thinking_level = get_current_thinking_level(ctx);
+	let right_side_without_provider = model_name;
+	if (ctx.model?.reasoning) right_side_without_provider = thinking_level === "off" ? `${model_name} • thinking off` : `${model_name} • ${thinking_level}`;
+	let right_side = right_side_without_provider;
+	if (footer_data.getAvailableProviderCount() > 1 && ctx.model) {
+		right_side = `(${ctx.model.provider}) ${right_side_without_provider}`;
+		if (stats_left_width + 2 + visibleWidth(right_side) > width) right_side = right_side_without_provider;
+	}
+	const right_side_width = visibleWidth(right_side);
+	const total_needed = stats_left_width + 2 + right_side_width;
+	let stats_line;
+	if (total_needed <= width) {
+		const padding = " ".repeat(width - stats_left_width - right_side_width);
+		stats_line = stats_left + padding + right_side;
+	} else {
+		const available_for_right = width - stats_left_width - 2;
+		if (available_for_right > 0) {
+			const truncated_right = truncateToWidth(right_side, available_for_right, "");
+			const truncated_right_width = visibleWidth(truncated_right);
+			const padding = " ".repeat(Math.max(0, width - stats_left_width - truncated_right_width));
+			stats_line = stats_left + padding + truncated_right;
+		} else stats_line = stats_left;
+	}
+	const dim_stats_left = theme.fg("dim", stats_left);
+	const remainder = stats_line.slice(stats_left.length);
+	const dim_remainder = theme.fg("dim", remainder);
+	const lines = [truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")), dim_stats_left + dim_remainder];
+	const prompt_status = get_footer_prompt_status(active_base_name, active_layers);
+	if (prompt_status) {
+		const themed_status = theme.fg("dim", prompt_status);
+		const status_width = visibleWidth(themed_status);
+		const aligned_status = status_width >= width ? truncateToWidth(themed_status, width, theme.fg("dim", "...")) : `${" ".repeat(width - status_width)}${themed_status}`;
+		lines.push(aligned_status);
+	}
+	const other_statuses = Array.from(footer_data.getExtensionStatuses().entries()).filter(([key]) => key !== "preset").sort(([a], [b]) => a.localeCompare(b)).map(([, text]) => sanitize_status_text(text));
+	if (other_statuses.length > 0) lines.push(truncateToWidth(other_statuses.join(" "), width, theme.fg("dim", "...")));
+	return lines;
+}
 function set_status(ctx, active_base_name, active_layers) {
-	const label = active_base_name ?? "none";
-	const layer_suffix = active_layers.size > 0 ? ` +${active_layers.size}` : "";
-	ctx.ui.setStatus("preset", `prompt:${label}${layer_suffix}`);
+	ctx.ui.setStatus("preset", void 0);
+	if (!ctx.hasUI) return;
+	ctx.ui.setFooter((tui, theme, footer_data) => {
+		return {
+			dispose: footer_data.onBranchChange(() => tui.requestRender()),
+			invalidate() {},
+			render(width) {
+				return render_footer_lines(ctx, theme, footer_data, width, active_base_name, active_layers);
+			}
+		};
+	});
 }
-function persist_state(pi, active_base_name, active_layers) {
-	pi.appendEntry(PRESET_STATE_TYPE, {
+function persist_state(pi, ctx, active_base_name, active_layers) {
+	const state = {
 		base_name: active_base_name ?? null,
 		layer_names: [...active_layers].sort()
-	});
+	};
+	pi.appendEntry(PRESET_STATE_TYPE, state);
+	save_persisted_prompt_state(ctx.cwd, state);
 }
 function normalize_active_state(presets, active_base_name, active_layers) {
 	return {
@@ -1308,7 +2363,7 @@ async function prompt_presets(pi) {
 		active_base_name = next_base_name;
 		active_layers = new Set(next_layers);
 		set_status(ctx, active_base_name, active_layers);
-		if (options?.persist !== false) persist_state(pi, active_base_name, active_layers);
+		if (options?.persist !== false) persist_state(pi, ctx, active_base_name, active_layers);
 		if (options?.notify) ctx.ui.notify(options.notify, "info");
 	}
 	function activate_base(name, ctx, options) {
@@ -1384,7 +2439,7 @@ async function prompt_presets(pi) {
 		active_base_name = normalized.active_base_name;
 		active_layers = normalized.active_layers;
 		set_status(ctx, active_base_name, active_layers);
-		persist_state(pi, active_base_name, active_layers);
+		persist_state(pi, ctx, active_base_name, active_layers);
 		const fallback = presets[name];
 		if (mode === "reset" && fallback) {
 			ctx.ui.notify(`Reset "${name}" to ${get_prompt_source_label(fallback.source)} preset`, "info");
@@ -1681,7 +2736,7 @@ async function prompt_presets(pi) {
 			set_status(ctx, active_base_name, active_layers);
 			return;
 		}
-		const restored = get_last_preset_state(ctx);
+		const restored = get_last_preset_state(ctx) ?? load_persisted_prompt_state(ctx.cwd);
 		if (restored) {
 			active_base_name = restored.base_name ?? void 0;
 			active_layers = new Set(restored.layer_names ?? []);
@@ -1702,6 +2757,7 @@ async function prompt_presets(pi) {
 	});
 	pi.on("session_shutdown", async (_event, ctx) => {
 		ctx.ui.setStatus("preset", void 0);
+		ctx.ui.setFooter(void 0);
 	});
 }
 //#endregion
@@ -2500,7 +3556,8 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	"filter-output": filter_output,
 	handoff,
 	recall,
-	"prompt-presets": prompt_presets
+	"prompt-presets": prompt_presets,
+	lsp: lsp_default
 };
 const PACKAGE_THEME_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "themes");
 function get_force_disabled_builtins(options) {
@@ -2512,6 +3569,7 @@ function get_force_disabled_builtins(options) {
 	if (!options.handoff) force_disabled.add("handoff");
 	if (!options.recall) force_disabled.add("recall");
 	if (!options.prompt_presets) force_disabled.add("prompt-presets");
+	if (!options.lsp) force_disabled.add("lsp");
 	return force_disabled;
 }
 function create_builtin_extension_factory(key, extension, force_disabled) {
@@ -2533,7 +3591,7 @@ function create_extensions_override(managed_inline_paths) {
 	};
 }
 async function create_my_pi(options = {}) {
-	const { cwd = process.cwd(), extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, model, system_prompt, append_system_prompt } = options;
+	const { cwd = process.cwd(), extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, lsp = true, model, system_prompt, append_system_prompt } = options;
 	const resolved_extensions = extensions.map((p) => resolve(cwd, p));
 	const force_disabled = get_force_disabled_builtins({
 		mcp,
@@ -2542,7 +3600,8 @@ async function create_my_pi(options = {}) {
 		filter_output,
 		handoff,
 		recall,
-		prompt_presets
+		prompt_presets,
+		lsp
 	});
 	const managed_extension_factories = [create_extensions_extension({ force_disabled }), ...BUILTIN_EXTENSIONS.map((extension) => create_builtin_extension_factory(extension.key, BUILTIN_EXTENSION_FACTORIES[extension.key], force_disabled))];
 	const managed_inline_paths = managed_extension_factories.map((_, index) => `<inline:${index + 1}>`);
@@ -2591,4 +3650,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-DtthDVIa.js.map
+//# sourceMappingURL=api-Dcq2JalY.js.map