sparkbun 0.1.5 → 0.1.7

package/src/native/win/nativeWrapper.cpp

@@ -75,7 +75,7 @@ struct DCompBridgeState;
 static std::map<void*, std::unique_ptr<DCompBridgeState>> g_dcompBridges;
 static std::mutex g_dcompBridgeMapMutex;
 
-using namespace electrobun;
+using namespace sparkbun;
 
 // Simple ASAR reader implementation for Windows (no external dependency)
 #include <fstream>
@@ -391,7 +391,7 @@ using namespace Microsoft::WRL;
 
 
 // Ensure the exported functions have appropriate visibility
-#define ELECTROBUN_EXPORT __declspec(dllexport)
+#define SPARKBUN_EXPORT __declspec(dllexport)
 #define WM_EXECUTE_SYNC_BLOCK (WM_USER + 1)
 #define WM_EXECUTE_ASYNC_BLOCK (WM_USER + 2)
 #define WM_DEVTOOLS_CREATE (WM_USER + 3)
@@ -406,7 +406,7 @@ class MyScriptMessageHandlerWithReply;
 class StatusItemTarget;
 
 // CEF function declarations
-ELECTROBUN_EXPORT bool isCEFAvailable();
+SPARKBUN_EXPORT bool isCEFAvailable();
 
 // Type definitions to match macOS types
 typedef double CGFloat;
@@ -424,9 +424,9 @@ static GetMimeType g_getMimeType = nullptr;
 static GetHTMLForWebviewSync g_getHTMLForWebviewSync = nullptr;
 
 // Global variables for CEF cache path isolation
-static std::string g_electrobunChannel = "";
-static std::string g_electrobunIdentifier = "";
-static std::string g_electrobunName = "";
+static std::string g_sparkbunChannel = "";
+static std::string g_sparkbunIdentifier = "";
+static std::string g_sparkbunName = "";
 
 // Webview content storage (replaces JSCallback approach)
 static std::map<uint32_t, std::string> webviewHTMLContent;
@@ -443,8 +443,8 @@ static std::mutex g_abstractViewsMutex;
 bool checkNavigationRules(AbstractView* view, const std::string& url);
 
 // Forward declarations for HTML content management
-extern "C" ELECTROBUN_EXPORT const char* getWebviewHTMLContent(uint32_t webviewId);
-extern "C" ELECTROBUN_EXPORT void setWebviewHTMLContent(uint32_t webviewId, const char* htmlContent);
+extern "C" SPARKBUN_EXPORT const char* getWebviewHTMLContent(uint32_t webviewId);
+extern "C" SPARKBUN_EXPORT void setWebviewHTMLContent(uint32_t webviewId, const char* htmlContent);
 
 // Global mutex to serialize webview creation
 static std::mutex g_webviewCreationMutex;
