electrobun-preact-devtools 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Alec Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# electrobun-preact-devtools
+
+## Purpose
+
+`electrobun-preact-devtools` runs the Preact devtools UI in a standalone Electrobun window.
+It gives you a Bun-side host, an app-window preload bridge, and a devtools-window mount API.
+
+## Installation
+
+```bash
+pnpm add electrobun-preact-devtools
+```
+
+## Quick Example
+
+```ts
+import { BrowserWindow } from 'electrobun/bun'
+import { Electroview } from 'electrobun/view'
+import { createPreactDevtoolsHost } from 'electrobun-preact-devtools/bun'
+import {
+  composeAppWindowViewRPC,
+  installPreactDevtoolsBridge,
+} from 'electrobun-preact-devtools/app-preload'
+import {
+  composeDevtoolsWindowViewRPC,
+  mountPreactDevtoolsWindow,
+} from 'electrobun-preact-devtools/devtools-view'
+
+const host = createPreactDevtoolsHost({
+  openWindow({ rpc }) {
+    return new BrowserWindow({
+      title: 'Preact Devtools',
+      url: 'views://preact-devtools/index.html',
+      rpc,
+    })
+  },
+})
+
+const appWindow = new BrowserWindow({
+  title: 'My App',
+  url: 'views://app/index.html',
+  preload: 'views://app/preload.js',
+  rpc: host.createAppWindowRPC({ targetId: 'main' }),
+})
+
+host.registerAppWindow({ targetId: 'main', window: appWindow })
+
+const appElectroview = new Electroview({ rpc: composeAppWindowViewRPC({}) })
+installPreactDevtoolsBridge({ electroview: appElectroview })
+
+const devtoolsElectroview = new Electroview({
+  rpc: composeDevtoolsWindowViewRPC({}),
+})
+
+mountPreactDevtoolsWindow({
+  container: document.getElementById('root')!,
+  electroview: devtoolsElectroview,
+})
+```
+
+## Documentation Map
+
+- Concepts and lifecycle: [docs/context.md](/Users/alec/dev/alloc/preact-devtools-standalone/docs/context.md)
+- Minimal example: [examples/minimal.ts](/Users/alec/dev/alloc/preact-devtools-standalone/examples/minimal.ts)
+- Existing RPC composition: [examples/compose-existing-rpc.ts](/Users/alec/dev/alloc/preact-devtools-standalone/examples/compose-existing-rpc.ts)
+- Exact exported signatures: generated in `dist/*.d.mts` after `pnpm build`

package/dist/app-preload.d.mts

@@ -0,0 +1,41 @@
+import { u as PreactDevtoolsAppWindowRPC } from "./index-ohWyACpe.mjs";
+import { n as PreactDevtoolsLogger, t as ComposeRPCHandlers } from "./rpc-Ct-cJYzf.mjs";
+import { ElectrobunRPCSchema, Electroview } from "electrobun/view";
+
+//#region src/app-preload/bridge.d.ts
+/**
+ * Options for installing the application-window bridge.
+ *
+ * The bridge must be installed before the application imports `preact/debug`
+ * or `preact/devtools`.
+ */
+interface InstallPreactDevtoolsBridgeOptions {
+  electroview?: Electroview<any>;
+  globalName?: string;
+  logger?: PreactDevtoolsLogger;
+}
+/** Handle returned by `installPreactDevtoolsBridge(...)`. */
+interface InstalledPreactDevtoolsBridge {
+  dispose(): void;
+}
+/**
+ * Installs `window.__PREACT_DEVTOOLS__` for the current application window and
+ * wires it to Electrobun RPC.
+ */
+declare function installPreactDevtoolsBridge(options?: InstallPreactDevtoolsBridgeOptions): InstalledPreactDevtoolsBridge;
+//#endregion
+//#region src/app-preload/rpc.d.ts
+/** The browser-side RPC definition type returned by `Electroview.defineRPC(...)`. */
+type ViewRPCDefinition<Schema extends ElectrobunRPCSchema = ElectrobunRPCSchema> = ReturnType<typeof Electroview.defineRPC<Schema>>;
+/** Consumer-owned webview handlers that are merged with the reserved app-bridge channel. */
+type ViewComposeRPCHandlers<Schema extends ElectrobunRPCSchema> = ComposeRPCHandlers<Schema, 'webview'>;
+/**
+ * Creates the app-window `Electroview.defineRPC(...)` result for apps that
+ * already have their own webview RPC handlers.
+ */
+declare function composeAppWindowViewRPC<TRPC extends PreactDevtoolsAppWindowRPC>(options: {
+  handlers?: ViewComposeRPCHandlers<TRPC>;
+  maxRequestTime?: number;
+}): ViewRPCDefinition<TRPC>;
+//#endregion
+export { type InstallPreactDevtoolsBridgeOptions, type InstalledPreactDevtoolsBridge, type ViewComposeRPCHandlers, type ViewRPCDefinition, composeAppWindowViewRPC, installPreactDevtoolsBridge };

