deck-plugin-sdk 1.13.0 → 1.15.0

package/README.md

@@ -62,8 +62,22 @@ actually exposes rather than a hand-written approximation that has drifted.
 Any other npm package is `npm install` and import: the build bundles it into `plugin.js`, with the
 images, fonts and CSS it brings. Writing a plugin, in the Docs, says what cannot work that way.
 
-When the build needs more than that (a worker bundled into the plugin, a dependency's locales left
-out), export esbuild plugins from `deck-plugin.config.mjs` beside `plugin.json`:
+Two things a build often needs are settings, which the registry can still rebuild:
+
+- **A worker of your own:** `import code from "./job.worker.ts?worker"` bundles that file and what
+  it imports into one script and gives its text, to start with
+  `new Worker(URL.createObjectURL(new Blob([code])))`.
+- **Files a package brings that you never use** (a library's translations into every language):
+  regular expressions in `package.json`, matched against each file's path, and each match is
+  bundled empty:
+
+  ```json
+  "deckPlugin": { "leaveOut": ["/locales/(?!en-)[^/]+\\.js$"] }
+  ```
+
+When the build needs more than that, export esbuild plugins from `deck-plugin.config.mjs` beside
+`plugin.json`. The registry does not run your code, so it cannot rebuild a plugin that has one:
+it is listed as build not verified, and misses those points.
 
 ```js
 export const esbuildPlugins = [{ name: "my-step", setup(build) { /* ... */ } }];

package/bin/deck-plugin.mjs

@@ -13,6 +13,7 @@
 // Run from a plugin's own directory.
 import { watch } from "node:fs";
 import { cpSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { buildPlugin } from "../build-plugin.mjs";
 import { publish } from "../publish.mjs";
@@ -70,15 +71,27 @@ function check() {
  * writes to your real Deck ("main"), for when the plugin is done.
  */
 function pluginsDir(defaultTarget) {
-  const appData = process.env.APPDATA;
-  if (!appData) die("APPDATA is not set — this command is for Windows, where Deck runs");
   const target = targetFlag ?? defaultTarget;
   if (target !== "test" && target !== "main") die(`--target is "test" or "main", not "${target}"`);
-  return { target, dir: join(appData, target === "test" ? "Deck-Dev" : "Deck", "plugins") };
+  return { target, dir: join(configRoot(), target === "test" ? "Deck-Dev" : "Deck", "plugins") };
+}
+
+/** Where Deck keeps its folder, as its Rust side finds it: %APPDATA% on Windows, $XDG_CONFIG_HOME
+ *  or ~/.config on Linux, ~/Library/Application Support on macOS. */
+function configRoot() {
+  if (process.platform === "win32") return process.env.APPDATA || die("APPDATA is not set");
+  if (process.platform === "darwin") return join(homedir(), "Library", "Application Support");
+  return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
 }
 
 /** Copy the built plugin into a Deck's plugins folder. Deck watches it and reloads the plugin. */
 function copyInto(manifest, defaultTarget) {
+  // A plugin that lists the systems it runs on is not put into a Deck on any other, which would not
+  // load it anyway.
+  const here = { win32: "windows", darwin: "mac" }[process.platform] ?? "linux";
+  if (Array.isArray(manifest.platforms) && manifest.platforms.length && !manifest.platforms.includes(here)) {
+    die(`${manifest.id} runs on ${manifest.platforms.join(", ")} only (its plugin.json "platforms"), and this is ${here}`);
+  }
   const { target, dir: plugins } = pluginsDir(defaultTarget);
   const dest = join(plugins, manifest.id);
   mkdirSync(dest, { recursive: true });

package/build-plugin.mjs

@@ -17,7 +17,7 @@ import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, write
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { assetLoaders, fromPackage, packageCss, rawImports } from "./packages.mjs";
+import { assetLoaders, fromPackage, leaveOut, packageCss, rawImports, workerImports } from "./packages.mjs";
 
 const sdk = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -58,11 +58,15 @@ export async function buildPlugin(dir, { entry = "plugin.tsx" } = {}) {
   }
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
 
-  // A plugin that needs more from esbuild than this build gives (a worker bundled into it, a
-  // dependency's locales left out) exports `esbuildPlugins` from deck-plugin.config.mjs beside
-  // plugin.json. They run after Deck's own, so they never take over react or the shim.
+  // What a plugin needs beyond the plain build is a setting where it can be: `?worker` imports, and
+  // `"deckPlugin": { "leaveOut": [...] }` in package.json (packages.mjs). Those run none of the
+  // plugin's code, so the registry can rebuild it. Anything more exports `esbuildPlugins` from
+  // deck-plugin.config.mjs beside plugin.json, which runs after Deck's own, so it never takes over
+  // react or the shim, and which the registry will not run.
   const configPath = join(dir, "deck-plugin.config.mjs");
   const config = existsSync(configPath) ? await import(pathToFileURL(configPath).href) : {};
+  const pkgPath = join(dir, "package.json");
+  const settings = (existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf8")).deckPlugin : null) ?? {};
 
   const sources = readdirSync(join(dir, "src"), { recursive: true })
     .filter((f) => typeof f === "string" && /\.tsx?$/.test(f))
@@ -150,7 +154,7 @@ ${names.map((n) => `export const ${n} = __src.${n};`).join("\n")}
           .map((k) => k.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")})$`);
         b.onResolve({ filter }, (a) => (fromPackage(a, dir) ? undefined : { path: shims[a.path] }));
       },
