bunite-core 0.12.1 → 0.16.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.12.1",
+  "version": "0.16.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.10",
-    "bunite-native-mac-arm64": "0.0.1",
-    "bunite-native-linux-x64": "0.0.1"
+    "bunite-native-win-x64": "0.0.14",
+    "bunite-native-mac-arm64": "0.0.4",
+    "bunite-native-linux-x64": "0.0.4"
   }
 }

package/src/host/core/App.ts

@@ -15,10 +15,10 @@ import {
 } from "../native";
 import { ensureRpcServer } from "./Socket";
 import { BrowserWindow } from "./BrowserWindow";
-import { createSurfaceCapImpl } from "./SurfaceManager";
+import { createSurfaceCapImpl, getPopupMetricsSnapshot } 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,23 @@ 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
+                );
+              }
+            });
+          },
+        }),
+      popupMetrics: () => getPopupMetricsSnapshot(),
     } satisfies ImplOf<typeof RuntimeCap>;
     return impl;
   }

package/src/host/core/BrowserView.ts

@@ -8,13 +8,21 @@ import {
   type Connection,
   type BytesPipe,
 } from "../../rpc/index";
-import type { EvaluateResult, SurfaceCapabilities } from "../../rpc/framework";
+import type {
+  EvaluateResult, SurfaceCapabilities, ScreenshotResult, Modifier,
+  AccessibilitySnapshotResult, AxNode, ListFramesResult,
+  ResolveAndClickArgs, ResolveAndClickResult,
+} 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,
+  setAccessibilityResultHandler, type NativeAccessibilityResult,
+  setListFramesResultHandler, type NativeListFramesResult,
+  setResolveAndClickResultHandler, type NativeResolveAndClickResult,
 } from "../native";
-import { getNativeEngineName } from "../native";
 import { attachBrowserViewRegistry, getRpcPort } from "./Socket";
 import { getAppRuntimeOrThrow } from "./App";
 import { randomBytes } from "node:crypto";
@@ -47,6 +55,236 @@ function rejectEvaluatesForView(viewId: number) {
   }
 }
 
