bunite-core 0.8.1 → 0.9.0

package/src/{preload/webviewElement.ts → webview/native.ts}

@@ -1,11 +1,30 @@
 // <bunite-webview> custom element — registered in every appres:// page via preload.
 
-declare const bunite: {
-  invoke: (method: string, params?: unknown) => Promise<any>;
-  on: (channel: string, handler: (data: any) => void) => (() => void);
-  off: (channel: string, handler: (data: any) => void) => void;
+import type { ClientOf } from "../rpc/index";
+import type { SurfaceCap } from "../rpc/framework";
+
+declare const host: {
+  runtime(): Promise<ClientOf<typeof import("../rpc/framework").RuntimeCap>>;
 };
 
+type SurfaceClient = ClientOf<typeof SurfaceCap>;
+let _surfaceCap: Promise<SurfaceClient> | null = null;
+function getSurfaceCap(): Promise<SurfaceClient> {
+  if (!_surfaceCap) {
+    _surfaceCap = host.runtime().then((r) => r.surface());
+  }
+  return _surfaceCap;
+}
+
+function callSurface<R>(fn: (s: SurfaceClient) => Promise<R> | R): Promise<R | void> {
+  return getSurfaceCap().then(fn).catch((err) => {
+    if ((globalThis as { __BUNITE_DEBUG__?: boolean }).__BUNITE_DEBUG__) {
+      console.warn("[bunite] surface call failed", err);
+    }
+    return undefined;
+  });
+}
+
 // OverlaySyncController: ResizeObserver + rAF position polling; dirty-flag coalescing ≤1 IPC/frame.
 
 type Rect = { x: number; y: number; width: number; height: number };
@@ -105,11 +124,24 @@ class BuniteWebviewElement extends HTMLElement {
     this._aborted = false;
     this._syncHidden = false;
     this._userHidden = false;
-    this._unsubNavigate = bunite.on("__bunite:webview.didNavigate", (data: any) => {
-      if (data?.surfaceId === this._surfaceId) {
-        this.dispatchEvent(new CustomEvent("did-navigate", { detail: { url: data.url } }));
+    const ctrl = new AbortController();
+    this._unsubNavigate = () => ctrl.abort();
+    void (async () => {
+      try {
+        const s = await getSurfaceCap();
+        const stream = s.didNavigate();
+        for await (const ev of stream) {
+          if (ctrl.signal.aborted) break;
+          if (ev.surfaceId === this._surfaceId) {
+            this.dispatchEvent(new CustomEvent("did-navigate", { detail: { url: ev.url } }));
+          }
+        }
+      } catch (err) {
+        if ((globalThis as { __BUNITE_DEBUG__?: boolean }).__BUNITE_DEBUG__) {
+          console.warn("[bunite] didNavigate stream failed", err);
+        }
       }
-    });
+    })();
     this._waitForLayout();
   }
 
@@ -152,12 +184,10 @@ class BuniteWebviewElement extends HTMLElement {
     if (this._surfaceId != null) {
       const id = this._surfaceId;
       this._surfaceId = null;
-      bunite.invoke("__bunite:surface.remove", { surfaceId: id }).catch(() => {});
+      void callSurface((s) => s.remove({ surfaceId: id }));
     } else if (this._initPromise) {
       this._initPromise
-        .then((r) => {
-          bunite.invoke("__bunite:surface.remove", { surfaceId: r.surfaceId }).catch(() => {});
-        })
+        .then((r) => { void callSurface((s) => s.remove({ surfaceId: r.surfaceId })); })
         .catch(() => {});
     }
     this._initPromise = null;
@@ -166,10 +196,8 @@ class BuniteWebviewElement extends HTMLElement {
   attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null) {
     if (name !== "src") return;
     if (this._surfaceId != null) {
-      bunite.invoke("__bunite:webview.navigate", {
-        surfaceId: this._surfaceId,
-        url: newValue || ""
-      }).catch(() => {});
+      const sid = this._surfaceId;
+      void callSurface((s) => s.navigate({ surfaceId: sid, url: newValue || "" }));
     } else if (this._initPromise) {
       // Init in progress — queue for after completion
       this._pendingSrc = newValue || "";
@@ -185,13 +213,13 @@ class BuniteWebviewElement extends HTMLElement {
   }
 
   goBack() {
-    if (this._surfaceId != null)
-      bunite.invoke("__bunite:webview.goBack", { surfaceId: this._surfaceId }).catch(() => {});
+    const sid = this._surfaceId;
+    if (sid != null) void callSurface((s) => s.goBack({ surfaceId: sid }));
   }
 
   reload() {
-    if (this._surfaceId != null)
-      bunite.invoke("__bunite:webview.reload", { surfaceId: this._surfaceId }).catch(() => {});
+    const sid = this._surfaceId;
+    if (sid != null) void callSurface((s) => s.reload({ surfaceId: sid }));
   }
 
   navigate(url: string) {
@@ -199,11 +227,10 @@ class BuniteWebviewElement extends HTMLElement {
   }
 
   private _applySurfaceHidden() {
-    if (this._surfaceId == null) return;
-    bunite.invoke("__bunite:surface.setHidden", {
-      surfaceId: this._surfaceId,
-      hidden: this._userHidden || this._syncHidden
-    }).catch(() => {});
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    const hidden = this._userHidden || this._syncHidden;
+    void callSurface((s) => s.setHidden({ surfaceId: sid, hidden }));
   }
 
   private initSurface() {
@@ -214,43 +241,42 @@ class BuniteWebviewElement extends HTMLElement {
     const src = this._pendingSrc || this.getAttribute("src") || "";
     this._pendingSrc = null;
 
-    const initPromise = bunite.invoke("__bunite:surface.init", {
+    const initPromise = getSurfaceCap().then((s) => s.init({
       src,
       x: Math.round(r.x * dpr),
       y: Math.round(r.y * dpr),
       width: Math.round(r.width * dpr),
       height: Math.round(r.height * dpr),
-      hidden: this._userHidden
-    }) as Promise<SurfaceInitResponse>;
+      hidden: this._userHidden,
+    })) as Promise<SurfaceInitResponse>;
     this._initPromise = initPromise;
 
     initPromise
       .then((response) => {
         if (this._initPromise !== initPromise) return;
         if (this._aborted) {
-          bunite.invoke("__bunite:surface.remove", { surfaceId: response.surfaceId }).catch(() => {});
+          void callSurface((s) => s.remove({ surfaceId: response.surfaceId }));
           return;
         }
 
         this._surfaceId = response.surfaceId;
 
-        // Apply hidden state that was set during init
         if (this._userHidden) {
           this._applySurfaceHidden();
         }
 
-        // Apply src that was set before init completed
         if (this._pendingSrc != null) {
           const pending = this._pendingSrc;
           this._pendingSrc = null;
-          bunite.invoke("__bunite:webview.navigate", {
-            surfaceId: this._surfaceId,
-            url: pending
-          }).catch(() => {});
+          const sid = this._surfaceId;
+          if (sid != null) {
+            void callSurface((s) => s.navigate({ surfaceId: sid, url: pending }));
+          }
         }
 
         this._syncCtrl = new OverlaySyncController(this, (rect) => {
-          if (this._surfaceId == null) return;
+          const sid = this._surfaceId;
+          if (sid == null) return;
 
           const isZero = rect.width === 0 && rect.height === 0;
           if (isZero) {
@@ -265,13 +291,9 @@ class BuniteWebviewElement extends HTMLElement {
             this._applySurfaceHidden();
           }
 
-          bunite.invoke("__bunite:surface.resize", {
-            surfaceId: this._surfaceId,
-            x: rect.x,
-            y: rect.y,
-            w: rect.width,
-            h: rect.height
-          }).catch(() => {});
+          void callSurface((s) => s.resize({
+            surfaceId: sid, x: rect.x, y: rect.y, w: rect.width, h: rect.height,
+          }));
         });
         this._syncCtrl.start();
       })
@@ -287,16 +309,14 @@ class BuniteWebviewElement extends HTMLElement {
 if (typeof customElements !== "undefined") {
   customElements.define("bunite-webview", BuniteWebviewElement);
 
-  // Host BrowserView HWND covers surface HWNDs on focus — re-raise.
-  const raiseAll = () => bunite.invoke("__bunite:surface.bringAllVisiblesToFront").catch(() => {});
+  const raiseAll = () => { void callSurface((s) => s.bringAllVisiblesToFront()); };
   document.addEventListener("pointerdown", raiseAll, true);
 
-  // Send surfaces behind host during drag so OLE DragDrop reaches host's IDropTarget.
   document.addEventListener("dragstart", () => {
-    bunite.invoke("__bunite:surface.setAllPassthrough", { passthrough: true }).catch(() => {});
+    void callSurface((s) => s.setAllPassthrough({ passthrough: true }));
   }, true);
   document.addEventListener("dragend", () => {
-    bunite.invoke("__bunite:surface.setAllPassthrough", { passthrough: false }).catch(() => {});
+    void callSurface((s) => s.setAllPassthrough({ passthrough: false }));
     raiseAll();
   }, true);
 }

package/src/{shared/webviewPolyfill.ts → webview/polyfill.ts}

@@ -124,10 +124,9 @@ function definePolyfillClass(): CustomElementConstructor {
 }
 
 /**
- * Register the `<bunite-webview>` iframe polyfill. No-op in non-browser
- * environments and when the native CEF preload has already registered the element.
- * `BuniteView` calls this automatically on construction; call directly only when
- * using `<bunite-webview>` markup without instantiating `BuniteView`.
+ * `<bunite-webview>` iframe polyfill — `import "bunite-core/polyfill"` to register.
+ * No-op in non-browser environments and when the native CEF preload has already
+ * registered the element.
  *
  * Defaults (web fallback only — native paths bypass these):
  * - `sandbox="allow-scripts allow-forms allow-popups"` (popup-escape stays opt-in).
@@ -140,8 +139,6 @@ function definePolyfillClass(): CustomElementConstructor {
  * - `sandbox="..."` — override the default sandbox token string verbatim.
  * - `unsandboxed` — remove the sandbox attribute entirely (trusted-content escape hatch).
  */
-export function registerBuniteWebviewPolyfill() {
-  if (typeof customElements === "undefined") return;
-  if (customElements.get("bunite-webview")) return;
+if (typeof customElements !== "undefined" && !customElements.get("bunite-webview")) {
   customElements.define("bunite-webview", definePolyfillClass());
 }

package/src/bun/core/Socket.ts

@@ -1,187 +0,0 @@
-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 { GlobalIPCHandler } from "./App";
-import { log } from "../../shared/log";
-import {
-  asUint8Array,
-  createEncryptedRpcFrame,
-  decodeRpcPacket,
-  encodeRpcPacket,
-  parseEncryptedRpcFrame
-} from "../../shared/rpcWire";
-import { RPC_AUTH_TAG_LENGTH } from "../../shared/rpcWireConstants";
-
-type ViewRegistry = {
-  getById(id: number): BrowserView | undefined;
-};
-
-type WebSocketData = {
-  webviewId: number;
-};
-
-let rpcServer: Server<WebSocketData> | null = null;
-let rpcPort = 0;
-
-const socketMap: Record<number, ServerWebSocket<WebSocketData> | null> = {};
-let registry: ViewRegistry | null = null;
-let globalIPCResolver: ((channel: string) => GlobalIPCHandler | undefined) | null = null;
-
-export function attachGlobalIPCResolver(resolver: (channel: string) => GlobalIPCHandler | undefined) {
-  globalIPCResolver = resolver;
-}
-
-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));
-}
-
-function decrypt(secretKey: Uint8Array, frame: Uint8Array) {
-  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);
-  decipher.setAuthTag(tag);
-  return new Uint8Array(Buffer.concat([decipher.update(ciphertext), decipher.final()]));
-}
-
-function normalizeIncomingBinaryMessage(
-  message: string | ArrayBuffer | Uint8Array | Buffer
-): Uint8Array | null {
-  if (typeof message === "string") {
-    return null;
-  }
-  return asUint8Array(message);
-}
-
-export function attachBrowserViewRegistry(nextRegistry: ViewRegistry) {
-  registry = nextRegistry;
-}
-
-export function ensureRpcServer() {
-  if (rpcServer) {
-    return { rpcServer, rpcPort };
-  }
-
-  let port = 45000;
-  while (port <= 65535) {
-    try {
-      rpcServer = Bun.serve<WebSocketData>({
-        hostname: "127.0.0.1",
-        port,
-        fetch(req, server) {
-          const url = new URL(req.url);
-          if (url.pathname !== "/socket") {
-            return new Response("Not found", { status: 404 });
-          }
-
-          const webviewId = Number(url.searchParams.get("webviewId"));
-          if (!Number.isFinite(webviewId)) {
-            return new Response("Missing webviewId", { status: 400 });
-          }
-          if (!registry?.getById(webviewId)) {
-            return new Response("Unknown webviewId", { status: 403 });
-          }
-
-          const upgraded = server.upgrade(req, {
-            data: { webviewId }
-          });
-          return upgraded ? undefined : new Response("Upgrade failed", { status: 500 });
-        },
-        websocket: {
-          open(ws) {
-            socketMap[ws.data.webviewId] = ws;
-          },
-          close(ws) {
-            socketMap[ws.data.webviewId] = null;
-          },
-          message(ws, message) {
-            const view = registry?.getById(ws.data.webviewId);
-            const binaryMessage = normalizeIncomingBinaryMessage(message);
-            if (!view || !binaryMessage) {
-              return;
-            }
-            try {
-              const decryptedMessage = decrypt(view.secretKey, binaryMessage);
-              const packet = decodeRpcPacket(decryptedMessage);
-
-              if (packet.type === "request" && (packet as RpcRequestPacket).scope === "global") {
-                void handleGlobalIPC(packet as RpcRequestPacket, ws.data.webviewId);
-                return;
-              }
-
-              view.handleIncomingRpc(packet);
-            } catch (error) {
-              log.error("Failed to parse RPC payload", error);
-            }
-          }
-        }
-      });
-      rpcPort = port;
-      break;
-    } catch (error: any) {
-      if (error?.code === "EADDRINUSE") {
-        port += 1;
-        continue;
-      }
-      throw error;
-    }
-  }
-
-  if (!rpcServer) {
-    throw new Error("Could not start bunite RPC server.");
-  }
-
-  return { rpcServer, rpcPort };
-}
-
-export function getRpcPort(): number {
-  return rpcPort;
-}
-
-async function handleGlobalIPC(packet: RpcRequestPacket, viewId: number) {
-  const handler = globalIPCResolver?.(packet.method);
-  if (!handler) {
-    sendMessageToView(viewId, {
-      type: "response",
-      id: packet.id,
-      success: false,
-      error: `No handler registered for: ${packet.method}`,
-      scope: "global"
-    });
-    return;
-  }
-  try {
-    const result = await handler(packet.params, { viewId });
-    sendMessageToView(viewId, {
-      type: "response",
-      id: packet.id,
-      success: true,
-      payload: result,
-      scope: "global"
-    });
-  } catch (error) {
-    sendMessageToView(viewId, {
-      type: "response",
-      id: packet.id,
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      scope: "global"
-    });
-  }
-}
-
-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));
-  socket.send(encrypted);
-  return true;
-}

package/src/bun/core/SurfaceBrowserIPC.ts

@@ -1,65 +0,0 @@
-import { getOwnedSurface } from "./SurfaceRegistry";
-import { sendMessageToView } from "./Socket";
-import { onSurfaceInit } from "./SurfaceManager";
-
-import type { GlobalIPCHandler } from "./App";
-
-// --- did-navigate forwarding ---
-
-onSurfaceInit((surfaceId, hostViewId, view) => {
-  view.on("did-navigate", (event: any) => {
-    sendMessageToView(hostViewId, {
-      type: "event",
-      channel: "__bunite:webview.didNavigate",
-      data: { surfaceId, url: event.data.detail }
-    });
-  });
-});
-
-// --- Helpers ---
-
-function assertNum(v: unknown, label: string): number {
-  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`Invalid ${label}`);
-  return v;
-}
-
-function assertStr(v: unknown, label: string): string {
-  if (typeof v !== "string") throw new Error(`Invalid ${label}`);
-  return v;
-}
-
-function assertObj(v: unknown, label: string): Record<string, unknown> {
-  if (!v || typeof v !== "object") throw new Error(`Invalid ${label}`);
-  return v as Record<string, unknown>;
-}
-
-// --- Handlers ---
-
-const handleGoBack: GlobalIPCHandler = async (params, ctx) => {
-  const record = getOwnedSurface(assertNum(assertObj(params, "p").surfaceId, "surfaceId"), ctx);
-  if (record) record.view.goBack();
-  return {};
-};
-
-const handleReload: GlobalIPCHandler = async (params, ctx) => {
-  const record = getOwnedSurface(assertNum(assertObj(params, "p").surfaceId, "surfaceId"), ctx);
-  if (record) record.view.reload();
-  return {};
-};
-
-const handleNavigate: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "webview.navigate params");
-  const surfaceId = assertNum(p.surfaceId, "surfaceId");
-  const url = assertStr(p.url, "url");
-  const record = getOwnedSurface(surfaceId, ctx);
-  if (record) record.view.loadURL(url);
-  return {};
-};
-
-export function getWebviewIPCHandlers(): Map<string, GlobalIPCHandler> {
-  return new Map([
-    ["__bunite:webview.goBack", handleGoBack],
-    ["__bunite:webview.reload", handleReload],
-    ["__bunite:webview.navigate", handleNavigate]
-  ]);
-}

package/src/bun/core/SurfaceManager.ts

@@ -1,201 +0,0 @@
-import { BrowserView } from "./BrowserView";
-import {
-  trackSurface, untrackSurface, getOwnedSurface,
-  getHostSurfaceIds, getSurfaceRecord,
-  MAX_SURFACES_PER_HOST
-} from "./SurfaceRegistry";
-
-import type { GlobalIPCHandler } from "./App";
-
-// --- Helpers ---
-
-function applyHostOffset(hostView: BrowserView, x: number, y: number) {
-  return { x: x + hostView.frame.x, y: y + hostView.frame.y };
-}
-
-function assertNum(v: unknown, label: string): number {
-  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`Invalid ${label}`);
-  return v;
-}
-
-function assertBool(v: unknown, label: string): boolean {
-  if (typeof v !== "boolean") throw new Error(`Invalid ${label}`);
-  return v;
-}
-
-function assertStr(v: unknown, label: string): string {
-  if (typeof v !== "string") throw new Error(`Invalid ${label}`);
-  return v;
-}
-
-function assertObj(v: unknown, label: string): Record<string, unknown> {
-  if (!v || typeof v !== "object") throw new Error(`Invalid ${label}`);
-  return v as Record<string, unknown>;
-}
-
-// --- Surface lifecycle callbacks (called by SurfaceBrowserIPC after init) ---
-
-type SurfaceInitCallback = (surfaceId: number, hostViewId: number, view: BrowserView) => void;
-const initCallbacks: SurfaceInitCallback[] = [];
-
-export function onSurfaceInit(cb: SurfaceInitCallback) {
-  initCallbacks.push(cb);
-}
-
-// --- Handlers ---
-
-const handleSurfaceInit: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "surface.init params");
-  const src = assertStr(p.src, "src");
-  const x = assertNum(p.x, "x");
-  const y = assertNum(p.y, "y");
-  const width = assertNum(p.width, "width");
-  const height = assertNum(p.height, "height");
-  const hidden = typeof p.hidden === "boolean" ? p.hidden : false;
-
-  const hostView = BrowserView.getById(ctx.viewId);
-  if (!hostView) throw new Error(`Host view not found: ${ctx.viewId}`);
-  if (!hostView.windowId) throw new Error(`Host window not found for view: ${ctx.viewId}`);
-
-  const hostIds = getHostSurfaceIds(ctx.viewId);
-  if (hostIds && hostIds.size >= MAX_SURFACES_PER_HOST) {
-    throw new Error(`Surface limit reached (${MAX_SURFACES_PER_HOST}) for host view ${ctx.viewId}`);
-  }
-
-  const offset = applyHostOffset(hostView, x, y);
-  const view = new BrowserView({
-    url: src,
-    windowId: hostView.windowId,
-    appresRoot: hostView.appresRoot,
-    frame: { x: offset.x, y: offset.y, width, height },
-    autoResize: false
-  });
-  trackSurface(view.id, { view, hostViewId: ctx.viewId, hidden });
-  try {
-    await view.whenReady();
-  } catch {
-    untrackSurface(view.id);
-    view.remove();
-    throw new Error("Surface browser creation failed or timed out");
-  }
-
-  for (const cb of initCallbacks) cb(view.id, ctx.viewId, view);
-
-  if (hidden) {
-    view.setVisible(false);
-  } else {
-    view.bringToFront();
-  }
-  return { surfaceId: view.id };
-};
-
-const handleSurfaceResize: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "surface.resize params");
-  const surfaceId = assertNum(p.surfaceId, "surfaceId");
-  const x = assertNum(p.x, "x");
-  const y = assertNum(p.y, "y");
-  const w = assertNum(p.w, "w");
-  const h = assertNum(p.h, "h");
-
-  const record = getOwnedSurface(surfaceId, ctx);
-  if (!record) return {};
-
-  const hostView = BrowserView.getById(ctx.viewId);
-  if (hostView) {
-    const offset = applyHostOffset(hostView, x, y);
-    record.view.setBoundsAsync(offset.x, offset.y, w, h);
-  }
-  return {};
-};
-
-const handleSurfaceRemove: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "surface.remove params");
-  const surfaceId = assertNum(p.surfaceId, "surfaceId");
-
-  const record = getOwnedSurface(surfaceId, ctx);
-  if (!record) return {};
-
-  untrackSurface(surfaceId);
-  record.view.remove();
-  return {};
-};
-
-const handleSurfaceSetHidden: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "surface.setHidden params");
-  const surfaceId = assertNum(p.surfaceId, "surfaceId");
-  const hidden = assertBool(p.hidden, "hidden");
-
-  const record = getOwnedSurface(surfaceId, ctx);
-  if (!record) return {};
-
-  record.hidden = hidden;
-  record.view.setVisible(!hidden);
-  if (!hidden) {
-    record.view.bringToFront();
-  }
-  return {};
-};
-
-const handleSurfaceSetMasks: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "surface.setMasks params");
-  const surfaceId = assertNum(p.surfaceId, "surfaceId");
-  const masksRaw = Array.isArray(p.masks) ? p.masks : [];
-
-  const record = getOwnedSurface(surfaceId, ctx);
-  if (!record) return {};
-
-  const hostView = BrowserView.getById(ctx.viewId);
-  if (!hostView) return {};
-
-  const offset = applyHostOffset(hostView, 0, 0);
-  const rects = masksRaw.map((r: any) => ({
-    x: assertNum(r.x, "mask.x") + offset.x,
-    y: assertNum(r.y, "mask.y") + offset.y,
-    w: assertNum(r.w, "mask.w"),
-    h: assertNum(r.h, "mask.h")
-  }));
-
-  record.view.setMaskRegion(rects);
-  return {};
-};
-
-const handleSurfaceSetAllPassthrough: GlobalIPCHandler = async (params, ctx) => {
-  const p = assertObj(params, "surface.setAllPassthrough params");
-  const passthrough = assertBool(p.passthrough, "passthrough");
-
-  const ids = getHostSurfaceIds(ctx.viewId);
-  if (!ids) return {};
-
-  for (const surfaceId of ids) {
-    const record = getSurfaceRecord(surfaceId);
-    if (record) {
-      record.view.setInputPassthrough(passthrough);
-    }
-  }
-  return {};
-};
-
-const handleSurfaceBringAllVisiblesToFront: GlobalIPCHandler = async (_params, ctx) => {
-  const ids = getHostSurfaceIds(ctx.viewId);
-  if (!ids) return {};
-
-  for (const surfaceId of ids) {
-    const record = getSurfaceRecord(surfaceId);
-    if (record && !record.hidden) {
-      record.view.bringToFront();
-    }
-  }
-  return {};
-};
-
-export function getSurfaceIPCHandlers(): Map<string, GlobalIPCHandler> {
-  return new Map([
-    ["__bunite:surface.init", handleSurfaceInit],
-    ["__bunite:surface.resize", handleSurfaceResize],
-    ["__bunite:surface.remove", handleSurfaceRemove],
-    ["__bunite:surface.setHidden", handleSurfaceSetHidden],
-    ["__bunite:surface.setMasks", handleSurfaceSetMasks],
-    ["__bunite:surface.setAllPassthrough", handleSurfaceSetAllPassthrough],
-    ["__bunite:surface.bringAllVisiblesToFront", handleSurfaceBringAllVisiblesToFront]
-  ]);
-}