@zappdev/cli 0.1.0

package/native/src/platform/shared/worker/qjs/encoding_qjs.zc

@@ -0,0 +1,95 @@
+// Shared QJS wrapper for TextEncoder/TextDecoder. Delegates to platform-specific core/encoding_core.zc.
+
+raw {
+#if defined(ZAPP_WORKER_ENGINE_QJS)
+    #include "quickjs.h"
+    uint8_t* zapp_core_text_encode(const char* input, size_t* out_len);
+    char* zapp_core_text_decode(const uint8_t* bytes, size_t len);
+
+    static JSValue qjs_bridge_textEncode(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val;
+        if (argc < 1) return JS_NewArrayBufferCopy(ctx, NULL, 0);
+        const char* str = JS_ToCString(ctx, argv[0]);
+        if (!str) return JS_NewArrayBufferCopy(ctx, NULL, 0);
+
+        size_t len = 0;
+        uint8_t* bytes = zapp_core_text_encode(str, &len);
+        JS_FreeCString(ctx, str);
+
+        if (!bytes || len == 0) {
+            free(bytes);
+            JSValue global = JS_GetGlobalObject(ctx);
+            JSValue u8ctor = JS_GetPropertyStr(ctx, global, "Uint8Array");
+            JSValue arg = JS_NewInt32(ctx, 0);
+            JSValue result = JS_CallConstructor(ctx, u8ctor, 1, &arg);
+            JS_FreeValue(ctx, arg);
+            JS_FreeValue(ctx, u8ctor);
+            JS_FreeValue(ctx, global);
+            return result;
+        }
+
+        JSValue global = JS_GetGlobalObject(ctx);
+        JSValue u8ctor = JS_GetPropertyStr(ctx, global, "Uint8Array");
+        JSValue lenArg = JS_NewInt32(ctx, (int32_t)len);
+        JSValue u8arr = JS_CallConstructor(ctx, u8ctor, 1, &lenArg);
+        JS_FreeValue(ctx, lenArg);
+
+        size_t u8size = 0;
+        uint8_t* u8ptr = JS_GetArrayBuffer(ctx, &u8size,
+            JS_GetPropertyStr(ctx, u8arr, "buffer"));
+        if (u8ptr && u8size >= len) {
+            memcpy(u8ptr, bytes, len);
+        } else {
+            for (size_t i = 0; i < len; i++) {
+                JS_SetPropertyUint32(ctx, u8arr, (uint32_t)i, JS_NewInt32(ctx, bytes[i]));
+            }
+        }
+
+        free(bytes);
+        JS_FreeValue(ctx, u8ctor);
+        JS_FreeValue(ctx, global);
+        return u8arr;
+    }
+
+    static JSValue qjs_bridge_textDecode(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val;
+        if (argc < 1) return JS_NewString(ctx, "");
+
+        size_t len = 0;
+        uint8_t* bytes = JS_GetArrayBuffer(ctx, &len, argv[0]);
+
+        if (!bytes) {
+            JSValue bufProp = JS_GetPropertyStr(ctx, argv[0], "buffer");
+            if (!JS_IsUndefined(bufProp)) {
+                size_t bufLen = 0;
+                uint8_t* bufPtr = JS_GetArrayBuffer(ctx, &bufLen, bufProp);
+                JSValue offsetVal = JS_GetPropertyStr(ctx, argv[0], "byteOffset");
+                JSValue lengthVal = JS_GetPropertyStr(ctx, argv[0], "byteLength");
+                int32_t offset = 0, length = 0;
+                JS_ToInt32(ctx, &offset, offsetVal);
+                JS_ToInt32(ctx, &length, lengthVal);
+                JS_FreeValue(ctx, offsetVal);
+                JS_FreeValue(ctx, lengthVal);
+
+                if (bufPtr && offset >= 0 && length > 0 && (size_t)(offset + length) <= bufLen) {
+                    bytes = bufPtr + offset;
+                    len = (size_t)length;
+                }
+            }
+            JS_FreeValue(ctx, bufProp);
+        }
+
+        if (!bytes || len == 0) return JS_NewString(ctx, "");
+
+        char* decoded = zapp_core_text_decode(bytes, len);
+        JSValue result = JS_NewString(ctx, decoded);
+        free(decoded);
+        return result;
+    }
+
+    void zapp_qjs_encoding_install(JSContext* ctx, JSValue bridge) {
+        JS_SetPropertyStr(ctx, bridge, "textEncode", JS_NewCFunction(ctx, qjs_bridge_textEncode, "textEncode", 1));
+        JS_SetPropertyStr(ctx, bridge, "textDecode", JS_NewCFunction(ctx, qjs_bridge_textDecode, "textDecode", 1));
+    }
+#endif
+}

