arrayview 0.7.0__tar.gz → 0.9.0__tar.gz

{arrayview-0.7.0 → arrayview-0.9.0}/.claude/skills/ui-consistency-audit/SKILL.md

@@ -222,6 +222,13 @@ These rules are codified as DOM assertions in `tests/ui_audit.py`. When a new in
 | R26 | Shared colorbar width capped in compare mode | `#slim-cb-wrap` width ≤ 500px in compare mode |
 | R27 | Mode eggs hidden during loading | `#mode-eggs` empty/hidden until at least one frame has been received |
 | R28 | Compare+multiview crosshair fade works | Crosshair lines in compare+multiview fade in/out on hover, scoped to the hovered array's panes |
+| R29 | Dimbar/colorbar height sync | `#info` and `#slim-cb-wrap` offsetHeight within 4px when both visible. Enforced by `_validateUIState()` (runtime) and `run_invariant_assertions()` (Playwright) |
+| R30 | Drag positions cleared on immersive exit | `_infoDragPos`, `_cbDragPos`, `_islandDragPos` all null when `!_fullscreenActive`. Enforced by `_validateUIState()` and `run_immersive_exit_assertions()` |
+| R31 | No .fs-overlay outside immersive | Zero `.fs-overlay` elements when `!_fullscreenActive && !_immersiveAnimating`. Enforced by `_validateUIState()` and `run_immersive_exit_assertions()` |
+| R32 | Per-pane cbs only in immersive+center | `.compare-pane-cb-island.fs-overlay` count > 0 only when `_fullscreenActive && centerMode`. Enforced by `_validateUIState()` |
+| R33 | Colorbar flex-direction always row | All visible `.cb-island` computed `flex-direction === 'row'`. Enforced by CSS (`!important`) and `_validateUIState()` and `run_invariant_assertions()` |
+| R34 | Shared colorbar visible in compare non-center | `#slim-cb-wrap` not `display:none` when `compareActive && !centerMode`. Enforced by `_validateUIState()` |
+| R35 | Islands fully inside or outside pane | Dynamic islands must be fully inside pane bounds (immersive) or fully outside in normal flow (non-immersive) — never partially overlapping |
 
 ---
 
