arrayview 0.43.1__py3-none-any.whl → 0.43.2__py3-none-any.whl

arrayview/_extra_ports.py

@@ -18,24 +18,23 @@ A port that has never been forwarded does not have that problem.  So a cold
 launch is served from a fresh port, which VS Code forwards for the first time.
 This module adds that port to the process that is *already* running, rather than
 starting another server: same process, same loaded arrays, nothing extra to shut
-down, and repeat opens keep using the original port.
+down, and overlapping opens share the same private viewer port.
 
 Lifetime
 --------
 
-An extra port is closed as soon as no viewer is connected **on that port**.
-Viewers report the port they arrived on, so a port is released the moment its
-own viewer goes away, rather than waiting for every viewer everywhere to close —
-otherwise one cold start early in a session would leave a port listening for the
-rest of the day.
+Every launch leases the singleton viewer port before its URL is handed off.
+The port is closed only when no viewer is connected **and** no launch still has
+a live lease.  This prevents the last old viewer from closing the port while a
+new viewer is between URL handoff and WebSocket connection.
 
 It must not be closed while a viewer loaded from it is alive: the viewer keeps
 using HTTP on its own origin long after the page has rendered, so pulling the
 port out from under it would break the viewer rather than tidy up after it.
 
-A port that never receives a viewer at all — the launch failed, or the user
-closed the tab before it loaded — is closed after ``UNUSED_GRACE_S``.  Without
-that, a failed cold start would leak a port with nothing to trigger its release.
+A launch that never receives a viewer loses its lease after a bounded timeout.
+Without that, a failed handoff would leak a port with nothing to trigger its
+release.
 """
 
 from __future__ import annotations
@@ -47,19 +46,20 @@ import time
 import arrayview._session as _session_mod
 from arrayview._session import _vprint
 
-# Cold starts are rare — one per session in practice, because the first launch
-# leaves a viewer open and every launch after that is warm.  The cap is a guard
-# against a pathological caller, not an expected working set.
-MAX_EXTRA_PORTS = 3
-
-# How long a freshly opened port may sit with no viewer on it before it is
-# reclaimed.  This is the leak guard for a launch that never produced a viewer;
-# it has to outlast a slow array load, because the port is opened before the
-# page is even requested and a large file can take a while to reach its socket.
-UNUSED_GRACE_S = 180.0
-
-# port -> {"socket", "server", "task", "viewers", "opened_at"}
+# A lease must be long enough for a slow or temporarily wedged VS Code handoff,
+# but a caller may not keep a private port alive without bound.
+MIN_LEASE_TTL_MS = 1
+MAX_LEASE_TTL_MS = 300_000
+# Keep the origin alive across the viewer's ordinary reconnect window.  The
+# correlated session uses the same 30-second default before it treats a lost
+# WebSocket as a closed tab; closing the listener sooner would make that
+# recovery impossible even though the server and session are still healthy.
+VIEWER_RECONNECT_GRACE_S = 30.0
+
+# port -> {"socket", "server", "task", "viewers", "opened_at", "leases",
+#          "idle_until", "idle_generation"}
 _EXTRA_PORTS: dict[int, dict] = {}
+_PORT_LOCK = asyncio.Lock()
 
 
 def extra_ports() -> list[int]:
@@ -76,18 +76,8 @@ def _bind_free_port() -> socket.socket:
     return sock
 
 
-async def open_extra_port() -> int | None:
-    """Serve the running app on one more, never-before-used port.
-
-    Returns the port, or ``None`` if one could not be added.  Never raises: a
-    launch that cannot get a fresh port is still a working launch on the main
-    port, only with the cold-start flicker it would have had anyway.
-    """
-    if len(_EXTRA_PORTS) >= MAX_EXTRA_PORTS:
-        _vprint(
-            f"[ArrayView] not adding another port; {len(_EXTRA_PORTS)} already open"
-        )
-        return None
+def _start_extra_port() -> tuple[int, dict] | None:
+    """Start the singleton extra listener; caller holds ``_PORT_LOCK``."""
     try:
         import uvicorn
 
@@ -105,57 +95,169 @@ async def open_extra_port() -> int | None:
         )
         server = uvicorn.Server(config)
         task = asyncio.create_task(server.serve(sockets=[sock]))
-        _EXTRA_PORTS[port] = {
+        entry = {
             "socket": sock,
             "server": server,
             "task": task,
             "viewers": 0,
             "opened_at": time.monotonic(),
+            "leases": {},
+            "idle_until": 0.0,
+            "idle_generation": 0,
         }
-        asyncio.create_task(_close_if_unused(port))
         # The socket is already listening and accepting before serve() runs, so
         # a client that connects immediately is queued rather than refused.
-        _vprint(f"[ArrayView] serving a cold-start port on {port}")
-        return port
+        _vprint(f"[ArrayView] serving the private viewer port on {port}")
+        return port, entry
     except Exception as exc:  # pragma: no cover - defensive
-        _vprint(f"[ArrayView] could not add a cold-start port: {exc}")
+        _vprint(f"[ArrayView] could not add the private viewer port: {exc}")
         return None
 
 
-def viewer_connected(port: int | None) -> None:
-    """Note that a viewer arrived on *port*, if it is one of ours."""
-    entry = _EXTRA_PORTS.get(port)
-    if entry is not None:
-        entry["viewers"] += 1
-
+async def acquire_viewer_port(request_id: str, ttl_ms: int) -> tuple[int | None, bool]:
+    """Lease the singleton private viewer port for one launch.
 
