arrayview 0.47.4__py3-none-any.whl → 0.48.0__py3-none-any.whl

arrayview/_io.py

@@ -3,11 +3,14 @@
 from __future__ import annotations
 
 import fnmatch
+import functools
 import gzip
 import glob
 import os
 import re
+import sys
 import threading
+import zlib
 from concurrent.futures import ThreadPoolExecutor
 from collections import OrderedDict
 
@@ -114,6 +117,23 @@ def list_npz_keys(filepath):
     return keys
 
 
+# MATLAB class -> dtype scipy.io.loadmat returns for it (complex is not
+# visible in the header; the picker only shows this when several arrays exist).
+_MAT_CLASS_DTYPES = {
+    "double": "float64",
+    "single": "float32",
+    "int8": "int8",
+    "uint8": "uint8",
+    "int16": "int16",
+    "uint16": "uint16",
+    "int32": "int32",
+    "uint32": "uint32",
+    "int64": "int64",
+    "uint64": "uint64",
+    "logical": "uint8",
+}
+
+
 def list_mat_keys(filepath):
     """Return [{key, shape, dtype}] for each array in a .mat file.
 
@@ -123,6 +143,17 @@ def list_mat_keys(filepath):
     try:
         import scipy.io
 
+        # The headers alone settle the common single-array file, whose array
+        # is loaded right after this anyway; reading it here too doubled the
+        # wait on network shares.
+        numeric = [
+            (name, shape, cls)
+            for name, shape, cls in scipy.io.whosmat(filepath)
+            if cls in _MAT_CLASS_DTYPES
+        ]
+        if len(numeric) == 1:
+            name, shape, cls = numeric[0]
+            return [{"key": name, "shape": list(shape), "dtype": _MAT_CLASS_DTYPES[cls]}]
         mat = scipy.io.loadmat(filepath)
         keys = []
         for k, v in mat.items():
@@ -435,12 +466,100 @@ def _load_nifti_with_meta(filepath):
     random-access, but it is no longer silently reordered.
     """
     img, meta = _nifti_header_with_meta(filepath, native=True)
-    arr = (
-        img.dataobj
-        if filepath.endswith(".nii")
-        else _nifti_display_array(img.dataobj)
-    )
-    return arr, meta
+    if filepath.endswith(".nii"):
+        return img.dataobj, meta
+    source = img
+    if _nifti_voxel_bytes(img) <= npy_eager_limit():
+        raw = read_gzip_file_parallel(filepath)
+        if raw is not None:
+            try:
+                source = type(img).from_bytes(raw)
+            except Exception:
+                source = img
+    return _nifti_display_array(source.dataobj), meta
+
+
+def _nifti_voxel_bytes(img) -> int:
+    try:
+        return int(np.prod(img.shape)) * np.dtype(img.get_data_dtype()).itemsize
+    except Exception:
+        return 1 << 62
+
+
+_GZIP_READ_CHUNK_BYTES = 8 << 20
+_GZIP_READ_THREADS = 8
+
+
+def read_gzip_file_parallel(filepath):
+    """Decompress a whole .gz file, reading it with several reads in flight.
+
+    A gzip stream can only be decoded front to back, so the decode is one
+    thread; but the bytes can arrive out of order. Reading 8 MB chunks in
+    parallel and decoding each as soon as its turn comes overlaps the two, so
+    on an SMB share the wait is close to the parallel read alone (~1.3 s for a
+    110 MB file) instead of a single slow reader followed by the decode.
+    Handles multi-member files. Returns None on any read or decode error so
+    the caller can fall back to its ordinary reader.
+    """
+    try:
+        size = os.path.getsize(filepath)
+        fd = os.open(filepath, os.O_RDONLY)
+    except OSError:
+        return None
+    buf = bytearray(size)
+    view = memoryview(buf)
+    starts = list(range(0, size, _GZIP_READ_CHUNK_BYTES))
+    ready = [threading.Event() for _ in starts]
+    failed = []
+
+    def _read(i):
+        start = starts[i]
+        stop = min(start + _GZIP_READ_CHUNK_BYTES, size)
+        pos = start
+        try:
+            while pos < stop:
+                n = os.preadv(fd, [view[pos:stop]], pos)
+                if n <= 0:
+                    raise OSError("unexpected end of file")
+                pos += n
+        except Exception as exc:  # noqa: BLE001 - reported to the decoder
+            failed.append(exc)
+        finally:
+            ready[i].set()
+
+    out = []
+    try:
+        with ThreadPoolExecutor(
+            max_workers=max(1, min(_GZIP_READ_THREADS, len(starts))),
+            thread_name_prefix="arrayview-gzip-read",
+        ) as pool:
+            for i in range(len(starts)):
+                pool.submit(_read, i)
+            decoder = zlib.decompressobj(wbits=31)
+            fed = False
+            for i, start in enumerate(starts):
+                ready[i].wait()
+                if failed:
+                    return None
+                chunk = view[start:min(start + _GZIP_READ_CHUNK_BYTES, size)]
+                while chunk:
+                    fed = True
+                    out.append(decoder.decompress(chunk))
+                    if not decoder.eof:
+                        break
+                    # End of one gzip member: any rest starts the next one.
+                    chunk = decoder.unused_data
+                    decoder = zlib.decompressobj(wbits=31)
+                    fed = False
+            if fed and not decoder.eof:
+                return None  # truncated: let the ordinary reader report it
+            if not out:
+                return None
+    except (zlib.error, OSError):
+        return None
+    finally:
+        os.close(fd)
+    return b"".join(out)
 
 
 # ---------------------------------------------------------------------------
@@ -1601,41 +1720,238 @@ def mmap_first_frame_is_cheap(arr, total_bytes) -> bool:
     return runs <= max_runs and faulted <= fraction * total_bytes
 
 
