@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/terminal-title.mjs

@@ -0,0 +1,186 @@
+/**
+ * Terminal tab/window title management for the TUI.
+ *
+ * Terminals label their tab from the window title, which an application sets
+ * with an OSC 0 sequence; without one the tab shows the process name ("node").
+ * The title text is untrusted display content (session names arrive through
+ * events and user input), so it is sanitized before emission: control
+ * characters and bidi/invisible formatting codepoints are stripped, whitespace
+ * runs collapse to single spaces, and the result is bounded. Clearing writes
+ * an empty OSC payload and the terminal falls back to its own default; the
+ * previously set title is not portable to read back and is never restored.
+ *
+ * @module @deepseek-ai/dsh-code/terminal-title
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { useLayoutEffect, useRef } from 'react';
+import { useStdout } from 'ink';
+/** The host process title at module load, restored on unmount. On Windows
+ * this reaches the tab through SetConsoleTitleW (ConPTY reflects it to VS
+ * Code and friends without any user setting); on POSIX it becomes the ps
+ * name. Node replaces the argv memory, so the original must be saved before
+ * the first assignment. */
+const initialProcessTitle = process.title;
+/** Tab label before a session carries a name. */
+export const DEFAULT_TERMINAL_TITLE = 'deepseek';
+/** Practical upper bound on title length, in visible characters: long enough
+ * for session names, short enough for tab bars and window managers. */
+export const MAX_TERMINAL_TITLE_CHARS = 240;
+/** Control characters, DEL/C1 range, and bidi or invisible formatting
+ * codepoints that could terminate the OSC sequence or visually reorder the
+ * title relative to its underlying text. */
+const DISALLOWED_TITLE_CHARS = /[\u0000-\u001F\u007F-\u009F\u00AD\u034F\u061C\u180E\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/;
+/** Normalize untrusted title text into one bounded display line: disallowed
+ * codepoints dropped, whitespace runs collapsed to single spaces, leading and
+ * trailing whitespace removed, length bounded. */
+export function sanitizeTerminalTitle(text) {
+    const chars = [];
+    let pendingSpace = false;
+    for (const ch of text) {
+        if (DISALLOWED_TITLE_CHARS.test(ch))
+            continue;
+        if (ch.trim() === '') {
+            if (chars.length > 0)
+                pendingSpace = true;
+            continue;
+        }
+        if (pendingSpace) {
+            if (chars.length + 1 >= MAX_TERMINAL_TITLE_CHARS)
+                break;
+            chars.push(' ');
+            pendingSpace = false;
+        }
+        if (chars.length >= MAX_TERMINAL_TITLE_CHARS)
+            break;
+        chars.push(ch);
+    }
+    return chars.join('');
+}
+/** Build one OSC 0 title sequence. An empty sanitized title yields an empty
+ * string: emitting nothing is distinct from clearing, which is a separate
+ * policy decision made by the caller. */
+export function terminalTitleSequence(text) {
+    const title = sanitizeTerminalTitle(text);
+    return title === '' ? '' : `\x1b]0;${title}\x07`;
+}
+/** Clear the managed title with an empty OSC payload; the terminal falls back
+ * to its own default label. */
+export function clearTerminalTitleSequence() {
+    return '\x1b]0;\x07';
+}
+/**
+ * Resolve the VS Code stable user-settings file for one platform and
+ * environment: `%APPDATA%` on Windows, the bundle data folder on macOS (NOT
+ * XDG `~/.config` — VS Code never reads that path there, so writing it
+ * silently no-ops and the tab kept showing the process name "node"), and
+ * XDG config on Linux.
+ */
+export function vscodeSettingsPath(platform, env) {
+    const windows = platform === 'win32';
+    const darwin = platform === 'darwin';
+    const base = windows ? env['APPDATA'] : env['HOME'];
+    if (base === undefined || base === '')
+        return undefined;
+    return windows
+        ? join(base, 'Code', 'User', 'settings.json')
+        : darwin
+            ? join(base, 'Library', 'Application Support', 'Code', 'User', 'settings.json')
+            : join(base, '.config', 'Code', 'User', 'settings.json');
+}
+/** VS Code renders an application-set tab title only when
+ * "terminal.integrated.tabs.title" maps to the sequence variable; the editor
+ * default shows the process name instead ("node" for a Node CLI). Inside a VS
+ * Code integrated terminal, align the user settings once: if the key is
+ * absent, insert it and keep a one-shot backup of the original file. A value
+ * the user already set is never overwritten, an unparseable file is never
+ * touched, and every failure degrades to a no-op - the OSC and process-title
+ * channels keep working everywhere else. */
+export function ensureVsCodeTabTitleSetting(options = {}) {
+    const env = options.env ?? process.env;
+    if (env['TERM_PROGRAM'] !== 'vscode')
+        return { wrote: false, reason: 'not-vscode' };
+    if ((options.isTTY ?? process.stdout.isTTY) !== true)
+        return { wrote: false, reason: 'not-vscode' };
+    let file = options.settingsFile;
+    if (file === undefined) {
+        const resolved = vscodeSettingsPath(process.platform, env);
+        if (resolved === undefined)
+            return { wrote: false, reason: 'error' };
+        file = resolved;
+    }
+    try {
+        if (!existsSync(file)) {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, '{\n  "terminal.integrated.tabs.title": "${sequence}"\n}\n', 'utf8');
+            return { wrote: true };
+        }
+        const text = readFileSync(file, 'utf8');
+        if (text.includes('"terminal.integrated.tabs.title"'))
+            return { wrote: false, reason: 'key-present' };
+        try {
+            JSON.parse(text);
+        }
+        catch {
+            return { wrote: false, reason: 'unparseable' };
+        }
+        const close = text.lastIndexOf('}');
+        if (close < 0)
+            return { wrote: false, reason: 'unparseable' };
+        const before = text.slice(0, close);
+        const trimmedBefore = before.replace(/[ \t\r\n]+$/, '');
+        const tail = before.slice(trimmedBefore.length);
+        const needsComma = trimmedBefore.trim() !== '' && !trimmedBefore.trimEnd().endsWith('{');
+        const inserted = (needsComma ? ',' : '') + '\n    "terminal.integrated.tabs.title": "${sequence}"\n';
+        writeFileSync(file + '.dsh-backup', text, 'utf8');
+        writeFileSync(file, trimmedBefore + inserted + tail + text.slice(close), 'utf8');
+        return { wrote: true };
+    }
+    catch {
+        return { wrote: false, reason: 'error' };
+    }
+}
+/**
+ * Keep the terminal tab label on `title` (sanitized; empty titles leave the
+ * current label alone). Two delivery channels run in parallel: the OSC 0
+ * sequence to stdout, and the host process title. Writes are deduplicated by
+ * title, and on unmount the managed title is cleared and the process title
+ * restored so the host shell regains its default label.
+ */
+export function useTerminalTitle(title, options = {}) {
+    const { clearOnUnmount = true } = options;
+    const { stdout } = useStdout();
+    const writtenRef = useRef(undefined);
+    const processTitleRef = useRef(false);
+    // Layout effects: the clear must run synchronously at unmount (passive
+    // cleanups are not flushed synchronously when Ink tears the tree down).
+    useLayoutEffect(() => {
+        if (stdout === undefined)
+            return undefined;
+        return () => {
+            if (processTitleRef.current) {
+                processTitleRef.current = false;
+                process.title = initialProcessTitle;
+            }
+            if (clearOnUnmount && writtenRef.current !== undefined)
+                stdout.write(clearTerminalTitleSequence());
+        };
+    }, [stdout, clearOnUnmount]);
+    useLayoutEffect(() => {
+        if (stdout === undefined)
+            return;
+        if (title === writtenRef.current)
+            return;
+        const sequence = terminalTitleSequence(title);
+        if (sequence === '')
+            return;
+        stdout.write(sequence);
+        // The process title is the second delivery channel: on Windows it drives
+        // the console title that ConPTY reflects onto the tab without any user
+        // setting, where the OSC channel alone only shows once the host maps
+        // "terminal.integrated.tabs.title" to the sequence variable.
+        process.title = sanitizeTerminalTitle(title);
+        processTitleRef.current = true;
+        writtenRef.current = title;
+    }, [stdout, title]);
+}

