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

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

@@ -1,4 +1,4 @@
-import { NO_CATEGORY, } from '../../contracts/spatial-dataset.contract';
+import { NO_CATEGORY, NO_OBSERVATION, } from '../../contracts/spatial-dataset.contract';
 /**
  * The wire format the bundled example server speaks, and its decoders.
  *
@@ -23,6 +23,8 @@ import { NO_CATEGORY, } from '../../contracts/spatial-dataset.contract';
  *
  * ENDPOINTS (base = the server root)
  * ----------------------------------
+ * Every route `SpatialDataHttpService` calls. `{id}` is the dataset id; names and
+ * gene lists are URI-encoded.
  * ```
  * GET {base}/spatial/datasets              -> { datasets: [{ id, name, count }] }
  * GET {base}/spatial/{id}/manifest         -> SpatialManifest
@@ -32,19 +34,28 @@ import { NO_CATEGORY, } from '../../contracts/spatial-dataset.contract';
  * 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}/embedding/{name} -> f32[N] per dimension, see decodeEmbedding
  * GET {base}/spatial/{id}/polygons         -> u32 count, u32[count+1] offsets, f32[2*rings] coords
+ * GET {base}/spatial/{id}/volume           -> u8[width*height*depth]   (manifest.volume only)
  * 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
+ * GET {base}/spatial/{id}/transcript-tile/{level}/{gx}/{gy}?genes=A,B&quality=high|all&box=
  *                                          -> 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
+ * GET {base}/spatial/{id}/gene-bins/{level}/{tx}/{ty}?genes=A,B
+ *                                          -> transcript-tile layout, per-gene bins
+ * GET {base}/spatial/{id}/density?genes=A,B&bin= -> see decodeDensity
+ * GET {base}/spatial/{id}/transcript-summary?box=&genes=&cells= -> SpatialTranscriptSummary
+ * GET {base}/spatial/{id}/transcript-counts?genes=A,B -> SpatialTranscriptCounts
+ * GET {base}/spatial/{id}/markers/{column}?n=  -> SpatialMarkerGenes
+ * POST {base}/spatial/{id}/groups?name=    (text/csv `cell_id,group`)
+ *                                          -> { column: CategoricalColumnMeta, matched }
  * ```
  *
- * The three tiled routes are optional and advertised in the manifest
- * (`polygonTiles`, `transcriptTiles`, `density`); a server without them never
- * sees them requested.
+ * The optional routes are advertised in the manifest (`polygons`, `volume`,
+ * `polygonTiles`, `transcriptTiles`, `transcriptBins`, `transcriptGeneBins`,
+ * `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;
@@ -66,12 +77,59 @@ function assertByteLength(buf, expected, what) {
             'Manifest count and served vector length disagree.');
     }
 }
-/** Reject a manifest this client cannot read, with a message naming the fix. */
+/**
+ * Reject a manifest this client cannot read, with a message naming the fix.
+ *
+ * Besides the version, the values every decoder sizes its views from: an observation
+ * count that is not a non-negative integer, or an embedding that is not 2-D or 3-D, would
+ * otherwise surface later as a RangeError deep inside a renderer.
+ */
 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.`);
     }
+    if (!Number.isSafeInteger(manifest.count) || manifest.count < 0) {
+        throw new Error(`[spatial] manifest count ${manifest.count} is not a non-negative integer`);
+    }
+    for (const e of manifest.embeddings ?? [])
+        assertEmbeddingDims(e);
+}
+function assertEmbeddingDims(meta) {
+    if (meta.dims !== 2 && meta.dims !== 3) {
+        throw new Error(`[spatial] embedding "${meta.name}": dims ${meta.dims} is not 2 or 3`);
+    }
+}
+/**
+ * Ring offsets must start at 0 and never go backwards: a decreasing pair is a negative
+ * vertex count, which a renderer turns into `new Float32Array(negative)` on every frame.
+ * (That the last offset matches the coordinate block is the byte-length check's job.)
+ */
+function assertRingOffsets(offsets, what) {
+    if (offsets[0] !== 0)
+        throw new Error(`[spatial] ${what}: offsets must start at 0`);
+    for (let i = 1; i < offsets.length; i++) {
+        if (offsets[i] < offsets[i - 1]) {
+            throw new Error(`[spatial] ${what}: offsets decrease at ring ${i - 1}`);
+        }
+    }
+}
+/** Every entry must name an observation below `count`, or {@link NO_OBSERVATION}. */
+function assertObservations(observation, count, what) {
+    if (count === undefined)
+        return;
+    for (let i = 0; i < observation.length; i++) {
+        const o = observation[i];
+        if (o >= count && o !== NO_OBSERVATION) {
+            throw new Error(`[spatial] ${what}: observation ${o} is past the ${count} in the dataset`);
+        }
+    }
+}
+/** A header-sized prefix must be there before any view over it is made. */
+function assertHeader(buf, bytes, what) {
+    if (buf.byteLength < bytes) {
+        throw new Error(`[spatial] ${what}: response too short for its header (${buf.byteLength} < ${bytes} bytes)`);
+    }
 }
 /**
  * `GET /coords` → x/y(/z). One request rather than two or three: the vectors
@@ -93,7 +151,6 @@ export function decodeRadius(buf, count) {
     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.
  *
@@ -102,6 +159,7 @@ export function decodeRadius(buf, count) {
  */
 export function decodeEmbedding(buf, meta, count) {
     assertLittleEndian();
+    assertEmbeddingDims(meta);
     assertByteLength(buf, count * meta.dims * 4, `embedding "${meta.name}"`);
     return {
         meta,
@@ -110,6 +168,7 @@ export function decodeEmbedding(buf, meta, count) {
         ...(meta.dims === 3 ? { z: new Float32Array(buf, count * 8, count) } : {}),
     };
 }
+/** `GET /feature/{name}` → one gene's expression vector. */
 export function decodeFeatureVector(buf, count) {
     assertLittleEndian();
     assertByteLength(buf, count * 4, 'feature vector');
@@ -147,9 +206,11 @@ export function decodePolygons(buf) {
         throw new Error('[spatial] polygons: response too short for a header');
     }
     const count = new Uint32Array(buf, 0, 1)[0];
+    const coordsByteOffset = 4 + (count + 1) * 4;
+    assertHeader(buf, coordsByteOffset, 'polygons');
     const offsets = new Uint32Array(buf, 4, count + 1);
+    assertRingOffsets(offsets, 'polygons');
     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 };
@@ -157,20 +218,27 @@ export function decodePolygons(buf) {
 /**
  * `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]]`.
+ *
+ * `observations` is the dataset's N; when given, every owner must be below it.
  */
-export function decodePolygonTile(buf) {
+export function decodePolygonTile(buf, observations) {
     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 coordsByteOffset = 4 + count * 4 + (count + 1) * 4;
+    assertHeader(buf, coordsByteOffset, 'polygon tile');
     const observation = new Uint32Array(buf, 4, count);
     const offsets = new Uint32Array(buf, 4 + count * 4, count + 1);
+    assertRingOffsets(offsets, 'polygon tile');
     const vertexCount = offsets[count];
-    const coordsByteOffset = 4 + count * 4 + (count + 1) * 4;
     assertByteLength(buf, coordsByteOffset + vertexCount * 8, 'polygon tile');
+    assertObservations(observation, observations, 'polygon tile');
     return {
-        count, observation, offsets,
+        count,
+        observation,
+        offsets,
         coords: new Float32Array(buf, coordsByteOffset, vertexCount * 2),
     };
 }
@@ -178,8 +246,11 @@ export function decodePolygonTile(buf) {
  * `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.
