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

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.5";
     globalThis._loadersgl_ = globalThis._loadersgl_ || {};
     globalThis._loadersgl_.version ||= version;
     return version;
@@ -42,23 +84,23 @@
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/npm-tag.js
-  var NPM_TAG = "latest";
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/npm-tag.js
+  var NPM_TAG2 = "latest";
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/version.js
+  // ../../node_modules/@math.gl/tasks/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.5";
   }
   var VERSION2 = getVersion2();
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/assert.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js
   function assert2(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/globals.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/globals.js
   var globals2 = {
     self: typeof self !== "undefined" && self,
     window: typeof window !== "undefined" && window,
@@ -77,7 +119,7 @@
   var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-job.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-job.js
   var WorkerJob = class {
     constructor(jobName, workerThread) {
       this.isRunning = true;
@@ -194,7 +236,7 @@
     return error;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js
   var NodeWorker = class {
     /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
     constructor(...arguments_) {
@@ -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
+  // ../../node_modules/@math.gl/tasks/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) {
@@ -250,7 +301,7 @@
 }`;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
@@ -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);
@@ -331,7 +385,7 @@
     return object === null ? {} : clone(object);
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-thread.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-thread.js
   var NOOP = () => {
   };
   var WorkerThread = class {
@@ -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) {
@@ -498,7 +566,7 @@
     }
   };
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-pool.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-pool.js
   var WorkerPool = class {
     /** Snapshot; byte figures describe input buffers, not total heap memory. */
     get stats() {
@@ -1024,7 +1092,7 @@
     }
   };
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-farm.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-farm.js
   var DEFAULT_PROPS = {
     maxQueuedJobs: Infinity,
     maxPendingAdmissions: 128,
@@ -1145,7 +1213,7 @@
     return loadWorkerId;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-body.js
   async function getParentPort() {
     return parentPort;
   }
@@ -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);
       }
@@ -1232,7 +1300,7 @@
     return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js
   var AsyncQueue = class {
     constructor() {
       this._values = [];
@@ -1299,7 +1367,7 @@
     }
   };
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/get-worker-url.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js
   var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
   function getWorkerName(worker) {
     const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
@@ -1313,7 +1381,7 @@
       if (isBrowser2) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
-        const workerSourceDirectory = worker.module === "core" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
+        const workerSourceDirectory = worker.module === "tasks" && 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}`;
       }
@@ -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}`;
@@ -1357,7 +1425,7 @@
     console.warn(`loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`);
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js
   function getWorkerCapabilities() {
     const isolated = typeof globalThis.crossOriginIsolated === "boolean" ? globalThis.crossOriginIsolated : void 0;
     const capabilities = {
@@ -1440,7 +1508,7 @@
     return options;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-input-byte-length.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-input-byte-length.js
   function getInputByteLength(input) {
     const seen = /* @__PURE__ */ new Set();
     let bytes = 0;
@@ -1469,8 +1537,62 @@
     return bytes;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/process-on-worker.js
+  // ../../node_modules/@math.gl/tasks/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/tasks/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);
@@ -1716,12 +1838,12 @@
     return inputOptions;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js
   var requestId = 0;
   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,173 +2039,1881 @@
       /** Flushes final progress and suppresses reports from stale callbacks. */
       finish(discard = false) {
         if (discard)
-          pending = void 0;
+          pending2 = void 0;
         flush();
         finished = true;
       }
     };
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
   var import_meta = {};
   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;
 
-  // ../core/src/worker-utils/lib/library-utils/library-utils.ts
-  var loadLibraryPromises = {};
-  function extractLoadLibraryOptions(options = {}) {
-    const useLocalLibraries = options.useLocalLibraries ?? options.core?.useLocalLibraries;
-    const CDN = getCDNOption(options.CDN, options.core?.CDN);
-    const modules = options.modules;
-    return {
-      ...useLocalLibraries !== void 0 ? { useLocalLibraries } : {},
-      ...CDN !== void 0 ? { CDN } : {},
-      ...modules !== void 0 ? { modules } : {}
-    };
-  }
-  function getCDNOption(cdn, coreCDN) {
-    if (typeof cdn === "string" || cdn === null) {
-      return cdn;
-    }
-    if (typeof coreCDN === "string" || coreCDN === null) {
-      return coreCDN;
+  // ../../node_modules/@math.gl/tasks/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 void 0;
+    return withSignal(promise, signal);
   }
-  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null, moduleLibraryName = null) {
-    let moduleLibraryUrl = libraryUrl;
-    if (moduleName) {
-      const requestedLibraryName = libraryName || libraryUrl;
-      const injectedLibrary = options.modules?.[requestedLibraryName];
-      if (injectedLibrary !== void 0 && typeof injectedLibrary !== "string") {
-        return injectedLibrary;
-      }
-      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
-      const hasLibraryOverride = typeof injectedLibrary === "string";
-      moduleLibraryUrl = moduleLibraryName && (!hasLibraryOverride || typeof options.modules?.[moduleLibraryName] === "string") ? getLibraryUrl(moduleLibraryName, moduleName, options, moduleLibraryName) : libraryUrl;
-    }
-    const cacheKey = getLibraryCacheKey(libraryUrl, moduleLibraryUrl, isWorker);
-    loadLibraryPromises[cacheKey] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    loadLibraryPromises[cacheKey] || loadLibraryFromFile(libraryUrl, moduleLibraryUrl);
-    return await loadLibraryPromises[cacheKey];
+  function isTaskCodeLoaded(task) {
+    return !task.preload || loaded.has(task);
   }
-  function getLibraryCacheKey(libraryUrl, moduleLibraryUrl, worker) {
-    return worker ? JSON.stringify([libraryUrl, moduleLibraryUrl]) : libraryUrl;
+  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);
+      });
+    });
   }
-  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
-    if (options?.core) {
-      throw new Error("loadLibrary: options.core must be pre-normalized");
-    }
-    libraryName = libraryName || library;
-    const modules = options.modules || {};
-    if (typeof modules[libraryName] === "string") {
-      return modules[libraryName];
-    }
-    if (!options.useLocalLibraries && library.startsWith("http")) {
-      return library;
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js
+  var TaskRequestError = class extends Error {
+  };
+  var TaskChannel = class {
+    constructor(options) {
+      this.options = options;
+      this.nextId = 1;
+      this.pending = /* @__PURE__ */ new Map();
+      this.incoming = /* @__PURE__ */ new Map();
+    }
+    /** Send a request without serializing other in-flight requests. */
+    request(operation, value, signal, transfer = []) {
+      if (this.failure)
+        return Promise.reject(this.failure.reason);
+      if (signal?.aborted)
+        return Promise.reject(signal.reason);
+      const id = this.nextId++;
+      return new Promise((resolve, reject) => {
+        const abort = () => {
+          const pending2 = this.pending.get(id);
+          if (!pending2)
+            return;
+          this.pending.delete(id);
+          pending2.cleanup();
+          reject(signal?.reason);
+          this.send({ source: "math.gl/tasks", kind: "cancel", id });
+        };
+        this.pending.set(id, {
+          resolve,
+          reject,
+          cleanup: () => signal?.removeEventListener("abort", abort)
+        });
+        signal?.addEventListener("abort", abort, { once: true });
+        this.send({ source: "math.gl/tasks", kind: "request", id, operation, value }, transfer);
+      });
     }
-    if (!isBrowser) {
-      return `modules/${moduleName}/dist/libs/${libraryName}`;
+    /** Send a one-way notification. */
+    emit(operation, value, transfer = []) {
+      if (this.failure)
+        throw this.failure.reason;
+      this.send({ source: "math.gl/tasks", kind: "event", id: 0, operation, value }, transfer);
     }
-    if (options.CDN) {
-      if (typeof options.CDN !== "string") {
-        throw new Error("loadLibrary: options.CDN must be a string or null");
+    /** Dispatch a transport message; unrelated protocols are ignored. */
+    receive(message) {
+      if (this.failure || message?.source !== "math.gl/tasks")
+        return;
+      if (message.kind === "failure") {
+        const reason = new Error(message.error?.message ?? "Task channel failed");
+        this.close(reason);
+        this.options.onFailure?.(reason);
+      } else if (message.kind === "result" || message.kind === "error") {
+        const pending2 = this.pending.get(message.id);
+        if (!pending2)
+          return;
+        this.pending.delete(message.id);
+        pending2.cleanup();
+        if (message.kind === "result")
+          pending2.resolve(message.value);
+        else {
+          const error = new TaskRequestError(message.error?.message ?? "Task request failed");
+          error.name = message.error?.name ?? "Error";
+          pending2.reject(error);
+        }
+      } else if (message.kind === "cancel") {
+        this.incoming.get(message.id)?.abort(new DOMException("Task request cancelled", "AbortError"));
+      } else if (message.kind === "event") {
+        try {
+          this.options.handleEvent?.(message.operation, message.value);
+        } catch (error) {
+          this.fail(error);
+        }
+      } else if (message.kind === "request") {
+        if (this.incoming.has(message.id)) {
+          this.fail(new Error("Duplicate task request identifier"));
+          return;
+        }
+        const controller = new AbortController();
+        this.incoming.set(message.id, controller);
+        void Promise.resolve().then(() => {
+          controller.signal.throwIfAborted();
+          return this.options.handleRequest(message.operation, message.value, controller.signal);
+        }).then((value) => {
+          if (!controller.signal.aborted && !this.failure) {
+            this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, this.options.getResultTransferList?.(value, message.value));
+          }
+        }).catch((reason) => {
+          if (!controller.signal.aborted && !this.failure) {
+            this.send({
+              source: "math.gl/tasks",
+              kind: "error",
+              id: message.id,
+              error: {
+                name: reason instanceof Error ? reason.name : "Error",
+                message: reason instanceof Error ? reason.message : String(reason)
+              }
+            });
+          }
+        }).finally(() => this.incoming.delete(message.id));
       }
-      assert(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
-    }
-    if (isWorker) {
-      return libraryName.endsWith(".mjs") ? `./libs/${libraryName}` : `../src/libs/${libraryName}`;
-    }
-    return `modules/${moduleName}/src/libs/${libraryName}`;
-  }
-  async function loadLibraryFromFile(libraryUrl, moduleLibraryUrl) {
-    if (libraryUrl.endsWith("wasm")) {
-      return await loadAsArrayBuffer(libraryUrl);
     }
-    if (!isBrowser) {
-      const { requireFromFile } = globalThis.loaders || {};
+    /** Reject all outstanding calls with a common cause and abort incoming callbacks. */
+    close(reason = new Error("Task channel closed")) {
+      if (this.failure)
+        return;
+      this.failure = { reason };
+      for (const pending2 of this.pending.values()) {
+        pending2.cleanup();
+        pending2.reject(reason);
+      }
+      this.pending.clear();
+      for (const controller of this.incoming.values())
+        controller.abort(reason);
+      this.incoming.clear();
+    }
+    send(message, transfer = []) {
+      if (this.failure)
+        return;
       try {
-        const result = await requireFromFile?.(libraryUrl);
-        if (result || !libraryUrl.includes("/dist/libs/")) {
-          return result;
-        }
-        return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
+        this.options.send(message, transfer);
       } catch (error) {
-        if (libraryUrl.includes("/dist/libs/")) {
-          try {
-            return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
-          } catch {
-          }
-        }
-        console.error(error);
-        return null;
+        this.fail(error);
       }
     }
-    if (isWorker) {
-      return loadLibraryInWorker(libraryUrl, moduleLibraryUrl);
-    }
-    const scriptSource = await loadAsText(libraryUrl);
-    return loadLibraryFromString(scriptSource, libraryUrl);
-  }
-  async function loadLibraryInWorker(libraryUrl, moduleLibraryUrl = libraryUrl) {
-    try {
-      importScripts();
-    } catch {
-      const moduleUrl2 = new URL(moduleLibraryUrl, globalThis.location.href).href;
-      const library = await import(
-        /* @vite-ignore */
-        moduleUrl2
-      );
-      return library.default ?? library;
+    /** Invalidate the channel and notify the peer when the transport still works. */
+    fail(reason) {
+      if (this.failure)
+        return;
+      this.close(reason);
+      try {
+        this.options.send({
+          source: "math.gl/tasks",
+          kind: "failure",
+          id: 0,
+          error: {
+            name: reason instanceof Error ? reason.name : "Error",
+            message: reason instanceof Error ? reason.message : String(reason)
+          }
+        }, []);
+      } catch {
+      }
+      this.options.onFailure?.(reason);
     }
-    return importScripts(libraryUrl);
+  };
+
+  // ../../node_modules/@math.gl/tasks/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 loadLibraryFromString(scriptSource, id) {
-    const script = document.createElement("script");
-    script.id = id;
-    try {
-      script.appendChild(document.createTextNode(scriptSource));
-    } catch (_e2) {
-      script.text = scriptSource;
-    }
-    document.body.appendChild(script);
-    return null;
+  function taskContext(state, context = {}) {
+    const signal = context.signal ?? new AbortController().signal;
+    return {
+      state,
+      signal,
+      requestHost: async (operation, payload, controls) => {
+        signal.throwIfAborted();
+        if (!context.requestHost)
+          throw new Error("No host request handler configured");
+        return context.requestHost(operation, payload, controls);
+      },
+      emitHost: (operation, payload) => {
+        signal.throwIfAborted();
+        context.emitHost?.(operation, payload);
+      },
+      throwIfAborted: () => {
+        signal.throwIfAborted();
+        context.throwIfAborted?.();
+      },
+      reportProgress: (progress) => context.reportProgress?.({
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      })
+    };
   }
-  async function loadAsArrayBuffer(url) {
-    const { readFileAsArrayBuffer } = globalThis.loaders || {};
-    if (isBrowser || !readFileAsArrayBuffer || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.arrayBuffer();
+  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 {};
     }
-    try {
-      return await readFileAsArrayBuffer(url);
-    } catch {
-      if (url.includes("/dist/libs/")) {
-        return await readFileAsArrayBuffer(url.replace("/dist/libs/", "/src/libs/"));
+    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);
       }
-      throw new Error(`Failed to load ArrayBuffer from ${url}`);
+      return {};
     }
-  }
-  async function loadAsText(url) {
-    const { readFileAsText } = globalThis.loaders || {};
-    if (isBrowser || !readFileAsText || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.text();
+    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;
     }
-    try {
-      return await readFileAsText(url);
-    } catch {
-      if (url.includes("/dist/libs/")) {
-        return await readFileAsText(url.replace("/dist/libs/", "/src/libs/"));
+    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 channelStream;
+    const channel = new TaskChannel({
+      getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+      send: (message, transfer) => {
+        const snapshot = structuredClone(message, { transfer });
+        void WorkerBody.postMessage("task-channel", snapshot).catch((reason) => channel.fail(reason));
+      },
+      handleRequest: async (operation, value, signal) => {
+        const request = value;
+        const context = {
+          signal,
+          reportProgress: (progress) => channel.emit("task:progress", { id: request.progressId, progress }),
+          requestHost: (operation2, payload, controls = {}) => {
+            const request2 = {
+              operation: operation2,
+              payload: clonePayload(payload, controls.inputOwnership),
+              outputOwnership: controls.outputOwnership ?? "copy"
+            };
+            return channel.request("task:host-request", request2, signal, getTransferList(request2));
+          },
+          emitHost: (operation2, payload) => channel.emit("task:host-event", { operation: operation2, payload, id: request.progressId })
+        };
+        switch (operation) {
+          case "initialize":
+            return runtime.initialize(request.input, context);
+          case "process":
+            return runtime.process(request.input, request.options, context);
+          case "stream-open": {
+            if (channelStream)
+              throw new Error("A task stream is already open");
+            async function* inputs() {
+              while (true) {
+                const result = await channel.request("task:next-input", { outputOwnership: "transfer" }, signal);
+                if (result.done)
+                  return;
+                yield result.value;
+              }
+            }
+            channelStream = runtime.stream(inputs(), request.options, context)[Symbol.asyncIterator]();
+            return {};
+          }
+          case "stream-next":
+            if (!channelStream)
+              throw new Error("No active task stream");
+            return channelStream.next();
+          case "stream-close":
+            try {
+              await channelStream?.return?.();
+            } finally {
+              channelStream = void 0;
+            }
+            return {};
+          case "destroy":
+            return runtime.destroy();
+          default:
+            throw new Error("Unknown task channel operation");
+        }
       }
-      throw new Error(`Failed to load text from ${url}`);
-    }
+    });
+    await WorkerBody.addEventListener((type, payload) => {
+      if (type === "task-channel")
+        channel.receive(payload);
+    });
+    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)
+    };
   }
 
-  // ../core/src/loader-utils/lib/env-utils/globals.ts
-  var globals3 = {
-    self: typeof self !== "undefined" && self,
+  // ../../node_modules/@math.gl/tasks/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/tasks/dist/tasks/task-operation-queue.js
+  var TaskOperationQueue = class {
+    constructor(maxConcurrency) {
+      this.maxConcurrency = maxConcurrency;
+      this.pending = [];
+      this.active = 0;
+      this.exclusive = false;
+      this.closed = false;
+      this.idleWaiters = /* @__PURE__ */ new Set();
+      if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1) {
+        throw new RangeError("maxConcurrency must be a positive safe integer");
+      }
+    }
+    /** Queue an operation; aborting before it starts removes it without running it. */
+    run(mode, operation, signal) {
+      if (this.closed)
+        return Promise.reject(new Error("Task operation queue is closed"));
+      if (mode !== "parallel" && mode !== "exclusive")
+        return Promise.reject(new TypeError("Invalid operation mode"));
+      if (signal?.aborted)
+        return Promise.reject(signal.reason);
+      return new Promise((resolve, reject) => {
+        const onAbort = () => {
+          const index = this.pending.indexOf(entry);
+          if (index >= 0) {
+            this.pending.splice(index, 1);
+            entry.cancel(signal?.reason);
+            this.pump();
+          }
+        };
+        const entry = {
+          mode,
+          cancel: (reason) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(reason);
+          },
+          start: () => {
+            signal?.removeEventListener("abort", onAbort);
+            this.active++;
+            if (mode === "exclusive")
+              this.exclusive = true;
+            void Promise.resolve().then(() => {
+              signal?.throwIfAborted();
+              return operation();
+            }).then(resolve, reject).finally(() => {
+              this.active--;
+              if (mode === "exclusive")
+                this.exclusive = false;
+              this.pump();
+            });
+          }
+        };
+        this.pending.push(entry);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+          onAbort();
+        else
+          this.pump();
+      });
+    }
+    /** Reject queued calls with one cause while allowing active operations to settle. */
+    cancelPending(reason) {
+      this.closed = true;
+      for (const entry of this.pending.splice(0))
+        entry.cancel(reason);
+      this.pump();
+    }
+    /** Stop accepting new work; accepted operations continue to completion. */
+    close() {
+      this.closed = true;
+      return this.whenIdle();
+    }
+    /** Wait until the queue has no running or waiting operations. */
+    whenIdle() {
+      if (!this.active && !this.pending.length)
+        return Promise.resolve();
+      return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    pump() {
+      while (!this.exclusive && this.pending.length && this.active < this.maxConcurrency) {
+        const entry = this.pending[0];
+        if (entry.mode === "exclusive" && this.active)
+          break;
+        this.pending.shift();
+        entry.start();
+        if (entry.mode === "exclusive")
+          break;
+      }
+      if (!this.active && !this.pending.length) {
+        for (const resolve of this.idleWaiters)
+          resolve();
+        this.idleWaiters.clear();
+      }
+    }
+  };
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-worker-channel.js
+  var TaskWorkerChannel = class {
+    constructor(name, target, options) {
+      this.thread = new WorkerThread({
+        name,
+        url: target.url?.toString(),
+        loadWorker: target.create,
+        workerType: "module"
+      });
+      this.channel = new TaskChannel({
+        ...options,
+        send: (message, transfer) => this.thread.postMessage({ source: "loaders.gl/tasks", type: "task-channel", payload: message }, transfer)
+      });
+      this.thread.onMessage = (message) => {
+        if (message?.type === "task-channel")
+          this.channel.receive(message.payload);
+      };
+      this.thread.onError = (reason) => {
+        this.channel.close(reason);
+        options.onFailure?.(reason);
+      };
+    }
+    /** Settle pending calls and terminate the worker without replacing its state. */
+    async destroy(reason) {
+      this.channel.close(reason);
+      await this.thread.destroy();
+    }
+  };
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-runner.js
+  var InitializedTask = class {
+    /** @internal Use TaskRunner.initializeTask. */
+    constructor(task, release, initializationControls) {
+      this.task = task;
+      this.release = release;
+      this.initializationControls = initializationControls;
+      this.nextProgressId = 1;
+      this.progressCallbacks = /* @__PURE__ */ new Map();
+      this.callbackFailures = /* @__PURE__ */ new Map();
+      this.closed = false;
+      this.finalized = false;
+      this.streams = /* @__PURE__ */ new Set();
+      this.invalid = false;
+      this.controller = new AbortController();
+      const controls = initializationControls;
+      this.runtime = new TaskRuntime(task);
+      const concurrency = controls.operationConcurrency ?? 1;
+      const maximum = task.concurrency?.maxConcurrency ?? 1;
+      if (!Number.isSafeInteger(maximum) || maximum < 1 || !Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > maximum) {
+        throw new RangeError("Task concurrency must be between 1 and the task maximum");
+      }
+      this.operationQueue = new TaskOperationQueue(concurrency);
+      this.concurrent = concurrency > 1;
+      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");
+        if (this.concurrent || controls.onRequest || controls.onEvent) {
+          this.workerChannel = new TaskWorkerChannel(task.id, target, {
+            handleRequest: async (operation, payload, signal) => {
+              if (operation === "task:next-input") {
+                if (!this.channelInputs)
+                  throw new Error("No active task stream");
+                return this.channelInputs.next();
+              }
+              if (!controls.onRequest)
+                throw new Error("No host request handler configured");
+              const request = payload;
+              if (operation !== "task:host-request")
+                throw new Error("Unknown host request");
+              return controls.onRequest(request.operation, request.payload, signal);
+            },
+            getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+            handleEvent: (operation, payload) => {
+              const { id } = payload;
+              try {
+                if (operation === "task:progress") {
+                  const event = payload;
+                  (this.progressCallbacks.get(event.id) ?? this.streamProgress)?.(event.progress);
+                } else if (operation === "task:host-event") {
+                  const event = payload;
+                  controls.onEvent?.(event.operation, event.payload);
+                }
+              } catch (reason) {
+                if (this.progressCallbacks.has(id) || this.streamProgressId === id) {
+                  if (!this.callbackFailures.has(id))
+                    this.callbackFailures.set(id, { reason });
+                }
+              }
+            },
+            onFailure: (reason) => {
+              this.invalid = true;
+              this.operationQueue.cancelPending(reason);
+              this.controller.abort(reason);
+            }
+          });
+          return;
+        }
+        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: "tasks",
+          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) {
+      if (this.invalid)
+        return Promise.reject(new Error("Initialized task is invalid; initialize a new instance"));
+      if (this.closed)
+        return Promise.reject(new Error("Initialized task is closed"));
+      const timeout = args[0]?.timeout;
+      if (timeout !== void 0 && (!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 4294967295)) {
+        return Promise.reject(new RangeError("Invalid task timeout"));
+      }
+      const deadline = timeout === void 0 ? void 0 : AbortSignal.timeout(timeout);
+      const signal = deadline && args[0]?.signal ? AbortSignal.any([deadline, args[0].signal]) : deadline ?? args[0]?.signal;
+      const controls = { ...args[0], signal };
+      const mode = this.task.concurrency?.getSchedulingMode?.(input) ?? "exclusive";
+      return this.operationQueue.run(mode, async () => {
+        signal?.throwIfAborted();
+        this.checkCapability("atomic");
+        const invalidate = () => {
+          if (this.concurrent) {
+            this.invalid = true;
+            this.operationQueue.cancelPending(signal?.reason);
+            this.controller.abort(signal?.reason);
+          }
+        };
+        signal?.addEventListener("abort", invalidate, { once: true });
+        try {
+          return await this.invoke("process", input, args[0]?.options ?? {}, controls);
+        } finally {
+          signal?.removeEventListener("abort", invalidate);
+        }
+      }, signal);
+    }
+    /** Independent calls sharing this instance, always serial and in input order. */
+    runTasks(inputs, ...args) {
+      return 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]);
+        }
+      }, args[0]?.signal);
+    }
+    /** One processor invocation for the entire input iterable. */
+    runTaskInBatches(inputs, ...args) {
+      return 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.workerChannel) {
+            self2.channelInputs = prepared()[Symbol.asyncIterator]();
+            self2.streamProgress = controls.onProgress;
+            try {
+              await self2.invoke("stream-open", {}, options, controls);
+              while (true) {
+                const result = await self2.invoke("stream-next", {}, {}, controls);
+                if (result.done)
+                  break;
+                yield result.value;
+              }
+            } finally {
+              try {
+                if (!self2.invalid)
+                  await self2.invoke("stream-close", {}, {}, controls);
+              } finally {
+                await self2.channelInputs.return?.();
+                self2.channelInputs = void 0;
+                self2.streamProgress = void 0;
+                if (self2.streamProgressId !== void 0)
+                  self2.callbackFailures.delete(self2.streamProgressId);
+                self2.streamProgressId = void 0;
+              }
+            }
+          } else 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, self2.runtimeContext(controls))) {
+              controls.signal?.throwIfAborted();
+              yield clonePayload(output, controls.outputOwnership ?? "transfer");
+            }
+          }
+          completed = true;
+        } catch (error) {
+          if (self2.workerChannel) {
+            self2.invalid = true;
+            self2.operationQueue.cancelPending(error);
+            self2.controller.abort(error);
+            await self2.workerChannel.destroy(error);
+          }
+          if (self2.pool) {
+            self2.invalid = true;
+            await self2.pool.destroy(error);
+          }
+          throw error;
+        } finally {
+          if (self2.pool && !completed)
+            self2.invalid = true;
+          if (self2.workerChannel && !completed && !self2.invalid) {
+            const reason = new Error("Worker stream ended before completion");
+            self2.invalid = true;
+            self2.operationQueue.cancelPending(reason);
+            self2.controller.abort(reason);
+            await self2.workerChannel.destroy(reason);
+          }
+        }
+      }, args[0]?.signal);
+    }
+    /** Lifecycle status of this initialized task. */
+    get state() {
+      if (this.invalid)
+        return "invalid";
+      if (this.finalized)
+        return "closed";
+      return this.closed ? "closing" : "ready";
+    }
+    /** Drain accepted work, invoke destroy, and release execution capacity. */
+    close() {
+      if (!this.closing) {
+        this.closed = true;
+        this.closing = (async () => {
+          try {
+            await this.operationQueue.close();
+            if (!this.invalid)
+              await this.invoke("destroy", {}, {});
+            else if (!this.pool && !this.workerChannel)
+              await this.runtime.destroy();
+          } finally {
+            try {
+              await this.pool?.destroy();
+              await this.workerChannel?.destroy();
+            } finally {
+              this.finalized = true;
+              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.operationQueue.cancelPending(reason);
+      this.controller.abort(reason);
+      if (this.workerChannel) {
+        this.invalid = true;
+        await this.workerChannel.destroy(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.workerChannel ? !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.workerChannel) {
+        const progressId = this.nextProgressId++;
+        const request = {
+          input: clonePayload(input, prepared.inputOwnership),
+          options: copiedOptions,
+          outputOwnership: prepared.outputOwnership ?? "transfer",
+          progressId
+        };
+        if (operation === "stream-open")
+          this.streamProgressId = progressId;
+        this.progressCallbacks.set(progressId, prepared.onProgress);
+        let callbackFailure;
+        try {
+          const result2 = await this.workerChannel.channel.request(operation, request, prepared.signal, getTransferList(request));
+          callbackFailure = this.callbackFailures.get(progressId) ?? (operation.startsWith("stream-") && this.streamProgressId !== void 0 ? this.callbackFailures.get(this.streamProgressId) : void 0);
+          if (callbackFailure)
+            throw callbackFailure.reason;
+          return result2;
+        } catch (reason) {
+          if (operation === "process" && !prepared.signal?.aborted && (reason instanceof TaskRequestError || callbackFailure))
+            throw reason;
+          this.invalid = true;
+          this.operationQueue.cancelPending(reason);
+          this.controller.abort(reason);
+          await this.workerChannel.destroy(reason);
+          throw reason;
+        } finally {
+          this.progressCallbacks.delete(progressId);
+          if (this.streamProgressId !== progressId)
+            this.callbackFailures.delete(progressId);
+        }
+      }
+      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 = this.runtimeContext(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");
+    }
+    runtimeContext(prepared) {
+      return {
+        ...localContext(prepared),
+        requestHost: async (operation, payload, controls = {}) => {
+          const signal = prepared.signal ?? this.controller.signal;
+          signal.throwIfAborted();
+          const handler = this.initializationControls.onRequest;
+          if (!handler)
+            throw new Error("No host request handler configured");
+          const result = await handler(operation, clonePayload(payload, controls.inputOwnership), signal);
+          signal.throwIfAborted();
+          return structuredClone(result, {
+            transfer: controls.outputOwnership === "transfer" ? getTransferList(result) : []
+          });
+        },
+        emitHost: (operation, payload) => this.initializationControls.onEvent?.(operation, structuredClone(payload))
+      };
+    }
+    enqueue(operation) {
+      if (this.closed)
+        return Promise.reject(new Error("Initialized task is closed"));
+      return this.operationQueue.run("exclusive", operation);
+    }
+    serialStream(operation, signal) {
+      const waiting = new AbortController();
+      const queueSignal = AbortSignal.any([waiting.signal, this.controller.signal, signal].filter((value) => Boolean(value)));
+      let started = false;
+      const iterator = this.acquireStream(operation, queueSignal, () => {
+        started = true;
+      });
+      const cancelWaiting = () => {
+        if (!started)
+          waiting.abort(new Error("Stream returned before execution"));
+      };
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        next: () => iterator.next(),
+        return: async () => {
+          cancelWaiting();
+          return iterator.return(void 0);
+        },
+        throw: async (reason) => {
+          cancelWaiting();
+          return iterator.throw(reason);
+        }
+      };
+    }
+    async *acquireStream(operation, signal, onStart) {
+      if (this.closed)
+        throw new Error("Initialized task is closed");
+      let acquire;
+      const acquired = new Promise((resolve) => {
+        acquire = resolve;
+      });
+      let release;
+      const held = new Promise((resolve) => {
+        release = resolve;
+      });
+      const lease = this.operationQueue.run("exclusive", async () => {
+        acquire();
+        await held;
+      }, signal);
+      await Promise.race([acquired, lease]);
+      if (signal.aborted) {
+        release();
+        throw signal.reason;
+      }
+      onStart();
+      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/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-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-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 = {}) {
+    const useLocalLibraries = options.useLocalLibraries ?? options.core?.useLocalLibraries;
+    const CDN = getCDNOption(options.CDN, options.core?.CDN);
+    const modules = options.modules;
+    return {
+      ...useLocalLibraries !== void 0 ? { useLocalLibraries } : {},
+      ...CDN !== void 0 ? { CDN } : {},
+      ...modules !== void 0 ? { modules } : {}
+    };
+  }
+  function getCDNOption(cdn, coreCDN) {
+    if (typeof cdn === "string" || cdn === null) {
+      return cdn;
+    }
+    if (typeof coreCDN === "string" || coreCDN === null) {
+      return coreCDN;
+    }
+    return void 0;
+  }
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null, moduleLibraryName = null) {
+    let moduleLibraryUrl = libraryUrl;
+    if (moduleName) {
+      const requestedLibraryName = libraryName || libraryUrl;
+      const injectedLibrary = options.modules?.[requestedLibraryName];
+      if (injectedLibrary !== void 0 && typeof injectedLibrary !== "string") {
+        return injectedLibrary;
+      }
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
+      const hasLibraryOverride = typeof injectedLibrary === "string";
+      moduleLibraryUrl = moduleLibraryName && (!hasLibraryOverride || typeof options.modules?.[moduleLibraryName] === "string") ? getLibraryUrl(moduleLibraryName, moduleName, options, moduleLibraryName) : libraryUrl;
+    }
+    const cacheKey = getLibraryCacheKey(libraryUrl, moduleLibraryUrl, isWorker);
+    loadLibraryPromises[cacheKey] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    loadLibraryPromises[cacheKey] || loadLibraryFromFile(libraryUrl, moduleLibraryUrl);
+    return await loadLibraryPromises[cacheKey];
+  }
+  function getLibraryCacheKey(libraryUrl, moduleLibraryUrl, worker) {
+    return worker ? JSON.stringify([libraryUrl, moduleLibraryUrl]) : libraryUrl;
+  }
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (options?.core) {
+      throw new Error("loadLibrary: options.core must be pre-normalized");
+    }
+    libraryName = libraryName || library;
+    const modules = options.modules || {};
+    if (typeof modules[libraryName] === "string") {
+      return modules[libraryName];
+    }
+    if (!options.useLocalLibraries && library.startsWith("http")) {
+      return library;
+    }
+    if (!isBrowser) {
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
+    }
+    if (options.CDN) {
+      if (typeof options.CDN !== "string") {
+        throw new Error("loadLibrary: options.CDN must be a string or null");
+      }
+      assert(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+    }
+    if (isWorker) {
+      return libraryName.endsWith(".mjs") ? `./libs/${libraryName}` : `../src/libs/${libraryName}`;
+    }
+    return `modules/${moduleName}/src/libs/${libraryName}`;
+  }
+  async function loadLibraryFromFile(libraryUrl, moduleLibraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      return await loadAsArrayBuffer(libraryUrl);
+    }
+    if (!isBrowser) {
+      const { requireFromFile } = globalThis.loaders || {};
+      try {
+        const result = await requireFromFile?.(libraryUrl);
+        if (result || !libraryUrl.includes("/dist/libs/")) {
+          return result;
+        }
+        return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
+      } catch (error) {
+        if (libraryUrl.includes("/dist/libs/")) {
+          try {
+            return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
+          } catch {
+          }
+        }
+        console.error(error);
+        return null;
+      }
+    }
+    if (isWorker) {
+      return loadLibraryInWorker(libraryUrl, moduleLibraryUrl);
+    }
+    const scriptSource = await loadAsText(libraryUrl);
+    return loadLibraryFromString(scriptSource, libraryUrl);
+  }
+  async function loadLibraryInWorker(libraryUrl, moduleLibraryUrl = libraryUrl) {
+    try {
+      importScripts();
+    } catch {
+      const moduleUrl2 = new URL(moduleLibraryUrl, globalThis.location.href).href;
+      const library = await import(
+        /* @vite-ignore */
+        moduleUrl2
+      );
+      return library.default ?? library;
+    }
+    return importScripts(libraryUrl);
+  }
+  function loadLibraryFromString(scriptSource, id) {
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (_e2) {
+      script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+  }
+  async function loadAsArrayBuffer(url) {
+    const { readFileAsArrayBuffer } = globalThis.loaders || {};
+    if (isBrowser || !readFileAsArrayBuffer || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
+    }
+    try {
+      return await readFileAsArrayBuffer(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsArrayBuffer(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load ArrayBuffer from ${url}`);
+    }
+  }
+  async function loadAsText(url) {
+    const { readFileAsText } = globalThis.loaders || {};
+    if (isBrowser || !readFileAsText || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
+    }
+    try {
+      return await readFileAsText(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsText(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load text from ${url}`);
+    }
+  }
+
+  // ../core/src/loader-utils/lib/env-utils/globals.ts
+  var globals3 = {
+    self: typeof self !== "undefined" && self,
     window: typeof window !== "undefined" && window,
     global: typeof global !== "undefined" && global,
     document: typeof document !== "undefined" && document
@@ -2128,15 +3961,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 +11330,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 +11357,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 +13772,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 +13805,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 +14040,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 +14072,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 +14097,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 +14111,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 +14277,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 +14299,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 +19031,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.5" : "latest";
 
   // src/draco/draco-format.ts
   var DracoFormat = {
@@ -17265,7 +19098,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 +19164,7 @@ return true;`);
   }
 
   // src/draco/workers/draco-writer-worker.ts
-  createWorker(
+  createWorker2(
     async (input, options) => (await encodeDraco(input, options)).data,
     encodeDracoInBatchesLocally
   );