deck-plugin-sdk 0.22.0 → 1.2.0

package/types/core/bridge.d.ts

@@ -42,6 +42,8 @@ export interface Settings {
     closeToTray: boolean;
     startMinimized: boolean;
     reduceMotion: boolean;
+    /** The Servers list (hosts from ~/.ssh/config) under the workspace list. */
+    serversList: boolean;
     soundOnFire: boolean;
     playerPlacement: "fixed" | "floating";
     accent: AccentColor;
@@ -74,13 +76,23 @@ export interface Settings {
     /** Drawer tabs left-to-right. Ids missing from it keep their discovery order, after the rest. */
     drawerOrder: string[];
     httpMcpRevealSecrets: boolean;
+    /**
+     * What to call the user: shown to the others when sharing (a Canvas board's cursor and the
+     * host's "wants to join"). "" means work it out: the Google account's name when signed in,
+     * else the Windows account's (see `userName` in settingsstore.ts).
+     */
+    userName: string;
 }
 export declare const DEFAULT_SETTINGS: Settings;
 export declare const setAutostart: (on: boolean) => Promise<void>;
 export declare const getAutostart: () => Promise<boolean>;
 export declare const toggleFullscreen: () => Promise<boolean>;
 export declare const isFullscreen: () => Promise<boolean>;
-/** Watch these exact paths for external changes; emits "fs-changed" with the path. [] stops. */
+/** Check a sudo password on the server and hold it until Deck exits (never written anywhere). */
+export declare const remoteSudoPassword: (host: string, password: string) => Promise<void>;
+/** Ask for the sudo password of `host` (SudoPasswordPrompt, mounted in App). True once it has
+ *  been accepted, false if the prompt was cancelled. */
+export declare function askSudoPassword(host: string): Promise<boolean>;
 export declare const watchFiles: (paths: string[]) => Promise<void>;
 /** RAM in bytes: Deck and its WebView2 children, plus every claude.exe. */
 export interface MemServer {
@@ -171,6 +183,18 @@ export interface HttpSendResult {
  * that does need to cancel should use core/httpclient.ts, which owns that id.
  */
 export declare const httpSend: (req: HttpSendRequest) => Promise<HttpSendResult>;
+/**
+ * The same send under an id the caller chose, so it can be cancelled with `httpCancel` while in
+ * flight. `req` is the full shape http.rs takes; the Requests plugin builds it.
+ */
+export declare const httpSendAs: <T = HttpSendResult>(id: string, req: object) => Promise<T>;
+/** Abort the send started under `id`. A no-op when it has already finished. */
+export declare const httpCancel: (id: string) => Promise<void>;
+/**
+ * Answer an `http-send` event: a send the MCP asked for through sessions.rs, which waits on this
+ * reply under `job`. The Requests plugin listens for the event and does the send.
+ */
+export declare const httpSendReply: (job: string, body: string) => Promise<void>;
 export interface DownloadItem {
     id: string;
     url: string;
@@ -365,6 +389,18 @@ export declare const fsRead: (path: string) => Promise<string>;
 /** Raw bytes, for a file that is not text — fsRead decodes as UTF-8 and would corrupt it. */
 export declare const fsReadBytes: (path: string) => Promise<Uint8Array<ArrayBuffer>>;
 export declare const fsSize: (path: string) => Promise<number>;
+/** What is at a remote path. A missing one is `exists: false`, not an error. */
+export interface RemoteStat {
+    exists: boolean;
+    dir: boolean;
+    size: number;
+    mtimeMs: number;
+}
+export declare const remoteStat: (path: string) => Promise<RemoteStat>;
+/** The server's home folder as host:/home/user (host+sudo: when it runs as root). */
+export declare const remoteHome: (host: string, sudo: boolean) => Promise<string>;
+/** Host names from ~/.ssh/config, without patterns. */
+export declare const sshHosts: () => Promise<string[]>;
 export declare const fsWrite: (path: string, content: string) => Promise<void>;
 /** Raw bytes — saving a response that is an image or a PDF, which a string would corrupt. */
 export declare const fsWriteBytes: (path: string, bytes: Uint8Array) => Promise<void>;

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,193 @@
+// 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;
+    /** Its lucide icon name and colour from language.json; "" when it names none. */
+    icon: string;
+    color: 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 {};