bunite-core 0.8.0 → 0.9.0

package/src/shared/rpcDemux.ts

@@ -1,219 +0,0 @@
-import type { RpcPacket, RpcTransport, RpcWithTransport } from "./rpc";
-
-type DemuxPacketEnvelope = { channel: string; packet: RpcPacket };
-type DemuxHelloFrame = { channel: string; hello: true };
-type DemuxFrame = DemuxPacketEnvelope | DemuxHelloFrame;
-
-function isDemuxFrame(value: unknown): value is DemuxFrame {
-  if (typeof value !== "object" || value === null) return false;
-  return typeof (value as DemuxFrame).channel === "string";
-}
-
-function isPacketEnvelope(frame: DemuxFrame): frame is DemuxPacketEnvelope {
-  const v = frame as DemuxPacketEnvelope;
-  return typeof v.packet === "object" && v.packet !== null;
-}
-
-function isHelloFrame(frame: DemuxFrame): frame is DemuxHelloFrame {
-  return (frame as DemuxHelloFrame).hello === true;
-}
-
-export type RpcChannelHandle = {
-  /**
-   * Connect an RPC instance to this channel. Returns a promise that resolves
-   * once both sides have registered a handler (HELLO handshake). Awaiting
-   * guarantees the first subsequent request reaches the peer.
-   */
-  bindTo(rpc: RpcWithTransport): Promise<void>;
-};
-
-export type RpcTransportDemuxer = {
-  channel(name: string): RpcChannelHandle;
-  dispose(): void;
-};
-
-export type RpcDemuxBufferPolicy = "drop-oldest" | "drop-newest";
-
-export type RpcTransportDemuxerOptions = {
-  /** ms to wait for peer before `bindTo` rejects. Default 10_000. */
-  readyTimeout?: number;
-  /**
-   * Per-channel cap for packets received before a handler is registered.
-   * Drained FIFO on registerHandler. Default 64. Set 0 to disable buffering.
-   */
-  bufferSize?: number;
-  /** Overflow behaviour when bufferSize is exceeded. Default "drop-oldest". */
-  bufferPolicy?: RpcDemuxBufferPolicy;
-};
-
-type ChannelState = {
-  handler?: (packet: RpcPacket) => void;
-  peerSawUs: boolean;
-  ready: Promise<void>;
-  resolveReady: () => void;
-  rejectReady: (error: Error) => void;
-  readySettled: boolean;
-  readyTimer?: ReturnType<typeof setTimeout>;
-  pending: RpcPacket[];
-};
-
-const DEFAULT_READY_TIMEOUT = 10_000;
-const DEFAULT_BUFFER_SIZE = 64;
-
-export function createRpcTransportDemuxer(
-  base: RpcTransport,
-  options: RpcTransportDemuxerOptions = {}
-): RpcTransportDemuxer {
-  if (!base.send || !base.registerHandler) {
-    throw new Error("createRpcTransportDemuxer requires a base transport with both send and registerHandler");
-  }
-
-  const readyTimeout = options.readyTimeout ?? DEFAULT_READY_TIMEOUT;
-  const bufferSize = Math.max(0, options.bufferSize ?? DEFAULT_BUFFER_SIZE);
-  const bufferPolicy: RpcDemuxBufferPolicy = options.bufferPolicy ?? "drop-oldest";
-  const channels = new Map<string, ChannelState>();
-  let disposed = false;
-
-  function getOrCreateState(name: string): ChannelState {
-    let state = channels.get(name);
-    if (state) return state;
-
-    let resolveReady!: () => void;
-    let rejectReady!: (error: Error) => void;
-    const ready = new Promise<void>((resolve, reject) => {
-      resolveReady = resolve;
-      rejectReady = reject;
-    });
-    ready.catch(() => {}); // prevent unhandled rejection if consumer doesn't await
-
-    state = {
-      peerSawUs: false,
-      ready,
-      resolveReady,
-      rejectReady,
-      readySettled: false,
-      pending: []
-    };
-    channels.set(name, state);
-    return state;
-  }
-
-  function bufferIncoming(state: ChannelState, packet: RpcPacket) {
-    if (bufferSize === 0) return;
-    if (state.pending.length < bufferSize) {
-      state.pending.push(packet);
-      return;
-    }
-    if (bufferPolicy === "drop-oldest") {
-      state.pending.shift();
-      state.pending.push(packet);
-    }
-    // drop-newest: leave the queue alone, discard the new packet
-  }
-
-  function settleReady(state: ChannelState, action: () => void) {
-    if (state.readySettled) return;
-    state.readySettled = true;
-    if (state.readyTimer) clearTimeout(state.readyTimer);
-    action();
-  }
-
-  function sendHello(name: string) {
-    const frame: DemuxHelloFrame = { channel: name, hello: true };
-    base.send!(frame as unknown as RpcPacket);
-  }
-
-  base.registerHandler((data) => {
-    if (!isDemuxFrame(data)) return;
-    const state = getOrCreateState(data.channel);
-
-    if (isHelloFrame(data)) {
-      if (state.handler) {
-        const wasReady = state.readySettled;
-        settleReady(state, state.resolveReady);
-        if (!wasReady && !disposed) sendHello(data.channel); // echo so peer wakes up
-      } else {
-        state.peerSawUs = true;
-      }
-      return;
-    }
-
-    if (isPacketEnvelope(data)) {
-      if (state.handler) {
-        state.handler(data.packet);
-      } else {
-        bufferIncoming(state, data.packet);
-      }
-    }
-  });
-
-  return {
-    channel(name) {
-      if (disposed) throw new Error(`Demuxer disposed; cannot open channel "${name}"`);
-      const state = getOrCreateState(name);
-
-      const transport: RpcTransport = {
-        send(packet) {
-          if (disposed) throw new Error(`Demuxer disposed; cannot send on channel "${name}"`);
-          const envelope: DemuxPacketEnvelope = { channel: name, packet };
-          base.send!(envelope as unknown as RpcPacket);
-        },
-        registerHandler(handler) {
-          if (disposed) throw new Error(`Demuxer disposed; cannot register on channel "${name}"`);
-          if (state.handler) {
-            throw new Error(`Channel "${name}" already has a handler on this demuxer`);
-          }
-          state.handler = handler;
-
-          sendHello(name);
-
-          if (state.peerSawUs) {
-            settleReady(state, state.resolveReady);
-          } else if (!state.readySettled && !state.readyTimer) {
-            state.readyTimer = setTimeout(() => {
-              settleReady(state, () =>
-                state.rejectReady(new Error(`Channel "${name}" ready timed out after ${readyTimeout}ms`))
-              );
-            }, readyTimeout);
-          }
-
-          // Drain after handshake bookkeeping so a thrown handler doesn't
-          // leave HELLO unsent or the ready promise un-armed. Handler errors
-          // during drain are swallowed so one bad packet doesn't drop the rest;
-          // synchronous throws from RPC handlers are a consumer bug.
-          if (state.pending.length > 0) {
-            const drained = state.pending;
-            state.pending = [];
-            for (const packet of drained) {
-              try { handler(packet); } catch { /* drain continues */ }
-            }
-          }
-        },
-        unregisterHandler() {
-          state.handler = undefined;
-        }
-      };
-
-      return {
-        bindTo(rpc) {
-          rpc.setTransport(transport);
-          return state.ready;
-        }
-      };
-    },
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      for (const state of channels.values()) {
-        if (state.readyTimer) clearTimeout(state.readyTimer);
-        if (!state.readySettled) {
-          state.readySettled = true;
-          state.rejectReady(new Error("Demuxer disposed"));
-        }
-        state.pending.length = 0;
-      }
-      channels.clear();
-      base.unregisterHandler?.();
-    }
-  };
-}