package/dist/app-preload.mjs

@@ -0,0 +1,126 @@
+import { t as PREACT_DEVTOOLS_MESSAGE } from "./protocol-rAxFKNGR.mjs";
+import { n as warnUnboundHandler, r as composeRPCHandlers, t as emitLog } from "./logger-Bpp6JxH4.mjs";
+import { r as createHook } from "./upstream-DgCs5wGH.mjs";
+import { Electroview } from "electrobun/view";
+//#region src/app-preload/rpc.ts
+/**
+* Creates the app-window `Electroview.defineRPC(...)` result for apps that
+* already have their own webview RPC handlers.
+*/
+function composeAppWindowViewRPC(options) {
+	return Electroview.defineRPC({
+		maxRequestTime: options.maxRequestTime,
+		handlers: composeRPCHandlers(options.handlers, (message) => {
+			const bridge = getActiveBridge();
+			if (!bridge) {
+				warnUnboundHandler("app bridge");
+				return;
+			}
+			bridge.handleMessage(message);
+		})
+	});
+}
+//#endregion
+//#region src/app-preload/bridge.ts
+var BridgeController = class {
+	electroview;
+	globalName;
+	logger;
+	hook;
+	disposed = false;
+	listeners = /* @__PURE__ */ new Map();
+	pageListeners = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.electroview = options.electroview ?? new Electroview({ rpc: composeAppWindowViewRPC({}) });
+		this.globalName = options.globalName ?? "__PREACT_DEVTOOLS__";
+		this.logger = options.logger;
+		const currentValue = window[this.globalName];
+		if (currentValue && currentValue !== activeBridge?.hook) throw new Error(`Cannot install the Preact devtools bridge because window.${this.globalName} is already defined.`);
+		this.hook = createHook({
+			listen: (type, callback) => {
+				this.addListener(this.listeners, type, callback);
+			},
+			send: (type, data) => {
+				if (this.disposed) return;
+				if (type === "root-order-page") {
+					this.emit(this.pageListeners, type, data);
+					return;
+				}
+				this.sendToBun({
+					kind: "hook-event",
+					type,
+					data
+				});
+			},
+			listenToPage: (type, callback) => {
+				this.addListener(this.pageListeners, type, callback);
+			}
+		});
+		window[this.globalName] = this.hook;
+		this.sendToBun({ kind: "bridge-ready" });
+	}
+	handleMessage(message) {
+		switch (message.kind) {
+			case "session-connected": return;
+			case "session-disconnected":
+				this.emit(this.listeners, "disconnect", null);
+				return;
+			case "request-refresh":
+				this.emit(this.listeners, "refresh", null);
+				return;
+			case "devtools-command":
+				this.emit(this.listeners, message.type, message.data);
+				return;
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.listeners.clear();
+		this.pageListeners.clear();
+		this.sendToBun({ kind: "bridge-disposed" });
+		if (window[this.globalName] === this.hook) delete window[this.globalName];
+		if (activeBridge === this) activeBridge = void 0;
+	}
+	sendToBun(message) {
+		const send = this.electroview.rpc?.sendProxy?.[PREACT_DEVTOOLS_MESSAGE];
+		if (typeof send === "function") {
+			send(message);
+			return;
+		}
+		emitLog(this.logger, {
+			level: "warn",
+			code: "missing-app-transport",
+			message: "Unable to send a Preact devtools bridge message because the RPC transport is unavailable.",
+			detail: message
+		});
+	}
+	addListener(map, type, callback) {
+		let listeners = map.get(type);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			map.set(type, listeners);
+		}
+		listeners.add(callback);
+	}
+	emit(map, type, data) {
+		const listeners = map.get(type);
+		if (!listeners) return;
+		for (const listener of listeners) listener(data);
+	}
+};
+let activeBridge;
+function getActiveBridge() {
+	return activeBridge;
+}
+/**
+* Installs `window.__PREACT_DEVTOOLS__` for the current application window and
+* wires it to Electrobun RPC.
+*/
+function installPreactDevtoolsBridge(options = {}) {
+	if (activeBridge) return activeBridge;
+	activeBridge = new BridgeController(options);
+	return activeBridge;
+}
+//#endregion
+export { composeAppWindowViewRPC, installPreactDevtoolsBridge };

