deck-plugin-sdk 0.15.1

package/shim/mcp.d.ts

@@ -0,0 +1,68 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// What a plugin's mcp.ts is handed. Type-only: none of this exists at run time, because the MCP
+// server passes the real implementations in. See mcp/src/plugin-api.ts for the values.
+import type { z as Zod } from "zod";
+
+/** One tool's reply. */
+export interface ToolReply { content: { type: "text"; text: string }[] }
+
+/**
+ * The MCP server, narrowed to what a plugin uses: registering tools.
+ *
+ * The handler's argument is inferred FROM the schema — `{ url: z.string() }` gives the handler
+ * a `{ url: string }`. Typing it as `any` instead would compile just as happily and lose every
+ * field name inside the handler, which is the one place a typo costs something.
+ */
+export interface McpServer {
+  tool<S extends Record<string, Zod.ZodTypeAny>>(
+    name: string,
+    description: string,
+    schema: S,
+    handler: (args: Zod.infer<Zod.ZodObject<S>>) => Promise<ToolReply> | ToolReply,
+  ): void;
+}
+
+export type Weekday =
+  | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
+
+export interface ScriptJob {
+  id: string; name: string; command: string; args: string[];
+  mode: "interval" | "atTime"; intervalMin: number; days: string[]; timeOfDay: string;
+  enabled: boolean; lastRun: number; target?: string;
+  everyWeeks?: number; startDate?: string;
+}
+export interface ScriptFile { jobs: ScriptJob[] }
+
+export interface Job {
+  id: string; module: string; label: string; mode: string; recurring: boolean;
+  days: Weekday[]; timeOfDay?: string; delayMin?: number; fireAt: number;
+  warned: boolean; payload: unknown;
+}
+export interface JobFile { jobs: Job[] }
+
+export interface StartupProgram {
+  Name: string; Path: string; Args?: string[];
+  Days: string[]; Start: string; End: string; Enabled: boolean;
+}
+
+/** Everything the server hands a plugin's tools. */
+export interface DeckMcp {
+  /** THIS server's zod — schemas must be built with it, never a bundled copy. */
+  z: typeof Zod;
+  ok: (text: string) => ToolReply;
+  weekday: Zod.ZodEnum<[Weekday, ...Weekday[]]>;
+  readJson: <T>(name: string, fallback: T) => T;
+  writeJson: (name: string, data: unknown) => void;
+  newId: () => string;
+  ALL_DAYS: Weekday[];
+  nextFire: (
+    spec: { mode: string; recurring: boolean; days: Weekday[]; timeOfDay?: string; fireAt: number },
+    now: number,
+  ) => number | null;
+  TIMER_MODULES: readonly ["app-closer", "power-timer"];
+  deckApi: (path: string, init?: RequestInit) => Promise<Response>;
+  apiErr: (e: unknown) => ToolReply;
+}
+
+export type RegisterTools = (server: McpServer, deck: DeckMcp) => void | Promise<void>;

package/shim/monaco.d.ts

@@ -0,0 +1,5 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's real Monaco types, so a plugin is checked against the actual API rather than any.
+import * as monaco from "monaco-editor";
+export { monaco };

package/shim/monaco.js

@@ -0,0 +1,15 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's Monaco. Resolved at USE time like the bridge: a plugin module is evaluated during
+// loadPlugins, and a reference copied out at import time would capture a half-built object.
+const m = () => {
+  const x = window.__deck?.monaco;
+  if (!x) throw new Error("window.__deck.monaco is missing — this plugin only runs inside Deck");
+  return x;
+};
+
+export const monaco = new Proxy({}, {
+  get: (_t, k) => m()[k],
+  ownKeys: () => Reflect.ownKeys(m()),
+  getOwnPropertyDescriptor: (_t, k) => ({ ...Object.getOwnPropertyDescriptor(m(), k), configurable: true }),
+});

package/shim/react.js

