deck-plugin-sdk 0.22.0 → 1.1.0

package/types/core/dap.d.ts

@@ -0,0 +1,181 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** How to launch an adapter: a language's `debug.adapter` block, resolved by lsp.rs's rules. */
+export interface AdapterSpec {
+    strategy: string;
+    command?: string;
+    module?: string;
+    args?: string[];
+}
+export interface Transport {
+    start(adapter: AdapterSpec, cwd: string): Promise<string>;
+    /** Another connection to a server adapter: the child session a `startDebugging` asks for. */
+    connect(parent: string): Promise<string>;
+    send(session: string, body: string): void;
+    stop(session: string): void;
+    /** Called once, before the first start: every message and every exit, for every session. */
+    listen(onMessage: (session: string, body: string) => void, onExit: (session: string) => void): Promise<void>;
+}
+export declare const tauriTransport: Transport;
+export interface Frame {
+    id: number;
+    name: string;
+    path?: string;
+    line: number;
+    column: number;
+}
+export interface Variable {
+    name: string;
+    value: string;
+    type?: string;
+    ref: number;
+}
+export interface OutputLine {
+    id: number;
+    category: string;
+    text: string;
+}
+/** A line breakpoint as the editor holds it. `verified` and `line` are the adapter's answer. */
+export interface Breakpoint {
+    line: number;
+    condition?: string;
+    verified?: boolean;
+    message?: string;
+    /** false: switched off, kept in the list and the gutter but not sent to the adapter. */
+    enabled?: boolean;
+}
+export type Status = "starting" | "running" | "paused" | "ended";
+export interface DebugState {
+    /** The session, or null when nothing is being debugged. Ended sessions stay until the next start. */
+    session: null | {
+        /** The connection requests go to: the adapter's, or the newest child session's. */
+        id: string;
+        /**
+         * Every connection of this session, the adapter's first. js-debug answers a launch by asking
+         * for a child session (`startDebugging`) on a second connection, and the program's stops,
+         * stack and variables are all on that one; the first is what ends the whole tree.
+         */
+        conns: string[];
+        name: string;
+        status: Status;
+        /** The thread that stopped, for every request that needs one (Dart isolates are threads). */
+        threadId?: number;
+        /** Why it paused: "breakpoint", "step", "exception", "pause", "entry". */
+        reason?: string;
+        /** The stopped thread's stack, top first. Empty while running. */
+        frames: Frame[];
+        /** The frame being looked at (index into `frames`): the top one on each stop, or a picked one. */
+        frame: number;
+        /** Counts stops, so a view of variables can tell this pause from the last one at the same line. */
+        stops: number;
+        /** The exception filters the adapter offers ("All", "Unhandled" for Dart), from `initialize`. */
+        filters: {
+            filter: string;
+            label: string;
+            default?: boolean;
+        }[];
+        /** The adapter's language ("dart", "python"): exception choices are kept per language. */
+        type: string;
+        /** A launched program ends with the session; an attached one is only detached. */
+        request: "launch" | "attach";
+        /** A stop on an exception: what was thrown, as the adapter describes it. */
+        description?: string;
+        error?: string;
+        /** The language, when the start said (for its debugger's Install button). */
+        languageId?: string;
+        /** The adapter never started or never answered: it is, most likely, not installed. */
+        notInstalled?: boolean;
+    };
+    output: OutputLine[];
+    /** The exception filters switched on, or null for the adapter's defaults. Kept across sessions. */
+    /**
+     * The exception filters switched on, per adapter type, or absent for that adapter's defaults.
+     * Per type because each adapter names its own ("Unhandled" for Dart, "uncaught" for Python).
+     */
+    exceptionFilters: Record<string, string[]>;
+    /** Breakpoints by file path, as the editor set them. */
+    breakpoints: Record<string, Breakpoint[]>;
+}
+/**
+ * The key a file's breakpoints are kept under: backslashes, as Windows tools and the adapter write
+ * paths. Two spellings of one file (slash direction, drive-letter case) must not hold two lists.
+ */
+export declare const bpKey: (path: string) => string;
+/** Whether two paths name the same file (Windows: case-insensitive). */
+export declare const samePath: (a: string, b: string) => boolean;
+/** What a start needs: the adapter, where to run it, and the launch or attach arguments. */
+export interface StartOptions {
+    name: string;
+    adapter: AdapterSpec;
+    cwd: string;
+    request: "launch" | "attach";
+    /** Passed to the adapter as the request's arguments (a launch.json configuration, more or less). */
+    args: Record<string, unknown>;
+    adapterId?: string;
+    /** What to install when the adapter will not start (language.json `debug.install`), in words. */
+    install?: string;
+    /** The language being debugged, so the panel can offer its debugger's Install button. */
+    languageId?: string;
+}
+type Msg = {
+    seq: number;
+    type: string;
+    request_seq?: number;
+    success?: boolean;
+    message?: string;
+    command?: string;
+    event?: string;
+    body?: Record<string, unknown>;
+};
+export declare function createDebugger(transport: Transport): {
+    subscribe: (fn: () => void) => () => void;
+    getState: () => DebugState;
+    start: (o: StartOptions) => Promise<void>;
+    stop: (terminate?: boolean) => Promise<void>;
+    continue: () => Promise<Msg>;
+    next: () => Promise<Msg>;
+    stepIn: () => Promise<Msg>;
+    stepOut: () => Promise<Msg>;
+    pause: () => Promise<Msg>;
+    /** The scopes of a frame (Locals, Globals…), each with the reference its variables are read by. */
+    scopes(frameId: number): Promise<{
+        name: string;
+        ref: number;
+    }[]>;
+    variables: (ref: number) => Promise<Variable[]>;
+    /** Evaluate in a frame: `watch` for the watch list, `repl` for the console, `hover` for the editor. */
+    evaluate(expression: string, frameId?: number, context?: "watch" | "repl" | "hover"): Promise<{
+        value: string;
+        ref: number;
+        error?: undefined;
+    } | {
+        error: string;
+        value?: undefined;
+        ref?: undefined;
+    }>;
+    /** Replace a file's breakpoints, and tell the adapter if a session is running. */
+    setBreakpoints: (path: string, list: Breakpoint[]) => void;
+    /** Add a breakpoint on a line, or remove the one there. */
+    toggleBreakpoint(path: string, line: number): void;
+    /** Set or clear a line's condition, adding the breakpoint if there is none. */
+    setCondition(path: string, line: number, condition: string): void;
+    /** Switch a breakpoint on or off without removing it. */
+    setEnabled(path: string, line: number, on: boolean): void;
+    /**
+     * The breakpoints' lines after an edit moved them. `lines` is in the order of the file's
+     * breakpoints; two that edits brought onto one line become one.
+     */
+    moveBreakpoints(path: string, lines: (number | undefined)[]): void;
+    breakpointsFor: (path: string) => Breakpoint[];
+    /** Look at another frame of the stopped thread's stack (the call stack's click). */
+    selectFrame(i: number): void;
+    clearOutput: () => void;
+    activeFilters: () => string[];
+    /** Choose which exceptions pause the program; remembered, and sent to a running adapter. */
+    setExceptionFilters(filters: string[]): void;
+    /** The debug console's input: echo it, evaluate it in the frame being looked at, print the answer. */
+    repl(expression: string): Promise<void>;
+};
+export type Debugger = ReturnType<typeof createDebugger>;
+/** Deck's debugger. */
+export declare const debug: Debugger;
+export {};

