arrayview 0.43.1__tar.gz → 0.43.2__tar.gz

{arrayview-0.43.1 → arrayview-0.43.2}/PKG-INFO

@@ -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 → arrayview-0.43.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.43.1"
+version = "0.43.2"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"

arrayview-0.43.2/src/arrayview/_extra_ports.py

@@ -0,0 +1,283 @@
+"""Extra listening ports on the already-running server.
+
+Why this exists
+---------------
+
+In VS Code the viewer is fetched over a forwarded port.  Measured 2026-08-06 on
+the real host: a forward that VS Code has *just created* never loses a page
+request (4/4, and 3/3 on a genuine cold start), while one that already exists
+and has sat idle for tens of seconds drops the first two to four.  A dropped
+request never arrives — the opener can only discard the tab and open another,
+which the user sees as the viewer flickering before the array appears.
+
+While any viewer is open the server keeps the forward from going idle (see the
+nudge in ``_routes_websocket``).  The case that leaves is the cold one: no
+viewer is open, so nothing has kept the forward alive, and the first launch pays.
+
+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 overlapping opens share the same private viewer port.
+
+Lifetime
+--------
+
+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 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
+
+import asyncio
+import socket
+import time
+
+import arrayview._session as _session_mod
+from arrayview._session import _vprint
+
+# 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]:
+    """Ports currently being served in addition to the main one."""
+    return sorted(_EXTRA_PORTS)
+
+
+def _bind_free_port() -> socket.socket:
+    """Bind a port the OS says is free, so nothing has to be guessed."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.bind(("localhost", 0))
+    sock.listen(128)
+    return sock
+
+
+def _start_extra_port() -> tuple[int, dict] | None:
+    """Start the singleton extra listener; caller holds ``_PORT_LOCK``."""
+    try:
+        import uvicorn
+
+        from arrayview import _server as _server_mod
+
+        sock = _bind_free_port()
+        port = sock.getsockname()[1]
+        config = uvicorn.Config(
+            _server_mod.app,
+            log_level="error",
+            timeout_keep_alive=30,
+            ws_ping_interval=None,
+            ws="websockets",
+            ws_per_message_deflate=True,
+        )
+        server = uvicorn.Server(config)
+        task = asyncio.create_task(server.serve(sockets=[sock]))
+        entry = {
+            "socket": sock,
+            "server": server,
+            "task": task,
+            "viewers": 0,
+            "opened_at": time.monotonic(),
+            "leases": {},
+            "idle_until": 0.0,
+            "idle_generation": 0,
+        }
+        # 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 the private viewer port on {port}")
+        return port, entry
+    except Exception as exc:  # pragma: no cover - defensive
+        _vprint(f"[ArrayView] could not add the private viewer port: {exc}")
+        return None
+
+
+async def acquire_viewer_port(request_id: str, ttl_ms: int) -> tuple[int | None, bool]:
+    """Lease the singleton private viewer port for one launch.
+
+    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
+    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
+
+
+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)
+    except Exception:
+        entry["task"].cancel()
+    finally:
+        try:
+            entry["socket"].close()
+        except Exception:
+            pass
+    _vprint(f"[ArrayView] released private viewer port {port}")
+
+
+async def close_extra_ports() -> None:
+    """Release every extra port.  Only safe with no viewer connected anywhere.
+
+    A backstop for the per-port release above: if a viewer is lost without its
+    disconnect being seen, this still reclaims the port once the server is idle.
+    """
+    if not _EXTRA_PORTS or _session_mod.VIEWER_SOCKETS > 0:
+        return
+    for port in list(_EXTRA_PORTS):
+        await _close_port(port, only_if_idle=True)

{arrayview-0.43.1 → arrayview-0.43.2}/src/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-0.43.1 → arrayview-0.43.2}/src/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-0.43.1 → arrayview-0.43.2}/src/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-0.43.1 → arrayview-0.43.2}/src/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-0.43.1 → arrayview-0.43.2}/src/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-0.43.1 → arrayview-0.43.2}/src/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-0.43.1 → arrayview-0.43.2}/src/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),