deck-plugin-sdk 1.8.0 → 1.10.0

package/types/core/p2p.d.ts

@@ -1,117 +1,117 @@
-// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-/** What can travel: anything JSON can carry. */
-export type Json = string | number | boolean | null | Json[] | {
-    [k: string]: Json;
-};
-/** Whether someone may change what is shared, or only watch. */
-export type Mode = "edit" | "view";
-/** Who may change things: a default for everyone, and a choice per person that wins over it. */
-export interface Roles {
-    def: Mode;
-    per: Record<string, Mode>;
-}
-/** Why a share ended for a joiner: the host stopped, vanished, removed this Deck, turned it away,
- *  or speaks another version. */
-export type Gone = "ended" | "lost" | "removed" | "denied" | "version";
-export interface Person {
-    id: string;
-    name: string; /** Round trip in ms, once measured. */
-    ms?: number;
-}
-/** What a share's bar and dialogs show. Replaced, never mutated, so React sees a change. */
-export interface ShareView {
-    /** Who is in and connected: on the host, everyone let in; on a joiner, the host and the others. */
-    peers: Person[];
-    /** On the host: who is asking to be let in. */
-    knocking: Person[];
-    /** On a joiner: the host is there but has not let this Deck in yet. */
-    waiting: boolean;
-    /** On a joiner: no host heard from for a while (wrong code, or a network that blocks it). */
-    stuck: boolean;
-    gone: Gone | null;
-    hostName: string;
-    /** A passing line: someone on another version, or whatever the plugin `say`s. */
-    note: string;
-    roles: Roles;
-    /** Whether this Deck may change things. */
-    canEdit: boolean;
-}
-export interface ShareOptions {
-    /** What the share is for, e.g. "canvas-share". Decks only meet others using the same one. */
-    app: string;
-    /** The share code, which names the room (see newCode). */
-    code: string;
-    /** Optional extra secret, needed with the code to connect at all. Sharing works without one. */
-    password?: string;
-    /** The plugin's message channel, at most 12 bytes (Trystero's cap). Defaults to "msg". */
-    channel?: string;
-    /** Whether this Deck is the one sharing. */
-    host: boolean;
-    /** Shown to the others: in the host's knock, on cursors, in the list of who is here. */
-    name: string;
-    /** The plugin's own protocol version. Decks on different versions do not share. */
-    version: number;
-    /** The host's default for who may change things. Joiners may until the host says otherwise. */
-    mode?: Mode;
-}
-export interface ShareHandlers<T> {
-    /** A plugin message, only ever from someone let in (and the host). Check `mayEdit(peer)` before
-     *  applying a change: a view-only person's edits are to be dropped by every Deck. */
-    message: (msg: T, peer: string) => void;
-    /** On the host: someone was just let in. Send them what they need to start, e.g. the board. */
-    welcome?: (peer: string) => void;
-    /** Someone left or was removed: forget what was kept for them (a cursor). */
-    left?: (peer: string) => void;
-}
-export interface P2pShare<T> {
-    readonly host: boolean;
-    /** Send a plugin message to everyone let in, or to one of them. Sends nothing before this Deck is
-     *  let in. Settles once handed to the connection, so awaiting it paces the sender. */
-    send(msg: T, to?: string): Promise<void>;
-    /** Whether a peer may change things: the host always, anyone else by the roles. */
-    mayEdit(peer: string): boolean;
-    /** The host: let someone in, or turn them away. */
-    allow(peer: string): void;
-    deny(peer: string): void;
-    /** The host: remove someone who was let in. They cannot come back with the same Deck. */
-    kick(peer: string): void;
-    /** The host: everyone's default, and one person's own choice (`null` follows the default). */
-    setDefault(mode: Mode): void;
-    setPerson(peer: string, mode: Mode | null): void;
-    /** Show a passing line in the view for a few seconds. */
-    say(note: string): void;
-    /** Leave. With `announce` (the host ending on purpose) everyone is told first, so they end at
-     *  once rather than when the connection times out. Safe to call twice. */
-    close(announce?: boolean): Promise<void>;
-    /** For useSyncExternalStore. */
-    subscribe(fn: () => void): () => void;
-    getView(): ShareView;
-}
-/** The part of a Trystero room a share uses: a seam, so the check can run a share without a network. */
-export interface RoomLike {
-    /** This Deck's id in the room; Trystero's own is `selfId()`. */
-    selfId?: string;
-    makeAction(name: string, config: {
-        onMessage: (data: any, ctx: {
-            peerId: string;
-        }) => void;
-    }): {
-        send(data: any, options?: {
-            target?: string | string[];
-        }): Promise<void>;
-    };
-    ping(peer: string): Promise<number>;
-    leave(): Promise<void>;
-    getPeers(): Record<string, unknown>;
-    onPeerJoin: ((peer: string) => void) | null;
-    onPeerLeave: ((peer: string) => void) | null;
-}
-/** This Deck's id in every share: the one the others know it by. The same for the whole session,
- *  so someone let in who rejoins after a dropped connection is let straight back in. */
-export declare function selfId(): string;
-/** Start sharing (`host`), or ask to join someone's share. */
-export declare function share<T extends Json>(opts: ShareOptions, on: ShareHandlers<T>, room?: RoomLike): P2pShare<T>;
-/** A share code: 16 random characters in four groups, easy to read out or paste. */
-export declare function newCode(random?: (n: number) => Uint8Array): string;
-/** A pasted code, tidied: spaces dropped, case folded. Empty when it is not a code. */
-export declare function cleanCode(text: string): string;
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** What can travel: anything JSON can carry. */
+export type Json = string | number | boolean | null | Json[] | {
+    [k: string]: Json;
+};
+/** Whether someone may change what is shared, or only watch. */
+export type Mode = "edit" | "view";
+/** Who may change things: a default for everyone, and a choice per person that wins over it. */
+export interface Roles {
+    def: Mode;
+    per: Record<string, Mode>;
+}
+/** Why a share ended for a joiner: the host stopped, vanished, removed this Deck, turned it away,
+ *  or speaks another version. */
+export type Gone = "ended" | "lost" | "removed" | "denied" | "version";
+export interface Person {
+    id: string;
+    name: string; /** Round trip in ms, once measured. */
+    ms?: number;
+}
+/** What a share's bar and dialogs show. Replaced, never mutated, so React sees a change. */
+export interface ShareView {
+    /** Who is in and connected: on the host, everyone let in; on a joiner, the host and the others. */
+    peers: Person[];
+    /** On the host: who is asking to be let in. */
+    knocking: Person[];
+    /** On a joiner: the host is there but has not let this Deck in yet. */
+    waiting: boolean;
+    /** On a joiner: no host heard from for a while (wrong code, or a network that blocks it). */
+    stuck: boolean;
+    gone: Gone | null;
+    hostName: string;
+    /** A passing line: someone on another version, or whatever the plugin `say`s. */
+    note: string;
+    roles: Roles;
+    /** Whether this Deck may change things. */
+    canEdit: boolean;
+}
+export interface ShareOptions {
+    /** What the share is for, e.g. "canvas-share". Decks only meet others using the same one. */
+    app: string;
+    /** The share code, which names the room (see newCode). */
+    code: string;
+    /** Optional extra secret, needed with the code to connect at all. Sharing works without one. */
+    password?: string;
+    /** The plugin's message channel, at most 12 bytes (Trystero's cap). Defaults to "msg". */
+    channel?: string;
+    /** Whether this Deck is the one sharing. */
+    host: boolean;
+    /** Shown to the others: in the host's knock, on cursors, in the list of who is here. */
+    name: string;
+    /** The plugin's own protocol version. Decks on different versions do not share. */
+    version: number;
+    /** The host's default for who may change things. Joiners may until the host says otherwise. */
+    mode?: Mode;
+}
+export interface ShareHandlers<T> {
+    /** A plugin message, only ever from someone let in (and the host). Check `mayEdit(peer)` before
+     *  applying a change: a view-only person's edits are to be dropped by every Deck. */
+    message: (msg: T, peer: string) => void;
+    /** On the host: someone was just let in. Send them what they need to start, e.g. the board. */
+    welcome?: (peer: string) => void;
+    /** Someone left or was removed: forget what was kept for them (a cursor). */
+    left?: (peer: string) => void;
+}
+export interface P2pShare<T> {
+    readonly host: boolean;
+    /** Send a plugin message to everyone let in, or to one of them. Sends nothing before this Deck is
+     *  let in. Settles once handed to the connection, so awaiting it paces the sender. */
+    send(msg: T, to?: string): Promise<void>;
+    /** Whether a peer may change things: the host always, anyone else by the roles. */
+    mayEdit(peer: string): boolean;
+    /** The host: let someone in, or turn them away. */
+    allow(peer: string): void;
+    deny(peer: string): void;
+    /** The host: remove someone who was let in. They cannot come back with the same Deck. */
+    kick(peer: string): void;
+    /** The host: everyone's default, and one person's own choice (`null` follows the default). */
+    setDefault(mode: Mode): void;
+    setPerson(peer: string, mode: Mode | null): void;
+    /** Show a passing line in the view for a few seconds. */
+    say(note: string): void;
+    /** Leave. With `announce` (the host ending on purpose) everyone is told first, so they end at
+     *  once rather than when the connection times out. Safe to call twice. */
+    close(announce?: boolean): Promise<void>;
+    /** For useSyncExternalStore. */
+    subscribe(fn: () => void): () => void;
+    getView(): ShareView;
+}
+/** The part of a Trystero room a share uses: a seam, so the check can run a share without a network. */
+export interface RoomLike {
+    /** This Deck's id in the room; Trystero's own is `selfId()`. */
+    selfId?: string;
+    makeAction(name: string, config: {
+        onMessage: (data: any, ctx: {
+            peerId: string;
+        }) => void;
+    }): {
+        send(data: any, options?: {
+            target?: string | string[];
+        }): Promise<void>;
+    };
+    ping(peer: string): Promise<number>;
+    leave(): Promise<void>;
+    getPeers(): Record<string, unknown>;
+    onPeerJoin: ((peer: string) => void) | null;
+    onPeerLeave: ((peer: string) => void) | null;
+}
+/** This Deck's id in every share: the one the others know it by. The same for the whole session,
+ *  so someone let in who rejoins after a dropped connection is let straight back in. */
+export declare function selfId(): string;
+/** Start sharing (`host`), or ask to join someone's share. */
+export declare function share<T extends Json>(opts: ShareOptions, on: ShareHandlers<T>, room?: RoomLike): P2pShare<T>;
+/** A share code: 16 random characters in four groups, easy to read out or paste. */
+export declare function newCode(random?: (n: number) => Uint8Array): string;
+/** A pasted code, tidied: spaces dropped, case folded. Empty when it is not a code. */
+export declare function cleanCode(text: string): string;

