deck-plugin-sdk 1.11.1 → 1.12.0

package/package.json

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

package/permissions.json

@@ -1,5 +1,5 @@
 {
-  "generated": "by sdk/gen-permissions.mjs from src/core/permissions.ts; do not edit",
+  "generated": "by sdk/gen-permissions.mjs from src/core/plugins/permissions.ts; do not edit",
   "permissions": {
     "files": "Read and change files anywhere on this PC",
     "processes": "Run programs and commands",

package/shim/p2p.d.ts

@@ -1,4 +1,4 @@
 // GENERATED by sdk/gen-shim.mjs — do not edit.
 //
 // Deck's real types, so a plugin is checked against the actual shape.
-export * from "../types/core/p2p";
+export * from "../types/core/app/p2p";

package/shim/settings.d.ts

@@ -1,5 +1,5 @@
 // GENERATED by sdk/gen-shim.mjs — do not edit.
 //
 // Deck's real settings types, so a plugin is checked against the actual shape.
-export { useSettings, getSettings, saveSettings, userName } from "../types/core/settingsstore";
+export { useSettings, getSettings, saveSettings, userName } from "../types/core/app/settingsstore";
 export type { Settings } from "../types/core/bridge";

package/shim/terminals.d.ts

@@ -1,4 +1,4 @@
 // GENERATED by sdk/gen-shim.mjs — do not edit.
 //
 // Deck's real types, so a plugin is checked against the actual shape.
-export * from "../types/core/terminals";
+export * from "../types/core/workspaces/terminals";

package/shim/ui.d.ts

@@ -6,21 +6,21 @@ export * from "../types/components/ConfirmDialog";
 export * from "../types/components/NamePrompt";
 export * from "../types/components/ContextMenu";
 export * from "../types/components/Toast";
-export * from "../types/core/notifyapi";
+export * from "../types/core/notifications/notifyapi";
 export * from "../types/components/useResize";
-export * from "../types/modules/editor/MarkdownLive";
+export * from "../types/modules/editor/viewers/MarkdownLive";
 export * from "../types/components/TreeRow";
 export * from "../types/components/dragrow";
 export * from "../types/components/TabStrip";
 export * from "../types/components/MarkdownToolbar";
 export * from "../types/components/ActivityBar";
-export * from "../types/core/editorsettings";
-export * from "../types/core/keystore";
-export * from "../types/modules/editor/viewers";
+export * from "../types/core/editor/editorsettings";
+export * from "../types/core/keys/keystore";
+export * from "../types/modules/editor/viewers/viewers";
 export * from "../types/components/FileIcon";
-export * from "../types/core/icontheme";
-export * from "../types/modules/editor/tree";
-export * from "../types/core/decode";
-export * from "../types/core/keys";
+export * from "../types/core/editor/icontheme";
+export * from "../types/modules/editor/tree/tree";
+export * from "../types/core/editor/decode";
+export * from "../types/core/keys/keys";
 export * from "../types/modules/editor/MonacoHosts";
-export * from "../types/core/fileview";
+export * from "../types/core/plugins/fileview";

package/template/plugin.json

@@ -5,6 +5,6 @@
   "icon": "Sparkles",
   "color": "#a78bfa",
   "version": "0.1.0",
-  "minDeck": "1.11.1",
+  "minDeck": "1.12.0",
   "permissions": []
 }

package/types/components/FileIcon.d.ts

@@ -1,5 +1,5 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-import { type IconRef } from "../core/icontheme";
+import { type IconRef } from "../core/editor/icontheme";
 export declare function FileIcon({ icon, size, tint }: {
     icon: IconRef;
     size?: number;

package/types/components/TabStrip.d.ts

@@ -1,5 +1,6 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-import type { ReactNode } from "react";
+import { type ReactNode } from "react";
+import { type MenuEntry } from "./ContextMenu";
 export interface TabItem {
     id: string;
     title: ReactNode;
@@ -12,7 +13,7 @@ export interface TabItem {
     /** Tooltip for the close button; defaults to "Close". */
     closeTitle?: string;
 }
-export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder, onDoubleClick, leading, trailing, pill: pillProp, chip, onAdd, addTitle, }: {
+export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder, onDoubleClick, menu, leading, trailing, pill: pillProp, chip, onAdd, addTitle, }: {
     tabs: readonly TabItem[];
     activeId: string | null;
     onSelect: (id: string) => void;
@@ -20,6 +21,8 @@ export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder,
     /** Moves `from` to `to`'s position. Omit to make the strip non-reorderable. */
     onReorder?: (from: string, to: string) => void;
     onDoubleClick?: (id: string) => void;
+    /** A tab's right-click menu. Asked for when it opens, so it reflects the tabs as they are then. */
+    menu?: (id: string) => MenuEntry[];
     /** Controls before the first tab. */
     leading?: ReactNode;
     /** Right-aligned controls after the tabs — view toggles, save state. */

package/types/core/{settingsstore.d.ts → app/settingsstore.d.ts}

@@ -1,5 +1,5 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-import { type Settings } from "./bridge";
+import { type Settings } from "../bridge";
 /** Called by Settings after every write, so readers update without a reload. */
 export declare function publishSettings(s: Settings): void;
 /**

package/types/core/bridge.d.ts

@@ -1,7 +1,7 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-import { type DebugTarget } from "./debugtargets";
-import type { Accent, Background, Density, Palette, TermCustom, TermTheme } from "./theme";
-import type { SearchEngine } from "./browserurl";
+import { type DebugTarget } from "./editor/debugtargets";
+import type { Accent, Background, Density, Palette, TermCustom, TermTheme } from "./app/theme";
+import type { SearchEngine } from "./browser/browserurl";
 /** Open a URL in the default browser. */
 export declare const openExternal: (url: string) => Promise<void>;
 /** A box in physical pixels, relative to the window: where a browser pane's webview goes. */
@@ -375,7 +375,7 @@ 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).
+    /** Which side of the footer each drawer tab and readout sits on, in order (core/app/footerlayout.ts).
      *  Absent until something is moved: drawer tabs left, readouts right, in the orders above. */
     footerLayout?: {
         left: string[];
@@ -1184,7 +1184,7 @@ export declare const sshTunnelClose: (id: number) => Promise<void>;
  * Offer programs to the editor's debugger: a plugin that runs something debuggable (the Flutter
  * plugin's runs) publishes them here, and the Run and Debug panel lists them to attach to. Pass
  * the plugin's whole current list each time, under its own `source`; an empty list removes it.
- * See core/debugtargets.ts.
+ * See core/editor/debugtargets.ts.
  */
 export declare const setDebugTargets: (source: string, targets: DebugTarget[]) => void;
-export type { DebugTarget } from "./debugtargets";
+export type { DebugTarget } from "./editor/debugtargets";

package/types/core/{bookmarks.d.ts → browser/bookmarks.d.ts}

@@ -4,6 +4,8 @@ export interface BookmarkNode {
     title: string;
     /** A page has a URL; a folder has children instead. */
     url?: string;
+    /** A word that opens it from the tool picker, as a link's does (links.ts). */
+    keyword?: string;
     children?: BookmarkNode[];
 }
 export interface Bookmarks {
@@ -30,8 +32,8 @@ export declare function folders(b: Bookmarks): {
 export declare const add: (b: Bookmarks, folder: string, node: BookmarkNode) => Bookmarks;
 /** Remove the node with `id`, wherever it is (a folder goes with what is in it). */
 export declare function remove(b: Bookmarks, id: string): Bookmarks;
-/** Change a node's title or URL. */
-export declare function update(b: Bookmarks, id: string, patch: Partial<Pick<BookmarkNode, "title" | "url">>): Bookmarks;
+/** Change a node's title, URL or keyword. */
+export declare function update(b: Bookmarks, id: string, patch: Partial<Pick<BookmarkNode, "title" | "url" | "keyword">>): Bookmarks;
 /** The node with `id`, and the id of the folder it is in. */
 export declare function locate(b: Bookmarks, id: string): {
     node: BookmarkNode;

package/types/core/{browser.d.ts → browser/browser.d.ts}

@@ -138,7 +138,7 @@ export declare const takeWaitingUrl: () => {
 export declare const newBrowserTab: (url?: string, isPrivate?: boolean) => boolean | void;
 /**
  * A browser tab on `url` in a floating window, so the main window's view stays (Terminals'
- * deck-open-float, core/floatwin.ts openInFloat): `name` the window that collects them ("links"
+ * deck-open-float, core/workspaces/floatwin.ts openInFloat): `name` the window that collects them ("links"
  * from other programs, "agent" for an agent's pages), `beside` the window a pane is in.
  */
 export declare function browserInFloat(url: string, where: {

package/types/core/{editorsettings.d.ts → editor/editorsettings.d.ts}

@@ -115,6 +115,6 @@ export declare function modelOptionsFor(s: EditorSettings, languageId: string |
     tabSize: number;
     insertSpaces: boolean;
 };
-/** Whether the file tree shows an entry, under these settings (core/treehide.ts). */
+/** Whether the file tree shows an entry, under these settings (core/editor/treehide.ts). */
 export declare const treeShows: (s: EditorSettings, name: string) => boolean;
 export declare function monacoOptionsFrom(s: EditorSettings): MonacoNS.editor.IEditorOptions;

package/types/core/{icontheme.d.ts → editor/icontheme.d.ts}

@@ -1,6 +1,6 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { type LucideIcon } from "lucide-react";
-import { type ImportedPack } from "./bridge";
+import { type ImportedPack } from "../bridge";
 export type IconRef = {
     kind: "lucide";
     icon: LucideIcon;

package/types/core/workspaces/layout.d.ts

@@ -0,0 +1,168 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { TabGroup } from "./zones";
+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;
+    /**
+     * Behind another tab in the same zone. Tabs sharing a cell are one zone, and the one without
+     * this flag is the one it shows — so a zone reopens on the tab you left it on. Absent on every
+     * tab that has a cell to itself, which is every tab written before zones held several.
+     */
+    hidden?: boolean;
+    /** The tab group it is in (LayoutWorkspace.groups); a group's tabs sit together in one zone. */
+    group?: string;
+    /** A colour of its own, an index into GROUP_COLORS: a faint tint behind the tab. */
+    color?: number;
+    /**
+     * Torn off into a window of its own (core/workspaces/floatwin.ts): the window's id. Such a tab is in no
+     * zone, though it keeps its x/y to go back to. A restart reopens the window (Layout.floats has
+     * where it was).
+     */
+    window?: string;
+    /**
+     * Opened straight into a floating window by Deck (openInFloat: a link, a page an agent opened, a
+     * file Ctrl+clicked in a terminal), so closing that window closes it rather than docking it into
+     * the main window. Dropped the moment the tab is moved by hand: then it is one of yours.
+     */
+    transient?: true;
+}
+export interface LayoutWorkspace {
+    id: string;
+    name: string;
+    cwd: string;
+    tabs: LayoutTab[];
+    activeTab: string;
+    /** Tab groups: a name and colour over tabs that sit together in a zone's row, folded or not. */
+    groups?: TabGroup[];
+    /** Its colour on the sidebar's collapsed rail, by index (Terminals' TONES); none picks one from the name. */
+    color?: number;
+}
+/** Where a floating window was, in physical screen pixels (its size and place before any maximise), to reopen it there. */
+export interface FloatBounds {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    max?: boolean;
+    /** A window things are sent to by name (core/workspaces/floatwin.ts openInFloat): "links", "agent". */
+    name?: string;
+}
+export interface Layout {
+    workspaces: LayoutWorkspace[];
+    activeWs: string;
+    floats?: FloatBounds[];
+}
+export declare let currentLayout: Layout | null;
+export declare const layoutSubs: Set<() => void>;
+export declare let notifyQueued: boolean;
+export declare function publishLayout(l: Layout): void;
+export declare function getLayout(): Layout | null;
+export declare const uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+export declare function defaultLayout(): Layout;
+export declare function allLeafIds(l: Layout): string[];
+/** Views that were Deck's own and are now a plugin's, old id to new. */
+export declare const MOVED_VIEWS: Record<string, string>;
+export declare let loadPromise: Promise<void> | null;
+export declare let liveAtLoad: Set<string> | null;
+export declare function loadLayoutOnce(): Promise<void>;
+/**
+ * What every layout write leaves true of a workspace: its active tab is one the main window draws
+ * (a tab in a floating window is not; going to one leaves the main window on a neighbour), its zone
+ * shows it (showActiveTab), a folded group holding it opens (openActiveGroup), and a tab group
+ * whose last tab went goes with it (pruneGroups).
+ */
+export declare function tidy(w: LayoutWorkspace): LayoutWorkspace;
+export declare let saveTimer: ReturnType<typeof setTimeout> | undefined;
+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. */
+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;
+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 const newLeaf: () => LayoutNode;
+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 declare const baseName: (p: string) => string;
+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;
+export declare function newTab(title: string): LayoutTab;
+export declare function newWorkspace(name: string, cwd: string): LayoutWorkspace;
+/**
+ * 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, opts?: {
+    besideActive?: boolean;
+}): string | null;

package/types/core/workspaces/terminals.d.ts

@@ -0,0 +1,252 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { Terminal } from "@xterm/xterm";
+import { FitAddon } from "@xterm/addon-fit";
+import { LayoutWorkspace } from "./layout";
+export { publishLayout, getLayout, loadLayoutOnce, mutateLayout, useLayout, activeWorkspaceCwd, switchWorkspace, workspaceByCwd, paneCwd, paneLabel, paneLocation, termSpawn, termWrite, termResize, termKill, termList, termSweepScrollback, termScrollback, leafIds, splitLeaf, setLeafLabel, setLeafView, closeLeaf, findLeaf, insertBeside, moveLeaf, openTabInWorkspace } from "./layout";
+export type { SplitDir, LayoutNode, LayoutTab, LayoutWorkspace, FloatBounds, Layout, DropSide } from "./layout";
+export { ZONE_BOARD, zoneAt, zones, zoneOf, zoneToward, moveZone, reorderTab, GROUP_COLORS, addToGroup, leaveGroup, moveGroup, toggleGroupFold, ungroup, setGroup, openActiveGroup, pruneGroups, moveTabToZone, addTabToZone, reopenTab, showActiveTab, nextActiveAfterClose, setTabWindow, mergeWindow, dockWindow, nextZoneSpot, zoneBoardFull } from "./zones";
+export type { Zone, TabGroup } from "./zones";
+/** 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;
+}
+/**
+ * Go to a pane: switch to its workspace and tab, then focus it. The pane only mounts once
+ * Terminals has rendered the newly-selected tab, so the focus is retried across a few frames.
+ */
+export declare function revealPane(paneId: string): boolean;
+/** Give a pane real keyboard focus. No-op if it isn't mounted yet — the caller retries. */
+export declare function focusPane(paneId: string): boolean;
+/**
+ * `agent`: asked for over the control API (an agent), not from Deck's own palette. Then a new
+ * terminal tab or project is added without switching to it (Settings → Where things open,
+ * agentTerminals), its shell started at once (spawnUnseen): a pane starts its shell when it is
+ * first drawn, and the agent's next command goes to that shell.
+ */
+export declare function applyDtCommand(op: string, args: Record<string, unknown>, agent?: boolean): string | void;
+/** Close the pane `pane`: its whole tab when it is the tab's only pane, as an agent's page is. */
+export declare function closePaneTab(pane: 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 10s, 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.mjs.
+ *
+ * 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[];
+/**
+ * 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;
+/** Open a file in this workspace's Editor, whatever opens its type elsewhere (Open with › Editor). */
+export declare function openInEditor(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
+ * 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;
+/** 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;
+/**
+ * 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;
+/** The command that resumes an agent's session, or undefined for a kind Deck cannot resume. */
+export declare const resumeCommand: (kind: string, session: string) => string;
+/**
+ * The agent session each of these panes holds, read fresh from the sweep's file (the map cached at
+ * startup misses an agent started since): for a closed tab to resume it when reopened. Read before
+ * the next sweep, which drops a pane gone from the layout.
+ */
+export declare function agentSessions(ids: string[]): Promise<Record<string, {
+    kind: string;
+    session: string;
+}>>;
+/**
+ * What is running in these panes besides their shells, for a close to ask about: the programs the
+ * sweep saw in each (state/term-procs), or "an agent" for one it has not listed yet. Only panes
+ * with a shell count; a view pane loses nothing by closing.
+ *
+ * ponytail: term-procs is up to 10s old (the sweep's interval), so a program started just before
+ * the close is missed. A term_busy command taking its own snapshot (pane_pids + sweep_procs) would
+ * not be.
+ */
+export declare function runningIn(ids: string[]): Promise<string[]>;
+/**
+ * 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.
+ */
+/**
+ * The terminals drawn in `doc` take its window's scale again: its window moved onto a monitor of
+ * other scaling (a floating window reopened where it was, or dragged there). The same hand-over
+ * as a move between windows (see attach).
+ */
+export declare function rebindTerminals(doc: Document): void;
+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;
+/**
+ * Stop the claude or codex in a pane: asked with Ctrl+C, so it tidies up and prints how to resume,
+ * and killed only if it stays (agent_stop in mem.rs), in which case its leftover modes are cleared.
+ */
+export declare function stopPaneAgent(id: string): Promise<void>;
+/**
+ * Turn off what a killed program left on in the pane's xterm: mouse reporting, focus events,
+ * bracketed paste, a hidden cursor. A program that exits turns these off itself; one killed
+ * never does, so every mouse move after it is typed into the shell. Only xterm is told (not the
+ * PTY), and unlike `term.reset()` the screen and scrollback stay.
+ */
+export declare function resetPaneModes(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;