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

package/dist/v5/adapters.js

@@ -325,29 +325,22 @@ import { Tile3DWriter, TILE3D_TYPE } from "@loaders.gl/3d-tiles";
 import { convertTableToMesh } from "@loaders.gl/schema-utils";
 import { TileConversionError as TileConversionError2 } from "@loaders.gl/tile-converter/v5/core";
 function encodePointCloudTile(pointBatch, options = {}) {
+  return encodePointCloudTileWithMetadata(pointBatch, options).pnts;
+}
+function encodePointCloudTileWithMetadata(pointBatch, options = {}) {
   const mesh = "attributes" in pointBatch ? pointBatch : convertTableToMesh(pointBatch);
   validatePointAttributes(mesh.attributes);
   const positionAttribute = mesh.attributes.POSITION;
-  if (!positionAttribute || positionAttribute.size !== 3) {
-    throw new TileConversionError2(
-      "POINT_CLOUD_POSITION_REQUIRED",
-      "Point cloud batches must contain a three-component POSITION attribute"
-    );
-  }
-  const positions = getPositionValues(positionAttribute, options.rtcCenter);
+  validatePointCloudPosition(positionAttribute);
+  const placement = encodePointPositions(positionAttribute, options);
+  const { positions } = placement;
   const pointCount = positions.length / 3;
-  if (pointCount === 0 || !Number.isInteger(pointCount)) {
-    throw new TileConversionError2(
-      "POINT_CLOUD_POSITION_COUNT_INVALID",
-      "Point cloud POSITION must contain one or more xyz triples"
-    );
-  }
   const colors = getColorAttribute(mesh.attributes.COLOR_0 || mesh.attributes.COLOR, pointCount);
   const constantRGBA = colors ? null : getConstantRgba(options.constantRGBA);
   const normals = getNormalAttribute(mesh.attributes.NORMAL, pointCount);
   const batchIds = getBatchIds(mesh.attributes.BATCH_ID, pointCount);
   const batchTableJson = validateBatchTable(options.batchTableJson, batchIds);
-  return Tile3DWriter.encodeSync(
+  const pnts = Tile3DWriter.encodeSync(
     {
       type: TILE3D_TYPE.POINT_CLOUD,
       featureTableJson: options.rtcCenter || constantRGBA ? {
@@ -359,6 +352,13 @@ function encodePointCloudTile(pointBatch, options = {}) {
     },
     {}
   );
+  return {
+    pnts,
+    pointCount,
+    rtcCenter: placement.rtcCenter,
+    localBoundingBox: placement.localBoundingBox,
+    maximumPositionError: placement.maximumPositionError
+  };
 }
 function validatePointAttributes(attributes) {
   const supportedAttributes = /* @__PURE__ */ new Set([
@@ -389,23 +389,88 @@ function getConstantRgba(constantRGBA) {
   }
   return [constantRGBA[0], constantRGBA[1], constantRGBA[2], constantRGBA[3]];
 }
-function getPositionValues(attribute, rtcCenter) {
-  if (rtcCenter && (rtcCenter.length !== 3 || rtcCenter.some((value) => !Number.isFinite(value)))) {
+function validatePointCloudPosition(attribute) {
+  if (!attribute || attribute.size !== 3 || attribute.byteOffset || attribute.byteStride || attribute.normalized || attribute.componentType) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_POSITION_REQUIRED",
+      "Point cloud batches must contain packed, non-normalized three-component POSITION values"
+    );
+  }
+  if (!attribute.value.length || attribute.value.length % 3) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_POSITION_COUNT_INVALID",
+      "Point cloud POSITION must contain one or more xyz triples"
+    );
+  }
+  const transform = attribute.transform;
+  if (transform && (transform.type !== "quantization" || !Number.isInteger(transform.bits) || transform.bits < 1 || transform.bits > 32 || transform.origin.length !== 3 || transform.origin.some((value) => !Number.isFinite(value)) || !Number.isFinite(transform.range) || transform.range < 0)) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_POSITION_TRANSFORM_INVALID",
+      "Position quantization requires finite xyz origin, nonnegative range and 1\u201332 bits"
+    );
+  }
+}
+function decodePointCloudPositions(attribute) {
+  validatePointCloudPosition(attribute);
+  const transform = attribute.transform;
+  return Float64Array.from(
+    attribute.value,
+    (value, index) => transform ? transform.origin[index % 3] + value / (2 ** transform.bits - 1) * transform.range : value
+  );
+}
+function encodePointPositions(attribute, options) {
+  const { rtcCenter = [0, 0, 0], maxPositionError = Infinity } = options;
+  if (rtcCenter.length !== 3 || rtcCenter.some((value) => !Number.isFinite(value))) {
     throw new TileConversionError2(
       "POINT_CLOUD_RTC_CENTER_INVALID",
       "Point cloud RTC_CENTER must contain three finite values"
     );
   }
+  if (options.maxPositionError !== void 0 && (!Number.isFinite(maxPositionError) || maxPositionError < 0)) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_PRECISION_INVALID",
+      "maxPositionError must be finite and nonnegative"
+    );
+  }
   const values = attribute.value;
-  const result = new Float32Array(values.length);
+  const positions = new Float32Array(values.length);
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  let maximumPositionError = 0;
   const transform = attribute.transform;
-  for (let index = 0; index < values.length; index++) {
-    const component = index % 3;
-    const value = values[index];
-    const absoluteValue = transform?.type === "quantization" ? transform.origin[component] + value / (2 ** transform.bits - 1) * transform.range : value;
-    result[index] = absoluteValue - (rtcCenter?.[component] ?? 0);
+  const errors = [0, 0, 0];
+  for (let point = 0; point < values.length; point += 3) {
+    for (let axis = 0; axis < 3; axis++) {
+      const value = values[point + axis];
+      const absoluteValue = transform ? transform.origin[axis] + value / (2 ** transform.bits - 1) * transform.range : value;
+      const relativeValue = absoluteValue - rtcCenter[axis];
+      positions[point + axis] = relativeValue;
+      const encodedValue = positions[point + axis];
+      const reconstructed = encodedValue + rtcCenter[axis];
+      if (!Number.isFinite(absoluteValue) || !Number.isFinite(relativeValue) || !Number.isFinite(encodedValue) || !Number.isFinite(reconstructed)) {
+        throw new TileConversionError2(
+          "POINT_CLOUD_POSITION_INVALID",
+          "Point positions and their float32 reconstruction must be finite"
+        );
+      }
+      errors[axis] = reconstructed - absoluteValue;
+      minimum[axis] = Math.min(minimum[axis], encodedValue);
+      maximum[axis] = Math.max(maximum[axis], encodedValue);
+    }
+    maximumPositionError = Math.max(maximumPositionError, Math.hypot(...errors));
+  }
+  if (!Number.isFinite(maximumPositionError) || maximumPositionError > maxPositionError) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_PRECISION_EXCEEDED",
+      "Float32 position reconstruction exceeds maxPositionError; select a closer RTC center"
+    );
   }
-  return result;
+  return {
+    positions,
+    rtcCenter: [...rtcCenter],
+    localBoundingBox: [minimum, maximum],
+    maximumPositionError
+  };
 }
 function getColorAttribute(attribute, pointCount) {
   if (!attribute) {
@@ -518,10 +583,191 @@ function validateBatchTable(batchTableJson, batchIds) {
   return normalizedBatchTable;
 }
 
+// src/v5/point-cloud-spatial.ts
+import { Matrix4 } from "@math.gl/core";
+import { getSpatialCoordinateFrame, createTilesetSpatialReference } from "@loaders.gl/tiles";
+import { convertTableToMesh as convertTableToMesh2, makeMeshArrowTable } from "@loaders.gl/schema-utils";
+import { TileConversionError as TileConversionError3 } from "@loaders.gl/tile-converter/v5/core";
+async function transformPointCloudSourceTile(sourceTile, options) {
+  options.signal?.throwIfAborted();
+  const { content } = sourceTile;
+  if (!content) return sourceTile;
+  const reference = options.spatialContext.spatialReference;
+  const contentReference = content.spatialReference;
+  const retainTransformedEcef = contentReference?.status === "transformed" && (contentReference.targetCrs || contentReference.sourceCrs) === "EPSG:4978" && reference.status === "native" && reference.sourceCrs === "EPSG:4978" && reference.verticalUnitScale === 1 && (reference.units?.every((unit) => unit === "meter") ?? true);
+  const sourceReference = retainTransformedEcef ? createTilesetSpatialReference({
+    sourceCrs: "EPSG:4978",
+    coordinateFrame: "geocentric",
+    axisOrder: "xyz",
+    units: reference.units,
+    coordinateEpoch: contentReference.coordinateEpoch,
+    heightReference: contentReference.targetHeightReference === "native" ? contentReference.heightReference : contentReference.targetHeightReference
+  }) : contentReference;
+  if (sourceReference && (sourceReference.status === "transformed" || sourceReference.status === "unresolved" || JSON.stringify(sourceReference.sourceCrs) !== JSON.stringify(reference.sourceCrs) || sourceReference.heightReference !== reference.heightReference || sourceReference.verticalUnitScale !== reference.verticalUnitScale || sourceReference.coordinateEpoch !== reference.coordinateEpoch || JSON.stringify(sourceReference.units) !== JSON.stringify(reference.units) || sourceReference.elevationMode !== reference.elevationMode || sourceReference.elevationOffset !== reference.elevationOffset || sourceReference.elevationUnitScale !== reference.elevationUnitScale)) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_SPATIAL_REFERENCE_MISMATCH",
+      "Point content and context must agree on the input CRS, units, height reference and epoch"
+    );
+  }
+  const sourceFrame = reference.coordinateFrame === "unknown" && reference.sourceCrs ? getSpatialCoordinateFrame(reference.sourceCrs) : reference.coordinateFrame;
+  const geographic = sourceFrame === "geographic";
+  if (!["xy", "xyz", "unknown"].includes(reference.axisOrder) || (geographic ? !["lnglat", "lnglat-offsets"].includes(content.coordinateSystem) : content.coordinateSystem !== "cartesian" || !["projected", "geocentric", "cartesian", "local"].includes(sourceFrame))) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_SOURCE_FRAME_UNSUPPORTED",
+      "Spatial preparation requires explicit Cartesian or longitude/latitude positions in source xyz order"
+    );
+  }
+  if (content.cartographicOrigin.length !== 3 || content.cartographicOrigin.some((value) => !Number.isFinite(value)) || content.coordinateSystem !== "lnglat-offsets" && content.cartographicOrigin.some((value) => value !== 0)) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_SOURCE_ORIGIN_INVALID",
+      "Only longitude/latitude offsets use a nonzero cartographic origin"
+    );
+  }
+  if (content.modelMatrix && (content.modelMatrix.length !== 16 || Array.from(content.modelMatrix).some((value) => !Number.isFinite(value)))) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_SOURCE_PLACEMENT_UNSUPPORTED",
+      "Point placement must contain sixteen finite matrix values"
+    );
+  }
+  const matrix = new Matrix4(content.modelMatrix ? Array.from(content.modelMatrix) : void 0);
+  const determinant = matrix.determinant();
+  if (matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0 || matrix[15] !== 1 || !Number.isFinite(determinant) || determinant === 0 || geographic && !matrix.equals(new Matrix4())) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_SOURCE_PLACEMENT_UNSUPPORTED",
+      "Cartesian placement must be finite, affine and invertible; geographic placement must be identity"
+    );
+  }
+  const mesh = convertTableToMesh2(content.data);
+  const positionAttribute = mesh.attributes.POSITION;
+  const declaredTransform = mesh.schema?.fields.find((field) => field.name === "POSITION")?.metadata?.["loaders.gl.transform"];
+  if (declaredTransform && !positionAttribute?.transform) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_POSITION_TRANSFORM_INVALID",
+      "Arrow position transform metadata is unsupported or invalid"
+    );
+  }
+  const sourcePositions = decodePointCloudPositions(positionAttribute);
+  if (sourcePositions.some((value) => !Number.isFinite(value))) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_POSITION_INVALID",
+      "Decoded point positions must be finite"
+    );
+  }
+  const translationOnly = Array.from(matrix).every(
+    (value, index) => index >= 12 && index <= 14 || value === (index % 5 === 0 ? 1 : 0)
+  );
+  for (let index = 0; index < sourcePositions.length; index += 3) {
+    if (geographic || translationOnly) {
+      for (let axis = 0; axis < 3; axis++) {
+        sourcePositions[index + axis] += geographic ? content.cartographicOrigin[axis] : matrix[12 + axis];
+      }
+    } else {
+      sourcePositions.set(
+        matrix.transformAsPoint(Array.from(sourcePositions.subarray(index, index + 3))),
+        index
+      );
+    }
+  }
+  const normalAttribute = mesh.attributes.NORMAL;
+  let normals;
+  if (normalAttribute) {
+    if (!options.normalReferenceFrame || normalAttribute.size !== 3 || normalAttribute.value.length !== sourcePositions.length || normalAttribute.transform || normalAttribute.normalized || normalAttribute.byteOffset || normalAttribute.byteStride || normalAttribute.componentType || !translationOnly) {
+      throw new TileConversionError3(
+        "POINT_CLOUD_NORMAL_FRAME_REQUIRED",
+        "Spatial point normals require a declared vector frame and packed xyz values"
+      );
+    }
+    normals = new Float32Array(normalAttribute.value.length);
+    for (let index = 0; index < normals.length; index += 3) {
+      const normal = Array.from(normalAttribute.value.slice(index, index + 3));
+      const length = Math.hypot(...normal);
+      if (!Number.isFinite(length) || length === 0) {
+        throw new TileConversionError3(
+          "POINT_CLOUD_NORMAL_INVALID",
+          "Spatial point normals must be finite and nonzero"
+        );
+      }
+      normals.set(
+        normal.map((value) => value / length),
+        index
+      );
+    }
+  }
+  const transformed = await options.spatialContext.transformGeometryAsync(
+    sourcePositions,
+    normals,
+    options.normalReferenceFrame
+  );
+  options.signal?.throwIfAborted();
+  if (transformed.positions.length !== sourcePositions.length) {
+    throw new TileConversionError3(
+      "POINT_CLOUD_POSITION_INVALID",
+      "Spatial conversion must return one xyz triple per point"
+    );
+  }
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (let index = 0; index < transformed.positions.length; index++) {
+    const value = transformed.positions[index];
+    if (!Number.isFinite(value)) {
+      throw new TileConversionError3(
+        "POINT_CLOUD_POSITION_INVALID",
+        "Transformed point positions must be finite"
+      );
+    }
+    const axis = index % 3;
+    minimum[axis] = Math.min(minimum[axis], value);
+    maximum[axis] = Math.max(maximum[axis], value);
+  }
+  const center = minimum.map((value, axis) => value / 2 + maximum[axis] / 2);
+  const targetFrame = reference.status === "native" ? sourceFrame : getSpatialCoordinateFrame(reference.targetCrs || reference.sourceCrs);
+  const targetIsGeographic = targetFrame === "geographic";
+  const attributes = {
+    ...mesh.attributes,
+    POSITION: { value: transformed.positions, size: 3 },
+    ...transformed.normals ? { NORMAL: { value: transformed.normals, size: 3 } } : {}
+  };
+  return {
+    header: sourceTile.header,
+    content: {
+      ...content,
+      data: makeMeshArrowTable(attributes, {
+        topology: "point-list",
+        boundingBox: [minimum, maximum],
+        schema: mesh.schema ? {
+          ...mesh.schema,
+          metadata: {
+            ...mesh.schema.metadata,
+            topology: "point-list",
+            boundingBox: JSON.stringify([minimum, maximum])
+          },
+          fields: mesh.schema.fields.map(
+            (field) => field.name === "POSITION" || transformed.normals && field.name === "NORMAL" ? { ...field, metadata: {} } : field
+          )
+        } : void 0
+      }),
+      coordinateSystem: targetIsGeographic ? "lnglat" : "cartesian",
+      cartographicOrigin: [0, 0, 0],
+      modelMatrix: void 0,
+      spatialReference: reference,
+      spatialBoundingVolume: {
+        cartographicBounds: [minimum, maximum],
+        coordinateFrame: targetIsGeographic ? "geographic" : "cartesian",
+        center,
+        radius: Math.hypot(...maximum.map((value, axis) => value - center[axis]))
+      }
+    }
+  };
+}
+
 // src/v5/point-cloud-source-encoder.ts
