@zappdev/cli 0.1.0

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

@@ -0,0 +1,30 @@
+// Darwin worker: single platform-agnostic API; backend chosen by cfg.
+// JSC = default (no engine flag). QJS = ZAPP_WORKER_ENGINE_QJS.
+
+import "../../worker.zc";
+
+@cfg(not(ZAPP_WORKER_ENGINE_QJS))
+import "./jsc.zc";
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+import "./qjs.zc";
+
+@cfg(not(ZAPP_WORKER_ENGINE_QJS))
+fn darwin_platform_bind_runtime(app: App*) -> void {
+    (DarwinWorkerJsc{}).bind_runtime(app);
+}
+
+@cfg(not(ZAPP_WORKER_ENGINE_QJS))
+fn darwin_platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    (DarwinWorkerJsc{}).handle_bridge(app, action, payload);
+}
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+fn darwin_platform_bind_runtime(app: App*) -> void {
+    (DarwinWorkerQjs{}).bind_runtime(app);
+}
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+fn darwin_platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    (DarwinWorkerQjs{}).handle_bridge(app, action, payload);
+}

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

@@ -0,0 +1,233 @@
+// QJS wrapper for fetch. Delegates to core/fetch_core.zc.
+
+import "../../../shared/log.zc";
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+raw {
+#ifdef ZAPP_WORKER_ENGINE_QJS
+#ifdef __APPLE__
+    // Log functions from log.zc
+    extern void zapp_log_worker(int level, int window_id, int worker_id, const char* message);
+    #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
+
+    extern NSValue* zapp_darwin_qjs_get_context(NSString* workerId);
+    extern void zapp_darwin_qjs_dispatch_async(dispatch_block_t block);
+    extern void zapp_darwin_qjs_drain_jobs(void* ctx, const char* label);
+
+    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);
+
+    static QJSValue qjs_bridge_fetch(QJSContext *ctx, QJSValue this_val, int argc, QJSValue *argv, int magic, QJSValue *func_data) {
+        if (argc < 4) return JS_UNDEFINED;
+
+        const char* worker_id = JS_ToCString(ctx, func_data[0]);
+        if (!worker_id) return JS_UNDEFINED;
+
+        // Extract URL
+        const char* urlStr = JS_ToCString(ctx, argv[0]);
+        if (!urlStr) { JS_FreeCString(ctx, worker_id); return JS_UNDEFINED; }
+        char* url_copy = strdup(urlStr);
+        JS_FreeCString(ctx, urlStr);
+
+        QJSValue optionsVal = argv[1];
+        QJSValue resolveVal = argv[2];
+        QJSValue rejectVal = argv[3];
+
+        // Extract method
+        char* method_copy = NULL;
+        if (!JS_IsUndefined(optionsVal) && !JS_IsNull(optionsVal)) {
+            QJSValue 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)) {
+            QJSValue headersVal = JS_GetPropertyStr(ctx, optionsVal, "headers");
+            if (JS_IsObject(headersVal)) {
+                QJSPropertyEnum *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);
+                        QJSValue 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)) {
+            QJSValue 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);
+        }
+
+        NSMutableURLRequest* request = zapp_core_fetch_build_request(
+            url_copy, method_copy,
+            (const char**)hKeys, (const char**)hVals, hCount,
+            body_copy, body_len);
+
+        free(url_copy);
+        free(method_copy);
+        for (int i = 0; i < hCount; i++) { free(hKeys[i]); free(hVals[i]); }
+        free(hKeys); free(hVals);
+        free(body_copy);
+
+        if (!request) {
+            QJSValue errArgs[1] = { JS_NewString(ctx, "Invalid URL") };
+            QJSValue ret = JS_Call(ctx, rejectVal, JS_UNDEFINED, 1, errArgs);
+            JS_FreeValue(ctx, ret); JS_FreeValue(ctx, errArgs[0]);
+            JS_FreeCString(ctx, worker_id);
+            return JS_UNDEFINED;
+        }
+
+        NSString* wId = [NSString stringWithUTF8String:worker_id];
+        JS_FreeCString(ctx, worker_id);
+
+        QJSValue savedResolve = JS_DupValue(ctx, resolveVal);
+        QJSValue savedReject = JS_DupValue(ctx, rejectVal);
+        QJSContext* creating_ctx = ctx;
+
+        zapp_core_fetch_execute(request, wId, ^(zapp_fetch_response_t* response, NSString* error) {
+            // The response pointer is only valid for the duration of this callback
+            // (fetch_core frees it immediately after). Copy data into ObjC objects
+            // which the block will retain across the async dispatch.
+            BOOL has_response = (response != nil);
+            int resp_status = 0;
+            NSString* resp_status_text = nil;
+            NSArray<NSString*>* resp_hdr_keys = nil;
+            NSArray<NSString*>* resp_hdr_vals = nil;
+            NSString* resp_body = nil;
+            NSString* resp_body_base64 = nil;
+
+            if (response) {
+                resp_status = response->status;
+                resp_status_text = response->status_text
+                    ? [NSString stringWithUTF8String:response->status_text] : @"";
+                if (response->header_count > 0) {
+                    NSMutableArray* hk = [NSMutableArray arrayWithCapacity:response->header_count];
+                    NSMutableArray* hv = [NSMutableArray arrayWithCapacity:response->header_count];
+                    for (int i = 0; i < response->header_count; i++) {
+                        if (response->header_keys[i] && response->header_values[i]) {
+                            [hk addObject:[NSString stringWithUTF8String:response->header_keys[i]]];
+                            [hv addObject:[NSString stringWithUTF8String:response->header_values[i]]];
+                        }
+                    }
+                    resp_hdr_keys = hk;
+                    resp_hdr_vals = hv;
+                }
+                if (response->body)
+                    resp_body = [NSString stringWithUTF8String:response->body];
+                else if (response->body_base64)
+                    resp_body_base64 = [NSString stringWithUTF8String:response->body_base64];
+            }
+
+            zapp_darwin_qjs_dispatch_async(^{
+                NSValue* val = zapp_darwin_qjs_get_context(wId);
+                if (!val) return;
+
+                QJSContext* current_ctx = (QJSContext*)[val pointerValue];
+                if (current_ctx != creating_ctx) return;
+
+                if (error) {
+                    QJSValue args[1] = { JS_NewString(current_ctx, [error UTF8String]) };
+                    QJSValue ret = JS_Call(current_ctx, savedReject, JS_UNDEFINED, 1, args);
+                    if (JS_IsException(ret)) {
+                        QJSValue exc = JS_GetException(current_ctx);
+                        const char* s = JS_ToCString(current_ctx, exc);
+                        if (s) { zapp_log_worker(ZAPP_LOG_ERROR, -1, -1, s); JS_FreeCString(current_ctx, s); }
+                        JS_FreeValue(current_ctx, exc);
+                    }
+                    JS_FreeValue(current_ctx, ret); JS_FreeValue(current_ctx, args[0]);
+                } else if (has_response) {
+                    QJSValue resObj = JS_NewObject(current_ctx);
+                    JS_SetPropertyStr(current_ctx, resObj, "status", JS_NewInt32(current_ctx, resp_status));
+                    JS_SetPropertyStr(current_ctx, resObj, "statusText",
+                        JS_NewString(current_ctx, [resp_status_text UTF8String]));
+
+                    QJSValue headersObj = JS_NewObject(current_ctx);
+                    if (resp_hdr_keys) {
+                        for (NSUInteger i = 0; i < [resp_hdr_keys count]; i++) {
+                            JS_SetPropertyStr(current_ctx, headersObj,
+                                [resp_hdr_keys[i] UTF8String],
+                                JS_NewString(current_ctx, [resp_hdr_vals[i] UTF8String]));
+                        }
+                    }
+                    JS_SetPropertyStr(current_ctx, resObj, "headers", headersObj);
+
+                    if (resp_body)
+                        JS_SetPropertyStr(current_ctx, resObj, "body", JS_NewString(current_ctx, [resp_body UTF8String]));
+                    else if (resp_body_base64)
+                        JS_SetPropertyStr(current_ctx, resObj, "body_base64", JS_NewString(current_ctx, [resp_body_base64 UTF8String]));
+                    else
+                        JS_SetPropertyStr(current_ctx, resObj, "body", JS_NewString(current_ctx, ""));
+
+                    QJSValue args[1] = { resObj };
+                    QJSValue ret = JS_Call(current_ctx, savedResolve, JS_UNDEFINED, 1, args);
+                    if (JS_IsException(ret)) {
+                        QJSValue exc = JS_GetException(current_ctx);
+                        const char* s = JS_ToCString(current_ctx, exc);
+                        if (s) { zapp_log_worker(ZAPP_LOG_ERROR, -1, -1, s); JS_FreeCString(current_ctx, s); }
+                        JS_FreeValue(current_ctx, exc);
+                    }
+                    JS_FreeValue(current_ctx, ret); JS_FreeValue(current_ctx, resObj);
+                }
+
+                JS_FreeValue(current_ctx, savedResolve);
+                JS_FreeValue(current_ctx, savedReject);
+                zapp_darwin_qjs_drain_jobs(current_ctx, "fetch");
+            });
+        });
+
+        return JS_UNDEFINED;
+    }
+
+    void zapp_darwin_qjs_fetch_cancel(NSString* workerId) {
+        zapp_core_fetch_cancel(workerId);
+    }
+
+    void zapp_darwin_qjs_fetch_cancel_all(void) {
+        zapp_core_fetch_cancel_all();
+    }
+
+    void zapp_darwin_qjs_fetch_install(QJSContext* ctx, QJSValue bridge, const char* worker_id) {
+        QJSValue wIdVal = JS_NewString(ctx, worker_id);
+        QJSValue funcData[1] = { wIdVal };
+        JS_SetPropertyStr(ctx, bridge, "fetch",
+            JS_NewCFunctionData(ctx, qjs_bridge_fetch, 4, 0, 1, funcData));
+        JS_FreeValue(ctx, wIdVal);
+    }
+#endif /* __APPLE__ */
+#endif
+}

