bunite-core 0.12.0 → 0.14.0

package/src/native/shared/ffi_exports.h

@@ -16,6 +16,27 @@ extern "C" {
 #endif
 
 /** ABI version. Bump on any breaking change to symbol set / signatures.
+ *  v9 (2026-05): adds `bunite_view_mouse` (move/down/up primitives for drag &
+ *                hover) + `bunite_view_respond_dialog`. Webview event names
+ *                expand to include `dialog` (alert/confirm/prompt/beforeunload)
+ *                and `console-message` (the latter is RPC-pushed by preload,
+ *                not emitted by native — listed here for the host-side event
+ *                channel completeness). Capability bits add `MOUSE` (1<<11),
+ *                `DIALOGS` (1<<12), `CONSOLE` (1<<13). `NATIVE_INPUT_TRUSTED`
+ *                meaning stretches to include `mouse` (click/type/press/mouse
+ *                all produce isTrusted=true on supporting backends; scroll and
+ *                screenshot remain outside that guarantee).
+ *  v8 (2026-05): `bunite_view_press` gains `action` (down/up/both), `extended`
+ *                (Win 0xE0 scancode prefix), `location` (DOM KeyboardEvent
+ *                location, 0/1/2/3) params. Webview event names expand to
+ *                include `load-start` / `load-finish` / `load-fail`. Capability
+ *                bit 2 renamed `TITLE_CHANGED` → `SURFACE_EVENTS` — value
+ *                unchanged but semantic is now "unified surfaceEvents stream
+ *                supported". A surface fires `load-finish` OR `load-fail` per
+ *                navigation, never both.
+ *  v7 (2026-05): adds `bunite_view_screenshot` + `bunite_view_capabilities`
+ *                + capability bitset (`BuniteCapBit`).
+ *  v6 (2026-05): adds input dispatch — `bunite_view_click/type/press/scroll`.
  *  v5 (2026-05): adds `bunite_view_evaluate` + `evaluate-result` webview event. */
 BUNITE_EXPORT int32_t bunite_abi_version(void);
 BUNITE_EXPORT void bunite_set_log_level(int32_t level);
@@ -124,6 +145,120 @@ BUNITE_EXPORT void bunite_view_set_anchor(uint32_t view_id, int mode, double ins
 BUNITE_EXPORT void bunite_view_go_back(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_reload(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_remove(uint32_t view_id);
+
+/* Input dispatch (ABI v6). Coordinates are CSS px, viewport-relative (TS
+ * normalizes devicePixelRatio + container offset). Modifier bitmask is
+ * Alt=1, Ctrl=2, Meta=4, Shift=8. Backends translate to their native form.
+ * No result envelope — `nativeInputTrusted` capability indicates DOM trust. */
+BUNITE_EXPORT void bunite_view_click(
+	uint32_t view_id,
+	double x,
+	double y,
+	int32_t button,       /* 0=left, 1=middle, 2=right */
+	int32_t click_count,  /* >=1 */
+	uint32_t modifiers
+);
+/** Type UTF-8 text. Each codepoint becomes a CHAR / insertText event — no IME composition. */
+BUNITE_EXPORT void bunite_view_type(uint32_t view_id, const char* text);
+/** Press a key: down + (optional) char + up.
+ *  `windows_vk_code` is Win32 VK_* for CEF / WebView2 CDP path.
+ *  `mac_key_code` is the Quartz Event Services hardware key code (kVK_*) — separate
+ *  from Win VK because DOM `KeyboardEvent.code` is derived from this on WebKit.
+ *  `key` / `code` are DOM `KeyboardEvent.key` / `.code` strings, passed to CDP so
+ *  the page sees the correct values. `character` is UTF-8 for the CHAR event;
+ *  empty = skip char. 0 vk codes = skip the virtual-key down/up.
+ *  `action`: 0=down only, 1=up only, 2=both (default). For Playwright-style
+ *  modifier-held wrap (keydown → click → keyup). CHAR follows Playwright rule:
+ *  emitted with down only when character is non-empty.
+ *  `extended`: Win scancode 0xE0 prefix — Numpad-Enter AND nav-cluster
+ *  (Arrow/Home/End/Insert/Delete/PageUp/PageDown/Meta/ContextMenu). Drives CEF
+ *  `native_key_code`. Other backends ignore.
+ *  `location`: DOM `KeyboardEvent.location` (0=standard, 1=left mod, 2=right
+ *  mod, 3=numpad). WV2 CDP forwards as `location`. Most extended keys are
+ *  location 0 — only NumpadEnter is location 3 here. */
+BUNITE_EXPORT void bunite_view_press(
+	uint32_t view_id,
+	int32_t windows_vk_code,
+	int32_t mac_key_code,
+	const char* key,
+	const char* code,
+	const char* character,
+	uint32_t modifiers,
+	int32_t action,
+	bool extended,
+	int32_t location
+);
+/** Scroll at (x, y). dx/dy in CSS px; positive = right/down. */
+BUNITE_EXPORT void bunite_view_scroll(
+	uint32_t view_id,
+	double dx,
+	double dy,
+	double x,
+	double y,
+	uint32_t modifiers
+);
+
+/** Raw mouse primitive. `action` 0=move, 1=down, 2=up. `button` 0=left, 1=middle,
+ *  2=right (ignored for move). Coordinates are CSS px viewport-relative. Drag is
+ *  composed = down → move(s) → up. Backends without input support (linux GTK)
+ *  treat as no-op. `modifiers` per-call atomic — no sticky state. */
+BUNITE_EXPORT void bunite_view_mouse(
+	uint32_t view_id,
+	int32_t action,
+	double x,
+	double y,
+	int32_t button,
+	uint32_t modifiers
+);
+
+/** Respond to a page-initiated modal dialog previously announced via the
+ *  webview event channel as `dialog` (`{requestId, kind, message, defaultPrompt?}`).
+ *  `accept` decides confirm/beforeunload outcome and gates whether `text` is
+ *  applied to `prompt`. Backends release the held page execution. */
+BUNITE_EXPORT void bunite_view_respond_dialog(
+	uint32_t view_id,
+	uint32_t request_id,
+	bool accept,
+	const char* text
+);
+
+/** Per-view automation capability bitset. Each backend returns the bits it
+ *  actually supports — TS layer decodes to `SurfaceCapabilities` object.
+ *  Bits are locked at ABI v6; append-only. */
+enum BuniteCapBit {
+	BUNITE_CAP_EVALUATE             = 1u << 0,
+	BUNITE_CAP_CROSS_ORIGIN_EVAL    = 1u << 1,
+	BUNITE_CAP_SURFACE_EVENTS       = 1u << 2,
+	BUNITE_CAP_NATIVE_INPUT_TRUSTED = 1u << 3,  /* click/type/press/mouse all isTrusted=true */
+	BUNITE_CAP_CLICK                = 1u << 4,
+	BUNITE_CAP_TYPE                 = 1u << 5,
+	BUNITE_CAP_PRESS                = 1u << 6,
+	BUNITE_CAP_SCROLL               = 1u << 7,
+	BUNITE_CAP_SCREENSHOT           = 1u << 8,
+	BUNITE_CAP_FORMAT_PNG           = 1u << 9,
+	BUNITE_CAP_FORMAT_JPEG          = 1u << 10,
+	BUNITE_CAP_MOUSE                = 1u << 11,
+	BUNITE_CAP_DIALOGS              = 1u << 12,
+	BUNITE_CAP_CONSOLE              = 1u << 13,
+};
+BUNITE_EXPORT uint32_t bunite_view_capabilities(uint32_t view_id);
+
+/** Capture the visible viewport as a PNG/JPEG image. Async — result reported
+ *  via the webview event handler as `screenshot-result` with payload
+ *    { requestId, ok: true, format, mime, dataBase64 }
+ *    { requestId, ok: false, code, message }
+ *  Error codes: `not_supported`, `runtime_error`, `timeout`, `black_frame` (CEF
+ *  compositor surface unreachable). `quality` is 0–100 for JPEG only — ignored
+ *  for PNG, and ignored entirely on WebView2 (`CapturePreview` has no quality
+ *  parameter; output uses Edge's default ~80). `dataBase64` is base64-encoded
+ *  image bytes; TS layer decodes. */
+BUNITE_EXPORT void bunite_view_screenshot(
+	uint32_t view_id,
+	uint32_t request_id,
+	const char* format,
+	int32_t quality
+);
+
 BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_close_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_toggle_devtools(uint32_t view_id);

package/src/native/win/native_host_cef.cpp

@@ -85,8 +85,11 @@ class BuniteCefClient
     public CefRequestHandler,
     public CefResourceRequestHandler,
     public CefPermissionHandler,
-    public CefDisplayHandler {
+    public CefDisplayHandler,
+    public CefJSDialogHandler {
 public:
+  // BuniteCefClient is constructed 1:1 with a `ViewHost*`; `last_title_` is
+  // therefore per-view. OnTitleChange runs on the CEF UI thread (single).
   explicit BuniteCefClient(ViewHost* view)
     : view_(view) {}
 
@@ -95,6 +98,49 @@ public:
   CefRefPtr<CefRequestHandler> GetRequestHandler() override { return this; }
   CefRefPtr<CefPermissionHandler> GetPermissionHandler() override { return this; }
   CefRefPtr<CefDisplayHandler> GetDisplayHandler() override { return this; }
+  CefRefPtr<CefJSDialogHandler> GetJSDialogHandler() override { return this; }
+
+  bool OnJSDialog(CefRefPtr<CefBrowser>, const CefString& /*origin_url*/,
+                  JSDialogType dialog_type, const CefString& message_text,
+                  const CefString& default_prompt_text,
+                  CefRefPtr<CefJSDialogCallback> callback,
+                  bool& suppress_message) override {
+    CEF_REQUIRE_UI_THREAD();
+    const char* kind = (dialog_type == JSDIALOGTYPE_ALERT) ? "alert"
+                     : (dialog_type == JSDIALOGTYPE_CONFIRM) ? "confirm" : "prompt";
+    const uint32_t rid = view_->next_dialog_request_id++;
+    view_->pending_dialogs[rid] = callback;
+    suppress_message = true;  // we control the dialog UX; host sends the answer.
+    std::string payload = "{\"requestId\":" + std::to_string(rid) +
+                          ",\"kind\":\"" + kind +
+                          "\",\"message\":\"" + bunite_win::escapeJsonString(message_text.ToString()) + "\"";
+    if (dialog_type == JSDIALOGTYPE_PROMPT) {
+      payload += ",\"defaultPrompt\":\"" + bunite_win::escapeJsonString(default_prompt_text.ToString()) + "\"";
+    }
+    payload += "}";
+    bunite_win::emitWebviewEvent(view_->id, "dialog", payload);
+    return true;  // handled — CEF will not show its own UI.
+  }
+
+  bool OnBeforeUnloadDialog(CefRefPtr<CefBrowser>, const CefString& message_text,
+                            bool /*is_reload*/,
+                            CefRefPtr<CefJSDialogCallback> callback) override {
+    CEF_REQUIRE_UI_THREAD();
+    const uint32_t rid = view_->next_dialog_request_id++;
+    view_->pending_dialogs[rid] = callback;
+    std::string payload = "{\"requestId\":" + std::to_string(rid) +
+                          ",\"kind\":\"beforeunload\",\"message\":\"" +
+                          bunite_win::escapeJsonString(message_text.ToString()) + "\"}";
+    bunite_win::emitWebviewEvent(view_->id, "dialog", payload);
+    return true;
+  }
+
+  void OnResetDialogState(CefRefPtr<CefBrowser>) override {
+    CEF_REQUIRE_UI_THREAD();
+    // Tab navigation / reload clears any stuck dialogs. Drop the callbacks —
+    // CEF won't deliver them anymore, and the page is already moving on.
+    view_->pending_dialogs.clear();
+  }
 
   bool OnProcessMessageReceived(
     CefRefPtr<CefBrowser> /*browser*/,
@@ -122,10 +168,25 @@ public:
 
   void OnTitleChange(CefRefPtr<CefBrowser>, const CefString& title) override {
     CEF_REQUIRE_UI_THREAD();
-    std::string payload = "{\"title\":\"" + bunite_win::escapeJsonString(title.ToString()) + "\"}";
+    std::string s = title.ToString();
+    // Filter the transients CEF emits during initial / mid-load (blank doc
+    // placeholder, momentary URL-as-title) and dedup on the last emitted value.
+    if (s.empty()) return;
+    if (s == last_title_) return;
+    last_title_ = s;
+    std::string payload = "{\"title\":\"" + bunite_win::escapeJsonString(s) + "\"}";
     bunite_win::emitWebviewEvent(view_->id, "title-changed", payload);
   }
 
+  void OnAddressChange(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame,
+                       const CefString& url) override {
+    CEF_REQUIRE_UI_THREAD();
+    if (!frame->IsMain()) return;
+    // URL commit point — parity with WV2 SourceChanged / mac didCommitNavigation.
+    // Distinct from load-finish (which is OnLoadEnd).
+    bunite_win::emitWebviewEvent(view_->id, "did-navigate", url.ToString());
+  }
+
   void OnBeforeDevToolsPopup(
     CefRefPtr<CefBrowser>,
     CefWindowInfo&,
@@ -153,6 +214,7 @@ public:
   void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
     CEF_REQUIRE_UI_THREAD();
     view_->browser = browser;
+    bunite_win::registerCdpObserverForView(view_);
     {
       std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
       g_runtime.browser_to_view_id[browser->GetIdentifier()] = view_->id;
@@ -270,6 +332,12 @@ public:
     return true;
   }
 
+  void OnLoadStart(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame, TransitionType) override {
+    CEF_REQUIRE_UI_THREAD();
+    if (!frame->IsMain()) return;
+    bunite_win::emitWebviewEvent(view_->id, "load-start", frame->GetURL().ToString());
+  }
+
   void OnLoadEnd(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame, int) override {
     CEF_REQUIRE_UI_THREAD();
     if (!frame->IsMain()) {
@@ -277,10 +345,24 @@ public:
     }
 
     const std::string url = frame->GetURL().ToString();
-    bunite_win::emitWebviewEvent(view_->id, "did-navigate", url);
+    bunite_win::emitWebviewEvent(view_->id, "load-finish", url);
     bunite_win::emitWebviewEvent(view_->id, "dom-ready", url);
   }
 
+  void OnLoadError(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame,
+                   ErrorCode errorCode, const CefString& errorText, const CefString& failedUrl) override {
+    CEF_REQUIRE_UI_THREAD();
+    if (!frame->IsMain()) return;
+    // ERR_ABORTED fires on user-initiated navigation cancellation — not a
+    // failure from the consumer's perspective. Filter to align with WV2.
+    if (errorCode == ERR_ABORTED) return;
+    std::string reason = errorText.ToString();
+    if (reason.empty()) reason = "ERR_" + std::to_string(static_cast<int>(errorCode));
+    std::string payload = "{\"url\":\"" + bunite_win::escapeJsonString(failedUrl.ToString()) +
+                          "\",\"reason\":\"" + bunite_win::escapeJsonString(reason) + "\"}";
+    bunite_win::emitWebviewEvent(view_->id, "load-fail", payload);
+  }
+
   bool OnShowPermissionPrompt(
     CefRefPtr<CefBrowser>,
     uint64_t,
@@ -341,6 +423,7 @@ public:
 
 private:
   ViewHost* view_;
+  std::string last_title_;
 
   IMPLEMENT_REFCOUNTING(BuniteCefClient);
 };