@@ -0,0 +1,50 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's React, not a second copy: two Reacts in one tree break hooks in ways that look like
+// random render bugs.
+const React = window.__deck.React;
+export default React;
+export const Activity = React.Activity;
+export const Children = React.Children;
+export const Component = React.Component;
+export const Fragment = React.Fragment;
+export const Profiler = React.Profiler;
+export const PureComponent = React.PureComponent;
+export const StrictMode = React.StrictMode;
+export const Suspense = React.Suspense;
+export const __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+export const __COMPILER_RUNTIME = React.__COMPILER_RUNTIME;
+export const act = React.act;
+export const cache = React.cache;
+export const cacheSignal = React.cacheSignal;
+export const captureOwnerStack = React.captureOwnerStack;
+export const cloneElement = React.cloneElement;
+export const createContext = React.createContext;
+export const createElement = React.createElement;
+export const createRef = React.createRef;
+export const forwardRef = React.forwardRef;
+export const isValidElement = React.isValidElement;
+export const lazy = React.lazy;
+export const memo = React.memo;
+export const startTransition = React.startTransition;
+export const unstable_useCacheRefresh = React.unstable_useCacheRefresh;
+export const use = React.use;
+export const useActionState = React.useActionState;
+export const useCallback = React.useCallback;
+export const useContext = React.useContext;
+export const useDebugValue = React.useDebugValue;
+export const useDeferredValue = React.useDeferredValue;
+export const useEffect = React.useEffect;
+export const useEffectEvent = React.useEffectEvent;
+export const useId = React.useId;
+export const useImperativeHandle = React.useImperativeHandle;
+export const useInsertionEffect = React.useInsertionEffect;
+export const useLayoutEffect = React.useLayoutEffect;
+export const useMemo = React.useMemo;
+export const useOptimistic = React.useOptimistic;
+export const useReducer = React.useReducer;
+export const useRef = React.useRef;
+export const useState = React.useState;
+export const useSyncExternalStore = React.useSyncExternalStore;
+export const useTransition = React.useTransition;
+export const version = React.version;

package/shim/settings.d.ts

@@ -0,0 +1,5 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's real settings types, so a plugin is checked against the actual shape.
+export { useSettings, getSettings, saveSettings } from "../types/core/settingsstore";
+export type { Settings } from "../types/core/bridge";

package/shim/settings.js

@@ -0,0 +1,13 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's settings store. Use this ONLY for settings Deck itself defines and its Rust side reads;
+// a plugin's own settings belong in its own config file via configRead/configWrite.
+const s = () => {
+  const x = window.__deck?.settings;
+  if (!x) throw new Error("window.__deck.settings is missing — this plugin only runs inside Deck");
+  return x;
+};
+
+export const useSettings = (...a) => s().use(...a);
+export const getSettings = (...a) => s().get(...a);
+export const saveSettings = (...a) => s().save(...a);

package/shim/terminals.d.ts

@@ -0,0 +1,4 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's real terminal types, so a plugin is checked against the actual layout shape.
+export * from "../types/core/terminals";

package/shim/terminals.js

