arrayview 0.31.1__tar.gz → 0.31.3__tar.gz

{arrayview-0.31.1 → arrayview-0.31.3}/.github/workflows/launch-contracts.yml

@@ -30,12 +30,12 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.12"
-      - uses: astral-sh/setup-uv@v6
-      - uses: actions/setup-node@v4
+      - uses: astral-sh/setup-uv@v8
+      - uses: actions/setup-node@v6
         with:
           node-version: "22"
       - run: uv sync --frozen --group dev --group test

{arrayview-0.31.1 → arrayview-0.31.3}/.mex/context/lifecycle.md

@@ -70,6 +70,13 @@ This contract describes who owns the backend, when it starts, and what closes it
 - `release_session()` is the session-release primitive.
 - Viewer WebSocket connect/disconnect owns active viewer counts.
 - URL panel disposal must release every SID encoded in the URL: `sid`, `compare_sid`, `compare_sids`, and `overlay_sid`.
+- Tunnel panel disposal posts release requests to the local backend immediately;
+  the forwarded public URL is display-only and is not the cleanup authority.
+- Reused file and collection sessions acquire one lease per tab, so closing one
+  tab cannot invalidate another tab that shares the same SID.
+- A VS Code readiness ACK includes the live opener version and is terminal only
+  after the requested SID exists and the viewer reports its first rendered frame.
+- Older ArrayView packages must not delete or downgrade a newer installed opener.
 - Tunnel registration cleanup must not remove live same-tunnel sibling windows.
 - Explicit cleanup wins over implicit disappearance.
 - Any VS Code extension source change must rebuild `src/arrayview/arrayview-opener.vsix` and keep the packaged version in sync.

{arrayview-0.31.1 → arrayview-0.31.3}/.mex/context/project-state.md

@@ -7,7 +7,7 @@ triggers:
   - "recent work"
   - "active feature"
   - "shipped recently"
-last_updated: 2026-06-30
+last_updated: 2026-07-13
 ---
 
 # Project State
@@ -21,7 +21,7 @@ last_updated: 2026-06-30
 - Backend transport: FastAPI HTTP/WebSocket is the single viewer transport; shared helpers keep route modules small for metadata/analysis, compare/diff, overlay compositing, and vector field layout/arrow sampling.
 - NIfTI spatial metadata, RAS resampling
 - Directory collections are header-scanned and lazy by default: compatible files form a dense virtual stack, mixed shapes use a ragged collection, and `--load lazy|eager` plus `--stack-policy auto|dense|ragged` make both choices explicit. Compressed NIfTI volumes use a byte-bounded LRU cache; `view_dir()` exposes the same controls.
-- VS Code extension v0.14.27 — stable window ID via `EnvironmentVariableCollection`; `arrayview.openInFloatingWindow` setting moves new tabs to a floating window; `view(arr, floating=True)` and `arrayview file.npy --floating` open in a floating window per-call regardless of global setting; remote/tunnel display uses the same forwarded HTTP/WebSocket path as local VS Code; floating mode uses a single persistent shell hub panel (`_shell.html`) so all arrays share one floating window as tabs instead of opening separate windows; second CLI calls inject tabs via `new_tab` postMessage relay (extension -> hub wrapper -> shell iframe)
+- VS Code extension v0.14.41 — stable per-window routing, queued concurrent requests, remote-only tunnel claims, live opener-version ACKs, first-frame readiness, and immediate local-backend session release. An installed-but-stale extension host now fails with a clear one-time reload instruction instead of opening an unverified blank tab; older cached ArrayView packages never delete a newer opener.
 - Colorbar refactor: `ColorBar` JS class partially migrated (in progress)
 - Colormap picker: `c` opens an expanded colorbar-island grid without changing the colormap; subsequent `c` taps cycle, hover/hjkl/arrows live-preview, Enter/click commits, Esc cancels, and auto-dismiss pauses while hovered
 - Cold-start loading spinner in VS Code and native shell
@@ -48,9 +48,10 @@ last_updated: 2026-06-30
   patient/modality directory layouts pair automatically. `--case-regex` remains
   an override for unusual layouts. CLI header scans show an in-place file counter
   and elapsed time on interactive terminals.