package/vendor/tui/lib/theme-panel.mjs

@@ -0,0 +1,60 @@
+/**
+ * The `/theme` picker (the Codex `/theme` contract): one bounded list over
+ * the three color themes — dark, light, and auto (terminal-sensed; auto
+ * falls back to dark until OSC-11 detection lands). Enter applies the row
+ * and the runner persists it; Esc closes without changing the theme.
+ *
+ * @module @deepseek-ai/dsh-tui/theme-panel
+ */
+import { createElement, useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { clampScroll, panelViewport } from './render/inspector.mjs';
+import { truncateColumns } from './render/text.mjs';
+import { panelAccent } from './panel-accent.mjs';
+import { getPalette, inkColor, THEMES } from './theme.mjs';
+import { t } from './i18n.mjs';
+/**
+ * The /theme list: one row per theme, the current one marked with ●, the
+ * focused one with ›. Enter applies the focused theme (the runner persists
+ * it), Esc/q closes without changing anything. Colors read the ACTIVE
+ * palette, so the panel itself adapts to a light theme once applied.
+ */
+export function ThemePanel({ current, select, close }) {
+    const [cursor, setCursor] = useState(() => {
+        const index = THEMES.findIndex(theme => theme.id === current);
+        return index < 0 ? 0 : index;
+    });
+    const stdout = useStdout().stdout;
+    const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+    useInput((input, key) => {
+        if (key.escape || input === 'q')
+            return close();
+        if (key.upArrow)
+            return setCursor(value => (value + THEMES.length - 1) % THEMES.length);
+        if (key.downArrow)
+            return setCursor(value => (value + 1) % THEMES.length);
+        if (key.return)
+            return select(THEMES[cursor].id);
+    });
+    if (viewport.maxHeight === 0 || viewport.compact) {
+        return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('theme.compact'), viewport.contentColumns));
+    }
+    // The theme rows share the panel's body budget like every other panel: an
+    // unsliced three-row list reached terminal-height equality on short
+    // terminals, where Ink rewrites the whole Static region every frame.
+    // Reveal-cursor slicing keeps the focused row visible instead.
+    const rowBudget = Math.max(1, viewport.bodyRows);
+    const first = clampScroll(cursor, THEMES.length, rowBudget);
+    const visibleThemes = THEMES.slice(first, first + rowBudget);
+    const hiddenThemes = THEMES.length - visibleThemes.length;
+    const accent = panelAccent('theme', getPalette().dim, getPalette().brandBright);
+    return createElement(Box, { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(accent.border), flexDirection: 'column', paddingX: 1 }, createElement(Text, { color: inkColor(accent.title), wrap: 'truncate-end' }, truncateColumns(t('theme.title'), viewport.contentColumns)), ...visibleThemes.map((theme, index) => {
+        const selected = first + index === cursor;
+        const active = theme.id === current;
+        return createElement(Text, {
+            key: theme.id,
+            color: selected ? inkColor(getPalette().brandBright) : undefined,
+            wrap: 'truncate-end',
+        }, truncateColumns(`${selected ? '› ' : '  '}${active ? '● ' : '○ '}${t(`theme.${theme.id}.label`)}${active ? ` · ${t('theme.current')}` : ''} · ${t(`theme.${theme.id}.description`)}`, viewport.contentColumns));
+    }), createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(`↑↓ choose · enter apply · esc/q close${hiddenThemes > 0 ? ` · +${hiddenThemes} more` : ''}`, viewport.contentColumns)));
+}

