@aics/vole-core 3.12.4

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

@@ -0,0 +1,94 @@
+import * as zarr from "@zarrita/core";
+import type WrappedStore from "./WrappedStore.js";
+import type SubscribableRequestQueue from "../../utils/SubscribableRequestQueue.js";
+export type TCZYX<T> = [T, T, T, T, T];
+export type SubscriberId = ReturnType<SubscribableRequestQueue["addSubscriber"]>;
+/**
+ * Directions in which to move outward from the loaded set of chunks while prefetching.
+ *
+ * Ordered in pairs of opposite directions both because that's a sensible order in which to prefetch for our purposes,
+ * and because it lets us treat the least significant bit as the sign. So `direction >> 1` gives the index of the
+ * direction in TZYX-ordered arrays, and `direction & 1` gives the sign of the direction (e.g. positive vs negative Z).
+ */
+export declare const enum PrefetchDirection {
+    T_MINUS = 0,
+    T_PLUS = 1,
+    Z_MINUS = 2,
+    Z_PLUS = 3,
+    Y_MINUS = 4,
+    Y_PLUS = 5,
+    X_MINUS = 6,
+    X_PLUS = 7
+}
+export type OMECoordinateTransformation = {
+    type: "identity";
+} | {
+    type: "translation";
+    translation: number[];
+} | {
+    type: "scale";
+    scale: number[];
+} | {
+    type: "translation" | "scale";
+    path: string;
+};
+export type OMEAxis = {
+    name: string;
+    type?: string;
+    unit?: string;
+};
+export type OMEDataset = {
+    path: string;
+    coordinateTransformations?: OMECoordinateTransformation[];
+};
+/** https://ngff.openmicroscopy.org/latest/#multiscale-md */
+export type OMEMultiscale = {
+    version?: string;
+    name?: string;
+    axes: OMEAxis[];
+    datasets: OMEDataset[];
+    coordinateTransformations?: OMECoordinateTransformation[];
+    type?: string;
+    metadata?: Record<string, unknown>;
+};
+/** https://ngff.openmicroscopy.org/latest/#omero-md */
+export type OmeroTransitionalMetadata = {
+    id: number;
+    name: string;
+    version: string;
+    channels: {
+        active: boolean;
+        coefficient: number;
+        color: string;
+        family: string;
+        inverted: boolean;
+        label: string;
+        window: {
+            end: number;
+            max: number;
+            min: number;
+            start: number;
+        };
+    }[];
+};
+export type OMEZarrMetadata = {
+    multiscales: OMEMultiscale[];
+    omero: OmeroTransitionalMetadata;
+};
+export type NumericZarrArray = zarr.Array<zarr.NumberDataType, WrappedStore<RequestInit>>;
+/** 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. */
+    scaleLevels: NumericZarrArray[];
+    /**
+     * Zarr dimensions may be ordered in many ways or missing altogether (e.g. TCXYZ, TYX). `axesTCZYX` represents
+     * dimension order as a mapping from dimensions to their indices in dimension-ordered arrays for this source.
+     */
+    axesTCZYX: TCZYX<number>;
+    /** OME-specified metadata record with most useful info on the current image, e.g. sizes, axis order, etc. */
+    multiscaleMetadata: OMEMultiscale;
+    /** OME-specified "transitional" metadata record which we mostly ignore, but which gives channel & volume names. */
+    omeroMetadata?: OmeroTransitionalMetadata;
+    /** Which channels in the volume come out of this source - i.e. source channel 0 is volume channel `channelOffset` */
+    channelOffset: number;
+};

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

