npm - sparkbun - Versions diffs - 0.1.0 - Mend

sparkbun 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (131) hide show

package/bin/sparkbun.cjs +18 -0
package/dist-linux-arm64/bsdiff +0 -0
package/dist-linux-arm64/bspatch +0 -0
package/dist-linux-arm64/libElectrobunCore.so +0 -0
package/dist-linux-arm64/libNativeWrapper.so +0 -0
package/dist-linux-arm64/libasar.so +0 -0
package/dist-linux-x64/bsdiff +0 -0
package/dist-linux-x64/bspatch +0 -0
package/dist-linux-x64/libElectrobunCore.so +0 -0
package/dist-linux-x64/libNativeWrapper.so +0 -0
package/dist-linux-x64/libasar.so +0 -0
package/dist-macos-arm64/bsdiff +0 -0
package/dist-macos-arm64/bspatch +0 -0
package/dist-macos-arm64/libElectrobunCore.dylib +0 -0
package/dist-macos-arm64/libNativeWrapper.dylib +0 -0
package/dist-macos-arm64/libasar.dylib +0 -0
package/dist-macos-arm64/libwebgpu_dawn.dylib +0 -0
package/dist-macos-arm64/preload-full.js +885 -0
package/dist-macos-arm64/preload-sandboxed.js +111 -0
package/dist-macos-arm64/process_helper +0 -0
package/dist-win-x64/ElectrobunCore.dll +0 -0
package/dist-win-x64/WebView2Loader.dll +0 -0
package/dist-win-x64/bsdiff.exe +0 -0
package/dist-win-x64/bspatch.exe +0 -0
package/dist-win-x64/libNativeWrapper.dll +0 -0
package/dist-win-x64/zig-asar/arm64/libasar.dll +0 -0
package/dist-win-x64/zig-asar/x64/libasar.dll +0 -0
package/package.json +47 -0
package/scripts/build-and-upload-artifacts.js +207 -0
package/scripts/gen-webgpu-ffi.mjs +162 -0
package/scripts/install-windows-deps.ps1 +80 -0
package/scripts/package-release.js +237 -0
package/scripts/push-version.js +84 -0
package/scripts/update-bun-version.ts +122 -0
package/scripts/update-cef-version.ts +145 -0
package/src/browser/builtinrpcSchema.ts +19 -0
package/src/browser/global.d.ts +36 -0
package/src/browser/index.ts +234 -0
package/src/browser/webviewtag.ts +88 -0
package/src/browser/wgputag.ts +48 -0
package/src/bun/SparkBunConfig.ts +497 -0
package/src/bun/__tests__/ffi-contract.test.ts +105 -0
package/src/bun/core/ApplicationMenu.ts +70 -0
package/src/bun/core/BrowserView.ts +416 -0
package/src/bun/core/BrowserWindow.ts +396 -0
package/src/bun/core/BuildConfig.ts +71 -0
package/src/bun/core/ContextMenu.ts +75 -0
package/src/bun/core/GpuWindow.ts +289 -0
package/src/bun/core/Paths.ts +5 -0
package/src/bun/core/Socket.ts +22 -0
package/src/bun/core/Tray.ts +197 -0
package/src/bun/core/Updater.ts +1131 -0
package/src/bun/core/Utils.ts +487 -0
package/src/bun/core/WGPUView.ts +167 -0
package/src/bun/core/menuRoles.ts +181 -0
package/src/bun/events/ApplicationEvents.ts +22 -0
package/src/bun/events/event.ts +27 -0
package/src/bun/events/eventEmitter.ts +45 -0
package/src/bun/events/trayEvents.ts +11 -0
package/src/bun/events/webviewEvents.ts +39 -0
package/src/bun/events/windowEvents.ts +23 -0
package/src/bun/index.ts +120 -0
package/src/bun/preload/.generated/compiled.ts +2 -0
package/src/bun/preload/build.ts +65 -0
package/src/bun/preload/dragRegions.ts +41 -0
package/src/bun/preload/encryption.ts +86 -0
package/src/bun/preload/events.ts +171 -0
package/src/bun/preload/globals.d.ts +45 -0
package/src/bun/preload/index-sandboxed.ts +28 -0
package/src/bun/preload/index.ts +77 -0
package/src/bun/preload/internalRpc.ts +80 -0
package/src/bun/preload/overlaySync.ts +107 -0
package/src/bun/preload/webviewTag.ts +451 -0
package/src/bun/preload/wgpuTag.ts +246 -0
package/src/bun/proc/linux.md +43 -0
package/src/bun/proc/native.ts +3253 -0
package/src/bun/webGPU.ts +346 -0
package/src/bun/webgpuAdapter.ts +3011 -0
package/src/cli/bun.lockb +0 -0
package/src/cli/index.ts +4653 -0
package/src/cli/package-lock.json +81 -0
package/src/cli/package.json +11 -0
package/src/cli/templates/embedded.ts +2 -0
package/src/core/build.zig +16 -0
package/src/core/main.zig +3378 -0
package/src/extractor/build.zig +22 -0
package/src/installer/installer-template.ts +216 -0
package/src/launcher/main.ts +221 -0
package/src/native/build/libNativeWrapper.so +0 -0
package/src/native/linux/build/nativeWrapper.o +0 -0
package/src/native/linux/cef_loader.cpp +110 -0
package/src/native/linux/cef_loader.h +28 -0
package/src/native/linux/cef_process_helper_linux.cpp +160 -0
package/src/native/linux/nativeWrapper.cpp +11768 -0
package/src/native/macos/cef_process_helper_mac.cc +160 -0
package/src/native/macos/nativeWrapper.mm +9172 -0
package/src/native/shared/accelerator_parser.h +72 -0
package/src/native/shared/app_paths.h +110 -0
package/src/native/shared/asar.h +35 -0
package/src/native/shared/cache_migration.h +244 -0
package/src/native/shared/callbacks.h +57 -0
package/src/native/shared/cef_response_filter.h +189 -0
package/src/native/shared/chromium_flags.h +181 -0
package/src/native/shared/config.h +66 -0
package/src/native/shared/download_event.h +197 -0
package/src/native/shared/ffi_helpers.h +139 -0
package/src/native/shared/glob_match.h +59 -0
package/src/native/shared/json_menu_parser.h +223 -0
package/src/native/shared/mime_types.h +101 -0
package/src/native/shared/navigation_rules.h +98 -0
package/src/native/shared/partition_context.h +137 -0
package/src/native/shared/pending_resize_queue.h +45 -0
package/src/native/shared/permissions.h +118 -0
package/src/native/shared/permissions_cef.h +74 -0
package/src/native/shared/preload_script.h +71 -0
package/src/native/shared/shutdown_guard.h +134 -0
package/src/native/shared/thread_safe_map.h +138 -0
package/src/native/shared/webview_storage.h +91 -0
package/src/native/win/cef_process_helper_win.cpp +143 -0
package/src/native/win/dcomp_compositor.h +352 -0
package/src/native/win/nativeWrapper.cpp +12434 -0
package/src/npmbin/index.js +34 -0
package/src/shared/bun-version.ts +3 -0
package/src/shared/cef-version.ts +5 -0
package/src/shared/naming.test.ts +327 -0
package/src/shared/naming.ts +188 -0
package/src/shared/platform.ts +48 -0
package/src/shared/rpc.ts +541 -0
package/src/shared/sparkbun-version.ts +2 -0
package/src/types/three.d.ts +1 -0
package/tsconfig.json +31 -0