@@ -0,0 +1,70 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's terminal panes. Resolved at USE time like the bridge: a plugin module is evaluated
+// during loadPlugins, and a reference copied out at import time would capture a half-built
+// object. The layout store is shared, not copied — a second one would not know about the panes
+// Deck already has open.
+const t = () => {
+  const x = window.__deck?.terminals;
+  if (!x) throw new Error("window.__deck.terminals is missing — this plugin only runs inside Deck");
+  return x;
+};
+
+export const ZONE_BOARD = (...a) => t().ZONE_BOARD(...a);
+export const activeWorkspaceCwd = (...a) => t().activeWorkspaceCwd(...a);
+export const applyDtCommand = (...a) => t().applyDtCommand(...a);
+export const applyTerminalLook = (...a) => t().applyTerminalLook(...a);
+export const attach = (...a) => t().attach(...a);
+export const bracketPaste = (...a) => t().bracketPaste(...a);
+export const clearPane = (...a) => t().clearPane(...a);
+export const closeLeaf = (...a) => t().closeLeaf(...a);
+export const destroy = (...a) => t().destroy(...a);
+export const findLeaf = (...a) => t().findLeaf(...a);
+export const focusPane = (...a) => t().focusPane(...a);
+export const getInstance = (...a) => t().getInstance(...a);
+export const getLayout = (...a) => t().getLayout(...a);
+export const insertBeside = (...a) => t().insertBeside(...a);
+export const isPinned = (...a) => t().isPinned(...a);
+export const isWorkspaceActive = (...a) => t().isWorkspaceActive(...a);
+export const leafIds = (...a) => t().leafIds(...a);
+export const loadLayoutOnce = (...a) => t().loadLayoutOnce(...a);
+export const markAgentStarted = (...a) => t().markAgentStarted(...a);
+export const moveLeaf = (...a) => t().moveLeaf(...a);
+export const moveWorkspace = (...a) => t().moveWorkspace(...a);
+export const moveZone = (...a) => t().moveZone(...a);
+export const mutateLayout = (...a) => t().mutateLayout(...a);
+export const nextZoneSpot = (...a) => t().nextZoneSpot(...a);
+export const openTabInWorkspace = (...a) => t().openTabInWorkspace(...a);
+export const paneCwd = (...a) => t().paneCwd(...a);
+export const paneHasAgent = (...a) => t().paneHasAgent(...a);
+export const paneLabel = (...a) => t().paneLabel(...a);
+export const paneLines = (...a) => t().paneLines(...a);
+export const paneLocation = (...a) => t().paneLocation(...a);
+export const pasteInto = (...a) => t().pasteInto(...a);
+export const publishLayout = (...a) => t().publishLayout(...a);
+export const queueInput = (...a) => t().queueInput(...a);
+export const refit = (...a) => t().refit(...a);
+export const restartPane = (...a) => t().restartPane(...a);
+export const sendInput = (...a) => t().sendInput(...a);
+export const setLeafLabel = (...a) => t().setLeafLabel(...a);
+export const setLeafView = (...a) => t().setLeafView(...a);
+export const splitLeaf = (...a) => t().splitLeaf(...a);
+export const suspendWorkspace = (...a) => t().suspendWorkspace(...a);
+export const switchWorkspace = (...a) => t().switchWorkspace(...a);
+export const termKill = (...a) => t().termKill(...a);
+export const termList = (...a) => t().termList(...a);
+export const termResize = (...a) => t().termResize(...a);
+export const termScrollback = (...a) => t().termScrollback(...a);
+export const termSpawn = (...a) => t().termSpawn(...a);
+export const termSweepScrollback = (...a) => t().termSweepScrollback(...a);
+export const termWrite = (...a) => t().termWrite(...a);
+export const togglePin = (...a) => t().togglePin(...a);
+export const useAgentPanesVersion = (...a) => t().useAgentPanesVersion(...a);
+export const useLayout = (...a) => t().useLayout(...a);
+export const usePinnedPanes = (...a) => t().usePinnedPanes(...a);
+export const webglLimit = (...a) => t().webglLimit(...a);
+export const workspaceByCwd = (...a) => t().workspaceByCwd(...a);
+export const workspaceShellCount = (...a) => t().workspaceShellCount(...a);
+export const zoneAt = (...a) => t().zoneAt(...a);
+export const zoneBoardFull = (...a) => t().zoneBoardFull(...a);
+export const zoneToward = (...a) => t().zoneToward(...a);

package/shim/ui.d.ts

@@ -0,0 +1,14 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's real component types, so a plugin is checked against the actual props rather than any.
+export * from "../types/components/ui";
+export * from "../types/components/ConfirmDialog";
+export * from "../types/components/NamePrompt";
+export * from "../types/components/ContextMenu";
+export * from "../types/components/Toast";
+export * from "../types/components/useResize";
+export * from "../types/modules/editor/MarkdownLive";
+export * from "../types/components/TreeRow";
+export * from "../types/components/dragrow";
+export * from "../types/components/TabStrip";
+export * from "../types/components/MarkdownToolbar";

package/shim/ui.js

@@ -0,0 +1,37 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's own form controls. Resolved at USE time for the same reason the bridge is: a plugin
+// module is evaluated during loadPlugins, and a reference copied out at import time would
+// capture a half-built object.
+const u = () => {
+  const x = window.__deck?.ui;
+  if (!x) throw new Error("window.__deck.ui is missing — this plugin only runs inside Deck");
+  return x;
+};
+
+export const ConfirmDialog = (...a) => u().ConfirmDialog(...a);
+export const ContextMenu = (...a) => u().ContextMenu(...a);
+export const DayPicker = (...a) => u().DayPicker(...a);
+export const Field = (...a) => u().Field(...a);
+export const GhostButton = (...a) => u().GhostButton(...a);
+export const MarkdownLive = (...a) => u().MarkdownLive(...a);
+export const MarkdownToolbar = (...a) => u().MarkdownToolbar(...a);
+export const NamePrompt = (...a) => u().NamePrompt(...a);
+export const PanelHead = (...a) => u().PanelHead(...a);
+export const PrimaryButton = (...a) => u().PrimaryButton(...a);
+export const Row = (...a) => u().Row(...a);
+export const Segmented = (...a) => u().Segmented(...a);
+export const Select = (...a) => u().Select(...a);
+export const StatusItem = (...a) => u().StatusItem(...a);
+export const StatusPopover = (...a) => u().StatusPopover(...a);
+export const TabStrip = (...a) => u().TabStrip(...a);
+export const Tabs = (...a) => u().Tabs(...a);
+export const TextInput = (...a) => u().TextInput(...a);
+export const TimeInput = (...a) => u().TimeInput(...a);
+export const Toggle = (...a) => u().Toggle(...a);
+export const TreeRow = (...a) => u().TreeRow(...a);
+export const cmSurface = (...a) => u().cmSurface(...a);
+export const rowAt = (...a) => u().rowAt(...a);
+export const toast = (...a) => u().toast(...a);
+export const useResize = (...a) => u().useResize(...a);
+export const useRowDrag = (...a) => u().useRowDrag(...a);