-async def viewer_disconnected(port: int | None) -> None:
-    """Note a viewer left *port*, and release the port if it was the last one."""
+    The selection and lease insertion are one event-loop transaction, so two
+    launches arriving before either viewer connects cannot create two ports.
+    """
+    ttl_ms = max(MIN_LEASE_TTL_MS, min(MAX_LEASE_TTL_MS, int(ttl_ms)))
+    retired: list[tuple[int, dict]] = []
+    async with _PORT_LOCK:
+        now = time.monotonic()
+        for port, entry in list(_EXTRA_PORTS.items()):
+            leases = entry.setdefault("leases", {})
+            for lease_id, expires_at in list(leases.items()):
+                if expires_at <= now:
+                    leases.pop(lease_id, None)
+            if (
+                entry["viewers"] == 0
+                and not leases
+                and float(entry.get("idle_until", 0.0)) <= now
+            ):
+                _EXTRA_PORTS.pop(port, None)
+                retired.append((port, entry))
+        reused = bool(_EXTRA_PORTS)
+        if reused:
+            port = next(iter(_EXTRA_PORTS))
+            entry = _EXTRA_PORTS[port]
+        else:
+            started = _start_extra_port()
+            if started is None:
+                for retired_port, retired_entry in retired:
+                    asyncio.create_task(
+                        _shutdown_entry(retired_port, retired_entry)
+                    )
+                return None, False
+            port, entry = started
+            _EXTRA_PORTS[port] = entry
+        expires_at = now + ttl_ms / 1000.0
+        entry.setdefault("leases", {})[request_id] = expires_at
+        entry["idle_until"] = 0.0
+        entry["idle_generation"] = int(entry.get("idle_generation", 0)) + 1
+        asyncio.create_task(_expire_lease(port, request_id, expires_at))
+    for retired_port, retired_entry in retired:
+        asyncio.create_task(_shutdown_entry(retired_port, retired_entry))
+    return port, reused
+
+
+def viewer_connected(port: int | None, request_id: str | None = None) -> None:
+    """Note that a viewer arrived and consume only its correlated lease."""
     entry = _EXTRA_PORTS.get(port)
     if entry is None:
         return
-    entry["viewers"] = max(0, entry["viewers"] - 1)
-    if entry["viewers"] == 0:
-        await _close_port(port)
-
-
-async def _close_if_unused(port: int) -> None:
-    """Reclaim a port that never got a viewer.
+    leases = entry.setdefault("leases", {})
+    if request_id:
+        consumed = leases.pop(request_id, None)
+        # Opener 0.15.47 asks for the port before it knows how to lease it.
+        # The endpoint gives that request a bounded compatibility lease so a
+        # package update does not force an immediate window reload. Consume one
+        # such lease only when no exact lease exists.
+        if consumed is None:
+            compatibility_lease = next(
+                (
+                    lease_id
+                    for lease_id in leases
+                    if lease_id.startswith("compat-")
+                ),
+                None,
+            )
+            if compatibility_lease is not None:
+                leases.pop(compatibility_lease, None)
+    entry["viewers"] += 1
+    entry["idle_until"] = 0.0
+    entry["idle_generation"] = int(entry.get("idle_generation", 0)) + 1
 
