arrayview 0.9.0__tar.gz → 0.10.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.9.0
+Version: 0.10.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.9.0 → arrayview-0.10.0}/pyproject.toml

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

{arrayview-0.9.0 → arrayview-0.10.0}/src/arrayview/_server.py

@@ -1913,6 +1913,90 @@ def get_volume_histogram(
     return result
 
 
+# ── Volume Data (3-D MIP) ────────────────────────────────────────
+
+
+@app.get("/volume_data/{sid}")
+def get_volume_data(
+    sid: str,
+    dims: str = "",
+    indices: str = "",
+    complex_mode: int = 0,
+):
+    """Return the full 3-D sub-volume as raw float32 bytes for the WebGL MIP renderer.
+
+    *dims* is a comma-separated triple of the three spatial dimensions (e.g. ``"0,1,2"``).
+    *indices* gives the current index for every dimension (comma-separated).
+    Dimensions not in *dims* are sliced at the value given in *indices*.
+
+    If any axis exceeds 256, stride-based down-sampling is applied so that
+    the returned volume fits within 256^3.
+
+    Response headers carry ``X-Shape`` (comma-separated), ``X-Vmin``, ``X-Vmax``.
+    """
+    session = SESSIONS.get(sid)
+    if not session:
+        return Response(status_code=404)
+
+    # Parse dims and indices
+    if not dims:
+        return Response(status_code=400, content="dims required")
+    dim_list = [int(d) for d in dims.split(",")]
+    if len(dim_list) != 3:
+        return Response(status_code=400, content="dims must be exactly 3 integers")
+
+    idx_list = [int(x) for x in indices.split(",")] if indices else [s // 2 for s in session.shape]
+
+    # Build slicer: keep the 3 spatial dims free, fix everything else
+    slicer = []
+    for i in range(len(session.shape)):
+        if i in dim_list:
+            slicer.append(slice(None))
+        else:
+            idx = idx_list[i] if i < len(idx_list) else session.shape[i] // 2
+            slicer.append(min(max(idx, 0), session.shape[i] - 1))
+    vol = np.array(session.data[tuple(slicer)])
+
+    # Reorder axes so dim_list order maps to (0, 1, 2) of the output
+    # vol currently has axes at the positions corresponding to dim_list within
+    # the free-axis subset.  We need to figure out which axes of `vol` correspond
+    # to which dim in dim_list.
+    free_axes_sorted = sorted(dim_list)
+    # vol axes are in the order of free_axes_sorted (numpy preserves order)
+    perm = [free_axes_sorted.index(d) for d in dim_list]
+    vol = np.transpose(vol, perm)
+
+    # Apply complex mode
+    vol = apply_complex_mode(vol, complex_mode)
+
+    # Downsample any axis > 256
+    max_dim = 256
+    strides = []
+    for s in vol.shape:
+        strides.append(max(1, (s + max_dim - 1) // max_dim))
+    if any(st > 1 for st in strides):
+        vol = vol[::strides[0], ::strides[1], ::strides[2]]
+
+    vol = np.ascontiguousarray(vol, dtype=np.float32)
+
+    finite = vol[np.isfinite(vol)]
+    if finite.size > 0:
+        vmin = float(np.percentile(finite, 1))
+        vmax = float(np.percentile(finite, 99))
+    else:
+        vmin, vmax = 0.0, 1.0
+
+    return Response(
+        content=vol.tobytes(),
+        media_type="application/octet-stream",
+        headers={
+            "X-Shape": ",".join(str(s) for s in vol.shape),
+            "X-Vmin": str(vmin),
+            "X-Vmax": str(vmax),
+        },
+    )
+
+
 @app.get("/lebesgue/{sid}")
 def get_lebesgue_slice(
     sid: str,

{arrayview-0.9.0 → arrayview-0.10.0}/src/arrayview/_viewer.html

@@ -83,6 +83,7 @@
             border-color: rgba(216, 222, 233, 0.07);
         }
         #viewer-row {
+            position: relative;
             display: flex; align-items: center; justify-content: center; flex-shrink: 0;
             width: 100%; padding: 8px; box-sizing: border-box;
         }
@@ -462,6 +463,8 @@
                               border: 1px solid rgba(210,90,200,0.25); }
         .mode-badge-diff    { background: rgba(255,130,90,0.15); color: #ff8a5c;
                               border: 1px solid rgba(255,130,90,0.25); }
+        .mode-badge-mip     { background: rgba(0,200,180,0.15); color: #4fd1c5;
+                              border-color: rgba(0,200,180,0.3); }
         .mode-badge-proj    { background: rgba(140,100,240,0.15); color: #a78bfa;
                               border: 1px solid rgba(140,100,240,0.25); }
         :root.light .mode-badge-fft { background: rgba(40,160,100,0.1); color: #288c64; border-color: rgba(40,160,100,0.25); }
@@ -470,6 +473,7 @@
         :root.light .mode-badge-alpha { background: rgba(180,50,50,0.1); color: #c04040; border-color: rgba(180,50,50,0.25); }
         :root.light .mode-badge-rgb  { background: rgba(170,50,160,0.1); color: #a030a0; border-color: rgba(170,50,160,0.25); }
         :root.light .mode-badge-diff { background: rgba(200,100,50,0.1); color: #b05520; border-color: rgba(200,100,50,0.25); }
+        :root.light .mode-badge-mip  { background: rgba(0,180,160,0.1); color: #108080; border-color: rgba(0,180,160,0.25); }
         :root.light .mode-badge-proj { background: rgba(120,80,200,0.1); color: #7040c0; border-color: rgba(120,80,200,0.25); }
         #mode-eggs { position: fixed; display: flex; flex-direction: row; align-items: center; gap: 4px; cursor: default; z-index: 2; pointer-events: none; transition: opacity 0.3s ease; }
         body.fullscreen-mode .mode-badge { background-color: rgba(30, 30, 30, 0.75); backdrop-filter: blur(8px); -webkit-backdrop-filter: blur(8px); }
@@ -618,6 +622,10 @@
             background: var(--surface); border: 1px solid var(--border);
             border-radius: var(--radius); pointer-events: none;
         }
+        /* ── MIP 3-D volume renderer ─────────────────────────────── */
+        #mip-canvas { display: none; position: absolute; top: 0; left: 0; width: 100%; height: 100%; cursor: grab; z-index: 5; }
+        #mip-canvas:active { cursor: grabbing; }
+
         #multi-view-wrap { display: none; width: 100%; height: 100%; }
         #multi-view-wrap.active { display: flex; flex-direction: column; align-items: stretch; justify-content: center; gap: 12px; }
         #mv-panes { display: flex; align-items: flex-start; justify-content: center; flex: 0 0 auto; gap: 16px; }
@@ -967,7 +975,9 @@
         #colormap-strip, #colormap-strip-right {
             position:fixed; display:flex; flex-direction:row; align-items:center; gap:8px;
             opacity:0; pointer-events:none; transition:opacity 0.25s ease;
-            z-index:8;
+            z-index:8; overflow:hidden; justify-content:center;
+            mask-image:linear-gradient(to right, transparent, black 8%, black 92%, transparent);
+            -webkit-mask-image:linear-gradient(to right, transparent, black 8%, black 92%, transparent);
         }
         #colormap-strip.visible, #colormap-strip-right.visible { opacity:1; }
         .cmap-thumb { display:flex; flex-direction:column; align-items:center; gap:2px; opacity:0.5; transition:opacity 0.15s ease; }
@@ -1366,6 +1376,7 @@
                 </div>
             </div>
         </div>
+        <canvas id="mip-canvas"></canvas>
         <div id="multi-view-wrap"></div>
         <div id="qmri-view-wrap"></div>
         <div id="loading-overlay"></div>
@@ -1473,7 +1484,7 @@
                 <div class="help-row"><span class="key">Shift+O</span><span class="desc">cycle overlay visibility: all → off → individual masks (when overlays active)</span></div>
                 <div class="help-row"><span class="key">X</span><span class="desc">cycle center pane: off → A−B → |A−B| → |A−B|/|A| → overlay → wipe → flicker → checker</span></div>
                 <div class="help-row"><span class="key">&lt; / &gt;</span><span class="desc">movie: fps (during playback)</span></div>
-                <div class="help-row"><span class="key">[ / ]</span><span class="desc">flicker: rate · checker: tile size · overlay/wipe/reg blend · arrow density · movie: fps</span></div>
+                <div class="help-row"><span class="key">[ / ]</span><span class="desc">flicker: rate · checker: tile size · overlay/wipe/reg blend · arrow density</span></div>
                 <div class="help-row"><span class="key">{ / }</span><span class="desc">arrow length shorter / longer (vector field mode)</span></div>
                 <div class="help-row"><span class="key">U</span><span class="desc">toggle vector arrows</span></div>
                  <div class="help-row"><span class="key">n</span><span class="desc">cycle compare target session</span></div>
@@ -1482,7 +1493,7 @@
                 <div class="help-row"><span class="key">shift+drag</span><span class="desc">move dimbar / colorbar in immersive mode (resets on exit)</span></div>
                 <div class="help-row"><span class="key">Z</span><span class="desc">focus center pane (when compare center is active — X to activate)</span></div>
                 <div class="help-row"><span class="key">L</span><span class="desc">toggle log scale</span></div>
-                <div class="help-row"><span class="key">p</span><span class="desc">cycle projection: off → MAX → MIN → MEAN → STD → SOS → SUM</span></div>
+                <div class="help-row"><span class="key">p</span><span class="desc">cycle projection: off → MAX → MIN → MEAN → STD → SOS → SUM; in multiview: toggle 3-D MIP volume renderer</span></div>
                 <div class="help-row"><span class="key">m</span><span class="desc">cycle complex mode (mag / phase / real / imag)</span></div>
                 <div class="help-row"><span class="key">f</span><span class="desc">toggle centred FFT (prompts for axes)</span></div>
                 <div class="help-row"><span class="key">M</span><span class="desc">toggle alpha transparency</span></div>
@@ -1837,6 +1848,7 @@
         const PROJECTION_COLORS = ['#4cc9f0', '#ff6b6b', '#80ed99', '#c77dff', '#ffa62b'];
         let alphaLevel = 0; // 0=off, 1=on (transparent below vmin)
         let multiViewActive = false;
+        let mipActive = false;
         let mvViews = [];
         let mvDims = [];
         let mvDraggingView = null;
@@ -2259,6 +2271,7 @@
         function _cbApplyAndRender() {
             proxyFetch(`/clearcache/${sid}`);
             updateView();
+            _mipOnWindowChange();
             saveState();
         }
         // Legacy slimCbCanvas wheel/mousedown/dblclick handlers REMOVED (Task 3).
@@ -3340,6 +3353,7 @@
             ModeRegistry.scaleAll();
             positionEggs();
             _validateUIState();
+            if (mipActive) _mipResizeCanvas();
         });
 
         // ── Mode crossfade utility ──────────────────────────────
@@ -3443,7 +3457,6 @@
             // ── Fullscreen overlay colorbar mode ──────────────────────
             if (_fullscreenActive) {
                 // Fullscreen: use morph draw, then position anchored to bottom
-                if (_cmapInIsland) return;
                 const cbRefW = compareActive ? window.innerWidth : (vpEl ? vpEl.offsetWidth : Math.round(canvasRect.width));
                 // Cap width: use pane viewport width if available, otherwise % of reference
                 let maxCbW = 350;
@@ -3494,8 +3507,6 @@
             }
 
             // ── Normal horizontal colorbar ──────────────────────────
-            // Skip everything if colormap preview is showing in the island
-            if (_cmapInIsland) return;
             if (wrap) {
                 wrap.classList.remove('compact-vertical', 'compact-overlay');
                 wrap.style.transform = '';
@@ -3580,7 +3591,7 @@
             // When collapsed: show window values (manualVmin/Vmax or currentVmin/Vmax)
             const slimVmin = document.getElementById('slim-cb-vmin');
             const slimVmax = document.getElementById('slim-cb-vmax');
-            if (slimVmin && slimVmax && !_cmapInIsland) {
+            if (slimVmin && slimVmax) {
                 if (compareActive) {
                     const sharedVmin = Math.min(...compareFrames.filter(Boolean).map(f => manualVmin ?? f.vmin));
                     const sharedVmax = Math.max(...compareFrames.filter(Boolean).map(f => manualVmax ?? f.vmax));
@@ -4058,7 +4069,7 @@
                     if (vminFrac > 0.005 || vmaxFrac < 0.995) {
                         [effVmin, effVmax].forEach(f => {
                             if (f <= 0.003 || f >= 0.997) return;
-                            const x = Math.round(f * cssW);
+                            const x = Math.max(2, Math.min(cssW - 2, Math.round(f * cssW)));
 
                             const lineH = cssH - labelH;
                             const lineTop = labelH;
@@ -4651,6 +4662,7 @@
                         _cbWindowChangeRafId = null;
                         updateView();
                         triggerPreload();
+                        _mipOnWindowChange();
                         saveState();
                     });
                 }
@@ -5919,6 +5931,9 @@
             if (projectionMode > 0) {
                 html += `<span class="mode-badge mode-badge-proj">${PROJECTION_LABELS[projectionMode - 1]}</span>`;
             }
+            if (mipActive) {
+                html += `<span class="mode-badge mode-badge-mip">MIP</span>`;
+            }
             el.innerHTML = html;
             // Position eggs below the active canvas, just above the slim colorbar
             if (html) positionEggs();
@@ -8317,6 +8332,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                 return;
             }
             if (e.key === 'Escape') {
+                if (mipActive) { exitMipMode(); return; }
                 helpOverlay.classList.remove('visible');
                 document.getElementById('info-overlay').classList.remove('visible');
                 return;
@@ -8508,13 +8524,6 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                     return;
                 }
             } else if (e.key === '[' || e.key === ']') {
-                if (isPlaying) {
-                    const delta = e.key === ']' ? 5 : -5;
-                    playFps = Math.max(1, Math.min(120, playFps + delta));
-                    setStatus(`▶ playing  (Space to stop · < / > fps: ${playFps})`);
-                    showToast(`playback: ${playFps} fps`);
-                    return;
-                }
                 const step = e.key === ']' ? 0.05 : -0.05;
                 if (rectRoiMode && _roiShape === 'floodfill') {
                     // Adjust flood fill tolerance
@@ -8879,6 +8888,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                 colormap_idx = (colormap_idx === -1 ? 0 : (colormap_idx + 1) % COLORMAPS.length);
                 proxyFetch(`/clearcache/${sid}`); updateView(); triggerPreload();
                 refreshAxesColor();
+                _mipOnColormapChange();
                 // When histogram is open, skip the previewer — just update the colorbar display
                 const _histOpen = primaryCb._expanded || (_diffLeftCb && _diffLeftCb.expanded);
                 if (_histOpen) {
@@ -8909,6 +8919,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                         colormap_idx = -1;
                         proxyFetch(`/clearcache/${sid}`); updateView(); triggerPreload();
                         refreshAxesColor();
+                        _mipOnColormapChange();
                         showStatus(`colormap: ${customColormap}`);
                         saveState();
                     });
@@ -9230,7 +9241,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
             } else if (e.key === 'h' || e.key === 'ArrowLeft') {
                 e.preventDefault();
                 // While colormap strip is visible, cycle colormap backward
-                if ((_cmapInIsland || (_cmapStrip && _cmapStrip.classList.contains('visible'))) && !qmriActive && !compareQmriActive && !rgbMode) {
+                if ((_cmapStrip && _cmapStrip.classList.contains('visible')) && !qmriActive && !compareQmriActive && !rgbMode) {
                     if (_cmapStripMode === 'diff-center') {
                         const pool = (diffMode === 1) ? DIFF_COLORMAPS : ABS_DIFF_COLORMAPS;
                         const idx = pool.indexOf(_diffCenterColormap);
@@ -9277,7 +9288,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
             } else if (e.key === 'l' || e.key === 'ArrowRight') {
                 e.preventDefault();
                 // While colormap strip is visible, cycle colormap forward
-                if ((_cmapInIsland || (_cmapStrip && _cmapStrip.classList.contains('visible'))) && !qmriActive && !compareQmriActive && !rgbMode) {
+                if ((_cmapStrip && _cmapStrip.classList.contains('visible')) && !qmriActive && !compareQmriActive && !rgbMode) {
                     if (_cmapStripMode === 'diff-center') {
                         const pool = (diffMode === 1) ? DIFF_COLORMAPS : ABS_DIFF_COLORMAPS;
                         const idx = pool.indexOf(_diffCenterColormap);
@@ -9343,6 +9354,12 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                 renderEggs();
                 saveState();
             } else if (e.key === 'p') {
+                // In multiview: toggle 3-D MIP volume renderer
+                if (multiViewActive || mipActive) {
+                    if (mipActive) { exitMipMode(); }
+                    else { enterMipMode(); }
+                    return;
+                }
                 // Statistical projections: off → MAX → MIN → MEAN → STD → SOS
                 if (shape.length < 3) { showStatus('projection: need ≥ 3D array'); return; }
                 if (hasVectorfield) { showStatus('projection: not available in vector field mode'); return; }
@@ -10325,7 +10342,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                     getWindow: () => ({ vmin: manualVmin ?? currentVmin, vmax: manualVmax ?? currentVmax }),
                     setWindow: (lo, hi) => { manualVmin = lo; manualVmax = hi; },
                     fetchHistogram: () => _fetchVolumeHistogram(_volHistSpatialOpts()),
-                    onWindowChange: () => { for (const v of mvViews) mvRender(v); },
+                    onWindowChange: () => { for (const v of mvViews) mvRender(v); _mipOnWindowChange(); },
                     onBinHover: (binIdx, frac) => {
                         if (!lebesgueMode) return;
                         if (binIdx < 0) { _clearLebesgueOverlay(); return; }
@@ -10503,6 +10520,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
         }
 
         function exitMultiView() {
+            if (mipActive) exitMipMode();
             multiViewActive = false;
             // Clean up multiview vector field state
             _mvVfieldCache.clear();
@@ -10539,6 +10557,483 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
             showStatus('3-plane view: off');
         }
 
+        // ═══════════════════════════════════════════════════════════
+        // ── 3-D Maximum Intensity Projection (MIP) renderer ──────
+        // ═══════════════════════════════════════════════════════════
+
+        // WebGL2 state
+        let _mipGL = null;
+        let _mipProgram = null;
+        let _mipVolTex = null;
+        let _mipLutTex = null;
+        let _mipVAO = null;
+        let _mipAzimuth = 0;
+        let _mipElevation = 0;
+        let _mipZoom = 2.5;
+        let _mipDragging = false;
+        let _mipDragX = 0;
+        let _mipDragY = 0;
+        let _mipVolShape = [1, 1, 1];
+        let _mipVolCacheKey = null;  // "sid:dims:indices:version" to detect changes
+        let _mipAnimFrame = null;
+
+        const _MIP_VERT_SRC = `#version 300 es
+        in vec2 a_pos;
+        out vec2 v_uv;
+        void main() {
+            v_uv = a_pos * 0.5 + 0.5;
+            gl_Position = vec4(a_pos, 0.0, 1.0);
+        }`;
+
+        const _MIP_FRAG_SRC = `#version 300 es
+        precision highp float;
+        precision highp sampler3D;
+        in vec2 v_uv;
+        out vec4 fragColor;
+
+        uniform sampler3D u_volume;
+        uniform sampler2D u_lut;
+        uniform vec3 u_volSize;   // normalized size ratios
+        uniform float u_vmin;
+        uniform float u_vmax;
+        uniform mat3 u_rotation;
+        uniform float u_camDist;
+        uniform int u_steps;
+
+        void main() {
+            // Ray origin and direction from orbit camera with perspective
+            vec3 center = vec3(0.0);
+            vec3 camPos = u_rotation * vec3(0.0, 0.0, u_camDist);
+
+            // Build ray direction with slight perspective
+            vec3 right = u_rotation * vec3(1.0, 0.0, 0.0);
+            vec3 up    = u_rotation * vec3(0.0, 1.0, 0.0);
+            vec3 fwd   = u_rotation * vec3(0.0, 0.0, -1.0);
+
+            float fov = 0.8; // radians
+            vec2 ndc = (v_uv - 0.5) * 2.0;
+            vec3 rayDir = normalize(fwd + ndc.x * right * fov + ndc.y * up * fov);
+            vec3 rayOri = camPos;
+
+            // AABB intersection with box [-0.5*volSize, 0.5*volSize]
+            vec3 halfBox = u_volSize * 0.5;
+            vec3 invDir = 1.0 / rayDir;
+            vec3 t0 = (-halfBox - rayOri) * invDir;
+            vec3 t1 = ( halfBox - rayOri) * invDir;
+            vec3 tmin = min(t0, t1);
+            vec3 tmax = max(t0, t1);
+            float tNear = max(max(tmin.x, tmin.y), tmin.z);
+            float tFar  = min(min(tmax.x, tmax.y), tmax.z);
+
+            if (tNear > tFar || tFar < 0.0) {
+                fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+                return;
+            }
+            tNear = max(tNear, 0.0);
+
+            // Ray-march: find maximum intensity
+            float maxVal = -1e30;
+            float stepSize = (tFar - tNear) / float(u_steps);
+            for (int i = 0; i < 512; i++) {
+                if (i >= u_steps) break;
+                float t = tNear + (float(i) + 0.5) * stepSize;
+                vec3 pos = rayOri + t * rayDir;
+                // Map to texture coords [0,1]
+                vec3 tc = pos / u_volSize + 0.5;
+                float val = texture(u_volume, tc).r;
+                maxVal = max(maxVal, val);
+            }
+
+            // Windowing
+            float intensity = clamp((maxVal - u_vmin) / (u_vmax - u_vmin + 1e-10), 0.0, 1.0);
+
+            // Colormap lookup
+            vec3 color = texture(u_lut, vec2(intensity, 0.5)).rgb;
+            fragColor = vec4(color, 1.0);
+        }`;
+
+        function _mipBuildRotationMatrix(az, el) {
+            const ca = Math.cos(az), sa = Math.sin(az);
+            const ce = Math.cos(el), se = Math.sin(el);
+            // Rotation: first azimuth around Y, then elevation around X
+            return [
+                ca,      sa * se,   sa * ce,
+                0,       ce,       -se,
+               -sa,      ca * se,   ca * ce,
+            ];
+        }
+
+        function _mipInitGL() {
+            const canvas = document.getElementById('mip-canvas');
+            if (_mipGL) return _mipGL;
+            const gl = canvas.getContext('webgl2', { antialias: false, alpha: false });
+            if (!gl) { showStatus('WebGL2 not available'); return null; }
+            gl.getExtension('OES_texture_float_linear');  // required for LINEAR filtering on R32F textures
+            _mipGL = gl;
+
+            // Compile shaders
+            function compile(type, src) {
+                const s = gl.createShader(type);
+                gl.shaderSource(s, src);
+                gl.compileShader(s);
+                if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
+                    console.error('MIP shader error:', gl.getShaderInfoLog(s));
+                    return null;
+                }
+                return s;
+            }
+            const vs = compile(gl.VERTEX_SHADER, _MIP_VERT_SRC);
+            const fs = compile(gl.FRAGMENT_SHADER, _MIP_FRAG_SRC);
+            const prog = gl.createProgram();
+            gl.attachShader(prog, vs);
+            gl.attachShader(prog, fs);
+            gl.linkProgram(prog);
+            if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {
+                console.error('MIP program link error:', gl.getProgramInfoLog(prog));
+                return null;
+            }
+            _mipProgram = prog;
+
+            // Full-screen quad VAO
+            _mipVAO = gl.createVertexArray();
+            gl.bindVertexArray(_mipVAO);
+            const buf = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+            gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+                -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1
+            ]), gl.STATIC_DRAW);
+            const loc = gl.getAttribLocation(prog, 'a_pos');
+            gl.enableVertexAttribArray(loc);
+            gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);
+            gl.bindVertexArray(null);
+
+            // Create LUT texture
+            _mipLutTex = gl.createTexture();
+            gl.activeTexture(gl.TEXTURE1);
+            gl.bindTexture(gl.TEXTURE_2D, _mipLutTex);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+            return gl;
+        }
+
+        function _mipBuildLUT() {
+            const gl = _mipGL;
+            if (!gl || !_mipLutTex) return;
+            const stops = colormap_idx === -1 ? customGradientStops : COLORMAP_GRADIENT_STOPS[COLORMAPS[colormap_idx]];
+            if (!stops || !stops.length) return;
+
+            // Build 256-wide RGBA LUT from gradient stops
+            // Stops are [r, g, b] triplets evenly spaced across the colormap
+            const lutSize = 256;
+            const data = new Uint8Array(lutSize * 4);
+            const n = stops.length;
+
+            for (let i = 0; i < lutSize; i++) {
+                const t = i / (lutSize - 1) * (n - 1);
+                const lo = Math.floor(t);
+                const hi = Math.min(lo + 1, n - 1);
+                const f = t - lo;
+                data[i * 4 + 0] = Math.round(stops[lo][0] + (stops[hi][0] - stops[lo][0]) * f);
+                data[i * 4 + 1] = Math.round(stops[lo][1] + (stops[hi][1] - stops[lo][1]) * f);
+                data[i * 4 + 2] = Math.round(stops[lo][2] + (stops[hi][2] - stops[lo][2]) * f);
+                data[i * 4 + 3] = 255;
+            }
+
+            gl.activeTexture(gl.TEXTURE1);
+            gl.bindTexture(gl.TEXTURE_2D, _mipLutTex);
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, lutSize, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+        }
+
+        function _mipUploadVolume(float32Data, shape) {
+            const gl = _mipGL;
+            if (!gl) return;
+            if (_mipVolTex) gl.deleteTexture(_mipVolTex);
+            _mipVolTex = gl.createTexture();
+            _mipVolShape = shape;
+            gl.activeTexture(gl.TEXTURE0);
+            gl.bindTexture(gl.TEXTURE_3D, _mipVolTex);
+            gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
+            gl.texImage3D(gl.TEXTURE_3D, 0, gl.R32F,
+                shape[2], shape[1], shape[0],   // width=Z, height=Y, depth=X  → texture(tc) where tc.xyz maps to [col, row, slice]
+                0, gl.RED, gl.FLOAT, float32Data);
+        }
+
+        function _mipRender() {
+            const gl = _mipGL;
+            if (!gl || !_mipProgram || !_mipVolTex) return;
+
+            const canvas = document.getElementById('mip-canvas');
+            const dpr = window.devicePixelRatio || 1;
+            const w = canvas.clientWidth;
+            const h = canvas.clientHeight;
+            if (canvas.width !== w * dpr || canvas.height !== h * dpr) {
+                canvas.width = w * dpr;
+                canvas.height = h * dpr;
+            }
+            gl.viewport(0, 0, canvas.width, canvas.height);
+
+            gl.clearColor(0, 0, 0, 1);
+            gl.clear(gl.COLOR_BUFFER_BIT);
+
+            gl.useProgram(_mipProgram);
+
+            // Volume size: normalize so longest side = 1
+            // Texture layout: width=shape[2], height=shape[1], depth=shape[0]
+            // World-space axes: x=width(shape[2]), y=height(shape[1]), z=depth(shape[0])
+            const s = _mipVolShape;
+            const maxS = Math.max(s[0], s[1], s[2]);
+            const volSize = [s[2] / maxS, s[1] / maxS, s[0] / maxS];
+
+            // Uniforms
+            const rotMat = _mipBuildRotationMatrix(_mipAzimuth, _mipElevation);
+
+            gl.uniform3f(gl.getUniformLocation(_mipProgram, 'u_volSize'), volSize[0], volSize[1], volSize[2]);
+            gl.uniform1f(gl.getUniformLocation(_mipProgram, 'u_vmin'), manualVmin ?? currentVmin);
+            gl.uniform1f(gl.getUniformLocation(_mipProgram, 'u_vmax'), manualVmax ?? currentVmax);
+            gl.uniformMatrix3fv(gl.getUniformLocation(_mipProgram, 'u_rotation'), false, rotMat);
+            gl.uniform1f(gl.getUniformLocation(_mipProgram, 'u_camDist'), _mipZoom);
+            gl.uniform1i(gl.getUniformLocation(_mipProgram, 'u_steps'), 256);
+
+            gl.activeTexture(gl.TEXTURE0);
+            gl.bindTexture(gl.TEXTURE_3D, _mipVolTex);
+            gl.uniform1i(gl.getUniformLocation(_mipProgram, 'u_volume'), 0);
+
+            gl.activeTexture(gl.TEXTURE1);
+            gl.bindTexture(gl.TEXTURE_2D, _mipLutTex);
+            gl.uniform1i(gl.getUniformLocation(_mipProgram, 'u_lut'), 1);
+
+            gl.bindVertexArray(_mipVAO);
+            gl.drawArrays(gl.TRIANGLES, 0, 6);
+            gl.bindVertexArray(null);
+        }
+
+        function _mipResizeCanvas() {
+            const canvas = document.getElementById('mip-canvas');
+            const row = document.getElementById('viewer-row');
+            const w = Math.max(100, window.innerWidth - 80);
+            const h = Math.max(100, window.innerHeight - uiReserveV() - 80);
+            // Set viewer-row to contain the canvas (it collapses when mv-wrap is hidden)
+            row.style.minHeight = h + 'px';
+            canvas.style.width = w + 'px';
+            canvas.style.height = h + 'px';
+            _mipRender();
+        }
+
+        function _mipCacheKey() {
+            const dims = mvDims.join(',');
+            const extraIndices = indices.map((v, i) => mvDims.includes(i) ? '' : v).join(',');
+            return `${sid}:${dims}:${extraIndices}:${_watchDataVersion}`;
+        }
+
+        async function enterMipMode() {
+            if (mipActive) return;
+            if (!multiViewActive) { showStatus('MIP: enter multiview first (v)'); return; }
+            if (shape.length < 3) { showStatus('MIP: need at least 3D array'); return; }
+
+            mipActive = true;
+            _eggsVisible = true;
+
+            // Hide multiview panes, show MIP canvas
+            const wrap = document.getElementById('multi-view-wrap');
+            wrap.style.display = 'none';
+            const canvas = document.getElementById('mip-canvas');
+            canvas.style.display = 'block';
+
+            // Show shared colorbar for MIP mode (mv-cb is inside hidden wrap)
+            _reconcileCbVisibility();
+            drawSlimColorbar(cbMarkerFrac);
+
+            showStatus('Loading volume...');
+            renderEggs();
+
+            // Init WebGL
+            const gl = _mipInitGL();
+            if (!gl) { exitMipMode(); return; }
+
+            // Fetch volume data
+            const cacheKey = _mipCacheKey();
+            if (_mipVolCacheKey !== cacheKey || !_mipVolTex) {
+                try {
+                    const dims = mvDims.join(',');
+                    const idxStr = indices.join(',');
+                    const resp = await proxyFetch(`/volume_data/${sid}?dims=${dims}&indices=${idxStr}&complex_mode=${complexMode}`);
+                    if (!resp.ok) { showStatus('MIP: failed to load volume'); exitMipMode(); return; }
+                    const shapeStr = resp.headers.get('X-Shape');
+                    const vmin = parseFloat(resp.headers.get('X-Vmin'));
+                    const vmax = parseFloat(resp.headers.get('X-Vmax'));
+                    const volShape = shapeStr.split(',').map(Number);
+                    const buf = await resp.arrayBuffer();
+                    const f32 = new Float32Array(buf);
+
+                    _mipUploadVolume(f32, volShape);
+                    _mipVolCacheKey = cacheKey;
+
+                    // Set auto vmin/vmax if not manually overridden
+                    if (manualVmin === null) currentVmin = vmin;
+                    if (manualVmax === null) currentVmax = vmax;
+                } catch (err) {
+                    console.error('MIP volume fetch error:', err);
+                    showStatus('MIP: volume load error');
+                    exitMipMode();
+                    return;
+                }
+            }
+
+            _mipBuildLUT();
+            _mipResizeCanvas();
+
+            // Attach mouse handlers
+            _mipAttachEvents();
+
+            showStatus('MIP — drag to rotate, scroll to zoom, p/Esc to exit', 3000);
+        }
+
+        function exitMipMode() {
+            if (!mipActive) return;
+            mipActive = false;
+
+            const canvas = document.getElementById('mip-canvas');
+            canvas.style.display = 'none';
+            _mipDetachEvents();
+
+            if (_mipAnimFrame) { cancelAnimationFrame(_mipAnimFrame); _mipAnimFrame = null; }
+
+            // Show multiview again
+            const wrap = document.getElementById('multi-view-wrap');
+            wrap.style.display = '';
+            document.getElementById('viewer-row').style.minHeight = '';
+
+            // Hide shared cb, restore mv colorbar
+            _reconcileCbVisibility();
+
+            _eggsVisible = true;
+            renderEggs();
+
+            // Re-render multiview panes
+            for (const v of mvViews) mvRender(v);
+            if (window._mvColorBar) window._mvColorBar.draw();
+
+            showStatus('MIP: off');
+        }
+
+        // Mouse interaction
+        let _mipEventsBound = false;
+        function _mipAttachEvents() {
+            if (_mipEventsBound) return;
+            const canvas = document.getElementById('mip-canvas');
+            canvas.addEventListener('mousedown', _mipOnMouseDown);
+            canvas.addEventListener('mousemove', _mipOnMouseMove);
+            canvas.addEventListener('mouseup', _mipOnMouseUp);
+            canvas.addEventListener('mouseleave', _mipOnMouseUp);
+            canvas.addEventListener('wheel', _mipOnWheel, { passive: false });
+            canvas.addEventListener('contextmenu', _mipPreventDefault);
+            // Touch support
+            canvas.addEventListener('touchstart', _mipOnTouchStart, { passive: false });
+            canvas.addEventListener('touchmove', _mipOnTouchMove, { passive: false });
+            canvas.addEventListener('touchend', _mipOnTouchEnd);
+            _mipEventsBound = true;
+        }
+        function _mipDetachEvents() {
+            if (!_mipEventsBound) return;
+            const canvas = document.getElementById('mip-canvas');
+            canvas.removeEventListener('mousedown', _mipOnMouseDown);
+            canvas.removeEventListener('mousemove', _mipOnMouseMove);
+            canvas.removeEventListener('mouseup', _mipOnMouseUp);
+            canvas.removeEventListener('mouseleave', _mipOnMouseUp);
+            canvas.removeEventListener('wheel', _mipOnWheel);
+            canvas.removeEventListener('contextmenu', _mipPreventDefault);
+            canvas.removeEventListener('touchstart', _mipOnTouchStart);
+            canvas.removeEventListener('touchmove', _mipOnTouchMove);
+            canvas.removeEventListener('touchend', _mipOnTouchEnd);
+            _mipEventsBound = false;
+        }
+        function _mipPreventDefault(e) { e.preventDefault(); e.stopPropagation(); }
+        function _mipOnMouseDown(e) {
+            e.preventDefault(); e.stopPropagation();
+            _mipDragging = true;
+            _mipDragX = e.clientX;
+            _mipDragY = e.clientY;
+        }
+        function _mipOnMouseMove(e) {
+            if (!_mipDragging) return;
+            e.preventDefault(); e.stopPropagation();
+            const dx = e.clientX - _mipDragX;
+            const dy = e.clientY - _mipDragY;
+            _mipDragX = e.clientX;
+            _mipDragY = e.clientY;
+            _mipAzimuth += dx * 0.008;
+            _mipElevation = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, _mipElevation + dy * 0.008));
+            _mipRender();
+        }
+        function _mipOnMouseUp(e) {
+            _mipDragging = false;
+        }
+        function _mipOnWheel(e) {
+            e.preventDefault(); e.stopPropagation();
+            _mipZoom = Math.max(0.5, Math.min(10.0, _mipZoom + e.deltaY * 0.005));
+            _mipRender();
+        }
+        // Touch events
+        let _mipTouchPrev = null;
+        let _mipTouchDist = null;
+        function _mipOnTouchStart(e) {
+            e.preventDefault(); e.stopPropagation();
+            if (e.touches.length === 1) {
+                _mipTouchPrev = { x: e.touches[0].clientX, y: e.touches[0].clientY };
+            } else if (e.touches.length === 2) {
+                const dx = e.touches[0].clientX - e.touches[1].clientX;
+                const dy = e.touches[0].clientY - e.touches[1].clientY;
+                _mipTouchDist = Math.sqrt(dx * dx + dy * dy);
+            }
+        }
+        function _mipOnTouchMove(e) {
+            e.preventDefault(); e.stopPropagation();
+            if (e.touches.length === 1 && _mipTouchPrev) {
+                const dx = e.touches[0].clientX - _mipTouchPrev.x;
+                const dy = e.touches[0].clientY - _mipTouchPrev.y;
+                _mipTouchPrev = { x: e.touches[0].clientX, y: e.touches[0].clientY };
+                _mipAzimuth += dx * 0.008;
+                _mipElevation = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, _mipElevation + dy * 0.008));
+                _mipRender();
+            } else if (e.touches.length === 2 && _mipTouchDist !== null) {
+                const dx = e.touches[0].clientX - e.touches[1].clientX;
+                const dy = e.touches[0].clientY - e.touches[1].clientY;
+                const dist = Math.sqrt(dx * dx + dy * dy);
+                const delta = _mipTouchDist - dist;
+                _mipZoom = Math.max(0.5, Math.min(10.0, _mipZoom + delta * 0.01));
+                _mipTouchDist = dist;
+                _mipRender();
+            }
+        }
+        function _mipOnTouchEnd(e) {
+            _mipTouchPrev = null;
+            _mipTouchDist = null;
+        }
+
+        // Called when colormap changes to update the LUT texture
+        function _mipOnColormapChange() {
+            if (!mipActive || !_mipGL) return;
+            _mipBuildLUT();
+            _mipRender();
+        }
+
+        // Called when vmin/vmax changes to re-render
+        function _mipOnWindowChange() {
+            if (!mipActive || !_mipGL) return;
+            _mipRender();
+        }
+
+        // ═══════════════════════════════════════════════════════════
+        // ── End MIP renderer ─────────────────────────────────────
+        // ═══════════════════════════════════════════════════════════
+
         // --------------- qMRI mode ---------------
         function enterQmri() {
             // Auto-detect: if exactly one dim has size 3–6, use it; otherwise fall back to activeDim
@@ -13631,7 +14126,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
 
             // 1. Shared colorbar
             _sharedCbVisible = colorbarVisible() && !isCenter
-                && !multiViewActive && !compareMvActive
+                && (!multiViewActive || mipActive) && !compareMvActive
                 && !qmriActive && !compareQmriActive;
             const cbWrap = document.getElementById('slim-cb-wrap');
             if (cbWrap) cbWrap.style.display = _sharedCbVisible ? '' : 'none';
@@ -13667,25 +14162,6 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
         const _cmapStripRight = document.getElementById('colormap-strip-right');
         let _cmapStripTimer = null;
         let _cmapStripMode = 'normal'; // 'normal' | 'diff-center' | 'diff-side'
-        let _cmapInIsland = false; // true when preview is rendered inside the island
-        function _cmapIslandRestore() {
-            if (!_cmapInIsland) return;
-            _cmapInIsland = false;
-            const inlinePreview = document.getElementById('cmap-island-preview');
-            if (inlinePreview) inlinePreview.remove();
-            const cv = document.getElementById('slim-cb');
-            const triZone = document.getElementById('slim-cb-tri-zone');
-            const vminEl = document.getElementById('slim-cb-vmin');
-            const vmaxEl = document.getElementById('slim-cb-vmax');
-            if (cv) cv.style.display = '';
-            if (triZone) triZone.style.display = '';
-            // Only show flanking values if histogram is collapsed
-            if (vminEl) vminEl.style.display = primaryCb._expanded ? 'none' : '';
-            if (vmaxEl) vmaxEl.style.display = primaryCb._expanded ? 'none' : '';
-            // Redraw to restore correct state
-            _syncPrimaryCb();
-            primaryCb.draw();
-        }
         // anchorEl: optional DOM element to position the strip on (instead of default colorbar)
         // extraFadeEls: optional array of extra DOM elements to fade out alongside the anchor
         /* ── JS: Colormap Strip and Wipe/Flicker Compare Tools ───── */
@@ -13694,21 +14170,10 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
             if (!_cmapStrip || !COLORMAP_GRADIENT_STOPS) return;
             const pool = overridePool || COLORMAPS;
             const ci = overrideName ? pool.indexOf(overrideName) : (colormap_idx === -1 ? 0 : colormap_idx);
-            // Compute how many thumbs fit in available width (~76px per thumb incl gap)
+            // Compute how many thumbs fit — never wider than the colorbar
             const THUMB_W = 76;
-            let availW = 999;
-            const useIslandEarly = !anchorEl && !multiViewActive;
-            if (useIslandEarly) {
-                const col = document.getElementById('slim-cb-col');
-                if (col) availW = col.offsetWidth;
-            } else if (_fullscreenActive && compareActive) {
-                const firstInner = anchorEl ? anchorEl.closest('.compare-canvas-inner') : document.querySelector('.compare-canvas-inner');
-                const vpW = firstInner && firstInner.dataset.vpW ? parseInt(firstInner.dataset.vpW) : 0;
-                if (vpW > 0) availW = vpW;
-            } else if (_fullscreenActive) {
-                const vpEl = document.getElementById('canvas-viewport');
-                if (vpEl) availW = vpEl.offsetWidth;
-            }
+            const cbWrap = anchorEl || document.getElementById(multiViewActive ? 'mv-cb-wrap' : 'slim-cb-wrap');
+            const availW = cbWrap ? cbWrap.getBoundingClientRect().width : 999;
             const rawThumbs = Math.max(1, Math.floor(availW / THUMB_W));
             const maxThumbs = rawThumbs % 2 === 0 ? rawThumbs - 1 : rawThumbs;
             const SIDE = Math.floor((maxThumbs - 1) / 2);
@@ -13743,37 +14208,7 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                 _cmapStrip.appendChild(_makeThumb(ci + offs, offs === 0));
             }
 
-            // --- Normal mode: render inside the island instead of floating ---
-            const useIsland = !anchorEl && !multiViewActive;
-            if (useIsland) {
-                _cmapIslandRestore(); // clean up any previous inline preview
-                const col = document.getElementById('slim-cb-col');
-                const cv = document.getElementById('slim-cb');
-                const triZone = document.getElementById('slim-cb-tri-zone');
-                const vminEl = document.getElementById('slim-cb-vmin');
-                const vmaxEl = document.getElementById('slim-cb-vmax');
-                // Hide normal colorbar contents
-                if (cv) cv.style.display = 'none';
-                if (triZone) triZone.style.display = 'none';
-                if (vminEl) vminEl.style.display = 'none';
-                if (vmaxEl) vmaxEl.style.display = 'none';
-                // Create inline preview container and move strip content into it
-                const preview = document.createElement('div');
-                preview.id = 'cmap-island-preview';
-                preview.style.cssText = 'display:flex;flex-direction:row;align-items:center;justify-content:center;gap:8px;width:100%;flex:1;overflow:hidden;mask-image:linear-gradient(to right, transparent, black 15%, black 85%, transparent);-webkit-mask-image:linear-gradient(to right, transparent, black 15%, black 85%, transparent);';
-                while (_cmapStrip.firstChild) {
-                    preview.appendChild(_cmapStrip.firstChild);
-                }
-                col.appendChild(preview);
-                _cmapInIsland = true;
-                clearTimeout(_cmapStripTimer);
-                _cmapStripTimer = setTimeout(() => {
-                    _cmapIslandRestore();
-                }, 1500);
-                return;
-            }
-
-            // --- Anchored / multiview modes: floating strip (original behavior) ---
+            // --- Floating strip positioned on the colorbar (or custom anchor) ---
             const hasRightAnchor = extraFadeEls && extraFadeEls.length > 0 && extraFadeEls[0] && _cmapStripRight;
             if (hasRightAnchor) {
                 for (let offs = -SIDE; offs <= SIDE; offs++) {
@@ -13781,21 +14216,22 @@ h1{font-size:22px;border-bottom:1px solid #2c2c2c;padding-bottom:12px;}</style><
                 }
             }
             // Position strip centered on the colorbar (or custom anchor)
-            const cbWrap = anchorEl || document.getElementById(multiViewActive ? 'mv-cb-wrap' : 'slim-cb-wrap');
             if (cbWrap) {
                 const cbRect = cbWrap.getBoundingClientRect();
-                _cmapStrip.style.top = (cbRect.top + cbRect.height / 2 - 16) + 'px';
+                _cmapStrip.style.top = (cbRect.top + (cbRect.height - 32) / 2) + 'px';
                 _cmapStrip.style.left = (cbRect.left + cbRect.width / 2) + 'px';
                 _cmapStrip.style.transform = 'translateX(-50%)';
+                _cmapStrip.style.maxWidth = cbRect.width + 'px';
                 cbWrap.style.opacity = '0';
             }
             // Position right strip on the right pane's colorbar
             if (hasRightAnchor) {
                 const rightAnchor = extraFadeEls[0];
                 const rRect = rightAnchor.getBoundingClientRect();
-                _cmapStripRight.style.top = (rRect.top + rRect.height / 2 - 16) + 'px';
+                _cmapStripRight.style.top = (rRect.top + (rRect.height - 32) / 2) + 'px';
                 _cmapStripRight.style.left = (rRect.left + rRect.width / 2) + 'px';
                 _cmapStripRight.style.transform = 'translateX(-50%)';
+                _cmapStripRight.style.maxWidth = rRect.width + 'px';
                 rightAnchor.style.opacity = '0';
                 for (let i = 1; i < extraFadeEls.length; i++) {
                     if (extraFadeEls[i]) extraFadeEls[i].style.opacity = '0';

{arrayview-0.9.0 → arrayview-0.10.0}/uv.lock

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