package/template/README.md

@@ -0,0 +1,17 @@
+# __NAME__
+
+A plugin for [Deck](https://deck.hasan-zarif.com).
+
+## Developing
+
+```sh
+npm run dev            # build, and rebuild as you edit
+npm run install-local  # copy it into Deck, which loads it without a restart
+```
+
+`src/plugin.tsx` is the entry point; its default export is the tab.
+
+## What it does
+
+Say what this plugin is for. This file is what the registry shows on its page, so it is worth
+writing for somebody deciding whether to install it rather than for yourself.

package/template/gitignore

@@ -0,0 +1,4 @@
+node_modules/
+# Copied in by the build from the SDK — not yours to edit, and not worth committing.
+shim/
+types/

package/template/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "__ID__",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "deck-plugin build",
+    "dev": "deck-plugin dev",
+    "install-local": "deck-plugin install"
+  }
+}

package/template/plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "__ID__",
+  "name": "__NAME__",
+  "description": "One line on what this is for, shown under its name in Settings.",
+  "icon": "Sparkles",
+  "version": "0.1.0",
+  "minDeck": "0.15.0"
+}

package/template/src/plugin.tsx

@@ -0,0 +1,65 @@
+// __NAME__ — a Deck plugin.
+//
+// The default export is the tab. A plugin can export more than that — a footer readout, a
+// settings panel, palette commands, a pane view — and `plugins/API.md` in the Deck repository
+// lists every slot. One export is enough to start.
+import { useState } from "react";
+import { Sparkles } from "lucide-react";
+import { configRead, configWrite } from "../shim/bridge.js";
+
+/** Where this plugin's own settings live. The `plugin-` prefix keeps them on this machine. */
+const CONFIG = "plugin-__ID__";
+
+export default function __COMPONENT__() {
+  const [note, setNote] = useState("");
+  const [saved, setSaved] = useState(false);
+
+  // Deck's config store, the same one its own modules use. Reading a key that has never been
+  // written resolves to an empty string rather than throwing.
+  const load = async () => {
+    const raw = await configRead(CONFIG).catch(() => "");
+    setNote(raw.trim() ? (JSON.parse(raw) as { note?: string }).note ?? "" : "");
+  };
+
+  const save = async () => {
+    await configWrite(CONFIG, JSON.stringify({ note }));
+    setSaved(true);
+    setTimeout(() => setSaved(false), 1500);
+  };
+
+  return (
+    <div className="flex h-full flex-col gap-4 p-6">
+      <header className="flex items-center gap-3">
+        <Sparkles size={18} style={{ color: "var(--accent)" }} />
+        <h1 className="text-base font-semibold text-text-primary">__NAME__</h1>
+      </header>
+
+      <p className="max-w-[60ch] text-sm text-text-secondary">
+        Edit <code className="rounded bg-elev px-1.5 py-0.5 text-text-primary">src/plugin.tsx</code>,
+        run <code className="rounded bg-elev px-1.5 py-0.5 text-text-primary">npm run dev</code>,
+        and Deck reloads the plugin as you save.
+      </p>
+
+      <div className="flex max-w-md items-center gap-2">
+        <input
+          value={note}
+          onChange={(e) => setNote(e.target.value)}
+          onFocus={() => void load()}
+          placeholder="Type something, then save it"
+          className="min-w-0 flex-1 rounded-lg border border-subtle bg-elev px-3 py-2 text-sm text-text-primary outline-none focus:border-accent"
+        />
+        <button
+          onClick={() => void save()}
+          className="shrink-0 rounded-lg border border-subtle bg-elev px-3 py-2 text-sm text-text-secondary hover:border-accent hover:text-text-primary"
+        >
+          {saved ? "Saved" : "Save"}
+        </button>
+      </div>
+
+      <p className="text-xs text-text-muted">
+        That writes to Deck's config store under <code>{CONFIG}</code>, which stays on this
+        machine.
+      </p>
+    </div>
+  );
+}

