@zappdev/cli 0.1.0

package/native/src/platform/windows/worker/core/websocket_core.zc

@@ -0,0 +1,343 @@
+// Win32-native WebSocket using WinHTTP WebSocket APIs.
+// Mirrors the interface of darwin/worker/core/websocket_core.zc.
+
+//> windows: link: -lwinhttp
+
+raw {
+#ifdef _WIN32
+    #include <windows.h>
+    #include <winhttp.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+
+    typedef void (*zapp_ws_event_fn)(
+        const char* ws_id,
+        const char* event_type,
+        const char* json_payload,
+        void* user_data
+    );
+
+    // Per-connection state
+    typedef struct {
+        char ws_id[64];
+        HINTERNET session;
+        HINTERNET connection;
+        HINTERNET websocket;
+        zapp_ws_event_fn callback;
+        void* user_data;
+        HANDLE thread;
+        volatile int closed;
+    } ZappWsConn;
+
+    #define ZAPP_WS_MAX 64
+    static ZappWsConn zapp_ws_conns[ZAPP_WS_MAX] = {0};
+    static int zapp_ws_id_counter = 1;
+    static CRITICAL_SECTION zapp_ws_lock;
+    static int zapp_ws_lock_init = 0;
+
+    static void zapp_ws_ensure_init(void) {
+        if (!zapp_ws_lock_init) {
+            InitializeCriticalSection(&zapp_ws_lock);
+            zapp_ws_lock_init = 1;
+        }
+    }
+
+    static ZappWsConn* zapp_ws_find(const char* ws_id) {
+        if (!ws_id) return NULL;
+        for (int i = 0; i < ZAPP_WS_MAX; i++) {
+            if (zapp_ws_conns[i].ws_id[0] && strcmp(zapp_ws_conns[i].ws_id, ws_id) == 0)
+                return &zapp_ws_conns[i];
+        }
+        return NULL;
+    }
+
+    static ZappWsConn* zapp_ws_alloc(void) {
+        for (int i = 0; i < ZAPP_WS_MAX; i++) {
+            if (!zapp_ws_conns[i].ws_id[0]) return &zapp_ws_conns[i];
+        }
+        return NULL;
+    }
+
+    static void zapp_ws_fire(ZappWsConn* c, const char* event_type, const char* json_payload) {
+        if (!c || !c->callback) return;
+        c->callback(c->ws_id, event_type, json_payload ? json_payload : "{}", c->user_data);
+    }
+
+    static char* zapp_ws_escape_json_string(const char* s) {
+        if (!s) return _strdup("");
+        size_t slen = strlen(s);
+        size_t cap = slen * 2 + 1;
+        char* out = (char*)malloc(cap);
+        size_t j = 0;
+        for (size_t i = 0; i < slen; i++) {
+            if (j + 6 >= cap) { cap *= 2; out = (char*)realloc(out, cap); }
+            char ch = s[i];
+            if (ch == '"') { out[j++] = '\\'; out[j++] = '"'; }
+            else if (ch == '\\') { out[j++] = '\\'; out[j++] = '\\'; }
+            else if (ch == '\n') { out[j++] = '\\'; out[j++] = 'n'; }
+            else if (ch == '\r') { out[j++] = '\\'; out[j++] = 'r'; }
+            else if (ch == '\t') { out[j++] = '\\'; out[j++] = 't'; }
+            else out[j++] = ch;
+        }
+        out[j] = '\0';
+        return out;
+    }
+
+    // Receive loop running on a dedicated thread
+    static DWORD WINAPI zapp_ws_receive_thread(LPVOID param) {
+        ZappWsConn* c = (ZappWsConn*)param;
+        BYTE buf[65536];
+        DWORD bytesRead = 0;
+        WINHTTP_WEB_SOCKET_BUFFER_TYPE bufType;
+
+        while (!c->closed && c->websocket) {
+            DWORD err = WinHttpWebSocketReceive(c->websocket, buf, sizeof(buf) - 1, &bytesRead, &bufType);
+            if (err != NO_ERROR) {
+                if (!c->closed) {
+                    char errJson[256];
+                    snprintf(errJson, sizeof(errJson),
+                        "{\"type\":\"error\",\"wsId\":\"%s\",\"message\":\"Receive error: %lu\"}",
+                        c->ws_id, err);
+                    zapp_ws_fire(c, "error", errJson);
+                }
+                break;
+            }
+
+            if (bufType == WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE) {
+                USHORT statusCode = 0;
+                BYTE reasonBuf[256] = {0};
+                DWORD reasonLen = 0;
+                WinHttpWebSocketQueryCloseStatus(c->websocket, &statusCode, reasonBuf, sizeof(reasonBuf) - 1, &reasonLen);
+                reasonBuf[reasonLen] = '\0';
+
+                char* escapedReason = zapp_ws_escape_json_string((const char*)reasonBuf);
+                char closeJson[512];
+                snprintf(closeJson, sizeof(closeJson),
+                    "{\"type\":\"close\",\"wsId\":\"%s\",\"code\":%d,\"reason\":\"%s\",\"wasClean\":true}",
+                    c->ws_id, (int)statusCode, escapedReason);
+                free(escapedReason);
+                zapp_ws_fire(c, "close", closeJson);
+                break;
+            }
+
+            if (bufType == WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE ||
+                bufType == WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE) {
+                buf[bytesRead] = '\0';
+                char* escaped = zapp_ws_escape_json_string((const char*)buf);
+                size_t jsonLen = strlen(escaped) + 128 + strlen(c->ws_id);
+                char* msgJson = (char*)malloc(jsonLen);
+                snprintf(msgJson, jsonLen,
+                    "{\"type\":\"message\",\"wsId\":\"%s\",\"data\":\"%s\",\"binary\":false}",
+                    c->ws_id, escaped);
+                free(escaped);
+                zapp_ws_fire(c, "message", msgJson);
+                free(msgJson);
+            } else if (bufType == WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE ||
+                       bufType == WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE) {
+                // Build a JSON array of bytes
+                size_t arrCap = bytesRead * 4 + 64 + strlen(c->ws_id) + 64;
+                char* msgJson = (char*)malloc(arrCap);
+                int off = snprintf(msgJson, arrCap,
+                    "{\"type\":\"message\",\"wsId\":\"%s\",\"data\":[", c->ws_id);
+                for (DWORD i = 0; i < bytesRead; i++) {
+                    if (i > 0) off += snprintf(msgJson + off, arrCap - off, ",");
+                    off += snprintf(msgJson + off, arrCap - off, "%u", (unsigned)buf[i]);
+                }
+                off += snprintf(msgJson + off, arrCap - off, "],\"binary\":true}");
+                zapp_ws_fire(c, "message", msgJson);
+                free(msgJson);
+            }
+        }
+        return 0;
+    }
+
+    // Connect. Returns wsId C string (caller must free), or NULL on failure.
+    static char* zapp_core_ws_connect(const char* url_str, const char** protocols, int protocol_count,
+                                       zapp_ws_event_fn callback, void* user_data) {
+        zapp_ws_ensure_init();
+        if (!url_str || !callback) return NULL;
+
+        // Parse URL: ws://host:port/path or wss://host:port/path
+        int secure = 0;
+        const char* hostStart = url_str;
+        if (strncmp(url_str, "wss://", 6) == 0) { hostStart = url_str + 6; secure = 1; }
+        else if (strncmp(url_str, "ws://", 5) == 0) { hostStart = url_str + 5; }
+        else return NULL;
+
+        char host[256] = {0};
+        INTERNET_PORT port = secure ? INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT;
+        const char* slash = strchr(hostStart, '/');
+        const char* colon = strchr(hostStart, ':');
+        if (colon && (!slash || colon < slash)) {
+            size_t hlen = (size_t)(colon - hostStart);
+            if (hlen >= sizeof(host)) return NULL;
+            memcpy(host, hostStart, hlen);
+            port = (INTERNET_PORT)atoi(colon + 1);
+        } else if (slash) {
+            size_t hlen = (size_t)(slash - hostStart);
+            if (hlen >= sizeof(host)) return NULL;
+            memcpy(host, hostStart, hlen);
+        } else {
+            strncpy(host, hostStart, sizeof(host) - 1);
+        }
+
+        const char* pathStr = slash ? slash : "/";
+        wchar_t wHost[256], wPath[1024];
+        MultiByteToWideChar(CP_UTF8, 0, host, -1, wHost, 256);
+        MultiByteToWideChar(CP_UTF8, 0, pathStr, -1, wPath, 1024);
+
+        HINTERNET session = WinHttpOpen(L"Zapp/1.0", WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
+        if (!session) return NULL;
+
+        HINTERNET connection = WinHttpConnect(session, wHost, port, 0);
+        if (!connection) { WinHttpCloseHandle(session); return NULL; }
+
+        DWORD flags = secure ? WINHTTP_FLAG_SECURE : 0;
+        HINTERNET request = WinHttpOpenRequest(connection, L"GET", wPath, NULL, NULL, NULL, flags);
+        if (!request) { WinHttpCloseHandle(connection); WinHttpCloseHandle(session); return NULL; }
+
+        // Add subprotocol header if requested
+        if (protocols && protocol_count > 0) {
+            size_t headerLen = 64;
+            for (int i = 0; i < protocol_count; i++) {
+                if (protocols[i]) headerLen += strlen(protocols[i]) + 2;
+            }
+            char* header = (char*)malloc(headerLen);
+            int off = snprintf(header, headerLen, "Sec-WebSocket-Protocol: ");
+            for (int i = 0; i < protocol_count; i++) {
+                if (protocols[i]) {
+                    if (i > 0) off += snprintf(header + off, headerLen - off, ", ");
+                    off += snprintf(header + off, headerLen - off, "%s", protocols[i]);
+                }
+            }
+            wchar_t wHeader[1024];
+            MultiByteToWideChar(CP_UTF8, 0, header, -1, wHeader, 1024);
+            WinHttpAddRequestHeaders(request, wHeader, (ULONG)-1L, WINHTTP_ADDREQ_FLAG_ADD);
+            free(header);
+        }
+
+        // Upgrade to WebSocket
+        if (!WinHttpSetOption(request, WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET, NULL, 0)) {
+            WinHttpCloseHandle(request); WinHttpCloseHandle(connection); WinHttpCloseHandle(session);
+            return NULL;
+        }
+
+        if (!WinHttpSendRequest(request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, NULL, 0, 0, 0) ||
+            !WinHttpReceiveResponse(request, NULL)) {
+            WinHttpCloseHandle(request); WinHttpCloseHandle(connection); WinHttpCloseHandle(session);
+            return NULL;
+        }
+
+        HINTERNET websocket = WinHttpWebSocketCompleteUpgrade(request, 0);
+        WinHttpCloseHandle(request);
+        if (!websocket) {
+            WinHttpCloseHandle(connection); WinHttpCloseHandle(session);
+            return NULL;
+        }
+
+        EnterCriticalSection(&zapp_ws_lock);
+        ZappWsConn* c = zapp_ws_alloc();
+        if (!c) {
+            LeaveCriticalSection(&zapp_ws_lock);
+            WinHttpWebSocketClose(websocket, WINHTTP_WEB_SOCKET_SUCCESS_CLOSE_STATUS, NULL, 0);
+            WinHttpCloseHandle(websocket); WinHttpCloseHandle(connection); WinHttpCloseHandle(session);
+            return NULL;
+        }
+
+        snprintf(c->ws_id, sizeof(c->ws_id), "ws-%d", zapp_ws_id_counter++);
+        c->session = session;
+        c->connection = connection;
+        c->websocket = websocket;
+        c->callback = callback;
+        c->user_data = user_data;
+        c->closed = 0;
+        c->thread = CreateThread(NULL, 0, zapp_ws_receive_thread, c, 0, NULL);
+        LeaveCriticalSection(&zapp_ws_lock);
+
+        // Fire open event
+        char openJson[128];
+        snprintf(openJson, sizeof(openJson), "{\"type\":\"open\",\"wsId\":\"%s\"}", c->ws_id);
+        zapp_ws_fire(c, "open", openJson);
+
+        return _strdup(c->ws_id);
+    }
+
+    static void zapp_core_ws_send_text(const char* ws_id, const char* text) {
+        if (!ws_id || !text) return;
+        EnterCriticalSection(&zapp_ws_lock);
+        ZappWsConn* c = zapp_ws_find(ws_id);
+        LeaveCriticalSection(&zapp_ws_lock);
+        if (!c || c->closed || !c->websocket) return;
+
+        DWORD len = (DWORD)strlen(text);
+        DWORD err = WinHttpWebSocketSend(c->websocket,
+            WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE, (PVOID)text, len);
+        if (err != NO_ERROR) {
+            char errJson[256];
+            snprintf(errJson, sizeof(errJson),
+                "{\"type\":\"error\",\"wsId\":\"%s\",\"message\":\"Send failed: %lu\"}",
+                ws_id, err);
+            zapp_ws_fire(c, "error", errJson);
+        }
+    }
+
+    static void zapp_core_ws_send_binary(const char* ws_id, const uint8_t* bytes, size_t len) {
+        if (!ws_id || !bytes || len == 0) return;
+        EnterCriticalSection(&zapp_ws_lock);
+        ZappWsConn* c = zapp_ws_find(ws_id);
+        LeaveCriticalSection(&zapp_ws_lock);
+        if (!c || c->closed || !c->websocket) return;
+
+        DWORD err = WinHttpWebSocketSend(c->websocket,
+            WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE, (PVOID)bytes, (DWORD)len);
+        if (err != NO_ERROR) {
+            char errJson[256];
+            snprintf(errJson, sizeof(errJson),
+                "{\"type\":\"error\",\"wsId\":\"%s\",\"message\":\"Binary send failed: %lu\"}",
+                ws_id, err);
+            zapp_ws_fire(c, "error", errJson);
+        }
+    }
+
+    static void zapp_core_ws_close(const char* ws_id, int code, const char* reason) {
+        if (!ws_id) return;
+
+        EnterCriticalSection(&zapp_ws_lock);
+        ZappWsConn* c = zapp_ws_find(ws_id);
+        if (!c || c->closed) {
+            LeaveCriticalSection(&zapp_ws_lock);
+            return;
+        }
+        c->closed = 1;
+        LeaveCriticalSection(&zapp_ws_lock);
+
+        if (c->websocket) {
+            DWORD reasonLen = reason ? (DWORD)strlen(reason) : 0;
+            WinHttpWebSocketClose(c->websocket, (USHORT)code, reason ? (PVOID)reason : NULL, reasonLen);
+        }
+
+        // Fire close event
+        char* escapedReason = zapp_ws_escape_json_string(reason ? reason : "");
+        char closeJson[512];
+        snprintf(closeJson, sizeof(closeJson),
+            "{\"type\":\"close\",\"wsId\":\"%s\",\"code\":%d,\"reason\":\"%s\",\"wasClean\":true}",
+            ws_id, code, escapedReason);
+        free(escapedReason);
+        zapp_ws_fire(c, "close", closeJson);
+
+        // Wait for receive thread to exit
+        if (c->thread) {
+            WaitForSingleObject(c->thread, 2000);
+            CloseHandle(c->thread);
+        }
+
+        // Cleanup handles
+        if (c->websocket) WinHttpCloseHandle(c->websocket);
+        if (c->connection) WinHttpCloseHandle(c->connection);
+        if (c->session) WinHttpCloseHandle(c->session);
+
+        memset(c, 0, sizeof(ZappWsConn));
+    }
+#endif
+}

package/native/src/platform/windows/worker/dispatch.zc

@@ -0,0 +1,34 @@
+raw {
+#if defined(_WIN32) && defined(ZAPP_WORKER_ENGINE_QJS)
+    #include <windows.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+
+    extern void zapp_windows_webview_eval_all(const char* js_utf8);
+    extern char* zapp_escape_js_string(const char* raw);
+
+    void zapp_dispatch_worker_to_webviews(const char* kind, const char* worker_id, const char* payload_json) {
+        if (kind == NULL || worker_id == NULL) return;
+        if (payload_json == NULL) payload_json = "null";
+
+        char* escaped_kind = zapp_escape_js_string(kind);
+        char* escaped_wid = zapp_escape_js_string(worker_id);
+
+        size_t jsLen = strlen(escaped_kind) + strlen(escaped_wid) + strlen(payload_json) + 256;
+        char* js = (char*)malloc(jsLen);
+        snprintf(js, jsLen,
+            "(function(){var b=globalThis[Symbol.for('zapp.bridge')];"
+            "if(b&&typeof b.dispatchWorkerBridge==='function'){"
+            "b.dispatchWorkerBridge('%s','%s',%s);}})();",
+            escaped_kind, escaped_wid, payload_json
+        );
+
+        zapp_windows_webview_eval_all(js);
+
+        free(js);
+        free(escaped_kind);
+        free(escaped_wid);
+    }
+#endif
+}

package/native/src/platform/windows/worker/mod.zc

@@ -0,0 +1,46 @@
+// Windows worker: QuickJS engine, opt-in via ZAPP_WORKER_ENGINE_QJS define.
+
+import "../../worker.zc";
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+import "./qjs.zc";
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+fn windows_platform_bind_runtime(app: App*) -> void {
+    raw {
+    #ifdef _WIN32
+        zapp_ui_thread_id = GetCurrentThreadId();
+    #endif
+    }
+    (WindowsWorkerQjs{}).bind_runtime(app);
+}
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+fn windows_platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    (WindowsWorkerQjs{}).handle_bridge(app, action, payload);
+}
+
+// No-op stubs when QJS workers are disabled
+@cfg(not(ZAPP_WORKER_ENGINE_QJS))
+fn windows_platform_bind_runtime(app: App*) -> void {
+    let _a = app;
+}
+
+@cfg(not(ZAPP_WORKER_ENGINE_QJS))
+fn windows_platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    let _a = app; let _b = action; let _c = payload;
+}
+
+raw {
+#if defined(_WIN32) && !defined(ZAPP_WORKER_ENGINE_QJS)
+    // Stubs for worker functions referenced outside the worker module
+    void zapp_windows_reset_owner_workers(const char* owner_id) { (void)owner_id; }
+    void zapp_windows_reset_all_workers(void) {}
+    void zapp_windows_send_event_to_js(void* app_ptr, char* name, char* payload) {
+        (void)app_ptr; (void)name; (void)payload;
+    }
+    void zapp_windows_worker_dispatch_sync_result(const char* worker_id, const char* payload_json) {
+        (void)worker_id; (void)payload_json;
+    }
+#endif
+}

