railmux 0.4.0.dev29__tar.gz → 0.4.0.dev31__tar.gz

{railmux-0.4.0.dev29/src/railmux.egg-info → railmux-0.4.0.dev31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev29
+Version: 0.4.0.dev31
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.0.dev31/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev31"

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/src/railmux/cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import os
+import signal
 import shutil
 import subprocess
 import sys
@@ -109,6 +110,9 @@ def _run_tmux_client_with_watchdog(
             attributes = termios.tcgetattr(sys.stdin.fileno())
         except (OSError, termios.error):
             pass
+    direct_terminal_size = (
+        _interactive_terminal_size() if managed_windows else None
+    )
     started_at = time.monotonic()
     try:
         popen_kwargs: dict[str, object] = {"env": env}
@@ -127,7 +131,7 @@ def _run_tmux_client_with_watchdog(
         *,
         asynchronous_probe: bool = False,
     ) -> tuple[int, bool]:
-        nonlocal expected_target, expected_session_id
+        nonlocal direct_terminal_size, expected_target, expected_session_id
         watchdog = tmux_health.FailureWatchdog.starting(
             (
                 time.monotonic()
@@ -151,6 +155,28 @@ def _run_tmux_client_with_watchdog(
             pump = getattr(process, "pump", None)
             if pump is None:
                 time.sleep(0.25)
+                if managed_windows:
+                    current_size = _interactive_terminal_size()
+                    if (
+                        current_size is not None
+                        and current_size != direct_terminal_size
+                    ):
+                        direct_terminal_size = current_size
+                        pid = getattr(process, "pid", None)
+                        if (
+                            isinstance(pid, int)
+                            and not isinstance(pid, bool)
+                            and pid > 0
+                        ):
+                            try:
+                                # MSYS2 occasionally misses the native
+                                # console's resize notification. Signal only
+                                # this launcher's direct tmux client so it
+                                # re-reads both dimensions; tmux remains the
+                                # authority for shared-window sizing.
+                                os.kill(pid, signal.SIGWINCH)
+                            except (OSError, ValueError):
+                                pass
             else:
                 pump(0.25)
             now = time.monotonic()

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/src/railmux/windows_install_log.py

@@ -22,6 +22,7 @@ from railmux.terminal_status import (
     STYLE_WARNING,
     styled,
 )
+from railmux.windows_paths import managed_windows_data_root
 
 
 _LOG_KEEP_COUNT = 5
@@ -79,14 +80,14 @@ def install_log_path(
     *,
     version: str,
     clock: Callable[[], float] = time.time,
+    data_root: Path | None = None,
 ) -> Path:
-    local_app_data = environ.get("LOCALAPPDATA", "").strip()
-    if not local_app_data:
-        raise OSError("LOCALAPPDATA is unavailable")
+    root = managed_windows_data_root(environ) if data_root is None else data_root
+    if root is None:
+        raise OSError("a non-virtualized Windows data directory is unavailable")
     stamp = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime(clock()))
     return (
-        Path(local_app_data)
-        / "Railmux"
+        root
         / "logs"
         / f"install-{version}-{stamp}-{os.getpid()}.log"
     )
@@ -323,7 +324,13 @@ class InstallReporter:
         if package_count is not None:
             self._package_total = int(package_count.group(1))
             self._package_step = max(1, self._package_total // 10)
-            self._progress_detail = f"preparing {self._package_total} packages"
+            self._progress_detail = (
+                f"waiting for the first transfer among "
+                f"{self._package_total} packages"
+            )
+            self.note(
+                f"Package transaction resolved: {self._package_total} packages."
+            )
             return
         total_download = _TOTAL_DOWNLOAD_RE.match(line)
         if total_download is not None:

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/src/railmux/windows_msys2.py

@@ -42,6 +42,10 @@ from railmux.windows_pacman import (
     validate_transaction_package_mirrors,
     write_msys_only_pacman_config,
 )
+from railmux.windows_paths import (
+    legacy_local_app_data_root,
+    managed_windows_data_root,
+)
 from railmux.terminal_status import STYLE_ACCENT, STYLE_MUTED, styled
 
 
@@ -554,17 +558,17 @@ class Msys2Runtime:
 
 
 def _managed_base(environ: Mapping[str, str]) -> Path | None:
-    local_app_data = environ.get("LOCALAPPDATA", "").strip()
-    if not local_app_data:
+    data_root = managed_windows_data_root(environ)
+    if data_root is None:
         return None
-    return Path(local_app_data) / "Railmux" / "runtimes"
+    return data_root / "runtimes"
 
 
 def _managed_cache(environ: Mapping[str, str]) -> Path | None:
-    local_app_data = environ.get("LOCALAPPDATA", "").strip()
-    if not local_app_data:
+    data_root = managed_windows_data_root(environ)
+    if data_root is None:
         return None
-    return Path(local_app_data) / "Railmux" / "cache"
+    return data_root / "cache"
 
 
 def _path_is_link_or_reparse(path: Path) -> bool:
@@ -595,6 +599,7 @@ def _prepare_cached_archive(
     cache: Path,
     *,
     downloader: Downloader | None,
+    prior_caches: Sequence[Path] = (),
 ) -> tuple[Path, str]:
     cache.mkdir(parents=True, exist_ok=True)
     archive = cache / MSYS2_ARCHIVE_NAME
@@ -604,6 +609,18 @@ def _prepare_cached_archive(
         archive.unlink(missing_ok=True)
     except OSError as exc:
         raise RuntimeInstallError("could not replace the private archive cache") from exc
+    for prior_cache in prior_caches:
+        prior_archive = prior_cache / MSYS2_ARCHIVE_NAME
+        if prior_archive == archive or not _archive_cache_is_valid(prior_archive):
+            continue
+        try:
+            shutil.copyfile(prior_archive, archive)
+        except OSError:
+            archive.unlink(missing_ok=True)
+            continue
+        if _archive_cache_is_valid(archive):
+            return archive, "verified prior local cache"
+        archive.unlink(missing_ok=True)
     source = download_from_sources(
         archive,
         MSYS2_ARCHIVE_SHA256,
@@ -1178,7 +1195,9 @@ def apply_managed_runtime_prune(
     """Re-plan under the install lock, then remove only unchanged candidates."""
     base = _managed_base(environ)
     if base is None:
-        raise RuntimeInstallError("LOCALAPPDATA is unavailable")
+        raise RuntimeInstallError(
+            "a non-virtualized Windows user data directory is unavailable"
+        )
     effective_lock = install_lock if lock_factory is None else lock_factory
     with effective_lock(base):
         current = plan_managed_runtime_prune(
@@ -2629,11 +2648,16 @@ def install_managed_runtime(
     base = _managed_base(environ)
     cache_base = _managed_cache(environ)
     if base is None or cache_base is None:
-        raise RuntimeInstallError("LOCALAPPDATA is unavailable")
+        raise RuntimeInstallError(
+            "a non-virtualized Windows user data directory is unavailable"
+        )
+    data_root = base.parent
     try:
         base.mkdir(parents=True, exist_ok=True)
         cache_base.mkdir(parents=True, exist_ok=True)
-        log_path = install_log_path(environ, version=version)
+        log_path = install_log_path(
+            environ, version=version, data_root=data_root
+        )
     except OSError as exc:
         raise RuntimeInstallError("could not create the private runtime log") from exc
     final_root = base / "shared" / MSYS2_RUNTIME_ID
@@ -2749,6 +2773,11 @@ def install_managed_runtime(
                     archive, source = _prepare_cached_archive(
                         cache_base,
                         downloader=downloader,
+                        prior_caches=tuple(
+                            legacy / "cache"
+                            for legacy in (legacy_local_app_data_root(environ),)
+                            if legacy is not None and legacy != data_root
+                        ),
                     )
                     reporter.done(source)
 

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/src/railmux/windows_pacman.py

@@ -30,7 +30,9 @@ _MIRRORLIST_LIMIT = 256 * 1024
 _PACMAN_CONF_LIMIT = 256 * 1024
 _PROBE_BYTES = 256 * 1024
 _PROBE_TIMEOUT = 8.0
+_PACKAGE_PROBE_BYTES = 256 * 1024
 _PACKAGE_PROBE_TIMEOUT = 5.0
+_PACKAGE_PROBE_MIN_RATE = 128 * 1024
 _SWITCH_RATIO = 1.25
 _FRESHNESS_WINDOW_SECONDS = 6 * 60 * 60
 _ZSTD_MAGIC = b"\x28\xb5\x2f\xfd"
@@ -91,18 +93,21 @@ def _probe_package_url(
     url: str,
     *,
     opener: Callable[..., object] = urllib.request.urlopen,
+    clock: Callable[[], float] = time.monotonic,
 ) -> None:
-    """Require one real package prefix instead of trusting database access."""
+    """Require a responsive real package path, not only database access."""
     if urllib.parse.urlsplit(url).scheme.lower() != "https":
         raise PacmanMirrorError("package URL is not HTTPS")
     request = urllib.request.Request(
         url,
         headers={
             "Accept-Encoding": "identity",
-            "Range": "bytes=0-1023",
+            "Range": f"bytes=0-{_PACKAGE_PROBE_BYTES - 1}",
             "User-Agent": "Railmux-pacman-package-probe/1",
         },
     )
+    started = clock()
+    data = bytearray()
     try:
         with opener(request, timeout=_PACKAGE_PROBE_TIMEOUT) as response:
             final_url = getattr(response, "geturl", lambda: request.full_url)()
@@ -111,15 +116,31 @@ def _probe_package_url(
             status = getattr(response, "status", 200)
             if status not in (200, 206):
                 raise PacmanMirrorError(f"package returned HTTP {status}")
-            data = response.read(1024)
+            while len(data) < _PACKAGE_PROBE_BYTES:
+                chunk = response.read(min(
+                    64 * 1024, _PACKAGE_PROBE_BYTES - len(data)
+                ))
+                if not chunk:
+                    break
+                data.extend(chunk)
+                if clock() - started >= _PACKAGE_PROBE_TIMEOUT:
+                    break
     except PacmanMirrorError:
         raise
     except urllib.error.HTTPError as exc:
         raise PacmanMirrorError(f"package returned HTTP {exc.code}") from exc
     except (OSError, urllib.error.URLError, http.client.HTTPException) as exc:
         raise PacmanMirrorError("package probe failed") from exc
+    elapsed = max(clock() - started, 0.001)
+    if len(data) < 1024:
+        raise PacmanMirrorError("mirror returned too little package data")
     if not data.startswith(_ZSTD_MAGIC):
         raise PacmanMirrorError("mirror did not return an MSYS package")
+    if (
+        elapsed >= _PACKAGE_PROBE_TIMEOUT
+        or len(data) / elapsed < _PACKAGE_PROBE_MIN_RATE
+    ):
+        raise PacmanMirrorError("package transfer was too slow")
 
 
 def probe_pacman_mirror(

railmux-0.4.0.dev31/src/railmux/windows_paths.py

@@ -0,0 +1,73 @@
+"""Stable native-Windows storage paths for the managed runtime.
+
+Microsoft Store and other MSIX-packaged Python interpreters can virtualize new
+writes beneath AppData.  Railmux's runtime contains executables that must be
+opened by child processes outside that virtualized view, so packaged Python
+uses a user-profile directory instead.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+
+
+_ERROR_INSUFFICIENT_BUFFER = 122
+_APPMODEL_ERROR_NO_PACKAGE = 15700
+_PACKAGED_PROFILE_DIRECTORY = ".railmux"
+_PACKAGED_WINDOWS_DIRECTORY = "windows"
+
+
+def _has_windows_package_identity() -> bool:
+    """Return whether this process has an MSIX/AppX package identity."""
+    if os.name != "nt":
+        return False
+    try:
+        get_family = ctypes.windll.kernel32.GetCurrentPackageFamilyName
+        length = ctypes.c_uint32(0)
+        result = int(get_family(ctypes.byref(length), None))
+    except (AttributeError, OSError, TypeError, ValueError):
+        return _looks_like_packaged_executable(sys.executable)
+    if result == _APPMODEL_ERROR_NO_PACKAGE:
+        return False
+    if result == _ERROR_INSUFFICIENT_BUFFER and length.value > 0:
+        return True
+    # A Store Python launcher and interpreter both have characteristic physical
+    # paths.  Keep this fallback fail-safe if the package API is unavailable or
+    # returns an unexpected platform error.
+    return _looks_like_packaged_executable(sys.executable)
+
+
+def _looks_like_packaged_executable(executable: str) -> bool:
+    normalized = executable.replace("/", "\\").casefold()
+    return "\\windowsapps\\" in normalized or (
+        "\\appdata\\local\\packages\\" in normalized and "\\localcache\\" in normalized
+    )
+
+
+def managed_windows_data_root(environ: Mapping[str, str]) -> Path | None:
+    """Select one data root visible to both Python and MSYS2 child processes."""
+    if _has_windows_package_identity():
+        user_profile = environ.get("USERPROFILE", "").strip()
+        if not user_profile:
+            return None
+        return (
+            Path(user_profile)
+            / _PACKAGED_PROFILE_DIRECTORY
+            / _PACKAGED_WINDOWS_DIRECTORY
+        )
+    local_app_data = environ.get("LOCALAPPDATA", "").strip()
+    if not local_app_data:
+        return None
+    return Path(local_app_data) / "Railmux"
+
+
+def legacy_local_app_data_root(environ: Mapping[str, str]) -> Path | None:
+    """Return the pre-packaged-Python-fix location for read-only cache reuse."""
+    local_app_data = environ.get("LOCALAPPDATA", "").strip()
+    if not local_app_data:
+        return None
+    return Path(local_app_data) / "Railmux"

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev29
+Version: 0.4.0.dev31
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/src/railmux.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ src/railmux/windows_bootstrap.py
 src/railmux/windows_install_log.py
 src/railmux/windows_msys2.py
 src/railmux/windows_pacman.py
+src/railmux/windows_paths.py
 src/railmux/windows_tmux_lifecycle.py
 src/railmux/windows_ui_transition.py
 src/railmux.egg-info/PKG-INFO
@@ -168,6 +169,7 @@ tests/test_windows_bootstrap.py
 tests/test_windows_install_log.py
 tests/test_windows_msys2.py
 tests/test_windows_pacman.py
+tests/test_windows_paths.py
 tests/test_windows_tmux_lifecycle.py
 tests/test_windows_ui_transition.py
 tests/test_windows_wrapper_contract.py

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/tests/test_cli.py

@@ -1,4 +1,5 @@
 import os
+import signal
 import subprocess
 import sys
 from unittest.mock import MagicMock, patch
@@ -632,6 +633,80 @@ def test_local_tmux_watchdog_exits_and_records_after_consecutive_failures(
     assert "stopped responding" in capsys.readouterr().err
 
 
+def test_managed_windows_direct_attach_notifies_height_only_resize(monkeypatch):
+    target = TmuxServerTarget("/tmp/railmux", 77)
+
+    class DirectClient:
+        pid = 321
+        returncode = None
+
+        def poll(self):
+            return self.returncode
+
+    client = DirectClient()
+    monkeypatch.setattr(
+        "railmux.cli.subprocess.Popen", lambda *_args, **_kwargs: client)
+    monkeypatch.setattr("railmux.cli.sys.stdin.isatty", lambda: True)
+    monkeypatch.setattr("railmux.cli.sys.stdout.isatty", lambda: True)
+    monkeypatch.setattr("railmux.cli.termios.tcgetattr", lambda _fd: ["saved"])
+    sizes = [os.terminal_size((120, 40)), os.terminal_size((120, 55))]
+    monkeypatch.setattr(
+        "railmux.cli.os.get_terminal_size",
+        lambda _fd: sizes.pop(0) if len(sizes) > 1 else sizes[0],
+    )
+
+    def finish_after_poll(_seconds):
+        client.returncode = 0
+
+    monkeypatch.setattr("railmux.cli.time.sleep", finish_after_poll)
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: True,
+    )
+    notify = MagicMock()
+    monkeypatch.setattr("railmux.cli.os.kill", notify)
+
+    assert _run_tmux_client_with_watchdog(
+        ["tmux", "-L", "railmux"], {}, expected_target=target,
+        expected_session_id="$7",
+    ) == 0
+    notify.assert_called_once_with(321, signal.SIGWINCH)
+
+
+def test_posix_direct_attach_does_not_poll_or_signal_resize(monkeypatch):
+    class DirectClient:
+        pid = 321
+        returncode = None
+
+        def poll(self):
+            return self.returncode
+
+    client = DirectClient()
+    monkeypatch.setattr(
+        "railmux.cli.subprocess.Popen", lambda *_args, **_kwargs: client)
+    monkeypatch.setattr("railmux.cli.sys.stdin.isatty", lambda: True)
+    monkeypatch.setattr("railmux.cli.termios.tcgetattr", lambda _fd: ["saved"])
+
+    def finish_after_poll(_seconds):
+        client.returncode = 0
+
+    monkeypatch.setattr("railmux.cli.time.sleep", finish_after_poll)
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: False,
+    )
+    get_size = MagicMock()
+    notify = MagicMock()
+    monkeypatch.setattr("railmux.cli.os.get_terminal_size", get_size)
+    monkeypatch.setattr("railmux.cli.os.kill", notify)
+
+    assert _run_tmux_client_with_watchdog(
+        ["tmux", "-L", "railmux"], {},
+    ) == 0
+    get_size.assert_not_called()
+    notify.assert_not_called()
+
+
 def test_abrupt_tmux_client_exit_records_disappeared_server(monkeypatch):
     target = TmuxServerTarget("/tmp/railmux", 77)
 

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/tests/test_windows_install_log.py

@@ -223,6 +223,25 @@ def test_log_path_is_private_versioned_and_utc(tmp_path, monkeypatch):
     )
 
 
+def test_log_path_uses_packaged_python_non_virtualized_root(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        windows_install_log,
+        "managed_windows_data_root",
+        lambda _environ: tmp_path / ".railmux" / "windows",
+    )
+
+    path = install_log_path(
+        {
+            "LOCALAPPDATA": str(tmp_path / "AppData" / "Local"),
+            "USERPROFILE": str(tmp_path),
+        },
+        version="0.4.0.dev30",
+        clock=lambda: 0,
+    )
+
+    assert path.parent == tmp_path / ".railmux" / "windows" / "logs"
+
+
 def test_default_command_runner_uses_no_stdin_and_captures_utf8(tmp_path):
     stream = io.StringIO()
     path = tmp_path / "install-0.4.0.dev7-20260803T000000Z-4.log"
@@ -291,6 +310,7 @@ def test_compact_reporter_surfaces_extraction_and_package_progress(tmp_path):
     assert "Extracting private runtime: 42%" in rendered
     assert "Extracting private runtime: 100%" in rendered
     assert "Package transaction: 48 packages, 57.40 MiB download." in rendered
+    assert "Package transaction resolved: 48 packages." in rendered
     assert "Downloading packages: 1/48" in rendered
     assert "Verifying downloaded package signatures" in rendered
     assert "Installing packages: 1/48" in rendered

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/tests/test_windows_msys2.py

@@ -628,6 +628,22 @@ def test_preview_versions_share_one_base_but_use_separate_app_layers(tmp_path):
     )
 
 
+def test_packaged_python_runtime_root_avoids_local_app_data(tmp_path, monkeypatch):
+    safe = tmp_path / ".railmux" / "windows"
+    monkeypatch.setattr(
+        windows_msys2, "managed_windows_data_root", lambda _environ: safe
+    )
+    environ = {
+        "LOCALAPPDATA": str(tmp_path / "AppData" / "Local"),
+        "USERPROFILE": str(tmp_path),
+    }
+
+    assert managed_root(environ) == (
+        safe / "runtimes" / "shared" / windows_msys2.MSYS2_RUNTIME_ID
+    )
+    assert windows_msys2._managed_cache(environ) == safe / "cache"
+
+
 def test_explicit_user_runtime_is_probed_but_never_requires_managed_marker(tmp_path):
     root = tmp_path / "用户-owned-msys"
     runtime = make_runtime(root, managed=False)
@@ -1268,6 +1284,57 @@ def test_verified_base_archive_cache_avoids_a_second_download(tmp_path, monkeypa
     assert source == "verified local cache"
 
 
+def test_packaged_python_reuses_verified_pre_fix_archive_cache(tmp_path, monkeypatch):
+    payload = b"verified prior cache archive"
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_SIZE", len(payload))
+    monkeypatch.setattr(
+        windows_msys2,
+        "MSYS2_ARCHIVE_SHA256",
+        hashlib.sha256(payload).hexdigest(),
+    )
+    prior = tmp_path / "virtualized-cache"
+    prior.mkdir()
+    (prior / MSYS2_ARCHIVE_NAME).write_bytes(payload)
+    current = tmp_path / "non-virtualized-cache"
+
+    selected, source = windows_msys2._prepare_cached_archive(
+        current,
+        downloader=lambda *_args: pytest.fail("prior cache should avoid downloading"),
+        prior_caches=(prior,),
+    )
+
+    assert selected.read_bytes() == payload
+    assert source == "verified prior local cache"
+
+
+def test_packaged_python_never_reuses_unverified_pre_fix_archive(
+    tmp_path, monkeypatch
+):
+    payload = b"expected archive"
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_SIZE", len(payload))
+    monkeypatch.setattr(
+        windows_msys2,
+        "MSYS2_ARCHIVE_SHA256",
+        hashlib.sha256(payload).hexdigest(),
+    )
+    prior = tmp_path / "virtualized-cache"
+    prior.mkdir()
+    (prior / MSYS2_ARCHIVE_NAME).write_bytes(b"tampered archive")
+    current = tmp_path / "non-virtualized-cache"
+
+    def downloader(_url, destination, _sha256):
+        destination.write_bytes(payload)
+
+    selected, source = windows_msys2._prepare_cached_archive(
+        current,
+        downloader=downloader,
+        prior_caches=(prior,),
+    )
+
+    assert selected.read_bytes() == payload
+    assert source in {label for label, _url in MSYS2_ARCHIVE_SOURCES}
+
+
 def _write_test_tar(path: Path, entries: list[tuple[tarfile.TarInfo, bytes]]) -> None:
     with tarfile.open(path, mode="w:xz") as archive:
         for member, payload in entries:

{railmux-0.4.0.dev29 → railmux-0.4.0.dev31}/tests/test_windows_pacman.py

@@ -10,6 +10,7 @@ from railmux.windows_pacman import (
     PACMAN_MIRROR_SOURCES,
     PacmanMirrorError,
     PacmanMirrorProbe,
+    _probe_package_url,
     deactivate_pacman_hosts,
     optimize_pacman_mirror,
     probe_pacman_mirror,
@@ -231,6 +232,40 @@ def test_network_probe_is_bounded_and_rejects_an_https_downgrade():
     assert requests[0][1] == 8.0
 
 
+def test_package_probe_measures_a_real_bounded_transfer():
+    requests = []
+
+    def opener(request, *, timeout):
+        requests.append((request, timeout))
+        return FakeResponse(
+            b"\x28\xb5\x2f\xfd" + b"x" * (256 * 1024),
+            final_url="https://mirror.invalid/python.pkg.tar.zst",
+        )
+
+    _probe_package_url(
+        "https://mirror.invalid/python.pkg.tar.zst",
+        opener=opener,
+        clock=lambda: 1.0,
+    )
+
+    assert requests[0][0].get_header("Range") == "bytes=0-262143"
+    assert requests[0][1] == 5.0
+
+
+def test_package_probe_rejects_a_working_but_slow_source():
+    times = [0.0, 3.0]
+
+    with pytest.raises(PacmanMirrorError, match="too slow"):
+        _probe_package_url(
+            "https://mirror.invalid/python.pkg.tar.zst",
+            opener=lambda _request, **_kwargs: FakeResponse(
+                b"\x28\xb5\x2f\xfd" + b"x" * (256 * 1024),
+                final_url="https://mirror.invalid/python.pkg.tar.zst",
+            ),
+            clock=lambda: times.pop(0) if len(times) > 1 else times[0],
+        )
+
+
 def test_optimizer_limits_active_pool_but_reprobes_inactive_candidates(tmp_path):
     mirrorlist = write_mirrorlist(tmp_path)
     nju = PACMAN_MIRROR_SOURCES[-1][1]