bunite-core 0.0.12 → 0.0.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
   "scripts": {
     "setup:cef": "bun ../tools/bunite-dev/scripts/setup-cef.ts",

package/src/bun/core/BrowserView.ts

@@ -2,7 +2,7 @@ import { ptr } from "bun:ffi";
 import { buildViewPreloadScript } from "../preload/inline";
 import { log } from "../../shared/log";
 import { buniteEventEmitter } from "../events/eventEmitter";
-import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport, type RPCRequestHandler } from "../../shared/rpc";
+import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport } from "../../shared/rpc";
 import { createWebRPCHandler } from "../../shared/webRpcHandler";
 import { ensureNativeRuntime, getNativeLibrary, toCString, waitForViewReady, cancelWaitForViewReady } from "../proc/native";
 import { attachBrowserViewRegistry, getRPCPort, sendMessageToView } from "./Socket";
@@ -165,8 +165,11 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
     config: BuniteRPCConfig<Schema, "bun">
   ) {
     const rpc = defineBuniteRPC("bun", config);
+    const webRpc = createWebRPCHandler<Schema>(config);
     return Object.assign(rpc, {
-      webHandler: createWebRPCHandler((config.handlers.requests ?? {}) as any)
+      webHandler: webRpc,
+      webClients: webRpc.webClients,
+      broadcast: webRpc.broadcast,
     });
   }
 

package/src/shared/rpc.ts

@@ -343,6 +343,16 @@ export function createRPC<
     ) => void;
   };
 
+  function dispose() {
+    for (const [id, pending] of pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("RPC disposed"));
+    }
+    pendingRequests.clear();
+    transport.unregisterHandler?.();
+    transport = {};
+  }
+
   return {
     setTransport,
     setRequestHandler,
@@ -352,6 +362,7 @@ export function createRPC<
     sendProxy,
     addMessageListener,
     removeMessageListener,
+    dispose,
     proxy: {
       request: requestProxy,
       send: sendProxy

package/src/shared/webRpcHandler.ts

@@ -1,48 +1,102 @@
+import {
+  defineBuniteRPC,
+  type BuniteRPCConfig,
+  type BuniteRPCSchema,
+  type RPCTransport,
+  type RPCPacket
+} from "./rpc";
 import { decodeRPCPacket, encodeRPCPacket, asUint8Array } from "./rpcWire";
+import { log } from "./log";
 
-type WebRPCHandlers = Record<string, (params?: unknown) => unknown>;
+type WebRPCSocket = { send(data: Uint8Array | ArrayBuffer): void | number };
 
-/** Minimal ws interface compatible with Bun's ServerWebSocket. */
-type WebRPCSocket = { send(data: Uint8Array): void | number };
+export type WebRPCClient<Schema extends BuniteRPCSchema = BuniteRPCSchema> = {
+  ws: WebRPCSocket;
+  rpc: ReturnType<typeof defineBuniteRPC<Schema, "bun">>;
+  handlePacket: (packet: RPCPacket) => void | Promise<void>;
+};
 
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
+export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
+  config: BuniteRPCConfig<Schema, "bun"> & {
+    extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
+  }
+) {
+  const connections = new WeakMap<WebRPCSocket, WebRPCClient<Schema>>();
+  const webClients = new Set<WebRPCClient<Schema>>();
+
+  const handler = {
+    open(ws: WebRPCSocket) {
+      let handlePacket: ((packet: RPCPacket) => void | Promise<void>) | undefined;
+
+      const transport: RPCTransport = {
+        send(packet) {
+          ws.send(encodeRPCPacket(packet));
+        },
+        registerHandler(h) {
+          handlePacket = h;
+        },
+        unregisterHandler() {
+          handlePacket = undefined;
+        }
+      };
+
+      const rpc = defineBuniteRPC("bun", config);
+      rpc.setTransport(transport);
+
+      const client: WebRPCClient<Schema> = {
+        ws,
+        rpc: rpc as WebRPCClient<Schema>["rpc"],
+        handlePacket: (packet) => handlePacket?.(packet)
+      };
+
+      connections.set(ws, client);
+      webClients.add(client);
+      handler.onWebClientConnected?.(client);
+    },
 
-export function createWebRPCHandler(handlers: WebRPCHandlers) {
-  return {
-    message(ws: WebRPCSocket, raw: string | Buffer) {
+    message(ws: WebRPCSocket, raw: string | Buffer | ArrayBuffer | Uint8Array) {
       if (typeof raw === "string") return;
 
-      let packet;
+      const client = connections.get(ws);
+      if (!client) return;
+
       try {
-        packet = decodeRPCPacket(asUint8Array(raw));
+        Promise.resolve(client.handlePacket(decodeRPCPacket(asUint8Array(raw)))).catch((error) => {
+          log.error("Web RPC packet handler error", error);
+        });
       } catch {
-        return;
+        // malformed packet — decode failure
       }
+    },
 
-      if (packet.type !== "request" || typeof packet.method !== "string") return;
+    close(ws: WebRPCSocket) {
+      const client = connections.get(ws);
+      if (!client) return;
 
-      const handler = handlers[packet.method];
-      if (!handler) {
-        ws.send(
-          encodeRPCPacket({ type: "response", id: packet.id, success: false, error: `Unknown method: ${packet.method}` })
-        );
-        return;
-      }
+      client.rpc.dispose();
+      webClients.delete(client);
+      connections.delete(ws);
+      handler.onWebClientDisconnected?.(client);
+    },
 
-      try {
-        Promise.resolve(handler(packet.params)).then(
-          (payload) =>
-            ws.send(encodeRPCPacket({ type: "response", id: packet.id, success: true, payload })),
-          (error) =>
-            ws.send(encodeRPCPacket({ type: "response", id: packet.id, success: false, error: errorMessage(error) }))
-        );
-      } catch (error) {
-        ws.send(
-          encodeRPCPacket({ type: "response", id: packet.id, success: false, error: errorMessage(error) })
-        );
+    webClients: webClients as ReadonlySet<WebRPCClient<Schema>>,
+
+    broadcast<M extends keyof Schema["bun"]["messages"]>(
+      messageName: M,
+      ...args: void extends Schema["bun"]["messages"][M]
+        ? []
+        : undefined extends Schema["bun"]["messages"][M]
+          ? [payload?: Schema["bun"]["messages"][M]]
+          : [payload: Schema["bun"]["messages"][M]]
+    ) {
+      for (const client of webClients) {
+        (client.rpc.send as any)(messageName, ...args);
       }
-    }
+    },
+
+    onWebClientConnected: undefined as ((client: WebRPCClient<Schema>) => void) | undefined,
+    onWebClientDisconnected: undefined as ((client: WebRPCClient<Schema>) => void) | undefined,
   };
+
+  return handler;
 }