@zappdev/cli 0.1.0

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

@@ -0,0 +1,179 @@
+// Engine-agnostic WebSocket connection management using NSURLSessionWebSocketTask.
+// The JS engine callback is abstracted via a C function pointer.
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+
+    static NSMutableDictionary<NSString*, NSMutableDictionary*>* zapp_ws_conns = nil;
+    static int zapp_ws_id_counter = 1;
+
+    static void zapp_core_ws_ensure_init(void) {
+        if (zapp_ws_conns == nil) zapp_ws_conns = [NSMutableDictionary new];
+    }
+
+    static NSString* zapp_core_ws_json_for_event(NSDictionary* dict) {
+        NSData* d = [NSJSONSerialization dataWithJSONObject:dict options:0 error:nil];
+        return d ? [[NSString alloc] initWithData:d encoding:NSUTF8StringEncoding] : @"{}";
+    }
+
+    static void zapp_core_ws_fire(NSString* wsId, NSString* eventType, NSDictionary* payload) {
+        NSMutableDictionary* conn = zapp_ws_conns[wsId];
+        if (conn == nil) return;
+
+        zapp_ws_event_fn cb = NULL;
+        NSValue* cbVal = conn[@"callback_fn"];
+        NSValue* udVal  = conn[@"user_data"];
+        if (cbVal) cb = (zapp_ws_event_fn)[cbVal pointerValue];
+        void* ud = udVal ? [udVal pointerValue] : NULL;
+        if (!cb) return;
+
+        NSMutableDictionary* full = [NSMutableDictionary dictionaryWithDictionary:payload ?: @{}];
+        full[@"type"] = eventType;
+        full[@"wsId"] = wsId;
+        NSString* json = zapp_core_ws_json_for_event(full);
+
+        cb([wsId UTF8String], [eventType UTF8String], [json UTF8String], ud);
+    }
+
+    static void zapp_core_ws_receive_loop(NSURLSessionWebSocketTask* task, NSString* wsId);
+
+    static void zapp_core_ws_receive_loop(NSURLSessionWebSocketTask* task, NSString* wsId) {
+        [task receiveMessageWithCompletionHandler:^(NSURLSessionWebSocketMessage* message, NSError* error) {
+            if (error != nil) {
+                zapp_core_ws_fire(wsId, @"error", @{@"message": [error localizedDescription] ?: @"WebSocket error"});
+                return;
+            }
+            if (message == nil) return;
+
+            if (message.type == NSURLSessionWebSocketMessageTypeString) {
+                NSString* text = message.string ?: @"";
+                zapp_core_ws_fire(wsId, @"message", @{@"data": text, @"binary": @NO});
+            } else if (message.type == NSURLSessionWebSocketMessageTypeData) {
+                NSData* data = message.data;
+                if (data != nil) {
+                    NSMutableArray* byteArray = [NSMutableArray arrayWithCapacity:[data length]];
+                    const uint8_t* bytes = (const uint8_t*)[data bytes];
+                    for (NSUInteger i = 0; i < [data length]; i++) {
+                        [byteArray addObject:@(bytes[i])];
+                    }
+                    zapp_core_ws_fire(wsId, @"message", @{@"data": byteArray, @"binary": @YES});
+                }
+            }
+
+            NSMutableDictionary* conn = zapp_ws_conns[wsId];
+            if (conn != nil && task.state == NSURLSessionTaskStateRunning) {
+                zapp_core_ws_receive_loop(task, wsId);
+            }
+        }];
+    }
+
+    // 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_core_ws_ensure_init();
+        if (url_str == NULL) return NULL;
+
+        NSURL* url = [NSURL URLWithString:[NSString stringWithUTF8String:url_str]];
+        if (url == nil) return NULL;
+
+        NSString* wsId = [NSString stringWithFormat:@"ws-%d", zapp_ws_id_counter++];
+
+        NSURLSessionConfiguration* config = [NSURLSessionConfiguration defaultSessionConfiguration];
+        NSURLSession* session = [NSURLSession sessionWithConfiguration:config];
+        NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:url];
+
+        if (protocols && protocol_count > 0) {
+            NSMutableArray* protos = [NSMutableArray arrayWithCapacity:protocol_count];
+            for (int i = 0; i < protocol_count; i++) {
+                if (protocols[i]) [protos addObject:[NSString stringWithUTF8String:protocols[i]]];
+            }
+            if ([protos count] > 0) {
+                [request setValue:[protos componentsJoinedByString:@", "] forHTTPHeaderField:@"Sec-WebSocket-Protocol"];
+            }
+        }
+
+        NSURLSessionWebSocketTask* task = [session webSocketTaskWithRequest:request];
+
+        NSMutableDictionary* conn = [NSMutableDictionary dictionary];
+        conn[@"task"] = task;
+        conn[@"session"] = session;
+        conn[@"callback_fn"] = [NSValue valueWithPointer:(void*)callback];
+        if (user_data) conn[@"user_data"] = [NSValue valueWithPointer:user_data];
+        zapp_ws_conns[wsId] = conn;
+
+        [task resume];
+        zapp_core_ws_receive_loop(task, wsId);
+
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+            NSMutableDictionary* c = zapp_ws_conns[wsId];
+            if (c != nil) {
+                NSURLSessionWebSocketTask* t = c[@"task"];
+                if (t && t.state == NSURLSessionTaskStateRunning) {
+                    zapp_core_ws_fire(wsId, @"open", @{});
+                } else {
+                    zapp_core_ws_fire(wsId, @"error", @{@"message": @"Connection failed"});
+                }
+            }
+        });
+
+        return strdup([wsId UTF8String]);
+    }
+
+    // Send text or binary data on an existing WebSocket.
+    static void zapp_core_ws_send_text(const char* ws_id, const char* text) {
+        if (!ws_id || !text) return;
+        NSString* wsId = [NSString stringWithUTF8String:ws_id];
+        NSMutableDictionary* conn = zapp_ws_conns[wsId];
+        if (!conn) return;
+        NSURLSessionWebSocketTask* task = conn[@"task"];
+        if (!task || task.state != NSURLSessionTaskStateRunning) return;
+
+        NSURLSessionWebSocketMessage* msg = [[NSURLSessionWebSocketMessage alloc] initWithString:[NSString stringWithUTF8String:text]];
+        [task sendMessage:msg completionHandler:^(NSError* error) {
+            if (error) {
+                zapp_core_ws_fire(wsId, @"error", @{@"message": [error localizedDescription] ?: @"Send failed"});
+            }
+        }];
+    }
+
+    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;
+        NSString* wsId = [NSString stringWithUTF8String:ws_id];
+        NSMutableDictionary* conn = zapp_ws_conns[wsId];
+        if (!conn) return;
+        NSURLSessionWebSocketTask* task = conn[@"task"];
+        if (!task || task.state != NSURLSessionTaskStateRunning) return;
+
+        NSData* data = [NSData dataWithBytes:bytes length:len];
+        NSURLSessionWebSocketMessage* msg = [[NSURLSessionWebSocketMessage alloc] initWithData:data];
+        [task sendMessage:msg completionHandler:^(NSError* error) {
+            if (error) {
+                zapp_core_ws_fire(wsId, @"error", @{@"message": [error localizedDescription] ?: @"Send failed"});
+            }
+        }];
+    }
+
+    // Close an existing WebSocket.
+    static void zapp_core_ws_close(const char* ws_id, int code, const char* reason) {
+        if (!ws_id) return;
+        NSString* wsId = [NSString stringWithUTF8String:ws_id];
+        NSMutableDictionary* conn = zapp_ws_conns[wsId];
+        if (!conn) return;
+
+        NSURLSessionWebSocketTask* task = conn[@"task"];
+        if (task) {
+            NSData* reasonData = reason ? [[NSString stringWithUTF8String:reason] dataUsingEncoding:NSUTF8StringEncoding] : nil;
+            [task cancelWithCloseCode:(NSURLSessionWebSocketCloseCode)code reason:reasonData];
+        }
+
+        zapp_core_ws_fire(wsId, @"close", @{
+            @"code": @(code),
+            @"reason": reason ? [NSString stringWithUTF8String:reason] : @"",
+            @"wasClean": @YES,
+        });
+
+        [zapp_ws_conns removeObjectForKey:wsId];
+    }
+#endif
+}

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

