bunite-core 0.12.0 → 0.14.0

package/src/host/native.ts

@@ -102,6 +102,31 @@ type NativeSymbols = {
   bunite_view_reload: (viewId: number) => void;
   bunite_view_execute_javascript: (viewId: number, script: CStringPointer) => void;
   bunite_view_evaluate: (viewId: number, requestId: number, script: CStringPointer) => void;
+  bunite_view_click: (
+    viewId: number, x: number, y: number,
+    button: number, clickCount: number, modifiers: number
+  ) => void;
+  bunite_view_type: (viewId: number, text: CStringPointer) => void;
+  bunite_view_press: (
+    viewId: number, windowsVkCode: number, macKeyCode: number,
+    key: CStringPointer, code: CStringPointer, character: CStringPointer,
+    modifiers: number, action: number, extended: boolean, location: number
+  ) => void;
+  bunite_view_scroll: (
+    viewId: number, dx: number, dy: number,
+    x: number, y: number, modifiers: number
+  ) => void;
+  bunite_view_mouse: (
+    viewId: number, action: number, x: number, y: number,
+    button: number, modifiers: number
+  ) => void;
+  bunite_view_respond_dialog: (
+    viewId: number, requestId: number, accept: boolean, text: CStringPointer
+  ) => void;
+  bunite_view_screenshot: (
+    viewId: number, requestId: number, format: CStringPointer, quality: number
+  ) => void;
+  bunite_view_capabilities: (viewId: number) => number;
   bunite_view_load_url: (viewId: number, url: CStringPointer) => void;
   bunite_view_load_html: (viewId: number, html: CStringPointer) => void;
   bunite_view_remove: (viewId: number) => void;
@@ -289,6 +314,38 @@ const nativeSymbolDefinitions = {
     args: [FFIType.u32, FFIType.u32, FFIType.cstring],
     returns: FFIType.void
   },
+  bunite_view_click: {
+    args: [FFIType.u32, FFIType.f64, FFIType.f64, FFIType.i32, FFIType.i32, FFIType.u32],
+    returns: FFIType.void
+  },
+  bunite_view_type: {
+    args: [FFIType.u32, FFIType.cstring],
+    returns: FFIType.void
+  },
+  bunite_view_press: {
+    args: [FFIType.u32, FFIType.i32, FFIType.i32, FFIType.cstring, FFIType.cstring, FFIType.cstring, FFIType.u32, FFIType.i32, FFIType.bool, FFIType.i32],
+    returns: FFIType.void
+  },
+  bunite_view_scroll: {
+    args: [FFIType.u32, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.u32],
+    returns: FFIType.void
+  },
+  bunite_view_mouse: {
+    args: [FFIType.u32, FFIType.i32, FFIType.f64, FFIType.f64, FFIType.i32, FFIType.u32],
+    returns: FFIType.void
+  },
+  bunite_view_respond_dialog: {
+    args: [FFIType.u32, FFIType.u32, FFIType.bool, FFIType.cstring],
+    returns: FFIType.void
+  },
+  bunite_view_screenshot: {
+    args: [FFIType.u32, FFIType.u32, FFIType.cstring, FFIType.i32],
+    returns: FFIType.void
+  },
+  bunite_view_capabilities: {
+    args: [FFIType.u32],
+    returns: FFIType.u32
+  },
   bunite_view_load_url: {
     args: [FFIType.u32, FFIType.cstring],
     returns: FFIType.void
@@ -350,6 +407,20 @@ export function setEvaluateResultHandler(handler: (viewId: number, result: Nativ
   evaluateResultHandler = handler;
 }
 
+export type NativeScreenshotResult = {
+  requestId: number;
+  ok: boolean;
+  format?: "png" | "jpeg";
+  mime?: string;
+  dataBase64?: string;
+  code?: string;
+  message?: string;
+};
+let screenshotResultHandler: ((viewId: number, result: NativeScreenshotResult) => void) | null = null;
+export function setScreenshotResultHandler(handler: (viewId: number, result: NativeScreenshotResult) => void) {
+  screenshotResultHandler = handler;
+}
+
 // Per-view deferred resolvers for "view-ready" (OnAfterCreated).
 const viewReadyResolvers = new Map<number, () => void>();
 
@@ -499,6 +570,11 @@ function registerNativeCallbacks(library: LoadedNativeLibrary) {
             evaluateResultHandler?.(viewId, parsed);
             break;
           }
+          case "screenshot-result": {
+            const parsed = maybeParsePayload(payload) as NativeScreenshotResult;
+            screenshotResultHandler?.(viewId, parsed);
+            break;
+          }
           case "title-changed": {
             const parsed = maybeParsePayload(payload) as { title: string };
             buniteEventEmitter.emitEvent(
@@ -507,6 +583,53 @@ function registerNativeCallbacks(library: LoadedNativeLibrary) {
             );
             break;
           }
+          case "load-start":
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.loadStart({ detail: payload }),
+              viewId
+            );
+            break;
+          case "load-finish":
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.loadFinish({ detail: payload }),
+              viewId
+            );
+            break;
+          case "load-fail": {
+            const parsed = maybeParsePayload(payload) as { url?: string; reason?: string };
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.loadFail({
+                url: parsed.url ?? "", reason: parsed.reason,
+              }),
+              viewId
+            );
+            break;
+          }
+          case "dialog": {
+            const parsed = maybeParsePayload(payload) as {
+              requestId: number;
+              kind: "alert" | "confirm" | "prompt" | "beforeunload";
+              message: string;
+              defaultPrompt?: string;
+            };
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.dialog(parsed),
+              viewId
+            );
+            break;
+          }
+          case "console-message": {
+            const parsed = maybeParsePayload(payload) as {
+              level: "log" | "warn" | "error" | "info" | "debug";
+              args: string[];
+              ts: number;
+            };
+            buniteEventEmitter.emitEvent(
+              buniteEventEmitter.events.webview.consoleMessage(parsed),
+              viewId
+            );
+            break;
+          }
         }
       },
       {
@@ -656,7 +779,7 @@ export async function initNativeRuntime(
     throw new Error(`bunite: failed to load native library at ${artifacts.nativeLibPath}.`);
   }
 
-  const EXPECTED_ABI = 5;
+  const EXPECTED_ABI = 9;
   const nativeAbi = nativeLibrary.symbols.bunite_abi_version();
   if (nativeAbi !== EXPECTED_ABI) {
     throw new Error(

package/src/native/linux/bunite_linux_ffi.cpp

@@ -1,10 +1,13 @@
 #include "bunite_linux_internal.h"
 #include "webview_storage.h"
 
+#include <cairo.h>
+
 #include <cstdlib>
 #include <cstring>
 #include <mutex>
 #include <string>
+#include <vector>
 
 using bunite_linux::g_runtime;
 using bunite_linux::runOnUiThreadSync;
@@ -133,12 +136,103 @@ extern "C" BUNITE_EXPORT void bunite_view_execute_javascript(uint32_t view_id, c
   });
 }
 
-extern "C" BUNITE_EXPORT void bunite_view_evaluate(uint32_t view_id, uint32_t request_id, const char* /*script*/) {
-  // Stage A: Linux evaluate not yet implemented.
-  std::string payload = "{\"requestId\":" + std::to_string(request_id) +
-                        ",\"ok\":false,\"code\":\"not_supported\","
-                        "\"message\":\"Linux evaluate not implemented (Stage A: Windows only)\"}";
-  bunite_linux::emitWebviewEvent(view_id, "evaluate-result", payload);
+namespace {
+
+struct EvaluateCtx {
+  uint32_t view_id;
+  uint32_t request_id;
+};
+
+void on_evaluate_done(GObject* source, GAsyncResult* res, gpointer user_data) {
+  auto* ctx = static_cast<EvaluateCtx*>(user_data);
+  WebKitWebView* wv = WEBKIT_WEB_VIEW(source);
+  GError* err = nullptr;
+  JSCValue* value = webkit_web_view_evaluate_javascript_finish(wv, res, &err);
+
+  std::string payload = "{\"requestId\":" + std::to_string(ctx->request_id);
+  if (err || !value) {
+    std::string msg = err ? err->message : "evaluate failed";
+    if (err) g_error_free(err);
+    payload += ",\"ok\":false,\"code\":\"runtime_error\","
+               "\"message\":\"" + bunite_linux::escapeJsonString(msg) + "\"}";
+  } else if (!jsc_value_is_string(value)) {
+    payload += ",\"ok\":false,\"code\":\"runtime_error\","
+               "\"message\":\"wrapper returned non-string\"}";
+  } else {
+    char* raw = jsc_value_to_string(value);
+    std::string inner = raw ? raw : "";
+    if (raw) g_free(raw);
+    if (inner.find("\"__bunite_ok\":true") != std::string::npos) {
+      static const std::string prefix = "{\"__bunite_ok\":true,\"value\":";
+      std::string value_json = "null";
+      if (inner.compare(0, prefix.size(), prefix) == 0 &&
+          inner.size() > prefix.size() + 1) {
+        value_json = inner.substr(prefix.size(), inner.size() - prefix.size() - 1);
+      }
+      payload += ",\"ok\":true,\"value\":\"" + bunite_linux::escapeJsonString(value_json) + "\"}";
+    } else {
+      static const std::string codePrefix = "{\"__bunite_ok\":false,\"code\":\"";
+      std::string code = "runtime_error";
+      std::string msg = "script threw";
+      if (inner.compare(0, codePrefix.size(), codePrefix) == 0) {
+        size_t start = codePrefix.size();
+        size_t end = start;
+        while (end < inner.size() && inner[end] != '"') ++end;
+        if (end > start) code = inner.substr(start, end - start);
+        static const std::string msgKey = "\",\"message\":\"";
+        if (end + msgKey.size() <= inner.size() &&
+            inner.compare(end, msgKey.size(), msgKey) == 0) {
+          size_t mstart = end + msgKey.size();
+          size_t mend = mstart;
+          while (mend < inner.size()) {
+            if (inner[mend] == '"' && (mend == mstart || inner[mend - 1] != '\\')) break;
+            ++mend;
+          }
+          if (mend > mstart) msg = inner.substr(mstart, mend - mstart);
+        }
+      }
+      payload += ",\"ok\":false,\"code\":\"" + bunite_linux::escapeJsonString(code) + "\","
+                 "\"message\":\"" + bunite_linux::escapeJsonString(msg) + "\"}";
+    }
+  }
+  if (value) g_object_unref(value);
+  bunite_linux::emitWebviewEvent(ctx->view_id, "evaluate-result", payload);
+  delete ctx;
+}
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT void bunite_view_evaluate(uint32_t view_id, uint32_t request_id, const char* script) {
+  // Wrapper matches WebView2/CEF: try/catch returns JSON envelope string.
+  // jsc_value_to_string delivers the wrapper's return value directly.
+  if (!script) {
+    std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                          ",\"ok\":false,\"code\":\"runtime_error\","
+                          "\"message\":\"null script\"}";
+    bunite_linux::emitWebviewEvent(view_id, "evaluate-result", payload);
+    return;
+  }
+  std::string wrapped =
+      "(function(){try{return JSON.stringify({__bunite_ok:true,value:("
+      + std::string(script) +
+      ")})}catch(e){var c=(e&&e.name===\"SecurityError\")?\"cross_origin\":\"runtime_error\";"
+      "return JSON.stringify({__bunite_ok:false,code:c,"
+      "message:(e&&e.message)?e.message:String(e),"
+      "name:(e&&e.name)||\"\"})}})()";
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_linux::findView(view_id);
+    if (!v || !v->webview) {
+      std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                            ",\"ok\":false,\"code\":\"not_supported\","
+                            "\"message\":\"view not ready\"}";
+      bunite_linux::emitWebviewEvent(view_id, "evaluate-result", payload);
+      return;
+    }
+    auto* ctx = new EvaluateCtx{view_id, request_id};
+    webkit_web_view_evaluate_javascript(
+        v->webview, wrapped.c_str(), -1, nullptr, nullptr, nullptr,
+        on_evaluate_done, ctx);
+  });
 }
 
 extern "C" BUNITE_EXPORT void bunite_view_load_url(uint32_t view_id, const char* url) {
@@ -254,6 +348,129 @@ extern "C" BUNITE_EXPORT void bunite_view_remove(uint32_t view_id) {
   runOnUiThreadSync([=]() { bunite_linux::removeView(view_id); });
 }
 
+// Input dispatch — no-op on GTK4 + Wayland (no portable synthetic-input primitive).
+// Capability `click/type/press/scroll: false` is honest; calls are silent no-ops.
+extern "C" BUNITE_EXPORT void bunite_view_click(uint32_t, double, double, int32_t, int32_t, uint32_t) {}
+extern "C" BUNITE_EXPORT void bunite_view_type(uint32_t, const char*) {}
+extern "C" BUNITE_EXPORT void bunite_view_press(uint32_t, int32_t, int32_t, const char*, const char*, const char*, uint32_t, int32_t, bool, int32_t) {}
+extern "C" BUNITE_EXPORT void bunite_view_scroll(uint32_t, double, double, double, double, uint32_t) {}
+extern "C" BUNITE_EXPORT void bunite_view_mouse(uint32_t, int32_t, double, double, int32_t, uint32_t) {}
+
+extern "C" BUNITE_EXPORT void bunite_view_respond_dialog(uint32_t view_id, uint32_t request_id,
+                                                          bool accept, const char* text) {
+  bunite_linux::respondToDialogRequest(view_id, request_id, accept, text ? text : "");
+}
+
+// Screenshot — webkit_web_view_get_snapshot → cairo_surface_t → PNG bytes via
+// cairo_surface_write_to_png_stream → g_base64_encode. JPEG path uses GdkPixbuf
+// for `pixbuf_save_to_buffer(... "jpeg" ...)`.
+namespace {
+
+struct LinuxShotCtx {
+  uint32_t view_id;
+  uint32_t request_id;
+  std::string format;  // "png" | "jpeg"
+  int32_t quality;
+};
+
+void emitLinuxShotError(uint32_t view_id, uint32_t request_id, const char* code, const std::string& msg) {
+  std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+                        ",\"ok\":false,\"code\":\"" + code + "\","
+                        "\"message\":\"" + bunite_linux::escapeJsonString(msg) + "\"}";
+  bunite_linux::emitWebviewEvent(view_id, "screenshot-result", payload);
+}
+
+// WebKitGTK 2.52+ snapshot returns GdkTexture (was cairo_surface_t pre-2.52).
+// PNG: gdk_texture_save_to_png_bytes — built-in. JPEG: bridge through GdkPixbuf
+// via gdk_pixbuf_get_from_texture (non-deprecated GTK4 path).
+void on_snapshot_done(GObject* source, GAsyncResult* res, gpointer user_data) {
+  auto* ctx = static_cast<LinuxShotCtx*>(user_data);
+  WebKitWebView* wv = WEBKIT_WEB_VIEW(source);
+  GError* err = nullptr;
+  GdkTexture* texture = webkit_web_view_get_snapshot_finish(wv, res, &err);
+  if (!texture) {
+    emitLinuxShotError(ctx->view_id, ctx->request_id, "runtime_error",
+                       err ? err->message : "snapshot returned nil");
+    if (err) g_error_free(err);
+    delete ctx;
+    return;
+  }
+
+  std::vector<unsigned char> bytes;
+  std::string mime;
+  const bool jpeg = (ctx->format == "jpeg" || ctx->format == "jpg");
+  if (jpeg) {
+    GdkPixbuf* pix = gdk_pixbuf_get_from_texture(texture);
+    if (pix) {
+      gchar* raw = nullptr; gsize raw_len = 0;
+      char qbuf[8]; snprintf(qbuf, sizeof(qbuf), "%d",
+                              ctx->quality < 0 ? 90 : (ctx->quality > 100 ? 100 : ctx->quality));
+      GError* perr = nullptr;
+      if (gdk_pixbuf_save_to_buffer(pix, &raw, &raw_len, "jpeg", &perr, "quality", qbuf, nullptr)) {
+        bytes.assign(raw, raw + raw_len);
+        g_free(raw);
+      } else if (perr) {
+        g_error_free(perr);
+      }
+      g_object_unref(pix);
+    }
+    mime = "image/jpeg";
+    ctx->format = "jpeg";
+  } else {
+    GBytes* png = gdk_texture_save_to_png_bytes(texture);
+    if (png) {
+      gsize n = 0;
+      const auto* p = static_cast<const unsigned char*>(g_bytes_get_data(png, &n));
+      bytes.assign(p, p + n);
+      g_bytes_unref(png);
+    }
+    mime = "image/png";
+    ctx->format = "png";
+  }
+  g_object_unref(texture);
+
+  if (bytes.empty()) {
+    emitLinuxShotError(ctx->view_id, ctx->request_id, "runtime_error", "encode failed");
+    delete ctx;
+    return;
+  }
+  gchar* b64 = g_base64_encode(bytes.data(), bytes.size());
+  std::string payload = "{\"requestId\":" + std::to_string(ctx->request_id) +
+                        ",\"ok\":true,\"format\":\"" + ctx->format +
+                        "\",\"mime\":\"" + mime +
+                        "\",\"dataBase64\":\"" + (b64 ? b64 : "") + "\"}";
+  if (b64) g_free(b64);
+  bunite_linux::emitWebviewEvent(ctx->view_id, "screenshot-result", payload);
+  delete ctx;
+}
+
+}  // namespace
+
+extern "C" BUNITE_EXPORT uint32_t bunite_view_capabilities(uint32_t view_id) {
+  // WebKitGTK — input dispatch impossible on GTK4+Wayland; screenshot via cairo.
+  auto* v = bunite_linux::findView(view_id);
+  if (!v) return 0;
+  return BUNITE_CAP_EVALUATE | BUNITE_CAP_SURFACE_EVENTS |
+         BUNITE_CAP_DIALOGS | BUNITE_CAP_CONSOLE |
+         BUNITE_CAP_SCREENSHOT | BUNITE_CAP_FORMAT_PNG | BUNITE_CAP_FORMAT_JPEG;
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_screenshot(uint32_t view_id, uint32_t request_id,
+                                                       const char* format, int32_t quality) {
+  std::string fmt = format ? format : "png";
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_linux::findView(view_id);
+    if (!v || !v->webview) {
+      emitLinuxShotError(view_id, request_id, "not_supported", "view not ready");
+      return;
+    }
+    auto* ctx = new LinuxShotCtx{view_id, request_id, fmt, quality};
+    webkit_web_view_get_snapshot(v->webview, WEBKIT_SNAPSHOT_REGION_VISIBLE,
+                                 WEBKIT_SNAPSHOT_OPTIONS_NONE, nullptr,
+                                 on_snapshot_done, ctx);
+  });
+}
+
 extern "C" BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id) {
   (void)view_id; BUNITE_LINUX_TODO("bunite_view_open_devtools");
 }

