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

package/dist/draco-worker-node.js

@@ -7617,7 +7617,7 @@ var init_initialize_wasm_module = __esm({
 
 // ../core/src/worker-utils/lib/env-utils/version.ts
 function getVersion() {
-  const version2 = false ? NPM_TAG : "5.0.0-beta.2";
+  const version2 = false ? NPM_TAG : "5.0.0-beta.5";
   globalThis._loadersgl_ = globalThis._loadersgl_ || {};
   globalThis._loadersgl_.version ||= version2;
   return version2;
@@ -7666,16 +7666,16 @@ var init_globals = __esm({
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads.js
 var import_worker_threads, parentPort;
 var init_worker_threads = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads.js"() {
     import_worker_threads = require("worker_threads");
     parentPort = import_worker_threads.parentPort;
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js
 function getTransferList(object2, recursive = true, transfers) {
   const transfersSet = transfers || /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -7688,6 +7688,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);
@@ -7723,11 +7726,11 @@ function isTransferable(object2) {
   return false;
 }
 var init_get_transfer_list = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-body.js
 async function getParentPort() {
   return parentPort;
 }
@@ -7740,7 +7743,7 @@ function getWorkerMessageData(message) {
 }
 var onMessageWrapperMap, WorkerBody;
 var init_worker_body = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-body.js"() {
     init_get_transfer_list();
     init_worker_threads();
     onMessageWrapperMap = /* @__PURE__ */ new Map();
@@ -7755,16 +7758,16 @@ var init_worker_body = __esm({
        */
       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;
           }
@@ -7782,9 +7785,9 @@ var init_worker_body = __esm({
           };
           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);
         }
@@ -7795,9 +7798,9 @@ var init_worker_body = __esm({
         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);
         }
@@ -7807,12 +7810,12 @@ var init_worker_body = __esm({
        * @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);
         }
@@ -7821,10 +7824,10 @@ var init_worker_body = __esm({
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js
 var AsyncQueue;
 var init_async_queue = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js"() {
     AsyncQueue = class {
       constructor() {
         this._values = [];
@@ -7893,10 +7896,10 @@ var init_async_queue = __esm({
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js
 var SharedWorkerState;
 var init_shared_state = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js"() {
     SharedWorkerState = class {
       constructor(buffer2) {
         if (typeof SharedArrayBuffer === "undefined" || !(buffer2 instanceof SharedArrayBuffer) || buffer2.byteLength !== 16)
@@ -7937,8 +7940,19 @@ var init_shared_state = __esm({
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
-async function createWorker(process2, processInBatches) {
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+function validateOutputOwnership(ownership) {
+  if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
+    throw new Error("Invalid worker output ownership");
+  }
+}
+var init_validate_output_ownership = __esm({
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
+  }
+});
+
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js
+async function createWorker(process2, processInBatches, preload2) {
   if (!await WorkerBody.inWorkerThread()) {
     return;
   }
@@ -7946,7 +7960,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();
@@ -7980,10 +7994,12 @@ async function createWorker(process2, processInBatches) {
       }
       switch (type) {
         case "preload":
+          await (preload2 == null ? void 0 : preload2());
           WorkerBody.postMessage("done", {});
           break;
         case "process":
           throwIfAborted();
+          validateOutputOwnership((_b2 = payload.options) == null ? void 0 : _b2["outputOwnership"]);
           if (!process2) {
             throw new Error("Worker does not support atomic processing");
           }
@@ -7993,10 +8009,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":
           throwIfAborted();
+          validateOutputOwnership((_d2 = payload.options) == null ? void 0 : _d2["outputOwnership"]);
           if (!processInBatches) {
             throw new Error("Worker does not support batched processing");
           }
@@ -8008,7 +8025,7 @@ async function createWorker(process2, processInBatches) {
             const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
             for await (const batch of resultIterator) {
               throwIfAborted();
-              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();
             }
             throwIfAborted();
@@ -8106,14 +8123,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 {
@@ -8121,9 +8138,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);
@@ -8132,7 +8149,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;
     }
@@ -8140,10 +8157,11 @@ function createProgressReporter() {
 }
 var requestId, activeController, activeInputBatches, activeOutputAcknowledgements;
 var init_create_worker = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js"() {
     init_shared_state();
     init_async_queue();
     init_worker_body();
+    init_validate_output_ownership();
     requestId = 0;
     activeController = null;
     activeInputBatches = null;
@@ -8151,29 +8169,619 @@ var init_create_worker = __esm({
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
 var import_meta3, path3, moduleUrl;
 var init_worker_utils = __esm({
-  "../../node_modules/@math.gl/core/dist/worker-utils/index.js"() {
+  "../../node_modules/@math.gl/tasks/dist/worker-utils/index.js"() {
+    init_worker_body();
     init_create_worker();
+    init_get_transfer_list();
     import_meta3 = {};
     path3 = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
     moduleUrl = path3 ? `file://${path3.startsWith("/") ? "" : "/"}${encodeURI(path3).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta3.url;
   }
 });
 
-// ../../node_modules/@math.gl/core/dist/tasks/index.js
-var init_tasks = __esm({
-  "../../node_modules/@math.gl/core/dist/tasks/index.js"() {
+// ../../node_modules/@math.gl/tasks/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/tasks/dist/tasks/task-preload.js"() {
+    pending = /* @__PURE__ */ new WeakMap();
+    loaded = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js
+var TaskRequestError, TaskChannel;
+var init_task_channel = __esm({
+  "../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js"() {
+    TaskRequestError = class extends Error {
+    };
+    TaskChannel = class {
+      constructor(options) {
+        this.options = options;
+        this.nextId = 1;
+        this.pending = /* @__PURE__ */ new Map();
+        this.incoming = /* @__PURE__ */ new Map();
+      }
+      /** Send a request without serializing other in-flight requests. */
+      request(operation, value, signal, transfer = []) {
+        if (this.failure)
+          return Promise.reject(this.failure.reason);
+        if (signal == null ? void 0 : signal.aborted)
+          return Promise.reject(signal.reason);
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+          const abort = () => {
+            const pending2 = this.pending.get(id);
+            if (!pending2)
+              return;
+            this.pending.delete(id);
+            pending2.cleanup();
+            reject(signal == null ? void 0 : signal.reason);
+            this.send({ source: "math.gl/tasks", kind: "cancel", id });
+          };
+          this.pending.set(id, {
+            resolve,
+            reject,
+            cleanup: () => signal == null ? void 0 : signal.removeEventListener("abort", abort)
+          });
+          signal == null ? void 0 : signal.addEventListener("abort", abort, { once: true });
+          this.send({ source: "math.gl/tasks", kind: "request", id, operation, value }, transfer);
+        });
+      }
+      /** Send a one-way notification. */
+      emit(operation, value, transfer = []) {
+        if (this.failure)
+          throw this.failure.reason;
+        this.send({ source: "math.gl/tasks", kind: "event", id: 0, operation, value }, transfer);
+      }
+      /** Dispatch a transport message; unrelated protocols are ignored. */
+      receive(message) {
+        var _a5, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
+        if (this.failure || (message == null ? void 0 : message.source) !== "math.gl/tasks")
+          return;
+        if (message.kind === "failure") {
+          const reason = new Error(((_a5 = message.error) == null ? void 0 : _a5.message) ?? "Task channel failed");
+          this.close(reason);
+          (_c2 = (_b2 = this.options).onFailure) == null ? void 0 : _c2.call(_b2, reason);
+        } else if (message.kind === "result" || message.kind === "error") {
+          const pending2 = this.pending.get(message.id);
+          if (!pending2)
+            return;
+          this.pending.delete(message.id);
+          pending2.cleanup();
+          if (message.kind === "result")
+            pending2.resolve(message.value);
+          else {
+            const error = new TaskRequestError(((_d2 = message.error) == null ? void 0 : _d2.message) ?? "Task request failed");
+            error.name = ((_e2 = message.error) == null ? void 0 : _e2.name) ?? "Error";
+            pending2.reject(error);
+          }
+        } else if (message.kind === "cancel") {
+          (_f2 = this.incoming.get(message.id)) == null ? void 0 : _f2.abort(new DOMException("Task request cancelled", "AbortError"));
+        } else if (message.kind === "event") {
+          try {
+            (_h2 = (_g2 = this.options).handleEvent) == null ? void 0 : _h2.call(_g2, message.operation, message.value);
+          } catch (error) {
+            this.fail(error);
+          }
+        } else if (message.kind === "request") {
+          if (this.incoming.has(message.id)) {
+            this.fail(new Error("Duplicate task request identifier"));
+            return;
+          }
+          const controller = new AbortController();
+          this.incoming.set(message.id, controller);
+          void Promise.resolve().then(() => {
+            controller.signal.throwIfAborted();
+            return this.options.handleRequest(message.operation, message.value, controller.signal);
+          }).then((value) => {
+            var _a6, _b3;
+            if (!controller.signal.aborted && !this.failure) {
+              this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, (_b3 = (_a6 = this.options).getResultTransferList) == null ? void 0 : _b3.call(_a6, value, message.value));
+            }
+          }).catch((reason) => {
+            if (!controller.signal.aborted && !this.failure) {
+              this.send({
+                source: "math.gl/tasks",
+                kind: "error",
+                id: message.id,
+                error: {
+                  name: reason instanceof Error ? reason.name : "Error",
+                  message: reason instanceof Error ? reason.message : String(reason)
+                }
+              });
+            }
+          }).finally(() => this.incoming.delete(message.id));
+        }
+      }
+      /** Reject all outstanding calls with a common cause and abort incoming callbacks. */
+      close(reason = new Error("Task channel closed")) {
+        if (this.failure)
+          return;
+        this.failure = { reason };
+        for (const pending2 of this.pending.values()) {
+          pending2.cleanup();
+          pending2.reject(reason);
+        }
+        this.pending.clear();
+        for (const controller of this.incoming.values())
+          controller.abort(reason);
+        this.incoming.clear();
+      }
+      send(message, transfer = []) {
+        if (this.failure)
+          return;
+        try {
+          this.options.send(message, transfer);
+        } catch (error) {
+          this.fail(error);
+        }
+      }
+      /** Invalidate the channel and notify the peer when the transport still works. */
+      fail(reason) {
+        var _a5, _b2;
+        if (this.failure)
+          return;
+        this.close(reason);
+        try {
+          this.options.send({
+            source: "math.gl/tasks",
+            kind: "failure",
+            id: 0,
+            error: {
+              name: reason instanceof Error ? reason.name : "Error",
+              message: reason instanceof Error ? reason.message : String(reason)
+            }
+          }, []);
+        } catch {
+        }
+        (_b2 = (_a5 = this.options).onFailure) == null ? void 0 : _b2.call(_a5, reason);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-runtime.js
+function assertPayload(value) {
+  if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new TypeError("Task payloads must be plain objects with named fields");
+  }
+}
+function clonePayload(value, ownership = "copy") {
+  assertPayload(value);
+  if (!["copy", "transfer", "share"].includes(ownership))
+    throw new TypeError("Invalid input ownership");
+  const transfer = getTransferList(value);
+  if (ownership === "share" && transfer.length)
+    throw new TypeError("Share requires shared storage");
+  return structuredClone(value, {
+    transfer: ownership === "transfer" ? transfer : []
+  });
+}
+function taskContext(state, context = {}) {
+  const signal = context.signal ?? new AbortController().signal;
+  return {
+    state,
+    signal,
+    requestHost: async (operation, payload, controls) => {
+      signal.throwIfAborted();
+      if (!context.requestHost)
+        throw new Error("No host request handler configured");
+      return context.requestHost(operation, payload, controls);
+    },
+    emitHost: (operation, payload) => {
+      var _a5;
+      signal.throwIfAborted();
+      (_a5 = context.emitHost) == null ? void 0 : _a5.call(context, operation, payload);
+    },
+    throwIfAborted: () => {
+      var _a5;
+      signal.throwIfAborted();
+      (_a5 = context.throwIfAborted) == null ? void 0 : _a5.call(context);
+    },
+    reportProgress: (progress) => {
+      var _a5;
+      return (_a5 = context.reportProgress) == null ? void 0 : _a5.call(context, {
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      });
+    }
+  };
+}
+async function initializeTaskWorker(task) {
+  if (!await WorkerBody.inWorkerThread())
+    throw new Error("initializeTaskWorker must run inside a worker");
+  if (installed)
+    throw new Error("A task is already installed in this worker");
+  installed = true;
+  const runtime = new TaskRuntime(task);
+  let channelStream;
+  const channel = new TaskChannel({
+    getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+    send: (message, transfer) => {
+      const snapshot = structuredClone(message, { transfer });
+      void WorkerBody.postMessage("task-channel", snapshot).catch((reason) => channel.fail(reason));
+    },
+    handleRequest: async (operation, value, signal) => {
+      var _a5;
+      const request = value;
+      const context = {
+        signal,
+        reportProgress: (progress) => channel.emit("task:progress", { id: request.progressId, progress }),
+        requestHost: (operation2, payload, controls = {}) => {
+          const request2 = {
+            operation: operation2,
+            payload: clonePayload(payload, controls.inputOwnership),
+            outputOwnership: controls.outputOwnership ?? "copy"
+          };
+          return channel.request("task:host-request", request2, signal, getTransferList(request2));
+        },
+        emitHost: (operation2, payload) => channel.emit("task:host-event", { operation: operation2, payload, id: request.progressId })
+      };
+      switch (operation) {
+        case "initialize":
+          return runtime.initialize(request.input, context);
+        case "process":
+          return runtime.process(request.input, request.options, context);
+        case "stream-open": {
+          if (channelStream)
+            throw new Error("A task stream is already open");
+          async function* inputs() {
+            while (true) {
+              const result = await channel.request("task:next-input", { outputOwnership: "transfer" }, signal);
+              if (result.done)
+                return;
+              yield result.value;
+            }
+          }
+          channelStream = runtime.stream(inputs(), request.options, context)[Symbol.asyncIterator]();
+          return {};
+        }
+        case "stream-next":
+          if (!channelStream)
+            throw new Error("No active task stream");
+          return channelStream.next();
+        case "stream-close":
+          try {
+            await ((_a5 = channelStream == null ? void 0 : channelStream.return) == null ? void 0 : _a5.call(channelStream));
+          } finally {
+            channelStream = void 0;
+          }
+          return {};
+        case "destroy":
+          return runtime.destroy();
+        default:
+          throw new Error("Unknown task channel operation");
+      }
+    }
+  });
+  await WorkerBody.addEventListener((type, payload) => {
+    if (type === "task-channel")
+      channel.receive(payload);
+  });
+  let streamOptions = {};
+  return createWorker(async (request, _options, context) => {
+    switch (request.operation) {
+      case "initialize":
+        return runtime.initialize(request.input, context);
+      case "destroy":
+        return runtime.destroy();
+      case "stream-options":
+        streamOptions = request.options;
+        return {};
+      case "process":
+        return runtime.process(request.input, request.options, context);
+      default:
+        throw new Error("Unknown task operation");
+    }
+  }, async function* (inputs, _options, context) {
+    async function* batches() {
+      for await (const input of inputs) {
+        assertPayload(input);
+        yield input;
+      }
+    }
+    try {
+      yield* runtime.stream(batches(), streamOptions, context);
+    } finally {
+      streamOptions = {};
+    }
+  }, () => preloadTaskCode(task));
+}
+var TaskRuntime, installed;
+var init_task_runtime = __esm({
+  "../../node_modules/@math.gl/tasks/dist/tasks/task-runtime.js"() {
     init_worker_utils();
+    init_task_preload();
+    init_task_channel();
+    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;
+        }
+      }
+    };
+    installed = false;
+  }
+});
+
+// ../../node_modules/@math.gl/tasks/dist/tasks/index.js
+var init_tasks = __esm({
+  "../../node_modules/@math.gl/tasks/dist/tasks/index.js"() {
+    init_task_runtime();
+  }
+});
+
+// ../../node_modules/@math.gl/tasks/dist/index.js
+var init_dist2 = __esm({
+  "../../node_modules/@math.gl/tasks/dist/index.js"() {
+    init_tasks();
+  }
+});
+
+// ../core/src/worker-utils/lib/node/worker_threads.ts
+var worker_threads_exports = {};
+__export(worker_threads_exports, {
+  BroadcastChannel: () => import_worker_threads3.BroadcastChannel,
+  MessageChannel: () => import_worker_threads3.MessageChannel,
+  MessagePort: () => import_worker_threads3.MessagePort,
+  NodeWorker: () => NodeWorker,
+  SHARE_ENV: () => import_worker_threads3.SHARE_ENV,
+  Worker: () => import_worker_threads3.Worker,
+  getEnvironmentData: () => import_worker_threads3.getEnvironmentData,
+  isInternalThread: () => isInternalThread2,
+  isMainThread: () => import_worker_threads3.isMainThread,
+  isMarkedAsUntransferable: () => import_worker_threads3.isMarkedAsUntransferable,
+  locks: () => locks2,
+  markAsUncloneable: () => import_worker_threads3.markAsUncloneable,
+  markAsUntransferable: () => import_worker_threads3.markAsUntransferable,
+  moveMessagePortToContext: () => import_worker_threads3.moveMessagePortToContext,
+  parentPort: () => parentPort2,
+  postMessageToThread: () => import_worker_threads3.postMessageToThread,
+  receiveMessageOnPort: () => import_worker_threads3.receiveMessageOnPort,
+  resourceLimits: () => import_worker_threads3.resourceLimits,
+  setEnvironmentData: () => import_worker_threads3.setEnvironmentData,
+  structuredClone: () => structuredClone3,
+  threadId: () => import_worker_threads3.threadId,
+  threadName: () => threadName2,
+  workerData: () => import_worker_threads3.workerData
+});
+var WorkerThreads, import_worker_threads3, parentPort2, NodeWorker, isInternalThread2, threadName2, locks2, structuredClone3;
+var init_worker_threads2 = __esm({
+  "../core/src/worker-utils/lib/node/worker_threads.ts"() {
+    "use strict";
+    WorkerThreads = __toESM(require("worker_threads"), 1);
+    import_worker_threads3 = require("worker_threads");
+    parentPort2 = WorkerThreads == null ? void 0 : WorkerThreads.parentPort;
+    NodeWorker = WorkerThreads.Worker;
+    isInternalThread2 = WorkerThreads.isInternalThread;
+    threadName2 = WorkerThreads.threadName;
+    locks2 = WorkerThreads.locks;
+    structuredClone3 = WorkerThreads.structuredClone;
+  }
+});
+
+// ../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_threads2(), worker_threads_exports));
+    return !isMainThread2;
+  }
+  return false;
+}
+var initializeTaskWorker2;
+var init_task_runtime2 = __esm({
+  "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
+    "use strict";
+    init_dist2();
+    initializeTaskWorker2 = initializeTaskWorker;
+  }
+});
+
+// ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+function getTransferList2(object2, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object2) {
+  } else if (isTransferable2(object2)) {
+    transfersSet.add(object2);
+  } else if (isTransferable2(object2.buffer)) {
+    transfersSet.add(object2.buffer);
+  } else if (ArrayBuffer.isView(object2)) {
+  } else if (recursive && typeof object2 === "object") {
+    for (const key in object2) {
+      getTransferList2(object2[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable2(object2) {
+  if (!object2) {
+    return false;
+  }
+  if (object2 instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object2 instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object2 instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object2 instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+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) => {
+      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 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_tasks();
+    init_task_runtime2();
+    init_get_transfer_list2();
   }
 });
 
@@ -8352,7 +8960,7 @@ var init_worker_utils2 = __esm({
 
 // ../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,
@@ -8607,7 +9215,7 @@ var init_vec42 = __esm({
 });
 
 // ../../node_modules/@math.gl/core/dist/index.js
-var init_dist2 = __esm({
+var init_dist3 = __esm({
   "../../node_modules/@math.gl/core/dist/index.js"() {
     init_math_utils();
     init_types2();
@@ -16394,11 +17002,11 @@ var init_builder = __esm({
         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)) {
@@ -16421,12 +17029,12 @@ var init_builder = __esm({
         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;
       }
@@ -19012,11 +19620,11 @@ var init_binary2 = __esm({
       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 {
@@ -19053,11 +19661,11 @@ var init_largebinary = __esm({
       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 {
@@ -19368,10 +19976,10 @@ var init_list2 = __esm({
         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 {
@@ -19410,10 +20018,10 @@ var init_largelist = __esm({
         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 {
@@ -19443,11 +20051,11 @@ var init_map3 = __esm({
       }
       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) {
@@ -19457,10 +20065,10 @@ var init_map3 = __esm({
         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 {
@@ -19669,7 +20277,7 @@ var init_utf83 = __esm({
         return super.setValue(index2, encodeUtf8(value));
       }
       // @ts-ignore
-      _flushPending(pending, pendingLength) {
+      _flushPending(pending2, pendingLength) {
       }
     };
     Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -19700,7 +20308,7 @@ var init_largeutf8 = __esm({
         return super.setValue(index2, encodeUtf8(value));
       }
       // @ts-ignore
-      _flushPending(pending, pendingLength) {
+      _flushPending(pending2, pendingLength) {
       }
     };
     LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -23962,12 +24570,6 @@ function serializeArrowSchema(arrowSchema) {
     metadata: serializeArrowMetadata(arrowSchema.metadata)
   };
 }
-function deserializeArrowSchema(schema, options) {
-  return new Schema2(
-    schema.fields.map((field) => deserializeArrowField(field, options)),
-    deserializeArrowMetadata(schema.metadata)
-  );
-}
 function serializeArrowMetadata(arrowMetadata) {
   return Object.fromEntries(arrowMetadata);
 }
@@ -24436,7 +25038,7 @@ function getFloat16Storage(array) {
 var init_float162 = __esm({
   "../core/src/schema/float16.ts"() {
     "use strict";
-    init_dist2();
+    init_dist3();
   }
 });
 
@@ -25657,7 +26259,29 @@ var init_draco_module_loader = __esm({
   }
 });
 
-// ../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts
+// ../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js
+function getArrowVariadicBuffers(data) {
+  return data.variadicBuffers ?? [];
+}
+function createArrowData(type, offset, length, nullCount, buffers, children, dictionary, variadicBuffers) {
+  return Reflect.construct(Data, [
+    type,
+    offset,
+    length,
+    nullCount,
+    buffers,
+    children,
+    dictionary,
+    variadicBuffers
+  ]);
+}
+var init_arrow_data = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js"() {
+    init_Arrow_node();
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js
 function splitArrowBuffers(input, options = {}) {
   const context = { ...options, copies: /* @__PURE__ */ new WeakMap() };
   if (isArrowTable2(input)) {
@@ -25680,17 +26304,12 @@ function isArrowRecordBatch2(input) {
 function isArrowVector2(input) {
   return "data" in input && Array.isArray(input.data);
 }
-function splitArrowTableBuffersInternal(table, options) {
-  const recordBatches = table.batches.map(
-    (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
-  );
-  return new Table(table.schema, recordBatches);
+function splitArrowTableBuffersInternal(arrowTable, options) {
+  const recordBatches = arrowTable.batches.map((recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options));
+  return new Table(arrowTable.schema, recordBatches);
 }
 function splitArrowRecordBatchBuffers(recordBatch, options) {
-  return new RecordBatch3(
-    recordBatch.schema,
-    splitArrowDataBuffers(recordBatch.data, options)
-  );
+  return new RecordBatch3(recordBatch.schema, splitArrowDataBuffers(recordBatch.data, options));
 }
 function splitArrowDataBuffers(data, options) {
   const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
@@ -25701,7 +26320,7 @@ function splitArrowDataBuffers(data, options) {
     [BufferType.VALIDITY]: splitArrowBuffer(data.buffers[BufferType.VALIDITY], options),
     [BufferType.TYPE]: splitArrowBuffer(data.buffers[BufferType.TYPE], options)
   };
-  return new Data(
+  return createArrowData(
     data.type,
     data.offset,
     data.length,
@@ -25709,7 +26328,8 @@ function splitArrowDataBuffers(data, options) {
     data._nullCount,
     buffers,
     children,
-    dictionary
+    dictionary,
+    getArrowVariadicBuffers(data).map((buffer2) => splitArrowBuffer(buffer2, options))
   );
 }
 function splitArrowVectorBuffers(vector, options) {
@@ -25727,7 +26347,7 @@ function splitArrowBuffer(array, options) {
   }
   let copy = options.copies.get(array);
   if (!copy) {
-    copy = array.slice();
+    copy = array instanceof Uint8Array ? new Uint8Array(array) : array.slice();
     options.copies.set(array, copy);
   }
   return copy;
@@ -25736,29 +26356,107 @@ function isArrowTypedArray(value) {
   return ArrayBuffer.isView(value) && !(value instanceof DataView);
 }
 var init_split_arrow_buffers = __esm({
-  "../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts"() {
-    "use strict";
+  "../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js"() {
     init_Arrow_node();
+    init_arrow_data();
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js
+var init_indexed_arrow_vector = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js"() {
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js
+var init_indexed_arrow_table = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js"() {
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js
+var init_mapped_arrow_table = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js"() {
   }
 });
 
-// ../core/src/schema-utils/lib/arrow/arrow-table-transport.ts
-function dehydrateArrowTable(table, options) {
-  const splitTable = splitArrowBuffers(table, options);
+// ../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js
+var init_rename_arrow_columns = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js"() {
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/arrow-table-transport.js
+function dehydrateArrowTable(arrowTable, options) {
+  const splitTable = splitArrowBuffers(arrowTable, options);
   return {
-    shape: "arrow-table",
     transport: "arrow-js",
-    schema: serializeArrowSchema(splitTable.schema),
-    batches: splitTable.batches.map((recordBatch) => dehydrateArrowRecordBatch(recordBatch))
+    version: 1,
+    schema: tableToIPC(new Table(splitTable.schema, [])),
+    metadataVersion: splitTable.schema.metadataVersion,
+    batches: splitTable.batches.map((batch) => dehydrateArrowData(batch.data))
   };
 }
 function hydrateArrowTable(table) {
-  const schema = deserializeArrowSchema(table.schema);
-  const recordBatches = table.batches.map(
-    (recordBatch) => new RecordBatch3(schema, hydrateArrowData(recordBatch.data))
-  );
-  return new Table(schema, recordBatches);
+  if (table.transport !== "arrow-js" || table.version !== 1) {
+    throw new Error("Unsupported Arrow column-buffer transport protocol.");
+  }
+  const decodedSchema = tableFromIPC(table.schema).schema;
+  const schema = new Schema2(decodedSchema.fields, decodedSchema.metadata, decodedSchema.dictionaries, table.metadataVersion);
+  const type = new Struct(schema.fields);
+  const batches = table.batches.map((data) => new RecordBatch3(schema, hydrateArrowData(data, type)));
+  return new Table(schema, batches);
 }
+function dehydrateArrowData(data) {
+  var _a5;
+  return {
+    offset: data.offset,
+    length: data.length,
+    nullCount: data.nullCount,
+    buffers: {
+      [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
+      [BufferType.DATA]: data.buffers[BufferType.DATA],
+      [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
+      [BufferType.TYPE]: data.buffers[BufferType.TYPE]
+    },
+    children: data.children.map((child) => dehydrateArrowData(child)),
+    variadicBuffers: getArrowVariadicBuffers(data),
+    dictionary: (_a5 = data.dictionary) == null ? void 0 : _a5.data.map((chunk) => dehydrateArrowData(chunk))
+  };
+}
+function hydrateArrowData(data, type) {
+  const children = data.children.map((child, index2) => hydrateArrowData(child, type.children[index2].type));
+  const dictionary = data.dictionary && DataType.isDictionary(type) ? new Vector(data.dictionary.map((chunk) => hydrateArrowData(chunk, type.dictionary))) : void 0;
+  return createArrowData(type, data.offset, data.length, data.nullCount, data.buffers, children, dictionary, data.variadicBuffers);
+}
+var init_arrow_table_transport = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/arrow-table-transport.js"() {
+    init_Arrow_node();
+    init_arrow_data();
+    init_split_arrow_buffers();
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/index.js
+var init_arrow = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/index.js"() {
+    init_indexed_arrow_table();
+    init_indexed_arrow_vector();
+    init_mapped_arrow_table();
+    init_rename_arrow_columns();
+    init_split_arrow_buffers();
+    init_arrow_table_transport();
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/index.js
+var init_dist4 = __esm({
+  "../../node_modules/@math.gl/arrow/dist/index.js"() {
+    init_arrow();
+  }
+});
+
+// ../core/src/arrow-worker-transport.ts
 function serializeArrowWorkerResult(result, options) {
   var _a5;
   if (!isArrowTableWrapper(result)) {
@@ -25789,60 +26487,10 @@ function isDehydratedArrowTableWrapper(value) {
     table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
   );
 }
-function dehydrateArrowRecordBatch(recordBatch) {
-  return { data: dehydrateArrowData(recordBatch.data) };
-}
-function dehydrateArrowData(data) {
-  return {
-    type: serializeArrowType(data.type),
-    offset: data.offset,
-    length: data.length,
-    // @ts-expect-error _nullCount is protected. Preserve the Arrow lazy null-count state.
-    nullCount: data._nullCount,
-    buffers: {
-      [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
-      [BufferType.DATA]: data.buffers[BufferType.DATA],
-      [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
-      [BufferType.TYPE]: data.buffers[BufferType.TYPE]
-    },
-    children: data.children.map((childData) => dehydrateArrowData(childData)),
-    dictionary: data.dictionary ? dehydrateArrowVector(data.dictionary) : void 0
-  };
-}
-function dehydrateArrowVector(vector) {
-  return { data: vector.data.map((data) => dehydrateArrowData(data)) };
-}
-function hydrateArrowData(data) {
-  const children = data.children.map((childData) => hydrateArrowData(childData));
-  const dictionary = data.dictionary ? hydrateArrowVector(data.dictionary) : void 0;
-  return new Data(
-    deserializeArrowType(data.type),
-    data.offset,
-    data.length,
-    data.nullCount,
-    data.buffers,
-    children,
-    dictionary
-  );
-}
-function hydrateArrowVector(vector) {
-  return new Vector(vector.data.map((data) => hydrateArrowData(data)));
-}
-var init_arrow_table_transport = __esm({
-  "../core/src/schema-utils/lib/arrow/arrow-table-transport.ts"() {
+var init_arrow_worker_transport = __esm({
+  "../core/src/arrow-worker-transport.ts"() {
     "use strict";
-    init_Arrow_node();
-    init_convert_arrow_schema();
-    init_split_arrow_buffers();
-  }
-});
-
-// ../core/src/schema-utils/arrow-transport.ts
-var init_arrow_transport = __esm({
-  "../core/src/schema-utils/arrow-transport.ts"() {
-    "use strict";
-    init_arrow_table_transport();
-    init_split_arrow_buffers();
+    init_dist4();
   }
 });
 
@@ -25851,7 +26499,7 @@ var VERSION2;
 var init_version2 = __esm({
   "src/draco/lib/utils/version.ts"() {
     "use strict";
-    VERSION2 = true ? "5.0.0-beta.2" : "latest";
+    VERSION2 = true ? "5.0.0-beta.5" : "latest";
   }
 });
 
@@ -26037,7 +26685,7 @@ var DracoLoader;
 var init_draco_loader_types = __esm({
   "src/draco/draco-loader-types.ts"() {
     "use strict";
-    init_arrow_transport();
+    init_arrow_worker_transport();
     init_version2();
     init_draco_format();
     init_draco_loader_options();