deck-plugin-sdk 1.5.0 → 1.6.0

package/package.json

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

package/shim/bridge.js

@@ -10,12 +10,47 @@ const b = () => {
   return x;
 };
 
+export const adblockConfig = (...a) => b().adblockConfig(...a);
+export const adblockInfo = (...a) => b().adblockInfo(...a);
+export const adblockRebuild = (...a) => b().adblockRebuild(...a);
+export const adblockUpdate = (...a) => b().adblockUpdate(...a);
 export const agentClis = (...a) => b().agentClis(...a);
 export const agentMcpStatus = (...a) => b().agentMcpStatus(...a);
 export const askSudoPassword = (...a) => b().askSudoPassword(...a);
 export const backupExport = (...a) => b().backupExport(...a);
 export const backupInspect = (...a) => b().backupInspect(...a);
 export const backupRestore = (...a) => b().backupRestore(...a);
+export const bookmarksBarMode = (...a) => b().bookmarksBarMode(...a);
+export const browserAgentAnswer = (...a) => b().browserAgentAnswer(...a);
+export const browserAgentConfig = (...a) => b().browserAgentConfig(...a);
+export const browserAgentFillAnswer = (...a) => b().browserAgentFillAnswer(...a);
+export const browserBounds = (...a) => b().browserBounds(...a);
+export const browserCapture = (...a) => b().browserCapture(...a);
+export const browserCdp = (...a) => b().browserCdp(...a);
+export const browserClear = (...a) => b().browserClear(...a);
+export const browserClose = (...a) => b().browserClose(...a);
+export const browserDefaultRegister = (...a) => b().browserDefaultRegister(...a);
+export const browserDefaultStatus = (...a) => b().browserDefaultStatus(...a);
+export const browserDevtools = (...a) => b().browserDevtools(...a);
+export const browserDownload = (...a) => b().browserDownload(...a);
+export const browserFind = (...a) => b().browserFind(...a);
+export const browserHistoryCount = (...a) => b().browserHistoryCount(...a);
+export const browserHistoryForgetRange = (...a) => b().browserHistoryForgetRange(...a);
+export const browserHistoryForgetUrl = (...a) => b().browserHistoryForgetUrl(...a);
+export const browserHistoryList = (...a) => b().browserHistoryList(...a);
+export const browserHistoryRecent = (...a) => b().browserHistoryRecent(...a);
+export const browserHistorySuggest = (...a) => b().browserHistorySuggest(...a);
+export const browserHistoryVisit = (...a) => b().browserHistoryVisit(...a);
+export const browserMute = (...a) => b().browserMute(...a);
+export const browserNav = (...a) => b().browserNav(...a);
+export const browserOpen = (...a) => b().browserOpen(...a);
+export const browserPermissionSet = (...a) => b().browserPermissionSet(...a);
+export const browserPermissions = (...a) => b().browserPermissions(...a);
+export const browserPrivacy = (...a) => b().browserPrivacy(...a);
+export const browserSetKeys = (...a) => b().browserSetKeys(...a);
+export const browserSite = (...a) => b().browserSite(...a);
+export const browserSiteClear = (...a) => b().browserSiteClear(...a);
+export const browserZoom = (...a) => b().browserZoom(...a);
 export const claudePlanLimits = (...a) => b().claudePlanLimits(...a);
 export const claudeUsage = (...a) => b().claudeUsage(...a);
 export const clearWallpaper = (...a) => b().clearWallpaper(...a);
@@ -28,9 +63,18 @@ export const dbConnect = (...a) => b().dbConnect(...a);
 export const dbDisconnect = (...a) => b().dbDisconnect(...a);
 export const dbQuery = (...a) => b().dbQuery(...a);
 export const dbSchema = (...a) => b().dbSchema(...a);
+export const deckReady = (...a) => b().deckReady(...a);
 export const deleteIconPack = (...a) => b().deleteIconPack(...a);
 export const dirsDownload = (...a) => b().dirsDownload(...a);
 export const exec = (...a) => b().exec(...a);
+export const extensionInstallFolder = (...a) => b().extensionInstallFolder(...a);
+export const extensionInstallStore = (...a) => b().extensionInstallStore(...a);
+export const extensionPopup = (...a) => b().extensionPopup(...a);
+export const extensionPopupClose = (...a) => b().extensionPopupClose(...a);
+export const extensionReload = (...a) => b().extensionReload(...a);
+export const extensionRemove = (...a) => b().extensionRemove(...a);
+export const extensionSetEnabled = (...a) => b().extensionSetEnabled(...a);
+export const extensionsList = (...a) => b().extensionsList(...a);
 export const footerOrder = (...a) => b().footerOrder(...a);
 export const fsCopy = (...a) => b().fsCopy(...a);
 export const fsCreateDir = (...a) => b().fsCreateDir(...a);
@@ -97,6 +141,7 @@ export const installFromRegistry = (...a) => b().installFromRegistry(...a);
 export const isFullscreen = (...a) => b().isFullscreen(...a);
 export const languagesDir = (...a) => b().languagesDir(...a);
 export const launchFiles = (...a) => b().launchFiles(...a);