@@ -539,7 +539,7 @@ static int FindAvailableRemoteDebugPort(int startPort, int endPort) {
 // CEF global variables
 static bool g_cef_initialized = false;
 static CefRefPtr<CefApp> g_cef_app;
-static electrobun::ChromiumFlagConfig g_userChromiumFlags;
+static sparkbun::ChromiumFlagConfig g_userChromiumFlags;
 static HANDLE g_job_object = nullptr;  // Job object to track all child processes
 
 // Quit/shutdown coordination
@@ -553,7 +553,7 @@ static DWORD g_mainThreadId = 0;
 #define WM_CEF_SCHEDULE_WORK (WM_USER + 100)
 static HWND g_cefPumpWindow = NULL;
 
-class ElectrobunCefApp : public CefApp, public CefBrowserProcessHandler {
+class SparkBunCefApp : public CefApp, public CefBrowserProcessHandler {
 public:
     CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() override {
         return this;
@@ -576,16 +576,16 @@ public:
 
     void OnBeforeCommandLineProcessing(const CefString& process_type, CefRefPtr<CefCommandLine> command_line) override {
         // Windows default flags — can be overridden via chromiumFlags in config
-        static const std::vector<electrobun::DefaultFlag> defaults = {
+        static const std::vector<sparkbun::DefaultFlag> defaults = {
             {"disable-web-security", ""},
             {"disable-features=VizDisplayCompositor", ""},
             {"remote-allow-origins", "*"},
             {"allow-insecure-localhost", ""},
         };
-        electrobun::applyDefaultFlags(defaults, g_userChromiumFlags.skip, command_line);
+        sparkbun::applyDefaultFlags(defaults, g_userChromiumFlags.skip, command_line);
 
         // Apply user-defined chromium flags from build.json
-        electrobun::applyChromiumFlags(g_userChromiumFlags, command_line);
+        sparkbun::applyChromiumFlags(g_userChromiumFlags, command_line);
     }
 
     void OnRegisterCustomSchemes(CefRawPtr<CefSchemeRegistrar> registrar) override {
@@ -599,24 +599,24 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunCefApp);
+    IMPLEMENT_REFCOUNTING(SparkBunCefApp);
 };
 
 // Forward declaration for CEF client (needed for load handler)
-class ElectrobunCefClient;
+class SparkBunCefClient;
 
 // CEF Load Handler for debugging navigation
-class ElectrobunLoadHandler : public CefLoadHandler {
+class SparkBunLoadHandler : public CefLoadHandler {
 public:
     uint32_t webview_id_ = 0;
     WebviewEventHandler webview_event_handler_ = nullptr;
-    CefRefPtr<ElectrobunCefClient> client_ = nullptr;
+    CefRefPtr<SparkBunCefClient> client_ = nullptr;
 
-    ElectrobunLoadHandler() {}
+    SparkBunLoadHandler() {}
 
     void SetWebviewId(uint32_t id) { webview_id_ = id; }
     void SetWebviewEventHandler(WebviewEventHandler handler) { webview_event_handler_ = handler; }
-    void SetClient(CefRefPtr<ElectrobunCefClient> client) { client_ = client; }
+    void SetClient(CefRefPtr<SparkBunCefClient> client) { client_ = client; }
 
     void OnLoadStart(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, TransitionType transition_type) override;
     void OnLoadEnd(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, int httpStatusCode) override;
@@ -627,19 +627,19 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunLoadHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunLoadHandler);
 };
 
 // Global map to store CEF clients for browser connection
-static std::map<HWND, CefRefPtr<ElectrobunCefClient>> g_cefClients;
+static std::map<HWND, CefRefPtr<SparkBunCefClient>> g_cefClients;
 
 // Forward declaration for helper functions (defined after class definitions)
-void SetBrowserOnClient(CefRefPtr<ElectrobunCefClient> client, CefRefPtr<CefBrowser> browser);
+void SetBrowserOnClient(CefRefPtr<SparkBunCefClient> client, CefRefPtr<CefBrowser> browser);
 void SetBrowserOnCEFView(HWND parentWindow, CefRefPtr<CefBrowser> browser);
 void SetWebViewOnWebView2View(HWND containerWindow, void* webview);
 
 // CEF Life Span Handler for async browser creation
-class ElectrobunLifeSpanHandler : public CefLifeSpanHandler {
+class SparkBunLifeSpanHandler : public CefLifeSpanHandler {
 public:
     void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
         // Note: Browser setup is now handled synchronously during CreateBrowserSync
@@ -683,11 +683,11 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunLifeSpanHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunLifeSpanHandler);
 };
 
 // Forward declaration for DevTools callback
-class ElectrobunCefClient;
+class SparkBunCefClient;
 typedef void (*RemoteDevToolsClosedCallback)(void* ctx, int target_id);
 void RemoteDevToolsClosed(void* ctx, int target_id);
 
@@ -723,7 +723,7 @@ struct DevToolsWindowContext {
 };
 
 static std::once_flag g_devtoolsClassRegistered;
-static const char* DEVTOOLS_WINDOW_CLASS = "ElectrobunDevToolsClass";
+static const char* DEVTOOLS_WINDOW_CLASS = "SparkBunDevToolsClass";
 
 static LRESULT CALLBACK DevToolsWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
     DevToolsWindowContext* dtCtx = nullptr;
@@ -783,9 +783,9 @@ std::string loadViewsFile(const std::string& path);
 std::string getMimeTypeForFile(const std::string& path);
 
 // CEF Resource Handler for views:// scheme (based on Mac implementation)
-class ElectrobunSchemeHandler : public CefResourceHandler {
+class SparkBunSchemeHandler : public CefResourceHandler {
 public:
-    ElectrobunSchemeHandler(uint32_t webviewId)
+    SparkBunSchemeHandler(uint32_t webviewId)
         : webviewId_(webviewId), offset_(0), hasResponse_(false) {}
 
     bool Open(CefRefPtr<CefRequest> request, bool& handle_request, CefRefPtr<CefCallback> callback) override {
@@ -847,11 +847,11 @@ private:
     std::vector<char> responseData_;
     bool hasResponse_;
     size_t offset_;
-    IMPLEMENT_REFCOUNTING(ElectrobunSchemeHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunSchemeHandler);
 };
 
 // CEF Scheme Handler Factory
-class ElectrobunSchemeHandlerFactory : public CefSchemeHandlerFactory {
+class SparkBunSchemeHandlerFactory : public CefSchemeHandlerFactory {
 public:
     CefRefPtr<CefResourceHandler> Create(CefRefPtr<CefBrowser> browser,
                                        CefRefPtr<CefFrame> frame,
@@ -867,17 +867,17 @@ public:
                 webviewId = it->second;
             }
         }
-        return new ElectrobunSchemeHandler(webviewId);
+        return new SparkBunSchemeHandler(webviewId);
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunSchemeHandlerFactory);
+    IMPLEMENT_REFCOUNTING(SparkBunSchemeHandlerFactory);
 };
 
 // CEF Response Filter for script injection
-class ElectrobunResponseFilter : public CefResponseFilter {
+class SparkBunResponseFilter : public CefResponseFilter {
 public:
-    ElectrobunResponseFilter(const std::string& script) : script_(script) {}
+    SparkBunResponseFilter(const std::string& script) : script_(script) {}
 
     bool InitFilter() override {
         return true;
@@ -950,18 +950,18 @@ private:
     std::string processed_data_;
     size_t output_offset_ = 0;
     bool processed_ = false;
-    IMPLEMENT_REFCOUNTING(ElectrobunResponseFilter);
+    IMPLEMENT_REFCOUNTING(SparkBunResponseFilter);
 };
 
-// Forward declaration for ElectrobunCefClient
-class ElectrobunCefClient;
+// Forward declaration for SparkBunCefClient
+class SparkBunCefClient;
 
 // CEF Resource Request Handler to inject preload scripts via response filter
-class ElectrobunResourceRequestHandler : public CefResourceRequestHandler {
+class SparkBunResourceRequestHandler : public CefResourceRequestHandler {
 public:
-    CefRefPtr<ElectrobunCefClient> client_ = nullptr;
+    CefRefPtr<SparkBunCefClient> client_ = nullptr;
 
-    ElectrobunResourceRequestHandler(CefRefPtr<ElectrobunCefClient> client) : client_(client) {}
+    SparkBunResourceRequestHandler(CefRefPtr<SparkBunCefClient> client) : client_(client) {}
 
     // Response filter to inject preload scripts into HTML before parsing
     // This ensures scripts execute BEFORE any page JavaScript
@@ -971,26 +971,26 @@ public:
         CefRefPtr<CefRequest> request,
         CefRefPtr<CefResponse> response) override;
 
-    IMPLEMENT_REFCOUNTING(ElectrobunResourceRequestHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunResourceRequestHandler);
 };
 
 // CEF Request Handler for views:// scheme support
-class ElectrobunRequestHandler : public CefRequestHandler {
+class SparkBunRequestHandler : public CefRequestHandler {
 public:
     uint32_t webview_id_ = 0;
     WebviewEventHandler webview_event_handler_ = nullptr;
     AbstractView* abstract_view_ = nullptr;
-    CefRefPtr<ElectrobunCefClient> client_ = nullptr;
+    CefRefPtr<SparkBunCefClient> client_ = nullptr;
 
     // Static debounce timestamp for ctrl+click handling
     static double lastCtrlClickTime;
 
-    ElectrobunRequestHandler() {}
+    SparkBunRequestHandler() {}
 
     void SetWebviewId(uint32_t id) { webview_id_ = id; }
     void SetWebviewEventHandler(WebviewEventHandler handler) { webview_event_handler_ = handler; }
     void SetAbstractView(AbstractView* view) { abstract_view_ = view; }
-    void SetClient(CefRefPtr<ElectrobunCefClient> client) { client_ = client; }
+    void SetClient(CefRefPtr<SparkBunCefClient> client) { client_ = client; }
 
     // Return resource request handler to enable response filtering
     CefRefPtr<CefResourceRequestHandler> GetResourceRequestHandler(
@@ -1003,7 +1003,7 @@ public:
         bool& disable_default_handling) override {
 
         if (client_) {
-            return new ElectrobunResourceRequestHandler(client_);
+            return new SparkBunResourceRequestHandler(client_);
         }
         return nullptr;
     }
@@ -1082,16 +1082,16 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunRequestHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunRequestHandler);
 };
 
 // Initialize static debounce timestamp
-double ElectrobunRequestHandler::lastCtrlClickTime = 0;
+double SparkBunRequestHandler::lastCtrlClickTime = 0;
 
 // CEF Context Menu Handler for devtools support
-class ElectrobunContextMenuHandler : public CefContextMenuHandler {
+class SparkBunContextMenuHandler : public CefContextMenuHandler {
 public:
-    ElectrobunContextMenuHandler() {}
+    SparkBunContextMenuHandler() {}
     
     void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
                            CefRefPtr<CefFrame> frame,
@@ -1102,7 +1102,7 @@ public:
         model->AddItem(26501, "Inspect Element");
     }
     
-    // Defined out-of-line after ElectrobunCefClient (needs full class definition)
+    // Defined out-of-line after SparkBunCefClient (needs full class definition)
     bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
                             CefRefPtr<CefFrame> frame,
                             CefRefPtr<CefContextMenuParams> params,
@@ -1110,11 +1110,11 @@ public:
                             EventFlags event_flags) override;
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunContextMenuHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunContextMenuHandler);
 };
 
 // CEF Permission Handler for user media and other permissions
-class ElectrobunPermissionHandler : public CefPermissionHandler {
+class SparkBunPermissionHandler : public CefPermissionHandler {
 public:
     bool OnRequestMediaAccessPermission(
         CefRefPtr<CefBrowser> browser,
@@ -1214,7 +1214,7 @@ public:
             // Unrecognized permission type — name what's being requested instead of
             // a generic "additional permissions" dialog so the user can decide.
             message = "This page is requesting permission for: " +
-                      electrobun::describeCefPermissions(requested_permissions) +
+                      sparkbun::describeCefPermissions(requested_permissions) +
                       ".\n\nDo you want to allow this?";
         }
 
@@ -1266,7 +1266,7 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunPermissionHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunPermissionHandler);
 };
 
 // Helper functions for string conversion
@@ -1315,7 +1315,7 @@ std::string WStringToString(const std::wstring& wstr) {
 }
 
 // CEF Dialog Handler for file dialogs
-class ElectrobunDialogHandler : public CefDialogHandler {
+class SparkBunDialogHandler : public CefDialogHandler {
 public:
     bool OnFileDialog(CefRefPtr<CefBrowser> browser,
                       FileDialogMode mode,
@@ -1462,13 +1462,13 @@ public:
     }
     
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunDialogHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunDialogHandler);
 };
 
 // CEF Download handler for Windows
-class ElectrobunDownloadHandler : public CefDownloadHandler {
+class SparkBunDownloadHandler : public CefDownloadHandler {
 public:
-    ElectrobunDownloadHandler() {}
+    SparkBunDownloadHandler() {}
 
     bool OnBeforeDownload(CefRefPtr<CefBrowser> browser,
                           CefRefPtr<CefDownloadItem> download_item,
@@ -1541,7 +1541,7 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunDownloadHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunDownloadHandler);
 };
 
 // OSR (Off-Screen Rendering) Window for transparent CEF windows
@@ -1740,9 +1740,9 @@ private:
 };
 
 // CEF Render Handler for off-screen rendering (OSR) mode
-class ElectrobunRenderHandler : public CefRenderHandler {
+class SparkBunRenderHandler : public CefRenderHandler {
 public:
-    ElectrobunRenderHandler() : view_width_(800), view_height_(600), osr_window_(nullptr) {}
+    SparkBunRenderHandler() : view_width_(800), view_height_(600), osr_window_(nullptr) {}
 
     void SetOSRWindow(OSRWindow* window) {
         osr_window_ = window;
@@ -1773,31 +1773,31 @@ private:
     int view_height_;
     OSRWindow* osr_window_;
 
-    IMPLEMENT_REFCOUNTING(ElectrobunRenderHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunRenderHandler);
 };
 
 // Forward declaration
 void handleApplicationMenuSelection(UINT menuId);
 
 // CEF Keyboard Handler for menu accelerators
-class ElectrobunKeyboardHandler : public CefKeyboardHandler {
+class SparkBunKeyboardHandler : public CefKeyboardHandler {
 public:
-    // Defined out-of-line after ElectrobunCefClient (needs full class definition)
+    // Defined out-of-line after SparkBunCefClient (needs full class definition)
     bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
                       const CefKeyEvent& event,
                       CefEventHandle os_event,
                       bool* is_keyboard_shortcut) override;
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunKeyboardHandler);
+    IMPLEMENT_REFCOUNTING(SparkBunKeyboardHandler);
 };
 
 // CEF Client class with load and life span handlers
-class ElectrobunCefClient : public CefClient, public CefDisplayHandler {
+class SparkBunCefClient : public CefClient, public CefDisplayHandler {
 public:
     WebviewEventHandler webview_event_handler_ = nullptr;
 
-    ElectrobunCefClient(uint32_t webviewId,
+    SparkBunCefClient(uint32_t webviewId,
                        HandlePostMessage eventBridgeHandler,
                        HandlePostMessage bunBridgeHandler,
                        HandlePostMessage internalBridgeHandler,
@@ -1808,23 +1808,23 @@ public:
           webview_tag_handler_(internalBridgeHandler),
           is_sandboxed_(sandbox),
           osr_enabled_(false) {
-        m_loadHandler = new ElectrobunLoadHandler();
+        m_loadHandler = new SparkBunLoadHandler();
         m_loadHandler->SetClient(this); // Set client reference for load handler
-        m_lifeSpanHandler = new ElectrobunLifeSpanHandler();
-        m_requestHandler = new ElectrobunRequestHandler();
+        m_lifeSpanHandler = new SparkBunLifeSpanHandler();
+        m_requestHandler = new SparkBunRequestHandler();
         m_requestHandler->SetWebviewId(webviewId);
         m_requestHandler->SetClient(this); // Set client reference for response filter
-        m_contextMenuHandler = new ElectrobunContextMenuHandler();
-        m_permissionHandler = new ElectrobunPermissionHandler();
-        m_dialogHandler = new ElectrobunDialogHandler();
-        m_downloadHandler = new ElectrobunDownloadHandler();
-        m_keyboardHandler = new ElectrobunKeyboardHandler();
+        m_contextMenuHandler = new SparkBunContextMenuHandler();
+        m_permissionHandler = new SparkBunPermissionHandler();
+        m_dialogHandler = new SparkBunDialogHandler();
+        m_downloadHandler = new SparkBunDownloadHandler();
+        m_keyboardHandler = new SparkBunKeyboardHandler();
         m_renderHandler = nullptr; // Created only when OSR is enabled
     }
 
     void EnableOSR(int width, int height) {
         osr_enabled_ = true;
-        m_renderHandler = new ElectrobunRenderHandler();
+        m_renderHandler = new SparkBunRenderHandler();
         m_renderHandler->SetViewSize(width, height);
     }
 
@@ -1862,7 +1862,7 @@ public:
     }
 
     void AddPreloadScript(const std::string& script) {
-        electrobun_script_ = script;
+        sparkbun_script_ = script;
     }
 
     void UpdateCustomPreloadScript(const std::string& script) {
@@ -1947,7 +1947,7 @@ public:
     std::string GetCombinedScript() const {
         // Inject webviewId into global scope before other scripts
         std::string combined_script = "window.webviewId = " + std::to_string(webview_id_) + ";\n";
-        combined_script += electrobun_script_;
+        combined_script += sparkbun_script_;
         if (!custom_script_.empty()) {
             combined_script += "\n" + custom_script_;
         }
@@ -1996,12 +1996,12 @@ public:
         int port = g_remoteDebugPort;
 
         // Keep ref to self for the background thread
-        CefRefPtr<ElectrobunCefClient> self(this);
+        CefRefPtr<SparkBunCefClient> self(this);
 
         // Fetch /json on a background thread
         std::thread([self, target_id, targetUrl, targetTitle, port]() {
             // WinHTTP synchronous GET to http://127.0.0.1:{port}/json
-            HINTERNET hSession = WinHttpOpen(L"Electrobun/DevTools",
+            HINTERNET hSession = WinHttpOpen(L"SparkBun/DevTools",
                                               WINHTTP_ACCESS_TYPE_NO_PROXY,
                                               WINHTTP_NO_PROXY_NAME,
                                               WINHTTP_NO_PROXY_BYPASS, 0);
@@ -2121,13 +2121,13 @@ public:
             // Post back to the UI thread via CefPostTask
             class CreateDevToolsTask : public CefTask {
             public:
-                CreateDevToolsTask(CefRefPtr<ElectrobunCefClient> client, int tid, const std::string& url)
+                CreateDevToolsTask(CefRefPtr<SparkBunCefClient> client, int tid, const std::string& url)
                     : client_(client), target_id_(tid), url_(url) {}
                 void Execute() override {
                     client_->CreateRemoteDevToolsWindow(target_id_, url_);
                 }
             private:
-                CefRefPtr<ElectrobunCefClient> client_;
+                CefRefPtr<SparkBunCefClient> client_;
                 int target_id_;
                 std::string url_;
                 IMPLEMENT_REFCOUNTING(CreateDevToolsTask);
@@ -2233,18 +2233,18 @@ private:
     HandlePostMessage bun_bridge_handler_;
     HandlePostMessage webview_tag_handler_;
     bool is_sandboxed_;
-    std::string electrobun_script_;
+    std::string sparkbun_script_;
     std::string custom_script_;
     CefRefPtr<CefBrowser> browser_;
-    CefRefPtr<ElectrobunLoadHandler> m_loadHandler;
-    CefRefPtr<ElectrobunLifeSpanHandler> m_lifeSpanHandler;
-    CefRefPtr<ElectrobunRequestHandler> m_requestHandler;
-    CefRefPtr<ElectrobunContextMenuHandler> m_contextMenuHandler;
-    CefRefPtr<ElectrobunPermissionHandler> m_permissionHandler;
-    CefRefPtr<ElectrobunDialogHandler> m_dialogHandler;
-    CefRefPtr<ElectrobunDownloadHandler> m_downloadHandler;
-    CefRefPtr<ElectrobunKeyboardHandler> m_keyboardHandler;
-    CefRefPtr<ElectrobunRenderHandler> m_renderHandler;
+    CefRefPtr<SparkBunLoadHandler> m_loadHandler;
+    CefRefPtr<SparkBunLifeSpanHandler> m_lifeSpanHandler;
+    CefRefPtr<SparkBunRequestHandler> m_requestHandler;
+    CefRefPtr<SparkBunContextMenuHandler> m_contextMenuHandler;
+    CefRefPtr<SparkBunPermissionHandler> m_permissionHandler;
+    CefRefPtr<SparkBunDialogHandler> m_dialogHandler;
+    CefRefPtr<SparkBunDownloadHandler> m_downloadHandler;
+    CefRefPtr<SparkBunKeyboardHandler> m_keyboardHandler;
+    CefRefPtr<SparkBunRenderHandler> m_renderHandler;
     bool osr_enabled_;
     std::function<void()> load_end_callback_;  // Callback for page load completion
 
@@ -2259,27 +2259,27 @@ private:
     std::map<int, DevToolsHost> devtools_hosts_;
     std::string last_title_;
 
-    IMPLEMENT_REFCOUNTING(ElectrobunCefClient);
+    IMPLEMENT_REFCOUNTING(SparkBunCefClient);
 };
 
-// Free function callback for RemoteDevToolsClient -> ElectrobunCefClient
+// Free function callback for RemoteDevToolsClient -> SparkBunCefClient
 void RemoteDevToolsClosed(void* ctx, int target_id) {
     if (!ctx) return;
-    static_cast<ElectrobunCefClient*>(ctx)->OnRemoteDevToolsClosed(target_id);
+    static_cast<SparkBunCefClient*>(ctx)->OnRemoteDevToolsClosed(target_id);
 }
 
-// Out-of-line definitions for handlers that need ElectrobunCefClient to be fully defined
+// Out-of-line definitions for handlers that need SparkBunCefClient to be fully defined
 
-bool ElectrobunContextMenuHandler::OnContextMenuCommand(
+bool SparkBunContextMenuHandler::OnContextMenuCommand(
     CefRefPtr<CefBrowser> browser,
     CefRefPtr<CefFrame> frame,
     CefRefPtr<CefContextMenuParams> params,
     int command_id,
     EventFlags event_flags) {
     if (command_id == 26501) {
-        // Open remote DevTools via the owning ElectrobunCefClient
+        // Open remote DevTools via the owning SparkBunCefClient
         CefRefPtr<CefClient> client = browser->GetHost()->GetClient();
-        ElectrobunCefClient* ebClient = static_cast<ElectrobunCefClient*>(client.get());
+        SparkBunCefClient* ebClient = static_cast<SparkBunCefClient*>(client.get());
         if (ebClient) {
             ebClient->OpenRemoteDevToolsFrontend(browser);
         }
@@ -2288,7 +2288,7 @@ bool ElectrobunContextMenuHandler::OnContextMenuCommand(
     return false;
 }
 
-bool ElectrobunKeyboardHandler::OnPreKeyEvent(
+bool SparkBunKeyboardHandler::OnPreKeyEvent(
     CefRefPtr<CefBrowser> browser,
     const CefKeyEvent& event,
     CefEventHandle os_event,
@@ -2305,7 +2305,7 @@ bool ElectrobunKeyboardHandler::OnPreKeyEvent(
                          (event.modifiers & EVENTFLAG_SHIFT_DOWN));
     if (isF12 || isCtrlShiftI) {
         CefRefPtr<CefClient> client = browser->GetHost()->GetClient();
-        ElectrobunCefClient* ebClient = static_cast<ElectrobunCefClient*>(client.get());
+        SparkBunCefClient* ebClient = static_cast<SparkBunCefClient*>(client.get());
         if (ebClient) {
             ebClient->OpenRemoteDevToolsFrontend(browser);
         }
@@ -2337,8 +2337,8 @@ bool ElectrobunKeyboardHandler::OnPreKeyEvent(
     return false;
 }
 
-// ElectrobunRenderHandler::OnPaint implementation
-void ElectrobunRenderHandler::OnPaint(CefRefPtr<CefBrowser> browser,
+// SparkBunRenderHandler::OnPaint implementation
+void SparkBunRenderHandler::OnPaint(CefRefPtr<CefBrowser> browser,
                                        PaintElementType type,
                                        const RectList& dirtyRects,
                                        const void* buffer,
@@ -2349,8 +2349,8 @@ void ElectrobunRenderHandler::OnPaint(CefRefPtr<CefBrowser> browser,
     }
 }
 
-// Helper function implementation (defined after ElectrobunCefClient class)
-void SetBrowserOnClient(CefRefPtr<ElectrobunCefClient> client, CefRefPtr<CefBrowser> browser) {
+// Helper function implementation (defined after SparkBunCefClient class)
+void SetBrowserOnClient(CefRefPtr<SparkBunCefClient> client, CefRefPtr<CefBrowser> browser) {
     if (client && browser) {
         client->SetBrowser(browser);
         // Store preload scripts for this browser ID so load handler can access them
@@ -2361,13 +2361,13 @@ void SetBrowserOnClient(CefRefPtr<ElectrobunCefClient> client, CefRefPtr<CefBrow
     }
 }
 
-// ElectrobunLoadHandler method implementations (defined after ElectrobunCefClient class)
-void ElectrobunLoadHandler::OnLoadStart(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, TransitionType transition_type) {
+// SparkBunLoadHandler method implementations (defined after SparkBunCefClient class)
+void SparkBunLoadHandler::OnLoadStart(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, TransitionType transition_type) {
     // NOTE: OnLoadStart is now a fallback - primary injection happens via GetResourceResponseFilter
     // This ensures preload scripts are in the HTML before parsing, guaranteeing execution order
 }
 
-void ElectrobunLoadHandler::OnLoadEnd(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, int httpStatusCode) {
+void SparkBunLoadHandler::OnLoadEnd(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, int httpStatusCode) {
     // Fire did-navigate event
     if (frame->IsMain() && webview_event_handler_) {
         std::string url = frame->GetURL().ToString();
@@ -2380,8 +2380,8 @@ void ElectrobunLoadHandler::OnLoadEnd(CefRefPtr<CefBrowser> browser, CefRefPtr<C
     }
 }
 
-// ElectrobunResourceRequestHandler method implementations (defined after ElectrobunCefClient class)
-CefRefPtr<CefResponseFilter> ElectrobunResourceRequestHandler::GetResourceResponseFilter(
+// SparkBunResourceRequestHandler method implementations (defined after SparkBunCefClient class)
+CefRefPtr<CefResponseFilter> SparkBunResourceRequestHandler::GetResourceResponseFilter(
     CefRefPtr<CefBrowser> browser,
     CefRefPtr<CefFrame> frame,
     CefRefPtr<CefRequest> request,
@@ -2404,7 +2404,7 @@ CefRefPtr<CefResponseFilter> ElectrobunResourceRequestHandler::GetResourceRespon
 
         if (!combinedScript.empty()) {
             std::cout << "[CEF] Installing response filter to inject preload scripts into HTML" << std::endl;
-            return new ElectrobunResponseFilter(combinedScript);
+            return new SparkBunResponseFilter(combinedScript);
         }
     }
 
@@ -2929,7 +2929,7 @@ public:
             bool isBlockRule = !rule.empty() && rule[0] == '^';
             std::string pattern = isBlockRule ? rule.substr(1) : rule;
 
-            if (electrobun::globMatch(pattern, url)) {
+            if (sparkbun::globMatch(pattern, url)) {
                 allowed = !isBlockRule; // Last match wins
             }
         }
@@ -3077,7 +3077,7 @@ private:
 public:
     std::string pendingUrl;
     std::string pendingHtml;  // Stored inline HTML for loading after async creation
-    std::string electrobunScript;
+    std::string sparkbunScript;
     std::string customScript;
     bool isCreationComplete = false;
     WebviewEventHandler webviewEventHandler = nullptr;
@@ -3536,7 +3536,7 @@ double WebView2View::lastCtrlClickTime = 0;
 class CEFView : public AbstractView {
 private:
     CefRefPtr<CefBrowser> browser;
-    CefRefPtr<ElectrobunCefClient> client;
+    CefRefPtr<SparkBunCefClient> client;
     OSRWindow* osr_window;
     bool is_osr_mode;
 
@@ -3749,7 +3749,7 @@ public:
         }
     }
     
-    void setClient(CefRefPtr<ElectrobunCefClient> cl) {
+    void setClient(CefRefPtr<SparkBunCefClient> cl) {
         client = cl;
     }
     
@@ -3757,7 +3757,7 @@ public:
         return browser;
     }
     
-    CefRefPtr<ElectrobunCefClient> getClient() {
+    CefRefPtr<SparkBunCefClient> getClient() {
         return client;
     }
     
@@ -5302,7 +5302,7 @@ static UINT getMenuVirtualKeyCode(const std::string& key) {
 // Parse modifiers from accelerator string for menu accelerators using the
 // shared cross-platform parser. Returns FCONTROL, FALT, FSHIFT flags.
 static BYTE parseMenuModifiers(const std::string& accelerator, std::string& outKey) {
-    auto parts = electrobun::parseAccelerator(accelerator);
+    auto parts = sparkbun::parseAccelerator(accelerator);
     outKey = parts.key;
 
     BYTE modifiers = FVIRTKEY;
@@ -5839,7 +5839,7 @@ void TerminateCEFHelperProcesses() {
     CloseHandle(hSnapshot);
 }
 
-ELECTROBUN_EXPORT bool initCEF() {
+SPARKBUN_EXPORT bool initCEF() {
     if (g_cef_initialized) {
         return true; // Already initialized
     }
@@ -5885,31 +5885,31 @@ ELECTROBUN_EXPORT bool initCEF() {
     std::string userDataDir;
     char* localAppData = getenv("LOCALAPPDATA");
     if (localAppData) {
-        userDataDir = buildAppDataPath(localAppData, g_electrobunIdentifier, g_electrobunChannel, "CEF", '\\');
+        userDataDir = buildAppDataPath(localAppData, g_sparkbunIdentifier, g_sparkbunChannel, "CEF", '\\');
         std::cout << "[CEF] Using path: " << userDataDir << std::endl;
     } else {
         // Fallback to executable directory if LOCALAPPDATA not available
-        userDataDir = buildAppDataPath(exePath, g_electrobunIdentifier, g_electrobunChannel, "cef_cache", '\\');
+        userDataDir = buildAppDataPath(exePath, g_sparkbunIdentifier, g_sparkbunChannel, "cef_cache", '\\');
     }
 
     // Create cache directory if it doesn't exist
     CreateDirectoryA(userDataDir.c_str(), NULL);
 
-    // One-shot wipe if Electrobun's cache format version has been bumped
+    // One-shot wipe if SparkBun's cache format version has been bumped
     // since the user's last launch. See cache_migration.h.
-    electrobun::migrateCacheFolderIfNeeded(userDataDir);
+    sparkbun::migrateCacheFolderIfNeeded(userDataDir);
 
     // Initialize CEF
     CefMainArgs main_args(GetModuleHandle(NULL));
     
     // Create the app
-    g_cef_app = new ElectrobunCefApp();
+    g_cef_app = new SparkBunCefApp();
 
     // Read user-defined chromium flags from build.json
     std::string buildJsonPath = std::string(exePath) + "\\..\\Resources\\build.json";
-    std::string buildJsonContent = electrobun::readFileToString(buildJsonPath);
+    std::string buildJsonContent = sparkbun::readFileToString(buildJsonPath);
     if (!buildJsonContent.empty()) {
-        g_userChromiumFlags = electrobun::parseChromiumFlags(buildJsonContent);
+        g_userChromiumFlags = sparkbun::parseChromiumFlags(buildJsonContent);
     }
 
     // CEF settings
@@ -5948,7 +5948,7 @@ ELECTROBUN_EXPORT bool initCEF() {
     if (success) {
         g_cef_initialized = true;
         // Register the views:// scheme handler factory
-        CefRegisterSchemeHandlerFactory("views", "", new ElectrobunSchemeHandlerFactory());
+        CefRegisterSchemeHandlerFactory("views", "", new SparkBunSchemeHandlerFactory());
         
         // We'll start the message pump timer when we create the first browser
     } else {
@@ -5971,7 +5971,7 @@ static std::shared_ptr<WebView2View> createWebView2View(uint32_t webviewId,
                                                  HandlePostMessage eventBridgeHandler,
                                                  HandlePostMessage bunBridgeHandler,
                                                  HandlePostMessage internalBridgeHandler,
-                                                 const char *electrobunPreloadScript,
+                                                 const char *sparkbunPreloadScript,
                                                  const char *customPreloadScript,
                                                  bool transparent,
                                                  bool sandbox) {
@@ -5991,7 +5991,7 @@ static std::shared_ptr<WebView2View> createWebView2View(uint32_t webviewId,
     
     // Make safe copies of string parameters to avoid memory corruption in lambda captures
     std::string urlString = url ? std::string(url) : "";
-    std::string electrobunScript = electrobunPreloadScript ? std::string(electrobunPreloadScript) : "";
+    std::string sparkbunScript = sparkbunPreloadScript ? std::string(sparkbunPreloadScript) : "";
     std::string customScript = customPreloadScript ? std::string(customPreloadScript) : "";
     std::string partitionStr = partitionIdentifier ? std::string(partitionIdentifier) : "";
 
@@ -6002,7 +6002,7 @@ static std::shared_ptr<WebView2View> createWebView2View(uint32_t webviewId,
 
     // Store URL and scripts in view to survive async callbacks
     view->pendingUrl = urlString;
-    view->electrobunScript = electrobunScript;
+    view->sparkbunScript = sparkbunScript;
     view->customScript = customScript;
 
     // Create WebView2 on main thread
@@ -6233,8 +6233,8 @@ static std::shared_ptr<WebView2View> createWebView2View(uint32_t webviewId,
                             
                             // Add preload scripts
                             std::string combinedScript;
-                            if (!view->electrobunScript.empty()) {
-                                combinedScript += view->electrobunScript;
+                            if (!view->sparkbunScript.empty()) {
+                                combinedScript += view->sparkbunScript;
                             }
                             if (!view->customScript.empty()) {
                                 if (!combinedScript.empty()) {
@@ -6695,7 +6695,7 @@ static std::shared_ptr<WebView2View> createWebView2View(uint32_t webviewId,
             std::wstring userDataFolder;
             char* localAppData = getenv("LOCALAPPDATA");
             if (localAppData) {
-                std::string userDataPath = buildAppDataPath(localAppData, g_electrobunIdentifier, g_electrobunChannel, "WebView2", '\\');
+                std::string userDataPath = buildAppDataPath(localAppData, g_sparkbunIdentifier, g_sparkbunChannel, "WebView2", '\\');
 
                 // Handle partition-specific storage
                 if (!partitionStr.empty()) {
@@ -6753,7 +6753,7 @@ static std::shared_ptr<WebView2View> createWebView2View(uint32_t webviewId,
 // cache_path for a persistent partition under %LOCALAPPDATA%, creating any
 // missing parent directories. Returns "" if %LOCALAPPDATA% is unset, which
 // causes the caller to fall back to an ephemeral context.
-namespace electrobun {
+namespace sparkbun {
 std::string buildAndEnsurePartitionCachePath(const std::string& partitionName) {
     char* localAppData = getenv("LOCALAPPDATA");
     if (!localAppData) {
@@ -6761,18 +6761,18 @@ std::string buildAndEnsurePartitionCachePath(const std::string& partitionName) {
         return "";
     }
     std::string cachePath = buildCEFPartitionPath(
-        localAppData, g_electrobunIdentifier, g_electrobunChannel, "CEF", partitionName, '\\');
+        localAppData, g_sparkbunIdentifier, g_sparkbunChannel, "CEF", partitionName, '\\');
     std::wstring wideCachePath(cachePath.begin(), cachePath.end());
     SHCreateDirectoryExW(NULL, wideCachePath.c_str(), NULL);
     return cachePath;
 }
-} // namespace electrobun
+} // namespace sparkbun
 
 CefRefPtr<CefRequestContext> CreateRequestContextForPartition(const char* partitionIdentifier,
                                                                uint32_t webviewId) {
-    static CefRefPtr<ElectrobunSchemeHandlerFactory> schemeFactory =
-        new ElectrobunSchemeHandlerFactory();
-    return electrobun::getOrCreateRequestContextForPartition(
+    static CefRefPtr<SparkBunSchemeHandlerFactory> schemeFactory =
+        new SparkBunSchemeHandlerFactory();
+    return sparkbun::getOrCreateRequestContextForPartition(
         partitionIdentifier, webviewId, schemeFactory);
 }
 
@@ -6789,7 +6789,7 @@ static std::shared_ptr<CEFView> createCEFView(uint32_t webviewId,
                                        HandlePostMessage eventBridgeHandler,
                                        HandlePostMessage bunBridgeHandler,
                                        HandlePostMessage internalBridgeHandler,
-                                       const char *electrobunPreloadScript,
+                                       const char *sparkbunPreloadScript,
                                        const char *customPreloadScript,
                                        bool transparent,
                                        bool sandbox) {
@@ -6831,7 +6831,7 @@ static std::shared_ptr<CEFView> createCEFView(uint32_t webviewId,
         }
 
         // Create CEF client with bridge handlers
-        auto client = new ElectrobunCefClient(webviewId, eventBridgeHandler, bunBridgeHandler, internalBridgeHandler, sandbox);
+        auto client = new SparkBunCefClient(webviewId, eventBridgeHandler, bunBridgeHandler, internalBridgeHandler, sandbox);
 
         // Configure OSR mode for transparent windows
         if (transparent) {
@@ -6852,8 +6852,8 @@ static std::shared_ptr<CEFView> createCEFView(uint32_t webviewId,
         }
         
         // Set up preload scripts
-        if (electrobunPreloadScript && strlen(electrobunPreloadScript) > 0) {
-            client->AddPreloadScript(std::string(electrobunPreloadScript));
+        if (sparkbunPreloadScript && strlen(sparkbunPreloadScript) > 0) {
+            client->AddPreloadScript(std::string(sparkbunPreloadScript));
         }
         if (customPreloadScript && strlen(customPreloadScript) > 0) {
             client->UpdateCustomPreloadScript(std::string(customPreloadScript));
@@ -6999,18 +6999,18 @@ BOOL WINAPI ConsoleControlHandler(DWORD dwCtrlType) {
 
 extern "C" {
 
-ELECTROBUN_EXPORT void startEventLoop(const char* identifier, const char* name, const char* channel) {
+SPARKBUN_EXPORT void startEventLoop(const char* identifier, const char* name, const char* channel) {
     g_mainThreadId = GetCurrentThreadId();
 
     // Store identifier, name, and channel globally for use in CEF initialization
     if (identifier && identifier[0]) {
-        g_electrobunIdentifier = std::string(identifier);
+        g_sparkbunIdentifier = std::string(identifier);
     }
     if (name && name[0]) {
-        g_electrobunName = std::string(name);
+        g_sparkbunName = std::string(name);
     }
     if (channel && channel[0]) {
-        g_electrobunChannel = std::string(channel);
+        g_sparkbunChannel = std::string(channel);
     }
 
     // Set up console control handler for graceful shutdown on Ctrl+C
@@ -7119,7 +7119,7 @@ ELECTROBUN_EXPORT void startEventLoop(const char* identifier, const char* name,
 }
 
 
-ELECTROBUN_EXPORT void stopEventLoop() {
+SPARKBUN_EXPORT void stopEventLoop() {
     if (g_eventLoopStopping.exchange(true)) {
         return;
     }
@@ -7138,12 +7138,12 @@ ELECTROBUN_EXPORT void stopEventLoop() {
     }
 }
 
-ELECTROBUN_EXPORT void killApp() {
+SPARKBUN_EXPORT void killApp() {
     // Deprecated - delegates to stopEventLoop for backward compatibility
     stopEventLoop();
 }
 
-ELECTROBUN_EXPORT void waitForShutdownComplete(int timeoutMs) {
+SPARKBUN_EXPORT void waitForShutdownComplete(int timeoutMs) {
     int waited = 0;
     while (!g_shutdownComplete.load() && waited < timeoutMs) {
         Sleep(10);
@@ -7151,15 +7151,15 @@ ELECTROBUN_EXPORT void waitForShutdownComplete(int timeoutMs) {
     }
 }
 
-ELECTROBUN_EXPORT void forceExit(int code) {
+SPARKBUN_EXPORT void forceExit(int code) {
     _exit(code);
 }
 
-ELECTROBUN_EXPORT void setQuitRequestedHandler(QuitRequestedHandler handler) {
+SPARKBUN_EXPORT void setQuitRequestedHandler(QuitRequestedHandler handler) {
     g_quitRequestedHandler = handler;
 }
 
-ELECTROBUN_EXPORT void shutdownApplication() {
+SPARKBUN_EXPORT void shutdownApplication() {
     // Deprecated - use stopEventLoop() instead
     stopEventLoop();
 }
@@ -7170,13 +7170,13 @@ static struct {
     bool startPassthrough;
 } g_nextWebviewFlags = {false, false};
 
-ELECTROBUN_EXPORT void setNextWebviewFlags(bool startTransparent, bool startPassthrough) {
+SPARKBUN_EXPORT void setNextWebviewFlags(bool startTransparent, bool startPassthrough) {
     g_nextWebviewFlags.startTransparent = startTransparent;
     g_nextWebviewFlags.startPassthrough = startPassthrough;
 }
 
 // Clean, elegant initWebview function - Windows version matching Mac pattern
-ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
+SPARKBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
                          NSWindow *window,  // Actually HWND on Windows
                          const char *renderer,
                          const char *url,
@@ -7189,7 +7189,7 @@ ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
                          HandlePostMessage eventBridgeHandler,
                          HandlePostMessage bunBridgeHandler,
                          HandlePostMessage internalBridgeHandler,
-                         const char *electrobunPreloadScript,
+                         const char *sparkbunPreloadScript,
                          const char *customPreloadScript,
                          const char *viewsRoot,
                          bool transparent,
@@ -7213,13 +7213,13 @@ ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
         auto cefView = createCEFView(webviewId, hwnd, url, x, y, width, height, autoResize,
                                     partitionIdentifier, navigationCallback, webviewEventHandler,
                                     eventBridgeHandler, bunBridgeHandler, internalBridgeHandler,
-                                    electrobunPreloadScript, customPreloadScript, transparent, sandbox);
+                                    sparkbunPreloadScript, customPreloadScript, transparent, sandbox);
         view = cefView.get();
     } else {
         auto webview2View = createWebView2View(webviewId, hwnd, url, x, y, width, height, autoResize,
                                               partitionIdentifier, navigationCallback, webviewEventHandler,
                                               eventBridgeHandler, bunBridgeHandler, internalBridgeHandler,
-                                              electrobunPreloadScript, customPreloadScript, transparent, sandbox);
+                                              sparkbunPreloadScript, customPreloadScript, transparent, sandbox);
         view = webview2View.get();
     }
 
@@ -7237,7 +7237,7 @@ ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
 
 }
 
-ELECTROBUN_EXPORT AbstractView* initWGPUView(uint32_t webviewId,
+SPARKBUN_EXPORT AbstractView* initWGPUView(uint32_t webviewId,
                          NSWindow *window,  // Actually HWND on Windows
                          double x, double y,
                          double width, double height,
@@ -7319,7 +7319,7 @@ ELECTROBUN_EXPORT AbstractView* initWGPUView(uint32_t webviewId,
     return view.get();
 }
 
-ELECTROBUN_EXPORT MyScriptMessageHandlerWithReply* addScriptMessageHandlerWithReply(WKWebView *webView,
+SPARKBUN_EXPORT MyScriptMessageHandlerWithReply* addScriptMessageHandlerWithReply(WKWebView *webView,
                                                               uint32_t webviewId,
                                                               const char *name,
                                                               HandlePostMessageWithReply callback) {
@@ -7329,7 +7329,7 @@ ELECTROBUN_EXPORT MyScriptMessageHandlerWithReply* addScriptMessageHandlerWithRe
     handler->webviewId = webviewId;
     return handler;
 }
-ELECTROBUN_EXPORT void loadURLInWebView(AbstractView *abstractView, const char *urlString) {
+SPARKBUN_EXPORT void loadURLInWebView(AbstractView *abstractView, const char *urlString) {
     if (!abstractView || !urlString) {
         ::log("ERROR: Invalid parameters passed to loadURLInWebView");
         return;
@@ -7340,7 +7340,7 @@ ELECTROBUN_EXPORT void loadURLInWebView(AbstractView *abstractView, const char *
     abstractView->loadURL(urlString);
 }
 
-ELECTROBUN_EXPORT void wgpuViewSetFrame(AbstractView *abstractView, double x, double y, double width, double height) {
+SPARKBUN_EXPORT void wgpuViewSetFrame(AbstractView *abstractView, double x, double y, double width, double height) {
     if (!abstractView) return;
     RECT bounds = {(LONG)x, (LONG)y, (LONG)(x + width), (LONG)(y + height)};
     abstractView->storePendingResize(bounds, "");
@@ -7348,28 +7348,28 @@ ELECTROBUN_EXPORT void wgpuViewSetFrame(AbstractView *abstractView, double x, do
     schedulePendingResizeDrain();
 }
 
-ELECTROBUN_EXPORT void wgpuViewSetTransparent(AbstractView *abstractView, BOOL transparent) {
+SPARKBUN_EXPORT void wgpuViewSetTransparent(AbstractView *abstractView, BOOL transparent) {
     if (!abstractView) return;
     MainThreadDispatcher::dispatch_sync([abstractView, transparent]() {
         abstractView->setTransparent(transparent);
     });
 }
 
-ELECTROBUN_EXPORT void wgpuViewSetPassthrough(AbstractView *abstractView, BOOL enablePassthrough) {
+SPARKBUN_EXPORT void wgpuViewSetPassthrough(AbstractView *abstractView, BOOL enablePassthrough) {
     if (!abstractView) return;
     MainThreadDispatcher::dispatch_sync([abstractView, enablePassthrough]() {
         abstractView->setPassthrough(enablePassthrough);
     });
 }
 
-ELECTROBUN_EXPORT void wgpuViewSetHidden(AbstractView *abstractView, BOOL hidden) {
+SPARKBUN_EXPORT void wgpuViewSetHidden(AbstractView *abstractView, BOOL hidden) {
     if (!abstractView) return;
     MainThreadDispatcher::dispatch_sync([abstractView, hidden]() {
         abstractView->setHidden(hidden);
     });
 }
 
-ELECTROBUN_EXPORT void wgpuViewRemove(AbstractView *abstractView) {
+SPARKBUN_EXPORT void wgpuViewRemove(AbstractView *abstractView) {
     if (!abstractView) return;
     uint32_t viewId = abstractView->webviewId;
     MainThreadDispatcher::dispatch_sync([abstractView]() {
@@ -7381,7 +7381,7 @@ ELECTROBUN_EXPORT void wgpuViewRemove(AbstractView *abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void* wgpuViewGetNativeHandle(AbstractView *abstractView) {
+SPARKBUN_EXPORT void* wgpuViewGetNativeHandle(AbstractView *abstractView) {
     if (!abstractView) return nullptr;
     return abstractView->hwnd;
 }
@@ -8128,7 +8128,7 @@ static void gpuTestRequestDeviceCallback(WGPURequestDeviceStatus status, WGPUDev
     state->device = device;
 
     if (p_wgpuDeviceSetLabel) {
-        WGPUStringView label = { "Electrobun WGPU Device", WGPU_STRLEN };
+        WGPUStringView label = { "SparkBun WGPU Device", WGPU_STRLEN };
         p_wgpuDeviceSetLabel(device, label);
     }
     state->queue = p_wgpuDeviceGetQueue(device);
@@ -8159,7 +8159,7 @@ static void runOnMainThreadSyncVoid(std::function<void()> fn) {
     MainThreadDispatcher::dispatch_sync([&]() { fn(); });
 }
 
-ELECTROBUN_EXPORT void* wgpuInstanceCreateSurfaceMainThread(void* instance, void* descriptor) {
+SPARKBUN_EXPORT void* wgpuInstanceCreateSurfaceMainThread(void* instance, void* descriptor) {
     if (!ensureWgpuSymbols()) return nullptr;
     return runOnMainThreadSyncPtr([&]() -> void* {
         return p_wgpuInstanceCreateSurface(instance, descriptor);
@@ -8170,7 +8170,7 @@ ELECTROBUN_EXPORT void* wgpuInstanceCreateSurfaceMainThread(void* instance, void
 static std::map<void*, HWND> g_surfaceToHwnd;
 static std::mutex g_surfaceToHwndMutex;
 
-ELECTROBUN_EXPORT void* wgpuCreateSurfaceForView(void* wgpuInstance, AbstractView* abstractView) {
+SPARKBUN_EXPORT void* wgpuCreateSurfaceForView(void* wgpuInstance, AbstractView* abstractView) {
     if (!wgpuInstance || !abstractView || !abstractView->hwnd) {
         printf("[WGPU] createSurfaceForView: null check failed (inst=%p view=%p hwnd=%p)\n",
                wgpuInstance, abstractView, abstractView ? abstractView->hwnd : nullptr);
@@ -8434,7 +8434,7 @@ static bool initDCompBridgeForSurface(void* surface, void* devicePtr, uint32_t w
     return true;
 }
 
-ELECTROBUN_EXPORT void wgpuSurfaceConfigureMainThread(void* surface, void* config) {
+SPARKBUN_EXPORT void wgpuSurfaceConfigureMainThread(void* surface, void* config) {
     if (!ensureWgpuSymbols()) return;
     runOnMainThreadSyncVoid([&]() { p_wgpuSurfaceConfigure(surface, config); });
 
@@ -8466,7 +8466,7 @@ ELECTROBUN_EXPORT void wgpuSurfaceConfigureMainThread(void* surface, void* confi
     initDCompBridgeForSurface(surface, devicePtr, width, height);
 }
 
-ELECTROBUN_EXPORT void wgpuSurfaceGetCurrentTextureMainThread(void* surface, void* surfaceTexture) {
+SPARKBUN_EXPORT void wgpuSurfaceGetCurrentTextureMainThread(void* surface, void* surfaceTexture) {
     if (!ensureWgpuSymbols()) return;
 
     // Check for DComp bridge
@@ -8539,7 +8539,7 @@ ELECTROBUN_EXPORT void wgpuSurfaceGetCurrentTextureMainThread(void* surface, voi
     runOnMainThreadSyncVoid([&]() { p_wgpuSurfaceGetCurrentTexture(surface, surfaceTexture); });
 }
 
-ELECTROBUN_EXPORT int32_t wgpuSurfacePresentMainThread(void* surface) {
+SPARKBUN_EXPORT int32_t wgpuSurfacePresentMainThread(void* surface) {
     if (!ensureWgpuSymbols()) return 0;
 
     // Check for DComp bridge
@@ -8657,7 +8657,7 @@ ELECTROBUN_EXPORT int32_t wgpuSurfacePresentMainThread(void* surface) {
     });
 }
 
-ELECTROBUN_EXPORT uint64_t wgpuQueueOnSubmittedWorkDoneShim(void* queue, void* callbackInfo) {
+SPARKBUN_EXPORT uint64_t wgpuQueueOnSubmittedWorkDoneShim(void* queue, void* callbackInfo) {
     if (!ensureWgpuSymbols()) return 0;
     if (!callbackInfo) return 0;
     WGPUQueueWorkDoneCallbackInfo info = *(WGPUQueueWorkDoneCallbackInfo*)callbackInfo;
@@ -8665,7 +8665,7 @@ ELECTROBUN_EXPORT uint64_t wgpuQueueOnSubmittedWorkDoneShim(void* queue, void* c
     return future.id;
 }
 
-ELECTROBUN_EXPORT uint64_t wgpuBufferMapAsyncShim(void* buffer, uint64_t mode, uint64_t offset, uint64_t size, void* callbackInfo) {
+SPARKBUN_EXPORT uint64_t wgpuBufferMapAsyncShim(void* buffer, uint64_t mode, uint64_t offset, uint64_t size, void* callbackInfo) {
     if (!ensureWgpuSymbols()) return 0;
     if (!callbackInfo) return 0;
     WGPUBufferMapCallbackInfo info = *(WGPUBufferMapCallbackInfo*)callbackInfo;
@@ -8673,7 +8673,7 @@ ELECTROBUN_EXPORT uint64_t wgpuBufferMapAsyncShim(void* buffer, uint64_t mode, u
     return future.id;
 }
 
-ELECTROBUN_EXPORT int32_t wgpuInstanceWaitAnyShim(void* instance, uint64_t futureId, uint64_t timeoutNS) {
+SPARKBUN_EXPORT int32_t wgpuInstanceWaitAnyShim(void* instance, uint64_t futureId, uint64_t timeoutNS) {
     if (!ensureWgpuSymbols()) return 0;
     if (!instance || !futureId) return 0;
     WGPUFutureWaitInfo info;
@@ -8684,7 +8684,7 @@ ELECTROBUN_EXPORT int32_t wgpuInstanceWaitAnyShim(void* instance, uint64_t futur
     return 0;
 }
 
-ELECTROBUN_EXPORT uint8_t* wgpuBufferReadSyncShim(
+SPARKBUN_EXPORT uint8_t* wgpuBufferReadSyncShim(
     void* instance,
     void* buffer,
     uint64_t offset,
@@ -8741,7 +8741,7 @@ ELECTROBUN_EXPORT uint8_t* wgpuBufferReadSyncShim(
     return out;
 }
 
-ELECTROBUN_EXPORT int32_t wgpuBufferReadSyncIntoShim(
+SPARKBUN_EXPORT int32_t wgpuBufferReadSyncIntoShim(
     void* instance,
     void* buffer,
     uint64_t offset,
@@ -8836,7 +8836,7 @@ static void wgpuReadbackCallback(
     job->done.store(1);
 }
 
-ELECTROBUN_EXPORT void* wgpuBufferReadbackBeginShim(
+SPARKBUN_EXPORT void* wgpuBufferReadbackBeginShim(
     void* buffer,
     uint64_t offset,
     uint64_t size,
@@ -8872,20 +8872,20 @@ ELECTROBUN_EXPORT void* wgpuBufferReadbackBeginShim(
     return job;
 }
 
-ELECTROBUN_EXPORT int32_t wgpuBufferReadbackStatusShim(void* jobPtr) {
+SPARKBUN_EXPORT int32_t wgpuBufferReadbackStatusShim(void* jobPtr) {
     if (!jobPtr) return 2;
     WGPUReadbackJob* job = (WGPUReadbackJob*)jobPtr;
     if (job->done.load() == 0) return 0;
     return job->status.load();
 }
 
-ELECTROBUN_EXPORT void wgpuBufferReadbackFreeShim(void* jobPtr) {
+SPARKBUN_EXPORT void wgpuBufferReadbackFreeShim(void* jobPtr) {
     if (!jobPtr) return;
     WGPUReadbackJob* job = (WGPUReadbackJob*)jobPtr;
     free(job);
 }
 
-ELECTROBUN_EXPORT void wgpuRunGPUTest(void* abstractView) {
+SPARKBUN_EXPORT void wgpuRunGPUTest(void* abstractView) {
     wgpu_log("WGPU test: wgpuRunGPUTest called, abstractView=%p", abstractView);
     if (!abstractView) {
         wgpu_log("WGPU test: abstractView is null, aborting");
@@ -8952,7 +8952,7 @@ ELECTROBUN_EXPORT void wgpuRunGPUTest(void* abstractView) {
     });
 }
 
-ELECTROBUN_EXPORT void wgpuToggleGPUTestShader(void* abstractView) {
+SPARKBUN_EXPORT void wgpuToggleGPUTestShader(void* abstractView) {
     if (!abstractView) return;
     if (!ensureWgpuTestSymbols()) return;
 
@@ -8965,7 +8965,7 @@ ELECTROBUN_EXPORT void wgpuToggleGPUTestShader(void* abstractView) {
     });
 }
 
-ELECTROBUN_EXPORT void wgpuCreateAdapterDeviceMainThread(void* instancePtr, void* surfacePtr, void* outAdapterDevice) {
+SPARKBUN_EXPORT void wgpuCreateAdapterDeviceMainThread(void* instancePtr, void* surfacePtr, void* outAdapterDevice) {
     printf("[WGPU] createAdapterDeviceMainThread: instance=%p surface=%p\n", instancePtr, surfacePtr);
     if (!ensureWgpuTestSymbols()) { printf("[WGPU] createAdapterDeviceMainThread: ensureWgpuTestSymbols FAILED\n"); return; }
     MainThreadDispatcher::dispatch_sync([instancePtr, surfacePtr, outAdapterDevice]() {
@@ -9061,7 +9061,7 @@ ELECTROBUN_EXPORT void wgpuCreateAdapterDeviceMainThread(void* instancePtr, void
     });
 }
 
-ELECTROBUN_EXPORT void loadHTMLInWebView(AbstractView *abstractView, const char *htmlString) {
+SPARKBUN_EXPORT void loadHTMLInWebView(AbstractView *abstractView, const char *htmlString) {
     if (!abstractView || !htmlString) {
         ::log("ERROR: Invalid parameters passed to loadHTMLInWebView");
         return;
@@ -9070,7 +9070,7 @@ ELECTROBUN_EXPORT void loadHTMLInWebView(AbstractView *abstractView, const char
     abstractView->loadHTML(htmlString);
 }
 
-ELECTROBUN_EXPORT void webviewGoBack(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewGoBack(AbstractView *abstractView) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView or webview in webviewGoBack");
         return;
@@ -9079,7 +9079,7 @@ ELECTROBUN_EXPORT void webviewGoBack(AbstractView *abstractView) {
     abstractView->goBack();
 }
 
-ELECTROBUN_EXPORT void webviewGoForward(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewGoForward(AbstractView *abstractView) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView or webview in webviewGoForward");
         return;
@@ -9088,7 +9088,7 @@ ELECTROBUN_EXPORT void webviewGoForward(AbstractView *abstractView) {
     abstractView->goForward();
 }
 
-ELECTROBUN_EXPORT void webviewReload(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewReload(AbstractView *abstractView) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView or webview in webviewReload");
         return;
@@ -9097,7 +9097,7 @@ ELECTROBUN_EXPORT void webviewReload(AbstractView *abstractView) {
     abstractView->reload();
 }
 
-ELECTROBUN_EXPORT void webviewRemove(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewRemove(AbstractView *abstractView) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView in webviewRemove");
         return;
@@ -9106,7 +9106,7 @@ ELECTROBUN_EXPORT void webviewRemove(AbstractView *abstractView) {
     abstractView->remove();
 }
 
-ELECTROBUN_EXPORT BOOL webviewCanGoBack(AbstractView *abstractView) {
+SPARKBUN_EXPORT BOOL webviewCanGoBack(AbstractView *abstractView) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView or webview in webviewCanGoBack");
         return FALSE;
@@ -9115,7 +9115,7 @@ ELECTROBUN_EXPORT BOOL webviewCanGoBack(AbstractView *abstractView) {
     return abstractView->canGoBack();
 }
 
-ELECTROBUN_EXPORT BOOL webviewCanGoForward(AbstractView *abstractView) {
+SPARKBUN_EXPORT BOOL webviewCanGoForward(AbstractView *abstractView) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView or webview in webviewCanGoForward");
         return FALSE;
@@ -9124,7 +9124,7 @@ ELECTROBUN_EXPORT BOOL webviewCanGoForward(AbstractView *abstractView) {
     return abstractView->canGoForward();
 }
 
-ELECTROBUN_EXPORT void evaluateJavaScriptWithNoCompletion(AbstractView *abstractView, const char *script) {
+SPARKBUN_EXPORT void evaluateJavaScriptWithNoCompletion(AbstractView *abstractView, const char *script) {
     if (!abstractView || !script) {
         ::log("ERROR: Invalid parameters passed to evaluateJavaScriptWithNoCompletion");
         return;
@@ -9134,11 +9134,11 @@ ELECTROBUN_EXPORT void evaluateJavaScriptWithNoCompletion(AbstractView *abstract
     
 }
 
-ELECTROBUN_EXPORT void testFFI(void *ptr) {
+SPARKBUN_EXPORT void testFFI(void *ptr) {
     // Stub implementation
 }
 
-ELECTROBUN_EXPORT void callAsyncJavaScript(const char *messageId,
+SPARKBUN_EXPORT void callAsyncJavaScript(const char *messageId,
                         AbstractView *abstractView,
                         const char *jsString,
                         uint32_t webviewId,
@@ -9150,7 +9150,7 @@ ELECTROBUN_EXPORT void callAsyncJavaScript(const char *messageId,
     }
 }
 
-ELECTROBUN_EXPORT void addPreloadScriptToWebView(AbstractView *abstractView, const char *scriptContent, BOOL forMainFrameOnly) {
+SPARKBUN_EXPORT void addPreloadScriptToWebView(AbstractView *abstractView, const char *scriptContent, BOOL forMainFrameOnly) {
     if (abstractView && scriptContent) {
         MainThreadDispatcher::dispatch_sync([abstractView, scriptContent]() {
             abstractView->addPreloadScriptToWebView(scriptContent);
@@ -9158,7 +9158,7 @@ ELECTROBUN_EXPORT void addPreloadScriptToWebView(AbstractView *abstractView, con
     }
 }
 
-ELECTROBUN_EXPORT void updatePreloadScriptToWebView(AbstractView *abstractView,
+SPARKBUN_EXPORT void updatePreloadScriptToWebView(AbstractView *abstractView,
                                  const char *scriptIdentifier,
                                  const char *scriptContent,
                                  BOOL forMainFrameOnly) {
@@ -9169,26 +9169,26 @@ ELECTROBUN_EXPORT void updatePreloadScriptToWebView(AbstractView *abstractView,
     }
 }
 
-ELECTROBUN_EXPORT void invokeDecisionHandler(void (*decisionHandler)(int), int policy) {
+SPARKBUN_EXPORT void invokeDecisionHandler(void (*decisionHandler)(int), int policy) {
     // Stub implementation
     if (decisionHandler) {
         decisionHandler(policy);
     }
 }
 
-ELECTROBUN_EXPORT const char* getUrlFromNavigationAction(void *navigationAction) {
+SPARKBUN_EXPORT const char* getUrlFromNavigationAction(void *navigationAction) {
     // Stub implementation
     static const char* defaultUrl = "about:blank";
     return defaultUrl;
 }
 
-ELECTROBUN_EXPORT const char* getBodyFromScriptMessage(void *message) {
+SPARKBUN_EXPORT const char* getBodyFromScriptMessage(void *message) {
     // Stub implementation
     static const char* emptyString = "";
     return emptyString;
 }
 
-ELECTROBUN_EXPORT void webviewSetTransparent(AbstractView *abstractView, BOOL transparent) {
+SPARKBUN_EXPORT void webviewSetTransparent(AbstractView *abstractView, BOOL transparent) {
     if (abstractView) {
         // UI operations must be performed on the main thread
         MainThreadDispatcher::dispatch_sync([abstractView, transparent]() {
@@ -9197,7 +9197,7 @@ ELECTROBUN_EXPORT void webviewSetTransparent(AbstractView *abstractView, BOOL tr
     }
 }
 
-ELECTROBUN_EXPORT void webviewSetPassthrough(AbstractView *abstractView, BOOL enablePassthrough) {
+SPARKBUN_EXPORT void webviewSetPassthrough(AbstractView *abstractView, BOOL enablePassthrough) {
     if (abstractView) {
         // UI operations must be performed on the main thread
         MainThreadDispatcher::dispatch_sync([abstractView, enablePassthrough]() {
@@ -9206,7 +9206,7 @@ ELECTROBUN_EXPORT void webviewSetPassthrough(AbstractView *abstractView, BOOL en
     }
 }
 
-ELECTROBUN_EXPORT void webviewSetHidden(AbstractView *abstractView, BOOL hidden) {
+SPARKBUN_EXPORT void webviewSetHidden(AbstractView *abstractView, BOOL hidden) {
     if (abstractView) {
         // UI operations must be performed on the main thread
         MainThreadDispatcher::dispatch_sync([abstractView, hidden]() {
@@ -9215,7 +9215,7 @@ ELECTROBUN_EXPORT void webviewSetHidden(AbstractView *abstractView, BOOL hidden)
     }
 }
 
-ELECTROBUN_EXPORT void setWebviewNavigationRules(AbstractView *abstractView, const char *rulesJson) {
+SPARKBUN_EXPORT void setWebviewNavigationRules(AbstractView *abstractView, const char *rulesJson) {
     if (abstractView) {
         // UI operations must be performed on the main thread
         MainThreadDispatcher::dispatch_sync([abstractView, rulesJson]() {
@@ -9224,7 +9224,7 @@ ELECTROBUN_EXPORT void setWebviewNavigationRules(AbstractView *abstractView, con
     }
 }
 
-ELECTROBUN_EXPORT void webviewFindInPage(AbstractView *abstractView, const char *searchText, bool forward, bool matchCase) {
+SPARKBUN_EXPORT void webviewFindInPage(AbstractView *abstractView, const char *searchText, bool forward, bool matchCase) {
     if (abstractView) {
         MainThreadDispatcher::dispatch_sync([abstractView, searchText, forward, matchCase]() {
             abstractView->findInPage(searchText, forward, matchCase);
@@ -9250,7 +9250,7 @@ void toggleRemoteDevTools(uint32_t webviewId) {
     openRemoteDevTools(webviewId);
 }
 
-ELECTROBUN_EXPORT void webviewStopFind(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewStopFind(AbstractView *abstractView) {
     if (abstractView) {
         MainThreadDispatcher::dispatch_sync([abstractView]() {
             abstractView->stopFindInPage();
@@ -9258,7 +9258,7 @@ ELECTROBUN_EXPORT void webviewStopFind(AbstractView *abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewOpenDevTools(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewOpenDevTools(AbstractView *abstractView) {
     if (abstractView) {
         MainThreadDispatcher::dispatch_sync([abstractView]() {
             abstractView->openDevTools();
@@ -9266,7 +9266,7 @@ ELECTROBUN_EXPORT void webviewOpenDevTools(AbstractView *abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewCloseDevTools(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewCloseDevTools(AbstractView *abstractView) {
     if (abstractView) {
         MainThreadDispatcher::dispatch_sync([abstractView]() {
             abstractView->closeDevTools();
@@ -9274,7 +9274,7 @@ ELECTROBUN_EXPORT void webviewCloseDevTools(AbstractView *abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewToggleDevTools(AbstractView *abstractView) {
+SPARKBUN_EXPORT void webviewToggleDevTools(AbstractView *abstractView) {
     if (abstractView) {
         MainThreadDispatcher::dispatch_sync([abstractView]() {
             abstractView->toggleDevTools();
@@ -9282,23 +9282,23 @@ ELECTROBUN_EXPORT void webviewToggleDevTools(AbstractView *abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewSetPageZoom(AbstractView *abstractView, double zoomLevel) {
+SPARKBUN_EXPORT void webviewSetPageZoom(AbstractView *abstractView, double zoomLevel) {
     // pageZoom is WebKit-specific, not available on Windows
     // TODO: implement WebView2 zoom if needed
 }
 
-ELECTROBUN_EXPORT double webviewGetPageZoom(AbstractView *abstractView) {
+SPARKBUN_EXPORT double webviewGetPageZoom(AbstractView *abstractView) {
     // pageZoom is WebKit-specific, not available on Windows
     return 1.0;
 }
 
-ELECTROBUN_EXPORT NSRect createNSRectWrapper(double x, double y, double width, double height) {
+SPARKBUN_EXPORT NSRect createNSRectWrapper(double x, double y, double width, double height) {
     // Stub implementation
     NSRect rect = {x, y, width, height};
     return rect;
 }
 
-ELECTROBUN_EXPORT NSWindow* createNSWindowWithFrameAndStyle(uint32_t windowId,
+SPARKBUN_EXPORT NSWindow* createNSWindowWithFrameAndStyle(uint32_t windowId,
                                          createNSWindowWithFrameAndStyleParams config,
                                          WindowCloseHandler zigCloseHandler,
                                          WindowMoveHandler zigMoveHandler,
@@ -9310,14 +9310,14 @@ ELECTROBUN_EXPORT NSWindow* createNSWindowWithFrameAndStyle(uint32_t windowId,
     return new NSWindow();
 }
 
-ELECTROBUN_EXPORT void testFFI2(void (*completionHandler)()) {
+SPARKBUN_EXPORT void testFFI2(void (*completionHandler)()) {
     // Stub implementation
     if (completionHandler) {
         completionHandler();
     }
 }
 
-ELECTROBUN_EXPORT HWND createWindowWithFrameAndStyleFromWorker(
+SPARKBUN_EXPORT HWND createWindowWithFrameAndStyleFromWorker(
     uint32_t windowId,
     double x, double y,
     double width, double height,
@@ -9484,7 +9484,7 @@ static void activateVisibleWindow(HWND hwnd) {
                 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
 }
 
-ELECTROBUN_EXPORT void showWindow(void *window, bool activate) {
+SPARKBUN_EXPORT void showWindow(void *window, bool activate) {
     // On Windows, window ptr is actually HWND
     HWND hwnd = reinterpret_cast<HWND>(window);
 
@@ -9510,7 +9510,7 @@ ELECTROBUN_EXPORT void showWindow(void *window, bool activate) {
     });
 }
 
-ELECTROBUN_EXPORT void activateWindow(void *window) {
+SPARKBUN_EXPORT void activateWindow(void *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9523,7 +9523,7 @@ ELECTROBUN_EXPORT void activateWindow(void *window) {
     });
 }
 
-ELECTROBUN_EXPORT void hideWindow(void *window) {
+SPARKBUN_EXPORT void hideWindow(void *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9536,7 +9536,7 @@ ELECTROBUN_EXPORT void hideWindow(void *window) {
     });
 }
 
-ELECTROBUN_EXPORT void setWindowTitle(NSWindow *window, const char *title) {
+SPARKBUN_EXPORT void setWindowTitle(NSWindow *window, const char *title) {
     // On Windows, NSWindow* is actually HWND
     HWND hwnd = reinterpret_cast<HWND>(window);
 
@@ -9579,7 +9579,7 @@ ELECTROBUN_EXPORT void setWindowTitle(NSWindow *window, const char *title) {
     });
 }
 
-ELECTROBUN_EXPORT void closeWindow(NSWindow *window) {
+SPARKBUN_EXPORT void closeWindow(NSWindow *window) {
     // On Windows, NSWindow* is actually HWND
     HWND hwnd = reinterpret_cast<HWND>(window);
 
@@ -9620,7 +9620,7 @@ ELECTROBUN_EXPORT void closeWindow(NSWindow *window) {
     });
 }
 
-ELECTROBUN_EXPORT void minimizeWindow(NSWindow *window) {
+SPARKBUN_EXPORT void minimizeWindow(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9633,7 +9633,7 @@ ELECTROBUN_EXPORT void minimizeWindow(NSWindow *window) {
     });
 }
 
-ELECTROBUN_EXPORT void restoreWindow(NSWindow *window) {
+SPARKBUN_EXPORT void restoreWindow(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9646,7 +9646,7 @@ ELECTROBUN_EXPORT void restoreWindow(NSWindow *window) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowMinimized(NSWindow *window) {
+SPARKBUN_EXPORT bool isWindowMinimized(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9656,7 +9656,7 @@ ELECTROBUN_EXPORT bool isWindowMinimized(NSWindow *window) {
     return IsIconic(hwnd) != 0;
 }
 
-ELECTROBUN_EXPORT void maximizeWindow(NSWindow *window) {
+SPARKBUN_EXPORT void maximizeWindow(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9669,7 +9669,7 @@ ELECTROBUN_EXPORT void maximizeWindow(NSWindow *window) {
     });
 }
 
-ELECTROBUN_EXPORT void unmaximizeWindow(NSWindow *window) {
+SPARKBUN_EXPORT void unmaximizeWindow(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9682,7 +9682,7 @@ ELECTROBUN_EXPORT void unmaximizeWindow(NSWindow *window) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowMaximized(NSWindow *window) {
+SPARKBUN_EXPORT bool isWindowMaximized(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9692,7 +9692,7 @@ ELECTROBUN_EXPORT bool isWindowMaximized(NSWindow *window) {
     return IsZoomed(hwnd) != 0;
 }
 
-ELECTROBUN_EXPORT void setWindowFullScreen(NSWindow *window, bool fullScreen) {
+SPARKBUN_EXPORT void setWindowFullScreen(NSWindow *window, bool fullScreen) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9746,7 +9746,7 @@ ELECTROBUN_EXPORT void setWindowFullScreen(NSWindow *window, bool fullScreen) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowFullScreen(NSWindow *window) {
+SPARKBUN_EXPORT bool isWindowFullScreen(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9757,7 +9757,7 @@ ELECTROBUN_EXPORT bool isWindowFullScreen(NSWindow *window) {
     return (style & WS_POPUP) && !(style & WS_OVERLAPPEDWINDOW);
 }
 
-ELECTROBUN_EXPORT void setWindowAlwaysOnTop(NSWindow *window, bool alwaysOnTop) {
+SPARKBUN_EXPORT void setWindowAlwaysOnTop(NSWindow *window, bool alwaysOnTop) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9773,7 +9773,7 @@ ELECTROBUN_EXPORT void setWindowAlwaysOnTop(NSWindow *window, bool alwaysOnTop)
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowAlwaysOnTop(NSWindow *window) {
+SPARKBUN_EXPORT bool isWindowAlwaysOnTop(NSWindow *window) {
     HWND hwnd = reinterpret_cast<HWND>(window);
 
     if (!IsWindow(hwnd)) {
@@ -9784,44 +9784,44 @@ ELECTROBUN_EXPORT bool isWindowAlwaysOnTop(NSWindow *window) {
     return (exStyle & WS_EX_TOPMOST) != 0;
 }
 
-ELECTROBUN_EXPORT void setWindowVisibleOnAllWorkspaces(NSWindow *window, bool visible) {
+SPARKBUN_EXPORT void setWindowVisibleOnAllWorkspaces(NSWindow *window, bool visible) {
     // Not applicable on Windows - no-op
 }
 
-ELECTROBUN_EXPORT bool isWindowVisibleOnAllWorkspaces(NSWindow *window) {
+SPARKBUN_EXPORT bool isWindowVisibleOnAllWorkspaces(NSWindow *window) {
     // Not applicable on Windows
     return false;
 }
 
-ELECTROBUN_EXPORT void setWindowPosition(NSWindow *window, double x, double y) {
+SPARKBUN_EXPORT void setWindowPosition(NSWindow *window, double x, double y) {
     HWND hwnd = reinterpret_cast<HWND>(window);
     if (!IsWindow(hwnd)) return;
 
     SetWindowPos(hwnd, NULL, (int)x, (int)y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-ELECTROBUN_EXPORT void setWindowButtonPosition(NSWindow *window, double x, double y) {
+SPARKBUN_EXPORT void setWindowButtonPosition(NSWindow *window, double x, double y) {
     (void)window;
     (void)x;
     (void)y;
     // Not applicable on Windows - no-op
 }
 
-ELECTROBUN_EXPORT void setWindowSize(NSWindow *window, double width, double height) {
+SPARKBUN_EXPORT void setWindowSize(NSWindow *window, double width, double height) {
     HWND hwnd = reinterpret_cast<HWND>(window);
     if (!IsWindow(hwnd)) return;
 
     SetWindowPos(hwnd, NULL, 0, 0, (int)width, (int)height, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-ELECTROBUN_EXPORT void setWindowFrame(NSWindow *window, double x, double y, double width, double height) {
+SPARKBUN_EXPORT void setWindowFrame(NSWindow *window, double x, double y, double width, double height) {
     HWND hwnd = reinterpret_cast<HWND>(window);
     if (!IsWindow(hwnd)) return;
 
     SetWindowPos(hwnd, NULL, (int)x, (int)y, (int)width, (int)height, SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-ELECTROBUN_EXPORT void getWindowFrame(NSWindow *window, double *outX, double *outY, double *outWidth, double *outHeight) {
+SPARKBUN_EXPORT void getWindowFrame(NSWindow *window, double *outX, double *outY, double *outWidth, double *outHeight) {
     HWND hwnd = reinterpret_cast<HWND>(window);
     if (!IsWindow(hwnd)) {
         *outX = 0;
@@ -9839,7 +9839,7 @@ ELECTROBUN_EXPORT void getWindowFrame(NSWindow *window, double *outX, double *ou
     *outHeight = (double)(rect.bottom - rect.top);
 }
 
-ELECTROBUN_EXPORT void resizeWebview(AbstractView *abstractView, double x, double y, double width, double height, const char *masksJson) {
+SPARKBUN_EXPORT void resizeWebview(AbstractView *abstractView, double x, double y, double width, double height, const char *masksJson) {
     if (!abstractView) {
         ::log("ERROR: Invalid AbstractView in resizeWebview");
         return;
@@ -9856,7 +9856,7 @@ ELECTROBUN_EXPORT void resizeWebview(AbstractView *abstractView, double x, doubl
 
 
 
-ELECTROBUN_EXPORT void stopWindowMove() {
+SPARKBUN_EXPORT void stopWindowMove() {
     if (g_isMovingWindow) {
         // Unregister raw input device
         RAWINPUTDEVICE rid;
@@ -9871,7 +9871,7 @@ ELECTROBUN_EXPORT void stopWindowMove() {
     }
 }
 
-ELECTROBUN_EXPORT void startWindowMove(NSWindow *window) {
+SPARKBUN_EXPORT void startWindowMove(NSWindow *window) {
     // On Windows, NSWindow* is actually HWND
     HWND hwnd = reinterpret_cast<HWND>(window);
     
@@ -9905,7 +9905,7 @@ ELECTROBUN_EXPORT void startWindowMove(NSWindow *window) {
     }
 }
 
-ELECTROBUN_EXPORT BOOL moveToTrash(char *pathString) {
+SPARKBUN_EXPORT BOOL moveToTrash(char *pathString) {
     if (!pathString) {
         ::log("ERROR: NULL path string passed to moveToTrash");
         return FALSE;
@@ -9944,7 +9944,7 @@ ELECTROBUN_EXPORT BOOL moveToTrash(char *pathString) {
     }
 }
 
-ELECTROBUN_EXPORT void showItemInFolder(char *path) {
+SPARKBUN_EXPORT void showItemInFolder(char *path) {
     if (!path) {
         ::log("ERROR: NULL path passed to showItemInFolder");
         return;
@@ -9987,7 +9987,7 @@ ELECTROBUN_EXPORT void showItemInFolder(char *path) {
 }
 
 // Open a URL in the default browser or appropriate application
-ELECTROBUN_EXPORT BOOL openExternal(const char *urlString) {
+SPARKBUN_EXPORT BOOL openExternal(const char *urlString) {
     if (!urlString) {
         ::log("ERROR: NULL URL passed to openExternal");
         return FALSE;
@@ -10029,7 +10029,7 @@ ELECTROBUN_EXPORT BOOL openExternal(const char *urlString) {
 }
 
 // Open a file or folder with the default application
-ELECTROBUN_EXPORT BOOL openPath(const char *pathString) {
+SPARKBUN_EXPORT BOOL openPath(const char *pathString) {
     if (!pathString) {
         ::log("ERROR: NULL path passed to openPath");
         return FALSE;
@@ -10071,7 +10071,7 @@ ELECTROBUN_EXPORT BOOL openPath(const char *pathString) {
 }
 
 // Show a native desktop notification using Shell_NotifyIcon balloon
-ELECTROBUN_EXPORT void showNotification(const char *title, const char *body, const char *subtitle, BOOL silent) {
+SPARKBUN_EXPORT void showNotification(const char *title, const char *body, const char *subtitle, BOOL silent) {
     if (!title) {
         ::log("ERROR: NULL title passed to showNotification");
         return;
@@ -10138,7 +10138,7 @@ ELECTROBUN_EXPORT void showNotification(const char *title, const char *body, con
     ::log("Notification shown: " + std::string(title));
 }
 
-ELECTROBUN_EXPORT const char* openFileDialog(const char *startingFolder,
+SPARKBUN_EXPORT const char* openFileDialog(const char *startingFolder,
                           const char *allowedFileTypes,
                           BOOL canChooseFiles,
                           BOOL canChooseDirectories,
@@ -10307,7 +10307,7 @@ ELECTROBUN_EXPORT const char* openFileDialog(const char *startingFolder,
     return strdup(result.c_str());
 }
 
-ELECTROBUN_EXPORT int showMessageBox(const char *type,
+SPARKBUN_EXPORT int showMessageBox(const char *type,
                                      const char *title,
                                      const char *message,
                                      const char *detail,
@@ -10411,7 +10411,7 @@ ELECTROBUN_EXPORT int showMessageBox(const char *type,
 
 // clipboardReadText - Read text from the system clipboard
 // Returns: UTF-8 string (caller must free) or NULL if no text available
-ELECTROBUN_EXPORT const char* clipboardReadText() {
+SPARKBUN_EXPORT const char* clipboardReadText() {
     return MainThreadDispatcher::dispatch_sync([=]() -> const char* {
         if (!OpenClipboard(nullptr)) {
             return nullptr;
@@ -10439,7 +10439,7 @@ ELECTROBUN_EXPORT const char* clipboardReadText() {
 }
 
 // clipboardWriteText - Write text to the system clipboard
-ELECTROBUN_EXPORT void clipboardWriteText(const char* text) {
+SPARKBUN_EXPORT void clipboardWriteText(const char* text) {
     if (!text) return;
 
     MainThreadDispatcher::dispatch_sync([=]() {
@@ -10467,7 +10467,7 @@ ELECTROBUN_EXPORT void clipboardWriteText(const char* text) {
 
 // clipboardReadImage - Read image from clipboard as PNG data
 // Returns: PNG data (caller must free) and sets outSize, or NULL if no image
-ELECTROBUN_EXPORT const uint8_t* clipboardReadImage(size_t* outSize) {
+SPARKBUN_EXPORT const uint8_t* clipboardReadImage(size_t* outSize) {
     return MainThreadDispatcher::dispatch_sync([=]() -> const uint8_t* {
         if (outSize) *outSize = 0;
 
@@ -10500,7 +10500,7 @@ ELECTROBUN_EXPORT const uint8_t* clipboardReadImage(size_t* outSize) {
 }
 
 // clipboardWriteImage - Write PNG image data to clipboard
-ELECTROBUN_EXPORT void clipboardWriteImage(const uint8_t* pngData, size_t size) {
+SPARKBUN_EXPORT void clipboardWriteImage(const uint8_t* pngData, size_t size) {
     if (!pngData || size == 0) return;
 
     MainThreadDispatcher::dispatch_sync([=]() {
@@ -10528,7 +10528,7 @@ ELECTROBUN_EXPORT void clipboardWriteImage(const uint8_t* pngData, size_t size)
 }
 
 // clipboardClear - Clear the clipboard
-ELECTROBUN_EXPORT void clipboardClear() {
+SPARKBUN_EXPORT void clipboardClear() {
     MainThreadDispatcher::dispatch_sync([=]() {
         if (OpenClipboard(nullptr)) {
             EmptyClipboard();
@@ -10539,7 +10539,7 @@ ELECTROBUN_EXPORT void clipboardClear() {
 
 // clipboardAvailableFormats - Get available formats in clipboard
 // Returns: comma-separated list of formats (caller must free)
-ELECTROBUN_EXPORT const char* clipboardAvailableFormats() {
+SPARKBUN_EXPORT const char* clipboardAvailableFormats() {
     return MainThreadDispatcher::dispatch_sync([=]() -> const char* {
         if (!OpenClipboard(nullptr)) {
             return strdup("");
@@ -10672,7 +10672,7 @@ LRESULT CALLBACK TrayWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lPara
     return DefWindowProc(hwnd, msg, wParam, lParam);
 }
 
-ELECTROBUN_EXPORT NSStatusItem* createTray(uint32_t trayId, const char *title, const char *pathToImage, bool isTemplate,
+SPARKBUN_EXPORT NSStatusItem* createTray(uint32_t trayId, const char *title, const char *pathToImage, bool isTemplate,
                         uint32_t width, uint32_t height, ZigStatusItemHandler zigTrayItemHandler) {
     
     return MainThreadDispatcher::dispatch_sync([=]() -> NSStatusItem* {
@@ -10798,7 +10798,7 @@ ELECTROBUN_EXPORT NSStatusItem* createTray(uint32_t trayId, const char *title, c
     });
 }
 
-ELECTROBUN_EXPORT void setTrayTitle(NSStatusItem *statusItem, const char *title) {
+SPARKBUN_EXPORT void setTrayTitle(NSStatusItem *statusItem, const char *title) {
     if (!statusItem) return;
     
     MainThreadDispatcher::dispatch_sync([=]() {
@@ -10816,7 +10816,7 @@ ELECTROBUN_EXPORT void setTrayTitle(NSStatusItem *statusItem, const char *title)
     });
 }
 
-ELECTROBUN_EXPORT void setTrayImage(NSStatusItem *statusItem, const char *image) {
+SPARKBUN_EXPORT void setTrayImage(NSStatusItem *statusItem, const char *image) {
     if (!statusItem) return;
     
     MainThreadDispatcher::dispatch_sync([=]() {
@@ -10857,7 +10857,7 @@ ELECTROBUN_EXPORT void setTrayImage(NSStatusItem *statusItem, const char *image)
 }
 
 // Updated setTrayMenuFromJSON function
-ELECTROBUN_EXPORT void setTrayMenuFromJSON(NSStatusItem *statusItem, const char *jsonString) {
+SPARKBUN_EXPORT void setTrayMenuFromJSON(NSStatusItem *statusItem, const char *jsonString) {
     if (!statusItem || !jsonString) return;
         
     MainThreadDispatcher::dispatch_sync([=]() {
@@ -10946,12 +10946,12 @@ void handleTrayIconMessage(HWND hwnd, WPARAM wParam, LPARAM lParam) {
     }
 }
 
-ELECTROBUN_EXPORT void setTrayMenu(NSStatusItem *statusItem, const char *menuConfig) {
+SPARKBUN_EXPORT void setTrayMenu(NSStatusItem *statusItem, const char *menuConfig) {
     // Delegate to JSON version for now
     setTrayMenuFromJSON(statusItem, menuConfig);
 }
 
-ELECTROBUN_EXPORT void removeTray(NSStatusItem *statusItem) {
+SPARKBUN_EXPORT void removeTray(NSStatusItem *statusItem) {
     if (!statusItem) return;
     
     MainThreadDispatcher::dispatch_sync([=]() {
@@ -10963,12 +10963,12 @@ ELECTROBUN_EXPORT void removeTray(NSStatusItem *statusItem) {
     });
 }
 
-ELECTROBUN_EXPORT const char* getTrayBounds(NSStatusItem *statusItem) {
+SPARKBUN_EXPORT const char* getTrayBounds(NSStatusItem *statusItem) {
     (void)statusItem;
     return _strdup("{\"x\":0,\"y\":0,\"width\":0,\"height\":0}");
 }
 
-ELECTROBUN_EXPORT void setApplicationMenu(const char *jsonString, ZigStatusItemHandler zigTrayItemHandler) {
+SPARKBUN_EXPORT void setApplicationMenu(const char *jsonString, ZigStatusItemHandler zigTrayItemHandler) {
     if (!jsonString) {
         ::log("ERROR: NULL JSON string passed to setApplicationMenu");
         return;
@@ -11040,7 +11040,7 @@ ELECTROBUN_EXPORT void setApplicationMenu(const char *jsonString, ZigStatusItemH
 }
 
 
-ELECTROBUN_EXPORT void showContextMenu(const char *jsonString, ZigStatusItemHandler contextMenuHandler) {
+SPARKBUN_EXPORT void showContextMenu(const char *jsonString, ZigStatusItemHandler contextMenuHandler) {
     if (!jsonString) {
         ::log("ERROR: NULL JSON string passed to showContextMenu");
         return;
@@ -11103,7 +11103,7 @@ ELECTROBUN_EXPORT void showContextMenu(const char *jsonString, ZigStatusItemHand
     });
 }
 
-ELECTROBUN_EXPORT void getWebviewSnapshot(uint32_t hostId, uint32_t webviewId,
+SPARKBUN_EXPORT void getWebviewSnapshot(uint32_t hostId, uint32_t webviewId,
                        WKWebView *webView,
                        zigSnapshotCallback callback) {
     // Stub implementation
@@ -11113,13 +11113,13 @@ ELECTROBUN_EXPORT void getWebviewSnapshot(uint32_t hostId, uint32_t webviewId,
     }
 }
 
-ELECTROBUN_EXPORT void setJSUtils(GetMimeType getMimeType, GetHTMLForWebviewSync getHTMLForWebviewSync) {
+SPARKBUN_EXPORT void setJSUtils(GetMimeType getMimeType, GetHTMLForWebviewSync getHTMLForWebviewSync) {
     ::log("setJSUtils called but using map-based approach instead of callbacks");
 }
 
 // MARK: - Webview HTML Content Management (replaces JSCallback approach)
 
-extern "C" ELECTROBUN_EXPORT void setWebviewHTMLContent(uint32_t webviewId, const char* htmlContent) {
+extern "C" SPARKBUN_EXPORT void setWebviewHTMLContent(uint32_t webviewId, const char* htmlContent) {
     std::lock_guard<std::mutex> lock(webviewHTMLMutex);
     if (htmlContent) {
         webviewHTMLContent[webviewId] = std::string(htmlContent);
@@ -11134,7 +11134,7 @@ extern "C" ELECTROBUN_EXPORT void setWebviewHTMLContent(uint32_t webviewId, cons
     }
 }
 
-extern "C" ELECTROBUN_EXPORT const char* getWebviewHTMLContent(uint32_t webviewId) {
+extern "C" SPARKBUN_EXPORT const char* getWebviewHTMLContent(uint32_t webviewId) {
     std::lock_guard<std::mutex> lock(webviewHTMLMutex);
     auto it = webviewHTMLContent.find(webviewId);
     if (it != webviewHTMLContent.end()) {
@@ -11152,7 +11152,7 @@ extern "C" ELECTROBUN_EXPORT const char* getWebviewHTMLContent(uint32_t webviewI
 }
 
 // Adding a few Windows-specific functions for interop if needed
-ELECTROBUN_EXPORT uint32_t getWindowStyle(
+SPARKBUN_EXPORT uint32_t getWindowStyle(
     bool Borderless,
     bool Titled,
     bool Closable,
@@ -11585,7 +11585,7 @@ static UINT getVirtualKeyCode(const std::string& key) {
 // Parse modifiers from accelerator string for global shortcuts using the
 // shared cross-platform parser. Returns MOD_CONTROL, MOD_ALT, MOD_SHIFT flags.
 static UINT parseModifiers(const std::string& accelerator, std::string& outKey) {
-    auto parts = electrobun::parseAccelerator(accelerator);
+    auto parts = sparkbun::parseAccelerator(accelerator);
     outKey = parts.key;
 
     UINT modifiers = 0;
@@ -11648,11 +11648,11 @@ static void hotkeyMessageLoop() {
     wc.cbSize = sizeof(WNDCLASSEXW);
     wc.lpfnWndProc = HotkeyWndProc;
     wc.hInstance = GetModuleHandle(NULL);
-    wc.lpszClassName = L"ElectrobunHotkeyWindow";
+    wc.lpszClassName = L"SparkBunHotkeyWindow";
 
     RegisterClassExW(&wc);
 
-    g_hotkeyWindow = CreateWindowExW(0, L"ElectrobunHotkeyWindow", L"",
+    g_hotkeyWindow = CreateWindowExW(0, L"SparkBunHotkeyWindow", L"",
         0, 0, 0, 0, 0, HWND_MESSAGE, NULL, GetModuleHandle(NULL), NULL);
 
     if (!g_hotkeyWindow) {
@@ -11671,7 +11671,7 @@ static void hotkeyMessageLoop() {
 }
 
 // Set the callback for global shortcut events
-extern "C" ELECTROBUN_EXPORT void setGlobalShortcutCallback(GlobalShortcutCallback callback) {
+extern "C" SPARKBUN_EXPORT void setGlobalShortcutCallback(GlobalShortcutCallback callback) {
     g_globalShortcutCallback = callback;
 
     // Start the hotkey message loop thread if not running
@@ -11686,7 +11686,7 @@ extern "C" ELECTROBUN_EXPORT void setGlobalShortcutCallback(GlobalShortcutCallba
 }
 
 // Register a global keyboard shortcut
-extern "C" ELECTROBUN_EXPORT BOOL registerGlobalShortcut(const char* accelerator) {
+extern "C" SPARKBUN_EXPORT BOOL registerGlobalShortcut(const char* accelerator) {
     if (!accelerator) {
         ::log("ERROR: Cannot register shortcut - invalid accelerator");
         return FALSE;
@@ -11758,7 +11758,7 @@ extern "C" ELECTROBUN_EXPORT BOOL registerGlobalShortcut(const char* accelerator
 }
 
 // Unregister a global keyboard shortcut
-extern "C" ELECTROBUN_EXPORT BOOL unregisterGlobalShortcut(const char* accelerator) {
+extern "C" SPARKBUN_EXPORT BOOL unregisterGlobalShortcut(const char* accelerator) {
     if (!accelerator) return FALSE;
 
     std::string accelStr(accelerator);
@@ -11784,14 +11784,14 @@ extern "C" ELECTROBUN_EXPORT BOOL unregisterGlobalShortcut(const char* accelerat
 }
 
 // Unregister all global keyboard shortcuts
-extern "C" ELECTROBUN_EXPORT void unregisterAllGlobalShortcuts() {
+extern "C" SPARKBUN_EXPORT void unregisterAllGlobalShortcuts() {
     if (g_hotkeyWindow) {
         PostMessage(g_hotkeyWindow, WM_UNREGISTER_ALL_HOTKEYS, 0, 0);
     }
 }
 
 // Check if a shortcut is registered
-extern "C" ELECTROBUN_EXPORT BOOL isGlobalShortcutRegistered(const char* accelerator) {
+extern "C" SPARKBUN_EXPORT BOOL isGlobalShortcutRegistered(const char* accelerator) {
     if (!accelerator) return FALSE;
 
     std::string accelStr(accelerator);
@@ -11868,7 +11868,7 @@ static BOOL CALLBACK MonitorEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT l
 }
 
 // Get all displays as JSON array
-extern "C" ELECTROBUN_EXPORT const char* getAllDisplays() {
+extern "C" SPARKBUN_EXPORT const char* getAllDisplays() {
     MonitorEnumData data;
 
     EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, reinterpret_cast<LPARAM>(&data));
@@ -11943,7 +11943,7 @@ static BOOL CALLBACK PrimaryMonitorEnumProc(HMONITOR hMonitor, HDC hdcMonitor, L
 }
 
 // Get primary display as JSON
-extern "C" ELECTROBUN_EXPORT const char* getPrimaryDisplay() {
+extern "C" SPARKBUN_EXPORT const char* getPrimaryDisplay() {
     PrimaryMonitorData data;
     data.found = false;
 
@@ -11957,7 +11957,7 @@ extern "C" ELECTROBUN_EXPORT const char* getPrimaryDisplay() {
 }
 
 // Get current cursor position as JSON: {"x": 123, "y": 456}
-extern "C" ELECTROBUN_EXPORT const char* getCursorScreenPoint() {
+extern "C" SPARKBUN_EXPORT const char* getCursorScreenPoint() {
     POINT cursorPos;
     if (GetCursorPos(&cursorPos)) {
         std::ostringstream json;
@@ -11968,7 +11968,7 @@ extern "C" ELECTROBUN_EXPORT const char* getCursorScreenPoint() {
     return _strdup("{\"x\":0,\"y\":0}");
 }
 
-extern "C" ELECTROBUN_EXPORT uint64_t getMouseButtons() {
+extern "C" SPARKBUN_EXPORT uint64_t getMouseButtons() {
     uint64_t buttons = 0;
     if (GetAsyncKeyState(VK_LBUTTON) & 0x8000) buttons |= 1ull << 0;
     if (GetAsyncKeyState(VK_RBUTTON) & 0x8000) buttons |= 1ull << 1;
@@ -11996,7 +11996,7 @@ static WebView2View* findWebView2ById(uint32_t webviewId) {
 // Get cookies for a webview (WebView2)
 // Note: WebView2 requires a live webview to access cookies. Pass webviewId of an existing webview.
 // filterJson: {"url": "https://example.com"} or {} for all
-extern "C" ELECTROBUN_EXPORT const char* sessionGetCookies(const char* partitionIdentifier, const char* filterJson) {
+extern "C" SPARKBUN_EXPORT const char* sessionGetCookies(const char* partitionIdentifier, const char* filterJson) {
     // For WebView2, we need a webview to access cookies
     // We'll try to find any webview with the matching partition
     // For now, return empty array - full implementation requires webview access
@@ -12121,7 +12121,7 @@ extern "C" ELECTROBUN_EXPORT const char* sessionGetCookies(const char* partition
 }
 
 // Set a cookie (WebView2)
-extern "C" ELECTROBUN_EXPORT bool sessionSetCookie(const char* partitionIdentifier, const char* cookieJson) {
+extern "C" SPARKBUN_EXPORT bool sessionSetCookie(const char* partitionIdentifier, const char* cookieJson) {
     if (!cookieJson) return false;
 
     // Find a WebView2 instance
@@ -12239,7 +12239,7 @@ extern "C" ELECTROBUN_EXPORT bool sessionSetCookie(const char* partitionIdentifi
 }
 
 // Remove a specific cookie (WebView2)
-extern "C" ELECTROBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, const char* urlStr, const char* cookieName) {
+extern "C" SPARKBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, const char* urlStr, const char* cookieName) {
     if (!urlStr || !cookieName) return false;
 
     // Find a WebView2 instance
@@ -12313,7 +12313,7 @@ extern "C" ELECTROBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdent
 }
 
 // Clear all cookies (WebView2)
-extern "C" ELECTROBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
+extern "C" SPARKBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
     // Find a WebView2 instance
     WebView2View* view = nullptr;
     for (auto& pair : g_webview2Views) {
@@ -12343,7 +12343,7 @@ extern "C" ELECTROBUN_EXPORT void sessionClearCookies(const char* partitionIdent
 }
 
 // Clear storage data (WebView2) - uses Profile API
-extern "C" ELECTROBUN_EXPORT void sessionClearStorageData(const char* partitionIdentifier, const char* storageTypesJson) {
+extern "C" SPARKBUN_EXPORT void sessionClearStorageData(const char* partitionIdentifier, const char* storageTypesJson) {
     // Find a WebView2 instance
     WebView2View* view = nullptr;
     for (auto& pair : g_webview2Views) {
@@ -12399,31 +12399,31 @@ extern "C" ELECTROBUN_EXPORT void sessionClearStorageData(const char* partitionI
 }
 
 // URL scheme handler - macOS only, stub for Windows
-extern "C" ELECTROBUN_EXPORT void setURLOpenHandler(void (*callback)(const char*)) {
+extern "C" SPARKBUN_EXPORT void setURLOpenHandler(void (*callback)(const char*)) {
     (void)callback;
     // Not supported on Windows - stub to prevent dlopen failure
     // Windows URL protocol handling is done via registry
 }
 
 // App reopen handler - macOS only, stub for Windows
-extern "C" ELECTROBUN_EXPORT void setAppReopenHandler(void (*callback)()) {
+extern "C" SPARKBUN_EXPORT void setAppReopenHandler(void (*callback)()) {
     (void)callback;
     // Not supported on Windows - stub to prevent dlopen failure
 }
 
 // Dock icon visibility - macOS only, stubs for Windows
-extern "C" ELECTROBUN_EXPORT void setDockIconVisible(bool visible) {
+extern "C" SPARKBUN_EXPORT void setDockIconVisible(bool visible) {
     (void)visible;
     // Not supported on Windows - stub to prevent dlopen failure
 }
 
-extern "C" ELECTROBUN_EXPORT bool isDockIconVisible() {
+extern "C" SPARKBUN_EXPORT bool isDockIconVisible() {
     // Not supported on Windows
     return true;
 }
 
 // Window icon - Linux only, no-op for Windows
-extern "C" ELECTROBUN_EXPORT void setWindowIcon(void* window, const char* iconPath) {
+extern "C" SPARKBUN_EXPORT void setWindowIcon(void* window, const char* iconPath) {
     // Not yet implemented on Windows
     // TODO: Implement using SetWindowIcon/LoadImage APIs
 }