deck-plugin-sdk 1.6.1 → 1.7.0

package/types/core/browser.d.ts

@@ -36,6 +36,24 @@ export interface BrowserState {
     rotated: boolean;
     /** Devices shown side by side (DeviceBar), the first in the pane's own webview; [] for one. */
     devices: string[];
+    /** The page is not running: asleep after being out of sight, or put away from the memory
+     *  readout. It wakes, or opens again, when the tab is shown. */
+    asleep: boolean;
+    /** The page's process crashed ("exited") or hangs ("unresponsive"); "" while it runs. */
+    crashed: "" | "exited" | "unresponsive";
+    /** An app link the page asked to open (mailto:, zoommtg:), and the site that asked, while the
+     *  pane's bar waits for an answer; "" otherwise. */
+    appLink: string;
+    appOrigin: string;
+    /** A site's request to send notifications, waiting for the pane's bar (0 for none), and the site. */
+    permAsk: number;
+    permOrigin: string;
+    /** A site's sign-in or certificate error waiting for the address bar (0 for none): which, the
+     *  address, and the realm or WebView2's error status. */
+    siteAsk: number;
+    siteKind: "" | "auth" | "cert";
+    siteUri: string;
+    siteDetail: string;
 }
 export declare const subscribeBrowser: (f: () => void) => () => void;
 export declare const browserState: (pane: string) => BrowserState | undefined;
@@ -73,6 +91,19 @@ export declare const totalBlocked: () => number;
 export declare const myFilters: () => Promise<string>;
 /** Save them, and put them to work. */
 export declare function saveMyFilters(text: string): Promise<void>;
+/** The address bar's answer to a site's sign-in or certificate error. */
+export declare function answerSite(pane: string, a: {
+    user?: string;
+    password?: string;
+    proceed?: boolean;
+}): void;
+/** The pane's bar: let the site send notifications, or not. */
+export declare function answerPermission(pane: string, allow: boolean): void;
+/** The pane's bar: open the app link it asked for, and with `always` for that site from now on. */
+export declare function openAppLink(pane: string, always: boolean): Promise<void>;
+export declare const dismissAppLink: (pane: string) => void;
+/** "Wait" on a page that hangs: the bar goes, and comes back if WebView2 reports it again. */
+export declare const dismissCrash: (pane: string) => void;
 /** Lay the pane's page out as a device (DeviceBar's ids), or as itself (""). */
 export declare const setDevice: (pane: string, device: string) => void;
 export declare const setRotated: (pane: string, rotated: boolean) => void;
@@ -186,4 +217,6 @@ export declare function noteTermOutput(pane: string, chunk: string): void;
 export declare function forgetTermPane(pane: string): void;
 /** Where a pane's page is on screen, in Deck's CSS pixels, while it shows one. */
 export declare const pageBox: (pane: string) => DOMRect | null;
+/** Close the pane's webview to give back its memory, keeping the tab and its address. */
+export declare function discardBrowserPane(pane: string): Promise<void>;
 export declare function trackBrowser(pane: string, el: HTMLElement, url: string): () => void;

package/types/core/fileview.d.ts

@@ -24,6 +24,7 @@ export declare const normaliseExts: (exts: unknown) => string[];
  */
 export declare const fileOpeners: {
     id: string;
+    name: string;
     exts: string[];
 }[];
 /** The id of the plugin that opens `path` (by its extension), or undefined: the Editor's. */
@@ -52,3 +53,16 @@ export declare const fileUrl: (path: string) => string;
  * Editor, which the caller opens it in. Every way Deck opens a file asks this first.
  */
 export declare function openByType(path: string, hint?: Opener): boolean;
+/**
+ * Everywhere `path` can open in Deck, for an Open with menu: the Editor, the browser (its types,
+ * on this PC), and each plugin that opens its type, named for the menu.
+ */
+export declare function openersFor(path: string): {
+    to: Opener;
+    label: string;
+}[];
+/**
+ * Open `path` in `to` whatever the Files tab says, for an Open with menu. False for the Editor,
+ * which the caller opens it in (terminals' openInEditor).
+ */
+export declare function openIn(path: string, to: Opener): boolean;