-    }, rawImports, packageCss(manifest.id, dir), ...(config.esbuildPlugins ?? [])],
+    }, rawImports, workerImports, leaveOut(settings.leaveOut), packageCss(manifest.id, dir), ...(config.esbuildPlugins ?? [])],
     logLevel: "info",
   });
 

package/package.json

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

package/packages.mjs

@@ -105,3 +105,47 @@ export const rawImports = {
     b.onLoad({ filter: /.*/, namespace: "deck-raw" }, (args) => ({ contents: readFileSync(args.path), loader: args.pluginData?.as === "base64" ? "base64" : "text" }));
   },
 };
+
+/**
+ * `import code from "./x.worker.ts?worker"` bundles that file and what it imports into one script
+ * and gives its text, for a Worker started from a Blob URL: a plugin is one plugin.js, so the
+ * worker cannot be a file beside it. Only esbuild runs, as for the plugin itself.
+ */
+export const workerImports = {
+  name: "deck-worker",
+  setup(b) {
+    b.onResolve({ filter: /\?worker$/ }, async (args) => {
+      const r = await b.resolve(args.path.slice(0, -"?worker".length), { kind: args.kind, resolveDir: args.resolveDir, importer: args.importer });
+      if (r.errors.length) return { errors: r.errors };
+      return { path: r.path, namespace: "deck-worker" };
+    });
+    b.onLoad({ filter: /.*/, namespace: "deck-worker" }, async (args) => {
+      const out = await b.esbuild.build({ entryPoints: [args.path], bundle: true, write: false, format: "iife", target: "es2022", minify: true, metafile: true });
+      return { contents: out.outputFiles[0].text, loader: "text", watchFiles: Object.keys(out.metafile.inputs) };
+    });
+  },
+};
+
+/**
+ * `"deckPlugin": { "leaveOut": [...] }` in package.json: regular expressions, and a file whose path
+ * (with forward slashes) matches one is bundled as an empty module. For what a package bundles but
+ * the plugin never uses, such as a library's translations into every language. Matched on load
+ * rather than on import, so a file reached by a pattern import (`import(\`./locales/${l}.js\`)`) is
+ * left out too. A setting rather than code, so the registry can still rebuild the plugin.
+ */
+export function leaveOut(patterns = []) {
+  if (!Array.isArray(patterns) || patterns.some((p) => typeof p !== "string" || p.length > 200)) {
+    throw new Error('package.json\'s "deckPlugin.leaveOut" must be a list of regular expressions, each under 200 characters');
+  }
+  const res = patterns.map((p) => new RegExp(p));
+  return {
+    name: "deck-leave-out",
+    setup(b) {
+      if (!res.length) return;
+      b.onLoad({ filter: /.*/ }, (a) => {
+        const path = a.path.replace(/\\/g, "/");
+        return res.some((r) => r.test(path)) ? { contents: "export default {};", loader: "js" } : undefined;
+      });
+    },
+  };
+}

