@loaders.gl/tile-converter 5.0.0-alpha.12 → 5.0.0-alpha.14

package/src/v5/mesh-source.ts

@@ -3,14 +3,10 @@
 // Copyright (c) vis.gl contributors
 
 import {Matrix4} from '@math.gl/core';
-import type {MeshAttribute} from '@loaders.gl/schema';
-import type {
-  GLTFPostprocessed,
-  GLTFNodePostprocessed,
-  GLTFMeshPrimitivePostprocessed,
-  GLTFMaterialPostprocessed
-} from '@loaders.gl/gltf';
-import type {Tileset3D, TilesetSourceMetadata} from '@loaders.gl/tiles';
+import type {MeshAttribute} from '@loaders.gl/core/schema';
+import type {GLTFWithBuffers, GLTFMeshPrimitive, GLTFMaterial} from '@loaders.gl/gltf';
+import {getGLTFAccessor, getGLTFAccessorValue} from '@loaders.gl/gltf';
+import type {Tileset3D, TilesetSourceMetadata} from '@loaders.gl/tiles-3d';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 import type {TileConversionSource} from '@loaders.gl/tile-converter/v5/core';
 import {createTilesetConversionSource} from '@loaders.gl/tile-converter/v5/core';
@@ -22,7 +18,7 @@ import {resolveMeshSourceTexture} from './mesh-source-texture.js';
 import {extractMeshFeatures} from './mesh-source-features.js';
 import type {MeshSourceFeatureOptions} from './mesh-source-features.js';
 import type {MeshSourceSchemaOptions} from './mesh-source-schema.js';
-import type {I3SMeshFeatures} from '@loaders.gl/i3s';
+import type {I3SMeshFeatures} from '@loaders.gl/tiles-3d/i3s';
 export type {MeshSourceFeatureOptions} from './mesh-source-features.js';
 
 /** Source mesh with optional explicit-schema feature data and triangle association. */
@@ -50,7 +46,7 @@ export interface MeshTilesetSourceOptions extends TilesetConversionSourceOptions
  * optional buffer-view or base64 data-URI PNG/JPEG images, TEXCOORD_0, glTF sampling and
  * KHR_texture_transform controls on TEXCOORD_0. Decode content with
  * `gltf.excludeExtensions: {KHR_texture_transform: false}` to retain authored UVs/transforms.
- * Triangle strips are expanded with alternating winding; the glTF loader already expands fans.
+ * Triangle strips are expanded with alternating winding; fans are expanded explicitly at the mesh boundary.
  * Shared traversal retains placement identity and unloads content according to the supplied policy.
  * The adapter applies node transforms, glTF up-axis correction, RTC translation, and tile placement
  * once, retaining Float64 absolute positions and inverse-transpose unit normals. Animation, skins,
@@ -120,7 +116,7 @@ export function createMeshTilesetConversionSource(
               'Content metadata requires a separate mapping'
             );
           const payload = content.payload as {
-            gltf?: GLTFPostprocessed;
+            gltf?: GLTFWithBuffers;
             gltfUpAxis?: string;
             rtcCenter?: number[];
             type?: string;
@@ -137,7 +133,8 @@ export function createMeshTilesetConversionSource(
               'Mesh extraction requires decoded GLB/glTF or B3DM content'
             );
           }
