sparkbun 0.1.4 → 0.1.6

package/src/native/linux/nativeWrapper.cpp

@@ -62,7 +62,7 @@
 #include "../shared/chromium_flags.h"
 #include "../shared/cache_migration.h"
 
-using namespace electrobun;
+using namespace sparkbun;
 
 // Global ASAR archive handle (lazy-loaded) with thread-safe initialization
 // ASAR C FFI declarations are in shared/asar.h
@@ -89,15 +89,15 @@ static int g_sigint_count = 0;
 static std::atomic<int> g_activeOperations{0};
 static std::mutex g_cefBrowserMutex;
 
-// Map from CEF browser identifier to electrobun webviewId, used by scheme handlers
+// Map from CEF browser identifier to sparkbun webviewId, used by scheme handlers
 static std::map<int, uint32_t> g_browserIdToWebviewId;
 static std::mutex g_browserIdToWebviewIdMutex;
 
 // Use OperationGuard from shared/shutdown_guard.h
-using electrobun::OperationGuard;
+using sparkbun::OperationGuard;
 
 // CEF includes - always include them even if it marginally increases binary size
-// we want a few binaries that will work whenever an electrobun developer
+// we want a few binaries that will work whenever an sparkbun developer
 // adds CEF into their bundles
 #include "include/cef_app.h"
 #include "include/cef_browser.h"
@@ -119,7 +119,7 @@ using electrobun::OperationGuard;
 #include "cef_loader.h"
 
 // Ensure the exported functions have appropriate visibility
-#define ELECTROBUN_EXPORT __attribute__((visibility("default")))
+#define SPARKBUN_EXPORT __attribute__((visibility("default")))
 
 // X11 Error Handler (non-fatal errors are common in WebKit/GTK)
 static int x11_error_handler(Display* display, XErrorEvent* error) {
@@ -180,12 +180,12 @@ static std::map<uint32_t, std::string> webviewHTMLContent;
 static std::mutex webviewHTMLMutex;
 
 // Global variables for CEF cache path isolation
-static std::string g_electrobunChannel = "";
-static std::string g_electrobunIdentifier = "";
+static std::string g_sparkbunChannel = "";
+static std::string g_sparkbunIdentifier = "";
 
 // 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);
 
 // MIME type detection function is in shared/mime_types.h
 // Permission cache types and functions are in shared/permissions.h
@@ -241,7 +241,7 @@ extern "C" void stopWgpuTestForWindow(Window window);
 void applyApplicationMenuToX11Window(X11Window* x11win);
 
 // Use parseMenuJson from shared/json_menu_parser.h
-using electrobun::parseMenuJson;
+using sparkbun::parseMenuJson;
 
 // Mask rectangle structure for X11 regions
 struct MaskRect {
@@ -355,8 +355,8 @@ static std::mutex g_webviewViewsRootMutex;
 // Global map to store preload scripts by browser ID (for multi-process CEF)
 static std::map<int, std::string> g_preloadScripts;
 
-CefRefPtr<class ElectrobunApp> g_app;
-electrobun::ChromiumFlagConfig g_userChromiumFlags;
+CefRefPtr<class SparkBunApp> g_app;
+sparkbun::ChromiumFlagConfig g_userChromiumFlags;
 
 
 // Get the directory of the current executable
@@ -457,17 +457,17 @@ bool isCEFAvailable() {
 
 
 // CEF Response Filter for preload script injection (Mac-style clean approach)
-class ElectrobunResponseFilter : public CefResponseFilter {
+class SparkBunResponseFilter : public CefResponseFilter {
 private:
-    std::string electrobun_script_;
+    std::string sparkbun_script_;
     std::string custom_script_;
     std::string buffer_;
     bool has_head_;
     bool injected_;
     
 public:
-    ElectrobunResponseFilter(const std::string& electrobunScript, const std::string& customScript)
-        : electrobun_script_(electrobunScript), 
+    SparkBunResponseFilter(const std::string& sparkbunScript, const std::string& customScript)
+        : sparkbun_script_(sparkbunScript), 
           custom_script_(customScript),
           has_head_(false), 
           injected_(false) {}
@@ -487,8 +487,8 @@ public:
         data_in_read = data_in_size;
         
         // Only inject once and if we have scripts to inject
-        if (!injected_ && (!electrobun_script_.empty() || !custom_script_.empty())) {
-            std::string combined_script = electrobun_script_;
+        if (!injected_ && (!sparkbun_script_.empty() || !custom_script_.empty())) {
+            std::string combined_script = sparkbun_script_;
             if (!custom_script_.empty()) {
                 combined_script += "\n" + custom_script_;
             }
@@ -542,7 +542,7 @@ public:
         return buffer_.empty() ? RESPONSE_FILTER_DONE : RESPONSE_FILTER_NEED_MORE_DATA;
     }
     
-    IMPLEMENT_REFCOUNTING(ElectrobunResponseFilter);
+    IMPLEMENT_REFCOUNTING(SparkBunResponseFilter);
 };
 
 // CEF views:// scheme handler implementation
@@ -822,12 +822,12 @@ private:
     IMPLEMENT_REFCOUNTING(V8MessageHandler);
 };
 
-// ElectrobunApp implementation for Linux
-class ElectrobunApp : public CefApp,
+// SparkBunApp implementation for Linux
+class SparkBunApp : public CefApp,
                      public CefBrowserProcessHandler,
                      public CefRenderProcessHandler {
 public:
-    ElectrobunApp() {}
+    SparkBunApp() {}
     
     void OnBeforeCommandLineProcessing(const CefString& process_type, CefRefPtr<CefCommandLine> command_line) override {
         command_line->AppendSwitchWithValue("custom-scheme", "views");
@@ -835,7 +835,7 @@ public:
         // Linux default flags — can be overridden via chromiumFlags in config
         // GPU acceleration disabled by default for VM compatibility;
         // skip with e.g. chromiumFlags: { "disable-gpu": false }
-        static const std::vector<electrobun::DefaultFlag> defaults = {
+        static const std::vector<sparkbun::DefaultFlag> defaults = {
             {"use-mock-keychain", ""},
             {"disable-gpu", ""},
             {"disable-gpu-compositing", ""},
@@ -850,10 +850,10 @@ public:
             {"ozone-platform", "x11"},
             {"use-x11", ""},
         };
-        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 {
@@ -911,13 +911,13 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunApp);
-    DISALLOW_COPY_AND_ASSIGN(ElectrobunApp);
+    IMPLEMENT_REFCOUNTING(SparkBunApp);
+    DISALLOW_COPY_AND_ASSIGN(SparkBunApp);
 };
 
 
-// ElectrobunClient implementation for Linux
-class ElectrobunClient : public CefClient,
+// SparkBunClient implementation for Linux
+class SparkBunClient : public CefClient,
                         public CefLoadHandler,
                         public CefRequestHandler,
                         public CefContextMenuHandler,
@@ -938,7 +938,7 @@ private:
     DecideNavigationCallback navigation_callback_;
     bool is_sandboxed_;
 
-    std::string electrobun_script_;
+    std::string sparkbun_script_;
     std::string custom_script_;
     CefRefPtr<CefBrowser> browser_;
     
@@ -959,7 +959,7 @@ private:
     Window parent_window_handle_;
 
 public:
-    ElectrobunClient(uint32_t webviewId,
+    SparkBunClient(uint32_t webviewId,
                      HandlePostMessage eventBridgeHandler,
                      HandlePostMessage bunBridgeHandler,
                      HandlePostMessage internalBridgeHandler,
@@ -984,7 +984,7 @@ public:
         , parent_window_handle_(0) {}
 
     void AddPreloadScript(const std::string& script, bool mainFrameOnly = false) {
-        electrobun_script_ = script;
+        sparkbun_script_ = script;
     }
 
     void UpdateCustomPreloadScript(const std::string& script) {
@@ -992,7 +992,7 @@ public:
     }
     
     std::string GetCombinedScript() {
-        std::string combined_script = electrobun_script_;
+        std::string combined_script = sparkbun_script_;
         if (!custom_script_.empty()) {
             combined_script += "\n" + custom_script_;
         }
@@ -1293,7 +1293,7 @@ public:
             
             std::string combined_script = GetCombinedScript();
             if (!combined_script.empty()) {
-                return new ElectrobunResponseFilter(electrobun_script_, custom_script_);
+                return new SparkBunResponseFilter(sparkbun_script_, custom_script_);
             }
         }
         return nullptr;
@@ -1834,7 +1834,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?";
         }
 
@@ -2182,17 +2182,17 @@ public:
     }
 
 private:
-    IMPLEMENT_REFCOUNTING(ElectrobunClient);
-    DISALLOW_COPY_AND_ASSIGN(ElectrobunClient);
+    IMPLEMENT_REFCOUNTING(SparkBunClient);
+    DISALLOW_COPY_AND_ASSIGN(SparkBunClient);
 };
 
 // Initialize static debounce timestamp for ctrl+click handling
-double ElectrobunClient::lastCtrlClickTime = 0;
+double SparkBunClient::lastCtrlClickTime = 0;
 
 static std::mutex g_osrClientsMutex;
-static std::map<uint32_t, CefRefPtr<ElectrobunClient>> g_osrClientsByWindowId;
+static std::map<uint32_t, CefRefPtr<SparkBunClient>> g_osrClientsByWindowId;
 
-static void registerOSRClientForWindow(uint32_t windowId, CefRefPtr<ElectrobunClient> client) {
+static void registerOSRClientForWindow(uint32_t windowId, CefRefPtr<SparkBunClient> client) {
     if (!windowId) return;
     std::lock_guard<std::mutex> lock(g_osrClientsMutex);
     if (client) {
@@ -2202,7 +2202,7 @@ static void registerOSRClientForWindow(uint32_t windowId, CefRefPtr<ElectrobunCl
     }
 }
 
-static CefRefPtr<ElectrobunClient> getOSRClientForWindow(uint32_t windowId) {
+static CefRefPtr<SparkBunClient> getOSRClientForWindow(uint32_t windowId) {
     std::lock_guard<std::mutex> lock(g_osrClientsMutex);
     auto it = g_osrClientsByWindowId.find(windowId);
     return it != g_osrClientsByWindowId.end() ? it->second : nullptr;
@@ -2258,7 +2258,7 @@ static int osrClickCountForEvent(Window window, const XButtonEvent& buttonEvent,
     return clickCount;
 }
 
-static void forwardX11EventToOSRClient(const XEvent& event, Display* display, Window window, CefRefPtr<ElectrobunClient> client) {
+static void forwardX11EventToOSRClient(const XEvent& event, Display* display, Window window, CefRefPtr<SparkBunClient> client) {
     if (!client) return;
 
     CefRefPtr<CefBrowser> browser;
@@ -2370,13 +2370,13 @@ bool initializeCEF() {
     }
     
     CefMainArgs main_args(argc, argv);
-    g_app = new ElectrobunApp();
+    g_app = new SparkBunApp();
 
     // Read user-defined chromium flags from build.json
     std::string buildJsonPath = getExecutableDir() + "/../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);
     }
 
     CefSettings settings;
@@ -2405,12 +2405,12 @@ bool initializeCEF() {
     char* home = getenv("HOME");
     if (home) {
         std::string basePath = std::string(home) + "/.cache";
-        std::string cachePath = buildAppDataPath(basePath, g_electrobunIdentifier, g_electrobunChannel, "CEF");
+        std::string cachePath = buildAppDataPath(basePath, g_sparkbunIdentifier, g_sparkbunChannel, "CEF");
         std::cout << "[CEF] Using path: " << cachePath << std::endl;
 
-        // 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(cachePath);
+        sparkbun::migrateCacheFolderIfNeeded(cachePath);
 
         CefString(&settings.root_cache_path) = cachePath;
     }
@@ -2528,7 +2528,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
             }
         }
@@ -2631,7 +2631,7 @@ public:
     HandlePostMessage bunBridgeHandler;
     HandlePostMessage internalBridgeHandler;
     bool isSandboxed;
-    std::string electrobunPreloadScript;
+    std::string sparkbunPreloadScript;
     std::string customPreloadScript;
     std::string partition;
     bool partitionContextReleased = false;
@@ -2653,7 +2653,7 @@ public:
                       HandlePostMessage eventBridgeHandler,
                       HandlePostMessage bunBridgeHandler,
                       HandlePostMessage internalBridgeHandler,
-                      const char* electrobunPreloadScript,
+                      const char* sparkbunPreloadScript,
                       const char* customPreloadScript,
                       bool sandbox,
                       bool startTransparent,
@@ -2662,7 +2662,7 @@ public:
           eventHandler(webviewEventHandler), eventBridgeHandler(eventBridgeHandler),
           bunBridgeHandler(bunBridgeHandler),
           internalBridgeHandler(internalBridgeHandler), isSandboxed(sandbox),
-          electrobunPreloadScript(electrobunPreloadScript ? electrobunPreloadScript : ""),
+          sparkbunPreloadScript(sparkbunPreloadScript ? sparkbunPreloadScript : ""),
           customPreloadScript(customPreloadScript ? customPreloadScript : ""),
           partition(partitionIdentifier ? partitionIdentifier : "")
     {
@@ -2730,8 +2730,8 @@ public:
         }
         
         // Add preload scripts
-        if (!this->electrobunPreloadScript.empty()) {
-            addPreloadScriptToWebView(this->electrobunPreloadScript.c_str());
+        if (!this->sparkbunPreloadScript.empty()) {
+            addPreloadScriptToWebView(this->sparkbunPreloadScript.c_str());
         }
         if (!this->customPreloadScript.empty()) {
             addPreloadScriptToWebView(this->customPreloadScript.c_str());
@@ -2980,9 +2980,9 @@ public:
             // Remove all custom scripts (we'll track them with a prefix)
             webkit_user_content_manager_remove_all_scripts(manager);
             
-            // Re-add electrobun preload script
-            if (!electrobunPreloadScript.empty()) {
-                WebKitUserScript* script = webkit_user_script_new(electrobunPreloadScript.c_str(), 
+            // Re-add sparkbun preload script
+            if (!sparkbunPreloadScript.empty()) {
+                WebKitUserScript* script = webkit_user_script_new(sparkbunPreloadScript.c_str(), 
                                                                 WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
                                                                 WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
                                                                 nullptr, nullptr);
@@ -4083,31 +4083,31 @@ double WebKitWebViewImpl::lastCtrlClickTime = 0;
 // Platform implementation for partition_context.h — builds the on-disk
 // cache_path for a persistent partition under $HOME/.cache, creating any
 // missing parent directories.
-namespace electrobun {
+namespace sparkbun {
 std::string buildAndEnsurePartitionCachePath(const std::string& partitionName) {
     char* home = getenv("HOME");
     std::string basePath = home ? std::string(home) + "/.cache" : "/tmp";
     std::string cachePath = buildCEFPartitionPath(
-        basePath, g_electrobunIdentifier, g_electrobunChannel, "CEF", partitionName);
+        basePath, g_sparkbunIdentifier, g_sparkbunChannel, "CEF", partitionName);
     g_mkdir_with_parents(cachePath.c_str(), 0755);
     return cachePath;
 }
-} // namespace electrobun
+} // namespace sparkbun
 
 CefRefPtr<CefRequestContext> CreateRequestContextForPartition(const char* partitionIdentifier,
                                                                uint32_t webviewId) {
     static CefRefPtr<ViewsSchemeHandlerFactory> schemeFactory = new ViewsSchemeHandlerFactory();
-    return electrobun::getOrCreateRequestContextForPartition(
+    return sparkbun::getOrCreateRequestContextForPartition(
         partitionIdentifier, webviewId, schemeFactory);
 }
 
 // Forward declaration for X11 event processing
-void processX11EventsForOSR(uint32_t windowId, CefRefPtr<ElectrobunClient> client);
+void processX11EventsForOSR(uint32_t windowId, CefRefPtr<SparkBunClient> client);
 
 // OSR event handling data structure
 struct OSREventData {
     uint32_t windowId;
-    CefRefPtr<ElectrobunClient> client;
+    CefRefPtr<SparkBunClient> client;
     bool active;
 };
 
@@ -4115,14 +4115,14 @@ struct OSREventData {
 class CEFWebViewImpl : public AbstractView {
 public:
     CefRefPtr<CefBrowser> browser;
-    CefRefPtr<ElectrobunClient> client;
+    CefRefPtr<SparkBunClient> client;
     DecideNavigationCallback navigationCallback;
     WebviewEventHandler eventHandler;
     HandlePostMessage eventBridgeHandler;
     HandlePostMessage bunBridgeHandler;
     HandlePostMessage internalBridgeHandler;
     bool isSandboxed;
-    std::string electrobunPreloadScript;
+    std::string sparkbunPreloadScript;
     std::string customPreloadScript;
     std::string partition;
     
@@ -4162,7 +4162,7 @@ public:
                    HandlePostMessage eventBridgeHandler,
                    HandlePostMessage bunBridgeHandler,
                    HandlePostMessage internalBridgeHandler,
-                   const char* electrobunPreloadScript,
+                   const char* sparkbunPreloadScript,
                    const char* customPreloadScript,
                    bool sandbox,
                    bool startTransparent,
@@ -4171,7 +4171,7 @@ public:
           eventHandler(webviewEventHandler), eventBridgeHandler(eventBridgeHandler),
           bunBridgeHandler(bunBridgeHandler),
           internalBridgeHandler(internalBridgeHandler), isSandboxed(sandbox),
-          electrobunPreloadScript(electrobunPreloadScript ? electrobunPreloadScript : ""),
+          sparkbunPreloadScript(sparkbunPreloadScript ? sparkbunPreloadScript : ""),
           customPreloadScript(customPreloadScript ? customPreloadScript : ""),
           partition(partitionIdentifier ? partitionIdentifier : "")
     {
@@ -4263,7 +4263,7 @@ public:
         }
         
         // Create client
-        client = new ElectrobunClient(
+        client = new SparkBunClient(
             webviewId,
             eventBridgeHandler,
             bunBridgeHandler,
@@ -4368,8 +4368,8 @@ public:
         });
         
         // Add preload scripts to the client
-        if (!electrobunPreloadScript.empty()) {
-            client->AddPreloadScript(electrobunPreloadScript);
+        if (!sparkbunPreloadScript.empty()) {
+            client->AddPreloadScript(sparkbunPreloadScript);
         }
         if (!customPreloadScript.empty()) {
             client->UpdateCustomPreloadScript(customPreloadScript);
@@ -4700,9 +4700,9 @@ public:
     }
     
     void addPreloadScriptToWebView(const char* jsString) override {
-        electrobunPreloadScript = jsString ? jsString : "";
+        sparkbunPreloadScript = jsString ? jsString : "";
         if (client) {
-            client->AddPreloadScript(electrobunPreloadScript);
+            client->AddPreloadScript(sparkbunPreloadScript);
         }
     }
     
@@ -5222,7 +5222,7 @@ public:
           title(title ? title : ""), imagePath(pathToImage ? pathToImage : "") {
         
         // Create unique indicator ID
-        std::string indicatorId = "electrobun-tray-" + std::to_string(id);
+        std::string indicatorId = "sparkbun-tray-" + std::to_string(id);
         
         // Create app indicator
         indicator = app_indicator_new(indicatorId.c_str(), 
@@ -5261,7 +5261,7 @@ public:
     void setImage(const char* newImage) {
         imagePath = newImage ? newImage : "";
         if (indicator && !imagePath.empty()) {
-            app_indicator_set_icon_full(indicator, imagePath.c_str(), "Electrobun Tray Icon");
+            app_indicator_set_icon_full(indicator, imagePath.c_str(), "SparkBun Tray Icon");
         }
     }
     
@@ -5297,7 +5297,7 @@ private:
     void createDefaultMenu() {
         menu = gtk_menu_new();
         
-        GtkWidget* defaultItem = gtk_menu_item_new_with_label("Electrobun App");
+        GtkWidget* defaultItem = gtk_menu_item_new_with_label("SparkBun App");
         gtk_widget_set_sensitive(defaultItem, FALSE);
         gtk_menu_shell_append(GTK_MENU_SHELL(menu), defaultItem);
         
@@ -5373,7 +5373,7 @@ static void focusX11Window(Display* display, Window window) {
 }
 
 // X11 event processing for OSR windows
-void processX11EventsForOSR(uint32_t windowId, CefRefPtr<ElectrobunClient> client) {
+void processX11EventsForOSR(uint32_t windowId, CefRefPtr<SparkBunClient> client) {
     // Check if shutting down
     if (g_shuttingDown.load()) return;
     
@@ -6057,8 +6057,8 @@ static WebKitWebContext* getContextForPartition(const char* partitionIdentifier)
             // Build paths with identifier/channel structure (consistent with CLI and updater)
             char* home = getenv("HOME");
             std::string homeStr = home ? std::string(home) : "/tmp";
-            std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_electrobunIdentifier, g_electrobunChannel, "WebKit", partitionName);
-            std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_electrobunIdentifier, g_electrobunChannel, "WebKit", partitionName);
+            std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
+            std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
 
             g_mkdir_with_parents(dataPath.c_str(), 0755);
             g_mkdir_with_parents(cachePath.c_str(), 0755);
@@ -6310,7 +6310,7 @@ gboolean process_x11_events(gpointer data) {
             }
 
             if (x11win->transparent) {
-                CefRefPtr<ElectrobunClient> osrClient = getOSRClientForWindow(windowId);
+                CefRefPtr<SparkBunClient> osrClient = getOSRClientForWindow(windowId);
                 if (osrClient) {
                     forwardX11EventToOSRClient(event, x11win->display, x11win->window, osrClient);
                 }
@@ -6414,7 +6414,7 @@ gboolean process_x11_events(gpointer data) {
 void runCEFEventLoop() {
     // Initialize GTK on the main thread (this MUST be done here)
     initializeGTK();
-    printf("=== ELECTROBUN NATIVE WRAPPER VERSION 1.0.2 === CEF EVENT LOOP STARTED ===\n");
+    printf("=== SPARKBUN NATIVE WRAPPER VERSION 1.0.2 === CEF EVENT LOOP STARTED ===\n");
     fflush(stdout);
         
     // Set up a timer to periodically call CefDoMessageLoopWork()
@@ -6439,7 +6439,7 @@ void runCEFEventLoop() {
 void runGTKEventLoop() {
     // Initialize GTK on the main thread (this MUST be done here)
     initializeGTK();
-    printf("=== ELECTROBUN NATIVE WRAPPER VERSION 1.0.2 === GTK EVENT LOOP STARTED ===\n");
+    printf("=== SPARKBUN NATIVE WRAPPER VERSION 1.0.2 === GTK EVENT LOOP STARTED ===\n");
 
     // Note: GDK_BACKEND=x11 forced for Wayland compatibility
 
@@ -6542,8 +6542,8 @@ void* createX11Window(uint32_t windowId, double x, double y, double width, doubl
             
             // Set WM_CLASS for proper taskbar icon matching
             XClassHint class_hint;
-            class_hint.res_name = (char*)"ElectrobunKitchenSink-dev";
-            class_hint.res_class = (char*)"ElectrobunKitchenSink-dev";
+            class_hint.res_name = (char*)"SparkBunKitchenSink-dev";
+            class_hint.res_class = (char*)"SparkBunKitchenSink-dev";
             XSetClassHint(display, x11_window, &class_hint);
             
             // Set window protocols for close button
@@ -6633,7 +6633,7 @@ void* createX11Window(uint32_t windowId, double x, double y, double width, doubl
     return result;
 }
 
-ELECTROBUN_EXPORT void* createGTKWindow(uint32_t windowId, double x, double y, double width, double height, const char* title,
+SPARKBUN_EXPORT void* createGTKWindow(uint32_t windowId, double x, double y, double width, double height, const char* title,
                    WindowCloseCallback closeCallback, WindowMoveCallback moveCallback, WindowResizeCallback resizeCallback, WindowFocusCallback focusCallback, WindowBlurCallback blurCallback, WindowKeyHandler keyCallback,
                    const char* titleBarStyle = nullptr, bool transparent = false) {
     
@@ -6649,7 +6649,7 @@ ELECTROBUN_EXPORT void* createGTKWindow(uint32_t windowId, double x, double y, d
         gtk_window_set_title(GTK_WINDOW(window), title);
         
         // Set WM_CLASS for proper taskbar icon matching
-        gtk_window_set_wmclass(GTK_WINDOW(window), "ElectrobunKitchenSink-dev", "ElectrobunKitchenSink-dev");
+        gtk_window_set_wmclass(GTK_WINDOW(window), "SparkBunKitchenSink-dev", "SparkBunKitchenSink-dev");
         
         gtk_window_set_default_size(GTK_WINDOW(window), (int)width, (int)height);
        
@@ -6791,7 +6791,7 @@ ELECTROBUN_EXPORT void* createGTKWindow(uint32_t windowId, double x, double y, d
 }
 
 // Mac-compatible function for Linux
-ELECTROBUN_EXPORT void* createWindowWithFrameAndStyleFromWorker(uint32_t windowId, double x, double y, double width, double height,
+SPARKBUN_EXPORT void* createWindowWithFrameAndStyleFromWorker(uint32_t windowId, double x, double y, double width, double height,
                                              uint32_t styleMask, const char* titleBarStyle, bool transparent,
                                              double trafficLightOffsetX, double trafficLightOffsetY,
                                              WindowCloseCallback closeCallback, WindowMoveCallback moveCallback, WindowResizeCallback resizeCallback, WindowFocusCallback focusCallback, WindowBlurCallback blurCallback, WindowKeyHandler keyCallback) {
@@ -6826,7 +6826,7 @@ void setGTKWindowTitle(void* window, const char* title) {
 }
 
 // Cross-platform compatible function for Linux
-ELECTROBUN_EXPORT void setWindowTitle(void* window, const char* title) {
+SPARKBUN_EXPORT void setWindowTitle(void* window, const char* title) {
     if (isCEFAvailable()) {
         setX11WindowTitle(window, title);
     } else {
@@ -6913,7 +6913,7 @@ void activateGTKWindow(void* window) {
     });
 }
 
-ELECTROBUN_EXPORT void showWindow(void* window, bool activate) {
+SPARKBUN_EXPORT void showWindow(void* window, bool activate) {
     if (isCEFAvailable()) {
         if (activate) {
             showX11Window(window);
@@ -6929,7 +6929,7 @@ ELECTROBUN_EXPORT void showWindow(void* window, bool activate) {
     }
 }
 
-ELECTROBUN_EXPORT void activateWindow(void* window) {
+SPARKBUN_EXPORT void activateWindow(void* window) {
     if (isCEFAvailable()) {
         activateX11Window(window);
     } else {
@@ -6953,7 +6953,7 @@ void hideGTKWindow(void* window) {
     });
 }
 
-ELECTROBUN_EXPORT void hideWindow(void* window) {
+SPARKBUN_EXPORT void hideWindow(void* window) {
     if (isCEFAvailable()) {
         hideX11Window(window);
     } else {
@@ -6962,7 +6962,7 @@ ELECTROBUN_EXPORT void hideWindow(void* window) {
 }
 
 // Cross-platform compatible function for Linux - return dummy style mask
-ELECTROBUN_EXPORT uint32_t getWindowStyle(bool borderless, bool titled, bool closable, bool miniaturizable,
+SPARKBUN_EXPORT uint32_t getWindowStyle(bool borderless, bool titled, bool closable, bool miniaturizable,
                         bool resizable, bool unifiedTitleAndToolbar, bool fullScreen,
                         bool fullSizeContentView, bool utilityWindow, bool docModalWindow,
                         bool nonactivatingPanel, bool hudWindow) {
@@ -6989,7 +6989,7 @@ AbstractView* initCEFWebview(uint32_t webviewId,
                          HandlePostMessage eventBridgeHandler,
                          HandlePostMessage bunBridgeHandler,
                          HandlePostMessage internalBridgeHandler,
-                         const char* electrobunPreloadScript,
+                         const char* sparkbunPreloadScript,
                          const char* customPreloadScript,
                          const char* viewsRoot,
                          bool sandbox,
@@ -7005,7 +7005,7 @@ AbstractView* initCEFWebview(uint32_t webviewId,
                 url, x, y, width, height, autoResize,
                 partitionIdentifier, navigationCallback, webviewEventHandler,
                 eventBridgeHandler, bunBridgeHandler, internalBridgeHandler,
-                electrobunPreloadScript, customPreloadScript, sandbox,
+                sparkbunPreloadScript, customPreloadScript, sandbox,
                 startTransparent, startPassthrough
             );
             
@@ -7091,7 +7091,7 @@ AbstractView* initGTKWebkitWebview(uint32_t webviewId,
                          HandlePostMessage eventBridgeHandler,
                          HandlePostMessage bunBridgeHandler,
                          HandlePostMessage internalBridgeHandler,
-                         const char* electrobunPreloadScript,
+                         const char* sparkbunPreloadScript,
                          const char* customPreloadScript,
                          const char* viewsRoot,
                          bool sandbox,
@@ -7108,7 +7108,7 @@ AbstractView* initGTKWebkitWebview(uint32_t webviewId,
                 url, x, y, width, height, autoResize,
                 partitionIdentifier, navigationCallback, webviewEventHandler,
                 eventBridgeHandler, bunBridgeHandler, internalBridgeHandler,
-                electrobunPreloadScript, customPreloadScript, sandbox,
+                sparkbunPreloadScript, customPreloadScript, sandbox,
                 startTransparent, startPassthrough
             );
             
@@ -7154,12 +7154,12 @@ AbstractView* initGTKWebkitWebview(uint32_t webviewId,
     return result;
 }
 
-ELECTROBUN_EXPORT void setNextWebviewFlags(bool startTransparent, bool startPassthrough) {
+SPARKBUN_EXPORT void setNextWebviewFlags(bool startTransparent, bool startPassthrough) {
     g_nextWebviewFlags.startTransparent = startTransparent;
     g_nextWebviewFlags.startPassthrough = startPassthrough;
 }
 
-ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
+SPARKBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
                          void* window,
                          const char* renderer,
                          const char* url,
@@ -7172,7 +7172,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,
@@ -7198,13 +7198,13 @@ ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
         view = initCEFWebview(webviewId, window, renderer, url, x, y, width, height, autoResize,
                               partitionIdentifier, navigationCallback, webviewEventHandler,
                               eventBridgeHandler, bunBridgeHandler, internalBridgeHandler,
-                              electrobunPreloadScript, customPreloadScript, viewsRoot, sandbox,
+                              sparkbunPreloadScript, customPreloadScript, viewsRoot, sandbox,
                               startTransparent, startPassthrough);
     } else {
         view = initGTKWebkitWebview(webviewId, window, renderer, url, x, y, width, height, autoResize,
                                     partitionIdentifier, navigationCallback, webviewEventHandler,
                                     eventBridgeHandler, bunBridgeHandler, internalBridgeHandler,
-                                    electrobunPreloadScript, customPreloadScript, viewsRoot, sandbox,
+                                    sparkbunPreloadScript, customPreloadScript, viewsRoot, sandbox,
                                     startTransparent, startPassthrough);
     }
 
@@ -7214,7 +7214,7 @@ ELECTROBUN_EXPORT AbstractView* initWebview(uint32_t webviewId,
 
 }
 
-ELECTROBUN_EXPORT AbstractView* initWGPUView(uint32_t webviewId,
+SPARKBUN_EXPORT AbstractView* initWGPUView(uint32_t webviewId,
                          void* window,
                          double x, double y,
                          double width, double height,
@@ -7372,7 +7372,7 @@ ELECTROBUN_EXPORT AbstractView* initWGPUView(uint32_t webviewId,
     return view.get();
 }
 
-ELECTROBUN_EXPORT void loadURLInWebView(AbstractView* abstractView, const char* urlString) {
+SPARKBUN_EXPORT void loadURLInWebView(AbstractView* abstractView, const char* urlString) {
     if (abstractView && urlString) {
         std::string urlStr(urlString);  // Copy the string to ensure it survives
         dispatch_sync_main_void([abstractView, urlStr]() {  // Capture by value
@@ -7381,7 +7381,7 @@ ELECTROBUN_EXPORT void loadURLInWebView(AbstractView* abstractView, const char*
     }
 }
 
-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;
     GdkRectangle frame = {(int)x, (int)y, (int)width, (int)height};
     abstractView->storePendingResize(frame, "");
@@ -7389,28 +7389,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;
     dispatch_sync_main_void([&]() {
         abstractView->setTransparent(transparent);
     });
 }
 
-ELECTROBUN_EXPORT void wgpuViewSetPassthrough(AbstractView* abstractView, bool enablePassthrough) {
+SPARKBUN_EXPORT void wgpuViewSetPassthrough(AbstractView* abstractView, bool enablePassthrough) {
     if (!abstractView) return;
     dispatch_sync_main_void([&]() {
         abstractView->setPassthrough(enablePassthrough);
     });
 }
 
-ELECTROBUN_EXPORT void wgpuViewSetHidden(AbstractView* abstractView, bool hidden) {
+SPARKBUN_EXPORT void wgpuViewSetHidden(AbstractView* abstractView, bool hidden) {
     if (!abstractView) return;
     dispatch_sync_main_void([&]() {
         abstractView->setHidden(hidden);
     });
 }
 
-ELECTROBUN_EXPORT void wgpuViewRemove(AbstractView* abstractView) {
+SPARKBUN_EXPORT void wgpuViewRemove(AbstractView* abstractView) {
     if (!abstractView) return;
     uint32_t viewId = abstractView->webviewId;
     WGPUViewImpl* view = dynamic_cast<WGPUViewImpl*>(abstractView);
@@ -7430,7 +7430,7 @@ ELECTROBUN_EXPORT void wgpuViewRemove(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void* wgpuViewGetNativeHandle(AbstractView* abstractView) {
+SPARKBUN_EXPORT void* wgpuViewGetNativeHandle(AbstractView* abstractView) {
     if (!abstractView) return nullptr;
     WGPUViewImpl* view = dynamic_cast<WGPUViewImpl*>(abstractView);
     if (!view) return nullptr;
@@ -8081,7 +8081,7 @@ static void gpuTestRequestDeviceCallback(WGPURequestDeviceStatus status, WGPUDev
     dispatch_sync_main_void([state, device]() {
         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);
@@ -8110,14 +8110,14 @@ static void runOnMainThreadAsyncVoid(std::function<void()> fn) {
     dispatch_async_main_void([fn = std::move(fn)]() { 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);
     });
 }
 
-ELECTROBUN_EXPORT void* wgpuCreateSurfaceForView(void* wgpuInstance, AbstractView* abstractView) {
+SPARKBUN_EXPORT void* wgpuCreateSurfaceForView(void* wgpuInstance, AbstractView* abstractView) {
     if (!wgpuInstance || !abstractView) return nullptr;
     if (!ensureWgpuSymbols()) return nullptr;
 
@@ -8151,24 +8151,24 @@ ELECTROBUN_EXPORT void* wgpuCreateSurfaceForView(void* wgpuInstance, AbstractVie
     });
 }
 
-ELECTROBUN_EXPORT void wgpuSurfaceConfigureMainThread(void* surface, void* config) {
+SPARKBUN_EXPORT void wgpuSurfaceConfigureMainThread(void* surface, void* config) {
     if (!ensureWgpuSymbols()) return;
     runOnMainThreadSyncVoid([&]() { p_wgpuSurfaceConfigure(surface, config); });
 }
 
-ELECTROBUN_EXPORT void wgpuSurfaceGetCurrentTextureMainThread(void* surface, void* surfaceTexture) {
+SPARKBUN_EXPORT void wgpuSurfaceGetCurrentTextureMainThread(void* surface, void* surfaceTexture) {
     if (!ensureWgpuSymbols()) return;
     runOnMainThreadSyncVoid([&]() { p_wgpuSurfaceGetCurrentTexture(surface, surfaceTexture); });
 }
 
-ELECTROBUN_EXPORT int32_t wgpuSurfacePresentMainThread(void* surface) {
+SPARKBUN_EXPORT int32_t wgpuSurfacePresentMainThread(void* surface) {
     if (!ensureWgpuSymbols()) return 0;
     return (int32_t)(intptr_t)runOnMainThreadSyncPtr([&]() -> void* {
         return (void*)(intptr_t)p_wgpuSurfacePresent(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;
@@ -8176,7 +8176,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;
@@ -8184,7 +8184,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;
@@ -8195,7 +8195,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,
@@ -8252,7 +8252,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,
@@ -8347,7 +8347,7 @@ static void wgpuReadbackCallback(
     job->done.store(1);
 }
 
-ELECTROBUN_EXPORT void* wgpuBufferReadbackBeginShim(
+SPARKBUN_EXPORT void* wgpuBufferReadbackBeginShim(
     void* buffer,
     uint64_t offset,
     uint64_t size,
@@ -8383,20 +8383,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) {
     if (!abstractView) return;
     if (!ensureWgpuTestSymbols()) return;
 
@@ -8463,7 +8463,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;
 
@@ -8476,7 +8476,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) {
     if (!ensureWgpuTestSymbols()) return;
     runOnMainThreadSyncVoid([&]() {
         WGPUInstance instance = (WGPUInstance)instancePtr;
@@ -8572,7 +8572,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) {
         std::string htmlStr(htmlString);  // Copy the string to ensure it survives
         dispatch_sync_main_void([abstractView, htmlStr]() {  // Capture by value
@@ -8581,7 +8581,7 @@ ELECTROBUN_EXPORT void loadHTMLInWebView(AbstractView* abstractView, const char*
     }
 }
 
-ELECTROBUN_EXPORT void webviewGoBack(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewGoBack(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([&]() {
             abstractView->goBack();
@@ -8589,7 +8589,7 @@ ELECTROBUN_EXPORT void webviewGoBack(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewGoForward(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewGoForward(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([&]() {
             abstractView->goForward();
@@ -8597,7 +8597,7 @@ ELECTROBUN_EXPORT void webviewGoForward(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewReload(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewReload(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([&]() {
             abstractView->reload();
@@ -8605,7 +8605,7 @@ ELECTROBUN_EXPORT void webviewReload(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewRemove(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewRemove(AbstractView* abstractView) {
     if (abstractView) {
         // Get the webview ID before scheduling async removal
         uint32_t webviewId = abstractView->webviewId;
@@ -8643,14 +8643,14 @@ ELECTROBUN_EXPORT void webviewRemove(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT bool webviewCanGoBack(AbstractView* abstractView) {
+SPARKBUN_EXPORT bool webviewCanGoBack(AbstractView* abstractView) {
     if (abstractView) {
         return abstractView->canGoBack();
     }
     return false;
 }
 
-ELECTROBUN_EXPORT bool webviewCanGoForward(AbstractView* abstractView) {
+SPARKBUN_EXPORT bool webviewCanGoForward(AbstractView* abstractView) {
     if (abstractView) {
         return abstractView->canGoForward();
     }
@@ -8717,7 +8717,7 @@ void updateActiveWebviewForMousePosition(uint32_t windowId, int mouseX, int mous
     container->activeWebView = nullptr;
 }
 
-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) {
         return;
     }
@@ -8732,7 +8732,7 @@ ELECTROBUN_EXPORT void resizeWebview(AbstractView* abstractView, double x, doubl
     schedulePendingResizeDrain();
 }
 
-ELECTROBUN_EXPORT void evaluateJavaScriptWithNoCompletion(AbstractView* abstractView, const char* js) {
+SPARKBUN_EXPORT void evaluateJavaScriptWithNoCompletion(AbstractView* abstractView, const char* js) {
     if (abstractView && js) {
         std::string jsString(js);  // Copy the string to ensure it survives
         dispatch_sync_main_void([abstractView, jsString]() {  // Capture by value
@@ -8773,7 +8773,7 @@ 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) {
         std::string rulesStr(rulesJson ? rulesJson : "");  // Copy the string to ensure it survives
         dispatch_sync_main_void([abstractView, rulesStr]() {
@@ -8782,7 +8782,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) {
         std::string text(searchText ? searchText : "");
         dispatch_sync_main_void([abstractView, text, forward, matchCase]() {
@@ -8791,7 +8791,7 @@ ELECTROBUN_EXPORT void webviewFindInPage(AbstractView* abstractView, const char*
     }
 }
 
-ELECTROBUN_EXPORT void webviewStopFind(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewStopFind(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([abstractView]() {
             abstractView->stopFindInPage();
@@ -8799,7 +8799,7 @@ ELECTROBUN_EXPORT void webviewStopFind(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewOpenDevTools(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewOpenDevTools(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([abstractView]() {
             abstractView->openDevTools();
@@ -8807,7 +8807,7 @@ ELECTROBUN_EXPORT void webviewOpenDevTools(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewCloseDevTools(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewCloseDevTools(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([abstractView]() {
             abstractView->closeDevTools();
@@ -8815,7 +8815,7 @@ ELECTROBUN_EXPORT void webviewCloseDevTools(AbstractView* abstractView) {
     }
 }
 
-ELECTROBUN_EXPORT void webviewToggleDevTools(AbstractView* abstractView) {
+SPARKBUN_EXPORT void webviewToggleDevTools(AbstractView* abstractView) {
     if (abstractView) {
         dispatch_sync_main_void([abstractView]() {
             abstractView->toggleDevTools();
@@ -8823,17 +8823,17 @@ 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 Linux CEF
     // TODO: implement CEF zoom if needed
 }
 
-ELECTROBUN_EXPORT double webviewGetPageZoom(AbstractView* abstractView) {
+SPARKBUN_EXPORT double webviewGetPageZoom(AbstractView* abstractView) {
     // pageZoom is WebKit-specific, not available on Linux CEF
     return 1.0;
 }
 
-ELECTROBUN_EXPORT void updatePreloadScriptToWebView(AbstractView* abstractView, const char* scriptIdentifier, const char* scriptContent, bool forMainFrameOnly) {
+SPARKBUN_EXPORT void updatePreloadScriptToWebView(AbstractView* abstractView, const char* scriptIdentifier, const char* scriptContent, bool forMainFrameOnly) {
     if (abstractView) {
         dispatch_sync_main_void([&]() {
             abstractView->updateCustomPreloadScript(scriptContent);
@@ -8884,7 +8884,7 @@ static gboolean onWindowDragButtonRelease(GtkWidget* widget, GdkEventButton* eve
     return FALSE; // Let other handlers process the event
 }
 
-ELECTROBUN_EXPORT void startWindowMove(void *window) {
+SPARKBUN_EXPORT void startWindowMove(void *window) {
   dispatch_sync_main_void([&]() {
     if (isCEFAvailable()) {
       // CEF is always forced to X11 mode (--ozone-platform=x11 / --use-x11),
@@ -8951,14 +8951,14 @@ ELECTROBUN_EXPORT void startWindowMove(void *window) {
   });
 }
 
-ELECTROBUN_EXPORT void stopWindowMove() {
+SPARKBUN_EXPORT void stopWindowMove() {
   // gtk_window_begin_move_drag is handled entirely by the WM/compositor —
   // there's nothing to clean up on our side.
   printf("stopWindowMove called\n");
   fflush(stdout);
 }
 
-ELECTROBUN_EXPORT void addPreloadScriptToWebView(AbstractView* abstractView, const char* scriptContent, bool forMainFrameOnly) {
+SPARKBUN_EXPORT void addPreloadScriptToWebView(AbstractView* abstractView, const char* scriptContent, bool forMainFrameOnly) {
     if (abstractView) {
         dispatch_sync_main_void([&]() {
             abstractView->addPreloadScriptToWebView(scriptContent);
@@ -8966,7 +8966,7 @@ ELECTROBUN_EXPORT void addPreloadScriptToWebView(AbstractView* abstractView, con
     }
 }
 
-ELECTROBUN_EXPORT void callAsyncJavaScript(const char* messageId, const char* jsString, uint32_t webviewId, uint32_t hostWebviewId, void* completionHandler) {
+SPARKBUN_EXPORT void callAsyncJavaScript(const char* messageId, const char* jsString, uint32_t webviewId, uint32_t hostWebviewId, void* completionHandler) {
     // Find the webview in containers
     for (auto& [id, container] : g_containers) {
         for (auto& view : container->abstractViews) {
@@ -9004,18 +9004,18 @@ void testFFI2(void (*completionHandler)()) {
     }
 }
 
-ELECTROBUN_EXPORT int simpleTest() {
+SPARKBUN_EXPORT int simpleTest() {
     printf("simpleTest called successfully\n");
     fflush(stdout);
     return 42;
 }
 
-ELECTROBUN_EXPORT const char* getUrlFromNavigationAction(void* navigationAction) {
+SPARKBUN_EXPORT const char* getUrlFromNavigationAction(void* navigationAction) {
     // TODO: Implement URL extraction from navigation action
     return nullptr;
 }
 
-ELECTROBUN_EXPORT const char* getBodyFromScriptMessage(void* message) {
+SPARKBUN_EXPORT const char* getBodyFromScriptMessage(void* message) {
     // TODO: Implement body extraction from script message
     return nullptr;
 }
@@ -9024,7 +9024,7 @@ void invokeDecisionHandler(void* decisionHandler, uint32_t policy) {
     // TODO: Implement decision handler invocation
 }
 
-ELECTROBUN_EXPORT bool moveToTrash(char* pathString) {
+SPARKBUN_EXPORT bool moveToTrash(char* pathString) {
     if (!pathString) return false;
     
     // Use GIO to move file to trash
@@ -9087,7 +9087,7 @@ 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) {
         fprintf(stderr, "ERROR: NULL URL passed to openExternal\n");
         return false;
@@ -9124,7 +9124,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) {
         fprintf(stderr, "ERROR: NULL path passed to openPath\n");
         return false;
@@ -9227,7 +9227,7 @@ void showNotification(const char* title, const char* body, const char* subtitle,
     }).detach();
 }
 
-ELECTROBUN_EXPORT const char* openFileDialog(const char* startingFolder, const char* allowedFileTypes, int canChooseFiles, int canChooseDirectories, int allowsMultipleSelection) {
+SPARKBUN_EXPORT const char* openFileDialog(const char* startingFolder, const char* allowedFileTypes, int canChooseFiles, int canChooseDirectories, int allowsMultipleSelection) {
     // This function needs to run on the main thread
     return dispatch_sync_main([&]() -> const char* {
         // Determine the file chooser action based on parameters
@@ -9332,7 +9332,7 @@ ELECTROBUN_EXPORT const char* openFileDialog(const char* startingFolder, const c
     });
 }
 
-ELECTROBUN_EXPORT int showMessageBox(const char *type,
+SPARKBUN_EXPORT int showMessageBox(const char *type,
                    const char *title,
                    const char *message,
                    const char *detail,
@@ -9425,7 +9425,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 dispatch_sync_main([&]() -> const char* {
         GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
         gchar* text = gtk_clipboard_wait_for_text(clipboard);
@@ -9439,7 +9439,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;
 
     // Make a copy of the text since we need it to persist
@@ -9493,7 +9493,7 @@ 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;
 
     // Copy the data since we need it to persist
@@ -9526,7 +9526,7 @@ ELECTROBUN_EXPORT void clipboardWriteImage(const uint8_t* pngData, size_t size)
 }
 
 // clipboardClear - Clear the clipboard
-ELECTROBUN_EXPORT void clipboardClear() {
+SPARKBUN_EXPORT void clipboardClear() {
     dispatch_sync_main_void([&]() {
         GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
         gtk_clipboard_clear(clipboard);
@@ -9535,7 +9535,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 dispatch_sync_main([&]() -> const char* {
         GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
         std::vector<std::string> formats;
@@ -9570,7 +9570,7 @@ ELECTROBUN_EXPORT const char* clipboardAvailableFormats() {
 // The TrayItem constructor handles deferred AppIndicator creation internally
 
 #ifndef NO_APPINDICATOR
-ELECTROBUN_EXPORT void* createTray(uint32_t trayId, const char* title, const char* pathToImage, bool isTemplate, uint32_t width, uint32_t height, void* clickHandler) {
+SPARKBUN_EXPORT void* createTray(uint32_t trayId, const char* title, const char* pathToImage, bool isTemplate, uint32_t width, uint32_t height, void* clickHandler) {
     // NOTE: width and height parameters are ignored on Linux since AppIndicator doesn't support custom sizing
     // These parameters are included for FFI consistency across platforms (macOS and Windows use them)
     
@@ -9600,7 +9600,7 @@ ELECTROBUN_EXPORT void* createTray(uint32_t trayId, const char* title, const cha
     });
 }
 
-ELECTROBUN_EXPORT void setTrayTitle(void* statusItem, const char* title) {
+SPARKBUN_EXPORT void setTrayTitle(void* statusItem, const char* title) {
     dispatch_sync_main_void([&]() {
         // Find the tray by statusItem pointer
         for (auto& [id, tray] : g_trays) {
@@ -9612,7 +9612,7 @@ ELECTROBUN_EXPORT void setTrayTitle(void* statusItem, const char* title) {
     });
 }
 
-ELECTROBUN_EXPORT void setTrayImage(void* statusItem, const char* image) {
+SPARKBUN_EXPORT void setTrayImage(void* statusItem, const char* image) {
     dispatch_sync_main_void([&]() {
         // Find the tray by statusItem pointer
         for (auto& [id, tray] : g_trays) {
@@ -9624,7 +9624,7 @@ ELECTROBUN_EXPORT void setTrayImage(void* statusItem, const char* image) {
     });
 }
 
-ELECTROBUN_EXPORT void setTrayMenuFromJSON(void* statusItem, const char* jsonString) {
+SPARKBUN_EXPORT void setTrayMenuFromJSON(void* statusItem, const char* jsonString) {
     dispatch_sync_main_void([&]() {
         // Find the tray by statusItem pointer
         for (auto& [id, tray] : g_trays) {
@@ -9636,11 +9636,11 @@ ELECTROBUN_EXPORT void setTrayMenuFromJSON(void* statusItem, const char* jsonStr
     });
 }
 
-ELECTROBUN_EXPORT void setTrayMenu(void* statusItem, const char* menuConfig) {
+SPARKBUN_EXPORT void setTrayMenu(void* statusItem, const char* menuConfig) {
     setTrayMenuFromJSON(statusItem, menuConfig);
 }
 
-ELECTROBUN_EXPORT void removeTray(void* statusItem) {
+SPARKBUN_EXPORT void removeTray(void* statusItem) {
     dispatch_sync_main_void([&]() {
         // Find the tray by statusItem pointer and remove it
         for (auto it = g_trays.begin(); it != g_trays.end(); ++it) {
@@ -9652,25 +9652,25 @@ ELECTROBUN_EXPORT void removeTray(void* statusItem) {
     });
 }
 
-ELECTROBUN_EXPORT const char* getTrayBounds(void* statusItem) {
+SPARKBUN_EXPORT const char* getTrayBounds(void* statusItem) {
     (void)statusItem;
     return strdup("{\"x\":0,\"y\":0,\"width\":0,\"height\":0}");
 }
 #else // NO_APPINDICATOR
 // Stub implementations when AppIndicator is not available
-ELECTROBUN_EXPORT void* createTray(uint32_t trayId, const char* title, const char* pathToImage, bool isTemplate, uint32_t width, uint32_t height, void* clickHandler) {
+SPARKBUN_EXPORT void* createTray(uint32_t trayId, const char* title, const char* pathToImage, bool isTemplate, uint32_t width, uint32_t height, void* clickHandler) {
     return nullptr;
 }
 
-ELECTROBUN_EXPORT void setTrayTitle(void* statusItem, const char* title) {}
-ELECTROBUN_EXPORT void setTrayImage(void* statusItem, const char* image) {}
-ELECTROBUN_EXPORT void setTrayMenuFromJSON(void* statusItem, const char* jsonString) {}
-ELECTROBUN_EXPORT void setTrayMenu(void* statusItem, const char* menuConfig) {}
-ELECTROBUN_EXPORT void removeTray(void* statusItem) {}
-ELECTROBUN_EXPORT const char* getTrayBounds(void* statusItem) { return strdup("{\"x\":0,\"y\":0,\"width\":0,\"height\":0}"); }
+SPARKBUN_EXPORT void setTrayTitle(void* statusItem, const char* title) {}
+SPARKBUN_EXPORT void setTrayImage(void* statusItem, const char* image) {}
+SPARKBUN_EXPORT void setTrayMenuFromJSON(void* statusItem, const char* jsonString) {}
+SPARKBUN_EXPORT void setTrayMenu(void* statusItem, const char* menuConfig) {}
+SPARKBUN_EXPORT void removeTray(void* statusItem) {}
+SPARKBUN_EXPORT const char* getTrayBounds(void* statusItem) { return strdup("{\"x\":0,\"y\":0,\"width\":0,\"height\":0}"); }
 #endif // NO_APPINDICATOR
 
-ELECTROBUN_EXPORT void setApplicationMenu(const char* jsonString, void* applicationMenuHandler) {
+SPARKBUN_EXPORT void setApplicationMenu(const char* jsonString, void* applicationMenuHandler) {
     if (!jsonString || strlen(jsonString) == 0) {
         return;
     }
@@ -9711,12 +9711,12 @@ ELECTROBUN_EXPORT void setApplicationMenu(const char* jsonString, void* applicat
 // On macOS, you can programmatically show a custom menu at the current mouse position.
 // On Linux/GTK, context menus are typically triggered by right-click events rather than
 // programmatic calls. This function is not supported on Linux.
-ELECTROBUN_EXPORT void showContextMenu(const char* jsonString, void* contextMenuHandler) {
+SPARKBUN_EXPORT void showContextMenu(const char* jsonString, void* contextMenuHandler) {
     printf("showContextMenu is not supported on Linux. Use application menus or system tray menus instead.\n");
     fflush(stdout);
 }
 
-ELECTROBUN_EXPORT void getWebviewSnapshot(uint32_t hostId, uint32_t webviewId, double x, double y, double width, double height, void* completionHandler) {
+SPARKBUN_EXPORT void getWebviewSnapshot(uint32_t hostId, uint32_t webviewId, double x, double y, double width, double height, void* completionHandler) {
     // TODO: Implement webview snapshot
 }
 
@@ -9755,25 +9755,25 @@ const char* getWebviewHTMLContent(uint32_t webviewId) {
 }
 
 // Forward declaration - stopEventLoop is defined after startEventLoop
-ELECTROBUN_EXPORT void stopEventLoop();
+SPARKBUN_EXPORT void stopEventLoop();
 
 // Note: `name` parameter is accepted for API consistency with Windows but not used on Linux
-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) {
     (void)name; // Unused on Linux - kept for API consistency with Windows
 
     // Store identifier and channel globally for use in CEF initialization
     if (identifier && identifier[0]) {
-        g_electrobunIdentifier = std::string(identifier);
+        g_sparkbunIdentifier = std::string(identifier);
     }
     if (channel && channel[0]) {
-        g_electrobunChannel = std::string(channel);
+        g_sparkbunChannel = std::string(channel);
     }
 
     // Linux uses runEventLoop instead
     runEventLoop();
 }
 
-ELECTROBUN_EXPORT void stopEventLoop() {
+SPARKBUN_EXPORT void stopEventLoop() {
     if (g_eventLoopStopping.exchange(true)) {
         return;
     }
@@ -9785,12 +9785,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) {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -9798,7 +9798,7 @@ ELECTROBUN_EXPORT void waitForShutdownComplete(int timeoutMs) {
     }
 }
 
-ELECTROBUN_EXPORT void forceExit(int code) {
+SPARKBUN_EXPORT void forceExit(int code) {
     _exit(code);
 }
 
@@ -9839,7 +9839,7 @@ static gboolean linux_signal_pipe_read(GIOChannel* source, GIOCondition conditio
     return G_SOURCE_CONTINUE;
 }
 
-ELECTROBUN_EXPORT void setQuitRequestedHandler(QuitRequestedHandler handler) {
+SPARKBUN_EXPORT void setQuitRequestedHandler(QuitRequestedHandler handler) {
     g_quitRequestedHandler = handler;
 
     // Set up signal handling via self-pipe + GLib IO watch.
@@ -9869,7 +9869,7 @@ ELECTROBUN_EXPORT void setQuitRequestedHandler(QuitRequestedHandler handler) {
     sigaction(SIGTERM, &sa, nullptr);
 }
 
-ELECTROBUN_EXPORT void shutdownApplication() {
+SPARKBUN_EXPORT void shutdownApplication() {
     // Deprecated - use stopEventLoop() instead
     stopEventLoop();
 }
@@ -9941,7 +9941,7 @@ void cleanupWebviewsForWindow(uint32_t windowId) {
     }
 }
 
-ELECTROBUN_EXPORT void closeWindow(void* window) {
+SPARKBUN_EXPORT void closeWindow(void* window) {
     if (!window) return;
     
     // Check if we're shutting down
@@ -10051,7 +10051,7 @@ ELECTROBUN_EXPORT void closeWindow(void* window) {
     }
 }
 
-ELECTROBUN_EXPORT void minimizeWindow(void* window) {
+SPARKBUN_EXPORT void minimizeWindow(void* window) {
     if (!window) return;
 
     dispatch_sync_main_void([&]() {
@@ -10070,7 +10070,7 @@ ELECTROBUN_EXPORT void minimizeWindow(void* window) {
     });
 }
 
-ELECTROBUN_EXPORT void restoreWindow(void* window) {
+SPARKBUN_EXPORT void restoreWindow(void* window) {
     if (!window) return;
 
     dispatch_sync_main_void([&]() {
@@ -10121,7 +10121,7 @@ ELECTROBUN_EXPORT void restoreWindow(void* window) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowMinimized(void* window) {
+SPARKBUN_EXPORT bool isWindowMinimized(void* window) {
     if (!window) return false;
 
     bool result = false;
@@ -10187,7 +10187,7 @@ ELECTROBUN_EXPORT bool isWindowMinimized(void* window) {
     return result;
 }
 
-ELECTROBUN_EXPORT void maximizeWindow(void* window) {
+SPARKBUN_EXPORT void maximizeWindow(void* window) {
     if (!window) return;
 
     dispatch_sync_main_void([&]() {
@@ -10221,7 +10221,7 @@ ELECTROBUN_EXPORT void maximizeWindow(void* window) {
     });
 }
 
-ELECTROBUN_EXPORT void unmaximizeWindow(void* window) {
+SPARKBUN_EXPORT void unmaximizeWindow(void* window) {
     if (!window) return;
 
     dispatch_sync_main_void([&]() {
@@ -10255,7 +10255,7 @@ ELECTROBUN_EXPORT void unmaximizeWindow(void* window) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowMaximized(void* window) {
+SPARKBUN_EXPORT bool isWindowMaximized(void* window) {
     if (!window) return false;
 
     bool result = false;
@@ -10295,7 +10295,7 @@ ELECTROBUN_EXPORT bool isWindowMaximized(void* window) {
     return result;
 }
 
-ELECTROBUN_EXPORT void setWindowFullScreen(void* window, bool fullScreen) {
+SPARKBUN_EXPORT void setWindowFullScreen(void* window, bool fullScreen) {
     if (!window) return;
 
     dispatch_sync_main_void([&]() {
@@ -10332,7 +10332,7 @@ ELECTROBUN_EXPORT void setWindowFullScreen(void* window, bool fullScreen) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowFullScreen(void* window) {
+SPARKBUN_EXPORT bool isWindowFullScreen(void* window) {
     if (!window) return false;
 
     bool result = false;
@@ -10375,7 +10375,7 @@ ELECTROBUN_EXPORT bool isWindowFullScreen(void* window) {
     return result;
 }
 
-ELECTROBUN_EXPORT void setWindowAlwaysOnTop(void* window, bool alwaysOnTop) {
+SPARKBUN_EXPORT void setWindowAlwaysOnTop(void* window, bool alwaysOnTop) {
     if (!window) return;
 
     dispatch_sync_main_void([&]() {
@@ -10412,7 +10412,7 @@ ELECTROBUN_EXPORT void setWindowAlwaysOnTop(void* window, bool alwaysOnTop) {
     });
 }
 
-ELECTROBUN_EXPORT bool isWindowAlwaysOnTop(void* window) {
+SPARKBUN_EXPORT bool isWindowAlwaysOnTop(void* window) {
     if (!window) return false;
 
     bool result = false;
@@ -10455,16 +10455,16 @@ ELECTROBUN_EXPORT bool isWindowAlwaysOnTop(void* window) {
     return result;
 }
 
-ELECTROBUN_EXPORT void setWindowVisibleOnAllWorkspaces(void* window, bool visible) {
+SPARKBUN_EXPORT void setWindowVisibleOnAllWorkspaces(void* window, bool visible) {
     // Not applicable on Linux - no-op
 }
 
-ELECTROBUN_EXPORT bool isWindowVisibleOnAllWorkspaces(void* window) {
+SPARKBUN_EXPORT bool isWindowVisibleOnAllWorkspaces(void* window) {
     // Not applicable on Linux
     return false;
 }
 
-ELECTROBUN_EXPORT void setWindowPosition(void* window, double x, double y) {
+SPARKBUN_EXPORT void setWindowPosition(void* window, double x, double y) {
     if (!window) return;
 
     dispatch_sync_main_void([=]() {
@@ -10494,14 +10494,14 @@ ELECTROBUN_EXPORT void setWindowPosition(void* window, double x, double y) {
     });
 }
 
-ELECTROBUN_EXPORT void setWindowButtonPosition(void* window, double x, double y) {
+SPARKBUN_EXPORT void setWindowButtonPosition(void* window, double x, double y) {
     (void)window;
     (void)x;
     (void)y;
     // Not applicable on Linux - no-op
 }
 
-ELECTROBUN_EXPORT void setWindowSize(void* window, double width, double height) {
+SPARKBUN_EXPORT void setWindowSize(void* window, double width, double height) {
     if (!window) return;
 
     dispatch_sync_main_void([=]() {
@@ -10520,7 +10520,7 @@ ELECTROBUN_EXPORT void setWindowSize(void* window, double width, double height)
     });
 }
 
-ELECTROBUN_EXPORT void setWindowFrame(void* window, double x, double y, double width, double height) {
+SPARKBUN_EXPORT void setWindowFrame(void* window, double x, double y, double width, double height) {
     if (!window) return;
 
     dispatch_sync_main_void([=]() {
@@ -10540,7 +10540,7 @@ ELECTROBUN_EXPORT void setWindowFrame(void* window, double x, double y, double w
     });
 }
 
-ELECTROBUN_EXPORT void getWindowFrame(void* window, double* outX, double* outY, double* outWidth, double* outHeight) {
+SPARKBUN_EXPORT void getWindowFrame(void* window, double* outX, double* outY, double* outWidth, double* outHeight) {
     if (!window) {
         *outX = 0;
         *outY = 0;
@@ -10612,17 +10612,17 @@ ELECTROBUN_EXPORT void getWindowFrame(void* window, double* outX, double* outY,
     });
 }
 
-ELECTROBUN_EXPORT void getWindowPosition(void* window, double* outX, double* outY) {
+SPARKBUN_EXPORT void getWindowPosition(void* window, double* outX, double* outY) {
     double width, height;
     getWindowFrame(window, outX, outY, &width, &height);
 }
 
-ELECTROBUN_EXPORT void getWindowSize(void* window, double* outWidth, double* outHeight) {
+SPARKBUN_EXPORT void getWindowSize(void* window, double* outWidth, double* outHeight) {
     double x, y;
     getWindowFrame(window, &x, &y, outWidth, outHeight);
 }
 
-ELECTROBUN_EXPORT void setWindowIcon(void* window, const char* iconPath) {
+SPARKBUN_EXPORT void setWindowIcon(void* window, const char* iconPath) {
     if (!window || !iconPath) return;
 
     dispatch_sync_main_void([=]() {
@@ -10816,7 +10816,7 @@ static KeySym getKeySym(const std::string& key) {
 // Parse modifiers from accelerator string for X11 shortcuts using the
 // shared cross-platform parser. Returns X11 modifier mask.
 static unsigned int parseX11Modifiers(const std::string& accelerator, std::string& outKey) {
-    auto parts = electrobun::parseAccelerator(accelerator);
+    auto parts = sparkbun::parseAccelerator(accelerator);
     outKey = parts.key;
 
     unsigned int modifiers = 0;
@@ -10868,7 +10868,7 @@ static void shortcutEventLoop() {
 }
 
 // Set the callback for global shortcut events
-ELECTROBUN_EXPORT void setGlobalShortcutCallback(GlobalShortcutCallback callback) {
+SPARKBUN_EXPORT void setGlobalShortcutCallback(GlobalShortcutCallback callback) {
     printf("GlobalShortcut: Setting callback (callback=%p)\n", callback);
     g_globalShortcutCallback = callback;
 
@@ -10892,7 +10892,7 @@ ELECTROBUN_EXPORT void setGlobalShortcutCallback(GlobalShortcutCallback callback
 }
 
 // Register a global keyboard shortcut
-ELECTROBUN_EXPORT bool registerGlobalShortcut(const char* accelerator) {
+SPARKBUN_EXPORT bool registerGlobalShortcut(const char* accelerator) {
     printf("GlobalShortcut: registerGlobalShortcut called for '%s'\n", accelerator ? accelerator : "(null)");
     
     if (!accelerator) {
@@ -10961,7 +10961,7 @@ ELECTROBUN_EXPORT bool registerGlobalShortcut(const char* accelerator) {
 }
 
 // Unregister a global keyboard shortcut
-ELECTROBUN_EXPORT bool unregisterGlobalShortcut(const char* accelerator) {
+SPARKBUN_EXPORT bool unregisterGlobalShortcut(const char* accelerator) {
     if (!accelerator || !g_shortcutDisplay) return false;
 
     std::string accelStr(accelerator);
@@ -10993,7 +10993,7 @@ ELECTROBUN_EXPORT bool unregisterGlobalShortcut(const char* accelerator) {
 }
 
 // Unregister all global keyboard shortcuts
-ELECTROBUN_EXPORT void unregisterAllGlobalShortcuts() {
+SPARKBUN_EXPORT void unregisterAllGlobalShortcuts() {
     if (!g_shortcutDisplay) return;
 
     Window root = DefaultRootWindow(g_shortcutDisplay);
@@ -11020,7 +11020,7 @@ ELECTROBUN_EXPORT void unregisterAllGlobalShortcuts() {
 }
 
 // Check if a shortcut is registered
-ELECTROBUN_EXPORT bool isGlobalShortcutRegistered(const char* accelerator) {
+SPARKBUN_EXPORT bool isGlobalShortcutRegistered(const char* accelerator) {
     if (!accelerator) return false;
     return g_globalShortcuts.find(std::string(accelerator)) != g_globalShortcuts.end();
 }
@@ -11032,7 +11032,7 @@ ELECTROBUN_EXPORT bool isGlobalShortcutRegistered(const char* accelerator) {
  */
 
 // Get all displays as JSON array
-ELECTROBUN_EXPORT const char* getAllDisplays() {
+SPARKBUN_EXPORT const char* getAllDisplays() {
     GdkDisplay* display = gdk_display_get_default();
     if (!display) {
         return strdup("[]");
@@ -11089,7 +11089,7 @@ ELECTROBUN_EXPORT const char* getAllDisplays() {
 }
 
 // Get primary display as JSON
-ELECTROBUN_EXPORT const char* getPrimaryDisplay() {
+SPARKBUN_EXPORT const char* getPrimaryDisplay() {
     GdkDisplay* display = gdk_display_get_default();
     if (!display) {
         return strdup("{}");
@@ -11140,7 +11140,7 @@ ELECTROBUN_EXPORT const char* getPrimaryDisplay() {
 }
 
 // Get current cursor position as JSON: {"x": 123, "y": 456}
-ELECTROBUN_EXPORT const char* getCursorScreenPoint() {
+SPARKBUN_EXPORT const char* getCursorScreenPoint() {
     return dispatch_sync_main([&]() -> const char* {
         GdkDisplay* display = gdk_display_get_default();
         if (!display) {
@@ -11167,7 +11167,7 @@ ELECTROBUN_EXPORT const char* getCursorScreenPoint() {
     });
 }
 
-ELECTROBUN_EXPORT uint64_t getMouseButtons() {
+SPARKBUN_EXPORT uint64_t getMouseButtons() {
     return dispatch_sync_main([&]() -> uint64_t {
         GdkDisplay* display = gdk_display_get_default();
         if (!display) {
@@ -11228,8 +11228,8 @@ static WebKitWebsiteDataManager* getDataManagerForPartition(const char* partitio
             // Build paths with identifier/channel structure (consistent with CLI and updater)
             char* home = getenv("HOME");
             std::string homeStr = home ? std::string(home) : "/tmp";
-            std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_electrobunIdentifier, g_electrobunChannel, "WebKit", partitionName);
-            std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_electrobunIdentifier, g_electrobunChannel, "WebKit", partitionName);
+            std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
+            std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
 
             g_mkdir_with_parents(dataPath.c_str(), 0755);
             g_mkdir_with_parents(cachePath.c_str(), 0755);
@@ -11320,7 +11320,7 @@ static void onGetCookiesFinished(GObject* source, GAsyncResult* result, gpointer
 }
 
 // Get cookies for a partition (WebKit2GTK)
-ELECTROBUN_EXPORT const char* sessionGetCookies(const char* partitionIdentifier, const char* filterJson) {
+SPARKBUN_EXPORT const char* sessionGetCookies(const char* partitionIdentifier, const char* filterJson) {
     // Copy arguments before dispatching to main thread
     std::string partitionStr = partitionIdentifier ? partitionIdentifier : "";
     std::string filterStr = filterJson ? filterJson : "{}";
@@ -11397,7 +11397,7 @@ static void onSetCookieFinished(GObject* source, GAsyncResult* result, gpointer
 }
 
 // Set a cookie (WebKit2GTK)
-ELECTROBUN_EXPORT bool sessionSetCookie(const char* partitionIdentifier, const char* cookieJson) {
+SPARKBUN_EXPORT bool sessionSetCookie(const char* partitionIdentifier, const char* cookieJson) {
     // Copy arguments before dispatching to main thread
     std::string partitionStr = partitionIdentifier ? partitionIdentifier : "";
     std::string jsonStr = cookieJson ? cookieJson : "{}";
@@ -11543,7 +11543,7 @@ static void onDeleteCookieFinished(GObject* source, GAsyncResult* result, gpoint
 }
 
 // Remove a specific cookie (WebKit2GTK)
-ELECTROBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, const char* urlStr, const char* cookieName) {
+SPARKBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, const char* urlStr, const char* cookieName) {
     if (!urlStr || !cookieName) return false;
 
     // Copy arguments before dispatching to main thread
@@ -11650,7 +11650,7 @@ ELECTROBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, cons
 
 // Clear all cookies (WebKit2GTK)
 // Clear all cookies (WebKit2GTK) - STUB implementation to prevent crashes
-ELECTROBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
+SPARKBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
     // Stub implementation: do nothing and return immediately
     // This prevents crashes from complex WebKit async patterns during tests
     // while maintaining API compatibility
@@ -11659,7 +11659,7 @@ ELECTROBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
 }
 
 // Clear storage data (WebKit2GTK)
-ELECTROBUN_EXPORT void sessionClearStorageData(const char* partitionIdentifier, const char* storageTypesJson) {
+SPARKBUN_EXPORT void sessionClearStorageData(const char* partitionIdentifier, const char* storageTypesJson) {
     // Copy arguments before dispatching to main thread
     std::string partitionStr = partitionIdentifier ? partitionIdentifier : "";
     std::string typesStr = storageTypesJson ? storageTypesJson : "";
@@ -11727,29 +11727,29 @@ ELECTROBUN_EXPORT void sessionClearStorageData(const char* partitionIdentifier,
     });
 }
 
-ELECTROBUN_EXPORT void setURLOpenHandler(void (*callback)(const char*)) {
+SPARKBUN_EXPORT void setURLOpenHandler(void (*callback)(const char*)) {
     (void)callback;
     // Not supported on Linux - stub to prevent dlopen failure
     // Linux URL protocol handling is done via desktop file associations
 }
 
-ELECTROBUN_EXPORT void setAppReopenHandler(void (*callback)()) {
+SPARKBUN_EXPORT void setAppReopenHandler(void (*callback)()) {
     (void)callback;
     // Not supported on Linux - stub to prevent dlopen failure
 }
 
-ELECTROBUN_EXPORT void setDockIconVisible(bool visible) {
+SPARKBUN_EXPORT void setDockIconVisible(bool visible) {
     (void)visible;
     // Not supported on Linux - stub to prevent dlopen failure
 }
 
-ELECTROBUN_EXPORT bool isDockIconVisible() {
+SPARKBUN_EXPORT bool isDockIconVisible() {
     // Not supported on Linux
     return true;
 }
 
 // Graceful shutdown function to coordinate cleanup
-ELECTROBUN_EXPORT void shutdownNativeWrapper() {
+SPARKBUN_EXPORT void shutdownNativeWrapper() {
     printf("Starting graceful shutdown of native wrapper...\n");
     
     // Set shutdown flag to prevent new operations