@jax-data-science/sci-image-visualizer 0.6.0 → 0.7.0

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

@@ -3,7 +3,7 @@ import { Injectable } from '@angular/core';
 import { BehaviorSubject, firstValueFrom } from 'rxjs';
 import { timeout } from 'rxjs/operators';
 import { findColumnMeta, } from '../../contracts/spatial-dataset.contract';
-import { assertManifestVersion, datasetFromManifest, decodeColumn, decodeCoords, decodeEmbedding, decodeFeatureVector, decodePolygons, decodeRadius, } from './spatial-wire';
+import { assertManifestVersion, datasetFromManifest, decodeColumn, decodeCoords, decodeDensity, decodeEmbedding, decodeFeatureVector, decodePolygonTile, decodePolygons, decodeRadius, decodeTranscriptTile, } from './spatial-wire';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
 /**
@@ -43,6 +43,7 @@ export class SupersededError extends Error {
 }
 export class SpatialDataHttpService {
     static { this.CACHE_LIMIT = 32; }
+    static { this.TILE_CACHE_LIMIT = 384; }
     constructor(http) {
         this.http = http;
         /** Server root, normalised to end with exactly one `/`. */
@@ -64,8 +65,15 @@ export class SpatialDataHttpService {
         this.cache = new Map();
         /** In-flight requests, so double-clicking a gene issues one fetch. */
         this.inFlight = new Map();
+        /**
+         * Tiles get their own, larger cache: panning revisits them constantly, and one screen
+         * of a zoomed-out section is dozens of them — far past the vector cache's limit.
+         */
+        this.tileCache = new Map();
         this.volumePromise = null;
         this.polygonsPromise = null;
+        /** Small JSON answers, keyed by URL — hovering back and forth must not refetch. */
+        this.summaryCache = new Map();
     }
     // ── configuration ───────────────────────────────────────────────────────
     /** Point the adapter at a server. Clears any loaded dataset. */
