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

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.4";
   globalThis._loadersgl_ = globalThis._loadersgl_ || {};
   globalThis._loadersgl_.version ||= version2;
   return version2;
@@ -10631,11 +10679,11 @@ var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.e
 var nodeVersion2 = matches && parseFloat(matches[1]) || 0;
 
 // ../../node_modules/@math.gl/core/dist/worker-utils/lib/npm-tag.js
-var NPM_TAG = "latest";
+var NPM_TAG2 = "latest";
 
 // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/version.js
 function getVersion2() {
-  return false ? NPM_TAG : "5.0.0-beta.2";
+  return false ? NPM_TAG2 : "5.0.0-beta.4";
 }
 var VERSION2 = getVersion2();
 
@@ -10793,9 +10841,19 @@ var NodeWorker = import_worker_threads.Worker;
 // ../../node_modules/@math.gl/core/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) {
@@ -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);
@@ -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) {
@@ -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);
     }
@@ -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}`;
@@ -12055,8 +12130,63 @@ function getInputByteLength(input) {
   return bytes;
 }
 
+// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+function validateOutputOwnership(ownership) {
+  if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
+    throw new Error("Invalid worker output ownership");
+  }
+}
+
 // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/process-on-worker.js
+async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+  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);
@@ -12309,7 +12439,7 @@ 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,7 +12636,7 @@ 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;
     }
@@ -12515,6 +12648,1207 @@ 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;
 
+// ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+var pending = /* @__PURE__ */ new WeakMap();
+var loaded = /* @__PURE__ */ new WeakSet();
+function preloadTaskCode(task, signal) {
+  if (!task.preload)
+    return Promise.resolve();
+  let promise = pending.get(task);
+  if (!promise) {
+    promise = Promise.resolve().then(() => task.preload()).then(() => {
+      loaded.add(task);
+    });
+    pending.set(task, promise);
+    void promise.catch(() => pending.delete(task));
+  }
+  return withSignal(promise, signal);
+}
+function isTaskCodeLoaded(task) {
+  return !task.preload || loaded.has(task);
+}
+function withSignal(operation, signal) {
+  if (!signal)
+    return operation;
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted)
+      abort();
+    operation.then((value) => {
+      signal.removeEventListener("abort", abort);
+      resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+  });
+}
+
+// ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+function assertPayload(value) {
+  if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new TypeError("Task payloads must be plain objects with named fields");
+  }
+}
+function clonePayload(value, ownership = "copy") {
+  assertPayload(value);
+  if (!["copy", "transfer", "share"].includes(ownership))
+    throw new TypeError("Invalid input ownership");
+  const transfer = getTransferList(value);
+  if (ownership === "share" && transfer.length)
+    throw new TypeError("Share requires shared storage");
+  return structuredClone(value, {
+    transfer: ownership === "transfer" ? transfer : []
+  });
+}
+function taskContext(state, context = {}) {
+  const signal = context.signal ?? new AbortController().signal;
+  return {
+    state,
+    signal,
+    throwIfAborted: () => {
+      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"
+      });
+    }
+  };
+}
+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 {};
+  }
+  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));
+    }
+    return {};
+  }
+  async process(input, options, context = {}) {
+    if (!this.initialized)
+      throw new Error("Task is not initialized");
+    if (!this.task.process)
+      throw new Error("Task has no atomic processor");
+    assertPayload(input);
+    const result = await this.task.process(input, options, taskContext(this.state, context));
+    assertPayload(result);
+    return result;
+  }
+  async *stream(inputs, options, context = {}) {
+    if (!this.initialized)
+      throw new Error("Task is not initialized");
+    if (!this.task.processInBatches)
+      throw new Error("Task has no streaming processor");
+    for await (const output of this.task.processInBatches(inputs, options, taskContext(this.state, context))) {
+      assertPayload(output);
+      yield output;
+    }
+  }
+};
+async function initializeTaskWorker(task) {
+  if (!await WorkerBody.inWorkerThread())
+    throw new Error("initializeTaskWorker must run inside a worker");
+  if (installed)
+    throw new Error("A task is already installed in this worker");
+  installed = true;
+  const runtime = new TaskRuntime(task);
+  let streamOptions = {};
+  return createWorker(async (request, _options, context) => {
+    switch (request.operation) {
+      case "initialize":
+        return runtime.initialize(request.input, context);
+      case "destroy":
+        return runtime.destroy();
+      case "stream-options":
+        streamOptions = request.options;
+        return {};
+      case "process":
+        return runtime.process(request.input, request.options, context);
+      default:
+        throw new Error("Unknown task operation");
+    }
+  }, async function* (inputs, _options, context) {
+    async function* batches() {
+      for await (const input of inputs) {
+        assertPayload(input);
+        yield input;
+      }
+    }
+    try {
+      yield* runtime.stream(batches(), streamOptions, context);
+    } finally {
+      streamOptions = {};
+    }
+  }, () => preloadTaskCode(task));
+}
+var installed = false;
+function localContext(controls) {
+  return {
+    signal: controls.signal,
+    reportProgress: (progress) => {
+      var _a5;
+      return (_a5 = controls.onProgress) == null ? void 0 : _a5.call(controls, progress);
+    }
+  };
+}
+
+// ../../node_modules/@math.gl/core/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/core/dist/tasks/task-runner.js
+var InitializedTask = class {
+  /** @internal Use TaskRunner.initializeTask. */
+  constructor(task, release, controls) {
+    var _a5, _b2;
+    this.task = task;
+    this.release = release;
+    this.tail = Promise.resolve();
+    this.closed = false;
+    this.streams = /* @__PURE__ */ new Set();
+    this.invalid = false;
+    this.controller = new AbortController();
+    this.runtime = new TaskRuntime(task);
+    const execution = controls.execution ?? "auto";
+    if (!["auto", "main-thread", "worker"].includes(execution))
+      throw new TypeError("Invalid execution mode");
+    if (execution === "worker" && !task.worker)
+      throw new Error("Task has no worker");
+    if (execution !== "main-thread" && task.worker) {
+      const target = task.worker;
+      if (Boolean(target.url) === Boolean(target.create))
+        throw new Error("Supply exactly one worker URL or factory");
+      this.pool = new WorkerPool({
+        name: task.id,
+        url: (_a5 = target.url) == null ? void 0 : _a5.toString(),
+        loadWorker: target.create,
+        workerType: "module",
+        maxConcurrency: 1,
+        maxMobileConcurrency: 1
+      });
+      this.descriptor = {
+        id: task.id,
+        name: task.id,
+        module: "core",
+        version: "prototype",
+        options: {},
+        worker: ((_b2 = target.url) == null ? void 0 : _b2.toString()) ?? true,
+        loadWorker: target.create,
+        workerInBatches: target.capabilities.streaming
+      };
+    }
+  }
+  /** @internal */
+  async initialize(input, controls) {
+    try {
+      assertPayload(input);
+      await this.enqueue(() => this.invoke("initialize", input, {}, controls));
+    } catch (error) {
+      await this.terminate(error);
+      throw error;
+    }
+  }
+  runTask(input, ...args) {
+    return this.enqueue(async () => {
+      var _a5;
+      this.checkCapability("atomic");
+      return this.invoke("process", input, ((_a5 = args[0]) == null ? void 0 : _a5.options) ?? {}, args[0]);
+    });
+  }
+  /** Independent calls sharing this instance, always serial and in input order. */
+  async *runTasks(inputs, ...args) {
+    yield* this.serialStream(async function* (self2) {
+      var _a5;
+      self2.checkCapability("atomic");
+      for await (const input of asAsync(inputs, self2.controls(args[0]).signal)) {
+        yield await self2.invoke("process", input, ((_a5 = args[0]) == null ? void 0 : _a5.options) ?? {}, args[0]);
+      }
+    });
+  }
+  /** One processor invocation for the entire input iterable. */
+  async *runTaskInBatches(inputs, ...args) {
+    yield* this.serialStream(async function* (self2) {
+      var _a5, _b2;
+      self2.checkCapability("streaming");
+      const controls = self2.controls(args[0]);
+      const options = clonePayload(((_a5 = args[0]) == null ? void 0 : _a5.options) ?? {});
+      async function* prepared() {
+        var _a6, _b3;
+        for await (const input of asAsync(inputs, controls.signal)) {
+          (_a6 = controls.signal) == null ? void 0 : _a6.throwIfAborted();
+          assertNoTransferAlias(input, ((_b3 = args[0]) == null ? void 0 : _b3.options) ?? {}, controls.inputOwnership);
+          yield clonePayload(input, controls.inputOwnership);
+        }
+      }
+      let completed = false;
+      try {
+        if (self2.pool) {
+          await self2.invoke("stream-options", {}, options, controls);
+          yield* processOnWorkerInBatches(self2.descriptor, prepared(), {
+            ...self2.workerOptions(controls),
+            inputOwnership: "transfer",
+            workerInBatches: true
+          });
+        } else {
+          for await (const output of self2.runtime.stream(prepared(), options, localContext(controls))) {
+            (_b2 = controls.signal) == null ? void 0 : _b2.throwIfAborted();
+            yield clonePayload(output, controls.outputOwnership ?? "transfer");
+          }
+        }
+        completed = true;
+      } catch (error) {
+        if (self2.pool) {
+          self2.invalid = true;
+          await self2.pool.destroy(error);
+        }
+        throw error;
+      } finally {
+        if (self2.pool && !completed)
+          self2.invalid = true;
+      }
+    });
+  }
+  /** Drain accepted work, invoke destroy, and release execution capacity. */
+  close() {
+    if (!this.closing) {
+      this.closed = true;
+      this.closing = (async () => {
+        var _a5;
+        try {
+          await this.tail;
+          if (!this.invalid)
+            await this.invoke("destroy", {}, {});
+        } finally {
+          try {
+            await ((_a5 = this.pool) == null ? void 0 : _a5.destroy());
+          } finally {
+            this.release();
+          }
+        }
+      })();
+    }
+    return this.closing;
+  }
+  /** Abort work. Local JavaScript must settle before its state can be destroyed. */
+  async terminate(reason = new Error("Task terminated")) {
+    this.controller.abort(reason);
+    if (this.pool) {
+      this.invalid = true;
+      await this.pool.destroy(reason);
+    }
+    await Promise.allSettled([...this.streams].map((stop) => stop()));
+    await this.close();
+  }
+  checkCapability(kind) {
+    var _a5;
+    if (this.pool ? !((_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;
+    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.pool) {
+      try {
+        return await processOnWorker(this.descriptor, { operation, input: clonePayload(input, prepared.inputOwnership), options: copiedOptions }, this.workerOptions({ ...prepared, inputOwnership: "transfer" }));
+      } catch (error) {
+        this.invalid = true;
+        await this.pool.destroy(error);
+        throw error;
+      }
+    }
+    if (operation === "destroy")
+      return this.runtime.destroy();
+    const copied = clonePayload(input, prepared.inputOwnership);
+    const context = localContext(prepared);
+    if (operation === "initialize") {
+      const result2 = await this.runtime.initialize(copied, context);
+      (_b2 = prepared.signal) == null ? void 0 : _b2.throwIfAborted();
+      return result2;
+    }
+    const result = await this.runtime.process(copied, copiedOptions, context);
+    (_c2 = prepared.signal) == null ? void 0 : _c2.throwIfAborted();
+    return clonePayload(result, prepared.outputOwnership ?? "transfer");
+  }
+  enqueue(operation) {
+    if (this.closed)
+      return Promise.reject(new Error("Initialized task is closed"));
+    const result = this.tail.then(operation);
+    this.tail = result.catch(() => {
+    });
+    return result;
+  }
+  async *serialStream(operation) {
+    if (this.closed)
+      throw new Error("Initialized task is closed");
+    const before = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await before;
+    if (this.controller.signal.aborted) {
+      release();
+      throw this.controller.signal.reason;
+    }
+    const iterator = operation(this)[Symbol.asyncIterator]();
+    let stopping;
+    const stop = () => {
+      stopping ?? (stopping = (async () => {
+        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/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-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-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 = {}) {
@@ -12720,15 +14054,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 +20705,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 +20732,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 +23155,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 +23188,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 +23423,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 +23455,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 +23480,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 +23494,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 +23660,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 +23682,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 +28695,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.4" : "latest";
 
 // src/draco/draco-format.ts
 var DracoFormat = {
@@ -27428,7 +28762,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 +28828,7 @@ function isDracoBuilderMesh(data) {
 }
 
 // src/draco/workers/draco-writer-worker-node.ts
-createWorker(
+createWorker2(
   async (input, options) => (await encodeDraco(input, options)).data,
   encodeDracoInBatchesLocally
 );