arrayview 0.48.4__py3-none-any.whl → 0.49.1__py3-none-any.whl

arrayview/_analysis.py

@@ -60,6 +60,15 @@ def _build_metadata(session) -> dict:
     }
     if getattr(session, "initial_view", None):
         meta["initial_view"] = session.initial_view
+    if meta["has_source_file"]:
+        from arrayview._config import get_viewer_remember_view
+
+        if get_viewer_remember_view():
+            from arrayview._view_memory import remembered_view
+
+            remembered = remembered_view(session)
+            if remembered:
+                meta["remembered_view"] = remembered
     code_source = _code_source(session)
     if code_source is not None:
         meta["code_source"] = code_source

arrayview/_config.py

@@ -39,6 +39,8 @@ BUILTIN_PREFERENCES = {
         "theme": "dark",
         "rounded_panes": True,
         "qmri_gapless": False,
+        "compare_gapless": False,
+        "remember_view": False,
         "ortho_layout": None,
         "dimbar_mode": "compact",
     },
@@ -49,6 +51,8 @@ PREFERENCE_SCHEMA = {
         "theme": sorted(_VALID_THEMES),
         "rounded_panes": "boolean",
         "qmri_gapless": "boolean",
+        "compare_gapless": "boolean",
+        "remember_view": "boolean",
         "colormaps": "non-empty list of names",
         "ortho_layout": sorted(_VALID_ORTHO_LAYOUTS),
         "dimbar_mode": sorted(_VALID_DIMBAR_MODES),
@@ -120,7 +124,7 @@ def _validate_preference(section: str, key: str, value):
         )
     if section == "viewer" and key == "theme":
         return _normalized_string(value, _VALID_THEMES, "viewer.theme")
-    if section == "viewer" and key in ("rounded_panes", "qmri_gapless"):
+    if section == "viewer" and key in ("rounded_panes", "qmri_gapless", "compare_gapless", "remember_view"):
         if not isinstance(value, bool):
             raise InvalidPreferenceError(f"viewer.{key} must be a boolean")
         return value
@@ -246,6 +250,20 @@ def get_viewer_qmri_gapless() -> bool:
     return isinstance(viewer_cfg, dict) and viewer_cfg.get("qmri_gapless") is True
 
 
+def get_viewer_compare_gapless() -> bool:
+    """Whether arrays compared side by side touch, with no space between them."""
+    viewer_cfg = load_config().get("viewer", {})
+    return isinstance(viewer_cfg, dict) and viewer_cfg.get("compare_gapless") is True
+
+
+def get_viewer_remember_view() -> bool:
+    """Whether reopening a file brings back the view it was last left in."""
+    viewer_cfg = load_config().get("viewer", {})
+    val = viewer_cfg.get("remember_view") if isinstance(viewer_cfg, dict) else None
+    # `arrayview config set` stores the word "true"; the Preferences menu a boolean.
+    return val is True or (isinstance(val, str) and val.strip().lower() in ("true", "1", "yes", "on"))
+
+
 def get_viewer_ortho_layout() -> str | None:
     """Return the preferred initial ortho-view layout."""
     viewer_cfg = load_config().get("viewer", {})

arrayview/_diff.py

@@ -135,8 +135,13 @@ def _compute_diff(
     diff_mode,
     indices_a=None,
     indices_b=None,
+    stats_out=None,
 ):
-    """Return raw diff, display range, colormap, and optional separator mask."""
+    """Return raw diff, display range, colormap, and optional separator mask.
+
+    When *stats_out* is a dict it is filled with summary numbers for the
+    compared view (see `_diff_summary`).
+    """
     def _parse_indices(raw_indices):
         if raw_indices is None:
             return ()
