bunite-core 0.14.0 → 0.17.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.14.0",
+  "version": "0.17.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.12",
-    "bunite-native-mac-arm64": "0.0.3",
-    "bunite-native-linux-x64": "0.0.3"
+    "bunite-native-win-x64": "0.0.15",
+    "bunite-native-mac-arm64": "0.0.5",
+    "bunite-native-linux-x64": "0.0.5"
   }
 }

package/src/host/core/App.ts

@@ -15,10 +15,11 @@ import {
 } from "../native";
 import { ensureRpcServer } from "./Socket";
 import { BrowserWindow } from "./BrowserWindow";
-import { createSurfaceCapImpl } from "./SurfaceManager";
+import { createSurfaceCapImpl, getPopupMetricsSnapshot } from "./SurfaceManager";
+import { createWindowCapImpl } from "./windowCap";
 import "./SurfaceBrowserIPC";
 import { log, logLevelToInt } from "../log";
-import { RuntimeCap, SurfaceCap, PageReportingCap, IpcError, type ImplOf } from "../../rpc/index";
+import { RuntimeCap, WindowCap, SurfaceCap, PageReportingCap, IpcError, type ImplOf } from "../../rpc/index";
 
 import type { LogLevel } from "../log";
 
@@ -179,7 +180,8 @@ export class AppRuntime {
       throw new IpcError({ code: "not_found", message: `Runtime.${name}` });
     };
     const impl = {
-      window: () => notImpl("window"),
+      window: (_: void, ctx: Parameters<ImplOf<typeof RuntimeCap>["window"]>[1]) =>
+        ctx.exportCap(WindowCap, createWindowCapImpl(viewId)),
       dialogs: () => notImpl("dialogs"),
       clipboard: () => notImpl("clipboard"),
       shell: () => notImpl("shell"),
@@ -205,6 +207,7 @@ export class AppRuntime {
             });
           },
         }),
+      popupMetrics: () => getPopupMetricsSnapshot(),
     } satisfies ImplOf<typeof RuntimeCap>;
     return impl;
   }

package/src/host/core/BrowserView.ts

@@ -8,13 +8,20 @@ import {
   type Connection,
   type BytesPipe,
 } from "../../rpc/index";
-import type { EvaluateResult, SurfaceCapabilities, ScreenshotResult, Modifier } 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,
   setScreenshotResultHandler, type NativeScreenshotResult,
+  setAccessibilityResultHandler, type NativeAccessibilityResult,
+  setListFramesResultHandler, type NativeListFramesResult,
+  setResolveAndClickResultHandler, type NativeResolveAndClickResult,
 } from "../native";
 import { attachBrowserViewRegistry, getRpcPort } from "./Socket";
 import { getAppRuntimeOrThrow } from "./App";
@@ -69,6 +76,175 @@ function rejectScreenshotsForView(viewId: number) {
   }
 }
 
+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);
@@ -96,6 +272,19 @@ setScreenshotResultHandler((viewId, raw: NativeScreenshotResult) => {
   }
 });
 
+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;
@@ -131,6 +320,12 @@ 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")[] = [];
@@ -149,6 +344,12 @@ function decodeCapabilityBits(bits: number): SurfaceCapabilities {
     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 } : {}),
   };
 }
@@ -208,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;
@@ -242,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) => {
@@ -342,13 +580,74 @@ 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),
+      );
     });
   }
 
@@ -440,6 +739,24 @@ export class BrowserView {
     });
   }
 
