levistone 0.6.2.dev58__1-cp312-cp312-win_amd64.whl → 0.10.5__1-cp312-cp312-win_amd64.whl

endstone/__init__.py

@@ -1,14 +1,28 @@
-from endstone._internal.endstone_python import ColorFormat, GameMode, Logger, OfflinePlayer, Player, Server, Skin
+from endstone._internal.endstone_python import (
+    ColorFormat,
+    EnchantmentRegistry,
+    GameMode,
+    ItemRegistry,
+    Logger,
+    NamespacedKey,
+    OfflinePlayer,
+    Player,
+    Server,
+    Skin,
+)
 from endstone._internal.version import __version__
 
-__minecraft_version__ = "1.21.60"
+__minecraft_version__ = "1.21.102"
 
 __all__ = [
     "__version__",
     "__minecraft_version__",
     "ColorFormat",
+    "EnchantmentRegistry",
     "GameMode",
+    "ItemRegistry",
     "Logger",
+    "NamespacedKey",
     "OfflinePlayer",
     "Player",
     "Server",

endstone/_internal/bootstrap/__init__.py

@@ -2,6 +2,7 @@ import functools
 import logging
 import platform
 import sys
+import time
 
 import click
 
@@ -50,7 +51,7 @@ def catch_exceptions(func):
 @click.option(
     "-r",
     "--remote",
-    default="https://raw.githubusercontent.com/EndstoneMC/bedrock-server-data/main/bedrock_server_data.json",
+    default="https://raw.githubusercontent.com/EndstoneMC/bedrock-server-data/v2",
     help="The remote URL to retrieve bedrock server data from.",
 )
 @click.version_option(__version__)
@@ -71,4 +72,8 @@ def cli(server_folder: str, no_confirm: bool, remote: str) -> None:
 
     bootstrap = cls(server_folder=server_folder, no_confirm=no_confirm, remote=remote)
     exit_code = bootstrap.run()
+    if exit_code != 0:
+        logger.error(f"Server exited with non-zero code {exit_code}.")
+        time.sleep(2)
+
     sys.exit(exit_code)

endstone/_internal/bootstrap/base.py

@@ -1,4 +1,5 @@
 import errno
+import fnmatch
 import hashlib
 import logging
 import os
@@ -12,13 +13,14 @@ from pathlib import Path
 from typing import Union
 
 import click
+import importlib_resources
 import requests
 import sentry_crashpad
+import tomlkit
 from packaging.version import Version
 from rich.progress import BarColumn, DownloadColumn, Progress, TextColumn, TimeRemainingColumn
 
 from endstone import __minecraft_version__ as minecraft_version
-from endstone import __version__ as endstone_version
 
 
 class Bootstrap:
@@ -49,13 +51,17 @@ class Bootstrap:
     def executable_path(self) -> Path:
         return self.server_path / self.executable_filename
 
+    @property
+    def config_path(self) -> Path:
+        return self.server_path / "endstone.toml"
+
     @property
     def plugin_path(self) -> Path:
         return self.server_path / "plugins"
 
     @property
     def user_agent(self) -> str:
-        return f"Endstone/{endstone_version} (Minecraft/{minecraft_version})"
+        return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36"
 
     def _validate(self) -> None:
         if platform.system().lower() != self.target_system:
@@ -69,22 +75,23 @@ class Bootstrap:
         dst = Path(dst)
 
         self._logger.info("Loading index from the remote server...")
-        response = requests.get(self._remote)
+        channel = "preview" if Version(minecraft_version).is_prerelease else "release"
+        metadata_url = "/".join([self._remote, channel, minecraft_version, "metadata.json"])
+        response = requests.get(metadata_url, timeout=10)
         response.raise_for_status()
-        server_data = response.json()
+        metadata = response.json()
 
-        if minecraft_version not in server_data["binary"]:
-            raise ValueError(f"Version v{minecraft_version} is not found in the remote server.")
+        if minecraft_version != metadata["version"]:
+            raise ValueError(f"Version mismatch, expect: {minecraft_version}, actual: {metadata['version']}")
 
         should_modify_server_properties = True
 
         with tempfile.TemporaryFile(dir=dst) as f:
-            metadata = server_data["binary"][minecraft_version][self.target_system.lower()]
-            url = metadata["url"]
+            url = metadata["binary"][self.target_system.lower()]["url"]
+            self._logger.info(f"Downloading server from {url}...")
             response = requests.get(url, stream=True, headers={"User-Agent": self.user_agent})
             response.raise_for_status()
             total_size = int(response.headers.get("Content-Length", 0))
-            self._logger.info(f"Downloading server from {url}...")
             m = hashlib.sha256()
 
             with Progress(
@@ -100,17 +107,28 @@ class Bootstrap:
                     m.update(data)
 
             self._logger.info("Download complete. Verifying integrity...")
-            if m.hexdigest() != metadata["sha256"]:
+            if m.hexdigest() != metadata["binary"][self.target_system.lower()]["sha256"]:
                 raise ValueError("SHA256 mismatch: the downloaded file may be corrupted or tampered with.")
 
             self._logger.info(f"Integrity check passed. Extracting to {dst}...")
             dst.mkdir(parents=True, exist_ok=True)
+            override_patterns = [
+                self.executable_filename,
+                "behavior_packs/*",
+                "definitions/*",
+                "resource_packs/*",
+                "bedrock_server_how_to.html",
+                "profanity_filter.wlist",
+                "release-notes.txt",
+            ]
             with zipfile.ZipFile(f) as zip_ref:
                 for file in zip_ref.namelist():
-                    if file in ["allowlist.json", "permissions.json", "server.properties"] and (dst / file).exists():
-                        self._logger.info(f"{file} already exists, skipping.")
-                        should_modify_server_properties = False
-                        continue
+                    dest_path = dst / file
+                    if dest_path.exists():
+                        if not any(fnmatch.fnmatch(file, pattern) for pattern in override_patterns):
+                            should_modify_server_properties = False
+                            self._logger.info(f"{dest_path} already exists, skipping.")
+                            continue
 
                     zip_ref.extract(file, dst)
 
@@ -140,6 +158,32 @@ class Bootstrap:
         shutil.copytree(
             Path(sentry_crashpad._get_executable("crashpad_handler")).parent, self.server_path, dirs_exist_ok=True
         )
+        if not self.config_path.exists():
+            ref = importlib_resources.files("endstone") / "config" / "endstone.toml"
+            with importlib_resources.as_file(ref) as path:
+                shutil.copy(path, self.config_path)
+        else:
+            ref = importlib_resources.files("endstone") / "config" / "endstone.toml"
+            with importlib_resources.as_file(ref) as path:
+                with open(path, "r", encoding="utf-8") as f:
+                    default_config = tomlkit.load(f)
+
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                config = tomlkit.load(f)
+
+            def migrate_config(from_doc: tomlkit.TOMLDocument, to_doc: tomlkit.TOMLDocument) -> None:
+                for key, val in from_doc.items():
+                    if key not in to_doc:
+                        # if the user hasn’t set it, copy it (with comments!)
+                        to_doc[key] = val
+                    else:
+                        # if both are tables, dive deeper
+                        if isinstance(val, tomlkit.TOMLDocument) and isinstance(to_doc[key], tomlkit.TOMLDocument):
+                            migrate_config(val, to_doc[key])
+
+            migrate_config(default_config, config)
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                tomlkit.dump(config, f)
 
     def _install(self) -> None:
         """
@@ -204,8 +248,7 @@ class Bootstrap:
         self._install()
         self._validate()
         self._prepare()
-        self._create_process()
-        return self._wait_for_server()
+        return self._run()
 
     @property
     def _endstone_runtime_filename(self) -> str:
@@ -216,48 +259,27 @@ class Bootstrap:
         p = Path(__file__).parent.parent / self._endstone_runtime_filename
         return p.resolve().absolute()
 
-    def _create_process(self, *args, **kwargs) -> None:
-        """
-        Creates a subprocess for running the server.
-
-        This method initializes a subprocess.Popen object for the server executable. It sets up the necessary
-        buffers and encodings for the process and specifies the working directory.
-
-        Args:
-            *args: Variable length argument list.
-            **kwargs: Arbitrary keyword arguments.
-
-        """
-        env = kwargs.pop("env", os.environ.copy())
+    @property
+    def _endstone_runtime_env(self) -> dict[str, str]:
+        env = os.environ.copy()
         env["PATH"] = os.pathsep.join(sys.path)
         env["PYTHONPATH"] = os.pathsep.join(sys.path)
         env["PYTHONIOENCODING"] = "UTF-8"
-        self._process = subprocess.Popen(
-            [str(self.executable_path.absolute())],
-            stdin=sys.stdin,
-            stdout=sys.stdout,
-            stderr=subprocess.STDOUT,
-            text=True,
-            encoding="utf-8",
-            cwd=str(self.server_path.absolute()),
-            env=env,
-            *args,
-            **kwargs,
-        )
+        env["ENDSTONE_PYTHON_EXECUTABLE"] = sys.executable
+        return env
 
-    def _wait_for_server(self) -> int:
+    def _run(self, *args, **kwargs) -> int:
         """
-        Waits for the server process to terminate and returns its exit code.
+        Runs the server and returns its exit code.
 
-        This method blocks until the server process created by _create_process terminates. It returns the
-        exit code of the process, which can be used to determine if the server shut down successfully or if
-        there were errors.
+        This method blocks until the server process terminates. It returns the exit code of the process, which can be
+        used to determine if the server shut down successfully or if there were errors.
+
+        Args:
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
 
         Returns:
-            int: The exit code of the server process. Returns -1 if the process is not created or still running.
+            int: The exit code of the server process.
         """
-
-        if self._process is None:
-            return -1
-
-        return self._process.wait()
+        raise NotImplementedError

endstone/_internal/bootstrap/linux.py

@@ -1,6 +1,7 @@
 import ctypes.util
 import os
 import stat
+import subprocess
 from pathlib import Path
 
 from endstone._internal.bootstrap.base import Bootstrap
@@ -23,17 +24,30 @@ class LinuxBootstrap(Bootstrap):
     def _endstone_runtime_filename(self) -> str:
         return "libendstone_runtime.so"
 
+    @property
+    def _endstone_runtime_env(self) -> dict[str, str]:
+        env = super()._endstone_runtime_env
+        env["LD_PRELOAD"] = str(self._endstone_runtime_path.absolute())
+        env["LD_LIBRARY_PATH"] = str(self._linked_libpython_path.parent.absolute())
+        return env
+
     def _prepare(self) -> None:
         super()._prepare()
         st = os.stat(self.executable_path)
         os.chmod(self.executable_path, st.st_mode | stat.S_IEXEC)
         os.chmod(self.server_path / "crashpad_handler", st.st_mode | stat.S_IEXEC)
 
-    def _create_process(self, *args, **kwargs) -> None:
-        env = os.environ.copy()
-        env["LD_PRELOAD"] = str(self._endstone_runtime_path.absolute())
-        env["LD_LIBRARY_PATH"] = str(self._linked_libpython_path.parent.absolute())
-        super()._create_process(env=env)
+    def _run(self, *args, **kwargs) -> int:
+        process = subprocess.Popen(
+            [str(self.executable_path.absolute())],
+            text=True,
+            encoding="utf-8",
+            cwd=str(self.server_path.absolute()),
+            env=self._endstone_runtime_env,
+            *args,
+            **kwargs,
+        )
+        return process.wait()
 
     @property
     def _linked_libpython_path(self) -> Path:

endstone/_internal/bootstrap/windows.py

@@ -1,86 +1,128 @@
+import _winapi
 import ctypes
 import os
 import subprocess
-from ctypes import get_last_error
-from ctypes.wintypes import (
-    BOOL,
-    DWORD,
-    HANDLE,
-    HMODULE,
-    LPCSTR,
-    LPCVOID,
-    LPCWSTR,
-    LPDWORD,
-    LPVOID,
-)
+import warnings
+from subprocess import STARTUPINFO, Handle, list2cmdline
 
+from endstone._internal import _detours
 from endstone._internal.bootstrap.base import Bootstrap
 
-SIZE_T = ctypes.c_size_t
-PSIZE_T = ctypes.POINTER(SIZE_T)
-
-
-class THREADENTRY32(ctypes.Structure):
-    _fields_ = [
-        ("dwSize", DWORD),
-        ("cntUsage", DWORD),
-        ("th32ThreadID", DWORD),
-        ("th32OwnerProcessID", DWORD),
-        ("tpBasePri", DWORD),
-        ("tpDeltaPri", DWORD),
-        ("dwFlags", DWORD),
-    ]
-
-
-# Kernel32 Functions
-kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-
-# Constants
-CREATE_SUSPENDED = 0x00000004  # https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
-MAX_PATH = 260  # https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
-MEM_COMMIT = 0x00001000  # https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
-MEM_RESERVE = 0x00002000  # https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
-PAGE_READWRITE = 0x04  # https://learn.microsoft.com/en-us/windows/win32/memory/memory-protection-constants
-INFINITE = 0xFFFFFFFF
-TH32CS_SNAPTHREAD = 0x00000004
-THREAD_ALL_ACCESS = 0x000F0000 | 0x00100000 | 0xFFFF
-INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
-DONT_RESOLVE_DLL_REFERENCES = 0x00000001
-
-# https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex
-VirtualAllocEx = kernel32.VirtualAllocEx
-VirtualAllocEx.restype = LPVOID
-VirtualAllocEx.argtypes = (HANDLE, LPVOID, SIZE_T, DWORD, DWORD)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory
-WriteProcessMemory = kernel32.WriteProcessMemory
-WriteProcessMemory.restype = BOOL
-WriteProcessMemory.argtypes = (HANDLE, LPVOID, LPCVOID, SIZE_T, PSIZE_T)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread
-CreateRemoteThread = kernel32.CreateRemoteThread
-CreateRemoteThread.restype = HANDLE
-CreateRemoteThread.argtypes = (HANDLE, LPVOID, SIZE_T, LPVOID, LPVOID, DWORD, LPDWORD)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getexitcodethread
-GetExitCodeThread = kernel32.GetExitCodeThread
-GetExitCodeThread.restype = BOOL
-GetExitCodeThread.argtypes = (HANDLE, LPDWORD)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulehandlew
-GetModuleHandle = kernel32.GetModuleHandleW
-GetModuleHandle.restype = HMODULE
-GetModuleHandle.argtypes = (LPCWSTR,)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress
-GetProcAddress = kernel32.GetProcAddress
-GetProcAddress.restype = LPVOID
-GetProcAddress.argtypes = (HMODULE, LPCSTR)
-
-# https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibraryexw
-LoadLibraryExW = kernel32.LoadLibraryExW
-LoadLibraryExW.restype = HMODULE
-LoadLibraryExW.argtypes = (LPCWSTR, HANDLE, DWORD)
+
+class PopenWithDll(subprocess.Popen):
+    def __init__(self, *args, **kwargs):
+        self.dll_names = kwargs.pop("dll_names", None)
+        super().__init__(*args, **kwargs)
+
+    def _execute_child(
+        self,
+        args,
+        executable,
+        preexec_fn,
+        close_fds,
+        pass_fds,
+        cwd,
+        env,
+        startupinfo,
+        creationflags,
+        shell,
+        p2cread,
+        p2cwrite,
+        c2pread,
+        c2pwrite,
+        errread,
+        errwrite,
+        unused_restore_signals,
+        unused_gid,
+        unused_gids,
+        unused_uid,
+        unused_umask,
+        unused_start_new_session,
+        unused_process_group,
+    ):
+        """Execute program (MS Windows version)"""
+
+        assert not pass_fds, "pass_fds not supported on Windows."
+
+        if isinstance(args, str):
+            pass
+        elif isinstance(args, bytes):
+            if shell:
+                raise TypeError("bytes args is not allowed on Windows")
+            args = list2cmdline([args])
+        elif isinstance(args, os.PathLike):
+            if shell:
+                raise TypeError("path-like args is not allowed when shell is true")
+            args = list2cmdline([args])
+        else:
+            args = list2cmdline(args)
+
+        if executable is not None:
+            executable = os.fsdecode(executable)
+
+        if startupinfo is None:
+            startupinfo = STARTUPINFO()
+        else:
+            startupinfo = startupinfo.copy()
+
+        use_std_handles = -1 not in (p2cread, c2pwrite, errwrite)
+        if use_std_handles:
+            startupinfo.dwFlags |= _winapi.STARTF_USESTDHANDLES
+            startupinfo.hStdInput = p2cread
+            startupinfo.hStdOutput = c2pwrite
+            startupinfo.hStdError = errwrite
+
+        attribute_list = startupinfo.lpAttributeList
+        have_handle_list = bool(attribute_list and "handle_list" in attribute_list and attribute_list["handle_list"])
+
+        # If we were given an handle_list or need to create one
+        if have_handle_list or (use_std_handles and close_fds):
+            if attribute_list is None:
+                attribute_list = startupinfo.lpAttributeList = {}
+            handle_list = attribute_list["handle_list"] = list(attribute_list.get("handle_list", []))
+
+            if use_std_handles:
+                handle_list += [int(p2cread), int(c2pwrite), int(errwrite)]
+
+            handle_list[:] = self._filter_handle_list(handle_list)
+
+            if handle_list:
+                if not close_fds:
+                    warnings.warn("startupinfo.lpAttributeList['handle_list'] overriding close_fds", RuntimeWarning)
+
+                # When using the handle_list we always request to inherit
+                # handles but the only handles that will be inherited are
+                # the ones in the handle_list
+                close_fds = False
+
+        assert not shell
+
+        if cwd is not None:
+            cwd = os.fsdecode(cwd)
+
+        # Start the process
+        try:
+            hp, ht, pid, tid = _detours.CreateProcessWithDllEx(
+                executable,
+                args,
+                # no special security
+                None,
+                None,
+                not close_fds,
+                creationflags,
+                env,
+                cwd,
+                startupinfo,
+                dll_name=self.dll_names,
+            )
+        finally:
+            self._close_pipe_fds(p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite)
+
+        # Retain the process handle, but close the thread handle
+        self._child_created = True
+        self._handle = Handle(hp)
+        self.pid = pid
+        _winapi.CloseHandle(ht)
 
 
 class WindowsBootstrap(Bootstrap):
@@ -100,24 +142,9 @@ class WindowsBootstrap(Bootstrap):
     def _endstone_runtime_filename(self) -> str:
         return "endstone_runtime_loader.dll"
 
-    def _add_loopback_exemption(self) -> bool:
-        sid = "S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436"
-        ret = subprocess.run(
-            ["CheckNetIsolation", "LoopbackExempt", "-s", f"-p={sid}"], check=True, capture_output=True
-        )
-        if sid not in str(ret.stdout):
-            ret = ctypes.windll.shell32.ShellExecuteW(
-                None, "runas", "CheckNetIsolation", " ".join(["LoopbackExempt", "-a", f"-p={sid}"]), None, 1
-            )
-            return ret > 32
-        else:
-            return True
-
-    def _create_process(self, *args, **kwargs) -> None:
-        self._add_loopback_exemption()
-
-        # Add paths for symbol lookup
-        env = os.environ.copy()
+    @property
+    def _endstone_runtime_env(self) -> dict[str, str]:
+        env = super()._endstone_runtime_env
         symbol_path = env.get("_NT_SYMBOL_PATH", "")
         symbol_path_list = symbol_path.split(os.pathsep)
         symbol_path_list = [
@@ -125,83 +152,36 @@ class WindowsBootstrap(Bootstrap):
             str(self.plugin_path.absolute()),
         ] + symbol_path_list
         env["_NT_SYMBOL_PATH"] = os.pathsep.join(symbol_path_list)
+        return env
 
-        # Create the process is a suspended state
-        super()._create_process(creationflags=CREATE_SUSPENDED, env=env)
-        handle_proc = int(self._process._handle)
-        lib_path = str(self._endstone_runtime_path.absolute())
-
-        # Validate dll
-        dll = kernel32.LoadLibraryExW(lib_path, None, DONT_RESOLVE_DLL_REFERENCES)
-        if not dll:
-            raise ValueError(f"LoadLibraryExW failed with error {get_last_error()}.")
-
-        # Allocate memory for lib_path
-        address = kernel32.VirtualAllocEx(
-            handle_proc,  # hProcess
-            0,  # lpAddress
-            MAX_PATH * 2 + 1,  # dwSize
-            DWORD(MEM_COMMIT | MEM_RESERVE),  # flAllocationType
-            DWORD(PAGE_READWRITE),  # flProtect
+    def _add_loopback_exemption(self) -> None:
+        sid = "S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436"
+        ret = subprocess.run(
+            ["CheckNetIsolation", "LoopbackExempt", "-s", f"-p={sid}"], check=True, capture_output=True
         )
-        if not address:
-            raise ValueError(f"VirtualAllocEx failed with error {get_last_error()}.")
+        if sid not in str(ret.stdout):
+            ret = ctypes.windll.shell32.ShellExecuteW(
+                None, "runas", "CheckNetIsolation", " ".join(["LoopbackExempt", "-a", f"-p={sid}"]), None, 1
+            )
+            if ret <= 32:
+                raise RuntimeError(f"CheckNetIsolation LoopbackExempt -a failed with exit code {ret}.")
+
+    def _run(self, *args, **kwargs) -> int:
+        try:
+            self._add_loopback_exemption()
+        except Exception as e:
+            self._logger.warning(
+                f"Unable to add loopback exemption: %s. See bedrock_server_how_to.html for more details. {e}"
+            )
 
-        # Write lib_path into the allocated memory
-        size_written = SIZE_T(0)
-        result = kernel32.WriteProcessMemory(
-            handle_proc, address, lib_path, len(lib_path) * 2 + 1, ctypes.byref(size_written)
+        process = PopenWithDll(
+            [str(self.executable_path.absolute())],
+            text=True,
+            encoding="utf-8",
+            cwd=str(self.server_path.absolute()),
+            env=self._endstone_runtime_env,
+            dll_names=str(self._endstone_runtime_path.absolute()),
+            *args,
+            **kwargs,
         )
-        if not result:
-            raise ValueError(f"WriteProcessMemory failed with error {get_last_error()}.")
-
-        # Get module handle of kernel32
-        handle_kernel32 = kernel32.GetModuleHandleW("kernel32.dll")
-        if not handle_kernel32:
-            raise ValueError(f"GetModuleHandleW failed with error {get_last_error()}.")
-
-        # Get address of LoadLibraryW
-        load_library = kernel32.GetProcAddress(handle_kernel32, b"LoadLibraryW")
-        if not load_library:
-            raise ValueError(f"GetProcAddress failed with error {get_last_error()}.")
-
-        # Start a new thread in the process, starting at LoadLibraryW with address as argument
-        remote_thread = kernel32.CreateRemoteThread(handle_proc, None, 0, load_library, address, 0, None)
-        if not remote_thread:
-            raise ValueError(f"CreateRemoteThread failed with error {get_last_error()}.")
-
-        # Wait for the remote thread to finish
-        if kernel32.WaitForSingleObject(remote_thread, INFINITE) == 0xFFFFFFFF:
-            raise ValueError(f"WaitForSingleObject failed with error {get_last_error()}.")
-
-        # Check dll load result
-        exit_code = DWORD()
-        result = kernel32.GetExitCodeThread(remote_thread, ctypes.byref(exit_code))
-        if result == 0:
-            raise ValueError(f"LoadLibrary failed with thread exit code: {exit_code.value}")
-
-        # Reopen the handle to process thread (which was closed by subprocess.Popen)
-        snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0)
-        if snapshot == INVALID_HANDLE_VALUE:
-            raise ValueError(f"CreateToolhelp32Snapshot failed with error {get_last_error()}.")
-
-        thread_entry = THREADENTRY32()
-        thread_entry.dwSize = ctypes.sizeof(thread_entry)
-        success = kernel32.Thread32First(snapshot, ctypes.byref(thread_entry))
-        if not success:
-            raise ValueError(f"Thread32First failed with error {get_last_error()}.")
-
-        handle_thread = None
-        while success:
-            if thread_entry.th32OwnerProcessID == self._process.pid:
-                handle_thread = kernel32.OpenThread(THREAD_ALL_ACCESS, None, thread_entry.th32ThreadID)
-                break
-
-            success = kernel32.Thread32Next(snapshot, ctypes.byref(thread_entry))
-
-        if handle_thread is None:
-            raise ValueError(f"OpenThread failed with error {get_last_error()}.")
-
-        # Resume main thread execution
-        kernel32.ResumeThread(handle_thread)
-        kernel32.CloseHandle(handle_thread)
+        return process.wait()