package/template/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022", "DOM"]
+  },
+  "include": ["src/**/*"]
+}

package/types/components/ConfirmDialog.d.ts

@@ -0,0 +1,22 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface ConfirmState {
+    title: string;
+    /** A sentence for a plain question; nodes when the answer needs structure — an import summary
+     *  listing what is about to be added, for instance. */
+    body?: React.ReactNode;
+    /** Defaults to "Confirm". */
+    confirmLabel?: string;
+    /** Red confirm button — for anything that destroys work. Default true. */
+    danger?: boolean;
+    /** Wider dialog, for a body that is a summary rather than a sentence. */
+    wide?: boolean;
+    /** Report something that already happened: one button, nothing to cancel. Replaces alert(),
+     *  which in a webview is an OS modal — it steals focus, hides the cursor, and cannot be
+     *  styled or dismissed with Escape. */
+    acknowledge?: boolean;
+    onConfirm: () => void;
+}
+export declare function ConfirmDialog({ state, onClose }: {
+    state: ConfirmState | null;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/types/components/ContextMenu.d.ts

@@ -0,0 +1,41 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type LucideIcon } from "lucide-react";
+export interface MenuItem {
+    label: string;
+    /** Dim second line — a path, a description. Makes the row two-line. */
+    subLabel?: string;
+    icon?: LucideIcon;
+    hint?: string;
+    /** Status dot before the label: "ok" green, "warn" amber, "off" muted. */
+    dot?: "ok" | "warn" | "off";
+    danger?: boolean;
+    disabled?: boolean;
+    children?: MenuEntry[];
+    onClick?: () => void;
+    /** Icon button revealed on row hover — for a per-row action (close, delete) that would
+     *  otherwise need a submenu. Its click never triggers the row's own onClick. */
+    action?: {
+        icon: LucideIcon;
+        title: string;
+        danger?: boolean;
+        onClick: () => void;
+    };
+    /** Set (with the menu's onReorder) to make this row drag-sortable. The value identifies the
+     *  row to the caller — it's handed back as the moved id. */
+    dragId?: string;
+    /** 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;
+}
+export type MenuEntry = MenuItem | "sep";
+export declare function ContextMenu({ x, y, items, alignRight, onClose, onReorder, flipAt }: {
+    x: number;
+    y: number;
+    items: MenuEntry[];
+    alignRight?: boolean;
+    onClose: () => void;
+    /** A submenu flips around its parent row's LEFT edge, not the point it opened at. */
+    flipAt?: number;
+    /** Called with (draggedId, newIndexAmongDraggableRows) after a drag-sort. */
+    onReorder?: (id: string, toIndex: number) => void;
+}): import("react").ReactPortal;

package/types/components/MarkdownToolbar.d.ts

@@ -0,0 +1,48 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import type { EditorView } from "@codemirror/view";
+/**
+ * The four things every button needs from an editor, so the buttons are written once and work
+ * over both of Deck's markdown surfaces: CodeMirror (Live) and Monaco (Split's raw pane).
+ *
+ * Everything is expressed as offsets into the document string. Both editors can convert to and
+ * from that, and it keeps the button logic free of either one's Position/Range types.
+ */
+export interface TextSurface {
+    text(): string;
+    /** Current selection as document offsets. */
+    selection(): {
+        from: number;
+        to: number;
+    };
+    /** Apply edits and optionally move the selection. Must be ONE undo step. */
+    apply(changes: {
+        from: number;
+        to: number;
+        insert: string;
+    }[], select?: {
+        from: number;
+        to: number;
+    }): void;
+    focus(): void;
+}
+/** A TextSurface over a CodeMirror EditorView. */
+export declare function cmSurface(view: EditorView): TextSurface;
+export declare function MarkdownToolbar({ surface, zoom, onZoom, floating, view }: {
+    /** The editor to drive. Null disables every button — there is nothing to type into. */
+    surface: TextSurface | null;
+    /** Current text size in px. Omit to hide the zoom controls entirely. */
+    zoom?: number;
+    /** Called with +1 / -1 to step the size, and 0 to reset it. */
+    onZoom?: (delta: number) => void;
+    /**
+     * Float over the selection instead of sitting above the editor.
+     *
+     * Omit it and the editor's own "Floating markdown toolbar" setting decides, which is what
+     * every caller should do — this exists only for a surface that has a reason to override it.
+     * Needs `view`, which is what turns a document offset into screen coordinates.
+     */
+    floating?: boolean;
+    /** The CodeMirror view, for positioning a floating bar. Ignored otherwise. */
+    view?: EditorView | null;
+}): import("react").JSX.Element;
+export default MarkdownToolbar;

