pi-ui-extend 0.1.2 → 0.1.3

package/README.md

@@ -16,8 +16,9 @@ The npm package is currently named `pi-ui-extend` and installs the `pix` CLI.
 
 ## Requirements
 
-- Node.js `24.x` (`24.16.0` is pinned for development).
-- A terminal with good Unicode support. JetBrainsMono Nerd Font is recommended for the default icon theme.
+- Node.js `>=22.19.0 <25` (`24.16.0` is pinned for development).
+- A terminal with good Unicode support. JetBrainsMono Nerd Font is recommended for the default icon theme; Pix can install it for the current user on macOS, Linux, and Windows.
+- Linux clipboard support: Pix first tries `wl-copy`, `xclip`, `xsel`, or `termux-clipboard-set`, then falls back to its bundled native clipboard package.
 - Optional for voice input: SoX (`rec`/`sox`), `ffmpeg`, or Linux `arecord`.
 
 Development uses `mise` when available. `.node-version` and `.nvmrc` are also provided for other Node version managers.
@@ -32,6 +33,16 @@ npm install -g pi-ui-extend --ignore-scripts
 
 The published package contains built JavaScript, the `pix` launcher, renderer extensions, documentation, and the bundled `pi-tools-suite` extension payload. Users do not need to clone the repository or build TypeScript locally.
 
+After installation, run the setup check when installing on a new machine:
+
+```bash
+pix install
+# or report only:
+pix install --check
+```
+
+`pix install` checks the icon font, `pi` CLI availability, and clipboard helpers. The `pix` launcher also prepends Pix's bundled dependency bin directory to `PATH`, so a package-manager install can use the bundled Pi CLI even when a separate global `pi` command is not present.
+
 On startup, Pix ensures the bundled suite is available at:
 
 ```text
@@ -185,7 +196,7 @@ Runtime requirements:
 
 - Optional npm package `vosk`. Pix installs or rebuilds it automatically with scripts enabled on first voice start if the native binding is missing.
 - A local recorder: SoX (`rec`/`sox`) preferred, or `ffmpeg`; Linux also supports `arecord`.
-- JetBrainsMono Nerd Font for default app icons. On macOS, Pix checks this at startup and can install the Homebrew cask `font-jetbrains-mono-nerd-font` when it is missing.
+- JetBrainsMono Nerd Font for default app icons. Pix checks this at startup and can install the font for the current user on macOS, Linux, and Windows when it is missing.
 
 If your terminal renders missing glyphs, start Pix with `PIX_USE_FALLBACK_ICONS=1` or set `iconTheme` to `fallback` in `~/.config/pi/pix.jsonc`.
 

package/bin/pix.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { existsSync, readdirSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const minimumNodeVersion = [22, 19, 0];
 const minimumNodeVersionLabel = "22.19.0";
+const launcherPath = fileURLToPath(import.meta.url);
+const packageRoot = dirname(dirname(launcherPath));
 const mainPath = fileURLToPath(new URL("../dist/main.js", import.meta.url));
 const updatePath = fileURLToPath(new URL("../dist/app/update.js", import.meta.url));
+const installPath = fileURLToPath(new URL("../dist/app/install.js", import.meta.url));
 const distPath = dirname(mainPath);
 const rawArgs = process.argv.slice(2);
 const childArgs = [];
@@ -40,6 +43,15 @@ if (childArgs[0] === "update") {
 	process.exit(await runPixUpdateCli(childArgs.slice(1)));
 }
 
+if (childArgs[0] === "install" || childArgs[0] === "setup") {
+	if (!existsSync(installPath)) {
+		console.error("pix install is not built yet. Run `npm run build:pix` or update from a published package.");
+		process.exit(1);
+	}
+	const { runPixInstallCli } = await import(new URL("../dist/app/install.js", import.meta.url));
+	process.exit(await runPixInstallCli(childArgs.slice(1), { env: pixChildEnv() }));
+}
+
 if (!existsSync(mainPath)) {
 	console.error("pix is not built yet. Run `npm run build:pix` or `npm run watch:pix`.");
 	process.exit(1);
@@ -82,6 +94,7 @@ function isCurrentNodeSupported() {
 function startChild() {
 	child = spawn(process.execPath, [mainPath, ...childArgs], {
 		stdio: "inherit",
+		env: pixChildEnv(),
 	});
 
 	child.on("error", (error) => {
@@ -103,6 +116,16 @@ function startChild() {
 	});
 }
 
+function pixChildEnv() {
+	const env = { ...process.env };
+	const bundledBinPath = join(packageRoot, "node_modules", ".bin");
+	if (existsSync(bundledBinPath)) {
+		env.PATH = [bundledBinPath, env.PATH ?? ""].filter(Boolean).join(delimiter);
+		env.PIX_BUNDLED_PI_BIN = bundledBinPath;
+	}
+	return env;
+}
+
 function startDistPolling() {
 	const pollInterval = Number(process.env.PIX_RELOAD_POLL_MS ?? 1000);
 	distPollTimer = setInterval(() => {

package/dist/app/app.js

@@ -493,7 +493,7 @@ export class PiUiExtendApp {
                 void this.tabsController.closeTab(tabId);
             },
             toastEntry: (toastId) => this.toastController.toast.entry(toastId),
-            showToast: (message, kind) => this.showToast(message, kind),
+            showToast: (message, kind, options) => this.showToast(message, kind, options),
             dismissToast: (toastId) => this.toastController.dismissToast(toastId),
             refreshModelUsageStatus: () => this.refreshModelUsageStatusFromClick(),
             toggleAllThinkingExpanded: () => {
@@ -842,8 +842,8 @@ export class PiUiExtendApp {
             this.showToast("Failed to refresh model usage limits", "error");
         });
     }
-    showToast(message, kind = "info") {
-        this.toastController.showToast(message, kind);
+    showToast(message, kind = "info", options) {
+        this.toastController.showToast(message, kind, options);
     }
     clearToastTimers() {
         this.toastController.clearToastTimers();

package/dist/app/cli.js

@@ -3,12 +3,14 @@ import { parseThemeName } from "../theme.js";
 export function usage() {
     return `Usage: pix [--cwd <path>] [--no-session] [--session <path>] [--theme dark|light] [--model <provider/model[:thinking]>]
 	       pix update [--check] [--force]
