fix(MSR-030): repair Windows consumer portability

Author: robertvokac

NEXT.md

@@ -3,6 +3,17 @@
 
 # NEXT.md
 
+> **2026-10-05 — MSR-030 Windows consumer qualification.** The CNA sample campaign's full
+> MinGW-w64 consumer build exposed four target-platform defects: Windows `SOCKET` values were
+> narrowed to signed `int` in `ServiceHost`, its listener started before `WSAStartup`, Socket's
+> async teardown used POSIX `SHUT_RDWR`, and MinGW emitted duplicate TLS initializers for the
+> non-trivial inline thread-local state in `Thread` and `CultureInfo`. The socket handles now keep
+> pointer width, Winsock initializes once, shutdown selects the platform constant, and non-trivial
+> TLS storage has one out-of-line definition. The seven-renderer CNA/cna-samples Windows cross-build
+> links the complete corpus. The warning-free two-job build and unchanged original Yacht SOAP
+> fixture pass **18,123/18,123 tests across 41 executables**, with zero failures/skips. This is
+> cross-build evidence, not native Windows runtime qualification.
+>
 > **2026-09-30 — current entry point:** See
 > [the human development handoff](docs/HumanDevelopmentHandoff-2026-09-30.md)
 > for the dated current state, ticket database, audit scope, and human-owned

modules/globalization/include/System/Globalization/CultureInfo.hpp

@@ -675,11 +675,7 @@ class CultureInfo : public System::IFormatProvider {
 // Absent by default: a thread that has chosen nothing falls through to the process-wide default
 // and then to the invariant culture, which is .NET's chain
 // (`s_currentThreadCulture ?? s_DefaultThreadCurrentCulture ?? s_userDefaultCulture`).
-inline thread_local std::optional<CultureInfo> CultureInfo::currentCulture_{};
-inline thread_local std::optional<CultureInfo> CultureInfo::currentUICulture_{};
 inline CultureInfo::SharedCultureSlot CultureInfo::defaultThreadCurrentCulture_{};
 inline CultureInfo::SharedCultureSlot CultureInfo::defaultThreadCurrentUICulture_{};
-inline thread_local std::shared_ptr<const CultureInfo> CultureInfo::currentCultureHold_{};
-inline thread_local std::shared_ptr<const CultureInfo> CultureInfo::currentUICultureHold_{};
 
 } // namespace System::Globalization

modules/globalization/src/System/Globalization/CultureInfo.cpp

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) Robert Vokac and contributors
+// Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
+#include "System/Globalization/CultureInfo.hpp"
+
+namespace System::Globalization {
+
+thread_local std::optional<CultureInfo> CultureInfo::currentCulture_{};
+thread_local std::optional<CultureInfo> CultureInfo::currentUICulture_{};
+thread_local std::shared_ptr<const CultureInfo> CultureInfo::currentCultureHold_{};
+thread_local std::shared_ptr<const CultureInfo> CultureInfo::currentUICultureHold_{};
+
+} // namespace System::Globalization

modules/net-sockets/src/System/Net/Sockets/Socket.cpp

