@jax-data-science/sci-image-visualizer 0.3.3 → 0.4.0

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

@@ -0,0 +1,304 @@
+import { HttpClient } from '@angular/common/http';
+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 * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Reference {@link SpatialDataPort} adapter for the wire format the bundled
+ * example server speaks (see `spatial-wire.ts` and
+ * `examples/tile-server/lib/spatial.mjs`).
+ *
+ * OPTIONAL AND UNBOUND BY DEFAULT — this service is `@Injectable()` without
+ * `providedIn`, so nothing gets it unless a host explicitly provides it:
+ *
+ * ```ts
+ * providers: [
+ *   SpatialDataHttpService,
+ *   { provide: SPATIAL_DATA_PORT, useExisting: SpatialDataHttpService },
+ * ]
+ * ```
+ *
+ * That mirrors `CellposeSegmenterService`: a concrete implementation the
+ * library ships for convenience, not a default the port inversion is quietly
+ * giving up on. A host with its own backend implements `SpatialDataPort`
+ * directly and never touches this class.
+ *
+ * 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; }
+    constructor(http) {
+        this.http = http;
+        /** Server root, normalised to end with exactly one `/`. */
+        this.baseUrl = '';
+        /** Per-request ceiling. Vectors are small; a hung request should not wedge
+         *  the picker. */
+        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;
+        /**
+         * 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).
+         */
+        this.cache = new Map();
+        /** In-flight requests, so double-clicking a gene issues one fetch. */
+        this.inFlight = new Map();
+        this.volumePromise = null;
+        this.polygonsPromise = null;
+    }
+    // ── configuration ───────────────────────────────────────────────────────
+    /** Point the adapter at a server. Clears any loaded dataset. */
+    configure(options) {
+        const raw = options.baseUrl ?? '';
+        this.baseUrl = raw.endsWith('/') ? raw : `${raw}/`;
+        if (options.timeoutMs !== undefined)
+            this.timeoutMs = options.timeoutMs;
+        this.clear();
+    }
+    /** Datasets this server offers, for a host-side picker. */
+    listDatasets() {
+        return this.getJson('spatial/datasets')
+            .then((r) => r.datasets ?? []);
+    }
+    /**
+     * One dataset's manifest, WITHOUT selecting it. Lets a host inspect what a
+     * server offers — column and feature metadata, and which image a dataset
+     * registers onto — while building a picker, rather than having to load each
+     * dataset to find out.
+     */
+    readManifest(id) {
+        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.
+     */
+    async selectDataset(id) {
+        this.clear();
+        // Selections are SEQUENCED: this is four 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 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`);
+        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 dataset = datasetFromManifest(manifest, coords, { ids, radius });
+        this.dataset$.next(dataset);
+        return dataset;
+    }
+    /** Drop the loaded dataset and every cached vector. */
+    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.manifest = null;
+        this.cache.clear();
+        this.inFlight.clear();
+        this.polygonsPromise = null;
+        this.volumePromise = null;
+        if (this.dataset$.value !== null)
+            this.dataset$.next(null);
+    }
+    // ── SpatialDataPort ─────────────────────────────────────────────────────
+    getDataset$() {
+        return this.dataset$.asObservable();
+    }
+    getColumn(name) {
+        const manifest = this.requireManifest();
+        const dataset = this.dataset$.value;
+        const meta = findColumnMeta(dataset, name);
+        if (!meta) {
+            // Reject rather than resolve empty: a typo must surface as an error, not
+            // 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)));
+    }
+    getEmbedding(name) {
+        const manifest = this.requireManifest();
+        const meta = manifest.embeddings?.find((e) => e.name === name);
+        if (!meta) {
+            return Promise.reject(new Error(`[spatial] unknown embedding "${name}"`));
+        }
+        return this.fetchCached(`embedding:${name}`, () => this.getBinary(`spatial/${encodeURIComponent(manifest.id)}/embedding/${encodeURIComponent(name)}`).then((buf) => decodeEmbedding(buf, meta, manifest.count)));
+    }
+    getFeatureVector(name) {
+        const manifest = this.requireManifest();
+        const names = manifest.features?.names;
+        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)));
+    }
+    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.
+        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}`;
+        return (await this.getJson(url)).names ?? [];
+    }
+    getPolygons() {
+        const manifest = this.requireManifest();
+        if (!manifest.polygons) {
+            return Promise.reject(new Error('[spatial] this dataset has no polygon geometry'));
+        }
+        // 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`)
+            .then(decodePolygons)
+            .catch((err) => { this.polygonsPromise = null; throw err; });
+        return this.polygonsPromise;
+    }
+    /**
+     * The reference volume's voxels, single-flighted like the polygons.
+     *
+     * Validated against the manifest's declared dimensions before it is handed
+     * back: a short or long buffer read as a 3D texture does not fail, it shears
+     * the anatomy into diagonal streaks, and that is far harder to recognise as a
+     * transport problem than an error is.
+     */
+    getVolume() {
+        const manifest = this.requireManifest();
+        const meta = manifest.volume;
+        if (!meta) {
+            return Promise.reject(new Error('[spatial] this dataset has no reference 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})`);
+            }
+            return new Uint8Array(buf);
+        })
+            .catch((err) => { this.volumePromise = null; throw err; });
+        return this.volumePromise;
+    }
+    // ── internals ───────────────────────────────────────────────────────────
+    requireManifest() {
+        if (!this.manifest || !this.dataset$.value) {
+            throw new Error('[spatial] no dataset selected — call selectDataset() first');
+        }
+        return this.manifest;
+    }
+    /**
+     * Cache + single-flight around a vector fetch.
+     *
+     * Keys are LOGICAL — `feature:GAPDH`, not `<dataset>/feature:GAPDH` — because `clear()`
+     * empties the maps on every switch, so two datasets never hold entries at once. What
+     * that does not cover is a request still in the air when the switch happens: `clear()`
+     * cannot cancel an HTTP call, so a vector fetched for dataset A can resolve after B has
+     * been selected and write itself into B's cache under a key B would read. Both datasets
+     * having a gene of that name is the common case, not the unlucky one, and the result is
+     * a plot of A's expression over B's cells — which looks like data, not like a fault.
+     *
+     * So the generation is checked after the await, and the in-flight slot is cleared only
+     * when the promise still sitting in it is this one: a late arrival must not evict the
+     * entry a newer request for the same key is already sharing.
+     */
+    fetchCached(key, load) {
+        const hit = this.cache.get(key);
+        if (hit) {
+            // Re-insert to mark most-recently-used (Map preserves insertion order).
+            this.cache.delete(key);
+            this.cache.set(key, hit);
+            return Promise.resolve(hit);
+        }
+        const pending = this.inFlight.get(key);
+        if (pending)
+            return pending;
+        const mine = this.selectToken;
+        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);
+                this.evict();
+            }
+            return value;
+        })
+            .finally(() => {
+            if (this.inFlight.get(key) === promise)
+                this.inFlight.delete(key);
+        });
+        this.inFlight.set(key, promise);
+        return promise;
+    }
+    evict() {
+        while (this.cache.size > SpatialDataHttpService.CACHE_LIMIT) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.cache.delete(oldest);
+        }
+    }
+    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)));
+    }
+    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 }); }
+}
+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 } 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"]}

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