package/types/core/decode.d.ts

@@ -0,0 +1,13 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/**
+ * Text from a file's bytes, by its byte-order mark: UTF-16 when it has one (what `>` writes in
+ * Windows PowerShell 5.1), else UTF-8, else the Windows code page.
+ *
+ * `utf8` is false when the bytes are not UTF-8, so writing the text back (which Deck always does
+ * as UTF-8) would change the file's encoding. A UTF-8 BOM is kept in the text, as `fs_read` and
+ * the git text commands keep it, so the same file reads the same either way.
+ */
+export declare function decodeText(b: Uint8Array): {
+    text: string;
+    utf8: boolean;
+};

package/types/core/icontheme.d.ts

@@ -0,0 +1,28 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type LucideIcon } from "lucide-react";
+import { type ImportedPack } from "./bridge";
+export type IconRef = {
+    kind: "lucide";
+    icon: LucideIcon;
+} | {
+    kind: "url";
+    name: string;
+} | {
+    kind: "src";
+    src: string;
+};
+export interface IconTheme {
+    id: string;
+    label: string;
+    file(name: string): IconRef;
+    folder(name: string, open: boolean): IconRef;
+}
+export declare const ICON_THEMES: Record<string, IconTheme>;
+export declare function listPacks(): Promise<ImportedPack[]>;
+export declare function loadImportedThemes(): Promise<void>;
+export declare function addPack(pack: ImportedPack): Promise<void>;
+export declare function removePack(id: string): Promise<void>;
+export declare function allThemes(): IconTheme[];
+export declare function themeById(id: string): IconTheme;
+export declare function resolveIconUrl(svgName: string): Promise<string | null>;
+export declare function useIconThemesVersion(): number;