package/native/src/platform/windows/worker/qjs/fetch_qjs.zc

@@ -0,0 +1,255 @@
+// QJS wrapper for fetch on Windows. Delegates to core/fetch_core.zc.
+
+raw {
+#if defined(_WIN32) && defined(ZAPP_WORKER_ENGINE_QJS)
+    #include "quickjs.h"
+    #include "quickjs-libc.h"
+    #include <stdlib.h>
+    #include <string.h>
+
+    extern void* zapp_windows_qjs_get_context(const char* workerId);
+    extern void zapp_windows_qjs_dispatch(void (*func)(void*), void* data);
+    extern void zapp_windows_qjs_drain_jobs(void* ctx, const char* label);
+    extern void zapp_log_worker(int level, int window_id, int worker_id, const char* message);
+    #ifndef ZAPP_LOG_ERROR
+    #define ZAPP_LOG_ERROR 0
+    #define ZAPP_LOG_WARN  1
+    #define ZAPP_LOG_INFO  2
+    #define ZAPP_LOG_DEBUG 3
+    #define ZAPP_LOG_TRACE 4
+    #endif
+
+
+    typedef struct {
+        char workerId[128];
+        JSContext* creatingCtx;
+        JSValue savedResolve;
+        JSValue savedReject;
+        zapp_fetch_response_t* response;
+        char* error;
+    } ZappFetchResultData;
+
+    static void zapp_fetch_deliver_on_qjs(void* data) {
+        ZappFetchResultData* d = (ZappFetchResultData*)data;
+
+        void* ctx_ptr = zapp_windows_qjs_get_context(d->workerId);
+        if (!ctx_ptr || (JSContext*)ctx_ptr != d->creatingCtx) {
+            JS_FreeValue(d->creatingCtx, d->savedResolve);
+            JS_FreeValue(d->creatingCtx, d->savedReject);
+            if (d->error) free(d->error);
+            if (d->response) {
+                free(d->response->status_text);
+                for (int i = 0; i < d->response->header_count; i++) {
+                    free(d->response->header_keys[i]);
+                    free(d->response->header_values[i]);
+                }
+                free(d->response->header_keys);
+                free(d->response->header_values);
+                free(d->response->body);
+                free(d->response->body_base64);
+                free(d->response);
+            }
+            free(d);
+            return;
+        }
+
+        JSContext* ctx = (JSContext*)ctx_ptr;
+
+        if (d->error) {
+            JSValue args[1] = { JS_NewString(ctx, d->error) };
+            JSValue ret = JS_Call(ctx, d->savedReject, JS_UNDEFINED, 1, args);
+            if (JS_IsException(ret)) {
+                JSValue exc = JS_GetException(ctx);
+                const char* s = JS_ToCString(ctx, exc);
+                if (s) { zapp_log_worker(ZAPP_LOG_ERROR, -1, -1, s); JS_FreeCString(ctx, s); }
+                JS_FreeValue(ctx, exc);
+            }
+            JS_FreeValue(ctx, ret);
+            JS_FreeValue(ctx, args[0]);
+        } else if (d->response) {
+            zapp_fetch_response_t* r = d->response;
+            JSValue resObj = JS_NewObject(ctx);
+            JS_SetPropertyStr(ctx, resObj, "status", JS_NewInt32(ctx, r->status));
+            JS_SetPropertyStr(ctx, resObj, "statusText",
+                JS_NewString(ctx, r->status_text ? r->status_text : ""));
+
+            JSValue headersObj = JS_NewObject(ctx);
+            for (int i = 0; i < r->header_count; i++) {
+                if (r->header_keys[i] && r->header_values[i]) {
+                    JS_SetPropertyStr(ctx, headersObj, r->header_keys[i],
+                        JS_NewString(ctx, r->header_values[i]));
+                }
+            }
+            JS_SetPropertyStr(ctx, resObj, "headers", headersObj);
+
+            if (r->body)
+                JS_SetPropertyStr(ctx, resObj, "body", JS_NewString(ctx, r->body));
+            else if (r->body_base64)
+                JS_SetPropertyStr(ctx, resObj, "body_base64", JS_NewString(ctx, r->body_base64));
+            else
+                JS_SetPropertyStr(ctx, resObj, "body", JS_NewString(ctx, ""));
+
+            JSValue args[1] = { resObj };
+            JSValue ret = JS_Call(ctx, d->savedResolve, JS_UNDEFINED, 1, args);
+            if (JS_IsException(ret)) {
+                JSValue exc = JS_GetException(ctx);
+                const char* s = JS_ToCString(ctx, exc);
+                if (s) { zapp_log_worker(ZAPP_LOG_ERROR, -1, -1, s); JS_FreeCString(ctx, s); }
+                JS_FreeValue(ctx, exc);
+            }
+            JS_FreeValue(ctx, ret);
+            JS_FreeValue(ctx, resObj);
+        }
+
+        JS_FreeValue(ctx, d->savedResolve);
+        JS_FreeValue(ctx, d->savedReject);
+        zapp_windows_qjs_drain_jobs(ctx, "fetch");
+
+        if (d->error) free(d->error);
+        if (d->response) {
+            free(d->response->status_text);
+            for (int i = 0; i < d->response->header_count; i++) {
+                free(d->response->header_keys[i]);
+                free(d->response->header_values[i]);
+            }
+            free(d->response->header_keys);
+            free(d->response->header_values);
+            free(d->response->body);
+            free(d->response->body_base64);
+            free(d->response);
+        }
+        free(d);
+    }
+
+    static void zapp_fetch_completion_handler(zapp_fetch_response_t* response, const char* error, void* userdata) {
+        ZappFetchResultData* d = (ZappFetchResultData*)userdata;
+
+        if (error) {
+            d->error = _strdup(error);
+            d->response = NULL;
+        } else if (response) {
+            // Deep copy the response since it's freed after callback returns
+            zapp_fetch_response_t* copy = (zapp_fetch_response_t*)calloc(1, sizeof(zapp_fetch_response_t));
+            copy->status = response->status;
+            copy->status_text = response->status_text ? _strdup(response->status_text) : NULL;
+            copy->header_count = response->header_count;
+            if (copy->header_count > 0) {
+                copy->header_keys = (char**)calloc(copy->header_count, sizeof(char*));
+                copy->header_values = (char**)calloc(copy->header_count, sizeof(char*));
+                for (int i = 0; i < copy->header_count; i++) {
+                    copy->header_keys[i] = response->header_keys[i] ? _strdup(response->header_keys[i]) : NULL;
+                    copy->header_values[i] = response->header_values[i] ? _strdup(response->header_values[i]) : NULL;
+                }
+            }
+            copy->body = response->body ? _strdup(response->body) : NULL;
+            copy->body_base64 = response->body_base64 ? _strdup(response->body_base64) : NULL;
+            d->response = copy;
+        }
+
+        zapp_windows_qjs_dispatch(zapp_fetch_deliver_on_qjs, d);
+    }
+
+    static JSValue qjs_bridge_fetch(JSContext* ctx, JSValue this_val, int argc, JSValue* argv, int magic, JSValue* func_data) {
+        (void)this_val; (void)magic;
+        if (argc < 4) return JS_UNDEFINED;
+
+        const char* worker_id = JS_ToCString(ctx, func_data[0]);
+        if (!worker_id) return JS_UNDEFINED;
+
+        const char* urlStr = JS_ToCString(ctx, argv[0]);
+        if (!urlStr) { JS_FreeCString(ctx, worker_id); return JS_UNDEFINED; }
+
+        JSValue optionsVal = argv[1];
+        JSValue resolveVal = argv[2];
+        JSValue rejectVal = argv[3];
+
+        // Extract method
+        char* method_copy = NULL;
+        if (!JS_IsUndefined(optionsVal) && !JS_IsNull(optionsVal)) {
+            JSValue m = JS_GetPropertyStr(ctx, optionsVal, "method");
+            if (!JS_IsUndefined(m)) {
+                const char* ms = JS_ToCString(ctx, m);
+                if (ms) { method_copy = _strdup(ms); JS_FreeCString(ctx, ms); }
+            }
+            JS_FreeValue(ctx, m);
+        }
+
+        // Extract headers
+        char** hKeys = NULL;
+        char** hVals = NULL;
+        int hCount = 0;
+        if (!JS_IsUndefined(optionsVal) && !JS_IsNull(optionsVal)) {
+            JSValue headersVal = JS_GetPropertyStr(ctx, optionsVal, "headers");
+            if (JS_IsObject(headersVal)) {
+                JSPropertyEnum* tab = NULL;
+                uint32_t len = 0;
+                if (JS_GetOwnPropertyNames(ctx, &tab, &len, headersVal, JS_GPN_STRING_MASK) == 0 && len > 0) {
+                    hCount = (int)len;
+                    hKeys = (char**)calloc(hCount, sizeof(char*));
+                    hVals = (char**)calloc(hCount, sizeof(char*));
+                    for (uint32_t i = 0; i < len; i++) {
+                        const char* key = JS_AtomToCString(ctx, tab[i].atom);
+                        JSValue val = JS_GetProperty(ctx, headersVal, tab[i].atom);
+                        const char* valStr = JS_ToCString(ctx, val);
+                        hKeys[i] = key ? _strdup(key) : NULL;
+                        hVals[i] = valStr ? _strdup(valStr) : NULL;
+                        if (key) JS_FreeCString(ctx, key);
+                        if (valStr) JS_FreeCString(ctx, valStr);
+                        JS_FreeValue(ctx, val);
+                        JS_FreeAtom(ctx, tab[i].atom);
+                    }
+                    js_free(ctx, tab);
+                }
+            }
+            JS_FreeValue(ctx, headersVal);
+        }
+
+        // Extract body
+        char* body_copy = NULL;
+        size_t body_len = 0;
+        if (!JS_IsUndefined(optionsVal) && !JS_IsNull(optionsVal)) {
+            JSValue bodyVal = JS_GetPropertyStr(ctx, optionsVal, "body");
+            if (!JS_IsUndefined(bodyVal) && !JS_IsNull(bodyVal) && JS_IsString(bodyVal)) {
+                const char* bs = JS_ToCString(ctx, bodyVal);
+                if (bs) { body_copy = _strdup(bs); body_len = strlen(body_copy); JS_FreeCString(ctx, bs); }
+            }
+            JS_FreeValue(ctx, bodyVal);
+        }
+
+        // Create result data with saved JS callbacks
+        ZappFetchResultData* resultData = (ZappFetchResultData*)calloc(1, sizeof(ZappFetchResultData));
+        strncpy(resultData->workerId, worker_id, sizeof(resultData->workerId) - 1);
+        resultData->creatingCtx = ctx;
+        resultData->savedResolve = JS_DupValue(ctx, resolveVal);
+        resultData->savedReject = JS_DupValue(ctx, rejectVal);
+
+        char* urlCopy = _strdup(urlStr);
+        JS_FreeCString(ctx, urlStr);
+        JS_FreeCString(ctx, worker_id);
+
+        zapp_core_fetch_execute(
+            urlCopy, method_copy,
+            (const char**)hKeys, (const char**)hVals, hCount,
+            body_copy, body_len,
+            resultData->workerId,
+            zapp_fetch_completion_handler, resultData
+        );
+
+        free(urlCopy);
+        free(method_copy);
+        for (int i = 0; i < hCount; i++) { free(hKeys[i]); free(hVals[i]); }
+        free(hKeys); free(hVals);
+        free(body_copy);
+
+        return JS_UNDEFINED;
+    }
+
+    void zapp_windows_qjs_fetch_install(JSContext* ctx, JSValue bridge, const char* worker_id) {
+        JSValue wIdVal = JS_NewString(ctx, worker_id);
+        JSValue funcData[1] = { wIdVal };
+        JS_SetPropertyStr(ctx, bridge, "fetch",
+            JS_NewCFunctionData(ctx, qjs_bridge_fetch, 4, 0, 1, funcData));
+        JS_FreeValue(ctx, wIdVal);
+    }
+#endif
+}