deck-plugin-sdk 1.2.0 → 1.5.0

package/types/core/fileview.d.ts

@@ -0,0 +1,35 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** The view showing `path` in plugin `pluginId`'s pane view. */
+export declare const fileView: (pluginId: string, path: string) => string;
+/** A view id's own part, and the file it was opened on if any. */
+export declare function splitView(view: string): {
+    base: string;
+    file?: string;
+};
+/**
+ * What two views are compared by, so one file is one tab however its path was spelled: the file
+ * tree, a terminal link and Quick Open can each give the same file with other slashes or case
+ * (Windows paths are case-insensitive). The stored view keeps the path as given, for the title.
+ */
+export declare function viewKey(view: string): string;
+/** A path's extension, lowercased with its dot (".pdf"), or "" when it has none. */
+export declare const extOf: (path: string) => string;
+/** The last part of a path, for a tab's title. */
+export declare const fileName: (path: string) => string;
+/** Extensions as a plugin wrote them (".pdf", "PDF", "pdf"), as extOf returns them. */
+export declare const normaliseExts: (exts: unknown) => string[];
+/**
+ * Which loaded plugin opens which file types, from each plugin's `opens` export. Filled by the
+ * plugin loader (plugins.ts) on every load; here so that anything can ask without importing it.
+ */
+export declare const fileOpeners: {
+    id: string;
+    exts: string[];
+}[];
+/** The id of the plugin that opens `path` (by its extension), or undefined: the Editor's. */
+export declare function pluginForFile(path: string): string | undefined;
+/**
+ * Open `path` in the plugin that claims its type, as a tab of its own. False when no plugin does,
+ * so the caller opens it in the Editor as before. Every way Deck opens a file asks this first.
+ */
+export declare function openWithPlugin(path: string): boolean;

package/types/core/lsp.d.ts

