@zogien/native-sdk 0.11.0-fork.2 → 0.11.0-fork.3

package/build/app.zig

@@ -2017,8 +2017,14 @@ pub fn addAppArtifacts(b: *std.Build, dep: *std.Build.Dependency, app_options: A
     // on GUI exes (handles inherit; only console AUTO-allocation is
     // gated by the subsystem), so automation harnesses that pipe
     // `app.exe > log 2>&1` keep their logs either way.
+    //
+    // MSVC's CRT enters a GUI-subsystem image through WinMainCRTStartup,
+    // which calls WinMain, but Zig apps export only `main`; MinGW's startup
+    // calls `main` under either subsystem. MSVC targets therefore keep the
+    // GUI subsystem and enter through the console CRT entry instead.
     if (target.result.os.tag == .windows and app_optimize != .Debug) {
         exe.subsystem = .windows;
+        if (target.result.abi == .msvc) exe.entry = .{ .symbol_name = "mainCRTStartup" };
     }
     linkPlatform(b, dep, target, app_mod, exe, selected_platform, web_engine, web_layer, cef_dir, cef_auto_install);
     const install = b.addInstallArtifact(exe, .{});
@@ -2096,32 +2102,25 @@ pub fn addAppArtifacts(b: *std.Build, dep: *std.Build.Dependency, app_options: A
     // not just its test failures. Test builds never analyze `main` (the
     // test runner replaces the entry point), so rules that fire inside it
     // — UiApp.create's Model-defaults rule above all — used to ambush at
-    // `native build`, the LAST step in the loop. Compiling this object
-    // forces full semantic analysis of the app module, entry point
-    // included; nothing links or runs.
-    const analysis_root = b.addWriteFiles().add("app_analysis.zig",
-        \\//! Generated by the app build: force semantic analysis of the
-        \\//! app's entry point at test time. Exactly `main`, transitively —
-        \\//! the same surface `native build` analyzes — so test-time can
-        \\//! never be stricter than the build it fronts.
-        \\comptime {
-        \\    const app = @import("app");
-        \\    if (@hasDecl(app, "main")) _ = &app.main;
-        \\}
-        \\
-    );
-    const analysis_mod = b.createModule(.{
-        .root_source_file = analysis_root,
-        .target = target,
-        .optimize = optimize,
-    });
-    analysis_mod.addImport("app", test_app_mod);
-    const analysis_obj = b.addObject(.{
+    // `native build`, the LAST step in the loop. This executable roots at
+    // the test app module itself, so std.start analyzes `main` exactly as
+    // the app's own entry build does: root-level decls, the body, and the
+    // entry signature. Test time is therefore never stricter, nor laxer,
+    // than the build it fronts. Nothing requests its binary, so Zig
+    // compiles it with -fno-emit-bin: nothing links or runs, and nothing
+    // may ever install it or ask for its emitted bin.
+    //
+    // It must stay an executable. Zig refuses any COFF object compile with
+    // more than one object, archive, or C input, -fno-emit-bin included,
+    // and Windows app modules routinely carry several: the compiled core
+    // archive beside the Debug markup data object, the platform hosts'
+    // C++ sources, and MSVC system import libraries.
+    const entry_analysis = b.addExecutable(.{
         .name = b.fmt("{s}-analysis", .{app_options.name}),
-        .root_module = analysis_mod,
+        .root_module = test_app_mod,
         .use_llvm = useLlvmWorkaround(target),
     });
-    test_step.dependOn(&analysis_obj.step);
+    test_step.dependOn(&entry_analysis.step);
 
     // `zig build model-contract`: reflect the app's Model/Msg into
     // zig-out/model-contract.zon so `native check` can verify markup
@@ -2314,6 +2313,9 @@ fn appModule(b: *std.Build, dep: *std.Build.Dependency, target: std.Build.Resolv
         if (link_ts_archives) {
             if (stage.service_archive) |service_archive| app_mod.addObjectFile(service_archive);
         }
+        if (link_ts_archives and target.result.os.tag == .windows and target.result.abi == .msvc) {
+            linkScriptcMsvcRuntime(dep, app_mod);
+        }
     }
     if (app_config.sqlite_capability) {
         // `store` and the relational `sqlite` tier share this exact object.
@@ -2331,6 +2333,25 @@ fn appModule(b: *std.Build, dep: *std.Build.Dependency, target: std.Build.Resolv
     return app_mod;
 }
 
+/// The Windows libraries scriptc's runtime pack declares (runtime-pack.json
+/// system_libraries; bcrypt and crypt32 back its TLS). An unused import
+/// library adds no DLL dependency, so they are linked unconditionally.
+const scriptc_windows_system_libraries = [_][]const u8{ "advapi32", "iphlpapi", "ws2_32", "bcrypt", "crypt32" };
+
+/// The pinned scriptc builds its Windows runtime against Zig's MinGW sysroot,
+/// and an MSVC image links the static UCRT without MinGW's default libraries.
+/// Restate what MinGW would have supplied on the module that carries the core
+/// and service archives, so the app exe and every test-side artifact that
+/// imports it (unit tests, model contract, test host) link alike: the pack's
+/// system libraries, MSVC's oldnames.lib for the POSIX names (open, read,
+/// close, ...), and scriptc_mingw_compat.c for the rest of MinGW's startup
+/// and CRT layer (running the runtime's .ctors constructors above all).
+fn linkScriptcMsvcRuntime(dep: *std.Build.Dependency, mod: *std.Build.Module) void {
+    for (scriptc_windows_system_libraries) |name| mod.linkSystemLibrary(name, .{});
+    mod.linkSystemLibrary("oldnames", .{});
+    mod.addCSourceFile(.{ .file = dep.path("src/platform/windows/scriptc_mingw_compat.c"), .flags = &.{} });
+}
+
 /// Compile primary markup bytes independently from the Zig app graph. The
 /// final artifact sees this as an object-file input, so a markup edit dirties
 /// only this tiny C compile and the final link.

package/native-sdk.d.ts

@@ -32,6 +32,8 @@ export interface NativeSdkWindowInfo {
   width: number;
   height: number;
   scale: number;
+  /** Maximized, whoever changed it; `window.zero.on("window:state", ...)` reports each change. */
+  maximized: boolean;
 }
 
 export type NativeSdkWindowTitlebarStyle =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zogien/native-sdk",
-  "version": "0.11.0-fork.2",
+  "version": "0.11.0-fork.3",
   "description": "Community-maintained fork of Native SDK: TypeScript, Native markup, and native desktop tooling",
   "type": "module",
   "engines": {
@@ -41,14 +41,14 @@
     "tar": "7.5.22"
   },
   "optionalDependencies": {
-    "@zogien/native-sdk-darwin-arm64": "0.11.0-fork.2",
-    "@zogien/native-sdk-darwin-x64": "0.11.0-fork.2",
-    "@zogien/native-sdk-linux-arm64-gnu": "0.11.0-fork.2",
-    "@zogien/native-sdk-linux-arm64-musl": "0.11.0-fork.2",
-    "@zogien/native-sdk-linux-x64-gnu": "0.11.0-fork.2",
-    "@zogien/native-sdk-linux-x64-musl": "0.11.0-fork.2",
-    "@zogien/native-sdk-win32-arm64": "0.11.0-fork.2",
-    "@zogien/native-sdk-win32-x64": "0.11.0-fork.2"
+    "@zogien/native-sdk-darwin-arm64": "0.11.0-fork.3",
+    "@zogien/native-sdk-darwin-x64": "0.11.0-fork.3",
+    "@zogien/native-sdk-linux-arm64-gnu": "0.11.0-fork.3",
+    "@zogien/native-sdk-linux-arm64-musl": "0.11.0-fork.3",
+    "@zogien/native-sdk-linux-x64-gnu": "0.11.0-fork.3",
+    "@zogien/native-sdk-linux-x64-musl": "0.11.0-fork.3",
+    "@zogien/native-sdk-win32-arm64": "0.11.0-fork.3",
+    "@zogien/native-sdk-win32-x64": "0.11.0-fork.3"
   },
   "repository": {
     "type": "git",

package/packages/core/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@native-sdk/core",
-  "version": "0.11.0-fork.2",
+  "version": "0.11.0-fork.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@native-sdk/core",
-      "version": "0.11.0-fork.2",
+      "version": "0.11.0-fork.3",
       "hasInstallScript": true,
       "dependencies": {
         "@scriptc/types": "0.3.0",

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@native-sdk/core",
-  "version": "0.11.0-fork.2",
+  "version": "0.11.0-fork.3",
   "description": "The TypeScript authoring tier: the app-core subset, its checker and contract frontend, the exact-pinned core compiler dependency, and the SDK module cores import",
   "repository": {
     "type": "git",

package/src/platform/null_platform.zig

@@ -448,6 +448,11 @@ pub const NullPlatform = struct {
     /// real hosts' close delegates, hiding instead of closing under
     /// `.hide`.
     window_close_policy: [max_windows]types.WindowClosePolicy = [_]types.WindowClosePolicy{.quit} ** max_windows,
+    /// Close requests (`request_close_window_fn`) not yet handled, oldest
+    /// first. The Windows host posts WM_CLOSE, so a requested close
+    /// resolves on a later loop turn; `takeQueuedCloseRequest` models it.
+    queued_close_requests: [max_windows]WindowId = [_]WindowId{0} ** max_windows,
+    queued_close_request_count: usize = 0,
     /// Test seam: refuse one OS create without retaining a window identity.
     fail_next_create_window: bool = false,
     /// Test seam: make the NEXT `close_window_fn` call fail with
@@ -918,6 +923,9 @@ pub const NullPlatform = struct {
                 .focus_window_fn = focusWindow,
                 .close_window_fn = closeWindow,
                 .minimize_window_fn = minimizeWindow,
+                .maximize_window_fn = maximizeWindow,
+                .unmaximize_window_fn = unmaximizeWindow,
+                .request_close_window_fn = requestCloseWindow,
                 .hide_window_fn = hideWindow,
                 .show_window_fn = showWindow,
                 .set_dock_presence_fn = setDockPresence,
@@ -1319,6 +1327,36 @@ pub const NullPlatform = struct {
         self.window_occluded[index] = true;
     }
 
+    /// The modeled maximize: the refusals the Windows host makes, then the
+    /// state flip its WM_SIZE handler reports. `windowFrameEvent` hands a
+    /// test the frame event that report carries.
+    fn maximizeWindow(context: ?*anyopaque, window_id: WindowId) anyerror!void {
+        const self: *NullPlatform = @ptrCast(@alignCast(context.?));
+        const index = self.findWindowIndex(window_id) orelse return error.WindowNotFound;
+        if (!self.windows[index].open) return error.WindowNotFound;
+        if (!self.window_resizable[index]) return error.WindowNotResizable;
+        if (self.windows[index].hidden or !self.window_visible[index]) return error.WindowHidden;
+        self.windows[index].maximized = true;
+    }
+
+    fn unmaximizeWindow(context: ?*anyopaque, window_id: WindowId) anyerror!void {
+        const self: *NullPlatform = @ptrCast(@alignCast(context.?));
+        const index = self.findWindowIndex(window_id) orelse return error.WindowNotFound;
+        if (!self.windows[index].open) return error.WindowNotFound;
+        if (!self.windows[index].maximized) return;
+        if (self.windows[index].hidden or !self.window_visible[index]) return error.WindowHidden;
+        self.windows[index].maximized = false;
+    }
+
+    fn requestCloseWindow(context: ?*anyopaque, window_id: WindowId) anyerror!void {
+        const self: *NullPlatform = @ptrCast(@alignCast(context.?));
+        const index = self.findWindowIndex(window_id) orelse return error.WindowNotFound;
+        if (!self.windows[index].open) return error.WindowNotFound;
+        if (self.queued_close_request_count >= self.queued_close_requests.len) return error.WindowLimitReached;
+        self.queued_close_requests[self.queued_close_request_count] = window_id;
+        self.queued_close_request_count += 1;
+    }
+
     fn showWindow(context: ?*anyopaque, window_id: WindowId) anyerror!void {
         const self: *NullPlatform = @ptrCast(@alignCast(context.?));
         if (self.fail_next_show_window) {
@@ -2928,6 +2966,7 @@ pub const NullPlatform = struct {
                 .open = true,
                 .focused = false,
                 .hidden = true,
+                .maximized = info.maximized,
             } };
         }
         const info = self.windows[index];
@@ -2945,6 +2984,33 @@ pub const NullPlatform = struct {
         } };
     }
 
+    /// Test seam: drain the oldest queued close request, the modeled loop
+    /// turn on which the host handles its posted WM_CLOSE. It resolves
+    /// exactly like `userCloseWindow` (close_policy decides); dispatch the
+    /// returned event through the runtime. Null while nothing is queued,
+    /// or when the window closed before its turn (a WM_CLOSE posted to a
+    /// destroyed window is never delivered).
+    pub fn takeQueuedCloseRequest(self: *NullPlatform) ?Event {
+        if (self.queued_close_request_count == 0) return null;
+        const window_id = self.queued_close_requests[0];
+        var cursor: usize = 0;
+        while (cursor + 1 < self.queued_close_request_count) : (cursor += 1) {
+            self.queued_close_requests[cursor] = self.queued_close_requests[cursor + 1];
+        }
+        self.queued_close_request_count -= 1;
+        const index = self.findWindowIndex(window_id) orelse return null;
+        if (!self.windows[index].open) return null;
+        return self.userCloseWindow(window_id);
+    }
+
+    /// Test seam: the frame event for a window's current modeled state,
+    /// `maximized` included: what the Windows host emits when a maximize
+    /// or restore lands. Null for an unknown window.
+    pub fn windowFrameEvent(self: *const NullPlatform, window_id: WindowId) ?Event {
+        const index = self.findWindowIndex(window_id) orelse return null;
+        return .{ .window_frame_changed = self.windows[index].state() };
+    }
+
     /// Test seam: the user asked the app to come back with no window on
     /// the glass (the macOS Dock-icon reopen). Models the host's
     /// `applicationShouldHandleReopen:` — every window hidden by its

package/src/platform/types.zig

@@ -718,6 +718,10 @@ pub const WindowInfo = struct {
     focused: bool = false,
     /// Alive but policy-hidden — see `WindowState.hidden`.
     hidden: bool = false,
+    /// Maximized as last reported by the host's frame event, whichever
+    /// path changed it (app call, caption double-click, system menu,
+    /// keyboard shortcut). Hosts that do not report it leave it false.
+    maximized: bool = false,
 
     pub fn state(self: WindowInfo) WindowState {
         return .{
@@ -729,6 +733,7 @@ pub const WindowInfo = struct {
             .open = self.open,
             .focused = self.focused,
             .hidden = self.hidden,
+            .maximized = self.maximized,
         };
     }
 };
@@ -2708,6 +2713,23 @@ pub const PlatformServices = struct {
     /// controls — chromeless windows have no system button to click.
     /// Platforms without the concept leave this null.
     minimize_window_fn: ?*const fn (context: ?*anyopaque, window_id: WindowId) anyerror!void = null,
+    /// The OS maximize and restore-from-maximized verbs for app-drawn
+    /// window controls (Windows `SW_MAXIMIZE`/`SW_RESTORE`). Hosts refuse
+    /// a non-resizable window (`error.WindowNotResizable`, the system has
+    /// no maximize affordance for it) and a window that is not on the
+    /// glass (`error.WindowHidden`). Unmaximizing a window that is not
+    /// maximized succeeds without effect. The resulting state arrives on
+    /// the window's frame event (`WindowState.maximized`). Platforms
+    /// without the verbs leave these null.
+    maximize_window_fn: ?*const fn (context: ?*anyopaque, window_id: WindowId) anyerror!void = null,
+    unmaximize_window_fn: ?*const fn (context: ?*anyopaque, window_id: WindowId) anyerror!void = null,
+    /// Ask the window to close the way the user's close button does
+    /// (Windows posts `WM_CLOSE`), so `close_policy` decides between
+    /// hiding and closing. Unlike `close_window_fn` this only queues the
+    /// request: the outcome arrives later as the host's ordinary frame
+    /// events, exactly like a user close. Platforms without the verb
+    /// leave this null.
+    request_close_window_fn: ?*const fn (context: ?*anyopaque, window_id: WindowId) anyerror!void = null,
     /// Keep a live window and all of its views, but order it off the
     /// glass. The runtime marks `WindowInfo.hidden` while it is out;
     /// `show_window_fn` is the inverse. Platforms without a reliable
@@ -3167,6 +3189,21 @@ pub const PlatformServices = struct {
         return minimize_fn(self.context, window_id);
     }
 
+    pub fn maximizeWindow(self: PlatformServices, window_id: WindowId) anyerror!void {
+        const maximize_fn = self.maximize_window_fn orelse return error.UnsupportedService;
+        return maximize_fn(self.context, window_id);
+    }
+
+    pub fn unmaximizeWindow(self: PlatformServices, window_id: WindowId) anyerror!void {
+        const unmaximize_fn = self.unmaximize_window_fn orelse return error.UnsupportedService;
+        return unmaximize_fn(self.context, window_id);
+    }
+
+    pub fn requestCloseWindow(self: PlatformServices, window_id: WindowId) anyerror!void {
+        const request_fn = self.request_close_window_fn orelse return error.UnsupportedService;
+        return request_fn(self.context, window_id);
+    }
+
     pub fn hideWindow(self: PlatformServices, window_id: WindowId) anyerror!void {
         const hide_fn = self.hide_window_fn orelse return error.UnsupportedService;
         return hide_fn(self.context, window_id);

package/src/platform/windows/root.zig

@@ -125,6 +125,9 @@ const WindowsEvent = extern struct {
     /// selection).
     widget_id: u64,
     menu_item_id: u32,
+    /// Window events: nonzero while the window is maximized. Every emit
+    /// carries the live value, so any frame event reports it.
+    maximized: c_int,
 };
 
 const WindowsCallback = *const fn (context: ?*anyopaque, event: *const WindowsEvent) callconv(.c) void;
@@ -166,6 +169,9 @@ extern fn native_sdk_windows_minimize_window(host: *WindowsHost, window_id: u64)
 extern fn native_sdk_windows_hide_window(host: *WindowsHost, window_id: u64) c_int;
 extern fn native_sdk_windows_show_window(host: *WindowsHost, window_id: u64) c_int;
 extern fn native_sdk_windows_set_window_close_policy(host: *WindowsHost, window_id: u64, close_policy: c_int) c_int;
+extern fn native_sdk_windows_maximize_window(host: *WindowsHost, window_id: u64) c_int;
+extern fn native_sdk_windows_unmaximize_window(host: *WindowsHost, window_id: u64) c_int;
+extern fn native_sdk_windows_request_close_window(host: *WindowsHost, window_id: u64) c_int;
 extern fn native_sdk_windows_create_view(host: *WindowsHost, window_id: u64, label: [*]const u8, label_len: usize, kind: c_int, gpu_backend_request: c_int, parent: [*]const u8, parent_len: usize, x: f64, y: f64, width: f64, height: f64, layer: c_int, visible: c_int, enabled: c_int, role: [*]const u8, role_len: usize, accessibility_label: [*]const u8, accessibility_label_len: usize, text: [*]const u8, text_len: usize, command: [*]const u8, command_len: usize) c_int;
 extern fn native_sdk_windows_update_view(host: *WindowsHost, window_id: u64, label: [*]const u8, label_len: usize, has_frame: c_int, x: f64, y: f64, width: f64, height: f64, has_layer: c_int, layer: c_int, has_visible: c_int, visible: c_int, has_enabled: c_int, enabled: c_int, has_role: c_int, role: [*]const u8, role_len: usize, has_accessibility_label: c_int, accessibility_label: [*]const u8, accessibility_label_len: usize, has_text: c_int, text: [*]const u8, text_len: usize, has_command: c_int, command: [*]const u8, command_len: usize) c_int;
 extern fn native_sdk_windows_set_view_frame(host: *WindowsHost, window_id: u64, label: [*]const u8, label_len: usize, x: f64, y: f64, width: f64, height: f64) c_int;
@@ -438,6 +444,9 @@ pub const WindowsPlatform = struct {
                 .focus_window_fn = focusWindow,
                 .close_window_fn = closeWindow,
                 .minimize_window_fn = minimizeWindow,
+                .maximize_window_fn = maximizeWindow,
+                .unmaximize_window_fn = unmaximizeWindow,
+                .request_close_window_fn = requestCloseWindow,
                 .hide_window_fn = hideWindow,
                 .show_window_fn = showWindow,
                 .quit_app_fn = quitApp,
@@ -658,6 +667,7 @@ fn windowsCallback(context: ?*anyopaque, event: *const WindowsEvent) callconv(.c
                 .open = event.open != 0,
                 .focused = event.focused != 0,
                 .hidden = event.hidden != 0,
+                .maximized = event.maximized != 0,
             } });
         },
         .view_focused => state.emit(.{ .view_focused = .{
@@ -1036,6 +1046,36 @@ fn minimizeWindow(context: ?*anyopaque, window_id: platform_mod.WindowId) anyerr
     if (native_sdk_windows_minimize_window(self.host, window_id) == 0) return error.WindowNotFound;
 }
 
+fn maximizeWindow(context: ?*anyopaque, window_id: platform_mod.WindowId) anyerror!void {
+    const self: *WindowsPlatform = @ptrCast(@alignCast(context.?));
+    return windowControlResult(native_sdk_windows_maximize_window(self.host, window_id));
+}
+
+fn unmaximizeWindow(context: ?*anyopaque, window_id: platform_mod.WindowId) anyerror!void {
+    const self: *WindowsPlatform = @ptrCast(@alignCast(context.?));
+    return windowControlResult(native_sdk_windows_unmaximize_window(self.host, window_id));
+}
+
+fn requestCloseWindow(context: ?*anyopaque, window_id: platform_mod.WindowId) anyerror!void {
+    const self: *WindowsPlatform = @ptrCast(@alignCast(context.?));
+    return switch (native_sdk_windows_request_close_window(self.host, window_id)) {
+        1 => {},
+        0 => error.WindowNotFound,
+        else => error.CloseFailed,
+    };
+}
+
+/// The maximize/unmaximize host status codes (see webview2_host.cpp).
+fn windowControlResult(status: c_int) anyerror!void {
+    return switch (status) {
+        1 => {},
+        0 => error.WindowNotFound,
+        -1 => error.WindowNotResizable,
+        -2 => error.WindowHidden,
+        else => error.Unexpected,
+    };
+}
+
 fn hideWindow(context: ?*anyopaque, window_id: platform_mod.WindowId) anyerror!void {
     const self: *WindowsPlatform = @ptrCast(@alignCast(context.?));
     if (native_sdk_windows_hide_window(self.host, window_id) == 0) return error.WindowNotFound;
@@ -2760,3 +2800,100 @@ fn flattenFilters(filters: []const platform_mod.FileFilter, buffer: []u8) []cons
 test "windows platform module exports type" {
     _ = WindowsPlatform;
 }
+
+test "windows event declares the same fields in the same order as the C host" {
+    // WindowsEvent is written twice, here and in webview2_host.cpp, and
+    // crosses the C ABI by layout. A field added on one side only, or at
+    // a different position, shifts every later field without a compile
+    // error, so the two declarations are compared by name and order.
+    const field_names = comptime blk: {
+        const fields = @typeInfo(WindowsEvent).@"struct".fields;
+        var names: [fields.len][]const u8 = undefined;
+        for (fields, 0..) |field, index| names[index] = field.name;
+        break :blk names;
+    };
+    const host_source = @embedFile("webview2_host.cpp");
+    const header = "struct WindowsEvent {";
+    const start = (std.mem.indexOf(u8, host_source, header) orelse return error.TestExpectedEqual) + header.len;
+    const end = std.mem.indexOfPos(u8, host_source, start, "};") orelse return error.TestExpectedEqual;
+    var lines = std.mem.splitScalar(u8, host_source[start..end], '\n');
+    var count: usize = 0;
+    var in_comment = false;
+    while (lines.next()) |raw| {
+        const line = std.mem.trim(u8, raw, " \t\r");
+        if (in_comment) {
+            if (std.mem.indexOf(u8, line, "*/") != null) in_comment = false;
+            continue;
+        }
+        if (std.mem.startsWith(u8, line, "/*")) {
+            if (std.mem.indexOf(u8, line, "*/") == null) in_comment = true;
+            continue;
+        }
+        if (!std.mem.endsWith(u8, line, ";")) continue;
+        var declaration = line[0 .. line.len - 1];
+        if (std.mem.indexOfScalar(u8, declaration, '[')) |bracket| declaration = declaration[0..bracket];
+        const name_start = (std.mem.lastIndexOfAny(u8, declaration, " *") orelse return error.TestExpectedEqual) + 1;
+        try std.testing.expect(count < field_names.len);
+        try std.testing.expectEqualStrings(field_names[count], declaration[name_start..]);
+        count += 1;
+    }
+    try std.testing.expectEqual(field_names.len, count);
+}
+
+/// One exported host function's source: from `start` up to the next
+/// exported `native_sdk_windows_` definition.
+fn hostFunction(host_source: []const u8, start: usize) ?[]const u8 {
+    const end = std.mem.indexOfPos(u8, host_source, start + 1, "int native_sdk_windows_") orelse return null;
+    return host_source[start..end];
+}
+
+test "windows maximize status codes map to explicit errors" {
+    try windowControlResult(1);
+    try std.testing.expectError(error.WindowNotFound, windowControlResult(0));
+    try std.testing.expectError(error.WindowNotResizable, windowControlResult(-1));
+    try std.testing.expectError(error.WindowHidden, windowControlResult(-2));
+}
+
+test "windows maximize refuses what the system would not maximize and reports every transition" {
+    // The host verbs are C++ this suite cannot execute; pin their shape
+    // textually, like the WM_CLOSE hook test above.
+    const host_source = @embedFile("webview2_host.cpp");
+    const maximize_at = std.mem.indexOf(u8, host_source, "int native_sdk_windows_maximize_window(") orelse return error.TestExpectedEqual;
+    const maximize_fn = hostFunction(host_source, maximize_at) orelse return error.TestExpectedEqual;
+    const resizable_at = std.mem.indexOf(u8, maximize_fn, "if (!found->second.resizable) return -1;") orelse return error.TestExpectedEqual;
+    const visible_at = std.mem.indexOf(u8, maximize_fn, "if (!IsWindowVisible(found->second.hwnd)) return -2;") orelse return error.TestExpectedEqual;
+    const show_at = std.mem.indexOf(u8, maximize_fn, "ShowWindow(found->second.hwnd, SW_MAXIMIZE);") orelse return error.TestExpectedEqual;
+    try std.testing.expect(resizable_at < show_at and visible_at < show_at);
+
+    // Every frame event carries the live state, and the top-level window
+    // procedure's WM_SIZE reports each transition, whoever caused it.
+    try std.testing.expect(std.mem.indexOf(u8, host_source, "event.maximized = window.hwnd && IsZoomed(window.hwnd) ? 1 : 0;") != null);
+    const proc_at = std.mem.indexOf(u8, host_source, "static LRESULT CALLBACK windowProc(") orelse return error.TestExpectedEqual;
+    const size_at = std.mem.indexOfPos(u8, host_source, proc_at, "case WM_SIZE:") orelse return error.TestExpectedEqual;
+    const next_case_at = std.mem.indexOfPos(u8, host_source, size_at, "case WM_SETFOCUS:") orelse return error.TestExpectedEqual;
+    try std.testing.expect(std.mem.indexOf(u8, host_source[size_at..next_case_at], "emitMaximizedTransition(host, hwnd);") != null);
+
+    // A maximized chromeless window keeps the taskbar visible: without
+    // a caption the system would size it to the whole monitor. The
+    // min/max answer sets the size, and the position change re-derives
+    // it from the monitor the window lands on, which the min/max answer
+    // alone can get wrong on a secondary monitor larger than the primary.
+    const minmax_at = std.mem.indexOfPos(u8, host_source, proc_at, "case WM_GETMINMAXINFO:") orelse return error.TestExpectedEqual;
+    try std.testing.expect(std.mem.startsWith(u8, std.mem.trimStart(u8, host_source[minmax_at + "case WM_GETMINMAXINFO:".len ..], " \t\r\n"), "applyChromelessMaximizedBounds(host, hwnd, reinterpret_cast<MINMAXINFO *>(lparam));"));
+    const changing_at = std.mem.indexOfPos(u8, host_source, proc_at, "case WM_WINDOWPOSCHANGING:") orelse return error.TestExpectedEqual;
+    try std.testing.expect(std.mem.startsWith(u8, std.mem.trimStart(u8, host_source[changing_at + "case WM_WINDOWPOSCHANGING:".len ..], " \t\r\n"), "clampChromelessMaximizedFrame(host, hwnd, reinterpret_cast<WINDOWPOS *>(lparam));"));
+}
+
+test "windows close request posts the user's WM_CLOSE while the app's close stays direct" {
+    const host_source = @embedFile("webview2_host.cpp");
+    const request_at = std.mem.indexOf(u8, host_source, "int native_sdk_windows_request_close_window(") orelse return error.TestExpectedEqual;
+    const request_fn = hostFunction(host_source, request_at) orelse return error.TestExpectedEqual;
+    try std.testing.expect(std.mem.indexOf(u8, request_fn, "PostMessageW(found->second.hwnd, WM_CLOSE, 0, 0)") != null);
+    try std.testing.expect(std.mem.indexOf(u8, request_fn, "DestroyWindow") == null);
+
+    // The app's own close keeps bypassing the WM_CLOSE close-policy hook.
+    const close_at = std.mem.indexOf(u8, host_source, "int native_sdk_windows_close_window(") orelse return error.TestExpectedEqual;
+    const close_fn = hostFunction(host_source, close_at) orelse return error.TestExpectedEqual;
+    try std.testing.expect(std.mem.indexOf(u8, close_fn, "DestroyWindow(found->second.hwnd);") != null);
+    try std.testing.expect(std.mem.indexOf(u8, close_fn, "WM_CLOSE") == null);
+}

package/src/platform/windows/scriptc_mingw_compat.c

@@ -0,0 +1,248 @@
+/* MinGW startup and CRT pieces for scriptc's Windows runtime on MSVC targets.
+ *
+ * The pinned scriptc builds its Windows runtime pack against Zig's MinGW
+ * sysroot (packages/runtime-win32-x64-msvc/scripts/build.mjs passes
+ * -target x86_64-windows-gnu). The runtime is already Win32-native for
+ * threads, child processes and its event loop; what remains is what MinGW
+ * layers over the UCRT. The MSVC build links the same UCRT statically, so
+ * this file restates exactly that, with the MinGW behaviour the runtime was
+ * compiled against: running its .ctors constructors, the dllimport slots for
+ * UCRT functions, stat64i32, the ___chkstk_ms stack probe, and <dirent.h>.
+ * POSIX names such as open/read/close come from MSVC's oldnames.lib instead.
+ *
+ * Delete this file once scriptc ships a runtime pack built for the MSVC CRT.
+ */
+
+/* The import slots below only take the address of the UCRT's "insecure"
+ * functions (_wfopen, _wopen); nothing here calls them. */
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <ctype.h>
+#include <errno.h>
+#include <io.h>
+#include <process.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/utime.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+/* clang places a MinGW object's __attribute__((constructor)) functions in
+ * .ctors, which only MinGW's startup runs; the MSVC CRT runs .CRT$XCU. The
+ * runtime initializes state that way (scr_json.c's small-int table, for one),
+ * so walk this image's .ctors from a .CRT$XCU initializer, back to front as
+ * MinGW's __do_global_ctors does, skipping its 0/-1 list markers. */
+typedef void (*scriptc_ctor_fn)(void);
+extern IMAGE_DOS_HEADER __ImageBase;
+
+static void __cdecl scriptc_run_mingw_ctors(void) {
+  const char *base = (const char *)&__ImageBase;
+  const IMAGE_NT_HEADERS *nt = (const IMAGE_NT_HEADERS *)(base + __ImageBase.e_lfanew);
+  const IMAGE_SECTION_HEADER *section = IMAGE_FIRST_SECTION(nt);
+  for (WORD index = 0; index < nt->FileHeader.NumberOfSections; index++, section++) {
+    if (memcmp(section->Name, ".ctors\0\0", IMAGE_SIZEOF_SHORT_NAME) != 0) continue;
+    scriptc_ctor_fn *begin = (scriptc_ctor_fn *)(base + section->VirtualAddress);
+    scriptc_ctor_fn *end = begin + section->Misc.VirtualSize / sizeof(scriptc_ctor_fn);
+    while (end > begin) {
+      scriptc_ctor_fn ctor = *--end;
+      if (ctor && ctor != (scriptc_ctor_fn)(intptr_t)-1) ctor();
+    }
+  }
+}
+
+__attribute__((section(".CRT$XCU"), used)) static void(__cdecl *const scriptc_mingw_ctors)(void) =
+    scriptc_run_mingw_ctors;
+
+/* MinGW's headers declare UCRT functions dllimport, so the runtime calls them
+ * through __imp_ slots that the static UCRT does not define. lld would bind
+ * most of them to the static definitions anyway, but with one LNK4217 warning
+ * each (and tolower not at all), so define every slot the runtime pack's
+ * library objects reference. A slot added by a future pack shows up as an
+ * undefined symbol or a new LNK4217 warning in the MSVC link. */
+#define SCRIPTC_UCRT_IMPORT(name) __typeof__(&name) const __imp_##name = &name;
+/* The UCRT exports _assert, but its <assert.h> declares only _wassert. */
+void __cdecl _assert(const char *message, const char *file, unsigned line);
+SCRIPTC_UCRT_IMPORT(__acrt_iob_func)
+SCRIPTC_UCRT_IMPORT(_assert)
+SCRIPTC_UCRT_IMPORT(_chsize_s)
+SCRIPTC_UCRT_IMPORT(_commit)
+SCRIPTC_UCRT_IMPORT(_errno)
+SCRIPTC_UCRT_IMPORT(_fstat64)
+SCRIPTC_UCRT_IMPORT(_fullpath)
+SCRIPTC_UCRT_IMPORT(_get_osfhandle)
+SCRIPTC_UCRT_IMPORT(_getpid)
+SCRIPTC_UCRT_IMPORT(_stricmp)
+SCRIPTC_UCRT_IMPORT(_umask_s)
+SCRIPTC_UCRT_IMPORT(_utime64)
+SCRIPTC_UCRT_IMPORT(_wfopen)
+SCRIPTC_UCRT_IMPORT(_wopen)
+SCRIPTC_UCRT_IMPORT(tolower)
+
+/* MinGW-UCRT aliases stat64i32 to the UCRT's _stat64i32. */
+int __cdecl stat64i32(const char *path, struct _stat64i32 *buf) {
+  return _stat64i32(path, buf);
+}
+
+/* MinGW's stack probe: rax holds the frame size; touch every page below the
+ * caller's stack pointer without moving it, preserving all registers. */
+__attribute__((naked)) void ___chkstk_ms(void) {
+  __asm__ volatile(
+      "pushq %rcx\n\t"
+      "pushq %rax\n\t"
+      "cmpq $0x1000, %rax\n\t"
+      "leaq 24(%rsp), %rcx\n\t"
+      "jb 1f\n"
+      "2:\n\t"
+      "subq $0x1000, %rcx\n\t"
+      "testq %rcx, (%rcx)\n\t"
+      "subq $0x1000, %rax\n\t"
+      "cmpq $0x1000, %rax\n\t"
+      "ja 2b\n"
+      "1:\n\t"
+      "subq %rax, %rcx\n\t"
+      "testq %rcx, (%rcx)\n\t"
+      "popq %rax\n\t"
+      "popq %rcx\n\t"
+      "retq");
+}
+
+/* <dirent.h>, ported from mingw-w64's public-domain misc/dirent.c (char
+ * variant). struct dirent and DIR keep mingw-w64's layout because the
+ * runtime was compiled against its header. */
+
+struct dirent {
+  long d_ino;
+  unsigned short d_reclen;
+  unsigned short d_namlen;
+  char d_name[260];
+};
+
+typedef struct {
+  struct _finddata_t dd_dta;
+  struct dirent dd_dir;
+  intptr_t dd_handle;
+  int dd_stat;
+  char dd_name[1];
+} DIR;
+
+DIR *__cdecl opendir(const char *path) {
+  errno = 0;
+  if (!path) {
+    errno = EFAULT;
+    return NULL;
+  }
+  if (path[0] == '\0') {
+    errno = ENOTDIR;
+    return NULL;
+  }
+  DWORD attributes = GetFileAttributesA(path);
+  if (attributes == INVALID_FILE_ATTRIBUTES) {
+    errno = ENOENT;
+    return NULL;
+  }
+  if (!(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+    errno = ENOTDIR;
+    return NULL;
+  }
+  char full[MAX_PATH];
+  if (!_fullpath(full, path, MAX_PATH)) return NULL;
+  size_t len = strlen(full);
+  /* The search pattern: the absolute path, a separator, "*", and NUL. */
+  DIR *dir = malloc(sizeof(DIR) + len + 3);
+  if (!dir) {
+    errno = ENOMEM;
+    return NULL;
+  }
+  memcpy(dir->dd_name, full, len);
+  if (len > 0 && full[len - 1] != '/' && full[len - 1] != '\\') dir->dd_name[len++] = '\\';
+  dir->dd_name[len++] = '*';
+  dir->dd_name[len] = '\0';
+  dir->dd_handle = -1;
+  dir->dd_stat = 0;
+  dir->dd_dir.d_ino = 0;
+  dir->dd_dir.d_reclen = 0;
+  dir->dd_dir.d_namlen = 0;
+  memset(dir->dd_dir.d_name, 0, sizeof(dir->dd_dir.d_name));
+  return dir;
+}
+
+struct dirent *__cdecl readdir(DIR *dir) {
+  errno = 0;
+  if (!dir) {
+    errno = EFAULT;
+    return NULL;
+  }
+  if (dir->dd_stat < 0) return NULL;
+  if (dir->dd_stat == 0) {
+    dir->dd_handle = _findfirst(dir->dd_name, &dir->dd_dta);
+    dir->dd_stat = dir->dd_handle == -1 ? -1 : 1;
+  } else if (_findnext(dir->dd_handle, &dir->dd_dta)) {
+    /* _findnext reports the end as ENOENT; the end is not an error. */
+    if (GetLastError() == ERROR_NO_MORE_FILES) errno = 0;
+    _findclose(dir->dd_handle);
+    dir->dd_handle = -1;
+    dir->dd_stat = -1;
+  } else {
+    dir->dd_stat++;
+  }
+  if (dir->dd_stat <= 0) return NULL;
+  /* Both buffers are MAX_PATH chars, so the name and its NUL always fit. */
+  size_t len = strlen(dir->dd_dta.name);
+  dir->dd_dir.d_namlen = (unsigned short)len;
+  memcpy(dir->dd_dir.d_name, dir->dd_dta.name, len + 1);
+  return &dir->dd_dir;
+}
+
+int __cdecl closedir(DIR *dir) {
+  errno = 0;
+  if (!dir) {
+    errno = EFAULT;
+    return -1;
+  }
+  int rc = dir->dd_handle != -1 ? _findclose(dir->dd_handle) : 0;
+  free(dir);
+  return rc;
+}
+
+void __cdecl rewinddir(DIR *dir) {
+  errno = 0;
+  if (!dir) {
+    errno = EFAULT;
+    return;
+  }
+  if (dir->dd_handle != -1) _findclose(dir->dd_handle);
+  dir->dd_handle = -1;
+  dir->dd_stat = 0;
+}
+
+long __cdecl telldir(DIR *dir) {
+  errno = 0;
+  if (!dir) {
+    errno = EFAULT;
+    return -1;
+  }
+  return dir->dd_stat;
+}
+
+void __cdecl seekdir(DIR *dir, long position) {
+  errno = 0;
+  if (!dir) {
+    errno = EFAULT;
+    return;
+  }
+  if (position < -1) {
+    errno = EINVAL;
+  } else if (position == -1) {
+    if (dir->dd_handle != -1) _findclose(dir->dd_handle);
+    dir->dd_handle = -1;
+    dir->dd_stat = -1;
+  } else {
+    rewinddir(dir);
+    while (dir->dd_stat < position && readdir(dir)) {
+    }
+  }
+}

package/src/platform/windows/webview2_host.cpp

@@ -312,6 +312,9 @@ struct WindowsEvent {
      * the selected item's id (0 = dismissed without a selection). */
     uint64_t widget_id;
     uint32_t menu_item_id;
+    /* Window events: nonzero while the window is maximized (IsZoomed).
+     * Every emit carries the live value, so any frame event reports it. */
+    int maximized;
 };
 
 /* One context-menu entry crossing the C ABI (the same shape the macOS
@@ -415,6 +418,9 @@ struct Window {
     /* True while the .hide policy has this window off the glass; the
      * hwnd stays live and the map entry stays owned. */
     bool policy_hidden = false;
+    /* The maximized state last reported to the runtime, so WM_SIZE emits
+     * a frame event only when it changes. */
+    bool maximized = false;
 };
 
 /* One rectangle of a canvas view's window-drag mirror (runtime push,
@@ -1382,6 +1388,7 @@ static void emit(Host *host, const Window &window, EventKind kind) {
     event.open = window.hwnd != nullptr;
     event.focused = windowOwnsKeyboardFocus(window);
     event.hidden = window.policy_hidden ? 1 : 0;
+    event.maximized = window.hwnd && IsZoomed(window.hwnd) ? 1 : 0;
     event.label = window.label.c_str();
     event.label_len = window.label.size();
     event.title = window.title.c_str();
@@ -1389,6 +1396,23 @@ static void emit(Host *host, const Window &window, EventKind kind) {
     host->callback(host->callback_context, &event);
 }
 
+/* WM_SIZE runs for every maximize and restore, whoever started it: the
+ * caption double-click, the system menu, Win+Up, a drag to the top edge,
+ * or the app's own maximize call. A frame event on each transition keeps the runtime's
+ * maximized state current; ordinary resizes emit nothing new. */
+static void emitMaximizedTransition(Host *host, HWND hwnd) {
+    if (!host || !hwnd) return;
+    for (auto &entry : host->windows) {
+        Window &window = entry.second;
+        if (window.hwnd != hwnd) continue;
+        const bool maximized = IsZoomed(hwnd) != FALSE;
+        if (maximized == window.maximized) return;
+        window.maximized = maximized;
+        emit(host, window, kWindowFrame);
+        return;
+    }
+}
+
 static void emitFileDrop(Host *host, const Window &window, const std::string &paths) {
     if (!host || !host->callback || paths.empty()) return;
     WindowsEvent event = {};
@@ -5673,6 +5697,67 @@ static bool handleAppTimerMessage(Host *host, WPARAM wparam) {
     return true;
 }
 
+/* Windows sizes only captioned windows to the work area when they
+ * maximize; a caption-less popup covers the whole monitor, taskbar
+ * included. Chromeless windows get the captioned behavior back: the
+ * maximized frame is the work area of the window's monitor, grown by the
+ * resize frame so the borders park offscreen and the client fills the
+ * work area exactly, whether an app control, a drag-region double-click,
+ * or the system menu maximized it. Writes that frame in screen
+ * coordinates, plus the monitor rect it was taken from. */
+static bool chromelessMaximizedFrame(HWND hwnd, HMONITOR monitor_handle, RECT *maximized, RECT *monitor_rect) {
+    MONITORINFO monitor = {};
+    monitor.cbSize = sizeof(monitor);
+    if (!GetMonitorInfoW(monitor_handle, &monitor)) return false;
+    RECT frame = {};
+    const DWORD style = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
+    const DWORD ex_style = (DWORD)GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
+    if (!adjustWindowRectForDpi(&frame, style, GetMenu(hwnd) != nullptr, ex_style, dpiForWindow(hwnd))) return false;
+    maximized->left = monitor.rcWork.left + frame.left;
+    maximized->top = monitor.rcWork.top + frame.top;
+    maximized->right = monitor.rcWork.right + frame.right;
+    maximized->bottom = monitor.rcWork.bottom + frame.bottom;
+    if (monitor_rect) *monitor_rect = monitor.rcMonitor;
+    return true;
+}
+
+static void applyChromelessMaximizedBounds(Host *host, HWND hwnd, MINMAXINFO *info) {
+    if (!info || !chromelessWindowForHwnd(host, hwnd)) return;
+    RECT maximized = {};
+    RECT monitor = {};
+    if (!chromelessMaximizedFrame(hwnd, MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST), &maximized, &monitor)) return;
+    info->ptMaxPosition.x = maximized.left - monitor.left;
+    info->ptMaxPosition.y = maximized.top - monitor.top;
+    info->ptMaxSize.x = maximized.right - maximized.left;
+    info->ptMaxSize.y = maximized.bottom - maximized.top;
+}
+
+/* WM_GETMINMAXINFO speaks in primary-monitor terms: when a window
+ * maximizes onto another monitor, the system rescales those values by
+ * the difference between the two monitors, which can overshoot a
+ * monitor larger than the primary one. So the final frame of a maximized
+ * chromeless window is set here, from the monitor it actually lands on,
+ * whatever moved it: a maximize, or a maximized window moving to another
+ * monitor. Pure z-order changes pass through. */
+static void clampChromelessMaximizedFrame(Host *host, HWND hwnd, WINDOWPOS *pos) {
+    if (!pos || ((pos->flags & SWP_NOMOVE) && (pos->flags & SWP_NOSIZE))) return;
+    if (!IsZoomed(hwnd) || !chromelessWindowForHwnd(host, hwnd)) return;
+    RECT proposed = {};
+    GetWindowRect(hwnd, &proposed);
+    if (!(pos->flags & SWP_NOMOVE)) OffsetRect(&proposed, pos->x - proposed.left, pos->y - proposed.top);
+    if (!(pos->flags & SWP_NOSIZE)) {
+        proposed.right = proposed.left + pos->cx;
+        proposed.bottom = proposed.top + pos->cy;
+    }
+    RECT maximized = {};
+    if (!chromelessMaximizedFrame(hwnd, MonitorFromRect(&proposed, MONITOR_DEFAULTTONEAREST), &maximized, nullptr)) return;
+    pos->x = maximized.left;
+    pos->y = maximized.top;
+    pos->cx = maximized.right - maximized.left;
+    pos->cy = maximized.bottom - maximized.top;
+    pos->flags &= ~(SWP_NOMOVE | SWP_NOSIZE);
+}
+
 static LRESULT CALLBACK windowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
     if (message == WM_NCCREATE) {
         auto *create = reinterpret_cast<CREATESTRUCTW *>(lparam);
@@ -5925,6 +6010,7 @@ static LRESULT CALLBACK windowProc(HWND hwnd, UINT message, WPARAM wparam, LPARA
                     }
                 }
             }
+            emitMaximizedTransition(host, hwnd);
             return 0;
         case WM_SETFOCUS:
         case WM_KILLFOCUS:
@@ -6010,7 +6096,11 @@ static LRESULT CALLBACK windowProc(HWND hwnd, UINT message, WPARAM wparam, LPARA
                 for (auto &entry : host->windows) emit(host, entry.second, kFrame);
             }
             return 0;
+        case WM_WINDOWPOSCHANGING:
+            clampChromelessMaximizedFrame(host, hwnd, reinterpret_cast<WINDOWPOS *>(lparam));
+            break;
         case WM_GETMINMAXINFO:
+            applyChromelessMaximizedBounds(host, hwnd, reinterpret_cast<MINMAXINFO *>(lparam));
             if (host) {
                 for (auto &entry : host->windows) {
                     Window &window = entry.second;
@@ -6903,6 +6993,45 @@ int native_sdk_windows_minimize_window(Host *host, uint64_t window_id) {
     return 1;
 }
 
+/* Maximize and restore-from-maximized for app-drawn window controls.
+ * Returns 1 on success, 0 for an unknown or destroyed window, -1 when the
+ * window is not resizable (the system offers it no maximize either), and
+ * -2 when it is not on the glass: SW_MAXIMIZE and SW_RESTORE both show a
+ * hidden window, which would bypass the policy-hidden and deferred-show
+ * bookkeeping. The state change reaches the runtime through WM_SIZE. */
+int native_sdk_windows_maximize_window(Host *host, uint64_t window_id) {
+    if (!host) return 0;
+    auto found = host->windows.find(window_id);
+    if (found == host->windows.end() || !found->second.hwnd) return 0;
+    if (!found->second.resizable) return -1;
+    if (!IsWindowVisible(found->second.hwnd)) return -2;
+    ShowWindow(found->second.hwnd, SW_MAXIMIZE);
+    return 1;
+}
+
+int native_sdk_windows_unmaximize_window(Host *host, uint64_t window_id) {
+    if (!host) return 0;
+    auto found = host->windows.find(window_id);
+    if (found == host->windows.end() || !found->second.hwnd) return 0;
+    if (!IsZoomed(found->second.hwnd)) return 1;
+    if (!IsWindowVisible(found->second.hwnd)) return -2;
+    ShowWindow(found->second.hwnd, SW_RESTORE);
+    return 1;
+}
+
+/* The user-close request: post the same WM_CLOSE the caption close button
+ * and Alt+F4 produce, so the WM_CLOSE handler applies close_policy.
+ * native_sdk_windows_close_window stays the app's unconditional close.
+ * Posting keeps the close out of the runtime call that requested it.
+ * Returns 1 when posted, 0 for an unknown or destroyed window, -1 when
+ * the post fails. */
+int native_sdk_windows_request_close_window(Host *host, uint64_t window_id) {
+    if (!host) return 0;
+    auto found = host->windows.find(window_id);
+    if (found == host->windows.end() || !found->second.hwnd) return 0;
+    return PostMessageW(found->second.hwnd, WM_CLOSE, 0, 0) ? 1 : -1;
+}
+
 int native_sdk_windows_hide_window(Host *host, uint64_t window_id) {
     if (!host) return 0;
     auto found = host->windows.find(window_id);

package/src/runtime/bridge_responses.zig

@@ -289,6 +289,8 @@ pub fn writeWindowJsonToWriter(window: platform.WindowInfo, writer: anytype) !vo
         window.frame.height,
         window.scale_factor,
     });
+    try writer.writeAll(",\"maximized\":");
+    try writer.writeAll(if (window.maximized) "true" else "false");
     try writer.writeByte('}');
 }
 

package/src/runtime/core.zig

@@ -815,6 +815,11 @@ pub const Runtime = struct {
     const viewTreeHasFocused = WindowViewMethods.viewTreeHasFocused;
     const viewTreeHasFocusedDepth = WindowViewMethods.viewTreeHasFocusedDepth;
 
+    const WindowControlMethods = @import("window_controls.zig").RuntimeWindowControls(Runtime);
+    pub const maximizeWindow = WindowControlMethods.maximizeWindow;
+    pub const unmaximizeWindow = WindowControlMethods.unmaximizeWindow;
+    pub const requestCloseWindow = WindowControlMethods.requestCloseWindow;
+
     const SystemServiceMethods = runtime_system_services.RuntimeSystemServices(Runtime);
     pub const readClipboard = SystemServiceMethods.readClipboard;
     pub const writeClipboard = SystemServiceMethods.writeClipboard;

package/src/runtime/tests.zig

@@ -45,4 +45,5 @@ test {
     _ = @import("persist_store.zig");
     _ = @import("session_record.zig");
     _ = @import("session_tests.zig");
+    _ = @import("window_controls_tests.zig");
 }

package/src/runtime/window_controls.zig

@@ -0,0 +1,73 @@
+//! Window controls for app-drawn title bars, beyond minimize: maximize,
+//! restore from maximized, and the user-close request. Each is the real
+//! OS verb for a tracked, open window. Like `minimizeWindow`, no runtime
+//! bookkeeping moves here: the host's own frame events report what the
+//! OS did, the same way they report the caption buttons, the system menu,
+//! and keyboard shortcuts.
+const lifecycle = @import("window_lifecycle_policy.zig");
+const std = @import("std");
+const runtime_window_views = @import("window_views.zig");
+const platform = @import("../platform/root.zig");
+
+/// The page event a window's WebViews receive when its maximized state
+/// changes, whoever changed it, so a page-drawn maximize/restore button
+/// can follow the caption double-click, the system menu, and keyboard
+/// shortcuts: `window.zero.on("window:state", ({ maximized }) => ...)`.
+pub const window_state_event = "window:state";
+
+/// Called by the runtime's window-state update when `maximized` flips.
+/// Best effort, like the other page notifications: the detail is always
+/// valid JSON, so the only failure is a host without page events
+/// (`error.UnsupportedService`), where no page exists to tell.
+pub fn announceMaximized(runtime: anytype, window_id: platform.WindowId, maximized: bool) void {
+    var detail_buffer: [64]u8 = undefined;
+    const detail = std.fmt.bufPrint(&detail_buffer, "{{\"windowId\":{d},\"maximized\":{s}}}", .{ window_id, if (maximized) "true" else "false" }) catch return;
+    runtime.options.platform.services.emitWindowEvent(window_id, window_state_event, detail) catch {};
+}
+
+pub fn RuntimeWindowControls(comptime Runtime: type) type {
+    const WindowViewMethods = runtime_window_views.RuntimeWindowViews(Runtime);
+
+    return struct {
+        /// Maximize a window. Refused for a non-resizable window
+        /// (`error.WindowNotResizable`) and for one that is not on the
+        /// glass (`error.WindowHidden`). `WindowInfo.maximized` follows
+        /// the host's frame event.
+        pub fn maximizeWindow(self: *Runtime, window_id: platform.WindowId) anyerror!void {
+            try requireOpenWindow(self, window_id);
+            try self.options.platform.services.maximizeWindow(window_id);
+        }
+
+        /// Restore a maximized window to its normal frame. A window that
+        /// is not maximized is left as it is.
+        pub fn unmaximizeWindow(self: *Runtime, window_id: platform.WindowId) anyerror!void {
+            try requireOpenWindow(self, window_id);
+            try self.options.platform.services.unmaximizeWindow(window_id);
+        }
+
+        /// Ask a window to close as if the user pressed its close button,
+        /// so its `close_policy` applies: `.hide` hides it and keeps its
+        /// views, `.quit` closes it and dispatches `window_closed`.
+        /// `closeWindow` remains the app's own unconditional close. The
+        /// request is queued; its outcome arrives as the host's frame
+        /// events, so success here means the request was delivered.
+        pub fn requestCloseWindow(self: *Runtime, window_id: platform.WindowId) anyerror!void {
+            try requireOpenWindow(self, window_id);
+            try self.options.platform.services.requestCloseWindow(window_id);
+        }
+
+        /// The liveness gate every window verb shares: a closed window
+        /// keeps its table slot, so a resolvable id is not enough.
+        fn requireOpenWindow(self: *Runtime, window_id: platform.WindowId) !void {
+            if (self.window_lifecycle_policy) |policy| {
+                // The compiled policy knows close, hide, show, and focus,
+                // which move runtime flags, and minimize, which moves
+                // none. These controls move none either, so they take
+                // minimize's admission: the window exists and is open.
+                return lifecycle.plan(policy, self, .begin, .{ .id = window_id, .variant = @intFromEnum(lifecycle.Verb.minimize) }).admitted();
+            }
+            const index = WindowViewMethods.findWindowIndexById(self, window_id) orelse return error.WindowNotFound;
+            if (!self.windows[index].info.open) return error.WindowNotFound;
+        }
+    };
+}

package/src/runtime/window_controls_tests.zig

@@ -0,0 +1,192 @@
+const support = @import("test_support.zig");
+const std = support.std;
+const platform = support.platform;
+const App = support.App;
+const Runtime = support.Runtime;
+const Event = support.Event;
+const TestHarness = support.TestHarness;
+const window_controls = @import("window_controls.zig");
+const bridge_responses = @import("bridge_responses.zig");
+
+const ControlsApp = struct {
+    window_closed_count: u32 = 0,
+
+    fn app(self: *@This()) App {
+        return .{ .context = self, .name = "window-controls", .source = platform.WebViewSource.html("<p>Controls</p>"), .event_fn = event };
+    }
+
+    fn event(context: *anyopaque, runtime: *Runtime, incoming: Event) !void {
+        _ = runtime;
+        const self: *@This() = @ptrCast(@alignCast(context));
+        if (incoming == .window_closed) self.window_closed_count += 1;
+    }
+};
+
+fn windowInfo(runtime: *const Runtime, window_id: platform.WindowId) ?platform.WindowInfo {
+    for (runtime.windows[0..runtime.window_count]) |window| {
+        if (window.info.id == window_id) return window.info;
+    }
+    return null;
+}
+
+fn expectEveryControlRefused(runtime: *Runtime, window_id: platform.WindowId, expected: anyerror) !void {
+    try std.testing.expectError(expected, runtime.maximizeWindow(window_id));
+    try std.testing.expectError(expected, runtime.unmaximizeWindow(window_id));
+    try std.testing.expectError(expected, runtime.requestCloseWindow(window_id));
+}
+
+test "maximize and unmaximize reach the host and maximized follows its frame events" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    const tools = try harness.runtime.createWindow(.{ .label = "tools", .title = "Tools" });
+    try harness.runtime.maximizeWindow(tools.id);
+    // The verb moves no runtime state; the host's frame event reports it.
+    try std.testing.expect(!windowInfo(&harness.runtime, tools.id).?.maximized);
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.windowFrameEvent(tools.id).?);
+    try std.testing.expect(windowInfo(&harness.runtime, tools.id).?.maximized);
+    try std.testing.expect(windowInfo(&harness.runtime, tools.id).?.state().maximized);
+    var output: [platform.max_windows]platform.WindowInfo = undefined;
+    for (harness.runtime.listWindows(&output)) |listed| {
+        if (listed.id == tools.id) try std.testing.expect(listed.maximized);
+    }
+
+    try harness.runtime.unmaximizeWindow(tools.id);
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.windowFrameEvent(tools.id).?);
+    try std.testing.expect(!windowInfo(&harness.runtime, tools.id).?.maximized);
+    // Restoring a window that is not maximized leaves it as it is.
+    try harness.runtime.unmaximizeWindow(tools.id);
+    try std.testing.expect(!harness.null_platform.windows[1].maximized);
+}
+
+test "a maximized change reaches the window's pages and its window JSON" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    const tools = try harness.runtime.createWindow(.{ .label = "tools" });
+    try harness.runtime.maximizeWindow(tools.id);
+    const before = harness.null_platform.windowEventCount();
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.windowFrameEvent(tools.id).?);
+    try std.testing.expectEqual(before + 1, harness.null_platform.windowEventCount());
+    try std.testing.expectEqual(tools.id, harness.null_platform.lastWindowEventWindowId());
+    try std.testing.expectEqualStrings(window_controls.window_state_event, harness.null_platform.lastWindowEventName());
+    try std.testing.expectEqualStrings("{\"windowId\":2,\"maximized\":true}", harness.null_platform.lastWindowEventDetail());
+
+    // A page loading now reads the same state from the window list.
+    var json_buffer: [512]u8 = undefined;
+    var writer = std.Io.Writer.fixed(&json_buffer);
+    try bridge_responses.writeWindowJsonToWriter(windowInfo(&harness.runtime, tools.id).?, &writer);
+    try std.testing.expect(std.mem.endsWith(u8, writer.buffered(), ",\"maximized\":true}"));
+
+    // A frame event that leaves the state alone (a move) tells nobody.
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.windowFrameEvent(tools.id).?);
+    try std.testing.expectEqual(before + 1, harness.null_platform.windowEventCount());
+
+    try harness.runtime.unmaximizeWindow(tools.id);
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.windowFrameEvent(tools.id).?);
+    try std.testing.expectEqual(before + 2, harness.null_platform.windowEventCount());
+    try std.testing.expectEqualStrings("{\"windowId\":2,\"maximized\":false}", harness.null_platform.lastWindowEventDetail());
+}
+
+test "a maximize the app did not request still updates maximized" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    // A caption double-click, the system menu, or Win+Up: the host's
+    // frame event is the only signal, and it is enough.
+    var state = windowInfo(&harness.runtime, 1).?.state();
+    state.maximized = true;
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), .{ .window_frame_changed = state });
+    try std.testing.expect(windowInfo(&harness.runtime, 1).?.maximized);
+    state.maximized = false;
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), .{ .window_frame_changed = state });
+    try std.testing.expect(!windowInfo(&harness.runtime, 1).?.maximized);
+}
+
+test "window controls refuse unknown, closed, hidden, and non-resizable windows" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    try expectEveryControlRefused(&harness.runtime, 99, error.WindowNotFound);
+
+    const fixed = try harness.runtime.createWindow(.{ .label = "fixed", .resizable = false });
+    try std.testing.expectError(error.WindowNotResizable, harness.runtime.maximizeWindow(fixed.id));
+
+    const tools = try harness.runtime.createWindow(.{ .label = "tools" });
+    try harness.runtime.hideWindow(tools.id);
+    try std.testing.expectError(error.WindowHidden, harness.runtime.maximizeWindow(tools.id));
+
+    // A closed window keeps its runtime slot; resolving its id is not
+    // liveness, and no verb reaches the host for it.
+    try harness.runtime.closeWindow(tools.id);
+    try expectEveryControlRefused(&harness.runtime, tools.id, error.WindowNotFound);
+    try std.testing.expect(harness.null_platform.takeQueuedCloseRequest() == null);
+}
+
+test "requestCloseWindow closes a quit-policy window the way the user's close button does" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    const tools = try harness.runtime.createWindow(.{ .label = "tools" });
+    try harness.runtime.requestCloseWindow(tools.id);
+    // Only a request: the window is untouched until the host handles it.
+    try std.testing.expect(windowInfo(&harness.runtime, tools.id).?.open);
+    try std.testing.expectEqual(@as(u32, 0), app_state.window_closed_count);
+
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.takeQueuedCloseRequest().?);
+    try std.testing.expect(!windowInfo(&harness.runtime, tools.id).?.open);
+    try std.testing.expectEqual(@as(u32, 1), app_state.window_closed_count);
+    try std.testing.expect(harness.null_platform.takeQueuedCloseRequest() == null);
+
+    // closeWindow keeps its meaning: the app's own close, which never
+    // reports back as a user close.
+    const other = try harness.runtime.createWindow(.{ .label = "other" });
+    try harness.runtime.closeWindow(other.id);
+    try std.testing.expectEqual(@as(u32, 1), app_state.window_closed_count);
+}
+
+test "requestCloseWindow hides a hide-policy window and keeps it alive" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    const palette = try harness.runtime.createWindow(.{ .label = "palette", .close_policy = .hide });
+    _ = try harness.runtime.createView(.{ .window_id = palette.id, .label = "action", .kind = .button, .frame = .init(10, 10, 80, 30) });
+    const view_count = harness.runtime.view_count;
+
+    try harness.runtime.requestCloseWindow(palette.id);
+    try harness.runtime.dispatchPlatformEvent(app_state.app(), harness.null_platform.takeQueuedCloseRequest().?);
+    const info = windowInfo(&harness.runtime, palette.id).?;
+    try std.testing.expect(info.open);
+    try std.testing.expect(info.hidden);
+    try std.testing.expectEqual(view_count, harness.runtime.view_count);
+    try std.testing.expectEqual(@as(u32, 0), app_state.window_closed_count);
+
+    // The hidden window comes back with its views, as after a user close.
+    try harness.runtime.showWindow(palette.id);
+    try std.testing.expect(!windowInfo(&harness.runtime, palette.id).?.hidden);
+}
+
+test "a close request for a window the app closed first is dropped" {
+    const harness = try TestHarness().create(std.testing.allocator, .{});
+    defer harness.destroy(std.testing.allocator);
+    var app_state: ControlsApp = .{};
+    try harness.start(app_state.app());
+
+    const tools = try harness.runtime.createWindow(.{ .label = "tools" });
+    try harness.runtime.requestCloseWindow(tools.id);
+    try harness.runtime.closeWindow(tools.id);
+    try std.testing.expect(harness.null_platform.takeQueuedCloseRequest() == null);
+    try std.testing.expectEqual(@as(u32, 0), app_state.window_closed_count);
+}