@@ -0,0 +1,23 @@
+import type { OMEAxis, OMEDataset, OMEMultiscale, TCZYX, ZarrSource } from "./types.js";
+/** Extracts channel names from a `ZarrSource`. Handles missing `omeroMetadata`. Does *not* resolve name collisions. */
+export declare function getSourceChannelNames(src: ZarrSource): string[];
+/** Turns `axesTCZYX` into the number of dimensions in the array */
+export declare const getDimensionCount: ([t, c, z]: TCZYX<number>) => number;
+export declare function remapAxesToTCZYX(axes: OMEAxis[]): TCZYX<number>;
+/** Reorder an array of values [T, C, Z, Y, X] to the given dimension order */
+export declare function orderByDimension<T>(valsTCZYX: TCZYX<T>, orderTCZYX: TCZYX<number>): T[];
+/** Reorder an array of values in the given dimension order to [T, C, Z, Y, X] */
+export declare function orderByTCZYX<T>(valsDimension: T[], orderTCZYX: TCZYX<number>, defaultValue: T): TCZYX<T>;
+/** Select the scale transform from an OME metadata object with coordinate transforms, and return it in TCZYX order */
+export declare function getScale(dataset: OMEDataset | OMEMultiscale, orderTCZYX: TCZYX<number>): TCZYX<number>;
+/**
+ * Ensures that all scale levels in `sources` are matched up by size. More precisely: enforces that, for any scale
+ * level `i`, the size of zarr array `s[i]` is equal for every source `s`. We accomplish this by removing any arrays
+ * (and their associated OME dataset metadata) which don't match up in all sources.
+ *
+ * Note that this function modifies the input `sources` array rather than returning a new value.
+ *
+ * Assumes all sources have scale levels ordered by size from largest to smallest. (This should always be true for
+ * compliant OME-Zarr data.)
+ */
+export declare function matchSourceScaleLevels(sources: ZarrSource[]): void;

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

@@ -0,0 +1,7 @@
+import { OMEZarrMetadata } from "./types.js";
+/**
+ * Validates that the `OMEZarrMetadata` record `data` 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;

package/es/types/test/ChunkPrefetchIterator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/RequestQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/SubscribableRequestQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/VolumeCache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/VolumeRenderSettings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/lut.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/num_utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/types/test/volume.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/es/types/types.d.ts

@@ -0,0 +1,115 @@
+import { Camera, OrthographicCamera, PerspectiveCamera, Vector3 } from "three";
+export interface Bounds {
+    bmin: Vector3;
+    bmax: Vector3;
+}
+export type Int8 = "int8";
+export type Int16 = "int16";
+export type Int32 = "int32";
+export type Int64 = "int64";
+export type Uint8 = "uint8";
+export type Uint16 = "uint16";
+export type Uint32 = "uint32";
+export type Uint64 = "uint64";
+export type Float32 = "float32";
+export type Float64 = "float64";
+export type NumberType = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32 | Float32 | Float64;
+export type TypedArray<D> = D extends Int8 ? Int8Array : D extends Int16 ? Int16Array : D extends Int32 ? Int32Array : D extends Int64 ? BigInt64Array : D extends Uint8 ? Uint8Array : D extends Uint16 ? Uint16Array : D extends Uint32 ? Uint32Array : D extends Uint64 ? BigUint64Array : D extends Float32 ? Float32Array : D extends Float64 ? Float64Array : never;
+export declare const ARRAY_CONSTRUCTORS: {
+    int8: Int8ArrayConstructor;
+    int16: Int16ArrayConstructor;
+    int32: Int32ArrayConstructor;
+    int64: BigInt64ArrayConstructor;
+    uint8: Uint8ArrayConstructor;
+    uint16: Uint16ArrayConstructor;
+    uint32: Uint32ArrayConstructor;
+    uint64: BigUint64ArrayConstructor;
+    float32: Float32ArrayConstructor;
+    float64: Float64ArrayConstructor;
+};
+export interface FuseChannel {
+    chIndex: number;
+    lut: Uint8Array;
+    rgbColor: [number, number, number] | number;
+}
+/** If `FuseChannel.rgbColor` is this value, it is disabled from fusion. */
+export declare const FUSE_DISABLED_RGB_COLOR = 0;
+/**
+ * Provide options to control the visual appearance of a Volume
+ * @typedef {Object} VolumeChannelDisplayOptions
+ * @property {boolean} enabled array of boolean per channel
+ * @property {Array.<number>} color array of rgb per channel
+ * @property {Array.<number>} specularColor array of rgb per channel
+ * @property {Array.<number>} emissiveColor array of rgb per channel
+ * @property {number} glossiness array of float per channel
+ * @property {boolean} isosurfaceEnabled array of boolean per channel
+ * @property {number} isovalue array of number per channel
+ * @property {number} isosurfaceOpacity array of number per channel
+ * @example let options = {
+   };
+ */
+export interface VolumeChannelDisplayOptions {
+    enabled?: boolean;
+    color?: [number, number, number];
+    specularColor?: [number, number, number];
+    emissiveColor?: [number, number, number];
+    glossiness?: number;
+    isosurfaceEnabled?: boolean;
+    isovalue?: number;
+    isosurfaceOpacity?: number;
+}
+export declare enum RenderMode {
+    RAYMARCH = 0,
+    PATHTRACE = 1,
+    SLICE = 2
+}
+/**
+ * Provide options to control the visual appearance of a Volume
+ * @typedef {Object} VolumeDisplayOptions
+ * @property {Array.<VolumeChannelDisplayOptions>} channels array of channel display options
+ * @property {number} density
+ * @property {Array.<number>} translation xyz
+ * @property {Array.<number>} rotation xyz angles in radians
+ * @property {number} maskChannelIndex
+ * @property {number} maskAlpha
+ * @property {Array.<number>} clipBounds [xmin, xmax, ymin, ymax, zmin, zmax] all range from 0 to 1 as a percentage of the volume on that axis
+ * @property {Array.<number>} scale xyz voxel size scaling
+ * @property {boolean} maxProjection true or false (ray marching)
+ * @property {number} renderMode 0 for raymarch, 1 for pathtrace
+ * @property {number} shadingMethod 0 for phase, 1 for brdf, 2 for hybrid (path tracer)
+ * @property {Array.<number>} gamma [min, max, scale]
+ * @property {number} primaryRayStepSize in voxels
+ * @property {number} secondaryRayStepSize in voxels
+ * @property {boolean} showBoundingBox true or false
+ * @property {Array.<number>} boundingBoxColor r,g,b for bounding box lines
+ * @example let options = {
+   };
+ */
+export interface VolumeDisplayOptions {
+    channels?: VolumeChannelDisplayOptions[];
+    density?: number;
+    translation?: [number, number, number];
+    rotation?: [number, number, number];
+    maskChannelIndex?: number;
+    maskAlpha?: number;
+    clipBounds?: [number, number, number, number, number, number];
+    maxProjection?: boolean;
+    renderMode?: RenderMode;
+    shadingMethod?: number;
+    gamma?: [number, number, number];
+    primaryRayStepSize?: number;
+    secondaryRayStepSize?: number;
+    showBoundingBox?: boolean;
+    boundingBoxColor?: [number, number, number];
+}
+export declare const isOrthographicCamera: (def: Camera) => def is OrthographicCamera;
+export declare const isPerspectiveCamera: (def: Camera) => def is PerspectiveCamera;
+export declare const enum ViewportCorner {
+    TOP_LEFT = "top_left",
+    TOP_RIGHT = "top_right",
+    BOTTOM_LEFT = "bottom_left",
+    BOTTOM_RIGHT = "bottom_right"
+}
+export declare const isTop: (corner: ViewportCorner) => boolean;
+export declare const isRight: (corner: ViewportCorner) => boolean;
+export declare const DATARANGE_UINT8: [number, number];

