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

package/dist/obj-worker.js

@@ -15,15 +15,15 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js
   var parentPort;
   var init_worker_threads_browser = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js"() {
       parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
@@ -74,11 +74,11 @@
     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;
   }
@@ -91,7 +91,7 @@
   }
   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_browser();
       onMessageWrapperMap = /* @__PURE__ */ new Map();
@@ -172,10 +172,10 @@
     }
   });
 
-  // ../../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 = [];
@@ -244,10 +244,10 @@
     }
   });
 
-  // ../../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(buffer) {
           if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
@@ -288,18 +288,18 @@
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js
   function validateOutputOwnership(ownership) {
     if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
       throw new Error("Invalid worker output ownership");
     }
   }
   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/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
     }
   });
 
-  // ../../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
   async function createWorker(process2, processInBatches, preload2) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
@@ -504,7 +504,7 @@
   }
   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();
@@ -516,19 +516,20 @@
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  // ../../node_modules/@math.gl/tasks/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"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/index.js"() {
       init_worker_body();
       init_create_worker();
+      init_get_transfer_list();
       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
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js
   function preloadTaskCode(task, signal) {
     if (!task.preload)
       return Promise.resolve();
@@ -564,23 +565,193 @@
   }
   var pending, loaded;
   var init_task_preload = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/task-preload.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js"() {
       pending = /* @__PURE__ */ new WeakMap();
       loaded = /* @__PURE__ */ new WeakSet();
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+  // ../../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?.aborted)
+            return Promise.reject(signal.reason);
+          const id = this.nextId++;
+          return new Promise((resolve, reject) => {
+            const abort = () => {
+              const pending2 = this.pending.get(id);
+              if (!pending2)
+                return;
+              this.pending.delete(id);
+              pending2.cleanup();
+              reject(signal?.reason);
+              this.send({ source: "math.gl/tasks", kind: "cancel", id });
+            };
+            this.pending.set(id, {
+              resolve,
+              reject,
+              cleanup: () => signal?.removeEventListener("abort", abort)
+            });
+            signal?.addEventListener("abort", abort, { once: true });
+            this.send({ source: "math.gl/tasks", kind: "request", id, operation, value }, transfer);
+          });
+        }
+        /** 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) {
+          if (this.failure || message?.source !== "math.gl/tasks")
+            return;
+          if (message.kind === "failure") {
+            const reason = new Error(message.error?.message ?? "Task channel failed");
+            this.close(reason);
+            this.options.onFailure?.(reason);
+          } else if (message.kind === "result" || message.kind === "error") {
+            const pending2 = this.pending.get(message.id);
+            if (!pending2)
+              return;
+            this.pending.delete(message.id);
+            pending2.cleanup();
+            if (message.kind === "result")
+              pending2.resolve(message.value);
+            else {
+              const error = new TaskRequestError(message.error?.message ?? "Task request failed");
+              error.name = message.error?.name ?? "Error";
+              pending2.reject(error);
+            }
+          } else if (message.kind === "cancel") {
+            this.incoming.get(message.id)?.abort(new DOMException("Task request cancelled", "AbortError"));
+          } else if (message.kind === "event") {
+            try {
+              this.options.handleEvent?.(message.operation, message.value);
+            } catch (error) {
+              this.fail(error);
+            }
+          } else if (message.kind === "request") {
+            if (this.incoming.has(message.id)) {
+              this.fail(new Error("Duplicate task request identifier"));
+              return;
+            }
+            const controller = new AbortController();
+            this.incoming.set(message.id, controller);
+            void Promise.resolve().then(() => {
+              controller.signal.throwIfAborted();
+              return this.options.handleRequest(message.operation, message.value, controller.signal);
+            }).then((value) => {
+              if (!controller.signal.aborted && !this.failure) {
+                this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, this.options.getResultTransferList?.(value, message.value));
+              }
+            }).catch((reason) => {
+              if (!controller.signal.aborted && !this.failure) {
+                this.send({
+                  source: "math.gl/tasks",
+                  kind: "error",
+                  id: message.id,
+                  error: {
+                    name: reason instanceof Error ? reason.name : "Error",
+                    message: reason instanceof Error ? reason.message : String(reason)
+                  }
+                });
+              }
+            }).finally(() => this.incoming.delete(message.id));
+          }
+        }
+        /** 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) {
+          if (this.failure)
+            return;
+          this.close(reason);
+          try {
+            this.options.send({
+              source: "math.gl/tasks",
+              kind: "failure",
+              id: 0,
+              error: {
+                name: reason instanceof Error ? reason.name : "Error",
+                message: reason instanceof Error ? reason.message : String(reason)
+              }
+            }, []);
+          } catch {
+          }
+          this.options.onFailure?.(reason);
+        }
+      };
+    }
+  });
+
+  // ../../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) => {
+        signal.throwIfAborted();
+        context.emitHost?.(operation, payload);
+      },
       throwIfAborted: () => {
         signal.throwIfAborted();
         context.throwIfAborted?.();
@@ -599,6 +770,69 @@
       throw new Error("A task is already installed in this worker");
     installed = true;
     const runtime = new TaskRuntime(task);
+    let channelStream;
+    const channel = new TaskChannel({
+      getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+      send: (message, transfer) => {
+        const snapshot = structuredClone(message, { transfer });
+        void WorkerBody.postMessage("task-channel", snapshot).catch((reason) => channel.fail(reason));
+      },
+      handleRequest: async (operation, value, signal) => {
+        const request = value;
+        const context = {
+          signal,
+          reportProgress: (progress) => channel.emit("task:progress", { id: request.progressId, progress }),
+          requestHost: (operation2, payload, controls = {}) => {
+            const request2 = {
+              operation: operation2,
+              payload: clonePayload(payload, controls.inputOwnership),
+              outputOwnership: controls.outputOwnership ?? "copy"
+            };
+            return channel.request("task:host-request", request2, signal, getTransferList(request2));
+          },
+          emitHost: (operation2, payload) => channel.emit("task:host-event", { operation: operation2, payload, id: request.progressId })
+        };
+        switch (operation) {
+          case "initialize":
+            return runtime.initialize(request.input, context);
+          case "process":
+            return runtime.process(request.input, request.options, context);
+          case "stream-open": {
+            if (channelStream)
+              throw new Error("A task stream is already open");
+            async function* inputs() {
+              while (true) {
+                const result = await channel.request("task:next-input", { outputOwnership: "transfer" }, signal);
+                if (result.done)
+                  return;
+                yield result.value;
+              }
+            }
+            channelStream = runtime.stream(inputs(), request.options, context)[Symbol.asyncIterator]();
+            return {};
+          }
+          case "stream-next":
+            if (!channelStream)
+              throw new Error("No active task stream");
+            return channelStream.next();
+          case "stream-close":
+            try {
+              await channelStream?.return?.();
+            } finally {
+              channelStream = void 0;
+            }
+            return {};
+          case "destroy":
+            return runtime.destroy();
+          default:
+            throw new Error("Unknown task channel operation");
+        }
+      }
+    });
+    await WorkerBody.addEventListener((type, payload) => {
+      if (type === "task-channel")
+        channel.receive(payload);
+    });
     let streamOptions = {};
     return createWorker(async (request, _options, context) => {
       switch (request.operation) {
@@ -630,9 +864,10 @@
   }
   var TaskRuntime, installed;
   var init_task_runtime = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/task-runtime.js"() {
+    "../../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;
@@ -683,13 +918,20 @@
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/index.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/index.js
   var init_tasks = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/index.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/index.js"() {
       init_task_runtime();
     }
   });
 
+  // ../../node_modules/@math.gl/tasks/dist/index.js
+  var init_dist = __esm({
+    "../../node_modules/@math.gl/tasks/dist/index.js"() {
+      init_tasks();
+    }
+  });
+
   // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
   var worker_threads_browser_exports = {};
   __export(worker_threads_browser_exports, {
@@ -734,7 +976,7 @@
   var init_task_runtime2 = __esm({
     "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
       "use strict";
-      init_tasks();
+      init_dist();
       initializeTaskWorker2 = initializeTaskWorker;
     }
   });
@@ -1221,7 +1463,7 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/index.js
-  var init_dist = __esm({
+  var init_dist2 = __esm({
     "../../node_modules/@math.gl/core/dist/index.js"() {
       init_math_utils();
       init_types2();
@@ -16145,6 +16387,304 @@ return true;`);
     }
   });
 
+  // ../../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_dom();
+    }
+  });
+
+  // ../../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)) {
+      return splitArrowTableBuffersInternal(input, context);
+    }
+    if (isArrowRecordBatch2(input)) {
+      return splitArrowRecordBatchBuffers(input, context);
+    }
+    if (isArrowVector2(input)) {
+      return splitArrowVectorBuffers(input, context);
+    }
+    return splitArrowDataBuffers(input, context);
+  }
+  function isArrowTable2(input) {
+    return "batches" in input;
+  }
+  function isArrowRecordBatch2(input) {
+    return "schema" in input && "data" in input && !Array.isArray(input.data);
+  }
+  function isArrowVector2(input) {
+    return "data" in input && Array.isArray(input.data);
+  }
+  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));
+  }
+  function splitArrowDataBuffers(data, options) {
+    const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
+    const dictionary = data.dictionary ? splitArrowVectorBuffers(data.dictionary, options) : void 0;
+    const buffers = {
+      [BufferType.OFFSET]: splitArrowBuffer(data.buffers[BufferType.OFFSET], options),
+      [BufferType.DATA]: splitArrowBuffer(data.buffers[BufferType.DATA], options),
+      [BufferType.VALIDITY]: splitArrowBuffer(data.buffers[BufferType.VALIDITY], options),
+      [BufferType.TYPE]: splitArrowBuffer(data.buffers[BufferType.TYPE], options)
+    };
+    return createArrowData(
+      data.type,
+      data.offset,
+      data.length,
+      // @ts-expect-error _nullCount is protected. Reuse it to preserve lazy null-count state.
+      data._nullCount,
+      buffers,
+      children,
+      dictionary,
+      getArrowVariadicBuffers(data).map((buffer) => splitArrowBuffer(buffer, options))
+    );
+  }
+  function splitArrowVectorBuffers(vector, options) {
+    return new Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
+  }
+  function splitArrowBuffer(array, options) {
+    if (!isArrowTypedArray(array)) {
+      return array;
+    }
+    if (options.copy === "none") {
+      return array;
+    }
+    if (options.copy !== "all" && array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {
+      return array;
+    }
+    let copy = options.copies.get(array);
+    if (!copy) {
+      copy = array instanceof Uint8Array ? new Uint8Array(array) : array.slice();
+      options.copies.set(array, copy);
+    }
+    return copy;
+  }
+  function isArrowTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  var init_split_arrow_buffers = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js"() {
+      init_Arrow_dom();
+      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"() {
+    }
+  });
+
+  // ../../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 {
+      transport: "arrow-js",
+      version: 1,
+      schema: tableToIPC(new Table(splitTable.schema, [])),
+      metadataVersion: splitTable.schema.metadataVersion,
+      batches: splitTable.batches.map((batch) => dehydrateArrowData(batch.data))
+    };
+  }
+  function hydrateArrowTable(table) {
+    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) {
+    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: data.dictionary?.data.map((chunk) => dehydrateArrowData(chunk))
+    };
+  }
+  function hydrateArrowData(data, type) {
+    const children = data.children.map((child, index) => hydrateArrowData(child, type.children[index].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_dom();
+      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_dist3 = __esm({
+    "../../node_modules/@math.gl/arrow/dist/index.js"() {
+      init_arrow();
+    }
+  });
+
+  // ../core/src/arrow-worker-transport.ts
+  function serializeArrowWorkerTable(result) {
+    if (!isArrowTableWrapper(result)) {
+      throw new Error("Workers require Arrow table output");
+    }
+    const { data, ...metadata } = result;
+    return {
+      ...structuredClone(metadata),
+      data: dehydrateArrowTable(data, { copy: "all" })
+    };
+  }
+  function deserializeArrowWorkerTable(result) {
+    if (!isDehydratedArrowTableWrapper(result)) {
+      throw new Error("Workers require Arrow column transport");
+    }
+    return { ...result, data: hydrateArrowTable(result.data) };
+  }
+  function isArrowTableWrapper(value) {
+    const table = value;
+    return Boolean(
+      table && table.shape === "arrow-table" && table.data && typeof table.data === "object" && "batches" in table.data
+    );
+  }
+  function isDehydratedArrowTableWrapper(value) {
+    const table = value;
+    return Boolean(
+      table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
+    );
+  }
+  var init_arrow_worker_transport = __esm({
+    "../core/src/arrow-worker-transport.ts"() {
+      "use strict";
+      init_dist3();
+    }
+  });
+
+  // ../core/src/schema-utils/lib/schema/data-type.ts
+  function getDataTypeFromValue(value, defaultNumberType = "float32") {
+    if (value instanceof Date) {
+      return "date-millisecond";
+    }
+    if (typeof value === "number") {
+      return defaultNumberType;
+    }
+    if (typeof value === "boolean") {
+      return "bool";
+    }
+    if (typeof value === "string") {
+      return "utf8";
+    }
+    if (value === null || value === "undefined") {
+      return "null";
+    }
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
+    }
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
+    }
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
+      return "float16";
+    }
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case BigInt64Array:
+        return "int64";
+      case BigUint64Array:
+        return "uint64";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+  var init_data_type = __esm({
+    "../core/src/schema-utils/lib/schema/data-type.ts"() {
+      "use strict";
+    }
+  });
+
   // ../core/src/schema-utils/lib/schema/convert-arrow-schema.ts
   function serializeArrowSchema(arrowSchema) {
     return {
@@ -16152,12 +16692,6 @@ return true;`);
       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);
   }
@@ -16580,259 +17114,6 @@ return true;`);
     }
   });
 
-  // ../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts
-  function splitArrowBuffers(input, options = {}) {
-    const context = { ...options, copies: /* @__PURE__ */ new WeakMap() };
-    if (isArrowTable2(input)) {
-      return splitArrowTableBuffersInternal(input, context);
-    }
-    if (isArrowRecordBatch2(input)) {
-      return splitArrowRecordBatchBuffers(input, context);
-    }
-    if (isArrowVector2(input)) {
-      return splitArrowVectorBuffers(input, context);
-    }
-    return splitArrowDataBuffers(input, context);
-  }
-  function isArrowTable2(input) {
-    return "batches" in input;
-  }
-  function isArrowRecordBatch2(input) {
-    return "schema" in input && "data" in input && !Array.isArray(input.data);
-  }
-  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 splitArrowRecordBatchBuffers(recordBatch, options) {
-    return new RecordBatch3(
-      recordBatch.schema,
-      splitArrowDataBuffers(recordBatch.data, options)
-    );
-  }
-  function splitArrowDataBuffers(data, options) {
-    const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
-    const dictionary = data.dictionary ? splitArrowVectorBuffers(data.dictionary, options) : void 0;
-    const buffers = {
-      [BufferType.OFFSET]: splitArrowBuffer(data.buffers[BufferType.OFFSET], options),
-      [BufferType.DATA]: splitArrowBuffer(data.buffers[BufferType.DATA], options),
-      [BufferType.VALIDITY]: splitArrowBuffer(data.buffers[BufferType.VALIDITY], options),
-      [BufferType.TYPE]: splitArrowBuffer(data.buffers[BufferType.TYPE], options)
-    };
-    return new Data(
-      data.type,
-      data.offset,
-      data.length,
-      // @ts-expect-error _nullCount is protected. Reuse it to preserve lazy null-count state.
-      data._nullCount,
-      buffers,
-      children,
-      dictionary
-    );
-  }
-  function splitArrowVectorBuffers(vector, options) {
-    return new Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
-  }
-  function splitArrowBuffer(array, options) {
-    if (!isArrowTypedArray(array)) {
-      return array;
-    }
-    if (options.copy === "none") {
-      return array;
-    }
-    if (options.copy !== "all" && array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {
-      return array;
-    }
-    let copy = options.copies.get(array);
-    if (!copy) {
-      copy = array.slice();
-      options.copies.set(array, copy);
-    }
-    return copy;
-  }
-  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";
-      init_Arrow_dom();
-    }
-  });
-
-  // ../core/src/schema-utils/lib/arrow/arrow-table-transport.ts
-  function dehydrateArrowTable(table, options) {
-    const splitTable = splitArrowBuffers(table, options);
-    return {
-      shape: "arrow-table",
-      transport: "arrow-js",
-      schema: serializeArrowSchema(splitTable.schema),
-      batches: splitTable.batches.map((recordBatch) => dehydrateArrowRecordBatch(recordBatch))
-    };
-  }
-  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);
-  }
-  function serializeArrowWorkerTable(result) {
-    if (!isArrowTableWrapper(result)) {
-      throw new Error("Workers require Arrow table output");
-    }
-    const { data, ...metadata } = result;
-    return {
-      ...structuredClone(metadata),
-      data: dehydrateArrowTable(data, { copy: "all" })
-    };
-  }
-  function deserializeArrowWorkerTable(result) {
-    if (!isDehydratedArrowTableWrapper(result)) {
-      throw new Error("Workers require Arrow column transport");
-    }
-    return { ...result, data: hydrateArrowTable(result.data) };
-  }
-  function isArrowTableWrapper(value) {
-    const table = value;
-    return Boolean(
-      table && table.shape === "arrow-table" && table.data && typeof table.data === "object" && "batches" in table.data
-    );
-  }
-  function isDehydratedArrowTableWrapper(value) {
-    const table = value;
-    return Boolean(
-      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"() {
-      "use strict";
-      init_Arrow_dom();
-      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();
-    }
-  });
-
-  // ../core/src/schema-utils/lib/schema/data-type.ts
-  function getDataTypeFromValue(value, defaultNumberType = "float32") {
-    if (value instanceof Date) {
-      return "date-millisecond";
-    }
-    if (typeof value === "number") {
-      return defaultNumberType;
-    }
-    if (typeof value === "boolean") {
-      return "bool";
-    }
-    if (typeof value === "string") {
-      return "utf8";
-    }
-    if (value === null || value === "undefined") {
-      return "null";
-    }
-    return "null";
-  }
-  function getDataTypeFromArray(array) {
-    let type = getDataTypeFromTypedArray(array);
-    if (type !== "null") {
-      return { type, nullable: false };
-    }
-    if (array.length > 0) {
-      type = getDataTypeFromValue(array[0]);
-      return { type, nullable: true };
-    }
-    return { type: "null", nullable: true };
-  }
-  function getDataTypeFromTypedArray(array) {
-    if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
-      return "float16";
-    }
-    switch (array.constructor) {
-      case Int8Array:
-        return "int8";
-      case Uint8Array:
-      case Uint8ClampedArray:
-        return "uint8";
-      case Int16Array:
-        return "int16";
-      case Uint16Array:
-        return "uint16";
-      case Int32Array:
-        return "int32";
-      case Uint32Array:
-        return "uint32";
-      case BigInt64Array:
-        return "int64";
-      case BigUint64Array:
-        return "uint64";
-      case Float32Array:
-        return "float32";
-      case Float64Array:
-        return "float64";
-      default:
-        return "null";
-    }
-  }
-  var init_data_type = __esm({
-    "../core/src/schema-utils/lib/schema/data-type.ts"() {
-      "use strict";
-    }
-  });
-
   // ../core/src/schema-utils/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     const positionAttribute = attributes?.POSITION;
@@ -16934,7 +17215,7 @@ return true;`);
   var init_float162 = __esm({
     "../core/src/schema/float16.ts"() {
       "use strict";
-      init_dist();
+      init_dist2();
     }
   });
 
@@ -17891,8 +18172,8 @@ return true;`);
     "src/obj/obj-loader-types.ts"() {
       "use strict";
       init_obj_format();
-      init_arrow_transport();
-      VERSION = true ? "5.0.0-beta.4" : "latest";
+      init_arrow_worker_transport();
+      VERSION = true ? "5.0.0-beta.6" : "latest";
       OBJLoader = {
         ...OBJFormat,
         dataType: null,
@@ -18021,7 +18302,7 @@ return true;`);
     "src/obj/obj-loader.ts"() {
       "use strict";
       init_loader_utils();
-      init_arrow_transport();
+      init_arrow_worker_transport();
       init_schema_utils();
       init_get_obj_schema();
       init_parse_obj();