-    Its own release is driven by the viewer that loaded from it, so a launch
-    that never produced one would otherwise leave the port listening forever.
-    """
-    await asyncio.sleep(UNUSED_GRACE_S)
-    entry = _EXTRA_PORTS.get(port)
-    if entry is not None and entry["viewers"] == 0:
-        _vprint(f"[ArrayView] cold-start port {port} was never used")
-        await _close_port(port)
 
-
-async def _close_port(port: int) -> None:
-    entry = _EXTRA_PORTS.pop(port, None)
-    if entry is None:
-        return
+async def viewer_disconnected(port: int | None) -> None:
+    """Release a port only after its last viewer and last handoff lease."""
+    close_after: tuple[int, float] | None = None
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if entry is None:
+            return
+        entry["viewers"] = max(0, entry["viewers"] - 1)
+        if entry["viewers"] == 0:
+            entry["idle_generation"] = int(entry.get("idle_generation", 0)) + 1
+            generation = entry["idle_generation"]
+            idle_until = time.monotonic() + VIEWER_RECONNECT_GRACE_S
+            entry["idle_until"] = idle_until
+            close_after = (generation, idle_until)
+    if close_after is not None:
+        generation, idle_until = close_after
+        asyncio.create_task(_close_after_reconnect_grace(port, generation, idle_until))
+
+
+async def _close_after_reconnect_grace(
+    port: int, generation: int, idle_until: float
+) -> None:
+    """Close only if no reconnect or new launch superseded this disconnect."""
+    await asyncio.sleep(max(0.0, idle_until - time.monotonic()))
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if (
+            entry is None
+            or int(entry.get("idle_generation", 0)) != generation
+            or entry["viewers"] > 0
+            or entry.get("leases")
+        ):
+            return
+    await _close_port(port, only_if_idle=True)
+
+
+async def _expire_lease(port: int, request_id: str, expires_at: float) -> None:
+    """Expire one exact launch lease and reclaim an otherwise idle port."""
+    await asyncio.sleep(max(0.0, expires_at - time.monotonic()))
+    should_close = False
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if entry is None:
+            return
+        leases = entry.setdefault("leases", {})
+        if leases.get(request_id) != expires_at:
+            return
+        leases.pop(request_id, None)
+        should_close = entry["viewers"] == 0 and not leases
+    if should_close:
+        _vprint(f"[ArrayView] viewer-port lease expired for {request_id[:12]}")
+        await _close_port(port, only_if_idle=True)
+
+
+async def _close_port(port: int, *, only_if_idle: bool = False) -> None:
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if entry is None:
+            return
+        if only_if_idle:
+            if entry["viewers"] > 0 or entry.get("leases"):
+                return
+            if float(entry.get("idle_until", 0.0)) > time.monotonic():
+                return
+        _EXTRA_PORTS.pop(port, None)
+    await _shutdown_entry(port, entry)
+
+
+async def _shutdown_entry(port: int, entry: dict) -> None:
+    """Stop one listener already removed from the selectable port registry."""
     try:
         entry["server"].should_exit = True
         await asyncio.wait_for(entry["task"], timeout=5)
@@ -166,7 +268,7 @@ async def _close_port(port: int) -> None:
             entry["socket"].close()
         except Exception:
             pass
-    _vprint(f"[ArrayView] released cold-start port {port}")
+    _vprint(f"[ArrayView] released private viewer port {port}")
 
 
 async def close_extra_ports() -> None:
@@ -178,4 +280,4 @@ async def close_extra_ports() -> None:
     if not _EXTRA_PORTS or _session_mod.VIEWER_SOCKETS > 0:
         return
     for port in list(_EXTRA_PORTS):
-        await _close_port(port)
+        await _close_port(port, only_if_idle=True)

arrayview/_routes_loading.py

@@ -832,7 +832,10 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
             )
             if require_display_ack:
                 if not signal_request:
-                    raise RuntimeError("VS Code display request could not be written")
+                    raise RuntimeError(
+                        signal_request.failure_reason
+                        or "VS Code display request could not be written"
+                    )
                 ack = await asyncio.to_thread(
                     _wait_for_vscode_ack,
                     signal_request,

arrayview/_routes_websocket.py

@@ -369,7 +369,7 @@ def register_websocket_routes(app) -> None:
         try:
             from arrayview import _extra_ports
 
-            _extra_ports.viewer_connected(arrived_on)
+            _extra_ports.viewer_connected(arrived_on, launch_request_id)
         except Exception:
             pass
         _session_mod.VIEWER_SID_COUNTS[sid] = (

arrayview/_server.py

@@ -293,20 +293,55 @@ def get_shell():
 
 
 @app.post("/cold-start-port")
-async def cold_start_port():
+async def cold_start_port(payload: dict):
     """Serve this same server on one more, never-before-forwarded port.
 
