deck-plugin-sdk 1.11.1 → 1.12.1

package/types/core/terminals.d.ts

@@ -1,573 +0,0 @@
-// 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;
-    /**
-     * 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/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/floatwin.ts openInFloat): "links", "agent". */
-    name?: string;
-}
-export interface Layout {
-    workspaces: LayoutWorkspace[];
-    activeWs: string;
-    floats?: FloatBounds[];
-}
-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 tab sits on the canvas — which is to say, which zone it belongs to. */
-export declare function zoneAt(tabs: readonly LayoutTab[], id: string, cols?: number): {
-    x: number;
-    y: number;
-};
-/** One zone: a cell, the tabs in it in list order, and the one it shows. */
-export interface Zone {
-    x: number;
-    y: number;
-    tabs: LayoutTab[];
-    front: LayoutTab;
-}
-/**
- * The tabs grouped into zones, one per occupied cell, in the order each cell first appears.
- *
- * The front tab is the one not marked `hidden` — the last one shown there, which is what makes a
- * zone open on the tab you left it on. A cell whose tabs are ALL hidden (its front was closed
- * from outside, by an agent) shows its first, rather than nothing.
- */
-export declare function zones(tabs: readonly LayoutTab[], cols?: number): Zone[];
-/** The zone holding a tab. */
-export declare function zoneOf(tabs: readonly LayoutTab[], id: string): Zone | undefined;
-/**
- * The zone to move to from `id` going `dir`, as the tab it would show, 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.
- *
- * Every tab in the zone moves, since the zone IS the tabs sharing a cell — moving only the one
- * named would split it in two.
- *
- * 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.
- */
-export declare function moveZone(tabs: readonly LayoutTab[], id: string, to: {
-    x: number;
-    y: number;
-}): LayoutTab[];
-/**
- * Move a tab to just before or after another — the order a zone's strip shows its tabs in, which
- * is their order in the list.
- *
- * Every tab's cell is pinned first (placeAll): a tab with no stored position takes its cell from
- * its index, so reordering the list could otherwise move a zone you never touched.
- */
-export declare function reorderTab(tabs: readonly LayoutTab[], srcId: string, overId: string, after: boolean, 
-/** A drag in the strip says which group the tab ends up in: the one of the tab it is held over
- *  (null: none, held over a tab outside any group or over a group's chip). Left out, the tabs
- *  either side decide (settleGroup). */
-group?: string | null): LayoutTab[];
-/** A tab group: its tabs carry its id. Its colour is an index into GROUP_COLORS. */
-export interface TabGroup {
-    id: string;
-    name: string;
-    color: number;
-    folded?: boolean;
-}
-/** Chrome's group colours, tuned for Deck's dark surfaces. */
-export declare const GROUP_COLORS: string[];
-/**
- * Put a tab in a group: `groupId`, or a new one in the next colour not yet used (its id is
- * returned, so its editor can open). The tab moves next to the group's other tabs.
- */
-export declare function addToGroup(w: LayoutWorkspace, tabId: string, groupId?: string): {
-    w: LayoutWorkspace;
-    groupId: string;
-};
-/** Take a tab out of its group, to just after the group's tabs. */
-export declare function leaveGroup(w: LayoutWorkspace, tabId: string): LayoutWorkspace;
-/**
- * Move a whole group, its tabs in their order, to just before or after `overId`. Over another
- * group's tab it goes before or after that group as a whole, never into the middle of it.
- */
-export declare function moveGroup(tabs: readonly LayoutTab[], groupId: string, overId: string, after: boolean): LayoutTab[];
-/**
- * Fold a group, or open it. A group holding the tab its zone shows is not folded over it: the
- * zone moves to the nearest tab outside the group that is not itself folded away (after the group
- * first, then before it). With none, `makeTab` gives a new tab for the zone to open on; without
- * it, the group stays open.
- */
-export declare function toggleGroupFold(w: LayoutWorkspace, groupId: string, makeTab?: () => LayoutTab): LayoutWorkspace;
-/** The group goes; its tabs stay where they are. */
-export declare function ungroup(w: LayoutWorkspace, groupId: string): LayoutWorkspace;
-/** Change a group's name, colour or fold. */
-export declare function setGroup(w: LayoutWorkspace, groupId: string, patch: Partial<Omit<TabGroup, "id">>): LayoutWorkspace;
-/**
- * The open tab is never folded away: however it came to be open (the tab beside a closed one, the
- * switcher, a shortcut, an agent's notification), a folded group holding it opens.
- */
-export declare function openActiveGroup(w: LayoutWorkspace): LayoutWorkspace;
-/** A group with no tabs left goes (its last tab closed, moved to another zone, taken out). */
-export declare function pruneGroups(w: LayoutWorkspace): LayoutWorkspace;
-/**
- * Move one tab to another zone's cell — joining the zone there as the tab it shows, or making a
- * new zone in an empty cell. The zone it left keeps its other tabs.
- */
-export declare function moveTabToZone(tabs: readonly LayoutTab[], tabId: string, to: {
-    x: number;
-    y: number;
-}): LayoutTab[];
-/**
- * Add a tab to the zone holding `besideId`, as the tab it shows.
- *
- * The others there are marked hidden here rather than left to the active-tab normaliser, so the
- * result is right even for a zone that is not the active one.
- */
-export declare function addTabToZone(tabs: readonly LayoutTab[], besideId: string, tab: LayoutTab): LayoutTab[];
-/**
- * A closed tab put back in workspace `w` (core/closedtabs.ts): in front in the zone you are in,
- * with new ids for the tab and its panes, since the old panes' shells and state are gone. Out of
- * any group and any window it was in. Returns the workspace and each old pane's new id.
- */
-export declare function reopenTab(w: LayoutWorkspace, tab: LayoutTab, fresh?: () => string): {
-    w: LayoutWorkspace;
-    ids: Record<string, string>;
-};
-/**
- * Make a workspace's active tab the one its zone shows.
- *
- * Run on every layout write (mutateLayout), so whatever made a tab active — a click in the
- * strip, the compass, an agent notification jumping to a pane in a tab behind another — the
- * zone ends up showing it, and remembers it next time. One place rather than every caller that
- * sets activeTab, of which there are many and will be more.
- */
-export declare function showActiveTab(w: LayoutWorkspace): LayoutWorkspace;
-/**
- * Which tab becomes active when `closing` goes: the one beside it in the same zone (the next, or
- * the one before when it was last), as a browser does, so closing a tab neither throws you out of
- * the zone nor back to its first tab; otherwise the first zone left.
- */
-export declare function nextActiveAfterClose(tabs: readonly LayoutTab[], closing: string): string | undefined;
-/**
- * Tear a tab off into window `win`, or (`win` undefined) dock it back. A workspace always keeps
- * one docked tab: floating its last one leaves a fresh terminal behind, as the main window has
- * to show something. Tearing off the active tab makes its neighbour active.
- */
-export declare function setTabWindow(w: LayoutWorkspace, tabId: string, win: string | undefined, keepGroup?: boolean): LayoutWorkspace;
-/**
- * Merge floating window `from`'s tabs into another window: floating window `into`, or (`into`
- * null) the main window, into the active zone of the project it shows. They go in behind the tab
- * that window shows, which stays shown: a tab dropped somewhere does not take you away from the one
- * you were on. The tabs move between projects when the window they land in shows another one's,
- * since a window holds one project's tabs.
- */
-export declare function mergeWindow(l: Layout, from: string, into: string | null): Layout;
-/**
- * Close floating window `id` into the main window: its tabs go back to their zones, each behind the
- * tab its zone shows, so closing a window does not take you away from the tab you are on. With
- * `discard` (its X, Alt+F4), the tabs Deck opened into it (`transient`) close instead; the caller
- * destroys their panes.
- */
-export declare function dockWindow(l: Layout, id: string, discard?: boolean): Layout;
-/** 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?
- *
- * Counts zones, not tabs: a zone can hold several tabs and still take one cell.
- *
- * 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;
-/**
- * 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;
-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, opts?: {
-    besideActive?: boolean;
-}): string | null;
-/**
- * `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;
-export {};