-def _read_npy_reporting_progress(mapped, progress):
-    """Copy a memmapped .npy into RAM in chunks, saying how far along it is.
+# Fetching the first frame's pages one by one beats reading the whole file
+# only on a local disk: on an SMB share the same 65k small reads of a 1.6 GB
+# file took 11 s against 0.7 s locally.
+_FIRST_FRAME_PREFETCH_MAX_PAGES = 1 << 17
+_FIRST_FRAME_PREFETCH_THREADS = 16
 
-    For a large array this read is the whole wait between a click and the
-    first frame — 9 s for a 1.6 GB file on a cold cache — and ``np.load``
-    reports nothing while it runs.  Copying in pieces costs the same reads
-    and makes the wait explainable.
 
-    The flat view follows the array's own memory order, so the copy stays
-    sequential whether the file is C- or Fortran-ordered.  A .npy memmap is
-    always contiguous in one of the two, so both reshapes are views.
+def _on_known_local_disk(filepath) -> bool:
+    if not sys.platform.startswith("linux"):
+        return False
+    try:
+        from ._source_safety import _KNOWN_LOCAL_STAGE_FILESYSTEMS, mount_for_path
+
+        mount = mount_for_path(os.path.realpath(filepath))
+    except Exception:
+        return False
+    return mount is not None and mount.filesystem in _KNOWN_LOCAL_STAGE_FILESYSTEMS
+
+
+def _viewer_start_index(shape, dims):
+    """The slice the viewer opens on; mirrors its ``_initialIndices``."""
+    ref = max(shape[dims[0]], shape[dims[1]])
+    return tuple(
+        size // 2 if (i in dims or size >= 0.25 * ref) else 0
+        for i, size in enumerate(shape)
+    )
+
+
+def prefetch_first_frame_pages(mapped, filepath, progress=None) -> bool:
+    """Pull just the pages of the viewer's first frame into memory, in parallel.
+
+    When the first frame is one element per page across the whole file (a
+    C-order array viewed along its leading axes), reading the file first made
+    a 1.6 GB array wait 3-4 s cold for its picture. Fetching only the pages the
+    frame touches, many at a time, takes ~0.7 s; the memmap then renders the
+    frame from memory while the full read continues in the background.
+
+    Returns False, having read nothing, when this would not pay off: not a
+    known local disk, the viewer would start elsewhere, or too many pages.
     """
-    order = "F" if mapped.flags.f_contiguous and not mapped.flags.c_contiguous else "C"
-    out = np.empty(mapped.shape, dtype=mapped.dtype, order=order)
-    src = mapped.reshape(-1, order="A")
-    dst = out.reshape(-1, order="A")
-    total = int(src.shape[0])
-    itemsize = int(mapped.dtype.itemsize)
-    # ~200 updates: smooth enough to read as motion, coarse enough that the
-    # per-chunk overhead stays lost in the read itself.
-    step = max(1, total // 200)
-    done = 0
-    while done < total:
-        end = min(done + step, total)
-        dst[done:end] = src[done:end]
-        done = end
+    from ._session import _default_start_dims_for_data, _viewer_start_dims_for_shape
+
+    shape = tuple(int(s) for s in mapped.shape)
+    if len(shape) < 3 or _default_start_dims_for_data(mapped) is not None:
+        return False
+    dims = _viewer_start_dims_for_shape(shape)
+    if dims is None:
+        return False
+    return prefetch_slice_pages(
+        mapped, filepath, dims, _viewer_start_index(shape, dims), progress=progress
+    )
+
+
+@functools.lru_cache(maxsize=64)
+def _on_known_local_disk_cached(filepath) -> bool:
+    return _on_known_local_disk(filepath)
+
+
+def prefetch_slice_pages(mapped, filepath, dims, index, progress=None) -> bool:
+    """Fetch the pages of one 2-D slice of a memmap with parallel reads.
+
+    Faulting such a slice in through the map is the slow way: readahead drags
+    in the pages between the wanted elements (6 s for one slice of a 1.6 GB
+    C-order file), and without readahead each page is its own wait (7.7 s).
+    Many small reads in flight take ~0.7 s on a local disk. Only worth it when
+    the slice is scattered one element per page; returns False otherwise, or
+    off a known local disk, having read nothing. *progress*, if given, is
+    called with ``(pages_done, pages_total)`` as batches of pages land — this
+    fetch is the whole wait, so it is what a progress line should follow.
+    """
+    shape = tuple(int(s) for s in mapped.shape)
+    strides = tuple(int(s) for s in mapped.strides)
+    runs, _faulted = first_frame_fault_cost(
+        shape, mapped.dtype.itemsize, strides, dims, mapped.nbytes
+    )
+    if runs <= 1024 or not _on_known_local_disk_cached(str(filepath)):
+        return False
+    base = int(mapped.offset) + sum(
+        int(index[i]) * strides[i] for i in range(len(shape)) if i not in dims
+    )
+    rows = np.arange(shape[dims[0]], dtype=np.int64) * strides[dims[0]]
+    cols = np.arange(shape[dims[1]], dtype=np.int64) * strides[dims[1]]
+    starts = (base + rows[:, None] + cols[None, :]).ravel()
+    ends = starts + (mapped.dtype.itemsize - 1)
+    pages = np.unique(np.concatenate((starts, ends)) // _MMAP_PAGE_BYTES)
+    if pages.size > _FIRST_FRAME_PREFETCH_MAX_PAGES:
+        return False
+
+    try:
+        fd = os.open(filepath, os.O_RDONLY)
+    except OSError:
+        return False
+    try:
+        # Only the pages asked for: readahead around each would multiply the I/O.
         try:
-            progress(done * itemsize, total * itemsize)
-        except Exception:
+            os.posix_fadvise(fd, 0, 0, os.POSIX_FADV_RANDOM)
+        except (AttributeError, OSError):
             pass
+        offsets = (pages * _MMAP_PAGE_BYTES).tolist()
+        total = len(offsets)
+        n = _FIRST_FRAME_PREFETCH_THREADS
+        # Interleaved batches: each one spans the file, so batches finish at
+        # a steady rate and the progress they report moves evenly.
+        batches = max(n, 64)
+        lock = threading.Lock()
+        done = [0]
+
+        def _warm(part):
+            for offset in part:
+                os.pread(fd, _MMAP_PAGE_BYTES, offset)
+            if progress is not None:
+                with lock:
+                    done[0] += len(part)
+                    finished = done[0]
+                try:
+                    progress(finished, total)
+                except Exception:
+                    pass
+
+        with ThreadPoolExecutor(max_workers=n, thread_name_prefix="arrayview-slice-prefetch") as pool:
+            for _ in pool.map(_warm, [offsets[k::batches] for k in range(batches)]):
+                pass
+    except OSError:
+        return False
+    finally:
+        os.close(fd)
+    return True
+
+
+def _h5_contiguous_memmap(filepath, ds):
+    """Map an HDF5 dataset straight from the file, or None if it can't be.
+
+    MATLAB v7.3 writes large arrays as one uncompressed contiguous block, so
+    the same first-frame shortcut as .npy applies: the viewer can draw a slice
+    without reading the whole file first. Chunked, compressed or filtered
+    datasets are not one block and return None.
+    """
+    try:
+        if ds.chunks is not None or ds.compression is not None:
+            return None
+        offset = ds.id.get_offset()
+        if offset is None:
+            return None
+        dtype = ds.dtype
+        if dtype.names:
+            # MATLAB complex: {real, imag} of one float type, packed, which is
+            # byte-for-byte numpy's complex layout.
+            if set(dtype.names) != {"real", "imag"}:
+                return None
+            real_t, real_off = dtype.fields["real"][:2]
+            imag_t, imag_off = dtype.fields["imag"][:2]
+            # Only single precision: the eager path downcasts complex to
+            # complex64, and the mapped array must come out the same.
+            if (
+                real_t != imag_t
+                or real_t.kind != "f"
+                or real_t.itemsize != 4
+                or real_off != 0
+                or imag_off != real_t.itemsize
+                or dtype.itemsize != 2 * real_t.itemsize
+            ):
+                return None
+            dtype = np.dtype(f"{real_t.byteorder}c{2 * real_t.itemsize}")
+        elif dtype.kind not in "biuf":
+            return None
+        if offset + int(np.prod(ds.shape)) * dtype.itemsize > os.path.getsize(filepath):
+            return None
+        return np.memmap(filepath, dtype=dtype, mode="r", offset=offset, shape=ds.shape)
+    except Exception:
+        return None
+
+
+_NPY_READ_CHUNK_BYTES = 8 << 20
+_NPY_READ_THREADS = 8
+
+
+def read_npy_into_ram(mapped, progress=None):
+    """Read a memmapped .npy into RAM with several reads in flight.
+
+    For a large array this read is the whole wait between a click and the
+    first frame. One sequential reader leaves a network share mostly idle:
+    on SMB a 220 MB file took 5.5 s that way and ~3 s with eight readers.
+    Local disks are not slowed by it.
+
+    The reads land directly in the result's memory, in the file's own byte
+    order: a .npy body is contiguous in either C or Fortran order, so the
+    result is allocated in that order and filled byte for byte.  *progress*,
+    if given, is called with ``(done_bytes, total_bytes)`` as chunks land.
+    """
+    order = "F" if mapped.flags.f_contiguous and not mapped.flags.c_contiguous else "C"
+    out = np.empty(mapped.shape, dtype=mapped.dtype, order=order)
+    total = int(out.nbytes)
+    if total == 0:
+        return out
+    dst = memoryview(out.reshape(-1, order="A").view(np.uint8))
+    offset = int(mapped.offset)
+    lock = threading.Lock()
+    done = [0]
+
+    fd = os.open(mapped.filename, os.O_RDONLY)
+    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)
+                if n <= 0:
+                    raise OSError(f"unexpected end of file reading {mapped.filename!r}")
+                pos += n
+            if progress is not None:
+                with lock:
+                    done[0] += stop - start
+                    finished = done[0]
+                try:
+                    progress(finished, total)
+                except Exception:
+                    pass
+
+        starts = range(0, total, _NPY_READ_CHUNK_BYTES)
+        with ThreadPoolExecutor(
+            max_workers=min(_NPY_READ_THREADS, len(starts)),
+            thread_name_prefix="arrayview-npy-read",
+        ) as pool:
+            for _ in pool.map(_read, starts):
+                pass
+    finally:
+        os.close(fd)
     return out
 
 
 def load_data_with_meta(filepath, key=None, *, load="lazy", stack="auto", select=None,
-                        progress=None):
+                        progress=None, fast_first_frame=False):
     """Like load_data but also returns spatial metadata for NIfTI files.
 
     Returns (array, meta_or_None). meta is None for non-NIfTI formats.