package/native/src/platform/darwin/worker/qjs/qjs_macros.zc

@@ -0,0 +1,23 @@
+// Re-establish QuickJS type macros for the shared QJS wrapper files.
+// engine_qjs.zc undef's them after including quickjs.h, so subsequent QJS
+// modules need them back to avoid collisions with JavaScriptCore types.
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+raw {
+#ifdef __APPLE__
+#ifdef ZAPP_WORKER_ENGINE_QJS
+    #define JSContext QJSContext
+    #define JSRuntime QJSRuntime
+    #define JSValue QJSValue
+    #define JSClassID QJSClassID
+    #define JSClassDef QJSClassDef
+    #define JSClassEx QJSClassEx
+    #define JSValueConst QJSValueConst
+    #define JSPropertyEnum QJSPropertyEnum
+    #define JSPropertyDescriptor QJSPropertyDescriptor
+    #include "quickjs.h"
+    #include "quickjs-libc.h"
+    /* Do NOT #undef: shared QJS modules need these macros active. */
+#endif
+#endif
+}

package/native/src/platform/darwin/worker/qjs/websocket_qjs.zc

@@ -0,0 +1,223 @@
+// QJS wrapper for WebSocket. Delegates to core/websocket_core.zc.
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+raw {
+#ifdef ZAPP_WORKER_ENGINE_QJS
+#ifdef __APPLE__
+    static char* zapp_core_ws_connect(const char* url_str, const char** protocols, int protocol_count,
+                                       zapp_ws_event_fn callback, void* user_data);
+    static void zapp_core_ws_send_text(const char* ws_id, const char* text);
+    static void zapp_core_ws_send_binary(const char* ws_id, const uint8_t* bytes, size_t len);
+    static void zapp_core_ws_close(const char* ws_id, int code, const char* reason);
+    static void zapp_core_ws_ensure_init(void);
+
+    dispatch_queue_t zapp_darwin_qjs_get_queue(void);
+    NSValue* zapp_darwin_qjs_get_context(NSString* workerId);
+    void zapp_darwin_qjs_drain_jobs(void* ctx, const char* label);
+
+    // Storage for QJS callback references keyed by wsId
+    static NSMutableDictionary<NSString*, NSMutableDictionary*>* zapp_qjs_ws_refs = nil;
+
+    // QJS WS callback: receives events from core and dispatches to QJS context.
+    static void zapp_qjs_ws_callback(const char* ws_id, const char* event_type, const char* json_payload, void* user_data) {
+        if (!ws_id || !json_payload || !user_data) return;
+
+        NSString* wsId = [NSString stringWithUTF8String:ws_id];
+        NSString* jsonStr = [NSString stringWithUTF8String:json_payload];
+        NSString* workerId = (__bridge NSString*)user_data;
+
+        dispatch_queue_t q = zapp_darwin_qjs_get_queue();
+        if (!q) return;
+
+        dispatch_async(q, ^{
+            NSValue* ctxVal = zapp_darwin_qjs_get_context(workerId);
+            if (!ctxVal) return;
+            QJSContext* ctx = (QJSContext*)[ctxVal pointerValue];
+
+            NSMutableDictionary* ref = zapp_qjs_ws_refs[wsId];
+            if (!ref) return;
+            NSValue* fnBoxed = ref[@"fn"];
+            if (!fnBoxed) return;
+            QJSValue fn = *(QJSValue*)[fnBoxed pointerValue];
+
+            // Parse JSON and call the JS callback
+            QJSValue global = JS_GetGlobalObject(ctx);
+            QJSValue JSON = JS_GetPropertyStr(ctx, global, "JSON");
+            QJSValue parse = JS_GetPropertyStr(ctx, JSON, "parse");
+            QJSValue jsonArg = JS_NewString(ctx, [jsonStr UTF8String]);
+            QJSValue parsed = JS_Call(ctx, parse, JSON, 1, &jsonArg);
+
+            QJSValue args[1] = { parsed };
+            QJSValue ret = JS_Call(ctx, fn, JS_UNDEFINED, 1, args);
+            if (JS_IsException(ret)) {
+                QJSValue exc = JS_GetException(ctx);
+                const char* s = JS_ToCString(ctx, exc);
+                NSLog(@"[zapp-ws-qjs] callback error: %s", s ? s : "unknown");
+                if (s) JS_FreeCString(ctx, s);
+                JS_FreeValue(ctx, exc);
+            }
+            JS_FreeValue(ctx, ret);
+            JS_FreeValue(ctx, parsed);
+            JS_FreeValue(ctx, jsonArg);
+            JS_FreeValue(ctx, parse);
+            JS_FreeValue(ctx, JSON);
+            JS_FreeValue(ctx, global);
+            zapp_darwin_qjs_drain_jobs(ctx, "ws-event");
+        });
+    }
+
+    static QJSValue qjs_bridge_wsConnect(QJSContext *ctx, QJSValue this_val, int argc, QJSValue *argv, int magic, QJSValue *func_data) {
+        if (argc < 3) return JS_NewString(ctx, "");
+
+        const char* urlStr = JS_ToCString(ctx, argv[0]);
+        if (!urlStr) return JS_NewString(ctx, "");
+
+        // Extract protocols array
+        const char** protos = NULL;
+        int protoCount = 0;
+        if (!JS_IsUndefined(argv[1]) && !JS_IsNull(argv[1])) {
+            QJSValue lenVal = JS_GetPropertyStr(ctx, argv[1], "length");
+            int32_t arrLen = 0;
+            JS_ToInt32(ctx, &arrLen, lenVal);
+            JS_FreeValue(ctx, lenVal);
+            if (arrLen > 0) {
+                protoCount = arrLen;
+                protos = (const char**)malloc(sizeof(const char*) * protoCount);
+                for (int i = 0; i < protoCount; i++) {
+                    QJSValue el = JS_GetPropertyUint32(ctx, argv[1], (uint32_t)i);
+                    protos[i] = JS_ToCString(ctx, el);
+                    JS_FreeValue(ctx, el);
+                }
+            }
+        }
+
+        // Get worker ID for callback dispatch
+        const char* workerId = JS_ToCString(ctx, func_data[0]);
+        NSString* wId = workerId ? [NSString stringWithUTF8String:workerId] : @"";
+        if (workerId) JS_FreeCString(ctx, workerId);
+
+        // Retain JS callback
+        QJSValue jsFn = JS_DupValue(ctx, argv[2]);
+        QJSValue* fnBox = (QJSValue*)malloc(sizeof(QJSValue));
+        *fnBox = jsFn;
+
+        char* wsIdC = zapp_core_ws_connect(urlStr, protos, protoCount, zapp_qjs_ws_callback, (__bridge void*)wId);
+
+        // Free protocol strings
+        for (int i = 0; i < protoCount; i++) {
+            if (protos[i]) JS_FreeCString(ctx, protos[i]);
+        }
+        free(protos);
+        JS_FreeCString(ctx, urlStr);
+
+        if (!wsIdC) {
+            JS_FreeValue(ctx, jsFn);
+            free(fnBox);
+            return JS_NewString(ctx, "");
+        }
+
+        NSString* wsId = [NSString stringWithUTF8String:wsIdC];
+        if (zapp_qjs_ws_refs == nil) zapp_qjs_ws_refs = [NSMutableDictionary new];
+        zapp_qjs_ws_refs[wsId] = [@{
+            @"fn": [NSValue valueWithPointer:fnBox],
+            @"ctx": [NSValue valueWithPointer:ctx],
+        } mutableCopy];
+
+        QJSValue result = JS_NewString(ctx, wsIdC);
+        free(wsIdC);
+        return result;
+    }
+
+    static QJSValue qjs_bridge_wsSend(QJSContext *ctx, QJSValue this_val, int argc, QJSValue *argv) {
+        if (argc < 3) return JS_UNDEFINED;
+
+        const char* wsId = JS_ToCString(ctx, argv[0]);
+        if (!wsId) return JS_UNDEFINED;
+
+        int isBinary = JS_ToBool(ctx, argv[2]);
+
+        if (isBinary) {
+            size_t len = 0;
+            uint8_t* bytes = JS_GetArrayBuffer(ctx, &len, argv[1]);
+            if (!bytes) {
+                QJSValue bufProp = JS_GetPropertyStr(ctx, argv[1], "buffer");
+                if (!JS_IsUndefined(bufProp)) {
+                    size_t bufLen = 0;
+                    uint8_t* bufPtr = JS_GetArrayBuffer(ctx, &bufLen, bufProp);
+                    QJSValue oVal = JS_GetPropertyStr(ctx, argv[1], "byteOffset");
+                    QJSValue lVal = JS_GetPropertyStr(ctx, argv[1], "byteLength");
+                    int32_t off = 0, blen = 0;
+                    JS_ToInt32(ctx, &off, oVal);
+                    JS_ToInt32(ctx, &blen, lVal);
+                    JS_FreeValue(ctx, oVal);
+                    JS_FreeValue(ctx, lVal);
+                    if (bufPtr && off >= 0 && blen > 0 && (size_t)(off + blen) <= bufLen) {
+                        bytes = bufPtr + off;
+                        len = (size_t)blen;
+                    }
+                }
+                JS_FreeValue(ctx, bufProp);
+            }
+            if (bytes && len > 0) zapp_core_ws_send_binary(wsId, bytes, len);
+        } else {
+            const char* text = JS_ToCString(ctx, argv[1]);
+            zapp_core_ws_send_text(wsId, text ? text : "");
+            if (text) JS_FreeCString(ctx, text);
+        }
+
+        JS_FreeCString(ctx, wsId);
+        return JS_UNDEFINED;
+    }
+
+    static QJSValue qjs_bridge_wsClose(QJSContext *ctx, QJSValue this_val, int argc, QJSValue *argv) {
+        if (argc < 1) return JS_UNDEFINED;
+        const char* wsId = JS_ToCString(ctx, argv[0]);
+        if (!wsId) return JS_UNDEFINED;
+
+        int32_t code = 1000;
+        if (argc >= 2 && !JS_IsUndefined(argv[1]) && !JS_IsNull(argv[1])) {
+            JS_ToInt32(ctx, &code, argv[1]);
+        }
+        const char* reason = NULL;
+        if (argc >= 3 && !JS_IsUndefined(argv[2]) && !JS_IsNull(argv[2])) {
+            reason = JS_ToCString(ctx, argv[2]);
+        }
+
+        zapp_core_ws_close(wsId, code, reason);
+
+        // Clean up JS callback reference
+        NSString* wsIdNS = [NSString stringWithUTF8String:wsId];
+        NSMutableDictionary* ref = zapp_qjs_ws_refs[wsIdNS];
+        if (ref) {
+            NSValue* fnBoxed = ref[@"fn"];
+            if (fnBoxed) {
+                QJSValue* fnBox = (QJSValue*)[fnBoxed pointerValue];
+                NSValue* ctxBoxed = ref[@"ctx"];
+                QJSContext* origCtx = ctxBoxed ? (QJSContext*)[ctxBoxed pointerValue] : ctx;
+                JS_FreeValue(origCtx, *fnBox);
+                free(fnBox);
+            }
+            [zapp_qjs_ws_refs removeObjectForKey:wsIdNS];
+        }
+
+        if (reason) JS_FreeCString(ctx, reason);
+        JS_FreeCString(ctx, wsId);
+        return JS_UNDEFINED;
+    }
+
+    void zapp_darwin_qjs_websocket_install(QJSContext* ctx, QJSValue bridge, const char* worker_id) {
+        zapp_core_ws_ensure_init();
+        if (zapp_qjs_ws_refs == nil) zapp_qjs_ws_refs = [NSMutableDictionary new];
+
+        QJSValue wIdVal = JS_NewString(ctx, worker_id);
+        QJSValue funcData[1] = { wIdVal };
+        JS_SetPropertyStr(ctx, bridge, "wsConnect", JS_NewCFunctionData(ctx, qjs_bridge_wsConnect, 3, 0, 1, funcData));
+        JS_FreeValue(ctx, wIdVal);
+
+        JS_SetPropertyStr(ctx, bridge, "wsSend", JS_NewCFunction(ctx, qjs_bridge_wsSend, "wsSend", 3));
+        JS_SetPropertyStr(ctx, bridge, "wsClose", JS_NewCFunction(ctx, qjs_bridge_wsClose, "wsClose", 3));
+    }
+
+#endif /* __APPLE__ */
+#endif
+}