+  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() {
     if (this.nativeAttached) {
       getNativeLibrary()?.symbols.bunite_view_go_back(this.id);
@@ -546,9 +863,13 @@ export class BrowserView {
     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}`);
     }
@@ -556,7 +877,7 @@ export class BrowserView {
   }
 
   on(
-    name: "will-navigate" | "did-navigate" | "dom-ready" | "new-window-open" | "permission-requested" | "title-changed" | "load-start" | "load-finish" | "load-fail" | "dialog" | "console-message",
+    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}`;

package/src/host/core/BrowserWindow.ts

@@ -22,6 +22,7 @@ export type WindowOptionsType = {
   preload: string | null;
   appresRoot: string | null;
   preloadOrigins?: string[];
+  label?: string;
   /** Setup callback fired when the window's renderer connection attaches. */
   serve?: (conn: Connection) => void;
   titleBarStyle: "hidden" | "hiddenInset" | "default";
@@ -63,6 +64,7 @@ export class BrowserWindow {
   id = getNextWindowId();
   private nativeAttached = false;
   title: string;
+  label = "";
   frame: WindowOptionsType["frame"];
   url: string | null;
   html: string | null;
@@ -77,6 +79,9 @@ export class BrowserWindow {
   webviewId: number;
   private closed = false;
   private restoreMaximizedAfterMinimize = false;
+  private _focused = false;
+  private readonly handleNativeFocus = () => { lastFocusedWindowId = this.id; this._focused = true; };
+  private readonly handleNativeBlur = () => { this._focused = false; };
   private readonly handleNativeMove = (event: unknown) => {
     const data = (event as {
       data?: { x?: number; y?: number; maximized?: boolean; minimized?: boolean };
@@ -122,6 +127,8 @@ export class BrowserWindow {
     }
     BrowserView.getById(this.webviewId)?.detachFromNative();
     delete BrowserWindowMap[this.id];
+    buniteEventEmitter.off(`focus-${this.id}`, this.handleNativeFocus);
+    buniteEventEmitter.off(`blur-${this.id}`, this.handleNativeBlur);
     buniteEventEmitter.off(`move-${this.id}`, this.handleNativeMove);
     buniteEventEmitter.off(`resize-${this.id}`, this.handleNativeResize);
     buniteEventEmitter.off(`close-${this.id}`, this.handleNativeClose);
@@ -132,6 +139,7 @@ export class BrowserWindow {
     ensureNativeRuntime();
 
     this.title = options.title ?? defaultOptions.title;
+    this.label = options.label ?? "";
     this.frame = { ...defaultOptions.frame, ...options.frame };
     this.html = options.html ?? defaultOptions.html;
     this.preload = options.preload ?? defaultOptions.preload;
@@ -160,6 +168,15 @@ export class BrowserWindow {
     this.navigationRules = options.navigationRules ?? defaultOptions.navigationRules;
     this.sandbox = options.sandbox ?? defaultOptions.sandbox;
 
+    // Register before native create — create shows the window and the initial
+    // WM_ACTIVATE fires synchronously, so listeners must be in place first.
+    BrowserWindowMap[this.id] = this;
+    buniteEventEmitter.on(`focus-${this.id}`, this.handleNativeFocus);
+    buniteEventEmitter.on(`blur-${this.id}`, this.handleNativeBlur);
+    buniteEventEmitter.on(`move-${this.id}`, this.handleNativeMove);
+    buniteEventEmitter.on(`resize-${this.id}`, this.handleNativeResize);
+    buniteEventEmitter.on(`close-${this.id}`, this.handleNativeClose);
+
     const native = getNativeLibrary();
     this.nativeAttached =
       native?.symbols.bunite_window_create(
@@ -182,12 +199,6 @@ export class BrowserWindow {
       );
     }
 
-    BrowserWindowMap[this.id] = this;
-    buniteEventEmitter.on(`focus-${this.id}`, () => { lastFocusedWindowId = this.id; });
-    buniteEventEmitter.on(`move-${this.id}`, this.handleNativeMove);
-    buniteEventEmitter.on(`resize-${this.id}`, this.handleNativeResize);
-    buniteEventEmitter.on(`close-${this.id}`, this.handleNativeClose);
-
     const webview = new BrowserView({
       url: this.url,
       html: this.html,
@@ -223,6 +234,15 @@ export class BrowserWindow {
     return Object.values(BrowserWindowMap);
   }
 
+  /** The window owning a given view id — its main webview, or a surface view
+   *  whose `windowId` points back to the window. */
+  static getByWebviewId(viewId: number) {
+    const direct = Object.values(BrowserWindowMap).find((w) => w.webviewId === viewId);
+    if (direct) return direct;
+    const view = BrowserView.getById(viewId) as { windowId?: number } | undefined;
+    return view?.windowId != null ? BrowserWindowMap[view.windowId] : undefined;
+  }
+
   get webview(): BrowserView | undefined {
     return BrowserView.getById(this.webviewId) as BrowserView | undefined;
   }
@@ -234,6 +254,11 @@ export class BrowserWindow {
     }
   }
 
+  /** Best-effort — no native focus FFI yet; show() brings the window up. */
+  focus() {
+    this.show();
+  }
+
   close() {
     if (this.closed) {
       return;
@@ -258,6 +283,8 @@ export class BrowserWindow {
       this.nativeAttached = false;
     }
     delete BrowserWindowMap[this.id];
+    buniteEventEmitter.off(`focus-${this.id}`, this.handleNativeFocus);
+    buniteEventEmitter.off(`blur-${this.id}`, this.handleNativeBlur);
     buniteEventEmitter.off(`move-${this.id}`, this.handleNativeMove);
     buniteEventEmitter.off(`resize-${this.id}`, this.handleNativeResize);
     buniteEventEmitter.off(`close-${this.id}`, this.handleNativeClose);
@@ -356,6 +383,18 @@ export class BrowserWindow {
     return minimized;
   }
 
+  isFocused() {
+    return this._focused;
+  }
+
+  toggleMaximize() {
+    if (this.isMaximized()) this.unmaximize(); else this.maximize();
+  }
+
+  getState() {
+    return { maximized: this.isMaximized(), minimized: this.isMinimized(), focused: this._focused };
+  }
+
   setTitle(title: string) {
     this.title = title;
     if (this.nativeAttached) {
@@ -374,6 +413,13 @@ export class BrowserWindow {
     return this.frame;
   }
 
+  /** Start an OS-driven window move drag. Call from a renderer mousedown on a
+   *  custom titlebar region; the OS tracks the drag through mouse-up. */
+  beginMoveDrag() {
+    if (!this.nativeAttached) return;
+    getNativeLibrary()?.symbols.bunite_window_begin_move_drag(this.id);
+  }
+
   on(name: "close-requested" | "close" | "focus" | "blur" | "move" | "resize", handler: (event: unknown) => void) {
     const specificName = `${name}-${this.id}`;
     buniteEventEmitter.on(specificName, handler);

package/src/host/core/SurfaceBrowserIPC.ts

@@ -1,9 +1,11 @@
 import {
-  onSurfaceInit, emitSurfaceEvent, emitConsole,
+  onSurfaceInit, emitSurfaceEvent, emitConsole, emitDownload, emitPopupRequested,
   registerDialogRequest, disposeSurfaceState, clearConsoleBuffer,
 } from "./SurfaceManager";
+import { log } from "../log";
 
 onSurfaceInit((surfaceId, hostViewId, view) => {
+  log.debug("surface/init surfaceId=" + surfaceId + " hostViewId=" + hostViewId);
   view.on("did-navigate", (event: any) => {
     emitSurfaceEvent(hostViewId, surfaceId, { type: "navigate", url: event.data.detail });
   });
@@ -32,6 +34,7 @@ onSurfaceInit((surfaceId, hostViewId, view) => {
       message: string;
       defaultPrompt?: string;
     };
+    log.debug("surface/dialog-ipc surfaceId=" + surfaceId + " hostViewId=" + hostViewId + " kind=" + d.kind);
     registerDialogRequest(hostViewId, surfaceId, d);
   });
   view.on("console-message", (event: any) => {
@@ -39,6 +42,12 @@ onSurfaceInit((surfaceId, hostViewId, view) => {
     // microtask — no extra deferral needed at the listener level.
     emitConsole(hostViewId, surfaceId, event.data);
   });
+  view.on("download-event", (event: any) => {
+    emitDownload(hostViewId, surfaceId, event.data);
+  });
+  view.on("popup-requested", (event: any) => {
+    emitPopupRequested(hostViewId, surfaceId, event.data);
+  });
 });
 
 // Surface registry's untrackSurface doesn't fire a teardown event — wire it