-    Asked for only when no viewer is connected.  A forward VS Code has just
-    created does not drop its first requests, while one that has sat idle does,
-    and that is what makes a cold launch flicker.  The port is released as soon
-    as no viewer is connected anywhere.
+    A forward VS Code has just created does not drop its first requests, while
+    one that has sat idle for tens of seconds drops the first two to four.  So
+    the viewer page is served from an extra port rather than the main one: a
+    fresh port for the first launch, then that same port is leased to later
+    launches.  A lease keeps the route alive between handoff and connection,
+    including when the previous viewer closes during that gap.  The port is
+    released only after its last viewer and its last bounded lease are gone.
     """
     from arrayview import _extra_ports
 
-    if _session_mod.VIEWER_SOCKETS > 0:
-        return {"port": None, "reason": "a viewer is already connected"}
-    port = await _extra_ports.open_extra_port()
-    return {"port": port}
+    request_id = payload.get("requestId")
+    ttl_ms = payload.get("ttlMs")
+    expected_server_id = payload.get("expectedServerId")
+    compatibility_request = not payload
+    if compatibility_request:
+        # Opener 0.15.47 shipped before correlated leases. Keep that already-
+        # loaded host working after the Python package updates, so users are
+        # not forced to reload a VS Code window merely to open the next array.
+        request_id = f"compat-{uuid.uuid4().hex}"
+        ttl_ms = 240_000
+        expected_server_id = _session_mod.SERVER_RUNTIME.instance_id
+    if not isinstance(request_id, str) or not request_id.strip():
+        raise HTTPException(status_code=400, detail="requestId is required")
+    if isinstance(ttl_ms, bool) or not isinstance(ttl_ms, int) or ttl_ms <= 0:
+        raise HTTPException(status_code=400, detail="ttlMs must be a positive integer")
+    if not isinstance(expected_server_id, str) or not expected_server_id:
+        raise HTTPException(status_code=400, detail="expectedServerId is required")
+    actual_server_id = _session_mod.SERVER_RUNTIME.instance_id
+    if expected_server_id != actual_server_id:
+        raise HTTPException(
+            status_code=409,
+            detail="The requested ArrayView backend no longer owns this port",
+        )
+    port, reused = await _extra_ports.acquire_viewer_port(request_id, ttl_ms)
+    if port is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Could not prepare the private VS Code viewer connection",
+        )
+    return {
+        "port": port,
+        "reused": reused,
+        "ttlMs": min(ttl_ms, _extra_ports.MAX_LEASE_TTL_MS),
+        "compatibility": compatibility_request,
+        "requestId": request_id,
+    }
 
 
 @app.get("/ping")

arrayview/_viewer.html

@@ -9564,6 +9564,11 @@
             }
             _normalizeCompareLayoutMode();
             applyCompareLayout();
+            // Reconcile the diff/wipe pane visibility before scaling so the
+            // incoming centre pane is already display:flex when its canvas is
+            // measured — sizing it against a settled layout instead of a
+            // display:none pane, which avoids a visible size jump on handoff.
+            _reconcileCompareState();
 
             if (newMode === 0) {
                 // Restore shared colorbar; hide per-pane colorbars and rescale to 2-column layout
@@ -9594,7 +9599,6 @@
             }
             _renderCompareCenterTitleControls();
             if (newMode > 0) _syncCompareCenterIsland();
-            _reconcileCompareState();
             _reconcileCbVisibility();
             _reconcileCompareCenterPicker();
             _reconcileCompareCenterModeBadge();
@@ -39803,11 +39807,15 @@
             if (!f0 || !f1) return null;
             const W = f0.width, H = f0.height;
             _wipeCanvas.width = W; _wipeCanvas.height = H;
-            const refCv = compareCanvases[0];
-            const cssW = parseInt(refCv.style.width)  || refCv.offsetWidth  || W;
-            const cssH = parseInt(refCv.style.height) || refCv.offsetHeight || H;
-            _wipeCanvas.style.width  = cssW + 'px';
-            _wipeCanvas.style.height = cssH + 'px';
+            if (!_isCompareBigLeftLayout()) {
+                const refCv = compareCanvases[0];
+                const cssW = parseInt(refCv.style.width)  || refCv.offsetWidth  || W;
+                const cssH = parseInt(refCv.style.height) || refCv.offsetHeight || H;
+                _wipeCanvas.style.width  = cssW + 'px';
+                _wipeCanvas.style.height = cssH + 'px';
+            }
+            const cssW = parseInt(_wipeCanvas.style.width)  || _wipeCanvas.offsetWidth  || W;
+            const cssH = parseInt(_wipeCanvas.style.height) || _wipeCanvas.offsetHeight || H;
             return { f0, f1, W, H, cssW, cssH };
         }
 

arrayview/_vscode_browser.py

@@ -348,7 +348,7 @@ def _open_browser(
                 return OpenResult(
                     OpenState.FAILED,
                     "vscode-signal",
-                    "signal request was not written",
+                    request.failure_reason or "signal request was not written",
                 )
             if not blocking:
                 return OpenResult(OpenState.ACCEPTED, "vscode-signal")
@@ -406,7 +406,7 @@ def _open_browser(
                 return OpenResult(
                     OpenState.FAILED,
                     "vscode-signal",
-                    "signal request was not written",
+                    request.failure_reason or "signal request was not written",
                 )
             if blocking:
                 ack = _wait_for_vscode_ack(

arrayview/_vscode_extension.py

@@ -57,7 +57,7 @@ _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_NO_LIVE_WINDOW = False  # no live host claims this terminal's window id
-_VSCODE_EXT_VERSION = "0.15.45"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.15.48"  # current bundled extension version
 _VSCODE_CONFIGURED_PORTS: set[int] = set()
 # Version-skew notices already printed, so a long-lived process (Jupyter, a
 # script opening several arrays) states the mismatch once instead of per call.

arrayview/_vscode_signal.py

@@ -54,6 +54,7 @@ class SignalRequest:
     ack_path: Path
     written: bool
     extension_version: str | None = None
+    failure_reason: str | None = None
 
     def __bool__(self) -> bool:
         return self.written
@@ -424,8 +425,14 @@ def _with_viewer_name(url: str, name: str | None) -> str:
         return url
 
 
-def _cold_start_url(url: str) -> str:
-    """Serve a cold launch from a port VS Code has not forwarded before.
+def _viewer_port_url(
+    url: str,
+    *,
+    request_id: str,
+    max_age_ms: int,
+    server_id: str | None,
+) -> str:
+    """Acquire the private tunnel viewer port for one correlated launch.
 
     Measured 2026-08-06, real host: a forward VS Code has just created never
     loses the viewer's page request (3/3 on genuine cold starts), while one that
@@ -433,11 +440,10 @@ def _cold_start_url(url: str) -> str:
     four.  A dropped request never arrives, so the opener can only throw the tab
     away and open another — the flicker.
 
-    While any viewer is open the server keeps the forward alive and this is
-    skipped, so the ordinary case still reuses the one port.  Only a launch with
-    nothing connected pays for a fresh one, and the server releases it as soon
-    as no viewer is left.  Best effort throughout: a launch that cannot get a
-    fresh port proceeds on the original one exactly as before.
+    The backend holds the selected port for this request until its correlated
+    viewer connects or the request expires.  That lease prevents the last old
+    viewer from closing the port during the handoff.  Failure is explicit: the
+    known-stale main port is not a safe fallback for a tunnel viewer.
     """
     import json as _json
     import urllib.request