@@ -1661,10 +1977,12 @@ 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)
-    return load_data(filepath, key=key, progress=progress), None
+    return load_data(
+        filepath, key=key, progress=progress, fast_first_frame=fast_first_frame
+    ), None
 
 
-def load_data(filepath, key=None, *, progress=None):
+def load_data(filepath, key=None, *, progress=None, fast_first_frame=False):
     if filepath.lower().endswith(".dcm"):
         from ._dicom import load_dicom_series
 
@@ -1685,16 +2003,19 @@ def load_data(filepath, key=None, *, progress=None):
         # read runs behind it (see mmap_first_frame_is_cheap) or the viewer shows
         # a spinner until the read completes.
         size = os.path.getsize(filepath)
-        if size >= npy_eager_limit():
-            return np.load(filepath, mmap_mode="r")
         mapped = np.load(filepath, mmap_mode="r")
+        if size >= npy_eager_limit():
+            if fast_first_frame:
+                prefetch_first_frame_pages(mapped, filepath, progress)
+            return mapped
         if mmap_first_frame_is_cheap(mapped, size):
             # Session creation upgrades this to an in-RAM array in the background.
             return mapped
-        if progress is not None:
-            return _read_npy_reporting_progress(mapped, progress)
-        del mapped
-        return np.load(filepath)
+        if fast_first_frame and prefetch_first_frame_pages(mapped, filepath, progress):
+            # Same as above: the first frame's pages are already in memory, and
+            # the full read runs behind the viewer.
+            return mapped
+        return read_npy_into_ram(mapped, progress)
     elif filepath.endswith(".npz"):
         npz = np.load(filepath)
         try:
@@ -1766,10 +2087,13 @@ def load_data(filepath, key=None, *, progress=None):
 
             f = h5py.File(filepath, "r")
             arrays = {k: f[k] for k in f.keys() if _is_viewable_h5_dataset(f[k])}
-            if key is not None:
-                return _fix_mat_complex(np.array(arrays[key]))
-            if len(arrays) == 1:
-                return _fix_mat_complex(np.array(next(iter(arrays.values()))))
+            if key is not None or len(arrays) == 1:
+                ds = arrays[key] if key is not None else next(iter(arrays.values()))
+                mapped = _h5_contiguous_memmap(filepath, ds)
+                if mapped is not None and mmap_first_frame_is_cheap(mapped, mapped.nbytes):
+                    # Session creation upgrades this to an in-RAM array in the background.
+                    return mapped
+                return _fix_mat_complex(np.array(ds))
             raise ValueError(
                 f".mat (v7.3) file contains multiple datasets: {list(arrays.keys())}. "
                 "Select one in the viewer or pass a key."

arrayview/_launcher.py

@@ -4853,6 +4853,7 @@ def _serve_daemon(
                     key=_load_key,
                     load=collection_load,
                     stack=collection_stack,
+                    fast_first_frame=True,
                 )
                 dir_overlay_items = None
                 collection_spatial_ndim = None

arrayview/_render.py

@@ -207,7 +207,19 @@ def extract_slice(session, dim_x, dim_y, idx_list, progress=None):
     # already served from cache.
     if progress is None:
         progress = getattr(session, 'progress_sink', None)
-    extracted = _extract_with_progress(session.data, slicer, progress)
+    data = session.data
+    if isinstance(data, np.memmap) and data.filename:
+        # A slice scattered one element per page reads far faster as many
+        # parallel small reads than by faulting through the map (local disks).
+        from ._io import prefetch_slice_pages
+
+        try:
+            prefetch_slice_pages(
+                data, data.filename, (dim_x, dim_y), idx_list, progress=progress
+            )
+        except Exception:
+            pass
+    extracted = _extract_with_progress(data, slicer, progress)
     if dim_x < dim_y:
         extracted = extracted.T
     # scipy.io.loadmat returns complex arrays as structured dtypes; convert here.

arrayview/_routes_loading.py

@@ -341,6 +341,7 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                         filepath,
                         select=body.get("select"),
                         progress=_report_read_progress,
+                        fast_first_frame=True,
                     )
                     session = Session(data, filepath=filepath, name=name)
                     session.sid = sid

arrayview/_routes_query.py

@@ -247,6 +247,7 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
                         request_id=request_id,
                         navigation_attempt=journal.get("navigation_attempt"),
                         phase=phase,
+                        client_ms=body.get("client_ms"),
                     )
                 except Exception:
                     pass

arrayview/_routes_websocket.py

