deck-plugin-sdk 0.15.1 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deck-plugin-sdk",
-  "version": "0.15.1",
+  "version": "0.17.0",
   "description": "Build a plugin for Deck, outside the Deck repository.",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "README.md"
   ],
   "dependencies": {
-    "esbuild": "^0.25.0"
+    "esbuild": "^0.28.0"
   },
   "peerDependencies": {
     "@types/react": "^19.0.0",
@@ -31,12 +31,22 @@
     "typescript": "^5.0.0"
   },
   "peerDependenciesMeta": {
-    "framer-motion": { "optional": true },
-    "monaco-editor": { "optional": true },
-    "typescript": { "optional": true }
+    "framer-motion": {
+      "optional": true
+    },
+    "monaco-editor": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=20"
   },
-  "keywords": ["deck", "plugin", "sdk"]
+  "keywords": [
+    "deck",
+    "plugin",
+    "sdk"
+  ]
 }

package/shim/bridge.js

@@ -12,6 +12,8 @@ const b = () => {
 export const askAssistant = (...a) => b().askAssistant(...a);
 export const calendarCached = (...a) => b().calendarCached(...a);
 export const calendarRefresh = (...a) => b().calendarRefresh(...a);
+export const claudeMcpEntry = (...a) => b().claudeMcpEntry(...a);
+export const claudeMcpStatus = (...a) => b().claudeMcpStatus(...a);
 export const claudePlanLimits = (...a) => b().claudePlanLimits(...a);
 export const claudeUsage = (...a) => b().claudeUsage(...a);
 export const clearWallpaper = (...a) => b().clearWallpaper(...a);
@@ -48,12 +50,18 @@ export const fsWrite = (...a) => b().fsWrite(...a);
 export const fsWriteBytes = (...a) => b().fsWriteBytes(...a);
 export const getAutostart = (...a) => b().getAutostart(...a);
 export const getVaultRoot = (...a) => b().getVaultRoot(...a);
+export const ghPrLineComment = (...a) => b().ghPrLineComment(...a);
+export const ghPrThreads = (...a) => b().ghPrThreads(...a);
+export const ghRun = (...a) => b().ghRun(...a);
+export const ghThreadReply = (...a) => b().ghThreadReply(...a);
+export const ghThreadResolve = (...a) => b().ghThreadResolve(...a);
 export const gitAbortOp = (...a) => b().gitAbortOp(...a);
 export const gitAiCommitMsg = (...a) => b().gitAiCommitMsg(...a);
 export const gitBlameLine = (...a) => b().gitBlameLine(...a);
 export const gitBranchAt = (...a) => b().gitBranchAt(...a);
 export const gitBranchDelete = (...a) => b().gitBranchDelete(...a);
 export const gitBranchDeleteRemote = (...a) => b().gitBranchDeleteRemote(...a);
+export const gitBranchRename = (...a) => b().gitBranchRename(...a);
 export const gitBranches = (...a) => b().gitBranches(...a);
 export const gitCheckout = (...a) => b().gitCheckout(...a);
 export const gitCheckoutDetach = (...a) => b().gitCheckoutDetach(...a);
@@ -63,22 +71,32 @@ export const gitCherryPick = (...a) => b().gitCherryPick(...a);
 export const gitCommit = (...a) => b().gitCommit(...a);
 export const gitCommitAmend = (...a) => b().gitCommitAmend(...a);
 export const gitCommitFiles = (...a) => b().gitCommitFiles(...a);
+export const gitContinueOp = (...a) => b().gitContinueOp(...a);
 export const gitDiscard = (...a) => b().gitDiscard(...a);
 export const gitFetch = (...a) => b().gitFetch(...a);
+export const gitFetchPr = (...a) => b().gitFetchPr(...a);
 export const gitFileBytes = (...a) => b().gitFileBytes(...a);
 export const gitFileDiff = (...a) => b().gitFileDiff(...a);
+export const gitHead = (...a) => b().gitHead(...a);
 export const gitHeadFile = (...a) => b().gitHeadFile(...a);
 export const gitIndexFile = (...a) => b().gitIndexFile(...a);
 export const gitInfo = (...a) => b().gitInfo(...a);
 export const gitLogGraph = (...a) => b().gitLogGraph(...a);
 export const gitMerge = (...a) => b().gitMerge(...a);
+export const gitMergeAs = (...a) => b().gitMergeAs(...a);
+export const gitMergeBase = (...a) => b().gitMergeBase(...a);
 export const gitPendingOp = (...a) => b().gitPendingOp(...a);
 export const gitPull = (...a) => b().gitPull(...a);
 export const gitPullRebase = (...a) => b().gitPullRebase(...a);
 export const gitPush = (...a) => b().gitPush(...a);
 export const gitPushBranch = (...a) => b().gitPushBranch(...a);
+export const gitRangeFiles = (...a) => b().gitRangeFiles(...a);
+export const gitRangeSubjects = (...a) => b().gitRangeSubjects(...a);
+export const gitRebase = (...a) => b().gitRebase(...a);
 export const gitRefs = (...a) => b().gitRefs(...a);
+export const gitRemoteUrl = (...a) => b().gitRemoteUrl(...a);
 export const gitRemotes = (...a) => b().gitRemotes(...a);
+export const gitRepos = (...a) => b().gitRepos(...a);
 export const gitResetTo = (...a) => b().gitResetTo(...a);
 export const gitRevert = (...a) => b().gitRevert(...a);
 export const gitShowFile = (...a) => b().gitShowFile(...a);
@@ -107,6 +125,7 @@ export const historyDelete = (...a) => b().historyDelete(...a);
 export const httpSend = (...a) => b().httpSend(...a);
 export const importIconPack = (...a) => b().importIconPack(...a);
 export const installClaudeHooks = (...a) => b().installClaudeHooks(...a);
+export const installClaudeMcp = (...a) => b().installClaudeMcp(...a);
 export const installFromRegistry = (...a) => b().installFromRegistry(...a);
 export const installPlugin = (...a) => b().installPlugin(...a);
 export const isFullscreen = (...a) => b().isFullscreen(...a);
@@ -151,6 +170,7 @@ export const readMusicTaste = (...a) => b().readMusicTaste(...a);
 export const readTermLayout = (...a) => b().readTermLayout(...a);
 export const readTrackMeta = (...a) => b().readTrackMeta(...a);
 export const removeClaudeHooks = (...a) => b().removeClaudeHooks(...a);
+export const removeClaudeMcp = (...a) => b().removeClaudeMcp(...a);
 export const restartApp = (...a) => b().restartApp(...a);
 export const revealInFolder = (...a) => b().revealInFolder(...a);
 export const runScriptNow = (...a) => b().runScriptNow(...a);

package/shim/terminals.js

@@ -12,6 +12,7 @@ const t = () => {
 
 export const ZONE_BOARD = (...a) => t().ZONE_BOARD(...a);
 export const activeWorkspaceCwd = (...a) => t().activeWorkspaceCwd(...a);
+export const addTabToZone = (...a) => t().addTabToZone(...a);
 export const applyDtCommand = (...a) => t().applyDtCommand(...a);
 export const applyTerminalLook = (...a) => t().applyTerminalLook(...a);
 export const attach = (...a) => t().attach(...a);
@@ -33,6 +34,7 @@ export const moveLeaf = (...a) => t().moveLeaf(...a);
 export const moveWorkspace = (...a) => t().moveWorkspace(...a);
 export const moveZone = (...a) => t().moveZone(...a);
 export const mutateLayout = (...a) => t().mutateLayout(...a);
+export const nextActiveAfterClose = (...a) => t().nextActiveAfterClose(...a);
 export const nextZoneSpot = (...a) => t().nextZoneSpot(...a);
 export const openTabInWorkspace = (...a) => t().openTabInWorkspace(...a);
 export const paneCwd = (...a) => t().paneCwd(...a);
@@ -48,6 +50,7 @@ export const restartPane = (...a) => t().restartPane(...a);
 export const sendInput = (...a) => t().sendInput(...a);
 export const setLeafLabel = (...a) => t().setLeafLabel(...a);
 export const setLeafView = (...a) => t().setLeafView(...a);
+export const showActiveTab = (...a) => t().showActiveTab(...a);
 export const splitLeaf = (...a) => t().splitLeaf(...a);
 export const suspendWorkspace = (...a) => t().suspendWorkspace(...a);
 export const switchWorkspace = (...a) => t().switchWorkspace(...a);
@@ -67,4 +70,6 @@ export const workspaceByCwd = (...a) => t().workspaceByCwd(...a);
 export const workspaceShellCount = (...a) => t().workspaceShellCount(...a);
 export const zoneAt = (...a) => t().zoneAt(...a);
 export const zoneBoardFull = (...a) => t().zoneBoardFull(...a);
+export const zoneOf = (...a) => t().zoneOf(...a);
 export const zoneToward = (...a) => t().zoneToward(...a);
+export const zones = (...a) => t().zones(...a);

package/template/plugin.json

@@ -4,5 +4,5 @@
   "description": "One line on what this is for, shown under its name in Settings.",
   "icon": "Sparkles",
   "version": "0.1.0",
-  "minDeck": "0.15.0"
+  "minDeck": "0.17.0"
 }

package/types/core/bridge.d.ts

@@ -506,9 +506,25 @@ export declare const fsDelete: (path: string) => Promise<void>;
 export declare const fsCopy: (src: string, dstDir: string) => Promise<string>;
 export declare const fsReveal: (path: string) => Promise<void>;
 export declare const installClaudeHooks: () => Promise<void>;
+/**
+ * Deck's MCP server, which lets an agent drive Deck's terminals and HTTP client.
+ *
+ * The server ships with Deck as a single bundled file, so there is nothing to clone or install.
+ * Registering it adds one entry to ~/.claude.json — a file that belongs to Claude Code, so Deck
+ * backs it up first, merges rather than replaces, and refuses outright if it cannot parse it.
+ *
+ * `claudeMcpStatus` is "missing", "current", or "stale" — stale meaning an entry exists but
+ * points somewhere else, which is what a reinstall to a different folder leaves behind.
+ */
+export declare const claudeMcpStatus: () => Promise<string>;
+export declare const claudeMcpEntry: () => Promise<string>;
+export declare const installClaudeMcp: () => Promise<string>;
+export declare const removeClaudeMcp: () => Promise<void>;
 export declare const removeClaudeHooks: () => Promise<void>;
 export declare const notifyOs: (title: string, body: string) => Promise<void>;
 export declare const gitStatus: (dir: string) => Promise<GitStatusRow[]>;
+/** The repos a folder holds: the one it is inside first, then any below it. Each a repo's top level. */
+export declare const gitRepos: (dir: string) => Promise<string[]>;
 export interface BlameLine {
     hash: string;
     author: string;
@@ -591,9 +607,37 @@ export declare const gitUndoCommit: (dir: string) => Promise<string>;
 export declare const gitBranchAt: (dir: string, name: string, rev: string) => Promise<string>;
 export declare const gitRevert: (dir: string, rev: string) => Promise<string>;
 export declare const gitCherryPick: (dir: string, rev: string) => Promise<string>;
-export declare const gitResetTo: (dir: string, rev: string, mode: "soft" | "mixed" | "hard") => Promise<string>;
+export declare const gitResetTo: (dir: string, rev: string, mode: "soft" | "mixed" | "hard" | "keep") => Promise<string>;
 export declare const gitTag: (dir: string, name: string, rev: string, message?: string) => Promise<string>;
 export declare const gitMerge: (dir: string, rev: string, noFf?: boolean) => Promise<string>;
+/** Rebase the current branch onto `onto`; a conflict leaves it pending (gitPendingOp → "rebase"). */
+export declare const gitRebase: (dir: string, onto: string) => Promise<string>;
+/** HEAD's commit and branch ("" when detached) — what an undo returns to. */
+export declare const gitHead: (dir: string) => Promise<{
+    hash: string;
+    branch: string;
+}>;
+/** Merge `rev` into the current branch: a merge commit always, fast-forward when possible, or squashed into one commit. */
+export declare const gitMergeAs: (dir: string, rev: string, style: "no-ff" | "ff" | "squash") => Promise<string>;
+/** Finish a merge, rebase, revert or cherry-pick (what gitPendingOp reported) once its conflicts are staged. */
+export declare const gitContinueOp: (dir: string, op: string) => Promise<string>;
+/** Subjects of the commits on `head` that `base` lacks, oldest first. */
+export declare const gitRangeSubjects: (dir: string, base: string, head: string) => Promise<string[]>;
+export declare const gitRemoteUrl: (dir: string, name: string) => Promise<string>;
+/** The GitHub CLI, `gh pr …` or `gh repo view …` only. Rejects with "gh-missing" when gh is not installed. */
+export declare const ghRun: (dir: string, args: string[]) => Promise<string>;
+/** Pull request N's review threads, as GitHub's GraphQL JSON (parsed by prs.ts parseThreads). */
+export declare const ghPrThreads: (dir: string, number: number) => Promise<string>;
+/** Comment on one line of a PR's diff: side "RIGHT" is the new version, "LEFT" the old. */
+export declare const ghPrLineComment: (dir: string, number: number, commit: string, path: string, line: number, side: "LEFT" | "RIGHT", body: string) => Promise<string>;
+export declare const ghThreadReply: (dir: string, thread: string, body: string) => Promise<string>;
+export declare const ghThreadResolve: (dir: string, thread: string, resolve: boolean) => Promise<string>;
+/** The files that differ between two revisions. */
+export declare const gitRangeFiles: (dir: string, from: string, to: string) => Promise<CommitFile[]>;
+export declare const gitMergeBase: (dir: string, a: string, b: string) => Promise<string>;
+/** Fetch pull request N's head from `remote`, so its commits can be diffed here. */
+export declare const gitFetchPr: (dir: string, remote: string, number: number, base: string) => Promise<string>;
+export declare const gitBranchRename: (dir: string, from: string, to: string) => Promise<string>;
 export declare const gitPendingOp: (dir: string) => Promise<string>;
 export declare const gitAbortOp: (dir: string, op: string) => Promise<string>;
 export declare const gitBranchDelete: (dir: string, name: string, force?: boolean) => Promise<string>;

package/types/core/keys.d.ts

@@ -0,0 +1,90 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/**
+ * Where a binding applies.
+ *
+ * Not decoration. App.tsx renders exactly one module and keys it by id, so navigating UNMOUNTS
+ * the previous one: Alt+Z and Ctrl+Alt+Space are window listeners today, but they only exist
+ * while Workspaces is on screen. A registry that ignored that would silently make every binding
+ * global, which is a behaviour change nobody asked for.
+ *
+ * It is also what lets two bindings share a chord honestly — the editor's save and a terminal
+ * action can both be Ctrl+S if the two surfaces never have the keyboard at the same time.
+ */
+export type Scope = "app" | "workspaces" | "editor" | "http" | "terminal" | `plugin:${string}`;
+/** Which thing owns the chord. Absent means a plain window listener. */
+export type Surface = "monaco" | "xterm" | "codemirror";
+export interface KeyBinding {
+    /** Stable and namespaced — "app:palette", "plugin:db:run". The id is what an override keys on,
+     *  so renaming one silently drops a user's binding. Treat these as permanent. */
+    id: string;
+    /** What the settings panel shows. */
+    title: string;
+    scope: Scope;
+    /** Canonical form, e.g. "ctrl+shift+p". Never a display string. */
+    defaultChord: string;
+    surface?: Surface;
+}
+/**
+ * A key event as its canonical chord, or "" when the event is a bare modifier.
+ *
+ * A modifier alone is not a chord — holding Ctrl fires keydown with key "Control", and treating
+ * that as a binding would make every chord fire its own prefix on the way down.
+ */
+export declare function parseChord(e: Pick<KeyboardEvent, "key" | "code" | "ctrlKey" | "altKey" | "shiftKey" | "metaKey">): string;
+/** Put a chord's parts in the canonical order, so a hand-edited config file still matches. */
+export declare function normalizeChord(chord: string): string;
+/** A chord as a person reads it: "ctrl+shift+p" -> "Ctrl+Shift+P". */
+export declare function formatChord(chord: string): string;
+/**
+ * What the user changed, and nothing else.
+ *
+ * A sparse map, never a full snapshot of the table. Deck already stores exceptions this way for
+ * the footer's order and for which plugins are off, and for the same reason: a binding added in
+ * a later version has to appear for someone who has customised something else, rather than being
+ * masked by a stale copy of the old table. An empty string means "unbound", which is different
+ * from absent (= use the default).
+ */
+export type Overrides = Record<string, string>;
+/** The chord in force for every binding: its default, with any override applied. */
+export declare function resolve(bindings: readonly KeyBinding[], overrides: Overrides): Map<string, string>;
+/** The reverse: which binding owns a chord in a given scope. Keyed "scope\u0000chord". */
+export declare function chordIndex(bindings: readonly KeyBinding[], overrides: Overrides): Map<string, string>;
+/**
+ * The binding already holding `chord` in `scope`, or null.
+ *
+ * Scope-aware on purpose: the same chord in two scopes that never have the keyboard at once is
+ * not a clash, and refusing it would be a lie. Only a collision within one scope blocks a save.
+ */
+export declare function conflict(bindings: readonly KeyBinding[], overrides: Overrides, id: string, chord: string): KeyBinding | null;
+/**
+ * Whether `scope` is live given the scopes currently active.
+ *
+ * "app" is always live. Everything else has to be in the set, which is what stops a Workspaces
+ * chord firing while the Editor has the screen.
+ */
+export declare function scopeActive(scope: Scope, active: ReadonlySet<Scope>): boolean;
+/** The binding to run for an event, or null. Scope-aware, so the caller need not filter. */
+export declare function match(bindings: readonly KeyBinding[], overrides: Overrides, e: Parameters<typeof parseChord>[0], active: ReadonlySet<Scope>): KeyBinding | null;
+/**
+ * A chord as Monaco's keycode bitmask, or null when Monaco has no code for it.
+ *
+ * Monaco owns its own keybindings, so a chord bound to something it hosts has to be handed over
+ * in its terms. Kept here beside the parsing rather than in the editor, so there is still one
+ * place that knows what a chord is.
+ *
+ * `mods` and `codes` are passed in rather than imported: this file must not pull in
+ * monaco-editor, which is megabytes and would land in every check that touches keys.ts.
+ */
+export declare function toMonaco(chord: string, mods: {
+    CtrlCmd: number;
+    Alt: number;
+    Shift: number;
+    WinCtrl: number;
+}, codes: Record<string, number>): number | null;
+/**
+ * Deck's built-in bindings.
+ *
+ * Plugin bindings are not here — they arrive at load time through the `keybindings` export and
+ * are concatenated on, so a disabled plugin's chords leave the table with it.
+ */
+export declare const DEFAULT_BINDINGS: readonly KeyBinding[];

package/types/core/keystore.d.ts

@@ -0,0 +1,45 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type KeyBinding, type Overrides, type Scope } from "./keys";
+export declare function setPluginBindings(list: readonly KeyBinding[]): void;
+/** Every binding in force: Deck's own, plus whatever the loaded plugins contribute. */
+export declare function allBindings(): readonly KeyBinding[];
+/** Read the saved overrides. Safe to call repeatedly; only the first does any work. */
+export declare function loadOverrides(): Promise<void>;
+export declare function getOverrides(): Overrides;
+/**
+ * Rebind one command, or clear it with "".
+ *
+ * The whole map is written, but only the entries that differ from the defaults are IN the map —
+ * see the note on Overrides in keys.ts. Setting a binding back to its default removes its entry
+ * rather than recording it, so the file stays a list of exceptions.
+ */
+export declare function setOverride(id: string, chord: string): Promise<void>;
+/** Drop every override, returning the whole table to its defaults. */
+export declare function resetOverrides(): Promise<void>;
+/** Subscribe for React. */
+export declare function useKeybindings(): number;
+/** The chord in force for a binding, for a label or a tooltip. */
+export declare function chordFor(id: string): string;
+/** Register one action. Returns a disposer; call it on unmount. */
+export declare function onKey(id: string, run: () => void): () => void;
+/** Register several at once — what a module with a dozen chords wants. */
+export declare function onKeys(map: Record<string, () => void>): () => void;
+/** Claim a scope. Returns a disposer. */
+export declare function pushScope(scope: Scope): () => void;
+export declare function activeScopes(): ReadonlySet<Scope>;
+/**
+ * Run whatever this event is bound to, and say whether anything did.
+ *
+ * The caller decides about preventDefault — this cannot, because some bindings want the default
+ * suppressed (the palette) and some do not (a chord whose action declines to act, like Ctrl+7
+ * with only three projects open).
+ */
+export declare function dispatch(e: KeyboardEvent): boolean;
+/**
+ * Whether a chord belongs to something OTHER than a focused terminal.
+ *
+ * xterm's key handler asks this to decide what to swallow, so the swallow list is derived from
+ * the table rather than written out a second time. The hand-maintained copy it replaces had
+ * already drifted: Ctrl+Alt+N and Ctrl+` were missing from it, so both reached the shell.
+ */
+export declare function claimedOutsideTerminal(e: KeyboardEvent): boolean;

package/types/core/terminals.d.ts

@@ -37,6 +37,12 @@ export interface LayoutTab {
     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;
 }
 export interface LayoutWorkspace {
     id: string;
@@ -63,18 +69,31 @@ export declare function switchWorkspace(wsId: string, tabId?: string): void;
  * 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.
- */
+/** 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 zone to move to from `id` going `dir`, or null when there is none that way.
+ * 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.
@@ -83,17 +102,37 @@ export declare function zoneToward(tabs: readonly LayoutTab[], id: string, dir:
 /**
  * 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.
- *
- * 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[];
+/**
+ * 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[];
+/**
+ * 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: another tab in the same zone if it has one, so
+ * closing a tab does not also throw you out of the zone; otherwise the first zone left.
+ */
+export declare function nextActiveAfterClose(tabs: readonly LayoutTab[], closing: string): string | undefined;
 /** 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;
@@ -102,6 +141,8 @@ export declare function nextZoneSpot(tabs: readonly LayoutTab[], cols?: 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.