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

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.4";
+  const version2 = false ? NPM_TAG : "5.0.0-beta.6";
   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();
@@ -7726,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;
 }
@@ -7743,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();
@@ -7824,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 = [];
@@ -7896,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)
@@ -7940,18 +7940,18 @@ var init_shared_state = __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
 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;
@@ -8157,7 +8157,7 @@ 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();
@@ -8169,19 +8169,20 @@ 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/task-preload.js
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js
 function preloadTaskCode(task, signal) {
   if (!task.preload)
     return Promise.resolve();
@@ -8217,23 +8218,197 @@ function withSignal(operation, signal) {
 }
 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 == 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();
@@ -8256,6 +8431,70 @@ async function initializeTaskWorker(task) {
     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) {
@@ -8287,9 +8526,10 @@ async function initializeTaskWorker(task) {
 }
 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;
@@ -8342,13 +8582,20 @@ var init_task_runtime = __esm({
   }
 });
 
-// ../../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_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, {
@@ -8409,7 +8656,7 @@ var initializeTaskWorker2;
 var init_task_runtime2 = __esm({
   "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
     "use strict";
-    init_tasks();
+    init_dist2();
     initializeTaskWorker2 = initializeTaskWorker;
   }
 });
@@ -8642,6 +8889,7 @@ async function loadLibraryInWorker(libraryUrl, moduleLibraryUrl = libraryUrl) {
   } catch {
     const moduleUrl2 = new URL(moduleLibraryUrl, globalThis.location.href).href;
     const library = await import(
+      /* webpackIgnore: true */
       /* @vite-ignore */
       moduleUrl2
     );
@@ -8968,7 +9216,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();
@@ -24323,12 +24571,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);
 }
@@ -24797,7 +25039,7 @@ function getFloat16Storage(array) {
 var init_float162 = __esm({
   "../core/src/schema/float16.ts"() {
     "use strict";
-    init_dist2();
+    init_dist3();
   }
 });
 
@@ -26018,7 +26260,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)) {
@@ -26041,17 +26305,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));
@@ -26062,7 +26321,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,
@@ -26070,7 +26329,8 @@ function splitArrowDataBuffers(data, options) {
     data._nullCount,
     buffers,
     children,
-    dictionary
+    dictionary,
+    getArrowVariadicBuffers(data).map((buffer2) => splitArrowBuffer(buffer2, options))
   );
 }
 function splitArrowVectorBuffers(vector, options) {
@@ -26088,7 +26348,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;
@@ -26097,29 +26357,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"() {
   }
 });
 
-// ../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/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 {
-    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)) {
@@ -26150,60 +26488,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"() {
-    "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"() {
+var init_arrow_worker_transport = __esm({
+  "../core/src/arrow-worker-transport.ts"() {
     "use strict";
-    init_arrow_table_transport();
-    init_split_arrow_buffers();
+    init_dist4();
   }
 });
 
@@ -26212,7 +26500,7 @@ var VERSION2;
 var init_version2 = __esm({
   "src/draco/lib/utils/version.ts"() {
     "use strict";
-    VERSION2 = true ? "5.0.0-beta.4" : "latest";
+    VERSION2 = true ? "5.0.0-beta.6" : "latest";
   }
 });
 
@@ -26398,7 +26686,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();