package/types/components/NamePrompt.d.ts

@@ -0,0 +1,16 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface NamePromptState {
+    title: string;
+    /** A second line under the title — the path being renamed, the ref being tagged. */
+    subtitle?: string;
+    /** Pre-filled value. A rename starts from the current name; a create starts empty. */
+    initial?: string;
+    placeholder?: string;
+    /** Defaults to "Save". */
+    confirmLabel?: string;
+    onSave: (value: string) => void;
+}
+export declare function NamePrompt({ state, onClose }: {
+    state: NamePromptState | null;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/types/components/TabStrip.d.ts

@@ -0,0 +1,26 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import type { ReactNode } from "react";
+export interface TabItem {
+    id: string;
+    title: ReactNode;
+    /** Drawn before the title — a file icon, an HTTP method, a kind glyph. */
+    icon?: ReactNode;
+    /** Unsaved changes: shows a dot that becomes the close X on hover. */
+    dirty?: boolean;
+    /** Rendered in italics — the editor's preview-tab convention. */
+    preview?: boolean;
+    /** Tooltip for the close button; defaults to "Close". */
+    closeTitle?: string;
+}
+export declare function TabStrip({ tabs, activeId, onSelect, onClose, onReorder, onDoubleClick, trailing, }: {
+    tabs: readonly TabItem[];
+    activeId: string | null;
+    onSelect: (id: string) => void;
+    onClose: (id: string) => void;
+    /** Moves `from` to `to`'s position. Omit to make the strip non-reorderable. */
+    onReorder?: (from: string, to: string) => void;
+    onDoubleClick?: (id: string) => void;
+    /** Right-aligned controls after the tabs — view toggles, save state. */
+    trailing?: ReactNode;
+}): import("react").JSX.Element;
+export default TabStrip;

package/types/components/Toast.d.ts

@@ -0,0 +1,48 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export type FlashKind = "info" | "success" | "error";
+export interface Flash {
+    id: number;
+    text: string;
+    kind: FlashKind;
+    /** Runs when the toast is clicked; the toast dismisses itself afterwards. */
+    onClick?: () => void;
+    /** Never expires on its own — see FlashOptions.ms. Exempt from the stack cap. */
+    sticky?: boolean;
+}
+/** The two things a caller may want to override per toast. Both optional. */
+export interface FlashOptions {
+    /**
+     * Make the toast clickable.
+     *
+     * The stack is `pointer-events-none` so a toast never eats a click meant for the UI behind it;
+     * an item with a handler re-enables pointer events on itself alone.
+     */
+    onClick?: () => void;
+    /**
+     * How long it stays up, overriding the per-kind default.
+     *
+     * 0 means it does not expire: it stays until it is clicked, or until the caller calls the
+     * dismiss function `toast` returned. For something that is true for a while — a meeting about
+     * to start — a duration is the wrong shape, because the right one is "until it is no longer
+     * true" and the caller is what knows that.
+     */
+    ms?: number;
+}
+/**
+ * Show a toast. Returns a function that dismisses it.
+ *
+ * The return value is ignorable — `toast("Saved")` is still the whole usage for the ordinary
+ * case. It exists for a toast raised with `ms: 0`, which never expires on its own and so needs
+ * someone to take it down.
+ *
+ * Safe to call from anywhere, including a plugin and a module-level store, because the queue is
+ * not React state.
+ */
+export declare function toast(text: string, kind?: FlashKind, opts?: FlashOptions): () => void;
+/**
+ * The toast stack. Rendered once, by App.
+ *
+ * Bottom-centre, above the footer: the corners are taken (the footer's popovers open upward on
+ * the right) and the centre is where the eye already is after a click.
+ */
+export declare function Toaster(): import("react").JSX.Element;