package/src/shared/rpcWire.ts

@@ -1,54 +0,0 @@
-import { pack, unpack } from "msgpackr";
-import type { RpcPacket } from "./rpc";
-import {
-  RPC_AUTH_TAG_LENGTH,
-  RPC_FRAME_VERSION,
-  RPC_IV_LENGTH
-} from "./rpcWireConstants";
-
-export function encodeRpcPacket(packet: RpcPacket): Uint8Array {
-  return pack(packet) as Uint8Array;
-}
-
-export function decodeRpcPacket(data: Uint8Array): RpcPacket {
-  return unpack(data) as RpcPacket;
-}
-
-export function createEncryptedRpcFrame(
-  iv: Uint8Array,
-  encryptedPayload: Uint8Array
-): Uint8Array {
-  if (iv.byteLength !== RPC_IV_LENGTH) {
-    throw new Error(`Invalid RPC IV length: expected ${RPC_IV_LENGTH}, got ${iv.byteLength}`);
-  }
-
-  const frame = new Uint8Array(1 + RPC_IV_LENGTH + encryptedPayload.byteLength);
-  frame[0] = RPC_FRAME_VERSION;
-  frame.set(iv, 1);
-  frame.set(encryptedPayload, 1 + RPC_IV_LENGTH);
-  return frame;
-}
-
-export function parseEncryptedRpcFrame(frame: Uint8Array) {
-  if (frame.byteLength < 1 + RPC_IV_LENGTH + RPC_AUTH_TAG_LENGTH) {
-    throw new Error("Invalid RPC frame: payload is too short.");
-  }
-  if (frame[0] !== RPC_FRAME_VERSION) {
-    throw new Error(`Unsupported RPC frame version: ${frame[0]}`);
-  }
-
-  return {
-    iv: frame.subarray(1, 1 + RPC_IV_LENGTH),
-    encryptedPayload: frame.subarray(1 + RPC_IV_LENGTH)
-  };
-}
-
-export function asUint8Array(data: ArrayBuffer | ArrayBufferView | Uint8Array): Uint8Array {
-  if (data instanceof Uint8Array) {
-    return data;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  return new Uint8Array(data);
-}

package/src/shared/rpcWireConstants.ts

@@ -1,3 +0,0 @@
-export const RPC_FRAME_VERSION = 1;
-export const RPC_IV_LENGTH = 12;
-export const RPC_AUTH_TAG_LENGTH = 16;

package/src/shared/webRpcHandler.ts

@@ -1,77 +0,0 @@
-import {
-  defineBunRpc,
-  type BuniteRpcConfig,
-  type BuniteRpcSchema
-} from "./rpc";
-import { createWebSocketTransport, type WebSocketLike } from "./webSocketTransport";
-import { log } from "./log";
-
-export type WebRpcClient<Schema extends BuniteRpcSchema = BuniteRpcSchema> = {
-  ws: WebSocketLike;
-  rpc: ReturnType<typeof defineBunRpc<Schema>>;
-};
-
-export function createWebRpcHandler<Schema extends BuniteRpcSchema>(
-  config: BuniteRpcConfig<Schema, "bun">
-) {
-  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: WebSocketLike) {
-      const pipe = createWebSocketTransport(ws);
-      const rpc = defineBunRpc(config);
-      rpc.setTransport(pipe.transport);
-
-      const client: WebRpcClient<Schema> = { ws, rpc: rpc as WebRpcClient<Schema>["rpc"] };
-
-      connections.set(ws, { client, receive: pipe.receive });
-      webClients.add(client);
-      handler.onWebClientConnected?.(client);
-    },
-
-    message(ws: WebSocketLike, raw: string | Buffer | ArrayBuffer | Uint8Array) {
-      if (typeof raw === "string") return;
-      const entry = connections.get(ws);
-      if (!entry) return;
-
-      try {
-        entry.receive(raw);
-      } catch (error) {
-        log.error("Web RPC packet handler error", error);
-      }
-    },
-
-    close(ws: WebSocketLike) {
-      const entry = connections.get(ws);
-      if (!entry) return;
-
-      entry.client.rpc.dispose();
-      webClients.delete(entry.client);
-      connections.delete(ws);
-      handler.onWebClientDisconnected?.(entry.client);
-    },
-
-    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;
-}

