deck-plugin-sdk 0.15.1

package/README.md

@@ -0,0 +1,77 @@
+# deck-plugin-sdk
+
+Build a plugin for [Deck](https://deck.hasan-zarif.com), outside Deck's own repository.
+
+```sh
+npm create deck-plugin my-thing
+cd my-thing
+npm run dev            # build, and rebuild as you edit
+npm run install-local  # copy it into Deck, which loads it without a restart
+```
+
+## What a plugin is
+
+A folder with a `plugin.json` and a built `plugin.js`, read from
+`%APPDATA%\Deck\plugins\<id>\` when Deck starts. It becomes a tab, or a readout in the footer,
+or a panel, or commands in the palette — `plugins/API.md` in the Deck repository lists every
+slot a plugin can fill. One is enough.
+
+Your sources import `react`, `lucide-react` and the shim modules as ordinary code does. At run
+time those resolve to **Deck's** copies, handed over on `window.__deck`. For React that is not
+an optimisation but a requirement: two Reacts in one tree break hooks.
+
+## Commands
+
+| | |
+|---|---|
+| `deck-plugin build` | bundle `src/` into `plugin.js` |
+| `deck-plugin dev` | the same, rebuilt whenever a source changes |
+| `deck-plugin check` | validate `plugin.json` without building |
+| `deck-plugin install` | build, then copy into Deck's plugins folder |
+
+`install` prefers `%APPDATA%\Deck-Dev` when it exists, since anyone writing a plugin is probably
+running a debug build beside the installed one.
+
+## What you can import
+
+```ts
+import { configRead, configWrite } from "../shim/bridge.js";   // Deck's Tauri commands
+import { listen } from "../shim/event.js";                     // Deck's event bus
+import { getSettings } from "../shim/settings.js";             // Deck's settings store
+import { Field, GhostButton } from "../shim/ui.js";            // Deck's form controls
+import { getLayout } from "../shim/terminals.js";              // the terminal layout
+import { monaco } from "../shim/monaco.js";                    // the editor
+```
+
+`shim/` and `types/` are written by the build. They are not yours to edit and belong in
+`.gitignore` — the template already ignores them.
+
+The types are generated from Deck's own source, so what your editor tells you is what Deck
+actually exposes rather than a hand-written approximation that has drifted.
+
+## What a plugin cannot do
+
+Add native capability. Every Tauri command is compiled into Deck, so a plugin calls what already
+exists. Anything needing new Rust belongs in Deck itself.
+
+## What a plugin CAN do, which is worth saying plainly
+
+**Everything Deck can.** A plugin runs inside Deck with the whole bridge: every Tauri command,
+the config directory, the filesystem, the terminal, a Google access token if one is connected.
+There is no sandbox and no permission prompt.
+
+That is a deliberate position rather than an oversight — a plugin is code you chose to run, like
+a VS Code extension or a shell script. It is also why the plugin registry is curated rather than
+open: an entry exists there because it was reviewed, and installing a plugin from anywhere else
+is the same decision as running any other program.
+
+## Versions
+
+The SDK's major and minor track Deck's, so an SDK 0.15 builds plugins for Deck 0.15. Declare the
+oldest Deck you work with as `minDeck` in `plugin.json`; Deck refuses to load a plugin that
+needs a newer one, with a sentence rather than an error from inside your module.
+
+## Publishing
+
+A plugin is published by being listed in Deck's registry, which points at a release in your own
+repository. Until that is open to submissions, ask.

package/bin/deck-plugin.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+// The Deck plugin CLI.
+//
+//   deck-plugin build          bundle src/ into plugin.js
+//   deck-plugin dev            rebuild whenever a source changes
+//   deck-plugin check          validate plugin.json without building
+//   deck-plugin install        copy the built plugin into Deck's plugins folder
+//
+// Run from a plugin's own directory.
+import { watch } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { buildPlugin } from "../build-plugin.mjs";
+
+const [cmd = "build"] = process.argv.slice(2);
+const dir = process.cwd();
+
+const die = (msg) => { console.error(msg); process.exit(1); };
+
+/**
+ * What Deck will refuse at install time, refused here instead.
+ *
+ * Every rule is one Deck's loader or install_from_registry applies — the id charset especially,
+ * because the id becomes a config key and a path component. Finding out here costs a second;
+ * finding out from a failed install costs a round trip.
+ */
+function check() {
+  const p = join(dir, "plugin.json");
+  if (!existsSync(p)) die("no plugin.json here — is this a plugin directory?");
+
+  let manifest;
+  try { manifest = JSON.parse(readFileSync(p, "utf8")); }
+  catch (e) { die(`plugin.json is not valid JSON: ${e.message}`); }
+
+  const id = (manifest.id ?? "").trim();
+  if (!id) die("plugin.json has no id");
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(id)) {
+    die(`id "${id}" must be letters, digits and dashes, starting with a letter or digit`);
+  }
+  if (!existsSync(join(dir, "src", "plugin.tsx"))) {
+    die("no src/plugin.tsx — that is the entry point");
+  }
+
+  // Not fatal, but worth saying: the registry's plugin page renders a README, and a published
+  // plugin without one gets an empty page.
+  const warn = [];
+  if (!manifest.version) warn.push("no version — Settings shows one, and the registry orders by it");
+  if (!manifest.description) warn.push("no description — the row says only a name");
+  if (!existsSync(join(dir, "README.md"))) warn.push("no README.md — publishing needs one");
+
+  console.log(`${manifest.name ?? id} ${manifest.version ?? ""}`.trim());
+  for (const w of warn) console.log(`  note: ${w}`);
+  return manifest;
+}
+
+/** Where Deck reads plugins from on this machine. */
+function pluginsDir() {
+  const appData = process.env.APPDATA;
+  if (!appData) die("APPDATA is not set — this command is for Windows, where Deck runs");
+  // Deck-Dev is the debug build's directory; prefer it when it exists, since someone building a
+  // plugin is almost certainly running a dev build beside it.
+  const dev = join(appData, "Deck-Dev", "plugins");
+  return existsSync(dev) ? dev : join(appData, "Deck", "plugins");
+}
+
+switch (cmd) {
+  case "check": {
+    check();
+    break;
+  }
+
+  case "build": {
+    const manifest = check();
+    await buildPlugin(dir);
+    console.log(`built ${manifest.id} -> plugin.js`);
+    break;
+  }
+
+  case "install": {
+    const manifest = check();
+    await buildPlugin(dir);
+    const dest = join(pluginsDir(), manifest.id);
+    mkdirSync(dest, { recursive: true });
+    for (const f of ["plugin.json", "plugin.js", "mcp.js"]) {
+      if (existsSync(join(dir, f))) cpSync(join(dir, f), join(dest, f));
+    }
+    console.log(`installed ${manifest.id} -> ${dest}`);
+    console.log("Deck watches that folder, so it is loaded already — no restart.");
+    break;
+  }
+
+  case "dev": {
+    check();
+    let building = false;
+    let again = false;
+    const once = async () => {
+      if (building) { again = true; return; }
+      building = true;
+      try { await buildPlugin(dir); console.log(`rebuilt at ${new Date().toLocaleTimeString()}`); }
+      catch (e) { console.error(e.message); }
+      building = false;
+      if (again) { again = false; void once(); }
+    };
+    await once();
+    // Debounced: an editor writing a file emits several events, and each would start a build.
+    let timer;
+    watch(join(dir, "src"), { recursive: true }, () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => void once(), 120);
+    });
+    console.log("watching src/ — ctrl+c to stop");
+    break;
+  }
+
+  default:
+    die(`unknown command "${cmd}" — try build, dev, check or install`);
+}

package/build-plugin.mjs

@@ -0,0 +1,143 @@
+// Build a Deck plugin: TSX sources -> one plugin.js Deck can import.
+//
+// The same build Deck's own plugins get, with one difference: the shim is shipped with this
+// package rather than generated, because generating it needs Deck's TypeScript sources and the
+// point of this package is that you do not have them.
+//
+// Why a plugin wants a build step at all: JSX, and ordinary imports across as many files as you
+// like. It is not rebuilding Deck — it is what a VS Code extension does.
+//
+// The shim is the whole trick. Deck hands React, its bridge, `listen`, its icons and its
+// animation library over on `window.__deck`, and esbuild resolves those module names to files
+// that read from there. So your sources import "react" as normal code does, and at run time get
+// DECK'S React — which is not an optimisation but a requirement, since two Reacts in one tree
+// break hooks.
+import { build } from "esbuild";
+import { cpSync, existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const sdk = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+/** The module names a plugin may import, and the shipped file each resolves to. */
+function shimMap(shimDir) {
+  return {
+    react: join(shimDir, "react.js"),
+    "deckreact/jsx-runtime": join(shimDir, "jsx-runtime.js"),
+    "@tauri-apps/api/event": join(shimDir, "event.js"),
+    "lucide-react": join(shimDir, "icons.js"),
+    "framer-motion": join(shimDir, "motion.js"),
+  };
+}
+
+/**
+ * Build the plugin in `dir`.
+ *
+ * The shim is copied in rather than imported from node_modules, because a plugin's sources refer
+ * to it by relative path (`../shim/bridge.js`) and that has to resolve on disk. Copied on every
+ * build so updating the SDK updates the shim, which is the behaviour someone upgrading expects.
+ */
+export async function buildPlugin(dir, { entry = "plugin.tsx" } = {}) {
+  const manifestPath = join(dir, "plugin.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error(`no plugin.json in ${dir}`);
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+  const shimDir = join(dir, "shim");
+  rmSync(shimDir, { recursive: true, force: true });
+  cpSync(join(sdk, "shim"), shimDir, { recursive: true });
+  // The declarations the shim's .d.ts files point at, as ../types/. Copied beside it for the
+  // same reason: a relative reference has to find something.
+  const typesDir = join(dir, "types");
+  rmSync(typesDir, { recursive: true, force: true });
+  cpSync(join(sdk, "types"), typesDir, { recursive: true });
+
+  // ---- icons and animation, generated per plugin ----
+  //
+  // These two cannot be shipped pre-generated like the rest of the shim. They name only the
+  // exports THIS plugin imports, on purpose: re-exporting the whole package goes through a
+  // module esbuild cannot see into, which defeats tree-shaking — doing that with lucide took a
+  // bundle from 403kb to 640kb, larger than just bundling it.
+  //
+  // Nothing about this needs Deck's source, only the plugin's own and the real package, so it
+  // runs here the same way it runs inside the Deck repository.
+  const sources = readdirSync(join(dir, "src"), { recursive: true })
+    .filter((f) => typeof f === "string" && /\.tsx?$/.test(f))
+    .map((f) => readFileSync(join(dir, "src", f), "utf8"));
+
+  for (const [pkg, file, global] of [
+    ["lucide-react", "icons.js", "icons"],
+    ["framer-motion", "motion.js", "motion"],
+  ]) {
+    const re = new RegExp(String.raw`import\s*\{([^}]*)\}\s*from\s*"${pkg}"`, "g");
+    const names = [...new Set(sources.flatMap((src) => [...src.matchAll(re)]
+      .flatMap((m) => m[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0]).filter(Boolean))))].sort();
+
+    // Checked against the real package, so a typo fails here rather than as a blank icon at run
+    // time. Only loaded when something is actually imported from it, since framer-motion is an
+    // optional peer dependency.
+    if (names.length) {
+      let real;
+      try { real = require(pkg); }
+      catch { throw new Error(`this plugin imports from "${pkg}" — run: npm i ${pkg}`); }
+      for (const n of names) if (!(n in real)) throw new Error(`${pkg} has no export "${n}"`);
+    }
+
+    writeFileSync(join(shimDir, file), `// GENERATED by the Deck plugin build — do not edit.
+//
+// Deck's ${pkg}, so this plugin does not bundle its own copy. Only the names this plugin
+// imports: naming every export would defeat tree-shaking and make the bundle larger.
+const __src = window.__deck.${global};
+${names.map((n) => `export const ${n} = __src.${n};`).join("\n")}
+`);
+  }
+
+  const shims = shimMap(shimDir);
+
+  await build({
+    entryPoints: [join(dir, "src", entry)],
+    outfile: join(dir, "plugin.js"),
+    bundle: true,
+    format: "esm",
+    target: "es2022",
+    // Nobody reads a plugin bundle; it is loaded by one import() at startup.
+    minify: true,
+    jsx: "automatic",
+    // React comes from Deck, so the automatic runtime must import from the shim rather than a
+    // "react/jsx-runtime" that does not exist here.
+    jsxImportSource: "deckreact",
+    // A .wasm import becomes a Uint8Array inlined in the bundle rather than a sidecar file. A
+    // plugin is installed as plugin.json + plugin.js, so a file beside them would never arrive.
+    loader: { ".wasm": "binary" },
+    // A resolve plugin rather than esbuild's `alias`, which maps package to package while these
+    // point at single files.
+    plugins: [{
+      name: "deck-runtime",
+      setup(b) {
+        const filter = new RegExp(`^(${Object.keys(shims)
+          .map((k) => k.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")})$`);
+        b.onResolve({ filter }, (a) => ({ path: shims[a.path] }));
+      },
+    }],
+    logLevel: "info",
+  });
+
+  // Optional: only a plugin that brings agent-facing tools has one. Built for node, because the
+  // MCP server runs outside the webview.
+  if (existsSync(join(dir, "src", "mcp.ts"))) {
+    await build({
+      entryPoints: [join(dir, "src", "mcp.ts")],
+      outfile: join(dir, "mcp.js"),
+      platform: "node",
+      format: "esm",
+      target: "node18",
+      bundle: true,
+      logLevel: "info",
+    });
+  }
+
+  return manifest;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "deck-plugin-sdk",
+  "version": "0.15.1",
+  "description": "Build a plugin for Deck, outside the Deck repository.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "deck-plugin": "bin/deck-plugin.mjs"
+  },
+  "exports": {
+    "./build": "./build-plugin.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "shim",
+    "types",
+    "template",
+    "build-plugin.mjs",
+    "README.md"
+  ],
+  "dependencies": {
+    "esbuild": "^0.25.0"
+  },
+  "peerDependencies": {
+    "@types/react": "^19.0.0",
+    "framer-motion": "^13.0.0",
+    "lucide-react": "^1.0.0",
+    "monaco-editor": "^0.56.0",
+    "react": "^19.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "framer-motion": { "optional": true },
+    "monaco-editor": { "optional": true },
+    "typescript": { "optional": true }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": ["deck", "plugin", "sdk"]
+}

