@vitessce/all 3.9.0 → 3.9.1

package/dist/{OrbitControls-B2DZt-9I.js → OrbitControls-BpeUSyh9.js}

@@ -1,4 +1,4 @@
-import { aG as getDefaultExportFromCjs, aH as Raycaster, W as OrthographicCamera, K as PerspectiveCamera, av as Scene, aI as PCFSoftShadowMap, aJ as VSMShadowMap, aK as PCFShadowMap, aL as BasicShadowMap, aM as NoToneMapping, aN as ACESFilmicToneMapping, e as Vector3, V as Vector2, aO as Clock, aP as WebGLRenderer, aQ as Camera, x as BufferGeometry, r as Material, aR as Layers, a1 as Texture, aC as RGBAFormat, ay as UnsignedByteType, C as Color, aj as _extends, aS as THREE, aT as EventDispatcher, aU as MOUSE, aV as TOUCH, aW as Spherical, Q as Quaternion, an as Ray, ak as Plane } from "./index-Ccs0RkVq.js";
+import { aG as getDefaultExportFromCjs, aH as Raycaster, W as OrthographicCamera, K as PerspectiveCamera, av as Scene, aI as PCFSoftShadowMap, aJ as VSMShadowMap, aK as PCFShadowMap, aL as BasicShadowMap, aM as NoToneMapping, aN as ACESFilmicToneMapping, e as Vector3, V as Vector2, aO as Clock, aP as WebGLRenderer, aQ as Camera, x as BufferGeometry, r as Material, aR as Layers, a1 as Texture, aC as RGBAFormat, ay as UnsignedByteType, C as Color, aj as _extends, aS as THREE, aT as EventDispatcher, aU as MOUSE, aV as TOUCH, aW as Spherical, Q as Quaternion, an as Ray, ak as Plane } from "./index-B-aCUFst.js";
 import * as React from "react";
 import React__default, { useReducer, useRef, useEffect, useLayoutEffect, useDebugValue, useState, useMemo } from "react";
 var constants = { exports: {} };

package/dist/{ReactNeuroglancer-rd4zjvRk.js → ReactNeuroglancer-CGvAuFr6.js}

@@ -1,4 +1,4 @@
-import { aG as getDefaultExportFromCjs, b1 as requireAssign, b2 as require_export, b3 as require_core, b4 as require_fails, b5 as require_toObject, b6 as require_objectKeys, b7 as require_cof, b8 as require_wks, b9 as require_iterators, ba as requireWeb_dom_iterable, bb as requireEs6_string_iterator, bc as require_anObject, bd as require_hide, be as require_ctx, bf as require_toLength, bg as require_global, bh as require_objectDp, bi as require_descriptors, bj as require_isObject, bk as require_objectCreate, bl as require_iterDefine, bm as require_iterStep, bn as require_meta, bo as require_isArray, bp as require_iobject, bq as require_setToStringTag, br as require_aFunction, bs as requireIterator, bt as require_propertyDesc, a_ as commonjsGlobal, bu as requireEs6_symbol, bv as requireDefineProperty, bw as require_toIobject, bx as require_objectGopd, by as require_html, bz as require_domCreate, bA as require_library, bB as requireSymbol, bC as require_objectPie, bD as require_has, bE as require_redefine, bF as require_objectAssign, bG as diffCameraState, ao as jsxRuntimeExports } from "./index-Ccs0RkVq.js";
+import { aG as getDefaultExportFromCjs, b1 as requireAssign, b2 as require_export, b3 as require_core, b4 as require_fails, b5 as require_toObject, b6 as require_objectKeys, b7 as require_cof, b8 as require_wks, b9 as require_iterators, ba as requireWeb_dom_iterable, bb as requireEs6_string_iterator, bc as require_anObject, bd as require_hide, be as require_ctx, bf as require_toLength, bg as require_global, bh as require_objectDp, bi as require_descriptors, bj as require_isObject, bk as require_objectCreate, bl as require_iterDefine, bm as require_iterStep, bn as require_meta, bo as require_isArray, bp as require_iobject, bq as require_setToStringTag, br as require_aFunction, bs as requireIterator, bt as require_propertyDesc, a_ as commonjsGlobal, bu as requireEs6_symbol, bv as requireDefineProperty, bw as require_toIobject, bx as require_objectGopd, by as require_html, bz as require_domCreate, bA as require_library, bB as requireSymbol, bC as require_objectPie, bD as require_has, bE as require_redefine, bF as require_objectAssign, bG as diffCameraState, ao as jsxRuntimeExports } from "./index-B-aCUFst.js";
 import React__default from "react";
 var assignExports = requireAssign();
 const _Object$assign = /* @__PURE__ */ getDefaultExportFromCjs(assignExports);