package/dist/bun.d.mts

@@ -0,0 +1,70 @@
+import { a as DevtoolsTargetId, d as PreactDevtoolsDevtoolsWindowRPC, s as HostConnectionState, u as PreactDevtoolsAppWindowRPC } from "./index-ohWyACpe.mjs";
+import { n as PreactDevtoolsLogger, t as ComposeRPCHandlers } from "./rpc-Ct-cJYzf.mjs";
+import { BrowserView, BrowserWindow, ElectrobunRPCSchema } from "electrobun/bun";
+import { Electroview } from "electrobun/view";
+
+//#region src/bun/host.d.ts
+/** The Bun-side RPC definition type returned by `BrowserView.defineRPC(...)`. */
+type BrowserWindowRPCDefinition<Schema extends ElectrobunRPCSchema = ElectrobunRPCSchema> = ReturnType<typeof BrowserView.defineRPC<Schema>>;
+/** The browser-side RPC definition type returned by `Electroview.defineRPC(...)`. */
+type ViewRPCDefinition<Schema extends ElectrobunRPCSchema = ElectrobunRPCSchema> = ReturnType<typeof Electroview.defineRPC<Schema>>;
+/** Consumer-owned Bun handlers that are merged with the reserved devtools message channel. */
+type BunComposeRPCHandlers<Schema extends ElectrobunRPCSchema> = ComposeRPCHandlers<Schema, 'bun'>;
+/** Arguments passed to `openWindow(...)` when the host needs a standalone devtools window. */
+interface OpenPreactDevtoolsWindowArgs {
+  targetId: DevtoolsTargetId;
+  rpc: BrowserWindowRPCDefinition<PreactDevtoolsDevtoolsWindowRPC>;
+  composeRPC<TRPC extends PreactDevtoolsDevtoolsWindowRPC>(options: {
+    handlers?: BunComposeRPCHandlers<TRPC>;
+  }): BrowserWindowRPCDefinition<TRPC>;
+}
+/** Options for creating the Bun-side devtools host. */
+interface CreatePreactDevtoolsHostOptions {
+  openWindow(args: OpenPreactDevtoolsWindowArgs): BrowserWindow | Promise<BrowserWindow>;
+  logger?: PreactDevtoolsLogger;
+}
+/** Associates one target id with an application BrowserWindow. */
+interface RegisterAppWindowOptions {
+  targetId: DevtoolsTargetId;
+  window: BrowserWindow;
+}
+/** Bun-side controller that tracks targets, opens devtools windows, and routes protocol traffic. */
+interface PreactDevtoolsHost {
+  createAppWindowRPC(options: {
+    targetId: DevtoolsTargetId;
+  }): BrowserWindowRPCDefinition<PreactDevtoolsAppWindowRPC>;
+  composeAppWindowRPC<TRPC extends PreactDevtoolsAppWindowRPC>(options: {
+    targetId: DevtoolsTargetId;
+    handlers?: BunComposeRPCHandlers<TRPC>;
+  }): BrowserWindowRPCDefinition<TRPC>;
+  registerAppWindow(options: RegisterAppWindowOptions): void;
+  open(targetId: DevtoolsTargetId): Promise<BrowserWindow>;
+  focus(targetId: DevtoolsTargetId): boolean;
+  close(targetId: DevtoolsTargetId): Promise<void>;
+  isOpen(targetId: DevtoolsTargetId): boolean;
+  getState(targetId: DevtoolsTargetId): HostConnectionState;
+  dispose(): void;
+}
+/**
+ * Creates the Bun-side RPC definition for an application window that already has
+ * consumer-defined handlers.
+ */
+declare function composeAppWindowRPC<TRPC extends PreactDevtoolsAppWindowRPC>(host: PreactDevtoolsHost, options: {
+  targetId: DevtoolsTargetId;
+  handlers?: BunComposeRPCHandlers<TRPC>;
+}): BrowserWindowRPCDefinition<TRPC>;
+/**
+ * Creates the Bun-side RPC definition for a standalone devtools window that already has
+ * consumer-defined handlers.
+ */
+declare function composeDevtoolsWindowRPC<TRPC extends PreactDevtoolsDevtoolsWindowRPC>(host: PreactDevtoolsHost, options: {
+  targetId: DevtoolsTargetId;
+  handlers?: BunComposeRPCHandlers<TRPC>;
+}): BrowserWindowRPCDefinition<TRPC>;
+/**
+ * Creates the Bun-side host that pairs application windows with standalone
+ * Preact devtools windows.
+ */
+declare function createPreactDevtoolsHost(options: CreatePreactDevtoolsHostOptions): PreactDevtoolsHost;
+//#endregion
+export { type BrowserWindowRPCDefinition, type BunComposeRPCHandlers, type CreatePreactDevtoolsHostOptions, type OpenPreactDevtoolsWindowArgs, type PreactDevtoolsHost, type RegisterAppWindowOptions, type ViewRPCDefinition, composeAppWindowRPC, composeDevtoolsWindowRPC, createPreactDevtoolsHost };

