@zappdev/cli 0.1.0

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

@@ -0,0 +1,149 @@
+//> macos: framework: JavaScriptCore
+
+raw {
+#ifdef __APPLE__
+    #include <Cocoa/Cocoa.h>
+    #include <WebKit/WebKit.h>
+    #include <dispatch/dispatch.h>
+    #include <JavaScriptCore/JavaScriptCore.h>
+
+    static dispatch_queue_t zapp_worker_js_queue = nil;
+    static void* zapp_worker_js_queue_key = &zapp_worker_js_queue_key;
+    static NSMutableDictionary<NSString*, NSMutableDictionary<NSNumber*, id>*>* zapp_worker_timers = nil;
+    static NSInteger zapp_next_timer_id = 1;
+    static const NSInteger zapp_worker_max_timers_per_worker = 256;
+    static const double zapp_worker_min_interval_ms = 4.0;
+
+    void zapp_darwin_worker_ensure_queue(void) {
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            zapp_worker_js_queue = dispatch_queue_create("dev.zapp.worker-js", DISPATCH_QUEUE_SERIAL);
+            dispatch_queue_set_specific(zapp_worker_js_queue, zapp_worker_js_queue_key, (void*)1, NULL);
+            zapp_worker_timers = [NSMutableDictionary dictionary];
+        });
+    }
+
+    void zapp_darwin_worker_js_sync(dispatch_block_t block) {
+        zapp_darwin_worker_ensure_queue();
+        if (dispatch_get_specific(zapp_worker_js_queue_key) != NULL) {
+            block();
+            return;
+        }
+        dispatch_sync(zapp_worker_js_queue, block);
+    }
+
+    void zapp_darwin_worker_timers_cancel(NSString* workerId) {
+        if (workerId == nil || zapp_worker_timers == nil) return;
+        NSMutableDictionary<NSNumber*, id>* timers = zapp_worker_timers[workerId];
+        if (timers == nil) return;
+        for (NSNumber* key in [timers allKeys]) {
+            dispatch_source_t src = (dispatch_source_t)timers[key];
+            if (src != nil) {
+                dispatch_source_cancel(src);
+            }
+        }
+        [timers removeAllObjects]; // Break retain cycle: timers -> src -> block -> timers
+        [zapp_worker_timers removeObjectForKey:workerId];
+    }
+
+    void zapp_darwin_worker_timers_cancel_all(void) {
+        if (zapp_worker_timers != nil) {
+            NSArray<NSString*>* workerIds = [zapp_worker_timers allKeys];
+            for (NSString* workerId in workerIds) {
+                zapp_darwin_worker_timers_cancel(workerId);
+            }
+            [zapp_worker_timers removeAllObjects];
+        }
+    }
+
+    void zapp_darwin_worker_timers_init(JSContext* ctx, NSString* workerId) {
+        zapp_darwin_worker_ensure_queue();
+        zapp_worker_timers[workerId] = [NSMutableDictionary dictionary];
+        __weak JSContext* weakCtx = ctx;
+
+        JSValue* bridge = ctx[@"__zappBridge"];
+        if (bridge == nil || bridge.isUndefined) {
+            ctx[@"__zappBridge"] = [JSValue valueWithNewObjectInContext:ctx];
+            bridge = ctx[@"__zappBridge"];
+        }
+
+        bridge[@"setTimer"] = ^(JSValue* fnVal, JSValue* msVal, JSValue* repeatVal) {
+            if (fnVal == nil || ![fnVal isObject]) return (NSNumber*)@0;
+            NSString* wId = [weakCtx[@"__zappWorkerDispatchId"] toString];
+            if (![wId isKindOfClass:[NSString class]] || [wId length] == 0) {
+                wId = workerId;
+            }
+            if (wId == nil) return (NSNumber*)@0;
+            NSMutableDictionary<NSNumber*, id>* timers = zapp_worker_timers[wId];
+            if (timers == nil) {
+                timers = [NSMutableDictionary dictionary];
+                zapp_worker_timers[wId] = timers;
+            }
+            if ([timers count] >= zapp_worker_max_timers_per_worker) {
+                return (NSNumber*)@0;
+            }
+            double ms = [msVal toDouble];
+            if (!(ms >= 0)) ms = 0;
+            BOOL shouldRepeat = [repeatVal toBool] ? YES : NO;
+            if (shouldRepeat && ms < zapp_worker_min_interval_ms) {
+                ms = zapp_worker_min_interval_ms;
+            }
+            NSInteger nextId = zapp_next_timer_id++;
+            NSNumber* timerId = @(nextId);
+            uint64_t intervalNs = (uint64_t)(ms * (double)NSEC_PER_MSEC);
+            if (intervalNs == 0) intervalNs = 1 * NSEC_PER_MSEC;
+            
+            dispatch_source_t src = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, zapp_worker_js_queue);
+            if (src == nil) return (NSNumber*)@0;
+            dispatch_source_set_timer(src, dispatch_time(DISPATCH_TIME_NOW, (int64_t)intervalNs), shouldRepeat ? intervalNs : DISPATCH_TIME_FOREVER, 1 * NSEC_PER_MSEC);
+            
+            __weak JSContext* weakCtxForTimer = weakCtx;
+            __block __weak dispatch_source_t weakSrc = src;
+            __block JSValue* blockFnVal = fnVal; // Make mutable so we can nil it out
+            
+            dispatch_source_set_event_handler(src, ^{
+                dispatch_source_t strongSrc = weakSrc;
+                JSContext* strongCtx = weakCtxForTimer;
+                if (strongCtx == nil) {
+                    if (strongSrc) dispatch_source_cancel(strongSrc);
+                    [timers removeObjectForKey:timerId];
+                    return;
+                }
+                NSString* currentDispatchId = [strongCtx[@"__zappWorkerDispatchId"] toString];
+                if (![currentDispatchId isKindOfClass:[NSString class]] || [currentDispatchId length] == 0) {
+                    currentDispatchId = wId;
+                }
+                if (blockFnVal) [blockFnVal callWithArguments:@[]];
+                if (!shouldRepeat) {
+                    if (strongSrc) dispatch_source_cancel(strongSrc);
+                    [timers removeObjectForKey:timerId];
+                }
+            });
+            
+            dispatch_source_set_cancel_handler(src, ^{
+                blockFnVal = nil; // Crucial: break the strong reference to JSValue -> JSContext
+            });
+            
+            dispatch_resume(src);
+            timers[timerId] = src;
+            return timerId;
+        };
+
+        bridge[@"clearTimer"] = ^(JSValue* idVal) {
+            NSString* wId = [weakCtx[@"__zappWorkerDispatchId"] toString];
+            if (![wId isKindOfClass:[NSString class]] || [wId length] == 0) {
+                wId = workerId;
+            }
+            if (wId == nil) return;
+            NSMutableDictionary<NSNumber*, id>* timers = zapp_worker_timers[wId];
+            if (timers == nil) return;
+            NSNumber* timerId = @([idVal toInt32]);
+            dispatch_source_t src = (dispatch_source_t)timers[timerId];
+            if (src != nil) {
+                dispatch_source_cancel(src);
+                [timers removeObjectForKey:timerId];
+            }
+        };
+    }
+#endif
+}

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