+export const launchUrls = (...a) => b().launchUrls(...a);
 export const listApps = (...a) => b().listApps(...a);
 export const listInstalled = (...a) => b().listInstalled(...a);
 export const logLatest = (...a) => b().logLatest(...a);
@@ -138,6 +183,26 @@ export const sshTunnelClose = (...a) => b().sshTunnelClose(...a);
 export const sshTunnelOpen = (...a) => b().sshTunnelOpen(...a);
 export const startupMarks = (...a) => b().startupMarks(...a);
 export const toggleFullscreen = (...a) => b().toggleFullscreen(...a);
+export const vaultChangePassword = (...a) => b().vaultChangePassword(...a);
+export const vaultConfig = (...a) => b().vaultConfig(...a);
+export const vaultCreate = (...a) => b().vaultCreate(...a);
+export const vaultDelete = (...a) => b().vaultDelete(...a);
+export const vaultExport = (...a) => b().vaultExport(...a);
+export const vaultFill = (...a) => b().vaultFill(...a);
+export const vaultFillNew = (...a) => b().vaultFillNew(...a);
+export const vaultGenerate = (...a) => b().vaultGenerate(...a);
+export const vaultImport = (...a) => b().vaultImport(...a);
+export const vaultList = (...a) => b().vaultList(...a);
+export const vaultLock = (...a) => b().vaultLock(...a);
+export const vaultMatches = (...a) => b().vaultMatches(...a);
+export const vaultNeverList = (...a) => b().vaultNeverList(...a);
+export const vaultNeverRemove = (...a) => b().vaultNeverRemove(...a);
+export const vaultOfferAnswer = (...a) => b().vaultOfferAnswer(...a);
+export const vaultSave = (...a) => b().vaultSave(...a);
+export const vaultSecret = (...a) => b().vaultSecret(...a);
+export const vaultStatus = (...a) => b().vaultStatus(...a);
+export const vaultTotp = (...a) => b().vaultTotp(...a);
+export const vaultUnlock = (...a) => b().vaultUnlock(...a);
 export const vpsRunsPull = (...a) => b().vpsRunsPull(...a);
 export const watchFiles = (...a) => b().watchFiles(...a);
 

package/shim/ui.d.ts

@@ -6,6 +6,7 @@ export * from "../types/components/ConfirmDialog";
 export * from "../types/components/NamePrompt";
 export * from "../types/components/ContextMenu";
 export * from "../types/components/Toast";
+export * from "../types/core/notifyapi";
 export * from "../types/components/useResize";
 export * from "../types/modules/editor/MarkdownLive";
 export * from "../types/components/TreeRow";

package/shim/ui.js

@@ -10,13 +10,17 @@ const u = () => {
 };
 
 export const ActivityBar = (...a) => u().ActivityBar(...a);
+export const Chip = (...a) => u().Chip(...a);
 export const ConfirmDialog = (...a) => u().ConfirmDialog(...a);
 export const ContextMenu = (...a) => u().ContextMenu(...a);
+export const CountChip = (...a) => u().CountChip(...a);
 export const DayPicker = (...a) => u().DayPicker(...a);
+export const EmptyState = (...a) => u().EmptyState(...a);
 export const Field = (...a) => u().Field(...a);
 export const FileIcon = (...a) => u().FileIcon(...a);
 export const FontViewer = (...a) => u().FontViewer(...a);
 export const GhostButton = (...a) => u().GhostButton(...a);
+export const IconButton = (...a) => u().IconButton(...a);
 export const ImageViewer = (...a) => u().ImageViewer(...a);
 export const MarkdownLive = (...a) => u().MarkdownLive(...a);
 export const MarkdownToolbar = (...a) => u().MarkdownToolbar(...a);
@@ -50,6 +54,7 @@ export const cmSurface = (...a) => u().cmSurface(...a);
 export const collectFiles = (...a) => u().collectFiles(...a);
 export const conflict = (...a) => u().conflict(...a);
 export const decodeText = (...a) => u().decodeText(...a);
+export const dismissNotification = (...a) => u().dismissNotification(...a);
 export const dispatch = (...a) => u().dispatch(...a);
 export const forLanguage = (...a) => u().forLanguage(...a);
 export const formatChord = (...a) => u().formatChord(...a);
@@ -60,6 +65,7 @@ export const mediaKind = (...a) => u().mediaKind(...a);
 export const modelOptionsFor = (...a) => u().modelOptionsFor(...a);
 export const monacoOptionsFrom = (...a) => u().monacoOptionsFrom(...a);
 export const normalizeChord = (...a) => u().normalizeChord(...a);
+export const notify = (...a) => u().notify(...a);
 export const onKey = (...a) => u().onKey(...a);
 export const onKeys = (...a) => u().onKeys(...a);
 export const parseChord = (...a) => u().parseChord(...a);