@@ -1,193 +1,195 @@
-// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-import { monaco } from "./monaco";
-/** How to launch the server — passed straight to Rust, which implements the strategies. */
-interface ServerSpec {
-    /** "path" | "node-module" | "exe-search" — see resolve_server() in lsp.rs. */
-    strategy: string;
-    command?: string;
-    module?: string;
-    args?: string[];
-    /** How to install the server, for the Install button in Settings › Languages. */
-    install?: Install;
-}
-/**
- * What to install for a server or a debugger, as one of a few kinds Deck turns into a command
- * itself (tools.rs): a definition from the registry never names a command to run.
- */
-export type InstallSpec = {
-    kind: "pip" | "npm";
-    packages: string[];
-} | {
-    kind: "github-release";
-    name: string;
-    repo: string;
-    tag: string;
-    asset: string;
-    sha256: string;
-};
-/** A structured install, or a sentence for what Deck cannot install itself (an SDK). */
-export type Install = InstallSpec | string;
-/** An install as one sentence, for where a button would not fit or there is nothing to run. */
-export declare function installText(i: Install): string;
-/** Whether Deck can run it (an Install button), rather than only describe it. */
-export declare const canInstall: (i: Install | undefined) => i is InstallSpec;
-/** A language's server or debugger install entry, if its definition has one. */
-export declare function installFor(languageId: string, what: "server" | "debug"): Install | undefined;
-/** A language's debug adapter, or null when its definition names none (or there is no such language). */
-export declare function debugAdapterFor(languageId: string): {
-    adapter: ServerSpec;
-    type: string;
-    rootMarker: string;
-    launch?: Record<string, unknown>;
-    launchUnless?: string;
-    install?: Install;
-} | null;
-/**
- * Whether a language's debug adapter runs on this machine: starts it and sees whether it is still
- * running a moment later. Resolves to what was run, rejects with why not (the adapter's first line
- * of output: Python's "No module named debugpy", Node's "Cannot find module"). Null when the
- * language names no adapter.
- */
-export declare function probeDebugger(languageId: string): Promise<string | null>;
-/**
- * Load every language definition from %APPDATA%\Deck\languages.
- *
- * This is the ONLY source of languages. Deck used to compile a few in from src/languages/, which
- * meant the shipped ones and a user's own obeyed different rules — one needed a rebuild to
- * change, the other a restart, and only the first could carry snippets. Now there is one kind of
- * language definition, and Deck ships none: an empty folder means Monaco's own highlighting and
- * no language server, which is a coherent state rather than a broken one.
- *
- * Never rejects. A language that fails to load is one language that does not work; it is not a
- * reason for the editor not to start, and the same contract loadPlugins states.
- */
-export declare function loadExternalLanguages(): Promise<void>;
-/** One language, as Settings lists it. Flattened from its LangDef — the panel shows what a
- *  definition claims, not the definition itself. */
-export interface LoadedLanguage {
-    languageId: string;
-    serverId: string;
-    extensions: string[];
-    rootMarker: string;
-    strategy: string;
-    /** The command or node module the strategy will look for. */
-    command: string;
-    /** The folder it came from, which is the name to look for on disk. */
-    folder: string;
-    /** language.json's version, or "" when it has none (a pack from before versions). */
-    version: string;
-    /** Its lucide icon name and colour from language.json; "" when it names none. */
-    icon: string;
-    color: string;
-    snippets?: number;
-}
-export interface LanguageError {
-    folder: string;
-    message: string;
-}
-/** Every language definition that loaded. */
-export declare function loadedLanguages(): readonly LoadedLanguage[];
-/**
- * Re-read the languages folder whenever it changes on disk. Called once at startup.
- *
- * What makes installing a language from the registry take effect without a restart, the same way
- * the plugin watcher does for a plugin. Debounced: writing a definition and its snippets emits
- * several events, and each would otherwise re-read the whole folder.
- *
- * Only NEW definitions and changed data are picked up. A language whose server is already
- * running keeps that session — lsp.rs owns it, and restarting one because a snippet file changed
- * would lose whatever it had analysed.
- */
-export declare function watchLanguages(): void;
-/**
- * Whether a language's server is actually installed, without opening a file of that type.
- *
- * Until this existed, a definition naming a server you do not have was only discoverable by
- * opening such a file and reading the error — so "Python needs basedpyright installed" was
- * something Deck knew and never said.
- *
- * `root` is optional and usually empty: a node module resolves from the project's node_modules
- * first, so a check with no project answers "is it installed globally".
- */
-export declare function probeLanguage(languageId: string, root?: string): Promise<string>;
-/**
- * Folders that failed to load, and why.
- *
- * The point of surfacing these: a definition with a typo is otherwise completely silent — the
- * language simply does not work, with nothing on screen to say a file was even read.
- */
-export declare function languageErrors(): readonly LanguageError[];
-export declare function lspSupports(languageId: string): boolean;
-export type LspPhase = "starting" | "ready" | "error" | "stopped";
-export interface LspStatus {
-    id: string;
-    serverId: string;
-    root: string;
-    phase: LspPhase;
-    detail: string;
-    log: string[];
-}
-/** React hook: current LSP server statuses (for the editor indicator). */
-export declare function useLspStatus(): LspStatus[];
-export declare function lspErrorVersion(): number;
-/** Live path -> error count. Read after subscribing to changes with subscribeLspErrors. */
-export declare function lspErrorCounts(): Map<string, number>;
-export declare function subscribeLspErrors(cb: () => void): () => void;
-/** Notify the server a document is open. Call when a file tab opens. */
-export declare function lspOpenDoc(path: string, content: string, root: string): Promise<void>;
-/**
- * Notify the server a document changed. Call for EVERY Monaco change, synchronously — no
- * debounce.
- *
- * Under incremental sync each notification describes one edit relative to the server's current
- * copy, so dropping or reordering any of them desynchronizes the document permanently. That is
- * also why this is no longer debounced: a debounce necessarily drops intermediate states, which
- * is only legal when every message carries the whole file. Sending immediately has the better
- * property anyway — completion and hover fire on the keystroke, so under the old 300ms debounce
- * they queried a server whose buffer was up to 300ms stale and answered for a position that did
- * not exist there yet.
- *
- * `changes` comes straight from Monaco's content-change event. Its ranges are in pre-edit
- * coordinates and it orders them end-of-document first, which is exactly what LSP expects for a
- * sequentially-applied batch: applying a later-in-document edit never shifts an earlier range.
- * Do not sort them.
- */
-export declare function lspChangeDoc(path: string, content: string, root: string, changes?: readonly monaco.editor.IModelContentChange[]): Promise<void>;
-/** Notify the server a document closed. Call when a tab closes. */
-export declare function lspCloseDoc(path: string, root: string): Promise<void>;
-/** One result of a project-wide symbol search (Ctrl+T). `line` and `col` are 1-based. */
-export interface ProjectSymbol {
-    name: string;
-    kind: number;
-    container: string;
-    path: string;
-    line: number;
-    col: number;
-}
-/**
- * Classes, functions and the rest whose name matches `query`, from every language server running
- * for `root` (a TypeScript and a Python server can share one), each server's own ranking kept and
- * the lists joined. Only servers already running answer: Ctrl+T does not start one. [] for an
- * empty query.
- */
-export declare function workspaceSymbols(root: string, query: string): Promise<ProjectSymbol[]>;
-/** A file's outline from its language server, or [] when no server has it open. Also what the
- *  debugger's inline values use to find the function a frame is in. */
-export declare function documentSymbols(model: monaco.editor.ITextModel): Promise<monaco.languages.DocumentSymbol[]>;
-type OpenFileHandler = (path: string, line: number, column: number) => void;
-export declare function setLspOpenFileHandler(fn: OpenFileHandler): void;
-/** Stop the servers no project has touched for IDLE_STOP_MS. Exported for the check. */
-export declare function stopIdleServers(now?: number): string[];
-/** Stop all sessions (e.g. on workspace close). */
-export declare function lspStopAll(): void;
-/** Restart one server (UI action from the status popover). */
-/**
- * Stop a language server. The next file opened for that root starts a fresh one, which is why
- * this is both the Restart action and the memory readout's stop button — there is no difference
- * between the two beyond what the caller says about it.
- *
- * Deleting the frontend session alongside the process matters: leaving it would send didOpen to
- * a dead pipe on the next open, and the editor would sit at "ready" with no diagnostics.
- */
-export declare function lspRestart(id: string): Promise<void>;
-export {};
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { monaco } from "./monaco";
+/** How to launch the server — passed straight to Rust, which implements the strategies. */
+interface ServerSpec {
+    /** "path" | "node-module" | "exe-search" — see resolve_server() in lsp.rs. */
+    strategy: string;
+    command?: string;
+    module?: string;
+    args?: string[];
+    /** How to install the server, for the Install button in Settings › Languages. */
+    install?: Install;
+}
+/**
+ * What to install for a server or a debugger, as one of a few kinds Deck turns into a command
+ * itself (tools.rs): a definition from the registry never names a command to run.
+ */
+export type InstallSpec = {
+    kind: "pip" | "npm";
+    packages: string[];
+} | {
+    kind: "github-release";
+    name: string;
+    repo: string;
+    tag: string;
+    asset: string;
+    sha256: string;
+};
+/** A structured install, or a sentence for what Deck cannot install itself (an SDK). */
+export type Install = InstallSpec | string;
+/** An install as one sentence, for where a button would not fit or there is nothing to run. */
+export declare function installText(i: Install): string;
+/** Whether Deck can run it (an Install button), rather than only describe it. */
+export declare const canInstall: (i: Install | undefined) => i is InstallSpec;
+/** A language's server or debugger install entry, if its definition has one. */
+export declare function installFor(languageId: string, what: "server" | "debug"): Install | undefined;
+/** A language's debug adapter, or null when its definition names none (or there is no such language). */
+export declare function debugAdapterFor(languageId: string): {
+    adapter: ServerSpec;
+    type: string;
+    rootMarker: string;
+    launch?: Record<string, unknown>;
+    launchUnless?: string;
+    install?: Install;
+} | null;
+/**
+ * Whether a language's debug adapter runs on this machine: starts it and sees whether it is still
+ * running a moment later. Resolves to what was run, rejects with why not (the adapter's first line
+ * of output: Python's "No module named debugpy", Node's "Cannot find module"). Null when the
+ * language names no adapter.
+ */
+export declare function probeDebugger(languageId: string): Promise<string | null>;
+/**
+ * Load every language definition from %APPDATA%\Deck\languages.
+ *
+ * This is the ONLY source of languages. Deck used to compile a few in from src/languages/, which
+ * meant the shipped ones and a user's own obeyed different rules — one needed a rebuild to
+ * change, the other a restart, and only the first could carry snippets. Now there is one kind of
+ * language definition, and Deck ships none: an empty folder means Monaco's own highlighting and
+ * no language server, which is a coherent state rather than a broken one.
+ *
+ * Never rejects. A language that fails to load is one language that does not work; it is not a
+ * reason for the editor not to start, and the same contract loadPlugins states.
+ */
+export declare function loadExternalLanguages(): Promise<void>;
+/** One language, as Settings lists it. Flattened from its LangDef — the panel shows what a
+ *  definition claims, not the definition itself. */
+export interface LoadedLanguage {
+    languageId: string;
+    serverId: string;
+    extensions: string[];
+    rootMarker: string;
+    strategy: string;
+    /** The command or node module the strategy will look for. */
+    command: string;
+    /** The folder it came from, which is the name to look for on disk. */
+    folder: string;
+    /** language.json's version, or "" when it has none (a pack from before versions). */
+    version: string;
+    /** Its lucide icon name and colour from language.json; "" when it names none. */
+    icon: string;
+    color: string;
+    snippets?: number;
+}
+export interface LanguageError {
+    folder: string;
+    message: string;
+}
+export declare function subscribeLanguages(fn: () => void): () => void;
+export declare function languagesVersion(): number;
+/** Every language definition that loaded. */
+export declare function loadedLanguages(): readonly LoadedLanguage[];
+/**
+ * Re-read the languages folder whenever it changes on disk. Called once at startup.
+ *
+ * What makes installing a language from the registry take effect without a restart, the same way
+ * the plugin watcher does for a plugin. Debounced: writing a definition and its snippets emits
+ * several events, and each would otherwise re-read the whole folder.
+ *
+ * Only NEW definitions and changed data are picked up. A language whose server is already
+ * running keeps that session — lsp.rs owns it, and restarting one because a snippet file changed
+ * would lose whatever it had analysed.
+ */
+export declare function watchLanguages(): void;
+/**
+ * Whether a language's server is actually installed, without opening a file of that type.
+ *
+ * Until this existed, a definition naming a server you do not have was only discoverable by
+ * opening such a file and reading the error — so "Python needs basedpyright installed" was
+ * something Deck knew and never said.
+ *
+ * `root` is optional and usually empty: a node module resolves from the project's node_modules
+ * first, so a check with no project answers "is it installed globally".
+ */
+export declare function probeLanguage(languageId: string, root?: string): Promise<string>;
+/**
+ * Folders that failed to load, and why.
+ *
+ * The point of surfacing these: a definition with a typo is otherwise completely silent — the
+ * language simply does not work, with nothing on screen to say a file was even read.
+ */
+export declare function languageErrors(): readonly LanguageError[];
+export declare function lspSupports(languageId: string): boolean;
+export type LspPhase = "starting" | "ready" | "error" | "stopped";
+export interface LspStatus {
+    id: string;
+    serverId: string;
+    root: string;
+    phase: LspPhase;
+    detail: string;
+    log: string[];
+}
+/** React hook: current LSP server statuses (for the editor indicator). */
+export declare function useLspStatus(): LspStatus[];
+export declare function lspErrorVersion(): number;
+/** Live path -> error count. Read after subscribing to changes with subscribeLspErrors. */
+export declare function lspErrorCounts(): Map<string, number>;
+export declare function subscribeLspErrors(cb: () => void): () => void;
+/** Notify the server a document is open. Call when a file tab opens. */
+export declare function lspOpenDoc(path: string, content: string, root: string): Promise<void>;
+/**
+ * Notify the server a document changed. Call for EVERY Monaco change, synchronously — no
+ * debounce.
+ *
+ * Under incremental sync each notification describes one edit relative to the server's current
+ * copy, so dropping or reordering any of them desynchronizes the document permanently. That is
+ * also why this is no longer debounced: a debounce necessarily drops intermediate states, which
+ * is only legal when every message carries the whole file. Sending immediately has the better
+ * property anyway — completion and hover fire on the keystroke, so under the old 300ms debounce
+ * they queried a server whose buffer was up to 300ms stale and answered for a position that did
+ * not exist there yet.
+ *
+ * `changes` comes straight from Monaco's content-change event. Its ranges are in pre-edit
+ * coordinates and it orders them end-of-document first, which is exactly what LSP expects for a
+ * sequentially-applied batch: applying a later-in-document edit never shifts an earlier range.
+ * Do not sort them.
+ */
+export declare function lspChangeDoc(path: string, content: string, root: string, changes?: readonly monaco.editor.IModelContentChange[]): Promise<void>;
+/** Notify the server a document closed. Call when a tab closes. */
+export declare function lspCloseDoc(path: string, root: string): Promise<void>;
+/** One result of a project-wide symbol search (Ctrl+T). `line` and `col` are 1-based. */
+export interface ProjectSymbol {
+    name: string;
+    kind: number;
+    container: string;
+    path: string;
+    line: number;
+    col: number;
+}
+/**
+ * Classes, functions and the rest whose name matches `query`, from every language server running
+ * for `root` (a TypeScript and a Python server can share one), each server's own ranking kept and
+ * the lists joined. Only servers already running answer: Ctrl+T does not start one. [] for an
+ * empty query.
+ */
+export declare function workspaceSymbols(root: string, query: string): Promise<ProjectSymbol[]>;
+/** A file's outline from its language server, or [] when no server has it open. Also what the
+ *  debugger's inline values use to find the function a frame is in. */
+export declare function documentSymbols(model: monaco.editor.ITextModel): Promise<monaco.languages.DocumentSymbol[]>;
+type OpenFileHandler = (path: string, line: number, column: number) => void;
+export declare function setLspOpenFileHandler(fn: OpenFileHandler): void;
+/** Stop the servers no project has touched for IDLE_STOP_MS. Exported for the check. */
+export declare function stopIdleServers(now?: number): string[];
+/** Stop all sessions (e.g. on workspace close). */
+export declare function lspStopAll(): void;
+/** Restart one server (UI action from the status popover). */
+/**
+ * Stop a language server. The next file opened for that root starts a fresh one, which is why
+ * this is both the Restart action and the memory readout's stop button — there is no difference
+ * between the two beyond what the caller says about it.
+ *
+ * Deleting the frontend session alongside the process matters: leaving it would send didOpen to
+ * a dead pipe on the next open, and the editor would sit at "ready" with no diagnostics.
+ */
+export declare function lspRestart(id: string): Promise<void>;
+export {};

