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

package/dist/las-worker.js

@@ -42,10 +42,10 @@
     }
   });
 
-  // ../../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 = 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();
@@ -96,7 +96,7 @@
     return false;
   }
 
-  // ../../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;
   }
@@ -183,7 +183,7 @@
     return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
   }
 
-  // ../../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 = class {
     constructor() {
       this._values = [];
@@ -250,7 +250,7 @@
     }
   };
 
-  // ../../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 = class {
     constructor(buffer) {
       if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
@@ -289,14 +289,14 @@
     }
   };
 
-  // ../../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");
     }
   }
 
-  // ../../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
   var requestId = 0;
   var activeController = null;
   var activeInputBatches = null;
@@ -504,12 +504,12 @@
     };
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
   var import_meta = {};
   var path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
   var 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
   var pending = /* @__PURE__ */ new WeakMap();
   var loaded = /* @__PURE__ */ new WeakSet();
   function preloadTaskCode(task, signal) {
@@ -546,17 +546,182 @@
     });
   }
 
-  // ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js
+  var TaskRequestError = class extends Error {
+  };
+  var 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?.();
@@ -621,6 +786,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) {
@@ -19289,12 +19517,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);
   }
@@ -20265,7 +20487,7 @@ return true;`);
   };
 
   // src/las/las-loader-shared.ts
-  var VERSION = true ? "5.0.0-beta.4" : "latest";
+  var VERSION = true ? "5.0.0-beta.6" : "latest";
   var DEFAULT_LAS_SHAPE = "arrow-table";
   function getLASShape(options) {
     return options?.las?.shape || DEFAULT_LAS_SHAPE;
@@ -20310,7 +20532,24 @@ return true;`);
     return { ...mesh, attributes };
   }
 
-  // ../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
+    ]);
+  }
+
+  // ../../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)) {
@@ -20333,17 +20572,12 @@ return true;`);
   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));
@@ -20354,7 +20588,7 @@ return true;`);
       [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,
@@ -20362,7 +20596,8 @@ return true;`);
       data._nullCount,
       buffers,
       children,
-      dictionary
+      dictionary,
+      getArrowVariadicBuffers(data).map((buffer) => splitArrowBuffer(buffer, options))
     );
   }
   function splitArrowVectorBuffers(vector, options) {
@@ -20380,7 +20615,7 @@ return true;`);
     }
     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;
@@ -20389,23 +20624,50 @@ return true;`);
     return ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
 
-  // ../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/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) {
+    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);
+  }
+
+  // ../core/src/arrow-worker-transport.ts
   function serializeArrowWorkerTable(result) {
     if (!isArrowTableWrapper(result)) {
       throw new Error("Workers require Arrow table output");
@@ -20434,45 +20696,6 @@ return true;`);
       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)));
