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

package/dist/draco-writer-worker-node.cjs

@@ -7580,6 +7580,48 @@ var init_dist = __esm({
   }
 });
 
+// ../core/src/worker-utils/lib/node/worker_threads.ts
+var worker_threads_exports = {};
+__export(worker_threads_exports, {
+  BroadcastChannel: () => import_worker_threads4.BroadcastChannel,
+  MessageChannel: () => import_worker_threads4.MessageChannel,
+  MessagePort: () => import_worker_threads4.MessagePort,
+  NodeWorker: () => NodeWorker2,
+  SHARE_ENV: () => import_worker_threads4.SHARE_ENV,
+  Worker: () => import_worker_threads4.Worker,
+  getEnvironmentData: () => import_worker_threads4.getEnvironmentData,
+  isInternalThread: () => isInternalThread2,
+  isMainThread: () => import_worker_threads4.isMainThread,
+  isMarkedAsUntransferable: () => import_worker_threads4.isMarkedAsUntransferable,
+  locks: () => locks2,
+  markAsUncloneable: () => import_worker_threads4.markAsUncloneable,
+  markAsUntransferable: () => import_worker_threads4.markAsUntransferable,
+  moveMessagePortToContext: () => import_worker_threads4.moveMessagePortToContext,
+  parentPort: () => parentPort2,
+  postMessageToThread: () => import_worker_threads4.postMessageToThread,
+  receiveMessageOnPort: () => import_worker_threads4.receiveMessageOnPort,
+  resourceLimits: () => import_worker_threads4.resourceLimits,
+  setEnvironmentData: () => import_worker_threads4.setEnvironmentData,
+  structuredClone: () => structuredClone3,
+  threadId: () => import_worker_threads4.threadId,
+  threadName: () => threadName2,
+  workerData: () => import_worker_threads4.workerData
+});
+var WorkerThreads, import_worker_threads4, parentPort2, NodeWorker2, isInternalThread2, threadName2, locks2, structuredClone3;
+var init_worker_threads = __esm({
+  "../core/src/worker-utils/lib/node/worker_threads.ts"() {
+    "use strict";
+    WorkerThreads = __toESM(require("worker_threads"), 1);
+    import_worker_threads4 = require("worker_threads");
+    parentPort2 = WorkerThreads == null ? void 0 : WorkerThreads.parentPort;
+    NodeWorker2 = WorkerThreads.Worker;
+    isInternalThread2 = WorkerThreads.isInternalThread;
+    threadName2 = WorkerThreads.threadName;
+    locks2 = WorkerThreads.locks;
+    structuredClone3 = WorkerThreads.structuredClone;
+  }
+});
+
 // ../../node_modules/flatbuffers/js/constants.js
 var require_constants2 = __commonJS({
   "../../node_modules/flatbuffers/js/constants.js"(exports2) {
@@ -10594,9 +10636,15 @@ globalThis.loaders.readFileAsText = readFileAsText;
 globalThis.loaders.requireFromFile = requireFromFile;
 globalThis.loaders.requireFromString = requireFromString;
 
+// ../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 version2 = false ? NPM_TAG : "5.0.0-beta.2";
+  const version2 = false ? NPM_TAG : "5.0.0-beta.5";
   globalThis._loadersgl_ = globalThis._loadersgl_ || {};
   globalThis._loadersgl_.version ||= version2;
   return version2;
@@ -10630,23 +10678,23 @@ var isMobile = typeof window !== "undefined" && typeof window.orientation !== "u
 var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion2 = 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,
@@ -10665,7 +10713,7 @@ var isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "
 var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion3 = 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;
@@ -10785,17 +10833,27 @@ function createAbortError(message) {
   return error;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads.js
 var import_worker_threads = require("worker_threads");
 var parentPort = import_worker_threads.parentPort;
 var NodeWorker = import_worker_threads.Worker;
 
-// ../../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) {
+  var _a5, _b2, _c2;
   assert2(props.source && !props.url || !props.source && props.url);
-  if (props.url && props.workerType === "module")
+  if (props.url && props.workerType === "module") {
+    const baseUrl = ((_a5 = globalThis.document) == null ? void 0 : _a5.baseURI) ?? ((_b2 = globalThis.location) == null ? void 0 : _b2.href);
+    if (!baseUrl)
+      return props.url;
+    const resolved = new URL(props.url, baseUrl);
+    const origin = (_c2 = globalThis.location) == null ? void 0 : _c2.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) {
@@ -10830,7 +10888,7 @@ function buildScriptSource(workerUrl) {
 }`;
 }
 
-// ../../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(object2, recursive = true, transfers) {
   const transfersSet = transfers || /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -10843,6 +10901,9 @@ function getTransferList(object2, recursive = true, transfers) {
     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);
@@ -10911,7 +10972,7 @@ function getTransferListForWriter(object2) {
   return object2 === null ? {} : clone2(object2);
 }
 
-// ../../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 {
@@ -10947,7 +11008,7 @@ var WorkerThread = class {
     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;
   }
@@ -10998,9 +11059,9 @@ var WorkerThread = class {
     var _a5;
     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) {
@@ -11014,8 +11075,22 @@ var WorkerThread = class {
       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) {
@@ -11079,7 +11154,7 @@ var WorkerThread = class {
   }
 };
 
-// ../../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() {
@@ -11609,7 +11684,7 @@ var WorkerPool = class {
   }
 };
 
-// ../../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,
@@ -11730,7 +11805,7 @@ function getLoadWorkerId(loadWorker) {
   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;
 }
@@ -11746,16 +11821,16 @@ var WorkerBody = class {
    */
   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;
       }
@@ -11773,9 +11848,9 @@ var WorkerBody = class {
       };
       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);
     }
@@ -11786,9 +11861,9 @@ var WorkerBody = class {
     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);
     }
@@ -11798,12 +11873,12 @@ var WorkerBody = class {
    * @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);
     }
@@ -11817,7 +11892,7 @@ function getWorkerMessageData(message) {
   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 = [];
@@ -11884,7 +11959,7 @@ var AsyncQueue = class {
   }
 };
 
-// ../../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})` : "";
@@ -11899,7 +11974,7 @@ function getCustomWorkerURL(worker, options = {}) {
     if (isBrowser3) {
       url = `modules/${worker.module}/dist/${workerFile}`;
     } else {
-      const workerSourceDirectory = worker.module === "core" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
+      const workerSourceDirectory = worker.module === "tasks" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
       const workerSourceNode = worker.workerSourceNode || `${workerSourceDirectory}/${worker.id}-worker-node.ts`;
       url = `modules/${worker.module}/src/${workerSourceNode}`;
     }
@@ -11921,7 +11996,7 @@ function getDefaultWorkerURL(worker, warn = false) {
   const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
   let version2 = worker.version;
   if (version2 === "latest") {
-    version2 = NPM_TAG;
+    version2 = NPM_TAG2;
   }
   const versionTag = version2 ? `@${version2}` : "";
   const packageName = worker.packageName || `@loaders.gl/${worker.module}`;
@@ -11943,7 +12018,7 @@ function warnIfUsingNpmTagFallback(worker, url) {
   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 = {
@@ -12026,7 +12101,7 @@ function prepareSharedState(options) {
   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;
@@ -12055,8 +12130,63 @@ function getInputByteLength(input) {
   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 = {}) {
+  var _a5;
+  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 (((_a5 = options.signal) == null ? void 0 : _a5.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);
@@ -12304,12 +12434,12 @@ function budgetOptions(options) {
   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;
   }
@@ -12317,7 +12447,7 @@ async function createWorker(process2, processInBatches) {
     process: processOnMainThread
   };
   WorkerBody.onmessage = async (type, payload) => {
-    var _a5;
+    var _a5, _b2, _c2, _d2, _e2;
     if (type === "cancel") {
       activeController == null ? void 0 : activeController.abort();
       activeInputBatches == null ? void 0 : activeInputBatches.close();
@@ -12351,10 +12481,12 @@ async function createWorker(process2, processInBatches) {
       }
       switch (type) {
         case "preload":
+          await (preload == null ? void 0 : preload());
           WorkerBody.postMessage("done", {});
           break;
         case "process":
           throwIfAborted3();
+          validateOutputOwnership((_b2 = payload.options) == null ? void 0 : _b2["outputOwnership"]);
           if (!process2) {
             throw new Error("Worker does not support atomic processing");
           }
@@ -12364,10 +12496,11 @@ async function createWorker(process2, processInBatches) {
           await WorkerBody.postMessage("done", {
             result,
             executionMs: performance.now() - startedAt
-          });
+          }, ((_c2 = payload.options) == null ? void 0 : _c2["outputOwnership"]) === "copy");
           break;
         case "process-in-batches":
           throwIfAborted3();
+          validateOutputOwnership((_d2 = payload.options) == null ? void 0 : _d2["outputOwnership"]);
           if (!processInBatches) {
             throw new Error("Worker does not support batched processing");
           }
@@ -12379,7 +12512,7 @@ async function createWorker(process2, processInBatches) {
             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 }, ((_e2 = payload.options) == null ? void 0 : _e2["outputOwnership"]) === "copy");
               await outputAcknowledgements.next();
             }
             throwIfAborted3();
@@ -12477,14 +12610,14 @@ function processOnMainThread(arrayBuffer2, options = {}, jobContext = {}) {
   });
 }
 function createProgressReporter() {
-  let pending;
+  let pending2;
   let finished2 = 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 {
@@ -12492,9 +12625,9 @@ function createProgressReporter() {
     report(progress) {
       if (finished2)
         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);
@@ -12503,172 +12636,1942 @@ function createProgressReporter() {
     /** Flushes final progress and suppresses reports from stale callbacks. */
     finish(discard = false) {
       if (discard)
-        pending = void 0;
+        pending2 = void 0;
       flush();
       finished2 = true;
     }
   };
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
 var import_meta3 = {};
 var path3 = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
 var moduleUrl = path3 ? `file://${path3.startsWith("/") ? "" : "/"}${encodeURI(path3).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta3.url;
 
-// ../core/src/worker-utils/lib/library-utils/library-utils.ts
-var loadLibraryPromises = {};
-function extractLoadLibraryOptions(options = {}) {
-  var _a5, _b2;
-  const useLocalLibraries = options.useLocalLibraries ?? ((_a5 = options.core) == null ? void 0 : _a5.useLocalLibraries);
-  const CDN = getCDNOption(options.CDN, (_b2 = options.core) == null ? void 0 : _b2.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) {
-  var _a5, _b2;
-  let moduleLibraryUrl = libraryUrl;
-  if (moduleName) {
-    const requestedLibraryName = libraryName || libraryUrl;
-    const injectedLibrary = (_a5 = options.modules) == null ? void 0 : _a5[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 ((_b2 = options.modules) == null ? void 0 : _b2[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 == null ? void 0 : 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 == null ? void 0 : 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 == null ? void 0 : signal.reason);
+        this.send({ source: "math.gl/tasks", kind: "cancel", id });
+      };
+      this.pending.set(id, {
+        resolve,
+        reject,
+        cleanup: () => signal == null ? void 0 : signal.removeEventListener("abort", abort)
+      });
+      signal == null ? void 0 : signal.addEventListener("abort", abort, { once: true });
+      this.send({ source: "math.gl/tasks", kind: "request", id, operation, value }, transfer);
+    });
   }
-  if (!isBrowser2) {
-    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) {
+    var _a5, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
+    if (this.failure || (message == null ? void 0 : message.source) !== "math.gl/tasks")
+      return;
+    if (message.kind === "failure") {
+      const reason = new Error(((_a5 = message.error) == null ? void 0 : _a5.message) ?? "Task channel failed");
+      this.close(reason);
+      (_c2 = (_b2 = this.options).onFailure) == null ? void 0 : _c2.call(_b2, 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(((_d2 = message.error) == null ? void 0 : _d2.message) ?? "Task request failed");
+        error.name = ((_e2 = message.error) == null ? void 0 : _e2.name) ?? "Error";
+        pending2.reject(error);
+      }
+    } else if (message.kind === "cancel") {
+      (_f2 = this.incoming.get(message.id)) == null ? void 0 : _f2.abort(new DOMException("Task request cancelled", "AbortError"));
+    } else if (message.kind === "event") {
+      try {
+        (_h2 = (_g2 = this.options).handleEvent) == null ? void 0 : _h2.call(_g2, 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) => {
+        var _a6, _b3;
+        if (!controller.signal.aborted && !this.failure) {
+          this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, (_b3 = (_a6 = this.options).getResultTransferList) == null ? void 0 : _b3.call(_a6, 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 (!isBrowser2) {
-    const { requireFromFile: requireFromFile2 } = 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 (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl));
-      if (result || !libraryUrl.includes("/dist/libs/")) {
-        return result;
-      }
-      return await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl.replace("/dist/libs/", "/src/libs/")));
+      this.options.send(message, transfer);
     } catch (error) {
-      if (libraryUrl.includes("/dist/libs/")) {
-        try {
-          return await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl.replace("/dist/libs/", "/src/libs/")));
-        } catch {
-        }
-      }
-      console.error(error);
-      return null;
+      this.fail(error);
     }
   }
-  if (isWorker) {
-    return loadLibraryInWorker(libraryUrl, moduleLibraryUrl);
+  /** Invalidate the channel and notify the peer when the transport still works. */
+  fail(reason) {
+    var _a5, _b2;
+    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 {
+    }
+    (_b2 = (_a5 = this.options).onFailure) == null ? void 0 : _b2.call(_a5, reason);
   }
-  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;
+};
+
+// ../../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");
   }
-  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;
+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 : []
+  });
 }
-async function loadAsArrayBuffer(url) {
-  const { readFileAsArrayBuffer: readFileAsArrayBuffer2 } = globalThis.loaders || {};
-  if (isBrowser2 || !readFileAsArrayBuffer2 || url.startsWith("http")) {
-    const response = await fetch(url);
-    return await response.arrayBuffer();
-  }
-  try {
-    return await readFileAsArrayBuffer2(url);
-  } catch {
-    if (url.includes("/dist/libs/")) {
-      return await readFileAsArrayBuffer2(url.replace("/dist/libs/", "/src/libs/"));
+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) => {
+      var _a5;
+      signal.throwIfAborted();
+      (_a5 = context.emitHost) == null ? void 0 : _a5.call(context, operation, payload);
+    },
+    throwIfAborted: () => {
+      var _a5;
+      signal.throwIfAborted();
+      (_a5 = context.throwIfAborted) == null ? void 0 : _a5.call(context);
+    },
+    reportProgress: (progress) => {
+      var _a5;
+      return (_a5 = context.reportProgress) == null ? void 0 : _a5.call(context, {
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      });
     }
-    throw new Error(`Failed to load ArrayBuffer from ${url}`);
-  }
+  };
 }
-async function loadAsText(url) {
-  const { readFileAsText: readFileAsText2 } = globalThis.loaders || {};
-  if (isBrowser2 || !readFileAsText2 || url.startsWith("http")) {
-    const response = await fetch(url);
-    return await response.text();
+var TaskRuntime = class {
+  constructor(task) {
+    this.task = task;
+    this.initialized = false;
+  }
+  async initialize(input, context = {}) {
+    var _a5, _b2, _c2;
+    if (this.initialized)
+      throw new Error("Task is already initialized");
+    assertPayload(input);
+    await preloadTaskCode(this.task, context.signal);
+    (_a5 = context.signal) == null ? void 0 : _a5.throwIfAborted();
+    this.state = await ((_c2 = (_b2 = this.task).initialize) == null ? void 0 : _c2.call(_b2, input, taskContext(void 0, context)));
+    this.initialized = true;
+    return {};
   }
-  try {
-    return await readFileAsText2(url);
-  } catch {
-    if (url.includes("/dist/libs/")) {
-      return await readFileAsText2(url.replace("/dist/libs/", "/src/libs/"));
+  async destroy() {
+    var _a5, _b2;
+    if (this.initialized) {
+      this.initialized = false;
+      const state = this.state;
+      this.state = void 0;
+      if (this.task.initialize)
+        await ((_b2 = (_a5 = this.task).destroy) == null ? void 0 : _b2.call(_a5, state));
     }
-    throw new Error(`Failed to load text from ${url}`);
+    return {};
+  }
+  async process(input, options, context = {}) {
+    if (!this.initialized)
+      throw new Error("Task is not initialized");
+    if (!this.task.process)
+      throw new Error("Task has no atomic processor");
+    assertPayload(input);
+    const result = await this.task.process(input, options, taskContext(this.state, context));
+    assertPayload(result);
+    return result;
   }
+  async *stream(inputs, options, context = {}) {
+    if (!this.initialized)
+      throw new Error("Task is not initialized");
+    if (!this.task.processInBatches)
+      throw new Error("Task has no streaming processor");
+    for await (const output of this.task.processInBatches(inputs, options, taskContext(this.state, context))) {
+      assertPayload(output);
+      yield output;
+    }
+  }
+};
+async function initializeTaskWorker(task) {
+  if (!await WorkerBody.inWorkerThread())
+    throw new Error("initializeTaskWorker must run inside a worker");
+  if (installed)
+    throw new Error("A task is already installed in this worker");
+  installed = true;
+  const runtime = new TaskRuntime(task);
+  let 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) => {
+      var _a5;
+      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 ((_a5 = channelStream == null ? void 0 : channelStream.return) == null ? void 0 : _a5.call(channelStream));
+          } finally {
+            channelStream = void 0;
+          }
+          return {};
+        case "destroy":
+          return runtime.destroy();
+        default:
+          throw new Error("Unknown task channel operation");
+      }
+    }
+  });
+  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) => {
+      var _a5;
+      return (_a5 = controls.onProgress) == null ? void 0 : _a5.call(controls, progress);
+    }
+  };
+}
+
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-sync.js
+function runTaskSync(task, input, request = {}) {
+  var _a5, _b2;
+  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 metadata2 = new Set(getTransferList(options));
+    if (getTransferList(input).some((buffer2) => metadata2.has(buffer2)))
+      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 = (_a5 = task.initialize) == null ? void 0 : _a5.call(task, initialization, context);
+    if (isThenable(state)) {
+      void Promise.resolve(state).then((value) => {
+        var _a6;
+        return (_a6 = task.destroy) == null ? void 0 : _a6.call(task, 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(() => {
+        var _a6;
+        if (task.initialize)
+          return (_a6 = task.destroy) == null ? void 0 : _a6.call(task, 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 = (_b2 = task.destroy) == null ? void 0 : _b2.call(task, 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 == null ? void 0 : signal.aborted)
+      return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        const index2 = this.pending.indexOf(entry);
+        if (index2 >= 0) {
+          this.pending.splice(index2, 1);
+          entry.cancel(signal == null ? void 0 : signal.reason);
+          this.pump();
+        }
+      };
+      const entry = {
+        mode,
+        cancel: (reason) => {
+          signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+          reject(reason);
+        },
+        start: () => {
+          signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+          this.active++;
+          if (mode === "exclusive")
+            this.exclusive = true;
+          void Promise.resolve().then(() => {
+            signal == null ? void 0 : signal.throwIfAborted();
+            return operation();
+          }).then(resolve, reject).finally(() => {
+            this.active--;
+            if (mode === "exclusive")
+              this.exclusive = false;
+            this.pump();
+          });
+        }
+      };
+      this.pending.push(entry);
+      signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+      if (signal == null ? void 0 : 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) {
+    var _a5;
+    this.thread = new WorkerThread({
+      name,
+      url: (_a5 = target.url) == null ? void 0 : _a5.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 == null ? void 0 : message.type) === "task-channel")
+        this.channel.receive(message.payload);
+    };
+    this.thread.onError = (reason) => {
+      var _a6;
+      this.channel.close(reason);
+      (_a6 = options.onFailure) == null ? void 0 : _a6.call(options, 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) {
+    var _a5, _b2, _c2;
+    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 concurrency2 = controls.operationConcurrency ?? 1;
+    const maximum = ((_a5 = task.concurrency) == null ? void 0 : _a5.maxConcurrency) ?? 1;
+    if (!Number.isSafeInteger(maximum) || maximum < 1 || !Number.isSafeInteger(concurrency2) || concurrency2 < 1 || concurrency2 > maximum) {
+      throw new RangeError("Task concurrency must be between 1 and the task maximum");
+    }
+    this.operationQueue = new TaskOperationQueue(concurrency2);
+    this.concurrent = concurrency2 > 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) => {
+            var _a6, _b3;
+            const { id } = payload;
+            try {
+              if (operation === "task:progress") {
+                const event = payload;
+                (_a6 = this.progressCallbacks.get(event.id) ?? this.streamProgress) == null ? void 0 : _a6(event.progress);
+              } else if (operation === "task:host-event") {
+                const event = payload;
+                (_b3 = controls.onEvent) == null ? void 0 : _b3.call(controls, 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: (_b2 = target.url) == null ? void 0 : _b2.toString(),
+        loadWorker: target.create,
+        workerType: "module",
+        maxConcurrency: 1,
+        maxMobileConcurrency: 1
+      });
+      this.descriptor = {
+        id: task.id,
+        name: task.id,
+        module: "tasks",
+        version: "prototype",
+        options: {},
+        worker: ((_c2 = target.url) == null ? void 0 : _c2.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) {
+    var _a5, _b2, _c2, _d2, _e2;
+    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 timeout2 = (_a5 = args[0]) == null ? void 0 : _a5.timeout;
+    if (timeout2 !== void 0 && (!Number.isSafeInteger(timeout2) || timeout2 < 0 || timeout2 > 4294967295)) {
+      return Promise.reject(new RangeError("Invalid task timeout"));
+    }
+    const deadline = timeout2 === void 0 ? void 0 : AbortSignal.timeout(timeout2);
+    const signal = deadline && ((_b2 = args[0]) == null ? void 0 : _b2.signal) ? AbortSignal.any([deadline, args[0].signal]) : deadline ?? ((_c2 = args[0]) == null ? void 0 : _c2.signal);
+    const controls = { ...args[0], signal };
+    const mode = ((_e2 = (_d2 = this.task.concurrency) == null ? void 0 : _d2.getSchedulingMode) == null ? void 0 : _e2.call(_d2, input)) ?? "exclusive";
+    return this.operationQueue.run(mode, async () => {
+      var _a6;
+      signal == null ? void 0 : signal.throwIfAborted();
+      this.checkCapability("atomic");
+      const invalidate = () => {
+        if (this.concurrent) {
+          this.invalid = true;
+          this.operationQueue.cancelPending(signal == null ? void 0 : signal.reason);
+          this.controller.abort(signal == null ? void 0 : signal.reason);
+        }
+      };
+      signal == null ? void 0 : signal.addEventListener("abort", invalidate, { once: true });
+      try {
+        return await this.invoke("process", input, ((_a6 = args[0]) == null ? void 0 : _a6.options) ?? {}, controls);
+      } finally {
+        signal == null ? void 0 : signal.removeEventListener("abort", invalidate);
+      }
+    }, signal);
+  }
+  /** Independent calls sharing this instance, always serial and in input order. */
+  runTasks(inputs, ...args) {
+    var _a5;
+    return this.serialStream(async function* (self2) {
+      var _a6;
+      self2.checkCapability("atomic");
+      for await (const input of asAsync(inputs, self2.controls(args[0]).signal)) {
+        yield await self2.invoke("process", input, ((_a6 = args[0]) == null ? void 0 : _a6.options) ?? {}, args[0]);
+      }
+    }, (_a5 = args[0]) == null ? void 0 : _a5.signal);
+  }
+  /** One processor invocation for the entire input iterable. */
+  runTaskInBatches(inputs, ...args) {
+    var _a5;
+    return this.serialStream(async function* (self2) {
+      var _a6, _b2, _c2, _d2;
+      self2.checkCapability("streaming");
+      const controls = self2.controls(args[0]);
+      const options = clonePayload(((_a6 = args[0]) == null ? void 0 : _a6.options) ?? {});
+      async function* prepared() {
+        var _a7, _b3;
+        for await (const input of asAsync(inputs, controls.signal)) {
+          (_a7 = controls.signal) == null ? void 0 : _a7.throwIfAborted();
+          assertNoTransferAlias(input, ((_b3 = args[0]) == null ? void 0 : _b3.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 ((_c2 = (_b2 = self2.channelInputs).return) == null ? void 0 : _c2.call(_b2));
+              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))) {
+            (_d2 = controls.signal) == null ? void 0 : _d2.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);
+        }
+      }
+    }, (_a5 = args[0]) == null ? void 0 : _a5.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 () => {
+        var _a5, _b2;
+        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 ((_a5 = this.pool) == null ? void 0 : _a5.destroy());
+            await ((_b2 = this.workerChannel) == null ? void 0 : _b2.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) {
+    var _a5;
+    if (this.pool || this.workerChannel ? !((_a5 = this.task.worker) == null ? void 0 : _a5.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 = {}) {
+    var _a5, _b2, _c2, _d2;
+    if (this.invalid)
+      throw new Error("Initialized task is invalid; initialize a new instance");
+    const prepared = operation === "destroy" ? {} : this.controls(controls);
+    (_a5 = prepared.signal) == null ? void 0 : _a5.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" && !((_b2 = prepared.signal) == null ? void 0 : _b2.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);
+      (_c2 = prepared.signal) == null ? void 0 : _c2.throwIfAborted();
+      return result2;
+    }
+    const result = await this.runtime.process(copied, copiedOptions, context);
+    (_d2 = prepared.signal) == null ? void 0 : _d2.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) => {
+        var _a5, _b2;
+        return (_b2 = (_a5 = this.initializationControls).onEvent) == null ? void 0 : _b2.call(_a5, 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 () => {
+        var _a5;
+        try {
+          await ((_a5 = iterator.return) == null ? void 0 : _a5.call(iterator));
+        } 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) {
+    var _a5;
+    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 concurrency2 = request.concurrency ?? 1;
+    if (!Number.isSafeInteger(concurrency2) || concurrency2 < 1 || concurrency2 > 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 finished2 = false;
+    let reading;
+    try {
+      while (!finished2 || pending2.length) {
+        signal.throwIfAborted();
+        if (!finished2 && !reading && pending2.length < concurrency2) {
+          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) {
+          finished2 = 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 (!finished2)
+          await ((_a5 = iterator.return) == null ? void 0 : _a5.call(iterator));
+      } 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 == null ? void 0 : 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) {
+    var _a5;
+    if (this.closed)
+      throw new Error("Task runner is closed");
+    (_a5 = controls.signal) == null ? void 0 : _a5.throwIfAborted();
+    if (this.count >= this.maxConcurrency) {
+      await new Promise((resolve, reject) => {
+        var _a6, _b2;
+        const waiter = {
+          resolve: () => {
+            cleanup();
+            resolve();
+          },
+          reject: (error) => {
+            cleanup();
+            reject(error);
+          }
+        };
+        const abort = () => {
+          var _a7;
+          this.waiters = this.waiters.filter((item) => item !== waiter);
+          waiter.reject((_a7 = controls.signal) == null ? void 0 : _a7.reason);
+        };
+        const cleanup = () => {
+          var _a7;
+          return (_a7 = controls.signal) == null ? void 0 : _a7.removeEventListener("abort", abort);
+        };
+        this.waiters.push(waiter);
+        (_a6 = controls.signal) == null ? void 0 : _a6.addEventListener("abort", abort, { once: true });
+        if ((_b2 = controls.signal) == null ? void 0 : _b2.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) {
+  var _a5, _b2;
+  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 == null ? void 0 : signal.removeEventListener("abort", abort);
+        const abort = () => {
+          cleanup();
+          reject(signal == null ? void 0 : signal.reason);
+        };
+        signal == null ? void 0 : signal.addEventListener("abort", abort, { once: true });
+        if (signal == null ? void 0 : 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((_a5 = iterator.return) == null ? void 0 : _a5.call(iterator)).catch(() => {
+          });
+        } catch {
+        }
+      } else {
+        await ((_b2 = iterator.return) == null ? void 0 : _b2.call(iterator));
+      }
+    }
+  }
+}
+function assertNoTransferAlias(input, options, ownership) {
+  if (ownership === "transfer") {
+    const metadata2 = new Set(getTransferList(options));
+    if (getTransferList(input).some((buffer2) => metadata2.has(buffer2))) {
+      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 = {}) {
+  var _a5, _b2;
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let url = getConfiguredWorkerURL2(worker, options);
+  const workerType = options._workerType || ((_a5 = options == null ? void 0 : options.core) == null ? void 0 : _a5._workerType);
+  if (!url && workerType === "test") {
+    if (isBrowser2) {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    } else {
+      const workerSourceDirectory = worker.module === "core" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.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 = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version2 = worker.version;
+  if (version2 === "latest") {
+    version2 = NPM_TAG;
+  }
+  const versionTag = version2 ? `@${version2}` : "";
+  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() {
+  var _a5;
+  if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+    return true;
+  if (typeof process !== "undefined" && ((_a5 = process.versions) == null ? void 0 : _a5.node)) {
+    const { isMainThread: isMainThread2 } = await Promise.resolve().then(() => (init_worker_threads(), worker_threads_exports));
+    return !isMainThread2;
+  }
+  return false;
+}
+var initializeTaskWorker2 = initializeTaskWorker;
+
+// ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+function getTransferList2(object2, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object2) {
+  } else if (isTransferable2(object2)) {
+    transfersSet.add(object2);
+  } else if (isTransferable2(object2.buffer)) {
+    transfersSet.add(object2.buffer);
+  } else if (ArrayBuffer.isView(object2)) {
+  } else if (recursive && typeof object2 === "object") {
+    for (const key in object2) {
+      getTransferList2(object2[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable2(object2) {
+  if (!object2) {
+    return false;
+  }
+  if (object2 instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object2 instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object2 instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object2 instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+function getTransferListForWriter2(object2) {
+  if (object2 === null) {
+    return {};
+  }
+  const clone2 = Object.assign({}, object2);
+  Object.keys(clone2).forEach((key) => {
+    if (object2[key] !== null && typeof object2[key] === "object" && !ArrayBuffer.isView(object2[key]) && !(object2[key] instanceof Array)) {
+      clone2[key] = getTransferListForWriter2(object2[key]);
+    } else if (typeof clone2[key] === "function" || clone2[key] instanceof RegExp) {
+      clone2[key] = {};
+    } else {
+      clone2[key] = object2[key];
+    }
+  });
+  return clone2;
+}
+
+// ../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 = isBrowser2 ? 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 = {}) {
+  var _a5;
+  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 = (_a5 = taskInput.return) == null ? void 0 : _a5.call(taskInput);
+    void (closingInput == null ? void 0 : closingInput.catch(() => {
+    }));
+    await (session == null ? void 0 : session.close());
+  }
+}
+function getTask(worker, options) {
+  var _a5;
+  if (options.source || ((_a5 = options.core) == null ? void 0 : _a5.source))
+    throw new Error(
+      "Inline legacy worker source is unsupported; use a TaskRunner worker URL or factory"
+    );
+  const create = !getCustomWorkerURL2(worker, options) && isBrowser2 ? 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) => {
+      var _a5;
+      return (_a5 = options.onProgress) == null ? void 0 : _a5.call(options, normalizeTaskProgress(progress));
+    } : void 0
+  };
+}
+function getParserOptions(options) {
+  const { signal, onProgress, ...parserOptions } = options;
+  return getTransferListForWriter2(parserOptions);
+}
+async function openSession(worker, options, context, jobContext) {
+  var _a5, _b2;
+  (_a5 = options.signal) == null ? void 0 : _a5.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 = () => {
+    var _a6;
+    return callbackController.abort((_a6 = options.signal) == null ? void 0 : _a6.reason);
+  };
+  (_b2 = options.signal) == null ? void 0 : _b2.addEventListener("abort", abortCallbacks, { once: true });
+  const closeChannel = () => {
+    var _a6;
+    channelClosed = true;
+    (_a6 = options.signal) == null ? void 0 : _a6.removeEventListener("abort", abortCallbacks);
+    callbackController.abort();
+    channel == null ? void 0 : channel.port1.close();
+    channel == null ? void 0 : 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() {
+      var _a5;
+      if (!inputClosed) {
+        inputClosed = true;
+        await ((_a5 = iterator.return) == null ? void 0 : _a5.call(iterator));
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+}
+function createModuleWorker(url) {
+  var _a5;
+  const resolved = new URL(url, ((_a5 = globalThis.document) == null ? void 0 : _a5.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) => {
+      var _a5;
+      return (_a5 = state.port) == null ? void 0 : _a5.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 = {}) {
+  var _a5, _b2;
+  const useLocalLibraries = options.useLocalLibraries ?? ((_a5 = options.core) == null ? void 0 : _a5.useLocalLibraries);
+  const CDN = getCDNOption(options.CDN, (_b2 = options.core) == null ? void 0 : _b2.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) {
+  var _a5, _b2;
+  let moduleLibraryUrl = libraryUrl;
+  if (moduleName) {
+    const requestedLibraryName = libraryName || libraryUrl;
+    const injectedLibrary = (_a5 = options.modules) == null ? void 0 : _a5[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 ((_b2 = options.modules) == null ? void 0 : _b2[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 == null ? void 0 : 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 (!isBrowser2) {
+    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 (!isBrowser2) {
+    const { requireFromFile: requireFromFile2 } = globalThis.loaders || {};
+    try {
+      const result = await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl));
+      if (result || !libraryUrl.includes("/dist/libs/")) {
+        return result;
+      }
+      return await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl.replace("/dist/libs/", "/src/libs/")));
+    } catch (error) {
+      if (libraryUrl.includes("/dist/libs/")) {
+        try {
+          return await (requireFromFile2 == null ? void 0 : requireFromFile2(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: readFileAsArrayBuffer2 } = globalThis.loaders || {};
+  if (isBrowser2 || !readFileAsArrayBuffer2 || url.startsWith("http")) {
+    const response = await fetch(url);
+    return await response.arrayBuffer();
+  }
+  try {
+    return await readFileAsArrayBuffer2(url);
+  } catch {
+    if (url.includes("/dist/libs/")) {
+      return await readFileAsArrayBuffer2(url.replace("/dist/libs/", "/src/libs/"));
+    }
+    throw new Error(`Failed to load ArrayBuffer from ${url}`);
+  }
+}
+async function loadAsText(url) {
+  const { readFileAsText: readFileAsText2 } = globalThis.loaders || {};
+  if (isBrowser2 || !readFileAsText2 || url.startsWith("http")) {
+    const response = await fetch(url);
+    return await response.text();
+  }
+  try {
+    return await readFileAsText2(url);
+  } catch {
+    if (url.includes("/dist/libs/")) {
+      return await readFileAsText2(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,
@@ -12720,15 +14623,15 @@ function initializeWasmModule(initialize, extractExports) {
 // ../core/src/loader-utils/lib/worker-loader-utils/encode-with-worker.ts
 function canEncodeWithWorker(writer, options) {
   var _a5, _b2;
-  if (!WorkerFarm.isSupported()) {
-    return false;
-  }
   const nodeWorkers = (options == null ? void 0 : options._nodeWorkers) ?? ((_a5 = options == null ? void 0 : options.core) == null ? void 0 : _a5._nodeWorkers);
   const useWorkers = (options == null ? void 0 : options.worker) ?? ((_b2 = options == null ? void 0 : options.core) == null ? void 0 : _b2.worker);
   if (!isBrowser4 && !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
@@ -19371,11 +21274,11 @@ var VariableWidthBuilder = class extends Builder {
     this._offsets = new OffsetsBufferBuilder(opts.type);
   }
   setValue(index2, value) {
-    const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-    const current = pending.get(index2);
+    const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+    const current = pending2.get(index2);
     current && (this._pendingLength -= current.length);
     this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
-    pending.set(index2, value);
+    pending2.set(index2, value);
   }
   setValid(index2, isValid) {
     if (!super.setValid(index2, isValid)) {
@@ -19398,12 +21301,12 @@ var VariableWidthBuilder = class extends Builder {
     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;
   }
@@ -21821,11 +23724,11 @@ var BinaryBuilder = class extends VariableWidthBuilder {
   setValue(index2, value) {
     return super.setValue(index2, toUint8Array2(value));
   }
-  _flushPending(pending, pendingLength) {
+  _flushPending(pending2, pendingLength) {
     const offsets = this._offsets;
     const data = this._values.reserve(pendingLength).buffer;
     let offset = 0;
-    for (const [index2, value] of pending) {
+    for (const [index2, value] of pending2) {
       if (value === void 0) {
         offsets.set(index2, 0);
       } else {
@@ -21854,11 +23757,11 @@ var LargeBinaryBuilder = class extends VariableWidthBuilder {
   setValue(index2, value) {
     return super.setValue(index2, toUint8Array2(value));
   }
-  _flushPending(pending, pendingLength) {
+  _flushPending(pending2, pendingLength) {
     const offsets = this._offsets;
     const data = this._values.reserve(pendingLength).buffer;
     let offset = 0;
-    for (const [index2, value] of pending) {
+    for (const [index2, value] of pending2) {
       if (value === void 0) {
         offsets.set(index2, BigInt(0));
       } else {
@@ -22089,10 +23992,10 @@ var ListBuilder = class extends VariableWidthBuilder {
     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 [index2, value] of pending) {
+    for (const [index2, value] of pending2) {
       if (typeof value === "undefined") {
         offsets.set(index2, 0);
       } else {
@@ -22121,10 +24024,10 @@ var LargeListBuilder = class extends VariableWidthBuilder {
     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 [index2, value] of pending) {
+    for (const [index2, value] of pending2) {
       if (typeof value === "undefined") {
         offsets.set(index2, BigInt(0));
       } else {
@@ -22146,11 +24049,11 @@ var MapBuilder = class extends VariableWidthBuilder {
   }
   setValue(index2, 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(index2);
+    const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+    const current = pending2.get(index2);
     current && (this._pendingLength -= current.size);
     this._pendingLength += row.size;
-    pending.set(index2, row);
+    pending2.set(index2, row);
   }
   addChild(child, name = `${this.numChildren}`) {
     if (this.numChildren > 0) {
@@ -22160,10 +24063,10 @@ var MapBuilder = class extends VariableWidthBuilder {
     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 [index2, value] of pending) {
+    for (const [index2, value] of pending2) {
       if (value === void 0) {
         offsets.set(index2, 0);
       } else {
@@ -22326,7 +24229,7 @@ var Utf8Builder = class extends VariableWidthBuilder {
     return super.setValue(index2, encodeUtf8(value));
   }
   // @ts-ignore
-  _flushPending(pending, pendingLength) {
+  _flushPending(pending2, pendingLength) {
   }
 };
 Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -22348,7 +24251,7 @@ var LargeUtf8Builder = class extends VariableWidthBuilder {
     return super.setValue(index2, encodeUtf8(value));
   }
   // @ts-ignore
-  _flushPending(pending, pendingLength) {
+  _flushPending(pending2, pendingLength) {
   }
 };
 LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -27361,7 +29264,7 @@ function getLibraryCacheKey2(type, options) {
 }
 
 // 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 = {
@@ -27428,7 +29331,7 @@ function encodeDracoInBatches(data, options = {}) {
   const normalizedData = normalizeDracoInputBatches(data);
   if (canEncodeWithWorker(DracoWriterWorker, options)) {
     const { onProgress: _onProgress, ...workerOptions } = options;
-    return processOnWorkerInBatches(
+    return processOnWorkerInBatches2(
       DracoWriterWorker,
       normalizedData,
       workerOptions
@@ -27494,7 +29397,7 @@ function isDracoBuilderMesh(data) {
 }
 
 // src/draco/workers/draco-writer-worker-node.ts
-createWorker(
+createWorker2(
   async (input, options) => (await encodeDraco(input, options)).data,
   encodeDracoInBatchesLocally
 );