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

package/dist/obj-worker.js

@@ -15,29 +15,44 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
   var parentPort;
   var init_worker_threads_browser = __esm({
-    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
-      "use strict";
-      parentPort = null;
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js"() {
+      parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
-    if (!object) {
-    } else if (isTransferable(object)) {
-      transfersSet.add(object);
-    } else if (isTransferable(object.buffer)) {
-      transfersSet.add(object.buffer);
-    } else if (ArrayBuffer.isView(object)) {
-    } else if (recursive && typeof object === "object") {
-      for (const key in object) {
-        getTransferList(object[key], recursive, transfersSet);
+    const seen = /* @__PURE__ */ new Set();
+    function visit(value) {
+      if (!value || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      if (isTransferable(value))
+        transfersSet.add(value);
+      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);
+          visit(item);
+        }
+      } else if (recursive && value instanceof Set) {
+        for (const item of value)
+          visit(item);
+      } else if (recursive) {
+        for (const key of Object.keys(value))
+          visit(value[key]);
       }
     }
+    visit(object);
     return transfers === void 0 ? Array.from(transfersSet) : [];
   }
   function isTransferable(object) {
@@ -59,12 +74,11 @@
     return false;
   }
   var init_get_transfer_list = __esm({
-    "../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-farm/worker-body.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
   async function getParentPort() {
     return parentPort;
   }
@@ -77,31 +91,31 @@
   }
   var onMessageWrapperMap, WorkerBody;
   var init_worker_body = __esm({
-    "../core/src/worker-utils/lib/worker-farm/worker-body.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js"() {
       init_get_transfer_list();
       init_worker_threads_browser();
       onMessageWrapperMap = /* @__PURE__ */ new Map();
       WorkerBody = class {
         /** Check that we are actually in a worker thread */
         static async inWorkerThread() {
-          return typeof self !== "undefined" || Boolean(await getParentPort());
+          const workerGlobalScope = globalThis.WorkerGlobalScope;
+          return typeof workerGlobalScope === "function" && globalThis instanceof workerGlobalScope || Boolean(await getParentPort());
         }
         /*
          * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
          */
         static set onmessage(onMessage) {
           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;
             onMessage(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;
             }
@@ -119,9 +133,9 @@
             };
             onMessageWrapperMap.set(onMessage, 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);
           }
@@ -132,9 +146,9 @@
           if (!onMessageWrapper) {
             return;
           }
-          const parentPort2 = await getParentPort();
-          if (parentPort2) {
-            parentPort2.off("message", onMessageWrapper);
+          const parentPort3 = await getParentPort();
+          if (parentPort3) {
+            parentPort3.off("message", onMessageWrapper);
           } else {
             globalThis.removeEventListener("message", onMessageWrapper);
           }
@@ -144,12 +158,12 @@
          * @param type
          * @param payload
          */
-        static async postMessage(type, payload) {
+        static async postMessage(type, payload, copy = false) {
           const data = { source: "loaders.gl", type, payload };
-          const transferList = getTransferList(payload);
-          const parentPort2 = await getParentPort();
-          if (parentPort2) {
-            parentPort2.postMessage(data, transferList);
+          const transferList = copy ? [] : getTransferList(payload);
+          const parentPort3 = await getParentPort();
+          if (parentPort3) {
+            parentPort3.postMessage(data, transferList);
           } else {
             globalThis.postMessage(data, transferList);
           }
@@ -158,15 +172,11 @@
     }
   });
 
-  // ../core/src/worker-utils/lib/async-queue/async-queue.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
   var AsyncQueue;
   var init_async_queue = __esm({
-    "../core/src/worker-utils/lib/async-queue/async-queue.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js"() {
       AsyncQueue = class {
-        _values;
-        _settlers;
-        _closed;
         constructor() {
           this._values = [];
           this._settlers = [];
@@ -234,8 +244,63 @@
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
-  async function createWorker(process, processInBatches) {
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+  var SharedWorkerState;
+  var init_shared_state = __esm({
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js"() {
+      SharedWorkerState = class {
+        constructor(buffer) {
+          if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
+            throw new Error("Expected a 16-byte shared worker control buffer");
+          this.buffer = buffer;
+          this.values = new Int32Array(buffer);
+        }
+        get snapshot() {
+          return {
+            cancelled: Atomics.load(this.values, 0) !== 0,
+            completed: Atomics.load(this.values, 1),
+            total: Atomics.load(this.values, 2),
+            revision: Atomics.load(this.values, 3)
+          };
+        }
+        cancel() {
+          Atomics.store(this.values, 0, 1);
+          Atomics.add(this.values, 3, 1);
+          Atomics.notify(this.values, 0);
+        }
+        throwIfCancelled() {
+          if (Atomics.load(this.values, 0) !== 0) {
+            const error = new Error("Shared worker task was cancelled");
+            error.name = "AbortError";
+            throw error;
+          }
+        }
+        /** Integer counters for application-defined work; messages still carry phase names and units. */
+        setProgress(completed, total = -1) {
+          if (!Number.isInteger(completed) || completed < 0 || completed > 2147483647 || !Number.isInteger(total) || total < -1 || total > 2147483647) {
+            throw new RangeError("Shared progress requires nonnegative int32 counts (or total -1)");
+          }
+          Atomics.store(this.values, 1, completed);
+          Atomics.store(this.values, 2, total);
+          Atomics.add(this.values, 3, 1);
+        }
+      };
+    }
+  });
+
+  // ../../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");
+    }
+  }
+  var init_validate_output_ownership = __esm({
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
+  async function createWorker(process2, processInBatches, preload2) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
     }
@@ -243,27 +308,59 @@
       process: processOnMainThread
     };
     WorkerBody.onmessage = async (type, payload) => {
+      if (type === "cancel") {
+        activeController?.abort();
+        activeInputBatches?.close();
+        activeOutputAcknowledgements?.close();
+        return;
+      }
+      const controller = type === "process" || type === "process-in-batches" ? new AbortController() : void 0;
+      if (controller)
+        activeController = controller;
+      const startedAt = performance.now();
       const reporter = type === "process" || type === "process-in-batches" ? createProgressReporter() : void 0;
-      const jobContext = { ...context, reportProgress: reporter?.report };
+      let sharedState;
+      const throwIfAborted = () => {
+        controller?.signal.throwIfAborted();
+        sharedState?.throwIfCancelled();
+      };
+      const jobContext = {
+        ...context,
+        signal: controller?.signal,
+        sharedState,
+        throwIfAborted,
+        reportProgress: (progress) => {
+          if (!controller?.signal.aborted && !sharedState?.snapshot.cancelled)
+            reporter?.report(progress);
+        }
+      };
       try {
+        if (controller && payload.options?.["sharedState"]) {
+          sharedState = new SharedWorkerState(payload.options["sharedState"]);
+          jobContext.sharedState = sharedState;
+        }
         switch (type) {
           case "preload":
+            await preload2?.();
             WorkerBody.postMessage("done", {});
             break;
           case "process":
-            if (!process) {
+            throwIfAborted();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
+            if (!process2) {
               throw new Error("Worker does not support atomic processing");
             }
-            const result = await process(
-              payload.input,
-              payload.options || {},
-              jobContext,
-              payload.context || {}
-            );
+            const result = await process2(payload.input, payload.options || {}, jobContext, payload.context || {});
+            throwIfAborted();
             reporter?.finish();
-            WorkerBody.postMessage("done", { result });
+            await WorkerBody.postMessage("done", {
+              result,
+              executionMs: performance.now() - startedAt
+            }, payload.options?.["outputOwnership"] === "copy");
             break;
           case "process-in-batches":
+            throwIfAborted();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
@@ -272,18 +369,15 @@
             activeInputBatches = inputBatches;
             activeOutputAcknowledgements = outputAcknowledgements;
             try {
-              const resultIterator = processInBatches(
-                createDemandDrivenIterator(inputBatches),
-                payload.options || {},
-                jobContext,
-                payload.context || {}
-              );
+              const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
               for await (const batch of resultIterator) {
-                await WorkerBody.postMessage("output-batch", { result: batch });
+                throwIfAborted();
+                await WorkerBody.postMessage("output-batch", { result: batch }, payload.options?.["outputOwnership"] === "copy");
                 await outputAcknowledgements.next();
               }
+              throwIfAborted();
               reporter?.finish();
-              await WorkerBody.postMessage("done", {});
+              await WorkerBody.postMessage("done", { executionMs: performance.now() - startedAt });
             } finally {
               activeInputBatches = null;
               activeOutputAcknowledgements = null;
@@ -310,11 +404,18 @@
           default:
         }
       } catch (error) {
-        reporter?.finish();
+        reporter?.finish(controller?.signal.aborted || sharedState?.snapshot.cancelled);
         const message = error instanceof Error ? error.message : "";
-        WorkerBody.postMessage("error", { error: message });
+        await WorkerBody.postMessage("error", {
+          error: message,
+          errorName: error instanceof Error ? error.name : "Error"
+        });
+      } finally {
+        if (controller && activeController === controller)
+          activeController = null;
       }
     };
+    await WorkerBody.postMessage("ready", {});
   }
   async function* createDemandDrivenIterator(inputBatches) {
     while (true) {
@@ -327,81 +428,449 @@
     }
   }
   function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
+    const signal = activeController?.signal;
+    signal?.throwIfAborted();
     return new Promise((resolve, reject) => {
       const id = requestId++;
-      const onMessage = (type, payload2) => {
-        if (payload2.id !== id) {
+      const cleanup = () => {
+        signal?.removeEventListener("abort", abort);
+        void WorkerBody.removeEventListener(onMessage);
+      };
+      const abort = () => {
+        cleanup();
+        reject(signal?.reason);
+      };
+      const onMessage = (type, payload) => {
+        if (payload.id !== id)
           return;
-        }
-        switch (type) {
-          case "done":
-            WorkerBody.removeEventListener(onMessage);
-            resolve(payload2.result);
-            break;
-          case "error":
-            WorkerBody.removeEventListener(onMessage);
-            reject(payload2.error);
-            break;
-          default:
+        if (type === "done") {
+          cleanup();
+          resolve(payload.result);
+        } else if (type === "error") {
+          cleanup();
+          reject(payload.error);
         }
       };
-      WorkerBody.addEventListener(onMessage);
-      const payload = { id, input: arrayBuffer, options, context: jobContext };
-      WorkerBody.postMessage("process", payload);
+      void WorkerBody.addEventListener(onMessage).then(async () => {
+        if (signal?.aborted) {
+          abort();
+          return;
+        }
+        signal?.addEventListener("abort", abort, { once: true });
+        await WorkerBody.postMessage("process", {
+          id,
+          input: arrayBuffer,
+          options,
+          context: jobContext
+        });
+      }).catch((error) => {
+        cleanup();
+        reject(error);
+      });
     });
   }
   function createProgressReporter() {
-    let pending;
+    let pending2;
     let finished = false;
     let scheduled = false;
     const flush = () => {
       scheduled = false;
-      if (pending) {
-        WorkerBody.postMessage("progress", { progress: pending });
-        pending = void 0;
+      if (pending2) {
+        WorkerBody.postMessage("progress", { progress: pending2 });
+        pending2 = void 0;
       }
     };
     return {
       /** Records progress while retaining phase transitions. */
       report(progress) {
-        if (finished) return;
-        if (pending && pending.phase !== progress.phase) flush();
-        pending = { ...progress };
+        if (finished)
+          return;
+        if (pending2 && pending2.phase !== progress.phase)
+          flush();
+        pending2 = { ...progress };
         if (!scheduled) {
           scheduled = true;
           setTimeout(flush, 0);
         }
       },
       /** Flushes final progress and suppresses reports from stale callbacks. */
-      finish() {
+      finish(discard = false) {
+        if (discard)
+          pending2 = void 0;
         flush();
         finished = true;
       }
     };
   }
-  var requestId, activeInputBatches, activeOutputAcknowledgements;
+  var requestId, activeController, activeInputBatches, activeOutputAcknowledgements;
   var init_create_worker = __esm({
-    "../core/src/worker-utils/lib/worker-api/create-worker.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js"() {
+      init_shared_state();
       init_async_queue();
       init_worker_body();
+      init_validate_output_ownership();
       requestId = 0;
+      activeController = null;
       activeInputBatches = null;
       activeOutputAcknowledgements = null;
     }
   });
 
-  // ../core/src/worker-utils/index.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  var import_meta, path, moduleUrl;
   var init_worker_utils = __esm({
+    "../../node_modules/@math.gl/core/dist/worker-utils/index.js"() {
+      init_worker_body();
+      init_create_worker();
+      import_meta = {};
+      path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
+      moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+  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 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);
+      });
+    });
+  }
+  var pending, loaded;
+  var init_task_preload = __esm({
+    "../../node_modules/@math.gl/core/dist/tasks/task-preload.js"() {
+      pending = /* @__PURE__ */ new WeakMap();
+      loaded = /* @__PURE__ */ new WeakSet();
+    }
+  });
+
+  // ../../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 taskContext(state, context = {}) {
+    const signal = context.signal ?? new AbortController().signal;
+    return {
+      state,
+      signal,
+      throwIfAborted: () => {
+        signal.throwIfAborted();
+        context.throwIfAborted?.();
+      },
+      reportProgress: (progress) => context.reportProgress?.({
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      })
+    };
+  }
+  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 TaskRuntime, installed;
+  var init_task_runtime = __esm({
+    "../../node_modules/@math.gl/core/dist/tasks/task-runtime.js"() {
+      init_worker_utils();
+      init_task_preload();
+      TaskRuntime = class {
+        constructor(task) {
+          this.task = task;
+          this.initialized = false;
+        }
+        async initialize(input, context = {}) {
+          if (this.initialized)
+            throw new Error("Task is already initialized");
+          assertPayload(input);
+          await preloadTaskCode(this.task, context.signal);
+          context.signal?.throwIfAborted();
+          this.state = await this.task.initialize?.(input, taskContext(void 0, context));
+          this.initialized = true;
+          return {};
+        }
+        async destroy() {
+          if (this.initialized) {
+            this.initialized = false;
+            const state = this.state;
+            this.state = void 0;
+            if (this.task.initialize)
+              await this.task.destroy?.(state);
+          }
+          return {};
+        }
+        async process(input, options, context = {}) {
+          if (!this.initialized)
+            throw new Error("Task is not initialized");
+          if (!this.task.process)
+            throw new Error("Task has no atomic processor");
+          assertPayload(input);
+          const result = await this.task.process(input, options, taskContext(this.state, context));
+          assertPayload(result);
+          return result;
+        }
+        async *stream(inputs, options, context = {}) {
+          if (!this.initialized)
+            throw new Error("Task is not initialized");
+          if (!this.task.processInBatches)
+            throw new Error("Task has no streaming processor");
+          for await (const output of this.task.processInBatches(inputs, options, taskContext(this.state, context))) {
+            assertPayload(output);
+            yield output;
+          }
+        }
+      };
+      installed = false;
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/tasks/index.js
+  var init_tasks = __esm({
+    "../../node_modules/@math.gl/core/dist/tasks/index.js"() {
+      init_task_runtime();
+    }
+  });
+
+  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  var worker_threads_browser_exports = {};
+  __export(worker_threads_browser_exports, {
+    NodeWorker: () => NodeWorker,
+    parentPort: () => parentPort2
+  });
+  var NodeWorker, parentPort2;
+  var init_worker_threads_browser2 = __esm({
+    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
+      "use strict";
+      NodeWorker = class {
+        /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+        constructor(...arguments_) {
+          const runtimeProcess = globalThis.process;
+          const WorkerConstructor = runtimeProcess?.getBuiltinModule?.("node:worker_threads").Worker;
+          if (WorkerConstructor) {
+            return new WorkerConstructor(...arguments_);
+          }
+        }
+        /** No-op browser fallback matching the native Worker API. */
+        terminate() {
+        }
+      };
+      parentPort2 = null;
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
+  function normalizeTaskProgress(progress) {
+    return { ...progress, phase: progress.phase ?? "process", unit: progress.unit ?? "items" };
+  }
+  async function isWorkerThread() {
+    if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+      return true;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const { isMainThread } = await Promise.resolve().then(() => (init_worker_threads_browser2(), worker_threads_browser_exports));
+      return !isMainThread;
+    }
+    return false;
+  }
+  var initializeTaskWorker2;
+  var init_task_runtime2 = __esm({
+    "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
+      "use strict";
+      init_tasks();
+      initializeTaskWorker2 = initializeTaskWorker;
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  function getTransferList2(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable2(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable2(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList2(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable2(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+  var init_get_transfer_list2 = __esm({
+    "../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts"() {
+      "use strict";
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  async function createWorker2(process2, processInBatches) {
+    if (!await isWorkerThread()) return;
+    await initializeTaskWorker2(createWorkerTask(process2, processInBatches));
+  }
+  function createWorkerTask(process2, processInBatches) {
+    return {
+      id: "loaders.gl",
+      initialize: (state) => state,
+      destroy: (state) => state.port?.close(),
+      process: async ({ value }, options, context) => {
+        if (!process2) throw new Error("Worker does not support atomic processing");
+        return { value: await process2(value, options, createContext(context), context.state.context) };
+      },
+      ...processInBatches ? {
+        processInBatches: async function* (inputs, options, context) {
+          async function* values() {
+            for await (const input of inputs) yield input.value;
+          }
+          for await (const value of processInBatches(
+            values(),
+            options,
+            createContext(context),
+            context.state.context
+          )) {
+            yield { value };
+          }
+        }
+      } : {}
+    };
+  }
+  function createContext(context) {
+    let requestIdentifier = 0;
+    const port = context.state.port;
+    return {
+      signal: context.signal,
+      throwIfAborted: () => context.throwIfAborted(),
+      reportProgress: (progress) => context.reportProgress(normalizeTaskProgress(progress)),
+      process: port ? (input, options = {}, jobContext = {}) => {
+        context.throwIfAborted();
+        const identifier = ++requestIdentifier;
+        return new Promise((resolve, reject) => {
+          const onMessage = (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", onMessage);
+            context.signal.removeEventListener("abort", onAbort);
+          };
+          port.addEventListener("message", onMessage);
+          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
+    };
+  }
+  var init_create_worker2 = __esm({
+    "../core/src/worker-utils/lib/worker-api/create-worker.ts"() {
+      "use strict";
+      init_task_runtime2();
+      init_get_transfer_list2();
+    }
+  });
+
+  // ../core/src/worker-utils/index.ts
+  var init_worker_utils2 = __esm({
     "../core/src/worker-utils/index.ts"() {
       "use strict";
-      init_create_worker();
+      init_create_worker2();
     }
   });
 
   // ../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts
   async function createLoaderWorker(loader, selectLoader = () => loader) {
-    await createWorker(
+    await createWorker2(
       (input, options, workerContext, loaderContext) => processLoaderWorkerData(
         selectLoader(options || {}),
         input,
@@ -539,7 +1008,7 @@
   var init_create_loader_worker = __esm({
     "../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts"() {
       "use strict";
-      init_worker_utils();
+      init_worker_utils2();
     }
   });
 
@@ -8426,11 +8895,11 @@ return true;`);
           this._offsets = new OffsetsBufferBuilder(opts.type);
         }
         setValue(index, value) {
-          const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-          const current = pending.get(index);
+          const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+          const current = pending2.get(index);
           current && (this._pendingLength -= current.length);
           this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
-          pending.set(index, value);
+          pending2.set(index, value);
         }
         setValid(index, isValid) {
           if (!super.setValid(index, isValid)) {
@@ -8453,12 +8922,12 @@ return true;`);
           return super.finish();
         }
         _flush() {
-          const pending = this._pending;
+          const pending2 = this._pending;
           const pendingLength = this._pendingLength;
           this._pendingLength = 0;
           this._pending = void 0;
-          if (pending && pending.size > 0) {
-            this._flushPending(pending, pendingLength);
+          if (pending2 && pending2.size > 0) {
+            this._flushPending(pending2, pendingLength);
           }
           return this;
         }
@@ -11044,11 +11513,11 @@ return true;`);
         setValue(index, value) {
           return super.setValue(index, toUint8Array(value));
         }
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
           const offsets = this._offsets;
           const data = this._values.reserve(pendingLength).buffer;
           let offset = 0;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (value === void 0) {
               offsets.set(index, 0);
             } else {
@@ -11085,11 +11554,11 @@ return true;`);
         setValue(index, value) {
           return super.setValue(index, toUint8Array(value));
         }
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
           const offsets = this._offsets;
           const data = this._values.reserve(pendingLength).buffer;
           let offset = 0;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (value === void 0) {
               offsets.set(index, BigInt(0));
             } else {
@@ -11400,10 +11869,10 @@ return true;`);
           this.type = new List2(new Field2(name, child.type, true));
           return this.numChildren - 1;
         }
-        _flushPending(pending) {
+        _flushPending(pending2) {
           const offsets = this._offsets;
           const [child] = this.children;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (typeof value === "undefined") {
               offsets.set(index, 0);
             } else {
@@ -11442,10 +11911,10 @@ return true;`);
           this.type = new LargeList2(new Field2(name, child.type, true));
           return this.numChildren - 1;
         }
-        _flushPending(pending) {
+        _flushPending(pending2) {
           const offsets = this._offsets;
           const [child] = this.children;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (typeof value === "undefined") {
               offsets.set(index, BigInt(0));
             } else {
@@ -11475,11 +11944,11 @@ return true;`);
         }
         setValue(index, value) {
           const row = value instanceof Map ? value : new Map(Object.entries(value));
-          const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-          const current = pending.get(index);
+          const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+          const current = pending2.get(index);
           current && (this._pendingLength -= current.size);
           this._pendingLength += row.size;
-          pending.set(index, row);
+          pending2.set(index, row);
         }
         addChild(child, name = `${this.numChildren}`) {
           if (this.numChildren > 0) {
@@ -11489,10 +11958,10 @@ return true;`);
           this.type = new Map_(new Field2(name, child.type, true), this.type.keysSorted);
           return this.numChildren - 1;
         }
-        _flushPending(pending) {
+        _flushPending(pending2) {
           const offsets = this._offsets;
           const [child] = this.children;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (value === void 0) {
               offsets.set(index, 0);
             } else {
@@ -11701,7 +12170,7 @@ return true;`);
           return super.setValue(index, encodeUtf8(value));
         }
         // @ts-ignore
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
         }
       };
       Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -11732,7 +12201,7 @@ return true;`);
           return super.setValue(index, encodeUtf8(value));
         }
         // @ts-ignore
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
         }
       };
       LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -17423,7 +17892,7 @@ return true;`);
       "use strict";
       init_obj_format();
       init_arrow_transport();
-      VERSION = true ? "5.0.0-beta.1" : "latest";
+      VERSION = true ? "5.0.0-beta.4" : "latest";
       OBJLoader = {
         ...OBJFormat,
         dataType: null,