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

package/src/v5/mesh-source-features.ts

@@ -7,6 +7,8 @@ import type {GLTFPostprocessed, GLTFMeshPrimitivePostprocessed} from '@loaders.g
 import type {I3SMeshFeatures} from '@loaders.gl/i3s';
 import {convertFeatureAttributesToArrowBatches} from './feature-arrow.js';
 import type {FeatureArrowBatchOptions} from './feature-arrow.js';
+import {createMeshSourceFeatureOptions} from './mesh-source-schema.js';
+import type {MeshSourceSchemaOptions} from './mesh-source-schema.js';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 
 /** Explicit source feature mapping; target type changes must be authorized separately. */
@@ -29,7 +31,7 @@ export function extractMeshFeatures(
     featureTableJson?: Record<string, unknown>;
   },
   mesh: MeshGeometry,
-  options?: MeshSourceFeatureOptions
+  options?: MeshSourceFeatureOptions | MeshSourceSchemaOptions
 ): I3SMeshFeatures | undefined {
   const declarations = primitive.extensions?.EXT_mesh_features?.featureIds;
   const metadata = gltf.extensions?.EXT_structural_metadata;
@@ -51,13 +53,14 @@ export function extractMeshFeatures(
   if (!options)
     throw new TileConversionError(
       'MESH_FEATURE_SCHEMA_REQUIRED',
-      'Feature extraction requires an explicit Arrow schema and class mapping'
+      'Feature extraction requires a class selection and a declared Arrow or inline source schema'
     );
   if (!options.metadataClass)
     throw new TileConversionError(
       'MESH_FEATURE_CLASS_REQUIRED',
       'Feature metadata class must be explicit'
     );
+  const mapping = 'schema' in options ? options : createMeshSourceFeatureOptions(gltf, options);
   let count: number;
   let attribute = legacy;
   let properties: Record<string, ArrayLike<unknown>>;
@@ -94,6 +97,17 @@ export function extractMeshFeatures(
         'Feature class and declared table counts must agree'
       );
     count = table.count;
+    // Qualified mesh writers require every feature row to own geometry. Check before defaults allocate.
+    if (
+      !Number.isSafeInteger(count) ||
+      count <= 0 ||
+      count > mesh.attributes.POSITION.value.length / 3
+    ) {
+      throw new TileConversionError(
+        'MESH_FEATURE_IDS_INVALID',
+        'Feature row count exceeds the available mesh vertices'
+      );
+    }
     properties = {};
     const classProperties = metadata.schema?.classes?.[table.class]?.properties;
     if (!classProperties)
@@ -110,6 +124,7 @@ export function extractMeshFeatures(
       string,
       {
         type: string;
+        required?: boolean;
         componentType?: string;
         array?: boolean;
         noData?: unknown;
@@ -123,7 +138,12 @@ export function extractMeshFeatures(
       if (
         !['SCALAR', 'STRING'].includes(property.type) ||
         property.array ||
-        property.noData !== undefined ||
+        (property.noData !== undefined &&
+          (property.normalized ||
+            property.offset !== undefined ||
+            property.scale !== undefined ||
+            column?.offset !== undefined ||
+            column?.scale !== undefined)) ||
         (['INT64', 'UINT64'].includes(property.componentType || '') &&
           (property.normalized ||
             property.offset !== undefined ||
@@ -136,12 +156,53 @@ export function extractMeshFeatures(
           `Property ${name} requires a separately qualified semantic mapping`
         );
       const data = column?.data;
-      if (data === undefined && property.default === undefined)
+      if (
+        (column !== undefined && (data === undefined || data === null)) ||
+        (data === undefined && property.required === true)
+      )
         throw new TileConversionError(
           'MESH_FEATURE_PROPERTY_UNAVAILABLE',
           `Property ${name} has not been decoded`
         );
-      properties[name] = data ?? Array.from({length: count}, () => property.default);
+      const integer64 = ['INT64', 'UINT64'].includes(property.componentType || '');
+      if (
+        integer64 &&
+        property.default !== undefined &&
+        (typeof property.default !== 'number' || !Number.isSafeInteger(property.default))
+      ) {
+        throw new TileConversionError(
+          'MESH_FEATURE_PROPERTY_UNSUPPORTED',
+          `Property ${name} requires an exact 64-bit default`
+        );
+      }
+      const defaultValue =
+        integer64 && property.default !== undefined
+          ? BigInt(property.default as number)
+          : (property.default ?? null);
+      const decoded = data ?? Array.from({length: count}, () => defaultValue);
+      if (property.noData === undefined || data === undefined) {
+        properties[name] = decoded;
+        continue;
+      }
+      const sentinel = property.noData;
+      if (
+        (property.type === 'STRING'
+          ? typeof sentinel !== 'string'
+          : typeof sentinel !== 'number' ||
+            !Number.isFinite(sentinel) ||
+            (integer64 && !Number.isSafeInteger(sentinel))) ||
+        !decoded ||
+        (!Array.isArray(decoded) && !ArrayBuffer.isView(decoded)) ||
+        (decoded as ArrayLike<unknown>).length !== count
+      )
+        throw new TileConversionError(
+          'MESH_FEATURE_PROPERTY_UNSUPPORTED',
+          `Property ${name} requires a valid decoded noData mapping`
+        );
+      const comparable = integer64 ? BigInt(sentinel as number) : sentinel;
+      properties[name] = Array.from(decoded as ArrayLike<unknown>, value =>
+        value === comparable ? defaultValue : value
+      );
     }
   } else {
     if (metadata)
@@ -208,18 +269,20 @@ export function extractMeshFeatures(
           .map(([name, values]) => [name, values[index]])
       )
     })),
-    options
+    mapping
   );
   const indices = mesh.indices?.value;
   const triangleFeatureIndices = new Uint32Array((indices?.length ?? vertexCount) / 3);
   for (let triangle = 0; triangle < triangleFeatureIndices.length; triangle++) {
-    const rows = [0, 1, 2].map(
-      corner => attribute.value[indices?.[triangle * 3 + corner] ?? triangle * 3 + corner]
+    const corners = [0, 1, 2].map(
+      corner => indices?.[triangle * 3 + corner] ?? triangle * 3 + corner
     );
-    if (rows.some(row => row !== rows[0]))
+    const rows = corners.map(corner => attribute.value[corner]);
+    // Repeated-index strip connectors have no surface; retain the first corner's feature row.
+    if (rows.some(row => row !== rows[0]) && new Set(corners).size === 3)
       throw new TileConversionError(
         'MESH_FEATURE_TRIANGLE_MIXED',
-        'All vertices of a triangle must reference the same feature row'
+        'All vertices of a nondegenerate triangle must reference the same feature row'
       );
     triangleFeatureIndices[triangle] = Number(rows[0]);
   }

package/src/v5/mesh-source-schema.ts

@@ -0,0 +1,134 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GLTFPostprocessed, GLTF_EXT_structural_metadata_ClassProperty} from '@loaders.gl/gltf';
+import type {DataType, Field} from '@loaders.gl/schema';
+import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
+import type {MeshSourceFeatureOptions} from './mesh-source-features.js';
+
+/** Class and identifier selection for a mapping derived from an inline glTF schema. */
+export type MeshSourceSchemaOptions = Omit<MeshSourceFeatureOptions, 'schema' | 'rawMetadataField'>;
+
+/** Declared scalar storage widths; no property values participate in type selection. */
+const SCALAR_TYPES: Readonly<Record<string, DataType>> = {
+  INT8: 'int8',
+  UINT8: 'uint8',
+  INT16: 'int16',
+  UINT16: 'uint16',
+  INT32: 'int32',
+  UINT32: 'uint32',
+  INT64: 'int64',
+  UINT64: 'uint64',
+  FLOAT32: 'float32',
+  FLOAT64: 'float64'
+};
+
+/**
+ * Builds an explicit Arrow mapping from one inline structural-metadata class and property table.
+ * Scalar widths, strings and optional/default/noData declarations are retained. The caller selects
+ * the class and stable identifier property; otherwise identifiers are uint32 table row indices.
+ * Arrays, enums, vectors, transformed numeric properties and external schemas fail explicitly.
+ * This does not authorize destination type changes or loss of source class semantics.
+ */
+export function createMeshSourceFeatureOptions(
+  gltf: GLTFPostprocessed,
+  options: MeshSourceSchemaOptions
+): MeshSourceFeatureOptions {
+  const metadata = gltf.extensions?.EXT_structural_metadata;
+  const table = metadata?.propertyTables?.[0];
+  const properties = metadata?.schema?.classes?.[options.metadataClass]?.properties;
+  if (
+    !options.metadataClass ||
+    metadata?.propertyTables?.length !== 1 ||
+    table?.class !== options.metadataClass ||
+    !properties ||
+    !Number.isSafeInteger(table.count) ||
+    table.count < 1 ||
+    table.count > 0xffffffff ||
+    metadata.propertyTextures?.length ||
+    metadata.propertyAttributes?.length
+  ) {
+    throw new TileConversionError(
+      'MESH_FEATURE_SCHEMA_REQUIRED',
+      'Schema mapping requires one inline class, one matching property table and a positive uint32 row count'
+    );
+  }
+  if (Object.keys(table.properties || {}).some(name => !Object.hasOwn(properties, name))) {
+    throw new TileConversionError(
+      'MESH_FEATURE_PROPERTY_UNMAPPED',
+      'Property table columns must be declared in the selected class'
+    );
+  }
+  const fields: Field[] = Object.entries(properties).map(([name, property]) => {
+    const declaration = property as GLTF_EXT_structural_metadata_ClassProperty;
+    const column = table.properties?.[name];
+    if (
+      declaration.array ||
+      !['SCALAR', 'STRING'].includes(declaration.type) ||
+      declaration.normalized ||
+      declaration.offset !== undefined ||
+      declaration.scale !== undefined ||
+      column?.offset !== undefined ||
+      column?.scale !== undefined ||
+      (declaration.required &&
+        (declaration.noData !== undefined || declaration.default !== undefined))
+    ) {
+      throw new TileConversionError(
+        'MESH_FEATURE_PROPERTY_UNSUPPORTED',
+        `Property ${name} requires an explicit separately qualified mapping`
+      );
+    }
+    const type =
+      declaration.type === 'STRING'
+        ? 'utf8'
+        : Object.hasOwn(SCALAR_TYPES, declaration.componentType || '')
+          ? SCALAR_TYPES[declaration.componentType!]
+          : undefined;
+    if (!type) {
+      throw new TileConversionError(
+        'MESH_FEATURE_PROPERTY_UNSUPPORTED',
+        `Property ${name} has no supported declared scalar width`
+      );
+    }
+    return {
+      name,
+      type,
+      nullable: declaration.required !== true,
+      metadata: {'loaders.gl:structural-property': JSON.stringify(declaration)}
+    };
+  });
+  const identifierName = options.featureIdField || 'feature_id';
+  const sourceIdentifier = options.sourceFeatureIdProperty;
+  const sourceField = sourceIdentifier
+    ? fields.find(field => field.name === sourceIdentifier)
+    : undefined;
+  if (
+    (sourceIdentifier && !sourceField) ||
+    fields.some(field => field.name === identifierName && field !== sourceField) ||
+    (sourceField &&
+      !['utf8', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64'].includes(
+        String(sourceField.type)
+      ))
+  ) {
+    throw new TileConversionError(
+      'MESH_FEATURE_ID_PROPERTY_REQUIRED',
+      'Select a declared string/integer identifier and a distinct output identifier name'
+    );
+  }
+  return {
+    ...options,
+    schema: {
+      fields: [
+        {
+          ...sourceField,
+          name: identifierName,
+          type: sourceField?.type || 'uint32',
+          nullable: false
+        },
+        ...fields.filter(field => field !== sourceField)
+      ],
+      metadata: {'loaders.gl:source-schema': JSON.stringify(metadata.schema)}
+    }
+  };
+}

package/src/v5/mesh-source-texture.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {getBinaryImageMetadata} from '@loaders.gl/images';
 import type {GLTFMaterialPostprocessed, GLTFImagePostprocessed} from '@loaders.gl/gltf';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 import type {MeshTileSampler, MeshTileTexture, MeshTileTextureTransform} from './mesh.js';
@@ -120,3 +121,49 @@ function mapMeshSourceImage(
     mimeType: match[1] as MeshTileTexture['mimeType']
   };
 }
+
+/** Resolves one external encoded image through an explicitly supplied application reader. */
+export async function resolveMeshSourceTexture(
+  textureInfo: NonNullable<GLTFMaterialPostprocessed['pbrMetallicRoughness']>['baseColorTexture'],
+  readExternalResource:
+    | ((uri: string, contentUri: string | undefined, signal?: AbortSignal) => Promise<Uint8Array>)
+    | undefined,
+  contentUri: string | undefined,
+  signal?: AbortSignal
+): Promise<MeshTileTexture> {
+  const image = textureInfo?.texture?.source;
+  if (!image || image.uri === undefined || image.uri.startsWith('data:'))
+    return mapMeshSourceTexture(textureInfo);
+  if (!readExternalResource || image.bufferView !== undefined)
+    throw new TileConversionError(
+      'MESH_SOURCE_TEXTURE_UNSUPPORTED',
+      'External images require an explicit bounded resource reader'
+    );
+  signal?.throwIfAborted();
+  const data = await readExternalResource(image.uri, contentUri, signal);
+  signal?.throwIfAborted();
+  let metadata;
+  try {
+    metadata = getBinaryImageMetadata(new DataView(data.buffer, data.byteOffset, data.byteLength));
+  } catch {
+    /* Report an unsupported encoded image consistently. */
+  }
+  if (
+    !metadata ||
+    !['image/png', 'image/jpeg'].includes(metadata.mimeType) ||
+    (image.mimeType !== undefined && image.mimeType !== metadata.mimeType)
+  )
+    throw new TileConversionError(
+      'MESH_SOURCE_TEXTURE_UNSUPPORTED',
+      'External images require matching PNG/JPEG headers'
+    );
+  // Select encoded bytes without decoding pixels or modifying the caller-owned glTF image.
+  const resolved = {
+    ...textureInfo,
+    texture: {
+      ...textureInfo!.texture,
+      source: {...image, uri: undefined, mimeType: metadata.mimeType, bufferView: {data}}
+    }
+  };
+  return mapMeshSourceTexture(resolved as typeof textureInfo);
+}

package/src/v5/mesh-source.ts

@@ -17,10 +17,11 @@ import {createTilesetConversionSource} from '@loaders.gl/tile-converter/v5/core'
 import type {TilesetConversionSourceOptions} from '@loaders.gl/tile-converter/v5/core';
 import type {MeshConversionInput} from './mesh-conversion.js';
 import type {MeshTileMaterial} from './mesh.js';
-import {validateMeshGeometry} from './mesh.js';
-import {mapMeshSourceTexture} from './mesh-source-texture.js';
+import {validateMeshGeometry, validateMeshIndices} from './mesh.js';
+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';
 export type {MeshSourceFeatureOptions} from './mesh-source-features.js';
 
@@ -28,12 +29,20 @@ export type {MeshSourceFeatureOptions} from './mesh-source-features.js';
 export interface MeshSourceResource extends MeshConversionInput {
   /** Arrow features associated with the selected primitive; IDs are distinct from table row indices. */
   readonly features?: I3SMeshFeatures;
+  /** Original I3S layer semantics, retained for destination policy and diagnostics. */
+  readonly sourceLayerType?: '3DObject' | 'IntegratedMesh';
 }
 
 /** Narrow source profile and content lifetime controls. */
 export interface MeshTilesetSourceOptions extends TilesetConversionSourceOptions {
-  /** Required when the source has batch/structural metadata; no schema is inferred. */
-  readonly features?: MeshSourceFeatureOptions;
+  /** Required for feature-bearing content; omit schema only to map an inline structural metadata class. */
+  readonly features?: MeshSourceFeatureOptions | MeshSourceSchemaOptions;
+  /** Explicit bounded reader for external encoded images, relative to the content URI. */
+  readonly readExternalResource?: (
+    uri: string,
+    contentUri: string | undefined,
+    signal?: AbortSignal
+  ) => Promise<Uint8Array>;
 }
 
 /**
@@ -41,13 +50,14 @@ 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.
  * 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,
  * morphs, instancing, broader texture semantics, unknown extensions, non-affine/mirrored
  * placements, and
  * metadata outside the declared feature profile fail explicitly. Multiple resources can be read;
- * the single-mesh I3S sink rejects a second resource and aborts the entire output.
+ * collection sinks accept bounded multiple placements; the compatibility single-mesh sink rejects a second resource.
  * @param tileset - Dedicated native EPSG:4978 runtime with decoded glTF content enabled.
  * @param options - Explicit feature schema/mapping and optional decoded-content cleanup.
  * @returns Portable conversion source; COLOR_0 is preserved for GLB, while I3S rejects vertex colors.
@@ -165,11 +175,18 @@ export function createMeshTilesetConversionSource(
               'A default scene or exactly one scene is required'
             );
           let primitiveIndex = 0;
-          for (const selected of traverseMeshNodes(roots, placement)) {
-            const resource = extractPrimitive(
+          const primitives = traverseMeshNodes(roots, placement);
+          let current = primitives.next();
+          while (!current.done) {
+            const selected = current.value;
+            const next = primitives.next();
+            const resource = await extractPrimitive(
               selected.primitive,
               selected.transform,
-              `${item.tile.id}/${content.index}/${primitiveIndex++}`
+              `${item.tile.id}/${content.index}/${primitiveIndex++}`,
+              options.readExternalResource,
+              content.uri,
+              signal
             );
             const features = extractMeshFeatures(
               gltf,
@@ -178,7 +195,12 @@ export function createMeshTilesetConversionSource(
               resource.mesh,
               options.features
             );
-            yield {...resource, features};
+            yield {
+              ...resource,
+              features,
+              contentPrimitive: {index: primitiveIndex - 1, last: Boolean(next.done)}
+            };
+            current = next;
           }
           if (!primitiveIndex)
             throw new TileConversionError(
@@ -229,11 +251,14 @@ function* traverseMeshNodes(
 }
 
 /** Copies one packed primitive, places it once, and derives a useful ECEF local origin. */
-function extractPrimitive(
+async function extractPrimitive(
   primitive: GLTFMeshPrimitivePostprocessed,
   transform: Matrix4,
-  id: string
-): MeshSourceResource {
+  id: string,
+  readExternalResource: MeshTilesetSourceOptions['readExternalResource'],
+  contentUri: string | undefined,
+  signal?: AbortSignal
+): Promise<MeshSourceResource> {
   if (
     primitive.targets?.length ||
     Object.keys(primitive.extensions || {}).some(name => name !== 'EXT_mesh_features')
@@ -271,11 +296,9 @@ function extractPrimitive(
   const mesh = validateMeshGeometry(
     {
       topology: 'triangle-list',
-      mode: primitive.mode ?? 4,
+      mode: primitive.mode === 5 ? 4 : (primitive.mode ?? 4),
       attributes,
-      indices: primitive.indices
-        ? {value: primitive.indices.value as MeshAttribute['value'], size: 1}
-        : undefined
+      indices: createTriangleIndices(primitive, (attributes.POSITION?.value.length ?? 0) / 3)
     },
     true
   );
@@ -312,19 +335,28 @@ function extractPrimitive(
     id,
     mesh,
     origin: minimum.map((value, axis) => value / 2 + maximum[axis] / 2) as [number, number, number],
-    material: mapMaterial(primitive.material)
+    material: await mapMeshSourceMaterial(
+      primitive.material,
+      readExternalResource,
+      contentUri,
+      signal
+    )
   };
 }
 
 /** Maps supported PBR controls and an embedded base-color image, rejecting unmapped semantics. */
-function mapMaterial(
-  material: GLTFMaterialPostprocessed | undefined
-): MeshTileMaterial | undefined {
+export async function mapMeshSourceMaterial(
+  material: GLTFMaterialPostprocessed | undefined,
+  readExternalResource: MeshTilesetSourceOptions['readExternalResource'],
+  contentUri: string | undefined,
+  signal?: AbortSignal
+): Promise<MeshTileMaterial | undefined> {
   if (!material) return undefined;
   const pbr = material.pbrMetallicRoughness;
   if (
-    Object.keys(material).some(
-      name =>
+    Object.entries(material).some(
+      ([name, value]) =>
+        value !== undefined &&
         ![
           'id',
           'name',
@@ -336,8 +368,9 @@ function mapMaterial(
           'extras'
         ].includes(name)
     ) ||
-    Object.keys(pbr || {}).some(
-      name =>
+    Object.entries(pbr || {}).some(
+      ([name, value]) =>
+        value !== undefined &&
         !['baseColorFactor', 'baseColorTexture', 'metallicFactor', 'roughnessFactor'].includes(name)
     ) ||
     material.emissiveFactor?.some(value => value !== 0)
@@ -349,7 +382,14 @@ function mapMaterial(
   return {
     baseColorFactor: pbr?.baseColorFactor as [number, number, number, number] | undefined,
     ...('baseColorTexture' in (pbr || {})
-      ? {baseColorTexture: mapMeshSourceTexture(pbr!.baseColorTexture)}
+      ? {
+          baseColorTexture: await resolveMeshSourceTexture(
+            pbr!.baseColorTexture,
+            readExternalResource,
+            contentUri,
+            signal
+          )
+        }
       : {}),
     metallicFactor: pbr?.metallicFactor,
     roughnessFactor: pbr?.roughnessFactor,
@@ -358,3 +398,37 @@ function mapMaterial(
     doubleSided: material.doubleSided
   };
 }
+
+/** Expands a strip without changing vertex storage, feature IDs, source indices, or parity. */
+function createTriangleIndices(
+  primitive: GLTFMeshPrimitivePostprocessed,
+  vertexCount: number
+): MeshAttribute | undefined {
+  const attribute = primitive.indices
+    ? {
+        value: primitive.indices.value as MeshAttribute['value'],
+        size: primitive.indices.components,
+        normalized: primitive.indices.normalized
+      }
+    : undefined;
+  if (primitive.mode !== 5) return attribute;
+  const sourceIndices = validateMeshIndices(attribute, vertexCount, 5);
+  const indexCount = sourceIndices?.length ?? vertexCount;
+  if (!Number.isSafeInteger(indexCount) || indexCount < 3) {
+    throw new TileConversionError(
+      'MESH_TRIANGLE_COUNT_INVALID',
+      'Triangle strips require at least three vertices'
+    );
+  }
+  const IndexArray = vertexCount < 65536 ? Uint16Array : Uint32Array;
+  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;
+    indices[triangle * 3 + 1] = sourceIndices?.[second] ?? second;
+    indices[triangle * 3 + 2] = sourceIndices?.[third] ?? third;
+  }
+  return {value: indices, size: 1};
+}

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

@@ -96,7 +96,7 @@ export function createSingleMeshTilesetSink(
 }
 
 /** Builds placement and local bounds for a trusted single-mesh codec output. */
-function createMeshTileset(
+export function createMeshTileset(
   resource: EncodedMeshConversionResource,
   geometricError: number
 ): Omit<Tiles3DTilesetJSON, 'root'> & {root: Omit<Tiles3DTileJSON, 'children'>} {

package/src/v5/mesh.ts

@@ -5,6 +5,11 @@
 import {GLTFScenegraph, GLTFWriter} from '@loaders.gl/gltf';
 import {getBinaryImageMetadata} from '@loaders.gl/images';
 import type {MeshAttribute, MeshGeometry} from '@loaders.gl/schema';
+import {
+  prepareMeshFeatureGeometry,
+  encodeMeshFeatures,
+  type MeshTileFeatures
+} from './mesh-features.js';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 
 /** Explicit glTF wrapping and filtering for the selected base-color image. */
@@ -61,6 +66,8 @@ export interface MeshTileMaterial {
 
 /** Optional appearance for the single-mesh GLB profile. */
 export interface MeshTileOptions {
+  /** One explicit Arrow feature table with a row index per triangle. */
+  readonly features?: MeshTileFeatures;
   /** Explicitly selected material; other texture maps and material extensions are unsupported. */
   readonly material?: MeshTileMaterial;
 }
@@ -82,7 +89,7 @@ export interface MeshTileOptions {
  * @returns An embedded-buffer GLB containing one mesh, node, and default scene.
  */
 export function encodeMeshTile(mesh: MeshGeometry, options: MeshTileOptions = {}): ArrayBuffer {
-  const geometry = validateMeshGeometry(mesh);
+  const geometry = prepareMeshFeatureGeometry(validateMeshGeometry(mesh), options.features);
   const {scenegraph, materialIndex} = createMeshTileScenegraph(options, geometry);
   const meshIndex = scenegraph.addMesh({
     attributes: geometry.attributes,
@@ -90,6 +97,7 @@ export function encodeMeshTile(mesh: MeshGeometry, options: MeshTileOptions = {}
     material: materialIndex,
     mode: 4
   });
+  encodeMeshFeatures(scenegraph, meshIndex, options.features);
   return finalizeMeshTileScenegraph(scenegraph, meshIndex);
 }
 
@@ -203,7 +211,7 @@ export function validateMeshGeometry(
       ...(normalized ? {normalized: true} : {})
     };
   }
-  const indices = getMeshIndices(mesh.indices, positions.length / 3);
+  const indices = validateMeshIndices(mesh.indices, positions.length / 3);
   if (!indices && positions.length % 9 !== 0) {
     throw new TileConversionError(
       'MESH_TRIANGLE_COUNT_INVALID',
@@ -246,10 +254,11 @@ function getFloatAttribute(
   return attribute.value;
 }
 
-/** Reads optional packed triangle indices and checks glTF range and primitive-restart rules. */
-function getMeshIndices(
+/** Validates packed indices for triangle lists or strips, including glTF primitive-restart rules. */
+export function validateMeshIndices(
   attribute: MeshAttribute | undefined,
-  vertexCount: number
+  vertexCount: number,
+  primitiveMode: 4 | 5 = 4
 ): Uint8Array | Uint16Array | Uint32Array | undefined {
   if (!attribute) return undefined;
   validateAttributeLayout(attribute, 'indices');
@@ -267,10 +276,10 @@ function getMeshIndices(
       'Indices must contain packed unsigned integer scalars'
     );
   }
-  if (values.length === 0 || values.length % 3 !== 0) {
+  if (primitiveMode === 5 ? values.length < 3 : values.length === 0 || values.length % 3 !== 0) {
     throw new TileConversionError(
       'MESH_TRIANGLE_COUNT_INVALID',
-      'Indices must contain complete triangles'
+      'Indices must contain complete triangles or at least three strip vertices'
     );
   }
   const restartIndex = 2 ** (values.BYTES_PER_ELEMENT * 8) - 1;