@loaders.gl/scene 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/draco-writer-worker.js

@@ -1,14 +1,56 @@
 "use strict";
 (() => {
   var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
+  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  var worker_threads_browser_exports = {};
+  __export(worker_threads_browser_exports, {
+    NodeWorker: () => NodeWorker2,
+    parentPort: () => parentPort2
+  });
+  var NodeWorker2, parentPort2;
+  var init_worker_threads_browser = __esm({
+    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
+      "use strict";
+      NodeWorker2 = class {
+        /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+        constructor(...arguments_) {
+          const runtimeProcess = globalThis.process;
+          const WorkerConstructor = runtimeProcess?.getBuiltinModule?.("node:worker_threads").Worker;
+          if (WorkerConstructor) {
+            return new WorkerConstructor(...arguments_);
+          }
+        }
+        /** No-op browser fallback matching the native Worker API. */
+        terminate() {
+        }
+      };
+      parentPort2 = null;
+    }
+  });
+
+  // ../core/src/constants/index.ts
+  var LOADERS_GL_FIXTURE_BRANCH = "master";
+  var LOADERS_GL_RAW_FIXTURE_URL = `https://raw.githubusercontent.com/visgl/loaders.gl/${LOADERS_GL_FIXTURE_BRANCH}/`;
+  var LOADERS_GL_REDIRECTING_FIXTURE_URL = `https://github.com/visgl/loaders.gl/raw/${LOADERS_GL_FIXTURE_BRANCH}/`;
+  var NPM_TAG = "beta";
+
   // ../core/src/worker-utils/lib/env-utils/version.ts
   function getVersion() {
-    const version = false ? NPM_TAG : "5.0.0-beta.2";
+    const version = false ? NPM_TAG : "5.0.0-beta.4";
     globalThis._loadersgl_ = globalThis._loadersgl_ || {};
     globalThis._loadersgl_.version ||= version;
     return version;
@@ -43,11 +85,11 @@
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/npm-tag.js
-  var NPM_TAG = "latest";
+  var NPM_TAG2 = "latest";
 
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/version.js
   function getVersion2() {
-    return false ? NPM_TAG : "5.0.0-beta.2";
+    return false ? NPM_TAG2 : "5.0.0-beta.4";
   }
   var VERSION2 = getVersion2();
 
@@ -208,14 +250,23 @@
     terminate() {
     }
   };
-  var parentPort = null;
+  var parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
 
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
   var workerURLCache = /* @__PURE__ */ new Map();
   function getLoadableWorkerURL(props) {
     assert2(props.source && !props.url || !props.source && props.url);
-    if (props.url && props.workerType === "module")
+    if (props.url && props.workerType === "module") {
+      const baseUrl = globalThis.document?.baseURI ?? globalThis.location?.href;
+      if (!baseUrl)
+        return props.url;
+      const resolved = new URL(props.url, baseUrl);
+      const origin = globalThis.location?.origin;
+      if (/^https?:$/.test(resolved.protocol) && resolved.origin !== origin) {
+        return getLoadableWorkerURLFromSource(`import ${JSON.stringify(resolved.href)};`);
+      }
       return props.url;
+    }
     let workerURL = workerURLCache.get(props.source || props.url);
     if (!workerURL) {
       if (props.url) {
@@ -263,6 +314,9 @@
       else if (ArrayBuffer.isView(value)) {
         if (isTransferable(value.buffer))
           transfersSet.add(value.buffer);
+      } else if (recursive && typeof MessageChannel !== "undefined" && value instanceof MessageChannel) {
+        visit(value.port1);
+        visit(value.port2);
       } else if (recursive && value instanceof Map) {
         for (const [key, item] of value) {
           visit(key);
@@ -367,7 +421,7 @@
       if (this.terminated)
         return this.termination ?? Promise.resolve();
       this.terminated = true;
-      this.termination = Promise.resolve(this.worker.terminate()).then(() => void 0);
+      this.termination = Promise.resolve(this.worker.terminate()).then(() => void 0).finally(() => this.releaseModuleWorkerURL());
       void this.termination.catch(() => void 0);
       return this.termination;
     }
@@ -417,9 +471,9 @@
     _createBrowserWorker() {
       if (this.loadWorker) {
         try {
-          const worker2 = this.loadWorker();
-          if (worker2) {
-            return this._initializeBrowserWorker(worker2);
+          const worker = this.loadWorker();
+          if (worker) {
+            return this._initializeBrowserWorker(worker);
           }
         } catch (error) {
           if (!this.source && !this.url && !this.getUrl) {
@@ -433,8 +487,22 @@
         url,
         workerType: this.workerType
       });
-      const worker = new Worker(this._loadableURL, { name: this.name, type: this.workerType });
-      return this._initializeBrowserWorker(worker);
+      if (this.workerType === "module" && url && this._loadableURL !== url && this._loadableURL.startsWith("blob:"))
+        this.ownedModuleWorkerURL = this._loadableURL;
+      try {
+        const worker = new Worker(this._loadableURL, { name: this.name, type: this.workerType });
+        return this._initializeBrowserWorker(worker);
+      } catch (error) {
+        this.releaseModuleWorkerURL();
+        throw error;
+      }
+    }
+    /** Releases only the module shim owned by this worker, never caller-owned blob URLs. */
+    releaseModuleWorkerURL() {
+      if (this.ownedModuleWorkerURL) {
+        URL.revokeObjectURL(this.ownedModuleWorkerURL);
+        this.ownedModuleWorkerURL = void 0;
+      }
     }
     /** Attaches protocol handlers to a browser worker. */
     _initializeBrowserWorker(worker) {
@@ -1161,16 +1229,16 @@
      */
     static set onmessage(onMessage2) {
       async function handleMessage(message) {
-        const parentPort2 = await getParentPort();
-        const { type, payload } = parentPort2 ? message : message.data;
+        const parentPort3 = await getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage2(type, payload);
       }
-      getParentPort().then((parentPort2) => {
-        if (parentPort2) {
-          parentPort2.on("message", (message) => {
+      getParentPort().then((parentPort3) => {
+        if (parentPort3) {
+          parentPort3.on("message", (message) => {
             handleMessage(message);
           });
-          parentPort2.on("exit", () => console.debug("Node worker closing"));
+          parentPort3.on("exit", () => console.debug("Node worker closing"));
         } else {
           globalThis.onmessage = handleMessage;
         }
@@ -1188,9 +1256,9 @@
         };
         onMessageWrapperMap.set(onMessage2, onMessageWrapper);
       }
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.on("message", onMessageWrapper);
+      const parentPort3 = await getParentPort();
+      if (parentPort3) {
+        parentPort3.on("message", onMessageWrapper);
       } else {
         globalThis.addEventListener("message", onMessageWrapper);
       }
@@ -1201,9 +1269,9 @@
       if (!onMessageWrapper) {
         return;
       }
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.off("message", onMessageWrapper);
+      const parentPort3 = await getParentPort();
+      if (parentPort3) {
+        parentPort3.off("message", onMessageWrapper);
       } else {
         globalThis.removeEventListener("message", onMessageWrapper);
       }
@@ -1213,12 +1281,12 @@
      * @param type
      * @param payload
      */
-    static async postMessage(type, payload) {
+    static async postMessage(type, payload, copy = false) {
       const data = { source: "loaders.gl", type, payload };
-      const transferList = getTransferList(payload);
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.postMessage(data, transferList);
+      const transferList = copy ? [] : getTransferList(payload);
+      const parentPort3 = await getParentPort();
+      if (parentPort3) {
+        parentPort3.postMessage(data, transferList);
       } else {
         globalThis.postMessage(data, transferList);
       }
@@ -1335,7 +1403,7 @@
     const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
     let version = worker.version;
     if (version === "latest") {
-      version = NPM_TAG;
+      version = NPM_TAG2;
     }
     const versionTag = version ? `@${version}` : "";
     const packageName = worker.packageName || `@loaders.gl/${worker.module}`;
@@ -1469,8 +1537,62 @@
     return bytes;
   }
 
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+  function validateOutputOwnership(ownership) {
+    if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
+      throw new Error("Invalid worker output ownership");
+    }
+  }
+
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/process-on-worker.js
+  async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+    validateOutputOwnership(options.outputOwnership);
+    if (options.inputOwnership !== void 0 && !["copy", "transfer", "share"].includes(options.inputOwnership))
+      throw new Error("Invalid worker input ownership");
+    options = prepareSharedState(options);
+    throwIfAborted(options.signal);
+    validateSharedInput(options, [data, serializableOptions(options), jobContext]);
+    const name = getWorkerName(worker);
+    const workerPool = options.workerPool ?? WorkerFarm.getWorkerFarm(options).getWorkerPool(getWorkerPoolTarget(worker, options, name));
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(
+      jobName,
+      // eslint-disable-next-line
+      onMessage.bind(null, context, options),
+      void 0,
+      options.signal,
+      {
+        inputBytes: getInputByteLength([data, budgetOptions(options), jobContext]),
+        priority: options.priority,
+        admission: options.admission,
+        sharedState: options.sharedState ? new SharedWorkerState(options.sharedState) : void 0,
+        cancellationMode: options.cancellationMode,
+        cancellationTimeout: options.cancellationTimeout
+      }
+    );
+    try {
+      if (options.signal?.aborted && !job.isCancelled)
+        job.abort(getAbortReason(options.signal));
+      const workerOptions = serializableOptions(options);
+      const transferableOptions = getTransferListForWriter(workerOptions);
+      const transferableContext = getTransferListForWriter(jobContext);
+      if (job.isRunning) {
+        job.postMessage("process", {
+          input: data,
+          options: transferableOptions,
+          context: transferableContext
+        }, options.inputOwnership === "copy" || options.inputOwnership === "share" ? [] : void 0);
+      }
+      const result = await job.result;
+      return result.result;
+    } catch (error) {
+      if (!job.isCancelled)
+        job.abort(error);
+      throw error;
+    }
+  }
   function processOnWorkerInBatches(worker, input, options = {}, context = {}, jobContext = {}) {
+    validateOutputOwnership(options.outputOwnership);
     if (options.inputOwnership !== void 0 && !["copy", "transfer", "share"].includes(options.inputOwnership))
       throw new Error("Invalid worker input ownership");
     return processOnWorkerInBatchesIterator(worker, input, options, context, jobContext);
@@ -1721,7 +1843,7 @@
   var activeController = null;
   var activeInputBatches = null;
   var activeOutputAcknowledgements = null;
-  async function createWorker(process2, processInBatches) {
+  async function createWorker(process2, processInBatches, preload) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
     }
@@ -1762,10 +1884,12 @@
         }
         switch (type) {
           case "preload":
+            await preload?.();
             WorkerBody.postMessage("done", {});
             break;
           case "process":
             throwIfAborted3();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
             if (!process2) {
               throw new Error("Worker does not support atomic processing");
             }
@@ -1775,10 +1899,11 @@
             await WorkerBody.postMessage("done", {
               result,
               executionMs: performance.now() - startedAt
-            });
+            }, payload.options?.["outputOwnership"] === "copy");
             break;
           case "process-in-batches":
             throwIfAborted3();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
@@ -1790,7 +1915,7 @@
               const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
               for await (const batch of resultIterator) {
                 throwIfAborted3();
-                await WorkerBody.postMessage("output-batch", { result: batch });
+                await WorkerBody.postMessage("output-batch", { result: batch }, payload.options?.["outputOwnership"] === "copy");
                 await outputAcknowledgements.next();
               }
               throwIfAborted3();
@@ -1888,14 +2013,14 @@
     });
   }
   function createProgressReporter() {
-    let pending;
+    let pending2;
     let finished = false;
     let scheduled = false;
     const flush = () => {
       scheduled = false;
-      if (pending) {
-        WorkerBody.postMessage("progress", { progress: pending });
-        pending = void 0;
+      if (pending2) {
+        WorkerBody.postMessage("progress", { progress: pending2 });
+        pending2 = void 0;
       }
     };
     return {
@@ -1903,9 +2028,9 @@
       report(progress) {
         if (finished)
           return;
-        if (pending && pending.phase !== progress.phase)
+        if (pending2 && pending2.phase !== progress.phase)
           flush();
-        pending = { ...progress };
+        pending2 = { ...progress };
         if (!scheduled) {
           scheduled = true;
           setTimeout(flush, 0);
@@ -1914,7 +2039,7 @@
       /** Flushes final progress and suppresses reports from stale callbacks. */
       finish(discard = false) {
         if (discard)
-          pending = void 0;
+          pending2 = void 0;
         flush();
         finished = true;
       }
@@ -1926,6 +2051,1159 @@
   var path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
   var moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
 
+  // ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+  var pending = /* @__PURE__ */ new WeakMap();
+  var loaded = /* @__PURE__ */ new WeakSet();
+  function preloadTaskCode(task, signal) {
+    if (!task.preload)
+      return Promise.resolve();
+    let promise = pending.get(task);
+    if (!promise) {
+      promise = Promise.resolve().then(() => task.preload()).then(() => {
+        loaded.add(task);
+      });
+      pending.set(task, promise);
+      void promise.catch(() => pending.delete(task));
+    }
+    return withSignal(promise, signal);
+  }
+  function isTaskCodeLoaded(task) {
+    return !task.preload || loaded.has(task);
+  }
+  function withSignal(operation, signal) {
+    if (!signal)
+      return operation;
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        signal.removeEventListener("abort", abort);
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted)
+        abort();
+      operation.then((value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      }, (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      });
+    });
+  }
+
+  // ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+  function assertPayload(value) {
+    if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
+      throw new TypeError("Task payloads must be plain objects with named fields");
+    }
+  }
+  function clonePayload(value, ownership = "copy") {
+    assertPayload(value);
+    if (!["copy", "transfer", "share"].includes(ownership))
+      throw new TypeError("Invalid input ownership");
+    const transfer = getTransferList(value);
+    if (ownership === "share" && transfer.length)
+      throw new TypeError("Share requires shared storage");
+    return structuredClone(value, {
+      transfer: ownership === "transfer" ? transfer : []
+    });
+  }
+  function taskContext(state, context = {}) {
+    const signal = context.signal ?? new AbortController().signal;
+    return {
+      state,
+      signal,
+      throwIfAborted: () => {
+        signal.throwIfAborted();
+        context.throwIfAborted?.();
+      },
+      reportProgress: (progress) => context.reportProgress?.({
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      })
+    };
+  }
+  var TaskRuntime = class {
+    constructor(task) {
+      this.task = task;
+      this.initialized = false;
+    }
+    async initialize(input, context = {}) {
+      if (this.initialized)
+        throw new Error("Task is already initialized");
+      assertPayload(input);
+      await preloadTaskCode(this.task, context.signal);
+      context.signal?.throwIfAborted();
+      this.state = await this.task.initialize?.(input, taskContext(void 0, context));
+      this.initialized = true;
+      return {};
+    }
+    async destroy() {
+      if (this.initialized) {
+        this.initialized = false;
+        const state = this.state;
+        this.state = void 0;
+        if (this.task.initialize)
+          await this.task.destroy?.(state);
+      }
+      return {};
+    }
+    async process(input, options, context = {}) {
+      if (!this.initialized)
+        throw new Error("Task is not initialized");
+      if (!this.task.process)
+        throw new Error("Task has no atomic processor");
+      assertPayload(input);
+      const result = await this.task.process(input, options, taskContext(this.state, context));
+      assertPayload(result);
+      return result;
+    }
+    async *stream(inputs, options, context = {}) {
+      if (!this.initialized)
+        throw new Error("Task is not initialized");
+      if (!this.task.processInBatches)
+        throw new Error("Task has no streaming processor");
+      for await (const output of this.task.processInBatches(inputs, options, taskContext(this.state, context))) {
+        assertPayload(output);
+        yield output;
+      }
+    }
+  };
+  async function initializeTaskWorker(task) {
+    if (!await WorkerBody.inWorkerThread())
+      throw new Error("initializeTaskWorker must run inside a worker");
+    if (installed)
+      throw new Error("A task is already installed in this worker");
+    installed = true;
+    const runtime = new TaskRuntime(task);
+    let streamOptions = {};
+    return createWorker(async (request, _options, context) => {
+      switch (request.operation) {
+        case "initialize":
+          return runtime.initialize(request.input, context);
+        case "destroy":
+          return runtime.destroy();
+        case "stream-options":
+          streamOptions = request.options;
+          return {};
+        case "process":
+          return runtime.process(request.input, request.options, context);
+        default:
+          throw new Error("Unknown task operation");
+      }
+    }, async function* (inputs, _options, context) {
+      async function* batches() {
+        for await (const input of inputs) {
+          assertPayload(input);
+          yield input;
+        }
+      }
+      try {
+        yield* runtime.stream(batches(), streamOptions, context);
+      } finally {
+        streamOptions = {};
+      }
+    }, () => preloadTaskCode(task));
+  }
+  var installed = false;
+  function localContext(controls) {
+    return {
+      signal: controls.signal,
+      reportProgress: (progress) => controls.onProgress?.(progress)
+    };
+  }
+
+  // ../../node_modules/@math.gl/core/dist/tasks/task-sync.js
+  function runTaskSync(task, input, request = {}) {
+    if (!isTaskCodeLoaded(task))
+      throw new Error("Preload task on the main thread before runTaskSync");
+    if ("execution" in request)
+      throw new TypeError("runTaskSync always runs on the calling thread");
+    if (!task.process)
+      throw new TypeError("Task has no atomic processor");
+    for (const hook of [task.initialize, task.process, task.destroy]) {
+      if (hook && Object.prototype.toString.call(hook) === "[object AsyncFunction]")
+        throw new TypeError("runTaskSync requires synchronous lifecycle hooks");
+    }
+    if (request.outputOwnership && !["copy", "transfer"].includes(request.outputOwnership))
+      throw new TypeError("Invalid output ownership");
+    const context = taskContext(void 0, localContext(request));
+    context.throwIfAborted();
+    const options = request.options ?? {};
+    if (request.inputOwnership === "transfer") {
+      const metadata = new Set(getTransferList(options));
+      if (getTransferList(input).some((buffer) => metadata.has(buffer)))
+        throw new Error("Transferred input aliases reusable options; use inputOwnership: copy");
+    }
+    const copiedOptions = clonePayload(options);
+    const initialization = clonePayload(request.initialization ?? {}, request.initializationOwnership);
+    let initialized = false;
+    let failure;
+    let failed = false;
+    let output;
+    try {
+      const state = task.initialize?.(initialization, context);
+      if (isThenable(state)) {
+        void Promise.resolve(state).then((value) => task.destroy?.(value)).catch(() => {
+        });
+        throw new TypeError("runTaskSync initialize returned a promise");
+      }
+      context.state = state;
+      initialized = true;
+      context.throwIfAborted();
+      const copiedInput = clonePayload(input, request.inputOwnership);
+      const result = task.process(copiedInput, copiedOptions, context);
+      if (isThenable(result)) {
+        initialized = false;
+        void Promise.resolve(result).catch(() => {
+        }).then(() => {
+          if (task.initialize)
+            return task.destroy?.(context.state);
+        }).catch(() => {
+        });
+        throw new TypeError("runTaskSync process returned a promise");
+      }
+      assertPayload(result);
+      context.throwIfAborted();
+      output = clonePayload(result, request.outputOwnership ?? "transfer");
+    } catch (error) {
+      failed = true;
+      failure = error;
+    } finally {
+      if (initialized && task.initialize) {
+        try {
+          const cleanup = task.destroy?.(context.state);
+          if (isThenable(cleanup)) {
+            void Promise.resolve(cleanup).catch(() => {
+            });
+            throw new TypeError("runTaskSync destroy returned a promise");
+          }
+        } catch (error) {
+          if (failed)
+            throw new AggregateError([failure, error], "Task processing and destruction failed");
+          throw error;
+        }
+      }
+    }
+    if (failed)
+      throw failure;
+    return output;
+  }
+  function isThenable(value) {
+    return Boolean(value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function");
+  }
+
+  // ../../node_modules/@math.gl/core/dist/tasks/task-runner.js
+  var InitializedTask = class {
+    /** @internal Use TaskRunner.initializeTask. */
+    constructor(task, release, controls) {
+      this.task = task;
+      this.release = release;
+      this.tail = Promise.resolve();
+      this.closed = false;
+      this.streams = /* @__PURE__ */ new Set();
+      this.invalid = false;
+      this.controller = new AbortController();
+      this.runtime = new TaskRuntime(task);
+      const execution = controls.execution ?? "auto";
+      if (!["auto", "main-thread", "worker"].includes(execution))
+        throw new TypeError("Invalid execution mode");
+      if (execution === "worker" && !task.worker)
+        throw new Error("Task has no worker");
+      if (execution !== "main-thread" && task.worker) {
+        const target = task.worker;
+        if (Boolean(target.url) === Boolean(target.create))
+          throw new Error("Supply exactly one worker URL or factory");
+        this.pool = new WorkerPool({
+          name: task.id,
+          url: target.url?.toString(),
+          loadWorker: target.create,
+          workerType: "module",
+          maxConcurrency: 1,
+          maxMobileConcurrency: 1
+        });
+        this.descriptor = {
+          id: task.id,
+          name: task.id,
+          module: "core",
+          version: "prototype",
+          options: {},
+          worker: target.url?.toString() ?? true,
+          loadWorker: target.create,
+          workerInBatches: target.capabilities.streaming
+        };
+      }
+    }
+    /** @internal */
+    async initialize(input, controls) {
+      try {
+        assertPayload(input);
+        await this.enqueue(() => this.invoke("initialize", input, {}, controls));
+      } catch (error) {
+        await this.terminate(error);
+        throw error;
+      }
+    }
+    runTask(input, ...args) {
+      return this.enqueue(async () => {
+        this.checkCapability("atomic");
+        return this.invoke("process", input, args[0]?.options ?? {}, args[0]);
+      });
+    }
+    /** Independent calls sharing this instance, always serial and in input order. */
+    async *runTasks(inputs, ...args) {
+      yield* this.serialStream(async function* (self2) {
+        self2.checkCapability("atomic");
+        for await (const input of asAsync(inputs, self2.controls(args[0]).signal)) {
+          yield await self2.invoke("process", input, args[0]?.options ?? {}, args[0]);
+        }
+      });
+    }
+    /** One processor invocation for the entire input iterable. */
+    async *runTaskInBatches(inputs, ...args) {
+      yield* this.serialStream(async function* (self2) {
+        self2.checkCapability("streaming");
+        const controls = self2.controls(args[0]);
+        const options = clonePayload(args[0]?.options ?? {});
+        async function* prepared() {
+          for await (const input of asAsync(inputs, controls.signal)) {
+            controls.signal?.throwIfAborted();
+            assertNoTransferAlias(input, args[0]?.options ?? {}, controls.inputOwnership);
+            yield clonePayload(input, controls.inputOwnership);
+          }
+        }
+        let completed = false;
+        try {
+          if (self2.pool) {
+            await self2.invoke("stream-options", {}, options, controls);
+            yield* processOnWorkerInBatches(self2.descriptor, prepared(), {
+              ...self2.workerOptions(controls),
+              inputOwnership: "transfer",
+              workerInBatches: true
+            });
+          } else {
+            for await (const output of self2.runtime.stream(prepared(), options, localContext(controls))) {
+              controls.signal?.throwIfAborted();
+              yield clonePayload(output, controls.outputOwnership ?? "transfer");
+            }
+          }
+          completed = true;
+        } catch (error) {
+          if (self2.pool) {
+            self2.invalid = true;
+            await self2.pool.destroy(error);
+          }
+          throw error;
+        } finally {
+          if (self2.pool && !completed)
+            self2.invalid = true;
+        }
+      });
+    }
+    /** Drain accepted work, invoke destroy, and release execution capacity. */
+    close() {
+      if (!this.closing) {
+        this.closed = true;
+        this.closing = (async () => {
+          try {
+            await this.tail;
+            if (!this.invalid)
+              await this.invoke("destroy", {}, {});
+          } finally {
+            try {
+              await this.pool?.destroy();
+            } finally {
+              this.release();
+            }
+          }
+        })();
+      }
+      return this.closing;
+    }
+    /** Abort work. Local JavaScript must settle before its state can be destroyed. */
+    async terminate(reason = new Error("Task terminated")) {
+      this.controller.abort(reason);
+      if (this.pool) {
+        this.invalid = true;
+        await this.pool.destroy(reason);
+      }
+      await Promise.allSettled([...this.streams].map((stop) => stop()));
+      await this.close();
+    }
+    checkCapability(kind) {
+      if (this.pool ? !this.task.worker?.capabilities[kind] : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
+        throw new Error(`Task has no ${kind} processor for this execution route`);
+      }
+    }
+    controls(controls = {}) {
+      if (controls.outputOwnership && !["copy", "transfer"].includes(controls.outputOwnership))
+        throw new TypeError("Invalid output ownership");
+      return {
+        ...controls,
+        signal: controls.signal ? AbortSignal.any([controls.signal, this.controller.signal]) : this.controller.signal
+      };
+    }
+    workerOptions(controls) {
+      return {
+        workerPool: this.pool,
+        workerType: "module",
+        inputOwnership: controls.inputOwnership ?? "copy",
+        outputOwnership: controls.outputOwnership ?? "transfer",
+        signal: controls.signal,
+        onProgress: controls.onProgress,
+        cancellationMode: "terminate"
+      };
+    }
+    async invoke(operation, input, options, controls = {}) {
+      if (this.invalid)
+        throw new Error("Initialized task is invalid; initialize a new instance");
+      const prepared = operation === "destroy" ? {} : this.controls(controls);
+      prepared.signal?.throwIfAborted();
+      assertPayload(input);
+      assertNoTransferAlias(input, options, prepared.inputOwnership);
+      const copiedOptions = clonePayload(options);
+      if (this.pool) {
+        try {
+          return await processOnWorker(this.descriptor, { operation, input: clonePayload(input, prepared.inputOwnership), options: copiedOptions }, this.workerOptions({ ...prepared, inputOwnership: "transfer" }));
+        } catch (error) {
+          this.invalid = true;
+          await this.pool.destroy(error);
+          throw error;
+        }
+      }
+      if (operation === "destroy")
+        return this.runtime.destroy();
+      const copied = clonePayload(input, prepared.inputOwnership);
+      const context = localContext(prepared);
+      if (operation === "initialize") {
+        const result2 = await this.runtime.initialize(copied, context);
+        prepared.signal?.throwIfAborted();
+        return result2;
+      }
+      const result = await this.runtime.process(copied, copiedOptions, context);
+      prepared.signal?.throwIfAborted();
+      return clonePayload(result, prepared.outputOwnership ?? "transfer");
+    }
+    enqueue(operation) {
+      if (this.closed)
+        return Promise.reject(new Error("Initialized task is closed"));
+      const result = this.tail.then(operation);
+      this.tail = result.catch(() => {
+      });
+      return result;
+    }
+    async *serialStream(operation) {
+      if (this.closed)
+        throw new Error("Initialized task is closed");
+      const before = this.tail;
+      let release;
+      this.tail = new Promise((resolve) => {
+        release = resolve;
+      });
+      await before;
+      if (this.controller.signal.aborted) {
+        release();
+        throw this.controller.signal.reason;
+      }
+      const iterator = operation(this)[Symbol.asyncIterator]();
+      let stopping;
+      const stop = () => {
+        stopping ?? (stopping = (async () => {
+          try {
+            await iterator.return?.();
+          } finally {
+            this.streams.delete(stop);
+            release();
+          }
+        })());
+        return stopping;
+      };
+      this.streams.add(stop);
+      try {
+        while (true) {
+          this.controller.signal.throwIfAborted();
+          const next = await iterator.next();
+          if (next.done)
+            return;
+          yield next.value;
+        }
+      } finally {
+        await stop();
+      }
+    }
+  };
+  var TaskRunner = class {
+    constructor(options = {}) {
+      this.active = /* @__PURE__ */ new Set();
+      this.count = 0;
+      this.waiters = [];
+      this.closed = false;
+      this.initializing = /* @__PURE__ */ new Set();
+      this.iterations = /* @__PURE__ */ new Set();
+      this.maxConcurrency = options.maxConcurrency ?? 1;
+      if (!Number.isSafeInteger(this.maxConcurrency) || this.maxConcurrency < 1)
+        throw new RangeError("maxConcurrency must be a positive safe integer");
+    }
+    /** Execute synchronous hooks immediately on the calling thread, without queueing. */
+    runTaskSync(task, input, ...args) {
+      if (this.closed)
+        throw new Error("Task runner is closed");
+      if (this.count >= this.maxConcurrency)
+        throw new Error("Task runner has no synchronous capacity");
+      this.count++;
+      try {
+        return runTaskSync(task, input, args[0]);
+      } finally {
+        const waiter = this.waiters.shift();
+        if (waiter)
+          waiter.resolve();
+        else
+          this.count--;
+      }
+    }
+    initializeTask(task, initialization, controls = {}) {
+      const pending2 = this.open(task, initialization, controls);
+      this.initializing.add(pending2);
+      void pending2.then(() => this.initializing.delete(pending2), () => this.initializing.delete(pending2));
+      return pending2;
+    }
+    async runTask(task, input, ...args) {
+      const request = args[0] ?? {};
+      const handle = await this.initializeTask(task, request.initialization ?? {}, {
+        ...request,
+        inputOwnership: request.initializationOwnership ?? "copy"
+      });
+      return finish(handle, () => handle.runTask(input, request));
+    }
+    async *runTasks(task, inputs, ...args) {
+      const request = args[0] ?? {};
+      if (this.closed)
+        throw new Error("Task runner is closed");
+      if (request.initializationOwnership === "transfer")
+        throw new TypeError("runTasks initialization is a reusable template; use copy or share");
+      const concurrency = request.concurrency ?? 1;
+      if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > this.maxConcurrency)
+        throw new RangeError("concurrency must be between 1 and maxConcurrency");
+      const handles = [];
+      const busy = /* @__PURE__ */ new Set();
+      const pending2 = [];
+      const controller = new AbortController();
+      this.iterations.add(controller);
+      const signal = request.signal ? AbortSignal.any([request.signal, controller.signal]) : controller.signal;
+      const iterator = asAsync(inputs, signal)[Symbol.asyncIterator]();
+      let finished = false;
+      let reading;
+      try {
+        while (!finished || pending2.length) {
+          signal.throwIfAborted();
+          if (!finished && !reading && pending2.length < concurrency) {
+            reading = iterator.next().then((next) => ({ kind: "input", next }));
+          }
+          const event = await Promise.race([
+            ...pending2.length ? [pending2[0]] : [],
+            ...reading ? [reading] : []
+          ]);
+          if (event.kind === "result") {
+            pending2.shift();
+            busy.delete(event.handle);
+            if (event.failed)
+              throw event.error;
+            yield event.value;
+            continue;
+          }
+          reading = void 0;
+          if (event.next.done) {
+            finished = true;
+            continue;
+          }
+          let handle = handles.find((candidate) => !busy.has(candidate));
+          if (!handle && (handles.length === 0 || this.count < this.maxConcurrency)) {
+            handle = await this.initializeTask(task, clonePayload(request.initialization ?? {}, request.initializationOwnership), {
+              ...request,
+              signal,
+              inputOwnership: request.initializationOwnership ?? "copy"
+            });
+            handles.push(handle);
+          }
+          if (!handle) {
+            const result = await pending2.shift();
+            busy.delete(result.handle);
+            if (result.failed)
+              throw result.error;
+            yield result.value;
+            handle = result.handle;
+          }
+          busy.add(handle);
+          const current = handle;
+          pending2.push(handle.runTask(event.next.value, { ...request, signal }).then((value) => ({ kind: "result", handle: current, value }), (error) => ({ kind: "result", handle: current, failed: true, error })));
+        }
+      } finally {
+        this.iterations.delete(controller);
+        controller.abort(new Error("Task iteration closed"));
+        try {
+          if (reading)
+            await reading.catch(() => {
+            });
+          if (!finished)
+            await iterator.return?.();
+        } finally {
+          await Promise.all(pending2);
+          await Promise.all(handles.map((handle) => handle.close()));
+        }
+      }
+    }
+    async *runTaskInBatches(task, inputs, ...args) {
+      const request = args[0] ?? {};
+      const handle = await this.initializeTask(task, request.initialization ?? {}, {
+        ...request,
+        inputOwnership: request.initializationOwnership ?? "copy"
+      });
+      try {
+        yield* handle.runTaskInBatches(inputs, request);
+      } finally {
+        await handle.close();
+      }
+    }
+    /** Close owned handles and workers. Finish or return active iterators first. */
+    close() {
+      if (!this.closing) {
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0))
+          waiter.reject(new Error("Task runner is closed"));
+        this.closing = (async () => {
+          await Promise.allSettled(this.initializing);
+          const results = await Promise.allSettled([...this.active].map((handle) => handle.close()));
+          const failure = results.find((result) => result.status === "rejected");
+          if (failure?.status === "rejected")
+            throw failure.reason;
+        })();
+      }
+      return this.closing;
+    }
+    async terminate(reason = new Error("Task runner terminated")) {
+      for (const controller of this.iterations)
+        controller.abort(reason);
+      const closing = this.close();
+      await Promise.allSettled([...this.active].map((handle) => handle.terminate(reason)));
+      await closing;
+    }
+    async open(task, initialization, controls) {
+      if (this.closed)
+        throw new Error("Task runner is closed");
+      controls.signal?.throwIfAborted();
+      if (this.count >= this.maxConcurrency) {
+        await new Promise((resolve, reject) => {
+          const waiter = {
+            resolve: () => {
+              cleanup();
+              resolve();
+            },
+            reject: (error) => {
+              cleanup();
+              reject(error);
+            }
+          };
+          const abort = () => {
+            this.waiters = this.waiters.filter((item) => item !== waiter);
+            waiter.reject(controls.signal?.reason);
+          };
+          const cleanup = () => controls.signal?.removeEventListener("abort", abort);
+          this.waiters.push(waiter);
+          controls.signal?.addEventListener("abort", abort, { once: true });
+          if (controls.signal?.aborted)
+            abort();
+        });
+      } else
+        this.count++;
+      let handle;
+      let released = false;
+      const release = () => {
+        if (released)
+          return;
+        released = true;
+        if (handle)
+          this.active.delete(handle);
+        const waiter = this.waiters.shift();
+        if (waiter)
+          waiter.resolve();
+        else
+          this.count--;
+      };
+      try {
+        if (this.closed)
+          throw new Error("Task runner is closed");
+        handle = new InitializedTask(task, release, controls);
+        this.active.add(handle);
+        await handle.initialize(initialization, controls);
+        return handle;
+      } catch (error) {
+        release();
+        throw error;
+      }
+    }
+  };
+  async function finish(handle, operation) {
+    let result;
+    try {
+      result = await operation();
+    } catch (error) {
+      try {
+        await handle.close();
+      } catch (cleanup) {
+        throw new AggregateError([error, cleanup], "Task processing and destruction failed");
+      }
+      throw error;
+    }
+    await handle.close();
+    return result;
+  }
+  async function* asAsync(inputs, signal) {
+    const iterator = Symbol.asyncIterator in inputs ? inputs[Symbol.asyncIterator]() : inputs[Symbol.iterator]();
+    let done = false;
+    let blocked = false;
+    try {
+      while (true) {
+        const next = await new Promise((resolve, reject) => {
+          const cleanup = () => signal?.removeEventListener("abort", abort);
+          const abort = () => {
+            cleanup();
+            reject(signal?.reason);
+          };
+          signal?.addEventListener("abort", abort, { once: true });
+          if (signal?.aborted) {
+            abort();
+            return;
+          }
+          try {
+            blocked = true;
+            Promise.resolve(iterator.next()).then((value) => {
+              blocked = false;
+              cleanup();
+              resolve(value);
+            }, (error) => {
+              blocked = false;
+              cleanup();
+              reject(error);
+            });
+          } catch (error) {
+            blocked = false;
+            cleanup();
+            reject(error);
+          }
+        });
+        if (next.done) {
+          done = true;
+          return;
+        }
+        yield next.value;
+      }
+    } finally {
+      if (!done) {
+        if (blocked) {
+          try {
+            void Promise.resolve(iterator.return?.()).catch(() => {
+            });
+          } catch {
+          }
+        } else {
+          await iterator.return?.();
+        }
+      }
+    }
+  }
+  function assertNoTransferAlias(input, options, ownership) {
+    if (ownership === "transfer") {
+      const metadata = new Set(getTransferList(options));
+      if (getTransferList(input).some((buffer) => metadata.has(buffer))) {
+        throw new Error("Transferred input aliases reusable options; use inputOwnership: copy");
+      }
+    }
+  }
+
+  // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
+  function normalizeTaskProgress(progress) {
+    return { ...progress, phase: progress.phase ?? "process", unit: progress.unit ?? "items" };
+  }
+  async function isWorkerThread() {
+    if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+      return true;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const { isMainThread } = await Promise.resolve().then(() => (init_worker_threads_browser(), worker_threads_browser_exports));
+      return !isMainThread;
+    }
+    return false;
+  }
+  var initializeTaskWorker2 = initializeTaskWorker;
+
+  // ../core/src/worker-utils/lib/worker-api/get-worker-url.ts
+  var warnedWorkerVersionFallbacks2 = /* @__PURE__ */ new Set();
+  function getCustomWorkerURL2(worker, options = {}) {
+    const workerFile = isBrowser ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+    let url = getConfiguredWorkerURL2(worker, options);
+    const workerType = options._workerType || options?.core?._workerType;
+    if (!url && workerType === "test") {
+      if (isBrowser) {
+        url = `modules/${worker.module}/dist/${workerFile}`;
+      } else {
+        const workerSourceDirectory = worker.module === "core" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
+        const workerSourceNode = worker.workerSourceNode || `${workerSourceDirectory}/${worker.id}-worker-node.ts`;
+        url = `modules/${worker.module}/src/${workerSourceNode}`;
+      }
+    }
+    return url || null;
+  }
+  function getConfiguredWorkerURL2(worker, options = {}) {
+    const workerOptions = options[worker.id] || {};
+    return workerOptions.workerUrl || (worker.id === "compression" ? options.workerUrl : null) || null;
+  }
+  function getWorkerURL2(worker, options = {}) {
+    const customWorkerUrl = getCustomWorkerURL2(worker, options);
+    const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
+    const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL2(worker, true);
+    assert(url);
+    return url;
+  }
+  function getDefaultWorkerURL2(worker, warn = false) {
+    const workerFile = isBrowser ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+    let version = worker.version;
+    if (version === "latest") {
+      version = NPM_TAG;
+    }
+    const versionTag = version ? `@${version}` : "";
+    const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    if (warn) {
+      warnIfUsingNpmTagFallback2(worker, url);
+    }
+    return url;
+  }
+  function warnIfUsingNpmTagFallback2(worker, url) {
+    if (worker.version !== "latest") {
+      return;
+    }
+    const workerId = `${worker.module}:${worker.id}`;
+    if (warnedWorkerVersionFallbacks2.has(workerId)) {
+      return;
+    }
+    warnedWorkerVersionFallbacks2.add(workerId);
+    console.warn(
+      `loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`
+    );
+  }
+
+  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  function getTransferList2(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable2(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable2(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList2(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable2(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+  function getTransferListForWriter2(object) {
+    if (object === null) {
+      return {};
+    }
+    const clone = Object.assign({}, object);
+    Object.keys(clone).forEach((key) => {
+      if (object[key] !== null && typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+        clone[key] = getTransferListForWriter2(object[key]);
+      } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
+        clone[key] = {};
+      } else {
+        clone[key] = object[key];
+      }
+    });
+    return clone;
+  }
+
+  // ../core/src/worker-utils/lib/worker-api/process-on-worker.ts
+  var runners = /* @__PURE__ */ new WeakMap();
+  var activeRunners = /* @__PURE__ */ new Set();
+  var moduleWorkerUrls = /* @__PURE__ */ new Map();
+  function canProcessOnWorker2(worker, options = {}) {
+    const supported = isBrowser ? typeof Worker !== "undefined" : Boolean(options._nodeWorkers);
+    return Boolean(
+      supported && options.worker && (worker.worker || worker.loadWorker || getConfiguredWorkerURL2(worker, options))
+    );
+  }
+  async function* processOnWorkerInBatches2(worker, input, options = {}, context = {}, jobContext = {}) {
+    const taskInput = wrapInput(input);
+    let session;
+    try {
+      session = await openSession(worker, options, context, jobContext);
+      for await (const result of session.handle.runTaskInBatches(taskInput, {
+        ...getControls(options),
+        options: getParserOptions(options)
+      }))
+        yield result.value;
+    } finally {
+      const closingInput = taskInput.return?.();
+      void closingInput?.catch(() => {
+      });
+      await session?.close();
+    }
+  }
+  function getTask(worker, options) {
+    if (options.source || options.core?.source)
+      throw new Error(
+        "Inline legacy worker source is unsupported; use a TaskRunner worker URL or factory"
+      );
+    const create = !getCustomWorkerURL2(worker, options) && isBrowser ? worker.loadWorker : void 0;
+    const url = getWorkerURL2(worker, options);
+    return {
+      id: `${worker.module}:${worker.id}`,
+      initialize: (state) => state,
+      worker: {
+        ...create ? { create: () => create() ?? createModuleWorker(url) } : { url },
+        capabilities: { atomic: true, streaming: true }
+      }
+    };
+  }
+  function getControls(options) {
+    return {
+      execution: "worker",
+      signal: options.signal,
+      inputOwnership: options.inputOwnership ?? "transfer",
+      outputOwnership: options.outputOwnership ?? "transfer",
+      onProgress: options.onProgress ? (progress) => options.onProgress?.(normalizeTaskProgress(progress)) : void 0
+    };
+  }
+  function getParserOptions(options) {
+    const { signal, onProgress, ...parserOptions } = options;
+    return getTransferListForWriter2(parserOptions);
+  }
+  async function openSession(worker, options, context, jobContext) {
+    options.signal?.throwIfAborted();
+    const task = getTask(worker, options);
+    let state = runners.get(worker);
+    if (!state) {
+      state = {
+        runner: new TaskRunner({
+          maxConcurrency: isMobile ? options.maxMobileConcurrency ?? 1 : options.maxConcurrency ?? 3
+        }),
+        requests: 0
+      };
+      runners.set(worker, state);
+    }
+    const runnerState = state;
+    const channel = context.process ? new MessageChannel() : void 0;
+    const callbackController = new AbortController();
+    let channelClosed = false;
+    const abortCallbacks = () => callbackController.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", abortCallbacks, { once: true });
+    const closeChannel = () => {
+      channelClosed = true;
+      options.signal?.removeEventListener("abort", abortCallbacks);
+      callbackController.abort();
+      channel?.port1.close();
+      channel?.port2.close();
+    };
+    if (channel) {
+      channel.port1.onmessage = async ({ data }) => {
+        try {
+          const value = await context.process(
+            data.input,
+            data.options,
+            {
+              signal: callbackController.signal,
+              throwIfAborted: () => callbackController.signal.throwIfAborted()
+            },
+            data.context
+          );
+          if (!channelClosed && !callbackController.signal.aborted)
+            channel.port1.postMessage({ identifier: data.identifier, value }, getTransferList2(value));
+        } catch (error) {
+          if (channelClosed || callbackController.signal.aborted) return;
+          channel.port1.postMessage({
+            identifier: data.identifier,
+            error: {
+              name: error instanceof Error ? error.name : "Error",
+              message: error instanceof Error ? error.message : String(error)
+            }
+          });
+        }
+      };
+      channel.port1.start();
+    }
+    runnerState.requests++;
+    activeRunners.add(runnerState);
+    let released = false;
+    const releaseRunner = () => {
+      if (released) return;
+      released = true;
+      runnerState.requests--;
+      if (!runnerState.requests) activeRunners.delete(runnerState);
+    };
+    let handle;
+    try {
+      handle = await runnerState.runner.initializeTask(
+        task,
+        {
+          context: structuredClone(jobContext),
+          ...channel ? { port: channel.port2 } : {}
+        },
+        // The callback port is setup state, independent of the caller's payload ownership.
+        { ...getControls(options), inputOwnership: "transfer" }
+      );
+    } catch (error) {
+      releaseRunner();
+      closeChannel();
+      throw error;
+    }
+    return {
+      handle,
+      /** Releases the worker and callback channel on success, failure, and early stream return. */
+      async close() {
+        try {
+          await handle.close();
+        } finally {
+          closeChannel();
+          releaseRunner();
+        }
+      }
+    };
+  }
+  function wrapInput(input) {
+    const iterator = Symbol.asyncIterator in input ? input[Symbol.asyncIterator]() : input[Symbol.iterator]();
+    let inputClosed = false;
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (inputClosed) return { done: true, value: void 0 };
+        const next = await iterator.next();
+        if (next.done || inputClosed) {
+          inputClosed = true;
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: { value: next.value } };
+      },
+      async return() {
+        if (!inputClosed) {
+          inputClosed = true;
+          await iterator.return?.();
+        }
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  function createModuleWorker(url) {
+    const resolved = new URL(url, globalThis.document?.baseURI ?? globalThis.location.href);
+    let workerUrl = resolved.href;
+    if (/^https?:$/.test(resolved.protocol) && resolved.origin !== globalThis.location.origin) {
+      let shimUrl = moduleWorkerUrls.get(resolved.href);
+      if (!shimUrl) {
+        shimUrl = URL.createObjectURL(
+          new Blob([`import ${JSON.stringify(resolved.href)};`], { type: "application/javascript" })
+        );
+        moduleWorkerUrls.set(resolved.href, shimUrl);
+      }
+      workerUrl = shimUrl;
+    }
+    return new Worker(workerUrl, { type: "module" });
+  }
+
+  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  async function createWorker2(process2, processInBatches) {
+    if (!await isWorkerThread()) return;
+    await initializeTaskWorker2(createWorkerTask(process2, processInBatches));
+  }
+  function createWorkerTask(process2, processInBatches) {
+    return {
+      id: "loaders.gl",
+      initialize: (state) => state,
+      destroy: (state) => state.port?.close(),
+      process: async ({ value }, options, context) => {
+        if (!process2) throw new Error("Worker does not support atomic processing");
+        return { value: await process2(value, options, createContext(context), context.state.context) };
+      },
+      ...processInBatches ? {
+        processInBatches: async function* (inputs, options, context) {
+          async function* values() {
+            for await (const input of inputs) yield input.value;
+          }
+          for await (const value of processInBatches(
+            values(),
+            options,
+            createContext(context),
+            context.state.context
+          )) {
+            yield { value };
+          }
+        }
+      } : {}
+    };
+  }
+  function createContext(context) {
+    let requestIdentifier = 0;
+    const port = context.state.port;
+    return {
+      signal: context.signal,
+      throwIfAborted: () => context.throwIfAborted(),
+      reportProgress: (progress) => context.reportProgress(normalizeTaskProgress(progress)),
+      process: port ? (input, options = {}, jobContext = {}) => {
+        context.throwIfAborted();
+        const identifier = ++requestIdentifier;
+        return new Promise((resolve, reject) => {
+          const onMessage2 = (event) => {
+            if (event.data.identifier !== identifier) return;
+            cleanup();
+            if (event.data.error) {
+              const error = new Error(event.data.error.message);
+              error.name = event.data.error.name;
+              reject(error);
+            } else resolve(event.data.value);
+          };
+          const onAbort = () => {
+            cleanup();
+            reject(context.signal.reason);
+          };
+          const cleanup = () => {
+            port.removeEventListener("message", onMessage2);
+            context.signal.removeEventListener("abort", onAbort);
+          };
+          port.addEventListener("message", onMessage2);
+          context.signal.addEventListener("abort", onAbort, { once: true });
+          port.start();
+          try {
+            const request = { identifier, input, options, context: jobContext };
+            port.postMessage(request, getTransferList2(request));
+          } catch (error) {
+            cleanup();
+            reject(error);
+          }
+        });
+      } : void 0
+    };
+  }
+
   // ../core/src/worker-utils/lib/library-utils/library-utils.ts
   var loadLibraryPromises = {};
   function extractLoadLibraryOptions(options = {}) {
@@ -2128,15 +3406,15 @@
 
   // ../core/src/loader-utils/lib/worker-loader-utils/encode-with-worker.ts
   function canEncodeWithWorker(writer, options) {
-    if (!WorkerFarm.isSupported()) {
-      return false;
-    }
     const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
     const useWorkers = options?.worker ?? options?.core?.worker;
     if (!isBrowser3 && !nodeWorkers) {
       return false;
     }
-    return Boolean(writer.worker && useWorkers);
+    return canProcessOnWorker2(
+      { ...writer, options: writer.options || {} },
+      { worker: Boolean(useWorkers), _nodeWorkers: Boolean(nodeWorkers) }
+    );
   }
 
   // ../../node_modules/@math.gl/core/dist/types/float16.js
@@ -9497,11 +10775,11 @@ return true;`);
       this._offsets = new OffsetsBufferBuilder(opts.type);
     }
     setValue(index, value) {
-      const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-      const current = pending.get(index);
+      const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+      const current = pending2.get(index);
       current && (this._pendingLength -= current.length);
       this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
-      pending.set(index, value);
+      pending2.set(index, value);
     }
     setValid(index, isValid) {
       if (!super.setValid(index, isValid)) {
@@ -9524,12 +10802,12 @@ return true;`);
       return super.finish();
     }
     _flush() {
-      const pending = this._pending;
+      const pending2 = this._pending;
       const pendingLength = this._pendingLength;
       this._pendingLength = 0;
       this._pending = void 0;
-      if (pending && pending.size > 0) {
-        this._flushPending(pending, pendingLength);
+      if (pending2 && pending2.size > 0) {
+        this._flushPending(pending2, pendingLength);
       }
       return this;
     }
@@ -11939,11 +13217,11 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, toUint8Array(value));
     }
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
       const offsets = this._offsets;
       const data = this._values.reserve(pendingLength).buffer;
       let offset = 0;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (value === void 0) {
           offsets.set(index, 0);
         } else {
@@ -11972,11 +13250,11 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, toUint8Array(value));
     }
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
       const offsets = this._offsets;
       const data = this._values.reserve(pendingLength).buffer;
       let offset = 0;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (value === void 0) {
           offsets.set(index, BigInt(0));
         } else {
@@ -12207,10 +13485,10 @@ return true;`);
       this.type = new List2(new Field2(name, child.type, true));
       return this.numChildren - 1;
     }
-    _flushPending(pending) {
+    _flushPending(pending2) {
       const offsets = this._offsets;
       const [child] = this.children;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (typeof value === "undefined") {
           offsets.set(index, 0);
         } else {
@@ -12239,10 +13517,10 @@ return true;`);
       this.type = new LargeList2(new Field2(name, child.type, true));
       return this.numChildren - 1;
     }
-    _flushPending(pending) {
+    _flushPending(pending2) {
       const offsets = this._offsets;
       const [child] = this.children;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (typeof value === "undefined") {
           offsets.set(index, BigInt(0));
         } else {
@@ -12264,11 +13542,11 @@ return true;`);
     }
     setValue(index, value) {
       const row = value instanceof Map ? value : new Map(Object.entries(value));
-      const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-      const current = pending.get(index);
+      const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+      const current = pending2.get(index);
       current && (this._pendingLength -= current.size);
       this._pendingLength += row.size;
-      pending.set(index, row);
+      pending2.set(index, row);
     }
     addChild(child, name = `${this.numChildren}`) {
       if (this.numChildren > 0) {
@@ -12278,10 +13556,10 @@ return true;`);
       this.type = new Map_(new Field2(name, child.type, true), this.type.keysSorted);
       return this.numChildren - 1;
     }
-    _flushPending(pending) {
+    _flushPending(pending2) {
       const offsets = this._offsets;
       const [child] = this.children;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (value === void 0) {
           offsets.set(index, 0);
         } else {
@@ -12444,7 +13722,7 @@ return true;`);
       return super.setValue(index, encodeUtf8(value));
     }
     // @ts-ignore
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
     }
   };
   Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -12466,7 +13744,7 @@ return true;`);
       return super.setValue(index, encodeUtf8(value));
     }
     // @ts-ignore
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
     }
   };
   LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -17198,7 +18476,7 @@ return true;`);
   }
 
   // src/draco/lib/utils/version.ts
-  var VERSION3 = true ? "5.0.0-beta.2" : "latest";
+  var VERSION3 = true ? "5.0.0-beta.4" : "latest";
 
   // src/draco/draco-format.ts
   var DracoFormat = {
@@ -17265,7 +18543,7 @@ return true;`);
     const normalizedData = normalizeDracoInputBatches(data);
     if (canEncodeWithWorker(DracoWriterWorker, options)) {
       const { onProgress: _onProgress, ...workerOptions } = options;
-      return processOnWorkerInBatches(
+      return processOnWorkerInBatches2(
         DracoWriterWorker,
         normalizedData,
         workerOptions
@@ -17331,7 +18609,7 @@ return true;`);
   }
 
   // src/draco/workers/draco-writer-worker.ts
-  createWorker(
+  createWorker2(
     async (input, options) => (await encodeDraco(input, options)).data,
     encodeDracoInBatchesLocally
   );