deck-plugin-sdk 0.15.1

package/types/core/editorsettings.d.ts

@@ -0,0 +1,60 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import type * as MonacoNS from "monaco-editor";
+export interface EditorSettings {
+    fontSize: number;
+    fontFamily: string;
+    lineHeight: number;
+    letterSpacing: number;
+    fontLigatures: boolean;
+    tabSize: number;
+    insertSpaces: boolean;
+    wordWrap: "off" | "on" | "bounded";
+    wordWrapColumn: number;
+    lineNumbers: "on" | "off" | "relative";
+    minimap: boolean;
+    minimapSide: "right" | "left";
+    renderWhitespace: "none" | "boundary" | "selection" | "all";
+    indentGuides: boolean;
+    bracketPairColorization: boolean;
+    stickyScroll: boolean;
+    /**
+     * Markdown: float the formatting bar over the selection instead of pinning it above the note.
+     *
+     * Lives with the editor's settings rather than the vault plugin's because MarkdownLive is
+     * Deck's own component — every surface that shows a note reads this one value.
+     */
+    mdFloatingToolbar: boolean;
+    renderLineHighlight: "none" | "line" | "gutter" | "all";
+    folding: boolean;
+    glyphMargin: boolean;
+    rulers: string;
+    scrollBeyondLastLine: boolean;
+    cursorStyle: "line" | "block" | "underline";
+    cursorBlinking: "blink" | "smooth" | "phase" | "expand" | "solid";
+    smoothCaret: boolean;
+    smoothScrolling: boolean;
+    mouseWheelZoom: boolean;
+    autoClosingBrackets: boolean;
+    autoClosingQuotes: boolean;
+    autoSaveDelay: number;
+    trimTrailingWhitespace: boolean;
+    formatOnSave: boolean;
+    formatLineLength: number;
+    inlineErrors: boolean;
+    inlineBlame: boolean;
+    aiCommitCommand: string;
+    aiCommitArgs: string;
+    aiCommitModel: string;
+    agentNotify: boolean;
+    agentNotifyFinished: boolean;
+    agentNotifyNeedsInput: boolean;
+    agentNotifyOsToast: boolean;
+    theme: "deck-dark" | "vs-dark" | "hc-black";
+    iconTheme: string;
+    diffSideBySide: boolean;
+}
+export declare const DEFAULT_EDITOR_SETTINGS: EditorSettings;
+export declare function updateEditorSettings(patch: Partial<EditorSettings>): void;
+export declare function getEditorSettings(): EditorSettings;
+export declare function useEditorSettings(): EditorSettings;
+export declare function monacoOptionsFrom(s: EditorSettings): MonacoNS.editor.IEditorOptions;

package/types/core/langmap.d.ts

@@ -0,0 +1,15 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** Extensions claimed by a language definition, lowercase and without the dot. */
+export type ExtensionClaims = ReadonlyMap<string, string>;
+/**
+ * The Monaco language id for a path.
+ *
+ * Three rules, and the order is the whole point:
+ *
+ * 1. Files whose NAME is the type and have no extension to split off. `.env.local` must be ini,
+ *    but splitting on "." sees "local"; dockerfile has no extension at all.
+ * 2. Extensions a language definition claimed. These are the ones with a server behind them, so
+ *    a definition naming an extension takes it over from rule 3.
+ * 3. The grammar-only map above.
+ */
+export declare function resolveLanguage(path: string, claims: ExtensionClaims): string;

package/types/core/monaco.d.ts

@@ -0,0 +1,36 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import * as monaco from "monaco-editor";
+type TokenColor = {
+    token: string;
+    foreground?: string;
+    fontStyle?: string;
+};
+/**
+ * Repaint the editor for a new background preset. Called by applyTheme().
+ *
+ * setTheme is what actually repaints live editors — defineTheme alone only updates the
+ * registration, so an open editor would keep the old colours until it was recreated.
+ */
+export declare function setEditorSurface(next: {
+    app: string;
+    card: string;
+    elev: string;
+    muted: string;
+}): void;
+/** Merge language-specific semantic-token colors into deck-dark (idempotent per token). */
+export declare function addSemanticColors(rules: TokenColor[]): void;
+/**
+ * Claim a file extension for a language. Lowercase, without the dot.
+ *
+ * Last registration wins, which is what makes a user's own definition able to override a
+ * built-in one rather than silently losing to it.
+ */
+export declare function registerExtension(ext: string, languageId: string): void;
+/**
+ * Map a filename to a Monaco language id.
+ *
+ * The rule itself is in langmap.ts, which has no Monaco import and so can be tested; this only
+ * supplies the extensions language definitions have claimed.
+ */
+export declare function languageForPath(path: string): string;
+export { monaco };

