electrobun 1.18.4-beta.3 → 1.18.4-beta.5

package/README.md

@@ -63,6 +63,7 @@ Don't miss our:
 - [GOG Achievements GUI](https://github.com/timendum/gog-achievements-gui) - desktop app for managing GOG achievements
 - [groov](https://github.com/laurenzcodes/groov) - desktop audio deck monitor
 - [Guerilla Glass](https://github.com/okikeSolutions/guerillaglass) - open-source cross-platform creator studio for fast Record -> Edit -> Deliver workflows
+- [Invoke](https://getinvoke.com) - macOS UI automation & shortcut platform
 - [Marginalia](https://github.com/lars-hoeijmans/Marginalia) - a simple note taking app
 - [MarkBun](https://github.com/xiaochong/markbun) - fast, beautiful, Typora-like markdown desktop editor
 - [md-browse](https://github.com/needle-tools/md-browse) - a markdown-first browser that converts web pages to clean markdown

package/dist/api/browser/global.d.ts

@@ -7,6 +7,8 @@ interface ElectrobunEncryptResult {
 }
 
 interface ElectrobunBridge {
+  receiveMessageFromHost: (msg: unknown) => void;
+  receiveInternalMessageFromHost: (msg: unknown) => void;
   receiveMessageFromBun: (msg: unknown) => void;
   receiveInternalMessageFromBun: (msg: unknown) => void;
 }
@@ -20,10 +22,13 @@ declare global {
     __electrobunWebviewId: number;
     __electrobunWindowId: number;
     __electrobunRpcSocketPort: number;
+    __electrobunHostSocketPort?: number;
     __electrobun?: ElectrobunBridge;
+    __electrobunPendingHostMessages?: unknown[];
     __electrobun_encrypt: (msg: string) => Promise<ElectrobunEncryptResult>;
     __electrobun_decrypt: (encryptedData: string, iv: string, tag: string) => Promise<string>;
     __electrobunInternalBridge?: MessageHandler;
+    __electrobunHostBridge?: MessageHandler;
     __electrobunBunBridge?: MessageHandler;
   }
 }

package/dist/api/browser/index.ts

@@ -15,13 +15,23 @@ import { type WgpuTagElement, type WgpuEventTypes } from "./wgputag";
 import "./global.d.ts";
 
 const WEBVIEW_ID = window.__electrobunWebviewId;
-const RPC_SOCKET_PORT = window.__electrobunRpcSocketPort;
+const HOST_SOCKET_PORT =
+	window.__electrobunHostSocketPort ?? window.__electrobunRpcSocketPort;
 
 class Electroview<T extends RPCWithTransport> {
-	bunSocket?: WebSocket;
+	hostSocket?: WebSocket;
+	hostSocketCanSend = false;
 	// user's custom rpc browser <-> bun
 	rpc?: T;
 	rpcHandler?: (msg: unknown) => void;
+	carrots = {
+		invoke: <R = unknown>(
+			carrotId: string,
+			method: string,
+			params?: unknown,
+			options?: { windowId?: string },
+		) => this.invokeCarrot<R>(carrotId, method, params, options),
+	};
 
 	constructor(config: { rpc: T }) {
 		this.rpc = config.rpc;
@@ -29,34 +39,42 @@ class Electroview<T extends RPCWithTransport> {
 	}
 
 	init() {
-		this.initSocketToBun();
+		this.initSocketToHost();
 
-		// Set up handler for user RPC messages from bun
-		// Note: receiveInternalMessageFromBun is set up by the preload script
-		window.__electrobun!.receiveMessageFromBun =
-			this.receiveMessageFromBun.bind(this);
+		// Set up handler for user RPC messages from the host runtime.
+		const hostMessageHandler = this.receiveMessageFromHost.bind(this);
+		window.__electrobun!.receiveMessageFromHost = hostMessageHandler;
+		window.__electrobun!.receiveMessageFromBun = hostMessageHandler;
 
 		if (this.rpc) {
 			this.rpc.setTransport(this.createTransport());
 		}
+
+		const pendingMessages = window.__electrobunPendingHostMessages;
+		if (pendingMessages?.length) {
+			window.__electrobunPendingHostMessages = [];
+			for (const message of pendingMessages) {
+				hostMessageHandler(message);
+			}
+		}
 	}
 
-	initSocketToBun() {
+	initSocketToHost() {
 		// Skip native socket when running in a remote browser (no port/webview ID)
-		if (!RPC_SOCKET_PORT || !WEBVIEW_ID) {
+		if (!HOST_SOCKET_PORT || !WEBVIEW_ID) {
 			return;
 		}
 
-		// Note: Using ws:// for localhost is intentional - all RPC messages are
+		// Note: Using ws:// for loopback is intentional - all RPC messages are
 		// encrypted with per-webview AES-GCM keys, making TLS redundant
 		const socket = new WebSocket(
-			`ws://localhost:${RPC_SOCKET_PORT}/socket?webviewId=${WEBVIEW_ID}`,
+			`ws://127.0.0.1:${HOST_SOCKET_PORT}/socket?webviewId=${WEBVIEW_ID}`,
 		);
 
-		this.bunSocket = socket;
+		this.hostSocket = socket;
 
 		socket.addEventListener("open", () => {
-			// this.bunSocket?.send("Hello from webview " + WEBVIEW_ID);
+			this.hostSocketCanSend = true;
 		});
 
 		socket.addEventListener("message", async (event) => {
@@ -71,6 +89,7 @@ class Electroview<T extends RPCWithTransport> {
 						encryptedPacket.tag,
 					);
 
+					this.hostSocketCanSend = true;
 					this.rpcHandler?.(JSON.parse(decrypted));
 				} catch (err) {
 					console.error("Error parsing bun message:", err);
@@ -83,10 +102,12 @@ class Electroview<T extends RPCWithTransport> {
 		});
 
 		socket.addEventListener("error", (event) => {
+			this.hostSocketCanSend = false;
 			console.error("Socket error:", event);
 		});
 
 		socket.addEventListener("close", (_event) => {
+			this.hostSocketCanSend = false;
 			// console.log("Socket closed:", event);
 		});
 	}
@@ -97,9 +118,9 @@ class Electroview<T extends RPCWithTransport> {
 			send(message: unknown) {
 				try {
 					const messageString = JSON.stringify(message);
-					that.bunBridge(messageString);
+					that.sendMessageToHost(messageString);
 				} catch (error) {
-					console.error("bun: failed to serialize message to webview", error);
+					console.error("host: failed to serialize message to webview", error);
 				}
 			},
 			registerHandler(handler: (msg: unknown) => void) {
@@ -108,8 +129,11 @@ class Electroview<T extends RPCWithTransport> {
 		};
 	}
 
-	async bunBridge(msg: string) {
-		if (this.bunSocket?.readyState === WebSocket.OPEN) {
+	async sendMessageToHost(msg: string) {
+		if (
+			this.hostSocketCanSend &&
+			this.hostSocket?.readyState === WebSocket.OPEN
+		) {
 			try {
 				const { encryptedData, iv, tag } =
 					await window.__electrobun_encrypt(msg);
@@ -120,24 +144,42 @@ class Electroview<T extends RPCWithTransport> {
 					tag: tag,
 				};
 				const encryptedPacketString = JSON.stringify(encryptedPacket);
-				this.bunSocket.send(encryptedPacketString);
+				this.hostSocket.send(encryptedPacketString);
 				return;
 			} catch (error) {
-				console.error("Error sending message to bun via socket:", error);
+				console.error("Error sending message to host via socket:", error);
 			}
 		}
 
 		// if socket's are unavailable, fallback to postMessage
-		window.__electrobunBunBridge?.postMessage(msg);
+		window.__electrobunHostBridge?.postMessage(msg);
 	}
 
-	receiveMessageFromBun(msg: unknown) {
-		// NOTE: in the webview messages are passed by executing ElectrobunView.receiveMessageFromBun(object)
+	receiveMessageFromHost(msg: unknown) {
+		// NOTE: in the webview messages are passed by executing window.__electrobun.receiveMessageFromHost(object)
 		// so they're already parsed into an object here
 		if (this.rpcHandler) {
 			this.rpcHandler(msg);
 		}
 	}
+
+	async invokeCarrot<R = unknown>(
+		carrotId: string,
+		method: string,
+		params?: unknown,
+		options?: { windowId?: string },
+	): Promise<R> {
+		const requestProxy = (this.rpc as any)?.request;
+		if (!requestProxy || typeof requestProxy.invokeCarrot !== "function") {
+			throw new Error("Renderer carrot invocation is not available in this Electrobun host.");
+		}
+		return requestProxy.invokeCarrot({
+			carrotId,
+			method,
+			params,
+			windowId: options?.windowId,
+		}) as Promise<R>;
+	}
 	static defineRPC<Schema extends ElectrobunRPCSchema>(
 		config: ElectrobunRPCConfig<Schema, "webview">,
 	) {

package/dist/api/bun/ElectrobunConfig.ts

@@ -13,6 +13,28 @@ type BunBuildOptions = Omit<
 	"entrypoints" | "outdir" | "target"
 >;
 
+type CarrotFileActivatorConfig = {
+	baseName?: string;
+	nodeType?: "file" | "dir" | "any";
+	slate: {
+		type: string;
+		name?: string;
+		icon?: string;
+		config?: Record<string, unknown>;
+	};
+};
+
+type CarrotContributionsConfig = {
+	fileActivators?: CarrotFileActivatorConfig[];
+};
+
+type CarrotUIDefinition = {
+	name?: string;
+	entrypoint?: string;
+	path?: string;
+	[key: string]: unknown;
+};
+
 export interface ElectrobunConfig {
 	/**
 	 * Application metadata configuration
@@ -264,7 +286,9 @@ export interface ElectrobunConfig {
 			carrotOnly?: boolean;
 			permissions?: Record<string, unknown>;
 			dependencies?: Record<string, string>;
-			remoteUIs?: Record<string, { entrypoint: string; [key: string]: unknown }>;
+			remoteUIs?: Record<string, CarrotUIDefinition>;
+			slateUIs?: Record<string, CarrotUIDefinition>;
+			contributions?: CarrotContributionsConfig;
 		};
 
 		/**

package/dist/api/bun/core/BrowserView.ts

@@ -177,23 +177,23 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 		this.rpc!.setTransport(this.createTransport());
 	}
 
-	sendMessageToWebviewViaExecute(jsonMessage: unknown) {
+	sendHostMessageToWebviewViaExecute(jsonMessage: unknown) {
 		const stringifiedMessage =
 			typeof jsonMessage === "string"
 				? jsonMessage
 				: JSON.stringify(jsonMessage);
 		// todo (yoav): make this a shared const with the browser api
-		const wrappedMessage = `window.__electrobun.receiveMessageFromBun(${stringifiedMessage})`;
+		const wrappedMessage = `window.__electrobun.receiveMessageFromHost(${stringifiedMessage})`;
 		this.executeJavascript(wrappedMessage);
 	}
 
-	sendInternalMessageViaExecute(jsonMessage: unknown) {
+	sendInternalHostMessageViaExecute(jsonMessage: unknown) {
 		const stringifiedMessage =
 			typeof jsonMessage === "string"
 				? jsonMessage
 				: JSON.stringify(jsonMessage);
 		// todo (yoav): make this a shared const with the browser api
-		const wrappedMessage = `window.__electrobun.receiveInternalMessageFromBun(${stringifiedMessage})`;
+		const wrappedMessage = `window.__electrobun.receiveInternalMessageFromHost(${stringifiedMessage})`;
 		this.executeJavascript(wrappedMessage);
 	}
 
@@ -312,9 +312,9 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 				if (!sentOverSocket) {
 					try {
 						const messageString = JSON.stringify(message);
-						that.sendMessageToWebviewViaExecute(messageString);
+						that.sendHostMessageToWebviewViaExecute(messageString);
 					} catch (error) {
-						console.error("bun: failed to serialize message to webview", error);
+						console.error("host: failed to serialize message to webview", error);
 					}
 				}
 			},
@@ -328,7 +328,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	};
 
 	remove() {
-		if (!this.ptr || this.isRemoved) {
+		if (this.isRemoved) {
 			return;
 		}
 		this.isRemoved = true;
@@ -341,13 +341,72 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 			unregisterHandler() {},
 		});
 		this.rpcHandler = undefined;
-		ffi.request.webviewRemove({ id: this.id });
+		try {
+			ffi.request.webviewRemove({ id: this.id });
+		} catch (error) {
+			console.error(`Error removing webview ${this.id}:`, error);
+		}
 	}
 
 	static getById(id: number) {
 		return BrowserViewMap[id];
 	}
 
+	// Core can create webviews before Bun has constructed a JS wrapper for them.
+	// Use this in native/runtime paths that need to ensure a wrapper exists.
+	static ensureWrapped<T extends RPCWithTransport = RPCWithTransport>(
+		id: number,
+		options: Partial<BrowserViewOptions<T>> = {},
+	) {
+		return (
+			(BrowserViewMap[id] as BrowserView<T> | undefined) ??
+			BrowserView.adoptExisting(id, options)
+		);
+	}
+
+	static adoptExisting<T extends RPCWithTransport = RPCWithTransport>(
+		id: number,
+		options: Partial<BrowserViewOptions<T>> = {},
+	) {
+		const existing = BrowserViewMap[id] as BrowserView<T> | undefined;
+		if (existing) {
+			return existing;
+		}
+
+		const ptr = ffi.request.getWebviewPointer({ id }) as Pointer | null;
+		if (!ptr) {
+			return undefined;
+		}
+
+		const view = Object.create(BrowserView.prototype) as BrowserView<T>;
+		view.id = id;
+		view.hostWebviewId = options.hostWebviewId;
+		view.windowId = options.windowId ?? 0;
+		view.renderer = options.renderer ?? defaultOptions.renderer ?? "native";
+		view.url = options.url ?? defaultOptions.url ?? null;
+		view.html = options.html ?? defaultOptions.html ?? null;
+		view.preload = options.preload ?? defaultOptions.preload ?? null;
+		view.viewsRoot = options.viewsRoot ?? defaultOptions.viewsRoot ?? null;
+		view.partition = options.partition ?? null;
+		view.frame = {
+			x: options.frame?.x ?? defaultOptions.frame!.x,
+			y: options.frame?.y ?? defaultOptions.frame!.y,
+			width: options.frame?.width ?? defaultOptions.frame!.width,
+			height: options.frame?.height ?? defaultOptions.frame!.height,
+		};
+		view.secretKey = new Uint8Array(0);
+		view.rpc = options.rpc;
+		view.rpcHandler = undefined;
+		view.autoResize = options.autoResize === false ? false : true;
+		view.navigationRules = options.navigationRules ?? null;
+		view.sandbox = options.sandbox ?? false;
+		view.startTransparent = options.startTransparent ?? false;
+		view.startPassthrough = options.startPassthrough ?? false;
+		view.isRemoved = false;
+		BrowserViewMap[id] = view as BrowserView<any>;
+		return view;
+	}
+
 	static getAll() {
 		return Object.values(BrowserViewMap);
 	}

package/dist/api/bun/core/BrowserWindow.ts

@@ -3,12 +3,13 @@ import electrobunEventEmitter from "../events/eventEmitter";
 import { BrowserView } from "./BrowserView";
 import { type Pointer } from "bun:ffi";
 import { BuildConfig } from "./BuildConfig";
-import { quit } from "./Utils";
 import { type RPCWithTransport } from "../../shared/rpc.js";
-import { GpuWindowMap } from "./GpuWindow";
 import { WGPUView } from "./WGPUView";
 
 const buildConfig = BuildConfig.getSync();
+ffi.request.setExitOnLastWindowClosed({
+	enabled: buildConfig.runtime?.exitOnLastWindowClosed ?? true,
+});
 
 export type WindowOptionsType<T = undefined> = {
 	trafficLightOffset?: {
@@ -72,7 +73,7 @@ export const BrowserWindowMap: {
 	[id: number]: BrowserWindow<RPCWithTransport>;
 } = {};
 
-// Clean up the window map when a window closes and optionally quit the app
+// Clean up JS wrapper state when a window closes. Native child cleanup is core-owned.
 electrobunEventEmitter.on("close", (event: { data: { id: number } }) => {
 	const windowId = event.data.id;
 	delete BrowserWindowMap[windowId];
@@ -88,30 +89,12 @@ electrobunEventEmitter.on("close", (event: { data: { id: number } }) => {
 	const wgpuViews = WGPUView.getAll().filter(v => v.windowId === windowId);
 	for (const view of wgpuViews) {
 		try {
-			// If ptr is null, the view was already cleaned up by the renderer or native cleanup
-			if (view.ptr === null) {
-				// Already cleaned up, skip
-			} else {
-				// Programmatic close path - remove the view
-				view.remove();
-			}
+			view.remove();
 		} catch (e) {
 			console.error(`Error cleaning up WGPU view ${view.id}:`, e);
-			// If remove() failed, at least mark it as cleaned up
-			view.ptr = null as any;
 		}
 	}
 
-	const exitOnLastWindowClosed =
-		buildConfig.runtime?.exitOnLastWindowClosed ?? true;
-
-	if (
-		exitOnLastWindowClosed &&
-		Object.keys(BrowserWindowMap).length === 0 &&
-		Object.keys(GpuWindowMap).length === 0
-	) {
-		quit();
-	}
 });
 
 export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {

package/dist/api/bun/core/GpuWindow.ts

@@ -2,6 +2,7 @@ import { ffi } from "../proc/native";
 import electrobunEventEmitter from "../events/eventEmitter";
 import { type Pointer } from "bun:ffi";
 import { WGPUView } from "./WGPUView";
+import { BuildConfig } from "./BuildConfig";
 
 
 export type GpuWindowOptionsType = {
@@ -34,11 +35,16 @@ const defaultOptions: GpuWindowOptionsType = {
 	transparent: false,
 };
 
+const buildConfig = BuildConfig.getSync();
+ffi.request.setExitOnLastWindowClosed({
+	enabled: buildConfig.runtime?.exitOnLastWindowClosed ?? true,
+});
+
 export const GpuWindowMap: {
 	[id: number]: GpuWindow;
 } = {};
 
-// Clean up the window map when a window closes and optionally quit the app
+// Clean up JS wrapper state when a window closes. Native child cleanup is core-owned.
 electrobunEventEmitter.on("close", (event: { data: { id: number } }) => {
 	const windowId = event.data.id;
 	delete GpuWindowMap[windowId];

package/dist/api/bun/core/Socket.ts

@@ -1,205 +1,22 @@
-import type { Server, ServerWebSocket } from "bun";
-import { BrowserView } from "./BrowserView";
-import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
-
-function base64ToUint8Array(base64: string) {
-	{
-		return new Uint8Array(
-			atob(base64)
-				.split("")
-				.map((char) => char.charCodeAt(0)),
-		);
-	}
-}
-
-// Encrypt function
-function encrypt(secretKey: Uint8Array, text: string) {
-	const iv = new Uint8Array(randomBytes(12)); // IV for AES-GCM
-	const cipher = createCipheriv("aes-256-gcm", secretKey, iv);
-	const encrypted = Buffer.concat([
-		new Uint8Array(cipher.update(text, "utf8")),
-		new Uint8Array(cipher.final()),
-	]).toString("base64");
-	const tag = cipher.getAuthTag().toString("base64");
-	return { encrypted, iv: Buffer.from(iv).toString("base64"), tag };
-}
-
-// Decrypt function
-function decrypt(
-	secretKey: Uint8Array,
-	encryptedData: Uint8Array,
-	iv: Uint8Array,
-	tag: Uint8Array,
-) {
-	const decipher = createDecipheriv("aes-256-gcm", secretKey, iv);
-	decipher.setAuthTag(tag);
-	const decrypted = Buffer.concat([
-		new Uint8Array(decipher.update(encryptedData)),
-		new Uint8Array(decipher.final()),
-	]);
-	return decrypted.toString("utf8");
-}
-
-export const socketMap: {
-	[webviewId: string]: {
-		socket: null | ServerWebSocket<unknown>;
-		queue: string[];
-	};
-} = {};
+import { ffi } from "../proc/native";
 
 export const removeSocketForWebview = (webviewId: number) => {
-	const rpc = socketMap[webviewId];
-	if (!rpc) return;
-
-	rpc.socket = null;
-	delete socketMap[webviewId];
+	ffi.request.clearWebviewHostTransport({ id: webviewId });
 };
 
-const startRPCServer = () => {
-	const startPort = 50000;
-	const endPort = 65535;
-	const payloadLimit = 1024 * 1024 * 500; // 500MB
-	let port = startPort;
-	let server = null;
-
-	while (port <= endPort) {
-		try {
-			server = Bun.serve<{ webviewId: number }>({
-				port,
-				fetch(req: Request, server: Server<{ webviewId: number }>) {
-					const url = new URL(req.url);
-					//   const token = new URL(req.url).searchParams.get("token");
-					//   if (token !== AUTH_TOKEN)
-					//     return new Response("Unauthorized", { status: 401 });
-					//   console.log("fetch!!", url.pathname);
-					if (url.pathname === "/socket") {
-						const webviewIdString = url.searchParams.get("webviewId");
-						if (!webviewIdString) {
-							return new Response("Missing webviewId", { status: 400 });
-						}
-						const webviewId = parseInt(webviewIdString, 10);
-						const success = server.upgrade(req, { data: { webviewId } });
-						return success
-							? undefined
-							: new Response("Upgrade failed", { status: 500 });
-					}
-
-					console.log("unhandled RPC Server request", req.url);
-				},
-				websocket: {
-					idleTimeout: 960,
-					// 500MB max payload should be plenty
-					maxPayloadLength: payloadLimit,
-					// Anything beyond the backpressure limit will be dropped
-					backpressureLimit: payloadLimit * 2,
-					open(ws: ServerWebSocket<{ webviewId: number }>) {
-						if (!ws?.data) {
-							return;
-						}
-						const { webviewId } = ws.data;
-
-						if (!socketMap[webviewId]) {
-							socketMap[webviewId] = { socket: ws, queue: [] };
-						} else {
-							socketMap[webviewId].socket = ws;
-						}
-					},
-					close(ws: ServerWebSocket<{ webviewId: number }>, _code: number, _reason: string) {
-						if (!ws?.data) {
-							return;
-						}
-						const { webviewId } = ws.data;
-						// console.log("Closed:", webviewId, code, reason);
-						if (socketMap[webviewId]) {
-							socketMap[webviewId].socket = null;
-						}
-					},
-
-					message(ws: ServerWebSocket<{ webviewId: number }>, message: string | Buffer) {
-						if (!ws?.data) {
-							return;
-						}
-						const { webviewId } = ws.data;
-						const browserView = BrowserView.getById(webviewId);
-						if (!browserView) {
-							return;
-						}
-
-						if (browserView.rpcHandler) {
-							if (typeof message === "string") {
-								try {
-									const encryptedPacket = JSON.parse(message);
-									const decrypted = decrypt(
-										browserView.secretKey,
-										base64ToUint8Array(encryptedPacket.encryptedData),
-										base64ToUint8Array(encryptedPacket.iv),
-										base64ToUint8Array(encryptedPacket.tag),
-									);
-
-									// Note: At this point the secretKey for the webview id would
-									// have had to match the encrypted packet data, so we can trust
-									// that this message can be passed to this browserview's rpc
-									// methods.
-									browserView.rpcHandler(JSON.parse(decrypted));
-								} catch (error) {
-									console.log("Error handling message:", error);
-								}
-							} else if (message instanceof ArrayBuffer) {
-								console.log("TODO: Received ArrayBuffer message:", message);
-							}
-						}
-					},
-				},
-			});
-
-			break;
-		} catch (error: any) {
-			if (error.code === "EADDRINUSE") {
-				console.log(`Port ${port} in use, trying next port...`);
-				port++;
-			} else {
-				throw error;
-			}
-		}
-	}
-
-	return { rpcServer: server, rpcPort: port };
-};
-
-export const { rpcServer, rpcPort } = startRPCServer();
-
-// Will return true if message was sent over websocket
-// false if it was not (caller should fallback to postMessage/evaluateJS rpc)
+// Will return true if message was sent over the core-owned websocket transport.
+// False means the caller should fall back to the native bridge / evaluateJS path.
 export const sendMessageToWebviewViaSocket = (
 	webviewId: number,
-	message: any,
+	message: unknown,
 ): boolean => {
-	const rpc = socketMap[webviewId];
-	const browserView = BrowserView.getById(webviewId);
-
-	if (!browserView) return false;
-
-	if (rpc?.socket?.readyState === WebSocket.OPEN) {
-		try {
-			const unencryptedString = JSON.stringify(message);
-			const encrypted = encrypt(browserView.secretKey, unencryptedString);
-
-			const encryptedPacket = {
-				encryptedData: encrypted.encrypted,
-				iv: encrypted.iv,
-				tag: encrypted.tag,
-			};
-
-			const encryptedPacketString = JSON.stringify(encryptedPacket);
-
-			rpc.socket.send(encryptedPacketString);
-			return true;
-		} catch (error) {
-			console.error("Error sending message to webview via socket:", error);
-		}
+	try {
+		return ffi.request.sendHostMessageToWebviewViaTransport({
+			id: webviewId,
+			messageJson: JSON.stringify(message),
+		}) as boolean;
+	} catch (error) {
+		console.error("Error sending message to webview via host transport:", error);
+		return false;
 	}
-
-	return false;
 };
-
-console.log("Server started at", rpcServer?.url.origin);

package/dist/api/bun/core/Utils.ts

@@ -137,9 +137,7 @@ export const quit = () => {
 	}
 
 	if (native) {
-		native.symbols.stopEventLoop();
-		native.symbols.waitForShutdownComplete(5000);
-		native.symbols.forceExit(0);
+		ffi.request.quitGracefully({ code: 0, timeoutMs: 5000 });
 	} else {
 		process.exit(0);
 	}
@@ -150,7 +148,7 @@ const _originalProcessExit = process.exit;
 process.exit = ((code?: number) => {
 	if (native) {
 		if (isQuitting) {
-			native.symbols.forceExit(code ?? 0);
+			ffi.request.quitGracefully({ code: code ?? 0, timeoutMs: 0 });
 			return;
 		}
 		quit();