package/es/types/utils/RequestQueue.d.ts

@@ -0,0 +1,112 @@
+/** Object format used when passing multiple requests to RequestQueue at once. */
+export type Request<V> = {
+    key: string;
+    requestAction: () => Promise<V>;
+};
+export declare const DEFAULT_REQUEST_CANCEL_REASON = "request cancelled";
+/**
+ * Manages a queue of asynchronous requests with unique string keys, which can be added to or cancelled.
+ * If redundant requests with the same key are issued, the request action will only be run once per key
+ * while the original request is still in the queue.
+ */
+export default class RequestQueue {
+    /**
+     * The maximum number of requests that can be handled concurrently.
+     * Once reached, additional requests will be queued up to run once a running request completes.
+     */
+    private maxActiveRequests;
+    /**
+     * The maximum number of requests that can be handled concurrently if only low-priority requests are waiting. Set
+     * lower than `concurrencyLimit` to always leave space for high-priority requests. Cannot be set higher than
+     * `concurrencyLimit`.
+     */
+    private maxLowPriorityRequests;
+    /** A queue of requests that are ready to be executed, in order of request time. */
+    private queue;
+    /** A queue of low-priority tasks that are ready to be executed. `queue` must be empty before any of these tasks run. */
+    private queueLowPriority;
+    /** Stores all requests, even those that are currently active. */
+    private allRequests;
+    /** Stores requests whose actions are currently being run. */
+    private activeRequests;
+    /**
+     * Creates a new RequestQueue.
+     * @param maxActiveRequests The maximum number of requests that will be handled concurrently. This is 10 by default.
+     * @param maxLowPriorityRequests The maximum number of low-priority requests that will be handled concurrently. Equal
+     *    to `maxActiveRequests` by default, but may be set lower to always leave space for new high-priority requests.
+     */
+    constructor(maxActiveRequests?: number, maxLowPriorityRequests?: number);
+    /**
+     * Stores request metadata to the internal map of all pending requests.
+     * @param key string identifier of the request.
+     * @param requestAction callable function action of the request.
+     * @returns a reference to the new, registered RequestItem.
+     */
+    private registerRequest;
+    /**
+     * Moves a registered request into the processing queue, clearing any timeouts on the request.
+     * @param key string identifier of the request.
+     * @param lowPriority Whether this request should be added with low priority. False by default.
+     */
+    private addRequestToQueue;
+    /**
+     * Adds a request with a unique key to the queue, if it doesn't already exist.
+     * @param key The key used to track the request.
+     * @param requestAction Function that will be called to complete the request. The function
+     *  will be run only once per unique key while the request exists, and may be deferred by the
+     *  queue at any time.
+     * @param lowPriority Whether this request should be added with low priority. False by default.
+     * @param delayMs Minimum delay, in milliseconds, before this request should be executed.
+     *
+     * NOTE: Cancelling a request while the action is running WILL NOT stop the action. If this behavior is desired,
+     * actions must be responsible for checking the RequestQueue, determining if the request is still valid (e.g.
+     * using `.hasRequest()`), and stopping or returning early.
+     *
+     * @returns A promise that will resolve on completion of the request, or reject if the request is cancelled.
+     *  If multiple requests are issued with the same key, a promise for the first request will be returned
+     *  until the request is resolved or cancelled.
+     *  Note that the return type of the promise will match that of the first request's instance.
+     */
+    addRequest<T>(key: string, requestAction: () => Promise<T>, lowPriority?: boolean, delayMs?: number): Promise<T>;
+    /**
+     * Adds multiple requests to the queue, with an optional delay between each.
+     * @param requests An array of RequestItems, which include a key and a request action.
+     * @param lowPriority Whether these requests should be added with low priority. False by default.
+     * @param delayMs An optional minimum delay in milliseconds to be added between each request.
+     *  For example, a delay of 10 ms will cause the second request to be added to the processing queue
+     *  after 10 ms, the third to added after 20 ms, and so on. Set to 10 ms by default.
+     * @returns An array of promises corresponding to the provided requests. (i.e., the `i`th value
+     * of the returned array will be a Promise for the resolution of `requests[i]`). If a request
+     *  with a matching key is already pending, returns the promise for the initial request.
+     */
+    addRequests<T>(requests: Request<T>[], lowPriority?: boolean, delayMs?: number): Promise<unknown>[];
+    /**
+     * Attempts to remove and run the next queued request item, if resources are available.
+     * @returns true if a request was started, or false if there are too many
+     * requests already active.
+     */
+    private dequeue;
+    /**
+     * Removes any request matching the provided key from the queue and rejects its promise.
+     * @param key The key that should be matched against.
+     * @param cancelReason A message or object that will be used as the promise rejection.
+     */
+    cancelRequest(key: string, cancelReason?: unknown): void;
+    /**
+     * Rejects all request promises and clears the queue.
+     * @param cancelReason A message or object that will be used as the promise rejection.
+     */
+    cancelAllRequests(cancelReason?: unknown): void;
+    /**
+     * Returns whether a request with the given key exists in the RequestQueue and is not cancelled.
+     * @param key the key to search for.
+     * @returns true if the request is in the RequestQueue.
+     */
+    hasRequest(key: string): boolean;
+    /**
+     * Returns whether the request with the given key is currently running (not waiting in the queue).
+     * @param key the key to search for.
+     * @returns true if the request is actively running.
+     */
+    requestRunning(key: string): boolean;
+}