package/native/src/platform/shared/worker/qjs/url_qjs.zc

@@ -0,0 +1,65 @@
+// Shared QJS wrapper for URL parsing. Delegates to platform-specific core/url_core.zc.
+
+raw {
+#if defined(ZAPP_WORKER_ENGINE_QJS)
+    #include "quickjs.h"
+    #ifndef ZAPP_URL_PARSED_DEFINED
+    #define ZAPP_URL_PARSED_DEFINED 1
+    typedef struct zapp_url_parsed {
+        char* href;
+        char* protocol;
+        char* host;
+        char* hostname;
+        char* port;
+        char* pathname;
+        char* search;
+        char* hash;
+        char* origin;
+        char* username;
+        char* password;
+    } zapp_url_parsed_t;
+    #endif
+
+    int zapp_core_url_parse(const char* url_str, const char* base_str, zapp_url_parsed_t* out);
+    void zapp_core_url_free(zapp_url_parsed_t* c);
+
+    static JSValue qjs_bridge_urlParse(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val;
+        if (argc < 1) return JS_NULL;
+
+        const char* urlStr = JS_ToCString(ctx, argv[0]);
+        if (!urlStr) return JS_NULL;
+
+        const char* baseStr = NULL;
+        if (argc >= 2 && !JS_IsUndefined(argv[1]) && !JS_IsNull(argv[1])) {
+            baseStr = JS_ToCString(ctx, argv[1]);
+        }
+
+        zapp_url_parsed_t c;
+        int err = zapp_core_url_parse(urlStr, baseStr, &c);
+        JS_FreeCString(ctx, urlStr);
+        if (baseStr) JS_FreeCString(ctx, baseStr);
+
+        if (err != 0) return JS_NULL;
+
+        JSValue obj = JS_NewObject(ctx);
+        JS_SetPropertyStr(ctx, obj, "href",     JS_NewString(ctx, c.href));
+        JS_SetPropertyStr(ctx, obj, "protocol", JS_NewString(ctx, c.protocol));
+        JS_SetPropertyStr(ctx, obj, "host",     JS_NewString(ctx, c.host));
+        JS_SetPropertyStr(ctx, obj, "hostname", JS_NewString(ctx, c.hostname));
+        JS_SetPropertyStr(ctx, obj, "port",     JS_NewString(ctx, c.port));
+        JS_SetPropertyStr(ctx, obj, "pathname", JS_NewString(ctx, c.pathname));
+        JS_SetPropertyStr(ctx, obj, "search",   JS_NewString(ctx, c.search));
+        JS_SetPropertyStr(ctx, obj, "hash",     JS_NewString(ctx, c.hash));
+        JS_SetPropertyStr(ctx, obj, "origin",   JS_NewString(ctx, c.origin));
+        JS_SetPropertyStr(ctx, obj, "username", JS_NewString(ctx, c.username));
+        JS_SetPropertyStr(ctx, obj, "password", JS_NewString(ctx, c.password));
+        zapp_core_url_free(&c);
+        return obj;
+    }
+
+    void zapp_qjs_url_install(JSContext* ctx, JSValue bridge) {
+        JS_SetPropertyStr(ctx, bridge, "urlParse", JS_NewCFunction(ctx, qjs_bridge_urlParse, "urlParse", 2));
+    }
+#endif
+}

package/native/src/platform/shared/worker_registry.zc