+ *
+ * `limits` bounds the indices when the caller knows them: `observations` is the dataset's
+ * N, and `genes` the length of the gene list the codes index (omit it for `ALL_GENES`).
  */
-export function decodeTranscriptTile(buf) {
+export function decodeTranscriptTile(buf, limits = {}) {
     assertLittleEndian();
     if (buf.byteLength < 8) {
         throw new Error('[spatial] transcript tile: response too short for a header');
@@ -187,6 +258,16 @@ export function decodeTranscriptTile(buf) {
     const [n, flags] = new Uint32Array(buf, 0, 2);
     const genePad = Math.ceil((n * 2) / 4) * 4;
     assertByteLength(buf, 8 + n * 20 + genePad, 'transcript tile');
+    const observation = new Uint32Array(buf, 8 + n * 16, n);
+    const gene = new Uint16Array(buf, 8 + n * 20, n);
+    assertObservations(observation, limits.observations, 'transcript tile');
+    if (limits.genes !== undefined) {
+        for (let i = 0; i < n; i++) {
+            if (gene[i] >= limits.genes) {
+                throw new Error(`[spatial] transcript tile: gene code ${gene[i]} is past the ${limits.genes} asked for`);
+            }
+        }
+    }
     return {
         count: n,
         aggregated: (flags & 1) === 1,
@@ -194,8 +275,8 @@ export function decodeTranscriptTile(buf) {
         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),
+        observation,
+        gene,
     };
 }
 /**
@@ -209,6 +290,10 @@ export function decodeDensity(buf, genes) {
         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);
+    // The cell size divides every downstream position; zero, negative or NaN is unusable.
+    if (!(cw > 0 && ch > 0 && Number.isFinite(cw) && Number.isFinite(ch))) {
+        throw new Error(`[spatial] density: grid size ${cw} x ${ch} is not positive and finite`);
+    }
     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) };
@@ -220,9 +305,7 @@ export function decodeDensity(buf, genes) {
  */
 export function datasetFromManifest(manifest, coords, extras = {}) {
     assertManifestVersion(manifest);
-    const radius = manifest.radius?.mode === 'uniform'
-        ? manifest.radius.value
-        : extras.radius;
+    const radius = manifest.radius?.mode === 'uniform' ? manifest.radius.value : extras.radius;
     const observations = {
         count: manifest.count,
         x: coords.x,
@@ -241,9 +324,7 @@ export function datasetFromManifest(manifest, coords, extras = {}) {
         ...(manifest.imageRef ? { imageRef: manifest.imageRef } : {}),
         ...(manifest.volume ? { volume: manifest.volume } : {}),
         ...(manifest.embeddings?.length ? { embeddings: manifest.embeddings } : {}),
-        ...(manifest.micronsPerUnit !== undefined
-            ? { micronsPerUnit: manifest.micronsPerUnit }
-            : {}),
+        ...(manifest.micronsPerUnit !== undefined ? { micronsPerUnit: manifest.micronsPerUnit } : {}),
         ...(manifest.polygonTiles ? { polygonTiles: manifest.polygonTiles } : {}),
         ...(manifest.transcriptTiles ? { transcriptTiles: manifest.transcriptTiles } : {}),
         ...(manifest.density ? { density: manifest.density } : {}),
@@ -252,4 +333,4 @@ export function datasetFromManifest(manifest, coords, extras = {}) {
         ...(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  SpatialDensityMeta,\n  SpatialDensityRaster,\n  SpatialEmbedding,\n  SpatialEmbeddingMeta,\n  SpatialFeatureMeta,\n  SpatialImageRef,\n  SpatialObservations,\n  SpatialPolygonTile,\n  SpatialPolygonTilesMeta,\n  SpatialPolygons,\n  SpatialTranscriptBinsMeta, SpatialTranscriptGeneBinsMeta,\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  transcriptGeneBins?: SpatialTranscriptGeneBinsMeta;\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.transcriptGeneBins ? { transcriptGeneBins: manifest.transcriptGeneBins } : {}),\n    ...(manifest.transcriptBinsStatus ? { transcriptBinsStatus: manifest.transcriptBinsStatus } : {}),\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  NO_OBSERVATION,\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  SpatialTranscriptGeneBinsMeta,\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 * Every route `SpatialDataHttpService` calls. `{id}` is the dataset id; names and\n * gene lists are URI-encoded.\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}/embedding/{name} -> f32[N] per dimension, see decodeEmbedding\n * GET {base}/spatial/{id}/polygons         -> u32 count, u32[count+1] offsets, f32[2*rings] coords\n * GET {base}/spatial/{id}/volume           -> u8[width*height*depth]   (manifest.volume only)\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&box=\n *                                          -> see decodeTranscriptTile\n * GET {base}/spatial/{id}/transcript-bins/{level}/{tx}/{ty}\n *                                          -> transcript-tile layout, one entry per bin\n * GET {base}/spatial/{id}/gene-bins/{level}/{tx}/{ty}?genes=A,B\n *                                          -> transcript-tile layout, per-gene bins\n * GET {base}/spatial/{id}/density?genes=A,B&bin= -> see decodeDensity\n * GET {base}/spatial/{id}/transcript-summary?box=&genes=&cells= -> SpatialTranscriptSummary\n * GET {base}/spatial/{id}/transcript-counts?genes=A,B -> SpatialTranscriptCounts\n * GET {base}/spatial/{id}/markers/{column}?n=  -> SpatialMarkerGenes\n * POST {base}/spatial/{id}/groups?name=    (text/csv `cell_id,group`)\n *                                          -> { column: CategoricalColumnMeta, matched }\n * ```\n *\n * The optional routes are advertised in the manifest (`polygons`, `volume`,\n * `polygonTiles`, `transcriptTiles`, `transcriptBins`, `transcriptGeneBins`,\n * `density`); a server without them never 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 = { mode: 'uniform'; value: number } | { 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  transcriptGeneBins?: SpatialTranscriptGeneBinsMeta;\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/**\n * Reject a manifest this client cannot read, with a message naming the fix.\n *\n * Besides the version, the values every decoder sizes its views from: an observation\n * count that is not a non-negative integer, or an embedding that is not 2-D or 3-D, would\n * otherwise surface later as a RangeError deep inside a renderer.\n */\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  if (!Number.isSafeInteger(manifest.count) || manifest.count < 0) {\n    throw new Error(`[spatial] manifest count ${manifest.count} is not a non-negative integer`);\n  }\n  for (const e of manifest.embeddings ?? []) assertEmbeddingDims(e);\n}\n\nfunction assertEmbeddingDims(meta: SpatialEmbeddingMeta): void {\n  if (meta.dims !== 2 && meta.dims !== 3) {\n    throw new Error(`[spatial] embedding \"${meta.name}\": dims ${meta.dims} is not 2 or 3`);\n  }\n}\n\n/**\n * Ring offsets must start at 0 and never go backwards: a decreasing pair is a negative\n * vertex count, which a renderer turns into `new Float32Array(negative)` on every frame.\n * (That the last offset matches the coordinate block is the byte-length check's job.)\n */\nfunction assertRingOffsets(offsets: Uint32Array, what: string): void {\n  if (offsets[0] !== 0) throw new Error(`[spatial] ${what}: offsets must start at 0`);\n  for (let i = 1; i < offsets.length; i++) {\n    if (offsets[i] < offsets[i - 1]) {\n      throw new Error(`[spatial] ${what}: offsets decrease at ring ${i - 1}`);\n    }\n  }\n}\n\n/** Every entry must name an observation below `count`, or {@link NO_OBSERVATION}. */\nfunction assertObservations(observation: Uint32Array, count: number | undefined, what: string): void {\n  if (count === undefined) return;\n  for (let i = 0; i < observation.length; i++) {\n    const o = observation[i];\n    if (o >= count && o !== NO_OBSERVATION) {\n      throw new Error(`[spatial] ${what}: observation ${o} is past the ${count} in the dataset`);\n    }\n  }\n}\n\n/** A header-sized prefix must be there before any view over it is made. */\nfunction assertHeader(buf: ArrayBuffer, bytes: number, what: string): void {\n  if (buf.byteLength < bytes) {\n    throw new Error(`[spatial] ${what}: response too short for its header (${buf.byteLength} < ${bytes} bytes)`);\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,\n  count: number,\n  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/**\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(buf: ArrayBuffer, meta: SpatialEmbeddingMeta, count: number): SpatialEmbedding {\n  assertLittleEndian();\n  assertEmbeddingDims(meta);\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\n/** `GET /feature/{name}` → one gene's expression vector. */\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(buf: ArrayBuffer, meta: SpatialColumnMeta, count: number): 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 coordsByteOffset = 4 + (count + 1) * 4;\n  assertHeader(buf, coordsByteOffset, 'polygons');\n  const offsets = new Uint32Array(buf, 4, count + 1);\n  assertRingOffsets(offsets, 'polygons');\n  const vertexCount = offsets[count];\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 *\n * `observations` is the dataset's N; when given, every owner must be below it.\n */\nexport function decodePolygonTile(buf: ArrayBuffer, observations?: number): 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 coordsByteOffset = 4 + count * 4 + (count + 1) * 4;\n  assertHeader(buf, coordsByteOffset, 'polygon tile');\n  const observation = new Uint32Array(buf, 4, count);\n  const offsets = new Uint32Array(buf, 4 + count * 4, count + 1);\n  assertRingOffsets(offsets, 'polygon tile');\n  const vertexCount = offsets[count];\n  assertByteLength(buf, coordsByteOffset + vertexCount * 8, 'polygon tile');\n  assertObservations(observation, observations, 'polygon tile');\n  return {\n    count,\n    observation,\n    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 *\n * `limits` bounds the indices when the caller knows them: `observations` is the dataset's\n * N, and `genes` the length of the gene list the codes index (omit it for `ALL_GENES`).\n */\nexport function decodeTranscriptTile(\n  buf: ArrayBuffer,\n  limits: { observations?: number; genes?: number } = {},\n): 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  const observation = new Uint32Array(buf, 8 + n * 16, n);\n  const gene = new Uint16Array(buf, 8 + n * 20, n);\n  assertObservations(observation, limits.observations, 'transcript tile');\n  if (limits.genes !== undefined) {\n    for (let i = 0; i < n; i++) {\n      if (gene[i] >= limits.genes) {\n        throw new Error(`[spatial] transcript tile: gene code ${gene[i]} is past the ${limits.genes} asked for`);\n      }\n    }\n  }\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,\n    gene,\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  // The cell size divides every downstream position; zero, negative or NaN is unusable.\n  if (!(cw > 0 && ch > 0 && Number.isFinite(cw) && Number.isFinite(ch))) {\n    throw new Error(`[spatial] density: grid size ${cw} x ${ch} is not positive and finite`);\n  }\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' ? manifest.radius.value : 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 ? { micronsPerUnit: manifest.micronsPerUnit } : {}),\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.transcriptGeneBins ? { transcriptGeneBins: manifest.transcriptGeneBins } : {}),\n    ...(manifest.transcriptBinsStatus ? { transcriptBinsStatus: manifest.transcriptBinsStatus } : {}),\n  };\n}\n"]}

package/esm2022/lib/implementations/tile-server/index.mjs

@@ -0,0 +1,6 @@
+/** Shared jit-service tile client (OSD-PLOTLY-15 / NAPARI-SVC-20). */
+export * from './tile-protocol';
+export * from './transport';
+export * from './poll-descriptor';
+export * from './native-histogram';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2ltcGxlbWVudGF0aW9ucy90aWxlLXNlcnZlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxzRUFBc0U7QUFDdEUsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogU2hhcmVkIGppdC1zZXJ2aWNlIHRpbGUgY2xpZW50IChPU0QtUExPVExZLTE1IC8gTkFQQVJJLVNWQy0yMCkuICovXG5leHBvcnQgKiBmcm9tICcuL3RpbGUtcHJvdG9jb2wnO1xuZXhwb3J0ICogZnJvbSAnLi90cmFuc3BvcnQnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2xsLWRlc2NyaXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9uYXRpdmUtaGlzdG9ncmFtJztcbiJdfQ==

package/esm2022/lib/implementations/tile-server/native-histogram.mjs

@@ -0,0 +1,30 @@
+import { nativeHistogramUrl } from './tile-protocol';
+/** Map the server's HistogramInfo to an {@link IHistogram} with native bin left-edges
+ *  (`rangeMin + i * binWidth`). */
+export function toNativeHistogram(hi) {
+    return {
+        bins: hi.counts.map((_, i) => hi.rangeMin + i * hi.binWidth),
+        counts: hi.counts,
+        max: hi.counts.reduce((m, c) => (c > m ? c : m), 0),
+        bitDepth: hi.bitDepth,
+        rangeMin: hi.rangeMin,
+        rangeMax: hi.rangeMax,
+        observedMin: hi.observedMin,
+        observedMax: hi.observedMax,
+    };
+}
+/**
+ * One channel's native-bit-depth histogram from `GET /histogram` (>8-bit images: the 8-bit display
+ * tiles cannot carry 16-bit values). The URL carries the per-app-load cache-buster.
+ *
+ * Resolves null when the server has no answer yet (202 while caching, or another status, or no
+ * counts) — the caller's pane retries. Transport failures propagate, so each backend keeps its
+ * own tagged catch; caching is the caller's too.
+ */
+export async function nativeHistogram(fetchJson, api, infoB64, req, signal) {
+    const resp = await fetchJson(nativeHistogramUrl(api, infoB64, req), signal);
+    if (resp.status !== 200 || !resp.body?.counts)
+        return null;
+    return toNativeHistogram(resp.body);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/tile-server/poll-descriptor.mjs

@@ -0,0 +1,65 @@
+import { abortError, abortableDelay, timeoutSignal } from './transport';
+/** Default per-request timeout of {@link pollDescriptor}. */
+export const DESCRIPTOR_REQUEST_TIMEOUT_MS = 45000;
+/**
+ * Poll `GET /tiles/info` until the server describes the source.
+ *
+ * The server answers 202 while it is still caching the source (GCS → PVC, which can take minutes
+ * for a cold whole-slide image) and 200 with the descriptor once ready. So:
+ *  - **202** → wait `intervalMs` and poll again, until `deadlineMs`;
+ *  - **200 with levels** → the descriptor;
+ *  - **any other status**, or a 200 without levels → `null` at once: this server will not describe
+ *    the source, and polling it for minutes only delays the caller's fallback (NAPARI-SVC-3);
+ *  - a **transport failure** (network error, per-request timeout) → retried like a 202: a large
+ *    image always passes through a busy window, and one bad poll must not abandon it;
+ *  - the **deadline** passing → `null`.
+ *
+ * The first request is issued synchronously, before the returned promise first awaits. Rejects
+ * with an `AbortError` as soon as `signal` aborts (between polls, or mid-request when the
+ * transport honours the signal).
+ *
+ * These are the napari-js backend's hardened semantics; the OpenSeadragon backend used to throw on
+ * the deadline and to retry every error status. It now shares this answer and turns `null` into
+ * its own load failure (see `OpenSeadragonVisualizerService.load`).
+ */
+export async function pollDescriptor(fetchJson, url, opts) {
+    const { signal } = opts;
+    const tag = opts.tag ?? '[tiles]';
+    const requestTimeoutMs = opts.requestTimeoutMs ?? DESCRIPTOR_REQUEST_TIMEOUT_MS;
+    const deadline = Date.now() + opts.deadlineMs;
+    for (;;) {
+        if (signal?.aborted)
+            throw abortError();
+        const req = timeoutSignal(signal, requestTimeoutMs);
+        try {
+            const resp = await fetchJson(url, req.signal);
+            if (signal?.aborted)
+                throw abortError();
+            if (resp.status === 200) {
+                if (resp.body?.levels?.length)
+                    return resp.body;
+                console.warn(`${tag} tiles/info answered without levels`);
+                return null;
+            }
+            if (resp.status !== 202) {
+                console.warn(`${tag} tiles/info → ${resp.status}`);
+                return null;
+            }
+            // 202: still caching → re-poll until the deadline.
+        }
+        catch (err) {
+            if (signal?.aborted)
+                throw abortError();
+            console.warn(`${tag} tiles/info poll retry`, err);
+        }
+        finally {
+            req.done();
+        }
+        if (Date.now() > deadline) {
+            console.warn(`${tag} tiles/info not ready before the deadline — file still caching`);
+            return null;
+        }
+        await abortableDelay(opts.intervalMs, signal);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/tile-server/tile-protocol.mjs

@@ -0,0 +1,42 @@
+/**
+ * The jit-service tile protocol, shared by the OpenSeadragon and napari-js backends: the
+ * `/tiles/info` descriptor, and the URLs of `/tiles/info`, `/tile`, `/histogram` and
+ * `/export/tiff`. Each URL shape lives here once — the backends used to string-build them
+ * separately and had already drifted (napari's `/histogram` lacked the cache-buster).
+ */
+/** The `/tiles/info` descriptor URL for one source. */
+export function tilesInfoUrl(api, infoB64) {
+    return `${api}tiles/info?info=${infoB64}`;
+}
+/** Build the `/tile` request URL — the one place its query shape lives (the
+ *  server caches on the exact parameter order). */
+export function buildTileUrl(api, infoB64, c) {
+    const ch = c.channel == null ? '' : `&channel=${c.channel}`;
+    return `${api}tile?info=${infoB64}&res=${c.res}&col=${c.col}&row=${c.row}&z=${c.z}&tileSize=${c.tileSize}${ch}`;
+}
+/**
+ * Per-app-load cache-buster for `/histogram`. The server marks the response
+ * cacheable for 24 h, and a hard refresh can't bust a post-load XHR. A token
+ * stable within a session (so the backends' in-session caches still dedupe) but
+ * new on each full load always reflects the live backend after a reload.
+ */
+export const HISTOGRAM_CACHE_BUSTER = Date.now();
+/** The `/histogram` URL, with the cache-buster (see {@link HISTOGRAM_CACHE_BUSTER}). */
+export function nativeHistogramUrl(api, infoB64, r, cacheBuster = HISTOGRAM_CACHE_BUSTER) {
+    return `${api}histogram?info=${infoB64}&channel=${r.channel}&z=${r.z}&bins=${r.bins}&_=${cacheBuster}`;
+}
+/**
+ * The `/export/tiff` URL for slice `z`. `visible` are the channel indices to
+ * export; the `channels` param is omitted when every one of the `channelCount`
+ * channels is visible (or none is), which is the server default (all).
+ */
+export function exportTiffUrl(api, infoB64, z, visible, channelCount) {
+    const ch = visible.length && visible.length < channelCount ? `&channels=${visible.join(',')}` : '';
+    return `${api}export/tiff?info=${infoB64}&z=${z}${ch}`;
+}
+/** The saved name of a native-bit-depth TIFF export of `fileName`. */
+export function exportTiffFilename(fileName) {
+    const stem = (fileName || 'image').replace(/\.[^.]+$/, '');
+    return `${stem}_16bit.ome.tif`;
+}
+//# sourceMappingURL=data:application/json;base64,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