deck-plugin-sdk 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deck-plugin-sdk",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Build a plugin for Deck, outside the Deck repository.",
   "type": "module",
   "license": "MIT",

package/shim/bridge.js

@@ -9,6 +9,8 @@ const b = () => {
   return x;
 };
 
+export const agentClis = (...a) => b().agentClis(...a);
+export const agentMcpStatus = (...a) => b().agentMcpStatus(...a);
 export const askSudoPassword = (...a) => b().askSudoPassword(...a);
 export const backupExport = (...a) => b().backupExport(...a);
 export const backupInspect = (...a) => b().backupInspect(...a);
@@ -136,6 +138,9 @@ export const httpSend = (...a) => b().httpSend(...a);
 export const httpSendAs = (...a) => b().httpSendAs(...a);
 export const httpSendReply = (...a) => b().httpSendReply(...a);
 export const importIconPack = (...a) => b().importIconPack(...a);
+export const installAgentHooks = (...a) => b().installAgentHooks(...a);
+export const installAgentMcp = (...a) => b().installAgentMcp(...a);
+export const installAgentSkills = (...a) => b().installAgentSkills(...a);
 export const installClaudeHooks = (...a) => b().installClaudeHooks(...a);
 export const installClaudeMcp = (...a) => b().installClaudeMcp(...a);
 export const installFromRegistry = (...a) => b().installFromRegistry(...a);
@@ -181,6 +186,8 @@ export const readTrackMeta = (...a) => b().readTrackMeta(...a);
 export const remoteHome = (...a) => b().remoteHome(...a);
 export const remoteStat = (...a) => b().remoteStat(...a);
 export const remoteSudoPassword = (...a) => b().remoteSudoPassword(...a);
+export const removeAgentHooks = (...a) => b().removeAgentHooks(...a);
+export const removeAgentMcp = (...a) => b().removeAgentMcp(...a);
 export const removeClaudeHooks = (...a) => b().removeClaudeHooks(...a);
 export const removeClaudeMcp = (...a) => b().removeClaudeMcp(...a);
 export const removeLanguage = (...a) => b().removeLanguage(...a);

package/shim/terminals.js

@@ -19,11 +19,13 @@ export const attach = (...a) => t().attach(...a);
 export const bracketPaste = (...a) => t().bracketPaste(...a);
 export const clearPane = (...a) => t().clearPane(...a);
 export const closeLeaf = (...a) => t().closeLeaf(...a);
+export const copyFrom = (...a) => t().copyFrom(...a);
 export const destroy = (...a) => t().destroy(...a);
 export const findLeaf = (...a) => t().findLeaf(...a);
 export const focusPane = (...a) => t().focusPane(...a);
 export const getInstance = (...a) => t().getInstance(...a);
 export const getLayout = (...a) => t().getLayout(...a);
+export const hasSelection = (...a) => t().hasSelection(...a);
 export const insertBeside = (...a) => t().insertBeside(...a);
 export const isPinned = (...a) => t().isPinned(...a);
 export const isWorkspaceActive = (...a) => t().isWorkspaceActive(...a);
@@ -44,11 +46,14 @@ export const paneLabel = (...a) => t().paneLabel(...a);
 export const paneLines = (...a) => t().paneLines(...a);
 export const paneLocation = (...a) => t().paneLocation(...a);
 export const pasteInto = (...a) => t().pasteInto(...a);
+export const pasteText = (...a) => t().pasteText(...a);
+export const pasteTextInto = (...a) => t().pasteTextInto(...a);
 export const publishLayout = (...a) => t().publishLayout(...a);
 export const queueInput = (...a) => t().queueInput(...a);
 export const refit = (...a) => t().refit(...a);
 export const reorderTab = (...a) => t().reorderTab(...a);
 export const restartPane = (...a) => t().restartPane(...a);
+export const runsLines = (...a) => t().runsLines(...a);
 export const sendInput = (...a) => t().sendInput(...a);
 export const setLeafLabel = (...a) => t().setLeafLabel(...a);
 export const setLeafView = (...a) => t().setLeafView(...a);

package/shim/ui.js

@@ -51,11 +51,13 @@ export const collectFiles = (...a) => u().collectFiles(...a);
 export const conflict = (...a) => u().conflict(...a);
 export const decodeText = (...a) => u().decodeText(...a);
 export const dispatch = (...a) => u().dispatch(...a);
