@vitessce/all 3.9.0 → 3.9.2

package/dist/{OrbitControls-B2DZt-9I.js → OrbitControls-DcLq7d8o.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-DKpg3n-y.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-DmKC4Wha.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-DKpg3n-y.js";
 import React__default from "react";
 var assignExports = requireAssign();
 const _Object$assign = /* @__PURE__ */ getDefaultExportFromCjs(assignExports);

package/dist/{deflate-mmlLWSqG.js → deflate-CmVftsf2.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-DKpg3n-y.js";
 class DeflateDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return inflate_1(new Uint8Array(buffer)).buffer;

package/dist/{higlass-Chx9S58D.js → higlass-BE5OHbDt.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-DKpg3n-y.js";
 var promise = {};
 var hasRequiredPromise;
 function requirePromise() {

package/dist/{index-SH4i0VjQ.js → index-4Tuk9eGd.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-DKpg3n-y.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-DcLq7d8o.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-1SLW0Iby.js"), []);
   const invalidate = useThree(({
     invalidate: invalidate2
   }) => invalidate2);

package/dist/{index-Ccs0RkVq.js → index-DKpg3n-y.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(),
@@ -72920,21 +72922,20 @@ Popper$1.Utils = (typeof window !== "undefined" ? window : global).PopperUtils;
 Popper$1.placements = placements$1;
 Popper$1.Defaults = Defaults;
 function createChainedFunction(...funcs) {
-  return funcs.reduce((acc, func) => {
-    if (func == null) {
-      return acc;
-    }
-    {
-      if (typeof func !== "function") {
-        console.error("Material-UI: Invalid Argument Type, must only provide functions, undefined, or null.");
+  return funcs.reduce(
+    (acc, func) => {
+      if (func == null) {
+        return acc;
       }
+      return function chainedFunction(...args) {
+        acc.apply(this, args);
+        func.apply(this, args);
+      };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    () => {
     }
-    return function chainedFunction(...args) {
-      acc.apply(this, args);
-      func.apply(this, args);
-    };
-  }, () => {
-  });
+  );
 }
 function setRef(ref2, value2) {
   if (typeof ref2 === "function") {
@@ -72973,7 +72974,7 @@ function flipPlacement(placement, theme) {
   }
 }
 function getAnchorEl(anchorEl) {
-  return typeof anchorEl === "function" ? anchorEl() : anchorEl;
+  return typeof anchorEl === "function" ? anchorEl(document.body) : anchorEl;
 }
 const useEnhancedEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
 const defaultPopperOptions = {};
@@ -73003,25 +73004,18 @@ const Popper = React.forwardRef((props, ref2) => {
     }
     if (popperRef.current) {
       popperRef.current.destroy();
-      handlePopperRefRef.current(null);
+      if (handlePopperRefRef.current) {
+        setRef(handlePopperRefRef.current, null);
+      }
     }
     const handlePopperUpdate = (data2) => {
       setPlacement(data2.placement);
     };
-    const resolvedAnchorEl = getAnchorEl(anchorEl);
-    {
-      if (resolvedAnchorEl && resolvedAnchorEl.nodeType === 1) {
-        const box = resolvedAnchorEl.getBoundingClientRect();
-        if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
-          console.warn([
-            "Material-UI: The `anchorEl` prop provided to the component is invalid.",
-            "The anchor element should be part of the document layout.",
-            "Make sure the element is present in the document or that it's not display none."
-          ].join("\n"));
-        }
-      }
+    const anchorElement = getAnchorEl(anchorEl);
+    if (!anchorElement) {
+      return;
     }
-    const popper2 = new Popper$1(getAnchorEl(anchorEl), tooltipRef.current, {
+    const popper2 = new Popper$1(anchorElement, tooltipRef.current, {
       placement: rtlPlacement,
       ...popperOptions,
       modifiers: {
@@ -73039,7 +73033,9 @@ const Popper = React.forwardRef((props, ref2) => {
       onCreate: createChainedFunction(handlePopperUpdate, popperOptions.onCreate),
       onUpdate: createChainedFunction(handlePopperUpdate, popperOptions.onUpdate)
     });
-    handlePopperRefRef.current(popper2);
+    if (handlePopperRefRef.current) {
+      setRef(handlePopperRefRef.current, popper2);
+    }
   }, [anchorEl, disablePortal, modifiers2, open2, rtlPlacement, popperOptions]);
   const handleRef = React.useCallback((node2) => {
     setRef(ownRef, node2);
@@ -73053,7 +73049,9 @@ const Popper = React.forwardRef((props, ref2) => {
       return;
     }
     popperRef.current.destroy();
-    handlePopperRefRef.current(null);
+    if (handlePopperRefRef.current) {
+      setRef(handlePopperRefRef.current, null);
+    }
   };
   const handleExited = () => {
     setExited(true);
@@ -73084,7 +73082,7 @@ const Popper = React.forwardRef((props, ref2) => {
     // Fix Popper.js display issue
     top: 0,
     left: 0,
-    display: !open2 && keepMounted && !transition3 ? "none" : null,
+    display: !open2 && keepMounted && !transition3 ? "none" : void 0,
     ...style2
   }, children: typeof children3 === "function" ? children3(childProps) : children3 }) });
 });
@@ -73099,7 +73097,7 @@ function ScopedGlobalStyles(props) {
   const component = useMemo$1(() => {
     const computedStyles = prependParentClassName(styles2, parentClassName);
     return jsxRuntimeExports.jsx(GlobalStyles$3, { styles: computedStyles });
-  }, [parentClassName]);
+  }, [parentClassName, styles2]);
   return component;
 }
 function ok$1() {
@@ -209140,22 +209138,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-QxVylWDO.js").then((m2) => m2.default));
+addDecoder(5, () => import("./lzw-CMvKxrGF.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-DeFocpVz.js").then((m2) => m2.default));
+addDecoder([8, 32946], () => import("./deflate-CmVftsf2.js").then((m2) => m2.default));
+addDecoder(32773, () => import("./packbits-Crf3i8qg.js").then((m2) => m2.default));
 addDecoder(
   34887,
-  () => import("./lerc-cm5d7rjy.js").then(async (m2) => {
+  () => import("./lerc-BCstSar4.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-DJBIWr5d.js").then((m2) => m2.default));
 function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
   return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
 }
@@ -252454,21 +252452,18 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
         };
       }
     }
-    const isStaticColor = obsColorEncoding === "spatialLayerColor";
-    const getMoleculeColor = (object2, { data: data2, index: index2, target: target2 }) => {
-      const obsId = data2.src.obsIndex[index2];
-      if (data2.src.obsLabelsMap && data2.src.uniqueObsLabels && data2.src.PALETTE) {
-        const obsLabel = data2.src.obsLabelsMap.get(obsId);
-        const labelIndex = data2.src.uniqueObsLabels.indexOf(obsLabel);
-        target2[0] = data2.src.PALETTE[labelIndex % data2.src.PALETTE.length]?.[0];
-        target2[1] = data2.src.PALETTE[labelIndex % data2.src.PALETTE.length]?.[1];
-        target2[2] = data2.src.PALETTE[labelIndex % data2.src.PALETTE.length]?.[2];
-      }
-      return target2;
-    };
-    const { obsPointsModelMatrix, obsPoints, obsPointsTilingType, loadPointsInRect } = this.obsPointsData?.[layerScope]?.src ?? {};
+    const {
+      obsPointsModelMatrix,
+      obsPoints,
+      // featureIndices: obsPointsFeatureIndices,
+      obsPointsTilingType,
+      loadPointsInRect
+    } = this.obsPointsData?.[layerScope]?.src ?? {};
     obsPoints?.shape?.[0] === 3;
     const modelMatrix2 = obsPointsModelMatrix?.clone();
+    const hasFeatureIndicesMinMax = !showUnselected && Array.isArray(featureIndices) && featureIndices.length === 1;
+    const FILTER_PLACEHOLDER = 0;
+    const featureIndicesMinMax = hasFeatureIndicesMinMax ? [featureIndices[0], featureIndices[0]] : [FILTER_PLACEHOLDER, FILTER_PLACEHOLDER];
     if (obsPointsTilingType === "tiled") {
       return new TileLayer({
         id: `Tiled-${POINT_LAYER_PREFIX}${layerScope}`,
@@ -252519,9 +252514,6 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
         renderSubLayers: (subLayerProps) => {
           const { bbox: bbox2, content: tileData } = subLayerProps.tile;
           const { left: left2, top: top2, right: right2, bottom: bottom2 } = bbox2;
-          const hasFeatureIndicesMinMax = !showUnselected && Array.isArray(featureIndices) && featureIndices.length === 1;
-          const FILTER_PLACEHOLDER = 0;
-          const featureIndicesMinMax = hasFeatureIndicesMinMax ? [featureIndices[0], featureIndices[0]] : [FILTER_PLACEHOLDER, FILTER_PLACEHOLDER];
           return new ScatterplotLayer(subLayerProps, {
             bounds: [left2, top2, right2, bottom2],
             data: tileData,
@@ -252598,26 +252590,44 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
       pickable: true,
       autoHighlight: AUTO_HIGHLIGHT,
-      radiusMaxPixels: 3,
       opacity: spatialLayerOpacity,
       visible: spatialLayerVisible,
       modelMatrix: modelMatrix2,
-      getRadius: 300,
+      getRadius: 5,
+      radiusMaxPixels: 3,
       getPosition: (object2, { data: data2, index: index2, target: target2 }) => {
         target2[0] = data2.src.obsPoints.data[0][index2];
         target2[1] = data2.src.obsPoints.data[1][index2];
         target2[2] = 0;
         return target2;
       },
-      getLineColor: isStaticColor ? staticColor : getMoleculeColor,
-      getFillColor: isStaticColor ? staticColor : getMoleculeColor,
+      getFillColor,
       onHover: (info2) => delegateHover(info2, "point", layerScope),
+      // Use GPU filtering to filter to only the points in the tile bounding box,
+      // since the row groups may contain points from other tiles.
+      // Note: this can be improved using filterCategories,
+      // but it is not available until post-v9 deck.gl/extensions.
+      filterRange: [featureIndicesMinMax],
+      getFilterValue: hasFeatureIndicesMinMax ? (object2, { data: data2, index: index2 }) => [
+        data2.src.featureIndices[index2]
+      ] : (object2, { data: data2, index: index2 }) => [
+        FILTER_PLACEHOLDER
+      ],
+      extensions: [
+        new DataFilterExtension({ filterSize: 1 })
+      ],
       updateTriggers: {
-        getRadius: [],
-        getFillColor: [obsColorEncoding, staticColor],
-        getLineColor: [obsColorEncoding, staticColor]
-      },
-      ...{}
+        getFillColor: [
+          showUnselected,
+          featureColor,
+          obsColorEncoding,
+          spatialLayerColor,
+          featureSelection,
+          hasMultipleFeaturesSelected
+        ],
+        getFilterValue: [hasFeatureIndicesMinMax, showUnselected, featureSelection],
+        filterRange: [hasFeatureIndicesMinMax, showUnselected, featureSelection]
+      }
     });
   }
   createSelectionLayer() {
@@ -253156,8 +253166,8 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
     this.obsSegmentationsLayers = this.createSegmentationLayers();
   }
   onUpdatePointsData(layerScope) {
-    const { obsPoints, pointMultiObsLabels } = this.props;
-    const { obsIndex, obsPoints: layerObsPoints, obsPointsModelMatrix, loadPointsInRect, obsPointsTilingType } = obsPoints?.[layerScope] || {};
+    const { obsPoints, pointMultiObsLabels, pointMatrixIndices } = this.props;
+    const { obsIndex, obsPoints: layerObsPoints, featureIds: layerObsPointsFeatureIds, obsPointsModelMatrix, loadPointsInRect, obsPointsTilingType } = obsPoints?.[layerScope] || {};
     const { obsIndex: obsLabelsIndex, obsLabels } = pointMultiObsLabels?.[layerScope] || {};
     if (obsPointsTilingType === "tiled") {
       this.obsPointsData[layerScope] = {
@@ -253165,6 +253175,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
           obsPointsTilingType,
           obsIndex: null,
           obsPoints: null,
+          featureIndices: null,
           obsPointsModelMatrix,
           obsLabelsMap: null,
           uniqueObsLabels: null,
@@ -253177,11 +253188,17 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       if (layerObsPoints) {
         const getCellCoords = makeDefaultGetObsCoords(layerObsPoints);
         this.obsPointsQuadTree[layerScope] = createQuadTree(layerObsPoints, getCellCoords);
+        let pointFeatureIndex = pointMatrixIndices?.[layerScope]?.featureIndex;
+        if (!pointFeatureIndex) {
+          pointFeatureIndex = Array.from(new Set(layerObsPointsFeatureIds));
+        }
+        const featureIndices = layerObsPointsFeatureIds.map((featureId2) => pointFeatureIndex?.indexOf(featureId2));
         this.obsPointsData[layerScope] = {
           src: {
             obsPointsTilingType,
             obsIndex,
             obsPoints: layerObsPoints,
+            featureIndices,
             obsPointsModelMatrix,
             obsLabelsMap: null,
             uniqueObsLabels: null,
@@ -253394,7 +253411,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       forceUpdate = true;
     } else {
       this.props.pointLayerScopes.forEach((layerScope) => {
-        if (shallowDiffByLayer("obsPoints", layerScope) || shallowDiffByLayer("pointMultiObsLabels", layerScope)) {
+        if (shallowDiffByLayer("obsPoints", layerScope) || shallowDiffByLayer("pointMultiObsLabels", layerScope) || shallowDiffByLayer("pointMatrixIndices", layerScope)) {
           this.onUpdatePointsData(layerScope);
           forceUpdate = true;
         }
@@ -253559,12 +253576,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-4Tuk9eGd.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-txFb0D-X.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 +267059,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-BE5OHbDt.js");
   return { default: HiGlassComponent };
 });
 const HG_SIZE = 800;
@@ -269989,7 +270006,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-DmKC4Wha.js"));
 function createWorker() {
   return new WorkerFactory();
 }
@@ -356075,6 +356092,9 @@ class AnnDataSource extends ZarrDataSource {
   async getFlatArrDecompressed(path2) {
     const { storeRoot } = this;
     const arr = await open$1(storeRoot.resolve(path2), { kind: "array" });
+    if (arr.shape[0] === 0) {
+      return [];
+    }
     const data2 = await get$c(arr);
     if (data2.data?.[Symbol.iterator]) {
       return (
@@ -358403,12 +358423,31 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
     this.locations = locations;
     return this.locations;
   }
-  async loadPointsInRect(bounds2, signal) {
+  /**
+     * Class method for loading the feature index column for points.
+     * @returns {Promise} A promise for a column array of integers.
+     */
+  async loadPointsFeatureIds() {
     const { path: path2 } = this.options;
+    if (this.locationsFeatureIndex) {
+      return this.locationsFeatureIndex;
+    }
+    let locationsFeatureIndex;
+    const formatVersion = await this.dataSource.getPointsFormatVersion(path2);
+    if (formatVersion === "0.1") {
+      locationsFeatureIndex = await this.dataSource.loadPointsFeatureIds(path2);
+    } else {
+      throw new UnknownSpatialDataFormatError("Only points format version 0.1 is supported.");
+    }
+    this.locationsFeatureIndex = locationsFeatureIndex;
+    return this.locationsFeatureIndex;
+  }
+  async loadPointsInRect(bounds2, signal) {
+    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 +358466,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;
@@ -358463,23 +358504,19 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
     };
     let obsIndex = null;
     let obsPoints = null;
-    const featureIndices = null;
+    let featureIds = null;
     if (!supportsTiling) {
-      [obsIndex, obsPoints] = await Promise.all([
+      [obsIndex, obsPoints, featureIds] = await Promise.all([
         this.loadObsIndex(),
-        this.loadPoints()
+        this.loadPoints(),
+        this.loadPointsFeatureIds()
       ]);
     }
     return new LoaderResult({
-      /* obsIndex: ["1"], // TEMP
-      obsPoints: { // TEMP
-        shape: [2, 1],
-        data: [[0], [0]],
-      }, */
       // These will be null if tiling is supported.
       obsIndex,
       obsPoints,
-      featureIndices,
+      featureIds,
       obsPointsModelMatrix: modelMatrix2,
       // Return 'tiled' if the morton_code_2d column
       // and bounding_box metadata are present,
@@ -368283,7 +368320,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 +368343,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 +368366,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 +368694,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 +368706,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 +368726,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 +368751,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 +368765,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`);
       }
@@ -374881,11 +374920,10 @@ class SpatialDataPointsSource extends SpatialDataTableSource {
   async loadPoints(elementPath) {
     const parquetPath = getParquetPath(elementPath);
     const zattrs = await this.loadSpatialDataElementAttrs(elementPath);
-    const { axes, spatialdata_attrs: spatialDataAttrs } = zattrs;
+    const { axes } = zattrs;
     const normAxes = normalizeAxes(axes);
     const axisNames = normAxes.map((axis2) => axis2.name);
-    const { feature_key: featureKey } = spatialDataAttrs;
-    const columnNames = [...axisNames, featureKey].filter(Boolean);
+    const columnNames = axisNames.filter(Boolean);
     const arrowTable = await this.loadParquetTable(parquetPath, columnNames);
     const axisColumnArrs = axisNames.map((name2) => {
       const column2 = arrowTable.getChild(name2);
@@ -374899,6 +374937,30 @@ class SpatialDataPointsSource extends SpatialDataTableSource {
       data: axisColumnArrs
     };
   }
+  /**
+   *
+   * @param {string} elementPath The path to the points element,
+   * like "points/element_name".
+   * @param {string|undefined} featureIndexColumnNameFromOptions The name
+   * of the feature index column specified in the file definition options, if any.
+   * @returns {Promise<number[]>} A promise for a zarr array containing the data.
+   */
+  async loadPointsFeatureIds(elementPath) {
+    const parquetPath = getParquetPath(elementPath);
+    const zattrs = await this.loadSpatialDataElementAttrs(elementPath);
+    const { spatialdata_attrs: spatialDataAttrs } = zattrs;
+    const { feature_key: featureKey } = spatialDataAttrs;
+    const columnNames = [featureKey];
+    const arrowTable = await this.loadParquetTable(parquetPath, columnNames);
+    const axisColumnArrs = columnNames.map((name2) => {
+      const column2 = arrowTable.getChild(name2);
+      if (!column2) {
+        throw new Error(`Column "${name2}" not found in the arrow table.`);
+      }
+      return column2.toArray();
+    });
+    return axisColumnArrs[0];
+  }
   /**
    *
    * @param {string} elementPath
@@ -374908,23 +374970,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-gdPd0Ws9.js → index-txFb0D-X.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-DKpg3n-y.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-DcLq7d8o.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-DKpg3n-y.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-DeFocpVz.js}

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

package/dist/{lerc-cm5d7rjy.js → lerc-BCstSar4.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-DKpg3n-y.js";
 var LercDecode = { exports: {} };
 var hasRequiredLercDecode;
 function requireLercDecode() {

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

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

package/dist/{packbits-BaMXgBB6.js → packbits-Crf3i8qg.js}

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

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

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

package/dist/{troika-three-text.esm-D_LuNiSc.js → troika-three-text.esm-1SLW0Iby.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-DKpg3n-y.js";
 function workerBootstrap() {
   var modules = /* @__PURE__ */ Object.create(null);
   function registerModule(ref, callback) {

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

@@ -1,4 +1,4 @@
-import { aX as BaseDecoder } from "./index-Ccs0RkVq.js";
+import { aX as BaseDecoder } from "./index-DKpg3n-y.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":"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"}
+{"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.2",
   "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/constants-internal": "3.9.2",
+    "@vitessce/abstract": "3.9.2",
+    "@vitessce/styles": "3.9.2",
+    "@vitessce/error": "3.9.2",
+    "@vitessce/csv": "3.9.2",
+    "@vitessce/description": "3.9.2",
+    "@vitessce/genomic-profiles": "3.9.2",
+    "@vitessce/feature-list": "3.9.2",
+    "@vitessce/heatmap": "3.9.2",
+    "@vitessce/glb": "3.9.2",
+    "@vitessce/json": "3.9.2",
+    "@vitessce/layer-controller": "3.9.2",
+    "@vitessce/layer-controller-beta": "3.9.2",
+    "@vitessce/plugins": "3.9.2",
+    "@vitessce/obs-sets-manager": "3.9.2",
+    "@vitessce/ome-tiff": "3.9.2",
+    "@vitessce/link-controller": "3.9.2",
+    "@vitessce/scatterplot-gating": "3.9.2",
+    "@vitessce/scatterplot-embedding": "3.9.2",
+    "@vitessce/spatial": "3.9.2",
+    "@vitessce/schemas": "3.9.2",
+    "@vitessce/statistical-plots": "3.9.2",
+    "@vitessce/status": "3.9.2",
+    "@vitessce/vit-s": "3.9.2",
+    "@vitessce/globals": "3.9.2",
+    "@vitessce/spatial-beta": "3.9.2",
+    "@vitessce/spatial-zarr": "3.9.2",
+    "@vitessce/spatial-three": "3.9.2",
+    "@vitessce/zarr": "3.9.2",
+    "@vitessce/spatial-accelerated": "3.9.2",
+    "@vitessce/biomarker-select": "3.9.2",
+    "@vitessce/neuroglancer": "3.9.2"
   },
   "devDependencies": {
     "@types/react": "^18.0.28",