bunite-core 0.14.0 → 0.17.0

package/src/rpc/framework.ts

@@ -1,18 +1,37 @@
 import { call, defineCap, stream, cap } from "./schema";
 import type { CapDef } from "./schema";
 
+/** Window state for custom-titlebar rendering (max/restore glyph + focus ring). */
+export interface WindowState {
+  maximized: boolean;
+  minimized: boolean;
+  focused: boolean;
+}
+
 export const BrowserWindowCap = defineCap("bunite.BrowserWindow", {
   focus: call<void, void>(),
-  close: call<void, void>(),
+  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 }),
   label: call<void, string>({ idempotent: true }),
+  minimize: call<void, void>(),
+  unminimize: call<void, void>(),
+  maximize: call<void, void>(),
+  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
+  // 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.
+  beginMoveDrag: call<void, void>(),
 });
 
 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 }),
   focus: call<{ id?: number; label?: string }, void>(),
   close: call<{ id?: number; label?: string }, void>(),
 });
@@ -82,9 +101,9 @@ export const PageReportingCap = defineCap("bunite.PageReporting", {
 
 export type SurfaceMask = { x: number; y: number; w: number; h: number };
 
-/** Automation feature flags reported per surface. Append-only — consumers
- *  treat missing fields as `false`. Backend-honest: a method may exist on the
- *  RPC surface but return `not_supported` when the backend can't fulfil it. */
+/** Automation feature flags reported per surface. Two categories: method
+ *  gate (false → must not call) and property advertise (false → method runs,
+ *  property degrades; per-field JSDoc below). See `.agents/architecture.md`. */
 export interface SurfaceCapabilities {
   evaluate: boolean;
   crossOriginEval: boolean;
@@ -110,19 +129,142 @@ export interface SurfaceCapabilities {
   screenshot: boolean;
   /** Present only when `screenshot` is true. */
   formats?: ("png" | "jpeg")[];
+  accessibilitySnapshot: boolean;
+  getBoundingRect: boolean;
+  /** `listFrames` works + `evaluate({frameId})` reaches the target frame's
+   *  isolated world. Frame-targeted input dispatch is not yet implemented. */
+  frames: boolean;
+  /** Backend can intercept downloads and emit lifecycle events. When `false`,
+   *  every download attempt emits `{kind: "blocked", reason: "not_supported"}`. */
+  downloads: boolean;
+  /** Backend can intercept popups (window.open / target=_blank / cmd-click) and
+   *  mint a new surface with the opener relationship preserved. Host adopts via
+   *  `acceptPopup({newSurfaceId, hostViewId, bounds})`. */
+  popups: boolean;
+  /** Atomic `resolveAndClick(selector)`. Click trust is per-call (see `ResolveAndClickResult`). */
+  resolveAndClick: boolean;
+}
+
+export interface AxNode {
+  nodeId: string;
+  role: string;
+  name: string;
+  value?: string;
+  description?: string;
+  level?: number;
+  checked?: boolean | "mixed";
+  pressed?: boolean | "mixed";
+  expanded?: boolean;
+  disabled?: boolean;
+  focused?: boolean;
+  invalid?: boolean;
+  required?: boolean;
+  selected?: boolean;
+  children?: AxNode[];
+}
+
+export interface AccessibilitySnapshotArgs {
+  surfaceId: number;
+  /** Drop nodes with `ignored:true` (and reparent their children). Default true. */
+  interestingOnly?: boolean;
+}
+export type AccessibilitySnapshotResult =
+  | { ok: true; tree: AxNode }
+  | { ok: false; code: "not_supported" | "runtime_error" | "timeout"; message: string };
+
+export interface BoundingRectArgs {
+  surfaceId: number;
+  selector: string;
+  /** When set, `rect` is FRAME-LOCAL (the iframe's own viewport). Use frame-local
+   *  coords for further `evaluate({frameId})` ops; do not pass to `click({x,y})`
+   *  which expects page-viewport coords. */
+  frameId?: string;
+}
+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 };
+
+export interface Frame {
+  frameId: string;
+  parentFrameId: string | null;
+  origin: string;
+  url: string;
+  name?: string;
+}
+
+export type ListFramesResult =
+  | { ok: true; frames: Frame[] }
+  | { ok: false; code: "not_supported" | "runtime_error"; message: string };
+
+export type DownloadPolicy = "auto" | "ask" | "block";
+
+export type DownloadEvent =
+  | { 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" };
+
+export type WaitForDownloadResult =
+  | { 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 {
+  surfaceId: number;
+  policy: DownloadPolicy;
+  /** Absolute path. When omitted, backend keeps current dir (or temp). */
+  downloadDir?: string;
+}
+
+export interface AcceptPopupArgs {
+  newSurfaceId: number;
+  /** The host BrowserView that will own the new surface. */
+  hostViewId: number;
+  bounds: { x: number; y: number; width: number; height: number };
+}
+export type AcceptPopupResult =
+  | { ok: true }
+  | { ok: false; code: "not_found" | "host_view_invalid"; message: string };
+
+export interface ExtendPopupTimeoutArgs {
+  newSurfaceId: number;
+  /** Reset semantic: new deadline = now + gracePeriodMs. Not cumulative.
+   *  Capped at 60s since the popup arm was emitted. */
+  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 };
 
-/** Surface lifecycle event arm. Backends emit a subset honestly — SPA
- *  `history.pushState` fires only `navigate`; classic navigation fires
- *  `load-start` → `navigate` → `load-finish` (order varies per backend hook
- *  sequence and isn't a strict invariant). A navigation produces `load-finish`
- *  OR `load-fail`, never both. */
-export type SurfaceEvent =
+/** Surface lifecycle event arm before the surface pipeline stamps `epoch`. */
+export type SurfaceEventBase =
   | { type: "navigate"; url: string }
   | { type: "load-start"; url: string }
   | { type: "load-finish"; url: string }
   | { type: "load-fail"; url: string; reason?: string }
-  | { type: "title-change"; title: string };
+  | { type: "title-change"; title: string }
+  | {
+      type: "popup";
+      url: string;
+      disposition: "tab" | "window" | "popup";
+      openerSurfaceId: number;
+      /** Native surface ID minted before the arm is emitted. Host must call
+       *  `acceptPopup` (within `popupAdoptionTimeoutMs`, default 5s) to attach,
+       *  or `dismissPopup` to close. Auto-dismiss fires on timeout. */
+      newSurfaceId: number;
+    };
+
+/** Wire form of `SurfaceEventBase`. `epoch` bumps on every `navigate` (incl. SPA
+ *  `pushState`); other arms carry the current epoch. See `docs/browser-automation.md`. */
+export type SurfaceEvent = SurfaceEventBase & { epoch: number };
+
+export interface NavigationState {
+  lastLoadEpoch: number;
+  isLoading: boolean;
+  currentUrl: string;
+}
 
 export type EvaluateResult =
   | { ok: true; value: unknown }
@@ -206,6 +348,7 @@ export interface WaitForSelectorArgs {
   selector: string;
   /** Default 5000ms. Polled at 50ms intervals via `evaluate`. */
   timeoutMs?: number;
+  frameId?: string;
 }
 export interface WaitForFunctionArgs {
   surfaceId: number;
@@ -215,6 +358,7 @@ export interface WaitForFunctionArgs {
   timeoutMs?: number;
   /** Default 50ms. Increase for heavy expressions to reduce IPC load. */
   pollIntervalMs?: number;
+  frameId?: string;
 }
 export type WaitResult =
   | { ok: true }
@@ -248,6 +392,22 @@ export type ScreenshotResult =
   | { ok: true; data: Uint8Array; mime: string; format: "png" | "jpeg" }
   | { ok: false; code: "not_supported" | "runtime_error" | "timeout" | "black_frame"; message: string };
 
+export interface ResolveAndClickArgs {
+  surfaceId: number;
+  selector: string;
+  /** Same-origin iframe (CEF/WV2). OOPIF → `cross_origin`. mac/linux → `not_supported`. */
+  frameId?: string;
+  button?: "left" | "middle" | "right";
+  clickCount?: number;
+  modifiers?: Modifier[];
+}
+/** rect is viewport-normalized. `isTrustedEvent` is empirical per backend —
+ *  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 };
+
 export const SurfaceCap = defineCap("bunite.Surface", {
   init: call<{
     src: string;
@@ -266,7 +426,7 @@ export const SurfaceCap = defineCap("bunite.Surface", {
   navigate: call<{ surfaceId: number; url: string }, void>(),
   goBack: call<{ surfaceId: number }, void>(),
   reload: call<{ surfaceId: number }, void>(),
-  evaluate: call<{ surfaceId: number; script: string }, EvaluateResult>(),
+  evaluate: call<{ surfaceId: number; script: string; frameId?: string }, EvaluateResult>(),
   capabilities: call<{ surfaceId: number }, SurfaceCapabilities>(),
   click: call<ClickArgs, void>(),
   type: call<TypeArgs, void>(),
@@ -282,8 +442,29 @@ export const SurfaceCap = defineCap("bunite.Surface", {
   surfaceEvents: stream<{ surfaceId: number }, SurfaceEvent>(),
   dialogs: stream<{ surfaceId: number }, DialogEvent>(),
   consoleEvents: stream<{ surfaceId: number }, ConsoleEntry>(),
+  getNavigationState: call<{ surfaceId: number }, NavigationState>({ idempotent: true }),
+  accessibilitySnapshot: call<AccessibilitySnapshotArgs, AccessibilitySnapshotResult>(),
+  getBoundingRect: call<BoundingRectArgs, BoundingRectResult>({ idempotent: true }),
+  listFrames: call<{ surfaceId: number }, ListFramesResult>({ idempotent: true }),
+  downloadEvents: stream<{ surfaceId: number }, DownloadEvent>(),
+  waitForDownload: call<{ surfaceId: number; timeoutMs?: number }, WaitForDownloadResult>(),
+  setDownloadPolicy: call<SetDownloadPolicyArgs, void>(),
+  acceptPopup: call<AcceptPopupArgs, AcceptPopupResult>(),
+  dismissPopup: call<{ newSurfaceId: number }, void>(),
+  extendPopupTimeout: call<ExtendPopupTimeoutArgs, ExtendPopupTimeoutResult>(),
+  resolveAndClick: call<ResolveAndClickArgs, ResolveAndClickResult>(),
 });
 
+/** Process-lifetime cumulative counts of popup lifecycle resolutions. Useful
+ *  for tuning the default popup adoption timeout. */
+export interface PopupMetrics {
+  armed: number;
+  adopted: number;
+  dismissed: number;
+  timeoutFired: number;
+  extended: number;
+}
+
 export const RuntimeCap = defineCap("bunite.Runtime", {
   window: call<void, typeof WindowCap>({ returns: cap(WindowCap), idempotent: true }),
   dialogs: call<void, typeof DialogsCap>({ returns: cap(DialogsCap), idempotent: true }),
@@ -295,6 +476,7 @@ export const RuntimeCap = defineCap("bunite.Runtime", {
   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 }),
+  popupMetrics: call<void, PopupMetrics>({ idempotent: true }),
 });
 
 export const FRAMEWORK_TYPE_IDS = {

package/src/rpc/index.ts

@@ -107,11 +107,17 @@ export {
 
 export type {
   WindowCreateOpts,
+  WindowState,
   DialogOpenFileOpts,
   DialogSaveFileOpts,
   DialogMessageOpts,
   SurfaceCapabilities,
   SurfaceEvent,
+  SurfaceEventBase,
+  NavigationState,
+  DownloadEvent,
+  DownloadPolicy,
+  WaitForDownloadResult,
   SurfaceMask,
   Modifier,
   ClickArgs,
@@ -130,6 +136,12 @@ export type {
   ScreenshotArgs,
   ScreenshotResult,
   EvaluateResult,
+  AcceptPopupArgs,
+  AcceptPopupResult,
+  ExtendPopupTimeoutArgs,
+  ExtendPopupTimeoutResult,
+  ResolveAndClickArgs,
+  ResolveAndClickResult,
 } from "./framework";
 
 export type {

package/src/rpc/peer.ts

@@ -56,7 +56,7 @@ export const FIRST_USER_TYPE_ID = 128;
 
 export const MAX_CAPS_PER_CONNECTION = 1024;
 export const MAX_IN_FLIGHT_CALLS_PER_CONNECTION = 1024;
-/** Client-side LRU cap for revoked cap-ids — prevents unbounded growth on long-lived connections with frequent plugin churn (e.g. flmux). */
+/** Client-side LRU cap for revoked cap-ids — prevents unbounded growth on long-lived connections with frequent plugin churn. */
 const REVOKED_CACHE_SIZE = MAX_CAPS_PER_CONNECTION * 4;
 
 const DEFAULT_DEADLINE_GRACE_MS = 500;

package/src/webview/native.ts

@@ -3,9 +3,14 @@
 import type { ClientOf } from "../rpc/index";
 import type {
   SurfaceCap, EvaluateResult, SurfaceCapabilities, ScreenshotResult,
-  SurfaceEvent, ConsoleEntry, WaitResult,
+  SurfaceEvent, ConsoleEntry, WaitResult, NavigationState,
+  AccessibilitySnapshotResult, BoundingRectResult, ListFramesResult,
+  DownloadEvent, DownloadPolicy, WaitForDownloadResult,
+  ResolveAndClickResult,
 } from "../rpc/framework";
 
+declare const __buniteWebviewId: number;
+
 declare const host: {
   runtime(): Promise<ClientOf<typeof import("../rpc/framework").RuntimeCap>>;
 };
@@ -138,17 +143,24 @@ class BuniteWebviewElement extends HTMLElement {
     this._unsubNavigate = () => ctrl.abort();
     void (async () => {
       try {
-        // Wait until *this* connection's init resolves, then capture surfaceId
-        // atomically before subscribing. Re-entrant connects abort prior loops
-        // via `ctrl`, so a stale resolve from a previous cycle can't leak in.
         const s = await getSurfaceCap();
         if (ctrl.signal.aborted) return;
         await this._waitForSurfaceId(ctrl.signal);
         const sid = this._surfaceId;
         if (ctrl.signal.aborted || sid == null) return;
-        const stream = s.surfaceEvents({ surfaceId: sid });
-        this._activeStreams.push(stream as { cancel?: () => void });
-        for await (const event of stream) {
+        const surfStream = s.surfaceEvents({ surfaceId: sid });
+        this._activeStreams.push(surfStream as { cancel?: () => void });
+        const dlStream = s.downloadEvents({ surfaceId: sid });
+        this._activeStreams.push(dlStream as { cancel?: () => void });
+        (async () => {
+          try {
+            for await (const event of dlStream) {
+              if (ctrl.signal.aborted) break;
+              this.dispatchEvent(new CustomEvent<DownloadEvent>("download-event", { detail: event }));
+            }
+          } catch { /* stream torn down */ }
+        })();
+        for await (const event of surfStream) {
           if (ctrl.signal.aborted) break;
           this.dispatchEvent(new CustomEvent<SurfaceEvent>("surface-event", { detail: event }));
         }
@@ -264,10 +276,10 @@ class BuniteWebviewElement extends HTMLElement {
     this.setAttribute("src", url);
   }
 
-  async evaluate(script: string): Promise<EvaluateResult> {
+  async evaluate(script: string, opts?: { frameId?: string }): Promise<EvaluateResult> {
     const sid = this._surfaceId;
     if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
-    return callSurfaceTyped((s) => s.evaluate({ surfaceId: sid, script }));
+    return callSurfaceTyped((s) => s.evaluate({ surfaceId: sid, script, frameId: opts?.frameId }));
   }
 
   async capabilities(): Promise<SurfaceCapabilities> {
@@ -277,7 +289,8 @@ class BuniteWebviewElement extends HTMLElement {
         evaluate: false, crossOriginEval: false, surfaceEvents: false,
         nativeInputTrusted: false, click: false, type: false, press: false,
         scroll: false, mouse: false, dialogs: false, console: false,
-        screenshot: false,
+        screenshot: false, accessibilitySnapshot: false, getBoundingRect: false,
+        frames: false, downloads: false, popups: false, resolveAndClick: false,
       };
     }
     return callSurfaceTyped((s) => s.capabilities({ surfaceId: sid }));
@@ -361,6 +374,64 @@ class BuniteWebviewElement extends HTMLElement {
     return (await callSurfaceTyped((s) => s.getConsoleBuffer({ surfaceId: sid, clear: opts?.clear }))) ?? [];
   }
 
+  async getNavigationState(): Promise<NavigationState> {
+    const sid = this._surfaceId;
+    if (sid == null) return { lastLoadEpoch: 0, isLoading: false, currentUrl: "" };
+    return callSurfaceTyped((s) => s.getNavigationState({ surfaceId: sid }));
+  }
+
+  async accessibilitySnapshot(opts?: { interestingOnly?: boolean }): Promise<AccessibilitySnapshotResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.accessibilitySnapshot({ surfaceId: sid, interestingOnly: opts?.interestingOnly }));
+  }
+
+  async getBoundingRect(selector: string, opts?: { frameId?: string }): Promise<BoundingRectResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "runtime_error", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.getBoundingRect({ surfaceId: sid, selector, frameId: opts?.frameId }));
+  }
+
+  async listFrames(): Promise<ListFramesResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.listFrames({ surfaceId: sid }));
+  }
+
+  async resolveAndClick(
+    selector: string,
+    opts?: {
+      frameId?: string;
+      button?: "left" | "middle" | "right";
+      clickCount?: number;
+      modifiers?: Array<"alt" | "ctrl" | "meta" | "shift">;
+    }
+  ): Promise<ResolveAndClickResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "runtime_error", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.resolveAndClick({ surfaceId: sid, selector, ...opts }));
+  }
+
+  async setDownloadPolicy(policy: DownloadPolicy, downloadDir?: string): Promise<void> {
+    const sid = this._surfaceId;
+    if (sid == null) return;
+    await callSurface((s) => s.setDownloadPolicy({ surfaceId: sid, policy, downloadDir }));
+  }
+
+  async waitForDownload(opts?: { timeoutMs?: number }): Promise<WaitForDownloadResult> {
+    const sid = this._surfaceId;
+    if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
+    return callSurfaceTyped((s) => s.waitForDownload({ surfaceId: sid, timeoutMs: opts?.timeoutMs }));
+  }
+
+  async dismissPopup(newSurfaceId: number): Promise<void> {
+    await callSurface((s) => s.dismissPopup({ newSurfaceId }));
+  }
+
+  async extendAdoptionTimeout(newSurfaceId: number, gracePeriodMs: number) {
+    return callSurfaceTyped((s) => s.extendPopupTimeout({ newSurfaceId, gracePeriodMs }));
+  }
+
   async screenshot(args?: { format?: "png" | "jpeg"; quality?: number }): Promise<ScreenshotResult> {
     const sid = this._surfaceId;
     if (sid == null) return { ok: false, code: "not_supported", message: "surface not ready" };
@@ -374,11 +445,71 @@ class BuniteWebviewElement extends HTMLElement {
     void callSurface((s) => s.setHidden({ surfaceId: sid, hidden }));
   }
 
+  private _setupSyncCtrl() {
+    this._syncCtrl = new OverlaySyncController(this, (rect) => {
+      const sid = this._surfaceId;
+      if (sid == null) return;
+      const isZero = rect.width === 0 && rect.height === 0;
+      if (isZero) {
+        if (!this._syncHidden) {
+          this._syncHidden = true;
+          this._applySurfaceHidden();
+        }
+        return;
+      }
+      if (this._syncHidden) {
+        this._syncHidden = false;
+        this._applySurfaceHidden();
+      }
+      void callSurface((s) => s.resize({
+        surfaceId: sid, x: rect.x, y: rect.y, w: rect.width, h: rect.height,
+      }));
+    });
+    this._syncCtrl.start();
+  }
+
   private initSurface() {
     if (this._surfaceId != null || this._initPromise != null) return;
 
     const dpr = window.devicePixelRatio || 1;
     const r = this.getBoundingClientRect();
+    const adoptAttr = this.getAttribute("adopt-popup-id");
+    const adoptId = adoptAttr ? Number(adoptAttr) : NaN;
+    if (Number.isFinite(adoptId)) {
+      // Popup adoption — bind a backend-minted surface (received via the parent
+      // page's `surface-event` `popup` arm) to this element.
+      const initPromise = getSurfaceCap().then(async (s) => {
+        const res = await s.acceptPopup({
+          newSurfaceId: adoptId,
+          hostViewId: __buniteWebviewId,
+          bounds: {
+            x: Math.round(r.x * dpr),
+            y: Math.round(r.y * dpr),
+            width: Math.round(r.width * dpr),
+            height: Math.round(r.height * dpr),
+          },
+        });
+        if (!res.ok) throw new Error(`acceptPopup failed: ${res.code}: ${res.message}`);
+        return { surfaceId: adoptId };
+      }) as Promise<SurfaceInitResponse>;
+      this._initPromise = initPromise;
+      initPromise.then((response) => {
+        if (this._initPromise !== initPromise) return;
+        if (this._aborted) {
+          void callSurface((s) => s.remove({ surfaceId: response.surfaceId }));
+          return;
+        }
+        this._surfaceId = response.surfaceId;
+        this._setupSyncCtrl();
+      }).catch((err) => {
+        if ((globalThis as { __BUNITE_DEBUG__?: boolean }).__BUNITE_DEBUG__) {
+          console.warn("[bunite] adopt-popup-id init failed", err);
+        }
+        this._initPromise = null;
+      });
+      return;
+    }
+
     const src = this._pendingSrc || this.getAttribute("src") || "";
     this._pendingSrc = null;
 
@@ -415,28 +546,7 @@ class BuniteWebviewElement extends HTMLElement {
           }
         }
 
-        this._syncCtrl = new OverlaySyncController(this, (rect) => {
-          const sid = this._surfaceId;
-          if (sid == null) return;
-
-          const isZero = rect.width === 0 && rect.height === 0;
-          if (isZero) {
-            if (!this._syncHidden) {
-              this._syncHidden = true;
-              this._applySurfaceHidden();
-            }
-            return;
-          }
-          if (this._syncHidden) {
-            this._syncHidden = false;
-            this._applySurfaceHidden();
-          }
-
-          void callSurface((s) => s.resize({
-            surfaceId: sid, x: rect.x, y: rect.y, w: rect.width, h: rect.height,
-          }));
-        });
-        this._syncCtrl.start();
+        this._setupSyncCtrl();
       })
       .catch(() => {})
       .finally(() => {