@@ -0,0 +1,179 @@
+import { NO_CATEGORY, } from '../../contracts/spatial-dataset.contract';
+/**
+ * The wire format the bundled example server speaks, and its decoders.
+ *
+ * Pure by design — no Angular, no RxJS, no HTTP — so the format is testable on
+ * its own and reusable by any transport (`SpatialDataHttpService` is one).
+ * Mirrors the split in `plotly-trace-builders.ts`: the shape lives in a pure
+ * module, the service just moves bytes.
+ *
+ * WHY BINARY
+ * ----------
+ * Vectors are one `Float32Array`/`Uint16Array` per request, delivered as raw
+ * little-endian bytes. JSON would cost ~8–12× the size and a parse that
+ * allocates one JS number per value; a typed-array view over the response
+ * buffer is zero-copy and uploads to the GPU directly.
+ *
+ * ENDIANNESS
+ * ----------
+ * Little-endian, asserted at decode. Every platform a browser runs on today is
+ * little-endian, so a `DataView` byte-by-byte read would cost real time for a
+ * case that does not occur — but failing loudly beats rendering transposed
+ * garbage if it ever does.
+ *
+ * ENDPOINTS (base = the server root)
+ * ----------------------------------
+ * ```
+ * GET {base}/spatial/datasets              -> { datasets: [{ id, name, count }] }
+ * GET {base}/spatial/{id}/manifest         -> SpatialManifest
+ * GET {base}/spatial/{id}/coords           -> f32[N] x, f32[N] y, f32[N] z?
+ * GET {base}/spatial/{id}/radius           -> f32[N]           (per-observation radius only)
+ * GET {base}/spatial/{id}/ids              -> { ids: string[] } (hasIds only)
+ * GET {base}/spatial/{id}/column/{name}    -> u16[N] codes | f32[N] values
+ * 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
+ * ```
+ */
+/** Bumped when the layout changes incompatibly; the client refuses anything else. */
+export const SPATIAL_WIRE_VERSION = 1;
+/** True on a little-endian host. */
+export function isLittleEndian() {
+    const probe = new Uint16Array([1]);
+    return new Uint8Array(probe.buffer)[0] === 1;
+}
+function assertLittleEndian() {
+    if (!isLittleEndian()) {
+        throw new Error('[spatial] wire format is little-endian; this platform is big-endian. ' +
+            'Serve JSON vectors, or byte-swap in a custom SpatialDataPort adapter.');
+    }
+}
+/** Guard a decode against a truncated or oversized response. */
+function assertByteLength(buf, expected, what) {
+    if (buf.byteLength !== expected) {
+        throw new Error(`[spatial] ${what}: expected ${expected} bytes, got ${buf.byteLength}. ` +
+            'Manifest count and served vector length disagree.');
+    }
+}
+/** Reject a manifest this client cannot read, with a message naming the fix. */
+export function assertManifestVersion(manifest) {
+    if (manifest.version !== SPATIAL_WIRE_VERSION) {
+        throw new Error(`[spatial] unsupported wire version ${manifest.version} ` +
+            `(this client speaks ${SPATIAL_WIRE_VERSION}). Update the server or the library.`);
+    }
+}
+/**
+ * `GET /coords` → x/y(/z). One request rather than two or three: the vectors
+ * are always fetched together, and a single response keeps them consistent if
+ * the dataset changes underneath.
+ */
+export function decodeCoords(buf, count, hasZ = false) {
+    assertLittleEndian();
+    const axes = hasZ ? 3 : 2;
+    assertByteLength(buf, count * axes * 4, 'coords');
+    const x = new Float32Array(buf, 0, count);
+    const y = new Float32Array(buf, count * 4, count);
+    const z = hasZ ? new Float32Array(buf, count * 8, count) : undefined;
+    return { x, y, z };
+}
+/** `GET /radius` → per-observation radii in image pixels. */
+export function decodeRadius(buf, count) {
+    assertLittleEndian();
+    assertByteLength(buf, count * 4, 'radius');
+    return new Float32Array(buf, 0, count);
+}
+/** `GET /feature/{name}` → one gene's expression vector. */
+/**
+ * `GET /spatial/{id}/embedding/{name}` — one plane per dimension, same layout as coords.
+ *
+ * Struct of arrays, not interleaved: every dimension is contiguous, so an axis can be handed to
+ * the renderer as a view with no copy and no stride.
+ */
+export function decodeEmbedding(buf, meta, count) {
+    assertLittleEndian();
+    assertByteLength(buf, count * meta.dims * 4, `embedding "${meta.name}"`);
+    return {
+        meta,
+        x: new Float32Array(buf, 0, count),
+        y: new Float32Array(buf, count * 4, count),
+        ...(meta.dims === 3 ? { z: new Float32Array(buf, count * 8, count) } : {}),
+    };
+}
+export function decodeFeatureVector(buf, count) {
+    assertLittleEndian();
+    assertByteLength(buf, count * 4, 'feature vector');
+    return new Float32Array(buf, 0, count);
+}
+/**
+ * `GET /column/{name}` → a loaded column, typed by its descriptor: `u16` codes
+ * for a categorical, `f32` values for a continuous. Codes outside the category
+ * list are normalised to {@link NO_CATEGORY} so a renderer can trust the
+ * invariant instead of bounds-checking every point.
+ */
+export function decodeColumn(buf, meta, count) {
+    assertLittleEndian();
+    if (meta.kind === 'categorical') {
+        assertByteLength(buf, count * 2, `column "${meta.name}"`);
+        const codes = new Uint16Array(buf, 0, count);
+        const n = meta.categories.length;
+        for (let i = 0; i < codes.length; i++) {
+            if (codes[i] >= n)
+                codes[i] = NO_CATEGORY;
+        }
+        return { meta: meta, codes };
+    }
+    assertByteLength(buf, count * 4, `column "${meta.name}"`);
+    return { meta: meta, values: new Float32Array(buf, 0, count) };
+}
+/**
+ * `GET /polygons` → boundary rings. Layout is
+ * `[u32 count][u32 offsets × (count+1)][f32 coords × 2·offsets[count]]`; every
+ * field is 4-byte wide so each typed-array view stays aligned.
+ */
+export function decodePolygons(buf) {
+    assertLittleEndian();
+    if (buf.byteLength < 8) {
+        throw new Error('[spatial] polygons: response too short for a header');
+    }
+    const count = new Uint32Array(buf, 0, 1)[0];
+    const offsets = new Uint32Array(buf, 4, count + 1);
+    const vertexCount = offsets[count];
+    const coordsByteOffset = 4 + (count + 1) * 4;
+    assertByteLength(buf, coordsByteOffset + vertexCount * 2 * 4, 'polygons');
+    const coords = new Float32Array(buf, coordsByteOffset, vertexCount * 2);
+    return { coords, offsets, count };
+}
+/**
+ * Fold a manifest plus its fetched coordinate/id/radius vectors into the
+ * library-facing {@link SpatialDataset}. Column and feature *values* are not
+ * part of this — they stay lazy behind the port.
+ */
+export function datasetFromManifest(manifest, coords, extras = {}) {
+    assertManifestVersion(manifest);
+    const radius = manifest.radius?.mode === 'uniform'
+        ? manifest.radius.value
+        : extras.radius;
+    const observations = {
+        count: manifest.count,
+        x: coords.x,
+        y: coords.y,
+        ...(coords.z ? { z: coords.z } : {}),
+        ...(extras.ids ? { ids: extras.ids } : {}),
+        ...(radius !== undefined ? { radius } : {}),
+    };
+    return {
+        id: manifest.id,
+        name: manifest.name,
+        observations,
+        columns: manifest.columns ?? [],
+        ...(manifest.features ? { features: manifest.features } : {}),
+        ...(manifest.polygons ? { polygons: manifest.polygons } : {}),
+        ...(manifest.imageRef ? { imageRef: manifest.imageRef } : {}),
+        ...(manifest.volume ? { volume: manifest.volume } : {}),
+        ...(manifest.embeddings?.length ? { embeddings: manifest.embeddings } : {}),
+        ...(manifest.micronsPerUnit !== undefined
+            ? { micronsPerUnit: manifest.micronsPerUnit }
+            : {}),
+    };
+}
+//# 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"]}