@@ -137,6 +145,8 @@ export class SpatialDataHttpService {
         this.manifest = null;
         this.cache.clear();
         this.inFlight.clear();
+        this.tileCache.clear();
+        this.summaryCache.clear();
         this.polygonsPromise = null;
         this.volumePromise = null;
         if (this.dataset$.value !== null)
@@ -201,6 +211,114 @@ export class SpatialDataHttpService {
             .catch((err) => { this.polygonsPromise = null; throw err; });
         return this.polygonsPromise;
     }
+    getPolygonTile(set, level, gx, gy) {
+        const manifest = this.requireManifest();
+        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));
+    }
+    getTranscriptTile(level, gx, gy, query) {
+        const manifest = this.requireManifest();
+        if (!manifest.transcriptTiles) {
+            return Promise.reject(new Error('[spatial] this dataset has no tiled transcripts'));
+        }
+        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));
+    }
+    getTranscriptBins(level, tx, ty) {
+        const manifest = this.requireManifest();
+        if (!manifest.transcriptBins) {
+            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));
+    }
+    getTranscriptSummary(query) {
+        const manifest = this.requireManifest();
+        const params = [];
+        if (query.box)
+            params.push(`box=${query.box.map((v) => +v.toFixed(3)).join(',')}`);
+        if (query.genes?.length)
+            params.push(`genes=${query.genes.map(encodeURIComponent).join(',')}`);
+        if (query.cells?.length)
+            params.push(`cells=${query.cells.join(',')}`);
+        const url = `spatial/${encodeURIComponent(manifest.id)}/transcript-summary?${params.join('&')}`;
+        let hit = this.summaryCache.get(url);
+        if (!hit) {
+            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;
+    }
+    getDensity(genes, binSize) {
+        const manifest = this.requireManifest();
+        if (!manifest.density)
+            return Promise.reject(new Error('[spatial] this dataset has no density raster'));
+        const list = [...genes];
+        const bin = binSize ? `&bin=${binSize}` : '';
+        return this.fetchCached(`density:${list.join(',')}:${binSize ?? ''}`, () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/density?genes=${list.map(encodeURIComponent).join(',')}${bin}`).then((buf) => decodeDensity(buf, list)));
+    }
+    async importGroups(label, table) {
+        const manifest = this.requireManifest();
+        const url = `${this.baseUrl}spatial/${encodeURIComponent(manifest.id)}/groups?name=${encodeURIComponent(label)}`;
+        // HttpClient, not fetch: a host's interceptors (its auth header) must apply to the
+        // upload as they do to every read, or a protected server refuses it.
+        let body;
+        try {
+            body = await firstValueFrom(this.http.post(url, table, {
+                headers: { 'Content-Type': 'text/csv' },
+            }).pipe(timeout(this.timeoutMs)));
+        }
+        catch (err) {
+            const e = err;
+            throw new Error(e?.error?.error ?? `[spatial] import failed (HTTP ${e?.status ?? '?'})`);
+        }
+        const column = body.column;
+        // The new column joins the dataset: re-emit so every panel sees it.
+        const current = this.dataset$.value;
+        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.dataset$.next({ ...current, columns });
+        }
+        return { column, matched: body.matched };
+    }
+    getTranscriptCounts(genes) {
+        const manifest = this.requireManifest();
+        return this.getJson(`spatial/${encodeURIComponent(manifest.id)}/transcript-counts?genes=${genes.map(encodeURIComponent).join(',')}`);
+    }
+    /** LRU over tile promises, so concurrent asks share one request and a failure is not kept. */
+    cachedTile(key, load) {
+        const hit = this.tileCache.get(key);
+        if (hit) {
+            this.tileCache.delete(key);
+            this.tileCache.set(key, hit);
+            return hit;
+        }
+        const mine = this.selectToken;
+        const promise = load().catch((err) => {
+            if (this.tileCache.get(key) === promise)
+                this.tileCache.delete(key);
+            throw err;
+        });
+        if (mine === this.selectToken) {
+            this.tileCache.set(key, promise);
+            while (this.tileCache.size > SpatialDataHttpService.TILE_CACHE_LIMIT) {
+                this.tileCache.delete(this.tileCache.keys().next().value);
+            }
+        }
+        return promise;
+    }
     /**
      * The reference volume's voxels, single-flighted like the polygons.
      *
@@ -301,4 +419,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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAc,cAAc,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAGzC,OAAO,EAKL,cAAc,GACf,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAGL,qBAAqB,EACrB,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,YAAY,GACb,MAAM,gBAAgB,CAAC;;;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;;;;;GAKG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IACxC,YAAY,EAAU;QACpB,KAAK,CAAC,2BAA2B,EAAE,iCAAiC,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AASD,MAAM,OAAO,sBAAsB;aAoBT,gBAAW,GAAG,EAAE,AAAL,CAAM;IAQzC,YAAoB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;QA3BpC,2DAA2D;QACnD,YAAO,GAAG,EAAE,CAAC;QACrB;0BACkB;QACV,cAAS,GAAG,MAAM,CAAC;QAEV,aAAQ,GAAG,IAAI,eAAe,CAAwB,IAAI,CAAC,CAAC;QACrE,aAAQ,GAA2B,IAAI,CAAC;QAChD;+EACuE;QAC/D,gBAAW,GAAG,CAAC,CAAC;QAExB;;;;;WAKG;QACc,UAAK,GAAG,IAAI,GAAG,EAAyB,CAAC;QAG1D,sEAAsE;QACrD,aAAQ,GAAG,IAAI,GAAG,EAAkC,CAAC;QAE9D,kBAAa,GAA+B,IAAI,CAAC;QACjD,oBAAe,GAAoC,IAAI,CAAC;IAEzB,CAAC;IAExC,2EAA2E;IAE3E,gEAAgE;IAChE,SAAS,CAAC,OAAgD;QACxD,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;QAClC,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;QACnD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACxE,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAED,2DAA2D;IAC3D,YAAY;QACV,OAAO,IAAI,CAAC,OAAO,CAAwC,kBAAkB,CAAC;aAC3E,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,EAAU;QACrB,OAAO,IAAI,CAAC,OAAO,CAAkB,WAAW,kBAAkB,CAAC,EAAE,CAAC,WAAW,CAAC;aAC/E,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YACjB,qBAAqB,CAAC,QAAQ,CAAC,CAAC;YAChC,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,aAAa,CAAC,EAAU;QAC5B,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,0EAA0E;QAC1E,6EAA6E;QAC7E,2EAA2E;QAC3E,mDAAmD;QACnD,MAAM,IAAI,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC;QAChC,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,CAAC;QACnD,MAAM,IAAI,GAAG,WAAW,kBAAkB,CAAC,EAAE,CAAC,EAAE,CAAC;QAEjD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAkB,GAAG,IAAI,WAAW,CAAC,CAAC;QACzE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAChC,IAAI,UAAU,EAAE;YAAE,MAAM,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAEzB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC;QACzD,IAAI,UAAU,EAAE;YAAE,MAAM,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAExE,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM;YACzB,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAoB,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG;YAC5D,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,IAAI,KAAK,iBAAiB;YACxD,CAAC,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;YACtE,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,UAAU,EAAE;YAAE,MAAM,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;QAEhD,MAAM,OAAO,GAAG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QACvE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,uDAAuD;IACvD,KAAK;QACH,4EAA4E;QAC5E,qDAAqD;QACrD,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,IAAI;YAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED,2EAA2E;IAE3E,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;IACtC,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAM,CAAC;QACrC,MAAM,IAAI,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,yEAAyE;YACzE,4DAA4D;YAC5D,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAC7B,6BAA6B,IAAI,iBAAiB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAClG,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CACrB,UAAU,IAAI,EAAE,EAChB,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC;aAClG,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAChC,CAAC;IAC9B,CAAC;IAED,YAAY,CAAC,IAAY;QACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,MAAM,IAAI,GAAG,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAC/D,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gCAAgC,IAAI,GAAG,CAAC,CAAC,CAAC;QAC5E,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CACrB,aAAa,IAAI,EAAE,EACnB,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAClB,WAAW,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,cAAc,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACnF,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAC/B,CAAC;IACjC,CAAC;IAED,gBAAgB,CAAC,IAAY;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;QACvC,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,8BAA8B,IAAI,GAAG,CAAC,CAAC,CAAC;QAC1E,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CACrB,WAAW,IAAI,EAAE,EACjB,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,YAAY,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC;aACnG,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,mBAAmB,CAAC,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAClC,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,KAAK,GAAG,EAAE;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,0EAA0E;QAC1E,iCAAiC;QACjC,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;QACvC,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,CAAC,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC1E,CAAC;QACD,MAAM,GAAG,GAAG,WAAW,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW;cAC7D,MAAM,kBAAkB,CAAC,KAAK,CAAC,UAAU,KAAK,EAAE,CAAC;QACrD,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,CAAsB,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;IACpE,CAAC;IAED,WAAW;QACT,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACvB,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC,CAAC;QACrF,CAAC;QACD,2EAA2E;QAC3E,mDAAmD;QACnD,IAAI,CAAC,eAAe,KAAK,IAAI;aAC1B,SAAS,CAAC,WAAW,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,CAAC;aAChE,IAAI,CAAC,cAAc,CAAC;aACpB,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;;;;;OAOG;IACH,SAAS;QACP,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC,CAAC;QACrF,CAAC;QACD,IAAI,CAAC,aAAa,KAAK,IAAI;aACxB,SAAS,CAAC,WAAW,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,CAAC;aAC9D,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;YACZ,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC;YACnD,IAAI,GAAG,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CACb,uBAAuB,GAAG,CAAC,UAAU,oBAAoB,IAAI,GAAG;sBAC9D,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,GAAG,CACjD,CAAC;YACJ,CAAC;YACD,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,2EAA2E;IAEnE,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YAC3C,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACK,WAAW,CAAC,GAAW,EAAE,IAAkC;QACjE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,GAAG,EAAE,CAAC;YACR,wEAAwE;YACxE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACzB,OAAO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,OAAO;YAAE,OAAO,OAAO,CAAC;QAE5B,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;QAC9B,MAAM,OAAO,GAA2B,IAAI,EAAE;aAC3C,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACd,8EAA8E;YAC9E,iFAAiF;YACjF,uEAAuE;YACvE,IAAI,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;gBAC9B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC3B,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;aACD,OAAO,CAAC,GAAG,EAAE;YACZ,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,OAAO;gBAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAChC,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,KAAK;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,sBAAsB,CAAC,WAAW,EAAE,CAAC;YAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAA2B,CAAC;YACpE,IAAI,MAAM,KAAK,SAAS;gBAAE,MAAM;YAChC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAEO,OAAO,CAAI,IAAY;QAC7B,OAAO,cAAc,CACnB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAI,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CACzE,CAAC;IACJ,CAAC;IAEO,SAAS,CAAC,IAAY;QAC5B,OAAO,cAAc,CACnB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE,EAAE,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC;aACrE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CACjC,CAAC;IACJ,CAAC;8GApSU,sBAAsB;kHAAtB,sBAAsB;;2FAAtB,sBAAsB;kBADlC,UAAU","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, firstValueFrom } from 'rxjs';\nimport { timeout } from 'rxjs/operators';\n\nimport { SpatialDataPort } from '../../contracts/ports/spatial-data.port';\nimport {\n  SpatialColumn,\n  SpatialDataset,\n  SpatialEmbedding,\n  SpatialPolygons,\n  findColumnMeta,\n} from '../../contracts/spatial-dataset.contract';\nimport {\n  SpatialDatasetSummary,\n  SpatialManifest,\n  assertManifestVersion,\n  datasetFromManifest,\n  decodeColumn,\n  decodeCoords,\n  decodeEmbedding,\n  decodeFeatureVector,\n  decodePolygons,\n  decodeRadius,\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;\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  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.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  /**\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 { 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  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  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  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"]}

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

@@ -33,7 +33,18 @@ import { NO_CATEGORY, } from '../../contracts/spatial-dataset.contract';
  * GET {base}/spatial/{id}/feature/{name}   -> f32[N]
  * GET {base}/spatial/{id}/features?q=&limit= -> { names: string[] }
  * GET {base}/spatial/{id}/polygons         -> u32 count, u32[count+1] offsets, f32[2*rings] coords
+ * GET {base}/spatial/{id}/polygon-tile/{set}/{level}/{gx}/{gy}
+ *                                          -> u32 count, u32[count] obs, u32[count+1] offsets, f32 coords
+ * GET {base}/spatial/{id}/transcript-tile/{level}/{gx}/{gy}?genes=A,B&quality=high|all
+ *                                          -> see decodeTranscriptTile
+ * GET {base}/spatial/{id}/density?genes=A,B -> f32[rows*cols]
+ * GET {base}/spatial/{id}/transcript-bins/{level}/{tx}/{ty}
+ *                                          -> transcript-tile layout, one entry per bin
  * ```
+ *
+ * The three tiled routes are optional and advertised in the manifest
+ * (`polygonTiles`, `transcriptTiles`, `density`); a server without them never
+ * sees them requested.
  */
 /** Bumped when the layout changes incompatibly; the client refuses anything else. */
 export const SPATIAL_WIRE_VERSION = 1;
@@ -143,6 +154,65 @@ export function decodePolygons(buf) {
     const coords = new Float32Array(buf, coordsByteOffset, vertexCount * 2);
     return { coords, offsets, count };
 }
+/**
+ * `GET /polygon-tile/...` → one tile of rings with their owning observations. Layout
+ * `[u32 count][u32 obs × count][u32 offsets × (count+1)][f32 coords × 2·offsets[count]]`.
+ */
+export function decodePolygonTile(buf) {
+    assertLittleEndian();
+    if (buf.byteLength < 8) {
+        throw new Error('[spatial] polygon tile: response too short for a header');
+    }
+    const count = new Uint32Array(buf, 0, 1)[0];
+    const observation = new Uint32Array(buf, 4, count);
+    const offsets = new Uint32Array(buf, 4 + count * 4, count + 1);
+    const vertexCount = offsets[count];
+    const coordsByteOffset = 4 + count * 4 + (count + 1) * 4;
+    assertByteLength(buf, coordsByteOffset + vertexCount * 8, 'polygon tile');
+    return {
+        count, observation, offsets,
+        coords: new Float32Array(buf, coordsByteOffset, vertexCount * 2),
+    };
+}
+/**
+ * `GET /transcript-tile/...` → transcripts or aggregates. Layout, 4-byte aligned:
+ * `[u32 n][u32 flags][f32 x·n][f32 y·n][f32 z·n][u32 weight·n][u32 obs·n][u16 gene·n, padded]`;
+ * flags bit 0 marks an aggregated level.
+ */
+export function decodeTranscriptTile(buf) {
+    assertLittleEndian();
+    if (buf.byteLength < 8) {
+        throw new Error('[spatial] transcript tile: response too short for a header');
+    }
+    const [n, flags] = new Uint32Array(buf, 0, 2);
+    const genePad = Math.ceil((n * 2) / 4) * 4;
+    assertByteLength(buf, 8 + n * 20 + genePad, 'transcript tile');
+    return {
+        count: n,
+        aggregated: (flags & 1) === 1,
+        x: new Float32Array(buf, 8, n),
+        y: new Float32Array(buf, 8 + n * 4, n),
+        z: new Float32Array(buf, 8 + n * 8, n),
+        weight: new Uint32Array(buf, 8 + n * 12, n),
+        observation: new Uint32Array(buf, 8 + n * 16, n),
+        gene: new Uint16Array(buf, 8 + n * 20, n),
+    };
+}
+/**
+ * `GET /density?genes=&bin=` → the summed raster. Layout
+ * `[u32 rows][u32 cols][f32 cellW][f32 cellH][f32 originX][f32 originY][f32 rows·cols]`:
+ * the geometry travels with the values because re-binning changes it.
+ */
+export function decodeDensity(buf, genes) {
+    assertLittleEndian();
+    if (buf.byteLength < 24)
+        throw new Error('[spatial] density: response too short for a header');
+    const [rows, cols] = new Uint32Array(buf, 0, 2);
+    const [cw, ch, ox, oy] = new Float32Array(buf, 8, 4);
+    assertByteLength(buf, 24 + rows * cols * 4, 'density');
+    const meta = { rows, cols, gridSize: [cw, ch], origin: [ox, oy] };
+    return { meta, genes, values: new Float32Array(buf, 24, rows * cols) };
+}
 /**
  * Fold a manifest plus its fetched coordinate/id/radius vectors into the
  * library-facing {@link SpatialDataset}. Column and feature *values* are not
@@ -174,6 +244,11 @@ export function datasetFromManifest(manifest, coords, extras = {}) {
         ...(manifest.micronsPerUnit !== undefined
             ? { micronsPerUnit: manifest.micronsPerUnit }
             : {}),
+        ...(manifest.polygonTiles ? { polygonTiles: manifest.polygonTiles } : {}),
+        ...(manifest.transcriptTiles ? { transcriptTiles: manifest.transcriptTiles } : {}),
+        ...(manifest.density ? { density: manifest.density } : {}),
+        ...(manifest.transcriptBins ? { transcriptBins: manifest.transcriptBins } : {}),
+        ...(manifest.transcriptBinsStatus ? { transcriptBinsStatus: manifest.transcriptBinsStatus } : {}),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-wire.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/spatial-data-http/spatial-wire.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CategoricalColumnMeta,\n  ContinuousColumnMeta,\n  NO_CATEGORY,\n  SpatialColumn,\n  SpatialColumnMeta,\n  SpatialDataset,\n  SpatialEmbedding,\n  SpatialEmbeddingMeta,\n  SpatialFeatureMeta,\n  SpatialImageRef,\n  SpatialObservations,\n  SpatialPolygons,\n  SpatialVolumeMeta,\n} from '../../contracts/spatial-dataset.contract';\n\n/**\n * The wire format the bundled example server speaks, and its decoders.\n *\n * Pure by design — no Angular, no RxJS, no HTTP — so the format is testable on\n * its own and reusable by any transport (`SpatialDataHttpService` is one).\n * Mirrors the split in `plotly-trace-builders.ts`: the shape lives in a pure\n * module, the service just moves bytes.\n *\n * WHY BINARY\n * ----------\n * Vectors are one `Float32Array`/`Uint16Array` per request, delivered as raw\n * little-endian bytes. JSON would cost ~8–12× the size and a parse that\n * allocates one JS number per value; a typed-array view over the response\n * buffer is zero-copy and uploads to the GPU directly.\n *\n * ENDIANNESS\n * ----------\n * Little-endian, asserted at decode. Every platform a browser runs on today is\n * little-endian, so a `DataView` byte-by-byte read would cost real time for a\n * case that does not occur — but failing loudly beats rendering transposed\n * garbage if it ever does.\n *\n * ENDPOINTS (base = the server root)\n * ----------------------------------\n * ```\n * GET {base}/spatial/datasets              -> { datasets: [{ id, name, count }] }\n * GET {base}/spatial/{id}/manifest         -> SpatialManifest\n * GET {base}/spatial/{id}/coords           -> f32[N] x, f32[N] y, f32[N] z?\n * GET {base}/spatial/{id}/radius           -> f32[N]           (per-observation radius only)\n * GET {base}/spatial/{id}/ids              -> { ids: string[] } (hasIds only)\n * GET {base}/spatial/{id}/column/{name}    -> u16[N] codes | f32[N] values\n * GET {base}/spatial/{id}/feature/{name}   -> f32[N]\n * GET {base}/spatial/{id}/features?q=&limit= -> { names: string[] }\n * GET {base}/spatial/{id}/polygons         -> u32 count, u32[count+1] offsets, f32[2*rings] coords\n * ```\n */\n\n/** Bumped when the layout changes incompatibly; the client refuses anything else. */\nexport const SPATIAL_WIRE_VERSION = 1;\n\n/** Per-observation marker radius: one shared value, or a served f32 vector. */\nexport type SpatialRadiusSpec =\n  | { mode: 'uniform'; value: number }\n  | { mode: 'per-observation' };\n\n/** `GET /spatial/{id}/manifest` — everything cheap enough to send up front. */\nexport interface SpatialManifest {\n  version: number;\n  id: string;\n  name: string;\n  /** N — observation count; every served vector has exactly this length. */\n  count: number;\n  hasZ?: boolean;\n  hasIds?: boolean;\n  radius?: SpatialRadiusSpec;\n  columns: SpatialColumnMeta[];\n  features?: SpatialFeatureMeta;\n  polygons?: { count: number };\n  imageRef?: SpatialImageRef;\n  volume?: SpatialVolumeMeta;\n  embeddings?: SpatialEmbeddingMeta[];\n  micronsPerUnit?: number;\n}\n\n/** `GET /spatial/datasets` */\nexport interface SpatialDatasetSummary {\n  id: string;\n  name: string;\n  count: number;\n}\n\n/** True on a little-endian host. */\nexport function isLittleEndian(): boolean {\n  const probe = new Uint16Array([1]);\n  return new Uint8Array(probe.buffer)[0] === 1;\n}\n\nfunction assertLittleEndian(): void {\n  if (!isLittleEndian()) {\n    throw new Error(\n      '[spatial] wire format is little-endian; this platform is big-endian. ' +\n      'Serve JSON vectors, or byte-swap in a custom SpatialDataPort adapter.',\n    );\n  }\n}\n\n/** Guard a decode against a truncated or oversized response. */\nfunction assertByteLength(buf: ArrayBuffer, expected: number, what: string): void {\n  if (buf.byteLength !== expected) {\n    throw new Error(\n      `[spatial] ${what}: expected ${expected} bytes, got ${buf.byteLength}. ` +\n      'Manifest count and served vector length disagree.',\n    );\n  }\n}\n\n/** Reject a manifest this client cannot read, with a message naming the fix. */\nexport function assertManifestVersion(manifest: SpatialManifest): void {\n  if (manifest.version !== SPATIAL_WIRE_VERSION) {\n    throw new Error(\n      `[spatial] unsupported wire version ${manifest.version} ` +\n      `(this client speaks ${SPATIAL_WIRE_VERSION}). Update the server or the library.`,\n    );\n  }\n}\n\n/**\n * `GET /coords` → x/y(/z). One request rather than two or three: the vectors\n * are always fetched together, and a single response keeps them consistent if\n * the dataset changes underneath.\n */\nexport function decodeCoords(\n  buf: ArrayBuffer, count: number, hasZ = false,\n): Pick<SpatialObservations, 'x' | 'y' | 'z'> {\n  assertLittleEndian();\n  const axes = hasZ ? 3 : 2;\n  assertByteLength(buf, count * axes * 4, 'coords');\n  const x = new Float32Array(buf, 0, count);\n  const y = new Float32Array(buf, count * 4, count);\n  const z = hasZ ? new Float32Array(buf, count * 8, count) : undefined;\n  return { x, y, z };\n}\n\n/** `GET /radius` → per-observation radii in image pixels. */\nexport function decodeRadius(buf: ArrayBuffer, count: number): Float32Array {\n  assertLittleEndian();\n  assertByteLength(buf, count * 4, 'radius');\n  return new Float32Array(buf, 0, count);\n}\n\n/** `GET /feature/{name}` → one gene's expression vector. */\n/**\n * `GET /spatial/{id}/embedding/{name}` — one plane per dimension, same layout as coords.\n *\n * Struct of arrays, not interleaved: every dimension is contiguous, so an axis can be handed to\n * the renderer as a view with no copy and no stride.\n */\nexport function decodeEmbedding(\n  buf: ArrayBuffer, meta: SpatialEmbeddingMeta, count: number,\n): SpatialEmbedding {\n  assertLittleEndian();\n  assertByteLength(buf, count * meta.dims * 4, `embedding \"${meta.name}\"`);\n  return {\n    meta,\n    x: new Float32Array(buf, 0, count),\n    y: new Float32Array(buf, count * 4, count),\n    ...(meta.dims === 3 ? { z: new Float32Array(buf, count * 8, count) } : {}),\n  };\n}\n\nexport function decodeFeatureVector(buf: ArrayBuffer, count: number): Float32Array {\n  assertLittleEndian();\n  assertByteLength(buf, count * 4, 'feature vector');\n  return new Float32Array(buf, 0, count);\n}\n\n/**\n * `GET /column/{name}` → a loaded column, typed by its descriptor: `u16` codes\n * for a categorical, `f32` values for a continuous. Codes outside the category\n * list are normalised to {@link NO_CATEGORY} so a renderer can trust the\n * invariant instead of bounds-checking every point.\n */\nexport function decodeColumn(\n  buf: ArrayBuffer, meta: SpatialColumnMeta, count: number,\n): SpatialColumn {\n  assertLittleEndian();\n  if (meta.kind === 'categorical') {\n    assertByteLength(buf, count * 2, `column \"${meta.name}\"`);\n    const codes = new Uint16Array(buf, 0, count);\n    const n = (meta as CategoricalColumnMeta).categories.length;\n    for (let i = 0; i < codes.length; i++) {\n      if (codes[i] >= n) codes[i] = NO_CATEGORY;\n    }\n    return { meta: meta as CategoricalColumnMeta, codes };\n  }\n  assertByteLength(buf, count * 4, `column \"${meta.name}\"`);\n  return { meta: meta as ContinuousColumnMeta, values: new Float32Array(buf, 0, count) };\n}\n\n/**\n * `GET /polygons` → boundary rings. Layout is\n * `[u32 count][u32 offsets × (count+1)][f32 coords × 2·offsets[count]]`; every\n * field is 4-byte wide so each typed-array view stays aligned.\n */\nexport function decodePolygons(buf: ArrayBuffer): SpatialPolygons {\n  assertLittleEndian();\n  if (buf.byteLength < 8) {\n    throw new Error('[spatial] polygons: response too short for a header');\n  }\n  const count = new Uint32Array(buf, 0, 1)[0];\n  const offsets = new Uint32Array(buf, 4, count + 1);\n  const vertexCount = offsets[count];\n  const coordsByteOffset = 4 + (count + 1) * 4;\n  assertByteLength(buf, coordsByteOffset + vertexCount * 2 * 4, 'polygons');\n  const coords = new Float32Array(buf, coordsByteOffset, vertexCount * 2);\n  return { coords, offsets, count };\n}\n\n/**\n * Fold a manifest plus its fetched coordinate/id/radius vectors into the\n * library-facing {@link SpatialDataset}. Column and feature *values* are not\n * part of this — they stay lazy behind the port.\n */\nexport function datasetFromManifest(\n  manifest: SpatialManifest,\n  coords: Pick<SpatialObservations, 'x' | 'y' | 'z'>,\n  extras: { ids?: string[]; radius?: Float32Array } = {},\n): SpatialDataset {\n  assertManifestVersion(manifest);\n  const radius = manifest.radius?.mode === 'uniform'\n    ? manifest.radius.value\n    : extras.radius;\n  const observations: SpatialObservations = {\n    count: manifest.count,\n    x: coords.x,\n    y: coords.y,\n    ...(coords.z ? { z: coords.z } : {}),\n    ...(extras.ids ? { ids: extras.ids } : {}),\n    ...(radius !== undefined ? { radius } : {}),\n  };\n  return {\n    id: manifest.id,\n    name: manifest.name,\n    observations,\n    columns: manifest.columns ?? [],\n    ...(manifest.features ? { features: manifest.features } : {}),\n    ...(manifest.polygons ? { polygons: manifest.polygons } : {}),\n    ...(manifest.imageRef ? { imageRef: manifest.imageRef } : {}),\n    ...(manifest.volume ? { volume: manifest.volume } : {}),\n    ...(manifest.embeddings?.length ? { embeddings: manifest.embeddings } : {}),\n    ...(manifest.micronsPerUnit !== undefined\n      ? { micronsPerUnit: manifest.micronsPerUnit }\n      : {}),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-wire.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/spatial-data-http/spatial-wire.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CategoricalColumnMeta,\n  ContinuousColumnMeta,\n  NO_CATEGORY,\n  SpatialColumn,\n  SpatialColumnMeta,\n  SpatialDataset,\n  SpatialDensityMeta,\n  SpatialDensityRaster,\n  SpatialEmbedding,\n  SpatialEmbeddingMeta,\n  SpatialFeatureMeta,\n  SpatialImageRef,\n  SpatialObservations,\n  SpatialPolygonTile,\n  SpatialPolygonTilesMeta,\n  SpatialPolygons,\n  SpatialTranscriptBinsMeta,\n  SpatialTranscriptBinsStatus,\n  SpatialTranscriptTile,\n  SpatialTranscriptTilesMeta,\n  SpatialVolumeMeta,\n} from '../../contracts/spatial-dataset.contract';\n\n/**\n * The wire format the bundled example server speaks, and its decoders.\n *\n * Pure by design — no Angular, no RxJS, no HTTP — so the format is testable on\n * its own and reusable by any transport (`SpatialDataHttpService` is one).\n * Mirrors the split in `plotly-trace-builders.ts`: the shape lives in a pure\n * module, the service just moves bytes.\n *\n * WHY BINARY\n * ----------\n * Vectors are one `Float32Array`/`Uint16Array` per request, delivered as raw\n * little-endian bytes. JSON would cost ~8–12× the size and a parse that\n * allocates one JS number per value; a typed-array view over the response\n * buffer is zero-copy and uploads to the GPU directly.\n *\n * ENDIANNESS\n * ----------\n * Little-endian, asserted at decode. Every platform a browser runs on today is\n * little-endian, so a `DataView` byte-by-byte read would cost real time for a\n * case that does not occur — but failing loudly beats rendering transposed\n * garbage if it ever does.\n *\n * ENDPOINTS (base = the server root)\n * ----------------------------------\n * ```\n * GET {base}/spatial/datasets              -> { datasets: [{ id, name, count }] }\n * GET {base}/spatial/{id}/manifest         -> SpatialManifest\n * GET {base}/spatial/{id}/coords           -> f32[N] x, f32[N] y, f32[N] z?\n * GET {base}/spatial/{id}/radius           -> f32[N]           (per-observation radius only)\n * GET {base}/spatial/{id}/ids              -> { ids: string[] } (hasIds only)\n * GET {base}/spatial/{id}/column/{name}    -> u16[N] codes | f32[N] values\n * GET {base}/spatial/{id}/feature/{name}   -> f32[N]\n * GET {base}/spatial/{id}/features?q=&limit= -> { names: string[] }\n * GET {base}/spatial/{id}/polygons         -> u32 count, u32[count+1] offsets, f32[2*rings] coords\n * GET {base}/spatial/{id}/polygon-tile/{set}/{level}/{gx}/{gy}\n *                                          -> u32 count, u32[count] obs, u32[count+1] offsets, f32 coords\n * GET {base}/spatial/{id}/transcript-tile/{level}/{gx}/{gy}?genes=A,B&quality=high|all\n *                                          -> see decodeTranscriptTile\n * GET {base}/spatial/{id}/density?genes=A,B -> f32[rows*cols]\n * GET {base}/spatial/{id}/transcript-bins/{level}/{tx}/{ty}\n *                                          -> transcript-tile layout, one entry per bin\n * ```\n *\n * The three tiled routes are optional and advertised in the manifest\n * (`polygonTiles`, `transcriptTiles`, `density`); a server without them never\n * sees them requested.\n */\n\n/** Bumped when the layout changes incompatibly; the client refuses anything else. */\nexport const SPATIAL_WIRE_VERSION = 1;\n\n/** Per-observation marker radius: one shared value, or a served f32 vector. */\nexport type SpatialRadiusSpec =\n  | { mode: 'uniform'; value: number }\n  | { mode: 'per-observation' };\n\n/** `GET /spatial/{id}/manifest` — everything cheap enough to send up front. */\nexport interface SpatialManifest {\n  version: number;\n  id: string;\n  name: string;\n  /** N — observation count; every served vector has exactly this length. */\n  count: number;\n  hasZ?: boolean;\n  hasIds?: boolean;\n  radius?: SpatialRadiusSpec;\n  columns: SpatialColumnMeta[];\n  features?: SpatialFeatureMeta;\n  polygons?: { count: number };\n  imageRef?: SpatialImageRef;\n  volume?: SpatialVolumeMeta;\n  embeddings?: SpatialEmbeddingMeta[];\n  micronsPerUnit?: number;\n  polygonTiles?: SpatialPolygonTilesMeta;\n  transcriptTiles?: SpatialTranscriptTilesMeta;\n  density?: SpatialDensityMeta;\n  transcriptBins?: SpatialTranscriptBinsMeta;\n  transcriptBinsStatus?: SpatialTranscriptBinsStatus;\n}\n\n/** `GET /spatial/datasets` */\nexport interface SpatialDatasetSummary {\n  id: string;\n  name: string;\n  count: number;\n}\n\n/** True on a little-endian host. */\nexport function isLittleEndian(): boolean {\n  const probe = new Uint16Array([1]);\n  return new Uint8Array(probe.buffer)[0] === 1;\n}\n\nfunction assertLittleEndian(): void {\n  if (!isLittleEndian()) {\n    throw new Error(\n      '[spatial] wire format is little-endian; this platform is big-endian. ' +\n      'Serve JSON vectors, or byte-swap in a custom SpatialDataPort adapter.',\n    );\n  }\n}\n\n/** Guard a decode against a truncated or oversized response. */\nfunction assertByteLength(buf: ArrayBuffer, expected: number, what: string): void {\n  if (buf.byteLength !== expected) {\n    throw new Error(\n      `[spatial] ${what}: expected ${expected} bytes, got ${buf.byteLength}. ` +\n      'Manifest count and served vector length disagree.',\n    );\n  }\n}\n\n/** Reject a manifest this client cannot read, with a message naming the fix. */\nexport function assertManifestVersion(manifest: SpatialManifest): void {\n  if (manifest.version !== SPATIAL_WIRE_VERSION) {\n    throw new Error(\n      `[spatial] unsupported wire version ${manifest.version} ` +\n      `(this client speaks ${SPATIAL_WIRE_VERSION}). Update the server or the library.`,\n    );\n  }\n}\n\n/**\n * `GET /coords` → x/y(/z). One request rather than two or three: the vectors\n * are always fetched together, and a single response keeps them consistent if\n * the dataset changes underneath.\n */\nexport function decodeCoords(\n  buf: ArrayBuffer, count: number, hasZ = false,\n): Pick<SpatialObservations, 'x' | 'y' | 'z'> {\n  assertLittleEndian();\n  const axes = hasZ ? 3 : 2;\n  assertByteLength(buf, count * axes * 4, 'coords');\n  const x = new Float32Array(buf, 0, count);\n  const y = new Float32Array(buf, count * 4, count);\n  const z = hasZ ? new Float32Array(buf, count * 8, count) : undefined;\n  return { x, y, z };\n}\n\n/** `GET /radius` → per-observation radii in image pixels. */\nexport function decodeRadius(buf: ArrayBuffer, count: number): Float32Array {\n  assertLittleEndian();\n  assertByteLength(buf, count * 4, 'radius');\n  return new Float32Array(buf, 0, count);\n}\n\n/** `GET /feature/{name}` → one gene's expression vector. */\n/**\n * `GET /spatial/{id}/embedding/{name}` — one plane per dimension, same layout as coords.\n *\n * Struct of arrays, not interleaved: every dimension is contiguous, so an axis can be handed to\n * the renderer as a view with no copy and no stride.\n */\nexport function decodeEmbedding(\n  buf: ArrayBuffer, meta: SpatialEmbeddingMeta, count: number,\n): SpatialEmbedding {\n  assertLittleEndian();\n  assertByteLength(buf, count * meta.dims * 4, `embedding \"${meta.name}\"`);\n  return {\n    meta,\n    x: new Float32Array(buf, 0, count),\n    y: new Float32Array(buf, count * 4, count),\n    ...(meta.dims === 3 ? { z: new Float32Array(buf, count * 8, count) } : {}),\n  };\n}\n\nexport function decodeFeatureVector(buf: ArrayBuffer, count: number): Float32Array {\n  assertLittleEndian();\n  assertByteLength(buf, count * 4, 'feature vector');\n  return new Float32Array(buf, 0, count);\n}\n\n/**\n * `GET /column/{name}` → a loaded column, typed by its descriptor: `u16` codes\n * for a categorical, `f32` values for a continuous. Codes outside the category\n * list are normalised to {@link NO_CATEGORY} so a renderer can trust the\n * invariant instead of bounds-checking every point.\n */\nexport function decodeColumn(\n  buf: ArrayBuffer, meta: SpatialColumnMeta, count: number,\n): SpatialColumn {\n  assertLittleEndian();\n  if (meta.kind === 'categorical') {\n    assertByteLength(buf, count * 2, `column \"${meta.name}\"`);\n    const codes = new Uint16Array(buf, 0, count);\n    const n = (meta as CategoricalColumnMeta).categories.length;\n    for (let i = 0; i < codes.length; i++) {\n      if (codes[i] >= n) codes[i] = NO_CATEGORY;\n    }\n    return { meta: meta as CategoricalColumnMeta, codes };\n  }\n  assertByteLength(buf, count * 4, `column \"${meta.name}\"`);\n  return { meta: meta as ContinuousColumnMeta, values: new Float32Array(buf, 0, count) };\n}\n\n/**\n * `GET /polygons` → boundary rings. Layout is\n * `[u32 count][u32 offsets × (count+1)][f32 coords × 2·offsets[count]]`; every\n * field is 4-byte wide so each typed-array view stays aligned.\n */\nexport function decodePolygons(buf: ArrayBuffer): SpatialPolygons {\n  assertLittleEndian();\n  if (buf.byteLength < 8) {\n    throw new Error('[spatial] polygons: response too short for a header');\n  }\n  const count = new Uint32Array(buf, 0, 1)[0];\n  const offsets = new Uint32Array(buf, 4, count + 1);\n  const vertexCount = offsets[count];\n  const coordsByteOffset = 4 + (count + 1) * 4;\n  assertByteLength(buf, coordsByteOffset + vertexCount * 2 * 4, 'polygons');\n  const coords = new Float32Array(buf, coordsByteOffset, vertexCount * 2);\n  return { coords, offsets, count };\n}\n\n/**\n * `GET /polygon-tile/...` → one tile of rings with their owning observations. Layout\n * `[u32 count][u32 obs × count][u32 offsets × (count+1)][f32 coords × 2·offsets[count]]`.\n */\nexport function decodePolygonTile(buf: ArrayBuffer): SpatialPolygonTile {\n  assertLittleEndian();\n  if (buf.byteLength < 8) {\n    throw new Error('[spatial] polygon tile: response too short for a header');\n  }\n  const count = new Uint32Array(buf, 0, 1)[0];\n  const observation = new Uint32Array(buf, 4, count);\n  const offsets = new Uint32Array(buf, 4 + count * 4, count + 1);\n  const vertexCount = offsets[count];\n  const coordsByteOffset = 4 + count * 4 + (count + 1) * 4;\n  assertByteLength(buf, coordsByteOffset + vertexCount * 8, 'polygon tile');\n  return {\n    count, observation, offsets,\n    coords: new Float32Array(buf, coordsByteOffset, vertexCount * 2),\n  };\n}\n\n/**\n * `GET /transcript-tile/...` → transcripts or aggregates. Layout, 4-byte aligned:\n * `[u32 n][u32 flags][f32 x·n][f32 y·n][f32 z·n][u32 weight·n][u32 obs·n][u16 gene·n, padded]`;\n * flags bit 0 marks an aggregated level.\n */\nexport function decodeTranscriptTile(buf: ArrayBuffer): SpatialTranscriptTile {\n  assertLittleEndian();\n  if (buf.byteLength < 8) {\n    throw new Error('[spatial] transcript tile: response too short for a header');\n  }\n  const [n, flags] = new Uint32Array(buf, 0, 2);\n  const genePad = Math.ceil((n * 2) / 4) * 4;\n  assertByteLength(buf, 8 + n * 20 + genePad, 'transcript tile');\n  return {\n    count: n,\n    aggregated: (flags & 1) === 1,\n    x: new Float32Array(buf, 8, n),\n    y: new Float32Array(buf, 8 + n * 4, n),\n    z: new Float32Array(buf, 8 + n * 8, n),\n    weight: new Uint32Array(buf, 8 + n * 12, n),\n    observation: new Uint32Array(buf, 8 + n * 16, n),\n    gene: new Uint16Array(buf, 8 + n * 20, n),\n  };\n}\n\n/**\n * `GET /density?genes=&bin=` → the summed raster. Layout\n * `[u32 rows][u32 cols][f32 cellW][f32 cellH][f32 originX][f32 originY][f32 rows·cols]`:\n * the geometry travels with the values because re-binning changes it.\n */\nexport function decodeDensity(buf: ArrayBuffer, genes: string[]): SpatialDensityRaster {\n  assertLittleEndian();\n  if (buf.byteLength < 24) throw new Error('[spatial] density: response too short for a header');\n  const [rows, cols] = new Uint32Array(buf, 0, 2);\n  const [cw, ch, ox, oy] = new Float32Array(buf, 8, 4);\n  assertByteLength(buf, 24 + rows * cols * 4, 'density');\n  const meta: SpatialDensityMeta = { rows, cols, gridSize: [cw, ch], origin: [ox, oy] };\n  return { meta, genes, values: new Float32Array(buf, 24, rows * cols) };\n}\n\n/**\n * Fold a manifest plus its fetched coordinate/id/radius vectors into the\n * library-facing {@link SpatialDataset}. Column and feature *values* are not\n * part of this — they stay lazy behind the port.\n */\nexport function datasetFromManifest(\n  manifest: SpatialManifest,\n  coords: Pick<SpatialObservations, 'x' | 'y' | 'z'>,\n  extras: { ids?: string[]; radius?: Float32Array } = {},\n): SpatialDataset {\n  assertManifestVersion(manifest);\n  const radius = manifest.radius?.mode === 'uniform'\n    ? manifest.radius.value\n    : extras.radius;\n  const observations: SpatialObservations = {\n    count: manifest.count,\n    x: coords.x,\n    y: coords.y,\n    ...(coords.z ? { z: coords.z } : {}),\n    ...(extras.ids ? { ids: extras.ids } : {}),\n    ...(radius !== undefined ? { radius } : {}),\n  };\n  return {\n    id: manifest.id,\n    name: manifest.name,\n    observations,\n    columns: manifest.columns ?? [],\n    ...(manifest.features ? { features: manifest.features } : {}),\n    ...(manifest.polygons ? { polygons: manifest.polygons } : {}),\n    ...(manifest.imageRef ? { imageRef: manifest.imageRef } : {}),\n    ...(manifest.volume ? { volume: manifest.volume } : {}),\n    ...(manifest.embeddings?.length ? { embeddings: manifest.embeddings } : {}),\n    ...(manifest.micronsPerUnit !== undefined\n      ? { micronsPerUnit: manifest.micronsPerUnit }\n      : {}),\n    ...(manifest.polygonTiles ? { polygonTiles: manifest.polygonTiles } : {}),\n    ...(manifest.transcriptTiles ? { transcriptTiles: manifest.transcriptTiles } : {}),\n    ...(manifest.density ? { density: manifest.density } : {}),\n    ...(manifest.transcriptBins ? { transcriptBins: manifest.transcriptBins } : {}),\n    ...(manifest.transcriptBinsStatus ? { transcriptBinsStatus: manifest.transcriptBinsStatus } : {}),\n  };\n}\n"]}