@@ -0,0 +1,209 @@
+// QJS worker timers: setTimer, clearTimer. Only built when ZAPP_WORKER_ENGINE_QJS.
+// Inlined after qjs.zc's QuickJS include so QJSContext/QJSValue are defined.
+
+@cfg(ZAPP_WORKER_ENGINE_QJS)
+raw {
+#ifdef ZAPP_WORKER_ENGINE_QJS
+#ifdef __APPLE__
+    #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 here: JS_UNDEFINED/JS_MKVAL etc. expand (JSValue){...} at use site;
+       later modules (fetch, crypto) and qjs need the macro active. */
+
+    static void qjs_call_bridge_method(QJSContext* ctx, NSString* methodName, int argc, QJSValue* argv);
+
+    extern NSValue* zapp_darwin_qjs_get_context(NSString* workerId);
+    extern dispatch_queue_t zapp_darwin_qjs_get_queue(void);
+    extern void zapp_darwin_qjs_drain_jobs(void* ctx, const char* label);
+
+    static NSMutableDictionary<NSString*, NSMutableDictionary<NSNumber*, id>*>* qjs_timers = nil;
+    static NSInteger qjs_next_timer_id = 1;
+    static const NSInteger qjs_max_timers_per_worker = 256;
+    static const double qjs_min_interval_ms = 4.0;
+
+    static QJSValue qjs_bridge_setTimer(QJSContext *ctx, QJSValue this_val, int argc, QJSValue *argv, int magic, QJSValue *func_data) {
+        if (argc < 3) return JS_NewInt32(ctx, 0);
+
+        const char *worker_id = JS_ToCString(ctx, func_data[0]);
+        if (!worker_id) return JS_NewInt32(ctx, 0);
+
+        QJSValue fnVal = argv[0];
+        if (!JS_IsFunction(ctx, fnVal)) {
+            JS_FreeCString(ctx, worker_id);
+            return JS_NewInt32(ctx, 0);
+        }
+
+        double ms = 0;
+        JS_ToFloat64(ctx, &ms, argv[1]);
+        if (!(ms >= 0)) ms = 0;
+
+        int shouldRepeat = JS_ToBool(ctx, argv[2]);
+        if (shouldRepeat && ms < qjs_min_interval_ms) {
+            ms = qjs_min_interval_ms;
+        }
+
+        NSString* wId = [NSString stringWithUTF8String:worker_id];
+        JS_FreeCString(ctx, worker_id);
+
+        dispatch_queue_t qjs_queue = zapp_darwin_qjs_get_queue();
+        if (!qjs_queue) return JS_NewInt32(ctx, 0);
+
+        if (!qjs_timers) qjs_timers = [NSMutableDictionary dictionary];
+        NSMutableDictionary<NSNumber*, id>* timers = qjs_timers[wId];
+        if (!timers) {
+            timers = [NSMutableDictionary dictionary];
+            qjs_timers[wId] = timers;
+        }
+
+        if ([timers count] >= qjs_max_timers_per_worker) {
+            return JS_NewInt32(ctx, 0);
+        }
+
+        NSInteger nextId = qjs_next_timer_id++;
+        NSNumber* timerId = @(nextId);
+        uint64_t intervalNs = (uint64_t)(ms * (double)NSEC_PER_MSEC);
+        if (intervalNs == 0) intervalNs = 1 * NSEC_PER_MSEC;
+
+        dispatch_source_t src = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, qjs_queue);
+        if (src == nil) return JS_NewInt32(ctx, 0);
+
+        dispatch_source_set_timer(
+            src,
+            dispatch_time(DISPATCH_TIME_NOW, (int64_t)intervalNs),
+            shouldRepeat ? intervalNs : DISPATCH_TIME_FOREVER,
+            1 * NSEC_PER_MSEC
+        );
+
+        QJSValue savedFn = JS_DupValue(ctx, fnVal);
+        QJSContext* creating_ctx = ctx;
+        __block BOOL isFreed = NO;
+        __block __weak dispatch_source_t weakSrc = src;
+
+        dispatch_source_set_event_handler(src, ^{
+            dispatch_source_t strongSrc = weakSrc;
+            NSValue* val = zapp_darwin_qjs_get_context(wId);
+            if (!val) {
+                if (strongSrc) dispatch_source_cancel(strongSrc);
+                return;
+            }
+
+            QJSContext* current_ctx = (QJSContext*)[val pointerValue];
+            if (current_ctx != creating_ctx) {
+                if (strongSrc) dispatch_source_cancel(strongSrc);
+                return;
+            }
+
+            QJSValue ret = JS_Call(current_ctx, savedFn, JS_UNDEFINED, 0, NULL);
+            if (JS_IsException(ret)) {
+                QJSValue exception = JS_GetException(current_ctx);
+                QJSValue args[1];
+                args[0] = JS_DupValue(current_ctx, exception);
+                qjs_call_bridge_method(current_ctx, @"reportError", 1, args);
+                JS_FreeValue(current_ctx, args[0]);
+                JS_FreeValue(current_ctx, exception);
+            }
+            JS_FreeValue(current_ctx, ret);
+
+            zapp_darwin_qjs_drain_jobs(current_ctx, "timer");
+
+            if (!shouldRepeat) {
+                if (strongSrc) dispatch_source_cancel(strongSrc);
+            }
+        });
+
+        dispatch_source_set_cancel_handler(src, ^{
+            if (!isFreed) {
+                NSValue* val = zapp_darwin_qjs_get_context(wId);
+                if (val) {
+                    QJSContext* current_ctx = (QJSContext*)[val pointerValue];
+                    if (current_ctx == creating_ctx) {
+                        JS_FreeValue(current_ctx, savedFn);
+                    }
+                }
+                isFreed = YES;
+            }
+            [timers removeObjectForKey:timerId];
+        });
+
+        timers[timerId] = src;
+        dispatch_resume(src);
+
+        return JS_NewInt32(ctx, (int32_t)nextId);
+    }
+
+    static QJSValue qjs_bridge_clearTimer(QJSContext *ctx, QJSValue this_val, int argc, QJSValue *argv, int magic, QJSValue *func_data) {
+        if (argc < 1) return JS_UNDEFINED;
+
+        const char *worker_id = JS_ToCString(ctx, func_data[0]);
+        if (!worker_id) return JS_UNDEFINED;
+
+        int32_t tId = 0;
+        JS_ToInt32(ctx, &tId, argv[0]);
+
+        NSString* wId = [NSString stringWithUTF8String:worker_id];
+        JS_FreeCString(ctx, worker_id);
+
+        if (qjs_timers) {
+            NSMutableDictionary<NSNumber*, id>* timers = qjs_timers[wId];
+            if (timers) {
+                NSNumber* timerId = @((NSInteger)tId);
+                dispatch_source_t src = (dispatch_source_t)timers[timerId];
+                if (src) {
+                    dispatch_source_cancel(src);
+                }
+            }
+        }
+
+        return JS_UNDEFINED;
+    }
+
+    void zapp_darwin_qjs_timers_cancel(NSString* workerId) {
+        if (workerId == nil || qjs_timers == nil) return;
+
+        NSMutableDictionary<NSNumber*, id>* timers = qjs_timers[workerId];
+        if (timers == nil) return;
+
+        for (NSNumber* key in [timers allKeys]) {
+            dispatch_source_t src = (dispatch_source_t)timers[key];
+            if (src != nil) {
+                dispatch_source_cancel(src);
+            }
+        }
+
+        [qjs_timers removeObjectForKey:workerId];
+    }
+
+    void zapp_darwin_qjs_timers_cancel_all(void) {
+        if (qjs_timers != nil) {
+            NSArray<NSString*>* workerIds = [qjs_timers allKeys];
+            for (NSString* workerId in workerIds) {
+                zapp_darwin_qjs_timers_cancel(workerId);
+            }
+            [qjs_timers removeAllObjects];
+        }
+    }
+
+    void zapp_darwin_qjs_timers_install(QJSContext* ctx, QJSValue bridge, const char* worker_id) {
+        QJSValue wIdVal = JS_NewString(ctx, worker_id);
+        QJSValue funcData[1] = { wIdVal };
+
+        QJSValue setTimerFunc = JS_NewCFunctionData(ctx, qjs_bridge_setTimer, 3, 0, 1, funcData);
+        JS_SetPropertyStr(ctx, bridge, "setTimer", setTimerFunc);
+
+        QJSValue clearTimerFunc = JS_NewCFunctionData(ctx, qjs_bridge_clearTimer, 1, 0, 1, funcData);
+        JS_SetPropertyStr(ctx, bridge, "clearTimer", clearTimerFunc);
+
+        JS_FreeValue(ctx, wIdVal);
+    }
+#endif /* __APPLE__ */
+#endif
+}