package/types/core/keys.d.ts

@@ -10,7 +10,7 @@
  * 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" | "terminal" | `plugin:${string}`;
+export type Scope = "app" | "workspaces" | "editor" | "terminal" | "browser" | "markdown" | `plugin:${string}`;
 /** Which thing owns the chord. Absent means a plain window listener. */
 export type Surface = "monaco" | "xterm" | "codemirror";
 export interface KeyBinding {
@@ -65,6 +65,14 @@ export declare function conflict(bindings: readonly KeyBinding[], overrides: Ove
 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;
+/**
+ * The bindings in the order a key looks for its owner: every other scope before "app".
+ *
+ * "app" is always live, so if it came first in table order a pane's own binding for the same chord
+ * could never run: the PDF viewer's Ctrl+= zoomed the window, and F11 went to full screen when
+ * the debugger was paused on Step Into. The narrower scope is on screen to be asked first.
+ */
+export declare function byScope(bindings: readonly KeyBinding[]): KeyBinding[];
 /**
  * A chord as Monaco's keycode bitmask, or null when Monaco has no code for it.
  *

package/types/core/keystore.d.ts

@@ -20,6 +20,36 @@ export declare function resetOverrides(): Promise<void>;
 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;
+/** The same, as a person reads it ("Ctrl+B"), for a tooltip or a menu hint; "" when unbound. */
+export declare function keyOf(id: string): string;
+/** A tooltip with the key in force after it: "Go back (Alt+←)", or the label alone when unbound. */
+export declare function withKey(label: string, id: string): string;
+/**
+ * Bind a registry binding inside one Monaco editor, and follow it when it is rebound in Settings.
+ *
+ * Monaco takes its keys before Deck's listener sees them, so a chord it hosts (Save) has to be
+ * handed to it. A one-off `addCommand` read the chord once, at mount: a rebind only reached the
+ * editors opened after it. An action can be disposed, so this swaps it whenever the chord changes.
+ * `monaco` is passed in so this file does not pull in monaco-editor. Returns the cleanup.
+ */
+export declare function bindMonacoKey(ed: {
+    addAction(a: {
+        id: string;
+        label: string;
+        keybindings: number[];
+        run: () => void | Promise<void>;
+    }): {
+        dispose(): void;
+    };
+}, monaco: {
+    KeyMod: {
+        CtrlCmd: number;
+        Alt: number;
+        Shift: number;
+        WinCtrl: number;
+    };
+    KeyCode: object;
+}, id: string, run: () => void | Promise<void>): () => void;
 /**
  * An action, or an action with a `when` guard.
  *

package/types/core/terminals.d.ts

@@ -43,6 +43,8 @@ export interface LayoutTab {
      * 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;
 }
 export interface LayoutWorkspace {
     id: string;
@@ -50,6 +52,8 @@ export interface LayoutWorkspace {
     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;
 }
@@ -121,7 +125,53 @@ export declare function moveZone(tabs: readonly LayoutTab[], id: string, to: {
  * 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): LayoutTab[];
+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.
@@ -147,8 +197,9 @@ export declare function addTabToZone(tabs: readonly LayoutTab[], besideId: strin
  */
 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.
+ * 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;
 /** The first free spot on the top row, for a zone created without a position of its own. */
@@ -186,6 +237,11 @@ export declare function paneLocation(paneId: 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>;
@@ -307,6 +363,8 @@ export declare function paneLines(id: string, max?: number): string[];
  * 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
@@ -384,6 +442,18 @@ export declare function refit(id: string): void;
  * (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

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

@@ -8,6 +8,8 @@ export declare const normPath: (p: string) => string;
 export declare const dirName: (p: string) => string;
 /** A repo as a picker names it: its path under `root`, or its own name when it is not under it. */
 export declare function repoLabel(root: string, repo: string): string;
+/** The repo a path is in: the deepest of `repos` that holds it (a nested repo before its parent). */
+export declare function repoOf(repos: readonly string[], path: string): string | undefined;
 export interface ChangeDir<T> {
     kind: "dir";
     name: string;