@@ -0,0 +1,55 @@
+raw {
+#ifdef __APPLE__
+    #include <Cocoa/Cocoa.h>
+    #include <WebKit/WebKit.h>
+    #include <dispatch/dispatch.h>
+
+    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";
+
+        NSString* k = [NSString stringWithUTF8String:kind];
+        NSString* wid = [NSString stringWithUTF8String:worker_id];
+        NSString* payload = [NSString stringWithUTF8String:payload_json];
+
+        k = [k stringByReplacingOccurrencesOfString:@"\\" withString:@"\\\\"];
+        k = [k stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
+        wid = [wid stringByReplacingOccurrencesOfString:@"\\" withString:@"\\\\"];
+        wid = [wid stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
+
+        NSString* js = [NSString stringWithFormat:
+            @"(function(){var b=globalThis[Symbol.for('zapp.bridge')];if(b&&typeof b.dispatchWorkerBridge==='function'){b.dispatchWorkerBridge('%@','%@',%@);}})();",
+            k, wid, payload
+        ];
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            for (NSWindow* window in [NSApp windows]) {
+                NSView* content = [window contentView];
+                if ([content isKindOfClass:[WKWebView class]]) {
+                    WKWebView* webview = (WKWebView*)content;
+                    [webview evaluateJavaScript:js completionHandler:nil];
+                }
+            }
+        });
+    }
+
+    NSString* zapp_json_stringify_obj(id obj) {
+        if (obj == nil || obj == [NSNull null]) return @"null";
+        if (![NSJSONSerialization isValidJSONObject:obj]) {
+            if ([obj isKindOfClass:[NSString class]]) {
+                NSData* data = [NSJSONSerialization dataWithJSONObject:@[(NSString*)obj] options:0 error:nil];
+                if (!data) return @"null";
+                NSString* arr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+                if ([arr length] >= 2) {
+                    return [arr substringWithRange:NSMakeRange(1, [arr length] - 2)];
+                }
+                return @"null";
+            }
+            return @"null";
+        }
+        NSData* jsonData = [NSJSONSerialization dataWithJSONObject:obj options:0 error:nil];
+        if (!jsonData) return @"null";
+        return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+    }
+#endif
+}

