arrayview 0.37.1__tar.gz → 0.38.1__tar.gz

{arrayview-0.37.1 → arrayview-0.38.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.37.1
+Version: 0.38.1
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview

{arrayview-0.37.1 → arrayview-0.38.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.37.1"
+version = "0.38.1"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"
@@ -43,7 +43,6 @@ dependencies = [
 
 [project.scripts]
 arrayview = "arrayview._launcher:arrayview"
-arrayview-codex = "arrayview._codex_open:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/arrayview"]

{arrayview-0.37.1 → arrayview-0.38.1}/src/arrayview/_launch_plan.py

@@ -41,7 +41,6 @@ class Invocation(_StrEnum):
     JULIA = "julia"
     MATLAB = "matlab"
     VSCODE_EXPLORER = "vscode_explorer"
-    CODEX = "codex"
 
 
 class Environment(_StrEnum):

{arrayview-0.37.1 → arrayview-0.38.1}/src/arrayview/_platform.py

@@ -6,6 +6,7 @@ import importlib.util
 import hashlib
 import json
 import os
+from collections.abc import Callable
 import subprocess
 import sys
 
@@ -450,6 +451,42 @@ def _process_is_alive(pid: object) -> bool:
         return False
 
 
+def _superseding_window_registration(
+    claimed_ids: list[str],
+    signal_dir: str,
+    read: Callable[[str], tuple[str, dict] | None],
+) -> tuple[str, dict] | None:
+    """Return the live window that replaced one of ``claimed_ids``, if unique.
+
+    Each registration lists the window ids it took over from, so a terminal left
+    holding a pre-reload id resolves to its own window rather than to a sibling
+    that merely shares a server root.  Two live windows claiming one id would be a
+    contradiction, so an ambiguous answer is refused instead of guessed.
+    """
+    if not claimed_ids:
+        return None
+    wanted = set(claimed_ids)
+    try:
+        filenames = os.listdir(signal_dir)
+    except OSError:
+        return None
+
+    matches: list[tuple[str, dict]] = []
+    for filename in filenames:
+        if not filename.startswith("window-") or not filename.endswith(".json"):
+            continue
+        candidate = read(filename[len("window-") : -len(".json")])
+        if candidate is None:
+            continue
+        superseded = candidate[1].get("supersedes")
+        if not isinstance(superseded, list):
+            continue
+        if wanted.intersection(item for item in superseded if isinstance(item, str)):
+            matches.append(candidate)
+
+    return matches[0] if len(matches) == 1 else None
+
+
 def _exact_vscode_window_registration(
     ipc: str | None = None,
 ) -> tuple[str, dict] | None:
@@ -461,6 +498,11 @@ def _exact_vscode_window_registration(
     remote registration is unsafe.  When direct window evidence is unavailable,
     match the live extension-host executable to the exact server root named by
     the terminal's NLS configuration, and only accept a unique match.
+
+    Reloading a window rotates its IPC socket and re-injects ``ARRAYVIEW_WINDOW_ID``
+    into new terminals only, so a terminal that predates the reload keeps naming a
+    window id that no longer registers.  The extension records the ids it replaced,
+    which turns that stale name back into an exact match on the window that owns it.
     """
     signal_dir = os.path.expanduser("~/.arrayview")
 
@@ -479,16 +521,23 @@ def _exact_vscode_window_registration(
             return None
         return window_id, registration
 
+    claimed_ids: list[str] = []
     registration = None
     if ipc:
         window_id = hashlib.sha256(ipc.encode()).hexdigest()[:16]
         if reg := _read(window_id):
             return reg
+        claimed_ids.append(window_id)
         registration = reg
     if registration is None:
         window_id = os.environ.get("ARRAYVIEW_WINDOW_ID")
-        if window_id and (reg := _read(window_id)):
-            return reg
+        if window_id:
+            if reg := _read(window_id):
+                return reg
+            claimed_ids.append(window_id)
+
+    if reg := _superseding_window_registration(claimed_ids, signal_dir, _read):
+        return reg
 
     exact_cli = _current_vscode_remote_cli()
     if exact_cli is None:

{arrayview-0.37.1 → arrayview-0.38.1}/src/arrayview/_vscode_browser.py

@@ -275,6 +275,12 @@ def _open_browser(
                         "ArrayView could not safely install its VS Code opener in "
                         "this exact remote window; no viewer request was sent."
                     )
+                elif _extension_state._VSCODE_EXT_NO_LIVE_WINDOW:
+                    detail = (
+                        "This terminal was opened before its VS Code window reloaded, "
+                        "so it still points at a window that no longer exists. Open a "
+                        "new terminal in the target window and retry."
+                    )
                 elif _extension_state._VSCODE_EXT_RELOAD_REQUIRED:
                     detail = (
                         "ArrayView's VS Code opener was installed; reload this exact "

{arrayview-0.37.1 → arrayview-0.38.1}/src/arrayview/_vscode_extension.py

@@ -54,7 +54,8 @@ _VSCODE_EXT_INSTALLED = False  # cached so we only check once per process
 _VSCODE_EXT_FRESH_INSTALL = False  # True if we just installed it this session
 _VSCODE_EXT_RELOAD_REQUIRED = False  # installed files are newer than the live host
 _VSCODE_EXT_INSTALL_FAILED = False  # automatic install could not complete safely
-_VSCODE_EXT_VERSION = "0.14.88"  # current bundled extension version
+_VSCODE_EXT_NO_LIVE_WINDOW = False  # no live host claims this terminal's window id
+_VSCODE_EXT_VERSION = "0.14.89"  # current bundled extension version
 _VSCODE_CONFIGURED_PORTS: set[int] = set()
 
 def _bundled_vscode_vsix_version(vsix_path: str) -> str | None:
@@ -471,9 +472,11 @@ def _ensure_vscode_extension(*, is_remote: bool | None = None) -> bool:
     """
     global _VSCODE_EXT_INSTALLED, _VSCODE_EXT_FRESH_INSTALL
     global _VSCODE_EXT_RELOAD_REQUIRED, _VSCODE_EXT_INSTALL_FAILED
+    global _VSCODE_EXT_NO_LIVE_WINDOW
     _VSCODE_EXT_FRESH_INSTALL = False
     _VSCODE_EXT_RELOAD_REQUIRED = False
     _VSCODE_EXT_INSTALL_FAILED = False
+    _VSCODE_EXT_NO_LIVE_WINDOW = False
 
     vsix_path = str(_pkg_files("arrayview").joinpath("arrayview-opener.vsix"))
     if not os.path.isfile(vsix_path):
@@ -496,6 +499,31 @@ def _ensure_vscode_extension(*, is_remote: bool | None = None) -> bool:
         and active_registration.get("extensionVersion") == active_version
         else None
     )
+    def _reject_unmatched_host(installed_version: str) -> bool:
+        """Record why the live host was rejected, so callers can advise correctly.
+
+        A version disagreement is fixed by reloading; an unidentifiable window is
+        not.  Conflating them tells the user to reload when the reload is what
+        stranded their terminal in the first place.
+        """
+        global _VSCODE_EXT_RELOAD_REQUIRED, _VSCODE_EXT_NO_LIVE_WINDOW
+        if active_version is None:
+            _VSCODE_EXT_NO_LIVE_WINDOW = True
+            _vprint(
+                f"[ArrayView] opener v{installed_version} is installed, but no live "
+                "VS Code window claims this terminal; open a new terminal in the "
+                "target window",
+                flush=True,
+            )
+            return False
+        _VSCODE_EXT_RELOAD_REQUIRED = True
+        _vprint(
+            f"[ArrayView] opener v{installed_version} is installed, but this VS Code "
+            "window is still running an older extension host; reload this window",
+            flush=True,
+        )
+        return False
+
     if _extension_on_disk(ext_version, vsix_path, remote=is_remote):
         active_matches = (
             active_version == ext_version
@@ -503,13 +531,7 @@ def _ensure_vscode_extension(*, is_remote: bool | None = None) -> bool:
             else active_version in (None, ext_version)
         )
         if not active_matches:
-            _VSCODE_EXT_RELOAD_REQUIRED = True
-            _vprint(
-                f"[ArrayView] opener v{ext_version} is installed, but this VS Code "
-                "window is still running an older extension host; reload this window",
-                flush=True,
-            )
-            return False
+            return _reject_unmatched_host(ext_version)
         if not is_remote:
             _remove_old_extension_versions(ext_version, remote=False)
         _VSCODE_EXT_INSTALLED = True
@@ -527,13 +549,7 @@ def _ensure_vscode_extension(*, is_remote: bool | None = None) -> bool:
             else active_version in (None, newer_version)
         )
         if not active_matches:
-            _VSCODE_EXT_RELOAD_REQUIRED = True
-            _vprint(
-                f"[ArrayView] newer opener v{newer_version} is installed, but this "
-                "VS Code window is still running an older extension host; reload this window",
-                flush=True,
-            )
-            return False
+            return _reject_unmatched_host(newer_version)
         _VSCODE_EXT_INSTALLED = True
         _vprint(
             f"[ArrayView] newer extension v{newer_version} is installed — keeping it",

{arrayview-0.37.1 → arrayview-0.38.1}/tests/test_api.py

@@ -5667,6 +5667,136 @@ class TestPortAndTunnelHelpers:
             is None
         )
 
+    def _write_reload_survivor_home(self, monkeypatch, tmp_path):
+        """Home whose only live window replaced the one this terminal remembers."""
+        import hashlib
+
+        home = tmp_path / "home"
+        signal_dir = home / ".arrayview"
+        signal_dir.mkdir(parents=True)
+        monkeypatch.setenv("HOME", str(home))
+        monkeypatch.delenv("ARRAYVIEW_WINDOW_ID", raising=False)
+        stale_ipc = "/run/user/1/vscode-ipc-before-reload.sock"
+        return signal_dir, stale_ipc, hashlib.sha256(stale_ipc.encode()).hexdigest()[:16]
+
+    def test_terminal_stranded_by_window_reload_resolves_via_supersedes(
+        self, monkeypatch, tmp_path
+    ):
+        import os
+        import arrayview._platform as platform
+
+        signal_dir, stale_ipc, stale_id = self._write_reload_survivor_home(
+            monkeypatch, tmp_path
+        )
+        (signal_dir / "window-after-reload.json").write_text(
+            json.dumps(
+                {
+                    "pid": os.getpid(),
+                    "hookTag": "after-reload",
+                    "remoteName": "tunnel",
+                    "extensionVersion": "0.14.89",
+                    "supersedes": [stale_id],
+                }
+            )
+        )
+
+        resolved = platform._exact_vscode_window_registration(stale_ipc)
+
+        assert resolved is not None
+        assert resolved[0] == "after-reload"
+        assert resolved[1]["extensionVersion"] == "0.14.89"
+
+    def test_stranded_terminal_resolves_stale_injected_window_id(
+        self, monkeypatch, tmp_path
+    ):
+        import os
+        import arrayview._platform as platform
+
+        home = tmp_path / "home"
+        signal_dir = home / ".arrayview"
+        signal_dir.mkdir(parents=True)
+        monkeypatch.setenv("HOME", str(home))
+        monkeypatch.setenv("ARRAYVIEW_WINDOW_ID", "pre-reload-id")
+        (signal_dir / "window-after-reload.json").write_text(
+            json.dumps(
+                {
+                    "pid": os.getpid(),
+                    "remoteName": "tunnel",
+                    "supersedes": ["older-still", "pre-reload-id"],
+                }
+            )
+        )
+
+        resolved = platform._exact_vscode_window_registration(None)
+
+        assert resolved is not None and resolved[0] == "after-reload"
+
+    def test_stranded_terminal_never_borrows_an_unrelated_window(
+        self, monkeypatch, tmp_path
+    ):
+        """A sibling window that never owned this terminal must not claim it."""
+        import os
+        import arrayview._platform as platform
+
+        signal_dir, stale_ipc, _stale_id = self._write_reload_survivor_home(
+            monkeypatch, tmp_path
+        )
+        (signal_dir / "window-unrelated.json").write_text(
+            json.dumps(
+                {
+                    "pid": os.getpid(),
+                    "remoteName": "tunnel",
+                    "supersedes": ["some-other-window"],
+                }
+            )
+        )
+        monkeypatch.setattr(platform, "_current_vscode_remote_cli", lambda: None)
+
+        assert platform._exact_vscode_window_registration(stale_ipc) is None
+
+    def test_contested_superseded_id_is_refused_rather_than_guessed(
+        self, monkeypatch, tmp_path
+    ):
+        import os
+        import arrayview._platform as platform
+
+        signal_dir, stale_ipc, stale_id = self._write_reload_survivor_home(
+            monkeypatch, tmp_path
+        )
+        for name in ("window-first.json", "window-second.json"):
+            (signal_dir / name).write_text(
+                json.dumps(
+                    {
+                        "pid": os.getpid(),
+                        "remoteName": "tunnel",
+                        "supersedes": [stale_id],
+                    }
+                )
+            )
+        monkeypatch.setattr(platform, "_current_vscode_remote_cli", lambda: None)
+
+        assert platform._exact_vscode_window_registration(stale_ipc) is None
+
+    def test_dead_superseding_window_does_not_resolve(self, monkeypatch, tmp_path):
+        """Lineage is not enough — the claiming host must still be running."""
+        import arrayview._platform as platform
+
+        signal_dir, stale_ipc, stale_id = self._write_reload_survivor_home(
+            monkeypatch, tmp_path
+        )
+        (signal_dir / "window-dead.json").write_text(
+            json.dumps(
+                {
+                    "pid": 2**31 - 1,
+                    "remoteName": "tunnel",
+                    "supersedes": [stale_id],
+                }
+            )
+        )
+        monkeypatch.setattr(platform, "_current_vscode_remote_cli", lambda: None)
+
+        assert platform._exact_vscode_window_registration(stale_ipc) is None
+
     def test_code_cli_selection_uses_captured_placement(self, monkeypatch):
         import glob
         import shutil

{arrayview-0.37.1 → arrayview-0.38.1}/tests/test_invocation_contract_matrix.py

@@ -73,10 +73,6 @@ CONTRACT_CASES = (
         "python_plain_ssh", Invocation.PYTHON, Environment.SSH,
         ServerOwner.IN_PROCESS, Registration.IN_PROCESS_SESSION, Display.BROWSER,
     ),
-    ContractCase(
-        "codex_local", Invocation.CODEX, Environment.TERMINAL,
-        ServerOwner.IN_PROCESS, Registration.IN_PROCESS_SESSION, Display.BROWSER,
-    ),
 )
 
 