package/shim/bridge.d.ts

@@ -0,0 +1,5 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's own bridge types, so a plugin is typechecked against what Deck actually exposes rather
+// than against `any`.
+export * from "../types/core/bridge";

package/shim/bridge.js

@@ -0,0 +1,196 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Deck's bridge. Everything resolves at USE time, never at import time: a plugin module is
+// evaluated during loadPlugins, and a reference copied out then would capture a half-built
+// object. Functions forward their arguments; plain values are proxied.
+const b = () => {
+  const x = window.__deck?.bridge;
+  if (!x) throw new Error("window.__deck.bridge is missing — this plugin only runs inside Deck");
+  return x;
+};
+
+export const askAssistant = (...a) => b().askAssistant(...a);
+export const calendarCached = (...a) => b().calendarCached(...a);
+export const calendarRefresh = (...a) => b().calendarRefresh(...a);
+export const claudePlanLimits = (...a) => b().claudePlanLimits(...a);
+export const claudeUsage = (...a) => b().claudeUsage(...a);
+export const clearWallpaper = (...a) => b().clearWallpaper(...a);
+export const closeApp = (...a) => b().closeApp(...a);
+export const configRead = (...a) => b().configRead(...a);
+export const configWrite = (...a) => b().configWrite(...a);
+export const convertFileSrc = (...a) => b().convertFileSrc(...a);
+export const dbConnect = (...a) => b().dbConnect(...a);
+export const dbDisconnect = (...a) => b().dbDisconnect(...a);
+export const dbQuery = (...a) => b().dbQuery(...a);
+export const dbSchema = (...a) => b().dbSchema(...a);
+export const defaultDownloadDir = (...a) => b().defaultDownloadDir(...a);
+export const deleteIconPack = (...a) => b().deleteIconPack(...a);
+export const dirsDownload = (...a) => b().dirsDownload(...a);
+export const exec = (...a) => b().exec(...a);
+export const footerOrder = (...a) => b().footerOrder(...a);
+export const fsCopy = (...a) => b().fsCopy(...a);
+export const fsCreateDir = (...a) => b().fsCreateDir(...a);
+export const fsCreateFile = (...a) => b().fsCreateFile(...a);
+export const fsDelete = (...a) => b().fsDelete(...a);
+export const fsHomeDir = (...a) => b().fsHomeDir(...a);
+export const fsList = (...a) => b().fsList(...a);
+export const fsMove = (...a) => b().fsMove(...a);
+export const fsOpen = (...a) => b().fsOpen(...a);
+export const fsRead = (...a) => b().fsRead(...a);
+export const fsReadBytes = (...a) => b().fsReadBytes(...a);
+export const fsRename = (...a) => b().fsRename(...a);
+export const fsReplace = (...a) => b().fsReplace(...a);
+export const fsReveal = (...a) => b().fsReveal(...a);
+export const fsSaveUnique = (...a) => b().fsSaveUnique(...a);
+export const fsSearch = (...a) => b().fsSearch(...a);
+export const fsSize = (...a) => b().fsSize(...a);
+export const fsWrite = (...a) => b().fsWrite(...a);
+export const fsWriteBytes = (...a) => b().fsWriteBytes(...a);
+export const getAutostart = (...a) => b().getAutostart(...a);
+export const getVaultRoot = (...a) => b().getVaultRoot(...a);
+export const gitAbortOp = (...a) => b().gitAbortOp(...a);
+export const gitAiCommitMsg = (...a) => b().gitAiCommitMsg(...a);
+export const gitBlameLine = (...a) => b().gitBlameLine(...a);
+export const gitBranchAt = (...a) => b().gitBranchAt(...a);
+export const gitBranchDelete = (...a) => b().gitBranchDelete(...a);
+export const gitBranchDeleteRemote = (...a) => b().gitBranchDeleteRemote(...a);
+export const gitBranches = (...a) => b().gitBranches(...a);
+export const gitCheckout = (...a) => b().gitCheckout(...a);
+export const gitCheckoutDetach = (...a) => b().gitCheckoutDetach(...a);
+export const gitCheckoutNew = (...a) => b().gitCheckoutNew(...a);
+export const gitCheckoutTrack = (...a) => b().gitCheckoutTrack(...a);
+export const gitCherryPick = (...a) => b().gitCherryPick(...a);
+export const gitCommit = (...a) => b().gitCommit(...a);
+export const gitCommitAmend = (...a) => b().gitCommitAmend(...a);
+export const gitCommitFiles = (...a) => b().gitCommitFiles(...a);
+export const gitDiscard = (...a) => b().gitDiscard(...a);
+export const gitFetch = (...a) => b().gitFetch(...a);
+export const gitFileBytes = (...a) => b().gitFileBytes(...a);
+export const gitFileDiff = (...a) => b().gitFileDiff(...a);
+export const gitHeadFile = (...a) => b().gitHeadFile(...a);
+export const gitIndexFile = (...a) => b().gitIndexFile(...a);
+export const gitInfo = (...a) => b().gitInfo(...a);
+export const gitLogGraph = (...a) => b().gitLogGraph(...a);
+export const gitMerge = (...a) => b().gitMerge(...a);
+export const gitPendingOp = (...a) => b().gitPendingOp(...a);
+export const gitPull = (...a) => b().gitPull(...a);
+export const gitPullRebase = (...a) => b().gitPullRebase(...a);
+export const gitPush = (...a) => b().gitPush(...a);
+export const gitPushBranch = (...a) => b().gitPushBranch(...a);
+export const gitRefs = (...a) => b().gitRefs(...a);
+export const gitRemotes = (...a) => b().gitRemotes(...a);
+export const gitResetTo = (...a) => b().gitResetTo(...a);
+export const gitRevert = (...a) => b().gitRevert(...a);
+export const gitShowFile = (...a) => b().gitShowFile(...a);
+export const gitStage = (...a) => b().gitStage(...a);
+export const gitStageContent = (...a) => b().gitStageContent(...a);
+export const gitStash = (...a) => b().gitStash(...a);
+export const gitStashApply = (...a) => b().gitStashApply(...a);
+export const gitStashClear = (...a) => b().gitStashClear(...a);
+export const gitStashDrop = (...a) => b().gitStashDrop(...a);
+export const gitStashList = (...a) => b().gitStashList(...a);
+export const gitStashPop = (...a) => b().gitStashPop(...a);
+export const gitStashShow = (...a) => b().gitStashShow(...a);
+export const gitStatus = (...a) => b().gitStatus(...a);
+export const gitTag = (...a) => b().gitTag(...a);
+export const gitTagDelete = (...a) => b().gitTagDelete(...a);
+export const gitTagDeleteRemote = (...a) => b().gitTagDeleteRemote(...a);
+export const gitTagPush = (...a) => b().gitTagPush(...a);
+export const gitUndoCommit = (...a) => b().gitUndoCommit(...a);
+export const gitUnstage = (...a) => b().gitUnstage(...a);
+export const googleAccount = (...a) => b().googleAccount(...a);
+export const googleSignIn = (...a) => b().googleSignIn(...a);
+export const googleSignOut = (...a) => b().googleSignOut(...a);
+export const googleToken = (...a) => b().googleToken(...a);
+export const historyClear = (...a) => b().historyClear(...a);
+export const historyDelete = (...a) => b().historyDelete(...a);
+export const httpSend = (...a) => b().httpSend(...a);
+export const importIconPack = (...a) => b().importIconPack(...a);
+export const installClaudeHooks = (...a) => b().installClaudeHooks(...a);
+export const installFromRegistry = (...a) => b().installFromRegistry(...a);
+export const installPlugin = (...a) => b().installPlugin(...a);
+export const isFullscreen = (...a) => b().isFullscreen(...a);
+export const jiraCached = (...a) => b().jiraCached(...a);
+export const jiraRefresh = (...a) => b().jiraRefresh(...a);
+export const languagesDir = (...a) => b().languagesDir(...a);
+export const launchFiles = (...a) => b().launchFiles(...a);
+export const listApps = (...a) => b().listApps(...a);
+export const listInstalled = (...a) => b().listInstalled(...a);
+export const mailCached = (...a) => b().mailCached(...a);
+export const mailRefresh = (...a) => b().mailRefresh(...a);
+export const mediaSetNowPlaying = (...a) => b().mediaSetNowPlaying(...a);
+export const mediaSetPlayback = (...a) => b().mediaSetPlayback(...a);
+export const memUsage = (...a) => b().memUsage(...a);
+export const notesDelete = (...a) => b().notesDelete(...a);
+export const notesList = (...a) => b().notesList(...a);
+export const notesRead = (...a) => b().notesRead(...a);
+export const notesRename = (...a) => b().notesRename(...a);
+export const notesScope = (...a) => b().notesScope(...a);
+export const notesWrite = (...a) => b().notesWrite(...a);
+export const notifyOs = (...a) => b().notifyOs(...a);
+export const openApp = (...a) => b().openApp(...a);
+export const openExternal = (...a) => b().openExternal(...a);
+export const openFile = (...a) => b().openFile(...a);
+export const pickAnyFile = (...a) => b().pickAnyFile(...a);
+export const pickExe = (...a) => b().pickExe(...a);
+export const pickFile = (...a) => b().pickFile(...a);
+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 pluginsDir = (...a) => b().pluginsDir(...a);
+export const powerAction = (...a) => b().powerAction(...a);
+export const procKill = (...a) => b().procKill(...a);
+export const procStream = (...a) => b().procStream(...a);
+export const procWrite = (...a) => b().procWrite(...a);
+export const readDownloads = (...a) => b().readDownloads(...a);
+export const readIconPackTheme = (...a) => b().readIconPackTheme(...a);
+export const readLibrary = (...a) => b().readLibrary(...a);
+export const readMusicSuggestions = (...a) => b().readMusicSuggestions(...a);
+export const readMusicTaste = (...a) => b().readMusicTaste(...a);
+export const readTermLayout = (...a) => b().readTermLayout(...a);
+export const readTrackMeta = (...a) => b().readTrackMeta(...a);
+export const removeClaudeHooks = (...a) => b().removeClaudeHooks(...a);
+export const restartApp = (...a) => b().restartApp(...a);
+export const revealInFolder = (...a) => b().revealInFolder(...a);
+export const runScriptNow = (...a) => b().runScriptNow(...a);
+export const sessionList = (...a) => b().sessionList(...a);
+export const setAutostart = (...a) => b().setAutostart(...a);
+export const setVaultRoot = (...a) => b().setVaultRoot(...a);
+export const setWallpaper = (...a) => b().setWallpaper(...a);
+export const setupChecks = (...a) => b().setupChecks(...a);
+export const slackCached = (...a) => b().slackCached(...a);
+export const slackRefresh = (...a) => b().slackRefresh(...a);
+export const speakWithVoice = (...a) => b().speakWithVoice(...a);
+export const sshTunnelClose = (...a) => b().sshTunnelClose(...a);
+export const sshTunnelList = (...a) => b().sshTunnelList(...a);
+export const sshTunnelOpen = (...a) => b().sshTunnelOpen(...a);
+export const startupRead = (...a) => b().startupRead(...a);
+export const startupWrite = (...a) => b().startupWrite(...a);
+export const stopSpeaking = (...a) => b().stopSpeaking(...a);
+export const toggleFullscreen = (...a) => b().toggleFullscreen(...a);
+export const vaultDataRead = (...a) => b().vaultDataRead(...a);
+export const vaultDataWrite = (...a) => b().vaultDataWrite(...a);
+export const vaultRelativize = (...a) => b().vaultRelativize(...a);
+export const vaultResolve = (...a) => b().vaultResolve(...a);
+export const watchFiles = (...a) => b().watchFiles(...a);
+export const writeDownloads = (...a) => b().writeDownloads(...a);
+export const writeLibrary = (...a) => b().writeLibrary(...a);
+export const writeMusicTaste = (...a) => b().writeMusicTaste(...a);
+export const writeTermLayout = (...a) => b().writeTermLayout(...a);
+
+export const DEFAULT_SETTINGS = new Proxy({}, {
+  get: (_t, k) => b().DEFAULT_SETTINGS[k],
+  ownKeys: () => Reflect.ownKeys(b().DEFAULT_SETTINGS),
+  getOwnPropertyDescriptor: (_t, k) => ({ ...Object.getOwnPropertyDescriptor(b().DEFAULT_SETTINGS, k), configurable: true }),
+});
+export const EMPTY_LIBRARY = new Proxy({}, {
+  get: (_t, k) => b().EMPTY_LIBRARY[k],
+  ownKeys: () => Reflect.ownKeys(b().EMPTY_LIBRARY),
+  getOwnPropertyDescriptor: (_t, k) => ({ ...Object.getOwnPropertyDescriptor(b().EMPTY_LIBRARY, k), configurable: true }),
+});
+export const FOOTER_ITEMS = new Proxy({}, {
+  get: (_t, k) => b().FOOTER_ITEMS[k],
+  ownKeys: () => Reflect.ownKeys(b().FOOTER_ITEMS),
+  getOwnPropertyDescriptor: (_t, k) => ({ ...Object.getOwnPropertyDescriptor(b().FOOTER_ITEMS, k), configurable: true }),
+});