package/dist/bun.mjs

@@ -0,0 +1,298 @@
+import { t as PREACT_DEVTOOLS_MESSAGE } from "./protocol-rAxFKNGR.mjs";
+import { r as composeRPCHandlers, t as emitLog } from "./logger-Bpp6JxH4.mjs";
+import { BrowserView } from "electrobun/bun";
+//#region src/bun/host.ts
+const hostInternals = /* @__PURE__ */ new WeakMap();
+const unsupportedDevtoolsCommands = new Set([
+	"inspect-host-node",
+	"load-host-selection",
+	"view-source"
+]);
+function getInternals(host) {
+	const internals = hostInternals.get(host);
+	if (!internals) throw new Error("Invalid Preact devtools host instance.");
+	return internals;
+}
+function sendReservedMessage(target, payload) {
+	const send = target?.webview?.rpc?.sendProxy?.[PREACT_DEVTOOLS_MESSAGE];
+	if (typeof send === "function") send(payload);
+}
+function connectSession(session) {
+	if (session.devtoolsWindow) sendReservedMessage(session.devtoolsWindow, {
+		kind: "connection-state",
+		connected: session.appReady && session.devtoolsReady,
+		targetId: session.targetId
+	});
+	if (session.appReady && session.devtoolsReady && session.appWindow) {
+		sendReservedMessage(session.appWindow, { kind: "session-connected" });
+		sendReservedMessage(session.appWindow, { kind: "request-refresh" });
+	}
+}
+function closeDevtoolsWindow(session) {
+	const window = session.devtoolsWindow;
+	session.devtoolsWindow = void 0;
+	session.devtoolsReady = false;
+	session.openingPromise = void 0;
+	if (window) try {
+		window.close();
+	} catch {}
+}
+function handleDevtoolsClosed(internals, session, reason) {
+	const hadDevtools = !!session.devtoolsWindow || session.devtoolsReady;
+	session.devtoolsWindow = void 0;
+	session.devtoolsReady = false;
+	session.openingPromise = void 0;
+	if (hadDevtools && session.appReady && session.appWindow) sendReservedMessage(session.appWindow, {
+		kind: "session-disconnected",
+		reason
+	});
+	if (!session.appWindow) internals.sessions.delete(session.targetId);
+}
+function handleAppWindowClosed(internals, session) {
+	session.closing = true;
+	session.appReady = false;
+	session.appWindow = void 0;
+	if (session.devtoolsWindow) closeDevtoolsWindow(session);
+	internals.sessions.delete(session.targetId);
+}
+/**
+* Creates the Bun-side RPC definition for an application window that already has
+* consumer-defined handlers.
+*/
+function composeAppWindowRPC(host, options) {
+	const internals = getInternals(host);
+	return BrowserView.defineRPC({ handlers: composeRPCHandlers(options.handlers, (message) => {
+		if (internals.disposed) {
+			emitLog(internals.logger, {
+				level: "warn",
+				code: "host-disposed-app-message",
+				message: "Dropped app-window message because the host has been disposed.",
+				targetId: options.targetId,
+				detail: message
+			});
+			return;
+		}
+		internals.handleAppMessage(options.targetId, message);
+	}) });
+}
+/**
+* Creates the Bun-side RPC definition for a standalone devtools window that already has
+* consumer-defined handlers.
+*/
+function composeDevtoolsWindowRPC(host, options) {
+	const internals = getInternals(host);
+	return BrowserView.defineRPC({ handlers: composeRPCHandlers(options.handlers, (message) => {
+		if (internals.disposed) {
+			emitLog(internals.logger, {
+				level: "warn",
+				code: "host-disposed-devtools-message",
+				message: "Dropped devtools-window message because the host has been disposed.",
+				targetId: options.targetId,
+				detail: message
+			});
+			return;
+		}
+		internals.handleDevtoolsMessage(options.targetId, message);
+	}) });
+}
+/**
+* Creates the Bun-side host that pairs application windows with standalone
+* Preact devtools windows.
+*/
+function createPreactDevtoolsHost(options) {
+	const sessions = /* @__PURE__ */ new Map();
+	const ensureSession = (targetId) => {
+		let session = sessions.get(targetId);
+		if (!session) {
+			session = {
+				targetId,
+				appReady: false,
+				devtoolsReady: false,
+				closing: false
+			};
+			sessions.set(targetId, session);
+		}
+		return session;
+	};
+	const host = {
+		createAppWindowRPC({ targetId }) {
+			return composeAppWindowRPC(host, { targetId });
+		},
+		composeAppWindowRPC({ targetId, handlers }) {
+			return composeAppWindowRPC(host, {
+				targetId,
+				handlers
+			});
+		},
+		registerAppWindow({ targetId, window }) {
+			const internals = getInternals(host);
+			const session = internals.ensureSession(targetId);
+			if (session.appWindow && session.appWindow !== window) throw new Error(`Target "${targetId}" is already registered to a different app window.`);
+			if (session.appWindow === window) return;
+			session.appWindow = window;
+			session.closing = false;
+			window.on("close", () => {
+				const active = internals.sessions.get(targetId);
+				if (!active || active.appWindow !== window) return;
+				handleAppWindowClosed(internals, active);
+			});
+		},
+		async open(targetId) {
+			const internals = getInternals(host);
+			if (internals.disposed) throw new Error("Cannot open devtools after the host has been disposed.");
+			const session = internals.sessions.get(targetId);
+			if (!session?.appWindow) throw new Error(`Target "${targetId}" has not been registered.`);
+			if (session.devtoolsWindow) {
+				session.devtoolsWindow.show();
+				session.devtoolsWindow.focus();
+				return session.devtoolsWindow;
+			}
+			if (session.openingPromise) return session.openingPromise;
+			session.openingPromise = Promise.resolve(options.openWindow({
+				targetId,
+				rpc: composeDevtoolsWindowRPC(host, { targetId }),
+				composeRPC({ handlers }) {
+					return composeDevtoolsWindowRPC(host, {
+						targetId,
+						handlers
+					});
+				}
+			})).then((window) => {
+				session.devtoolsWindow = window;
+				session.devtoolsReady = false;
+				session.closing = false;
+				window.on("close", () => {
+					const active = internals.sessions.get(targetId);
+					if (!active || active.devtoolsWindow !== window) return;
+					handleDevtoolsClosed(internals, active, "devtools-closed");
+				});
+				return window;
+			}).finally(() => {
+				const active = internals.sessions.get(targetId);
+				if (active) active.openingPromise = void 0;
+			});
+			return session.openingPromise;
+		},
+		focus(targetId) {
+			const session = getInternals(host).sessions.get(targetId);
+			if (!session?.devtoolsWindow) return false;
+			session.devtoolsWindow.show();
+			session.devtoolsWindow.focus();
+			return true;
+		},
+		async close(targetId) {
+			const session = getInternals(host).sessions.get(targetId);
+			if (!session?.devtoolsWindow) return;
+			session.closing = true;
+			session.devtoolsWindow.close();
+		},
+		isOpen(targetId) {
+			return !!getInternals(host).sessions.get(targetId)?.devtoolsWindow;
+		},
+		getState(targetId) {
+			const session = getInternals(host).sessions.get(targetId);
+			if (!session?.appWindow) return "unregistered";
+			if (session.closing) return "closing";
+			if (session.devtoolsWindow && (!session.devtoolsReady || !session.appReady)) return "devtools-opening";
+			if (session.devtoolsWindow && session.devtoolsReady && session.appReady) return "devtools-connected";
+			if (session.appReady) return "app-connected";
+			return "registered";
+		},
+		dispose() {
+			const internals = getInternals(host);
+			if (internals.disposed) return;
+			internals.disposed = true;
+			for (const session of internals.sessions.values()) {
+				session.closing = true;
+				if (session.appReady && session.appWindow) sendReservedMessage(session.appWindow, {
+					kind: "session-disconnected",
+					reason: "host-disposed"
+				});
+				if (session.devtoolsWindow) closeDevtoolsWindow(session);
+			}
+			internals.sessions.clear();
+		}
+	};
+	const internals = {
+		options,
+		logger: options.logger,
+		sessions,
+		disposed: false,
+		ensureSession,
+		handleAppMessage(targetId, message) {
+			const session = ensureSession(targetId);
+			switch (message.kind) {
+				case "bridge-ready":
+					session.appReady = true;
+					session.closing = false;
+					connectSession(session);
+					return;
+				case "bridge-disposed":
+					session.appReady = false;
+					if (session.devtoolsWindow) {
+						sendReservedMessage(session.devtoolsWindow, {
+							kind: "connection-state",
+							connected: false,
+							targetId
+						});
+						sendReservedMessage(session.devtoolsWindow, {
+							kind: "clear-store",
+							reason: "target-reset"
+						});
+					}
+					return;
+				case "hook-event":
+					if (!session.devtoolsWindow || !session.devtoolsReady) return;
+					sendReservedMessage(session.devtoolsWindow, {
+						kind: "deliver-event",
+						type: message.type,
+						data: message.data
+					});
+					return;
+			}
+		},
+		handleDevtoolsMessage(targetId, message) {
+			const session = ensureSession(targetId);
+			switch (message.kind) {
+				case "view-ready":
+					session.devtoolsReady = true;
+					connectSession(session);
+					return;
+				case "view-disposed":
+					handleDevtoolsClosed(internals, session, "devtools-closed");
+					return;
+				case "ui-command":
+					if (unsupportedDevtoolsCommands.has(message.type)) {
+						emitLog(internals.logger, {
+							level: "warn",
+							code: "unsupported-devtools-command",
+							message: `Dropped unsupported devtools command "${message.type}".`,
+							targetId,
+							detail: message
+						});
+						return;
+					}
+					if (!session.appReady || !session.appWindow) {
+						emitLog(internals.logger, {
+							level: "warn",
+							code: "dropped-devtools-command",
+							message: "Dropped devtools command because the target bridge is not connected.",
+							targetId,
+							detail: message
+						});
+						return;
+					}
+					sendReservedMessage(session.appWindow, {
+						kind: "devtools-command",
+						type: message.type,
+						data: message.data
+					});
+					return;
+			}
+		}
+	};
+	hostInternals.set(host, internals);
+	return host;
+}
+//#endregion
+export { composeAppWindowRPC, composeDevtoolsWindowRPC, createPreactDevtoolsHost };

