deck-plugin-sdk 1.4.0 → 1.6.0

package/types/core/browser.d.ts

@@ -0,0 +1,189 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type RecentPage } from "./browserurl";
+import { type Bookmarks } from "./bookmarks";
+/**
+ * `home`: the pane shows Deck's start page, and its webview (if it has one) is hidden. `back` and
+ * `forward`: whether the page has history that way. `private`: nothing it visits is kept.
+ * `page`: which of Deck's own pages the pane shows instead of a site, with `home` set too so the
+ * webview stays hidden ("" with `home` is the start page).
+ */
+export type DeckPage = "" | "history" | "bookmarks" | "settings" | "downloads" | "passwords" | "extensions";
+export interface BrowserState {
+    url: string;
+    title: string;
+    loading: boolean;
+    home: boolean;
+    page: DeckPage;
+    back: boolean;
+    forward: boolean;
+    private: boolean;
+    /** The find bar: shown, and the matches the search has (index is the current one, from 1). */
+    findOpen: boolean;
+    findCount: number;
+    findIndex: number;
+    /** The site's icon, whether the page plays sound and is muted, and its zoom (1 = 100%). */
+    favicon: string;
+    playing: boolean;
+    muted: boolean;
+    zoom: number;
+    /** The tab's own volume, 0 to 1, over what the page sets (VOLUME_JS in browser.rs). */
+    volume: number;
+    /** Ads and trackers the ad blocker refused on the current page. */
+    blocked: number;
+    /** The device the page is laid out as (DeviceBar), "" for the page's own size. */
+    device: string;
+    /** The device turned on its side (width and height swapped). */
+    rotated: boolean;
+    /** Devices shown side by side (DeviceBar), the first in the pane's own webview; [] for one. */
+    devices: string[];
+}
+export declare const subscribeBrowser: (f: () => void) => () => void;
+export declare const browserState: (pane: string) => BrowserState | undefined;
+/**
+ * The pane is gone (closed, or its tab or workspace was): close its webview and forget its page.
+ * Called from terminals.ts's destroy(), which every way of removing a pane goes through.
+ */
+export declare function closeBrowserPane(pane: string): void;
+/** The find bar registers how to focus its box, for Ctrl+F while it is already open. */
+export declare function registerFindBox(pane: string, focus: () => void): () => void;
+/** Open the find bar (Ctrl+F), or put the keyboard back in it when it is open. */
+export declare function openFind(pane: string): void;
+/** Close it and clear the page's highlights. */
+export declare function closeFind(pane: string): void;
+/** Show the start page in the pane, or leave it for `url`. */
+export declare const showHome: (pane: string) => void;
+export declare const leaveHome: (pane: string, url: string) => void;
+/** Show the history page in the pane. */
+export declare const showHistory: (pane: string) => void;
+/** Show the bookmarks page in the pane. */
+export declare const showBookmarks: (pane: string) => void;
+/** Show the downloads in the pane. */
+export declare const showDownloads: (pane: string) => void;
+/** Show the extensions in the pane. */
+export declare const showExtensions: (pane: string) => void;
+/** Show the password vault in the pane. */
+export declare const showPasswords: (pane: string) => void;
+/** Show the browser's settings in the pane. */
+export declare const showBrowserSettings: (pane: string) => void;
+/** A new pane's kind, before anything else is known about it. */
+export declare const startPane: (pane: string, isPrivate: boolean) => void;
+/** Every ad and tracker blocked so far. */
+export declare const totalBlocked: () => number;
+/** The user's own ad blocker rules, as text. */
+export declare const myFilters: () => Promise<string>;
+/** Save them, and put them to work. */
+export declare function saveMyFilters(text: string): Promise<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;
+/** Show these devices side by side (the first in the pane's own webview), or one ([]). */
+export declare const setDevices: (pane: string, devices: string[]) => void;
+/** A side-by-side device's webview rather than a pane's own. */
+export declare function isMirror(pane: string): boolean;
+/** The pane a mirror belongs to (a pane is its own). */
+export declare function paneOf(id: string): string;
+export declare function addMirror(id: string): void;
+export declare function removeMirror(id: string): void;
+/** Close a pane's mirrors from the `from`th on: side by side switched off, a device taken away, the
+ *  pane closed. Not when the pane is only out of sight: a mirror stays, hidden, as the pane's own
+ *  webview does, so coming back neither reloads it nor races a close against a reopen. */
+export declare function closeMirrors(pane: string, from?: number): void;
+/** Mute or unmute a pane's page. */
+export declare const setMuted: (pane: string, muted: boolean) => undefined;
+/** The tab's volume, 0 to 1. Kept for the tab, and sent again to each page it loads. */
+export declare function setVolume(pane: string, v: number): void;
+/** A browser pane says how to tell whether it has the keyboard and is showing a page. */
+export declare function registerZoomTarget(pane: string, holds: () => boolean): () => void;
+/** The browser pane whose page Deck's zoom keys should zoom, if the keyboard is in one. */
+export declare const activeBrowserPage: () => string | undefined;
+/** Zoom the pane's page a step in or out, or back to 100% (0). */
+export declare function stepZoom(pane: string, dir: -1 | 0 | 1): void;
+/** The URL a just-opened browser pane should show, if a page asked for it. */
+export declare const takeWaitingUrl: () => {
+    url: string;
+    private: boolean;
+} | undefined;
+/** A new browser tab, on `url` or on the start page. */
+export declare const newBrowserTab: (url?: string, isPrivate?: boolean) => boolean | void;
+/** Read once, before the first browser pane asks. */
+export declare const loadPanes: () => Promise<void>;
+/** The page a pane was on when Deck last closed. */
+export declare const savedPage: (pane: string) => string | undefined;
+/** How Ctrl+Shift+B shows or hides the bookmarks bar: set by the browser pane, which holds the settings. */
+export declare const setBarToggle: (f: () => void) => void;
+/** Bookmark the pane's page, as its star does: Ctrl+D, and the browser menu. */
+export declare const pressStar: (pane: string) => void | undefined;
+/** The pane's star registers how to bookmark the page, for Ctrl+D. */
+export declare function registerStar(pane: string, run: () => void): () => void;
+/** The pane's key in the address bar registers what Ctrl+Shift+L does: fill the login, or offer the choice. */
+export declare function registerVaultKey(pane: string, run: () => void): () => void;
+/** The pane's address bar registers how to focus it, for Ctrl+L. */
+export declare function registerAddressBar(pane: string, focus: () => void): () => void;
+/** Tell Rust which chords to take from a page. Called when a browser pane mounts and whenever a
+ *  binding changes. */
+export declare function syncBrowserKeys(): void;
+export interface Pin {
+    title: string;
+    url: string;
+}
+export declare const subscribeLists: (f: () => void) => () => void;
+export declare const listsSnapshot: () => number;
+export declare const browserPins: () => Pin[];
+export declare const recentPages: () => RecentPage[];
+export declare const ensureLists: () => undefined;
+/** `id` is Rust's, for pausing and cancelling, and starts again each run; `key` is unique for good.
+ *  `session`: started since Deck opened, so the toolbar shows it. */
+export interface Download {
+    key: string;
+    id: number;
+    pane: string;
+    url: string;
+    path: string;
+    received: number;
+    total: number;
+    state: "running" | "paused" | "done" | "failed";
+    started: number;
+    session: boolean;
+    /** An extension being installed from the store (extensions.rs), not a file: its name once known. */
+    extension?: string;
+}
+export declare const subscribeDownloads: (f: () => void) => () => void;
+export declare const downloadsSnapshot: () => number;
+/** Newest first. */
+export declare const browserDownloads: () => Download[];
+/** Take one finished download off the list (the file stays). */
+export declare function forgetDownload(key: string): void;
+/** Take every finished download off the list. */
+export declare function clearDownloads(): void;
+export declare const browserBookmarks: () => Bookmarks;
+export declare function setBookmarks(next: Bookmarks): void;
+/** A Chromium browser's bookmarks on this machine, one per profile that has any. */
+export interface BookmarkSource {
+    browser: string;
+    profile: string;
+    path: string;
+}
+/** Every profile of Chrome, Edge and Brave with a Bookmarks file. A browser not installed is no error. */
+export declare function findBookmarkSources(): Promise<BookmarkSource[]>;
+/** Import one source's bookmarks as a "From Chrome" folder in each root. Returns how many pages. */
+export declare function importBookmarks(src: BookmarkSource): Promise<number>;
+/** Every bookmark to a bookmarks HTML file, which any browser imports, and Deck too. How many pages. */
+export declare function exportBookmarks(path: string): Promise<number>;
+/** A bookmarks HTML file (Deck's own export, or any browser's) merged in, into folders of the same
+ *  name and without pages already bookmarked. How many pages it added. */
+export declare function importBookmarksFile(path: string): Promise<number>;
+export declare function setPins(next: Pin[]): void;
+/** Forget one page, or every visit between `from` and `to` (all of them when neither is given). */
+export declare function forgetHistory(url: string): void;
+export declare function forgetHistory(range: {
+    from?: number;
+    to?: number;
+}): void;
+export declare const forgetRecent: (url: string) => void;
+export declare const serversSnapshot: () => number;
+export declare const devServers: () => string[];
+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;
+export declare function trackBrowser(pane: string, el: HTMLElement, url: string): () => void;

