@zappdev/cli 0.1.0

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

@@ -0,0 +1,1271 @@
+import "../window.zc";
+
+//> windows: link: -lcomdlg32
+
+raw {
+#ifdef _WIN32
+    #include <windows.h>
+    #include <stdio.h>
+
+    #ifndef ZAPP_WINDOW_ENTRY_DEFINED
+    #define ZAPP_WINDOW_ENTRY_DEFINED
+    typedef struct ZappWindowEntry {
+        HWND hwnd;
+        void* controller;
+        void* webview;
+        char ownerId[64];
+        BOOL in_use;
+        BOOL inspectable;
+        BOOL bridgeReady;
+        BOOL pendingFocusEvent;
+        BOOL closeGuarded;
+        BOOL forceClose;
+        WINDOWPLACEMENT prevPlacement;
+    } ZappWindowEntry;
+    #endif
+
+    extern const wchar_t* ZAPP_WINDOW_CLASS;
+    extern void zapp_windows_webview_create(HWND hwnd, BOOL inspectable);
+    extern ZappWindowEntry* zapp_window_entry_for_hwnd(HWND hwnd);
+
+    extern HMENU zapp_default_menu;
+
+    static HWND zapp_create_hwnd(const char* title, int width, int height, int x, int y,
+                                  _Bool resizable, _Bool closable, _Bool minimizable, _Bool maximizable,
+                                  _Bool borderless, _Bool alwaysOnTop) {
+        int titleLen = MultiByteToWideChar(CP_UTF8, 0, title, -1, NULL, 0);
+        wchar_t* wTitle = (wchar_t*)malloc(titleLen * sizeof(wchar_t));
+        MultiByteToWideChar(CP_UTF8, 0, title, -1, wTitle, titleLen);
+
+        UINT dpi = 96;
+        HMODULE user32 = GetModuleHandleW(L"user32.dll");
+        if (user32) {
+            typedef UINT (WINAPI *GetDpiForSystemFn)(void);
+            GetDpiForSystemFn getDpi = (GetDpiForSystemFn)GetProcAddress(user32, "GetDpiForSystem");
+            if (getDpi) dpi = getDpi();
+        }
+        int scaledW = MulDiv(width, dpi, 96);
+        int scaledH = MulDiv(height, dpi, 96);
+        int scaledX = (x != 0) ? MulDiv(x, dpi, 96) : 0;
+        int scaledY = (y != 0) ? MulDiv(y, dpi, 96) : 0;
+
+        // Build style from options
+        DWORD style = WS_CLIPCHILDREN;
+        DWORD exStyle = 0;
+        if (borderless) {
+            style |= WS_POPUP;
+        } else {
+            style |= WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU;
+            if (resizable)    style |= WS_THICKFRAME;
+            if (minimizable)  style |= WS_MINIMIZEBOX;
+            if (maximizable)  style |= WS_MAXIMIZEBOX;
+        }
+        if (alwaysOnTop) exStyle |= WS_EX_TOPMOST;
+
+        RECT rc = { 0, 0, scaledW, scaledH };
+        AdjustWindowRectEx(&rc, style, zapp_default_menu ? TRUE : FALSE, exStyle);
+        int adjW = rc.right - rc.left;
+        int adjH = rc.bottom - rc.top;
+
+        int screenW = GetSystemMetrics(SM_CXSCREEN);
+        int screenH = GetSystemMetrics(SM_CYSCREEN);
+        int posX = (scaledX == 0) ? (screenW - adjW) / 2 : scaledX;
+        int posY = (scaledY == 0) ? (screenH - adjH) / 2 : scaledY;
+
+        HWND hwnd = CreateWindowExW(
+            exStyle,
+            ZAPP_WINDOW_CLASS,
+            wTitle,
+            style,
+            posX, posY, adjW, adjH,
+            NULL, borderless ? NULL : zapp_default_menu,
+            GetModuleHandleW(NULL),
+            NULL
+        );
+        free(wTitle);
+        return hwnd;
+    }
+#endif
+}
+
+fn windows_window_create(options: WindowOptions*) -> void* {
+    let handle: void* = NULL;
+    raw {
+    #ifdef _WIN32
+        extern void zapp_register_window_class(void);
+        CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+        zapp_register_window_class();
+        HWND hwnd = zapp_create_hwnd(
+            (const char*)options->title,
+            options->width, options->height,
+            options->x, options->y,
+            options->resizable, options->closable,
+            options->minimizable, options->maximizable,
+            options->borderless, options->alwaysOnTop
+        );
+        if (hwnd == NULL) {
+            fprintf(stderr, "[zapp] CreateWindowEx failed: %lu\n", GetLastError());
+            return NULL;
+        }
+        BOOL inspectable = options->webContentInspectable > 0 ? TRUE : FALSE;
+        zapp_windows_webview_create(hwnd, inspectable);
+        if (options->fullscreen) {
+            windows_window_set_fullscreen((void*)hwnd, true);
+        }
+        if (options->visible && !options->hidden) {
+            ShowWindow(hwnd, SW_SHOW);
+            UpdateWindow(hwnd);
+        }
+        handle = (void*)hwnd;
+    #endif
+    }
+    return handle;
+}
+
+fn windows_window_destroy(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) DestroyWindow(hwnd);
+    #endif
+    }
+}
+
+fn windows_window_show(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) { ShowWindow(hwnd, SW_SHOW); UpdateWindow(hwnd); }
+    #endif
+    }
+}
+
+fn windows_window_hide(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) ShowWindow(hwnd, SW_HIDE);
+    #endif
+    }
+}
+
+fn windows_window_minimize(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) ShowWindow(hwnd, SW_MINIMIZE);
+    #endif
+    }
+}
+
+fn windows_window_unminimize(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) ShowWindow(hwnd, SW_RESTORE);
+    #endif
+    }
+}
+
+fn windows_window_maximize(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) ShowWindow(hwnd, SW_MAXIMIZE);
+    #endif
+    }
+}
+
+fn windows_window_unmaximize(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd) && IsZoomed(hwnd)) ShowWindow(hwnd, SW_RESTORE);
+    #endif
+    }
+}
+
+fn windows_window_toggle_minimize(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) ShowWindow(hwnd, IsIconic(hwnd) ? SW_RESTORE : SW_MINIMIZE);
+    #endif
+    }
+}
+
+fn windows_window_toggle_maximize(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) ShowWindow(hwnd, IsZoomed(hwnd) ? SW_RESTORE : SW_MAXIMIZE);
+    #endif
+    }
+}
+
+fn windows_window_set_title(window: void*, title: string) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd) && title) {
+            int len = MultiByteToWideChar(CP_UTF8, 0, (const char*)title, -1, NULL, 0);
+            wchar_t* wTitle = (wchar_t*)malloc(len * sizeof(wchar_t));
+            MultiByteToWideChar(CP_UTF8, 0, (const char*)title, -1, wTitle, len);
+            SetWindowTextW(hwnd, wTitle);
+            free(wTitle);
+        }
+    #endif
+    }
+}
+
+fn windows_window_set_size(window: void*, width: int, height: int) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) {
+            // Convert client area dimensions to window frame dimensions
+            DWORD style = (DWORD)GetWindowLongW(hwnd, GWL_STYLE);
+            BOOL hasMenu = GetMenu(hwnd) != NULL;
+            RECT desired = { 0, 0, width, height };
+            AdjustWindowRectEx(&desired, style, hasMenu, 0);
+            RECT pos;
+            GetWindowRect(hwnd, &pos);
+            MoveWindow(hwnd, pos.left, pos.top,
+                       desired.right - desired.left,
+                       desired.bottom - desired.top, TRUE);
+        }
+    #endif
+    }
+}
+
+fn windows_window_set_position(window: void*, x: int, y: int) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) {
+            RECT rc;
+            GetWindowRect(hwnd, &rc);
+            MoveWindow(hwnd, x, y, rc.right - rc.left, rc.bottom - rc.top, TRUE);
+        }
+    #endif
+    }
+}
+
+fn windows_window_set_fullscreen(window: void*, on: bool) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (!hwnd || !IsWindow(hwnd)) return;
+        extern int zapp_window_trigger_event_with_data(int id, int event_id, int w, int h, int x, int y);
+        extern void zapp_dispatch_window_event_to_bridge_win(const char* window_id, int event_id, int w, int h, int x, int y);
+        extern const char* zapp_win_id_for_hwnd(HWND hwnd);
+        extern int zapp_window_get_numeric_id(const char* window_id);
+        ZappWindowEntry* entry = zapp_window_entry_for_hwnd(hwnd);
+        LONG style = GetWindowLongW(hwnd, GWL_STYLE);
+        BOOL isFS = !(style & WS_OVERLAPPEDWINDOW);
+        if (on && !isFS) {
+            MONITORINFO mi = { sizeof(MONITORINFO) };
+            if (entry) {
+                entry->prevPlacement.length = sizeof(WINDOWPLACEMENT);
+                GetWindowPlacement(hwnd, &entry->prevPlacement);
+            }
+            GetMonitorInfoW(MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST), &mi);
+            SetWindowLongW(hwnd, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW);
+            SetWindowPos(hwnd, HWND_TOP,
+                mi.rcMonitor.left, mi.rcMonitor.top,
+                mi.rcMonitor.right - mi.rcMonitor.left,
+                mi.rcMonitor.bottom - mi.rcMonitor.top,
+                SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+            // Fire FULLSCREEN event
+            const char* wid = zapp_win_id_for_hwnd(hwnd);
+            if (wid) {
+                int nid = zapp_window_get_numeric_id(wid);
+                if (nid >= 0) zapp_window_trigger_event_with_data(nid, 9, 0, 0, 0, 0);
+                if (entry && entry->bridgeReady) zapp_dispatch_window_event_to_bridge_win(wid, 9, 0, 0, 0, 0);
+            }
+        } else if (!on && isFS && entry) {
+            SetWindowLongW(hwnd, GWL_STYLE, style | WS_OVERLAPPEDWINDOW);
+            SetWindowPlacement(hwnd, &entry->prevPlacement);
+            SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
+                SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+            // Fire UNFULLSCREEN event
+            const char* wid = zapp_win_id_for_hwnd(hwnd);
+            if (wid) {
+                int nid = zapp_window_get_numeric_id(wid);
+                if (nid >= 0) zapp_window_trigger_event_with_data(nid, 10, 0, 0, 0, 0);
+                if (entry && entry->bridgeReady) zapp_dispatch_window_event_to_bridge_win(wid, 10, 0, 0, 0, 0);
+            }
+        }
+    #endif
+    }
+}
+
+fn windows_window_set_always_on_top(window: void*, on: bool) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd))
+            SetWindowPos(hwnd, on ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+    #endif
+    }
+}
+
+raw {
+#ifdef _WIN32
+    // ---------------------------------------------------------------------------
+    // Numeric ID registry (maps window ID strings to numeric IDs for on_ready)
+    // ---------------------------------------------------------------------------
+
+    #define ZAPP_MAX_NUMERIC_IDS 64
+    typedef struct { char window_id[64]; int numeric_id; int in_use; } ZappNumericIdEntry;
+    static ZappNumericIdEntry zapp_numeric_ids[ZAPP_MAX_NUMERIC_IDS] = {0};
+
+    static void zapp_window_register_numeric_id_str(const char* window_id, int numeric_id) {
+        if (!window_id) return;
+        for (int i = 0; i < ZAPP_MAX_NUMERIC_IDS; i++) {
+            if (!zapp_numeric_ids[i].in_use) {
+                strncpy(zapp_numeric_ids[i].window_id, window_id, 63);
+                zapp_numeric_ids[i].window_id[63] = '\0';
+                zapp_numeric_ids[i].numeric_id = numeric_id;
+                zapp_numeric_ids[i].in_use = 1;
+                return;
+            }
+        }
+    }
+
+    int zapp_window_get_numeric_id(const char* window_id) {
+        if (!window_id) return -1;
+        for (int i = 0; i < ZAPP_MAX_NUMERIC_IDS; i++) {
+            if (zapp_numeric_ids[i].in_use && strcmp(zapp_numeric_ids[i].window_id, window_id) == 0)
+                return zapp_numeric_ids[i].numeric_id;
+        }
+        return -1;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Window registry (JS-created windows by string ID)
+    // ---------------------------------------------------------------------------
+
+    #define ZAPP_WIN_REG_MAX 256
+    typedef struct { char id[64]; HWND hwnd; int in_use; } ZappWinRegEntry;
+    static ZappWinRegEntry zapp_win_reg[ZAPP_WIN_REG_MAX] = {0};
+    static int zapp_win_reg_next = 0;
+
+    static const char* zapp_win_register(HWND hwnd) {
+        for (int i = 0; i < ZAPP_WIN_REG_MAX; i++) {
+            if (!zapp_win_reg[i].in_use) {
+                snprintf(zapp_win_reg[i].id, sizeof(zapp_win_reg[i].id), "win-%d", zapp_win_reg_next++);
+                zapp_win_reg[i].hwnd = hwnd;
+                zapp_win_reg[i].in_use = 1;
+                return zapp_win_reg[i].id;
+            }
+        }
+        return NULL;
+    }
+
+    static HWND zapp_win_lookup(const char* windowId) {
+        if (!windowId) return NULL;
+        for (int i = 0; i < ZAPP_WIN_REG_MAX; i++) {
+            if (zapp_win_reg[i].in_use && strcmp(zapp_win_reg[i].id, windowId) == 0)
+                return zapp_win_reg[i].hwnd;
+        }
+        return NULL;
+    }
+
+    static void zapp_win_unregister(const char* windowId) {
+        if (!windowId) return;
+        for (int i = 0; i < ZAPP_WIN_REG_MAX; i++) {
+            if (zapp_win_reg[i].in_use && strcmp(zapp_win_reg[i].id, windowId) == 0) {
+                zapp_win_reg[i].in_use = 0;
+                zapp_win_reg[i].hwnd = NULL;
+                return;
+            }
+        }
+    }
+
+    void zapp_win_unregister_by_hwnd(HWND hwnd) {
+        if (!hwnd) return;
+        for (int i = 0; i < ZAPP_WIN_REG_MAX; i++) {
+            if (zapp_win_reg[i].in_use && zapp_win_reg[i].hwnd == hwnd) {
+                zapp_win_reg[i].in_use = 0;
+                zapp_win_reg[i].hwnd = NULL;
+                return;
+            }
+        }
+    }
+
+    const char* zapp_win_id_for_hwnd(HWND hwnd) {
+        if (!hwnd) return NULL;
+        for (int i = 0; i < ZAPP_WIN_REG_MAX; i++) {
+            if (zapp_win_reg[i].in_use && zapp_win_reg[i].hwnd == hwnd)
+                return zapp_win_reg[i].id;
+        }
+        return NULL;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Dispatch window result to all webviews + backend
+    // ---------------------------------------------------------------------------
+
+    extern void zapp_windows_webview_eval_all(const char* js_utf8);
+    extern char* zapp_escape_js_string(const char* raw);
+    extern void zapp_backend_dispatch_window_result(const char* payload_json);
+    extern void windows_window_set_fullscreen(void* window, _Bool on);
+
+    static void zapp_dispatch_window_result_to_all(const char* payload_json) {
+        char* escaped = zapp_escape_js_string(payload_json);
+        size_t jsLen = strlen(escaped) + 256;
+        char* js = (char*)malloc(jsLen);
+        snprintf(js, jsLen,
+            "(function(){var b=globalThis[Symbol.for('zapp.bridge')];"
+            "if(b&&typeof b.dispatchWindowResult==='function'){b.dispatchWindowResult('%s');}})();",
+            escaped);
+        zapp_windows_webview_eval_all(js);
+        free(js);
+        free(escaped);
+        zapp_backend_dispatch_window_result(payload_json);
+    }
+
+    #ifndef ZAPP_EVENT_WINDOW_READY
+    #define ZAPP_EVENT_WINDOW_READY 0
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_FOCUS
+    #define ZAPP_EVENT_WINDOW_FOCUS 1
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_BLUR
+    #define ZAPP_EVENT_WINDOW_BLUR  2
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_RESIZE
+    #define ZAPP_EVENT_WINDOW_RESIZE 3
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_MOVE
+    #define ZAPP_EVENT_WINDOW_MOVE 4
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_CLOSE
+    #define ZAPP_EVENT_WINDOW_CLOSE 5
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_MINIMIZE
+    #define ZAPP_EVENT_WINDOW_MINIMIZE 6
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_MAXIMIZE
+    #define ZAPP_EVENT_WINDOW_MAXIMIZE 7
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_RESTORE
+    #define ZAPP_EVENT_WINDOW_RESTORE 8
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_FULLSCREEN
+    #define ZAPP_EVENT_WINDOW_FULLSCREEN 9
+    #endif
+    #ifndef ZAPP_EVENT_WINDOW_UNFULLSCREEN
+    #define ZAPP_EVENT_WINDOW_UNFULLSCREEN 10
+    #endif
+
+    static const char* zapp_get_window_event_name_win(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_win(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_win(event_id);
+        // Only include size/position payload for events where it's meaningful
+        int 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);
+        char js[1024];
+        if (hasPayload) {
+            snprintf(js, sizeof(js),
+                "(function(){var b=globalThis[Symbol.for('zapp.bridge')];"
+                "if(b&&b.dispatchWindowEvent)b.dispatchWindowEvent('%s','%s',"
+                "'{\"width\":%d,\"height\":%d,\"x\":%d,\"y\":%d}');})();",
+                window_id, event_name, width, height, x, y);
+        } else {
+            snprintf(js, sizeof(js),
+                "(function(){var b=globalThis[Symbol.for('zapp.bridge')];"
+                "if(b&&b.dispatchWindowEvent)b.dispatchWindowEvent('%s','%s');})();",
+                window_id, event_name);
+        }
+        zapp_windows_webview_eval_all(js);
+    }
+
+    // ---------------------------------------------------------------------------
+    // app_handle_window_message — called from app.zc for "window" messages
+    // ---------------------------------------------------------------------------
+
+    extern void zapp_windows_webview_create(HWND hwnd, BOOL inspectable);
+    extern const char* zapp_build_initial_url(void);
+    extern void zapp_backend_dispatch_window_ready(const char* window_id);
+    extern void window_manager_trigger_on_ready(int window_id);
+
+    extern char* zapp_json_get_string(const char* json, const char* key);
+    extern int zapp_json_get_int(const char* json, const char* key, int default_val);
+    extern int zapp_json_get_bool(const char* json, const char* key, int default_val);
+    extern char* zapp_json_get_raw(const char* json, const char* key);
+
+    void app_handle_window_message(App* app, char* action, char* payload_json) {
+        if (action == NULL || payload_json == NULL) return;
+        const char* json = (const char*)payload_json;
+
+        if (strcmp(action, "ready") == 0) {
+            char* windowId = zapp_json_get_string(json, "windowId");
+            if (windowId && windowId[0] != '\0') {
+                zapp_backend_dispatch_window_ready(windowId);
+                int numericId = zapp_window_get_numeric_id(windowId);
+                if (numericId >= 0) {
+                    window_manager_trigger_on_ready(numericId);
+                }
+                HWND hwnd = zapp_win_lookup(windowId);
+                if (hwnd) {
+                    ZappWindowEntry* entry = zapp_window_entry_for_hwnd(hwnd);
+                    if (entry) {
+                        entry->bridgeReady = TRUE;
+                        if (entry->pendingFocusEvent) {
+                            entry->pendingFocusEvent = FALSE;
+                            zapp_dispatch_window_event_to_bridge_win(windowId, ZAPP_EVENT_WINDOW_FOCUS, 0, 0, 0, 0);
+                        }
+                    }
+                }
+            }
+            if (windowId) free(windowId);
+            return;
+        }
+
+        if (strcmp(action, "create") == 0) {
+            char* requestId = zapp_json_get_string(json, "requestId");
+            if (!requestId || requestId[0] == '\0') { free(requestId); return; }
+
+            char* optsRaw = zapp_json_get_raw(json, "options");
+            const char* opts = optsRaw ? optsRaw : "{}";
+
+            char* title = zapp_json_get_string(opts, "title");
+            int width = zapp_json_get_int(opts, "width", 800);
+            int height = zapp_json_get_int(opts, "height", 600);
+            int x = zapp_json_get_int(opts, "x", 0);
+            int y = zapp_json_get_int(opts, "y", 0);
+            int visible = zapp_json_get_bool(opts, "visible", 1);
+
+            HWND hwnd = zapp_create_hwnd(
+                title ? title : "Zapp Window",
+                width, height, x, y,
+                1, 1, 1, 1, 0, 0  // defaults: resizable, closable, minimizable, maximizable, not borderless, not alwaysOnTop
+            );
+
+            if (hwnd) {
+                extern bool app_get_bootstrap_web_content_inspectable(void);
+                zapp_windows_webview_create(hwnd, app_get_bootstrap_web_content_inspectable() ? TRUE : FALSE);
+                const char* windowId = zapp_win_register(hwnd);
+
+                char* url = zapp_json_get_string(opts, "url");
+                if (url && url[0]) {
+                    extern void zapp_windows_webview_navigate(HWND hwnd, const char* url_utf8);
+                    zapp_windows_webview_navigate(hwnd, url);
+                }
+                if (url) free(url);
+
+                if (visible) {
+                    ShowWindow(hwnd, SW_SHOW);
+                    UpdateWindow(hwnd);
+                }
+
+                char response[512];
+                snprintf(response, sizeof(response),
+                    "{\"requestId\":\"%s\",\"id\":\"%s\",\"ok\":true}",
+                    requestId, windowId ? windowId : "");
+                zapp_dispatch_window_result_to_all(response);
+            }
+
+            free(requestId);
+            free(title);
+            if (optsRaw) free(optsRaw);
+            return;
+        }
+
+        char* windowId = zapp_json_get_string(json, "windowId");
+        if (!windowId || windowId[0] == '\0') { free(windowId); return; }
+
+        HWND hwnd = zapp_win_lookup(windowId);
+        if (!hwnd || !IsWindow(hwnd)) { free(windowId); return; }
+
+        if (strcmp(action, "setCloseGuard") == 0) {
+            extern int zapp_json_get_bool(const char* json, const char* key, int default_val);
+            int guard = zapp_json_get_bool(json, "guard", 0);
+            ZappWindowEntry* entry = zapp_window_entry_for_hwnd(hwnd);
+            if (entry) entry->closeGuarded = guard ? TRUE : FALSE;
+            free(windowId);
+            return;
+        }
+
+        if (strcmp(action, "destroy") == 0) {
+            ZappWindowEntry* entry = zapp_window_entry_for_hwnd(hwnd);
+            if (entry) entry->forceClose = TRUE;
+            PostMessageW(hwnd, WM_CLOSE, 0, 0);
+            free(windowId);
+            return;
+        }
+
+        if (strcmp(action, "startDrag") == 0) {
+            ReleaseCapture();
+            SendMessageW(hwnd, WM_SYSCOMMAND, SC_MOVE | HTCAPTION, 0);
+            free(windowId);
+            return;
+        }
+
+        if (strcmp(action, "close") == 0) {
+            zapp_win_unregister(windowId);
+            DestroyWindow(hwnd);
+        } else if (strcmp(action, "show") == 0) {
+            ShowWindow(hwnd, SW_SHOW);
+            UpdateWindow(hwnd);
+        } else if (strcmp(action, "hide") == 0) {
+            ShowWindow(hwnd, SW_HIDE);
+        } else if (strcmp(action, "minimize") == 0) {
+            ShowWindow(hwnd, SW_MINIMIZE);
+        } else if (strcmp(action, "maximize") == 0) {
+            ShowWindow(hwnd, SW_MAXIMIZE);
+        } else if (strcmp(action, "unminimize") == 0) {
+            ShowWindow(hwnd, SW_RESTORE);
+        } else if (strcmp(action, "unmaximize") == 0) {
+            if (IsZoomed(hwnd)) ShowWindow(hwnd, SW_RESTORE);
+        } else if (strcmp(action, "toggle_minimize") == 0) {
+            ShowWindow(hwnd, IsIconic(hwnd) ? SW_RESTORE : SW_MINIMIZE);
+        } else if (strcmp(action, "toggle_maximize") == 0) {
+            ShowWindow(hwnd, IsZoomed(hwnd) ? SW_RESTORE : SW_MAXIMIZE);
+        } else if (strcmp(action, "set_title") == 0) {
+            char* t = zapp_json_get_string(json, "title");
+            if (t) {
+                int len = MultiByteToWideChar(CP_UTF8, 0, t, -1, NULL, 0);
+                wchar_t* wt = (wchar_t*)malloc(len * sizeof(wchar_t));
+                MultiByteToWideChar(CP_UTF8, 0, t, -1, wt, len);
+                SetWindowTextW(hwnd, wt);
+                free(wt);
+                free(t);
+            }
+        } else if (strcmp(action, "set_size") == 0) {
+            int w = zapp_json_get_int(json, "width", -1);
+            int h = zapp_json_get_int(json, "height", -1);
+            if (w > 0 && h > 0) {
+                RECT rc;
+                GetWindowRect(hwnd, &rc);
+                MoveWindow(hwnd, rc.left, rc.top, w, h, TRUE);
+            }
+        } else if (strcmp(action, "set_position") == 0) {
+            int px = zapp_json_get_int(json, "x", -1);
+            int py = zapp_json_get_int(json, "y", -1);
+            if (px >= 0 && py >= 0) {
+                RECT rc;
+                GetWindowRect(hwnd, &rc);
+                int w = rc.right - rc.left;
+                int h = rc.bottom - rc.top;
+                MoveWindow(hwnd, px, py, w, h, TRUE);
+            }
+        } else if (strcmp(action, "set_fullscreen") == 0) {
+            int on = zapp_json_get_bool(json, "on", 0);
+            windows_window_set_fullscreen((void*)hwnd, on);
+        } else if (strcmp(action, "set_always_on_top") == 0) {
+            int on = zapp_json_get_bool(json, "on", 0);
+            SetWindowPos(hwnd, on ? HWND_TOPMOST : HWND_NOTOPMOST,
+                0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+        }
+
+        free(windowId);
+    }
+#endif
+}
+
+raw {
+#ifdef _WIN32
+    // --- Dialog handling (Windows) ---
+    extern char* zapp_json_get_string(const char* json, const char* key);
+    extern int zapp_json_get_bool(const char* json, const char* key, int default_val);
+    extern char* zapp_json_get_raw(const char* json, const char* key);
+    #include <commdlg.h>
+    #include <shlobj.h>
+    #include <shobjidl.h>
+    #include <commctrl.h>
+
+    static void zapp_dispatch_dialog_result(const char* payload_json) {
+        char* escaped = zapp_escape_js_string(payload_json);
+        size_t jsLen = strlen(escaped) + 256;
+        char* js = (char*)malloc(jsLen);
+        snprintf(js, jsLen,
+            "(function(){var b=globalThis[Symbol.for('zapp.bridge')];"
+            "if(b&&typeof b.dispatchDialogResult==='function'){b.dispatchDialogResult('%s');}})();",
+            escaped);
+        zapp_windows_webview_eval_all(js);
+        free(js);
+        free(escaped);
+    }
+
+    // Helper: escape a UTF-8 string for JSON embedding (quotes + backslashes)
+    static void zapp_json_escape_path(const char* src, char* dst, size_t dstSize) {
+        size_t i = 0;
+        while (*src && i + 3 < dstSize) {
+            if (*src == '"') { dst[i++] = '\\'; dst[i++] = '"'; }
+            else if (*src == '\\') { dst[i++] = '\\'; dst[i++] = '\\'; }
+            else { dst[i++] = *src; }
+            src++;
+        }
+        dst[i] = '\0';
+    }
+
+    // ---------------------------------------------------------------------------
+    // openFile: directory selection via IFileDialog COM
+    // ---------------------------------------------------------------------------
+    static int zapp_open_folder_dialog(const char* titleUtf8, const char* defaultPathUtf8,
+                                        char* requestId) {
+        IFileDialog* pfd = NULL;
+        HRESULT hr = CoCreateInstance(&CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER,
+                                       &IID_IFileOpenDialog, (void**)&pfd);
+        if (FAILED(hr) || !pfd) return 0;
+
+        DWORD opts = 0;
+        pfd->lpVtbl->GetOptions(pfd, &opts);
+        pfd->lpVtbl->SetOptions(pfd, opts | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM);
+
+        if (titleUtf8 && titleUtf8[0]) {
+            int len = MultiByteToWideChar(CP_UTF8, 0, titleUtf8, -1, NULL, 0);
+            wchar_t* wt = (wchar_t*)malloc(len * sizeof(wchar_t));
+            MultiByteToWideChar(CP_UTF8, 0, titleUtf8, -1, wt, len);
+            pfd->lpVtbl->SetTitle(pfd, wt);
+            free(wt);
+        }
+
+        if (defaultPathUtf8 && defaultPathUtf8[0]) {
+            int len = MultiByteToWideChar(CP_UTF8, 0, defaultPathUtf8, -1, NULL, 0);
+            wchar_t* wp = (wchar_t*)malloc(len * sizeof(wchar_t));
+            MultiByteToWideChar(CP_UTF8, 0, defaultPathUtf8, -1, wp, len);
+            IShellItem* psi = NULL;
+            SHCreateItemFromParsingName(wp, NULL, &IID_IShellItem, (void**)&psi);
+            if (psi) {
+                pfd->lpVtbl->SetFolder(pfd, psi);
+                psi->lpVtbl->Release(psi);
+            }
+            free(wp);
+        }
+
+        hr = pfd->lpVtbl->Show(pfd, NULL);
+        if (SUCCEEDED(hr)) {
+            IShellItem* psi = NULL;
+            pfd->lpVtbl->GetResult(pfd, &psi);
+            if (psi) {
+                PWSTR wPath = NULL;
+                psi->lpVtbl->GetDisplayName(psi, SIGDN_FILESYSPATH, &wPath);
+                if (wPath) {
+                    char utf8[MAX_PATH * 4];
+                    WideCharToMultiByte(CP_UTF8, 0, wPath, -1, utf8, sizeof(utf8), NULL, NULL);
+                    CoTaskMemFree(wPath);
+                    char escaped[MAX_PATH * 8];
+                    zapp_json_escape_path(utf8, escaped, sizeof(escaped));
+                    char response[MAX_PATH * 8 + 256];
+                    snprintf(response, sizeof(response),
+                        "{\"requestId\":\"%s\",\"ok\":true,\"paths\":[\"%s\"]}",
+                        requestId, escaped);
+                    zapp_dispatch_dialog_result(response);
+                }
+                psi->lpVtbl->Release(psi);
+            }
+        } else {
+            char response[256];
+            snprintf(response, sizeof(response),
+                "{\"requestId\":\"%s\",\"ok\":false,\"cancelled\":true}",
+                requestId);
+            zapp_dispatch_dialog_result(response);
+        }
+        pfd->lpVtbl->Release(pfd);
+        return 1;
+    }
+
+    // ---------------------------------------------------------------------------
+    // Build lpstrFilter from JSON filters array
+    // Format: "Description\0*.ext1;*.ext2\0...\0\0"
+    // ---------------------------------------------------------------------------
+    static wchar_t* zapp_build_filter_string(const char* json) {
+        // Parse the filters array from the JSON payload
+        char* filtersRaw = zapp_json_get_raw(json, "filters");
+        if (!filtersRaw || filtersRaw[0] != '[') { free(filtersRaw); return NULL; }
+
+        // Simple parser for [{"name":"X","extensions":["a","b"]}, ...]
+        // We build: Name\0*.a;*.b\0Name2\0*.c\0\0
+        static wchar_t buf[4096];
+        int pos = 0;
+        memset(buf, 0, sizeof(buf));
+
+        const char* p = filtersRaw + 1; // skip '['
+        while (*p) {
+            // Find next object
+            while (*p && *p != '{') p++;
+            if (!*p) break;
+
+            // Extract "name" value
+            const char* nameKey = strstr(p, "\"name\"");
+            char name[256] = "Files";
+            if (nameKey) {
+                nameKey = strchr(nameKey + 6, '"');
+                if (nameKey) {
+                    nameKey++;
+                    int ni = 0;
+                    while (*nameKey && *nameKey != '"' && ni < 255) name[ni++] = *nameKey++;
+                    name[ni] = '\0';
+                }
+            }
+
+            // Extract "extensions" array
+            const char* extKey = strstr(p, "\"extensions\"");
+            char extBuf[1024] = "";
+            int extPos = 0;
+            if (extKey) {
+                const char* arrStart = strchr(extKey + 12, '[');
+                if (arrStart) {
+                    arrStart++;
+                    while (*arrStart && *arrStart != ']') {
+                        if (*arrStart == '"') {
+                            arrStart++;
+                            if (extPos > 0 && extPos < 1020) extBuf[extPos++] = ';';
+                            extBuf[extPos++] = '*';
+                            extBuf[extPos++] = '.';
+                            while (*arrStart && *arrStart != '"' && extPos < 1020)
+                                extBuf[extPos++] = *arrStart++;
+                            if (*arrStart == '"') arrStart++;
+                        } else {
+                            arrStart++;
+                        }
+                    }
+                }
+            }
+            extBuf[extPos] = '\0';
+
+            if (extPos > 0) {
+                // Write name
+                int nLen = MultiByteToWideChar(CP_UTF8, 0, name, -1, buf + pos, 4096 - pos);
+                pos += nLen; // nLen includes null terminator, which acts as separator
+                // Write extensions pattern
+                int eLen = MultiByteToWideChar(CP_UTF8, 0, extBuf, -1, buf + pos, 4096 - pos);
+                pos += eLen;
+            }
+
+            // Skip to end of this object
+            int depth = 1;
+            p++;
+            while (*p && depth > 0) {
+                if (*p == '{') depth++;
+                else if (*p == '}') depth--;
+                p++;
+            }
+        }
+
+        free(filtersRaw);
+        if (pos == 0) return NULL;
+        buf[pos] = L'\0'; // double-null terminate
+        return buf;
+    }
+
+    void app_handle_dialog(App* app, char* action, char* payload_json) {
+        (void)app;
+        if (action == NULL || payload_json == NULL) return;
+        const char* json = (const char*)payload_json;
+
+        char* requestId = zapp_json_get_string(json, "requestId");
+        if (!requestId || requestId[0] == '\0') { free(requestId); return; }
+
+        if (strcmp(action, "openFile") == 0) {
+            int directory = zapp_json_get_bool(json, "directory", 0);
+            char* title = zapp_json_get_string(json, "title");
+            char* defaultPath = zapp_json_get_string(json, "defaultPath");
+
+            // --- Directory selection: use IFileDialog COM ---
+            if (directory) {
+                zapp_open_folder_dialog(title, defaultPath, requestId);
+                free(requestId);
+                if (title) free(title);
+                if (defaultPath) free(defaultPath);
+                return;
+            }
+
+            // --- File selection ---
+            int multiple = zapp_json_get_bool(json, "multiple", 0);
+
+            OPENFILENAMEW ofn;
+            wchar_t szFile[MAX_PATH * 100] = {0};
+            ZeroMemory(&ofn, sizeof(ofn));
+            ofn.lStructSize = sizeof(ofn);
+            ofn.hwndOwner = NULL;
+            ofn.lpstrFile = szFile;
+            ofn.nMaxFile = sizeof(szFile) / sizeof(szFile[0]);
+            ofn.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER;
+            if (multiple) ofn.Flags |= OFN_ALLOWMULTISELECT;
+
+            // File type filters
+            wchar_t* filterStr = zapp_build_filter_string(json);
+            if (filterStr) {
+                ofn.lpstrFilter = filterStr;
+            }
+
+            // Title
+            wchar_t wTitle[256] = {0};
+            if (title && title[0]) {
+                MultiByteToWideChar(CP_UTF8, 0, title, -1, wTitle, 256);
+                ofn.lpstrTitle = wTitle;
+            }
+
+            // Default path
+            wchar_t wDefaultPath[MAX_PATH] = {0};
+            if (defaultPath && defaultPath[0]) {
+                MultiByteToWideChar(CP_UTF8, 0, defaultPath, -1, wDefaultPath, MAX_PATH);
+                ofn.lpstrInitialDir = wDefaultPath;
+            }
+
+            if (GetOpenFileNameW(&ofn)) {
+                if (multiple) {
+                    // Multi-select: buffer is dir\0file1\0file2\0\0
+                    // Single-select: buffer is full-path\0\0
+                    // If szFile[wcslen(szFile)+1] != 0, it's multi-select format
+                    size_t dirLen = wcslen(szFile);
+                    if (szFile[dirLen + 1] != L'\0') {
+                        // Multi-select: parse dir + filenames
+                        char response[MAX_PATH * 100 + 256];
+                        int rpos = snprintf(response, sizeof(response),
+                            "{\"requestId\":\"%s\",\"ok\":true,\"paths\":[", requestId);
+                        const wchar_t* dir = szFile;
+                        const wchar_t* fname = szFile + dirLen + 1;
+                        int first = 1;
+                        while (*fname) {
+                            // Build full path: dir\fname
+                            wchar_t fullPath[MAX_PATH * 2];
+                            size_t dl = wcslen(dir);
+                            // Add backslash separator if dir doesn't end with one
+                            if (dl > 0 && dir[dl - 1] != L'\\' && dir[dl - 1] != L'/') {
+                                swprintf(fullPath, sizeof(fullPath)/sizeof(fullPath[0]),
+                                    L"%s\\%s", dir, fname);
+                            } else {
+                                swprintf(fullPath, sizeof(fullPath)/sizeof(fullPath[0]),
+                                    L"%s%s", dir, fname);
+                            }
+                            char utf8[MAX_PATH * 4];
+                            WideCharToMultiByte(CP_UTF8, 0, fullPath, -1, utf8, sizeof(utf8), NULL, NULL);
+                            char escaped[MAX_PATH * 8];
+                            zapp_json_escape_path(utf8, escaped, sizeof(escaped));
+                            rpos += snprintf(response + rpos, sizeof(response) - rpos,
+                                "%s\"%s\"", first ? "" : ",", escaped);
+                            first = 0;
+                            fname += wcslen(fname) + 1;
+                        }
+                        snprintf(response + rpos, sizeof(response) - rpos, "]}");
+                        zapp_dispatch_dialog_result(response);
+                    } else {
+                        // Single file selected even with multi-select enabled
+                        char utf8Path[MAX_PATH * 4];
+                        WideCharToMultiByte(CP_UTF8, 0, szFile, -1, utf8Path, sizeof(utf8Path), NULL, NULL);
+                        char escapedPath[MAX_PATH * 8];
+                        zapp_json_escape_path(utf8Path, escapedPath, sizeof(escapedPath));
+                        char response[MAX_PATH * 8 + 256];
+                        snprintf(response, sizeof(response),
+                            "{\"requestId\":\"%s\",\"ok\":true,\"paths\":[\"%s\"]}",
+                            requestId, escapedPath);
+                        zapp_dispatch_dialog_result(response);
+                    }
+                } else {
+                    // Single-select
+                    char utf8Path[MAX_PATH * 4];
+                    WideCharToMultiByte(CP_UTF8, 0, szFile, -1, utf8Path, sizeof(utf8Path), NULL, NULL);
+                    char escapedPath[MAX_PATH * 8];
+                    zapp_json_escape_path(utf8Path, escapedPath, sizeof(escapedPath));
+                    char response[MAX_PATH * 8 + 256];
+                    snprintf(response, sizeof(response),
+                        "{\"requestId\":\"%s\",\"ok\":true,\"paths\":[\"%s\"]}",
+                        requestId, escapedPath);
+                    zapp_dispatch_dialog_result(response);
+                }
+            } else {
+                char response[256];
+                snprintf(response, sizeof(response),
+                    "{\"requestId\":\"%s\",\"ok\":false,\"cancelled\":true}",
+                    requestId);
+                zapp_dispatch_dialog_result(response);
+            }
+            free(requestId);
+            if (title) free(title);
+            if (defaultPath) free(defaultPath);
+            return;
+        }
+
+        if (strcmp(action, "saveFile") == 0) {
+            OPENFILENAMEW ofn;
+            wchar_t szFile[MAX_PATH] = {0};
+            ZeroMemory(&ofn, sizeof(ofn));
+            ofn.lStructSize = sizeof(ofn);
+            ofn.hwndOwner = NULL;
+            ofn.lpstrFile = szFile;
+            ofn.nMaxFile = sizeof(szFile) / sizeof(szFile[0]);
+            ofn.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER;
+
+            char* defaultName = zapp_json_get_string(json, "defaultName");
+            if (defaultName && defaultName[0]) {
+                MultiByteToWideChar(CP_UTF8, 0, defaultName, -1, szFile, MAX_PATH);
+            }
+
+            char* title = zapp_json_get_string(json, "title");
+            wchar_t wTitle[256] = {0};
+            if (title && title[0]) {
+                MultiByteToWideChar(CP_UTF8, 0, title, -1, wTitle, 256);
+                ofn.lpstrTitle = wTitle;
+            }
+
+            char* defaultPath = zapp_json_get_string(json, "defaultPath");
+            wchar_t wDefaultPath[MAX_PATH] = {0};
+            if (defaultPath && defaultPath[0]) {
+                MultiByteToWideChar(CP_UTF8, 0, defaultPath, -1, wDefaultPath, MAX_PATH);
+                ofn.lpstrInitialDir = wDefaultPath;
+            }
+
+            if (GetSaveFileNameW(&ofn)) {
+                char utf8Path[MAX_PATH * 4];
+                WideCharToMultiByte(CP_UTF8, 0, szFile, -1, utf8Path, sizeof(utf8Path), NULL, NULL);
+                char escapedPath[MAX_PATH * 8];
+                zapp_json_escape_path(utf8Path, escapedPath, sizeof(escapedPath));
+                char response[MAX_PATH * 8 + 256];
+                snprintf(response, sizeof(response),
+                    "{\"requestId\":\"%s\",\"ok\":true,\"path\":\"%s\"}",
+                    requestId, escapedPath);
+                zapp_dispatch_dialog_result(response);
+            } else {
+                char response[256];
+                snprintf(response, sizeof(response),
+                    "{\"requestId\":\"%s\",\"ok\":false,\"cancelled\":true}",
+                    requestId);
+                zapp_dispatch_dialog_result(response);
+            }
+            free(requestId);
+            if (defaultName) free(defaultName);
+            if (title) free(title);
+            if (defaultPath) free(defaultPath);
+            return;
+        }
+
+        if (strcmp(action, "message") == 0) {
+            char* title = zapp_json_get_string(json, "title");
+            char* message = zapp_json_get_string(json, "message");
+            char* kind = zapp_json_get_string(json, "kind");
+            char* buttonsRaw = zapp_json_get_raw(json, "buttons");
+
+            // Parse button labels from JSON array
+            // Simple parser: find each quoted string in the array
+            wchar_t* buttonLabels[32];
+            int buttonCount = 0;
+            if (buttonsRaw && buttonsRaw[0] == '[') {
+                const char* p = buttonsRaw + 1;
+                while (*p && buttonCount < 32) {
+                    // Skip whitespace and commas
+                    while (*p == ' ' || *p == ',' || *p == '\t' || *p == '\n' || *p == '\r') p++;
+                    if (*p == ']' || *p == '\0') break;
+                    if (*p == '"') {
+                        p++; // skip opening quote
+                        const char* start = p;
+                        while (*p && *p != '"') {
+                            if (*p == '\\' && *(p+1)) p++; // skip escaped char
+                            p++;
+                        }
+                        // Extract the string between start and p
+                        int len = (int)(p - start);
+                        char* label = (char*)malloc(len + 1);
+                        memcpy(label, start, len);
+                        label[len] = '\0';
+                        // Convert to wide
+                        int wlen = MultiByteToWideChar(CP_UTF8, 0, label, -1, NULL, 0);
+                        buttonLabels[buttonCount] = (wchar_t*)malloc(wlen * sizeof(wchar_t));
+                        MultiByteToWideChar(CP_UTF8, 0, label, -1, buttonLabels[buttonCount], wlen);
+                        free(label);
+                        buttonCount++;
+                        if (*p == '"') p++; // skip closing quote
+                    }
+                }
+            }
+
+            // Fallback: if no buttons, add "OK"
+            if (buttonCount == 0) {
+                buttonLabels[0] = _wcsdup(L"OK");
+                buttonCount = 1;
+            }
+
+            // Convert title and message to wide
+            wchar_t wTitle[256] = {0};
+            wchar_t wMessage[4096] = {0};
+            if (title) MultiByteToWideChar(CP_UTF8, 0, title, -1, wTitle, 256);
+            if (message) MultiByteToWideChar(CP_UTF8, 0, message, -1, wMessage, 4096);
+
+            // Build TASKDIALOG_BUTTON array with IDs 1000 + index
+            TASKDIALOG_BUTTON* tdButtons = (TASKDIALOG_BUTTON*)calloc(buttonCount, sizeof(TASKDIALOG_BUTTON));
+            for (int i = 0; i < buttonCount; i++) {
+                tdButtons[i].nButtonID = 1000 + i;
+                tdButtons[i].pszButtonText = buttonLabels[i];
+            }
+
+            TASKDIALOGCONFIG config = {0};
+            config.cbSize = sizeof(config);
+            config.hwndParent = NULL;
+            config.dwFlags = 0;
+            config.pszWindowTitle = wTitle;
+            config.pszContent = wMessage;
+            config.cButtons = buttonCount;
+            config.pButtons = tdButtons;
+            config.nDefaultButton = 1000;
+
+            // Set icon based on kind
+            if (kind) {
+                if (strcmp(kind, "warning") == 0) {
+                    config.pszMainIcon = TD_WARNING_ICON;
+                } else if (strcmp(kind, "critical") == 0) {
+                    config.pszMainIcon = TD_ERROR_ICON;
+                } else {
+                    config.pszMainIcon = TD_INFORMATION_ICON;
+                }
+            } else {
+                config.pszMainIcon = TD_INFORMATION_ICON;
+            }
+
+            int pressedButton = 0;
+            HRESULT hr = TaskDialogIndirect(&config, &pressedButton, NULL, NULL);
+
+            int buttonIndex = 0;
+            if (SUCCEEDED(hr)) {
+                buttonIndex = pressedButton - 1000;
+                if (buttonIndex < 0 || buttonIndex >= buttonCount) buttonIndex = 0;
+            } else {
+                // Fallback to MessageBoxW if TaskDialogIndirect fails
+                UINT mbType = MB_OK | MB_ICONINFORMATION;
+                if (kind) {
+                    if (strcmp(kind, "warning") == 0) mbType = MB_OK | MB_ICONWARNING;
+                    else if (strcmp(kind, "critical") == 0) mbType = MB_OK | MB_ICONERROR;
+                }
+                MessageBoxW(NULL, wMessage, wTitle, mbType);
+                buttonIndex = 0;
+            }
+
+            // Clean up
+            for (int i = 0; i < buttonCount; i++) free(buttonLabels[i]);
+            free(tdButtons);
+
+            char response[256];
+            snprintf(response, sizeof(response),
+                "{\"requestId\":\"%s\",\"ok\":true,\"button\":%d}",
+                requestId, buttonIndex);
+            zapp_dispatch_dialog_result(response);
+
+            free(requestId);
+            if (title) free(title);
+            if (message) free(message);
+            if (kind) free(kind);
+            if (buttonsRaw) free(buttonsRaw);
+            return;
+        }
+
+        free(requestId);
+    }
+#endif
+}
+
+fn windows_window_get_size(window: void*) -> WindowSize {
+    let s = WindowSize{ width: 0, height: 0 };
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) {
+            RECT rc;
+            GetClientRect(hwnd, &rc);
+            s.width = rc.right - rc.left;
+            s.height = rc.bottom - rc.top;
+        }
+    #endif
+    }
+    return s;
+}
+
+fn windows_window_get_position(window: void*) -> WindowPosition {
+    let p = WindowPosition{ x: 0, y: 0 };
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) {
+            RECT rc;
+            GetWindowRect(hwnd, &rc);
+            p.x = rc.left;
+            p.y = rc.top;
+        }
+    #endif
+    }
+    return p;
+}
+
+fn windows_window_is_minimized(window: void*) -> bool {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) return IsIconic(hwnd) ? true : false;
+    #endif
+    }
+    return false;
+}
+
+fn windows_window_is_maximized(window: void*) -> bool {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) return IsZoomed(hwnd) ? true : false;
+    #endif
+    }
+    return false;
+}
+
+fn windows_window_is_fullscreen(window: void*) -> bool {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) {
+            LONG style = GetWindowLongW(hwnd, GWL_STYLE);
+            return !(style & WS_OVERLAPPEDWINDOW) ? true : false;
+        }
+    #endif
+    }
+    return false;
+}
+
+fn windows_window_force_close(window: void*) -> void {
+    raw {
+    #ifdef _WIN32
+        HWND hwnd = (HWND)window;
+        if (hwnd && IsWindow(hwnd)) {
+            ZappWindowEntry* entry = zapp_window_entry_for_hwnd(hwnd);
+            if (entry) entry->forceClose = TRUE;
+            PostMessageW(hwnd, WM_CLOSE, 0, 0);
+        }
+    #endif
+    }
+}
+
+fn windows_window_register_numeric_id(window: void*, numeric_id: int) -> void {
+    raw {
+    #ifdef _WIN32
+        if (window == NULL) return;
+        HWND hwnd = (HWND)window;
+        const char* existing = zapp_win_id_for_hwnd(hwnd);
+        if (existing) {
+            zapp_window_register_numeric_id_str(existing, numeric_id);
+        } else {
+            const char* regId = zapp_win_register(hwnd);
+            if (regId) {
+                zapp_window_register_numeric_id_str(regId, numeric_id);
+            }
+        }
+    #endif
+    }
+}