-  }
 
   // src/las/lib/get-las-schema.ts
   function getLASSchema(lasHeader, attributes) {

package/dist/las-writer.cjs

@@ -28,7 +28,7 @@ module.exports = __toCommonJS(las_writer_exports);
 var import_loader_utils = require("@loaders.gl/core/loader-utils");
 var import_schema_utils = require("@loaders.gl/core/schema-utils");
 var import_las_format = require("./las-format.cjs");
-var VERSION = true ? "5.0.0-beta.4" : "latest";
+var VERSION = true ? "5.0.0-beta.6" : "latest";
 var LAS_HEADER_LENGTH = 227;
 var LAS_1_4_HEADER_LENGTH = 375;
 var LAS_1_5_HEADER_LENGTH = 393;

package/dist/pcd/pcd-loader-types.cjs

@@ -35,8 +35,8 @@ __export(pcd_loader_types_exports, {
 });
 module.exports = __toCommonJS(pcd_loader_types_exports);
 var import_pcd_format = require("./pcd-format.cjs");
-var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
-var VERSION = true ? "5.0.0-beta.4" : "latest";
+var import_arrow_worker_transport = require("@loaders.gl/core/arrow-worker-transport");
+var VERSION = true ? "5.0.0-beta.6" : "latest";
 async function preload() {
   const { PCDLoaderWithParser } = await import("@loaders.gl/pointclouds/pcd-loader");
   return PCDLoaderWithParser;
@@ -49,7 +49,7 @@ var PCDLoader = {
   worker: true,
   /** Enables the stateful input/output batch protocol on the built-in worker. */
   workerInBatches: true,
-  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerResult: import_arrow_worker_transport.serializeArrowWorkerTable,
   options: {
     pcd: { shape: "arrow-table", colorFormat: "uint8norm" }
   },

package/dist/pcd/pcd-loader-types.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/pcd/pcd-loader-types.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {PCDFormat} from './pcd-format';\nimport {serializeArrowWorkerTable} from '@loaders.gl/core/schema-utils/arrow-transport';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type PCDLoaderOptions = LoaderOptions & {\n  pcd?: {\n    /** Output shape. Defaults to a Mesh Arrow table. */\n    shape?: 'mesh' | 'arrow-table';\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/**\n * Preloads the parser-bearing PCD loader implementation.\n */\nasync function preload() {\n  const {PCDLoaderWithParser} = await import('@loaders.gl/pointclouds/pcd-loader');\n  return PCDLoaderWithParser;\n}\n\n/**\n * Metadata-only worker loader for PCD - Point Cloud Data\n */\nexport const PCDLoader = {\n  ...PCDFormat,\n  dataType: null as unknown as PCDMesh | MeshArrowTable,\n  batchType: null as unknown as PCDMesh | ArrowTableBatch,\n  version: VERSION,\n  worker: true,\n  /** Enables the stateful input/output batch protocol on the built-in worker. */\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  options: {\n    pcd: {shape: 'arrow-table', colorFormat: 'uint8norm'}\n  },\n  preload\n} as const satisfies Loader<PCDMesh | MeshArrowTable, PCDMesh | ArrowTableBatch, PCDLoaderOptions>;\n\n/** @deprecated Use PCDLoader. */\nexport const PCDWorkerLoader = PCDLoader;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,wBAAwB;AACxB,6BAAwC;AAIxC,IAAM,UAAU,OAAqC,iBAAc;AAgBnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAKO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,UAAU;AAAA,EACV,WAAW;AAAA,EACX,SAAS;AAAA,EACT,QAAQ;AAAA;AAAA,EAER,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,SAAS;AAAA,IACP,KAAK,EAAC,OAAO,eAAe,aAAa,YAAW;AAAA,EACtD;AAAA,EACA;AACF;AAGO,IAAM,kBAAkB;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {PCDFormat} from './pcd-format';\nimport {serializeArrowWorkerTable} from '@loaders.gl/core/arrow-worker-transport';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type PCDLoaderOptions = LoaderOptions & {\n  pcd?: {\n    /** Output shape. Defaults to a Mesh Arrow table. */\n    shape?: 'mesh' | 'arrow-table';\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/**\n * Preloads the parser-bearing PCD loader implementation.\n */\nasync function preload() {\n  const {PCDLoaderWithParser} = await import('@loaders.gl/pointclouds/pcd-loader');\n  return PCDLoaderWithParser;\n}\n\n/**\n * Metadata-only worker loader for PCD - Point Cloud Data\n */\nexport const PCDLoader = {\n  ...PCDFormat,\n  dataType: null as unknown as PCDMesh | MeshArrowTable,\n  batchType: null as unknown as PCDMesh | ArrowTableBatch,\n  version: VERSION,\n  worker: true,\n  /** Enables the stateful input/output batch protocol on the built-in worker. */\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  options: {\n    pcd: {shape: 'arrow-table', colorFormat: 'uint8norm'}\n  },\n  preload\n} as const satisfies Loader<PCDMesh | MeshArrowTable, PCDMesh | ArrowTableBatch, PCDLoaderOptions>;\n\n/** @deprecated Use PCDLoader. */\nexport const PCDWorkerLoader = PCDLoader;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,wBAAwB;AACxB,oCAAwC;AAIxC,IAAM,UAAU,OAAqC,iBAAc;AAgBnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAKO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,UAAU;AAAA,EACV,WAAW;AAAA,EACX,SAAS;AAAA,EACT,QAAQ;AAAA;AAAA,EAER,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,SAAS;AAAA,IACP,KAAK,EAAC,OAAO,eAAe,aAAa,YAAW;AAAA,EACtD;AAAA,EACA;AACF;AAGO,IAAM,kBAAkB;",
   "names": []
 }

package/dist/pcd/pcd-loader-types.d.ts

@@ -1,7 +1,7 @@
 import type { LoaderOptions } from '@loaders.gl/core/loader-utils';
 import type { MeshArrowTable, ArrowTableBatch } from '@loaders.gl/core/schema';
 import type { PCDMesh } from "./lib/pcd-types.js";
-import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 export type PCDLoaderOptions = LoaderOptions & {
     pcd?: {
         /** Output shape. Defaults to a Mesh Arrow table. */

package/dist/pcd/pcd-loader-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader-types.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,cAAc,EAAE,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAE7C,OAAO,EAAC,yBAAyB,EAAC,MAAM,+CAA+C,CAAC;AAMxF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,oDAAoD;QACpD,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;QAC/B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,iBAAe,OAAO;;;;;;;;uBAUS,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;GARxD;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;uBAES,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAOiB,CAAC;AAEnG,iCAAiC;AACjC,eAAO,MAAM,eAAe;uBAdG,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAUzC,CAAC"}
+{"version":3,"file":"pcd-loader-types.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,cAAc,EAAE,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAE7C,OAAO,EAAC,yBAAyB,EAAC,MAAM,yCAAyC,CAAC;AAMlF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,oDAAoD;QACpD,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;QAC/B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,iBAAe,OAAO;;;;;;;;uBAUS,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;GARxD;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;uBAES,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAOiB,CAAC;AAEnG,iCAAiC;AACjC,eAAO,MAAM,eAAe;uBAdG,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAUzC,CAAC"}

package/dist/pcd/pcd-loader-types.js

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { PCDFormat } from "./pcd-format.js";
-import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-beta.4" !== 'undefined' ? "5.0.0-beta.4" : 'latest';
+const VERSION = typeof "5.0.0-beta.6" !== 'undefined' ? "5.0.0-beta.6" : 'latest';
 /**
  * Preloads the parser-bearing PCD loader implementation.
  */

package/dist/pcd/pcd-loader-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader-types.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,yBAAyB,EAAC,MAAM,+CAA+C,CAAC;AAExF,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAa5E;;GAEG;AACH,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;IACjF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,SAAS;IACZ,QAAQ,EAAE,IAA2C;IACrD,SAAS,EAAE,IAA4C;IACvD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,+EAA+E;IAC/E,eAAe,EAAE,IAAI;IACrB,qBAAqB,EAAE,yBAAyB;IAChD,OAAO,EAAE;QACP,GAAG,EAAE,EAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAC;KACtD;IACD,OAAO;CACyF,CAAC;AAEnG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}
+{"version":3,"file":"pcd-loader-types.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,yBAAyB,EAAC,MAAM,yCAAyC,CAAC;AAElF,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAa5E;;GAEG;AACH,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;IACjF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,SAAS;IACZ,QAAQ,EAAE,IAA2C;IACrD,SAAS,EAAE,IAA4C;IACvD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,+EAA+E;IAC/E,eAAe,EAAE,IAAI;IACrB,qBAAqB,EAAE,yBAAyB;IAChD,OAAO,EAAE;QACP,GAAG,EAAE,EAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAC;KACtD;IACD,OAAO;CACyF,CAAC;AAEnG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}

package/dist/pcd/pcd-loader.cjs

@@ -24,7 +24,7 @@ __export(pcd_loader_exports, {
 });
 module.exports = __toCommonJS(pcd_loader_exports);
 var import_loader_utils = require("@loaders.gl/core/loader-utils");
-var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
+var import_arrow_worker_transport = require("@loaders.gl/core/arrow-worker-transport");
 var import_schema_utils = require("@loaders.gl/core/schema-utils");
 var import_parse_pcd = require("./lib/parse-pcd.cjs");
 var import_pcd_loader_types = require("./pcd-loader-types.cjs");
@@ -52,9 +52,9 @@ var PCDLoaderWithParser = {
     }
     yield makePCDBatch((0, import_parse_pcd.parsePCD)(data, options), options);
   },
-  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerResult: import_arrow_worker_transport.serializeArrowWorkerTable,
   deserializeWorkerResult: deserializePCDWorkerResult,
-  serializeWorkerBatch: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerBatch: import_arrow_worker_transport.serializeArrowWorkerTable,
   deserializeWorkerBatch: deserializePCDWorkerBatch
 };
 function getNumericBatchSize(options) {
@@ -131,7 +131,7 @@ function makePCDHeaderText(pcdHeader, pointCount) {
 `;
 }
 function deserializePCDWorkerResult(result, options) {
-  const table = (0, import_arrow_transport.deserializeArrowWorkerTable)(result);
+  const table = (0, import_arrow_worker_transport.deserializeArrowWorkerTable)(result);
   return options?.pcd?.shape === "mesh" ? convertPCDTableToMesh(table, table) : table;
 }
 function deserializePCDWorkerBatch(result, options) {