+// 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" });
+    }
+  }
+}
+
+type AxPending = { viewId: number; resolve: (result: AccessibilitySnapshotResult) => void; interestingOnly: boolean };
+let nextAxRequestId = 1;
+const axResolvers = new Map<number, AxPending>();
+
+function registerAxRequest(viewId: number, resolve: (result: AccessibilitySnapshotResult) => void, interestingOnly: boolean): number {
+  const id = nextAxRequestId++;
+  axResolvers.set(id, { viewId, resolve, interestingOnly });
+  return id;
+}
+
+function rejectAxForView(viewId: number) {
+  for (const [reqId, entry] of axResolvers) {
+    if (entry.viewId === viewId) {
+      axResolvers.delete(reqId);
+      entry.resolve({ ok: false, code: "not_supported", message: "view destroyed" });
+    }
+  }
+}
+
+// CDP `Accessibility.getFullAXTree` returns `{nodes: [flat]}` with `childIds`
+// references — build a nested tree from the first node. When `interestingOnly`
+// is true, ignored nodes are dropped and their children reparent up.
+function convertAxTree(cdpResult: { nodes?: any[] } | undefined, interestingOnly: boolean): AxNode {
+  const flat = cdpResult?.nodes ?? [];
+  if (flat.length === 0) return { nodeId: "", role: "", name: "" };
+  const byId = new Map<string, any>();
+  for (const n of flat) if (n?.nodeId != null) byId.set(String(n.nodeId), n);
+  // Root = node without a parentId (rather than relying on flat[0] ordering).
+  const root = flat.find((n) => n?.parentId == null) ?? flat[0];
+  // Walk childIds skipping ignored nodes (when filtering) and produce a flat list
+  // of "interesting" descendants for the given node.
+  const seen = new Set<string>();
+  const interestingDescendants = (cdpNode: any): any[] => {
+    const out: any[] = [];
+    if (!Array.isArray(cdpNode?.childIds)) return out;
+    for (const cid of cdpNode.childIds) {
+      const child = byId.get(String(cid));
+      if (!child) continue;
+      if (interestingOnly && child.ignored === true) {
+        out.push(...interestingDescendants(child));
+      } else {
+        out.push(child);
+      }
+    }
+    return out;
+  };
+  const build = (n: any): AxNode => {
+    const id = String(n?.nodeId ?? "");
+    if (id && seen.has(id)) return { nodeId: id, role: "", name: "" };  // cycle guard
+    if (id) seen.add(id);
+    const props = new Map<string, unknown>();
+    if (Array.isArray(n?.properties)) {
+      for (const p of n.properties) {
+        if (p?.name && p.value && "value" in p.value) props.set(p.name, p.value.value);
+      }
+    }
+    const out: AxNode = {
+      nodeId: id,
+      role: String(n?.role?.value ?? ""),
+      name: String(n?.name?.value ?? ""),
+    };
+    if (n?.value?.value !== undefined) out.value = String(n.value.value);
+    if (n?.description?.value !== undefined) out.description = String(n.description.value);
+    const level = props.get("level"); if (typeof level === "number") out.level = level;
+    const checked = props.get("checked"); if (checked === true || checked === false || checked === "mixed") out.checked = checked;
+    const pressed = props.get("pressed"); if (pressed === true || pressed === false || pressed === "mixed") out.pressed = pressed;
+    const expanded = props.get("expanded"); if (typeof expanded === "boolean") out.expanded = expanded;
+    const disabled = props.get("disabled"); if (typeof disabled === "boolean") out.disabled = disabled;
+    const focused = props.get("focused"); if (typeof focused === "boolean") out.focused = focused;
+    const invalid = props.get("invalid"); if (typeof invalid === "boolean") out.invalid = invalid;
+    const required = props.get("required"); if (typeof required === "boolean") out.required = required;
+    const selected = props.get("selected"); if (typeof selected === "boolean") out.selected = selected;
+    const kids = interestingDescendants(n).map(build);
+    if (kids.length > 0) out.children = kids;
+    return out;
+  };
+  return build(root);
+}
+
+type FramesPending = { viewId: number; resolve: (result: ListFramesResult) => void };
+let nextFramesRequestId = 1;
+const framesResolvers = new Map<number, FramesPending>();
+function registerFramesRequest(viewId: number, resolve: (result: ListFramesResult) => void): number {
+  const id = nextFramesRequestId++;
+  framesResolvers.set(id, { viewId, resolve });
+  return id;
+}
+function rejectFramesForView(viewId: number) {
+  for (const [reqId, entry] of framesResolvers) {
+    if (entry.viewId === viewId) {
+      framesResolvers.delete(reqId);
+      entry.resolve({ ok: false, code: "runtime_error", message: "view destroyed" });
+    }
+  }
+}
+
+type ResolveAndClickPending = { viewId: number; resolve: (result: ResolveAndClickResult) => void };
+let nextResolveAndClickRequestId = 1;
+const resolveAndClickResolvers = new Map<number, ResolveAndClickPending>();
+function registerResolveAndClickRequest(viewId: number, resolve: (result: ResolveAndClickResult) => void): number {
+  const id = nextResolveAndClickRequestId++;
+  resolveAndClickResolvers.set(id, { viewId, resolve });
+  return id;
+}
+function rejectResolveAndClickForView(viewId: number) {
+  for (const [reqId, entry] of resolveAndClickResolvers) {
+    if (entry.viewId === viewId) {
+      resolveAndClickResolvers.delete(reqId);
+      entry.resolve({ ok: false, code: "runtime_error", message: "view destroyed" });
+    }
+  }
+}
+
+function flattenFrameTree(raw: any): { frameId: string; parentFrameId: string | null; origin: string; url: string; name?: string }[] {
+  const out: { frameId: string; parentFrameId: string | null; origin: string; url: string; name?: string }[] = [];
+  const walk = (node: any, parent: string | null) => {
+    const f = node?.frame;
+    if (!f) return;
+    const entry: { frameId: string; parentFrameId: string | null; origin: string; url: string; name?: string } = {
+      frameId: String(f.id ?? ""),
+      parentFrameId: parent,
+      origin: String(f.securityOrigin ?? ""),
+      url: String(f.url ?? ""),
+    };
+    if (typeof f.name === "string" && f.name.length > 0) entry.name = f.name;
+    out.push(entry);
+    if (Array.isArray(node.childFrames)) for (const c of node.childFrames) walk(c, entry.frameId);
+  };
+  const root = raw?.frameTree;
+  if (root) walk(root, null);
+  return out;
+}
+
+setListFramesResultHandler((viewId, raw: NativeListFramesResult) => {
+  const entry = framesResolvers.get(raw.requestId);
+  if (!entry || entry.viewId !== viewId) return;
+  framesResolvers.delete(raw.requestId);
+  if (raw.ok && raw.raw) {
+    try {
+      const frames = flattenFrameTree(raw.raw);
+      entry.resolve({ ok: true, frames });
+    } catch (e) {
+      entry.resolve({ ok: false, code: "runtime_error", message: `frame tree flatten failed: ${(e as Error).message}` });
+    }
+  } else {
+    entry.resolve({
+      ok: false,
+      code: (raw.code as "not_supported" | "runtime_error") ?? "runtime_error",
+      message: raw.message ?? "list frames failed",
+    });
+  }
+});
+
+setAccessibilityResultHandler((viewId, raw: NativeAccessibilityResult) => {
+  const entry = axResolvers.get(raw.requestId);
+  if (!entry || entry.viewId !== viewId) return;
+  axResolvers.delete(raw.requestId);
+  if (raw.ok && raw.tree) {
+    try { entry.resolve({ ok: true, tree: convertAxTree(raw.tree as any, entry.interestingOnly) }); }
+    catch (e) { entry.resolve({ ok: false, code: "runtime_error", message: `ax tree convert failed: ${(e as Error).message}` }); }
+  } else {
+    entry.resolve({
+      ok: false,
+      code: (raw.code as "not_supported" | "runtime_error" | "timeout") ?? "runtime_error",
+      message: raw.message ?? "accessibility snapshot failed",
+    });
+  }
+});
+
+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",
+    });
+  }
+});
+
+setResolveAndClickResultHandler((viewId, raw: NativeResolveAndClickResult) => {
+  const entry = resolveAndClickResolvers.get(raw.requestId);
+  if (!entry || entry.viewId !== viewId) return;
+  resolveAndClickResolvers.delete(raw.requestId);
+  if (raw.ok && raw.rect) {
+    entry.resolve({ ok: true, rect: raw.rect, isTrustedEvent: !!raw.isTrustedEvent });
+  } else {
+    type FailCode = "not_found" | "not_visible" | "runtime_error" | "cross_origin" | "not_supported";
+    const code = (raw.code as FailCode | undefined) ?? "runtime_error";
+    entry.resolve({ ok: false, code, message: raw.message ?? "resolveAndClick failed" });
+  }
+});
+
 setEvaluateResultHandler((viewId, raw: NativeEvaluateResult) => {
   const entry = evaluateResolvers.get(raw.requestId);
   if (!entry) return;
@@ -67,18 +305,52 @@ 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;
+const CAP_AX                   = 1 << 15;
+const CAP_BOUNDING_RECT        = 1 << 16;
+const CAP_FRAMES               = 1 << 17;
+const CAP_DOWNLOADS            = 1 << 18;
+const CAP_POPUPS               = 1 << 19;
+const CAP_RESOLVE_AND_CLICK    = 1 << 20;
+
+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),
+    accessibilitySnapshot: !!(bits & CAP_AX),
+    getBoundingRect: !!(bits & CAP_BOUNDING_RECT),
+    frames: !!(bits & CAP_FRAMES),
+    downloads: !!(bits & CAP_DOWNLOADS),
+    popups: !!(bits & CAP_POPUPS),
+    resolveAndClick: !!(bits & CAP_RESOLVE_AND_CLICK),
+    ...(formats.length > 0 ? { formats } : {}),
   };
 }
 