package/src/native/shared/cef_response_filter.h ADDED Viewed

@@ -0,0 +1,189 @@
+// cef_response_filter.h - Cross-platform CEF response filter for preload script injection
+// Injects preload scripts into HTML responses before any page scripts execute
+// Used across Windows, macOS, and Linux CEF implementations
+//
+// This is a header-only implementation to avoid build complexity.
+// Requires CEF headers to be included before this file.
+#ifndef ELECTROBUN_CEF_RESPONSE_FILTER_H
+#define ELECTROBUN_CEF_RESPONSE_FILTER_H
+#include <string>
+#include <algorithm>
+#include <cstring>
+#include "preload_script.h"
+namespace electrobun {
+// CEF Response Filter that injects preload scripts into HTML responses
+// Injection happens right after <head> tag to ensure scripts run before page scripts
+class ElectrobunResponseFilter : public CefResponseFilter {
+private:
+    std::string buffer_;
+    bool injected_;
+    PreloadScript electrobun_script_;
+    PreloadScript custom_script_;
+public:
+    // Constructor with PreloadScript structs (preferred)
+    ElectrobunResponseFilter(const PreloadScript& electrobunScript,
+                            const PreloadScript& customScript)
+        : injected_(false),
+          electrobun_script_(electrobunScript),
+          custom_script_(customScript) {}
+    // Constructor with raw strings (for compatibility)
+    ElectrobunResponseFilter(const std::string& electrobunScript,
+                            const std::string& customScript = "")
+        : injected_(false),
+          electrobun_script_(electrobunScript),
+          custom_script_(customScript) {}
+    // Single script constructor (for simpler use cases)
+    explicit ElectrobunResponseFilter(const std::string& script)
+        : injected_(false),
+          electrobun_script_(script) {}
+    bool InitFilter() override {
+        buffer_.clear();
+        injected_ = false;
+        return true;
+    }
+    FilterStatus Filter(void* data_in,
+                       size_t data_in_size,
+                       size_t& data_in_read,
+                       void* data_out,
+                       size_t data_out_size,
+                       size_t& data_out_written) override {
+        // If no scripts to inject, pass through directly
+        if (electrobun_script_.empty() && custom_script_.empty()) {
+            size_t copy_size = std::min(data_in_size, data_out_size);
+            std::memcpy(data_out, data_in, copy_size);
+            data_in_read = copy_size;
+            data_out_written = copy_size;
+            return RESPONSE_FILTER_DONE;
+        }
+        // Append incoming data to buffer
+        if (data_in_size > 0) {
+            buffer_.append(static_cast<char*>(data_in), data_in_size);
+            data_in_read = data_in_size;
+        } else {
+            data_in_read = 0;
+        }
+        // If already injected, just output buffered data
+        if (injected_) {
+            return OutputBufferedData(data_out, data_out_size, data_out_written);
+        }
+        // Try to inject scripts
+        TryInjectScripts();
+        // Output buffered data
+        return OutputBufferedData(data_out, data_out_size, data_out_written);
+    }
+private:
+    void TryInjectScripts() {
+        if (injected_) return;
+        std::string script_tag = BuildScriptTag();
+        if (script_tag.empty()) return;
+        // Strategy 1: Look for <head> tag (most common case)
+        size_t head_pos = FindTagCaseInsensitive("<head>");
+        if (head_pos != std::string::npos) {
+            // Find the end of <head> or <head ...>
+            size_t insert_pos = buffer_.find('>', head_pos);
+            if (insert_pos != std::string::npos) {
+                buffer_.insert(insert_pos + 1, script_tag);
+                injected_ = true;
+                return;
+            }
+        }
+        // Strategy 2: Look for <head with attributes (e.g., <head class="...">)
+        head_pos = FindTagCaseInsensitive("<head ");
+        if (head_pos != std::string::npos) {
+            size_t insert_pos = buffer_.find('>', head_pos);
+            if (insert_pos != std::string::npos) {
+                buffer_.insert(insert_pos + 1, script_tag);
+                injected_ = true;
+                return;
+            }
+        }
+        // If buffer is large enough, try fallback strategies
+        if (buffer_.size() > 1024) {
+            // Strategy 3: Look for <html> and create a <head> section
+            size_t html_pos = FindTagCaseInsensitive("<html");
+            if (html_pos != std::string::npos) {
+                size_t insert_pos = buffer_.find('>', html_pos);
+                if (insert_pos != std::string::npos) {
+                    std::string head_with_script = "<head>" + script_tag + "</head>";
+                    buffer_.insert(insert_pos + 1, head_with_script);
+                    injected_ = true;
+                    return;
+                }
+            }
+            // Strategy 4: Last resort - inject at the very beginning
+            buffer_.insert(0, script_tag);
+            injected_ = true;
+        }
+    }
+    std::string BuildScriptTag() const {
+        if (electrobun_script_.empty() && custom_script_.empty()) {
+            return "";
+        }
+        std::string result = "<script>\n";
+        if (!electrobun_script_.empty()) {
+            result += electrobun_script_.code;
+            result += "\n";
+        }
+        if (!custom_script_.empty()) {
+            result += custom_script_.code;
+            result += "\n";
+        }
+        result += "</script>\n";
+        return result;
+    }
+    // Case-insensitive tag search
+    size_t FindTagCaseInsensitive(const std::string& tag) const {
+        std::string lower_buffer = buffer_;
+        std::string lower_tag = tag;
+        std::transform(lower_buffer.begin(), lower_buffer.end(), lower_buffer.begin(),
+                      [](unsigned char c) { return std::tolower(c); });
+        std::transform(lower_tag.begin(), lower_tag.end(), lower_tag.begin(),
+                      [](unsigned char c) { return std::tolower(c); });
+        return lower_buffer.find(lower_tag);
+    }
+    FilterStatus OutputBufferedData(void* data_out, size_t data_out_size, size_t& data_out_written) {
+        size_t copy_size = std::min(buffer_.size(), data_out_size);
+        if (copy_size > 0) {
+            std::memcpy(data_out, buffer_.c_str(), copy_size);
+            buffer_.erase(0, copy_size);
+        }
+        data_out_written = copy_size;
+        return buffer_.empty() ? RESPONSE_FILTER_DONE : RESPONSE_FILTER_NEED_MORE_DATA;
+    }
+    IMPLEMENT_REFCOUNTING(ElectrobunResponseFilter);
+};
+} // namespace electrobun
+#endif // ELECTROBUN_CEF_RESPONSE_FILTER_H