package/native/src/platform/darwin/worker/jsc/base64_jsc.zc

@@ -0,0 +1,39 @@
+// JSC wrapper for btoa/atob. Delegates to core/base64_core.zc.
+
+//> macos: framework: JavaScriptCore
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <JavaScriptCore/JavaScriptCore.h>
+
+    static char* zapp_core_btoa(const char* input);
+    static char* zapp_core_atob(const char* input);
+
+    void zapp_darwin_worker_base64_init(JSContext* ctx) {
+        JSValue* bridge = ctx[@"__zappBridge"];
+        if (bridge == nil || bridge.isUndefined) {
+            ctx[@"__zappBridge"] = [JSValue valueWithNewObjectInContext:ctx];
+            bridge = ctx[@"__zappBridge"];
+        }
+
+        bridge[@"btoa"] = ^NSString*(JSValue* strVal) {
+            if (strVal == nil || [strVal isUndefined] || [strVal isNull]) return @"";
+            const char* input = [[strVal toString] UTF8String];
+            char* result = zapp_core_btoa(input);
+            NSString* ns = [NSString stringWithUTF8String:result];
+            free(result);
+            return ns ?: @"";
+        };
+
+        bridge[@"atob"] = ^NSString*(JSValue* strVal) {
+            if (strVal == nil || [strVal isUndefined] || [strVal isNull]) return @"";
+            const char* input = [[strVal toString] UTF8String];
+            char* result = zapp_core_atob(input);
+            NSString* ns = [NSString stringWithUTF8String:result];
+            free(result);
+            return ns ?: @"";
+        };
+    }
+#endif
+}