+export const forLanguage = (...a) => u().forLanguage(...a);
 export const formatChord = (...a) => u().formatChord(...a);
 export const getEditorSettings = (...a) => u().getEditorSettings(...a);
 export const getOverrides = (...a) => u().getOverrides(...a);
 export const match = (...a) => u().match(...a);
 export const mediaKind = (...a) => u().mediaKind(...a);
+export const modelOptionsFor = (...a) => u().modelOptionsFor(...a);
 export const monacoOptionsFrom = (...a) => u().monacoOptionsFrom(...a);
 export const normalizeChord = (...a) => u().normalizeChord(...a);
 export const onKey = (...a) => u().onKey(...a);

package/types/components/ui.d.ts

@@ -23,7 +23,7 @@ export declare function TimeInput({ value, onChange, className, }: {
     onChange: (v: string) => void;
     className?: string;
 }): import("react").JSX.Element;
-export declare function Select(props: React.SelectHTMLAttributes<HTMLSelectElement>): import("react").JSX.Element;
+export declare function Select({ className, ...props }: React.SelectHTMLAttributes<HTMLSelectElement>): import("react").JSX.Element;
 export declare function PrimaryButton({ children, ...p }: React.ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
 export declare function GhostButton({ children, ...p }: React.ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
 /**

package/types/core/bridge.d.ts

@@ -1,6 +1,6 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { type DebugTarget } from "./debugtargets";
-import type { AccentColor, BgPreset, Density, TermTheme } from "./theme";
+import type { Accent, Background, Density, Palette, TermCustom, TermTheme } from "./theme";
 /** Open a URL in the default browser. */
 export declare const openExternal: (url: string) => Promise<void>;
 export interface AppProc {
@@ -44,12 +44,30 @@ export interface Settings {
     reduceMotion: boolean;
     /** The Servers list (hosts from ~/.ssh/config) under the workspace list. */
     serversList: boolean;
+    /** The mouse wheel over a tab bar switches tabs rather than scrolling the bar. */
+    tabWheelSwitch: boolean;
+    /** Install plugin and language updates at startup instead of only announcing them. */
+    pluginAutoUpdate: boolean;
     soundOnFire: boolean;
     playerPlacement: "fixed" | "floating";
-    accent: AccentColor;
-    bgPreset: BgPreset;
+    accent: Accent;
+    bgPreset: Background;
+    /** The colours of the "custom" background, each "#rrggbb". Kept when a preset is picked, so
+     *  going back to Custom finds them again. */
+    customTheme?: Partial<Palette>;
+    /** Custom palettes the user saved by name, shown as cards beside the presets. */
+    savedThemes?: {
+        id: string;
+        name: string;
+        palette: Partial<Palette>;
+    }[];
+    /** The saved theme the custom colours came from, which edits are written back to. */
+    savedThemeId?: string;
     density: Density;
+    uiZoom: number;
     termTheme: TermTheme;
+    /** The "custom" terminal theme's colours. Kept when another theme is picked. */
+    termCustom?: Partial<TermCustom>;
     termFont: string;
     termFontSize: number;
     termScrollback: number;
@@ -75,6 +93,12 @@ export interface Settings {
     drawerHidden: string[];
     /** Drawer tabs left-to-right. Ids missing from it keep their discovery order, after the rest. */
     drawerOrder: string[];
+    /** Which side of the footer each drawer tab and readout sits on, in order (core/footerlayout.ts).
+     *  Absent until something is moved: drawer tabs left, readouts right, in the orders above. */
+    footerLayout?: {
+        left: string[];
+        right: string[];
+    };
     httpMcpRevealSecrets: boolean;
     /**
      * What to call the user: shown to the others when sharing (a Canvas board's cursor and the
@@ -523,6 +547,30 @@ export declare const claudeMcpStatus: () => Promise<string>;
 export declare const claudeMcpEntry: () => Promise<string>;
 export declare const installClaudeMcp: () => Promise<string>;
 export declare const removeClaudeMcp: () => Promise<void>;
+/**
+ * The same for any AI coding agent Deck knows: "claude", "codex", "gemini" or "cursor". Each keeps
+ * its MCP servers somewhere else (see agentmcp.rs); the status is the same four answers, with
+ * "no-node" when nothing could run the server whatever the config says.
+ */
+export declare const agentMcpStatus: (agent: string) => Promise<string>;
+export declare const installAgentMcp: (agent: string) => Promise<string>;
+export declare const removeAgentMcp: (agent: string) => Promise<void>;
+/** Deck's hooks for an agent that has them ("claude", "codex"): what the Agents panel and the
+ *  agent notifications hear from. Merged into the agent's own settings, backed up first. */
+export declare const installAgentHooks: (agent: string) => Promise<void>;
+export declare const removeAgentHooks: (agent: string) => Promise<void>;
+/**
+ * Deck's skills (how to use its MCP tools) for an agent that reads skills: "claude" or "codex".
+ * Each comes back with what happened to it: "installed", "updated", "current", "kept-yours" (a
+ * skill of that name that is not Deck's) or "kept-edited" (Deck's, changed since). Deck only
+ * replaces a skill folder it wrote and nobody has edited.
+ */
+export declare const installAgentSkills: (agent: string) => Promise<{
+    skill: string;
+    outcome: string;
+}[]>;
+/** Which agent command-line tools are on PATH: any of claude, codex, gemini, cursor-agent, cursor. */
+export declare const agentClis: () => Promise<string[]>;
 export declare const removeClaudeHooks: () => Promise<void>;
 export declare const notifyOs: (title: string, body: string) => Promise<void>;
 export declare const gitStatus: (dir: string) => Promise<GitStatusRow[]>;

package/types/core/editorsettings.d.ts

@@ -1,5 +1,11 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import type * as MonacoNS from "monaco-editor";
+/** What a language may set differently from the editor-wide value. Absent means "as everywhere". */
+export interface LanguageOverride {
+    tabSize?: number;
+    insertSpaces?: boolean;
+    formatOnSave?: boolean;
+}
 export interface EditorSettings {
     fontSize: number;
     fontFamily: string;
@@ -38,9 +44,32 @@ export interface EditorSettings {
     mouseWheelZoom: boolean;
     autoClosingBrackets: boolean;
     autoClosingQuotes: boolean;
+    /** When a file writes itself to disk. Off (the default) means only Ctrl+S saves. */
+    autoSave: "off" | "afterDelay" | "onFocusChange";
     autoSaveDelay: number;
     trimTrailingWhitespace: boolean;
     formatOnSave: boolean;
+    formatOnPaste: boolean;
+    /** Completion: popping up while typing, on a trigger character like ".", and what Enter does. */
+    quickSuggestions: boolean;
+    suggestOnTriggerCharacters: boolean;
+    acceptSuggestionOnEnter: "on" | "smart" | "off";
+    snippetSuggestions: "top" | "bottom" | "inline" | "none";
+    /** Renaming an HTML/JSX tag renames its closing tag as you type. */
+    linkedEditing: boolean;
+    /** Lines kept visible above and below the cursor when it moves near an edge. */
+    cursorSurroundingLines: number;
+    multiCursorModifier: "alt" | "ctrlCmd";
+    /** Copy or cut with nothing selected takes the whole line. */
+    emptySelectionClipboard: boolean;
+    /** The file tree: names or globs to hide (comma-separated), dotfiles, following the open file. */
+    treeHide: string;
+    treeShowDotfiles: boolean;
+    treeFollowActive: boolean;
+    /** The folders above what is in view stay pinned at the top of the tree while it scrolls. */
+    treeStickyScroll: boolean;
+    /** Per-language overrides, keyed by Monaco language id ("python", "typescript"). */
+    languageOverrides: Record<string, LanguageOverride>;
     formatLineLength: number;
     inlineErrors: boolean;
     inlineBlame: boolean;
@@ -66,4 +95,17 @@ export declare function getEditorSettings(): EditorSettings;
 /** For a store outside React that reacts to a setting (lsp.ts re-asks for inlay hints). */
 export declare function subscribeEditorSettings(cb: () => void): () => void;
 export declare function useEditorSettings(): EditorSettings;
+/** A language's own value for each overridable setting, else the editor-wide one. */
+export declare function forLanguage(s: EditorSettings, languageId: string | undefined): {
+    tabSize: number;
+    insertSpaces: boolean;
+    formatOnSave: boolean;
+};
+/** The model options for a file of `languageId`. */
+export declare function modelOptionsFor(s: EditorSettings, languageId: string | undefined): {
+    tabSize: number;
+    insertSpaces: boolean;
+};
+/** Whether the file tree shows an entry, under these settings (core/treehide.ts). */
+export declare const treeShows: (s: EditorSettings, name: string) => boolean;
 export declare function monacoOptionsFrom(s: EditorSettings): MonacoNS.editor.IEditorOptions;

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

@@ -318,7 +318,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;