@zappdev/cli 0.1.0

package/native/src/platform/darwin/window.zc

@@ -0,0 +1,1223 @@
+import "../window.zc";
+import "./webview.zc";
+
+raw {
+#ifdef __APPLE__
+    #undef panic
+    #include <Cocoa/Cocoa.h>
+    #include <dispatch/dispatch.h>
+    #import <objc/runtime.h>
+
+    // Window event IDs (must match src/event/events.zc)
+    #define ZAPP_EVENT_WINDOW_READY       0
+    #define ZAPP_EVENT_WINDOW_FOCUS       1
+    #define ZAPP_EVENT_WINDOW_BLUR        2
+    #define ZAPP_EVENT_WINDOW_RESIZE      3
+    #define ZAPP_EVENT_WINDOW_MOVE        4
+    #define ZAPP_EVENT_WINDOW_CLOSE       5
+    #define ZAPP_EVENT_WINDOW_MINIMIZE    6
+    #define ZAPP_EVENT_WINDOW_MAXIMIZE    7
+    #define ZAPP_EVENT_WINDOW_RESTORE     8
+    #define ZAPP_EVENT_WINDOW_FULLSCREEN  9
+    #define ZAPP_EVENT_WINDOW_UNFULLSCREEN 10
+
+    #ifndef ZAPP_EVENT_RESULT_CANCEL
+    #define ZAPP_EVENT_RESULT_CANCEL 1
+    #endif
+
+    extern void zapp_darwin_reset_all_workers(void);
+    extern void zapp_darwin_reset_owner_workers(const char* owner_id);
+    extern void zapp_darwin_webview_create(void* window_ptr, bool inspectable);
+    extern void zapp_dispatch_window_event_to_bridge(const char* window_id, int event_id, int width, int height, int x, int y);
+    static int zapp_window_get_numeric_id(NSString* windowId);
+    extern int zapp_window_trigger_event_with_data(int id, int event_id, int w, int h, int x, int y);
+
+    // Per-window delegate that terminates attached workers when the window closes.
+    @interface ZappWindowDelegate : NSObject <NSWindowDelegate>
+    @property (nonatomic, copy) NSString* ownerId;
+    @property (nonatomic, copy) NSString* windowId;
+    @property (nonatomic, assign) BOOL bridgeReady;
+    @property (nonatomic, assign) BOOL pendingFocusEvent;
+    @property (nonatomic, assign) BOOL wasZoomed;
+    @property (nonatomic, assign) BOOL closeGuarded;
+    @property (nonatomic, assign) BOOL forceClose;
+    @end
+
+    static void zapp_window_unregister(NSWindow* window);
+
+    // Helper to fire both native callback and bridge event
+    static void zapp_fire_window_event(NSString* windowId, int event_id, int w, int h, int x, int y) {
+        if (windowId == nil) return;
+        int numId = zapp_window_get_numeric_id(windowId);
+        if (numId >= 0) zapp_window_trigger_event_with_data(numId, event_id, w, h, x, y);
+        zapp_dispatch_window_event_to_bridge([windowId UTF8String], event_id, w, h, x, y);
+    }
+
+    @implementation ZappWindowDelegate
+    - (instancetype)init {
+        self = [super init];
+        if (self) {
+            _bridgeReady = NO;
+            _pendingFocusEvent = NO;
+            _wasZoomed = NO;
+            _closeGuarded = NO;
+            _forceClose = NO;
+        }
+        return self;
+    }
+    - (BOOL)windowShouldClose:(NSWindow*)sender {
+        (void)sender;
+        if (self.forceClose) {
+            self.forceClose = NO;
+            return YES;
+        }
+        if (self.windowId) {
+            int numId = zapp_window_get_numeric_id(self.windowId);
+            if (numId >= 0) {
+                int result = zapp_window_trigger_event_with_data(numId, ZAPP_EVENT_WINDOW_CLOSE, 0, 0, 0, 0);
+                if (result == ZAPP_EVENT_RESULT_CANCEL) return NO;
+            }
+            if (self.closeGuarded) {
+                zapp_dispatch_window_event_to_bridge([self.windowId UTF8String], ZAPP_EVENT_WINDOW_CLOSE, 0, 0, 0, 0);
+                return NO;
+            }
+        }
+        return YES;
+    }
+    - (void)windowWillClose:(NSNotification*)notification {
+        NSWindow* window = (NSWindow*)[notification object];
+        if (window) {
+            zapp_window_unregister(window);
+        }
+        if (self.ownerId) {
+            zapp_darwin_reset_owner_workers([self.ownerId UTF8String]);
+        }
+    }
+    - (void)windowDidBecomeKey:(NSNotification*)notification {
+        (void)notification;
+        if (self.windowId) {
+            int numId = zapp_window_get_numeric_id(self.windowId);
+            if (numId >= 0) zapp_window_trigger_event_with_data(numId, ZAPP_EVENT_WINDOW_FOCUS, 0, 0, 0, 0);
+            if (self.bridgeReady) {
+                zapp_dispatch_window_event_to_bridge([self.windowId UTF8String], ZAPP_EVENT_WINDOW_FOCUS, 0, 0, 0, 0);
+            } else {
+                self.pendingFocusEvent = YES;
+            }
+        }
+    }
+    - (void)windowDidResignKey:(NSNotification*)notification {
+        (void)notification;
+        if (self.windowId) {
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_BLUR, 0, 0, 0, 0);
+        }
+    }
+    - (void)windowDidResize:(NSNotification*)notification {
+        NSWindow* window = (NSWindow*)[notification object];
+        if (self.windowId && window) {
+            NSRect frame = [window frame];
+            int w = (int)frame.size.width;
+            int h = (int)frame.size.height;
+            int x = (int)frame.origin.x;
+            int y = (int)frame.origin.y;
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_RESIZE, w, h, x, y);
+            // Detect maximize (zoom) transitions
+            BOOL isZoomed = [window isZoomed];
+            if (isZoomed && !self.wasZoomed) {
+                zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_MAXIMIZE, w, h, x, y);
+            } else if (!isZoomed && self.wasZoomed) {
+                zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_RESTORE, w, h, x, y);
+            }
+            self.wasZoomed = isZoomed;
+        }
+    }
+    - (void)windowDidMove:(NSNotification*)notification {
+        NSWindow* window = (NSWindow*)[notification object];
+        if (self.windowId && window) {
+            NSRect frame = [window frame];
+            int w = (int)frame.size.width;
+            int h = (int)frame.size.height;
+            int x = (int)frame.origin.x;
+            int y = (int)frame.origin.y;
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_MOVE, w, h, x, y);
+        }
+    }
+    - (void)windowDidMiniaturize:(NSNotification*)notification {
+        (void)notification;
+        if (self.windowId) {
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_MINIMIZE, 0, 0, 0, 0);
+        }
+    }
+    - (void)windowDidDeminiaturize:(NSNotification*)notification {
+        (void)notification;
+        if (self.windowId) {
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_RESTORE, 0, 0, 0, 0);
+        }
+    }
+    - (void)windowDidEnterFullScreen:(NSNotification*)notification {
+        (void)notification;
+        if (self.windowId) {
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_FULLSCREEN, 0, 0, 0, 0);
+        }
+    }
+    - (void)windowDidExitFullScreen:(NSNotification*)notification {
+        (void)notification;
+        if (self.windowId) {
+            zapp_fire_window_event(self.windowId, ZAPP_EVENT_WINDOW_UNFULLSCREEN, 0, 0, 0, 0);
+        }
+    }
+    @end
+
+    // Called when webview signals readiness - replays any buffered events
+    void zapp_window_set_bridge_ready(const char* window_id) {
+        if (window_id == NULL) return;
+        NSString* wid = [NSString stringWithUTF8String:window_id];
+        for (NSWindow* window in [NSApp windows]) {
+            ZappWindowDelegate* delegate = (ZappWindowDelegate*)[window delegate];
+            if ([delegate isKindOfClass:[ZappWindowDelegate class]] && [delegate.windowId isEqualToString:wid]) {
+                delegate.bridgeReady = YES;
+                if (delegate.pendingFocusEvent) {
+                    delegate.pendingFocusEvent = NO;
+                    zapp_dispatch_window_event_to_bridge([delegate.windowId UTF8String], ZAPP_EVENT_WINDOW_FOCUS, 0, 0, 0, 0);
+                }
+                break;
+            }
+        }
+    }
+
+    // Key for retaining the window delegate via associated object (NSWindow.delegate is weak).
+    static const char kZappWindowDelegateKey = 0;
+#endif
+}
+
+fn darwin_window_create(options: WindowOptions*) -> void* {
+    let handle: void* = NULL;
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            __block void* out = NULL;
+            void (^work)(void) = ^{
+                // Build style mask from options
+                NSUInteger styleMask = 0;
+                if (!options->borderless) {
+                    styleMask |= NSWindowStyleMaskTitled;
+                    if (options->closable)     styleMask |= NSWindowStyleMaskClosable;
+                    if (options->minimizable)  styleMask |= NSWindowStyleMaskMiniaturizable;
+                    if (options->resizable)    styleMask |= NSWindowStyleMaskResizable;
+                } else {
+                    styleMask = NSWindowStyleMaskBorderless;
+                }
+
+                NSRect frame = NSMakeRect(options->x, options->y, options->width, options->height);
+                NSWindow* window = [[NSWindow alloc] initWithContentRect:frame
+                    styleMask:styleMask
+                    backing:NSBackingStoreBuffered
+                    defer:NO];
+                [window setReleasedWhenClosed:NO];
+
+                NSString* titleStr = [NSString stringWithUTF8String:(const char*)options->title];
+                [window setTitle:titleStr];
+
+                if (options->titleBarStyle == WINDOW_TITLEBAR_STYLE_HIDDEN || options->titleBarStyle == WINDOW_TITLEBAR_STYLE_HIDDEN_INSET) {
+                    [window setStyleMask:([window styleMask] | NSWindowStyleMaskFullSizeContentView)];
+                    [window setTitleVisibility:NSWindowTitleHidden];
+                    [window setTitlebarAppearsTransparent:YES];
+                }
+
+                if (options->titleBarStyle == WINDOW_TITLEBAR_STYLE_HIDDEN_INSET) {
+                    #if defined(NSWindowToolbarStyleUnifiedCompact)
+                        if ([window respondsToSelector:@selector(setToolbarStyle:)]) {
+                            [window setToolbarStyle:NSWindowToolbarStyleUnifiedCompact];
+                        }
+                    #endif
+                }
+
+                if (options->transparent) {
+                    [window setOpaque:NO];
+                    [window setBackgroundColor:[NSColor clearColor]];
+                }
+
+                if (options->alwaysOnTop) {
+                    [window setLevel:NSFloatingWindowLevel];
+                }
+
+                bool inspectable = options->webContentInspectable > 0;
+                zapp_darwin_webview_create((__bridge void*)window, inspectable);
+
+                NSString* windowId = [NSString stringWithFormat:@"win-%p", window];
+                NSString* ownerId = [NSString stringWithFormat:@"owner-%p", window];
+                ZappWindowDelegate* windowDelegate = [[ZappWindowDelegate alloc] init];
+                windowDelegate.windowId = windowId;
+                windowDelegate.ownerId = ownerId;
+                objc_setAssociatedObject(window, &kZappWindowDelegateKey, windowDelegate, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+                [window setDelegate:windowDelegate];
+
+                if (options->fullscreen) {
+                    [window toggleFullScreen:nil];
+                }
+
+                if (options->visible && !options->hidden) {
+                    [window makeKeyAndOrderFront:nil];
+                }
+
+                out = (__bridge_retained void*)window;
+            };
+
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+
+            handle = out;
+        }
+#endif
+    }
+    return handle;
+}
+
+fn darwin_window_destroy(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    if ([[NSApp windows] count] <= 1) {
+                        zapp_darwin_reset_all_workers();
+                    }
+                    [nsWindow close];
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_show(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow makeKeyAndOrderFront:nil];
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_hide(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow orderOut:nil];
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_minimize(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow miniaturize:nil];
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_unminimize(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow deminiaturize:nil];
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_maximize(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow zoom:nil];
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_unmaximize(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    if ([nsWindow isZoomed]) {
+                        [nsWindow zoom:nil];
+                    }
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_register_numeric_id(window: void*, numeric_id: int) -> void {
+    raw {
+#ifdef __APPLE__
+        if (window == NULL) return;
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        NSString* windowId = [NSString stringWithFormat:@"win-%p", nsWindow];
+        zapp_window_register_numeric_id(windowId, numeric_id);
+#endif
+    }
+}
+
+fn darwin_window_toggle_minimize(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    if ([nsWindow isMiniaturized]) {
+                        [nsWindow deminiaturize:nil];
+                    } else {
+                        [nsWindow miniaturize:nil];
+                    }
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_toggle_maximize(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow zoom:nil];
+                }
+            };
+            if ([NSThread isMainThread]) {
+                work();
+            } else {
+                dispatch_sync(dispatch_get_main_queue(), work);
+            }
+        }
+#endif
+    }
+}
+
+fn darwin_window_set_title(window: void*, title: string) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow && title) {
+                    [nsWindow setTitle:[NSString stringWithUTF8String:(const char*)title]];
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_set_size(window: void*, width: int, height: int) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    NSRect frame = [nsWindow frame];
+                    frame.size = NSMakeSize((CGFloat)width, (CGFloat)height);
+                    [nsWindow setFrame:frame display:YES animate:YES];
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_set_position(window: void*, x: int, y: int) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow setFrameOrigin:NSMakePoint((CGFloat)x, (CGFloat)y)];
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_set_fullscreen(window: void*, on: bool) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    BOOL isFS = ([nsWindow styleMask] & NSWindowStyleMaskFullScreen) != 0;
+                    if ((on && !isFS) || (!on && isFS)) {
+                        [nsWindow toggleFullScreen:nil];
+                    }
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_set_always_on_top(window: void*, on: bool) -> void {
+    raw {
+#ifdef __APPLE__
+        @autoreleasepool {
+            void (^work)(void) = ^{
+                NSWindow* nsWindow = (__bridge NSWindow*)window;
+                if (nsWindow) {
+                    [nsWindow setLevel:on ? NSFloatingWindowLevel : NSNormalWindowLevel];
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_sync(dispatch_get_main_queue(), work); }
+        }
+#endif
+    }
+}
+
+fn darwin_window_get_size(window: void*) -> WindowSize {
+    let s = WindowSize{ width: 0, height: 0 };
+    raw {
+#ifdef __APPLE__
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        if (nsWindow) {
+            NSRect frame = [nsWindow frame];
+            s.width = (int)frame.size.width;
+            s.height = (int)frame.size.height;
+        }
+#endif
+    }
+    return s;
+}
+
+fn darwin_window_get_position(window: void*) -> WindowPosition {
+    let p = WindowPosition{ x: 0, y: 0 };
+    raw {
+#ifdef __APPLE__
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        if (nsWindow) {
+            NSRect frame = [nsWindow frame];
+            p.x = (int)frame.origin.x;
+            p.y = (int)frame.origin.y;
+        }
+#endif
+    }
+    return p;
+}
+
+fn darwin_window_is_minimized(window: void*) -> bool {
+    raw {
+#ifdef __APPLE__
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        if (nsWindow) return [nsWindow isMiniaturized] ? true : false;
+#endif
+    }
+    return false;
+}
+
+fn darwin_window_is_maximized(window: void*) -> bool {
+    raw {
+#ifdef __APPLE__
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        if (nsWindow) return [nsWindow isZoomed] ? true : false;
+#endif
+    }
+    return false;
+}
+
+fn darwin_window_is_fullscreen(window: void*) -> bool {
+    raw {
+#ifdef __APPLE__
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        if (nsWindow) return ([nsWindow styleMask] & NSWindowStyleMaskFullScreen) != 0;
+#endif
+    }
+    return false;
+}
+
+fn darwin_window_force_close(window: void*) -> void {
+    raw {
+#ifdef __APPLE__
+        NSWindow* nsWindow = (__bridge NSWindow*)window;
+        if (nsWindow) {
+            ZappWindowDelegate* del = (ZappWindowDelegate*)[nsWindow delegate];
+            if ([del isKindOfClass:[ZappWindowDelegate class]]) {
+                del.forceClose = YES;
+            }
+            [nsWindow close];
+        }
+#endif
+    }
+}
+
+raw {
+#ifdef __APPLE__
+    extern void* app_get_active(void);
+    extern void zapp_handle_message(void* app_ptr, char* msg_c);
+    extern void window_manager_trigger_on_ready(int window_id);
+
+    // Strong-reference registry so JS-created windows survive until explicitly closed.
+    static NSMutableDictionary<NSString*, NSWindow*>* zapp_window_registry = nil;
+    static NSMutableDictionary<NSString*, NSNumber*>* zapp_window_numeric_ids = nil;
+
+    static void zapp_window_registry_ensure(void) {
+        if (zapp_window_registry == nil) {
+            zapp_window_registry = [NSMutableDictionary dictionary];
+        }
+        if (zapp_window_numeric_ids == nil) {
+            zapp_window_numeric_ids = [NSMutableDictionary dictionary];
+        }
+    }
+
+    static NSString* zapp_window_register(NSWindow* window) {
+        zapp_window_registry_ensure();
+        NSString* windowId = [NSString stringWithFormat:@"win-%p", window];
+        [zapp_window_registry setObject:window forKey:windowId];
+        return windowId;
+    }
+
+    static void zapp_window_register_numeric_id(NSString* windowId, int numericId) {
+        zapp_window_registry_ensure();
+        [zapp_window_numeric_ids setObject:@(numericId) forKey:windowId];
+    }
+
+    static int zapp_window_get_numeric_id(NSString* windowId) {
+        zapp_window_registry_ensure();
+        NSNumber* num = [zapp_window_numeric_ids objectForKey:windowId];
+        return num ? [num intValue] : -1;
+    }
+
+    void zapp_darwin_window_register_numeric_id(const char* window_id, int numeric_id) {
+        NSString* windowId = [NSString stringWithUTF8String:window_id];
+        zapp_window_register_numeric_id(windowId, numeric_id);
+    }
+#endif
+}
+
+raw {
+#ifdef __APPLE__
+    static void zapp_window_unregister(NSWindow* window) {
+        if (zapp_window_registry == nil || window == nil) return;
+        NSString* keyToRemove = nil;
+        for (NSString* key in zapp_window_registry) {
+            if (zapp_window_registry[key] == window) {
+                keyToRemove = key;
+                break;
+            }
+        }
+        if (keyToRemove) [zapp_window_registry removeObjectForKey:keyToRemove];
+    }
+
+    static NSWindow* zapp_window_lookup(NSString* windowId) {
+        zapp_window_registry_ensure();
+        if (windowId == nil || [windowId length] == 0) return nil;
+
+        NSWindow* win = [zapp_window_registry objectForKey:windowId];
+        if (win != nil) return win;
+
+        for (NSWindow* window in [NSApp windows]) {
+            NSString* ownerId = [NSString stringWithFormat:@"owner-%p", window];
+            if ([ownerId isEqualToString:windowId]) return window;
+        }
+        return nil;
+    }
+
+    extern void zapp_backend_dispatch_window_result(const char* payload_json);
+    extern void zapp_backend_dispatch_window_ready(const char* window_id);
+
+    static void zapp_dispatch_window_result_to_all(const char* payload_json) {
+        NSString* payload = [NSString stringWithUTF8String:payload_json];
+        payload = [payload stringByReplacingOccurrencesOfString:@"\\" withString:@"\\\\"];
+        payload = [payload stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
+        NSString* js = [NSString stringWithFormat:
+            @"(function(){var b=globalThis[Symbol.for('zapp.bridge')];if(b&&typeof b.dispatchWindowResult==='function'){b.dispatchWindowResult('%@');}})();",
+            payload
+        ];
+        for (NSWindow* window in [NSApp windows]) {
+            NSView* content = [window contentView];
+            if ([content isKindOfClass:[WKWebView class]]) {
+                WKWebView* webview = (WKWebView*)content;
+                [webview evaluateJavaScript:js completionHandler:nil];
+            }
+        }
+        // Also dispatch to backend context
+        zapp_backend_dispatch_window_result(payload_json);
+    }
+
+    static void zapp_dispatch_dialog_result(const char* payload_json) {
+        NSString* payload = [NSString stringWithUTF8String:payload_json];
+        payload = [payload stringByReplacingOccurrencesOfString:@"\\" withString:@"\\\\"];
+        payload = [payload stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
+        NSString* js = [NSString stringWithFormat:
+            @"(function(){var b=globalThis[Symbol.for('zapp.bridge')];if(b&&typeof b.dispatchDialogResult==='function'){b.dispatchDialogResult('%@');}})();",
+            payload
+        ];
+        for (NSWindow* window in [NSApp windows]) {
+            NSView* content = [window contentView];
+            if ([content isKindOfClass:[WKWebView class]]) {
+                WKWebView* webview = (WKWebView*)content;
+                [webview evaluateJavaScript:js completionHandler:nil];
+            }
+        }
+    }
+
+    // Event names matching WindowEvent enum in TypeScript runtime
+    static const char* zapp_get_window_event_name(int event_id) {
+        switch (event_id) {
+            case ZAPP_EVENT_WINDOW_READY: return "ready";
+            case ZAPP_EVENT_WINDOW_FOCUS: return "focus";
+            case ZAPP_EVENT_WINDOW_BLUR: return "blur";
+            case ZAPP_EVENT_WINDOW_RESIZE: return "resize";
+            case ZAPP_EVENT_WINDOW_MOVE: return "move";
+            case ZAPP_EVENT_WINDOW_CLOSE: return "close";
+            case ZAPP_EVENT_WINDOW_MINIMIZE: return "minimize";
+            case ZAPP_EVENT_WINDOW_MAXIMIZE: return "maximize";
+            case ZAPP_EVENT_WINDOW_RESTORE: return "restore";
+            case ZAPP_EVENT_WINDOW_FULLSCREEN: return "fullscreen";
+            case ZAPP_EVENT_WINDOW_UNFULLSCREEN: return "unfullscreen";
+            default: return "unknown";
+        }
+    }
+
+    void zapp_dispatch_window_event_to_bridge(const char* window_id, int event_id, int width, int height, int x, int y) {
+        if (window_id == NULL) return;
+        const char* event_name = zapp_get_window_event_name(event_id);
+        NSString* escapedEvent = [NSString stringWithUTF8String:event_name];
+        escapedEvent = [escapedEvent stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
+        NSString* windowIdStr = [NSString stringWithUTF8String:window_id];
+
+        // Only include size/position payload for events where it's meaningful
+        BOOL hasPayload = (event_id == ZAPP_EVENT_WINDOW_RESIZE || event_id == ZAPP_EVENT_WINDOW_MOVE ||
+                           event_id == ZAPP_EVENT_WINDOW_MAXIMIZE || event_id == ZAPP_EVENT_WINDOW_RESTORE);
+        NSString* js;
+        if (hasPayload) {
+            js = [NSString stringWithFormat:
+                @"(function(){var b=globalThis[Symbol.for('zapp.bridge')];if(b&&typeof b.dispatchWindowEvent==='function'){b.dispatchWindowEvent('%@','%@','{\"width\":%d,\"height\":%d,\"x\":%d,\"y\":%d}');}})();",
+                windowIdStr, escapedEvent, width, height, x, y
+            ];
+        } else {
+            js = [NSString stringWithFormat:
+                @"(function(){var b=globalThis[Symbol.for('zapp.bridge')];if(b&&typeof b.dispatchWindowEvent==='function'){b.dispatchWindowEvent('%@','%@');}})();",
+                windowIdStr, escapedEvent
+            ];
+        }
+        for (NSWindow* window in [NSApp windows]) {
+            NSView* content = [window contentView];
+            if ([content isKindOfClass:[WKWebView class]]) {
+                WKWebView* webview = (WKWebView*)content;
+                [webview evaluateJavaScript:js completionHandler:nil];
+            }
+        }
+    }
+
+    void app_handle_window_message(App* app, char* action, char* payload_json) {
+        if (action == NULL || payload_json == NULL) return;
+        NSString* actionStr = [NSString stringWithUTF8String:action];
+        NSString* payload = [NSString stringWithUTF8String:payload_json];
+        NSData* payloadData = [payload dataUsingEncoding:NSUTF8StringEncoding];
+        if (payloadData == nil) return;
+        NSDictionary* body = [NSJSONSerialization JSONObjectWithData:payloadData options:0 error:nil];
+        if (![body isKindOfClass:[NSDictionary class]]) return;
+
+        if ([actionStr isEqualToString:@"ready"]) {
+            NSString* windowId = body[@"windowId"];
+            if ([windowId isKindOfClass:[NSString class]]) {
+                zapp_backend_dispatch_window_ready([windowId UTF8String]);
+                zapp_window_set_bridge_ready([windowId UTF8String]);
+                // Trigger native on_ready callback
+                int numericId = zapp_window_get_numeric_id(windowId);
+                if (numericId >= 0) {
+                    window_manager_trigger_on_ready(numericId);
+                }
+            }
+            return;
+        }
+
+        if ([actionStr isEqualToString:@"create"]) {
+            NSString* requestId = body[@"requestId"];
+            NSDictionary* opts = body[@"options"];
+            if (![requestId isKindOfClass:[NSString class]] || [requestId length] == 0) return;
+            if (![opts isKindOfClass:[NSDictionary class]]) opts = @{};
+
+            void (^createWork)(void) = ^{
+                NSString* title = [opts[@"title"] isKindOfClass:[NSString class]] ? opts[@"title"] : @"Zapp Window";
+                CGFloat width = [opts[@"width"] respondsToSelector:@selector(doubleValue)] ? [opts[@"width"] doubleValue] : 800;
+                CGFloat height = [opts[@"height"] respondsToSelector:@selector(doubleValue)] ? [opts[@"height"] doubleValue] : 600;
+                CGFloat x = [opts[@"x"] respondsToSelector:@selector(doubleValue)] ? [opts[@"x"] doubleValue] : 0;
+                CGFloat y = [opts[@"y"] respondsToSelector:@selector(doubleValue)] ? [opts[@"y"] doubleValue] : 0;
+
+                NSUInteger styleMask = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable | NSWindowStyleMaskResizable;
+
+                NSRect frame = NSMakeRect(x, y, width, height);
+                NSWindow* window = [[NSWindow alloc] initWithContentRect:frame
+                    styleMask:styleMask
+                    backing:NSBackingStoreBuffered
+                    defer:NO];
+                [window setReleasedWhenClosed:NO];
+                [window setTitle:title];
+
+                NSString* titleBarStyle = [opts[@"titleBarStyle"] isKindOfClass:[NSString class]] ? opts[@"titleBarStyle"] : @"default";
+                if ([titleBarStyle isEqualToString:@"hidden"] || [titleBarStyle isEqualToString:@"hiddenInset"]) {
+                    [window setStyleMask:([window styleMask] | NSWindowStyleMaskFullSizeContentView)];
+                    [window setTitleVisibility:NSWindowTitleHidden];
+                    [window setTitlebarAppearsTransparent:YES];
+                }
+
+                extern bool app_get_bootstrap_web_content_inspectable(void);
+                zapp_darwin_webview_create((__bridge void*)window, app_get_bootstrap_web_content_inspectable());
+
+                NSString* windowId = zapp_window_register(window);
+
+                NSString* ownerId = [NSString stringWithFormat:@"owner-%p", window];
+                ZappWindowDelegate* windowDelegate = [[ZappWindowDelegate alloc] init];
+                windowDelegate.windowId = windowId;
+                windowDelegate.ownerId = ownerId;
+                objc_setAssociatedObject(window, &kZappWindowDelegateKey, windowDelegate, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+                [window setDelegate:windowDelegate];
+
+                id visible = opts[@"visible"];
+                BOOL shouldShow = (visible == nil || ([visible respondsToSelector:@selector(boolValue)] && [visible boolValue]));
+                if (shouldShow) {
+                    [window makeKeyAndOrderFront:nil];
+                }
+
+                NSString* responseJson = [NSString stringWithFormat:
+                    @"{\"requestId\":\"%@\",\"id\":\"%@\",\"ok\":true}",
+                    requestId, windowId
+                ];
+                zapp_dispatch_window_result_to_all([responseJson UTF8String]);
+
+                // If a custom URL was specified, navigate to it (initial URL already loaded by webview create)
+                NSString* url = [opts[@"url"] isKindOfClass:[NSString class]] ? opts[@"url"] : nil;
+                if (url != nil && [url length] > 0) {
+                    NSView* content = [window contentView];
+                    if ([content isKindOfClass:[WKWebView class]]) {
+                        WKWebView* webview = (WKWebView*)content;
+                        NSURL* loadUrl;
+                        if ([url hasPrefix:@"http://"] || [url hasPrefix:@"https://"]) {
+                            loadUrl = [NSURL URLWithString:url];
+                        } else {
+                            // Relative URL: use the same scheme/base as the initial URL
+                            NSString* baseUrl = [NSString stringWithUTF8String:zapp_build_initial_url()];
+                            if ([baseUrl hasPrefix:@"http"]) {
+                                // Dev mode: relative to dev server
+                                NSURL* base = [NSURL URLWithString:baseUrl];
+                                loadUrl = [NSURL URLWithString:url relativeToURL:base];
+                            } else {
+                                // Prod mode: use zapp:// scheme
+                                if ([url hasPrefix:@"/"]) {
+                                    loadUrl = [NSURL URLWithString:[NSString stringWithFormat:@"zapp://app%@", url]];
+                                } else {
+                                    loadUrl = [NSURL URLWithString:[NSString stringWithFormat:@"zapp://app/%@", url]];
+                                }
+                            }
+                        }
+                        if (loadUrl) {
+                            [webview loadRequest:[NSURLRequest requestWithURL:loadUrl]];
+                        }
+                    }
+                }
+            };
+
+            if ([NSThread isMainThread]) { createWork(); }
+            else { dispatch_async(dispatch_get_main_queue(), createWork); }
+            return;
+        }
+
+        // All other actions operate on an existing window
+        NSString* windowId = body[@"windowId"];
+        if (![windowId isKindOfClass:[NSString class]] || [windowId length] == 0) return;
+
+        if ([actionStr isEqualToString:@"setCloseGuard"]) {
+            id guardVal = body[@"guard"];
+            BOOL guard = [guardVal respondsToSelector:@selector(boolValue)] && [guardVal boolValue];
+            void (^work)(void) = ^{
+                for (NSWindow* window in [NSApp windows]) {
+                    NSString* wid = [NSString stringWithFormat:@"win-%p", window];
+                    if ([wid isEqualToString:windowId]) {
+                        ZappWindowDelegate* del = (ZappWindowDelegate*)[window delegate];
+                        if ([del isKindOfClass:[ZappWindowDelegate class]]) {
+                            del.closeGuarded = guard;
+                        }
+                        break;
+                    }
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_async(dispatch_get_main_queue(), work); }
+            return;
+        }
+
+        if ([actionStr isEqualToString:@"destroy"]) {
+            void (^work)(void) = ^{
+                for (NSWindow* window in [NSApp windows]) {
+                    NSString* wid = [NSString stringWithFormat:@"win-%p", window];
+                    if ([wid isEqualToString:windowId]) {
+                        ZappWindowDelegate* del = (ZappWindowDelegate*)[window delegate];
+                        if ([del isKindOfClass:[ZappWindowDelegate class]]) {
+                            del.forceClose = YES;
+                        }
+                        [window close];
+                        break;
+                    }
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_async(dispatch_get_main_queue(), work); }
+            return;
+        }
+
+        if ([actionStr isEqualToString:@"setDragRegion"]) {
+            id dragVal = body[@"drag"];
+            BOOL drag = [dragVal respondsToSelector:@selector(boolValue)] && [dragVal boolValue];
+            void (^work)(void) = ^{
+                // Find the window by matching its windowId (win-%p format)
+                for (NSWindow* window in [NSApp windows]) {
+                    NSString* wid = [NSString stringWithFormat:@"win-%p", window];
+                    if ([wid isEqualToString:windowId]) {
+                        NSView* content = [window contentView];
+                        if ([content isKindOfClass:[ZappWebView class]]) {
+                            [(ZappWebView*)content setInDragRegion:drag];
+                        }
+                        break;
+                    }
+                }
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_async(dispatch_get_main_queue(), work); }
+            return;
+        }
+
+        void (^actionWork)(void) = ^{
+            NSWindow* nsWindow = zapp_window_lookup(windowId);
+            if (nsWindow == nil) return;
+
+            if ([actionStr isEqualToString:@"close"]) {
+                [nsWindow close];
+            } else if ([actionStr isEqualToString:@"show"]) {
+                [nsWindow makeKeyAndOrderFront:nil];
+            } else if ([actionStr isEqualToString:@"hide"]) {
+                [nsWindow orderOut:nil];
+            } else if ([actionStr isEqualToString:@"minimize"]) {
+                [nsWindow miniaturize:nil];
+            } else if ([actionStr isEqualToString:@"maximize"]) {
+                [nsWindow zoom:nil];
+            } else if ([actionStr isEqualToString:@"unminimize"]) {
+                [nsWindow deminiaturize:nil];
+            } else if ([actionStr isEqualToString:@"unmaximize"]) {
+                if ([nsWindow isZoomed]) [nsWindow zoom:nil];
+            } else if ([actionStr isEqualToString:@"toggle_minimize"]) {
+                if ([nsWindow isMiniaturized]) [nsWindow deminiaturize:nil];
+                else [nsWindow miniaturize:nil];
+            } else if ([actionStr isEqualToString:@"toggle_maximize"]) {
+                [nsWindow zoom:nil];
+            } else if ([actionStr isEqualToString:@"set_title"]) {
+                NSString* title = body[@"title"];
+                if ([title isKindOfClass:[NSString class]]) [nsWindow setTitle:title];
+            } else if ([actionStr isEqualToString:@"set_size"]) {
+                NSNumber* w = body[@"width"];
+                NSNumber* h = body[@"height"];
+                if ([w respondsToSelector:@selector(doubleValue)] && [h respondsToSelector:@selector(doubleValue)]) {
+                    NSRect frame = [nsWindow frame];
+                    frame.size = NSMakeSize([w doubleValue], [h doubleValue]);
+                    [nsWindow setFrame:frame display:YES animate:YES];
+                }
+            } else if ([actionStr isEqualToString:@"set_position"]) {
+                NSNumber* px = body[@"x"];
+                NSNumber* py = body[@"y"];
+                if ([px respondsToSelector:@selector(doubleValue)] && [py respondsToSelector:@selector(doubleValue)]) {
+                    [nsWindow setFrameOrigin:NSMakePoint([px doubleValue], [py doubleValue])];
+                }
+            } else if ([actionStr isEqualToString:@"set_fullscreen"]) {
+                id onVal = body[@"on"];
+                if ([onVal respondsToSelector:@selector(boolValue)]) {
+                    BOOL on = [onVal boolValue];
+                    BOOL isFS = ([nsWindow styleMask] & NSWindowStyleMaskFullScreen) != 0;
+                    if ((on && !isFS) || (!on && isFS)) {
+                        [nsWindow toggleFullScreen:nil];
+                    }
+                }
+            } else if ([actionStr isEqualToString:@"set_always_on_top"]) {
+                id onVal = body[@"on"];
+                if ([onVal respondsToSelector:@selector(boolValue)]) {
+                    [nsWindow setLevel:[onVal boolValue] ? NSFloatingWindowLevel : NSNormalWindowLevel];
+                }
+            }
+        };
+
+        if ([NSThread isMainThread]) { actionWork(); }
+        else { dispatch_async(dispatch_get_main_queue(), actionWork); }
+    }
+
+    void app_handle_app_action(App* app, char* action) {
+        (void)app;
+        if (action == NULL) return;
+        NSString* actionStr = [NSString stringWithUTF8String:action];
+
+        void (^work)(void) = ^{
+            if ([actionStr isEqualToString:@"quit"]) {
+                [NSApp terminate:nil];
+            } else if ([actionStr isEqualToString:@"hide"]) {
+                [NSApp hide:nil];
+            } else if ([actionStr isEqualToString:@"show"]) {
+                [NSApp unhide:nil];
+                [NSApp activateIgnoringOtherApps:YES];
+            }
+        };
+
+        if ([NSThread isMainThread]) { work(); }
+        else { dispatch_async(dispatch_get_main_queue(), work); }
+    }
+
+    // --- Open external URL ---
+    void app_open_external(App* app, char* payload) {
+        (void)app;
+        if (payload == NULL) return;
+        NSString* jsonStr = [NSString stringWithUTF8String:(const char*)payload];
+        NSData* data = [jsonStr dataUsingEncoding:NSUTF8StringEncoding];
+        if (data == nil) return;
+        NSDictionary* dict = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+        if (![dict isKindOfClass:[NSDictionary class]]) return;
+        NSString* urlStr = dict[@"url"];
+        if (![urlStr isKindOfClass:[NSString class]] || [urlStr length] == 0) return;
+        NSURL* url = [NSURL URLWithString:urlStr];
+        if (url) {
+            [[NSWorkspace sharedWorkspace] openURL:url];
+        }
+    }
+
+    // --- Dialog handling ---
+
+    void app_handle_dialog(App* app, char* action, char* payload_json) {
+        (void)app;
+        if (action == NULL || payload_json == NULL) return;
+        NSString* actionStr = [NSString stringWithUTF8String:action];
+        NSString* payload = [NSString stringWithUTF8String:payload_json];
+        NSData* payloadData = [payload dataUsingEncoding:NSUTF8StringEncoding];
+        if (payloadData == nil) return;
+        NSDictionary* body = [NSJSONSerialization JSONObjectWithData:payloadData options:0 error:nil];
+        if (![body isKindOfClass:[NSDictionary class]]) return;
+
+        NSString* requestId = body[@"requestId"];
+        if (![requestId isKindOfClass:[NSString class]] || [requestId length] == 0) return;
+
+        if ([actionStr isEqualToString:@"openFile"]) {
+            void (^work)(void) = ^{
+                NSOpenPanel* panel = [NSOpenPanel openPanel];
+                NSString* title = body[@"title"];
+                if ([title isKindOfClass:[NSString class]]) [panel setTitle:title];
+                id multiVal = body[@"multiple"];
+                if ([multiVal respondsToSelector:@selector(boolValue)]) {
+                    [panel setAllowsMultipleSelection:[multiVal boolValue]];
+                }
+                id dirVal = body[@"directory"];
+                if ([dirVal respondsToSelector:@selector(boolValue)] && [dirVal boolValue]) {
+                    [panel setCanChooseDirectories:YES];
+                    [panel setCanChooseFiles:NO];
+                } else {
+                    [panel setCanChooseDirectories:NO];
+                    [panel setCanChooseFiles:YES];
+                }
+                NSArray* filters = body[@"filters"];
+                if ([filters isKindOfClass:[NSArray class]] && [filters count] > 0) {
+                    NSMutableArray<NSString*>* extensions = [NSMutableArray array];
+                    for (NSDictionary* filter in filters) {
+                        NSArray* exts = filter[@"extensions"];
+                        if ([exts isKindOfClass:[NSArray class]]) {
+                            for (NSString* ext in exts) {
+                                if ([ext isKindOfClass:[NSString class]]) {
+                                    [extensions addObject:ext];
+                                }
+                            }
+                        }
+                    }
+                    if ([extensions count] > 0) {
+                        // Use allowedFileTypes (available on all macOS versions)
+                        [panel setAllowedFileTypes:extensions];
+                    }
+                }
+                NSString* defaultPath = body[@"defaultPath"];
+                if ([defaultPath isKindOfClass:[NSString class]] && [defaultPath length] > 0) {
+                    [panel setDirectoryURL:[NSURL fileURLWithPath:defaultPath]];
+                }
+
+                NSModalResponse result = [panel runModal];
+                NSString* responseJson;
+                if (result == NSModalResponseOK) {
+                    NSMutableArray<NSString*>* paths = [NSMutableArray array];
+                    for (NSURL* url in [panel URLs]) {
+                        [paths addObject:[url path]];
+                    }
+                    NSData* pathsData = [NSJSONSerialization dataWithJSONObject:paths options:0 error:nil];
+                    NSString* pathsStr = [[NSString alloc] initWithData:pathsData encoding:NSUTF8StringEncoding];
+                    responseJson = [NSString stringWithFormat:
+                        @"{\"requestId\":\"%@\",\"ok\":true,\"paths\":%@}",
+                        requestId, pathsStr];
+                } else {
+                    responseJson = [NSString stringWithFormat:
+                        @"{\"requestId\":\"%@\",\"ok\":false,\"cancelled\":true}",
+                        requestId];
+                }
+                zapp_dispatch_dialog_result([responseJson UTF8String]);
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_async(dispatch_get_main_queue(), work); }
+            return;
+        }
+
+        if ([actionStr isEqualToString:@"saveFile"]) {
+            void (^work)(void) = ^{
+                NSSavePanel* panel = [NSSavePanel savePanel];
+                NSString* title = body[@"title"];
+                if ([title isKindOfClass:[NSString class]]) [panel setTitle:title];
+                NSString* defaultName = body[@"defaultName"];
+                if ([defaultName isKindOfClass:[NSString class]] && [defaultName length] > 0) {
+                    [panel setNameFieldStringValue:defaultName];
+                }
+                NSString* defaultPath = body[@"defaultPath"];
+                if ([defaultPath isKindOfClass:[NSString class]] && [defaultPath length] > 0) {
+                    [panel setDirectoryURL:[NSURL fileURLWithPath:defaultPath]];
+                }
+
+                NSModalResponse result = [panel runModal];
+                NSString* responseJson;
+                if (result == NSModalResponseOK && [panel URL]) {
+                    NSString* path = [[panel URL] path];
+                    NSString* escaped = [path stringByReplacingOccurrencesOfString:@"\"" withString:@"\\\""];
+                    responseJson = [NSString stringWithFormat:
+                        @"{\"requestId\":\"%@\",\"ok\":true,\"path\":\"%@\"}",
+                        requestId, escaped];
+                } else {
+                    responseJson = [NSString stringWithFormat:
+                        @"{\"requestId\":\"%@\",\"ok\":false,\"cancelled\":true}",
+                        requestId];
+                }
+                zapp_dispatch_dialog_result([responseJson UTF8String]);
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_async(dispatch_get_main_queue(), work); }
+            return;
+        }
+
+        if ([actionStr isEqualToString:@"message"]) {
+            void (^work)(void) = ^{
+                NSAlert* alert = [[NSAlert alloc] init];
+                NSString* title = body[@"title"];
+                NSString* message = body[@"message"];
+                NSString* kind = body[@"kind"];
+                NSArray* buttons = body[@"buttons"];
+                if ([title isKindOfClass:[NSString class]]) [alert setMessageText:title];
+                if ([message isKindOfClass:[NSString class]]) [alert setInformativeText:message];
+                if ([kind isKindOfClass:[NSString class]]) {
+                    if ([kind isEqualToString:@"warning"]) [alert setAlertStyle:NSAlertStyleWarning];
+                    else if ([kind isEqualToString:@"critical"]) [alert setAlertStyle:NSAlertStyleCritical];
+                    else [alert setAlertStyle:NSAlertStyleInformational];
+                }
+                if ([buttons isKindOfClass:[NSArray class]]) {
+                    for (NSString* btn in buttons) {
+                        if ([btn isKindOfClass:[NSString class]]) {
+                            [alert addButtonWithTitle:btn];
+                        }
+                    }
+                }
+                if ([[alert buttons] count] == 0) {
+                    [alert addButtonWithTitle:@"OK"];
+                }
+                NSModalResponse result = [alert runModal];
+                int buttonIndex = (int)(result - NSAlertFirstButtonReturn);
+                NSString* responseJson = [NSString stringWithFormat:
+                    @"{\"requestId\":\"%@\",\"ok\":true,\"button\":%d}",
+                    requestId, buttonIndex];
+                zapp_dispatch_dialog_result([responseJson UTF8String]);
+            };
+            if ([NSThread isMainThread]) { work(); }
+            else { dispatch_async(dispatch_get_main_queue(), work); }
+            return;
+        }
+    }
+#endif
+}