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

package/esm2022/lib/implementations/spatial-data-http/spatial-data-http.service.mjs

@@ -1,11 +1,43 @@
 import { HttpClient } from '@angular/common/http';
+import { LruCache } from 'napari-js';
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, firstValueFrom } from 'rxjs';
 import { timeout } from 'rxjs/operators';
+import { ALL_GENES } from '../../contracts/ports/spatial-data.port';
 import { findColumnMeta, } from '../../contracts/spatial-dataset.contract';
 import { assertManifestVersion, datasetFromManifest, decodeColumn, decodeCoords, decodeDensity, decodeEmbedding, decodeFeatureVector, decodePolygonTile, decodePolygons, decodeRadius, decodeTranscriptTile, } from './spatial-wire';
+import { searchGeneNames } from '../../spatial/gene-search';
+import { Supersede } from '../../util/supersede';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
+/**
+ * A dataset selection that a newer selection (or a `clear`) overtook.
+ *
+ * Thrown rather than resolved so a caller cannot mistake it for "this dataset is
+ * now loaded": nothing was published, on purpose.
+ */
+export class SupersededError extends Error {
+    constructor(id) {
+        super(`[spatial] selection of "${id}" was superseded by a newer one`);
+        this.name = 'SupersededError';
+    }
+}
+/**
+ * Bytes a decoded payload holds: its own typed-array views, one level deep — every
+ * payload here is a typed array or a flat record of them.
+ */
+function payloadBytes(value) {
+    if (ArrayBuffer.isView(value))
+        return value.byteLength;
+    let bytes = 0;
+    if (value && typeof value === 'object') {
+        for (const v of Object.values(value))
+            if (ArrayBuffer.isView(v))
+                bytes += v.byteLength;
+    }
+    return bytes;
+}
+const MiB = 1024 * 1024;
 /**
  * Reference {@link SpatialDataPort} adapter for the wire format the bundled
  * example server speaks (see `spatial-wire.ts` and
@@ -29,18 +61,6 @@ import * as i1 from "@angular/common/http";
  * Requests go through Angular's `HttpClient` (not `fetch`) so the host's
  * interceptors — auth headers above all — apply, matching `tile-client.ts`.
  */