package/src/native/shared/chromium_flags.h ADDED Viewed

@@ -0,0 +1,181 @@
+// chromium_flags.h - Cross-platform Chromium CLI flag passthrough
+// Reads user-defined Chromium flags from build.json and applies them
+// to CEF's command line during initialization.
+// Used across Windows, macOS, and Linux.
+//
+// This is a header-only implementation to avoid build complexity.
+#ifndef ELECTROBUN_CHROMIUM_FLAGS_H
+#define ELECTROBUN_CHROMIUM_FLAGS_H
+#include <string>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <sstream>
+// Forward-declare CEF types so this header can be included without
+// pulling in the full CEF headers (the call sites already include them).
+#include "include/cef_command_line.h"
+namespace electrobun {
+struct ChromiumFlag {
+    std::string name;
+    std::string value;
+    bool hasValue;
+};
+struct ChromiumFlagConfig {
+    std::vector<ChromiumFlag> flags;  // flags to add (true / "value")
+    std::set<std::string> skip;       // default flags to skip (any user-specified flag overrides its default)
+};
+// Read an entire file into a string. Returns empty string on failure.
+inline std::string readFileToString(const std::string& path) {
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        return "";
+    }
+    std::stringstream buf;
+    buf << file.rdbuf();
+    return buf.str();
+}
+// Parse the "chromiumFlags" object from build.json content.
+// Handles three value types:
+//   "flag-name": true        -> add switch (hasValue = false)
+//   "flag-name": "value"     -> add switch with value (hasValue = true)
+//   "flag-name": false       -> skip a default flag set by Electrobun
+inline ChromiumFlagConfig parseChromiumFlags(const std::string& json) {
+    ChromiumFlagConfig config;
+    // Find the "chromiumFlags" key
+    std::string key = "\"chromiumFlags\"";
+    size_t keyPos = json.find(key);
+    if (keyPos == std::string::npos) {
+        return config;
+    }
+    // Find the opening brace of the object
+    size_t objStart = json.find('{', keyPos + key.length());
+    if (objStart == std::string::npos) {
+        return config;
+    }
+    // Find the matching closing brace (handles nested depth = 0 since
+    // chromiumFlags values are only primitives, not nested objects)
+    int depth = 1;
+    size_t objEnd = objStart + 1;
+    while (objEnd < json.size() && depth > 0) {
+        if (json[objEnd] == '{') depth++;
+        else if (json[objEnd] == '}') depth--;
+        objEnd++;
+    }
+    std::string objContent = json.substr(objStart + 1, objEnd - objStart - 2);
+    // Iterate over key-value pairs inside the object
+    size_t pos = 0;
+    while (pos < objContent.size()) {
+        // Find next quoted key
+        size_t nameStart = objContent.find('"', pos);
+        if (nameStart == std::string::npos) break;
+        nameStart++;
+        size_t nameEnd = objContent.find('"', nameStart);
+        if (nameEnd == std::string::npos) break;
+        std::string flagName = objContent.substr(nameStart, nameEnd - nameStart);
+        // Skip past the colon
+        size_t colon = objContent.find(':', nameEnd + 1);
+        if (colon == std::string::npos) break;
+        // Skip whitespace after colon
+        size_t valStart = colon + 1;
+        while (valStart < objContent.size() &&
+               (objContent[valStart] == ' ' || objContent[valStart] == '\t' ||
+                objContent[valStart] == '\n' || objContent[valStart] == '\r')) {
+            valStart++;
+        }
+        if (valStart >= objContent.size()) break;
+        // Any user-specified flag overrides the corresponding default
+        config.skip.insert(flagName);
+        if (objContent[valStart] == '"') {
+            // String value — add flag with value
+            valStart++;
+            size_t valEnd = objContent.find('"', valStart);
+            if (valEnd == std::string::npos) break;
+            ChromiumFlag flag;
+            flag.name = flagName;
+            flag.value = objContent.substr(valStart, valEnd - valStart);
+            flag.hasValue = true;
+            config.flags.push_back(flag);
+            pos = valEnd + 1;
+        } else {
+            // Boolean token — "false" means skip only, "true" means add
+            size_t tokenEnd = valStart;
+            while (tokenEnd < objContent.size() &&
+                   objContent[tokenEnd] != ',' && objContent[tokenEnd] != '}' &&
+                   objContent[tokenEnd] != '\n') {
+                tokenEnd++;
+            }
+            std::string token = objContent.substr(valStart, tokenEnd - valStart);
+            // Trim whitespace from token
+            while (!token.empty() && (token.back() == ' ' || token.back() == '\t' || token.back() == '\r')) {
+                token.pop_back();
+            }
+            if (token != "false") {
+                // true or any other value — add as switch-only
+                ChromiumFlag flag;
+                flag.name = flagName;
+                flag.hasValue = false;
+                config.flags.push_back(flag);
+            }
+            pos = tokenEnd;
+        }
+    }
+    return config;
+}
+// A default flag: either a switch-only or a switch with a value.
+struct DefaultFlag {
+    std::string name;
+    std::string value;  // empty = switch-only
+};
+// Apply a list of default flags, skipping any that the user overrode.
+inline void applyDefaultFlags(const std::vector<DefaultFlag>& defaults,
+                              const std::set<std::string>& skip,
+                              CefRefPtr<CefCommandLine> command_line) {
+    for (const auto& def : defaults) {
+        if (skip.count(def.name) > 0) continue;
+        if (def.value.empty()) {
+            command_line->AppendSwitch(def.name);
+        } else {
+            command_line->AppendSwitchWithValue(def.name, def.value);
+        }
+    }
+}
+// Apply user-defined flags to a CefCommandLine. Call this from
+// OnBeforeCommandLineProcessing after default flags.
+inline void applyChromiumFlags(const ChromiumFlagConfig& config,
+                               CefRefPtr<CefCommandLine> command_line) {
+    for (const auto& flag : config.flags) {
+        if (flag.hasValue) {
+            command_line->AppendSwitchWithValue(flag.name, flag.value);
+        } else {
+            command_line->AppendSwitch(flag.name);
+        }
+    }
+}
+} // namespace electrobun
+#endif // ELECTROBUN_CHROMIUM_FLAGS_H

