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

package/dist/v5/adapters.js

@@ -0,0 +1,1972 @@
+// src/v5/feature-arrow.ts
+import { ArrowTableBuilder } from "@loaders.gl/schema-utils";
+import { TileConversionError } from "@loaders.gl/tile-converter/v5/core";
+var DEFAULT_FEATURE_ID_FIELD = "feature_id";
+var FEATURE_CLASS_METADATA_KEY = "loaders.gl:feature-class";
+function convertFeatureAttributesToArrowBatches(features, options) {
+  const featureIdField = options.featureIdField || DEFAULT_FEATURE_ID_FIELD;
+  const batchSize = options.batchSize ?? 65536;
+  if (!Number.isInteger(batchSize) || batchSize <= 0) {
+    throw new TileConversionError(
+      "INVALID_FEATURE_BATCH_SIZE",
+      "Feature Arrow batch size must be a positive integer"
+    );
+  }
+  const featureClasses = new Set(features.map((feature) => feature.metadataClass));
+  if (featureClasses.size > 1) {
+    throw new TileConversionError(
+      "MULTIPLE_FEATURE_CLASSES",
+      "Build separate Arrow batches for each source metadata class"
+    );
+  }
+  const metadataClass = features[0]?.metadataClass;
+  const schema = makeFeatureSchema(
+    options.schema,
+    featureIdField,
+    options.rawMetadataField,
+    metadataClass
+  );
+  const fieldsByName = new Map(schema.fields.map((field) => [field.name, field]));
+  const propertyFieldNames = new Set(
+    schema.fields.filter((field) => field.name !== featureIdField && field.name !== options.rawMetadataField).map((field) => field.name)
+  );
+  for (const feature of features) {
+    validateFeatureIdentifier(feature.featureId, fieldsByName.get(featureIdField)?.type);
+    if (feature.rawMetadata && !options.rawMetadataField) {
+      throw new TileConversionError(
+        "RAW_METADATA_FIELD_REQUIRED",
+        "A rawMetadataField must be declared to preserve encoded source metadata"
+      );
+    }
+    for (const propertyName of Object.keys(feature.properties)) {
+      if (!propertyFieldNames.has(propertyName)) {
+        throw new TileConversionError(
+          "FEATURE_PROPERTY_NOT_MAPPED",
+          `Feature property "${propertyName}" is not declared in the Arrow schema`
+        );
+      }
+    }
+  }
+  const batches = [];
+  for (let batchStart = 0; batchStart < features.length; batchStart += batchSize) {
+    const tableBuilder = new ArrowTableBuilder(schema);
+    const batchFeatures = features.slice(batchStart, batchStart + batchSize);
+    for (const feature of batchFeatures) {
+      const row = {
+        ...feature.properties,
+        [featureIdField]: feature.featureId
+      };
+      if (options.rawMetadataField) {
+        row[options.rawMetadataField] = feature.rawMetadata || null;
+      }
+      for (const field of schema.fields) {
+        if (row[field.name] === void 0) {
+          row[field.name] = null;
+        }
+        validateFeatureValue(field, row[field.name], field.name);
+      }
+      tableBuilder.addObjectRow(row);
+    }
+    const batch = tableBuilder.finishBatch();
+    if (batch) {
+      batches.push(batch);
+    }
+  }
+  return batches;
+}
+function makeFeatureSchema(sourceSchema, featureIdField, rawMetadataField, metadataClass) {
+  const fieldsByName = new Map(sourceSchema.fields.map((field) => [field.name, field]));
+  if (fieldsByName.size !== sourceSchema.fields.length) {
+    throw new TileConversionError(
+      "DUPLICATE_FEATURE_FIELDS",
+      "Arrow schema fields must have unique names"
+    );
+  }
+  for (const field of sourceSchema.fields) {
+    validateFeatureSchemaType(field);
+  }
+  const featureIdType = fieldsByName.get(featureIdField)?.type;
+  if (!featureIdType) {
+    throw new TileConversionError(
+      "FEATURE_ID_FIELD_REQUIRED",
+      `Arrow schema must declare the feature identifier field "${featureIdField}"`
+    );
+  }
+  if (rawMetadataField && !fieldsByName.has(rawMetadataField)) {
+    throw new TileConversionError(
+      "RAW_METADATA_FIELD_NOT_DECLARED",
+      `Arrow schema does not declare the raw metadata field "${rawMetadataField}"`
+    );
+  }
+  if (rawMetadataField === featureIdField) {
+    throw new TileConversionError(
+      "FEATURE_FIELDS_COLLIDE",
+      "The feature identifier and raw metadata require separate Arrow fields"
+    );
+  }
+  if (rawMetadataField && !isBinaryType(fieldsByName.get(rawMetadataField)?.type)) {
+    throw new TileConversionError(
+      "RAW_METADATA_FIELD_NOT_BINARY",
+      `Arrow schema field "${rawMetadataField}" must use binary or fixed-size-binary type`
+    );
+  }
+  return {
+    ...sourceSchema,
+    metadata: {
+      ...sourceSchema.metadata || {},
+      ...metadataClass ? { [FEATURE_CLASS_METADATA_KEY]: metadataClass } : {}
+    }
+  };
+}
+function validateFeatureIdentifier(featureId, dataType) {
+  const isStringIdentifier = typeof featureId === "string";
+  const isIntegerIdentifier2 = typeof featureId === "bigint" || Number.isSafeInteger(featureId);
+  const isStringType = dataType === "utf8" || dataType === "utf8-view";
+  if (isStringIdentifier && isStringType || isIntegerIdentifier2 && isIntegerDataType(dataType)) {
+    return;
+  }
+  throw new TileConversionError(
+    "FEATURE_ID_TYPE_MISMATCH",
+    `Feature identifier ${String(featureId)} is not compatible with the declared Arrow type`
+  );
+}
+function validateFeatureValue(field, value, fieldPath) {
+  if (value === null || value === void 0) {
+    if (field.nullable !== true) {
+      throw new TileConversionError(
+        "FEATURE_VALUE_REQUIRED",
+        `Required Arrow field "${fieldPath}" has no value`
+      );
+    }
+    return;
+  }
+  const dataType = field.type;
+  if (typeof dataType === "object") {
+    if (dataType.type === "dictionary") {
+      validateFeatureValue({ ...field, type: dataType.dictionary }, value, fieldPath);
+      return;
+    }
+    if (dataType.type === "list" || dataType.type === "large-list") {
+      if (!Array.isArray(value)) {
+        throw createFeatureValueTypeError(fieldPath, "an array");
+      }
+      const childField = dataType.children[0];
+      for (let index = 0; index < value.length; index++) {
+        validateFeatureValue(childField, value[index], `${fieldPath}[${index}]`);
+      }
+      return;
+    }
+    if (dataType.type === "fixed-size-list") {
+      if (!Array.isArray(value) || value.length !== dataType.listSize) {
+        throw createFeatureValueTypeError(fieldPath, `an array of length ${dataType.listSize}`);
+      }
+      const childField = dataType.children[0];
+      for (let index = 0; index < value.length; index++) {
+        validateFeatureValue(childField, value[index], `${fieldPath}[${index}]`);
+      }
+      return;
+    }
+    if (dataType.type === "struct") {
+      if (!isRecord(value)) {
+        throw createFeatureValueTypeError(fieldPath, "an object");
+      }
+      const childNames = new Set(dataType.children.map((childField) => childField.name));
+      const unknownNames = Object.keys(value).filter((name) => !childNames.has(name));
+      if (unknownNames.length > 0) {
+        throw new TileConversionError(
+          "FEATURE_PROPERTY_NOT_MAPPED",
+          `Nested feature properties "${unknownNames.join(", ")}" are not declared under "${fieldPath}"`
+        );
+      }
+      for (const childField of dataType.children) {
+        validateFeatureValue(childField, value[childField.name], `${fieldPath}.${childField.name}`);
+      }
+      return;
+    }
+    if (dataType.type === "decimal") {
+      if (typeof value !== "bigint") {
+        throw createFeatureValueTypeError(fieldPath, "an unscaled bigint decimal value");
+      }
+      if (value <= -(10n ** BigInt(dataType.precision)) || value >= 10n ** BigInt(dataType.precision)) {
+        throw new TileConversionError(
+          "FEATURE_VALUE_OUT_OF_RANGE",
+          `Value for Arrow decimal field "${fieldPath}" exceeds precision ${dataType.precision}`
+        );
+      }
+      return;
+    }
+    if (dataType.type === "fixed-size-binary") {
+      const byteLength = getByteLength(value);
+      if (byteLength !== dataType.byteWidth) {
+        throw createFeatureValueTypeError(fieldPath, `exactly ${dataType.byteWidth} bytes`);
+      }
+      return;
+    }
+    throw new TileConversionError(
+      "FEATURE_VALUE_MAPPING_UNSUPPORTED",
+      `Arrow schema type "${dataType.type}" has no feature value mapping for "${fieldPath}"`
+    );
+  }
+  if (isIntegerDataType(dataType)) {
+    if (!isIntegerIdentifier(value)) {
+      throw createFeatureValueTypeError(fieldPath, "an integer");
+    }
+    const [minimum, maximum] = getIntegerBounds(dataType);
+    const integerValue = typeof value === "bigint" ? value : BigInt(value);
+    if (integerValue < minimum || integerValue > maximum) {
+      throw new TileConversionError(
+        "FEATURE_VALUE_OUT_OF_RANGE",
+        `Value for Arrow field "${fieldPath}" is outside the range of ${dataType}`
+      );
+    }
+    return;
+  }
+  if (dataType === "utf8" || dataType === "utf8-view") {
+    if (typeof value !== "string") throw createFeatureValueTypeError(fieldPath, "a string");
+    if (new TextDecoder().decode(new TextEncoder().encode(value)) !== value)
+      throw createFeatureValueTypeError(fieldPath, "a valid Unicode string");
+    return;
+  }
+  if (dataType === "bool") {
+    if (typeof value !== "boolean") throw createFeatureValueTypeError(fieldPath, "a boolean");
+    return;
+  }
+  if (dataType === "binary" || dataType === "binary-view") {
+    if (getByteLength(value) < 0) throw createFeatureValueTypeError(fieldPath, "binary data");
+    return;
+  }
+  if (dataType === "float" || dataType === "float16" || dataType === "float32" || dataType === "float64") {
+    if (typeof value !== "number") throw createFeatureValueTypeError(fieldPath, "a number");
+    return;
+  }
+  if (dataType === "null") {
+    throw createFeatureValueTypeError(fieldPath, "null");
+  }
+  if (dataType === "date-day" || dataType === "date-millisecond" || dataType.startsWith("timestamp-")) {
+    if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+      throw createFeatureValueTypeError(fieldPath, "a valid Date");
+    }
+    return;
+  }
+  throw new TileConversionError(
+    "FEATURE_VALUE_MAPPING_UNSUPPORTED",
+    `Arrow schema type "${dataType}" has no feature value mapping for "${fieldPath}"`
+  );
+}
+function isIntegerIdentifier(value) {
+  return typeof value === "bigint" || typeof value === "number" && Number.isSafeInteger(value);
+}
+function isIntegerDataType(dataType) {
+  return dataType === "int8" || dataType === "int16" || dataType === "int32" || dataType === "int64" || dataType === "uint8" || dataType === "uint16" || dataType === "uint32" || dataType === "uint64";
+}
+function validateFeatureSchemaType(field) {
+  const dataType = field.type;
+  if (dataType === "int") {
+    throw new TileConversionError(
+      "FEATURE_INTEGER_TYPE_UNSUPPORTED",
+      `Arrow field "${field.name}" must declare an explicit integer width and signedness`
+    );
+  }
+  if (typeof dataType !== "object") {
+    return;
+  }
+  let childFields = [];
+  if (dataType.type === "dictionary" && dataType.indices) {
+    childFields = [{ name: `${field.name} index`, type: dataType.indices, nullable: false }];
+  } else if ("children" in dataType) {
+    childFields = dataType.children;
+  }
+  for (const childField of childFields) {
+    validateFeatureSchemaType(childField);
+  }
+}
+function getIntegerBounds(dataType) {
+  switch (dataType) {
+    case "int8":
+      return [-128n, 127n];
+    case "uint8":
+      return [0n, 255n];
+    case "int16":
+      return [-32768n, 32767n];
+    case "uint16":
+      return [0n, 65535n];
+    case "int32":
+      return [-2147483648n, 2147483647n];
+    case "uint32":
+      return [0n, 4294967295n];
+    case "int64":
+      return [-(2n ** 63n), 2n ** 63n - 1n];
+    case "uint64":
+      return [0n, 2n ** 64n - 1n];
+    default:
+      return [-(2n ** 31n), 2n ** 31n - 1n];
+  }
+}
+function createFeatureValueTypeError(fieldPath, expected) {
+  return new TileConversionError(
+    "FEATURE_VALUE_TYPE_MISMATCH",
+    `Arrow field "${fieldPath}" requires ${expected}`
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getByteLength(value) {
+  if (value instanceof Uint8Array) return value.byteLength;
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  return -1;
+}
+function isBinaryType(dataType) {
+  return dataType === "binary" || dataType === "binary-view" || typeof dataType === "object" && dataType.type === "fixed-size-binary";
+}
+
+// src/v5/point-cloud.ts
+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 = {}) {
+  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);
+  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(
+    {
+      type: TILE3D_TYPE.POINT_CLOUD,
+      featureTableJson: options.rtcCenter || constantRGBA ? {
+        ...options.rtcCenter ? { RTC_CENTER: [...options.rtcCenter] } : {},
+        ...constantRGBA ? { CONSTANT_RGBA: constantRGBA } : {}
+      } : void 0,
+      batchTableJson,
+      attributes: { positions, colors, normals, batchIds }
+    },
+    {}
+  );
+}
+function validatePointAttributes(attributes) {
+  const supportedAttributes = /* @__PURE__ */ new Set([
+    "POSITION",
+    "NORMAL",
+    "BATCH_ID",
+    attributes.COLOR_0 ? "COLOR_0" : "COLOR"
+  ]);
+  const unsupportedAttributes = Object.keys(attributes).filter(
+    (name) => !supportedAttributes.has(name)
+  );
+  if (unsupportedAttributes.length > 0) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_ATTRIBUTE_UNSUPPORTED",
+      `PNTS encoding does not support these point attributes: ${unsupportedAttributes.join(", ")}`
+    );
+  }
+}
+function getConstantRgba(constantRGBA) {
+  if (!constantRGBA) {
+    return null;
+  }
+  if (constantRGBA.length !== 4 || constantRGBA.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_CONSTANT_RGBA_INVALID",
+      "Point cloud constantRGBA must contain four unsigned byte values"
+    );
+  }
+  return [constantRGBA[0], constantRGBA[1], constantRGBA[2], constantRGBA[3]];
+}
+function getPositionValues(attribute, rtcCenter) {
+  if (rtcCenter && (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"
+    );
+  }
+  const values = attribute.value;
+  const result = new Float32Array(values.length);
+  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);
+  }
+  return result;
+}
+function getColorAttribute(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 3 && attribute.size !== 4) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_COLOR_SIZE_UNSUPPORTED",
+      "Point cloud color attributes must contain three or four components"
+    );
+  }
+  if (attribute.value.length !== pointCount * attribute.size) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_COLOR_COUNT_MISMATCH",
+      "Point cloud color count does not match the POSITION count"
+    );
+  }
+  const colors = new Uint8Array(attribute.value.length);
+  const maximum = getIntegerColorMaximum(attribute.value);
+  for (let index = 0; index < attribute.value.length; index++) {
+    const value = attribute.value[index];
+    const scaledValue = maximum ? value / maximum * 255 : value <= 1 ? value * 255 : value;
+    if (!Number.isFinite(scaledValue) || scaledValue < 0 || scaledValue > 255) {
+      throw new TileConversionError2(
+        "POINT_CLOUD_COLOR_VALUE_INVALID",
+        "Point cloud color components must be finite values from 0 through 255"
+      );
+    }
+    colors[index] = Math.round(scaledValue);
+  }
+  return { type: 5121, value: colors, size: attribute.size, normalized: false };
+}
+function getIntegerColorMaximum(values) {
+  if (values instanceof Uint8Array || values instanceof Uint8ClampedArray) {
+    return 255;
+  }
+  if (values instanceof Uint16Array) {
+    return 65535;
+  }
+  if (values instanceof Uint32Array) {
+    return 4294967295;
+  }
+  return null;
+}
+function getNormalAttribute(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 3 || attribute.value.length !== pointCount * 3) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_NORMAL_COUNT_MISMATCH",
+      "Point cloud normals must contain one xyz triple per position"
+    );
+  }
+  return { type: 5126, value: Float32Array.from(attribute.value), size: 3 };
+}
+function getBatchIds(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 1 || attribute.value.length !== pointCount) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_BATCH_ID_COUNT_MISMATCH",
+      "Point cloud BATCH_ID must contain one value per position"
+    );
+  }
+  const batchIds = new Uint16Array(pointCount);
+  for (let index = 0; index < pointCount; index++) {
+    const batchId = attribute.value[index];
+    if (!Number.isInteger(batchId) || batchId < 0 || batchId > 65535) {
+      throw new TileConversionError2(
+        "POINT_CLOUD_BATCH_ID_OUT_OF_RANGE",
+        "Point cloud BATCH_ID values must be unsigned 16-bit integers"
+      );
+    }
+    batchIds[index] = batchId;
+  }
+  return batchIds;
+}
+function validateBatchTable(batchTableJson, batchIds) {
+  if (!batchTableJson) {
+    if (batchIds) {
+      throw new TileConversionError2(
+        "POINT_CLOUD_BATCH_TABLE_REQUIRED",
+        "BATCH_ID values require matching batchTableJson properties"
+      );
+    }
+    return void 0;
+  }
+  if (!batchIds) {
+    throw new TileConversionError2(
+      "POINT_CLOUD_BATCH_ID_REQUIRED",
+      "batchTableJson requires a BATCH_ID attribute"
+    );
+  }
+  let batchLength = 0;
+  for (const batchId of batchIds) {
+    batchLength = Math.max(batchLength, batchId + 1);
+  }
+  const normalizedBatchTable = {};
+  for (const [name, values] of Object.entries(batchTableJson)) {
+    if (values.length !== batchLength) {
+      throw new TileConversionError2(
+        "POINT_CLOUD_BATCH_TABLE_LENGTH_MISMATCH",
+        `Batch table property "${name}" must contain ${batchLength} values`
+      );
+    }
+    normalizedBatchTable[name] = [...values];
+  }
+  return normalizedBatchTable;
+}
+
+// src/v5/point-cloud-source-encoder.ts
+import { traversePointCloudSource } from "@loaders.gl/tile-converter/v5/core";
+async function* encodePointCloudSource(source, options = {}) {
+  for await (const sourceTile of traversePointCloudSource(source, options)) {
+    const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
+    const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
+    if (encodedTile) {
+      yield encodedTile;
+    }
+  }
+}
+function encodePointCloudSourceTile(sourceTile, options = {}) {
+  const { header, content } = sourceTile;
+  if (!content) {
+    return null;
+  }
+  return {
+    id: header.id,
+    header,
+    pnts: encodePointCloudTile(content.data, {
+      ...options,
+      constantRGBA: options.constantRGBA ?? content.constantRGBA
+    }),
+    pointCount: content.pointCount,
+    coordinateSystem: content.coordinateSystem,
+    cartographicOrigin: [...content.cartographicOrigin],
+    modelMatrix: content.modelMatrix ? Array.from(content.modelMatrix) : void 0,
+    spatialReference: content.spatialReference,
+    spatialBoundingVolume: content.spatialBoundingVolume || header.spatialBoundingVolume
+  };
+}
+
+// src/v5/point-cloud-conversion.ts
+import { convertTileset } from "@loaders.gl/tile-converter/v5/core";
+import { traversePointCloudSource as traversePointCloudSource2 } from "@loaders.gl/tile-converter/v5/core";
+function convertPointCloudSource(source, options) {
+  return convertTileset({
+    source: {
+      async inspect() {
+        if (!source.isReady) {
+          await source.initialize();
+        }
+      },
+      read: (_inspection, signal) => traversePointCloudSource2(source, { maxDepth: options.maxDepth, signal })
+    },
+    codec: {
+      async *convert(sourceTile) {
+        const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
+        const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
+        if (encodedTile) {
+          yield encodedTile;
+        }
+      }
+    },
+    sink: options.sink,
+    measureInputBytes: options.measureInputBytes,
+    measureOutputBytes: (resource) => resource.pnts.byteLength,
+    maxInputResourceBytes: options.maxInputResourceBytes,
+    maxOutputResourceBytes: options.maxOutputResourceBytes,
+    signal: options.signal,
+    onProgress: options.onProgress
+  });
+}
+
+// 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";
+function encodeMeshTile(mesh, options = {}) {
+  const geometry = validateMeshGeometry(mesh);
+  const { scenegraph, materialIndex } = createMeshTileScenegraph(options, geometry);
+  const meshIndex = scenegraph.addMesh({
+    attributes: geometry.attributes,
+    indices: geometry.indices?.value,
+    material: materialIndex,
+    mode: 4
+  });
+  return finalizeMeshTileScenegraph(scenegraph, meshIndex);
+}
+function createMeshTileScenegraph(options, geometry) {
+  const scenegraph = new GLTFScenegraph({ json: { asset: { version: "2.0", generator: "loaders.gl" } } });
+  const material = options.material === void 0 ? void 0 : validateMeshMaterial(options.material, scenegraph, "TEXCOORD_0" in geometry.attributes);
+  return { scenegraph, materialIndex: material ? scenegraph.addMaterial(material) : void 0 };
+}
+function finalizeMeshTileScenegraph(scenegraph, meshIndex) {
+  const nodeIndex = scenegraph.addNode({ meshIndex });
+  const sceneIndex = scenegraph.addScene({ nodeIndices: [nodeIndex] });
+  scenegraph.setDefaultScene(sceneIndex);
+  scenegraph.createBinaryChunk();
+  return GLTFWriter.encodeSync(scenegraph.gltf);
+}
+function validateMeshGeometry(mesh, allowFloat64Positions = false) {
+  if (mesh.topology !== "triangle-list" || mesh.mode !== 4) {
+    throw new TileConversionError3(
+      "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(
+        "MESH_ATTRIBUTE_UNSUPPORTED",
+        `Mesh attribute ${name} is unsupported`
+      );
+    }
+  }
+  const positions = getFloatAttribute(mesh.attributes.POSITION, "POSITION", allowFloat64Positions);
+  const attributes = {
+    POSITION: { value: positions, size: 3 }
+  };
+  if (mesh.attributes.NORMAL) {
+    const normals = getFloatAttribute(mesh.attributes.NORMAL, "NORMAL");
+    if (normals.length !== positions.length) {
+      throw new TileConversionError3(
+        "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(
+          "MESH_NORMAL_INVALID",
+          "NORMAL vectors must have unit length"
+        );
+      }
+    }
+    attributes.NORMAL = { value: normals, size: 3 };
+  }
+  if ("COLOR_0" in mesh.attributes) {
+    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(
+        "MESH_COLOR_INVALID",
+        "COLOR_0 requires packed linear RGB/RGBA: Float32 in [0, 1] or normalized Uint8/Uint16, one per vertex"
+      );
+    }
+    validateAttributeLayout(colors, "COLOR_0", normalized);
+    attributes.COLOR_0 = {
+      value: colors.value,
+      size: colors.size,
+      ...normalized ? { normalized: true } : {}
+    };
+  }
+  if ("TEXCOORD_0" in mesh.attributes) {
+    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(
+        "MESH_TEXCOORD_INVALID",
+        "TEXCOORD_0 requires packed finite Float32 or normalized Uint8/Uint16 UV pairs, one per vertex"
+      );
+    }
+    validateAttributeLayout(textureCoordinates, "TEXCOORD_0", normalized);
+    attributes.TEXCOORD_0 = {
+      value: textureCoordinates.value,
+      size: 2,
+      ...normalized ? { normalized: true } : {}
+    };
+  }
+  const indices = getMeshIndices(mesh.indices, positions.length / 3);
+  if (!indices && positions.length % 9 !== 0) {
+    throw new TileConversionError3(
+      "MESH_TRIANGLE_COUNT_INVALID",
+      "Nonindexed meshes require complete triangles"
+    );
+  }
+  return {
+    topology: "triangle-list",
+    mode: 4,
+    attributes,
+    indices: indices ? { value: indices, size: 1 } : void 0
+  };
+}
+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(
+      "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`);
+  }
+  return attribute.value;
+}
+function getMeshIndices(attribute, vertexCount) {
+  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(
+      "MESH_INDICES_INVALID",
+      "Indices must contain packed unsigned integer scalars"
+    );
+  }
+  if (values.length === 0 || values.length % 3 !== 0) {
+    throw new TileConversionError3(
+      "MESH_TRIANGLE_COUNT_INVALID",
+      "Indices must contain complete triangles"
+    );
+  }
+  const restartIndex = 2 ** (values.BYTES_PER_ELEMENT * 8) - 1;
+  if (values.some((value) => value >= vertexCount || value === restartIndex)) {
+    throw new TileConversionError3(
+      "MESH_INDEX_OUT_OF_RANGE",
+      "Indices must reference existing vertices and exclude primitive-restart values"
+    );
+  }
+  return values;
+}
+function isNormalizedUnsignedAttribute(attribute) {
+  return attribute?.normalized === true && (attribute.value instanceof Uint8Array || attribute.value instanceof Uint16Array);
+}
+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(
+      "MESH_ATTRIBUTE_LAYOUT_UNSUPPORTED",
+      `${name} must use packed contiguous storage with supported normalization`
+    );
+  }
+}
+function validateMeshMaterial(material, scenegraph, hasTextureCoordinates) {
+  if (!material || typeof material !== "object" || Array.isArray(material)) {
+    throw new TileConversionError3("MESH_MATERIAL_INVALID", "Material must be an object");
+  }
+  const allowedProperties = [
+    "baseColorFactor",
+    "baseColorTexture",
+    "metallicFactor",
+    "roughnessFactor",
+    "alphaMode",
+    "alphaCutoff",
+    "doubleSided"
+  ];
+  for (const name of Object.keys(material)) {
+    if (!allowedProperties.includes(name)) {
+      throw new TileConversionError3(
+        "MESH_MATERIAL_UNSUPPORTED",
+        `Material property ${name} is unsupported`
+      );
+    }
+  }
+  const { baseColorFactor, metallicFactor, roughnessFactor, alphaMode, alphaCutoff, doubleSided } = material;
+  if (baseColorFactor !== void 0 && (!Array.isArray(baseColorFactor) || baseColorFactor.length !== 4 || Array.from(baseColorFactor).some(
+    (value) => !Number.isFinite(value) || value < 0 || value > 1
+  )) || [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(
+      "MESH_MATERIAL_INVALID",
+      "Material values must satisfy the selected glTF profile"
+    );
+  }
+  return {
+    pbrMetallicRoughness: {
+      baseColorFactor: baseColorFactor ? [...baseColorFactor] : void 0,
+      metallicFactor,
+      roughnessFactor,
+      baseColorTexture: "baseColorTexture" in material ? encodeBaseColorTexture(material.baseColorTexture, scenegraph, hasTextureCoordinates) : void 0
+    },
+    alphaMode,
+    alphaCutoff,
+    doubleSided
+  };
+}
+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(
+      "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(
+      "MESH_TEXCOORD_REQUIRED",
+      "Base-color texture requires TEXCOORD_0"
+    );
+  }
+  const image = new DataView(texture.data.buffer, texture.data.byteOffset, texture.data.byteLength);
+  let metadata;
+  try {
+    metadata = getBinaryImageMetadata(image);
+  } catch {
+  }
+  if (!metadata || metadata.mimeType !== texture.mimeType || metadata.width <= 0 || metadata.height <= 0) {
+    throw new TileConversionError3(
+      "MESH_TEXTURE_INVALID",
+      "Image header must match mimeType and declare positive dimensions"
+    );
+  }
+  const samplerIndex = "sampler" in texture ? scenegraph.addSampler(validateMeshSampler(texture.sampler)) : void 0;
+  const transform = "transform" in texture ? validateMeshTextureTransform(texture.transform) : void 0;
+  if (transform) scenegraph.registerRequiredExtension("KHR_texture_transform");
+  return {
+    ...transform ? { extensions: { KHR_texture_transform: transform } } : {},
+    index: scenegraph.addTexture({
+      imageIndex: scenegraph.addImage(image, texture.mimeType),
+      samplerIndex
+    })
+  };
+}
+function validateMeshSampler(sampler) {
+  if (!sampler || typeof sampler !== "object" || Array.isArray(sampler)) {
+    throw new TileConversionError3("MESH_SAMPLER_INVALID", "Sampler must be an object");
+  }
+  const allowedValues = {
+    wrapS: [33071, 33648, 10497],
+    wrapT: [33071, 33648, 10497],
+    magFilter: [9728, 9729],
+    minFilter: [9728, 9729, 9984, 9985, 9986, 9987]
+  };
+  for (const name in sampler) {
+    if (!Object.hasOwn(allowedValues, name)) {
+      throw new TileConversionError3(
+        "MESH_SAMPLER_UNSUPPORTED",
+        `Sampler property ${name} is unsupported`
+      );
+    }
+  }
+  const selectedSampler = {
+    wrapS: sampler.wrapS,
+    wrapT: sampler.wrapT,
+    minFilter: sampler.minFilter,
+    magFilter: sampler.magFilter
+  };
+  for (const name of Object.keys(allowedValues)) {
+    const property = name;
+    if (selectedSampler[property] !== void 0 && !allowedValues[property].includes(selectedSampler[property])) {
+      throw new TileConversionError3(
+        "MESH_SAMPLER_INVALID",
+        `Sampler ${name} must use a glTF wrapping/filtering value`
+      );
+    }
+  }
+  return selectedSampler;
+}
+function validateMeshTextureTransform(transform) {
+  if (!transform || typeof transform !== "object" || Array.isArray(transform)) {
+    throw new TileConversionError3(
+      "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(
+        "MESH_TEXTURE_TRANSFORM_UNSUPPORTED",
+        `Texture transform property ${name} is unsupported`
+      );
+    }
+  }
+  const { offset, rotation, scale } = transform;
+  const offsetValues = Array.isArray(offset) && offset.length === 2 ? [offset[0], offset[1]] : offset;
+  const scaleValues = Array.isArray(scale) && scale.length === 2 ? [scale[0], scale[1]] : scale;
+  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(
+      "MESH_TEXTURE_TRANSFORM_INVALID",
+      "Texture transform requires finite UV pairs and a finite rotation"
+    );
+  }
+  return {
+    offset: offsetValues === void 0 ? void 0 : [offsetValues[0], offsetValues[1]],
+    rotation,
+    scale: scaleValues === void 0 ? void 0 : [scaleValues[0], scaleValues[1]]
+  };
+}
+
+// src/v5/mesh-conversion.ts
+import { getSpatialCoordinateFrame } from "@loaders.gl/tiles";
+import { TileConversionError as TileConversionError5 } 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";
+var DRACO_EXTENSION = "KHR_draco_mesh_compression";
+async function encodeDracoMeshTile(geometry, options, libraryOptions = {}) {
+  geometry = validateMeshGeometry(geometry);
+  if (!geometry.indices) {
+    geometry.indices = {
+      size: 1,
+      value: Uint32Array.from(
+        { length: geometry.attributes.POSITION.value.length / 3 },
+        (_, index) => index
+      )
+    };
+  }
+  const { modules, useLocalLibraries, CDN: contentDeliveryNetwork } = libraryOptions;
+  const runtimeOptions = { modules, core: { useLocalLibraries, CDN: contentDeliveryNetwork } };
+  const { scenegraph, materialIndex } = createMeshTileScenegraph(options, geometry);
+  const encoded = await encodeDraco(geometry, {
+    ...runtimeOptions,
+    draco: { method: "MESH_EDGEBREAKER_ENCODING" }
+  });
+  const loaderOptions = { ...runtimeOptions, draco: { shape: "mesh" } };
+  const loader = await DracoLoader.preload("", loaderOptions);
+  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(
+      "MESH_DRACO_ENCODING_INVALID",
+      "Draco must preserve the triangle count and emit finite positions"
+    );
+  }
+  const inputPositions = geometry.attributes.POSITION.value;
+  const positionKeys = /* @__PURE__ */ new Set();
+  for (let index = 0; index < inputPositions.length; index += 3) {
+    positionKeys.add(getPositionKey(inputPositions, index));
+  }
+  for (let index = 0; index < positions.length; index += 3) {
+    if (!positionKeys.has(getPositionKey(positions, index))) {
+      throw new TileConversionError4(
+        "MESH_DRACO_POSITION_CHANGED",
+        "Lossless Draco must preserve the encoded Float32 positions"
+      );
+    }
+  }
+  const bufferView = scenegraph.addBufferView(encoded.data);
+  const attributes = {};
+  const attributeIdentifiers = {};
+  scenegraph.json.accessors = [];
+  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}`);
+    }
+    const accessor = {
+      componentType: attribute.value instanceof Uint8Array ? 5121 : attribute.value instanceof Uint16Array ? 5123 : 5126,
+      count: encoded.report.pointCount,
+      type: attribute.size === 2 ? "VEC2" : attribute.size === 3 ? "VEC3" : "VEC4",
+      ...attribute.normalized ? { normalized: true } : {}
+    };
+    if (name === "POSITION") {
+      const minimum = [Infinity, Infinity, Infinity];
+      const maximum = [-Infinity, -Infinity, -Infinity];
+      for (let index = 0; index < positions.length; index++) {
+        const axis = index % 3;
+        minimum[axis] = Math.min(minimum[axis], positions[index]);
+        maximum[axis] = Math.max(maximum[axis], positions[index]);
+      }
+      accessor.min = minimum;
+      accessor.max = maximum;
+    }
+    attributes[name] = scenegraph.json.accessors.push(accessor) - 1;
+    attributeIdentifiers[name] = encoded.report.attributes[name].id;
+  }
+  const indices = scenegraph.json.accessors.push({
+    componentType: decoded.indices.value instanceof Uint16Array ? 5123 : 5125,
+    count: encoded.report.faceCount * 3,
+    type: "SCALAR"
+  }) - 1;
+  scenegraph.json.meshes = [
+    {
+      primitives: [
+        {
+          attributes,
+          indices,
+          mode: 4,
+          ...materialIndex === void 0 ? {} : { material: materialIndex },
+          extensions: { [DRACO_EXTENSION]: { bufferView, attributes: attributeIdentifiers } }
+        }
+      ]
+    }
+  ];
+  scenegraph.registerRequiredExtension(DRACO_EXTENSION);
+  return { glb: finalizeMeshTileScenegraph(scenegraph, 0), positions };
+}
+function getPositionKey(positions, index) {
+  return `${positions[index]},${positions[index + 1]},${positions[index + 2]}`;
+}
+
+// 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");
+  }
+  if (!Number.isFinite(maxPositionError) || maxPositionError < 0) {
+    throw new TileConversionError5(
+      "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";
+  if (!["native", "transformed"].includes(spatialReference.status) || !["projected", "geocentric", "local", "cartesian"].includes(outputFrame)) {
+    throw new TileConversionError5(
+      "MESH_OUTPUT_FRAME_UNSUPPORTED",
+      "Mesh output requires a resolved Cartesian coordinate frame"
+    );
+  }
+  return {
+    /** 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(
+          "MESH_ORIGIN_INVALID",
+          "Target origin must contain three finite coordinates"
+        );
+      }
+      const targetPositions = spatialContext.transformPositions(sourcePositions);
+      if (targetPositions.length !== sourcePositions.length || targetPositions.some((value) => !Number.isFinite(value))) {
+        throw new TileConversionError5(
+          "MESH_TRANSFORM_INVALID",
+          "Spatial transformation must return one finite xyz position per vertex"
+        );
+      }
+      const localPositions = new Float32Array(targetPositions.length);
+      const minimum = [Infinity, Infinity, Infinity];
+      const maximum = [-Infinity, -Infinity, -Infinity];
+      const localMinimum = [Infinity, Infinity, Infinity];
+      const localMaximum = [-Infinity, -Infinity, -Infinity];
+      let maximumPositionError = 0;
+      for (let index = 0; index < targetPositions.length; index += 3) {
+        for (let axis = 0; axis < 3; axis++) {
+          localPositions[index + axis] = targetPositions[index + axis] - origin[axis];
+        }
+        const positionError = Math.hypot(
+          localPositions[index] + origin[0] - targetPositions[index],
+          localPositions[index + 1] + origin[1] - targetPositions[index + 1],
+          localPositions[index + 2] + origin[2] - targetPositions[index + 2]
+        );
+        if (!Number.isFinite(positionError) || positionError > maxPositionError) {
+          throw new TileConversionError5(
+            "MESH_POSITION_PRECISION_EXCEEDED",
+            "Float32 mesh positions exceed the configured reconstruction error budget"
+          );
+        }
+        maximumPositionError = Math.max(maximumPositionError, positionError);
+      }
+      geometry.attributes.POSITION = { value: localPositions, size: 3 };
+      if (geometry.attributes.NORMAL) {
+        geometry.attributes.NORMAL = {
+          value: spatialContext.transformNormals(geometry.attributes.NORMAL.value, sourcePositions),
+          size: 3
+        };
+      }
+      const appearance = { material: resource.material };
+      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++) {
+        const axis = index % 3;
+        const position = encoded.positions[index];
+        localMinimum[axis] = Math.min(localMinimum[axis], position);
+        localMaximum[axis] = Math.max(localMaximum[axis], position);
+        minimum[axis] = Math.min(minimum[axis], position + origin[axis]);
+        maximum[axis] = Math.max(maximum[axis], position + origin[axis]);
+      }
+      yield {
+        id: resource.id,
+        glb: encoded.glb,
+        origin,
+        boundingBox: [minimum, maximum],
+        localBoundingBox: [localMinimum, localMaximum],
+        spatialReference,
+        maximumPositionError
+      };
+    },
+    /** Reports position rounding authorized by the configured precision budget. */
+    async validateOutput(resource) {
+      return resource.maximumPositionError > 0 ? [
+        {
+          code: "MESH_POSITION_ROUNDING",
+          message: `Encoded positions have up to ${resource.maximumPositionError} target-unit reconstruction error`,
+          severity: "info",
+          resourceId: resource.id
+        }
+      ] : [];
+    }
+  };
+}
+
+// src/v5/mesh-tileset-sink.ts
+import { TileConversionError as TileConversionError6 } 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(
+      "MESH_GEOMETRIC_ERROR_INVALID",
+      "geometricError must be finite and nonnegative, in meters"
+    );
+  }
+  const memorySink = createBoundedMemoryTileConversionSink(options);
+  let state = "empty";
+  let completed = false;
+  return {
+    getFiles() {
+      return completed ? memorySink.getFiles() : [];
+    },
+    async write(resource, signal) {
+      signal?.throwIfAborted();
+      if (state !== "empty") {
+        throw new TileConversionError6(
+          "SINGLE_MESH_SINK_UNAVAILABLE",
+          "The sink accepts exactly one mesh before finalization or abort"
+        );
+      }
+      const json = JSON.stringify(createMeshTileset(resource, geometricError));
+      state = "writing";
+      await memorySink.write(
+        { resourceId: "mesh.glb", parts: [resource.glb], contentType: "model/gltf-binary" },
+        signal
+      );
+      await memorySink.write(
+        { resourceId: "tileset.json", parts: [json], contentType: "application/json" },
+        signal
+      );
+      state = "written";
+    },
+    async finalize(report) {
+      if (state !== "written") {
+        throw new TileConversionError6(
+          "SINGLE_MESH_SINK_INCOMPLETE",
+          "Finalization requires exactly one successfully written mesh"
+        );
+      }
+      await memorySink.finalize(report);
+      state = "closed";
+      completed = true;
+    },
+    async abort(error) {
+      state = "closed";
+      completed = false;
+      await memorySink.abort(error);
+    }
+  };
+}
+function createMeshTileset(resource, geometricError) {
+  const reference = resource.spatialReference;
+  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(
+      "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(
+      "MESH_GEOMETRIC_ERROR_INVALID",
+      "geometricError must include the measured position reconstruction error"
+    );
+  }
+  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(
+      "MESH_TILESET_BOUNDS_INVALID",
+      "Origin and local bounds must be finite xyz coordinates with ordered bounds"
+    );
+  }
+  const center = minimum.map((value, axis) => value / 2 + maximum[axis] / 2);
+  const halfSize = minimum.map((value, axis) => maximum[axis] / 2 - value / 2);
+  return {
+    asset: { version: "1.1" },
+    geometricError,
+    root: {
+      // 3D Tiles applies y-up -> z-up to GLB content before the tile transform.
+      transform: [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, ...origin, 1],
+      boundingVolume: {
+        // Bounds use the same y-up -> z-up rotation before the inverse tile rotation.
+        box: [
+          center[0],
+          -center[2],
+          center[1],
+          halfSize[0],
+          0,
+          0,
+          0,
+          0,
+          halfSize[1],
+          0,
+          -halfSize[2],
+          0
+        ]
+      },
+      geometricError,
+      refine: "REPLACE",
+      content: { uri: "mesh.glb" }
+    }
+  };
+}
+function createMeshTilesetSink(options) {
+  const { geometricError, maxMeshes } = options;
+  if (!Number.isFinite(geometricError) || geometricError < 0 || !Number.isSafeInteger(maxMeshes) || maxMeshes < 1) {
+    throw new TileConversionError6(
+      "MESH_TILESET_OPTIONS_INVALID",
+      "A leaf collection requires finite nonnegative geometricError and positive maxMeshes"
+    );
+  }
+  const memory = createBoundedMemoryTileConversionSink(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 the complete package atomically. */
+    getFiles: () => completed ? memory.getFiles() : [],
+    /** Retains one placement and its corresponding encoded GLB. */
+    async write(resource, signal) {
+      signal?.throwIfAborted();
+      if (state !== "open")
+        throw new TileConversionError6(
+          "MESH_TILESET_SINK_UNAVAILABLE",
+          "The mesh sink is busy or closed"
+        );
+      if (children.length >= maxMeshes || identifiers.has(resource.id))
+        throw new TileConversionError6(
+          "MESH_TILESET_PLACEMENT_INVALID",
+          "Mesh count exceeds maxMeshes or a placement identifier is repeated"
+        );
+      const tile = createMeshTileset(resource, geometricError).root;
+      const lower = resource.localBoundingBox[0].map(
+        (value, axis) => value + resource.origin[axis]
+      );
+      const upper = resource.localBoundingBox[1].map(
+        (value, axis) => value + resource.origin[axis]
+      );
+      if ([...lower, ...upper].some((value) => !Number.isFinite(value)))
+        throw new TileConversionError6(
+          "MESH_TILESET_BOUNDS_INVALID",
+          "Absolute bounds must be finite"
+        );
+      const resourceId = `meshes/${children.length}.glb`;
+      tile.content = { uri: resourceId };
+      state = "writing";
+      await memory.write(
+        { resourceId, parts: [resource.glb], contentType: "model/gltf-binary" },
+        signal
+      );
+      children.push(tile);
+      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";
+    },
+    /** Writes the enclosing root only when every leaf has completed. */
+    async finalize(report) {
+      if (state !== "open" || !children.length)
+        throw new TileConversionError6(
+          "MESH_TILESET_SINK_INCOMPLETE",
+          "Finalization requires written mesh leaves"
+        );
+      state = "writing";
+      const center = minimum.map((value, axis) => value / 2 + maximum[axis] / 2);
+      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(
+          "MESH_TILESET_BOUNDS_INVALID",
+          "Root bounds must have a finite diagonal"
+        );
+      const json = JSON.stringify({
+        asset: { version: "1.1" },
+        geometricError: rootGeometricError,
+        root: {
+          boundingVolume: {
+            box: [
+              center[0],
+              center[1],
+              center[2],
+              halfSize[0],
+              0,
+              0,
+              0,
+              halfSize[1],
+              0,
+              0,
+              0,
+              halfSize[2]
+            ]
+          },
+          geometricError: rootGeometricError,
+          refine: "ADD",
+          children
+        }
+      });
+      await memory.write({
+        resourceId: "tileset.json",
+        parts: [json],
+        contentType: "application/json"
+      });
+      await memory.finalize(report);
+      state = "closed";
+      completed = true;
+    },
+    /** Discards files and hierarchy metadata on failure or cancellation. */
+    async abort(error) {
+      state = "closed";
+      completed = false;
+      children.length = 0;
+      identifiers.clear();
+      await memory.abort(error);
+    }
+  };
+}
+
+// src/v5/conversion-archive.ts
+import {
+  Tiles3DArchiveWriter,
+  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";
+async function createTileConversionArchive(files, options) {
+  const { resources, format, maxArchiveBytes, signal } = prepareArchiveInput(files, options);
+  const writer = format === "3tz" ? Tiles3DArchiveWriter : SLPKWriter;
+  const archive = await writer.encode(resources, { [format]: { maxArchiveBytes, signal } });
+  return new Blob([archive], { type: writer.mimeTypes[0] });
+}
+async function* encodeTileConversionArchiveInBatches(files, options) {
+  const { resources, format, maxArchiveBytes, signal } = prepareArchiveInput(files, options);
+  const encode = format === "3tz" ? encodeTiles3DArchiveInBatches : encodeSLPKArchiveInBatches;
+  yield* encode(resources, { [format]: { maxArchiveBytes, signal } });
+}
+function prepareArchiveInput(files, options) {
+  const { format, maxArchiveBytes, signal } = options;
+  if (!Number.isSafeInteger(maxArchiveBytes) || maxArchiveBytes < 0) {
+    throw new TileConversionError7(
+      "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");
+  }
+  const resources = Object.fromEntries(files.map((file) => [file.resourceId, file.blob]));
+  if (Object.keys(resources).length !== files.length) {
+    throw new TileConversionError7(
+      "DUPLICATE_ARCHIVE_RESOURCE",
+      "Archive resource identifiers must be unique"
+    );
+  }
+  return { resources, format, maxArchiveBytes, signal };
+}
+
+// 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";
+async function createSingleMeshTilesetArchive(files, options) {
+  const { maxArchiveBytes, signal } = options;
+  if (!Number.isSafeInteger(maxArchiveBytes) || maxArchiveBytes < 0) {
+    throw new TileConversionError8(
+      "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(
+      "INVALID_SINGLE_MESH_ARCHIVE",
+      "Expected mesh.glb and tileset.json from a finalized single-mesh sink"
+    );
+  }
+  const resources = Object.fromEntries(files.map((file) => [file.resourceId, file.blob]));
+  const archive = await Tiles3DArchiveWriter2.encode(resources, { "3tz": { maxArchiveBytes, signal } });
+  return new Blob([archive], { type: Tiles3DArchiveWriter2.mimeTypes[0] });
+}
+
+// src/v5/mesh-source.ts
+import { Matrix4 } from "@math.gl/core";
+import { TileConversionError as TileConversionError11 } 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";
+function mapMeshSourceTexture(textureInfo) {
+  const texture = textureInfo?.texture;
+  const image = texture?.source;
+  const sampler = texture?.sampler;
+  const extensions = textureInfo?.extensions || {};
+  const hasTransform = Object.hasOwn(extensions, "KHR_texture_transform");
+  const transform = extensions.KHR_texture_transform;
+  if (!textureInfo || textureInfo.texCoord !== void 0 && textureInfo.texCoord !== 0 || Object.keys(extensions).some((name) => name !== "KHR_texture_transform") || hasTransform && (!transform || typeof transform !== "object" || Array.isArray(transform) || transform.texCoord !== void 0 && transform.texCoord !== 0 || Object.keys(transform.extensions || {}).length || Object.keys(transform).some(
+    (name) => !["offset", "rotation", "scale", "texCoord", "extensions", "extras"].includes(name)
+  )) || Object.keys(textureInfo).some(
+    (name) => !["id", "index", "texture", "texCoord", "extensions", "extras"].includes(name)
+  ) || !texture || Object.keys(texture).some(
+    (name) => !["id", "source", "sampler", "name", "extensions", "extras"].includes(name)
+  ) || Object.keys(texture.extensions || {}).length || !image || image.uri !== void 0 && image.bufferView !== void 0 || Object.keys(image.extensions || {}).length || image.uri === void 0 && (!(image.bufferView?.data instanceof Uint8Array) || Object.keys(image.bufferView.extensions || {}).length || !["image/png", "image/jpeg"].includes(image.mimeType || "")) || sampler && (Object.keys(sampler.extensions || {}).length || Object.keys(sampler).some(
+    (name) => ![
+      "id",
+      "parameters",
+      "wrapS",
+      "wrapT",
+      "magFilter",
+      "minFilter",
+      "name",
+      "extensions",
+      "extras"
+    ].includes(name)
+  ))) {
+    throw new TileConversionError9(
+      "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"
+    );
+  }
+  const selectedSampler = sampler ? {
+    wrapS: sampler.wrapS,
+    wrapT: sampler.wrapT,
+    magFilter: sampler.magFilter,
+    minFilter: sampler.minFilter
+  } : void 0;
+  return {
+    ...mapMeshSourceImage(image),
+    ...hasTransform ? {
+      transform: {
+        offset: transform.offset,
+        rotation: transform.rotation,
+        scale: transform.scale
+      }
+    } : {},
+    ...selectedSampler && Object.values(selectedSampler).some((value) => value !== void 0) ? { sampler: selectedSampler } : {}
+  };
+}
+function mapMeshSourceImage(image) {
+  if (image.uri === void 0) {
+    return { data: image.bufferView.data, mimeType: image.mimeType };
+  }
+  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(
+      "MESH_SOURCE_TEXTURE_UNSUPPORTED",
+      "Inline images require a PNG/JPEG base64 data URI and matching optional mimeType"
+    );
+  }
+  let encodedBytes;
+  try {
+    encodedBytes = atob(match[2]);
+  } catch {
+    throw new TileConversionError9("MESH_SOURCE_TEXTURE_UNSUPPORTED", "Invalid inline image base64");
+  }
+  return {
+    data: Uint8Array.from(encodedBytes, (character) => character.charCodeAt(0)),
+    mimeType: match[1]
+  };
+}
+
+// src/v5/mesh-source-features.ts
+import { TileConversionError as TileConversionError10 } 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(
+        "MESH_FEATURE_MAPPING_REQUIRED",
+        "Feature attributes require an EXT_mesh_features declaration"
+      );
+    return void 0;
+  }
+  if (!options)
+    throw new TileConversionError10(
+      "MESH_FEATURE_SCHEMA_REQUIRED",
+      "Feature extraction requires an explicit Arrow schema and class mapping"
+    );
+  if (!options.metadataClass)
+    throw new TileConversionError10(
+      "MESH_FEATURE_CLASS_REQUIRED",
+      "Feature metadata class must be explicit"
+    );
+  let count;
+  let attribute = legacy;
+  let properties;
+  if (declarations) {
+    if (legacy || declarations.length !== 1 || metadata?.propertyTables?.length !== 1 || metadata.propertyTextures?.length || metadata.propertyAttributes?.length)
+      throw new TileConversionError10(
+        "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(
+        "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(
+        "MESH_FEATURE_CLASS_MISMATCH",
+        "Feature class and declared table counts must agree"
+      );
+    count = table.count;
+    properties = {};
+    const classProperties = metadata.schema?.classes?.[table.class]?.properties;
+    if (!classProperties)
+      throw new TileConversionError10(
+        "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(
+        "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(
+          "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(
+          "MESH_FEATURE_PROPERTY_UNAVAILABLE",
+          `Property ${name} has not been decoded`
+        );
+      properties[name] = data ?? Array.from({ length: count }, () => property.default);
+    }
+  } else {
+    if (metadata)
+      throw new TileConversionError10(
+        "MESH_FEATURE_MAPPING_UNSUPPORTED",
+        "Structural metadata requires an attribute-backed feature declaration"
+      );
+    count = payload.header?.batchLength ?? Number(payload.featureTableJson?.BATCH_LENGTH);
+    properties = payload.batchTableJson || {};
+  }
+  const vertexCount = mesh.attributes.POSITION.value.length / 3;
+  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(
+      "MESH_FEATURE_IDS_INVALID",
+      "Feature IDs must be one valid property-table row index per vertex"
+    );
+  const selectedAttribute = declarations ? `_FEATURE_ID_${declarations[0].attribute}` : "_BATCHID";
+  if (Object.keys(primitive.attributes).some(
+    (name) => (name === "_BATCHID" || /^_FEATURE_ID_\d+$/.test(name)) && name !== selectedAttribute
+  ))
+    throw new TileConversionError10(
+      "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(
+        "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(
+      "MESH_FEATURE_ID_PROPERTY_REQUIRED",
+      "Stable source identifier property is missing"
+    );
+  const batches = convertFeatureAttributesToArrowBatches(
+    Array.from({ length: count }, (_, index) => ({
+      featureId: sourceIdentifier ? properties[sourceIdentifier][index] : index,
+      metadataClass: options.metadataClass,
+      properties: Object.fromEntries(
+        Object.entries(properties).filter(([name]) => name !== sourceIdentifier).map(([name, values]) => [name, values[index]])
+      )
+    })),
+    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]
+    );
+    if (rows.some((row) => row !== rows[0]))
+      throw new TileConversionError10(
+        "MESH_FEATURE_TRIANGLE_MIXED",
+        "All vertices of a triangle must reference the same feature row"
+      );
+    triangleFeatureIndices[triangle] = Number(rows[0]);
+  }
+  return {
+    batches,
+    triangleFeatureIndices,
+    featureIdField: options.featureIdField || "feature_id",
+    integer64Encoding: options.integer64Encoding
+  };
+}
+
+// src/v5/mesh-source.ts
+function createMeshTilesetConversionSource(tileset, options = {}) {
+  const source = createTilesetConversionSource(tileset, options);
+  return {
+    /** Validates the source frame and supported dataset metadata before traversal. */
+    async inspect(signal) {
+      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(
+          "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(
+          "MESH_SOURCE_METADATA_UNSUPPORTED",
+          "Tileset/group metadata requires a separate mapping"
+        );
+      }
+      return metadata;
+    },
+    /** Yields each primitive placement while the shared traversal owns content lifetime. */
+    async *read(inspection, signal) {
+      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(
+            "MESH_SOURCE_FRAME_UNSUPPORTED",
+            "Nested mesh placements require native ECEF coordinates"
+          );
+        if (item.tile.header.metadata || item.tile.header.implicitMetadata)
+          throw new TileConversionError11(
+            "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(
+              "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(
+              "MESH_SOURCE_CONTENT_UNSUPPORTED",
+              "Mesh extraction requires decoded GLB/glTF or B3DM content"
+            );
+          }
+          const gltf = payload.gltf;
+          if (gltf.animations?.length || gltf.skins?.length || Object.keys(gltf.extensions || {}).some(
+            (name) => !["EXT_structural_metadata", "CESIUM_RTC"].includes(name)
+          )) {
+            throw new TileConversionError11(
+              "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);
+          const rtc = payload.rtcCenter || gltf.extensions?.CESIUM_RTC?.center;
+          if (rtc) {
+            if (rtc.length !== 3 || rtc.some((value) => !Number.isFinite(value)))
+              throw new TileConversionError11(
+                "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]));
+          if (axis === "X")
+            placement.multiplyRight(new Matrix4([0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]));
+          const roots = gltf.scene?.nodes || (gltf.scenes?.length === 1 ? gltf.scenes[0].nodes : void 0);
+          if (!roots?.length)
+            throw new TileConversionError11(
+              "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(
+              selected.primitive,
+              selected.transform,
+              `${item.tile.id}/${content.index}/${primitiveIndex++}`
+            );
+            const features = extractMeshFeatures(
+              gltf,
+              selected.primitive,
+              payload,
+              resource.mesh,
+              options.features
+            );
+            yield { ...resource, features };
+          }
+          if (!primitiveIndex)
+            throw new TileConversionError11(
+              "MESH_SOURCE_CONTENT_EMPTY",
+              "Declared content contains no supported mesh primitive"
+            );
+        }
+      }
+    }
+  };
+}
+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(
+        "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])
+    );
+    if (node.mesh) {
+      if (node.mesh.weights || Object.keys(node.mesh.extensions || {}).length)
+        throw new TileConversionError11(
+          "MESH_SOURCE_NODE_UNSUPPORTED",
+          "Morph weights and mesh extensions are unsupported"
+        );
+      for (const primitive of node.mesh.primitives) yield { primitive, transform };
+    }
+    yield* traverseMeshNodes(node.children || [], transform, /* @__PURE__ */ new Set([...ancestors, node]));
+  }
+}
+function extractPrimitive(primitive, transform, id) {
+  if (primitive.targets?.length || Object.keys(primitive.extensions || {}).some((name) => name !== "EXT_mesh_features"))
+    throw new TileConversionError11(
+      "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(
+      "MESH_SOURCE_TRANSFORM_INVALID",
+      "Mesh placement requires a finite invertible affine transform with positive determinant"
+    );
+  const attributes = {};
+  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(
+        "MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
+        `Unsupported mesh attribute ${name}`
+      );
+    attributes[name] = {
+      value: accessor.value,
+      size: accessor.components,
+      ...accessor.normalized ? { normalized: true } : {}
+    };
+  }
+  const mesh = validateMeshGeometry(
+    {
+      topology: "triangle-list",
+      mode: primitive.mode ?? 4,
+      attributes,
+      indices: primitive.indices ? { value: primitive.indices.value, size: 1 } : void 0
+    },
+    true
+  );
+  const sourcePositions = mesh.attributes.POSITION.value;
+  const positions = new Float64Array(sourcePositions.length);
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (let index = 0; index < positions.length; index += 3) {
+    const placed = transform.transformAsPoint(
+      Array.from(sourcePositions.subarray(index, index + 3))
+    );
+    positions.set(placed, index);
+    for (let axis = 0; axis < 3; axis++) {
+      minimum[axis] = Math.min(minimum[axis], placed[axis]);
+      maximum[axis] = Math.max(maximum[axis], placed[axis]);
+    }
+  }
+  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 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)));
+      const length = Math.hypot(...normal);
+      normals.set(
+        normal.map((value) => value / length),
+        index
+      );
+    }
+    mesh.attributes.NORMAL = { value: normals, size: 3 };
+  }
+  return {
+    id,
+    mesh,
+    origin: minimum.map((value, axis) => value / 2 + maximum[axis] / 2),
+    material: mapMaterial(primitive.material)
+  };
+}
+function mapMaterial(material) {
+  if (!material) return void 0;
+  const pbr = material.pbrMetallicRoughness;
+  if (Object.keys(material).some(
+    (name) => ![
+      "id",
+      "name",
+      "pbrMetallicRoughness",
+      "alphaMode",
+      "alphaCutoff",
+      "doubleSided",
+      "emissiveFactor",
+      "extras"
+    ].includes(name)
+  ) || Object.keys(pbr || {}).some(
+    (name) => !["baseColorFactor", "baseColorTexture", "metallicFactor", "roughnessFactor"].includes(name)
+  ) || material.emissiveFactor?.some((value) => value !== 0))
+    throw new TileConversionError11(
+      "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) } : {},
+    metallicFactor: pbr?.metallicFactor,
+    roughnessFactor: pbr?.roughnessFactor,
+    alphaMode: material.alphaMode,
+    ...material.alphaMode === "MASK" ? { alphaCutoff: material.alphaCutoff ?? 0.5 } : {},
+    doubleSided: material.doubleSided
+  };
+}
+
+// src/v5/i3s-mesh-conversion.ts
+import { encodeI3SMeshLayer } from "@loaders.gl/i3s";
+import { TileConversionError as TileConversionError12 } 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(
+      "I3S_MESH_FRAME_UNSUPPORTED",
+      "I3S mesh authoring requires resolved ECEF coordinates and ellipsoidal heights"
+    );
+  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
+      };
+      if (mesh.attributes.NORMAL)
+        mesh.attributes.NORMAL = {
+          value: options.spatialContext.transformNormals(mesh.attributes.NORMAL.value, positions),
+          size: 3
+        };
+      let layer;
+      try {
+        layer = encodeI3SMeshLayer(mesh, {
+          ...options,
+          material: resource.material,
+          features: resource.features
+        });
+      } catch (error) {
+        throw new TileConversionError12(
+          "I3S_MESH_PROFILE_UNSUPPORTED",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      signal?.throwIfAborted();
+      yield { id: resource.id, ...layer };
+    },
+    /** Reports measured precision and explicitly authorized integer representation changes. */
+    async validateOutput(resource) {
+      return [
+        ...resource.maximumPositionError > 0 ? [
+          {
+            code: "I3S_MESH_POSITION_ROUNDING",
+            message: `I3S positions have up to ${resource.maximumPositionError} meters reconstruction error`,
+            severity: "info",
+            resourceId: resource.id
+          }
+        ] : [],
+        ...resource.decimalStringFields.map((field) => ({
+          code: "I3S_INTEGER_DECIMAL_STRING",
+          message: `Explicitly represented 64-bit integer field ${field} as exact decimal text`,
+          severity: "info",
+          resourceId: resource.id
+        }))
+      ];
+    }
+  };
+}
+function createSingleMeshI3SSink(options) {
+  const memory = createBoundedMemoryTileConversionSink2(options);
+  let state = "empty";
+  let completed = false;
+  return {
+    /** Exposes resources only after successful finalization. */
+    getFiles: () => completed ? memory.getFiles() : [],
+    /** Writes exactly one layer within the retained-resource budget. */
+    async write(resource, signal) {
+      signal?.throwIfAborted();
+      if (state !== "empty")
+        throw new TileConversionError12(
+          "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);
+      state = "written";
+    },
+    /** Commits a complete single-layer result. */
+    async finalize(report) {
+      if (state !== "written")
+        throw new TileConversionError12(
+          "SINGLE_I3S_MESH_INCOMPLETE",
+          "Finalization requires exactly one successfully written layer"
+        );
+      await memory.finalize(report);
+      state = "closed";
+      completed = true;
+    },
+    /** Discards all resources after any conversion failure. */
+    async abort(error) {
+      completed = false;
+      state = "closed";
+      await memory.abort(error);
+    }
+  };
+}
+export {
+  convertFeatureAttributesToArrowBatches,
+  convertPointCloudSource,
+  createI3SMeshConversionCodec,
+  createMeshConversionCodec,
+  createMeshTilesetConversionSource,
+  createMeshTilesetSink,
+  createSingleMeshI3SSink,
+  createSingleMeshTilesetArchive,
+  createSingleMeshTilesetSink,
+  createTileConversionArchive,
+  encodeMeshTile,
+  encodePointCloudSource,
+  encodePointCloudSourceTile,
+  encodePointCloudTile,
+  encodeTileConversionArchiveInBatches
+};