package/types/core/browserurl.d.ts

@@ -0,0 +1,64 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export type SearchEngine = "google" | "brave" | "duckduckgo" | "bing";
+export declare const SEARCH_ENGINES: Record<SearchEngine, {
+    label: string;
+    home: string;
+    query: string;
+}>;
+export declare const searchUrl: (engine: SearchEngine, q: string) => string;
+/**
+ * What was typed into the address bar or the start page's search box, as a URL to open.
+ *
+ * A scheme is kept; a local host gets plain http (dev servers rarely have TLS); a Windows or Unix
+ * path to a file becomes file:///; text with a space, or a single word with no dot, is a search;
+ * anything else is a host and gets https.
+ */
+export declare function toUrl(typed: string, engine: SearchEngine): string;
+/**
+ * Local URLs in a chunk of terminal output: what a dev server prints when it starts ("Local:
+ * http://localhost:5173/"). 0.0.0.0 is where a server listens, not somewhere to go, so it becomes
+ * localhost. A trailing dot or comma is the sentence's, not the URL's.
+ */
+export declare function devUrls(chunk: string): string[];
+/** The web addresses in a line of terminal output, where each starts and its text: what Ctrl+click
+ *  opens. A trailing dot, comma or closing bracket is the sentence's, not the address's. */
+export declare function findUrls(line: string): {
+    start: number;
+    text: string;
+}[];
+export interface RecentPage {
+    url: string;
+    title: string;
+}
+/** Whether `url` is a search engine's results page: on the way somewhere, not a place to go back to. */
+export declare const isSearchPage: (url: string) => boolean;
+/** One page in the history: how often it was opened, and when last (browser_history.rs keeps them). */
+export interface Visit {
+    url: string;
+    title: string;
+    count: number;
+    last: number;
+}
+export interface Suggestion {
+    url: string;
+    title: string;
+    kind: "pin" | "bookmark" | "history";
+}
+/**
+ * What the address bar offers for `typed`: pinned sites, bookmarks and history whose address or
+ * title holds every word typed. An address that starts with what was typed comes first, then by
+ * how often and how lately it was visited, a pin or a bookmark counting as often.
+ */
+export declare function suggest(typed: string, sources: {
+    pins?: readonly {
+        url: string;
+        title: string;
+    }[];
+    bookmarks?: readonly {
+        url: string;
+        title: string;
+    }[];
+    history?: readonly Visit[];
+}, now: number, limit?: number): Suggestion[];
+/** A day's heading in the history: Today, Yesterday, or the date. */
+export declare function dayLabel(t: number, now: number): string;