package/types/core/monaco.d.ts

@@ -16,6 +16,7 @@ export declare function setEditorSurface(next: {
     card: string;
     elev: string;
     muted: string;
+    text?: string;
 }): void;
 /** Merge language-specific semantic-token colors into deck-dark (idempotent per token). */
 export declare function addSemanticColors(rules: TokenColor[]): void;

package/types/core/settingsstore.d.ts

@@ -11,6 +11,15 @@ export declare function publishSettings(s: Settings): void;
  * for the shared half.
  */
 export declare function saveSettings(next: Settings): void;
+/** The zoom steps Ctrl+= and Ctrl+- move through, in percent, as a browser's do. */
+export declare const ZOOM_STEPS: number[];
+/**
+ * Zoom the whole window: the webview's own zoom, the same as a browser's Ctrl+=, rather than CSS
+ * `zoom`, which leaves xterm and Monaco measuring the mouse in unzoomed pixels.
+ */
+export declare function applyZoom(pct: number | undefined): void;
+/** One step in or out from the current zoom, or back to 100% with dir 0. Saved like any setting. */
+export declare function stepZoom(dir: -1 | 0 | 1): void;
 /** Current settings for non-React callers (the palette's providers). */
 export declare const getSettings: () => Settings;
 export declare function userName(): Promise<string>;