package/native/src/platform/darwin/worker/jsc/crypto_jsc.zc

@@ -0,0 +1,49 @@
+// JSC wrapper for crypto. Delegates to core/crypto_core.zc.
+
+//> macos: framework: JavaScriptCore
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <JavaScriptCore/JavaScriptCore.h>
+
+    static void zapp_core_crypto_random_bytes(uint8_t* buf, size_t len);
+    static char* zapp_core_crypto_random_uuid(void);
+
+    void zapp_darwin_worker_crypto_init(JSContext* ctx) {
+        JSValue* bridge = ctx[@"__zappBridge"];
+        if (bridge == nil || bridge.isUndefined) {
+            ctx[@"__zappBridge"] = [JSValue valueWithNewObjectInContext:ctx];
+            bridge = ctx[@"__zappBridge"];
+        }
+
+        bridge[@"getRandomValues"] = ^(JSValue* arrayVal) {
+            if (arrayVal == nil || [arrayVal isUndefined] || [arrayVal isNull]) return arrayVal;
+
+            JSContextRef ctxRef = ctx.JSGlobalContextRef;
+            JSValueRef valRef = arrayVal.JSValueRef;
+            if (!ctxRef || !valRef) return arrayVal;
+
+            JSValueRef exception = NULL;
+            JSTypedArrayType type = JSValueGetTypedArrayType(ctxRef, valRef, &exception);
+            if (type == kJSTypedArrayTypeNone) return arrayVal;
+
+            size_t len = JSObjectGetTypedArrayByteLength(ctxRef, valRef, &exception);
+            if (len == 0 || exception) return arrayVal;
+
+            void* bytes = JSObjectGetTypedArrayBytesPtr(ctxRef, valRef, &exception);
+            if (!bytes || exception) return arrayVal;
+
+            zapp_core_crypto_random_bytes((uint8_t*)bytes, len);
+            return arrayVal;
+        };
+
+        bridge[@"randomUUID"] = ^NSString*() {
+            char* uuid = zapp_core_crypto_random_uuid();
+            NSString* result = [NSString stringWithUTF8String:uuid];
+            free(uuid);
+            return result;
+        };
+    }
+#endif
+}

package/native/src/platform/darwin/worker/jsc/encoding_jsc.zc