@@ -240,6 +247,31 @@ All colorbars across ALL modes follow the same structure: `[vmin span] [gradient
 
 ---
 
+## Section 5d: Enforcement Layers
+
+Rules are enforced through multiple layers. When adding new rules, add enforcement at the appropriate layer(s):
+
+| Layer | Mechanism | Where | When it runs |
+|-------|-----------|-------|--------------|
+| **CSS** | `!important` structural constraints | `_viewer.html` CSS (line ~156) | Always — structurally impossible to violate |
+| **Runtime JS** | `_validateUIState()` | `_viewer.html` JS (after `_positionFullscreenChrome`) | After every layout change, gated behind `?debug_ui=1` |
+| **Playwright** | `run_invariant_assertions()` + `run_immersive_exit_assertions()` | `tests/ui_audit.py` | During `ui_audit.py` runs (all tiers) |
+| **Skill** | This document (Section 5b) | `.claude/skills/ui-consistency-audit/SKILL.md` | When AI agent invokes the skill |
+
+**Cross-reference:**
+
+| Rule | CSS | Runtime JS | Playwright | Notes |
+|------|-----|-----------|------------|-------|
+| R29 (height sync) | — | ✓ | ✓ | |
+| R30 (drag cleanup) | — | ✓ | ✓ | Only after immersive exit |
+| R31 (fs-overlay cleanup) | — | ✓ | ✓ | Only after immersive exit |
+| R32 (per-pane cb visibility) | — | ✓ | — | |
+| R33 (flex-direction row) | ✓ | ✓ | ✓ | CSS makes violation impossible |
+| R34 (shared cb in compare) | — | ✓ | — | |
+| R35 (island containment) | — | — | — | Design principle, enforced by code review |
+
+---
+
 ## Section 6: Common Feature Categories
 
 ### Zoom / Canvas Sizing

arrayview-0.9.0/.claude/skills/visual-bug-fixing/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: visual-bug-fixing
+description: Use when fixing any visual bug, layout glitch, rendering artifact, or UI regression in arrayview. Triggered by symptoms like overlapping elements, wrong positioning, missing components, flickering, or incorrect sizing in any view mode.
+---
+
+# Visual Bug Fixing
+
+## Overview
+
+**Fix visual bugs with screenshot evidence, not guesswork.** Capture before-state, diagnose root cause, fix, capture after-state, verify no regressions across all view modes. Never commit a visual fix without photographic proof it works and doesn't break anything else.
+
+## When to Use
+
+- User reports a visual bug (overlap, misalignment, wrong size, missing element, rendering artifact)
+- You notice a visual inconsistency during other work
+- A UI change causes unexpected layout shifts
+- Screenshot diff failures in `ui_audit.py`
+
+**When NOT to use:**
+- Pure logic bugs with no visual impact — use superpowers:systematic-debugging
+- Adding new UI features — use ui-consistency-audit + frontend-designer
+- Updating test coverage — use viewer-ui-checklist
+
+## Workflow
+
+```dot
+digraph visual_bug_fix {
+  rankdir=TB;
+  "Bug reported" -> "Capture baseline screenshots";
+  "Capture baseline screenshots" -> "Diagnose root cause";
+  "Diagnose root cause" -> "Implement fix";
+  "Implement fix" -> "Capture post-fix screenshots";
+  "Capture post-fix screenshots" -> "Compare before/after";
+  "Compare before/after" -> "Run full regression check";
+  "Run full regression check" -> "Regressions found?" [shape=diamond];
+  "Regressions found?" -> "Implement fix" [label="yes — iterate"];
+  "Regressions found?" -> "Show evidence & commit" [label="no"];
+}
+```
+
+### Step 1: Capture Baseline Screenshots
+
+Before touching any code, capture the current broken state. Use the Playwright MCP tools:
+
+1. **Navigate** to the affected view using `browser_navigate` to the arrayview URL
+2. **Set up the bug conditions** — press keys to enter the right mode, load the right array
+3. **Screenshot the broken state** with `browser_take_screenshot` — save as `baseline_bug.png`
+4. **Screenshot ALL other modes** that could be affected:
+   - Normal view (default)
+   - Immersive mode (`Shift+K`)
+   - Compare mode (navigate to compare URL)
+   - Diff modes (`Shift+X` to cycle)
+   - Multiview (`v`)
+   - Zen mode (`Shift+F`)
+   - Zoomed state (`+` keys)
+
+**Key selectors to inspect** (via `browser_snapshot` or `browser_evaluate`):
+- `#canvas-wrap` — main canvas container
+- `#slim-cb-wrap` — colorbar wrapper
+- `#info` — info bar
+- `.mode-egg` — mode indicator badges
+- `#miniview` — minimap overlay
+- `#dimbar` — dimension navigation bar
+
+### Step 2: Diagnose Root Cause
+
+Read the relevant source files. The UI lives in:
+
+| Layer | File |
+|-------|------|
+| HTML structure | `arrayview/_viewer.html` |
+| Inline CSS | `<style>` blocks in `_viewer.html` |
+| Canvas rendering | JavaScript in `_viewer.html` (search for `scaleCanvas`, `mvScaleAllCanvases`, `compareScaleCanvases`) |
+| Python server | `arrayview/_app.py` |
+| Colorbar logic | `ColorBar` class in `_viewer.html` |
+
+**Diagnosis checklist:**
+- Is this a CSS issue (positioning, overflow, z-index, flexbox)?
+- Is this a JS layout calculation issue (wrong width/height, missing mode branch)?
+- Does the bug only appear in certain modes? Which scale function is involved?
+- Does zoom level matter? Check the zoom-related code paths.
+- Is this a race condition (element rendered before data arrives)?
+
+**Check hard rules:** Before implementing a fix, check if the bug is a violation of a hard UI rule (R1-R35 in `ui-consistency-audit` Section 5b). If so, the fix should restore the invariant rather than work around it. Enable `?debug_ui=1` to see runtime invariant warnings in the browser console — they may pinpoint the exact rule being violated.
+
+**Use `browser_evaluate` to inspect live DOM state:**
+```javascript
+// Get bounding boxes of key elements
+JSON.stringify({
+  canvas: document.querySelector('#canvas-wrap')?.getBoundingClientRect(),
+  colorbar: document.querySelector('#slim-cb-wrap')?.getBoundingClientRect(),
+  info: document.querySelector('#info')?.getBoundingClientRect(),
+  viewport: { width: window.innerWidth, height: window.innerHeight }
+})
+```
+
+### Step 3: Implement the Fix
+
+Apply the minimal fix. Reference the ui-consistency-audit design rules (R1-R35) to ensure the fix doesn't violate any existing constraints.
+
+**Common fix patterns:**
+- **Overlap bugs**: Check z-index hierarchy, adjust `position`/`top`/`left`/`right`
+- **Sizing bugs**: Trace the calculation chain in the relevant scale function
+- **Mode-specific bugs**: Ensure all mode branches handle the element (check `isCompare`, `isMultiview`, `isImmersive`, `isZen` flags)
+- **Zoom bugs**: Check `zoomLevel` interactions with element positioning
+
+### Step 4: Capture Post-Fix Screenshots
+
+Repeat the exact same navigation and key presses from Step 1. Screenshot every view that was captured in the baseline.
+
+### Step 5: Compare Before/After
+
+Present the before and after screenshots to the user. Explain:
+- What was broken (with baseline screenshot)
+- What changed in the code
+- What it looks like now (with post-fix screenshot)
+
+### Step 6: Full Regression Check
+
+Run the automated visual audit:
+
+```bash
+uv run python tests/ui_audit.py --tier 1
+```
+
+This checks 14 core scenarios with DOM assertions and pixel diffs. If any fail:
+- Read the failure output to identify which scenario regressed
+- Screenshot that specific scenario manually to understand the regression
+- Go back to Step 3 and iterate
+
+For thorough validation (before committing):
+```bash
+uv run python tests/ui_audit.py --tier 2
+```
+
+**Only commit when Tier 1 passes clean.** Tier 2 failures should be investigated but may be pre-existing.
+
+## Red Flags — STOP and Investigate
+
+| Symptom | Likely Cause |
+|---------|-------------|
+| Fix works in normal mode but breaks compare | Missing branch in `compareScaleCanvases` |
+| Element disappears on zoom | Absolute positioning without zoom-aware offsets |
+| Fix works at 1440x900 but breaks at other sizes | Hardcoded pixel values instead of relative/calc |
+| Colorbar overlaps canvas after fix | Forgot to account for colorbar width in canvas sizing |
+| Mode eggs shift position | Changed a parent container's layout without updating egg anchoring |
+
+## Common Mistakes
+
+- **Fixing the symptom, not the cause** — A `display:none` hack hides the bug. Find why the element is in the wrong place.
+- **Testing only the affected mode** — Visual bugs often have cross-mode impact. Always check at minimum: normal, immersive, compare, multiview.
+- **Skipping the baseline screenshot** — Without before/after evidence, you can't prove the fix worked or detect subtle regressions.
+- **Committing without running ui_audit.py** — DOM assertions catch things screenshots miss (off-by-1px overlaps, viewport overflow).

