@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.10

package/src/las/lib/typescript/parse-las.ts

@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {makeArrowMetadataBatch, updateArrowTableMetadata} from '@loaders.gl/core/schema-utils';
+import * as arrow from 'apache-arrow';
+import {makeMetadataFromLasHeader} from '../get-las-schema';
 import type {MeshArrowTable, MeshAttributes} from '@loaders.gl/core/schema';
 import {makeMeshArrowTable, type MeshArrowAttributes} from '@loaders.gl/core/schema-utils';
 import {
@@ -375,6 +378,7 @@ export async function* parseLASInBatches(
   let header: LASHeader | null = null;
   let sourcePointIndex = 0;
   let totalRead = 0;
+  let lastTable: LASArrowTable | undefined;
 
   while (true) {
     const next = await inputIterator.next();
@@ -385,6 +389,7 @@ export async function* parseLASInBatches(
     pending = concatenateUint8Arrays(pending, toUint8Array(chunk));
     if (!header) {
       header = tryParseHeader(pending, absoluteOffset);
+      if (header && pending.byteLength < header.pointsOffset) header = null;
       if (header) {
         header.totalToRead = header.pointsCount;
       }
@@ -393,7 +398,68 @@ export async function* parseLASInBatches(
       continue;
     }
     if (header.isCompressed) {
-      yield* parseLAZInBatches(pending, inputIterator, header, options);
+      const extendedOffset = header.metadata?.evlrOffset;
+      let inputOffset = pending.byteLength;
+      const extendedChunks: Uint8Array<ArrayBufferLike>[] = [];
+      if (extendedOffset && extendedOffset < inputOffset) {
+        extendedChunks.push(pending.subarray(extendedOffset));
+      }
+      const trackedIterator: AsyncIterator<ArrayBufferLike | ArrayBufferView> = {
+        async next() {
+          const next = await inputIterator.next();
+          if (!next.done && extendedOffset) {
+            const bytes = toUint8Array(next.value);
+            const start = Math.max(extendedOffset - inputOffset, 0);
+            if (start < bytes.byteLength) extendedChunks.push(bytes.slice(start));
+            inputOffset += bytes.byteLength;
+          }
+          return next;
+        }
+      };
+      if (header.pointsCount === 0) {
+        const {laszip} = await readLASZipVLRFromInput(pending, trackedIterator, header);
+        validateTypeScriptLAZSupport(header, laszip);
+        lastTable = makeEmptyLASBatch(header, options);
+      } else {
+        for await (const table of parseLAZInBatches(pending, trackedIterator, header, options)) {
+          lastTable = updateArrowTableMetadata(
+            table,
+            makeMetadataFromLasHeader({
+              ...header,
+              totalRead: table.loaderData.totalRead,
+              metadata: table.loaderData.metadata || header.metadata
+            })
+          );
+          yield lastTable;
+        }
+      }
+      if (
+        extendedOffset &&
+        lastTable &&
+        header.metadata?.evlrCount &&
+        (lastTable.loaderData.metadata?.evlrs.length ?? 0) < header.metadata.evlrCount
+      ) {
+        while (!(await trackedIterator.next()).done) {
+          // Finish reading trailing records if the decoder stopped at its chunk table.
+        }
+        // The tracked iterator retains only the extended-record suffix.
+        const suffix = extendedChunks.reduce<Uint8Array<ArrayBufferLike>>(
+          concatenateUint8Arrays,
+          new Uint8Array(0)
+        );
+        const update = makeLASMetadataUpdate(
+          lastTable,
+          header,
+          suffix,
+          extendedOffset,
+          lastTable.loaderData.totalRead
+        );
+        if (update) {
+          yield update;
+          return;
+        }
+      }
+      if (header.pointsCount === 0 && lastTable) yield lastTable;
       return;
     }
 
@@ -409,7 +475,11 @@ export async function* parseLASInBatches(
       totalRead = batch.totalRead;
       pending = batch.pending;
       absoluteOffset = batch.absoluteOffset;
-      yield parseLASArrowTableBatch(batch.arrayBuffer, batch.header, options);
+      lastTable = updateArrowTableMetadata(
+        parseLASArrowTableBatch(batch.arrayBuffer, batch.header, options),
+        makeMetadataFromLasHeader({...header, totalRead})
+      );
+      yield lastTable;
     }
   }
 
@@ -419,6 +489,60 @@ export async function* parseLASInBatches(
   if (totalRead < header.totalToRead) {
     throw new Error('LASLoader: truncated LAS point data');
   }
+  if (!lastTable) {
+    lastTable = makeEmptyLASBatch(header, options);
+    yield lastTable;
+  }
+  const update = makeLASMetadataUpdate(lastTable, header, pending, absoluteOffset, totalRead);
+  if (update) yield update;
+}
+
+/** Creates the declared point schema and original header metadata for a zero-point stream. */
+function makeEmptyLASBatch(header: LASHeader, options: LASLoaderOptions): LASArrowTable {
+  const table = parseLASArrowTableBatch(new ArrayBuffer(0), {...header, pointsOffset: 0}, options);
+  return updateArrowTableMetadata(
+    {...table, loaderData: header},
+    makeMetadataFromLasHeader(header)
+  );
+}
+
+/** Builds a schema-only batch carrying late extended records and their absolute offsets. */
+function makeLASMetadataUpdate(
+  lastTable: LASArrowTable,
+  header: LASHeader,
+  pending: Uint8Array,
+  absoluteOffset: number,
+  totalRead: number
+): LASArrowTable | undefined {
+  const metadata = header.metadata;
+  if (metadata?.evlrOffset && metadata.evlrCount) {
+    const relativeOffset = metadata.evlrOffset - absoluteOffset;
+    const records = parseLASExtendedVariableLengthRecords(
+      new DataView(pending.buffer, pending.byteOffset, pending.byteLength),
+      relativeOffset,
+      metadata.evlrCount
+    ).map(record => ({...record, offset: record.offset + absoluteOffset}));
+    const finalMetadata = {
+      ...metadata,
+      evlrs: records,
+      extraBytes: [...metadata.extraBytes],
+      waveformPacketDescriptors: [...metadata.waveformPacketDescriptors]
+    };
+    for (const record of records)
+      parseTypedLASMetadataRecord(
+        {...record, data: record.data || new Uint8Array()},
+        finalMetadata
+      );
+    resolveLASGeoTIFFKeyDirectory(finalMetadata);
+    const finalHeader = {...header, totalRead, metadata: finalMetadata};
+    if (records.length > 0) {
+      const data = new arrow.Table([makeArrowMetadataBatch(lastTable.data.schema)]);
+      return updateArrowTableMetadata(
+        {...lastTable, data, loaderData: finalHeader},
+        makeMetadataFromLasHeader(finalHeader)
+      );
+    }
+  }
 }
 
 /** Decode LAS data into raw point chunks. */
@@ -1017,7 +1141,7 @@ function* parseLAZChunkedIterator(
   if (header.pointsFormatId <= 5 || laszip.variableChunks) {
     yield* decodeLAZFileFromCompleteBytes(new Uint8Array(arrayBuffer), header, laszip, {
       ...options,
-      batchSize
+      core: {...options.core, batchSize}
     });
     return;
   }
@@ -1052,7 +1176,11 @@ function* decodeLAZFileFromCompleteBytes(
   options: LASLoaderOptions = {}
 ): Iterable<LASDecodedChunk> {
   const batchSize = getBatchSize(options);
-  const outputHeader = {...header, totalToRead: header.pointsCount};
+  const outputHeader = {
+    ...header,
+    metadata: parseLASMetadata(bytes, header),
+    totalToRead: header.pointsCount
+  };
   const state = createRawPointBatchState(
     batchSize,
     header.pointsStructSize,
@@ -1207,8 +1335,12 @@ function hasCompleteLASMetadata(arrayBuffer: ArrayBufferLike, header: LASHeader)
   return arrayBuffer.byteLength >= Math.max(vlrEnd, header.pointsOffset);
 }
 
-function parseLASMetadata(arrayBuffer: ArrayBufferLike, header: LASHeader): LASMetadata {
-  const dataView = new DataView(arrayBuffer);
+function parseLASMetadata(
+  arrayBuffer: ArrayBufferLike | ArrayBufferView,
+  header: LASHeader
+): LASMetadata {
+  const dataView = makeDataView(arrayBuffer);
+  const bytes = new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength);
   const version = header.versionAsString || '1.0';
   const versionParts = version.split('.').map(Number);
   const isAtLeast14 = versionParts[0] > 1 || (versionParts[0] === 1 && versionParts[1] >= 4);
@@ -1223,9 +1355,9 @@ function parseLASMetadata(arrayBuffer: ArrayBufferLike, header: LASHeader): LASM
       versionParts[0] > 1 || (versionParts[0] === 1 && versionParts[1] >= 3)
         ? dataView.getBigUint64(227, true)
         : undefined,
-    projectId: formatLASProjectId(new Uint8Array(arrayBuffer, 8, 16)),
-    systemIdentifier: readLASString(new Uint8Array(arrayBuffer), 26, 32),
-    generatingSoftware: readLASString(new Uint8Array(arrayBuffer), 58, 32),
+    projectId: formatLASProjectId(bytes.subarray(8, 24)),
+    systemIdentifier: readLASString(bytes, 26, 32),
+    generatingSoftware: readLASString(bytes, 58, 32),
     creationDayOfYear: dataView.getUint16(90, true),
     creationYear: dataView.getUint16(92, true),
     headerSize: header.headerSize!,
@@ -1287,7 +1419,7 @@ function parseLASExtendedVariableLengthRecords(
   evlrOffset: number,
   evlrCount: number
 ): LASExtendedVariableLengthRecord[] {
-  if (!evlrOffset || !evlrCount || evlrOffset >= dataView.byteLength) {
+  if (evlrOffset < 0 || !evlrCount || evlrOffset >= dataView.byteLength) {
     return [];
   }
   const bytes = new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength);
@@ -2011,7 +2143,7 @@ function detectTwoByteColors(
 }
 
 function getBatchSize(options: LASLoaderOptions): number {
-  const batchSize = options.batchSize ?? options.core?.batchSize;
+  const batchSize = options.core?.batchSize;
   return typeof batchSize === 'number' ? batchSize : DEFAULT_BATCH_SIZE;
 }
 

package/src/las/libs/laz-rs-wasm/README.md

@@ -0,0 +1,5 @@
+# laz-rs-wasm
+
+WebAssembly bindings for laz-rs LAZ decompression.
+
+Supported formats: LAS, LAZ.

package/src/las/libs/laz-rs-wasm/package.json

@@ -15,5 +15,11 @@
   "types": "laz_rs_wasm.d.ts",
   "sideEffects": [
     "./snippets/*"
+  ],
+  "description": "WebAssembly bindings for laz-rs LAZ decompression",
+  "keywords": [
+    "loaders.gl",
+    "LAS",
+    "LAZ"
   ]
 }

package/src/las/unbundled.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 export type {LASLoaderOptions} from './las-loader-types';
-export {LASLoader, LASWorkerLoader} from './las-loader-types';
+export {LASLoader} from './las-loader-types';
 export {LASCOPCLoader} from './las-copc-loader-types';
 export {LAZPerfLoader} from './lazperf-loader-types';
 export {LAZRsLoader} from './laz-rs-loader-types';

package/src/las/workers/las-worker.ts

@@ -3,22 +3,22 @@
 // Copyright (c) vis.gl contributors
 
 import {createLoaderWorker} from '@loaders.gl/core/loader-utils';
-import {LASLoaderWithParser} from '../las-loader';
+import {LASColumnLoader} from '../las-loader';
 
 createLoaderWorker({
-  ...LASLoaderWithParser,
+  ...LASColumnLoader,
   /** Decodes worker output as transferable columns; caller formatting follows hydration. */
   parse(input, options) {
-    return LASLoaderWithParser.parse(input, {
+    return LASColumnLoader.parse(input, {
       ...options,
-      las: {...options?.las, shape: 'arrow-table', colorFormat: 'uint8norm'}
+      las: {...options?.las, shape: 'arrow', colorFormat: 'uint8norm'}
     });
   },
   /** Keeps the primary TypeScript decoder alive for the full input stream. */
   parseInBatches(input, options) {
-    return LASLoaderWithParser.parseInBatches(input, {
+    return LASColumnLoader.parseInBatches(input, {
       ...options,
-      las: {...options?.las, shape: 'arrow-table', colorFormat: 'uint8norm'}
+      las: {...options?.las, shape: 'arrow', colorFormat: 'uint8norm'}
     });
   }
 });

package/src/las-copc-loader-types.ts

@@ -0,0 +1 @@
+export * from './las/las-copc-loader-types.js';

package/src/las-copc-loader.ts

@@ -0,0 +1 @@
+export * from './las/las-copc-loader.js';

package/src/las-loader-types.ts

@@ -0,0 +1 @@
+export * from './las/las-loader-types.js';

package/src/las-loader.ts

@@ -0,0 +1 @@
+export * from './las/las-loader.js';

package/src/las-writer.ts

@@ -0,0 +1 @@
+export * from './las/las-writer.js';

package/src/laz-rs-loader-types.ts

@@ -0,0 +1 @@
+export * from './las/laz-rs-loader-types.js';

package/src/laz-rs-loader.ts

@@ -0,0 +1 @@
+export * from './las/laz-rs-loader.js';

package/src/lazperf-loader-types.ts

@@ -0,0 +1 @@
+export * from './las/lazperf-loader-types.js';

package/src/lazperf-loader.ts

@@ -0,0 +1 @@
+export * from './las/lazperf-loader.js';

package/src/pcd/bundled.ts

@@ -3,7 +3,4 @@
 // Copyright vis.gl contributors
 
 export type {PCDLoaderOptions} from './pcd-loader-types';
-export {
-  PCDLoaderWithParser as PCDWorkerLoader,
-  PCDLoaderWithParser as PCDLoader
-} from './pcd-loader';
+export {PCDLoaderWithParser as PCDLoader} from './pcd-loader';

package/src/pcd/index.ts

@@ -7,7 +7,3 @@ export {PCDFormat} from './pcd-format';
 export {PCDLoader} from './pcd-loader-types';
 export type {PCDWriterOptions} from './pcd-writer';
 export {PCDWriter} from './pcd-writer';
-
-// DEPRECATED EXPORTS
-/** @deprecated Use PCDLoader. */
-export {PCDWorkerLoader} from './pcd-loader-types';

package/src/pcd/pcd-loader-types.ts

@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {Table, RecordBatch} from 'apache-arrow';
 import type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';
-import type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';
 import type {PCDMesh} from './lib/pcd-types';
 import {PCDFormat} from './pcd-format';
-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__'.
@@ -15,7 +15,7 @@ const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 export type PCDLoaderOptions = LoaderOptions & {
   pcd?: {
     /** Output shape. Defaults to a Mesh Arrow table. */
-    shape?: 'mesh' | 'arrow-table';
+    shape?: 'mesh' | 'arrow';
     /** Color storage format. Defaults to uint8norm for backwards compatibility. */
     colorFormat?: 'uint8norm' | 'float16' | 'float32';
     /** Override the URL to the worker bundle (by default loads from unpkg.com) */
@@ -27,7 +27,7 @@ export type PCDLoaderOptions = LoaderOptions & {
  * Preloads the parser-bearing PCD loader implementation.
  */
 async function preload() {
-  const {PCDLoaderWithParser} = await import('@loaders.gl/pointclouds/pcd/pcd-loader');
+  const {PCDLoaderWithParser} = await import('@loaders.gl/pointclouds/pcd-loader');
   return PCDLoaderWithParser;
 }
 
@@ -35,19 +35,18 @@ async function preload() {
  * Metadata-only worker loader for PCD - Point Cloud Data
  */
 export const PCDLoader = {
+  defaultShape: 'arrow',
+  supportsNativeArrow: true,
   ...PCDFormat,
-  dataType: null as unknown as PCDMesh | MeshArrowTable,
-  batchType: null as unknown as PCDMesh | ArrowTableBatch,
+  dataType: null as unknown as PCDMesh | Table,
+  batchType: null as unknown as PCDMesh | RecordBatch,
   version: VERSION,
   worker: true,
   /** Enables the stateful input/output batch protocol on the built-in worker. */
   workerInBatches: true,
   serializeWorkerResult: serializeArrowWorkerTable,
   options: {
-    pcd: {shape: 'arrow-table', colorFormat: 'uint8norm'}
+    pcd: {shape: 'arrow', colorFormat: 'uint8norm'}
   },
   preload
-} as const satisfies Loader<PCDMesh | MeshArrowTable, PCDMesh | ArrowTableBatch, PCDLoaderOptions>;
-
-/** @deprecated Use PCDLoader. */
-export const PCDWorkerLoader = PCDLoader;
+} as const satisfies Loader<PCDMesh | Table, PCDMesh | RecordBatch, PCDLoaderOptions>;

package/src/pcd/pcd-loader.ts

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {refineArrowTableBatches, makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';
+import type {Table, RecordBatch} from 'apache-arrow';
 import type {PCDLoaderOptions} from './pcd-loader-types';
 
 import {
@@ -13,8 +15,8 @@ import type {ArrowTableBatch, MeshArrowTable} from '@loaders.gl/core/schema';
 import {
   deserializeArrowWorkerTable,
   serializeArrowWorkerTable
-} from '@loaders.gl/core/schema-utils/arrow-transport';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+} from '@loaders.gl/core/arrow-worker-transport';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import type {PCDMesh} from './lib/pcd-types';
 import {parsePCD, parsePCDHeader} from './lib/parse-pcd';
 import {PCDLoader as PCDLoaderMetadata} from './pcd-loader-types';
@@ -24,7 +26,7 @@ const {preload: _PCDLoaderPreload, ...PCDLoaderMetadataWithoutPreload} = PCDLoad
 type PCDParsedBatch = PCDMesh | ArrowTableBatch;
 
 function convertPCDMesh(mesh: PCDMesh, options?: PCDLoaderOptions): PCDMesh | MeshArrowTable {
-  const table = convertMeshToTable(mesh, 'arrow-table');
+  const table = convertMeshToArrowTableWrapper(mesh);
   return options?.pcd?.shape === 'mesh'
     ? convertPCDTableToMesh(table, mesh)
     : {...table, loader: mesh.loader, loaderData: mesh.loaderData};
@@ -33,33 +35,14 @@ function convertPCDMesh(mesh: PCDMesh, options?: PCDLoaderOptions): PCDMesh | Me
 /**
  * Loader for PCD - Point Cloud Data
  */
-export const PCDLoaderWithParser = {
+export const PCDColumnLoader = {
   ...PCDLoaderMetadataWithoutPreload,
+  dataType: null as unknown as PCDMesh | MeshArrowTable,
+  batchType: null as unknown as PCDMesh | ArrowTableBatch,
   parse: async (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),
   parseSync: (arrayBuffer, options) => convertPCDMesh(parsePCD(arrayBuffer, options), options),
-  parseInBatches: async function* (
-    arrayBuffer:
-      | AsyncIterable<ArrayBufferLike | ArrayBufferView>
-      | Iterable<ArrayBufferLike | ArrayBufferView>,
-    options
-  ): AsyncIterable<PCDParsedBatch> {
-    const batchSize = getNumericBatchSize(options);
-    const data = await concatenateArrayBuffersAsync(arrayBuffer);
-    const textData = new TextDecoder().decode(data);
-    const pcdHeader = parsePCDHeader(textData);
-
-    if (pcdHeader.data === 'ascii') {
-      yield* parsePCDASCIIInBatches(data, options, batchSize);
-      return;
-    }
-
-    if (pcdHeader.data === 'binary') {
-      yield* parsePCDBinaryInBatches(data, options, batchSize);
-      return;
-    }
-
-    yield makePCDBatch(parsePCD(data, options), options);
-  },
+  parseInBatches: (input, options) =>
+    refineArrowTableBatches(parsePCDWithMetadataInBatches(input, options)),
   serializeWorkerResult: serializeArrowWorkerTable,
   deserializeWorkerResult: deserializePCDWorkerResult,
   serializeWorkerBatch: serializeArrowWorkerTable,
@@ -68,7 +51,7 @@ export const PCDLoaderWithParser = {
 
 /** Returns a numeric batch size when batching has an explicit row count. */
 function getNumericBatchSize(options?: PCDLoaderOptions): number | undefined {
-  const batchSize = options?.batchSize ?? options?.core?.batchSize;
+  const batchSize = options?.core?.batchSize;
   return typeof batchSize === 'number' ? batchSize : undefined;
 }
 
@@ -118,7 +101,7 @@ function* parsePCDBinaryInBatches(
 }
 
 function makePCDBatch(mesh: PCDMesh, options?: PCDLoaderOptions): PCDParsedBatch {
-  const table = convertMeshToTable(mesh, 'arrow-table');
+  const table = convertMeshToArrowTableWrapper(mesh);
   if (options?.pcd?.shape === 'mesh') {
     return convertPCDTableToMesh(table, mesh);
   }
@@ -177,3 +160,88 @@ function deserializePCDWorkerResult(
 function deserializePCDWorkerBatch(result: unknown, options?: PCDLoaderOptions): PCDParsedBatch {
   return deserializePCDWorkerResult(result, options) as PCDParsedBatch;
 }
+
+/** Parses PCD batches before shared cumulative metadata refinement. */
+async function* parsePCDWithMetadataInBatches(
+  arrayBuffer:
+    | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+    | Iterable<ArrayBufferLike | ArrayBufferView>,
+  options?: PCDLoaderOptions
+): AsyncIterable<PCDParsedBatch> {
+  const batchSize = getNumericBatchSize(options);
+  const data = await concatenateArrayBuffersAsync(arrayBuffer);
+  const textData = new TextDecoder().decode(data);
+  const pcdHeader = parsePCDHeader(textData);
+
+  if (pcdHeader.data === 'ascii') {
+    yield* parsePCDASCIIInBatches(data, options, batchSize);
+    return;
+  }
+
+  if (pcdHeader.data === 'binary') {
+    yield* parsePCDBinaryInBatches(data, options, batchSize);
+    return;
+  }
+
+  yield makePCDBatch(parsePCD(data, options), options);
+}
+
+/** Exposes native Arrow output while retaining the worker's column protocol. */
+export const PCDLoaderWithParser = {
+  ...PCDColumnLoader,
+  dataType: PCDLoaderMetadata.dataType,
+  batchType: PCDLoaderMetadata.batchType,
+  parse: async (input: ArrayBuffer, options?: PCDLoaderOptions) =>
+    unwrapPCDTable(await PCDColumnLoader.parse(input, options)),
+  parseSync: (input: ArrayBuffer, options?: PCDLoaderOptions) =>
+    unwrapPCDTable(PCDColumnLoader.parseSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const batch of PCDColumnLoader.parseInBatches(input, options)) {
+      if (isColumnBatch(batch)) {
+        batch.data.schema.metadata.set(
+          'loaders.gl.pcd.header',
+          JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)
+        );
+        for (const recordBatch of batch.data.batches) {
+          recordBatch.schema.metadata.set(
+            'loaders.gl.pcd.header',
+            batch.data.schema.metadata.get('loaders.gl.pcd.header')!
+          );
+        }
+        if (batch.data.batches.length) yield* batch.data.batches;
+        else yield makeArrowMetadataBatch(batch.data.schema);
+      } else yield batch;
+    }
+  },
+  deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) =>
+    unwrapPCDTable(PCDColumnLoader.deserializeWorkerResult(result, options)),
+  deserializeWorkerBatch(result: unknown, options?: PCDLoaderOptions) {
+    const batch = PCDColumnLoader.deserializeWorkerBatch(result, options);
+    if (isColumnBatch(batch)) {
+      const recordBatch = batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema);
+      recordBatch.schema.metadata.set(
+        'loaders.gl.pcd.header',
+        JSON.stringify((batch as ArrowTableBatch & {loaderData?: unknown}).loaderData)
+      );
+      return recordBatch;
+    }
+    return batch;
+  }
+} as const satisfies LoaderWithParser<PCDMesh | Table, PCDMesh | RecordBatch, PCDLoaderOptions>;
+
+/** Returns the Arrow table with its file metadata or the requested mesh. */
+function unwrapPCDTable(result: PCDMesh | MeshArrowTable): PCDMesh | Table {
+  if ('shape' in result && result.shape === 'arrow-table') {
+    result.data.schema.metadata.set(
+      'loaders.gl.pcd.header',
+      JSON.stringify((result as MeshArrowTable & {loaderData?: unknown}).loaderData)
+    );
+    return result.data;
+  }
+  return result as PCDMesh;
+}
+
+/** Identifies the private Arrow batch envelope. */
+function isColumnBatch(batch: PCDMesh | ArrowTableBatch): batch is ArrowTableBatch {
+  return 'shape' in batch && batch.shape === 'arrow-table';
+}

package/src/pcd/pcd-writer.ts

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {Table} from 'apache-arrow';
 import type {WriterOptions, WriterWithEncoder} from '@loaders.gl/core/loader-utils';
 import type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';
-import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';
 import {PCDFormat} from './pcd-format';
 
 // __VERSION__ is injected by babel-plugin-version-inline
@@ -22,7 +23,7 @@ export type PCDWriterOptions = WriterOptions & {
  */
 export const PCDWriter = {
   ...PCDFormat,
-  dataType: null as unknown as Mesh | MeshArrowTable,
+  dataType: null as unknown as Mesh | MeshArrowTable | Table,
   batchType: null as never,
   version: VERSION,
   options: {
@@ -32,16 +33,19 @@ export const PCDWriter = {
   encode: async (data, options) => encodePCDSync(data, options),
   encodeSync: encodePCDSync,
   encodeTextSync: encodePCD
-} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable, never, PCDWriterOptions>;
+} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable | Table, never, PCDWriterOptions>;
 
 /** Encode mesh category data as PCD bytes. */
-function encodePCDSync(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): ArrayBuffer {
+function encodePCDSync(
+  data: Mesh | MeshArrowTable | Table,
+  options?: PCDWriterOptions
+): ArrayBuffer {
   const text = encodePCD(data, options);
   return new TextEncoder().encode(text).buffer;
 }
 
 /** Encode mesh category data as ASCII PCD text. */
-function encodePCD(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): string {
+function encodePCD(data: Mesh | MeshArrowTable | Table, options?: PCDWriterOptions): string {
   const mesh = convertTableToMesh(normalizeMeshArrowTable(data));
   const positionAttribute = getRequiredAttribute(mesh, 'POSITION');
   const normalAttribute = mesh.attributes.NORMAL;
@@ -106,11 +110,11 @@ function encodePCD(data: Mesh | MeshArrowTable, options?: PCDWriterOptions): str
 }
 
 /** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */
-function normalizeMeshArrowTable(data: Mesh | MeshArrowTable): MeshArrowTable {
-  if ('shape' in data && data.shape === 'arrow-table') {
+function normalizeMeshArrowTable(data: Mesh | MeshArrowTable | Table): MeshArrowTable | Table {
+  if (!('attributes' in data)) {
     return data;
   }
-  return convertMeshToTable(data as Mesh, 'arrow-table');
+  return convertMeshToArrowTableWrapper(data as Mesh);
 }
 
 /** Return a required mesh attribute or throw a format-specific error. */

package/src/pcd/unbundled.ts

@@ -3,4 +3,4 @@
 // Copyright vis.gl contributors
 
 export type {PCDLoaderOptions} from './pcd-loader-types';
-export {PCDWorkerLoader, PCDLoader} from './pcd-loader-types';
+export {PCDLoader} from './pcd-loader-types';

package/src/pcd/workers/pcd-worker.ts

@@ -3,22 +3,22 @@
 // Copyright (c) vis.gl contributors
 
 import {createLoaderWorker} from '@loaders.gl/core/loader-utils';
-import {PCDLoaderWithParser} from '../pcd-loader';
+import {PCDColumnLoader} from '../pcd-loader';
 
 createLoaderWorker({
-  ...PCDLoaderWithParser,
+  ...PCDColumnLoader,
   /** Always returns columnar data; legacy mesh conversion runs on the caller. */
   parse(input, options) {
-    return PCDLoaderWithParser.parse(input, {
+    return PCDColumnLoader.parse(input, {
       ...options,
-      pcd: {...options?.pcd, shape: 'arrow-table'}
+      pcd: {...options?.pcd, shape: 'arrow'}
     });
   },
   /** Keeps one columnar parser alive for the entire worker input stream. */
   parseInBatches(input, options) {
-    return PCDLoaderWithParser.parseInBatches(input, {
+    return PCDColumnLoader.parseInBatches(input, {
       ...options,
-      pcd: {...options?.pcd, shape: 'arrow-table'}
+      pcd: {...options?.pcd, shape: 'arrow'}
     });
   }
 });