electrobun 1.18.4-beta.3 → 1.18.4-beta.6

package/dist/api/bun/proc/native.ts

@@ -1,9 +1,9 @@
-import { join } from "path";
+import { dirname, join } from "path";
+import { createReadStream } from "node:fs";
 import electrobunEventEmitter from "../events/eventEmitter";
 import ElectrobunEvent from "../events/event";
 import { BrowserView } from "../core/BrowserView";
 import { WGPUView } from "../core/WGPUView";
-import { rpcPort } from "../core/Socket";
 import {
 	preloadScript,
 	preloadScriptSandboxed,
@@ -12,7 +12,6 @@ import {
 // Menu data reference system to avoid serialization overhead
 const menuDataRegistry = new Map<string, any>();
 let menuDataCounter = 0;
-
 function storeMenuData(data: any): string {
 	const id = `menuData_${++menuDataCounter}`;
 	menuDataRegistry.set(id, data);
@@ -71,6 +70,30 @@ import {
 	type Pointer,
 } from "bun:ffi";
 
+function getElectrobunLibraryPathCandidates(fileName: string) {
+	const candidates = new Set<string>();
+	candidates.add(join(process.cwd(), fileName));
+	if (process.argv0) {
+		candidates.add(join(dirname(process.argv0), fileName));
+	}
+	return Array.from(candidates);
+}
+
+function tryDlopenCandidates<T extends Record<string, { args: FFIType[]; returns: FFIType }>>(
+	fileName: string,
+	symbols: T,
+) {
+	let lastError: unknown = null;
+	for (const candidatePath of getElectrobunLibraryPathCandidates(fileName)) {
+		try {
+			return dlopen(candidatePath, symbols);
+		} catch (error) {
+			lastError = error;
+		}
+	}
+	throw lastError ?? new Error(`Failed to load ${fileName}`);
+}
+
 function getWindowPtr(winId: number) {
 	return core?.symbols.getWindowPointer(winId) || null;
 }
@@ -93,7 +116,7 @@ function ensureWebviewRuntimeConfigured() {
 	}
 
 	const configured = core?.symbols.configureWebviewRuntime(
-		rpcPort,
+		0,
 		toCString(preloadScript),
 		toCString(preloadScriptSandboxed),
 	);
@@ -107,13 +130,11 @@ function ensureWebviewRuntimeConfigured() {
 
 const core = (() => {
 	try {
-		const corePath = join(
-			process.cwd(),
+		const coreFileName =
 			process.platform === "win32"
 				? "ElectrobunCore.dll"
-				: `libElectrobunCore.${suffix}`,
-		);
-		return dlopen(corePath, {
+				: `libElectrobunCore.${suffix}`;
+		return tryDlopenCandidates(coreFileName, {
 			electrobun_core_last_error: {
 				args: [],
 				returns: FFIType.cstring,
@@ -367,6 +388,26 @@ const core = (() => {
 				args: [FFIType.u32, FFIType.cstring],
 				returns: FFIType.void,
 			},
+			sendHostMessageToWebviewViaTransport: {
+				args: [FFIType.u32, FFIType.cstring],
+				returns: FFIType.bool,
+			},
+			popNextQueuedHostMessage: {
+				args: [FFIType.ptr],
+				returns: FFIType.ptr,
+			},
+			getHostMessageWakeupReadFD: {
+				args: [],
+				returns: FFIType.int,
+			},
+			freeCoreString: {
+				args: [FFIType.ptr],
+				returns: FFIType.void,
+			},
+			clearWebviewHostTransport: {
+				args: [FFIType.u32],
+				returns: FFIType.void,
+			},
 			dispatchHostWebviewEvent: {
 				args: [FFIType.u32, FFIType.cstring, FFIType.cstring],
 				returns: FFIType.bool,
@@ -395,6 +436,55 @@ const core = (() => {
 				args: [FFIType.u32],
 				returns: FFIType.f64,
 			},
+			createWGPUView: {
+				args: [
+					FFIType.u32,
+					FFIType.f64,
+					FFIType.f64,
+					FFIType.f64,
+					FFIType.f64,
+					FFIType.bool,
+					FFIType.bool,
+					FFIType.bool,
+				],
+				returns: FFIType.u32,
+			},
+			getWGPUViewPointer: {
+				args: [FFIType.u32],
+				returns: FFIType.ptr,
+			},
+			setWGPUViewFrame: {
+				args: [FFIType.u32, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64],
+				returns: FFIType.void,
+			},
+			resizeWGPUView: {
+				args: [FFIType.u32, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.cstring],
+				returns: FFIType.void,
+			},
+			setWGPUViewTransparent: {
+				args: [FFIType.u32, FFIType.bool],
+				returns: FFIType.void,
+			},
+			setWGPUViewPassthrough: {
+				args: [FFIType.u32, FFIType.bool],
+				returns: FFIType.void,
+			},
+			setWGPUViewHidden: {
+				args: [FFIType.u32, FFIType.bool],
+				returns: FFIType.void,
+			},
+			removeWGPUView: {
+				args: [FFIType.u32],
+				returns: FFIType.void,
+			},
+			getWGPUViewNativeHandle: {
+				args: [FFIType.u32],
+				returns: FFIType.ptr,
+			},
+			runWGPUViewTest: {
+				args: [FFIType.u32],
+				returns: FFIType.void,
+			},
 			createTray: {
 				args: [
 					FFIType.cstring,
@@ -537,6 +627,18 @@ const core = (() => {
 				args: [],
 				returns: FFIType.bool,
 			},
+			setExitOnLastWindowClosed: {
+				args: [FFIType.bool],
+				returns: FFIType.void,
+			},
+			setQuitRequestedHandler: {
+				args: [FFIType.function],
+				returns: FFIType.void,
+			},
+			quitGracefully: {
+				args: [FFIType.i32, FFIType.i32],
+				returns: FFIType.void,
+			},
 		});
 	} catch {
 		return null;
@@ -545,10 +647,8 @@ const core = (() => {
 
 export const native = (() => {
 	try {
-		// Use absolute path to native wrapper DLL to avoid working directory issues
-		// On Windows shortcuts, the working directory may not be set correctly
-		const nativeWrapperPath = join(process.cwd(), `libNativeWrapper.${suffix}`);
-		return dlopen(nativeWrapperPath, {
+		const nativeWrapperFileName = `libNativeWrapper.${suffix}`;
+		return tryDlopenCandidates(nativeWrapperFileName, {
 			// webview
 			initWebview: {
 				args: [
@@ -565,13 +665,13 @@ export const native = (() => {
 					FFIType.function, // decideNavigation: *const fn (u32, [*:0]const u8) callconv(.C) bool,
 					FFIType.function, // webviewEventHandler: *const fn (u32, [*:0]const u8, [*:0]const u8) callconv(.C) void,
 					FFIType.function, // eventBridgeHandler: *const fn (u32, [*:0]const u8) callconv(.C) void (events only, always active)
-					FFIType.function, // bunBridgePostmessageHandler: *const fn (u32, [*:0]const u8) callconv(.C) void (user RPC, disabled in sandbox)
+					FFIType.function, // hostBridgePostmessageHandler: *const fn (u32, [*:0]const u8) callconv(.C) void (user RPC, disabled in sandbox)
 					FFIType.function, // internalBridgeHandler: *const fn (u32, [*:0]const u8) callconv(.C) void (internal RPC, disabled in sandbox)
 					FFIType.cstring, // electrobunPreloadScript
 					FFIType.cstring, // customPreloadScript
 					FFIType.cstring, // viewsRoot
 					FFIType.bool, // transparent
-					FFIType.bool, // sandbox - when true, bunBridge and internalBridge are not set up
+					FFIType.bool, // sandbox - when true, hostBridge and internalBridge are not set up
 				],
 				returns: FFIType.ptr,
 			},
@@ -992,7 +1092,14 @@ function createFfiRequestProxy(ffiRequest: Record<string, Function>): Record<str
 	return new Proxy(ffiRequest, {
 		get(target, method: string) {
 			if (typeof method !== "string") return target[method];
-			return (params?: unknown) => bridge!.requestHost(method, params);
+			return (params?: unknown) => {
+				if (!bridge) {
+					throw new Error(
+						`Electrobun FFI is unavailable and no host bridge exists for request ${method}`,
+					);
+				}
+				return bridge.requestHost(method, params);
+			};
 		},
 	});
 }
@@ -1006,6 +1113,70 @@ function createFfiRequestProxy(ffiRequest: Record<string, Function>): Record<str
 // Non-null accessor for use inside _ffiImpl — these methods are only called when hasFFI is true.
 const core_ = core!;
 const native_ = native!;
+const queuedHostMessageWebviewIdBuf = new Uint32Array(1);
+
+const drainQueuedHostMessages = () => {
+	if (!core) {
+		return;
+	}
+
+	for (;;) {
+		const messagePtr = core_.symbols.popNextQueuedHostMessage(
+			ptr(queuedHostMessageWebviewIdBuf),
+		) as Pointer | null;
+
+		if (!messagePtr) {
+			return;
+		}
+
+		try {
+			const rawMessage = new CString(messagePtr).toString();
+			if (!rawMessage) {
+				continue;
+			}
+
+			const webview = BrowserView.ensureWrapped(
+				queuedHostMessageWebviewIdBuf[0]!,
+			);
+			if (!webview) {
+				continue;
+			}
+
+			webview.rpcHandler?.(JSON.parse(rawMessage));
+		} catch (err) {
+			console.error("error draining queued host message:", err);
+		} finally {
+			core_.symbols.freeCoreString(messagePtr);
+		}
+	}
+};
+
+if (core) {
+	const wakeupReadFd = core_.symbols.getHostMessageWakeupReadFD();
+
+	if (typeof wakeupReadFd === "number" && wakeupReadFd >= 0) {
+		try {
+			const wakeupStream = createReadStream("/dev/null", {
+				fd: wakeupReadFd,
+				autoClose: false,
+			});
+			wakeupStream.on("data", () => {
+				drainQueuedHostMessages();
+			});
+			wakeupStream.on("error", (error) => {
+				console.error("host message wakeup stream failed, falling back to polling:", error);
+				setInterval(drainQueuedHostMessages, 16);
+			});
+		} catch (error) {
+			console.error("failed to start host message wakeup stream, falling back to polling:", error);
+			setInterval(drainQueuedHostMessages, 16);
+		}
+	} else {
+		setInterval(drainQueuedHostMessages, 16);
+	}
+
+	drainQueuedHostMessages();
+}
 
 const _ffiImpl = {
 	request: {
@@ -1446,12 +1617,12 @@ const _ffiImpl = {
 				webviewDecideNavigation,
 				webviewEventJSCallback,
 				eventBridgeHandler,
-				bunBridgePostmessageHandler,
+				hostBridgePostmessageHandler,
 				internalBridgeHandler,
 				toCString(secretKey),
 				toCString(preload || ""),
 				toCString(viewsRoot || ""),
-				sandbox, // When true, bunBridge and internalBridge are not set up in native code
+				sandbox, // When true, hostBridge and internalBridge are not set up in native code
 				startTransparent,
 				startPassthrough,
 			);
@@ -1543,7 +1714,6 @@ const _ffiImpl = {
 		},
 
 		createWGPUView: (params: {
-			id: number;
 			windowId: number;
 			frame: {
 				x: number;
@@ -1554,9 +1724,8 @@ const _ffiImpl = {
 			autoResize: boolean;
 			startTransparent: boolean;
 			startPassthrough: boolean;
-		}): FFIType.ptr => {
+		}): number => {
 			const {
-				id,
 				windowId,
 				frame: { x, y, width, height },
 				autoResize,
@@ -1564,14 +1733,8 @@ const _ffiImpl = {
 				startPassthrough,
 			} = params;
 
-			const windowPtr = getWindowPtr(windowId);
-			if (!windowPtr) {
-				throw `Can't add WGPUView to window. window no longer exists`;
-			}
-
-			const viewPtr = native_.symbols.initWGPUView(
-				id,
-				windowPtr,
+			const viewId = core_.symbols.createWGPUView(
+				windowId,
 				x,
 				y,
 				width,
@@ -1581,11 +1744,14 @@ const _ffiImpl = {
 				startPassthrough,
 			);
 
-			if (!viewPtr) {
+			if (!viewId) {
 				throw "Failed to create WGPUView";
 			}
 
-			return viewPtr;
+			return viewId;
+		},
+		getWGPUViewPointer: (params: { id: number }): Pointer | null => {
+			return core_.symbols.getWGPUViewPointer(params.id) || null;
 		},
 
 		wgpuViewSetFrame: (params: {
@@ -1595,16 +1761,8 @@ const _ffiImpl = {
 			width: number;
 			height: number;
 		}) => {
-			const view = WGPUView.getById(params.id);
-			if (!view?.ptr) {
-				console.error(
-					`wgpuViewSetFrame: WGPUView not found or has no ptr for id ${params.id}`,
-				);
-				return;
-			}
-
-			native_.symbols.wgpuViewSetFrame(
-				view.ptr,
+			core_.symbols.setWGPUViewFrame(
+				params.id,
 				params.x,
 				params.y,
 				params.width,
@@ -1613,66 +1771,28 @@ const _ffiImpl = {
 		},
 
 		wgpuViewSetTransparent: (params: { id: number; transparent: boolean }) => {
-			const view = WGPUView.getById(params.id);
-			if (!view?.ptr) {
-				console.error(
-					`wgpuViewSetTransparent: WGPUView not found or has no ptr for id ${params.id}`,
-				);
-				return;
-			}
-
-			native_.symbols.wgpuViewSetTransparent(view.ptr, params.transparent);
+			core_.symbols.setWGPUViewTransparent(params.id, params.transparent);
 		},
 
 		wgpuViewSetPassthrough: (params: {
 			id: number;
 			passthrough: boolean;
 		}) => {
-			const view = WGPUView.getById(params.id);
-			if (!view?.ptr) {
-				console.error(
-					`wgpuViewSetPassthrough: WGPUView not found or has no ptr for id ${params.id}`,
-				);
-				return;
-			}
-
-			native_.symbols.wgpuViewSetPassthrough(view.ptr, params.passthrough);
+			core_.symbols.setWGPUViewPassthrough(params.id, params.passthrough);
 		},
 
 		wgpuViewSetHidden: (params: { id: number; hidden: boolean }) => {
-			const view = WGPUView.getById(params.id);
-			if (!view?.ptr) {
-				console.error(
-					`wgpuViewSetHidden: WGPUView not found or has no ptr for id ${params.id}`,
-				);
-				return;
-			}
-
-			native_.symbols.wgpuViewSetHidden(view.ptr, params.hidden);
+			core_.symbols.setWGPUViewHidden(params.id, params.hidden);
 		},
 
 		wgpuViewRemove: (params: { id: number }) => {
-			const view = WGPUView.getById(params.id);
-			if (!view?.ptr) {
-				console.error(
-					`wgpuViewRemove: WGPUView not found or has no ptr for id ${params.id}`,
-				);
-				return;
-			}
-
-			native_.symbols.wgpuViewRemove(view.ptr);
+			core_.symbols.removeWGPUView(params.id);
 		},
 		wgpuViewGetNativeHandle: (params: { id: number }): Pointer | null => {
-			const view = WGPUView.getById(params.id);
-			if (!view?.ptr) {
-				console.error(
-					`wgpuViewGetNativeHandle: WGPUView not found or has no ptr for id ${params.id}`,
-				);
-				return null;
-			}
-
-			const handle = native_.symbols.wgpuViewGetNativeHandle(view.ptr);
-			return handle || null;
+			return core_.symbols.getWGPUViewNativeHandle(params.id) || null;
+		},
+		runWGPUViewTest: (params: { id: number }) => {
+			core_.symbols.runWGPUViewTest(params.id);
 		},
 
 		evaluateJavascriptWithNoCompletion: (params: {
@@ -1684,6 +1804,18 @@ const _ffiImpl = {
 				toCString(params.js),
 			);
 		},
+		sendHostMessageToWebviewViaTransport: (params: {
+			id: number;
+			messageJson: string;
+		}): boolean => {
+			return core_.symbols.sendHostMessageToWebviewViaTransport(
+				params.id,
+				toCString(params.messageJson),
+			);
+		},
+		clearWebviewHostTransport: (params: { id: number }) => {
+			core_.symbols.clearWebviewHostTransport(params.id);
+		},
 		webviewOpenDevTools: (params: { id: number }) => {
 			core_.symbols.webviewOpenDevTools(params.id);
 		},
@@ -1699,6 +1831,12 @@ const _ffiImpl = {
 		webviewGetPageZoom: (params: { id: number }): number => {
 			return core_.symbols.webviewGetPageZoom(params.id);
 		},
+		setExitOnLastWindowClosed: (params: { enabled: boolean }) => {
+			core_.symbols.setExitOnLastWindowClosed(params.enabled);
+		},
+		quitGracefully: (params: { code: number; timeoutMs: number }) => {
+			core_.symbols.quitGracefully(params.code, params.timeoutMs);
+		},
 
 		createTray: (params: {
 			title: string;
@@ -2243,7 +2381,7 @@ const getMimeType = new JSCallback(
 
 const getHTMLForWebviewSync = new JSCallback(
 	(webviewId) => {
-		const webview = BrowserView.getById(webviewId);
+		const webview = BrowserView.ensureWrapped(webviewId);
 
 		return toCString(webview?.html || "");
 	},
@@ -2296,7 +2434,7 @@ if (native) {
 		},
 		{ args: [], returns: "void", threadsafe: true },
 	);
-	native_.symbols.setQuitRequestedHandler(quitRequestedCallback);
+	core_.symbols.setQuitRequestedHandler(quitRequestedCallback);
 
 	const globalShortcutCallback = new JSCallback(
 		(acceleratorPtr) => {
@@ -2592,6 +2730,8 @@ const webviewDecideNavigation = new JSCallback(
 );
 
 const webviewEventHandler = (id: number, eventName: string, detail: string) => {
+	BrowserView.ensureWrapped(id);
+
 	core_.symbols.dispatchHostWebviewEvent(
 		id,
 		toCString(eventName),
@@ -2690,7 +2830,7 @@ const webviewEventJSCallback = new JSCallback(
 	},
 );
 
-const bunBridgePostmessageHandler = new JSCallback(
+const hostBridgePostmessageHandler = new JSCallback(
 	(id, msg) => {
 		try {
 			const msgStr = new CString(msg);
@@ -2704,12 +2844,14 @@ const bunBridgePostmessageHandler = new JSCallback(
 			}
 			const msgJson = JSON.parse(rawMessage);
 
-			const webview = BrowserView.getById(id);
-			if (!webview) return;
+			const webview = BrowserView.ensureWrapped(id);
+			if (!webview) {
+				return;
+			}
 
 			webview.rpcHandler?.(msgJson);
 		} catch (err) {
-			console.error("error sending message to bun: ", err);
+			console.error("error sending message to host: ", err);
 		}
 	},
 	{
@@ -3030,14 +3172,14 @@ export const internalRpcHandlers = {
 			);
 		},
 		webviewTagUpdateSrc: (params: { id: number; url: string }) => {
-			const webview = BrowserView.getById(params.id);
+			const webview = BrowserView.ensureWrapped(params.id);
 			if (webview) {
 				webview.url = params.url;
 			}
 			core_.symbols.loadURLInWebView(params.id, toCString(params.url));
 		},
 		webviewTagUpdateHtml: (params: { id: number; html: string }) => {
-			const webview = BrowserView.getById(params.id);
+			const webview = BrowserView.ensureWrapped(params.id);
 			if (!webview) {
 				console.error(`webviewTagUpdateHtml: BrowserView not found for id ${params.id}`);
 				return;
@@ -3047,7 +3189,7 @@ export const internalRpcHandlers = {
 			webview.html = params.html;
 		},
 		webviewTagUpdatePreload: (params: { id: number; preload: string }) => {
-			const webview = BrowserView.getById(params.id);
+			const webview = BrowserView.ensureWrapped(params.id);
 			if (webview) {
 				webview.preload = params.preload;
 			}
@@ -3068,7 +3210,7 @@ export const internalRpcHandlers = {
 			core_.symbols.webviewReload(params.id);
 		},
 		webviewTagRemove: (params: { id: number }) => {
-			const webview = BrowserView.getById(params.id);
+			const webview = BrowserView.ensureWrapped(params.id);
 			if (!webview) {
 				console.error(`webviewTagRemove: BrowserView not found for id ${params.id}`);
 				return;
@@ -3157,7 +3299,7 @@ export const internalRpcHandlers = {
 		},
 		webviewTagSetNavigationRules: (params: { id: number; rules: string[] }) => {
 			const rulesJson = JSON.stringify(params.rules);
-			const webview = BrowserView.getById(params.id);
+			const webview = BrowserView.ensureWrapped(params.id);
 			if (webview) {
 				webview.navigationRules = rulesJson;
 			}

package/dist/api/bun/webGPU.ts

@@ -291,7 +291,7 @@ const WGPU_LIB_NAMES: Record<string, string[]> = {
 };
 
 function findWgpuLibraryPath(): string | null {
-	const envPath = process.env['ELECTROBUN_WGPU_PATH'];
+	const envPath = process.env["ELECTROBUN_WGPU_PATH"];
 	if (envPath && existsSync(envPath)) return envPath;
 
 	const names = WGPU_LIB_NAMES[process.platform] ?? ["libwebgpu_dawn." + suffix];

package/dist/preload-full.js

@@ -236,6 +236,26 @@ class ElectrobunWebviewTag extends HTMLElement {
     if (this._sync)
       this._sync.stop();
   }
+  getInitialNavigationRules() {
+    const rawRules = this.getAttribute("navigation-rules");
+    if (rawRules === null) {
+      return null;
+    }
+    const trimmed = rawRules.trim();
+    if (!trimmed) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!Array.isArray(parsed) || !parsed.every((rule) => typeof rule === "string")) {
+        throw new Error("navigation-rules must be a JSON string array");
+      }
+      return parsed;
+    } catch (error) {
+      console.error("Invalid navigation-rules attribute:", error);
+      return [];
+    }
+  }
   async initWebview() {
     const rect = this.getBoundingClientRect();
     const initialRect = {
@@ -250,6 +270,7 @@ class ElectrobunWebviewTag extends HTMLElement {
     const partition = this.getAttribute("partition");
     const renderer = this.getAttribute("renderer") || "native";
     const masks = this.getAttribute("masks");
+    const navigationRules = this.getInitialNavigationRules();
     const sandbox = this.hasAttribute("sandbox");
     this.sandboxed = sandbox;
     const transparent = this.hasAttribute("transparent");
@@ -264,7 +285,7 @@ class ElectrobunWebviewTag extends HTMLElement {
       masks.split(",").forEach((s) => this.maskSelectors.add(s.trim()));
     }
     try {
-      const webviewId = await request("webviewTagInit", {
+      const webviewInitParams = {
         hostWebviewId: window.__electrobunWebviewId,
         windowId: window.__electrobunWindowId,
         renderer,
@@ -278,11 +299,12 @@ class ElectrobunWebviewTag extends HTMLElement {
           x: rect.x,
           y: rect.y
         },
-        navigationRules: null,
         sandbox,
         transparent,
-        passthrough
-      });
+        passthrough,
+        ...navigationRules === null ? {} : { navigationRules }
+      };
+      const webviewId = await request("webviewTagInit", webviewInitParams);
       this.webviewId = webviewId;
       this.id = `electrobun-webview-${webviewId}`;
       webviewRegistry[webviewId] = this;
@@ -859,18 +881,24 @@ initEncryption().catch((err) => console.error("Failed to initialize encryption:"
 var internalMessageHandler = (msg) => {
   handleResponse(msg);
 };
+var defaultUserMessageHandler = (msg) => {
+  if (!window.__electrobunPendingHostMessages) {
+    window.__electrobunPendingHostMessages = [];
+  }
+  window.__electrobunPendingHostMessages.push(msg);
+};
 if (!window.__electrobun) {
   window.__electrobun = {
+    receiveInternalMessageFromHost: internalMessageHandler,
+    receiveMessageFromHost: defaultUserMessageHandler,
     receiveInternalMessageFromBun: internalMessageHandler,
-    receiveMessageFromBun: (msg) => {
-      console.log("receiveMessageFromBun (no handler):", msg);
-    }
+    receiveMessageFromBun: defaultUserMessageHandler
   };
 } else {
+  window.__electrobun.receiveInternalMessageFromHost = internalMessageHandler;
+  window.__electrobun.receiveMessageFromHost = defaultUserMessageHandler;
   window.__electrobun.receiveInternalMessageFromBun = internalMessageHandler;
-  window.__electrobun.receiveMessageFromBun = (msg) => {
-    console.log("receiveMessageFromBun (no handler):", msg);
-  };
+  window.__electrobun.receiveMessageFromBun = defaultUserMessageHandler;
 }
 window.__electrobunSendToHost = (message) => {
   emitWebviewEvent("host-message", JSON.stringify(message));