{arrayview-0.7.0 → arrayview-0.9.0}/.gitignore

@@ -29,4 +29,8 @@ dev/
 
 benchmarks/data
 .superpowers/brainstorm
-site/
+site/
+van_gogh/
+cig_presentation/
+docs/superpowers
+.playwright-mcp/

arrayview-0.9.0/AGENTS.md

@@ -0,0 +1,40 @@
+Read `src/arrayview/ARCHITECTURE.md` for codebase orientation.
+
+# ArrayView
+
+## Skills
+
+Load the relevant skill before touching the corresponding area.
+
+| Skill | When |
+|-------|------|
+| `ui-consistency-audit` | Any visual/UI change |
+| `frontend-designer` | Styling/layout changes to `_viewer.html` |
+| `vscode-simplebrowser` | Extension, signal-file IPC, `_VSCODE_EXT_VERSION` |
+| `invocation-consistency` | Server startup, display-opening, env detection |
+| `docs-style` | README, help overlay, docstrings |
+
+## Non-Negotiables
+
+- Always use `localhost` (not `127.0.0.1`) -- required for VS Code port forwarding
+- Never `--force` reinstall the extension if correct version is on disk
+- Do not add logic to `_app.py` -- compat shim only
+- Avoid orphan processes; shutdown must be automatic
+- Do not regress working display paths when fixing another
+- For visual/animation features, propose 2-3 options BEFORE implementing
+- UI visibility changes go through reconcilers (`_reconcileUI`/`_reconcileLayout`/`_reconcileCompareState`/`_reconcileCbVisibility`), not inline `style.display` or `classList` toggles in mode functions
+- All colorbar state (animation, window/level, hover, drag) flows through `primaryCb` ColorBar instance — never read/write legacy globals. Multiview colorbars sync via `primaryCb`.
+
+## Execution
+
+Always use **subagent-driven development** for implementation. Commit completed work automatically.
+
+## Testing
+
+```bash
+uv run pytest tests/test_api.py -v       # HTTP API
+uv run pytest tests/test_browser.py -v   # Playwright
+uv run python tests/visual_smoke.py      # screenshots
+```
+
+After any UI change, use `/ui-consistency-audit` to verify across all modes.