package/types/core/editorsession.d.ts

@@ -0,0 +1,55 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface SessionTab {
+    /** Older sessions can also hold "graph" and "pr" tabs, from before git moved to the Git
+     *  plugin. The Editor skips them on restore. */
+    /** "untitled" is a buffer never saved (Ctrl+N), path `untitled:Untitled-N`: restored from
+     *  `content` alone, with no disk read. An older Deck skips the kind, as it skips "graph". */
+    kind: "file" | "media" | "graph" | "pr" | "untitled";
+    path: string;
+    rel: string | null;
+    dirty?: string;
+    /** untitled: its whole text, and the language picked by hand for it (none: detected). */
+    content?: string;
+    lang?: string;
+}
+export interface WorkspaceSession {
+    tabs: SessionTab[];
+    activeId: string | null;
+    expanded: string[];
+    /** A typed-but-uncommitted message. Per root, because a message belongs to the repo it
+     *  describes. Only the active module is mounted, so without this a half-written message is
+     *  destroyed by switching to a terminal to check something — which is exactly when you switch. */
+    commitMsg?: string;
+    /** Collapsed Source Control rows: the two section headers, and folders in tree view. Per root
+     *  because the keys are paths in this repo. A Set on the way in and out; an array here because
+     *  that is what survives JSON. */
+    scmCollapsed?: string[];
+}
+/** A file to open, and optionally where in it to land. */
+export interface PendingFile {
+    path: string;
+    line?: number;
+}
+export declare function queueOpenFiles(files: (string | PendingFile)[], instance?: EditorInstance): void;
+/** Take everything queued for one editor, leaving its queue empty. */
+export declare function drainOpenFiles(instance?: EditorInstance): PendingFile[];
+/**
+ * Which editor is asking.
+ *
+ * There are two: the Editor tab, which opens whatever folder you point it at, and the one inside
+ * Terminals, which follows that workspace's cwd. They are separate windows onto different work,
+ * so their open folder and their UI prefs are stored per instance. Open TABS already separate on
+ * their own — loadSession is keyed by root, and the two rarely share one.
+ */
+export type EditorInstance = "tab" | "terminals";
+export declare function loadEditorRoot(instance: EditorInstance, pane?: string): string;
+export declare function saveEditorRoot(instance: EditorInstance, root: string, pane?: string): void;
+export interface GlobalUi {
+    mdMode: "edit" | "live" | "split" | "preview";
+    panel: "explorer" | "search" | "debug" | "scm";
+    sidebarW: number;
+}
+export declare function loadSession(root: string): WorkspaceSession | null;
+export declare function saveSession(root: string, s: WorkspaceSession): void;
+export declare function loadUi(instance: EditorInstance): Partial<GlobalUi>;
+export declare function saveUi(instance: EditorInstance, ui: GlobalUi): void;

