railmux 0.4.0.dev35__tar.gz → 0.4.0.dev36__tar.gz

{railmux-0.4.0.dev35/src/railmux.egg-info → railmux-0.4.0.dev36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev35
+Version: 0.4.0.dev36
 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.dev36/src/railmux/__init__.py

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

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/src/railmux/provider_paths.py

@@ -9,13 +9,15 @@ import sys
 from collections.abc import Mapping
 from pathlib import Path
 
+from railmux.release_version import PROJECT_VERSION_PATTERN
+
 
 _DRIVE_PATH = re.compile(r"^(?:\\\\\?\\)?([A-Za-z]):[\\/](.*)\Z")
 _MANAGED_BASE_MARKER = Path("/railmux-base.json")
 _MANAGED_BASE_CONTENT_MARKER = Path("/railmux-base-content-v1.json")
 _MANAGED_APP_ROOT = Path("/opt/railmux/apps")
 _MANAGED_APP_ID = re.compile(
-    r"railmux-[0-9]+(?:\.[0-9]+)*(?:\.dev[0-9]+)?\Z"
+    rf"railmux-{PROJECT_VERSION_PATTERN}\Z"
 )
 
 

railmux-0.4.0.dev36/src/railmux/release_version.py

@@ -0,0 +1,111 @@
+"""Narrow version grammar shared by managed Windows app-layer identities."""
+from __future__ import annotations
+
+import re
+from functools import total_ordering
+from typing import Any
+
+
+class InvalidVersion(ValueError):
+    """A version is outside Railmux's canonical persisted grammar."""
+
+
+@total_ordering
+class ProjectVersion:
+    """Small standard-library ordering type for native bootstrap identities."""
+
+    __slots__ = ("_key", "_value")
+
+    def __init__(
+        self,
+        value: str,
+        release: tuple[int, ...],
+        stage: int,
+        stage_number: int,
+    ) -> None:
+        normalized = release
+        while len(normalized) > 1 and normalized[-1] == 0:
+            normalized = normalized[:-1]
+        self._value = value
+        self._key = (normalized, stage, stage_number)
+
+    def __str__(self) -> str:
+        return self._value
+
+    def __repr__(self) -> str:
+        return f"ProjectVersion({self._value!r})"
+
+    def __hash__(self) -> int:
+        return hash(self._key)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, ProjectVersion):
+            return NotImplemented
+        return self._key == other._key
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, ProjectVersion):
+            return NotImplemented
+        return self._key < other._key
+
+
+# Railmux app directories are security-sensitive persisted identities.  Accept
+# only the spellings that this project publishes: a final, an RC, or a
+# development release.  PEP 440 aliases, epochs, post releases, and local
+# versions are deliberately excluded so equal versions have one path spelling.
+_CANONICAL_INTEGER_PATTERN = r"(?:0|[1-9][0-9]*)"
+PROJECT_VERSION_PATTERN = (
+    rf"{_CANONICAL_INTEGER_PATTERN}"
+    rf"(?:\.{_CANONICAL_INTEGER_PATTERN})*"
+    rf"(?:rc{_CANONICAL_INTEGER_PATTERN}|\.dev{_CANONICAL_INTEGER_PATTERN})?"
+)
+PROJECT_VERSION_RE = re.compile(PROJECT_VERSION_PATTERN + r"\Z")
+_PROJECT_VERSION_PARTS_RE = re.compile(
+    rf"(?P<release>{_CANONICAL_INTEGER_PATTERN}"
+    rf"(?:\.{_CANONICAL_INTEGER_PATTERN})*)"
+    rf"(?:(?:rc(?P<rc>{_CANONICAL_INTEGER_PATTERN}))|"
+    rf"(?:\.dev(?P<dev>{_CANONICAL_INTEGER_PATTERN})))?\Z"
+)
+
+
+def parse_project_version(value: str) -> ProjectVersion:
+    """Return the canonical supported Railmux version or raise InvalidVersion."""
+    match = _PROJECT_VERSION_PARTS_RE.fullmatch(value)
+    if match is None:
+        raise InvalidVersion(value)
+    release_parts = match.group("release").split(".")
+    stage_text = match.group("rc") or match.group("dev")
+    numeric_parts = release_parts + ([stage_text] if stage_text else [])
+    if any(
+        len(part) > 1 and part.startswith("0")
+        for part in numeric_parts
+    ):
+        raise InvalidVersion(
+            f"non-canonical Railmux version spelling: {value!r}"
+        )
+    if match.group("dev") is not None:
+        stage = 0
+        stage_number = int(match.group("dev"))
+    elif match.group("rc") is not None:
+        stage = 1
+        stage_number = int(match.group("rc"))
+    else:
+        stage = 2
+        stage_number = 0
+    return ProjectVersion(
+        value,
+        tuple(int(part) for part in release_parts),
+        stage,
+        stage_number,
+    )
+
+
+def is_project_version(value: object) -> bool:
+    """Return whether *value* is one canonical published-version spelling."""
+    if not isinstance(value, str):
+        return False
+    try:
+        parse_project_version(value)
+    except InvalidVersion:
+        return False
+    return True

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/src/railmux/windows_msys2.py

