@vitessce/launcher 3.9.4 → 3.9.6

package/dist/{index-DT1vlRPc.js → index-C_nd9lWQ.js}

@@ -11115,6 +11115,7 @@ const FileType$1 = {
   // Neuroglancer
   // Precomputed (mesh) format
   OBS_SEGMENTATIONS_NG_PRECOMPUTED: "obsSegmentations.ng-precomputed",
+  OBS_POINTS_NG_ANNOTATIONS: "obsPoints.ng-annotations",
   // New file types to support old file types:
   // - cells.json
   OBS_EMBEDDING_CELLS_JSON: "obsEmbedding.cells.json",
@@ -11321,7 +11322,7 @@ const ViewHelpMapping = {
   FEATURE_VALUE_HISTOGRAM: "The feature value histogram displays the distribution of values (e.g., expression) for the selected feature (e.g., gene).",
   DOT_PLOT: "The dot plot displays summary information about expression of the selected features (e.g., genes) for each selected observation set (e.g., cell type).",
   FEATURE_BAR_PLOT: "The feature bar plot displays one bar per observation (e.g., cell) along the x-axis, where the value of a selected feature (e.g., gene) is encoded along the y-axis.",
-  NEUROGLANCER: "The Neuroglancer view displays 3d meshes using Neuroglancer developed by Google.",
+  NEUROGLANCER: "This view displays 3D meshes and points using Neuroglancer developed by Google.",
   TREEMAP: "The treemap provides an overview of the current state of sample-level or cell-level selection and filtering.",
   VOLCANO_PLOT: "The volcano plot displays differential expression results. Each data point represents a feature (as opposed to an observation).",
   OBS_SET_COMPOSITION_BAR_PLOT: "The set composition bar plot displays the results of a compositional analysis conducted using the scCODA method (Büttner et al. 2021 Nature Communications).",
@@ -11373,6 +11374,7 @@ const ViewHelpMapping = {
   [FileType$1.FEATURE_LABELS_MUDATA_ZARR]: DataType$3.FEATURE_LABELS,
   [FileType$1.OBS_SEGMENTATIONS_GLB]: DataType$3.OBS_SEGMENTATIONS,
   [FileType$1.OBS_SEGMENTATIONS_NG_PRECOMPUTED]: DataType$3.OBS_SEGMENTATIONS,
+  [FileType$1.OBS_POINTS_NG_ANNOTATIONS]: DataType$3.OBS_POINTS,
   [FileType$1.IMAGE_SPATIALDATA_ZARR]: DataType$3.IMAGE,
   [FileType$1.LABELS_SPATIALDATA_ZARR]: DataType$3.OBS_SEGMENTATIONS,
   [FileType$1.SHAPES_SPATIALDATA_ZARR]: DataType$3.OBS_SEGMENTATIONS,
@@ -11592,6 +11594,8 @@ const ALT_ZARR_STORE_TYPES = {
 ];
 const COMPONENT_COORDINATION_TYPES = {
   [ViewType$1.NEUROGLANCER]: [
+    CoordinationType$1.META_COORDINATION_SCOPES,
+    CoordinationType$1.META_COORDINATION_SCOPES_BY,
     CoordinationType$1.DATASET,
     CoordinationType$1.SPATIAL_TARGET_X,
     CoordinationType$1.SPATIAL_TARGET_Y,
@@ -11613,7 +11617,26 @@ const COMPONENT_COORDINATION_TYPES = {
     CoordinationType$1.OBS_COLOR_ENCODING,
     CoordinationType$1.EMBEDDING_TYPE,
     CoordinationType$1.ADDITIONAL_OBS_SETS,
-    CoordinationType$1.TOOLTIPS_VISIBLE
+    CoordinationType$1.TOOLTIPS_VISIBLE,
+    CoordinationType$1.FILE_UID,
+    CoordinationType$1.IMAGE_LAYER,
+    CoordinationType$1.SEGMENTATION_LAYER,
+    CoordinationType$1.IMAGE_CHANNEL,
+    CoordinationType$1.SEGMENTATION_CHANNEL,
+    CoordinationType$1.POINT_LAYER,
+    CoordinationType$1.FEATURE_COLOR,
+    CoordinationType$1.FEATURE_FILTER_MODE,
+    CoordinationType$1.FEATURE_HIGHLIGHT,
+    CoordinationType$1.FEATURE_SELECTION,
+    CoordinationType$1.FEATURE_VALUE_COLORMAP,
+    CoordinationType$1.FEATURE_VALUE_COLORMAP_RANGE,
+    CoordinationType$1.SPATIAL_LAYER_COLOR,
+    CoordinationType$1.SPATIAL_LAYER_OPACITY,
+    CoordinationType$1.SPATIAL_LAYER_VISIBLE,
+    CoordinationType$1.SPATIAL_CHANNEL_COLOR,
+    CoordinationType$1.SPATIAL_CHANNEL_OPACITY,
+    CoordinationType$1.SPATIAL_CHANNEL_VISIBLE,
+    CoordinationType$1.LEGEND_VISIBLE
   ],
   [ViewType$1.SCATTERPLOT]: [
     CoordinationType$1.DATASET,
@@ -12720,17 +12743,26 @@ const meshGlbSchema = z.object({
   sceneScaleZ: z.number(),
   materialSide: z.enum(["front", "back"])
 }).partial().nullable();
-const ngSchema = z.object({
+const ngPrecomputedMeshSchema = z.object({
   // TODO: Should this explicitly specify sharded vs. unsharded?
   // Or can/should that be inferred from the data?
-  dimensionX: z.number(),
-  dimensionY: z.number(),
-  dimensionZ: z.number(),
-  dimensionUnit: z.enum(["nm", "um", "µm", "mm", "cm", "m"]),
+  // Note: None of these make sense to specify at the file level, since they
+  // are global camera settings that would apply to all layers.
+  // Intead, initial values should be set via the usual coordination space mechanism,
+  // and the NeuroglancerSubscriber should handle conversion into values to pass to Neuroglancer.
+  // dimensionX: z.number(),
+  // dimensionY: z.number(),
+  // dimensionZ: z.number(),
+  // dimensionUnit: z.enum(['nm', 'um', 'µm', 'mm', 'cm', 'm']),
   // TODO: should the following be passed via coordination types instead?
-  projectionScale: z.number(),
-  position: z.array(z.number()).length(3),
-  projectionOrientation: z.array(z.number()).length(4)
+  // projectionScale: z.number(),
+  // position: z.array(z.number()).length(3),
+  // projectionOrientation: z.array(z.number()).length(4),
+}).partial().nullable();
+const ngPointAnnotationSchema = z.object({
+  projectionAnnotationSpacing: z.number(),
+  featureIndexProp: z.string().optional().describe("The name of the Neuroglancer AnnotationProperty containing feature IDs. For example, specify 'gene' to use prop_gene() in the Neuroglancer shader code."),
+  pointIndexProp: z.string().optional().describe("The name of the Neuroglancer AnnotationProperty containing point IDs. For example, specify 'point_id' to use prop_point_id() in the Neuroglancer shader code.")
 }).partial().nullable();
 const obsEmbeddingAnndataSchema = annDataObsEmbedding;
 const obsSpotsAnndataSchema = annDataObsLocations;
@@ -211787,22 +211819,22 @@ async function getDecoder(fileDirectory) {
   const Decoder = await importFn();
   return new Decoder(fileDirectory);
 }
-addDecoder([void 0, 1], () => import("./raw-DIDBeWlq.js").then((m2) => m2.default));
-addDecoder(5, () => import("./lzw-CcpH5iJt.js").then((m2) => m2.default));
+addDecoder([void 0, 1], () => import("./raw-gTiCW4uC.js").then((m2) => m2.default));
+addDecoder(5, () => import("./lzw-BZquPZzK.js").then((m2) => m2.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-CDMJPRrU.js").then((m2) => m2.default));
-addDecoder([8, 32946], () => import("./deflate-CrWHFwMs.js").then((m2) => m2.default));
-addDecoder(32773, () => import("./packbits-BeOEJDb9.js").then((m2) => m2.default));
+addDecoder(7, () => import("./jpeg-sdYhU6M1.js").then((m2) => m2.default));
+addDecoder([8, 32946], () => import("./deflate-ByRX5czT.js").then((m2) => m2.default));
+addDecoder(32773, () => import("./packbits-CCy9a1OH.js").then((m2) => m2.default));
 addDecoder(
   34887,
-  () => import("./lerc-BfnnHmSr.js").then(async (m2) => {
+  () => import("./lerc-DU3LD97H.js").then(async (m2) => {
     await m2.zstd.init();
     return m2;
   }).then((m2) => m2.default)
 );
-addDecoder(50001, () => import("./webimage-BPux70Xk.js").then((m2) => m2.default));
+addDecoder(50001, () => import("./webimage-H51ZBpKw.js").then((m2) => m2.default));
 function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
   return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
 }
@@ -229403,13 +229435,13 @@ class Scatterplot extends AbstractSpatialOrScatterplot {
    */
   componentDidUpdate(prevProps) {
     this.viewInfoDidUpdate();
-    const shallowDiff = (propName) => prevProps[propName] !== this.props[propName];
+    const shallowDiff2 = (propName) => prevProps[propName] !== this.props[propName];
     let forceUpdate = false;
-    if (["obsEmbedding", "obsEmbeddingIndex"].some(shallowDiff)) {
+    if (["obsEmbedding", "obsEmbeddingIndex"].some(shallowDiff2)) {
       this.onUpdateCellsData();
       forceUpdate = true;
     }
-    if (["stratifiedData"].some(shallowDiff)) {
+    if (["stratifiedData"].some(shallowDiff2)) {
       this.onUpdateStratifiedData();
       forceUpdate = true;
     }
@@ -229428,7 +229460,7 @@ class Scatterplot extends AbstractSpatialOrScatterplot {
       "cellColorEncoding",
       "getExpressionValue",
       "embeddingPointsVisible"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateCellsLayer();
       forceUpdate = true;
     }
@@ -229440,7 +229472,7 @@ class Scatterplot extends AbstractSpatialOrScatterplot {
       "embeddingContoursVisible",
       "cellSetLabelsVisible",
       "cellSetLabelSize"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateContourLayers();
       forceUpdate = true;
     }
@@ -229450,11 +229482,11 @@ class Scatterplot extends AbstractSpatialOrScatterplot {
       "cellSetLabelsVisible",
       "cellSetLabelSize",
       "embeddingContoursVisible"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateCellSetsLayers(false);
       forceUpdate = true;
     }
-    if (shallowDiff("viewState")) {
+    if (shallowDiff2("viewState")) {
       this.onUpdateCellSetsLayers(true);
       forceUpdate = true;
     }
@@ -254219,21 +254251,21 @@ let Spatial$1 = class Spatial extends AbstractSpatialOrScatterplot {
    */
   componentDidUpdate(prevProps) {
     this.viewInfoDidUpdate();
-    const shallowDiff = (propName) => prevProps[propName] !== this.props[propName];
+    const shallowDiff2 = (propName) => prevProps[propName] !== this.props[propName];
     let forceUpdate = false;
     if ([
       "obsSegmentations",
       "obsSegmentationsType",
       "obsCentroids"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateCellsData();
       forceUpdate = true;
     }
-    if (["cellColors"].some(shallowDiff)) {
+    if (["cellColors"].some(shallowDiff2)) {
       this.onUpdateCellColors();
       forceUpdate = true;
     }
-    if (["expressionData"].some(shallowDiff)) {
+    if (["expressionData"].some(shallowDiff2)) {
       this.onUpdateExpressionData();
       forceUpdate = true;
     }
@@ -254252,7 +254284,7 @@ let Spatial$1 = class Spatial extends AbstractSpatialOrScatterplot {
       "cellColorEncoding",
       "geneExpressionColormap",
       "segmentationLayerCallbacks"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateCellsLayer();
       forceUpdate = true;
     }
@@ -254260,7 +254292,7 @@ let Spatial$1 = class Spatial extends AbstractSpatialOrScatterplot {
       "obsLocations",
       "obsLocationsLabels",
       "obsLocationsFeatureIndex"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateMoleculesData();
       forceUpdate = true;
     }
@@ -254270,15 +254302,15 @@ let Spatial$1 = class Spatial extends AbstractSpatialOrScatterplot {
       "obsLocationsIndex",
       "obsLocationsLabels",
       "obsLocationsFeatureIndex"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateMoleculesLayer();
       forceUpdate = true;
     }
-    if (["neighborhoods"].some(shallowDiff)) {
+    if (["neighborhoods"].some(shallowDiff2)) {
       this.onUpdateNeighborhoodsData();
       forceUpdate = true;
     }
-    if (["neighborhoodLayerDefsDefs", "neighborhoods"].some(shallowDiff)) {
+    if (["neighborhoodLayerDefsDefs", "neighborhoods"].some(shallowDiff2)) {
       this.onUpdateNeighborhoodsLayer();
       forceUpdate = true;
     }
@@ -254292,7 +254324,7 @@ let Spatial$1 = class Spatial extends AbstractSpatialOrScatterplot {
       "imageLayerCallbacks",
       "geneExpressionColormap",
       "photometricInterpretation"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateImages();
       forceUpdate = true;
     }
@@ -256042,24 +256074,24 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
    */
   componentDidUpdate(prevProps) {
     this.viewInfoDidUpdate();
-    const shallowDiff = (propName) => prevProps[propName] !== this.props[propName];
-    const shallowDiffByLayer = (propName, scopeName) => prevProps?.[propName]?.[scopeName] !== this.props?.[propName]?.[scopeName];
+    const shallowDiff2 = (propName) => prevProps[propName] !== this.props[propName];
+    const shallowDiffByLayer2 = (propName, scopeName) => prevProps?.[propName]?.[scopeName] !== this.props?.[propName]?.[scopeName];
     const shallowDiffByChannel = (propName, firstName, secondName) => prevProps?.[propName]?.[firstName]?.[secondName] !== this.props?.[propName]?.[firstName]?.[secondName];
     const shallowDiffByLayerCoordination = (propName, layerScope) => prevProps?.[propName]?.[0]?.[layerScope] !== this.props?.[propName]?.[0]?.[layerScope];
     const shallowDiffByChannelCoordination = (propName, layerScope, channelScope) => prevProps?.[propName]?.[0]?.[layerScope]?.[channelScope] !== this.props?.[propName]?.[0]?.[layerScope]?.[channelScope];
     let forceUpdate = false;
-    if (shallowDiff("segmentationLayerScopes")) {
+    if (shallowDiff2("segmentationLayerScopes")) {
       this.onUpdateAllSegmentationsData();
       forceUpdate = true;
     } else {
       this.props.segmentationLayerScopes?.forEach((layerScope) => {
-        if (shallowDiffByLayer("obsSegmentations", layerScope)) {
+        if (shallowDiffByLayer2("obsSegmentations", layerScope)) {
           this.onUpdateSegmentationsData(layerScope);
           forceUpdate = true;
         }
       });
     }
-    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff)) {
+    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff2)) {
       this.onUpdateAllSegmentationsLocationsData();
       forceUpdate = true;
     } else {
@@ -256072,7 +256104,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
         });
       });
     }
-    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff)) {
+    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff2)) {
       this.onUpdateAllSegmentationsSetsData();
       forceUpdate = true;
     } else {
@@ -256085,7 +256117,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
         });
       });
     }
-    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff)) {
+    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff2)) {
       this.onUpdateAllSegmentationsIndexData();
       forceUpdate = true;
     } else {
@@ -256098,7 +256130,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
         });
       });
     }
-    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff)) {
+    if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(shallowDiff2)) {
       this.onUpdateAllSegmentationsExpressionData();
       forceUpdate = true;
     } else {
@@ -256123,49 +256155,49 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       "segmentationLayerCoordination",
       "segmentationChannelScopesByLayer",
       "segmentationChannelCoordination"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateSegmentationsLayer();
       forceUpdate = true;
     }
-    if (shallowDiff("spotLayerScopes")) {
+    if (shallowDiff2("spotLayerScopes")) {
       this.onUpdateAllSpotsData();
       forceUpdate = true;
     } else {
       this.props.spotLayerScopes.forEach((layerScope) => {
-        if (shallowDiffByLayer("obsSpots", layerScope)) {
+        if (shallowDiffByLayer2("obsSpots", layerScope)) {
           this.onUpdateSpotsData(layerScope);
           forceUpdate = true;
         }
       });
     }
-    if (shallowDiff("spotLayerScopes")) {
+    if (shallowDiff2("spotLayerScopes")) {
       this.onUpdateAllSpotsSetsData();
       forceUpdate = true;
     } else {
       this.props.spotLayerScopes.forEach((layerScope) => {
-        if (shallowDiffByLayer("obsSpotsSets", layerScope) || shallowDiffByLayer("obsSpots", layerScope) || shallowDiffByLayerCoordination("spotLayerCoordination", layerScope)) {
+        if (shallowDiffByLayer2("obsSpotsSets", layerScope) || shallowDiffByLayer2("obsSpots", layerScope) || shallowDiffByLayerCoordination("spotLayerCoordination", layerScope)) {
           this.onUpdateSpotsSetsData(layerScope);
           forceUpdate = true;
         }
       });
     }
-    if (shallowDiff("spotLayerScopes")) {
+    if (shallowDiff2("spotLayerScopes")) {
       this.onUpdateAllSpotsIndexData();
       forceUpdate = true;
     } else {
       this.props.spotLayerScopes.forEach((layerScope) => {
-        if (shallowDiffByLayer("spotMatrixIndices", layerScope) || shallowDiffByLayer("obsSpots", layerScope)) {
+        if (shallowDiffByLayer2("spotMatrixIndices", layerScope) || shallowDiffByLayer2("obsSpots", layerScope)) {
           this.onUpdateSpotsIndexData(layerScope);
           forceUpdate = true;
         }
       });
     }
-    if (shallowDiff("spotLayerScopes")) {
+    if (shallowDiff2("spotLayerScopes")) {
       this.onUpdateAllSpotsExpressionData();
       forceUpdate = true;
     } else {
       this.props.spotLayerScopes.forEach((layerScope) => {
-        if (shallowDiffByLayer("spotMatrixIndices", layerScope) || shallowDiffByLayer("obsSpots", layerScope) || shallowDiffByLayer("spotMultiExpressionData", layerScope)) {
+        if (shallowDiffByLayer2("spotMatrixIndices", layerScope) || shallowDiffByLayer2("obsSpots", layerScope) || shallowDiffByLayer2("spotMultiExpressionData", layerScope)) {
           this.onUpdateSpotsExpressionData(layerScope);
           forceUpdate = true;
         }
@@ -256180,16 +256212,16 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       // Coordination props.
       "spotLayerScopes",
       "spotLayerCoordination"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateSpotsLayer();
       forceUpdate = true;
     }
-    if (shallowDiff("pointLayerScopes")) {
+    if (shallowDiff2("pointLayerScopes")) {
       this.onUpdateAllPointsData();
       forceUpdate = true;
     } else {
       this.props.pointLayerScopes.forEach((layerScope) => {
-        if (shallowDiffByLayer("obsPoints", layerScope) || shallowDiffByLayer("pointMultiObsLabels", layerScope) || shallowDiffByLayer("pointMatrixIndices", layerScope)) {
+        if (shallowDiffByLayer2("obsPoints", layerScope) || shallowDiffByLayer2("pointMultiObsLabels", layerScope) || shallowDiffByLayer2("pointMatrixIndices", layerScope)) {
           this.onUpdatePointsData(layerScope);
           forceUpdate = true;
         }
@@ -256203,7 +256235,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       // Coordination props.
       "pointLayerScopes",
       "pointLayerCoordination"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdatePointsLayer();
       forceUpdate = true;
     }
@@ -256215,7 +256247,7 @@ class Spatial2 extends AbstractSpatialOrScatterplot {
       "imageLayerCoordination",
       "imageChannelScopesByLayer",
       "imageChannelCoordination"
-    ].some(shallowDiff)) {
+    ].some(shallowDiff2)) {
       this.onUpdateImages();
       forceUpdate = true;
     }
@@ -256354,12 +256386,12 @@ class ErrorBoundary extends React__default.Component {
   }
 }
 const LazySpatialThree = React__default.lazy(async () => {
-  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-Chf9TR4u.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-xAWMcZc7.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-fYLGd5-F.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-vYTQdcDn.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 }) }) }) }));
@@ -271397,7 +271429,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-DXSQ9sk_.js");
+  const { HiGlassComponent } = await import("./higlass-JheOYeK6.js");
   return { default: HiGlassComponent };
 });
 const HG_SIZE = 800;
@@ -274344,7 +274376,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-BvdUAGCt.js"));
+const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-DQisjzJ2.js"));
 function createWorker() {
   return new WorkerFactory();
 }
@@ -274421,107 +274453,548 @@ class NeuroglancerComp extends PureComponent {
     return jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [jsxRuntimeExports.jsx(NeuroglancerGlobalStyles, { classes: classes2 }), jsxRuntimeExports.jsx("div", { className: classes2.neuroglancerWrapper, children: jsxRuntimeExports.jsx(Suspense, { fallback: jsxRuntimeExports.jsx("div", { children: "Loading..." }), children: jsxRuntimeExports.jsx(LazyReactNeuroglancer, { brainMapsClientId: "NOT_A_VALID_ID", viewerState, onViewerStateChanged: this.onViewerStateChanged, bundleRoot: this.bundleRoot, cellColorMapping, ref: this.onRef }) }) })] });
   }
 }
+function useMemoCustomComparison(factory2, dependencies2, customIsEqual) {
+  const ref2 = useRef(
+    /** @type {{ deps: any; value: T } | undefined} */
+    void 0
+  );
+  if (ref2.current === void 0 || !customIsEqual(ref2.current.deps, dependencies2)) {
+    ref2.current = { deps: dependencies2, value: factory2() };
+  }
+  return ref2.current.value;
+}
+const shallowDiff = (prevDeps, nextDeps, depName) => prevDeps[depName] !== nextDeps[depName];
+const shallowDiffByLayer = (prevDeps, nextDeps, depName, scopeName) => prevDeps?.[depName]?.[scopeName] !== nextDeps?.[depName]?.[scopeName];
+const shallowDiffByChannelWithKeys = (prevDeps, nextDeps, depName, firstName, secondName, keys2) => keys2.some((k) => prevDeps?.[depName]?.[firstName]?.[secondName]?.[k] !== nextDeps?.[depName]?.[firstName]?.[secondName]?.[k]);
+const shallowDiffByLayerCoordinationWithKeys = (prevDeps, nextDeps, depName, layerScope, keys2) => keys2.some((k) => prevDeps?.[depName]?.[0]?.[layerScope]?.[k] !== nextDeps?.[depName]?.[0]?.[layerScope]?.[k]);
+const shallowDiffByChannelCoordinationWithKeys = (prevDeps, nextDeps, depName, layerScope, channelScope, keys2) => keys2.some((k) => prevDeps?.[depName]?.[0]?.[layerScope]?.[channelScope]?.[k] !== nextDeps?.[depName]?.[0]?.[layerScope]?.[channelScope]?.[k]);
+function customIsEqualForCellColors(prevDeps, nextDeps) {
+  let forceUpdate = false;
+  const curriedShallowDiff = (depName) => shallowDiff(prevDeps, nextDeps, depName);
+  const curriedShallowDiffByChannelWithKeys = (depName, firstName, secondName, keys2) => shallowDiffByChannelWithKeys(prevDeps, nextDeps, depName, firstName, secondName, keys2);
+  const curriedShallowDiffByChannelCoordinationWithKeys = (depName, layerScope, channelScope, keys2) => shallowDiffByChannelCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, channelScope, keys2);
+  if (curriedShallowDiff("theme")) {
+    forceUpdate = true;
+  }
+  if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(curriedShallowDiff)) {
+    forceUpdate = true;
+  } else {
+    nextDeps.segmentationLayerScopes?.forEach((layerScope) => {
+      nextDeps.segmentationChannelScopesByLayer?.[layerScope]?.forEach((channelScope) => {
+        if (curriedShallowDiffByChannelWithKeys("obsSegmentationsSetsData", layerScope, channelScope, [
+          "obsSets",
+          "obsIndex"
+        ]) || curriedShallowDiffByChannelCoordinationWithKeys("segmentationChannelCoordination", layerScope, channelScope, [
+          "obsSetColor",
+          "obsColorEncoding",
+          "obsSetSelection",
+          "additionalObsSets"
+        ])) {
+          forceUpdate = true;
+        }
+      });
+    });
+  }
+  return !forceUpdate;
+}
+function customIsEqualForInitialViewerState(prevDeps, nextDeps) {
+  let forceUpdate = false;
+  const curriedShallowDiff = (depName) => shallowDiff(prevDeps, nextDeps, depName);
+  const curriedShallowDiffByLayer = (depName, scopeName) => shallowDiffByLayer(prevDeps, nextDeps, depName, scopeName);
+  const curriedShallowDiffByLayerCoordinationWithKeys = (depName, layerScope, keys2) => shallowDiffByLayerCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, keys2);
+  const curriedShallowDiffByChannelCoordinationWithKeys = (depName, layerScope, channelScope, keys2) => shallowDiffByChannelCoordinationWithKeys(prevDeps, nextDeps, depName, layerScope, channelScope, keys2);
+  if (["segmentationLayerScopes", "segmentationChannelScopesByLayer"].some(curriedShallowDiff)) {
+    forceUpdate = true;
+  } else {
+    nextDeps.segmentationLayerScopes?.forEach((layerScope) => {
+      if (curriedShallowDiffByLayer("obsSegmentationsData", layerScope) || curriedShallowDiffByLayerCoordinationWithKeys("segmentationLayerCoordination", layerScope, [
+        "spatialLayerVisible"
+      ])) {
+        forceUpdate = true;
+      }
+      nextDeps.segmentationChannelScopesByLayer?.[layerScope]?.forEach((channelScope) => {
+        if (curriedShallowDiffByChannelCoordinationWithKeys("segmentationChannelCoordination", layerScope, channelScope, [
+          "spatialChannelVisible"
+        ])) {
+          forceUpdate = true;
+        }
+      });
+    });
+  }
+  if (curriedShallowDiff("pointLayerScopes")) {
+    forceUpdate = true;
+  } else {
+    nextDeps.pointLayerScopes?.forEach((layerScope) => {
+      if (curriedShallowDiffByLayer("obsPointsData", layerScope) || curriedShallowDiffByLayer("pointMultiIndicesData", layerScope) || curriedShallowDiffByLayerCoordinationWithKeys("pointLayerCoordination", layerScope, [
+        "spatialLayerVisible",
+        "obsColorEncoding",
+        "spatialLayerColor",
+        "featureSelection",
+        "featureFilterMode",
+        "featureColor"
+      ]) || Math.abs(prevDeps?.pointLayerCoordination?.[0]?.[layerScope]?.spatialLayerOpacity - nextDeps?.pointLayerCoordination?.[0]?.[layerScope]?.spatialLayerOpacity) >= 0.05) {
+        forceUpdate = true;
+      }
+    });
+  }
+  return !forceUpdate;
+}
+function normalizeColor(rgbColor) {
+  return rgbColor.map((c2) => c2 / 255);
+}
+function toVec3(normalizedColor) {
+  return `vec3(${normalizedColor.join(", ")})`;
+}
+function toVec4(normalizedColor, alpha2) {
+  return `vec4(${normalizedColor.join(", ")}, ${alpha2})`;
+}
+function getSpatialLayerColorShader(staticColor, opacity2) {
+  const norm2 = normalizeColor(staticColor);
+  return `
+        void main() {
+            setColor(${toVec4(norm2, opacity2)});
+        }
+    `;
+}
+function getSpatialLayerColorWithSelectionShader(staticColor, opacity2, featureIndices, defaultColor, featureIndexProp) {
+  const normStatic = normalizeColor(staticColor);
+  const normDefault = normalizeColor(defaultColor);
+  const numFeatures = featureIndices.length;
+  const indicesArr = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesArr}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (isSelected) {
+                setColor(${toVec4(normStatic, opacity2)});
+            } else {
+                setColor(${toVec4(normDefault, opacity2)});
+            }
+        }
+    `;
+}
+function getSpatialLayerColorFilteredShader(staticColor, opacity2, featureIndices, featureIndexProp) {
+  const normStatic = normalizeColor(staticColor);
+  const numFeatures = featureIndices.length;
+  const indicesArr = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesArr}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            setColor(${toVec4(normStatic, opacity2)});
+        }
+    `;
+}
+function getGeneSelectionNoSelectionShader(staticColor, opacity2) {
+  const norm2 = normalizeColor(staticColor);
+  return `
+        void main() {
+            setColor(${toVec4(norm2, opacity2)});
+        }
+    `;
+}
+function getGeneSelectionWithSelectionShader(featureIndices, featureColors, staticColor, defaultColor, opacity2, featureIndexProp) {
+  const numFeatures = featureIndices.length;
+  const normDefault = normalizeColor(defaultColor);
+  const normColors = featureColors.map((c2) => normalizeColor(c2));
+  const normStatic = normalizeColor(staticColor);
+  const colorArr = normColors.map((c2) => c2 ? toVec3(c2) : toVec3(normStatic));
+  const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  const colorsDecl = `vec3 featureColors[${numFeatures}] = vec3[${numFeatures}](${colorArr.join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesDecl}
+            ${colorsDecl}
+            vec4 color = ${toVec4(normDefault, opacity2)};
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    color = vec4(featureColors[i], ${opacity2});
+                }
+            }
+            setColor(color);
+        }
+    `;
+}
+function getGeneSelectionFilteredShader(featureIndices, featureColors, staticColor, opacity2, featureIndexProp) {
+  const numFeatures = featureIndices.length;
+  const normColors = featureColors.map((c2) => normalizeColor(c2));
+  const normStatic = normalizeColor(staticColor);
+  const colorArr = normColors.map((c2) => c2 ? toVec3(c2) : toVec3(normStatic));
+  const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  const colorsDecl = `vec3 featureColors[${numFeatures}] = vec3[${numFeatures}](${colorArr.join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesDecl}
+            ${colorsDecl}
+            bool isSelected = false;
+            vec3 matchedColor = vec3(0.0);
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                    matchedColor = featureColors[i];
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            setColor(vec4(matchedColor, ${opacity2}));
+        }
+    `;
+}
+function getRandomByFeatureShader(opacity2, featureIndexProp) {
+  const paletteSize = PALETTE.length;
+  const normPalette = PALETTE.map((c2) => normalizeColor(c2));
+  const paletteDecl = `vec3 palette[${paletteSize}] = vec3[${paletteSize}](${normPalette.map((c2) => toVec3(c2)).join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${paletteDecl}
+            int colorIdx = geneIndex - (geneIndex / ${paletteSize}) * ${paletteSize};
+            if (colorIdx < 0) { colorIdx = -colorIdx; }
+            vec3 color = palette[colorIdx];
+            setColor(vec4(color, ${opacity2}));
+        }
+    `;
+}
+function getRandomByFeatureWithSelectionShader(featureIndices, defaultColor, opacity2, featureIndexProp) {
+  const paletteSize = PALETTE.length;
+  const normPalette = PALETTE.map((c2) => normalizeColor(c2));
+  const normDefault = normalizeColor(defaultColor);
+  const numFeatures = featureIndices.length;
+  const paletteDecl = `vec3 palette[${paletteSize}] = vec3[${paletteSize}](${normPalette.map((c2) => toVec3(c2)).join(", ")});`;
+  const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${paletteDecl}
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (isSelected) {
+                int colorIdx = geneIndex - (geneIndex / ${paletteSize}) * ${paletteSize};
+                if (colorIdx < 0) { colorIdx = -colorIdx; }
+                setColor(vec4(palette[colorIdx], ${opacity2}));
+            } else {
+                setColor(${toVec4(normDefault, opacity2)});
+            }
+        }
+    `;
+}
+function getRandomByFeatureFilteredShader(featureIndices, opacity2, featureIndexProp) {
+  const paletteSize = PALETTE.length;
+  const normPalette = PALETTE.map((c2) => normalizeColor(c2));
+  const numFeatures = featureIndices.length;
+  const paletteDecl = `vec3 palette[${paletteSize}] = vec3[${paletteSize}](${normPalette.map((c2) => toVec3(c2)).join(", ")});`;
+  const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${paletteDecl}
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            int colorIdx = geneIndex - (geneIndex / ${paletteSize}) * ${paletteSize};
+            if (colorIdx < 0) { colorIdx = -colorIdx; }
+            setColor(vec4(palette[colorIdx], ${opacity2}));
+        }
+    `;
+}
+function hashToFloatGlsl() {
+  return `
+        float hashToFloat(int v, int seed) {
+            int h = v ^ (seed * 16777619);
+            h = h * 747796405 + 2891336453;
+            h = ((h >> 16) ^ h) * 2654435769;
+            h = ((h >> 16) ^ h);
+            return float(h & 0x7FFFFFFF) / float(0x7FFFFFFF);
+        }
+    `;
+}
+function getRandomPerPointShader(opacity2, featureIndexProp, pointIndexProp) {
+  return `
+        ${hashToFloatGlsl()}
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            int pointIndex = prop_${pointIndexProp}();
+            float r = hashToFloat(pointIndex, 0);
+            float g = hashToFloat(pointIndex, 1);
+            float b = hashToFloat(pointIndex, 2);
+            setColor(vec4(r, g, b, ${opacity2}));
+        }
+    `;
+}
+function getRandomPerPointWithSelectionShader(featureIndices, defaultColor, opacity2, featureIndexProp, pointIndexProp) {
+  const normDefault = normalizeColor(defaultColor);
+  const numFeatures = featureIndices.length;
+  const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  return `
+        ${hashToFloatGlsl()}
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            int pointIndex = prop_${pointIndexProp}();
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (isSelected) {
+                float r = hashToFloat(pointIndex, 0);
+                float g = hashToFloat(pointIndex, 1);
+                float b = hashToFloat(pointIndex, 2);
+                setColor(vec4(r, g, b, ${opacity2}));
+            } else {
+                setColor(${toVec4(normDefault, opacity2)});
+            }
+        }
+    `;
+}
+function getRandomPerPointFilteredShader(featureIndices, opacity2, featureIndexProp, pointIndexProp) {
+  const numFeatures = featureIndices.length;
+  const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(", ")});`;
+  return `
+        ${hashToFloatGlsl()}
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            int pointIndex = prop_${pointIndexProp}();
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            float r = hashToFloat(pointIndex, 0);
+            float g = hashToFloat(pointIndex, 1);
+            float b = hashToFloat(pointIndex, 2);
+            setColor(vec4(r, g, b, ${opacity2}));
+        }
+    `;
+}
+function getPointsShader(layerCoordination) {
+  const { theme, featureIndex, spatialLayerOpacity, obsColorEncoding, spatialLayerColor, featureSelection, featureFilterMode, featureColor, featureIndexProp, pointIndexProp } = layerCoordination;
+  const defaultColor = getDefaultColor(theme);
+  const opacity2 = spatialLayerOpacity ?? 1;
+  const staticColor = Array.isArray(spatialLayerColor) && spatialLayerColor.length === 3 ? spatialLayerColor : defaultColor;
+  const hasFeatureSelection = Array.isArray(featureSelection) && featureSelection.length > 0;
+  const isFiltered = featureFilterMode === "featureSelection";
+  let featureIndices = [];
+  if (hasFeatureSelection && Array.isArray(featureIndex)) {
+    featureIndices = featureSelection.map((name2) => featureIndex.indexOf(name2)).filter((i2) => i2 >= 0);
+  }
+  const hasResolvedIndices = featureIndices.length > 0;
+  const resolvedFeatureColors = hasResolvedIndices ? featureSelection.filter((name2) => featureIndex?.indexOf(name2) >= 0).map((name2) => {
+    const match2 = Array.isArray(featureColor) ? featureColor.find((fc) => fc.name === name2)?.color : null;
+    return match2 || staticColor;
+  }) : [];
+  if (obsColorEncoding === "spatialLayerColor") {
+    if (!hasFeatureSelection || !hasResolvedIndices) {
+      return getSpatialLayerColorShader(staticColor, opacity2);
+    }
+    if (isFiltered) {
+      return getSpatialLayerColorFilteredShader(staticColor, opacity2, featureIndices, featureIndexProp);
+    }
+    return getSpatialLayerColorWithSelectionShader(staticColor, opacity2, featureIndices, defaultColor, featureIndexProp);
+  }
+  if (obsColorEncoding === "geneSelection") {
+    if (!featureIndexProp) {
+      throw new Error("In order to use gene-based color encoding for Neuroglancer Points, options.featureIndexProp must be specified for the obsPoints.ng-annotations fileType in the Vitessce configuration.");
+    }
+    if (!hasFeatureSelection || !hasResolvedIndices) {
+      return getGeneSelectionNoSelectionShader(staticColor, opacity2);
+    }
+    if (isFiltered) {
+      return getGeneSelectionFilteredShader(featureIndices, resolvedFeatureColors, staticColor, opacity2, featureIndexProp);
+    }
+    return getGeneSelectionWithSelectionShader(featureIndices, resolvedFeatureColors, staticColor, defaultColor, opacity2, featureIndexProp);
+  }
+  if (obsColorEncoding === "randomByFeature") {
+    if (!featureIndexProp) {
+      throw new Error("In order to use gene-based color encoding for Neuroglancer Points, options.featureIndexProp must be specified for the obsPoints.ng-annotations fileType in the Vitessce configuration.");
+    }
+    if (!hasFeatureSelection || !hasResolvedIndices) {
+      return getRandomByFeatureShader(opacity2, featureIndexProp);
+    }
+    if (isFiltered) {
+      return getRandomByFeatureFilteredShader(featureIndices, opacity2, featureIndexProp);
+    }
+    return getRandomByFeatureWithSelectionShader(featureIndices, defaultColor, opacity2, featureIndexProp);
+  }
+  if (obsColorEncoding === "random") {
+    if (!pointIndexProp) {
+      throw new Error("In order to use per-point color encoding for Neuroglancer Points, options.pointIndexProp must be specified for the obsPoints.ng-annotations fileType in the Vitessce configuration.");
+    }
+    if (!hasFeatureSelection || !hasResolvedIndices) {
+      return getRandomPerPointShader(opacity2, featureIndexProp, pointIndexProp);
+    }
+    if (isFiltered) {
+      return getRandomPerPointFilteredShader(featureIndices, opacity2, featureIndexProp, pointIndexProp);
+    }
+    return getRandomPerPointWithSelectionShader(featureIndices, defaultColor, opacity2, featureIndexProp, pointIndexProp);
+  }
+  return getSpatialLayerColorShader(staticColor, opacity2);
+}
 const DEFAULT_NG_PROPS = {
   layout: "3d",
   position: [0, 0, 0],
   projectionOrientation: [0, 0, 0, 1],
   projectionScale: 1024,
-  crossSectionScale: 1
+  crossSectionScale: 1,
+  dimensions: {
+    x: [1, "nm"],
+    y: [1, "nm"],
+    z: [1, "nm"]
+  },
+  layers: []
 };
 function toPrecomputedSource(url) {
   if (!url) {
-    return void 0;
+    throw new Error("toPrecomputedSource: URL is required");
   }
   return `precomputed://${url}`;
 }
