bunite-core 0.12.0 → 0.14.0

package/src/host/core/SurfaceManager.ts

@@ -1,10 +1,13 @@
 import { BrowserView } from "./BrowserView";
 import {
   trackSurface, untrackSurface, getOwnedSurface,
-  getHostSurfaceIds, getSurfaceRecord,
+  getHostSurfaceIds, getSurfaceRecord, onSurfaceDispose,
   MAX_SURFACES_PER_HOST
 } from "./SurfaceRegistry";
-import { SurfaceCap, type ImplOf, IpcError } from "../../rpc/index";
+import {
+  SurfaceCap, type ImplOf, IpcError,
+  type SurfaceEvent, type DialogEvent, type ConsoleEntry,
+} from "../../rpc/index";
 import { Stream } from "../../rpc/stream";
 
 function applyHostOffset(hostView: BrowserView, x: number, y: number) {
@@ -18,22 +21,131 @@ export function onSurfaceInit(cb: SurfaceInitCallback) {
   initCallbacks.push(cb);
 }
 
-type DidNavigateEmit = (event: { surfaceId: number; url: string }) => void;
-const didNavigateSubs = new Map<number, Set<DidNavigateEmit>>();
+type SurfaceEventEmit = (event: { surfaceId: number; event: SurfaceEvent }) => void;
+const surfaceEventSubs = new Map<number, Set<SurfaceEventEmit>>();
 
-export function emitDidNavigate(hostViewId: number, surfaceId: number, url: string) {
-  const subs = didNavigateSubs.get(hostViewId);
+export function emitSurfaceEvent(hostViewId: number, surfaceId: number, event: SurfaceEvent) {
+  const subs = surfaceEventSubs.get(hostViewId);
   if (!subs) return;
-  for (const emit of subs) emit({ surfaceId, url });
+  for (const emit of subs) emit({ surfaceId, event });
+}
+
+type DialogEmit = (event: { surfaceId: number; event: DialogEvent }) => void;
+const dialogSubs = new Map<number, Set<DialogEmit>>();
+
+type ConsoleEmit = (event: { surfaceId: number; entry: ConsoleEntry }) => void;
+const consoleSubs = new Map<number, Set<ConsoleEmit>>();
+
+const CONSOLE_BUFFER_LIMIT = 200;
+const DEFAULT_DIALOG_TIMEOUT_MS = 5000;
+
+type PendingDialog = {
+  requestId: number;
+  originalKind: "alert" | "confirm" | "prompt" | "beforeunload";
+  message: string;
+  timer: ReturnType<typeof setTimeout> | null;
+};
+
+type SurfaceState = {
+  consoleBuffer: ConsoleEntry[];
+  dialogTimeoutMs: number | null;  // null = no auto-dismiss
+  pendingDialogs: Map<number, PendingDialog>;
+};
+
+const surfaceState = new Map<number, SurfaceState>();
+
+function getOrCreateState(surfaceId: number): SurfaceState {
+  let s = surfaceState.get(surfaceId);
+  if (!s) {
+    s = {
+      consoleBuffer: [],
+      dialogTimeoutMs: DEFAULT_DIALOG_TIMEOUT_MS,
+      pendingDialogs: new Map(),
+    };
+    surfaceState.set(surfaceId, s);
+  }
+  return s;
 }
 
-type TitleChangedEmit = (event: { surfaceId: number; title: string }) => void;
-const titleChangedSubs = new Map<number, Set<TitleChangedEmit>>();
+export function disposeSurfaceState(surfaceId: number) {
+  const s = surfaceState.get(surfaceId);
+  if (!s) return;
+  for (const p of s.pendingDialogs.values()) {
+    if (p.timer) clearTimeout(p.timer);
+  }
+  surfaceState.delete(surfaceId);
+}
+
+// Wire dispose to any untrack path (remove + removeSurfacesForHostView).
+onSurfaceDispose(disposeSurfaceState);
+
+export function clearConsoleBuffer(surfaceId: number) {
+  const s = surfaceState.get(surfaceId);
+  if (s) s.consoleBuffer.length = 0;
+}
 
-export function emitTitleChanged(hostViewId: number, surfaceId: number, title: string) {
-  const subs = titleChangedSubs.get(hostViewId);
+export function emitDialog(hostViewId: number, surfaceId: number, event: DialogEvent) {
+  const subs = dialogSubs.get(hostViewId);
   if (!subs) return;
-  for (const emit of subs) emit({ surfaceId, title });
+  for (const emit of subs) emit({ surfaceId, event });
+}
+
+export function emitConsole(hostViewId: number, surfaceId: number, entry: ConsoleEntry) {
+  const state = getOrCreateState(surfaceId);
+  state.consoleBuffer.push(entry);
+  if (state.consoleBuffer.length > CONSOLE_BUFFER_LIMIT) {
+    state.consoleBuffer.splice(0, state.consoleBuffer.length - CONSOLE_BUFFER_LIMIT);
+  }
+  const subs = consoleSubs.get(hostViewId);
+  if (!subs) return;
+  for (const emit of subs) emit({ surfaceId, entry });
+}
+
+/** Called by SurfaceBrowserIPC on native `dialog` event. Stashes pending entry
+ *  + arms the auto-dismiss timer, then broadcasts to subscribers. */
+export function registerDialogRequest(
+  hostViewId: number,
+  surfaceId: number,
+  request: { requestId: number; kind: "alert" | "confirm" | "prompt" | "beforeunload"; message: string; defaultPrompt?: string }
+) {
+  const state = getOrCreateState(surfaceId);
+  const view = getSurfaceRecord(surfaceId)?.view;
+
+  const entry: PendingDialog = {
+    requestId: request.requestId,
+    originalKind: request.kind,
+    message: request.message,
+    timer: null,
+  };
+  if (state.dialogTimeoutMs !== null && view) {
+    entry.timer = setTimeout(() => {
+      if (!state.pendingDialogs.delete(request.requestId)) return;
+      view.respondToDialog(request.requestId, false);
+      emitDialog(hostViewId, surfaceId, {
+        kind: "auto-dismissed",
+        originalKind: entry.originalKind,
+        message: entry.message,
+      });
+    }, state.dialogTimeoutMs);
+  }
+  state.pendingDialogs.set(request.requestId, entry);
+
+  emitDialog(hostViewId, surfaceId, {
+    kind: request.kind,
+    requestId: request.requestId,
+    message: request.message,
+    defaultPrompt: request.defaultPrompt,
+  });
+}
+
+function consumePendingDialog(surfaceId: number, requestId: number): boolean {
+  const state = surfaceState.get(surfaceId);
+  if (!state) return false;
+  const entry = state.pendingDialogs.get(requestId);
+  if (!entry) return false;
+  if (entry.timer) clearTimeout(entry.timer);
+  state.pendingDialogs.delete(requestId);
+  return true;
 }
 
 export function createSurfaceCapImpl(hostViewId: number): ImplOf<typeof SurfaceCap> {
@@ -87,6 +199,7 @@ export function createSurfaceCapImpl(hostViewId: number): ImplOf<typeof SurfaceC
       const record = ownedSurface(surfaceId);
       if (!record) return;
       untrackSurface(surfaceId);
+      disposeSurfaceState(surfaceId);
       record.view.remove();
     },
 
@@ -151,45 +264,164 @@ export function createSurfaceCapImpl(hostViewId: number): ImplOf<typeof SurfaceC
       return record.view.evaluate(script);
     },
 
+    click: ({ surfaceId, ...args }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      record.view.click(args);
+    },
+
+    type: ({ surfaceId, text }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      record.view.type(text);
+    },
+
+    press: ({ surfaceId, key, modifiers, action }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      record.view.press(key, modifiers, action);
+    },
+
+    scroll: ({ surfaceId, ...args }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      record.view.scroll(args);
+    },
+
+    mouse: ({ surfaceId, ...args }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      record.view.mouse(args);
+    },
+
+    screenshot: async ({ surfaceId, format = "png", quality = 90 }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return { ok: false as const, code: "not_supported" as const, message: "surface not found" };
+      return record.view.screenshot(format, quality);
+    },
+
+    waitForSelector: async ({ surfaceId, selector, timeoutMs = 5000 }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return { ok: false as const, code: "runtime_error" as const, message: "surface not found" };
+      const deadline = Date.now() + timeoutMs;
+      const expr = `!!document.querySelector(${JSON.stringify(selector)})`;
+      while (Date.now() < deadline) {
+        const res = await record.view.evaluate(expr);
+        if (res.ok && res.value === true) return { ok: true as const };
+        if (!res.ok && res.code !== "timeout") {
+          // Propagate cross_origin distinct from runtime_error — consumer
+          // may want to retry with a same-origin sub-surface vs. fix the script.
+          const code = res.code === "cross_origin" ? "cross_origin" as const : "runtime_error" as const;
+          return { ok: false as const, code, message: res.message };
+        }
+        await new Promise((r) => setTimeout(r, 50));
+      }
+      return { ok: false as const, code: "timeout" as const, message: `selector ${JSON.stringify(selector)} not found within ${timeoutMs}ms` };
+    },
+
+    waitForFunction: async ({ surfaceId, expression, timeoutMs = 5000, pollIntervalMs = 50 }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return { ok: false as const, code: "runtime_error" as const, message: "surface not found" };
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const res = await record.view.evaluate(expression);
+        if (res.ok && res.value) return { ok: true as const };
+        if (!res.ok && res.code !== "timeout") {
+          const code = res.code === "cross_origin" ? "cross_origin" as const : "runtime_error" as const;
+          return { ok: false as const, code, message: res.message };
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+      }
+      return { ok: false as const, code: "timeout" as const, message: `function did not satisfy within ${timeoutMs}ms` };
+    },
+
+    respondToDialog: ({ surfaceId, requestId, accept, text }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      if (!consumePendingDialog(surfaceId, requestId)) return;  // stale or already auto-dismissed
+      record.view.respondToDialog(requestId, accept, text);
+    },
+
+    setDialogTimeout: ({ surfaceId, ms }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      const state = getOrCreateState(surfaceId);
+      state.dialogTimeoutMs = ms;
+    },
+
+    getConsoleBuffer: ({ surfaceId, clear }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return [];
+      const state = getOrCreateState(surfaceId);
+      const snapshot = state.consoleBuffer.slice();
+      if (clear) state.consoleBuffer.length = 0;
+      return snapshot;
+    },
+
     capabilities: ({ surfaceId }) => {
       const record = ownedSurface(surfaceId);
       if (!record) {
         return {
-          evaluate: false, crossOriginEval: false, titleChanged: false,
+          evaluate: false, crossOriginEval: false, surfaceEvents: false,
           nativeInputTrusted: false, click: false, type: false, press: false,
-          scroll: false, screenshot: false,
+          scroll: false, mouse: false, dialogs: false, console: false,
+          screenshot: false,
         };
       }
       return record.view.capabilities();
     },
 
-    didNavigate: () => Stream.from<{ surfaceId: number; url: string }>((emit, signal) => {
-      let subs = didNavigateSubs.get(hostViewId);
+    surfaceEvents: ({ surfaceId: filterId }) => Stream.from<SurfaceEvent>((emit, signal) => {
+      let subs = surfaceEventSubs.get(hostViewId);
+      if (!subs) {
+        subs = new Set();
+        surfaceEventSubs.set(hostViewId, subs);
+      }
+      const wrapped: SurfaceEventEmit = ({ surfaceId, event }) => {
+        if (surfaceId === filterId) emit(event);
+      };
+      subs.add(wrapped);
+      signal.addEventListener("abort", () => {
+        const set = surfaceEventSubs.get(hostViewId);
+        if (!set) return;
+        set.delete(wrapped);
+        if (set.size === 0) surfaceEventSubs.delete(hostViewId);
+      });
+    }),
+
+    dialogs: ({ surfaceId: filterId }) => Stream.from<DialogEvent>((emit, signal) => {
+      let subs = dialogSubs.get(hostViewId);
       if (!subs) {
         subs = new Set();
-        didNavigateSubs.set(hostViewId, subs);
+        dialogSubs.set(hostViewId, subs);
       }
-      subs.add(emit);
+      const wrapped: DialogEmit = ({ surfaceId, event }) => {
+        if (surfaceId === filterId) emit(event);
+      };
+      subs.add(wrapped);
       signal.addEventListener("abort", () => {
-        const set = didNavigateSubs.get(hostViewId);
+        const set = dialogSubs.get(hostViewId);
         if (!set) return;
-        set.delete(emit);
-        if (set.size === 0) didNavigateSubs.delete(hostViewId);
+        set.delete(wrapped);
+        if (set.size === 0) dialogSubs.delete(hostViewId);
       });
     }),
 
-    titleChanged: () => Stream.from<{ surfaceId: number; title: string }>((emit, signal) => {
-      let subs = titleChangedSubs.get(hostViewId);
+    consoleEvents: ({ surfaceId: filterId }) => Stream.from<ConsoleEntry>((emit, signal) => {
+      let subs = consoleSubs.get(hostViewId);
       if (!subs) {
         subs = new Set();
-        titleChangedSubs.set(hostViewId, subs);
+        consoleSubs.set(hostViewId, subs);
       }
-      subs.add(emit);
+      const wrapped: ConsoleEmit = ({ surfaceId, entry }) => {
+        if (surfaceId === filterId) emit(entry);
+      };
+      subs.add(wrapped);
       signal.addEventListener("abort", () => {
-        const set = titleChangedSubs.get(hostViewId);
+        const set = consoleSubs.get(hostViewId);
         if (!set) return;
-        set.delete(emit);
-        if (set.size === 0) titleChangedSubs.delete(hostViewId);
+        set.delete(wrapped);
+        if (set.size === 0) consoleSubs.delete(hostViewId);
       });
     }),
   };

package/src/host/core/SurfaceRegistry.ts

@@ -21,6 +21,13 @@ export function trackSurface(surfaceId: number, record: SurfaceRecord) {
   ids.add(surfaceId);
 }
 
+type DisposeHook = (surfaceId: number) => void;
+const disposeHooks: DisposeHook[] = [];
+
+export function onSurfaceDispose(cb: DisposeHook) {
+  disposeHooks.push(cb);
+}
+
 export function untrackSurface(surfaceId: number) {
   const record = surfaces.get(surfaceId);
   if (!record) return;
@@ -30,6 +37,7 @@ export function untrackSurface(surfaceId: number) {
     ids.delete(surfaceId);
     if (ids.size === 0) hostSurfaceIds.delete(record.hostViewId);
   }
+  for (const cb of disposeHooks) cb(surfaceId);
 }
 
 export function getOwnedSurface(surfaceId: number, ctx: { viewId: number }): SurfaceRecord | null {
@@ -54,7 +62,7 @@ export function removeSurfacesForHostView(hostViewId: number) {
   for (const surfaceId of Array.from(ids)) {
     const record = surfaces.get(surfaceId);
     if (!record) continue;
-    untrackSurface(surfaceId);
+    untrackSurface(surfaceId);  // fires disposeHooks
     record.view.remove();
   }
 }

package/src/host/core/inputDispatch.ts

@@ -0,0 +1,147 @@
+// Input dispatch helpers — modifier encoding + DOM `key` → Win32 VK + macOS
+// Quartz key code + DOM `code` + char. Backends translate the FFI bitmask
+// (Alt=1, Ctrl=2, Meta=4, Shift=8) to native form. Stage B keymap covers
+// ASCII + the named keys Playwright-style automation relies on.
+
+import type { Modifier } from "../../rpc/framework";
+
+export function encodeModifiers(mods: Modifier[] | undefined): number {
+  if (!mods) return 0;
+  let bits = 0;
+  for (const m of mods) {
+    if (m === "alt") bits |= 1;
+    else if (m === "ctrl") bits |= 2;
+    else if (m === "meta") bits |= 4;
+    else if (m === "shift") bits |= 8;
+  }
+  return bits;
+}
+
+export interface ResolvedKey {
+  windowsVkCode: number;
+  macKeyCode: number;
+  /** DOM `KeyboardEvent.key` — pass-through; native dispatchers forward to engines. */
+  key: string;
+  /** DOM `KeyboardEvent.code` — derived from US keyboard mapping. */
+  code: string;
+  /** Text payload for the CHAR / insertText event; empty = skip char. */
+  character: string;
+  /** Win scancode 0xE0 prefix: nav cluster (Arrow/Insert/Delete/Home/End/
+   *  PageUp/PageDown/Meta/ContextMenu) AND Numpad-Enter. Distinct from
+   *  `location` — most extended keys are NOT numpad (location 0). */
+  extended: boolean;
+  /** DOM `KeyboardEvent.location`: 0=standard, 1=left mod, 2=right mod,
+   *  3=numpad. WV2 CDP uses this; CEF derives from scancode 0xE0 prefix. */
+  location: 0 | 1 | 2 | 3;
+}
+
+/** Maps a DOM `KeyboardEvent.key` value to backend-neutral identifiers. */
+export function resolveKey(domKey: string): ResolvedKey {
+  if (domKey.length === 0) {
+    return { windowsVkCode: 0, macKeyCode: 0, key: "", code: "", character: "", extended: false, location: 0 };
+  }
+
+  // Named key (Enter, Tab, ArrowLeft …).
+  const named = NAMED_KEYS[domKey];
+  if (named) {
+    return {
+      windowsVkCode: named.win,
+      macKeyCode: named.mac,
+      key: domKey,
+      code: named.code,
+      // Space/Tab/Enter generate text in CDP automatically; we pass an explicit
+      // character so DOM `keypress` fires consistently across engines.
+      character: named.character ?? "",
+      extended: named.ext === true,
+      location: named.loc ?? 0,
+    };
+  }
+
+  // Single Unicode codepoint — letter / digit / printable / extended.
+  if ([...domKey].length === 1) {
+    const cp = domKey.codePointAt(0)!;
+    // ASCII A-Z / a-z → matching Win VK + mac keyCode + DOM code "KeyX".
+    if ((cp >= 0x41 && cp <= 0x5A) || (cp >= 0x61 && cp <= 0x7A)) {
+      const upper = cp & ~0x20;  // strip lowercase bit
+      return {
+        windowsVkCode: upper,
+        macKeyCode: MAC_KEY_LETTER[upper - 0x41],
+        key: domKey,
+        code: `Key${String.fromCharCode(upper)}`,
+        character: domKey,
+        extended: false,
+        location: 0,
+      };
+    }
+    // ASCII 0-9.
+    if (cp >= 0x30 && cp <= 0x39) {
+      return {
+        windowsVkCode: cp,
+        macKeyCode: MAC_KEY_DIGIT[cp - 0x30],
+        key: domKey,
+        code: `Digit${domKey}`,
+        character: domKey,
+        extended: false,
+        location: 0,
+      };
+    }
+    // Other printable codepoint — char event only, no virtual key.
+    return { windowsVkCode: 0, macKeyCode: 0, key: domKey, code: "", character: domKey, extended: false, location: 0 };
+  }
+
+  // Multi-codepoint string we don't recognise as a named key — pass-through.
+  return { windowsVkCode: 0, macKeyCode: 0, key: domKey, code: "", character: "", extended: false, location: 0 };
+}
+
+// Win32 VK_* + Quartz Event Services kVK_* + DOM code + literal character +
+// LPARAM extended-key flag. `ext: true` for nav-cluster keys (separate from
+// numpad equivalents) and Numpad-Enter — Chromium derives `KeyboardEvent.code`
+// from LPARAM scancode + extended bit. Sources:
+//   learn.microsoft.com/windows/win32/inputdev/virtual-key-codes
+//   chromium/ui/events/keycodes/dom/keycode_converter_data.inc
+type NamedKey = { win: number; mac: number; code: string; character?: string; ext?: true; loc?: 1 | 2 | 3 };
+const NAMED_KEYS: Record<string, NamedKey> = {
+  Backspace:    { win: 0x08, mac: 0x33, code: "Backspace" },
+  Tab:          { win: 0x09, mac: 0x30, code: "Tab", character: "\t" },
+  Enter:        { win: 0x0D, mac: 0x24, code: "Enter", character: "\r" },
+  NumpadEnter:  { win: 0x0D, mac: 0x4C, code: "NumpadEnter", character: "\r", ext: true, loc: 3 },
+  Escape:       { win: 0x1B, mac: 0x35, code: "Escape" },
+  " ":          { win: 0x20, mac: 0x31, code: "Space", character: " " },
+  Space:        { win: 0x20, mac: 0x31, code: "Space", character: " " },
+  PageUp:       { win: 0x21, mac: 0x74, code: "PageUp", ext: true },
+  PageDown:     { win: 0x22, mac: 0x79, code: "PageDown", ext: true },
+  End:          { win: 0x23, mac: 0x77, code: "End", ext: true },
+  Home:         { win: 0x24, mac: 0x73, code: "Home", ext: true },
+  ArrowLeft:    { win: 0x25, mac: 0x7B, code: "ArrowLeft", ext: true },
+  ArrowUp:      { win: 0x26, mac: 0x7E, code: "ArrowUp", ext: true },
+  ArrowRight:   { win: 0x27, mac: 0x7C, code: "ArrowRight", ext: true },
+  ArrowDown:    { win: 0x28, mac: 0x7D, code: "ArrowDown", ext: true },
+  Insert:       { win: 0x2D, mac: 0x72, code: "Insert", ext: true },
+  Delete:       { win: 0x2E, mac: 0x75, code: "Delete", ext: true },
+  Meta:         { win: 0x5B, mac: 0x37, code: "MetaLeft", ext: true },
+  ContextMenu:  { win: 0x5D, mac: 0x6E, code: "ContextMenu", ext: true },
+  F1:  { win: 0x70, mac: 0x7A, code: "F1" },
+  F2:  { win: 0x71, mac: 0x78, code: "F2" },
+  F3:  { win: 0x72, mac: 0x63, code: "F3" },
+  F4:  { win: 0x73, mac: 0x76, code: "F4" },
+  F5:  { win: 0x74, mac: 0x60, code: "F5" },
+  F6:  { win: 0x75, mac: 0x61, code: "F6" },
+  F7:  { win: 0x76, mac: 0x62, code: "F7" },
+  F8:  { win: 0x77, mac: 0x64, code: "F8" },
+  F9:  { win: 0x78, mac: 0x65, code: "F9" },
+  F10: { win: 0x79, mac: 0x6D, code: "F10" },
+  F11: { win: 0x7A, mac: 0x67, code: "F11" },
+  F12: { win: 0x7B, mac: 0x6F, code: "F12" },
+};
+
+// US keyboard layout — Quartz hardware key code per ASCII letter (A → 0x00, …, Z → 0x06).
+const MAC_KEY_LETTER = [
+  // A    B    C    D    E    F    G    H    I    J    K    L    M
+  0x00, 0x0B, 0x08, 0x02, 0x0E, 0x03, 0x05, 0x04, 0x22, 0x26, 0x28, 0x25, 0x2E,
+  // N    O    P    Q    R    S    T    U    V    W    X    Y    Z
+  0x2D, 0x1F, 0x23, 0x0C, 0x0F, 0x01, 0x11, 0x20, 0x09, 0x0D, 0x07, 0x10, 0x06,
+];
+// US keyboard layout — Quartz hardware key code per digit (0 → 0x1D, 1 → 0x12 …).
+const MAC_KEY_DIGIT = [
+  0x1D, 0x12, 0x13, 0x14, 0x15, 0x17, 0x16, 0x1A, 0x1C, 0x19,
+];

package/src/host/events/webviewEvents.ts

@@ -8,5 +8,12 @@ export default {
     new BuniteEvent("new-window-open", data),
   permissionRequested: (data: { requestId: number; kind: number; url?: string }) =>
     new BuniteEvent("permission-requested", data),
-  titleChanged: (data: { detail: string }) => new BuniteEvent("title-changed", data)
+  titleChanged: (data: { detail: string }) => new BuniteEvent("title-changed", data),
+  loadStart: (data: { detail: string }) => new BuniteEvent("load-start", data),
+  loadFinish: (data: { detail: string }) => new BuniteEvent("load-finish", data),
+  loadFail: (data: { url: string; reason?: string }) => new BuniteEvent("load-fail", data),
+  dialog: (data: { requestId: number; kind: "alert" | "confirm" | "prompt" | "beforeunload"; message: string; defaultPrompt?: string }) =>
+    new BuniteEvent("dialog", data),
+  consoleMessage: (data: { level: "log" | "warn" | "error" | "info" | "debug"; args: string[]; ts: number }) =>
+    new BuniteEvent("console-message", data)
 };