@loaders.gl/splats 4.5.3 → 5.0.0-alpha.10

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

@@ -1,5 +1,26 @@
 import type { MeshArrowTable } from '@loaders.gl/schema';
-/** Loader metadata for Niantic Spatial `.spz` Gaussian splat files. */
+import type { SplatsLoaderOptions } from "./types.js";
+/** Preloads the parser-bearing SPZ loader implementation. */
+declare function preload(): Promise<{
+    readonly parse: (arrayBuffer: ArrayBuffer, options?: SplatsLoaderOptions) => Promise<MeshArrowTable>;
+    readonly version: any;
+    readonly options: {
+        readonly splats: {
+            readonly shape: "arrow-table";
+        };
+    };
+    readonly name: "SPZ";
+    readonly id: "spz";
+    readonly module: "splats";
+    readonly format: "spz";
+    readonly extensions: ["spz"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: [ArrayBuffer];
+    readonly dataType: MeshArrowTable;
+    readonly batchType: never;
+}>;
+/** Metadata-only loader for Niantic Spatial `.spz` Gaussian splat files. */
 export declare const SPZLoader: {
     readonly version: any;
     readonly options: {
@@ -7,9 +28,11 @@ export declare const SPZLoader: {
             readonly shape: "arrow-table";
         };
     };
+    readonly preload: typeof preload;
     readonly name: "SPZ";
     readonly id: "spz";
     readonly module: "splats";
+    readonly format: "spz";
     readonly extensions: ["spz"];
     readonly mimeTypes: ["application/octet-stream"];
     readonly binary: true;
@@ -17,4 +40,5 @@ export declare const SPZLoader: {
     readonly dataType: MeshArrowTable;
     readonly batchType: never;
 };
+export {};
 //# sourceMappingURL=spz-loader-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spz-loader-types.d.ts","sourceRoot":"","sources":["../src/spz-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAQvD,uEAAuE;AACvE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;uBACS,cAAc;wBACxB,KAAK;CAQ6C,CAAC"}
+{"version":3,"file":"spz-loader-types.d.ts","sourceRoot":"","sources":["../src/spz-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAC,mBAAmB,EAAC,mBAAgB;AAOjD,6DAA6D;AAC7D,iBAAe,OAAO;;;;;;;;;;;;;;;;uBAOS,cAAc;wBACxB,KAAK;GALzB;AAED,4EAA4E;AAC5E,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;uBACS,cAAc;wBACxB,KAAK;CAS6C,CAAC"}

package/dist/spz-loader-types.js

@@ -4,8 +4,13 @@
 import { SPZFormat } from "./splats-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.5.3" !== 'undefined' ? "4.5.3" : 'latest';
-/** Loader metadata for Niantic Spatial `.spz` Gaussian splat files. */
+const VERSION = typeof "5.0.0-alpha.10" !== 'undefined' ? "5.0.0-alpha.10" : 'latest';
+/** Preloads the parser-bearing SPZ loader implementation. */
+async function preload() {
+    const { SPZLoaderWithParser } = await import("./spz-loader.js");
+    return SPZLoaderWithParser;
+}
+/** Metadata-only loader for Niantic Spatial `.spz` Gaussian splat files. */
 export const SPZLoader = {
     dataType: null,
     batchType: null,
@@ -15,6 +20,7 @@ export const SPZLoader = {
         splats: {
             shape: 'arrow-table'
         }
-    }
+    },
+    preload
 };
 //# sourceMappingURL=spz-loader-types.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"spz-loader-types.js","sourceRoot":"","sources":["../src/spz-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,2BAAwB;AAE1C,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,cAAkB,KAAK,WAAW,CAAC,CAAC,SAAa,CAAC,CAAC,QAAQ,CAAC;AAE5E,uEAAuE;AACvE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,QAAQ,EAAE,IAAiC;IAC3C,SAAS,EAAE,IAAa;IACxB,GAAG,SAAS;IACZ,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE;QACP,MAAM,EAAE;YACN,KAAK,EAAE,aAAa;SACrB;KACF;CACoE,CAAC"}
+{"version":3,"file":"spz-loader-types.js","sourceRoot":"","sources":["../src/spz-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,2BAAwB;AAE1C,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,uBAAkB,KAAK,WAAW,CAAC,CAAC,kBAAa,CAAC,CAAC,QAAQ,CAAC;AAE5E,6DAA6D;AAC7D,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,mBAAgB,CAAC;IAC3D,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,QAAQ,EAAE,IAAiC;IAC3C,SAAS,EAAE,IAAa;IACxB,GAAG,SAAS;IACZ,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE;QACP,MAAM,EAAE;YACN,KAAK,EAAE,aAAa;SACrB;KACF;IACD,OAAO;CAC8D,CAAC"}

package/dist/spz-loader.d.ts

@@ -12,6 +12,7 @@ export declare const SPZLoaderWithParser: {
     readonly name: "SPZ";
     readonly id: "spz";
     readonly module: "splats";
+    readonly format: "spz";
     readonly extensions: ["spz"];
     readonly mimeTypes: ["application/octet-stream"];
     readonly binary: true;

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

@@ -1 +1 @@
-{"version":3,"file":"spz-loader.d.ts","sourceRoot":"","sources":["../src/spz-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAC,mBAAmB,EAAC,mBAAgB;AAIjD,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB;kCAEH,WAAW,YAAY,mBAAmB;;;;;;;;;;;;;;;;CAEU,CAAC"}
+{"version":3,"file":"spz-loader.d.ts","sourceRoot":"","sources":["../src/spz-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAC,mBAAmB,EAAC,mBAAgB;AAMjD,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB;kCAEH,WAAW,YAAY,mBAAmB;;;;;;;;;;;;;;;;;CAEU,CAAC"}

package/dist/spz-loader.js

@@ -3,9 +3,10 @@
 // Copyright (c) vis.gl contributors
 import { parseSPZ } from "./lib/parse-spz.js";
 import { SPZLoader as SPZLoaderMetadata } from "./spz-loader-types.js";
+const { preload: _SPZLoaderPreload, ...SPZLoaderMetadataWithoutPreload } = SPZLoaderMetadata;
 /** Parser-bearing loader for Niantic Spatial `.spz` Gaussian splat files. */
 export const SPZLoaderWithParser = {
-    ...SPZLoaderMetadata,
+    ...SPZLoaderMetadataWithoutPreload,
     parse: async (arrayBuffer, options) => parseSPZ(arrayBuffer, options)
 };
 //# sourceMappingURL=spz-loader.js.map

package/dist/spz-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"spz-loader.js","sourceRoot":"","sources":["../src/spz-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,QAAQ,EAAC,2BAAwB;AACzC,OAAO,EAAC,SAAS,IAAI,iBAAiB,EAAC,8BAA2B;AAElE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,iBAAiB;IACpB,KAAK,EAAE,KAAK,EAAE,WAAwB,EAAE,OAA6B,EAAE,EAAE,CACvE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC+C,CAAC"}
+{"version":3,"file":"spz-loader.js","sourceRoot":"","sources":["../src/spz-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,QAAQ,EAAC,2BAAwB;AACzC,OAAO,EAAC,SAAS,IAAI,iBAAiB,EAAC,8BAA2B;AAElE,MAAM,EAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,+BAA+B,EAAC,GAAG,iBAAiB,CAAC;AAE3F,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,+BAA+B;IAClC,KAAK,EAAE,KAAK,EAAE,WAAwB,EAAE,OAA6B,EAAE,EAAE,CACvE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC+C,CAAC"}

package/dist/types.d.ts

@@ -4,8 +4,14 @@ export type SplatsLoaderOptions = LoaderOptions & {
     splats?: {
         /** Output shape. V1 supports loaders.gl Mesh Arrow tables. */
         shape?: 'arrow-table';
+        /** Coordinate frame stored in the source SPZ payload. */
+        sourceCoordinateSystem?: SPZCoordinateSystem;
+        /** Coordinate frame expected by the caller. Defaults to the source frame. */
+        targetCoordinateSystem?: SPZCoordinateSystem;
     };
 };
+/** Coordinate-system labels used by the SPZ container and glTF bridge. */
+export type SPZCoordinateSystem = 'RUB' | 'LUF' | 'RUF' | 'UNSPECIFIED';
 /** Linear Gaussian splat values before Arrow table construction. */
 export type GaussianSplats = {
     /** Source format identifier. */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,gDAAgD;AAChD,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,8DAA8D;QAC9D,KAAK,CAAC,EAAE,aAAa,CAAC;KACvB,CAAC;CACH,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG;IAC3B,gCAAgC;IAChC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;IAC3C,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,SAAS,EAAE,YAAY,CAAC;IACxB,0DAA0D;IAC1D,MAAM,EAAE,YAAY,CAAC;IACrB,uDAAuD;IACvD,SAAS,EAAE,YAAY,CAAC;IACxB,+CAA+C;IAC/C,MAAM,EAAE,UAAU,CAAC;IACnB,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,YAAY,CAAC;IACpC,kFAAkF;IAClF,SAAS,EAAE,YAAY,CAAC;IACxB,qDAAqD;IACrD,kBAAkB,CAAC,EAAE,YAAY,CAAC;IAClC,gDAAgD;IAChD,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,gCAAgC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,gDAAgD;AAChD,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD,MAAM,CAAC,EAAE;QACP,8DAA8D;QAC9D,KAAK,CAAC,EAAE,aAAa,CAAC;QACtB,yDAAyD;QACzD,sBAAsB,CAAC,EAAE,mBAAmB,CAAC;QAC7C,6EAA6E;QAC7E,sBAAsB,CAAC,EAAE,mBAAmB,CAAC;KAC9C,CAAC;CACH,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,CAAC;AAExE,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG;IAC3B,gCAAgC;IAChC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;IAC3C,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,SAAS,EAAE,YAAY,CAAC;IACxB,0DAA0D;IAC1D,MAAM,EAAE,YAAY,CAAC;IACrB,uDAAuD;IACvD,SAAS,EAAE,YAAY,CAAC;IACxB,+CAA+C;IAC/C,MAAM,EAAE,UAAU,CAAC;IACnB,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,YAAY,CAAC;IACpC,kFAAkF;IAClF,SAAS,EAAE,YAAY,CAAC;IACxB,qDAAqD;IACrD,kBAAkB,CAAC,EAAE,YAAY,CAAC;IAClC,gDAAgD;IAChD,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,gCAAgC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/splats",
-  "version": "4.5.3",
+  "version": "5.0.0-alpha.10",
   "description": "Framework-independent loaders for Gaussian splat formats",
   "license": "MIT",
   "type": "module",
@@ -78,9 +78,9 @@
     "build-bundle-dev": "ocular-bundle ./bundle.ts --env=dev --output=dist/dist.dev.js"
   },
   "dependencies": {
-    "@loaders.gl/compression": "4.5.3",
-    "@loaders.gl/loader-utils": "4.5.3",
-    "@loaders.gl/schema": "4.5.3",
+    "@loaders.gl/compression": "5.0.0-alpha.10",
+    "@loaders.gl/loader-utils": "5.0.0-alpha.10",
+    "@loaders.gl/schema": "5.0.0-alpha.10",
     "apache-arrow": ">= 17.0.0",
     "zod": "^4.1.12"
   },
@@ -88,7 +88,7 @@
     "zstd-codec": "^0.1.0"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "~4.5.0"
+    "@loaders.gl/core": "~5.0.0-alpha.0"
   },
-  "gitHead": "3ad4ab002b4a53ac5d88feb856117a8a1e8c5bb0"
+  "gitHead": "7cbfaef633e86356c946541dab4977b522745b6c"
 }

package/src/index.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-export type {GaussianSplats, SplatsLoaderOptions} from './types';
 export type {
   RADChunkMetadata,
   RADChunkMetadataJSON,
@@ -16,10 +15,12 @@ export type {
   RADSplatEncoding
 } from './lib/parse-rad';
 export {SPLATFormat, KSPLATFormat, SPZFormat, RADFormat} from './splats-format';
-export {SPLATLoaderWithParser as SPLATLoader} from './splat-loader';
-export {KSPLATLoaderWithParser as KSPLATLoader} from './ksplat-loader';
-export {SPZLoaderWithParser as SPZLoader} from './spz-loader';
-export {RADLoaderWithParser as RADLoader} from './rad-loader';
+export type {GaussianSplats, SPZCoordinateSystem, SplatsLoaderOptions} from './types';
+export {parseSPZ, parseSPZToGaussianSplats} from './lib/parse-spz';
+export {SPLATLoader} from './splat-loader-types';
+export {KSPLATLoader} from './ksplat-loader-types';
+export {SPZLoader} from './spz-loader-types';
+export {RADLoader} from './rad-loader-types';
 export type {
   RADChunkRequestOptions,
   RADChunkTableIteratorOptions,

package/src/ksplat-loader-types.ts

@@ -11,7 +11,13 @@ import {KSPLATFormat} from './splats-format';
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
-/** Loader metadata for `.ksplat` Gaussian splat files. */
+/** Preloads the parser-bearing KSPLAT loader implementation. */
+async function preload() {
+  const {KSPLATLoaderWithParser} = await import('./ksplat-loader');
+  return KSPLATLoaderWithParser;
+}
+
+/** Metadata-only loader for `.ksplat` Gaussian splat files. */
 export const KSPLATLoader = {
   dataType: null as unknown as MeshArrowTable,
   batchType: null as never,
@@ -21,5 +27,6 @@ export const KSPLATLoader = {
     splats: {
       shape: 'arrow-table'
     }
-  }
+  },
+  preload
 } as const satisfies Loader<MeshArrowTable, never, SplatsLoaderOptions>;

package/src/ksplat-loader.ts

@@ -8,9 +8,11 @@ import type {SplatsLoaderOptions} from './types';
 import {parseKSPLAT} from './lib/parse-ksplat';
 import {KSPLATLoader as KSPLATLoaderMetadata} from './ksplat-loader-types';
 
+const {preload: _KSPLATLoaderPreload, ...KSPLATLoaderMetadataWithoutPreload} = KSPLATLoaderMetadata;
+
 /** Parser-bearing loader for `.ksplat` Gaussian splat files. */
 export const KSPLATLoaderWithParser = {
-  ...KSPLATLoaderMetadata,
+  ...KSPLATLoaderMetadataWithoutPreload,
   parse: async (arrayBuffer: ArrayBuffer) => parseKSPLAT(arrayBuffer),
   parseSync: (arrayBuffer: ArrayBuffer) => parseKSPLAT(arrayBuffer)
 } as const satisfies LoaderWithParser<MeshArrowTable, never, SplatsLoaderOptions>;

package/src/lib/parse-ksplat.ts

@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-/* eslint-disable max-params */
-
 import type {MeshArrowTable} from '@loaders.gl/schema';
 import type {GaussianSplats} from '../types';
 import {makeGaussianSplatsArrowTable} from './splats-arrow-table';
@@ -114,7 +112,7 @@ export function parseKSPLATToGaussianSplats(data: ArrayBuffer): GaussianSplats {
     0,
     ...sections
       .slice(0, getActiveSectionCount(header))
-      .map((section) => getSphericalHarmonicsComponentCount(section.sphericalHarmonicsDegree))
+      .map(section => getSphericalHarmonicsComponentCount(section.sphericalHarmonicsDegree))
   );
 
   const positions = new Float32Array(splatCount * 3);
@@ -165,7 +163,7 @@ export function parseKSPLATToGaussianSplats(data: ArrayBuffer): GaussianSplats {
     loaderData: {
       format: 'ksplat',
       ...header,
-      sections: sections.slice(0, getActiveSectionCount(header)).map((section) => ({
+      sections: sections.slice(0, getActiveSectionCount(header)).map(section => ({
         splatCount: section.splatCount,
         maxSplatCount: section.maxSplatCount,
         sphericalHarmonicsDegree: section.sphericalHarmonicsDegree

package/src/lib/parse-rad-chunk.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {DeflateCompression} from '@loaders.gl/compression';
+import {DeflateDecompressor} from '@loaders.gl/compression/deflate-decompressor';
 import type {MeshArrowTable} from '@loaders.gl/schema';
 import type {GaussianSplats, SplatsLoaderOptions} from '../types';
 import {
@@ -15,8 +15,8 @@ import {
 import {makeGaussianSplatsArrowTable} from './splats-arrow-table';
 import {decodeFloat16, normalizeQuaternion, SH_C0} from './splat-utils';
 
-const RAD_PROPERTY_DEFLATE = new DeflateCompression();
-const RAD_PROPERTY_RAW_DEFLATE = new DeflateCompression({raw: true});
+const RAD_PROPERTY_DEFLATE = new DeflateDecompressor({useNative: false});
+const RAD_PROPERTY_RAW_DEFLATE = new DeflateDecompressor({raw: true, useNative: false});
 
 /** Options for decoding one Spark RADC chunk payload. */
 export type RADChunkDecodeOptions = SplatsLoaderOptions & {
@@ -210,7 +210,7 @@ function decodeRADSphericalHarmonics(
     return null;
   }
 
-  const decodedProperties = shProperties.map((entry) => ({
+  const decodedProperties = shProperties.map(entry => ({
     values: decodeRADFloatProperty(bytes, metadata, entry.property, entry.dimensions),
     dimensions: entry.dimensions
   }));
@@ -620,7 +620,7 @@ function findRADProperty(
   metadata: RADChunkMetadata,
   propertyName: string
 ): RADChunkProperty | undefined {
-  return metadata.properties.find((property) => property.property === propertyName);
+  return metadata.properties.find(property => property.property === propertyName);
 }
 
 /** Merges source-level splat encoding with chunk-local encoding. */

package/src/lib/parse-spz.ts

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ZstdCompression} from '@loaders.gl/compression';
+import {GZipDecompressor, ZstdDecompressor} from '@loaders.gl/compression';
 import type {MeshArrowTable} from '@loaders.gl/schema';
-import type {GaussianSplats, SplatsLoaderOptions} from '../types';
+import type {GaussianSplats, SPZCoordinateSystem, SplatsLoaderOptions} from '../types';
 import {makeGaussianSplatsArrowTable} from './splats-arrow-table';
 import {normalizeQuaternion} from './splat-utils';
 
@@ -46,20 +46,205 @@ export async function parseSPZToGaussianSplats(
   data: ArrayBuffer,
   options?: SplatsLoaderOptions
 ): Promise<GaussianSplats> {
+  const version = detectSPZVersion(data);
+  if (version === 0) {
+    return await parseLegacySPZ(data, options);
+  }
+  if (version !== SPZ_VERSION) {
+    throw new Error(`SPZLoader: version ${version} is not supported.`);
+  }
   const header = parseSPZHeader(data);
   const streamInfos = parseSPZStreamInfos(data, header, getSPZStreamByteLengths(header));
-  const compressedStreams = streamInfos.map((streamInfo) =>
+  const compressedStreams = streamInfos.map(streamInfo =>
     data.slice(streamInfo.compressedOffset, streamInfo.compressedOffset + streamInfo.compressedSize)
   );
-  const compression = new ZstdCompression({modules: options?.modules});
+  const decompressor = new ZstdDecompressor({modules: options?.modules});
   const streams = await Promise.all(
     compressedStreams.map((compressedStream, streamIndex) =>
-      compression.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)
+      decompressor.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)
     )
   );
 
   validateSPZStreamLengths(streams, streamInfos);
-  return decodeSPZStreams(header, streams, data);
+  return applySPZCoordinateSystem(
+    decodeSPZStreams(header, streams, data),
+    options?.splats?.sourceCoordinateSystem ?? 'RUB',
+    options?.splats?.targetCoordinateSystem ?? options?.splats?.sourceCoordinateSystem ?? 'RUB'
+  );
+}
+
+/** Detects the SPZ generation from either the legacy gzip or v4 plaintext header. */
+function detectSPZVersion(data: ArrayBuffer): number {
+  if (data.byteLength < 8) {
+    throw new Error('SPZLoader: file must contain at least an 8-byte header.');
+  }
+  const bytes = new Uint8Array(data);
+  if (bytes[0] === 0x1f && bytes[1] === 0x8b) {
+    // Legacy files carry their 16-byte header inside the gzip stream. The
+    // version is therefore read by parseLegacySPZ after decompression.
+    return 0;
+  }
+  if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
+    throw new Error('SPZLoader: file must contain a 32-byte header.');
+  }
+  return new DataView(data).getUint32(4, true);
+}
+
+/** Decodes the single-stream SPZ v2/v3 container. */
+async function parseLegacySPZ(
+  data: ArrayBuffer,
+  options?: SplatsLoaderOptions
+): Promise<GaussianSplats> {
+  const decompressed = await new GZipDecompressor({
+    modules: options?.modules,
+    useNative: true
+  }).decompress(data);
+  if (decompressed.byteLength < 16) {
+    throw new Error('SPZLoader: legacy payload must contain a 16-byte header.');
+  }
+  const dataView = new DataView(decompressed);
+  const header = {
+    magic: dataView.getUint32(0, true),
+    version: dataView.getUint32(4, true),
+    numPoints: dataView.getUint32(8, true),
+    shDegree: dataView.getUint8(12),
+    fractionalBits: dataView.getUint8(13),
+    flags: dataView.getUint8(14)
+  };
+  if (header.magic !== SPZ_MAGIC) {
+    throw new Error('SPZLoader: NGSP magic header not found.');
+  }
+  if (header.version !== 2 && header.version !== 3) {
+    throw new Error(`SPZLoader: version ${header.version} is not supported.`);
+  }
+  if (dataView.getUint8(15) !== 0) {
+    throw new Error('SPZLoader: legacy header reserved byte must be zero.');
+  }
+  if (header.shDegree > 3) {
+    throw new Error(`SPZLoader: spherical harmonics degree ${header.shDegree} is not supported.`);
+  }
+
+  const count = header.numPoints;
+  const shComponentCount = getSphericalHarmonicsComponentCount(header.shDegree);
+  const positionByteLength = count * 9;
+  const alphaByteLength = count;
+  const colorByteLength = count * 3;
+  const scaleByteLength = count * 3;
+  const rotationByteLength = count * (header.version === 2 ? 3 : 4);
+  const shByteLength = count * shComponentCount;
+  const payloadByteLength =
+    positionByteLength +
+    alphaByteLength +
+    colorByteLength +
+    scaleByteLength +
+    rotationByteLength +
+    shByteLength;
+  if (decompressed.byteLength - 16 !== payloadByteLength) {
+    throw new Error(
+      `SPZLoader: legacy payload has ${decompressed.byteLength - 16} bytes, expected ${payloadByteLength}.`
+    );
+  }
+
+  let offset = 16;
+  const positions = new Float32Array(count * 3);
+  const opacities = new Float32Array(count);
+  const colors = new Uint8Array(count * 3);
+  const scales = new Float32Array(count * 3);
+  const rotations = new Float32Array(count * 4);
+  const sphericalHarmonicDcs = new Float32Array(count * 3);
+  const sphericalHarmonics = shComponentCount
+    ? new Float32Array(count * shComponentCount)
+    : undefined;
+  decodeSPZPositions(
+    new Uint8Array(decompressed, offset, positionByteLength),
+    positions,
+    header.fractionalBits
+  );
+  offset += positionByteLength;
+  decodeSPZOpacities(new Uint8Array(decompressed, offset, alphaByteLength), opacities);
+  offset += alphaByteLength;
+  decodeSPZColors(
+    new Uint8Array(decompressed, offset, colorByteLength),
+    colors,
+    sphericalHarmonicDcs
+  );
+  offset += colorByteLength;
+  decodeSPZScales(new Uint8Array(decompressed, offset, scaleByteLength), scales);
+  offset += scaleByteLength;
+  if (header.version === 2) {
+    decodeLegacySPZRotations(new Uint8Array(decompressed, offset, rotationByteLength), rotations);
+  } else {
+    decodeSPZRotations(new Uint8Array(decompressed, offset, rotationByteLength), rotations);
+  }
+  offset += rotationByteLength;
+  if (sphericalHarmonics) {
+    decodeSPZSphericalHarmonics(
+      new Uint8Array(decompressed, offset, shByteLength),
+      sphericalHarmonics
+    );
+  }
+
+  return applySPZCoordinateSystem(
+    {
+      format: 'spz',
+      splatCount: count,
+      positions,
+      scales,
+      rotations,
+      colors,
+      sphericalHarmonicDcs,
+      opacities,
+      sphericalHarmonics,
+      sphericalHarmonicsComponentCount: shComponentCount || undefined,
+      loaderData: {...header, legacy: true}
+    },
+    options?.splats?.sourceCoordinateSystem ?? 'RUB',
+    options?.splats?.targetCoordinateSystem ?? options?.splats?.sourceCoordinateSystem ?? 'RUB'
+  );
+}
+
+/** Decodes the three signed bytes used by SPZ v2 rotations. */
+function decodeLegacySPZRotations(rotationStream: Uint8Array, rotations: Float32Array): void {
+  for (let splatIndex = 0; splatIndex < rotations.length / 4; splatIndex++) {
+    const byteOffset = splatIndex * 3;
+    const x = signedByte(rotationStream[byteOffset]) / 127;
+    const y = signedByte(rotationStream[byteOffset + 1]) / 127;
+    const z = signedByte(rotationStream[byteOffset + 2]) / 127;
+    const w = Math.sqrt(Math.max(0, 1 - x * x - y * y - z * z));
+    const normalized = normalizeQuaternion(w, x, y, z);
+    rotations.set(normalized, splatIndex * 4);
+  }
+}
+
+/** Converts an unsigned byte containing a signed int8 value. */
+function signedByte(value: number): number {
+  return value > 127 ? value - 256 : value;
+}
+
+/** Applies the explicitly requested SPZ coordinate conversion. */
+function applySPZCoordinateSystem(
+  splats: GaussianSplats,
+  source: SPZCoordinateSystem,
+  target: SPZCoordinateSystem
+): GaussianSplats {
+  if (source === target || source === 'UNSPECIFIED' || target === 'UNSPECIFIED') {
+    return splats;
+  }
+  if (source === 'RUB' && target === 'LUF') {
+    for (let index = 0; index < splats.positions.length; index += 3) {
+      splats.positions[index] = -splats.positions[index];
+      splats.positions[index + 2] = -splats.positions[index + 2];
+    }
+    for (let index = 0; index < splats.rotations.length; index += 4) {
+      splats.rotations[index + 1] = -splats.rotations[index + 1];
+      splats.rotations[index + 3] = -splats.rotations[index + 3];
+    }
+    return splats;
+  }
+  if (source === 'LUF' && target === 'RUB') {
+    return applySPZCoordinateSystem(splats, 'RUB', 'LUF');
+  }
+  throw new Error(`SPZLoader: coordinate conversion ${source} -> ${target} is not supported.`);
 }
 
 /** Parses and validates the SPZ v4 plaintext header. */
@@ -161,7 +346,7 @@ function getSPZStreamByteLengths(header: SPZHeader): number[] {
     header.numPoints * 3,
     header.numPoints * 4,
     header.numPoints * getSphericalHarmonicsComponentCount(header.shDegree)
-  ].filter((byteLength) => byteLength > 0);
+  ].filter(byteLength => byteLength > 0);
 }
 
 /** Validates that decompressed stream lengths match the TOC. */
@@ -197,7 +382,7 @@ function decodeSPZStreams(
     scaleStream,
     rotationStream,
     sphericalHarmonicsStream
-  ] = streams.map((stream) => new Uint8Array(stream));
+  ] = streams.map(stream => new Uint8Array(stream));
 
   decodeSPZPositions(positionStream, positions, header.fractionalBits);
   decodeSPZScales(scaleStream, scales);

package/src/lib/splats-arrow-table.ts

@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-/* eslint-disable max-params */
-
 import * as arrow from 'apache-arrow';
 import type {Field, MeshArrowTable, Schema} from '@loaders.gl/schema';
 import type {GaussianSplats} from '../types';

package/src/rad-loader-types.ts

@@ -10,11 +10,18 @@ import type {RADMetadata} from './lib/parse-rad';
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
-/** Loader metadata for Spark `.rad` paged LoD Gaussian splat containers. */
+/** Preloads the parser-bearing RAD loader implementation. */
+async function preload() {
+  const {RADLoaderWithParser} = await import('./rad-loader');
+  return RADLoaderWithParser;
+}
+
+/** Metadata-only loader for Spark `.rad` paged LoD Gaussian splat containers. */
 export const RADLoader = {
   dataType: null as unknown as RADMetadata,
   batchType: null as never,
   ...RADFormat,
   version: VERSION,
-  options: {}
+  options: {},
+  preload
 } as const satisfies Loader<RADMetadata, never, LoaderOptions>;

package/src/rad-loader.ts

@@ -14,9 +14,11 @@ export {
   type RADChunkDecodeOptions
 } from './lib/parse-rad-chunk';
 
+const {preload: _RADLoaderPreload, ...RADLoaderMetadataWithoutPreload} = RADLoaderMetadata;
+
 /** Parser-bearing loader for Spark `.rad` paged LoD Gaussian splat container metadata. */
 export const RADLoaderWithParser = {
-  ...RADLoaderMetadata,
+  ...RADLoaderMetadataWithoutPreload,
   parse: async (arrayBuffer: ArrayBuffer) => parseRADHeader(arrayBuffer),
   parseSync: (arrayBuffer: ArrayBuffer) => parseRADHeader(arrayBuffer)
 } as const satisfies LoaderWithParser<RADMetadata, never, LoaderOptions>;

package/src/rad-source-loader.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {DataSourceOptions} from '@loaders.gl/loader-utils';
+import type {CoreAPI, DataSourceOptions, SourceLoader} from '@loaders.gl/loader-utils';
 import {DataSource} from '@loaders.gl/loader-utils';
 import type {MeshArrowTable} from '@loaders.gl/schema';
 import {RADFormat} from './splats-format';
@@ -88,9 +88,12 @@ export const RADSourceLoader = {
   },
 
   testURL: (url: string): boolean => /\.rad(?:$|[?#])/i.test(url),
-  createDataSource: (data: string | Blob, options: RADSourceLoaderOptions): RADSource =>
-    new RADSource(data, options)
-} as const;
+  createDataSource: (
+    data: string | Blob,
+    options: RADSourceLoaderOptions,
+    coreApi?: CoreAPI
+  ): RADSource => new RADSource(data, options, coreApi)
+} as const satisfies SourceLoader<RADSource>;
 
 /** Runtime source for RAD metadata and chunk-byte access. */
 export class RADSource extends DataSource<string | Blob, RADSourceLoaderOptions> {
@@ -102,8 +105,8 @@ export class RADSource extends DataSource<string | Blob, RADSourceLoaderOptions>
   /** Lazily initialized per-chunk metadata promises. */
   private _chunkMetadataPromises: Map<number, Promise<RADChunkMetadata>> = new Map();
 
-  constructor(data: string | Blob, options: RADSourceLoaderOptions) {
-    super(data, options, RADSourceLoader.defaultOptions);
+  constructor(data: string | Blob, options: RADSourceLoaderOptions, coreApi?: CoreAPI) {
+    super(data, options, RADSourceLoader.defaultOptions, coreApi);
     this.metadata = this.getMetadata();
   }
 
@@ -173,7 +176,7 @@ export class RADSource extends DataSource<string | Blob, RADSourceLoaderOptions>
   ): Promise<RADChunkMetadata> {
     let chunkMetadataPromise = this._chunkMetadataPromises.get(chunkIndex);
     if (!chunkMetadataPromise) {
-      chunkMetadataPromise = this.getChunk(chunkIndex, options).then((chunk) =>
+      chunkMetadataPromise = this.getChunk(chunkIndex, options).then(chunk =>
         parseRADChunkHeader(chunk)
       );
       this._chunkMetadataPromises.set(chunkIndex, chunkMetadataPromise);
@@ -347,7 +350,17 @@ export class RADSource extends DataSource<string | Blob, RADSourceLoaderOptions>
 
   /** Fetches through custom source fetch hooks or the injected core fetchFile helper. */
   private async _fetchResponse(url: string, requestInit: RequestInit): Promise<Response> {
-    return await this.fetch(url, requestInit);
+    if (this._hasCustomFetch()) {
+      return await this.fetch(url, requestInit);
+    }
+    return this.hasCoreApi
+      ? await this.coreApi.fetchFile(url, requestInit)
+      : await this.fetch(url, requestInit);
+  }
+
+  /** Returns true when source options supplied an explicit fetch override. */
+  private _hasCustomFetch(): boolean {
+    return Boolean(this.loadOptions?.core?.fetch || this.loadOptions?.fetch);
   }
 
   /** Builds request options for RAD fetches. */