@@ -137,9 +409,36 @@ export class BrowserView {
   sandbox: boolean;
   secretKey: Uint8Array;
 
-  constructor(options: Partial<BrowserViewOptions>) {
+  /** Wrap a pre-existing native view (popup mint). Skips `bunite_view_create`;
+   *  the new view is then attached to the host window via `bunite_view_popup_accept`. */
+  static adopt(args: {
+    nativeViewId: number;
+    hostWindowId: number;
+    bounds: { x: number; y: number; width: number; height: number };
+    appresRoot: string | null;
+  }): BrowserView {
+    return new BrowserView({
+      adoptNativeViewId: args.nativeViewId,
+      windowId: args.hostWindowId,
+      frame: args.bounds,
+      appresRoot: args.appresRoot,
+      autoResize: false,
+    } as Partial<BrowserViewOptions> & { adoptNativeViewId: number });
+  }
+
+  static dismissPopupById(newSurfaceId: number) {
+    getNativeLibrary()?.symbols.bunite_view_popup_dismiss(newSurfaceId);
+  }
+
+  constructor(options: Partial<BrowserViewOptions> & { adoptNativeViewId?: number }) {
     ensureNativeRuntime();
 
+    const adopting = options.adoptNativeViewId != null;
+    if (adopting) {
+      this.id = options.adoptNativeViewId!;
+      // Adopted IDs live in the upper u32 half (popup namespace). Keep TS's
+      // sequential allocator untouched so normal creates stay below 0x80000000.
+    }
     this.windowId = options.windowId ?? defaultOptions.windowId;
     this.url = options.url ?? defaultOptions.url;
     this.html = options.html ?? defaultOptions.html;
@@ -171,23 +470,33 @@ export class BrowserView {
 
     BrowserViewMap[this.id] = this;
     this._readyPromise = waitForViewReady(this.id);
-    this.nativeAttached =
-      getNativeLibrary()?.symbols.bunite_view_create(
-        this.id,
-        this.windowId,
-        toCString(this.url ?? ""),
-        toCString(this.html ?? ""),
-        toCString(preloadScript),
-        toCString(this.appresRoot ?? ""),
-        toCString(this.navigationRules ? JSON.stringify(this.navigationRules) : ""),
-        this.frame.x,
-        this.frame.y,
-        this.frame.width,
-        this.frame.height,
-        this.autoResize,
-        this.sandbox,
-        toCString(this.preloadOrigins ? JSON.stringify(this.preloadOrigins) : "")
-      ) ?? false;
+    if (adopting) {
+      // Native popup mint already created the view; bind to host window + bounds.
+      const lib = getNativeLibrary();
+      lib?.symbols.bunite_view_popup_accept(
+        this.id, this.windowId,
+        this.frame.x, this.frame.y, this.frame.width, this.frame.height,
+      );
+      this.nativeAttached = true;
+    } else {
+      this.nativeAttached =
+        getNativeLibrary()?.symbols.bunite_view_create(
+          this.id,
+          this.windowId,
+          toCString(this.url ?? ""),
+          toCString(this.html ?? ""),
+          toCString(preloadScript),
+          toCString(this.appresRoot ?? ""),
+          toCString(this.navigationRules ? JSON.stringify(this.navigationRules) : ""),
+          this.frame.x,
+          this.frame.y,
+          this.frame.width,
+          this.frame.height,
+          this.autoResize,
+          this.sandbox,
+          toCString(this.preloadOrigins ? JSON.stringify(this.preloadOrigins) : "")
+        ) ?? false;
+    }
 
     if (this.nativeAttached) {
       this.on("did-navigate", (event: any) => {
@@ -271,18 +580,181 @@ export class BrowserView {
     }
   }
 
-  evaluate(script: string): Promise<EvaluateResult> {
+  evaluate(script: string, frameId?: string): Promise<EvaluateResult> {
     if (!this.nativeAttached) {
       return Promise.resolve({ ok: false, code: "not_supported", message: "native runtime unavailable" });
     }
     return new Promise<EvaluateResult>((resolve) => {
-      const requestId = registerEvaluateRequest(this.id, resolve);
-      getNativeLibrary()?.symbols.bunite_view_evaluate(this.id, requestId, toCString(script));
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      const wrappedResolve = (r: EvaluateResult) => { if (timer) clearTimeout(timer); resolve(r); };
+      const requestId = registerEvaluateRequest(this.id, wrappedResolve);
+      // 30s timeout — two-hop CDP path (createIsolatedWorld → Runtime.evaluate)
+      // can silently hang if the frame is destroyed mid-flight.
+      timer = setTimeout(() => {
+        if (evaluateResolvers.delete(requestId)) {
+          resolve({ ok: false, code: "timeout", message: "evaluate timed out after 30s" });
+        }
+      }, 30_000);
+      const lib = getNativeLibrary();
+      if (frameId) {
+        lib?.symbols.bunite_view_evaluate_in_frame(this.id, requestId, toCString(script), toCString(frameId));
+      } else {
+        lib?.symbols.bunite_view_evaluate(this.id, requestId, toCString(script));
+      }
+    });
+  }
+
+  setDownloadPolicy(policy: "auto" | "ask" | "block", downloadDir?: string) {
+    if (!this.nativeAttached) return;
+    const policyCode = policy === "auto" ? 0 : policy === "ask" ? 1 : 2;
+    getNativeLibrary()?.symbols.bunite_view_set_download_policy(
+      this.id, policyCode, toCString(downloadDir ?? "")
+    );
+  }
+
+  listFrames(): Promise<ListFramesResult> {
+    if (!this.nativeAttached) {
+      return Promise.resolve({ ok: false, code: "not_supported", message: "native runtime unavailable" });
+    }
+    return new Promise<ListFramesResult>((resolve) => {
+      const requestId = registerFramesRequest(this.id, resolve);
+      const timer = setTimeout(() => {
+        if (framesResolvers.delete(requestId)) {
+          resolve({ ok: false, code: "runtime_error", message: "list frames timed out after 10s" });
+        }
+      }, 10_000);
+      const wrappedResolve = (r: ListFramesResult) => { clearTimeout(timer); resolve(r); };
+      framesResolvers.set(requestId, { viewId: this.id, resolve: wrappedResolve });
+      getNativeLibrary()?.symbols.bunite_view_list_frames(this.id, requestId);
+    });
+  }
+
+  resolveAndClick(args: ResolveAndClickArgs): Promise<ResolveAndClickResult> {
+    if (!this.nativeAttached) {
+      return Promise.resolve({ ok: false, code: "not_supported", message: "native runtime unavailable" });
+    }
+    return new Promise<ResolveAndClickResult>((resolve) => {
+      const requestId = registerResolveAndClickRequest(this.id, resolve);
+      const timer = setTimeout(() => {
+        if (resolveAndClickResolvers.delete(requestId)) {
+          resolve({ ok: false, code: "runtime_error", message: "resolveAndClick timed out after 5s" });
+        }
+      }, 5_000);
+      const wrappedResolve = (r: ResolveAndClickResult) => { clearTimeout(timer); resolve(r); };
+      resolveAndClickResolvers.set(requestId, { viewId: this.id, resolve: wrappedResolve });
+      const button = args.button === "right" ? 2 : args.button === "middle" ? 1 : 0;
+      getNativeLibrary()?.symbols.bunite_view_resolve_and_click(
+        this.id, requestId,
+        toCString(args.selector), toCString(args.frameId ?? ""),
+        button, args.clickCount ?? 1, encodeModifiers(args.modifiers),
+      );
     });
   }
 
   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);
+    });
+  }
+
+  accessibilitySnapshot(interestingOnly: boolean): Promise<AccessibilitySnapshotResult> {
+    if (!this.nativeAttached) {
+      return Promise.resolve({ ok: false, code: "not_supported", message: "native runtime unavailable" });
+    }
+    return new Promise<AccessibilitySnapshotResult>((resolve) => {
+      const requestId = registerAxRequest(this.id, resolve, interestingOnly);
+      const timer = setTimeout(() => {
+        if (axResolvers.delete(requestId)) {
+          resolve({ ok: false, code: "timeout", message: "accessibility snapshot timed out after 30s" });
+        }
+      }, 30_000);
+      const wrappedResolve = (r: AccessibilitySnapshotResult) => { clearTimeout(timer); resolve(r); };
+      axResolvers.set(requestId, { viewId: this.id, resolve: wrappedResolve, interestingOnly });
+      // Native flag is currently unused (filter is TS-side); kept for ABI shape stability.
+      getNativeLibrary()?.symbols.bunite_view_accessibility_snapshot(this.id, requestId, interestingOnly ? 1 : 0);
+    });
   }
 
   goBack() {
@@ -390,9 +862,14 @@ export class BrowserView {
     removeSurfacesForHostView(this.id);
     cancelWaitForViewReady(this.id);
     rejectEvaluatesForView(this.id);
+    rejectScreenshotsForView(this.id);
+    rejectAxForView(this.id);
+    rejectFramesForView(this.id);
+    rejectResolveAndClickForView(this.id);
     this.nativeAttached = false;
     for (const eventName of [
-      "will-navigate", "did-navigate", "dom-ready", "new-window-open", "permission-requested", "title-changed"
+      "will-navigate", "did-navigate", "dom-ready", "new-window-open", "permission-requested", "title-changed",
+      "load-start", "load-finish", "load-fail", "dialog", "console-message", "download-event", "popup-requested",
     ]) {
       buniteEventEmitter.removeAllListeners(`${eventName}-${this.id}`);
     }
@@ -400,7 +877,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" | "download-event" | "popup-requested",
     handler: (event: unknown) => void
   ) {
     const specificName = `${name}-${this.id}`;