package/types/core/terminals.d.ts

@@ -300,6 +300,11 @@ export declare function moveWorkspace(id: string, toIndex: number): void;
  * Empty for a pane that has not spawned yet, which is the honest answer — there is nothing in it.
  */
 export declare function paneLines(id: string, max?: number): string[];
+/**
+ * Open a file in Deck the way its file tree does: in the plugin that opens its type (a .pdf in the
+ * PDF plugin), otherwise in this workspace's Editor, at `line` when given.
+ */
+export declare function openFile(path: string, line?: number): void;
 export declare function getInstance(id: string): Instance;
 /**
  * Wrap pasted text in bracketed-paste markers, so the receiving app can tell one paste from
@@ -318,7 +323,31 @@ export declare function getInstance(id: string): Instance;
  * smaller writes would only add more seams.
  */
 export declare function bracketPaste(text: string, bracketed: boolean): string;
-/** Paste the clipboard text into a terminal's PTY (Ctrl+V and the context-menu Paste). */
+/** Whether a terminal has text selected, for its right-click menu's Copy. */
+export declare const hasSelection: (id: string) => boolean;
+/**
+ * Copy a terminal's selection, then clear it: with the selection kept, the next Ctrl+C copied
+ * again instead of interrupting the program, until something was clicked.
+ */
+export declare function copyFrom(id: string): void;
+/**
+ * A paste's line breaks as the Enter key sends them. Text copied on Windows carries CRLF, and
+ * written raw each line arrived as Enter plus a stray line feed. xterm's own paste does this
+ * conversion; Deck writes pastes itself, so it does it here.
+ */
+export declare const pasteText: (text: string) => string;
+/**
+ * A pasted line break that will run a command: one ending a line, outside a bracketed paste.
+ * The shell (PowerShell, cmd) takes each as Enter, so pasting two lines ran the first at once.
+ */
+export declare const runsLines: (text: string, bracketed: boolean) => boolean;
+/**
+ * Paste text into a terminal: line breaks as Enter, bracketed when the app asked for it, and
+ * when it would run lines in a shell that cannot tell a paste from typing, asked first, the way
+ * Windows Terminal asks. Focus goes back to the terminal afterwards, as a menu click takes it.
+ */
+export declare function pasteTextInto(id: string, text: string): Promise<void>;
+/** Paste the clipboard into a terminal, from its right-click menu (no key event to read). */
 export declare function pasteInto(id: string): Promise<void>;
 export declare function attach(id: string, el: HTMLElement, cwd: string): () => void;
 export declare function queueInput(paneId: string, text: string): void;

