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

package/esm2022/lib/region-source/worker-region-source.mjs

@@ -0,0 +1,229 @@
+/**
+ * A {@link RegionSource} over a GeoJSON string, parsed and tiled in the region-source Web Worker.
+ *
+ * One worker serves every open source. Where no worker can start (jsdom, SSR, a blocked worker
+ * URL) the same tables run on the main thread; if the worker dies, each source re-opens itself
+ * there from its text (which the host holds anyway: it handed it over) and carries on — whether
+ * it had a call in flight then or not (see {@link RegionSourceWorkerClient.generation}).
+ */
+import { RegionTileCache, abortable } from './region-source';
+import { RegionSourceTables, } from './region-source-ops';
+/** The worker died under a call; the caller re-opens on the main thread. */
+class WorkerLostError extends Error {
+    constructor() {
+        super('The region-source worker stopped.');
+        this.name = 'WorkerLostError';
+    }
+}
+/** Owns the region-source worker and the calls in flight on it. */
+export class RegionSourceWorkerClient {
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand —
+     * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile
+     * rejects.
+     */
+    constructor(factory) {
+        this.factory = factory;
+        this.worker = null;
+        this.starting = null;
+        this.unavailable = false;
+        this.nextId = 1;
+        this.pending = new Map();
+        /** The main-thread tables, once anything runs here. */
+        this.local = null;
+        this.tables = 0;
+    }
+    /** Whether calls now run on the main thread. */
+    get inThread() {
+        return this.unavailable;
+    }
+    /**
+     * Which table set calls run on: bumped when the worker is lost. A handle opened under another
+     * names a table that is gone (or, here, another source's), so its source must open again.
+     */
+    get generation() {
+        return this.tables;
+    }
+    /** Run `request` in the worker, or here when there is none. */
+    async call(request) {
+        return (await this.run(request)).result;
+    }
+    /** {@link call}, with the {@link generation} the request ran on. */
+    async run(request) {
+        const started = await this.ensureWorker();
+        // The worker may have been lost while this waited for it.
+        const worker = started === this.worker ? started : null;
+        const generation = this.tables;
+        if (!worker)
+            return { result: (this.local ??= new RegionSourceTables()).run(request), generation };
+        const id = this.nextId++;
+        const result = await new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: resolve, reject });
+            worker.postMessage({ ...request, id });
+        });
+        return { result, generation };
+    }
+    /** Terminate the worker; calls in flight reject. */
+    dispose() {
+        this.lose();
+    }
+    ensureWorker() {
+        if (this.worker)
+            return Promise.resolve(this.worker);
+        if (this.unavailable || (!this.factory && typeof Worker === 'undefined')) {
+            this.unavailable = true;
+            return Promise.resolve(null);
+        }
+        if (!this.starting) {
+            const starting = this.startWorker();
+            this.starting = starting;
+            void starting.then(() => {
+                if (this.starting === starting)
+                    this.starting = null;
+            });
+        }
+        return this.starting;
+    }
+    async startWorker() {
+        try {
+            const made = this.factory
+                ? this.factory()
+                : import('./region-source-worker').then((m) => m.createRegionSourceWorker());
+            const worker = made instanceof Promise ? await made : made;
+            worker.onmessage = (event) => this.onReply(event.data);
+            worker.onerror = (event) => {
+                event.preventDefault?.();
+                if (worker === this.worker) {
+                    console.warn('[region-source] worker failed; tiling on the main thread');
+                    this.lose();
+                }
+            };
+            this.worker = worker;
+            return worker;
+        }
+        catch (err) {
+            console.warn('[region-source] worker unavailable; tiling on the main thread', err);
+            this.unavailable = true;
+            return null;
+        }
+    }
+    onReply(reply) {
+        const call = this.pending.get(reply.id);
+        if (!call)
+            return;
+        this.pending.delete(reply.id);
+        if (reply.ok)
+            call.resolve(reply.result);
+        else
+            call.reject(new Error(reply.error));
+    }
+    /** Stop the worker for good: every later call runs here, every call in flight is lost. */
+    lose() {
+        if (this.worker)
+            this.tables++;
+        this.unavailable = true;
+        this.worker?.terminate();
+        this.worker = null;
+        const calls = [...this.pending.values()];
+        this.pending.clear();
+        for (const call of calls)
+            call.reject(new WorkerLostError());
+    }
+}
+let shared = null;
+/** The worker client every GeoJSON source shares. */
+export function sharedRegionSourceClient() {
+    return (shared ??= new RegionSourceWorkerClient());
+}
+/**
+ * Open a GeoJSON FeatureCollection string as a tiled region source. Rejects on invalid JSON or
+ * a collection without `features`.
+ */
+export async function openGeoJsonRegionSource(text, client = sharedRegionSourceClient()) {
+    // The worker lost under the open: open on the main thread instead.
+    const opened = await client
+        .run({ op: 'open', text })
+        .catch((err) => (err instanceof WorkerLostError ? client.run({ op: 'open', text }) : Promise.reject(err)));
+    const { handle, info } = opened.result;
+    return new WorkerRegionSource(client, text, handle, opened.generation, info);
+}
+/**
+ * The 3D reconstruction of a region from its outlines on a stack (see `geometry/reconstruct`),
+ * meshed in the region-source worker (on the main thread where there is none).
+ */
+export function reconstructInWorker(slices, options, client = sharedRegionSourceClient()) {
+    return client.call({ op: 'mesh', slices, options });
+}
+class WorkerRegionSource {
+    constructor(client, text, handle, 
+    /** The client's {@link RegionSourceWorkerClient.generation} {@link handle} was opened under. */
+    generation, info) {
+        this.client = client;
+        this.text = text;
+        this.handle = handle;
+        this.generation = generation;
+        this.info = info;
+        this.cache = new RegionTileCache();
+        this.disposed = false;
+        /** The main-thread re-open after the worker died, shared by every call that finds it so. */
+        this.reopening = null;
+    }
+    getTile(z, key, signal) {
+        const tile = this.cache.get(z, key, () => this.call((handle) => ({ op: 'tile', handle, z, level: key.level, gx: key.gx, gy: key.gy })));
+        return abortable(tile, signal);
+    }
+    getFeatures(ids) {
+        return this.call((handle) => ({ op: 'features', handle, ids }));
+    }
+    getIndex(z, query) {
+        return this.call((handle) => ({ op: 'index', handle, z, query }));
+    }
+    getClassOutlines(classes, level, exclude) {
+        return this.call((handle) => ({ op: 'outlines', handle, classes, level, exclude }));
+    }
+    getClassCounts(z, exclude) {
+        return this.call((handle) => ({ op: 'classes', handle, z, exclude }));
+    }
+    exportGeoJson(exclude, extra) {
+        return this.call((handle) => ({ op: 'export', handle, exclude, extra }));
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.cache.clear();
+        // A handle from a lost worker's tables names nothing here, or another source's table.
+        if (this.generation !== this.client.generation)
+            return;
+        void this.client.call({ op: 'close', handle: this.handle }).catch(() => undefined);
+    }
+    /**
+     * Run a request on this source's table; when the worker died (under this call or before it),
+     * re-open here and run it there.
+     */
+    async call(make) {
+        for (let attempt = 0;; attempt++) {
+            if (this.generation !== this.client.generation)
+                await this.reopen();
+            try {
+                return await this.client.call(make(this.handle));
+            }
+            catch (err) {
+                if (!(err instanceof WorkerLostError) || attempt > 0)
+                    throw err;
+            }
+        }
+    }
+    /** Open this source's text again on the client's current tables, once for every call waiting. */
+    reopen() {
+        this.reopening ??= this.client
+            .run({ op: 'open', text: this.text })
+            .then(({ result, generation }) => {
+            this.handle = result.handle;
+            this.generation = generation;
+        })
+            .finally(() => (this.reopening = null));
+        return this.reopening;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker-region-source.js","sourceRoot":"","sources":["../../../../src/lib/region-source/worker-region-source.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A {@link RegionSource} over a GeoJSON string, parsed and tiled in the region-source Web Worker.\n *\n * One worker serves every open source. Where no worker can start (jsdom, SSR, a blocked worker\n * URL) the same tables run on the main thread; if the worker dies, each source re-opens itself\n * there from its text (which the host holds anyway: it handed it over) and carries on — whether\n * it had a call in flight then or not (see {@link RegionSourceWorkerClient.generation}).\n */\nimport { RegionSource, RegionTileCache, SourceFeature, abortable } from './region-source';\nimport {\n  RegionSourceMessage,\n  RegionSourceReply,\n  RegionSourceRequest,\n  RegionSourceResults,\n  RegionSourceTables,\n} from './region-source-ops';\nimport type {\n  ClassOutlines,\n  RegionIndexPage,\n  RegionIndexQuery,\n  RegionSourceInfo,\n  RegionTile,\n  RegionTileKey,\n} from './region-tiles';\nimport type { ReconstructOptions, SliceOutlines } from '../geometry/reconstruct';\nimport type { Mesh } from 'napari-js/geometry';\n\n/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */\nexport type RegionSourceWorkerFactory = () => Worker | Promise<Worker>;\n\n/** The worker died under a call; the caller re-opens on the main thread. */\nclass WorkerLostError extends Error {\n  constructor() {\n    super('The region-source worker stopped.');\n    this.name = 'WorkerLostError';\n  }\n}\n\ninterface PendingCall {\n  resolve: (value: unknown) => void;\n  reject: (reason: unknown) => void;\n}\n\n/** Owns the region-source worker and the calls in flight on it. */\nexport class RegionSourceWorkerClient {\n  private worker: Worker | null = null;\n  private starting: Promise<Worker | null> | null = null;\n  private unavailable = false;\n  private nextId = 1;\n  private readonly pending = new Map<number, PendingCall>();\n  /** The main-thread tables, once anything runs here. */\n  private local: RegionSourceTables | null = null;\n  private tables = 0;\n\n  /**\n   * `factory` is optional: without one the real worker module is imported on demand —\n   * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile\n   * rejects.\n   */\n  constructor(private readonly factory?: RegionSourceWorkerFactory) {}\n\n  /** Whether calls now run on the main thread. */\n  get inThread(): boolean {\n    return this.unavailable;\n  }\n\n  /**\n   * Which table set calls run on: bumped when the worker is lost. A handle opened under another\n   * names a table that is gone (or, here, another source's), so its source must open again.\n   */\n  get generation(): number {\n    return this.tables;\n  }\n\n  /** Run `request` in the worker, or here when there is none. */\n  async call<R extends RegionSourceRequest>(request: R): Promise<RegionSourceResults[R['op']]> {\n    return (await this.run(request)).result;\n  }\n\n  /** {@link call}, with the {@link generation} the request ran on. */\n  async run<R extends RegionSourceRequest>(\n    request: R,\n  ): Promise<{ result: RegionSourceResults[R['op']]; generation: number }> {\n    const started = await this.ensureWorker();\n    // The worker may have been lost while this waited for it.\n    const worker = started === this.worker ? started : null;\n    const generation = this.tables;\n    if (!worker) return { result: (this.local ??= new RegionSourceTables()).run(request), generation };\n    const id = this.nextId++;\n    const result = await new Promise<RegionSourceResults[R['op']]>((resolve, reject) => {\n      this.pending.set(id, { resolve: resolve as (v: unknown) => void, reject });\n      worker.postMessage({ ...request, id } as RegionSourceMessage);\n    });\n    return { result, generation };\n  }\n\n  /** Terminate the worker; calls in flight reject. */\n  dispose(): void {\n    this.lose();\n  }\n\n  private ensureWorker(): Promise<Worker | null> {\n    if (this.worker) return Promise.resolve(this.worker);\n    if (this.unavailable || (!this.factory && typeof Worker === 'undefined')) {\n      this.unavailable = true;\n      return Promise.resolve(null);\n    }\n    if (!this.starting) {\n      const starting = this.startWorker();\n      this.starting = starting;\n      void starting.then(() => {\n        if (this.starting === starting) this.starting = null;\n      });\n    }\n    return this.starting;\n  }\n\n  private async startWorker(): Promise<Worker | null> {\n    try {\n      const made = this.factory\n        ? this.factory()\n        : import('./region-source-worker').then((m) => m.createRegionSourceWorker());\n      const worker = made instanceof Promise ? await made : made;\n      worker.onmessage = (event: MessageEvent<RegionSourceReply>) => this.onReply(event.data);\n      worker.onerror = (event: Event) => {\n        event.preventDefault?.();\n        if (worker === this.worker) {\n          console.warn('[region-source] worker failed; tiling on the main thread');\n          this.lose();\n        }\n      };\n      this.worker = worker;\n      return worker;\n    } catch (err) {\n      console.warn('[region-source] worker unavailable; tiling on the main thread', err);\n      this.unavailable = true;\n      return null;\n    }\n  }\n\n  private onReply(reply: RegionSourceReply): void {\n    const call = this.pending.get(reply.id);\n    if (!call) return;\n    this.pending.delete(reply.id);\n    if (reply.ok) call.resolve(reply.result);\n    else call.reject(new Error(reply.error));\n  }\n\n  /** Stop the worker for good: every later call runs here, every call in flight is lost. */\n  private lose(): void {\n    if (this.worker) this.tables++;\n    this.unavailable = true;\n    this.worker?.terminate();\n    this.worker = null;\n    const calls = [...this.pending.values()];\n    this.pending.clear();\n    for (const call of calls) call.reject(new WorkerLostError());\n  }\n}\n\nlet shared: RegionSourceWorkerClient | null = null;\n\n/** The worker client every GeoJSON source shares. */\nexport function sharedRegionSourceClient(): RegionSourceWorkerClient {\n  return (shared ??= new RegionSourceWorkerClient());\n}\n\n/**\n * Open a GeoJSON FeatureCollection string as a tiled region source. Rejects on invalid JSON or\n * a collection without `features`.\n */\nexport async function openGeoJsonRegionSource(\n  text: string,\n  client: RegionSourceWorkerClient = sharedRegionSourceClient(),\n): Promise<RegionSource> {\n  // The worker lost under the open: open on the main thread instead.\n  const opened = await client\n    .run({ op: 'open', text })\n    .catch((err) => (err instanceof WorkerLostError ? client.run({ op: 'open', text }) : Promise.reject(err)));\n  const { handle, info } = opened.result;\n  return new WorkerRegionSource(client, text, handle, opened.generation, info);\n}\n\n/**\n * The 3D reconstruction of a region from its outlines on a stack (see `geometry/reconstruct`),\n * meshed in the region-source worker (on the main thread where there is none).\n */\nexport function reconstructInWorker(\n  slices: readonly SliceOutlines[],\n  options?: ReconstructOptions,\n  client: RegionSourceWorkerClient = sharedRegionSourceClient(),\n): Promise<Mesh> {\n  return client.call({ op: 'mesh', slices, options });\n}\n\nclass WorkerRegionSource implements RegionSource {\n  private readonly cache = new RegionTileCache();\n  private disposed = false;\n  /** The main-thread re-open after the worker died, shared by every call that finds it so. */\n  private reopening: Promise<void> | null = null;\n\n  constructor(\n    private readonly client: RegionSourceWorkerClient,\n    private readonly text: string,\n    private handle: number,\n    /** The client's {@link RegionSourceWorkerClient.generation} {@link handle} was opened under. */\n    private generation: number,\n    readonly info: RegionSourceInfo,\n  ) {}\n\n  getTile(z: number, key: RegionTileKey, signal?: AbortSignal): Promise<RegionTile> {\n    const tile = this.cache.get(z, key, () =>\n      this.call((handle) => ({ op: 'tile', handle, z, level: key.level, gx: key.gx, gy: key.gy })),\n    );\n    return abortable(tile, signal);\n  }\n\n  getFeatures(ids: readonly string[]): Promise<SourceFeature[]> {\n    return this.call((handle) => ({ op: 'features', handle, ids }));\n  }\n\n  getIndex(z: number, query: RegionIndexQuery): Promise<RegionIndexPage> {\n    return this.call((handle) => ({ op: 'index', handle, z, query }));\n  }\n\n  getClassOutlines(\n    classes: readonly string[] | null,\n    level: number,\n    exclude?: readonly string[],\n  ): Promise<ClassOutlines[]> {\n    return this.call((handle) => ({ op: 'outlines', handle, classes, level, exclude }));\n  }\n\n  getClassCounts(z: number | null, exclude?: readonly string[]): Promise<Record<string, number>> {\n    return this.call((handle) => ({ op: 'classes', handle, z, exclude }));\n  }\n\n  exportGeoJson(exclude: readonly string[], extra: readonly object[]): Promise<string> {\n    return this.call((handle) => ({ op: 'export', handle, exclude, extra }));\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.cache.clear();\n    // A handle from a lost worker's tables names nothing here, or another source's table.\n    if (this.generation !== this.client.generation) return;\n    void this.client.call({ op: 'close', handle: this.handle }).catch(() => undefined);\n  }\n\n  /**\n   * Run a request on this source's table; when the worker died (under this call or before it),\n   * re-open here and run it there.\n   */\n  private async call<R extends RegionSourceRequest>(\n    make: (handle: number) => R,\n  ): Promise<RegionSourceResults[R['op']]> {\n    for (let attempt = 0; ; attempt++) {\n      if (this.generation !== this.client.generation) await this.reopen();\n      try {\n        return await this.client.call(make(this.handle));\n      } catch (err) {\n        if (!(err instanceof WorkerLostError) || attempt > 0) throw err;\n      }\n    }\n  }\n\n  /** Open this source's text again on the client's current tables, once for every call waiting. */\n  private reopen(): Promise<void> {\n    this.reopening ??= this.client\n      .run({ op: 'open', text: this.text })\n      .then(({ result, generation }) => {\n        this.handle = result.handle;\n        this.generation = generation;\n      })\n      .finally(() => (this.reopening = null));\n    return this.reopening;\n  }\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":"AAmCA,MAAM,OAAO,kBAAkB;IAC7B,YACU,IAAuB,EACvB,eAAe,IAAI;QADnB,SAAI,GAAJ,IAAI,CAAmB;QACvB,iBAAY,GAAZ,YAAY,CAAO;IAC1B,CAAC;IAEJ,gFAAgF;IAChF,KAAK,CAAC,MAAM,CAAC,IAAgB,EAAE,SAA4B;QACzD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACzC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;YACjD,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;gBACrC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;YAChD,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,oBAAoB,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC9C,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACvB,oBAAoB,GAAG,IAAI,CAAC;YAC5B,OAAO,CAAC,GAAG,CAAC,iDAAiD,CAAC,CAAC;QACjE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,0EAA0E;YAC1E,4EAA4E;YAC5E,OAAO,CAAC,IAAI,CAAC,kDAAkD,EAAE,GAAG,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YAC3B,IAAI,oBAAoB,EAAE,CAAC;gBACzB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,sDAAsD,CAAC,CAAC;YACnF,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,qDAAqD,CAAC,CAAC;YACnF,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YAC3B,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,GAAG,CAAC,CAAC;YAC5D,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,wEAAwE;IAChE,oBAAoB,CAAC,IAAgB;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACrD,OAAO,CAAC,IAAI,CAAC,wDAAwD,EAAE,GAAG,CAAC,CAAC;YAC5E,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACtF,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAClC,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,aAAa;IAGxB,YACU,KAA0B,EAC1B,UAAU,GAAG;QADb,UAAK,GAAL,KAAK,CAAqB;QAC1B,YAAO,GAAP,OAAO,CAAM;QAJf,UAAK,GAAyC,IAAI,CAAC;IAKxD,CAAC;IAEJ,iDAAiD;IACjD,KAAK,CAAC,CAAS;QACb,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAChB,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;IAED,mFAAmF;IACnF,MAAM,CAAC,CAAS;QACd,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAChB,CAAC;IAED,wDAAwD;IACxD,MAAM;QACJ,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QACpB,CAAC;IACH,CAAC;CACF","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"]}