bunite-core 0.12.0 → 0.14.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "type": "module",
   "scripts": {
     "setup:cef": "bun ../tools/bunite-dev/scripts/setup-cef.ts",
@@ -24,8 +24,8 @@
     "msgpackr": "^1.11.9"
   },
   "optionalDependencies": {
-    "bunite-native-win-x64": "0.0.9",
-    "bunite-native-mac-arm64": "0.0.1",
-    "bunite-native-linux-x64": "0.0.1"
+    "bunite-native-win-x64": "0.0.12",
+    "bunite-native-mac-arm64": "0.0.3",
+    "bunite-native-linux-x64": "0.0.3"
   }
 }

package/src/host/core/App.ts

@@ -18,7 +18,7 @@ import { BrowserWindow } from "./BrowserWindow";
 import { createSurfaceCapImpl } from "./SurfaceManager";
 import "./SurfaceBrowserIPC";
 import { log, logLevelToInt } from "../log";
-import { RuntimeCap, SurfaceCap, IpcError, type ImplOf } from "../../rpc/index";
+import { RuntimeCap, SurfaceCap, PageReportingCap, IpcError, type ImplOf } from "../../rpc/index";
 
 import type { LogLevel } from "../log";
 
@@ -189,6 +189,22 @@ export class AppRuntime {
       themeWatch: () => notImpl("themeWatch"),
       surface: (_: void, ctx: Parameters<ImplOf<typeof RuntimeCap>["surface"]>[1]) =>
         ctx.exportCap(SurfaceCap, createSurfaceCapImpl(viewId)),
+      reporting: (_: void, ctx: Parameters<ImplOf<typeof RuntimeCap>["reporting"]>[1]) =>
+        ctx.exportCap(PageReportingCap, {
+          reportConsoleBatch: ({ entries }) => {
+            // One queueMicrotask per batch (not per entry) — a 1000-log
+            // spam still translates to 1 microtask + N synchronous emits,
+            // not N microtasks competing for the queue.
+            queueMicrotask(() => {
+              for (const entry of entries) {
+                buniteEventEmitter.emitEvent(
+                  buniteEventEmitter.events.webview.consoleMessage(entry),
+                  viewId
+                );
+              }
+            });
+          },
+        }),
     } satisfies ImplOf<typeof RuntimeCap>;
     return impl;
   }

package/src/host/core/BrowserView.ts

@@ -8,13 +8,14 @@ import {
   type Connection,
   type BytesPipe,
 } from "../../rpc/index";
-import type { EvaluateResult, SurfaceCapabilities } from "../../rpc/framework";
+import type { EvaluateResult, SurfaceCapabilities, ScreenshotResult, Modifier } from "../../rpc/framework";
+import { encodeModifiers, resolveKey } from "./inputDispatch";
 import { createEncryptedPipe } from "../encryptedPipe";
 import {
   ensureNativeRuntime, getNativeLibrary, toCString, waitForViewReady, cancelWaitForViewReady,
-  setEvaluateResultHandler, type NativeEvaluateResult
+  setEvaluateResultHandler, type NativeEvaluateResult,
+  setScreenshotResultHandler, type NativeScreenshotResult,
 } from "../native";
-import { getNativeEngineName } from "../native";
 import { attachBrowserViewRegistry, getRpcPort } from "./Socket";
 import { getAppRuntimeOrThrow } from "./App";
 import { randomBytes } from "node:crypto";
@@ -25,29 +26,89 @@ const BrowserViewMap: Record<number, BrowserView> = {};
 let nextWebviewId = 1;
 
 // Evaluate request plumbing — native fires `evaluate-result` events keyed by
-// requestId. Resolvers are sliced by viewId on dispatch (set once at module
-// load).
+// requestId. Each pending entry records its viewId so detachFromNative can
+// reject any in-flight Promises for that view (otherwise the resolver leaks
+// when the view is destroyed mid-evaluate).
+type EvaluatePending = { viewId: number; resolve: (result: EvaluateResult) => void };
 let nextEvaluateRequestId = 1;
-const evaluateResolvers = new Map<number, (result: EvaluateResult) => void>();
+const evaluateResolvers = new Map<number, EvaluatePending>();
 