@@ -75,6 +81,7 @@ export const subscribeEditorSettings = (...a) => u().subscribeEditorSettings(...
 export const themeById = (...a) => u().themeById(...a);
 export const toMonaco = (...a) => u().toMonaco(...a);
 export const toast = (...a) => u().toast(...a);
+export const tone = (...a) => u().tone(...a);
 export const updateEditorSettings = (...a) => u().updateEditorSettings(...a);
 export const useEditorSettings = (...a) => u().useEditorSettings(...a);
 export const useIconThemesVersion = (...a) => u().useIconThemesVersion(...a);

package/template/plugin.json

@@ -5,5 +5,5 @@
   "icon": "Sparkles",
   "color": "#a78bfa",
   "version": "0.1.0",
-  "minDeck": "1.5.0"
+  "minDeck": "1.6.0"
 }

package/types/components/ActivityBar.d.ts

@@ -11,10 +11,12 @@ export interface ActivityView<Id extends string> {
     onClick?: (el: HTMLElement) => void;
 }
 export default ActivityBar;
-export declare function ActivityBar<Id extends string>({ views, active, onSelect, trailing, }: {
+export declare function ActivityBar<Id extends string>({ views, active, onSelect, trailing, grouped, }: {
     views: readonly ActivityView<Id>[];
     active: Id;
     onSelect: (id: Id) => void;
     /** Fixed controls pinned to the right — present for every view, or the icons shift. */
     trailing?: React.ReactNode;
+    /** The icons together in one rounded group, smaller, rather than loose pills. */
+    grouped?: boolean;
 }): import("react").JSX.Element;

package/types/components/ContextMenu.d.ts

@@ -26,6 +26,9 @@ export interface MenuItem {
     /** A setting rather than an action: renders a checkbox and does NOT close the menu, so several
      *  can be flipped in one visit. The caller re-renders with the new value. */
     checked?: boolean;
+    /** Controls of its own at the row's right (a zoom's − and +, a slider): the row is not
+     *  clicked itself, and using them leaves the menu open. */
+    controls?: React.ReactNode;
 }
 export type MenuEntry = MenuItem | "sep";
 export declare function ContextMenu({ x, y, items, alignRight, onClose, onReorder, flipAt, up }: {

package/types/components/TabStrip.d.ts

@@ -12,7 +12,7 @@ export interface TabItem {
     /** Tooltip for the close button; defaults to "Close". */
     closeTitle?: string;
 }
-export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder, onDoubleClick, trailing, pill, onAdd, addTitle, }: {
+export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder, onDoubleClick, leading, trailing, pill: pillProp, chip, onAdd, addTitle, }: {
     tabs: readonly TabItem[];
     activeId: string | null;
     onSelect: (id: string) => void;
@@ -20,11 +20,16 @@ export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder,
     /** Moves `from` to `to`'s position. Omit to make the strip non-reorderable. */
     onReorder?: (from: string, to: string) => void;
     onDoubleClick?: (id: string) => void;
+    /** Controls before the first tab. */
+    leading?: ReactNode;
     /** Right-aligned controls after the tabs — view toggles, save state. */
     trailing?: ReactNode;
     /** Rounded tabs with the active one lit in the accent, the look of the workspace tabs in the
      *  title bar, instead of the editor-style boxed row. */
     pill?: boolean;
+    /** Rounded like `pill`, with the open tab raised on the card colour rather than lit in the
+     *  accent: the editor's tabs, where the accent already marks the open file in the tree. */
+    chip?: boolean;
     /** A + right after the last tab, as the workspace tabs have. */
     onAdd?: () => void;
     addTitle?: string;

package/types/components/ui.d.ts

@@ -58,10 +58,14 @@ export declare function DayPicker({ value, onChange, }: {
     onChange: (days: string[]) => void;
 }): import("react").JSX.Element;
 /** One readout in the footer strip: an icon, a short label, and an optional click. */
-export declare function StatusItem({ icon, color, label, title, onClick, }: {
+export declare function StatusItem({ icon, color, label, detail, meter, title, onClick, }: {
     icon: React.ReactNode;
     color: string;
     label: string;
+    /** A second, quieter part after the label: a branch, a commit. */
+    detail?: string;
+    /** 0 to 100: a small bar before the label, in the item's colour (a limit's use). */
+    meter?: number;
     title?: string;
     onClick?: () => void;
 }): import("react").JSX.Element;
@@ -100,3 +104,46 @@ export declare function Toggle({ on, onChange }: {
     on: boolean;
     onChange: (v: boolean) => void;
 }): import("react").JSX.Element;
+/** A state in its colour: Ready, Running, Paused, Failed. `color` is any CSS colour; a `--tone-*`
+ *  one (`tone("green")`) follows a light theme. */
+export declare function Chip({ color, title, children }: {
+    color: string;
+    title?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A `--tone-*` colour as CSS, for a Chip, a dot or text: `tone("amber")`. */
+export declare function tone(name: "red" | "emerald" | "amber" | "blue" | "green" | "cyan" | "sky" | "violet" | "pink" | "orange", shade?: 300 | 400): string;
+/** How many, after a heading or a row. */
+export declare function CountChip({ n, title }: {
+    n: number;
+    title?: string;
+}): import("react").JSX.Element;
+/**
+ * What a space is for and the way in, when it has nothing to show: a sentence and, usually, a
+ * button. `card` puts it in a quiet card, for when it is the only thing on screen.
+ */
+export declare function EmptyState({ icon, title, children, action, card }: {
+    icon?: ReactNode;
+    /** A short line above the sentence, when the space needs naming. */
+    title?: string;
+    children: ReactNode;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    card?: boolean;
+}): import("react").JSX.Element;
+/**
+ * An icon-only button. `toolbar` (size-7) for a panel's own actions, `row` (size-5) for one inside
+ * a list row, shown on the row's hover by the caller. `danger` turns it red on hover only; `active`
+ * marks a toggle that is on. `title` is required: it is the only label the button has.
+ */
+export declare function IconButton({ title, onClick, children, size, danger, active, disabled }: {
+    title: string;
+    onClick: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    children: ReactNode;
+    size?: "toolbar" | "row";
+    danger?: boolean;
+    active?: boolean;
+    disabled?: boolean;
+}): import("react").JSX.Element;

package/types/components/useResize.d.ts

@@ -19,7 +19,7 @@ export declare function useNarrow(px: number): [boolean, (el: HTMLElement | null
  * Listeners go on `window`, not the divider, so a fast drag that outruns the pointer keeps
  * resizing instead of stopping the moment the cursor leaves the 4px handle.
  */
-export declare function useResize({ initial, min, max, direction, invert, }: {
+export declare function useResize({ initial, min, max, direction, invert, collapseBelow, onCollapse, }: {
     initial: number;
     min: number;
     max: number;
@@ -31,6 +31,13 @@ export declare function useResize({ initial, min, max, direction, invert, }: {
      * would grow a pane that is actually being squeezed from above.
      */
     invert?: boolean;
+    /**
+     * Dragged this far down (below `min`), the drag ends and `onCollapse` runs: the pane snaps shut
+     * rather than stopping at its minimum. Its size goes back to what it was when the drag began, so
+     * opening it again gives the width it had.
+     */
+    collapseBelow?: number;
+    onCollapse?: () => void;
 }): readonly [number, {
     readonly onMouseDown: (e: React.MouseEvent) => void;
 }, boolean];

package/types/core/bookmarks.d.ts

@@ -0,0 +1,79 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface BookmarkNode {
+    id: string;
+    title: string;
+    /** A page has a URL; a folder has children instead. */
+    url?: string;
+    children?: BookmarkNode[];
+}
+export interface Bookmarks {
+    bar: BookmarkNode[];
+    other: BookmarkNode[];
+}
+export declare const EMPTY: Bookmarks;
+export declare const isFolder: (n: BookmarkNode) => boolean;
+/** An id unique within this run and across runs: time, then a counter. */
+export declare const newId: () => string;
+/** Every page in the tree, depth first, with the folder titles above it. */
+export declare function pages(b: Bookmarks): {
+    node: BookmarkNode;
+    path: string[];
+}[];
+/** The bookmark for `url`, if there is one (the first, when it was saved twice). */
+export declare const findByUrl: (b: Bookmarks, url: string) => BookmarkNode | undefined;
+/** Every folder, for a "save in" list: the two roots first, then each folder by its path. */
+export declare function folders(b: Bookmarks): {
+    id: string;
+    path: string;
+}[];
+/** Add `node` at the end of `folder`. */
+export declare const add: (b: Bookmarks, folder: string, node: BookmarkNode) => Bookmarks;
+/** Remove the node with `id`, wherever it is (a folder goes with what is in it). */
+export declare function remove(b: Bookmarks, id: string): Bookmarks;
+/** Change a node's title or URL. */
+export declare function update(b: Bookmarks, id: string, patch: Partial<Pick<BookmarkNode, "title" | "url">>): Bookmarks;
+/** The node with `id`, and the id of the folder it is in. */
+export declare function locate(b: Bookmarks, id: string): {
+    node: BookmarkNode;
+    folder: string;
+} | null;
+/** Move a node to the end of another folder. A folder cannot go inside itself. */
+export declare function move(b: Bookmarks, id: string, folder: string): Bookmarks;
+/**
+ * A Chromium browser's Bookmarks file (Chrome, Edge, Brave all keep the same JSON) as Deck's
+ * nodes: its bar, its other bookmarks, and on Chrome its mobile ones, each as given. Anything that
+ * is not a page or a folder (a separator, an app link) is left out.
+ */
+export declare function fromChrome(json: string): {
+    bar: BookmarkNode[];
+    other: BookmarkNode[];
+};
+/** An import, as one folder in each root named after where it came from ("From Chrome"), left out
+ *  of a root it has nothing for. */
+export declare function addImport(b: Bookmarks, from: string, got: {
+    bar: BookmarkNode[];
+    other: BookmarkNode[];
+}): Bookmarks;
+/** How many pages a set of nodes holds. */
+export declare const countPages: (ns: readonly BookmarkNode[]) => number;
+/** Deck's bookmarks as a bookmarks HTML file. */
+export declare function toHtml(b: Bookmarks): string;
+/** A bookmarks HTML file as Deck's two roots. Read by its tags, not as a page: folders (H3) open
+ *  the list (DL) that follows them, pages are links (A HREF). */
+export declare function fromHtml(html: string): {
+    bar: BookmarkNode[];
+    other: BookmarkNode[];
+};
+/**
+ * An import merged in: a folder joins the folder of the same name where it lands (made if there
+ * is none), and a page already bookmarked anywhere is left out. So a file exported from Deck
+ * restores into the same places, and importing one twice adds nothing the second time.
+ * Returns the bookmarks and how many pages were added.
+ */
+export declare function mergeImport(b: Bookmarks, got: {
+    bar: BookmarkNode[];
+    other: BookmarkNode[];
+}): {
+    bookmarks: Bookmarks;
+    added: number;
+};

package/types/core/bridge.d.ts

@@ -1,8 +1,192 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { type DebugTarget } from "./debugtargets";
 import type { Accent, Background, Density, Palette, TermCustom, TermTheme } from "./theme";
+import type { SearchEngine } from "./browserurl";
 /** Open a URL in the default browser. */
 export declare const openExternal: (url: string) => Promise<void>;
+/** A box in physical pixels, relative to the window: where a browser pane's webview goes. */
+export interface PhysRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Open `url` in the browser pane's own webview (created the first time) at `r`. A private one
+ *  keeps no cookies, history or cache. */
+export declare const browserOpen: (pane: string, url: string, isPrivate: boolean, r: PhysRect) => Promise<void>;
+/** Move the pane's webview, or hide it. */
+export declare const browserBounds: (pane: string, r: PhysRect, visible: boolean) => Promise<void>;
+export declare const browserNav: (pane: string, action: "back" | "forward" | "reload" | "go" | "focus", url?: string) => Promise<void>;
+/** The chords Rust takes from a focused page: `deck` moves the keyboard back to Deck, `page` does not. */
+export declare const browserSetKeys: (deck: string[], page: string[]) => Promise<void>;
+export declare const browserClose: (pane: string) => Promise<void>;
+/** A JPEG of what the pane's webview shows. */
+/** The ad blocker on or off, and the sites it is off for. */
+export declare const adblockConfig: (enabled: boolean, off: string[], youtube: boolean) => Promise<void>;
+/** Whether the ad blocker is ready, how many rules it holds, and when its lists were downloaded. */
+export declare const adblockInfo: () => Promise<{
+    ready: boolean;
+    rules: number;
+    updated: number;
+}>;
+/** Rebuild the ad blocker from its lists and the user's own rules, after those changed. */
+export declare const adblockRebuild: () => Promise<void>;
+/** Download the ad blocker's lists again now. */
+export declare const adblockUpdate: () => Promise<void>;
+/** The browser's privacy settings, for every browser pane. */
+export declare const browserPrivacy: (tracking: string, autofill: boolean) => Promise<void>;
+/** Clear the browser's stored data of these kinds (cookies, cache, passwords, autofill) since `since`
+ *  (seconds since 1970; 0 for all of it). */
+export declare const browserClear: (kinds: string[], since: number) => Promise<void>;
+/** The user's answer to an agent asking to be signed in on a page: the login to fill, or none. */
+export declare const browserAgentFillAnswer: (id: number, login: string | null) => Promise<void>;
+/** A saved login, without its secrets. */
+export interface VaultMeta {
+    id: string;
+    site: string;
+    username: string;
+    note: string;
+    totp: boolean;
+    created: number;
+    updated: number;
+    used: number;
+}
+/** A login to save: a password or 2FA key left out keeps the saved one; an empty 2FA key removes it. */
+export interface VaultEntryIn {
+    id?: string;
+    site: string;
+    username: string;
+    password?: string;
+    note?: string;
+    totp?: string;
+}
+export declare const vaultStatus: () => Promise<{
+    exists: boolean;
+    unlocked: boolean;
+}>;
+/** The minutes before the vault locks itself, and whether to offer saving a sign-in. */
+export declare const vaultConfig: (autolockMinutes: number, offer: boolean) => Promise<void>;
+export declare const vaultCreate: (password: string) => Promise<void>;
+export declare const vaultUnlock: (password: string) => Promise<void>;
+export declare const vaultLock: () => Promise<void>;
+export declare const vaultChangePassword: (old: string, next: string) => Promise<void>;
+export declare const vaultList: () => Promise<VaultMeta[]>;
+/** Add or update a login; its id. */
+export declare const vaultSave: (entry: VaultEntryIn) => Promise<string>;
+export declare const vaultDelete: (id: string) => Promise<void>;
+/** One login's password, to show or copy. */
+export declare const vaultSecret: (id: string) => Promise<string>;
+/** One login's 2FA code now, and the seconds it has left. */
+export declare const vaultTotp: (id: string) => Promise<{
+    code: string;
+    remaining: number;
+}>;
+export declare const vaultGenerate: (length: number, symbols: boolean) => Promise<string>;
+/** The sites never offered saving for. */
+export declare const vaultNeverList: () => Promise<string[]>;
+export declare const vaultNeverRemove: (site: string) => Promise<void>;
+/** The logins saved for the page a pane shows. */
+export declare const vaultMatches: (pane: string) => Promise<VaultMeta[]>;
+/** Fill a login into the pane's page ("ok", or "user" when the page asks for the username first). */
+export declare const vaultFill: (pane: string, id: string) => Promise<string>;
+/** Fill a new generated password into a sign-up page's password fields. */
+export declare const vaultFillNew: (pane: string, length: number, symbols: boolean) => Promise<void>;
+export declare const vaultOfferAnswer: (pane: string, answer: "save" | "never" | "dismiss") => Promise<void>;
+/** Logins from a password export (Chrome, Edge, Brave, Firefox, Bitwarden). */
+export declare const vaultImport: (path: string) => Promise<{
+    added: number;
+    updated: number;
+    skipped: number;
+}>;
+/** Every login to a plain-text CSV file, after the master password again; how many. */
+export declare const vaultExport: (path: string, password: string) => Promise<number>;
+/** A page in the history: its title, how often and when it was last visited (ms). */
+export interface HistoryPage {
+    url: string;
+    title: string;
+    count: number;
+    last: number;
+}
+/** One visit to a page. */
+export interface HistoryVisit {
+    url: string;
+    title: string;
+    at: number;
+}
+/** A visit to a web page; `counted` false is only its title arriving. Whether anything changed. */
+export declare const browserHistoryVisit: (url: string, title: string, counted: boolean) => Promise<boolean>;
+export declare const browserHistoryRecent: (limit: number) => Promise<HistoryPage[]>;
+/** Visits newest first, before `before` (ms), whose page matches every word of `q`. */
+export declare const browserHistoryList: (q: string, before: number | null, limit: number) => Promise<HistoryVisit[]>;
+/** The pages the address bar offers for `q`, best first. */
+export declare const browserHistorySuggest: (q: string, limit: number) => Promise<HistoryPage[]>;
+/** How many pages the history holds. */
+export declare const browserHistoryCount: () => Promise<number>;
+export declare const browserHistoryForgetUrl: (url: string) => Promise<void>;
+/** Forget the visits from `from` to `to` (ms); all of them when neither is given. */
+export declare const browserHistoryForgetRange: (from?: number, to?: number) => Promise<void>;
+/** An installed extension. `id` is WebView2's, which chrome-extension:// addresses use. */
+export interface BrowserExtension {
+    id: string;
+    name: string;
+    version: string;
+    enabled: boolean;
+    storeId?: string;
+    popup?: string;
+    options?: string;
+    icon?: string;
+    path: string;
+    inPlace: boolean;
+}
+export declare const extensionsList: () => Promise<BrowserExtension[]>;
+/** Install from the Chrome Web Store, by its link or the extension's id; its name. */
+export declare const extensionInstallStore: (link: string) => Promise<string>;
+/** Install an unpacked extension from a folder: copied in, or loaded where it is (`inPlace`, developer mode); its name. */
+export declare const extensionInstallFolder: (path: string, inPlace?: boolean) => Promise<string>;
+/** Load an extension again from its files (an unpacked one's edits); its name. */
+export declare const extensionReload: (id: string) => Promise<string>;
+export declare const extensionSetEnabled: (id: string, enabled: boolean) => Promise<void>;
+export declare const extensionRemove: (id: string) => Promise<void>;
+/** Show an extension's popup page for `pane`, its right edge at `right` and top at `top` (physical pixels). */
+export declare const extensionPopup: (pane: string, id: string, page: string, right: number, top: number) => Promise<void>;
+export declare const extensionPopupClose: (pane: string) => Promise<void>;
+/** The sites agents may use in the browser without asking. */
+export declare const browserAgentConfig: (sites: string[]) => Promise<void>;
+/** The user's answer to an agent's question about a site. */
+export declare const browserAgentAnswer: (id: number, site: string, allow: boolean, forGood: boolean) => Promise<void>;
+/** A DevTools protocol call on a browser pane's page, and its answer. */
+export declare const browserCdp: (pane: string, method: string, params?: unknown) => Promise<unknown>;
+/** Open a browser pane's developer tools. */
+export declare const browserDevtools: (pane: string) => Promise<void>;
+/** What the site in a browser pane keeps and has been allowed: its cookie count and permissions. */
+export declare const browserSite: (pane: string) => Promise<{
+    origin: string;
+    cookies: number;
+    permissions: {
+        origin: string;
+        kind: number;
+        state: number;
+    }[];
+}>;
+/** Delete the site's cookies, storage and cache. */
+export declare const browserSiteClear: (pane: string) => Promise<void>;
+/** Every site given or refused a permission. */
+export declare const browserPermissions: () => Promise<{
+    origin: string;
+    kind: number;
+    state: number;
+}[]>;
+/** Set a site's permission: 0 ask again, 1 allow, 2 block. */
+export declare const browserPermissionSet: (origin: string, kind: number, state: number) => Promise<void>;
+/** Mute or unmute a browser pane's page. */
+export declare const browserMute: (pane: string, muted: boolean) => Promise<void>;
+/** Set a browser pane's page zoom (1 = 100%). */
+export declare const browserZoom: (pane: string, factor: number) => Promise<void>;
+/** Pause, resume or cancel one of the browser's downloads. */
+export declare const browserDownload: (id: number, action: "pause" | "resume" | "cancel") => Promise<void>;
+/** Find in the pane's page: start a search, step through its matches, or stop (clearing them). */
+export declare const browserFind: (pane: string, action: "start" | "next" | "prev" | "stop", term?: string, matchCase?: boolean) => Promise<void>;
+export declare const browserCapture: (pane: string) => Promise<ArrayBuffer>;
 export interface AppProc {
     name: string;
     title: string;
@@ -56,6 +240,19 @@ export interface Settings {
     serversList: boolean;
     /** The mouse wheel over a tab bar switches tabs rather than scrolling the bar. */
     tabWheelSwitch: boolean;
+    /** When the tabs do not fit, every one but the open tab shrinks to its icon. */
+    tabSqueeze?: boolean;
+    /** Each project's own colour on the sidebar's collapsed rail. Off, they are all one grey. */
+    projectColours?: boolean;
+    /** Pane controls float over the pane's top-right corner on hover, instead of a header row. */
+    floatingPaneControls: boolean;
+    /** Per notification kind, whether it shows as a card, in the bell, with a sound, and as a Windows
+     *  notification while Deck is not focused. A missing entry takes the default (notifications.ts). */
+    notifPrefs?: Partial<Record<"input" | "done" | "attention" | "activity" | "update" | "error" | "plugin", Partial<Record<"card" | "bell" | "sound" | "os", boolean>>>>;
+    /** No cards and no sound; everything still lands in the bell. */
+    doNotDisturb?: boolean;
+    /** Which corner on the right the notification cards stack in. */
+    notifPosition?: "bottom" | "top";
     /** Install plugin and language updates at startup instead of only announcing them. */
     pluginAutoUpdate: boolean;
     soundOnFire: boolean;
@@ -116,7 +313,53 @@ export interface Settings {
      * else the Windows account's (see `userName` in settingsstore.ts).
      */
     userName: string;
-}
+    /** What a new browser pane opens: Deck's start page, the search engine's own page, or a URL
+     *  (a site, or a local .html file the user wrote). */
+    browserHome: "deck" | "search" | "url";
+    browserHomeUrl: string;
+    /** Where a search typed into the address bar or the start page goes. */
+    browserSearch: SearchEngine;
+    /** Which parts of Deck's start page show. */
+    browserHomeSections: {
+        clock: boolean;
+        search: boolean;
+        servers: boolean;
+        pins: boolean;
+        recent: boolean;
+    };
+    /** Behind the start page: a photo that changes each time it opens, one from a folder of the
+     *  user's own, or none (Deck's background). */
+    browserBackground: "photos" | "folder" | "none";
+    browserBackgroundFolder: string;
+    /** Where the bookmarks bar shows under a browser's toolbar: on every page, on the start page
+     *  only, or not at all (and only once something is on it). true and false are what it was saved
+     *  as before it had three; read it through bookmarksBarMode. */
+    browserBookmarksBar: "always" | "home" | "never" | boolean;
+    /** WebView2's tracking prevention for the browser: how many trackers it blocks. */
+    browserTracking: "none" | "basic" | "balanced" | "strict";
+    /** Whether the vault offers to save a sign-in, and the minutes it stays open unused. */
+    browserVaultOffer: boolean;
+    browserVaultLock: number;
+    /** Extensions pinned to the browser's toolbar, by WebView2's id, in order. */
+    browserPinnedExtensions: string[];
+    /** The Extensions page's developer mode: load unpacked folders in place, reload them, ids and folders shown. */
+    browserExtensionsDev: boolean;
+    /** Whether the browser fills in forms (addresses, names). */
+    browserAutofill: boolean;
+    /** The ad blocker (EasyList and EasyPrivacy), and the sites it is switched off for, by host. */
+    browserAdblock: boolean;
+    browserAdblockOff: string[];
+    /** Skip YouTube's video ads: click Skip when it shows, run an unskippable one to its end. */
+    browserYoutubeSkip: boolean;
+    /** Where Ctrl+click on a web address in a terminal opens it: a browser tab of Deck's, or the system's. */
+    browserTerminalLinks: "deck" | "system";
+    /** The start page offers to make Deck the default browser while it is not. Off: "Don't ask again". */
+    browserDefaultAsk?: boolean;
+    /** Sites (by host) an agent may use in the browser without asking; localhost and files always. */
+    browserAgentSites: string[];
+}
+/** The bookmarks bar setting, older true/false values included. */
+export declare const bookmarksBarMode: (s: Settings) => "always" | "home" | "never";
 export declare const DEFAULT_SETTINGS: Settings;
 export declare const setAutostart: (on: boolean) => Promise<void>;
 export declare const getAutostart: () => Promise<boolean>;
@@ -239,6 +482,18 @@ export declare const logLatest: () => Promise<string>;
 export declare const openFile: (path: string) => Promise<void>;
 /** Files Deck was launched with — a double-click through Explorer's "Open with". */
 export declare const launchFiles: () => Promise<string[]>;
+/** Web addresses Deck was launched with: a link opened in another app, Deck being the default browser. */
+export declare const launchUrls: () => Promise<string[]>;
+export interface DefaultBrowserStatus {
+    registered: boolean;
+    isDefault: boolean;
+    name: string;
+}
+/** Whether Deck is offered as a browser in Windows, and whether links open with it. */
+export declare const browserDefaultStatus: () => Promise<DefaultBrowserStatus>;
+/** Register Deck as a browser for this user and open Windows' Default apps page at it: Windows
+ *  keeps the choice itself to the user. */
+export declare const browserDefaultRegister: () => Promise<DefaultBrowserStatus>;
 export declare const mediaSetNowPlaying: (title: string, artist: string, artPath: string) => Promise<void>;
 export declare const mediaSetPlayback: (playing: boolean) => Promise<void>;
 export interface TrackMeta {
@@ -411,6 +666,8 @@ export interface StartupMarks {
     setupEnd: number;
 }
 export declare const startupMarks: () => Promise<StartupMarks | null>;
+/** The page has drawn: Rust shows the window, hidden until then so it never shows see-through. */
+export declare const deckReady: () => Promise<void>;
 /** What a backup file holds: the Deck that wrote it, when, and how many of each thing. */
 export interface BackupSummary {
     deck: string;
@@ -664,6 +921,8 @@ export interface DbTable {
     name: string;
     kind: "table" | "view";
     columns: DbColumn[];
+    /** The statement that created it, where the engine keeps one (SQLite). */
+    sql?: string;
 }
 export interface DbForeignKey {
     table: string;
@@ -675,11 +934,15 @@ export interface DbSchema {
     tables: DbTable[];
     foreignKeys: DbForeignKey[];
 }
-/** Open a postgres:// or mysql:// connection. The handle outlives the calling component. */
+/** Open a connection; the url's scheme picks the engine. The handle outlives the calling component. */
 export declare const dbConnect: (url: string) => Promise<number>;
 export declare const dbDisconnect: (handle: number) => Promise<void>;
-/** Run ONE statement. `readOnly` wraps it in a read-only transaction the server enforces. */
-export declare const dbQuery: (handle: number, sql: string, readOnly: boolean) => Promise<DbQueryResult>;
+/**
+ * Run a statement and return up to 1000 rows, after skipping the first `skip` (how a grid pages).
+ * `readOnly` refuses writes, by the database itself (a read-only session on Postgres and MySQL,
+ * query_only on SQLite).
+ */
+export declare const dbQuery: (handle: number, sql: string, readOnly: boolean, skip?: number) => Promise<DbQueryResult>;
 export declare const dbSchema: (handle: number) => Promise<DbSchema>;
 /** Open a tunnel. `remote` is host:port as seen FROM `host`. Returns [id, local port]. */
 export declare const sshTunnelOpen: (host: string, remote: string) => Promise<[number, number]>;

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

@@ -1,50 +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. */
-    kind: "file" | "media" | "graph" | "pr";
-    path: string;
-    rel: string | null;
-    dirty?: 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): string;
-export declare function saveEditorRoot(instance: EditorInstance, root: 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;
+// 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/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[];

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/models.d.ts

@@ -1,7 +1,18 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { monaco } from "../../core/monaco";
 export declare const viewStates: Map<string, monaco.editor.ICodeEditorViewState | null>;
+/**
+ * An untitled buffer (Ctrl+N): `untitled:Untitled-N`. It has no file behind it, so its model gets
+ * an untitled: URI rather than a file:// one, it is never shown to a language server (which would
+ * answer for a file that does not exist), and its language comes from its text.
+ */
+export declare const isUntitled: (path: string) => boolean;
 export declare function fileUri(path: string): monaco.Uri;
+/** Pick an untitled buffer's language by hand, or null to go back to detecting it. Fine to call
+ *  before its model exists (a restored tab): the model is then created with it. */
+export declare function setUntitledLanguage(path: string, id: string | null): void;
+/** Take `path` for `owner`; false when another editor's buffer has it. */
+export declare function claimUntitled(path: string, owner: string): boolean;
 export declare function getFileModel(path: string, initial: string): monaco.editor.ITextModel;
 export declare function setModelValue(path: string, value: string): void;
 export declare function disposeModel(path: string | undefined): void;