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

package/esm2022/lib/region-overlay/svg-region-renderer.mjs

@@ -0,0 +1,228 @@
+import { WORLD, boundsKind, regionHasHoles, regionPathD } from './region-geometry';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+export const IDENTITY_AFFINE = [1, 0, 0, 1, 0, 0];
+/**
+ * The affine of a projection that is affine (pan/zoom/rotate/flip), read from
+ * where it sends (0,0), (1,0) and (0,1) — how the OSD overlay gets its matrix
+ * from the viewport transform without depending on viewer internals. (napari-js
+ * hands the napari overlay its matrix directly: `Viewer.canvasTransform()`.)
+ */
+export function affineFromProjection(project) {
+    const [ox, oy] = project(0, 0);
+    const [ux, uy] = project(1, 0);
+    const [vx, vy] = project(0, 1);
+    return [ux - ox, uy - oy, vx - ox, vy - oy, ox, oy];
+}
+/** Apply an affine to a point. */
+export function applyAffine(m, x, y) {
+    return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+/**
+ * A screen-space layer: elements positioned from world anchors through the
+ * current camera, re-positioned (not rebuilt) on every camera change.
+ */
+export class ScreenLayer {
+    constructor(group, project) {
+        this.group = group;
+        this.project = project;
+        this.placed = [];
+    }
+    /** Append `el`, positioned by `place` now and after every camera change. */
+    place(el, place) {
+        place(el, this.project);
+        this.group.appendChild(el);
+        this.placed.push({ el, place: place });
+        return el;
+    }
+    /** Append `el` with attributes `x`/`y` (e.g. `'cx'`/`'cy'`) at a world point, offset in pixels. */
+    at(el, wx, wy, attrs = {}) {
+        const { x = 'x', y = 'y', dx = 0, dy = 0 } = attrs;
+        return this.place(el, (e, project) => {
+            const [sx, sy] = project(wx, wy);
+            e.setAttribute(x, `${sx + dx}`);
+            e.setAttribute(y, `${sy + dy}`);
+        });
+    }
+    /** A `<line>` between two world points. */
+    line(ax, ay, bx, by) {
+        return this.place(svgEl('line'), (e, project) => {
+            const [x1, y1] = project(ax, ay);
+            const [x2, y2] = project(bx, by);
+            e.setAttribute('x1', `${x1}`);
+            e.setAttribute('y1', `${y1}`);
+            e.setAttribute('x2', `${x2}`);
+            e.setAttribute('y2', `${y2}`);
+        });
+    }
+    /** A `<polygon>` / `<polyline>` through world points. */
+    poly(tag, pts) {
+        return this.place(svgEl(tag), (e, project) => {
+            e.setAttribute('points', pts.map((p) => project(p.x, p.y).join(',')).join(' '));
+        });
+    }
+    /** Re-position every element for the current camera. */
+    reproject() {
+        for (const { el, place } of this.placed)
+            place(el, this.project);
+    }
+    get isEmpty() {
+        return !this.group.firstChild;
+    }
+    clear() {
+        this.placed.length = 0;
+        while (this.group.firstChild)
+            this.group.removeChild(this.group.firstChild);
+    }
+}
+/** Create an SVG element. */
+export function svgEl(tag) {
+    return document.createElementNS(SVG_NS, tag);
+}
+export class SvgRegionRenderer {
+    constructor(svg, opts) {
+        this.svg = svg;
+        this.opts = opts;
+        this.camera = IDENTITY_AFFINE;
+        this.world = svgEl('g');
+        /** World → svg-local pixels through the current camera. */
+        this.project = (x, y) => applyAffine(this.camera, x, y);
+        this.world.setAttribute('data-layer', 'regions');
+        this.labels = new ScreenLayer(svgEl('g'), this.project);
+        this.labels.group.setAttribute('data-layer', 'labels');
+        this.overlay = new ScreenLayer(svgEl('g'), this.project);
+        this.overlay.group.setAttribute('data-layer', 'overlay');
+        this.applyCamera();
+    }
+    /** The current world → svg-local affine. */
+    get affine() {
+        return this.camera;
+    }
+    /**
+     * Move the camera: rewrite the world group's transform and re-position the
+     * screen-space elements. No element is created or removed. Returns false
+     * (and touches nothing) when the affine did not change.
+     */
+    setCamera(affine) {
+        if (!affine.every(Number.isFinite))
+            return false;
+        if (affine.every((v, i) => v === this.camera[i]))
+            return false;
+        this.camera = affine;
+        this.applyCamera();
+        this.labels.reproject();
+        this.overlay.reproject();
+        return true;
+    }
+    /** Rebuild the region shapes (world space) and their decorations. */
+    render(regions, selected) {
+        const shapes = document.createDocumentFragment();
+        this.labels.clear();
+        const sel = new Set(selected);
+        regions.forEach((region, i) => {
+            if (this.opts.skip?.(region))
+                return;
+            const isSel = sel.has(i);
+            const el = this.shapeOf(region);
+            if (el) {
+                el.setAttribute('vector-effect', 'non-scaling-stroke');
+                this.opts.styleShape(el, region, isSel);
+                shapes.appendChild(el);
+            }
+            this.opts.decorate?.(region, i, isSel, this.labels);
+        });
+        while (this.world.firstChild)
+            this.world.removeChild(this.world.firstChild);
+        this.world.appendChild(shapes);
+        this.sync();
+    }
+    /** Rebuild the overlay layer (the selected region's handles, drafts). */
+    renderOverlay(build) {
+        this.overlay.clear();
+        build(this.overlay);
+        this.sync();
+    }
+    /** Remove every layer from the svg. */
+    destroy() {
+        for (const g of [this.world, this.labels.group, this.overlay.group])
+            g.parentNode?.removeChild(g);
+    }
+    applyCamera() {
+        this.world.setAttribute('transform', `matrix(${this.camera.join(' ')})`);
+    }
+    /** Attach the layers that have content (in order) and detach the empty ones. */
+    sync() {
+        const layers = [
+            [this.world, !!this.world.firstChild],
+            [this.labels.group, !this.labels.isEmpty],
+            [this.overlay.group, !this.overlay.isEmpty],
+        ];
+        let before = null;
+        for (let i = layers.length - 1; i >= 0; i--) {
+            const [g, show] = layers[i];
+            if (!show) {
+                g.parentNode?.removeChild(g);
+                continue;
+            }
+            if (g.parentNode !== this.svg || g.nextSibling !== before) {
+                if (before)
+                    this.svg.insertBefore(g, before);
+                else if (g.parentNode !== this.svg)
+                    this.svg.appendChild(g);
+            }
+            before = g;
+        }
+    }
+    /** The world-space element for a region's geometry, or null when it has none. */
+    shapeOf(region) {
+        const b = region.bounds;
+        switch (boundsKind(b)) {
+            case 'rect': {
+                const r = b;
+                const x0 = Math.min(r.x, r.x + r.width), y0 = Math.min(r.y, r.y + r.height);
+                const w = Math.abs(r.width), h = Math.abs(r.height);
+                if (this.opts.rectElement === 'rect') {
+                    const el = svgEl('rect');
+                    el.setAttribute('x', `${x0}`);
+                    el.setAttribute('y', `${y0}`);
+                    el.setAttribute('width', `${w}`);
+                    el.setAttribute('height', `${h}`);
+                    return el;
+                }
+                const el = svgEl('polygon');
+                el.setAttribute('points', `${x0},${y0} ${x0 + w},${y0} ${x0 + w},${y0 + h} ${x0},${y0 + h}`);
+                return el;
+            }
+            case 'poly': {
+                const p = b;
+                const n = p.xpoints?.length ?? 0;
+                if (n === 0)
+                    return null;
+                const holes = regionHasHoles(region);
+                if ((p.bezier && n >= 2) || holes)
+                    return pathEl(regionPathD(region, WORLD), holes);
+                const el = svgEl(p.closed === false ? 'polyline' : 'polygon');
+                let pts = '';
+                for (let i = 0; i < n; i++)
+                    pts += `${i ? ' ' : ''}${p.xpoints[i]},${p.ypoints[i]}`;
+                el.setAttribute('points', pts);
+                return el;
+            }
+            case 'multi': {
+                const parts = b.polygons;
+                if (!parts.some((p) => (p.xpoints?.length ?? 0) >= 3))
+                    return null;
+                return pathEl(regionPathD(region, WORLD), true);
+            }
+            default:
+                return null;
+        }
+    }
+}
+function pathEl(d, evenOdd) {
+    const el = svgEl('path');
+    el.setAttribute('d', d);
+    if (evenOdd)
+        el.setAttribute('fill-rule', 'evenodd');
+    return el;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"svg-region-renderer.js","sourceRoot":"","sources":["../../../../src/lib/region-overlay/svg-region-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * World-space SVG region renderer shared by the OpenSeadragon and napari\n * overlays (review NAPARI-BOUNDARY-10, OSD-PLOTLY-11).\n *\n * The overlays used to delete and rebuild every region element on every camera\n * frame, projecting every vertex to screen pixels (napari also read the layout\n * once per vertex). Here region geometry is drawn ONCE, in world coordinates,\n * inside a single `<g transform=\"matrix(a b c d e f)\">`, with\n * `vector-effect: non-scaling-stroke` so strokes keep their pixel width. A\n * camera change rewrites that one attribute and re-positions the few\n * screen-sized elements (labels, the selected region's handles, a draft) —\n * nothing is created or removed. Region nodes are rebuilt only when the\n * regions or the selection change ({@link render}).\n *\n * Layers, bottom to top, each attached only while it has content:\n *  1. world   — region shapes, in world coordinates (transformed group);\n *  2. labels  — screen-space text pinned to world anchors, rebuilt with the regions;\n *  3. overlay — screen-space handles/drafts, rebuilt by the overlay on demand\n *     ({@link renderOverlay}).\n */\nimport { MultiPolygon, Polygon, Rectangle, Region } from '../models/region';\nimport { WORLD, boundsKind, regionHasHoles, regionPathD } from './region-geometry';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n\n/** An SVG affine `matrix(a b c d e f)`: x' = a·x + c·y + e, y' = b·x + d·y + f. */\nexport type Affine = readonly [number, number, number, number, number, number];\n\n/** World → svg-local pixel projection. */\nexport type Project = (x: number, y: number) => [number, number];\n\nexport const IDENTITY_AFFINE: Affine = [1, 0, 0, 1, 0, 0];\n\n/**\n * The affine of a projection that is affine (pan/zoom/rotate/flip), read from\n * where it sends (0,0), (1,0) and (0,1) — how the OSD overlay gets its matrix\n * from the viewport transform without depending on viewer internals. (napari-js\n * hands the napari overlay its matrix directly: `Viewer.canvasTransform()`.)\n */\nexport function affineFromProjection(project: (x: number, y: number) => readonly [number, number]): Affine {\n  const [ox, oy] = project(0, 0);\n  const [ux, uy] = project(1, 0);\n  const [vx, vy] = project(0, 1);\n  return [ux - ox, uy - oy, vx - ox, vy - oy, ox, oy];\n}\n\n/** Apply an affine to a point. */\nexport function applyAffine(m: Affine, x: number, y: number): [number, number] {\n  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];\n}\n\n/** How a placed screen element is (re)positioned for the current camera. */\nexport type Placement<T extends SVGElement> = (el: T, project: Project) => void;\n\n/** Options for {@link SvgRegionRenderer}. */\nexport interface SvgRegionRendererOptions {\n  /** Draw a {@link Rectangle} as a `<rect>` or as a four-point `<polygon>`. Default polygon. */\n  rectElement?: 'rect' | 'polygon';\n  /** Stroke and fill for one region's shape element. */\n  styleShape(el: SVGElement, region: Region, selected: boolean): void;\n  /** Add a region's screen-space decorations (its label) — once per {@link render}. */\n  decorate?(region: Region, index: number, selected: boolean, layer: ScreenLayer): void;\n  /** Leave a region out entirely (it keeps its index). */\n  skip?(region: Region): boolean;\n}\n\n/**\n * A screen-space layer: elements positioned from world anchors through the\n * current camera, re-positioned (not rebuilt) on every camera change.\n */\nexport class ScreenLayer {\n  private readonly placed: Array<{ el: SVGElement; place: Placement<SVGElement> }> = [];\n\n  constructor(\n    readonly group: SVGGElement,\n    private readonly project: Project,\n  ) {}\n\n  /** Append `el`, positioned by `place` now and after every camera change. */\n  place<T extends SVGElement>(el: T, place: Placement<T>): T {\n    place(el, this.project);\n    this.group.appendChild(el);\n    this.placed.push({ el, place: place as Placement<SVGElement> });\n    return el;\n  }\n\n  /** Append `el` with attributes `x`/`y` (e.g. `'cx'`/`'cy'`) at a world point, offset in pixels. */\n  at<T extends SVGElement>(\n    el: T,\n    wx: number,\n    wy: number,\n    attrs: { x?: string; y?: string; dx?: number; dy?: number } = {},\n  ): T {\n    const { x = 'x', y = 'y', dx = 0, dy = 0 } = attrs;\n    return this.place(el, (e, project) => {\n      const [sx, sy] = project(wx, wy);\n      e.setAttribute(x, `${sx + dx}`);\n      e.setAttribute(y, `${sy + dy}`);\n    });\n  }\n\n  /** A `<line>` between two world points. */\n  line(ax: number, ay: number, bx: number, by: number): SVGLineElement {\n    return this.place(svgEl('line'), (e, project) => {\n      const [x1, y1] = project(ax, ay);\n      const [x2, y2] = project(bx, by);\n      e.setAttribute('x1', `${x1}`);\n      e.setAttribute('y1', `${y1}`);\n      e.setAttribute('x2', `${x2}`);\n      e.setAttribute('y2', `${y2}`);\n    });\n  }\n\n  /** A `<polygon>` / `<polyline>` through world points. */\n  poly(tag: 'polygon' | 'polyline', pts: ReadonlyArray<{ x: number; y: number }>): SVGElement {\n    return this.place(svgEl(tag), (e, project) => {\n      e.setAttribute('points', pts.map((p) => project(p.x, p.y).join(',')).join(' '));\n    });\n  }\n\n  /** Re-position every element for the current camera. */\n  reproject(): void {\n    for (const { el, place } of this.placed) place(el, this.project);\n  }\n\n  get isEmpty(): boolean {\n    return !this.group.firstChild;\n  }\n\n  clear(): void {\n    this.placed.length = 0;\n    while (this.group.firstChild) this.group.removeChild(this.group.firstChild);\n  }\n}\n\n/** Create an SVG element. */\nexport function svgEl<K extends keyof SVGElementTagNameMap>(tag: K): SVGElementTagNameMap[K] {\n  return document.createElementNS(SVG_NS, tag);\n}\n\nexport class SvgRegionRenderer {\n  private camera: Affine = IDENTITY_AFFINE;\n  private readonly world = svgEl('g');\n  private readonly labels: ScreenLayer;\n  private readonly overlay: ScreenLayer;\n\n  /** World → svg-local pixels through the current camera. */\n  readonly project: Project = (x, y) => applyAffine(this.camera, x, y);\n\n  constructor(\n    private readonly svg: SVGSVGElement,\n    private readonly opts: SvgRegionRendererOptions,\n  ) {\n    this.world.setAttribute('data-layer', 'regions');\n    this.labels = new ScreenLayer(svgEl('g'), this.project);\n    this.labels.group.setAttribute('data-layer', 'labels');\n    this.overlay = new ScreenLayer(svgEl('g'), this.project);\n    this.overlay.group.setAttribute('data-layer', 'overlay');\n    this.applyCamera();\n  }\n\n  /** The current world → svg-local affine. */\n  get affine(): Affine {\n    return this.camera;\n  }\n\n  /**\n   * Move the camera: rewrite the world group's transform and re-position the\n   * screen-space elements. No element is created or removed. Returns false\n   * (and touches nothing) when the affine did not change.\n   */\n  setCamera(affine: Affine): boolean {\n    if (!affine.every(Number.isFinite)) return false;\n    if (affine.every((v, i) => v === this.camera[i])) return false;\n    this.camera = affine;\n    this.applyCamera();\n    this.labels.reproject();\n    this.overlay.reproject();\n    return true;\n  }\n\n  /** Rebuild the region shapes (world space) and their decorations. */\n  render(regions: ReadonlyArray<Region>, selected: ReadonlyArray<number>): void {\n    const shapes = document.createDocumentFragment();\n    this.labels.clear();\n    const sel = new Set(selected);\n    regions.forEach((region, i) => {\n      if (this.opts.skip?.(region)) return;\n      const isSel = sel.has(i);\n      const el = this.shapeOf(region);\n      if (el) {\n        el.setAttribute('vector-effect', 'non-scaling-stroke');\n        this.opts.styleShape(el, region, isSel);\n        shapes.appendChild(el);\n      }\n      this.opts.decorate?.(region, i, isSel, this.labels);\n    });\n    while (this.world.firstChild) this.world.removeChild(this.world.firstChild);\n    this.world.appendChild(shapes);\n    this.sync();\n  }\n\n  /** Rebuild the overlay layer (the selected region's handles, drafts). */\n  renderOverlay(build: (layer: ScreenLayer) => void): void {\n    this.overlay.clear();\n    build(this.overlay);\n    this.sync();\n  }\n\n  /** Remove every layer from the svg. */\n  destroy(): void {\n    for (const g of [this.world, this.labels.group, this.overlay.group]) g.parentNode?.removeChild(g);\n  }\n\n  private applyCamera(): void {\n    this.world.setAttribute('transform', `matrix(${this.camera.join(' ')})`);\n  }\n\n  /** Attach the layers that have content (in order) and detach the empty ones. */\n  private sync(): void {\n    const layers: Array<[SVGGElement, boolean]> = [\n      [this.world, !!this.world.firstChild],\n      [this.labels.group, !this.labels.isEmpty],\n      [this.overlay.group, !this.overlay.isEmpty],\n    ];\n    let before: ChildNode | null = null;\n    for (let i = layers.length - 1; i >= 0; i--) {\n      const [g, show] = layers[i];\n      if (!show) {\n        g.parentNode?.removeChild(g);\n        continue;\n      }\n      if (g.parentNode !== this.svg || g.nextSibling !== before) {\n        if (before) this.svg.insertBefore(g, before);\n        else if (g.parentNode !== this.svg) this.svg.appendChild(g);\n      }\n      before = g;\n    }\n  }\n\n  /** The world-space element for a region's geometry, or null when it has none. */\n  private shapeOf(region: Region): SVGElement | null {\n    const b = region.bounds;\n    switch (boundsKind(b)) {\n      case 'rect': {\n        const r = b as Rectangle;\n        const x0 = Math.min(r.x, r.x + r.width),\n          y0 = Math.min(r.y, r.y + r.height);\n        const w = Math.abs(r.width),\n          h = Math.abs(r.height);\n        if (this.opts.rectElement === 'rect') {\n          const el = svgEl('rect');\n          el.setAttribute('x', `${x0}`);\n          el.setAttribute('y', `${y0}`);\n          el.setAttribute('width', `${w}`);\n          el.setAttribute('height', `${h}`);\n          return el;\n        }\n        const el = svgEl('polygon');\n        el.setAttribute('points', `${x0},${y0} ${x0 + w},${y0} ${x0 + w},${y0 + h} ${x0},${y0 + h}`);\n        return el;\n      }\n      case 'poly': {\n        const p = b as Polygon;\n        const n = p.xpoints?.length ?? 0;\n        if (n === 0) return null;\n        const holes = regionHasHoles(region);\n        if ((p.bezier && n >= 2) || holes) return pathEl(regionPathD(region, WORLD), holes);\n        const el = svgEl(p.closed === false ? 'polyline' : 'polygon');\n        let pts = '';\n        for (let i = 0; i < n; i++) pts += `${i ? ' ' : ''}${p.xpoints[i]},${p.ypoints[i]}`;\n        el.setAttribute('points', pts);\n        return el;\n      }\n      case 'multi': {\n        const parts = (b as MultiPolygon).polygons;\n        if (!parts.some((p) => (p.xpoints?.length ?? 0) >= 3)) return null;\n        return pathEl(regionPathD(region, WORLD), true);\n      }\n      default:\n        return null;\n    }\n  }\n}\n\nfunction pathEl(d: string, evenOdd: boolean): SVGPathElement {\n  const el = svgEl('path');\n  el.setAttribute('d', d);\n  if (evenOdd) el.setAttribute('fill-rule', 'evenodd');\n  return el;\n}\n"]}

package/esm2022/lib/render-orchestrator.mjs

@@ -8,11 +8,12 @@ export class RenderOrchestrator {
         if (!smallInfo) {
             try {
                 await this.host.renderPhase(info, false);
-                this.host.finished(false, 'finished plotting');
+                this.host.finished(false);
             }
             catch (err) {
                 console.error('Preview failed', err);
-                this.host.finished(false, 'plotting aborted');
+                this.host.finished(false);
+                this.host.renderFailed(err);
             }
             return;
         }
@@ -21,7 +22,6 @@ export class RenderOrchestrator {
             await this.host.renderPhase(smallInfo, false);
             this.host.smallShown();
             smallReleasedOverlay = true;
-            console.log('multi-tier: small tier rendered, starting large');
         }
         catch (err) {
             // Small-tier render failed (older backend without tier support, transient
@@ -31,17 +31,20 @@ export class RenderOrchestrator {
         try {
             await this.renderLargeWithRetry(info);
             this.host.sharpenSettled();
-            if (smallReleasedOverlay) {
-                this.host.finished(true, 'multi-tier: large tier rendered, sharpening complete');
-            }
-            else {
-                this.host.finished(false, 'finished plotting (large only after small fallback)');
-            }
+            this.host.finished(smallReleasedOverlay);
         }
         catch (err) {
             this.host.sharpenSettled();
             console.error('Large-tier preview failed after retry', err);
-            this.host.sharpenFailed(err);
+            if (smallReleasedOverlay) {
+                this.host.sharpenFailed(err);
+            }
+            else {
+                // The small tier never made it either: there is no preview to fall back
+                // on, and the overlay is still up.
+                this.host.finished(false);
+                this.host.renderFailed(err);
+            }
         }
     }
     /** One retry after a brief delay before giving up on the large tier. */
@@ -84,4 +87,4 @@ export class SliceScrubber {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-orchestrator.js","sourceRoot":"","sources":["../../../src/lib/render-orchestrator.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from './contracts/image.contract';\n\n/**\n * Two-pass (small→large) render sequencing, extracted from\n * VisualizerComponent (refactoring plan, Step 7 — a pure move of the\n * orchestration; the component keeps the UI flags and supplies them through\n * the host callbacks).\n *\n * When the file has small-tier URLs we render the small tier first for a fast\n * blurry preview, release the loading overlay (keeping a translucent\n * \"sharpening\" spinner), then sharpen by re-rendering the canonical large tier\n * in place. Without a small tier it's the original single pass. The large pass\n * retries once after a short delay — the preview endpoint can hit a transient\n * 503 or a lock-contention window, and the second attempt usually lands on\n * fresh pre-gen-cached PNGs.\n */\nexport interface TwoPassRenderHost {\n  /** Load + plot one phase (the component owns div/screen/plot-type/z and the\n   *  newer-click filename guard). `inPlace` updates the existing render so the\n   *  canvas doesn't blank during the small→large swap. */\n  renderPhase(info: IImageInfo, inPlace: boolean): Promise<unknown>;\n  /** The small tier is on screen — drop the full loading overlay so the user\n   *  sees the blurry preview, and show the sharpening spinner. */\n  smallShown(): void;\n  /** The large render settled (either way) — sharpening spinner off. */\n  sharpenSettled(): void;\n  /** Rendering finished. `viaSmall` = the overlay was already released by the\n   *  small tier (so only release the running guard + apply the ROI); otherwise\n   *  do the full finalize (overlay + running + ROI). */\n  finished(viaSmall: boolean, logTag: string): void;\n  /** Both large-tier attempts failed; the small tier stays on screen as the\n   *  fallback. Surface it to the user and release the running guard + ROI. */\n  sharpenFailed(err: unknown): void;\n}\n\nexport class RenderOrchestrator {\n  constructor(\n    private host: TwoPassRenderHost,\n    private retryDelayMs = 1000,\n  ) {}\n\n  /** Run the render: single-pass when `smallInfo` is null, two-pass otherwise. */\n  async render(info: IImageInfo, smallInfo: IImageInfo | null): Promise<void> {\n    if (!smallInfo) {\n      try {\n        await this.host.renderPhase(info, false);\n        this.host.finished(false, 'finished plotting');\n      } catch (err) {\n        console.error('Preview failed', err);\n        this.host.finished(false, 'plotting aborted');\n      }\n      return;\n    }\n\n    let smallReleasedOverlay = false;\n    try {\n      await this.host.renderPhase(smallInfo, false);\n      this.host.smallShown();\n      smallReleasedOverlay = true;\n      console.log('multi-tier: small tier rendered, starting large');\n    } catch (err) {\n      // Small-tier render failed (older backend without tier support, transient\n      // error, …). Continue with large only; the overlay stays up until it lands.\n      console.warn('Small-tier preview failed, falling back to large', err);\n    }\n\n    try {\n      await this.renderLargeWithRetry(info);\n      this.host.sharpenSettled();\n      if (smallReleasedOverlay) {\n        this.host.finished(true, 'multi-tier: large tier rendered, sharpening complete');\n      } else {\n        this.host.finished(false, 'finished plotting (large only after small fallback)');\n      }\n    } catch (err) {\n      this.host.sharpenSettled();\n      console.error('Large-tier preview failed after retry', err);\n      this.host.sharpenFailed(err);\n    }\n  }\n\n  /** One retry after a brief delay before giving up on the large tier. */\n  private renderLargeWithRetry(info: IImageInfo): Promise<unknown> {\n    return this.host.renderPhase(info, true).catch((err) => {\n      console.warn('Large-tier preview failed on first try, retrying in 1s', err);\n      return new Promise<void>((resolve) => setTimeout(resolve, this.retryDelayMs)).then(() =>\n        this.host.renderPhase(info, true),\n      );\n    });\n  }\n}\n\n/**\n * Debounced z-slice scrubbing (extracted with the orchestrator): coalesce the\n * rapid changes a slider drag fires so a slice swap doesn't run on every\n * pixel; the final value lands immediately via {@link commit} (onSlideEnd).\n */\nexport class SliceScrubber {\n  private timer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor(\n    private apply: (z: number) => void,\n    private delayMs = 120,\n  ) {}\n\n  /** Debounced application of z while dragging. */\n  scrub(z: number): void {\n    this.cancel();\n    this.timer = setTimeout(() => {\n      this.timer = null;\n      this.apply(z);\n    }, this.delayMs);\n  }\n\n  /** Apply z immediately (slide end / keyboard step), dropping any pending scrub. */\n  commit(z: number): void {\n    this.cancel();\n    this.apply(z);\n  }\n\n  /** Drop a pending scrub without applying (teardown). */\n  cancel(): void {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = null;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-orchestrator.js","sourceRoot":"","sources":["../../../src/lib/render-orchestrator.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from './contracts/image.contract';\n\n/**\n * Two-pass (small→large) render sequencing, extracted from\n * VisualizerComponent (refactoring plan, Step 7 — a pure move of the\n * orchestration; the component keeps the UI flags and supplies them through\n * the host callbacks).\n *\n * When the file has small-tier URLs we render the small tier first for a fast\n * blurry preview, release the loading overlay (keeping a translucent\n * \"sharpening\" spinner), then sharpen by re-rendering the canonical large tier\n * in place. Without a small tier it's the original single pass. The large pass\n * retries once after a short delay — the preview endpoint can hit a transient\n * 503 or a lock-contention window, and the second attempt usually lands on\n * fresh pre-gen-cached PNGs.\n */\nexport interface TwoPassRenderHost {\n  /** Load + plot one phase (the component owns div/screen/plot-type/z and the\n   *  newer-click filename guard). `inPlace` updates the existing render so the\n   *  canvas doesn't blank during the small→large swap. Rejects when the phase\n   *  could not be drawn (including a backend's `plot()` resolving false). */\n  renderPhase(info: IImageInfo, inPlace: boolean): Promise<unknown>;\n  /** The small tier is on screen — drop the full loading overlay so the user\n   *  sees the blurry preview, and show the sharpening spinner. */\n  smallShown(): void;\n  /** The large render settled (either way) — sharpening spinner off. */\n  sharpenSettled(): void;\n  /** Rendering finished. `viaSmall` = the overlay was already released by the\n   *  small tier (so only release the running guard + apply the ROI); otherwise\n   *  do the full finalize (overlay + running + ROI). */\n  finished(viaSmall: boolean): void;\n  /** Both large-tier attempts failed; the small tier stays on screen as the\n   *  fallback. Surface it to the user and release the running guard + ROI. */\n  sharpenFailed(err: unknown): void;\n  /** Nothing could be drawn: the single pass failed, or both tiers did. Called\n   *  after {@link finished} (which releases the overlay), to tell the user. */\n  renderFailed(err: unknown): void;\n}\n\nexport class RenderOrchestrator {\n  constructor(\n    private host: TwoPassRenderHost,\n    private retryDelayMs = 1000,\n  ) {}\n\n  /** Run the render: single-pass when `smallInfo` is null, two-pass otherwise. */\n  async render(info: IImageInfo, smallInfo: IImageInfo | null): Promise<void> {\n    if (!smallInfo) {\n      try {\n        await this.host.renderPhase(info, false);\n        this.host.finished(false);\n      } catch (err) {\n        console.error('Preview failed', err);\n        this.host.finished(false);\n        this.host.renderFailed(err);\n      }\n      return;\n    }\n\n    let smallReleasedOverlay = false;\n    try {\n      await this.host.renderPhase(smallInfo, false);\n      this.host.smallShown();\n      smallReleasedOverlay = true;\n    } catch (err) {\n      // Small-tier render failed (older backend without tier support, transient\n      // error, …). Continue with large only; the overlay stays up until it lands.\n      console.warn('Small-tier preview failed, falling back to large', err);\n    }\n\n    try {\n      await this.renderLargeWithRetry(info);\n      this.host.sharpenSettled();\n      this.host.finished(smallReleasedOverlay);\n    } catch (err) {\n      this.host.sharpenSettled();\n      console.error('Large-tier preview failed after retry', err);\n      if (smallReleasedOverlay) {\n        this.host.sharpenFailed(err);\n      } else {\n        // The small tier never made it either: there is no preview to fall back\n        // on, and the overlay is still up.\n        this.host.finished(false);\n        this.host.renderFailed(err);\n      }\n    }\n  }\n\n  /** One retry after a brief delay before giving up on the large tier. */\n  private renderLargeWithRetry(info: IImageInfo): Promise<unknown> {\n    return this.host.renderPhase(info, true).catch((err) => {\n      console.warn('Large-tier preview failed on first try, retrying in 1s', err);\n      return new Promise<void>((resolve) => setTimeout(resolve, this.retryDelayMs)).then(() =>\n        this.host.renderPhase(info, true),\n      );\n    });\n  }\n}\n\n/**\n * Debounced z-slice scrubbing (extracted with the orchestrator): coalesce the\n * rapid changes a slider drag fires so a slice swap doesn't run on every\n * pixel; the final value lands immediately via {@link commit} (onSlideEnd).\n */\nexport class SliceScrubber {\n  private timer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor(\n    private apply: (z: number) => void,\n    private delayMs = 120,\n  ) {}\n\n  /** Debounced application of z while dragging. */\n  scrub(z: number): void {\n    this.cancel();\n    this.timer = setTimeout(() => {\n      this.timer = null;\n      this.apply(z);\n    }, this.delayMs);\n  }\n\n  /** Apply z immediately (slide end / keyboard step), dropping any pending scrub. */\n  commit(z: number): void {\n    this.cancel();\n    this.apply(z);\n  }\n\n  /** Drop a pending scrub without applying (teardown). */\n  cancel(): void {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = null;\n    }\n  }\n}\n"]}

package/esm2022/lib/render-session.mjs

@@ -0,0 +1,207 @@
+import { RenderOrchestrator } from './render-orchestrator';
+import { Supersede } from './util/supersede';
+/** A user-facing message for a failure: an HttpErrorResponse's server message, an
+ *  Error's message, or the status text, else the value itself. */
+export function errorMessage(err) {
+    const e = err;
+    return e?.error?.message || e?.message || e?.statusText || String(err);
+}
+/**
+ * The viewer's render pipeline: one image (or image-less dataset) at a time, the newest
+ * always winning.
+ *
+ * Every render takes a task from a {@link Supersede}: a newer render, a Cancel or
+ * teardown makes the older one stale — its callbacks return early instead of painting,
+ * releasing the newer render's overlay or applying its ROIs — and aborts the signal its
+ * loads were given, so superseded network work stops at the source. Sequencing of the
+ * small→large tiers lives in {@link RenderOrchestrator}; this owns the UI flags it
+ * drives ({@link running}, {@link sharpening}).
+ */
+export class ImageRenderSession {
+    constructor(host) {
+        this.host = host;
+        /** A render is in flight. */
+        this.running = false;
+        /** The small tier is on screen and the large one is still loading. */
+        this.sharpening = false;
+        /** Set once the plot div exists; an image-less draw before then waits for it. */
+        this.viewReady = false;
+        this.pendingDraw = null;
+        this.supersede = new Supersede();
+    }
+    /**
+     * Render `info` (which has urls), preempting whatever is in flight. A newer image
+     * ALWAYS preempts: dropping it while the old one finished reported image B as loaded
+     * while image A stayed on screen, and a cold image held the slot for its whole
+     * server-side cache fill.
+     */
+    render(info) {
+        const host = this.host;
+        const viz = host.visualizer;
+        const urls = info.urls;
+        const task = this.supersede.next();
+        if (this.running) {
+            // Stop the previous render's frame streaming (napari volume/surface preload keeps
+            // fetching otherwise) and clear its sharpen flag. Its callbacks are already inert.
+            viz.cancelLoading?.();
+            this.sharpening = false;
+        }
+        // Measure the plot div directly so the toolbar height is excluded.
+        const screenHeight = document.getElementById(host.plotDivName)?.offsetHeight || 500;
+        host.beforeReset();
+        viz.reset();
+        host.prepare(info);
+        this.running = true;
+        const smallCount = info.smallUrls?.length ?? 0;
+        const small = host.isHeatmap() && smallCount > 0 && smallCount === urls.length
+            ? { ...info, urls: info.smallUrls }
+            : null;
+        let overlayReleased = false;
+        const releaseOverlay = () => {
+            if (overlayReleased)
+                return;
+            overlayReleased = true;
+            host.releaseOverlay(info);
+        };
+        const settle = () => {
+            this.running = false;
+            host.landed(info);
+        };
+        new RenderOrchestrator({
+            // inPlace=true updates the existing render instead of rebuilding it, so the
+            // canvas doesn't blank during the small→large swap.
+            renderPhase: (phaseInfo, inPlace) => {
+                const phase = (rebuild) => {
+                    // Superseded BEFORE this phase started — don't even issue the load (the
+                    // orchestrator calls this per tier and retries the sharpen pass).
+                    if (!task.isCurrent())
+                        return Promise.resolve(null);
+                    // The backend that loads is the one for the type selected NOW (see RoutingVisualizerService).
+                    const plotType = host.plotType();
+                    return viz.load(phaseInfo, host.zIndex(), task.signal).then((loaded) => {
+                        if (!task.isCurrent())
+                            return null;
+                        // Guard against a newer click reaching us mid-render.
+                        if (phaseInfo.fileName !== loaded.filename)
+                            return null;
+                        // The type changed while this loaded (a spatial dataset cleared mid-switch falls
+                        // back to Image): the loaded image is the old backend's, so load for the new one.
+                        if (host.plotType() !== plotType)
+                            return phase(true);
+                        return viz
+                            .plot(host.plotDivName, loaded, phaseInfo, screenHeight, plotType, inPlace && !rebuild)
+                            .then((drawn) => {
+                            // A backend that cannot draw (no plot target, no WebGPU, no tile descriptor)
+                            // resolves false: a failed phase, so the retry/failure paths run.
+                            if (drawn === false && task.isCurrent())
+                                throw new Error('the renderer could not draw the image');
+                            return drawn;
+                        });
+                    });
+                };
+                return phase(false);
+            },
+            smallShown: () => {
+                if (!task.isCurrent())
+                    return;
+                // Still caching server-side: keep the full cache-progress overlay up rather than
+                // a translucent spinner over a blank canvas; finished() releases it.
+                if (host.isCaching())
+                    return;
+                // Small tier on screen: drop the full overlay, keep a translucent spinner so the
+                // blurry render isn't mistaken for the final image.
+                releaseOverlay();
+                this.sharpening = true;
+            },
+            sharpenSettled: () => {
+                if (task.isCurrent())
+                    this.sharpening = false;
+            },
+            finished: () => {
+                if (!task.isCurrent())
+                    return;
+                releaseOverlay(); // idempotent: now if smallShown deferred it or was skipped
+                settle();
+            },
+            sharpenFailed: (err) => {
+                if (!task.isCurrent())
+                    return;
+                // The small tier stays on screen as the fallback.
+                host.alert('warn', 'Preview not sharpened', `The full-resolution preview did not load (${errorMessage(err)}). ` +
+                    'The low-resolution preview is still shown. Try clicking the image again.');
+                settle();
+            },
+            renderFailed: (err) => {
+                if (!task.isCurrent())
+                    return;
+                host.alert('error', 'Could not draw the image', `${info.fileName ?? 'The image'}: ${errorMessage(err)}. Try opening it again.`);
+            },
+        }).render(info, small);
+    }
+    /**
+     * Draw a spatial mode with no image behind it: the observations alone, framed on their
+     * own extent. The image info is a placeholder naming the dataset, so regions drawn here
+     * are kept per dataset like any image's. Supersedes (and is superseded by) image renders.
+     */
+    async plotWithoutImage(dataset) {
+        if (!this.viewReady) {
+            // A host that creates the viewer AFTER publishing the dataset has it replayed before
+            // the plot div exists; drawing now finds no target. Draw once the view is ready.
+            this.pendingDraw = dataset;
+            return;
+        }
+        const host = this.host;
+        const task = this.supersede.next();
+        const info = {
+            isGrayscale: false,
+            trueImageSize: [0, 0],
+            urls: [],
+            isStack: false,
+            showStack: false,
+            scaleRatio: true,
+            fileName: `spatial:${dataset.id}`,
+            imageMeta: [],
+        };
+        const height = document.getElementById(host.plotDivName)?.offsetHeight || 500;
+        let failure = null;
+        try {
+            // A backend that cannot draw (no WebGPU, no plot target) resolves false rather than throwing.
+            if (!(await host.visualizer.plot(host.plotDivName, null, info, height, host.plotType()))) {
+                failure = 'the renderer could not start';
+            }
+        }
+        catch (err) {
+            failure = err;
+        }
+        // Superseded: a newer render owns the loading state now.
+        if (!task.isCurrent())
+            return;
+        if (failure) {
+            console.warn('[visualizer] could not draw the spatial dataset', failure);
+            const e = failure;
+            // An image-less dataset has no tissue image to fall back on, so say so rather than
+            // leave an empty canvas that looks finished.
+            host.alert('error', 'Could not draw the dataset', `${dataset.name ?? dataset.id}: ${e?.message ?? String(failure)}.`);
+        }
+        host.setImageLoading(false);
+        host.detectChanges();
+    }
+    /**
+     * The plot div exists now: run an image-less draw that arrived before it did — only if
+     * its dataset is still the one on offer (by id: the port may re-emit the same dataset
+     * as a new object, and the current object is the one to draw) and no image has arrived.
+     */
+    viewIsReady(current, hasImage) {
+        this.viewReady = true;
+        const pending = this.pendingDraw;
+        this.pendingDraw = null;
+        if (pending && current && current.id === pending.id && !hasImage)
+            void this.plotWithoutImage(current);
+    }
+    /** Cancel the render in flight: abort its loads and make its callbacks inert. */
+    cancel() {
+        this.supersede.cancel();
+        this.running = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-session.js","sourceRoot":"","sources":["../../../src/lib/render-session.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from './contracts/image.contract';\nimport { PlotType } from './contracts/plot-type';\nimport { SpatialDataset } from './contracts/spatial-dataset.contract';\nimport { IVisualizer } from './contracts/visualizer.contract';\nimport { RenderOrchestrator } from './render-orchestrator';\nimport { Supersede } from './util/supersede';\n\n/** A user-facing message for a failure: an HttpErrorResponse's server message, an\n *  Error's message, or the status text, else the value itself. */\nexport function errorMessage(err: unknown): string {\n  const e = err as { error?: { message?: string }; message?: string; statusText?: string } | null;\n  return e?.error?.message || e?.message || e?.statusText || String(err);\n}\n\n/** The viewer a render session draws into, and what it tells the viewer. */\nexport interface RenderSessionHost {\n  readonly plotDivName: string;\n  readonly visualizer: IVisualizer;\n  /** The slice to load, read when each phase starts. */\n  zIndex(): number;\n  plotType(): PlotType;\n  /** A 2D view: only it renders the small tier first (the in-place sharpen pass does\n   *  not rebuild a 3D scene, so it blanked one). */\n  isHeatmap(): boolean;\n  /** A server-side cache fill is in progress (keeps the full overlay up). */\n  isCaching(): boolean;\n  /** The view is about to be torn down: end what was bound to it (contributed sessions). */\n  beforeReset(): void;\n  /** Lay the new image out (stack flag, slice bounds, initial slice) once the old view is gone. */\n  prepare(info: IImageInfo): void;\n  /** Drop the loading overlay the render owns (once per render). */\n  releaseOverlay(info: IImageInfo): void;\n  /** The render landed, sharp or as a fallback: apply ROIs, start sessions. */\n  landed(info: IImageInfo): void;\n  setImageLoading(loading: boolean): void;\n  alert(severity: 'warn' | 'error', summary: string, detail: string): void;\n  detectChanges(): void;\n}\n\n/**\n * The viewer's render pipeline: one image (or image-less dataset) at a time, the newest\n * always winning.\n *\n * Every render takes a task from a {@link Supersede}: a newer render, a Cancel or\n * teardown makes the older one stale — its callbacks return early instead of painting,\n * releasing the newer render's overlay or applying its ROIs — and aborts the signal its\n * loads were given, so superseded network work stops at the source. Sequencing of the\n * small→large tiers lives in {@link RenderOrchestrator}; this owns the UI flags it\n * drives ({@link running}, {@link sharpening}).\n */\nexport class ImageRenderSession {\n  /** A render is in flight. */\n  running = false;\n  /** The small tier is on screen and the large one is still loading. */\n  sharpening = false;\n  /** Set once the plot div exists; an image-less draw before then waits for it. */\n  private viewReady = false;\n  private pendingDraw: SpatialDataset | null = null;\n  private readonly supersede = new Supersede();\n\n  constructor(private readonly host: RenderSessionHost) {}\n\n  /**\n   * Render `info` (which has urls), preempting whatever is in flight. A newer image\n   * ALWAYS preempts: dropping it while the old one finished reported image B as loaded\n   * while image A stayed on screen, and a cold image held the slot for its whole\n   * server-side cache fill.\n   */\n  render(info: IImageInfo): void {\n    const host = this.host;\n    const viz = host.visualizer;\n    const urls = info.urls;\n    const task = this.supersede.next();\n    if (this.running) {\n      // Stop the previous render's frame streaming (napari volume/surface preload keeps\n      // fetching otherwise) and clear its sharpen flag. Its callbacks are already inert.\n      viz.cancelLoading?.();\n      this.sharpening = false;\n    }\n    // Measure the plot div directly so the toolbar height is excluded.\n    const screenHeight = document.getElementById(host.plotDivName)?.offsetHeight || 500;\n    host.beforeReset();\n    viz.reset();\n    host.prepare(info);\n    this.running = true;\n    const smallCount = info.smallUrls?.length ?? 0;\n    const small =\n      host.isHeatmap() && smallCount > 0 && smallCount === urls.length\n        ? { ...info, urls: info.smallUrls as string[] }\n        : null;\n    let overlayReleased = false;\n    const releaseOverlay = () => {\n      if (overlayReleased) return;\n      overlayReleased = true;\n      host.releaseOverlay(info);\n    };\n    const settle = () => {\n      this.running = false;\n      host.landed(info);\n    };\n\n    new RenderOrchestrator({\n      // inPlace=true updates the existing render instead of rebuilding it, so the\n      // canvas doesn't blank during the small→large swap.\n      renderPhase: (phaseInfo, inPlace) => {\n        const phase = (rebuild: boolean): Promise<boolean | null> => {\n          // Superseded BEFORE this phase started — don't even issue the load (the\n          // orchestrator calls this per tier and retries the sharpen pass).\n          if (!task.isCurrent()) return Promise.resolve(null);\n          // The backend that loads is the one for the type selected NOW (see RoutingVisualizerService).\n          const plotType = host.plotType();\n          return viz.load(phaseInfo, host.zIndex(), task.signal).then((loaded) => {\n            if (!task.isCurrent()) return null;\n            // Guard against a newer click reaching us mid-render.\n            if (phaseInfo.fileName !== loaded.filename) return null;\n            // The type changed while this loaded (a spatial dataset cleared mid-switch falls\n            // back to Image): the loaded image is the old backend's, so load for the new one.\n            if (host.plotType() !== plotType) return phase(true);\n            return viz\n              .plot(host.plotDivName, loaded, phaseInfo, screenHeight, plotType, inPlace && !rebuild)\n              .then((drawn) => {\n                // A backend that cannot draw (no plot target, no WebGPU, no tile descriptor)\n                // resolves false: a failed phase, so the retry/failure paths run.\n                if (drawn === false && task.isCurrent()) throw new Error('the renderer could not draw the image');\n                return drawn;\n              });\n          });\n        };\n        return phase(false);\n      },\n      smallShown: () => {\n        if (!task.isCurrent()) return;\n        // Still caching server-side: keep the full cache-progress overlay up rather than\n        // a translucent spinner over a blank canvas; finished() releases it.\n        if (host.isCaching()) return;\n        // Small tier on screen: drop the full overlay, keep a translucent spinner so the\n        // blurry render isn't mistaken for the final image.\n        releaseOverlay();\n        this.sharpening = true;\n      },\n      sharpenSettled: () => {\n        if (task.isCurrent()) this.sharpening = false;\n      },\n      finished: () => {\n        if (!task.isCurrent()) return;\n        releaseOverlay(); // idempotent: now if smallShown deferred it or was skipped\n        settle();\n      },\n      sharpenFailed: (err: unknown) => {\n        if (!task.isCurrent()) return;\n        // The small tier stays on screen as the fallback.\n        host.alert(\n          'warn',\n          'Preview not sharpened',\n          `The full-resolution preview did not load (${errorMessage(err)}). ` +\n            'The low-resolution preview is still shown. Try clicking the image again.',\n        );\n        settle();\n      },\n      renderFailed: (err: unknown) => {\n        if (!task.isCurrent()) return;\n        host.alert(\n          'error',\n          'Could not draw the image',\n          `${info.fileName ?? 'The image'}: ${errorMessage(err)}. Try opening it again.`,\n        );\n      },\n    }).render(info, small);\n  }\n\n  /**\n   * Draw a spatial mode with no image behind it: the observations alone, framed on their\n   * own extent. The image info is a placeholder naming the dataset, so regions drawn here\n   * are kept per dataset like any image's. Supersedes (and is superseded by) image renders.\n   */\n  async plotWithoutImage(dataset: SpatialDataset): Promise<void> {\n    if (!this.viewReady) {\n      // A host that creates the viewer AFTER publishing the dataset has it replayed before\n      // the plot div exists; drawing now finds no target. Draw once the view is ready.\n      this.pendingDraw = dataset;\n      return;\n    }\n    const host = this.host;\n    const task = this.supersede.next();\n    const info: IImageInfo = {\n      isGrayscale: false,\n      trueImageSize: [0, 0],\n      urls: [],\n      isStack: false,\n      showStack: false,\n      scaleRatio: true,\n      fileName: `spatial:${dataset.id}`,\n      imageMeta: [],\n    };\n    const height = document.getElementById(host.plotDivName)?.offsetHeight || 500;\n    let failure: unknown = null;\n    try {\n      // A backend that cannot draw (no WebGPU, no plot target) resolves false rather than throwing.\n      if (!(await host.visualizer.plot(host.plotDivName, null, info, height, host.plotType()))) {\n        failure = 'the renderer could not start';\n      }\n    } catch (err) {\n      failure = err;\n    }\n    // Superseded: a newer render owns the loading state now.\n    if (!task.isCurrent()) return;\n    if (failure) {\n      console.warn('[visualizer] could not draw the spatial dataset', failure);\n      const e = failure as { message?: string };\n      // An image-less dataset has no tissue image to fall back on, so say so rather than\n      // leave an empty canvas that looks finished.\n      host.alert(\n        'error',\n        'Could not draw the dataset',\n        `${dataset.name ?? dataset.id}: ${e?.message ?? String(failure)}.`,\n      );\n    }\n    host.setImageLoading(false);\n    host.detectChanges();\n  }\n\n  /**\n   * The plot div exists now: run an image-less draw that arrived before it did — only if\n   * its dataset is still the one on offer (by id: the port may re-emit the same dataset\n   * as a new object, and the current object is the one to draw) and no image has arrived.\n   */\n  viewIsReady(current: SpatialDataset | null, hasImage: boolean): void {\n    this.viewReady = true;\n    const pending = this.pendingDraw;\n    this.pendingDraw = null;\n    if (pending && current && current.id === pending.id && !hasImage) void this.plotWithoutImage(current);\n  }\n\n  /** Cancel the render in flight: abort its loads and make its callbacks inert. */\n  cancel(): void {\n    this.supersede.cancel();\n    this.running = false;\n  }\n}\n"]}