fix: remove <windows.h> entirely to avoid MinGW std::byte conflict

platform.hpp: return 0 (unknown) for RAM on Windows
platform_io.hpp: use mutex-based _lseeki64+_read instead of ReadFile
file_reader.hpp: use _open/_read/_lseeki64/_close instead of Win32 API

All three files previously included <windows.h> which caused
rpcndr.h byte typedef to collide with std::byte in C++17+ mode
on MinGW (rtools45). Completely avoiding <windows.h> eliminates
the ambiguity.

Author: Zachary DeBruine

inst/build_config

@@ -4,4 +4,4 @@ cuda_version=
 cuda_home=
 nvcc_path=
 gpu_arch=
-build_date=2026-03-14T16:07:22Z
+build_date=2026-03-14T19:31:56Z

inst/include/FactorNet/core/platform.hpp

@@ -16,16 +16,9 @@
 #include <string>
 
 #if defined(_WIN32)
-// Workaround for MinGW C++17+: std::byte (from <cstddef>) conflicts
-// with rpcndr.h "typedef unsigned char byte;" inside <windows.h>.
-// Temporarily rename the Windows byte to avoid the ambiguity.
-#define WIN32_LEAN_AND_MEAN
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#define byte win_byte_override
-#include <windows.h>
-#undef byte
+// On Windows we avoid <windows.h> entirely because MinGW C++17+
+// introduces std::byte which conflicts with rpcndr.h's byte typedef.
+// RAM detection is unavailable; callers handle 0 gracefully.
 #elif defined(__APPLE__)
 #include <sys/sysctl.h>
 #include <unistd.h>