package/types/core/portal.d.ts

@@ -0,0 +1,3 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type ReactNode } from "react";
+export declare function createPortal(children: ReactNode, container: Element | DocumentFragment, key?: string | null): ReactNode;

package/types/core/settingsstore.d.ts

@@ -1,26 +1,26 @@
-// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-import { type Settings } from "./bridge";
-/** Called by Settings after every write, so readers update without a reload. */
-export declare function publishSettings(s: Settings): void;
-/**
- * Write settings and apply everything that has to happen alongside the write.
- *
- * Settings' own persist() used to be the only path, so anything outside that module (the
- * command palette toggling relay, say) would have had to repeat five steps and would break
- * quietly when one of them changed. Settings still owns its local form state and calls this
- * for the shared half.
- */
-export declare function saveSettings(next: Settings): void;
-/** The zoom steps Ctrl+= and Ctrl+- move through, in percent, as a browser's do. */
-export declare const ZOOM_STEPS: number[];
-/**
- * Zoom the whole window: the webview's own zoom, the same as a browser's Ctrl+=, rather than CSS
- * `zoom`, which leaves xterm and Monaco measuring the mouse in unzoomed pixels.
- */
-export declare function applyZoom(pct: number | undefined): void;
-/** One step in or out from the current zoom, or back to 100% with dir 0. Saved like any setting. */
-export declare function stepZoom(dir: -1 | 0 | 1): void;
-/** Current settings for non-React callers (the palette's providers). */
-export declare const getSettings: () => Settings;
-export declare function userName(): Promise<string>;
-export declare function useSettings(): Settings;
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type Settings } from "./bridge";
+/** Called by Settings after every write, so readers update without a reload. */
+export declare function publishSettings(s: Settings): void;
+/**
+ * Write settings and apply everything that has to happen alongside the write.
+ *
+ * Settings' own persist() used to be the only path, so anything outside that module (the
+ * command palette toggling relay, say) would have had to repeat five steps and would break
+ * quietly when one of them changed. Settings still owns its local form state and calls this
+ * for the shared half.
+ */
+export declare function saveSettings(next: Settings): void;
+/** The zoom steps Ctrl+= and Ctrl+- move through, in percent, as a browser's do. */
+export declare const ZOOM_STEPS: number[];
+/**
+ * Zoom the whole window: the webview's own zoom, the same as a browser's Ctrl+=, rather than CSS
+ * `zoom`, which leaves xterm and Monaco measuring the mouse in unzoomed pixels.
+ */
+export declare function applyZoom(pct: number | undefined): void;
+/** One step in or out from the current zoom, or back to 100% with dir 0. Saved like any setting. */
+export declare function stepZoom(dir: -1 | 0 | 1): void;
+/** Current settings for non-React callers (the palette's providers). */
+export declare const getSettings: () => Settings;
+export declare function userName(): Promise<string>;
+export declare function useSettings(): Settings;

