electrobun 0.8.0-beta.0 → 0.9.3-beta.0

package/dist/api/browser/rpc/webview.ts

@@ -74,6 +74,10 @@ export type InternalWebviewHandlers = RPCSchema<{
         id: number;
         hidden: boolean;
       };
+      webviewTagSetNavigationRules: {
+        id: number;
+        rules: string[];
+      };
     };
   }>;
   

package/dist/api/browser/webviewtag.ts

@@ -559,7 +559,19 @@ const ConfigureWebviewTags = (
         id: this.webviewId,
         hidden: this.hidden|| Boolean(hidden),
       });
-    }   
+    }
+
+    setNavigationRules(rules: string[]) {
+      if (!this.webviewId) {
+        console.warn('setNavigationRules called on removed webview');
+        return;
+      }
+
+      this.internalRpc.send.webviewTagSetNavigationRules({
+        id: this.webviewId,
+        rules: rules,
+      });
+    }
   }
 
   customElements.define("electrobun-webview", WebviewTag);

package/dist/api/bun/ElectrobunConfig.ts

@@ -12,17 +12,35 @@ export interface ElectrobunConfig {
      * The display name of your application
      */
     name: string;
-    
+
     /**
      * Unique identifier for your application (e.g., "com.example.myapp")
      * Used for platform-specific identifiers
      */
     identifier: string;
-    
+
     /**
      * Application version string (e.g., "1.0.0")
      */
     version: string;
+
+    /**
+     * Custom URL schemes to register for deep linking (e.g., ["myapp", "myapp-dev"])
+     * This allows your app to be opened via URLs like myapp://some/path
+     *
+     * Platform support:
+     * - macOS: Fully supported. App must be in /Applications folder for registration to work.
+     * - Windows: Not yet supported
+     * - Linux: Not yet supported
+     *
+     * To handle incoming URLs, listen for the "open-url" event:
+     * ```typescript
+     * Electrobun.events.on("open-url", (e) => {
+     *   console.log("Opened with URL:", e.data.url);
+     * });
+     * ```
+     */
+    urlSchemes?: string[];
   };
 
   /**

package/dist/api/bun/core/BrowserView.ts

@@ -215,7 +215,7 @@ export class BrowserView<T> {
   loadHTML(html: string) {
     this.html = html;
     console.log(`DEBUG: Setting HTML content for webview ${this.id}:`, html.substring(0, 50) + '...');
-    
+
     if (this.renderer === 'cef') {
       // For CEF, store HTML content in native map and use scheme handler
       native.symbols.setWebviewHTMLContent(this.id, toCString(html));
@@ -226,6 +226,21 @@ export class BrowserView<T> {
     }
   }
 
+  setNavigationRules(rules: string[]) {
+    this.navigationRules = JSON.stringify(rules);
+    const rulesJson = JSON.stringify(rules);
+    native.symbols.setWebviewNavigationRules(this.ptr, toCString(rulesJson));
+  }
+
+  findInPage(searchText: string, options?: {forward?: boolean; matchCase?: boolean}) {
+    const forward = options?.forward ?? true;
+    const matchCase = options?.matchCase ?? false;
+    native.symbols.webviewFindInPage(this.ptr, toCString(searchText), forward, matchCase);
+  }
+
+  stopFindInPage() {
+    native.symbols.webviewStopFind(this.ptr);
+  }
 
   // todo (yoav): move this to a class that also has off, append, prepend, etc.
   // name should only allow browserView events

package/dist/api/bun/core/BrowserWindow.ts

@@ -6,8 +6,6 @@ import {FFIType} from 'bun:ffi'
 
 let nextWindowId = 1;
 
-// todo (yoav): if we default to builtInSchema, we don't want dev to have to define custom handlers
-// for the built-in schema stuff.
 type WindowOptionsType<T = undefined> = {
   title: string;
   frame: {
@@ -45,9 +43,6 @@ const defaultOptions: WindowOptionsType = {
 
 export const BrowserWindowMap = {};
 
-// todo (yoav): do something where the type extends the default schema
-// that way we can provide built-in requests/messages and devs can extend it
-
 export class BrowserWindow<T> {
   id: number = nextWindowId++;
   ptr: FFIType.ptr;
@@ -185,6 +180,46 @@ export class BrowserWindow<T> {
     return ffi.request.focusWindow({ winId: this.id });
   }
 
+  minimize() {
+    return ffi.request.minimizeWindow({ winId: this.id });
+  }
+
+  unminimize() {
+    return ffi.request.unminimizeWindow({ winId: this.id });
+  }
+
+  isMinimized(): boolean {
+    return ffi.request.isWindowMinimized({ winId: this.id });
+  }
+
+  maximize() {
+    return ffi.request.maximizeWindow({ winId: this.id });
+  }
+
+  unmaximize() {
+    return ffi.request.unmaximizeWindow({ winId: this.id });
+  }
+
+  isMaximized(): boolean {
+    return ffi.request.isWindowMaximized({ winId: this.id });
+  }
+
+  setFullScreen(fullScreen: boolean) {
+    return ffi.request.setWindowFullScreen({ winId: this.id, fullScreen });
+  }
+
+  isFullScreen(): boolean {
+    return ffi.request.isWindowFullScreen({ winId: this.id });
+  }
+
+  setAlwaysOnTop(alwaysOnTop: boolean) {
+    return ffi.request.setWindowAlwaysOnTop({ winId: this.id, alwaysOnTop });
+  }
+
+  isAlwaysOnTop(): boolean {
+    return ffi.request.isWindowAlwaysOnTop({ winId: this.id });
+  }
+
   // todo (yoav): move this to a class that also has off, append, prepend, etc.
   // name should only allow browserWindow events
   on(name, handler) {

package/dist/api/bun/core/Utils.ts

@@ -9,6 +9,104 @@ export const showItemInFolder = (path: string) => {
   return ffi.request.showItemInFolder({ path });
 };
 
+/**
+ * Open a URL in the default browser or appropriate application.
+ * Works with http/https URLs, mailto: links, custom URL schemes, etc.
+ *
+ * @param url - The URL to open (e.g., "https://example.com", "mailto:test@example.com")
+ * @returns true if the URL was opened successfully, false otherwise
+ *
+ * @example
+ * // Open a website
+ * openExternal("https://example.com");
+ *
+ * // Open an email
+ * openExternal("mailto:support@example.com?subject=Help");
+ *
+ * // Open a custom URL scheme
+ * openExternal("slack://open");
+ */
+export const openExternal = (url: string): boolean => {
+  return ffi.request.openExternal({ url });
+};
+
+/**
+ * Open a file or folder with the default application.
+ * For files, opens with the associated application (e.g., .pdf with PDF reader).
+ * For folders, opens in the file manager.
+ *
+ * @param path - The absolute path to the file or folder
+ * @returns true if the path was opened successfully, false otherwise
+ *
+ * @example
+ * // Open a document with default app
+ * openPath("/Users/me/Documents/report.pdf");
+ *
+ * // Open a folder in file manager
+ * openPath("/Users/me/Downloads");
+ */
+export const openPath = (path: string): boolean => {
+  return ffi.request.openPath({ path });
+};
+
+export type NotificationOptions = {
+  /**
+   * The title of the notification (required)
+   */
+  title: string;
+  /**
+   * The main body text of the notification
+   */
+  body?: string;
+  /**
+   * A subtitle displayed below the title (macOS only, shown as additional line on other platforms)
+   */
+  subtitle?: string;
+  /**
+   * If true, the notification will not play a sound
+   */
+  silent?: boolean;
+};
+
+/**
+ * Show a native desktop notification.
+ *
+ * @param options - Notification options
+ * @param options.title - The title of the notification (required)
+ * @param options.body - The main body text
+ * @param options.subtitle - A subtitle (macOS shows this between title and body)
+ * @param options.silent - If true, no sound will be played
+ *
+ * @example
+ * // Simple notification
+ * showNotification({ title: "Download Complete" });
+ *
+ * // Notification with body
+ * showNotification({
+ *   title: "New Message",
+ *   body: "You have a new message from John"
+ * });
+ *
+ * // Full notification
+ * showNotification({
+ *   title: "Reminder",
+ *   subtitle: "Calendar Event",
+ *   body: "Team meeting in 15 minutes",
+ *   silent: false
+ * });
+ *
+ * // Silent notification
+ * showNotification({
+ *   title: "Sync Complete",
+ *   body: "All files have been synchronized",
+ *   silent: true
+ * });
+ */
+export const showNotification = (options: NotificationOptions): void => {
+  const { title, body, subtitle, silent } = options;
+  ffi.request.showNotification({ title, body, subtitle, silent });
+};
+
 export const quit = () => {
   // Use native killApp for graceful shutdown
   native.symbols.killApp();
@@ -51,3 +149,121 @@ export const openFileDialog = async (
   // todo: it's nested like this due to zig union types. needs a zig refactor and revisit
   return filePaths;
 };
+
+export type MessageBoxOptions = {
+  type?: "info" | "warning" | "error" | "question";
+  title?: string;
+  message?: string;
+  detail?: string;
+  buttons?: string[];
+  defaultId?: number;
+  cancelId?: number;
+};
+
+export type MessageBoxResponse = {
+  response: number; // Index of the clicked button
+};
+
+/**
+ * Shows a message box dialog and returns which button was clicked.
+ * Similar to Electron's dialog.showMessageBox()
+ *
+ * @param opts - Options for the message box
+ * @param opts.type - The type of dialog: "info", "warning", "error", or "question"
+ * @param opts.title - The title of the dialog window
+ * @param opts.message - The main message to display
+ * @param opts.detail - Additional detail text (displayed smaller on some platforms)
+ * @param opts.buttons - Array of button labels (e.g., ["OK", "Cancel"])
+ * @param opts.defaultId - Index of the default button (focused on open)
+ * @param opts.cancelId - Index of the button to trigger on Escape key or dialog close
+ * @returns Promise resolving to an object with `response` (0-based button index clicked)
+ *
+ * @example
+ * const { response } = await showMessageBox({
+ *   type: "question",
+ *   title: "Confirm",
+ *   message: "Are you sure you want to delete this file?",
+ *   buttons: ["Delete", "Cancel"],
+ *   defaultId: 1,
+ *   cancelId: 1
+ * });
+ * if (response === 0) {
+ *   // User clicked Delete
+ * }
+ */
+export const showMessageBox = async (
+  opts: MessageBoxOptions = {}
+): Promise<MessageBoxResponse> => {
+  const {
+    type = "info",
+    title = "",
+    message = "",
+    detail = "",
+    buttons = ["OK"],
+    defaultId = 0,
+    cancelId = -1,
+  } = opts;
+
+  const response = ffi.request.showMessageBox({
+    type,
+    title,
+    message,
+    detail,
+    buttons,
+    defaultId,
+    cancelId,
+  });
+
+  return { response };
+};
+
+// ============================================================================
+// Clipboard API
+// ============================================================================
+
+/**
+ * Read text from the system clipboard.
+ * @returns The clipboard text, or null if no text is available
+ */
+export const clipboardReadText = (): string | null => {
+  return ffi.request.clipboardReadText();
+};
+
+/**
+ * Write text to the system clipboard.
+ * @param text - The text to write to the clipboard
+ */
+export const clipboardWriteText = (text: string): void => {
+  ffi.request.clipboardWriteText({ text });
+};
+
+/**
+ * Read image from the system clipboard as PNG data.
+ * @returns PNG image data as Uint8Array, or null if no image is available
+ */
+export const clipboardReadImage = (): Uint8Array | null => {
+  return ffi.request.clipboardReadImage();
+};
+
+/**
+ * Write PNG image data to the system clipboard.
+ * @param pngData - PNG image data as Uint8Array
+ */
+export const clipboardWriteImage = (pngData: Uint8Array): void => {
+  ffi.request.clipboardWriteImage({ pngData });
+};
+
+/**
+ * Clear the system clipboard.
+ */
+export const clipboardClear = (): void => {
+  ffi.request.clipboardClear();
+};
+
+/**
+ * Get the available formats in the clipboard.
+ * @returns Array of format names (e.g., ["text", "image", "files", "html"])
+ */
+export const clipboardAvailableFormats = (): string[] => {
+  return ffi.request.clipboardAvailableFormats();
+};

package/dist/api/bun/events/ApplicationEvents.ts

@@ -11,4 +11,9 @@ export default {
       "context-menu-clicked",
       data
     ),
+  openUrl: (data) =>
+    new ElectrobunEvent<{ url: string }, void>(
+      "open-url",
+      data
+    ),
 };

