bunite-core 0.17.1 → 0.17.3

package/src/preload/runtime.ts

@@ -1,13 +1,13 @@
 import {
+  type AnyCapDef,
+  type ClientOf,
+  type Connection,
   createConnection,
+  createEncryptedPipe,
   createFrameTransport,
   createWebSocketPipe,
-  createEncryptedPipe,
-  type Connection,
-  type CapDef,
   type Schema,
   type SchemaRoots,
-  type ClientOf,
   type WebSocketLike,
 } from "../rpc/index";
 
@@ -19,19 +19,28 @@ let _conn: Connection | null = null;
 let _connPromise: Promise<Connection> | null = null;
 
 function ensureConnection(): Promise<Connection> {
-  if (_conn) return Promise.resolve(_conn);
+  if (_conn) {
+    if (!_conn.closed) return Promise.resolve(_conn);
+    _conn = null;
+    _connPromise = null;
+  }
   if (_connPromise) return _connPromise;
   const attempt = (async () => {
     const ws = new WebSocket(
-      `ws://localhost:${__buniteRpcSocketPort}/rpc?webviewId=${__buniteWebviewId}`
+      `ws://localhost:${__buniteRpcSocketPort}/rpc?webviewId=${__buniteWebviewId}`,
     );
     ws.binaryType = "arraybuffer";
     await new Promise<void>((resolve, reject) => {
       ws.addEventListener("open", () => resolve(), { once: true });
-      ws.addEventListener("error", () => reject(new Error("bunite preload ws connect failed")), { once: true });
+      ws.addEventListener("error", () => reject(new Error("bunite preload ws connect failed")), {
+        once: true,
+      });
     });
     const rawKey = Uint8Array.from(atob(__buniteSecretKeyBase64), (c) => c.charCodeAt(0));
-    const pipe = await createEncryptedPipe(createWebSocketPipe(ws as unknown as WebSocketLike), rawKey);
+    const pipe = await createEncryptedPipe(
+      createWebSocketPipe(ws as unknown as WebSocketLike),
+      rawKey,
+    );
     const conn = createConnection({
       transport: createFrameTransport(pipe),
       mode: "native",
@@ -53,12 +62,13 @@ w.__buniteWebviewId = __buniteWebviewId;
 w.__buniteRpcSocketPort = __buniteRpcSocketPort;
 w.host ??= {};
 
-w.host.bootstrap = async (target: CapDef<any, any> | Schema<SchemaRoots>): Promise<unknown> => {
+w.host.bootstrap = async (target: AnyCapDef | Schema<SchemaRoots>): Promise<unknown> => {
   const conn = await ensureConnection();
   return (conn.bootstrap as (t: unknown) => Promise<unknown>)(target);
 };
 
-w.host.runtime = async () => (await ensureConnection()).runtime() as ClientOf<typeof import("../rpc/framework").RuntimeCap>;
+w.host.runtime = async () =>
+  (await ensureConnection()).runtime() as ClientOf<typeof import("../rpc/framework").RuntimeCap>;
 
 w.host.releaseRef = async (proxy: unknown): Promise<void> => {
   (await ensureConnection()).releaseRef(proxy);
@@ -89,10 +99,16 @@ const pageBuffer = (w as any)[CONSOLE_BUFFER_KEY] as ConsoleEntry[];
 function serializeArg(a: unknown): string {
   if (typeof a === "string") return a;
   if (a instanceof Error) return a.stack ?? a.message;
-  try { return JSON.stringify(a); } catch { return String(a); }
+  try {
+    return JSON.stringify(a);
+  } catch {
+    return String(a);
+  }
 }
 
-let reportingCap: Promise<{ reportConsoleBatch(args: { entries: ConsoleEntry[] }): Promise<void> | void }> | null = null;
+let reportingCap: Promise<{
+  reportConsoleBatch(args: { entries: ConsoleEntry[] }): Promise<void> | void;
+}> | null = null;
 // Circuit breaker: after a failed cap fetch, hold off for a cooldown so a
 // permanently-disconnected host doesn't burn a retry per batch (16ms cadence).
 let nextRetryMs = 0;
@@ -115,7 +131,10 @@ let batch: ConsoleEntry[] = [];
 let batchTimer: ReturnType<typeof setTimeout> | null = null;
 
 function flushBatch() {
-  if (batchTimer) { clearTimeout(batchTimer); batchTimer = null; }
+  if (batchTimer) {
+    clearTimeout(batchTimer);
+    batchTimer = null;
+  }
   if (batch.length === 0) return;
   const entries = batch;
   batch = [];
@@ -139,11 +158,17 @@ function scheduleFlush() {
 
 function installConsoleProxy() {
   for (const level of ["log", "warn", "error", "info", "debug"] as const) {
-    const original = (console as Record<ConsoleLevel, (...a: unknown[]) => void>)[level].bind(console);
+    const original = (console as Record<ConsoleLevel, (...a: unknown[]) => void>)[level].bind(
+      console,
+    );
     (console as Record<ConsoleLevel, (...a: unknown[]) => void>)[level] = (...args: unknown[]) => {
       // Original console first — preserve page-author dev experience even if
       // the bunite plumbing throws further down (shouldn't, but defensive).
-      try { original(...args); } catch { /* extreme: original throws */ }
+      try {
+        original(...args);
+      } catch {
+        /* extreme: original throws */
+      }
       try {
         const entry: ConsoleEntry = {
           level,
@@ -156,7 +181,9 @@ function installConsoleProxy() {
         }
         batch.push(entry);
         scheduleFlush();
-      } catch { /* never propagate to page */ }
+      } catch {
+        /* never propagate to page */
+      }
     };
   }
 }
@@ -176,7 +203,9 @@ function windowCap() {
       const wc = await rt.window();
       return await wc.current();
     })();
-    _windowCap.catch(() => { _windowCap = null; });
+    _windowCap.catch(() => {
+      _windowCap = null;
+    });
   }
   return _windowCap;
 }
@@ -193,13 +222,25 @@ function isDragHit(target: EventTarget | null): boolean {
 // call — lazy resolution (bootstrap + window + current) would otherwise miss
 // the drag's first frames while the cursor has already moved.
 void windowCap();
-document.addEventListener("mousedown", (e) => {
-  if (e.button !== 0 || window.self !== window.top || !isDragHit(e.target)) return;
-  windowCap().then((c) => c.beginMoveDrag()).catch(() => {});
-}, true);
-document.addEventListener("dblclick", (e) => {
-  if (e.button !== 0 || window.self !== window.top || !isDragHit(e.target)) return;
-  windowCap().then((c) => c.toggleMaximize()).catch(() => {});
-}, true);
+document.addEventListener(
+  "mousedown",
+  (e) => {
+    if (e.button !== 0 || window.self !== window.top || !isDragHit(e.target)) return;
+    windowCap()
+      .then((c) => c.beginMoveDrag())
+      .catch(() => {});
+  },
+  true,
+);
+document.addEventListener(
+  "dblclick",
+  (e) => {
+    if (e.button !== 0 || window.self !== window.top || !isDragHit(e.target)) return;
+    windowCap()
+      .then((c) => c.toggleMaximize())
+      .catch(() => {});
+  },
+  true,
+);
 
 import "../webview/native";

package/src/rpc/encrypt.ts

@@ -1,3 +1,4 @@
+import type { CloseInfo } from "./peer";
 import type { BytesPipe } from "./transport";
 
 const VERSION = 1;
@@ -11,7 +12,10 @@ function toBufferSource(view: Uint8Array): ArrayBuffer {
 }
 
 async function importAesGcmKey(rawKey: Uint8Array): Promise<CryptoKey> {
-  return crypto.subtle.importKey("raw", toBufferSource(rawKey), "AES-GCM", false, ["encrypt", "decrypt"]);
+  return crypto.subtle.importKey("raw", toBufferSource(rawKey), "AES-GCM", false, [
+    "encrypt",
+    "decrypt",
+  ]);
 }
 
 // WebCrypto AES-256-GCM (browser / preload). For Bun-side use `host/encryptedPipe.ts` (node:crypto).
@@ -21,7 +25,16 @@ export async function createEncryptedPipe(base: BytesPipe, rawKey: Uint8Array):
   let sendChain: Promise<void> = Promise.resolve();
   let recvChain: Promise<void> = Promise.resolve();
   let closed = false;
-  const closeOnce = () => { if (!closed) { closed = true; base.close(); } };
+  let onCloseHandler: ((info?: CloseInfo) => void) | undefined;
+  // Report close (so the Connection tears down) for both a base disconnect and a
+  // local crypto/frame failure, then close the base transport.
+  const closeOnce = (info?: CloseInfo) => {
+    if (closed) return;
+    closed = true;
+    onCloseHandler?.(info);
+    base.close();
+  };
+  base.onClose?.((info) => closeOnce(info));
 
   base.setReceive((frame) => {
     if (closed) return;
@@ -51,7 +64,11 @@ export async function createEncryptedPipe(base: BytesPipe, rawKey: Uint8Array):
         try {
           const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
           const ivBuf = toBufferSource(iv);
-          const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv: ivBuf }, key, payload);
+          const encrypted = await crypto.subtle.encrypt(
+            { name: "AES-GCM", iv: ivBuf },
+            key,
+            payload,
+          );
           const encArr = new Uint8Array(encrypted);
           const out = new Uint8Array(HEADER_LENGTH + encArr.byteLength);
           out[0] = VERSION;
@@ -66,9 +83,11 @@ export async function createEncryptedPipe(base: BytesPipe, rawKey: Uint8Array):
     setReceive(handler) {
       downstream = handler;
     },
+    onClose(h) {
+      onCloseHandler = h;
+    },
     close() {
       closeOnce();
     },
   };
 }
-

package/src/rpc/error.ts

@@ -22,14 +22,9 @@ export type ResourceExhaustedReason =
   | "stream_credit_window"
   | "rate_limited";
 
-export type UnavailableReason =
-  | "peer_closing"
-  | "goaway"
-  | "plugin_unloading";
+export type UnavailableReason = "peer_closing" | "goaway" | "plugin_unloading";
 
-export type AlreadyExistsReason =
-  | "name_collision"
-  | "reserved_namespace";
+export type AlreadyExistsReason = "name_collision" | "reserved_namespace";
 
 export type RetrySpec =
   | { kind: "never" }

package/src/rpc/framework.ts

@@ -1,5 +1,5 @@
-import { call, defineCap, stream, cap } from "./schema";
-import type { CapDef } from "./schema";
+import type { AnyCapDef } from "./schema";
+import { call, cap, defineCap, stream } from "./schema";
 
 /** Window state for custom-titlebar rendering (max/restore glyph + focus ring). */
 export interface WindowState {
@@ -10,7 +10,7 @@ export interface WindowState {
 
 export const BrowserWindowCap = defineCap("bunite.BrowserWindow", {
   focus: call<void, void>(),
-  close: call<void, void>(),  // vetoable — routes through close-requested
+  close: call<void, void>(), // vetoable — routes through close-requested
   setBounds: call<{ x: number; y: number; w: number; h: number }, void>(),
   setTitle: call<{ title: string }, void>(),
   id: call<void, number>({ idempotent: true }),
@@ -21,7 +21,7 @@ export const BrowserWindowCap = defineCap("bunite.BrowserWindow", {
   unmaximize: call<void, void>(),
   toggleMaximize: call<void, void>(),
   getState: call<void, WindowState>({ idempotent: true }),
-  stateWatch: stream<void, WindowState>(),  // emits current state on subscribe, then on change
+  stateWatch: stream<void, WindowState>(), // emits current state on subscribe, then on change
   // Start an OS window move (Tauri startDragging equiv) — call from a custom
   // titlebar mousedown. Preload auto-calls this for `app-region: drag`; manual
   // callers use it for custom hit-testing. Start-only; native follows the cursor.
@@ -30,8 +30,14 @@ export const BrowserWindowCap = defineCap("bunite.BrowserWindow", {
 
 export const WindowCap = defineCap("bunite.Window", {
   create: call<WindowCreateOpts, typeof BrowserWindowCap>({ returns: cap(BrowserWindowCap) }),
-  list: call<void, typeof BrowserWindowCap>({ returns: cap.array(BrowserWindowCap), idempotent: true }),
-  current: call<void, typeof BrowserWindowCap>({ returns: cap(BrowserWindowCap), idempotent: true }),
+  list: call<void, typeof BrowserWindowCap>({
+    returns: cap.array(BrowserWindowCap),
+    idempotent: true,
+  }),
+  current: call<void, typeof BrowserWindowCap>({
+    returns: cap(BrowserWindowCap),
+    idempotent: true,
+  }),
   focus: call<{ id?: number; label?: string }, void>(),
   close: call<{ id?: number; label?: string }, void>(),
 });
@@ -43,12 +49,16 @@ export interface WindowCreateOpts {
   label?: string;
 }
 
-export const FileRefCap = defineCap("bunite.FileRef", {
-  text: call<void, string>({ idempotent: true }),
-  bytes: call<void, Uint8Array>({ idempotent: true }),
-  path: call<void, string>({ idempotent: true }),
-  revoke: call<void, void>(),
-}, { disposal: { method: "revoke" } });
+export const FileRefCap = defineCap(
+  "bunite.FileRef",
+  {
+    text: call<void, string>({ idempotent: true }),
+    bytes: call<void, Uint8Array>({ idempotent: true }),
+    path: call<void, string>({ idempotent: true }),
+    revoke: call<void, void>(),
+  },
+  { disposal: { method: "revoke" } },
+);
 
 export const DialogsCap = defineCap("bunite.Dialogs", {
   openFile: call<DialogOpenFileOpts, typeof FileRefCap>({ returns: cap.array(FileRefCap) }),
@@ -184,7 +194,11 @@ export type BoundingRectResult =
   /** `visible` = rect has size AND intersects the frame's viewport. opacity /
    *  visibility:hidden / occlusion are NOT checked — agent must `evaluate` for those. */
   | { ok: true; rect: { x: number; y: number; width: number; height: number }; visible: boolean }
-  | { ok: false; code: "not_found" | "runtime_error" | "cross_origin" | "not_supported"; message: string };
+  | {
+      ok: false;
+      code: "not_found" | "runtime_error" | "cross_origin" | "not_supported";
+      message: string;
+    };
 
 export interface Frame {
   frameId: string;
@@ -201,14 +215,39 @@ export type ListFramesResult =
 export type DownloadPolicy = "auto" | "ask" | "block";
 
 export type DownloadEvent =
-  | { kind: "started"; id: string; url: string; suggestedFilename: string; mimeType?: string; sizeBytes?: number }
+  | {
+      kind: "started";
+      id: string;
+      url: string;
+      suggestedFilename: string;
+      mimeType?: string;
+      sizeBytes?: number;
+    }
   | { kind: "progress"; id: string; receivedBytes: number; totalBytes?: number }
   | { kind: "completed"; id: string; localPath: string }
   | { kind: "failed"; id: string; reason: string }
-  | { kind: "blocked"; id: string; url: string; reason: "host-policy" | "backend-block" | "mime-blocked" | "not_supported" | "ask-not-implemented" };
+  | {
+      kind: "blocked";
+      id: string;
+      url: string;
+      reason:
+        | "host-policy"
+        | "backend-block"
+        | "mime-blocked"
+        | "not_supported"
+        | "ask-not-implemented";
+    };
 
 export type WaitForDownloadResult =
-  | { ok: true; id: string; suggestedFilename: string; url: string; mimeType?: string; sizeBytes?: number; localPath: string }
+  | {
+      ok: true;
+      id: string;
+      suggestedFilename: string;
+      url: string;
+      mimeType?: string;
+      sizeBytes?: number;
+      localPath: string;
+    }
   | { ok: false; code: "timeout" | "blocked" | "failed" | "not_supported"; message: string };
 
 export interface SetDownloadPolicyArgs {
@@ -235,8 +274,12 @@ export interface ExtendPopupTimeoutArgs {
   gracePeriodMs: number;
 }
 export type ExtendPopupTimeoutResult =
-  | { ok: true; deadlineMs: number }   // epoch ms of the new deadline
-  | { ok: false; code: "not_found" | "already_adopted" | "already_dismissed" | "cap_exceeded"; message: string };
+  | { ok: true; deadlineMs: number } // epoch ms of the new deadline
+  | {
+      ok: false;
+      code: "not_found" | "already_adopted" | "already_dismissed" | "cap_exceeded";
+      message: string;
+    };
 
 /** Surface lifecycle event arm before the surface pipeline stamps `epoch`. */
 export type SurfaceEventBase =
@@ -268,7 +311,11 @@ export interface NavigationState {
 
 export type EvaluateResult =
   | { ok: true; value: unknown }
-  | { ok: false; code: "cross_origin" | "runtime_error" | "not_supported" | "timeout"; message: string };
+  | {
+      ok: false;
+      code: "cross_origin" | "runtime_error" | "not_supported" | "timeout";
+      message: string;
+    };
 
 /** Modifier bitmask for input dispatch. Backends translate to native form. */
 export type Modifier = "alt" | "ctrl" | "meta" | "shift";
@@ -281,7 +328,10 @@ export interface ClickArgs {
   clickCount?: number;
   modifiers?: Modifier[];
 }
-export interface TypeArgs { surfaceId: number; text: string }
+export interface TypeArgs {
+  surfaceId: number;
+  text: string;
+}
 export interface PressArgs {
   surfaceId: number;
   key: string;
@@ -390,7 +440,11 @@ export interface ScreenshotArgs {
 }
 export type ScreenshotResult =
   | { ok: true; data: Uint8Array; mime: string; format: "png" | "jpeg" }
-  | { ok: false; code: "not_supported" | "runtime_error" | "timeout" | "black_frame"; message: string };
+  | {
+      ok: false;
+      code: "not_supported" | "runtime_error" | "timeout" | "black_frame";
+      message: string;
+    };
 
 export interface ResolveAndClickArgs {
   surfaceId: number;
@@ -405,18 +459,29 @@ export interface ResolveAndClickArgs {
  *  CEF/WV2 CDP `Input.dispatchMouseEvent` produces trusted events; mac NSEvent
  *  direct dispatch is also trusted. All shipped backends report `true`. */
 export type ResolveAndClickResult =
-  | { ok: true; rect: { x: number; y: number; width: number; height: number }; isTrustedEvent: boolean }
-  | { ok: false; code: "not_found" | "not_visible" | "runtime_error" | "cross_origin" | "not_supported"; message: string };
+  | {
+      ok: true;
+      rect: { x: number; y: number; width: number; height: number };
+      isTrustedEvent: boolean;
+    }
+  | {
+      ok: false;
+      code: "not_found" | "not_visible" | "runtime_error" | "cross_origin" | "not_supported";
+      message: string;
+    };
 
 export const SurfaceCap = defineCap("bunite.Surface", {
-  init: call<{
-    src: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    hidden?: boolean;
-  }, { surfaceId: number }>(),
+  init: call<
+    {
+      src: string;
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+      hidden?: boolean;
+    },
+    { surfaceId: number }
+  >(),
   resize: call<{ surfaceId: number; x: number; y: number; w: number; h: number }, void>(),
   remove: call<{ surfaceId: number }, void>(),
   setHidden: call<{ surfaceId: number; hidden: boolean }, void>(),
@@ -438,7 +503,9 @@ export const SurfaceCap = defineCap("bunite.Surface", {
   waitForFunction: call<WaitForFunctionArgs, WaitResult>(),
   respondToDialog: call<RespondToDialogArgs, void>(),
   setDialogTimeout: call<SetDialogTimeoutArgs, void>(),
-  getConsoleBuffer: call<{ surfaceId: number; clear?: boolean }, ConsoleEntry[]>({ idempotent: true }),
+  getConsoleBuffer: call<{ surfaceId: number; clear?: boolean }, ConsoleEntry[]>({
+    idempotent: true,
+  }),
   surfaceEvents: stream<{ surfaceId: number }, SurfaceEvent>(),
   dialogs: stream<{ surfaceId: number }, DialogEvent>(),
   consoleEvents: stream<{ surfaceId: number }, ConsoleEntry>(),
@@ -475,7 +542,10 @@ export const RuntimeCap = defineCap("bunite.Runtime", {
   theme: call<void, "light" | "dark">({ idempotent: true }),
   themeWatch: stream<void, "light" | "dark">(),
   surface: call<void, typeof SurfaceCap>({ returns: cap(SurfaceCap), idempotent: true }),
-  reporting: call<void, typeof PageReportingCap>({ returns: cap(PageReportingCap), idempotent: true }),
+  reporting: call<void, typeof PageReportingCap>({
+    returns: cap(PageReportingCap),
+    idempotent: true,
+  }),
   popupMetrics: call<void, PopupMetrics>({ idempotent: true }),
 });
 
@@ -491,7 +561,7 @@ export const FRAMEWORK_TYPE_IDS = {
   PageReporting: 9,
 } as const;
 
-const FRAMEWORK_CAP_TYPE_IDS = new Map<CapDef<any, any>, number>([
+const FRAMEWORK_CAP_TYPE_IDS = new Map<AnyCapDef, number>([
   [RuntimeCap, FRAMEWORK_TYPE_IDS.Runtime],
   [WindowCap, FRAMEWORK_TYPE_IDS.Window],
   [DialogsCap, FRAMEWORK_TYPE_IDS.Dialogs],
@@ -503,6 +573,6 @@ const FRAMEWORK_CAP_TYPE_IDS = new Map<CapDef<any, any>, number>([
   [PageReportingCap, FRAMEWORK_TYPE_IDS.PageReporting],
 ]);
 
-export function frameworkTypeIdOf(cap: CapDef<any, any>): number | undefined {
+export function frameworkTypeIdOf(cap: AnyCapDef): number | undefined {
   return FRAMEWORK_CAP_TYPE_IDS.get(cap);
 }