@@ -446,28 +452,47 @@ def _cold_start_url(url: str) -> str:
     try:
         parts = urlsplit(url)
         if parts.hostname != "localhost" or not parts.port:
-            return url
+            raise RuntimeError("the backend URL is not a private localhost route")
         origin = f"http://localhost:{parts.port}"
         with urllib.request.urlopen(f"{origin}/ping", timeout=1.0) as response:
             status = _json.load(response)
         if status.get("service") != "arrayview":
-            return url
-        if int(status.get("viewer_sockets") or 0) > 0:
-            return url
+            raise RuntimeError("the target port is not an ArrayView server")
+        body = _json.dumps({
+            "requestId": request_id,
+            "ttlMs": max_age_ms,
+            "expectedServerId": server_id,
+        }).encode("utf-8")
         request = urllib.request.Request(
-            f"{origin}/cold-start-port", data=b"", method="POST"
+            f"{origin}/cold-start-port",
+            data=body,
+            headers={"Content-Type": "application/json"},
+            method="POST",
         )
         with urllib.request.urlopen(request, timeout=3.0) as response:
-            port = _json.load(response).get("port")
+            lease = _json.load(response)
+        if lease.get("requestId") != request_id:
+            raise RuntimeError(
+                "the running server does not support safe viewer handoff"
+            )
+        port = lease.get("port")
         if not port:
