bunite-core 0.3.1 → 0.4.0

package/package.json

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

package/src/bun/core/App.ts

@@ -14,7 +14,7 @@ import {
   toCString,
   type NativeBootstrapOptions
 } from "../proc/native";
-import { attachGlobalIPCResolver, ensureRPCServer } from "./Socket";
+import { attachGlobalIPCResolver, ensureRpcServer } from "./Socket";
 import { BrowserWindow } from "./BrowserWindow";
 import { getSurfaceIPCHandlers } from "./SurfaceManager";
 import { getWebviewIPCHandlers } from "./SurfaceBrowserIPC";
@@ -134,7 +134,7 @@ export class AppRuntime {
       });
     }
 
-    ensureRPCServer();
+    ensureRpcServer();
     buniteEventEmitter.emitEvent(
       new BuniteEvent("ready", {
         usingStub: runtime.usingStub,

package/src/bun/core/BrowserView.ts

@@ -2,9 +2,9 @@ import { ptr } from "bun:ffi";
 import { buildViewPreloadScript } from "../preload/inline";
 import { log } from "../../shared/log";
 import { buniteEventEmitter } from "../events/eventEmitter";
-import { type RPCPacket, type RPCTransport, type RPCWithTransport } from "../../shared/rpc";
+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 { attachBrowserViewRegistry, getRpcPort, sendMessageToView } from "./Socket";
 import { randomBytes } from "node:crypto";
 import { resolveDefaultAppResRoot } from "../../shared/paths";
 import { removeSurfacesForHostView } from "./SurfaceRegistry";
@@ -14,13 +14,13 @@ const BrowserViewMap: Record<number, BrowserView<any>> = {};
 let nextWebviewId = 1;
 
 function createNativeViewPipe(viewId: number) {
-  let handler: ((packet: RPCPacket) => void) | undefined;
-  const transport: RPCTransport = {
+  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) };
+  return { transport, receive: (packet: RpcPacket) => handler?.(packet) };
 }
 
 export type BrowserViewOptions<T = undefined> = {
@@ -62,7 +62,7 @@ const defaultOptions: BrowserViewOptions = {
   sandbox: false
 };
 
-export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
+export class BrowserView<T extends RpcWithTransport = RpcWithTransport> {
   id = nextWebviewId++;
   private nativeAttached = false;
   private _readyPromise: Promise<void>;
@@ -75,7 +75,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
   partition: string | null;
   frame: BrowserViewOptions["frame"];
   rpc?: T;
-  readonly transport: RPCTransport;
+  readonly transport: RpcTransport;
   private pipe: ReturnType<typeof createNativeViewPipe>;
   autoResize: boolean;
   navigationRules: string[] | null;
@@ -113,7 +113,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
       preload: this.preload,
       appresRoot: this.appresRoot,
       webviewId: this.id,
-      rpcSocketPort: getRPCPort(),
+      rpcSocketPort: getRpcPort(),
       secretKey: this.secretKey
     });
 
@@ -174,12 +174,12 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
     return Object.values(BrowserViewMap);
   }
 
-  handleIncomingRPC(packet: RPCPacket) {
+  handleIncomingRpc(packet: RpcPacket) {
     this.pipe.receive(packet);
   }
 
   get rpcPort() {
-    return getRPCPort();
+    return getRpcPort();
   }
 
   setAnchor(mode: "none" | "fill" | "top" | "below-top", inset = 0) {

package/src/bun/core/BrowserWindow.ts

@@ -3,7 +3,7 @@ import { BuniteEvent } from "../events/event";
 import { buniteEventEmitter } from "../events/eventEmitter";
 import { ensureNativeRuntime, getNativeLibrary, toCString } from "../proc/native";
 import { BrowserView, type BrowserViewOptions } from "./BrowserView";
-import type { RPCWithTransport } from "../../shared/rpc";
+import type { RpcWithTransport } from "../../shared/rpc";
 import { getNextWindowId } from "./windowIds";
 import { getBaseDir, resolveDefaultAppResRoot } from "../../shared/paths";
 
@@ -58,7 +58,7 @@ export function getLastFocusedWindowId(): number | null {
   return lastFocusedWindowId;
 }
 
-export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
+export class BrowserWindow<T extends RpcWithTransport = RpcWithTransport> {
   id = getNextWindowId();
   private nativeAttached = false;
   title: string;

package/src/bun/core/Socket.ts

@@ -1,15 +1,15 @@
 import type { Server, ServerWebSocket } from "bun";
 import type { BrowserView } from "./BrowserView";
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-import type { RPCPacket, RPCRequestPacket } from "../../shared/rpc";
+import type { RpcPacket, RpcRequestPacket } from "../../shared/rpc";
 import type { GlobalIPCHandler } from "./App";
 import { log } from "../../shared/log";
 import {
   asUint8Array,
-  createEncryptedRPCFrame,
-  decodeRPCPacket,
-  encodeRPCPacket,
-  parseEncryptedRPCFrame
+  createEncryptedRpcFrame,
+  decodeRpcPacket,
+  encodeRpcPacket,
+  parseEncryptedRpcFrame
 } from "../../shared/rpcWire";
 import { RPC_AUTH_TAG_LENGTH } from "../../shared/rpcWireConstants";
 
@@ -36,11 +36,11 @@ function encrypt(secretKey: Uint8Array, payload: Uint8Array) {
   const iv = new Uint8Array(randomBytes(12));
   const cipher = createCipheriv("aes-256-gcm", secretKey, iv);
   const encrypted = Buffer.concat([cipher.update(payload), cipher.final(), cipher.getAuthTag()]);
-  return createEncryptedRPCFrame(iv, new Uint8Array(encrypted));
+  return createEncryptedRpcFrame(iv, new Uint8Array(encrypted));
 }
 
 function decrypt(secretKey: Uint8Array, frame: Uint8Array) {
-  const { iv, encryptedPayload } = parseEncryptedRPCFrame(frame);
+  const { iv, encryptedPayload } = parseEncryptedRpcFrame(frame);
   const ciphertext = encryptedPayload.subarray(0, encryptedPayload.byteLength - RPC_AUTH_TAG_LENGTH);
   const tag = encryptedPayload.subarray(encryptedPayload.byteLength - RPC_AUTH_TAG_LENGTH);
   const decipher = createDecipheriv("aes-256-gcm", secretKey, iv);
@@ -61,7 +61,7 @@ export function attachBrowserViewRegistry(nextRegistry: ViewRegistry) {
   registry = nextRegistry;
 }
 
-export function ensureRPCServer() {
+export function ensureRpcServer() {
   if (rpcServer) {
     return { rpcServer, rpcPort };
   }
@@ -106,14 +106,14 @@ export function ensureRPCServer() {
             }
             try {
               const decryptedMessage = decrypt(view.secretKey, binaryMessage);
-              const packet = decodeRPCPacket(decryptedMessage);
+              const packet = decodeRpcPacket(decryptedMessage);
 
-              if (packet.type === "request" && (packet as RPCRequestPacket).scope === "global") {
-                void handleGlobalIPC(packet as RPCRequestPacket, ws.data.webviewId);
+              if (packet.type === "request" && (packet as RpcRequestPacket).scope === "global") {
+                void handleGlobalIPC(packet as RpcRequestPacket, ws.data.webviewId);
                 return;
               }
 
-              view.handleIncomingRPC(packet);
+              view.handleIncomingRpc(packet);
             } catch (error) {
               log.error("Failed to parse RPC payload", error);
             }
@@ -138,11 +138,11 @@ export function ensureRPCServer() {
   return { rpcServer, rpcPort };
 }
 
-export function getRPCPort(): number {
+export function getRpcPort(): number {
   return rpcPort;
 }
 
-async function handleGlobalIPC(packet: RPCRequestPacket, viewId: number) {
+async function handleGlobalIPC(packet: RpcRequestPacket, viewId: number) {
   const handler = globalIPCResolver?.(packet.method);
   if (!handler) {
     sendMessageToView(viewId, {
@@ -174,14 +174,14 @@ async function handleGlobalIPC(packet: RPCRequestPacket, viewId: number) {
   }
 }
 
-export function sendMessageToView(viewId: number, message: RPCPacket): boolean {
+export function sendMessageToView(viewId: number, message: RpcPacket): boolean {
   const socket = socketMap[viewId];
   const view = registry?.getById(viewId);
   if (!socket || socket.readyState !== WebSocket.OPEN || !view) {
     return false;
   }
 
-  const encrypted = encrypt(view.secretKey, encodeRPCPacket(message));
+  const encrypted = encrypt(view.secretKey, encodeRpcPacket(message));
   socket.send(encrypted);
   return true;
 }

package/src/bun/index.ts

@@ -6,16 +6,16 @@ import { buniteEventEmitter } from "./events/eventEmitter";
 import { BuniteEvent } from "./events/event";
 import { completePermissionRequest } from "./proc/native";
 import {
-  createRPC,
-  defineBunRPC,
-  type BuniteRPCConfig,
-  type BuniteRPCSchema,
-  type RPCSchema,
-  type RPCWithTransport
+  createRpc,
+  defineBunRpc,
+  type BuniteRpcConfig,
+  type BuniteRpcSchema,
+  type RpcSchema,
+  type RpcWithTransport
 } from "../shared/rpc";
-import { createTransportDemuxer, type ChannelHandle, type TransportDemuxer, type TransportDemuxerOptions } from "../shared/rpcDemux";
+import { createRpcTransportDemuxer, type RpcChannelHandle, type RpcTransportDemuxer, type RpcTransportDemuxerOptions } from "../shared/rpcDemux";
 import { createWebSocketTransport, type WebSocketLike, type WebSocketTransportPipe } from "../shared/webSocketTransport";
-import { createWebRPCHandler, type WebRPCClient } from "../shared/webRpcHandler";
+import { createWebRpcHandler, type WebRpcClient } from "../shared/webRpcHandler";
 import type { MessageBoxOptions, MessageBoxResponse } from "./core/Utils";
 import { log, type LogLevel } from "../shared/log";
 
@@ -26,28 +26,28 @@ export {
   Utils,
   buniteEventEmitter,
   completePermissionRequest,
-  createRPC,
-  createTransportDemuxer,
-  createWebRPCHandler,
+  createRpc,
+  createRpcTransportDemuxer,
+  createWebRpcHandler,
   createWebSocketTransport,
-  defineBunRPC,
+  defineBunRpc,
   log
 };
 
 export type {
   LogLevel,
   BuniteEvent,
-  BuniteRPCConfig,
-  BuniteRPCSchema,
+  BuniteRpcConfig,
+  BuniteRpcSchema,
   BrowserViewOptions,
-  ChannelHandle,
+  RpcChannelHandle,
   MessageBoxOptions,
   MessageBoxResponse,
-  RPCSchema,
-  RPCWithTransport,
-  TransportDemuxer,
-  TransportDemuxerOptions,
-  WebRPCClient,
+  RpcSchema,
+  RpcWithTransport,
+  RpcTransportDemuxer,
+  RpcTransportDemuxerOptions,
+  WebRpcClient,
   WebSocketLike,
   WebSocketTransportPipe,
   WindowOptionsType

package/src/shared/rpc.ts

@@ -1,4 +1,4 @@
-export type RPCRequestPacket = {
+export type RpcRequestPacket = {
   type: "request";
   id: number;
   method: string;
@@ -6,54 +6,54 @@ export type RPCRequestPacket = {
   scope?: "global";
 };
 
-export type RPCResponsePacket =
+export type RpcResponsePacket =
   | { type: "response"; id: number; success: true; payload: unknown; scope?: "global" }
   | { type: "response"; id: number; success: false; error?: string; scope?: "global" };
 
-export type RPCMessagePacket = {
+export type RpcMessagePacket = {
   type: "message";
   id: string;
   payload: unknown;
 };
 
-export type RPCEventPacket = {
+export type RpcEventPacket = {
   type: "event";
   channel: string;
   data: unknown;
 };
 
-export type RPCPacket = RPCRequestPacket | RPCResponsePacket | RPCMessagePacket | RPCEventPacket;
+export type RpcPacket = RpcRequestPacket | RpcResponsePacket | RpcMessagePacket | RpcEventPacket;
 
-type BaseRPCRequestsSchema = Record<string, { params: unknown; response: unknown }>;
-type BaseRPCMessagesSchema = Record<string, unknown>;
+type BaseRpcRequestsSchema = Record<string, { params: unknown; response: unknown }>;
+type BaseRpcMessagesSchema = Record<string, unknown>;
 
-export type RPCRequestsSchema<T extends BaseRPCRequestsSchema = BaseRPCRequestsSchema> = T;
-export type RPCMessagesSchema<T extends BaseRPCMessagesSchema = BaseRPCMessagesSchema> = T;
+export type RpcRequestsSchema<T extends BaseRpcRequestsSchema = BaseRpcRequestsSchema> = T;
+export type RpcMessagesSchema<T extends BaseRpcMessagesSchema = BaseRpcMessagesSchema> = T;
 
-type InputRPCSchema = {
-  requests?: RPCRequestsSchema;
-  messages?: RPCMessagesSchema;
+type InputRpcSchema = {
+  requests?: RpcRequestsSchema;
+  messages?: RpcMessagesSchema;
 };
 
-type ResolvedRPCSchema<I extends InputRPCSchema> = {
-  requests: undefined extends I["requests"] ? BaseRPCRequestsSchema : NonNullable<I["requests"]>;
-  messages: undefined extends I["messages"] ? BaseRPCMessagesSchema : NonNullable<I["messages"]>;
+type ResolvedRpcSchema<I extends InputRpcSchema> = {
+  requests: undefined extends I["requests"] ? BaseRpcRequestsSchema : NonNullable<I["requests"]>;
+  messages: undefined extends I["messages"] ? BaseRpcMessagesSchema : NonNullable<I["messages"]>;
 };
 
-export type RPCSchema<I extends InputRPCSchema | void = InputRPCSchema> = ResolvedRPCSchema<
-  I extends InputRPCSchema ? I : InputRPCSchema
+export type RpcSchema<I extends InputRpcSchema | void = InputRpcSchema> = ResolvedRpcSchema<
+  I extends InputRpcSchema ? I : InputRpcSchema
 >;
 
-type RequestParams<RS extends RPCRequestsSchema, M extends keyof RS> = RS[M]["params"];
-type RequestResponse<RS extends RPCRequestsSchema, M extends keyof RS> = RS[M]["response"];
-type MessagePayload<MS extends RPCMessagesSchema, N extends keyof MS> = MS[N];
+type RequestParams<RS extends RpcRequestsSchema, M extends keyof RS> = RS[M]["params"];
+type RequestResponse<RS extends RpcRequestsSchema, M extends keyof RS> = RS[M]["response"];
+type MessagePayload<MS extends RpcMessagesSchema, N extends keyof MS> = MS[N];
 
-type RPCRequestHandlerFn<RS extends RPCRequestsSchema> = <M extends keyof RS>(
+type RpcRequestHandlerFn<RS extends RpcRequestsSchema> = <M extends keyof RS>(
   method: M,
   params: RequestParams<RS, M>
 ) => Promise<RequestResponse<RS, M>> | RequestResponse<RS, M>;
 
-type RPCRequestHandlerObject<RS extends RPCRequestsSchema> = {
+type RpcRequestHandlerObject<RS extends RpcRequestsSchema> = {
   [M in keyof RS]?: (
     ...args: undefined extends RS[M]["params"] ? [params?: RS[M]["params"]] : [params: RS[M]["params"]]
   ) => Promise<Awaited<RequestResponse<RS, M>>> | Awaited<RequestResponse<RS, M>>;
@@ -61,34 +61,34 @@ type RPCRequestHandlerObject<RS extends RPCRequestsSchema> = {
   _?: (method: keyof RS, params: RequestParams<RS, keyof RS>) => unknown;
 };
 
-export type RPCRequestHandler<RS extends RPCRequestsSchema = RPCRequestsSchema> =
-  | RPCRequestHandlerFn<RS>
-  | RPCRequestHandlerObject<RS>;
+export type RpcRequestHandler<RS extends RpcRequestsSchema = RpcRequestsSchema> =
+  | RpcRequestHandlerFn<RS>
+  | RpcRequestHandlerObject<RS>;
 
-export type RPCTransport = {
-  send?: (data: RPCPacket) => void;
-  registerHandler?: (handler: (packet: RPCPacket) => void) => void;
+export type RpcTransport = {
+  send?: (data: RpcPacket) => void;
+  registerHandler?: (handler: (packet: RpcPacket) => void) => void;
   unregisterHandler?: () => void;
 };
 
-export interface RPCWithTransport {
-  setTransport: (transport: RPCTransport) => void;
+export interface RpcWithTransport {
+  setTransport: (transport: RpcTransport) => void;
 }
 
-export type BuniteRPCSchema = {
-  bun: RPCSchema;
-  webview: RPCSchema;
+export type BuniteRpcSchema = {
+  bun: RpcSchema;
+  webview: RpcSchema;
 };
 
 type RemoteSideOf<S extends "bun" | "webview"> = S extends "bun" ? "webview" : "bun";
 
-export type BuniteRPCConfig<
-  Schema extends BuniteRPCSchema,
+export type BuniteRpcConfig<
+  Schema extends BuniteRpcSchema,
   Side extends "bun" | "webview"
 > = {
   maxRequestTime?: number;
   handlers: {
-    requests?: RPCRequestHandler<Schema[Side]["requests"]>;
+    requests?: RpcRequestHandler<Schema[Side]["requests"]>;
     messages?: {
       [K in keyof Schema[RemoteSideOf<Side>]["messages"]]?: (
         payload: MessagePayload<Schema[RemoteSideOf<Side>]["messages"], K>
@@ -111,33 +111,33 @@ function missingTransportMethodError(methods: string[], action: string): Error {
   );
 }
 
-export function createRPC<
-  Schema extends RPCSchema = RPCSchema,
-  RemoteSchema extends RPCSchema = Schema
+export function createRpc<
+  Schema extends RpcSchema = RpcSchema,
+  RemoteSchema extends RpcSchema = Schema
 >(options: {
-  transport?: RPCTransport;
-  requestHandler?: RPCRequestHandler<Schema["requests"]>;
+  transport?: RpcTransport;
+  requestHandler?: RpcRequestHandler<Schema["requests"]>;
   maxRequestTime?: number;
 } = {}) {
-  let transport: RPCTransport = {};
+  let transport: RpcTransport = {};
   let requestHandler:
-    | RPCRequestHandlerFn<Schema["requests"]>
+    | RpcRequestHandlerFn<Schema["requests"]>
     | undefined;
 
-  function setTransport(nextTransport: RPCTransport) {
+  function setTransport(nextTransport: RpcTransport) {
     transport.unregisterHandler?.();
     transport = nextTransport;
     transport.registerHandler?.(handlePacket);
   }
 
-  function setRequestHandler(handler: RPCRequestHandler<Schema["requests"]>) {
+  function setRequestHandler(handler: RpcRequestHandler<Schema["requests"]>) {
     if (typeof handler === "function") {
-      requestHandler = handler as RPCRequestHandlerFn<Schema["requests"]>;
+      requestHandler = handler as RpcRequestHandlerFn<Schema["requests"]>;
       return;
     }
 
     requestHandler = (method, params) => {
-      const requestHandlerObject = handler as RPCRequestHandlerObject<Schema["requests"]>;
+      const requestHandlerObject = handler as RpcRequestHandlerObject<Schema["requests"]>;
       const specificHandler = requestHandlerObject[method];
       if (specificHandler) {
         return (specificHandler as (...args: [unknown]) => unknown)(params);
@@ -190,7 +190,7 @@ export function createRPC<
 
     const id = nextRequestId();
     const params = args[0];
-    const packet: RPCRequestPacket = {
+    const packet: RpcRequestPacket = {
       type: "request",
       id,
       method: String(method),
@@ -257,7 +257,7 @@ export function createRPC<
     messageListeners.get(String(messageName))?.delete(listener as (payload: unknown) => void);
   }
 
-  async function handlePacket(packet: RPCPacket) {
+  async function handlePacket(packet: RpcPacket) {
     if (packet.type === "request") {
       if (!transport.send || !requestHandler) {
         throw missingTransportMethodError(["send", "requestHandler"], "handle requests");
@@ -370,11 +370,11 @@ export function createRPC<
   };
 }
 
-function defineSideRPC<
-  Schema extends BuniteRPCSchema,
+function defineSideRpc<
+  Schema extends BuniteRpcSchema,
   Side extends "bun" | "webview"
 >(
-  config: BuniteRPCConfig<Schema, Side> & {
+  config: BuniteRpcConfig<Schema, Side> & {
     extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
   }
 ) {
@@ -388,12 +388,12 @@ function defineSideRPC<
     messages: Schema[Side]["messages"];
   };
 
-  const rpc = createRPC<LocalSchema, RemoteSchema>({
+  const rpc = createRpc<LocalSchema, RemoteSchema>({
     maxRequestTime: config.maxRequestTime,
     requestHandler: {
       ...(config.handlers.requests ?? {}),
       ...(config.extraRequestHandlers ?? {})
-    } as RPCRequestHandler<LocalSchema["requests"]>,
+    } as RpcRequestHandler<LocalSchema["requests"]>,
     transport: {
       registerHandler: () => {}
     }
@@ -416,18 +416,18 @@ function defineSideRPC<
   return rpc;
 }
 
-export function defineBunRPC<Schema extends BuniteRPCSchema>(
-  config: BuniteRPCConfig<Schema, "bun"> & {
+export function defineBunRpc<Schema extends BuniteRpcSchema>(
+  config: BuniteRpcConfig<Schema, "bun"> & {
     extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
   }
 ) {
-  return defineSideRPC<Schema, "bun">(config);
+  return defineSideRpc<Schema, "bun">(config);
 }
 
-export function defineWebviewRPC<Schema extends BuniteRPCSchema>(
-  config: BuniteRPCConfig<Schema, "webview"> & {
+export function defineWebviewRpc<Schema extends BuniteRpcSchema>(
+  config: BuniteRpcConfig<Schema, "webview"> & {
     extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
   }
 ) {
-  return defineSideRPC<Schema, "webview">(config);
+  return defineSideRpc<Schema, "webview">(config);
 }

package/src/shared/rpcDemux.ts

@@ -1,6 +1,6 @@
-import type { RPCPacket, RPCTransport, RPCWithTransport } from "./rpc";
+import type { RpcPacket, RpcTransport, RpcWithTransport } from "./rpc";
 
-type DemuxPacketEnvelope = { channel: string; packet: RPCPacket };
+type DemuxPacketEnvelope = { channel: string; packet: RpcPacket };
 type DemuxHelloFrame = { channel: string; hello: true };
 type DemuxFrame = DemuxPacketEnvelope | DemuxHelloFrame;
 
@@ -18,27 +18,27 @@ function isHelloFrame(frame: DemuxFrame): frame is DemuxHelloFrame {
   return (frame as DemuxHelloFrame).hello === true;
 }
 
-export type ChannelHandle = {
+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>;
+  bindTo(rpc: RpcWithTransport): Promise<void>;
 };
 
-export type TransportDemuxer = {
-  channel(name: string): ChannelHandle;
+export type RpcTransportDemuxer = {
+  channel(name: string): RpcChannelHandle;
   dispose(): void;
 };
 
-export type TransportDemuxerOptions = {
+export type RpcTransportDemuxerOptions = {
   /** ms to wait for peer before `bindTo` rejects. Default 10_000. */
   readyTimeout?: number;
 };
 
 type ChannelState = {
-  handler?: (packet: RPCPacket) => void;
+  handler?: (packet: RpcPacket) => void;
   peerSawUs: boolean;
   ready: Promise<void>;
   resolveReady: () => void;
@@ -49,12 +49,12 @@ type ChannelState = {
 
 const DEFAULT_READY_TIMEOUT = 10_000;
 
-export function createTransportDemuxer(
-  base: RPCTransport,
-  options: TransportDemuxerOptions = {}
-): TransportDemuxer {
+export function createRpcTransportDemuxer(
+  base: RpcTransport,
+  options: RpcTransportDemuxerOptions = {}
+): RpcTransportDemuxer {
   if (!base.send || !base.registerHandler) {
-    throw new Error("createTransportDemuxer requires a base transport with both send and registerHandler");
+    throw new Error("createRpcTransportDemuxer requires a base transport with both send and registerHandler");
   }
 
   const readyTimeout = options.readyTimeout ?? DEFAULT_READY_TIMEOUT;
@@ -93,7 +93,7 @@ export function createTransportDemuxer(
 
   function sendHello(name: string) {
     const frame: DemuxHelloFrame = { channel: name, hello: true };
-    base.send!(frame as unknown as RPCPacket);
+    base.send!(frame as unknown as RpcPacket);
   }
 
   base.registerHandler((data) => {
@@ -120,11 +120,11 @@ export function createTransportDemuxer(
     channel(name) {
       const state = getOrCreateState(name);
 
-      const transport: RPCTransport = {
+      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);
+          base.send!(envelope as unknown as RpcPacket);
         },
         registerHandler(handler) {
           if (disposed) throw new Error(`Demuxer disposed; cannot register on channel "${name}"`);

package/src/shared/rpcWire.ts

@@ -1,20 +1,20 @@
 import { pack, unpack } from "msgpackr";
-import type { RPCPacket } from "./rpc";
+import type { RpcPacket } from "./rpc";
 import {
   RPC_AUTH_TAG_LENGTH,
   RPC_FRAME_VERSION,
   RPC_IV_LENGTH
 } from "./rpcWireConstants";
 
-export function encodeRPCPacket(packet: RPCPacket): Uint8Array {
+export function encodeRpcPacket(packet: RpcPacket): Uint8Array {
   return pack(packet) as Uint8Array;
 }
 
-export function decodeRPCPacket(data: Uint8Array): RPCPacket {
-  return unpack(data) as RPCPacket;
+export function decodeRpcPacket(data: Uint8Array): RpcPacket {
+  return unpack(data) as RpcPacket;
 }
 
-export function createEncryptedRPCFrame(
+export function createEncryptedRpcFrame(
   iv: Uint8Array,
   encryptedPayload: Uint8Array
 ): Uint8Array {
@@ -29,7 +29,7 @@ export function createEncryptedRPCFrame(
   return frame;
 }
 
-export function parseEncryptedRPCFrame(frame: Uint8Array) {
+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.");
   }

package/src/shared/webRpcHandler.ts

@@ -1,33 +1,33 @@
 import {
-  defineBunRPC,
-  type BuniteRPCConfig,
-  type BuniteRPCSchema
+  defineBunRpc,
+  type BuniteRpcConfig,
+  type BuniteRpcSchema
 } from "./rpc";
 import { createWebSocketTransport, type WebSocketLike } from "./webSocketTransport";
 import { log } from "./log";
 
-export type WebRPCClient<Schema extends BuniteRPCSchema = BuniteRPCSchema> = {
+export type WebRpcClient<Schema extends BuniteRpcSchema = BuniteRpcSchema> = {
   ws: WebSocketLike;
-  rpc: ReturnType<typeof defineBunRPC<Schema>>;
+  rpc: ReturnType<typeof defineBunRpc<Schema>>;
 };
 
-export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
-  config: BuniteRPCConfig<Schema, "bun"> & {
+export function createWebRpcHandler<Schema extends BuniteRpcSchema>(
+  config: BuniteRpcConfig<Schema, "bun"> & {
     extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
   }
 ) {
-  type Entry = { client: WebRPCClient<Schema>; receive: (raw: ArrayBuffer | Uint8Array) => void };
+  type Entry = { client: WebRpcClient<Schema>; receive: (raw: ArrayBuffer | Uint8Array) => void };
 
   const connections = new WeakMap<WebSocketLike, Entry>();
-  const webClients = new Set<WebRPCClient<Schema>>();
+  const webClients = new Set<WebRpcClient<Schema>>();
 
   const handler = {
     open(ws: WebSocketLike) {
       const pipe = createWebSocketTransport(ws);
-      const rpc = defineBunRPC(config);
+      const rpc = defineBunRpc(config);
       rpc.setTransport(pipe.transport);
 
-      const client: WebRPCClient<Schema> = { ws, rpc: rpc as WebRPCClient<Schema>["rpc"] };
+      const client: WebRpcClient<Schema> = { ws, rpc: rpc as WebRpcClient<Schema>["rpc"] };
 
       connections.set(ws, { client, receive: pipe.receive });
       webClients.add(client);
@@ -56,7 +56,7 @@ export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
       handler.onWebClientDisconnected?.(entry.client);
     },
 
-    webClients: webClients as ReadonlySet<WebRPCClient<Schema>>,
+    webClients: webClients as ReadonlySet<WebRpcClient<Schema>>,
 
     broadcast<M extends keyof Schema["bun"]["messages"]>(
       messageName: M,
@@ -71,8 +71,8 @@ export function createWebRPCHandler<Schema extends BuniteRPCSchema>(
       }
     },
 
-    onWebClientConnected: undefined as ((client: WebRPCClient<Schema>) => void) | undefined,
-    onWebClientDisconnected: undefined as ((client: WebRPCClient<Schema>) => void) | undefined,
+    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 +1,26 @@
-import type { RPCPacket, RPCTransport } from "./rpc";
-import { asUint8Array, decodeRPCPacket, encodeRPCPacket } from "./rpcWire";
+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;
+  transport: RpcTransport;
   receive(raw: ArrayBuffer | ArrayBufferView | Uint8Array): void;
 };
 
 export function createWebSocketTransport(ws: WebSocketLike): WebSocketTransportPipe {
-  let handler: ((packet: RPCPacket) => void) | undefined;
+  let handler: ((packet: RpcPacket) => void) | undefined;
 
   return {
     transport: {
-      send(packet) { ws.send(encodeRPCPacket(packet)); },
+      send(packet) { ws.send(encodeRpcPacket(packet)); },
       registerHandler(h) { handler = h; },
       unregisterHandler() { handler = undefined; }
     },
     receive(raw) {
-      handler?.(decodeRPCPacket(asUint8Array(raw)));
+      handler?.(decodeRpcPacket(asUint8Array(raw)));
     }
   };
 }

package/src/view/index.ts

@@ -1,16 +1,16 @@
 import "../shared/webviewPolyfill";
 import {
-  defineWebviewRPC,
-  type BuniteRPCConfig,
-  type RPCPacket,
-  type BuniteRPCSchema,
-  type RPCSchema,
-  type RPCTransport,
-  type RPCWithTransport
+  defineWebviewRpc,
+  type BuniteRpcConfig,
+  type RpcPacket,
+  type BuniteRpcSchema,
+  type RpcSchema,
+  type RpcTransport,
+  type RpcWithTransport
 } from "../shared/rpc";
-import { createTransportDemuxer, type ChannelHandle, type TransportDemuxer, type TransportDemuxerOptions } from "../shared/rpcDemux";
+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 { decodeRpcPacket, encodeRpcPacket } from "../shared/rpcWire";
 import { log } from "../shared/log";
 
 type BuniteWindowGlobals = Window &
@@ -36,13 +36,13 @@ function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
   return copy.buffer;
 }
 
-export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
+export class BuniteView<T extends RpcWithTransport = RpcWithTransport> {
   bunSocket?: WebSocket;
   rpc?: T;
-  readonly transport: RPCTransport;
+  readonly transport: RpcTransport;
 
-  private handler?: (packet: RPCPacket) => void;
-  private pendingPackets: RPCPacket[] = [];
+  private handler?: (packet: RpcPacket) => void;
+  private pendingPackets: RpcPacket[] = [];
 
   constructor(config?: { rpc?: T }) {
     this.rpc = config?.rpc;
@@ -63,19 +63,19 @@ export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
     if (isNative) {
       buniteWindow.__bunite ??= {};
       buniteWindow.__bunite.receiveMessageFromBun = (message) => {
-        this.handler?.(message as RPCPacket);
+        this.handler?.(message as RpcPacket);
       };
     }
     this.rpc?.setTransport(this.transport);
   }
 
-  private sendPacket(packet: RPCPacket) {
+  private sendPacket(packet: RpcPacket) {
     if (isNative) {
       void this.bunBridge(packet).catch((error) => {
         log.error("Failed to send RPC packet", error);
       });
     } else {
-      this.bunSocket!.send(toArrayBuffer(encodeRPCPacket(packet)));
+      this.bunSocket!.send(toArrayBuffer(encodeRpcPacket(packet)));
     }
   }
 
@@ -90,7 +90,7 @@ export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
         const bytes = await messageToUint8Array(event.data);
         if (!bytes) return;
         try {
-          this.handler?.(decodeRPCPacket(bytes));
+          this.handler?.(decodeRpcPacket(bytes));
         } catch (error) {
           log.error("Failed to parse WebSocket message", error);
         }
@@ -122,7 +122,7 @@ export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
             return;
           }
           const decrypted = await decrypt(binaryMessage);
-          const packet = decodeRPCPacket(decrypted);
+          const packet = decodeRpcPacket(decrypted);
           if ((packet as any).scope === "global") return;
           this.handler?.(packet);
         } catch (error) {
@@ -148,7 +148,7 @@ export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
     });
   }
 
-  async bunBridge(message: RPCPacket) {
+  async bunBridge(message: RpcPacket) {
     if (this.bunSocket?.readyState !== WebSocket.OPEN) return;
 
     const encrypt = buniteWindow.__bunite_encrypt;
@@ -157,7 +157,7 @@ export class BuniteView<T extends RPCWithTransport = RPCWithTransport> {
       return;
     }
 
-    const encrypted = await encrypt(encodeRPCPacket(message));
+    const encrypted = await encrypt(encodeRpcPacket(message));
     this.bunSocket.send(toArrayBuffer(encrypted));
   }
 
@@ -171,15 +171,15 @@ async function messageToUint8Array(data: unknown) {
 }
 
 export { log, type LogLevel } from "../shared/log";
-export { createTransportDemuxer, createWebSocketTransport, defineWebviewRPC };
+export { createRpcTransportDemuxer, createWebSocketTransport, defineWebviewRpc };
 
 export type {
-  BuniteRPCConfig,
-  BuniteRPCSchema,
-  ChannelHandle,
-  RPCSchema,
-  TransportDemuxer,
-  TransportDemuxerOptions,
+  BuniteRpcConfig,
+  BuniteRpcSchema,
+  RpcChannelHandle,
+  RpcSchema,
+  RpcTransportDemuxer,
+  RpcTransportDemuxerOptions,
   WebSocketLike,
   WebSocketTransportPipe
 };