@@ -47,6 +47,13 @@ from railmux.windows_paths import (
     legacy_local_app_data_root,
     managed_windows_data_root,
 )
+from railmux.release_version import (
+    PROJECT_VERSION_PATTERN,
+    PROJECT_VERSION_RE,
+    ProjectVersion,
+    is_project_version,
+    parse_project_version,
+)
 from railmux.terminal_status import STYLE_ACCENT, STYLE_MUTED, styled
 
 
@@ -108,7 +115,7 @@ _DOWNLOAD_PROBE_TIMEOUT = 10.0
 _DOWNLOAD_SLOW_REMAINING_SECONDS = 60.0
 _DOWNLOAD_SWITCH_RATIO = 1.25
 _CONTENT_RANGE_RE = re.compile(r"bytes (\d+)-(\d+)/(\d+)\Z")
-_VERSION_RE = re.compile(r"[0-9]+(?:\.[0-9]+)*(?:\.dev[0-9]+)?\Z")
+_VERSION_RE = PROJECT_VERSION_RE
 
 _PACMAN_CONFIG = "/etc/railmux-pacman.conf"
 _PACMAN_PACKAGES = "tmux python python-pip"
@@ -1077,10 +1084,8 @@ def _app_marker_matches(root: Path, *, app_name: str, version: str) -> bool:
     )
 
 
-def _version_key(version: str) -> tuple[tuple[int, ...], int]:
-    base, separator, dev = version.partition(".dev")
-    numbers = tuple(int(part) for part in base.split("."))
-    return numbers, int(dev) if separator else sys.maxsize
+def _version_key(version: str) -> ProjectVersion:
+    return parse_project_version(version)
 
 
 def _marked_app_versions(root: Path) -> dict[str, Path] | None:
@@ -1113,7 +1118,7 @@ def _marked_app_versions(root: Path) -> dict[str, Path] | None:
             continue
         version = candidate.name[len(prefix):]
         if (
-            _VERSION_RE.fullmatch(version)
+            is_project_version(version)
             and _app_marker_matches(
                 root, app_name=candidate.name, version=version)
         ):
