@aics/vole-core 3.12.4 → 3.13.1

package/es/types/loaders/zarr_utils/types.d.ts

@@ -1,5 +1,5 @@
-import * as zarr from "@zarrita/core";
-import type WrappedStore from "./WrappedStore.js";
+import * as zarr from "zarrita";
+import { AsyncReadable } from "@zarrita/storage";
 import type SubscribableRequestQueue from "../../utils/SubscribableRequestQueue.js";
 export type TCZYX<T> = [T, T, T, T, T];
 export type SubscriberId = ReturnType<SubscribableRequestQueue["addSubscriber"]>;
@@ -53,16 +53,16 @@ export type OMEMultiscale = {
 };
 /** https://ngff.openmicroscopy.org/latest/#omero-md */
 export type OmeroTransitionalMetadata = {
-    id: number;
-    name: string;
-    version: string;
+    id?: number;
+    name?: string;
+    version?: string;
     channels: {
-        active: boolean;
-        coefficient: number;
+        active?: boolean;
+        coefficient?: number;
         color: string;
-        family: string;
-        inverted: boolean;
-        label: string;
+        family?: string;
+        inverted?: boolean;
+        label?: string;
         window: {
             end: number;
             max: number;
@@ -73,9 +73,14 @@ export type OmeroTransitionalMetadata = {
 };
 export type OMEZarrMetadata = {
     multiscales: OMEMultiscale[];
-    omero: OmeroTransitionalMetadata;
+    omero?: OmeroTransitionalMetadata;
+};
+export type WrappedArrayOpts = {
+    subscriber?: SubscriberId;
+    reportChunk?: (coords: number[], subscriber: SubscriberId) => void;
+    isPrefetch?: boolean;
 };
-export type NumericZarrArray = zarr.Array<zarr.NumberDataType, WrappedStore<RequestInit>>;
+export type NumericZarrArray = zarr.Array<zarr.NumberDataType, AsyncReadable<RequestInit & WrappedArrayOpts>>;
 /** A record with everything we need to access and use a single remote source of multiscale OME-Zarr data. */
 export type ZarrSource = {
     /** Representations of each scale level in this zarr. We pick one and pass it to zarrita to load data. */

package/es/types/loaders/zarr_utils/validation.d.ts

@@ -1,7 +1,19 @@
 import { OMEZarrMetadata } from "./types.js";
 /**
- * Validates that the `OMEZarrMetadata` record `data` has the minimal amount of data required to open a volume. Since
+ * If `meta` is the top-level metadata of a zarr node formatted according to the OME-Zarr spec version 0.5, returns
+ * the object formatted according to v0.4 of the spec. For our purposes this just means flattening out the `ome` key.
+ *
+ * Return type is `unknown` because this does no actual validation; use `validateOMEZarrMetadata` for that.
+ */
+export declare const toOMEZarrMetaV4: (meta: unknown) => unknown;
+/** Intermediate stage of validation, before we've picked a single multiscale to validate */
+export type MultiscaleRecord = {
+    multiscales: unknown[];
+};
+export declare function assertMetadataHasMultiscales(meta: unknown, name?: string): asserts meta is MultiscaleRecord;
+/**
+ * Validates that the `OMEZarrMetadata` record `meta` has the minimal amount of data required to open a volume. Since
  * we only ever open one multiscale, we only validate the multiscale metadata record at index `multiscaleIdx` here.
  * `name` is used in error messages to identify the source of the metadata.
  */
-export declare function validateOMEZarrMetadata(data: unknown, multiscaleIdx?: number, name?: string): asserts data is OMEZarrMetadata;
+export declare function validateOMEZarrMetadata(meta: MultiscaleRecord, multiscaleIdx?: number, name?: string): asserts meta is OMEZarrMetadata;

package/es/types/loaders/zarr_utils/wrapArray.d.ts

@@ -0,0 +1,7 @@
+import type { Array as ZarrArray, AsyncReadable, DataType } from "zarrita";
+import VolumeCache from "../../VolumeCache.js";
+import type { WrappedArrayOpts } from "./types.js";
+import SubscribableRequestQueue from "../../utils/SubscribableRequestQueue.js";
+type AsyncReadableExt<Opts> = AsyncReadable<Opts & WrappedArrayOpts>;
+export default function wrapArray<T extends DataType, Opts = unknown, Store extends AsyncReadable<Opts> = AsyncReadable<Opts>>(array: ZarrArray<T, Store>, basePath: string, cache?: VolumeCache, queue?: SubscribableRequestQueue): ZarrArray<T, AsyncReadableExt<Opts>>;
+export {};

package/es/types/workers/VolumeLoaderContext.d.ts

@@ -4,9 +4,8 @@ import { CreateLoaderOptions, PrefetchDirection } from "../loaders/index.js";
 import { ThreadableVolumeLoader, LoadSpec, RawChannelDataCallback, LoadedVolumeInfo } from "../loaders/IVolumeLoader.js";
 import { RawArrayLoader } from "../loaders/RawArrayLoader.js";
 import { TiffLoader } from "../loaders/TiffLoader.js";
-import type { WorkerRequestPayload, WorkerResponsePayload, ChannelLoadEvent, MetadataUpdateEvent } from "./types.js";
+import type { ChannelLoadEvent, MetadataUpdateEvent, WorkerMsgTypeGlobal, WorkerMsgTypeWithLoader, WorkerRequestPayload, WorkerResponsePayload } from "./types.js";
 import type { ZarrLoaderFetchOptions } from "../loaders/OmeZarrLoader.js";
-import { WorkerMsgType } from "./types.js";
 /**
  * A handle that holds the worker and manages requests and messages to/from it.
  *
@@ -22,9 +21,7 @@ declare class SharedLoadWorkerHandle {
     private worker;
     private pendingRequests;
     private workerOpen;
-    private throttleChannelData;
-    onChannelData: ((e: ChannelLoadEvent) => void) | undefined;
-    onUpdateMetadata: ((e: MetadataUpdateEvent) => void) | undefined;
+    onEvent: ((e: ChannelLoadEvent | MetadataUpdateEvent) => void) | undefined;
     constructor();
     /** Given a handle for settling a promise when a response is received from the worker, store it and return its ID */
     private registerMessagePromise;
@@ -35,16 +32,16 @@ declare class SharedLoadWorkerHandle {
      * Send a message of type `T` to the worker.
      * Returns a `Promise` that resolves with the worker's response, or rejects with an error message.
      */
-    sendMessage<T extends WorkerMsgType>(type: T, payload: WorkerRequestPayload<T>): Promise<WorkerResponsePayload<T>>;
+    sendMessage<T extends WorkerMsgTypeGlobal>(type: T, payload: WorkerRequestPayload<T>): Promise<WorkerResponsePayload<T>>;
+    sendMessage<T extends WorkerMsgTypeWithLoader>(type: T, payload: WorkerRequestPayload<T>, loaderId: number): Promise<WorkerResponsePayload<T>>;
     /** Receive a message from the worker. If it's an event, call a callback; otherwise, resolve/reject a promise. */
     private receiveMessage;
-    setThrottleChannelData(throttle: boolean): void;
 }
 /**
  * A context in which volume loaders can be run, which allows loading to run on a WebWorker (where it won't block
  * rendering or UI updates) and loaders to share a single `VolumeCache` and `RequestQueue`.
  *
- * ### To use:
+ * # To use:
  * 1. Create a `VolumeLoaderContext` with the desired cache and queue configuration.
  * 2. Before creating a loader, await `onOpen` to ensure the worker is ready.
  * 3. Create a loader with `createLoader`. This accepts nearly the same arguments as `createVolumeLoader`, but without
@@ -56,14 +53,15 @@ declare class SharedLoadWorkerHandle {
  */
 declare class VolumeLoaderContext {
     private workerHandle;
+    private loaders;
     private openPromise;
-    private activeLoader;
-    private activeLoaderId;
+    private throttleChannelData;
     constructor(maxCacheSize?: number, maxActiveRequests?: number, maxLowPriorityRequests?: number);
     /** Returns a `Promise` that resolves when the worker is ready. `await` it before trying to create a loader. */
     onOpen(): Promise<void>;
     /** Close this context, its worker, and any active loaders. */
     close(): void;
+    private handleEvent;
     /**
      * Create a new loader within this context. This loader will share the context's `VolumeCache` and `RequestQueue`.
      *
@@ -71,7 +69,6 @@ declare class VolumeLoaderContext {
      */
     createLoader(path: string | string[], options?: Omit<CreateLoaderOptions, "cache" | "queue">): Promise<WorkerLoader | TiffLoader | RawArrayLoader>;
     setThrottleChannelData(throttle: boolean): void;
-    getActiveLoader(): WorkerLoader | undefined;
 }
 /**
  * A handle to an instance of `IVolumeLoader` (technically, a `ThreadableVolumeLoader`) running on a WebWorker.
@@ -81,12 +78,11 @@ declare class VolumeLoaderContext {
 declare class WorkerLoader extends ThreadableVolumeLoader {
     private loaderId;
     private workerHandle;
-    private isOpen;
     private currentLoadId;
     private currentLoadCallback;
     private currentMetadataUpdateCallback;
     constructor(loaderId: number, workerHandle: SharedLoadWorkerHandle);
-    private checkIsOpen;
+    private getLoaderId;
     /** Close and permanently invalidate this loader. */
     close(): void;
     /**

package/es/types/workers/types.d.ts

@@ -9,13 +9,18 @@ import type { ZarrLoaderFetchOptions } from "../loaders/OmeZarrLoader.js";
 export declare const enum WorkerMsgType {
     INIT = 0,
     CREATE_LOADER = 1,
-    CREATE_VOLUME = 2,
-    LOAD_DIMS = 3,
-    LOAD_VOLUME_DATA = 4,
-    SET_PREFETCH_PRIORITY_DIRECTIONS = 5,
-    SYNCHRONIZE_MULTICHANNEL_LOADING = 6,
-    UPDATE_FETCH_OPTIONS = 7
+    CLOSE_LOADER = 2,
+    CREATE_VOLUME = 3,
+    LOAD_DIMS = 4,
+    LOAD_VOLUME_DATA = 5,
+    SET_PREFETCH_PRIORITY_DIRECTIONS = 6,
+    SYNCHRONIZE_MULTICHANNEL_LOADING = 7,
+    UPDATE_FETCH_OPTIONS = 8
 }
+/** The variants of `WorkerMessageType` which represent "global" actions that don't require a specific loader */
+export type WorkerMsgTypeGlobal = WorkerMsgType.INIT | WorkerMsgType.CREATE_LOADER;
+/** The variants of `WorkerMessageType` which represent actions on a specific loader */
+export type WorkerMsgTypeWithLoader = Exclude<WorkerMsgType, WorkerMsgTypeGlobal>;
 /** The kind of response a worker can return - `SUCCESS`, `ERROR`, or `EVENT`. */
 export declare const enum WorkerResponseResult {
     SUCCESS = 0,
@@ -29,9 +34,13 @@ export declare const enum WorkerEventType {
     /** Fired when data for a channel (or batch of channels) is loaded */
     CHANNEL_LOAD = 1
 }
-/** All messages to/from a worker carry a `msgId`, a `type`, and a `payload` (whose type is determined by `type`). */
+/**
+ * All messages to/from a worker carry a `msgId`, a `type`, and a `payload` (whose type is determined by `type`).
+ * Messages which operate on a specific loader also require a `loaderId`.
+ */
 type WorkerMsgBase<T extends WorkerMsgType, P> = {
     msgId: number;
+    loaderId: T extends WorkerMsgTypeWithLoader ? number : undefined;
     type: T;
     payload: P;
 };
@@ -46,12 +55,12 @@ export type WorkerRequestPayload<T extends WorkerMsgType> = {
         path: string | string[];
         options?: CreateLoaderOptions;
     };
+    [WorkerMsgType.CLOSE_LOADER]: void;
     [WorkerMsgType.CREATE_VOLUME]: LoadSpec;
     [WorkerMsgType.LOAD_DIMS]: LoadSpec;
     [WorkerMsgType.LOAD_VOLUME_DATA]: {
         imageInfo: ImageInfo;
         loadSpec: LoadSpec;
-        loaderId: number;
         loadId: number;
     };
     [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: PrefetchDirection[];
@@ -61,7 +70,8 @@ export type WorkerRequestPayload<T extends WorkerMsgType> = {
 /** Maps each `WorkerMsgType` to the type of the payload of responses of that type. */
 export type WorkerResponsePayload<T extends WorkerMsgType> = {
     [WorkerMsgType.INIT]: void;
-    [WorkerMsgType.CREATE_LOADER]: boolean;
+    [WorkerMsgType.CREATE_LOADER]: number | undefined;
+    [WorkerMsgType.CLOSE_LOADER]: void;
     [WorkerMsgType.CREATE_VOLUME]: LoadedVolumeInfo;
     [WorkerMsgType.LOAD_DIMS]: VolumeDims[];
     [WorkerMsgType.LOAD_VOLUME_DATA]: void;
@@ -69,11 +79,13 @@ export type WorkerResponsePayload<T extends WorkerMsgType> = {
     [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: void;
     [WorkerMsgType.UPDATE_FETCH_OPTIONS]: void;
 }[T];
-/** Event for when a batch of channel data loads. */
-export type ChannelLoadEvent = {
-    eventType: WorkerEventType.CHANNEL_LOAD;
+type WorkerEventBase<T extends WorkerEventType> = {
+    eventType: T;
     loaderId: number;
     loadId: number;
+};
+/** Event for when a batch of channel data loads. */
+export type ChannelLoadEvent = WorkerEventBase<WorkerEventType.CHANNEL_LOAD> & {
     channelIndex: number[];
     dtype: NumberType[];
     data: TypedArray<NumberType>[];
@@ -81,10 +93,7 @@ export type ChannelLoadEvent = {
     atlasDims?: [number, number];
 };
 /** Event for when metadata updates. */
-export type MetadataUpdateEvent = {
-    eventType: WorkerEventType.METADATA_UPDATE;
-    loaderId: number;
-    loadId: number;
+export type MetadataUpdateEvent = WorkerEventBase<WorkerEventType.METADATA_UPDATE> & {
     imageInfo?: ImageInfo;
     loadSpec?: LoadSpec;
 };

package/es/workers/VolumeLoadWorker.js

@@ -9,9 +9,16 @@ import { rebuildLoadSpec } from "./util.js";
 let cache = undefined;
 let queue = undefined;
 let subscribableQueue = undefined;
-let loader = undefined;
+let loaderCount = 0;
+const loaders = new Map();
+const getLoader = loaderId => {
+  const loader = loaders.get(loaderId);
+  if (loader === undefined) {
+    throw new VolumeLoadError(`Loader with ID ${loaderId} does not exist`);
+  }
+  return loader;
+};
 let initialized = false;
-let copyOnLoad = false;
 const messageHandlers = {
   [WorkerMsgType.INIT]: ({
     maxCacheSize,
@@ -30,37 +37,50 @@ const messageHandlers = {
     path,
     options
   }) => {
-    const pathString = Array.isArray(path) ? path[0] : path;
-    const fileType = options?.fileType || pathToFileType(pathString);
-    copyOnLoad = fileType === VolumeFileFormat.JSON;
-    loader = await createVolumeLoader(path, {
+    const loader = await createVolumeLoader(path, {
       ...options,
       cache,
       queue: subscribableQueue
     });
-    return loader !== undefined;
-  },
-  [WorkerMsgType.CREATE_VOLUME]: async loadSpec => {
     if (loader === undefined) {
-      throw new VolumeLoadError("No loader created");
+      return undefined;
     }
+    const pathString = Array.isArray(path) ? path[0] : path;
+    const fileType = options?.fileType || pathToFileType(pathString);
+    const copyOnLoad = fileType === VolumeFileFormat.JSON;
+    const loaderId = loaderCount;
+    loaderCount += 1;
+    loaders.set(loaderId, {
+      loader,
+      copyOnLoad
+    });
+    return loaderId;
+  },
+  [WorkerMsgType.CLOSE_LOADER]: (_, loaderId) => {
+    loaders.delete(loaderId);
+    return Promise.resolve();
+  },
+  [WorkerMsgType.CREATE_VOLUME]: async (loadSpec, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     return await loader.createImageInfo(rebuildLoadSpec(loadSpec));
   },
-  [WorkerMsgType.LOAD_DIMS]: async loadSpec => {
-    if (loader === undefined) {
-      throw new VolumeLoadError("No loader created");
-    }
+  [WorkerMsgType.LOAD_DIMS]: async (loadSpec, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     return await loader.loadDims(rebuildLoadSpec(loadSpec));
   },
   [WorkerMsgType.LOAD_VOLUME_DATA]: ({
     imageInfo,
     loadSpec,
-    loaderId,
     loadId
-  }) => {
-    if (loader === undefined) {
-      throw new VolumeLoadError("No loader created");
-    }
+  }, loaderId) => {
+    const {
+      loader,
+      copyOnLoad
+    } = getLoader(loaderId);
     return loader.loadRawChannelData(imageInfo, rebuildLoadSpec(loadSpec), (imageInfo, loadSpec) => {
       const message = {
         responseResult: WorkerResponseResult.EVENT,
@@ -86,16 +106,25 @@ const messageHandlers = {
       self.postMessage(message, copyOnLoad ? [] : data.map(d => d.buffer));
     });
   },
-  [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: directions => {
+  [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: (directions, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     // Silently does nothing if the loader isn't an `OMEZarrLoader`
     loader?.setPrefetchPriority(directions);
     return Promise.resolve();
   },
-  [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: syncChannels => {
+  [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: (syncChannels, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     loader?.syncMultichannelLoading(syncChannels);
     return Promise.resolve();
   },
-  [WorkerMsgType.UPDATE_FETCH_OPTIONS]: fetchOptions => {
+  [WorkerMsgType.UPDATE_FETCH_OPTIONS]: (fetchOptions, loaderId) => {
+    const {
+      loader
+    } = getLoader(loaderId);
     loader?.updateFetchOptions(fetchOptions);
     return Promise.resolve();
   }
@@ -103,25 +132,18 @@ const messageHandlers = {
 self.onmessage = async ({
   data
 }) => {
-  const {
-    msgId,
-    type,
-    payload
-  } = data;
   let message;
   try {
-    const response = await messageHandlers[type](payload);
+    const response = await messageHandlers[data.type](data.payload, data.loaderId);
     message = {
+      ...data,
       responseResult: WorkerResponseResult.SUCCESS,
-      msgId,
-      type,
       payload: response
     };
   } catch (e) {
     message = {
+      ...data,
       responseResult: WorkerResponseResult.ERROR,
-      msgId,
-      type,
       payload: serializeError(e)
     };
   }

package/es/workers/VolumeLoaderContext.js

@@ -21,11 +21,11 @@ const throttle = throttledQueue(1, 16);
 class SharedLoadWorkerHandle {
   pendingRequests = [];
   workerOpen = true;
-  throttleChannelData = false;
-  onChannelData = undefined;
-  onUpdateMetadata = undefined;
+  onEvent = undefined;
   constructor() {
-    this.worker = new Worker(new URL("./VolumeLoadWorker", import.meta.url));
+    this.worker = new Worker(new URL("./VolumeLoadWorker", import.meta.url), {
+      type: "module"
+    });
     this.worker.onmessage = this.receiveMessage.bind(this);
   }
 
@@ -53,7 +53,11 @@ class SharedLoadWorkerHandle {
    * Send a message of type `T` to the worker.
    * Returns a `Promise` that resolves with the worker's response, or rejects with an error message.
    */
-  sendMessage(type, payload) {
+  // overload 1: message is a global action and does not require a loader ID
+
+  // overload 2: message is a loader-specific action and requires a loader ID
+
+  sendMessage(type, payload, loaderId) {
     let msgId = -1;
     const promise = new Promise((resolve, reject) => {
       msgId = this.registerMessagePromise({
@@ -65,7 +69,8 @@ class SharedLoadWorkerHandle {
     const msg = {
       msgId,
       type,
-      payload
+      payload,
+      loaderId
     };
     this.worker.postMessage(msg);
     return promise;
@@ -76,17 +81,7 @@ class SharedLoadWorkerHandle {
     data
   }) {
     if (data.responseResult === WorkerResponseResult.EVENT) {
-      if (data.eventType === WorkerEventType.CHANNEL_LOAD) {
-        if (this.onChannelData) {
-          if (this.throttleChannelData) {
-            throttle(() => this.onChannelData ? this.onChannelData(data) : {});
-          } else {
-            this.onChannelData ? this.onChannelData(data) : {};
-          }
-        }
-      } else if (data.eventType === WorkerEventType.METADATA_UPDATE) {
-        this.onUpdateMetadata?.(data);
-      }
+      this.onEvent?.(data);
     } else {
       const prom = this.pendingRequests[data.msgId];
       if (prom === undefined) {
@@ -103,16 +98,13 @@ class SharedLoadWorkerHandle {
       this.pendingRequests[data.msgId] = undefined;
     }
   }
-  setThrottleChannelData(throttle) {
-    this.throttleChannelData = throttle;
-  }
 }
 
 /**
  * A context in which volume loaders can be run, which allows loading to run on a WebWorker (where it won't block
  * rendering or UI updates) and loaders to share a single `VolumeCache` and `RequestQueue`.
  *
- * ### To use:
+ * # To use:
  * 1. Create a `VolumeLoaderContext` with the desired cache and queue configuration.
  * 2. Before creating a loader, await `onOpen` to ensure the worker is ready.
  * 3. Create a loader with `createLoader`. This accepts nearly the same arguments as `createVolumeLoader`, but without
@@ -123,10 +115,11 @@ class SharedLoadWorkerHandle {
  * running on the worker.
  */
 class VolumeLoaderContext {
-  activeLoader = undefined;
-  activeLoaderId = -1;
+  throttleChannelData = false;
   constructor(maxCacheSize, maxActiveRequests, maxLowPriorityRequests) {
     this.workerHandle = new SharedLoadWorkerHandle();
+    this.workerHandle.onEvent = this.handleEvent.bind(this);
+    this.loaders = new Map();
     this.openPromise = this.workerHandle.sendMessage(WorkerMsgType.INIT, {
       maxCacheSize,
       maxActiveRequests,
@@ -145,7 +138,20 @@ class VolumeLoaderContext {
   /** Close this context, its worker, and any active loaders. */
   close() {
     this.workerHandle.close();
-    this.activeLoader?.close();
+  }
+  handleEvent(e) {
+    const loader = this.loaders.get(e.loaderId);
+    if (loader) {
+      if (e.eventType === WorkerEventType.CHANNEL_LOAD) {
+        if (this.throttleChannelData) {
+          throttle(() => loader.onChannelData(e));
+        } else {
+          loader.onChannelData(e);
+        }
+      } else if (e.eventType === WorkerEventType.METADATA_UPDATE) {
+        loader.onUpdateMetadata(e);
+      }
+    }
   }
 
   /**
@@ -165,23 +171,19 @@ class VolumeLoaderContext {
       }
       return new RawArrayLoader(options.rawArrayOptions.data, options.rawArrayOptions.metadata);
     }
-    const success = await this.workerHandle.sendMessage(WorkerMsgType.CREATE_LOADER, {
+    const loaderId = await this.workerHandle.sendMessage(WorkerMsgType.CREATE_LOADER, {
       path,
       options
     });
-    if (!success) {
+    if (loaderId === undefined) {
       throw new Error("Failed to create loader");
     }
-    this.activeLoader?.close();
-    this.activeLoaderId += 1;
-    this.activeLoader = new WorkerLoader(this.activeLoaderId, this.workerHandle);
-    return this.activeLoader;
+    const loader = new WorkerLoader(loaderId, this.workerHandle);
+    this.loaders.set(loaderId, loader);
+    return loader;
   }
   setThrottleChannelData(throttle) {
-    this.workerHandle.setThrottleChannelData(throttle);
-  }
-  getActiveLoader() {
-    return this.activeLoader;
+    this.throttleChannelData = throttle;
   }
 }
 
@@ -191,7 +193,6 @@ class VolumeLoaderContext {
  * Created with `VolumeLoaderContext.createLoader`. See its documentation for more.
  */
 class WorkerLoader extends ThreadableVolumeLoader {
-  isOpen = true;
   currentLoadId = -1;
   currentLoadCallback = undefined;
   currentMetadataUpdateCallback = undefined;
@@ -199,18 +200,21 @@ class WorkerLoader extends ThreadableVolumeLoader {
     super();
     this.loaderId = loaderId;
     this.workerHandle = workerHandle;
-    workerHandle.onChannelData = this.onChannelData.bind(this);
-    workerHandle.onUpdateMetadata = this.onUpdateMetadata.bind(this);
   }
-  checkIsOpen() {
-    if (!this.isOpen || !this.workerHandle.isOpen) {
+  getLoaderId() {
+    if (this.loaderId === undefined || !this.workerHandle.isOpen) {
       throw new Error("Tried to use a closed loader");
     }
+    return this.loaderId;
   }
 
   /** Close and permanently invalidate this loader. */
   close() {
-    this.isOpen = false;
+    if (this.loaderId === undefined) {
+      return;
+    }
+    this.workerHandle.sendMessage(WorkerMsgType.CLOSE_LOADER, undefined, this.loaderId);
+    this.loaderId = undefined;
   }
 
   /**
@@ -218,40 +222,37 @@ class WorkerLoader extends ThreadableVolumeLoader {
    * any chunks are prefetched in any other directions. Has no effect if this loader doesn't support prefetching.
    */
   setPrefetchPriority(directions) {
-    return this.workerHandle.sendMessage(WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS, directions);
+    return this.workerHandle.sendMessage(WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS, directions, this.getLoaderId());
   }
   updateFetchOptions(fetchOptions) {
-    return this.workerHandle.sendMessage(WorkerMsgType.UPDATE_FETCH_OPTIONS, fetchOptions);
+    return this.workerHandle.sendMessage(WorkerMsgType.UPDATE_FETCH_OPTIONS, fetchOptions, this.getLoaderId());
   }
   syncMultichannelLoading(sync) {
-    return this.workerHandle.sendMessage(WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING, sync);
+    return this.workerHandle.sendMessage(WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING, sync, this.getLoaderId());
   }
   loadDims(loadSpec) {
-    this.checkIsOpen();
-    return this.workerHandle.sendMessage(WorkerMsgType.LOAD_DIMS, loadSpec);
+    return this.workerHandle.sendMessage(WorkerMsgType.LOAD_DIMS, loadSpec, this.getLoaderId());
   }
   async createImageInfo(loadSpec) {
-    this.checkIsOpen();
     const {
       imageInfo,
       loadSpec: adjustedLoadSpec
-    } = await this.workerHandle.sendMessage(WorkerMsgType.CREATE_VOLUME, loadSpec);
+    } = await this.workerHandle.sendMessage(WorkerMsgType.CREATE_VOLUME, loadSpec, this.getLoaderId());
     return {
       imageInfo,
       loadSpec: rebuildLoadSpec(adjustedLoadSpec)
     };
   }
   loadRawChannelData(imageInfo, loadSpec, onUpdateMetadata, onData) {
-    this.checkIsOpen();
     this.currentLoadCallback = onData;
     this.currentMetadataUpdateCallback = onUpdateMetadata;
     this.currentLoadId += 1;
-    return this.workerHandle.sendMessage(WorkerMsgType.LOAD_VOLUME_DATA, {
+    const message = {
       imageInfo,
       loadSpec,
-      loaderId: this.loaderId,
       loadId: this.currentLoadId
-    });
+    };
+    return this.workerHandle.sendMessage(WorkerMsgType.LOAD_VOLUME_DATA, message, this.getLoaderId());
   }
   onChannelData(e) {
     if (e.loaderId !== this.loaderId || e.loadId !== this.currentLoadId) {

package/es/workers/types.js

@@ -2,15 +2,20 @@
 export let WorkerMsgType = /*#__PURE__*/function (WorkerMsgType) {
   WorkerMsgType[WorkerMsgType["INIT"] = 0] = "INIT";
   WorkerMsgType[WorkerMsgType["CREATE_LOADER"] = 1] = "CREATE_LOADER";
-  WorkerMsgType[WorkerMsgType["CREATE_VOLUME"] = 2] = "CREATE_VOLUME";
-  WorkerMsgType[WorkerMsgType["LOAD_DIMS"] = 3] = "LOAD_DIMS";
-  WorkerMsgType[WorkerMsgType["LOAD_VOLUME_DATA"] = 4] = "LOAD_VOLUME_DATA";
-  WorkerMsgType[WorkerMsgType["SET_PREFETCH_PRIORITY_DIRECTIONS"] = 5] = "SET_PREFETCH_PRIORITY_DIRECTIONS";
-  WorkerMsgType[WorkerMsgType["SYNCHRONIZE_MULTICHANNEL_LOADING"] = 6] = "SYNCHRONIZE_MULTICHANNEL_LOADING";
-  WorkerMsgType[WorkerMsgType["UPDATE_FETCH_OPTIONS"] = 7] = "UPDATE_FETCH_OPTIONS";
+  WorkerMsgType[WorkerMsgType["CLOSE_LOADER"] = 2] = "CLOSE_LOADER";
+  WorkerMsgType[WorkerMsgType["CREATE_VOLUME"] = 3] = "CREATE_VOLUME";
+  WorkerMsgType[WorkerMsgType["LOAD_DIMS"] = 4] = "LOAD_DIMS";
+  WorkerMsgType[WorkerMsgType["LOAD_VOLUME_DATA"] = 5] = "LOAD_VOLUME_DATA";
+  WorkerMsgType[WorkerMsgType["SET_PREFETCH_PRIORITY_DIRECTIONS"] = 6] = "SET_PREFETCH_PRIORITY_DIRECTIONS";
+  WorkerMsgType[WorkerMsgType["SYNCHRONIZE_MULTICHANNEL_LOADING"] = 7] = "SYNCHRONIZE_MULTICHANNEL_LOADING";
+  WorkerMsgType[WorkerMsgType["UPDATE_FETCH_OPTIONS"] = 8] = "UPDATE_FETCH_OPTIONS";
   return WorkerMsgType;
 }({});
 
+/** The variants of `WorkerMessageType` which represent "global" actions that don't require a specific loader */
+
+/** The variants of `WorkerMessageType` which represent actions on a specific loader */
+
 /** The kind of response a worker can return - `SUCCESS`, `ERROR`, or `EVENT`. */
 export let WorkerResponseResult = /*#__PURE__*/function (WorkerResponseResult) {
   WorkerResponseResult[WorkerResponseResult["SUCCESS"] = 0] = "SUCCESS";
@@ -21,12 +26,17 @@ export let WorkerResponseResult = /*#__PURE__*/function (WorkerResponseResult) {
 
 /** The kind of events that can occur when loading */
 export let WorkerEventType = /*#__PURE__*/function (WorkerEventType) {
+  /** Fired to update a `Volume`'s `imageInfo` and/or `loadSpec` based on loaded data (time, channels, region, etc.) */
   WorkerEventType[WorkerEventType["METADATA_UPDATE"] = 0] = "METADATA_UPDATE";
+  /** Fired when data for a channel (or batch of channels) is loaded */
   WorkerEventType[WorkerEventType["CHANNEL_LOAD"] = 1] = "CHANNEL_LOAD";
   return WorkerEventType;
 }({});
 
-/** All messages to/from a worker carry a `msgId`, a `type`, and a `payload` (whose type is determined by `type`). */
+/**
+ * All messages to/from a worker carry a `msgId`, a `type`, and a `payload` (whose type is determined by `type`).
+ * Messages which operate on a specific loader also require a `loaderId`.
+ */
 
 /** Maps each `WorkerMsgType` to the type of the payload of requests of that type. */