package/es/types/utils/SubscribableRequestQueue.d.ts

@@ -0,0 +1,52 @@
+import RequestQueue from "./RequestQueue.js";
+/**
+ * An extension of `RequestQueue` that adds a concept of "subscribers," which may share references to a single request
+ * or cancel their subscription without disrupting the request for other subscribers.
+ */
+export default class SubscribableRequestQueue {
+    private queue;
+    /** The next unused subscriber ID. Increments whenever a subscriber is added. */
+    private nextSubscriberId;
+    /**
+     * Map of subscribers keyed by ID. Subscribers store a map to all their subscriptions by request key.
+     * Subscribers are only useful as handles to cancel subscriptions early, so we only need to store rejecters here.
+     */
+    private subscribers;
+    /** Map from "inner" request (managed by `queue`) to "outer" promises generated per-subscriber. */
+    private requests;
+    /**
+     * Since `SubscribableRequestQueue` wraps `RequestQueue`, its constructor may either take the same arguments as the
+     * `RequestQueue` constructor and create a new `RequestQueue`, or it may take an existing `RequestQueue` to wrap.
+     */
+    constructor(maxActiveRequests?: number, maxLowPriorityRequests?: number);
+    constructor(inner: RequestQueue);
+    /** Resolves all subscriptions to request `key` with `value` */
+    private resolveAll;
+    /** Rejects all subscriptions to request `key` with `reason` */
+    private rejectAll;
+    /** Adds a new request subscriber. Returns a unique ID to identify this subscriber. */
+    addSubscriber(): number;
+    /**
+     * Queues a new request, or adds a subscription if the request is already queued/running.
+     *
+     * If `subscriberId` is already subscribed to the request, this rejects the existing promise and returns a new one.
+     */
+    addRequest<T>(key: string, subscriberId: number, requestAction: () => Promise<T>, lowPriority?: boolean, delayMs?: number): Promise<T>;
+    /**
+     * Rejects a subscription and removes it from the list of subscriptions for a request, then cancels the underlying
+     * request if it is no longer subscribed and is not running already.
+     */
+    private rejectSubscription;
+    /** Cancels a request subscription, and cancels the underlying request if it is no longer subscribed or running. */
+    cancelRequest(key: string, subscriberId: number, cancelReason?: unknown): boolean;
+    /** Removes a subscriber and cancels its remaining subscriptions. */
+    removeSubscriber(subscriberId: number, cancelReason?: unknown): void;
+    /** Returns whether a request with the given `key` is running or waiting in the queue */
+    hasRequest(key: string): boolean;
+    /** Returns whether a request with the given `key` is running */
+    requestRunning(key: string): boolean;
+    /** Returns whether a subscriber with the given `subscriberId` exists */
+    hasSubscriber(subscriberId: number): boolean;
+    /** Returns whether a subscriber with the given `subscriberId` is subscribed to the request with the given `key` */
+    isSubscribed(subscriberId: number, key: string): boolean;
+}