@@ -1144,8 +1149,8 @@ def _in_use_app_names(
     except UnicodeDecodeError:
         return None
     pattern = re.compile(
-        r"(?:^|/)opt/railmux/apps/"
-        r"(railmux-[0-9]+(?:\.[0-9]+)*(?:\.dev[0-9]+)?)(?:/|$)"
+        rf"(?:^|/)opt/railmux/apps/"
+        rf"(railmux-{PROJECT_VERSION_PATTERN})(?:/|$)"
     )
     return frozenset(match.group(1) for match in pattern.finditer(text))
 
@@ -1158,7 +1163,7 @@ def plan_managed_runtime_prune(
     probe: Probe = _probe,
 ) -> RuntimePrunePlan:
     """Build a fail-closed plan without deleting any file."""
-    if not _VERSION_RE.fullmatch(version):
+    if not is_project_version(version):
         raise RuntimeInstallError("the Railmux package version is invalid")
     if environ.get(_RUNTIME_OVERRIDE, "").strip():
         raise RuntimeInstallError(
@@ -1277,7 +1282,7 @@ def _find_shared_root(base: Path) -> Path | None:
     if _base_marker_matches(canonical):
         return canonical
     legacy_parent = base / MSYS2_RUNTIME_ID
-    candidates: list[tuple[tuple[tuple[int, ...], int], Path]] = []
+    candidates: list[tuple[ProjectVersion, Path]] = []
     try:
         paths = list(legacy_parent.glob("railmux-*"))
     except OSError:
@@ -1288,7 +1293,7 @@ def _find_shared_root(base: Path) -> Path | None:
         if (
             not candidate.is_symlink()
             and _base_marker_matches(candidate)
-            and _VERSION_RE.fullmatch(version)
+            and is_project_version(version)
         ):
             candidates.append((_version_key(version), candidate))
     if candidates:
@@ -2332,7 +2337,7 @@ def _write_app_marker(app_root: Path, *, version: str) -> None:
 
 def _legacy_candidates(base: Path) -> list[tuple[Path, str]]:
     parent = base / MSYS2_RUNTIME_ID
-    candidates: list[tuple[tuple[tuple[int, ...], int], Path, str]] = []
+    candidates: list[tuple[ProjectVersion, Path, str]] = []
     try:
         paths = list(parent.glob("railmux-*"))
     except OSError:
@@ -2346,7 +2351,7 @@ def _legacy_candidates(base: Path) -> list[tuple[Path, str]]:
         version = payload.get("railmux")
         if (
             not isinstance(version, str)
-            or not _VERSION_RE.fullmatch(version)
+            or not is_project_version(version)
             or payload
             != {
                 "schema": RUNTIME_SCHEMA,
@@ -2492,11 +2497,21 @@ def _venv_site_packages(application: Path) -> Path | None:
 def _native_application_payload(version: str) -> tuple[Path, Path] | None:
     """Locate the currently executing pure-Python package and dist-info."""
     try:
-        distribution = importlib_metadata.distribution("railmux")
-    except importlib_metadata.PackageNotFoundError:
+        matches = [
+            distribution
+            for distribution in importlib_metadata.distributions(name="railmux")
+            if distribution.version == version
+        ]
+    except (OSError, ValueError):
         return None
-    if distribution.version != version:
+    # A long-lived Windows test/user environment can retain an old dist-info
+    # directory even though pip installed the current package code. Selecting
+    # ``distribution("railmux")`` would then be order-dependent and could
+    # force an unnecessary network fallback. Never delete metadata here; use
+    # the unique distribution whose version exactly matches the imported app.
+    if len(matches) != 1:
         return None
+    distribution = matches[0]
     package = Path(__file__).resolve().parent
     if not package.is_dir():
         return None
@@ -2965,7 +2980,7 @@ def install_managed_runtime(
     reuse_only: bool = False,
 ) -> Msys2Runtime:
     """Install a fresh private runtime and activate it only after verification."""
-    if not _VERSION_RE.fullmatch(version):
+    if not is_project_version(version):
         raise RuntimeInstallError("the Railmux package version is invalid")
     if environ.get(_RUNTIME_OVERRIDE, "").strip():
         raise RuntimeInstallError(

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/src/railmux/windows_ui_transition.py

@@ -23,6 +23,7 @@ from typing import Iterator, Mapping, Sequence
 from packaging.version import InvalidVersion, Version
 
 from railmux import restart_state, tmux_server
+from railmux.release_version import PROJECT_VERSION_PATTERN
 from railmux.windows_msys2 import MSYS2_BASE_LINEAGE_SHA256
 
 
@@ -31,7 +32,7 @@ REQUESTED_APP_OPTION = "@railmux_requested_app_v1"
 TRANSITION_STATUS_OPTION = "@railmux_app_transition_status_v1"
 UPGRADE_WAKE_SEQUENCE = "\x1b[33~"
 _APP_RE = re.compile(
-    r"railmux-([0-9]+(?:\.[0-9]+)*(?:\.dev[0-9]+)?)\Z"
+    rf"railmux-({PROJECT_VERSION_PATTERN})\Z"
 )
 _CONTENT_RE = re.compile(r"[0-9a-f]{64}\Z")
 _PANE_RE = re.compile(r"%[0-9]+\Z")
@@ -557,7 +558,7 @@ def _pane_app_version(
         pass
     pattern = re.compile(
         r"/opt/railmux/apps/railmux-"
-        r"([0-9]+(?:\.[0-9]+)*(?:\.dev[0-9]+)?)/venv/bin/railmux"
+        rf"({PROJECT_VERSION_PATTERN})/venv/bin/railmux"
     )
     for candidate in candidates:
         match = pattern.search(candidate)
@@ -663,7 +664,7 @@ def ensure_current_ui(
     runtime: str,
     target_app: str,
     target_version: str,
-    timeout: float = 8.0,
+    timeout: float = 15.0,
 ) -> TransitionOutcome:
     """Converge a detached managed outer UI without touching providers."""
     content_id = _base_identity(runtime)

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev35
+Version: 0.4.0.dev36
 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.dev35 → railmux-0.4.0.dev36}/src/railmux.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ src/railmux/path_codec.py
 src/railmux/preview_pager.py
 src/railmux/project_favorites.py
 src/railmux/provider_paths.py
+src/railmux/release_version.py
 src/railmux/remote_config.py
 src/railmux/renames.py
 src/railmux/restart_state.py
@@ -126,6 +127,7 @@ tests/test_project_favorites.py
 tests/test_projects_pane.py
 tests/test_provider_paths.py
 tests/test_release_notes.py
+tests/test_release_version.py
 tests/test_release_workflow.py
 tests/test_remote_config.py
 tests/test_renames.py

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/tests/test_release_notes.py

@@ -79,6 +79,21 @@ def test_renders_development_release_section():
     )
 
 
+def test_renders_release_candidate_section():
+    changelog = (
+        "## [0.4.0rc1] - 2026-08-07\n\n"
+        "- Release candidate.\n\n"
+        "[0.4.0rc1]: "
+        "https://example.test/compare/v0.4.0.dev36...v0.4.0rc1\n"
+    )
+
+    assert render_release_notes(changelog, "v0.4.0rc1") == (
+        "- Release candidate.\n\n"
+        "**Full Changelog**: "
+        "https://example.test/compare/v0.4.0.dev36...v0.4.0rc1\n"
+    )
+
+
 def test_last_section_does_not_include_changelog_link_definitions():
     notes = render_release_notes(CHANGELOG, "0.2.30")
 
@@ -89,7 +104,17 @@ def test_last_section_does_not_include_changelog_link_definitions():
 
 @pytest.mark.parametrize(
     "version",
-    ["0.2.4", "Unreleased", "v0.2", "0.2.3-dev1", "0.2.3.dev"],
+    [
+        "0.2.4",
+        "Unreleased",
+        "v0.2",
+        "0.2.3-dev1",
+        "0.2.3.dev",
+        "00.2.3",
+        "0.02.3",
+        "0.2.03",
+        "0.2.3rc01",
+    ],
 )
 def test_rejects_missing_or_invalid_release(version):
     with pytest.raises(ValueError):

railmux-0.4.0.dev36/tests/test_release_version.py

@@ -0,0 +1,128 @@
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from railmux import __version__, provider_paths, windows_msys2
+from railmux import windows_ui_transition
+from railmux.release_version import (
+    InvalidVersion,
+    is_project_version,
+    parse_project_version,
+)
+from tools.release_notes import normalize_version
+
+
+ROOT = Path(__file__).parents[1]
+
+
+@pytest.mark.parametrize(
+    "version",
+    ["0.4.0.dev35", "0.4.0.dev36", "0.4.0rc1", "0.4.0", "1.2.3"],
+)
+def test_every_persisted_version_consumer_accepts_release_spellings(version):
+    app = f"railmux-{version}"
+
+    assert is_project_version(version)
+    assert windows_msys2._VERSION_RE.fullmatch(version)
+    assert windows_ui_transition._APP_RE.fullmatch(app)
+    assert provider_paths._MANAGED_APP_ID.fullmatch(app)
+    assert normalize_version(f"v{version}") == version
+
+
+@pytest.mark.parametrize(
+    "version",
+    [
+        "0.4.0-rc1",
+        "0.4.0RC1",
+        "0.4.0rc01",
+        "0.4.0.dev01",
+        "00.4.0",
+        "0.04.0",
+        "0.4.00",
+        "0.4.0a1",
+        "0.4.0b1",
+        "0.4.0.post1",
+        "0.4.0+local",
+        "1!0.4.0",
+    ],
+)
+def test_persisted_version_grammar_rejects_aliases_and_unsupported_forms(version):
+    with pytest.raises(InvalidVersion):
+        parse_project_version(version)
+    app = f"railmux-{version}"
+    assert windows_msys2._VERSION_RE.fullmatch(version) is None
+    assert windows_ui_transition._APP_RE.fullmatch(app) is None
+    assert provider_paths._MANAGED_APP_ID.fullmatch(app) is None
+
+
+def test_release_order_matches_dev_to_rc_to_final():
+    versions = ["0.4.0", "0.4.0.dev35", "0.4.0rc1", "0.4.0.dev36"]
+
+    assert sorted(versions, key=windows_msys2._version_key) == [
+        "0.4.0.dev35",
+        "0.4.0.dev36",
+        "0.4.0rc1",
+        "0.4.0",
+    ]
+
+
+def test_release_order_crosses_the_next_development_base():
+    versions = ["0.4.1.dev1", "0.4.0", "0.4.0rc2", "0.4.0.dev99"]
+
+    assert sorted(versions, key=parse_project_version) == [
+        "0.4.0.dev99",
+        "0.4.0rc2",
+        "0.4.0",
+        "0.4.1.dev1",
+    ]
+
+
+def test_package_version_uses_its_canonical_persisted_spelling():
+    assert str(parse_project_version(__version__)) == __version__
+
+
+def test_native_bootstrap_version_command_does_not_import_packaging():
+    code = f"""
+import importlib.abc
+import sys
+sys.path.insert(0, {str(ROOT / 'src')!r})
+class BlockPackaging(importlib.abc.MetaPathFinder):
+    def find_spec(self, fullname, path=None, target=None):
+        if fullname == 'packaging' or fullname.startswith('packaging.'):
+            raise ModuleNotFoundError(fullname)
+        return None
+sys.meta_path.insert(0, BlockPackaging())
+from railmux.windows_bootstrap import main
+raise SystemExit(main(['--version'], version_info=(3, 10)))
+"""
+
+    result = subprocess.run(
+        [sys.executable, "-c", code],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert result.stdout.startswith("railmux 0.4.0")
+
+
+def test_in_use_inventory_retains_an_rc_app_layer(tmp_path):
+    output = (
+        b"/opt/railmux/apps/railmux-0.4.0rc1/venv/bin/railmux\0"
+        b"/opt/railmux/apps/railmux-0.4.0.dev36/venv/bin/railmux\0"
+    )
+
+    result = windows_msys2._in_use_app_names(
+        tmp_path,
+        environ={},
+        probe=lambda argv, **kwargs: subprocess.CompletedProcess(
+            argv, 0, stdout=output, stderr=b""
+        ),
+    )
+
+    assert result == frozenset(
+        {"railmux-0.4.0rc1", "railmux-0.4.0.dev36"}
+    )

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/tests/test_windows_msys2.py

@@ -2200,6 +2200,49 @@ def test_runtime_status_distinguishes_reusable_base_from_current_app(tmp_path):
     assert snapshot["current_app"] is False
 
 
+def test_native_payload_selects_exact_version_among_stale_dist_info(
+    tmp_path, monkeypatch,
+):
+    current_info = tmp_path / "railmux-0.4.0rc1.dist-info"
+    stale_info = tmp_path / "railmux-0.4.0.dev33.dist-info"
+    current_info.mkdir()
+    stale_info.mkdir()
+
+    def distribution(version, info):
+        return SimpleNamespace(
+            version=version,
+            files=(Path(info.name) / "METADATA",),
+            locate_file=lambda relative: tmp_path / relative,
+        )
+
+    monkeypatch.setattr(
+        windows_msys2.importlib_metadata,
+        "distributions",
+        lambda **_kwargs: iter((
+            distribution("0.4.0.dev33", stale_info),
+            distribution("0.4.0rc1", current_info),
+        )),
+    )
+
+    payload = windows_msys2._native_application_payload("0.4.0rc1")
+
+    assert payload is not None
+    assert payload[1] == current_info
+
+
+def test_native_payload_rejects_duplicate_exact_metadata(tmp_path, monkeypatch):
+    info = tmp_path / "railmux-0.4.0rc1.dist-info"
+    info.mkdir()
+    distribution = SimpleNamespace(version="0.4.0rc1")
+    monkeypatch.setattr(
+        windows_msys2.importlib_metadata,
+        "distributions",
+        lambda **_kwargs: iter((distribution, distribution)),
+    )
+
+    assert windows_msys2._native_application_payload("0.4.0rc1") is None
+
+
 def test_prune_retains_current_previous_and_process_proven_layers(tmp_path):
     environ = {"LOCALAPPDATA": str(tmp_path)}
     root = managed_root(environ)
@@ -2222,6 +2265,29 @@ def test_prune_retains_current_previous_and_process_proven_layers(tmp_path):
     assert f"railmux-{VERSION}" in plan.retained_apps
 
 
+def test_prune_retains_running_rc_beyond_current_and_previous_layers(tmp_path):
+    environ = {"LOCALAPPDATA": str(tmp_path)}
+    root = managed_root(environ)
+    assert root is not None
+    make_runtime(root, managed=True, shared=True)
+    old_dev = add_marked_app(root, "0.4.0.dev36")
+    running_rc = add_marked_app(root, "0.4.0rc1")
+    final = add_marked_app(root, "0.4.0")
+    current = add_marked_app(root, "0.4.1.dev1")
+    in_use = b"/opt/railmux/apps/railmux-0.4.0rc1/venv/bin/railmux\0"
+
+    plan = windows_msys2.plan_managed_runtime_prune(
+        version="0.4.1.dev1",
+        environ=environ,
+        probe=lambda argv, **_kwargs: completed(argv, stdout=in_use),
+    )
+
+    assert plan.remove_apps == (old_dev,)
+    assert running_rc.name in plan.retained_apps
+    assert final.name in plan.retained_apps
+    assert current.name in plan.retained_apps
+
+
 def test_prune_ignores_unmarked_directories_and_fails_closed_on_process_probe(
     tmp_path,
 ):
@@ -2243,6 +2309,23 @@ def test_prune_ignores_unmarked_directories_and_fails_closed_on_process_probe(
     assert unmarked.is_dir()
 
 
+def test_prune_ignores_marked_noncanonical_version_directory(tmp_path):
+    environ = {"LOCALAPPDATA": str(tmp_path)}
+    root = managed_root(environ)
+    assert root is not None
+    make_runtime(root, managed=True, shared=True)
+    noncanonical = add_marked_app(root, "0.04.0")
+
+    plan = windows_msys2.plan_managed_runtime_prune(
+        version=VERSION,
+        environ=environ,
+        probe=lambda argv, **_kwargs: completed(argv, stdout=b""),
+    )
+
+    assert noncanonical not in plan.remove_apps
+    assert noncanonical.is_dir()
+
+
 def test_prune_refuses_linked_application_parent(tmp_path):
     environ = {"LOCALAPPDATA": str(tmp_path)}
     root = managed_root(environ)

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/tests/test_windows_ui_transition.py

@@ -165,7 +165,7 @@ def test_detached_cooperative_ui_requests_exact_upgrade(monkeypatch, tmp_path):
         "target_app": TARGET_APP,
         "target_version": TARGET_VERSION,
         "base_content_id": CONTENT,
-        "timeout": 8.0,
+        "timeout": 15.0,
     }]
 
 

{railmux-0.4.0.dev35 → railmux-0.4.0.dev36}/tools/release_notes.py

@@ -9,7 +9,10 @@ import sys
 from pathlib import Path
 
 
-_VERSION_RE = re.compile(r"\d+\.\d+\.\d+(?:\.dev\d+)?")
+_VERSION_RE = re.compile(
+    r"(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)"
+    r"(?:rc(?:0|[1-9]\d*)|\.dev(?:0|[1-9]\d*))?"
+)
 _SECTION_RE = re.compile(r"^## \[([^]]+)](?:\s+-\s+.+)?\s*$")
 _LINK_RE = re.compile(r"^\[([^]]+)]\s*:\s*(\S+)\s*$")
 
@@ -66,7 +69,7 @@ def main(argv: list[str] | None = None) -> int:
         "version",
         help=(
             "release version or tag, for example 0.2.3, v0.2.3, or "
-            "v0.2.4.dev1"
+            "v0.2.4.dev1, or v0.4.0rc1"
         ),
     )
     parser.add_argument(

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

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