@@ -48,11 +41,7 @@ namespace FactorNet {
  */
 inline uint64_t get_available_ram_bytes() {
 #if defined(_WIN32)
-    MEMORYSTATUSEX status;
-    status.dwLength = sizeof(status);
-    if (GlobalMemoryStatusEx(&status))
-        return static_cast<uint64_t>(status.ullAvailPhys);
-    return 0;
+    return 0;  // Windows: <windows.h> avoided; callers treat 0 as "unknown"
 #elif defined(__APPLE__)
     int64_t page_size = sysconf(_SC_PAGE_SIZE);
     int64_t free_pages = 0;

inst/include/FactorNet/io/file_reader.hpp

@@ -17,10 +17,12 @@
 #include <string>
 
 #ifdef _WIN32
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
+// Avoid <windows.h> entirely — MinGW C++17+ std::byte conflicts with
+// rpcndr.h byte typedef.  Use POSIX-compat _open/_read/_lseeki64 instead.
+#  include <io.h>
+#  include <fcntl.h>
+#  include <sys/stat.h>
+#  include <mutex>
 #else
 #  include <fcntl.h>
 #  include <unistd.h>
@@ -33,35 +35,22 @@ namespace streampress {
 /// Platform-agnostic random-access file reader.
 /// Supports positional reads without moving any file cursor.
 /// Thread-safe for concurrent pread() calls on POSIX platforms.
+/// On Windows, uses a mutex to serialise _lseeki64 + _read.
 class FileReader {
 public:
     explicit FileReader(const std::string& path) {
 #ifdef _WIN32
-        // Convert UTF-8 path to wide string
-        int wlen = MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, nullptr, 0);
-        if (wlen <= 0)
-            throw std::runtime_error("Cannot convert path to wide string: " + path);
-        std::wstring wpath(wlen, L'\0');
-        MultiByteToWideChar(CP_UTF8, 0, path.c_str(), -1, &wpath[0], wlen);
-
-        hFile_ = CreateFileW(
-            wpath.c_str(),
-            GENERIC_READ,
-            FILE_SHARE_READ,
-            nullptr,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
-            nullptr);
-        if (hFile_ == INVALID_HANDLE_VALUE)
+        fd_ = _open(path.c_str(), _O_RDONLY | _O_BINARY);
+        if (fd_ < 0)
             throw std::runtime_error("Cannot open file: " + path);
-
-        LARGE_INTEGER li;
-        if (!GetFileSizeEx(hFile_, &li)) {
-            CloseHandle(hFile_);
-            hFile_ = INVALID_HANDLE_VALUE;
+        __int64 sz = _lseeki64(fd_, 0, SEEK_END);
+        if (sz < 0) {
+            _close(fd_);
+            fd_ = -1;
             throw std::runtime_error("Cannot get file size: " + path);
         }
-        file_size_ = static_cast<uint64_t>(li.QuadPart);
+        file_size_ = static_cast<uint64_t>(sz);
+        _lseeki64(fd_, 0, SEEK_SET);
 #else
         fd_ = ::open(path.c_str(), O_RDONLY);
         if (fd_ < 0)
@@ -86,31 +75,18 @@ class FileReader {
     // Movable
     FileReader(FileReader&& other) noexcept
         : file_size_(other.file_size_)
-#ifdef _WIN32
-        , hFile_(other.hFile_)
-#else
         , fd_(other.fd_)
-#endif
     {
         other.file_size_ = 0;
-#ifdef _WIN32
-        other.hFile_ = INVALID_HANDLE_VALUE;
-#else
         other.fd_ = -1;
-#endif
     }
 
     FileReader& operator=(FileReader&& other) noexcept {
         if (this != &other) {
             close();
             file_size_ = other.file_size_;
-#ifdef _WIN32
-            hFile_ = other.hFile_;
-            other.hFile_ = INVALID_HANDLE_VALUE;
-#else
             fd_ = other.fd_;
             other.fd_ = -1;
-#endif
             other.file_size_ = 0;
         }
         return *this;
@@ -121,13 +97,13 @@ class FileReader {
     size_t pread(uint64_t offset, void* buf, size_t size) const {
         if (size == 0) return 0;
 #ifdef _WIN32
-        OVERLAPPED ov = {};
-        ov.Offset     = static_cast<DWORD>(offset & 0xFFFFFFFF);
-        ov.OffsetHigh = static_cast<DWORD>(offset >> 32);
-        DWORD bytes_read = 0;
-        if (!ReadFile(hFile_, buf, static_cast<DWORD>(size), &bytes_read, &ov))
-            throw std::runtime_error("ReadFile failed at offset " + std::to_string(offset));
-        return static_cast<size_t>(bytes_read);
+        std::lock_guard<std::mutex> lock(mtx_);
+        if (_lseeki64(fd_, static_cast<__int64>(offset), SEEK_SET) < 0)
+            throw std::runtime_error("_lseeki64 failed at offset " + std::to_string(offset));
+        int n = _read(fd_, buf, static_cast<unsigned int>(size));
+        if (n < 0)
+            throw std::runtime_error("_read failed at offset " + std::to_string(offset));
+        return static_cast<size_t>(n);
 #else
         ssize_t n = ::pread(fd_, buf, size, static_cast<off_t>(offset));
         if (n < 0)
@@ -139,19 +115,13 @@ class FileReader {
 
     uint64_t file_size() const { return file_size_; }
 
-    bool is_open() const {
-#ifdef _WIN32
-        return hFile_ != INVALID_HANDLE_VALUE;
-#else
-        return fd_ >= 0;
-#endif
-    }
+    bool is_open() const { return fd_ >= 0; }
 
     void close() {
 #ifdef _WIN32
-        if (hFile_ != INVALID_HANDLE_VALUE) {
-            CloseHandle(hFile_);
-            hFile_ = INVALID_HANDLE_VALUE;
+        if (fd_ >= 0) {
+            _close(fd_);
+            fd_ = -1;
         }
 #else
         if (fd_ >= 0) {
@@ -163,10 +133,9 @@ class FileReader {
 
 private:
     uint64_t file_size_ = 0;
-#ifdef _WIN32
-    HANDLE hFile_ = INVALID_HANDLE_VALUE;
-#else
     int fd_ = -1;
+#ifdef _WIN32
+    mutable std::mutex mtx_;
 #endif
 };
 

inst/include/streampress/core/platform_io.hpp

@@ -12,30 +12,24 @@
 #include <cstddef>
 
 #ifdef _WIN32
-// Workaround for MinGW C++17+: std::byte vs rpcndr.h byte collision
-#define WIN32_LEAN_AND_MEAN
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#define byte win_byte_override
-#include <windows.h>
-#undef byte
+// Avoid <windows.h> entirely — MinGW C++17+ std::byte conflicts with
+// rpcndr.h byte typedef.  Use _lseeki64 + _read under a mutex instead.
 #include <io.h>
+#include <fcntl.h>
+#include <mutex>
 #else
 #include <unistd.h>
 #endif
 
 namespace streampress {
 
 #ifdef _WIN32
-static inline ssize_t safe_pread(int fd, void* buf, size_t count, uint64_t offset) {
-    HANDLE h = (HANDLE)_get_osfhandle(fd);
-    OVERLAPPED ov = {};
-    ov.Offset     = static_cast<DWORD>(offset & 0xFFFFFFFFULL);
-    ov.OffsetHigh = static_cast<DWORD>(offset >> 32);
-    DWORD nread = 0;
-    if (!ReadFile(h, buf, static_cast<DWORD>(count), &nread, &ov)) return -1;
-    return static_cast<ssize_t>(nread);
+inline ssize_t safe_pread(int fd, void* buf, size_t count, uint64_t offset) {
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lock(mtx);
+    if (_lseeki64(fd, static_cast<__int64>(offset), SEEK_SET) < 0) return -1;
+    int n = _read(fd, buf, static_cast<unsigned int>(count));
+    return static_cast<ssize_t>(n);
 }
 #else
 static inline ssize_t safe_pread(int fd, void* buf, size_t count, uint64_t offset) {