package/types/core/settingsstore.d.ts

@@ -0,0 +1,19 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type Settings } from "./bridge";
+/** Called by Settings after every write, so readers update without a reload. */
+export declare function publishSettings(s: Settings): void;
+/**
+ * Write settings and apply everything that has to happen alongside the write.
+ *
+ * Settings' own persist() used to be the only path, so anything outside that module (the
+ * command palette toggling relay, say) would have had to repeat five steps and would break
+ * quietly when one of them changed. Settings still owns its local form state and calls this
+ * for the shared half.
+ */
+export declare function saveSettings(next: Settings): void;
+/** Current settings for non-React callers (the palette's providers). */
+export declare const getSettings: () => Settings;
+/** The OS account name — the home directory's last segment. "" if it can't be read. */
+export declare function osAccountName(): Promise<string>;
+export declare function userName(): Promise<string>;
+export declare function useSettings(): Settings;

package/types/core/shellpath.d.ts

@@ -0,0 +1,45 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** Quote a path for a shell only when it needs it, so the common case stays readable. */
+export declare function quotePath(p: string): string;
+/** A path found in terminal output, resolved and ready to open. */
+export interface TermPath {
+    text: string;
+    path: string;
+    line?: number;
+    start: number;
+}
+/**
+ * Every path CANDIDATE in one row of terminal output, each resolved against `cwd`.
+ *
+ * A space is both a legal path character and the thing that separates a path from the next word,
+ * so "D:\Program Files\Deck" cannot be told from "src/foo.ts and more" by shape alone. Rather
+ * than guess, each match is emitted at its shortest extent and then again grown by one
+ * space-separated token at a time; `chooseLinks` picks between them once something can say which
+ * of those files exists. Candidates that share a `start` are the same match at different lengths.
+ *
+ * The shortest extent comes first, so a caller that only wants the unambiguous reading can take
+ * the first candidate per `start` and never consult the filesystem.
+ *
+ * ponytail: one row at a time, so a path wrapped across two visual rows is missed, and a relative
+ * path resolves against the cwd the pane SPAWNED with, so it is wrong after a `cd`. Absolute
+ * paths — what Claude Code and most tools print — are unaffected by both.
+ *
+ * ponytail: only the END of a path can be recovered this way. A RELATIVE path whose first segment
+ * contains a space ("My Docs\a.txt") is anchored at "Docs\a.txt", because the match can only
+ * begin where a path-shaped run begins. An absolute path is safe — its drive or leading slash
+ * anchors it — and that is the form tools print.
+ */
+export declare function findPaths(row: string, cwd: string): TermPath[];
+/**
+ * Pick the links to offer from `findPaths`'s candidates, given which of them exist.
+ *
+ * `exists` is positional — one entry per candidate. Kept as a parameter rather than a callback so
+ * this stays pure and node-testable; the filesystem lives in the caller.
+ *
+ * For each match (candidates sharing a `start`) the LONGEST existing extent wins: if both
+ * "D:\Program" and "D:\Program Files\Deck\deck.exe" existed, the longer one is what was written.
+ * Overlapping results are then dropped, because the tail of a space-containing path is itself a
+ * relative-path-shaped match at a later column, and two links over one span would let a click
+ * land on either.
+ */
+export declare function chooseLinks(candidates: readonly TermPath[], exists: readonly boolean[]): TermPath[];

package/types/core/terminals.d.ts