package/permissions.json

@@ -112,6 +112,7 @@
     "fsTrash": "files",
     "fsWrite": "files",
     "fsWriteBytes": "files",
+    "ghAvatar": "network",
     "ghPrLineComment": "network",
     "ghPrThreads": "network",
     "ghRun": "processes",
@@ -230,6 +231,7 @@
     "fsHomeDir",
     "getAutostart",
     "isFullscreen",
+    "isWindows",
     "languagesDir",
     "launchUrls",
     "mediaSetNowPlaying",
@@ -237,6 +239,7 @@
     "memUsage",
     "notifyOs",
     "openExternal",
+    "pathKey",
     "pickAnyFile",
     "pickExe",
     "pickFile",
@@ -244,8 +247,10 @@
     "pickImage",
     "pickSavePath",
     "pickScript",
+    "platform",
     "pluginsDir",
     "revealInFolder",
+    "samePath",
     "startupMarks",
     "toggleFullscreen"
   ]

package/publish.mjs

@@ -18,7 +18,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { checkAssets, checkIcon, checkId, checkLockfile, checkManifest, checkPermissions, fileFacts, ICON_FILE, points } from "./validate.mjs";
+import { checkAssets, checkIcon, checkId, checkLockfile, checkManifest, checkPermissions, checkPortable, fileFacts, ICON_FILE, points } from "./validate.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const REGISTRY = "deck-desktop/deck-registry";
@@ -83,6 +83,7 @@ export async function publish(dir, manifest, { dryRun, buildPlugin }) {
   const perms = checkPermissions(manifest.permissions, readFileSync(join(dir, "plugin.js"), "utf8"), table, manifest.id);
   errors.push(...perms.errors);
   notes.push(...perms.notes);
+  notes.push(...checkPortable(manifest, readFileSync(join(dir, "plugin.js"), "utf8")));
   if (errors.length) {
     for (const e of errors) console.error(`  ✗ ${e}`);
     process.exit(1);

package/shim/bridge.js

@@ -121,6 +121,7 @@ export const fsTrash = (...a) => b().fsTrash(...a);
 export const fsWrite = (...a) => b().fsWrite(...a);
 export const fsWriteBytes = (...a) => b().fsWriteBytes(...a);
 export const getAutostart = (...a) => b().getAutostart(...a);
+export const ghAvatar = (...a) => b().ghAvatar(...a);
 export const ghPrLineComment = (...a) => b().ghPrLineComment(...a);
 export const ghPrThreads = (...a) => b().ghPrThreads(...a);
 export const ghRun = (...a) => b().ghRun(...a);
@@ -160,6 +161,7 @@ export const installAgentMcp = (...a) => b().installAgentMcp(...a);
 export const installAgentSkills = (...a) => b().installAgentSkills(...a);
 export const installFromRegistry = (...a) => b().installFromRegistry(...a);
 export const isFullscreen = (...a) => b().isFullscreen(...a);
+export const isWindows = (...a) => b().isWindows(...a);
 export const languagesDir = (...a) => b().languagesDir(...a);
 export const launchFiles = (...a) => b().launchFiles(...a);
 export const launchUrls = (...a) => b().launchUrls(...a);
@@ -175,6 +177,7 @@ export const notifyOs = (...a) => b().notifyOs(...a);
 export const openExternal = (...a) => b().openExternal(...a);
 export const openFile = (...a) => b().openFile(...a);
 export const openTestDeck = (...a) => b().openTestDeck(...a);
+export const pathKey = (...a) => b().pathKey(...a);
 export const pickAnyFile = (...a) => b().pickAnyFile(...a);
 export const pickExe = (...a) => b().pickExe(...a);
 export const pickFile = (...a) => b().pickFile(...a);
@@ -182,6 +185,7 @@ export const pickFolder = (...a) => b().pickFolder(...a);
 export const pickImage = (...a) => b().pickImage(...a);
 export const pickSavePath = (...a) => b().pickSavePath(...a);
 export const pickScript = (...a) => b().pickScript(...a);
+export const platform = (...a) => b().platform(...a);
 export const pluginsDir = (...a) => b().pluginsDir(...a);
 export const procKill = (...a) => b().procKill(...a);
 export const procStream = (...a) => b().procStream(...a);
@@ -197,6 +201,7 @@ export const removeLanguage = (...a) => b().removeLanguage(...a);
 export const restartApp = (...a) => b().restartApp(...a);
 export const revealInFolder = (...a) => b().revealInFolder(...a);
 export const runScriptNow = (...a) => b().runScriptNow(...a);
+export const samePath = (...a) => b().samePath(...a);
 export const sessionList = (...a) => b().sessionList(...a);
 export const setAutostart = (...a) => b().setAutostart(...a);
 export const setDebugTargets = (...a) => b().setDebugTargets(...a);

package/shim/p2p.js

@@ -10,7 +10,7 @@ const t = () => {
   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);
+export const myTeamId = (...a) => t().myTeamId(...a);
+export const subscribeTeams = (...a) => t().subscribeTeams(...a);
+export const teamChannel = (...a) => t().teamChannel(...a);
+export const teamsView = (...a) => t().teamsView(...a);

package/template/plugin.json

@@ -5,6 +5,6 @@
   "icon": "Sparkles",
   "color": "#a78bfa",
   "version": "0.1.0",
-  "minDeck": "1.13.0",
+  "minDeck": "1.15.0",
   "permissions": []
 }

package/template/src/assets.d.ts

@@ -14,3 +14,5 @@ declare module "*.wasm" { const bytes: Uint8Array; export default bytes; }
 declare module "*?raw" { const text: string; export default text; }
 // `import data from "some/file?base64"`: any file's bytes, as a base64 string.
 declare module "*?base64" { const base64: string; export default base64; }
+// `import code from "./job.worker.ts?worker"`: that worker, bundled, as the text of a script.
+declare module "*?worker" { const code: string; export default code; }

package/types/core/app/p2p.d.ts

@@ -1,117 +1,3 @@
 // 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;
+export type { Json } from "./p2pshare";
+export { teamChannel, teamsView, subscribeTeams, myTeamId, type Member, type TeamView, type TeamChannel, type ChannelHandlers } from "./teams";

package/types/core/app/p2pshare.d.ts

@@ -0,0 +1,131 @@
+// 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;
+    /**
+     * The host: who is let in, decided here rather than by a knock. Asked for each Deck that says
+     * hello: true lets it straight in, false turns it away (no knock at all). For a team share
+     * (teams.ts): only a Deck checked as a current member of the team, so a code and password that
+     * reached anyone else, or a member removed since, let no one in.
+     */
+    admit?: (peer: string) => boolean;
+    /**
+     * A joiner: who may be the host. Without it, the first Deck that says it hosts is believed. For a
+     * team share: only the member who sent the invite.
+     */
+    trustHost?: (peer: string) => boolean;
+    /** The largest message taken from anyone, in bytes (12 MB unless set). */
+    maxBytes?: number;
+}
+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/app/platform.d.ts