package/vendor/tui/lib/theme.mjs

@@ -0,0 +1,379 @@
+/**
+ * Terminal color tokens for the dsh TUI, mapped from the product design
+ * platform's DeepSeek palette
+ * (`packages/client/ui-theme/src/styles/design-platform.css`). Truecolor RGB
+ * rides chalk, which degrades automatically on terminals without truecolor.
+ *
+ * Three palettes — `dark` (the default), `light`, and `prismatic` (the
+ * neon synthwave skin) — share the same token keys with different values.
+ * Painters and the palette accessor read the ACTIVE
+ * palette selected through {@link setTheme}, so a theme switch recolors every
+ * painted surface on the next render without touching call sites; consumers
+ * read colors through {@link getPalette} or the painters below only.
+ *
+ * @module @deepseek-ai/dsh-tui/theme
+ */
+import chalk from 'chalk';
+import { rainbowRoll } from './rainbow.mjs';
+/** Valid theme names in canonical picker order. */
+export const THEME_NAMES = ['dark', 'light', 'prismatic', 'rainbow', 'auto'];
+/**
+ * Every theme's picker metadata in canonical order — the single source the
+ * /theme panel rows derive from; {@link THEME_NAMES} stays the validation
+ * list. Adding a theme means adding its palette plus one row here.
+ */
+export const THEMES = [
+    { id: 'dark', label: 'dark', description: 'DeepSeek dark palette (default)' },
+    { id: 'light', label: 'light', description: 'light palette for bright terminals' },
+    { id: 'prismatic', label: 'prismatic', description: 'neon synthwave palette (violet/magenta/cyan)' },
+    { id: 'rainbow', label: 'rainbow', description: 'randomized carnival palette (/rainbow to reroll)' },
+    { id: 'auto', label: 'auto', description: 'follow the terminal; dark until detection lands' },
+];
+/**
+ * DeepSeek dark palette: the original TUI colors, one entry per
+ * design-platform token in use. Keep names and values in sync with the CSS
+ * custom properties cited inline.
+ */
+export const DARK_PALETTE = {
+    /** Primary brand blue — `--dsw-static-deepseek-500`. */
+    brand: [65, 118, 230],
+    /** Brighter brand blue for live/streaming emphasis — `--dsw-static-deepseek-400`. */
+    brandBright: [103, 158, 254],
+    /** Intermediate brand blue between brand and brandBright — `--dsw-static-deepseek-450`. */
+    brandMid: [86, 134, 254],
+    /** Deep brand blue for secondary chrome — `--dsw-static-deepseek-600`. */
+    brandDeep: [72, 104, 178],
+    /** Muted caption gray — `--dsw-static-neutral-bluish-600`. */
+    dim: [129, 133, 140],
+    /** Success green — `--dsw-static-green-500`. */
+    success: [34, 197, 94],
+    /** Error red — `--dsw-static-red-500`. */
+    error: [239, 68, 68],
+    /** Warning amber — `--dsw-static-amber-500`. */
+    warn: [245, 158, 11],
+    /** Default foreground text — `--dsw-static-neutral-50`. */
+    text: [236, 240, 246],
+    /** Inline/fenced code — soft sky blue, distinct from brand accents. */
+    code: [125, 211, 252],
+    /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+    composerBand: [46, 48, 52],
+    /** Diff added-line background — Codex's muted dark green tint (#213A2B). */
+    diffAdd: [33, 58, 43],
+    /** Diff removed-line background — Codex's muted dark red tint (#4A221D). */
+    diffDel: [74, 34, 29],
+    /** Diff added-line foreground — green-500, 5.4:1 on the diffAdd tint. */
+    diffAddFg: [34, 197, 94],
+    /** Diff removed-line foreground — red-400, 4.9:1 on the diffDel tint (error's red-500 sinks to 3.6:1 on it). */
+    diffDelFg: [248, 113, 113],
+    /** Terminal background this palette is designed against; row tints blend toward it. */
+    surface: [0, 0, 0],
+    /**
+     * The three prompt-row colors, one per delivery kind. They are the palette's
+     * own accents (bright brand, warning amber, violet) rather than fixed RGBs,
+     * and every row's bar is these colors laid over {@link surface}.
+     */
+    prompt: [103, 158, 254],
+    queued: [245, 158, 11],
+    steered: [167, 139, 250],
+};
+/**
+ * Light palette tuned for white terminals: the same token keys as dark with
+ * contrast-driven values (AA on a white background). Brand keeps its dark
+ * value (≈4.2:1 on white — reserved for bold/accent spans; body-size brand
+ * text uses brandBright at ≈5.4:1); the bright/mid/deep blues, muted grays,
+ * and status colors deepen so they stay legible on bright backgrounds.
+ */
+export const LIGHT_PALETTE = {
+    /** Primary brand blue — unchanged design-platform value; ≈4.2:1 on white, so bold/accent spans only (body-size brand text uses brandBright). */
+    brand: [65, 118, 230],
+    /** Brighter brand blue deepened for white backgrounds (was 2.7:1). */
+    brandBright: [72, 104, 178],
+    /** Intermediate brand blue — Tailwind blue-500. */
+    brandMid: [59, 130, 246],
+    /** Deep brand blue for secondary chrome — `--dsw-static-deepseek-700`. */
+    brandDeep: [47, 76, 143],
+    /** Muted caption gray deepened for white backgrounds. */
+    dim: [101, 103, 107],
+    /** Success green — Tailwind green-700. */
+    success: [21, 128, 61],
+    /** Error red — Tailwind red-600. */
+    error: [236, 19, 19],
+    /** Warning amber — Tailwind amber-700. */
+    warn: [180, 83, 9],
+    /** Default foreground text — near-black. */
+    text: [21, 21, 23],
+    /** Inline/fenced code — Tailwind cyan-700, distinct from brand accents. */
+    code: [14, 116, 144],
+    /** Composer three-row band base — neutral light gray, hue-free so wave tints read on it. */
+    composerBand: [229, 231, 235],
+    /** Diff added-line background — GitHub's pastel green (#dafbe1), Codex's light pick. */
+    diffAdd: [218, 251, 225],
+    /** Diff removed-line background — GitHub's pastel red (#ffebe9), Codex's light pick. */
+    diffDel: [255, 235, 233],
+    /** Diff added-line foreground — green-800, 6.4:1 on the pastel tint (green-700 clears 4.5:1 by a hair). */
+    diffAddFg: [22, 101, 52],
+    /** Diff removed-line foreground — red-700, 5.6:1 on the pastel tint (error's red-600 is 3.9:1). */
+    diffDelFg: [185, 28, 28],
+    /** Terminal background this palette is designed against; row tints blend toward it. */
+    surface: [255, 255, 255],
+    /**
+     * Prompt-row colors deepened for white: the amber and violet the dark theme
+     * uses sit at the AA edge on their own pastel bars, so each kind carries a
+     * value that clears 4.5:1 both on the bar and on plain white.
+     */
+    prompt: [47, 76, 143],
+    queued: [124, 53, 10],
+    steered: [109, 40, 217],
+};
+/**
+ * Prismatic palette — the neon synthwave skin (docs/prismatic-theme-design.md):
+ * electric violet replaces the brand blues, neon fuchsia carries live
+ * emphasis, neon cyan paints code, and a lavender gray dims captions. Paints
+ * on a black terminal; every value meets the same WCAG thresholds as the
+ * other palettes (body tokens ≥4.5:1, accents ≥3:1 on pure black). Semantic
+ * colors — success/error/warn and the four diff tokens — reuse the dark
+ * values verbatim so green still means added and red still means removed.
+ */
+export const PRISMATIC_PALETTE = {
+    /** Primary electric purple — violet-500 (#8B5CF6), 5.0:1 on black. */
+    brand: [139, 92, 246],
+    /** Live/streaming emphasis — neon fuchsia-300 (#F0ABFC), 11.9:1 on black. */
+    brandBright: [240, 171, 252],
+    /** Intermediate violet — violet-400 (#A78BFA), 7.7:1 on black. */
+    brandMid: [167, 139, 250],
+    /** Deep secondary chrome — violet-600 (#7C3AED), 3.7:1 on black (violet-700 misses 3:1). */
+    brandDeep: [124, 58, 237],
+    /** Muted captions — lavender gray (#A6A3B8), 8.6:1 on black. */
+    dim: [166, 163, 184],
+    /** Success green — unchanged from dark. */
+    success: [34, 197, 94],
+    /** Error red — unchanged from dark. */
+    error: [239, 68, 68],
+    /** Warning amber — unchanged from dark. */
+    warn: [245, 158, 11],
+    /** Default foreground text — white with a lavender cast (#F0EEF9). */
+    text: [240, 238, 249],
+    /** Inline/fenced code — neon cyan-300 (#67E8F9), 14.5:1 on black. */
+    code: [103, 232, 249],
+    /** Composer three-row band base — neutral dark gray, hue-free so wave tints read on it. */
+    composerBand: [46, 46, 52],
+    /** Diff added-line background — unchanged from dark. */
+    diffAdd: [33, 58, 43],
+    /** Diff removed-line background — unchanged from dark. */
+    diffDel: [74, 34, 29],
+    /** Diff added-line foreground — unchanged from dark. */
+    diffAddFg: [34, 197, 94],
+    /** Diff removed-line foreground — unchanged from dark. */
+    diffDelFg: [248, 113, 113],
+    /** Terminal background this palette is designed against; row tints blend toward it. */
+    surface: [0, 0, 0],
+    /** Prompt rows in the skin's own neon: fuchsia, amber, cyan. */
+    prompt: [240, 171, 252],
+    queued: [245, 158, 11],
+    steered: [103, 232, 249],
+};
+/**
+ * Every STATIC palette by theme name; auto resolves through {@link resolveTheme}
+ * and rainbow is rolled per launch ({@link rainbowRoll}), so neither lives
+ * here — {@link setTheme} resolves both through the same key space.
+ */
+export const PALETTES = {
+    dark: DARK_PALETTE,
+    light: LIGHT_PALETTE,
+    prismatic: PRISMATIC_PALETTE,
+};
+/** The theme name in force (the requested name; 'auto' included). */
+let activeName = 'dark';
+/** The palette painters and {@link getPalette} read for the active theme. */
+let activePalette = DARK_PALETTE;
+/**
+ * Resolve a theme name to the palette actually in use. `auto` detection
+ * (OSC 11 terminal background query) is a later enhancement; until it lands,
+ * auto falls back to the dark palette (prismatic and rainbow are always
+ * explicit choices, never auto-resolved).
+ * @param name - the requested theme name.
+ * @returns 'dark', 'light', 'prismatic', or 'rainbow' — the palette key.
+ */
+export function resolveTheme(name) {
+    return name === 'light' ? 'light' : name === 'prismatic' ? 'prismatic' : name === 'rainbow' ? 'rainbow' : 'dark';
+}
+/**
+ * Switch the active theme: painters and {@link getPalette} reflect the new
+ * palette from the next render onward. The default is dark, so a process
+ * that never calls this paints exactly as before.
+ * @param name - the theme to activate ('auto' resolves to dark for now).
+ */
+export function setTheme(name) {
+    activeName = name;
+    const resolved = resolveTheme(name);
+    activePalette = resolved === 'rainbow' ? rainbowRoll().palette : PALETTES[resolved];
+}
+/**
+ * The theme name in force. Returns the requested name ('auto' included) so
+ * the /theme picker and persistence can round-trip the user's choice; the
+ * palette actually used is {@link getPalette}.
+ */
+export function getTheme() {
+    return activeName;
+}
+/** The palette in force; theme-aware call sites read colors through it. */
+export function getPalette() {
+    return activePalette;
+}
+/**
+ * Parse a persisted theme name: only names in {@link THEME_NAMES} survive;
+ * anything else (missing, corrupt, or unknown) falls back to the dark default.
+ * @param value - the raw parsed JSON value (expected string).
+ * @returns a valid theme name.
+ */
+export function parseThemeName(value) {
+    return typeof value === 'string' && THEME_NAMES.includes(value)
+        ? value
+        : 'dark';
+}
+/** Ink `color` string for one RGB triple. */
+export function inkColor(triple) {
+    return `rgb(${triple[0]}, ${triple[1]}, ${triple[2]})`;
+}
+/**
+ * Diff-line background as an Ink `backgroundColor` string, theme-aware and
+ * depth-gated (the Codex diff renderer's rule): 16-color terminals paint
+ * backgrounds from the saturated system palette, which drowns the text, so
+ * they keep the foreground-only look; 256-color and truecolor terminals get
+ * the palette's tint (chalk quantizes the RGB form down automatically).
+ * @param token - which diff background, added or removed lines.
+ * @returns the Ink background color, or undefined to paint foreground-only.
+ */
+export function diffBackground(token) {
+    if (chalk.level < 2)
+        return undefined;
+    return inkColor(activePalette[token]);
+}
+/** How far one prompt-row tint leans toward its color, over the surface. */
+const PROMPT_ROW_TINT = 0.22;
+/**
+ * The color family one prompt row wears, chosen by how it was delivered: the
+ * ordinary brand accent, the warning amber for a queued prompt, and the
+ * palette's own third accent for a steered one. The bar behind it is derived
+ * from that same color, so every theme — including a freshly rolled rainbow —
+ * carries its own look instead of a fixed triple.
+ * @param delivery - how the prompt was delivered; undefined is an ordinary one.
+ * @returns the palette token whose color paints the row.
+ */
+export function promptRowTokens(delivery) {
+    if (delivery === 'queued')
+        return { fg: 'queued' };
+    if (delivery === 'steered')
+        return { fg: 'steered' };
+    return { fg: 'prompt' };
+}
+/**
+ * Blended prompt-row background for one row color: the palette color laid
+ * over the surface the palette is designed for (dark themes over black, light
+ * over white), depth-gated exactly like {@link diffBackground} — a 16-color
+ * terminal keeps the foreground-only look rather than painting a saturated
+ * system background behind the text.
+ * @param color - the row's palette token.
+ * @returns the Ink background color, or undefined to paint foreground-only.
+ */
+export function rowBackground(color) {
+    if (chalk.level < 2)
+        return undefined;
+    const surface = activePalette.surface;
+    const tint = activePalette[color];
+    const blend = (index) => Math.round(surface[index] + (tint[index] - surface[index]) * PROMPT_ROW_TINT);
+    return inkColor([blend(0), blend(1), blend(2)]);
+}
+/**
+ * The prismatic surface ring: four neon accents panels cycle through by
+ * mount order (cyan → fuchsia → violet → lime), all ≥3:1 on black. Dark and
+ * light ignore the ring — {@link surfaceAccent} falls back to the passed-in
+ * base color so those themes stay pixel-identical.
+ */
+export const ACCENT_RING = [
+    [34, 211, 238],
+    [232, 121, 249],
+    [167, 139, 250],
+    [163, 230, 53],
+];
+/**
+ * The prismatic flow anchors: brand violet → neon fuchsia → neon cyan. All
+ * three clear 4.5:1 on black, so a flowing foreground stays AA throughout
+ * the oscillation (render/animations.ts walks the triangle).
+ */
+export const FLOW_ANCHORS = [
+    [139, 92, 246],
+    [232, 121, 249],
+    [34, 211, 238],
+];
+/**
+ * Whether the active theme is prismatic (the neon skin with surface rings
+ * and flowing accents).
+ */
+export function isPrismatic() {
+    return activeName === 'prismatic';
+}
+/** Whether the active theme is rainbow (the per-launch carnival roll). */
+export function isRainbow() {
+    return activeName === 'rainbow';
+}
+/**
+ * The flowing theme's anchor walk: prismatic rides the fixed violet→fuchsia→
+ * cyan triangle; rainbow rides its rolled full-spectrum anchors with a random
+ * phase; dark and light have no flow (undefined) and keep static accents.
+ */
+export function themeFlow() {
+    if (isPrismatic())
+        return { anchors: FLOW_ANCHORS, phaseMs: 0 };
+    if (isRainbow()) {
+        const roll = rainbowRoll();
+        return { anchors: roll.flowAnchors, phaseMs: roll.flowPhaseMs };
+    }
+    return undefined;
+}
+/**
+ * The accent for one surface slot: prismatic rotates the {@link ACCENT_RING}
+ * by slot index; every other theme gets the caller's base color back.
+ * @param index - the slot's position in the mount-order sequence.
+ * @param base - the color to use outside prismatic (the surface's usual one).
+ * @returns the accent to paint the surface's border/title with.
+ */
+export function surfaceAccent(index, base) {
+    if (isPrismatic()) {
+        const ring = ACCENT_RING;
+        return ring[((index % ring.length) + ring.length) % ring.length];
+    }
+    if (isRainbow()) {
+        const ring = rainbowRoll().ring;
+        return ring[((index % ring.length) + ring.length) % ring.length];
+    }
+    return base;
+}
+/** Paint with the primary brand blue: whale, wordmark, tool names, accents. */
+export function brand(text) {
+    return chalk.rgb(...activePalette.brand)(text);
+}
+/** Paint with the bright brand blue: streaming output and active spinners. */
+export function brandBright(text) {
+    return chalk.rgb(...activePalette.brandBright)(text);
+}
+/** Paint with the deep brand blue: borders and secondary chrome. */
+export function brandDeep(text) {
+    return chalk.rgb(...activePalette.brandDeep)(text);
+}
+/** Paint muted captions, hints, and meta lines. */
+export function dim(text) {
+    return chalk.rgb(...activePalette.dim)(text);
+}
+/** Paint completed tool results and confirmations. */
+export function success(text) {
+    return chalk.rgb(...activePalette.success)(text);
+}
+/** Paint failures and error entries. */
+export function error(text) {
+    return chalk.rgb(...activePalette.error)(text);
+}
+/** Paint warnings. */
+export function warn(text) {
+    return chalk.rgb(...activePalette.warn)(text);
+}