{arrayview-0.7.0 → arrayview-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.7.0
+Version: 0.9.0
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview
@@ -103,7 +103,23 @@ for epoch in range(100):
 
 ## Once open
 
-`c` colormaps · `d` dynamic range · `v` 3-plane · `z` mosaic · `Shift+O` overlay toggle · `?` help · colorbar dblclick histogram
+**Navigation:** scroll slices · `h`/`l` cycle dims · `j`/`k` slices · `=`/`-` zoom · drag pan
+**Views:** `v` 3-plane · `z` mosaic · `q` qMRI · `n` compare · `=` immersive
+**Display:** `c`/`C` colormaps · `d`/`D` dynamic range · `f` FFT · `m` complex · `p` projections · `L` log
+**Tools:** `S` segmentation · `u` ruler · `s` screenshot · `?` help
+
+
+## nnInteractive Segmentation
+
+`S` starts AI-assisted 3D segmentation (requires CUDA). Click/draw to segment, `Enter` to accept.
+
+```toml
+[nninteractive]
+url = "http://gpu-server:1527"   # skip auto-launch, use running server
+```
+
+Or: `ARRAYVIEW_NNINTERACTIVE_URL=http://gpu-server:1527`
+
 
 ## Config
 

{arrayview-0.7.0 → arrayview-0.9.0}/README.md

@@ -68,7 +68,23 @@ for epoch in range(100):
 
 ## Once open
 
-`c` colormaps · `d` dynamic range · `v` 3-plane · `z` mosaic · `Shift+O` overlay toggle · `?` help · colorbar dblclick histogram
+**Navigation:** scroll slices · `h`/`l` cycle dims · `j`/`k` slices · `=`/`-` zoom · drag pan
+**Views:** `v` 3-plane · `z` mosaic · `q` qMRI · `n` compare · `=` immersive
+**Display:** `c`/`C` colormaps · `d`/`D` dynamic range · `f` FFT · `m` complex · `p` projections · `L` log
+**Tools:** `S` segmentation · `u` ruler · `s` screenshot · `?` help
+
+
+## nnInteractive Segmentation
+
+`S` starts AI-assisted 3D segmentation (requires CUDA). Click/draw to segment, `Enter` to accept.
+
+```toml
+[nninteractive]
+url = "http://gpu-server:1527"   # skip auto-launch, use running server
+```
+
+Or: `ARRAYVIEW_NNINTERACTIVE_URL=http://gpu-server:1527`
+
 
 ## Config
 

{arrayview-0.7.0 → arrayview-0.9.0}/docs/remote.md

@@ -16,19 +16,40 @@ Auto-detects VS Code terminals and opens in Simple Browser. Works automatically.
 
 ## VS Code tunnel
 
-For remote development through a VS Code tunnel, start the server on the remote machine:
+The VS Code extension uses a **direct webview** transport: the viewer runs
+inside a VS Code webview panel and communicates with a Python subprocess via
+the extension host.  No port forwarding or public ports are needed — everything
+stays inside the tunnel.
 
 ```bash
-# on the remote machine
-arrayview --serve
+arrayview volume.nii.gz     # opens in a webview tab automatically
+```
+
+### How it works
+
+```
+Viewer (webview) ←postMessage→ Extension Host ←stdin/stdout→ Python
 ```
 
-Set port 8000 to Public in the VS Code Ports tab. Load arrays normally — each opens in Simple Browser:
+Instead of a WebSocket connection to a running server, the extension spawns a
+dedicated Python process per array.  Slice requests travel through VS Code's
+`postMessage` IPC and the extension relays them to Python's stdin as JSON.
+Binary RGBA responses flow back through stdout with a length prefix.
+
+This avoids the main limitation of the WebSocket approach: VS Code tunnels
+don't expose arbitrary ports, so the old method required manually setting
+port 8000 to "Public" in the Ports tab.
+
+### Fallback: WebSocket mode
+
+If you prefer the traditional WebSocket server (e.g. for multi-hop setups or
+when sharing the viewer URL), you can still use it:
 
 ```bash
-arrayview volume.nii.gz
+arrayview --serve
 ```
 
+Set port 8000 to Public in the VS Code Ports tab, then load arrays normally.
 The server persists across invocations. Kill it with `arrayview --kill`.
 
 ## Multi-hop

arrayview-0.9.0/plans/webview/LOG.md

@@ -0,0 +1,130 @@
+# Webview Message Passing Debug Log
+
+## Problem Statement
+`uv run arrayview medium_array.npy` in VS Code tunnel: opens webview tab the first time, but subsequent runs (after closing tab + Ctrl+C) do nothing.
+
+## Root Cause Found (2026-03-31)
+
+### Extension log for first run (works):
+```
+DISPATCH: file=open-request-v0900.json mode=direct hasFilepath=true ...
+SIGNAL-DATA: mode=direct filepath=...medium_array.npy
+PYTHON: spawning .../python3 -m arrayview --mode stdio .../medium_array.npy
+SIGNAL: missing url          <-- v0800 compat duplicate being processed
+SESSION READY: sid=...
+DIRECT: opened "ArrayView: medium_array.npy"
+```
+
+### Extension log for second run (broken):
+```
+PYTHON: exited with code null   <-- user closed tab + Ctrl+C
+SIGNAL: missing url              <-- NO DISPATCH line!
+SIGNAL: missing url
+```
+
+### Analysis
+1. First run: v0900 signal (mode=direct) is processed correctly. v0800 compat duplicate also fires, falls through to "missing url" (harmless).
+2. User closes tab, presses Ctrl+C -> Python subprocess exits (`code null` = SIGTERM)
+3. Second run: signal files are written by Python, but NO `DISPATCH:` log appears, meaning the signals are being consumed before reaching `processSignalData`.
+
+### Key insight: the v0800 compat signal from the FIRST run
+Python writes to BOTH `open-request-v0900.json` AND `open-request-v0800.json` (same data). On the first run:
+- Tick 1: v0900 is claimed and processed (direct mode -> success)
+- Tick 2: v0800 is claimed and processed (direct mode, but duplicate -> "missing url" because it passes the direct check but the Python process already exited, OR it's a different issue)
+
+Wait -- looking again at the log: `SIGNAL: missing url` at 10:12:12.781 happens DURING the first run's processing (between PYTHON spawn and SESSION READY). This is the v0800 being processed on the SAME tick? No -- `tryOpenSignalFile` processes one signal per tick and returns.
+
+Actually the v0800 `SIGNAL: missing url` at 10:12:12.781 has NO `DISPATCH:` line either! So this is coming from a DIFFERENT code path or an OLD extension host.
+
+### Root cause hypothesis
+There may be TWO signal file consumers:
+1. The fs.watch handler
+2. The setInterval polling handler
+
+Both call `tryOpenSignalFile()`. The `isProcessingSignal` flag prevents re-entry WITHIN `processSignalData`, but the claim (rename) happens BEFORE `processSignalData` is called. Two concurrent `tryOpenSignalFile` calls could each claim different files.
+
+Actually no -- looking at the code flow: `tryOpenSignalFile` iterates through candidates, tries to rename (claim) each one. If rename succeeds, it processes that file. If another call already claimed it, `rename` throws and `continue` moves to the next candidate.
+
+The REAL issue: the v0800 compat signal is being claimed and processed by a SECOND `tryOpenSignalFile` invocation that runs with the OLD in-memory code (no DISPATCH logging). This happens because `fs.watch` can fire multiple times for a single file write, and each fires `tryOpenSignalFile`.
+
+### Actual fix needed
+The v0800 compat signal duplicates are harmful. The second signal gets processed while the first is still in-flight (the `isProcessingSignal` flag isn't set yet when the second call starts because the first hasn't reached `processSignalData` yet -- it's still in the claiming loop).
+
+**The real fix**: Stop writing to the v0800 compat signal file. Only write to v0900. The v0800 compat path was for older extension versions which are no longer relevant since we control the extension install.
+
+OR: the second run fails because the v0800 from the SECOND run gets claimed by a concurrent `tryOpenSignalFile` that started before `isProcessingSignal` was set by the first one.
+
+## Previous issues resolved
+1. **System python not found** (initial): Extension spawned `/usr/bin/python3` which didn't have arrayview. Fixed by passing `pythonPath` (sys.executable) in the signal file.
+2. **Extension not reloading**: `code --install-extension --force` updates files on disk but the extension host in a tunnel doesn't auto-restart. Need "Developer: Restart Extension Host" specifically.
+
+## Fix: v0800 compat duplicate causing isProcessingSignal deadlock
+
+**Root cause confirmed**: Python writes to both `v0900` and `v0800` signal files (same data). The v0800 duplicate gets processed after the first direct webview completes, triggering a SECOND `openDirectWebview` that spawns another Python subprocess. This keeps `isProcessingSignal = true` for up to 30 seconds (timeout). During that window, any new signals from a second `arrayview` invocation are silently dropped.
+
+**Fix applied**:
+1. **Python side**: `_open_direct_via_signal_file()` and `_open_direct_via_shm()` now pass `skip_compat=True` to `_write_vscode_signal()`, so direct-mode signals only write to `v0900` (no v0800 duplicate).
+2. **Extension side**: After detecting a direct-mode signal, immediately delete any compat signal files (`v0800`, `v0400`) before spawning the subprocess. This prevents duplicates even if old Python code writes compat files.
+
+## Fix: extension not loading due to version mismatch (2026-03-31, session 2)
+
+**Symptom**: `uv run arrayview medium_array.npy` writes signal file, but nothing happens. Extension log shows no `ACTIVATE` since 10:50. Extension hosts running (PIDs 28784, 4052896) but not loading the extension.
+
+**Root cause**: `_VSCODE_EXT_VERSION` in `_vscode.py` was `"0.10.0"` but the bundled VSIX and `vscode-extension/package.json` are at `"0.10.2"`. This caused a cascade:
+1. `_ensure_vscode_extension()` calls `_remove_old_extension_versions("0.10.0")`, which deletes the `arrayview.arrayview-opener-0.10.2/` directory.
+2. `_extension_on_disk("0.10.0")` finds the v0.10.0 directory and skips reinstall.
+3. But `extensions.json` (VS Code's extension registry) still points to the v0.10.2 path.
+4. VS Code extension host looks for `arrayview.arrayview-opener-0.10.2/`, can't find it, silently skips loading → no ACTIVATE, no signal handling.
+
+**Evidence**:
+- `extensions.json` referenced `arrayview.arrayview-opener-0.10.2` but only `0.10.0` directory existed
+- `code --list-extensions --show-versions` showed `@0.10.2` (from metadata) but directory was named `0.10.0`
+- No ACTIVATE log entries after 10:50 despite two running extension hosts
+- `SIGNAL: missing url` entries in log came from a PREVIOUS (now-dead) extension host whose fs.watch/setInterval leaked past deactivation
+
+**Fix**:
+1. Updated `_VSCODE_EXT_VERSION` to `"0.10.2"` in `_vscode.py`
+2. Uninstalled + reinstalled extension to sync directory name with metadata
+3. Restart extension host needed to load the extension
+
+## Multi-window targeting issue (2026-03-31, session 3)
+
+**Symptom**: When multiple VS Code tunnel windows are open to the same remote (different directories), `arrayview` opens the webview tab in the wrong window.
+
+**Analysis**:
+In tunnel/remote mode, the original code skips hookTag matching (`if ipc_hook and not _is_vscode_remote()` — line 642) and falls back to PID ancestry matching. Two potential problems:
+
+1. **hookTag matching was disabled for remotes**: The comment says "terminal and extension host have different IPC hooks in tunnel mode" — but this may not be true. In SSH remotes and possibly tunnels, both the terminal and extension host may share the same `VSCODE_IPC_HOOK_CLI` from the same VS Code server instance. If so, hookTag is the most reliable targeting method.
+
+2. **PID ancestry may be ambiguous**: If the tunnel server's process tree doesn't clearly separate per-window subtrees, PID ancestry matching picks the wrong window (or falls to broadcast, where any window can claim the signal).
+
+**Root cause confirmed via diagnostics**:
+1. Both extension hosts have IDENTICAL ppids `[3342979, 3342975, 22342, ...]` — both are direct children of the same `node` process. PID ancestry matching gives identical scores.
+2. In a tunnel, all terminals share the same `VSCODE_IPC_HOOK_CLI` socket (the tunnel server's CLI socket), so hookTag is the same for both terminals → always targets the same window.
+
+**Fix: EnvironmentVariableCollection**:
+- **Extension side**: Uses `context.environmentVariableCollection.replace('ARRAYVIEW_WINDOW_ID', windowId)` to inject a window-specific env var into all terminals opened in that window. Each window has a unique `windowId` (hookTag or PID).
+- **Python side**: New `_find_arrayview_window_id()` reads `ARRAYVIEW_WINDOW_ID` from direct env or ancestor `/proc/<pid>/environ` (handles `uv run` env stripping). Used as primary targeting method for remote/tunnel, with PID ancestry as fallback.
+- Rebuilt VSIX, force-reinstalled extension, cleaned up stale window registrations.
+
+**Result**: Fix confirmed working — each window now correctly targets its own webview tab.
+
+## Fix: av.view() in tunnel using ports instead of direct webview (2026-03-31, session 3)
+
+**Symptom**: `av.view(x)` from a Python script in a VS Code tunnel terminal shows "Remote tunnel session on port 8123" message and uses port-based approach instead of direct webview.
+
+**Root cause**: A stale server running on port 8123 (from a previous CLI session) caused `_server_alive(port)` at line 836 to return True, taking the URL-based path before reaching the direct webview path at line 928.
+
+**Fix**:
+1. Moved the non-Jupyter tunnel direct webview check ABOVE the `_server_alive` check. Tunnel sessions now always use direct webview regardless of stale servers.
+2. Changed the `_server_alive` path to only activate for non-remote sessions (`not _is_vscode_remote()`).
+3. Jupyter in tunnel: changed from "webview tab + message" to inline IFrame mode. VS Code tunnel auto-forwards ports, so IFrames work for the tunnel owner. Added `_configure_vscode_port_preview(port)` to set the port as silent.
+
+## Changes made so far
+- `_vscode.py`: `_open_direct_via_signal_file()` now includes `pythonPath: sys.executable`
+- `_vscode.py`: New `_open_direct_via_shm()` for passing arrays via shared memory
+- `_launcher.py`: `view()` tunnel paths use `_open_direct_via_shm()` instead of temp files
+- `_launcher.py`: Added `--shm-name/--shm-shape/--shm-dtype/--name` CLI args for stdio mode
+- `extension.js`: `PythonBridge` accepts `pythonPath` and `shmParams`
+- `extension.js`: `processSignalData` handles `data.shm` for shared memory mode
+- `extension.js`: Debug logging (`DISPATCH:`, `SIGNAL-DATA:`)

{arrayview-0.7.0 → arrayview-0.9.0}/pyproject.toml

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

arrayview-0.9.0/scripts/release.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# release.sh — bump version, commit, tag, push, create GitHub release
+# ---------------------------------------------------------------------------
+
+BUMP="minor"
+DRY_RUN=true
+
+usage() {
+    cat <<EOF
+Usage: $(basename "$0") [OPTIONS]
+
+Options:
+  --bump {major,minor,patch}   Version bump type (default: minor)
+  --execute                    Actually run (default is dry-run)
+  -h, --help                   Show this help
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --bump)   BUMP="$2"; shift 2 ;;
+        --execute) DRY_RUN=false; shift ;;
+        -h|--help) usage; exit 0 ;;
+        *) echo "Unknown option: $1"; usage; exit 1 ;;
+    esac
+done
+
+if [[ ! "$BUMP" =~ ^(major|minor|patch)$ ]]; then
+    echo "Error: --bump must be major, minor, or patch (got '$BUMP')"
+    exit 1
+fi
+
+# --- Guard: clean working tree on main ---
+branch=$(git rev-parse --abbrev-ref HEAD)
+if [[ "$branch" != "main" ]]; then
+    echo "Error: must be on main (currently on '$branch')"
+    exit 1
+fi
+
+if ! git diff --quiet || ! git diff --cached --quiet; then
+    echo "Error: working tree is dirty — commit or stash first"
+    exit 1
+fi
+
+# --- Bump version ---
+uv version --bump "$BUMP"
+VERSION=$(uv version --short)
+TAG="v${VERSION}"
+
+echo "Version bumped to $VERSION (tag: $TAG)"
+
+run() {
+    echo "+ $*"
+    if [[ "$DRY_RUN" == true ]]; then
+        return
+    fi
+    "$@"
+}
+
+# --- Commit, tag, push, release ---
+run git add pyproject.toml
+run git commit -m "release: $TAG"
+run git push origin main
+run git tag "$TAG"
+run git push origin "$TAG"
+run gh release create "$TAG" \
+    --title "[Pre-release] $TAG" \
+    --generate-notes \
+    --prerelease
+
+if [[ "$DRY_RUN" == true ]]; then
+    echo ""
+    echo "(dry-run — re-run with --execute to apply)"
+    git checkout pyproject.toml
+fi