package/es/types/utils/num_utils.d.ts

@@ -0,0 +1,43 @@
+import { TimeUnit } from "../constants/time.js";
+import { Axis } from "../VolumeRenderSettings.js";
+export declare const DEFAULT_SIG_FIGS = 5;
+/**
+ * Formats numbers for display as a string with a (hopefully) limited length.
+ *
+ * - If the number is an integer with 4 or fewer digits, it is returned as a string.
+ * - If the number is a decimal, it is rounded to `sigFigs` significant figures. (default 5)
+ * - If the number's absolute value is over 10,000 or less than 0.01, it is formatted in scientific notation to
+ *   `sciSigFigs` significant figures. (Default `sigFigs - 2`, so 3 if neither are specified. The `- 2` leaves space
+ *   for the exponential part. Remember: the purpose of this function is keeping number strings *consistently* short!)
+ */
+export declare function formatNumber(value: number, sigFigs?: number, sciSigFigs?: number): string;
+export declare function timeToMilliseconds(time: number, unit: TimeUnit): number;
+/**
+ * Gets a timestamp formatted as `{time} / {total} {unit}`. If `unit` is a recognized
+ * time unit, the timestamp will be formatted as a `d:hh:mm:ss.ms` string.
+ *
+ * @param time Current time, in specified units.
+ * @param total Total time, in specified units.
+ * @param unit The unit of time.
+ * @returns A formatted timestamp string.
+ * - If `unit` is not recognized, the timestamp will be formatted as `{time} / {total} {unit}`,
+ * where `time` and `total` are formatted with significant digits as needed.
+ * - If `unit` is recognized, the timestamp will be formatted as `d:hh:mm:ss.ms`, specifying
+ * the most significant unit based on the total time, and the least significant unit with
+ * `unit`. See `parseTimeUnit()` for recognized time units.
+ */
+export declare function getTimestamp(time: number, total: number, unit: string): string;
+/**
+ * Constrains the `src` vector relative to the `target` so it only has freedom along the
+ * specified `axis`. Does nothing if `axis = Axis.NONE`.
+ *
+ * @example
+ * ```
+ *   const src = [1, 2, 3];
+ *   const target = [4, 5, 6];
+ *   const constrained = constrainToAxis(src, target, Axis.X);
+ *   console.log(constrained); // [1, 5, 6]
+ * ```
+ */
+export declare function constrainToAxis(src: [number, number, number], target: [number, number, number], axis: Axis): [number, number, number];
+export declare function getDataRange(data: ArrayLike<number>): [number, number];

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

