@draco-rust/decoder 0.2.0 → 0.3.0

package/README.md

@@ -60,7 +60,9 @@ if (!result.success) throw new Error(result.error);
 const { index, attributes } = result; // attributes[i]: { name, array, itemSize, normalized, ... }
 ```
 
-Without the second argument every attribute comes back in its own type.
+Without the second argument every attribute comes back in its own type. The
+index is a `Uint32Array`; a third argument `{ index: "auto" }` makes it a
+`Uint16Array` wherever the points number at most 65536, half the bytes.
 
 ### On workers
 
@@ -80,6 +82,10 @@ them. The stream is copied to the worker; `pool.decode(bytes, requests, {
 transfer: true })` hands over the buffer itself instead. The pool runs on Web
 Workers, on Node's worker threads (Node 20.16 and later), and from a CDN. With
 `workers: 0`, or where there are no workers, it decodes on the calling thread.
+`pool.decode` also takes `index`, as `decode_draco` does, and an `AbortSignal`
+as `signal`: aborting rejects the promise at once. A decode a worker has
+already started still runs to its end and its result is dropped; one not yet
+sent is never sent.
 A bundler that follows `new URL("./worker.js", import.meta.url)`, as Vite and
 webpack do, emits the worker on its own.
 
@@ -114,7 +120,7 @@ package's other entries do not need it.
 ### From a CDN, without a bundler
 
 ```js
