bunite-core 0.11.0 → 0.11.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "type": "module",
   "scripts": {
     "setup:cef": "bun ../tools/bunite-dev/scripts/setup-cef.ts",
@@ -24,7 +24,7 @@
     "msgpackr": "^1.11.9"
   },
   "optionalDependencies": {
-    "bunite-native-win-x64": "0.0.4",
+    "bunite-native-win-x64": "0.0.6",
     "bunite-native-mac-arm64": "0.0.1",
     "bunite-native-linux-x64": "0.0.1"
   }

package/src/host/core/App.ts

@@ -88,9 +88,15 @@ export class AppRuntime {
       process.env.BUNITE_USER_DATA_DIR = join(appDataDir, name);
     }
 
+    const envEngine = process.env.BUNITE_ENGINE;
+    const engineFromEnv = envEngine === "cef" || envEngine === "webview2"
+      ? envEngine
+      : undefined;
+
     await initNativeRuntime({
       hideConsole: options.hideConsole,
       popupBlocking: options.popupBlocking,
+      engine: options.engine ?? engineFromEnv,
       engineFlags: options.engineFlags
     });
 
@@ -126,11 +132,21 @@ export class AppRuntime {
   }
 
   run() {
+    if (!getNativeRuntimeState()) {
+      throw new Error("AppRuntime.run() called before await app.ready completed");
+    }
     const lib = getNativeLibrary();
+    // CEF: bunite_run_loop blocks here. WebView2 / mac / linux: returns immediately
+    // (cooperative pump kicks in below).
     lib?.symbols.bunite_run_loop();
 
-    if (process.platform === "darwin" || process.platform === "linux") {
-      // mac/linux: cooperative pump on Bun's main thread (NSApp/GTK first-thread constraint).
+    const engine = getNativeEngineName();
+    const cooperative =
+      process.platform === "darwin" ||
+      process.platform === "linux" ||
+      (process.platform === "win32" && engine !== "cef");
+
+    if (cooperative) {
       this.pumpActive = true;
       const pump = () => {
         if (!this.pumpActive) return;
@@ -139,8 +155,6 @@ export class AppRuntime {
       };
       pump();
     }
-    // Windows: native UI thread is separate. Bun's loop stays alive via the RPC
-    // listening socket started by ensureRpcServer() in the constructor.
   }
 
   quit(code = 0) {

package/src/host/core/BrowserWindow.ts

@@ -175,6 +175,12 @@ export class BrowserWindow {
         Boolean(this.frame.minimized),
         Boolean(this.frame.maximized)
       ) ?? false;
+    if (!this.nativeAttached) {
+      console.error(
+        `[bunite] bunite_window_create returned false for window ${this.id} — ` +
+        `window will be unusable. Check native log (BUNITE_LOG_LEVEL=info).`
+      );
+    }
 
     BrowserWindowMap[this.id] = this;
     buniteEventEmitter.on(`focus-${this.id}`, () => { lastFocusedWindowId = this.id; });

package/src/host/index.ts

@@ -8,7 +8,7 @@ import { acquireSingleInstanceLock, type SingleInstanceLock } from "./core/singl
 import { log, type LogLevel } from "./log";
 
 export { serveWeb } from "./serveWeb";
-export type { WebRpcMount } from "./serveWeb";
+export type { WebRpcMount, WsData, ServeWebOptions } from "./serveWeb";
 
 export {
   acquireSingleInstanceLock,

package/src/host/native.ts

@@ -2,16 +2,20 @@ import { CString, dlopen, FFIType, JSCallback, ptr, type Pointer } from "bun:ffi
 import { existsSync } from "node:fs";
 import { delimiter, join } from "node:path";
 import { buniteEventEmitter } from "./events/eventEmitter";
-import { resolveNativeArtifacts, type ResolvedNativeArtifacts } from "./paths";
+import { resolveNativeArtifacts, type ResolvedNativeArtifacts, type WindowsEngine } from "./paths";
+import { resolvePackageRoot } from "./paths";
 import { log } from "./log";
 
 export type NativeBootstrapOptions = {
   hideConsole?: boolean;
   popupBlocking?: boolean;
+  /** Windows-only engine selection. Default "webview2"; "cef" requires bunite-cef-win-x64. */
+  engine?: WindowsEngine;
   /**
    * Engine-specific opaque config. Each adapter parses its own keys.
    * - CEF (Windows): Chromium command-line flags as `Record<flag, value | true>`.
-   * - WKWebView, WebKitGTK: defined per adapter; refer to the adapter's bootstrap docs.
+   * - WebView2 (Windows): `{ userDataFolder?, additionalBrowserArguments?, language? }`.
+   * - WKWebView, WebKitGTK: defined per adapter.
    */
   engineFlags?: Record<string, string | boolean>;
 };
@@ -356,7 +360,8 @@ export function toCString(value: string): CStringPointer {
 }
 
 function applyEnvironment(artifacts: ResolvedNativeArtifacts) {
-  // CEF needs engine dir on PATH (libcef.dll) and ICU_DATA pointing at resources. Null for mac/linux.
+  // CEF needs engine dir on PATH (libcef.dll) and ICU_DATA pointing at resources.
+  // WebView2 needs the directory containing WebView2Loader.dll on PATH.
   const engineBinaryDir = artifacts.cefDir && existsSync(join(artifacts.cefDir, "Release", "libcef.dll"))
     ? join(artifacts.cefDir, "Release")
     : artifacts.cefDir;
@@ -367,10 +372,18 @@ function applyEnvironment(artifacts: ResolvedNativeArtifacts) {
   if (engineResourceDir && !process.env.ICU_DATA) {
     process.env.ICU_DATA = engineResourceDir;
   }
-  if (engineBinaryDir) {
+
+  const pathDirs: string[] = [];
+  if (engineBinaryDir) pathDirs.push(engineBinaryDir);
+  if (artifacts.engine === "webview2" && artifacts.nativeLibPath) {
+    const dir = join(artifacts.nativeLibPath, "..");
+    if (existsSync(join(dir, "WebView2Loader.dll"))) pathDirs.push(dir);
+  }
+  if (pathDirs.length > 0) {
     const pathEntries = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
-    if (!pathEntries.includes(engineBinaryDir)) {
-      process.env.PATH = [engineBinaryDir, ...pathEntries].join(delimiter);
+    const newDirs = pathDirs.filter((d) => !pathEntries.includes(d));
+    if (newDirs.length > 0) {
+      process.env.PATH = [...newDirs, ...pathEntries].join(delimiter);
     }
   }
 }
@@ -575,18 +588,33 @@ export async function initNativeRuntime(
     return state;
   }
 
-  const artifacts = resolveNativeArtifacts();
+  const artifacts = resolveNativeArtifacts(options.engine);
   const hasNativeArtifacts = Boolean(
     artifacts.nativeLibPath && existsSync(artifacts.nativeLibPath)
   );
 
   applyEnvironment(artifacts);
 
+  // Migration nudge: pre-existing CEF deps + unset engine ⇒ default flipped to WebView2.
+  if (
+    process.platform === "win32" &&
+    options.engine === undefined &&
+    resolvePackageRoot("bunite-cef-win-x64") != null
+  ) {
+    log.warn(
+      "[bunite] Detected bunite-cef-win-x64. Windows default engine is now \"webview2\" — " +
+      "this app is currently running on WebView2. " +
+      "To stay on CEF: pass engine: \"cef\" to AppRuntime. " +
+      "To accept the new default: drop bunite-cef-win-x64 from dependencies."
+    );
+  }
+
   if (!hasNativeArtifacts) {
+    const engineSuffix = artifacts.engine === "cef" ? " (engine=cef requires bunite-cef-win-x64)" : "";
     throw new Error(
       "bunite: native runtime not found. Install the platform package " +
-      `(bunite-native-${process.platform === "win32" ? "win" : process.platform === "darwin" ? "mac" : "linux"}-<arch>) ` +
-      "or set BUNITE_CEF_DIR to a CEF runtime directory."
+      `(bunite-native-${process.platform === "win32" ? "win" : process.platform === "darwin" ? "mac" : "linux"}-<arch>)` +
+      engineSuffix + "."
     );
   }
 

package/src/host/paths.ts

@@ -6,6 +6,8 @@ import { CEF_VERSION } from "./cefVersion";
 
 const require = createRequire(import.meta.url);
 
+export type WindowsEngine = "webview2" | "cef";
+
 export type ResolvedNativeArtifacts = {
   packageRoot: string;
   source: "optional-package" | "local-build" | "missing";
@@ -14,8 +16,17 @@ export type ResolvedNativeArtifacts = {
   nativeLibPath: string | null;
   /** CEF framework dir containing libcef.dll. Null on macOS/Linux (system framework). */
   cefDir: string | null;
+  /** Selected Windows engine. Undefined on mac/linux. */
+  engine?: WindowsEngine;
 };
 
+function nativeLibBasename(engine: WindowsEngine | undefined): string {
+  if (PLATFORM_TAG === "win" && engine === "webview2") {
+    return `libBuniteNativeWebView2${NATIVE_LIB_EXT}`;
+  }
+  return `libBuniteNative${NATIVE_LIB_EXT}`;
+}
+
 export function resolvePackageRoot(packageName: string): string | null {
   try {
     const packageJsonPath = require.resolve(`${packageName}/package.json`);
@@ -106,12 +117,14 @@ export function resolveDefaultAppResRoot(): string | null {
   return existsSync(candidate) ? candidate : null;
 }
 
-export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
+export function resolveNativeArtifacts(engine?: WindowsEngine): ResolvedNativeArtifacts {
   const exeDir = getBaseDir();
+  const resolvedEngine: WindowsEngine | undefined =
+    PLATFORM_TAG === "win" ? (engine ?? "webview2") : undefined;
+  const libName = nativeLibBasename(resolvedEngine);
 
-  // 1. Entry-script-dir / executable-relative — covers both `bun dist/main.js`
-  //    and a compiled standalone binary, where artifacts ship alongside the entry.
-  const exeNativeLib = join(exeDir, `libBuniteNative${NATIVE_LIB_EXT}`);
+  // 1. Entry-script-dir / executable-relative.
+  const exeNativeLib = join(exeDir, libName);
   if (existsSync(exeNativeLib)) {
     return {
       packageRoot: exeDir,
@@ -119,21 +132,22 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
       nativePackageName: null,
       enginePackageName: null,
       nativeLibPath: exeNativeLib,
-      cefDir: resolveCefDir([exeDir])
+      cefDir: resolvedEngine === "cef" ? resolveCefDir([exeDir]) : null,
+      engine: resolvedEngine
     };
   }
 
   const packageRoot = resolveBunitePackageRoot();
 
-  // 2. Optional npm packages (bunite-native-*, bunite-cef-* on Windows only)
+  // 2. Optional npm packages.
   const nativePackageName = `bunite-native-${PLATFORM_TAG}-${ARCH}`;
-  const enginePackageName = PLATFORM_TAG === "win" ? `bunite-cef-${PLATFORM_TAG}-${ARCH}` : null;
+  const enginePackageName = PLATFORM_TAG === "win" && resolvedEngine === "cef"
+    ? `bunite-cef-${PLATFORM_TAG}-${ARCH}`
+    : null;
   const nativePackageRoot = resolvePackageRoot(nativePackageName);
   const enginePackageRoot = enginePackageName ? resolvePackageRoot(enginePackageName) : null;
 
-  const packagedNativeLibPath = nativePackageRoot
-    ? join(nativePackageRoot, `libBuniteNative${NATIVE_LIB_EXT}`)
-    : null;
+  const packagedNativeLibPath = nativePackageRoot ? join(nativePackageRoot, libName) : null;
   const packagedEngineDir = enginePackageRoot ?? null;
 
   if (packagedNativeLibPath && existsSync(packagedNativeLibPath)) {
@@ -143,16 +157,19 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
       nativePackageName,
       enginePackageName: packagedEngineDir && existsSync(packagedEngineDir) ? enginePackageName : null,
       nativeLibPath: packagedNativeLibPath,
-      cefDir: (packagedEngineDir && existsSync(packagedEngineDir))
-        ? packagedEngineDir
-        : resolveCefDir([nativePackageRoot, packageRoot].filter(Boolean) as string[])
+      cefDir: resolvedEngine === "cef"
+        ? ((packagedEngineDir && existsSync(packagedEngineDir))
+            ? packagedEngineDir
+            : resolveCefDir([nativePackageRoot, packageRoot].filter(Boolean) as string[]))
+        : null,
+      engine: resolvedEngine
     };
   }
 
-  // 3. Local build (development)
+  // 3. Local build (development).
   if (packageRoot) {
     const localBuildRoot = join(packageRoot, "native-build", `${PLATFORM_TAG}-${ARCH}`);
-    const directLib = join(localBuildRoot, `libBuniteNative${NATIVE_LIB_EXT}`);
+    const directLib = join(localBuildRoot, libName);
 
     if (existsSync(directLib)) {
       return {
@@ -161,12 +178,12 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
         nativePackageName: null,
         enginePackageName: null,
         nativeLibPath: directLib,
-        cefDir: resolveCefDir([localBuildRoot])
+        cefDir: resolvedEngine === "cef" ? resolveCefDir([localBuildRoot]) : null,
+        engine: resolvedEngine
       };
     }
 
-    const releaseLib = join(localBuildRoot, "Release", `libBuniteNative${NATIVE_LIB_EXT}`);
-
+    const releaseLib = join(localBuildRoot, "Release", libName);
     if (existsSync(releaseLib)) {
       return {
         packageRoot,
@@ -174,7 +191,8 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
         nativePackageName: null,
         enginePackageName: null,
         nativeLibPath: releaseLib,
-        cefDir: resolveCefDir([localBuildRoot])
+        cefDir: resolvedEngine === "cef" ? resolveCefDir([localBuildRoot]) : null,
+        engine: resolvedEngine
       };
     }
   }
@@ -185,6 +203,7 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
     nativePackageName: nativePackageRoot ? nativePackageName : null,
     enginePackageName: enginePackageRoot ? enginePackageName : null,
     nativeLibPath: null,
-    cefDir: null
+    cefDir: null,
+    engine: resolvedEngine
   };
 }

package/src/native/shared/log.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #include <atomic>
 
 enum class BuniteLogLevel : int { Debug = 0, Info = 1, Warn = 2, Error = 3, Silent = 4 };
@@ -11,6 +13,18 @@ inline void buniteSetLogLevel(BuniteLogLevel level) {
   g_bunite_log_level.store(level, std::memory_order_relaxed);
 }
 
+/** Read BUNITE_LOG_LEVEL env once and apply it. Call early in bunite_init so
+ *  init-time logs land before the TS side's setNativeLogLevel arrives. */
+inline void buniteApplyEnvLogLevel() {
+  const char* v = std::getenv("BUNITE_LOG_LEVEL");
+  if (!v || !*v) return;
+  if (std::strcmp(v, "debug") == 0) buniteSetLogLevel(BuniteLogLevel::Debug);
+  else if (std::strcmp(v, "info") == 0) buniteSetLogLevel(BuniteLogLevel::Info);
+  else if (std::strcmp(v, "warn") == 0) buniteSetLogLevel(BuniteLogLevel::Warn);
+  else if (std::strcmp(v, "error") == 0) buniteSetLogLevel(BuniteLogLevel::Error);
+  else if (std::strcmp(v, "silent") == 0) buniteSetLogLevel(BuniteLogLevel::Silent);
+}
+
 inline bool buniteShouldLog(BuniteLogLevel level) {
   return static_cast<int>(level) >= static_cast<int>(g_bunite_log_level.load(std::memory_order_relaxed));
 }

package/src/native/win-webview2/bunite_webview2_ffi.cpp

@@ -0,0 +1,294 @@
+#include "webview2_internal.h"
+
+#include <cstring>
+
+using namespace bunite_webview2;
+
+// Forward declaration of helper defined in webview2_runtime.cpp.
+namespace bunite_webview2 {
+void setViewInputPassthrough(ViewHost* v, bool passthrough);
+}
+
+extern "C" {
+
+BUNITE_EXPORT int32_t bunite_abi_version(void) { return 4; }
+
+BUNITE_EXPORT void bunite_set_log_level(int32_t level) {
+  if (level < 0) level = 0;
+  if (level > 4) level = 4;
+  buniteSetLogLevel(static_cast<BuniteLogLevel>(level));
+}
+
+BUNITE_EXPORT bool bunite_init(const char* engine_dir, bool hide_console,
+                                bool popup_blocking, const char* engine_config_json) {
+  return initRuntime(engine_dir, hide_console, popup_blocking, engine_config_json);
+}
+
+BUNITE_EXPORT const char* bunite_engine_name(void) { return "webview2"; }
+
+BUNITE_EXPORT const char* bunite_engine_version(void) {
+  // Cache only on success — env is created lazily on first view, so early
+  // callers (e.g. window-title formatting) would otherwise pin "unknown".
+  static std::string cached;
+  if (!cached.empty()) return cached.c_str();
+  if (!g_runtime.env) return "unknown";
+  LPWSTR ver = nullptr;
+  if (FAILED(g_runtime.env->get_BrowserVersionString(&ver)) || !ver) {
+    if (ver) CoTaskMemFree(ver);
+    return "unknown";
+  }
+  cached = wideToUtf8(ver);
+  CoTaskMemFree(ver);
+  return cached.c_str();
+}
+
+BUNITE_EXPORT void bunite_run_loop(void) {
+  // Cooperative engine — TS drives via bunite_pump_once.
+}
+
+BUNITE_EXPORT void bunite_pump_once(void) { pumpOnce(); }
+
+BUNITE_EXPORT void bunite_quit(void) { shutdownRuntime(); }
+
+BUNITE_EXPORT void bunite_free_cstring(const char* value) {
+  if (value) free(const_cast<char*>(value));
+}
+
+BUNITE_EXPORT void bunite_set_webview_event_handler(BuniteWebviewEventHandler h) {
+  g_runtime.webview_event_handler = h;
+}
+
+BUNITE_EXPORT void bunite_set_window_event_handler(BuniteWindowEventHandler h) {
+  g_runtime.window_event_handler = h;
+}
+
+// ---- windows ----------------------------------------------------------
+
+BUNITE_EXPORT bool bunite_window_create(
+    uint32_t window_id, double x, double y, double w, double h,
+    const char* title, const char* title_bar_style,
+    bool transparent, bool hidden, bool minimized, bool maximized) {
+  return createWindow(window_id, x, y, w, h, title, title_bar_style,
+                      transparent, hidden, minimized, maximized);
+}
+
+BUNITE_EXPORT void bunite_window_destroy(uint32_t window_id) { destroyWindow(window_id); }
+
+BUNITE_EXPORT void bunite_window_reset_close_pending(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w) w->close_pending.store(false);
+}
+
+BUNITE_EXPORT void bunite_window_show(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd) ShowWindow(w->hwnd, SW_SHOW);
+}
+
+BUNITE_EXPORT void bunite_window_close(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd) DestroyWindow(w->hwnd);
+}
+
+BUNITE_EXPORT void bunite_window_set_title(uint32_t window_id, const char* title) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd && title) SetWindowTextW(w->hwnd, utf8ToWide(title).c_str());
+}
+
+BUNITE_EXPORT void bunite_window_minimize(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd) ShowWindow(w->hwnd, SW_MINIMIZE);
+}
+
+BUNITE_EXPORT void bunite_window_unminimize(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd) ShowWindow(w->hwnd, SW_RESTORE);
+}
+
+BUNITE_EXPORT bool bunite_window_is_minimized(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  return w && w->hwnd && IsIconic(w->hwnd);
+}
+
+BUNITE_EXPORT void bunite_window_maximize(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd) ShowWindow(w->hwnd, SW_MAXIMIZE);
+}
+
+BUNITE_EXPORT void bunite_window_unmaximize(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  if (w && w->hwnd) ShowWindow(w->hwnd, SW_RESTORE);
+}
+
+BUNITE_EXPORT bool bunite_window_is_maximized(uint32_t window_id) {
+  WindowHost* w = getWindow(window_id);
+  return w && w->hwnd && IsZoomed(w->hwnd);
+}
+
+BUNITE_EXPORT void bunite_window_set_frame(uint32_t window_id,
+                                            double x, double y, double w, double h) {
+  WindowHost* win = getWindow(window_id);
+  if (win && win->hwnd) {
+    SetWindowPos(win->hwnd, nullptr,
+                 static_cast<int>(x), static_cast<int>(y),
+                 static_cast<int>(w), static_cast<int>(h),
+                 SWP_NOZORDER | SWP_NOACTIVATE);
+  }
+}
+
+// ---- views ------------------------------------------------------------
+
+BUNITE_EXPORT bool bunite_view_create(
+    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,
+    double x, double y, double w, double h,
+    bool auto_resize, bool sandbox, const char* preload_origins_json) {
+  return createView(view_id, window_id, url, html, preload, appres_root,
+                    navigation_rules_json, x, y, w, h,
+                    auto_resize, sandbox, preload_origins_json);
+}
+
+BUNITE_EXPORT void bunite_view_execute_javascript(uint32_t view_id, const char* script) {
+  ViewHost* v = getView(view_id);
+  if (!v || !v->webview || !script) return;
+  v->webview->ExecuteScript(utf8ToWide(script).c_str(), nullptr);
+}
+
+BUNITE_EXPORT void bunite_view_load_url(uint32_t view_id, const char* url) {
+  ViewHost* v = getView(view_id);
+  if (!v || !url) return;
+  if (v->webview) v->webview->Navigate(utf8ToWide(url).c_str());
+  else v->url = url;
+}
+
+BUNITE_EXPORT void bunite_view_load_html(uint32_t view_id, const char* html) {
+  ViewHost* v = getView(view_id);
+  if (!v || !html) return;
+  if (v->webview) v->webview->NavigateToString(utf8ToWide(html).c_str());
+  else v->html = html;
+}
+
+BUNITE_EXPORT void bunite_register_appres_route(const char* path) {
+  registerAppResRoute(path);
+}
+
+BUNITE_EXPORT void bunite_unregister_appres_route(const char* path) {
+  unregisterAppResRoute(path);
+}
+
+BUNITE_EXPORT void bunite_complete_route_request(uint32_t request_id, const char* html) {
+  completeRouteRequest(request_id, html);
+}
+
+BUNITE_EXPORT void bunite_view_set_visible(uint32_t view_id, bool visible) {
+  ViewHost* v = getView(view_id);
+  if (!v) return;
+  v->pending_visible = visible;
+  if (v->container_hwnd) ShowWindow(v->container_hwnd, visible ? SW_SHOW : SW_HIDE);
+  if (v->controller) v->controller->put_IsVisible(visible);
+}
+
+BUNITE_EXPORT void bunite_view_set_input_passthrough(uint32_t view_id, bool passthrough) {
+  ViewHost* v = getView(view_id);
+  if (v) setViewInputPassthrough(v, passthrough);
+}
+
+BUNITE_EXPORT void bunite_view_set_mask_region(uint32_t /*view_id*/,
+                                                const double* /*rects*/, uint32_t /*count*/) {
+  static bool warned = false;
+  if (!warned) {
+    BUNITE_WARN("webview2: set_mask_region ignored — WebView2 D3D surface cannot be masked. "
+                "Use engine \"cef\" + bunite-cef-win-x64 if mask region is required.");
+    warned = true;
+  }
+}
+
+BUNITE_EXPORT void bunite_view_bring_to_front(uint32_t view_id) {
+  ViewHost* v = getView(view_id);
+  if (!v || !v->container_hwnd) return;
+  // Raise our own container HWND. WebView2's internal HWND tree under the
+  // container moves with it; we never touch the Edge-owned HWNDs directly.
+  SetWindowPos(v->container_hwnd, HWND_TOP, 0, 0, 0, 0,
+               SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+}
+
+static void applyBounds(ViewHost* v, double x, double y, double w, double h) {
+  v->bounds = { static_cast<LONG>(x), static_cast<LONG>(y),
+                static_cast<LONG>(x + w), static_cast<LONG>(y + h) };
+  if (v->container_hwnd) {
+    SetWindowPos(v->container_hwnd, nullptr,
+                 v->bounds.left, v->bounds.top,
+                 v->bounds.right - v->bounds.left,
+                 v->bounds.bottom - v->bounds.top,
+                 SWP_NOZORDER | SWP_NOACTIVATE);
+  }
+  if (v->controller) {
+    RECT inner{ 0, 0,
+                v->bounds.right - v->bounds.left,
+                v->bounds.bottom - v->bounds.top };
+    v->controller->put_Bounds(inner);
+  }
+}
+
+BUNITE_EXPORT void bunite_view_set_bounds(uint32_t view_id,
+                                           double x, double y, double w, double h) {
+  ViewHost* v = getView(view_id);
+  if (v) applyBounds(v, x, y, w, h);
+}
+
+BUNITE_EXPORT void bunite_view_set_bounds_async(uint32_t view_id,
+                                                 double x, double y, double w, double h) {
+  postUiTask([view_id, x, y, w, h]() {
+    ViewHost* v = getView(view_id);
+    if (v) applyBounds(v, x, y, w, h);
+  });
+}
+
+BUNITE_EXPORT void bunite_view_set_anchor(uint32_t view_id, int mode, double /*inset*/) {
+  ViewHost* v = getView(view_id);
+  if (!v) return;
+  v->auto_resize = (mode == 1);   // ViewAnchorMode::Fill
+}
+
+BUNITE_EXPORT void bunite_view_go_back(uint32_t view_id) {
+  ViewHost* v = getView(view_id);
+  if (v && v->webview) v->webview->GoBack();
+}
+
+BUNITE_EXPORT void bunite_view_reload(uint32_t view_id) {
+  ViewHost* v = getView(view_id);
+  if (v && v->webview) v->webview->Reload();
+}
+
+BUNITE_EXPORT void bunite_view_remove(uint32_t view_id) { destroyView(view_id); }
+
+BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id) {
+  ViewHost* v = getView(view_id);
+  if (v && v->webview) v->webview->OpenDevToolsWindow();
+}
+
+BUNITE_EXPORT void bunite_view_close_devtools(uint32_t /*view_id*/) {
+  // WebView2 doesn't expose a "close devtools" API; the user closes the panel.
+}
+
+BUNITE_EXPORT void bunite_view_toggle_devtools(uint32_t view_id) {
+  bunite_view_open_devtools(view_id);
+}
+
+// ---- permissions ------------------------------------------------------
+
+BUNITE_EXPORT void bunite_complete_permission_request(uint32_t request_id, uint32_t state) {
+  PendingPermissionRequest p;
+  {
+    std::lock_guard<std::mutex> g(g_runtime.permission_mutex);
+    auto it = g_runtime.pending_permissions.find(request_id);
+    if (it == g_runtime.pending_permissions.end()) return;
+    p = std::move(it->second);
+    g_runtime.pending_permissions.erase(it);
+  }
+  if (p.args) p.args->put_State(buniteStateToWebView2(state));
+  if (p.deferral) p.deferral->Complete();
+}
+
+}  // extern "C"