bunite-core 0.14.0 → 0.16.0

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(() => {

package/src/webview/polyfill.ts

@@ -1,6 +1,6 @@
 // Iframe fallback for web (no-op if native already registered). HTMLElement deref'd lazily so module is import-safe in Node/Bun.
 
-import type { SurfaceEvent } from "../rpc/framework";
+import type { SurfaceEvent, SurfaceEventBase } from "../rpc/framework";
 
 // Default sandbox omits allow-same-origin / allow-top-navigation / allow-modals /
 // allow-popups-to-escape-sandbox — popup escape stays opt-in so a sandboxed page
@@ -31,6 +31,12 @@ function definePolyfillClass(): CustomElementConstructor {
     private _iframe: HTMLIFrameElement | null = null;
     private _titleObserver: MutationObserver | null = null;
     private _lastTitle: string = "";
+    private _epoch: number = 0;
+    private _isLoading: boolean = false;
+    private _currentUrl: string = "";
+    // Local history stack for goBack — cross-origin contentWindow.history is
+    // inaccessible, so we track navigations ourselves.
+    private _history: string[] = [];
 
     private isReachable(): boolean {
       if (!this._iframe) return false;
@@ -50,8 +56,22 @@ function definePolyfillClass(): CustomElementConstructor {
       };
     }
 
-    private emit(event: SurfaceEvent) {
-      this.dispatchEvent(new CustomEvent<SurfaceEvent>("surface-event", { detail: event }));
+    private emit(event: SurfaceEventBase) {
+      if (event.type === "navigate") {
+        this._epoch++;
+        // Avoid pushing duplicate / same-as-top entries (reload doesn't grow history).
+        if (this._currentUrl && this._currentUrl !== event.url &&
+            this._history[this._history.length - 1] !== this._currentUrl) {
+          this._history.push(this._currentUrl);
+        }
+        this._currentUrl = event.url;
+      } else if (event.type === "load-start") {
+        this._isLoading = true;
+      } else if (event.type === "load-finish" || event.type === "load-fail") {
+        this._isLoading = false;
+      }
+      const stamped: SurfaceEvent = { ...event, epoch: this._epoch };
+      this.dispatchEvent(new CustomEvent<SurfaceEvent>("surface-event", { detail: stamped }));
     }
 
     private setupTitleObserver() {
@@ -100,6 +120,7 @@ function definePolyfillClass(): CustomElementConstructor {
           this.dispatchBlocked(src);
         } else {
           iframe.src = src;
+          this._currentUrl = src;
           this.emit({ type: "load-start", url: src });
         }
       }
@@ -112,8 +133,9 @@ function definePolyfillClass(): CustomElementConstructor {
         // Suppress the spurious about:blank load that fires after a blocked
         // navigation (or before any explicit navigate).
         if (isBlockedSrc(url)) return;
-        this.emit({ type: "load-finish", url });
+        // navigate first so load-finish carries the bumped epoch.
         this.emit({ type: "navigate", url });
+        this.emit({ type: "load-finish", url });
         this.setupTitleObserver();
       });
 
@@ -148,19 +170,22 @@ function definePolyfillClass(): CustomElementConstructor {
     }
 
     goBack() {
-      try {
-        this._iframe?.contentWindow?.history.back();
-      } catch {}
+      // Same-origin path uses native history. Cross-origin throws → fall back
+      // to our tracked stack (push on every navigate; pop here).
+      try { this._iframe?.contentWindow?.history.back(); return; } catch {}
+      const prev = this._history.pop();
+      if (prev && this._iframe) this._iframe.src = prev;
     }
 
     reload() {
-      try {
-        this._iframe?.contentWindow?.location.reload();
-      } catch {
-        if (this._iframe) {
-          this._iframe.src = this._iframe.src;
-        }
-      }
+      try { this._iframe?.contentWindow?.location.reload(); return; } catch {}
+      // Cross-origin fallback: reassigning the same src is a no-op in WHATWG;
+      // cycle via about:blank to force a fresh navigation.
+      const iframe = this._iframe;
+      if (!iframe) return;
+      const url = this._currentUrl || iframe.src;
+      iframe.src = "about:blank";
+      requestAnimationFrame(() => { if (this._iframe) this._iframe.src = url; });
     }
 
     setHidden(hidden: boolean) {
@@ -219,6 +244,54 @@ function definePolyfillClass(): CustomElementConstructor {
       target.dispatchEvent(new MouseEvent("click", init));
     }
 
+    async resolveAndClick(_selector: string, _opts?: unknown) {
+      return { ok: false as const, code: "not_supported" as const, message: "polyfill iframe: atomic resolveAndClick not supported" };
+    }
+
+    async getBoundingRect(selector: string, _opts?: unknown) {
+      if (!this.isReachable()) return { ok: false as const, code: "not_supported" as const, message: "iframe not reachable" };
+      try {
+        const el = this._iframe!.contentDocument!.querySelector(selector) as Element | null;
+        if (!el) return { ok: false as const, code: "not_found" as const, message: `selector ${selector} not found` };
+        const r = el.getBoundingClientRect();
+        const win = this._iframe!.contentWindow!;
+        const visible = r.width > 0 && r.height > 0 && r.bottom > 0 && r.right > 0
+                       && r.top < win.innerHeight && r.left < win.innerWidth;
+        return { ok: true as const, rect: { x: r.x, y: r.y, width: r.width, height: r.height }, visible };
+      } catch (e: any) {
+        const code = e?.name === "SecurityError" ? "cross_origin" as const : "runtime_error" as const;
+        return { ok: false as const, code, message: e?.message ?? String(e) };
+      }
+    }
+
+    async listFrames() {
+      return { ok: false as const, code: "not_supported" as const, message: "polyfill: not implemented" };
+    }
+
+    async accessibilitySnapshot(_opts?: unknown) {
+      return { ok: false as const, code: "not_supported" as const, message: "polyfill: not implemented" };
+    }
+
+    async setDownloadPolicy(_policy: unknown, _dir?: unknown) {
+      // No-op — iframe has no download lifecycle hook.
+    }
+
+    async waitForDownload(_opts?: unknown) {
+      return { ok: false as const, code: "not_supported" as const, message: "polyfill: not implemented" };
+    }
+
+    async acceptPopup(_opts?: unknown) {
+      return { ok: false as const, code: "not_found" as const, message: "polyfill: no popup orchestration" };
+    }
+
+    async dismissPopup(_id?: unknown) {
+      // No-op.
+    }
+
+    async extendAdoptionTimeout(_id?: unknown, _ms?: unknown) {
+      return { ok: false as const, code: "not_found" as const, message: "polyfill: no popup orchestration" };
+    }
+
     async sendType(text: string) {
       if (!this.isReachable()) return;
       const doc = this._iframe!.contentDocument!;
@@ -313,6 +386,10 @@ function definePolyfillClass(): CustomElementConstructor {
       return [] as { level: string; args: string[]; ts: number }[];
     }
 
+    async getNavigationState() {
+      return { lastLoadEpoch: this._epoch, isLoading: this._isLoading, currentUrl: this._currentUrl };
+    }
+
     async screenshot(_args?: { format?: "png" | "jpeg"; quality?: number }) {
       return { ok: false as const, code: "not_supported" as const, message: "iframe polyfill does not support screenshot" };
     }