arrayview 0.12.2__tar.gz → 0.13.0__tar.gz

{arrayview-0.12.2 → arrayview-0.13.0}/PKG-INFO

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

{arrayview-0.12.2 → arrayview-0.13.0}/pyproject.toml

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

{arrayview-0.12.2 → arrayview-0.13.0}/scripts/release.sh

@@ -66,7 +66,7 @@ run() {
 }
 
 # --- Generate release notes ---
-CLAUDE_BIN="${CLAUDE_BIN:-/Users/oscar/.local/bin/claude}"
+CLAUDE_BIN="${CLAUDE_BIN:-$(command -v claude 2>/dev/null || echo claude)}"
 PREV_TAG=$(git describe --tags --abbrev=0 HEAD 2>/dev/null || echo "")
 NOTES=""
 

{arrayview-0.12.2 → arrayview-0.13.0}/src/arrayview/_launcher.py

@@ -2102,24 +2102,67 @@ def arrayview():
             from arrayview._io import load_data
             from arrayview._session import SESSIONS, Session
 
-            for file_path in args.files:
-                data = load_data(file_path)
-                session = Session(
-                    data=data,
-                    filepath=file_path,
-                    name=_Path(file_path).name,
+            # First file is the main array
+            base_path = args.files[0]
+            data = load_data(base_path)
+            session = Session(
+                data=data,
+                filepath=base_path,
+                name=_Path(base_path).name,
+            )
+            if getattr(args, "rgb", False):
+                _setup_rgb(session)
+
+            # Attach vector field if provided
+            if getattr(args, "vectorfield", None):
+                from arrayview._server import _configure_vectorfield
+
+                vf_data = load_data(args.vectorfield)
+                _configure_vectorfield(
+                    session, vf_data,
+                    getattr(args, "vectorfield_components_dim", None),
                 )
-                if getattr(args, "rgb", False):
-                    _setup_rgb(session)
-                SESSIONS[session.sid] = session
-                info = json.dumps(
-                    {
-                        "sid": session.sid,
-                        "name": session.name,
-                        "shape": [int(s) for s in session.shape],
-                    }
+
+            SESSIONS[session.sid] = session
+
+            # Load overlay as a separate session
+            overlay_sid = None
+            if getattr(args, "overlay", None):
+                ov_data = load_data(args.overlay)
+                ov_session = Session(
+                    data=ov_data,
+                    filepath=args.overlay,
+                    name="overlay",
                 )
-                print(f"SESSION:{info}", file=sys.stderr)
+                SESSIONS[ov_session.sid] = ov_session
+                overlay_sid = ov_session.sid
+
+            # Load compare files (additional positional args + --compare)
+            compare_sids = []
+            compare_paths = list(args.files[1:])
+            if getattr(args, "compare", None):
+                compare_paths.append(args.compare)
+            for cp in compare_paths:
+                cmp_data = load_data(cp)
+                cmp_session = Session(
+                    data=cmp_data,
+                    filepath=cp,
+                    name=_Path(cp).name,
+                )
+                SESSIONS[cmp_session.sid] = cmp_session
+                compare_sids.append(cmp_session.sid)
+
+            info = json.dumps(
+                {
+                    "sid": session.sid,
+                    "name": session.name,
+                    "shape": [int(s) for s in session.shape],
+                    "has_vectorfield": session.vfield is not None,
+                    "overlay_sid": overlay_sid,
+                    "compare_sids": compare_sids or None,
+                }
+            )
+            print(f"SESSION:{info}", file=sys.stderr)
         run_stdio_server()
         return
 
@@ -2662,9 +2705,27 @@ def arrayview():
     # WebSocket server entirely.  The extension spawns a Python subprocess
     # with --mode stdio and bridges via postMessage — no ports needed.
     is_remote = _is_vscode_remote()
-    if is_remote and not args.overlay and not compare_files and not getattr(args, 'vectorfield', None):
+    if is_remote:
         _ensure_vscode_extension()
-        _open_direct_via_signal_file(base_file, title=f"ArrayView: {name}")
+        # Build generic extra CLI args so new flags work without touching the
+        # VS Code extension — they're forwarded verbatim to the subprocess.
+        extra_args: list[str] = []
+        if args.vectorfield:
+            extra_args += ["--vectorfield", os.path.abspath(args.vectorfield)]
+            if vfield_components_dim is not None:
+                extra_args += ["--vectorfield-components-dim", str(vfield_components_dim)]
+        if args.overlay:
+            extra_args += ["--overlay", os.path.abspath(args.overlay)]
+        if args.rgb:
+            extra_args.append("--rgb")
+        # Compare files: pass as additional positional args
+        for cf in compare_files:
+            extra_args.append(cf)
+        _open_direct_via_signal_file(
+            base_file,
+            title=f"ArrayView: {name}",
+            extra_args=extra_args or None,
+        )
         return
 
     sid = uuid.uuid4().hex

{arrayview-0.12.2 → arrayview-0.13.0}/src/arrayview/_stdio_server.py

@@ -24,7 +24,10 @@ import numpy as np
 
 from arrayview._io import load_data, load_data_with_meta
 from arrayview._render import (
+    LUTS,
     _composite_overlay_mask,
+    _compute_vmin_vmax,
+    _ensure_lut,
     _extract_overlay_mask,
     _init_luts,
     _overlay_is_label_map,
@@ -32,6 +35,7 @@ from arrayview._render import (
     apply_complex_mode,
     extract_projection,
     extract_slice,
+    mosaic_shape,
     render_mosaic,
     render_projection_rgba,
     render_rgb_rgba,
@@ -485,6 +489,258 @@ def _handle_lebesgue(sid: str, params: dict[str, str]) -> None:
     })
 
 
+def _handle_vectorfield_fetch(sid: str, params: dict) -> None:
+    """Return downsampled vector field arrows for a 2-D view."""
+    session = SESSIONS.get(sid)
+    if not session or session.vfield is None:
+        _write_json({"error": "no vectorfield"})
+        return
+    dim_x = int(params.get("dim_x", 0))
+    dim_y = int(params.get("dim_y", 0))
+    indices = params.get("indices", "")
+    idx_tuple = tuple(int(x) for x in indices.split(",")) if indices else ()
+    t_index = int(params.get("t_index", 0))
+    density_offset = int(params.get("density_offset", 0))
+    result = _compute_vfield_arrows(session, dim_x, dim_y, idx_tuple, t_index, density_offset)
+    if result is None:
+        _write_json({"error": "vectorfield computation failed"})
+        return
+    _write_json({
+        "arrows": result["arrows"].tolist(),
+        "scale": result["scale"],
+        "stride": result["stride"],
+    })
+
+
+def _handle_pixel(sid: str, params: dict) -> None:
+    """Return the raw value at a single pixel."""
+    session = SESSIONS.get(sid)
+    if not session:
+        _write_json({"error": "session not found"})
+        return
+    if session.rgb_axis is not None:
+        _write_json({"value": None})
+        return
+    dim_x = int(params.get("dim_x", 0))
+    dim_y = int(params.get("dim_y", 0))
+    indices = params.get("indices", "")
+    idx_tuple = tuple(int(x) for x in indices.split(",")) if indices else ()
+    px = int(params.get("px", 0))
+    py = int(params.get("py", 0))
+    complex_mode = int(params.get("complex_mode", 0))
+    raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
+    data = apply_complex_mode(raw, complex_mode)
+    h, w = data.shape
+    if 0 <= py < h and 0 <= px < w:
+        v = data[py, px]
+        val = None if np.isnan(v) or np.isinf(v) else float(v)
+    else:
+        val = None
+    _write_json({"value": val})
+
+
+# ---------------------------------------------------------------------------
+# Diff / Compare helpers
+# ---------------------------------------------------------------------------
+
+def _render_normalized(session, dim_x, dim_y, idx_tuple, dr, complex_mode, log_scale):
+    """Extract a slice and normalize to [0, 1] float32."""
+    raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
+    data, vmin, vmax = _prepare_display(session, raw, complex_mode, dr, log_scale)
+    if vmax > vmin:
+        normalized = np.clip((data - vmin) / (vmax - vmin), 0, 1)
+    else:
+        normalized = np.zeros_like(data)
+    return normalized.astype(np.float32)
+
+
+def _render_normalized_mosaic(session, dim_x, dim_y, dim_z, idx_tuple, dr, complex_mode, log_scale):
+    """Return (float32 normalized mosaic [0,1], nan_mask)."""
+    n = session.shape[dim_z]
+    idx_list = list(idx_tuple)
+    frames_raw = [
+        extract_slice(
+            session, dim_x, dim_y,
+            [i if j == dim_z else idx_list[j] for j in range(len(session.shape))],
+        )
+        for i in range(n)
+    ]
+    frames = [apply_complex_mode(f, complex_mode) for f in frames_raw]
+    if log_scale:
+        frames = [np.log1p(np.abs(f)).astype(np.float32) for f in frames]
+    all_data = np.stack(frames)
+    if log_scale:
+        vmin = float(np.percentile(all_data, 1))
+        vmax = float(np.percentile(all_data, 99))
+    else:
+        vmin, vmax = _compute_vmin_vmax(session, all_data, dr, complex_mode)
+    rows, cols = mosaic_shape(n)
+    H, W = frames[0].shape
+    GAP = 2
+    total_h = rows * H + (rows - 1) * GAP
+    total_w = cols * W + (cols - 1) * GAP
+    grid = np.full((total_h, total_w), np.nan, dtype=np.float32)
+    for k in range(n):
+        r, c = divmod(k, cols)
+        r0, c0 = r * (H + GAP), c * (W + GAP)
+        grid[r0 : r0 + H, c0 : c0 + W] = all_data[k]
+    nan_mask = np.isnan(grid)
+    if vmax > vmin:
+        normalized = np.clip(np.where(nan_mask, 0.0, (grid - vmin) / (vmax - vmin)), 0, 1)
+    else:
+        normalized = np.zeros_like(grid)
+    return normalized.astype(np.float32), nan_mask
+
+
+def _compute_diff(session_a, session_b, dim_x, dim_y, indices, dim_z, dr, complex_mode, log_scale, diff_mode):
+    """Shared diff logic for both diff image and diff histogram handlers.
+
+    Returns (raw_diff, vmin, vmax, colormap, nan_mask_or_None).
+    """
+    idx_tuple = tuple(int(x) for x in indices.split(",")) if isinstance(indices, str) else indices
+    ndim_a = len(session_a.shape)
+    ndim_b = len(session_b.shape)
+    idx_a = idx_tuple[:ndim_a]
+    idx_b = idx_tuple[:ndim_b]
+    nan_mask = None
+
+    if dim_z >= 0:
+        a, nan_mask_a = _render_normalized_mosaic(session_a, dim_x, dim_y, dim_z, idx_a, dr, complex_mode, log_scale)
+        b, nan_mask_b = _render_normalized_mosaic(session_b, dim_x, dim_y, dim_z, idx_b, dr, complex_mode, log_scale)
+        nan_mask = nan_mask_a | nan_mask_b
+    else:
+        a = _render_normalized(session_a, dim_x, dim_y, idx_a, dr, complex_mode, log_scale)
+        b = _render_normalized(session_b, dim_x, dim_y, idx_b, dr, complex_mode, log_scale)
+
+    # Resize b to match a if shapes differ
+    if a.shape != b.shape:
+        b_img = _pil_image().fromarray((b * 255).astype(np.uint8), mode="L")
+        b_img = b_img.resize((a.shape[1], a.shape[0]), _pil_image().BILINEAR)
+        b = np.array(b_img, dtype=np.float32) / 255.0
+
+    if diff_mode == 1:
+        raw = a - b
+        vmin, vmax = -1.0, 1.0
+        colormap = "RdBu_r"
+    elif diff_mode == 2:
+        raw = np.abs(a - b)
+        vmax = float(raw.max()) or 1.0
+        vmin = 0.0
+        colormap = "afmhot"
+    else:
+        raw = np.abs(a - b) / np.maximum(np.abs(a), 1e-6)
+        raw = np.clip(raw, 0.0, 2.0).astype(np.float32)
+        vmax = float(raw.max()) or 1.0
+        vmin = 0.0
+        colormap = "afmhot"
+
+    return raw, vmin, vmax, colormap, nan_mask
+
+
+def _handle_diff(sid_a: str, sid_b: str, params: dict) -> None:
+    """Render a diff image and return as base64 JPEG with metadata headers."""
+    import base64
+    import io
+
+    session_a = SESSIONS.get(sid_a)
+    session_b = SESSIONS.get(sid_b)
+    if not session_a or not session_b:
+        _write_json({"error": "session not found"})
+        return
+
+    dim_x = int(params.get("dim_x", 0))
+    dim_y = int(params.get("dim_y", 0))
+    indices = params.get("indices", "")
+    dim_z = int(params.get("dim_z", -1))
+    dr = int(params.get("dr", 1))
+    complex_mode = int(params.get("complex_mode", 0))
+    log_scale = params.get("log_scale", "false").lower() == "true"
+    diff_mode = int(params.get("diff_mode", 1))
+    diff_colormap = params.get("diff_colormap", "")
+    _vmin_ov = params.get("vmin_override")
+    _vmax_ov = params.get("vmax_override")
+    vmin_override = float(_vmin_ov) if _vmin_ov is not None else None
+    vmax_override = float(_vmax_ov) if _vmax_ov is not None else None
+
+    try:
+        raw, vmin, vmax, colormap, nan_mask = _compute_diff(
+            session_a, session_b, dim_x, dim_y, indices,
+            dim_z, dr, complex_mode, log_scale, diff_mode,
+        )
+    except Exception as e:
+        _write_json({"error": str(e)})
+        return
+
+    if vmin_override is not None:
+        vmin = vmin_override
+    if vmax_override is not None:
+        vmax = vmax_override
+    if diff_colormap and _ensure_lut(diff_colormap):
+        colormap = diff_colormap
+
+    if vmax > vmin:
+        normalized = np.clip((raw - vmin) / (vmax - vmin), 0, 1)
+    else:
+        normalized = np.zeros_like(raw)
+    _ensure_lut(colormap)
+    lut = LUTS.get(colormap, LUTS["gray"])
+    rgba = lut[(normalized * 255).astype(np.uint8)]
+    if nan_mask is not None and nan_mask.shape == rgba.shape[:2]:
+        rgba[nan_mask] = [22, 22, 22, 255]
+
+    img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=90)
+
+    _write_json({
+        "_binary": True,
+        "data": base64.b64encode(buf.getvalue()).decode("ascii"),
+        "headers": {
+            "X-ArrayView-Vmin": str(vmin),
+            "X-ArrayView-Vmax": str(vmax),
+            "X-ArrayView-Colormap": colormap,
+        },
+    })
+
+
+def _handle_diff_histogram(sid_a: str, sid_b: str, params: dict) -> None:
+    """Compute histogram of the diff between two sessions."""
+    session_a = SESSIONS.get(sid_a)
+    session_b = SESSIONS.get(sid_b)
+    if not session_a or not session_b:
+        _write_json({"error": "session not found"})
+        return
+
+    dim_x = int(params.get("dim_x", 0))
+    dim_y = int(params.get("dim_y", 0))
+    indices = params.get("indices", "")
+    dim_z = int(params.get("dim_z", -1))
+    dr = int(params.get("dr", 1))
+    complex_mode = int(params.get("complex_mode", 0))
+    log_scale = params.get("log_scale", "false").lower() == "true"
+    diff_mode = int(params.get("diff_mode", 1))
+    bins = int(params.get("bins", 64))
+
+    try:
+        raw, _, _, _, _ = _compute_diff(
+            session_a, session_b, dim_x, dim_y, indices,
+            dim_z, dr, complex_mode, log_scale, diff_mode,
+        )
+    except Exception as e:
+        _write_json({"error": str(e)})
+        return
+
+    vmin = float(raw.min())
+    vmax = float(raw.max())
+    counts, edges = np.histogram(raw.ravel(), bins=bins)
+    _write_json({
+        "counts": counts.tolist(),
+        "edges": edges.tolist(),
+        "vmin": vmin,
+        "vmax": vmax,
+    })
+
+
 def _handle_fetch_proxy(msg: dict) -> None:
     """Handle proxied fetch requests from the viewer."""
     endpoint = msg.get("endpoint", "")
@@ -516,6 +772,14 @@ def _handle_fetch_proxy(msg: dict) -> None:
         _write_json({"status": "started"})
     elif route == "preload_status" and sid:
         _write_json({"done": 0, "total": 0, "skipped": True})
+    elif route == "vectorfield" and sid:
+        _handle_vectorfield_fetch(sid, params)
+    elif route == "pixel" and sid:
+        _handle_pixel(sid, params)
+    elif route == "diff" and len(parts) >= 3:
+        _handle_diff(parts[1], parts[2], params)
+    elif route == "diff-histogram" and len(parts) >= 3:
+        _handle_diff_histogram(parts[1], parts[2], params)
     else:
         _write_error(f"unsupported endpoint: {endpoint}")
 
@@ -648,7 +912,20 @@ def _handle_get_viewer_html(msg: dict) -> None:
 
     sid = msg.get("sid", "")
 
-    query_val = json.dumps(f"?sid={sid}&transport=postMessage") if sid else "null"
+    # Build query string from session info — the extension forwards the full
+    # SESSION: payload so new features (overlay_sid, compare, etc.) work
+    # without touching extension code.
+    qs = f"?sid={sid}&transport=postMessage"
+    overlay_sid = msg.get("overlay_sid")
+    if overlay_sid:
+        qs += f"&overlay_sid={overlay_sid}"
+    compare_sids = msg.get("compare_sids")
+    if compare_sids:
+        sids = compare_sids if isinstance(compare_sids, list) else [s.strip() for s in str(compare_sids).split(",") if s.strip()]
+        if sids:
+            qs += f"&compare_sid={sids[0]}"
+            qs += f"&compare_sids={','.join(sids)}"
+    query_val = json.dumps(qs) if sid else "null"
 
     _theme_names = ["dark", "light", "solarized", "nord"]
     _cfg_theme = get_viewer_theme()

{arrayview-0.12.2 → arrayview-0.13.0}/src/arrayview/_vscode.py

@@ -58,7 +58,7 @@ def _vscode_app_bundle() -> str | None:
 
 _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_VERSION = "0.9.0"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.13.0"  # current bundled extension version
 _VSCODE_SIGNAL_FILENAME = "open-request-v0900.json"
 _VSCODE_COMPAT_SIGNAL_FILENAMES: tuple[str, ...] = ("open-request-v0800.json",)
 _VSCODE_PORT_SETTINGS_SETTLE_SECONDS = 2.0
@@ -152,14 +152,42 @@ def _remove_old_extension_versions(current_version: str) -> None:
                 _vprint(f"[ArrayView] could not remove {entry}: {exc}", flush=True)
 
 
-def _extension_on_disk(version: str) -> bool:
-    """Return True if the extension directory for *version* exists on disk."""
+def _extension_on_disk(version: str, vsix_path: str | None = None) -> bool:
+    """Return True if the extension directory for *version* exists on disk.
+
+    When *vsix_path* is given, also verifies that the installed extension
+    matches the bundled VSIX by comparing a content hash stored at install
+    time.  This catches rebuilds during development where the version stays
+    the same but the VSIX content changed.
+    """
+    import hashlib
+
     for base in (
         os.path.expanduser("~/.vscode/extensions"),
         os.path.expanduser("~/.vscode-server/extensions"),
     ):
-        if os.path.isdir(os.path.join(base, f"arrayview.arrayview-opener-{version}")):
+        ext_dir = os.path.join(base, f"arrayview.arrayview-opener-{version}")
+        if not os.path.isdir(ext_dir):
+            continue
+        if vsix_path is None:
+            return True
+        # Compare content hash
+        try:
+            vsix_hash = hashlib.md5(open(vsix_path, "rb").read()).hexdigest()
+        except OSError:
+            return True  # can't read VSIX, assume installed is fine
+        hash_file = os.path.join(ext_dir, ".vsix_hash")
+        try:
+            installed_hash = open(hash_file).read().strip()
+        except OSError:
+            installed_hash = None
+        if installed_hash == vsix_hash:
             return True
+        _vprint(
+            f"[ArrayView] VSIX content changed (installed={installed_hash}, bundled={vsix_hash}) — reinstalling",
+            flush=True,
+        )
+        return False
     return False
 
 
@@ -190,11 +218,11 @@ def _ensure_vscode_extension() -> bool:
         _vprint("[ArrayView] could not read version from bundled VSIX", flush=True)
         return False
 
-    # Fast path: correct version already installed — no reinstall needed.
-    # Reinstalling with --force triggers an extension-host reload, which
-    # creates a ~10-15s gap during which the signal file can be missed.
+    # Fast path: correct version and content already installed — no reinstall
+    # needed.  Reinstalling with --force triggers an extension-host reload,
+    # which creates a ~10-15s gap during which the signal file can be missed.
     _remove_old_extension_versions(ext_version)
-    if _extension_on_disk(ext_version):
+    if _extension_on_disk(ext_version, vsix_path):
         _VSCODE_EXT_INSTALLED = True
         _vprint(
             f"[ArrayView] extension v{ext_version} already installed — skipping reinstall",
@@ -228,6 +256,21 @@ def _ensure_vscode_extension() -> bool:
         )
         if r.returncode == 0 and not install_failed:
             _patch_vscode_extension_metadata(ext_version)
+            # Write content hash so future runs can detect VSIX rebuilds
+            # without a version bump (common during development).
+            try:
+                import hashlib
+                vsix_hash = hashlib.md5(open(vsix_path, "rb").read()).hexdigest()
+                for base in (
+                    os.path.expanduser("~/.vscode/extensions"),
+                    os.path.expanduser("~/.vscode-server/extensions"),
+                ):
+                    ext_dir = os.path.join(base, f"arrayview.arrayview-opener-{ext_version}")
+                    if os.path.isdir(ext_dir):
+                        with open(os.path.join(ext_dir, ".vsix_hash"), "w") as f:
+                            f.write(vsix_hash)
+            except Exception:
+                pass  # non-critical
             _VSCODE_EXT_INSTALLED = True
             _VSCODE_EXT_FRESH_INSTALL = True
             return True
@@ -566,7 +609,9 @@ def _open_via_signal_file(
 
 
 def _open_direct_via_signal_file(
-    filepath: str, title: str | None = None
+    filepath: str,
+    title: str | None = None,
+    extra_args: list[str] | None = None,
 ) -> bool:
     """Write a direct-mode signal file for the VS Code extension.
 
@@ -574,6 +619,10 @@ def _open_direct_via_signal_file(
     subprocess (``python -m arrayview --mode stdio <filepath>``) and hosts
     the viewer HTML directly in a webview panel with postMessage transport.
     No ports, no WebSocket, no authentication — just IPC.
+
+    *extra_args* are forwarded verbatim to the subprocess command line so
+    that new CLI flags (``--vectorfield``, ``--overlay``, ``--rgb``, …)
+    work without touching the extension.
     """
     import sys as _sys
 
@@ -586,6 +635,8 @@ def _open_direct_via_signal_file(
     }
     if title:
         payload["title"] = title
+    if extra_args:
+        payload["extraArgs"] = extra_args
     return _write_vscode_signal(payload, skip_compat=True)
 
 

{arrayview-0.12.2 → arrayview-0.13.0}/uv.lock

@@ -44,7 +44,7 @@ wheels = [
 
 [[package]]
 name = "arrayview"
-version = "0.12.2"
+version = "0.13.0"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },

{arrayview-0.12.2 → arrayview-0.13.0}/vscode-extension/extension.js

@@ -74,9 +74,10 @@ const EXT_PPIDS = _getAncestorPids(process.pid, 8);
 // bridges length-prefixed binary responses from stdout / JSON requests on stdin.
 // ---------------------------------------------------------------------------
 class PythonBridge {
-    constructor(filePath, onSessionReady, pythonPath, shmParams) {
+    constructor(filePath, onSessionReady, pythonPath, shmParams, extraArgs) {
         this.filePath = filePath;
         this.shmParams = shmParams || null;  // {name, shape, dtype}
+        this.extraArgs = extraArgs || [];    // additional CLI args (e.g. --vectorfield)
         this.process = null;
         this.sid = null;
         this._buffer = Buffer.alloc(0);
@@ -89,38 +90,85 @@ class PythonBridge {
         return new Promise((resolve, reject) => {
             this._startResolve = resolve;
             this._startReject = reject;
-            this._spawn(this.pythonPath || 'python3');
+            // Candidate order:
+            // 1. Explicit pythonPath (from signal file — always correct)
+            // 2. Workspace .venv (covers uv sync / editable installs during dev)
+            // 3. System python3/python (might have arrayview via pip)
+            // 4. uv run --with arrayview (ephemeral env from PyPI — always works)
+            if (this.pythonPath) {
+                this._candidates = [this.pythonPath];
+            } else {
+                this._candidates = ['python3', 'python', 'uv run --with arrayview python'];
+                // Prepend workspace .venv if it exists
+                const folders = vscode.workspace.workspaceFolders;
+                if (folders) {
+                    for (const f of folders) {
+                        const venvPy = path.join(f.uri.fsPath, '.venv', 'bin', 'python');
+                        if (fs.existsSync(venvPy)) {
+                            this._candidates.unshift(venvPy);
+                            break;
+                        }
+                    }
+                }
+            }
+            this._tryNextCandidate();
         });
     }
 
+    _tryNextCandidate() {
+        if (this._candidates.length === 0) {
+            const msg = 'Python with arrayview not found. Install with: pip install arrayview (or uv pip install arrayview)';
+            log(`PYTHON: all candidates exhausted`);
+            if (this._startReject) { this._startReject(new Error(msg)); this._startReject = null; }
+            return;
+        }
+        const cmd = this._candidates.shift();
+        this._spawn(cmd);
+    }
+
     _spawn(cmd) {
         const { spawn } = require('child_process');
-        let args;
+        let arrayviewArgs;
         if (this.shmParams) {
-            args = ['-m', 'arrayview', '--mode', 'stdio',
+            arrayviewArgs = ['-m', 'arrayview', '--mode', 'stdio',
                 '--shm-name', this.shmParams.name,
                 '--shm-shape', this.shmParams.shape,
                 '--shm-dtype', this.shmParams.dtype];
             if (this.shmParams.arrayName) {
-                args.push('--name', this.shmParams.arrayName);
+                arrayviewArgs.push('--name', this.shmParams.arrayName);
             }
         } else {
-            args = ['-m', 'arrayview', '--mode', 'stdio', this.filePath];
+            arrayviewArgs = ['-m', 'arrayview', '--mode', 'stdio', this.filePath];
+        }
+        if (this.extraArgs.length > 0) {
+            arrayviewArgs.push(...this.extraArgs);
+        }
+
+        // Support compound commands like "uv run python"
+        let spawnCmd, spawnArgs;
+        const parts = cmd.split(/\s+/);
+        if (parts.length > 1) {
+            spawnCmd = parts[0];
+            spawnArgs = [...parts.slice(1), ...arrayviewArgs];
+        } else {
+            spawnCmd = cmd;
+            spawnArgs = arrayviewArgs;
         }
-        log(`PYTHON: spawning ${cmd} ${args.join(' ')}`);
-        this.process = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+
+        log(`PYTHON: spawning ${spawnCmd} ${spawnArgs.join(' ')}`);
+        this.process = spawn(spawnCmd, spawnArgs, { stdio: ['pipe', 'pipe', 'pipe'] });
+
+        this._currentCmd = cmd;
 
         this.process.on('error', (err) => {
-            if (err.code === 'ENOENT' && cmd === 'python3' && !this.pythonPath) {
-                log('PYTHON: python3 not found, trying python');
-                this._spawn('python');
+            if (err.code === 'ENOENT' && this._candidates.length > 0) {
+                log(`PYTHON: ${spawnCmd} not found, trying next candidate`);
+                this._tryNextCandidate();
                 return;
             }
             log(`PYTHON: spawn error: ${err.message}`);
             if (this._startReject) {
-                this._startReject(new Error(
-                    cmd === 'python' ? 'Python not found. Install Python and arrayview (pip install arrayview).' : err.message
-                ));
+                this._startReject(new Error(err.message));
                 this._startReject = null;
             }
         });
@@ -133,6 +181,7 @@ class PythonBridge {
                     try {
                         const info = JSON.parse(line.slice(8));
                         this.sid = info.sid;
+                        this.sessionInfo = info;  // preserve full session info (overlay_sid, etc.)
                         if (this.onSessionReady) this.onSessionReady(info);
                         if (this._startResolve) {
                             this._startResolve(info);
@@ -152,7 +201,13 @@ class PythonBridge {
         });
 
         this.process.on('exit', (code) => {
-            log(`PYTHON: exited with code ${code}`);
+            log(`PYTHON: ${this._currentCmd} exited with code ${code}`);
+            // If we haven't started yet and there are more candidates, try next
+            if (code !== 0 && this._startResolve && this._candidates && this._candidates.length > 0) {
+                log(`PYTHON: trying next candidate after exit code ${code}`);
+                this._tryNextCandidate();
+                return;
+            }
             // Reject any pending request callbacks
             for (const cb of this._pendingCallbacks) {
                 cb(Buffer.from(JSON.stringify({ error: `process exited with code ${code}` })));
@@ -202,36 +257,28 @@ class PythonBridge {
 // ---------------------------------------------------------------------------
 // Direct webview: embeds the viewer HTML directly (no iframe/server)
 // ---------------------------------------------------------------------------
-async function openDirectWebview(filePath, title, pythonPath, shmParams) {
-    const label = title || (filePath ? path.basename(filePath) : (shmParams && shmParams.arrayName) || 'Array');
 
-    const viewColumn = vscode.window.activeTextEditor
-        ? vscode.ViewColumn.Beside
-        : vscode.ViewColumn.Active;
-
-    const panel = vscode.window.createWebviewPanel(
-        'arrayview.viewer',
-        `ArrayView: ${label}`,
-        { viewColumn, preserveFocus: false },
-        {
-            enableScripts: true,
-            retainContextWhenHidden: true,
-        }
-    );
-
-    // Spawn Python subprocess and wait for session to be ready
+/**
+ * Wire up a webview panel to a PythonBridge: set HTML, bridge messages,
+ * clean up on dispose.  Shared by openDirectWebview and the custom editor.
+ */
+async function setupArrayViewPanel(panel, filePath, pythonPath, shmParams, extraArgs) {
     const bridge = new PythonBridge(filePath, (sessionInfo) => {
         log(`SESSION READY: sid=${sessionInfo.sid} name=${sessionInfo.name}`);
-    }, pythonPath, shmParams);
+    }, pythonPath, shmParams, extraArgs);
     const sessionInfo = await Promise.race([
         bridge.start(),
         new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for Python session (30s)')), 30000)),
     ]);
 
-    // Get the rendered viewer HTML from the Python subprocess
+    // Get the rendered viewer HTML from the Python subprocess.
+    // Forward the full sessionInfo so the stdio server can build the correct
+    // query string (overlay_sid, etc.) without the extension needing to know
+    // about each feature.
     const htmlPayload = await bridge.sendRequest({
         type: 'get-viewer-html',
         sid: bridge.sid,
+        ...(bridge.sessionInfo || {}),
     });
 
     let viewerHtml;
@@ -239,13 +286,10 @@ async function openDirectWebview(filePath, title, pythonPath, shmParams) {
         const response = JSON.parse(htmlPayload.toString());
         viewerHtml = response.html;
     } catch (e) {
-        vscode.window.showErrorMessage(`ArrayView: Failed to get viewer HTML: ${e.message}`);
         bridge.destroy();
-        panel.dispose();
-        return;
+        throw new Error(`Failed to get viewer HTML: ${e.message}`);
     }
 
-    // Set the webview HTML
     panel.webview.html = viewerHtml;
 
     // Bridge messages between webview and Python subprocess
@@ -383,9 +427,66 @@ async function openDirectWebview(filePath, title, pythonPath, shmParams) {
         }
     });
 
+    log(`DIRECT: setup complete for ${filePath}`);
+    return bridge;
+}
+
+async function openDirectWebview(filePath, title, pythonPath, shmParams, extraArgs) {
+    const label = title || (filePath ? `ArrayView: ${path.basename(filePath)}` : (shmParams && shmParams.arrayName) || 'Array');
+
+    const viewColumn = vscode.window.activeTextEditor
+        ? vscode.ViewColumn.Beside
+        : vscode.ViewColumn.Active;
+
+    const panel = vscode.window.createWebviewPanel(
+        'arrayview.viewer',
+        label,
+        { viewColumn, preserveFocus: false },
+        {
+            enableScripts: true,
+            retainContextWhenHidden: true,
+        }
+    );
+
+    try {
+        await setupArrayViewPanel(panel, filePath, pythonPath, shmParams, extraArgs);
+    } catch (e) {
+        panel.dispose();
+        throw e;
+    }
     log(`DIRECT: opened "${label}" for ${filePath}`);
 }
 
+// ---------------------------------------------------------------------------
+// Custom editor provider: "Open With..." from Explorer
+// ---------------------------------------------------------------------------
+class ArrayViewEditorProvider {
+    static viewType = 'arrayview.arrayEditor';
+
+    openCustomDocument(uri, _openContext, _token) {
+        // Minimal document — just wraps the URI.  No data loading here;
+        // PythonBridge handles everything in resolveCustomEditor.
+        return { uri, dispose: () => {} };
+    }
+
+    async resolveCustomEditor(document, webviewPanel, _token) {
+        const filePath = document.uri.fsPath;
+        log(`CUSTOM-EDITOR: resolveCustomEditor for ${filePath}`);
+        webviewPanel.webview.options = { enableScripts: true };
+        webviewPanel.webview.html = `<html><body style="background:#1e1e1e;color:#ccc;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;font-family:system-ui">
+            <div>Loading ${path.basename(filePath)}…</div></body></html>`;
+        try {
+            await setupArrayViewPanel(webviewPanel, filePath);
+            log(`CUSTOM-EDITOR: setup complete for ${filePath}`);
+        } catch (e) {
+            log(`CUSTOM-EDITOR: error: ${e.message}\n${e.stack}`);
+            webviewPanel.webview.html = `<html><body style="color:#c00;padding:2em;font-family:monospace">
+                <h2>ArrayView failed to open</h2><pre>${e.message}</pre>
+                <p>Check Output → "ArrayView" for details.</p></body></html>`;
+        }
+    }
+}
+
 let version = 'unknown';
 let isProcessingSignal = false;
 let lastHandledRequestId = null;
@@ -715,7 +816,10 @@ async function processSignalData(data) {
                 try { fs.unlinkSync(path.join(SIGNAL_DIR, compat)); } catch (_) {}
             }
             const shmParams = data.shm ? { ...data.shm, arrayName: data.arrayName } : null;
-            await openDirectWebview(data.filepath, data.title, data.pythonPath, shmParams);
+            // Forward extra CLI args generically — Python builds this list from
+            // its argparse namespace so new flags work without extension changes.
+            const extraArgs = Array.isArray(data.extraArgs) ? data.extraArgs : [];
+            await openDirectWebview(data.filepath, data.title, data.pythonPath, shmParams, extraArgs);
             return;
         }
 
@@ -901,6 +1005,14 @@ function activate(context) {
     });
     context.subscriptions.push(openFileCmd);
 
+    // Register custom editor provider for "Open With..." support
+    const editorProvider = vscode.window.registerCustomEditorProvider(
+        ArrayViewEditorProvider.viewType,
+        new ArrayViewEditorProvider(),
+        { webviewOptions: { retainContextWhenHidden: true } }
+    );
+    context.subscriptions.push(editorProvider);
+
     // Start SSH relay listener for zero-config remote array viewing
     startRelayServer();
     context.subscriptions.push({ dispose: () => {

arrayview-0.13.0/vscode-extension/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "arrayview-opener",
+  "displayName": "ArrayView Opener",
+  "description": "Opens ArrayView in VS Code and can promote tunnel ports to public preview",
+  "version": "0.13.0",
+  "publisher": "arrayview",
+  "license": "MIT",
+  "icon": "icon.png",
+  "engines": { "vscode": "^1.80.0" },
+  "extensionKind": ["workspace", "ui"],
+  "categories": ["Other"],
+  "activationEvents": ["*"],
+  "main": "./extension.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oscarvanderheide/arrayview.git"
+  },
+  "files": [
+    "extension.js",
+    "package.json",
+    "icon.png",
+    "LICENSE"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "arrayview.openFile",
+        "title": "Open in ArrayView"
+      }
+    ],
+    "customEditors": [
+      {
+        "viewType": "arrayview.arrayEditor",
+        "displayName": "ArrayView",
+        "selector": [
+          { "filenamePattern": "*.npy" },
+          { "filenamePattern": "*.npz" },
+          { "filenamePattern": "*.nii" },
+          { "filenamePattern": "*.nii.gz" },
+          { "filenamePattern": "*.h5" },
+          { "filenamePattern": "*.hdf5" },
+          { "filenamePattern": "*.mat" },
+          { "filenamePattern": "*.tif" },
+          { "filenamePattern": "*.tiff" },
+          { "filenamePattern": "*.pt" },
+          { "filenamePattern": "*.pth" },
+          { "filenamePattern": "*.zarr.zip" }
+        ],
+        "priority": "default"
+      }
+    ]
+  }
+}

arrayview-0.12.2/vscode-extension/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "arrayview-opener",
-  "displayName": "ArrayView Opener",
-  "description": "Opens ArrayView in VS Code and can promote tunnel ports to public preview",
-  "version": "0.11.0",
-  "publisher": "arrayview",
-  "license": "MIT",
-  "engines": { "vscode": "^1.80.0" },
-  "extensionKind": ["workspace", "ui"],
-  "categories": ["Other"],
-  "activationEvents": ["*"],
-  "main": "./extension.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/oscarvanderheide/arrayview.git"
-  },
-  "files": [
-    "extension.js",
-    "package.json",
-    "LICENSE"
-  ],
-  "contributes": {
-    "commands": [
-      {
-        "command": "arrayview.openFile",
-        "title": "ArrayView: Open File"
-      }
-    ]
-  }
-}