package/dist/api/bun/index.ts

@@ -6,17 +6,28 @@ import * as ApplicationMenu from "./core/ApplicationMenu";
 import * as ContextMenu from "./core/ContextMenu";
 import { Updater } from "./core/Updater";
 import * as Utils from "./core/Utils";
+import type { MessageBoxOptions, MessageBoxResponse } from "./core/Utils";
 import { type RPCSchema, createRPC } from "rpc-anywhere";
 import type ElectrobunEvent from "./events/event";
 import * as PATHS from "./core/Paths";
 import * as Socket from "./core/Socket";
 import type { ElectrobunConfig } from "./ElectrobunConfig";
+import { GlobalShortcut, Screen, Session } from "./proc/native";
+import type { Display, Rectangle, Point, Cookie, CookieFilter, StorageType } from "./proc/native";
 
 // Named Exports
 export {
   type RPCSchema,
   type ElectrobunEvent,
   type ElectrobunConfig,
+  type MessageBoxOptions,
+  type MessageBoxResponse,
+  type Display,
+  type Rectangle,
+  type Point,
+  type Cookie,
+  type CookieFilter,
+  type StorageType,
   createRPC,
   BrowserWindow,
   BrowserView,
@@ -27,6 +38,9 @@ export {
   ContextMenu,
   PATHS,
   Socket,
+  GlobalShortcut,
+  Screen,
+  Session,
 };
 
 // Default Export
@@ -38,6 +52,9 @@ const Electrobun = {
   Utils,
   ApplicationMenu,
   ContextMenu,
+  GlobalShortcut,
+  Screen,
+  Session,
   events: electobunEventEmmitter,
   PATHS,
   Socket,

package/dist/api/bun/proc/native.ts

@@ -98,6 +98,46 @@ export const native = (() => {
         ],
         returns: FFIType.void,
       },
+      minimizeNSWindow: {
+        args: [FFIType.ptr],
+        returns: FFIType.void,
+      },
+      unminimizeNSWindow: {
+        args: [FFIType.ptr],
+        returns: FFIType.void,
+      },
+      isNSWindowMinimized: {
+        args: [FFIType.ptr],
+        returns: FFIType.bool,
+      },
+      maximizeNSWindow: {
+        args: [FFIType.ptr],
+        returns: FFIType.void,
+      },
+      unmaximizeNSWindow: {
+        args: [FFIType.ptr],
+        returns: FFIType.void,
+      },
+      isNSWindowMaximized: {
+        args: [FFIType.ptr],
+        returns: FFIType.bool,
+      },
+      setNSWindowFullScreen: {
+        args: [FFIType.ptr, FFIType.bool],
+        returns: FFIType.void,
+      },
+      isNSWindowFullScreen: {
+        args: [FFIType.ptr],
+        returns: FFIType.bool,
+      },
+      setNSWindowAlwaysOnTop: {
+        args: [FFIType.ptr, FFIType.bool],
+        returns: FFIType.void,
+      },
+      isNSWindowAlwaysOnTop: {
+        args: [FFIType.ptr],
+        returns: FFIType.bool,
+      },
       // webview
       initWebview: {
         args: [
@@ -207,7 +247,19 @@ export const native = (() => {
       webviewSetHidden: {
         args: [FFIType.ptr, FFIType.bool],
         returns: FFIType.void
-      },     
+      },
+      setWebviewNavigationRules: {
+        args: [FFIType.ptr, FFIType.cstring],
+        returns: FFIType.void
+      },
+      webviewFindInPage: {
+        args: [FFIType.ptr, FFIType.cstring, FFIType.bool, FFIType.bool],
+        returns: FFIType.void
+      },
+      webviewStopFind: {
+        args: [FFIType.ptr],
+        returns: FFIType.void
+      },
       evaluateJavaScriptWithNoCompletion: {
         args: [FFIType.ptr, FFIType.cstring],
         returns: FFIType.void
@@ -256,7 +308,61 @@ export const native = (() => {
       showItemInFolder: {
         args: [FFIType.cstring],
         returns: FFIType.void
-      },  
+      },
+      openExternal: {
+        args: [FFIType.cstring],
+        returns: FFIType.bool
+      },
+      openPath: {
+        args: [FFIType.cstring],
+        returns: FFIType.bool
+      },
+      showNotification: {
+        args: [
+          FFIType.cstring, // title
+          FFIType.cstring, // body
+          FFIType.cstring, // subtitle
+          FFIType.bool,    // silent
+        ],
+        returns: FFIType.void
+      },
+
+      // Global keyboard shortcuts
+      setGlobalShortcutCallback: {
+        args: [FFIType.function],
+        returns: FFIType.void
+      },
+      registerGlobalShortcut: {
+        args: [FFIType.cstring],
+        returns: FFIType.bool
+      },
+      unregisterGlobalShortcut: {
+        args: [FFIType.cstring],
+        returns: FFIType.bool
+      },
+      unregisterAllGlobalShortcuts: {
+        args: [],
+        returns: FFIType.void
+      },
+      isGlobalShortcutRegistered: {
+        args: [FFIType.cstring],
+        returns: FFIType.bool
+      },
+
+      // Screen API
+      getAllDisplays: {
+        args: [],
+        returns: FFIType.cstring
+      },
+      getPrimaryDisplay: {
+        args: [],
+        returns: FFIType.cstring
+      },
+      getCursorScreenPoint: {
+        args: [],
+        returns: FFIType.cstring
+      },
+
       openFileDialog: {
         args: [
           FFIType.cstring,
@@ -266,8 +372,74 @@ export const native = (() => {
           FFIType.int,
         ],
         returns: FFIType.cstring
-      },  
-      
+      },
+      showMessageBox: {
+        args: [
+          FFIType.cstring, // type
+          FFIType.cstring, // title
+          FFIType.cstring, // message
+          FFIType.cstring, // detail
+          FFIType.cstring, // buttons (comma-separated)
+          FFIType.int,     // defaultId
+          FFIType.int,     // cancelId
+        ],
+        returns: FFIType.int
+      },
+
+      // Clipboard API
+      clipboardReadText: {
+        args: [],
+        returns: FFIType.cstring
+      },
+      clipboardWriteText: {
+        args: [FFIType.cstring],
+        returns: FFIType.void
+      },
+      clipboardReadImage: {
+        args: [FFIType.ptr], // pointer to size_t for output size
+        returns: FFIType.ptr  // pointer to PNG data
+      },
+      clipboardWriteImage: {
+        args: [FFIType.ptr, FFIType.u64], // PNG data pointer, size
+        returns: FFIType.void
+      },
+      clipboardClear: {
+        args: [],
+        returns: FFIType.void
+      },
+      clipboardAvailableFormats: {
+        args: [],
+        returns: FFIType.cstring
+      },
+
+      // Session/Cookie API
+      sessionGetCookies: {
+        args: [FFIType.cstring, FFIType.cstring],
+        returns: FFIType.cstring
+      },
+      sessionSetCookie: {
+        args: [FFIType.cstring, FFIType.cstring],
+        returns: FFIType.bool
+      },
+      sessionRemoveCookie: {
+        args: [FFIType.cstring, FFIType.cstring, FFIType.cstring],
+        returns: FFIType.bool
+      },
+      sessionClearCookies: {
+        args: [FFIType.cstring],
+        returns: FFIType.void
+      },
+      sessionClearStorageData: {
+        args: [FFIType.cstring, FFIType.cstring],
+        returns: FFIType.void
+      },
+
+      // URL scheme handler (macOS only)
+      setURLOpenHandler: {
+        args: [FFIType.function], // handler callback
+        returns: FFIType.void
+      },
+
       // MacOS specific native utils
       getNSWindowStyleMask: {
         args: [
@@ -441,14 +613,124 @@ export const ffi = {
       focusWindow: (params: {winId: number}) => {
         const {winId} = params;
         const windowPtr = BrowserWindow.getById(winId)?.ptr;
-        
+
         if (!windowPtr) {
           throw `Can't focus window. Window no longer exists`;
         }
-        
+
         native.symbols.makeNSWindowKeyAndOrderFront(windowPtr);
       },
 
+      minimizeWindow: (params: {winId: number}) => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't minimize window. Window no longer exists`;
+        }
+
+        native.symbols.minimizeNSWindow(windowPtr);
+      },
+
+      unminimizeWindow: (params: {winId: number}) => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't unminimize window. Window no longer exists`;
+        }
+
+        native.symbols.unminimizeNSWindow(windowPtr);
+      },
+
+      isWindowMinimized: (params: {winId: number}): boolean => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          return false;
+        }
+
+        return native.symbols.isNSWindowMinimized(windowPtr);
+      },
+
+      maximizeWindow: (params: {winId: number}) => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't maximize window. Window no longer exists`;
+        }
+
+        native.symbols.maximizeNSWindow(windowPtr);
+      },
+
+      unmaximizeWindow: (params: {winId: number}) => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't unmaximize window. Window no longer exists`;
+        }
+
+        native.symbols.unmaximizeNSWindow(windowPtr);
+      },
+
+      isWindowMaximized: (params: {winId: number}): boolean => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          return false;
+        }
+
+        return native.symbols.isNSWindowMaximized(windowPtr);
+      },
+
+      setWindowFullScreen: (params: {winId: number; fullScreen: boolean}) => {
+        const {winId, fullScreen} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't set fullscreen. Window no longer exists`;
+        }
+
+        native.symbols.setNSWindowFullScreen(windowPtr, fullScreen);
+      },
+
+      isWindowFullScreen: (params: {winId: number}): boolean => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          return false;
+        }
+
+        return native.symbols.isNSWindowFullScreen(windowPtr);
+      },
+
+      setWindowAlwaysOnTop: (params: {winId: number; alwaysOnTop: boolean}) => {
+        const {winId, alwaysOnTop} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't set always on top. Window no longer exists`;
+        }
+
+        native.symbols.setNSWindowAlwaysOnTop(windowPtr, alwaysOnTop);
+      },
+
+      isWindowAlwaysOnTop: (params: {winId: number}): boolean => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          return false;
+        }
+
+        return native.symbols.isNSWindowAlwaysOnTop(windowPtr);
+      },
+
       createWebview: (params: {
         id: number;
         windowId: number;
@@ -858,7 +1140,24 @@ export const ffi = {
           path
         } = params;
 
-        native.symbols.showItemInFolder(toCString(path));        
+        native.symbols.showItemInFolder(toCString(path));
+      },
+      openExternal: (params: {url: string}): boolean => {
+        const { url } = params;
+        return native.symbols.openExternal(toCString(url));
+      },
+      openPath: (params: {path: string}): boolean => {
+        const { path } = params;
+        return native.symbols.openPath(toCString(path));
+      },
+      showNotification: (params: {title: string, body?: string, subtitle?: string, silent?: boolean}): void => {
+        const { title, body = '', subtitle = '', silent = false } = params;
+        native.symbols.showNotification(
+          toCString(title),
+          toCString(body),
+          toCString(subtitle),
+          silent
+        );
       },
       openFileDialog: (params: {startingFolder: string, allowedFileTypes: string, canChooseFiles: boolean, canChooseDirectory: boolean, allowsMultipleSelection: boolean}): string => {
         const {
@@ -867,12 +1166,79 @@ export const ffi = {
           canChooseFiles,
           canChooseDirectory,
           allowsMultipleSelection,
-        } = params;        
-        const filePath = native.symbols.openFileDialog(toCString(startingFolder), toCString(allowedFileTypes), canChooseFiles, canChooseDirectory, allowsMultipleSelection);        
-        
+        } = params;
+        const filePath = native.symbols.openFileDialog(toCString(startingFolder), toCString(allowedFileTypes), canChooseFiles, canChooseDirectory, allowsMultipleSelection);
+
         return filePath.toString();
       },
-      
+      showMessageBox: (params: {type?: string, title?: string, message?: string, detail?: string, buttons?: string[], defaultId?: number, cancelId?: number}): number => {
+        const {
+          type = 'info',
+          title = '',
+          message = '',
+          detail = '',
+          buttons = ['OK'],
+          defaultId = 0,
+          cancelId = -1,
+        } = params;
+        // Convert buttons array to comma-separated string
+        const buttonsStr = buttons.join(',');
+        return native.symbols.showMessageBox(
+          toCString(type),
+          toCString(title),
+          toCString(message),
+          toCString(detail),
+          toCString(buttonsStr),
+          defaultId,
+          cancelId
+        );
+      },
+
+      // Clipboard API
+      clipboardReadText: (): string | null => {
+        const result = native.symbols.clipboardReadText();
+        if (!result) return null;
+        return result.toString();
+      },
+      clipboardWriteText: (params: {text: string}): void => {
+        native.symbols.clipboardWriteText(toCString(params.text));
+      },
+      clipboardReadImage: (): Uint8Array | null => {
+        // Allocate a buffer for the size output
+        const sizeBuffer = new BigUint64Array(1);
+        const dataPtr = native.symbols.clipboardReadImage(ptr(sizeBuffer));
+
+        if (!dataPtr) return null;
+
+        const size = Number(sizeBuffer[0]);
+        if (size === 0) return null;
+
+        // Copy the data to a Uint8Array
+        const result = new Uint8Array(size);
+        const sourceView = new Uint8Array(toArrayBuffer(dataPtr, 0, size));
+        result.set(sourceView);
+
+        // Note: The native code allocated this memory with malloc
+        // We should free it, but Bun's FFI doesn't expose free directly
+        // The memory will be reclaimed when the process exits
+
+        return result;
+      },
+      clipboardWriteImage: (params: {pngData: Uint8Array}): void => {
+        const { pngData } = params;
+        native.symbols.clipboardWriteImage(ptr(pngData), BigInt(pngData.length));
+      },
+      clipboardClear: (): void => {
+        native.symbols.clipboardClear();
+      },
+      clipboardAvailableFormats: (): string[] => {
+        const result = native.symbols.clipboardAvailableFormats();
+        if (!result) return [];
+        const formatsStr = result.toString();
+        if (!formatsStr) return [];
+        return formatsStr.split(',').filter(f => f.length > 0);
+      },
+
       // ffifunc: (params: {}): void => {
       //   const {
           
@@ -1047,15 +1413,333 @@ const getHTMLForWebviewSync = new JSCallback((webviewId) => {
 
 native.symbols.setJSUtils(getMimeType, getHTMLForWebviewSync);
 
-// TODO XX: revisit this as integrated into the will-navigate handler
+// URL scheme open handler (macOS only)
+// Receives URLs when the app is opened via custom URL schemes (e.g., myapp://path)
+const urlOpenCallback = new JSCallback(
+  (urlPtr) => {
+    const url = new CString(urlPtr).toString();
+    const handler = electrobunEventEmitter.events.app.openUrl;
+    const event = handler({ url });
+    electrobunEventEmitter.emitEvent(event);
+  },
+  {
+    args: [FFIType.cstring],
+    returns: "void",
+    threadsafe: true,
+  }
+);
+
+// Register the URL open handler with native code (macOS only)
+if (process.platform === 'darwin') {
+  native.symbols.setURLOpenHandler(urlOpenCallback);
+}
+
+// Global shortcut storage and callback
+const globalShortcutHandlers = new Map<string, () => void>();
+
+const globalShortcutCallback = new JSCallback(
+  (acceleratorPtr) => {
+    const accelerator = new CString(acceleratorPtr).toString();
+    const handler = globalShortcutHandlers.get(accelerator);
+    if (handler) {
+      handler();
+    }
+  },
+  {
+    args: [FFIType.cstring],
+    returns: "void",
+    threadsafe: true,
+  }
+);
+
+// Set up the global shortcut callback
+native.symbols.setGlobalShortcutCallback(globalShortcutCallback);
+
+// GlobalShortcut module for external use
+export const GlobalShortcut = {
+  /**
+   * Register a global keyboard shortcut
+   * @param accelerator - The shortcut string (e.g., "CommandOrControl+Shift+Space")
+   * @param callback - Function to call when the shortcut is triggered
+   * @returns true if registered successfully, false otherwise
+   */
+  register: (accelerator: string, callback: () => void): boolean => {
+    if (globalShortcutHandlers.has(accelerator)) {
+      return false; // Already registered
+    }
+
+    const result = native.symbols.registerGlobalShortcut(toCString(accelerator));
+    if (result) {
+      globalShortcutHandlers.set(accelerator, callback);
+    }
+    return result;
+  },
+
+  /**
+   * Unregister a global keyboard shortcut
+   * @param accelerator - The shortcut string to unregister
+   * @returns true if unregistered successfully, false otherwise
+   */
+  unregister: (accelerator: string): boolean => {
+    const result = native.symbols.unregisterGlobalShortcut(toCString(accelerator));
+    if (result) {
+      globalShortcutHandlers.delete(accelerator);
+    }
+    return result;
+  },
+
+  /**
+   * Unregister all global keyboard shortcuts
+   */
+  unregisterAll: (): void => {
+    native.symbols.unregisterAllGlobalShortcuts();
+    globalShortcutHandlers.clear();
+  },
+
+  /**
+   * Check if a shortcut is registered
+   * @param accelerator - The shortcut string to check
+   * @returns true if registered, false otherwise
+   */
+  isRegistered: (accelerator: string): boolean => {
+    return native.symbols.isGlobalShortcutRegistered(toCString(accelerator));
+  },
+};
+
+// Types for Screen API
+export interface Rectangle {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface Display {
+  id: number;
+  bounds: Rectangle;
+  workArea: Rectangle;
+  scaleFactor: number;
+  isPrimary: boolean;
+}
+
+export interface Point {
+  x: number;
+  y: number;
+}
+
+// Screen module for display and cursor information
+export const Screen = {
+  /**
+   * Get the primary display
+   * @returns Display object for the primary monitor
+   */
+  getPrimaryDisplay: (): Display => {
+    const jsonStr = native.symbols.getPrimaryDisplay();
+    if (!jsonStr) {
+      return {
+        id: 0,
+        bounds: { x: 0, y: 0, width: 0, height: 0 },
+        workArea: { x: 0, y: 0, width: 0, height: 0 },
+        scaleFactor: 1,
+        isPrimary: true,
+      };
+    }
+    try {
+      return JSON.parse(jsonStr);
+    } catch {
+      return {
+        id: 0,
+        bounds: { x: 0, y: 0, width: 0, height: 0 },
+        workArea: { x: 0, y: 0, width: 0, height: 0 },
+        scaleFactor: 1,
+        isPrimary: true,
+      };
+    }
+  },
+
+  /**
+   * Get all connected displays
+   * @returns Array of Display objects
+   */
+  getAllDisplays: (): Display[] => {
+    const jsonStr = native.symbols.getAllDisplays();
+    if (!jsonStr) {
+      return [];
+    }
+    try {
+      return JSON.parse(jsonStr);
+    } catch {
+      return [];
+    }
+  },
+
+  /**
+   * Get the current cursor position in screen coordinates
+   * @returns Point with x and y coordinates
+   */
+  getCursorScreenPoint: (): Point => {
+    const jsonStr = native.symbols.getCursorScreenPoint();
+    if (!jsonStr) {
+      return { x: 0, y: 0 };
+    }
+    try {
+      return JSON.parse(jsonStr);
+    } catch {
+      return { x: 0, y: 0 };
+    }
+  },
+};
+
+// Types for Session/Cookie API
+export interface Cookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'no_restriction' | 'lax' | 'strict';
+  expirationDate?: number; // Unix timestamp in seconds
+}
+
+export interface CookieFilter {
+  url?: string;
+  name?: string;
+  domain?: string;
+  path?: string;
+  secure?: boolean;
+  session?: boolean;
+}
+
+export type StorageType =
+  | 'cookies'
+  | 'localStorage'
+  | 'sessionStorage'
+  | 'indexedDB'
+  | 'webSQL'
+  | 'cache'
+  | 'all';
+
+// Cookies API for a session
+class SessionCookies {
+  private partitionId: string;
+
+  constructor(partitionId: string) {
+    this.partitionId = partitionId;
+  }
+
+  /**
+   * Get cookies matching the filter criteria
+   * @param filter - Optional filter to match cookies
+   * @returns Array of matching cookies
+   */
+  get(filter?: CookieFilter): Cookie[] {
+    const filterJson = JSON.stringify(filter || {});
+    const result = native.symbols.sessionGetCookies(
+      toCString(this.partitionId),
+      toCString(filterJson)
+    );
+    if (!result) return [];
+    try {
+      return JSON.parse(result);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Set a cookie
+   * @param cookie - The cookie to set
+   * @returns true if the cookie was set successfully
+   */
+  set(cookie: Cookie): boolean {
+    const cookieJson = JSON.stringify(cookie);
+    return native.symbols.sessionSetCookie(
+      toCString(this.partitionId),
+      toCString(cookieJson)
+    );
+  }
+
+  /**
+   * Remove a specific cookie
+   * @param url - The URL associated with the cookie
+   * @param name - The name of the cookie
+   * @returns true if the cookie was removed successfully
+   */
+  remove(url: string, name: string): boolean {
+    return native.symbols.sessionRemoveCookie(
+      toCString(this.partitionId),
+      toCString(url),
+      toCString(name)
+    );
+  }
+
+  /**
+   * Clear all cookies for this session
+   */
+  clear(): void {
+    native.symbols.sessionClearCookies(toCString(this.partitionId));
+  }
+}
+
+// Session class representing a storage partition
+class SessionInstance {
+  readonly partition: string;
+  readonly cookies: SessionCookies;
+
+  constructor(partition: string) {
+    this.partition = partition;
+    this.cookies = new SessionCookies(partition);
+  }
+
+  /**
+   * Clear storage data for this session
+   * @param types - Array of storage types to clear, or 'all' to clear everything
+   */
+  clearStorageData(types: StorageType[] | 'all' = 'all'): void {
+    const typesArray = types === 'all' ? ['all'] : types;
+    native.symbols.sessionClearStorageData(
+      toCString(this.partition),
+      toCString(JSON.stringify(typesArray))
+    );
+  }
+}
+
+// Cache of session instances
+const sessionCache = new Map<string, SessionInstance>();
+
+// Session module for storage/cookie management
+export const Session = {
+  /**
+   * Get or create a session for a given partition
+   * @param partition - The partition identifier (e.g., "persist:myapp" or "ephemeral")
+   * @returns Session instance for the partition
+   */
+  fromPartition: (partition: string): SessionInstance => {
+    let session = sessionCache.get(partition);
+    if (!session) {
+      session = new SessionInstance(partition);
+      sessionCache.set(partition, session);
+    }
+    return session;
+  },
+
+  /**
+   * Get the default session (persist:default partition)
+   */
+  get defaultSession(): SessionInstance {
+    return Session.fromPartition('persist:default');
+  },
+};
+
+// DEPRECATED: This callback is no longer used for navigation decisions.
+// Navigation rules are now stored in native code and evaluated synchronously
+// without calling back to Bun. Use webview.setNavigationRules() instead.
+// This callback is kept for FFI signature compatibility but is not called.
 const webviewDecideNavigation = new JSCallback((webviewId, url) => {
-  console.log('TODO: webviewDecideNavigation', webviewId, new CString(url))
   return true;
 }, {
   args: [FFIType.u32, FFIType.cstring],
-  // NOTE: In Objc true is YES which is so dumb, but that doesn't work with Bun's FFIType.bool
-  // in JSCallbacks right now (it always infers false) so to make this cross platform we have to use 
-  // FFIType.u32 and uint32_t and then just treat it as a boolean in code.
   returns: FFIType.u32,
   threadsafe: true
 });
@@ -1496,6 +2180,31 @@ export const internalRpcHandlers = {
       }
       native.symbols.webviewSetHidden(webview.ptr, params.hidden);
     },
+    webviewTagSetNavigationRules: (params: {id: number; rules: string[]}) => {
+      const webview = BrowserView.getById(params.id);
+      if (!webview || !webview.ptr) {
+        console.error(`webviewTagSetNavigationRules: BrowserView not found or has no ptr for id ${params.id}`);
+        return;
+      }
+      const rulesJson = JSON.stringify(params.rules);
+      native.symbols.setWebviewNavigationRules(webview.ptr, toCString(rulesJson));
+    },
+    webviewTagFindInPage: (params: {id: number; searchText: string; forward: boolean; matchCase: boolean}) => {
+      const webview = BrowserView.getById(params.id);
+      if (!webview || !webview.ptr) {
+        console.error(`webviewTagFindInPage: BrowserView not found or has no ptr for id ${params.id}`);
+        return;
+      }
+      native.symbols.webviewFindInPage(webview.ptr, toCString(params.searchText), params.forward, params.matchCase);
+    },
+    webviewTagStopFind: (params: {id: number}) => {
+      const webview = BrowserView.getById(params.id);
+      if (!webview || !webview.ptr) {
+        console.error(`webviewTagStopFind: BrowserView not found or has no ptr for id ${params.id}`);
+        return;
+      }
+      native.symbols.webviewStopFind(webview.ptr);
+    },
     webviewEvent: (params) => {
       console.log('-----------------+webviewEvent', params)
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.8.0-beta.0",
+  "version": "0.9.3-beta.0",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",

package/src/cli/index.ts

@@ -609,22 +609,45 @@ function escapeXml(str: string): string {
 // Helper function to generate usage description entries for Info.plist
 function generateUsageDescriptions(entitlements: Record<string, boolean | string>): string {
   const usageEntries: string[] = [];
-  
+
   for (const [entitlement, value] of Object.entries(entitlements)) {
     const plistKey = ENTITLEMENT_TO_PLIST_KEY[entitlement];
     if (plistKey && value) {
       // Use the string value as description, or a default if it's just true
-      const description = typeof value === "string" 
+      const description = typeof value === "string"
         ? escapeXml(value)
         : `This app requires access for ${entitlement.split('.').pop()?.replace('-', ' ')}`;
-      
+
       usageEntries.push(`    <key>${plistKey}</key>\n    <string>${description}</string>`);
     }
   }
-  
+
   return usageEntries.join('\n');
 }
 
+// Helper function to generate CFBundleURLTypes for custom URL schemes
+function generateURLTypes(urlSchemes: string[] | undefined, identifier: string): string {
+  if (!urlSchemes || urlSchemes.length === 0) {
+    return '';
+  }
+
+  const schemesXml = urlSchemes.map(scheme => `                <string>${escapeXml(scheme)}</string>`).join('\n');
+
+  return `    <key>CFBundleURLTypes</key>
+    <array>
+        <dict>
+            <key>CFBundleURLName</key>
+            <string>${escapeXml(identifier)}</string>
+            <key>CFBundleTypeRole</key>
+            <string>Viewer</string>
+            <key>CFBundleURLSchemes</key>
+            <array>
+${schemesXml}
+            </array>
+        </dict>
+    </array>`;
+}
+
 const command = commandDefaults[commandArg];
 
 if (!command) {
@@ -1064,7 +1087,9 @@ if (commandArg === "init") {
   // provide methods to help segment data in those folders based on channel/environment
   // Generate usage descriptions from entitlements
   const usageDescriptions = generateUsageDescriptions(config.build.mac.entitlements || {});
-  
+  // Generate URL scheme handlers
+  const urlTypes = generateURLTypes(config.app.urlSchemes, config.app.identifier);
+
   const InfoPlistContents = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -1080,7 +1105,7 @@ if (commandArg === "init") {
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleIconFile</key>
-    <string>AppIcon</string>${usageDescriptions ? '\n' + usageDescriptions : ''}
+    <string>AppIcon</string>${usageDescriptions ? '\n' + usageDescriptions : ''}${urlTypes ? '\n' + urlTypes : ''}
 </dict>
 </plist>`;