@vitessce/all 3.8.1 → 3.8.2

package/dist/{OrbitControls-jfNc3RRq.js → OrbitControls-CeIrm0B5.js}

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

package/dist/{ReactNeuroglancer-CebI6oJd.js → ReactNeuroglancer-BoUKguqy.js}

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

package/dist/{deflate-CiJW6nDN.js → deflate-BmPQfLH1.js}

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

package/dist/{higlass-0qSOunpw.js → higlass-CHvsEtQd.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 { aZ as commonjsGlobal$1, a_ as requireObjectAssign, aF as getDefaultExportFromCjs$1, a$ as earcut } from "./index-BvVS_3Vn.js";
+import { aZ as commonjsGlobal$1, a_ as requireObjectAssign, aF as getDefaultExportFromCjs$1, a$ as earcut } from "./index-BNUI-w49.js";
 var promise = {};
 var hasRequiredPromise;
 function requirePromise() {

package/dist/{index-BvVS_3Vn.js → index-BNUI-w49.js}

@@ -9131,6 +9131,9 @@ const FileType$1 = {
   OBS_SEGMENTATIONS_OME_TIFF: "obsSegmentations.ome-tiff",
   // GLB
   OBS_SEGMENTATIONS_GLB: "obsSegmentations.glb",
+  // Neuroglancer
+  // Precomputed (mesh) format
+  OBS_SEGMENTATIONS_NG_PRECOMPUTED: "obsSegmentations.ng-precomputed",
   // New file types to support old file types:
   // - cells.json
   OBS_EMBEDDING_CELLS_JSON: "obsEmbedding.cells.json",
@@ -9385,6 +9388,7 @@ const ViewHelpMapping = {
   [FileType$1.OBS_LABELS_MUDATA_ZARR]: DataType$3.OBS_LABELS,
   [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.IMAGE_SPATIALDATA_ZARR]: DataType$3.IMAGE,
   [FileType$1.LABELS_SPATIALDATA_ZARR]: DataType$3.OBS_SEGMENTATIONS,
   [FileType$1.SHAPES_SPATIALDATA_ZARR]: DataType$3.OBS_SEGMENTATIONS,
@@ -10714,6 +10718,18 @@ const meshGlbSchema = z.object({
   sceneScaleZ: z.number(),
   materialSide: z.enum(["front", "back"])
 }).partial().nullable();
+const ngSchema = 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"]),
+  // 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)
+}).partial().nullable();
 const obsEmbeddingAnndataSchema = annDataObsEmbedding;
 const obsSpotsAnndataSchema = annDataObsLocations;
 const obsPointsAnndataSchema = annDataObsLocations;
@@ -209303,22 +209319,22 @@ async function getDecoder(fileDirectory) {
   const Decoder = await importFn();
   return new Decoder(fileDirectory);
 }
-addDecoder([void 0, 1], () => import("./raw-AeiJCa5u.js").then((m2) => m2.default));
-addDecoder(5, () => import("./lzw-C7bIlAE9.js").then((m2) => m2.default));
+addDecoder([void 0, 1], () => import("./raw-CDmwxpDL.js").then((m2) => m2.default));
+addDecoder(5, () => import("./lzw-BlOU-CBg.js").then((m2) => m2.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-D1F3JoMr.js").then((m2) => m2.default));
-addDecoder([8, 32946], () => import("./deflate-CiJW6nDN.js").then((m2) => m2.default));
-addDecoder(32773, () => import("./packbits-B0NoJqXw.js").then((m2) => m2.default));
+addDecoder(7, () => import("./jpeg-BB_ilRwM.js").then((m2) => m2.default));
+addDecoder([8, 32946], () => import("./deflate-BmPQfLH1.js").then((m2) => m2.default));
+addDecoder(32773, () => import("./packbits-BkMUG84m.js").then((m2) => m2.default));
 addDecoder(
   34887,
-  () => import("./lerc-BjYwawxE.js").then(async (m2) => {
+  () => import("./lerc-STi5EC9q.js").then(async (m2) => {
     await m2.zstd.init();
     return m2;
   }).then((m2) => m2.default)
 );
-addDecoder(50001, () => import("./webimage-CrFV1v2P.js").then((m2) => m2.default));
+addDecoder(50001, () => import("./webimage-C4EDX2gd.js").then((m2) => m2.default));
 function copyNewSize(array2, width2, height2, samplesPerPixel = 1) {
   return new (Object.getPrototypeOf(array2)).constructor(width2 * height2 * samplesPerPixel);
 }
@@ -248643,7 +248659,7 @@ let Location$1 = class Location {
   }
   resolve(path2) {
     let root2 = new URL(`file://${this.path.endsWith("/") ? this.path : `${this.path}/`}`);
-    return new Location(this.store, new URL(path2, root2).pathname);
+    return new Location(this.store, decodeURIComponent(new URL(path2, root2).pathname));
   }
 };
 function root$1(store) {
@@ -253014,12 +253030,12 @@ class ErrorBoundary extends React__default.Component {
   }
 }
 const LazySpatialThree = React__default.lazy(async () => {
-  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-D7Xl0b0t.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-BR7YdakD.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-CkinFFl6.js");
+  const { SpatialWrapper: SpatialWrapper2 } = await import("./index-BWxI6QUS.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 }) }) }) }));
@@ -253224,6 +253240,7 @@ function SpatialSubscriber(props) {
     CoordinationType$1.LEGEND_VISIBLE
   ], coordinationScopes, coordinationScopesBy, CoordinationType$1.POINT_LAYER);
   const is3dMode = spatialRenderingMode === "3D";
+  const shouldUseThree = threeFor3d && is3dMode;
   const [deckWidth, deckHeight, deckRef] = useDeckCanvasSize();
   const [threeWidth, threeHeight, threeRef] = useGridItemSize();
   const width2 = threeFor3d && deckWidth === void 0 ? threeWidth : deckWidth;
@@ -253492,7 +253509,7 @@ function SpatialSubscriber(props) {
       }
     }
   };
-  return jsxRuntimeExports.jsxs(TitleInfo, { title: title2, info: subtitle, isSpatial: true, urls: urls2, theme, closeButtonVisible, downloadButtonVisible, removeGridComponent, isReady, errors, children: [is3dMode ? acceleratedFor3d ? jsxRuntimeExports.jsx(SpatialAcceleratedAdapter, { ref: threeRef, uuid: uuid2, width: width2, height: height2, theme, hideTools: !isSelectable, rotation: [rotationX, rotationY, rotationZ], setRotationX, setRotationY, setRotationZ, targetT, targetZ, viewState: isValidViewState ? {
+  return jsxRuntimeExports.jsxs(TitleInfo, { title: title2, info: subtitle, isSpatial: true, urls: urls2, theme, closeButtonVisible, downloadButtonVisible, removeGridComponent, isReady, errors, children: [shouldUseThree ? acceleratedFor3d ? jsxRuntimeExports.jsx(SpatialAcceleratedAdapter, { ref: threeRef, uuid: uuid2, width: width2, height: height2, theme, hideTools: !isSelectable, rotation: [rotationX, rotationY, rotationZ], setRotationX, setRotationY, setRotationZ, targetT, targetZ, viewState: isValidViewState ? {
     zoom: zoom2,
     target: [targetX2, targetY2, targetZ],
     rotationX,
@@ -266219,7 +266236,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-0qSOunpw.js");
+  const { HiGlassComponent } = await import("./higlass-CHvsEtQd.js");
   return { default: HiGlassComponent };
 });
 const HG_SIZE = 800;
@@ -269166,7 +269183,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-CebI6oJd.js"));
+const LazyReactNeuroglancer = React__default.lazy(() => import("./ReactNeuroglancer-BoUKguqy.js"));
 function createWorker() {
   return new WorkerFactory();
 }
@@ -269243,6 +269260,108 @@ 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 }) }) })] });
   }
 }
+const DEFAULT_NG_PROPS = {
+  layout: "3d",
+  position: [0, 0, 0],
+  projectionOrientation: [0, 0, 0, 1],
+  projectionScale: 1024,
+  crossSectionScale: 1
+};
+function toPrecomputedSource(url) {
+  if (!url) {
+    return void 0;
+  }
+  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");
+  }
+  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");
+  }
+  return {
+    x: xNm ? [dimensionX, dimensionUnit] : [1, "nm"],
+    y: yNm ? [dimensionY, dimensionUnit] : [1, "nm"],
+    z: zNm ? [dimensionZ, dimensionUnit] : [1, "nm"]
+  };
+}
+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);
+}
 /**
  * @license
  * Copyright 2010-2023 Three.js Authors
@@ -298858,10 +298977,6 @@ const multiplyQuat = (a2, b2) => {
 const conjQuat = (q) => [-q[0], -q[1], -q[2], q[3]];
 const rad2deg = (r3) => r3 * 180 / Math.PI;
 const deg2rad = (d) => d * Math.PI / 180;
-function isValidState(viewerState) {
-  const { projectionScale, projectionOrientation, position: position2, dimensions } = viewerState || {};
-  return dimensions !== void 0 && typeof projectionScale === "number" && Array.isArray(projectionOrientation) && projectionOrientation.length === 4 && Array.isArray(position2) && position2.length === 3;
-}
 function valueGreaterThanEpsilon(a2, b2, epsilon3) {
   if (Array.isArray(a2) && Array.isArray(b2) && a2.length === b2.length) {
     return a2.some((val, i2) => Math.abs(val - b2[i2]) > epsilon3);
@@ -298873,8 +298988,6 @@ function valueGreaterThanEpsilon(a2, b2, epsilon3) {
 }
 const nearEq = (a2, b2, epsilon3) => Number.isFinite(a2) && Number.isFinite(b2) ? Math.abs(a2 - b2) <= epsilon3 : a2 === b2;
 function diffCameraState(prev2, next4) {
-  if (!isValidState(next4))
-    return { changed: false, scale: false, pos: false, rot: false };
   const eps = EPSILON_KEYS_MAPPING_NG;
   const scale2 = valueGreaterThanEpsilon(prev2?.projectionScale, next4?.projectionScale, eps.projectionScale);
   const posHard = valueGreaterThanEpsilon(prev2?.position, next4?.position, eps.position);
@@ -298921,7 +299034,7 @@ 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, viewerState: initialViewerState } = props;
+  const { coordinationScopes: coordinationScopesRaw, closeButtonVisible, downloadButtonVisible, removeGridComponent, theme, title: title2 = "Neuroglancer", helpText = ViewHelpMapping.NEUROGLANCER } = props;
   const loaders = useLoaders();
   const coordinationScopes = useCoordinationScopes(coordinationScopesRaw);
   const [{
@@ -298953,11 +299066,12 @@ function NeuroglancerSubscriber(props) {
     setSpatialRotationOrbit: setRotationOrbit,
     setSpatialZoom: setZoom
   }] = useCoordination(COMPONENT_COORDINATION_TYPES[ViewType$1.NEUROGLANCER], coordinationScopes);
-  const latestViewerStateRef = useRef(initialViewerState);
-  const initialRotationPushedRef = useRef(false);
   const { classes: classes2 } = useStyles$4();
   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 initialRotationPushedRef = useRef(false);
   const ngRotPushAtRef = useRef(0);
   const lastInteractionSource = useRef(null);
   const applyNgUpdateTimeoutRef = useRef(null);
@@ -299004,7 +299118,7 @@ function NeuroglancerSubscriber(props) {
         return;
       const zRef = Number.isFinite(spatialZoom) ? spatialZoom : 0;
       initialRenderCalibratorRef.current = makeVitNgZoomCalibrator(projectionScale, zRef);
-      const [px2 = 0, py2 = 0, pz2 = 0] = Array.isArray(position2) ? position2 : [0, 0, 0];
+      const [px2 = 0, py2 = 0, pz2 = 0] = position2;
       const tX = Number.isFinite(spatialTargetX) ? spatialTargetX : 0;
       const tY = Number.isFinite(spatialTargetY) ? spatialTargetY : 0;
       translationOffsetRef.current = [px2 - tX, py2 - tY, pz2];
@@ -357332,6 +357446,22 @@ class SpatialDataObsEmbeddingLoader extends ObsEmbeddingAnndataLoader {
     this.tablePath = this.options.tablePath;
   }
 }
+class PrecomputedMeshSource {
+  constructor({ url, requestInit: requestInit2 }) {
+    this.url = url;
+    this.requestInit = requestInit2;
+  }
+}
+class PrecomputedMeshDataLoader extends AbstractTwoStepLoader {
+  /* eslint-disable class-methods-use-this */
+  async load(url) {
+    return new LoaderResult({
+      obsIndex: null,
+      obsSegmentations: {},
+      obsSegmentationsType: "mesh"
+    }, url);
+  }
+}
 const decoder = new TextDecoder("utf-8");
 const decodeUtf8 = (buffer2) => decoder.decode(buffer2);
 const encoder = new TextEncoder();