package/dist/{deflate-mmlLWSqG.js → deflate-C63ycJxP.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-B-aCUFst.js";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return inflate_1(new Uint8Array(buffer)).buffer;

package/dist/{higlass-Chx9S58D.js → higlass-Dsba4gSg.js}

@@ -1,7 +1,7 @@
 import * as React$7 from "react";
 import React__default, { isValidElement, PureComponent, Component, createElement, createContext, createRef } from "react";
 import ReactDOM__default, { findDOMNode as findDOMNode$1 } from "react-dom";
-import { a_ as commonjsGlobal$1, a$ as requireObjectAssign, aG as getDefaultExportFromCjs$1, b0 as earcut } from "./index-Ccs0RkVq.js";
+import { a_ as commonjsGlobal$1, a$ as requireObjectAssign, aG as getDefaultExportFromCjs$1, b0 as earcut } from "./index-B-aCUFst.js";
 var promise = {};
 var hasRequiredPromise;
 function requirePromise() {

package/dist/{index-Ccs0RkVq.js → index-B-aCUFst.js}

@@ -10815,7 +10815,9 @@ const obsSegmentationsSpatialdataSchema = z.object({
 const obsPointsSpatialdataSchema = z.object({
   path: z.string().describe("The path to the point data."),
   tablePath: z.string().optional().describe("The path to a table which annotates the points. If available but not specified, the spot identifiers may not be aligned with associated tabular data as expected."),
-  coordinateSystem: z.string().optional().describe('The name of a coordinate transformation output used to transform the image. If not provided, the "global" coordinate system is assumed.')
+  coordinateSystem: z.string().optional().describe('The name of a coordinate transformation output used to transform the image. If not provided, the "global" coordinate system is assumed.'),
+  featureIndexColumn: z.string().optional().describe("The name of the column in the table which contains the feature (e.g., gene) indices associated with each point (aligned with the table var.index dataframe column)."),
+  mortonCodeColumn: z.string().optional().describe('The name of the column in the table which contains the Morton codes for each point, used for efficient spatial querying. If not provided, Vitessce will assume the default column name "morton_code_2d".')
 });
 z.object({
   path: z.string(),
@@ -209140,22 +209142,22 @@ async function getDecoder(fileDirectory) {
   const Decoder = await importFn();
   return new Decoder(fileDirectory);
 }
-addDecoder([void 0, 1], () => import("./raw-C5wVKuiu.js").then((m2) => m2.default));
-addDecoder(5, () => import("./lzw-BNtf5UsG.js").then((m2) => m2.default));
+addDecoder([void 0, 1], () => import("./raw-fm6sEfJs.js").then((m2) => m2.default));
+addDecoder(5, () => import("./lzw-fa9yKTSy.js").then((m2) => m2.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-C90IvgAr.js").then((m2) => m2.default));
-addDecoder([8, 32946], () => import("./deflate-mmlLWSqG.js").then((m2) => m2.default));
-addDecoder(32773, () => import("./packbits-BaMXgBB6.js").then((m2) => m2.default));
+addDecoder(7, () => import("./jpeg-BZSLq5O3.js").then((m2) => m2.default));
+addDecoder([8, 32946], () => import("./deflate-C63ycJxP.js").then((m2) => m2.default));
+addDecoder(32773, () => import("./packbits-8C0e8lDT.js").then((m2) => m2.default));
 addDecoder(
   34887,
-  () => import("./lerc-cm5d7rjy.js").then(async (m2) => {
+  () => import("./lerc-BZk5g5T2.js").then(async (m2) => {
     await m2.zstd.init();
     return m2;
   }).then((m2) => m2.default)
 );
-addDecoder(50001, () => import("./webimage-BjAUnP6y.js").then((m2) => m2.default));
+addDecoder(50001, () => import("./webimage-CyRSWQVR.js").then((m2) => m2.default));
 function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
   return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
 }
@@ -253559,12 +253561,12 @@ class ErrorBoundary extends React__default.Component {
   }
 }
 const LazySpatialThree = React__default.lazy(async () => {
-  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-SH4i0VjQ.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-DBnzUqAs.js");
   return { default: SpatialWrapper2 };
 });
 const SpatialThreeAdapter = React__default.forwardRef((props, ref2) => jsxRuntimeExports.jsx("div", { ref: ref2, style: { width: "100%", height: "100%" }, children: jsxRuntimeExports.jsx(ErrorBoundary, { children: jsxRuntimeExports.jsx(Suspense, { fallback: jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: jsxRuntimeExports.jsx(LazySpatialThree, { ...props }) }) }) }));
 const LazySpatialAccelerated = React__default.lazy(async () => {
-  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-gdPd0Ws9.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-Do4xvqoi.js");
   return { default: SpatialWrapper2 };
 });
 const SpatialAcceleratedAdapter = React__default.forwardRef((props, ref2) => jsxRuntimeExports.jsx("div", { ref: ref2, style: { width: "100%", height: "100%" }, children: jsxRuntimeExports.jsx(ErrorBoundary, { children: jsxRuntimeExports.jsx(Suspense, { fallback: jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: jsxRuntimeExports.jsx(LazySpatialAccelerated, { ...props }) }) }) }));
@@ -267042,7 +267044,7 @@ function HiglassGlobalStyles(props) {
 }
 register({ dataFetcher: ZarrMultivecDataFetcher_default, config: ZarrMultivecDataFetcher_default.config }, { pluginType: "dataFetcher" });
 const LazyHiGlassComponent = React__default.lazy(async () => {
-  const { HiGlassComponent } = await import("./higlass-Chx9S58D.js");
+  const { HiGlassComponent } = await import("./higlass-Dsba4gSg.js");
   return { default: HiGlassComponent };
 });
 const HG_SIZE = 800;
@@ -269989,7 +269991,7 @@ function NeuroglancerGlobalStyles(props) {
   const { classes: classes2 } = props;
   return jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx(GlobalStyles$3, { styles: globalNeuroglancerCss }), jsxRuntimeExports.jsx(ScopedGlobalStyles, { styles: globalNeuroglancerStyles, parentClassName: classes2.neuroglancerWrapper })] });
 }
-const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-rd4zjvRk.js"));
+const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-CGvAuFr6.js"));
 function createWorker() {
   return new WorkerFactory();
 }
@@ -358389,14 +358391,14 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
      * @returns {Promise} A promise for an array of columns.
      */
   async loadPoints() {
-    const { path: path2 } = this.options;
+    const { path: path2, featureIndexColumn } = this.options;
     if (this.locations) {
       return this.locations;
     }
     let locations;
     const formatVersion = await this.dataSource.getPointsFormatVersion(path2);
     if (formatVersion === "0.1") {
-      locations = await this.dataSource.loadPoints(path2);
+      locations = await this.dataSource.loadPoints(path2, featureIndexColumn);
     } else {
       throw new UnknownSpatialDataFormatError("Only points format version 0.1 is supported.");
     }
@@ -358404,11 +358406,11 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
     return this.locations;
   }
   async loadPointsInRect(bounds2, signal) {
-    const { path: path2 } = this.options;
+    const { path: path2, featureIndexColumn, mortonCodeColumn } = this.options;
     let locations;
     const formatVersion = await this.dataSource.getPointsFormatVersion(path2);
     if (formatVersion === "0.1") {
-      locations = await this.dataSource.loadPointsInRect(path2, bounds2, signal);
+      locations = await this.dataSource.loadPointsInRect(path2, bounds2, signal, featureIndexColumn, mortonCodeColumn);
     } else {
       throw new UnknownSpatialDataFormatError("Only points format version 0.1 is supported.");
     }
@@ -358427,15 +358429,17 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
     return null;
   }
   async supportsTiling() {
-    const { path: path2 } = this.options;
-    const [formatVersion, zattrs, hasRequiredColumnsAndRowGroupSize] = await Promise.all([
+    const { path: path2, featureIndexColumn: featureIndexColumnNameFromOptions, mortonCodeColumn } = this.options;
+    const zattrs = await this.dataSource.loadSpatialDataElementAttrs(path2);
+    const { spatialdata_attrs: spatialDataAttrs } = zattrs;
+    const { feature_key: featureKey } = spatialDataAttrs;
+    const featureIndexColumnName = featureIndexColumnNameFromOptions ?? `${featureKey}_codes`;
+    const [formatVersion, hasRequiredColumnsAndRowGroupSize] = await Promise.all([
       // Check the points format version.
       this.dataSource.getPointsFormatVersion(path2),
-      // Check for the presence of bounding_box metadata.
-      this.dataSource.loadSpatialDataElementAttrs(path2),
       // Check the size of parquet row groups,
       // and for the presence of morton_code_2d and feature_index columns.
-      this.dataSource.supportsLoadPointsInRect(path2)
+      this.dataSource.supportsLoadPointsInRect(path2, featureIndexColumnName, mortonCodeColumn)
     ]);
     const isSupportedVersion = formatVersion === "0.1";
     const boundingBox = zattrs?.bounding_box;
@@ -368283,7 +368287,7 @@ async function _bisectRowGroupsRight({ queryClient, store }, parquetPath, column
     meta: { queryClient, store }
   });
 }
-async function _rectToRowGroupIndices({ queryClient, store }, parquetPath, tileBbox, allPointsBbox) {
+async function _rectToRowGroupIndices({ queryClient, store }, parquetPath, tileBbox, allPointsBbox, mortonCodeColumnName) {
   return queryClient.fetchQuery({
     queryKey: ["SpatialDataTableSource", "_rectToRowGroupIndices", parquetPath, tileBbox, allPointsBbox],
     staleTime: Infinity,
@@ -368306,8 +368310,8 @@ async function _rectToRowGroupIndices({ queryClient, store }, parquetPath, tileB
         const [startMin, startMax] = mortonIntervals[startIndex];
         const [endMin, endMax] = mortonIntervals[endIndex];
         const [rowGroupIndexMin, rowGroupIndexMax] = await Promise.all([
-          _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, "morton_code_2d", startMin),
-          _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, "morton_code_2d", endMax)
+          _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, mortonCodeColumnName, startMin),
+          _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, mortonCodeColumnName, endMax)
         ]);
         if (rowGroupIndexMin === rowGroupIndexMax) {
           return [false, [rowGroupIndexMin]];
@@ -368329,8 +368333,8 @@ async function _rectToRowGroupIndices({ queryClient, store }, parquetPath, tileB
           if (startIndex === endIndex) {
             const [intervalMin, intervalMax] = mortonIntervals[startIndex];
             const [rowGroupIndexMin, rowGroupIndexMax] = await Promise.all([
-              _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, "morton_code_2d", intervalMin),
-              _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, "morton_code_2d", intervalMax)
+              _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, mortonCodeColumnName, intervalMin),
+              _bisectRowGroupsRight({ queryClient: queryClient2, store: store2 }, parquetPath, mortonCodeColumnName, intervalMax)
             ]);
             if (rowGroupIndexMin <= rowGroupIndexMax) {
               coveredRowGroupIndices = coveredRowGroupIndices.concat(range$e(rowGroupIndexMin, rowGroupIndexMax + 1));
@@ -368657,7 +368661,7 @@ class SpatialDataTableSource extends AnnDataSource {
     this.varAliases[varPath] = this.varAliases[varPath].map((val, ind) => val ? val.concat(` (${index2[ind]})`) : index2[ind]);
     return this.varAliases[varPath];
   }
-  async _supportsTiledPoints(parquetPath) {
+  async _supportsTiledPoints(parquetPath, featureIndexColumnName, mortonCodeColumn) {
     const { queryClient } = this;
     const { store } = this.storeRoot;
     const allMetadata = await _loadParquetMetadataByPart({ queryClient, store }, parquetPath);
@@ -368669,7 +368673,8 @@ class SpatialDataTableSource extends AnnDataSource {
       }
       return false;
     }
-    const requiredColumns = ["x", "y", "feature_index", "morton_code_2d"];
+    const mortonCodeColumnName = mortonCodeColumn ?? "morton_code_2d";
+    const requiredColumns = ["x", "y", featureIndexColumnName, mortonCodeColumnName];
     const hasColumns = allMetadata?.schema?.fields?.map((f2) => f2.name);
     if (!hasColumns) {
       return false;
@@ -368688,9 +368693,10 @@ class SpatialDataTableSource extends AnnDataSource {
    * @param {string[]|undefined} columns An optional list of column names to load.
    * @returns
    */
-  async loadParquetTableInRect(parquetPath, tileBbox, allPointsBbox, signal) {
+  async loadParquetTableInRect(parquetPath, tileBbox, allPointsBbox, signal, featureIndexColumnName, mortonCodeColumn) {
     const { queryClient } = this;
     const { store } = this.storeRoot;
+    const mortonCodeColumnName = mortonCodeColumn ?? "morton_code_2d";
     const TILE_SIZE2 = 256;
     let tileBboxes = [];
     if (tileBbox.right - tileBbox.left > TILE_SIZE2 || tileBbox.bottom - tileBbox.top > TILE_SIZE2) {
@@ -368712,7 +368718,7 @@ class SpatialDataTableSource extends AnnDataSource {
     } else {
       tileBboxes = [tileBbox];
     }
-    const rowGroupIndicesPerTile = await Promise.all(tileBboxes.map(async (subTileBbox) => _rectToRowGroupIndices({ queryClient, store }, parquetPath, subTileBbox, allPointsBbox)));
+    const rowGroupIndicesPerTile = await Promise.all(tileBboxes.map(async (subTileBbox) => _rectToRowGroupIndices({ queryClient, store }, parquetPath, subTileBbox, allPointsBbox, mortonCodeColumnName)));
     const uniqueCoveredRowGroupIndices = Array.from(new Set(rowGroupIndicesPerTile.flat())).toSorted((a2, b2) => a2 - b2);
     const allMetadata = await _loadParquetMetadataByPart({ queryClient, store }, parquetPath);
     const { numRowsPerGroup } = allMetadata;
@@ -368726,7 +368732,7 @@ class SpatialDataTableSource extends AnnDataSource {
     rowGroupTables.forEach((table2) => {
       const xColumn = table2.getChild("x");
       const yColumn = table2.getChild("y");
-      const featureIndexColumn = table2.getChild("feature_index");
+      const featureIndexColumn = table2.getChild(featureIndexColumnName);
       if (!xColumn || !yColumn || !featureIndexColumn) {
         throw new Error(`Missing required column in parquet table at ${parquetPath}. Required columns: x, y, feature_index`);
       }
@@ -374878,7 +374884,7 @@ class SpatialDataPointsSource extends SpatialDataTableSource {
    *  shape: [number, number],
    * }>} A promise for a zarr array containing the data.
    */
-  async loadPoints(elementPath) {
+  async loadPoints(elementPath, featureIndexColumnNameFromOptions) {
     const parquetPath = getParquetPath(elementPath);
     const zattrs = await this.loadSpatialDataElementAttrs(elementPath);
     const { axes, spatialdata_attrs: spatialDataAttrs } = zattrs;
@@ -374908,23 +374914,25 @@ class SpatialDataPointsSource extends SpatialDataTableSource {
    *  shape: [number, number],
    * }>} A promise for a zarr array containing the data.
    */
-  async loadPointsInRect(elementPath, tileBbox, signal) {
+  async loadPointsInRect(elementPath, tileBbox, signal, featureIndexColumnNameFromOptions, mortonCodeColumn) {
     const parquetPath = getParquetPath(elementPath);
     const zattrs = await this.loadSpatialDataElementAttrs(elementPath);
     const {
       // axes,
-      // spatialdata_attrs: spatialDataAttrs,
+      spatialdata_attrs: spatialDataAttrs,
       // The bounding box (extent) of all points.
       // Required for un-normalization from uints back to floats.
       // TODO: decide whether these will be stored here or somewhere else.
       // Reference: https://github.com/vitessce/vitessce-python/pull/476#issuecomment-3362656956
       bounding_box: allPointsBbox
     } = zattrs;
-    return this.loadParquetTableInRect(parquetPath, tileBbox, allPointsBbox, signal);
+    const { feature_key: featureKey } = spatialDataAttrs;
+    const featureIndexColumnName = featureIndexColumnNameFromOptions ?? `${featureKey}_codes`;
+    return this.loadParquetTableInRect(parquetPath, tileBbox, allPointsBbox, signal, featureIndexColumnName, mortonCodeColumn);
   }
-  async supportsLoadPointsInRect(elementPath) {
+  async supportsLoadPointsInRect(elementPath, featureIndexColumnName, mortonCodeColumn) {
     const parquetPath = getParquetPath(elementPath);
-    return this._supportsTiledPoints(parquetPath);
+    return this._supportsTiledPoints(parquetPath, featureIndexColumnName, mortonCodeColumn);
   }
 }
 class OmeTiffSource {

package/dist/{index-SH4i0VjQ.js → index-DBnzUqAs.js}

@@ -1,7 +1,7 @@
-import { G as Group, M as Matrix4, T as TrianglesDrawMode, a as TriangleFanDrawMode, b as TriangleStripDrawMode, R as REVISION, L as Loader, c as LoaderUtils, F as FileLoader, d as MeshPhysicalMaterial, V as Vector2, C as Color, S as SpotLight, P as PointLight, D as DirectionalLight, e as Vector3, I as InstancedMesh, Q as Quaternion, O as Object3D, f as TextureLoader, g as ImageBitmapLoader, B as BufferAttribute, h as InterleavedBuffer, i as LinearMipmapLinearFilter, N as NearestMipmapLinearFilter, j as LinearMipmapNearestFilter, k as NearestMipmapNearestFilter, l as LinearFilter, m as NearestFilter, n as RepeatWrapping, o as MirroredRepeatWrapping, p as ClampToEdgeWrapping, q as PointsMaterial, r as Material, s as LineBasicMaterial, t as MeshStandardMaterial, u as DoubleSide, v as MeshBasicMaterial, w as PropertyBinding, x as BufferGeometry, y as SkinnedMesh, z as Mesh, A as LineSegments, E as Line$1, H as LineLoop, J as Points, K as PerspectiveCamera, U as MathUtils, W as OrthographicCamera, X as Skeleton, Y as InterpolateDiscrete, Z as InterpolateLinear, _ as AnimationClip, $ as Bone, a0 as InterleavedBufferAttribute, a1 as Texture, a2 as VectorKeyframeTrack, a3 as QuaternionKeyframeTrack, a4 as NumberKeyframeTrack, a5 as FrontSide, a6 as Interpolant, a7 as Box3, a8 as Sphere, a9 as InstancedBufferGeometry, aa as Float32BufferAttribute, ab as InstancedInterleavedBuffer, ac as WireframeGeometry, ad as ShaderMaterial, ae as UniformsUtils, af as UniformsLib, ag as Vector4, ah as Line3, ai as SphereGeometry, aj as _extends, ak as Plane, al as Triangle, am as BackSide, an as Ray$1, ao as jsxRuntimeExports, ap as Matrix3, aq as CoordinationType, ar as Data3DTexture, as as RedFormat, at as FloatType, au as getImageSize, av as Scene } from "./index-Ccs0RkVq.js";
+import { G as Group, M as Matrix4, T as TrianglesDrawMode, a as TriangleFanDrawMode, b as TriangleStripDrawMode, R as REVISION, L as Loader, c as LoaderUtils, F as FileLoader, d as MeshPhysicalMaterial, V as Vector2, C as Color, S as SpotLight, P as PointLight, D as DirectionalLight, e as Vector3, I as InstancedMesh, Q as Quaternion, O as Object3D, f as TextureLoader, g as ImageBitmapLoader, B as BufferAttribute, h as InterleavedBuffer, i as LinearMipmapLinearFilter, N as NearestMipmapLinearFilter, j as LinearMipmapNearestFilter, k as NearestMipmapNearestFilter, l as LinearFilter, m as NearestFilter, n as RepeatWrapping, o as MirroredRepeatWrapping, p as ClampToEdgeWrapping, q as PointsMaterial, r as Material, s as LineBasicMaterial, t as MeshStandardMaterial, u as DoubleSide, v as MeshBasicMaterial, w as PropertyBinding, x as BufferGeometry, y as SkinnedMesh, z as Mesh, A as LineSegments, E as Line$1, H as LineLoop, J as Points, K as PerspectiveCamera, U as MathUtils, W as OrthographicCamera, X as Skeleton, Y as InterpolateDiscrete, Z as InterpolateLinear, _ as AnimationClip, $ as Bone, a0 as InterleavedBufferAttribute, a1 as Texture, a2 as VectorKeyframeTrack, a3 as QuaternionKeyframeTrack, a4 as NumberKeyframeTrack, a5 as FrontSide, a6 as Interpolant, a7 as Box3, a8 as Sphere, a9 as InstancedBufferGeometry, aa as Float32BufferAttribute, ab as InstancedInterleavedBuffer, ac as WireframeGeometry, ad as ShaderMaterial, ae as UniformsUtils, af as UniformsLib, ag as Vector4, ah as Line3, ai as SphereGeometry, aj as _extends, ak as Plane, al as Triangle, am as BackSide, an as Ray$1, ao as jsxRuntimeExports, ap as Matrix3, aq as CoordinationType, ar as Data3DTexture, as as RedFormat, at as FloatType, au as getImageSize, av as Scene } from "./index-B-aCUFst.js";
 import * as React from "react";
 import { useRef, useEffect, useState, forwardRef } from "react";
-import { u as useThree, a as useFrame, c as create, e as extend, b as createPortal, O as OrbitControls, C as Canvas } from "./OrbitControls-B2DZt-9I.js";
+import { u as useThree, a as useFrame, c as create, e as extend, b as createPortal, O as OrbitControls, C as Canvas } from "./OrbitControls-BpeUSyh9.js";
 const isPromise = (promise) => typeof promise === "object" && typeof promise.then === "function";
 const globalCache = [];
 function shallowEqualArrays(arrA, arrB, equal = (a, b) => a === b) {
@@ -5027,7 +5027,7 @@ const Text = /* @__PURE__ */ React.forwardRef(({
   const {
     Text: TextMeshImpl,
     preloadFont
-  } = suspend(async () => import("./troika-three-text.esm-D_LuNiSc.js"), []);
+  } = suspend(async () => import("./troika-three-text.esm-Cf8otk5M.js"), []);
   const invalidate = useThree(({
     invalidate: invalidate2
   }) => invalidate2);

package/dist/{index-gdPd0Ws9.js → index-Do4xvqoi.js}

@@ -1,6 +1,6 @@
-import { aw as log, ax as isEqual, ar as Data3DTexture, as as RedFormat, ay as UnsignedByteType, l as LinearFilter, az as RedIntegerFormat, aA as UnsignedIntType, m as NearestFilter, e as Vector3, V as Vector2, ag as Vector4, ae as UniformsUtils, aq as CoordinationType, aB as WebGLMultipleRenderTargets, aC as RGBAFormat, av as Scene, W as OrthographicCamera, ad as ShaderMaterial, z as Mesh, aD as PlaneGeometry, aE as useEventCallback, ao as jsxRuntimeExports, aF as GLSL3, am as BackSide } from "./index-Ccs0RkVq.js";
+import { aw as log, ax as isEqual, ar as Data3DTexture, as as RedFormat, ay as UnsignedByteType, l as LinearFilter, az as RedIntegerFormat, aA as UnsignedIntType, m as NearestFilter, e as Vector3, V as Vector2, ag as Vector4, ae as UniformsUtils, aq as CoordinationType, aB as WebGLMultipleRenderTargets, aC as RGBAFormat, av as Scene, W as OrthographicCamera, ad as ShaderMaterial, z as Mesh, aD as PlaneGeometry, aE as useEventCallback, ao as jsxRuntimeExports, aF as GLSL3, am as BackSide } from "./index-B-aCUFst.js";
 import { useRef, useState, useMemo, useEffect, Suspense } from "react";
-import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-B2DZt-9I.js";
+import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-BpeUSyh9.js";
 const LogLevel = {
   INFO: "info",
   WARN: "warn",

package/dist/index.js

@@ -1,4 +1,4 @@
-import { bR, bP, bN, bQ, bO, bM, bS } from "./index-Ccs0RkVq.js";
+import { bR, bP, bN, bQ, bO, bM, bS } from "./index-B-aCUFst.js";
 import { useComplexCoordination, useComplexCoordinationSecondary, useCoordination, useCoordinationScopes, useCoordinationScopesBy, useGridItemSize, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondaryNonNull, usePageModeView } from "@vitessce/vit-s";
 export {
   bR as PluginAsyncFunction,

package/dist/{jpeg-C90IvgAr.js → jpeg-BZSLq5O3.js}

@@ -1,4 +1,4 @@
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-B-aCUFst.js";
 const dctZigZag = new Int32Array([
   0,
   1,

package/dist/{lerc-cm5d7rjy.js → lerc-BZk5g5T2.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { aG as getDefaultExportFromCjs, aX as BaseDecoder, aY as LercParameters, aZ as LercAddCompression } from "./index-Ccs0RkVq.js";
+import { aG as getDefaultExportFromCjs, aX as BaseDecoder, aY as LercParameters, aZ as LercAddCompression } from "./index-B-aCUFst.js";
 var LercDecode = { exports: {} };
 var hasRequiredLercDecode;
 function requireLercDecode() {

package/dist/{lzw-BNtf5UsG.js → lzw-fa9yKTSy.js}

@@ -1,4 +1,4 @@
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-B-aCUFst.js";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;
 const EOI_CODE = 257;

package/dist/{packbits-BaMXgBB6.js → packbits-8C0e8lDT.js}

@@ -1,4 +1,4 @@
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-B-aCUFst.js";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     const dataView = new DataView(buffer);

package/dist/{raw-C5wVKuiu.js → raw-fm6sEfJs.js}

@@ -1,4 +1,4 @@
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-B-aCUFst.js";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return buffer;

package/dist/{troika-three-text.esm-D_LuNiSc.js → troika-three-text.esm-Cf8otk5M.js}

@@ -1,4 +1,4 @@
-import { bH as MeshDistanceMaterial, bI as MeshDepthMaterial, bJ as RGBADepthPacking, ae as UniformsUtils, bK as ShaderChunk, a9 as InstancedBufferGeometry, a8 as Sphere, a7 as Box3, am as BackSide, u as DoubleSide, z as Mesh, a5 as FrontSide, v as MeshBasicMaterial, C as Color, e as Vector3, M as Matrix4, V as Vector2, ap as Matrix3, ag as Vector4, a1 as Texture, l as LinearFilter, aD as PlaneGeometry, x as BufferGeometry, aa as Float32BufferAttribute, bL as InstancedBufferAttribute } from "./index-Ccs0RkVq.js";
+import { bH as MeshDistanceMaterial, bI as MeshDepthMaterial, bJ as RGBADepthPacking, ae as UniformsUtils, bK as ShaderChunk, a9 as InstancedBufferGeometry, a8 as Sphere, a7 as Box3, am as BackSide, u as DoubleSide, z as Mesh, a5 as FrontSide, v as MeshBasicMaterial, C as Color, e as Vector3, M as Matrix4, V as Vector2, ap as Matrix3, ag as Vector4, a1 as Texture, l as LinearFilter, aD as PlaneGeometry, x as BufferGeometry, aa as Float32BufferAttribute, bL as InstancedBufferAttribute } from "./index-B-aCUFst.js";
 function workerBootstrap() {
   var modules = /* @__PURE__ */ Object.create(null);
   function registerModule(ref, callback) {

package/dist/{webimage-BjAUnP6y.js → webimage-CyRSWQVR.js}

@@ -1,4 +1,4 @@
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-B-aCUFst.js";
 class WebImageDecoder extends BaseDecoder {
   constructor() {
     super();

package/dist-tsc/base-plugins.d.ts

@@ -267,14 +267,20 @@ export declare const baseJointFileTypes: (PluginJointFileType<z.ZodObject<{
         path: z.ZodString;
         tablePath: z.ZodOptional<z.ZodString>;
         coordinateSystem: z.ZodOptional<z.ZodString>;
+        featureIndexColumn: z.ZodOptional<z.ZodString>;
+        mortonCodeColumn: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         path: string;
         tablePath?: string | undefined;
         coordinateSystem?: string | undefined;
+        featureIndexColumn?: string | undefined;
+        mortonCodeColumn?: string | undefined;
     }, {
         path: string;
         tablePath?: string | undefined;
         coordinateSystem?: string | undefined;
+        featureIndexColumn?: string | undefined;
+        mortonCodeColumn?: string | undefined;
     }>>;
     obsFeatureMatrix: z.ZodOptional<z.ZodObject<{
         path: z.ZodString;
@@ -394,6 +400,8 @@ export declare const baseJointFileTypes: (PluginJointFileType<z.ZodObject<{
         path: string;
         tablePath?: string | undefined;
         coordinateSystem?: string | undefined;
+        featureIndexColumn?: string | undefined;
+        mortonCodeColumn?: string | undefined;
     } | undefined;
     obsFeatureMatrix?: {
         path: string;
@@ -445,6 +453,8 @@ export declare const baseJointFileTypes: (PluginJointFileType<z.ZodObject<{
         path: string;
         tablePath?: string | undefined;
         coordinateSystem?: string | undefined;
+        featureIndexColumn?: string | undefined;
+        mortonCodeColumn?: string | undefined;
     } | undefined;
     obsFeatureMatrix?: {
         path: string;

package/dist-tsc/base-plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,CAAC,EAqDF,MAAM,mBAAmB,CAAC;AAmL3B,eAAO,MAAM,aAAa,kBA8BzB,CAAC;AAEF,eAAO,MAAM,aAAa,wDA2EzB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuGwD,CAAC;gCAClE,CAAC;;;yBAGF,CAAC;gCAEa,CAAC;;;;;;;;;;;;;;;;iBAqBkB,CAAC;;;;iBAKtC,CAAC;;;;;;;YAGW,CAAC;;;YAIxB,CAAC;;;;;;;YAMH,CAAC;;;YAEmB,CAAC;;;;;;;YAKF,CAAC;;;YAGd,CAAC;;;;;;;;;;;;;;YAWP,CAAC;;;YAGgB,CAAC;;;;;;;;YAapB,CAAF;;;;YAGY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;yBAgBqB,CAAC;gCAAsD,CAAC;;;;;;;;iBAGrD,CAAC;;;;YACQ,CAAC;;;;YACM,CAAC;;;;YACO,CAAC;;;;;;;YAE9B,CAAC;;;;YACV,CAAC;;;;;;;;;;;;;;;;;;;;yBAKtB,CADkG;gCAC9E,CAAC;;;;;;;;iBAEjB,CAAA;;;;YACG,CAAC;;;;YACM,CAAC;;;;YAAkG,CAAC;;;;;;;YAEpF,CAAC;;;;YACI,CAAC;;;;;;;;;;;wBA4D+7D,CAAC;;;wBAA6E,CAAC;;;;;;;;iBAAwR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;iBAAiR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;;;yBAAkZ,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;yBAA8E,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;;;;;iBAAgR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;;;;;qBAAygB,CAAC;;;;qBAA2J,CAAC;;;;;;qBAAsN,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;qBAA0K,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;;;YAAoP,CAAC;;;YAAmE,CAAC;;;;;;;;YAAuR,CAAC;;;;YAAkG,CAAC;;;;;;;;;;;;;;;;;;;;;;wBAAmoB,CAAC;;;;iBAAyG,CAAC;wBAA8C,CAAC;;;;iBAAkG,CAAC;wBAA8C,CAAC;;;;yBAAiH,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;iBAAiG,CAAC;wBAA8C,CAAC;;;;;;qBAAoM,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;YAAgG,CAAC;;;;YAAmG,CAAC;;;;;;;;;;;;wBAA6R,CAAC;;;;iBAAyG,CAAC;wBAA8C,CAAC;;;;iBAAkG,CAAC;wBAA8C,CAAC;;;;yBAAiH,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;iBAAiG,CAAC;wBAA8C,CAAC;;;;;;qBAAoM,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;YAAgG,CAAC;;;;YAAmG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAljBnsS,CAAC;;;;;qBAGkB,CAAC;qBAA4C,CAAC;;;;;;;;;qBAI/B,CAAC;6BAAoD,CAAC;;sBAClC,CAAC;;;;;qBAQzC,CAAC;qBAEZ,CAAC;;;;;;;;;qBAWD,CAAC;6BAEK,CAAC;;;;;;;;;;;;;kBAuBH,CAAA;mBAGE,CAAC;gBACkB,CAAC;gBAEzB,CAAC;uBAEH,CAAF;iBACU,CAAC;oBACS,CAAC;oBAER,CAAC;qBAEZ,CAAF;;kBAC0B,CAAC;mBAEvB,CAAC;gBACmB,CAAC;gBAGlB,CAAC;uBAEe,CAAC;iBACC,CAAC;oBAIrB,CAAA;oBAEgB,CAAC;qBAET,CAAC;;;;;;gBAMZ,CAAD;sBAA0B,CAAC;;;;;qBAOR,CAAC;qBAGjB,CAAC;;;;;;;;;qBAaoB,CAAC;6BAEd,CAAC;;mBAGF,CAAC;kBACI,CAAC;mBAEL,CAAC;gBAEK,CAAC;gBAEH,CAAC;uBAEV,CAAC;iBACE,CAAC;oBAEC,CAAC;oBAEV,CAAC;qBAEC,CAAC;;;;;;gBAMD,CAAC;sBAA0B,CAAC;;;;;qBAKX,CAAC;qBAA4C,CAAC;;;;;;;;;qBAGtC,CAAC;6BAE/B,CADA;;mBACO,CAAC;kBAAsB,CAAC;mBAAyC,CAAC;gBAAmD,CAAC;gBAAuC,CAAA;uBAC3I,CAAC;iBACZ,CAAC;oBACmB,CAAC;oBAA0C,CAAC;qBAG5D,CAAC;;;;;;;;;gBAEiD,CAAC;sBACjD,CAAA;;;;;qBAOK,CAAC;qBACa,CAAC;;;;;;;;;qBAI1B,CAAC;6BACC,CAAC;;mBACW,CAAC;kBAAsB,CAAC;mBACrB,CAAC;gBACF,CAAC;gBACxB,CAAC;uBAA6C,CAAC;iBAC/B,CAAC;oBAA0C,CAAC;oBACrC,CAAC;qBACR,CAAC;;;;;;;;;;;gBAG8B,CAAC;sBAC3C,CAAC;;;;;qBAG+B,CAAC;qBAClB,CAAC;;;;;;;;;qBAGgC,CAAC;6BACX,CAAC;;mBACW,CAAC;kBACtD,CAAC;mBAAyC,CAAC;gBAC/B,CAAC;gBAAsC,CAAC;uBAC/C,CAAC;iBAAuC,CAAC;oBACvD,CAAC;oBAGQ,CAAA;qBACmB,CAAC;;;;;;;;;;;;;;OA6F5B,CAAC;AAIF,eAAO,MAAM,qBAAqB;;;;;;;;aA9WtB,CAAC;cAGX,CAAD;eAES,CAAC;;;aAIH,CAAC;cAEP,CAAF;eACgB,CAAC;;;;;;;;;;;;;;;;;;;aAgCd,CAAC;cACQ,CAAC;eACW,CAAC;;;;;;;;;;;;;;;;;;;aAqBE,CAAC;cAC1B,CAAC;eAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aApE/B,CAAC;cAGX,CAAD;eAES,CAAC;;;aAIH,CAAC;cAEP,CAAF;eACgB,CAAC;;;;;;;;;;;;;;;;;;;aAgCd,CAAC;cACQ,CAAC;eACW,CAAC;;;;;;;;;;;;;;;;;;;aAqBE,CAAC;cAC1B,CAAC;eAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kzBAyiB1C,CAAC;AAEF,eAAO,MAAM,kBAAkB,uBAK9B,CAAC"}
+{"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/all",
-  "version": "3.9.0",
+  "version": "3.9.1",
   "author": "HIDIVE Lab at HMS",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -17,38 +17,38 @@
   ],
   "dependencies": {
     "zod": "^3.21.4",
-    "@vitessce/styles": "3.9.0",
-    "@vitessce/abstract": "3.9.0",
-    "@vitessce/constants-internal": "3.9.0",
-    "@vitessce/csv": "3.9.0",
-    "@vitessce/error": "3.9.0",
-    "@vitessce/description": "3.9.0",
-    "@vitessce/feature-list": "3.9.0",
-    "@vitessce/genomic-profiles": "3.9.0",
-    "@vitessce/glb": "3.9.0",
-    "@vitessce/json": "3.9.0",
-    "@vitessce/heatmap": "3.9.0",
-    "@vitessce/link-controller": "3.9.0",
-    "@vitessce/layer-controller": "3.9.0",
-    "@vitessce/layer-controller-beta": "3.9.0",
-    "@vitessce/obs-sets-manager": "3.9.0",
-    "@vitessce/ome-tiff": "3.9.0",
-    "@vitessce/scatterplot-gating": "3.9.0",
-    "@vitessce/scatterplot-embedding": "3.9.0",
-    "@vitessce/schemas": "3.9.0",
-    "@vitessce/spatial": "3.9.0",
-    "@vitessce/spatial-beta": "3.9.0",
-    "@vitessce/statistical-plots": "3.9.0",
-    "@vitessce/status": "3.9.0",
-    "@vitessce/zarr": "3.9.0",
-    "@vitessce/vit-s": "3.9.0",
-    "@vitessce/globals": "3.9.0",
-    "@vitessce/spatial-zarr": "3.9.0",
-    "@vitessce/plugins": "3.9.0",
-    "@vitessce/spatial-three": "3.9.0",
-    "@vitessce/spatial-accelerated": "3.9.0",
-    "@vitessce/biomarker-select": "3.9.0",
-    "@vitessce/neuroglancer": "3.9.0"
+    "@vitessce/styles": "3.9.1",
+    "@vitessce/abstract": "3.9.1",
+    "@vitessce/constants-internal": "3.9.1",
+    "@vitessce/error": "3.9.1",
+    "@vitessce/description": "3.9.1",
+    "@vitessce/feature-list": "3.9.1",
+    "@vitessce/genomic-profiles": "3.9.1",
+    "@vitessce/csv": "3.9.1",
+    "@vitessce/heatmap": "3.9.1",
+    "@vitessce/json": "3.9.1",
+    "@vitessce/layer-controller": "3.9.1",
+    "@vitessce/link-controller": "3.9.1",
+    "@vitessce/glb": "3.9.1",
+    "@vitessce/obs-sets-manager": "3.9.1",
+    "@vitessce/ome-tiff": "3.9.1",
+    "@vitessce/layer-controller-beta": "3.9.1",
+    "@vitessce/plugins": "3.9.1",
+    "@vitessce/scatterplot-gating": "3.9.1",
+    "@vitessce/scatterplot-embedding": "3.9.1",
+    "@vitessce/schemas": "3.9.1",
+    "@vitessce/statistical-plots": "3.9.1",
+    "@vitessce/spatial": "3.9.1",
+    "@vitessce/spatial-beta": "3.9.1",
+    "@vitessce/vit-s": "3.9.1",
+    "@vitessce/status": "3.9.1",
+    "@vitessce/zarr": "3.9.1",
+    "@vitessce/spatial-zarr": "3.9.1",
+    "@vitessce/globals": "3.9.1",
+    "@vitessce/spatial-three": "3.9.1",
+    "@vitessce/spatial-accelerated": "3.9.1",
+    "@vitessce/biomarker-select": "3.9.1",
+    "@vitessce/neuroglancer": "3.9.1"
   },
   "devDependencies": {
     "@types/react": "^18.0.28",