bunite-core 0.0.14 → 0.2.0

package/package.json

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

package/src/bun/core/App.ts

@@ -31,6 +31,10 @@ type AppOptions = NativeBootstrapOptions & {
 
 export type GlobalIPCHandler = (params: unknown, ctx: { viewId: number }) => unknown | Promise<unknown>;
 
+function normalizeAppResPath(path: string): string {
+  return path.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
 export class AppRuntime {
   private stubKeepAliveTimer: ReturnType<typeof setInterval> | null = null;
   private readonly globalIPCHandlers = new Map<string, GlobalIPCHandler>();
@@ -209,13 +213,15 @@ export class AppRuntime {
   private readonly appresHandlers = new Map<string, () => string>();
 
   getAppRes(path: string, handler: () => string) {
-    this.appresHandlers.set(path, handler);
-    getNativeLibrary()?.symbols.bunite_register_appres_route(toCString(path));
+    const normalized = normalizeAppResPath(path);
+    this.appresHandlers.set(normalized, handler);
+    getNativeLibrary()?.symbols.bunite_register_appres_route(toCString(normalized));
   }
 
   removeAppRes(path: string) {
-    this.appresHandlers.delete(path);
-    getNativeLibrary()?.symbols.bunite_unregister_appres_route(toCString(path));
+    const normalized = normalizeAppResPath(path);
+    this.appresHandlers.delete(normalized);
+    getNativeLibrary()?.symbols.bunite_unregister_appres_route(toCString(normalized));
   }
 
   /** @internal */

package/src/bun/core/BrowserView.ts

@@ -2,8 +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 } from "../../shared/rpc";
-import { createWebRPCHandler } from "../../shared/webRpcHandler";
+import { type RPCPacket, type RPCTransport, type RPCWithTransport } from "../../shared/rpc";
 import { ensureNativeRuntime, getNativeLibrary, toCString, waitForViewReady, cancelWaitForViewReady } from "../proc/native";
 import { attachBrowserViewRegistry, getRPCPort, sendMessageToView } from "./Socket";
 import { randomBytes } from "node:crypto";
@@ -14,6 +13,16 @@ import { cancelPendingMessageBoxesForView } from "./Utils";
 const BrowserViewMap: Record<number, BrowserView<any>> = {};
 let nextWebviewId = 1;
 
+function createNativeViewPipe(viewId: number) {
+  let handler: ((packet: RPCPacket) => void) | undefined;
+  const transport: RPCTransport = {
+    send: (packet) => { sendMessageToView(viewId, packet); },
+    registerHandler: (h) => { handler = h; },
+    unregisterHandler: () => { handler = undefined; }
+  };
+  return { transport, receive: (packet: RPCPacket) => handler?.(packet) };
+}
+
 export type BrowserViewOptions<T = undefined> = {
   url: string | null;
   html: string | null;
@@ -66,7 +75,8 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
   partition: string | null;
   frame: BrowserViewOptions["frame"];
   rpc?: T;
-  rpcHandler?: (message: unknown) => void;
+  readonly transport: RPCTransport;
+  private pipe: ReturnType<typeof createNativeViewPipe>;
   autoResize: boolean;
   navigationRules: string[] | null;
   sandbox: boolean;
@@ -75,6 +85,9 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
   constructor(options: Partial<BrowserViewOptions<T>>) {
     ensureNativeRuntime();
 
+    this.pipe = createNativeViewPipe(this.id);
+    this.transport = this.pipe.transport;
+
     this.windowId = options.windowId ?? defaultOptions.windowId;
     this.url = options.url ?? defaultOptions.url;
     this.html = options.html ?? defaultOptions.html;
@@ -105,7 +118,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
     });
 
     BrowserViewMap[this.id] = this;
-    this.rpc?.setTransport(this.createTransport());
+    this.rpc?.setTransport(this.transport);
     // Register ready waiter BEFORE native create — OnAfterCreated can fire
     // on the CEF UI thread before bunite_view_create returns to JS.
     this._readyPromise = waitForViewReady(this.id);
@@ -161,34 +174,8 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
     return Object.values(BrowserViewMap);
   }
 
-  static defineRPC<Schema extends BuniteRPCSchema>(
-    config: BuniteRPCConfig<Schema, "bun">
-  ) {
-    const rpc = defineBuniteRPC("bun", config);
-    const webRpc = createWebRPCHandler<Schema>(config);
-    return Object.assign(rpc, {
-      webHandler: webRpc,
-      webClients: webRpc.webClients,
-      broadcast: webRpc.broadcast,
-    });
-  }
-
-  handleIncomingRPC(message: unknown) {
-    this.rpcHandler?.(message);
-  }
-
-  createTransport() {
-    return {
-      send: (message: any) => {
-        sendMessageToView(this.id, message);
-      },
-      registerHandler: (handler: (message: any) => void) => {
-        this.rpcHandler = handler;
-      },
-      unregisterHandler: () => {
-        this.rpcHandler = undefined;
-      }
-    };
+  handleIncomingRPC(packet: RPCPacket) {
+    this.pipe.receive(packet);
   }
 
   get rpcPort() {

package/src/bun/core/BrowserWindow.ts

@@ -202,6 +202,12 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
     this.webviewId = webview.id;
   }
 
+  get view(): BrowserView<T> {
+    const view = BrowserView.getById(this.webviewId);
+    if (!view) throw new Error(`BrowserWindow ${this.id} has no attached view`);
+    return view as BrowserView<T>;
+  }
+
   static getById(id: number) {
     return BrowserWindowMap[id];
   }

package/src/bun/index.ts

@@ -7,12 +7,15 @@ import { BuniteEvent } from "./events/event";
 import { completePermissionRequest } from "./proc/native";
 import {
   createRPC,
-  defineBuniteRPC,
+  defineBunRPC,
   type BuniteRPCConfig,
   type BuniteRPCSchema,
   type RPCSchema,
   type RPCWithTransport
 } from "../shared/rpc";
+import { createTransportDemuxer, type TransportDemuxer } from "../shared/rpcDemux";
+import { createWebSocketTransport, type WebSocketLike, type WebSocketTransportPipe } from "../shared/webSocketTransport";
+import { createWebRPCHandler, type WebRPCClient } from "../shared/webRpcHandler";
 import type { MessageBoxOptions, MessageBoxResponse } from "./core/Utils";
 import { log, type LogLevel } from "../shared/log";
 
@@ -24,7 +27,10 @@ export {
   buniteEventEmitter,
   completePermissionRequest,
   createRPC,
-  defineBuniteRPC,
+  createTransportDemuxer,
+  createWebRPCHandler,
+  createWebSocketTransport,
+  defineBunRPC,
   log
 };
 
@@ -38,5 +44,9 @@ export type {
   MessageBoxResponse,
   RPCSchema,
   RPCWithTransport,
+  TransportDemuxer,
+  WebRPCClient,
+  WebSocketLike,
+  WebSocketTransportPipe,
   WindowOptionsType
 };

package/src/shared/rpc.ts

@@ -370,11 +370,10 @@ export function createRPC<
   };
 }
 
-export function defineBuniteRPC<
+function defineSideRPC<
   Schema extends BuniteRPCSchema,
   Side extends "bun" | "webview"
 >(
-  side: Side,
   config: BuniteRPCConfig<Schema, Side> & {
     extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
   }
@@ -416,3 +415,19 @@ export function defineBuniteRPC<
 
   return rpc;
 }
+
+export function defineBunRPC<Schema extends BuniteRPCSchema>(
+  config: BuniteRPCConfig<Schema, "bun"> & {
+    extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
+  }
+) {
+  return defineSideRPC<Schema, "bun">(config);
+}
+
+export function defineWebviewRPC<Schema extends BuniteRPCSchema>(
+  config: BuniteRPCConfig<Schema, "webview"> & {
+    extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
+  }
+) {
+  return defineSideRPC<Schema, "webview">(config);
+}

package/src/shared/rpcDemux.ts

@@ -0,0 +1,65 @@
+import type { RPCPacket, RPCTransport } from "./rpc";
+
+type DemuxEnvelope = { channel: string; packet: RPCPacket };
+
+function isDemuxEnvelope(value: unknown): value is DemuxEnvelope {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Partial<DemuxEnvelope>;
+  return typeof v.channel === "string" && typeof v.packet === "object" && v.packet !== null;
+}
+
+export type TransportDemuxer = {
+  channel(name: string): RPCTransport;
+  dispose(): void;
+};
+
+export function createTransportDemuxer(base: RPCTransport): TransportDemuxer {
+  if (!base.send || !base.registerHandler) {
+    throw new Error("createTransportDemuxer requires a base transport with both send and registerHandler");
+  }
+
+  const handlers = new Map<string, (packet: RPCPacket) => void>();
+  let disposed = false;
+
+  base.registerHandler((data) => {
+    // Envelopes missing or malformed are dropped. A future fallthrough hook
+    // would land here if we ever multiplex legacy RPC on the same transport.
+    if (!isDemuxEnvelope(data)) return;
+    handlers.get(data.channel)?.(data.packet);
+  });
+
+  return {
+    channel(name) {
+      let ownHandler: ((packet: RPCPacket) => void) | undefined;
+
+      return {
+        send(packet) {
+          if (disposed) throw new Error(`Demuxer disposed; cannot send on channel "${name}"`);
+          const envelope: DemuxEnvelope = { channel: name, packet };
+          // The wire layer (msgpackr) serializes the envelope opaquely, so
+          // routing the wider type through RPCTransport.send is safe in practice.
+          base.send!(envelope as unknown as RPCPacket);
+        },
+        registerHandler(handler) {
+          if (disposed) throw new Error(`Demuxer disposed; cannot register on channel "${name}"`);
+          if (handlers.has(name)) {
+            throw new Error(`Channel "${name}" already has a handler on this demuxer`);
+          }
+          ownHandler = handler;
+          handlers.set(name, handler);
+        },
+        unregisterHandler() {
+          if (ownHandler && handlers.get(name) === ownHandler) {
+            handlers.delete(name);
+            ownHandler = undefined;
+          }
+        }
+      };
+    },
+    dispose() {
+      disposed = true;
+      handlers.clear();
+      base.unregisterHandler?.();
+    }
+  };
+}

package/src/shared/webRpcHandler.ts

@@ -1,19 +1,14 @@
 import {
-  defineBuniteRPC,
+  defineBunRPC,
   type BuniteRPCConfig,
-  type BuniteRPCSchema,
-  type RPCTransport,
-  type RPCPacket
+  type BuniteRPCSchema
 } from "./rpc";
-import { decodeRPCPacket, encodeRPCPacket, asUint8Array } from "./rpcWire";
+import { createWebSocketTransport, type WebSocketLike } from "./webSocketTransport";
 import { log } from "./log";
 
-type WebRPCSocket = { send(data: Uint8Array | ArrayBuffer): void | number };
-
 export type WebRPCClient<Schema extends BuniteRPCSchema = BuniteRPCSchema> = {
-  ws: WebRPCSocket;
-  rpc: ReturnType<typeof defineBuniteRPC<Schema, "bun">>;
-  handlePacket: (packet: RPCPacket) => void | Promise<void>;
+  ws: WebSocketLike;
+  rpc: ReturnType<typeof defineBunRPC<Schema>>;
 };
 
 export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
@@ -21,62 +16,44 @@ export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
     extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
   }
 ) {
-  const connections = new WeakMap<WebRPCSocket, WebRPCClient<Schema>>();
+  type Entry = { client: WebRPCClient<Schema>; receive: (raw: ArrayBuffer | Uint8Array) => void };
+
+  const connections = new WeakMap<WebSocketLike, Entry>();
   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;
-        }
-      };
+    open(ws: WebSocketLike) {
+      const pipe = createWebSocketTransport(ws);
+      const rpc = defineBunRPC(config);
+      rpc.setTransport(pipe.transport);
 
-      const rpc = defineBuniteRPC("bun", config);
-      rpc.setTransport(transport);
+      const client: WebRPCClient<Schema> = { ws, rpc: rpc as WebRPCClient<Schema>["rpc"] };
 
-      const client: WebRPCClient<Schema> = {
-        ws,
-        rpc: rpc as WebRPCClient<Schema>["rpc"],
-        handlePacket: (packet) => handlePacket?.(packet)
-      };
-
-      connections.set(ws, client);
+      connections.set(ws, { client, receive: pipe.receive });
       webClients.add(client);
       handler.onWebClientConnected?.(client);
     },
 