@@ -0,0 +1,86 @@
+// JSC wrapper for TextEncoder/TextDecoder. Delegates to core/encoding_core.zc.
+
+//> macos: framework: JavaScriptCore
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <JavaScriptCore/JavaScriptCore.h>
+
+    static uint8_t* zapp_core_text_encode(const char* input, size_t* out_len);
+    static char* zapp_core_text_decode(const uint8_t* bytes, size_t len);
+
+    static JSValue* zapp_jsc_create_uint8array(JSContext* ctx, const uint8_t* bytes, size_t len) {
+        JSContextRef ctxRef = ctx.JSGlobalContextRef;
+        JSValueRef exception = NULL;
+
+        JSStringRef u8Name = JSStringCreateWithUTF8CString("Uint8Array");
+        JSValueRef u8Ctor = JSObjectGetProperty(ctxRef, JSContextGetGlobalObject(ctxRef), u8Name, NULL);
+        JSStringRelease(u8Name);
+
+        if (len == 0 || bytes == NULL) {
+            JSValueRef args[1] = { JSValueMakeNumber(ctxRef, 0) };
+            JSObjectRef result = JSObjectCallAsConstructor(ctxRef, (JSObjectRef)u8Ctor, 1, args, &exception);
+            if (result && !exception) return [JSValue valueWithJSValueRef:result inContext:ctx];
+            return [JSValue valueWithUndefinedInContext:ctx];
+        }
+
+        JSValueRef args[1] = { JSValueMakeNumber(ctxRef, (double)len) };
+        JSObjectRef u8Arr = JSObjectCallAsConstructor(ctxRef, (JSObjectRef)u8Ctor, 1, args, &exception);
+        if (!u8Arr || exception) return [JSValue valueWithUndefinedInContext:ctx];
+
+        void* ptr = JSObjectGetTypedArrayBytesPtr(ctxRef, u8Arr, &exception);
+        if (ptr && !exception) memcpy(ptr, bytes, len);
+
+        return [JSValue valueWithJSValueRef:u8Arr inContext:ctx];
+    }
+
+    void zapp_darwin_worker_encoding_init(JSContext* ctx) {
+        JSValue* bridge = ctx[@"__zappBridge"];
+        if (bridge == nil || bridge.isUndefined) {
+            ctx[@"__zappBridge"] = [JSValue valueWithNewObjectInContext:ctx];
+            bridge = ctx[@"__zappBridge"];
+        }
+
+        bridge[@"textEncode"] = ^JSValue*(JSValue* strVal) {
+            if (strVal == nil || [strVal isUndefined] || [strVal isNull]) {
+                return zapp_jsc_create_uint8array(ctx, NULL, 0);
+            }
+            NSString* str = [strVal toString];
+            if (str == nil) return zapp_jsc_create_uint8array(ctx, NULL, 0);
+            size_t len = 0;
+            uint8_t* bytes = zapp_core_text_encode([str UTF8String], &len);
+            JSValue* result = zapp_jsc_create_uint8array(ctx, bytes, len);
+            free(bytes);
+            return result;
+        };
+
+        bridge[@"textDecode"] = ^NSString*(JSValue* bufVal) {
+            if (bufVal == nil || [bufVal isUndefined] || [bufVal isNull]) return @"";
+
+            JSContextRef ctxRef = ctx.JSGlobalContextRef;
+            JSValueRef valRef = bufVal.JSValueRef;
+            JSValueRef exception = NULL;
+            const uint8_t* bytes = NULL;
+            size_t len = 0;
+
+            JSTypedArrayType type = JSValueGetTypedArrayType(ctxRef, valRef, &exception);
+            if (type != kJSTypedArrayTypeNone && exception == NULL) {
+                bytes = (const uint8_t*)JSObjectGetTypedArrayBytesPtr(ctxRef, valRef, &exception);
+                size_t byteOffset = JSObjectGetTypedArrayByteOffset(ctxRef, valRef, &exception);
+                len = JSObjectGetTypedArrayByteLength(ctxRef, valRef, &exception);
+                if (bytes) bytes += byteOffset;
+            } else {
+                exception = NULL;
+                bytes = (const uint8_t*)JSObjectGetArrayBufferBytesPtr(ctxRef, valRef, &exception);
+                if (bytes && exception == NULL) len = JSObjectGetArrayBufferByteLength(ctxRef, valRef, &exception);
+            }
+
+            char* decoded = zapp_core_text_decode(bytes, len);
+            NSString* result = [NSString stringWithUTF8String:decoded];
+            free(decoded);
+            return result ?: @"";
+        };
+    }
+#endif
+}

package/native/src/platform/darwin/worker/jsc/fetch_jsc.zc