package/types/core/editorsettings.d.ts

@@ -80,6 +80,15 @@ export interface EditorSettings {
     agentNotifyFinished: boolean;
     agentNotifyNeedsInput: boolean;
     agentNotifyOsToast: boolean;
+    /** Layout: the file panel docked beside the code or a drawer over it (Ctrl+B either way), the
+     *  status as a bar along the bottom or a pill floating over the code, and the file's path on its
+     *  own row under the tabs or in the tab line. */
+    layoutFiles: "docked" | "drawer";
+    layoutStatus: "bar" | "pill";
+    layoutPath: "row" | "tabs";
+    /** With the files in a drawer: Search, Source Control and Debug as icons in the tab line, or
+     *  along the top of the drawer. */
+    layoutViews: "tabs" | "drawer";
     theme: "deck-dark" | "vs-dark" | "hc-black";
     iconTheme: string;
     diffSideBySide: boolean;

package/types/core/fileview.d.ts

@@ -0,0 +1,35 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** The view showing `path` in plugin `pluginId`'s pane view. */
+export declare const fileView: (pluginId: string, path: string) => string;
+/** A view id's own part, and the file it was opened on if any. */
+export declare function splitView(view: string): {
+    base: string;
+    file?: string;
+};
+/**
+ * What two views are compared by, so one file is one tab however its path was spelled: the file
+ * tree, a terminal link and Quick Open can each give the same file with other slashes or case
+ * (Windows paths are case-insensitive). The stored view keeps the path as given, for the title.
+ */
+export declare function viewKey(view: string): string;
+/** A path's extension, lowercased with its dot (".pdf"), or "" when it has none. */
+export declare const extOf: (path: string) => string;
+/** The last part of a path, for a tab's title. */
+export declare const fileName: (path: string) => string;
+/** Extensions as a plugin wrote them (".pdf", "PDF", "pdf"), as extOf returns them. */
+export declare const normaliseExts: (exts: unknown) => string[];
+/**
+ * Which loaded plugin opens which file types, from each plugin's `opens` export. Filled by the
+ * plugin loader (plugins.ts) on every load; here so that anything can ask without importing it.
+ */
+export declare const fileOpeners: {
+    id: string;
+    exts: string[];
+}[];
+/** The id of the plugin that opens `path` (by its extension), or undefined: the Editor's. */
+export declare function pluginForFile(path: string): string | undefined;
+/**
+ * Open `path` in the plugin that claims its type, as a tab of its own. False when no plugin does,
+ * so the caller opens it in the Editor as before. Every way Deck opens a file asks this first.
+ */
+export declare function openWithPlugin(path: string): boolean;

package/types/core/notifications.d.ts

@@ -0,0 +1,84 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/**
+ * attention: needs you now (a meeting starting, someone asking to join a board, a timer about to
+ * fire). activity: something finished in the background (a download, a timer that ran).
+ */
+export type NotifKind = "input" | "done" | "attention" | "activity" | "update" | "error" | "news" | "plugin";
+/**
+ * A button on a card and on its bell row. `nav` (a deck-navigate target) and `act` (a handler
+ * registered with onNotifAction) survive a restart; `run`, a plugin's own function, does not, so
+ * after a restart that button is gone from the bell.
+ */
+export interface NotifAction {
+    label: string;
+    primary?: boolean;
+    nav?: string;
+    act?: string;
+    run?: () => void;
+}
+export interface Notif {
+    id: string;
+    kind: NotifKind;
+    title: string;
+    body: string;
+    ts: number;
+    /** Replaces an earlier notification with the same key. */
+    key?: string;
+    /** The workspace an agent notification is about: a click goes there. */
+    wsId?: string;
+    /** Where a click on the card itself goes, when it is not about a workspace. */
+    nav?: string;
+    /** Who posted it, shown beside the time: a plugin's name. */
+    source?: string;
+    actions?: NotifAction[];
+    /** Seen: the bell has been opened since it came. Read: the bell was closed after that. */
+    seen?: boolean;
+    read?: boolean;
+}
+export type Card = Notif & {
+    sticky: boolean;
+};
+/** The kinds Settings lists. What's new counts as an update. */
+export type PrefKind = "input" | "done" | "attention" | "activity" | "update" | "error" | "plugin";
+export type Channel = "card" | "bell" | "sound" | "os";
+export declare const PREF_KINDS: {
+    kind: PrefKind;
+    label: string;
+    desc: string;
+}[];
+/**
+ * Whether a kind shows on a channel. Until it is set in Settings › Notifications, the agent kinds
+ * follow the four switches that Settings › AI agents used to have (on at all, finished, needs input,
+ * Windows), so nobody's choice flips.
+ */
+export declare function prefFor(kind: PrefKind, ch: Channel): boolean;
+export declare const useNotifCards: () => Card[];
+export declare function useNotifHistory(): Notif[];
+/** Whether Deck is the window in front, for a caller that only speaks up when you are away. */
+export declare const deckInFront: () => boolean;
+/**
+ * Post a notification. Returns its id, or "" when the user has every channel for its kind off.
+ * `transient`: a card only, never kept in the bell, for something in progress that a result will
+ * replace or resolveKey will take down (a hot reload while it runs).
+ */
+export declare function notify(n: Omit<Notif, "id" | "ts" | "seen" | "read"> & {
+    sticky?: boolean;
+    transient?: boolean;
+}): string;
+/** The card's ✕: it goes, and its key stays quiet (see notify) until resolved or acted on. */
+export declare function closeCard(id: string): void;
+/** The card goes; the bell keeps it. */
+export declare function dismissCard(id: string): void;
+/** Gone from the bell, and its card with it. */
+export declare function removeNotif(id: string): void;
+/** What a key was about is dealt with (an agent was answered): its card goes, its row is read. */
+export declare function resolveKey(key: string): void;
+export declare function clearNotifs(): void;
+/** The bell was opened: the badge clears, the rows stay lifted until it closes. */
+export declare function markSeen(): void;
+export declare function markRead(): void;
+/** What a persisted action's `act` runs. Registered by the module that posts it, at import. */
+export declare function onNotifAction(name: string, run: () => unknown): void;
+/** A click on the card or the row itself: where it is about, then the card goes. */
+export declare function openNotif(n: Notif): void;
+export declare function runAction(n: Notif, a: NotifAction): void;

package/types/core/notifyapi.d.ts

@@ -0,0 +1,39 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface PluginNotification {
+    title: string;
+    /**
+     * Which of Settings › Notifications' rows it follows. "plugin" (the default) for a plugin's own
+     * news; "attention" for something that needs the user now (a meeting starting, a request to
+     * join), which also reaches Windows while Deck is behind; "activity" for something that finished
+     * in the background; "error" for a failure.
+     */
+    kind?: "plugin" | "attention" | "activity" | "error";
+    body?: string;
+    /** The plugin's name, shown beside the time. */
+    source: string;
+    /** Replaces this plugin's earlier notification with the same key, rather than adding another. */
+    key?: string;
+    /** Stays until dismissed instead of going after a few seconds. The bell keeps it either way. */
+    sticky?: boolean;
+    /**
+     * Something in progress: a card only, with no sound, never kept in the bell. Take it down with
+     * dismissNotification when it is done, or replace it (same key) with the result.
+     */
+    transient?: boolean;
+    /**
+     * Buttons on the card and on its bell row. `run` is the plugin's own function, so it lasts only
+     * as long as this session: after a restart the row is still in the bell, without its buttons.
+     */
+    actions?: {
+        label: string;
+        primary?: boolean;
+        run: () => void;
+    }[];
+}
+/**
+ * Post a notification: a card in the corner and a row in the bell, as Settings › Notifications
+ * says for plugins. For a passing word ("Copied") use toast() instead, which the bell does not keep.
+ */
+export declare function notify(n: PluginNotification): void;
+/** Take down this plugin's notification with that key: its card goes, its bell row is marked read. */
+export declare function dismissNotification(source: string, key: string): void;

package/types/core/terminals.d.ts

@@ -50,6 +50,8 @@ export interface LayoutWorkspace {
     cwd: string;
     tabs: LayoutTab[];
     activeTab: string;
+    /** Its colour on the sidebar's collapsed rail, by index (Terminals' TONES); none picks one from the name. */
+    color?: number;
 }
 export interface Layout {
     workspaces: LayoutWorkspace[];
@@ -300,6 +302,11 @@ export declare function moveWorkspace(id: string, toIndex: number): void;
  * 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;
 export declare function getInstance(id: string): Instance;
 /**
  * Wrap pasted text in bracketed-paste markers, so the receiving app can tell one paste from

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

@@ -0,0 +1,19 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type RefObject } from "react";
+import { monaco } from "../../core/monaco";
+import { type DirtyRange } from "./hunks";
+/**
+ * The peek, for the editor in `edRef` showing `path` with the gutter's `ranges`. Returns what to
+ * render (a portal into the overlay), or null while closed.
+ *
+ * `clean` is whether the editor holds what is on disk: the changes are git's, read from disk, so
+ * their line numbers only fit the buffer when it has no unsaved edits. Staging and reverting wait
+ * for a save otherwise. `readBase` gives the text a change is against: the index's copy of the
+ * file for a change in the working tree, HEAD's for a staged one.
+ */
+export declare function useDiffPeek(edRef: RefObject<monaco.editor.IStandaloneCodeEditor | null>, path: string, ranges: DirtyRange[] | undefined, opts: {
+    clean: boolean;
+    onStage: (r: DirtyRange) => Promise<void>;
+    onUnstage: (r: DirtyRange) => Promise<void>;
+    readBase: (staged: boolean) => Promise<string>;
+}): import("react").ReactPortal | null;

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

@@ -1,8 +1,8 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { monaco } from "../../core/monaco";
 import { type EditorSettings } from "../../core/editorsettings";
-import type { DirtyRange } from "./tree";
-declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLine, gotoCol, gotoNonce, highlight, dirty, settings, onEditor }: {
+import type { DirtyRange } from "./hunks";
+declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLine, gotoCol, gotoNonce, highlight, dirty, settings, onEditor, clean, onStageChange, onUnstageChange, onReadBase }: {
     path: string;
     rel?: string | null;
     value: string;
@@ -22,6 +22,13 @@ declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLin
     /** Hands the live editor out, and null on unmount. For a formatting toolbar, which has to
      *  dispatch into this instance rather than rewrite the string around it. */
     onEditor?: (e: monaco.editor.IStandaloneCodeEditor | null) => void;
+    /** The buffer matches the file on disk, which the gutter's changes were read from. */
+    clean?: boolean;
+    /** Stage or unstage one change from the gutter's peek (DiffPeek.tsx). */
+    onStageChange?: (r: DirtyRange) => Promise<void>;
+    onUnstageChange?: (r: DirtyRange) => Promise<void>;
+    /** The text the file's changes are against: the index's copy, or HEAD's for a staged change. */
+    onReadBase?: (staged: boolean) => Promise<string>;
 }): import("react").JSX.Element;
 /**
  * Monaco owns its buffer, so this component re-rendering achieves nothing on its own — yet it was
@@ -35,13 +42,19 @@ declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLin
  */
 export declare const MonacoEditor: import("react").MemoExoticComponent<typeof MonacoEditorInner>;
 export declare function applyLineChanges(original: monaco.editor.ITextModel, modified: monaco.editor.ITextModel, diffs: monaco.editor.ILineChange[]): string;