package/src/native/linux/bunite_linux_internal.h

@@ -38,6 +38,11 @@ struct ViewState {
   std::string preload_script;
   std::string stored_html;
   std::vector<std::string> navigation_rules;
+
+  // Page-initiated dialogs awaiting host response. WebKitScriptDialog is
+  // held until we mark confirmed/text + emit signal completion.
+  std::unordered_map<uint32_t, WebKitScriptDialog*> pending_dialogs;
+  uint32_t next_dialog_request_id = 1;
 };
 
 struct RuntimeState {
@@ -134,6 +139,7 @@ void destroyWindow(uint32_t window_id);
 
 ViewState* findView(uint32_t view_id);
 uint32_t viewIdForWebView(WebKitWebView* wv);
+void respondToDialogRequest(uint32_t view_id, uint32_t request_id, bool accept, const std::string& text);
 bool createView(uint32_t view_id, uint32_t window_id,
                 const char* url, const char* html, const char* preload, const char* appres_root,
                 const char* navigation_rules_json, const char* preload_origins_json,

package/src/native/linux/bunite_linux_runtime.cpp

@@ -16,7 +16,7 @@ bool isOnMainThread() {
 
 namespace {
 
-constexpr int32_t kBuniteAbiVersion = 5;
+constexpr int32_t kBuniteAbiVersion = 9;
 
 }  // namespace
 

package/src/native/linux/bunite_linux_utils.cpp

@@ -93,8 +93,8 @@ std::vector<std::string> parseNavigationRulesJson(const std::string& json) {
 }
 
 bool shouldAlwaysAllowNavigationUrl(const std::string& url) {
-  return url == "about:blank" ||
-         url.rfind("appres://app.internal/internal/", 0) == 0;
+  // Exact-match — prefix would let `../../evil` style paths bypass scrutiny.
+  return url == "about:blank" || url == "appres://app.internal/internal/index.html";
 }
 
 bool shouldAllowNavigation(const ViewState* view, const std::string& url) {

package/src/native/linux/bunite_linux_view.cpp

@@ -18,11 +18,15 @@ void emit_url(uint32_t view_id, const char* name, WebKitWebView* wv) {
 void on_load_changed(WebKitWebView* wv, WebKitLoadEvent event, gpointer user_data) {
   const uint32_t view_id = GPOINTER_TO_UINT(user_data);
   switch (event) {
+    case WEBKIT_LOAD_STARTED:
+      emit_url(view_id, "load-start", wv);
+      break;
     case WEBKIT_LOAD_COMMITTED:
       emit_url(view_id, "did-navigate", wv);
       queueViewRedraw(wv);
       break;
     case WEBKIT_LOAD_FINISHED:
+      emit_url(view_id, "load-finish", wv);
       emit_url(view_id, "dom-ready", wv);
       queueViewRedraw(wv);
       break;
@@ -30,6 +34,55 @@ void on_load_changed(WebKitWebView* wv, WebKitLoadEvent event, gpointer user_dat
   }
 }
 
+gboolean on_load_failed(WebKitWebView* /*wv*/, WebKitLoadEvent /*ev*/, const char* failing_uri,
+                        GError* error, gpointer user_data) {
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  std::string payload = "{\"url\":\"" + escapeJsonString(failing_uri ? failing_uri : "") +
+                        "\",\"reason\":\"" + escapeJsonString(error && error->message ? error->message : "") + "\"}";
+  emitWebviewEvent(view_id, "load-fail", payload);
+  return FALSE;  // let WebKit show its default error page
+}
+
+gboolean on_load_failed_tls(WebKitWebView* /*wv*/, const char* failing_uri,
+                            GTlsCertificate* /*cert*/, GTlsCertificateFlags /*errors*/,
+                            gpointer user_data) {
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  std::string payload = "{\"url\":\"" + escapeJsonString(failing_uri ? failing_uri : "") +
+                        "\",\"reason\":\"tls-certificate-error\"}";
+  emitWebviewEvent(view_id, "load-fail", payload);
+  return FALSE;  // do not override default certificate failure behavior
+}
+
+gboolean on_script_dialog(WebKitWebView* /*wv*/, WebKitScriptDialog* dialog, gpointer user_data) {
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  auto* v = findView(view_id);
+  if (!v) return FALSE;
+  WebKitScriptDialogType type = webkit_script_dialog_get_dialog_type(dialog);
+  const char* kind = nullptr;
+  switch (type) {
+    case WEBKIT_SCRIPT_DIALOG_ALERT:        kind = "alert"; break;
+    case WEBKIT_SCRIPT_DIALOG_CONFIRM:      kind = "confirm"; break;
+    case WEBKIT_SCRIPT_DIALOG_PROMPT:       kind = "prompt"; break;
+    case WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM: kind = "beforeunload"; break;
+    default: return FALSE;
+  }
+  // Defer the dialog so the page execution stays paused until host responds.
+  webkit_script_dialog_ref(dialog);
+  const uint32_t rid = v->next_dialog_request_id++;
+  v->pending_dialogs[rid] = dialog;
+  const char* message = webkit_script_dialog_get_message(dialog);
+  std::string payload = "{\"requestId\":" + std::to_string(rid) +
+                        ",\"kind\":\"" + kind +
+                        "\",\"message\":\"" + escapeJsonString(message ? message : "") + "\"";
+  if (type == WEBKIT_SCRIPT_DIALOG_PROMPT) {
+    const char* def = webkit_script_dialog_prompt_get_default_text(dialog);
+    payload += ",\"defaultPrompt\":\"" + escapeJsonString(def ? def : "") + "\"";
+  }
+  payload += "}";
+  emitWebviewEvent(view_id, "dialog", payload);
+  return TRUE;  // we handled it
+}
+
 GtkWidget* on_create(WebKitWebView* wv, WebKitNavigationAction* action, gpointer user_data) {
   const uint32_t view_id = GPOINTER_TO_UINT(user_data);
   WebKitURIRequest* req = webkit_navigation_action_get_request(action);
@@ -40,6 +93,14 @@ GtkWidget* on_create(WebKitWebView* wv, WebKitNavigationAction* action, gpointer
   return nullptr;  // cancel; JS opens via load_url if desired
 }
 
+void on_title_changed(GObject* source, GParamSpec* /*pspec*/, gpointer user_data) {
+  const uint32_t view_id = GPOINTER_TO_UINT(user_data);
+  WebKitWebView* wv = WEBKIT_WEB_VIEW(source);
+  const char* title = webkit_web_view_get_title(wv);
+  std::string payload = "{\"title\":\"" + escapeJsonString(title ? title : "") + "\"}";
+  emitWebviewEvent(view_id, "title-changed", payload);
+}
+
 // WebKitGTK fires nav-action for sub-frames with no main-frame discriminator — iframes hit nav rules.
 gboolean on_decide_policy(WebKitWebView* wv, WebKitPolicyDecision* decision,
                           WebKitPolicyDecisionType type, gpointer user_data) {
@@ -72,6 +133,26 @@ uint32_t viewIdForWebView(WebKitWebView* wv) {
   return GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(wv), kViewIdKey));
 }
 
+void respondToDialogRequest(uint32_t view_id, uint32_t request_id, bool accept,
+                            const std::string& text) {
+  auto* v = findView(view_id);
+  if (!v) return;
+  auto it = v->pending_dialogs.find(request_id);
+  if (it == v->pending_dialogs.end()) return;
+  WebKitScriptDialog* dialog = it->second;
+  v->pending_dialogs.erase(it);
+  if (!dialog) return;
+  WebKitScriptDialogType type = webkit_script_dialog_get_dialog_type(dialog);
+  if (type == WEBKIT_SCRIPT_DIALOG_CONFIRM || type == WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM) {
+    webkit_script_dialog_confirm_set_confirmed(dialog, accept ? TRUE : FALSE);
+  } else if (type == WEBKIT_SCRIPT_DIALOG_PROMPT) {
+    if (accept) webkit_script_dialog_prompt_set_text(dialog, text.c_str());
+    else webkit_script_dialog_prompt_set_text(dialog, nullptr);
+  }
+  webkit_script_dialog_close(dialog);
+  webkit_script_dialog_unref(dialog);
+}
+
 bool createView(uint32_t view_id, uint32_t window_id,
                 const char* url, const char* html, const char* preload, const char* appres_root,
                 const char* navigation_rules_json, const char* preload_origins_json,
@@ -122,8 +203,12 @@ bool createView(uint32_t view_id, uint32_t window_id,
   registerAppresScheme(webkit_web_view_get_context(wv));
 
   g_signal_connect(wv, "load-changed", G_CALLBACK(on_load_changed), GUINT_TO_POINTER(view_id));
+  g_signal_connect(wv, "load-failed", G_CALLBACK(on_load_failed), GUINT_TO_POINTER(view_id));
+  g_signal_connect(wv, "load-failed-with-tls-errors", G_CALLBACK(on_load_failed_tls), GUINT_TO_POINTER(view_id));
   g_signal_connect(wv, "decide-policy", G_CALLBACK(on_decide_policy), GUINT_TO_POINTER(view_id));
   g_signal_connect(wv, "create", G_CALLBACK(on_create), GUINT_TO_POINTER(view_id));
+  g_signal_connect(wv, "notify::title", G_CALLBACK(on_title_changed), GUINT_TO_POINTER(view_id));
+  g_signal_connect(wv, "script-dialog", G_CALLBACK(on_script_dialog), GUINT_TO_POINTER(view_id));
 
   GtkWidget* container = GTK_WIDGET(wv);
   if (auto_resize) {