-import { traversePointCloudSource } from "@loaders.gl/tile-converter/v5/core";
+import { traversePointCloudSource, TileConversionError as TileConversionError4 } from "@loaders.gl/tile-converter/v5/core";
 async function* encodePointCloudSource(source, options = {}) {
-  for await (const sourceTile of traversePointCloudSource(source, options)) {
+  for await (const inputTile of traversePointCloudSource(source, options)) {
+    const sourceTile = options.spatialContext ? await transformPointCloudSourceTile(inputTile, {
+      ...options,
+      spatialContext: options.spatialContext
+    }) : inputTile;
     const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
     const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
     if (encodedTile) {
@@ -534,14 +780,20 @@ function encodePointCloudSourceTile(sourceTile, options = {}) {
   if (!content) {
     return null;
   }
+  const encoded = encodePointCloudTileWithMetadata(content.data, {
+    ...options,
+    constantRGBA: options.constantRGBA ?? content.constantRGBA
+  });
+  if (content.pointCount !== encoded.pointCount) {
+    throw new TileConversionError4(
+      "POINT_CLOUD_SOURCE_COUNT_INVALID",
+      "Source pointCount must match the encoded Arrow point rows"
+    );
+  }
   return {
     id: header.id,
     header,
-    pnts: encodePointCloudTile(content.data, {
-      ...options,
-      constantRGBA: options.constantRGBA ?? content.constantRGBA
-    }),
-    pointCount: content.pointCount,
+    ...encoded,
     coordinateSystem: content.coordinateSystem,
     cartographicOrigin: [...content.cartographicOrigin],
     modelMatrix: content.modelMatrix ? Array.from(content.modelMatrix) : void 0,
@@ -564,7 +816,12 @@ function convertPointCloudSource(source, options) {
       read: (_inspection, signal) => traversePointCloudSource2(source, { maxDepth: options.maxDepth, signal })
     },
     codec: {
-      async *convert(sourceTile) {
+      async *convert(inputTile, _inspection, signal) {
+        const sourceTile = options.spatialContext ? await transformPointCloudSourceTile(inputTile, {
+          ...options,
+          spatialContext: options.spatialContext,
+          signal
+        }) : inputTile;
         const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
         const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
         if (encodedTile) {
@@ -585,9 +842,257 @@ function convertPointCloudSource(source, options) {
 // src/v5/mesh.ts
 import { GLTFScenegraph, GLTFWriter } from "@loaders.gl/gltf";
 import { getBinaryImageMetadata } from "@loaders.gl/images";
-import { TileConversionError as TileConversionError3 } from "@loaders.gl/tile-converter/v5/core";
+
+// src/v5/mesh-features.ts
+import { convertArrowToSchema } from "@loaders.gl/schema-utils";
+import { TileConversionError as TileConversionError5 } from "@loaders.gl/tile-converter/v5/core";
+function prepareMeshFeatureGeometry(mesh, features) {
+  if (!features) return mesh;
+  const count = features.batches.reduce((total, batch) => total + batch.data.numRows, 0);
+  const indices = mesh.indices?.value;
+  const vertexCount = indices?.length ?? mesh.attributes.POSITION.value.length / 3;
+  const associations = features.triangleFeatureIndices;
+  if (!(associations instanceof Uint32Array) || associations.length !== vertexCount / 3 || associations.some((row) => row >= count) || new Set(associations).size !== count) {
+    throw new TileConversionError5(
+      "MESH_FEATURE_ASSOCIATION_INVALID",
+      "Every feature row must own a triangle and every triangle must reference a valid row"
+    );
+  }
+  if (count > 2 ** 24)
+    throw new TileConversionError5(
+      "MESH_FEATURE_COUNT_UNSUPPORTED",
+      "Feature row indices must be exactly representable in a glTF vertex attribute"
+    );
+  const attributes = Object.fromEntries(
+    Object.entries(mesh.attributes).map(([name, attribute]) => {
+      const values = attribute.value;
+      const Constructor = values.constructor;
+      const output = new Constructor(vertexCount * attribute.size);
+      for (let vertex = 0; vertex < vertexCount; vertex++) {
+        const sourceVertex = indices?.[vertex] ?? vertex;
+        for (let component = 0; component < attribute.size; component++)
+          output[vertex * attribute.size + component] = Number(
+            values[sourceVertex * attribute.size + component]
+          );
+      }
+      return [name, { ...attribute, value: output }];
+    })
+  );
+  const featureIndices = count <= 65536 ? new Uint16Array(vertexCount) : new Float32Array(vertexCount);
+  for (let vertex = 0; vertex < vertexCount; vertex++)
+    featureIndices[vertex] = associations[Math.floor(vertex / 3)];
+  attributes._FEATURE_ID_0 = { value: featureIndices, size: 1 };
+  return { ...mesh, indices: void 0, attributes };
+}
+function encodeMeshFeatures(scenegraph, meshIndex, features) {
+  if (!features) return;
+  const { batches, featureIdField } = features;
+  const schema = batches[0]?.schema;
+  const count = batches.reduce((total, batch) => total + batch.data.numRows, 0);
+  const metadataClass = schema?.metadata?.["loaders.gl:feature-class"] || "features";
+  if (!schema || !count || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(metadataClass) || !schema.fields.some((field) => field.name === featureIdField && field.nullable !== true) || new Set(schema.fields.map((field) => field.name)).size !== schema.fields.length) {
+    throw new TileConversionError5(
+      "MESH_FEATURE_SCHEMA_INVALID",
+      "Features require a single named class, unique fields, and a non-null stable identifier"
+    );
+  }
+  for (const batch of batches) {
+    const actual = convertArrowToSchema(batch.data.schema).fields;
+    if (JSON.stringify(batch.schema) !== JSON.stringify(schema) || batch.length !== batch.data.numRows || JSON.stringify(actual.map((field) => [field.name, field.type])) !== JSON.stringify(schema.fields.map((field) => [field.name, field.type]))) {
+      throw new TileConversionError5(
+        "MESH_FEATURE_SCHEMA_INVALID",
+        "Declared feature schemas and Arrow column types must agree across batches"
+      );
+    }
+  }
+  const properties = /* @__PURE__ */ Object.create(null);
+  const columns = /* @__PURE__ */ Object.create(null);
+  for (const field of schema.fields) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(field.name))
+      throw new TileConversionError5(
+        "MESH_FEATURE_SCHEMA_INVALID",
+        "Property names must be metadata identifiers"
+      );
+    const values = batches.flatMap((batch) => {
+      const column = batch.data.getChild(field.name);
+      if (!column)
+        throw new TileConversionError5(
+          "MESH_FEATURE_SCHEMA_INVALID",
+          `Missing Arrow column ${field.name}`
+        );
+      return Array.from({ length: column.length }, (_, index) => column.get(index));
+    });
+    if (field.name === featureIdField && (values.some(
+      (value) => !(typeof value === "string" || typeof value === "bigint" || Number.isSafeInteger(value))
+    ) || new Set(values).size !== count))
+      throw new TileConversionError5(
+        "MESH_FEATURE_IDS_INVALID",
+        "Stable identifiers must be unique strings or exact integers"
+      );
+    const encoded = encodeFeatureColumn(field, values);
+    properties[field.name] = encoded.property;
+    columns[field.name] = {
+      values: addMetadataBuffer(scenegraph, encoded.data),
+      ...encoded.offsets ? {
+        stringOffsets: addMetadataBuffer(scenegraph, encoded.offsets),
+        stringOffsetType: "UINT32"
+      } : {}
+    };
+  }
+  scenegraph.json.extensions ||= {};
+  scenegraph.json.extensions.EXT_structural_metadata = {
+    schema: { id: "loaders_gl_features", classes: { [metadataClass]: { properties } } },
+    propertyTables: [{ class: metadataClass, count, properties: columns }]
+  };
+  const primitive = scenegraph.json.meshes[meshIndex].primitives[0];
+  primitive.extensions ||= {};
+  primitive.extensions.EXT_mesh_features = {
+    featureIds: [{ featureCount: count, attribute: 0, propertyTable: 0 }]
+  };
+  scenegraph.registerUsedExtension("EXT_structural_metadata");
+  scenegraph.registerUsedExtension("EXT_mesh_features");
+}
+function addMetadataBuffer(scenegraph, data) {
+  if (scenegraph.byteLength % 8) scenegraph.addBufferView(new Uint8Array(4));
+  return scenegraph.addBufferView(data);
+}
+function encodeFeatureColumn(field, values) {
+  const type = field.type;
+  const hasNull = values.includes(null);
+  if (hasNull && field.nullable !== true)
+    throw new TileConversionError5(
+      "MESH_FEATURE_VALUE_INVALID",
+      `Required field ${field.name} contains null`
+    );
+  const present = values.filter((value) => value !== null);
+  let noData;
+  if (type === "utf8") {
+    if (present.some(
+      (value) => typeof value !== "string" || new TextDecoder().decode(new TextEncoder().encode(value)) !== value
+    ))
+      throw new TileConversionError5("MESH_FEATURE_VALUE_INVALID", "Strings require valid Unicode");
+    if (hasNull) {
+      noData = "";
+      const strings = new Set(present);
+      while (strings.has(noData)) noData += "_";
+    }
+    const encoded = values.map(
+      (value) => new TextEncoder().encode(value === null ? noData : value)
+    );
+    const offsets = new Uint32Array(values.length + 1);
+    for (let index = 0; index < values.length; index++)
+      offsets[index + 1] = offsets[index] + encoded[index].length;
+    const data2 = new Uint8Array(offsets[values.length]);
+    encoded.forEach((bytes, index) => data2.set(bytes, offsets[index]));
+    return {
+      property: { type: "STRING", required: field.nullable !== true, ...hasNull ? { noData } : {} },
+      data: data2,
+      offsets
+    };
+  }
+  const widths = {
+    int8: 1,
+    uint8: 1,
+    int16: 2,
+    uint16: 2,
+    int32: 4,
+    uint32: 4,
+    int64: 8,
+    uint64: 8,
+    float32: 4,
+    float64: 8
+  };
+  const width = widths[String(type)];
+  if (!width)
+    throw new TileConversionError5(
+      "MESH_FEATURE_TYPE_UNSUPPORTED",
+      `No qualified GLB property mapping for ${String(type)}`
+    );
+  const isInteger64 = type === "int64" || type === "uint64";
+  const isFloat = type === "float32" || type === "float64";
+  const minimum = isFloat ? -Infinity : String(type).startsWith("uint") ? 0n : -(1n << BigInt(width * 8 - 1));
+  const maximum = isFloat ? Infinity : (1n << BigInt(width * 8 - (String(type).startsWith("uint") ? 0 : 1))) - 1n;
+  if (present.some(
+    (value) => isInteger64 ? typeof value !== "bigint" || value < minimum || value > maximum : typeof value !== "number" || !Number.isFinite(value) || !isFloat && (!Number.isSafeInteger(value) || BigInt(value) < minimum || BigInt(value) > maximum)
+  ))
+    throw new TileConversionError5(
+      "MESH_FEATURE_VALUE_INVALID",
+      `Values do not fit ${String(type)}`
+    );
+  if (hasNull) {
+    const used = new Set(present.map(String));
+    noData = 0;
+    while (used.has(String(noData))) noData++;
+    if (noData > maximum && minimum < 0) {
+      noData = -1;
+      while (used.has(String(noData))) noData--;
+    }
+    if (noData > maximum || noData < minimum)
+      throw new TileConversionError5(
+        "MESH_FEATURE_NULL_UNREPRESENTABLE",
+        "No unused value remains for null without losing a real value"
+      );
+  }
+  const data = new Uint8Array(values.length * width);
+  const view = new DataView(data.buffer);
+  values.forEach((value, index) => {
+    const selected = value === null ? isInteger64 ? BigInt(noData) : noData : value;
+    const offset = index * width;
+    switch (type) {
+      case "int8":
+        view.setInt8(offset, selected);
+        break;
+      case "uint8":
+        view.setUint8(offset, selected);
+        break;
+      case "int16":
+        view.setInt16(offset, selected, true);
+        break;
+      case "uint16":
+        view.setUint16(offset, selected, true);
+        break;
+      case "int32":
+        view.setInt32(offset, selected, true);
+        break;
+      case "uint32":
+        view.setUint32(offset, selected, true);
+        break;
+      case "int64":
+        view.setBigInt64(offset, selected, true);
+        break;
+      case "uint64":
+        view.setBigUint64(offset, selected, true);
+        break;
+      case "float32":
+        view.setFloat32(offset, selected, true);
+        break;
+      case "float64":
+        view.setFloat64(offset, selected, true);
+        break;
+    }
+    if (isFloat && !Number.isFinite(
+      type === "float32" ? view.getFloat32(offset, true) : view.getFloat64(offset, true)
+    ))
+      throw new TileConversionError5(
+        "MESH_FEATURE_VALUE_INVALID",
+        "Floating point property overflow"
+      );
+  });
+  return {
+    property: {
+      type: "SCALAR",
+      componentType: String(type).toUpperCase(),
+      required: field.nullable !== true,
+      ...hasNull ? { noData } : {}
+    },
+    data
+  };
+}
+
+// src/v5/mesh.ts
+import { TileConversionError as TileConversionError6 } from "@loaders.gl/tile-converter/v5/core";
 function encodeMeshTile(mesh, options = {}) {
-  const geometry = validateMeshGeometry(mesh);
+  const geometry = prepareMeshFeatureGeometry(validateMeshGeometry(mesh), options.features);
   const { scenegraph, materialIndex } = createMeshTileScenegraph(options, geometry);
   const meshIndex = scenegraph.addMesh({
     attributes: geometry.attributes,
@@ -595,6 +1100,7 @@ function encodeMeshTile(mesh, options = {}) {
     material: materialIndex,
     mode: 4
   });
+  encodeMeshFeatures(scenegraph, meshIndex, options.features);
   return finalizeMeshTileScenegraph(scenegraph, meshIndex);
 }
 function createMeshTileScenegraph(options, geometry) {
@@ -611,14 +1117,14 @@ function finalizeMeshTileScenegraph(scenegraph, meshIndex) {
 }
 function validateMeshGeometry(mesh, allowFloat64Positions = false) {
   if (mesh.topology !== "triangle-list" || mesh.mode !== 4) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TOPOLOGY_UNSUPPORTED",
       "Only triangle-list mode 4 is supported"
     );
   }
   for (const name of Object.keys(mesh.attributes)) {
     if (name !== "POSITION" && name !== "NORMAL" && name !== "COLOR_0" && name !== "TEXCOORD_0") {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_ATTRIBUTE_UNSUPPORTED",
         `Mesh attribute ${name} is unsupported`
       );
@@ -631,14 +1137,14 @@ function validateMeshGeometry(mesh, allowFloat64Positions = false) {
   if (mesh.attributes.NORMAL) {
     const normals = getFloatAttribute(mesh.attributes.NORMAL, "NORMAL");
     if (normals.length !== positions.length) {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_NORMAL_COUNT_MISMATCH",
         "NORMAL count must match POSITION count"
       );
     }
     for (let index = 0; index < normals.length; index += 3) {
       if (Math.abs(Math.hypot(normals[index], normals[index + 1], normals[index + 2]) - 1) > 1e-4) {
-        throw new TileConversionError3(
+        throw new TileConversionError6(
           "MESH_NORMAL_INVALID",
           "NORMAL vectors must have unit length"
         );
@@ -650,7 +1156,7 @@ function validateMeshGeometry(mesh, allowFloat64Positions = false) {
     const colors = mesh.attributes.COLOR_0;
     const normalized = isNormalizedUnsignedAttribute(colors);
     if (!colors || !(colors.value instanceof Float32Array || normalized) || colors.size !== 3 && colors.size !== 4 || colors.value.length / colors.size !== positions.length / 3 || colors.value instanceof Float32Array && colors.value.some((value) => !Number.isFinite(value) || value < 0 || value > 1)) {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_COLOR_INVALID",
         "COLOR_0 requires packed linear RGB/RGBA: Float32 in [0, 1] or normalized Uint8/Uint16, one per vertex"
       );
@@ -666,7 +1172,7 @@ function validateMeshGeometry(mesh, allowFloat64Positions = false) {
     const textureCoordinates = mesh.attributes.TEXCOORD_0;
     const normalized = isNormalizedUnsignedAttribute(textureCoordinates);
     if (!textureCoordinates || !(textureCoordinates.value instanceof Float32Array || normalized) || textureCoordinates.size !== 2 || textureCoordinates.value.length / 2 !== positions.length / 3 || textureCoordinates.value.some((value) => !Number.isFinite(value))) {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_TEXCOORD_INVALID",
         "TEXCOORD_0 requires packed finite Float32 or normalized Uint8/Uint16 UV pairs, one per vertex"
       );
@@ -678,9 +1184,9 @@ function validateMeshGeometry(mesh, allowFloat64Positions = false) {
       ...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 TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TRIANGLE_COUNT_INVALID",
       "Nonindexed meshes require complete triangles"
     );
@@ -694,36 +1200,36 @@ function validateMeshGeometry(mesh, allowFloat64Positions = false) {
 }
 function getFloatAttribute(attribute, name, allowFloat64 = false) {
   if (!attribute || !(attribute.value instanceof Float32Array || allowFloat64 && attribute.value instanceof Float64Array) || attribute.size !== 3 || attribute.value.length === 0 || attribute.value.length % 3 !== 0) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_ATTRIBUTE_INVALID",
       `${name} must contain packed ${allowFloat64 ? "Float32 or Float64" : "Float32"} xyz triples`
     );
   }
   validateAttributeLayout(attribute, name);
   if (attribute.value.some((value) => !Number.isFinite(value))) {
-    throw new TileConversionError3("MESH_ATTRIBUTE_NONFINITE", `${name} must contain finite values`);
+    throw new TileConversionError6("MESH_ATTRIBUTE_NONFINITE", `${name} must contain finite values`);
   }
   return attribute.value;
 }
-function getMeshIndices(attribute, vertexCount) {
+function validateMeshIndices(attribute, vertexCount, primitiveMode = 4) {
   if (!attribute) return void 0;
   validateAttributeLayout(attribute, "indices");
   const values = attribute.value;
   if (attribute.size !== 1 || !(values instanceof Uint8Array || values instanceof Uint16Array || values instanceof Uint32Array)) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_INDICES_INVALID",
       "Indices must contain packed unsigned integer scalars"
     );
   }
-  if (values.length === 0 || values.length % 3 !== 0) {
-    throw new TileConversionError3(
+  if (primitiveMode === 5 ? values.length < 3 : values.length === 0 || values.length % 3 !== 0) {
+    throw new TileConversionError6(
       "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;
   if (values.some((value) => value >= vertexCount || value === restartIndex)) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_INDEX_OUT_OF_RANGE",
       "Indices must reference existing vertices and exclude primitive-restart values"
     );
@@ -735,7 +1241,7 @@ function isNormalizedUnsignedAttribute(attribute) {
 }
 function validateAttributeLayout(attribute, name, allowNormalized = false) {
   if ((attribute.byteOffset ?? 0) !== 0 || (attribute.byteStride ?? 0) !== 0 || attribute.normalized && !allowNormalized || attribute.transform || attribute.componentType) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_ATTRIBUTE_LAYOUT_UNSUPPORTED",
       `${name} must use packed contiguous storage with supported normalization`
     );
@@ -743,7 +1249,7 @@ function validateAttributeLayout(attribute, name, allowNormalized = false) {
 }
 function validateMeshMaterial(material, scenegraph, hasTextureCoordinates) {
   if (!material || typeof material !== "object" || Array.isArray(material)) {
-    throw new TileConversionError3("MESH_MATERIAL_INVALID", "Material must be an object");
+    throw new TileConversionError6("MESH_MATERIAL_INVALID", "Material must be an object");
   }
   const allowedProperties = [
     "baseColorFactor",
@@ -756,7 +1262,7 @@ function validateMeshMaterial(material, scenegraph, hasTextureCoordinates) {
   ];
   for (const name of Object.keys(material)) {
     if (!allowedProperties.includes(name)) {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_MATERIAL_UNSUPPORTED",
         `Material property ${name} is unsupported`
       );
@@ -768,7 +1274,7 @@ function validateMeshMaterial(material, scenegraph, hasTextureCoordinates) {
   )) || [metallicFactor, roughnessFactor].some(
     (value) => value !== void 0 && (!Number.isFinite(value) || value < 0 || value > 1)
   ) || alphaMode !== void 0 && !["OPAQUE", "MASK", "BLEND"].includes(alphaMode) || alphaCutoff !== void 0 && (alphaMode !== "MASK" || !Number.isFinite(alphaCutoff) || alphaCutoff < 0) || doubleSided !== void 0 && typeof doubleSided !== "boolean") {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_MATERIAL_INVALID",
       "Material values must satisfy the selected glTF profile"
     );
@@ -789,13 +1295,13 @@ function encodeBaseColorTexture(texture, scenegraph, hasTextureCoordinates) {
   if (!texture || Object.keys(texture).some(
     (name) => name !== "data" && name !== "mimeType" && name !== "sampler" && name !== "transform"
   ) || !(texture.data instanceof Uint8Array) || !["image/png", "image/jpeg"].includes(texture.mimeType)) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TEXTURE_INVALID",
       "Base-color texture must supply Uint8Array data, image/png or image/jpeg mimeType, and optional sampling/transform controls"
     );
   }
   if (!hasTextureCoordinates) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TEXCOORD_REQUIRED",
       "Base-color texture requires TEXCOORD_0"
     );
@@ -807,7 +1313,7 @@ function encodeBaseColorTexture(texture, scenegraph, hasTextureCoordinates) {
   } catch {
   }
   if (!metadata || metadata.mimeType !== texture.mimeType || metadata.width <= 0 || metadata.height <= 0) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TEXTURE_INVALID",
       "Image header must match mimeType and declare positive dimensions"
     );
@@ -825,7 +1331,7 @@ function encodeBaseColorTexture(texture, scenegraph, hasTextureCoordinates) {
 }
 function validateMeshSampler(sampler) {
   if (!sampler || typeof sampler !== "object" || Array.isArray(sampler)) {
-    throw new TileConversionError3("MESH_SAMPLER_INVALID", "Sampler must be an object");
+    throw new TileConversionError6("MESH_SAMPLER_INVALID", "Sampler must be an object");
   }
   const allowedValues = {
     wrapS: [33071, 33648, 10497],
@@ -835,7 +1341,7 @@ function validateMeshSampler(sampler) {
   };
   for (const name in sampler) {
     if (!Object.hasOwn(allowedValues, name)) {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_SAMPLER_UNSUPPORTED",
         `Sampler property ${name} is unsupported`
       );
@@ -850,7 +1356,7 @@ function validateMeshSampler(sampler) {
   for (const name of Object.keys(allowedValues)) {
     const property = name;
     if (selectedSampler[property] !== void 0 && !allowedValues[property].includes(selectedSampler[property])) {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_SAMPLER_INVALID",
         `Sampler ${name} must use a glTF wrapping/filtering value`
       );
@@ -860,14 +1366,14 @@ function validateMeshSampler(sampler) {
 }
 function validateMeshTextureTransform(transform) {
   if (!transform || typeof transform !== "object" || Array.isArray(transform)) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TEXTURE_TRANSFORM_INVALID",
       "Texture transform must be an object"
     );
   }
   for (const name in transform) {
     if (name !== "offset" && name !== "rotation" && name !== "scale") {
-      throw new TileConversionError3(
+      throw new TileConversionError6(
         "MESH_TEXTURE_TRANSFORM_UNSUPPORTED",
         `Texture transform property ${name} is unsupported`
       );
@@ -879,7 +1385,7 @@ function validateMeshTextureTransform(transform) {
   if ([offsetValues, scaleValues].some(
     (value) => value !== void 0 && (!Array.isArray(value) || value.length !== 2 || value.some((component) => !Number.isFinite(component)))
   ) || rotation !== void 0 && !Number.isFinite(rotation)) {
-    throw new TileConversionError3(
+    throw new TileConversionError6(
       "MESH_TEXTURE_TRANSFORM_INVALID",
       "Texture transform requires finite UV pairs and a finite rotation"
     );
@@ -892,15 +1398,15 @@ function validateMeshTextureTransform(transform) {
 }
 
 // src/v5/mesh-conversion.ts
-import { getSpatialCoordinateFrame } from "@loaders.gl/tiles";
-import { TileConversionError as TileConversionError5 } from "@loaders.gl/tile-converter/v5/core";
+import { getSpatialCoordinateFrame as getSpatialCoordinateFrame2 } from "@loaders.gl/tiles";
+import { TileConversionError as TileConversionError8 } from "@loaders.gl/tile-converter/v5/core";
 
 // src/v5/mesh-draco.ts
 import { DracoLoader, encodeDraco } from "@loaders.gl/draco";
-import { TileConversionError as TileConversionError4 } from "@loaders.gl/tile-converter/v5/core";
+import { TileConversionError as TileConversionError7 } from "@loaders.gl/tile-converter/v5/core";
 var DRACO_EXTENSION = "KHR_draco_mesh_compression";
 async function encodeDracoMeshTile(geometry, options, libraryOptions = {}) {
-  geometry = validateMeshGeometry(geometry);
+  geometry = prepareMeshFeatureGeometry(validateMeshGeometry(geometry), options.features);
   if (!geometry.indices) {
     geometry.indices = {
       size: 1,
@@ -922,7 +1428,7 @@ async function encodeDracoMeshTile(geometry, options, libraryOptions = {}) {
   const decoded = await loader.parse(encoded.data, loaderOptions);
   const positions = decoded.attributes.POSITION.value;
   if (!(positions instanceof Float32Array) || positions.length !== encoded.report.pointCount * 3 || encoded.report.pointCount === 0 || !decoded.indices || decoded.indices.value.length !== encoded.report.faceCount * 3 || encoded.report.faceCount * 3 !== (geometry.indices?.value.length ?? geometry.attributes.POSITION.value.length / 3)) {
-    throw new TileConversionError4(
+    throw new TileConversionError7(
       "MESH_DRACO_ENCODING_INVALID",
       "Draco must preserve the triangle count and emit finite positions"
     );
@@ -934,12 +1440,18 @@ async function encodeDracoMeshTile(geometry, options, libraryOptions = {}) {
   }
   for (let index = 0; index < positions.length; index += 3) {
     if (!positionKeys.has(getPositionKey(positions, index))) {
-      throw new TileConversionError4(
+      throw new TileConversionError7(
         "MESH_DRACO_POSITION_CHANGED",
         "Lossless Draco must preserve the encoded Float32 positions"
       );
     }
   }
+  if (JSON.stringify(getMeshTriangles(geometry)) !== JSON.stringify(getMeshTriangles(decoded))) {
+    throw new TileConversionError7(
+      "MESH_DRACO_ATTRIBUTE_CHANGED",
+      "Lossless Draco must preserve oriented triangles and every attribute, including feature ownership"
+    );
+  }
   const bufferView = scenegraph.addBufferView(encoded.data);
   const attributes = {};
   const attributeIdentifiers = {};
@@ -947,12 +1459,12 @@ async function encodeDracoMeshTile(geometry, options, libraryOptions = {}) {
   for (const [name, attribute] of Object.entries(geometry.attributes)) {
     const decodedAttribute = decoded.attributes[name];
     if (!decodedAttribute || decodedAttribute.value.length !== encoded.report.pointCount * attribute.size) {
-      throw new TileConversionError4("MESH_DRACO_ENCODING_INVALID", `Draco must preserve ${name}`);
+      throw new TileConversionError7("MESH_DRACO_ENCODING_INVALID", `Draco must preserve ${name}`);
     }
     const accessor = {
-      componentType: attribute.value instanceof Uint8Array ? 5121 : attribute.value instanceof Uint16Array ? 5123 : 5126,
+      componentType: attribute.value instanceof Uint8Array ? 5121 : attribute.value instanceof Uint16Array ? 5123 : attribute.value instanceof Uint32Array ? 5125 : 5126,
       count: encoded.report.pointCount,
-      type: attribute.size === 2 ? "VEC2" : attribute.size === 3 ? "VEC3" : "VEC4",
+      type: attribute.size === 1 ? "SCALAR" : attribute.size === 2 ? "VEC2" : attribute.size === 3 ? "VEC3" : "VEC4",
       ...attribute.normalized ? { normalized: true } : {}
     };
     if (name === "POSITION") {
@@ -987,30 +1499,51 @@ async function encodeDracoMeshTile(geometry, options, libraryOptions = {}) {
       ]
     }
   ];
+  encodeMeshFeatures(scenegraph, 0, options.features);
   scenegraph.registerRequiredExtension(DRACO_EXTENSION);
   return { glb: finalizeMeshTileScenegraph(scenegraph, 0), positions };
 }
 function getPositionKey(positions, index) {
   return `${positions[index]},${positions[index + 1]},${positions[index + 2]}`;
 }
+function getMeshTriangles(mesh) {
+  const names = Object.keys(mesh.attributes).sort();
+  const indices = mesh.indices.value;
+  const triangles = [];
+  for (let index = 0; index < indices.length; index += 3) {
+    const vertices = [0, 1, 2].map(
+      (corner) => names.map((name) => {
+        const attribute = mesh.attributes[name];
+        return Array.from(
+          { length: attribute.size },
+          (_, component) => attribute.value[indices[index + corner] * attribute.size + component]
+        ).join(",");
+      }).join("|")
+    );
+    triangles.push(
+      [0, 1, 2].map((corner) => [...vertices.slice(corner), ...vertices.slice(0, corner)].join(";")).sort()[0]
+    );
+  }
+  return triangles.sort();
+}
 
 // src/v5/mesh-conversion.ts
 function createMeshConversionCodec(options) {
   const { spatialContext, maxPositionError, draco = true, dracoLibraryOptions } = options;
   if (typeof draco !== "boolean") {
-    throw new TileConversionError5("MESH_DRACO_OPTIONS_INVALID", "draco must be a boolean");
+    throw new TileConversionError8("MESH_DRACO_OPTIONS_INVALID", "draco must be a boolean");
   }
   if (!Number.isFinite(maxPositionError) || maxPositionError < 0) {
-    throw new TileConversionError5(
+    throw new TileConversionError8(
       "MESH_PRECISION_LIMIT_INVALID",
       "maxPositionError must be finite and nonnegative"
     );
   }
   const spatialReference = spatialContext.spatialReference;
   const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
-  const outputFrame = spatialReference.status === "native" ? spatialReference.coordinateFrame : outputCrs ? getSpatialCoordinateFrame(outputCrs) : "unknown";
+  const outputFrame = spatialReference.status === "native" ? spatialReference.coordinateFrame : outputCrs ? getSpatialCoordinateFrame2(outputCrs) : "unknown";
   if (!["native", "transformed"].includes(spatialReference.status) || !["projected", "geocentric", "local", "cartesian"].includes(outputFrame)) {
-    throw new TileConversionError5(
+    throw new TileConversionError8(
       "MESH_OUTPUT_FRAME_UNSUPPORTED",
       "Mesh output requires a resolved Cartesian coordinate frame"
     );
@@ -1019,28 +1552,41 @@ function createMeshConversionCodec(options) {
     /** Prepares and encodes one geometry while honoring cancellation. */
     async *convert(resource, _inspection, signal) {
       signal?.throwIfAborted();
-      if ("features" in resource && resource.features) {
-        throw new TileConversionError5(
-          "MESH_FEATURE_OUTPUT_UNSUPPORTED",
-          "The GLB codec requires an explicit feature metadata writer; use the I3S codec for supported feature-bearing meshes"
-        );
-      }
       const geometry = validateMeshGeometry(resource.mesh, true);
       const sourcePositions = geometry.attributes.POSITION.value;
       const origin = [...resource.origin];
       if (origin.length !== 3 || origin.some((value) => !Number.isFinite(value))) {
-        throw new TileConversionError5(
+        throw new TileConversionError8(
           "MESH_ORIGIN_INVALID",
           "Target origin must contain three finite coordinates"
         );
       }
-      const targetPositions = spatialContext.transformPositions(sourcePositions);
+      const transformed = "transformGeometryAsync" in spatialContext ? await spatialContext.transformGeometryAsync(
+        sourcePositions,
+        geometry.attributes.NORMAL?.value,
+        resource.normalReferenceFrame ?? options.normalReferenceFrame
+      ) : {
+        positions: spatialContext.transformPositions(sourcePositions),
+        normals: geometry.attributes.NORMAL ? spatialContext.transformNormals(geometry.attributes.NORMAL.value, sourcePositions) : void 0
+      };
+      signal?.throwIfAborted();
+      const targetPositions = transformed.positions;
       if (targetPositions.length !== sourcePositions.length || targetPositions.some((value) => !Number.isFinite(value))) {
-        throw new TileConversionError5(
+        throw new TileConversionError8(
           "MESH_TRANSFORM_INVALID",
           "Spatial transformation must return one finite xyz position per vertex"
         );
       }
+      if (options.autoOrigin) {
+        const minimum2 = [Infinity, Infinity, Infinity];
+        const maximum2 = [-Infinity, -Infinity, -Infinity];
+        for (let index = 0; index < targetPositions.length; index++) {
+          const axis = index % 3;
+          minimum2[axis] = Math.min(minimum2[axis], targetPositions[index]);
+          maximum2[axis] = Math.max(maximum2[axis], targetPositions[index]);
+        }
+        for (let axis = 0; axis < 3; axis++) origin[axis] = minimum2[axis] / 2 + maximum2[axis] / 2;
+      }
       const localPositions = new Float32Array(targetPositions.length);
       const minimum = [Infinity, Infinity, Infinity];
       const maximum = [-Infinity, -Infinity, -Infinity];
@@ -1057,7 +1603,7 @@ function createMeshConversionCodec(options) {
           localPositions[index + 2] + origin[2] - targetPositions[index + 2]
         );
         if (!Number.isFinite(positionError) || positionError > maxPositionError) {
-          throw new TileConversionError5(
+          throw new TileConversionError8(
             "MESH_POSITION_PRECISION_EXCEEDED",
             "Float32 mesh positions exceed the configured reconstruction error budget"
           );
@@ -1067,11 +1613,11 @@ function createMeshConversionCodec(options) {
       geometry.attributes.POSITION = { value: localPositions, size: 3 };
       if (geometry.attributes.NORMAL) {
         geometry.attributes.NORMAL = {
-          value: spatialContext.transformNormals(geometry.attributes.NORMAL.value, sourcePositions),
+          value: transformed.normals,
           size: 3
         };
       }
-      const appearance = { material: resource.material };
+      const appearance = { material: resource.material, features: resource.features };
       const encoded = draco ? await encodeDracoMeshTile(geometry, appearance, dracoLibraryOptions) : { glb: encodeMeshTile(geometry, appearance), positions: localPositions };
       signal?.throwIfAborted();
       for (let index = 0; index < encoded.positions.length; index++) {
@@ -1107,12 +1653,12 @@ function createMeshConversionCodec(options) {
 }
 
 // src/v5/mesh-tileset-sink.ts
-import { TileConversionError as TileConversionError6 } from "@loaders.gl/tile-converter/v5/core";
+import { TileConversionError as TileConversionError9 } from "@loaders.gl/tile-converter/v5/core";
 import { createBoundedMemoryTileConversionSink } from "@loaders.gl/tile-converter/v5/core";
 function createSingleMeshTilesetSink(options) {
   const { geometricError } = options;
   if (!Number.isFinite(geometricError) || geometricError < 0) {
-    throw new TileConversionError6(
+    throw new TileConversionError9(
       "MESH_GEOMETRIC_ERROR_INVALID",
       "geometricError must be finite and nonnegative, in meters"
     );
@@ -1127,7 +1673,7 @@ function createSingleMeshTilesetSink(options) {
     async write(resource, signal) {
       signal?.throwIfAborted();
       if (state !== "empty") {
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "SINGLE_MESH_SINK_UNAVAILABLE",
           "The sink accepts exactly one mesh before finalization or abort"
         );
@@ -1146,7 +1692,7 @@ function createSingleMeshTilesetSink(options) {
     },
     async finalize(report) {
       if (state !== "written") {
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "SINGLE_MESH_SINK_INCOMPLETE",
           "Finalization requires exactly one successfully written mesh"
         );
@@ -1167,13 +1713,13 @@ function createMeshTileset(resource, geometricError) {
   const outputCrs = reference.targetCrs || reference.sourceCrs;
   const heightReference = reference.targetHeightReference === "native" ? reference.heightReference : reference.targetHeightReference;
   if (!["native", "transformed"].includes(reference.status) || outputCrs !== "EPSG:4978" || heightReference !== "ellipsoidal" || reference.status === "native" && (reference.coordinateFrame !== "geocentric" || reference.axisOrder !== "xyz" || reference.verticalUnitScale !== 1 || reference.units?.some((unit) => unit !== "meter"))) {
-    throw new TileConversionError6(
+    throw new TileConversionError9(
       "MESH_TILESET_FRAME_UNSUPPORTED",
       "Single-mesh tilesets require resolved EPSG:4978 xyz coordinates in meters with ellipsoidal heights"
     );
   }
   if (!Number.isFinite(resource.maximumPositionError) || resource.maximumPositionError < 0 || resource.maximumPositionError > geometricError) {
-    throw new TileConversionError6(
+    throw new TileConversionError9(
       "MESH_GEOMETRIC_ERROR_INVALID",
       "geometricError must include the measured position reconstruction error"
     );
@@ -1181,7 +1727,7 @@ function createMeshTileset(resource, geometricError) {
   const origin = [...resource.origin];
   const [minimum, maximum] = resource.localBoundingBox.map((bound) => [...bound]);
   if (origin.length !== 3 || minimum.length !== 3 || maximum.length !== 3 || [...origin, ...minimum, ...maximum].some((value) => !Number.isFinite(value)) || minimum.some((value, axis) => value > maximum[axis])) {
-    throw new TileConversionError6(
+    throw new TileConversionError9(
       "MESH_TILESET_BOUNDS_INVALID",
       "Origin and local bounds must be finite xyz coordinates with ordered bounds"
     );
@@ -1220,7 +1766,7 @@ function createMeshTileset(resource, geometricError) {
 function createMeshTilesetSink(options) {
   const { geometricError, maxMeshes } = options;
   if (!Number.isFinite(geometricError) || geometricError < 0 || !Number.isSafeInteger(maxMeshes) || maxMeshes < 1) {
-    throw new TileConversionError6(
+    throw new TileConversionError9(
       "MESH_TILESET_OPTIONS_INVALID",
       "A leaf collection requires finite nonnegative geometricError and positive maxMeshes"
     );
@@ -1239,12 +1785,12 @@ function createMeshTilesetSink(options) {
     async write(resource, signal) {
       signal?.throwIfAborted();
       if (state !== "open")
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "MESH_TILESET_SINK_UNAVAILABLE",
           "The mesh sink is busy or closed"
         );
       if (children.length >= maxMeshes || identifiers.has(resource.id))
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "MESH_TILESET_PLACEMENT_INVALID",
           "Mesh count exceeds maxMeshes or a placement identifier is repeated"
         );
@@ -1256,7 +1802,7 @@ function createMeshTilesetSink(options) {
         (value, axis) => value + resource.origin[axis]
       );
       if ([...lower, ...upper].some((value) => !Number.isFinite(value)))
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "MESH_TILESET_BOUNDS_INVALID",
           "Absolute bounds must be finite"
         );
@@ -1278,7 +1824,7 @@ function createMeshTilesetSink(options) {
     /** Writes the enclosing root only when every leaf has completed. */
     async finalize(report) {
       if (state !== "open" || !children.length)
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "MESH_TILESET_SINK_INCOMPLETE",
           "Finalization requires written mesh leaves"
         );
@@ -1287,7 +1833,7 @@ function createMeshTilesetSink(options) {
       const halfSize = minimum.map((value, axis) => maximum[axis] / 2 - value / 2);
       const rootGeometricError = Math.max(geometricError, 2 * Math.hypot(...halfSize));
       if (!Number.isFinite(rootGeometricError))
-        throw new TileConversionError6(
+        throw new TileConversionError9(
           "MESH_TILESET_BOUNDS_INVALID",
           "Root bounds must have a finite diagonal"
         );
@@ -1342,7 +1888,7 @@ import {
   encodeTiles3DArchiveInBatches
 } from "@loaders.gl/3d-tiles/3d-tiles-archive-writer";
 import { SLPKWriter, encodeSLPKArchiveInBatches } from "@loaders.gl/i3s/i3s-slpk-writer";
-import { TileConversionError as TileConversionError7 } from "@loaders.gl/tile-converter/v5/core";
+import { TileConversionError as TileConversionError10 } from "@loaders.gl/tile-converter/v5/core";
 async function createTileConversionArchive(files, options) {
   const { resources, format, maxArchiveBytes, signal } = prepareArchiveInput(files, options);
   const writer = format === "3tz" ? Tiles3DArchiveWriter : SLPKWriter;
@@ -1357,17 +1903,17 @@ async function* encodeTileConversionArchiveInBatches(files, options) {
 function prepareArchiveInput(files, options) {
   const { format, maxArchiveBytes, signal } = options;
   if (!Number.isSafeInteger(maxArchiveBytes) || maxArchiveBytes < 0) {
-    throw new TileConversionError7(
+    throw new TileConversionError10(
       "INVALID_ARCHIVE_BYTE_LIMIT",
       "Archive byte limit must be a non-negative safe integer"
     );
   }
   if (format !== "3tz" && format !== "slpk") {
-    throw new TileConversionError7("INVALID_ARCHIVE_FORMAT", "Expected 3tz or slpk archive format");
+    throw new TileConversionError10("INVALID_ARCHIVE_FORMAT", "Expected 3tz or slpk archive format");
   }
   const resources = Object.fromEntries(files.map((file) => [file.resourceId, file.blob]));
   if (Object.keys(resources).length !== files.length) {
-    throw new TileConversionError7(
+    throw new TileConversionError10(
       "DUPLICATE_ARCHIVE_RESOURCE",
       "Archive resource identifiers must be unique"
     );
@@ -1377,17 +1923,17 @@ function prepareArchiveInput(files, options) {
 
 // src/v5/mesh-tileset-archive.ts
 import { Tiles3DArchiveWriter as Tiles3DArchiveWriter2 } from "@loaders.gl/3d-tiles/3d-tiles-archive-writer";
-import { TileConversionError as TileConversionError8 } from "@loaders.gl/tile-converter/v5/core";
+import { TileConversionError as TileConversionError11 } from "@loaders.gl/tile-converter/v5/core";
 async function createSingleMeshTilesetArchive(files, options) {
   const { maxArchiveBytes, signal } = options;
   if (!Number.isSafeInteger(maxArchiveBytes) || maxArchiveBytes < 0) {
-    throw new TileConversionError8(
+    throw new TileConversionError11(
       "INVALID_ARCHIVE_BYTE_LIMIT",
       "Archive byte limit must be a non-negative safe integer"
     );
   }
   if (files.length !== 2 || !files.some((file) => file.resourceId === "mesh.glb") || !files.some((file) => file.resourceId === "tileset.json")) {
-    throw new TileConversionError8(
+    throw new TileConversionError11(
       "INVALID_SINGLE_MESH_ARCHIVE",
       "Expected mesh.glb and tileset.json from a finalized single-mesh sink"
     );
@@ -1398,12 +1944,13 @@ async function createSingleMeshTilesetArchive(files, options) {
 }
 
 // src/v5/mesh-source.ts
-import { Matrix4 } from "@math.gl/core";
-import { TileConversionError as TileConversionError11 } from "@loaders.gl/tile-converter/v5/core";
+import { Matrix4 as Matrix42 } from "@math.gl/core";
+import { TileConversionError as TileConversionError14 } from "@loaders.gl/tile-converter/v5/core";
 import { createTilesetConversionSource } from "@loaders.gl/tile-converter/v5/core";
 
 // src/v5/mesh-source-texture.ts
-import { TileConversionError as TileConversionError9 } from "@loaders.gl/tile-converter/v5/core";
+import { getBinaryImageMetadata as getBinaryImageMetadata2 } from "@loaders.gl/images";
+import { TileConversionError as TileConversionError12 } from "@loaders.gl/tile-converter/v5/core";
 function mapMeshSourceTexture(textureInfo) {
   const texture = textureInfo?.texture;
   const image = texture?.source;
@@ -1430,7 +1977,7 @@ function mapMeshSourceTexture(textureInfo) {
       "extras"
     ].includes(name)
   ))) {
-    throw new TileConversionError9(
+    throw new TileConversionError12(
       "MESH_SOURCE_TEXTURE_UNSUPPORTED",
       "Base-color textures require a PNG/JPEG bufferView or base64 data URI, TEXCOORD_0, glTF sampling and an optional KHR_texture_transform on TEXCOORD_0"
     );
@@ -1459,7 +2006,7 @@ function mapMeshSourceImage(image) {
   }
   const match = typeof image.uri === "string" ? /^data:(image\/(?:png|jpeg));base64,([A-Za-z0-9+/]+={0,2})$/.exec(image.uri) : null;
   if (!match || image.mimeType !== void 0 && image.mimeType !== match[1]) {
-    throw new TileConversionError9(
+    throw new TileConversionError12(
       "MESH_SOURCE_TEXTURE_UNSUPPORTED",
       "Inline images require a PNG/JPEG base64 data URI and matching optional mimeType"
     );
@@ -1468,35 +2015,66 @@ function mapMeshSourceImage(image) {
   try {
     encodedBytes = atob(match[2]);
   } catch {
-    throw new TileConversionError9("MESH_SOURCE_TEXTURE_UNSUPPORTED", "Invalid inline image base64");
+    throw new TileConversionError12("MESH_SOURCE_TEXTURE_UNSUPPORTED", "Invalid inline image base64");
   }
   return {
     data: Uint8Array.from(encodedBytes, (character) => character.charCodeAt(0)),
     mimeType: match[1]
   };
 }
+async function resolveMeshSourceTexture(textureInfo, readExternalResource, contentUri, signal) {
+  const image = textureInfo?.texture?.source;
+  if (!image || image.uri === void 0 || image.uri.startsWith("data:"))
+    return mapMeshSourceTexture(textureInfo);
+  if (!readExternalResource || image.bufferView !== void 0)
+    throw new TileConversionError12(
+      "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 = getBinaryImageMetadata2(new DataView(data.buffer, data.byteOffset, data.byteLength));
+  } catch {
+  }
+  if (!metadata || !["image/png", "image/jpeg"].includes(metadata.mimeType) || image.mimeType !== void 0 && image.mimeType !== metadata.mimeType)
+    throw new TileConversionError12(
+      "MESH_SOURCE_TEXTURE_UNSUPPORTED",
+      "External images require matching PNG/JPEG headers"
+    );
+  const resolved = {
+    ...textureInfo,
+    texture: {
+      ...textureInfo.texture,
+      source: { ...image, uri: void 0, mimeType: metadata.mimeType, bufferView: { data } }
+    }
+  };
+  return mapMeshSourceTexture(resolved);
+}
 
 // src/v5/mesh-source-features.ts
-import { TileConversionError as TileConversionError10 } from "@loaders.gl/tile-converter/v5/core";
+import { TileConversionError as TileConversionError13 } from "@loaders.gl/tile-converter/v5/core";
 function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
   const declarations = primitive.extensions?.EXT_mesh_features?.featureIds;
   const metadata = gltf.extensions?.EXT_structural_metadata;
   const legacy = primitive.attributes._BATCHID;
   if (!declarations && !legacy && !metadata && !Object.keys(payload.batchTableJson || {}).length && !payload.header?.batchLength) {
     if (Object.keys(primitive.attributes).some((name) => /^_FEATURE_ID_\d+$/.test(name)))
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_MAPPING_REQUIRED",
         "Feature attributes require an EXT_mesh_features declaration"
       );
     return void 0;
   }
   if (!options)
-    throw new TileConversionError10(
+    throw new TileConversionError13(
       "MESH_FEATURE_SCHEMA_REQUIRED",
       "Feature extraction requires an explicit Arrow schema and class mapping"
     );
   if (!options.metadataClass)
-    throw new TileConversionError10(
+    throw new TileConversionError13(
       "MESH_FEATURE_CLASS_REQUIRED",
       "Feature metadata class must be explicit"
     );
@@ -1505,20 +2083,20 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
   let properties;
   if (declarations) {
     if (legacy || declarations.length !== 1 || metadata?.propertyTables?.length !== 1 || metadata.propertyTextures?.length || metadata.propertyAttributes?.length)
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_MAPPING_UNSUPPORTED",
         "Only one attribute-backed feature set and one property table are supported"
       );
     const declaration = declarations[0];
     if (!Number.isInteger(declaration.attribute) || declaration.attribute < 0 || declaration.propertyTable !== 0 || declaration.texture || declaration.implicit || declaration.nullFeatureId !== void 0)
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_MAPPING_UNSUPPORTED",
         "Features require an attribute and property table 0 without null/texture/implicit IDs"
       );
     attribute = primitive.attributes[`_FEATURE_ID_${declaration.attribute}`];
     const table = metadata.propertyTables[0];
     if (table.class !== options.metadataClass || table.count !== declaration.featureCount)
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_CLASS_MISMATCH",
         "Feature class and declared table counts must agree"
       );
@@ -1526,33 +2104,49 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
     properties = {};
     const classProperties = metadata.schema?.classes?.[table.class]?.properties;
     if (!classProperties)
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_SCHEMA_REQUIRED",
         "A decoded inline structural metadata class is required"
       );
     if (Object.keys(table.properties || {}).some((name) => !Object.hasOwn(classProperties, name)))
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_PROPERTY_UNMAPPED",
         "Property table columns must be declared in the metadata class"
       );
     for (const [name, property] of Object.entries(classProperties)) {
       const column = table.properties?.[name];
-      if (!["SCALAR", "STRING"].includes(property.type) || property.array || property.noData !== void 0 || ["INT64", "UINT64"].includes(property.componentType || "") && (property.normalized || property.offset !== void 0 || property.scale !== void 0 || column?.offset !== void 0 || column?.scale !== void 0))
-        throw new TileConversionError10(
+      if (!["SCALAR", "STRING"].includes(property.type) || property.array || property.noData !== void 0 && (property.normalized || property.offset !== void 0 || property.scale !== void 0 || column?.offset !== void 0 || column?.scale !== void 0) || ["INT64", "UINT64"].includes(property.componentType || "") && (property.normalized || property.offset !== void 0 || property.scale !== void 0 || column?.offset !== void 0 || column?.scale !== void 0))
+        throw new TileConversionError13(
           "MESH_FEATURE_PROPERTY_UNSUPPORTED",
           `Property ${name} requires a separately qualified semantic mapping`
         );
       const data = column?.data;
       if (data === void 0 && property.default === void 0)
-        throw new TileConversionError10(
+        throw new TileConversionError13(
           "MESH_FEATURE_PROPERTY_UNAVAILABLE",
           `Property ${name} has not been decoded`
         );
-      properties[name] = data ?? Array.from({ length: count }, () => property.default);
+      const decoded = data ?? Array.from({ length: count }, () => property.default);
+      if (property.noData === void 0 || data === void 0) {
+        properties[name] = decoded;
+        continue;
+      }
+      const sentinel = property.noData;
+      const integer64 = ["INT64", "UINT64"].includes(property.componentType || "");
+      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.length !== count)
+        throw new TileConversionError13(
+          "MESH_FEATURE_PROPERTY_UNSUPPORTED",
+          `Property ${name} requires a valid decoded noData mapping`
+        );
+      const comparable = integer64 ? BigInt(sentinel) : sentinel;
+      properties[name] = Array.from(
+        decoded,
+        (value) => value === comparable ? property.default ?? null : value
+      );
     }
   } else {
     if (metadata)
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_MAPPING_UNSUPPORTED",
         "Structural metadata requires an attribute-backed feature declaration"
       );
@@ -1563,7 +2157,7 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
   if (!Number.isSafeInteger(count) || count <= 0 || !attribute || attribute.components !== 1 || attribute.normalized || attribute.value.length !== vertexCount || Array.from(attribute.value).some(
     (value) => !Number.isSafeInteger(value) || value < 0 || value >= count
   ))
-    throw new TileConversionError10(
+    throw new TileConversionError13(
       "MESH_FEATURE_IDS_INVALID",
       "Feature IDs must be one valid property-table row index per vertex"
     );
@@ -1571,20 +2165,20 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
   if (Object.keys(primitive.attributes).some(
     (name) => (name === "_BATCHID" || /^_FEATURE_ID_\d+$/.test(name)) && name !== selectedAttribute
   ))
-    throw new TileConversionError10(
+    throw new TileConversionError13(
       "MESH_FEATURE_MAPPING_UNSUPPORTED",
       "Additional feature ID sets require separate mappings"
     );
   for (const [name, values] of Object.entries(properties)) {
     if (!values || !Array.isArray(values) && !ArrayBuffer.isView(values) || values.length !== count)
-      throw new TileConversionError10(
+      throw new TileConversionError13(
         "MESH_FEATURE_PROPERTY_UNAVAILABLE",
         `Property ${name} must be a decoded column matching the table count`
       );
   }
   const sourceIdentifier = options.sourceFeatureIdProperty;
   if (sourceIdentifier && !properties[sourceIdentifier])
-    throw new TileConversionError10(
+    throw new TileConversionError13(
       "MESH_FEATURE_ID_PROPERTY_REQUIRED",
       "Stable source identifier property is missing"
     );
@@ -1601,13 +2195,14 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
   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]))
-      throw new TileConversionError10(
+    const rows = corners.map((corner) => attribute.value[corner]);
+    if (rows.some((row) => row !== rows[0]) && new Set(corners).size === 3)
+      throw new TileConversionError13(
         "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]);
   }
@@ -1628,13 +2223,13 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
       const metadata = await source.inspect(signal);
       const reference = metadata.spatialReference;
       if (metadata.type !== "TILES3D" || !reference || reference.status !== "native" || reference.sourceCrs !== "EPSG:4978" || reference.heightReference !== "ellipsoidal" || reference.axisOrder !== "xyz" || reference.verticalUnitScale !== 1 || reference.units?.some((unit) => unit !== "meter")) {
-        throw new TileConversionError11(
+        throw new TileConversionError14(
           "MESH_SOURCE_FRAME_UNSUPPORTED",
           "Mesh extraction requires native EPSG:4978 xyz coordinates in meters and ellipsoidal heights"
         );
       }
       if (metadata.tileset.metadata || metadata.tileset.groups?.length) {
-        throw new TileConversionError11(
+        throw new TileConversionError14(
           "MESH_SOURCE_METADATA_UNSUPPORTED",
           "Tileset/group metadata requires a separate mapping"
         );
@@ -1646,25 +2241,25 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
       for await (const item of source.read(inspection, signal)) {
         const placementReference = item.tile.header._spatialReference || tileset.spatialReference;
         if (placementReference && (placementReference.status !== "native" || placementReference.sourceCrs !== "EPSG:4978"))
-          throw new TileConversionError11(
+          throw new TileConversionError14(
             "MESH_SOURCE_FRAME_UNSUPPORTED",
             "Nested mesh placements require native ECEF coordinates"
           );
         if (item.tile.header.metadata || item.tile.header.implicitMetadata)
-          throw new TileConversionError11(
+          throw new TileConversionError14(
             "MESH_SOURCE_METADATA_UNSUPPORTED",
             "Tile metadata requires a separate mapping"
           );
         for (const content of item.contents) {
           signal?.throwIfAborted();
           if (content.metadata || content.group !== void 0)
-            throw new TileConversionError11(
+            throw new TileConversionError14(
               "MESH_SOURCE_METADATA_UNSUPPORTED",
               "Content metadata requires a separate mapping"
             );
           const payload = content.payload;
           if (!payload?.gltf || !["glTF", "gltf", "b3dm"].includes(payload.type || content.type || "")) {
-            throw new TileConversionError11(
+            throw new TileConversionError14(
               "MESH_SOURCE_CONTENT_UNSUPPORTED",
               "Mesh extraction requires decoded GLB/glTF or B3DM content"
             );
@@ -1673,40 +2268,43 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
           if (gltf.animations?.length || gltf.skins?.length || Object.keys(gltf.extensions || {}).some(
             (name) => !["EXT_structural_metadata", "CESIUM_RTC"].includes(name)
           )) {
-            throw new TileConversionError11(
+            throw new TileConversionError14(
               "MESH_SOURCE_SCENE_UNSUPPORTED",
               "Animated/skinned scenes and unmapped scene extensions are unsupported"
             );
           }
           const axis = payload.gltfUpAxis || "Y";
           if (!["X", "Y", "Z"].includes(axis))
-            throw new TileConversionError11("MESH_SOURCE_AXIS_UNSUPPORTED", "Unknown glTF up axis");
-          const placement = new Matrix4(item.tile.computedTransform);
+            throw new TileConversionError14("MESH_SOURCE_AXIS_UNSUPPORTED", "Unknown glTF up axis");
+          const placement = new Matrix42(item.tile.computedTransform);
           const rtc = payload.rtcCenter || gltf.extensions?.CESIUM_RTC?.center;
           if (rtc) {
             if (rtc.length !== 3 || rtc.some((value) => !Number.isFinite(value)))
-              throw new TileConversionError11(
+              throw new TileConversionError14(
                 "MESH_SOURCE_TRANSFORM_INVALID",
                 "RTC center must contain finite xyz coordinates"
               );
             placement.translate(rtc);
           }
           if (axis === "Y")
-            placement.multiplyRight(new Matrix4([1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]));
+            placement.multiplyRight(new Matrix42([1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]));
           if (axis === "X")
-            placement.multiplyRight(new Matrix4([0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]));
+            placement.multiplyRight(new Matrix42([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 : void 0);
           if (!roots?.length)
-            throw new TileConversionError11(
+            throw new TileConversionError14(
               "MESH_SOURCE_SCENE_UNSUPPORTED",
               "A default scene or exactly one scene is required"
             );
           let primitiveIndex = 0;
           for (const selected of traverseMeshNodes(roots, placement)) {
-            const resource = extractPrimitive(
+            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,
@@ -1718,7 +2316,7 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
             yield { ...resource, features };
           }
           if (!primitiveIndex)
-            throw new TileConversionError11(
+            throw new TileConversionError14(
               "MESH_SOURCE_CONTENT_EMPTY",
               "Declared content contains no supported mesh primitive"
             );
@@ -1730,16 +2328,16 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
 function* traverseMeshNodes(nodes, parent, ancestors = /* @__PURE__ */ new Set()) {
   for (const node of nodes) {
     if (ancestors.has(node) || node.skin || node.weights || Object.keys(node.extensions || {}).length)
-      throw new TileConversionError11(
+      throw new TileConversionError14(
         "MESH_SOURCE_NODE_UNSUPPORTED",
         "Cyclic, skinned, morphed, or extended nodes are unsupported"
       );
-    const transform = new Matrix4(parent).multiplyRight(
-      node.matrix ? new Matrix4(node.matrix) : new Matrix4().translate(node.translation || [0, 0, 0]).multiplyRight(new Matrix4().fromQuaternion(node.rotation || [0, 0, 0, 1])).scale(node.scale || [1, 1, 1])
+    const transform = new Matrix42(parent).multiplyRight(
+      node.matrix ? new Matrix42(node.matrix) : new Matrix42().translate(node.translation || [0, 0, 0]).multiplyRight(new Matrix42().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)
-        throw new TileConversionError11(
+        throw new TileConversionError14(
           "MESH_SOURCE_NODE_UNSUPPORTED",
           "Morph weights and mesh extensions are unsupported"
         );
@@ -1748,14 +2346,14 @@ function* traverseMeshNodes(nodes, parent, ancestors = /* @__PURE__ */ new Set()
     yield* traverseMeshNodes(node.children || [], transform, /* @__PURE__ */ new Set([...ancestors, node]));
   }
 }
-function extractPrimitive(primitive, transform, id) {
+async function extractPrimitive(primitive, transform, id, readExternalResource, contentUri, signal) {
   if (primitive.targets?.length || Object.keys(primitive.extensions || {}).some((name) => name !== "EXT_mesh_features"))
-    throw new TileConversionError11(
+    throw new TileConversionError14(
       "MESH_SOURCE_PRIMITIVE_UNSUPPORTED",
       "Morph targets and unmapped primitive extensions are unsupported"
     );
   if (Array.from(transform).some((value) => !Number.isFinite(value)) || transform[3] !== 0 || transform[7] !== 0 || transform[11] !== 0 || transform[15] !== 1 || transform.determinant() <= 0)
-    throw new TileConversionError11(
+    throw new TileConversionError14(
       "MESH_SOURCE_TRANSFORM_INVALID",
       "Mesh placement requires a finite invertible affine transform with positive determinant"
     );
@@ -1763,7 +2361,7 @@ function extractPrimitive(primitive, transform, id) {
   for (const [name, accessor] of Object.entries(primitive.attributes)) {
     if (name === "_BATCHID" || /^_FEATURE_ID_\d+$/.test(name)) continue;
     if (!["POSITION", "NORMAL", "COLOR_0", "TEXCOORD_0"].includes(name))
-      throw new TileConversionError11(
+      throw new TileConversionError14(
         "MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
         `Unsupported mesh attribute ${name}`
       );
@@ -1776,9 +2374,9 @@ function extractPrimitive(primitive, transform, id) {
   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, size: 1 } : void 0
+      indices: createTriangleIndices(primitive, (attributes.POSITION?.value.length ?? 0) / 3)
     },
     true
   );
@@ -1799,7 +2397,7 @@ function extractPrimitive(primitive, transform, id) {
   mesh.attributes.POSITION = { value: positions, size: 3 };
   if (mesh.attributes.NORMAL) {
     const values = mesh.attributes.NORMAL.value;
-    const normalMatrix = new Matrix4(transform).invert().transpose();
+    const normalMatrix = new Matrix42(transform).invert().transpose();
     const normals = new Float32Array(values.length);
     for (let index = 0; index < values.length; index += 3) {
       const normal = normalMatrix.transformAsVector(Array.from(values.subarray(index, index + 3)));
@@ -1815,14 +2413,19 @@ function extractPrimitive(primitive, transform, id) {
     id,
     mesh,
     origin: minimum.map((value, axis) => value / 2 + maximum[axis] / 2),
-    material: mapMaterial(primitive.material)
+    material: await mapMeshSourceMaterial(
+      primitive.material,
+      readExternalResource,
+      contentUri,
+      signal
+    )
   };
 }
-function mapMaterial(material) {
+async function mapMeshSourceMaterial(material, readExternalResource, contentUri, signal) {
   if (!material) return void 0;
   const pbr = material.pbrMetallicRoughness;
-  if (Object.keys(material).some(
-    (name) => ![
+  if (Object.entries(material).some(
+    ([name, value]) => value !== void 0 && ![
       "id",
       "name",
       "pbrMetallicRoughness",
@@ -1832,16 +2435,23 @@ function mapMaterial(material) {
       "emissiveFactor",
       "extras"
     ].includes(name)
-  ) || Object.keys(pbr || {}).some(
-    (name) => !["baseColorFactor", "baseColorTexture", "metallicFactor", "roughnessFactor"].includes(name)
+  ) || Object.entries(pbr || {}).some(
+    ([name, value]) => value !== void 0 && !["baseColorFactor", "baseColorTexture", "metallicFactor", "roughnessFactor"].includes(name)
   ) || material.emissiveFactor?.some((value) => value !== 0))
-    throw new TileConversionError11(
+    throw new TileConversionError14(
       "MESH_SOURCE_MATERIAL_UNSUPPORTED",
       "Only metallic-roughness factors and one embedded base-color image are supported"
     );
   return {
     baseColorFactor: pbr?.baseColorFactor,
-    ..."baseColorTexture" in (pbr || {}) ? { baseColorTexture: mapMeshSourceTexture(pbr.baseColorTexture) } : {},
+    ..."baseColorTexture" in (pbr || {}) ? {
+      baseColorTexture: await resolveMeshSourceTexture(
+        pbr.baseColorTexture,
+        readExternalResource,
+        contentUri,
+        signal
+      )
+    } : {},
     metallicFactor: pbr?.metallicFactor,
     roughnessFactor: pbr?.roughnessFactor,
     alphaMode: material.alphaMode,
@@ -1849,48 +2459,81 @@ function mapMaterial(material) {
     doubleSided: material.doubleSided
   };
 }
+function createTriangleIndices(primitive, vertexCount) {
+  const attribute = primitive.indices ? {
+    value: primitive.indices.value,
+    size: primitive.indices.components,
+    normalized: primitive.indices.normalized
+  } : void 0;
+  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 TileConversionError14(
+      "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++) {
+    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 };
+}
 
 // src/v5/i3s-mesh-conversion.ts
-import { encodeI3SMeshLayer } from "@loaders.gl/i3s";
-import { TileConversionError as TileConversionError12 } from "@loaders.gl/tile-converter/v5/core";
+import { encodeI3SMeshLayer, encodeI3SMeshLayerWithDraco } from "@loaders.gl/i3s";
+import { TileConversionError as TileConversionError15 } from "@loaders.gl/tile-converter/v5/core";
 import { createBoundedMemoryTileConversionSink as createBoundedMemoryTileConversionSink2 } from "@loaders.gl/tile-converter/v5/core";
 function createI3SMeshConversionCodec(options) {
   const reference = options.spatialContext.spatialReference;
   const height = reference.targetHeightReference === "native" ? reference.heightReference : reference.targetHeightReference;
   if (!["native", "transformed"].includes(reference.status) || (reference.targetCrs || reference.sourceCrs) !== "EPSG:4978" || height !== "ellipsoidal" || reference.status === "native" && (!["xyz", "unknown"].includes(reference.axisOrder) || reference.verticalUnitScale !== 1 || reference.units?.some((unit) => unit !== "meter")))
-    throw new TileConversionError12(
+    throw new TileConversionError15(
       "I3S_MESH_FRAME_UNSUPPORTED",
       "I3S mesh authoring requires resolved ECEF coordinates and ellipsoidal heights"
     );
+  let objectIdOffset = 0;
   return {
     /** Places a source mesh in ECEF and authors one layer without modifying source arrays. */
     async *convert(resource, _inspection, signal) {
       signal?.throwIfAborted();
       const mesh = validateMeshGeometry(resource.mesh, true);
       const positions = mesh.attributes.POSITION.value;
-      mesh.attributes.POSITION = {
-        value: options.spatialContext.transformPositions(positions),
-        size: 3
+      const context = options.spatialContext;
+      const transformed = "transformGeometryAsync" in context ? await context.transformGeometryAsync(
+        positions,
+        mesh.attributes.NORMAL?.value,
+        resource.normalReferenceFrame ?? options.normalReferenceFrame
+      ) : {
+        positions: context.transformPositions(positions),
+        normals: mesh.attributes.NORMAL ? context.transformNormals(mesh.attributes.NORMAL.value, positions) : void 0
       };
-      if (mesh.attributes.NORMAL)
-        mesh.attributes.NORMAL = {
-          value: options.spatialContext.transformNormals(mesh.attributes.NORMAL.value, positions),
-          size: 3
-        };
+      signal?.throwIfAborted();
+      mesh.attributes.POSITION = { value: transformed.positions, size: 3 };
+      if (mesh.attributes.NORMAL) mesh.attributes.NORMAL = { value: transformed.normals, size: 3 };
       let layer;
       try {
-        layer = encodeI3SMeshLayer(mesh, {
+        const writerOptions = {
           ...options,
           material: resource.material,
-          features: resource.features
-        });
+          features: resource.features,
+          objectIdOffset
+        };
+        layer = options.draco === false ? encodeI3SMeshLayer(mesh, writerOptions) : await encodeI3SMeshLayerWithDraco(mesh, writerOptions, options.dracoLibraryOptions);
       } catch (error) {
-        throw new TileConversionError12(
+        throw new TileConversionError15(
           "I3S_MESH_PROFILE_UNSUPPORTED",
           error instanceof Error ? error.message : String(error)
         );
       }
       signal?.throwIfAborted();
+      objectIdOffset += resource.features?.batches.reduce((total, batch) => total + batch.data.numRows, 0) ?? 1;
       yield { id: resource.id, ...layer };
     },
     /** Reports measured precision and explicitly authorized integer representation changes. */
@@ -1925,19 +2568,26 @@ function createSingleMeshI3SSink(options) {
     async write(resource, signal) {
       signal?.throwIfAborted();
       if (state !== "empty")
-        throw new TileConversionError12(
+        throw new TileConversionError15(
           "SINGLE_I3S_MESH_UNAVAILABLE",
           "The initial I3S sink accepts exactly one mesh layer"
         );
       state = "writing";
       for (const [resourceId, bytes] of Object.entries(resource.files))
-        await memory.write({ resourceId, parts: [bytes], contentType: "application/gzip" }, signal);
+        await memory.write(
+          {
+            resourceId,
+            parts: [bytes],
+            contentType: resourceId.endsWith(".png") ? "image/png" : resourceId.endsWith(".jpg") ? "image/jpeg" : "application/gzip"
+          },
+          signal
+        );
       state = "written";
     },
     /** Commits a complete single-layer result. */
     async finalize(report) {
       if (state !== "written")
-        throw new TileConversionError12(
+        throw new TileConversionError15(
           "SINGLE_I3S_MESH_INCOMPLETE",
           "Finalization requires exactly one successfully written layer"
         );
@@ -1953,20 +2603,935 @@ function createSingleMeshI3SSink(options) {
     }
   };
 }
+
+// src/v5/i3s-mesh-sink.ts
+import { Ellipsoid } from "@math.gl/geospatial";
+import { GZipDecompressor, GZipCompressor } from "@loaders.gl/compression";
+import {
+  TileConversionError as TileConversionError16,
+  createBoundedMemoryTileConversionSink as createBoundedMemoryTileConversionSink3
+} from "@loaders.gl/tile-converter/v5/core";
+function createI3SMeshSink(options) {
+  const { maxMeshes, maxResourceBytes } = options;
+  if (!Number.isInteger(maxMeshes) || maxMeshes < 1 || maxMeshes > 64 || !Number.isSafeInteger(maxResourceBytes) || maxResourceBytes < 1)
+    throw new TileConversionError16(
+      "I3S_COLLECTION_OPTIONS_INVALID",
+      "I3S collections require 1\u201364 meshes and a positive resource byte limit"
+    );
+  const memory = createBoundedMemoryTileConversionSink3(options);
+  const compressor = new GZipCompressor({ useNative: false, gzip: { mtime: 0 } });
+  const decompressor = new GZipDecompressor({ useNative: false });
+  const leaves = [];
+  const identifiers = /* @__PURE__ */ new Set();
+  const objectIdRanges = [];
+  let layer;
+  let schemaKey;
+  let state = "open";
+  let completed = false;
+  async function readBytes(bytes) {
+    const output = await decompressor.decompress(bytes);
+    if (output.byteLength > maxResourceBytes)
+      throw new TileConversionError16(
+        "I3S_COLLECTION_RESOURCE_TOO_LARGE",
+        "I3S metadata exceeds maxResourceBytes"
+      );
+    return output;
+  }
+  async function readJson(resource, name) {
+    return JSON.parse(new TextDecoder().decode(await readBytes(resource.files[name])));
+  }
+  async function writeJson(resourceId, value) {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    if (bytes.byteLength > maxResourceBytes)
+      throw new TileConversionError16(
+        "I3S_COLLECTION_RESOURCE_TOO_LARGE",
+        "I3S index exceeds maxResourceBytes"
+      );
+    await memory.write({
+      resourceId,
+      parts: [await compressor.compress(bytes.buffer)],
+      contentType: "application/gzip"
+    });
+  }
+  return {
+    /** Exposes the whole collection atomically. */
+    getFiles: () => completed ? memory.getFiles() : [],
+    /** Retains one leaf's binary resources and validates its shared schema and IDs. */
+    async write(resource, signal) {
+      signal?.throwIfAborted();
+      if (state !== "open" || identifiers.has(resource.id) || leaves.length >= maxMeshes)
+        throw new TileConversionError16(
+          "I3S_COLLECTION_UNAVAILABLE",
+          "I3S collection is busy, closed, full, or repeats a placement"
+        );
+      state = "writing";
+      const authored = await readJson(resource, "3dSceneLayer.json.gz");
+      const key = JSON.stringify([
+        authored.fields,
+        authored.attributeStorageInfo,
+        authored.description,
+        authored.store.defaultGeometrySchema
+      ]);
+      if (schemaKey !== void 0 && key !== schemaKey)
+        throw new TileConversionError16(
+          "I3S_COLLECTION_SCHEMA_MISMATCH",
+          "Mesh nodes must share feature fields and the legacy geometry layout"
+        );
+      const objectIds = new DataView(
+        await readBytes(resource.files["nodes/1/attributes/f_0/0.bin.gz"])
+      );
+      const count = objectIds.getUint32(0, true);
+      const first = objectIds.getUint32(4, true);
+      if (objectIds.byteLength !== 4 + count * 4 || !count || objectIdRanges.some(([start, end]) => first < end && first + count > start) || Array.from({ length: count }, (_, index2) => objectIds.getUint32(4 + index2 * 4, true)).some(
+        (value, index2) => value !== first + index2
+      ))
+        throw new TileConversionError16(
+          "I3S_COLLECTION_IDS_INVALID",
+          "Generated object IDs must be contiguous and disjoint across nodes"
+        );
+      const index = leaves.length + 1;
+      const node = (await readJson(resource, "nodepages/0.json.gz")).nodes[1];
+      const legacy = await readJson(
+        resource,
+        "nodes/1/3dNodeIndexDocument.json.gz"
+      );
+      if (node.obb.quaternion.join(",") !== "0,0,0,1" || [...node.obb.center, ...node.obb.halfSize].some((value) => !Number.isFinite(value)) || node.obb.halfSize.some((value) => value < 0))
+        throw new TileConversionError16(
+          "I3S_COLLECTION_BOUNDS_INVALID",
+          "Expected finite axis-aligned bounds from the I3S mesh writer"
+        );
+      if (!layer) {
+        layer = structuredClone(authored);
+        layer.materialDefinitions = [];
+        layer.geometryDefinitions = [];
+        layer.textureSetDefinitions = [];
+        schemaKey = key;
+      }
+      const material = structuredClone(authored.materialDefinitions[0]);
+      const texture = material.pbrMetallicRoughness?.baseColorTexture;
+      if (texture) {
+        texture.textureSetDefinitionId = layer.textureSetDefinitions.length;
+        layer.textureSetDefinitions.push(authored.textureSetDefinitions[0]);
+        node.mesh.material.resource = index;
+      }
+      node.index = index;
+      node.parentIndex = 0;
+      node.mesh.material.definition = layer.materialDefinitions.length;
+      node.mesh.geometry.definition = layer.geometryDefinitions.length;
+      node.mesh.geometry.resource = index;
+      node.mesh.attribute.resource = index;
+      layer.materialDefinitions.push(material);
+      layer.geometryDefinitions.push(authored.geometryDefinitions[0]);
+      layer.store.resourcePattern = [
+        .../* @__PURE__ */ new Set([...layer.store.resourcePattern, ...authored.store.resourcePattern])
+      ];
+      layer.store.extent = layer.store.extent.map(
+        (value, axis) => axis < 2 ? Math.min(value, authored.store.extent[axis]) : Math.max(value, authored.store.extent[axis])
+      );
+      for (const [name, bytes] of Object.entries(resource.files)) {
+        if (name.startsWith("nodes/1/") && !name.endsWith("3dNodeIndexDocument.json.gz"))
+          await memory.write(
+            {
+              resourceId: name.replace("nodes/1/", `nodes/${index}/`),
+              parts: [bytes],
+              contentType: name.endsWith(".gz") ? "application/gzip" : name.endsWith(".png") ? "image/png" : "image/jpeg"
+            },
+            signal
+          );
+      }
+      leaves.push({ node, legacy: { ...legacy, id: String(index) } });
+      identifiers.add(resource.id);
+      objectIdRanges.push([first, first + count]);
+      state = "open";
+    },
+    /** Rebuilds both indices and layer bounds only after every leaf has completed. */
+    async finalize(report) {
+      if (state !== "open" || !layer || !leaves.length)
+        throw new TileConversionError16(
+          "I3S_COLLECTION_INCOMPLETE",
+          "Finalization requires successfully written mesh nodes"
+        );
+      state = "writing";
+      const minimum = [Infinity, Infinity, Infinity];
+      const maximum = [-Infinity, -Infinity, -Infinity];
+      for (const { node } of leaves) {
+        const center2 = Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
+        for (let axis = 0; axis < 3; axis++) {
+          minimum[axis] = Math.min(minimum[axis], center2[axis] - node.obb.halfSize[axis]);
+          maximum[axis] = Math.max(maximum[axis], center2[axis] + node.obb.halfSize[axis]);
+        }
+      }
+      const center = minimum.map((value, axis) => value / 2 + maximum[axis] / 2);
+      const geographicCenter = Array.from(Ellipsoid.WGS84.cartesianToCartographic(center));
+      const reconstructedCenter = Ellipsoid.WGS84.cartographicToCartesian(geographicCenter);
+      const obb = {
+        center: geographicCenter,
+        halfSize: minimum.map(
+          (value, axis) => maximum[axis] / 2 - value / 2 + Math.abs(center[axis] - reconstructedCenter[axis]) + 1e-7
+        ),
+        quaternion: [0, 0, 0, 1]
+      };
+      if ([...obb.center, ...obb.halfSize].some((value) => !Number.isFinite(value)))
+        throw new TileConversionError16(
+          "I3S_COLLECTION_BOUNDS_INVALID",
+          "Collection bounds cannot be represented"
+        );
+      const mbs = [...obb.center, Math.hypot(...obb.halfSize)];
+      const children = leaves.map(({ node }) => ({
+        id: String(node.index),
+        href: `../${node.index}`,
+        obb: node.obb,
+        mbs: [...node.obb.center, Math.hypot(...node.obb.halfSize)]
+      }));
+      await writeJson("nodes/root/3dNodeIndexDocument.json.gz", {
+        id: "root",
+        level: 0,
+        version: "1",
+        obb,
+        mbs,
+        lodSelection: [{ metricType: "maxScreenThresholdSQ", maxError: 0 }],
+        children
+      });
+      for (const { node, legacy } of leaves)
+        await writeJson(`nodes/${node.index}/3dNodeIndexDocument.json.gz`, {
+          ...legacy,
+          parentNode: { id: "root", href: "../root", obb, mbs }
+        });
+      const nodes = [
+        { index: 0, obb, lodThreshold: 0, children: leaves.map(({ node }) => node.index) },
+        ...leaves.map(({ node }) => node)
+      ];
+      for (let page = 0; page * 64 < nodes.length; page++)
+        await writeJson(`nodepages/${page}.json.gz`, {
+          nodes: nodes.slice(page * 64, (page + 1) * 64)
+        });
+      if (!layer.textureSetDefinitions?.length) delete layer.textureSetDefinitions;
+      await writeJson("3dSceneLayer.json.gz", layer);
+      await writeJson("metadata.json.gz", {
+        folderPattern: "BASIC",
+        archiveCompressionType: "STORE",
+        resourceCompressionType: "GZIP",
+        I3SVersion: "1.7",
+        nodeCount: nodes.length
+      });
+      await memory.finalize(report);
+      state = "closed";
+      completed = true;
+    },
+    /** Discards binary resources and index metadata after any failure. */
+    async abort(error) {
+      completed = false;
+      state = "closed";
+      leaves.length = 0;
+      identifiers.clear();
+      objectIdRanges.length = 0;
+      layer = void 0;
+      await memory.abort(error);
+    }
+  };
+}
+
+// src/v5/conversion-api.ts
+var TileConversionError17 = class extends Error {
+  /** Stable machine-readable failure code. */
+  code;
+  /** Diagnostics associated with this failure. */
+  diagnostics;
+  /** Creates a typed conversion failure. */
+  constructor(code, message, diagnostics = []) {
+    super(message);
+    this.name = "TileConversionError";
+    this.code = code;
+    this.diagnostics = diagnostics;
+  }
+};
+
+// src/v5/resource-fetcher.ts
+function createTileConversionResourceFetcher(options) {
+  let consumed = options.initialInputBytes ?? 0;
+  if (!Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 1 || !Number.isSafeInteger(consumed) || consumed < 0 || consumed > options.maxInputBytes)
+    throw new TileConversionError17(
+      "INVALID_INPUT_MEMORY_LIMIT",
+      "Resource fetch requires a positive aggregate byte budget and valid initial bytes"
+    );
+  const fetcher = options.fetcher ?? fetch;
+  return async (input, requestOptions) => {
+    options.signal?.throwIfAborted();
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    if (!["http:", "https:", "blob:", "data:"].includes(url.protocol))
+      throw new TileConversionError17(
+        "EXTERNAL_RESOURCE_UNSUPPORTED",
+        "Conversion transport requires HTTP(S), Blob or embedded data resources"
+      );
+    const requestSignal = requestOptions?.signal ?? (input instanceof Request ? input.signal : void 0);
+    const signal = options.signal && requestSignal ? AbortSignal.any([options.signal, requestSignal]) : options.signal ?? requestSignal;
+    const response = await fetcher(input, { ...requestOptions, signal });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new TileConversionError17(
+        "BROWSER_SOURCE_FETCH_FAILED",
+        `Could not fetch conversion resource (${response.status})`
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+      throw new TileConversionError17(
+        "BROWSER_SOURCE_STREAM_UNAVAILABLE",
+        "Conversion resources require readable response streams"
+      );
+    const cancelRead = () => {
+      void reader.cancel(signal?.reason).catch(() => {
+      });
+    };
+    signal?.addEventListener("abort", cancelRead, { once: true });
+    const parts = [];
+    let byteLength = 0;
+    try {
+      while (true) {
+        signal?.throwIfAborted();
+        const { done, value } = await reader.read();
+        signal?.throwIfAborted();
+        if (done) break;
+        if (value.byteLength > options.maxInputBytes - consumed)
+          throw new TileConversionError17(
+            "INPUT_RESOURCE_TOO_LARGE",
+            "Selected contents and external dependencies exceed the aggregate input byte budget"
+          );
+        consumed += value.byteLength;
+        byteLength += value.byteLength;
+        parts.push(value);
+      }
+    } catch (error) {
+      await reader.cancel(error);
+      throw error;
+    } finally {
+      signal?.removeEventListener("abort", cancelRead);
+      reader.releaseLock();
+    }
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    return new Response(bytes, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+}
+
+// src/v5/point-cloud-tileset-sink.ts
+import {
+  createBoundedMemoryTileConversionSink as createBoundedMemoryTileConversionSink4,
+  TileConversionError as TileConversionError18
+} from "@loaders.gl/tile-converter/v5/core";
+function createPointCloudTilesetSink(options) {
+  const { maxTiles, geometricError } = options;
+  if (!Number.isSafeInteger(maxTiles) || maxTiles < 1 || !Number.isFinite(geometricError) || geometricError < 0) {
+    throw new TileConversionError18(
+      "POINT_CLOUD_TILESET_OPTIONS_INVALID",
+      "Positive maxTiles and finite nonnegative geometricError are required"
+    );
+  }
+  const memory = createBoundedMemoryTileConversionSink4(options);
+  const children = [];
+  const identifiers = /* @__PURE__ */ new Set();
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  let state = "open";
+  let completed = false;
+  return {
+    /** Exposes finalized files without exposing a partial package. */
+    getFiles: () => completed ? memory.getFiles() : [],
+    /** Captures one validated placement and encoded PNTS resource. */
+    async write(resource, signal) {
+      signal?.throwIfAborted();
+      if (state !== "open")
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
+          "Point sink is busy or closed"
+        );
+      if (!resource.id || identifiers.has(resource.id) || children.length >= maxTiles) {
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_PLACEMENT_INVALID",
+          "Placements require unique nonempty identifiers within maxTiles"
+        );
+      }
+      const [lower, upper] = getPointTileBounds(resource, geometricError);
+      const resourceId = `points/${children.length}.pnts`;
+      state = "writing";
+      await memory.write(
+        { resourceId, parts: [resource.pnts], contentType: "application/octet-stream" },
+        signal
+      );
+      if (state !== "writing")
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
+          "Point sink was aborted during writing"
+        );
+      children.push({
+        boundingVolume: { box: createPointBoundsBox(lower, upper) },
+        geometricError,
+        content: { uri: resourceId }
+      });
+      identifiers.add(resource.id);
+      for (let axis = 0; axis < 3; axis++) {
+        minimum[axis] = Math.min(minimum[axis], lower[axis]);
+        maximum[axis] = Math.max(maximum[axis], upper[axis]);
+      }
+      state = "open";
+    },
+    /** Serializes the enclosing root after all placements have completed. */
+    async finalize(report) {
+      if (state !== "open" || !children.length)
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_SINK_INCOMPLETE",
+          "Finalization requires successfully written point tiles"
+        );
+      state = "writing";
+      const rootError = Math.max(
+        geometricError,
+        Math.hypot(...minimum.map((value, axis) => maximum[axis] - value))
+      );
+      if (!Number.isFinite(rootError))
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_BOUNDS_INVALID",
+          "Enclosing bounds must have a finite diagonal"
+        );
+      const json = JSON.stringify({
+        asset: { version: "1.0" },
+        geometricError: rootError,
+        root: {
+          boundingVolume: { box: createPointBoundsBox(minimum, maximum) },
+          geometricError: rootError,
+          refine: "ADD",
+          children
+        }
+      });
+      await memory.write({
+        resourceId: "tileset.json",
+        parts: [json],
+        contentType: "application/json"
+      });
+      if (state !== "writing")
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
+          "Point sink was aborted during finalization"
+        );
+      await memory.finalize(report);
+      if (state !== "writing")
+        throw new TileConversionError18(
+          "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
+          "Point sink was aborted during finalization"
+        );
+      state = "closed";
+      completed = true;
+    },
+    /** Clears resource and hierarchy storage on failure or cancellation. */
+    async abort(error) {
+      state = "closed";
+      completed = false;
+      children.length = 0;
+      identifiers.clear();
+      await memory.abort(error);
+    }
+  };
+}
+function getPointTileBounds(resource, geometricError) {
+  const reference = resource.spatialReference;
+  const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  if (!reference || !["native", "transformed"].includes(reference.status) || (reference.targetCrs || reference.sourceCrs) !== "EPSG:4978" || (reference.targetHeightReference === "native" ? reference.heightReference : reference.targetHeightReference) !== "ellipsoidal" || resource.coordinateSystem !== "cartesian" || resource.cartographicOrigin.length !== 3 || resource.cartographicOrigin.some((value) => value !== 0) || resource.modelMatrix && (resource.modelMatrix.length !== 16 || resource.modelMatrix.some((value, index) => value !== identity[index])) || reference.status === "native" && (reference.coordinateFrame !== "geocentric" || reference.axisOrder !== "xyz" || reference.verticalUnitScale !== 1 || reference.units?.some((unit) => unit !== "meter"))) {
+    throw new TileConversionError18(
+      "POINT_CLOUD_TILESET_FRAME_UNSUPPORTED",
+      "Point tiles require declared EPSG:4978 xyz meters, ellipsoidal heights and no additional source placement"
+    );
+  }
+  if (!Number.isFinite(resource.maximumPositionError) || resource.maximumPositionError < 0 || resource.maximumPositionError > geometricError) {
+    throw new TileConversionError18(
+      "POINT_CLOUD_GEOMETRIC_ERROR_INVALID",
+      "geometricError must include measured position reconstruction error"
+    );
+  }
+  const [minimum, maximum] = resource.localBoundingBox;
+  const center = resource.rtcCenter;
+  if (center.length !== 3 || minimum.length !== 3 || maximum.length !== 3 || [...center, ...minimum, ...maximum].some((value) => !Number.isFinite(value)) || minimum.some((value, axis) => value > maximum[axis])) {
+    throw new TileConversionError18(
+      "POINT_CLOUD_TILESET_BOUNDS_INVALID",
+      "RTC center and encoded xyz bounds must be finite and ordered"
+    );
+  }
+  const lower = minimum.map((value, axis) => value + center[axis]);
+  const upper = maximum.map((value, axis) => value + center[axis]);
+  if ([...lower, ...upper].some((value) => !Number.isFinite(value)))
+    throw new TileConversionError18(
+      "POINT_CLOUD_TILESET_BOUNDS_INVALID",
+      "Reconstructed ECEF bounds must be finite"
+    );
+  return [lower, upper];
+}
+function createPointBoundsBox(minimum, maximum) {
+  const center = minimum.map((value, axis) => value / 2 + maximum[axis] / 2);
+  const halfSize = minimum.map((value, axis) => maximum[axis] / 2 - value / 2);
+  return [center[0], center[1], center[2], halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]];
+}
+
+// src/v5/i3s-mesh-source.ts
+import {
+  TileConversionError as TileConversionError21,
+  createTilesetConversionSource as createTilesetConversionSource2
+} from "@loaders.gl/tile-converter/v5/core";
+
+// src/v5/i3s-mesh-source-material.ts
+import { getBinaryImageMetadata as getBinaryImageMetadata3 } from "@loaders.gl/images";
+import { TileConversionError as TileConversionError19 } from "@loaders.gl/tile-converter/v5/core";
+async function mapI3SMeshSourceMaterial(content, header, readExternalResource, contentUri, signal) {
+  const material = Object.fromEntries(
+    Object.entries(content.material || {}).filter(([, value]) => value !== void 0)
+  );
+  const metallicRoughness = material.pbrMetallicRoughness ? Object.fromEntries(
+    Object.entries(material.pbrMetallicRoughness).filter(([, value]) => value !== void 0)
+  ) : {};
+  material.pbrMetallicRoughness = metallicRoughness;
+  if (material.cullFace !== void 0 && material.cullFace !== "back") {
+    throw new TileConversionError19(
+      "I3S_MESH_SOURCE_MATERIAL_UNSUPPORTED",
+      "Only back-face culling is supported"
+    );
+  }
+  delete material.cullFace;
+  let textureInfo = metallicRoughness.baseColorTexture ? { ...metallicRoughness.baseColorTexture } : void 0;
+  const resources = header.textureUrls?.length ? header.textureUrls : header.textureUrl ? [
+    {
+      textureSetDefinitionId: textureInfo?.textureSetDefinitionId ?? 0,
+      textureUrl: header.textureUrl,
+      textureFormat: header.textureFormat || "jpg"
+    }
+  ] : [];
+  if (!textureInfo && !header.materialDefinition && resources.length === 1) {
+    textureInfo = { textureSetDefinitionId: resources[0].textureSetDefinitionId };
+  }
+  const encodedTextures = content.textures || {};
+  if (!textureInfo && (resources.length || content.texture || Object.keys(encodedTextures).length)) {
+    throw new TileConversionError19(
+      "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
+      "Texture resources require a base-color mapping"
+    );
+  }
+  if (textureInfo) {
+    const definitionId = textureInfo.textureSetDefinitionId;
+    const wrappingModes = { none: 33071, repeat: 10497, mirror: 33648 };
+    if (typeof definitionId !== "number" || !Number.isSafeInteger(definitionId) || definitionId < 0 || textureInfo.texCoord !== void 0 && textureInfo.texCoord !== 0 || Object.keys(textureInfo).some(
+      (name) => !["textureSetDefinitionId", "texCoord", "wrapS", "wrapT", "texture"].includes(name)
+    ) || ["wrapS", "wrapT"].some(
+      (name) => textureInfo[name] !== void 0 && (typeof textureInfo[name] !== "string" || !Object.hasOwn(wrappingModes, textureInfo[name]))
+    ) || resources.length > 1 || resources.some((resource) => resource.textureSetDefinitionId !== definitionId) || Object.keys(encodedTextures).some((key) => key !== String(definitionId))) {
+      throw new TileConversionError19(
+        "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
+        "Only one base-color texture set on TEXCOORD_0 with qualified wrapping is supported"
+      );
+    }
+    let encoded = encodedTextures[String(definitionId)] || content.texture || textureInfo.texture?.source?.image;
+    if (!encoded) {
+      if (!resources.length || !readExternalResource) {
+        throw new TileConversionError19(
+          "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
+          "Encoded texture bytes or an explicit bounded resource reader are required"
+        );
+      }
+      signal?.throwIfAborted();
+      encoded = await readExternalResource(resources[0].textureUrl, contentUri, signal);
+      signal?.throwIfAborted();
+    }
+    const data = encoded instanceof ArrayBuffer ? new Uint8Array(encoded) : encoded;
+    let image;
+    if (data instanceof Uint8Array) {
+      try {
+        image = getBinaryImageMetadata3(new DataView(data.buffer, data.byteOffset, data.byteLength));
+      } catch {
+      }
+    }
+    const declaredFormat = resources[0]?.textureFormat;
+    if (!image || !["image/png", "image/jpeg"].includes(image.mimeType) || declaredFormat && (declaredFormat === "png" ? image.mimeType !== "image/png" : declaredFormat === "jpg" ? image.mimeType !== "image/jpeg" : true)) {
+      throw new TileConversionError19(
+        "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
+        "I3S base-color bytes must have matching PNG/JPEG headers"
+      );
+    }
+    const sampler = Object.fromEntries(
+      ["wrapS", "wrapT"].filter((name) => textureInfo[name] !== void 0).map((name) => [name, wrappingModes[textureInfo[name]]])
+    );
+    metallicRoughness.baseColorTexture = {
+      texCoord: 0,
+      texture: {
+        source: { mimeType: image.mimeType, bufferView: { data } },
+        ...Object.keys(sampler).length ? { sampler } : {}
+      }
+    };
+  }
+  const mapped = await mapMeshSourceMaterial(
+    material,
+    void 0,
+    contentUri,
+    signal
+  );
+  if (mapped?.baseColorTexture && !content.sourceAttributes?.uv0) {
+    throw new TileConversionError19(
+      "MESH_TEXCOORD_REQUIRED",
+      "Base-color textures require TEXCOORD_0"
+    );
+  }
+  return mapped;
+}
+
+// src/v5/i3s-mesh-source-features.ts
+import { I3SAttributeLoader } from "@loaders.gl/i3s";
+import { TileConversionError as TileConversionError20 } from "@loaders.gl/tile-converter/v5/core";
+async function extractI3SMeshFeatures(content, item, metadata, options, readExternalResource, contentUri, signal) {
+  const maximumAttributeBytes = options.maxAttributeBytes;
+  const storage = metadata.tileset.attributeStorageInfo;
+  const attributeUrls = item.tile.header.attributeUrls;
+  if (!options.metadataClass || !options.objectIdProperty || options.rawMetadataField || !Number.isSafeInteger(maximumAttributeBytes) || maximumAttributeBytes <= 0 || !storage?.length || attributeUrls?.length !== storage.length || !readExternalResource || new Set(storage.map((attribute2) => attribute2.name)).size !== storage.length || new Set(storage.map((attribute2) => attribute2.key)).size !== storage.length || !storage.some((attribute2) => attribute2.name === options.objectIdProperty) || (metadata.tileset.fields || []).some(
+    (field) => field.domain || field.type === "esriFieldTypeDate" || !storage.some((attribute2) => attribute2.name === field.name)
+  )) {
+    throw new TileConversionError20(
+      "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
+      "I3S attributes require an explicit scalar schema, object ID column, byte budget and resource reader; domains/dates/raw metadata need a custom mapper"
+    );
+  }
+  const attributeLoader = await I3SAttributeLoader.preload();
+  const columns = /* @__PURE__ */ Object.create(null);
+  let inputBytes = 0;
+  let count;
+  for (const [index, attribute2] of storage.entries()) {
+    signal?.throwIfAborted();
+    const values = attribute2.objectIds ?? attribute2.attributeValues;
+    const type = values?.valueType;
+    const expectedOrdering = attribute2.objectIds ? ["objectIds"] : type === "String" ? ["attributeByteCounts", "attributeValues"] : ["attributeValues"];
+    const expectedHeader = type === "String" ? [
+      { property: "count", valueType: "UInt32" },
+      { property: "attributeValuesByteCount", valueType: "UInt32" }
+    ] : [{ property: "count", valueType: "UInt32" }];
+    if (!type || values?.valuesPerElement !== 1 || attribute2.objectIds && attribute2.attributeValues || attribute2.header?.length !== expectedHeader.length || expectedHeader.some(
+      (value, headerIndex) => attribute2.header[headerIndex]?.property !== value.property || attribute2.header[headerIndex]?.valueType !== value.valueType
+    ) || attribute2.ordering && JSON.stringify(
+      attribute2.ordering.map((value) => value === "ObjectIds" ? "objectIds" : value)
+    ) !== JSON.stringify(expectedOrdering) || type === "String" && (values.encoding !== "UTF-8" || attribute2.attributeByteCounts?.valueType !== "UInt32" || attribute2.attributeByteCounts.valuesPerElement !== 1) || !attributeUrls[index]) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
+        `Attribute ${attribute2.name} requires a standard scalar/string resource layout`
+      );
+    }
+    const bytes = await readExternalResource(attributeUrls[index], contentUri, signal);
+    signal?.throwIfAborted();
+    inputBytes += bytes instanceof Uint8Array ? bytes.byteLength : Infinity;
+    if (!(bytes instanceof Uint8Array) || inputBytes > maximumAttributeBytes) {
+      throw new TileConversionError20(
+        "INPUT_RESOURCE_TOO_LARGE",
+        "I3S node attributes exceed maxAttributeBytes"
+      );
+    }
+    let parsed;
+    try {
+      parsed = await attributeLoader.parse(Uint8Array.from(bytes).buffer, {
+        attributeName: attribute2.name,
+        attributeType: type,
+        i3s: { attributeValues: "exact" }
+      });
+    } catch (error) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_ATTRIBUTE_INVALID",
+        `Invalid attribute ${attribute2.name}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const column = parsed[attribute2.name];
+    if (!column || count !== void 0 && column.length !== count || !column.length) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_ATTRIBUTE_COUNT_INVALID",
+        "Every attribute must have the same nonzero row count"
+      );
+    }
+    if (Array.from(column).some(
+      (value) => typeof value === "number" && !Number.isFinite(value)
+    )) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
+        "Numeric noData values require an explicit custom mapper"
+      );
+    }
+    count = column.length;
+    columns[attribute2.name] = column;
+  }
+  const identifiers = columns[options.objectIdProperty];
+  const attributeRows = /* @__PURE__ */ new Map();
+  for (let index = 0; index < count; index++) {
+    const identifier = identifiers[index];
+    if (!(typeof identifier === "bigint" || typeof identifier === "number" && Number.isSafeInteger(identifier)) || attributeRows.has(BigInt(identifier))) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
+        "Object IDs must be unique exact integers"
+      );
+    }
+    attributeRows.set(BigInt(identifier), index);
+  }
+  const vertexCount = content.vertexCount;
+  const geometryIdentifiers = content.featureIds;
+  const attribute = content.sourceAttributes?.id;
+  if (geometryIdentifiers.length !== vertexCount || attribute?.size !== 1 || attribute.normalized || attribute.value.length !== vertexCount || Array.from(geometryIdentifiers).some((value, index) => value !== attribute.value[index])) {
+    throw new TileConversionError20(
+      "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
+      "Geometry requires one exact unnormalized object ID per vertex"
+    );
+  }
+  const indices = content.indices;
+  const triangleFeatureIndices = new Uint32Array((indices?.length ?? vertexCount) / 3);
+  if (content.drawRanges?.length) {
+    const covered = new Uint8Array(triangleFeatureIndices.length);
+    for (const range of content.drawRanges) {
+      if (!Number.isSafeInteger(range.firstPrimitive) || range.firstPrimitive < 0 || !Number.isSafeInteger(range.primitiveCount) || range.primitiveCount <= 0 || range.firstPrimitive + range.primitiveCount > covered.length) {
+        throw new TileConversionError20(
+          "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
+          "Feature draw ranges must cover valid triangles"
+        );
+      }
+      for (let triangle = range.firstPrimitive; triangle < range.firstPrimitive + range.primitiveCount; triangle++) {
+        const vertex = indices?.[triangle * 3] ?? triangle * 3;
+        if (covered[triangle] || geometryIdentifiers[vertex] !== range.featureId) {
+          throw new TileConversionError20(
+            "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
+            "Feature draw ranges must agree with decoded ownership without overlapping"
+          );
+        }
+        covered[triangle] = 1;
+      }
+    }
+    if (covered.some((value) => value === 0)) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
+        "Feature draw ranges must cover every triangle"
+      );
+    }
+  }
+  const usedRows = /* @__PURE__ */ new Set();
+  for (let triangle = 0; triangle < triangleFeatureIndices.length; triangle++) {
+    const corners = [0, 1, 2].map(
+      (corner) => indices?.[triangle * 3 + corner] ?? triangle * 3 + corner
+    );
+    const featureIds = corners.map((corner) => geometryIdentifiers[corner]);
+    const row = attributeRows.get(BigInt(featureIds[0]));
+    if (row === void 0 || featureIds.some((identifier) => identifier !== featureIds[0])) {
+      throw new TileConversionError20(
+        "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
+        "Each triangle must reference one declared attribute row"
+      );
+    }
+    triangleFeatureIndices[triangle] = row;
+    usedRows.add(row);
+  }
+  if (usedRows.size !== count) {
+    throw new TileConversionError20(
+      "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
+      "Attribute rows without geometry require a separately qualified mapping"
+    );
+  }
+  const stableProperty = options.sourceFeatureIdProperty ?? options.objectIdProperty;
+  if (!Object.hasOwn(columns, stableProperty)) {
+    throw new TileConversionError20(
+      "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
+      "Stable identifier column is missing"
+    );
+  }
+  const batches = convertFeatureAttributesToArrowBatches(
+    Array.from({ length: count }, (_, index) => ({
+      featureId: columns[stableProperty][index],
+      metadataClass: options.metadataClass,
+      properties: Object.fromEntries(
+        Object.entries(columns).filter(([name]) => name !== options.objectIdProperty && name !== stableProperty).map(([name, values]) => [name, values[index]])
+      )
+    })),
+    options
+  );
+  const stableIds = /* @__PURE__ */ new Set();
+  for (const batch of batches) {
+    const column = batch.data.getChild(options.featureIdField || "feature_id");
+    for (let index = 0; index < column.length; index++) {
+      const identifier = column.get(index);
+      if (stableIds.has(identifier)) {
+        throw new TileConversionError20(
+          "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
+          "Stable IDs must be unique"
+        );
+      }
+      stableIds.add(identifier);
+    }
+  }
+  return {
+    batches,
+    triangleFeatureIndices,
+    featureIdField: options.featureIdField || "feature_id",
+    integer64Encoding: options.integer64Encoding
+  };
+}
+
+// src/v5/i3s-mesh-source.ts
+function createI3SMeshTilesetConversionSource(tileset, options = {}) {
+  const source = createTilesetConversionSource2(tileset, options);
+  return {
+    /** Validates the layer profile and explicit source decode policy before reading. */
+    async inspect(signal) {
+      if (options.features && options.getFeatures) {
+        throw new TileConversionError21(
+          "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
+          "Choose explicit resource features or a custom getFeatures mapper, not both"
+        );
+      }
+      const metadata = await source.inspect(signal);
+      if (metadata.type !== "I3S" || !["3DObject", "IntegratedMesh"].includes(metadata.tileset.layerType) || tileset.options.i3s?.geometryMode !== "source") {
+        throw new TileConversionError21(
+          "I3S_MESH_SOURCE_PROFILE_UNSUPPORTED",
+          "I3S mesh extraction requires a 3DObject/IntegratedMesh runtime with geometryMode=source"
+        );
+      }
+      if (!metadata.spatialReference?.sourceCrs) {
+        throw new TileConversionError21(
+          "I3S_MESH_SOURCE_REFERENCE_REQUIRED",
+          "I3S conversion requires an explicit source CRS"
+        );
+      }
+      return metadata;
+    },
+    /** Converts each supported content entry before shared traversal releases its buffers. */
+    async *read(metadata, signal) {
+      for await (const item of source.read(metadata, signal)) {
+        for (const entry of item.contents) {
+          signal?.throwIfAborted();
+          const content = entry.payload;
+          const attributes = content?.sourceAttributes;
+          if (content?.geometryMode !== "source" || content.topology !== "triangle-list" || !attributes || !(attributes.position?.value instanceof Float64Array) || content.spatialReference?.status !== "native" || [
+            "sourceCrs",
+            "verticalCrs",
+            "axisOrder",
+            "units",
+            "verticalUnitScale",
+            "heightReference",
+            "elevationMode",
+            "elevationOffset",
+            "elevationUnitScale",
+            "coordinateEpoch"
+          ].some(
+            (field) => JSON.stringify(content.spatialReference?.[field]) !== JSON.stringify(metadata.spatialReference?.[field])
+          )) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_GEOMETRY_UNSUPPORTED",
+              "I3S extraction requires original source-frame Float64 triangle geometry"
+            );
+          }
+          if (!["earth-centered", "vertex-reference-frame"].includes(
+            content.normalReferenceFrame || ""
+          ) || content.normalReferenceFrame !== (metadata.tileset.store?.normalReferenceFrame || "earth-centered")) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_NORMAL_FRAME_UNSUPPORTED",
+              "Unknown I3S vector basis"
+            );
+          }
+          if (content.meshSegmentation || Object.entries(attributes).some(
+            ([name, value]) => value && !["position", "normal", "uv0", "id", "faceRange"].includes(name)
+          )) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
+              "Only positions, normals, TEXCOORD_0 and explicitly mapped feature associations are supported"
+            );
+          }
+          const hasFeatures = content.featureIds.length > 0 || metadata.tileset.fields?.length || metadata.tileset.attributeStorageInfo?.length;
+          if (Array.from(content.featureIds).some((value) => !Number.isSafeInteger(value))) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
+              "Decoded numeric feature IDs must be exact safe integers"
+            );
+          }
+          if (hasFeatures && !options.getFeatures && !options.features) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
+              "I3S feature data requires explicit resource features or a custom Arrow mapper"
+            );
+          }
+          const mesh = validateMeshGeometry(
+            {
+              mode: 4,
+              topology: "triangle-list",
+              attributes: {
+                POSITION: attributes.position,
+                ...attributes.normal ? { NORMAL: attributes.normal } : {},
+                ...attributes.uv0 ? { TEXCOORD_0: attributes.uv0 } : {}
+              },
+              ...content.indices ? { indices: { value: content.indices, size: 1 } } : {}
+            },
+            true
+          );
+          if (mesh.attributes.POSITION.value.length / 3 !== content.vertexCount) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_COUNT_INVALID",
+              "I3S vertexCount must match the decoded geometry"
+            );
+          }
+          const features = options.getFeatures ? await options.getFeatures(content, item, metadata, signal) : options.features ? await extractI3SMeshFeatures(
+            content,
+            item,
+            metadata,
+            options.features,
+            options.readExternalResource,
+            entry.uri,
+            signal
+          ) : void 0;
+          signal?.throwIfAborted();
+          if (hasFeatures && !features) {
+            throw new TileConversionError21(
+              "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
+              "The feature mapper must return all declared feature data"
+            );
+          }
+          const mappedMaterial = await mapI3SMeshSourceMaterial(
+            content,
+            item.tile.header,
+            options.readExternalResource,
+            entry.uri,
+            signal
+          );
+          signal?.throwIfAborted();
+          yield {
+            id: `${item.tile.id}/${entry.index}`,
+            origin: [0, 0, 0],
+            mesh,
+            normalReferenceFrame: content.normalReferenceFrame === "vertex-reference-frame" ? "vertex-reference-frame" : "earth-centered",
+            features,
+            material: mappedMaterial
+          };
+        }
+      }
+    }
+  };
+}
 export {
   convertFeatureAttributesToArrowBatches,
   convertPointCloudSource,
   createI3SMeshConversionCodec,
+  createI3SMeshSink,
+  createI3SMeshTilesetConversionSource,
   createMeshConversionCodec,
   createMeshTilesetConversionSource,
   createMeshTilesetSink,
+  createPointCloudTilesetSink,
   createSingleMeshI3SSink,
   createSingleMeshTilesetArchive,
   createSingleMeshTilesetSink,
   createTileConversionArchive,
+  createTileConversionResourceFetcher,
   encodeMeshTile,
   encodePointCloudSource,
   encodePointCloudSourceTile,
   encodePointCloudTile,
-  encodeTileConversionArchiveInBatches
+  encodePointCloudTileWithMetadata,
+  encodeTileConversionArchiveInBatches,
+  transformPointCloudSourceTile
 };