+type HunkRun = (change: monaco.editor.ILineChange, models: {
+    original: monaco.editor.ITextModel;
+    modified: monaco.editor.ITextModel;
+}) => void;
+/**
+ * Per-change buttons in a diff's gutter: stage (or unstage) one change, and, given `revert`, put
+ * one change back to the left side's text. Each change gets them at its first line.
+ */
 export interface HunkAction {
     label: string;
     unstage: boolean;
-    run: (change: monaco.editor.ILineChange, models: {
-        original: monaco.editor.ITextModel;
-        modified: monaco.editor.ITextModel;
-    }) => void;
+    run: HunkRun;
+    revert?: HunkRun;
 }
 /** A side of a diff: LEFT the old version, RIGHT the new — GitHub's names, which line comments use. */
 export type DiffSide = "LEFT" | "RIGHT";

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

@@ -0,0 +1,3 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** A Monaco language id (only ones Monaco ships), "plaintext" when nothing stands out. */
+export declare function detectLanguage(text: string): string;

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

@@ -10,6 +10,8 @@ export interface EditorStatus {
         author: string;
         summary: string;
     } | null;
+    /** The shown model's Monaco language id: an untitled buffer's changes as it is detected. */
+    lang?: string;
 }
 export declare let editorStatus: EditorStatus;
 export declare function setEditorStatus(patch: Partial<EditorStatus>): void;

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