package/types/core/theme.d.ts

@@ -1,6 +1,28 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 export type AccentColor = "violet" | "blue" | "cyan" | "green" | "amber" | "red";
+/** A preset's name, or a custom colour as "#rrggbb". */
+export type Accent = AccentColor | `#${string}`;
 export type BgPreset = "black" | "slate" | "warm" | "midnight" | "charcoal" | "nord" | "plum" | "dracula" | "forest";
+/** A preset, or "custom": the user's own colours, from `customTheme`. */
+export type Background = BgPreset | "custom";
+/**
+ * Every colour a theme sets, so a custom one can set them all: the five surfaces darkest first,
+ * and the three text colours. Each is "#rrggbb", which is what a colour picker reads and writes.
+ */
+export interface Palette {
+    app: string;
+    panel: string;
+    card: string;
+    elev: string;
+    hover: string;
+    text: string;
+    textSecondary: string;
+    muted: string;
+    /** What is drawn on the accent: a primary button's label, a switch's knob. */
+    onAccent: string;
+}
+/** "#rrggbb" as "r g b", the form the rgb(var(--x) / alpha) tokens take. */
+export declare const channels: (hex: string) => string;
 export type Density = "compact" | "cozy";
 /** Accent base/strong pairs. Values match the primitives already in tokens.css. */
 export declare const ACCENTS: Record<AccentColor, {
@@ -27,23 +49,54 @@ export declare const DENSITIES: Record<Density, {
     scale: number;
     radius: number;
 }>;
+/** The colours a background setting resolves to. A custom one missing a colour (or with none
+ *  saved) takes it from the near-black preset, so a half-filled palette still draws. */
+export declare function paletteOf(bgPreset?: string, custom?: Partial<Palette>): Palette;
+/** Whether a "#rrggbb" background is light: relative luminance over the midpoint. */
+export declare function isLightColor(hex: string): boolean;
+/** Whether an accent is a custom colour rather than a preset's name. */
+export declare const isCustomAccent: (accent?: string) => accent is `#${string}`;
+/**
+ * An accent's base and strong colours. A custom one has no hand-picked strong shade, so it is the
+ * base mixed toward black, which is what the presets' pairs are. Anything unknown (a preset that
+ * was removed) falls back to violet.
+ */
+export declare function accentOf(accent?: string): {
+    base: string;
+    strong: string;
+};
 /** Apply the three appearance settings to the document. Safe to call repeatedly. */
 export declare function applyTheme(opts: {
-    accent?: AccentColor;
-    bgPreset?: BgPreset;
+    accent?: Accent;
+    bgPreset?: Background;
+    customTheme?: Partial<Palette>;
     density?: Density;
     termTheme?: TermTheme;
+    termCustom?: Partial<TermCustom>;
 }): void;
 /** The values the app starts with, before settings.json has been read. Matches tokens.css. */
 export declare const DEFAULT_APPEARANCE: {
-    accent: AccentColor;
-    bgPreset: BgPreset;
+    accent: Accent;
+    bgPreset: Background;
     density: Density;
 };
-export type TermTheme = "match" | "deck" | "dark" | "dimmed" | "solarized";
+export type TermTheme = "match" | "deck" | "dark" | "dimmed" | "solarized" | "custom";
+/** The eight ANSI colours programs print with. Bright variants follow them in a custom theme. */
+export declare const ANSI_KEYS: readonly ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
+export type Ansi = Record<(typeof ANSI_KEYS)[number], string>;
+/** xterm's own defaults, which every theme but a custom one leaves in place. */
+export declare const XTERM_ANSI: Ansi;
+/** A custom terminal theme: every colour, each "#rrggbb". */
+export interface TermCustom {
+    background: string;
+    foreground: string;
+    cursor: string;
+    selection: string;
+    ansi: Ansi;
+}
 /** Fixed palettes. "match" isn't here — it's derived from the app's accent + background at
  *  resolve time (see termThemeColors), so it changes with those settings. */
-export declare const TERM_THEMES: Record<Exclude<TermTheme, "match">, {
+export declare const TERM_THEMES: Record<Exclude<TermTheme, "match" | "custom">, {
     label: string;
     background: string;
     foreground: string;
@@ -55,13 +108,16 @@ export declare const TERM_THEME_LABELS: Record<TermTheme, string>;
 /** Resolve a terminal theme to concrete colours. "match" follows the app's own appearance: the
  *  card surface as the background (so a terminal reads as part of the panel it sits in) and the
  *  accent as the cursor, so picking a new accent recolours the terminal too. */
-export declare function termThemeColors(theme: TermTheme, accent?: AccentColor, bgPreset?: BgPreset): {
+export declare function termThemeColors(theme: TermTheme, accent?: Accent, bgPreset?: Background, custom?: Partial<Palette>, term?: Partial<TermCustom>): {
     label: string;
     background: string;
     foreground: string;
     cursor: string;
     selectionBackground: string;
+    ansi?: Ansi;
 };
+/** A custom terminal theme with every colour filled: what is missing comes from the Deck theme. */
+export declare function customTerm(t?: Partial<TermCustom>): TermCustom;
 export declare const TERM_FONTS: {
     value: string;
     label: string;

package/types/core/treehide.d.ts

@@ -0,0 +1,5 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** "dist, *.log" as one case-insensitive whole-name pattern each: * is any run, ? one character. */
+export declare function hidePatterns(text: string): RegExp[];
+/** Whether the tree shows an entry named `name`. */
+export declare function treeVisible(name: string, hide: string, dotfiles: boolean): boolean;