@@ -0,0 +1,149 @@
+// JSC wrapper for fetch. Delegates to core/fetch_core.zc.
+
+//> macos: framework: JavaScriptCore
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <JavaScriptCore/JavaScriptCore.h>
+
+    extern void zapp_darwin_worker_js_sync(dispatch_block_t block);
+    static void zapp_core_fetch_ensure_init(void);
+    static void zapp_core_fetch_execute(NSMutableURLRequest*, NSString*, zapp_fetch_completion_t);
+    static NSMutableURLRequest* zapp_core_fetch_build_request(const char*, const char*, const char**, const char**, int, const char*, size_t);
+    static void zapp_core_fetch_cancel(NSString*);
+    static void zapp_core_fetch_cancel_all(void);
+
+    void zapp_darwin_worker_fetch_init(JSContext* ctx, NSString* workerId) {
+        zapp_core_fetch_ensure_init();
+
+        __weak JSContext* weakCtx = ctx;
+
+        JSValue* bridge = ctx[@"__zappBridge"];
+        if (bridge == nil || bridge.isUndefined) {
+            ctx[@"__zappBridge"] = [JSValue valueWithNewObjectInContext:ctx];
+            bridge = ctx[@"__zappBridge"];
+        }
+
+        bridge[@"fetch"] = ^(JSValue* urlVal, JSValue* optionsVal, JSValue* resolveVal, JSValue* rejectVal) {
+            JSContext* strongCtx = weakCtx;
+            if (!strongCtx) return;
+
+            NSString* wId = [strongCtx[@"__zappWorkerDispatchId"] toString];
+            if (![wId isKindOfClass:[NSString class]] || [wId length] == 0) wId = workerId;
+            if (!wId) return;
+
+            const char* urlStr = [[urlVal toString] UTF8String];
+
+            // Extract method
+            const char* method = NULL;
+            NSString* methodNS = nil;
+            if (optionsVal && ![optionsVal isUndefined] && ![optionsVal isNull]) {
+                JSValue* m = optionsVal[@"method"];
+                if (m && ![m isUndefined]) { methodNS = [m toString]; method = [methodNS UTF8String]; }
+            }
+
+            // Extract headers
+            const char** hKeys = NULL;
+            const char** hVals = NULL;
+            int hCount = 0;
+            NSMutableArray* hKeysNS = nil;
+            NSMutableArray* hValsNS = nil;
+            if (optionsVal && ![optionsVal isUndefined] && ![optionsVal isNull]) {
+                JSValue* headersVal = optionsVal[@"headers"];
+                if (headersVal && ![headersVal isUndefined] && [headersVal isObject]) {
+                    NSDictionary* hDict = [headersVal toDictionary];
+                    hCount = (int)[hDict count];
+                    if (hCount > 0) {
+                        hKeysNS = [NSMutableArray arrayWithCapacity:hCount];
+                        hValsNS = [NSMutableArray arrayWithCapacity:hCount];
+                        hKeys = (const char**)calloc(hCount, sizeof(char*));
+                        hVals = (const char**)calloc(hCount, sizeof(char*));
+                        int i = 0;
+                        for (NSString* k in hDict) {
+                            NSString* v = [NSString stringWithFormat:@"%@", hDict[k]];
+                            [hKeysNS addObject:k];
+                            [hValsNS addObject:v];
+                            hKeys[i] = [k UTF8String];
+                            hVals[i] = [v UTF8String];
+                            i++;
+                        }
+                    }
+                }
+            }
+
+            // Extract body
+            const char* body = NULL;
+            size_t bodyLen = 0;
+            NSString* bodyNS = nil;
+            if (optionsVal && ![optionsVal isUndefined] && ![optionsVal isNull]) {
+                JSValue* bodyVal = optionsVal[@"body"];
+                if (bodyVal && ![bodyVal isUndefined] && ![bodyVal isNull] && [bodyVal isString]) {
+                    bodyNS = [bodyVal toString];
+                    body = [bodyNS UTF8String];
+                    bodyLen = [bodyNS lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+                }
+            }
+
+            NSMutableURLRequest* request = zapp_core_fetch_build_request(urlStr, method, hKeys, hVals, hCount, body, bodyLen);
+            free(hKeys);
+            free(hVals);
+
+            if (!request) {
+                if (rejectVal && ![rejectVal isUndefined]) [rejectVal callWithArguments:@[@"Invalid URL"]];
+                return;
+            }
+
+            __block JSValue* blockResolve = resolveVal;
+            __block JSValue* blockReject = rejectVal;
+
+            zapp_core_fetch_execute(request, wId, ^(zapp_fetch_response_t* response, NSString* error) {
+                zapp_darwin_worker_js_sync(^{
+                    JSContext* ctx2 = weakCtx;
+                    if (!ctx2) return;
+
+                    if (error) {
+                        if (blockReject && ![blockReject isUndefined]) {
+                            [blockReject callWithArguments:@[error]];
+                        }
+                        blockResolve = nil; blockReject = nil;
+                        return;
+                    }
+
+                    if (!response) { blockResolve = nil; blockReject = nil; return; }
+
+                    NSMutableDictionary* resDict = [NSMutableDictionary dictionary];
+                    resDict[@"status"] = @(response->status);
+                    resDict[@"statusText"] = response->status_text ? [NSString stringWithUTF8String:response->status_text] : @"";
+
+                    NSMutableDictionary* headers = [NSMutableDictionary dictionary];
+                    for (int i = 0; i < response->header_count; i++) {
+                        if (response->header_keys[i] && response->header_values[i]) {
+                            headers[[NSString stringWithUTF8String:response->header_keys[i]]] =
+                                [NSString stringWithUTF8String:response->header_values[i]];
+                        }
+                    }
+                    resDict[@"headers"] = headers;
+
+                    if (response->body) resDict[@"body"] = [NSString stringWithUTF8String:response->body];
+                    else if (response->body_base64) resDict[@"body_base64"] = [NSString stringWithUTF8String:response->body_base64];
+                    else resDict[@"body"] = @"";
+
+                    if (blockResolve && ![blockResolve isUndefined]) {
+                        [blockResolve callWithArguments:@[resDict]];
+                    }
+                    blockResolve = nil; blockReject = nil;
+                });
+            });
+        };
+    }
+
+    void zapp_darwin_worker_fetch_cancel(NSString* workerId) {
+        zapp_core_fetch_cancel(workerId);
+    }
+
+    void zapp_darwin_worker_fetch_cancel_all(void) {
+        zapp_core_fetch_cancel_all();
+    }
+#endif
+}