@@ -0,0 +1,54 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** One change: lines `oldStart..` of the base replaced by lines `newStart..` of the file. */
+export interface Hunk {
+    oldStart: number;
+    oldCount: number;
+    /** For a deletion (newCount 0), the line the removed lines were after; 0 at the very top. */
+    newStart: number;
+    newCount: number;
+    /** The base's lines and the file's, without git's prefix or a trailing \r. */
+    removed: string[];
+    added: string[];
+    /** The hunk exactly as git printed it, from its @@ line on, for a patch. */
+    raw: string[];
+}
+/** One file's diff: the lines before the first hunk (its header), and the hunks. */
+export interface FileDiff {
+    header: string[];
+    hunks: Hunk[];
+}
+/** A changed line range in the file, for the gutter. */
+export interface DirtyRange {
+    start: number;
+    end: number;
+    type: "added" | "modified" | "deleted";
+    /** Staged: in the index already, so shown dimmed. */
+    staged?: boolean;
+    hunk: Hunk;
+}
+/** Parse `git diff --unified=0` for one file. Empty text is an empty diff. */
+export declare function parseDiff(diff: string): FileDiff;
+/** Where a hunk sits in the file. A deletion is drawn on the line it follows (the first, at the top). */
+export declare function rangeOf(h: Hunk): Omit<DirtyRange, "hunk">;
+/**
+ * The gutter's ranges: every unstaged change, and every staged one that has not been changed again
+ * since it was staged.
+ *
+ * `unstaged` is the file against the index; `sinceHead`, when given, the file against HEAD. Both
+ * are in the file's own line numbers, which a diff of the index against HEAD (`--cached`) would
+ * not be once there are unstaged edits too. A change against HEAD that touches no unstaged line is
+ * entirely in the index: that is a staged one.
+ */
+export declare function dirtyRanges(unstaged: FileDiff, sinceHead?: FileDiff): DirtyRange[];
+/** A patch holding just this hunk, for `git apply --cached --unidiff-zero`. */
+export declare function hunkPatch(file: FileDiff, h: Hunk): string;
+/** The hunk in `file` with the same removed and added lines as `h`: a staged change, found in `--cached`. */
+export declare function sameHunk(file: FileDiff, h: Hunk): Hunk | undefined;
+/**
+ * The edit that puts a hunk's base lines back in the file, as a range in 1-based lines and
+ * columns and its replacement text. `lineCount` and `maxColumn` describe the file as it is.
+ */
+export declare function revertEdit(h: Hunk, lineCount: number, maxColumn: (line: number) => number, eol?: string): {
+    range: [number, number, number, number];
+    text: string;
+};