package/native/src/platform/platform.zc

@@ -0,0 +1,64 @@
+//> macos: define: apple
+//> windows: define: windows
+
+import "./window.zc";
+
+trait Platform {
+    fn init(self) -> void;
+    fn run(self, app: App*) -> int;
+}
+
+@cfg(apple)
+import "./darwin/platform.zc";
+
+@cfg(windows)
+import "./windows/platform.zc";
+
+@cfg(apple)
+fn platform_bind_runtime(app: App*) -> void {
+    darwin_platform_bind_runtime(app);
+}
+
+@cfg(windows)
+fn platform_bind_runtime(app: App*) -> void {
+    windows_platform_bind_runtime(app);
+}
+
+@cfg(ZAPP_LINUX)
+fn platform_bind_runtime(app: App*) -> void {
+    let _ = app;
+}
+
+@cfg(apple)
+fn platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    darwin_platform_handle_worker_bridge(app, action, payload);
+}
+
+@cfg(windows)
+fn platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    windows_platform_handle_worker_bridge(app, action, payload);
+}
+
+@cfg(ZAPP_LINUX)
+fn platform_handle_worker_bridge(app: App*, action: string, payload: string) -> void {
+    
+}
+
+@cfg(apple)
+fn platform_run(app: App*) -> int {
+    let platform = CocoaPlatform{};
+    return platform.run(app);
+}
+
+@cfg(windows)
+fn platform_run(app: App*) -> int {
+    let platform = WindowsPlatform{};
+    return platform.run(app);
+}
+
+@cfg(ZAPP_LINUX)
+fn platform_run(app: App*) -> int {
+    let _ = app;
+    println "Linux not implemented yet";
+    return 0;
+}

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