@@ -144,6 +144,7 @@ namespace {
      * The flag is added to **sends only**. A receive cannot raise SIGPIPE, and adding a flag a
      * platform does not define would not compile.
      */
+#if !defined(_WIN32)
     int nativeSendFlags(SocketFlags flags) {
 #if defined(MSG_NOSIGNAL)
         return nativeSocketFlags(flags) | MSG_NOSIGNAL;
@@ -153,6 +154,7 @@ namespace {
         return nativeSocketFlags(flags);
 #endif
     }
+#endif
 
     // Builds a native sockaddr for `ep` into `storage`, returning the address length.
     // Supports IPEndPoint (v4/v6) and UnixDomainSocketEndPoint.
@@ -335,7 +337,13 @@ void Socket::waitForAsyncOperations(bool discardDescriptor) noexcept {
     // be discarded. shutdown() is irreversible: using it to drain the source side of a move would
     // transfer a disabled socket. Source moves therefore stop AcceptAsync through its bounded
     // poll loop but let the other operations complete naturally (#2417).
-    if (needsShutdown && fd_ >= 0) ::shutdown(static_cast<int>(fd_), SHUT_RDWR);
+    if (needsShutdown && fd_ >= 0) {
+#if defined(_WIN32)
+        ::shutdown(toSk(fd_), SD_BOTH);
+#else
+        ::shutdown(static_cast<int>(fd_), SHUT_RDWR);
+#endif
+    }
 #endif
     std::unique_lock<std::mutex> lock(asyncOps_->mutex);
     asyncOps_->idle.wait(lock, [this] { return asyncOps_->inFlight == 0; });

modules/service-model/include/System/ServiceModel/ServiceHost.hpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <atomic>
+#include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
@@ -100,7 +101,7 @@ namespace System::ServiceModel {
         [[nodiscard]] const EndpointAddress& getBaseAddressProperty() const { return baseAddress_; }
 
     private:
-        void Listen();
+        void Listen(std::uintptr_t listenerSocket);
         [[nodiscard]] std::string HandleRequest(const std::string& requestLine,
                                                 const std::string& soapAction,
                                                 const std::string& body);
@@ -115,7 +116,7 @@ namespace System::ServiceModel {
 
         std::atomic<bool> open_{false};
         std::thread listener_;
-        int listenSocket_ = -1;
+        std::optional<std::uintptr_t> listenSocket_;
         std::mutex mutex_;
     };
 

modules/service-model/src/System/ServiceModel/ServiceHost.cpp

@@ -14,13 +14,15 @@
 #    include <winsock2.h>
 #    include <ws2tcpip.h>
 using socket_t = SOCKET;
+constexpr socket_t kInvalidSocket = INVALID_SOCKET;
 #    define SM_CLOSE_SOCKET closesocket
 #else
 #    include <arpa/inet.h>
 #    include <netinet/in.h>
 #    include <sys/socket.h>
 #    include <unistd.h>
 using socket_t = int;
+constexpr socket_t kInvalidSocket = -1;
 #    define SM_CLOSE_SOCKET ::close
 #endif
 
@@ -32,6 +34,26 @@ namespace System::ServiceModel {
 
 namespace {
 
+bool IsInvalidSocket(socket_t socket)
+{
+    return socket == kInvalidSocket;
+}
+
+void InitializeSockets()
+{
+#if defined(_WIN32)
+    static std::once_flag initialized;
+    static int result = 0;
+    std::call_once(initialized, [] {
+        WSADATA data{};
+        result = ::WSAStartup(MAKEWORD(2, 2), &data);
+    });
+    if (result != 0) {
+        throw CommunicationException("ServiceHost: could not initialize Windows sockets.");
+    }
+#endif
+}
+
 std::string LocalName(const std::string& name)
 {
     const std::size_t colon = name.find(':');
@@ -185,8 +207,9 @@ void ServiceHost::Open()
         }
     }
 
+    InitializeSockets();
     const socket_t listener = ::socket(AF_INET, SOCK_STREAM, 0);
-    if (listener < 0) {
+    if (IsInvalidSocket(listener)) {
         throw CommunicationException("ServiceHost: could not create a listening socket.");
     }
 
@@ -205,16 +228,17 @@ void ServiceHost::Open()
         throw CommunicationException("ServiceHost: could not listen on " + uri + ".");
     }
 
-    listenSocket_ = static_cast<int>(listener);
+    listenSocket_ = static_cast<std::uintptr_t>(listener);
     open_ = true;
-    listener_ = std::thread([this] { Listen(); });
+    listener_ = std::thread([this, listenerSocket = *listenSocket_] { Listen(listenerSocket); });
 }
 
-void ServiceHost::Listen()
+void ServiceHost::Listen(std::uintptr_t listenerSocket)
 {
+    const socket_t listener = static_cast<socket_t>(listenerSocket);
     while (open_) {
-        const socket_t connection = ::accept(static_cast<socket_t>(listenSocket_), nullptr, nullptr);
-        if (connection < 0) {
+        const socket_t connection = ::accept(listener, nullptr, nullptr);
+        if (IsInvalidSocket(connection)) {
             if (!open_) {
                 break;
             }
@@ -331,19 +355,20 @@ void ServiceHost::Close()
 
     open_ = false;
 
-    if (listenSocket_ >= 0) {
+    if (listenSocket_.has_value()) {
+        const socket_t listener = static_cast<socket_t>(*listenSocket_);
 #if defined(_WIN32)
-        ::shutdown(static_cast<socket_t>(listenSocket_), SD_BOTH);
+        ::shutdown(listener, SD_BOTH);
 #else
-        ::shutdown(static_cast<socket_t>(listenSocket_), SHUT_RDWR);
+        ::shutdown(listener, SHUT_RDWR);
 #endif
-        SM_CLOSE_SOCKET(static_cast<socket_t>(listenSocket_));
-        listenSocket_ = -1;
+        SM_CLOSE_SOCKET(listener);
     }
 
     if (listener_.joinable()) {
         listener_.join();
     }
+    listenSocket_.reset();
 }
 
 } // namespace System::ServiceModel

modules/threading/include/System/Threading/Thread.hpp

@@ -65,7 +65,7 @@ namespace System::Threading {
         // thread receives a distinct ID from the same counter as wrapped threads (#1958).
         // Holding the shared_ptr here (rather than a raw Thread*) means CurrentThreadProxy never
         // dereferences the (possibly already-destroyed) Thread object itself.
-        inline static thread_local std::shared_ptr<RunState> currentThreadState_;
+        static thread_local std::shared_ptr<RunState> currentThreadState_;
 
         // #1958 / SR-AUD-193. A thread NOT started through this class used to report managed id
         // 1 -- the main thread's -- so every external thread collided with it and with each

modules/threading/src/System/Threading/Thread.cpp

@@ -13,6 +13,8 @@
 
 namespace System::Threading {
 
+    thread_local std::shared_ptr<Thread::RunState> Thread::currentThreadState_;
+
     intcs Thread::GetCurrentProcessorId() {
 #if defined(_WIN32)
         return static_cast<intcs>(GetCurrentProcessorNumber());

plan.md

@@ -1,5 +1,21 @@
 # Sharp Runtime plan
 
+## 2026-10-05 — MSR-030 Windows consumer qualification
+
+The authorized CNA multi-renderer sample campaign cross-linked the complete Windows sample corpus
+against sharp-runtime and exposed platform defects that ordinary single-translation-unit builds had
+not reached. `ServiceHost` now preserves the unsigned pointer-sized Winsock `SOCKET`, initializes
+Winsock once, and passes the listener value into its worker without narrowing. Socket async teardown
+uses `SD_BOTH` on Windows. `Thread` and `CultureInfo` retain their per-thread semantics while moving
+non-trivial TLS definitions out of public headers, avoiding MinGW's duplicate TLS initializer
+symbols in multi-TU applications.
+
+The existing `build/` tree was reused. The full warning-free build ran at the repository's stricter
+two-job ceiling. The complete component gate used the unchanged Yacht SOAP fixture on a private
+loopback port and passed **18,123/18,123 tests across 41 executables**, zero failures and zero skips.
+The Windows seven-renderer CNA/cna-samples cross-build links completely; native Windows execution is
+still a separate qualification phase.
+
 ## 2026-09-30 — human development handoff
 
 The active handoff and current issue inventory are in