@@ -81,9 +81,11 @@ def _render_progress_reporter(
     Anything finishing inside `quiet_for_s` therefore shows nothing at all,
     which is what keeps a fast load from flashing a bar on its way past.
     """
-    state = {"started": time.perf_counter(), "last": 0.0}
+    state = {"started": time.perf_counter(), "last": 0.0, "closed": False}
 
     def report(done, total):
+        if state["closed"]:
+            return
         now = time.perf_counter()
         if now - state["started"] < quiet_for_s:
             return
@@ -98,15 +100,24 @@ def _render_progress_reporter(
             "total": int(total),
             "label": label,
         }
+        def _send():
+            # Checked again on the loop: an update queued just before the
+            # frame was sent would otherwise arrive after it, and the viewer
+            # (which clears its bar when a frame lands) kept the bar up.
+            if not state["closed"]:
+                asyncio.ensure_future(_send_json_quietly(ws, payload))
+
         try:
-            loop.call_soon_threadsafe(
-                lambda: asyncio.ensure_future(_send_json_quietly(ws, payload))
-            )
+            loop.call_soon_threadsafe(_send)
         except RuntimeError:
             # Loop already closed (viewer went away mid-render); progress is
             # never worth raising over.
             pass
 
+    def close():
+        state["closed"] = True
+
+    report.close = close
     return report
 
 
@@ -118,9 +129,11 @@ async def _await_session_reporting_read_progress(ws, sid):
     holding a line to the viewer while the wait happens.
 
     Silent for the first stretch, so an ordinary fast open never flashes a
-    bar on its way past — the same rule the render progress reporter uses.
+    bar on its way past. Shorter than the viewer's own 0.6 s before it shows
+    its loading screen (counted from page load, which starts later), so the
+    line is ready when the screen appears rather than coming after it.
     """
-    quiet_for_s = 0.6
+    quiet_for_s = 0.3
     started = time.perf_counter()
     waiter = asyncio.ensure_future(wait_for_session_ready(sid))
     last = None
@@ -694,7 +707,12 @@ def register_websocket_routes(app) -> None:
 
                 # The pixels exist; nothing after this point reads the array,
                 # and the viewer clears its indicator when the frame lands.
+                # Closing the reporter also drops updates still queued for
+                # the socket, which would otherwise land after the frame.
+                sink = session.progress_sink
                 session.progress_sink = None
+                if hasattr(sink, "close"):
+                    sink.close()
                 render_ms = (time.perf_counter() - render_t0) * 1000.0
                 post_t0 = time.perf_counter()
                 header = np.array([seq, w, h], dtype=np.uint32).tobytes()

arrayview/_session.py

@@ -743,12 +743,9 @@ def upgrade_memmap_in_background(session) -> bool:
         return False
 
     if is_memmap:
-        if not filepath.endswith(".npy"):
-            return False
-        try:
-            nbytes = os.path.getsize(filepath)
-        except OSError:
+        if not filepath.endswith((".npy", ".mat")):
             return False
+        nbytes = int(data.nbytes)
     else:
         nbytes = _nifti_proxy_nbytes(data)
     if nbytes >= npy_eager_limit():
@@ -759,8 +756,14 @@ def upgrade_memmap_in_background(session) -> bool:
 
     def _upgrade():
         try:
-            if is_memmap:
-                loaded = np.load(filepath)
+            if is_memmap and filepath.endswith(".npy"):
+                from ._io import read_npy_into_ram
+
+                loaded = read_npy_into_ram(data)
+            elif is_memmap:
+                # A block mapped out of a larger file (.mat v7.3): copy it in
+                # file order, which is one sequential read.
+                loaded = np.array(data, copy=True, order="K")
             else:
                 from ._io import _nifti_display_array
 

arrayview/_viewer.html

@@ -52,6 +52,45 @@
             } catch (_) {}
         })();
 
+        // Open the viewer's WebSocket now, while the rest of this page and the
+        // large viewer script are still arriving. Through a VS Code tunnel a
+        // new connection takes ~0.2 s to set up, and the viewer used to start
+        // it only once its whole script had loaded and run. initWebSocket()
+        // adopts this socket if the address matches and replays anything it
+        // received in the meantime; otherwise it is closed and a fresh one made.
+        (function () {
+            try {
+                var params = new URLSearchParams(__ARRAYVIEW_QUERY__ || location.search);
+                var sid = params.get('sid');
+                if (
+                    !sid
+                    || params.get('transport') === 'http'
+                    || params.get('_av_relay_hedge') === '1'
+                    || typeof window.__ARRAYVIEW_SERVER_ORIGIN__ === 'string'
+                    || /\/proxy\/\d+(?:\/|$)/.test(location.pathname)
+                ) return;
+                var target = '/ws/' + sid;
+                var nativeRequestId = params.get('native_request_id');
+                if (nativeRequestId) {
+                    target += '?native_request_id=' + encodeURIComponent(nativeRequestId);
+                }
+                var requestId = params.get('_av_launch_request_id');
+                var token = params.get('_av_launch_token');
+                if (requestId && token) {
+                    target += (target.indexOf('?') >= 0 ? '&' : '?')
+                        + 'launch_request_id=' + encodeURIComponent(requestId)
+                        + '&launch_token=' + encodeURIComponent(token);
+                }
+                var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+                var url = proto + '//' + location.host + target;
+                var early = { url: url, ws: new WebSocket(url), opened: false, events: [] };
+                early.ws.binaryType = 'arraybuffer';
+                early.ws.onopen = function () { early.opened = true; };
+                early.ws.onmessage = function (event) { early.events.push(event); };
+                window.__avEarlySocket = early;
+            } catch (_) {}
+        })();
+
         // Name the tab at parse time. Without this the tab shows the host
         // ("localhost:8000") until metadata arrives over the WebSocket, and
         // that wait is the array load — seconds for a large file. The name
@@ -4443,9 +4482,17 @@
             box-shadow: none;
         }
         .qmri-synth-param-value { color: var(--text); text-align: right; font-variant-numeric: tabular-nums; }
+        /* Hidden for the first 600 ms of the page: most opens draw their
+           first frame within that, and a logo that flashes past reads as
+           noise. Only a slower open gets the loading screen (see the script
+           after the overlay markup). */
         #loading-overlay {
             display: flex; flex-direction: column; align-items: center; justify-content: center;
             position: fixed; inset: 0; z-index: 5; pointer-events: none;
+            visibility: hidden; opacity: 0;
+        }
+        #loading-overlay.av-load-shown {
+            visibility: visible; opacity: 1; transition: opacity 0.15s ease;
         }
         #loading-overlay .av-load-logo {
             width: 64px; height: 64px;
@@ -4453,11 +4500,28 @@
         #loading-overlay .av-load-name {
             margin-top: 14px; font-size: 11px; color: var(--muted);
             letter-spacing: 0.1em; text-transform: uppercase;
-            opacity: 0; transition: opacity 0.4s ease;
+            min-height: 1.2em; opacity: 0;
         }
         #loading-overlay .av-load-name.visible { opacity: 1; }
+        /* The startup screen is the only loading signal until the first frame:
+           logo, name, and — whenever there is progress to report — this line
+           under the name. The top-edge hairline and the busy panel stay hidden
+           meanwhile (see _reconcileUI), so a slow open never stacks three
+           different indicators. */
+        #loading-overlay .av-load-progress {
+            margin-top: 12px; width: 120px; height: 2px; border-radius: 1px;
+            background: color-mix(in srgb, var(--muted) 35%, transparent);
+            overflow: hidden; opacity: 0; transition: opacity 0.25s ease;
+        }
+        #loading-overlay .av-load-progress.visible { opacity: 1; }
+        #loading-overlay .av-load-progress .bar {
+            height: 100%; width: 0%;
+            background: var(--accent, #4cc9f0);
+            transition: width 0.25s linear;
+        }
         #loading-overlay.av-array-switch .av-load-logo,
