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

package/README.md

@@ -83,7 +83,7 @@ full walkthrough (adapters, TIFF handling, the Angular-17 toolchain note).
   one `IVisualizer` contract; the host picks per plot type via `RoutingVisualizerService`.
 - **Plot types** — Image (OSD), Plotly (Heatmap, Contour, Scatter 2D, Surface 3D,
   Scatter 3D, Isosurface), and napari · WebGPU (Image, Scatter 2D, Surface,
-  Scatter 3D, Volume, Isosurface).
+  Scatter 3D, Volume, Isosurface, **Spatial omics**, **Spatial omics 3D**).
 - **Region / annotation tools** — selection, rectangle, polyline, freeform,
   polygon + vertex editing, move, Bézier↔polygon, magic wand, brush, vertex eraser.
 - **Channels & histogram** — brightness/contrast/gamma, per-channel display,
@@ -143,7 +143,8 @@ data as you zoom in:
 ### napari-js — WebGPU
 GPU-accelerated renderings via [napari-js](https://www.npmjs.com/package/napari-js)
 (WebGPU), selectable from the plot-type menu as the "napari · WebGPU" variants of
-Image, Scatter 2D, Surface, Scatter 3D, **Volume**, and **Isosurface**. It
+Image, Scatter 2D, Surface, Scatter 3D, **Volume**, **Isosurface**, and the two
+spatial-omics modes ([below](#spatial-omics)). It
 assembles the volume from the slice endpoints with a runtime **decimate factor**
 (resolution slider, default ½), a surface **wireframe** toggle, a 3D **axes / scale
 gizmo**, an in-view **Z-height drag handle** for the volume, **cancellable** loading,
@@ -151,8 +152,16 @@ and **multichannel volume** compositing (one additive tinted layer per channel).
 Regions and display options stay in sync with the other backends via the shared
 stores.
 
-When a stack is open, a slice slider (Image view) or single-image/stack toggle
-(other views) navigates the z-dimension. A stack may be one server-tiled file
+Volume and Isosurface take their voxels from the **image stack**, and only from
+it — there is one voxel path, so a dataset reaches those modes by being a stack.
+A stack that declares its slice spacing (`imageMeta[0].mppZ`, alongside
+`mppX`/`mppY`) is rendered at its **true physical extent**, so 40 × 40 × 200 µm
+voxels read as anatomy rather than as a cube-aspect brick, and the axis labels
+read in real units on all three axes. Without it the world box is
+resolution-invariant but shape-only, and Z is labelled in slices.
+
+When a stack is open, a slice slider (Image view, and the 2D Spatial omics view)
+or single-image/stack toggle (other views) navigates the z-dimension. A stack may be one server-tiled file
 (internal z) or a set of self-contained per-slice URLs (`IImageInfo.tiled ===
 false`) — the latter (e.g. a host-assembled folder of numbered files) fetches
 `urls[z]` per slice on demand. For a per-slice stack the host can also supply a
@@ -164,6 +173,187 @@ A line-ROI tool draws coloured lines and plots intensity along each one in a liv
 floating inset chart that re-samples at the current zoom. It works today but the
 API/UX are still stabilizing (see [In progress / roadmap](#in-progress--roadmap)).
 
+## Spatial omics
+
+Contracts for **spatial-omics datasets**: N observations (Visium spots,
+segmented cells) positioned in a tissue image's pixel space, each carrying
+categorical and continuous annotations plus a lazily-fetched feature (gene)
+matrix.
+
+```ts
+import {
+  SPATIAL_DATA_PORT, SpatialDataHttpService, SpatialDataset,
+} from '@jax-data-science/sci-image-visualizer';
+
+providers: [
+  SpatialDataHttpService,
+  { provide: SPATIAL_DATA_PORT, useExisting: SpatialDataHttpService },
+]
+```
+
+Like `TILE_ACCESS_PORT`, this is a **port**: the library consumes typed arrays
+and never learns how the data is stored. `SpatialDataHttpService` is an optional
+reference adapter for the format the bundled example server speaks; a host with
+its own backend implements `SpatialDataPort` instead and imports neither.
+
+Two properties the design turns on:
+
+- **Metadata is eager, values are lazy.** A `SpatialDataset` holds coordinates
+  plus column and feature *descriptors*; vectors arrive one at a time, for the
+  one column or gene being displayed. A Visium table is ~31k genes wide — the
+  dense matrix is ~800 MB — so loading a dataset can never mean loading its
+  matrix.
+- **Struct-of-arrays, not object-per-cell.** Datasets run 10³ (Visium) to 10⁶
+  (Xenium/CosMx) observations; two `Float32Array`s beat 500k `{x, y}` objects
+  and upload to the GPU without a copy.
+
+Once a dataset is published, the spatial plot types appear in the selector (and
+disappear when it is cleared — the same gating that hides Volume without a
+z-stack):
+
+- **Spatial omics** — one marker per observation over the tissue image the
+  coordinates live in, positioned through `imageRef`'s affine.
+- **Spatial omics 3D** — gated additionally on the observations carrying a `z`
+  (`requiresSpatial3d`): the same observations as a point cloud under an orbit
+  camera, inside the dataset's reference volume if it has one.
+
+**A dataset whose 3D data is one file gets an image made from it.** A registered
+volume (`SpatialDataset.volume` + `SpatialDataPort.getVolume()`) is published *as*
+a grayscale z-stack image — one plane per slice, opened mid-volume — so the whole
+image surface applies to it: the toolbar slice slider, the contrast window,
+colormaps, the region tools, the physical scale bar, and Volume / Isosurface
+through the ordinary stack path. In the 2D mode the displayed plane then draws
+**that plane's** observations over that plane's anatomy, in the volume's own pixel
+grid, and a region drawn there selects that plane's cells rather than the whole
+depth behind them.
+
+**Cluster density volumes** *(3D mode, optional)* — a checkbox that raymarches
+each cluster as a smooth density field beside the cloud, tinted with its legend
+colour and blended additively. Serial sections hundreds of microns apart cannot be
+read as an anatomical distribution from points alone: the eye will not integrate a
+stack of discs into a shape, and every gap between sections reads as absence.
+Individual cells are never interpolated — consecutive sections sample different
+cells, so there is nothing to interpolate along — but a density *field* is an
+estimate legitimately defined between the imaged planes, and it renders as a
+translucent cloud so it cannot be mistaken for measurement. The kernel is
+anisotropic (σ along z clears one section gap) and the field is coverage-normalised
+along z, so unimaged planes do not read as empty tissue.
+
+In **3D** the same `Gene map` checkbox draws one field per imaged section, at its
+own depth, with the gaps between sections empty — the measured slides, stacked.
+`One map section at a time` isolates a single sheet (its own control, separate from
+the cloud's, so every combination stays reachable), and `Volume rendering
+(interpolate along z)` smooths the sheets into a continuous volume. The last is a
+different object and the panel labels it as one: the planes between sections then
+carry an estimate smoothed from their neighbours' mean, nothing is drawn past the
+outermost section, and the section restriction is ignored because a volume built
+from one slide would smear it through the whole specimen. It is estimated on the
+reference volume's lattice — coarsened in-plane but never along z, so one plane is
+one section — and shares the 2D map's bandwidth, window and colormap.
+
+**Show** *(3D mode)* — the reference volume, the observation cloud and the cluster
+density volumes share one space, so any two of them hide each other; 374k points
+drawn as a stack of discs hide the density volumes almost entirely. Each is
+toggled independently, so every combination is reachable — the estimated fields
+alone, the fields with the anatomy behind them, the anatomy on its own. These are
+visibility only: the layers stay built, so a toggle never re-fetches the template
+or re-rasterises a field, and none of them re-frames the orbit camera. (The
+density checkbox is the exception and still gates construction, since building six
+volumes is not free.) **Volume opacity** is the backdrop's own slider, separate
+from the markers': reading the cloud or a density field *through* the anatomy
+means turning the anatomy down, not the data over it. **One section at a time** restricts the cloud to a single
+imaged section, which is how you check whether the estimated field follows the
+cells that were actually measured. Sections are the distinct z of the
+observations — every cell on a slide shares that slide's registered z, so no
+section-label column is needed — and a dataset whose z is continuous rather than
+sectioned is offered no section control instead of having one invented for it.
+
+**Hover and click** — hovering an observation names it in a cursor tooltip: the
+class for a categorical column, the value with its unit for a gene or numeric one,
+and nothing at all when no colour source is set (there is no cluster to name).
+Clicking a marker selects that whole class, the same selection the legend's rows
+produce, and clicking it again clears. Because a click means "select" here,
+napari's click-to-zoom is off in the spatial modes — the wheel, the zoom buttons
+and the zoom-box tool still zoom. A gene cannot be clicked to select: no set of
+cells "is" a value.
+
+**Colormap** *(continuous colouring)* — the low→high gradient for a gene or a
+numeric column, chosen from the library's own `COLORMAP_OPTIONS` with the same
+swatch previews the image's colormap picker uses. It defaults to following the
+image's colormap (with a Viridis fallback, since a grey measurement over grey
+anatomy cannot be told apart from it), and clearing the picker returns to that.
+One setting drives the markers, both gene maps and the panel's colour bar, so none
+of them can disagree about what a colour means.
+
+**Gene map** *(2D mode, optional, with a gene selected)* — a checkbox that draws
+the selected gene's expression as a smooth field *beneath* the cells. Coloured
+markers answer "which cells express this gene"; they do not answer "where is it
+expressed", because the eye cannot integrate thousands of small dots into a
+territory. The field is the kernel-weighted **mean per cell, not a sum** — a sum
+would make a crowded region glow whatever its cells were doing — and smoothing the
+numerator and denominator together spreads *where*, not *how much*. That
+denominator is also what lets the layer say nothing: where no cell was measured the
+mean is undefined rather than zero, so those pixels stay fully transparent instead
+of taking the colormap's low end, and alpha ramps with local support so a thinly
+sampled pixel reads as tentative. `Smoothing` sets the kernel σ; `Map opacity` is
+the field's own opacity, separate from the markers' — turn the markers down to read
+the field under them. On a volume-backed dataset the field is re-estimated per
+plane from that plane's cells.
+
+Colour it through `getSpatialControls()`:
+
+```ts
+const controls = viz.getSpatialControls();   // null unless a port is bound
+controls?.colorByColumn('region');           // categorical -> the column's palette
+controls?.colorByFeature('Ttr');             // gene -> colormap, log, percentile-clipped
+controls?.setViewState({ pointScale: 2 });
+```
+
+The view state lives in the shared store, so the controls work before any
+backend has mounted and survive a plot-type switch.
+
+The [example server](examples/tile-server/README.md#spatial-omics-endpoints)
+implements the endpoints, and `npm run make-spatial-demo` generates a synthetic
+Visium-geometry dataset **and a matching tissue image** so the
+[browser example](examples/browser-image/README.md#spatial-omics-demo) runs the
+whole path with no download. A converter for real SpatialData Zarr stores ships
+alongside it.
+
+A **Spatial omics** controls panel (`<spatial-controls>`, opened from the
+toolbar) drives all of this from the UI: a column dropdown, a gene search over
+the feature panel, a legend for categorical colourings and a colour bar for
+continuous ones, plus point-size, opacity, log-scale and outlier-clip controls.
+Its legend swatches and colour bar are built with the same functions the
+renderer uses, so the key cannot drift from the canvas.
+
+**Selection** reuses the region tools you already have: draw a rectangle,
+polygon, freehand shape, wand or brush region, then *Select from ROIs* selects
+every observation inside their union and mutes the rest. Legend rows select
+their category on click.
+
+**Linked distributions** sit in the same panel, below the colour controls, over
+whatever the map is coloured by: histogram, violin or box for a continuous column
+or a gene, and per-category **counts** for a categorical one — a histogram of a
+category code would be meaningless, but "how many cells per class" is the question
+the legend implies and never answers. Violin and box are splittable by a
+categorical column. One dialog on purpose — changing the gene
+and watching the distribution move is a single action. They follow the selection: the histogram
+overlays *Selected* on the full distribution, violin and box narrow to it. The
+chart's subject is the map's colour source rather than an independent picker, so
+the two cannot disagree about what is being shown.
+
+Categorical colouring has one renderer-specific limit worth knowing: the 3D
+points layer maps a per-point scalar through a 256-entry LUT, which keeps 96
+blocks apart exactly — one of them reserved for a missing value, so **95
+categories** fit — and above that the cloud draws flat and the panel says so.
+The 2D markers (per-point RGBA) and the density volumes (a scalar field per
+cluster) have no such limit — which is why the example server serves `subclass`
+(338) even though the cloud cannot colour by it.
+
+Still to build: hover tooltips, chart → map brushing, and a GPU layer for cell
+boundary polygons (they are served, not yet drawn) — see
+[docs/spatial-omics-plot-mode-design.md](docs/spatial-omics-plot-mode-design.md).
+
 ## Regions & annotation
 
 Regions are stored in a shared **region store** and use a GeoJSON-friendly model
@@ -241,11 +431,11 @@ once per image; the decoder runs per prompt). The registry lives in
 
 | Picker id | Domain | Encoder | Runs on | HF model |
 |---|---|---|---|---|
-| `microsam-vit-t-lm` *(default)* | light microscopy | TinyViT, ~14 MB fp16 | WASM¹ | [Ballon999/microsam-vit-t-lm-onnx](https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx) |
-| `microsam-vit-b-lm` | light microscopy | ViT-B, ~172 MB fp16 | WebGPU | [Ballon999/microsam-vit-b-lm-onnx](https://huggingface.co/Ballon999/microsam-vit-b-lm-onnx) |
-| `patho-sam-vit-b` | histopathology (H&E) | ViT-B, ~172 MB fp16 | WebGPU | [Ballon999/patho-sam-vit-b-onnx](https://huggingface.co/Ballon999/patho-sam-vit-b-onnx) |
-| `patho-sam-vit-b-int8` | histopathology (H&E) | ViT-B, ~100 MB int8 | WASM | [Ballon999/patho-sam-vit-b-onnx](https://huggingface.co/Ballon999/patho-sam-vit-b-onnx) (`encoder.int8.onnx`) |
-| cellpose-SAM *(automatic)* | cells (generalist) | SAM ViT + flow head | WebGPU/WASM | [ballon999/cellpose-sam-onnx](https://huggingface.co/ballon999/cellpose-sam-onnx) |
+| `microsam-vit-t-lm` *(default)* | light microscopy | TinyViT, ~14 MB fp16 | WASM¹ | [jax-image-tools/microsam-vit-t-lm-onnx](https://huggingface.co/jax-image-tools/microsam-vit-t-lm-onnx) |
+| `microsam-vit-b-lm` | light microscopy | ViT-B, ~172 MB fp16 | WebGPU | [jax-image-tools/microsam-vit-b-lm-onnx](https://huggingface.co/jax-image-tools/microsam-vit-b-lm-onnx) |
+| `patho-sam-vit-b` | histopathology (H&E) | ViT-B, ~172 MB fp16 | WebGPU | [jax-image-tools/patho-sam-vit-b-onnx](https://huggingface.co/jax-image-tools/patho-sam-vit-b-onnx) |
+| `patho-sam-vit-b-int8` | histopathology (H&E) | ViT-B, ~100 MB int8 | WASM | [jax-image-tools/patho-sam-vit-b-onnx](https://huggingface.co/jax-image-tools/patho-sam-vit-b-onnx) (`encoder.int8.onnx`) |
+| cellpose-SAM *(automatic)* | cells (generalist) | SAM ViT + flow head | WebGPU/WASM | [jax-image-tools/cellpose-sam-onnx](https://huggingface.co/jax-image-tools/cellpose-sam-onnx) |
 
 ¹ TinyViT's fp16 attention overflows on the onnxruntime-web WebGPU EP (returns an
 empty mask); it is numerically correct and fast on WASM, so its encoder is pinned
@@ -270,6 +460,16 @@ Work that is landed-but-unstable or planned (not yet available):
   and browser-side SAM/cellpose segmentation) against sample images — so the
   library can be evaluated and developed standalone, outside jit-ui. Tracked in
   the library-extraction SOW ([docs/JIT_UI_visualization_library_SOW.docx](docs/JIT_UI_visualization_library_SOW.docx)).
+- **Spatial-omics follow-ons** *(planned — the modes themselves shipped in
+  0.4.0, see [Spatial omics](#spatial-omics))* — hover tooltips over
+  observations, brushing a chart selection back onto the map, and a GPU shapes
+  layer for cell-boundary polygons (the example server serves them; nothing draws
+  them yet, since a DOM overlay will not hold 10⁴–10⁵ outlines). The GPU layer is
+  measured as feasible — generating the geometry in a compute pass is bit-exact
+  and ~16× faster than JS, and 10⁵–10⁶ outlines draw in single-digit
+  milliseconds; the constraint is napari-js's closed renderer, not WebGPU. See
+  [.planning/research/cell-boundary-polygons-webgpu.md](.planning/research/cell-boundary-polygons-webgpu.md)
+  and [docs/spatial-omics-plot-mode-design.md](docs/spatial-omics-plot-mode-design.md).
 - **SAM 3 model** *(planned)* — a `variant: 'sam3'` decoder path + export tooling
   (SAM 2/3 use a different mask I/O than the current SAM-v1 path). See
   [docs/sam-segmentation-design.md](docs/sam-segmentation-design.md).
@@ -284,6 +484,10 @@ Design, architecture, and planning docs for the library:
 - **[docs/sam-segmentation-design.md](docs/sam-segmentation-design.md)** — design of
   the browser SAM segmentation: model choice, ONNX export/quantization recipe,
   encoder/decoder I/O, the engine/session architecture, and the rollout phases.
+- **[docs/spatial-omics-plot-mode-design.md](docs/spatial-omics-plot-mode-design.md)** —
+  design and phased plan for the spatial-omics plot mode: current-state audit,
+  what the CosMx / Spatial-Live / SpatialData references contribute, the data
+  plane, MoSCoW requirements, and the open questions still to settle.
 - **Architecture diagrams**
   - [docs/jit-ui-visualization-architecture.mmd](docs/jit-ui-visualization-architecture.mmd)
     ([PNG](docs/img/jit-ui-visualization-architecture.png) ·
@@ -366,8 +570,8 @@ cellpose adapter). Configure hosted SAM model URLs once at startup:
 import { setSamModelUrls } from '@jax-data-science/sci-image-visualizer';
 
 setSamModelUrls('microsam-vit-t-lm',
-  'https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx/resolve/main/encoder.fp16.onnx',
-  'https://huggingface.co/Ballon999/microsam-vit-t-lm-onnx/resolve/main/decoder.onnx');
+  'https://huggingface.co/jax-image-tools/microsam-vit-t-lm-onnx/resolve/main/encoder.fp16.onnx',
+  'https://huggingface.co/jax-image-tools/microsam-vit-t-lm-onnx/resolve/main/decoder.onnx');
 ```
 
 `onnxruntime-web` WASM/JSEP sidecars must be served from `/assets/ort/`. See

package/esm2022/index.mjs

@@ -12,6 +12,8 @@ export * from './lib/contracts/ports/image-state.port';
 export * from './lib/contracts/ports/tile-access.port';
 export * from './lib/contracts/ports/region-io.port';
 export * from './lib/contracts/ports/preferences.port';
+export * from './lib/contracts/ports/spatial-data.port';
+export * from './lib/contracts/spatial-dataset.contract';
 export * from './lib/contracts/channel-histogram-api.contract';
 export * from './lib/contracts/viz-config';
 export * from './lib/contracts/image.contract';
@@ -24,6 +26,18 @@ export * from './lib/contracts/display-types';
 export * from './lib/contracts/sam.contract';
 export * from './lib/contracts/cell-segmenter.contract';
 export { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';
+// ── Spatial-omics data plane ─────────────────────────────────────────────
+// The wire format the bundled example server speaks, plus a ready-made
+// SpatialDataPort adapter for it. Both are OPTIONAL: a host with its own
+// backend implements SpatialDataPort directly and imports neither.
+export { SpatialDataHttpService, SupersededError } from './lib/implementations/spatial-data-http/spatial-data-http.service';
+export { SPATIAL_WIRE_VERSION, isLittleEndian, assertManifestVersion, datasetFromManifest, decodeCoords, decodeRadius, decodeColumn, decodeFeatureVector, decodePolygons, } from './lib/implementations/spatial-data-http/spatial-wire';
+// Backend-neutral encodings: columns/genes -> per-point colours and sizes.
+export { encodeCategorical, encodeContinuous, resolveCategoryColors, contrastWindow, markerDiameters, toRgbaTuples, lutFor, DEFAULT_CATEGORICAL_PALETTE, DEFAULT_MUTED_OPACITY, MISSING_COLOR, } from './lib/spatial/spatial-encoding';
+// Selection: which observations fall inside the drawn ROIs, and the shared store
+// that holds the answer.
+export { selectInRegions, selectByCategory, mutedFromSelection, pointInRing, emptySelection, countMask, maskToIndices, } from './lib/spatial/spatial-selection';
+export { SpatialSelectionStore } from './lib/store/spatial-selection.service';
 export * from './lib/contracts/instance-segmenter.contract';
 export * from './lib/contracts/semantic-segmenter.contract';
 // ── Generic client-side image utilities (shared with the host's pipeline) ──
@@ -52,4 +66,9 @@ export { VisualizerComponent } from './lib/visualizer.component';
 export { RegionEditorComponent } from './lib/region-editor/region-editor.component';
 export { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';
 export { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';
-//# sourceMappingURL=data:application/json;base64,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
+export { SpatialControlsComponent, } from './lib/spatial-controls/spatial-controls.component';
+export { SpatialChartsComponent } from './lib/spatial-controls/spatial-charts/spatial-charts.component';
+// Pure chart builders, exported so a host can render the same distributions
+// wherever it likes (a report, a different charting surface).
+export { buildOmicsTraces, omicsLayout, benefitsFromGrouping, } from './lib/implementations/plotly/omics-trace-builders';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Public API of the jax-image-visualization library. External consumers import\n * ONLY from here (`@jax-data-science/sci-image-visualizer`); everything else under `lib/` is\n * internal. The surface is contracts + tokens + neutral models + the Angular\n * module, plus the routing service the host's composition root binds the tokens\n * to (`useExisting`).\n */\n\n// ── Contracts & DI tokens ────────────────────────────────────────────────\nexport * from './lib/contracts/visualizer.contract';\nexport * from './lib/contracts/region-editor-api.contract';\nexport * from './lib/contracts/ports/image-state.port';\nexport * from './lib/contracts/ports/tile-access.port';\nexport * from './lib/contracts/ports/region-io.port';\nexport * from './lib/contracts/ports/preferences.port';\nexport * from './lib/contracts/ports/spatial-data.port';\nexport * from './lib/contracts/spatial-dataset.contract';\nexport * from './lib/contracts/channel-histogram-api.contract';\nexport * from './lib/contracts/viz-config';\nexport * from './lib/contracts/image.contract';\nexport * from './lib/contracts/plot-type';\nexport * from './lib/contracts/toolbar-config';\nexport * from './lib/contracts/toolbar-tool.contract';\nexport * from './lib/contracts/capabilities.contract';\nexport * from './lib/contracts/region-overlay.contract';\nexport * from './lib/contracts/display-types';\nexport * from './lib/contracts/sam.contract';\nexport * from './lib/contracts/cell-segmenter.contract';\nexport { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';\n\n// ── Spatial-omics data plane ─────────────────────────────────────────────\n// The wire format the bundled example server speaks, plus a ready-made\n// SpatialDataPort adapter for it. Both are OPTIONAL: a host with its own\n// backend implements SpatialDataPort directly and imports neither.\nexport { SpatialDataHttpService, SupersededError } from './lib/implementations/spatial-data-http/spatial-data-http.service';\nexport {\n  SPATIAL_WIRE_VERSION, isLittleEndian, assertManifestVersion, datasetFromManifest,\n  decodeCoords, decodeRadius, decodeColumn, decodeFeatureVector, decodePolygons,\n} from './lib/implementations/spatial-data-http/spatial-wire';\nexport type {\n  SpatialManifest, SpatialDatasetSummary, SpatialRadiusSpec,\n} from './lib/implementations/spatial-data-http/spatial-wire';\n// Backend-neutral encodings: columns/genes -> per-point colours and sizes.\nexport {\n  encodeCategorical, encodeContinuous, resolveCategoryColors, contrastWindow,\n  markerDiameters, toRgbaTuples, lutFor,\n  DEFAULT_CATEGORICAL_PALETTE, DEFAULT_MUTED_OPACITY, MISSING_COLOR,\n} from './lib/spatial/spatial-encoding';\nexport type {\n  RGBA, CategoricalEncodingOptions, ContinuousEncodingOptions,\n} from './lib/spatial/spatial-encoding';\n// Selection: which observations fall inside the drawn ROIs, and the shared store\n// that holds the answer.\nexport {\n  selectInRegions, selectByCategory, mutedFromSelection, pointInRing,\n  emptySelection, countMask, maskToIndices,\n} from './lib/spatial/spatial-selection';\nexport type { SpatialSelectionMask } from './lib/spatial/spatial-selection';\nexport { SpatialSelectionStore } from './lib/store/spatial-selection.service';\nexport * from './lib/contracts/instance-segmenter.contract';\nexport * from './lib/contracts/semantic-segmenter.contract';\n\n// ── Generic client-side image utilities (shared with the host's pipeline) ──\nexport { ProcessingImage } from './lib/processing/processing-image';\nexport { cropImage, CropImageOptions } from './lib/processing/image-crop';\nexport { ImageConverterService } from './lib/processing/image-converter.service';\n\n// ── SAM model registry (host configures hosted ONNX URLs once available) ──\nexport {\n  SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls,\n  setDefaultSamModel, getDefaultSamModelId,\n} from './lib/toolbar/segmentation/sam-model-registry';\n\n// ── onnxruntime-web WASM location (host overrides once, at app init) ───────\nexport { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';\n\n// ── Neutral data models ──────────────────────────────────────────────────\nexport * from './lib/models/region';\nexport * from './lib/models/class-preset';\nexport { ShapeSelection } from './lib/models/shape';\n\n// ── Angular module + composition-root service ────────────────────────────\nexport { VisualizationModule } from './lib/visualization.module';\nexport { RoutingVisualizerService } from './lib/routing-visualizer.service';\n// Provider factory for an isolated, component-scoped viewer instance (e.g. a\n// modal that must not share the main viewer's region/image state).\nexport { provideVisualization } from './lib/provide-visualization';\n\n// ── Public components (exported by VisualizationModule) ───────────────────\n// ng-packagr requires module-exported components to be reachable from the\n// entry point so consumers get their types; these are the embeddable elements\n// (`<visualizer>`, `<region-editor>`, `<hex-color-picker>`).\nexport { VisualizerComponent } from './lib/visualizer.component';\nexport { RegionEditorComponent } from './lib/region-editor/region-editor.component';\nexport { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';\nexport { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';\nexport {\n  SpatialControlsComponent,\n} from './lib/spatial-controls/spatial-controls.component';\nexport type { SpatialLegendEntry } from './lib/spatial-controls/spatial-controls.component';\nexport { SpatialChartsComponent } from './lib/spatial-controls/spatial-charts/spatial-charts.component';\n// Pure chart builders, exported so a host can render the same distributions\n// wherever it likes (a report, a different charting surface).\nexport {\n  buildOmicsTraces, omicsLayout, benefitsFromGrouping,\n} from './lib/implementations/plotly/omics-trace-builders';\nexport type {\n  OmicsChartKind, OmicsGrouping, OmicsTraceInput,\n} from './lib/implementations/plotly/omics-trace-builders';\n"]}

package/esm2022/lib/contracts/display-types.mjs

@@ -4,5 +4,23 @@
  * so existing hosts (which pass PrimeNG `TreeNode`s and plain option objects)
  * keep compiling unchanged while consumers finally get named shapes.
  */
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+export const DEFAULT_SPATIAL_VIEW = {
+    colorBy: null,
+    pointScale: 1,
+    opacity: 1,
+    logScale: false,
+    percentileClip: [0.01, 0.99],
+    continuousColormap: null,
+    showVolume: true,
+    volumeOpacity: 0.5,
+    showPoints: true,
+    pointSection: null,
+    densityVolume: false,
+    densitySmoothing: 1,
+    geneMap: false,
+    geneMapSection: null,
+    geneMapVolume: false,
+    geneMapSmoothing: 1,
+    geneMapOpacity: 0.85,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-types.js","sourceRoot":"","sources":["../../../../src/lib/contracts/display-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2KH,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACpD,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,CAAC;IACb,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,KAAK;IACf,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;IAC5B,kBAAkB,EAAE,IAAI;IACxB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,GAAG;IAClB,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,IAAI;IAClB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,OAAO,EAAE,KAAK;IACd,cAAc,EAAE,IAAI;IACpB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,cAAc,EAAE,IAAI;CACrB,CAAC","sourcesContent":["/**\n * Publication-critical types that were `any` on the public contracts\n * (refactoring plan, Step 6). Deliberately permissive — every field optional —\n * so existing hosts (which pass PrimeNG `TreeNode`s and plain option objects)\n * keep compiling unchanged while consumers finally get named shapes.\n */\n\n/** A colormap value as Plotly understands it: a built-in scale name (e.g.\n *  'Viridis') or an inline array of `[stop, color]` pairs. */\nexport type ColormapValue = string | Array<[number, string]>;\n\n/** One node of the colormap selector tree (structurally compatible with the\n *  PrimeNG `TreeNode`s the host passes): group nodes carry `children`, leaf\n *  nodes carry the scale in `data.value` (+ a preview image in `data.src`). */\nexport interface ColormapNode {\n  label?: string;\n  data?: { value?: ColormapValue; src?: string };\n  children?: ColormapNode[];\n}\n\n/** Magic-wand pixel-comparison space. */\nexport type WandType = 'GRAY' | 'RGB' | 'LAB_DISTANCE';\n\n/** Options for the magic-wand tool (QuPath-style). */\nexport interface IWandOptions {\n  type?: WandType;\n  /** Gaussian sigma applied to the patch before thresholding. */\n  sigma?: number;\n  /** Higher = stricter (smaller selection) for GRAY/RGB; higher = looser for\n   *  LAB_DISTANCE — matches QuPath. */\n  sensitivity?: number;\n  /** Square patch size in pixels (must be odd). */\n  patchSize?: number;\n  /** When true, skip blur/threshold and flood-fill at exact-match\n   *  (Cmd/Ctrl-click in QuPath). */\n  simpleMode?: boolean;\n}\n\n/** Options for the brush region tool (QuPath-style). */\nexport interface IBrushOptions {\n  /** Brush diameter in matrix (image) pixels. */\n  size?: number;\n}\n\n/** What drives point colour in the spatial-omics mode: an annotation column\n *  from the dataset, or one feature (gene) vector fetched on demand. */\nexport interface SpatialColorBy {\n  kind: 'column' | 'feature';\n  name: string;\n}\n\n/** Display state for the spatial-omics plot mode. Lives in `VisualizerStore`\n *  alongside the colormap/channel state so the renderer reacts to edits the\n *  same way it does for an image. */\nexport interface SpatialViewState {\n  /** Colour source; `null` renders every observation in one neutral colour\n   *  (useful on its own — it shows where the tissue actually is). */\n  colorBy: SpatialColorBy | null;\n  /** Multiplier on the dataset's physical marker size. 1 = true size, which for\n   *  a 55 µm Visium spot is correct but can be invisible when zoomed out. */\n  pointScale: number;\n  /** Alpha for points that are not muted. */\n  opacity: number;\n  /** Log-scale continuous values before mapping them onto the colormap. Seeded\n   *  from the column's `logScaleHint` — count data needs it. */\n  logScale: boolean;\n  /** Percentile clip for the contrast window as `[lo, hi]` fractions, so a\n   *  handful of saturated observations don't flatten the rest. */\n   percentileClip: [number, number];\n  /**\n   * Colormap for CONTINUOUS spatial colouring — a gene, a numeric column — as a\n   * {@link ColormapValue}, the same shape the display colormap carries: a scale\n   * NAME for the built-ins, or an inline `[stop, colour]` array for the rest.\n   * Null follows the display colormap.\n   *\n   * Its own setting because the display colormap belongs to the tissue image and\n   * is usually a grey ramp, which is the wrong thing to read a measurement\n   * through: grey over grey cannot be told apart from the anatomy. Following it\n   * (with a Viridis fallback for exactly that case) is a reasonable default and a\n   * poor ceiling, since which gradient reads best is a judgement about the data.\n   *\n   * One setting for the markers, the 2D gene map and the 3D gene map together, so\n   * the field under the cells and the cells over it cannot disagree about what a\n   * colour means — and the panel's own colour bar is built from it too.\n   */\n  continuousColormap: ColormapValue | null;\n  /**\n   * What the 3D scene draws. The three things in it — the reference volume, the\n   * observation cloud and the cluster density volumes — occupy the same space, so\n   * any two of them hide each other to some degree. These are independent because\n   * the useful views are the combinations: the volumes alone to read an estimated\n   * distribution, one section's cells over them to check that estimate against the\n   * measurement, the anatomy alone to find a landmark.\n   *\n   * Visibility only — the layers stay built, so toggling one back on is immediate\n   * and does not re-run a rasterisation. {@link densityVolume} is the exception and\n   * genuinely gates construction, because building six volumes is not free.\n   */\n  showVolume: boolean;\n  /**\n   * The reference volume's opacity.\n   *\n   * Its own, not {@link opacity} (which belongs to the markers): the volume is a\n   * BACKDROP, and reading the cloud or a density field through it means turning\n   * the anatomy down without touching the data drawn over it. Ranges lower than\n   * the markers' slider for the same reason — a faint anatomical hint is a useful\n   * setting for a backdrop and a useless one for the measurement.\n   */\n  volumeOpacity: number;\n  /** Draw the observation cloud (3D). */\n  showPoints: boolean;\n  /**\n   * Restrict the cloud to ONE imaged section, by index into the dataset's sampled\n   * sections; null draws every section.\n   *\n   * The whole cloud is a stack of discs that hides whatever is drawn between them.\n   * One section at a time is the view that answers \"does the estimated field\n   * actually follow the cells I measured\" — and it is only offered for data that\n   * really is sectioned (see `sampledSections`).\n   */\n  pointSection: number | null;\n  /**\n   * Draw each cluster as a translucent DENSITY volume alongside the 3D cloud.\n   *\n   * Serial sections hundreds of microns apart make a cloud hard to read as an\n   * anatomical distribution — the eye cannot integrate discs into a shape. A\n   * density field can be estimated between the imaged planes (a continuous\n   * estimate, unlike individual cells, which have no correspondence to\n   * interpolate along) and renders as a cloud that reads as an estimate.\n   */\n  densityVolume: boolean;\n  /** Multiplier on the default kernel bandwidth. Above 1 is smoother and less\n   *  committal; below 1 exposes the individual sections. */\n  densitySmoothing: number;\n  /**\n   * Draw the active GENE as a continuous field under the observations (2D).\n   *\n   * Colouring the markers by a gene says which cells express it; it cannot say\n   * where, because the eye will not integrate thousands of dots into a territory.\n   * The field is an estimate — a kernel-weighted mean per cell, transparent where\n   * no cell was measured — and it is drawn beneath the cells, not instead of them,\n   * so the measurement stays on screen next to the interpolation.\n   *\n   * Ignored unless the colour source is a gene: there is nothing else to map.\n   */\n  geneMap: boolean;\n  /**\n   * Restrict the 3D gene map to ONE imaged section, by index into the dataset's\n   * sampled sections; null draws every section's sheet.\n   *\n   * Separate from {@link pointSection} so the combinations stay open: all the\n   * sheets with one section's cells over them is a useful view, and so is one\n   * sheet inside the whole cloud. Ignored while {@link geneMapVolume} is set —\n   * interpolating a single section along z would smear one slide through the\n   * specimen's whole depth and call it an estimate.\n   */\n  geneMapSection: number | null;\n  /**\n   * Smooth the per-section gene maps along z into a continuous VOLUME (3D).\n   *\n   * The sheets are what was measured — one field per imaged slide, with the gaps\n   * between them empty. This turns them into an estimate defined between the\n   * slides, the same move the cluster density volumes make and with the same\n   * caveat: a field may be interpolated between sections, individual cells may\n   * not, and the result is drawn as a translucent cloud so it cannot be mistaken\n   * for measurement.\n   */\n  geneMapVolume: boolean;\n  /** Multiplier on the gene map's kernel bandwidth. */\n  geneMapSmoothing: number;\n  /** The gene map's own opacity. Separate from {@link opacity}, which belongs to\n   *  the markers: turning the cells down to read the field underneath must not\n   *  turn the field down with them. */\n  geneMapOpacity: number;\n}\n\nexport const DEFAULT_SPATIAL_VIEW: SpatialViewState = {\n  colorBy: null,\n  pointScale: 1,\n  opacity: 1,\n  logScale: false,\n  percentileClip: [0.01, 0.99],\n  continuousColormap: null,\n  showVolume: true,\n  volumeOpacity: 0.5,\n  showPoints: true,\n  pointSection: null,\n  densityVolume: false,\n  densitySmoothing: 1,\n  geneMap: false,\n  geneMapSection: null,\n  geneMapVolume: false,\n  geneMapSmoothing: 1,\n  geneMapOpacity: 0.85,\n};\n"]}

package/esm2022/lib/contracts/image.contract.mjs

@@ -8,4 +8,4 @@
  * structurally, so the host keeps passing its own instances unchanged.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/contracts/plot-type.mjs

@@ -34,6 +34,15 @@ export var PlotType;
     PlotType["NAPARI_SCATTER"] = "napari-scatter";
     /** WebGPU 3D scatter of the downsampled voxel cloud (napari-js analog of Plotly SCATTER3D). */
     PlotType["NAPARI_SCATTER3D"] = "napari-scatter3d";
+    /** Spatial-omics observations (Visium spots, segmented cells) drawn over the tissue image and
+     *  coloured by an annotation column or a gene. Needs a `SpatialDataset` on `SPATIAL_DATA_PORT`,
+     *  so it is gated by `requiresSpatialData` and never appears for an image-only host. */
+    PlotType["SPATIAL_OMICS"] = "spatial-omics";
+    /** Spatial-omics observations as a 3D point cloud, for assays whose observations carry a z —
+     *  serial sections registered into a common frame (e.g. the Allen CCF), or a genuinely
+     *  volumetric assay. Gated by `requiresSpatial3d`, a strictly narrower gate than
+     *  {@link SPATIAL_OMICS}: a single-plane dataset has no z to render. */
+    PlotType["SPATIAL_OMICS_3D"] = "spatial-omics-3d";
 })(PlotType || (PlotType = {}));
 /**
  * Single source of truth for plot-type metadata. LINE is intentionally absent —
@@ -66,6 +75,9 @@ export const PLOT_TYPE_DESCRIPTORS = {
     [PlotType.NAPARI_SCATTER3D]: { type: PlotType.NAPARI_SCATTER3D, label: 'Scatter 3D (napari · WebGPU)', icon: 'assets/plotting/3d-coordinates.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },
     [PlotType.NAPARI_VOLUME]: { type: PlotType.NAPARI_VOLUME, label: 'Volume (napari · WebGPU)', productionLabel: 'Volume', icon: 'assets/plotting/cube-3d.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },
     [PlotType.NAPARI_ISOSURFACE]: { type: PlotType.NAPARI_ISOSURFACE, label: 'Isosurface (napari · WebGPU)', productionLabel: 'Isosurface', icon: 'assets/plotting/isosurface.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },
+    // ── Spatial omics ──
+    [PlotType.SPATIAL_OMICS]: { type: PlotType.SPATIAL_OMICS, label: 'Spatial omics (napari · WebGPU)', productionLabel: 'Spatial omics', icon: 'assets/plotting/spatial-omics.svg', dimensions: '2d', source: 'spatial', requiresSpatialData: true },
+    [PlotType.SPATIAL_OMICS_3D]: { type: PlotType.SPATIAL_OMICS_3D, label: 'Spatial omics 3D (napari · WebGPU)', productionLabel: 'Spatial omics 3D', icon: 'assets/plotting/spatial-omics-3d.svg', dimensions: '3d', source: 'spatial', requiresSpatialData: true, requiresSpatial3d: true },
 };
 export function getPlotTypeDescriptor(type) {
     return PLOT_TYPE_DESCRIPTORS[type];
@@ -94,6 +106,29 @@ export function isNapariScatter(type) {
 export function isNapariScatter3d(type) {
     return type === PlotType.NAPARI_SCATTER3D;
 }
+/** Spatial-omics observations over the tissue image. */
+export function isSpatialOmics(type) {
+    return type === PlotType.SPATIAL_OMICS;
+}
+/** Spatial-omics observations as a 3D point cloud. */
+export function isSpatialOmics3d(type) {
+    return type === PlotType.SPATIAL_OMICS_3D;
+}
+/**
+ * Whether the renderer, rather than the shell, should handle wheel zoom.
+ *
+ * The shell's wheel listener applies a FIXED step per event, which is far too sensitive for a
+ * renderer that reads the scroll delta: it works out at 30% per event against napari-js's 3%, and
+ * ignores the device normalization and easing the renderer does. So every plot type drawn by a
+ * renderer that owns the wheel has to opt out here.
+ *
+ * The image view always did. The spatial-omics modes did NOT, despite being drawn by the same
+ * napari-js viewer — the shell gated on an `isHeatmap` flag that defaults to true and only goes
+ * false for the 3D Plotly scenes, so it silently took the wheel for them too.
+ */
+export function rendererOwnsWheel(type) {
+    return type === PlotType.IMAGE || isSpatialOmics(type) || isSpatialOmics3d(type);
+}
 /** Any napari-js 3D plot type (volume, isosurface, surface, or 3D scatter). Resolution is a runtime
  *  decimate factor (Full / ½ / ¼ / ⅛) — see the service's `resolutionScale`. */
 export function isNapari3d(type) {
@@ -109,4 +144,4 @@ export const NAPARI_DECIMATE_OPTIONS = [
 /** Default decimate factor: ¼. The caps are set so ¼ is a sensible default resolution while ½ and
  *  Full offer 2× and 4× the detail for opt-in high-resolution renders. */
 export const NAPARI_DEFAULT_DECIMATE = 4;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-type.js","sourceRoot":"","sources":["../../../../src/lib/contracts/plot-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAN,IAAY,QAuBX;AAvBD,WAAY,QAAQ;IAClB;iFAC6E;IAC7E,2BAAe,CAAA;IACf,+BAAmB,CAAA;IACnB,+BAAmB,CAAA;IACnB,+BAAmB,CAAA;IACnB,+BAAmB,CAAA;IACnB,yFAAyF;IACzF,yBAAa,CAAA;IACb,mCAAuB,CAAA;IACvB,qCAAyB,CAAA;IACzB;uGACmG;IACnG,yCAA6B,CAAA;IAC7B,2CAA+B,CAAA;IAC/B,mDAAuC,CAAA;IACvC,gGAAgG;IAChG,6CAAiC,CAAA;IACjC,kFAAkF;IAClF,6CAAiC,CAAA;IACjC,+FAA+F;IAC/F,iDAAqC,CAAA;AACvC,CAAC,EAvBW,QAAQ,KAAR,QAAQ,QAuBnB;AAgDD;;;;;GAKG;AACH,+FAA+F;AAC/F,oDAAoD;AACpD,kFAAkF;AAClF,iFAAiF;AACjF,mEAAmE;AACnE,2EAA2E;AAC3E,sEAAsE;AACtE,4EAA4E;AAC5E,MAAM,CAAC,MAAM,qBAAqB,GAAkD;IAClF,gBAAgB;IAChB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAO,KAAK,EAAE,aAAa,EAAY,eAAe,EAAE,OAAO,EAAO,IAAI,EAAE,aAAa,EAAqB,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IAC9L,eAAe;IACf,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAK,KAAK,EAAE,kBAAkB,EAAO,eAAe,EAAE,SAAS,EAAK,IAAI,EAAE,6BAA6B,EAAK,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IAC9L,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAK,KAAK,EAAE,kBAAkB,EAAO,eAAe,EAAE,SAAS,EAAK,IAAI,EAAE,6BAA6B,EAAK,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE;IACvN,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAK,KAAK,EAAE,qBAAqB,EAAI,IAAI,EAAE,qBAAqB,EAAa,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE;IACjK,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAK,KAAK,EAAE,kBAAkB,EAAO,IAAI,EAAE,6BAA6B,EAAK,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE;IACxL,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAG,KAAK,EAAE,qBAAqB,EAAI,IAAI,EAAE,oCAAoC,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE;IACjN,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,qBAAqB,EAAI,IAAI,EAAE,gCAAgC,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE;IAC7M,oFAAoF;IACpF,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,YAAY,EAAO,KAAK,EAAE,yBAAyB,EAAO,IAAI,EAAE,aAAa,EAAyB,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;IACxL,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,cAAc,EAAK,KAAK,EAAE,8BAA8B,EAAE,IAAI,EAAE,qBAAqB,EAAiB,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE;IAC1L,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,cAAc,EAAK,KAAK,EAAE,2BAA2B,EAAK,eAAe,EAAE,SAAS,EAAK,IAAI,EAAE,6BAA6B,EAAS,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,kHAAkH;IAC3U,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,gBAAgB,EAAG,KAAK,EAAE,8BAA8B,EAAE,IAAI,EAAE,oCAAoC,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE;IACtO,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,aAAa,EAAM,KAAK,EAAE,0BAA0B,EAAM,eAAe,EAAE,QAAQ,EAAM,IAAI,EAAE,6BAA6B,EAAS,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE;IACrQ,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,iBAAiB,EAAE,KAAK,EAAE,8BAA8B,EAAE,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,gCAAgC,EAAM,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE;CACtQ,CAAC;AAEF,MAAM,UAAU,qBAAqB,CAAC,IAAc;IAClD,OAAO,qBAAqB,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,IAAc;IAC/C,OAAO,qBAAqB,CAAC,IAAI,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;AAC1D,CAAC;AAED,gFAAgF;AAChF,wBAAwB;AACxB,MAAM,UAAU,cAAc,CAAC,IAAc;IAC3C,OAAO,IAAI,KAAK,QAAQ,CAAC,aAAa,CAAC;AACzC,CAAC;AACD,4BAA4B;AAC5B,MAAM,UAAU,kBAAkB,CAAC,IAAc;IAC/C,OAAO,IAAI,KAAK,QAAQ,CAAC,iBAAiB,CAAC;AAC7C,CAAC;AACD,2CAA2C;AAC3C,MAAM,UAAU,eAAe,CAAC,IAAc;IAC5C,OAAO,IAAI,KAAK,QAAQ,CAAC,cAAc,CAAC;AAC1C,CAAC;AACD,+CAA+C;AAC/C,MAAM,UAAU,eAAe,CAAC,IAAc;IAC5C,OAAO,IAAI,KAAK,QAAQ,CAAC,cAAc,CAAC;AAC1C,CAAC;AACD,gDAAgD;AAChD,MAAM,UAAU,iBAAiB,CAAC,IAAc;IAC9C,OAAO,IAAI,KAAK,QAAQ,CAAC,gBAAgB,CAAC;AAC5C,CAAC;AACD;gFACgF;AAChF,MAAM,UAAU,UAAU,CAAC,IAAc;IACvC,OAAO,CACL,cAAc,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,IAAI,CAAC,CACrG,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,MAAM,CAAC,MAAM,uBAAuB,GAAuC;IACzE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE;IAC3B,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE;IACxB,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE;IACxB,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE;CACzB,CAAC;AAEF;0EAC0E;AAC1E,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC","sourcesContent":["/**\n * The kind of rendering a viewer backend should produce for the loaded data.\n *\n * Lives in `contracts/` (rather than inside a specific backend) because it is\n * part of the backend-neutral plotting contract: both the Plotly backend and\n * any future backend (e.g. OpenSeadragon) accept a `PlotType` on `plot()`.\n *\n * NOTE: a backend may not support every type — 3D types (`SURFACE`,\n * `SCATTER3D`, `ISOSURFACE`) are gated behind `ViewerFeature.Surface3D` in the\n * capabilities contract, so a 2D-only backend can advertise that it can't\n * render them and the UI can hide the option.\n */\nexport enum PlotType {\n  /** Natively-tiled, zoomable raster rendered by OpenSeadragon (the default\n   *  view for an image). Heatmap remains the Plotly scalar-image rendering. */\n  IMAGE = 'image',\n  HEATMAP = 'heatmap',\n  SURFACE = 'surface',\n  CONTOUR = 'contour',\n  SCATTER = 'scatter',\n  // LINE: reserved/stubbed — intensity profiles are now Region-based (kept for future use)\n  LINE = 'line',\n  SCATTER3D = 'scatter3d',\n  ISOSURFACE = 'isosurface',\n  /** WebGPU napari-js renderings (jit-ui#102), selectable alongside the OSD/Plotly types. The 3D\n   *  types take a runtime decimate factor (Full / ½ / ¼ / ⅛) instead of fixed hi/lo-res variants. */\n  NAPARI_IMAGE = 'napari-image',\n  NAPARI_VOLUME = 'napari-volume',\n  NAPARI_ISOSURFACE = 'napari-isosurface',\n  /** WebGPU height-field surface mesh (z = intensity), the napari-js analog of Plotly SURFACE. */\n  NAPARI_SURFACE = 'napari-surface',\n  /** WebGPU 2D scatter of region centroids (napari-js analog of Plotly SCATTER). */\n  NAPARI_SCATTER = 'napari-scatter',\n  /** WebGPU 3D scatter of the downsampled voxel cloud (napari-js analog of Plotly SCATTER3D). */\n  NAPARI_SCATTER3D = 'napari-scatter3d',\n}\n\n/** How many spatial dimensions a plot type renders in. */\nexport type PlotDimensions = '2d' | '3d';\n\n/**\n * Where a plot type pulls its data from:\n *  - `image`   — the loaded pixel matrices / z-stack (HEATMAP, SURFACE, …)\n *  - `regions` — the drawn/derived regions (SCATTER of region centroids, …)\n */\nexport type PlotDataSource = 'image' | 'regions';\n\n/**\n * Backend-neutral metadata about a plot type. Drives UI affordances (which\n * types are 3D, which need an image stack, how to label them in a dropdown)\n * without any backend's trace-building logic leaking into the contract.\n */\nexport interface PlotTypeDescriptor {\n  type: PlotType;\n  /** Human-readable label for menus/dropdowns. Shown in **test mode**, where\n   *  every backend's type is offered, so it carries the backend suffix (e.g.\n   *  \"Surface (napari · WebGPU)\") to disambiguate same-named modes. */\n  label: string;\n  /**\n   * Label shown in the **default (non-test) selector**, where a single curated\n   * mode owns each name — so it drops the backend suffix (e.g. just \"Surface\").\n   * A type WITHOUT a `productionLabel` is **test-only**: hidden from the default\n   * selector and shown only when the host enables test mode. This is the single\n   * knob that curates the default plot-mode list (jax-image-visualization).\n   */\n  productionLabel?: string;\n  /**\n   * Icon shown to the left of the label in the plot-type selector. Either a\n   * PrimeNG icon class (starts with `pi `, e.g. `pi pi-image`) rendered as a\n   * font glyph, or a served SVG asset path (e.g. `assets/plotting/surface.svg`)\n   * rendered as an `<img>`. Both are tinted to the toolbar's primary blue.\n   */\n  icon?: string;\n  dimensions: PlotDimensions;\n  source: PlotDataSource;\n  /** True when the type only makes sense over a multi-frame z-stack. */\n  requiresStack?: boolean;\n  /** True when the type maps a single scalar intensity per pixel (contour,\n   *  surface, intensity profile, isosurface) — only meaningful for grayscale.\n   *  Image/Heatmap render RGB fine; Scatter uses regions. */\n  requiresGrayscale?: boolean;\n}\n\n/**\n * Single source of truth for plot-type metadata. LINE is intentionally absent —\n * intensity profiles are now Region-based line ROIs (available in Heatmap/Image\n * mode), so LINE is no longer offered in the selector (the enum member is kept\n * for future use). Hence the `Partial` record.\n */\n// Dropdown order = insertion order: Image (OSD) default at the top, then all Plotly plot modes\n// grouped, then all napari-js WebGPU modes grouped.\n// `productionLabel` marks the curated default-selector set (jit-ui#70 follow-up):\n//  - IMAGE / HEATMAP / CONTOUR (2D) and the napari SURFACE / VOLUME / ISOSURFACE\n//    (3D) are the modes shown by default, under suffix-free names.\n//  - Everything else (all Scatters, NAPARI_IMAGE, and the Plotly SURFACE /\n//    ISOSURFACE that the napari versions supersede) is test-only — no\n//    `productionLabel`, so it appears only when the host enables test mode.\nexport const PLOT_TYPE_DESCRIPTORS: Partial<Record<PlotType, PlotTypeDescriptor>> = {\n  // ── Default ──\n  [PlotType.IMAGE]:      { type: PlotType.IMAGE,      label: 'Image (OSD)',           productionLabel: 'Image',      icon: 'pi pi-image',                    dimensions: '2d', source: 'image' },\n  // ── Plotly ──\n  [PlotType.HEATMAP]:    { type: PlotType.HEATMAP,    label: 'Heatmap (Plotly)',      productionLabel: 'Heatmap',    icon: 'assets/plotting/heatmap.svg',    dimensions: '2d', source: 'image' },\n  [PlotType.CONTOUR]:    { type: PlotType.CONTOUR,    label: 'Contour (Plotly)',      productionLabel: 'Contour',    icon: 'assets/plotting/contour.svg',    dimensions: '2d', source: 'image', requiresGrayscale: true },\n  [PlotType.SCATTER]:    { type: PlotType.SCATTER,    label: 'Scatter 2D (Plotly)',   icon: 'pi pi-chart-scatter',            dimensions: '2d', source: 'regions' },\n  [PlotType.SURFACE]:    { type: PlotType.SURFACE,    label: 'Surface (Plotly)',      icon: 'assets/plotting/surface.svg',    dimensions: '3d', source: 'image', requiresGrayscale: true },\n  [PlotType.SCATTER3D]:  { type: PlotType.SCATTER3D,  label: 'Scatter 3D (Plotly)',   icon: 'assets/plotting/3d-coordinates.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  [PlotType.ISOSURFACE]: { type: PlotType.ISOSURFACE, label: 'Isosurface (Plotly)',   icon: 'assets/plotting/isosurface.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  // ── napari-js WebGPU (jit-ui#102). The 3D types take a runtime decimate factor. ──\n  [PlotType.NAPARI_IMAGE]:      { type: PlotType.NAPARI_IMAGE,      label: 'Image (napari · WebGPU)',      icon: 'pi pi-image',                        dimensions: '2d', source: 'image' },\n  [PlotType.NAPARI_SCATTER]:    { type: PlotType.NAPARI_SCATTER,    label: 'Scatter 2D (napari · WebGPU)', icon: 'pi pi-chart-scatter',                dimensions: '2d', source: 'regions' },\n  [PlotType.NAPARI_SURFACE]:    { type: PlotType.NAPARI_SURFACE,    label: 'Surface (napari · WebGPU)',    productionLabel: 'Surface',    icon: 'assets/plotting/surface.svg',        dimensions: '3d', source: 'image' }, // a height-field is z=intensity of one plane — works for any grayscale/RGB image (RGB→luminance), no stack needed\n  [PlotType.NAPARI_SCATTER3D]:  { type: PlotType.NAPARI_SCATTER3D,  label: 'Scatter 3D (napari · WebGPU)', icon: 'assets/plotting/3d-coordinates.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  [PlotType.NAPARI_VOLUME]:     { type: PlotType.NAPARI_VOLUME,     label: 'Volume (napari · WebGPU)',     productionLabel: 'Volume',     icon: 'assets/plotting/cube-3d.svg',        dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  [PlotType.NAPARI_ISOSURFACE]: { type: PlotType.NAPARI_ISOSURFACE, label: 'Isosurface (napari · WebGPU)', productionLabel: 'Isosurface', icon: 'assets/plotting/isosurface.svg',     dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n};\n\nexport function getPlotTypeDescriptor(type: PlotType): PlotTypeDescriptor | undefined {\n  return PLOT_TYPE_DESCRIPTORS[type];\n}\n\nexport function isThreeDimensional(type: PlotType): boolean {\n  return PLOT_TYPE_DESCRIPTORS[type]?.dimensions === '3d';\n}\n\n// ── napari-js 3D plot-type predicates ────────────────────────────────────────\n/** napari-js volume. */\nexport function isNapariVolume(type: PlotType): boolean {\n  return type === PlotType.NAPARI_VOLUME;\n}\n/** napari-js isosurface. */\nexport function isNapariIsosurface(type: PlotType): boolean {\n  return type === PlotType.NAPARI_ISOSURFACE;\n}\n/** napari-js height-field surface mesh. */\nexport function isNapariSurface(type: PlotType): boolean {\n  return type === PlotType.NAPARI_SURFACE;\n}\n/** napari-js 2D scatter (region centroids). */\nexport function isNapariScatter(type: PlotType): boolean {\n  return type === PlotType.NAPARI_SCATTER;\n}\n/** napari-js 3D scatter (voxel point cloud). */\nexport function isNapariScatter3d(type: PlotType): boolean {\n  return type === PlotType.NAPARI_SCATTER3D;\n}\n/** Any napari-js 3D plot type (volume, isosurface, surface, or 3D scatter). Resolution is a runtime\n *  decimate factor (Full / ½ / ¼ / ⅛) — see the service's `resolutionScale`. */\nexport function isNapari3d(type: PlotType): boolean {\n  return (\n    isNapariVolume(type) || isNapariIsosurface(type) || isNapariSurface(type) || isNapariScatter3d(type)\n  );\n}\n\n/** Decimate factors offered by the Resolution control (1 = Full … 8 = ⅛). */\nexport const NAPARI_DECIMATE_OPTIONS: { label: string; value: number }[] = [\n  { label: 'Full', value: 1 },\n  { label: '½', value: 2 },\n  { label: '¼', value: 4 },\n  { label: '⅛', value: 8 },\n];\n\n/** Default decimate factor: ¼. The caps are set so ¼ is a sensible default resolution while ½ and\n *  Full offer 2× and 4× the detail for opt-in high-resolution renders. */\nexport const NAPARI_DEFAULT_DECIMATE = 4;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-type.js","sourceRoot":"","sources":["../../../../src/lib/contracts/plot-type.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The kind of rendering a viewer backend should produce for the loaded data.\n *\n * Lives in `contracts/` (rather than inside a specific backend) because it is\n * part of the backend-neutral plotting contract: both the Plotly backend and\n * any future backend (e.g. OpenSeadragon) accept a `PlotType` on `plot()`.\n *\n * NOTE: a backend may not support every type — 3D types (`SURFACE`,\n * `SCATTER3D`, `ISOSURFACE`) are gated behind `ViewerFeature.Surface3D` in the\n * capabilities contract, so a 2D-only backend can advertise that it can't\n * render them and the UI can hide the option.\n */\nexport enum PlotType {\n  /** Natively-tiled, zoomable raster rendered by OpenSeadragon (the default\n   *  view for an image). Heatmap remains the Plotly scalar-image rendering. */\n  IMAGE = 'image',\n  HEATMAP = 'heatmap',\n  SURFACE = 'surface',\n  CONTOUR = 'contour',\n  SCATTER = 'scatter',\n  // LINE: reserved/stubbed — intensity profiles are now Region-based (kept for future use)\n  LINE = 'line',\n  SCATTER3D = 'scatter3d',\n  ISOSURFACE = 'isosurface',\n  /** WebGPU napari-js renderings (jit-ui#102), selectable alongside the OSD/Plotly types. The 3D\n   *  types take a runtime decimate factor (Full / ½ / ¼ / ⅛) instead of fixed hi/lo-res variants. */\n  NAPARI_IMAGE = 'napari-image',\n  NAPARI_VOLUME = 'napari-volume',\n  NAPARI_ISOSURFACE = 'napari-isosurface',\n  /** WebGPU height-field surface mesh (z = intensity), the napari-js analog of Plotly SURFACE. */\n  NAPARI_SURFACE = 'napari-surface',\n  /** WebGPU 2D scatter of region centroids (napari-js analog of Plotly SCATTER). */\n  NAPARI_SCATTER = 'napari-scatter',\n  /** WebGPU 3D scatter of the downsampled voxel cloud (napari-js analog of Plotly SCATTER3D). */\n  NAPARI_SCATTER3D = 'napari-scatter3d',\n  /** Spatial-omics observations (Visium spots, segmented cells) drawn over the tissue image and\n   *  coloured by an annotation column or a gene. Needs a `SpatialDataset` on `SPATIAL_DATA_PORT`,\n   *  so it is gated by `requiresSpatialData` and never appears for an image-only host. */\n  SPATIAL_OMICS = 'spatial-omics',\n  /** Spatial-omics observations as a 3D point cloud, for assays whose observations carry a z —\n   *  serial sections registered into a common frame (e.g. the Allen CCF), or a genuinely\n   *  volumetric assay. Gated by `requiresSpatial3d`, a strictly narrower gate than\n   *  {@link SPATIAL_OMICS}: a single-plane dataset has no z to render. */\n  SPATIAL_OMICS_3D = 'spatial-omics-3d',\n}\n\n/** How many spatial dimensions a plot type renders in. */\nexport type PlotDimensions = '2d' | '3d';\n\n/**\n * Where a plot type pulls its data from:\n *  - `image`   — the loaded pixel matrices / z-stack (HEATMAP, SURFACE, …)\n *  - `regions` — the drawn/derived regions (SCATTER of region centroids, …)\n *  - `spatial` — a `SpatialDataset` supplied through `SPATIAL_DATA_PORT`: N\n *    observations (spots/cells) with categorical + continuous columns and a\n *    lazily-fetched feature matrix, drawn over the tissue image they came from.\n */\nexport type PlotDataSource = 'image' | 'regions' | 'spatial';\n\n/**\n * Backend-neutral metadata about a plot type. Drives UI affordances (which\n * types are 3D, which need an image stack, how to label them in a dropdown)\n * without any backend's trace-building logic leaking into the contract.\n */\nexport interface PlotTypeDescriptor {\n  type: PlotType;\n  /** Human-readable label for menus/dropdowns. Shown in **test mode**, where\n   *  every backend's type is offered, so it carries the backend suffix (e.g.\n   *  \"Surface (napari · WebGPU)\") to disambiguate same-named modes. */\n  label: string;\n  /**\n   * Label shown in the **default (non-test) selector**, where a single curated\n   * mode owns each name — so it drops the backend suffix (e.g. just \"Surface\").\n   * A type WITHOUT a `productionLabel` is **test-only**: hidden from the default\n   * selector and shown only when the host enables test mode. This is the single\n   * knob that curates the default plot-mode list (jax-image-visualization).\n   */\n  productionLabel?: string;\n  /**\n   * Icon shown to the left of the label in the plot-type selector. Either a\n   * PrimeNG icon class (starts with `pi `, e.g. `pi pi-image`) rendered as a\n   * font glyph, or a served SVG asset path (e.g. `assets/plotting/surface.svg`)\n   * rendered as an `<img>`. Both are tinted to the toolbar's primary blue.\n   */\n  icon?: string;\n  dimensions: PlotDimensions;\n  source: PlotDataSource;\n  /** True when the type only makes sense over a multi-frame z-stack. */\n  requiresStack?: boolean;\n  /** True when the type maps a single scalar intensity per pixel (contour,\n   *  surface, intensity profile, isosurface) — only meaningful for grayscale.\n   *  Image/Heatmap render RGB fine; Scatter uses regions. */\n  requiresGrayscale?: boolean;\n  /** True when the type renders a `SpatialDataset` (`source: 'spatial'`) and is\n   *  therefore meaningless without one. The selector hides it until a dataset is\n   *  published on `SPATIAL_DATA_PORT` — the same shape of gate as\n   *  {@link requiresStack} for a z-stack, so a host with no spatial data never\n   *  sees the mode. */\n  requiresSpatialData?: boolean;\n  /** True when the type needs observations with a z coordinate, not merely a\n   *  `SpatialDataset`. Narrower than {@link requiresSpatialData}: most spatial\n   *  assays are a single plane, so this hides the 3D mode unless the published\n   *  dataset actually carries `observations.z`. */\n  requiresSpatial3d?: boolean;\n}\n\n/**\n * Single source of truth for plot-type metadata. LINE is intentionally absent —\n * intensity profiles are now Region-based line ROIs (available in Heatmap/Image\n * mode), so LINE is no longer offered in the selector (the enum member is kept\n * for future use). Hence the `Partial` record.\n */\n// Dropdown order = insertion order: Image (OSD) default at the top, then all Plotly plot modes\n// grouped, then all napari-js WebGPU modes grouped.\n// `productionLabel` marks the curated default-selector set (jit-ui#70 follow-up):\n//  - IMAGE / HEATMAP / CONTOUR (2D) and the napari SURFACE / VOLUME / ISOSURFACE\n//    (3D) are the modes shown by default, under suffix-free names.\n//  - Everything else (all Scatters, NAPARI_IMAGE, and the Plotly SURFACE /\n//    ISOSURFACE that the napari versions supersede) is test-only — no\n//    `productionLabel`, so it appears only when the host enables test mode.\nexport const PLOT_TYPE_DESCRIPTORS: Partial<Record<PlotType, PlotTypeDescriptor>> = {\n  // ── Default ──\n  [PlotType.IMAGE]:      { type: PlotType.IMAGE,      label: 'Image (OSD)',           productionLabel: 'Image',      icon: 'pi pi-image',                    dimensions: '2d', source: 'image' },\n  // ── Plotly ──\n  [PlotType.HEATMAP]:    { type: PlotType.HEATMAP,    label: 'Heatmap (Plotly)',      productionLabel: 'Heatmap',    icon: 'assets/plotting/heatmap.svg',    dimensions: '2d', source: 'image' },\n  [PlotType.CONTOUR]:    { type: PlotType.CONTOUR,    label: 'Contour (Plotly)',      productionLabel: 'Contour',    icon: 'assets/plotting/contour.svg',    dimensions: '2d', source: 'image', requiresGrayscale: true },\n  [PlotType.SCATTER]:    { type: PlotType.SCATTER,    label: 'Scatter 2D (Plotly)',   icon: 'pi pi-chart-scatter',            dimensions: '2d', source: 'regions' },\n  [PlotType.SURFACE]:    { type: PlotType.SURFACE,    label: 'Surface (Plotly)',      icon: 'assets/plotting/surface.svg',    dimensions: '3d', source: 'image', requiresGrayscale: true },\n  [PlotType.SCATTER3D]:  { type: PlotType.SCATTER3D,  label: 'Scatter 3D (Plotly)',   icon: 'assets/plotting/3d-coordinates.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  [PlotType.ISOSURFACE]: { type: PlotType.ISOSURFACE, label: 'Isosurface (Plotly)',   icon: 'assets/plotting/isosurface.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  // ── napari-js WebGPU (jit-ui#102). The 3D types take a runtime decimate factor. ──\n  [PlotType.NAPARI_IMAGE]:      { type: PlotType.NAPARI_IMAGE,      label: 'Image (napari · WebGPU)',      icon: 'pi pi-image',                        dimensions: '2d', source: 'image' },\n  [PlotType.NAPARI_SCATTER]:    { type: PlotType.NAPARI_SCATTER,    label: 'Scatter 2D (napari · WebGPU)', icon: 'pi pi-chart-scatter',                dimensions: '2d', source: 'regions' },\n  [PlotType.NAPARI_SURFACE]:    { type: PlotType.NAPARI_SURFACE,    label: 'Surface (napari · WebGPU)',    productionLabel: 'Surface',    icon: 'assets/plotting/surface.svg',        dimensions: '3d', source: 'image' }, // a height-field is z=intensity of one plane — works for any grayscale/RGB image (RGB→luminance), no stack needed\n  [PlotType.NAPARI_SCATTER3D]:  { type: PlotType.NAPARI_SCATTER3D,  label: 'Scatter 3D (napari · WebGPU)', icon: 'assets/plotting/3d-coordinates.svg', dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  [PlotType.NAPARI_VOLUME]:     { type: PlotType.NAPARI_VOLUME,     label: 'Volume (napari · WebGPU)',     productionLabel: 'Volume',     icon: 'assets/plotting/cube-3d.svg',        dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  [PlotType.NAPARI_ISOSURFACE]: { type: PlotType.NAPARI_ISOSURFACE, label: 'Isosurface (napari · WebGPU)', productionLabel: 'Isosurface', icon: 'assets/plotting/isosurface.svg',     dimensions: '3d', source: 'image', requiresStack: true, requiresGrayscale: true },\n  // ── Spatial omics ──\n  [PlotType.SPATIAL_OMICS]:     { type: PlotType.SPATIAL_OMICS,     label: 'Spatial omics (napari · WebGPU)', productionLabel: 'Spatial omics', icon: 'assets/plotting/spatial-omics.svg',  dimensions: '2d', source: 'spatial', requiresSpatialData: true },\n  [PlotType.SPATIAL_OMICS_3D]:  { type: PlotType.SPATIAL_OMICS_3D,  label: 'Spatial omics 3D (napari · WebGPU)', productionLabel: 'Spatial omics 3D', icon: 'assets/plotting/spatial-omics-3d.svg', dimensions: '3d', source: 'spatial', requiresSpatialData: true, requiresSpatial3d: true },\n};\n\nexport function getPlotTypeDescriptor(type: PlotType): PlotTypeDescriptor | undefined {\n  return PLOT_TYPE_DESCRIPTORS[type];\n}\n\nexport function isThreeDimensional(type: PlotType): boolean {\n  return PLOT_TYPE_DESCRIPTORS[type]?.dimensions === '3d';\n}\n\n// ── napari-js 3D plot-type predicates ────────────────────────────────────────\n/** napari-js volume. */\nexport function isNapariVolume(type: PlotType): boolean {\n  return type === PlotType.NAPARI_VOLUME;\n}\n/** napari-js isosurface. */\nexport function isNapariIsosurface(type: PlotType): boolean {\n  return type === PlotType.NAPARI_ISOSURFACE;\n}\n/** napari-js height-field surface mesh. */\nexport function isNapariSurface(type: PlotType): boolean {\n  return type === PlotType.NAPARI_SURFACE;\n}\n/** napari-js 2D scatter (region centroids). */\nexport function isNapariScatter(type: PlotType): boolean {\n  return type === PlotType.NAPARI_SCATTER;\n}\n/** napari-js 3D scatter (voxel point cloud). */\nexport function isNapariScatter3d(type: PlotType): boolean {\n  return type === PlotType.NAPARI_SCATTER3D;\n}\n/** Spatial-omics observations over the tissue image. */\nexport function isSpatialOmics(type: PlotType): boolean {\n  return type === PlotType.SPATIAL_OMICS;\n}\n/** Spatial-omics observations as a 3D point cloud. */\nexport function isSpatialOmics3d(type: PlotType): boolean {\n  return type === PlotType.SPATIAL_OMICS_3D;\n}\n/**\n * Whether the renderer, rather than the shell, should handle wheel zoom.\n *\n * The shell's wheel listener applies a FIXED step per event, which is far too sensitive for a\n * renderer that reads the scroll delta: it works out at 30% per event against napari-js's 3%, and\n * ignores the device normalization and easing the renderer does. So every plot type drawn by a\n * renderer that owns the wheel has to opt out here.\n *\n * The image view always did. The spatial-omics modes did NOT, despite being drawn by the same\n * napari-js viewer — the shell gated on an `isHeatmap` flag that defaults to true and only goes\n * false for the 3D Plotly scenes, so it silently took the wheel for them too.\n */\nexport function rendererOwnsWheel(type: PlotType): boolean {\n  return type === PlotType.IMAGE || isSpatialOmics(type) || isSpatialOmics3d(type);\n}\n\n/** Any napari-js 3D plot type (volume, isosurface, surface, or 3D scatter). Resolution is a runtime\n *  decimate factor (Full / ½ / ¼ / ⅛) — see the service's `resolutionScale`. */\nexport function isNapari3d(type: PlotType): boolean {\n  return (\n    isNapariVolume(type) || isNapariIsosurface(type) || isNapariSurface(type) || isNapariScatter3d(type)\n  );\n}\n\n/** Decimate factors offered by the Resolution control (1 = Full … 8 = ⅛). */\nexport const NAPARI_DECIMATE_OPTIONS: { label: string; value: number }[] = [\n  { label: 'Full', value: 1 },\n  { label: '½', value: 2 },\n  { label: '¼', value: 4 },\n  { label: '⅛', value: 8 },\n];\n\n/** Default decimate factor: ¼. The caps are set so ¼ is a sensible default resolution while ½ and\n *  Full offer 2× and 4× the detail for opt-in high-resolution renders. */\nexport const NAPARI_DEFAULT_DECIMATE = 4;\n"]}