-- Reused collection sessions are protected by per-tab leases, including their
-  overlay sessions, and VS Code opener readiness now verifies the requested
-  session metadata before acknowledging `backend_ready`.
+- Reused file and collection sessions are protected by per-tab leases, including
+  collection overlay sessions. The VS Code opener verifies the local SID before
+  creating a panel and waits for the viewer's first rendered frame before
+  acknowledging `backend_ready`.
 - Filesystem picker endpoint (`GET /fs/list`) clamped to `$HOME`. Accepts `base_sid` + `mode` (`overlay` | `vectorfield`) to filter entries by a cheap header-shape peek (`.npy`, `.nii`/`.nii.gz`, `.h5`, `.zarr`); overlay mode requires identical shape, vectorfield mode requires base shape plus one axis of size 3
 - Island collapse affordance: inline `~` at the island's top-right animates the panel into the bottom-left `~` hint circle; external `~` hint only visible while the island is actually collapsed. New `/` hint circle at bottom-right opens the tool menu
 - Compare center tool menu: `/` now re-opens the last-used compare center mode from the tool menu, while compare pane header buttons select diff / overlay / wipe directly. Eligible two-array compare layouts can switch into a big-left arrangement with a wider center pane, and the diff colorbar now matches that center-pane width.

{arrayview-0.31.1 → arrayview-0.31.3}/PKG-INFO

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

{arrayview-0.31.1 → arrayview-0.31.3}/docs/index.md

@@ -30,6 +30,8 @@ MATLAB and Julia setup: [MATLAB and Julia](foreign-hosts.md).
 
 Remote and tunnel setup: [Remote](remote.md).
 
+Stacked patient collections and masks: [Stack and Overlay Collections](stack-overlays.md).
+
 ## Formats
 
 `.npy` `.npz` `.nii` `.nii.gz` `.zarr` `.pt` `.h5` `.tif` `.mat`

{arrayview-0.31.1 → arrayview-0.31.3}/docs/loading.md

@@ -85,7 +85,7 @@ Native windows also show a static preview while the live viewer warms up.
 ```bash
 uvx arrayview base.npy moving.npy           # compare mode
 uvx arrayview volume.nii.gz --overlay mask.nii.gz
-uvx arrayview volume.nii.gz --overlay "ground truth=mask.nii.gz"
+uvx arrayview volume.nii.gz --overlay "ground truth=mask_gt.nii.gz" --overlay "prediction=mask_pred.nii.gz"
 ```
 
 An unnamed overlay uses the filename stem as its display name (`mask` above).
@@ -99,8 +99,7 @@ shows all overlays at once.
 
 ## Directory Pattern Collections
 
-Use `--stack` when reviewing many arrays. Passing a directory scans supported
-files recursively; passing patterns keeps the aligned channel/overlay workflow.
+Use `--stack` when reviewing many arrays.
 
 ```bash
 uvx arrayview --stack scans/
@@ -115,48 +114,8 @@ dense` requires matching shapes, while `--stack-policy ragged` forces collection
 semantics. `--load eager` is intended for small datasets that should be loaded
 up front.
 
-Positional patterns become a channel/modality axis:
-
-```bash
-uvx arrayview --stack "data/**/*_0000.nii.gz" "data/**/*_0001.nii.gz"
-```
-
-Overlays become named recursive patterns:
-
-```bash
-uvx arrayview --stack \
-  "data/**/*_0000.nii.gz" \
-  "data/**/*_0001.nii.gz" \
-  --overlay "gt=data/**/labels/**/*.nii.gz" \
-  --overlay "pred=data/**/pred/**/*.nii.gz"
-```
-
-When every case has a directory containing separately named masks,
-`--overlay-dir` discovers one overlay role per filename. Masks that are absent
-for a case are shown as empty. ArrayView infers the shared case directory from
-layouts such as `sub-0001/T1_W/` and `sub-0001/masks/`:
-
-```bash
-uvx arrayview --stack "data/*/T1_W/*.nii.gz" \
-  --overlay-dir "data/*/masks"
-```
-
-Repeat `--overlay-dir` to combine masks from multiple per-case directories.
-
-ArrayView pairs files by sorted match order. The first match from each pattern
-belongs to the first case, the second match belongs to the second case, and so
-on. Use `--dry-run` to inspect matches without opening a viewer.
-
-```bash
-uvx arrayview --stack "data/**/*_0000.nii.gz" --overlay "gt=data/**/labels/*.nii.gz" --dry-run
-```
-
-For unusual or ambiguous layouts, pass a regex with a `case` group to override
-automatic directory inference:
-
-```bash
-uvx arrayview --stack "data/**/*.nii.gz" --case-regex "(?P<case>patient-[0-9]+)"
-```
+Pattern collections, named overlays, multiple overlays, and `--overlay-dir`:
+[Stack and Overlay Collections](stack-overlays.md).
 
 ## NIfTI Series (4D/5D from a directory)
 