-        #loading-overlay.av-array-switch .av-load-name { display: none; }
+        #loading-overlay.av-array-switch .av-load-name,
+        #loading-overlay.av-array-switch .av-load-progress { display: none; }
         /* Deliberately outside #loading-overlay. The overlay is centred over the
            canvas, so anything drawn in it sits on top of the slice — wrong for
            progress that continues after the viewer is live and showing data.
@@ -5678,12 +5742,29 @@
         <div id="multi-view-wrap"></div>
         <div id="qmri-view-wrap"></div>
         <div id="stack-mosaic-wrap"></div>
-        <div id="loading-overlay"><svg class="av-load-logo av-logo-loading" width="64" height="64" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><rect width="16" height="16" rx="2.5" fill="#0c0c0c"/><rect id="load-b0" x="2" y="2" width="3" height="3" fill="#3a0ca3"/><rect id="load-b1" x="6.5" y="2" width="3" height="3" fill="#560bad"/><rect id="load-b2" x="11" y="2" width="3" height="3" fill="#c77dff"/><rect id="load-b3" x="2" y="6.5" width="3" height="3" fill="#4361ee"/><rect id="load-b4" x="6.5" y="6.5" width="3" height="3" fill="#4cc9f0"/><rect id="load-b5" x="11" y="6.5" width="3" height="3" fill="#f5c842"/><rect id="load-b6" x="2" y="11" width="3" height="3" fill="#4895ef"/><rect id="load-b7" x="6.5" y="11" width="3" height="3" fill="#80ed99"/><rect id="load-b8" x="11" y="11" width="3" height="3" fill="#f8961e"/></svg><div class="av-load-name"></div></div>
+        <div id="loading-overlay"><svg class="av-load-logo av-logo-loading" width="64" height="64" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><rect width="16" height="16" rx="2.5" fill="#0c0c0c"/><rect id="load-b0" x="2" y="2" width="3" height="3" fill="#3a0ca3"/><rect id="load-b1" x="6.5" y="2" width="3" height="3" fill="#560bad"/><rect id="load-b2" x="11" y="2" width="3" height="3" fill="#c77dff"/><rect id="load-b3" x="2" y="6.5" width="3" height="3" fill="#4361ee"/><rect id="load-b4" x="6.5" y="6.5" width="3" height="3" fill="#4cc9f0"/><rect id="load-b5" x="11" y="6.5" width="3" height="3" fill="#f5c842"/><rect id="load-b6" x="2" y="11" width="3" height="3" fill="#4895ef"/><rect id="load-b7" x="6.5" y="11" width="3" height="3" fill="#80ed99"/><rect id="load-b8" x="11" y="11" width="3" height="3" fill="#f8961e"/></svg><div class="av-load-name"></div><div class="av-load-progress"><div class="bar"></div></div></div>
         <div id="render-progress"><div class="bar"></div></div>
         <div id="render-progress-text"></div>
         <div id="fft-spinner-overlay"><div class="av-loading-panel"><svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><rect width="16" height="16" rx="2.5" fill="#0c0c0c"/><rect x="2" y="2" width="3" height="3" fill="#3a0ca3"/><rect x="6.5" y="2" width="3" height="3" fill="#560bad"/><rect x="11" y="2" width="3" height="3" fill="#c77dff"/><rect x="2" y="6.5" width="3" height="3" fill="#4361ee"/><rect x="6.5" y="6.5" width="3" height="3" fill="#4cc9f0"/><rect x="11" y="6.5" width="3" height="3" fill="#f5c842"/><rect x="2" y="11" width="3" height="3" fill="#4895ef"/><rect x="6.5" y="11" width="3" height="3" fill="#80ed99"/><rect x="11" y="11" width="3" height="3" fill="#f8961e"/></svg><span>Computing FFT…</span></div></div>
         <div id="busy-overlay" role="status" aria-live="polite" aria-hidden="true"><div class="av-loading-panel"><svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><rect width="16" height="16" rx="2.5" fill="#0c0c0c"/><rect x="2" y="2" width="3" height="3" fill="#3a0ca3"/><rect x="6.5" y="2" width="3" height="3" fill="#560bad"/><rect x="11" y="2" width="3" height="3" fill="#c77dff"/><rect x="2" y="6.5" width="3" height="3" fill="#4361ee"/><rect x="6.5" y="6.5" width="3" height="3" fill="#4cc9f0"/><rect x="11" y="6.5" width="3" height="3" fill="#f5c842"/><rect x="2" y="11" width="3" height="3" fill="#4895ef"/><rect x="6.5" y="11" width="3" height="3" fill="#80ed99"/><rect x="11" y="11" width="3" height="3" fill="#f8961e"/></svg><span>Loading…</span></div></div>
         <script>
+            // Show the loading screen only if the first frame has not arrived
+            // 600 ms into the page (a switch between arrays shows its panel
+            // at once). Timed from navigation start, here rather than in the
+            // main script, which may itself take longer than that to arrive.
+            try {
+                const ol = document.getElementById('loading-overlay');
+                setTimeout(() => {
+                    if (document.body.classList.contains('av-loading')) ol.classList.add('av-load-shown');
+                }, Math.max(0, 600 - performance.now()));
+            } catch (_) {}
+            // The array's name under the startup logo, so the loading screen
+            // does not change while it is up.
+            try {
+                const name = new URLSearchParams(__ARRAYVIEW_QUERY__ || location.search).get('av_name');
+                const el = document.querySelector('#loading-overlay .av-load-name');
+                if (el && name) { el.textContent = name; el.classList.add('visible'); }
+            } catch (_) {}
             // After a switch between arrays of a multi-array file the page
             // reloads. Show the same small loading panel the switch used, not
             // the startup splash, so no second, larger logo flashes by.
@@ -5695,7 +5776,7 @@
                     const panel = document.querySelector('#busy-overlay .av-loading-panel').cloneNode(true);
                     panel.querySelector('span').textContent = `Loading ${key}…`;
                     panel.classList.add('av-array-switch-panel');
-                    ol.classList.add('av-array-switch');
+                    ol.classList.add('av-array-switch', 'av-load-shown');
                     ol.appendChild(panel);
                 }
             } catch (_) {}
@@ -5881,6 +5962,17 @@
         // server could not answer immediately (still loading), in which case
         // the viewer asks over the socket exactly as it always has.
         const BOOT_METADATA = __ARRAYVIEW_BOOT_METADATA__;
+        // Launches without ?av_name= still have the name in the page itself.
+        (function () {
+            try {
+                const el = document.querySelector('#loading-overlay .av-load-name');
+                const name = BOOT_METADATA && BOOT_METADATA.name;
+                if (el && !el.textContent && name && name !== 'welcome') {
+                    el.textContent = name;
+                    el.classList.add('visible');
+                }
+            } catch (_) {}
+        })();
         /* __AV_STATIC_SCRIPT_BELOW__ — nothing after this line is substituted at serve time. */
         const urlParams = new URLSearchParams(_arrayViewLaunchSearch);
         const _isIntegratedBrowserViewer = (
@@ -6215,7 +6307,36 @@
             return proxy;
         }
 