package/src/runtime/window_storage.zig

@@ -220,6 +220,9 @@ pub fn RuntimeWindowStorage(comptime Runtime: type) type {
             const index = existing_index orelse try Self.reserveWindow(self, state.id, state.label, state.title, null, true, .allow_source_less);
             self.windows[index].info.frame = state.frame;
             self.windows[index].info.scale_factor = state.scale_factor;
+            const was_maximized = self.windows[index].info.maximized;
+            self.windows[index].info.maximized = state.maximized;
+            if (was_maximized != state.maximized) @import("window_controls.zig").announceMaximized(self, state.id, state.maximized);
             if (self.window_lifecycle_policy == null) {
                 self.windows[index].info.open = state.open;
                 self.windows[index].info.hidden = state.hidden;

package/src/tooling/templates.zig

@@ -1493,9 +1493,12 @@ fn buildZig(allocator: std.mem.Allocator, names: TemplateNames, framework_path:
         \\    // release-shaped exes are GUI-subsystem so the app never flashes a
         \\    // console behind its window; Debug keeps the console for dev logs.
         \\    // Redirected logging still works on GUI exes - only console
-        \\    // AUTO-allocation is subsystem-gated.
+        \\    // AUTO-allocation is subsystem-gated. MSVC's CRT enters a GUI exe
+        \\    // through WinMain, which Zig apps do not export, so MSVC targets
+        \\    // keep the GUI subsystem but enter through mainCRTStartup.
         \\    if (target.result.os.tag == .windows and optimize != .Debug) {
         \\        exe.subsystem = .windows;
+        \\        if (target.result.abi == .msvc) exe.entry = .{ .symbol_name = "mainCRTStartup" };
         \\    }
         \\    linkPlatform(b, target, app_mod, exe, selected_platform, web_engine, web_layer, native_sdk_path, cef_dir, cef_auto_install);
         \\    b.installArtifact(exe);
@@ -1554,6 +1557,7 @@ fn buildZig(allocator: std.mem.Allocator, names: TemplateNames, framework_path:
         \\        // exe's own mode: release-shaped Windows exes are GUI-subsystem.
         \\        if (target.result.os.tag == .windows and package_optimize != .Debug) {
         \\            built.subsystem = .windows;
+        \\            if (target.result.abi == .msvc) built.entry = .{ .symbol_name = "mainCRTStartup" };
         \\        }
         \\        linkPlatform(b, target, package_app_mod, built, selected_platform, web_engine, web_layer, native_sdk_path, cef_dir, cef_auto_install);
         \\        break :pkg built;
@@ -4284,6 +4288,9 @@ test "writeDefaultApp emits Vite project files" {
     // the SDK build graph) so packaged scaffold apps never flash a console.
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "if (target.result.os.tag == .windows and optimize != .Debug) {") != null);
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "exe.subsystem = .windows;") != null);
+    // MSVC's CRT would enter that GUI exe through WinMain, which Zig apps
+    // do not export; MSVC targets enter through mainCRTStartup instead.
+    try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "if (target.result.abi == .msvc) exe.entry = .{ .symbol_name = \"mainCRTStartup\" };") != null);
     // The package step wraps its own release-shaped exe: Debug stays the
     // run/dev default, but `zig build package` must never ship a Debug
     // (console-subsystem) binary unless the user pinned the mode
@@ -4296,6 +4303,7 @@ test "writeDefaultApp emits Vite project files" {
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "const package_exe = if (package_optimize == optimize) exe else pkg: {") != null);
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "if (target.result.os.tag == .windows and package_optimize != .Debug) {") != null);
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "built.subsystem = .windows;") != null);
+    try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "if (target.result.abi == .msvc) built.entry = .{ .symbol_name = \"mainCRTStartup\" };") != null);
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "package.addFileArg(package_exe.getEmittedBin());") != null);
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "package.step.dependOn(&package_exe.step);") != null);
     try std.testing.expect(std.mem.indexOf(u8, build_zig_text, "package_optimize_name,") != null);

package/tools/native-sdk/main.zig

@@ -6,7 +6,7 @@ const tooling = @import("tooling");
 const automation_protocol = @import("automation_protocol");
 const cli_build_info = @import("cli_build_info");
 
-const version = "0.11.0-fork.2";
+const version = "0.11.0-fork.3";
 
 pub fn main(init: std.process.Init) !void {
     const allocator = init.arena.allocator();