@drift-beacon/plugin 0.1.0 → 0.2.0

package/dist/ui.js

@@ -1,23 +1,31 @@
-/**
- * The UI client: runs inside a plugin's iframe and talks to the Drift Beacon web app.
- *
- * ```ts
- * const ctx = await connect();
- * ctx.onDataChange(render);
- * ```
- */
 import { PluginError } from "./errors.js";
 import { Collection } from "./internal/collection.js";
+import { deepFreeze } from "./internal/freeze.js";
 import { jsonEqual } from "./internal/json-equal.js";
 import { WorkspaceModels } from "./internal/models.js";
+import { commandArgumentsProblem, commandBudgetMs, samePluginStatus } from "./internal/peers.js";
 import { isUiMessage, UI_CHANNEL, } from "./internal/protocol.js";
 import { API_VERSION } from "./version.js";
 export { PluginError } from "./errors.js";
 export { API_VERSION } from "./version.js";
 const HELLO_INTERVAL_MS = 250;
 const REQUEST_TIMEOUT_MS = 10_000;
+const COMMAND_GRACE_MS = 2_000;
+const NO_PEERS = Object.freeze({
+    state: "unavailable",
+    reason: "This version of Drift Beacon doesn't share other plugins with plugin UIs",
+});
+const UNLISTED = Object.freeze({ state: "unavailable", reason: "No longer in manifest.json uses" });
+const PAGE = (() => {
+    const bytes = new Uint8Array(6);
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function")
+        crypto.getRandomValues(bytes);
+    else
+        for (let i = 0; i < bytes.length; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    return Array.from(bytes, (byte) => byte.toString(36).padStart(2, "0")).join("");
+})();
 let connection = null;
-/** Connect to the Drift Beacon web app. Resolves once the app accepts this UI; later calls return the same context. */
 export function connect(options = {}) {
     connection ??= open(options.timeoutMs ?? 10_000);
     return connection;
@@ -59,7 +67,6 @@ function open(timeoutMs) {
         };
         window.addEventListener("message", onMessage);
         const sayHello = () => post({ channel: UI_CHANNEL, type: "hello", apiVersion: API_VERSION });
-        // Repeat until answered: the app may still be setting up when the UI first loads.
         const hello = setInterval(sayHello, HELLO_INTERVAL_MS);
         sayHello();
         const timeout = setTimeout(() => {
@@ -73,6 +80,7 @@ class UiClient {
     post;
     context;
     config;
+    plugin;
     rows = {
         activities: new Collection(),
         categories: new Collection(),
@@ -86,19 +94,24 @@ class UiClient {
     storageListeners = new Set();
     storage = new Map();
     serverStorage;
-    /** Keys with writes the app hasn't answered; older pushes must not revert them. */
     pendingWrites = new Map();
-    /**
-     * Keys written since the app last sent storage, with the latest write's ID. The app may answer a
-     * write before its next push, so an answered write stays in place until that push arrives.
-     */
     writesSincePush = new Map();
     nextWrite = 0;
     pending = new Map();
     nextRequest = 0;
+    peersShared;
+    listed = new Set();
+    selfId;
+    peerViews = new Map();
+    peerObjects = new Map();
     constructor(welcome, post) {
         this.post = post;
         this.config = welcome.config;
+        this.plugin = welcome.plugin;
+        this.peersShared = welcome.peers !== undefined;
+        this.selfId = welcome.peers?.self ?? welcome.plugin.id;
+        if (welcome.peers)
+            this.applyPeers(welcome.peers);
         this.serverStorage = welcome.storage;
         this.storage = new Map(Object.entries(welcome.storage));
         this.models = new WorkspaceModels({
@@ -119,7 +132,9 @@ class UiClient {
             return () => listeners.delete(callback);
         };
         this.context = {
-            plugin: welcome.plugin,
+            get plugin() {
+                return self.plugin;
+            },
             user: welcome.user,
             workspace: welcome.workspace,
             get config() {
@@ -132,21 +147,136 @@ class UiClient {
             storage: {
                 get: (key) => this.storage.get(key),
                 keys: () => [...this.storage.keys()],
-                set: (key, value) => this.write(key, JSON.parse(JSON.stringify(value))),
+                set: (key, value) => {
+                    if (value === undefined)
+                        return this.write(key, undefined);
+                    let plain;
+                    try {
+                        plain = JSON.parse(JSON.stringify(value));
+                    }
+                    catch {
+                        return Promise.reject(new PluginError("invalid", `Storage value for "${key}" is not JSON-compatible`));
+                    }
+                    return this.write(key, plain);
+                },
                 remove: (key) => this.write(key, undefined),
                 onChange: (callback) => subscribe(this.storageListeners, callback),
             },
+            plugins: {
+                get: (id) => this.peer(id),
+                get self() {
+                    return self.peer(self.selfId);
+                },
+            },
         };
     }
+    peer(id) {
+        const problem = this.unreachable(id);
+        if (problem)
+            throw problem;
+        const existing = this.peerObjects.get(id);
+        if (existing)
+            return existing;
+        const view = this.viewOf(id);
+        const subscribe = (listeners, callback) => {
+            listeners.add(callback);
+            return () => listeners.delete(callback);
+        };
+        const peer = Object.freeze({
+            id,
+            get status() {
+                return view.status;
+            },
+            onStatusChange: (callback) => subscribe(view.statusListeners, callback),
+            command: (name, input, options) => this.command(id, name, input, options),
+            state: Object.freeze({
+                get: (key) => view.state.get(key),
+                keys: () => [...view.state.keys()],
+                onChange: (callback) => subscribe(view.stateListeners, callback),
+            }),
+        });
+        this.peerObjects.set(id, peer);
+        return peer;
+    }
+    unreachable(id) {
+        return typeof id !== "string" || (this.peersShared && !this.listed.has(id))
+            ? new PluginError("invalid", `List "${String(id)}" in manifest.json uses to reach it`)
+            : null;
+    }
+    viewOf(id) {
+        let view = this.peerViews.get(id);
+        if (!view) {
+            view = { status: NO_PEERS, state: new Map(), statusListeners: new Set(), stateListeners: new Set() };
+            this.peerViews.set(id, view);
+        }
+        return view;
+    }
+    applyPeers(peers) {
+        this.peersShared = true;
+        this.selfId = peers.self;
+        this.listed = new Set(Object.keys(peers.plugins));
+        const statusChanges = [];
+        const stateChanges = [];
+        const unlisted = [...this.peerViews.keys()]
+            .filter((id) => !this.listed.has(id))
+            .map((id) => [id, { status: UNLISTED, state: {} }]);
+        for (const [id, next] of [...Object.entries(peers.plugins), ...unlisted]) {
+            const view = this.viewOf(id);
+            if (!samePluginStatus(view.status, next.status)) {
+                const status = deepFreeze({ ...next.status });
+                view.status = status;
+                statusChanges.push(() => notify(view.statusListeners, (listener) => listener(status)));
+            }
+            const state = new Map(Object.entries(next.state).map(([key, value]) => [key, deepFreeze(value)]));
+            for (const key of new Set([...view.state.keys(), ...state.keys()])) {
+                if (view.state.has(key) === state.has(key) && jsonEqual(view.state.get(key), state.get(key)))
+                    continue;
+                const value = state.get(key);
+                stateChanges.push(() => notify(view.stateListeners, (listener) => listener(key, value)));
+            }
+            view.state = state;
+        }
+        for (const change of [...statusChanges, ...stateChanges])
+            change();
+    }
+    command(plugin, command, input, options) {
+        const unreachable = this.unreachable(plugin);
+        if (unreachable)
+            return Promise.reject(unreachable);
+        const problem = commandArgumentsProblem(command, input, options);
+        if (problem)
+            return Promise.reject(new PluginError("invalid", problem));
+        let plain;
+        try {
+            plain = input === undefined ? undefined : JSON.parse(JSON.stringify(input));
+        }
+        catch {
+            return Promise.reject(new PluginError("invalid", "Command input must be JSON-compatible"));
+        }
+        const timeoutMs = options?.timeoutMs;
+        return this.request({
+            method: "plugins.command",
+            params: {
+                plugin,
+                command,
+                ...(plain === undefined ? {} : { input: plain }),
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            },
+        }, {
+            ms: commandBudgetMs(timeoutMs) + COMMAND_GRACE_MS,
+            error: () => new PluginError("timeout", `${plugin} didn't answer "${command}" in time; it may have run`),
+        });
+    }
     receive(message) {
         if (message.type === "welcome") {
-            // A reconnect: identity is unchanged, so only the state is new.
+            this.plugin = message.plugin;
             this.receive({
                 channel: message.channel,
                 type: "state",
                 config: message.config,
                 data: message.data,
                 storage: message.storage,
+                ...(message.peers ? { peers: message.peers } : {}),
             });
             return;
         }
@@ -172,9 +302,10 @@ class UiClient {
             this.writesSincePush.clear();
             this.reconcileStorage();
         }
+        if (message.peers)
+            this.applyPeers(message.peers);
         notify(this.dataListeners, (listener) => listener());
     }
-    /** Replace all three collections before telling anyone, so callbacks see one consistent snapshot. */
     applyData(data) {
         const changes = this.models.update({
             activities: this.rows.activities.replace(data.activities),
@@ -188,7 +319,6 @@ class UiClient {
         for (const change of changes.sessions)
             notify(this.sessionListeners, (listener) => listener(change));
     }
-    /** Apply the app's storage, keeping local values for keys with unconfirmed writes. Returns whether anything changed. */
     reconcileStorage() {
         const isProtected = (key) => this.pendingWrites.has(key) || this.writesSincePush.has(key);
         const next = new Map();
@@ -225,7 +355,6 @@ class UiClient {
                 : { method: "storage.set", params: { key, value } });
         }
         catch (error) {
-            // Roll back to the app's value, unless a later local write replaced this one.
             if (this.writesSincePush.get(key) === writeId)
                 this.writesSincePush.delete(key);
             throw error;
@@ -240,16 +369,19 @@ class UiClient {
                 notify(this.dataListeners, (listener) => listener());
         }
     }
-    request(request) {
-        const id = String(++this.nextRequest);
+    request(request, timeout = {
+        ms: REQUEST_TIMEOUT_MS,
+        error: () => new PluginError("unavailable", `${request.method} timed out`),
+    }) {
+        const id = `${PAGE}-${++this.nextRequest}`;
         return new Promise((resolve, reject) => {
             this.pending.set(id, { resolve, reject });
             this.post({ channel: UI_CHANNEL, type: "request", id, ...request });
             setTimeout(() => {
                 if (!this.pending.delete(id))
                     return;
-                reject(new PluginError("unavailable", `${request.method} timed out`));
-            }, REQUEST_TIMEOUT_MS);
+                reject(timeout.error());
+            }, timeout.ms);
         });
     }
 }

package/dist/version.d.ts

@@ -2,5 +2,5 @@
  * The plugin API version this SDK describes, `major.minor`. It matches the package version's
  * major and minor. Before 1.0 every minor version may break plugins.
  */
-export declare const API_VERSION = "0.1";
+export declare const API_VERSION = "0.2";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,5 +1 @@
-/**
- * The plugin API version this SDK describes, `major.minor`. It matches the package version's
- * major and minor. Before 1.0 every minor version may break plugins.
- */
-export const API_VERSION = "0.1";
+export const API_VERSION = "0.2";

package/dist/vite.js

@@ -6,18 +6,6 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-/**
- * `driftBeacon()` (`@drift-beacon/plugin/vite`): the Vite plugin of a plugin package. The UI is the author's
- * own Vite app rooted at `ui/`; this plugin builds main next to it, so `dist/` is exactly the release package.
- *
- * `vite build` builds main once the UI is written. `vite` (`pnpm dev`) serves the UI with HMR, watch-builds main
- * into `dist/` and keeps the manifest, the icon and the config types in sync. It writes a marker (dev.ts) that
- * the Drift Beacon server polls; the server then connects to Vite's HMR socket and sends lines to print here.
- *
- * Through `link:`, a bare `vite` import from here would resolve to Cartridge's copy, whose types never match
- * another copy's. So vite is only a type here: at run time the plugin loads the project's own vite, and the
- * public signature names no vite type.
- */
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -27,12 +15,7 @@ import { stripVTControlCharacters, styleText } from "node:util";
 import { DEV_MARKER } from "./dev.js";
 import { PACKAGE_JSON } from "./internal/package-layout.js";
 import { prepare } from "./prepare.js";
-/** How long `pnpm dev` waits for a Drift Beacon server before saying how to connect one. */
 const HINT_DELAY_MS = 5_000;
-/**
- * The Vite plugin for a Drift Beacon plugin package: `plugins: [driftBeacon()]`. It owns `root`, `base` and
- * `build.outDir`. Typed as `{ name: string }` so it fits any Vite version's `plugins`.
- */
 export function driftBeacon() {
     let pkg = "";
     let dist = "";
@@ -44,7 +27,6 @@ export function driftBeacon() {
             if (env.isPreview)
                 return;
             pkg = path.resolve(config.root ?? process.cwd());
-            // Read, not assumed: `dbplugin pack` redirects the whole build into a temp folder through `build.outDir`.
             dist = config.build?.outDir ? path.resolve(pkg, config.build.outDir) : path.join(pkg, "dist");
             for (const file of ["ui/index.html", "main/src/index.ts"]) {
                 if (!existsSync(path.join(pkg, file)))
@@ -55,14 +37,13 @@ export function driftBeacon() {
                 throw new Error("driftBeacon(): a custom server.hmr port or path is not supported");
             }
             ({ manifest, bytes: manifestBytes } = prepare(pkg, { strict: true }));
-            // `dist/ui` is outside the root `ui/`, so Vite only empties it when asked to.
             return { root: path.join(pkg, "ui"), base: "./", build: { outDir: path.join(dist, "ui"), emptyOutDir: true } };
         },
-        // `vite` (`pnpm dev`). A Vite restart creates the new server before closing the old one: both share the state.
         configureServer(server) {
+            if (process.env.VITEST)
+                return;
             serveDev(server, devStates.get(pkg) ?? startDev(pkg, dist, manifest, manifestBytes, server.config.logger));
         },
-        // `vite build` (and `dbplugin pack`). Runs after the UI is written (and Vite has copied `ui/public/` into `dist/ui/`).
         async writeBundle() {
             const vite = await loadVite(pkg);
             await vite.build(mainBuild(vite, pkg, { outDir: path.join(dist, "main"), minify: true, sourcemap: false, logLevel: "warn" }));
@@ -73,16 +54,12 @@ export function driftBeacon() {
     };
     return plugin;
 }
-/** The project's own vite: through `link:`, a bare import would resolve to the SDK's copy. */
 const loadVite = async (pkg) => import(__rewriteRelativeImportExtension(pathToFileURL(createRequire(path.join(pkg, "package.json")).resolve("vite")).href));
-/** Main as one ESM file, with every dependency bundled except the SDK, which the plugin host supplies. */
 function mainBuild(vite, pkg, options) {
-    // One file on both Vite 7 (Rollup) and Vite 8 (Rolldown, which deprecates `inlineDynamicImports`).
     const single = "rolldownVersion" in vite ? { codeSplitting: false } : { inlineDynamicImports: true };
     return {
         configFile: false,
         root: pkg,
-        // Vite copies publicDir in every build: a stray `<pkg>/public/` must not reach `dist/main/`.
         publicDir: false,
         logLevel: options.logLevel,
         build: {
@@ -101,13 +78,10 @@ function mainBuild(vite, pkg, options) {
         ssr: { noExternal: true },
     };
 }
-// On globalThis, so the state survives whatever reloads this module; keyed by package root, so one process
-// (a test file) can serve several roots.
 const DEV_STATES = Symbol.for("drift-beacon.dev");
 const shared = globalThis;
 shared[DEV_STATES] ??= new Map();
 const devStates = shared[DEV_STATES];
-/** Once per root: seed `dist/` and start the main watch build. */
 function startDev(pkg, dist, manifest, bytes, logger) {
     writeAtomic(path.join(dist, "manifest.json"), bytes);
     writeAtomic(path.join(dist, "package.json"), `${JSON.stringify(PACKAGE_JSON, null, 2)}\n`);
@@ -118,6 +92,7 @@ function startDev(pkg, dist, manifest, bytes, logger) {
         manifest,
         manifestBytes: bytes,
         watcher: Promise.resolve(undefined),
+        idle: Promise.resolve(),
         buildId: hashDist(dist),
         uiUrl: null,
         socket: null,
@@ -133,18 +108,18 @@ function startDev(pkg, dist, manifest, bytes, logger) {
     });
     return state;
 }
-/**
- * Builds main into `.drift-beacon/main-next/` on every save, then moves the files into `dist/main/`: never a
- * half-written bundle in `dist/`, and at the same depth, so the map's relative sources still resolve.
- */
 async function watchMain(state) {
     const vite = await loadVite(state.pkg);
     const staging = path.join(state.pkg, ".drift-beacon/main-next");
     const options = { outDir: staging, minify: false, sourcemap: true, watch: {}, logLevel: "silent" };
     const watcher = (await vite.build(mainBuild(vite, state.pkg, options)));
-    // Vite closes each event's bundle itself.
+    let built = () => { };
     watcher.on("event", (event) => {
-        if (event.code === "BUNDLE_END") {
+        if (event.code === "START")
+            state.idle = new Promise((resolve) => (built = resolve));
+        else if (event.code === "END")
+            built();
+        else if (event.code === "BUNDLE_END") {
             try {
                 moveFiles(staging, path.join(state.dist, "main"));
                 const changed = writeDevMarker(state);
@@ -158,7 +133,6 @@ async function watchMain(state) {
             }
         }
         else if (event.code === "ERROR") {
-            // dist/ is untouched, so the server keeps the last good build.
             const reason = shorten(state, event.error.message).replaceAll(/\n\s*\n/g, "\n");
             print(state.logger, {
                 level: "error",
@@ -166,15 +140,14 @@ async function watchMain(state) {
             });
         }
     });
+    await new Promise((resolve) => watcher.on("event", () => resolve()));
     return watcher;
 }
-/** Per dev server: the manifest and icon watchers, the marker, and the server's socket. */
 function serveDev(server, state) {
     state.servers += 1;
     state.logger = server.config.logger;
     const manifestFile = path.join(state.pkg, "manifest.json");
     server.watcher.add(manifestFile);
-    // Vite already watches its root `ui/`, so the icon's changes arrive here too.
     server.watcher.on("all", (event, file) => {
         if (file === manifestFile && event !== "unlink")
             updateManifest(state);
@@ -183,7 +156,6 @@ function serveDev(server, state) {
     });
     server.httpServer?.on("listening", () => {
         state.uiUrl = server.resolvedUrls?.local[0] ?? null;
-        // Even before main has built: the server can connect and serve the UI meanwhile.
         writeDevMarker(state);
         clearTimeout(state.hint);
         state.hint = setTimeout(() => {
@@ -191,22 +163,19 @@ function serveDev(server, state) {
                 print(state.logger, { level: "warn", text: noServerHint(state) });
         }, HINT_DELAY_MS).unref();
     });
-    // On the dev server's own close: its http server emits "close" only if it listened, and has none in middleware mode.
-    const close = server.close.bind(server);
+    const { watcher } = server;
+    const closeWatcher = watcher.close.bind(watcher);
     let open = true;
-    server.close = () => {
-        if (open) {
-            open = false;
-            release(state);
-        }
-        return close();
+    watcher.close = async () => {
+        const released = open ? release(state) : undefined;
+        open = false;
+        await Promise.all([closeWatcher(), released]);
     };
-    // Vite custom events over the HMR socket. Never `server.ws.send`: it broadcasts, plugin iframes included.
     server.ws.on("drift-beacon:hello", (data, client) => {
         if (data?.session !== state.session)
             return;
         const welcome = { v: 1, session: state.session, pluginId: state.manifest.id };
-        client.send("drift-beacon:welcome", welcome); // this socket only
+        client.send("drift-beacon:welcome", welcome);
         clearTimeout(state.hint);
         const { socket } = client;
         state.socket = socket;
@@ -222,25 +191,23 @@ function serveDev(server, state) {
             print(state.logger, data);
     });
 }
-/** One dev server closed: the last one for the root stops the main watch build and forgets the root. */
-function release(state) {
+async function release(state) {
     if (--state.servers > 0)
         return;
     clearTimeout(state.hint);
     if (devStates.get(state.pkg) === state)
         devStates.delete(state.pkg);
-    void state.watcher.then((watcher) => watcher?.close());
+    const watcher = await state.watcher;
+    await state.idle;
+    await watcher?.close();
 }
-/** A saved manifest: checked, copied, and its config types and icon refreshed. An invalid one keeps the old copy. */
 function updateManifest(state) {
     try {
         const { manifest, bytes } = prepare(state.pkg, { strict: true });
-        // A missing icon was already reported under its name; say it again only for a new name.
         const renamed = manifest.icon !== state.manifest.icon;
         state.manifest = manifest;
         state.manifestBytes = bytes;
         syncIcon(state, renamed);
-        // Copies the manifest.
         writeDevMarker(state);
     }
     catch (error) {
@@ -250,7 +217,6 @@ function updateManifest(state) {
         });
     }
 }
-/** Copies the manifest icon from `ui/public/` into `dist/ui/` (Vite does it in a build), or removes a deleted one. */
 function syncIcon(state, warnMissing) {
     const { icon } = state.manifest;
     if (!icon)
@@ -275,7 +241,6 @@ function syncIcon(state, warnMissing) {
         });
     }
 }
-/** Moves every staged file into `to`, maps first and `index.js` last, so the new index.js never meets an old map. */
 function moveFiles(from, to) {
     const rank = (file) => (file === "index.js" ? 2 : file.endsWith(".map") ? 0 : 1);
     const files = readdirSync(from, { recursive: true, withFileTypes: true })
@@ -287,10 +252,6 @@ function moveFiles(from, to) {
         renameSync(path.join(from, file), path.join(to, file));
     }
 }
-/**
- * Writes the dev marker for what is in `dist/` now; true when its build id changed. The manifest, `package.json`
- * and a missing icon are written first, so a `dist/` deleted while `pnpm dev` runs is whole again.
- */
 function writeDevMarker(state) {
     writeAtomic(path.join(state.dist, "manifest.json"), state.manifestBytes);
     writeAtomic(path.join(state.dist, "package.json"), `${JSON.stringify(PACKAGE_JSON, null, 2)}\n`);
@@ -307,7 +268,6 @@ const noServerHint = (state) => [
     `The server connects when it finds dist/${DEV_MARKER} in a folder directly`,
     `under its DEV_PLUGINS_PATH. Run it in development mode with DEV_PLUGINS_PATH=${path.dirname(state.pkg)}`,
 ].join("\n");
-/** Plain text with package paths made relative, for messages that come from Vite or the file system. */
 const shorten = (state, text) => stripVTControlCharacters(text).replaceAll(`${state.pkg}${path.sep}`, "").trim();
 const TIME = new Intl.DateTimeFormat(undefined, { hour: "numeric", minute: "numeric", second: "numeric" });
 const STYLES = {
@@ -316,11 +276,6 @@ const STYLES = {
     warn: "yellow",
     error: "red",
 };
-/**
- * Prints a line (from the server, or about the local build) through Vite's logger, timed like Vite's own lines
- * but tagged `[beacon]` (Vite's `timestamp` option would tag it `[vite]`). The first line is coloured by level;
- * the others are dimmed and indented under it.
- */
 function print(logger, { level, text }) {
     const time = TIME.format(new Date());
     const [first = "", ...rest] = String(text).split("\n");
@@ -336,33 +291,29 @@ function print(logger, { level, text }) {
     else
         logger.info(message);
 }
-// ============================================================================
-// Shared
-// ============================================================================
-/** Writes the marker for what is in `dist/` now and returns its build id. */
 function writeMarker(dist, { pluginId, session, uiUrl }) {
     const buildId = hashDist(dist);
-    // The HMR socket shares the UI's host and port; a relative base serves it at `/`.
     const marker = { v: 1, pluginId, buildId, session, uiUrl, wsUrl: uiUrl?.replace(/^http/, "ws") ?? null };
     writeAtomic(path.join(dist, DEV_MARKER), `${JSON.stringify(marker, null, 2)}\n`);
     return buildId;
 }
-/**
- * The build id: sha256 of what the server loads, first 16 hex characters. Null until main is built. It
- * covers `ui/index.html` so a UI-only build still refreshes an open static UI.
- */
 function hashDist(dist) {
     if (!existsSync(path.join(dist, "main/index.js")))
         return null;
+    const ui = existsSync(path.join(dist, "ui"))
+        ? readdirSync(path.join(dist, "ui"), { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => path.relative(dist, path.join(entry.parentPath, entry.name)).split(path.sep).join("/"))
+            .sort()
+        : [];
     const hash = createHash("sha256");
-    for (const name of ["manifest.json", "main/index.js", "main/index.js.map", "ui/index.html"]) {
+    for (const name of ["manifest.json", "main/index.js", "main/index.js.map", ...ui]) {
         const file = path.join(dist, name);
         if (existsSync(file))
             hash.update(`${name}\0`).update(readFileSync(file));
     }
     return hash.digest("hex").slice(0, 16);
 }
-/** Writes through a temporary file and a rename, so the server never reads a partial file. */
 function writeAtomic(file, content) {
     mkdirSync(path.dirname(file), { recursive: true });
     writeFileSync(`${file}.tmp`, content);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-beacon/plugin",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The Drift Beacon plugin SDK: APIs for plugin main code and UIs, the driftBeacon() Vite plugin and the dbplugin CLI",
   "license": "MIT",
   "author": {
@@ -38,8 +38,15 @@
   },
   "files": [
     "bin",
-    "dist",
-    "!dist/**/*.map"
+    "dist/**/*.js",
+    "!dist/internal.js",
+    "dist/index.d.ts",
+    "dist/ui.d.ts",
+    "dist/vite.d.ts",
+    "dist/main.d.ts",
+    "dist/types.d.ts",
+    "dist/errors.d.ts",
+    "dist/version.d.ts"
   ],
   "publishConfig": {
     "access": "public"
@@ -65,7 +72,7 @@
     "vite": "7.1.2"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "build": "rm -rf dist && tsc -p tsconfig.json --removeComments && tsc -p tsconfig.json --emitDeclarationOnly",
     "clean": "rm -rf dist",
     "typecheck": "tsc --noEmit && node scripts/api-report.mjs --check",
     "api:update": "node scripts/api-report.mjs"

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/dev.d.ts

@@ -1,38 +0,0 @@
-/**
- * The `pnpm dev` handshake between `driftBeacon()` and the Drift Beacon server. The dev tool writes a
- * marker into the package's `dist/`; the server polls for it, connects to Vite's HMR socket and trusts
- * the socket only after a `welcome` whose `session` equals the marker's. Messages travel as Vite custom
- * events (`{ type: "custom", event, data }`). All wording is rendered on the server; the tool only prints.
- */
-/** File name of the marker in `dist/`. Written as tmp, then renamed, synchronously. Never packed. */
-export declare const DEV_MARKER = ".drift-beacon-dev.json";
-export interface DevMarker {
-    readonly v: 1;
-    /** `manifest.id`; the server routes logs and the dev UI URL by it. */
-    readonly pluginId: string;
-    /** Hash of the built package; null until `dist/main/index.js` exists. A new id means a new build. */
-    readonly buildId: string | null;
-    /** One per `pnpm dev` process and package root; null after `vite build`. */
-    readonly session: string | null;
-    /** The dev server's UI URL, for example `http://localhost:5174/`. */
-    readonly uiUrl: string | null;
-    /** The dev server's HMR socket, for example `ws://localhost:5174/`. */
-    readonly wsUrl: string | null;
-}
-/** Server → tool, event `drift-beacon:hello`. */
-export interface DevHello {
-    readonly v: 1;
-    readonly session: string;
-}
-/** Tool → server, event `drift-beacon:welcome`, sent only to the socket that said hello. */
-export interface DevWelcome {
-    readonly v: 1;
-    readonly session: string;
-    readonly pluginId: string;
-}
-/** Server → tool, event `drift-beacon:print`: one line (or block) for the plugin's terminal. */
-export interface DevPrint {
-    readonly level: "info" | "success" | "warn" | "error";
-    readonly text: string;
-}
-//# sourceMappingURL=dev.d.ts.map