-          const gltf = payload.gltf;
+          const gltfWithBuffers = payload.gltf;
+          const gltf = gltfWithBuffers.json;
           if (
             gltf.animations?.length ||
             gltf.skins?.length ||
@@ -154,7 +151,9 @@ export function createMeshTilesetConversionSource(
           if (!['X', 'Y', 'Z'].includes(axis))
             throw new TileConversionError('MESH_SOURCE_AXIS_UNSUPPORTED', 'Unknown glTF up axis');
           const placement = new Matrix4(item.tile.computedTransform);
-          const rtc = payload.rtcCenter || gltf.extensions?.CESIUM_RTC?.center;
+          const rtc =
+            payload.rtcCenter ||
+            (gltf.extensions?.CESIUM_RTC as {center?: number[]} | undefined)?.center;
           if (rtc) {
             if (rtc.length !== 3 || rtc.some((value: number) => !Number.isFinite(value)))
               throw new TileConversionError(
@@ -168,19 +167,21 @@ export function createMeshTilesetConversionSource(
           if (axis === 'X')
             placement.multiplyRight(new Matrix4([0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]));
           const roots =
-            gltf.scene?.nodes || (gltf.scenes?.length === 1 ? gltf.scenes[0].nodes : undefined);
+            (gltf.scene !== undefined ? gltf.scenes?.[gltf.scene]?.nodes : undefined) ||
+            (gltf.scenes?.length === 1 ? gltf.scenes[0].nodes : undefined);
           if (!roots?.length)
             throw new TileConversionError(
               'MESH_SOURCE_SCENE_UNSUPPORTED',
               'A default scene or exactly one scene is required'
             );
           let primitiveIndex = 0;
-          const primitives = traverseMeshNodes(roots, placement);
+          const primitives = traverseMeshNodes(gltfWithBuffers, roots, placement);
           let current = primitives.next();
           while (!current.done) {
             const selected = current.value;
             const next = primitives.next();
             const resource = await extractPrimitive(
+              gltfWithBuffers,
               selected.primitive,
               selected.transform,
               `${item.tile.id}/${content.index}/${primitiveIndex++}`,
@@ -189,7 +190,7 @@ export function createMeshTilesetConversionSource(
               signal
             );
             const features = extractMeshFeatures(
-              gltf,
+              gltfWithBuffers,
               selected.primitive,
               payload,
               resource.mesh,
@@ -213,16 +214,19 @@ export function createMeshTilesetConversionSource(
   };
 }
 
-/** Walks scene placements without deduplicating a shared mesh or mutating postprocessed nodes. */
+/** Walks scene placements without deduplicating a shared mesh or mutating source nodes. */
 function* traverseMeshNodes(
-  nodes: readonly GLTFNodePostprocessed[],
+  gltf: GLTFWithBuffers,
+  nodes: readonly number[],
   parent: Matrix4,
-  ancestors = new Set<GLTFNodePostprocessed>()
-): Generator<{primitive: GLTFMeshPrimitivePostprocessed; transform: Matrix4}> {
-  for (const node of nodes) {
+  ancestors = new Set<number>()
+): Generator<{primitive: GLTFMeshPrimitive; transform: Matrix4}> {
+  for (const nodeIndex of nodes) {
+    const node = gltf.json.nodes![nodeIndex];
     if (
-      ancestors.has(node) ||
-      node.skin ||
+      !node ||
+      ancestors.has(nodeIndex) ||
+      node.skin !== undefined ||
       node.weights ||
       Object.keys(node.extensions || {}).length
     )
@@ -238,21 +242,28 @@ function* traverseMeshNodes(
             .multiplyRight(new Matrix4().fromQuaternion(node.rotation || [0, 0, 0, 1]))
             .scale(node.scale || [1, 1, 1])
     );
-    if (node.mesh) {
-      if (node.mesh.weights || Object.keys(node.mesh.extensions || {}).length)
+    if (node.mesh !== undefined) {
+      const mesh = gltf.json.meshes![node.mesh];
+      if (mesh.weights || Object.keys(mesh.extensions || {}).length)
         throw new TileConversionError(
           'MESH_SOURCE_NODE_UNSUPPORTED',
           'Morph weights and mesh extensions are unsupported'
         );
-      for (const primitive of node.mesh.primitives) yield {primitive, transform};
+      for (const primitive of mesh.primitives) yield {primitive, transform};
     }
-    yield* traverseMeshNodes(node.children || [], transform, new Set([...ancestors, node]));
+    yield* traverseMeshNodes(
+      gltf,
+      node.children || [],
+      transform,
+      new Set([...ancestors, nodeIndex])
+    );
   }
 }
 
 /** Copies one packed primitive, places it once, and derives a useful ECEF local origin. */
 async function extractPrimitive(
-  primitive: GLTFMeshPrimitivePostprocessed,
+  gltf: GLTFWithBuffers,
+  primitive: GLTFMeshPrimitive,
   transform: Matrix4,
   id: string,
   readExternalResource: MeshTilesetSourceOptions['readExternalResource'],
@@ -280,7 +291,8 @@ async function extractPrimitive(
       'Mesh placement requires a finite invertible affine transform with positive determinant'
     );
   const attributes: Record<string, MeshAttribute> = {};
-  for (const [name, accessor] of Object.entries(primitive.attributes)) {
+  for (const [name, reference] of Object.entries(primitive.attributes)) {
+    const accessor = getGLTFAccessor(gltf, reference);
     if (name === '_BATCHID' || /^_FEATURE_ID_\d+$/.test(name)) continue;
     if (!['POSITION', 'NORMAL', 'COLOR_0', 'TEXCOORD_0'].includes(name))
       throw new TileConversionError(
@@ -288,17 +300,17 @@ async function extractPrimitive(
         `Unsupported mesh attribute ${name}`
       );
     attributes[name] = {
-      value: accessor.value as MeshAttribute['value'],
-      size: accessor.components,
+      value: getGLTFAccessorValue(gltf, reference) as MeshAttribute['value'],
+      size: accessor.type === 'SCALAR' ? 1 : Number(accessor.type.slice(3)),
       ...(accessor.normalized ? {normalized: true} : {})
     };
   }
   const mesh = validateMeshGeometry(
     {
       topology: 'triangle-list',
-      mode: primitive.mode === 5 ? 4 : (primitive.mode ?? 4),
+      mode: [5, 6].includes(primitive.mode ?? 4) ? 4 : (primitive.mode ?? 4),
       attributes,
-      indices: createTriangleIndices(primitive, (attributes.POSITION?.value.length ?? 0) / 3)
+      indices: createTriangleIndices(gltf, primitive, (attributes.POSITION?.value.length ?? 0) / 3)
     },
     true
   );
@@ -336,20 +348,22 @@ async function extractPrimitive(
     mesh,
     origin: minimum.map((value, axis) => value / 2 + maximum[axis] / 2) as [number, number, number],
     material: await mapMeshSourceMaterial(
-      primitive.material,
+      primitive.material === undefined ? undefined : gltf.json.materials?.[primitive.material],
       readExternalResource,
       contentUri,
-      signal
+      signal,
+      gltf
     )
   };
 }
 
 /** Maps supported PBR controls and an embedded base-color image, rejecting unmapped semantics. */
 export async function mapMeshSourceMaterial(
-  material: GLTFMaterialPostprocessed | undefined,
+  material: GLTFMaterial | undefined,
   readExternalResource: MeshTilesetSourceOptions['readExternalResource'],
   contentUri: string | undefined,
-  signal?: AbortSignal
+  signal: AbortSignal | undefined,
+  gltf: GLTFWithBuffers
 ): Promise<MeshTileMaterial | undefined> {
   if (!material) return undefined;
   const pbr = material.pbrMetallicRoughness;
@@ -384,6 +398,7 @@ export async function mapMeshSourceMaterial(
     ...('baseColorTexture' in (pbr || {})
       ? {
           baseColorTexture: await resolveMeshSourceTexture(
+            gltf,
             pbr!.baseColorTexture,
             readExternalResource,
             contentUri,
@@ -401,17 +416,20 @@ export async function mapMeshSourceMaterial(
 
 /** Expands a strip without changing vertex storage, feature IDs, source indices, or parity. */
 function createTriangleIndices(
-  primitive: GLTFMeshPrimitivePostprocessed,
+  gltf: GLTFWithBuffers,
+  primitive: GLTFMeshPrimitive,
   vertexCount: number
 ): MeshAttribute | undefined {
-  const attribute = primitive.indices
+  const accessor =
+    primitive.indices === undefined ? undefined : getGLTFAccessor(gltf, primitive.indices);
+  const attribute = accessor
     ? {
-        value: primitive.indices.value as MeshAttribute['value'],
-        size: primitive.indices.components,
-        normalized: primitive.indices.normalized
+        value: getGLTFAccessorValue(gltf, accessor) as MeshAttribute['value'],
+        size: 1,
+        normalized: accessor.normalized
       }
     : undefined;
-  if (primitive.mode !== 5) return attribute;
+  if (primitive.mode !== 5 && primitive.mode !== 6) return attribute;
   const sourceIndices = validateMeshIndices(attribute, vertexCount, 5);
   const indexCount = sourceIndices?.length ?? vertexCount;
   if (!Number.isSafeInteger(indexCount) || indexCount < 3) {
@@ -424,9 +442,10 @@ function createTriangleIndices(
   const indices = new IndexArray((indexCount - 2) * 3);
   for (let triangle = 0; triangle < indexCount - 2; triangle++) {
     // Match the glTF strip equation, including degenerate connectors; they advance parity too.
-    const second = triangle + 1 + (triangle % 2);
-    const third = triangle + 2 - (triangle % 2);
-    indices[triangle * 3] = sourceIndices?.[triangle] ?? triangle;
+    const second = primitive.mode === 6 ? triangle + 1 : triangle + 1 + (triangle % 2);
+    const third = primitive.mode === 6 ? triangle + 2 : triangle + 2 - (triangle % 2);
+    const first = primitive.mode === 6 ? 0 : triangle;
+    indices[triangle * 3] = sourceIndices?.[first] ?? first;
     indices[triangle * 3 + 1] = sourceIndices?.[second] ?? second;
     indices[triangle * 3 + 2] = sourceIndices?.[third] ?? third;
   }

package/src/v5/mesh-tileset-archive.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Tiles3DArchiveWriter} from '@loaders.gl/3d-tiles/3d-tiles-archive-writer';
+import {Tiles3DArchiveWriter} from '@loaders.gl/tiles-3d/3d-tiles/3d-tiles-archive-writer';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 import type {BrowserTileConversionFile} from '@loaders.gl/tile-converter/v5/core';
 

package/src/v5/mesh-tileset-sink.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Tiles3DTilesetJSON, Tiles3DTileJSON} from '@loaders.gl/3d-tiles';
+import type {Tiles3DTilesetJSON, Tiles3DTileJSON} from '@loaders.gl/tiles-3d/3d-tiles';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 import type {TileConversionSink} from '@loaders.gl/tile-converter/v5/core';
 import {createBoundedMemoryTileConversionSink} from '@loaders.gl/tile-converter/v5/core';

package/src/v5/mesh.ts

@@ -4,7 +4,7 @@
 
 import {GLTFScenegraph, GLTFWriter} from '@loaders.gl/gltf';
 import {getBinaryImageMetadata} from '@loaders.gl/images';
-import type {MeshAttribute, MeshGeometry} from '@loaders.gl/schema';
+import type {MeshAttribute, MeshGeometry} from '@loaders.gl/core/schema';
 import {
   prepareMeshFeatureGeometry,
   encodeMeshFeatures,

package/src/v5/node-cli.ts

@@ -31,6 +31,7 @@ const HELP = `Usage: tile-converter-v5 inspect|convert|validate <input path or U
   --max-resources N            Lower the 1,000 content-declaration limit
   --max-documents N            Lower the 32 metadata-document limit
   --max-output-bytes N         Lower the 32 MiB output/archive budget
+  --profile                   Include elapsed conversion stage timings in JSON
   --help                      Show this help
 
 Inspect reads metadata only, following declared .json external tilesets.
@@ -54,6 +55,7 @@ export async function runTileConverterCLI(
       allowPositionals: true,
       options: {
         help: {type: 'boolean'},
+        profile: {type: 'boolean'},
         'preserve-hierarchy': {type: 'boolean'},
         'input-format': {type: 'string', default: '3d-tiles'},
         'max-input-bytes': {type: 'string', default: String(NODE_TILESET_LIMITS.maxInputBytes)},
@@ -123,6 +125,7 @@ export async function runTileConverterCLI(
         ...sourceOptions,
         ...features,
         resourceIds: values.resource,
+        profile: values.profile,
         preserveHierarchy: values['preserve-hierarchy'],
         outputFormat: values['output-format'] as NodeTileConversionOutputFormat,
         output: values.output,
@@ -139,6 +142,7 @@ export async function runTileConverterCLI(
       return 0;
     }
     if (
+      values.profile !== undefined ||
       values['feature-schema'] !== undefined ||
       values['preserve-hierarchy'] !== undefined ||
       values['geometric-error'] !== undefined ||

package/src/v5/node-conversion.ts

@@ -35,6 +35,8 @@ export type NodeTileConversionOutputFormat = '3d-tiles' | '3tz' | 'slpk';
 /** Selected static mesh conversion with application-owned Node output. */
 export interface NodeTileConversionOptions
   extends Omit<NodeTilesetConversionSourceOptions, 'format'> {
+  /** Include portable stages and Node setup/output elapsed milliseconds in the report. */
+  readonly profile?: boolean;
   /** Explicit 3D Tiles, I3S layer or indexed archive source. */
   readonly format?: '3d-tiles' | '3tz' | 'i3s' | 'slpk';
   /** Explicit I3S attribute mapping, also supplied by the CLI feature-schema file. */
@@ -61,6 +63,8 @@ export interface NodeTileConversionOptions
 export async function convertNodeTileset(
   options: NodeTileConversionOptions
 ): Promise<TileConversionReport> {
+  const started = options.profile ? performance.now() : 0;
+  let setupMilliseconds = 0;
   const signal = options.signal ?? new AbortController().signal;
   const maxOutputBytes = options.maxOutputBytes ?? SELECTED_MESH_LIMITS.maxOutputBytes;
   if (
@@ -124,7 +128,7 @@ export async function convertNodeTileset(
   let report: TileConversionReport;
   try {
     const inspection = await rawSource.inspect(signal);
-    await import('@loaders.gl/polyfills');
+    await import('@loaders.gl/core/polyfills');
     const {getDracoLibraryOptions} = await import('@loaders.gl/draco/bundled');
     const dracoLibraryOptions = getDracoLibraryOptions({
       decoderProfile: 'full',
@@ -155,7 +159,9 @@ export async function convertNodeTileset(
             }
           );
     const {source, spatialContext, geometricError} = selection;
+    setupMilliseconds = options.profile ? performance.now() - started : 0;
     const common = {
+      profile: options.profile,
       source,
       signal,
       measureInputBytes: measureMeshBytes,
@@ -209,6 +215,7 @@ export async function convertNodeTileset(
   } finally {
     await rawSource.close();
   }
+  const outputStarted = options.profile ? performance.now() : 0;
   signal.throwIfAborted();
   // Validate packaging as well as content, including on the write-free validation path.
   if (options.outputFormat !== '3d-tiles' && !options.output) {
@@ -227,7 +234,17 @@ export async function convertNodeTileset(
       maxOutputBytes,
       signal
     );
-  return report;
+  return report.timings
+    ? {
+        ...report,
+        timings: {
+          ...report.timings,
+          setupMilliseconds,
+          outputMilliseconds: performance.now() - outputStarted,
+          totalMilliseconds: performance.now() - started
+        }
+      }
+    : report;
 }
 
 /** Saves fixed relative resource names or an archive; existing destinations are never overwritten. */

package/src/v5/node-source.ts

@@ -5,8 +5,8 @@
 import {open, realpath} from 'node:fs/promises';
 import {basename, dirname, isAbsolute, relative, resolve, sep} from 'node:path';
 import {fileURLToPath} from 'node:url';
-import type {ReadableFile} from '@loaders.gl/loader-utils';
-import {parse3DTilesArchive} from '@loaders.gl/3d-tiles';
+import type {ReadableFile} from '@loaders.gl/core/loader-utils';
+import {parse3DTilesArchive} from '@loaders.gl/tiles-3d/3d-tiles';
 import {
   createBrowserTilesetConversionSource,
   TileConversionError

package/src/v5/point-cloud-attributes.ts

@@ -0,0 +1,113 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Mesh, MeshArrowTable} from '@loaders.gl/core/schema';
+import {convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
+
+/** Explicit source-name mapping and authorized semantic losses. */
+export interface PointCloudAttributeMapping {
+  /** Destination attribute name to source attribute name. Values and normalization remain unchanged. */
+  readonly attributes: Readonly<Record<string, string>>;
+  /** Source attributes intentionally omitted, each with a nonempty reason. */
+  readonly drop?: Readonly<Record<string, string>>;
+}
+
+/** Decoded mapped rows and a record of every authorized omission. */
+export interface MappedPointCloud {
+  /** Mesh with renamed attributes sharing immutable source values. */
+  readonly mesh: Mesh;
+  /** Explicit source-name/reason pairs, sorted deterministically. */
+  readonly droppedAttributes: Readonly<Record<string, string>>;
+}
+
+/** Maps decoded point attributes without implicit aliases, casts, projection or silent omissions. */
+export function mapPointCloudAttributes(
+  input: Mesh | MeshArrowTable,
+  mapping: PointCloudAttributeMapping
+): MappedPointCloud {
+  const mesh = getPointCloudMesh(input);
+  const attributes: Mesh['attributes'] = Object.create(null);
+  const selected = new Set<string>();
+  for (const [target, source] of Object.entries(mapping.attributes)) {
+    if (
+      !target ||
+      ['__proto__', 'constructor', 'prototype'].includes(target) ||
+      !Object.hasOwn(mesh.attributes, source)
+    )
+      throw new TileConversionError(
+        'POINT_CLOUD_MAPPING_INVALID',
+        `Invalid point attribute mapping ${target}: ${source}`
+      );
+    if (Object.hasOwn(mapping.drop || {}, source))
+      throw new TileConversionError(
+        'POINT_CLOUD_MAPPING_INVALID',
+        `Point attribute ${source} is both selected and dropped`
+      );
+    attributes[target] = {...mesh.attributes[source]};
+    selected.add(source);
+  }
+  const droppedAttributes: Record<string, string> = Object.create(null);
+  for (const [source, reason] of Object.entries(mapping.drop || {}).sort(([left], [right]) =>
+    left < right ? -1 : left > right ? 1 : 0
+  )) {
+    if (!Object.hasOwn(mesh.attributes, source) || typeof reason !== 'string' || !reason.trim())
+      throw new TileConversionError(
+        'POINT_CLOUD_MAPPING_INVALID',
+        `Invalid loss declaration for ${source}`
+      );
+    droppedAttributes[source] = reason;
+  }
+  const unmapped = Object.keys(mesh.attributes).filter(
+    name => !selected.has(name) && !Object.hasOwn(droppedAttributes, name)
+  );
+  if (unmapped.length || !attributes.POSITION)
+    throw new TileConversionError(
+      'POINT_CLOUD_MAPPING_REQUIRED',
+      `Map POSITION and explicitly retain or drop every attribute: ${unmapped.join(', ')}`
+    );
+  return {
+    mesh: {...mesh, attributes, schema: {fields: [], metadata: {...mesh.schema?.metadata}}},
+    droppedAttributes
+  };
+}
+
+/** Converts decoded point input after optional retained-buffer accounting and null validation. */
+export function getPointCloudMesh(input: Mesh | MeshArrowTable, maxInputBytes = Infinity): Mesh {
+  const buffers = new Set<ArrayBufferLike>();
+  let bytes = 0;
+  /** Counts distinct retained buffers rather than narrow views. */
+  const countBuffer = (buffer: ArrayBufferLike): void => {
+    if (!buffers.has(buffer)) {
+      buffers.add(buffer);
+      bytes += buffer.byteLength;
+    }
+    if (bytes > maxInputBytes)
+      throw new TileConversionError('POINT_CLOUD_INPUT_BUDGET', 'Point input byte budget exceeded');
+  };
+  if ('shape' in input) {
+    /** Validates nullable nested Arrow columns before conversion. */
+    type ArrowColumn = MeshArrowTable['data']['batches'][number]['data']['children'][number];
+    const checkColumn = (column: ArrowColumn): void => {
+      if (column.nullCount)
+        throw new TileConversionError(
+          'POINT_CLOUD_NULL_UNSUPPORTED',
+          'Null point values require an explicit preprocessing step'
+        );
+      for (const buffer of Object.values(column.buffers)) if (buffer) countBuffer(buffer.buffer);
+      for (const view of column.variadicBuffers) countBuffer(view.buffer);
+      for (const child of column.children) checkColumn(child);
+      for (const dictionary of column.dictionary?.data || []) checkColumn(dictionary);
+    };
+    for (const batch of input.data.batches) checkColumn(batch.data);
+  } else
+    for (const attribute of Object.values(input.attributes)) countBuffer(attribute.value.buffer);
+  const mesh = 'shape' in input ? convertTableToMesh(input) : input;
+  if (mesh.topology !== 'point-list' || mesh.indices)
+    throw new TileConversionError(
+      'POINT_CLOUD_INPUT_INVALID',
+      'Decoded unindexed point-list input is required'
+    );
+  return mesh;
+}

package/src/v5/point-cloud-conversion.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {PointCloudTilesetSource} from '@loaders.gl/tiles';
+import type {PointCloudTilesetSource} from '@loaders.gl/tiles-3d';
 import {convertTileset} from '@loaders.gl/tile-converter/v5/core';
 import type {
   TileConversionProgress,