deck-plugin-sdk 1.1.0 → 1.2.0

package/package.json

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

package/shim/p2p.d.ts

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

package/shim/p2p.js

@@ -0,0 +1,15 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's live connections to other Decks. 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. One transport for every plugin, so a fix to it reaches all of them.
+const t = () => {
+  const x = window.__deck?.p2p;
+  if (!x) throw new Error("window.__deck.p2p is missing — this plugin only runs inside Deck");
+  return x;
+};
+
+export const cleanCode = (...a) => t().cleanCode(...a);
+export const newCode = (...a) => t().newCode(...a);
+export const selfId = (...a) => t().selfId(...a);
+export const share = (...a) => t().share(...a);

package/shim/settings.d.ts

@@ -1,5 +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 { useSettings, getSettings, saveSettings, userName } from "../types/core/settingsstore";
 export type { Settings } from "../types/core/bridge";

package/shim/settings.js

@@ -11,3 +11,6 @@ const s = () => {
 export const useSettings = (...a) => s().use(...a);
 export const getSettings = (...a) => s().get(...a);
 export const saveSettings = (...a) => s().save(...a);
+// What to call the user (needs a Deck newer than 1.1): the name set in Settings, else their Google or Windows
+// account's. For a plugin that shows the user to someone else.
+export const userName = (...a) => s().userName(...a);

package/shim/terminals.d.ts

@@ -1,4 +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.
+// Deck's real types, so a plugin is checked against the actual shape.
 export * from "../types/core/terminals";

package/template/plugin.json

@@ -1,8 +1,9 @@
-{
-  "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.17.0"
-}
+{
+  "id": "__ID__",
+  "name": "__NAME__",
+  "description": "One line on what this is for, shown under its name in Settings.",
+  "icon": "Sparkles",
+  "color": "#a78bfa",
+  "version": "0.1.0",
+  "minDeck": "0.17.0"
+}

package/types/components/ContextMenu.d.ts

@@ -28,7 +28,7 @@ export interface MenuItem {
     checked?: boolean;
 }
 export type MenuEntry = MenuItem | "sep";
-export declare function ContextMenu({ x, y, items, alignRight, onClose, onReorder, flipAt }: {
+export declare function ContextMenu({ x, y, items, alignRight, onClose, onReorder, flipAt, up }: {
     x: number;
     y: number;
     items: MenuEntry[];
@@ -36,6 +36,8 @@ export declare function ContextMenu({ x, y, items, alignRight, onClose, onReorde
     onClose: () => void;
     /** A submenu flips around its parent row's LEFT edge, not the point it opened at. */
     flipAt?: number;
+    /** Open upward from (x, y) when it fits: a menu from a bottom bar, above the bar's buttons. */
+    up?: boolean;
     /** Called with (draggedId, newIndexAmongDraggableRows) after a drag-sort. */
     onReorder?: (id: string, toIndex: number) => void;
 }): import("react").ReactPortal;

package/types/components/menuplace.d.ts

@@ -27,4 +27,10 @@ export declare function place(x: number, y: number, width: number, height: numbe
  *
  * Left out by a menu raised at a cursor, which has no width and so flips around itself.
  */
-flipAt?: number): Placement;
+flipAt?: number, 
+/**
+ * Open upward from (x, y) whenever it fits there. For a menu raised from a button in a bottom
+ * bar: opening downward fits too (the window's edge is further down), and then covers the very
+ * buttons the menu is about.
+ */
+up?: boolean): Placement;

package/types/core/bridge.d.ts

@@ -76,6 +76,12 @@ 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>;

package/types/core/lsp.d.ts

@@ -1,190 +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;
-    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 {};
+// 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 {};

package/types/core/p2p.d.ts

@@ -0,0 +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;

package/types/core/settingsstore.d.ts

@@ -13,4 +13,5 @@ export declare function publishSettings(s: Settings): void;
 export declare function saveSettings(next: Settings): 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;