package/shim/event.d.ts

@@ -0,0 +1,5 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// Tauri's real event types, so `listen` and the unsubscribe it returns are typed.
+export { listen } from "@tauri-apps/api/event";
+export type { Event, EventCallback, UnlistenFn } from "@tauri-apps/api/event";

package/shim/event.js

@@ -0,0 +1,5 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// @tauri-apps/api/event. Only listen: a plugin subscribing to Deck's events is expected, one
+// emitting into them is not.
+export const listen = (event, handler) => window.__deck.listen(event, handler);

package/shim/jsx-runtime.js

@@ -0,0 +1,20 @@
+// GENERATED by sdk/gen-shim.mjs — do not edit.
+//
+// The automatic JSX runtime, backed by Deck's React. With jsx: "automatic", esbuild emits an
+// import of "<source>/jsx-runtime" per element, so that module has to exist and has to be
+// Deck's React. createElement covers jsx/jsxs/jsxDEV: the difference is a key argument and a
+// dev warning, neither of which changes what renders.
+const React = window.__deck.React;
+const make = (type, props, key) => {
+  const { children, ...rest } = props ?? {};
+  if (key !== undefined) rest.key = key;
+  return Array.isArray(children)
+    ? React.createElement(type, rest, ...children)
+    : children === undefined
+      ? React.createElement(type, rest)
+      : React.createElement(type, rest, children);
+};
+export const jsx = make;
+export const jsxs = make;
+export const jsxDEV = make;
+export const Fragment = React.Fragment;