@@ -170,6 +175,8 @@ def _compute_diff(
         a = _render_values(session_a, dim_x, dim_y, idx_a, complex_mode, log_scale)
         b = _render_values(session_b, dim_x, dim_y, idx_b, complex_mode, log_scale)
         b = _resize_values_like(b, a)
+    if stats_out is not None:
+        stats_out.update(_diff_summary(a, b, nan_mask))
     if diff_mode == 1:
         raw = a - b
         lo = float(np.nanpercentile(raw, 1))
@@ -192,6 +199,29 @@ def _compute_diff(
     return raw, vmin, vmax, colormap, nan_mask
 
 
+def _diff_summary(a: np.ndarray, b: np.ndarray, nan_mask: np.ndarray | None) -> dict[str, float]:
+    """RMS of A−B, largest |A−B|, and RMS of A−B relative to the RMS of A.
+
+    Pixels that are not finite in either array (or are mosaic separators)
+    are left out. Empty or all-zero inputs give NaN for what is undefined.
+    """
+    a = np.asarray(a, dtype=np.float64)
+    b = np.asarray(b, dtype=np.float64)
+    valid = np.isfinite(a) & np.isfinite(b)
+    if nan_mask is not None and nan_mask.shape == valid.shape:
+        valid &= ~nan_mask
+    if not valid.any():
+        return {"rmse": float("nan"), "max_abs": float("nan"), "rel": float("nan")}
+    d = a[valid] - b[valid]
+    rmse = float(np.sqrt(np.mean(d * d)))
+    rms_a = float(np.sqrt(np.mean(a[valid] ** 2)))
+    return {
+        "rmse": rmse,
+        "max_abs": float(np.max(np.abs(d))),
+        "rel": rmse / rms_a if rms_a > 0 else float("nan"),
+    }
+
+
 def _render_diff_rgba(
     raw: np.ndarray,
     vmin: float,

arrayview/_instance_registry.py

@@ -70,7 +70,10 @@ def runtime_directory() -> Path:
         return Path(base) / "arrayview"
     if hasattr(os, "getuid"):
         return Path(tempfile.gettempdir()) / f"arrayview-{os.getuid()}"
-    return Path(tempfile.gettempdir()) / f"arrayview-{os.getpid()}"
+    # Windows: no uid, but the temp folder is already per user. One shared
+    # name lets every command see the servers the others started.
+    user = "".join(c for c in os.environ.get("USERNAME", "") if c.isalnum() or c in "-_.")
+    return Path(tempfile.gettempdir()) / f"arrayview-{user or 'user'}"
 
 
 def process_start_identity(pid: int) -> str | None:

arrayview/_io.py

@@ -503,7 +503,7 @@ def read_gzip_file_parallel(filepath):
     """
     try:
         size = os.path.getsize(filepath)
-        fd = os.open(filepath, os.O_RDONLY)
+        fd = os.open(filepath, _O_RDONLY_BINARY)
     except OSError:
         return None
     buf = bytearray(size)
@@ -518,7 +518,7 @@ def read_gzip_file_parallel(filepath):
         pos = start
         try:
             while pos < stop:
-                n = os.preadv(fd, [view[pos:stop]], pos)
+                n = _pread_into(fd, view[pos:stop], pos)
                 if n <= 0:
                     raise OSError("unexpected end of file")
                 pos += n
@@ -624,10 +624,21 @@ def _mapped_slice_is_scattered(view) -> bool:
     return nbytes > 4 * view.nbytes and nbytes > _REGION_READ_CHUNK_BYTES
 
 
+# Windows has neither pread nor preadv: reads there seek and read under one
+# lock, so they are correct but no longer run in parallel.
+_SEEK_READ_LOCK = threading.Lock()
+_O_RDONLY_BINARY = os.O_RDONLY | getattr(os, "O_BINARY", 0)
+
+
 def _pread_into(fd, buf, offset):
     if hasattr(os, "preadv"):
         return os.preadv(fd, [buf], offset)
-    data = os.pread(fd, len(buf), offset)
+    if hasattr(os, "pread"):
+        data = os.pread(fd, len(buf), offset)
+    else:
+        with _SEEK_READ_LOCK:
+            os.lseek(fd, offset, os.SEEK_SET)
+            data = os.read(fd, len(buf))
     buf[: len(data)] = data
     return len(data)
 
@@ -646,7 +657,7 @@ def read_mapped_region(view, progress=None):
     mv = memoryview(buf)
     lock = threading.Lock()
     done = [0]
-    fd = os.open(filename, os.O_RDONLY)
+    fd = os.open(filename, _O_RDONLY_BINARY)
     try:
 
         def _read(start):
@@ -681,9 +692,9 @@ class _ScatteredRegionMixin:
     map of a 4D one. When a requested slice would be scattered across its
     region, the region is read in one go (see ``read_mapped_region``) and kept;
     every later slice of it, in any direction, is then served from memory.
-    Afterwards the case's other regions and the neighbouring case are read in
-    the background, so the next step — another map, the next patient — is
-    usually already there.
+    Whichever way the case is first viewed, its regions and the neighbouring
+    case's are then read in the background, so the next step — scrolling,
+    another map, a crossing view, the next patient — is usually already there.
     """
 
     def _init_region_cache(self):
@@ -793,6 +804,9 @@ class _ScatteredRegionMixin:
         if region is None:
             try:
                 if not _mapped_slice_is_scattered(mapped[tuple(spatial_key)]):
+                    # Cheap to read now, but the next scroll steps and any
+                    # switch to a crossing view are not: load the case anyway.
+                    self._schedule_region_warm(p_idx, m_idx, rest, spatial_key)
                     return None
                 view = self._region_view(mapped, rest)
                 if view.nbytes > self._region_cache_max_bytes // 2:
@@ -825,11 +839,6 @@ class _ScatteredRegionMixin:
         else:
             step = -1 if last is not None and last[0] > p_idx else 1
             neighbours = [(p_idx + step, m_idx), (p_idx - step, m_idx)]
-        # Which axes are on screen is all that carries over to another case;
-        # the indices along the others may not fit a differently-sized one.
-        probe = tuple(
-            slice(None) if isinstance(k, slice) else 0 for k in spatial_key[: min(3, len(spatial_key))]
-        )
         plan = [(p_idx, m_idx)] + [
             (p, m) for p, m in neighbours if 0 <= p < n_p and 0 <= m < n_m
         ]
@@ -845,7 +854,7 @@ class _ScatteredRegionMixin:
                     if self._file_matrix[p][m] is None:
                         continue
                     mapped = self._mapped_volume(p, m, self._get_volume(p, m))
-                    if mapped is None or not _mapped_slice_is_scattered(mapped[probe + first_rest]):
+                    if mapped is None:
                         continue
                     n_sp = min(3, mapped.ndim)
                     rests = list(np.ndindex(*mapped.shape[n_sp:])) or [()]
@@ -1106,11 +1115,12 @@ class _FileSeries:
 
     _av_lazy = True
 
-    def __init__(self, file_matrix, vol_shape, dtype, spatial_meta=None):
+    def __init__(self, file_matrix, vol_shape, dtype, spatial_meta=None, spacing_matrix=None):
         self._file_matrix = file_matrix
         self._vol_shape = tuple(vol_shape)
         self._dtype = np.dtype(dtype)
         self._spatial_meta = spatial_meta
+        self._spacing_matrix = spacing_matrix
         n_patients = len(file_matrix)
         n_modalities = len(file_matrix[0]) if file_matrix else 0
         if n_modalities <= 1:
@@ -1126,6 +1136,10 @@ class _FileSeries:
         )
         self._cache_lock = threading.Lock()
 
+    @property
+    def case_voxel_spacings(self):
+        return self._spacing_matrix
+
     @property
     def dtype(self):
         return self._dtype
@@ -1378,6 +1392,11 @@ def _is_nifti_path(filepath):
     return filepath.endswith(".nii") or filepath.endswith(".nii.gz")
 
 
+def _is_gipl_path(filepath):
+    """True if *filepath* ends with .gipl or .gipl.gz."""
+    return filepath.lower().endswith((".gipl", ".gipl.gz"))
+
+
 def _get_ext(filepath):
     """Return the extension of *filepath*, normalising .nii.gz and .zarr.zip."""
     lower = filepath.lower()
@@ -1596,11 +1615,15 @@ def _series_from_file_matrix(
         return series, spatial_meta
 
     spatial_shapes = []
+    # GIPL headers carry a voxel size; use it when every file has one.
+    gipl_metas = [] if all(_is_gipl_path(path) for path in all_paths) else None
     for fpath in all_paths:
         arr = load_data(fpath)
         shape = arr.shape
         dtype = arr.dtype
         spatial_shapes.append(shape)
+        if gipl_metas is not None:
+            gipl_metas.append(_gipl_spatial_meta(fpath, arr))
         if ref_shape is None:
             ref_shape = shape
             ref_dtype = dtype
@@ -1616,30 +1639,47 @@ def _series_from_file_matrix(
             )
         if scan_progress is not None:
             scan_progress(scan_label, fpath)
+    spacing_matrix = None
+    if gipl_metas and all(meta is not None for meta in gipl_metas):
+        spatial_meta = gipl_metas[0]
+        spacing_matrix = []
     shape_matrix = []
     pos = 0
     for row in file_matrix:
         row_shapes = []
+        row_spacings = []
         for path in row:
             if path is None:
                 row_shapes.append(ref_shape)
+                if spacing_matrix is not None:
+                    row_spacings.append(gipl_metas[0]["voxel_sizes"])
             else:
                 row_shapes.append(spatial_shapes[pos])
+                if spacing_matrix is not None:
+                    row_spacings.append(gipl_metas[pos]["voxel_sizes"])
                 pos += 1
         shape_matrix.append(row_shapes)
+        if spacing_matrix is not None:
+            spacing_matrix.append(row_spacings)
     shapes_differ = any(shape != ref_shape for shape in spatial_shapes)
     if stack == "dense" and shapes_differ:
         raise ValueError("Dense stacking requires every file to have the same shape.")
     if stack == "ragged" or shapes_differ:
-        series = _RaggedFileSeries(file_matrix, shape_matrix, ref_dtype, spatial_meta=None)
+        series = _RaggedFileSeries(
+            file_matrix, shape_matrix, ref_dtype,
+            spatial_meta=spatial_meta, spacing_matrix=spacing_matrix,
+        )
     else:
-        series = _FileSeries(file_matrix, ref_shape, ref_dtype, spatial_meta=None)
+        series = _FileSeries(
+            file_matrix, ref_shape, ref_dtype,
+            spatial_meta=spatial_meta, spacing_matrix=spacing_matrix,
+        )
     if load == "eager":
         for p, row in enumerate(file_matrix):
             for m, path in enumerate(row):
                 if path is not None:
                     series._get_volume(p, m)
-    return series, None
+    return series, spatial_meta
 
 
 def _collection_scan_workers():
@@ -2182,7 +2222,7 @@ def prefetch_slice_pages(mapped, filepath, dims, index, progress=None) -> bool:
         return False
 
     try:
-        fd = os.open(filepath, os.O_RDONLY)
+        fd = os.open(filepath, _O_RDONLY_BINARY)
     except OSError:
         return False
     try:
@@ -2292,13 +2332,13 @@ def read_npy_into_ram(mapped, progress=None):
     lock = threading.Lock()
     done = [0]
 
-    fd = os.open(mapped.filename, os.O_RDONLY)
+    fd = os.open(mapped.filename, _O_RDONLY_BINARY)
     try:
         def _read(start):
             stop = min(start + _NPY_READ_CHUNK_BYTES, total)
             pos = start
             while pos < stop:
-                n = os.preadv(fd, [dst[pos:stop]], offset + pos)
+                n = _pread_into(fd, dst[pos:stop], offset + pos)
                 if n <= 0:
                     raise OSError(f"unexpected end of file reading {mapped.filename!r}")
                 pos += n
@@ -2350,6 +2390,9 @@ def load_data_with_meta(filepath, key=None, *, load="lazy", stack="auto", select
         return _load_file_series(filepath, load=load, stack=stack)
     if filepath.endswith(".nii") or filepath.endswith(".nii.gz"):
         return _load_nifti_with_meta(filepath)
+    if filepath.lower().endswith((".gipl", ".gipl.gz")):
+        arr = _load_gipl(filepath)
+        return arr, _gipl_spatial_meta(filepath, arr)
     return load_data(
         filepath, key=key, progress=progress, fast_first_frame=fast_first_frame
     ), None
@@ -2546,6 +2589,31 @@ def _load_gipl(filepath):
     return np.ascontiguousarray(arr)
 
 
+def _gipl_spatial_meta(filepath, arr):
+    """Voxel sizes from a GIPL header, so the viewer shows true proportions.
+
+    GIPL stores no orientation, so axis labels stay empty. Returns None when
+    the header has no usable voxel sizes.
+    """
+    import gzip
+
+    opener = gzip.open if filepath.lower().endswith(".gz") else open
+    with opener(filepath, "rb") as f:
+        header = f.read(_GIPL_HEADER_SIZE)
+    pixdim = np.frombuffer(header, ">f4", count=4, offset=10).astype(float)
+    n = min(arr.ndim, 3)
+    voxel_sizes = tuple(float(v) for v in pixdim[:n])
+    if not all(np.isfinite(v) and v > 0 for v in voxel_sizes):
+        return None
+    return {
+        "voxel_sizes": voxel_sizes,
+        "axis_labels": (),
+        "is_oblique": False,
+        "is_canonical": True,
+        "spatial_shape": tuple(int(v) for v in arr.shape[:n]),
+    }
+
+
 def _tensor_to_numpy(obj, source="object"):
     """Convert a tensor-like object (PyTorch, etc.) to a numpy array."""
     if isinstance(obj, np.ndarray):

arrayview/_launch_trace.py

@@ -151,7 +151,8 @@ def emit_launch_event(event: str, **attrs: object) -> None:
                 encoded = (json.dumps(payload, separators=(",", ":")) + "\n").encode()
             fd = os.open(_path, os.O_APPEND | os.O_CREAT | os.O_WRONLY, 0o600)
             try:
-                os.fchmod(fd, 0o600)
+                if hasattr(os, "fchmod"):  # Windows has none before Python 3.13
+                    os.fchmod(fd, 0o600)
                 os.write(fd, encoded)
             finally:
                 os.close(fd)

arrayview/_launcher.py

@@ -74,10 +74,15 @@ def _detached_child_kwargs() -> dict[str, object]:
     control event raised for that group reaches *every* process attached to it,
     so a child being shut down can deliver a KeyboardInterrupt to the process
     that spawned it — under pytest, to the test runner itself.  Both branches
-    state the same intent: the child gets its own group.
+    state the same intent: the child gets its own group.  On Windows it also
+    gets no console of its own: started from a notebook or a GUI app, a
+    background server would otherwise pop up an empty black console window.
     """
     if sys.platform == "win32":
-        return {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
+        return {
+            "creationflags": subprocess.CREATE_NEW_PROCESS_GROUP
+            | subprocess.CREATE_NO_WINDOW
+        }
     return {"start_new_session": True}
 
 
@@ -391,6 +396,19 @@ def _build_inline_shell_html(url: str, shell_port: int) -> str | None:
         return None
 
 
+def _set_listen_reuse(sock: "socket.socket") -> None:
+    """Let a restarted server rebind its port at once, without sharing it.
+
+    On Windows ``SO_REUSEADDR`` lets a second process bind a port another
+    listener already holds, so two servers could answer on one port; the
+    exclusive option there is what the POSIX flag means elsewhere.
+    """
+    if sys.platform == "win32":
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+    else:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+
 def _make_loopback_socket(port: int) -> "socket.socket":
     """Bind a single TCP listener on the same loopback host the viewer URLs use."""
     for family, socktype, proto, _, sockaddr in socket.getaddrinfo(
@@ -401,7 +419,7 @@ def _make_loopback_socket(port: int) -> "socket.socket":
         sock = None
         try:
             sock = socket.socket(family, socktype, proto)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            _set_listen_reuse(sock)
             sock.bind(sockaddr)
             sock.listen(128)
             sock.set_inheritable(True)
@@ -439,7 +457,7 @@ def _make_loopback_sockets(port: int) -> list["socket.socket"]:
         sock = None
         try:
             sock = socket.socket(family, socktype, proto)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            _set_listen_reuse(sock)
             # On Linux, binding ::1 first then 127.0.0.1 on the same port is
             # fine (different addresses). IPV6_V6ONLY stays default (off on
             # Linux) which is harmless since we bind explicit addresses.
@@ -3539,11 +3557,12 @@ def view(
     vmax: float | None = None,
     log: bool = False,
     complex: str | None = None,
+    voxel_size=None,
 ):
     """
     Launch the viewer. Does not block the main Python process.
 
-    Accepts one to four arrays::
+    Accepts one to six arrays (the same limit as the command line)::
 
         handle = arrayview.view(a)
         ha, hb = arrayview.view(a, b)
@@ -3588,6 +3607,10 @@ def view(
     ``"imag"`` (``"mag"`` shows the absolute value of real data). Pressing
     ``E`` in the viewer copies the current view as such a call.
 
+    ``voxel_size`` — physical size of one step along each dimension, e.g.
+    ``(1, 1, 2)`` for 1 mm pixels and 2 mm slices. Slices then show their
+    true proportions. Leading dimensions only; later ones keep size 1.
+
     Returns a ``ViewHandle`` for a single array, or a tuple of ``ViewHandle``
     objects for multiple arrays (one per array). In inline/Jupyter mode with
     multiple arrays, the IFrame is displayed automatically and a uniform tuple
@@ -3601,9 +3624,14 @@ def view(
 
     _initial_view = _session_mod.initial_view_spec(
         mode=mode, dims=dims, index=index, cmap=cmap, vmin=vmin, vmax=vmax, log=log,
-        complex=complex,
+        complex=complex, voxel_size=voxel_size,
     )
     _code_name = _caller_variable_name(arrays[0]) if arrays else None
+    # Several arrays side by side need telling apart; the caller's variable
+    # names do that better than identical "Array (shape)" labels.
+    _var_names = (
+        [_caller_variable_name(arr) for arr in arrays] if len(arrays) > 1 else []
+    )
 
     height = _normalize_inline_height(height)
     _inline_mode_heights = _normalize_inline_mode_heights(mode_heights)
@@ -3612,8 +3640,8 @@ def view(
     n_arrays = len(arrays)
     if n_arrays == 0:
         raise ValueError("view() requires at least one array.")
-    if n_arrays > 4:
-        raise ValueError(f"view() accepts at most 4 arrays, got {n_arrays}.")
+    if n_arrays > 6:
+        raise ValueError(f"view() accepts at most 6 arrays, got {n_arrays}.")
 
     # --- Normalise per-array kwargs (name, rgb) ---
     if isinstance(name, list):
@@ -3664,6 +3692,8 @@ def view(
     arrays = tuple(_convert_array(arr) for arr in arrays)
 
     # --- Apply name defaults after conversion (shape is available now) ---
+    if len(set(filter(None, _var_names))) == n_arrays:
+        names = [names[i] if names[i] is not None else _var_names[i] for i in range(n_arrays)]
     names = [
         (f"Array {getattr(arrays[i], 'shape', '?')}" if names[i] is None else names[i])
         for i in range(n_arrays)
@@ -3680,6 +3710,13 @@ def view(
                 f"index has {len(_initial_view['index'])} entries but the array "
                 f"has {_ndim} dimensions"
             )
+    if _initial_view and "voxel_size" in _initial_view:
+        _ndim = len(getattr(data, "shape", ()))
+        if len(_initial_view["voxel_size"]) > _ndim:
+            raise ValueError(
+                f"voxel_size has {len(_initial_view['voxel_size'])} entries but the "
+                f"array has {_ndim} dimensions"
+            )
 
     # --- Normalise string window modes ---
     _raw_window = window
@@ -5633,8 +5670,26 @@ def _handle_management_command(argv: list[str]) -> bool:
     return True
 
 
+def _replace_unprintable_output() -> None:
+    """Keep messages with arrows or ticks from crashing a Windows console.
+
+    Output redirected to a file or pipe on Windows uses an old code page that
+    cannot encode such characters, so printing them raised instead of showing
+    the message. The servers this command starts inherit the same setting.
+    """
+    if os.name != "nt":
+        return
+    os.environ.setdefault("PYTHONIOENCODING", ":replace")
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+
 def arrayview():
     """Command Line Interface Entry Point."""
+    _replace_unprintable_output()
     # Handle "arrayview config ..." subcommand before argparse
     if len(sys.argv) > 1 and sys.argv[1] == "config":
         _handle_config_command(sys.argv[2:])

arrayview/_platform.py

@@ -452,8 +452,17 @@ def _has_vscode_window_registration() -> bool:
 def _process_is_alive(pid: object) -> bool:
     try:
         numeric_pid = int(pid)
+    except (TypeError, ValueError):
+        return False
+    if os.name == "nt":
+        # Signal 0 is CTRL_C_EVENT on Windows: os.kill would try to interrupt
+        # a console process group rather than test whether the pid exists.
+        from arrayview._instance_registry import process_start_identity
+
+        return process_start_identity(numeric_pid) is not None
+    try:
         os.kill(numeric_pid, 0)
-    except (OSError, TypeError, ValueError):
+    except OSError:
         return False
     if sys.platform.startswith("linux"):
         try:

arrayview/_routes_export.py

@@ -1,5 +1,6 @@
 import asyncio
 import io
+import re
 
 import numpy as np
 from fastapi import Body, Depends, Request, Response
@@ -8,6 +9,12 @@ from fastapi.responses import JSONResponse
 from arrayview._render import render_rgba
 
 
+def _safe_filename(name: str, default: str) -> str:
+    """A bare file name every OS accepts: no folders, no reserved characters."""
+    name = re.sub(r'[\\/:*?"<>|\x00-\x1f\s]+', "_", str(name or "")).strip("._")
+    return name or default
+
+
 def register_export_routes(app, *, get_session_or_404, pil_image) -> None:
     @app.get("/export_array/{sid}")
     def export_array(
@@ -20,8 +27,7 @@ def register_export_routes(app, *, get_session_or_404, pil_image) -> None:
         buf = io.BytesIO()
         np.save(buf, data)
         buf.seek(0)
-        name_stem = (session.name or "array").replace(" ", "_").replace("/", "_")
-        filename = f"{name_stem}.npy"
+        filename = f"{_safe_filename(session.name, 'array')}.npy"
         if save_to_downloads:
             import pathlib
 
@@ -39,7 +45,7 @@ def register_export_routes(app, *, get_session_or_404, pil_image) -> None:
     async def save_file(request: Request):
         """Save a client-generated file to the Downloads folder."""
         body = await request.json()
-        filename = body.get("filename", "arrayview_export")
+        filename = _safe_filename(body.get("filename"), "arrayview_export")
         data_b64 = body.get("data", "")
         if "," in data_b64:
             data_b64 = data_b64.split(",", 1)[1]

arrayview/_routes_loading.py

@@ -618,6 +618,18 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
         )
         return {"sid": session.sid, "name": name, "notified": notified}
 
+    @app.post("/reveal/{sid}")
+    async def reveal_session_tab(sid: str):
+        """Bring the VS Code browser tab already showing *sid* forward."""
+        from arrayview._routes_websocket import viewer_tab_reveal_target
+        from arrayview._vscode_signal import _request_vscode_tab_reveal
+
+        target = viewer_tab_reveal_target(sid)
+        if target is None:
+            return {"sid": sid, "revealed": False}
+        revealed = await asyncio.to_thread(_request_vscode_tab_reveal, *target)
+        return {"sid": sid, "revealed": revealed}
+
     @app.post("/release/{sid}")
     def release_viewer_session(sid: str, request: Request):
         """Release a session when its owning viewer tab/window closes."""

arrayview/_routes_preferences.py

@@ -68,6 +68,28 @@ def register_preferences_routes(app) -> None:
             return JSONResponse({"error": "session_not_found"}, status_code=404)
         return _response_payload()
 
+    @app.post("/view-memory/{sid}")
+    async def view_memory_post(sid: str, request: Request):
+        """Store the view a file was left in (Preferences → Reopen where you left off)."""
+        session = SESSIONS.get(sid)
+        if session is None:
+            return JSONResponse({"error": "session_not_found"}, status_code=404)
+        from arrayview._config import get_viewer_remember_view
+        from arrayview._view_memory import remember_view
+
+        if not get_viewer_remember_view():
+            return {"saved": False}
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse({"error": "invalid_json"}, status_code=400)
+        view = body.get("view") if isinstance(body, dict) else None
+        try:
+            saved = remember_view(session, view)
+        except OSError:
+            saved = False
+        return {"saved": saved}
+
     @app.patch("/preferences/{sid}")
     async def preferences_patch(sid: str, request: Request):
         if SESSIONS.get(sid) is None: