@vitessce/all 3.9.9 → 3.9.11

package/dist/{OrbitControls-22a8bk04.js → OrbitControls-DSciBy3x.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-DyvHlPKD.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-CoPFL-Jj.js";
 import * as React from "react";
 import React__default, { useReducer, useRef, useEffect, useLayoutEffect, useDebugValue, useState, useMemo } from "react";
 var constants = { exports: {} };

package/dist/{ReactNeuroglancer-R9DY-SSe.js → ReactNeuroglancer-YYn0SUi6.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-DyvHlPKD.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-CoPFL-Jj.js";
 import React__default from "react";
 var assignExports = requireAssign();
 const _Object$assign = /* @__PURE__ */ getDefaultExportFromCjs(assignExports);

package/dist/{deflate-LlDFQTvY.js → deflate-BlzReVld.js}

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

package/dist/{higlass-BsC0wgvT.js → higlass-BNmPmXUj.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-DyvHlPKD.js";
+import { a_ as commonjsGlobal$1, a$ as requireObjectAssign, aG as getDefaultExportFromCjs$1, b0 as earcut } from "./index-CoPFL-Jj.js";
 var promise = {};
 var hasRequiredPromise;
 function requirePromise() {

package/dist/{index-DpX5nUsD.js → index-BMOfsV8_.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-DyvHlPKD.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-CoPFL-Jj.js";
 import { useRef, useState, useMemo, useEffect, Suspense } from "react";
-import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-22a8bk04.js";
+import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-DSciBy3x.js";
 const LogLevel = {
   INFO: "info",
   WARN: "warn",

package/dist/{index-DyvHlPKD.js → index-CoPFL-Jj.js}

@@ -9263,6 +9263,7 @@ const FileType$1 = {
   OBS_LABELS_MUDATA_ZARR: "obsLabels.mudata.zarr",
   FEATURE_LABELS_MUDATA_ZARR: "featureLabels.mudata.zarr",
   GENOMIC_PROFILES_ZARR: "genomic-profiles.zarr",
+  GENOMIC_PROFILES_ZARR_ZIP: "genomic-profiles.zarr.zip",
   NEIGHBORHOODS_JSON: "neighborhoods.json",
   // OME-TIFF
   IMAGE_OME_TIFF: "image.ome-tiff",
@@ -9557,6 +9558,7 @@ const ViewHelpMapping = {
   [FileType$1.OBS_LABELS_MOLECULES_JSON]: DataType$3.OBS_LABELS,
   // For old file types
   [FileType$1.GENOMIC_PROFILES_ZARR]: DataType$3.GENOMIC_PROFILES,
+  [FileType$1.GENOMIC_PROFILES_ZARR_ZIP]: DataType$3.GENOMIC_PROFILES,
   [FileType$1.NEIGHBORHOODS_JSON]: DataType$3.NEIGHBORHOODS
 });
 ({
@@ -9721,6 +9723,10 @@ const ALT_ZARR_STORE_TYPES = {
   },
   [FileType$1.OBS_EMBEDDING_SPATIALDATA_ZARR]: {
     zip: FileType$1.OBS_EMBEDDING_SPATIALDATA_ZARR_ZIP
+  },
+  // For genomic profiles:
+  [FileType$1.GENOMIC_PROFILES_ZARR]: {
+    zip: FileType$1.GENOMIC_PROFILES_ZARR_ZIP
   }
 };
 [
@@ -210359,22 +210365,22 @@ async function getDecoder(fileDirectory) {
   const Decoder = await importFn();
   return new Decoder(fileDirectory);
 }
-addDecoder([void 0, 1], () => import("./raw-Q9iDQlA8.js").then((m2) => m2.default));
-addDecoder(5, () => import("./lzw-Cbew-c41.js").then((m2) => m2.default));
+addDecoder([void 0, 1], () => import("./raw-B0bXY73t.js").then((m2) => m2.default));
+addDecoder(5, () => import("./lzw-BDf8r2uF.js").then((m2) => m2.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-CIYI21V8.js").then((m2) => m2.default));
-addDecoder([8, 32946], () => import("./deflate-LlDFQTvY.js").then((m2) => m2.default));
-addDecoder(32773, () => import("./packbits-QQ3Kq95W.js").then((m2) => m2.default));
+addDecoder(7, () => import("./jpeg-ZD-cMTI7.js").then((m2) => m2.default));
+addDecoder([8, 32946], () => import("./deflate-BlzReVld.js").then((m2) => m2.default));
+addDecoder(32773, () => import("./packbits-BiHBxbwP.js").then((m2) => m2.default));
 addDecoder(
   34887,
-  () => import("./lerc-BKoJuTs1.js").then(async (m2) => {
+  () => import("./lerc-D5-B9wm5.js").then(async (m2) => {
     await m2.zstd.init();
     return m2;
   }).then((m2) => m2.default)
 );
-addDecoder(50001, () => import("./webimage-CVAiK7LB.js").then((m2) => m2.default));
+addDecoder(50001, () => import("./webimage-k_GfzbL-.js").then((m2) => m2.default));
 function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
   return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
 }
@@ -254873,12 +254879,12 @@ class ErrorBoundary extends React__default.Component {
   }
 }
 const LazySpatialThree = React__default.lazy(async () => {
-  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-CAfSSaWL.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-D6qJZY8C.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-DpX5nUsD.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-BMOfsV8_.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 }) }) }) }));
@@ -268585,7 +268591,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-BsC0wgvT.js");
+  const { HiGlassComponent } = await import("./higlass-BNmPmXUj.js");
   return { default: HiGlassComponent };
 });
 const HG_SIZE = 800;
@@ -271533,7 +271539,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-R9DY-SSe.js"));
+const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-YYn0SUi6.js"));
 function createWorker() {
   const worker = new WorkerFactory$1();
   worker.AsyncComputationWorker = WorkerFactory;
@@ -357257,7 +357263,9 @@ class OmeAutoConfig extends AbstractAutoConfig {
   // TODO: how to handle h5ad-based AnnData (since needs reference JSON file).
   // Perhaps just assume one H5AD+one JSON (or .ref.json) file correspond to each other?
   [FileType$1.SPATIALDATA_ZARR]: [".sd.zarr", ".sdata.zarr", ".spatialdata.zarr"],
-  [FileType$1.SPATIALDATA_ZARR_ZIP]: [".sd.zarr.zip", ".sdata.zarr.zip", ".spatialdata.zarr.zip"]
+  [FileType$1.SPATIALDATA_ZARR_ZIP]: [".sd.zarr.zip", ".sdata.zarr.zip", ".spatialdata.zarr.zip"],
+  [FileType$1.GENOMIC_PROFILES_ZARR]: [".multivec.zarr"],
+  [FileType$1.GENOMIC_PROFILES_ZARR_ZIP]: [".multivec.zarr.zip"]
 });
 ({
   // OME-TIFF
@@ -357283,7 +357291,9 @@ class OmeAutoConfig extends AbstractAutoConfig {
   FileType$1.IMAGE_OME_ZARR,
   FileType$1.IMAGE_OME_ZARR_ZIP,
   FileType$1.OBS_SEGMENTATIONS_OME_ZARR,
-  FileType$1.OBS_SEGMENTATIONS_OME_ZARR_ZIP
+  FileType$1.OBS_SEGMENTATIONS_OME_ZARR_ZIP,
+  FileType$1.GENOMIC_PROFILES_ZARR,
+  FileType$1.GENOMIC_PROFILES_ZARR_ZIP
 ];
 class ObsSpotsCsvLoader extends CsvLoader {
   loadFromCache(data2) {
@@ -359377,16 +359387,25 @@ let FeatureStatsAnndataLoader$1 = class FeatureStatsAnndataLoader extends Abstra
     return this.dataSource.loadDataFrameIndex(dfPath);
   }
   async loadDataFrame(dfPath) {
-    const [featureId2, featureFoldChange, featureSignificance] = await Promise.all([
-      this.loadFeatureNames(dfPath),
-      this.loadFoldChanges(dfPath),
-      this.loadSignificances(dfPath)
-    ]);
-    return {
-      featureId: featureId2,
-      featureFoldChange,
-      featureSignificance
-    };
+    try {
+      const [featureId2, featureFoldChange, featureSignificance] = await Promise.all([
+        this.loadFeatureNames(dfPath),
+        this.loadFoldChanges(dfPath),
+        this.loadSignificances(dfPath)
+      ]);
+      return {
+        featureId: featureId2,
+        featureFoldChange,
+        featureSignificance
+      };
+    } catch (e3) {
+      log$b.warn("Dataframe not found at", dfPath);
+      return {
+        featureId: [],
+        featureFoldChange: [],
+        featureSignificance: []
+      };
+    }
   }
   /**
    *
@@ -359413,7 +359432,7 @@ let FeatureStatsAnndataLoader$1 = class FeatureStatsAnndataLoader extends Abstra
    * @returns {Promise<LoaderResult<FeatureStatsData>>}
    */
   async loadMulti(volcanoOptions) {
-    const { analysisType: targetAnalysisType = "rank_genes_groups" } = this.options;
+    const { analysisType: targetAnalysisType = "pydeseq2" } = this.options;
     const { sampleSetSelection, obsSetSelection } = volcanoOptions || {};
     const rawObsSetSelection = obsSetSelection;
     const rawSampleSetSelection = sampleSetSelection;
@@ -360391,7 +360410,7 @@ class SpatialDataObsSpotsLoader extends AbstractTwoStepLoader {
       const formatVersion = await this.dataSource.getShapesFormatVersion(path2);
       if (formatVersion === "0.1") {
         locations = await this.dataSource.loadNumericForDims(getCoordsPath(path2), [0, 1]);
-      } else if (formatVersion === "0.2") {
+      } else if (formatVersion === "0.2" || formatVersion === "0.3") {
         locations = await this.dataSource.loadCircleShapes(getGeometryPath$1(path2));
       }
       this.locations = locations;
@@ -360654,9 +360673,7 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
       this.dataSource.supportsLoadPointsInRect(path2, featureIndexColumnName, mortonCodeColumn)
     ]);
     const isSupportedVersion = formatVersion === "0.1" || formatVersion === "0.2";
-    const boundingBox = zattrs?.bounding_box;
-    const hasBoundingBox2D = typeof boundingBox?.x_max === "number" && typeof boundingBox?.x_min === "number" && typeof boundingBox?.y_max === "number" && typeof boundingBox?.y_min === "number";
-    return isSupportedVersion && hasBoundingBox2D && hasRequiredColumnsAndRowGroupSize;
+    return isSupportedVersion && hasRequiredColumnsAndRowGroupSize;
   }
   async load() {
     const [modelMatrix2, supportsTiling] = await Promise.all([
@@ -360694,7 +360711,7 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
       featureIds,
       obsPointsModelMatrix: modelMatrix2,
       // Return 'tiled' if the morton_code_2d column
-      // and bounding_box metadata are present,
+      // is present,
       // and the row group size is small enough.
       // Otherwise, return 'full'.
       obsPointsTilingType: supportsTiling ? "tiled" : "full",
@@ -370203,6 +370220,7 @@ function sdataMortonQueryRectAux(boundingBox, origRect) {
   const mortonIntervals = zcoverRectangle(normRect[0][0], normRect[0][1], normRect[1][0], normRect[1][1], 16, null, true);
   return mortonIntervals;
 }
+const MORTON_CODE_EXTREME_VALUE_INDICATOR = 0;
 async function getParquetModule() {
   const module2 = await import(
     /* webpackIgnore: true */
@@ -370328,22 +370346,22 @@ async function _loadParquetMetadataByPart({ queryClient, store }, parquetPath) {
         } catch (error2) {
           if (error2.message.includes("Failed to load parquet footerLength")) {
             numParts = partIndex;
+            log$b.info(`Found ${numParts} parts for parquet path ${parquetPath}; An above "Failed to load parquet footerLength" error is expected for the subsequent part.`);
           }
         }
       } while (numParts === void 0);
+      const numRows = allMetadata.map((part) => part.metadata.fileMetadata().numRows());
+      const numRowGroups = allMetadata.map((part) => part.metadata.numRowGroups());
+      const numRowsPerGroup = allMetadata.map((part) => part.metadata.rowGroup(0).numRows());
       const metadata2 = {
-        numRows: 0,
-        numRowGroups: 0,
-        numRowsPerGroup: 0,
-        schema: null
-      };
-      if (allMetadata.length > 0) {
-        const firstPart = allMetadata[0];
-        metadata2.numRows = allMetadata.reduce((sum2, part) => sum2 + part.metadata.fileMetadata().numRows(), 0);
-        metadata2.numRowGroups = allMetadata.reduce((sum2, part) => sum2 + part.metadata.numRowGroups(), 0);
-        metadata2.numRowsPerGroup = firstPart.metadata.rowGroup(0).numRows();
-        metadata2.schema = firstPart.schema.schema;
-      }
+        totalNumRows: numRows.reduce((a2, b2) => a2 + b2, 0),
+        totalNumRowGroups: numRowGroups.reduce((a2, b2) => a2 + b2, 0),
+        // Array of count per part (length equal to numParts).
+        numRowsByPart: numRows,
+        numRowGroupsByPart: numRowGroups,
+        numRowsPerGroupByPart: numRowsPerGroup,
+        schema: allMetadata?.[0]?.schema?.schema
+      };
       const result = {
         ...metadata2,
         // TODO: extract metadata per part and rowGroup into plain objects that match the hyparquet parquetMetadata() return value?
@@ -370367,8 +370385,8 @@ async function _loadParquetRowGroupByGroupIndex({ queryClient, store }, parquetP
       const store2 = ctx.meta?.store;
       const { readParquetRowGroup } = await _getParquetModule({ queryClient: queryClient2 });
       const allMetadata = await _loadParquetMetadataByPart({ queryClient: queryClient2, store: store2 }, parquetPath);
-      if (rowGroupIndex < 0 || rowGroupIndex >= allMetadata.numRowGroups) {
-        throw new Error(`Row group index ${rowGroupIndex} is out of bounds for parquet table with ${allMetadata.numRowGroups} row groups.`);
+      if (rowGroupIndex < 0 || rowGroupIndex >= allMetadata.totalNumRowGroups) {
+        throw new Error(`Row group index ${rowGroupIndex} is out of bounds for parquet table with ${allMetadata.totalNumRowGroups} row groups.`);
       }
       let partIndex;
       let cumulativeRowGroups = 0;
@@ -370478,9 +370496,9 @@ async function _bisectRowGroupsRight({ queryClient, store }, parquetPath, column
       );
       const store2 = ctx.meta?.store;
       const allMetadata = await _loadParquetMetadataByPart({ queryClient: queryClient2, store: store2 }, parquetPath);
-      const { numRowGroups } = allMetadata;
+      const { totalNumRowGroups } = allMetadata;
       let lo = 0;
-      let hi = numRowGroups;
+      let hi = totalNumRowGroups;
       while (lo < hi) {
         const cachedInRange = await getCachedInRange(queryClient2, parquetPath, columnName, lo, hi);
         const betterLo = cachedInRange.slice().reverse().find((c2) => c2.index > lo && targetValue >= c2.max);
@@ -370883,11 +370901,12 @@ class SpatialDataTableSource extends AnnDataSource {
     const { queryClient } = this;
     const { store } = this.storeRoot;
     const allMetadata = await _loadParquetMetadataByPart({ queryClient, store }, parquetPath);
-    const { numRowsPerGroup } = allMetadata;
-    const numRowsTotal = allMetadata.numRows;
-    if (numRowsPerGroup >= 1e5) {
+    const { numRowsPerGroupByPart } = allMetadata;
+    const numRowsTotal = allMetadata.totalNumRows;
+    const maxNumRowsPerGroup = Math.max(...numRowsPerGroupByPart);
+    if (maxNumRowsPerGroup >= 1e5) {
       if (numRowsTotal > 5e6) {
-        throw new Error(`The Parquet table at ${parquetPath} has ${numRowsTotal} total rows, which necessitates tiled loading, but it was not possible because the row group size is too large (${numRowsPerGroup}). See the Vitessce documentation at Data Troubleshooting -> Points for more details.`);
+        throw new Error(`The Parquet table at ${parquetPath} has ${numRowsTotal} total rows, which necessitates tiled loading, but it was not possible because the row group size is too large (${maxNumRowsPerGroup}). See the Vitessce documentation at Data Troubleshooting -> Points for more details.`);
       }
       return false;
     }
@@ -370911,7 +370930,7 @@ class SpatialDataTableSource extends AnnDataSource {
    * @param {string[]|undefined} columns An optional list of column names to load.
    * @returns
    */
-  async loadParquetTableInRect(parquetPath, tileBbox, allPointsBbox, signal, featureIndexColumnName, mortonCodeColumn) {
+  async loadParquetTableInRect(parquetPath, tileBbox, signal, featureIndexColumnName, mortonCodeColumn) {
     const { queryClient } = this;
     const { store } = this.storeRoot;
     const mortonCodeColumnName = mortonCodeColumn ?? "morton_code_2d";
@@ -370936,15 +370955,46 @@ class SpatialDataTableSource extends AnnDataSource {
     } else {
       tileBboxes = [tileBbox];
     }
+    const firstRowGroupTable = await _loadParquetRowGroupByGroupIndex({ queryClient, store }, parquetPath, 0);
+    const xColumnForBoundingBox = firstRowGroupTable.getChild("x");
+    const yColumnForBoundingBox = firstRowGroupTable.getChild("y");
+    const mortonCodeColumnForBoundingBox = firstRowGroupTable.getChild(mortonCodeColumnName);
+    const boundingBoxMaxNumRows = Math.min(4, firstRowGroupTable.numRows);
+    const firstMortonCodes = range$e(boundingBoxMaxNumRows).map((i2) => mortonCodeColumnForBoundingBox.get(i2));
+    const boundingBoxNumRows = firstMortonCodes.filter((code2) => code2 === MORTON_CODE_EXTREME_VALUE_INDICATOR).length;
+    const boundingBoxXValues = range$e(boundingBoxNumRows).map((i2) => xColumnForBoundingBox.get(i2));
+    const boundingBoxYValues = range$e(boundingBoxNumRows).map((i2) => yColumnForBoundingBox.get(i2));
+    const xMin = Math.min(...boundingBoxXValues);
+    const xMax = Math.max(...boundingBoxXValues);
+    const yMin = Math.min(...boundingBoxYValues);
+    const yMax = Math.max(...boundingBoxYValues);
+    const allPointsBbox = {
+      x_min: xMin,
+      x_max: xMax,
+      y_min: yMin,
+      y_max: yMax
+    };
     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;
-    const numRowGroups = uniqueCoveredRowGroupIndices.length;
-    const totalNumRows = numRowsPerGroup * numRowGroups;
-    const xArr = new Float32Array(totalNumRows);
-    const yArr = new Float32Array(totalNumRows);
-    const featureIndexArr = new Uint32Array(totalNumRows);
+    const { numRowsPerGroupByPart, numRowGroupsByPart } = allMetadata;
+    const rowGroupIToNumRows = (rowGroupI) => {
+      let currPartIndex = 0;
+      let prevTotalRowGroupCount = 0;
+      for (let partIndex = 0; partIndex < numRowGroupsByPart.length; partIndex++) {
+        const numRowGroupsInPart = numRowGroupsByPart[partIndex];
+        if (prevTotalRowGroupCount <= rowGroupI && rowGroupI < prevTotalRowGroupCount + numRowGroupsInPart) {
+          currPartIndex = partIndex;
+          break;
+        }
+        prevTotalRowGroupCount += numRowGroupsInPart;
+      }
+      return numRowsPerGroupByPart[currPartIndex];
+    };
+    const totalNumRowsToLoad = uniqueCoveredRowGroupIndices.reduce((acc, rowGroupI) => acc + rowGroupIToNumRows(rowGroupI), 0);
+    const xArr = new Float32Array(totalNumRowsToLoad);
+    const yArr = new Float32Array(totalNumRowsToLoad);
+    const featureIndexArr = new Uint32Array(totalNumRowsToLoad);
     const rowGroupTables = await Promise.all(uniqueCoveredRowGroupIndices.map(async (rowGroupIndex) => _loadParquetRowGroupByGroupIndex({ queryClient, store }, parquetPath, rowGroupIndex)));
     let rowOffset = 0;
     rowGroupTables.forEach((table2) => {
@@ -370957,7 +371007,7 @@ class SpatialDataTableSource extends AnnDataSource {
       xArr.set(xColumn.toArray(), rowOffset);
       yArr.set(yColumn.toArray(), rowOffset);
       featureIndexArr.set(featureIndexColumn.toArray(), rowOffset);
-      rowOffset += numRowsPerGroup;
+      rowOffset += table2.numRows;
     });
     return {
       data: {
@@ -370965,7 +371015,7 @@ class SpatialDataTableSource extends AnnDataSource {
         y: yArr,
         featureIndices: featureIndexArr
       },
-      shape: [3, totalNumRows]
+      shape: [3, totalNumRowsToLoad]
     };
   }
 }
@@ -376841,14 +376891,14 @@ class SpatialDataShapesSource extends SpatialDataTableSource {
   /**
    *
    * @param {string} path A path to within shapes.
-   * @returns {Promise<"0.1"|"0.2">} The format version.
+   * @returns {Promise<"0.1"|"0.2"|"0.3">} The format version.
    */
   async getShapesFormatVersion(path2) {
     const zattrs = await this.loadSpatialDataElementAttrs(path2);
     const formatVersion = zattrs.spatialdata_attrs.version;
     const geos = zattrs.spatialdata_attrs.geos || {};
     const encodingType = zattrs["encoding-type"];
-    if (encodingType !== "ngff:shapes" || !(formatVersion === "0.1" && (geos.name === "POINT" && geos.type === 0) || formatVersion === "0.2")) {
+    if (encodingType !== "ngff:shapes" || !(formatVersion === "0.1" && (geos.name === "POINT" && geos.type === 0) || formatVersion === "0.2" || formatVersion === "0.3")) {
       throw new Error(`Unexpected encoding type or version for shapes spatialdata_attrs: ${encodingType} ${formatVersion}`);
     }
     return formatVersion;
@@ -377160,16 +377210,11 @@ class SpatialDataPointsSource extends SpatialDataTableSource {
     const zattrs = await this.loadSpatialDataElementAttrs(elementPath);
     const {
       // axes,
-      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
+      spatialdata_attrs: spatialDataAttrs
     } = zattrs;
     const { feature_key: featureKey } = spatialDataAttrs;
     const featureIndexColumnName = featureIndexColumnNameFromOptions ?? `${featureKey}_codes`;
-    return this.loadParquetTableInRect(parquetPath, tileBbox, allPointsBbox, signal, featureIndexColumnName, mortonCodeColumn);
+    return this.loadParquetTableInRect(parquetPath, tileBbox, signal, featureIndexColumnName, mortonCodeColumn);
   }
   async supportsLoadPointsInRect(elementPath, featureIndexColumnName, mortonCodeColumn) {
     const parquetPath = getParquetPath(elementPath);
@@ -382727,7 +382772,8 @@ const baseFileTypes = [
   makeFileType(FileType$1.OBS_LOCATIONS_MOLECULES_JSON, DataType$3.OBS_LOCATIONS, MoleculesJsonAsObsLocationsLoader, JsonSource, z.null()),
   makeFileType(FileType$1.OBS_LABELS_MOLECULES_JSON, DataType$3.OBS_LABELS, MoleculesJsonAsObsLabelsLoader, JsonSource, z.null()),
   makeFileType(FileType$1.NEIGHBORHOODS_JSON, DataType$3.NEIGHBORHOODS, JsonLoader, JsonSource, z.null()),
-  makeFileType(FileType$1.GENOMIC_PROFILES_ZARR, DataType$3.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null())
+  makeFileType(FileType$1.GENOMIC_PROFILES_ZARR, DataType$3.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null()),
+  makeFileType(FileType$1.GENOMIC_PROFILES_ZARR_ZIP, DataType$3.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null())
 ];
 const baseJointFileTypes = [
   new PluginJointFileType(FileType$1.ANNDATA_ZARR, expandAnndataZarr, anndataZarrSchema),

package/dist/{index-CAfSSaWL.js → index-D6qJZY8C.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-DyvHlPKD.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-CoPFL-Jj.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-22a8bk04.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-DSciBy3x.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-CVOtVmFe.js"), []);
+  } = suspend(async () => import("./troika-three-text.esm-U6CVqbh4.js"), []);
   const invalidate = useThree(({
     invalidate: invalidate2
   }) => invalidate2);

package/dist/index.js

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

package/dist/{jpeg-CIYI21V8.js → jpeg-ZD-cMTI7.js}

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

package/dist/{lerc-BKoJuTs1.js → lerc-D5-B9wm5.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-DyvHlPKD.js";
+import { aG as getDefaultExportFromCjs, aX as BaseDecoder, aY as LercParameters, aZ as LercAddCompression } from "./index-CoPFL-Jj.js";
 var LercDecode = { exports: {} };
 var hasRequiredLercDecode;
 function requireLercDecode() {

package/dist/{lzw-Cbew-c41.js → lzw-BDf8r2uF.js}

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

package/dist/{packbits-QQ3Kq95W.js → packbits-BiHBxbwP.js}

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

package/dist/{raw-Q9iDQlA8.js → raw-B0bXY73t.js}

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

package/dist/{troika-three-text.esm-CVOtVmFe.js → troika-three-text.esm-U6CVqbh4.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-DyvHlPKD.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-CoPFL-Jj.js";
 function workerBootstrap() {
   var modules = /* @__PURE__ */ Object.create(null);
   function registerModule(ref, callback) {

package/dist/{webimage-CVAiK7LB.js → webimage-k_GfzbL-.js}

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

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/dist-tsc/base-plugins.js

@@ -177,6 +177,7 @@ export const baseFileTypes = [
     makeFileType(FileType.OBS_LABELS_MOLECULES_JSON, DataType.OBS_LABELS, MoleculesJsonAsObsLabelsLoader, JsonSource, z.null()),
     makeFileType(FileType.NEIGHBORHOODS_JSON, DataType.NEIGHBORHOODS, JsonLoader, JsonSource, z.null()),
     makeFileType(FileType.GENOMIC_PROFILES_ZARR, DataType.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null()),
+    makeFileType(FileType.GENOMIC_PROFILES_ZARR_ZIP, DataType.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null()),
 ];
 export const baseJointFileTypes = [
     new PluginJointFileType(FileType.ANNDATA_ZARR, expandAnndataZarr, anndataZarrSchema),

package/package.json

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

package/src/base-plugins.ts

@@ -366,6 +366,7 @@ export const baseFileTypes = [
   makeFileType(FileType.OBS_LABELS_MOLECULES_JSON, DataType.OBS_LABELS, MoleculesJsonAsObsLabelsLoader, JsonSource, z.null()),
   makeFileType(FileType.NEIGHBORHOODS_JSON, DataType.NEIGHBORHOODS, JsonLoader, JsonSource, z.null()),
   makeFileType(FileType.GENOMIC_PROFILES_ZARR, DataType.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null()),
+  makeFileType(FileType.GENOMIC_PROFILES_ZARR_ZIP, DataType.GENOMIC_PROFILES, GenomicProfilesZarrLoader, ZarrDataSource, z.null()),
 ];
 
 export const baseJointFileTypes = [