-/**
- * A dataset selection that a newer selection (or a `clear`) overtook.
- *
- * Thrown rather than resolved so a caller cannot mistake it for "this dataset is
- * now loaded": nothing was published, on purpose.
- */
-export class SupersededError extends Error {
-    constructor(id) {
-        super(`[spatial] selection of "${id}" was superseded by a newer one`);
-        this.name = 'SupersededError';
-    }
-}
 export class SpatialDataHttpService {
     static { this.CACHE_LIMIT = 32; }
     static { this.TILE_CACHE_LIMIT = 384; }
@@ -53,16 +73,23 @@ export class SpatialDataHttpService {
         this.timeoutMs = 30_000;
         this.dataset$ = new BehaviorSubject(null);
         this.manifest = null;
-        /** Bumped by every `selectDataset` and every `clear`, so a selection that
-         *  finishes after a newer intent can tell and drop what it fetched. */
-        this.selectToken = 0;
+        /** Advanced by every `selectDataset` and every `clear`, so a selection that
+         *  finishes after a newer intent can tell and drop what it fetched. Cache fills
+         *  take a {@link Supersede.current snapshot} of it, so a vector or tile that lands
+         *  after a switch is returned to its caller but never kept for the next dataset. */
+        this.selection = new Supersede();
         /**
          * Loaded vectors, keyed `column:<name>` / `feature:<name>`. Bounded LRU:
          * colouring by cluster → by a gene → back by cluster must not refetch, but an
-         * afternoon of browsing genes must not grow without limit either (one vector
-         * is `4·N` bytes — 2 MB at 500k cells).
+         * afternoon of browsing genes must not grow without limit either.
+         *
+         * Bounded by BYTES as well as entries: one vector is `4·N` bytes — 2 MB at 500k
+         * cells, but 14.8 MB at 3.7M, where 32 entries (an embedding is two or three
+         * vectors) could pin close to half a gigabyte.
          */
         this.cache = new Map();
+        this.cachedBytes = 0;
+        this.cacheBytes = 256 * MiB;
         /** In-flight requests, so double-clicking a gene issues one fetch. */
         this.inFlight = new Map();
         /**
@@ -70,24 +97,37 @@ export class SpatialDataHttpService {
          * of a zoomed-out section is dozens of them — far past the vector cache's limit.
          */
         this.tileCache = new Map();
+        /** Bytes of each RESOLVED tile in {@link tileCache}; a pending one counts once it lands. */
+        this.tileBytes = new Map();
+        this.tileBytesTotal = 0;
+        this.tileCacheBytes = 128 * MiB;
         this.volumePromise = null;
         this.polygonsPromise = null;
-        /** Small JSON answers, keyed by URL — hovering back and forth must not refetch. */
-        this.summaryCache = new Map();
+        /** Small JSON answers, keyed by URL — hovering back and forth must not refetch. Least recently
+         *  USED goes first, so the summary under the pointer stays while others are evicted. */
+        this.summaryCache = new LruCache(256);
     }
     // ── configuration ───────────────────────────────────────────────────────
-    /** Point the adapter at a server. Clears any loaded dataset. */
+    /**
+     * Point the adapter at a server. Clears any loaded dataset.
+     *
+     * `cacheBytes` / `tileCacheBytes` cap the decoded vectors (default 256 MiB) and tiles
+     * (default 128 MiB) kept for reuse; the most recent entry is always kept.
+     */
     configure(options) {
         const raw = options.baseUrl ?? '';
         this.baseUrl = raw.endsWith('/') ? raw : `${raw}/`;
         if (options.timeoutMs !== undefined)
             this.timeoutMs = options.timeoutMs;
+        if (options.cacheBytes !== undefined)
+            this.cacheBytes = options.cacheBytes;
+        if (options.tileCacheBytes !== undefined)
+            this.tileCacheBytes = options.tileCacheBytes;
         this.clear();
     }
     /** Datasets this server offers, for a host-side picker. */
     listDatasets() {
-        return this.getJson('spatial/datasets')
-            .then((r) => r.datasets ?? []);
+        return this.getJson('spatial/datasets').then((r) => r.datasets ?? []);
     }
     /**
      * One dataset's manifest, WITHOUT selecting it. Lets a host inspect what a
@@ -96,43 +136,41 @@ export class SpatialDataHttpService {
      * dataset to find out.
      */
     readManifest(id) {
-        return this.getJson(`spatial/${encodeURIComponent(id)}/manifest`)
-            .then((manifest) => {
+        return this.getJson(`spatial/${encodeURIComponent(id)}/manifest`).then((manifest) => {
             assertManifestVersion(manifest);
             return manifest;
         });
     }
     /**
      * Load a dataset and publish it on {@link getDataset$}. Fetches the manifest,
-     * then the vectors that are always needed (coordinates, and ids/radius when
-     * the manifest says they exist) — nothing else.
+     * then, in parallel, the vectors that are always needed (coordinates, and
+     * ids/radius when the manifest says they exist) — nothing else.
      */
     async selectDataset(id) {
         this.clear();
-        // Selections are SEQUENCED: this is four awaits deep, so a slower earlier
+        // Selections are SEQUENCED: this is two awaits deep, so a slower earlier
         // call would otherwise assign `this.manifest` or publish its dataset after a
         // later one — leaving the manifest and the observations from two different
         // datasets, which is worse than either being late.
-        const mine = ++this.selectToken;
-        const superseded = () => mine !== this.selectToken;
+        const task = this.selection.next();
+        const superseded = () => !task.isCurrent();
         const path = `spatial/${encodeURIComponent(id)}`;
         const manifest = await this.getJson(`${path}/manifest`);
         assertManifestVersion(manifest);
         if (superseded())
             throw new SupersededError(id);
         this.manifest = manifest;
-        const coordsBuf = await this.getBinary(`${path}/coords`);
+        // Independent of each other, so requested together: time to first paint is the
+        // slowest of them, not their sum (the ids JSON alone is tens of MB on a large dataset).
+        const [coordsBuf, ids, radiusBuf] = await Promise.all([
+            this.getBinary(`${path}/coords`),
+            manifest.hasIds ? this.getJson(`${path}/ids`).then((r) => r.ids) : undefined,
+            manifest.radius?.mode === 'per-observation' ? this.getBinary(`${path}/radius`) : undefined,
+        ]);
         if (superseded())
             throw new SupersededError(id);
         const coords = decodeCoords(coordsBuf, manifest.count, !!manifest.hasZ);
-        const ids = manifest.hasIds
-            ? (await this.getJson(`${path}/ids`)).ids
-            : undefined;
-        const radius = manifest.radius?.mode === 'per-observation'
-            ? decodeRadius(await this.getBinary(`${path}/radius`), manifest.count)
-            : undefined;
-        if (superseded())
-            throw new SupersededError(id);
+        const radius = radiusBuf ? decodeRadius(radiusBuf, manifest.count) : undefined;
         const dataset = datasetFromManifest(manifest, coords, { ids, radius });
         this.dataset$.next(dataset);
         return dataset;
@@ -141,11 +179,14 @@ export class SpatialDataHttpService {
     clear() {
         // A clear is itself the newest intent, so it supersedes any selection still
         // in flight rather than letting one land afterwards.
-        this.selectToken++;
+        this.selection.cancel();
         this.manifest = null;
         this.cache.clear();
+        this.cachedBytes = 0;
         this.inFlight.clear();
         this.tileCache.clear();
+        this.tileBytes.clear();
+        this.tileBytesTotal = 0;
         this.summaryCache.clear();
         this.polygonsPromise = null;
         this.volumePromise = null;
@@ -165,8 +206,7 @@ export class SpatialDataHttpService {
             // as a plot that silently renders every point as "no data".
             return Promise.reject(new Error(`[spatial] unknown column "${name}". Available: ${dataset.columns.map((c) => c.name).join(', ')}`));
         }
-        return this.fetchCached(`column:${name}`, () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/column/${encodeURIComponent(name)}`)
-            .then((buf) => decodeColumn(buf, meta, manifest.count)));
+        return this.fetchCached(`column:${name}`, () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/column/${encodeURIComponent(name)}`).then((buf) => decodeColumn(buf, meta, manifest.count)));
     }
     getEmbedding(name) {
         const manifest = this.requireManifest();
@@ -182,20 +222,16 @@ export class SpatialDataHttpService {
         if (names && !names.includes(name)) {
             return Promise.reject(new Error(`[spatial] unknown feature "${name}"`));
         }
-        return this.fetchCached(`feature:${name}`, () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/feature/${encodeURIComponent(name)}`)
-            .then((buf) => decodeFeatureVector(buf, manifest.count)));
+        return this.fetchCached(`feature:${name}`, () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/feature/${encodeURIComponent(name)}`).then((buf) => decodeFeatureVector(buf, manifest.count)));
     }
     async searchFeatures(query, limit = 50) {
         const manifest = this.requireManifest();
         // A dataset that inlined its names (targeted panel) is filtered locally —
-        // no round-trip for a keystroke.
+        // no round-trip for a keystroke — and ranked as the picker ranks them.
         const names = manifest.features?.names;
-        if (names) {
-            const q = query.toLowerCase();
-            return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);
-        }
-        const url = `spatial/${encodeURIComponent(manifest.id)}/features`
-            + `?q=${encodeURIComponent(query)}&limit=${limit}`;
+        if (names)
+            return searchGeneNames(names, query, limit);
+        const url = `spatial/${encodeURIComponent(manifest.id)}/features` + `?q=${encodeURIComponent(query)}&limit=${limit}`;
         return (await this.getJson(url)).names ?? [];
     }
     getPolygons() {
@@ -205,10 +241,12 @@ export class SpatialDataHttpService {
         }
         // Geometry is one large blob rather than a per-name vector, so it gets its
         // own single-flight slot instead of a cache entry.
-        this.polygonsPromise ??= this
-            .getBinary(`spatial/${encodeURIComponent(manifest.id)}/polygons`)
+        this.polygonsPromise ??= this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/polygons`)
             .then(decodePolygons)
-            .catch((err) => { this.polygonsPromise = null; throw err; });
+            .catch((err) => {
+            this.polygonsPromise = null;
+            throw err;
+        });
         return this.polygonsPromise;
     }
     getPolygonTile(set, level, gx, gy) {
@@ -216,9 +254,9 @@ export class SpatialDataHttpService {
         if (!manifest.polygonTiles) {
             return Promise.reject(new Error('[spatial] this dataset has no tiled polygons'));
         }
-        const path = `spatial/${encodeURIComponent(manifest.id)}/polygon-tile/`
-            + `${encodeURIComponent(set)}/${level}/${gx}/${gy}`;
-        return this.cachedTile(path, () => this.getBinary(path).then(decodePolygonTile));
+        const path = `spatial/${encodeURIComponent(manifest.id)}/polygon-tile/` +
+            `${encodeURIComponent(set)}/${level}/${gx}/${gy}`;
+        return this.cachedTile(path, () => this.getBinary(path).then((buf) => decodePolygonTile(buf, manifest.count)));
     }
     getTranscriptTile(level, gx, gy, query) {
         const manifest = this.requireManifest();
@@ -227,15 +265,28 @@ export class SpatialDataHttpService {
         }
         const genes = query.genes.map(encodeURIComponent).join(',');
         const box = query.box ? `&box=${query.box.join(',')}` : '';
-        const path = `spatial/${encodeURIComponent(manifest.id)}/transcript-tile/${level}/${gx}/${gy}`
-            + `?genes=${genes}&quality=${query.quality ?? 'high'}${box}`;
-        return this.cachedTile(path, () => this.getBinary(path).then(decodeTranscriptTile));
+        const path = `spatial/${encodeURIComponent(manifest.id)}/transcript-tile/${level}/${gx}/${gy}` +
+            `?genes=${genes}&quality=${query.quality ?? 'high'}${box}`;
+        // The codes index the genes asked for — except for ALL_GENES, whose list the
+        // server owns, so only the observations can be bounded there.
+        const limits = {
+            observations: manifest.count,
+            ...(query.genes.includes(ALL_GENES) ? {} : { genes: query.genes.length }),
+        };
+        return this.cachedTile(path, () => this.getBinary(path).then((buf) => decodeTranscriptTile(buf, limits)));
     }
     getTranscriptGeneBins(level, tx, ty, genes) {
         const manifest = this.requireManifest();
-        const path = `spatial/${encodeURIComponent(manifest.id)}/gene-bins/${level}/${tx}/${ty}`
-            + `?genes=${genes.map(encodeURIComponent).join(',')}`;
-        return this.cachedTile(path, () => this.getBinary(path).then(decodeTranscriptTile));
+        if (!manifest.transcriptGeneBins) {
+            return Promise.reject(new Error('[spatial] this dataset has no per-gene bins'));
+        }
+        const path = `spatial/${encodeURIComponent(manifest.id)}/gene-bins/${level}/${tx}/${ty}` +
+            `?genes=${genes.map(encodeURIComponent).join(',')}`;
+        const limits = {
+            observations: manifest.count,
+            ...(genes.includes(ALL_GENES) ? {} : { genes: genes.length }),
+        };
+        return this.cachedTile(path, () => this.getBinary(path).then((buf) => decodeTranscriptTile(buf, limits)));
     }
     getTranscriptBins(level, tx, ty) {
         const manifest = this.requireManifest();
@@ -243,7 +294,7 @@ export class SpatialDataHttpService {
             return Promise.reject(new Error('[spatial] this dataset has no transcript pyramid'));
         }
         const path = `spatial/${encodeURIComponent(manifest.id)}/transcript-bins/${level}/${tx}/${ty}`;
-        return this.cachedTile(path, () => this.getBinary(path).then(decodeTranscriptTile));
+        return this.cachedTile(path, () => this.getBinary(path).then((buf) => decodeTranscriptTile(buf, { observations: manifest.count })));
     }
     getTranscriptSummary(query) {
         const manifest = this.requireManifest();
@@ -260,8 +311,6 @@ export class SpatialDataHttpService {
             hit = this.getJson(url);
             hit.catch(() => this.summaryCache.delete(url));
             this.summaryCache.set(url, hit);
-            if (this.summaryCache.size > 256)
-                this.summaryCache.delete(this.summaryCache.keys().next().value);
         }
         return hit;
     }
@@ -280,9 +329,11 @@ export class SpatialDataHttpService {
         // upload as they do to every read, or a protected server refuses it.
         let body;
         try {
-            body = await firstValueFrom(this.http.post(url, table, {
+            body = await firstValueFrom(this.http
+                .post(url, table, {
                 headers: { 'Content-Type': 'text/csv' },
-            }).pipe(timeout(this.timeoutMs)));
+            })
+                .pipe(timeout(this.timeoutMs)));
         }
         catch (err) {
             const e = err;
@@ -294,7 +345,7 @@ export class SpatialDataHttpService {
         if (current && this.manifest?.id === manifest.id) {
             const columns = current.columns.filter((c) => c.name !== column.name).concat(column);
             this.manifest = { ...this.manifest, columns };
-            this.cache.delete(`column:${column.name}`);
+            this.uncache(`column:${column.name}`);
             this.dataset$.next({ ...current, columns });
         }
         return { column, matched: body.matched };
@@ -316,20 +367,39 @@ export class SpatialDataHttpService {
             this.tileCache.set(key, hit);
             return hit;
         }
-        const mine = this.selectToken;
-        const promise = load().catch((err) => {
+        const generation = this.selection.current();
+        const promise = load().then((tile) => {
+            // Sized once it lands, and only while it is still the entry under its key.
+            if (this.tileCache.get(key) === promise && !this.tileBytes.has(key)) {
+                const bytes = payloadBytes(tile);
+                this.tileBytes.set(key, bytes);
+                this.tileBytesTotal += bytes;
+                this.evictTiles();
+            }
+            return tile;
+        }, (err) => {
             if (this.tileCache.get(key) === promise)
-                this.tileCache.delete(key);
+                this.dropTile(key);
             throw err;
         });
-        if (mine === this.selectToken) {
+        if (generation.isCurrent()) {
             this.tileCache.set(key, promise);
-            while (this.tileCache.size > SpatialDataHttpService.TILE_CACHE_LIMIT) {
-                this.tileCache.delete(this.tileCache.keys().next().value);
-            }
+            this.evictTiles();
         }
         return promise;
     }
+    /** Oldest first, past the entry cap or the byte budget, keeping the newest. */
+    evictTiles() {
+        while (this.tileCache.size > 1 &&
+            (this.tileCache.size > SpatialDataHttpService.TILE_CACHE_LIMIT || this.tileBytesTotal > this.tileCacheBytes)) {
+            this.dropTile(this.tileCache.keys().next().value);
+        }
+    }
+    dropTile(key) {
+        this.tileCache.delete(key);
+        this.tileBytesTotal -= this.tileBytes.get(key) ?? 0;
+        this.tileBytes.delete(key);
+    }
     /**
      * The reference volume's voxels, single-flighted like the polygons.
      *
@@ -344,17 +414,19 @@ export class SpatialDataHttpService {
         if (!meta) {
             return Promise.reject(new Error('[spatial] this dataset has no reference volume'));
         }
-        this.volumePromise ??= this
-            .getBinary(`spatial/${encodeURIComponent(manifest.id)}/volume`)
+        this.volumePromise ??= this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/volume`)
             .then((buf) => {
             const want = meta.width * meta.height * meta.depth;
             if (buf.byteLength !== want) {
-                throw new Error(`[spatial] volume is ${buf.byteLength} bytes, expected ${want} `
-                    + `(${meta.width}x${meta.height}x${meta.depth})`);
+                throw new Error(`[spatial] volume is ${buf.byteLength} bytes, expected ${want} ` +
+                    `(${meta.width}x${meta.height}x${meta.depth})`);
             }
             return new Uint8Array(buf);
         })
-            .catch((err) => { this.volumePromise = null; throw err; });
+            .catch((err) => {
+            this.volumePromise = null;
+            throw err;
+        });
         return this.volumePromise;
     }
     // ── internals ───────────────────────────────────────────────────────────
@@ -385,19 +457,22 @@ export class SpatialDataHttpService {
             // Re-insert to mark most-recently-used (Map preserves insertion order).
             this.cache.delete(key);
             this.cache.set(key, hit);
-            return Promise.resolve(hit);
+            return Promise.resolve(hit.value);
         }
         const pending = this.inFlight.get(key);
         if (pending)
             return pending;
-        const mine = this.selectToken;
+        const generation = this.selection.current();
         const promise = load()
             .then((value) => {
             // Still returned to the caller that asked: it may well be a component that is
             // itself being torn down, and rejecting here would surface a switch as an error.
             // What must not happen is the value being kept for whoever comes next.
-            if (mine === this.selectToken) {
-                this.cache.set(key, value);
+            if (generation.isCurrent()) {
+                this.uncache(key);
+                const bytes = payloadBytes(value);
+                this.cache.set(key, { value, bytes });
+                this.cachedBytes += bytes;
                 this.evict();
             }
             return value;
@@ -409,20 +484,25 @@ export class SpatialDataHttpService {
         this.inFlight.set(key, promise);
         return promise;
     }
+    /** Oldest first, past the entry cap or the byte budget, keeping the newest. */
     evict() {
-        while (this.cache.size > SpatialDataHttpService.CACHE_LIMIT) {
-            const oldest = this.cache.keys().next().value;
-            if (oldest === undefined)
-                break;
-            this.cache.delete(oldest);
+        while (this.cache.size > 1 &&
+            (this.cache.size > SpatialDataHttpService.CACHE_LIMIT || this.cachedBytes > this.cacheBytes)) {
+            this.uncache(this.cache.keys().next().value);
         }
     }
+    uncache(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return;
+        this.cache.delete(key);
+        this.cachedBytes -= entry.bytes;
+    }
     getJson(path) {
         return firstValueFrom(this.http.get(`${this.baseUrl}${path}`).pipe(timeout(this.timeoutMs)));
     }
     getBinary(path) {
-        return firstValueFrom(this.http.get(`${this.baseUrl}${path}`, { responseType: 'arraybuffer' })
-            .pipe(timeout(this.timeoutMs)));
+        return firstValueFrom(this.http.get(`${this.baseUrl}${path}`, { responseType: 'arraybuffer' }).pipe(timeout(this.timeoutMs)));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialDataHttpService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialDataHttpService }); }
@@ -430,4 +510,4 @@ export class SpatialDataHttpService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SpatialDataHttpService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-data-http.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/spatial-data-http/spatial-data-http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, firstValueFrom } from 'rxjs';\nimport { timeout } from 'rxjs/operators';\n\nimport { SpatialDataPort, TranscriptTileQuery } from '../../contracts/ports/spatial-data.port';\nimport {\n  SpatialColumn,\n  SpatialDataset,\n  SpatialDensityRaster,\n  SpatialEmbedding,\n  SpatialPolygonTile,\n  SpatialPolygons,\n  CategoricalColumnMeta,\n  SpatialMarkerGenes, SpatialTranscriptCounts,\n  SpatialTranscriptSummary,\n  SpatialTranscriptTile,\n  findColumnMeta,\n} from '../../contracts/spatial-dataset.contract';\nimport {\n  SpatialDatasetSummary,\n  SpatialManifest,\n  assertManifestVersion,\n  datasetFromManifest,\n  decodeColumn,\n  decodeCoords,\n  decodeDensity,\n  decodeEmbedding,\n  decodeFeatureVector,\n  decodePolygonTile,\n  decodePolygons,\n  decodeRadius,\n  decodeTranscriptTile,\n} from './spatial-wire';\n\n/**\n * Reference {@link SpatialDataPort} adapter for the wire format the bundled\n * example server speaks (see `spatial-wire.ts` and\n * `examples/tile-server/lib/spatial.mjs`).\n *\n * OPTIONAL AND UNBOUND BY DEFAULT — this service is `@Injectable()` without\n * `providedIn`, so nothing gets it unless a host explicitly provides it:\n *\n * ```ts\n * providers: [\n *   SpatialDataHttpService,\n *   { provide: SPATIAL_DATA_PORT, useExisting: SpatialDataHttpService },\n * ]\n * ```\n *\n * That mirrors `CellposeSegmenterService`: a concrete implementation the\n * library ships for convenience, not a default the port inversion is quietly\n * giving up on. A host with its own backend implements `SpatialDataPort`\n * directly and never touches this class.\n *\n * Requests go through Angular's `HttpClient` (not `fetch`) so the host's\n * interceptors — auth headers above all — apply, matching `tile-client.ts`.\n */\n/**\n * A dataset selection that a newer selection (or a `clear`) overtook.\n *\n * Thrown rather than resolved so a caller cannot mistake it for \"this dataset is\n * now loaded\": nothing was published, on purpose.\n */\nexport class SupersededError extends Error {\n  constructor(id: string) {\n    super(`[spatial] selection of \"${id}\" was superseded by a newer one`);\n    this.name = 'SupersededError';\n  }\n}\n\n/**\n * What the LRU can hold. One alias rather than a union repeated at each use, so adding a payload\n * kind is a single edit instead of four that can drift apart.\n */\ntype CachedPayload = SpatialColumn | Float32Array | SpatialEmbedding | SpatialDensityRaster;\n\n@Injectable()\nexport class SpatialDataHttpService implements SpatialDataPort {\n  /** Server root, normalised to end with exactly one `/`. */\n  private baseUrl = '';\n  /** Per-request ceiling. Vectors are small; a hung request should not wedge\n   *  the picker. */\n  private timeoutMs = 30_000;\n\n  private readonly dataset$ = new BehaviorSubject<SpatialDataset | null>(null);\n  private manifest: SpatialManifest | null = null;\n  /** Bumped by every `selectDataset` and every `clear`, so a selection that\n   *  finishes after a newer intent can tell and drop what it fetched. */\n  private selectToken = 0;\n\n  /**\n   * Loaded vectors, keyed `column:<name>` / `feature:<name>`. Bounded LRU:\n   * colouring by cluster → by a gene → back by cluster must not refetch, but an\n   * afternoon of browsing genes must not grow without limit either (one vector\n   * is `4·N` bytes — 2 MB at 500k cells).\n   */\n  private readonly cache = new Map<string, CachedPayload>();\n  private static readonly CACHE_LIMIT = 32;\n\n  /** In-flight requests, so double-clicking a gene issues one fetch. */\n  private readonly inFlight = new Map<string, Promise<CachedPayload>>();\n\n  /**\n   * Tiles get their own, larger cache: panning revisits them constantly, and one screen\n   * of a zoomed-out section is dozens of them — far past the vector cache's limit.\n   */\n  private readonly tileCache = new Map<string, Promise<SpatialPolygonTile | SpatialTranscriptTile>>();\n  private static readonly TILE_CACHE_LIMIT = 384;\n\n  private volumePromise: Promise<Uint8Array> | null = null;\n  private polygonsPromise: Promise<SpatialPolygons> | null = null;\n\n  constructor(private http: HttpClient) {}\n\n  // ── configuration ───────────────────────────────────────────────────────\n\n  /** Point the adapter at a server. Clears any loaded dataset. */\n  configure(options: { baseUrl: string; timeoutMs?: number }): void {\n    const raw = options.baseUrl ?? '';\n    this.baseUrl = raw.endsWith('/') ? raw : `${raw}/`;\n    if (options.timeoutMs !== undefined) this.timeoutMs = options.timeoutMs;\n    this.clear();\n  }\n\n  /** Datasets this server offers, for a host-side picker. */\n  listDatasets(): Promise<SpatialDatasetSummary[]> {\n    return this.getJson<{ datasets: SpatialDatasetSummary[] }>('spatial/datasets')\n      .then((r) => r.datasets ?? []);\n  }\n\n  /**\n   * One dataset's manifest, WITHOUT selecting it. Lets a host inspect what a\n   * server offers — column and feature metadata, and which image a dataset\n   * registers onto — while building a picker, rather than having to load each\n   * dataset to find out.\n   */\n  readManifest(id: string): Promise<SpatialManifest> {\n    return this.getJson<SpatialManifest>(`spatial/${encodeURIComponent(id)}/manifest`)\n      .then((manifest) => {\n        assertManifestVersion(manifest);\n        return manifest;\n      });\n  }\n\n  /**\n   * Load a dataset and publish it on {@link getDataset$}. Fetches the manifest,\n   * then the vectors that are always needed (coordinates, and ids/radius when\n   * the manifest says they exist) — nothing else.\n   */\n  async selectDataset(id: string): Promise<SpatialDataset> {\n    this.clear();\n    // Selections are SEQUENCED: this is four awaits deep, so a slower earlier\n    // call would otherwise assign `this.manifest` or publish its dataset after a\n    // later one — leaving the manifest and the observations from two different\n    // datasets, which is worse than either being late.\n    const mine = ++this.selectToken;\n    const superseded = () => mine !== this.selectToken;\n    const path = `spatial/${encodeURIComponent(id)}`;\n\n    const manifest = await this.getJson<SpatialManifest>(`${path}/manifest`);\n    assertManifestVersion(manifest);\n    if (superseded()) throw new SupersededError(id);\n    this.manifest = manifest;\n\n    const coordsBuf = await this.getBinary(`${path}/coords`);\n    if (superseded()) throw new SupersededError(id);\n    const coords = decodeCoords(coordsBuf, manifest.count, !!manifest.hasZ);\n\n    const ids = manifest.hasIds\n      ? (await this.getJson<{ ids: string[] }>(`${path}/ids`)).ids\n      : undefined;\n    const radius = manifest.radius?.mode === 'per-observation'\n      ? decodeRadius(await this.getBinary(`${path}/radius`), manifest.count)\n      : undefined;\n    if (superseded()) throw new SupersededError(id);\n\n    const dataset = datasetFromManifest(manifest, coords, { ids, radius });\n    this.dataset$.next(dataset);\n    return dataset;\n  }\n\n  /** Drop the loaded dataset and every cached vector. */\n  clear(): void {\n    // A clear is itself the newest intent, so it supersedes any selection still\n    // in flight rather than letting one land afterwards.\n    this.selectToken++;\n    this.manifest = null;\n    this.cache.clear();\n    this.inFlight.clear();\n    this.tileCache.clear();\n    this.summaryCache.clear();\n    this.polygonsPromise = null;\n    this.volumePromise = null;\n    if (this.dataset$.value !== null) this.dataset$.next(null);\n  }\n\n  // ── SpatialDataPort ─────────────────────────────────────────────────────\n\n  getDataset$(): Observable<SpatialDataset | null> {\n    return this.dataset$.asObservable();\n  }\n\n  getColumn(name: string): Promise<SpatialColumn> {\n    const manifest = this.requireManifest();\n    const dataset = this.dataset$.value!;\n    const meta = findColumnMeta(dataset, name);\n    if (!meta) {\n      // Reject rather than resolve empty: a typo must surface as an error, not\n      // as a plot that silently renders every point as \"no data\".\n      return Promise.reject(new Error(\n        `[spatial] unknown column \"${name}\". Available: ${dataset.columns.map((c) => c.name).join(', ')}`,\n      ));\n    }\n    return this.fetchCached(\n      `column:${name}`,\n      () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/column/${encodeURIComponent(name)}`)\n        .then((buf) => decodeColumn(buf, meta, manifest.count)),\n    ) as Promise<SpatialColumn>;\n  }\n\n  getEmbedding(name: string): Promise<SpatialEmbedding> {\n    const manifest = this.requireManifest();\n    const meta = manifest.embeddings?.find((e) => e.name === name);\n    if (!meta) {\n      return Promise.reject(new Error(`[spatial] unknown embedding \"${name}\"`));\n    }\n    return this.fetchCached(\n      `embedding:${name}`,\n      () => this.getBinary(\n        `spatial/${encodeURIComponent(manifest.id)}/embedding/${encodeURIComponent(name)}`,\n      ).then((buf) => decodeEmbedding(buf, meta, manifest.count)),\n    ) as Promise<SpatialEmbedding>;\n  }\n\n  getFeatureVector(name: string): Promise<Float32Array> {\n    const manifest = this.requireManifest();\n    const names = manifest.features?.names;\n    if (names && !names.includes(name)) {\n      return Promise.reject(new Error(`[spatial] unknown feature \"${name}\"`));\n    }\n    return this.fetchCached(\n      `feature:${name}`,\n      () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/feature/${encodeURIComponent(name)}`)\n        .then((buf) => decodeFeatureVector(buf, manifest.count)),\n    ) as Promise<Float32Array>;\n  }\n\n  async searchFeatures(query: string, limit = 50): Promise<string[]> {\n    const manifest = this.requireManifest();\n    // A dataset that inlined its names (targeted panel) is filtered locally —\n    // no round-trip for a keystroke.\n    const names = manifest.features?.names;\n    if (names) {\n      const q = query.toLowerCase();\n      return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);\n    }\n    const url = `spatial/${encodeURIComponent(manifest.id)}/features`\n      + `?q=${encodeURIComponent(query)}&limit=${limit}`;\n    return (await this.getJson<{ names: string[] }>(url)).names ?? [];\n  }\n\n  getPolygons(): Promise<SpatialPolygons> {\n    const manifest = this.requireManifest();\n    if (!manifest.polygons) {\n      return Promise.reject(new Error('[spatial] this dataset has no polygon geometry'));\n    }\n    // Geometry is one large blob rather than a per-name vector, so it gets its\n    // own single-flight slot instead of a cache entry.\n    this.polygonsPromise ??= this\n      .getBinary(`spatial/${encodeURIComponent(manifest.id)}/polygons`)\n      .then(decodePolygons)\n      .catch((err) => { this.polygonsPromise = null; throw err; });\n    return this.polygonsPromise;\n  }\n\n  getPolygonTile(set: string, level: number, gx: number, gy: number): Promise<SpatialPolygonTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.polygonTiles) {\n      return Promise.reject(new Error('[spatial] this dataset has no tiled polygons'));\n    }\n    const path = `spatial/${encodeURIComponent(manifest.id)}/polygon-tile/`\n      + `${encodeURIComponent(set)}/${level}/${gx}/${gy}`;\n    return this.cachedTile(path, () => this.getBinary(path).then(decodePolygonTile)) as\n      Promise<SpatialPolygonTile>;\n  }\n\n  getTranscriptTile(\n    level: number, gx: number, gy: number, query: TranscriptTileQuery,\n  ): Promise<SpatialTranscriptTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.transcriptTiles) {\n      return Promise.reject(new Error('[spatial] this dataset has no tiled transcripts'));\n    }\n    const genes = query.genes.map(encodeURIComponent).join(',');\n    const box = query.box ? `&box=${query.box.join(',')}` : '';\n    const path = `spatial/${encodeURIComponent(manifest.id)}/transcript-tile/${level}/${gx}/${gy}`\n      + `?genes=${genes}&quality=${query.quality ?? 'high'}${box}`;\n    return this.cachedTile(path, () => this.getBinary(path).then(decodeTranscriptTile)) as\n      Promise<SpatialTranscriptTile>;\n  }\n\n  getTranscriptGeneBins(level: number, tx: number, ty: number, genes: string[]): Promise<SpatialTranscriptTile> {\n    const manifest = this.requireManifest();\n    const path = `spatial/${encodeURIComponent(manifest.id)}/gene-bins/${level}/${tx}/${ty}`\n      + `?genes=${genes.map(encodeURIComponent).join(',')}`;\n    return this.cachedTile(path, () => this.getBinary(path).then(decodeTranscriptTile)) as\n      Promise<SpatialTranscriptTile>;\n  }\n\n  getTranscriptBins(level: number, tx: number, ty: number): Promise<SpatialTranscriptTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.transcriptBins) {\n      return Promise.reject(new Error('[spatial] this dataset has no transcript pyramid'));\n    }\n    const path = `spatial/${encodeURIComponent(manifest.id)}/transcript-bins/${level}/${tx}/${ty}`;\n    return this.cachedTile(path, () => this.getBinary(path).then(decodeTranscriptTile)) as\n      Promise<SpatialTranscriptTile>;\n  }\n\n  /** Small JSON answers, keyed by URL — hovering back and forth must not refetch. */\n  private readonly summaryCache = new Map<string, Promise<SpatialTranscriptSummary>>();\n\n  getTranscriptSummary(query: {\n    box?: [number, number, number, number]; genes?: string[]; cells?: number[];\n  }): Promise<SpatialTranscriptSummary> {\n    const manifest = this.requireManifest();\n    const params: string[] = [];\n    if (query.box) params.push(`box=${query.box.map((v) => +v.toFixed(3)).join(',')}`);\n    if (query.genes?.length) params.push(`genes=${query.genes.map(encodeURIComponent).join(',')}`);\n    if (query.cells?.length) params.push(`cells=${query.cells.join(',')}`);\n    const url = `spatial/${encodeURIComponent(manifest.id)}/transcript-summary?${params.join('&')}`;\n    let hit = this.summaryCache.get(url);\n    if (!hit) {\n      hit = this.getJson<SpatialTranscriptSummary>(url);\n      hit.catch(() => this.summaryCache.delete(url));\n      this.summaryCache.set(url, hit);\n      if (this.summaryCache.size > 256) this.summaryCache.delete(this.summaryCache.keys().next().value!);\n    }\n    return hit;\n  }\n\n  getDensity(genes: string[], binSize?: number): Promise<SpatialDensityRaster> {\n    const manifest = this.requireManifest();\n    if (!manifest.density) return Promise.reject(new Error('[spatial] this dataset has no density raster'));\n    const list = [...genes];\n    const bin = binSize ? `&bin=${binSize}` : '';\n    return this.fetchCached(\n      `density:${list.join(',')}:${binSize ?? ''}`,\n      () => this.getBinary(\n        `spatial/${encodeURIComponent(manifest.id)}/density?genes=${list.map(encodeURIComponent).join(',')}${bin}`,\n      ).then((buf) => decodeDensity(buf, list)),\n    ) as Promise<SpatialDensityRaster>;\n  }\n\n  async importGroups(label: string, table: string): Promise<{ column: CategoricalColumnMeta; matched: number }> {\n    const manifest = this.requireManifest();\n    const url = `${this.baseUrl}spatial/${encodeURIComponent(manifest.id)}/groups?name=${encodeURIComponent(label)}`;\n    // HttpClient, not fetch: a host's interceptors (its auth header) must apply to the\n    // upload as they do to every read, or a protected server refuses it.\n    let body: { column: CategoricalColumnMeta; matched: number };\n    try {\n      body = await firstValueFrom(\n        this.http.post<{ column: CategoricalColumnMeta; matched: number }>(url, table, {\n          headers: { 'Content-Type': 'text/csv' },\n        }).pipe(timeout(this.timeoutMs)),\n      );\n    } catch (err) {\n      const e = err as HttpErrorResponse;\n      throw new Error(e?.error?.error ?? `[spatial] import failed (HTTP ${e?.status ?? '?'})`);\n    }\n    const column = body.column;\n    // The new column joins the dataset: re-emit so every panel sees it.\n    const current = this.dataset$.value;\n    if (current && this.manifest?.id === manifest.id) {\n      const columns = current.columns.filter((c) => c.name !== column.name).concat(column);\n      this.manifest = { ...this.manifest, columns };\n      this.cache.delete(`column:${column.name}`);\n      this.dataset$.next({ ...current, columns });\n    }\n    return { column, matched: body.matched };\n  }\n\n  getMarkerGenes(column: string, perGroup = 5): Promise<SpatialMarkerGenes> {\n    const manifest = this.requireManifest();\n    // No per-request timeout: the first computation is a pass over the whole matrix.\n    return firstValueFrom(this.http.get<SpatialMarkerGenes>(\n      `${this.baseUrl}spatial/${encodeURIComponent(manifest.id)}/markers/${encodeURIComponent(column)}?n=${perGroup}`,\n    ));\n  }\n\n  getTranscriptCounts(genes: string[]): Promise<SpatialTranscriptCounts> {\n    const manifest = this.requireManifest();\n    return this.getJson<SpatialTranscriptCounts>(\n      `spatial/${encodeURIComponent(manifest.id)}/transcript-counts?genes=${genes.map(encodeURIComponent).join(',')}`,\n    );\n  }\n\n  /** LRU over tile promises, so concurrent asks share one request and a failure is not kept. */\n  private cachedTile<T extends SpatialPolygonTile | SpatialTranscriptTile>(\n    key: string, load: () => Promise<T>,\n  ): Promise<T> {\n    const hit = this.tileCache.get(key);\n    if (hit) {\n      this.tileCache.delete(key);\n      this.tileCache.set(key, hit);\n      return hit as Promise<T>;\n    }\n    const mine = this.selectToken;\n    const promise = load().catch((err) => {\n      if (this.tileCache.get(key) === promise) this.tileCache.delete(key);\n      throw err;\n    });\n    if (mine === this.selectToken) {\n      this.tileCache.set(key, promise);\n      while (this.tileCache.size > SpatialDataHttpService.TILE_CACHE_LIMIT) {\n        this.tileCache.delete(this.tileCache.keys().next().value!);\n      }\n    }\n    return promise;\n  }\n\n  /**\n   * The reference volume's voxels, single-flighted like the polygons.\n   *\n   * Validated against the manifest's declared dimensions before it is handed\n   * back: a short or long buffer read as a 3D texture does not fail, it shears\n   * the anatomy into diagonal streaks, and that is far harder to recognise as a\n   * transport problem than an error is.\n   */\n  getVolume(): Promise<Uint8Array> {\n    const manifest = this.requireManifest();\n    const meta = manifest.volume;\n    if (!meta) {\n      return Promise.reject(new Error('[spatial] this dataset has no reference volume'));\n    }\n    this.volumePromise ??= this\n      .getBinary(`spatial/${encodeURIComponent(manifest.id)}/volume`)\n      .then((buf) => {\n        const want = meta.width * meta.height * meta.depth;\n        if (buf.byteLength !== want) {\n          throw new Error(\n            `[spatial] volume is ${buf.byteLength} bytes, expected ${want} `\n            + `(${meta.width}x${meta.height}x${meta.depth})`,\n          );\n        }\n        return new Uint8Array(buf);\n      })\n      .catch((err) => { this.volumePromise = null; throw err; });\n    return this.volumePromise;\n  }\n\n  // ── internals ───────────────────────────────────────────────────────────\n\n  private requireManifest(): SpatialManifest {\n    if (!this.manifest || !this.dataset$.value) {\n      throw new Error('[spatial] no dataset selected — call selectDataset() first');\n    }\n    return this.manifest;\n  }\n\n  /**\n   * Cache + single-flight around a vector fetch.\n   *\n   * Keys are LOGICAL — `feature:GAPDH`, not `<dataset>/feature:GAPDH` — because `clear()`\n   * empties the maps on every switch, so two datasets never hold entries at once. What\n   * that does not cover is a request still in the air when the switch happens: `clear()`\n   * cannot cancel an HTTP call, so a vector fetched for dataset A can resolve after B has\n   * been selected and write itself into B's cache under a key B would read. Both datasets\n   * having a gene of that name is the common case, not the unlucky one, and the result is\n   * a plot of A's expression over B's cells — which looks like data, not like a fault.\n   *\n   * So the generation is checked after the await, and the in-flight slot is cleared only\n   * when the promise still sitting in it is this one: a late arrival must not evict the\n   * entry a newer request for the same key is already sharing.\n   */\n  private fetchCached(key: string, load: () => Promise<CachedPayload>): Promise<CachedPayload> {\n    const hit = this.cache.get(key);\n    if (hit) {\n      // Re-insert to mark most-recently-used (Map preserves insertion order).\n      this.cache.delete(key);\n      this.cache.set(key, hit);\n      return Promise.resolve(hit);\n    }\n    const pending = this.inFlight.get(key);\n    if (pending) return pending;\n\n    const mine = this.selectToken;\n    const promise: Promise<CachedPayload> = load()\n      .then((value) => {\n        // Still returned to the caller that asked: it may well be a component that is\n        // itself being torn down, and rejecting here would surface a switch as an error.\n        // What must not happen is the value being kept for whoever comes next.\n        if (mine === this.selectToken) {\n          this.cache.set(key, value);\n          this.evict();\n        }\n        return value;\n      })\n      .finally(() => {\n        if (this.inFlight.get(key) === promise) this.inFlight.delete(key);\n      });\n    this.inFlight.set(key, promise);\n    return promise;\n  }\n\n  private evict(): void {\n    while (this.cache.size > SpatialDataHttpService.CACHE_LIMIT) {\n      const oldest = this.cache.keys().next().value as string | undefined;\n      if (oldest === undefined) break;\n      this.cache.delete(oldest);\n    }\n  }\n\n  private getJson<T>(path: string): Promise<T> {\n    return firstValueFrom(\n      this.http.get<T>(`${this.baseUrl}${path}`).pipe(timeout(this.timeoutMs)),\n    );\n  }\n\n  private getBinary(path: string): Promise<ArrayBuffer> {\n    return firstValueFrom(\n      this.http.get(`${this.baseUrl}${path}`, { responseType: 'arraybuffer' })\n        .pipe(timeout(this.timeoutMs)),\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-data-http.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/spatial-data-http/spatial-data-http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { LruCache } from 'napari-js';\nimport { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, firstValueFrom } from 'rxjs';\nimport { timeout } from 'rxjs/operators';\n\nimport { ALL_GENES, SpatialDataPort, TranscriptTileQuery } from '../../contracts/ports/spatial-data.port';\nimport {\n  SpatialColumn,\n  SpatialDataset,\n  SpatialDensityRaster,\n  SpatialEmbedding,\n  SpatialPolygonTile,\n  SpatialPolygons,\n  CategoricalColumnMeta,\n  SpatialMarkerGenes,\n  SpatialTranscriptCounts,\n  SpatialTranscriptSummary,\n  SpatialTranscriptTile,\n  findColumnMeta,\n} from '../../contracts/spatial-dataset.contract';\nimport {\n  SpatialDatasetSummary,\n  SpatialManifest,\n  assertManifestVersion,\n  datasetFromManifest,\n  decodeColumn,\n  decodeCoords,\n  decodeDensity,\n  decodeEmbedding,\n  decodeFeatureVector,\n  decodePolygonTile,\n  decodePolygons,\n  decodeRadius,\n  decodeTranscriptTile,\n} from './spatial-wire';\nimport { searchGeneNames } from '../../spatial/gene-search';\nimport { Supersede } from '../../util/supersede';\n\n/**\n * A dataset selection that a newer selection (or a `clear`) overtook.\n *\n * Thrown rather than resolved so a caller cannot mistake it for \"this dataset is\n * now loaded\": nothing was published, on purpose.\n */\nexport class SupersededError extends Error {\n  constructor(id: string) {\n    super(`[spatial] selection of \"${id}\" was superseded by a newer one`);\n    this.name = 'SupersededError';\n  }\n}\n\n/**\n * What the LRU can hold. One alias rather than a union repeated at each use, so adding a payload\n * kind is a single edit instead of four that can drift apart.\n */\ntype CachedPayload = SpatialColumn | Float32Array | SpatialEmbedding | SpatialDensityRaster;\n\n/**\n * Bytes a decoded payload holds: its own typed-array views, one level deep — every\n * payload here is a typed array or a flat record of them.\n */\nfunction payloadBytes(value: unknown): number {\n  if (ArrayBuffer.isView(value)) return value.byteLength;\n  let bytes = 0;\n  if (value && typeof value === 'object') {\n    for (const v of Object.values(value)) if (ArrayBuffer.isView(v)) bytes += v.byteLength;\n  }\n  return bytes;\n}\n\nconst MiB = 1024 * 1024;\n\n/**\n * Reference {@link SpatialDataPort} adapter for the wire format the bundled\n * example server speaks (see `spatial-wire.ts` and\n * `examples/tile-server/lib/spatial.mjs`).\n *\n * OPTIONAL AND UNBOUND BY DEFAULT — this service is `@Injectable()` without\n * `providedIn`, so nothing gets it unless a host explicitly provides it:\n *\n * ```ts\n * providers: [\n *   SpatialDataHttpService,\n *   { provide: SPATIAL_DATA_PORT, useExisting: SpatialDataHttpService },\n * ]\n * ```\n *\n * That mirrors `CellposeSegmenterService`: a concrete implementation the\n * library ships for convenience, not a default the port inversion is quietly\n * giving up on. A host with its own backend implements `SpatialDataPort`\n * directly and never touches this class.\n *\n * Requests go through Angular's `HttpClient` (not `fetch`) so the host's\n * interceptors — auth headers above all — apply, matching `tile-client.ts`.\n */\n@Injectable()\nexport class SpatialDataHttpService implements SpatialDataPort {\n  /** Server root, normalised to end with exactly one `/`. */\n  private baseUrl = '';\n  /** Per-request ceiling. Vectors are small; a hung request should not wedge\n   *  the picker. */\n  private timeoutMs = 30_000;\n\n  private readonly dataset$ = new BehaviorSubject<SpatialDataset | null>(null);\n  private manifest: SpatialManifest | null = null;\n  /** Advanced by every `selectDataset` and every `clear`, so a selection that\n   *  finishes after a newer intent can tell and drop what it fetched. Cache fills\n   *  take a {@link Supersede.current snapshot} of it, so a vector or tile that lands\n   *  after a switch is returned to its caller but never kept for the next dataset. */\n  private readonly selection = new Supersede();\n\n  /**\n   * Loaded vectors, keyed `column:<name>` / `feature:<name>`. Bounded LRU:\n   * colouring by cluster → by a gene → back by cluster must not refetch, but an\n   * afternoon of browsing genes must not grow without limit either.\n   *\n   * Bounded by BYTES as well as entries: one vector is `4·N` bytes — 2 MB at 500k\n   * cells, but 14.8 MB at 3.7M, where 32 entries (an embedding is two or three\n   * vectors) could pin close to half a gigabyte.\n   */\n  private readonly cache = new Map<string, { value: CachedPayload; bytes: number }>();\n  private cachedBytes = 0;\n  private static readonly CACHE_LIMIT = 32;\n  private cacheBytes = 256 * MiB;\n\n  /** In-flight requests, so double-clicking a gene issues one fetch. */\n  private readonly inFlight = new Map<string, Promise<CachedPayload>>();\n\n  /**\n   * Tiles get their own, larger cache: panning revisits them constantly, and one screen\n   * of a zoomed-out section is dozens of them — far past the vector cache's limit.\n   */\n  private readonly tileCache = new Map<string, Promise<SpatialPolygonTile | SpatialTranscriptTile>>();\n  private static readonly TILE_CACHE_LIMIT = 384;\n  /** Bytes of each RESOLVED tile in {@link tileCache}; a pending one counts once it lands. */\n  private readonly tileBytes = new Map<string, number>();\n  private tileBytesTotal = 0;\n  private tileCacheBytes = 128 * MiB;\n\n  private volumePromise: Promise<Uint8Array> | null = null;\n  private polygonsPromise: Promise<SpatialPolygons> | null = null;\n\n  constructor(private http: HttpClient) {}\n\n  // ── configuration ───────────────────────────────────────────────────────\n\n  /**\n   * Point the adapter at a server. Clears any loaded dataset.\n   *\n   * `cacheBytes` / `tileCacheBytes` cap the decoded vectors (default 256 MiB) and tiles\n   * (default 128 MiB) kept for reuse; the most recent entry is always kept.\n   */\n  configure(options: { baseUrl: string; timeoutMs?: number; cacheBytes?: number; tileCacheBytes?: number }): void {\n    const raw = options.baseUrl ?? '';\n    this.baseUrl = raw.endsWith('/') ? raw : `${raw}/`;\n    if (options.timeoutMs !== undefined) this.timeoutMs = options.timeoutMs;\n    if (options.cacheBytes !== undefined) this.cacheBytes = options.cacheBytes;\n    if (options.tileCacheBytes !== undefined) this.tileCacheBytes = options.tileCacheBytes;\n    this.clear();\n  }\n\n  /** Datasets this server offers, for a host-side picker. */\n  listDatasets(): Promise<SpatialDatasetSummary[]> {\n    return this.getJson<{ datasets: SpatialDatasetSummary[] }>('spatial/datasets').then((r) => r.datasets ?? []);\n  }\n\n  /**\n   * One dataset's manifest, WITHOUT selecting it. Lets a host inspect what a\n   * server offers — column and feature metadata, and which image a dataset\n   * registers onto — while building a picker, rather than having to load each\n   * dataset to find out.\n   */\n  readManifest(id: string): Promise<SpatialManifest> {\n    return this.getJson<SpatialManifest>(`spatial/${encodeURIComponent(id)}/manifest`).then((manifest) => {\n      assertManifestVersion(manifest);\n      return manifest;\n    });\n  }\n\n  /**\n   * Load a dataset and publish it on {@link getDataset$}. Fetches the manifest,\n   * then, in parallel, the vectors that are always needed (coordinates, and\n   * ids/radius when the manifest says they exist) — nothing else.\n   */\n  async selectDataset(id: string): Promise<SpatialDataset> {\n    this.clear();\n    // Selections are SEQUENCED: this is two awaits deep, so a slower earlier\n    // call would otherwise assign `this.manifest` or publish its dataset after a\n    // later one — leaving the manifest and the observations from two different\n    // datasets, which is worse than either being late.\n    const task = this.selection.next();\n    const superseded = () => !task.isCurrent();\n    const path = `spatial/${encodeURIComponent(id)}`;\n\n    const manifest = await this.getJson<SpatialManifest>(`${path}/manifest`);\n    assertManifestVersion(manifest);\n    if (superseded()) throw new SupersededError(id);\n    this.manifest = manifest;\n\n    // Independent of each other, so requested together: time to first paint is the\n    // slowest of them, not their sum (the ids JSON alone is tens of MB on a large dataset).\n    const [coordsBuf, ids, radiusBuf] = await Promise.all([\n      this.getBinary(`${path}/coords`),\n      manifest.hasIds ? this.getJson<{ ids: string[] }>(`${path}/ids`).then((r) => r.ids) : undefined,\n      manifest.radius?.mode === 'per-observation' ? this.getBinary(`${path}/radius`) : undefined,\n    ]);\n    if (superseded()) throw new SupersededError(id);\n    const coords = decodeCoords(coordsBuf, manifest.count, !!manifest.hasZ);\n    const radius = radiusBuf ? decodeRadius(radiusBuf, manifest.count) : undefined;\n\n    const dataset = datasetFromManifest(manifest, coords, { ids, radius });\n    this.dataset$.next(dataset);\n    return dataset;\n  }\n\n  /** Drop the loaded dataset and every cached vector. */\n  clear(): void {\n    // A clear is itself the newest intent, so it supersedes any selection still\n    // in flight rather than letting one land afterwards.\n    this.selection.cancel();\n    this.manifest = null;\n    this.cache.clear();\n    this.cachedBytes = 0;\n    this.inFlight.clear();\n    this.tileCache.clear();\n    this.tileBytes.clear();\n    this.tileBytesTotal = 0;\n    this.summaryCache.clear();\n    this.polygonsPromise = null;\n    this.volumePromise = null;\n    if (this.dataset$.value !== null) this.dataset$.next(null);\n  }\n\n  // ── SpatialDataPort ─────────────────────────────────────────────────────\n\n  getDataset$(): Observable<SpatialDataset | null> {\n    return this.dataset$.asObservable();\n  }\n\n  getColumn(name: string): Promise<SpatialColumn> {\n    const manifest = this.requireManifest();\n    const dataset = this.dataset$.value!;\n    const meta = findColumnMeta(dataset, name);\n    if (!meta) {\n      // Reject rather than resolve empty: a typo must surface as an error, not\n      // as a plot that silently renders every point as \"no data\".\n      return Promise.reject(\n        new Error(\n          `[spatial] unknown column \"${name}\". Available: ${dataset.columns.map((c) => c.name).join(', ')}`,\n        ),\n      );\n    }\n    return this.fetchCached(`column:${name}`, () =>\n      this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/column/${encodeURIComponent(name)}`).then((buf) =>\n        decodeColumn(buf, meta, manifest.count),\n      ),\n    ) as Promise<SpatialColumn>;\n  }\n\n  getEmbedding(name: string): Promise<SpatialEmbedding> {\n    const manifest = this.requireManifest();\n    const meta = manifest.embeddings?.find((e) => e.name === name);\n    if (!meta) {\n      return Promise.reject(new Error(`[spatial] unknown embedding \"${name}\"`));\n    }\n    return this.fetchCached(`embedding:${name}`, () =>\n      this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/embedding/${encodeURIComponent(name)}`).then(\n        (buf) => decodeEmbedding(buf, meta, manifest.count),\n      ),\n    ) as Promise<SpatialEmbedding>;\n  }\n\n  getFeatureVector(name: string): Promise<Float32Array> {\n    const manifest = this.requireManifest();\n    const names = manifest.features?.names;\n    if (names && !names.includes(name)) {\n      return Promise.reject(new Error(`[spatial] unknown feature \"${name}\"`));\n    }\n    return this.fetchCached(`feature:${name}`, () =>\n      this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/feature/${encodeURIComponent(name)}`).then(\n        (buf) => decodeFeatureVector(buf, manifest.count),\n      ),\n    ) as Promise<Float32Array>;\n  }\n\n  async searchFeatures(query: string, limit = 50): Promise<string[]> {\n    const manifest = this.requireManifest();\n    // A dataset that inlined its names (targeted panel) is filtered locally —\n    // no round-trip for a keystroke — and ranked as the picker ranks them.\n    const names = manifest.features?.names;\n    if (names) return searchGeneNames(names, query, limit);\n    const url =\n      `spatial/${encodeURIComponent(manifest.id)}/features` + `?q=${encodeURIComponent(query)}&limit=${limit}`;\n    return (await this.getJson<{ names: string[] }>(url)).names ?? [];\n  }\n\n  getPolygons(): Promise<SpatialPolygons> {\n    const manifest = this.requireManifest();\n    if (!manifest.polygons) {\n      return Promise.reject(new Error('[spatial] this dataset has no polygon geometry'));\n    }\n    // Geometry is one large blob rather than a per-name vector, so it gets its\n    // own single-flight slot instead of a cache entry.\n    this.polygonsPromise ??= this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/polygons`)\n      .then(decodePolygons)\n      .catch((err) => {\n        this.polygonsPromise = null;\n        throw err;\n      });\n    return this.polygonsPromise;\n  }\n\n  getPolygonTile(set: string, level: number, gx: number, gy: number): Promise<SpatialPolygonTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.polygonTiles) {\n      return Promise.reject(new Error('[spatial] this dataset has no tiled polygons'));\n    }\n    const path =\n      `spatial/${encodeURIComponent(manifest.id)}/polygon-tile/` +\n      `${encodeURIComponent(set)}/${level}/${gx}/${gy}`;\n    return this.cachedTile(path, () =>\n      this.getBinary(path).then((buf) => decodePolygonTile(buf, manifest.count)),\n    ) as Promise<SpatialPolygonTile>;\n  }\n\n  getTranscriptTile(\n    level: number,\n    gx: number,\n    gy: number,\n    query: TranscriptTileQuery,\n  ): Promise<SpatialTranscriptTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.transcriptTiles) {\n      return Promise.reject(new Error('[spatial] this dataset has no tiled transcripts'));\n    }\n    const genes = query.genes.map(encodeURIComponent).join(',');\n    const box = query.box ? `&box=${query.box.join(',')}` : '';\n    const path =\n      `spatial/${encodeURIComponent(manifest.id)}/transcript-tile/${level}/${gx}/${gy}` +\n      `?genes=${genes}&quality=${query.quality ?? 'high'}${box}`;\n    // The codes index the genes asked for — except for ALL_GENES, whose list the\n    // server owns, so only the observations can be bounded there.\n    const limits = {\n      observations: manifest.count,\n      ...(query.genes.includes(ALL_GENES) ? {} : { genes: query.genes.length }),\n    };\n    return this.cachedTile(path, () =>\n      this.getBinary(path).then((buf) => decodeTranscriptTile(buf, limits)),\n    ) as Promise<SpatialTranscriptTile>;\n  }\n\n  getTranscriptGeneBins(level: number, tx: number, ty: number, genes: string[]): Promise<SpatialTranscriptTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.transcriptGeneBins) {\n      return Promise.reject(new Error('[spatial] this dataset has no per-gene bins'));\n    }\n    const path =\n      `spatial/${encodeURIComponent(manifest.id)}/gene-bins/${level}/${tx}/${ty}` +\n      `?genes=${genes.map(encodeURIComponent).join(',')}`;\n    const limits = {\n      observations: manifest.count,\n      ...(genes.includes(ALL_GENES) ? {} : { genes: genes.length }),\n    };\n    return this.cachedTile(path, () =>\n      this.getBinary(path).then((buf) => decodeTranscriptTile(buf, limits)),\n    ) as Promise<SpatialTranscriptTile>;\n  }\n\n  getTranscriptBins(level: number, tx: number, ty: number): Promise<SpatialTranscriptTile> {\n    const manifest = this.requireManifest();\n    if (!manifest.transcriptBins) {\n      return Promise.reject(new Error('[spatial] this dataset has no transcript pyramid'));\n    }\n    const path = `spatial/${encodeURIComponent(manifest.id)}/transcript-bins/${level}/${tx}/${ty}`;\n    return this.cachedTile(path, () =>\n      this.getBinary(path).then((buf) => decodeTranscriptTile(buf, { observations: manifest.count })),\n    ) as Promise<SpatialTranscriptTile>;\n  }\n\n  /** Small JSON answers, keyed by URL — hovering back and forth must not refetch. Least recently\n   *  USED goes first, so the summary under the pointer stays while others are evicted. */\n  private readonly summaryCache = new LruCache<Promise<SpatialTranscriptSummary>>(256);\n\n  getTranscriptSummary(query: {\n    box?: [number, number, number, number];\n    genes?: string[];\n    cells?: number[];\n  }): Promise<SpatialTranscriptSummary> {\n    const manifest = this.requireManifest();\n    const params: string[] = [];\n    if (query.box) params.push(`box=${query.box.map((v) => +v.toFixed(3)).join(',')}`);\n    if (query.genes?.length) params.push(`genes=${query.genes.map(encodeURIComponent).join(',')}`);\n    if (query.cells?.length) params.push(`cells=${query.cells.join(',')}`);\n    const url = `spatial/${encodeURIComponent(manifest.id)}/transcript-summary?${params.join('&')}`;\n    let hit = this.summaryCache.get(url);\n    if (!hit) {\n      hit = this.getJson<SpatialTranscriptSummary>(url);\n      hit.catch(() => this.summaryCache.delete(url));\n      this.summaryCache.set(url, hit);\n    }\n    return hit;\n  }\n\n  getDensity(genes: string[], binSize?: number): Promise<SpatialDensityRaster> {\n    const manifest = this.requireManifest();\n    if (!manifest.density) return Promise.reject(new Error('[spatial] this dataset has no density raster'));\n    const list = [...genes];\n    const bin = binSize ? `&bin=${binSize}` : '';\n    return this.fetchCached(`density:${list.join(',')}:${binSize ?? ''}`, () =>\n      this.getBinary(\n        `spatial/${encodeURIComponent(manifest.id)}/density?genes=${list.map(encodeURIComponent).join(',')}${bin}`,\n      ).then((buf) => decodeDensity(buf, list)),\n    ) as Promise<SpatialDensityRaster>;\n  }\n\n  async importGroups(label: string, table: string): Promise<{ column: CategoricalColumnMeta; matched: number }> {\n    const manifest = this.requireManifest();\n    const url = `${this.baseUrl}spatial/${encodeURIComponent(manifest.id)}/groups?name=${encodeURIComponent(label)}`;\n    // HttpClient, not fetch: a host's interceptors (its auth header) must apply to the\n    // upload as they do to every read, or a protected server refuses it.\n    let body: { column: CategoricalColumnMeta; matched: number };\n    try {\n      body = await firstValueFrom(\n        this.http\n          .post<{ column: CategoricalColumnMeta; matched: number }>(url, table, {\n            headers: { 'Content-Type': 'text/csv' },\n          })\n          .pipe(timeout(this.timeoutMs)),\n      );\n    } catch (err) {\n      const e = err as HttpErrorResponse;\n      throw new Error(e?.error?.error ?? `[spatial] import failed (HTTP ${e?.status ?? '?'})`);\n    }\n    const column = body.column;\n    // The new column joins the dataset: re-emit so every panel sees it.\n    const current = this.dataset$.value;\n    if (current && this.manifest?.id === manifest.id) {\n      const columns = current.columns.filter((c) => c.name !== column.name).concat(column);\n      this.manifest = { ...this.manifest, columns };\n      this.uncache(`column:${column.name}`);\n      this.dataset$.next({ ...current, columns });\n    }\n    return { column, matched: body.matched };\n  }\n\n  getMarkerGenes(column: string, perGroup = 5): Promise<SpatialMarkerGenes> {\n    const manifest = this.requireManifest();\n    // No per-request timeout: the first computation is a pass over the whole matrix.\n    return firstValueFrom(\n      this.http.get<SpatialMarkerGenes>(\n        `${this.baseUrl}spatial/${encodeURIComponent(manifest.id)}/markers/${encodeURIComponent(column)}?n=${perGroup}`,\n      ),\n    );\n  }\n\n  getTranscriptCounts(genes: string[]): Promise<SpatialTranscriptCounts> {\n    const manifest = this.requireManifest();\n    return this.getJson<SpatialTranscriptCounts>(\n      `spatial/${encodeURIComponent(manifest.id)}/transcript-counts?genes=${genes.map(encodeURIComponent).join(',')}`,\n    );\n  }\n\n  /** LRU over tile promises, so concurrent asks share one request and a failure is not kept. */\n  private cachedTile<T extends SpatialPolygonTile | SpatialTranscriptTile>(\n    key: string,\n    load: () => Promise<T>,\n  ): Promise<T> {\n    const hit = this.tileCache.get(key);\n    if (hit) {\n      this.tileCache.delete(key);\n      this.tileCache.set(key, hit);\n      return hit as Promise<T>;\n    }\n    const generation = this.selection.current();\n    const promise: Promise<T> = load().then(\n      (tile) => {\n        // Sized once it lands, and only while it is still the entry under its key.\n        if (this.tileCache.get(key) === promise && !this.tileBytes.has(key)) {\n          const bytes = payloadBytes(tile);\n          this.tileBytes.set(key, bytes);\n          this.tileBytesTotal += bytes;\n          this.evictTiles();\n        }\n        return tile;\n      },\n      (err) => {\n        if (this.tileCache.get(key) === promise) this.dropTile(key);\n        throw err;\n      },\n    );\n    if (generation.isCurrent()) {\n      this.tileCache.set(key, promise);\n      this.evictTiles();\n    }\n    return promise;\n  }\n\n  /** Oldest first, past the entry cap or the byte budget, keeping the newest. */\n  private evictTiles(): void {\n    while (\n      this.tileCache.size > 1 &&\n      (this.tileCache.size > SpatialDataHttpService.TILE_CACHE_LIMIT || this.tileBytesTotal > this.tileCacheBytes)\n    ) {\n      this.dropTile(this.tileCache.keys().next().value!);\n    }\n  }\n\n  private dropTile(key: string): void {\n    this.tileCache.delete(key);\n    this.tileBytesTotal -= this.tileBytes.get(key) ?? 0;\n    this.tileBytes.delete(key);\n  }\n\n  /**\n   * The reference volume's voxels, single-flighted like the polygons.\n   *\n   * Validated against the manifest's declared dimensions before it is handed\n   * back: a short or long buffer read as a 3D texture does not fail, it shears\n   * the anatomy into diagonal streaks, and that is far harder to recognise as a\n   * transport problem than an error is.\n   */\n  getVolume(): Promise<Uint8Array> {\n    const manifest = this.requireManifest();\n    const meta = manifest.volume;\n    if (!meta) {\n      return Promise.reject(new Error('[spatial] this dataset has no reference volume'));\n    }\n    this.volumePromise ??= this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/volume`)\n      .then((buf) => {\n        const want = meta.width * meta.height * meta.depth;\n        if (buf.byteLength !== want) {\n          throw new Error(\n            `[spatial] volume is ${buf.byteLength} bytes, expected ${want} ` +\n              `(${meta.width}x${meta.height}x${meta.depth})`,\n          );\n        }\n        return new Uint8Array(buf);\n      })\n      .catch((err) => {\n        this.volumePromise = null;\n        throw err;\n      });\n    return this.volumePromise;\n  }\n\n  // ── internals ───────────────────────────────────────────────────────────\n\n  private requireManifest(): SpatialManifest {\n    if (!this.manifest || !this.dataset$.value) {\n      throw new Error('[spatial] no dataset selected — call selectDataset() first');\n    }\n    return this.manifest;\n  }\n\n  /**\n   * Cache + single-flight around a vector fetch.\n   *\n   * Keys are LOGICAL — `feature:GAPDH`, not `<dataset>/feature:GAPDH` — because `clear()`\n   * empties the maps on every switch, so two datasets never hold entries at once. What\n   * that does not cover is a request still in the air when the switch happens: `clear()`\n   * cannot cancel an HTTP call, so a vector fetched for dataset A can resolve after B has\n   * been selected and write itself into B's cache under a key B would read. Both datasets\n   * having a gene of that name is the common case, not the unlucky one, and the result is\n   * a plot of A's expression over B's cells — which looks like data, not like a fault.\n   *\n   * So the generation is checked after the await, and the in-flight slot is cleared only\n   * when the promise still sitting in it is this one: a late arrival must not evict the\n   * entry a newer request for the same key is already sharing.\n   */\n  private fetchCached(key: string, load: () => Promise<CachedPayload>): Promise<CachedPayload> {\n    const hit = this.cache.get(key);\n    if (hit) {\n      // Re-insert to mark most-recently-used (Map preserves insertion order).\n      this.cache.delete(key);\n      this.cache.set(key, hit);\n      return Promise.resolve(hit.value);\n    }\n    const pending = this.inFlight.get(key);\n    if (pending) return pending;\n\n    const generation = this.selection.current();\n    const promise: Promise<CachedPayload> = load()\n      .then((value) => {\n        // Still returned to the caller that asked: it may well be a component that is\n        // itself being torn down, and rejecting here would surface a switch as an error.\n        // What must not happen is the value being kept for whoever comes next.\n        if (generation.isCurrent()) {\n          this.uncache(key);\n          const bytes = payloadBytes(value);\n          this.cache.set(key, { value, bytes });\n          this.cachedBytes += bytes;\n          this.evict();\n        }\n        return value;\n      })\n      .finally(() => {\n        if (this.inFlight.get(key) === promise) this.inFlight.delete(key);\n      });\n    this.inFlight.set(key, promise);\n    return promise;\n  }\n\n  /** Oldest first, past the entry cap or the byte budget, keeping the newest. */\n  private evict(): void {\n    while (\n      this.cache.size > 1 &&\n      (this.cache.size > SpatialDataHttpService.CACHE_LIMIT || this.cachedBytes > this.cacheBytes)\n    ) {\n      this.uncache(this.cache.keys().next().value!);\n    }\n  }\n\n  private uncache(key: string): void {\n    const entry = this.cache.get(key);\n    if (!entry) return;\n    this.cache.delete(key);\n    this.cachedBytes -= entry.bytes;\n  }\n\n  private getJson<T>(path: string): Promise<T> {\n    return firstValueFrom(this.http.get<T>(`${this.baseUrl}${path}`).pipe(timeout(this.timeoutMs)));\n  }\n\n  private getBinary(path: string): Promise<ArrayBuffer> {\n    return firstValueFrom(\n      this.http.get(`${this.baseUrl}${path}`, { responseType: 'arraybuffer' }).pipe(timeout(this.timeoutMs)),\n    );\n  }\n}\n"]}