-    message(ws: WebRPCSocket, raw: string | Buffer | ArrayBuffer | Uint8Array) {
+    message(ws: WebSocketLike, raw: string | Buffer | ArrayBuffer | Uint8Array) {
       if (typeof raw === "string") return;
-
-      const client = connections.get(ws);
-      if (!client) return;
+      const entry = connections.get(ws);
+      if (!entry) return;
 
       try {
-        Promise.resolve(client.handlePacket(decodeRPCPacket(asUint8Array(raw)))).catch((error) => {
-          log.error("Web RPC packet handler error", error);
-        });
-      } catch {
-        // malformed packet — decode failure
+        entry.receive(raw);
+      } catch (error) {
+        log.error("Web RPC packet handler error", error);
       }
     },
 
-    close(ws: WebRPCSocket) {
-      const client = connections.get(ws);
-      if (!client) return;
+    close(ws: WebSocketLike) {
+      const entry = connections.get(ws);
+      if (!entry) return;
 
-      client.rpc.dispose();
-      webClients.delete(client);
+      entry.client.rpc.dispose();
+      webClients.delete(entry.client);
       connections.delete(ws);
-      handler.onWebClientDisconnected?.(client);
+      handler.onWebClientDisconnected?.(entry.client);
     },
 
     webClients: webClients as ReadonlySet<WebRPCClient<Schema>>,

package/src/shared/webSocketTransport.ts

@@ -0,0 +1,26 @@
+import type { RPCPacket, RPCTransport } from "./rpc";
+import { asUint8Array, decodeRPCPacket, encodeRPCPacket } from "./rpcWire";
+
+export type WebSocketLike = {
+  send(data: Uint8Array | ArrayBuffer): void | number;
+};
+
+export type WebSocketTransportPipe = {
+  transport: RPCTransport;
+  receive(raw: ArrayBuffer | ArrayBufferView | Uint8Array): void;
+};
+
+export function createWebSocketTransport(ws: WebSocketLike): WebSocketTransportPipe {
+  let handler: ((packet: RPCPacket) => void) | undefined;
+
+  return {
+    transport: {
+      send(packet) { ws.send(encodeRPCPacket(packet)); },
+      registerHandler(h) { handler = h; },
+      unregisterHandler() { handler = undefined; }
+    },
+    receive(raw) {
+      handler?.(decodeRPCPacket(asUint8Array(raw)));
+    }
+  };
+}

package/src/view/index.ts

@@ -1,6 +1,6 @@
 import "../shared/webviewPolyfill";
 import {
-  defineBuniteRPC,
+  defineWebviewRPC,
   type BuniteRPCConfig,
   type RPCPacket,
   type BuniteRPCSchema,
@@ -8,6 +8,8 @@ import {
   type RPCTransport,
   type RPCWithTransport
 } from "../shared/rpc";
+import { createTransportDemuxer, type TransportDemuxer } from "../shared/rpcDemux";
+import { createWebSocketTransport, type WebSocketLike, type WebSocketTransportPipe } from "../shared/webSocketTransport";
 import { decodeRPCPacket, encodeRPCPacket } from "../shared/rpcWire";
 import { log } from "../shared/log";
 
@@ -34,24 +36,37 @@ function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
   return copy.buffer;
 }
 
-export class BuniteView<T extends RPCWithTransport> {
+export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
   bunSocket?: WebSocket;
   rpc?: T;
-  rpcHandler?: (message: unknown) => void;
+  readonly transport: RPCTransport;
+
+  private handler?: (packet: RPCPacket) => void;
   private pendingPackets: RPCPacket[] = [];
 
-  constructor(config: { rpc: T }) {
-    this.rpc = config.rpc;
-    this.init();
-  }
+  constructor(config?: { rpc?: T }) {
+    this.rpc = config?.rpc;
+
+    this.transport = {
+      send: (packet) => {
+        if (this.bunSocket?.readyState === WebSocket.OPEN) {
+          this.sendPacket(packet);
+        } else if (this.bunSocket?.readyState === WebSocket.CONNECTING) {
+          this.pendingPackets.push(packet);
+        }
+      },
+      registerHandler: (h) => { this.handler = h; },
+      unregisterHandler: () => { this.handler = undefined; }
+    };
 
-  init() {
     this.initSocketToBun();
     if (isNative) {
       buniteWindow.__bunite ??= {};
-      buniteWindow.__bunite.receiveMessageFromBun = this.receiveMessageFromBun.bind(this);
+      buniteWindow.__bunite.receiveMessageFromBun = (message) => {
+        this.handler?.(message as RPCPacket);
+      };
     }
-    this.rpc?.setTransport(this.createTransport());
+    this.rpc?.setTransport(this.transport);
   }
 
   private sendPacket(packet: RPCPacket) {
@@ -72,10 +87,10 @@ export class BuniteView<T extends RPCWithTransport> {
       this.bunSocket = socket;
 
       socket.addEventListener("message", async (event) => {
-        const bytes = await this.messageToUint8Array(event.data);
+        const bytes = await messageToUint8Array(event.data);
         if (!bytes) return;
         try {
-          this.rpcHandler?.(decodeRPCPacket(bytes));
+          this.handler?.(decodeRPCPacket(bytes));
         } catch (error) {
           log.error("Failed to parse WebSocket message", error);
         }
@@ -97,7 +112,7 @@ export class BuniteView<T extends RPCWithTransport> {
       }
 
       this.bunSocket!.addEventListener("message", async (event) => {
-        const binaryMessage = await this.messageToUint8Array(event.data);
+        const binaryMessage = await messageToUint8Array(event.data);
         if (!binaryMessage) return;
 
         try {
@@ -109,7 +124,7 @@ export class BuniteView<T extends RPCWithTransport> {
           const decrypted = await decrypt(binaryMessage);
           const packet = decodeRPCPacket(decrypted);
           if ((packet as any).scope === "global") return;
-          this.rpcHandler?.(packet);
+          this.handler?.(packet);
         } catch (error) {
           log.error("Failed to parse message from Bun", error);
         }
@@ -133,35 +148,6 @@ export class BuniteView<T extends RPCWithTransport> {
     });
   }
 
-  async messageToUint8Array(data: unknown) {
-    if (data instanceof ArrayBuffer) return new Uint8Array(data);
-    if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
-    if (data instanceof Uint8Array) return data;
-    return null;
-  }
-
-  createTransport(): RPCTransport {
-    return {
-      send: (message) => {
-        if (this.bunSocket?.readyState === WebSocket.OPEN) {
-          this.sendPacket(message);
-        } else if (this.bunSocket?.readyState === WebSocket.CONNECTING) {
-          this.pendingPackets.push(message);
-        }
-      },
-      registerHandler: (handler: (packet: any) => void) => {
-        this.rpcHandler = handler;
-      },
-      unregisterHandler: () => {
-        this.rpcHandler = undefined;
-      }
-    };
-  }
-
-  receiveMessageFromBun(message: unknown) {
-    this.rpcHandler?.(message);
-  }
-
   async bunBridge(message: RPCPacket) {
     if (this.bunSocket?.readyState !== WebSocket.OPEN) return;
 
@@ -175,19 +161,23 @@ export class BuniteView<T extends RPCWithTransport> {
     this.bunSocket.send(toArrayBuffer(encrypted));
   }
 
-  static defineRPC<Schema extends BuniteRPCSchema>(
-    config: BuniteRPCConfig<Schema, "webview">
-  ) {
-    const rpc = defineBuniteRPC("webview", config);
-    new BuniteView({ rpc });
-    return rpc;
-  }
+}
+
+async function messageToUint8Array(data: unknown) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+  if (data instanceof Uint8Array) return data;
+  return null;
 }
 
 export { log, type LogLevel } from "../shared/log";
+export { createTransportDemuxer, createWebSocketTransport, defineWebviewRPC };
 
 export type {
   BuniteRPCConfig,
   BuniteRPCSchema,
-  RPCSchema
+  RPCSchema,
+  TransportDemuxer,
+  WebSocketLike,
+  WebSocketTransportPipe
 };