-function registerEvaluateRequest(resolve: (result: EvaluateResult) => void): number {
+function registerEvaluateRequest(viewId: number, resolve: (result: EvaluateResult) => void): number {
   const id = nextEvaluateRequestId++;
-  evaluateResolvers.set(id, resolve);
+  evaluateResolvers.set(id, { viewId, resolve });
   return id;
 }
 
-setEvaluateResultHandler((_viewId, raw: NativeEvaluateResult) => {
-  const resolve = evaluateResolvers.get(raw.requestId);
-  if (!resolve) return;
+function rejectEvaluatesForView(viewId: number) {
+  for (const [reqId, entry] of evaluateResolvers) {
+    if (entry.viewId === viewId) {
+      evaluateResolvers.delete(reqId);
+      entry.resolve({ ok: false, code: "not_supported", message: "view destroyed" });
+    }
+  }
+}
+
+// Screenshot resolvers — parallel to evaluate. Native fires `screenshot-result`
+// keyed by requestId; payload carries base64 data which TS decodes to Uint8Array.
+type ScreenshotPending = { viewId: number; resolve: (result: ScreenshotResult) => void };
+let nextScreenshotRequestId = 1;
+const screenshotResolvers = new Map<number, ScreenshotPending>();
+
+function registerScreenshotRequest(viewId: number, resolve: (result: ScreenshotResult) => void): number {
+  const id = nextScreenshotRequestId++;
+  screenshotResolvers.set(id, { viewId, resolve });
+  return id;
+}
+
+function rejectScreenshotsForView(viewId: number) {
+  for (const [reqId, entry] of screenshotResolvers) {
+    if (entry.viewId === viewId) {
+      screenshotResolvers.delete(reqId);
+      entry.resolve({ ok: false, code: "not_supported", message: "view destroyed" });
+    }
+  }
+}
+
+function decodeBase64(b64: string): Uint8Array {
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+setScreenshotResultHandler((viewId, raw: NativeScreenshotResult) => {
+  const entry = screenshotResolvers.get(raw.requestId);
+  if (!entry) return;
+  if (entry.viewId !== viewId) return;
+  screenshotResolvers.delete(raw.requestId);
+  if (raw.ok && raw.dataBase64 && raw.format && raw.mime) {
+    try {
+      entry.resolve({ ok: true, data: decodeBase64(raw.dataBase64), mime: raw.mime, format: raw.format });
+    } catch (e) {
+      entry.resolve({ ok: false, code: "runtime_error", message: `base64 decode failed: ${(e as Error).message}` });
+    }
+  } else {
+    entry.resolve({
+      ok: false,
+      code: (raw.code as "not_supported" | "runtime_error" | "timeout") ?? "runtime_error",
+      message: raw.message ?? "screenshot failed",
+    });
+  }
+});
+
+setEvaluateResultHandler((viewId, raw: NativeEvaluateResult) => {
+  const entry = evaluateResolvers.get(raw.requestId);
+  if (!entry) return;
+  if (entry.viewId !== viewId) return;  // foreign event — ignore
   evaluateResolvers.delete(raw.requestId);
   if (raw.ok && raw.value !== undefined) {
     try {
-      resolve({ ok: true, value: JSON.parse(raw.value) });
+      entry.resolve({ ok: true, value: JSON.parse(raw.value) });
     } catch (e) {
-      resolve({ ok: false, code: "runtime_error", message: `result JSON parse failed: ${(e as Error).message}` });
+      entry.resolve({ ok: false, code: "runtime_error", message: `result JSON parse failed: ${(e as Error).message}` });
     }
   } else {
-    resolve({
+    entry.resolve({
       ok: false,
       code: (raw.code as EvaluateResult extends { code: infer C } ? C : never) ?? "runtime_error",
       message: raw.message ?? "evaluate failed",
@@ -55,18 +116,40 @@ setEvaluateResultHandler((_viewId, raw: NativeEvaluateResult) => {
   }
 });
 
-function computeCapabilities(engine: string | null): SurfaceCapabilities {
-  const supports = engine === "webview2" || engine === "cef";
+// Bit positions match the native enum in `ffi_exports.h` (BuniteCapBit).
+const CAP_EVALUATE             = 1 << 0;
+const CAP_CROSS_ORIGIN_EVAL    = 1 << 1;
+const CAP_SURFACE_EVENTS       = 1 << 2;
+const CAP_NATIVE_INPUT_TRUSTED = 1 << 3;
+const CAP_CLICK                = 1 << 4;
+const CAP_TYPE                 = 1 << 5;
+const CAP_PRESS                = 1 << 6;
+const CAP_SCROLL               = 1 << 7;
+const CAP_SCREENSHOT           = 1 << 8;
+const CAP_FORMAT_PNG           = 1 << 9;
+const CAP_FORMAT_JPEG          = 1 << 10;
+const CAP_MOUSE                = 1 << 11;
+const CAP_DIALOGS              = 1 << 12;
+const CAP_CONSOLE              = 1 << 13;
+
+function decodeCapabilityBits(bits: number): SurfaceCapabilities {
+  const formats: ("png" | "jpeg")[] = [];
+  if (bits & CAP_FORMAT_PNG) formats.push("png");
+  if (bits & CAP_FORMAT_JPEG) formats.push("jpeg");
   return {
-    evaluate: supports,
-    crossOriginEval: false,
-    titleChanged: supports,
-    nativeInputTrusted: false,
-    click: false,
-    type: false,
-    press: false,
-    scroll: false,
-    screenshot: false,
+    evaluate: !!(bits & CAP_EVALUATE),
+    crossOriginEval: !!(bits & CAP_CROSS_ORIGIN_EVAL),
+    surfaceEvents: !!(bits & CAP_SURFACE_EVENTS),
+    nativeInputTrusted: !!(bits & CAP_NATIVE_INPUT_TRUSTED),
+    click: !!(bits & CAP_CLICK),
+    type: !!(bits & CAP_TYPE),
+    press: !!(bits & CAP_PRESS),
+    scroll: !!(bits & CAP_SCROLL),
+    mouse: !!(bits & CAP_MOUSE),
+    dialogs: !!(bits & CAP_DIALOGS),
+    console: !!(bits & CAP_CONSOLE),
+    screenshot: !!(bits & CAP_SCREENSHOT),
+    ...(formats.length > 0 ? { formats } : {}),
   };
 }
 
@@ -264,13 +347,97 @@ export class BrowserView {
       return Promise.resolve({ ok: false, code: "not_supported", message: "native runtime unavailable" });
     }
     return new Promise<EvaluateResult>((resolve) => {
-      const requestId = registerEvaluateRequest(resolve);
+      const requestId = registerEvaluateRequest(this.id, resolve);
       getNativeLibrary()?.symbols.bunite_view_evaluate(this.id, requestId, toCString(script));
     });
   }
 
   capabilities(): SurfaceCapabilities {
-    return computeCapabilities(getNativeEngineName());
+    if (!this.nativeAttached) return decodeCapabilityBits(0);
+    const bits = getNativeLibrary()?.symbols.bunite_view_capabilities(this.id) ?? 0;
+    return decodeCapabilityBits(bits);
+  }
+
+  // High-level automation API — same shape as `SurfaceCap` RPC + element
+  // `send*` methods. Modifier translation + key resolution happen inside;
+  // callers never touch the FFI int contract.
+  click(args: {
+    x: number; y: number;
+    button?: "left" | "middle" | "right";
+    clickCount?: number;
+    modifiers?: Modifier[];
+  }) {
+    if (!this.nativeAttached) return;
+    const button = args.button === "right" ? 2 : args.button === "middle" ? 1 : 0;
+    getNativeLibrary()?.symbols.bunite_view_click(
+      this.id, args.x, args.y, button, args.clickCount ?? 1, encodeModifiers(args.modifiers)
+    );
+  }
+
+  type(text: string) {
+    if (!this.nativeAttached) return;
+    getNativeLibrary()?.symbols.bunite_view_type(this.id, toCString(text));
+  }
+
+  press(key: string, modifiers?: Modifier[], action?: "down" | "up" | "both") {
+    if (!this.nativeAttached) return;
+    const r = resolveKey(key);
+    const a = action === "down" ? 0 : action === "up" ? 1 : 2;
+    getNativeLibrary()?.symbols.bunite_view_press(
+      this.id, r.windowsVkCode, r.macKeyCode,
+      toCString(r.key), toCString(r.code), toCString(r.character),
+      encodeModifiers(modifiers), a, r.extended, r.location
+    );
+  }
+
+  scroll(args: {
+    dx: number; dy: number; x?: number; y?: number;
+    modifiers?: Modifier[];
+  }) {
+    if (!this.nativeAttached) return;
+    getNativeLibrary()?.symbols.bunite_view_scroll(
+      this.id, args.dx, args.dy, args.x ?? 0, args.y ?? 0, encodeModifiers(args.modifiers)
+    );
+  }
+
+  mouse(args: {
+    action: "move" | "down" | "up";
+    x: number; y: number;
+    button?: "left" | "middle" | "right";
+    modifiers?: Modifier[];
+  }) {
+    if (!this.nativeAttached) return;
+    const action = args.action === "move" ? 0 : args.action === "down" ? 1 : 2;
+    const button = args.button === "right" ? 2 : args.button === "middle" ? 1 : 0;
+    getNativeLibrary()?.symbols.bunite_view_mouse(
+      this.id, action, args.x, args.y, button, encodeModifiers(args.modifiers)
+    );
+  }
+
+  respondToDialog(requestId: number, accept: boolean, text?: string) {
+    if (!this.nativeAttached) return;
+    getNativeLibrary()?.symbols.bunite_view_respond_dialog(
+      this.id, requestId, accept, toCString(text ?? "")
+    );
+  }
+
+  screenshot(format: "png" | "jpeg", quality: number): Promise<ScreenshotResult> {
+    if (!this.nativeAttached) {
+      return Promise.resolve({ ok: false, code: "not_supported", message: "native runtime unavailable" });
+    }
+    return new Promise<ScreenshotResult>((resolve) => {
+      const requestId = registerScreenshotRequest(this.id, resolve);
+      // Timeout — guards against silent hangs (e.g. CEF compositor never delivers).
+      const timer = setTimeout(() => {
+        if (screenshotResolvers.delete(requestId)) {
+          resolve({ ok: false, code: "timeout", message: "screenshot timed out after 30s" });
+        }
+      }, 30_000);
+      const wrappedResolve = (r: ScreenshotResult) => { clearTimeout(timer); resolve(r); };
+      // Replace the registered resolver so the timeout-clearing wrapper runs on success.
+      screenshotResolvers.set(requestId, { viewId: this.id, resolve: wrappedResolve });
+      getNativeLibrary()?.symbols.bunite_view_screenshot(this.id, requestId, toCString(format), quality);
+    });
   }
 
   goBack() {
@@ -377,6 +544,8 @@ export class BrowserView {
   detachFromNative() {
     removeSurfacesForHostView(this.id);
     cancelWaitForViewReady(this.id);
+    rejectEvaluatesForView(this.id);
+    rejectScreenshotsForView(this.id);
     this.nativeAttached = false;
     for (const eventName of [
       "will-navigate", "did-navigate", "dom-ready", "new-window-open", "permission-requested", "title-changed"
@@ -387,7 +556,7 @@ export class BrowserView {
   }
 
   on(
-    name: "will-navigate" | "did-navigate" | "dom-ready" | "new-window-open" | "permission-requested" | "title-changed",
+    name: "will-navigate" | "did-navigate" | "dom-ready" | "new-window-open" | "permission-requested" | "title-changed" | "load-start" | "load-finish" | "load-fail" | "dialog" | "console-message",
     handler: (event: unknown) => void
   ) {
     const specificName = `${name}-${this.id}`;

package/src/host/core/SurfaceBrowserIPC.ts

@@ -1,10 +1,51 @@
-import { onSurfaceInit, emitDidNavigate, emitTitleChanged } from "./SurfaceManager";
+import {
+  onSurfaceInit, emitSurfaceEvent, emitConsole,
+  registerDialogRequest, disposeSurfaceState, clearConsoleBuffer,
+} from "./SurfaceManager";
 
 onSurfaceInit((surfaceId, hostViewId, view) => {
   view.on("did-navigate", (event: any) => {
-    emitDidNavigate(hostViewId, surfaceId, event.data.detail);
+    emitSurfaceEvent(hostViewId, surfaceId, { type: "navigate", url: event.data.detail });
   });
   view.on("title-changed", (event: any) => {
-    emitTitleChanged(hostViewId, surfaceId, event.data.detail);
+    emitSurfaceEvent(hostViewId, surfaceId, { type: "title-change", title: event.data.detail });
+  });
+  view.on("load-start", (event: any) => {
+    // Reload / fresh nav — clear retained host buffer so consumers don't see
+    // stale entries from the prior document.
+    clearConsoleBuffer(surfaceId);
+    emitSurfaceEvent(hostViewId, surfaceId, { type: "load-start", url: event.data.detail });
+  });
+  view.on("load-finish", (event: any) => {
+    emitSurfaceEvent(hostViewId, surfaceId, { type: "load-finish", url: event.data.detail });
+  });
+  view.on("load-fail", (event: any) => {
+    const d = event.data;
+    emitSurfaceEvent(hostViewId, surfaceId, {
+      type: "load-fail", url: d.url ?? "", reason: d.reason,
+    });
+  });
+  view.on("dialog", (event: any) => {
+    const d = event.data as {
+      requestId: number;
+      kind: "alert" | "confirm" | "prompt" | "beforeunload";
+      message: string;
+      defaultPrompt?: string;
+    };
+    registerDialogRequest(hostViewId, surfaceId, d);
+  });
+  view.on("console-message", (event: any) => {
+    // PageReportingCap impl already wraps the whole batch in a single
+    // microtask — no extra deferral needed at the listener level.
+    emitConsole(hostViewId, surfaceId, event.data);
   });
 });
+
+// Surface registry's untrackSurface doesn't fire a teardown event — wire it
+// at the call site if needed. For now state TTL aligns with the view lifetime
+// since surfaceId is reused only after view destruction; the buffer is GC'd
+// once the surface is removed via `remove()` which eventually triggers
+// `disposeSurfaceState` here.
+export function disposeSurface(surfaceId: number) {
+  disposeSurfaceState(surfaceId);
+}