@@ -379117,6 +379247,7 @@ 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, FeatureLabelsAnndataLoader, 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),
   // 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),

package/dist/{index-D7Xl0b0t.js → index-BR7YdakD.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-BvVS_3Vn.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-BNUI-w49.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-jfNc3RRq.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-CeIrm0B5.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-BW_QR91G.js"), []);
+  } = suspend(async () => import("./troika-three-text.esm-C8Q3aJRr.js"), []);
   const invalidate = useThree(({
     invalidate: invalidate2
   }) => invalidate2);

package/dist/{index-CkinFFl6.js → index-BWxI6QUS.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, ao as jsxRuntimeExports, aE as GLSL3, am as BackSide } from "./index-BvVS_3Vn.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, ao as jsxRuntimeExports, aE as GLSL3, am as BackSide } from "./index-BNUI-w49.js";
 import { useRef, useState, useMemo, useEffect, useCallback } from "react";
-import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-jfNc3RRq.js";
+import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-CeIrm0B5.js";
 const LogLevel = {
   INFO: "info",
   WARN: "warn",

package/dist/index.js

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

package/dist/{jpeg-D1F3JoMr.js → jpeg-BB_ilRwM.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BvVS_3Vn.js";
+import { aW as BaseDecoder } from "./index-BNUI-w49.js";
 const dctZigZag = new Int32Array([
   0,
   1,

package/dist/{lerc-BjYwawxE.js → lerc-STi5EC9q.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { aF as getDefaultExportFromCjs, aW as BaseDecoder, aX as LercParameters, aY as LercAddCompression } from "./index-BvVS_3Vn.js";
+import { aF as getDefaultExportFromCjs, aW as BaseDecoder, aX as LercParameters, aY as LercAddCompression } from "./index-BNUI-w49.js";
 var LercDecode = { exports: {} };
 var hasRequiredLercDecode;
 function requireLercDecode() {

package/dist/{lzw-C7bIlAE9.js → lzw-BlOU-CBg.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BvVS_3Vn.js";
+import { aW as BaseDecoder } from "./index-BNUI-w49.js";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;
 const EOI_CODE = 257;

package/dist/{packbits-B0NoJqXw.js → packbits-BkMUG84m.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BvVS_3Vn.js";
+import { aW as BaseDecoder } from "./index-BNUI-w49.js";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     const dataView = new DataView(buffer);

package/dist/{raw-AeiJCa5u.js → raw-CDmwxpDL.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BvVS_3Vn.js";
+import { aW as BaseDecoder } from "./index-BNUI-w49.js";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return buffer;

package/dist/{troika-three-text.esm-BW_QR91G.js → troika-three-text.esm-C8Q3aJRr.js}

@@ -1,4 +1,4 @@
-import { bG as MeshDistanceMaterial, bH as MeshDepthMaterial, bI as RGBADepthPacking, ae as UniformsUtils, bJ 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, bK as InstancedBufferAttribute } from "./index-BvVS_3Vn.js";
+import { bG as MeshDistanceMaterial, bH as MeshDepthMaterial, bI as RGBADepthPacking, ae as UniformsUtils, bJ 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, bK as InstancedBufferAttribute } from "./index-BNUI-w49.js";
 function workerBootstrap() {
   var modules = /* @__PURE__ */ Object.create(null);
   function registerModule(ref, callback) {

package/dist/{webimage-CrFV1v2P.js → webimage-C4EDX2gd.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BvVS_3Vn.js";
+import { aW as BaseDecoder } from "./index-BNUI-w49.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":"AAWA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,CAAC,EAqDF,MAAM,mBAAmB,CAAC;AAkL3B,eAAO,MAAM,aAAa,kBA8BzB,CAAC;AAEF,eAAO,MAAM,aAAa,wDA2EzB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAwGzB,CAAA;gCACwB,CAAC;;;yBAIb,CAAC;gCAAsD,CAAC;;;;;;;;;;;;;;;;iBAeZ,CAAC;;;;iBAIpC,CAAC;;;;;;;YAOtB,CAAC;;;YAGG,CAAC;;;;;;;YAKL,CAAC;;;YAEH,CAAA;;;;;;;YAKqB,CAAC;;;YAEW,CAAC;;;;;;;;;;;;;;YAkBK,CAAC;;;YAIxB,CAAC;;;;;;;;YAWT,CAAC;;;;YAIO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;yBAMgC,CAAC;gCAChC,CAAC;;;;;;;;iBAEsD,CAAC;;;;YACF,CAAC;;;;YACH,CAAC;;;;YACX,CAAC;;;;;;;YAExB,CAAC;;;;YACU,CAAC;;;;;;;;;;;;;;;;;;;;yBAIhC,CAAC;gCAAuD,CAAA;;;;;;;;iBAGjE,CAAC;;;;YAA8F,CAAC;;;;YACjC,CAAA;;;;YACG,CAAC;;;;;;;YAEhC,CAAC;;;;YACzB,CAAC;;;;;;;;;;;wBAwDm1E,CAAC;;;wBAA6E,CAAC;;;;;;;;iBAAwR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;iBAAiR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;;;yBAAkZ,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;yBAA8E,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;;;;;iBAAgR,CAAC;wBAA8C,CAAC;;;iBAAsE,CAAC;wBAA8C,CAAC;;;;;;;;;;;;qBAAygB,CAAC;;;;qBAA2J,CAAC;;;;;;qBAAsN,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;qBAA0K,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;;;;YAAoP,CAAC;;;YAAmE,CAAC;;;;;;;;YAAuR,CAAC;;;;YAAkG,CAAC;;;;;;wBAAqM,CAAC;;;;iBAAyG,CAAC;wBAA8C,CAAC;;;;iBAAkG,CAAC;wBAA8C,CAAC;;;;yBAAiH,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;iBAAiG,CAAC;wBAA8C,CAAC;;;;;;qBAAoM,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;YAAgG,CAAC;;;;YAAmG,CAAC;;;;;;wBAAyJ,CAAC;;;;iBAAyG,CAAC;wBAA8C,CAAC;;;;iBAAkG,CAAC;wBAA8C,CAAC;;;;yBAAiH,CAAC;gCAAsD,CAAC;cAAoC,CAAC;wBAA8C,CAAC;;;;iBAAiG,CAAC;wBAA8C,CAAC;;;;;;qBAAoM,CAAC;;cAAiD,CAAC;iBAAuC,CAAC;;;;YAAgG,CAAC;;;;YAAmG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBApiBvgS,CAAC;;;;;qBAGkB,CAAC;qBAA4C,CAAC;;;;;;;;;qBAI/B,CAAC;6BAAoD,CAAC;;sBAClC,CAAC;;;;;qBAQzC,CAAC;qBAEZ,CAAC;;;;;;;;;qBAWD,CAAC;6BAEK,CAAC;;;;;;;;;;;;;kBAuBH,CAAA;mBAGE,CAAC;gBACkB,CAAC;gBAEzB,CAAC;uBAEH,CAAF;iBACU,CAAC;oBACS,CAAC;oBAER,CAAC;qBAEZ,CAAF;;kBAC0B,CAAC;mBAEvB,CAAC;gBACmB,CAAC;gBAGlB,CAAC;uBAEe,CAAC;iBACC,CAAC;oBAIrB,CAAA;oBAEgB,CAAC;qBAET,CAAC;;;;;;gBAMZ,CAAD;sBAA0B,CAAC;;;;;qBAOD,CAAC;qBAGC,CAAC;;;;;;;;;qBAaH,CAAC;6BAGzB,CAAC;;mBAEuB,CAAC;kBAExB,CAAC;mBAEL,CAAC;gBAEU,CAAC;gBACS,CAAC;uBAElB,CAAC;iBAEF,CAAC;oBACoB,CAAC;oBAEP,CAAC;qBAEA,CAAC;;;;;;gBAKmB,CAAC;sBAC9B,CAAC;;;;;qBAI6C,CAAC;qBAA4C,CAAC;;;;;;;;;qBAGtC,CAAC;6BAChC,CAAC;;mBACO,CAAC;kBAAsB,CAAC;mBAAyC,CAAC;gBAAmD,CAAC;gBAClJ,CAAC;uBACN,CAAC;iBACgB,CAAC;oBAA0C,CAAC;oBAG7D,CAAC;qBAA2C,CAAC;;;;;;;;;gBAG3B,CAAC;sBACN,CAAC;;;;;qBAOM,CAAC;qBACjB,CAAC;;;;;;;;;qBAGmC,CAAC;6BACC,CAAC;;mBAEjD,CAAD;kBAAsB,CAAC;mBACZ,CAAC;gBACX,CAAC;gBAAuC,CAAA;uBACzB,CAAC;iBAAuC,CAAC;oBACrC,CAAC;oBACT,CAAC;qBAA2C,CAAC;;;;;;;;;;;gBAIvC,CAAC;sBAClB,CAAD;;;;;qBAGe,CAAC;qBAA4C,CAAC;;;;;;;;;qBAI/B,CAAC;6BACD,CAAC;;mBACZ,CAAC;kBAAsB,CAAC;mBACzC,CAAC;gBAAmD,CAAC;gBACtD,CAAC;uBAA6C,CAAC;iBAAuC,CAAC;oBAKvF,CADF;oBACkB,CAAC;qBAA2C,CAAC;;;;;;;;;;;;;;OA6F9D,CAAC;AAIF,eAAO,MAAM,qBAAqB;;;;;;;;aA7WtB,CAAC;cAGX,CAAD;eAES,CAAC;;;aAIH,CAAC;cAEP,CAAF;eACgB,CAAC;;;;;;;;;;;;;;;;;;;aAgCd,CAAC;cACQ,CAAC;eACW,CAAC;;;;;;;;;;;;;;;;;;;aAqBE,CAAC;cAC1B,CAAC;eAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aApE/B,CAAC;cAGX,CAAD;eAES,CAAC;;;aAIH,CAAC;cAEP,CAAF;eACgB,CAAC;;;;;;;;;;;;;;;;;;;aAgCd,CAAC;cACQ,CAAC;eACW,CAAC;;;;;;;;;;;;;;;;;;;aAqBE,CAAC;cAC1B,CAAC;eAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kzBA2hB1C,CAAC;AAEF,eAAO,MAAM,kBAAkB,uBAK9B,CAAC"}

package/dist-tsc/base-plugins.js

@@ -1,6 +1,6 @@
 import { FileType, DataType, ViewType, CoordinationType, AsyncFunctionType, COMPONENT_COORDINATION_TYPES, ALT_ZARR_STORE_TYPES, } from '@vitessce/constants-internal';
 import { PluginFileType, PluginJointFileType, PluginViewType, PluginCoordinationType, PluginAsyncFunction, } from '@vitessce/plugins';
-import { z, obsEmbeddingCsvSchema, obsSetsCsvSchema, obsSpotsCsvSchema, obsPointsCsvSchema, obsLocationsCsvSchema, obsLabelsCsvSchema, featureLabelsCsvSchema, sampleSetsCsvSchema, obsSetsAnndataSchema, sampleSetsAnndataSchema, obsEmbeddingAnndataSchema, obsSpotsAnndataSchema, obsPointsAnndataSchema, obsLocationsAnndataSchema, obsLabelsAnndataSchema, obsFeatureMatrixAnndataSchema, obsFeatureColumnsAnndataSchema, obsSegmentationsAnndataSchema, featureLabelsAnndataSchema, sampleEdgesAnndataSchema, comparisonMetadataAnndataSchema, featureStatsAnndataSchema, featureSetStatsAnndataSchema, obsSetStatsAnndataSchema, rasterJsonSchema, anndataZarrSchema, anndataH5adSchema, spatialdataZarrSchema, anndataCellsZarrSchema, anndataCellSetsZarrSchema, anndataExpressionMatrixZarrSchema, cellsJsonSchema, imageOmeZarrSchema, imageOmeTiffSchema, imageSpatialdataSchema, obsSegmentationsOmeTiffSchema, obsSegmentationsOmeZarrSchema, obsSegmentationsSpatialdataSchema, obsFeatureMatrixSpatialdataSchema, obsSpotsSpatialdataSchema, obsPointsSpatialdataSchema, obsSetsSpatialdataSchema, obsEmbeddingSpatialdataSchema, obsSetPath, rgbArray, obsSetsSchema, imageLayerObj, cellsLayerObj, neighborhoodsLayerObj, moleculesLayerObj, meshGlbSchema, } from '@vitessce/schemas';
+import { z, obsEmbeddingCsvSchema, obsSetsCsvSchema, obsSpotsCsvSchema, obsPointsCsvSchema, obsLocationsCsvSchema, obsLabelsCsvSchema, featureLabelsCsvSchema, sampleSetsCsvSchema, obsSetsAnndataSchema, sampleSetsAnndataSchema, obsEmbeddingAnndataSchema, obsSpotsAnndataSchema, obsPointsAnndataSchema, obsLocationsAnndataSchema, obsLabelsAnndataSchema, obsFeatureMatrixAnndataSchema, obsFeatureColumnsAnndataSchema, obsSegmentationsAnndataSchema, featureLabelsAnndataSchema, sampleEdgesAnndataSchema, comparisonMetadataAnndataSchema, featureStatsAnndataSchema, featureSetStatsAnndataSchema, obsSetStatsAnndataSchema, rasterJsonSchema, anndataZarrSchema, anndataH5adSchema, spatialdataZarrSchema, anndataCellsZarrSchema, anndataCellSetsZarrSchema, anndataExpressionMatrixZarrSchema, cellsJsonSchema, imageOmeZarrSchema, imageOmeTiffSchema, imageSpatialdataSchema, obsSegmentationsOmeTiffSchema, obsSegmentationsOmeZarrSchema, obsSegmentationsSpatialdataSchema, obsFeatureMatrixSpatialdataSchema, obsSpotsSpatialdataSchema, obsPointsSpatialdataSchema, obsSetsSpatialdataSchema, obsEmbeddingSpatialdataSchema, obsSetPath, rgbArray, obsSetsSchema, imageLayerObj, cellsLayerObj, neighborhoodsLayerObj, moleculesLayerObj, meshGlbSchema, ngSchema, } from '@vitessce/schemas';
 // Register view type plugins
 import { DescriptionSubscriber } from '@vitessce/description';
 import { ObsSetsManagerSubscriber } from '@vitessce/obs-sets-manager';
@@ -37,7 +37,9 @@ import {
 // OME
 OmeZarrLoader, OmeZarrAsObsSegmentationsLoader, 
 // SpatialData
-SpatialDataTableSource, SpatialDataShapesSource, SpatialDataPointsSource, SpatialDataImageLoader, SpatialDataLabelsLoader, SpatialDataObsSpotsLoader, SpatialDataObsPointsLoader, SpatialDataObsSegmentationsLoader, SpatialDataObsSetsLoader, SpatialDataObsEmbeddingLoader, } from '@vitessce/spatial-zarr';
+SpatialDataTableSource, SpatialDataShapesSource, SpatialDataPointsSource, SpatialDataImageLoader, SpatialDataLabelsLoader, SpatialDataObsSpotsLoader, SpatialDataObsPointsLoader, SpatialDataObsSegmentationsLoader, SpatialDataObsSetsLoader, SpatialDataObsEmbeddingLoader, 
+// NG precomputed
+NgPrecomputedMeshSource, NgPrecomputedMeshLoader, } from '@vitessce/spatial-zarr';
 import { OmeTiffAsObsSegmentationsLoader, OmeTiffLoader, OmeTiffSource, } from '@vitessce/ome-tiff';
 import { GlbSource, GlbLoader, } from '@vitessce/glb';
 // Joint file types
@@ -157,6 +159,7 @@ export const baseFileTypes = [
     ...makeZarrFileTypes(FileType.OBS_EMBEDDING_SPATIALDATA_ZARR, DataType.OBS_EMBEDDING, SpatialDataObsEmbeddingLoader, SpatialDataTableSource, obsEmbeddingSpatialdataSchema),
     ...makeZarrFileTypes(FileType.FEATURE_LABELS_SPATIALDATA_ZARR, DataType.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
     makeFileType(FileType.OBS_SEGMENTATIONS_GLB, DataType.OBS_SEGMENTATIONS, GlbLoader, GlbSource, meshGlbSchema),
+    makeFileType(FileType.OBS_SEGMENTATIONS_NG_PRECOMPUTED, DataType.OBS_SEGMENTATIONS, NgPrecomputedMeshLoader, NgPrecomputedMeshSource, ngSchema),
     // All legacy file types
     makeFileType(FileType.OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR, DataType.OBS_FEATURE_MATRIX, MatrixZarrAsObsFeatureMatrixLoader, ZarrDataSource, z.null()),
     makeFileType(FileType.IMAGE_RASTER_JSON, DataType.IMAGE, RasterJsonAsImageLoader, JsonSource, rasterJsonSchema),

package/package.json

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

package/src/base-plugins.ts

@@ -73,6 +73,7 @@ import {
   neighborhoodsLayerObj,
   moleculesLayerObj,
   meshGlbSchema,
+  ngSchema,
 } from '@vitessce/schemas';
 
 // Register view type plugins
@@ -180,6 +181,9 @@ import {
   SpatialDataObsSegmentationsLoader,
   SpatialDataObsSetsLoader,
   SpatialDataObsEmbeddingLoader,
+  // NG precomputed
+  NgPrecomputedMeshSource,
+  NgPrecomputedMeshLoader,
 } from '@vitessce/spatial-zarr';
 
 import {
@@ -339,6 +343,7 @@ export const baseFileTypes = [
   ...makeZarrFileTypes(FileType.FEATURE_LABELS_SPATIALDATA_ZARR, DataType.FEATURE_LABELS, FeatureLabelsAnndataLoader, SpatialDataTableSource, featureLabelsAnndataSchema),
 
   makeFileType(FileType.OBS_SEGMENTATIONS_GLB, DataType.OBS_SEGMENTATIONS, GlbLoader, GlbSource, meshGlbSchema),
+  makeFileType(FileType.OBS_SEGMENTATIONS_NG_PRECOMPUTED, DataType.OBS_SEGMENTATIONS, NgPrecomputedMeshLoader, NgPrecomputedMeshSource, ngSchema),
   // All legacy file types
   makeFileType(FileType.OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR, DataType.OBS_FEATURE_MATRIX, MatrixZarrAsObsFeatureMatrixLoader, ZarrDataSource, z.null()),
   makeFileType(FileType.IMAGE_RASTER_JSON, DataType.IMAGE, RasterJsonAsImageLoader, JsonSource, rasterJsonSchema),