package/types/core/shellpath.d.ts

@@ -20,9 +20,11 @@ export interface TermPath {
  * The shortest extent comes first, so a caller that only wants the unambiguous reading can take
  * the first candidate per `start` and never consult the filesystem.
  *
- * ponytail: one row at a time, so a path wrapped across two visual rows is missed, and a relative
- * path resolves against the cwd the pane SPAWNED with, so it is wrong after a `cd`. Absolute
- * paths — what Claude Code and most tools print — are unaffected by both.
+ * One line of text: a path wrapped over several rows is found once `joinRows` has put them back
+ * together.
+ *
+ * ponytail: a relative path resolves against the cwd the pane SPAWNED with, so it is wrong after a
+ * `cd`. Absolute paths — what Claude Code and most tools print — are unaffected.
  *
  * ponytail: only the END of a path can be recovered this way. A RELATIVE path whose first segment
  * contains a space ("My Docs\a.txt") is anchored at "Docs\a.txt", because the match can only
@@ -43,3 +45,41 @@ export declare function findPaths(row: string, cwd: string): TermPath[];
  * land on either.
  */
 export declare function chooseLinks(candidates: readonly TermPath[], exists: readonly boolean[]): TermPath[];
+/**
+ * A Windows path not found as printed, with a backslash put back that Markdown took out. Claude
+ * Code renders its output as Markdown, where `\.` and `\_` mean a plain dot and underscore, so
+ * "review-repo\.gitattributes" is shown as "review-repo.gitattributes". One reading per dot or
+ * underscore that follows a name character, each to be tried on disk.
+ */
+export declare function unescapedReadings(path: string): string[];
+/** A row of the screen: its text (trailing blanks kept), and whether xterm wrapped it onto the row before. */
+export interface Row {
+    text: string;
+    wrapped: boolean;
+}
+/**
+ * The line row `at` is part of, read back as one: rows xterm wrapped itself (a shell's long line),
+ * and rows a program broke where a path ran out of room. Claude Code wraps its own output, a hard
+ * line break with the rest indented under it, so xterm knows nothing of that wrap: a row and the
+ * next are taken as a path broken in two when the words either side of the break look like one
+ * (see `broken`), and they join without the break or the indent. `cells[i]` is where character `i`
+ * of the text is on screen: its row (an index into `rows`) and column. At most `reach` rows each way.
+ *
+ * A list of paths, one a row, joins too: only the filesystem can tell it from one path broken in
+ * two, which is why the terminal also offers the row on its own.
+ */
+export declare function joinRows(rows: readonly Row[], at: number, reach?: number): {
+    text: string;
+    cells: [number, number][];
+};
+/**
+ * Every path candidate on row `at`, also one wrapped over the rows around it. A join xterm made is
+ * certain, but one at a break (`broken`) is a guess: a path can end a row with the next row's words
+ * glued on, so the joined line (`joinRows`) is read cut at each such break as well, every span of
+ * it that holds row `at`. Starts are indices into `text`, ascending, ready for `chooseLinks`;
+ * `cells` says where each is on screen.
+ */
+export declare function rowPaths(rows: readonly Row[], at: number, cwd: string): {
+    cands: TermPath[];
+    cells: [number, number][];
+};

package/types/core/terminals.d.ts

@@ -45,6 +45,18 @@ export interface LayoutTab {
     hidden?: boolean;
     /** The tab group it is in (LayoutWorkspace.groups); a group's tabs sit together in one zone. */
     group?: string;
+    /**
+     * Torn off into a window of its own (core/floatwin.ts): the window's id. Such a tab is in no
+     * zone, though it keeps its x/y to go back to. A restart reopens the window (Layout.floats has
+     * where it was).
+     */
+    window?: string;
+    /**
+     * Opened straight into a floating window by Deck (openInFloat: a link, a page an agent opened, a
+     * file Ctrl+clicked in a terminal), so closing that window closes it rather than docking it into
+     * the main window. Dropped the moment the tab is moved by hand: then it is one of yours.
+     */
+    transient?: true;
 }
 export interface LayoutWorkspace {
     id: string;
@@ -57,9 +69,21 @@ export interface LayoutWorkspace {
     /** Its colour on the sidebar's collapsed rail, by index (Terminals' TONES); none picks one from the name. */
     color?: number;
 }
+/** Where a floating window was, in physical screen pixels (its size and place before any maximise), to reopen it there. */
+export interface FloatBounds {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    max?: boolean;
+    /** A window things are sent to by name (core/floatwin.ts openInFloat): "links", "agent". */
+    name?: string;
+}
 export interface Layout {
     workspaces: LayoutWorkspace[];
     activeWs: string;
+    floats?: FloatBounds[];
 }
 export declare function publishLayout(l: Layout): void;
 export declare function getLayout(): Layout | null;
@@ -187,6 +211,15 @@ export declare function moveTabToZone(tabs: readonly LayoutTab[], tabId: string,
  * result is right even for a zone that is not the active one.
  */
 export declare function addTabToZone(tabs: readonly LayoutTab[], besideId: string, tab: LayoutTab): LayoutTab[];
+/**
+ * A closed tab put back in workspace `w` (core/closedtabs.ts): in front in the zone you are in,
+ * with new ids for the tab and its panes, since the old panes' shells and state are gone. Out of
+ * any group and any window it was in. Returns the workspace and each old pane's new id.
+ */
+export declare function reopenTab(w: LayoutWorkspace, tab: LayoutTab, fresh?: () => string): {
+    w: LayoutWorkspace;
+    ids: Record<string, string>;
+};
 /**
  * Make a workspace's active tab the one its zone shows.
  *
@@ -202,6 +235,27 @@ export declare function showActiveTab(w: LayoutWorkspace): LayoutWorkspace;
  * the zone nor back to its first tab; otherwise the first zone left.
  */
 export declare function nextActiveAfterClose(tabs: readonly LayoutTab[], closing: string): string | undefined;
+/**
+ * Tear a tab off into window `win`, or (`win` undefined) dock it back. A workspace always keeps
+ * one docked tab: floating its last one leaves a fresh terminal behind, as the main window has
+ * to show something. Tearing off the active tab makes its neighbour active.
+ */
+export declare function setTabWindow(w: LayoutWorkspace, tabId: string, win: string | undefined, keepGroup?: boolean): LayoutWorkspace;
+/**
+ * Merge floating window `from`'s tabs into another window: floating window `into`, or (`into`
+ * null) the main window, into the active zone of the project it shows. They go in behind the tab
+ * that window shows, which stays shown: a tab dropped somewhere does not take you away from the one
+ * you were on. The tabs move between projects when the window they land in shows another one's,
+ * since a window holds one project's tabs.
+ */
+export declare function mergeWindow(l: Layout, from: string, into: string | null): Layout;
+/**
+ * Close floating window `id` into the main window: its tabs go back to their zones, each behind the
+ * tab its zone shows, so closing a window does not take you away from the tab you are on. With
+ * `discard` (its X, Alt+F4), the tabs Deck opened into it (`transient`) close instead; the caller
+ * destroys their panes.
+ */
+export declare function dockWindow(l: Layout, id: string, discard?: boolean): Layout;
 /** The first free spot on the top row, for a zone created without a position of its own. */
 export declare function nextZoneSpot(tabs: readonly LayoutTab[], cols?: number, rows?: number): {
     x: number;
@@ -286,7 +340,15 @@ export declare function moveLeaf(root: LayoutNode, srcId: string, targetId: stri
 export declare function openTabInWorkspace(wsId: string, title: string, opts?: {
     besideActive?: boolean;
 }): string | null;
-export declare function applyDtCommand(op: string, args: Record<string, unknown>): string | void;
+/**
+ * `agent`: asked for over the control API (an agent), not from Deck's own palette. Then a new
+ * terminal tab or project is added without switching to it (Settings → Where things open,
+ * agentTerminals), its shell started at once (spawnUnseen): a pane starts its shell when it is
+ * first drawn, and the agent's next command goes to that shell.
+ */
+export declare function applyDtCommand(op: string, args: Record<string, unknown>, agent?: boolean): string | void;
+/** Close the pane `pane`: its whole tab when it is the tab's only pane, as an agent's page is. */
+export declare function closePaneTab(pane: string): void;
 interface Instance {
     term: Terminal;
     fit: FitAddon;
@@ -331,7 +393,7 @@ export declare function moveWorkspace(id: string, toIndex: number): void;
  * Registered per attach because resolving a relative path needs the pane's cwd, which is what
  * attach is given. The instance outlives its DOM, so the previous provider is disposed first
  * rather than stacking a second one on every re-attach. The matching itself lives in shellpath
- * (no xterm import), where it is exercised by shellpath.check.ts.
+ * (no xterm import), where it is exercised by shellpath.check.mjs.
  *
  * Only a path that actually exists is offered as a link. Matching the shape of a path is not the
  * same as having one: output wraps mid-path at the edge of a narrow pane, a relative path resolves
@@ -419,6 +481,27 @@ export declare function queueInput(paneId: string, text: string): void;
  * the user picked (the agent launcher) has to handle both.
  */
 export declare function sendInput(paneId: string, text: string): void;
+/** The command that resumes an agent's session, or undefined for a kind Deck cannot resume. */
+export declare const resumeCommand: (kind: string, session: string) => string;
+/**
+ * The agent session each of these panes holds, read fresh from the sweep's file (the map cached at
+ * startup misses an agent started since): for a closed tab to resume it when reopened. Read before
+ * the next sweep, which drops a pane gone from the layout.
+ */
+export declare function agentSessions(ids: string[]): Promise<Record<string, {
+    kind: string;
+    session: string;
+}>>;
+/**
+ * What is running in these panes besides their shells, for a close to ask about: the programs the
+ * sweep saw in each (state/term-procs), or "an agent" for one it has not listed yet. Only panes
+ * with a shell count; a view pane loses nothing by closing.
+ *
+ * ponytail: term-procs is up to 10s old (the sweep's interval), so a program started just before
+ * the close is missed. A term_busy command taking its own snapshot (pane_pids + sweep_procs) would
+ * not be.
+ */
+export declare function runningIn(ids: string[]): Promise<string[]>;
 /**
  * Size a pane's PTY, and every view of it, to the SMALLER of those views.
  *
@@ -431,6 +514,12 @@ export declare function sendInput(paneId: string, text: string): void;
  * layout and re-fires the observer that called us. Measuring first and resizing once — only when
  * the size actually differs — means the observer's next pass finds nothing to do and it settles.
  */
+/**
+ * The terminals drawn in `doc` take its window's scale again: its window moved onto a monitor of
+ * other scaling (a floating window reopened where it was, or dragged there). The same hand-over
+ * as a move between windows (see attach).
+ */
+export declare function rebindTerminals(doc: Document): void;
 export declare function refit(id: string): void;
 /**
  * Clear the screen, the way the shell expects.

package/types/core/windows.d.ts

@@ -0,0 +1,52 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+type Cleanup = void | (() => void);
+type Hook = (win: Window) => Cleanup;
+/** Every Deck window: the main one, then each floating one. */
+export declare const allWindows: () => Window[];
+/**
+ * A Deck window's Tauri label: "main", or a floating window's (floatwin.rs). A floating window is
+ * only registered here once its label exists, so every hook can rely on it.
+ */
+export declare function windowLabel(w: Window): string;
+/**
+ * Whether `x` is an element, in any Deck window. Not `instanceof Element`: an element in a
+ * floating window is an instance of THAT window's Element, so the main window's check is false.
+ */
+export declare function isElement(x: unknown): x is Element;
+/**
+ * A ResizeObserver from the window `el` is drawn in. One made by the main window watches an element
+ * in a floating window only when the main window next draws, so a terminal opened in a float that
+ * waited for its size could sit blank for seconds.
+ */
+export declare function resizeObserverFor(el: Element, cb: ResizeObserverCallback): ResizeObserver;
+/** The window an element is drawn in: the main one, or a floating window's. */
+export declare function winOf(el: Element | null | undefined): Window;
+/**
+ * The Deck window the user is in: the one they last clicked, typed or moved focus in. Not
+ * document.hasFocus() alone: with a floating window in front, the main window's document still
+ * says it has focus too (WebView2, for a popup it opened), so the first match was always main.
+ */
+export declare function activeWindow(): Window;
+/** What has focus in the window the user is in: what `document.activeElement` means in one window. */
+export declare function activeElement(): Element | null;
+/** Run `fn` for every Deck window, now and as floats open; what it returns runs when that window goes, or on the returned unsubscribe. */
+export declare function onEachWindow(fn: Hook): () => void;
+/** A floating window opened (floatwin.ts), its label known: every hook runs for it. */
+export declare function addWindow(win: Window): void;
+/** A floating window is going: what each hook installed in it is undone. */
+export declare function removeWindow(win: Window): void;
+/**
+ * Listen on every Deck window (or every window's document), now and as floats open; returns the
+ * unsubscribe. For what closes a menu or a dialog wherever the user is: Escape, a click outside.
+ */
+export declare function onAll<K extends keyof WindowEventMap>(type: K, fn: (e: WindowEventMap[K]) => void, opts?: boolean | AddEventListenerOptions, on?: "window" | "document"): () => void;
+/**
+ * Make the main realm's `navigator.clipboard` work from every Deck window. The browser refuses a
+ * clipboard call from a document that does not have focus ("Document is not focused"), and the
+ * realm's clipboard is the MAIN window's: while the user works in a floating window, every copy and
+ * paste failed, a terminal's Ctrl+C clearing the selection with nothing copied. Each call now goes
+ * to the clipboard of the window the user is in, which is main's own when that is where they are.
+ * Installed once, before plugins load, so their copies and pastes get it too.
+ */
+export declare function routeClipboard(): void;
+export {};

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

@@ -13,6 +13,12 @@ export declare function fileUri(path: string): monaco.Uri;
 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;
+/**
+ * Put `value` into `m` as the one edit between their common start and end, rather than replacing
+ * the whole text: a cursor outside the change stays where it is. A whole-text replace (setValue, or
+ * an edit over the full range) moved every cursor to the top of the file, mid-typing.
+ */
+export declare function replaceText(m: monaco.editor.ITextModel, value: string): void;
 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;