+	       pix install [--check]
 	       npm run dev -- [--cwd <path>] [--no-session] [--session <path>] [--theme dark|light] [--model <provider/model[:thinking]>]
 
 Examples:
 	  pix --cwd ../pi-mono
 	  pix --cwd ../pi-mono --theme light --model anthropic/claude-sonnet-4-20250514:medium
-	  pix update --check`;
+	  pix update --check
+	  pix install --check`;
 }
 export function parseArgs(argv) {
     let cwd = process.cwd();

package/dist/app/clipboard.d.ts

@@ -1 +1,3 @@
 export declare function copyTextToClipboard(text: string): void;
+export declare function clipboardSupportAvailable(env?: NodeJS.ProcessEnv): boolean;
+export declare function clipboardInstallHint(): string;

package/dist/app/clipboard.js

@@ -1,4 +1,6 @@
 import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
 export function copyTextToClipboard(text) {
     const commands = clipboardCommands();
     for (const [command, args] of commands) {
@@ -6,7 +8,24 @@ export function copyTextToClipboard(text) {
         if (!result.error && result.status === 0)
             return;
     }
-    throw new Error("No clipboard command found");
+    if (copyWithNativeClipboard(text))
+        return;
+    throw new Error(`No clipboard command found. ${clipboardInstallHint()}`);
+}
+export function clipboardSupportAvailable(env = process.env) {
+    if (clipboardCommands().some(([command]) => commandExists(command, env)))
+        return true;
+    return resolveNativeClipboardEntrypoint() !== undefined;
+}
+export function clipboardInstallHint() {
+    if (process.platform === "linux") {
+        return "Install wl-clipboard for Wayland or xclip/xsel for X11 (for example: sudo apt install wl-clipboard xclip xsel).";
+    }
+    if (process.platform === "darwin")
+        return "Install pbcopy or check macOS clipboard permissions.";
+    if (process.platform === "win32")
+        return "Install clip.exe or check Windows clipboard access.";
+    return "Install a platform clipboard command.";
 }
 function clipboardCommands() {
     switch (process.platform) {
@@ -19,6 +38,40 @@ function clipboardCommands() {
                 ["wl-copy", []],
                 ["xclip", ["-selection", "clipboard"]],
                 ["xsel", ["--clipboard", "--input"]],
+                ["termux-clipboard-set", []],
             ];
     }
 }
+function copyWithNativeClipboard(text) {
+    const entrypoint = resolveNativeClipboardEntrypoint();
+    if (!entrypoint)
+        return false;
+    const script = `
+		import { createRequire } from "node:module";
+		import { readFileSync } from "node:fs";
+		const require = createRequire(${JSON.stringify(import.meta.url)});
+		const clipboard = require(${JSON.stringify(entrypoint)});
+		await clipboard.setText(readFileSync(0, "utf8"));
+	`;
+    const result = spawnSync(process.execPath, ["--input-type=module", "-e", script], {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"],
+        timeout: 3_000,
+    });
+    return !result.error && result.status === 0;
+}
+function resolveNativeClipboardEntrypoint() {
+    try {
+        return require.resolve("@mariozechner/clipboard");
+    }
+    catch {
+        return undefined;
+    }
+}
+function commandExists(command, env) {
+    const names = process.platform === "win32" ? [command, command.replace(/\.exe$/iu, ".cmd"), command.replace(/\.exe$/iu, ".bat")] : [command];
+    return names.some((name) => spawnSync(process.platform === "win32" ? "where" : "sh", process.platform === "win32" ? [name] : ["-lc", `command -v ${shellQuote(name)}`], { env, stdio: "ignore" }).status === 0);
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/app/dcp-stats.js

@@ -1,22 +1,39 @@
 import { normalizeToolName, parseArgsText } from "../tool-renderers/utils.js";
+const NUDGE_TYPES = ["turn", "iteration", "context-soft", "context-strong"];
 export function formatDcpStatsToast(session) {
     const stats = collectDcpSessionStats(session);
-    const parts = [
-        `context ${formatContextUsage(stats)}`,
-        `freed ${formatCompactNumber(stats.tokensSaved)} tokens`,
-        `${stats.runs.toLocaleString()} ${plural(stats.runs, "run")}`,
-        stats.items > 0 ? `${stats.items.toLocaleString()} ${plural(stats.items, "item")}` : undefined,
-        stats.summaryTokens > 0 ? `${formatCompactNumber(stats.summaryTokens)} summary` : undefined,
-        stats.activeBlocks != null && stats.totalBlocks != null ? `blocks ${stats.activeBlocks}/${stats.totalBlocks}` : undefined,
-        stats.prunedTools > 0 ? `pruned ${stats.prunedTools.toLocaleString()} tools` : undefined,
-    ].filter((part) => Boolean(part));
-    return `DCP: ${parts.join(" · ")}`;
+    const nudgeStats = collectDcpNudgeStats(session);
+    const activeBlocks = stats.activeBlocks ?? 0;
+    const totalBlocks = stats.totalBlocks ?? stats.activeBlocks ?? 0;
+    const totalNudgeEvents = nudgeStats.emitted + nudgeStats.upgraded;
+    const activeAnchors = NUDGE_TYPES.reduce((sum, type) => sum + nudgeStats.activeByType[type], 0);
+    const lines = [
+        "DCP Session Statistics:",
+        `  Tokens saved (estimated): ${fmt(stats.tokensSaved)}`,
+        `  Total pruning operations: ${fmt(stats.totalPruneCount)}`,
+        `  Compression blocks active: ${activeBlocks} / ${totalBlocks} total`,
+        "  Manual mode: off",
+        "",
+        "Nudge telemetry:",
+        `  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.upgraded)} upgraded`,
+        `  By type: ${NUDGE_TYPES.map((type) => `${type}=${fmt(nudgeStats.byType[type])}`).join(", ")}`,
+        `  Active anchors: ${fmt(activeAnchors)}${activeAnchors > 0 ? ` (${NUDGE_TYPES.map((type) => `${type}=${fmt(nudgeStats.activeByType[type])}`).join(", ")})` : ""}`,
+        `  Cleared after compress: ${fmt(nudgeStats.clearedEvents)} time${nudgeStats.clearedEvents === 1 ? "" : "s"} (${fmt(nudgeStats.clearedAnchors)} anchor${nudgeStats.clearedAnchors === 1 ? "" : "s"})`,
+        `  Compliance proxy: ${fmt(nudgeStats.clearedEvents)} compress-after-nudge / ${fmt(totalNudgeEvents)} nudge event${totalNudgeEvents === 1 ? "" : "s"} (${pct(nudgeStats.clearedEvents, totalNudgeEvents)})`,
+        nudgeStats.last
+            ? `  Last nudge: ${nudgeStats.last.type} ${nudgeStats.last.event} at ${formatDate(nudgeStats.last.createdAt)} (${formatContextPercent(nudgeStats.last.contextPercent)})`
+            : "  Last nudge: none recorded",
+        "",
+        `Context: ${formatContextUsage(stats)}`,
+    ];
+    return lines.join("\n");
 }
 function collectDcpSessionStats(session) {
     const usage = session.getContextUsage();
     const stats = {
         runs: 0,
         tokensSaved: 0,
+        totalPruneCount: 0,
         items: 0,
         summaryTokens: 0,
         prunedTools: 0,
@@ -24,9 +41,15 @@ function collectDcpSessionStats(session) {
         ...(usage?.contextWindow != null ? { contextWindow: usage.contextWindow } : {}),
         ...(usage?.percent != null ? { contextPercent: usage.percent } : {}),
     };
-    for (const entry of session.sessionManager.getBranch()) {
+    const branch = session.sessionManager.getBranch();
+    const latestState = latestCustomEntryData(branch, "dcp-state");
+    if (latestState)
+        applyDcpStateStats(stats, latestState);
+    for (const entry of branch) {
         if (entry.type !== "message")
             continue;
+        if (latestState)
+            continue;
         const message = entry.message;
         if (message.role !== "toolResult")
             continue;
@@ -39,6 +62,7 @@ function collectDcpSessionStats(session) {
             continue;
         stats.runs += 1;
         stats.tokensSaved += numberValue(result.tokensSaved) ?? 0;
+        stats.totalPruneCount = Math.max(stats.totalPruneCount, numberValue(result.totalPruneCount) ?? 0);
         stats.items += numberValue(result.itemCount) ?? sumDefined(numberValue(result.ranges), numberValue(result.messages)) ?? 0;
         stats.summaryTokens += numberValue(result.totalSummaryTokens) ?? 0;
         stats.prunedTools += numberValue(result.prunedTools) ?? 0;
@@ -60,6 +84,91 @@ function collectDcpSessionStats(session) {
     }
     return stats;
 }
+function applyDcpStateStats(stats, data) {
+    stats.tokensSaved = numberValue(data.tokensSaved) ?? stats.tokensSaved;
+    stats.totalPruneCount = numberValue(data.totalPruneCount) ?? stats.totalPruneCount;
+    const blocks = Array.isArray(data.compressionBlocks) ? data.compressionBlocks : undefined;
+    if (blocks) {
+        stats.totalBlocks = blocks.length;
+        stats.activeBlocks = blocks.filter((block) => isRecord(block) && block.active !== false).length;
+    }
+    if (Array.isArray(data.prunedToolIds))
+        stats.prunedTools = data.prunedToolIds.length;
+}
+function collectDcpNudgeStats(session) {
+    const stats = {
+        emitted: 0,
+        upgraded: 0,
+        clearedEvents: 0,
+        clearedAnchors: 0,
+        byType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
+        activeByType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
+    };
+    const branch = session.sessionManager.getBranch();
+    const latestState = latestCustomEntryData(branch, "dcp-state");
+    if (latestState)
+        applyActiveAnchorStats(stats, latestState);
+    for (const entry of branch) {
+        const data = customEntryData(entry, "dcp-nudge");
+        if (!data)
+            continue;
+        const event = data.event;
+        if ((event === "emitted" || event === "upgraded") && isNudgeType(data.type)) {
+            if (event === "emitted")
+                stats.emitted += 1;
+            else
+                stats.upgraded += 1;
+            stats.byType[data.type] += 1;
+            const createdAt = numberValue(data.createdAt);
+            const contextPercent = typeof data.contextPercent === "number" || data.contextPercent === null ? data.contextPercent : undefined;
+            if (!stats.last || (createdAt ?? 0) >= (stats.last.createdAt ?? 0)) {
+                stats.last = {
+                    type: data.type,
+                    event,
+                    ...(createdAt !== undefined ? { createdAt } : {}),
+                    ...(contextPercent !== undefined ? { contextPercent } : {}),
+                };
+            }
+        }
+        else if (event === "cleared") {
+            stats.clearedEvents += 1;
+            stats.clearedAnchors += Math.max(0, numberValue(data.clearedAnchors) ?? 0);
+        }
+    }
+    return stats;
+}
+function applyActiveAnchorStats(stats, data) {
+    stats.activeByType = { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 };
+    const anchors = Array.isArray(data.nudgeAnchors) ? data.nudgeAnchors : [];
+    for (const anchor of anchors) {
+        if (isRecord(anchor) && isNudgeType(anchor.type))
+            stats.activeByType[anchor.type] += 1;
+    }
+    const last = isRecord(data.lastNudge) ? data.lastNudge : undefined;
+    if (last && isNudgeType(last.type) && !stats.last) {
+        const contextPercent = numberValue(last.contextPercent);
+        const createdAt = numberValue(last.createdAt);
+        stats.last = {
+            type: last.type,
+            event: "emitted",
+            ...(createdAt !== undefined ? { createdAt } : {}),
+            ...(contextPercent !== undefined ? { contextPercent: contextPercent * 100 } : {}),
+        };
+    }
+}
+function customEntryData(entry, customType) {
+    if (!isRecord(entry) || entry.type !== "custom" || entry.customType !== customType)
+        return undefined;
+    return isRecord(entry.data) ? entry.data : undefined;
+}
+function latestCustomEntryData(entries, customType) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const data = customEntryData(entries[i], customType);
+        if (data)
+            return data;
+    }
+    return undefined;
+}
 function parseToolResultText(content) {
     const parsed = parseArgsText(textContent(content));
     return isRecord(parsed) ? parsed : undefined;
@@ -87,6 +196,29 @@ function formatContextUsage(stats) {
         return `${percentText} of ${formatCompactNumber(window)}`;
     return percentText;
 }
+function isNudgeType(value) {
+    return typeof value === "string" && NUDGE_TYPES.includes(value);
+}
+function fmt(n) {
+    return Math.round(n).toLocaleString();
+}
+function pct(numerator, denominator) {
+    if (denominator <= 0)
+        return "n/a";
+    return `${((numerator / denominator) * 100).toFixed(1)}%`;
+}
+function formatDate(ts) {
+    if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0)
+        return "unknown time";
+    return new Date(ts).toLocaleString();
+}
+function formatContextPercent(value) {
+    if (value === null)
+        return "unknown context";
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return "unknown context";
+    return `${value.toFixed(1)}% context`;
+}
 function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
@@ -108,9 +240,6 @@ function formatPercent(value) {
 function trimDecimal(value) {
     return value.toFixed(1).replace(/\.0$/, "");
 }
-function plural(count, word) {
-    return count === 1 ? word : `${word}s`;
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/app/install.d.ts

@@ -0,0 +1,10 @@
+export type PixInstallCliOptions = {
+    checkOnly: boolean;
+    help: boolean;
+};
+export type PixInstallCliContext = {
+    env?: NodeJS.ProcessEnv;
+};
+export declare function pixInstallUsage(): string;
+export declare function parsePixInstallArgs(argv: readonly string[]): PixInstallCliOptions;
+export declare function runPixInstallCli(argv?: readonly string[], context?: PixInstallCliContext): Promise<number>;

package/dist/app/install.js

@@ -0,0 +1,135 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { FONT_FAMILY_NAME, installJetBrainsNerdFont, isJetBrainsNerdFontInstalled, } from "./nerd-font-controller.js";
+import { clipboardInstallHint, clipboardSupportAvailable } from "./clipboard.js";
+export function pixInstallUsage() {
+    return `Usage: pix install [--check]
+       pix setup [--check]
+
+Check and install Pix runtime helpers for this user.
+
+What it checks:
+  - ${FONT_FAMILY_NAME} icon font for Pix glyphs
+  - pi CLI availability, including Pix's bundled Pi dependency
+  - Linux clipboard helpers / native clipboard fallback
+
+Options:
+  --check    Only report missing helpers, do not install
+  -h, --help Show this help`;
+}
+export function parsePixInstallArgs(argv) {
+    let checkOnly = false;
+    let help = false;
+    for (const arg of argv) {
+        if (arg === "--check") {
+            checkOnly = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+            continue;
+        }
+        throw new Error(`Unknown pix install argument: ${arg}\n\n${pixInstallUsage()}`);
+    }
+    return { checkOnly, help };
+}
+export async function runPixInstallCli(argv = process.argv.slice(2), context = {}) {
+    let options;
+    try {
+        options = parsePixInstallArgs(argv);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    if (options.help) {
+        console.log(pixInstallUsage());
+        return 0;
+    }
+    const env = context.env ?? process.env;
+    let failures = 0;
+    console.log("Pix install checks");
+    if (await isJetBrainsNerdFontInstalled()) {
+        console.log(`✓ ${FONT_FAMILY_NAME} is installed`);
+    }
+    else if (options.checkOnly) {
+        console.log(`! ${FONT_FAMILY_NAME} is missing`);
+        failures += 1;
+    }
+    else {
+        try {
+            await installJetBrainsNerdFont();
+            console.log(`✓ Installed ${FONT_FAMILY_NAME}`);
+        }
+        catch (error) {
+            console.error(`✗ Failed to install ${FONT_FAMILY_NAME}: ${errorMessage(error)}`);
+            failures += 1;
+        }
+    }
+    const piCli = await resolvePiCliStatus(env);
+    if (piCli.available) {
+        console.log(`✓ pi CLI is available${piCli.detail ? ` (${piCli.detail})` : ""}`);
+    }
+    else if (options.checkOnly) {
+        console.log("! pi CLI is missing");
+        failures += 1;
+    }
+    else {
+        try {
+            await installPiCli();
+            console.log("✓ Installed pi CLI globally");
+        }
+        catch (error) {
+            console.error(`✗ Failed to install pi CLI: ${errorMessage(error)}`);
+            console.error("  Pix can still use its bundled SDK, but sub-agent helpers may need `pi` on PATH.");
+            failures += 1;
+        }
+    }
+    if (clipboardSupportAvailable(env)) {
+        console.log("✓ Clipboard support is available");
+    }
+    else {
+        console.log(`! Clipboard support is missing. ${clipboardInstallHint()}`);
+        if (process.platform === "linux")
+            failures += 1;
+    }
+    return failures === 0 ? 0 : 1;
+}
+async function resolvePiCliStatus(env) {
+    const bundledBin = env.PIX_BUNDLED_PI_BIN;
+    if (bundledBin && (existsSync(join(bundledBin, process.platform === "win32" ? "pi.cmd" : "pi")) || existsSync(join(bundledBin, "pi")))) {
+        return { available: true, detail: "bundled with Pix" };
+    }
+    if (commandExists("pi", env))
+        return { available: true, detail: "PATH" };
+    return { available: false };
+}
+async function installPiCli() {
+    await runRequired("npm", ["install", "-g", "--ignore-scripts", "--min-release-age=0", "@earendil-works/pi-coding-agent"]);
+}
+function commandExists(command, env = process.env) {
+    const pathValue = env.PATH ?? "";
+    const dirs = pathValue.split(process.platform === "win32" ? ";" : ":").filter(Boolean);
+    const names = process.platform === "win32" ? [command, `${command}.cmd`, `${command}.exe`, `${command}.bat`] : [command];
+    return dirs.some((dir) => names.some((name) => existsSync(join(dir, name))));
+}
+async function runRequired(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr = `${stderr}${chunk.toString("utf8")}`.slice(-800);
+        });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(stderr.trim() || `${command} exited with code ${code ?? "unknown"}`));
+        });
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/app/mouse-controller.d.ts

@@ -2,7 +2,7 @@ import type { AppCommandController } from "./command-controller.js";
 import type { ConversationViewport } from "./conversation-viewport.js";
 import type { EditorLayoutRenderer } from "./editor-layout-renderer.js";
 import type { ImageContent, InputEditor } from "../input-editor.js";
-import type { ToastEntry } from "../ui.js";
+import type { ToastEntry, ToastVariant } from "../ui.js";
 import type { AppPopupActionController } from "./popup-action-controller.js";
 import type { AppPopupMenuController } from "./popup-menu-controller.js";
 import type { AppScrollController } from "./scroll-controller.js";
@@ -50,7 +50,10 @@ export type AppMouseControllerHost = {
     switchToTab(tabId: string): void;
     closeTab(tabId: string): void;
     toastEntry(toastId: number): ToastEntry | undefined;
-    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info", options?: {
+        durationMs?: number;
+        variant?: ToastVariant;
+    }): void;
     dismissToast(toastId: number): void;
     refreshModelUsageStatus(): void | Promise<void>;
     toggleAllThinkingExpanded?(): void;
@@ -87,10 +90,7 @@ export declare class AppMouseController {
     } | {
         kind: "queue-message";
         id: string;
-    } | {
-        kind: "toast";
-        id: number;
-    } | undefined>;
+    } | import("./types.js").ToastLineTarget | undefined>;
     readonly renderedRowTexts: Map<number, string>;
     readonly renderedRowBackgrounds: Map<number, string>;
     readonly renderedImageTargets: Map<number, readonly ImageClickTarget[]>;

package/dist/app/mouse-controller.js

@@ -114,6 +114,10 @@ export class AppMouseController {
         if (event.button !== 0)
             return;
         if (target?.kind === "toast") {
+            if (!toastTargetContainsEvent(target, event))
+                return;
+            if (target.action === "body")
+                return;
             if (this.copyErrorToast(target.id)) {
                 this.showClickFlashForEvent(event);
                 return;
@@ -235,6 +239,14 @@ export class AppMouseController {
         const statusTarget = this.statusTargetAt(event);
         if (statusTarget)
             return statusTarget;
+        const toastTarget = this.renderedTargets.get(event.y);
+        if (toastTarget?.kind === "toast" && toastTargetContainsEvent(toastTarget, event)) {
+            return {
+                y: event.y,
+                startColumn: toastTarget.startColumn ?? event.x,
+                endColumn: toastTarget.endColumn ?? event.x + 1,
+            };
+        }
         if (this.renderedTargets.has(event.y)) {
             const bounds = nonBlankLineBounds(this.renderedRowTexts.get(event.y) ?? "", event.x);
             return { y: event.y, startColumn: bounds.startColumn, endColumn: bounds.endColumn };
@@ -469,7 +481,8 @@ export class AppMouseController {
         const session = this.host.runtimeSession();
         if (!session)
             return false;
-        this.host.showToast(formatDcpStatsToast(session), "info");
+        const message = formatDcpStatsToast(session);
+        this.host.showToast(message, "info", { variant: "dialog" });
         return true;
     }
     handleStatusModelUsageClick(event) {
@@ -910,6 +923,11 @@ export function screenSelectionLineText(row, text, startColumn, endColumn, input
 function sameConversationPoint(left, right) {
     return !!left && left.line === right.line && left.x === right.x;
 }
+function toastTargetContainsEvent(target, event) {
+    if (target.startColumn === undefined || target.endColumn === undefined)
+        return true;
+    return event.x >= target.startColumn && event.x < target.endColumn;
+}
 function displayCellsInColumnRange(text, startColumn, endColumn) {
     let cells = "";
     for (let column = startColumn; column < endColumn; column += 1) {

package/dist/app/nerd-font-controller.d.ts

@@ -2,6 +2,9 @@ export type NerdFontInstallHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
 };
+export declare const FONT_FAMILY_NAME = "JetBrainsMono Nerd Font Mono";
+export declare const FONT_FILE_NAME = "JetBrainsMonoNerdFontMono-Regular.ttf";
+export declare const FONT_DOWNLOAD_URL = "https://raw.githubusercontent.com/ryanoasis/nerd-fonts/master/patched-fonts/JetBrainsMono/Ligatures/Regular/JetBrainsMonoNerdFontMono-Regular.ttf";
 export declare class NerdFontController {
     private readonly host;
     private ensureStarted;
@@ -9,3 +12,6 @@ export declare class NerdFontController {
     ensureInstalledOnStartup(): void;
     private ensureInstalled;
 }
+export declare function isJetBrainsNerdFontInstalled(): Promise<boolean>;
+export declare function installJetBrainsNerdFont(): Promise<string>;
+export declare function userFontInstallPath(): string;

package/dist/app/nerd-font-controller.js

@@ -1,8 +1,12 @@
 import { spawn, spawnSync } from "node:child_process";
-import { readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 const CASK_NAME = "font-jetbrains-mono-nerd-font";
+export const FONT_FAMILY_NAME = "JetBrainsMono Nerd Font Mono";
+export const FONT_FILE_NAME = "JetBrainsMonoNerdFontMono-Regular.ttf";
+export const FONT_DOWNLOAD_URL = "https://raw.githubusercontent.com/ryanoasis/nerd-fonts/master/patched-fonts/JetBrainsMono/Ligatures/Regular/JetBrainsMonoNerdFontMono-Regular.ttf";
 const FONT_FILE_PATTERN = /(?:JetBrainsMono|JetBrains).*Nerd.*\.(?:ttf|otf)$/iu;
 export class NerdFontController {
     host;
@@ -19,17 +23,9 @@ export class NerdFontController {
     async ensureInstalled() {
         if (await isJetBrainsNerdFontInstalled())
             return;
-        if (process.platform !== "darwin") {
-            this.host.showToast("Nerd Font is missing; auto-install is only configured for macOS Homebrew", "warning");
-            return;
-        }
-        if (!commandExists("brew")) {
-            this.host.showToast("Nerd Font is missing; install Homebrew or JetBrainsMono Nerd Font manually", "warning");
-            return;
-        }
         this.host.showToast("Installing JetBrainsMono Nerd Font…", "info");
         try {
-            await runBrewInstall();
+            await installJetBrainsNerdFont();
             if (await isJetBrainsNerdFontInstalled()) {
                 this.host.showToast("JetBrainsMono Nerd Font installed", "success");
             }
@@ -45,18 +41,89 @@ export class NerdFontController {
         }
     }
 }
-async function isJetBrainsNerdFontInstalled() {
+export async function isJetBrainsNerdFontInstalled() {
     if (commandExists("brew") && spawnSync("brew", ["list", "--cask", CASK_NAME], { stdio: "ignore" }).status === 0)
         return true;
-    const fontDirs = [join(homedir(), "Library", "Fonts"), "/Library/Fonts", "/System/Library/Fonts"];
+    if (process.platform === "linux" && commandExists("fc-match")) {
+        const result = spawnSync("fc-match", ["-f", "%{family}", FONT_FAMILY_NAME], { encoding: "utf8" });
+        if (result.status === 0 && /JetBrains.*Nerd/iu.test(result.stdout))
+            return true;
+    }
+    const fontDirs = platformFontDirs();
     for (const dir of fontDirs) {
+        if (await directoryContainsFont(dir))
+            return true;
+    }
+    return false;
+}
+export async function installJetBrainsNerdFont() {
+    if (process.platform === "darwin" && commandExists("brew")) {
+        await runBrewInstall();
+        return CASK_NAME;
+    }
+    const targetPath = userFontInstallPath();
+    await mkdir(dirname(targetPath), { recursive: true });
+    const response = await fetch(FONT_DOWNLOAD_URL, {
+        headers: { "User-Agent": "pix-font-installer" },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok)
+        throw new Error(`download failed with HTTP ${response.status}`);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.length < 100_000)
+        throw new Error("downloaded font is unexpectedly small");
+    await writeFile(targetPath, bytes);
+    if (process.platform === "linux")
+        runOptionalCommand("fc-cache", ["-f", dirname(targetPath)]);
+    if (process.platform === "win32")
+        registerWindowsUserFont(targetPath);
+    return targetPath;
+}
+export function userFontInstallPath() {
+    switch (process.platform) {
+        case "darwin":
+            return join(homedir(), "Library", "Fonts", FONT_FILE_NAME);
+        case "win32":
+            return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "Microsoft", "Windows", "Fonts", FONT_FILE_NAME);
+        default:
+            return join(homedir(), ".local", "share", "fonts", "pix", FONT_FILE_NAME);
+    }
+}
+function platformFontDirs() {
+    switch (process.platform) {
+        case "darwin":
+            return [join(homedir(), "Library", "Fonts"), "/Library/Fonts", "/System/Library/Fonts"];
+        case "win32":
+            return [
+                join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "Microsoft", "Windows", "Fonts"),
+                join(process.env.WINDIR ?? "C:\\Windows", "Fonts"),
+            ];
+        default:
+            return [join(homedir(), ".local", "share", "fonts"), join(homedir(), ".fonts"), "/usr/local/share/fonts", "/usr/share/fonts"];
+    }
+}
+async function directoryContainsFont(root) {
+    if (!existsSync(root))
+        return false;
+    const pending = [{ dir: root, depth: 0 }];
+    let scanned = 0;
+    while (pending.length > 0 && scanned < 5_000) {
+        const current = pending.pop();
+        if (!current)
+            continue;
+        let entries;
         try {
-            const files = await readdir(dir);
-            if (files.some((file) => FONT_FILE_PATTERN.test(file)))
-                return true;
+            entries = await readdir(current.dir, { withFileTypes: true });
         }
         catch {
-            // Ignore unreadable/missing font directories.
+            continue;
+        }
+        for (const entry of entries) {
+            scanned += 1;
+            if (entry.isFile() && FONT_FILE_PATTERN.test(entry.name))
+                return true;
+            if (entry.isDirectory() && current.depth < 4)
+                pending.push({ dir: join(current.dir, entry.name), depth: current.depth + 1 });
         }
     }
     return false;
@@ -80,6 +147,20 @@ async function runBrewInstall() {
         });
     });
 }
+function registerWindowsUserFont(fontPath) {
+    const escapedPath = fontPath.replaceAll("'", "''");
+    const escapedName = `${FONT_FAMILY_NAME} (TrueType)`.replaceAll("'", "''");
+    runOptionalCommand("powershell.exe", [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        `New-Item -Path 'HKCU:\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts' -Force | Out-Null; New-ItemProperty -Path 'HKCU:\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts' -Name '${escapedName}' -Value '${escapedPath}' -PropertyType String -Force | Out-Null`,
+    ]);
+}
+function runOptionalCommand(command, args) {
+    spawnSync(command, args, { stdio: "ignore" });
+}
 function commandExists(command) {
     if (process.platform === "win32")
         return spawnSync("where", [command], { stdio: "ignore" }).status === 0;

package/dist/app/render-controller.js

@@ -243,10 +243,11 @@ export class AppRenderController {
         }
         for (const toastOverlay of renderToastOverlays(this.deps.toastController.toast.visibleStates, columns, Math.max(0, statusRow - topReservedRows - 1), this.deps.theme)) {
             const row = topReservedRows + toastOverlay.row;
-            this.deps.mouseController.renderedTargets.set(row, { kind: "toast", id: toastOverlay.id });
-            this.deps.mouseController.renderedRowTexts.set(row, toastOverlay.text);
-            setRenderedBackground(row, this.deps.theme.colors.toastBackground);
-            appendFrameOutput(regionForOverlayRow(row), row, this.renderFrameRow(row, toastOverlay.output));
+            const rowText = this.deps.mouseController.renderedRowTexts.get(row) ?? "";
+            if (toastOverlay.target)
+                this.deps.mouseController.renderedTargets.set(row, toastOverlay.target);
+            this.deps.mouseController.renderedRowTexts.set(row, overlayText(rowText, toastOverlay.column, toastOverlay.text));
+            appendFrameOutput(regionForOverlayRow(row), row, `\x1b[${row};${toastOverlay.column}H${toastOverlay.output}`);
         }
         if (topReservedRows === 0) {
             const newTabTarget = tabLayout.targets.find((target) => target.kind === "new-tab");

package/dist/app/startup-checks.js

@@ -14,7 +14,7 @@ export async function checkPiCliAvailability(pathValue = process.env.PATH ?? "")
         return [];
     return [{
             kind: "error",
-            message: "pi CLI is not available on PATH. Install pi or add it to PATH before starting pix.",
+            message: "pi CLI is not available on PATH. Run `pix install` or add pi to PATH before starting pix.",
         }];
 }
 export function checkPiToolsSuiteExtensionAvailability(extensionsResult) {
@@ -34,13 +34,16 @@ export function checkPiToolsSuiteExtensionAvailability(extensionsResult) {
 }
 async function executableExistsOnPath(command, pathValue) {
     const dirs = pathValue.split(delimiter).filter((part) => part.length > 0);
+    const names = process.platform === "win32" ? [command, `${command}.cmd`, `${command}.exe`, `${command}.bat`] : [command];
     for (const dir of dirs) {
-        try {
-            await access(join(dir, command), fsConstants.X_OK);
-            return true;
-        }
-        catch {
-            // Keep scanning PATH entries.
+        for (const name of names) {
+            try {
+                await access(join(dir, name), fsConstants.X_OK);
+                return true;
+            }
+            catch {
+                // Keep scanning PATH entries.
+            }
         }
     }
     return false;

package/dist/app/toast-controller.d.ts

@@ -1,4 +1,4 @@
-import { Toast, type ToastKind } from "../ui.js";
+import { Toast, type ToastKind, type ToastVariant } from "../ui.js";
 export type AppToastControllerHost = {
     render(): void;
 };
@@ -7,7 +7,10 @@ export declare class AppToastController {
     readonly toast: Toast;
     private readonly timers;
     constructor(host: AppToastControllerHost);
-    showToast(message: string, kind?: ToastKind): void;
+    showToast(message: string, kind?: ToastKind, options?: {
+        durationMs?: number;
+        variant?: ToastVariant;
+    }): void;
     dismissToast(toastId: number): void;
     clearToastTimers(): void;
 }

package/dist/app/toast-controller.js

@@ -7,17 +7,20 @@ export class AppToastController {
     constructor(host) {
         this.host = host;
     }
-    showToast(message, kind = "info") {
-        const toastId = this.toast.show(message, kind);
-        if (kind === "error") {
+    showToast(message, kind = "info", options = {}) {
+        const toastId = this.toast.show(message, kind, options.variant ? { variant: options.variant } : {});
+        if (kind === "error" || options.variant === "dialog") {
             this.host.render();
             return;
         }
+        const durationMs = typeof options.durationMs === "number" && Number.isFinite(options.durationMs) && options.durationMs > 0
+            ? Math.floor(options.durationMs)
+            : TOAST_DURATION_MS;
         const timer = setTimeout(() => {
             this.toast.hide(toastId);
             this.timers.delete(toastId);
             this.host.render();
-        }, TOAST_DURATION_MS);
+        }, durationMs);
         this.timers.set(toastId, timer);
         timer.unref();
         this.host.render();

package/dist/app/toast-renderer.d.ts

@@ -1,9 +1,12 @@
 import { type Theme } from "../theme.js";
 import type { ToastEntry } from "../ui.js";
+import type { ToastLineTarget } from "./types.js";
 export type ToastOverlay = {
     id: number;
     row: number;
+    column: number;
     text: string;
     output: string;
+    target?: ToastLineTarget;
 };
 export declare function renderToastOverlays(states: readonly ToastEntry[], width: number, maxRows: number, theme: Theme): ToastOverlay[];

package/dist/app/toast-renderer.js

@@ -9,6 +9,10 @@ export function renderToastOverlays(states, width, maxRows, theme) {
     for (const state of [...states].reverse()) {
         if (overlays.length >= maxRows)
             break;
+        if (state.variant === "dialog") {
+            overlays.push(...renderDialogToastOverlay(state, width, Math.max(0, maxRows - overlays.length), theme, overlays.length));
+            continue;
+        }
         const icon = toastKindIcon(state.kind);
         const lines = toastMessageLines(state.message, icon, Math.max(1, width - 6));
         const visibleLines = lines.slice(0, Math.max(0, maxRows - overlays.length));
@@ -17,19 +21,22 @@ export function renderToastOverlays(states, width, maxRows, theme) {
         const contentWidth = Math.max(...visibleLines.map((line) => stringDisplayWidth(line)));
         const toastWidth = Math.min(Math.max(12, contentWidth + 2), Math.max(1, width - 4));
         const leftWidth = Math.max(0, width - toastWidth - 2);
-        const rightWidth = Math.max(0, width - leftWidth - toastWidth);
+        const column = leftWidth + 1;
         for (const line of visibleLines) {
             const message = ` ${padOrTrimPlain(line, Math.max(0, toastWidth - 2))} `;
-            const text = `${" ".repeat(leftWidth)}${padOrTrimPlain(message, toastWidth)}${" ".repeat(rightWidth)}`;
-            const output = [
-                colorLine("", leftWidth, { background: theme.colors.background }),
-                colorLine(message, toastWidth, {
-                    ...toastKindStyle(state.kind, theme),
-                    bold: true,
-                }),
-                colorLine("", rightWidth, { background: theme.colors.background }),
-            ].join("");
-            overlays.push({ id: state.id, row: overlays.length + 1, text, output });
+            const text = padOrTrimPlain(message, toastWidth);
+            const output = colorLine(message, toastWidth, {
+                ...toastKindStyle(state.kind, theme),
+                bold: true,
+            });
+            overlays.push({
+                id: state.id,
+                row: overlays.length + 1,
+                column,
+                text,
+                output,
+                target: { kind: "toast", id: state.id, action: "toast", startColumn: column, endColumn: column + toastWidth },
+            });
         }
     }
     return overlays;
@@ -53,6 +60,60 @@ function toastMessageLines(message, icon, maxWidth) {
     }
     return lines.length > 0 ? lines : [firstPrefix.trimEnd()];
 }
+function renderDialogToastOverlay(state, width, maxRows, theme, rowOffset) {
+    if (maxRows <= 0 || width <= 0)
+        return [];
+    const maxDialogWidth = Math.max(1, Math.min(width - 4, 72));
+    const icon = toastKindIcon(state.kind);
+    const closeLabel = `[${APP_ICONS.close}]`;
+    const wrappedLines = dialogMessageLines(state.message, Math.max(1, maxDialogWidth - 4));
+    const title = `${icon} Dialog`;
+    const requiredWidth = Math.max(16, stringDisplayWidth(` ${title} ${closeLabel} `) + 2, ...wrappedLines.map((line) => stringDisplayWidth(line) + 4));
+    const dialogWidth = Math.min(maxDialogWidth, Math.max(16, requiredWidth));
+    const bodyWidth = Math.max(1, dialogWidth - 4);
+    const bodyLines = dialogMessageLines(state.message, bodyWidth);
+    const bodyRows = Math.max(0, maxRows - 2);
+    const visibleBodyLines = bodyLines.slice(0, bodyRows);
+    const includeBottom = maxRows > 1;
+    const dialogRows = [
+        dialogTopLine(title, closeLabel, dialogWidth),
+        ...visibleBodyLines.map((line) => `│ ${padOrTrimPlain(line, bodyWidth)} │`),
+        ...(includeBottom ? [`╰${"─".repeat(Math.max(0, dialogWidth - 2))}╯`] : []),
+    ].slice(0, maxRows);
+    const leftWidth = Math.max(0, width - dialogWidth - 2);
+    const column = leftWidth + 1;
+    const style = toastKindStyle(state.kind, theme);
+    const closeStartColumn = column + 1 + dialogTopCloseOffset(title, closeLabel, dialogWidth);
+    const closeEndColumn = closeStartColumn + stringDisplayWidth(closeLabel);
+    return dialogRows.map((text, index) => ({
+        id: state.id,
+        row: rowOffset + index + 1,
+        column,
+        text,
+        output: colorLine(text, dialogWidth, { ...style, bold: true }),
+        target: index === 0
+            ? { kind: "toast", id: state.id, action: "close", startColumn: closeStartColumn, endColumn: closeEndColumn }
+            : { kind: "toast", id: state.id, action: "body", startColumn: column, endColumn: column + dialogWidth },
+    }));
+}
+function dialogMessageLines(message, maxWidth) {
+    const safeMaxWidth = Math.max(1, maxWidth);
+    const lines = sanitizeText(message).split("\n").flatMap((line) => wrapDisplayLine(line, safeMaxWidth));
+    return lines.length > 0 ? lines : [""];
+}
+function dialogTopLine(title, closeLabel, width) {
+    const innerWidth = Math.max(0, width - 2);
+    const closeOffset = dialogTopCloseOffset(title, closeLabel, width);
+    const leftLabel = ` ${title} `;
+    const spacer = " ".repeat(Math.max(0, closeOffset - stringDisplayWidth(leftLabel)));
+    return `╭${padOrTrimPlain(`${leftLabel}${spacer}${closeLabel} `, innerWidth)}╮`;
+}
+function dialogTopCloseOffset(title, closeLabel, width) {
+    const innerWidth = Math.max(0, width - 2);
+    const leftLabel = ` ${title} `;
+    const closeWidth = stringDisplayWidth(closeLabel);
+    return Math.max(stringDisplayWidth(leftLabel), innerWidth - closeWidth - 1);
+}
 function toastKindIcon(kind) {
     switch (kind) {
         case "success":

package/dist/app/types.d.ts

@@ -227,10 +227,14 @@ export type RenderedLine = {
     } | {
         kind: "queue-message";
         id: string;
-    } | {
-        kind: "toast";
-        id: number;
-    };
+    } | ToastLineTarget;
+};
+export type ToastLineTarget = {
+    kind: "toast";
+    id: number;
+    action?: "toast" | "body" | "close";
+    startColumn?: number;
+    endColumn?: number;
 };
 export type ImageClickTarget = {
     start: number;

package/dist/ui.d.ts

@@ -28,9 +28,11 @@ export declare class PopupMenu<T> {
 }
 export declare const TOAST_KINDS: readonly ["success", "error", "warning", "info"];
 export type ToastKind = (typeof TOAST_KINDS)[number];
+export type ToastVariant = "compact" | "dialog";
 export type ToastState = {
     message: string;
     kind: ToastKind;
+    variant?: ToastVariant;
 };
 export type ToastEntry = ToastState & {
     id: number;
@@ -47,7 +49,9 @@ export declare function isToastKind(value: unknown): value is ToastKind;
 export declare class Toast {
     private readonly entries;
     private nextId;
-    show(message: string, kind?: ToastKind): number;
+    show(message: string, kind?: ToastKind, options?: {
+        variant?: ToastVariant;
+    }): number;
     hide(id?: number): void;
     get state(): ToastState | undefined;
     get visibleStates(): readonly ToastEntry[];

package/dist/ui.js

@@ -60,10 +60,10 @@ export function isToastKind(value) {
 export class Toast {
     entries = [];
     nextId = 1;
-    show(message, kind = "info") {
+    show(message, kind = "info", options = {}) {
         const id = this.nextId;
         this.nextId += 1;
-        this.entries.push({ id, message, kind, createdAt: Date.now() });
+        this.entries.push({ id, message, kind, createdAt: Date.now(), ...(options.variant ? { variant: options.variant } : {}) });
         return id;
     }
     hide(id) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "private": false,
   "type": "module",
   "bin": {