@@ -0,0 +1,156 @@
+// Zapp Unified Logging System
+// Provides consistent, colored logging across all contexts (workers, backend, webview)
+
+include <stdio.h>
+include <string.h>
+
+raw {
+    // Log levels (higher = more verbose)
+    #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
+
+    // Context types
+    #define ZAPP_LOG_CTX_BACKEND 0
+    #define ZAPP_LOG_CTX_WEBVIEW 1
+    #define ZAPP_LOG_CTX_WORKER  2
+
+    // ANSI color codes
+    #define ZAPP_ANSI_RESET   "\x1b[0m"
+    #define ZAPP_ANSI_RED     "\x1b[31m"
+    #define ZAPP_ANSI_YELLOW  "\x1b[33m"
+    #define ZAPP_ANSI_CYAN    "\x1b[36m"
+    #define ZAPP_ANSI_GRAY    "\x1b[90m"
+    #define ZAPP_ANSI_BOLD    "\x1b[1m"
+
+    // Global log level (default: WARN for prod, INFO for dev)
+    // Can be overridden via ZAPP_LOG_LEVEL env var or CLI flag
+    static int g_zapp_log_level = ZAPP_LOG_WARN;
+}
+
+// Platform-specific TTY check - Windows
+raw {
+#ifdef _WIN32
+    #include <io.h>
+    static bool zapp_log_use_colors(void) {
+        return _isatty(_fileno(stderr)) != 0;
+    }
+#endif
+}
+
+// Platform-specific TTY check - Unix/macOS
+raw {
+#ifndef _WIN32
+    #include <unistd.h>
+    static bool zapp_log_use_colors(void) {
+        return isatty(fileno(stderr)) != 0;
+    }
+#endif
+}
+
+raw {
+    // Get ANSI color for log level
+    static const char* zapp_log_level_color(int level) {
+        if (!zapp_log_use_colors()) return "";
+        switch (level) {
+            case ZAPP_LOG_ERROR: return ZAPP_ANSI_RED;
+            case ZAPP_LOG_WARN:  return ZAPP_ANSI_YELLOW;
+            case ZAPP_LOG_DEBUG: return ZAPP_ANSI_CYAN;
+            case ZAPP_LOG_TRACE: return ZAPP_ANSI_GRAY;
+            default: return "";
+        }
+    }
+
+    // Get level name string
+    static const char* zapp_log_level_name(int level) {
+        switch (level) {
+            case ZAPP_LOG_ERROR: return "error";
+            case ZAPP_LOG_WARN:  return "warn";
+            case ZAPP_LOG_INFO:  return "info";
+            case ZAPP_LOG_DEBUG: return "debug";
+            case ZAPP_LOG_TRACE: return "trace";
+            default: return "log";
+        }
+    }
+
+    // Core logging function
+    void zapp_log(int level, int ctx_type, int window_id, int worker_id, const char* message) {
+        if (level > g_zapp_log_level) return;
+        if (!message) return;
+
+        const char* color = zapp_log_level_color(level);
+        const char* reset = zapp_log_use_colors() ? ZAPP_ANSI_RESET : "";
+        const char* level_name = zapp_log_level_name(level);
+
+        // Build context string
+        char ctx_buf[64];
+        ctx_buf[0] = '\0';
+
+        if (ctx_type == ZAPP_LOG_CTX_BACKEND) {
+            snprintf(ctx_buf, sizeof(ctx_buf), "[B]");
+        } else if (ctx_type == ZAPP_LOG_CTX_WEBVIEW) {
+            snprintf(ctx_buf, sizeof(ctx_buf), "[V]");
+        } else if (ctx_type == ZAPP_LOG_CTX_WORKER) {
+            if (window_id >= 0 && worker_id >= 0) {
+                snprintf(ctx_buf, sizeof(ctx_buf), "[Win:%d][W:%d]", window_id, worker_id);
+            } else if (worker_id >= 0) {
+                snprintf(ctx_buf, sizeof(ctx_buf), "[W:%d]", worker_id);
+            } else {
+                snprintf(ctx_buf, sizeof(ctx_buf), "[W:?]");
+            }
+        }
+
+        // Output format: [Zapp] [Win:N][W:M] level: message
+        // Or for backend/webview: [Zapp] [B] level: message
+        fprintf(stderr, "%s[Zapp]%s %s %s%s:%s %s\n",
+                zapp_log_use_colors() ? ZAPP_ANSI_BOLD : "",
+                reset,
+                ctx_buf,
+                color,
+                level_name,
+                reset,
+                message);
+    }
+
+    // Convenience functions for each context
+    void zapp_log_backend(int level, const char* message) {
+        zapp_log(level, ZAPP_LOG_CTX_BACKEND, -1, -1, message);
+    }
+
+    void zapp_log_webview(int level, int window_id, const char* message) {
+        zapp_log(level, ZAPP_LOG_CTX_WEBVIEW, window_id, -1, message);
+    }
+
+    void zapp_log_worker(int level, int window_id, int worker_id, const char* message) {
+        zapp_log(level, ZAPP_LOG_CTX_WORKER, window_id, worker_id, message);
+    }
+
+    // Set global log level
+    void zapp_set_log_level(int level) {
+        if (level >= ZAPP_LOG_ERROR && level <= ZAPP_LOG_TRACE) {
+            g_zapp_log_level = level;
+        }
+    }
+
+    // Get current log level
+    int zapp_get_log_level(void) {
+        return g_zapp_log_level;
+    }
+
+    // Initialize log level from environment or default
+    void zapp_log_init(int default_level) {
+        g_zapp_log_level = default_level;
+
+        // Check environment variable
+        const char* env_level = getenv("ZAPP_LOG_LEVEL");
+        if (env_level) {
+            if (strcmp(env_level, "error") == 0) g_zapp_log_level = ZAPP_LOG_ERROR;
+            else if (strcmp(env_level, "warn") == 0) g_zapp_log_level = ZAPP_LOG_WARN;
+            else if (strcmp(env_level, "info") == 0) g_zapp_log_level = ZAPP_LOG_INFO;
+            else if (strcmp(env_level, "debug") == 0) g_zapp_log_level = ZAPP_LOG_DEBUG;
+            else if (strcmp(env_level, "trace") == 0) g_zapp_log_level = ZAPP_LOG_TRACE;
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+// Shared QJS wrapper for btoa/atob. Delegates to platform-specific core/base64_core.zc.
+
+raw {
+#if defined(ZAPP_WORKER_ENGINE_QJS)
+    #include "quickjs.h"
+    char* zapp_core_btoa(const char* input);
+    char* zapp_core_atob(const char* input);
+
+    static JSValue qjs_bridge_btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val;
+        if (argc < 1) return JS_NewString(ctx, "");
+        const char* input = JS_ToCString(ctx, argv[0]);
+        if (!input) return JS_NewString(ctx, "");
+        char* result = zapp_core_btoa(input);
+        JS_FreeCString(ctx, input);
+        JSValue ret = JS_NewString(ctx, result);
+        free(result);
+        return ret;
+    }
+
+    static JSValue qjs_bridge_atob(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val;
+        if (argc < 1) return JS_NewString(ctx, "");
+        const char* input = JS_ToCString(ctx, argv[0]);
+        if (!input) return JS_NewString(ctx, "");
+        char* result = zapp_core_atob(input);
+        JS_FreeCString(ctx, input);
+        JSValue ret = JS_NewString(ctx, result);
+        free(result);
+        return ret;
+    }
+
+    void zapp_qjs_base64_install(JSContext* ctx, JSValue bridge) {
+        JS_SetPropertyStr(ctx, bridge, "btoa", JS_NewCFunction(ctx, qjs_bridge_btoa, "btoa", 1));
+        JS_SetPropertyStr(ctx, bridge, "atob", JS_NewCFunction(ctx, qjs_bridge_atob, "atob", 1));
+    }
+#endif
+}

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

@@ -0,0 +1,44 @@
+// Shared QJS wrapper for crypto. Delegates to platform-specific core/crypto_core.zc.
+
+raw {
+#if defined(ZAPP_WORKER_ENGINE_QJS)
+    #include "quickjs.h"
+    void zapp_core_crypto_random_bytes(uint8_t* buf, size_t len);
+    char* zapp_core_crypto_random_uuid(void);
+
+    static JSValue qjs_bridge_getRandomValues(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val;
+        if (argc < 1) return JS_UNDEFINED;
+
+        JSValue arrayVal = argv[0];
+        size_t byte_offset = 0, byte_length = 0, bytes_per_element = 0;
+        JSValue buffer = JS_GetTypedArrayBuffer(ctx, arrayVal, &byte_offset, &byte_length, &bytes_per_element);
+        if (!JS_IsException(buffer)) {
+            size_t len = 0;
+            uint8_t* buf = JS_GetArrayBuffer(ctx, &len, buffer);
+            if (buf) zapp_core_crypto_random_bytes(buf + byte_offset, byte_length);
+            JS_FreeValue(ctx, buffer);
+        } else {
+            size_t len = 0;
+            uint8_t* buf = JS_GetArrayBuffer(ctx, &len, arrayVal);
+            if (buf) zapp_core_crypto_random_bytes(buf, len);
+        }
+        return JS_DupValue(ctx, arrayVal);
+    }
+
+    static JSValue qjs_bridge_randomUUID(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+        (void)this_val; (void)argc; (void)argv;
+        char* uuid = zapp_core_crypto_random_uuid();
+        JSValue result = JS_NewString(ctx, uuid);
+        free(uuid);
+        return result;
+    }
+
+    void zapp_qjs_crypto_install(JSContext* ctx, JSValue bridge) {
+        JS_SetPropertyStr(ctx, bridge, "getRandomValues",
+            JS_NewCFunction(ctx, qjs_bridge_getRandomValues, "getRandomValues", 1));
+        JS_SetPropertyStr(ctx, bridge, "randomUUID",
+            JS_NewCFunction(ctx, qjs_bridge_randomUUID, "randomUUID", 0));
+    }
+#endif
+}