arrayview 0.45.0__tar.gz → 0.45.1__tar.gz

{arrayview-0.45.0 → arrayview-0.45.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arrayview
-Version: 0.45.0
+Version: 0.45.1
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview
@@ -59,6 +59,14 @@ uvx arrayview path/to/dicom-series/
 Press `v` for the three-plane ortho view. `Shift+3` replaces the current slice,
 or all three ortho panes, with interactive 3D cutaway renders.
 Drop another file onto an open viewer to compare, open separately, or overlay it.
+Press `Shift+R` for ROI analysis: a compact HUD lists each region's mean and standard
+deviation. The HUD sits beside the image when space allows; drag its header
+to move it. Hover a row or region to highlight its counterpart, and use each
+row's trash icon to delete that region. Open the detailed analysis with the
+button beside the HUD's column headings.
+Hold a flood-fill seed and drag up/down to adjust sensitivity; a translucent tapered gauge
+at the starting point shows the current value and the 1%–100% range. The
+pointer hides while adjusting; only the gauge marker moves.
 
 
 Check the [docs](https://oscarvanderheide.github.io/arrayview/) to learn more. 

{arrayview-0.45.0 → arrayview-0.45.1}/README.md

@@ -22,6 +22,14 @@ uvx arrayview path/to/dicom-series/
 Press `v` for the three-plane ortho view. `Shift+3` replaces the current slice,
 or all three ortho panes, with interactive 3D cutaway renders.
 Drop another file onto an open viewer to compare, open separately, or overlay it.
+Press `Shift+R` for ROI analysis: a compact HUD lists each region's mean and standard
+deviation. The HUD sits beside the image when space allows; drag its header
+to move it. Hover a row or region to highlight its counterpart, and use each
+row's trash icon to delete that region. Open the detailed analysis with the
+button beside the HUD's column headings.
+Hold a flood-fill seed and drag up/down to adjust sensitivity; a translucent tapered gauge
+at the starting point shows the current value and the 1%–100% range. The
+pointer hides while adjusting; only the gauge marker moves.
 
 
 Check the [docs](https://oscarvanderheide.github.io/arrayview/) to learn more. 

{arrayview-0.45.0 → arrayview-0.45.1}/pyproject.toml

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

arrayview-0.45.1/src/arrayview/_bootstrap_app.py

@@ -0,0 +1,120 @@
+"""Answer the health check while the real server is still loading.
+
+A freshly spawned daemon binds its port within ~150 ms, but importing the web
+framework and the route modules takes another ~300-500 ms (more on a busy
+host). Nothing that arrives in that window can be served by the real app, and
+the launcher, the VS Code opener and the tunnel proxy all wait on ``/ping``
+before they will open a viewer tab.
+
+This tiny ASGI app is what uvicorn serves from the moment the socket is bound:
+
+* ``GET /ping`` is answered immediately with the daemon's real identity (the
+  same payload the real route returns, built from ``_session``), so the tab
+  can be opened while the framework is still importing;
+* every other request simply waits in line and is handed to the real app the
+  moment it is attached, so the page download overlaps the import instead of
+  starting after it;
+* if the real app fails to load, waiting requests get a 503 and the daemon
+  exits, which is what happened before too — just later.
+
+No ordering that the launch relies on changes: ``/ping`` still reports the
+identity that the registry record carries, and the viewer page still cannot
+arrive before the server that serves it exists.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import threading
+from typing import Awaitable, Callable
+
+Scope = dict
+Receive = Callable[[], Awaitable[dict]]
+Send = Callable[[dict], Awaitable[None]]
+
+
+class BootstrapApp:
+    """ASGI app that answers ``/ping`` itself until the real app is attached."""
+
+    def __init__(self) -> None:
+        self._app = None
+        self._error: BaseException | None = None
+        self._ready = threading.Event()
+
+    # ── wiring (called from whichever thread loads the real app) ──────────
+    def attach(self, app) -> None:
+        self._app = app
+        self._ready.set()
+
+    def fail(self, error: BaseException) -> None:
+        self._error = error
+        self._ready.set()
+
+    @property
+    def ready(self) -> bool:
+        return self._app is not None
+
+    # ── ASGI ──────────────────────────────────────────────────────────────
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        kind = scope.get("type")
+        if kind == "lifespan":
+            await self._lifespan(receive, send)
+            return
+        if (
+            self._app is None
+            and kind == "http"
+            and scope.get("method") == "GET"
+            and scope.get("path") == "/ping"
+        ):
+            await self._ping(send)
+            return
+        if not self._ready.is_set():
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self._ready.wait)
+        if self._app is None:
+            await self._unavailable(kind, send)
+            return
+        await self._app(scope, receive, send)
+
+    async def _lifespan(self, receive: Receive, send: Send) -> None:
+        # The real app registers no startup/shutdown hooks, so uvicorn's
+        # lifespan protocol is answered here and never forwarded.
+        while True:
+            message = await receive()
+            if message["type"] == "lifespan.startup":
+                await send({"type": "lifespan.startup.complete"})
+            elif message["type"] == "lifespan.shutdown":
+                await send({"type": "lifespan.shutdown.complete"})
+                return
+
+    async def _ping(self, send: Send) -> None:
+        import arrayview._session as _session_mod
+
+        payload = _session_mod.ping_payload(
+            active_sessions=len(_session_mod.SESSIONS)
+        )
+        await _send_json(send, 200, payload)
+
+    async def _unavailable(self, kind: str | None, send: Send) -> None:
+        detail = f"ArrayView server failed to start: {self._error!r}"
+        if kind == "websocket":
+            await send({"type": "websocket.close", "code": 1011, "reason": detail[:120]})
+            return
+        await _send_json(send, 503, {"error": detail, "type": "ServerStartupFailed"})
+
+
+async def _send_json(send: Send, status: int, payload: dict) -> None:
+    body = json.dumps(payload).encode("utf-8")
+    await send(
+        {
+            "type": "http.response.start",
+            "status": status,
+            "headers": [
+                (b"content-type", b"application/json"),
+                (b"content-length", str(len(body)).encode("ascii")),
+                (b"cache-control", b"no-store"),
+            ],
+        }
+    )
+    await send({"type": "http.response.body", "body": body})

{arrayview-0.45.0 → arrayview-0.45.1}/src/arrayview/_launch_plan.py

@@ -9,6 +9,7 @@ import os
 import socket
 import sys
 import time
+import urllib.error
 import urllib.request
 import uuid
 
@@ -710,6 +711,11 @@ def _ping_arrayview_server(port: int) -> dict | None:
                 payload = json.loads(resp.read().decode("utf-8"))
             if payload.get("ok") is True and payload.get("service") == "arrayview":
                 return payload
+        except urllib.error.URLError as exc:
+            # Nobody is listening on the port: retrying cannot change that,
+            # and the two 50 ms pauses were paid on every fresh launch.
+            if isinstance(exc.reason, ConnectionRefusedError):
+                return None
         except Exception:
             pass
         if attempt < 2:

{arrayview-0.45.0 → arrayview-0.45.1}/src/arrayview/_launcher.py

@@ -155,15 +155,17 @@ def _register_server_runtime(port: int, owner_mode: str):
         os.chmod(log_directory, 0o700)
     except OSError:
         pass
+    # Identity lives in _session, not _server, so registering does not pull in
+    # the web framework: the daemon can answer /ping before that import runs.
     record = InstanceRecord.create(
         port=port,
-        protocol_version=_server_mod().SERVER_PROTOCOL_VERSION,
+        protocol_version=_session_mod.SERVER_PROTOCOL_VERSION,
         package_version=__version__,
         owner_mode=owner_mode,
         log_path=str(log_directory / f"server-{os.getpid()}.log"),
     )
     registry.write(record)
-    _server_mod().configure_server_runtime(
+    _session_mod.configure_server_runtime(
         instance_id=record.instance_id,
         process_start=record.process_start,
         owner_mode=record.owner_mode,
@@ -4622,13 +4624,24 @@ def _serve_daemon(
         port=record.port,
     )
 
+    # Serve from the bootstrap app right away: /ping answers with this
+    # daemon's identity while the web framework is still importing, so the
+    # launcher and the opener can open the tab ~0.4 s sooner and the page
+    # download overlaps the import. Every other request waits in line and is
+    # served by the real app the moment it is attached.
+    from arrayview._bootstrap_app import BootstrapApp
+
+    bootstrap = BootstrapApp()
+    uvicorn_server: list = []
+
     def _run_uvicorn_on_socket():
         config = _uvicorn().Config(
-            _server_mod().app,
+            bootstrap,
             log_level="error",
             timeout_keep_alive=30,
         )
         server = _uvicorn().Server(config)
+        uvicorn_server.append(server)
         asyncio.run(server.serve(sockets=sock))
 
     # Start uvicorn immediately — the window can open before data is ready.
@@ -4638,14 +4651,43 @@ def _serve_daemon(
     ).start()
     _trace_launch_event("backend.http_thread_started", port=port)
 
-    # Pre-warm colormap LUTs in background (saves ~200 ms on first frame render).
-    def _warm_luts():
+    # Let the listener come up before any CPU-heavy import starts: with the
+    # framework import, the colormap warm-up and the data load all competing
+    # for the interpreter, uvicorn's own startup was measured taking ~0.6 s
+    # instead of ~0.03 s, which delayed the first /ping answer by the same.
+    serving_deadline = time.monotonic() + 5.0
+    while time.monotonic() < serving_deadline:
+        if uvicorn_server and getattr(uvicorn_server[0], "started", False):
+            break
+        time.sleep(0.002)
+    _trace_launch_event("backend.serving", port=port)
+
+    def _attach_full_app():
+        try:
+            bootstrap.attach(_server_mod().app)
+        except BaseException as exc:  # noqa: BLE001 — any failure here is fatal
+            bootstrap.fail(exc)
+            _trace_launch_event("daemon.exiting", reason="server_import_failed")
+            _vprint(f"[ArrayView] server failed to start: {exc!r}", flush=True)
+            try:
+                registry.remove(record.instance_id)
+            except Exception:
+                pass
+            _cleanup_source_staging_dirs(source_staging_dirs)
+            os._exit(1)
+        _trace_launch_event("backend.app_attached", port=port)
+        # Pre-warm colormap LUTs (the page and the first frame both need
+        # them). Sequenced after the framework import rather than alongside
+        # it: run together they contend for the interpreter and both finish
+        # later than they do one after the other.
         try:
             from arrayview._render import _init_luts
             _init_luts()
         except Exception:
             pass
-    threading.Thread(target=_warm_luts, daemon=True).start()
+        _trace_launch_event("backend.luts_ready", port=port)
+
+    threading.Thread(target=_attach_full_app, daemon=True).start()
 
     def _load():
         from arrayview._io import (

{arrayview-0.45.0 → arrayview-0.45.1}/src/arrayview/_platform.py

@@ -102,6 +102,12 @@ def _in_jupyter() -> bool:
     global _JUPYTER_CACHE
     if _JUPYTER_CACHE is not None:
         return _JUPYTER_CACHE
+    # A notebook kernel has IPython loaded before any user code runs, so a
+    # process without it cannot be one. Importing IPython just to ask costs
+    # ~250 ms on every terminal launch; skip it when it is not already there.
+    if "IPython" not in sys.modules:
+        _JUPYTER_CACHE = False
+        return False
     try:
         from IPython import get_ipython
 

{arrayview-0.45.0 → arrayview-0.45.1}/src/arrayview/_server.py

@@ -9,7 +9,6 @@ import json
 import os
 import time
 import uuid
-from dataclasses import dataclass, replace
 from urllib.parse import urlencode
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import HTMLResponse, JSONResponse, Response
@@ -25,7 +24,6 @@ from arrayview._session import (
     COLORMAPS,
 )
 from arrayview import __version__ as _av_version
-from arrayview._instance_registry import process_start_identity
 import arrayview._session as _session_mod  # for mutable VIEWER_SOCKETS
 
 from arrayview._render import (
@@ -68,75 +66,17 @@ from arrayview._imaging import ensure_image as _pil_image, ensure_imageops as _p
 app = FastAPI()
 
 
-SERVER_PROTOCOL_VERSION = "1"
-SERVER_CAPABILITIES = (
-    "health-status",
-    "session-registration",
-    "identity-fenced-load",
-    "identity-fenced-mutations",
-    "transactional-relay-display",
-    "viewer-websocket",
-    "viewer-phase-journal",
-    "shell-websocket",
-    "dir-collection-case-inference",
-    "staged-drop-import",
+# Identity, capabilities and the /ping contract are owned by _session.py so a
+# booting daemon can answer /ping before this module has imported. Re-exported
+# here so callers and tests keep addressing them through the server module.
+from arrayview._session import (  # noqa: E402
+    SERVER_CAPABILITIES,
+    SERVER_PROTOCOL_VERSION,
+    ServerRuntimeState,
+    configure_server_runtime,
 )
 
 
-def _environment_port() -> int | None:
-    value = os.environ.get("ARRAYVIEW_SERVER_PORT")
-    if not value:
-        return None
-    try:
-        port = int(value)
-    except ValueError:
-        return None
-    return port if 0 < port < 65536 else None
-
-
-def _environment_started_at() -> float:
-    value = os.environ.get("ARRAYVIEW_STARTED_AT")
-    if value:
-        try:
-            return float(value)
-        except ValueError:
-            pass
-    return time.time()
-
-
-@dataclass(frozen=True)
-class ServerRuntimeState:
-    """Stable identity and ownership metadata for this server process."""
-
-    instance_id: str
-    process_start: str
-    owner_mode: str
-    started_at: float
-    port: int | None
-    protocol_version: str = SERVER_PROTOCOL_VERSION
-    capabilities: tuple[str, ...] = SERVER_CAPABILITIES
-
-
-if _session_mod.SERVER_RUNTIME is None:
-    _session_mod.SERVER_RUNTIME = ServerRuntimeState(
-        instance_id=os.environ.get("ARRAYVIEW_INSTANCE_ID") or str(uuid.uuid4()),
-        process_start=(
-            os.environ.get("ARRAYVIEW_PROCESS_START")
-            or process_start_identity(os.getpid())
-            or f"pid-only:{os.getpid()}"
-        ),
-        owner_mode=os.environ.get("ARRAYVIEW_OWNER_MODE", "unknown"),
-        started_at=_environment_started_at(),
-        port=_environment_port(),
-    )
-
-
-def configure_server_runtime(**changes) -> ServerRuntimeState:
-    """Set launch metadata once the listener's final ownership/port is known."""
-    _session_mod.SERVER_RUNTIME = replace(_session_mod.SERVER_RUNTIME, **changes)
-    return _session_mod.SERVER_RUNTIME
-
-
 @app.exception_handler(Exception)
 async def _generic_exception_handler(request: Request, exc: Exception):
     import traceback
@@ -164,6 +104,42 @@ _GSAP_JS: str = (
     _pkg_files("arrayview").joinpath("gsap.min.js").read_text(encoding="utf-8")
 )
 
+
+def _split_viewer_template(template: str) -> tuple[str, str, str]:
+    """Split the viewer into a per-launch page and one static script.
+
+    Everything in the main script below ``__AV_STATIC_SCRIPT_BELOW__`` is
+    byte-identical on every launch (all substituted values sit above the
+    marker), so it is served as ``viewer-<hash>.js`` with an immutable cache
+    header instead of being re-sent inside every page. On a VS Code tunnel
+    that is ~400 KB gzipped per open that the browser now keeps. The source
+    file stays one self-contained HTML document; the split happens here.
+    Returns ``(page_template, static_js, static_hash)``; without the marker
+    the whole file is served inline exactly as before.
+    """
+    marker = "__AV_STATIC_SCRIPT_BELOW__"
+    marker_at = template.find(marker)
+    if marker_at < 0:
+        return template, "", ""
+    script_start = template.index("\n", marker_at) + 1
+    script_end = template.index("</script>", script_start)
+    static_js = template[script_start:script_end]
+    import hashlib
+
+    digest = hashlib.sha256(static_js.encode("utf-8")).hexdigest()[:16]
+    page = (
+        template[:script_start]
+        + f'    </script>\n    <script src="viewer-{digest}.js">'
+        + template[script_end:]
+    )
+    return page, static_js, digest
+
+
+_VIEWER_PAGE_TEMPLATE, _VIEWER_STATIC_JS, _VIEWER_STATIC_JS_HASH = (
+    _split_viewer_template(_VIEWER_HTML_TEMPLATE)
+)
+_VIEWER_STATIC_JS_GZIP: bytes | None = None
+
 # The viewer page is ~2 MB of single-file HTML. On loopback that is free, but a
 # VS Code tunnel relays every byte through a cloud endpoint, where the same
 # payload has been observed taking 8-18 s. gzip cuts it to ~380 KB (5x), so the
@@ -207,11 +183,53 @@ def _text_response(
     return Response(content=packed, media_type=media_type, headers=out)
 
 
+@app.get("/viewer-{digest}.js")
+def serve_viewer_static_js(digest: str, request: Request):
+    """Serve the launch-independent part of the viewer script.
+
+    The digest is in the URL, so a changed viewer gets a new address and the
+    browser may keep this one forever; a stale address is simply unknown.
+    """
+    if not _VIEWER_STATIC_JS or digest != _VIEWER_STATIC_JS_HASH:
+        return Response(status_code=404)
+    headers = {"Cache-Control": "public, max-age=31536000, immutable"}
+    if not _accepts_gzip(request):
+        return Response(
+            content=_VIEWER_STATIC_JS,
+            media_type="application/javascript",
+            headers=headers,
+        )
+    global _VIEWER_STATIC_JS_GZIP
+    if _VIEWER_STATIC_JS_GZIP is None:
+        import gzip
+
+        _VIEWER_STATIC_JS_GZIP = gzip.compress(_VIEWER_STATIC_JS.encode("utf-8"), 6)
+    headers["Content-Encoding"] = "gzip"
+    headers["Vary"] = "Accept-Encoding"
+    return Response(
+        content=_VIEWER_STATIC_JS_GZIP,
+        media_type="application/javascript",
+        headers=headers,
+    )
+
+
+_GSAP_ETAG = '"' + __import__("hashlib").sha256(_GSAP_JS.encode("utf-8")).hexdigest()[:16] + '"'
+
+
 @app.get("/gsap.min.js")
 def serve_gsap(request: Request):
-    """Serve vendored GSAP library (browser caches via ETag)."""
+    """Serve the vendored GSAP library.
+
+    Cached for a day and revalidated by ETag after that, so a repeat launch
+    costs one small round trip instead of another 28 KB through the tunnel.
+    """
+    if request.headers.get("if-none-match") == _GSAP_ETAG:
+        return Response(status_code=304, headers={"ETag": _GSAP_ETAG})
     return _text_response(
-        _GSAP_JS, request=request, media_type="application/javascript"
+        _GSAP_JS,
+        request=request,
+        media_type="application/javascript",
+        headers={"Cache-Control": "max-age=86400", "ETag": _GSAP_ETAG},
     )
 
 
@@ -347,40 +365,7 @@ async def cold_start_port(payload: dict):
 @app.get("/ping")
 def ping():
     """Health marker so clients can verify this is an ArrayView server."""
-    import socket
-
-    runtime = _session_mod.SERVER_RUNTIME
-    return {
-        "ok": True,
-        "service": "arrayview",
-        "pid": os.getpid(),
-        "uid": os.geteuid() if hasattr(os, "geteuid") else None,
-        "hostname": socket.gethostname(),
-        "protocol_version": runtime.protocol_version,
-        "package_version": _av_version,
-        "instance_id": runtime.instance_id,
-        "process_start": runtime.process_start,
-        "owner_mode": runtime.owner_mode,
-        "started_at": runtime.started_at,
-        "port": runtime.port,
-        "capabilities": list(runtime.capabilities),
-        "active_sessions": len(SESSIONS),
-        "active_viewer_sockets": _session_mod.VIEWER_SOCKETS,
-        "active_shell_sockets": len(_session_mod.SHELL_SOCKETS),
-        "viewer_sockets": _session_mod.VIEWER_SOCKETS,
-        "viewer_connections_seen": _session_mod.VIEWER_CONNECTIONS_SEEN,
-        "shell_sockets": len(_session_mod.SHELL_SOCKETS),
-        "shell_request_ids": sorted(_session_mod.SHELL_REQUEST_IDS),
-        "active_viewer_requests": sorted(
-            f"{sid}:{request_id}"
-            for (sid, request_id), count in _session_mod.VIEWER_REQUEST_COUNTS.items()
-            if count > 0
-        ),
-        "native_ready_requests": sorted(
-            f"{sid}:{request_id}"
-            for sid, request_id in _session_mod.NATIVE_READY_REQUESTS
-        ),
-    }
+    return _session_mod.ping_payload(active_sessions=len(SESSIONS))
 
 
 @app.get("/status")
@@ -428,13 +413,50 @@ def _trace_page_request(
         pass
 
 
+def _boot_metadata_json(sid: str | None) -> str:
+    """The array's description, for the page to carry instead of asking.
+
+    The viewer otherwise waits for the server to push this over the freshly
+    opened WebSocket, which costs half a round trip before it can request its
+    first frame — noticeable over a VS Code tunnel. The server already knows
+    which session the page is for, so it writes the description into the page.
+
+    Returns ``"null"`` whenever the answer is not already known (no sid, still
+    loading, or anything unexpected); the viewer then asks the way it always
+    has. This must never wait for a session: a pending one is exactly the case
+    the WebSocket push handles better.
+    """
+    if not sid:
+        return "null"
+    try:
+        if sid in _session_mod.PENDING_SESSIONS:
+            return "null"
+        session = SESSIONS.get(sid)
+        if session is None:
+            return "null"
+        from arrayview._analysis import _build_metadata
+
+        return json.dumps(_build_metadata(session))
+    except Exception:
+        return "null"
+
+
 def _viewer_ui_response(
     request: Request,
     *,
     sid: str | None,
     query_val: str,
+    asset_base: str = "",
 ):
-    """Render one viewer page with its launch query already chosen."""
+    """Render one viewer page with its launch query already chosen.
+
+    ``asset_base`` is prepended to the page's script addresses. The plain
+    route keeps them relative so the page also works behind a Jupyter proxy
+    prefix; the private tunnel route passes "/" so the addresses are the
+    same on every launch and the browser can reuse the cached script
+    (relative addresses under /_av/<tab>/... change with every tab key, which
+    made the built-in browser download the 400 KB script on every open).
+    """
     _init_luts()
     _cfg_colormaps = get_viewer_colormaps()
     _valid_cfg_colormaps = (
@@ -451,12 +473,13 @@ def _viewer_ui_response(
     _default_ortho_layout = json.dumps(get_viewer_ortho_layout())
     _default_dimbar_mode = json.dumps(get_viewer_dimbar_mode())
     html = (
-        _VIEWER_HTML_TEMPLATE.replace("__COLORMAPS__", str(_active_colormaps))
+        _VIEWER_PAGE_TEMPLATE.replace("__COLORMAPS__", str(_active_colormaps))
         .replace("__COLORMAP_GRADIENT_STOPS__", json.dumps(COLORMAP_GRADIENT_STOPS))
         .replace("__LABEL_COLORS__", json.dumps(LABEL_COLORS.astype(int).tolist()))
         .replace("__COMPLEX_MODES__", str(COMPLEX_MODES))
         .replace("__REAL_MODES__", str(REAL_MODES))
         .replace("__ARRAYVIEW_QUERY__", query_val)
+        .replace("__ARRAYVIEW_BOOT_METADATA__", _boot_metadata_json(sid))
         .replace("__DEFAULT_THEME_IDX__", str(_default_theme_idx))
         .replace("__DEFAULT_ROUNDED_PANES__", _default_rounded_panes)
         .replace("__DEFAULT_ORTHO_LAYOUT__", _default_ortho_layout)
@@ -464,6 +487,9 @@ def _viewer_ui_response(
         .replace("__BODY_CLASS__", "av-loading" if sid else "")
         .replace("__ARRAYVIEW_VERSION__", _av_version)
     )
+    if asset_base:
+        html = html.replace('<script src="gsap.min.js">', f'<script src="{asset_base}gsap.min.js">')
+        html = html.replace('<script src="viewer-', f'<script src="{asset_base}viewer-')
     return _text_response(
         html,
         request=request,
@@ -479,6 +505,15 @@ def get_short_viewer_ui(
     navigation_key: str,
 ):
     """Resolve a private integrated-browser launch without exposing its query."""
+    # The page's script tags use relative addresses so they also work behind
+    # a Jupyter proxy prefix. Under this nested route the browser resolves
+    # them to /_av/<tab_key>/<asset>, so the assets are answered here too.
+    # (Before this, gsap.min.js silently 404'd on every tunnel launch and the
+    # viewer ran without its animation library.)
+    if navigation_key == "gsap.min.js":
+        return serve_gsap(request)
+    if navigation_key.startswith("viewer-") and navigation_key.endswith(".js"):
+        return serve_viewer_static_js(navigation_key[len("viewer-"):-3], request)
     try:
         from arrayview._launch_trace import emit_route_launch_event
 
@@ -535,6 +570,7 @@ def get_short_viewer_ui(
         request,
         sid=sid,
         query_val=json.dumps(bootstrap_query),
+        asset_base="/",
     )