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

package/esm2022/lib/implementations/osd/simple-source.mjs

@@ -0,0 +1,395 @@
+import { readRgba } from './tile-client';
+import { throwIfAborted } from '../tile-server';
+/** OSD's single-image source for a directly-loadable URL. */
+function imageSource(url) {
+    return { type: 'image', url };
+}
+/** Skip the full-res upscale above this longest-side dimension — a folder
+ *  stack is per-file previews (well under this); this only guards against an
+ *  accidental enormous canvas allocation. */
+const SIMPLE_UPSCALE_MAX_DIM = 8192;
+/**
+ * The "simple" (`tiled: false`) image source: self-contained per-slice URLs and
+ * no tile server — e.g. a numbered image series assembled client-side into a
+ * stack, or the processing-pipeline preview. Each slice is resampled to the
+ * full-resolution size so regions align and opened as OSD's single-image source;
+ * a SERVERLESS multichannel image is composited client-side from its per-channel
+ * planes (kept OFF the tiled per-channel path).
+ *
+ * Owns every piece of simple-mode state and is the single place that resets it,
+ * so none of it can outlive the simple image (OSD-PLOTLY-1).
+ */
+export class OsdSimpleSource {
+    constructor(host, simpleStack) {
+        this.host = host;
+        this.simpleStack = simpleStack;
+        /** True while the mounted image is simple: setZIndex re-opens the viewer on
+         *  the new slice's URL instead of toggling a tiled slice. */
+        this.active = false;
+        /** urls[] of the mounted simple image, for the slice being scrubbed to. */
+        this.urls = [];
+        /** preview blob URL → full-res resampled blob URL (see toFullResUrl), so
+         *  re-visiting a slice doesn't re-resample. Revoked on file change. */
+        this.fullResUrls = new Map();
+        /** SERVERLESS multichannel (tiled:false + channelCount>1): the stack's
+         *  per-slice per-channel plane URLs, the current slice's decoded planes, and
+         *  the displayed composite blob URL. */
+        this.multichannel = false;
+        this.channelUrls = [];
+        this.channelPlanes = [];
+        this.compositeUrl = null;
+    }
+    /** Forget the simple image's state: mode, slice URLs and the serverless-
+     *  multichannel flag, URLs and decoded planes. Called when a tiled image is
+     *  mounted and on teardown; {@link commit} sets it from an {@link OsdLoaded}. */
+    reset() {
+        this.active = false;
+        this.urls = [];
+        this.multichannel = false;
+        this.channelUrls = [];
+        this.channelPlanes = [];
+    }
+    /** Revoke every blob URL this source created (a different file was selected). */
+    revokeUrls() {
+        for (const u of this.fullResUrls.values())
+            URL.revokeObjectURL(u);
+        this.fullResUrls.clear();
+        if (this.compositeUrl) {
+            URL.revokeObjectURL(this.compositeUrl);
+            this.compositeUrl = null;
+        }
+    }
+    /** Build the `plot()` payload for a simple (tiled:false) image: a single-level
+     *  descriptor sized from `trueImageSize`, plus the directly-loadable URL —
+     *  resolved and fetched via {@link SimpleSliceAccessService} (shared with
+     *  napari-js; see its docs for why this can't be a raw `fetch()`/`<img>`).
+     *  Those fetches take no signal, so an abort is honoured once they settle. */
+    async load(imageInfo, zIndex, signal) {
+        const z = zIndex || 0;
+        const filename = imageInfo?.fileName;
+        const [width, height] = imageInfo.trueImageSize ?? [0, 0];
+        const meta = imageInfo.imageMeta?.[0];
+        // SERVERLESS MULTICHANNEL: composite the slice's per-channel planes
+        // client-side (no tile server), driven by the channel pane.
+        // Everything is computed into locals and returned: the image on screen keeps
+        // its state until plot() commits this payload.
+        const chUrls = imageInfo.channelUrls;
+        const multichannel = !!chUrls?.length && (meta?.channelCount ?? 1) > 1;
+        let url;
+        let channelPlanes;
+        if (multichannel) {
+            try {
+                channelPlanes = await this.loadChannelPlanes(chUrls[z] ?? chUrls[0]);
+                url = await this.composite(channelPlanes);
+                // NB: histograms are binned in plot(), AFTER destroyViewer clears the
+                // sampler — computing them here would be wiped by that clear.
+            }
+            catch (err) {
+                console.warn('[OSD] simple multichannel composite failed', err);
+            }
+        }
+        else {
+            const rawUrl = this.simpleStack.urlFor(imageInfo, z);
+            if (rawUrl) {
+                try {
+                    const previewUrl = await this.simpleStack.fetchAsBlobUrl(rawUrl);
+                    // Resample the (downscaled) preview to full resolution so OSD's world
+                    // matches the full-res ROI coordinate space — see toFullResUrl.
+                    url = await this.toFullResUrl(previewUrl, width, height);
+                }
+                catch (err) {
+                    console.warn('[OSD] simple-mode slice fetch failed', err);
+                }
+            }
+        }
+        throwIfAborted(signal);
+        // No loadable URL (empty urls[] or the fetch failed): signal "couldn't
+        // load" with a null descriptor — same as the tiled path when there's no
+        // selected-file info — so plot() returns false (its `if (!d)` guard) and
+        // the router can fall back, instead of mounting an <img> with an undefined
+        // src that throws at runtime.
+        if (!url) {
+            console.warn('[OSD] simple-mode slice has no loadable URL; skipping OSD render', filename);
+            return { descriptor: null, infoB64: '', z, filename };
+        }
+        const descriptor = {
+            width,
+            height,
+            tileSize: 0, // unused: simple mode never calls buildTileSource
+            z: 1, // single frame
+            channels: meta?.rgbChannels ?? (imageInfo.isGrayscale ? 1 : 3),
+            multichannel: false,
+            realLevels: 1,
+            levels: [{ res: 0, width, height }],
+            mppX: meta?.mppX ?? 0,
+            mppY: meta?.mppY ?? 0,
+        };
+        return {
+            descriptor,
+            infoB64: '',
+            z,
+            filename,
+            simple: true,
+            url,
+            ...(multichannel ? { channelUrls: chUrls, channelPlanes: channelPlanes ?? [] } : {}),
+        };
+    }
+    /** Commit a mounted image's simple-mode state from its {@link OsdLoaded}
+     *  payload (cleared for a tiled one). */
+    commit(loaded, imageInfo) {
+        this.active = !!loaded.simple;
+        this.urls = loaded.simple ? (imageInfo?.urls ?? []) : [];
+        this.commitMultichannel(loaded);
+    }
+    /** The simple image's new viewer is about to open `loaded.url` (the old viewer
+     *  is gone): take ownership of its composite and bin its histograms — after
+     *  the service's destroyViewer, whose last act is clearing the sampler. */
+    mount(loaded) {
+        // The new viewer opens this image's composite (serverless multichannel):
+        // the old viewer is gone, so its composite can go now.
+        if (this.compositeUrl && this.compositeUrl !== loaded.url) {
+            URL.revokeObjectURL(this.compositeUrl);
+        }
+        this.compositeUrl = this.multichannel ? (loaded.url ?? null) : null;
+        // Multichannel bins each cached channel plane; single-band / RGB bins the
+        // decoded frame's own pixels.
+        if (this.multichannel) {
+            this.host.sampler().computeSimpleMultichannelHistograms(loaded.z, this.channelPlanes);
+        }
+        else {
+            void this.sampleHistogram(loaded.url, loaded.z);
+        }
+    }
+    /**
+     * The in-place (large-tier) pass for a mounted simple image. Simple mode has
+     * no pyramid to fall back on: it displays literally whatever URL was last
+     * opened, so without this swap the small tier's 128px placeholder would stay
+     * on screen forever (pixelated, never "sharpening" like the tiled path).
+     */
+    refreshInPlace(loaded, imageInfo) {
+        const viewer = this.host.viewer();
+        if (!viewer || !loaded.simple || !loaded.url)
+            return;
+        // Also refresh urls to THIS phase's (large-tier) urls[] — it was set from
+        // the small tier's 128px urls on the initial mount, which never runs again
+        // for the in-place pass. Without this, setZIndex's later slider scrubs would
+        // keep reading the small tier's low-res URLs forever, even though the
+        // initial slice was correctly swapped to full resolution here.
+        this.urls = imageInfo?.urls ?? this.urls;
+        if (loaded.channelPlanes) {
+            this.commitMultichannel(loaded);
+            this.openComposite(loaded.url);
+        }
+        else {
+            viewer.open(imageSource(loaded.url));
+        }
+    }
+    /**
+     * Show slice `z` of the mounted simple image. Each slice is its own complete
+     * image (no pyramid to toggle opacity on), so this re-opens the viewer on the
+     * new slice's URL; the viewer's preserveViewport keeps the current zoom/pan.
+     * Scrubs can resolve out of order: only the current slice may land.
+     */
+    setZIndex(z) {
+        if (this.multichannel) {
+            const urls = this.channelUrls[z] ?? this.channelUrls[0];
+            if (!urls)
+                return;
+            this.host.setCurrentZ(z);
+            // A different image commits a new channelUrls array (see commit()).
+            const image = this.channelUrls;
+            void (async () => {
+                const planes = await this.loadChannelPlanes(urls);
+                // Only the current slice's planes may land, or a later recomposite
+                // would show the wrong slice.
+                if (this.host.currentZ() !== z || this.channelUrls !== image || !this.host.viewer())
+                    return;
+                this.channelPlanes = planes;
+                this.host.sampler().computeSimpleMultichannelHistograms(z, planes);
+                this.host.scheduleInvalidate(); // recomposite + open, coalesced with slider changes
+            })();
+            return;
+        }
+        const rawUrl = this.urls[z] ?? this.urls[0];
+        if (!rawUrl)
+            return;
+        this.host.setCurrentZ(z);
+        // Fetched via SimpleSliceAccessService (auth interceptor applies) then
+        // resampled to full-res (same as the initial load — see toFullResUrl) so
+        // the world stays full-res across slices and ROIs keep aligning. Guard
+        // against a newer scrub landing first.
+        const d = this.host.descriptor();
+        this.simpleStack
+            .fetchAsBlobUrl(rawUrl)
+            .then((previewUrl) => this.toFullResUrl(previewUrl, d?.width ?? 0, d?.height ?? 0))
+            .then((url) => {
+            const viewer = this.host.viewer();
+            if (this.host.currentZ() !== z || !viewer)
+                return;
+            viewer.open(imageSource(url));
+            void this.sampleHistogram(url, z); // re-bin the scrubbed slice
+        })
+            .catch((err) => console.warn('[OSD] slice fetch failed', err));
+    }
+    /**
+     * OSD's `{type:'image'}` source sizes its coordinate world to the image's
+     * NATURAL pixels. A folder-stack slice is a server `/preview` whose pixel size
+     * needn't match the full-resolution image — it may be downscaled (large
+     * images) OR larger than the dimensions `/metadata` reports. Either way OSD's
+     * world would differ from the full-res ROI coordinate space (QuPath geojson,
+     * in level-0 pixels): a smaller preview renders ROIs oversized, a larger one
+     * renders them undersized/offset. Resample the preview to EXACTLY the
+     * full-resolution dimensions (blurry but positionally exact — scaling up or
+     * down as needed) so OSD's world matches the ROI coordinate space, while still
+     * using OSD's reliable single-image renderer. Cached per preview URL (revoked
+     * on file change); a no-op when the preview is already exactly full-res (small
+     * images, in-memory pipeline blobs), when the dims are unknown, or when
+     * they're implausibly large (guards against an enormous canvas). (jit-ui#93)
+     */
+    async toFullResUrl(previewUrl, width, height) {
+        if (!width || !height || Math.max(width, height) > SIMPLE_UPSCALE_MAX_DIM)
+            return previewUrl;
+        const cached = this.fullResUrls.get(previewUrl);
+        if (cached)
+            return cached;
+        let img;
+        try {
+            img = await this.loadImageEl(previewUrl);
+        }
+        catch {
+            return previewUrl; // couldn't decode — let OSD try the URL as-is
+        }
+        // Already the exact full-res world — no resample needed. (A preview that is
+        // larger OR smaller than full-res must still be resized so OSD's world ==
+        // the ROI coordinate space; only an exact match is skippable.)
+        if (img.naturalWidth === width && img.naturalHeight === height)
+            return previewUrl;
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return previewUrl;
+        ctx.drawImage(img, 0, 0, width, height); // scale preview (up or down) to full-res
+        const blob = await new Promise((resolve) => canvas.toBlob(resolve));
+        if (!blob)
+            return previewUrl;
+        const fullResUrl = URL.createObjectURL(blob);
+        this.fullResUrls.set(previewUrl, fullResUrl);
+        return fullResUrl;
+    }
+    /** Sample a slice's own decoded pixels into the histogram — the serverless
+     *  analog of the tiled samplers (no tile server). Fire-and-forget; a decode
+     *  failure just leaves the pane empty rather than throwing. */
+    async sampleHistogram(url, z) {
+        if (!url)
+            return;
+        try {
+            const px = await this.decodeUrlToRgba(url);
+            if (px)
+                this.host.sampler().computeSimpleHistogram(z, px.data, this.host.isGrayscale());
+        }
+        catch (err) {
+            console.warn('[OSD] simple-mode histogram sample failed', err);
+        }
+    }
+    /** Fetch + decode a slice's per-channel planes (single-band grayscale) into
+     *  pixel buffers, for the serverless multichannel compositor. Auth-safe: goes
+     *  through SimpleSliceAccessService (blob:/data: as-is; http via HttpClient).
+     *  The channels are fetched in parallel; plane c stays at index c, and a
+     *  plane that fails to load is empty (the compositor skips it). */
+    async loadChannelPlanes(urls) {
+        const empty = () => ({ data: new Uint8ClampedArray(0), width: 0, height: 0 });
+        return Promise.all((urls ?? []).map(async (u) => {
+            try {
+                const px = await this.decodeUrlToRgba(await this.simpleStack.fetchAsBlobUrl(u));
+                return px ? { data: px.data, width: px.width, height: px.height } : empty();
+            }
+            catch (err) {
+                console.warn('[OSD] channel plane decode failed', err);
+                return empty();
+            }
+        }));
+    }
+    /** Composite per-channel planes into ONE RGBA image using the current channel
+     *  states (colour/window/gamma/visibility) — the client-side analog of the
+     *  tiled per-channel 'lighter' compositor (same display.channelRgbLut math as
+     *  the channel-tile recolor, applied per-plane). Returns a new blob: URL of the
+     *  composite PNG, owned by the caller (see {@link openComposite}). */
+    async composite(planes) {
+        if (!planes.length)
+            return undefined;
+        const w = planes[0].width, h = planes[0].height;
+        if (!w || !h)
+            return undefined;
+        const out = this.host.display().compositeChannels(planes.map((p) => (p.width === w && p.height === h ? p.data : null)), this.host.channelStates());
+        const canvas = document.createElement('canvas');
+        canvas.width = w;
+        canvas.height = h;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return undefined;
+        ctx.putImageData(new ImageData(out, w, h), 0, 0);
+        const blob = await new Promise((res) => canvas.toBlob(res, 'image/png'));
+        if (!blob)
+            return undefined;
+        return URL.createObjectURL(blob);
+    }
+    /** Re-composite the current slice from its cached planes (new channel states)
+     *  and re-open — the serverless analog of the tiled invalidate-on-channel-change.
+     *  Runs from the recolorer's invalidateDisplay, so it is coalesced per frame,
+     *  and drops its composite once a newer display round (`token`) has started. */
+    async recompositeAndOpen(token) {
+        const url = await this.composite(this.channelPlanes);
+        if (!url)
+            return;
+        if (!this.host.isCurrentDisplay(token) || !this.host.viewer()) {
+            URL.revokeObjectURL(url); // superseded — never displayed
+            return;
+        }
+        this.openComposite(url);
+    }
+    /** Open a serverless-multichannel composite and take ownership of its URL. The
+     *  previously displayed composite is revoked only once this open settles: an
+     *  `open()` still decoding a revoked blob: URL fails. */
+    openComposite(url) {
+        const viewer = this.host.viewer();
+        if (!viewer)
+            return;
+        const prev = this.compositeUrl;
+        this.compositeUrl = url;
+        if (prev && prev !== url) {
+            const revokePrev = () => {
+                viewer.removeHandler('open', revokePrev);
+                viewer.removeHandler('open-failed', revokePrev);
+                URL.revokeObjectURL(prev);
+            };
+            viewer.addHandler('open', revokePrev);
+            viewer.addHandler('open-failed', revokePrev);
+        }
+        viewer.open(imageSource(url));
+    }
+    /** Commit the serverless-multichannel part of an {@link OsdLoaded} payload. */
+    commitMultichannel(loaded) {
+        this.multichannel = !!loaded.channelPlanes;
+        this.channelUrls = loaded.channelUrls ?? [];
+        this.channelPlanes = loaded.channelPlanes ?? [];
+    }
+    /** Decode an image URL to RGBA pixels (null for an empty image or no 2d
+     *  context). Throws when the URL can't be decoded. */
+    async decodeUrlToRgba(url) {
+        const img = await this.loadImageEl(url);
+        const w = img.naturalWidth, h = img.naturalHeight;
+        return w && h ? readRgba(img, w, h) : null;
+    }
+    /** Load a URL into an HTMLImageElement (resolves once decoded). */
+    loadImageEl(url) {
+        return new Promise((resolve, reject) => {
+            const img = document.createElement('img');
+            img.onload = () => resolve(img);
+            img.onerror = (e) => reject(e);
+            img.src = url;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-source.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/simple-source.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as OpenSeadragon from 'openseadragon';\n\nimport { readRgba } from './tile-client';\nimport { DisplayPipeline } from './display-pipeline';\nimport { HistogramSampler } from './histogram-sampler';\nimport { TileDescriptor, throwIfAborted } from '../tile-server';\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\nimport { SimpleSliceAccessService } from '../simple-slice-access.service';\n\n/** One decoded single-band channel plane (serverless multichannel). */\nexport interface SimplePlane {\n  data: Uint8ClampedArray;\n  width: number;\n  height: number;\n}\n\n/** What `load()` hands to `plot()`. `load()` only computes it: the image on\n *  screen keeps its own state until `plot()` commits this payload. */\nexport interface OsdLoaded {\n  descriptor: TileDescriptor | null;\n  infoB64: string;\n  z: number;\n  /** Mirrors the loaded image's filename — the diagram's render pipeline\n   *  guards on `loaded.filename === phaseInfo.fileName` before calling plot(). */\n  filename: string | undefined;\n  /** Simple (non-tiled) image: `plot()` opens {@link url} directly via OSD's\n   *  single-image source — no tile pyramid, no server. Set when the image\n   *  carries `tiled === false` (see {@link IImageInfo.tiled}). */\n  simple?: boolean;\n  /** The directly-loadable image URL (`blob:`/`data:`/`http`) for simple mode. */\n  url?: string;\n  /** Serverless multichannel only: every slice's per-channel plane URLs, and\n   *  the loaded slice's decoded planes ({@link url} is their composite). */\n  channelUrls?: string[][];\n  channelPlanes?: SimplePlane[];\n}\n\n/** The service state the simple source reads and drives. */\nexport interface SimpleSourceHost {\n  viewer(): OpenSeadragon.Viewer | null;\n  descriptor(): TileDescriptor | null;\n  isGrayscale(): boolean;\n  currentZ(): number;\n  /** Show slice `z`: the service records it and drops its slice-specific readback. */\n  setCurrentZ(z: number): void;\n  sampler(): HistogramSampler;\n  display(): DisplayPipeline;\n  channelStates(): IChannelState[];\n  /** Whether display round `token` is still the current one (see OsdTileRecolorer). */\n  isCurrentDisplay(token: number): boolean;\n  /** Queue a coalesced display round (for the serverless multichannel recomposite). */\n  scheduleInvalidate(): void;\n}\n\n/** OSD's single-image source for a directly-loadable URL. */\nfunction imageSource(url: string): Parameters<OpenSeadragon.Viewer['open']>[0] {\n  return { type: 'image', url } as unknown as Parameters<OpenSeadragon.Viewer['open']>[0];\n}\n\n/** Skip the full-res upscale above this longest-side dimension — a folder\n *  stack is per-file previews (well under this); this only guards against an\n *  accidental enormous canvas allocation. */\nconst SIMPLE_UPSCALE_MAX_DIM = 8192;\n\n/**\n * The \"simple\" (`tiled: false`) image source: self-contained per-slice URLs and\n * no tile server — e.g. a numbered image series assembled client-side into a\n * stack, or the processing-pipeline preview. Each slice is resampled to the\n * full-resolution size so regions align and opened as OSD's single-image source;\n * a SERVERLESS multichannel image is composited client-side from its per-channel\n * planes (kept OFF the tiled per-channel path).\n *\n * Owns every piece of simple-mode state and is the single place that resets it,\n * so none of it can outlive the simple image (OSD-PLOTLY-1).\n */\nexport class OsdSimpleSource {\n  /** True while the mounted image is simple: setZIndex re-opens the viewer on\n   *  the new slice's URL instead of toggling a tiled slice. */\n  active = false;\n  /** urls[] of the mounted simple image, for the slice being scrubbed to. */\n  urls: string[] = [];\n  /** preview blob URL → full-res resampled blob URL (see toFullResUrl), so\n   *  re-visiting a slice doesn't re-resample. Revoked on file change. */\n  private readonly fullResUrls = new Map<string, string>();\n  /** SERVERLESS multichannel (tiled:false + channelCount>1): the stack's\n   *  per-slice per-channel plane URLs, the current slice's decoded planes, and\n   *  the displayed composite blob URL. */\n  multichannel = false;\n  channelUrls: string[][] = [];\n  channelPlanes: SimplePlane[] = [];\n  compositeUrl: string | null = null;\n\n  constructor(\n    private readonly host: SimpleSourceHost,\n    private readonly simpleStack: SimpleSliceAccessService,\n  ) {}\n\n  /** Forget the simple image's state: mode, slice URLs and the serverless-\n   *  multichannel flag, URLs and decoded planes. Called when a tiled image is\n   *  mounted and on teardown; {@link commit} sets it from an {@link OsdLoaded}. */\n  reset(): void {\n    this.active = false;\n    this.urls = [];\n    this.multichannel = false;\n    this.channelUrls = [];\n    this.channelPlanes = [];\n  }\n\n  /** Revoke every blob URL this source created (a different file was selected). */\n  revokeUrls(): void {\n    for (const u of this.fullResUrls.values()) URL.revokeObjectURL(u);\n    this.fullResUrls.clear();\n    if (this.compositeUrl) {\n      URL.revokeObjectURL(this.compositeUrl);\n      this.compositeUrl = null;\n    }\n  }\n\n  /** Build the `plot()` payload for a simple (tiled:false) image: a single-level\n   *  descriptor sized from `trueImageSize`, plus the directly-loadable URL —\n   *  resolved and fetched via {@link SimpleSliceAccessService} (shared with\n   *  napari-js; see its docs for why this can't be a raw `fetch()`/`<img>`).\n   *  Those fetches take no signal, so an abort is honoured once they settle. */\n  async load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<OsdLoaded> {\n    const z = zIndex || 0;\n    const filename = imageInfo?.fileName;\n    const [width, height] = imageInfo.trueImageSize ?? [0, 0];\n    const meta = imageInfo.imageMeta?.[0];\n    // SERVERLESS MULTICHANNEL: composite the slice's per-channel planes\n    // client-side (no tile server), driven by the channel pane.\n    // Everything is computed into locals and returned: the image on screen keeps\n    // its state until plot() commits this payload.\n    const chUrls = imageInfo.channelUrls;\n    const multichannel = !!chUrls?.length && (meta?.channelCount ?? 1) > 1;\n    let url: string | undefined;\n    let channelPlanes: SimplePlane[] | undefined;\n    if (multichannel) {\n      try {\n        channelPlanes = await this.loadChannelPlanes(chUrls![z] ?? chUrls![0]);\n        url = await this.composite(channelPlanes);\n        // NB: histograms are binned in plot(), AFTER destroyViewer clears the\n        // sampler — computing them here would be wiped by that clear.\n      } catch (err) {\n        console.warn('[OSD] simple multichannel composite failed', err);\n      }\n    } else {\n      const rawUrl = this.simpleStack.urlFor(imageInfo, z);\n      if (rawUrl) {\n        try {\n          const previewUrl = await this.simpleStack.fetchAsBlobUrl(rawUrl);\n          // Resample the (downscaled) preview to full resolution so OSD's world\n          // matches the full-res ROI coordinate space — see toFullResUrl.\n          url = await this.toFullResUrl(previewUrl, width, height);\n        } catch (err) {\n          console.warn('[OSD] simple-mode slice fetch failed', err);\n        }\n      }\n    }\n    throwIfAborted(signal);\n    // No loadable URL (empty urls[] or the fetch failed): signal \"couldn't\n    // load\" with a null descriptor — same as the tiled path when there's no\n    // selected-file info — so plot() returns false (its `if (!d)` guard) and\n    // the router can fall back, instead of mounting an <img> with an undefined\n    // src that throws at runtime.\n    if (!url) {\n      console.warn('[OSD] simple-mode slice has no loadable URL; skipping OSD render', filename);\n      return { descriptor: null, infoB64: '', z, filename };\n    }\n    const descriptor: TileDescriptor = {\n      width,\n      height,\n      tileSize: 0, // unused: simple mode never calls buildTileSource\n      z: 1, // single frame\n      channels: meta?.rgbChannels ?? (imageInfo.isGrayscale ? 1 : 3),\n      multichannel: false,\n      realLevels: 1,\n      levels: [{ res: 0, width, height }],\n      mppX: meta?.mppX ?? 0,\n      mppY: meta?.mppY ?? 0,\n    };\n    return {\n      descriptor,\n      infoB64: '',\n      z,\n      filename,\n      simple: true,\n      url,\n      ...(multichannel ? { channelUrls: chUrls as string[][], channelPlanes: channelPlanes ?? [] } : {}),\n    };\n  }\n\n  /** Commit a mounted image's simple-mode state from its {@link OsdLoaded}\n   *  payload (cleared for a tiled one). */\n  commit(loaded: OsdLoaded, imageInfo: IImageInfo): void {\n    this.active = !!loaded.simple;\n    this.urls = loaded.simple ? (imageInfo?.urls ?? []) : [];\n    this.commitMultichannel(loaded);\n  }\n\n  /** The simple image's new viewer is about to open `loaded.url` (the old viewer\n   *  is gone): take ownership of its composite and bin its histograms — after\n   *  the service's destroyViewer, whose last act is clearing the sampler. */\n  mount(loaded: OsdLoaded): void {\n    // The new viewer opens this image's composite (serverless multichannel):\n    // the old viewer is gone, so its composite can go now.\n    if (this.compositeUrl && this.compositeUrl !== loaded.url) {\n      URL.revokeObjectURL(this.compositeUrl);\n    }\n    this.compositeUrl = this.multichannel ? (loaded.url ?? null) : null;\n    // Multichannel bins each cached channel plane; single-band / RGB bins the\n    // decoded frame's own pixels.\n    if (this.multichannel) {\n      this.host.sampler().computeSimpleMultichannelHistograms(loaded.z, this.channelPlanes);\n    } else {\n      void this.sampleHistogram(loaded.url, loaded.z);\n    }\n  }\n\n  /**\n   * The in-place (large-tier) pass for a mounted simple image. Simple mode has\n   * no pyramid to fall back on: it displays literally whatever URL was last\n   * opened, so without this swap the small tier's 128px placeholder would stay\n   * on screen forever (pixelated, never \"sharpening\" like the tiled path).\n   */\n  refreshInPlace(loaded: OsdLoaded, imageInfo: IImageInfo): void {\n    const viewer = this.host.viewer();\n    if (!viewer || !loaded.simple || !loaded.url) return;\n    // Also refresh urls to THIS phase's (large-tier) urls[] — it was set from\n    // the small tier's 128px urls on the initial mount, which never runs again\n    // for the in-place pass. Without this, setZIndex's later slider scrubs would\n    // keep reading the small tier's low-res URLs forever, even though the\n    // initial slice was correctly swapped to full resolution here.\n    this.urls = imageInfo?.urls ?? this.urls;\n    if (loaded.channelPlanes) {\n      this.commitMultichannel(loaded);\n      this.openComposite(loaded.url);\n    } else {\n      viewer.open(imageSource(loaded.url));\n    }\n  }\n\n  /**\n   * Show slice `z` of the mounted simple image. Each slice is its own complete\n   * image (no pyramid to toggle opacity on), so this re-opens the viewer on the\n   * new slice's URL; the viewer's preserveViewport keeps the current zoom/pan.\n   * Scrubs can resolve out of order: only the current slice may land.\n   */\n  setZIndex(z: number): void {\n    if (this.multichannel) {\n      const urls = this.channelUrls[z] ?? this.channelUrls[0];\n      if (!urls) return;\n      this.host.setCurrentZ(z);\n      // A different image commits a new channelUrls array (see commit()).\n      const image = this.channelUrls;\n      void (async () => {\n        const planes = await this.loadChannelPlanes(urls);\n        // Only the current slice's planes may land, or a later recomposite\n        // would show the wrong slice.\n        if (this.host.currentZ() !== z || this.channelUrls !== image || !this.host.viewer()) return;\n        this.channelPlanes = planes;\n        this.host.sampler().computeSimpleMultichannelHistograms(z, planes);\n        this.host.scheduleInvalidate(); // recomposite + open, coalesced with slider changes\n      })();\n      return;\n    }\n    const rawUrl = this.urls[z] ?? this.urls[0];\n    if (!rawUrl) return;\n    this.host.setCurrentZ(z);\n    // Fetched via SimpleSliceAccessService (auth interceptor applies) then\n    // resampled to full-res (same as the initial load — see toFullResUrl) so\n    // the world stays full-res across slices and ROIs keep aligning. Guard\n    // against a newer scrub landing first.\n    const d = this.host.descriptor();\n    this.simpleStack\n      .fetchAsBlobUrl(rawUrl)\n      .then((previewUrl) => this.toFullResUrl(previewUrl, d?.width ?? 0, d?.height ?? 0))\n      .then((url) => {\n        const viewer = this.host.viewer();\n        if (this.host.currentZ() !== z || !viewer) return;\n        viewer.open(imageSource(url));\n        void this.sampleHistogram(url, z); // re-bin the scrubbed slice\n      })\n      .catch((err) => console.warn('[OSD] slice fetch failed', err));\n  }\n\n  /**\n   * OSD's `{type:'image'}` source sizes its coordinate world to the image's\n   * NATURAL pixels. A folder-stack slice is a server `/preview` whose pixel size\n   * needn't match the full-resolution image — it may be downscaled (large\n   * images) OR larger than the dimensions `/metadata` reports. Either way OSD's\n   * world would differ from the full-res ROI coordinate space (QuPath geojson,\n   * in level-0 pixels): a smaller preview renders ROIs oversized, a larger one\n   * renders them undersized/offset. Resample the preview to EXACTLY the\n   * full-resolution dimensions (blurry but positionally exact — scaling up or\n   * down as needed) so OSD's world matches the ROI coordinate space, while still\n   * using OSD's reliable single-image renderer. Cached per preview URL (revoked\n   * on file change); a no-op when the preview is already exactly full-res (small\n   * images, in-memory pipeline blobs), when the dims are unknown, or when\n   * they're implausibly large (guards against an enormous canvas). (jit-ui#93)\n   */\n  async toFullResUrl(previewUrl: string, width: number, height: number): Promise<string> {\n    if (!width || !height || Math.max(width, height) > SIMPLE_UPSCALE_MAX_DIM) return previewUrl;\n    const cached = this.fullResUrls.get(previewUrl);\n    if (cached) return cached;\n    let img: HTMLImageElement;\n    try {\n      img = await this.loadImageEl(previewUrl);\n    } catch {\n      return previewUrl; // couldn't decode — let OSD try the URL as-is\n    }\n    // Already the exact full-res world — no resample needed. (A preview that is\n    // larger OR smaller than full-res must still be resized so OSD's world ==\n    // the ROI coordinate space; only an exact match is skippable.)\n    if (img.naturalWidth === width && img.naturalHeight === height) return previewUrl;\n    const canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n    const ctx = canvas.getContext('2d');\n    if (!ctx) return previewUrl;\n    ctx.drawImage(img, 0, 0, width, height); // scale preview (up or down) to full-res\n    const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve));\n    if (!blob) return previewUrl;\n    const fullResUrl = URL.createObjectURL(blob);\n    this.fullResUrls.set(previewUrl, fullResUrl);\n    return fullResUrl;\n  }\n\n  /** Sample a slice's own decoded pixels into the histogram — the serverless\n   *  analog of the tiled samplers (no tile server). Fire-and-forget; a decode\n   *  failure just leaves the pane empty rather than throwing. */\n  private async sampleHistogram(url: string | undefined, z: number): Promise<void> {\n    if (!url) return;\n    try {\n      const px = await this.decodeUrlToRgba(url);\n      if (px) this.host.sampler().computeSimpleHistogram(z, px.data, this.host.isGrayscale());\n    } catch (err) {\n      console.warn('[OSD] simple-mode histogram sample failed', err);\n    }\n  }\n\n  /** Fetch + decode a slice's per-channel planes (single-band grayscale) into\n   *  pixel buffers, for the serverless multichannel compositor. Auth-safe: goes\n   *  through SimpleSliceAccessService (blob:/data: as-is; http via HttpClient).\n   *  The channels are fetched in parallel; plane c stays at index c, and a\n   *  plane that fails to load is empty (the compositor skips it). */\n  async loadChannelPlanes(urls: string[] | undefined): Promise<SimplePlane[]> {\n    const empty = (): SimplePlane => ({ data: new Uint8ClampedArray(0), width: 0, height: 0 });\n    return Promise.all(\n      (urls ?? []).map(async (u) => {\n        try {\n          const px = await this.decodeUrlToRgba(await this.simpleStack.fetchAsBlobUrl(u));\n          return px ? { data: px.data, width: px.width, height: px.height } : empty();\n        } catch (err) {\n          console.warn('[OSD] channel plane decode failed', err);\n          return empty();\n        }\n      }),\n    );\n  }\n\n  /** Composite per-channel planes into ONE RGBA image using the current channel\n   *  states (colour/window/gamma/visibility) — the client-side analog of the\n   *  tiled per-channel 'lighter' compositor (same display.channelRgbLut math as\n   *  the channel-tile recolor, applied per-plane). Returns a new blob: URL of the\n   *  composite PNG, owned by the caller (see {@link openComposite}). */\n  async composite(planes: SimplePlane[]): Promise<string | undefined> {\n    if (!planes.length) return undefined;\n    const w = planes[0].width,\n      h = planes[0].height;\n    if (!w || !h) return undefined;\n    const out = this.host.display().compositeChannels(\n      planes.map((p) => (p.width === w && p.height === h ? p.data : null)),\n      this.host.channelStates(),\n    );\n    const canvas = document.createElement('canvas');\n    canvas.width = w;\n    canvas.height = h;\n    const ctx = canvas.getContext('2d');\n    if (!ctx) return undefined;\n    ctx.putImageData(new ImageData(out, w, h), 0, 0);\n    const blob = await new Promise<Blob | null>((res) => canvas.toBlob(res, 'image/png'));\n    if (!blob) return undefined;\n    return URL.createObjectURL(blob);\n  }\n\n  /** Re-composite the current slice from its cached planes (new channel states)\n   *  and re-open — the serverless analog of the tiled invalidate-on-channel-change.\n   *  Runs from the recolorer's invalidateDisplay, so it is coalesced per frame,\n   *  and drops its composite once a newer display round (`token`) has started. */\n  async recompositeAndOpen(token: number): Promise<void> {\n    const url = await this.composite(this.channelPlanes);\n    if (!url) return;\n    if (!this.host.isCurrentDisplay(token) || !this.host.viewer()) {\n      URL.revokeObjectURL(url); // superseded — never displayed\n      return;\n    }\n    this.openComposite(url);\n  }\n\n  /** Open a serverless-multichannel composite and take ownership of its URL. The\n   *  previously displayed composite is revoked only once this open settles: an\n   *  `open()` still decoding a revoked blob: URL fails. */\n  private openComposite(url: string): void {\n    const viewer = this.host.viewer();\n    if (!viewer) return;\n    const prev = this.compositeUrl;\n    this.compositeUrl = url;\n    if (prev && prev !== url) {\n      const revokePrev = () => {\n        viewer.removeHandler('open', revokePrev);\n        viewer.removeHandler('open-failed', revokePrev);\n        URL.revokeObjectURL(prev);\n      };\n      viewer.addHandler('open', revokePrev);\n      viewer.addHandler('open-failed', revokePrev);\n    }\n    viewer.open(imageSource(url));\n  }\n\n  /** Commit the serverless-multichannel part of an {@link OsdLoaded} payload. */\n  private commitMultichannel(loaded: OsdLoaded): void {\n    this.multichannel = !!loaded.channelPlanes;\n    this.channelUrls = loaded.channelUrls ?? [];\n    this.channelPlanes = loaded.channelPlanes ?? [];\n  }\n\n  /** Decode an image URL to RGBA pixels (null for an empty image or no 2d\n   *  context). Throws when the URL can't be decoded. */\n  async decodeUrlToRgba(url: string): Promise<ImageData | null> {\n    const img = await this.loadImageEl(url);\n    const w = img.naturalWidth,\n      h = img.naturalHeight;\n    return w && h ? readRgba(img, w, h) : null;\n  }\n\n  /** Load a URL into an HTMLImageElement (resolves once decoded). */\n  loadImageEl(url: string): Promise<HTMLImageElement> {\n    return new Promise((resolve, reject) => {\n      const img = document.createElement('img');\n      img.onload = () => resolve(img);\n      img.onerror = (e) => reject(e);\n      img.src = url;\n    });\n  }\n}\n"]}