-        function createTransport(transportSid, onMessage, onOpen, onClose, onError) {
+        // Hand over the socket the page head opened early (see the head
+        // script), if it is for this exact address and still usable. Its
+        // open event and any messages that arrived before the viewer's own
+        // handlers existed are replayed once those handlers are attached,
+        // which happens synchronously after this returns.
+        function _takeEarlySocket(url) {
+            const early = window.__avEarlySocket;
+            window.__avEarlySocket = null;
+            if (!early) return null;
+            const usable = early.url === url
+                && (early.ws.readyState === WebSocket.CONNECTING
+                    || early.ws.readyState === WebSocket.OPEN);
+            if (!usable) {
+                try { early.ws.onopen = null; early.ws.onmessage = null; early.ws.close(); } catch (_) {}
+                return null;
+            }
+            const ws = early.ws;
+            ws.onopen = null;
+            ws.onmessage = null;
+            queueMicrotask(() => {
+                if (early.opened && ws.onopen) ws.onopen(new Event('open'));
+                for (const event of early.events) {
+                    if (ws.onmessage) ws.onmessage(event);
+                }
+                early.events.length = 0;
+            });
+            return ws;
+        }
+
+        function createTransport(transportSid, onMessage, onOpen, onClose, onError, adoptEarly = false) {
             let wsTarget = resolveServerPath(`/ws/${transportSid}`);
             const nativeRequestId = urlParams.get('native_request_id');
             if (nativeRequestId) {
@@ -6232,23 +6353,21 @@
                 wsTarget += `${separator}launch_request_id=${encodeURIComponent(launchRequestId)}`;
                 wsTarget += `&launch_token=${encodeURIComponent(launchToken)}`;
             }
-            const makeSocket = () => {
+            const socketUrl = () => {
                 if (_embeddedServerOrigin) {
                     const wsUrl = new URL(wsTarget);
                     const proto = wsUrl.protocol === 'https:' ? 'wss:' : 'ws:';
-                    return new WebSocket(
-                        `${proto}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}${wsUrl.hash}`
-                    );
+                    return `${proto}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}${wsUrl.hash}`;
                 }
                 const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
-                return new WebSocket(`${proto}//${location.host}${wsTarget}`);
+                return `${proto}//${location.host}${wsTarget}`;
             };
-            const ws = (
-                _relayWsHedgeEnabled
-                && transportSid === sid
-            )
-                ? _createHedgedWebSocket(makeSocket)
-                : makeSocket();
+            const makeSocket = () => new WebSocket(socketUrl());
+            const hedged = _relayWsHedgeEnabled && transportSid === sid;
+            const early = (adoptEarly && transportSid === sid && !hedged)
+                ? _takeEarlySocket(socketUrl())
+                : null;
+            const ws = early || (hedged ? _createHedgedWebSocket(makeSocket) : makeSocket());
             ws.binaryType = 'arraybuffer';
             if (onOpen) ws.onopen = onOpen;
             if (onMessage) ws.onmessage = onMessage;
@@ -6310,6 +6429,10 @@
                 const phaseBody = JSON.stringify({
                     phase,
                     detail: detail || null,
+                    // When it happened on the page's own clock (ms since
+                    // navigation start): reports are sent one after another,
+                    // so their arrival time at the server lags the event.
+                    client_ms: Math.round(performance.now()),
                     server_id: _launchPhaseServerId,
                     window_id: _launchPhaseWindowId,
                     token: _launchPhaseToken,
@@ -6958,6 +7081,7 @@
             [arrayName, info, cbWrap, helpHint].forEach(el => {
                 if (!el) return;
                 el.style.removeProperty('opacity');
+                el.style.removeProperty('transition');
                 el.style.removeProperty('--fly-y');
                 el.style.removeProperty('scale');
                 el.style.removeProperty('transformOrigin');
@@ -7016,15 +7140,11 @@
             const helpHint   = document.getElementById('help-hint');
             const cbVisible  = cbWrap && getComputedStyle(cbWrap).display !== 'none';
 
-            // Seize opacity immediately so CSS transition doesn't race GSAP
-            gsap.set([canvasWrap, arrayName, info, helpHint], { opacity: 0 });
-            if (cbVisible) gsap.set(cbWrap, { opacity: 0 });
-
-            // Set starting transforms for Act 3 (chrome assembly)
-            if (arrayName) gsap.set(arrayName, { '--fly-y': '-8px' });
-            if (info)      gsap.set(info,      { '--fly-y': '-8px' });
-            if (cbVisible) gsap.set(cbWrap,    { '--fly-y': '12px' });
-            if (helpHint)  gsap.set(helpHint,  { scale: 0.55, transformOrigin: 'center center' });
+            // Seize opacity immediately, and switch off their CSS opacity
+            // transition: left on, it re-eases every step of the fade below
+            // and stretches it to twice its length.
+            gsap.set([canvasWrap, arrayName, info, helpHint], { opacity: 0, transition: 'none' });
+            if (cbVisible) gsap.set(cbWrap, { opacity: 0, transition: 'none' });
 
             _startupAnimTl = gsap.timeline({ onComplete: () => {
                 clearTimeout(_safety);
@@ -7033,47 +7153,28 @@
                 if (ol) ol.style.display = 'none';
             }});
 
-            // ── Act 1: Logo settles (stops pulsing, all blocks snap to full) ──
+            // The logo stops pulsing, and the loading screen hands over to the
+            // viewer in one short cross-fade: picture and its labels arrive
+            // together. (They used to arrive in two waves, the labels flying in
+            // after the picture, which read as yet another loading step.)
             _startupAnimTl.call(() => {
                 if (loadLogo) loadLogo.classList.remove('av-logo-loading');
             }, null, 0);
-
-            // ── Act 2: Overlay exits, canvas revealed ──────────────────────
-            if (loadLogo) {
-                _startupAnimTl.to(loadLogo, {
-                    opacity: 0, scale: 0.6, duration: 0.18, ease: 'power2.in'
-                }, 0.05);
-            }
-            if (loadName) {
-                _startupAnimTl.to(loadName, {
-                    opacity: 0, duration: 0.14, ease: 'power2.in'
-                }, 0.05);
-            }
-            _startupAnimTl.to(canvasWrap, {
-                opacity: 1, duration: 0.22, ease: 'power2.out'
-            }, 0.08);
+            const loadProgress = ol ? ol.querySelector('.av-load-progress') : null;
+            const leaving = [loadLogo, loadName, loadProgress].filter(Boolean);
+            if (leaving.length) {
+                _startupAnimTl.to(leaving, { opacity: 0, duration: 0.16, ease: 'power2.in' }, 0);
+            }
+            const arriving = [canvasWrap, arrayName, info, helpHint].filter(Boolean);
+            if (cbVisible) arriving.push(cbWrap);
+            _startupAnimTl.to(arriving, { opacity: 1, duration: 0.2, ease: 'power2.out' }, 0.06);
             _startupAnimTl.call(() => {
                 document.body.classList.remove('av-loading');
                 _reconcileUI();
-            }, null, 0.08);
+            }, null, 0.06);
             _startupAnimTl.call(() => {
                 if (ol) ol.style.display = 'none';
-            }, null, 0.30);
-
-            // ── Act 3: Chrome assembles around canvas ──────────────────────
-            _startupAnimTl
-                .to(arrayName, { opacity: 1, '--fly-y': '0px', duration: 0.26, ease: 'power3.out' }, 0.32)
-                .to(info,      { opacity: 1, '--fly-y': '0px', duration: 0.26, ease: 'power3.out' }, 0.38);
-            if (cbVisible) {
-                _startupAnimTl.to(cbWrap, {
-                    opacity: 1, '--fly-y': '0px', duration: 0.24, ease: 'power3.out'
-                }, 0.48);
-            }
-            if (helpHint) {
-                _startupAnimTl.to(helpHint, {
-                    opacity: 1, scale: 1, duration: 0.22, ease: 'back.out(1.7)'
-                }, 0.58);
-            }
+            }, null, 0.26);
         }
         let _immersiveDriveTween = null; // tween that scrubs immersiveTl.progress()
         let _immTargetZoom = 1.0; // cached zoom target at start of transition
@@ -15798,7 +15899,7 @@
             }
             if (_wsRetryTimer) { clearTimeout(_wsRetryTimer); _wsRetryTimer = null; }
             if (_wsGaveUp) return;
-            ws = createTransport(sid, null, null, null, null);
+            ws = createTransport(sid, null, null, null, null, true);
 
             // Only the first connection is bounded. Once a socket has opened,
             // a later drop is a reconnect — the server may be restarting, and
@@ -15855,7 +15956,12 @@
                         } else if (msg.type === 'render_timing' && _PERF_ENABLED) {
                             _perfHandleTimingMessage(event.data, 'main');
                         } else if (msg.type === 'render_progress') {
-                            _showRenderProgress(msg.done, msg.total, msg.label);
+                            // Only while a frame is actually awaited: a late
+                            // report for a frame already drawn would show a
+                            // bar that nothing then clears.
+                            if (isRendering || !_reportedFirstFrame) {
+                                _showRenderProgress(msg.done, msg.total, msg.label);
+                            }
                         } else if (msg.type === 'warm_path') {
                             _warmClientPath(msg.connections);
                         } else if (msg.type === 'render_error') {
@@ -16967,6 +17073,8 @@
         }
         function _showRenderProgress(done, total, label) {
             if (!total || done > total) return;
+            const startupBar = document.querySelector('#loading-overlay .av-load-progress .bar');
+            if (startupBar) startupBar.style.width = ((done / total) * 100).toFixed(1) + '%';
             const bar = document.querySelector('#render-progress .bar');
             const text = document.getElementById('render-progress-text');
             if (!bar || !text) return;
@@ -41836,22 +41944,29 @@
             _reconcileMainLoupeState();
             _reconcileInfoCursor();
             _reconcileModePicker();
+            // Until the first frame the startup screen owns every loading
+            // signal; its own line stands in for the hairline.
+            const startupScreen = document.body.classList.contains('av-loading');
+            const startupProgress = document.querySelector('#loading-overlay .av-load-progress');
+            if (startupProgress) {
+                startupProgress.classList.toggle('visible', startupScreen && _renderProgressVisible);
+            }
             const busyOverlay = document.getElementById('busy-overlay');
             if (busyOverlay) {
-                const busy = _patientLoadingVisible || _slowRenderBusyVisible || _smPageBusyVisible;
+                const busy = !startupScreen
+                    && (_patientLoadingVisible || _slowRenderBusyVisible || _smPageBusyVisible);
                 busyOverlay.classList.toggle('visible', busy);
                 busyOverlay.setAttribute('aria-hidden', busy ? 'false' : 'true');
             }
+            const hairline = _renderProgressVisible && !startupScreen;
             const renderProgress = document.getElementById('render-progress');
             if (renderProgress) {
-                renderProgress.classList.toggle('visible', _renderProgressVisible);
-                renderProgress.setAttribute(
-                    'aria-hidden', _renderProgressVisible ? 'false' : 'true'
-                );
+                renderProgress.classList.toggle('visible', hairline);
+                renderProgress.setAttribute('aria-hidden', hairline ? 'false' : 'true');
             }
             const renderProgressText = document.getElementById('render-progress-text');
             if (renderProgressText) {
-                renderProgressText.classList.toggle('visible', _renderProgressVisible);
+                renderProgressText.classList.toggle('visible', hairline);
             }
             const dropMenu = document.getElementById('drop-action-menu');
             if (dropMenu) {

arrayview/_vscode_extension.py

@@ -58,7 +58,7 @@ _VSCODE_EXT_FRESH_INSTALL = False  # True if we just installed it this session
 _VSCODE_EXT_RELOAD_REQUIRED = False  # installed files are newer than the live host
 _VSCODE_EXT_INSTALL_FAILED = False  # automatic install could not complete safely
 _VSCODE_EXT_NO_LIVE_WINDOW = False  # no live host claims this terminal's window id
-_VSCODE_EXT_VERSION = "0.15.64"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.15.70"  # current bundled extension version
 _VSCODE_CONFIGURED_PORTS: set[int] = set()
 # Version-skew notices already printed, so a long-lived process (Jupyter, a
 # script opening several arrays) states the mismatch once instead of per call.

{arrayview-0.47.4.dist-info → arrayview-0.48.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arrayview
-Version: 0.47.4
+Version: 0.48.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.47.4.dist-info → arrayview-0.48.0.dist-info}/RECORD

@@ -12,30 +12,30 @@ arrayview/_extra_ports.py,sha256=MZcx04NI9Eg4coydb-yPIHp7uJbE6UscyYGnw8fxid0,111
 arrayview/_icon.png,sha256=a8RTAbvweLhh3hzD5eGg76Peq-KSDcS6YrCphRb_HEs,2748
 arrayview/_imaging.py,sha256=MQX1uy4m1lofOeoLDhCp6cHO5p_V5fXm4qlSu9Ykn-c,534
 arrayview/_instance_registry.py,sha256=h7vyvCl0LTt9R8sDB1Vxe4a-KzfkLVuwrSw_ANpPTD8,8833
-arrayview/_io.py,sha256=u1wrxfEA3kRT9n6tV-7ptcQxr1mOylZaREYq3Ex6nvM,77652
+arrayview/_io.py,sha256=waUJr9au3yrYJKhUFa4EmOdRjkGjKrb9G01NJtCysrs,90123
 arrayview/_launch_plan.py,sha256=KGgIPGsflXArECB2txnIAewjuPvF4fZTbO63alC8x28,23570
 arrayview/_launch_trace.py,sha256=4yjJdkFyEvSrPN14QVFJ3u6on2q0TH2ySSdgUp9SjKI,5668
-arrayview/_launcher.py,sha256=Eu1XFLhuXiO45StFWZoSPPjFkBLqcEeqGB8Utx7kotQ,243224
+arrayview/_launcher.py,sha256=Hljfeq4AmxVTDiDgYyMtHT5eiatgFdrvcr6bq75onZY,243267
 arrayview/_lifecycle.py,sha256=bqG0oKr-e-5S1ssCTlGmF-yBE47ilrpO1S_Owfjs9Z8,5365
 arrayview/_overlays.py,sha256=CksypG9rWfCz_3RRGIeyaKeXse17AFxvkEjmYyXnIIE,5399
 arrayview/_platform.py,sha256=qSWjRcx9rLIdLvKrRArSueFnbyn5GPKfTEMOc5mCIUs,29970
-arrayview/_render.py,sha256=sSNPWreJumIyFKvZtAS5v2gxbNHRVyAdc7JGj34caPw,34121
+arrayview/_render.py,sha256=iDf0weQ30AH93l74KOlO8Ciq__Wbh-wqfAY7KQS1utE,34576
 arrayview/_routes_analysis.py,sha256=Xz9Ysr04u07pzSRB4Fzmcl6XwVxyaG6xCWxGwYZi_80,33085
 arrayview/_routes_drop.py,sha256=FC4e7STdCo3hYIA0C4Yy9Ka2UKFx7nLDU5dkujmc1Vo,12477
 arrayview/_routes_export.py,sha256=Ha8mMO2E9TlRL5x25-ADV8_8xUiC-jRz9N1oWwgKOsg,3898
-arrayview/_routes_loading.py,sha256=r88PRn1ogSRe1Ec0odhCN3jd5FwIDH0y7acPdUoY9v0,42404
+arrayview/_routes_loading.py,sha256=CuKOtJKb3qTS0JXP_662ehPns4-BIppcm0DHErH74mY,42451
 arrayview/_routes_persistence.py,sha256=T03csHb7ppGT-8yMDf227XkqhnhjgSLYj0RW2wmg59g,17176
 arrayview/_routes_preferences.py,sha256=xoMHbPKliYspgjaclhx2r8HbP9mFo9Td-nTF76eWVMg,4680
 arrayview/_routes_preload.py,sha256=KOsankNguxdIWmFW9iZcY9p2SvUN1mOKY7KkW1qMGcc,1729
-arrayview/_routes_query.py,sha256=QkIfx_H2h8OE57hWI-A7auneLdaNKKdsLMjuUrkLRzU,24955
+arrayview/_routes_query.py,sha256=HEEmMKuFycUTBNVUSWtUFXCnWB7ZrM3hv9IZWbXz11o,25012
 arrayview/_routes_rendering.py,sha256=EQq2QzdtUS_pv35k7prLdlRdO5nByIlQ_Eu0nhVsn1Y,22970
 arrayview/_routes_segmentation.py,sha256=x2bBjQffZryeTMmOH38YdBWethw1o3KpA8V0chJcZHI,23599
 arrayview/_routes_state.py,sha256=T_xoYcRlv7L47ydTxxiXb0Fp5M5x9KR2U-wkxaVeuMY,12462
 arrayview/_routes_vectorfield.py,sha256=OWZtAONwRKQHdYnbDAMbOVf0q6pH7kqV8fa1icDhKHM,9734
-arrayview/_routes_websocket.py,sha256=1EWgjCNZ1hbDCGY13c3TyBqL1_u4uCWztGzk00lWfBs,41272
+arrayview/_routes_websocket.py,sha256=CADgPfAsYWfB7IA75_qJ4voL8dQ3y4RjfzPO0vahIkc,42093
 arrayview/_segmentation.py,sha256=aENWHmefrKDScXhcZL1X3KgYXE784dpMkmFFo83qnrw,7377
 arrayview/_server.py,sha256=A8O8J6N4WTDcujFHjTWjlJYWIzkJe8y9XmKpj9XozE0,22918
-arrayview/_session.py,sha256=-Jems6lGOVU3uLs4Uq1ggIfY-qTrAXNzpUk6nMbuTBA,35616
+arrayview/_session.py,sha256=jDOERph1hRzqLr9_uzy4Yi0AlLYLD4Y8JJD8bM8r56M,35867
 arrayview/_session_spec.py,sha256=mKDfMRsPYQdEmN9hLXmDU_9N7etiDyBXr8mz-fB8QBo,6825
 arrayview/_shell.html,sha256=vNa2Kiwx_eoB5H329jolYafLhwJDCH9DsJafBqvVMWU,13194
 arrayview/_source_safety.py,sha256=cI7JAL7DWYuxuB_LnYExvJZaICX2R2qJEJWD1M0z_gg,27664
@@ -43,17 +43,17 @@ arrayview/_synthetic_mri.py,sha256=CNL-2WC835i6WCqkvmWBCO6WQ5w7HE5trNb8OyEfe64,7
 arrayview/_torch.py,sha256=13sqIMCUu_-b9SQ9KfDCExDz2UMStL87EDVjnbJxAEo,7536
 arrayview/_tutorial.py,sha256=2zZHJGJDa4n30GE1-9ADjKFAifGBH9vvHXP4uDt7BaA,19547
 arrayview/_vectorfield.py,sha256=eDqMCMEGjO8Jdt-6Auh01cz3WD9dbF7xYUWD9xHAf1E,8115
-arrayview/_viewer.html,sha256=aiHPSbCCtj90EnHV0nJ7kh8YkxAaUmzdDYJGW5KC0Zg,2372368
+arrayview/_viewer.html,sha256=mqFwuv1qoxAOCPjKBZKfqBzavZcz3-muqQEBDLqfY50,2379540
 arrayview/_vscode.py,sha256=EKnGN2zrjlybc4FQOmYA8BvYdtkcJbLHDEdgtvO7ul4,837
 arrayview/_vscode_browser.py,sha256=VCH9JpAAjFuhO0wQe8tIGjAL5837AXg_bpmBFtWOQqc,20573
-arrayview/_vscode_extension.py,sha256=tF62xp_zVDMexlPtAZ7wKvKCKakdygmf3IGIcICoKeE,53156
+arrayview/_vscode_extension.py,sha256=eYsWAQmik2tt7HMWad9vBnn2kpRyRpLrh42FBGQy0M4,53156
 arrayview/_vscode_signal.py,sha256=N3PCHG6-3tCEc_tHLjg2dhSEQ2EnF_psE2IJRBpAuac,54938
 arrayview/_watch.py,sha256=PxxS_5hcj_S6xQf9Ep4p1HLRkrI5iDMh1aRa4olV7ew,1873
-arrayview/arrayview-opener.vsix,sha256=BpRLXxm4j9gc34xusHzE80g01m6CvIK_fzf3ApgS5xE,61442
+arrayview/arrayview-opener.vsix,sha256=44uiTM39qj_RXji3pFQaR8TA1jhNB3LYwVU_dGFbP4c,62284
 arrayview/gsap.min.js,sha256=VGihm4idI0E1uqrWezWsiScB9F_jMosn7qs6pPSkeac,72304
 arrayview/todo.md,sha256=KhnRzpn6_jezR0nDDB61-zhox-rbOmEGW-A7Z0_7FnU,622
-arrayview-0.47.4.dist-info/METADATA,sha256=V3wlriyNB8GhY_UZwcin_BktoAU6pkum8vDVg6FYVCY,2288
-arrayview-0.47.4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-arrayview-0.47.4.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
-arrayview-0.47.4.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
-arrayview-0.47.4.dist-info/RECORD,,
+arrayview-0.48.0.dist-info/METADATA,sha256=v_WbIzyXx3Z9rNgk9uKz7YPEPyVcnUqfPOU4BpVD4is,2288
+arrayview-0.48.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+arrayview-0.48.0.dist-info/entry_points.txt,sha256=-0s08axutXkTbINiKs0Q7iv-33aWuTaamUg2q2-NyQ4,60
+arrayview-0.48.0.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
+arrayview-0.48.0.dist-info/RECORD,,