package/src/native/shared/config.h ADDED Viewed

@@ -0,0 +1,66 @@
+// config.h - Cross-platform global configuration
+// Used for CEF cache path isolation and app identification
+// across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+#ifndef ELECTROBUN_CONFIG_H
+#define ELECTROBUN_CONFIG_H
+#include <string>
+#include <mutex>
+namespace electrobun {
+// Thread-safe configuration singleton
+class Config {
+public:
+    static Config& getInstance() {
+        static Config instance;
+        return instance;
+    }
+    void setChannel(const std::string& channel) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        channel_ = channel;
+    }
+    std::string getChannel() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return channel_;
+    }
+    void setIdentifier(const std::string& identifier) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        identifier_ = identifier;
+    }
+    std::string getIdentifier() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return identifier_;
+    }
+    void setName(const std::string& name) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        name_ = name;
+    }
+    std::string getName() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return name_;
+    }
+private:
+    Config() = default;
+    Config(const Config&) = delete;
+    Config& operator=(const Config&) = delete;
+    mutable std::mutex mutex_;
+    std::string channel_;
+    std::string identifier_;
+    std::string name_;
+};
+} // namespace electrobun
+#endif // ELECTROBUN_CONFIG_H

package/src/native/shared/download_event.h ADDED Viewed

@@ -0,0 +1,197 @@
+// download_event.h - Cross-platform download event structures
+// Common data structures for download events
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+#ifndef ELECTROBUN_DOWNLOAD_EVENT_H
+#define ELECTROBUN_DOWNLOAD_EVENT_H
+#include <string>
+#include <cstdint>
+#include <sstream>
+namespace electrobun {
+// Download event types
+enum class DownloadEventType {
+    STARTED,
+    PROGRESS,
+    COMPLETED,
+    CANCELLED,
+    FAILED
+};
+// Convert event type to string
+inline const char* downloadEventTypeToString(DownloadEventType type) {
+    switch (type) {
+        case DownloadEventType::STARTED:   return "download-started";
+        case DownloadEventType::PROGRESS:  return "download-progress";
+        case DownloadEventType::COMPLETED: return "download-completed";
+        case DownloadEventType::CANCELLED: return "download-cancelled";
+        case DownloadEventType::FAILED:    return "download-failed";
+        default: return "download-unknown";
+    }
+}
+// Download event data structure
+struct DownloadEvent {
+    uint32_t downloadId = 0;
+    std::string url;
+    std::string filename;
+    std::string mimeType;
+    std::string destinationPath;
+    int64_t totalBytes = -1;      // -1 if unknown
+    int64_t receivedBytes = 0;
+    int percentComplete = 0;
+    bool canResume = false;
+    std::string errorMessage;
+    // Serialize to JSON string for FFI callbacks
+    std::string toJson() const {
+        std::ostringstream ss;
+        ss << "{";
+        ss << "\"downloadId\":" << downloadId;
+        if (!url.empty()) {
+            ss << ",\"url\":\"" << escapeJson(url) << "\"";
+        }
+        if (!filename.empty()) {
+            ss << ",\"filename\":\"" << escapeJson(filename) << "\"";
+        }
+        if (!mimeType.empty()) {
+            ss << ",\"mimeType\":\"" << escapeJson(mimeType) << "\"";
+        }
+        if (!destinationPath.empty()) {
+            ss << ",\"destinationPath\":\"" << escapeJson(destinationPath) << "\"";
+        }
+        ss << ",\"totalBytes\":" << totalBytes;
+        ss << ",\"receivedBytes\":" << receivedBytes;
+        ss << ",\"percentComplete\":" << percentComplete;
+        ss << ",\"canResume\":" << (canResume ? "true" : "false");
+        if (!errorMessage.empty()) {
+            ss << ",\"errorMessage\":\"" << escapeJson(errorMessage) << "\"";
+        }
+        ss << "}";
+        return ss.str();
+    }
+    // Serialize to simple key=value format (legacy format)
+    std::string toKeyValue() const {
+        std::ostringstream ss;
+        ss << "downloadId=" << downloadId;
+        if (!url.empty()) {
+            ss << "&url=" << url;
+        }
+        if (!filename.empty()) {
+            ss << "&filename=" << filename;
+        }
+        if (!mimeType.empty()) {
+            ss << "&mimeType=" << mimeType;
+        }
+        if (!destinationPath.empty()) {
+            ss << "&destinationPath=" << destinationPath;
+        }
+        ss << "&totalBytes=" << totalBytes;
+        ss << "&receivedBytes=" << receivedBytes;
+        ss << "&percentComplete=" << percentComplete;
+        return ss.str();
+    }
+private:
+    // Simple JSON string escaping
+    static std::string escapeJson(const std::string& str) {
+        std::string result;
+        result.reserve(str.length() * 2);
+        for (char c : str) {
+            switch (c) {
+                case '"':  result += "\\\""; break;
+                case '\\': result += "\\\\"; break;
+                case '\b': result += "\\b";  break;
+                case '\f': result += "\\f";  break;
+                case '\n': result += "\\n";  break;
+                case '\r': result += "\\r";  break;
+                case '\t': result += "\\t";  break;
+                default:   result += c;      break;
+            }
+        }
+        return result;
+    }
+};
+// Builder pattern for download events
+class DownloadEventBuilder {
+public:
+    DownloadEventBuilder& setDownloadId(uint32_t id) {
+        event_.downloadId = id;
+        return *this;
+    }
+    DownloadEventBuilder& setUrl(const std::string& url) {
+        event_.url = url;
+        return *this;
+    }
+    DownloadEventBuilder& setFilename(const std::string& filename) {
+        event_.filename = filename;
+        return *this;
+    }
+    DownloadEventBuilder& setMimeType(const std::string& mimeType) {
+        event_.mimeType = mimeType;
+        return *this;
+    }
+    DownloadEventBuilder& setDestinationPath(const std::string& path) {
+        event_.destinationPath = path;
+        return *this;
+    }
+    DownloadEventBuilder& setTotalBytes(int64_t bytes) {
+        event_.totalBytes = bytes;
+        return *this;
+    }
+    DownloadEventBuilder& setReceivedBytes(int64_t bytes) {
+        event_.receivedBytes = bytes;
+        return *this;
+    }
+    DownloadEventBuilder& setPercentComplete(int percent) {
+        event_.percentComplete = percent;
+        return *this;
+    }
+    DownloadEventBuilder& setCanResume(bool canResume) {
+        event_.canResume = canResume;
+        return *this;
+    }
+    DownloadEventBuilder& setErrorMessage(const std::string& msg) {
+        event_.errorMessage = msg;
+        return *this;
+    }
+    DownloadEvent build() const {
+        return event_;
+    }
+    std::string toJson() const {
+        return event_.toJson();
+    }
+private:
+    DownloadEvent event_;
+};
+} // namespace electrobun
+#endif // ELECTROBUN_DOWNLOAD_EVENT_H