package/native/src/platform/darwin/worker/jsc/url_jsc.zc

@@ -0,0 +1,54 @@
+// JSC wrapper for URL parsing. Delegates to core/url_core.zc.
+
+//> macos: framework: JavaScriptCore
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <JavaScriptCore/JavaScriptCore.h>
+
+    static int zapp_core_url_parse(const char* url_str, const char* base_str, zapp_url_parsed_t* out);
+    static void zapp_core_url_free(zapp_url_parsed_t* c);
+
+    void zapp_darwin_worker_url_init(JSContext* ctx) {
+        JSValue* bridge = ctx[@"__zappBridge"];
+        if (bridge == nil || bridge.isUndefined) {
+            ctx[@"__zappBridge"] = [JSValue valueWithNewObjectInContext:ctx];
+            bridge = ctx[@"__zappBridge"];
+        }
+
+        bridge[@"urlParse"] = ^(JSValue* urlVal, JSValue* baseVal) {
+            if (urlVal == nil || [urlVal isUndefined] || [urlVal isNull]) {
+                return [JSValue valueWithNullInContext:ctx];
+            }
+
+            const char* urlStr = [[urlVal toString] UTF8String];
+            const char* baseStr = NULL;
+            if (baseVal != nil && ![baseVal isUndefined] && ![baseVal isNull]) {
+                baseStr = [[baseVal toString] UTF8String];
+            }
+
+            zapp_url_parsed_t c;
+            if (zapp_core_url_parse(urlStr, baseStr, &c) != 0) {
+                return [JSValue valueWithNullInContext:ctx];
+            }
+
+            NSDictionary* result = @{
+                @"href":     [NSString stringWithUTF8String:c.href],
+                @"protocol": [NSString stringWithUTF8String:c.protocol],
+                @"host":     [NSString stringWithUTF8String:c.host],
+                @"hostname": [NSString stringWithUTF8String:c.hostname],
+                @"port":     [NSString stringWithUTF8String:c.port],
+                @"pathname": [NSString stringWithUTF8String:c.pathname],
+                @"search":   [NSString stringWithUTF8String:c.search],
+                @"hash":     [NSString stringWithUTF8String:c.hash],
+                @"origin":   [NSString stringWithUTF8String:c.origin],
+                @"username": [NSString stringWithUTF8String:c.username],
+                @"password": [NSString stringWithUTF8String:c.password],
+            };
+            zapp_core_url_free(&c);
+            return [JSValue valueWithObject:result inContext:ctx];
+        };
+    }
+#endif
+}