-import init, { parse_drc_bytes } from "https://cdn.jsdelivr.net/npm/@draco-rust/decoder@0.2/mesh/index.js";
+import init, { parse_drc_bytes } from "https://cdn.jsdelivr.net/npm/@draco-rust/decoder@0.3/mesh/index.js";
 await init(); // finds index_bg.wasm next to the script
 ```
 
@@ -141,4 +147,4 @@ For a subpath entry, resolve its own file, for example
 - Licensed under Apache-2.0, like Draco.
 ## This build
 
-`@draco-rust/decoder@0.2.0` was built from draco-rust commit `8650e1ca`, with draco-core 2.3.2, draco-io 0.6.0, draco-gltf 0.7.0.
+`@draco-rust/decoder@0.3.0` was built from draco-rust commit `4b72cfc8`, with draco-core 2.3.2, draco-io 0.6.0, draco-gltf 0.7.0.

package/index.d.ts

@@ -35,41 +35,37 @@ export interface DracoAttribute {
     normalized: boolean;
 }
 
+export interface DracoDecodeOptions {
+    /**
+     * The index's array: `"Uint32Array"`, the default, or `"auto"`, which uses a
+     * `Uint16Array` when every point number fits, at most 65536 points, and
+     * halves what a worker sends back.
+     */
+    index?: "Uint32Array" | "auto";
+}
+
 export interface DracoDecodeResult {
     success: boolean;
     error?: string;
     warnings: string[];
     geometry?: "mesh" | "point_cloud";
     /** Triangle corners for a mesh, `null` for a point cloud. */
-    index: Uint32Array | null;
+    index: Uint32Array | Uint16Array | null;
     attributes: DracoAttribute[];
 }
 
-
-
 /**
- * Decodes a Draco stream and returns its attributes as typed arrays.
- *
- * `attributes` is `undefined` for every attribute in its own component type,
- * or an array of requests `{ name, id, semantic, type }`:
- *
- * - `id`, a unique id, finds that attribute, as glTF's
- *   `KHR_draco_mesh_compression` names them; a missing one is an error.
- * - `semantic` (`"POSITION"`, `"NORMAL"`, `"COLOR"`, `"TEX_COORD"` or
- *   `"GENERIC"`) finds the first attribute of that type instead, as a `.drc`
- *   file is read; a missing one is left out.
- * - `type`, a typed array's name such as `"Float32Array"` or
- *   `"Uint16Array"`, converts the values the way upstream's
- *   `GetAttributeDataArrayForAllPoints` does; without it the values keep
- *   their own type. A value the type cannot hold is an error.
- *
- * The result is `{ success, error, warnings, geometry, index, attributes }`,
- * where `geometry` is `"mesh"` or `"point_cloud"` as the stream's header says,
- * `index` a `Uint32Array` of triangle corners for a mesh and `null` for a
- * point cloud, and each attribute `{ name, uniqueId, semantic, array,
- * itemSize, normalized }`.
+ * Decodes a Draco stream and returns its attributes as typed arrays: every
+ * attribute in its own type, or the ones `attributes` requests, converted as
+ * upstream's `GetAttributeDataArrayForAllPoints` converts them.
  */
-export function decode_draco(data: Uint8Array, attributes: DracoAttributeRequest[] | undefined): DracoDecodeResult;
+export function decode_draco(
+data: Uint8Array,
+attributes?: DracoAttributeRequest[],
+options?: DracoDecodeOptions,
+): DracoDecodeResult;
+
+
 
 /**
  * Install the panic hook, so a panic reads as a message rather than a trap.
@@ -95,7 +91,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly decode_draco: (a: number, b: number, c: number) => number;
+    readonly decode_draco: (a: number, b: number, c: number, d: number) => number;
     readonly init: () => void;
     readonly parse_drc_bytes: (a: number, b: number) => number;
     readonly supported_extensions: (a: number) => void;

package/index.js

@@ -18,17 +18,22 @@
  *
  * The result is `{ success, error, warnings, geometry, index, attributes }`,
  * where `geometry` is `"mesh"` or `"point_cloud"` as the stream's header says,
- * `index` a `Uint32Array` of triangle corners for a mesh and `null` for a
- * point cloud, and each attribute `{ name, uniqueId, semantic, array,
- * itemSize, normalized }`.
+ * `index` the triangle corners for a mesh and `null` for a point cloud, and
+ * each attribute `{ name, uniqueId, semantic, array, itemSize, normalized }`.
+ * The index is a `Uint32Array`, or with `options.index` set to `"auto"` a
+ * `Uint16Array` where the points number at most 65536.
+ *
+ * Its TypeScript declaration is written by hand in the section above, where
+ * the trailing parameters can be optional.
  * @param {Uint8Array} data
- * @param {DracoAttributeRequest[] | undefined} attributes
- * @returns {DracoDecodeResult}
+ * @param {any} attributes
+ * @param {object | null} [options]
+ * @returns {any}
  */
-export function decode_draco(data, attributes) {
+export function decode_draco(data, attributes, options) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.decode_draco(ptr0, len0, addHeapObject(attributes));
+    const ret = wasm.decode_draco(ptr0, len0, addHeapObject(attributes), isLikeNone(options) ? 0 : addHeapObject(options));
     return takeObject(ret);
 }
 

package/index_bg.wasm.d.ts

@@ -1,7 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const decode_draco: (a: number, b: number, c: number) => number;
+export const decode_draco: (a: number, b: number, c: number, d: number) => number;
 export const init: () => void;
 export const parse_drc_bytes: (a: number, b: number) => number;
 export const supported_extensions: (a: number) => void;

package/legacy/index.d.ts

@@ -35,41 +35,37 @@ export interface DracoAttribute {
     normalized: boolean;
 }
 
+export interface DracoDecodeOptions {
+    /**
+     * The index's array: `"Uint32Array"`, the default, or `"auto"`, which uses a
+     * `Uint16Array` when every point number fits, at most 65536 points, and
+     * halves what a worker sends back.
+     */
+    index?: "Uint32Array" | "auto";
+}
+
 export interface DracoDecodeResult {
     success: boolean;
     error?: string;
     warnings: string[];
     geometry?: "mesh" | "point_cloud";
     /** Triangle corners for a mesh, `null` for a point cloud. */
-    index: Uint32Array | null;
+    index: Uint32Array | Uint16Array | null;
     attributes: DracoAttribute[];
 }
 
-
-
 /**
- * Decodes a Draco stream and returns its attributes as typed arrays.
- *
- * `attributes` is `undefined` for every attribute in its own component type,
- * or an array of requests `{ name, id, semantic, type }`:
- *
- * - `id`, a unique id, finds that attribute, as glTF's
- *   `KHR_draco_mesh_compression` names them; a missing one is an error.
- * - `semantic` (`"POSITION"`, `"NORMAL"`, `"COLOR"`, `"TEX_COORD"` or
- *   `"GENERIC"`) finds the first attribute of that type instead, as a `.drc`
- *   file is read; a missing one is left out.
- * - `type`, a typed array's name such as `"Float32Array"` or
- *   `"Uint16Array"`, converts the values the way upstream's
- *   `GetAttributeDataArrayForAllPoints` does; without it the values keep
- *   their own type. A value the type cannot hold is an error.
- *
- * The result is `{ success, error, warnings, geometry, index, attributes }`,
- * where `geometry` is `"mesh"` or `"point_cloud"` as the stream's header says,
- * `index` a `Uint32Array` of triangle corners for a mesh and `null` for a
- * point cloud, and each attribute `{ name, uniqueId, semantic, array,
- * itemSize, normalized }`.
+ * Decodes a Draco stream and returns its attributes as typed arrays: every
+ * attribute in its own type, or the ones `attributes` requests, converted as
+ * upstream's `GetAttributeDataArrayForAllPoints` converts them.
  */
-export function decode_draco(data: Uint8Array, attributes: DracoAttributeRequest[] | undefined): DracoDecodeResult;
+export function decode_draco(
+data: Uint8Array,
+attributes?: DracoAttributeRequest[],
+options?: DracoDecodeOptions,
+): DracoDecodeResult;
+
+
 
 /**
  * Install the panic hook, so a panic reads as a message rather than a trap.
@@ -95,7 +91,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly decode_draco: (a: number, b: number, c: number) => number;
+    readonly decode_draco: (a: number, b: number, c: number, d: number) => number;
     readonly init: () => void;
     readonly parse_drc_bytes: (a: number, b: number) => number;
     readonly supported_extensions: (a: number) => void;

package/legacy/index.js

@@ -18,17 +18,22 @@
  *
  * The result is `{ success, error, warnings, geometry, index, attributes }`,
  * where `geometry` is `"mesh"` or `"point_cloud"` as the stream's header says,
- * `index` a `Uint32Array` of triangle corners for a mesh and `null` for a
- * point cloud, and each attribute `{ name, uniqueId, semantic, array,
- * itemSize, normalized }`.
+ * `index` the triangle corners for a mesh and `null` for a point cloud, and
+ * each attribute `{ name, uniqueId, semantic, array, itemSize, normalized }`.
+ * The index is a `Uint32Array`, or with `options.index` set to `"auto"` a
+ * `Uint16Array` where the points number at most 65536.
+ *
+ * Its TypeScript declaration is written by hand in the section above, where
+ * the trailing parameters can be optional.
  * @param {Uint8Array} data
- * @param {DracoAttributeRequest[] | undefined} attributes
- * @returns {DracoDecodeResult}
+ * @param {any} attributes
+ * @param {object | null} [options]
+ * @returns {any}
  */
-export function decode_draco(data, attributes) {
+export function decode_draco(data, attributes, options) {
     const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.decode_draco(ptr0, len0, addHeapObject(attributes));
+    const ret = wasm.decode_draco(ptr0, len0, addHeapObject(attributes), isLikeNone(options) ? 0 : addHeapObject(options));
     return takeObject(ret);
 }
 

package/legacy/index_bg.wasm.d.ts

@@ -1,7 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const decode_draco: (a: number, b: number, c: number) => number;
+export const decode_draco: (a: number, b: number, c: number, d: number) => number;
 export const init: () => void;
 export const parse_drc_bytes: (a: number, b: number) => number;
 export const supported_extensions: (a: number) => void;

package/legacy/pool-core.d.ts

@@ -0,0 +1,44 @@
+export interface PoolOptions {
+  /**
+   * How many workers to run at most; they start as work arrives. Defaults to
+   * one less than the cores, between one and four. `0` runs on the calling
+   * thread, as does an environment without workers.
+   */
+  workers?: number;
+  /**
+   * The entry's wasm, when it is not next to this module where the pool looks
+   * for it: a URL, a `Response`, the bytes, or a compiled module.
+   */
+  wasm?: string | URL | Response | BufferSource | WebAssembly.Module;
+}
+
+export interface TaskOptions {
+  /**
+   * Hand the input's buffers to the worker instead of copying them, leaving
+   * them detached here. For buffers nothing else reads afterwards.
+   */
+  transfer?: boolean;
+  /**
+   * Abandons the task: the promise rejects with the signal's reason at once.
+   * A task a worker has already started still runs to its end, and its result
+   * is dropped; one not yet sent is never sent.
+   */
+  signal?: AbortSignal;
+}
+
+export interface Pool {
+  /** Compiles the wasm and starts one worker ahead of the first task. */
+  preload(): Promise<void>;
+  /** Changes the worker limit; idle workers past it stop now, busy ones when done. */
+  setWorkerLimit(workers: number): void;
+  readonly workerLimit: number;
+  /** Stops every worker and rejects what they held. */
+  dispose(): void;
+}
+
+export interface TaskPool extends Pool {
+  /** Runs the task `tasks.js` exports under `name` on a worker. */
+  run(name: string, args?: unknown[], options?: TaskOptions): Promise<any>;
+}
+
+export function createPool(options?: PoolOptions): TaskPool;

package/legacy/pool-core.js

@@ -0,0 +1,250 @@
+// Work off the calling thread: a pool of workers, each running this entry's
+// own module and the tasks its `tasks.js` names. The wasm is compiled once here
+// and handed to every worker; inputs go over by transfer of a copy, or of the
+// caller's own buffers when asked, and results come back by transfer, so a
+// task copies nothing it does not have to.
+import init from './index.js';
+import * as tasks from './tasks.js';
+
+/** Leaves a core for the page, and stops at four, past which a page rarely has
+ * that many files in flight at once. */
+const defaultWorkers = () =>
+  Math.max(1, Math.min(4, (globalThis.navigator?.hardwareConcurrency ?? 4) - 1));
+
+const builtin = (name) =>
+  typeof process !== 'undefined' && typeof process.getBuiltinModule === 'function'
+    ? process.getBuiltinModule(name)
+    : undefined;
+
+async function compile(wasm) {
+  if (wasm instanceof WebAssembly.Module) return wasm;
+  let source = wasm ?? new URL('./index_bg.wasm', import.meta.url);
+  if (typeof source === 'string' || source instanceof URL) {
+    const url = new URL(source, import.meta.url);
+    // Node's fetch does not read files.
+    const fs = url.protocol === 'file:' ? builtin('node:fs/promises') : undefined;
+    if (fs) return WebAssembly.compile(await fs.readFile(url));
+    source = await fetch(url);
+  }
+  if (typeof Response !== 'undefined' && source instanceof Response) {
+    if (!source.ok) throw new Error(`failed to fetch ${source.url}: ${source.status}`);
+    if (source.headers.get('content-type') === 'application/wasm') {
+      return WebAssembly.compileStreaming(source);
+    }
+    source = await source.arrayBuffer();
+  }
+  return WebAssembly.compile(source);
+}
+
+/** What the pool needs of a worker, the same over a Web Worker and a Node
+ * worker thread. */
+function spawn(blobUrl) {
+  if (typeof Worker === 'function') {
+    const url = new URL('./worker.js', import.meta.url);
+    // A bundler recognises this exact form and emits the worker as a chunk.
+    const worker =
+      typeof location === 'undefined' || url.origin === location.origin
+        ? new Worker(new URL('./worker.js', import.meta.url), { type: 'module' })
+        : new Worker(blobUrl(url), { type: 'module' });
+    return {
+      post: (message, transfer) => worker.postMessage(message, transfer),
+      listen: (onMessage, onError) => {
+        worker.addEventListener('message', (event) => onMessage(event.data));
+        worker.addEventListener('error', (event) => {
+          event.preventDefault();
+          onError(new Error(event.message || 'the worker failed'));
+        });
+        worker.addEventListener('messageerror', () => onError(new Error('a result could not be read')));
+      },
+      busy: () => {},
+      terminate: () => worker.terminate(),
+    };
+  }
+  const threads = builtin('node:worker_threads');
+  if (!threads) return null;
+  const worker = new threads.Worker(new URL('./worker.js', import.meta.url));
+  // An idle worker does not keep Node running; one with work does.
+  worker.unref();
+  return {
+    post: (message, transfer) => worker.postMessage(message, transfer),
+    listen: (onMessage, onError) => {
+      worker.on('message', onMessage);
+      worker.on('error', onError);
+      worker.on('exit', (code) => onError(new Error(`the worker exited with code ${code}`)));
+    },
+    busy: (busy) => (busy ? worker.ref() : worker.unref()),
+    terminate: () => worker.terminate(),
+  };
+}
+
+const workersAvailable = () =>
+  typeof Worker === 'function' || builtin('node:worker_threads') !== undefined;
+
+const isPlain = (value) => {
+  if (value === null || typeof value !== 'object') return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+
+/**
+ * The arguments as they go to a worker, and the buffers that go with them.
+ * Without `transfer` every typed array is copied first -- just its own bytes,
+ * where structured cloning would copy the whole buffer behind a view -- and
+ * the copy is what moves; with it the caller's buffers move and are left
+ * detached.
+ */
+function outgoing(args, transfer) {
+  const buffers = new Set();
+  const visit = (value) => {
+    if (ArrayBuffer.isView(value)) {
+      const view = transfer ? value : value.slice();
+      if (!(view.buffer instanceof ArrayBuffer)) return view;
+      buffers.add(view.buffer);
+      return view;
+    }
+    if (value instanceof ArrayBuffer) {
+      const buffer = transfer ? value : value.slice(0);
+      buffers.add(buffer);
+      return buffer;
+    }
+    if (Array.isArray(value)) return value.map(visit);
+    if (isPlain(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, visit(item)]));
+    return value;
+  };
+  const sent = args.map(visit);
+  return { sent, buffers: [...buffers] };
+}
+
+const aborted = (signal) => signal.reason ?? new DOMException('The task was aborted', 'AbortError');
+
+export function createPool(options = {}) {
+  let limit = options.workers ?? defaultWorkers();
+  let compiled = null;
+  let local = null;
+  let blob = null;
+  let disposed = false;
+  let nextId = 0;
+  const slots = [];
+
+  const load = () => (compiled ??= compile(options.wasm));
+  // A worker script must share the page's origin. From a CDN, a worker made
+  // here imports it instead, which a module worker may do across origins.
+  const blobUrl = (url) =>
+    (blob ??= URL.createObjectURL(
+      new Blob([`import ${JSON.stringify(url.href)};`], { type: 'text/javascript' }),
+    ));
+
+  function retire(slot, error) {
+    const at = slots.indexOf(slot);
+    if (at >= 0) slots.splice(at, 1);
+    slot.worker.terminate();
+    for (const { reject } of slot.pending.values()) reject(error);
+    slot.pending.clear();
+  }
+
+  function open(module) {
+    const worker = spawn(blobUrl);
+    if (!worker) return null;
+    const slot = { worker, pending: new Map() };
+    worker.listen(
+      (message) => {
+        const task = slot.pending.get(message.id);
+        if (!task) return;
+        slot.pending.delete(message.id);
+        if (slot.pending.size === 0) {
+          worker.busy(false);
+          if (slots.indexOf(slot) >= limit) retire(slot);
+        }
+        if ('error' in message) task.reject(new Error(message.error));
+        else task.resolve(message.result);
+      },
+      // A worker that fails takes only its own tasks down; the next task
+      // starts another.
+      (error) => {
+        if (slots.includes(slot)) retire(slot, error);
+      },
+    );
+    worker.post({ type: 'init', module });
+    slots.push(slot);
+    return slot;
+  }
+
+  /** The least loaded worker, or a new one while every worker is busy and
+   * the limit allows another. */
+  function pick(module) {
+    let best = null;
+    for (const slot of slots.slice(0, limit)) {
+      if (!best || slot.pending.size < best.pending.size) best = slot;
+    }
+    if ((!best || best.pending.size > 0) && slots.length < limit) return open(module) ?? best;
+    return best;
+  }
+
+  const onThisThread = () =>
+    (local ??= load().then((module) => init({ module_or_path: module })));
+
+  async function run(name, args = [], { transfer = false, signal } = {}) {
+    if (disposed) throw new Error('the pool was disposed');
+    if (typeof tasks[name] !== 'function') throw new TypeError(`no task named ${name}`);
+    signal?.throwIfAborted();
+    if (limit > 0 && workersAvailable()) {
+      const module = await load();
+      if (disposed) throw new Error('the pool was disposed');
+      signal?.throwIfAborted();
+      const slot = pick(module);
+      if (slot) {
+        const id = nextId++;
+        const { sent, buffers } = outgoing(args, transfer);
+        return new Promise((resolve, reject) => {
+          const task = { resolve, reject };
+          if (signal) {
+            // A task a worker has started runs to its end. Aborting it settles
+            // the caller now and drops the result when it comes; the task stays
+            // counted against its worker until then, so the load stays true.
+            const onAbort = () => {
+              task.resolve = task.reject = () => {};
+              reject(aborted(signal));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            const settle = (done) => (value) => {
+              signal.removeEventListener('abort', onAbort);
+              done(value);
+            };
+            task.resolve = settle(resolve);
+            task.reject = settle(reject);
+          }
+          slot.pending.set(id, task);
+          slot.worker.busy(true);
+          slot.worker.post({ id, task: name, args: sent }, buffers);
+        });
+      }
+    }
+    await onThisThread();
+    signal?.throwIfAborted();
+    return tasks[name](...args);
+  }
+
+  return {
+    run,
+    async preload() {
+      if (limit > 0 && workersAvailable()) {
+        const module = await load();
+        if (!disposed && slots.length === 0) open(module);
+      } else {
+        await onThisThread();
+      }
+    },
+    setWorkerLimit(workers) {
+      limit = workers;
+      for (const slot of slots.slice(limit)) if (slot.pending.size === 0) retire(slot);
+    },
+    get workerLimit() {
+      return limit;
+    },
+    dispose() {
+      disposed = true;
+      for (const slot of [...slots]) retire(slot, new Error('the pool was disposed'));
+      if (blob) URL.revokeObjectURL(blob);
+    },
+  };
+}

package/legacy/pool.d.ts

@@ -1,28 +1,11 @@
-import type { DracoAttributeRequest, DracoDecodeResult } from './index.js';
+import type { DracoAttributeRequest, DracoDecodeOptions, DracoDecodeResult } from './index.js';
+import type { Pool, PoolOptions, TaskOptions } from './pool-core.js';
 
-export interface DecoderPoolOptions {
-  /**
-   * How many workers to run at most; they start as work arrives. Defaults to
-   * one less than the cores, between one and four. `0` decodes on the calling
-   * thread, as does an environment without workers.
-   */
-  workers?: number;
-  /**
-   * The entry's wasm, when it is not next to this module where the pool looks
-   * for it: a URL, a `Response`, the bytes, or a compiled module.
-   */
-  wasm?: string | URL | Response | BufferSource | WebAssembly.Module;
-}
+export type DecoderPoolOptions = PoolOptions;
 
-export interface DecodeOptions {
-  /**
-   * Hand the stream's buffer to the worker instead of copying it, leaving it
-   * detached here. For a buffer nothing else reads afterwards.
-   */
-  transfer?: boolean;
-}
+export interface DecodeOptions extends DracoDecodeOptions, TaskOptions {}
 
-export interface DecoderPool {
+export interface DecoderPool extends Pool {
   /**
    * `decode_draco` on a worker. A stream that does not decode resolves with
    * `success: false`, as `decode_draco` returns it; a worker that fails rejects
@@ -33,13 +16,7 @@ export interface DecoderPool {
     attributes?: DracoAttributeRequest[],
     options?: DecodeOptions,
   ): Promise<DracoDecodeResult>;
-  /** Compiles the wasm and starts one worker ahead of the first decode. */
-  preload(): Promise<void>;
-  /** Changes the worker limit; idle workers past it stop now, busy ones when done. */
-  setWorkerLimit(workers: number): void;
-  readonly workerLimit: number;
-  /** Stops every worker and rejects what they held. */
-  dispose(): void;
 }
 
 export function createDecoderPool(options?: DecoderPoolOptions): DecoderPool;
+export { createDecoderPool as createPool };