-const UNIT_TO_NM = {
-  nm: 1,
-  um: 1e3,
-  µm: 1e3,
-  mm: 1e6,
-  cm: 1e7,
-  m: 1e9
-};
-function isInNanometerRange(value2, unit2, minNm = 1, maxNm = 100) {
-  const n3 = typeof value2 === "number" ? value2 : Number(value2);
-  if (!Number.isFinite(n3))
-    return false;
-  const factor = unit2 && UNIT_TO_NM[unit2];
-  if (!factor)
-    return false;
-  const nm = n3 * factor;
-  return nm >= minNm && nm <= maxNm;
-}
-function normalizeDimensionsToNanometers(opts2) {
-  const { dimensionUnit, dimensionX, dimensionY, dimensionZ } = opts2;
-  if (!dimensionUnit || !dimensionX || !dimensionY || !dimensionZ) {
-    console.warn("Missing dimension info");
+function toNgLayerName(dataType, layerScope, channelScope = null) {
+  if (dataType === DataType$3.OBS_SEGMENTATIONS) {
+    return `obsSegmentations-${layerScope}-${channelScope}`;
   }
-  const xNm = isInNanometerRange(dimensionX, dimensionUnit);
-  const yNm = isInNanometerRange(dimensionY, dimensionUnit);
-  const zNm = isInNanometerRange(dimensionZ, dimensionUnit);
-  if (!xNm || !yNm || !zNm) {
-    console.warn("Dimension was converted to nm units");
+  if (dataType === DataType$3.OBS_POINTS) {
+    return `obsPoints-${layerScope}`;
   }
-  return {
-    x: xNm ? [dimensionX, dimensionUnit] : [1, "nm"],
-    y: yNm ? [dimensionY, dimensionUnit] : [1, "nm"],
-    z: zNm ? [dimensionZ, dimensionUnit] : [1, "nm"]
-  };
+  throw new Error(`Unsupported data type: ${dataType}`);
 }
-function extractDataTypeEntities(loaders, dataset, dataType) {
-  const datasetEntry = loaders?.[dataset];
-  const internMap = datasetEntry?.loaders?.[dataType];
-  if (!internMap || typeof internMap.entries !== "function")
-    return [];
-  return Array.from(internMap.entries()).map(([key2, loader2]) => {
-    const url = loader2?.url ?? loader2?.dataSource?.url ?? void 0;
-    const fileUid = key2?.fileUid ?? loader2?.coordinationValues?.fileUid ?? void 0;
-    const { position: position2, projectionOrientation, projectionScale, crossSectionScale } = loader2?.options ?? {};
-    const isPrecomputed = loader2?.fileType.includes("precomputed");
-    if (!isPrecomputed) {
-      console.warn("Filetype needs to be precomputed");
-    }
-    return {
-      key: key2,
-      type: "segmentation",
-      fileUid,
-      layout: DEFAULT_NG_PROPS.layout,
-      url,
-      source: toPrecomputedSource(url),
-      name: fileUid ?? key2?.name ?? "segmentation",
-      // For precomputed: nm is the unit used
-      dimensions: normalizeDimensionsToNanometers(loader2?.options),
-      // If not provided, no error, but difficult to see the data
-      position: Array.isArray(position2) && position2.length === 3 ? position2 : DEFAULT_NG_PROPS.position,
-      // If not provided, will have a default orientation
-      projectionOrientation: Array.isArray(projectionOrientation) && projectionOrientation.length === 4 ? projectionOrientation : DEFAULT_NG_PROPS.projectionOrientation,
-      projectionScale: Number.isFinite(projectionScale) ? projectionScale : DEFAULT_NG_PROPS.projectionScale,
-      crossSectionScale: Number.isFinite(crossSectionScale) ? crossSectionScale : DEFAULT_NG_PROPS.crossSectionScale
-    };
-  });
-}
-function useExtractOptionsForNg(loaders, dataset, dataType) {
-  const extractedEntities = useMemo$1(() => extractDataTypeEntities(loaders, dataset, dataType), [loaders, dataset, dataType]);
-  const layers = useMemo$1(() => extractedEntities.filter((t4) => t4.source).map((t4) => ({
-    type: t4.type,
-    source: t4.source,
-    segments: [],
-    name: t4.name || "segmentation"
-  })), [extractedEntities]);
-  const viewerState = useMemo$1(() => ({
-    dimensions: extractedEntities[0]?.dimensions,
-    position: extractedEntities[0]?.position,
-    crossSectionScale: extractedEntities[0]?.crossSectionScale,
-    projectionOrientation: extractedEntities[0]?.projectionOrientation,
-    projectionScale: extractedEntities[0]?.projectionScale,
-    layers,
-    layout: extractedEntities[0].layout
-  }));
-  return [viewerState];
-}
-function useNeuroglancerViewerState(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-  return useExtractOptionsForNg(loaders, dataset, DataType$3.OBS_SEGMENTATIONS);
+function useNeuroglancerViewerState(theme, segmentationLayerScopes, segmentationChannelScopesByLayer, segmentationLayerCoordination, segmentationChannelCoordination, obsSegmentationsUrls, obsSegmentationsData, pointLayerScopes, pointLayerCoordination, obsPointsUrls, obsPointsData, pointMultiIndicesData) {
+  const viewerState = useMemoCustomComparison(() => {
+    let result = cloneDeep$1(DEFAULT_NG_PROPS);
+    segmentationLayerScopes.forEach((layerScope) => {
+      const layerCoordination = segmentationLayerCoordination[0][layerScope];
+      const channelScopes = segmentationChannelScopesByLayer[layerScope] || [];
+      const layerData = obsSegmentationsData[layerScope];
+      const layerUrl = obsSegmentationsUrls[layerScope]?.[0]?.url;
+      if (layerUrl && layerData) {
+        const { spatialLayerVisible } = layerCoordination || {};
+        channelScopes.forEach((channelScope) => {
+          const channelCoordination = segmentationChannelCoordination[0]?.[layerScope]?.[channelScope];
+          const { spatialChannelVisible } = channelCoordination || {};
+          result = {
+            ...result,
+            layers: [
+              ...result.layers,
+              {
+                type: "segmentation",
+                source: toPrecomputedSource(layerUrl),
+                segments: [],
+                name: toNgLayerName(DataType$3.OBS_SEGMENTATIONS, layerScope, channelScope),
+                visible: spatialLayerVisible && spatialChannelVisible,
+                // Both layer and channel
+                // visibility must be true for the layer to be visible.
+                // TODO: update this to extract specific properties from
+                // neuroglancerOptions as needed.
+                ...layerData.neuroglancerOptions ?? {}
+              }
+            ]
+          };
+        });
+      }
+    });
+    pointLayerScopes.forEach((layerScope) => {
+      const layerCoordination = pointLayerCoordination[0][layerScope];
+      const layerData = obsPointsData[layerScope];
+      const layerUrl = obsPointsUrls[layerScope]?.[0]?.url;
+      const featureIndex = pointMultiIndicesData[layerScope]?.featureIndex;
+      if (layerUrl && layerData) {
+        const { spatialLayerVisible, spatialLayerOpacity, obsColorEncoding, spatialLayerColor, featureSelection, featureFilterMode, featureColor } = layerCoordination || {};
+        const shader = getPointsShader({
+          theme,
+          featureIndex,
+          spatialLayerOpacity,
+          obsColorEncoding,
+          spatialLayerColor,
+          featureSelection,
+          featureFilterMode,
+          featureColor,
+          featureIndexProp: layerData.neuroglancerOptions?.featureIndexProp,
+          pointIndexProp: layerData.neuroglancerOptions?.pointIndexProp
+        });
+        result = {
+          ...result,
+          layers: [
+            ...result.layers,
+            {
+              type: "annotation",
+              source: {
+                url: toPrecomputedSource(layerUrl),
+                subsources: {
+                  default: true
+                },
+                enableDefaultSubsources: false
+              },
+              tab: "annotations",
+              shader,
+              name: toNgLayerName(DataType$3.OBS_POINTS, layerScope),
+              visible: spatialLayerVisible,
+              // Options from layerData.neuroglancerOptions
+              // like projectionAnnotationSpacing:
+              projectionAnnotationSpacing: layerData.neuroglancerOptions?.projectionAnnotationSpacing ?? 1
+            }
+          ],
+          // TODO: is this needed?
+          // The selected layer here will overwrite anything
+          // that was previously specified.
+          selectedLayer: {
+            // size: ? // TODO:  is this needed?
+            layer: toNgLayerName(DataType$3.OBS_POINTS, layerScope)
+          }
+        };
+      }
+    });
+    return result;
+  }, {
+    theme,
+    segmentationLayerScopes,
+    segmentationChannelScopesByLayer,
+    segmentationLayerCoordination,
+    segmentationChannelCoordination,
+    obsSegmentationsUrls,
+    obsSegmentationsData,
+    pointLayerScopes,
+    pointLayerCoordination,
+    obsPointsUrls,
+    obsPointsData,
+    pointMultiIndicesData
+  }, customIsEqualForInitialViewerState);
+  return viewerState;
 }
 /**
  * @license
@@ -304195,9 +304668,29 @@ function rgbToHex$1(rgb2) {
   return typeof rgb2 === "string" ? rgb2 : `#${rgb2.map((c2) => c2.toString(16).padStart(2, "0")).join("")}`;
 }
 function NeuroglancerSubscriber(props) {
-  const { coordinationScopes: coordinationScopesRaw, closeButtonVisible, downloadButtonVisible, removeGridComponent, theme, title: title2 = "Neuroglancer", helpText = ViewHelpMapping.NEUROGLANCER } = props;
+  const {
+    uuid: uuid2,
+    coordinationScopes: coordinationScopesRaw,
+    coordinationScopesBy: coordinationScopesByRaw,
+    closeButtonVisible,
+    downloadButtonVisible,
+    removeGridComponent,
+    theme,
+    title: title2 = "Spatial",
+    subtitle = "Powered by Neuroglancer",
+    helpText = ViewHelpMapping.NEUROGLANCER,
+    // Note: this is a temporary mechanism
+    // to pass an initial NG camera state.
+    // Ideally, all camera state should be passed via
+    // the existing spatialZoom, spatialTargetX, spatialRotationOrbit, etc,
+    // and then NeuroglancerSubscriber should internally convert
+    // to NG-compatible values, which would eliminate the need for this.
+    initialNgCameraState
+  } = props;
   const loaders = useLoaders();
+  const mergeCoordination = useMergeCoordination();
   const coordinationScopes = useCoordinationScopes(coordinationScopesRaw);
+  const coordinationScopesBy = useCoordinationScopesBy(coordinationScopes, coordinationScopesByRaw);
   const [{
     dataset,
     obsType,
@@ -304227,11 +304720,129 @@ function NeuroglancerSubscriber(props) {
     setSpatialRotationOrbit: setRotationOrbit,
     setSpatialZoom: setZoom
   }] = useCoordination(COMPONENT_COORDINATION_TYPES[ViewType$1.NEUROGLANCER], coordinationScopes);
+  const [ngWidth, ngHeight, containerRef] = useGridItemSize();
+  const [segmentationLayerScopes, segmentationChannelScopesByLayer] = useMultiCoordinationScopesSecondaryNonNull(CoordinationType$1.SEGMENTATION_CHANNEL, CoordinationType$1.SEGMENTATION_LAYER, coordinationScopes, coordinationScopesBy);
+  const pointLayerScopes = useMultiCoordinationScopesNonNull(CoordinationType$1.POINT_LAYER, coordinationScopes);
+  const segmentationLayerCoordination = useComplexCoordination([
+    CoordinationType$1.FILE_UID,
+    CoordinationType$1.SEGMENTATION_CHANNEL,
+    CoordinationType$1.SPATIAL_LAYER_VISIBLE,
+    CoordinationType$1.SPATIAL_LAYER_OPACITY
+  ], coordinationScopes, coordinationScopesBy, CoordinationType$1.SEGMENTATION_LAYER);
+  const segmentationChannelCoordination = useComplexCoordinationSecondary([
+    CoordinationType$1.OBS_TYPE,
+    CoordinationType$1.SPATIAL_TARGET_C,
+    CoordinationType$1.SPATIAL_CHANNEL_VISIBLE,
+    CoordinationType$1.SPATIAL_CHANNEL_OPACITY,
+    CoordinationType$1.SPATIAL_CHANNEL_COLOR,
+    CoordinationType$1.SPATIAL_SEGMENTATION_FILLED,
+    CoordinationType$1.SPATIAL_SEGMENTATION_STROKE_WIDTH,
+    CoordinationType$1.OBS_COLOR_ENCODING,
+    CoordinationType$1.FEATURE_SELECTION,
+    CoordinationType$1.FEATURE_AGGREGATION_STRATEGY,
+    CoordinationType$1.FEATURE_VALUE_COLORMAP,
+    CoordinationType$1.FEATURE_VALUE_COLORMAP_RANGE,
+    CoordinationType$1.OBS_SET_COLOR,
+    CoordinationType$1.OBS_SET_SELECTION,
+    CoordinationType$1.ADDITIONAL_OBS_SETS,
+    CoordinationType$1.OBS_HIGHLIGHT,
+    CoordinationType$1.TOOLTIPS_VISIBLE,
+    CoordinationType$1.TOOLTIP_CROSSHAIRS_VISIBLE,
+    CoordinationType$1.LEGEND_VISIBLE
+  ], coordinationScopes, coordinationScopesBy, CoordinationType$1.SEGMENTATION_LAYER, CoordinationType$1.SEGMENTATION_CHANNEL);
+  const pointLayerCoordination = useComplexCoordination([
+    CoordinationType$1.OBS_TYPE,
+    CoordinationType$1.SPATIAL_LAYER_VISIBLE,
+    CoordinationType$1.SPATIAL_LAYER_OPACITY,
+    CoordinationType$1.OBS_COLOR_ENCODING,
+    CoordinationType$1.FEATURE_COLOR,
+    CoordinationType$1.FEATURE_FILTER_MODE,
+    CoordinationType$1.FEATURE_SELECTION,
+    CoordinationType$1.FEATURE_VALUE_COLORMAP,
+    CoordinationType$1.FEATURE_VALUE_COLORMAP_RANGE,
+    CoordinationType$1.SPATIAL_LAYER_COLOR,
+    CoordinationType$1.OBS_HIGHLIGHT,
+    CoordinationType$1.TOOLTIPS_VISIBLE,
+    CoordinationType$1.TOOLTIP_CROSSHAIRS_VISIBLE,
+    CoordinationType$1.LEGEND_VISIBLE
+  ], coordinationScopes, coordinationScopesBy, CoordinationType$1.POINT_LAYER);
+  const [obsPointsData, obsPointsDataStatus, obsPointsUrls, obsPointsErrors] = useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, uuid2);
+  const [pointMultiIndicesData, pointMultiIndicesDataStatus, pointMultiIndicesDataErrors] = usePointMultiObsFeatureMatrixIndices(coordinationScopes, coordinationScopesBy, loaders, dataset);
+  const [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls, obsSegmentationsDataErrors] = useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, uuid2);
+  const [obsSegmentationsSetsData, obsSegmentationsSetsDataStatus, obsSegmentationsSetsDataErrors] = useSegmentationMultiObsSets(coordinationScopes, coordinationScopesBy, loaders, dataset);
+  const [segmentationMultiExpressionData, segmentationMultiLoadedFeatureSelection, segmentationMultiExpressionExtents, segmentationMultiExpressionNormData, segmentationMultiFeatureSelectionStatus, segmentationMultiFeatureSelectionErrors] = useSegmentationMultiFeatureSelection(coordinationScopes, coordinationScopesBy, loaders, dataset);
+  const [segmentationMultiIndicesData, segmentationMultiIndicesDataStatus, segmentationMultiIndicesDataErrors] = useSegmentationMultiObsFeatureMatrixIndices(coordinationScopes, coordinationScopesBy, loaders, dataset);
+  const errors = [
+    ...obsPointsErrors,
+    ...obsSegmentationsDataErrors,
+    ...obsSegmentationsSetsDataErrors,
+    ...pointMultiIndicesDataErrors,
+    ...segmentationMultiFeatureSelectionErrors,
+    ...segmentationMultiIndicesDataErrors
+  ];
+  const isReady = useReady([
+    // Points
+    obsPointsDataStatus,
+    pointMultiIndicesDataStatus,
+    // Segmentations
+    obsSegmentationsDataStatus,
+    obsSegmentationsSetsDataStatus,
+    segmentationMultiFeatureSelectionStatus,
+    segmentationMultiIndicesDataStatus
+  ]);
   const { classes: classes2 } = useStyles$5();
-  const [{ obsSets: cellSets }] = useObsSetsData(loaders, dataset, false, { setObsSetSelection: setCellSetSelection, setObsSetColor: setCellSetColor }, { cellSetSelection, obsSetColor: cellSetColor }, { obsType });
-  const [{ obsIndex }] = useObsEmbeddingData(loaders, dataset, true, {}, {}, { obsType, embeddingType: mapping });
-  const [initalViewerState] = useNeuroglancerViewerState(loaders, dataset);
-  const latestViewerStateRef = useRef(initalViewerState);
+  const segmentationColorMapping = useMemoCustomComparison(() => {
+    const result = {};
+    segmentationLayerScopes?.forEach((layerScope) => {
+      result[layerScope] = {};
+      segmentationChannelScopesByLayer?.[layerScope]?.forEach((channelScope) => {
+        const { obsSets: layerSets, obsIndex: layerIndex } = obsSegmentationsSetsData?.[layerScope]?.[channelScope] || {};
+        if (layerSets && layerIndex) {
+          const { obsSetColor, obsColorEncoding, obsSetSelection, additionalObsSets } = segmentationChannelCoordination[0][layerScope][channelScope];
+          const mergedCellSets = mergeObsSets(layerSets, additionalObsSets);
+          const cellColors = getCellColors({
+            cellSets: mergedCellSets,
+            cellSetSelection: obsSetSelection,
+            cellSetColor: obsSetColor,
+            obsIndex: layerIndex,
+            theme
+          });
+          const ngCellColors = {};
+          cellColors.forEach((color2, i2) => {
+            ngCellColors[i2] = rgbToHex$1(color2);
+          });
+          result[layerScope][channelScope] = ngCellColors;
+        }
+      });
+    });
+    return result;
+  }, {
+    // The dependencies for the comparison,
+    // used by the custom equality function.
+    segmentationLayerScopes,
+    segmentationChannelScopesByLayer,
+    obsSegmentationsSetsData,
+    segmentationChannelCoordination,
+    theme
+  }, customIsEqualForCellColors);
+  const initalViewerState = useNeuroglancerViewerState(theme, segmentationLayerScopes, segmentationChannelScopesByLayer, segmentationLayerCoordination, segmentationChannelCoordination, obsSegmentationsUrls, obsSegmentationsData, pointLayerScopes, pointLayerCoordination, obsPointsUrls, obsPointsData, pointMultiIndicesData);
+  const [latestViewerStateIteration, incrementLatestViewerStateIteration] = useReducer((x2) => x2 + 1, 0);
+  const latestViewerStateRef = useRef({
+    ...initalViewerState,
+    ...initialNgCameraState ?? {}
+  });
+  useEffect(() => {
+    const prevNgCameraState = {
+      position: latestViewerStateRef.current.position,
+      projectionOrientation: latestViewerStateRef.current.projectionOrientation,
+      projectionScale: latestViewerStateRef.current.projectionScale
+    };
+    latestViewerStateRef.current = {
+      ...initalViewerState,
+      ...prevNgCameraState
+    };
+    incrementLatestViewerStateIteration();
+  }, [initalViewerState]);
   const initialRotationPushedRef = useRef(false);
   const ngRotPushAtRef = useRef(0);
   const lastInteractionSource = useRef(null);
@@ -304257,20 +304868,6 @@ function NeuroglancerSubscriber(props) {
     tx: spatialTargetX,
     ty: spatialTargetY
   });
-  const mergedCellSets = useMemo$1(() => mergeObsSets(cellSets, additionalCellSets), [cellSets, additionalCellSets]);
-  const cellColors = useMemo$1(() => getCellColors({
-    cellSets: mergedCellSets,
-    cellSetSelection,
-    cellSetColor,
-    obsIndex,
-    theme
-  }), [
-    mergedCellSets,
-    theme,
-    cellSetColor,
-    cellSetSelection,
-    obsIndex
-  ]);
   const handleStateUpdate = useCallback((newState) => {
     lastInteractionSource.current = LAST_INTERACTION_SOURCE.neuroglancer;
     const { projectionScale, projectionOrientation, position: position2 } = newState;
@@ -304362,25 +304959,12 @@ function NeuroglancerSubscriber(props) {
     setCellSetColor,
     setCellSetSelection
   ]);
-  const batchedUpdateTimeoutRef = useRef(null);
-  const [batchedCellColors, setBatchedCellColors] = useState(cellColors);
-  useEffect(() => {
-    if (batchedUpdateTimeoutRef.current) {
-      clearTimeout(batchedUpdateTimeoutRef.current);
-    }
-    batchedUpdateTimeoutRef.current = setTimeout(() => {
-      setBatchedCellColors(cellColors);
-    }, 100);
-  }, [cellColors]);
-  const cellColorMapping = useMemo$1(() => {
-    const colorMapping = {};
-    batchedCellColors.forEach((color2, cell2) => {
-      colorMapping[cell2] = rgbToHex$1(color2);
-    });
-    return colorMapping;
-  }, [batchedCellColors]);
+  const cellColorMapping = useMemo$1(() => segmentationColorMapping?.[segmentationLayerScopes?.[0]]?.[segmentationChannelScopesByLayer?.[segmentationLayerScopes?.[0]]?.[0]] ?? {}, [segmentationColorMapping]);
   const derivedViewerState = useMemo$1(() => {
     const { current: current2 } = latestViewerStateRef;
+    if (current2.layers.length <= 0) {
+      return current2;
+    }
     const nextSegments = Object.keys(cellColorMapping);
     const prevLayer = current2?.layers?.[0] || {};
     const prevSegments = prevLayer.segments || [];
@@ -304466,12 +305050,15 @@ function NeuroglancerSubscriber(props) {
     spatialRotationY,
     spatialRotationZ,
     spatialTargetX,
-    spatialTargetY
+    spatialTargetY,
+    initalViewerState,
+    latestViewerStateIteration
   ]);
   const onSegmentHighlight = useCallback((obsId) => {
     setCellHighlight(String(obsId));
-  }, [obsIndex, setCellHighlight]);
-  return jsxRuntimeExports.jsx(TitleInfo, { title: title2, helpText, isSpatial: true, theme, closeButtonVisible, downloadButtonVisible, removeGridComponent, isReady: true, withPadding: false, children: jsxRuntimeExports.jsx(NeuroglancerComp, { classes: classes2, onSegmentClick, onSelectHoveredCoords: onSegmentHighlight, viewerState: derivedViewerState, cellColorMapping, setViewerState: handleStateUpdate }) });
+  }, [setCellHighlight]);
+  const hasLayers = derivedViewerState?.layers?.length > 0;
+  return jsxRuntimeExports.jsx(TitleInfo, { title: title2, info: subtitle, helpText, isSpatial: true, theme, closeButtonVisible, downloadButtonVisible, removeGridComponent, isReady, errors, withPadding: false, children: jsxRuntimeExports.jsxs("div", { style: { position: "relative", width: "100%", height: "100%" }, ref: containerRef, children: [jsxRuntimeExports.jsx("div", { style: { position: "absolute", top: 0, right: 0, zIndex: 50 }, children: jsxRuntimeExports.jsx(MultiLegend, { theme: "dark", maxHeight: ngHeight, segmentationLayerScopes, segmentationLayerCoordination, segmentationChannelScopesByLayer, segmentationChannelCoordination }) }), hasLayers ? jsxRuntimeExports.jsx(NeuroglancerComp, { classes: classes2, onSegmentClick, onSelectHoveredCoords: onSegmentHighlight, viewerState: derivedViewerState, cellColorMapping, setViewerState: handleStateUpdate }) : null] }) });
 }
 const FEATURE_AGGREGATION_STRATEGIES = ["first", "last", "sum", "mean"];
 function CellSetExpressionPlotOptions(props) {
@@ -360317,7 +360904,7 @@ class ObsSpotsCsvLoader extends CsvLoader {
     const payload = await this.getSourceData();
     const coordinationValues = {
       spotLayer: CL({
-        obsType: "spot",
+        obsType: this.coordinationValues?.obsType ?? "spot",
         // obsColorEncoding: 'spatialLayerColor',
         // spatialLayerColor: [255, 255, 255],
         spatialLayerVisible: true,
@@ -360357,7 +360944,7 @@ class ObsPointsCsvLoader extends CsvLoader {
     const payload = await this.getSourceData();
     const coordinationValues = {
       pointLayer: CL({
-        obsType: "point",
+        obsType: this.coordinationValues?.obsType ?? "point",
         // obsColorEncoding: 'spatialLayerColor',
         // spatialLayerColor: [255, 255, 255],
         spatialLayerVisible: true,
@@ -361923,7 +362510,7 @@ class ObsSpotsAnndataLoader extends AbstractTwoStepLoader {
     const { path: path2 } = this.options;
     const coordinationValues = {
       spotLayer: CL({
-        obsType: "spot",
+        obsType: this.coordinationValues?.obsType ?? "spot",
         // obsColorEncoding: 'spatialLayerColor',
         // spatialLayerColor: [255, 255, 255],
         spatialLayerVisible: true,
@@ -361967,7 +362554,7 @@ class ObsPointsAnndataLoader extends AbstractTwoStepLoader {
     const { path: path2 } = this.options;
     const coordinationValues = {
       pointLayer: CL({
-        obsType: "point",
+        obsType: this.coordinationValues?.obsType ?? "point",
         // obsColorEncoding: 'spatialLayerColor',
         // spatialLayerColor: [255, 255, 255],
         spatialLayerVisible: true,
@@ -363454,7 +364041,7 @@ class SpatialDataObsSpotsLoader extends AbstractTwoStepLoader {
     const spatialSpotRadius = obsRadius?.data?.[0];
     const coordinationValues = {
       spotLayer: CL({
-        obsType: "spot",
+        obsType: this.coordinationValues?.obsType ?? "spot",
         // obsColorEncoding: 'spatialLayerColor',
         // spatialLayerColor: [255, 255, 255],
         spatialLayerVisible: true,
@@ -363669,7 +364256,7 @@ class SpatialDataObsPointsLoader extends AbstractTwoStepLoader {
     ]);
     const coordinationValues = {
       pointLayer: CL({
-        obsType: "point",
+        obsType: this.coordinationValues?.obsType ?? "point",
         obsColorEncoding: "spatialLayerColor",
         spatialLayerColor: [255, 255, 255],
         spatialLayerVisible: true,
@@ -363737,12 +364324,26 @@ class PrecomputedMeshSource {
   }
 }
 class PrecomputedMeshDataLoader extends AbstractTwoStepLoader {
-  /* eslint-disable class-methods-use-this */
-  async load(url) {
+  async load() {
+    const { url, options } = this;
     return new LoaderResult({
       obsIndex: null,
       obsSegmentations: {},
-      obsSegmentationsType: "mesh"
+      obsSegmentationsType: "mesh",
+      neuroglancerOptions: options
+    }, url);
+  }
+}
+class NgAnnotationPointsDataLoader extends AbstractTwoStepLoader {
+  async load() {
+    const { url, options } = this;
+    return new LoaderResult({
+      obsIndex: null,
+      obsPoints: null,
+      featureIds: null,
+      obsPointsModelMatrix: null,
+      obsPointsTilingType: "neuroglancer",
+      neuroglancerOptions: options
     }, url);
   }
 }
@@ -385701,7 +386302,8 @@ const baseFileTypes = [
   ...makeZarrFileTypes(FileType$1.OBS_EMBEDDING_SPATIALDATA_ZARR, DataType$3.OBS_EMBEDDING, SpatialDataObsEmbeddingLoader, SpatialDataTableSource, obsEmbeddingSpatialdataSchema),
   ...makeZarrFileTypes(FileType$1.FEATURE_LABELS_SPATIALDATA_ZARR, DataType$3.FEATURE_LABELS, SpatialDataFeatureLabelsLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
   makeFileType(FileType$1.OBS_SEGMENTATIONS_GLB, DataType$3.OBS_SEGMENTATIONS, GlbDataLoader, GlbSource, meshGlbSchema),
-  makeFileType(FileType$1.OBS_SEGMENTATIONS_NG_PRECOMPUTED, DataType$3.OBS_SEGMENTATIONS, PrecomputedMeshDataLoader, PrecomputedMeshSource, ngSchema),
+  makeFileType(FileType$1.OBS_SEGMENTATIONS_NG_PRECOMPUTED, DataType$3.OBS_SEGMENTATIONS, PrecomputedMeshDataLoader, PrecomputedMeshSource, ngPrecomputedMeshSchema),
+  makeFileType(FileType$1.OBS_POINTS_NG_ANNOTATIONS, DataType$3.OBS_POINTS, NgAnnotationPointsDataLoader, PrecomputedMeshSource, ngPointAnnotationSchema),
   // All legacy file types
   makeFileType(FileType$1.OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR, DataType$3.OBS_FEATURE_MATRIX, MatrixZarrAsObsFeatureMatrixLoader, ZarrDataSource, z.null()),
   makeFileType(FileType$1.IMAGE_RASTER_JSON, DataType$3.IMAGE, RasterJsonAsImageLoader, JsonSource, rasterJsonSchema),