@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.0

package/esm2022/lib/implementations/napari-js/napari-tile-client.mjs

@@ -0,0 +1,562 @@
+import { from, of } from 'rxjs';
+import { saveAs } from 'file-saver';
+import { LruCache, assembleVolume, bitmapToScalar, chooseStitchLevel, decodeImageRGBA, readLevel, } from 'napari-js';
+import { buildTileUrl, exportTiffFilename, exportTiffUrl, fetchJsonWithAuth, fetchWithAuth, isAbortError, nativeHistogram, pollDescriptor, tilesInfoUrl, } from '../tile-server';
+import { DESCRIPTOR_POLL_INTERVAL_MS, DESCRIPTOR_TIMEOUT_MS, MAX_STITCH_TILES, MAX_TEXTURE_DIM, RGB_BAND_CACHE_TILES, STITCH_BUDGET_COEFF, TILE_FETCH_CONCURRENCY, TILE_SIZE, VOLUME_FETCH_CONCURRENCY, VOLUME_MAX_SLICE, create2dCanvas, splitRgbBands, stackDepth, } from './napari-helpers';
+/** Decode an `ImageBitmap` to a single-channel uint8 luminance plane with napari-js's
+ *  `bitmapToScalar` (server bands are grey, R=G=B, and decode exactly; a colour composite
+ *  becomes its BT.601 luminance). `maxSide` caps the longest side (downscaling on the canvas
+ *  draw) — used to keep pre-loaded surface slice planes small. Closes the bitmap. */
+export function bitmapToLuminance(bmp, maxSide) {
+    const plane = bitmapToScalar(bmp, { maxSide, weights: 'bt601' });
+    bmp.close?.();
+    return plane;
+}
+/** A colour tile's R, G and B bands (closes a bitmap tile). */
+function chunkToBands(chunk) {
+    if (typeof ImageBitmap !== 'undefined' && chunk.data instanceof ImageBitmap) {
+        const bmp = chunk.data;
+        try {
+            return splitRgbBands(decodeImageRGBA(bmp));
+        }
+        finally {
+            bmp.close?.();
+        }
+    }
+    return splitRgbBands({ data: chunk.data, width: chunk.width, height: chunk.height });
+}
+/**
+ * The napari-js backend's client of the jit-service tile server (review Appendix B, step 2), on
+ * the shared `tile-server/` protocol: the `/tiles/info` descriptor (polled, cached per source,
+ * shared between concurrent callers), whole-slice reads from the pyramid (napari-js `readLevel`), the pyramidal
+ * {@link TiledSource}s the 2D image draws, volume assembly, surface planes, the native `/histogram`
+ * and the `/export/tiff` download.
+ *
+ * The image is always passed in — the client never reads which image the service has loaded —
+ * so a descriptor can only ever describe the image a caller asked about (NAPARI-SVC-2).
+ *
+ * Scene-scoped state (the poll in flight, the sources that answered "no", the native histograms)
+ * lives until {@link startScene}; the descriptor cache itself survives scenes, keyed by source.
+ */
+export class NapariTileClient {
+    constructor(tiles, simpleStack, api) {
+        this.tiles = tiles;
+        this.simpleStack = simpleStack;
+        this.api = api;
+        /** Cached `/tiles/info` pyramid descriptor + the infoB64 it was fetched for. */
+        this.descriptor = null;
+        this.descriptorKey = null;
+        /** The poll in flight, shared by every caller asking for the same `infoB64`. */
+        this.descriptorPoll = null;
+        /** `infoB64`s this scene's poll got no descriptor for (non-202 status, empty body, timeout).
+         *  Scene-scoped, so a re-plot retries a slow or flaky server once. */
+        this.descriptorMisses = new Set();
+        /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}` (>8-bit images). */
+        this.nativeHistograms = new Map();
+        /** The current scene's lifetime: a poll started under it ends when it is aborted. */
+        this.scene = new AbortController().signal;
+    }
+    /** Whether `info` is a self-contained stack (`tiled:false`: each slice its own file, no
+     *  server pyramid). */
+    isSimple(info) {
+        return this.simpleStack.isSimple(info);
+    }
+    /** A new scene: forget the scene-scoped state and poll under `signal` from now on. */
+    startScene(signal) {
+        this.scene = signal;
+        this.descriptorPoll = null;
+        this.descriptorMisses.clear();
+        this.nativeHistograms.clear();
+    }
+    /**
+     * Fetch + cache the server pyramid descriptor (`GET /tiles/info`): the REAL per-level tile grid,
+     * tile size, channel metadata and physical pixel size. The backend returns 202 while the source
+     * is still caching, so we poll ({@link pollDescriptor}). Cached per `infoB64`; returns null if it
+     * never becomes ready, or the server will not describe the source (callers fall back to a
+     * single-tile fetch). Read it back through {@link currentDescriptor}. This is the authoritative
+     * grid — guessing level dims from `trueImageSize` overshoots the real grid and the server 400s
+     * out-of-range tiles.
+     */
+    ensureDescriptor(info) {
+        // Self-contained multi-slice stack (no tile server — e.g. a numbered image
+        // series assembled client-side, each slice a different file): there is no
+        // single server-tiled pyramid to describe. Returning null routes every
+        // caller (2D image, volume, surface) to their stitched/single-fetch
+        // fallback, which — via fetchImage's own SimpleSliceAccessService branch —
+        // correctly fetches each slice's own URL instead of one fixed file's tile
+        // pyramid.
+        if (this.simpleStack.isSimple(info))
+            return Promise.resolve(null);
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return Promise.resolve(null);
+        if (this.descriptor && this.descriptorKey === infoB64)
+            return Promise.resolve(this.descriptor);
+        // A source that answered "no" (or never answered) this scene is not asked again: the render,
+        // the stitch fallback and every slice would otherwise each wait out their own poll.
+        if (this.descriptorMisses.has(infoB64))
+            return Promise.resolve(null);
+        // Concurrent callers (render, navigator, histogram) share one poll.
+        if (this.descriptorPoll?.key === infoB64)
+            return this.descriptorPoll.promise;
+        const scene = this.scene;
+        const promise = this.pollDescriptor(infoB64, scene).then((desc) => {
+            if (this.descriptorPoll?.promise === promise)
+                this.descriptorPoll = null;
+            if (desc) {
+                this.descriptor = desc;
+                this.descriptorKey = infoB64;
+            }
+            else if (!scene.aborted) {
+                this.descriptorMisses.add(infoB64);
+            }
+            return desc;
+        });
+        this.descriptorPoll = { key: infoB64, promise };
+        return promise;
+    }
+    /**
+     * The `/tiles/info` loop behind {@link ensureDescriptor}: the shared jit-service poll
+     * (`tile-server/pollDescriptor`). Re-polls only on 202 (the server is still caching the source);
+     * any other status means this server will not describe it, so the answer is null at once. Each
+     * request gives up after its own timeout — a hung request would otherwise never reach the
+     * deadline check — and the whole poll ends (null) as soon as `scene` is aborted.
+     */
+    async pollDescriptor(infoB64, scene) {
+        try {
+            return await pollDescriptor(fetchJsonWithAuth(this.tiles), tilesInfoUrl(this.api, infoB64), {
+                deadlineMs: DESCRIPTOR_TIMEOUT_MS,
+                intervalMs: DESCRIPTOR_POLL_INTERVAL_MS,
+                signal: scene,
+                tag: '[napari-js]',
+            });
+        }
+        catch (err) {
+            if (isAbortError(err))
+                return null; // the scene was reset
+            throw err;
+        }
+    }
+    /**
+     * The pyramid descriptor of `info`, or null when it has none.
+     *
+     * The cache is keyed by `infoB64` and survives image switches and failed polls, so reading it
+     * directly would hand a `tiled:false` stack (or an image whose poll never answered) the
+     * PREVIOUS image's size, µm/pixel, tile size and bit depth. Every read site goes through here.
+     */
+    currentDescriptor(info) {
+        if (!this.descriptor || this.simpleStack.isSimple(info))
+            return null;
+        return this.descriptorKey === this.tiles.getSelectedInfoB64() ? this.descriptor : null;
+    }
+    /** µm per pixel along x for `info`: the descriptor's, else the image metadata's; 0 when
+     *  neither declares it. */
+    mppX(info) {
+        return this.currentDescriptor(info)?.mppX || info?.imageMeta?.[0]?.mppX || 0;
+    }
+    /**
+     * Slice `z` as ONE image, for a source with no pyramid to read: a `tiled:false` stack's own
+     * file for `z`, else (no descriptor) the server's single top-left tile — correct for
+     * small/simple images.
+     *
+     * A self-contained multi-slice stack's `z` indexes a completely different file's own preview
+     * URL, not an internal slice of one server-tiled file, so it is resolved and fetched via
+     * SimpleSliceAccessService (shared with OSD; see its docs for why this can't be a bare fetch())
+     * rather than as a /tile?info=...&z= request against whichever single file
+     * getSelectedInfoB64() points at (which would 400/mismatch for any z beyond that one file's own
+     * extent). `channel` selects a band: a serverless multichannel stack's own plane
+     * (`channelUrls[z][channel]`, the client-side analog of the server's per-channel
+     * `/tile?channel=c`), else the server's.
+     */
+    async fetchImage(info, z, channel) {
+        if (this.simpleStack.isSimple(info)) {
+            const chUrls = info.channelUrls;
+            const url = channel != null && chUrls?.[z]?.[channel] != null
+                ? chUrls[z][channel]
+                : this.simpleStack.urlFor(info, z);
+            if (!url)
+                throw new Error(`[napari-js] no URL for slice ${z}`);
+            return this.simpleStack.fetchAsBitmap(url);
+        }
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            throw new Error('[napari-js] no selected image info (getSelectedInfoB64 null)');
+        const url = buildTileUrl(this.api, infoB64, { res: 0, col: 0, row: 0, z, tileSize: TILE_SIZE, channel });
+        const resp = await fetchWithAuth(this.tiles, url);
+        if (!resp.ok)
+            throw new Error(`[napari-js] slice fetch failed: ${resp.status} (0/0 res 0)`);
+        return createImageBitmap(await resp.blob());
+    }
+    /**
+     * Slice `z` as a single-channel uint8 luminance plane. With a pyramid, napari-js's `readLevel`
+     * reads it from the same {@link tiledSource} the 2D view draws: the finest level whose tile grid
+     * fits `maxTiles` and whose longest side fits the GPU texture limit (no finer than `maxSide`
+     * needs, when given), stitched with bounded concurrency and area-averaged down to `maxSide`.
+     * Without one, the single image of {@link fetchImage}. `channel` selects a band (real levels
+     * only); omit it for the composite, whose overview levels let a large image read a small level.
+     * `compositeFallback`: see {@link planeSource}. `signal` cancels the read (it rejects).
+     */
+    async readPlane(info, z, channel, opts) {
+        // A tiled:false stack has no pyramid: fetch its slice in this tick, as the 2D render does.
+        const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);
+        if (!desc?.levels?.length)
+            return bitmapToLuminance(await this.fetchImage(info, z, channel), opts.maxSide);
+        const budget = {
+            maxTiles: opts.maxTiles,
+            maxSide: opts.maxSide,
+            maxTextureDim: MAX_TEXTURE_DIM,
+        };
+        const source = opts.compositeFallback
+            ? this.planeSource(desc, channel, budget)
+            : this.tiledSource(desc, channel, 1);
+        const img = await readLevel(source, z, {
+            ...budget,
+            concurrency: TILE_FETCH_CONCURRENCY,
+            signal: opts.signal,
+        });
+        if (!img.fits && opts.maxTiles >= MAX_STITCH_TILES) {
+            console.warn(`[napari-js] no level of slice ${z} fits the ${opts.maxTiles}-tile/${MAX_TEXTURE_DIM}px budget; ` +
+                `read the coarsest (level ${img.level}) and downscaled it to ${img.width}×${img.height}.`);
+        }
+        return { data: img.data, width: img.width, height: img.height };
+    }
+    /**
+     * The scalar source for one decimated plane of band `channel`. A band has tiles only at the
+     * (few, large) real Bio-Formats levels; when none of them fits the budget — e.g. the coarsest
+     * real level is still 14982×18670, ~1100 full-res tiles — stitching it per slice floods the
+     * server (504s) and stalls the load. The composite pyramid has small overview levels, so the
+     * plane is read from the composite instead (its luminance). Only for a caller that wants one
+     * decimated plane (the surface height): for a multichannel VOLUME every channel would then read
+     * the same composite and the channels would collapse into one, so volumes keep each band.
+     */
+    planeSource(desc, channel, budget) {
+        const band = this.tiledSource(desc, channel, 1);
+        if (channel == null || desc.levels.length <= (desc.realLevels ?? desc.levels.length))
+            return band;
+        const own = chooseStitchLevel(band, budget);
+        if (own.fits)
+            return band;
+        const composite = this.tiledSource(desc, undefined, 1);
+        const alt = chooseStitchLevel(composite, budget);
+        if (!alt.fits && alt.cols * alt.rows >= own.cols * own.rows)
+            return band;
+        console.warn(`[napari-js] channel ${channel} has no pyramid level within the ${budget.maxTiles}-tile ` +
+            `budget; using the composite overview (${alt.width}×${alt.height}) for this plane.`);
+        return composite;
+    }
+    /**
+     * A small picture of the whole slice for the navigator: the composite (or band `channel`) at the
+     * finest level a single tile holds, else the coarsest level, as an RGBA canvas. Without a
+     * pyramid, the single image of {@link fetchImage}.
+     */
+    async overviewImage(info, z, channel) {
+        const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);
+        if (!desc?.levels?.length)
+            return this.fetchImage(info, z, channel);
+        const img = await readLevel(this.tiledSource(desc, channel, 4), z, {
+            maxTiles: 1,
+            maxTextureDim: MAX_TEXTURE_DIM,
+            concurrency: TILE_FETCH_CONCURRENCY,
+        });
+        const { canvas, ctx } = create2dCanvas(img.width, img.height, 'overview');
+        const pixels = ctx.createImageData(img.width, img.height);
+        pixels.data.set(img.data);
+        ctx.putImageData(pixels, 0, 0);
+        return canvas;
+    }
+    /**
+     * Slice `z`'s R, G and B bands, as three uint8 planes: the composite read as RGBA at the
+     * finest level within `maxTiles` (as {@link readPlane} picks it; 1 for a cheap overview
+     * sample), else the single image of {@link fetchImage}. The raw bands of an RGB image, for the
+     * per-band layers and their histograms.
+     */
+    async readRgbBands(info, z, maxTiles = MAX_STITCH_TILES) {
+        const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);
+        if (!desc?.levels?.length) {
+            const bmp = await this.fetchImage(info, z);
+            return chunkToBands({ width: bmp.width, height: bmp.height, data: bmp });
+        }
+        const img = await readLevel(this.tiledSource(desc, undefined, 4), z, {
+            maxTiles,
+            maxTextureDim: MAX_TEXTURE_DIM,
+            concurrency: TILE_FETCH_CONCURRENCY,
+        });
+        return splitRgbBands({ data: img.data, width: img.width, height: img.height });
+    }
+    /** Fetch slice `z` and read it back as a single-channel uint8 plane (see {@link readPlane}),
+     *  within `budgetTiles`: the 2D stitch fallback reads at the full budget, the histogram samples
+     *  at 1 for a cheap overview tile. */
+    async fetchChannelData(info, z, channel, budgetTiles = MAX_STITCH_TILES) {
+        return this.readPlane(info, z, channel, { maxTiles: budgetTiles });
+    }
+    /** Tile budget to stitch a whole slice at ~`targetPx` resolution from the pyramid. Shared by the
+     *  surface plane fetch and the volume assembly, so both cap their reads by the decimate factor. */
+    tileBudgetFor(info, targetPx) {
+        const tileSize = this.currentDescriptor(info)?.tileSize || TILE_SIZE;
+        return Math.min(MAX_STITCH_TILES, Math.max(1, Math.round((targetPx / tileSize) ** 2 * STITCH_BUDGET_COEFF)));
+    }
+    /**
+     * Build a pyramidal TiledSource backed by the server `/tile` endpoint. `channel` selects a band
+     * (grayscale luminance, real levels only); omit it for the composite (RGBA, all levels).
+     *
+     * For the 2D view, `scene` is the signal of the render that asked for it, taken before that
+     * render's awaits, and `onTile` is told of each tile request and handed back the tile's end. A
+     * request issued once `scene` is aborted (a disposed source still fetching after a reset) is not
+     * reported, and one that settles after it does not end, so it can never count toward the next
+     * scene. A tile request's own `signal` (napari-js aborts a read it no longer needs) aborts the
+     * HTTP request.
+     */
+    tiledSource(desc, channel, channels, scene, onTile) {
+        const infoB64 = this.tiles.getSelectedInfoB64() ?? '';
+        // Per-channel tiles exist only at REAL Bio-Formats levels; the composite exists at all levels.
+        const usable = channel == null ? desc.levels : desc.levels.slice(0, Math.max(1, desc.realLevels ?? desc.levels.length));
+        const levelScales = usable.map((l) => desc.width / Math.max(1, l.width)); // level-0 px per level px
+        const tileSize = desc.tileSize || TILE_SIZE;
+        const api = this.api;
+        return {
+            kind: 'tiled',
+            width: desc.width,
+            height: desc.height,
+            tileSize,
+            levels: usable.length,
+            levelScales,
+            depth: Math.max(1, desc.z || 1),
+            channels,
+            dtype: 'uint8',
+            fetchTile: async (key, signal) => {
+                const res = usable[key.level]?.res ?? key.level;
+                const url = buildTileUrl(api, infoB64, {
+                    res,
+                    col: key.col,
+                    row: key.row,
+                    z: key.z,
+                    tileSize,
+                    channel,
+                });
+                const end = !onTile || scene?.aborted ? null : onTile();
+                try {
+                    const resp = await fetchWithAuth(this.tiles, url, signal ? { signal } : {});
+                    if (!resp.ok) {
+                        throw new Error(`[napari-js] tile ${key.level}/${key.col}/${key.row} → ${resp.status}`);
+                    }
+                    const bmp = await createImageBitmap(await resp.blob());
+                    if (channels === 4)
+                        return { width: bmp.width, height: bmp.height, data: bmp };
+                    return bitmapToLuminance(bmp);
+                }
+                finally {
+                    if (!scene?.aborted)
+                        end?.();
+                }
+            },
+        };
+    }
+    /**
+     * The composite pyramid's R, G and B bands as three scalar {@link TiledSource}s — one per
+     * additive layer, so each band takes its own window, gamma, invert, tint and visibility — that
+     * share ONE `/tile` request per tile. The three layers ask for a tile in the same frame: the
+     * first fetches the RGBA tile and splits it, the other two take their band from the same
+     * promise, and the split tile is dropped once all three have it. A band that asks later (one
+     * shown again after being hidden) finds it in a small LRU, else fetches it again. `scene` and
+     * `onTile` as {@link tiledSource}: the loading badge counts the one request.
+     */
+    rgbBandSources(desc, scene, onTile) {
+        const composite = this.tiledSource(desc, undefined, 4, scene, onTile);
+        const split = new LruCache(RGB_BAND_CACHE_TILES);
+        const band = (key, b) => {
+            const id = `${key.z}/${key.level}/${key.col}/${key.row}`;
+            let entry = split.get(id);
+            if (!entry) {
+                const bands = composite.fetchTile(key).then(chunkToBands);
+                const fresh = { bands, taken: new Set() };
+                // A failed tile is not remembered: the next ask fetches it again.
+                bands.catch(() => split.get(id) === fresh && split.delete(id));
+                split.set(id, (entry = fresh));
+            }
+            entry.taken.add(b);
+            if (entry.taken.size === 3)
+                split.delete(id);
+            return entry.bands.then((planes) => planes[b]);
+        };
+        return [0, 1, 2].map((b) => ({
+            ...composite,
+            channels: 1,
+            fetchTile: (key) => band(key, b),
+        }));
+    }
+    /**
+     * Assemble a downsampled uint8 volume (luminance) of `info`'s stack with napari-js's
+     * `assembleVolume`: every `sliceStep`th slice, read from the band's (or composite's) pyramid at
+     * the level that `maxSlice` needs, within its tile budget, and area-averaged to `maxSlice` on
+     * the longest side. Slices are read with bounded concurrency (the connection pool stays full
+     * without flooding it on a deep stack), each reporting `progress` (0–100) as it lands so the host
+     * shows a determinate progress bar. Null when `signal` aborts (a Cancel or a new plot), which
+     * also aborts the tile requests in flight — a partial volume is never returned.
+     */
+    async assembleVolume(info, opts, channel, hooks) {
+        const { signal } = hooks;
+        const fullDepth = stackDepth(info) || 1;
+        const step = Math.max(1, Math.floor(opts.sliceStep ?? 1));
+        const maxSlice = opts.maxSlice ?? VOLUME_MAX_SLICE;
+        // Source-slice indices sampled into the volume (every `step`th plane → low-res is faster).
+        const zIndices = [];
+        for (let z = 0; z < fullDepth; z += step)
+            zIndices.push(z);
+        hooks.progress(0);
+        try {
+            // `channel` selects a band (multichannel volume); omit for the grayscale composite. The
+            // caller owns the stackLoading flag (multichannel assembles channels in turn).
+            const source = await this.volumeSource(info, channel, zIndices[0]);
+            return await assembleVolume(source, zIndices, {
+                maxSide: maxSlice,
+                maxTiles: this.tileBudgetFor(info, maxSlice),
+                maxTextureDim: MAX_TEXTURE_DIM,
+                concurrency: VOLUME_FETCH_CONCURRENCY,
+                tileConcurrency: TILE_FETCH_CONCURRENCY,
+                onProgress: (done, total) => hooks.progress(Math.round((done / total) * 100)),
+                signal,
+            });
+        }
+        catch (err) {
+            if (signal.aborted)
+                return null; // cancelled → don't render a partial volume
+            throw err;
+        }
+        finally {
+            hooks.progress(0);
+        }
+    }
+    /**
+     * The scalar source a volume reads: the band's (or composite's) pyramid; without one, one whole
+     * image per slice ({@link fetchImage}) as a single-tile level sized by the first slice, which is
+     * fetched here and served again as that slice's tile.
+     */
+    async volumeSource(info, channel, firstZ) {
+        const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);
+        if (desc?.levels?.length)
+            return this.tiledSource(desc, channel, 1);
+        let first = await this.fetchImage(info, firstZ, channel);
+        const source = {
+            kind: 'tiled',
+            width: first.width,
+            height: first.height,
+            tileSize: Math.max(1, first.width, first.height),
+            levels: 1,
+            depth: stackDepth(info) || 1,
+            channels: 1,
+            dtype: 'uint8',
+            fetchTile: async (key) => {
+                let bmp;
+                if (first && key.z === firstZ) {
+                    bmp = first;
+                    first = null;
+                }
+                else {
+                    bmp = await this.fetchImage(info, key.z, channel);
+                }
+                return { width: bmp.width, height: bmp.height, data: bmp };
+            },
+        };
+        return source;
+    }
+    /**
+     * Slice `z` as a single WHOLE-image luminance plane (decimated to `maxGrid`), for the surface.
+     * Prefers the server pyramid, read at the level the grid needs ({@link readPlane}, which may
+     * drop a band to the composite overview); without a descriptor, the app's complete per-slice
+     * image (`urls`/`smallUrls`, as the Plotly surface) — never a lone top-left tile, which would be
+     * a corner of the slice — and only as a last resort the single-tile fetch.
+     */
+    async fetchPlane(info, z, channel, maxGrid) {
+        const desc = await this.ensureDescriptor(info);
+        // Preferred: the WHOLE slice from the server pyramid at a resolution driven by the decimate
+        // factor — a higher target grid reads a FINER pyramid level (more real detail). This is what
+        // makes "Full" actually higher-res than "½", not just a fixed preview. The surface is a single
+        // decimated plane, so the composite fallback is acceptable when the band has no small level.
+        if (desc?.levels?.length) {
+            return this.readPlane(info, z, channel, {
+                maxTiles: this.tileBudgetFor(info, maxGrid),
+                maxSide: maxGrid,
+                compositeFallback: true,
+            });
+        }
+        // Fallback (no pyramid): the app's COMPLETE per-slice image (urls[z], not the small blurry
+        // thumbnail) — whole slice, avoids a corner tile. Capped at the image's own resolution.
+        const url = info?.urls?.[z] ?? info?.smallUrls?.[z];
+        if (url) {
+            try {
+                const resp = await fetchWithAuth(this.tiles, url);
+                if (resp.ok)
+                    return bitmapToLuminance(await createImageBitmap(await resp.blob()), maxGrid);
+            }
+            catch (err) {
+                console.warn(`[napari-js] surface url fetch failed for z=${z}`, err);
+            }
+        }
+        // Last resort (no pyramid and no complete image): the single image.
+        return bitmapToLuminance(await this.fetchImage(info, z, channel), maxGrid);
+    }
+    /**
+     * Channel `channel`'s native-bit-depth histogram at slice `z` when `info` is a >8-bit image —
+     * the displayed pixels are 8-bit, so a client histogram would be clipped — cached per
+     * `(z, channel)`; null for an 8-bit channel, which the caller bins from the client data.
+     */
+    nativeHistogram$(info, z, channel, bins) {
+        const bitDepth = this.currentDescriptor(info)?.channelInfo?.[channel]?.bitDepth ?? 8;
+        if (bitDepth <= 8)
+            return null;
+        const key = `${z}|${channel}`;
+        const cached = this.nativeHistograms.get(key);
+        if (cached)
+            return of(cached);
+        return from(this.fetchNativeHistogram(channel, bins, z, key));
+    }
+    /** Fetch + cache one channel's native-bit-depth histogram from `GET /histogram` (>8-bit),
+     *  through the shared jit-service client — whose URL carries the per-app-load cache-buster
+     *  this backend used to omit, so a reload showed the server's 24 h-cached histogram. */
+    async fetchNativeHistogram(channel, bins, z, key) {
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return null;
+        try {
+            const out = await nativeHistogram(fetchJsonWithAuth(this.tiles), this.api, infoB64, {
+                z,
+                channel,
+                bins,
+            });
+            if (!out)
+                return null; // 202 (still caching) or transient → null; the pane retries
+            this.nativeHistograms.set(key, out);
+            return out;
+        }
+        catch (err) {
+            console.warn('[napari-js] native histogram fetch failed', err);
+            return null;
+        }
+    }
+    /** Native-bit-depth (16/32-bit) multi-band TIFF export of slice `z` via the server
+     *  `/export/tiff` endpoint — the displayed PNG is an 8-bit figure, this preserves the true pixel
+     *  values. Visible channels only (omitted when all are visible → server default). Mirrors the
+     *  OSD backend. */
+    async exportTiff(z, states, fileName) {
+        const infoB64 = this.tiles.getSelectedInfoB64();
+        if (!infoB64)
+            return;
+        const visible = states.filter((c) => c.visible).map((c) => c.index);
+        const url = exportTiffUrl(this.api, infoB64, z, visible, states.length);
+        const saveName = exportTiffFilename(fileName);
+        try {
+            const resp = await fetchWithAuth(this.tiles, url);
+            if (resp.status === 202) {
+                console.warn('[napari-js] 16-bit export: file still caching — try again shortly.');
+                return;
+            }
+            if (!resp.ok)
+                throw new Error(`status ${resp.status}`);
+            saveAs(await resp.blob(), saveName);
+        }
+        catch (err) {
+            console.warn('[napari-js] 16-bit TIFF export failed', err);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-tile-client.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-tile-client.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, from, of } from 'rxjs';\nimport { saveAs } from 'file-saver';\nimport {\n  LruCache,\n  assembleVolume,\n  bitmapToScalar,\n  chooseStitchLevel,\n  decodeImageRGBA,\n  readLevel,\n} from 'napari-js';\nimport type { PixelChunk, StitchBudget, TileKey, TiledSource } from 'napari-js';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IChannelState, IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { TileAccessPort } from '../../contracts/ports/tile-access.port';\nimport { SimpleSliceAccessService } from '../simple-slice-access.service';\nimport {\n  TileDescriptor,\n  buildTileUrl,\n  exportTiffFilename,\n  exportTiffUrl,\n  fetchJsonWithAuth,\n  fetchWithAuth,\n  isAbortError,\n  nativeHistogram,\n  pollDescriptor,\n  tilesInfoUrl,\n} from '../tile-server';\nimport {\n  DESCRIPTOR_POLL_INTERVAL_MS,\n  DESCRIPTOR_TIMEOUT_MS,\n  LumaPlane,\n  MAX_STITCH_TILES,\n  MAX_TEXTURE_DIM,\n  RGB_BAND_CACHE_TILES,\n  STITCH_BUDGET_COEFF,\n  TILE_FETCH_CONCURRENCY,\n  TILE_SIZE,\n  VOLUME_FETCH_CONCURRENCY,\n  VOLUME_MAX_SLICE,\n  create2dCanvas,\n  splitRgbBands,\n  stackDepth,\n} from './napari-helpers';\n\n/** What the navigator draws: a whole-slice picture (a canvas read from the pyramid, or a bitmap). */\nexport type OverviewImage = ImageBitmap | HTMLCanvasElement | OffscreenCanvas;\n\n/** An assembled uint8 (luminance) volume, x-fastest then y then z. */\nexport interface AssembledVolume {\n  data: Uint8Array;\n  width: number;\n  height: number;\n  depth: number;\n}\n\n/** Decode an `ImageBitmap` to a single-channel uint8 luminance plane with napari-js's\n *  `bitmapToScalar` (server bands are grey, R=G=B, and decode exactly; a colour composite\n *  becomes its BT.601 luminance). `maxSide` caps the longest side (downscaling on the canvas\n *  draw) — used to keep pre-loaded surface slice planes small. Closes the bitmap. */\nexport function bitmapToLuminance(bmp: ImageBitmap, maxSide?: number): LumaPlane {\n  const plane = bitmapToScalar(bmp, { maxSide, weights: 'bt601' });\n  bmp.close?.();\n  return plane;\n}\n\n/** A colour tile's R, G and B bands (closes a bitmap tile). */\nfunction chunkToBands(chunk: PixelChunk): LumaPlane[] {\n  if (typeof ImageBitmap !== 'undefined' && chunk.data instanceof ImageBitmap) {\n    const bmp = chunk.data;\n    try {\n      return splitRgbBands(decodeImageRGBA(bmp));\n    } finally {\n      bmp.close?.();\n    }\n  }\n  return splitRgbBands({ data: chunk.data as Uint8Array, width: chunk.width, height: chunk.height });\n}\n\n/**\n * The napari-js backend's client of the jit-service tile server (review Appendix B, step 2), on\n * the shared `tile-server/` protocol: the `/tiles/info` descriptor (polled, cached per source,\n * shared between concurrent callers), whole-slice reads from the pyramid (napari-js `readLevel`), the pyramidal\n * {@link TiledSource}s the 2D image draws, volume assembly, surface planes, the native `/histogram`\n * and the `/export/tiff` download.\n *\n * The image is always passed in — the client never reads which image the service has loaded —\n * so a descriptor can only ever describe the image a caller asked about (NAPARI-SVC-2).\n *\n * Scene-scoped state (the poll in flight, the sources that answered \"no\", the native histograms)\n * lives until {@link startScene}; the descriptor cache itself survives scenes, keyed by source.\n */\nexport class NapariTileClient {\n  /** Cached `/tiles/info` pyramid descriptor + the infoB64 it was fetched for. */\n  private descriptor: TileDescriptor | null = null;\n  private descriptorKey: string | null = null;\n  /** The poll in flight, shared by every caller asking for the same `infoB64`. */\n  private descriptorPoll: { key: string; promise: Promise<TileDescriptor | null> } | null = null;\n  /** `infoB64`s this scene's poll got no descriptor for (non-202 status, empty body, timeout).\n   *  Scene-scoped, so a re-plot retries a slow or flaky server once. */\n  private readonly descriptorMisses = new Set<string>();\n  /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}` (>8-bit images). */\n  private readonly nativeHistograms = new Map<string, IHistogram>();\n  /** The current scene's lifetime: a poll started under it ends when it is aborted. */\n  private scene: AbortSignal = new AbortController().signal;\n\n  constructor(\n    private readonly tiles: TileAccessPort,\n    private readonly simpleStack: SimpleSliceAccessService,\n    private readonly api: string,\n  ) {}\n\n  /** Whether `info` is a self-contained stack (`tiled:false`: each slice its own file, no\n   *  server pyramid). */\n  isSimple(info: IImageInfo | undefined): boolean {\n    return this.simpleStack.isSimple(info);\n  }\n\n  /** A new scene: forget the scene-scoped state and poll under `signal` from now on. */\n  startScene(signal: AbortSignal): void {\n    this.scene = signal;\n    this.descriptorPoll = null;\n    this.descriptorMisses.clear();\n    this.nativeHistograms.clear();\n  }\n\n  /**\n   * Fetch + cache the server pyramid descriptor (`GET /tiles/info`): the REAL per-level tile grid,\n   * tile size, channel metadata and physical pixel size. The backend returns 202 while the source\n   * is still caching, so we poll ({@link pollDescriptor}). Cached per `infoB64`; returns null if it\n   * never becomes ready, or the server will not describe the source (callers fall back to a\n   * single-tile fetch). Read it back through {@link currentDescriptor}. This is the authoritative\n   * grid — guessing level dims from `trueImageSize` overshoots the real grid and the server 400s\n   * out-of-range tiles.\n   */\n  ensureDescriptor(info: IImageInfo | undefined): Promise<TileDescriptor | null> {\n    // Self-contained multi-slice stack (no tile server — e.g. a numbered image\n    // series assembled client-side, each slice a different file): there is no\n    // single server-tiled pyramid to describe. Returning null routes every\n    // caller (2D image, volume, surface) to their stitched/single-fetch\n    // fallback, which — via fetchImage's own SimpleSliceAccessService branch —\n    // correctly fetches each slice's own URL instead of one fixed file's tile\n    // pyramid.\n    if (this.simpleStack.isSimple(info)) return Promise.resolve(null);\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return Promise.resolve(null);\n    if (this.descriptor && this.descriptorKey === infoB64) return Promise.resolve(this.descriptor);\n    // A source that answered \"no\" (or never answered) this scene is not asked again: the render,\n    // the stitch fallback and every slice would otherwise each wait out their own poll.\n    if (this.descriptorMisses.has(infoB64)) return Promise.resolve(null);\n    // Concurrent callers (render, navigator, histogram) share one poll.\n    if (this.descriptorPoll?.key === infoB64) return this.descriptorPoll.promise;\n    const scene = this.scene;\n    const promise = this.pollDescriptor(infoB64, scene).then((desc) => {\n      if (this.descriptorPoll?.promise === promise) this.descriptorPoll = null;\n      if (desc) {\n        this.descriptor = desc;\n        this.descriptorKey = infoB64;\n      } else if (!scene.aborted) {\n        this.descriptorMisses.add(infoB64);\n      }\n      return desc;\n    });\n    this.descriptorPoll = { key: infoB64, promise };\n    return promise;\n  }\n\n  /**\n   * The `/tiles/info` loop behind {@link ensureDescriptor}: the shared jit-service poll\n   * (`tile-server/pollDescriptor`). Re-polls only on 202 (the server is still caching the source);\n   * any other status means this server will not describe it, so the answer is null at once. Each\n   * request gives up after its own timeout — a hung request would otherwise never reach the\n   * deadline check — and the whole poll ends (null) as soon as `scene` is aborted.\n   */\n  private async pollDescriptor(infoB64: string, scene: AbortSignal): Promise<TileDescriptor | null> {\n    try {\n      return await pollDescriptor(fetchJsonWithAuth(this.tiles), tilesInfoUrl(this.api, infoB64), {\n        deadlineMs: DESCRIPTOR_TIMEOUT_MS,\n        intervalMs: DESCRIPTOR_POLL_INTERVAL_MS,\n        signal: scene,\n        tag: '[napari-js]',\n      });\n    } catch (err) {\n      if (isAbortError(err)) return null; // the scene was reset\n      throw err;\n    }\n  }\n\n  /**\n   * The pyramid descriptor of `info`, or null when it has none.\n   *\n   * The cache is keyed by `infoB64` and survives image switches and failed polls, so reading it\n   * directly would hand a `tiled:false` stack (or an image whose poll never answered) the\n   * PREVIOUS image's size, µm/pixel, tile size and bit depth. Every read site goes through here.\n   */\n  currentDescriptor(info: IImageInfo | undefined): TileDescriptor | null {\n    if (!this.descriptor || this.simpleStack.isSimple(info)) return null;\n    return this.descriptorKey === this.tiles.getSelectedInfoB64() ? this.descriptor : null;\n  }\n\n  /** µm per pixel along x for `info`: the descriptor's, else the image metadata's; 0 when\n   *  neither declares it. */\n  mppX(info: IImageInfo | undefined): number {\n    return this.currentDescriptor(info)?.mppX || info?.imageMeta?.[0]?.mppX || 0;\n  }\n\n  /**\n   * Slice `z` as ONE image, for a source with no pyramid to read: a `tiled:false` stack's own\n   * file for `z`, else (no descriptor) the server's single top-left tile — correct for\n   * small/simple images.\n   *\n   * A self-contained multi-slice stack's `z` indexes a completely different file's own preview\n   * URL, not an internal slice of one server-tiled file, so it is resolved and fetched via\n   * SimpleSliceAccessService (shared with OSD; see its docs for why this can't be a bare fetch())\n   * rather than as a /tile?info=...&z= request against whichever single file\n   * getSelectedInfoB64() points at (which would 400/mismatch for any z beyond that one file's own\n   * extent). `channel` selects a band: a serverless multichannel stack's own plane\n   * (`channelUrls[z][channel]`, the client-side analog of the server's per-channel\n   * `/tile?channel=c`), else the server's.\n   */\n  async fetchImage(info: IImageInfo | undefined, z: number, channel?: number): Promise<ImageBitmap> {\n    if (this.simpleStack.isSimple(info)) {\n      const chUrls = (info as IImageInfo).channelUrls;\n      const url =\n        channel != null && chUrls?.[z]?.[channel] != null\n          ? chUrls[z][channel]\n          : this.simpleStack.urlFor(info as IImageInfo, z);\n      if (!url) throw new Error(`[napari-js] no URL for slice ${z}`);\n      return this.simpleStack.fetchAsBitmap(url);\n    }\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) throw new Error('[napari-js] no selected image info (getSelectedInfoB64 null)');\n    const url = buildTileUrl(this.api, infoB64, { res: 0, col: 0, row: 0, z, tileSize: TILE_SIZE, channel });\n    const resp = await fetchWithAuth(this.tiles, url);\n    if (!resp.ok) throw new Error(`[napari-js] slice fetch failed: ${resp.status} (0/0 res 0)`);\n    return createImageBitmap(await resp.blob());\n  }\n\n  /**\n   * Slice `z` as a single-channel uint8 luminance plane. With a pyramid, napari-js's `readLevel`\n   * reads it from the same {@link tiledSource} the 2D view draws: the finest level whose tile grid\n   * fits `maxTiles` and whose longest side fits the GPU texture limit (no finer than `maxSide`\n   * needs, when given), stitched with bounded concurrency and area-averaged down to `maxSide`.\n   * Without one, the single image of {@link fetchImage}. `channel` selects a band (real levels\n   * only); omit it for the composite, whose overview levels let a large image read a small level.\n   * `compositeFallback`: see {@link planeSource}. `signal` cancels the read (it rejects).\n   */\n  async readPlane(\n    info: IImageInfo | undefined,\n    z: number,\n    channel: number | undefined,\n    opts: { maxTiles: number; maxSide?: number; compositeFallback?: boolean; signal?: AbortSignal },\n  ): Promise<LumaPlane> {\n    // A tiled:false stack has no pyramid: fetch its slice in this tick, as the 2D render does.\n    const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);\n    if (!desc?.levels?.length) return bitmapToLuminance(await this.fetchImage(info, z, channel), opts.maxSide);\n    const budget: StitchBudget = {\n      maxTiles: opts.maxTiles,\n      maxSide: opts.maxSide,\n      maxTextureDim: MAX_TEXTURE_DIM,\n    };\n    const source = opts.compositeFallback\n      ? this.planeSource(desc, channel, budget)\n      : this.tiledSource(desc, channel, 1);\n    const img = await readLevel(source, z, {\n      ...budget,\n      concurrency: TILE_FETCH_CONCURRENCY,\n      signal: opts.signal,\n    });\n    if (!img.fits && opts.maxTiles >= MAX_STITCH_TILES) {\n      console.warn(\n        `[napari-js] no level of slice ${z} fits the ${opts.maxTiles}-tile/${MAX_TEXTURE_DIM}px budget; ` +\n          `read the coarsest (level ${img.level}) and downscaled it to ${img.width}×${img.height}.`,\n      );\n    }\n    return { data: img.data as Uint8Array, width: img.width, height: img.height };\n  }\n\n  /**\n   * The scalar source for one decimated plane of band `channel`. A band has tiles only at the\n   * (few, large) real Bio-Formats levels; when none of them fits the budget — e.g. the coarsest\n   * real level is still 14982×18670, ~1100 full-res tiles — stitching it per slice floods the\n   * server (504s) and stalls the load. The composite pyramid has small overview levels, so the\n   * plane is read from the composite instead (its luminance). Only for a caller that wants one\n   * decimated plane (the surface height): for a multichannel VOLUME every channel would then read\n   * the same composite and the channels would collapse into one, so volumes keep each band.\n   */\n  private planeSource(desc: TileDescriptor, channel: number | undefined, budget: StitchBudget): TiledSource {\n    const band = this.tiledSource(desc, channel, 1);\n    if (channel == null || desc.levels.length <= (desc.realLevels ?? desc.levels.length)) return band;\n    const own = chooseStitchLevel(band, budget);\n    if (own.fits) return band;\n    const composite = this.tiledSource(desc, undefined, 1);\n    const alt = chooseStitchLevel(composite, budget);\n    if (!alt.fits && alt.cols * alt.rows >= own.cols * own.rows) return band;\n    console.warn(\n      `[napari-js] channel ${channel} has no pyramid level within the ${budget.maxTiles}-tile ` +\n        `budget; using the composite overview (${alt.width}×${alt.height}) for this plane.`,\n    );\n    return composite;\n  }\n\n  /**\n   * A small picture of the whole slice for the navigator: the composite (or band `channel`) at the\n   * finest level a single tile holds, else the coarsest level, as an RGBA canvas. Without a\n   * pyramid, the single image of {@link fetchImage}.\n   */\n  async overviewImage(info: IImageInfo | undefined, z: number, channel?: number): Promise<OverviewImage> {\n    const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);\n    if (!desc?.levels?.length) return this.fetchImage(info, z, channel);\n    const img = await readLevel(this.tiledSource(desc, channel, 4), z, {\n      maxTiles: 1,\n      maxTextureDim: MAX_TEXTURE_DIM,\n      concurrency: TILE_FETCH_CONCURRENCY,\n    });\n    const { canvas, ctx } = create2dCanvas(img.width, img.height, 'overview');\n    const pixels = ctx.createImageData(img.width, img.height);\n    pixels.data.set(img.data as Uint8Array);\n    ctx.putImageData(pixels, 0, 0);\n    return canvas;\n  }\n\n  /**\n   * Slice `z`'s R, G and B bands, as three uint8 planes: the composite read as RGBA at the\n   * finest level within `maxTiles` (as {@link readPlane} picks it; 1 for a cheap overview\n   * sample), else the single image of {@link fetchImage}. The raw bands of an RGB image, for the\n   * per-band layers and their histograms.\n   */\n  async readRgbBands(\n    info: IImageInfo | undefined,\n    z: number,\n    maxTiles: number = MAX_STITCH_TILES,\n  ): Promise<LumaPlane[]> {\n    const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);\n    if (!desc?.levels?.length) {\n      const bmp = await this.fetchImage(info, z);\n      return chunkToBands({ width: bmp.width, height: bmp.height, data: bmp });\n    }\n    const img = await readLevel(this.tiledSource(desc, undefined, 4), z, {\n      maxTiles,\n      maxTextureDim: MAX_TEXTURE_DIM,\n      concurrency: TILE_FETCH_CONCURRENCY,\n    });\n    return splitRgbBands({ data: img.data as Uint8Array, width: img.width, height: img.height });\n  }\n\n  /** Fetch slice `z` and read it back as a single-channel uint8 plane (see {@link readPlane}),\n   *  within `budgetTiles`: the 2D stitch fallback reads at the full budget, the histogram samples\n   *  at 1 for a cheap overview tile. */\n  async fetchChannelData(\n    info: IImageInfo | undefined,\n    z: number,\n    channel?: number,\n    budgetTiles: number = MAX_STITCH_TILES,\n  ): Promise<LumaPlane> {\n    return this.readPlane(info, z, channel, { maxTiles: budgetTiles });\n  }\n\n  /** Tile budget to stitch a whole slice at ~`targetPx` resolution from the pyramid. Shared by the\n   *  surface plane fetch and the volume assembly, so both cap their reads by the decimate factor. */\n  tileBudgetFor(info: IImageInfo | undefined, targetPx: number): number {\n    const tileSize = this.currentDescriptor(info)?.tileSize || TILE_SIZE;\n    return Math.min(MAX_STITCH_TILES, Math.max(1, Math.round((targetPx / tileSize) ** 2 * STITCH_BUDGET_COEFF)));\n  }\n\n  /**\n   * Build a pyramidal TiledSource backed by the server `/tile` endpoint. `channel` selects a band\n   * (grayscale luminance, real levels only); omit it for the composite (RGBA, all levels).\n   *\n   * For the 2D view, `scene` is the signal of the render that asked for it, taken before that\n   * render's awaits, and `onTile` is told of each tile request and handed back the tile's end. A\n   * request issued once `scene` is aborted (a disposed source still fetching after a reset) is not\n   * reported, and one that settles after it does not end, so it can never count toward the next\n   * scene. A tile request's own `signal` (napari-js aborts a read it no longer needs) aborts the\n   * HTTP request.\n   */\n  tiledSource(\n    desc: TileDescriptor,\n    channel: number | undefined,\n    channels: 1 | 4,\n    scene?: AbortSignal,\n    onTile?: () => () => void,\n  ): TiledSource {\n    const infoB64 = this.tiles.getSelectedInfoB64() ?? '';\n    // Per-channel tiles exist only at REAL Bio-Formats levels; the composite exists at all levels.\n    const usable =\n      channel == null ? desc.levels : desc.levels.slice(0, Math.max(1, desc.realLevels ?? desc.levels.length));\n    const levelScales = usable.map((l) => desc.width / Math.max(1, l.width)); // level-0 px per level px\n    const tileSize = desc.tileSize || TILE_SIZE;\n    const api = this.api;\n    return {\n      kind: 'tiled',\n      width: desc.width,\n      height: desc.height,\n      tileSize,\n      levels: usable.length,\n      levelScales,\n      depth: Math.max(1, desc.z || 1),\n      channels,\n      dtype: 'uint8',\n      fetchTile: async (key: TileKey, signal?: AbortSignal): Promise<PixelChunk> => {\n        const res = usable[key.level]?.res ?? key.level;\n        const url = buildTileUrl(api, infoB64, {\n          res,\n          col: key.col,\n          row: key.row,\n          z: key.z,\n          tileSize,\n          channel,\n        });\n        const end = !onTile || scene?.aborted ? null : onTile();\n        try {\n          const resp = await fetchWithAuth(this.tiles, url, signal ? { signal } : {});\n          if (!resp.ok) {\n            throw new Error(`[napari-js] tile ${key.level}/${key.col}/${key.row} → ${resp.status}`);\n          }\n          const bmp = await createImageBitmap(await resp.blob());\n          if (channels === 4) return { width: bmp.width, height: bmp.height, data: bmp };\n          return bitmapToLuminance(bmp);\n        } finally {\n          if (!scene?.aborted) end?.();\n        }\n      },\n    };\n  }\n\n  /**\n   * The composite pyramid's R, G and B bands as three scalar {@link TiledSource}s — one per\n   * additive layer, so each band takes its own window, gamma, invert, tint and visibility — that\n   * share ONE `/tile` request per tile. The three layers ask for a tile in the same frame: the\n   * first fetches the RGBA tile and splits it, the other two take their band from the same\n   * promise, and the split tile is dropped once all three have it. A band that asks later (one\n   * shown again after being hidden) finds it in a small LRU, else fetches it again. `scene` and\n   * `onTile` as {@link tiledSource}: the loading badge counts the one request.\n   */\n  rgbBandSources(desc: TileDescriptor, scene?: AbortSignal, onTile?: () => () => void): TiledSource[] {\n    const composite = this.tiledSource(desc, undefined, 4, scene, onTile);\n    const split = new LruCache<{ bands: Promise<LumaPlane[]>; taken: Set<number> }>(RGB_BAND_CACHE_TILES);\n    const band = (key: TileKey, b: number): Promise<PixelChunk> => {\n      const id = `${key.z}/${key.level}/${key.col}/${key.row}`;\n      let entry = split.get(id);\n      if (!entry) {\n        const bands = composite.fetchTile(key).then(chunkToBands);\n        const fresh = { bands, taken: new Set<number>() };\n        // A failed tile is not remembered: the next ask fetches it again.\n        bands.catch(() => split.get(id) === fresh && split.delete(id));\n        split.set(id, (entry = fresh));\n      }\n      entry.taken.add(b);\n      if (entry.taken.size === 3) split.delete(id);\n      return entry.bands.then((planes) => planes[b]);\n    };\n    return [0, 1, 2].map((b): TiledSource => ({\n      ...composite,\n      channels: 1,\n      fetchTile: (key: TileKey) => band(key, b),\n    }));\n  }\n\n  /**\n   * Assemble a downsampled uint8 volume (luminance) of `info`'s stack with napari-js's\n   * `assembleVolume`: every `sliceStep`th slice, read from the band's (or composite's) pyramid at\n   * the level that `maxSlice` needs, within its tile budget, and area-averaged to `maxSlice` on\n   * the longest side. Slices are read with bounded concurrency (the connection pool stays full\n   * without flooding it on a deep stack), each reporting `progress` (0–100) as it lands so the host\n   * shows a determinate progress bar. Null when `signal` aborts (a Cancel or a new plot), which\n   * also aborts the tile requests in flight — a partial volume is never returned.\n   */\n  async assembleVolume(\n    info: IImageInfo | undefined,\n    opts: { maxSlice?: number; sliceStep?: number },\n    channel: number | undefined,\n    hooks: { signal: AbortSignal; progress(percent: number): void },\n  ): Promise<AssembledVolume | null> {\n    const { signal } = hooks;\n    const fullDepth = stackDepth(info) || 1;\n    const step = Math.max(1, Math.floor(opts.sliceStep ?? 1));\n    const maxSlice = opts.maxSlice ?? VOLUME_MAX_SLICE;\n    // Source-slice indices sampled into the volume (every `step`th plane → low-res is faster).\n    const zIndices: number[] = [];\n    for (let z = 0; z < fullDepth; z += step) zIndices.push(z);\n\n    hooks.progress(0);\n    try {\n      // `channel` selects a band (multichannel volume); omit for the grayscale composite. The\n      // caller owns the stackLoading flag (multichannel assembles channels in turn).\n      const source = await this.volumeSource(info, channel, zIndices[0]);\n      return await assembleVolume(source, zIndices, {\n        maxSide: maxSlice,\n        maxTiles: this.tileBudgetFor(info, maxSlice),\n        maxTextureDim: MAX_TEXTURE_DIM,\n        concurrency: VOLUME_FETCH_CONCURRENCY,\n        tileConcurrency: TILE_FETCH_CONCURRENCY,\n        onProgress: (done, total) => hooks.progress(Math.round((done / total) * 100)),\n        signal,\n      });\n    } catch (err) {\n      if (signal.aborted) return null; // cancelled → don't render a partial volume\n      throw err;\n    } finally {\n      hooks.progress(0);\n    }\n  }\n\n  /**\n   * The scalar source a volume reads: the band's (or composite's) pyramid; without one, one whole\n   * image per slice ({@link fetchImage}) as a single-tile level sized by the first slice, which is\n   * fetched here and served again as that slice's tile.\n   */\n  private async volumeSource(info: IImageInfo | undefined, channel: number | undefined, firstZ: number) {\n    const desc = this.simpleStack.isSimple(info) ? null : await this.ensureDescriptor(info);\n    if (desc?.levels?.length) return this.tiledSource(desc, channel, 1);\n    let first: ImageBitmap | null = await this.fetchImage(info, firstZ, channel);\n    const source: TiledSource = {\n      kind: 'tiled',\n      width: first.width,\n      height: first.height,\n      tileSize: Math.max(1, first.width, first.height),\n      levels: 1,\n      depth: stackDepth(info) || 1,\n      channels: 1,\n      dtype: 'uint8',\n      fetchTile: async (key: TileKey): Promise<PixelChunk> => {\n        let bmp: ImageBitmap;\n        if (first && key.z === firstZ) {\n          bmp = first;\n          first = null;\n        } else {\n          bmp = await this.fetchImage(info, key.z, channel);\n        }\n        return { width: bmp.width, height: bmp.height, data: bmp };\n      },\n    };\n    return source;\n  }\n\n  /**\n   * Slice `z` as a single WHOLE-image luminance plane (decimated to `maxGrid`), for the surface.\n   * Prefers the server pyramid, read at the level the grid needs ({@link readPlane}, which may\n   * drop a band to the composite overview); without a descriptor, the app's complete per-slice\n   * image (`urls`/`smallUrls`, as the Plotly surface) — never a lone top-left tile, which would be\n   * a corner of the slice — and only as a last resort the single-tile fetch.\n   */\n  async fetchPlane(\n    info: IImageInfo | undefined,\n    z: number,\n    channel: number | undefined,\n    maxGrid: number,\n  ): Promise<LumaPlane> {\n    const desc = await this.ensureDescriptor(info);\n    // Preferred: the WHOLE slice from the server pyramid at a resolution driven by the decimate\n    // factor — a higher target grid reads a FINER pyramid level (more real detail). This is what\n    // makes \"Full\" actually higher-res than \"½\", not just a fixed preview. The surface is a single\n    // decimated plane, so the composite fallback is acceptable when the band has no small level.\n    if (desc?.levels?.length) {\n      return this.readPlane(info, z, channel, {\n        maxTiles: this.tileBudgetFor(info, maxGrid),\n        maxSide: maxGrid,\n        compositeFallback: true,\n      });\n    }\n\n    // Fallback (no pyramid): the app's COMPLETE per-slice image (urls[z], not the small blurry\n    // thumbnail) — whole slice, avoids a corner tile. Capped at the image's own resolution.\n    const url = info?.urls?.[z] ?? info?.smallUrls?.[z];\n    if (url) {\n      try {\n        const resp = await fetchWithAuth(this.tiles, url);\n        if (resp.ok) return bitmapToLuminance(await createImageBitmap(await resp.blob()), maxGrid);\n      } catch (err) {\n        console.warn(`[napari-js] surface url fetch failed for z=${z}`, err);\n      }\n    }\n\n    // Last resort (no pyramid and no complete image): the single image.\n    return bitmapToLuminance(await this.fetchImage(info, z, channel), maxGrid);\n  }\n\n  /**\n   * Channel `channel`'s native-bit-depth histogram at slice `z` when `info` is a >8-bit image —\n   * the displayed pixels are 8-bit, so a client histogram would be clipped — cached per\n   * `(z, channel)`; null for an 8-bit channel, which the caller bins from the client data.\n   */\n  nativeHistogram$(\n    info: IImageInfo | undefined,\n    z: number,\n    channel: number,\n    bins: number,\n  ): Observable<IHistogram | null> | null {\n    const bitDepth = this.currentDescriptor(info)?.channelInfo?.[channel]?.bitDepth ?? 8;\n    if (bitDepth <= 8) return null;\n    const key = `${z}|${channel}`;\n    const cached = this.nativeHistograms.get(key);\n    if (cached) return of(cached);\n    return from(this.fetchNativeHistogram(channel, bins, z, key));\n  }\n\n  /** Fetch + cache one channel's native-bit-depth histogram from `GET /histogram` (>8-bit),\n   *  through the shared jit-service client — whose URL carries the per-app-load cache-buster\n   *  this backend used to omit, so a reload showed the server's 24 h-cached histogram. */\n  async fetchNativeHistogram(channel: number, bins: number, z: number, key: string): Promise<IHistogram | null> {\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return null;\n    try {\n      const out = await nativeHistogram(fetchJsonWithAuth(this.tiles), this.api, infoB64, {\n        z,\n        channel,\n        bins,\n      });\n      if (!out) return null; // 202 (still caching) or transient → null; the pane retries\n      this.nativeHistograms.set(key, out);\n      return out;\n    } catch (err) {\n      console.warn('[napari-js] native histogram fetch failed', err);\n      return null;\n    }\n  }\n\n  /** Native-bit-depth (16/32-bit) multi-band TIFF export of slice `z` via the server\n   *  `/export/tiff` endpoint — the displayed PNG is an 8-bit figure, this preserves the true pixel\n   *  values. Visible channels only (omitted when all are visible → server default). Mirrors the\n   *  OSD backend. */\n  async exportTiff(z: number, states: IChannelState[], fileName: string | undefined): Promise<void> {\n    const infoB64 = this.tiles.getSelectedInfoB64();\n    if (!infoB64) return;\n    const visible = states.filter((c) => c.visible).map((c) => c.index);\n    const url = exportTiffUrl(this.api, infoB64, z, visible, states.length);\n    const saveName = exportTiffFilename(fileName);\n    try {\n      const resp = await fetchWithAuth(this.tiles, url);\n      if (resp.status === 202) {\n        console.warn('[napari-js] 16-bit export: file still caching — try again shortly.');\n        return;\n      }\n      if (!resp.ok) throw new Error(`status ${resp.status}`);\n      saveAs(await resp.blob(), saveName);\n    } catch (err) {\n      console.warn('[napari-js] 16-bit TIFF export failed', err);\n    }\n  }\n}\n"]}