@aics/vole-core 3.12.4

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

@@ -0,0 +1,101 @@
+import type { ErrorObject } from "serialize-error";
+import type { ImageInfo } from "../ImageInfo.js";
+import type { VolumeDims } from "../VolumeDims.js";
+import type { CreateLoaderOptions, PrefetchDirection } from "../loaders/index.js";
+import type { LoadSpec, LoadedVolumeInfo } from "../loaders/IVolumeLoader.js";
+import type { TypedArray, NumberType } from "../types.js";
+import type { ZarrLoaderFetchOptions } from "../loaders/OmeZarrLoader.js";
+/** The types of requests that can be made to the worker. Mostly corresponds to methods on `IVolumeLoader`. */
+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
+}
+/** The kind of response a worker can return - `SUCCESS`, `ERROR`, or `EVENT`. */
+export declare const enum WorkerResponseResult {
+    SUCCESS = 0,
+    ERROR = 1,
+    EVENT = 2
+}
+/** The kind of events that can occur when loading */
+export declare const enum WorkerEventType {
+    /** Fired to update a `Volume`'s `imageInfo` and/or `loadSpec` based on loaded data (time, channels, region, etc.) */
+    METADATA_UPDATE = 0,
+    /** 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`). */
+type WorkerMsgBase<T extends WorkerMsgType, P> = {
+    msgId: number;
+    type: T;
+    payload: P;
+};
+/** Maps each `WorkerMsgType` to the type of the payload of requests of that type. */
+export type WorkerRequestPayload<T extends WorkerMsgType> = {
+    [WorkerMsgType.INIT]: {
+        maxCacheSize?: number;
+        maxActiveRequests?: number;
+        maxLowPriorityRequests?: number;
+    };
+    [WorkerMsgType.CREATE_LOADER]: {
+        path: string | string[];
+        options?: CreateLoaderOptions;
+    };
+    [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[];
+    [WorkerMsgType.SYNCHRONIZE_MULTICHANNEL_LOADING]: boolean;
+    [WorkerMsgType.UPDATE_FETCH_OPTIONS]: Partial<ZarrLoaderFetchOptions>;
+}[T];
+/** 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_VOLUME]: LoadedVolumeInfo;
+    [WorkerMsgType.LOAD_DIMS]: VolumeDims[];
+    [WorkerMsgType.LOAD_VOLUME_DATA]: void;
+    [WorkerMsgType.SET_PREFETCH_PRIORITY_DIRECTIONS]: void;
+    [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;
+    loaderId: number;
+    loadId: number;
+    channelIndex: number[];
+    dtype: NumberType[];
+    data: TypedArray<NumberType>[];
+    ranges: [number, number][];
+    atlasDims?: [number, number];
+};
+/** Event for when metadata updates. */
+export type MetadataUpdateEvent = {
+    eventType: WorkerEventType.METADATA_UPDATE;
+    loaderId: number;
+    loadId: number;
+    imageInfo?: ImageInfo;
+    loadSpec?: LoadSpec;
+};
+/** All valid types of worker requests, with some `WorkerMsgType` and a matching payload type. */
+export type WorkerRequest<T extends WorkerMsgType> = WorkerMsgBase<T, WorkerRequestPayload<T>>;
+/** All valid types of worker responses: `SUCCESS` with a matching payload, `ERROR` with a message, or an `EVENT`. */
+export type WorkerResponse<T extends WorkerMsgType> = ({
+    responseResult: WorkerResponseResult.SUCCESS;
+} & WorkerMsgBase<T, WorkerResponsePayload<T>>) | ({
+    responseResult: WorkerResponseResult.ERROR;
+} & WorkerMsgBase<T, ErrorObject>) | ({
+    responseResult: WorkerResponseResult.EVENT;
+} & (ChannelLoadEvent | MetadataUpdateEvent));
+export {};

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

@@ -0,0 +1,3 @@
+import { LoadSpec } from "../loaders/IVolumeLoader";
+/** Recreates a `LoadSpec` that has just been sent to/from a worker to restore three.js object prototypes */
+export declare function rebuildLoadSpec(spec: LoadSpec): LoadSpec;

package/es/types.js

@@ -0,0 +1,75 @@
+// numeric types compatible with zarrita.js.
+// see https://github.com/manzt/zarrita.js/blob/main/packages/core/src/metadata.ts
+
+export const ARRAY_CONSTRUCTORS = {
+  int8: Int8Array,
+  int16: Int16Array,
+  int32: Int32Array,
+  int64: globalThis.BigInt64Array,
+  uint8: Uint8Array,
+  uint16: Uint16Array,
+  uint32: Uint32Array,
+  uint64: globalThis.BigUint64Array,
+  float32: Float32Array,
+  float64: Float64Array
+};
+/** If `FuseChannel.rgbColor` is this value, it is disabled from fusion. */
+export 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 let RenderMode = /*#__PURE__*/function (RenderMode) {
+  RenderMode[RenderMode["RAYMARCH"] = 0] = "RAYMARCH";
+  RenderMode[RenderMode["PATHTRACE"] = 1] = "PATHTRACE";
+  RenderMode[RenderMode["SLICE"] = 2] = "SLICE";
+  return RenderMode;
+}({});
+
+/**
+ * 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 const isOrthographicCamera = def => def && def.isOrthographicCamera;
+export const isPerspectiveCamera = def => def && def.isPerspectiveCamera;
+export let ViewportCorner = /*#__PURE__*/function (ViewportCorner) {
+  ViewportCorner["TOP_LEFT"] = "top_left";
+  ViewportCorner["TOP_RIGHT"] = "top_right";
+  ViewportCorner["BOTTOM_LEFT"] = "bottom_left";
+  ViewportCorner["BOTTOM_RIGHT"] = "bottom_right";
+  return ViewportCorner;
+}({});
+export const isTop = corner => corner === ViewportCorner.TOP_LEFT || corner === ViewportCorner.TOP_RIGHT;
+export const isRight = corner => corner === ViewportCorner.TOP_RIGHT || corner === ViewportCorner.BOTTOM_RIGHT;
+export const DATARANGE_UINT8 = [0, 255];

package/es/utils/RequestQueue.js

@@ -0,0 +1,267 @@
+/** Object format used when passing multiple requests to RequestQueue at once. */
+
+export const DEFAULT_REQUEST_CANCEL_REASON = "request cancelled";
+
+/**
+ * Internal object interface used by RequestQueue to store request metadata and callbacks.
+ */
+
+/**
+ * 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.
+   */
+
+  /**
+   * 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`.
+   */
+
+  /** A queue of requests that are ready to be executed, in order of request time. */
+
+  /** A queue of low-priority tasks that are ready to be executed. `queue` must be empty before any of these tasks run. */
+
+  /** Stores all requests, even those that are currently active. */
+
+  /** Stores requests whose actions are currently being run. */
+
+  /**
+   * 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 = 10, maxLowPriorityRequests = 5) {
+    this.allRequests = new Map();
+    this.activeRequests = new Set();
+    this.queue = [];
+    this.queueLowPriority = [];
+    this.maxActiveRequests = maxActiveRequests;
+    this.maxLowPriorityRequests = Math.min(maxActiveRequests, maxLowPriorityRequests);
+  }
+
+  /**
+   * 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.
+   */
+  registerRequest(key, requestAction) {
+    // Create a new promise and store the resolve and reject callbacks for later.
+    // This lets us perform the actual action at a later point, when the request is at the
+    // front of the processing queue.
+    let promiseResolve, promiseReject;
+    const promise = new Promise((resolve, reject) => {
+      promiseResolve = resolve;
+      promiseReject = reject;
+    });
+    // Store the request data.
+    const requestItem = {
+      key: key,
+      action: requestAction,
+      resolve: promiseResolve,
+      reject: promiseReject,
+      promise
+    };
+    this.allRequests.set(key, requestItem);
+    return requestItem;
+  }
+
+  /**
+   * 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.
+   */
+  addRequestToQueue(key, lowPriority) {
+    // Check that this request is not cancelled.
+    if (this.allRequests.has(key)) {
+      // Clear the request timeout, if it has one, since it is being added to the queue.
+      const requestItem = this.allRequests.get(key);
+      if (requestItem && requestItem.timeoutId) {
+        clearTimeout(requestItem.timeoutId);
+        requestItem.timeoutId = undefined;
+      }
+      if (!this.queue.includes(key) && !this.queueLowPriority.includes(key)) {
+        // Add to queue and check if the request can be processed right away.
+        if (lowPriority) {
+          this.queueLowPriority.push(key);
+        } else {
+          this.queue.push(key);
+        }
+        this.dequeue();
+      }
+    }
+  }
+
+  /**
+   * 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(key, requestAction, lowPriority = false, delayMs = 0) {
+    if (!this.allRequests.has(key)) {
+      // New request!
+      const requestItem = this.registerRequest(key, requestAction);
+      // If a delay is set, wait to add this to the queue.
+      if (delayMs > 0) {
+        const timeoutId = setTimeout(() => this.addRequestToQueue(key, lowPriority), delayMs);
+        // Save timeout information to request metadata
+        requestItem.timeoutId = timeoutId;
+      } else {
+        // No delay, add immediately
+        this.addRequestToQueue(key, lowPriority);
+      }
+    } else {
+      const lowPriorityIndex = this.queueLowPriority.indexOf(key);
+      if (lowPriorityIndex > -1 && !lowPriority) {
+        // This request is registered and queued, but is now being requested with high priority.
+        // Promote it to high priority.
+        this.queueLowPriority.splice(lowPriorityIndex, 1);
+        this.addRequestToQueue(key);
+      } else if (delayMs <= 0) {
+        // This request is registered, but is now being requested without a delay.
+        // Move into queue immediately if it's not already added, and clear any timeouts it may have.
+        this.addRequestToQueue(key, lowPriority);
+      }
+    }
+    const promise = this.allRequests.get(key)?.promise;
+    if (!promise) {
+      throw new Error("Found no promise to return when getting stored request data.");
+    }
+    return promise;
+  }
+
+  /**
+   * 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(requests, lowPriority = false, delayMs = 10) {
+    const promises = [];
+    for (let i = 0; i < requests.length; i++) {
+      const item = requests[i];
+      const promise = this.addRequest(item.key, item.requestAction, lowPriority, delayMs * i);
+      promises.push(promise);
+    }
+    return promises;
+  }
+
+  /**
+   * 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.
+   */
+  async dequeue() {
+    const numRequests = this.activeRequests.size;
+    if (numRequests >= this.maxActiveRequests || this.queue.length === 0 && (numRequests >= this.maxLowPriorityRequests || this.queueLowPriority.length === 0)) {
+      return;
+    }
+    const requestKey = this.queue.shift() ?? this.queueLowPriority.shift();
+    if (!requestKey) {
+      return;
+    }
+    if (this.activeRequests.has(requestKey)) {
+      // This request is already active, try the next one instead. (this shouldn't happen)
+      this.dequeue();
+      return;
+    }
+    const requestItem = this.allRequests.get(requestKey);
+    if (!requestItem) {
+      return;
+    }
+    const key = requestItem.key;
+    // Mark that this request is active
+    this.activeRequests.add(key);
+    await requestItem.action().then(requestItem.resolve, requestItem.reject);
+    this.activeRequests.delete(key);
+    this.allRequests.delete(key);
+    this.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, cancelReason = DEFAULT_REQUEST_CANCEL_REASON) {
+    if (!this.allRequests.has(key)) {
+      return;
+    }
+    const requestItem = this.allRequests.get(key);
+    if (requestItem) {
+      if (requestItem.timeoutId) {
+        // Cancel requests that have not been queued yet.
+        clearTimeout(requestItem.timeoutId);
+      }
+      // Reject the request, then clear from the queue and known requests.
+      requestItem.reject(cancelReason);
+    }
+    const queueIndex = this.queue.indexOf(key);
+    if (queueIndex > -1) {
+      this.queue.splice(queueIndex, 1);
+    } else {
+      const lowPriorityIndex = this.queueLowPriority.indexOf(key);
+      if (lowPriorityIndex > -1) {
+        this.queueLowPriority.splice(lowPriorityIndex, 1);
+      }
+    }
+    this.allRequests.delete(key);
+    this.activeRequests.delete(key);
+  }
+
+  /**
+   * Rejects all request promises and clears the queue.
+   * @param cancelReason A message or object that will be used as the promise rejection.
+   */
+  cancelAllRequests(cancelReason = DEFAULT_REQUEST_CANCEL_REASON) {
+    // Clear the queue so we don't do extra work while filtering it
+    this.queue = [];
+    this.queueLowPriority = [];
+    for (const key of this.allRequests.keys()) {
+      this.cancelRequest(key, cancelReason);
+    }
+  }
+
+  /**
+   * 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) {
+    return this.allRequests.has(key);
+  }
+
+  /**
+   * 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) {
+    return this.activeRequests.has(key);
+  }
+}

package/es/utils/SubscribableRequestQueue.js

@@ -0,0 +1,187 @@
+import RequestQueue from "./RequestQueue.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * 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 {
+  /** The next unused subscriber ID. Increments whenever a subscriber is added. */
+
+  /**
+   * 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.
+   */
+
+  /** Map from "inner" request (managed by `queue`) to "outer" promises generated per-subscriber. */
+
+  /**
+   * 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, maxLowPriorityRequests) {
+    if (typeof maxActiveRequests === "number" || maxActiveRequests === undefined) {
+      this.queue = new RequestQueue(maxActiveRequests, maxLowPriorityRequests);
+    } else {
+      this.queue = maxActiveRequests;
+    }
+    this.nextSubscriberId = 0;
+    this.subscribers = new Map();
+    this.requests = new Map();
+  }
+
+  /** Resolves all subscriptions to request `key` with `value` */
+  resolveAll(key, value) {
+    const requests = this.requests.get(key);
+    if (requests) {
+      for (const {
+        resolve,
+        subscriberId
+      } of requests) {
+        resolve(value);
+        this.subscribers.get(subscriberId)?.delete(key);
+      }
+      this.requests.delete(key);
+    }
+  }
+
+  /** Rejects all subscriptions to request `key` with `reason` */
+  rejectAll(key, reason) {
+    const requests = this.requests.get(key);
+    if (requests) {
+      for (const {
+        reject,
+        subscriberId
+      } of requests) {
+        reject(reason);
+        this.subscribers.get(subscriberId)?.delete(key);
+      }
+      this.requests.delete(key);
+    }
+  }
+
+  /** Adds a new request subscriber. Returns a unique ID to identify this subscriber. */
+  addSubscriber() {
+    const subscriberId = this.nextSubscriberId;
+    this.nextSubscriberId++;
+    this.subscribers.set(subscriberId, new Map());
+    return subscriberId;
+  }
+
+  /**
+   * 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(key, subscriberId, requestAction, lowPriority, delayMs) {
+    // Create single underlying request if it does not yet exist
+    this.queue.addRequest(key, requestAction, lowPriority, delayMs).then(value => this.resolveAll(key, value)).catch(reason => this.rejectAll(key, reason));
+    if (!this.requests.has(key)) {
+      this.requests.set(key, []);
+    }
+
+    // Validate subscriber
+    if (subscriberId >= this.nextSubscriberId || subscriberId < 0) {
+      throw new Error(`SubscribableRequestQueue: subscriber id ${subscriberId} has not been registered`);
+    }
+    const subscriber = this.subscribers.get(subscriberId);
+    if (!subscriber) {
+      throw new Error(`SubscribableRequestQueue: subscriber id ${subscriberId} has been removed`);
+    }
+
+    // Create promise and add to list of requests
+    return new Promise((resolve, reject) => {
+      this.requests.get(key)?.push({
+        resolve,
+        reject,
+        subscriberId
+      });
+      const subscriber = this.subscribers.get(subscriberId);
+      const existingRequest = subscriber?.get(key);
+      if (existingRequest) {
+        existingRequest.push(reject);
+      } else {
+        subscriber?.set(key, [reject]);
+      }
+    });
+  }
+
+  /**
+   * 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.
+   */
+  rejectSubscription(key, reject, cancelReason) {
+    // Reject the outer "subscription" promise
+    reject(cancelReason);
+
+    // Get the list of subscriptions for this request
+    const subscriptions = this.requests.get(key);
+    if (!subscriptions) {
+      // This should never happen
+      return;
+    }
+    // Remove this request subscription by ref equality to `reject`
+    const idx = subscriptions.findIndex(sub => sub.reject === reject);
+    if (idx >= 0) {
+      subscriptions.splice(idx, 1);
+    }
+
+    // Remove the underlying request if there are no more subscribers and the request is not already running
+    if (subscriptions.length < 1 && !this.queue.requestRunning(key)) {
+      this.queue.cancelRequest(key, cancelReason);
+      this.requests.delete(key);
+    }
+  }
+
+  /** Cancels a request subscription, and cancels the underlying request if it is no longer subscribed or running. */
+  cancelRequest(key, subscriberId, cancelReason) {
+    const subscriber = this.subscribers.get(subscriberId);
+    if (!subscriber) {
+      return false;
+    }
+    const rejecters = subscriber.get(key);
+    if (!rejecters || !rejecters.length) {
+      return false;
+    }
+    for (const reject of rejecters) {
+      this.rejectSubscription(key, reject, cancelReason);
+    }
+    subscriber.delete(key);
+    return true;
+  }
+
+  /** Removes a subscriber and cancels its remaining subscriptions. */
+  removeSubscriber(subscriberId, cancelReason) {
+    const subscriptions = this.subscribers.get(subscriberId);
+    if (subscriptions) {
+      for (const [key, rejecters] of subscriptions.entries()) {
+        for (const reject of rejecters) {
+          this.rejectSubscription(key, reject, cancelReason);
+        }
+      }
+      this.subscribers.delete(subscriberId);
+    }
+  }
+
+  /** Returns whether a request with the given `key` is running or waiting in the queue */
+  hasRequest(key) {
+    return this.queue.hasRequest(key);
+  }
+
+  /** Returns whether a request with the given `key` is running */
+  requestRunning(key) {
+    return this.queue.requestRunning(key);
+  }
+
+  /** Returns whether a subscriber with the given `subscriberId` exists */
+  hasSubscriber(subscriberId) {
+    return this.subscribers.has(subscriberId);
+  }
+
+  /** Returns whether a subscriber with the given `subscriberId` is subscribed to the request with the given `key` */
+  isSubscribed(subscriberId, key) {
+    return this.subscribers.get(subscriberId)?.has(key) ?? false;
+  }
+}