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

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;
@@ -2687,6 +2727,43 @@ test "windows webview focus reports the focused child label" {
     try std.testing.expect(std.mem.indexOf(u8, host_source, "event.view_label = focused->second.label.c_str();") != null);
 }
 
+test "windows webview2 keeps its user data with the app's per-user data" {
+    // WebView2's default user data folder sits beside the executable,
+    // which is read-only under Program Files and is swapped away with
+    // the program files on update. Every environment the host creates
+    // names the folder beside the app_dirs roots instead, and an earlier
+    // "<exe>.WebView2" folder moves there once.
+    const host_source = @embedFile("webview2_host.cpp");
+    try std.testing.expect(std.mem.indexOf(u8, host_source, "factory(nullptr, webViewUserDataFolder(host), nullptr,") != null);
+    try std.testing.expect(std.mem.indexOf(u8, host_source, "factory(nullptr, nullptr, nullptr,") == null);
+    const resolve_at = std.mem.indexOf(u8, host_source, "static const wchar_t *webViewUserDataFolder(Host *host) {") orelse return error.TestExpectedEqual;
+    const resolve = host_source[resolve_at..];
+    try std.testing.expect(std.mem.indexOf(u8, resolve, "GetEnvironmentVariableW(L\"LOCALAPPDATA\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, resolve, "const std::wstring folder = app_root + L\"\\\\WebView2\";") != null);
+    try std.testing.expect(std.mem.indexOf(u8, resolve, "MoveFileExW(legacy.c_str(), folder.c_str(), 0)") != null);
+    try std.testing.expect(std.mem.indexOf(u8, host_source, "return path + L\".WebView2\";") != null);
+}
+
+test "windows webview assets resolve against the packaged resources beside bin" {
+    // `native package` stages bin\<exe> and the app-relative asset tree
+    // in resources\; a relative asset root names that tree when the app
+    // runs from a package and the working directory otherwise.
+    const host_source = @embedFile("webview2_host.cpp");
+    try std.testing.expect(std.mem.indexOf(u8, host_source, "std::string path = assetRootPath(webview.asset_root);") != null);
+    const resources_at = std.mem.indexOf(u8, host_source, "static const std::wstring &packagedResourcesDirectory() {") orelse return error.TestExpectedEqual;
+    const resources = host_source[resources_at..];
+    try std.testing.expect(std.mem.indexOf(u8, resources, "CompareStringOrdinal(bin.c_str() + bin_slash + 1, -1, L\"bin\", -1, TRUE)") != null);
+    try std.testing.expect(std.mem.indexOf(u8, resources, "return bin.substr(0, bin_slash) + L\"\\\\resources\";") != null);
+}
+
+test "windows names the process by its bundle id for the taskbar" {
+    // The installer's Start menu shortcut carries the bundle id as its
+    // AppUserModelID; the process must claim the same id.
+    const host_source = @embedFile("webview2_host.cpp");
+    const create_at = std.mem.indexOf(u8, host_source, "host->bundle_id = slice(bundle_id, bundle_id_len);") orelse return error.TestExpectedEqual;
+    try std.testing.expect(std.mem.indexOf(u8, host_source[create_at..], "SetCurrentProcessExplicitAppUserModelID(app_user_model_id.c_str());") != null);
+}
+
 test "windows audio event maps kinds and payload" {
     var event = std.mem.zeroes(WindowsEvent);
     event.audio_kind = 1;
@@ -2760,3 +2837,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)) {
+    }
+  }
+}