@@ -0,0 +1,206 @@
+// Worker Registry - Tracks per-window worker counters for logging
+
+include <string.h>
+
+raw {
+    #define ZAPP_MAX_WINDOWS 64
+    #define ZAPP_MAX_WORKER_ID_LEN 256
+
+    typedef struct {
+        char owner_id[ZAPP_MAX_WORKER_ID_LEN];
+        int window_id;
+        int next_worker_id;
+    } zapp_window_worker_counter_t;
+
+    static zapp_window_worker_counter_t g_window_worker_counters[ZAPP_MAX_WINDOWS];
+    static int g_window_counter_count = 0;
+    static int g_next_window_id = 1;
+
+    // Extract owner_id from worker_id (format: owner:ctx:zw-N)
+    static void zapp_extract_owner_id(const char* worker_id, char* owner_buf, size_t buf_len) {
+        if (!worker_id || !owner_buf || buf_len == 0) {
+            if (owner_buf && buf_len > 0) owner_buf[0] = '\0';
+            return;
+        }
+        
+        // Find first colon
+        const char* colon = strchr(worker_id, ':');
+        if (!colon) {
+            strncpy(owner_buf, worker_id, buf_len - 1);
+            owner_buf[buf_len - 1] = '\0';
+            return;
+        }
+        
+        size_t owner_len = colon - worker_id;
+        if (owner_len >= buf_len) owner_len = buf_len - 1;
+        strncpy(owner_buf, worker_id, owner_len);
+        owner_buf[owner_len] = '\0';
+    }
+
+    // Get window ID for an owner (creates if not exists)
+    static int zapp_get_window_id(const char* owner_id) {
+        if (!owner_id || owner_id[0] == '\0') return -1;
+
+        // Find existing window
+        for (int i = 0; i < g_window_counter_count; i++) {
+            if (strcmp(g_window_worker_counters[i].owner_id, owner_id) == 0) {
+                return g_window_worker_counters[i].window_id;
+            }
+        }
+
+        // Create new window entry
+        if (g_window_counter_count < ZAPP_MAX_WINDOWS) {
+            strncpy(g_window_worker_counters[g_window_counter_count].owner_id, owner_id, ZAPP_MAX_WORKER_ID_LEN - 1);
+            g_window_worker_counters[g_window_counter_count].owner_id[ZAPP_MAX_WORKER_ID_LEN - 1] = '\0';
+            g_window_worker_counters[g_window_counter_count].window_id = g_next_window_id++;
+            g_window_worker_counters[g_window_counter_count].next_worker_id = 0;
+            g_window_counter_count++;
+            return g_window_worker_counters[g_window_counter_count - 1].window_id;
+        }
+
+        return -1; // Too many windows
+    }
+
+    // Get or create a counter for a window (by owner_id)
+    static int zapp_get_next_worker_id(const char* owner_id) {
+        if (!owner_id || owner_id[0] == '\0') return -1;
+
+        // Find existing counter
+        for (int i = 0; i < g_window_counter_count; i++) {
+            if (strcmp(g_window_worker_counters[i].owner_id, owner_id) == 0) {
+                return ++g_window_worker_counters[i].next_worker_id;
+            }
+        }
+
+        // Create new counter (also assigns window ID)
+        if (g_window_counter_count < ZAPP_MAX_WINDOWS) {
+            strncpy(g_window_worker_counters[g_window_counter_count].owner_id, owner_id, ZAPP_MAX_WORKER_ID_LEN - 1);
+            g_window_worker_counters[g_window_counter_count].owner_id[ZAPP_MAX_WORKER_ID_LEN - 1] = '\0';
+            g_window_worker_counters[g_window_counter_count].window_id = g_next_window_id++;
+            g_window_worker_counters[g_window_counter_count].next_worker_id = 1;
+            g_window_counter_count++;
+            return 1;
+        }
+
+        return -1; // Too many windows
+    }
+
+    // Get both window ID and next worker ID in one call
+    static void zapp_get_window_and_worker_id(const char* owner_id, int* out_window_id, int* out_worker_id) {
+        if (!owner_id || owner_id[0] == '\0') {
+            if (out_window_id) *out_window_id = -1;
+            if (out_worker_id) *out_worker_id = -1;
+            return;
+        }
+
+        // Find existing
+        for (int i = 0; i < g_window_counter_count; i++) {
+            if (strcmp(g_window_worker_counters[i].owner_id, owner_id) == 0) {
+                if (out_window_id) *out_window_id = g_window_worker_counters[i].window_id;
+                if (out_worker_id) *out_worker_id = ++g_window_worker_counters[i].next_worker_id;
+                return;
+            }
+        }
+
+        // Create new
+        if (g_window_counter_count < ZAPP_MAX_WINDOWS) {
+            strncpy(g_window_worker_counters[g_window_counter_count].owner_id, owner_id, ZAPP_MAX_WORKER_ID_LEN - 1);
+            g_window_worker_counters[g_window_counter_count].owner_id[ZAPP_MAX_WORKER_ID_LEN - 1] = '\0';
+            g_window_worker_counters[g_window_counter_count].window_id = g_next_window_id++;
+            g_window_worker_counters[g_window_counter_count].next_worker_id = 1;
+            if (out_window_id) *out_window_id = g_window_worker_counters[g_window_counter_count].window_id;
+            if (out_worker_id) *out_worker_id = 1;
+            g_window_counter_count++;
+            return;
+        }
+
+        if (out_window_id) *out_window_id = -1;
+        if (out_worker_id) *out_worker_id = -1;
+    }
+
+    // Reset counter for a window (when window closes)
+    static void zapp_reset_window_workers(const char* owner_id) {
+        if (!owner_id) return;
+
+        for (int i = 0; i < g_window_counter_count; i++) {
+            if (strcmp(g_window_worker_counters[i].owner_id, owner_id) == 0) {
+                // Shift remaining counters
+                for (int j = i; j < g_window_counter_count - 1; j++) {
+                    memcpy(&g_window_worker_counters[j], &g_window_worker_counters[j + 1], sizeof(zapp_window_worker_counter_t));
+                }
+                g_window_counter_count--;
+                return;
+            }
+        }
+    }
+
+    // Reset all counters
+    static void zapp_reset_all_window_workers(void) {
+        g_window_counter_count = 0;
+        g_next_window_id = 1;
+    }
+
+    // --- Per-worker ID registry (register once, lookup many) ---
+
+    #define ZAPP_MAX_REGISTERED_WORKERS 512
+
+    typedef struct {
+        char worker_id[ZAPP_MAX_WORKER_ID_LEN];
+        int window_id;
+        int worker_seq_id;
+    } zapp_registered_worker_t;
+
+    static zapp_registered_worker_t g_registered_workers[ZAPP_MAX_REGISTERED_WORKERS];
+    static int g_registered_worker_count = 0;
+
+    static void zapp_worker_register(const char* worker_id) {
+        if (!worker_id || worker_id[0] == '\0') return;
+        if (g_registered_worker_count >= ZAPP_MAX_REGISTERED_WORKERS) return;
+
+        for (int i = 0; i < g_registered_worker_count; i++) {
+            if (strcmp(g_registered_workers[i].worker_id, worker_id) == 0) return;
+        }
+
+        char owner_buf[256];
+        zapp_extract_owner_id(worker_id, owner_buf, sizeof(owner_buf));
+
+        int win_id = -1, seq_id = -1;
+        zapp_get_window_and_worker_id(owner_buf, &win_id, &seq_id);
+
+        zapp_registered_worker_t* w = &g_registered_workers[g_registered_worker_count++];
+        strncpy(w->worker_id, worker_id, ZAPP_MAX_WORKER_ID_LEN - 1);
+        w->worker_id[ZAPP_MAX_WORKER_ID_LEN - 1] = '\0';
+        w->window_id = win_id;
+        w->worker_seq_id = seq_id;
+    }
+
+    static void zapp_worker_lookup(const char* worker_id, int* out_window_id, int* out_worker_seq_id) {
+        if (!worker_id || worker_id[0] == '\0') {
+            if (out_window_id) *out_window_id = -1;
+            if (out_worker_seq_id) *out_worker_seq_id = -1;
+            return;
+        }
+        for (int i = 0; i < g_registered_worker_count; i++) {
+            if (strcmp(g_registered_workers[i].worker_id, worker_id) == 0) {
+                if (out_window_id) *out_window_id = g_registered_workers[i].window_id;
+                if (out_worker_seq_id) *out_worker_seq_id = g_registered_workers[i].worker_seq_id;
+                return;
+            }
+        }
+        if (out_window_id) *out_window_id = -1;
+        if (out_worker_seq_id) *out_worker_seq_id = -1;
+    }
+
+    static void zapp_worker_unregister(const char* worker_id) {
+        if (!worker_id) return;
+        for (int i = 0; i < g_registered_worker_count; i++) {
+            if (strcmp(g_registered_workers[i].worker_id, worker_id) == 0) {
+                for (int j = i; j < g_registered_worker_count - 1; j++) {
+                    memcpy(&g_registered_workers[j], &g_registered_workers[j + 1], sizeof(zapp_registered_worker_t));
+                }
+                g_registered_worker_count--;
+                return;
+            }
+        }
+    }
+}