@@ -0,0 +1,14 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+export type Platform = "windows" | "linux" | "mac";
+/** Which system Deck runs on. A function, as everything plugins reach through the bridge is. */
+export declare const platform: () => Platform;
+export declare const isWindows: () => boolean;
+/** Whether two paths name the same file: without regard to case on Windows, whose file system
+ *  ignores it, and exactly elsewhere, where `Readme.md` and `README.md` are two files. */
+export declare function samePath(a: string, b: string): boolean;
+/** A path as a key that `samePath` would match: lowercased on Windows only. */
+export declare function pathKey(p: string): string;
+/** The system's name, for words shown to the user. */
+export declare const osName: () => string;
+/** The menu item that shows a file in the system's file manager. */
+export declare const revealLabel: () => string;

package/types/core/app/settingsstore.d.ts

@@ -23,4 +23,6 @@ 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>;
+/** Told after every change to the settings, from anywhere (Settings, a file edited elsewhere). */
+export declare const subscribeSettings: (cb: () => void) => () => void;
 export declare function useSettings(): Settings;

package/types/core/app/teams.d.ts

@@ -0,0 +1,122 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { share, type Json, type RoomLike, type P2pShare } from "./p2pshare";
+export type Member = {
+    id: string;
+    pub: string;
+    name: string;
+};
+/** A team's members, as the owner signed them. */
+export type MemberList = {
+    team: string;
+    name: string;
+    owner: string;
+    ownerPub: string;
+    rev: number;
+    members: Member[];
+    sig: string; /** The owner ended the team. */
+    ended?: boolean;
+};
+/** What this Deck keeps for a team. The key is secret: it names and encrypts the room. */
+export type Team = {
+    id: string;
+    key: string;
+    list: MemberList; /** Each member's name as last heard from them: theirs to change. */
+    seen?: Record<string, string>; /** When this Deck heard the team was ended: kept as a tombstone until ENDED_DAYS after. */
+    endedAt?: number;
+};
+/** A team as the Teams page shows it. */
+export interface TeamView {
+    id: string;
+    name: string;
+    owner: boolean;
+    ownerId: string;
+    members: (Member & {
+        me: boolean;
+        online: boolean;
+    })[];
+}
+export interface TeamChannel<T> {
+    /** Send to every member online, or to one (`to`: a member id). Nothing goes to anyone else. */
+    send(msg: T, to?: string): Promise<void>;
+    /** The members connected and checked right now, this Deck not included. */
+    online(): Member[];
+    close(): void;
+}
+export interface ChannelHandlers<T> {
+    message: (msg: T, from: Member) => void;
+    /** A member connected and was checked: send them what they need to catch up. */
+    joined?: (m: Member) => void;
+    left?: (m: Member) => void;
+}
+/** Where teams keep things and how they reach the network: a seam, so the check runs without either. */
+export interface TeamDeps {
+    read(name: string): Promise<string>;
+    write(name: string, text: string): Promise<void>;
+    /** This Deck's name, as the others see it. */
+    name(): Promise<string>;
+    /** A team's room: Trystero's, or a fake one. */
+    room(key: string, id: string): RoomLike;
+    /** Told when this Deck's name may have changed (the settings changed). */
+    watchName(cb: () => void): void;
+    share: typeof share;
+}
+/** For the check: replace the storage, the name and the network. */
+export declare function _setTeamDeps(d: Partial<TeamDeps>): void;
+/** A short code for an identity, to read out and compare: whoever invites shows theirs, whoever joins sees it. */
+export declare const fingerprint: (id: string) => string;
+/** A member's id: the first half of the hash of their public key. */
+export declare function idOf(pub: string): Promise<string>;
+/** Whether a list is the owner's own: signed by them, for this team, with ids that match the keys. */
+export declare function validList(l: MemberList, ownerPub?: string): Promise<boolean>;
+/** A plugin's line to a team: its messages, only to and from checked members. */
+export declare function teamChannel<T extends Json>(teamId: string, app: string, on: ChannelHandlers<T>): TeamChannel<T>;
+export declare function teamsView(): TeamView[];
+export declare function subscribeTeams(fn: () => void): () => void;
+/** This Deck's member id. */
+export declare const myTeamId: () => Promise<string>;
+/** Start a team, with this Deck as its owner and only member. */
+export declare function createTeam(name: string): Promise<string>;
+/** The owner takes someone off the team. */
+export declare function removeMember(teamId: string, memberId: string): Promise<void>;
+/**
+ * Leave a team: this Deck forgets it, and the others still list it until the owner removes it. The
+ * owner leaving ends the team for everyone: a last signed list says so, sent to those online now
+ * and, through the tombstones, to the others when they come back.
+ */
+export declare function leaveTeam(teamId: string): Promise<void>;
+type InviteMsg = {
+    t: "join";
+    id: string;
+    pub: string;
+    name: string;
+} | {
+    t: "team";
+    team: Team;
+};
+/**
+ * The owner invites: a code to give someone, and a share where they knock and are let in, as a
+ * live share's people are (`share.allow`). Whoever is let in is added to the team and sent it.
+ */
+export declare function inviteToTeam(teamId: string): Promise<{
+    code: string;
+    share: P2pShare<InviteMsg>;
+    fingerprint: string;
+    joined: Promise<string>;
+}>;
+/**
+ * Join a team with the code its owner gave you: knock, and once let in, say who you are and take
+ * the team the owner sends. Resolves with the team's id.
+ */
+/** A team offered by an invite: who owns it, to compare, and keeping it. */
+export interface TeamOffer {
+    id: string;
+    name: string;
+    owner: string;
+    fingerprint: string;
+    keep: () => Promise<string>;
+}
+export declare function joinTeam(code: string): Promise<{
+    share: P2pShare<InviteMsg>;
+    done: Promise<TeamOffer>;
+}>;
+export {};