package/types/core/inlay.d.ts

@@ -0,0 +1,37 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** Which hints the editor shows: Settings → Editor → Display. */
+export type InlayShow = "all" | "types" | "parameters" | "off";
+export interface HintPart<U> {
+    label: string;
+    tooltip?: string | {
+        value: string;
+    };
+    location?: {
+        uri: U;
+        range: {
+            startLineNumber: number;
+            startColumn: number;
+            endLineNumber: number;
+            endColumn: number;
+        };
+    };
+}
+export interface Hint<U> {
+    label: string | HintPart<U>[];
+    position: {
+        lineNumber: number;
+        column: number;
+    };
+    kind?: number;
+    paddingLeft?: boolean;
+    paddingRight?: boolean;
+    tooltip?: string | {
+        value: string;
+    };
+}
+/**
+ * Monaco's hints for a `textDocument/inlayHint` reply, keeping only the kinds `show` asks for.
+ * LSP positions are 0-based and Monaco's 1-based. A hint with no kind (a server may send one) is
+ * kept by "all" and dropped by a filter, since it cannot be said to be either.
+ */
+export declare function toInlayHints<U>(reply: any, show: InlayShow, toUri: (uri: string) => U): Hint<U>[];

package/types/core/keys.d.ts

@@ -10,7 +10,7 @@
  * It is also what lets two bindings share a chord honestly — the editor's save and a terminal
  * action can both be Ctrl+S if the two surfaces never have the keyboard at the same time.
  */