arrayview-0.31.3/docs/stack-overlays.md

@@ -0,0 +1,129 @@
+# Stack and Overlay Collections
+
+Review many arrays with aligned image and mask patterns.
+
+## Patient Stack
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz"
+```
+
+`*` matches one path segment. `**` matches recursively:
+
+```bash
+uvx arrayview --stack "data/**/*.nii.gz"
+```
+
+ArrayView sorts matches and adds a collection index dimension. Use `--dry-run`
+to inspect pairings without opening the viewer:
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" --dry-run
+```
+
+## MR Contrasts
+
+```bash
+uvx arrayview --stack \
+  "data/*/T1w.nii.gz" \
+  "data/*/T2w.nii.gz" \
+  "data/*/FLAIR.nii.gz"
+```
+
+Each positional pattern becomes a contrast dimension. The first `T1w`, first
+`T2w`, and first `FLAIR` belong to patient 1; the second match from each pattern
+belongs to patient 2.
+
+For ambiguous layouts, define the patient key:
+
+```bash
+uvx arrayview --stack "data/**/*.nii.gz" \
+  --case-regex "(?P<case>sub-[0-9]+)"
+```
+
+## Ragged Shapes
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" --stack-policy ragged
+```
+
+`--stack-policy auto` uses a dense stack when shapes match and ragged mode when
+they do not. `--stack-policy dense` requires matching shapes.
+
+## One Overlay
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" \
+  --overlay "lesion=data/*/masks/lesion.nii.gz"
+```
+
+Use `name=pattern` to control the overlay label. Without `name=`, the filename
+stem is used.
+
+## Multiple Overlays
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" \
+  --overlay "gt=data/*/masks/gt.nii.gz" \
+  --overlay "pred=data/*/masks/pred.nii.gz"
+```
+
+Overlays are paired to cases by sorted match order unless `--case-regex` is
+provided.
+
+## Overlay Directories
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" \
+  --overlay-dir "data/*/masks"
+```
+
+`--overlay-dir` creates one overlay role per mask filename inside each matched
+directory. Missing masks are shown as empty overlays.
+
+Repeat it to combine mask folders:
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" \
+  --overlay-dir "data/*/manual_masks" \
+  --overlay-dir "data/*/model_masks"
+```
+
+## Complete Example
+
+```text
+data/
+  sub-001/
+    anat/T1w.nii.gz
+    anat/T2w.nii.gz
+    masks/lesion.nii.gz
+    masks/edema.nii.gz
+  sub-002/
+    anat/T1w.nii.gz
+    anat/T2w.nii.gz
+    masks/lesion.nii.gz
+```
+
+```bash
+uvx arrayview --stack \
+  "data/*/anat/T1w.nii.gz" \
+  "data/*/anat/T2w.nii.gz" \
+  --overlay-dir "data/*/masks" \
+  --stack-policy auto \
+  --dry-run
+```
+
+Remove `--dry-run` to open the viewer.
+
+## Compressed NIfTI Performance
+
+`.nii.gz` files are lazy through nibabel, but gzip compression limits random
+slice access. Large compressed collections can feel slower when scrolling across
+many patients or contrasts.
+
+For repeated review, prefer uncompressed `.nii`, chunked `.zarr`, or a local
+fast disk cache. Use `--load eager` only for small collections that fit in RAM:
+
+```bash
+uvx arrayview --stack "data/*/T1w.nii.gz" --load eager
+```

{arrayview-0.31.1 → arrayview-0.31.3}/mkdocs.yml

@@ -24,6 +24,7 @@ extra_css:
 nav:
   - Home: index.md
   - Loading Arrays: loading.md
+  - Stack and Overlays: stack-overlays.md
   - Viewing: viewing.md
   - Comparing: comparing.md
   - Display: display.md

{arrayview-0.31.1 → arrayview-0.31.3}/pyproject.toml

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

{arrayview-0.31.1 → arrayview-0.31.3}/src/arrayview/_instance_registry.py

@@ -115,11 +115,17 @@ def _windows_process_start(pid: int) -> str | None:
     handle = kernel32.OpenProcess(0x1000, False, pid)
     if not handle:
         return None
+    still_active = 259
+    exit_code = ctypes.c_ulong()
     creation = ctypes.c_ulonglong()
     exit_time = ctypes.c_ulonglong()
     kernel = ctypes.c_ulonglong()
     user = ctypes.c_ulonglong()
     try:
+        if not kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code)):
+            return None
+        if exit_code.value != still_active:
+            return None
         ok = kernel32.GetProcessTimes(handle, ctypes.byref(creation),
                                       ctypes.byref(exit_time), ctypes.byref(kernel),
                                       ctypes.byref(user))

arrayview-0.31.3/src/arrayview/_overlays.py

@@ -0,0 +1,150 @@
+"""Shared overlay compositing helpers."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from arrayview._render import (
+    _build_mosaic_grid,
+    _composite_overlay_mask,
+    _extract_overlay_mask,
+    _overlay_is_label_map,
+)
+
+
+def _parse_hex_color(hex_str: str) -> np.ndarray | None:
+    """Parse a 6-char hex RGB color."""
+    h = hex_str.strip().lstrip("#")
+    if len(h) != 6:
+        return None
+    try:
+        return np.array(
+            [int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)],
+            dtype=np.uint8,
+        )
+    except ValueError:
+        return None
+
+
+def _composite_overlays(
+    rgba: np.ndarray,
+    overlay_sid_str: str | None,
+    overlay_colors_str: str | None,
+    overlay_alpha: float,
+    overlay_alphas_str: str | None,
+    overlay_outline: bool,
+    dim_x: int,
+    dim_y: int,
+    idx_tuple: tuple[int, ...],
+    shape_hw: tuple[int, int],
+    base_shape: tuple[int, ...] | None = None,
+) -> np.ndarray:
+    """Composite one or more overlay masks onto RGBA pixels."""
+    if not overlay_sid_str:
+        return rgba
+    sids = [s.strip() for s in overlay_sid_str.split(",") if s.strip()]
+    colors_raw = (
+        [c.strip() for c in overlay_colors_str.split(",")] if overlay_colors_str else []
+    )
+    alphas_raw = (
+        [a.strip() for a in overlay_alphas_str.split(",")] if overlay_alphas_str else []
+    )
+    for i, sid in enumerate(sids):
+        color = _parse_hex_color(colors_raw[i]) if i < len(colors_raw) else None
+        alpha = overlay_alpha
+        if i < len(alphas_raw):
+            try:
+                alpha = float(alphas_raw[i])
+            except ValueError:
+                alpha = overlay_alpha
+        alpha = max(0.0, min(1.0, alpha))
+        ov_raw = _extract_overlay_mask(
+            sid,
+            dim_x,
+            dim_y,
+            idx_tuple,
+            expected_shape=shape_hw,
+            base_shape=base_shape,
+        )
+        rgba = _composite_overlay_mask(
+            rgba,
+            ov_raw,
+            alpha=alpha,
+            is_label=_overlay_is_label_map(sid, ov_raw),
+            override_color=color,
+            outline_only=overlay_outline,
+        )
+    return rgba
+
+
+def _composite_mosaic_overlays(
+    rgba: np.ndarray,
+    overlay_sid_str: str | None,
+    overlay_colors_str: str | None,
+    overlay_alpha: float,
+    overlay_alphas_str: str | None,
+    overlay_outline: bool,
+    dim_x: int,
+    dim_y: int,
+    dim_z: int,
+    idx_tuple: tuple[int, ...],
+    base_shape: tuple[int, ...],
+    mosaic_cols: int | None = None,
+) -> np.ndarray:
+    """Composite each overlay as a mosaic using the base mosaic's frame indices.
+
+    Missing overlay axes are resolved per frame by ``_extract_overlay_mask``.
+    That lets a mask omit, for example, an echo axis without materialising a
+    repeated full-volume copy.
+    """
+    if not overlay_sid_str:
+        return rgba
+    sids = [sid.strip() for sid in overlay_sid_str.split(",") if sid.strip()]
+    colors_raw = (
+        [color.strip() for color in overlay_colors_str.split(",")]
+        if overlay_colors_str
+        else []
+    )
+    alphas_raw = (
+        [alpha.strip() for alpha in overlay_alphas_str.split(",")]
+        if overlay_alphas_str
+        else []
+    )
+    tile_shape = (int(base_shape[dim_y]), int(base_shape[dim_x]))
+    n_frames = int(base_shape[dim_z])
+
+    for i, sid in enumerate(sids):
+        color = _parse_hex_color(colors_raw[i]) if i < len(colors_raw) else None
+        try:
+            alpha = float(alphas_raw[i]) if i < len(alphas_raw) else overlay_alpha
+        except ValueError:
+            alpha = overlay_alpha
+        alpha = max(0.0, min(1.0, alpha))
+
+        frames = []
+        for frame in range(n_frames):
+            frame_idx = list(idx_tuple)
+            frame_idx[dim_z] = frame
+            ov_raw = _extract_overlay_mask(
+                sid,
+                dim_x,
+                dim_y,
+                tuple(frame_idx),
+                expected_shape=tile_shape,
+                base_shape=base_shape,
+            )
+            frames.append(
+                ov_raw if ov_raw is not None else np.zeros(tile_shape, dtype=np.float32)
+            )
+        grid, _, _ = _build_mosaic_grid(frames, n_frames, cols=mosaic_cols)
+        # Gaps are transparent, not NaN label values or heatmap samples.
+        grid = np.nan_to_num(grid, nan=0.0)
+        rgba = _composite_overlay_mask(
+            rgba,
+            grid,
+            alpha=alpha,
+            is_label=_overlay_is_label_map(sid, grid),
+            override_color=color,
+            outline_only=overlay_outline,
+        )
+    return rgba

{arrayview-0.31.1 → arrayview-0.31.3}/src/arrayview/_routes_loading.py

@@ -141,7 +141,8 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
         else:
             for existing in SESSIONS.values():
                 if existing.filepath and os.path.abspath(existing.filepath) == abs_path:
-                    return {"sid": existing.sid, "name": existing.name, "notified": False}
+                    if acquire_session_leases([existing.sid]):
+                        return {"sid": existing.sid, "name": existing.name, "notified": False}
         if not dir_patterns and not os.environ.get("ARRAYVIEW_SKIP_RAM_GUARD"):
             from ._io import FULL_LOAD_EXTS
 

{arrayview-0.31.1 → arrayview-0.31.3}/src/arrayview/_routes_rendering.py

@@ -6,7 +6,7 @@ from fastapi import Depends, Response
 from fastapi.responses import JSONResponse
 
 from arrayview._diff import _compute_diff, _diff_histogram, _render_diff_rgba
-from arrayview._overlays import _composite_overlays
+from arrayview._overlays import _composite_mosaic_overlays, _composite_overlays
 from arrayview._render import (
     LUTS,
     _build_mosaic_grid,
@@ -178,6 +178,11 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     vmin_override=vmin_override,
                     vmax_override=vmax_override,
                 )
+                rgba = _composite_mosaic_overlays(
+                    rgba, overlay_sid, overlay_colors, overlay_alpha, overlay_alphas,
+                    overlay_outline, dim_x, dim_y, dim_z, idx_tuple, session.shape,
+                    mosaic_cols,
+                )
                 if vmin_override is not None and vmax_override is not None:
                     vmin, vmax = float(vmin_override), float(vmax_override)
                 else:
@@ -264,6 +269,12 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                 )
                 if qmri_role:
                     vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
+            if dim_z >= 0 and qmri_role:
+                rgba = _composite_mosaic_overlays(
+                    rgba, overlay_sid, overlay_colors, overlay_alpha, overlay_alphas,
+                    overlay_outline, dim_x, dim_y, dim_z, idx_tuple, session.shape,
+                    mosaic_cols,
+                )
         render_ms = (time.perf_counter() - render_t0) * 1000.0
         encode_t0 = time.perf_counter()
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")

{arrayview-0.31.1 → arrayview-0.31.3}/src/arrayview/_routes_websocket.py

@@ -8,7 +8,7 @@ from starlette.websockets import WebSocketDisconnect
 import arrayview._session as _session_mod
 from arrayview._analysis import _build_metadata
 from arrayview._lifecycle import release_session
-from arrayview._overlays import _composite_overlays
+from arrayview._overlays import _composite_mosaic_overlays, _composite_overlays
 from arrayview._render import (
     LUTS,
     _prepare_display,
@@ -232,6 +232,12 @@ def register_websocket_routes(app) -> None:
                                 vmax_override=vmax_override,
                             ),
                         )
+                        rgba = _composite_mosaic_overlays(
+                            rgba, msg.get("overlay_sid"), msg.get("overlay_colors"),
+                            float(msg.get("overlay_alpha", 0.45)), msg.get("overlay_alphas"),
+                            bool(msg.get("overlay_outline", False)), dim_x, dim_y, dim_z,
+                            idx_tuple, session.shape, mosaic_cols,
+                        )
                         h, w = rgba.shape[:2]
                         raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
                         _, vmin, vmax = _prepare_display(
@@ -344,6 +350,14 @@ def register_websocket_routes(app) -> None:
                         session.shape,
                     )
 
+                if dim_z >= 0 and qmri_role:
+                    rgba = _composite_mosaic_overlays(
+                        rgba, msg.get("overlay_sid"), msg.get("overlay_colors"),
+                        float(msg.get("overlay_alpha", 0.45)), msg.get("overlay_alphas"),
+                        bool(msg.get("overlay_outline", False)), dim_x, dim_y, dim_z,
+                        idx_tuple, session.shape, mosaic_cols,
+                    )
+
                 render_ms = (time.perf_counter() - render_t0) * 1000.0
                 post_t0 = time.perf_counter()
                 header = np.array([seq, w, h], dtype=np.uint32).tobytes()

{arrayview-0.31.1 → arrayview-0.31.3}/src/arrayview/_session.py

@@ -283,6 +283,7 @@ class Session:
         self.fft_original_data = None
         self.fft_axes = None
         self.data_version = 0  # incremented by /reload when file is reloaded
+        self.viewer_leases = 1  # one release is required for each tab using this SID
 
         self.rgb_axis = None  # set by _setup_rgb(); axis index in actual shape
         self.spatial_shape = data.shape  # shape without rgb_axis (set by _setup_rgb)

{arrayview-0.31.1 → arrayview-0.31.3}/src/arrayview/_vscode_browser.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import json
+import platform
 import subprocess
 import sys
 import threading
@@ -15,7 +16,7 @@ from enum import Enum
 
 from arrayview._session import _vprint
 from arrayview._platform import _in_vscode_terminal, _is_vscode_remote
-from arrayview._vscode_extension import _configure_vscode_port_preview, _ensure_vscode_extension, _VSCODE_EXT_FRESH_INSTALL
+from arrayview._vscode_extension import _configure_vscode_port_preview, _ensure_vscode_extension
 from arrayview._vscode_signal import (
     AckState,
     _open_via_signal_file,
@@ -132,9 +133,13 @@ def _open_browser(
         if is_remote:
             # Remote/tunnel: install extension + write signal file.
             ext_ok = _ensure_vscode_extension()
-            if ext_ok and _VSCODE_EXT_FRESH_INSTALL:
-                time.sleep(1.5)
-
+            from arrayview import _vscode_extension as _extension_state
+            if not ext_ok and _extension_state._VSCODE_EXT_RELOAD_REQUIRED:
+                return OpenResult(
+                    OpenState.FAILED,
+                    "vscode-extension",
+                    "ArrayView updated its VS Code opener; reload this VS Code window once, then retry",
+                )
             # URL-based mode: port is forwarded by VS Code and the viewer
             # connects via WebSocket through the devtunnel.
             _configure_vscode_port_preview(parsed_port)
@@ -171,8 +176,13 @@ def _open_browser(
             # Local VS Code terminal (or --window vscode forced): install extension + signal file.
             _configure_vscode_port_preview(parsed_port)
             ext_ok = _ensure_vscode_extension()
-            if ext_ok and _VSCODE_EXT_FRESH_INSTALL:
-                time.sleep(1.5)
+            from arrayview import _vscode_extension as _extension_state
+            if not ext_ok and _extension_state._VSCODE_EXT_RELOAD_REQUIRED:
+                return OpenResult(
+                    OpenState.FAILED,
+                    "vscode-extension",
+                    "ArrayView updated its VS Code opener; reload this VS Code window once, then retry",
+                )
             # Always write the signal file: the extension may already be
             # installed even if _ensure failed (e.g. `code` CLI not found).
             request = _open_via_signal_file(
@@ -219,7 +229,7 @@ def _open_browser(
                     port_hint = int(url.split(":")[2].split("/")[0].split("?")[0])
                 except Exception:
                     port_hint = parsed_port
-                hostname = os.uname().nodename or "<this-host>"
+                hostname = platform.node() or "<this-host>"
                 print(
                     f"[ArrayView] Plain SSH session detected.\n"
                     f"\n"