package/types/core/bridge.d.ts

@@ -672,6 +672,11 @@ export interface TrackMeta {
 }
 export declare const readTrackMeta: (paths: string[]) => Promise<TrackMeta[]>;
 export { convertFileSrc } from "@tauri-apps/api/core";
+export { platform } from "./app/platform";
+export { isWindows } from "./app/platform";
+export { samePath } from "./app/platform";
+export { pathKey } from "./app/platform";
+export type { Platform } from "./app/platform";
 /** Start a sign-in. Returns the consent URL to open in the browser. */
 export declare const googleSignIn: () => Promise<string>;
 /** A valid access token, refreshed if needed. Rejects when not connected. */
@@ -1077,6 +1082,8 @@ export declare const gitAiCommitMsg: (dir: string, command: string, args: string
 export declare const ghRun: (dir: string, args: string[]) => Promise<string>;
 /** Pull request N's review threads, as GitHub's GraphQL JSON (parsed by prs.ts parseThreads). */
 export declare const ghPrThreads: (dir: string, number: number) => Promise<string>;
+/** The GitHub profile picture's address of whoever commits as `email` in this repo, "" when none. */
+export declare const ghAvatar: (dir: string, email: string) => Promise<string>;
 /** Comment on one line of a PR's diff: side "RIGHT" is the new version, "LEFT" the old. */
 export declare const ghPrLineComment: (dir: string, number: number, commit: string, path: string, line: number, side: "LEFT" | "RIGHT", body: string) => Promise<string>;
 export declare const ghThreadReply: (dir: string, thread: string, body: string) => Promise<string>;
@@ -1084,8 +1091,8 @@ export declare const ghThreadResolve: (dir: string, thread: string, resolve: boo
 /** The GitLab CLI, `glab mr …` only. Rejects with "glab-missing" when glab is not installed. */
 export declare const glabRun: (dir: string, args: string[]) => Promise<string>;
 /**
- * One GitLab REST request about this repo's merge requests (`projects/:id/merge_requests…` or
- * `user`). `fields` go as strings; `json` values must be objects or arrays.
+ * One GitLab REST request about this repo's merge requests (`projects/:id/merge_requests…`, `user`,
+ * or `avatar?email=` for someone's picture). `fields` go as strings; `json` values must be objects or arrays.
  */
 export declare const glabApi: (dir: string, method: "GET" | "POST" | "PUT", path: string, fields?: [string, string][], json?: Record<string, object>) => Promise<string>;
 /** The files that differ between two revisions. */

package/types/core/browser/bookmarksources.d.ts

@@ -0,0 +1,9 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** A Chromium browser's bookmarks on this machine, one per profile that has any. */
+export interface BookmarkSource {
+    browser: string;
+    profile: string;
+    path: string;
+}
+/** Every profile of Chrome, Edge and Brave with a Bookmarks file. A browser not installed is no error. */
+export declare function findBookmarkSources(): Promise<BookmarkSource[]>;

package/types/core/browser/browser.d.ts

@@ -203,14 +203,8 @@ export declare function forgetDownload(key: string): void;
 export declare function clearDownloads(): void;
 export declare const browserBookmarks: () => Bookmarks;
 export declare function setBookmarks(next: Bookmarks): void;
-/** A Chromium browser's bookmarks on this machine, one per profile that has any. */
-export interface BookmarkSource {
-    browser: string;
-    profile: string;
-    path: string;
-}
-/** Every profile of Chrome, Edge and Brave with a Bookmarks file. A browser not installed is no error. */
-export declare function findBookmarkSources(): Promise<BookmarkSource[]>;
+import type { BookmarkSource } from "./bookmarksources";
+export { findBookmarkSources, type BookmarkSource } from "./bookmarksources";
 /** Import one source's bookmarks as a "From Chrome" folder in each root. Returns how many pages. */
 export declare function importBookmarks(src: BookmarkSource): Promise<number>;
 /** Every bookmark to a bookmarks HTML file, which any browser imports, and Deck too. How many pages. */

package/types/core/keys/keys.d.ts

@@ -89,10 +89,4 @@ export declare function toMonaco(chord: string, mods: {
     Shift: number;
     WinCtrl: number;
 }, codes: Record<string, number>): number | null;
-/**
- * Deck's built-in bindings.
- *
- * Plugin bindings are not here — they arrive at load time through the `keybindings` export and
- * are concatenated on, so a disabled plugin's chords leave the table with it.
- */
 export declare const DEFAULT_BINDINGS: readonly KeyBinding[];

package/types/core/workspaces/windows.d.ts

@@ -32,7 +32,7 @@ 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;
+export declare function addWindow(win: Window, label?: string): void;
 /** A floating window is going: what each hook installed in it is undone. */
 export declare function removeWindow(win: Window): void;
 /**

package/validate.mjs

@@ -44,6 +44,10 @@ export function checkManifest(m) {
   if (typeof m.version !== "string" || !SEMVER.test(m.version)) errors.push("`version` must be a version, such as \"1.0.0\"");
   if (typeof m.minDeck !== "string" || !SEMVER.test(m.minDeck)) errors.push("`minDeck` must say which Deck it needs, such as \"1.8.0\"");
   if (m.color !== undefined && !/^#[0-9a-f]{6}$/i.test(m.color)) errors.push("`color` must be #rrggbb");
+  // Where it runs: absent means every system. Deck will not load or install it on any other.
+  if (m.platforms !== undefined && (!Array.isArray(m.platforms) || !m.platforms.length || !m.platforms.every((p) => ["windows", "linux", "mac"].includes(p)))) {
+    errors.push("`platforms` lists the systems it runs on, from \"windows\", \"linux\" and \"mac\"; leave it out to run on all of them");
+  }
   if (typeof m.icon === "string" && m.icon.endsWith(".svg") && m.icon !== ICON_FILE) errors.push(`an icon of its own must be named ${ICON_FILE}`);
   return errors;
 }
@@ -152,6 +156,21 @@ export function checkPermissions(declared, bundle, table, id) {
   return { errors, notes, used: [...needs.keys()] };
 }
 
+/**
+ * Windows-only habits in a plugin that says it runs on Linux too (no "platforms", or a list naming
+ * "linux"): a path joined with a backslash, a program named with ".exe". Notes, not errors, and
+ * none for a bundle that asks isWindows(), which keeps a Windows branch beside a Linux one.
+ */
+export function checkPortable(manifest, bundle) {
+  const runs = Array.isArray(manifest.platforms) ? manifest.platforms : ["windows", "linux"];
+  if (!runs.includes("linux") || /\(\)\.isWindows\(|\bisWindows\(/.test(bundle)) return [];
+  const notes = [];
+  const joins = (bundle.match(/\}\\\\|["'`]\\\\["'`]/g) ?? []).length;
+  if (joins) notes.push(`It joins paths with a backslash (${joins} place${joins > 1 ? "s" : ""}), which on Linux is part of a file name: ask isWindows() from the bridge for the separator, or say "platforms": ["windows"] in plugin.json.`);
+  if (/\.exe["'`]/.test(bundle)) notes.push(`It names a program with ".exe", which Linux programs do not have: ask isWindows() from the bridge, or say "platforms": ["windows"] in plugin.json.`);
+  return notes;
+}
+
 // ---- points ----
 // A version's points: advice for whoever is choosing a plugin, never a gate (the checks above are
 // that). Worked out once when it is published, by the registry for a submission and by