-            return url
-        _vprint(f"[ArrayView] cold start: serving this launch from port {port}")
+            raise RuntimeError("the server did not provide a viewer connection")
+        _vprint(f"[ArrayView] serving this launch from port {port}")
         return urlunsplit(
             (parts.scheme, f"localhost:{port}", parts.path, parts.query, parts.fragment)
         )
     except Exception as exc:
-        _vprint(f"[ArrayView] cold-start port unavailable ({exc}); using the main port")
-        return url
+        _vprint(f"[ArrayView] private viewer connection unavailable: {exc}")
+        if "does not support safe viewer handoff" in str(exc):
+            raise RuntimeError(
+                "ArrayView needs to restart once before it can open this viewer "
+                "safely; run `arrayview --kill`, then retry"
+            ) from exc
+        raise RuntimeError(
+            "ArrayView could not prepare the private VS Code viewer connection; "
+            "no display request was sent"
+        ) from exc
 
 
 def _open_via_signal_file(
@@ -489,8 +514,33 @@ def _open_via_signal_file(
     If omitted it is auto-derived from the session name embedded in the URL's
     ``?sid=`` query parameter.
     """
+    effective_max_age_ms = (
+        max(1, int(max_age_ms))
+        if max_age_ms is not None
+        else _VSCODE_SIGNAL_MAX_AGE_MS
+    )
+    request_id = uuid.uuid4().hex
+    ack_path = _vscode_ack_path(request_id)
     if cold_start_port:
-        url = _cold_start_url(url)
+        try:
+            url = _viewer_port_url(
+                url,
+                request_id=request_id,
+                max_age_ms=effective_max_age_ms,
+                server_id=server_id,
+            )
+        except RuntimeError as exc:
+            from arrayview._vscode_extension import _VSCODE_EXT_VERSION
+
+            return SignalRequest(
+                request_id,
+                window_id,
+                server_id,
+                ack_path,
+                False,
+                _VSCODE_EXT_VERSION,
+                str(exc),
+            )
     session_name = _session_name_for_url(url)
     if title is None and session_name:
         title = f"ArrayView: {session_name}"
@@ -499,10 +549,8 @@ def _open_via_signal_file(
     # pre-formatted and others pass as a bare filename.
     url = _with_viewer_name(url, session_name)
 
-    request_id = uuid.uuid4().hex
     if window_id is None:
         window_id = _find_arrayview_window_id()
-    ack_path = _vscode_ack_path(request_id)
     _cleanup_stale_vscode_acks()
     try:
         ack_path.unlink()
@@ -511,11 +559,7 @@ def _open_via_signal_file(
     payload: dict = {
         "action": "open-preview",
         "url": url,
-        "maxAgeMs": (
-            max(1, int(max_age_ms))
-            if max_age_ms is not None
-            else _VSCODE_SIGNAL_MAX_AGE_MS
-        ),
+        "maxAgeMs": effective_max_age_ms,
         "protocolVersion": _VSCODE_ACK_PROTOCOL_VERSION,
         "requestId": request_id,
         "ackPath": str(ack_path),

{arrayview-0.43.1.dist-info → arrayview-0.43.2.dist-info}/METADATA

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

{arrayview-0.43.1.dist-info → arrayview-0.43.2.dist-info}/RECORD

@@ -7,7 +7,7 @@ arrayview/_config.py,sha256=HEy3931e-pUzxen_Tn55xgpXfi-YSDSj-4K2w_eoZzI,13164
 arrayview/_diagnostics.py,sha256=XB0rCoDn3cpfhz4H-ayLktOgCMIoVJ0wM9N0ep_kKkQ,11018
 arrayview/_dicom.py,sha256=tNY353MNWTvcXavHeIkqj3242dbgfH_ctwcx9NDee-E,19607
 arrayview/_diff.py,sha256=mSIo1ArNxkrB0v2iUMy3dezJOlpos0xNu1V_umNUMhU,5677
-arrayview/_extra_ports.py,sha256=tW1IxAxSuJ1DOd1Z0_8XAOzUX5oou1-sVET6H1OcwvM,6852
+arrayview/_extra_ports.py,sha256=Q-bH3jPcgQr8I2iecnU8cpcRkA9jz7g2WrtCWkiG-hI,11124
 arrayview/_icon.png,sha256=a8RTAbvweLhh3hzD5eGg76Peq-KSDcS6YrCphRb_HEs,2748
 arrayview/_imaging.py,sha256=MQX1uy4m1lofOeoLDhCp6cHO5p_V5fXm4qlSu9Ykn-c,534
 arrayview/_instance_registry.py,sha256=h7vyvCl0LTt9R8sDB1Vxe4a-KzfkLVuwrSw_ANpPTD8,8833
@@ -22,7 +22,7 @@ arrayview/_render.py,sha256=wjmyLrwmVF4bOjx4V-a0HgfjIIo9H502gdAEqQhRUCA,33589
 arrayview/_routes_analysis.py,sha256=b2yiPm3qiapFPcBZWpltZrsTKNkFyHYV7o1O2ZrzVUo,32320
 arrayview/_routes_drop.py,sha256=FC4e7STdCo3hYIA0C4Yy9Ka2UKFx7nLDU5dkujmc1Vo,12477
 arrayview/_routes_export.py,sha256=Ha8mMO2E9TlRL5x25-ADV8_8xUiC-jRz9N1oWwgKOsg,3898
-arrayview/_routes_loading.py,sha256=4AP2cHYIvZNjeD1lpT0jILHOUNnJ3CbuFzx9O-mMtHs,38917
+arrayview/_routes_loading.py,sha256=s7Vc33Og9Cr2YrsFX7VP5lwjLY5Aa6fv9WoqQfJAsR8,39020
 arrayview/_routes_persistence.py,sha256=T03csHb7ppGT-8yMDf227XkqhnhjgSLYj0RW2wmg59g,17176
 arrayview/_routes_preferences.py,sha256=SKnhTf2X2vRyYi06Wb2si4dXMB1y0XiSBr28RZ5oKUw,4691
 arrayview/_routes_preload.py,sha256=KOsankNguxdIWmFW9iZcY9p2SvUN1mOKY7KkW1qMGcc,1729
@@ -31,9 +31,9 @@ arrayview/_routes_rendering.py,sha256=EQq2QzdtUS_pv35k7prLdlRdO5nByIlQ_Eu0nhVsn1
 arrayview/_routes_segmentation.py,sha256=x2bBjQffZryeTMmOH38YdBWethw1o3KpA8V0chJcZHI,23599
 arrayview/_routes_state.py,sha256=T_xoYcRlv7L47ydTxxiXb0Fp5M5x9KR2U-wkxaVeuMY,12462
 arrayview/_routes_vectorfield.py,sha256=OWZtAONwRKQHdYnbDAMbOVf0q6pH7kqV8fa1icDhKHM,9734
-arrayview/_routes_websocket.py,sha256=GRWA3OzL1ztywozO8QqhG-dt9vE1znHBp0MuUqbldB0,39736
+arrayview/_routes_websocket.py,sha256=fq8NDAIQlgidaIVadyexQlyxVoXVw7ouW3TY_7VycP0,39755
 arrayview/_segmentation.py,sha256=aENWHmefrKDScXhcZL1X3KgYXE784dpMkmFFo83qnrw,7377
-arrayview/_server.py,sha256=fkoZFH0QKtS2ynpf7lpcdZDR-X-C6Mo0eS49CXEWN_M,18593
+arrayview/_server.py,sha256=p0XB4n6G3sNBgTsXfnqbOl4It-0pth5wf0OETXUbbE4,20444
 arrayview/_session.py,sha256=ZuD-SJwp4H0rROwu-9MgHrULBUsq-6fiTS9zPHKUAw8,27090
 arrayview/_session_spec.py,sha256=mKDfMRsPYQdEmN9hLXmDU_9N7etiDyBXr8mz-fB8QBo,6825
 arrayview/_shell.html,sha256=vNa2Kiwx_eoB5H329jolYafLhwJDCH9DsJafBqvVMWU,13194
@@ -42,17 +42,17 @@ arrayview/_synthetic_mri.py,sha256=CNL-2WC835i6WCqkvmWBCO6WQ5w7HE5trNb8OyEfe64,7
 arrayview/_torch.py,sha256=13sqIMCUu_-b9SQ9KfDCExDz2UMStL87EDVjnbJxAEo,7536
 arrayview/_tutorial.py,sha256=U09j6hcps_dp3_azivvAoTChwqjNYGNLFqu9Cz1bOzE,6839
 arrayview/_vectorfield.py,sha256=eDqMCMEGjO8Jdt-6Auh01cz3WD9dbF7xYUWD9xHAf1E,8115
-arrayview/_viewer.html,sha256=-bw4d5eJ7nO0rBvJ3J8o-WPmzoLXGCy1R6c0IYebstk,2097505
+arrayview/_viewer.html,sha256=JYkMXAkmPrP0WTvS53eaFCEeJ-ZXbBGaS1dYk2TkT7k,2098084
 arrayview/_vscode.py,sha256=EKnGN2zrjlybc4FQOmYA8BvYdtkcJbLHDEdgtvO7ul4,837
-arrayview/_vscode_browser.py,sha256=sfhQFJcIRjQvB_G9Kgnfoft96bLNhumpEGwIlBjxXTE,20080
-arrayview/_vscode_extension.py,sha256=-I12FyUzv3NL5h04eFKzlarWPi6lKNn2KBYhHMHkEXE,44477
-arrayview/_vscode_signal.py,sha256=8K9-0RGa5G3TlLS_M2aiXmERK65I8f5OuJICNPEZmSA,49832
+arrayview/_vscode_browser.py,sha256=xypCgIwphII1Jgb6xC92gJu4Zo-oHtwjceymOqq4D_Y,20132
+arrayview/_vscode_extension.py,sha256=dBQiP92h-2QH-sRbTtm3InAkxiIg_1YGswTmaLmXyvY,44477
+arrayview/_vscode_signal.py,sha256=8kf6rHrowQ0P6HzHavqb1IWweKh-JyB_rq39v80Bkks,51366
 arrayview/_watch.py,sha256=PxxS_5hcj_S6xQf9Ep4p1HLRkrI5iDMh1aRa4olV7ew,1873
-arrayview/arrayview-opener.vsix,sha256=3kCNlIj_PIr4nImiBWS3d1eJgDz2AZ56gvK0uVHvrow,53581
+arrayview/arrayview-opener.vsix,sha256=jQSEXjPTB2dMzKLVCvsdjUGvlOZV8cYVPPPA_YEndhM,54164
 arrayview/gsap.min.js,sha256=VGihm4idI0E1uqrWezWsiScB9F_jMosn7qs6pPSkeac,72304
 arrayview/todo.md,sha256=4rzoaIY4nJJACDHPJKeqP8guasCMxeRQ1cyNLxUYink,999
-arrayview-0.43.1.dist-info/METADATA,sha256=AV0dRemMvC7qFDq98-4yGj02_4jqrXx4xMCPtam-UnY,2515
-arrayview-0.43.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-arrayview-0.43.1.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
-arrayview-0.43.1.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
-arrayview-0.43.1.dist-info/RECORD,,
+arrayview-0.43.2.dist-info/METADATA,sha256=PmteArvJCUMkj5kkTtaeUntyGx2sqcg-T3tq0e5im1Q,2515
+arrayview-0.43.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+arrayview-0.43.2.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
+arrayview-0.43.2.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
+arrayview-0.43.2.dist-info/RECORD,,