@@ -0,0 +1,322 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { Terminal } from "@xterm/xterm";
+import { FitAddon } from "@xterm/addon-fit";
+/** The cap, so Settings can state the real number rather than repeating a literal. */
+export declare const webglLimit: () => number;
+export interface TermOutput {
+    id: string;
+    data: string;
+}
+export interface TermExit {
+    id: string;
+}
+export type SplitDir = "h" | "v";
+export type LayoutNode = {
+    kind: "leaf";
+    id: string;
+    label?: string;
+    view?: string;
+} | {
+    kind: "split";
+    dir: SplitDir;
+    a: LayoutNode;
+    b: LayoutNode;
+    ratio: number;
+};
+/**
+ * A tab, and — with `x`/`y` — a zone on the canvas.
+ *
+ * The coordinates are OPTIONAL and nothing writes them on load: a tab saved before zones
+ * existed has none, and `zoneAt` places it by its index instead. That keeps every layout ever
+ * written valid and means the tab strip and the canvas are two views of one list, not two
+ * models to keep in sync.
+ */
+export interface LayoutTab {
+    id: string;
+    title: string;
+    root: LayoutNode;
+    x?: number;
+    y?: number;
+}
+export interface LayoutWorkspace {
+    id: string;
+    name: string;
+    cwd: string;
+    tabs: LayoutTab[];
+    activeTab: string;
+}
+export interface Layout {
+    workspaces: LayoutWorkspace[];
+    activeWs: string;
+}
+export declare function publishLayout(l: Layout): void;
+export declare function getLayout(): Layout | null;
+export declare function loadLayoutOnce(): Promise<void>;
+export declare function mutateLayout(fn: (l: Layout) => Layout): void;
+export declare function useLayout(): Layout | null;
+export declare function activeWorkspaceCwd(): string;
+/** Switch the active workspace (+ optionally its active tab) — used by agent-notification clicks. */
+export declare function switchWorkspace(wsId: string, tabId?: string): void;
+/** The workspace whose cwd matches (case/slash-insensitive), for routing an agent hook to a tab. */
+/**
+ * How many columns the zone board has. Here rather than only in the UI because the fallback
+ * placement below has to agree with what the overview can draw.
+ */
+export declare const ZONE_BOARD = 3;
+/**
+ * Where a zone sits on the canvas: its stored coordinates, else its place in the list.
+ *
+ * The fallback is what makes zones work on a layout that predates them — the tabs you already
+ * have become the first row, left to right, without rewriting anything on disk.
+ */
+export declare function zoneAt(tabs: readonly LayoutTab[], id: string, cols?: number): {
+    x: number;
+    y: number;
+};
+/**
+ * The zone to move to from `id` going `dir`, or null when there is none that way.
+ *
+ * Nearest in a straight line: same row for left/right, same column for up/down, smallest step.
+ * No wrapping — running out of canvas should feel like an edge, not teleport you across it.
+ */
+export declare function zoneToward(tabs: readonly LayoutTab[], id: string, dir: "left" | "right" | "up" | "down"): LayoutTab | null;
+/**
+ * Put a zone at a spot on the canvas, swapping with whatever is already there.
+ *
+ * Swap rather than push-and-shuffle: a zone you did not touch should not move because another
+ * one arrived next to it, and with sparse coordinates there is no row to shuffle along anyway.
+ *
+ * Every tab gets explicit coordinates on the way out, including ones that were still relying on
+ * the index fallback — otherwise moving one zone would silently shift the unplaced ones, since
+ * their position depends on where they sit in the list.
+ */
+export declare function moveZone(tabs: readonly LayoutTab[], id: string, to: {
+    x: number;
+    y: number;
+}): LayoutTab[];
+/** The first free spot on the top row, for a zone created without a position of its own. */
+export declare function nextZoneSpot(tabs: readonly LayoutTab[], cols?: number, rows?: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Is there nowhere left to put a zone?
+ *
+ * The board is a fixed 3x3 — deliberately, so the overview and the Ctrl+Alt compass are always
+ * the same nine cells. A tenth zone has no spot: it drew off the edge of the overview and the
+ * compass could not reach it, so it existed but could not be seen or switched to.
+ *
+ * Checked by every caller that creates one, rather than inside nextZoneSpot, because refusing
+ * and reporting why is the caller's job — the keyboard shortcut says so in a toast, and the
+ * layout op tells the agent that asked.
+ */
+export declare function zoneBoardFull(tabs: readonly LayoutTab[], cols?: number, rows?: number): boolean;
+export declare function workspaceByCwd(cwd: string): LayoutWorkspace | undefined;
+/** The folder a pane's shell was spawned in — its workspace's cwd. */
+export declare function paneCwd(paneId: string): string;
+/**
+ * A pane's display name: its own label, else the title of the tab holding it.
+ *
+ * Here rather than in the footer that first needed it, because Settings lists the same pinned
+ * panes and a second copy of this walk would be a second answer to one question.
+ */
+export declare function paneLabel(paneId: string): string;
+/** Which workspace + tab holds a pane, for jumping to an agent from outside Terminals. */
+export declare function paneLocation(paneId: string): {
+    wsId: string;
+    wsName: string;
+    tabId: string;
+} | undefined;
+/** Give a pane real keyboard focus. No-op if it isn't mounted yet — the caller retries. */
+export declare function focusPane(paneId: string): boolean;
+export declare const termSpawn: (id: string, cwd: string, cols: number, rows: number) => Promise<void>;
+export declare const termWrite: (id: string, data: string) => Promise<void>;
+export declare const termResize: (id: string, cols: number, rows: number) => Promise<void>;
+export declare const termKill: (id: string) => Promise<void>;
+export declare const termList: () => Promise<string[]>;
+/** Delete scrollback logs for panes not in `keep`. Returns how many were removed. */
+export declare const termSweepScrollback: (keep: string[]) => Promise<number>;
+export declare const termScrollback: (id: string) => Promise<string>;
+export declare function leafIds(n: LayoutNode): string[];
+export declare function splitLeaf(n: LayoutNode, id: string, dir: SplitDir, ratio?: number, view?: string): LayoutNode;
+export declare function setLeafLabel(n: LayoutNode, id: string, label: string): LayoutNode;
+/**
+ * Turn a pane into a view, or back into a terminal when `view` is empty.
+ *
+ * The pane keeps its id, so the layout, the splits around it and its place in the tab are
+ * untouched — only what it renders changes. Its label goes with the old contents: a terminal
+ * named "server" that becomes a notes pane is not the server any more.
+ */
+export declare function setLeafView(n: LayoutNode, id: string, view: string): LayoutNode;
+export declare function closeLeaf(n: LayoutNode, id: string): LayoutNode | null;
+export type DropSide = "left" | "right" | "top" | "bottom";
+/** The leaf node itself (not just its id) — a move carries the pane's label with it. */
+export declare function findLeaf(n: LayoutNode, id: string): LayoutNode | null;
+/** Replace a leaf with a split holding it and `leaf`, ordered by which side `leaf` lands on. */
+export declare function insertBeside(n: LayoutNode, targetId: string, leaf: LayoutNode, side: DropSide): LayoutNode;
+/**
+ * Move a pane next to another within one tab. The leaf keeps its id, so the xterm instance (and
+ * therefore the running shell and its scrollback) survives — attach() re-parents it on remount.
+ * closeLeaf already collapses the split the pane leaves behind.
+ */
+export declare function moveLeaf(root: LayoutNode, srcId: string, targetId: string, side: DropSide): LayoutNode;
+/**
+ * Open a new tab in a workspace and return the id of the pane it contains.
+ *
+ * applyDtCommand's "new-tab" does the same thing but returns nothing, which is fine for an agent
+ * driving Deck over HTTP (it can look the pane up afterwards) and useless in-process, where the
+ * caller wants to type into the pane it just made. Pair it with queueInput: the pane has no PTY
+ * until it is attached to a sized element, so anything written before then is dropped.
+ */
+export declare function openTabInWorkspace(wsId: string, title: string): string | null;
+export declare function applyDtCommand(op: string, args: Record<string, unknown>): string | void;
+interface Instance {
+    term: Terminal;
+    fit: FitAddon;
+    opened: boolean;
+    spawned: boolean;
+    exited: boolean;
+    lastCols: number;
+    lastRows: number;
+}
+/** Re-apply the terminal look to every live pane. Called when the settings change, so an open
+ *  terminal restyles in place instead of only new ones picking it up. A font change alters the
+ *  cell size, so each pane is refit and its PTY told the new grid — otherwise the shell keeps
+ *  drawing to the old column count. */
+export declare function applyTerminalLook(): void;
+export declare function useAgentPanesVersion(): number;
+/**
+ * How many of a workspace's panes have a shell right now.
+ *
+ * A pane spawns lazily and is killed by a suspend, so the layout says nothing about whether
+ * anything is running in it. This is what distinguishes a workspace worth suspending from one
+ * already asleep.
+ */
+export declare function workspaceShellCount(ws: LayoutWorkspace): number;
+/** A workspace is "active" if any of its panes has a LIVE claude agent (not just a shell). */
+export declare function isWorkspaceActive(ws: LayoutWorkspace): boolean;
+/**
+ * Mark a pane as running an agent right now, without waiting for the sweep.
+ *
+ * agentPanes is refreshed from Rust every 45s, which is the right cadence for noticing an agent
+ * that EXITED but far too slow for one we just started ourselves — the menu would keep offering
+ * to start a second one for most of a minute. The next sweep confirms it, or clears it if the
+ * command never took.
+ */
+export declare function markAgentStarted(paneId: string): void;
+/** Does this pane have a LIVE claude agent? Used to decide whether closing needs confirming. */
+export declare function paneHasAgent(paneId: string): boolean;
+/** Move a workspace to a new index (drag-reorder). Order is what Ctrl+1..9 indexes into. */
+export declare function moveWorkspace(id: string, toIndex: number): void;
+/**
+ * Ctrl+click a file path in terminal output to open it in this workspace's editor.
+ *
+ * Registered per attach because resolving a relative path needs the pane's cwd, which is what
+ * attach is given. The instance outlives its DOM, so the previous provider is disposed first
+ * rather than stacking a second one on every re-attach. The matching itself lives in shellpath
+ * (no xterm import), where it is exercised by shellpath.check.ts.
+ *
+ * Only a path that actually exists is offered as a link. Matching the shape of a path is not the
+ * same as having one: output wraps mid-path at the edge of a narrow pane, a relative path resolves
+ * against the cwd the pane spawned with rather than the one it is in now, and ordinary prose
+ * contains slashes ("feature/foo", "and/or"). All three produce a link that opens nothing, so the
+ * check is on existence rather than on any single one of those causes.
+ *
+ * provideLinks is callback-shaped so a provider may answer asynchronously. xterm asks only about
+ * the row under the cursor and caches the answer until the buffer changes, so this is a few small
+ * IPC calls on hover, not one per line of output.
+ *
+ * ponytail: fsSize, because it already exists and needs no Rust change. A directory reports 0 on
+ * Windows, so this rejects those too — which is right, the editor cannot open one. The cost is
+ * that a genuinely empty file is not clickable; a dedicated fs_is_file is not worth that case.
+ */
+/**
+ * The last lines a pane has on screen, as plain text.
+ *
+ * For drawing a pane somewhere it cannot actually be mounted — the zone overview. An xterm has
+ * ONE element and `attach` moves it into whichever host mounted last, so a second live copy is
+ * not possible: rendering real panes in the overview would pull every terminal out of the zone
+ * being looked at. Reading the buffer sidesteps that entirely.
+ *
+ * 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[];
+export declare function getInstance(id: string): Instance;
+/**
+ * Wrap pasted text in bracketed-paste markers, so the receiving app can tell one paste from
+ * typing — and, more importantly, from a paste that arrives in pieces.
+ *
+ * ConPTY takes about 1KB per input write. A 4KB paste is handed to write_all whole, and
+ * Windows still delivers it to the shell in 1KB fragments with gaps between them. An app that
+ * decides "paste or typing?" on timing then sees four separate pastes: pasting a long command
+ * into Claude Code split it into five messages, each cut mid-line at a 1024-byte boundary.
+ * Nothing was lost — only the boundaries were wrong.
+ *
+ * The markers put the boundaries in the CONTENT, where fragmentation cannot move them: the
+ * reader reassembles on ESC[200~ / ESC[201~ rather than on when the bytes happened to land.
+ *
+ * Chunking the write instead would not fix this. The fragmentation is ConPTY's, below us, and
+ * 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). */
+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;
+/**
+ * Type into a pane whether or not its shell exists yet.
+ *
+ * queueInput alone is only right for a pane being CREATED — the queue is drained by the spawn, so
+ * on a pane that is already running the text would sit there forever. Anything typing into a pane
+ * the user picked (the agent launcher) has to handle both.
+ */
+export declare function sendInput(paneId: string, text: string): void;
+/**
+ * Size a pane's PTY, and every view of it, to the SMALLER of those views.
+ *
+ * The single sizing authority. A PTY has one column count, so a pinned pane's two views cannot
+ * each own their own size — and when they tried, each view's resize re-fired the other's
+ * ResizeObserver, which resized back. Two term_resize calls per cycle, each a full ConPTY screen
+ * repaint written into both xterms: that ping-pong was the lag.
+ *
+ * proposeDimensions(), never fit(): fit() RESIZES as a side effect, which changes the host's
+ * layout and re-fires the observer that called us. Measuring first and resizing once — only when
+ * the size actually differs — means the observer's next pass finds nothing to do and it settles.
+ */
+export declare function refit(id: string): void;
+/**
+ * Clear the screen, the way the shell expects.
+ *
+ * NOT xterm's term.clear(): that drops the scrollback behind xterm's back while ConPTY still
+ * thinks the cursor sits where it was, so PowerShell redraws its prompt at a stale row and
+ * typing appears mid-screen with no prompt. Sending Ctrl+L (\x0c) instead lets the program
+ * owning the pane do the clearing — PSReadLine clears and reprints its prompt, and a TUI
+ * (Claude, vim) treats it as a repaint. Terminal and shell stay in agreement either way.
+ */
+export declare function clearPane(id: string): void;
+/**
+ * Kill the pane's shell and start a fresh one in the same xterm, keeping the pane id (so the
+ * layout, name and split position survive). Claude is NOT re-resumed: `agentResumed` already
+ * holds this id from the first spawn, and a restart is a request for a clean shell.
+ */
+export declare function restartPane(id: string, cwd: string): Promise<void>;
+/**
+ * Kill every shell in a workspace, keeping its layout.
+ *
+ * The same thing a Deck restart does to a workspace you have not opened, done on demand: the
+ * panes, splits and zones stay exactly as they are, and each one spawns again — resuming its
+ * Claude session — the next time it is attached. What it buys is memory: an xterm buffer, a
+ * WebGL context, a ConPTY and a shell per pane, for a project you are not using right now.
+ *
+ * What does NOT come back is anything the shell was running that Deck did not start: a dev
+ * server or a `flutter run` is killed, and nothing recorded the command to type again. Only a
+ * Claude session is resumable, because its uuid is the one thing that gets written down.
+ *
+ * Returns how many shells were actually killed.
+ */
+export declare function suspendWorkspace(wsId: string): Promise<number>;
+export declare function destroy(id: string): void;
+export declare function usePinnedPanes(): string[];
+export declare const isPinned: (id: string) => boolean;
+export declare function togglePin(id: string): void;
+export {};

package/types/core/theme.d.ts

@@ -0,0 +1,68 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export type AccentColor = "violet" | "blue" | "cyan" | "green" | "amber" | "red";
+export type BgPreset = "black" | "slate" | "warm" | "midnight" | "charcoal" | "nord" | "plum" | "dracula" | "forest";
+export type Density = "compact" | "cozy";
+/** Accent base/strong pairs. Values match the primitives already in tokens.css. */
+export declare const ACCENTS: Record<AccentColor, {
+    label: string;
+    base: string;
+    strong: string;
+}>;
+/** The five-step neutral ramp, darkest surface first. Borders come from white alpha, so they
+ *  work across all three without per-preset values. */
+export declare const BG_PRESETS: Record<BgPreset, {
+    label: string;
+    app: string;
+    panel: string;
+    card: string;
+    elev: string;
+    hover: string;
+    muted: string;
+}>;
+/** Density scales the type ramp and the shared radii — the two things that set how much fits
+ *  on screen without touching any component's own padding. */
+export declare const DENSITIES: Record<Density, {
+    label: string;
+    hint: string;
+    scale: number;
+    radius: number;
+}>;
+/** Apply the three appearance settings to the document. Safe to call repeatedly. */
+export declare function applyTheme(opts: {
+    accent?: AccentColor;
+    bgPreset?: BgPreset;
+    density?: Density;
+    termTheme?: TermTheme;
+}): 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;
+    density: Density;
+};
+export type TermTheme = "match" | "deck" | "dark" | "dimmed" | "solarized";
+/** 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">, {
+    label: string;
+    background: string;
+    foreground: string;
+    cursor: string;
+    selectionBackground: string;
+}>;
+/** The label a theme shows in the picker, including the derived "match" entry. */
+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): {
+    label: string;
+    background: string;
+    foreground: string;
+    cursor: string;
+    selectionBackground: string;
+};
+export declare const TERM_FONTS: {
+    value: string;
+    label: string;
+}[];