-export type Scope = "app" | "workspaces" | "editor" | "http" | "terminal" | "graph" | "graph-visible" | `plugin:${string}`;
+export type Scope = "app" | "workspaces" | "editor" | "terminal" | `plugin:${string}`;
 /** Which thing owns the chord. Absent means a plain window listener. */
 export type Surface = "monaco" | "xterm" | "codemirror";
 export interface KeyBinding {

package/types/core/keystore.d.ts

@@ -38,9 +38,23 @@ export type KeyAction = (() => void) | {
 export declare function onKey(id: string, run: () => void, when?: () => boolean): () => void;
 /** Register several at once — what a module with a dozen chords wants. */
 export declare function onKeys(map: Record<string, KeyAction>): () => void;
-/** Claim a scope. Returns a disposer. */
-export declare function pushScope(scope: Scope): () => void;
+/**
+ * Claim a scope. `holds` says whether the claim counts right now (default: always). Returns a
+ * disposer.
+ */
+export declare function pushScope(scope: Scope, holds?: () => boolean): () => void;
 export declare function activeScopes(): ReadonlySet<Scope>;
+/**
+ * Whether the tool being rendered has the keyboard. A pane provides one that answers "is focus in
+ * me" (see ContentPane in Terminals.tsx); outside any pane a tool owns the window and always has it.
+ *
+ * Without this, a tool's shortcuts were live wherever focus was the moment it mounted, and a
+ * terminal swallows every chord something else has claimed, so an HTTP pane on screen took
+ * Ctrl+Enter away from the shell beside it.
+ */
+export declare const ScopeGate: import("react").Context<() => boolean>;
+/** Claim `scope` for as long as the component is mounted, while its pane (if any) has focus. */
+export declare function useScope(scope: Scope): void;
 /**
  * Run whatever this event is bound to, and say whether anything did.
  *

package/types/core/lsp.d.ts

@@ -0,0 +1,190 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { monaco } from "./monaco";
+/** How to launch the server — passed straight to Rust, which implements the strategies. */
+interface ServerSpec {
+    /** "path" | "node-module" | "exe-search" — see resolve_server() in lsp.rs. */
+    strategy: string;
+    command?: string;
+    module?: string;
+    args?: string[];
+    /** How to install the server, for the Install button in Settings › Languages. */
+    install?: Install;
+}
+/**
+ * What to install for a server or a debugger, as one of a few kinds Deck turns into a command
+ * itself (tools.rs): a definition from the registry never names a command to run.
+ */
+export type InstallSpec = {
+    kind: "pip" | "npm";
+    packages: string[];
+} | {
+    kind: "github-release";
+    name: string;
+    repo: string;
+    tag: string;
+    asset: string;
+    sha256: string;
+};
+/** A structured install, or a sentence for what Deck cannot install itself (an SDK). */
+export type Install = InstallSpec | string;
+/** An install as one sentence, for where a button would not fit or there is nothing to run. */
+export declare function installText(i: Install): string;
+/** Whether Deck can run it (an Install button), rather than only describe it. */
+export declare const canInstall: (i: Install | undefined) => i is InstallSpec;
+/** A language's server or debugger install entry, if its definition has one. */
+export declare function installFor(languageId: string, what: "server" | "debug"): Install | undefined;
+/** A language's debug adapter, or null when its definition names none (or there is no such language). */
+export declare function debugAdapterFor(languageId: string): {
+    adapter: ServerSpec;
+    type: string;
+    rootMarker: string;
+    launch?: Record<string, unknown>;
+    launchUnless?: string;
+    install?: Install;
+} | null;
+/**
+ * Whether a language's debug adapter runs on this machine: starts it and sees whether it is still
+ * running a moment later. Resolves to what was run, rejects with why not (the adapter's first line
+ * of output: Python's "No module named debugpy", Node's "Cannot find module"). Null when the
+ * language names no adapter.
+ */
+export declare function probeDebugger(languageId: string): Promise<string | null>;
+/**
+ * Load every language definition from %APPDATA%\Deck\languages.
+ *
+ * This is the ONLY source of languages. Deck used to compile a few in from src/languages/, which
+ * meant the shipped ones and a user's own obeyed different rules — one needed a rebuild to
+ * change, the other a restart, and only the first could carry snippets. Now there is one kind of
+ * language definition, and Deck ships none: an empty folder means Monaco's own highlighting and
+ * no language server, which is a coherent state rather than a broken one.
+ *
+ * Never rejects. A language that fails to load is one language that does not work; it is not a
+ * reason for the editor not to start, and the same contract loadPlugins states.
+ */
+export declare function loadExternalLanguages(): Promise<void>;
+/** One language, as Settings lists it. Flattened from its LangDef — the panel shows what a
+ *  definition claims, not the definition itself. */
+export interface LoadedLanguage {
+    languageId: string;
+    serverId: string;
+    extensions: string[];
+    rootMarker: string;
+    strategy: string;
+    /** The command or node module the strategy will look for. */
+    command: string;
+    /** The folder it came from, which is the name to look for on disk. */
+    folder: string;
+    /** language.json's version, or "" when it has none (a pack from before versions). */
+    version: string;
+    snippets?: number;
+}
+export interface LanguageError {
+    folder: string;
+    message: string;
+}
+/** Every language definition that loaded. */
+export declare function loadedLanguages(): readonly LoadedLanguage[];
+/**
+ * Re-read the languages folder whenever it changes on disk. Called once at startup.
+ *
+ * What makes installing a language from the registry take effect without a restart, the same way
+ * the plugin watcher does for a plugin. Debounced: writing a definition and its snippets emits
+ * several events, and each would otherwise re-read the whole folder.
+ *
+ * Only NEW definitions and changed data are picked up. A language whose server is already
+ * running keeps that session — lsp.rs owns it, and restarting one because a snippet file changed
+ * would lose whatever it had analysed.
+ */
+export declare function watchLanguages(): void;
+/**
+ * Whether a language's server is actually installed, without opening a file of that type.
+ *
+ * Until this existed, a definition naming a server you do not have was only discoverable by
+ * opening such a file and reading the error — so "Python needs basedpyright installed" was
+ * something Deck knew and never said.
+ *
+ * `root` is optional and usually empty: a node module resolves from the project's node_modules
+ * first, so a check with no project answers "is it installed globally".
+ */
+export declare function probeLanguage(languageId: string, root?: string): Promise<string>;
+/**
+ * Folders that failed to load, and why.
+ *
+ * The point of surfacing these: a definition with a typo is otherwise completely silent — the
+ * language simply does not work, with nothing on screen to say a file was even read.
+ */
+export declare function languageErrors(): readonly LanguageError[];
+export declare function lspSupports(languageId: string): boolean;
+export type LspPhase = "starting" | "ready" | "error" | "stopped";
+export interface LspStatus {
+    id: string;
+    serverId: string;
+    root: string;
+    phase: LspPhase;
+    detail: string;
+    log: string[];
+}
+/** React hook: current LSP server statuses (for the editor indicator). */
+export declare function useLspStatus(): LspStatus[];
+export declare function lspErrorVersion(): number;
+/** Live path -> error count. Read after subscribing to changes with subscribeLspErrors. */
+export declare function lspErrorCounts(): Map<string, number>;
+export declare function subscribeLspErrors(cb: () => void): () => void;
+/** Notify the server a document is open. Call when a file tab opens. */
+export declare function lspOpenDoc(path: string, content: string, root: string): Promise<void>;
+/**
+ * Notify the server a document changed. Call for EVERY Monaco change, synchronously — no
+ * debounce.
+ *
+ * Under incremental sync each notification describes one edit relative to the server's current
+ * copy, so dropping or reordering any of them desynchronizes the document permanently. That is
+ * also why this is no longer debounced: a debounce necessarily drops intermediate states, which
+ * is only legal when every message carries the whole file. Sending immediately has the better
+ * property anyway — completion and hover fire on the keystroke, so under the old 300ms debounce
+ * they queried a server whose buffer was up to 300ms stale and answered for a position that did
+ * not exist there yet.
+ *
+ * `changes` comes straight from Monaco's content-change event. Its ranges are in pre-edit
+ * coordinates and it orders them end-of-document first, which is exactly what LSP expects for a
+ * sequentially-applied batch: applying a later-in-document edit never shifts an earlier range.
+ * Do not sort them.
+ */
+export declare function lspChangeDoc(path: string, content: string, root: string, changes?: readonly monaco.editor.IModelContentChange[]): Promise<void>;
+/** Notify the server a document closed. Call when a tab closes. */
+export declare function lspCloseDoc(path: string, root: string): Promise<void>;
+/** One result of a project-wide symbol search (Ctrl+T). `line` and `col` are 1-based. */
+export interface ProjectSymbol {
+    name: string;
+    kind: number;
+    container: string;
+    path: string;
+    line: number;
+    col: number;
+}
+/**
+ * Classes, functions and the rest whose name matches `query`, from every language server running
+ * for `root` (a TypeScript and a Python server can share one), each server's own ranking kept and
+ * the lists joined. Only servers already running answer: Ctrl+T does not start one. [] for an
+ * empty query.
+ */
+export declare function workspaceSymbols(root: string, query: string): Promise<ProjectSymbol[]>;
+/** A file's outline from its language server, or [] when no server has it open. Also what the
+ *  debugger's inline values use to find the function a frame is in. */
+export declare function documentSymbols(model: monaco.editor.ITextModel): Promise<monaco.languages.DocumentSymbol[]>;
+type OpenFileHandler = (path: string, line: number, column: number) => void;
+export declare function setLspOpenFileHandler(fn: OpenFileHandler): void;
+/** Stop the servers no project has touched for IDLE_STOP_MS. Exported for the check. */
+export declare function stopIdleServers(now?: number): string[];
+/** Stop all sessions (e.g. on workspace close). */
+export declare function lspStopAll(): void;
+/** Restart one server (UI action from the status popover). */
+/**
+ * Stop a language server. The next file opened for that root starts a fresh one, which is why
+ * this is both the Restart action and the memory readout's stop button — there is no difference
+ * between the two beyond what the caller says about it.
+ *
+ * Deleting the frontend session alongside the process matters: leaving it would send didOpen to
+ * a dead pipe on the next open, and the editor would sit at "ready" with no diagnostics.
+ */
+export declare function lspRestart(id: string): Promise<void>;
+export {};

package/types/core/patterntokens.d.ts

@@ -0,0 +1,24 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import * as monaco from "monaco-editor";
+/** One pattern, from a language definition. */
+export interface TokenPattern {
+    /** The semantic token type to emit — the name an extraTokenColors rule matches. */
+    token: string;
+    /**
+     * A regular expression, as a string, with ONE capturing group: the part to colour.
+     *
+     * The group is what makes `new\s+(\w+)` colour the class and not the keyword. A pattern with
+     * no group is ignored rather than colouring its whole match, because the whole match is almost
+     * never what was meant.
+     */
+    pattern: string;
+    /** Regex flags. `g` is added if absent; `i` is the only one usually wanted beyond it. */
+    flags?: string;
+}
+/**
+ * Register pattern-based semantic tokens for one language.
+ *
+ * Returns a disposable, so reloading a definition does not leave the previous provider behind
+ * emitting the old patterns alongside the new ones.
+ */
+export declare function registerPatternTokens(languageId: string, patterns: TokenPattern[]): monaco.IDisposable | null;

package/types/core/remotepath.d.ts

@@ -0,0 +1,17 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface RemotePath {
+    host: string;
+    /** File access runs through sudo on the server. */
+    sudo: boolean;
+    /** Absolute POSIX path on the server. */
+    path: string;
+}
+export declare const isRemote: (p: string) => boolean;
+export declare function parseRemote(p: string): RemotePath | null;
+export declare function formatRemote(r: RemotePath): string;
+/** What a remote workspace is called: `vps:project`, or `vps:/` for the server's root. */
+export declare function remoteLabel(p: string): string;
+/** The ssh arguments that open an interactive shell in the folder. The path is single-quoted for
+ *  the remote shell, so spaces and `$` in it are taken literally. A server that sets no $SHELL
+ *  (minimal Alpine images) gets /bin/sh. */
+export declare function sshShellArgs(p: string): string[] | null;

package/types/core/snippets.d.ts

@@ -0,0 +1,15 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export interface Snippet {
+    prefix: string;
+    body: string;
+    detail?: string;
+}
+/**
+ * Load every snippet file in one language folder's `snippets/` subfolder.
+ *
+ * Never rejects, and never throws: a language with no snippets folder is the normal case, not an
+ * error, and one malformed file must not cost the others in the same folder.
+ */
+export declare function loadSnippets(languageId: string, languageDir: string): Promise<void>;
+/** Snippets for a language id (empty if none dropped in for it). */
+export declare function snippetsFor(languageId: string): Snippet[];

package/types/core/timeFormat.d.ts

@@ -0,0 +1,12 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** Format an "HH:mm" (24h storage) string for display in 12h or 24h. */
+export declare function fmtTime(hhmm: string, is12h: boolean): string;
+/** Format an epoch-ms timestamp's clock time (with seconds) for display. */
+export declare function fmtClock(ms: number, is12h: boolean): string;
+/** The app displays 12-hour time everywhere. */
+export declare function useTimeFormat(): boolean;
+/** Coarse relative time from an epoch-ms timestamp, e.g. "5 months ago", "just now". */
+export declare function fmtRelative(ms: number): string;
+export declare const useSettingBool: (key: string, fallback?: boolean) => boolean;
+export declare const useSettingString: (key: string, fallback?: string) => string;
+export declare const useSettingNumber: (key: string, fallback?: number) => number;

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

@@ -0,0 +1,80 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { monaco } from "../../core/monaco";
+import { type EditorSettings } from "../../core/editorsettings";
+import type { DirtyRange } from "./tree";
+declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLine, gotoCol, gotoNonce, highlight, dirty, settings, onEditor }: {
+    path: string;
+    rel?: string | null;
+    value: string;
+    onChange: (v: string) => void;
+    onSave?: () => void;
+    gotoLine?: number;
+    gotoCol?: number;
+    gotoNonce?: number;
+    highlight?: {
+        query: string;
+        caseSensitive: boolean;
+        isRegex: boolean;
+        wholeWord: boolean;
+    } | null;
+    dirty?: DirtyRange[];
+    settings: EditorSettings;
+    /** Hands the live editor out, and null on unmount. For a formatting toolbar, which has to
+     *  dispatch into this instance rather than rewrite the string around it. */
+    onEditor?: (e: monaco.editor.IStandaloneCodeEditor | null) => void;
+}): import("react").JSX.Element;
+/**
+ * Monaco owns its buffer, so this component re-rendering achieves nothing on its own — yet it was
+ * re-rendering on every keystroke, because Editor re-renders per character and passes a new
+ * `value` and freshly-defined callbacks each time.
+ *
+ * The comparator ignores exactly the props that cannot affect what is on screen: every callback
+ * (each is read through a ref that is reassigned on render, so identity is already irrelevant) and
+ * `value` itself (the editor's text comes from its model, never from this prop after mount).
+ * What remains are the props that really do drive an effect.
+ */
+export declare const MonacoEditor: import("react").MemoExoticComponent<typeof MonacoEditorInner>;
+export declare function applyLineChanges(original: monaco.editor.ITextModel, modified: monaco.editor.ITextModel, diffs: monaco.editor.ILineChange[]): string;
+export interface HunkAction {
+    label: string;
+    unstage: boolean;
+    run: (change: monaco.editor.ILineChange, models: {
+        original: monaco.editor.ITextModel;
+        modified: monaco.editor.ITextModel;
+    }) => void;
+}
+/** A side of a diff: LEFT the old version, RIGHT the new — GitHub's names, which line comments use. */
+export type DiffSide = "LEFT" | "RIGHT";
+/**
+ * Line comments on a diff (a pull request's): a mark in the gutter for each thread, a click on a
+ * line number to start one, and a line to bring into view when a thread is picked from the list.
+ */
+export interface LineComments {
+    marks: {
+        line: number;
+        side: DiffSide;
+        resolved: boolean;
+    }[];
+    /** `other`: the same line on the other side when this one is unchanged, else null. */
+    onPick: (line: number, side: DiffSide, other: number | null) => void;
+    /** `n` changes to reveal again, even the same line. */
+    reveal?: {
+        line: number;
+        side: DiffSide;
+        n: number;
+    };
+}
+export declare function MonacoDiff({ path, head, work, sideBySide, readOnly, rev, onChange, onSave, hunkAction, lineComments }: {
+    path: string;
+    head: string;
+    work: string;
+    sideBySide: boolean;
+    readOnly: boolean;
+    rev: number;
+    onChange: (v: string) => void;
+    /** Ctrl+S from inside the diff. Without it an editable diff took edits and silently lost them. */
+    onSave?: () => void;
+    hunkAction?: HunkAction;
+    lineComments?: LineComments;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export declare const GAP = "\u00A0\u00A0\u00A0\u00A0";

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

@@ -0,0 +1,13 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** A line change as Monaco's diff reports it: an end of 0 means that side's range is empty. */
+export interface LineChange {
+    originalStartLineNumber: number;
+    originalEndLineNumber: number;
+    modifiedStartLineNumber: number;
+    modifiedEndLineNumber: number;
+}
+/**
+ * The line on the other side of the diff that `line` on `side` is the same line as, or null when
+ * it is inside a change. GitLab needs both numbers to place a comment on an unchanged line.
+ */
+export declare function counterpartLine(changes: readonly LineChange[], line: number, side: "LEFT" | "RIGHT"): number | null;