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

package/dist/las/las-loader-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"las-loader-shared.d.ts","sourceRoot":"","sources":["../../src/las/las-loader-shared.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAEzE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAM7C,sEAAsE;AACtE,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,WAAW,GACX,gBAAgB,GAChB,WAAW,GACX,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GACT,UAAU,GACV,KAAK,GACL,WAAW,GACX,UAAU,GACV,eAAe,GACf,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,kBAAkB,GAClB,UAAU,GACV,aAAa,CAAC;AAElB,sDAAsD;AACtD,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,6BAA6B;QAC7B,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAAC;QAClD,uDAAuD;QACvD,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,8DAA8D;QAC9D,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC7B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,4DAA4D;QAC5D,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;QACnC,iFAAiF;QACjF,UAAU,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;QAC7B,yFAAyF;QACzF,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,gGAAgG;QAChG,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;QACnC,6CAA6C;QAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,0DAA0D;IAC1D,UAAU,CAAC,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,EAAG,aAAsB,CAAC;AAExD,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAEjG;AAED,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;uBAGD,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAgByC,CAAC;AAElG,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,GAC/C,OAAO,CAyBT"}
+{"version":3,"file":"las-loader-shared.d.ts","sourceRoot":"","sources":["../../src/las/las-loader-shared.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAEzE,OAAO,KAAK,EAAC,KAAK,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAM7C,sEAAsE;AACtE,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,WAAW,GACX,gBAAgB,GAChB,WAAW,GACX,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GACT,UAAU,GACV,KAAK,GACL,WAAW,GACX,UAAU,GACV,eAAe,GACf,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,mBAAmB,GACnB,kBAAkB,GAClB,UAAU,GACV,aAAa,CAAC;AAElB,sDAAsD;AACtD,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,6BAA6B;QAC7B,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,OAAO,CAAC;QAC5C,uDAAuD;QACvD,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,8DAA8D;QAC9D,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC7B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,4DAA4D;QAC5D,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;QACnC,iFAAiF;QACjF,UAAU,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC;QAC7B,yFAAyF;QACzF,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,gGAAgG;QAChG,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;QACnC,6CAA6C;QAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,0DAA0D;IAC1D,UAAU,CAAC,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,EAAG,OAAgB,CAAC;AAElD,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,gBAAgB,GAAG,OAAO,CAE3F;AAED,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;;;uBAKD,OAAO,GAAG,KAAK;wBACd,OAAO,GAAG,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAgBgC,CAAC;AAEtF,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,GAC/C,OAAO,CAyBT"}

package/dist/las/las-loader-shared.js

@@ -5,9 +5,9 @@ import { convertColorArrayToFloat16, convertColorArrayToFloat32 } from '@loaders
 import { LASFormat } from "./las-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+const VERSION = typeof "5.0.0-beta.10" !== 'undefined' ? "5.0.0-beta.10" : 'latest';
 /** Default output shape for LAS and LAZ loaders. */
-export const DEFAULT_LAS_SHAPE = 'arrow-table';
+export const DEFAULT_LAS_SHAPE = 'arrow';
 /** Resolve the LAS output shape, including the Arrow-primary default. */
 export function getLASShape(options) {
     return options?.las?.shape || DEFAULT_LAS_SHAPE;
@@ -15,6 +15,8 @@ export function getLASShape(options) {
 /** Parser-independent LAS loader metadata shared by each loader variant. */
 export const LAS_LOADER_METADATA = {
     ...LASFormat,
+    defaultShape: 'arrow',
+    supportsNativeArrow: true,
     dataType: null,
     batchType: null,
     version: VERSION,

package/dist/las/las-loader-shared.js.map

@@ -1 +1 @@
-{"version":3,"file":"las-loader-shared.js","sourceRoot":"","sources":["../../src/las/las-loader-shared.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,0BAA0B,EAAE,0BAA0B,EAAC,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAC,SAAS,EAAC,wBAAqB;AAGvC,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAmD5E,oDAAoD;AACpD,MAAM,CAAC,MAAM,iBAAiB,GAAG,aAAsB,CAAC;AAExD,yEAAyE;AACzE,MAAM,UAAU,WAAW,CAAC,OAA0B;IACpD,OAAO,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,iBAAiB,CAAC;AAClD,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,SAAS;IAEZ,QAAQ,EAAE,IAA2C;IACrD,SAAS,EAAE,IAA2C;IAEtD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE;QACP,GAAG,EAAE;YACH,KAAK,EAAE,iBAAiB;YACxB,IAAI,EAAE,KAAK;YACX,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,WAAW;YACxB,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,KAAK;YACjB,wBAAwB,EAAE,KAAK;YAC/B,iBAAiB,EAAE,MAAM;SAC1B;KACF;CAC8F,CAAC;AAElG,iFAAiF;AACjF,MAAM,UAAU,mBAAmB,CACjC,IAAa,EACb,WAAgD;IAEhD,IAAI,WAAW,KAAK,WAAW,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;IAC/C,MAAM,WAAW,GAAG,cAAc,CAAC,KAAK,YAAY,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9E,MAAM,KAAK,GACT,WAAW,KAAK,SAAS;QACvB,CAAC,CAAC,0BAA0B,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC;QAC/D,CAAC,CAAC,0BAA0B,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,EAAC,GAAG,IAAI,CAAC,UAAU,EAAC,CAAC;IAExC,KAAK,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACpE,IAAI,SAAS,CAAC,KAAK,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;YAC7C,UAAU,CAAC,aAAa,CAAC,GAAG;gBAC1B,GAAG,SAAS;gBACZ,KAAK;gBACL,UAAU,EAAE,KAAK;gBACjB,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAC,aAAa,EAAE,SAAkB,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAC,GAAG,IAAI,EAAE,UAAU,EAAC,CAAC;AAC/B,CAAC"}
+{"version":3,"file":"las-loader-shared.js","sourceRoot":"","sources":["../../src/las/las-loader-shared.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,0BAA0B,EAAE,0BAA0B,EAAC,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAC,SAAS,EAAC,wBAAqB;AAGvC,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAmD5E,oDAAoD;AACpD,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAgB,CAAC;AAElD,yEAAyE;AACzE,MAAM,UAAU,WAAW,CAAC,OAA0B;IACpD,OAAO,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,iBAAiB,CAAC;AAClD,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,SAAS;IACZ,YAAY,EAAE,OAAO;IACrB,mBAAmB,EAAE,IAAI;IAEzB,QAAQ,EAAE,IAAkC;IAC5C,SAAS,EAAE,IAAwC;IAEnD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE;QACP,GAAG,EAAE;YACH,KAAK,EAAE,iBAAiB;YACxB,IAAI,EAAE,KAAK;YACX,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,WAAW;YACxB,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,KAAK;YACjB,wBAAwB,EAAE,KAAK;YAC/B,iBAAiB,EAAE,MAAM;SAC1B;KACF;CACkF,CAAC;AAEtF,iFAAiF;AACjF,MAAM,UAAU,mBAAmB,CACjC,IAAa,EACb,WAAgD;IAEhD,IAAI,WAAW,KAAK,WAAW,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;IAC/C,MAAM,WAAW,GAAG,cAAc,CAAC,KAAK,YAAY,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9E,MAAM,KAAK,GACT,WAAW,KAAK,SAAS;QACvB,CAAC,CAAC,0BAA0B,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC;QAC/D,CAAC,CAAC,0BAA0B,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,EAAC,GAAG,IAAI,CAAC,UAAU,EAAC,CAAC;IAExC,KAAK,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACpE,IAAI,SAAS,CAAC,KAAK,KAAK,cAAc,CAAC,KAAK,EAAE,CAAC;YAC7C,UAAU,CAAC,aAAa,CAAC,GAAG;gBAC1B,GAAG,SAAS;gBACZ,KAAK;gBACL,UAAU,EAAE,KAAK;gBACjB,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAC,aAAa,EAAE,SAAkB,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAC,GAAG,IAAI,EAAE,UAAU,EAAC,CAAC;AAC/B,CAAC"}

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

@@ -30,13 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/las/las-loader-types.ts
 var las_loader_types_exports = {};
 __export(las_loader_types_exports, {
-  LASLoader: () => LASLoader,
-  LASWorkerLoader: () => LASWorkerLoader
+  LASLoader: () => LASLoader
 });
 module.exports = __toCommonJS(las_loader_types_exports);
 var import_las_loader_shared = require("./las-loader-shared.cjs");
 async function preload() {
-  const { LASLoaderWithParser } = await import("@loaders.gl/pointclouds/las/las-loader");
+  const { LASLoaderWithParser } = await import("@loaders.gl/pointclouds/las-loader");
   return LASLoaderWithParser;
 }
 var LASLoader = {
@@ -45,10 +44,8 @@ var LASLoader = {
   workerInBatches: true,
   preload
 };
-var LASWorkerLoader = LASLoader;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LASLoader,
-  LASWorkerLoader
+  LASLoader
 });
 //# sourceMappingURL=las-loader-types.cjs.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/las/las-loader-types.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport type {LASMesh} from './lib/las-types';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\n\nexport type {LASColumnName, LASLoaderOptions} from './las-loader-shared';\n\n/** Preloads the parser-bearing primary TypeScript LAS loader implementation. */\nasync function preload() {\n  const {LASLoaderWithParser} = await import('@loaders.gl/pointclouds/las/las-loader');\n  return LASLoaderWithParser;\n}\n\n/** Metadata-only loader for the LAS (LASer) point cloud format. */\nexport const LASLoader = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  preload\n} as const satisfies Loader<LASMesh | MeshArrowTable, LASMesh | MeshArrowTable, LASLoaderOptions>;\n\n/** @deprecated Use LASLoader. */\nexport const LASWorkerLoader = LASLoader;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAKzD,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,wCAAwC;AACnF,SAAO;AACT;AAGO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB;AACF;AAGO,IAAM,kBAAkB;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport type {LASMesh} from './lib/las-types';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\n\nexport type {LASColumnName, LASLoaderOptions} from './las-loader-shared';\n\n/** Preloads the parser-bearing primary TypeScript LAS loader implementation. */\nasync function preload() {\n  const {LASLoaderWithParser} = await import('@loaders.gl/pointclouds/las-loader');\n  return LASLoaderWithParser;\n}\n\n/** Metadata-only loader for the LAS (LASer) point cloud format. */\nexport const LASLoader = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  preload\n} as const satisfies Loader<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,+BAAyD;AAKzD,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAGO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB;AACF;",
   "names": []
 }

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

@@ -1,24 +1,26 @@
-import type { MeshArrowTable } from '@loaders.gl/core/schema';
+import type { Table, RecordBatch } from 'apache-arrow';
 import type { LASMesh } from "./lib/las-types.js";
 import { type LASLoaderOptions } from "./las-loader-shared.js";
 export type { LASColumnName, LASLoaderOptions } from "./las-loader-shared.js";
 /** Preloads the parser-bearing primary TypeScript LAS loader implementation. */
 declare function preload(): Promise<{
+    readonly dataType: LASMesh | Table<any>;
+    readonly batchType: LASMesh | RecordBatch<any>;
+    readonly parse: (input: ArrayBuffer, options?: LASLoaderOptions) => Promise<LASMesh | Table<any>>;
+    readonly parseSync: (input: ArrayBuffer, options?: LASLoaderOptions) => LASMesh | Table<any>;
+    readonly parseInBatches: (input: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options: LASLoaderOptions | undefined) => AsyncGenerator<LASMesh | RecordBatch<any>, void, unknown>;
+    readonly deserializeWorkerResult: (result: unknown, options?: LASLoaderOptions) => LASMesh | Table<any>;
+    readonly deserializeWorkerBatch: (result: unknown, options?: LASLoaderOptions) => LASMesh | RecordBatch<any>;
     readonly worker: true;
     readonly workerInBatches: true;
-    readonly serializeWorkerResult: typeof import("@loaders.gl/core/schema-utils/arrow-transport").serializeArrowWorkerTable;
-    readonly serializeWorkerBatch: typeof import("@loaders.gl/core/schema-utils/arrow-transport").serializeArrowWorkerTable;
-    readonly deserializeWorkerResult: (result: unknown, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
-    readonly deserializeWorkerBatch: (result: unknown, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
-    readonly parse: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => Promise<LASMesh | MeshArrowTable>;
-    readonly parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
-    readonly parseInBatches: (arrayBufferIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options?: LASLoaderOptions) => AsyncGenerator<LASMesh | MeshArrowTable, void, any>;
-    readonly dataType: LASMesh | MeshArrowTable;
-    readonly batchType: LASMesh | MeshArrowTable;
+    readonly serializeWorkerResult: typeof import("@loaders.gl/core/arrow-worker-transport").serializeArrowWorkerTable;
+    readonly serializeWorkerBatch: typeof import("@loaders.gl/core/arrow-worker-transport").serializeArrowWorkerTable;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
     readonly version: any;
     readonly options: {
         readonly las: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
             readonly fp64: false;
             readonly colorDepth: 8;
             readonly colorFormat: "uint8norm";
@@ -44,43 +46,14 @@ export declare const LASLoader: {
     readonly worker: true;
     readonly workerInBatches: true;
     readonly preload: typeof preload;
-    readonly dataType: LASMesh | MeshArrowTable;
-    readonly batchType: LASMesh | MeshArrowTable;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
+    readonly dataType: LASMesh | Table;
+    readonly batchType: LASMesh | RecordBatch;
     readonly version: any;
     readonly options: {
         readonly las: {
-            readonly shape: "arrow-table";
-            readonly fp64: false;
-            readonly colorDepth: 8;
-            readonly colorFormat: "uint8norm";
-            readonly columns: undefined;
-            readonly extraBytes: "raw";
-            readonly recoverMissingChunkTable: false;
-            readonly compatibilityMode: "auto";
-        };
-    };
-    readonly name: "LAS";
-    readonly id: "las";
-    readonly module: "pointclouds";
-    readonly encoding: "binary";
-    readonly format: "las";
-    readonly extensions: ["las", "laz"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly text: false;
-    readonly binary: true;
-    readonly tests: ["LASF"];
-};
-/** @deprecated Use LASLoader. */
-export declare const LASWorkerLoader: {
-    readonly worker: true;
-    readonly workerInBatches: true;
-    readonly preload: typeof preload;
-    readonly dataType: LASMesh | MeshArrowTable;
-    readonly batchType: LASMesh | MeshArrowTable;
-    readonly version: any;
-    readonly options: {
-        readonly las: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
             readonly fp64: false;
             readonly colorDepth: 8;
             readonly colorFormat: "uint8norm";

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

@@ -1 +1 @@
-{"version":3,"file":"las-loader-types.d.ts","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAC7C,OAAO,EAAsB,KAAK,gBAAgB,EAAC,+BAA4B;AAE/E,YAAY,EAAC,aAAa,EAAE,gBAAgB,EAAC,+BAA4B;AAEzE,gFAAgF;AAChF,iBAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGrB;AAED,mEAAmE;AACnE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK2E,CAAC;AAElG,iCAAiC;AACjC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC"}
+{"version":3,"file":"las-loader-types.d.ts","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,KAAK,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAC7C,OAAO,EAAsB,KAAK,gBAAgB,EAAC,+BAA4B;AAE/E,YAAY,EAAC,aAAa,EAAE,gBAAgB,EAAC,+BAA4B;AAEzE,gFAAgF;AAChF,iBAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGrB;AAED,mEAAmE;AACnE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK+D,CAAC"}

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

@@ -4,7 +4,7 @@
 import { LAS_LOADER_METADATA } from "./las-loader-shared.js";
 /** Preloads the parser-bearing primary TypeScript LAS loader implementation. */
 async function preload() {
-    const { LASLoaderWithParser } = await import('@loaders.gl/pointclouds/las/las-loader');
+    const { LASLoaderWithParser } = await import('@loaders.gl/pointclouds/las-loader');
     return LASLoaderWithParser;
 }
 /** Metadata-only loader for the LAS (LASer) point cloud format. */
@@ -14,6 +14,4 @@ export const LASLoader = {
     workerInBatches: true,
     preload
 };
-/** @deprecated Use LASLoader. */
-export const LASWorkerLoader = LASLoader;
 //# sourceMappingURL=las-loader-types.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"las-loader-types.js","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAI/E,gFAAgF;AAChF,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,wCAAwC,CAAC,CAAC;IACrF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,mEAAmE;AACnE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,mBAAmB;IACtB,MAAM,EAAE,IAAI;IACZ,eAAe,EAAE,IAAI;IACrB,OAAO;CACwF,CAAC;AAElG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}
+{"version":3,"file":"las-loader-types.js","sourceRoot":"","sources":["../../src/las/las-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,mBAAmB,EAAwB,+BAA4B;AAI/E,gFAAgF;AAChF,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;IACjF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,mEAAmE;AACnE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,mBAAmB;IACtB,MAAM,EAAE,IAAI;IACZ,eAAe,EAAE,IAAI;IACrB,OAAO;CAC4E,CAAC"}

package/dist/las/las-loader.cjs

@@ -20,19 +20,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/las/las-loader.ts
 var las_loader_exports = {};
 __export(las_loader_exports, {
-  LASLoaderWithParser: () => LASLoaderWithParser
+  LASColumnLoader: () => LASColumnLoader,
+  LASLoaderWithParser: () => LASLoaderWithParser,
+  getLASRecordBatches: () => getLASRecordBatches,
+  toPublicLASResult: () => toPublicLASResult
 });
 module.exports = __toCommonJS(las_loader_exports);
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
 var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_schema_utils2 = require("@loaders.gl/core/schema-utils");
 var import_las_loader_shared = require("./las-loader-shared.cjs");
-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_parse_las = require("./lib/typescript/parse-las.cjs");
-var LASLoaderWithParser = {
+var LASColumnLoader = {
   ...import_las_loader_shared.LAS_LOADER_METADATA,
+  dataType: null,
+  batchType: null,
   worker: true,
   workerInBatches: true,
-  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
-  serializeWorkerBatch: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerResult: import_arrow_worker_transport.serializeArrowWorkerTable,
+  serializeWorkerBatch: import_arrow_worker_transport.serializeArrowWorkerTable,
   deserializeWorkerResult: deserializeLASWorkerTable,
   deserializeWorkerBatch: deserializeLASWorkerTable,
   parse: async (arrayBuffer, options) => convertLASMesh(parseLASTable(arrayBuffer, options), options),
@@ -47,34 +54,75 @@ function parseLASTable(arrayBuffer, options) {
 }
 function convertLASMesh(table, options) {
   const formattedTable = options?.las?.colorFormat === void 0 || options.las.colorFormat === "uint8norm" ? table : {
-    ...(0, import_schema_utils.convertMeshToTable)(
-      (0, import_las_loader_shared.formatLASMeshColors)((0, import_schema_utils.convertTableToMesh)(table), options.las.colorFormat),
-      "arrow-table"
+    ...(0, import_schema_utils2.convertMeshToArrowTableWrapper)(
+      (0, import_las_loader_shared.formatLASMeshColors)((0, import_schema_utils2.convertTableToMesh)(table), options.las.colorFormat)
     ),
     loader: table.loader,
     loaderData: table.loaderData,
     progress: table.progress
   };
-  if ((0, import_las_loader_shared.getLASShape)(options) === "arrow-table") {
+  if ((0, import_las_loader_shared.getLASShape)(options) === "arrow") {
     return formattedTable;
   }
   return {
-    ...(0, import_schema_utils.convertTableToMesh)(formattedTable),
+    ...(0, import_schema_utils2.convertTableToMesh)(formattedTable),
     loader: formattedTable.loader,
     loaderData: formattedTable.loaderData,
     progress: formattedTable.progress
   };
 }
 async function* convertLASMeshBatches(tableBatches, options) {
-  for await (const table of tableBatches) {
+  for await (const table of (0, import_loader_utils.paceBatchIterator)(tableBatches, {
+    batchMaxRowsPerSecond: options?.core?.batchMaxRowsPerSecond,
+    getRowCount: (batch) => batch.data.numRows,
+    signal: options?.signal
+  })) {
     yield convertLASMesh(table, options);
   }
 }
 function deserializeLASWorkerTable(result, options) {
-  return convertLASMesh((0, import_arrow_transport.deserializeArrowWorkerTable)(result), options);
+  return convertLASMesh((0, import_arrow_worker_transport.deserializeArrowWorkerTable)(result), options);
+}
+var LASLoaderWithParser = {
+  ...LASColumnLoader,
+  dataType: import_las_loader_shared.LAS_LOADER_METADATA.dataType,
+  batchType: import_las_loader_shared.LAS_LOADER_METADATA.batchType,
+  parse: async (input, options) => toPublicLASResult(await LASColumnLoader.parse(input, options)),
+  parseSync: (input, options) => toPublicLASResult(LASColumnLoader.parseSync(input, options)),
+  async *parseInBatches(input, options) {
+    for await (const result of LASColumnLoader.parseInBatches(input, options)) {
+      if ("shape" in result) yield* getLASRecordBatches(result);
+      else yield result;
+    }
+  },
+  deserializeWorkerResult: (result, options) => toPublicLASResult(deserializeLASWorkerTable(result, options)),
+  deserializeWorkerBatch(result, options) {
+    const decoded = deserializeLASWorkerTable(result, options);
+    return "shape" in decoded ? getLASRecordBatches(decoded)[0] : decoded;
+  }
+};
+function toPublicLASResult(result) {
+  if (!("shape" in result)) return result;
+  const header = JSON.stringify(
+    result.loaderData,
+    (_key, value) => typeof value === "bigint" ? value.toString() : ArrayBuffer.isView(value) ? Array.from(value) : value
+  );
+  if (header) {
+    result.data.schema.metadata.set("loaders.gl.las.header", header);
+    for (const batch of result.data.batches)
+      batch.schema.metadata.set("loaders.gl.las.header", header);
+  }
+  return result.data;
+}
+function getLASRecordBatches(result) {
+  const table = toPublicLASResult(result);
+  return table.batches.length ? table.batches : [(0, import_schema_utils.makeArrowMetadataBatch)(table.schema)];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LASLoaderWithParser
+  LASColumnLoader,
+  LASLoaderWithParser,
+  getLASRecordBatches,
+  toPublicLASResult
 });
 //# sourceMappingURL=las-loader.cjs.map

package/dist/las/las-loader.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/las/las-loader.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport {\n  formatLASMeshColors,\n  getLASShape,\n  LAS_LOADER_METADATA,\n  type LASLoaderOptions\n} from './las-loader-shared';\nimport {\n  serializeArrowWorkerTable,\n  deserializeArrowWorkerTable\n} from '@loaders.gl/core/schema-utils/arrow-transport';\nimport type {LASMesh} from './lib/las-types';\nimport {\n  decodeLAZChunkToArrowTable,\n  parseLAS,\n  parseLASInBatches,\n  type LASArrowTable,\n  type LAZChunkArrowTableMetadata\n} from './lib/typescript/parse-las';\n\ntype LASWorkerChunkRequest = {\n  metadata: LAZChunkArrowTableMetadata;\n};\n\ntype LASWorkerOptions = LASLoaderOptions & {\n  las?: LASLoaderOptions['las'] & {\n    _chunk?: LASWorkerChunkRequest;\n  };\n};\n\n/** Parser-bearing TypeScript-only LAS loader implementation. */\nexport const LASLoaderWithParser = {\n  ...LAS_LOADER_METADATA,\n  worker: true,\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  serializeWorkerBatch: serializeArrowWorkerTable,\n  deserializeWorkerResult: deserializeLASWorkerTable,\n  deserializeWorkerBatch: deserializeLASWorkerTable,\n  parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLASTable(arrayBuffer, options), options),\n  parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLASTable(arrayBuffer, options), options),\n  parseInBatches: async function* (arrayBufferIterator, options?: LASLoaderOptions) {\n    yield* convertLASMeshBatches(parseLASInBatches(arrayBufferIterator, options), options);\n  }\n} as const satisfies LoaderWithParser<\n  LASMesh | MeshArrowTable,\n  LASMesh | MeshArrowTable,\n  LASLoaderOptions\n>;\n\n/** Parse a complete LAS file or an internal standalone worker chunk request. */\nfunction parseLASTable(arrayBuffer: ArrayBuffer, options?: LASLoaderOptions): LASArrowTable {\n  const chunkRequest = (options as LASWorkerOptions | undefined)?.las?._chunk;\n  return chunkRequest\n    ? decodeLAZChunkToArrowTable(arrayBuffer, chunkRequest.metadata, options || {})\n    : parseLAS(arrayBuffer, options);\n}\n\nfunction convertLASMesh(\n  table: LASArrowTable,\n  options?: LASLoaderOptions\n): LASMesh | MeshArrowTable {\n  const formattedTable =\n    options?.las?.colorFormat === undefined || options.las.colorFormat === 'uint8norm'\n      ? table\n      : {\n          ...convertMeshToTable(\n            formatLASMeshColors(convertTableToMesh(table) as LASMesh, options.las.colorFormat),\n            'arrow-table'\n          ),\n          loader: table.loader,\n          loaderData: table.loaderData,\n          progress: table.progress\n        };\n  if (getLASShape(options) === 'arrow-table') {\n    return formattedTable;\n  }\n  return {\n    ...(convertTableToMesh(formattedTable) as LASMesh),\n    loader: formattedTable.loader,\n    loaderData: formattedTable.loaderData,\n    progress: formattedTable.progress\n  } as LASMesh & {progress?: number};\n}\n\nasync function* convertLASMeshBatches(\n  tableBatches: AsyncIterable<LASArrowTable>,\n  options?: LASLoaderOptions\n): AsyncIterable<LASMesh | MeshArrowTable> {\n  for await (const table of tableBatches) {\n    yield convertLASMesh(table, options);\n  }\n}\n\n/** Hydrates transferred columns and applies the requested mesh and color representation on the caller. */\nfunction deserializeLASWorkerTable(\n  result: unknown,\n  options?: LASLoaderOptions\n): LASMesh | MeshArrowTable {\n  return convertLASMesh(deserializeArrowWorkerTable(result), options);\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,0BAAqD;AACrD,+BAKO;AACP,6BAGO;AAEP,uBAMO;AAaA,IAAM,sBAAsB;AAAA,EACjC,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,sBAAsB;AAAA,EACtB,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,OAAO,OAAO,aAA0B,YACtC,eAAe,cAAc,aAAa,OAAO,GAAG,OAAO;AAAA,EAC7D,WAAW,CAAC,aAA0B,YACpC,eAAe,cAAc,aAAa,OAAO,GAAG,OAAO;AAAA,EAC7D,gBAAgB,iBAAiB,qBAAqB,SAA4B;AAChF,WAAO,0BAAsB,oCAAkB,qBAAqB,OAAO,GAAG,OAAO;AAAA,EACvF;AACF;AAOA,SAAS,cAAc,aAA0B,SAA2C;AAC1F,QAAM,eAAgB,SAA0C,KAAK;AACrE,SAAO,mBACH,6CAA2B,aAAa,aAAa,UAAU,WAAW,CAAC,CAAC,QAC5E,2BAAS,aAAa,OAAO;AACnC;AAEA,SAAS,eACP,OACA,SAC0B;AAC1B,QAAM,iBACJ,SAAS,KAAK,gBAAgB,UAAa,QAAQ,IAAI,gBAAgB,cACnE,QACA;AAAA,IACE,OAAG;AAAA,UACD,kDAAoB,wCAAmB,KAAK,GAAc,QAAQ,IAAI,WAAW;AAAA,MACjF;AAAA,IACF;AAAA,IACA,QAAQ,MAAM;AAAA,IACd,YAAY,MAAM;AAAA,IAClB,UAAU,MAAM;AAAA,EAClB;AACN,UAAI,sCAAY,OAAO,MAAM,eAAe;AAC1C,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,OAAI,wCAAmB,cAAc;AAAA,IACrC,QAAQ,eAAe;AAAA,IACvB,YAAY,eAAe;AAAA,IAC3B,UAAU,eAAe;AAAA,EAC3B;AACF;AAEA,gBAAgB,sBACd,cACA,SACyC;AACzC,mBAAiB,SAAS,cAAc;AACtC,UAAM,eAAe,OAAO,OAAO;AAAA,EACrC;AACF;AAGA,SAAS,0BACP,QACA,SAC0B;AAC1B,SAAO,mBAAe,oDAA4B,MAAM,GAAG,OAAO;AACpE;",
-  "names": []
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {paceBatchIterator, type LoaderWithParser} from '@loaders.gl/core/loader-utils';\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport {makeArrowMetadataBatch} from '@loaders.gl/core/schema-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport {\n  formatLASMeshColors,\n  getLASShape,\n  LAS_LOADER_METADATA,\n  type LASLoaderOptions\n} from './las-loader-shared';\nimport {\n  serializeArrowWorkerTable,\n  deserializeArrowWorkerTable\n} from '@loaders.gl/core/arrow-worker-transport';\nimport type {LASMesh} from './lib/las-types';\nimport {\n  decodeLAZChunkToArrowTable,\n  parseLAS,\n  parseLASInBatches,\n  type LASArrowTable,\n  type LAZChunkArrowTableMetadata\n} from './lib/typescript/parse-las';\n\ntype LASWorkerChunkRequest = {\n  metadata: LAZChunkArrowTableMetadata;\n};\n\ntype LASWorkerOptions = LASLoaderOptions & {\n  las?: LASLoaderOptions['las'] & {\n    _chunk?: LASWorkerChunkRequest;\n  };\n};\n\n/** Parser-bearing TypeScript-only LAS loader implementation. */\nexport const LASColumnLoader = {\n  ...LAS_LOADER_METADATA,\n  dataType: null as unknown as LASMesh | MeshArrowTable,\n  batchType: null as unknown as LASMesh | MeshArrowTable,\n  worker: true,\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  serializeWorkerBatch: serializeArrowWorkerTable,\n  deserializeWorkerResult: deserializeLASWorkerTable,\n  deserializeWorkerBatch: deserializeLASWorkerTable,\n  parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLASTable(arrayBuffer, options), options),\n  parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    convertLASMesh(parseLASTable(arrayBuffer, options), options),\n  parseInBatches: async function* (arrayBufferIterator, options?: LASLoaderOptions) {\n    yield* convertLASMeshBatches(parseLASInBatches(arrayBufferIterator, options), options);\n  }\n} as const satisfies LoaderWithParser<\n  LASMesh | MeshArrowTable,\n  LASMesh | MeshArrowTable,\n  LASLoaderOptions\n>;\n\n/** Parse a complete LAS file or an internal standalone worker chunk request. */\nfunction parseLASTable(arrayBuffer: ArrayBuffer, options?: LASLoaderOptions): LASArrowTable {\n  const chunkRequest = (options as LASWorkerOptions | undefined)?.las?._chunk;\n  return chunkRequest\n    ? decodeLAZChunkToArrowTable(arrayBuffer, chunkRequest.metadata, options || {})\n    : parseLAS(arrayBuffer, options);\n}\n\nfunction convertLASMesh(\n  table: LASArrowTable,\n  options?: LASLoaderOptions\n): LASMesh | MeshArrowTable {\n  const formattedTable =\n    options?.las?.colorFormat === undefined || options.las.colorFormat === 'uint8norm'\n      ? table\n      : {\n          ...convertMeshToArrowTableWrapper(\n            formatLASMeshColors(convertTableToMesh(table) as LASMesh, options.las.colorFormat)\n          ),\n          loader: table.loader,\n          loaderData: table.loaderData,\n          progress: table.progress\n        };\n  if (getLASShape(options) === 'arrow') {\n    return formattedTable;\n  }\n  return {\n    ...(convertTableToMesh(formattedTable) as LASMesh),\n    loader: formattedTable.loader,\n    loaderData: formattedTable.loaderData,\n    progress: formattedTable.progress\n  } as LASMesh & {progress?: number};\n}\n\nasync function* convertLASMeshBatches(\n  tableBatches: AsyncIterable<LASArrowTable>,\n  options?: LASLoaderOptions\n): AsyncIterable<LASMesh | MeshArrowTable> {\n  for await (const table of paceBatchIterator(tableBatches, {\n    batchMaxRowsPerSecond: options?.core?.batchMaxRowsPerSecond,\n    getRowCount: batch => batch.data.numRows,\n    signal: options?.signal\n  })) {\n    yield convertLASMesh(table, options);\n  }\n}\n\n/** Hydrates transferred columns and applies the requested mesh and color representation on the caller. */\nfunction deserializeLASWorkerTable(\n  result: unknown,\n  options?: LASLoaderOptions\n): LASMesh | MeshArrowTable {\n  return convertLASMesh(deserializeArrowWorkerTable(result), options);\n}\n\n/** Exposes native Arrow while retaining the column worker and mesh compatibility paths. */\nexport const LASLoaderWithParser = {\n  ...LASColumnLoader,\n  dataType: LAS_LOADER_METADATA.dataType,\n  batchType: LAS_LOADER_METADATA.batchType,\n  parse: async (input: ArrayBuffer, options?: LASLoaderOptions) =>\n    toPublicLASResult(await LASColumnLoader.parse(input, options)),\n  parseSync: (input: ArrayBuffer, options?: LASLoaderOptions) =>\n    toPublicLASResult(LASColumnLoader.parseSync(input, options)),\n  async *parseInBatches(input, options) {\n    for await (const result of LASColumnLoader.parseInBatches(input, options)) {\n      if ('shape' in result) yield* getLASRecordBatches(result);\n      else yield result;\n    }\n  },\n  deserializeWorkerResult: (result: unknown, options?: LASLoaderOptions) =>\n    toPublicLASResult(deserializeLASWorkerTable(result, options)),\n  deserializeWorkerBatch(result: unknown, options?: LASLoaderOptions) {\n    const decoded = deserializeLASWorkerTable(result, options);\n    return 'shape' in decoded ? getLASRecordBatches(decoded)[0] : decoded;\n  }\n} as const satisfies LoaderWithParser<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;\n\n/** Unwraps the Arrow table with its complete file header. */\nexport function toPublicLASResult(result: LASMesh | MeshArrowTable): LASMesh | Table {\n  if (!('shape' in result)) return result;\n  const header = JSON.stringify((result as LASArrowTable).loaderData, (_key, value) =>\n    typeof value === 'bigint'\n      ? value.toString()\n      : ArrayBuffer.isView(value)\n        ? Array.from(value as Uint8Array)\n        : value\n  );\n  if (header) {\n    result.data.schema.metadata.set('loaders.gl.las.header', header);\n    for (const batch of result.data.batches)\n      batch.schema.metadata.set('loaders.gl.las.header', header);\n  }\n  return result.data;\n}\n\n/** Unwraps the record batches, retaining schema on empty LAS results. */\nexport function getLASRecordBatches(result: MeshArrowTable): RecordBatch[] {\n  const table = toPublicLASResult(result) as Table;\n  return table.batches.length ? table.batches : [makeArrowMetadataBatch(table.schema)];\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,0BAAuD;AAEvD,0BAAqC;AAErC,IAAAA,uBAAiE;AACjE,+BAKO;AACP,oCAGO;AAEP,uBAMO;AAaA,IAAM,kBAAkB;AAAA,EAC7B,GAAG;AAAA,EACH,UAAU;AAAA,EACV,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,sBAAsB;AAAA,EACtB,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,OAAO,OAAO,aAA0B,YACtC,eAAe,cAAc,aAAa,OAAO,GAAG,OAAO;AAAA,EAC7D,WAAW,CAAC,aAA0B,YACpC,eAAe,cAAc,aAAa,OAAO,GAAG,OAAO;AAAA,EAC7D,gBAAgB,iBAAiB,qBAAqB,SAA4B;AAChF,WAAO,0BAAsB,oCAAkB,qBAAqB,OAAO,GAAG,OAAO;AAAA,EACvF;AACF;AAOA,SAAS,cAAc,aAA0B,SAA2C;AAC1F,QAAM,eAAgB,SAA0C,KAAK;AACrE,SAAO,mBACH,6CAA2B,aAAa,aAAa,UAAU,WAAW,CAAC,CAAC,QAC5E,2BAAS,aAAa,OAAO;AACnC;AAEA,SAAS,eACP,OACA,SAC0B;AAC1B,QAAM,iBACJ,SAAS,KAAK,gBAAgB,UAAa,QAAQ,IAAI,gBAAgB,cACnE,QACA;AAAA,IACE,OAAG;AAAA,UACD,kDAAoB,yCAAmB,KAAK,GAAc,QAAQ,IAAI,WAAW;AAAA,IACnF;AAAA,IACA,QAAQ,MAAM;AAAA,IACd,YAAY,MAAM;AAAA,IAClB,UAAU,MAAM;AAAA,EAClB;AACN,UAAI,sCAAY,OAAO,MAAM,SAAS;AACpC,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,OAAI,yCAAmB,cAAc;AAAA,IACrC,QAAQ,eAAe;AAAA,IACvB,YAAY,eAAe;AAAA,IAC3B,UAAU,eAAe;AAAA,EAC3B;AACF;AAEA,gBAAgB,sBACd,cACA,SACyC;AACzC,mBAAiB,aAAS,uCAAkB,cAAc;AAAA,IACxD,uBAAuB,SAAS,MAAM;AAAA,IACtC,aAAa,WAAS,MAAM,KAAK;AAAA,IACjC,QAAQ,SAAS;AAAA,EACnB,CAAC,GAAG;AACF,UAAM,eAAe,OAAO,OAAO;AAAA,EACrC;AACF;AAGA,SAAS,0BACP,QACA,SAC0B;AAC1B,SAAO,mBAAe,2DAA4B,MAAM,GAAG,OAAO;AACpE;AAGO,IAAM,sBAAsB;AAAA,EACjC,GAAG;AAAA,EACH,UAAU,6CAAoB;AAAA,EAC9B,WAAW,6CAAoB;AAAA,EAC/B,OAAO,OAAO,OAAoB,YAChC,kBAAkB,MAAM,gBAAgB,MAAM,OAAO,OAAO,CAAC;AAAA,EAC/D,WAAW,CAAC,OAAoB,YAC9B,kBAAkB,gBAAgB,UAAU,OAAO,OAAO,CAAC;AAAA,EAC7D,OAAO,eAAe,OAAO,SAAS;AACpC,qBAAiB,UAAU,gBAAgB,eAAe,OAAO,OAAO,GAAG;AACzE,UAAI,WAAW,OAAQ,QAAO,oBAAoB,MAAM;AAAA,UACnD,OAAM;AAAA,IACb;AAAA,EACF;AAAA,EACA,yBAAyB,CAAC,QAAiB,YACzC,kBAAkB,0BAA0B,QAAQ,OAAO,CAAC;AAAA,EAC9D,uBAAuB,QAAiB,SAA4B;AAClE,UAAM,UAAU,0BAA0B,QAAQ,OAAO;AACzD,WAAO,WAAW,UAAU,oBAAoB,OAAO,EAAE,CAAC,IAAI;AAAA,EAChE;AACF;AAGO,SAAS,kBAAkB,QAAmD;AACnF,MAAI,EAAE,WAAW,QAAS,QAAO;AACjC,QAAM,SAAS,KAAK;AAAA,IAAW,OAAyB;AAAA,IAAY,CAAC,MAAM,UACzE,OAAO,UAAU,WACb,MAAM,SAAS,IACf,YAAY,OAAO,KAAK,IACtB,MAAM,KAAK,KAAmB,IAC9B;AAAA,EACR;AACA,MAAI,QAAQ;AACV,WAAO,KAAK,OAAO,SAAS,IAAI,yBAAyB,MAAM;AAC/D,eAAW,SAAS,OAAO,KAAK;AAC9B,YAAM,OAAO,SAAS,IAAI,yBAAyB,MAAM;AAAA,EAC7D;AACA,SAAO,OAAO;AAChB;AAGO,SAAS,oBAAoB,QAAuC;AACzE,QAAM,QAAQ,kBAAkB,MAAM;AACtC,SAAO,MAAM,QAAQ,SAAS,MAAM,UAAU,KAAC,4CAAuB,MAAM,MAAM,CAAC;AACrF;",
+  "names": ["import_schema_utils"]
 }

package/dist/las/las-loader.d.ts

@@ -1,9 +1,12 @@
+import type { Table, RecordBatch } from 'apache-arrow';
 import type { MeshArrowTable } from '@loaders.gl/core/schema';
 import { type LASLoaderOptions } from "./las-loader-shared.js";
-import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 import type { LASMesh } from "./lib/las-types.js";
 /** Parser-bearing TypeScript-only LAS loader implementation. */
-export declare const LASLoaderWithParser: {
+export declare const LASColumnLoader: {
+    readonly dataType: LASMesh | MeshArrowTable;
+    readonly batchType: LASMesh | MeshArrowTable;
     readonly worker: true;
     readonly workerInBatches: true;
     readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
@@ -13,12 +16,12 @@ export declare const LASLoaderWithParser: {
     readonly parse: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => Promise<LASMesh | MeshArrowTable>;
     readonly parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) => LASMesh | MeshArrowTable;
     readonly parseInBatches: (arrayBufferIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options?: LASLoaderOptions) => AsyncGenerator<LASMesh | MeshArrowTable, void, any>;
-    readonly dataType: LASMesh | MeshArrowTable;
-    readonly batchType: LASMesh | MeshArrowTable;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
     readonly version: any;
     readonly options: {
         readonly las: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
             readonly fp64: false;
             readonly colorDepth: 8;
             readonly colorFormat: "uint8norm";
@@ -41,5 +44,48 @@ export declare const LASLoaderWithParser: {
 };
 /** Hydrates transferred columns and applies the requested mesh and color representation on the caller. */
 declare function deserializeLASWorkerTable(result: unknown, options?: LASLoaderOptions): LASMesh | MeshArrowTable;
+/** Exposes native Arrow while retaining the column worker and mesh compatibility paths. */
+export declare const LASLoaderWithParser: {
+    readonly dataType: LASMesh | Table<any>;
+    readonly batchType: LASMesh | RecordBatch<any>;
+    readonly parse: (input: ArrayBuffer, options?: LASLoaderOptions) => Promise<LASMesh | Table<any>>;
+    readonly parseSync: (input: ArrayBuffer, options?: LASLoaderOptions) => LASMesh | Table<any>;
+    readonly parseInBatches: (input: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options: LASLoaderOptions | undefined) => AsyncGenerator<LASMesh | RecordBatch<any>, void, unknown>;
+    readonly deserializeWorkerResult: (result: unknown, options?: LASLoaderOptions) => LASMesh | Table<any>;
+    readonly deserializeWorkerBatch: (result: unknown, options?: LASLoaderOptions) => LASMesh | RecordBatch<any>;
+    readonly worker: true;
+    readonly workerInBatches: true;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
+    readonly serializeWorkerBatch: typeof serializeArrowWorkerTable;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
+    readonly version: any;
+    readonly options: {
+        readonly las: {
+            readonly shape: "arrow";
+            readonly fp64: false;
+            readonly colorDepth: 8;
+            readonly colorFormat: "uint8norm";
+            readonly columns: undefined;
+            readonly extraBytes: "raw";
+            readonly recoverMissingChunkTable: false;
+            readonly compatibilityMode: "auto";
+        };
+    };
+    readonly name: "LAS";
+    readonly id: "las";
+    readonly module: "pointclouds";
+    readonly encoding: "binary";
+    readonly format: "las";
+    readonly extensions: ["las", "laz"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly text: false;
+    readonly binary: true;
+    readonly tests: ["LASF"];
+};
+/** Unwraps the Arrow table with its complete file header. */
+export declare function toPublicLASResult(result: LASMesh | MeshArrowTable): LASMesh | Table;
+/** Unwraps the record batches, retaining schema on empty LAS results. */
+export declare function getLASRecordBatches(result: MeshArrowTable): RecordBatch[];
 export {};
 //# sourceMappingURL=las-loader.d.ts.map

package/dist/las/las-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"las-loader.d.ts","sourceRoot":"","sources":["../../src/las/las-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAIL,KAAK,gBAAgB,EACtB,+BAA4B;AAC7B,OAAO,EACL,yBAAyB,EAE1B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAmB7C,gEAAgE;AAChE,eAAO,MAAM,mBAAmB;;;;;;;kCAQH,WAAW,YAAY,gBAAgB;sCAEzC,WAAW,YAAY,gBAAgB;+LAEA,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CAOjF,CAAC;AA8CF,0GAA0G;AAC1G,iBAAS,yBAAyB,CAChC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,GAAG,cAAc,CAE1B"}
+{"version":3,"file":"las-loader.d.ts","sourceRoot":"","sources":["../../src/las/las-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,KAAK,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAIL,KAAK,gBAAgB,EACtB,+BAA4B;AAC7B,OAAO,EACL,yBAAyB,EAE1B,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAmB7C,gEAAgE;AAChE,eAAO,MAAM,eAAe;uBAEG,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,cAAc;;;;;;;kCAO3B,WAAW,YAAY,gBAAgB;sCAEzC,WAAW,YAAY,gBAAgB;+LAEA,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CAOjF,CAAC;AAiDF,0GAA0G;AAC1G,iBAAS,yBAAyB,CAChC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,GAAG,cAAc,CAE1B;AAED,2FAA2F;AAC3F,eAAO,MAAM,mBAAmB;;;4BAIT,WAAW,YAAY,gBAAgB;gCAEzC,WAAW,YAAY,gBAAgB;;+CAQxB,OAAO,YAAY,gBAAgB;8CAEtC,OAAO,YAAY,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI2B,CAAC;AAEhG,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,GAAG,OAAO,GAAG,KAAK,CAenF;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,EAAE,CAGzE"}

package/dist/las/las-loader.js

@@ -1,13 +1,17 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { convertMeshToTable, convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { paceBatchIterator } from '@loaders.gl/core/loader-utils';
+import { makeArrowMetadataBatch } from '@loaders.gl/core/schema-utils';
+import { convertMeshToArrowTableWrapper, convertTableToMesh } from '@loaders.gl/core/schema-utils';
 import { formatLASMeshColors, getLASShape, LAS_LOADER_METADATA } from "./las-loader-shared.js";
-import { serializeArrowWorkerTable, deserializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable, deserializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 import { decodeLAZChunkToArrowTable, parseLAS, parseLASInBatches } from "./lib/typescript/parse-las.js";
 /** Parser-bearing TypeScript-only LAS loader implementation. */
-export const LASLoaderWithParser = {
+export const LASColumnLoader = {
     ...LAS_LOADER_METADATA,
+    dataType: null,
+    batchType: null,
     worker: true,
     workerInBatches: true,
     serializeWorkerResult: serializeArrowWorkerTable,
@@ -31,12 +35,12 @@ function convertLASMesh(table, options) {
     const formattedTable = options?.las?.colorFormat === undefined || options.las.colorFormat === 'uint8norm'
         ? table
         : {
-            ...convertMeshToTable(formatLASMeshColors(convertTableToMesh(table), options.las.colorFormat), 'arrow-table'),
+            ...convertMeshToArrowTableWrapper(formatLASMeshColors(convertTableToMesh(table), options.las.colorFormat)),
             loader: table.loader,
             loaderData: table.loaderData,
             progress: table.progress
         };
-    if (getLASShape(options) === 'arrow-table') {
+    if (getLASShape(options) === 'arrow') {
         return formattedTable;
     }
     return {
@@ -47,7 +51,11 @@ function convertLASMesh(table, options) {
     };
 }
 async function* convertLASMeshBatches(tableBatches, options) {
-    for await (const table of tableBatches) {
+    for await (const table of paceBatchIterator(tableBatches, {
+        batchMaxRowsPerSecond: options?.core?.batchMaxRowsPerSecond,
+        getRowCount: batch => batch.data.numRows,
+        signal: options?.signal
+    })) {
         yield convertLASMesh(table, options);
     }
 }
@@ -55,4 +63,46 @@ async function* convertLASMeshBatches(tableBatches, options) {
 function deserializeLASWorkerTable(result, options) {
     return convertLASMesh(deserializeArrowWorkerTable(result), options);
 }
+/** Exposes native Arrow while retaining the column worker and mesh compatibility paths. */
+export const LASLoaderWithParser = {
+    ...LASColumnLoader,
+    dataType: LAS_LOADER_METADATA.dataType,
+    batchType: LAS_LOADER_METADATA.batchType,
+    parse: async (input, options) => toPublicLASResult(await LASColumnLoader.parse(input, options)),
+    parseSync: (input, options) => toPublicLASResult(LASColumnLoader.parseSync(input, options)),
+    async *parseInBatches(input, options) {
+        for await (const result of LASColumnLoader.parseInBatches(input, options)) {
+            if ('shape' in result)
+                yield* getLASRecordBatches(result);
+            else
+                yield result;
+        }
+    },
+    deserializeWorkerResult: (result, options) => toPublicLASResult(deserializeLASWorkerTable(result, options)),
+    deserializeWorkerBatch(result, options) {
+        const decoded = deserializeLASWorkerTable(result, options);
+        return 'shape' in decoded ? getLASRecordBatches(decoded)[0] : decoded;
+    }
+};
+/** Unwraps the Arrow table with its complete file header. */
+export function toPublicLASResult(result) {
+    if (!('shape' in result))
+        return result;
+    const header = JSON.stringify(result.loaderData, (_key, value) => typeof value === 'bigint'
+        ? value.toString()
+        : ArrayBuffer.isView(value)
+            ? Array.from(value)
+            : value);
+    if (header) {
+        result.data.schema.metadata.set('loaders.gl.las.header', header);
+        for (const batch of result.data.batches)
+            batch.schema.metadata.set('loaders.gl.las.header', header);
+    }
+    return result.data;
+}
+/** Unwraps the record batches, retaining schema on empty LAS results. */
+export function getLASRecordBatches(result) {
+    const table = toPublicLASResult(result);
+    return table.batches.length ? table.batches : [makeArrowMetadataBatch(table.schema)];
+}
 //# sourceMappingURL=las-loader.js.map

package/dist/las/las-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"las-loader.js","sourceRoot":"","sources":["../../src/las/las-loader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"las-loader.js","sourceRoot":"","sources":["../../src/las/las-loader.ts"],"names":[],"mappings":"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"}

package/dist/las/las-writer.cjs

@@ -26,7 +26,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.1" : "latest";
+var VERSION = true ? "5.0.0-beta.10" : "latest";
 var LAS_HEADER_LENGTH = 227;
 var LAS_1_4_HEADER_LENGTH = 375;
 var LAS_1_5_HEADER_LENGTH = 393;
@@ -476,13 +476,13 @@ function validateLAZOptions(version, pointDataRecordFormat, chunkSize) {
   }
 }
 function normalizeMesh(data) {
-  if ("shape" in data && data.shape === "arrow-table") {
+  if (!("attributes" in data)) {
     return (0, import_schema_utils.convertTableToMesh)(data);
   }
   return data;
 }
 function normalizeMeshArrowTable(data) {
-  return "shape" in data && data.shape === "arrow-table" ? data : (0, import_schema_utils.convertMeshToTable)(data, "arrow-table");
+  return !("attributes" in data) ? data : (0, import_schema_utils.convertMeshToArrowTableWrapper)(data);
 }
 function mergeMeshBatches(batches) {
   if (batches.length === 0) {