package/src/shared/webSocketTransport.ts

@@ -1,26 +0,0 @@
-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,196 +0,0 @@
-import { registerBuniteWebviewPolyfill } from "../shared/webviewPolyfill";
-import {
-  defineWebviewRpc,
-  type BuniteRpcConfig,
-  type RpcPacket,
-  type BuniteRpcSchema,
-  type RpcSchema,
-  type RpcTransport,
-  type RpcWithTransport
-} from "../shared/rpc";
-import { createRpcTransportDemuxer, type RpcChannelHandle, type RpcTransportDemuxer, type RpcTransportDemuxerOptions } from "../shared/rpcDemux";
-import { createWebSocketTransport, type WebSocketLike, type WebSocketTransportPipe } from "../shared/webSocketTransport";
-import { decodeRpcPacket, encodeRpcPacket } from "../shared/rpcWire";
-import { log } from "../shared/log";
-
-type BuniteWindowGlobals = Window &
-  typeof globalThis & {
-    __buniteWebviewId?: number;
-    __buniteRpcSocketPort?: number;
-    __bunite?: {
-      receiveMessageFromBun?: (message: unknown) => void;
-    };
-    __bunite_encrypt?: (data: Uint8Array) => Promise<Uint8Array>;
-    __bunite_decrypt?: (data: Uint8Array) => Promise<Uint8Array>;
-  };
-
-type BuniteEnv = {
-  window: BuniteWindowGlobals | null;
-  webviewId: number | undefined;
-  rpcPort: number | undefined;
-  isNative: boolean;
-};
-
-function readBuniteEnv(): BuniteEnv {
-  const w = typeof window !== "undefined" ? (window as BuniteWindowGlobals) : null;
-  const webviewId = w?.__buniteWebviewId;
-  const rpcPort = w?.__buniteRpcSocketPort;
-  return { window: w, webviewId, rpcPort, isNative: webviewId != null && rpcPort != null };
-}
-
-function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
-  const copy = new Uint8Array(bytes.byteLength);
-  copy.set(bytes);
-  return copy.buffer;
-}
-
-export class BuniteView<T extends RpcWithTransport = RpcWithTransport> {
-  bunSocket?: WebSocket;
-  rpc?: T;
-  readonly transport: RpcTransport;
-
-  private env: BuniteEnv;
-  private handler?: (packet: RpcPacket) => void;
-  private pendingPackets: RpcPacket[] = [];
-
-  constructor(config?: { rpc?: T }) {
-    registerBuniteWebviewPolyfill();
-    this.env = readBuniteEnv();
-    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; }
-    };
-
-    this.initSocketToBun();
-    if (this.env.isNative && this.env.window) {
-      this.env.window.__bunite ??= {};
-      this.env.window.__bunite.receiveMessageFromBun = (message) => {
-        this.handler?.(message as RpcPacket);
-      };
-    }
-    this.rpc?.setTransport(this.transport);
-  }
-
-  private sendPacket(packet: RpcPacket) {
-    if (this.env.isNative) {
-      void this.bunBridge(packet).catch((error) => {
-        log.error("Failed to send RPC packet", error);
-      });
-    } else {
-      this.bunSocket!.send(toArrayBuffer(encodeRpcPacket(packet)));
-    }
-  }
-
-  initSocketToBun() {
-    if (!this.env.isNative) {
-      const proto = location.protocol === "https:" ? "wss:" : "ws:";
-      const socket = new WebSocket(`${proto}//${location.host}/rpc`);
-      socket.binaryType = "arraybuffer";
-      this.bunSocket = socket;
-
-      socket.addEventListener("message", async (event) => {
-        const bytes = await messageToUint8Array(event.data);
-        if (!bytes) return;
-        try {
-          this.handler?.(decodeRpcPacket(bytes));
-        } catch (error) {
-          log.error("Failed to parse WebSocket message", error);
-        }
-      });
-    } else {
-      // Share a single WebSocket with the preload's bunite.invoke.
-      const globals = this.env.window as any;
-      globals.__bunite ??= {};
-      const existing = globals.__bunite._socket;
-      if (existing && existing.readyState <= WebSocket.OPEN) {
-        this.bunSocket = existing;
-      } else {
-        const socket = new WebSocket(
-          `ws://localhost:${this.env.rpcPort}/socket?webviewId=${this.env.webviewId}`
-        );
-        socket.binaryType = "arraybuffer";
-        this.bunSocket = socket;
-        globals.__bunite._socket = socket;
-      }
-
-      this.bunSocket!.addEventListener("message", async (event) => {
-        const binaryMessage = await messageToUint8Array(event.data);
-        if (!binaryMessage) return;
-
-        try {
-          const decrypt = this.env.window?.__bunite_decrypt;
-          if (!decrypt) {
-            log.error("No decrypt function available in preload globals");
-            return;
-          }
-          const decrypted = await decrypt(binaryMessage);
-          const packet = decodeRpcPacket(decrypted);
-          if ((packet as any).scope === "global") return;
-          this.handler?.(packet);
-        } catch (error) {
-          log.error("Failed to parse message from Bun", error);
-        }
-      });
-    }
-
-    this.bunSocket!.addEventListener("open", () => {
-      for (const packet of this.pendingPackets) this.sendPacket(packet);
-      this.pendingPackets = [];
-    });
-
-    this.bunSocket!.addEventListener("error", () => {
-      log.error("RPC WebSocket error");
-    });
-
-    this.bunSocket!.addEventListener("close", () => {
-      if (this.pendingPackets.length > 0) {
-        log.error(`RPC WebSocket closed with ${this.pendingPackets.length} pending packets`);
-        this.pendingPackets = [];
-      }
-    });
-  }
-
-  async bunBridge(message: RpcPacket) {
-    if (this.bunSocket?.readyState !== WebSocket.OPEN) return;
-
-    const encrypt = this.env.window?.__bunite_encrypt;
-    if (!encrypt) {
-      log.error("No encrypt function available in preload globals");
-      return;
-    }
-
-    const encrypted = await encrypt(encodeRpcPacket(message));
-    this.bunSocket.send(toArrayBuffer(encrypted));
-  }
-
-}
-
-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 { createRpcTransportDemuxer, createWebSocketTransport, defineWebviewRpc, registerBuniteWebviewPolyfill };
-
-export type {
-  BuniteRpcConfig,
-  BuniteRpcSchema,
-  RpcChannelHandle,
-  RpcSchema,
-  RpcTransportDemuxer,
-  RpcTransportDemuxerOptions,
-  WebSocketLike,
-  WebSocketTransportPipe
-};