{arrayview-0.37.1 → arrayview-0.38.1}/tests/test_launch_plan.py

@@ -95,7 +95,6 @@ def test_launch_data_enums_match_refactor_contract():
         "julia",
         "matlab",
         "vscode_explorer",
-        "codex",
     }
     assert {item.value for item in Environment} == {
         "terminal",

{arrayview-0.37.1 → arrayview-0.38.1}/tests/test_lifecycle_contract.py

@@ -1701,6 +1701,20 @@ def test_vscode_open_ack_requires_requested_session_metadata():
     assert "Viewer session did not become ready" in source
 
 
+def test_vscode_registration_publishes_superseded_window_ids():
+    """Terminals older than the last reload are only reachable via this chain."""
+    source = (Path(__file__).resolve().parents[1] / "vscode-extension" / "extension.js").read_text()
+
+    # The previous id must be read before replace() overwrites the collection.
+    assert source.index("_readEnvCollection('ARRAYVIEW_WINDOW_ID')") < source.index(
+        "envCollection.replace('ARRAYVIEW_WINDOW_ID', windowId)"
+    )
+    assert "_readEnvCollection('ARRAYVIEW_WINDOW_CHAIN')" in source
+    assert "envCollection.replace('ARRAYVIEW_WINDOW_CHAIN', supersededIds.join(','))" in source
+    assert "supersedes: supersededIds," in source
+    assert "supersedes.slice(0, MAX_SUPERSEDED_WINDOW_IDS)" in source
+
+
 def test_vscode_tunnel_resolution_reuses_verified_routes_and_retries_fresh():
     source = (Path(__file__).resolve().parents[1] / "vscode-extension" / "extension.js").read_text()
 

arrayview-0.37.1/src/arrayview/_codex_open.py

@@ -1,137 +0,0 @@
-"""Codex-app helper for safely loading one file into ArrayView.
-
-Usage:
-    uv run arrayview-codex path/to/file.nii
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import subprocess
-import sys
-import uuid
-
-from arrayview._instance_registry import InstanceRegistry
-from arrayview._launch_plan import (
-    Invocation,
-    LaunchIntent,
-    Registration,
-    create_launch_context,
-)
-from arrayview._launcher import (
-    _find_server_port,
-    _load_session_from_filepath,
-    _port_in_use,
-    _revalidate_launch_server,
-    _server_alive,
-    _server_pid,
-    _wait_for_port,
-)
-
-
-def _start_loaded_server(
-    filepath: str, port: int, sid: str, name: str
-) -> subprocess.Popen[bytes]:
-    script = (
-        "from arrayview._launcher import _serve_daemon; "
-        f"_serve_daemon({filepath!r}, {port}, {sid!r}, name={name!r}, persist=True)"
-    )
-    proc = subprocess.Popen(
-        [sys.executable, "-c", script],
-        stdin=subprocess.DEVNULL,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        start_new_session=True,
-    )
-    if not _wait_for_port(port, timeout=15.0, tcp_only=True):
-        if proc.poll() is None:
-            proc.terminate()
-        raise RuntimeError(f"ArrayView server failed to start on port {port}")
-    if not _server_alive(port, timeout=2.0):
-        if proc.poll() is None:
-            proc.terminate()
-        raise RuntimeError(f"ArrayView server on port {port} did not become healthy")
-    actual_pid = _server_pid(port)
-    if actual_pid != proc.pid:
-        if proc.poll() is None:
-            proc.terminate()
-        raise RuntimeError(
-            f"Port {port} was claimed by another process while ArrayView was starting"
-        )
-    return proc
-
-
-def _open_codex_file(filepath: str, requested_port: int) -> str:
-    context = create_launch_context(
-        LaunchIntent(
-            Invocation.CODEX,
-            requested_port,
-            requested_window="browser",
-            persistent=True,
-        )
-    )
-    if not context.plan.ok:
-        raise ValueError(f"Invalid launch request: {context.plan.failure.value}")
-
-    name = os.path.basename(filepath)
-    expected_server_id = None
-    with InstanceRegistry().startup_lock(timeout=20.0):
-        port = context.plan.effective_port
-        already_running = context.plan.registration is Registration.HTTP_LOAD
-        if already_running:
-            port = _revalidate_launch_server(context, port)
-            expected_server_id = context.evidence.server.server_instance_id
-        else:
-            if _port_in_use(port):
-                port, appeared_running = _find_server_port(port + 1)
-                if appeared_running or _port_in_use(port):
-                    raise RuntimeError("Could not find a free port for ArrayView")
-            if not 1 <= port <= 65535 or _port_in_use(port):
-                raise RuntimeError("Could not find a free port for ArrayView")
-            sid = uuid.uuid4().hex
-            _start_loaded_server(filepath, port, sid, name)
-
-    if already_running:
-        result = _load_session_from_filepath(
-            port,
-            filepath,
-            name,
-            expected_server_id=expected_server_id,
-            release_on_disconnect=True,
-        )
-        if "error" in result:
-            raise RuntimeError(f"ArrayView server rejected the file: {result['error']}")
-        sid = str(result["sid"])
-
-    return f"http://localhost:{port}/?sid={sid}"
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        prog="arrayview-codex",
-        description=(
-            "Load one file into a compatible ArrayView server, starting one on "
-            "a free port when needed, and print the Codex app browser URL."
-        ),
-    )
-    parser.add_argument("file", help="Array file to load")
-    parser.add_argument("--port", type=int, default=8000, help="Preferred port")
-    args = parser.parse_args()
-
-    filepath = os.path.abspath(args.file)
-    if not os.path.isfile(filepath):
-        print(f"Error: file not found: {filepath}", file=sys.stderr)
-        return 1
-
-    try:
-        url = _open_codex_file(filepath, args.port)
-    except (OSError, RuntimeError, TimeoutError, ValueError) as exc:
-        print(f"Error: {exc}", file=sys.stderr)
-        return 1
-    print(url)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

arrayview-0.37.1/tests/test_codex_open.py

@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-from contextlib import contextmanager
-from types import SimpleNamespace
-
-from arrayview._launch_plan import Registration
-
-
-def _context(port: int, *, existing: bool = False):
-    return SimpleNamespace(
-        plan=SimpleNamespace(
-            ok=True,
-            effective_port=port,
-            failure=None,
-            registration=(
-                Registration.HTTP_LOAD
-                if existing
-                else Registration.DAEMON_STARTUP
-            ),
-        ),
-        evidence=SimpleNamespace(
-            server=SimpleNamespace(
-                server_instance_id="existing-server" if existing else None
-            )
-        )
-    )
-
-
-class _Registry:
-    def __init__(self, events: list[str]):
-        self.events = events
-
-    @contextmanager
-    def startup_lock(self, *, timeout: float):
-        self.events.append(f"lock:{timeout}")
-        try:
-            yield
-        finally:
-            self.events.append("unlock")
-
-
-def test_codex_reuses_compatible_server_without_killing_or_spawning(
-    monkeypatch, tmp_path
-):
-    import arrayview._codex_open as codex
-
-    filepath = tmp_path / "array.npy"
-    filepath.write_bytes(b"data")
-    events: list[str] = []
-    intents = []
-    monkeypatch.setattr(
-        codex,
-        "create_launch_context",
-        lambda intent: intents.append(intent) or _context(8000, existing=True),
-    )
-    monkeypatch.setattr(codex, "InstanceRegistry", lambda: _Registry(events))
-    monkeypatch.setattr(
-        codex,
-        "_revalidate_launch_server",
-        lambda context, port: port,
-    )
-    monkeypatch.setattr(
-        codex,
-        "_load_session_from_filepath",
-        lambda port, path, name, **kwargs: events.append(
-            f"load:{port}:{name}:{kwargs['expected_server_id']}:"
-            f"release={kwargs['release_on_disconnect']}"
-        )
-        or {"sid": "existing-sid"},
-    )
-    monkeypatch.setattr(
-        codex,
-        "_start_loaded_server",
-        lambda *args: (_ for _ in ()).throw(AssertionError("must reuse the server")),
-    )
-    monkeypatch.setattr(
-        codex.os,
-        "kill",
-        lambda *args: (_ for _ in ()).throw(AssertionError("must not kill a listener")),
-    )
-
-    url = codex._open_codex_file(str(filepath), 8000)
-
-    assert url == "http://localhost:8000/?sid=existing-sid"
-    assert events == [
-        "lock:20.0",
-        "unlock",
-        "load:8000:array.npy:existing-server:release=True",
-    ]
-    assert intents[0].invocation.value == "codex"
-    assert intents[0].requested_window == "browser"
-    assert intents[0].persistent is True
-
-
-def test_codex_uses_free_port_and_starts_under_startup_lock(monkeypatch, tmp_path):
-    import arrayview._codex_open as codex
-
-    filepath = tmp_path / "array.npy"
-    filepath.write_bytes(b"data")
-    events: list[str] = []
-    monkeypatch.setattr(codex, "create_launch_context", lambda intent: _context(8001))
-    monkeypatch.setattr(codex, "InstanceRegistry", lambda: _Registry(events))
-    monkeypatch.setattr(codex, "_port_in_use", lambda port: False)
-
-    def start(path, port, sid, name):
-        assert events == ["lock:20.0"]
-        events.append(f"start:{port}:{name}")
-        return SimpleNamespace(pid=123)
-
-    monkeypatch.setattr(codex, "_start_loaded_server", start)
-    monkeypatch.setattr(codex.uuid, "uuid4", lambda: SimpleNamespace(hex="new-sid"))
-
-    url = codex._open_codex_file(str(filepath), 8000)
-
-    assert url == "http://localhost:8001/?sid=new-sid"
-    assert events == ["lock:20.0", "start:8001:array.npy", "unlock"]
-
-
-def test_spawned_server_must_match_child_pid(monkeypatch):
-    import arrayview._codex_open as codex
-
-    terminated: list[bool] = []
-    proc = SimpleNamespace(
-        pid=123,
-        poll=lambda: None,
-        terminate=lambda: terminated.append(True),
-    )
-    monkeypatch.setattr(codex.subprocess, "Popen", lambda *args, **kwargs: proc)
-    monkeypatch.setattr(codex, "_wait_for_port", lambda *args, **kwargs: True)
-    monkeypatch.setattr(codex, "_server_alive", lambda *args, **kwargs: True)
-    monkeypatch.setattr(codex, "_server_pid", lambda port: 456)
-
-    try:
-        codex._start_loaded_server("/tmp/array.npy", 8000, "sid", "array.npy")
-    except RuntimeError as exc:
-        assert "claimed by another process" in str(exc)
-    else:
-        raise AssertionError("PID mismatch must fail")
-
-    assert terminated == [True]
-
-
-def test_codex_main_reports_actual_selected_port(monkeypatch, tmp_path, capsys):
-    import arrayview._codex_open as codex
-
-    filepath = tmp_path / "array.npy"
-    filepath.write_bytes(b"data")
-    monkeypatch.setattr(
-        codex.sys,
-        "argv",
-        ["arrayview-codex", str(filepath), "--port", "8000"],
-    )
-    monkeypatch.setattr(
-        codex,
-        "_open_codex_file",
-        lambda path, port: "http://localhost:8010/?sid=selected",
-    )
-
-    assert codex.main() == 0
-    assert capsys.readouterr().out.strip() == "http://localhost:8010/?sid=selected"