package/dist/devtools-view.d.mts

@@ -0,0 +1,36 @@
+import { d as PreactDevtoolsDevtoolsWindowRPC } from "./index-ohWyACpe.mjs";
+import { n as PreactDevtoolsLogger, t as ComposeRPCHandlers } from "./rpc-Ct-cJYzf.mjs";
+import { ElectrobunRPCSchema, Electroview } from "electrobun/view";
+
+//#region src/devtools-view/controller.d.ts
+/** Options for mounting the standalone devtools UI inside a browser window. */
+interface MountPreactDevtoolsWindowOptions {
+  container: HTMLElement;
+  electroview?: Electroview<any>;
+  logger?: PreactDevtoolsLogger;
+}
+/** Handle returned by `mountPreactDevtoolsWindow(...)`. */
+interface MountedPreactDevtoolsWindow {
+  dispose(): void;
+}
+/**
+ * Mounts the vendored Preact devtools UI into the current browser window and
+ * connects it to the Bun host over Electrobun RPC.
+ */
+declare function mountPreactDevtoolsWindow(options: MountPreactDevtoolsWindowOptions): MountedPreactDevtoolsWindow;
+//#endregion
+//#region src/devtools-view/rpc.d.ts
+/** The browser-side RPC definition type returned by `Electroview.defineRPC(...)`. */
+type ViewRPCDefinition<Schema extends ElectrobunRPCSchema = ElectrobunRPCSchema> = ReturnType<typeof Electroview.defineRPC<Schema>>;
+/** Consumer-owned webview handlers that are merged with the reserved devtools message channel. */
+type ViewComposeRPCHandlers<Schema extends ElectrobunRPCSchema> = ComposeRPCHandlers<Schema, 'webview'>;
+/**
+ * Creates the devtools-window `Electroview.defineRPC(...)` result for windows
+ * that already have their own webview RPC handlers.
+ */
+declare function composeDevtoolsWindowViewRPC<TRPC extends PreactDevtoolsDevtoolsWindowRPC>(options: {
+  handlers?: ViewComposeRPCHandlers<TRPC>;
+  maxRequestTime?: number;
+}): ViewRPCDefinition<TRPC>;
+//#endregion
+export { type MountPreactDevtoolsWindowOptions, type MountedPreactDevtoolsWindow, type ViewComposeRPCHandlers, type ViewRPCDefinition, composeDevtoolsWindowViewRPC, mountPreactDevtoolsWindow };