package/types/modules/editor/MarkdownLive.d.ts

@@ -0,0 +1,61 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { EditorView } from "@codemirror/view";
+export declare function MarkdownLive({ value, path, onChange, onSave, onView, flush, fontSize, onWikiLink, resolveWikiLink, wikiLinkOptions, mermaid, resolveEmbed }: {
+    value: string;
+    path?: string;
+    onChange: (v: string) => void;
+    onSave?: () => void;
+    /** Hands the live EditorView out, and null on unmount. For a formatting toolbar, which has to
+     *  dispatch into this editor rather than rewrite the string around it. */
+    onView?: (v: EditorView | null) => void;
+    /** Left-align the text across the full width instead of a centred document column. The column
+     *  suits a file you sit and read; a side panel just loses its width to the margins. */
+    flush?: boolean;
+    /** Base text size in px. Applied through a Compartment so changing it reconfigures the live
+     *  editor rather than rebuilding it — a remount per zoom step would discard the undo history. */
+    fontSize?: number;
+    /**
+     * Handle a click on a `[[wikilink]]`. Omit and wikilinks are not parsed at all, so the Editor
+     * renders a note exactly as it did before this existed.
+     *
+     * Deck itself has no note-resolution rules — which file `[[Name]]` means is the vault plugin's
+     * question, so it answers it.
+     */
+    onWikiLink?: (target: string, heading: string) => void;
+    /**
+     * Does this wikilink point at a note that exists? Dimmed and struck through when it does not.
+     *
+     * Deck cannot answer this — which file `[[Name]]` means is the vault's question — so the caller
+     * does. Omit it and every link is drawn as though it resolves.
+     */
+    resolveWikiLink?: (target: string) => boolean;
+    /**
+     * Candidates for a `[[` being typed, so a link can be picked rather than remembered.
+     *
+     * Given whatever has been typed since the brackets. Returns what to offer: `target` is written
+     * into the document, `label` and `detail` are what the list shows. Omit it and typing `[[`
+     * does nothing special.
+     */
+    wikiLinkOptions?: (query: string) => {
+        target: string;
+        label: string;
+        detail?: string;
+    }[];
+    /**
+     * Draw ```mermaid fences as diagrams. The caret inside one shows its source again, so it can
+     * be edited, and it redraws when the caret leaves.
+     *
+     * Off by default: mermaid is a large dependency, loaded on first use, and the Editor already
+     * renders a note's diagrams in its Preview view.
+     */
+    mermaid?: boolean;
+    /**
+     * Where an Obsidian embed's file lives: `![[diagram.png]]` gives "diagram.png" and wants an
+     * absolute path back, or null when nothing matches.
+     *
+     * Resolved by NAME against the whole vault, which is a question only the caller can answer.
+     * Omit it and an embed stays as text rather than rendering as a broken image.
+     */
+    resolveEmbed?: (name: string) => string | null;
+}): import("react").JSX.Element;
+export default MarkdownLive;