arrayview 0.35.3__tar.gz → 0.37.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.35.3
+Version: 0.37.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.35.3 → arrayview-0.37.1}/pyproject.toml

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

{arrayview-0.35.3 → arrayview-0.37.1}/src/arrayview/_io.py

@@ -1397,6 +1397,76 @@ def _load_nifti_series(path, *, load="lazy", stack="auto"):
     return _series_from_file_matrix(file_matrix, load=load, stack=stack)
 
 
+_MMAP_PAGE_BYTES = 4096
+
+
+def npy_eager_limit() -> int:
+    """Largest .npy that may be read fully into RAM."""
+    return int(os.environ.get("AV_NPY_EAGER_BYTES", 2 * 1024**3))
+
+
+def first_frame_fault_cost(shape, itemsize, strides, dims, total_bytes):
+    """Estimate what a memmap must fetch to render one 2D slice.
+
+    Returns ``(runs, bytes)``.  Both matter, and on network storage the run
+    count matters more: a frame of 210 single-page runs measured 1.34 s off an
+    SMB share while transferring under a megabyte, because the cost was 210
+    round-trips rather than the bytes.
+
+    Only the layout is consulted, so this touches no data.  The displayed axes
+    are ordered by stride; the inner one decides whether the frame arrives as a
+    few long runs or as one page per element.
+    """
+    dx, dy = dims
+    inner, outer = sorted(
+        ((abs(int(strides[d])), int(shape[d])) for d in (dx, dy)),
+        key=lambda pair: pair[0],
+    )
+    inner_stride, inner_len = inner
+    outer_stride, outer_len = outer
+
+    row_span = inner_len * inner_stride
+    if inner_stride == itemsize and outer_stride == row_span:
+        # The displayed pair is itself one contiguous block (e.g. axes (0, 1) of
+        # a Fortran-order array, or the trailing pair of a C-order one).
+        return 1, min(row_span * outer_len, int(total_bytes))
+    if inner_stride >= _MMAP_PAGE_BYTES:
+        # Nothing shares a page: one fetch per element, the pathological case.
+        runs = inner_len * outer_len
+        return runs, min(runs * _MMAP_PAGE_BYTES, int(total_bytes))
+    # Each row is one near-contiguous span; rows are scattered across the file.
+    row_bytes = max(row_span, _MMAP_PAGE_BYTES)
+    return outer_len, min(outer_len * row_bytes, int(total_bytes))
+
+
+def mmap_first_frame_is_cheap(arr, total_bytes) -> bool:
+    """Whether serving the viewer's first frame off *arr* beats reading it whole.
+
+    A memmap wins when the axes the viewer starts on are the fastest-varying
+    ones in the file layout, and loses badly when they are the slowest: the same
+    4D array costs a single contiguous block in Fortran order and roughly one
+    page per element in C order.  Both regimes are common, so decide per array
+    rather than assuming either.
+    """
+    if os.environ.get("AV_MMAP_FIRST_FRAME", "1") == "0":
+        return False
+    from ._session import _viewer_start_dims_for_shape
+
+    shape = tuple(int(s) for s in getattr(arr, "shape", ()))
+    strides = tuple(int(s) for s in getattr(arr, "strides", ()))
+    if len(shape) < 2 or len(strides) != len(shape) or not total_bytes:
+        return False
+    dims = _viewer_start_dims_for_shape(shape)
+    if dims is None:
+        return False
+    runs, faulted = first_frame_fault_cost(
+        shape, arr.dtype.itemsize, strides, dims, total_bytes
+    )
+    max_runs = int(os.environ.get("AV_MMAP_FIRST_FRAME_MAX_RUNS", "1024"))
+    fraction = float(os.environ.get("AV_MMAP_FIRST_FRAME_FRACTION", "0.25"))
+    return runs <= max_runs and faulted <= fraction * total_bytes
+
+
 def load_data_with_meta(filepath, key=None, *, load="lazy", stack="auto", select=None):
     """Like load_data but also returns spatial metadata for NIfTI files.
 
@@ -1430,15 +1500,20 @@ def load_data(filepath, key=None):
         series, _meta = _load_file_series(filepath)
         return series
     if filepath.endswith(".npy"):
-        # Eager-load small-to-medium files into RAM.  mmap_mode="r" on a C-order
-        # 4D+ array forces scattered page faults for every orthogonal slice
-        # (elements are thousands of bytes apart), making first renders very slow.
-        # Sequential read is much faster and the PENDING_SESSIONS background thread
-        # hides the upfront cost.  Keep mmap only for files that don't fit in RAM.
-        _NPY_EAGER_LIMIT = int(os.environ.get("AV_NPY_EAGER_BYTES", 2 * 1024**3))
-        if os.path.getsize(filepath) < _NPY_EAGER_LIMIT:
-            return np.load(filepath)
-        return np.load(filepath, mmap_mode="r")
+        # Files that do not fit in RAM must be mapped whatever the access cost.
+        # Below that limit the array ends up in RAM either way; the only question
+        # is whether the first frame is served from the map while the sequential
+        # read runs behind it (see mmap_first_frame_is_cheap) or the viewer shows
+        # a spinner until the read completes.
+        size = os.path.getsize(filepath)
+        if size >= npy_eager_limit():
+            return np.load(filepath, mmap_mode="r")
+        mapped = np.load(filepath, mmap_mode="r")
+        if mmap_first_frame_is_cheap(mapped, size):
+            # Session creation upgrades this to an in-RAM array in the background.
+            return mapped
+        del mapped
+        return np.load(filepath)
     elif filepath.endswith(".npz"):
         npz = np.load(filepath)
         try:

{arrayview-0.35.3 → arrayview-0.37.1}/src/arrayview/_launcher.py

@@ -1672,7 +1672,7 @@ def _register_cli_session_with_existing_server_impl(
             error += (
                 "\nThe server on this port is an older ArrayView process that "
                 "does not support automatic --overlay-dir case inference yet. "
-                f"Restart it with: arrayview --kill --port {port}"
+                "Restart it with: arrayview stop"
             )
         raise RuntimeError(f"Error from server: {error}")
     _loaded_sids.append(str(result["sid"]))
@@ -1860,7 +1860,7 @@ def _handle_cli_existing_server(
             print(
                 f"Error: existing ArrayView server on port {port} does not support "
                 "directory stacking. Restart it with "
-                f"`arrayview --kill --port {port}` or choose a free port with "
+                "`arrayview stop` or choose a free port with "
                 f"`--port`. ({e})"
             )
             sys.exit(1)
@@ -2590,6 +2590,11 @@ _PERSIST_DAEMON_CONNECT_TIMEOUT_SECONDS = float(
 _PERSIST_DAEMON_IDLE_SECONDS = float(
     os.environ.get("ARRAYVIEW_PERSIST_IDLE_SECONDS", "1800")
 )
+# How long a daemon whose initial load failed keeps serving so the opener can
+# read the reason from /metadata/<sid> before the port is released.
+_FAILED_LOAD_EXIT_GRACE_SECONDS = float(
+    os.environ.get("ARRAYVIEW_FAILED_LOAD_EXIT_GRACE_SECONDS", "30")
+)
 
 
 def _join_query_values(values: _CSVValues) -> str:
@@ -4169,6 +4174,7 @@ def _serve_daemon(
         owner="persistent" if persist else "transient",
     )
     # Register sid as pending so /metadata can poll while data loads.
+    _initial_load_failed = threading.Event()
     _session_mod.PENDING_SESSIONS.add(sid)
     _pending_event = threading.Event()
     _session_mod.PENDING_SESSION_EVENTS[sid] = _pending_event
@@ -4301,6 +4307,7 @@ def _serve_daemon(
                         f"[ArrayView] Warning: failed to load vector field {vfield_filepath}: {e}",
                         flush=True,
                     )
+            _session_mod.upgrade_memmap_in_background(session)
             _session_mod.SESSIONS[session.sid] = session
             if dir_overlay_items is not None:
                 for item, ov_sid in zip(dir_overlay_items, overlay_sids or []):
@@ -4349,6 +4356,18 @@ def _serve_daemon(
                 sid_tag=sid_tag,
                 error_type=type(exc).__name__,
             )
+            # This runs on a daemon thread, so re-raising only kills the thread
+            # and writes to a stderr nobody reads. Record why the sid will never
+            # become ready so /metadata can report it instead of returning 404
+            # until the opener gives up.
+            _session_mod.FAILED_PENDING_SESSIONS[sid] = (
+                str(exc) or type(exc).__name__
+            )
+            _vprint(
+                f"[ArrayView] Failed to load {filepath}: {exc}",
+                flush=True,
+            )
+            _initial_load_failed.set()
             raise
         finally:
             _session_mod.PENDING_SESSIONS.discard(sid)
@@ -4357,6 +4376,32 @@ def _serve_daemon(
 
     threading.Thread(target=_load, daemon=True).start()
 
+    def _exit_if_initial_load_failed() -> None:
+        """Release the port when the file this daemon exists to serve won't load.
+
+        uvicorn starts before the load finishes, so a failed load otherwise
+        leaves a server with no session holding the port until the connect
+        timeout expires minutes later — and answering /ping the whole time. The
+        grace period is only so the opener can read the failure from
+        /metadata/<sid> before the port goes away.
+        """
+        _initial_load_failed.wait()
+        time.sleep(_FAILED_LOAD_EXIT_GRACE_SECONDS)
+        if _session_mod.SESSIONS or _session_mod.VIEWER_SOCKETS:
+            return  # something else is using this server; leave it alone
+        _trace_launch_event(
+            "daemon.exiting",
+            reason="initial_load_failed",
+            instance_tag=_launch_trace_tag(record.instance_id),
+        )
+        try:
+            registry.remove(record.instance_id)
+        except Exception:
+            pass
+        os._exit(0)
+
+    threading.Thread(target=_exit_if_initial_load_failed, daemon=True).start()
+
     if persist:
         _wait_for_viewer_close(
             idle_seconds=_PERSIST_DAEMON_IDLE_SECONDS,
@@ -4771,9 +4816,29 @@ def _instance_public_dict(record) -> dict[str, object]:
     return value
 
 
+def _run_stop_command() -> None:
+    """Stop every running ArrayView instance and clean up stale state."""
+    from arrayview._instance_registry import InstanceRegistry  # noqa: PLC0415
+
+    records = InstanceRegistry().discover(clean_stale=True)
+    if not records:
+        print("[ArrayView] No running ArrayView instances.")
+    for record in records:
+        message, _pid = _stop_verified_server(record.port)
+        print(f"[ArrayView] {record.instance_id}: {message}")
+
+    from arrayview._vscode_signal import (  # noqa: PLC0415
+        _cleanup_zombie_registrations,
+    )
+
+    cleaned = _cleanup_zombie_registrations(verbose=True)
+    if cleaned:
+        print(f"[ArrayView] Cleaned {cleaned} zombie window registration(s)")
+
+
 def _handle_management_command(argv: list[str]) -> bool:
     """Handle dependency-light management subcommands before the file CLI."""
-    if not argv or argv[0] not in {"doctor", "instances", "stop"}:
+    if not argv or argv[0] not in {"doctor", "instances", "stop", "kill"}:
         return False
     command = argv[0]
     parser = argparse.ArgumentParser(prog=f"arrayview {command}")
@@ -4799,22 +4864,10 @@ def _handle_management_command(argv: list[str]) -> bool:
                 )
         return True
 
-    if command == "stop":
-        group = parser.add_mutually_exclusive_group(required=True)
-        group.add_argument("instance_id", nargs="?")
-        group.add_argument("--all", action="store_true")
-        args = parser.parse_args(argv[1:])
-        records = InstanceRegistry().discover(clean_stale=True)
-        selected = (
-            records
-            if args.all
-            else [record for record in records if record.instance_id == args.instance_id]
-        )
-        if not selected:
-            parser.error("no matching running ArrayView instance")
-        for record in selected:
-            message, _pid = _stop_verified_server(record.port)
-            print(f"[ArrayView] {record.instance_id}: {message}")
+    if command in {"stop", "kill"}:
+        parser.description = "Stop every running ArrayView server."
+        parser.parse_args(argv[1:])
+        _run_stop_command()
         return True
 
     parser.add_argument("--json", action="store_true")
@@ -4958,7 +5011,7 @@ def arrayview():
     parser.add_argument(
         "--kill",
         action="store_true",
-        help="Kill the ArrayView server running on --port (default 8000) and exit",
+        help="Deprecated: use `arrayview stop`",
     )
     parser.add_argument(
         "--overlay",
@@ -5306,15 +5359,9 @@ def arrayview():
             sys.exit(1)
         return
 
-    # -- --kill: stop the server on the given port --
+    # -- --kill: deprecated alias for `arrayview stop` --
     if args.kill:
-        message, _pid = _stop_verified_server(args.port)
-        print(f"[ArrayView] {message}")
-
-        from arrayview._vscode_signal import _cleanup_zombie_registrations
-        cleaned = _cleanup_zombie_registrations(verbose=True)
-        if cleaned:
-            print(f"[ArrayView] Cleaned {cleaned} zombie window registration(s)")
+        _run_stop_command()
         return
 
     # -- --serve: start a persistent empty server and exit --
@@ -5359,7 +5406,7 @@ def arrayview():
                 if serve_context.evidence.is_vscode_remote:
                     print(
                         f"[ArrayView] Port {args.port} was claimed while starting.\n"
-                        f"  Run 'arrayview --kill --port {args.port}' to free it, "
+                        "  Run 'arrayview stop' to free it, "
                         "or use --port to specify a different port.",
                         flush=True,
                     )
@@ -5631,7 +5678,7 @@ def arrayview():
     if launch_plan.failure is LaunchFailure.REMOTE_PORT_CONFLICT:
         print(
             f"[ArrayView] Port {args.port} is in use by another process.\n"
-            f"  Run 'arrayview --kill --port {args.port}' to free it, "
+            "  Run 'arrayview stop' to free it, "
             f"or use --port to specify a different port.",
             flush=True,
         )

{arrayview-0.35.3 → arrayview-0.37.1}/src/arrayview/_routes_loading.py

@@ -18,11 +18,13 @@ from arrayview._lifecycle import (
 )
 from arrayview._session import (
     CANCELLED_PENDING_SESSIONS,
+    FAILED_PENDING_SESSIONS,
     PENDING_SESSION_EVENTS,
     PENDING_SESSIONS,
     SESSIONS,
     Session,
     file_signature,
+    upgrade_memmap_in_background,
     wait_for_session_ready,
 )
 
@@ -263,6 +265,7 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
             # the real Session instead of seeing a transient 404.
             sid = requested_sid or uuid.uuid4().hex
             pending_event = threading.Event()
+            FAILED_PENDING_SESSIONS.pop(sid, None)
             PENDING_SESSIONS.add(sid)
             PENDING_SESSION_EVENTS[sid] = pending_event
             signature_before_load = file_signature(abs_path)
@@ -291,14 +294,17 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                     session.related_release_sids = [
                         str(value) for value in body.get("related_sids", [])
                     ]
+                    upgrade_memmap_in_background(session)
                     commit_pending_session(sid, session)
                 except Exception as exc:
-                    # Keep the server alive and make the failure visible in its
-                    # log. The opener will fail closed when metadata never
-                    # becomes ready, while a retry creates a fresh request.
+                    # Keep the server alive, and record why this sid will never
+                    # become ready. Without the record the opener cannot tell a
+                    # failed load from a slow one and burns its whole deadline
+                    # on a file that raised immediately.
                     import traceback
 
                     traceback.print_exc()
+                    FAILED_PENDING_SESSIONS[sid] = str(exc) or exc.__class__.__name__
                 finally:
                     PENDING_SESSIONS.discard(sid)
                     CANCELLED_PENDING_SESSIONS.discard(sid)

{arrayview-0.35.3 → arrayview-0.37.1}/src/arrayview/_routes_query.py

@@ -211,6 +211,14 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
         # request; the opener retries until the pending Session is published.
         if sid in _session_mod.PENDING_SESSIONS:
             return Response(status_code=404, headers={"Retry-After": "1"})
+        # A load that raised is terminal. Say so with a distinct status and the
+        # real reason, so the caller stops polling and can show the user why
+        # this file will never open instead of waiting out its deadline.
+        load_error = _session_mod.FAILED_PENDING_SESSIONS.get(sid)
+        if load_error is not None:
+            return Response(
+                status_code=422, content=load_error.encode(), media_type="text/plain"
+            )
         session = await wait_for_session_ready(sid)
         if not session:
             return Response(status_code=404)

{arrayview-0.35.3 → arrayview-0.37.1}/src/arrayview/_session.py

@@ -41,6 +41,10 @@ _window_process = None
 PENDING_SESSIONS: set = set()  # sids whose data is still loading in a background thread
 PENDING_SESSION_EVENTS: dict[str, threading.Event] = {}
 CANCELLED_PENDING_SESSIONS: set[str] = set()
+# sid -> why its background load failed. A load that raises must be reportable:
+# without this the opener cannot tell "still loading" from "will never load" and
+# waits out its whole deadline on a file that failed in the first second.
+FAILED_PENDING_SESSIONS: dict[str, str] = {}
 
 
 def file_signature(filepath: str):
@@ -454,6 +458,49 @@ def _startup_dims_for_data(data, shape=None) -> tuple[int, int] | None:
     return _viewer_start_dims_for_shape(target_shape)
 
 
+def upgrade_memmap_in_background(session) -> bool:
+    """Read a memmap-backed session into RAM behind the viewer.
+
+    ``load_data`` hands back a memmap only when the first frame is cheap to
+    fault in, which buys an immediate picture but leaves later orientations
+    paying scattered reads.  The sequential read still has to happen, so run it
+    off the hot path and swap the array in when it lands.
+
+    Rebinding ``session.data`` is atomic under the GIL and the values are
+    identical, so a render already holding the memmap stays correct and the
+    slice caches stay valid.
+    """
+    data = getattr(session, "data", None)
+    filepath = getattr(session, "filepath", None)
+    if not isinstance(data, np.memmap) or not filepath:
+        return False
+    if not str(filepath).endswith(".npy"):
+        return False
+    try:
+        from ._io import npy_eager_limit
+
+        if os.path.getsize(filepath) >= npy_eager_limit():
+            return False  # does not fit in RAM — the map is the only option
+    except OSError:
+        return False
+
+    expected = data
+    version = getattr(session, "data_version", 0)
+
+    def _upgrade():
+        try:
+            loaded = np.load(filepath)
+        except Exception:
+            return  # keep serving from the map
+        # A /reload or a released session must not be clobbered by a read that
+        # started against the previous array.
+        if session.data is expected and getattr(session, "data_version", 0) == version:
+            session.data = loaded
+
+    threading.Thread(target=_upgrade, daemon=True).start()
+    return True
+
+
 SESSIONS = {}
 
 COLORMAPS = [
@@ -575,6 +622,7 @@ __all__ = [
     "_window_process",
     "PENDING_SESSIONS",
     "PENDING_SESSION_EVENTS",
+    "FAILED_PENDING_SESSIONS",
     "wait_for_session_ready",
     # Render thread pool
     "_RENDER_QUEUE",

{arrayview-0.35.3 → arrayview-0.37.1}/src/arrayview/_viewer.html

@@ -9278,7 +9278,20 @@
         function formatValueGroup(values, options = {}) {
             const finite = (Array.isArray(values) ? values : [values]).filter(Number.isFinite);
             const cap = Math.max(0, Math.min(8, Math.trunc(options.maxDecimals ?? 7)));
-            const minDecimals = Math.max(0, Math.min(cap, Math.trunc(options.minDecimals ?? 2)));
+            // Decimals worth showing depend on magnitude. Two was applied at
+            // every scale, so a range topping out near 1890 read as "1890.04"
+            // when the hundredths carry no information. The floor is only ever
+            // lowered for large values, never raised, so small ranges keep the
+            // precision they had. The search below can still add decimals when
+            // values would otherwise collide.
+            const _defaultMinDecimals = (vals) => {
+                const m = Math.max(...vals.filter(Number.isFinite).map(v => Math.abs(v)));
+                if (!(m > 0) || !Number.isFinite(m)) return 2;
+                return Math.max(0, Math.min(2, 3 - Math.floor(Math.log10(m))));
+            };
+            const minDecimals = Math.max(0, Math.min(cap, Math.trunc(
+                options.minDecimals ?? _defaultMinDecimals(finite)
+            )));
             const ordinaryLo = options.ordinaryLo ?? 1e-4;
             const ordinaryHi = options.ordinaryHi ?? 1e6;
             const fallback = {
@@ -14242,6 +14255,41 @@
 
         /* ── JS: Initialization and Metadata Fetch ────────────────── */
 
+        // The backend serves this page as soon as its port is up, which can be
+        // seconds before a large array has finished loading. While the session
+        // is still loading /metadata answers 404 with a Retry-After header; an
+        // unknown or released sid answers 404 without one, and a load that
+        // failed answers 422 with the reason. Keep waiting only for the first.
+        async function fetchMetadataWithRetry(sid, timeoutMs = 180000) {
+            const deadline = Date.now() + timeoutMs;
+            for (;;) {
+                const res = await proxyFetch(`/metadata/${sid}`);
+                if (res.ok) return { data: await res.json() };
+                if (res.status === 422) {
+                    let reason = '';
+                    try { reason = (await res.text()).trim(); } catch (_e) {}
+                    return { error: reason || 'This file could not be loaded.', status: 422 };
+                }
+                const pending = res.status === 404 && res.headers.get('Retry-After');
+                if (!pending || Date.now() >= deadline) {
+                    return { error: null, status: res.status };
+                }
+                await new Promise(r => setTimeout(r, 300));
+            }
+        }
+
+        function showMetadataError(result) {
+            const msg = result.error
+                ? result.error
+                : (result.status === 404
+                    ? 'Session not found or expired.'
+                    : `Server error ${result.status} — check Python console for details.`);
+            document.getElementById('loading-overlay').innerHTML =
+                `<div style="color:#c55;font-size:16px;font-family:monospace;max-width:60ch;text-align:center;line-height:1.5;padding:0 2em">${
+                    msg.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+                }</div>`;
+        }
+
         async function init() {
             // Loading spinner is in static HTML — body.av-loading set by server template.
             if (!sid) { hideLoadingOverlay(); drawPlasmaDemo(); return; }
@@ -14260,26 +14308,24 @@
                 );
                 data = await Promise.race([_metadataFromWs, httpFallback]);
                 if (!data) {
-                    // Both failed — try direct HTTP without timeout
-                    const res = await proxyFetch(`/metadata/${sid}`);
-                    if (!res.ok) {
-                        reportParent('metadata-http-error', { status: res.status, sid });
-                        const msg = res.status === 404 ? 'Session not found or expired.' : `Server error ${res.status} — check Python console for details.`;
-                        document.getElementById('loading-overlay').innerHTML = `<div style="color:#c55;font-size:18px;font-family:monospace">${msg}</div>`;
+                    // Both failed — wait out a still-loading session.
+                    const result = await fetchMetadataWithRetry(sid);
+                    if (!result.data) {
+                        reportParent('metadata-http-error', { status: result.status, sid });
+                        showMetadataError(result);
                         return;
                     }
-                    data = await res.json();
+                    data = result.data;
                 }
             } else {
                 // HTTP transport mode (VS Code) — use traditional fetch
-                const res = await proxyFetch(`/metadata/${sid}`);
-                if (!res.ok) {
-                    reportParent('metadata-http-error', { status: res.status, sid });
-                    const msg = res.status === 404 ? 'Session not found or expired.' : `Server error ${res.status} — check Python console for details.`;
-                    document.getElementById('loading-overlay').innerHTML = `<div style="color:#c55;font-size:18px;font-family:monospace">${msg}</div>`;
+                const result = await fetchMetadataWithRetry(sid);
+                if (!result.data) {
+                    reportParent('metadata-http-error', { status: result.status, sid });
+                    showMetadataError(result);
                     return;
                 }
-                data = await res.json();
+                data = result.data;
             }
 
             await _loadOverlayLabelValues();
@@ -35919,9 +35965,12 @@
                 return `${x.toFixed(1)},${y.toFixed(1)}`;
             }).join(' ');
             const distLabel = distance.toFixed(1) + ' px';
+            // Share the colorbar's formatter so the same value does not read
+            // differently here than it does on the colorbar.
+            const _lpFmt = formatValueGroup([vMin, vMax]);
             const fmtVal = v => {
                 if (v === null || !isFinite(v)) return '?';
-                return Math.abs(v) < 0.01 || Math.abs(v) >= 1e4 ? v.toExponential(2) : v.toFixed(2);
+                return _lpFmt.format(v);
             };
             _lineProfileOverlay.innerHTML = `
                 <svg width="${W}" height="${H}" xmlns="http://www.w3.org/2000/svg">

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

@@ -54,7 +54,7 @@ _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.80"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.14.88"  # current bundled extension version
 _VSCODE_CONFIGURED_PORTS: set[int] = set()
 
 def _bundled_vscode_vsix_version(vsix_path: str) -> str | None:
@@ -633,6 +633,47 @@ def _ensure_vscode_extension(*, is_remote: bool | None = None) -> bool:
 # ---------------------------------------------------------------------------
 
 
+def _port_has_listener(port: int) -> bool:
+    """Return True when something is listening on ``port`` on loopback."""
+    import socket
+
+    for family, addr in ((socket.AF_INET, "127.0.0.1"), (socket.AF_INET6, "::1")):
+        sock = socket.socket(family, socket.SOCK_STREAM)
+        try:
+            sock.settimeout(0.15)
+            if sock.connect_ex((addr, port)) == 0:
+                return True
+        except OSError:
+            continue
+        finally:
+            sock.close()
+    return False
+
+
+def _stale_arrayview_port_keys(attrs: dict, keep_port: int) -> list[str]:
+    """Return ArrayView port entries that no longer have a live server.
+
+    Every launch on a fresh port used to leave its entry behind for good. On a
+    tunnel those entries keep telling VS Code to forward ports nothing serves,
+    which competes for a limited per-tunnel forwarding budget. Only entries
+    ArrayView wrote are considered, and only when their port is dead, so a
+    second concurrent ArrayView server is never disturbed.
+    """
+    stale: list[str] = []
+    for key, value in list(attrs.items()):
+        if not isinstance(value, dict) or value.get("label") != "ArrayView":
+            continue
+        if key == str(keep_port):
+            continue
+        try:
+            candidate = int(key)
+        except (TypeError, ValueError):
+            continue
+        if not _port_has_listener(candidate):
+            stale.append(key)
+    return stale
+
+
 def _configure_vscode_port_preview(
     port: int,
     *,
@@ -686,8 +727,11 @@ def _configure_vscode_port_preview(
         }
         current = attrs.get(str(port))
         updated = {**current, **desired} if isinstance(current, dict) else desired
-        if current == updated:
+        stale = _stale_arrayview_port_keys(attrs, port)
+        if current == updated and not stale:
             return
+        for key in stale:
+            attrs.pop(key, None)
         attrs[str(port)] = updated
         with open(path, "w") as f:
             json.dump(settings, f, indent=2)