@@ -0,0 +1,106 @@
+import { ImageInfo } from "../ImageInfo.js";
+import { VolumeDims } from "../VolumeDims.js";
+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 { ZarrLoaderFetchOptions } from "../loaders/OmeZarrLoader.js";
+import { WorkerMsgType } from "./types.js";
+/**
+ * A handle that holds the worker and manages requests and messages to/from it.
+ *
+ * `VolumeLoaderContext` and every `LoaderWorker` it creates all hold references to one `SharedLoadWorkerHandle`.
+ * They use it to interact with the worker via `sendMessage`, which speaks the protocol defined in ./types.ts and
+ * converts messages received from the worker into resolved `Promise`s and called callbacks.
+ *
+ * This class exists to represent that access to the worker is shared between `VolumeLoaderContext` and any
+ * `LoaderWorker`s. This is as opposed to implementing `sendMessage` directly on `VolumeLoaderContext`, where making
+ * the method public to `LoaderWorker`s would require also allowing access to users of the class.
+ */
+declare class SharedLoadWorkerHandle {
+    private worker;
+    private pendingRequests;
+    private workerOpen;
+    private throttleChannelData;
+    onChannelData: ((e: ChannelLoadEvent) => void) | undefined;
+    onUpdateMetadata: ((e: 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;
+    get isOpen(): boolean;
+    /** Close the worker. */
+    close(): void;
+    /**
+     * 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>>;
+    /** 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:
+ * 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
+ *    options to directly link to a cache or queue (the loader will always be linked to the context's shared instances
+ *    of these if possible).
+ *
+ * The returned `WorkerLoader` can be used like any other `IVolumeLoader` and acts as a handle to the actual loader
+ * running on the worker.
+ */
+declare class VolumeLoaderContext {
+    private workerHandle;
+    private openPromise;
+    private activeLoader;
+    private activeLoaderId;
+    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;
+    /**
+     * Create a new loader within this context. This loader will share the context's `VolumeCache` and `RequestQueue`.
+     *
+     * This works just like `createVolumeLoader`. A file format may be provided, or it may be inferred from the URL.
+     */
+    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.
+ *
+ * Created with `VolumeLoaderContext.createLoader`. See its documentation for more.
+ */
+declare class WorkerLoader extends ThreadableVolumeLoader {
+    private loaderId;
+    private workerHandle;
+    private isOpen;
+    private currentLoadId;
+    private currentLoadCallback;
+    private currentMetadataUpdateCallback;
+    constructor(loaderId: number, workerHandle: SharedLoadWorkerHandle);
+    private checkIsOpen;
+    /** Close and permanently invalidate this loader. */
+    close(): void;
+    /**
+     * Change which directions to prioritize when prefetching. All chunks will be prefetched in these directions before
+     * any chunks are prefetched in any other directions. Has no effect if this loader doesn't support prefetching.
+     */
+    setPrefetchPriority(directions: PrefetchDirection[]): Promise<void>;
+    updateFetchOptions(fetchOptions: Partial<ZarrLoaderFetchOptions>): Promise<void>;
+    syncMultichannelLoading(sync: boolean): Promise<void>;
+    loadDims(loadSpec: LoadSpec): Promise<VolumeDims[]>;
+    createImageInfo(loadSpec: LoadSpec): Promise<LoadedVolumeInfo>;
+    loadRawChannelData(imageInfo: ImageInfo, loadSpec: LoadSpec, onUpdateMetadata: (imageInfo?: ImageInfo, loadSpec?: LoadSpec) => void, onData: RawChannelDataCallback): Promise<void>;
+    onChannelData(e: ChannelLoadEvent): void;
+    onUpdateMetadata(e: MetadataUpdateEvent): void;
+}
+export default VolumeLoaderContext;
+export type { WorkerLoader };