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

package/dist/v5/adapters.cjs

@@ -20,32 +20,49 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/v5/adapters.ts
 var adapters_exports = {};
 __export(adapters_exports, {
+  SELECTED_MESH_LIMITS: () => SELECTED_MESH_LIMITS,
   convertFeatureAttributesToArrowBatches: () => convertFeatureAttributesToArrowBatches,
   convertPointCloudSource: () => convertPointCloudSource,
+  convertPointCloudToPotree: () => convertPointCloudToPotree,
+  convertPointCloudToTileset: () => convertPointCloudToTileset,
+  createCOPCConversionCodec: () => createCOPCConversionCodec,
   createI3SMeshConversionCodec: () => createI3SMeshConversionCodec,
   createI3SMeshSink: () => createI3SMeshSink,
   createI3SMeshTilesetConversionSource: () => createI3SMeshTilesetConversionSource,
   createMeshConversionCodec: () => createMeshConversionCodec,
+  createMeshHierarchyTilesetSink: () => createMeshHierarchyTilesetSink,
+  createMeshSourceFeatureOptions: () => createMeshSourceFeatureOptions,
   createMeshTilesetConversionSource: () => createMeshTilesetConversionSource,
   createMeshTilesetSink: () => createMeshTilesetSink,
   createPointCloudTilesetSink: () => createPointCloudTilesetSink,
+  createSelectedI3SMeshConversionSource: () => createSelectedI3SMeshConversionSource,
+  createSelectedMeshConversionSource: () => createSelectedMeshConversionSource,
   createSingleMeshI3SSink: () => createSingleMeshI3SSink,
   createSingleMeshTilesetArchive: () => createSingleMeshTilesetArchive,
   createSingleMeshTilesetSink: () => createSingleMeshTilesetSink,
   createTileConversionArchive: () => createTileConversionArchive,
+  createTileConversionArchiveTransport: () => createTileConversionArchiveTransport,
   createTileConversionResourceFetcher: () => createTileConversionResourceFetcher,
   encodeMeshTile: () => encodeMeshTile,
+  encodePointCloudCOPC: () => encodePointCloudCOPC,
   encodePointCloudSource: () => encodePointCloudSource,
   encodePointCloudSourceTile: () => encodePointCloudSourceTile,
   encodePointCloudTile: () => encodePointCloudTile,
   encodePointCloudTileWithMetadata: () => encodePointCloudTileWithMetadata,
+  encodePotreeArchive: () => encodePotreeArchive,
   encodeTileConversionArchiveInBatches: () => encodeTileConversionArchiveInBatches,
+  extractMeshVertices: () => extractMeshVertices,
+  inspectI3SMeshConversionSource: () => inspectI3SMeshConversionSource,
+  mapPointCloudAttributes: () => mapPointCloudAttributes,
+  measureMeshBytes: () => measureMeshBytes,
+  openPointCloudFile: () => openPointCloudFile,
+  openTileConversionArchive: () => openTileConversionArchive,
   transformPointCloudSourceTile: () => transformPointCloudSourceTile
 });
 module.exports = __toCommonJS(adapters_exports);
 
 // src/v5/feature-arrow.ts
-var import_schema_utils = require("@loaders.gl/schema-utils");
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
 var import_core = require("@loaders.gl/tile-converter/v5/core");
 var DEFAULT_FEATURE_ID_FIELD = "feature_id";
 var FEATURE_CLASS_METADATA_KEY = "loaders.gl:feature-class";
@@ -367,8 +384,8 @@ function isBinaryType(dataType) {
 }
 
 // src/v5/point-cloud.ts
-var import_d_tiles = require("@loaders.gl/3d-tiles");
-var import_schema_utils2 = require("@loaders.gl/schema-utils");
+var import_d_tiles = require("@loaders.gl/tiles-3d/3d-tiles");
+var import_schema_utils2 = require("@loaders.gl/core/schema-utils");
 var import_core2 = require("@loaders.gl/tile-converter/v5/core");
 function encodePointCloudTile(pointBatch, options = {}) {
   return encodePointCloudTileWithMetadata(pointBatch, options).pnts;
@@ -631,8 +648,8 @@ function validateBatchTable(batchTableJson, batchIds) {
 
 // src/v5/point-cloud-spatial.ts
 var import_core3 = require("@math.gl/core");
-var import_tiles = require("@loaders.gl/tiles");
-var import_schema_utils3 = require("@loaders.gl/schema-utils");
+var import_tiles_3d = require("@loaders.gl/tiles-3d");
+var import_schema_utils3 = require("@loaders.gl/core/schema-utils");
 var import_core4 = require("@loaders.gl/tile-converter/v5/core");
 async function transformPointCloudSourceTile(sourceTile, options) {
   options.signal?.throwIfAborted();
@@ -641,7 +658,7 @@ async function transformPointCloudSourceTile(sourceTile, options) {
   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 ? (0, import_tiles.createTilesetSpatialReference)({
+  const sourceReference = retainTransformedEcef ? (0, import_tiles_3d.createTilesetSpatialReference)({
     sourceCrs: "EPSG:4978",
     coordinateFrame: "geocentric",
     axisOrder: "xyz",
@@ -655,7 +672,7 @@ async function transformPointCloudSourceTile(sourceTile, options) {
       "Point content and context must agree on the input CRS, units, height reference and epoch"
     );
   }
-  const sourceFrame = reference.coordinateFrame === "unknown" && reference.sourceCrs ? (0, import_tiles.getSpatialCoordinateFrame)(reference.sourceCrs) : reference.coordinateFrame;
+  const sourceFrame = reference.coordinateFrame === "unknown" && reference.sourceCrs ? (0, import_tiles_3d.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 import_core4.TileConversionError(
@@ -766,7 +783,7 @@ async function transformPointCloudSourceTile(sourceTile, options) {
     maximum[axis] = Math.max(maximum[axis], value);
   }
   const center = minimum.map((value, axis) => value / 2 + maximum[axis] / 2);
-  const targetFrame = reference.status === "native" ? sourceFrame : (0, import_tiles.getSpatialCoordinateFrame)(reference.targetCrs || reference.sourceCrs);
+  const targetFrame = reference.status === "native" ? sourceFrame : (0, import_tiles_3d.getSpatialCoordinateFrame)(reference.targetCrs || reference.sourceCrs);
   const targetIsGeographic = targetFrame === "geographic";
   const attributes = {
     ...mesh.attributes,
@@ -890,7 +907,7 @@ var import_gltf = require("@loaders.gl/gltf");
 var import_images = require("@loaders.gl/images");
 
 // src/v5/mesh-features.ts
-var import_schema_utils4 = require("@loaders.gl/schema-utils");
+var import_schema_utils4 = require("@loaders.gl/core/schema-utils");
 var import_core8 = require("@loaders.gl/tile-converter/v5/core");
 function prepareMeshFeatureGeometry(mesh, features) {
   if (!features) return mesh;
@@ -1444,7 +1461,7 @@ function validateMeshTextureTransform(transform) {
 }
 
 // src/v5/mesh-conversion.ts
-var import_tiles2 = require("@loaders.gl/tiles");
+var import_tiles_3d2 = require("@loaders.gl/tiles-3d");
 var import_core11 = require("@loaders.gl/tile-converter/v5/core");
 
 // src/v5/mesh-draco.ts
@@ -1587,7 +1604,7 @@ function createMeshConversionCodec(options) {
   }
   const spatialReference = spatialContext.spatialReference;
   const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
-  const outputFrame = spatialReference.status === "native" ? spatialReference.coordinateFrame : outputCrs ? (0, import_tiles2.getSpatialCoordinateFrame)(outputCrs) : "unknown";
+  const outputFrame = spatialReference.status === "native" ? spatialReference.coordinateFrame : outputCrs ? (0, import_tiles_3d2.getSpatialCoordinateFrame)(outputCrs) : "unknown";
   if (!["native", "transformed"].includes(spatialReference.status) || !["projected", "geocentric", "local", "cartesian"].includes(outputFrame)) {
     throw new import_core11.TileConversionError(
       "MESH_OUTPUT_FRAME_UNSUPPORTED",
@@ -1676,6 +1693,8 @@ function createMeshConversionCodec(options) {
       }
       yield {
         id: resource.id,
+        contentResourceId: resource.contentResourceId,
+        contentPrimitive: resource.contentPrimitive,
         glb: encoded.glb,
         origin,
         boundingBox: [minimum, maximum],
@@ -1929,8 +1948,8 @@ function createMeshTilesetSink(options) {
 }
 
 // src/v5/conversion-archive.ts
-var import_d_tiles_archive_writer = require("@loaders.gl/3d-tiles/3d-tiles-archive-writer");
-var import_i3s_slpk_writer = require("@loaders.gl/i3s/i3s-slpk-writer");
+var import_d_tiles_archive_writer = require("@loaders.gl/tiles-3d/3d-tiles/3d-tiles-archive-writer");
+var import_i3s_slpk_writer = require("@loaders.gl/tiles-3d/i3s/i3s-slpk-writer");
 var import_core14 = require("@loaders.gl/tile-converter/v5/core");
 async function createTileConversionArchive(files, options) {
   const { resources, format, maxArchiveBytes, signal } = prepareArchiveInput(files, options);
@@ -1965,7 +1984,7 @@ function prepareArchiveInput(files, options) {
 }
 
 // src/v5/mesh-tileset-archive.ts
-var import_d_tiles_archive_writer2 = require("@loaders.gl/3d-tiles/3d-tiles-archive-writer");
+var import_d_tiles_archive_writer2 = require("@loaders.gl/tiles-3d/3d-tiles/3d-tiles-archive-writer");
 var import_core15 = require("@loaders.gl/tile-converter/v5/core");
 async function createSingleMeshTilesetArchive(files, options) {
   const { maxArchiveBytes, signal } = options;
@@ -1987,17 +2006,19 @@ async function createSingleMeshTilesetArchive(files, options) {
 }
 
 // src/v5/mesh-source.ts
-var import_core18 = require("@math.gl/core");
-var import_core19 = require("@loaders.gl/tile-converter/v5/core");
+var import_core19 = require("@math.gl/core");
+var import_gltf4 = require("@loaders.gl/gltf");
 var import_core20 = require("@loaders.gl/tile-converter/v5/core");
+var import_core21 = require("@loaders.gl/tile-converter/v5/core");
 
 // src/v5/mesh-source-texture.ts
 var import_images2 = require("@loaders.gl/images");
+var import_gltf2 = require("@loaders.gl/gltf");
 var import_core16 = require("@loaders.gl/tile-converter/v5/core");
-function mapMeshSourceTexture(textureInfo) {
-  const texture = textureInfo?.texture;
-  const image = texture?.source;
-  const sampler = texture?.sampler;
+function mapMeshSourceTexture(gltf, textureInfo) {
+  const texture = textureInfo ? gltf.json.textures?.[textureInfo.index] : void 0;
+  const image = texture?.source === void 0 ? void 0 : gltf.json.images?.[texture.source];
+  const sampler = texture?.sampler === void 0 ? void 0 : gltf.json.samplers?.[texture.sampler];
   const extensions = textureInfo?.extensions || {};
   const hasTransform = Object.hasOwn(extensions, "KHR_texture_transform");
   const transform = extensions.KHR_texture_transform;
@@ -2007,7 +2028,7 @@ function mapMeshSourceTexture(textureInfo) {
     (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(
+  ) || 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 === void 0 || !gltf.json.bufferViews?.[image.bufferView] || Object.keys(gltf.json.bufferViews?.[image.bufferView]?.extensions || {}).length || !["image/png", "image/jpeg"].includes(image.mimeType || "")) || sampler && (Object.keys(sampler.extensions || {}).length || Object.keys(sampler).some(
     (name) => ![
       "id",
       "parameters",
@@ -2032,7 +2053,7 @@ function mapMeshSourceTexture(textureInfo) {
     minFilter: sampler.minFilter
   } : void 0;
   return {
-    ...mapMeshSourceImage(image),
+    ...mapMeshSourceImage(gltf, image),
     ...hasTransform ? {
       transform: {
         offset: transform.offset,
@@ -2043,9 +2064,12 @@ function mapMeshSourceTexture(textureInfo) {
     ...selectedSampler && Object.values(selectedSampler).some((value) => value !== void 0) ? { sampler: selectedSampler } : {}
   };
 }
-function mapMeshSourceImage(image) {
+function mapMeshSourceImage(gltf, image) {
   if (image.uri === void 0) {
-    return { data: image.bufferView.data, mimeType: image.mimeType };
+    return {
+      data: new import_gltf2.GLTFScenegraph(gltf).getTypedArrayForBufferView(image.bufferView),
+      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]) {
@@ -2065,10 +2089,11 @@ function mapMeshSourceImage(image) {
     mimeType: match[1]
   };
 }
-async function resolveMeshSourceTexture(textureInfo, readExternalResource, contentUri, signal) {
-  const image = textureInfo?.texture?.source;
+async function resolveMeshSourceTexture(gltf, textureInfo, readExternalResource, contentUri, signal) {
+  const texture = textureInfo ? gltf.json.textures?.[textureInfo.index] : void 0;
+  const image = texture?.source === void 0 ? void 0 : gltf.json.images?.[texture.source];
   if (!image || image.uri === void 0 || image.uri.startsWith("data:"))
-    return mapMeshSourceTexture(textureInfo);
+    return mapMeshSourceTexture(gltf, textureInfo);
   if (!readExternalResource || image.bufferView !== void 0)
     throw new import_core16.TileConversionError(
       "MESH_SOURCE_TEXTURE_UNSUPPORTED",
@@ -2087,168 +2112,336 @@ async function resolveMeshSourceTexture(textureInfo, readExternalResource, conte
       "MESH_SOURCE_TEXTURE_UNSUPPORTED",
       "External images require matching PNG/JPEG headers"
     );
+  const resolvedImage = {
+    ...image,
+    uri: void 0,
+    mimeType: metadata.mimeType,
+    bufferView: (gltf.json.bufferViews || []).length
+  };
   const resolved = {
-    ...textureInfo,
-    texture: {
-      ...textureInfo.texture,
-      source: { ...image, uri: void 0, mimeType: metadata.mimeType, bufferView: { data } }
+    ...gltf,
+    buffers: [
+      ...gltf.buffers,
+      {
+        arrayBuffer: data.buffer,
+        byteOffset: data.byteOffset,
+        byteLength: data.byteLength
+      }
+    ],
+    json: {
+      ...gltf.json,
+      images: gltf.json.images.map(
+        (entry, index) => index === texture.source ? resolvedImage : entry
+      ),
+      bufferViews: [
+        ...gltf.json.bufferViews || [],
+        { buffer: gltf.buffers.length, byteLength: data.byteLength }
+      ]
     }
   };
-  return mapMeshSourceTexture(resolved);
+  return mapMeshSourceTexture(resolved, textureInfo);
 }
 
 // src/v5/mesh-source-features.ts
+var import_gltf3 = require("@loaders.gl/gltf");
+
+// src/v5/mesh-source-schema.ts
 var import_core17 = require("@loaders.gl/tile-converter/v5/core");
+var SCALAR_TYPES = {
+  INT8: "int8",
+  UINT8: "uint8",
+  INT16: "int16",
+  UINT16: "uint16",
+  INT32: "int32",
+  UINT32: "uint32",
+  INT64: "int64",
+  UINT64: "uint64",
+  FLOAT32: "float32",
+  FLOAT64: "float64"
+};
+function createMeshSourceFeatureOptions(gltf, options) {
+  const metadata = gltf.extensions?.EXT_structural_metadata;
+  const table = metadata?.propertyTables?.[0];
+  const properties = metadata?.schema?.classes?.[options.metadataClass]?.properties;
+  if (!options.metadataClass || metadata?.propertyTables?.length !== 1 || table?.class !== options.metadataClass || !properties || !Number.isSafeInteger(table.count) || table.count < 1 || table.count > 4294967295 || metadata.propertyTextures?.length || metadata.propertyAttributes?.length) {
+    throw new import_core17.TileConversionError(
+      "MESH_FEATURE_SCHEMA_REQUIRED",
+      "Schema mapping requires one inline class, one matching property table and a positive uint32 row count"
+    );
+  }
+  if (Object.keys(table.properties || {}).some((name) => !Object.hasOwn(properties, name))) {
+    throw new import_core17.TileConversionError(
+      "MESH_FEATURE_PROPERTY_UNMAPPED",
+      "Property table columns must be declared in the selected class"
+    );
+  }
+  const fields = Object.entries(properties).map(([name, property]) => {
+    const declaration = property;
+    const column = table.properties?.[name];
+    if (declaration.array || !["SCALAR", "STRING"].includes(declaration.type) || declaration.normalized || declaration.offset !== void 0 || declaration.scale !== void 0 || column?.offset !== void 0 || column?.scale !== void 0 || declaration.required && (declaration.noData !== void 0 || declaration.default !== void 0)) {
+      throw new import_core17.TileConversionError(
+        "MESH_FEATURE_PROPERTY_UNSUPPORTED",
+        `Property ${name} requires an explicit separately qualified mapping`
+      );
+    }
+    const type = declaration.type === "STRING" ? "utf8" : Object.hasOwn(SCALAR_TYPES, declaration.componentType || "") ? SCALAR_TYPES[declaration.componentType] : void 0;
+    if (!type) {
+      throw new import_core17.TileConversionError(
+        "MESH_FEATURE_PROPERTY_UNSUPPORTED",
+        `Property ${name} has no supported declared scalar width`
+      );
+    }
+    return {
+      name,
+      type,
+      nullable: declaration.required !== true,
+      metadata: { "loaders.gl:structural-property": JSON.stringify(declaration) }
+    };
+  });
+  const identifierName = options.featureIdField || "feature_id";
+  const sourceIdentifier = options.sourceFeatureIdProperty;
+  const sourceField = sourceIdentifier ? fields.find((field) => field.name === sourceIdentifier) : void 0;
+  if (sourceIdentifier && !sourceField || fields.some((field) => field.name === identifierName && field !== sourceField) || sourceField && !["utf8", "int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64"].includes(
+    String(sourceField.type)
+  )) {
+    throw new import_core17.TileConversionError(
+      "MESH_FEATURE_ID_PROPERTY_REQUIRED",
+      "Select a declared string/integer identifier and a distinct output identifier name"
+    );
+  }
+  return {
+    ...options,
+    schema: {
+      fields: [
+        {
+          ...sourceField,
+          name: identifierName,
+          type: sourceField?.type || "uint32",
+          nullable: false
+        },
+        ...fields.filter((field) => field !== sourceField)
+      ],
+      metadata: { "loaders.gl:source-schema": JSON.stringify(metadata.schema) }
+    }
+  };
+}
+
+// src/v5/mesh-source-features.ts
+var import_core18 = require("@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 metadata = gltf.json.extensions?.EXT_structural_metadata;
   const legacy = primitive.attributes._BATCHID;
-  if (!declarations && !legacy && !metadata && !Object.keys(payload.batchTableJson || {}).length && !payload.header?.batchLength) {
+  if (!declarations && legacy === void 0 && !metadata && !Object.keys(payload.batchTableJson || {}).length && !payload.header?.batchLength) {
     if (Object.keys(primitive.attributes).some((name) => /^_FEATURE_ID_\d+$/.test(name)))
-      throw new import_core17.TileConversionError(
+      throw new import_core18.TileConversionError(
         "MESH_FEATURE_MAPPING_REQUIRED",
         "Feature attributes require an EXT_mesh_features declaration"
       );
     return void 0;
   }
   if (!options)
-    throw new import_core17.TileConversionError(
+    throw new import_core18.TileConversionError(
       "MESH_FEATURE_SCHEMA_REQUIRED",
-      "Feature extraction requires an explicit Arrow schema and class mapping"
+      "Feature extraction requires a class selection and a declared Arrow or inline source schema"
     );
   if (!options.metadataClass)
-    throw new import_core17.TileConversionError(
+    throw new import_core18.TileConversionError(
       "MESH_FEATURE_CLASS_REQUIRED",
       "Feature metadata class must be explicit"
     );
+  const mapping = "schema" in options ? options : createMeshSourceFeatureOptions(gltf.json, options);
+  const propertyMappings = /* @__PURE__ */ new Map();
   let count;
-  let attribute = legacy;
+  let attributeReference = legacy;
   let properties;
   if (declarations) {
-    if (legacy || declarations.length !== 1 || metadata?.propertyTables?.length !== 1 || metadata.propertyTextures?.length || metadata.propertyAttributes?.length)
-      throw new import_core17.TileConversionError(
+    if (legacy !== void 0 || declarations.length !== 1 || metadata?.propertyTables?.length !== 1 || metadata.propertyTextures?.length || metadata.propertyAttributes?.length)
+      throw new import_core18.TileConversionError(
         "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 import_core17.TileConversionError(
+    if (typeof declaration.attribute !== "number" || !Number.isInteger(declaration.attribute) || declaration.attribute < 0 || declaration.propertyTable !== 0 || declaration.texture || declaration.implicit || declaration.nullFeatureId !== void 0)
+      throw new import_core18.TileConversionError(
         "MESH_FEATURE_MAPPING_UNSUPPORTED",
         "Features require an attribute and property table 0 without null/texture/implicit IDs"
       );
-    attribute = primitive.attributes[`_FEATURE_ID_${declaration.attribute}`];
+    attributeReference = primitive.attributes[`_FEATURE_ID_${declaration.attribute}`];
     const table = metadata.propertyTables[0];
-    if (table.class !== options.metadataClass || table.count !== declaration.featureCount)
-      throw new import_core17.TileConversionError(
+    if (table.class !== options.metadataClass || !Number.isSafeInteger(declaration.featureCount) || declaration.featureCount <= 0 || declaration.featureCount > table.count)
+      throw new import_core18.TileConversionError(
         "MESH_FEATURE_CLASS_MISMATCH",
-        "Feature class and declared table counts must agree"
+        "Feature class must agree and declared feature count must fit the property table"
       );
     count = table.count;
-    properties = {};
+    if (!Number.isSafeInteger(count) || count <= 0 || count > 4294967295) {
+      throw new import_core18.TileConversionError(
+        "MESH_FEATURE_IDS_INVALID",
+        "Feature row count must fit uint32 indices"
+      );
+    }
+    properties = /* @__PURE__ */ Object.create(null);
     const classProperties = metadata.schema?.classes?.[table.class]?.properties;
     if (!classProperties)
-      throw new import_core17.TileConversionError(
+      throw new import_core18.TileConversionError(
         "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 import_core17.TileConversionError(
+      throw new import_core18.TileConversionError(
         "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 && (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 import_core17.TileConversionError(
+        throw new import_core18.TileConversionError(
           "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 import_core17.TileConversionError(
+      if (column !== void 0 && (data === void 0 || data === null) || data === void 0 && property.required === true)
+        throw new import_core18.TileConversionError(
           "MESH_FEATURE_PROPERTY_UNAVAILABLE",
           `Property ${name} has not been decoded`
         );
-      const decoded = data ?? Array.from({ length: count }, () => property.default);
+      const integer64 = ["INT64", "UINT64"].includes(property.componentType || "");
+      if (integer64 && property.default !== void 0 && (typeof property.default !== "number" || !Number.isSafeInteger(property.default))) {
+        throw new import_core18.TileConversionError(
+          "MESH_FEATURE_PROPERTY_UNSUPPORTED",
+          `Property ${name} requires an exact 64-bit default`
+        );
+      }
+      const defaultValue = integer64 && property.default !== void 0 ? BigInt(property.default) : property.default ?? null;
+      const decoded = data;
       if (property.noData === void 0 || data === void 0) {
-        properties[name] = decoded;
+        if (decoded !== void 0) properties[name] = decoded;
+        else propertyMappings.set(name, { defaultValue });
         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 import_core17.TileConversionError(
+        throw new import_core18.TileConversionError(
           "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
-      );
+      const values = decoded;
+      properties[name] = values;
+      propertyMappings.set(name, { noData: comparable, defaultValue });
     }
   } else {
     if (metadata)
-      throw new import_core17.TileConversionError(
+      throw new import_core18.TileConversionError(
         "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 accessor = attributeReference === void 0 ? void 0 : (0, import_gltf3.getGLTFAccessor)(gltf, attributeReference);
+  const attribute = accessor ? {
+    ...accessor,
+    components: accessor.type === "SCALAR" ? 1 : Number(accessor.type.slice(3)),
+    value: (0, import_gltf3.getGLTFAccessorValue)(gltf, accessor)
+  } : void 0;
   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 import_core17.TileConversionError(
+  if (!Number.isSafeInteger(count) || count <= 0 || !attribute || attribute.components !== 1 || attribute.normalized || attribute.value.length !== vertexCount)
+    throw new import_core18.TileConversionError(
       "MESH_FEATURE_IDS_INVALID",
       "Feature IDs must be one valid property-table row index per vertex"
     );
+  const vertexRows = declarations ? /* @__PURE__ */ new Set() : void 0;
+  for (const value of attribute.value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value >= count)
+      throw new import_core18.TileConversionError(
+        "MESH_FEATURE_IDS_INVALID",
+        "Feature IDs must reference valid property-table rows"
+      );
+    vertexRows?.add(Number(value));
+  }
+  if (declarations && vertexRows.size !== declarations[0].featureCount)
+    throw new import_core18.TileConversionError(
+      "MESH_FEATURE_IDS_INVALID",
+      "Declared feature count must match distinct vertex feature IDs"
+    );
   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 import_core17.TileConversionError(
+    throw new import_core18.TileConversionError(
       "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 import_core17.TileConversionError(
+      throw new import_core18.TileConversionError(
         "MESH_FEATURE_PROPERTY_UNAVAILABLE",
-        `Property ${name} must be a decoded column matching the table count`
+        `Property ${name} must be a decoded column matching the feature row count`
       );
   }
   const sourceIdentifier = options.sourceFeatureIdProperty;
-  if (sourceIdentifier && !properties[sourceIdentifier])
-    throw new import_core17.TileConversionError(
+  if (sourceIdentifier && !properties[sourceIdentifier] && !propertyMappings.has(sourceIdentifier))
+    throw new import_core18.TileConversionError(
       "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 corners = [0, 1, 2].map(
-      (corner) => indices?.[triangle * 3 + corner] ?? triangle * 3 + corner
+  const cornerCount = indices?.length ?? vertexCount;
+  if (cornerCount % 3)
+    throw new import_core18.TileConversionError(
+      "MESH_FEATURE_IDS_INVALID",
+      "Triangle geometry requires complete triples"
     );
-    const rows = corners.map((corner) => attribute.value[corner]);
-    if (rows.some((row) => row !== rows[0]) && new Set(corners).size === 3)
-      throw new import_core17.TileConversionError(
+  const triangleFeatureIndices = new Uint32Array(cornerCount / 3);
+  const referencedRows = /* @__PURE__ */ new Set();
+  const readFeatureRow = (corner) => {
+    if (!Number.isSafeInteger(corner) || corner < 0 || corner >= vertexCount)
+      throw new import_core18.TileConversionError(
+        "MESH_FEATURE_IDS_INVALID",
+        "Triangle indices must reference valid mesh vertices"
+      );
+    return Number(attribute.value[corner]);
+  };
+  for (let triangle = 0; triangle < triangleFeatureIndices.length; triangle++) {
+    const firstCorner = indices?.[triangle * 3] ?? triangle * 3;
+    const secondCorner = indices?.[triangle * 3 + 1] ?? triangle * 3 + 1;
+    const thirdCorner = indices?.[triangle * 3 + 2] ?? triangle * 3 + 2;
+    const firstRow = readFeatureRow(firstCorner);
+    const secondRow = readFeatureRow(secondCorner);
+    const thirdRow = readFeatureRow(thirdCorner);
+    if ((firstRow !== secondRow || firstRow !== thirdRow) && firstCorner !== secondCorner && firstCorner !== thirdCorner && secondCorner !== thirdCorner)
+      throw new import_core18.TileConversionError(
         "MESH_FEATURE_TRIANGLE_MIXED",
         "All vertices of a nondegenerate triangle must reference the same feature row"
       );
-    triangleFeatureIndices[triangle] = Number(rows[0]);
+    triangleFeatureIndices[triangle] = firstRow;
+    referencedRows.add(firstRow);
   }
+  const selectedRows = [...referencedRows].sort((left, right) => left - right);
+  const denseRows = new Map(selectedRows.map((row, index) => [row, index]));
+  for (let triangle = 0; triangle < triangleFeatureIndices.length; triangle++) {
+    triangleFeatureIndices[triangle] = denseRows.get(triangleFeatureIndices[triangle]);
+  }
+  const readProperty = (name, row) => {
+    const values = properties[name];
+    const propertyMapping = propertyMappings.get(name);
+    if (!values) return propertyMapping?.defaultValue;
+    const value = values[row];
+    return propertyMapping && value === propertyMapping.noData ? propertyMapping.defaultValue : value;
+  };
+  const propertyNames = [
+    .../* @__PURE__ */ new Set([...Object.keys(properties), ...propertyMappings.keys()])
+  ].filter((name) => name !== sourceIdentifier);
+  const batches = convertFeatureAttributesToArrowBatches(
+    selectedRows.map((row) => ({
+      featureId: sourceIdentifier ? readProperty(sourceIdentifier, row) : row,
+      metadataClass: options.metadataClass,
+      properties: Object.fromEntries(propertyNames.map((name) => [name, readProperty(name, row)]))
+    })),
+    mapping
+  );
   return {
     batches,
     triangleFeatureIndices,
@@ -2259,20 +2452,20 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
 
 // src/v5/mesh-source.ts
 function createMeshTilesetConversionSource(tileset, options = {}) {
-  const source = (0, import_core20.createTilesetConversionSource)(tileset, options);
+  const source = (0, import_core21.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 import_core19.TileConversionError(
+        throw new import_core20.TileConversionError(
           "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 import_core19.TileConversionError(
+        throw new import_core20.TileConversionError(
           "MESH_SOURCE_METADATA_UNSUPPORTED",
           "Tileset/group metadata requires a separate mapping"
         );
@@ -2284,64 +2477,70 @@ 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 import_core19.TileConversionError(
+          throw new import_core20.TileConversionError(
             "MESH_SOURCE_FRAME_UNSUPPORTED",
             "Nested mesh placements require native ECEF coordinates"
           );
         if (item.tile.header.metadata || item.tile.header.implicitMetadata)
-          throw new import_core19.TileConversionError(
+          throw new import_core20.TileConversionError(
             "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 import_core19.TileConversionError(
+            throw new import_core20.TileConversionError(
               "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 import_core19.TileConversionError(
+            throw new import_core20.TileConversionError(
               "MESH_SOURCE_CONTENT_UNSUPPORTED",
               "Mesh extraction requires decoded GLB/glTF or B3DM content"
             );
           }
-          const gltf = payload.gltf;
+          const gltfWithBuffers = payload.gltf;
+          const gltf = gltfWithBuffers.json;
           if (gltf.animations?.length || gltf.skins?.length || Object.keys(gltf.extensions || {}).some(
             (name) => !["EXT_structural_metadata", "CESIUM_RTC"].includes(name)
           )) {
-            throw new import_core19.TileConversionError(
+            throw new import_core20.TileConversionError(
               "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 import_core19.TileConversionError("MESH_SOURCE_AXIS_UNSUPPORTED", "Unknown glTF up axis");
-          const placement = new import_core18.Matrix4(item.tile.computedTransform);
+            throw new import_core20.TileConversionError("MESH_SOURCE_AXIS_UNSUPPORTED", "Unknown glTF up axis");
+          const placement = new import_core19.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 import_core19.TileConversionError(
+              throw new import_core20.TileConversionError(
                 "MESH_SOURCE_TRANSFORM_INVALID",
                 "RTC center must contain finite xyz coordinates"
               );
             placement.translate(rtc);
           }
           if (axis === "Y")
-            placement.multiplyRight(new import_core18.Matrix4([1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]));
+            placement.multiplyRight(new import_core19.Matrix4([1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]));
           if (axis === "X")
-            placement.multiplyRight(new import_core18.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);
+            placement.multiplyRight(new import_core19.Matrix4([0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]));
+          const roots = (gltf.scene !== void 0 ? gltf.scenes?.[gltf.scene]?.nodes : void 0) || (gltf.scenes?.length === 1 ? gltf.scenes[0].nodes : void 0);
           if (!roots?.length)
-            throw new import_core19.TileConversionError(
+            throw new import_core20.TileConversionError(
               "MESH_SOURCE_SCENE_UNSUPPORTED",
               "A default scene or exactly one scene is required"
             );
           let primitiveIndex = 0;
-          for (const selected of traverseMeshNodes(roots, placement)) {
+          const primitives = traverseMeshNodes(gltfWithBuffers, roots, placement);
+          let current = primitives.next();
+          while (!current.done) {
+            const selected = current.value;
+            const next = primitives.next();
             const resource = await extractPrimitive(
+              gltfWithBuffers,
               selected.primitive,
               selected.transform,
               `${item.tile.id}/${content.index}/${primitiveIndex++}`,
@@ -2350,16 +2549,21 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
               signal
             );
             const features = extractMeshFeatures(
-              gltf,
+              gltfWithBuffers,
               selected.primitive,
               payload,
               resource.mesh,
               options.features
             );
-            yield { ...resource, features };
+            yield {
+              ...resource,
+              features,
+              contentPrimitive: { index: primitiveIndex - 1, last: Boolean(next.done) }
+            };
+            current = next;
           }
           if (!primitiveIndex)
-            throw new import_core19.TileConversionError(
+            throw new import_core20.TileConversionError(
               "MESH_SOURCE_CONTENT_EMPTY",
               "Declared content contains no supported mesh primitive"
             );
@@ -2368,58 +2572,66 @@ 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 import_core19.TileConversionError(
+function* traverseMeshNodes(gltf, nodes, parent, ancestors = /* @__PURE__ */ new Set()) {
+  for (const nodeIndex of nodes) {
+    const node = gltf.json.nodes[nodeIndex];
+    if (!node || ancestors.has(nodeIndex) || node.skin !== void 0 || node.weights || Object.keys(node.extensions || {}).length)
+      throw new import_core20.TileConversionError(
         "MESH_SOURCE_NODE_UNSUPPORTED",
         "Cyclic, skinned, morphed, or extended nodes are unsupported"
       );
-    const transform = new import_core18.Matrix4(parent).multiplyRight(
-      node.matrix ? new import_core18.Matrix4(node.matrix) : new import_core18.Matrix4().translate(node.translation || [0, 0, 0]).multiplyRight(new import_core18.Matrix4().fromQuaternion(node.rotation || [0, 0, 0, 1])).scale(node.scale || [1, 1, 1])
+    const transform = new import_core19.Matrix4(parent).multiplyRight(
+      node.matrix ? new import_core19.Matrix4(node.matrix) : new import_core19.Matrix4().translate(node.translation || [0, 0, 0]).multiplyRight(new import_core19.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 import_core19.TileConversionError(
+    if (node.mesh !== void 0) {
+      const mesh = gltf.json.meshes[node.mesh];
+      if (mesh.weights || Object.keys(mesh.extensions || {}).length)
+        throw new import_core20.TileConversionError(
           "MESH_SOURCE_NODE_UNSUPPORTED",
           "Morph weights and mesh extensions are unsupported"
         );
-      for (const primitive of node.mesh.primitives) yield { primitive, transform };
+      for (const primitive of mesh.primitives) yield { primitive, transform };
     }
-    yield* traverseMeshNodes(node.children || [], transform, /* @__PURE__ */ new Set([...ancestors, node]));
+    yield* traverseMeshNodes(
+      gltf,
+      node.children || [],
+      transform,
+      /* @__PURE__ */ new Set([...ancestors, nodeIndex])
+    );
   }
 }
-async function extractPrimitive(primitive, transform, id, readExternalResource, contentUri, signal) {
+async function extractPrimitive(gltf, primitive, transform, id, readExternalResource, contentUri, signal) {
   if (primitive.targets?.length || Object.keys(primitive.extensions || {}).some((name) => name !== "EXT_mesh_features"))
-    throw new import_core19.TileConversionError(
+    throw new import_core20.TileConversionError(
       "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 import_core19.TileConversionError(
+    throw new import_core20.TileConversionError(
       "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)) {
+  for (const [name, reference] of Object.entries(primitive.attributes)) {
+    const accessor = (0, import_gltf4.getGLTFAccessor)(gltf, reference);
     if (name === "_BATCHID" || /^_FEATURE_ID_\d+$/.test(name)) continue;
     if (!["POSITION", "NORMAL", "COLOR_0", "TEXCOORD_0"].includes(name))
-      throw new import_core19.TileConversionError(
+      throw new import_core20.TileConversionError(
         "MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
         `Unsupported mesh attribute ${name}`
       );
     attributes[name] = {
-      value: accessor.value,
-      size: accessor.components,
+      value: (0, import_gltf4.getGLTFAccessorValue)(gltf, reference),
+      size: accessor.type === "SCALAR" ? 1 : Number(accessor.type.slice(3)),
       ...accessor.normalized ? { normalized: true } : {}
     };
   }
   const mesh = validateMeshGeometry(
     {
       topology: "triangle-list",
-      mode: primitive.mode === 5 ? 4 : primitive.mode ?? 4,
+      mode: [5, 6].includes(primitive.mode ?? 4) ? 4 : primitive.mode ?? 4,
       attributes,
-      indices: createTriangleIndices(primitive, (attributes.POSITION?.value.length ?? 0) / 3)
+      indices: createTriangleIndices(gltf, primitive, (attributes.POSITION?.value.length ?? 0) / 3)
     },
     true
   );
@@ -2440,7 +2652,7 @@ async function extractPrimitive(primitive, transform, id, readExternalResource,
   mesh.attributes.POSITION = { value: positions, size: 3 };
   if (mesh.attributes.NORMAL) {
     const values = mesh.attributes.NORMAL.value;
-    const normalMatrix = new import_core18.Matrix4(transform).invert().transpose();
+    const normalMatrix = new import_core19.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)));
@@ -2457,14 +2669,15 @@ async function extractPrimitive(primitive, transform, id, readExternalResource,
     mesh,
     origin: minimum.map((value, axis) => value / 2 + maximum[axis] / 2),
     material: await mapMeshSourceMaterial(
-      primitive.material,
+      primitive.material === void 0 ? void 0 : gltf.json.materials?.[primitive.material],
       readExternalResource,
       contentUri,
-      signal
+      signal,
+      gltf
     )
   };
 }
-async function mapMeshSourceMaterial(material, readExternalResource, contentUri, signal) {
+async function mapMeshSourceMaterial(material, readExternalResource, contentUri, signal, gltf) {
   if (!material) return void 0;
   const pbr = material.pbrMetallicRoughness;
   if (Object.entries(material).some(
@@ -2481,7 +2694,7 @@ async function mapMeshSourceMaterial(material, readExternalResource, contentUri,
   ) || Object.entries(pbr || {}).some(
     ([name, value]) => value !== void 0 && !["baseColorFactor", "baseColorTexture", "metallicFactor", "roughnessFactor"].includes(name)
   ) || material.emissiveFactor?.some((value) => value !== 0))
-    throw new import_core19.TileConversionError(
+    throw new import_core20.TileConversionError(
       "MESH_SOURCE_MATERIAL_UNSUPPORTED",
       "Only metallic-roughness factors and one embedded base-color image are supported"
     );
@@ -2489,6 +2702,7 @@ async function mapMeshSourceMaterial(material, readExternalResource, contentUri,
     baseColorFactor: pbr?.baseColorFactor,
     ..."baseColorTexture" in (pbr || {}) ? {
       baseColorTexture: await resolveMeshSourceTexture(
+        gltf,
         pbr.baseColorTexture,
         readExternalResource,
         contentUri,
@@ -2502,17 +2716,18 @@ async function mapMeshSourceMaterial(material, readExternalResource, contentUri,
     doubleSided: material.doubleSided
   };
 }
-function createTriangleIndices(primitive, vertexCount) {
-  const attribute = primitive.indices ? {
-    value: primitive.indices.value,
-    size: primitive.indices.components,
-    normalized: primitive.indices.normalized
+function createTriangleIndices(gltf, primitive, vertexCount) {
+  const accessor = primitive.indices === void 0 ? void 0 : (0, import_gltf4.getGLTFAccessor)(gltf, primitive.indices);
+  const attribute = accessor ? {
+    value: (0, import_gltf4.getGLTFAccessorValue)(gltf, accessor),
+    size: 1,
+    normalized: accessor.normalized
   } : void 0;
-  if (primitive.mode !== 5) return attribute;
+  if (primitive.mode !== 5 && primitive.mode !== 6) return attribute;
   const sourceIndices = validateMeshIndices(attribute, vertexCount, 5);
   const indexCount = sourceIndices?.length ?? vertexCount;
   if (!Number.isSafeInteger(indexCount) || indexCount < 3) {
-    throw new import_core19.TileConversionError(
+    throw new import_core20.TileConversionError(
       "MESH_TRIANGLE_COUNT_INVALID",
       "Triangle strips require at least three vertices"
     );
@@ -2520,9 +2735,10 @@ function createTriangleIndices(primitive, vertexCount) {
   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;
+    const second = primitive.mode === 6 ? triangle + 1 : triangle + 1 + triangle % 2;
+    const third = primitive.mode === 6 ? triangle + 2 : triangle + 2 - triangle % 2;
+    const first = primitive.mode === 6 ? 0 : triangle;
+    indices[triangle * 3] = sourceIndices?.[first] ?? first;
     indices[triangle * 3 + 1] = sourceIndices?.[second] ?? second;
     indices[triangle * 3 + 2] = sourceIndices?.[third] ?? third;
   }
@@ -2530,14 +2746,20 @@ function createTriangleIndices(primitive, vertexCount) {
 }
 
 // src/v5/i3s-mesh-conversion.ts
-var import_i3s = require("@loaders.gl/i3s");
-var import_core21 = require("@loaders.gl/tile-converter/v5/core");
+var import_i3s = require("@loaders.gl/tiles-3d/i3s");
 var import_core22 = require("@loaders.gl/tile-converter/v5/core");
+var import_core23 = require("@loaders.gl/tile-converter/v5/core");
 function createI3SMeshConversionCodec(options) {
+  if (options.integratedMeshPolicy !== void 0 && options.integratedMeshPolicy !== "as-3d-object") {
+    throw new import_core22.TileConversionError(
+      "I3S_LAYER_TYPE_POLICY_INVALID",
+      "Unknown IntegratedMesh conversion policy"
+    );
+  }
   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 import_core21.TileConversionError(
+    throw new import_core22.TileConversionError(
       "I3S_MESH_FRAME_UNSUPPORTED",
       "I3S mesh authoring requires resolved ECEF coordinates and ellipsoidal heights"
     );
@@ -2546,6 +2768,12 @@ function createI3SMeshConversionCodec(options) {
     /** Places a source mesh in ECEF and authors one layer without modifying source arrays. */
     async *convert(resource, _inspection, signal) {
       signal?.throwIfAborted();
+      if (resource.sourceLayerType === "IntegratedMesh" && options.integratedMeshPolicy !== "as-3d-object") {
+        throw new import_core22.TileConversionError(
+          "I3S_LAYER_TYPE_CHANGE_REQUIRED",
+          "IntegratedMesh to 3DObject conversion requires integratedMeshPolicy=as-3d-object"
+        );
+      }
       const mesh = validateMeshGeometry(resource.mesh, true);
       const positions = mesh.attributes.POSITION.value;
       const context = options.spatialContext;
@@ -2562,6 +2790,7 @@ function createI3SMeshConversionCodec(options) {
       if (mesh.attributes.NORMAL) mesh.attributes.NORMAL = { value: transformed.normals, size: 3 };
       let layer;
       try {
+        await (0, import_i3s.preloadI3SMeshCompression)();
         const writerOptions = {
           ...options,
           material: resource.material,
@@ -2570,18 +2799,26 @@ function createI3SMeshConversionCodec(options) {
         };
         layer = options.draco === false ? (0, import_i3s.encodeI3SMeshLayer)(mesh, writerOptions) : await (0, import_i3s.encodeI3SMeshLayerWithDraco)(mesh, writerOptions, options.dracoLibraryOptions);
       } catch (error) {
-        throw new import_core21.TileConversionError(
+        throw new import_core22.TileConversionError(
           "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 };
+      yield { id: resource.id, ...layer, sourceLayerType: resource.sourceLayerType };
     },
     /** Reports measured precision and explicitly authorized integer representation changes. */
     async validateOutput(resource) {
       return [
+        ...resource.sourceLayerType === "IntegratedMesh" ? [
+          {
+            code: "I3S_LAYER_TYPE_CHANGED",
+            message: "Explicitly authored IntegratedMesh geometry as I3S 1.7 3DObject; integrated surface layer semantics and source LOD are not preserved",
+            severity: "warning",
+            resourceId: resource.id
+          }
+        ] : [],
         ...resource.maximumPositionError > 0 ? [
           {
             code: "I3S_MESH_POSITION_ROUNDING",
@@ -2601,7 +2838,7 @@ function createI3SMeshConversionCodec(options) {
   };
 }
 function createSingleMeshI3SSink(options) {
-  const memory = (0, import_core22.createBoundedMemoryTileConversionSink)(options);
+  const memory = (0, import_core23.createBoundedMemoryTileConversionSink)(options);
   let state = "empty";
   let completed = false;
   return {
@@ -2611,7 +2848,7 @@ function createSingleMeshI3SSink(options) {
     async write(resource, signal) {
       signal?.throwIfAborted();
       if (state !== "empty")
-        throw new import_core21.TileConversionError(
+        throw new import_core22.TileConversionError(
           "SINGLE_I3S_MESH_UNAVAILABLE",
           "The initial I3S sink accepts exactly one mesh layer"
         );
@@ -2630,7 +2867,7 @@ function createSingleMeshI3SSink(options) {
     /** Commits a complete single-layer result. */
     async finalize(report) {
       if (state !== "written")
-        throw new import_core21.TileConversionError(
+        throw new import_core22.TileConversionError(
           "SINGLE_I3S_MESH_INCOMPLETE",
           "Finalization requires exactly one successfully written layer"
         );
@@ -2650,16 +2887,16 @@ function createSingleMeshI3SSink(options) {
 // src/v5/i3s-mesh-sink.ts
 var import_geospatial = require("@math.gl/geospatial");
 var import_compression = require("@loaders.gl/compression");
-var import_core23 = require("@loaders.gl/tile-converter/v5/core");
+var import_core24 = require("@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 import_core23.TileConversionError(
+    throw new import_core24.TileConversionError(
       "I3S_COLLECTION_OPTIONS_INVALID",
       "I3S collections require 1\u201364 meshes and a positive resource byte limit"
     );
-  const memory = (0, import_core23.createBoundedMemoryTileConversionSink)(options);
-  const compressor = new import_compression.GZipCompressor({ useNative: false, gzip: { mtime: 0 } });
+  const memory = (0, import_core24.createBoundedMemoryTileConversionSink)(options);
+  const compressor = new import_compression.GZipCompressor({ useNative: false });
   const decompressor = new import_compression.GZipDecompressor({ useNative: false });
   const leaves = [];
   const identifiers = /* @__PURE__ */ new Set();
@@ -2671,7 +2908,7 @@ function createI3SMeshSink(options) {
   async function readBytes(bytes) {
     const output = await decompressor.decompress(bytes);
     if (output.byteLength > maxResourceBytes)
-      throw new import_core23.TileConversionError(
+      throw new import_core24.TileConversionError(
         "I3S_COLLECTION_RESOURCE_TOO_LARGE",
         "I3S metadata exceeds maxResourceBytes"
       );
@@ -2683,7 +2920,7 @@ function createI3SMeshSink(options) {
   async function writeJson(resourceId, value) {
     const bytes = new TextEncoder().encode(JSON.stringify(value));
     if (bytes.byteLength > maxResourceBytes)
-      throw new import_core23.TileConversionError(
+      throw new import_core24.TileConversionError(
         "I3S_COLLECTION_RESOURCE_TOO_LARGE",
         "I3S index exceeds maxResourceBytes"
       );
@@ -2700,7 +2937,7 @@ function createI3SMeshSink(options) {
     async write(resource, signal) {
       signal?.throwIfAborted();
       if (state !== "open" || identifiers.has(resource.id) || leaves.length >= maxMeshes)
-        throw new import_core23.TileConversionError(
+        throw new import_core24.TileConversionError(
           "I3S_COLLECTION_UNAVAILABLE",
           "I3S collection is busy, closed, full, or repeats a placement"
         );
@@ -2713,7 +2950,7 @@ function createI3SMeshSink(options) {
         authored.store.defaultGeometrySchema
       ]);
       if (schemaKey !== void 0 && key !== schemaKey)
-        throw new import_core23.TileConversionError(
+        throw new import_core24.TileConversionError(
           "I3S_COLLECTION_SCHEMA_MISMATCH",
           "Mesh nodes must share feature fields and the legacy geometry layout"
         );
@@ -2725,7 +2962,7 @@ function createI3SMeshSink(options) {
       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 import_core23.TileConversionError(
+        throw new import_core24.TileConversionError(
           "I3S_COLLECTION_IDS_INVALID",
           "Generated object IDs must be contiguous and disjoint across nodes"
         );
@@ -2736,7 +2973,7 @@ function createI3SMeshSink(options) {
         "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 import_core23.TileConversionError(
+        throw new import_core24.TileConversionError(
           "I3S_COLLECTION_BOUNDS_INVALID",
           "Expected finite axis-aligned bounds from the I3S mesh writer"
         );
@@ -2787,7 +3024,7 @@ function createI3SMeshSink(options) {
     /** Rebuilds both indices and layer bounds only after every leaf has completed. */
     async finalize(report) {
       if (state !== "open" || !layer || !leaves.length)
-        throw new import_core23.TileConversionError(
+        throw new import_core24.TileConversionError(
           "I3S_COLLECTION_INCOMPLETE",
           "Finalization requires successfully written mesh nodes"
         );
@@ -2812,7 +3049,7 @@ function createI3SMeshSink(options) {
         quaternion: [0, 0, 0, 1]
       };
       if ([...obb.center, ...obb.halfSize].some((value) => !Number.isFinite(value)))
-        throw new import_core23.TileConversionError(
+        throw new import_core24.TileConversionError(
           "I3S_COLLECTION_BOUNDS_INVALID",
           "Collection bounds cannot be represented"
         );
@@ -2872,7 +3109,7 @@ function createI3SMeshSink(options) {
 }
 
 // src/v5/conversion-api.ts
-var TileConversionError17 = class extends Error {
+var TileConversionError18 = class extends Error {
   /** Stable machine-readable failure code. */
   code;
   /** Diagnostics associated with this failure. */
@@ -2890,7 +3127,7 @@ var TileConversionError17 = class extends Error {
 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(
+    throw new TileConversionError18(
       "INVALID_INPUT_MEMORY_LIMIT",
       "Resource fetch requires a positive aggregate byte budget and valid initial bytes"
     );
@@ -2899,7 +3136,7 @@ function createTileConversionResourceFetcher(options) {
     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(
+      throw new TileConversionError18(
         "EXTERNAL_RESOURCE_UNSUPPORTED",
         "Conversion transport requires HTTP(S), Blob or embedded data resources"
       );
@@ -2908,14 +3145,14 @@ function createTileConversionResourceFetcher(options) {
     const response = await fetcher(input, { ...requestOptions, signal });
     if (!response.ok) {
       await response.body?.cancel();
-      throw new TileConversionError17(
+      throw new TileConversionError18(
         "BROWSER_SOURCE_FETCH_FAILED",
         `Could not fetch conversion resource (${response.status})`
       );
     }
     const reader = response.body?.getReader();
     if (!reader)
-      throw new TileConversionError17(
+      throw new TileConversionError18(
         "BROWSER_SOURCE_STREAM_UNAVAILABLE",
         "Conversion resources require readable response streams"
       );
@@ -2933,7 +3170,7 @@ function createTileConversionResourceFetcher(options) {
         signal?.throwIfAborted();
         if (done) break;
         if (value.byteLength > options.maxInputBytes - consumed)
-          throw new TileConversionError17(
+          throw new TileConversionError18(
             "INPUT_RESOURCE_TOO_LARGE",
             "Selected contents and external dependencies exceed the aggregate input byte budget"
           );
@@ -2954,25 +3191,27 @@ function createTileConversionResourceFetcher(options) {
       bytes.set(part, offset);
       offset += part.byteLength;
     }
-    return new Response(bytes, {
+    const boundedResponse = new Response(bytes, {
       status: response.status,
       statusText: response.statusText,
       headers: response.headers
     });
+    Object.defineProperty(boundedResponse, "url", { value: response.url });
+    return boundedResponse;
   };
 }
 
 // src/v5/point-cloud-tileset-sink.ts
-var import_core24 = require("@loaders.gl/tile-converter/v5/core");
+var import_core25 = require("@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 import_core24.TileConversionError(
+    throw new import_core25.TileConversionError(
       "POINT_CLOUD_TILESET_OPTIONS_INVALID",
       "Positive maxTiles and finite nonnegative geometricError are required"
     );
   }
-  const memory = (0, import_core24.createBoundedMemoryTileConversionSink)(options);
+  const memory = (0, import_core25.createBoundedMemoryTileConversionSink)(options);
   const children = [];
   const identifiers = /* @__PURE__ */ new Set();
   const minimum = [Infinity, Infinity, Infinity];
@@ -2986,12 +3225,12 @@ function createPointCloudTilesetSink(options) {
     async write(resource, signal) {
       signal?.throwIfAborted();
       if (state !== "open")
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
           "Point sink is busy or closed"
         );
       if (!resource.id || identifiers.has(resource.id) || children.length >= maxTiles) {
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_PLACEMENT_INVALID",
           "Placements require unique nonempty identifiers within maxTiles"
         );
@@ -3004,7 +3243,7 @@ function createPointCloudTilesetSink(options) {
         signal
       );
       if (state !== "writing")
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
           "Point sink was aborted during writing"
         );
@@ -3023,7 +3262,7 @@ function createPointCloudTilesetSink(options) {
     /** Serializes the enclosing root after all placements have completed. */
     async finalize(report) {
       if (state !== "open" || !children.length)
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_SINK_INCOMPLETE",
           "Finalization requires successfully written point tiles"
         );
@@ -3033,7 +3272,7 @@ function createPointCloudTilesetSink(options) {
         Math.hypot(...minimum.map((value, axis) => maximum[axis] - value))
       );
       if (!Number.isFinite(rootError))
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_BOUNDS_INVALID",
           "Enclosing bounds must have a finite diagonal"
         );
@@ -3053,13 +3292,13 @@ function createPointCloudTilesetSink(options) {
         contentType: "application/json"
       });
       if (state !== "writing")
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
           "Point sink was aborted during finalization"
         );
       await memory.finalize(report);
       if (state !== "writing")
-        throw new import_core24.TileConversionError(
+        throw new import_core25.TileConversionError(
           "POINT_CLOUD_TILESET_SINK_UNAVAILABLE",
           "Point sink was aborted during finalization"
         );
@@ -3080,13 +3319,13 @@ 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 import_core24.TileConversionError(
+    throw new import_core25.TileConversionError(
       "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 import_core24.TileConversionError(
+    throw new import_core25.TileConversionError(
       "POINT_CLOUD_GEOMETRIC_ERROR_INVALID",
       "geometricError must include measured position reconstruction error"
     );
@@ -3094,7 +3333,7 @@ function getPointTileBounds(resource, geometricError) {
   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 import_core24.TileConversionError(
+    throw new import_core25.TileConversionError(
       "POINT_CLOUD_TILESET_BOUNDS_INVALID",
       "RTC center and encoded xyz bounds must be finite and ordered"
     );
@@ -3102,7 +3341,7 @@ function getPointTileBounds(resource, geometricError) {
   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 import_core24.TileConversionError(
+    throw new import_core25.TileConversionError(
       "POINT_CLOUD_TILESET_BOUNDS_INVALID",
       "Reconstructed ECEF bounds must be finite"
     );
@@ -3115,12 +3354,13 @@ function createPointBoundsBox(minimum, maximum) {
 }
 
 // src/v5/i3s-mesh-source.ts
-var import_core27 = require("@loaders.gl/tile-converter/v5/core");
+var import_core28 = require("@loaders.gl/tile-converter/v5/core");
 
 // src/v5/i3s-mesh-source-material.ts
 var import_images3 = require("@loaders.gl/images");
-var import_core25 = require("@loaders.gl/tile-converter/v5/core");
+var import_core26 = require("@loaders.gl/tile-converter/v5/core");
 async function mapI3SMeshSourceMaterial(content, header, readExternalResource, contentUri, signal) {
+  const gltf = { json: { asset: { version: "2.0" } }, buffers: [] };
   const material = Object.fromEntries(
     Object.entries(content.material || {}).filter(([, value]) => value !== void 0)
   );
@@ -3129,7 +3369,7 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
   ) : {};
   material.pbrMetallicRoughness = metallicRoughness;
   if (material.cullFace !== void 0 && material.cullFace !== "back") {
-    throw new import_core25.TileConversionError(
+    throw new import_core26.TileConversionError(
       "I3S_MESH_SOURCE_MATERIAL_UNSUPPORTED",
       "Only back-face culling is supported"
     );
@@ -3148,7 +3388,7 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
   }
   const encodedTextures = content.textures || {};
   if (!textureInfo && (resources.length || content.texture || Object.keys(encodedTextures).length)) {
-    throw new import_core25.TileConversionError(
+    throw new import_core26.TileConversionError(
       "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
       "Texture resources require a base-color mapping"
     );
@@ -3161,7 +3401,7 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
     ) || ["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 import_core25.TileConversionError(
+      throw new import_core26.TileConversionError(
         "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
         "Only one base-color texture set on TEXCOORD_0 with qualified wrapping is supported"
       );
@@ -3169,7 +3409,7 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
     let encoded = encodedTextures[String(definitionId)] || content.texture || textureInfo.texture?.source?.image;
     if (!encoded) {
       if (!resources.length || !readExternalResource) {
-        throw new import_core25.TileConversionError(
+        throw new import_core26.TileConversionError(
           "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
           "Encoded texture bytes or an explicit bounded resource reader are required"
         );
@@ -3187,8 +3427,8 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
       }
     }
     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 import_core25.TileConversionError(
+    if (!(data instanceof Uint8Array) || !image || !["image/png", "image/jpeg"].includes(image.mimeType) || declaredFormat && (declaredFormat === "png" ? image.mimeType !== "image/png" : declaredFormat === "jpg" ? image.mimeType !== "image/jpeg" : true)) {
+      throw new import_core26.TileConversionError(
         "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
         "I3S base-color bytes must have matching PNG/JPEG headers"
       );
@@ -3196,22 +3436,27 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
     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 } : {}
-      }
-    };
+    gltf.buffers.push({
+      arrayBuffer: data.buffer,
+      byteOffset: data.byteOffset,
+      byteLength: data.byteLength
+    });
+    gltf.json.buffers = [{ byteLength: data.byteLength }];
+    gltf.json.bufferViews = [{ buffer: 0, byteLength: data.byteLength }];
+    gltf.json.images = [{ mimeType: image.mimeType, bufferView: 0 }];
+    gltf.json.samplers = [sampler];
+    gltf.json.textures = [{ source: 0, sampler: 0 }];
+    metallicRoughness.baseColorTexture = { texCoord: 0, index: 0 };
   }
   const mapped = await mapMeshSourceMaterial(
     material,
     void 0,
     contentUri,
-    signal
+    signal,
+    gltf
   );
   if (mapped?.baseColorTexture && !content.sourceAttributes?.uv0) {
-    throw new import_core25.TileConversionError(
+    throw new import_core26.TileConversionError(
       "MESH_TEXCOORD_REQUIRED",
       "Base-color textures require TEXCOORD_0"
     );
@@ -3220,8 +3465,8 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
 }
 
 // src/v5/i3s-mesh-source-features.ts
-var import_i3s2 = require("@loaders.gl/i3s");
-var import_core26 = require("@loaders.gl/tile-converter/v5/core");
+var import_i3s2 = require("@loaders.gl/tiles-3d/i3s");
+var import_core27 = require("@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;
@@ -3229,7 +3474,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
   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 import_core26.TileConversionError(
+    throw new import_core27.TileConversionError(
       "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"
     );
@@ -3252,7 +3497,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     ) || 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 import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "I3S_MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
         `Attribute ${attribute2.name} requires a standard scalar/string resource layout`
       );
@@ -3261,7 +3506,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     signal?.throwIfAborted();
     inputBytes += bytes instanceof Uint8Array ? bytes.byteLength : Infinity;
     if (!(bytes instanceof Uint8Array) || inputBytes > maximumAttributeBytes) {
-      throw new import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "INPUT_RESOURCE_TOO_LARGE",
         "I3S node attributes exceed maxAttributeBytes"
       );
@@ -3274,14 +3519,14 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
         i3s: { attributeValues: "exact" }
       });
     } catch (error) {
-      throw new import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "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 import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "I3S_MESH_SOURCE_ATTRIBUTE_COUNT_INVALID",
         "Every attribute must have the same nonzero row count"
       );
@@ -3289,7 +3534,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     if (Array.from(column).some(
       (value) => typeof value === "number" && !Number.isFinite(value)
     )) {
-      throw new import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "I3S_MESH_SOURCE_ATTRIBUTE_UNSUPPORTED",
         "Numeric noData values require an explicit custom mapper"
       );
@@ -3302,7 +3547,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
   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 import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
         "Object IDs must be unique exact integers"
       );
@@ -3313,7 +3558,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
   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 import_core26.TileConversionError(
+    throw new import_core27.TileConversionError(
       "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
       "Geometry requires one exact unnormalized object ID per vertex"
     );
@@ -3324,7 +3569,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     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 import_core26.TileConversionError(
+        throw new import_core27.TileConversionError(
           "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
           "Feature draw ranges must cover valid triangles"
         );
@@ -3332,7 +3577,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
       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 import_core26.TileConversionError(
+          throw new import_core27.TileConversionError(
             "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
             "Feature draw ranges must agree with decoded ownership without overlapping"
           );
@@ -3341,7 +3586,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
       }
     }
     if (covered.some((value) => value === 0)) {
-      throw new import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
         "Feature draw ranges must cover every triangle"
       );
@@ -3355,7 +3600,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     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 import_core26.TileConversionError(
+      throw new import_core27.TileConversionError(
         "I3S_MESH_SOURCE_FEATURE_ASSOCIATION_INVALID",
         "Each triangle must reference one declared attribute row"
       );
@@ -3364,14 +3609,14 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     usedRows.add(row);
   }
   if (usedRows.size !== count) {
-    throw new import_core26.TileConversionError(
+    throw new import_core27.TileConversionError(
       "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 import_core26.TileConversionError(
+    throw new import_core27.TileConversionError(
       "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
       "Stable identifier column is missing"
     );
@@ -3392,7 +3637,7 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
     for (let index = 0; index < column.length; index++) {
       const identifier = column.get(index);
       if (stableIds.has(identifier)) {
-        throw new import_core26.TileConversionError(
+        throw new import_core27.TileConversionError(
           "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
           "Stable IDs must be unique"
         );
@@ -3410,25 +3655,25 @@ async function extractI3SMeshFeatures(content, item, metadata, options, readExte
 
 // src/v5/i3s-mesh-source.ts
 function createI3SMeshTilesetConversionSource(tileset, options = {}) {
-  const source = (0, import_core27.createTilesetConversionSource)(tileset, options);
+  const source = (0, import_core28.createTilesetConversionSource)(tileset, options);
   return {
     /** Validates the layer profile and explicit source decode policy before reading. */
     async inspect(signal) {
       if (options.features && options.getFeatures) {
-        throw new import_core27.TileConversionError(
+        throw new import_core28.TileConversionError(
           "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 import_core27.TileConversionError(
+        throw new import_core28.TileConversionError(
           "I3S_MESH_SOURCE_PROFILE_UNSUPPORTED",
           "I3S mesh extraction requires a 3DObject/IntegratedMesh runtime with geometryMode=source"
         );
       }
       if (!metadata.spatialReference?.sourceCrs) {
-        throw new import_core27.TileConversionError(
+        throw new import_core28.TileConversionError(
           "I3S_MESH_SOURCE_REFERENCE_REQUIRED",
           "I3S conversion requires an explicit source CRS"
         );
@@ -3456,7 +3701,7 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
           ].some(
             (field) => JSON.stringify(content.spatialReference?.[field]) !== JSON.stringify(metadata.spatialReference?.[field])
           )) {
-            throw new import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "I3S_MESH_SOURCE_GEOMETRY_UNSUPPORTED",
               "I3S extraction requires original source-frame Float64 triangle geometry"
             );
@@ -3464,7 +3709,7 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
           if (!["earth-centered", "vertex-reference-frame"].includes(
             content.normalReferenceFrame || ""
           ) || content.normalReferenceFrame !== (metadata.tileset.store?.normalReferenceFrame || "earth-centered")) {
-            throw new import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "I3S_MESH_SOURCE_NORMAL_FRAME_UNSUPPORTED",
               "Unknown I3S vector basis"
             );
@@ -3472,20 +3717,20 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
           if (content.meshSegmentation || Object.entries(attributes).some(
             ([name, value]) => value && !["position", "normal", "uv0", "id", "faceRange"].includes(name)
           )) {
-            throw new import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "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 import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "I3S_MESH_SOURCE_FEATURE_ID_UNSUPPORTED",
               "Decoded numeric feature IDs must be exact safe integers"
             );
           }
           if (hasFeatures && !options.getFeatures && !options.features) {
-            throw new import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
               "I3S feature data requires explicit resource features or a custom Arrow mapper"
             );
@@ -3504,7 +3749,7 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
             true
           );
           if (mesh.attributes.POSITION.value.length / 3 !== content.vertexCount) {
-            throw new import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "I3S_MESH_SOURCE_COUNT_INVALID",
               "I3S vertexCount must match the decoded geometry"
             );
@@ -3520,7 +3765,7 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
           ) : void 0;
           signal?.throwIfAborted();
           if (hasFeatures && !features) {
-            throw new import_core27.TileConversionError(
+            throw new import_core28.TileConversionError(
               "I3S_MESH_SOURCE_FEATURE_MAPPING_REQUIRED",
               "The feature mapper must return all declared feature data"
             );
@@ -3536,6 +3781,7 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
           yield {
             id: `${item.tile.id}/${entry.index}`,
             origin: [0, 0, 0],
+            sourceLayerType: metadata.tileset.layerType,
             mesh,
             normalReferenceFrame: content.normalReferenceFrame === "vertex-reference-frame" ? "vertex-reference-frame" : "earth-centered",
             features,
@@ -3546,3 +3792,1529 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
     }
   };
 }
+
+// src/v5/point-cloud-attributes.ts
+var import_schema_utils5 = require("@loaders.gl/core/schema-utils");
+var import_core29 = require("@loaders.gl/tile-converter/v5/core");
+function mapPointCloudAttributes(input, mapping) {
+  const mesh = getPointCloudMesh(input);
+  const attributes = /* @__PURE__ */ Object.create(null);
+  const selected = /* @__PURE__ */ new Set();
+  for (const [target, source] of Object.entries(mapping.attributes)) {
+    if (!target || ["__proto__", "constructor", "prototype"].includes(target) || !Object.hasOwn(mesh.attributes, source))
+      throw new import_core29.TileConversionError(
+        "POINT_CLOUD_MAPPING_INVALID",
+        `Invalid point attribute mapping ${target}: ${source}`
+      );
+    if (Object.hasOwn(mapping.drop || {}, source))
+      throw new import_core29.TileConversionError(
+        "POINT_CLOUD_MAPPING_INVALID",
+        `Point attribute ${source} is both selected and dropped`
+      );
+    attributes[target] = { ...mesh.attributes[source] };
+    selected.add(source);
+  }
+  const droppedAttributes = /* @__PURE__ */ Object.create(null);
+  for (const [source, reason] of Object.entries(mapping.drop || {}).sort(
+    ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+  )) {
+    if (!Object.hasOwn(mesh.attributes, source) || typeof reason !== "string" || !reason.trim())
+      throw new import_core29.TileConversionError(
+        "POINT_CLOUD_MAPPING_INVALID",
+        `Invalid loss declaration for ${source}`
+      );
+    droppedAttributes[source] = reason;
+  }
+  const unmapped = Object.keys(mesh.attributes).filter(
+    (name) => !selected.has(name) && !Object.hasOwn(droppedAttributes, name)
+  );
+  if (unmapped.length || !attributes.POSITION)
+    throw new import_core29.TileConversionError(
+      "POINT_CLOUD_MAPPING_REQUIRED",
+      `Map POSITION and explicitly retain or drop every attribute: ${unmapped.join(", ")}`
+    );
+  return {
+    mesh: { ...mesh, attributes, schema: { fields: [], metadata: { ...mesh.schema?.metadata } } },
+    droppedAttributes
+  };
+}
+function getPointCloudMesh(input, maxInputBytes = Infinity) {
+  const buffers = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  const countBuffer = (buffer) => {
+    if (!buffers.has(buffer)) {
+      buffers.add(buffer);
+      bytes += buffer.byteLength;
+    }
+    if (bytes > maxInputBytes)
+      throw new import_core29.TileConversionError("POINT_CLOUD_INPUT_BUDGET", "Point input byte budget exceeded");
+  };
+  if ("shape" in input) {
+    const checkColumn = (column) => {
+      if (column.nullCount)
+        throw new import_core29.TileConversionError(
+          "POINT_CLOUD_NULL_UNSUPPORTED",
+          "Null point values require an explicit preprocessing step"
+        );
+      for (const buffer of Object.values(column.buffers)) if (buffer) countBuffer(buffer.buffer);
+      for (const view of column.variadicBuffers) countBuffer(view.buffer);
+      for (const child of column.children) checkColumn(child);
+      for (const dictionary of column.dictionary?.data || []) checkColumn(dictionary);
+    };
+    for (const batch of input.data.batches) checkColumn(batch.data);
+  } else
+    for (const attribute of Object.values(input.attributes)) countBuffer(attribute.value.buffer);
+  const mesh = "shape" in input ? (0, import_schema_utils5.convertTableToMesh)(input) : input;
+  if (mesh.topology !== "point-list" || mesh.indices)
+    throw new import_core29.TileConversionError(
+      "POINT_CLOUD_INPUT_INVALID",
+      "Decoded unindexed point-list input is required"
+    );
+  return mesh;
+}
+
+// src/v5/point-cloud-copc.ts
+var import_copc = require("@loaders.gl/tiles-3d/copc");
+var import_core30 = require("@loaders.gl/tile-converter/v5/core");
+var SCALAR_RANGES = {
+  intensity: [0, 65535],
+  classification: [0, 255],
+  nir: [0, 65535],
+  gpsTime: [-Infinity, Infinity],
+  scanAngle: [-32768, 32767],
+  userData: [0, 255],
+  pointSourceId: [0, 65535],
+  returnNumber: [1, 15],
+  numberOfReturns: [1, 15],
+  scannerChannel: [0, 3],
+  scanDirectionFlag: [0, 1],
+  edgeOfFlightLine: [0, 1],
+  synthetic: [0, 1],
+  keyPoint: [0, 1],
+  withheld: [0, 1],
+  overlap: [0, 1]
+};
+async function encodePointCloudCOPC(input, options) {
+  const maxInputBytes = options.maxInputBytes ?? 64 * 1024 * 1024;
+  const maxPoints = options.maxPoints ?? 1e6;
+  const maxOutputBytes = options.maxOutputBytes ?? 128 * 1024 * 1024;
+  if ([maxInputBytes, maxPoints, maxOutputBytes].some(
+    (value) => !Number.isSafeInteger(value) || value < 1
+  ) || options.scale.length !== 3 || options.scale.some((value) => !Number.isFinite(value) || value <= 0) || options.offset.length !== 3 || options.offset.some((value) => !Number.isFinite(value)) || typeof options.wkt !== "string" || !options.wkt.trim() || !Number.isFinite(options.maxPositionError) || options.maxPositionError < 0)
+    throw new import_core30.TileConversionError(
+      "POINT_CLOUD_COPC_OPTIONS_INVALID",
+      "COPC requires explicit finite scale, offset, CRS, precision and positive budgets"
+    );
+  options.signal?.throwIfAborted();
+  const source = getPointCloudMesh(input, maxInputBytes);
+  const { mesh, droppedAttributes } = mapPointCloudAttributes(source, options.mapping);
+  const position = mesh.attributes.POSITION;
+  const pointCount = mesh.header?.vertexCount ?? position.value.length / 3;
+  if (!Number.isSafeInteger(pointCount) || pointCount < 1 || pointCount > maxPoints)
+    throw new import_core30.TileConversionError(
+      "POINT_CLOUD_POINT_BUDGET",
+      "COPC requires a nonempty batch within the point limit"
+    );
+  if (!(position.value instanceof Float32Array || position.value instanceof Float64Array) || position.size !== 3 || position.normalized)
+    throw new import_core30.TileConversionError(
+      "POINT_CLOUD_POSITION_INVALID",
+      "COPC requires decoded floating XYZ"
+    );
+  const extraNames = new Set(options.extraBytes?.map((field) => field.attribute) || []);
+  const descriptorNames = new Set(
+    options.extraBytes?.map((field) => field.name || field.attribute) || []
+  );
+  if (extraNames.size !== (options.extraBytes?.length || 0) || descriptorNames.size !== extraNames.size || options.extraBytes?.some((field) => {
+    const name = field.name || field.attribute;
+    const description = field.description || "";
+    return !mesh.attributes[field.attribute] || !field.attribute || !name.length || name.length > 32 || description.length > 32 || /[^\x20-\x7e]/.test(name) || /[^\x20-\x7e]/.test(description);
+  }))
+    throw new import_core30.TileConversionError(
+      "POINT_CLOUD_EXTRA_BYTES_INVALID",
+      "Extra Bytes descriptors require unique mapped attributes and names/descriptions within 32 printable ASCII bytes"
+    );
+  for (const name of extraNames)
+    if (name === "POSITION" || name === "COLOR_0" || Object.hasOwn(SCALAR_RANGES, name))
+      throw new import_core30.TileConversionError(
+        "POINT_CLOUD_EXTRA_BYTES_INVALID",
+        "Map standard attributes directly instead of duplicating them as Extra Bytes"
+      );
+  for (const [name, attribute] of Object.entries(mesh.attributes)) {
+    const color2 = name === "COLOR_0";
+    const extra = extraNames.has(name);
+    if (name !== "POSITION" && !color2 && !extra && !Object.hasOwn(SCALAR_RANGES, name))
+      throw new import_core30.TileConversionError(
+        "POINT_CLOUD_ATTRIBUTE_UNSUPPORTED",
+        `COPC cannot preserve ${name}; supply an explicit supported mapping or drop reason`
+      );
+    if (attribute.transform || attribute.byteOffset || attribute.byteStride || attribute.componentType === "float16" || attribute.value.length !== pointCount * attribute.size || !color2 && attribute.normalized || name !== "POSITION" && !color2 && (extra ? ![1, 3].includes(attribute.size) : attribute.size !== 1))
+      throw new import_core30.TileConversionError(
+        "POINT_CLOUD_ATTRIBUTE_INVALID",
+        `COPC requires packed decoded attributes: ${name}`
+      );
+    if (color2) {
+      if (attribute.size !== 3 || !(attribute.value instanceof Uint8Array || attribute.value instanceof Uint16Array))
+        throw new import_core30.TileConversionError(
+          "POINT_CLOUD_COLOR_INVALID",
+          "COPC requires explicitly mapped uint8/uint16 RGB"
+        );
+    } else if (extra) {
+      for (const value of attribute.value)
+        if (typeof value !== "bigint" && !Number.isFinite(value))
+          throw new import_core30.TileConversionError(
+            "POINT_CLOUD_ATTRIBUTE_RANGE",
+            `Nonfinite Extra Bytes value: ${name}`
+          );
+    } else if (name !== "POSITION") {
+      const [minimum2, maximum2] = SCALAR_RANGES[name];
+      for (const value of attribute.value) {
+        if (typeof value !== "number" || !Number.isFinite(value) || value < minimum2 || value > maximum2 || name !== "gpsTime" && !Number.isInteger(value))
+          throw new import_core30.TileConversionError(
+            "POINT_CLOUD_ATTRIBUTE_RANGE",
+            `COPC value outside the qualified range: ${name}`
+          );
+      }
+    }
+  }
+  let maximumPositionError = 0;
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  const errors = [0, 0, 0];
+  for (let row = 0; row < pointCount; row++) {
+    for (let axis = 0; axis < 3; axis++) {
+      const value = position.value[row * 3 + axis];
+      const encoded = Math.round((value - options.offset[axis]) / options.scale[axis]);
+      if (!Number.isFinite(value) || !Number.isSafeInteger(encoded) || encoded < -2147483648 || encoded > 2147483647)
+        throw new import_core30.TileConversionError(
+          "POINT_CLOUD_POSITION_RANGE",
+          "COPC position exceeds signed int32 quantization"
+        );
+      minimum[axis] = Math.min(minimum[axis], value);
+      maximum[axis] = Math.max(maximum[axis], value);
+      errors[axis] = encoded * options.scale[axis] + options.offset[axis] - value;
+    }
+    maximumPositionError = Math.max(maximumPositionError, Math.hypot(...errors));
+    if (maximumPositionError > options.maxPositionError)
+      throw new import_core30.TileConversionError(
+        "POINT_CLOUD_PRECISION_EXCEEDED",
+        "COPC position rounding exceeds the declared error gate"
+      );
+    if (row % 16384 === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      options.signal?.throwIfAborted();
+    }
+  }
+  const width = Math.max(...maximum.map((value, axis) => value - minimum[axis]), ...options.scale);
+  const radius = width / 2;
+  if (!Number.isFinite(Math.hypot(radius, radius, radius)) || minimum.some((value, axis) => {
+    const center = value + (maximum[axis] - value) / 2;
+    return !Number.isFinite(value + maximum[axis]) || !Number.isFinite(center - radius) || !Number.isFinite(center + radius);
+  }))
+    throw new import_core30.TileConversionError("POINT_CLOUD_BOUNDS_INVALID", "COPC coordinate extent overflow");
+  options.signal?.throwIfAborted();
+  const color = mesh.attributes.COLOR_0;
+  const copc = import_copc.COPCWriter.encodeSync(mesh, {
+    copc: {
+      ...options.organization,
+      scale: [...options.scale],
+      offset: [...options.offset],
+      wkt: options.wkt,
+      pointDataRecordFormat: mesh.attributes.nir ? 8 : color ? 7 : 6,
+      colorDepth: color?.value instanceof Uint16Array ? 16 : 8,
+      extraBytes: options.extraBytes
+    }
+  });
+  options.signal?.throwIfAborted();
+  if (copc.byteLength > maxOutputBytes)
+    throw new import_core30.TileConversionError(
+      "POINT_CLOUD_OUTPUT_BUDGET",
+      "Completed COPC output exceeds the byte budget"
+    );
+  return { copc, pointCount, maximumPositionError, droppedAttributes };
+}
+function createCOPCConversionCodec(options) {
+  return {
+    async *convert(input, _inspection, signal) {
+      const combinedSignal = options.signal && signal ? AbortSignal.any([options.signal, signal]) : options.signal || signal;
+      yield await encodePointCloudCOPC(input, { ...options, signal: combinedSignal });
+    }
+  };
+}
+
+// src/v5/point-cloud-tileset.ts
+var import_point_cloud_tile_source = require("@loaders.gl/tiles-3d/point-cloud-tile-source");
+var import_core31 = require("@loaders.gl/tile-converter/v5/core");
+async function convertPointCloudToTileset(input, options) {
+  const reference = options.spatialReference;
+  if (!reference || reference.status !== "native" || reference.sourceCrs !== "EPSG:4978" || reference.targetCrs && reference.targetCrs !== "EPSG:4978" || reference.coordinateFrame !== "geocentric" || reference.axisOrder !== "xyz" || reference.heightReference !== "ellipsoidal" || reference.verticalUnitScale !== 1 || reference.units?.some((unit) => unit !== "meter")) {
+    throw new import_core31.TileConversionError(
+      "POINT_CLOUD_TILESET_FRAME_UNSUPPORTED",
+      "Point authoring requires explicit native EPSG:4978 xyz meters and ellipsoidal heights"
+    );
+  }
+  if (options.archive && (!Number.isSafeInteger(options.archive.maxArchiveBytes) || options.archive.maxArchiveBytes < 0)) {
+    throw new import_core31.TileConversionError(
+      "INVALID_ARCHIVE_BYTE_LIMIT",
+      "Archive byte limit must be a non-negative safe integer"
+    );
+  }
+  options.signal?.throwIfAborted();
+  const sink = createPointCloudTilesetSink(options);
+  let source;
+  try {
+    source = new import_point_cloud_tile_source.PointCloudTileSource(input, {
+      pointCloudTiler: { ...options.tiling, signal: options.signal, spatialReference: reference }
+    });
+    const { pointCount } = await source.getMetadata();
+    const report = await convertPointCloudSource(source, {
+      sink,
+      signal: options.signal,
+      onProgress: options.onProgress,
+      measureInputBytes: (tile) => {
+        const table = tile.content?.data.data;
+        return table ? table.schema.fields.reduce(
+          (bytes, _field, index) => bytes + (table.getChildAt(index)?.byteLength ?? 0),
+          0
+        ) : 0;
+      },
+      getTileEncodingOptions: (tile) => ({
+        rtcCenter: [
+          tile.header.boundingVolume.center[0],
+          tile.header.boundingVolume.center[1],
+          tile.header.boundingVolume.center[2]
+        ],
+        maxPositionError: options.geometricError
+      })
+    });
+    options.signal?.throwIfAborted();
+    const files = sink.getFiles();
+    const archive = options.archive ? await createTileConversionArchive(files, {
+      format: "3tz",
+      maxArchiveBytes: options.archive.maxArchiveBytes,
+      signal: options.signal
+    }) : void 0;
+    options.signal?.throwIfAborted();
+    return { pointCount, report, files, archive };
+  } catch (error) {
+    await sink.abort(error);
+    throw error;
+  } finally {
+    source?.close();
+  }
+}
+
+// src/v5/point-cloud-file.ts
+var import_copc2 = require("@loaders.gl/tiles-3d/copc");
+var import_potree = require("@loaders.gl/tiles-3d/potree");
+var import_schema_utils6 = require("@loaders.gl/core/schema-utils");
+var import_zip = require("@loaders.gl/archives/zip");
+async function encodePotreeArchive(input, options) {
+  validateLimit(options.maxArchiveBytes);
+  const dataset = await (0, import_potree.encodePotreeDataset)(input, { potree: options.potree });
+  return encodePotreeDatasetArchive(dataset, options.maxArchiveBytes, options.potree?.signal);
+}
+async function encodePotreeDatasetArchive(dataset, maxArchiveBytes, signal) {
+  validateLimit(maxArchiveBytes);
+  for (const path of dataset.files.keys()) validatePath(path);
+  signal?.throwIfAborted();
+  const archive = await (0, import_zip.encodeZip)(Object.fromEntries(dataset.files), {
+    compression: "store",
+    zip64: "never",
+    maxEntries: 65535,
+    maxArchiveBytes: BigInt(maxArchiveBytes),
+    signal
+  });
+  signal?.throwIfAborted();
+  return new Blob([archive], { type: "application/zip" });
+}
+async function openPointCloudFile(input, options) {
+  validateLimit(options.maxFileBytes);
+  if (input.size > options.maxFileBytes) throw new RangeError("Point file input budget exceeded");
+  options.signal?.throwIfAborted();
+  if (options.format === "copc") {
+    const source2 = import_copc2.COPCSourceLoader.createDataSource(input, options.sourceOptions || {});
+    try {
+      await source2.metadata;
+      options.signal?.throwIfAborted();
+      return { source: source2, close: () => source2.close() };
+    } catch (error) {
+      await source2.close();
+      throw error;
+    }
+  }
+  if (options.format !== "potree-zip") throw new TypeError("Unsupported point file format");
+  const maxEntries = options.maxEntries ?? 1e5;
+  const maxResourceBytes = options.maxResourceBytes ?? 64 * 1024 * 1024;
+  validateLimit(maxEntries);
+  validateLimit(maxResourceBytes);
+  const controller = new AbortController();
+  const signals = [controller.signal, options.signal, options.sourceOptions?.potree?.signal].filter(
+    (value) => Boolean(value)
+  );
+  const signal = AbortSignal.any(signals);
+  let archive;
+  const entries = /* @__PURE__ */ new Map();
+  let source;
+  try {
+    archive = await (0, import_zip.openZipArchive)(input, {
+      maxArchiveBytes: BigInt(options.maxFileBytes),
+      maxEntries,
+      maxReadBytes: Math.max(65557, maxResourceBytes),
+      maxCompressedBytes: BigInt(maxResourceBytes),
+      maxDecodedBytes: BigInt(maxResourceBytes),
+      signal
+    });
+    for await (const entry of archive.entries()) {
+      if (entry.directory) continue;
+      validatePath(entry.path);
+      if (entry.compression !== "store")
+        throw new Error("Potree bundles require unencrypted STORE entries");
+      entries.set(entry.path, entry);
+    }
+    const candidates = ["metadata.json", "cloud.js"].filter((path) => entries.has(path));
+    const metadataPath = options.metadataPath || (candidates.length === 1 ? candidates[0] : "");
+    validatePath(metadataPath);
+    if (!entries.has(metadataPath) || !/(^|\/)(metadata\.json|cloud\.js)$/.test(metadataPath))
+      throw new Error("Potree ZIP requires one metadata entry or an explicit metadataPath");
+    const prefix = "https://point-bundle.loaders.gl.invalid/";
+    const fetchResource = async (resource, request = {}) => {
+      signal.throwIfAborted();
+      request.signal?.throwIfAborted();
+      const url = new URL(resource);
+      if (url.origin !== new URL(prefix).origin || url.search || url.hash)
+        throw new Error("Resource outside the Potree bundle");
+      const path = decodeURIComponent(url.pathname.slice(1));
+      validatePath(path);
+      const entry = entries.get(path);
+      if (!entry) throw new Error(`Missing Potree bundle resource: ${path}`);
+      const range = new Headers(request.headers).get("range");
+      const match = range?.match(/^bytes=(\d+)-(\d+)$/);
+      if (range && !match) throw new RangeError("Unsupported Potree bundle byte range");
+      const begin = match ? Number(match[1]) : 0;
+      const end = match ? Number(match[2]) + 1 : Number(entry.size);
+      if (!Number.isSafeInteger(begin) || !Number.isSafeInteger(end) || begin < 0 || end < begin || BigInt(end) > entry.size || end - begin > maxResourceBytes)
+        throw new RangeError("Potree bundle resource/range budget exceeded");
+      const headers = new Headers({
+        "content-length": String(end - begin),
+        "accept-ranges": "bytes"
+      });
+      if (match) headers.set("content-range", `bytes ${begin}-${end - 1}/${entry.size}`);
+      const bytes = match ? await archive.readRange(entry, {
+        start: BigInt(begin),
+        end: BigInt(end),
+        signal: request.signal ?? void 0
+      }) : await archive.read(entry, { signal: request.signal ?? void 0 });
+      const response = new Response(bytes, {
+        status: match ? 206 : 200,
+        headers
+      });
+      Object.defineProperty(response, "url", { value: url.href });
+      signal.throwIfAborted();
+      return response;
+    };
+    source = import_potree.PotreeSourceLoader.createDataSource(`${prefix}${metadataPath}`, {
+      ...options.sourceOptions,
+      core: { ...options.sourceOptions?.core, fetch: fetchResource },
+      potree: { ...options.sourceOptions?.potree, signal }
+    });
+    await source.initialize();
+    signal.throwIfAborted();
+    return {
+      source,
+      async close() {
+        controller.abort();
+        source?.close();
+        await archive?.close();
+      }
+    };
+  } catch (error) {
+    controller.abort();
+    source?.close();
+    await archive?.close();
+    throw error;
+  }
+}
+function extractMeshVertices(mesh, options) {
+  validateLimit(options.maxPoints);
+  const position = mesh.attributes.POSITION;
+  const pointCount = position?.value.length / 3;
+  if (mesh.topology !== "triangle-list" || mesh.mode !== 4 || !position || position.size !== 3 || position.normalized || position.transform || position.byteStride || position.byteOffset || !(position.value instanceof Float32Array || position.value instanceof Float64Array) || !Number.isSafeInteger(pointCount) || pointCount > options.maxPoints || position.value.some((value) => !Number.isFinite(value)))
+    throw new Error(
+      "Mesh vertex harvesting requires packed finite triangle XYZ within the point budget"
+    );
+  const attributes = { POSITION: position };
+  for (const name of options.attributes) {
+    const attribute = mesh.attributes[name];
+    if (!attribute || attribute.transform || attribute.byteStride || attribute.byteOffset || !Number.isSafeInteger(attribute.size) || attribute.size < 1 || attribute.value.length !== pointCount * attribute.size)
+      throw new Error(`Invalid selected mesh vertex attribute: ${name}`);
+    attributes[name] = attribute;
+  }
+  return { topology: "point-list", mode: 0, attributes, schema: (0, import_schema_utils6.deduceMeshSchema)(attributes) };
+}
+function validatePath(path) {
+  if (!path || !/^[A-Za-z0-9_.\/-]+$/.test(path) || path.split("/").some((part) => !part || part === "." || part === ".."))
+    throw new Error("Potree bundle paths must be canonical relative ASCII paths");
+}
+function validateLimit(value) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new RangeError("Point file limits must be positive safe integers");
+}
+
+// src/v5/point-cloud-potree.ts
+var import_schema_utils7 = require("@loaders.gl/core/schema-utils");
+var import_potree2 = require("@loaders.gl/tiles-3d/potree");
+async function convertPointCloudToPotree(input, options) {
+  if (typeof options.projection !== "string" || !options.projection.trim()) {
+    throw new Error("Potree authoring requires an explicit native CRS declaration");
+  }
+  for (const limit of [
+    options.maxGatheredBytes,
+    options.maxOutputBytes,
+    options.archive?.maxArchiveBytes
+  ]) {
+    if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1)) {
+      throw new RangeError("Potree authoring byte limits must be positive safe integers");
+    }
+  }
+  if (options.maxGatheredBytes === void 0 || options.maxOutputBytes === void 0) {
+    throw new RangeError("Potree authoring requires gathered and encoded byte limits");
+  }
+  options.signal?.throwIfAborted();
+  const tiler = new import_schema_utils7.PointCloudTiler(input, {
+    ...options.tiling,
+    maxNodes: Math.min(options.tiling?.maxNodes ?? 1e5, options.potree?.maxNodes ?? 1e5),
+    maxTileBytes: Math.min(
+      options.tiling?.maxTileBytes ?? 64 * 1024 * 1024,
+      options.maxGatheredBytes
+    ),
+    signal: options.signal
+  });
+  const nodes = [];
+  let gatheredBytes = 0;
+  let pointByteLength = 0;
+  let pointCount;
+  try {
+    const pending = [await tiler.getRootNode()];
+    pointCount = tiler.pointCount;
+    while (pending.length) {
+      options.signal?.throwIfAborted();
+      const node = pending.pop();
+      if (node.pointCount * pointByteLength > options.maxGatheredBytes - gatheredBytes) {
+        throw new RangeError("Potree gathered node byte budget exceeded");
+      }
+      const mesh = await tiler.getTileMesh(node.id);
+      const nodeBytes = Array.from(
+        new Set(Object.values(mesh.attributes).map((attribute) => attribute.value.buffer))
+      ).reduce((bytes, buffer) => bytes + buffer.byteLength, 0);
+      if (nodeBytes > options.maxGatheredBytes - gatheredBytes) {
+        throw new RangeError("Potree gathered node byte budget exceeded");
+      }
+      if (node.pointCount) pointByteLength = nodeBytes / node.pointCount;
+      gatheredBytes += nodeBytes;
+      nodes.push({ id: node.id, mesh });
+      const children = await tiler.getChildNodes(node.id);
+      for (let index = children.length - 1; index >= 0; index--) pending.push(children[index]);
+    }
+  } finally {
+    tiler.close();
+  }
+  const dataset = await (0, import_potree2.encodePotreeDataset)(nodes, {
+    potree: {
+      ...options.potree,
+      projection: options.projection,
+      maxOutputBytes: options.maxOutputBytes,
+      signal: options.signal
+    }
+  });
+  const archive = options.archive ? await encodePotreeDatasetArchive(dataset, options.archive.maxArchiveBytes, options.signal) : void 0;
+  options.signal?.throwIfAborted();
+  return { pointCount, nodeCount: nodes.length, dataset, archive };
+}
+
+// src/v5/mesh-hierarchy.ts
+var import_core32 = require("@math.gl/core");
+var import_tiles_3d3 = require("@loaders.gl/tiles-3d");
+var import_core33 = require("@loaders.gl/tile-converter/v5/core");
+function prepareMeshHierarchy(inspection, resourceIds) {
+  const rejectHierarchy = (message) => {
+    throw new import_core33.TileConversionError("MESH_HIERARCHY_UNSUPPORTED", message);
+  };
+  if (!inspection.documents?.length || inspection.documents.length > 32)
+    rejectHierarchy(
+      "Hierarchy preservation requires expanded metadata inspection of at most 32 explicit document placements"
+    );
+  if (!resourceIds.length || resourceIds.length > 64 || new Set(resourceIds).size !== resourceIds.length || resourceIds.length !== inspection.resources.length || inspection.resources.some((resource) => !resourceIds.includes(resource.resourceId)))
+    rejectHierarchy(
+      "Hierarchy preservation requires every content placement, without duplicates (at most 64)"
+    );
+  const entryTransform = new import_core32.Matrix4();
+  if (inspection.documents[0].parentResourceId !== void 0 || !Array.isArray(inspection.documents[0].parentTransform) || inspection.documents[0].parentTransform.length !== 16 || inspection.documents[0].parentTransform.some((value, index) => value !== entryTransform[index]))
+    rejectHierarchy("The entry document must have identity parent placement");
+  const documents = inspection.documents.map((placement) => placement.tileset);
+  const document = documents[0];
+  const externalDocuments = /* @__PURE__ */ new Map();
+  for (let index = 1; index < inspection.documents.length; index++) {
+    const identifier = inspection.documents[index].parentResourceId;
+    if (!identifier || externalDocuments.has(identifier))
+      rejectHierarchy(
+        "Every external document requires a distinct inspected parent content placement"
+      );
+    externalDocuments.set(identifier, index);
+  }
+  for (const document2 of documents) {
+    if (document2.metadata || document2.groups || document2.schema || document2.schemaUri || Object.keys(document2.extensions ?? {}).some((name) => name !== "EXT_geospatial_crs") || (document2.extensionsRequired ?? []).some((name) => name !== "EXT_geospatial_crs"))
+      rejectHierarchy(
+        "Dataset metadata and unmapped extensions require a separate hierarchy profile"
+      );
+    if (!["1.0", "1.1"].includes(document2.asset?.version ?? ""))
+      rejectHierarchy("Hierarchy preservation requires a 3D Tiles 1.0 or 1.1 document");
+    if (document2.geometricError !== void 0 && (typeof document2.geometricError !== "number" || !Number.isFinite(document2.geometricError) || document2.geometricError < 0))
+      rejectHierarchy("Dataset geometricError must be finite nonnegative meters");
+  }
+  const spatialReferences = documents.map(
+    (document2) => (0, import_tiles_3d3.get3DTilesSpatialReference)(document2)
+  );
+  const spatialReference = (0, import_core33.createTiles3DConversionSpatialContext)(
+    spatialReferences[0]
+  ).spatialReference;
+  if (spatialReference.status !== "native" || spatialReference.sourceCrs !== "EPSG:4978" || spatialReference.heightReference !== "ellipsoidal" || spatialReference.axisOrder !== "xyz" || spatialReference.verticalUnitScale !== 1 || spatialReference.units?.some((unit) => unit !== "meter"))
+    rejectHierarchy(
+      "Hierarchy preservation requires native EPSG:4978 xyz meters and ellipsoidal heights"
+    );
+  for (const reference of spatialReferences.slice(1)) {
+    const inherited = reference.crs.state === "absent" && reference.coordinateEpoch === void 0 && !reference.verticalCrs && !reference.warnings.length;
+    const context = (0, import_core33.createTiles3DConversionSpatialContext)(inherited ? spatialReference : reference);
+    if (context.spatialReference.status !== "native" || context.spatialReference.sourceCrs !== spatialReference.sourceCrs || context.spatialReference.heightReference !== spatialReference.heightReference || context.spatialReference.axisOrder !== spatialReference.axisOrder || context.spatialReference.verticalUnitScale !== 1 || context.spatialReference.units?.some((unit) => unit !== "meter") || context.spatialReference.coordinateEpoch !== spatialReference.coordinateEpoch)
+      rejectHierarchy("External document CRS and coordinate epoch must match the entry frame");
+  }
+  const nodes = [];
+  const visitedDocuments = /* @__PURE__ */ new Set([0]);
+  const stack = [
+    {
+      tile: document.root,
+      documentIndex: 0,
+      prefix: "",
+      path: [],
+      parent: -1,
+      transform: new import_core32.Matrix4(),
+      refine: void 0
+    }
+  ];
+  while (stack.length) {
+    const {
+      tile,
+      path,
+      parent,
+      documentIndex,
+      prefix,
+      transform: parentTransform,
+      refine: inheritedRefine
+    } = stack.pop();
+    const document2 = documents[documentIndex];
+    if (nodes.length >= 256) rejectHierarchy("Hierarchy preservation supports at most 256 tiles");
+    if (!tile || typeof tile !== "object" || Array.isArray(tile) || tile.implicitTiling !== void 0 || tile.extensions !== void 0 || tile.metadata !== void 0 || tile.viewerRequestVolume !== void 0 || tile.content !== void 0 && tile.contents !== void 0 || tile.contents !== void 0 && (!Array.isArray(tile.contents) || !tile.contents.length || document2.asset?.version !== "1.1") || tile.children !== void 0 && !Array.isArray(tile.children))
+      rejectHierarchy(
+        "Hierarchy tiles require explicit children, exclusive content/contents declarations and no unmapped metadata, extensions or request volumes"
+      );
+    const refine = tile.refine ?? inheritedRefine;
+    if (refine !== "ADD" && refine !== "REPLACE")
+      rejectHierarchy("Root refinement must be explicit ADD or REPLACE; children may inherit");
+    const matrix = tile.transform;
+    if (matrix !== void 0 && (!Array.isArray(matrix) || matrix.length !== 16 || matrix.some((value) => typeof value !== "number" || !Number.isFinite(value)) || matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0 || matrix[15] !== 1))
+      rejectHierarchy("Hierarchy transforms must be finite affine matrices");
+    const transform = new import_core32.Matrix4(parentTransform).multiplyRight(matrix ?? new import_core32.Matrix4());
+    const columns = [0, 1, 2].map(
+      (column) => [0, 1, 2].reduce((sum, row) => sum + Math.abs(transform[column * 4 + row]), 0)
+    );
+    const rows = [0, 1, 2].map(
+      (row) => [0, 1, 2].reduce((sum, column) => sum + Math.abs(transform[column * 4 + row]), 0)
+    );
+    const scale = document2.asset?.version === "1.0" ? 1 : Math.sqrt(Math.max(...columns)) * Math.sqrt(Math.max(...rows));
+    const geometricError2 = (tile.geometricError ?? NaN) * scale;
+    if (typeof tile.geometricError !== "number" || (tile.geometricError ?? -1) < 0 || !Number.isFinite(geometricError2) || Array.from(transform).some((value) => !Number.isFinite(value)))
+      rejectHierarchy("Every hierarchy tile must declare a finite nonnegative metric error");
+    const contents = tile.contents ?? (tile.content ? [tile.content] : []);
+    const identifiers = contents.map(
+      (_, contentIndex) => `${prefix}tile-${path.length ? path.join("-") : "root"}-content-${contentIndex}`
+    );
+    const externalIndexes = identifiers.map((identifier) => externalDocuments.get(identifier));
+    const externalIndex = externalIndexes.find((index2) => index2 !== void 0);
+    for (const [contentIndex, content] of contents.entries()) {
+      if (!content || typeof content !== "object" || Array.isArray(content) || content.metadata !== void 0 || content.group !== void 0 || content.extensions !== void 0)
+        rejectHierarchy("Content metadata, groups and extensions require a separate mapping");
+      if (externalIndexes[contentIndex] === void 0 && !inspection.resources.some(
+        (resource) => resource.resourceId === identifiers[contentIndex] && resource.documentIndex === documentIndex && resource.uri === (content.uri ?? content.url) && resource.tilePath.length === path.length && resource.tilePath.every((value, index2) => value === path[index2])
+      ))
+        rejectHierarchy("Hierarchy content must match the inspected placement");
+    }
+    const resourceId = identifiers[0];
+    if (externalIndex !== void 0) {
+      if (contents.length !== 1 || tile.contents !== void 0 || tile.children?.length || visitedDocuments.has(externalIndex))
+        rejectHierarchy(
+          "External references require a single content, no source children and a unique document placement"
+        );
+      visitedDocuments.add(externalIndex);
+      const placement = inspection.documents[externalIndex];
+      if (!Array.isArray(placement.parentTransform) || placement.parentTransform.length !== 16 || placement.parentTransform.some((value, index2) => value !== transform[index2]))
+        rejectHierarchy("External document placement must match its referencing tile transform");
+      const contentUri = tile.content?.uri ?? tile.content?.url;
+      if (!contentUri || !new URL(contentUri, inspection.documents[documentIndex].url).pathname.toLowerCase().endsWith(".json"))
+        rejectHierarchy("External documents require an inspected .json content reference");
+    }
+    const index = nodes.length;
+    nodes.push({
+      children: [],
+      resourceIds: externalIndex === void 0 ? identifiers : [],
+      geometricError: Math.max(
+        geometricError2,
+        externalIndex === void 0 ? 0 : documents[externalIndex].geometricError ?? 0
+      ),
+      refine
+    });
+    if (parent !== -1) nodes[parent].children.push(index);
+    if (externalIndex !== void 0) {
+      stack.push({
+        tile: documents[externalIndex].root,
+        path: [],
+        parent: index,
+        documentIndex: externalIndex,
+        prefix: resourceId + "/",
+        transform,
+        refine: void 0
+      });
+    }
+    if (nodes.length + stack.length + (tile.children?.length ?? 0) > 256)
+      rejectHierarchy("Hierarchy preservation supports at most 256 tiles");
+    for (let child = (tile.children?.length ?? 0) - 1; child >= 0; child--)
+      stack.push({
+        tile: tile.children[child],
+        documentIndex,
+        prefix,
+        path: [...path, child],
+        parent: index,
+        transform,
+        refine
+      });
+  }
+  if (visitedDocuments.size !== documents.length || nodes.reduce((count, node) => count + node.resourceIds.length, 0) !== resourceIds.length || nodes.some((node) => !node.resourceIds.length && !node.children.length))
+    rejectHierarchy("Contentless leaves or unmatched content placements cannot be preserved");
+  const geometricError = document.geometricError ?? nodes[0].geometricError;
+  if (typeof geometricError !== "number" || !Number.isFinite(geometricError) || geometricError < 0)
+    rejectHierarchy("Dataset geometricError must be finite nonnegative meters");
+  return {
+    nodes,
+    geometricError: Math.max(geometricError, nodes[0].geometricError),
+    coordinateEpoch: spatialReference.coordinateEpoch
+  };
+}
+function createMeshHierarchyTilesetSink(options) {
+  const hierarchy = prepareMeshHierarchy(options.inspection, options.resourceIds);
+  const extensions = structuredClone(
+    options.inspection.tileset.extensions
+  );
+  const extensionsRequired = structuredClone(
+    options.inspection.tileset.extensionsRequired
+  );
+  const { maxPositionError } = options;
+  if (!Number.isFinite(maxPositionError) || maxPositionError < 0 || hierarchy.nodes.some((node) => !Number.isFinite(node.geometricError + maxPositionError)) || !Number.isFinite(hierarchy.geometricError + maxPositionError))
+    throw new import_core33.TileConversionError(
+      "MESH_GEOMETRIC_ERROR_INVALID",
+      "Hierarchy position allowance and resulting errors must be finite nonnegative meters"
+    );
+  const memory = (0, import_core33.createBoundedMemoryTileConversionSink)(options);
+  const placements = /* @__PURE__ */ new Map();
+  const completedContents = /* @__PURE__ */ new Set();
+  const primitiveIdentifiers = /* @__PURE__ */ new Set();
+  let state = "open";
+  let completed = false;
+  return {
+    /** Exposes files only after complete finalization. */
+    getFiles: () => completed ? memory.getFiles() : [],
+    /** Retains ordered codec outputs and requires a terminal primitive for each content. */
+    async write(resource, signal) {
+      signal?.throwIfAborted();
+      const identifier = resource.contentResourceId;
+      const { index: primitiveIndex, last: lastPrimitive } = resource.contentPrimitive ?? {
+        index: 0,
+        last: true
+      };
+      if (state !== "open" || !identifier || completedContents.has(identifier) || primitiveIdentifiers.has(resource.id) || primitiveIdentifiers.size >= 64 || !Number.isSafeInteger(primitiveIndex) || primitiveIndex !== (placements.get(identifier)?.length ?? 0) || typeof lastPrimitive !== "boolean" || !hierarchy.nodes.some((node2) => node2.resourceIds.includes(identifier)))
+        throw new import_core33.TileConversionError(
+          "MESH_HIERARCHY_PLACEMENT_INVALID",
+          "Hierarchy writes require ordered, distinct primitives for declared contents before close (at most 64)"
+        );
+      if (resource.spatialReference.coordinateEpoch !== hierarchy.coordinateEpoch)
+        throw new import_core33.TileConversionError(
+          "MESH_SOURCE_EPOCH_MISMATCH",
+          "Hierarchy output coordinate epoch must match its source"
+        );
+      const tile = createMeshTileset(resource, maxPositionError).root;
+      const nodeIndex = hierarchy.nodes.findIndex((node2) => node2.resourceIds.includes(identifier));
+      const node = hierarchy.nodes[nodeIndex];
+      const sibling = node.resourceIds.map((identifier2) => placements.get(identifier2)?.[0]).find(Boolean);
+      if (sibling && sibling.origin.some((value, axis) => value !== resource.origin[axis]))
+        throw new import_core33.TileConversionError(
+          "MESH_HIERARCHY_PLACEMENT_INVALID",
+          "Contents on one tile must share an encoded origin"
+        );
+      const suffix = node.resourceIds.length > 1 ? "-" + node.resourceIds.indexOf(identifier) : "";
+      const primitiveSuffix = primitiveIndex > 0 || !lastPrimitive ? "-primitive-" + primitiveIndex : "";
+      const uri = `meshes/${nodeIndex}${suffix}${primitiveSuffix}.glb`;
+      state = "writing";
+      await memory.write(
+        { resourceId: uri, parts: [resource.glb], contentType: "model/gltf-binary" },
+        signal
+      );
+      const contentPlacements = placements.get(identifier) ?? [];
+      contentPlacements.push({
+        transform: [...tile.transform],
+        origin: [...resource.origin],
+        localBoundingBox: resource.localBoundingBox.map((bound) => [...bound]),
+        uri
+      });
+      placements.set(identifier, contentPlacements);
+      primitiveIdentifiers.add(resource.id);
+      if (lastPrimitive) completedContents.add(identifier);
+      state = "open";
+    },
+    /** Publishes original topology only after every source content has completed. */
+    async finalize(report) {
+      if (state !== "open" || completedContents.size !== hierarchy.nodes.reduce((count, node) => count + node.resourceIds.length, 0))
+        throw new import_core33.TileConversionError(
+          "MESH_HIERARCHY_INCOMPLETE",
+          "Finalization requires every declared hierarchy content"
+        );
+      state = "writing";
+      const tiles = new Array(hierarchy.nodes.length);
+      const bounds = new Array(hierarchy.nodes.length);
+      const transforms = hierarchy.nodes.map((node) => {
+        const placement = placements.get(node.resourceIds[0])?.[0];
+        return placement ? new import_core32.Matrix4(placement.transform) : new import_core32.Matrix4();
+      });
+      for (let index = hierarchy.nodes.length - 1; index >= 0; index--) {
+        const node = hierarchy.nodes[index];
+        const placement = placements.get(node.resourceIds[0])?.[0];
+        const minimum = [Infinity, Infinity, Infinity];
+        const maximum = [-Infinity, -Infinity, -Infinity];
+        const contributors = node.children.map((child) => bounds[child]);
+        const nodePlacements = node.resourceIds.flatMap((identifier) => placements.get(identifier));
+        for (const placement2 of nodePlacements) {
+          contributors.push(
+            placement2.localBoundingBox.map(
+              (bound, boundIndex) => bound.map((value, axis) => {
+                const padding = 8 * Number.EPSILON * Math.max(
+                  1,
+                  Math.abs(placement2.origin[axis]),
+                  ...placement2.localBoundingBox.map((limit) => Math.abs(limit[axis]))
+                );
+                return value + placement2.origin[axis] + (boundIndex ? padding : -padding);
+              })
+            )
+          );
+        }
+        for (const [lower, upper] of contributors)
+          for (let axis = 0; axis < 3; axis++) {
+            minimum[axis] = Math.min(minimum[axis], lower[axis]);
+            maximum[axis] = Math.max(maximum[axis], upper[axis]);
+          }
+        if ([...minimum, ...maximum].some((value) => !Number.isFinite(value)))
+          throw new import_core33.TileConversionError(
+            "MESH_TILESET_BOUNDS_INVALID",
+            "Hierarchy absolute bounds must remain finite"
+          );
+        bounds[index] = [minimum, maximum];
+        const inverse = new import_core32.Matrix4(transforms[index]).invert();
+        const center = Array.from(
+          inverse.transformAsPoint(minimum.map((value, axis) => value / 2 + maximum[axis] / 2))
+        );
+        const halfSize = minimum.map((value, axis) => maximum[axis] / 2 - value / 2);
+        const halfAxes = [0, 1, 2].flatMap(
+          (axis) => Array.from(
+            inverse.transformAsVector(
+              halfSize.map((value, coordinate) => coordinate === axis ? value : 0)
+            )
+          )
+        );
+        if ([...center, ...halfAxes].some((value) => !Number.isFinite(value)))
+          throw new import_core33.TileConversionError(
+            "MESH_TILESET_BOUNDS_INVALID",
+            "Hierarchy local bounds must remain finite"
+          );
+        tiles[index] = {
+          transform: Array.from(transforms[index]),
+          boundingVolume: { box: [...center, ...halfAxes] },
+          geometricError: node.geometricError + maxPositionError,
+          refine: node.refine,
+          ...nodePlacements.length > 1 ? { contents: nodePlacements.map((placement2) => ({ uri: placement2.uri })) } : placement ? { content: { uri: placement.uri } } : {},
+          ...node.children.length ? {
+            children: node.children.map((child) => {
+              tiles[child].transform = Array.from(
+                new import_core32.Matrix4(inverse).multiplyRight(transforms[child])
+              );
+              if (tiles[child].transform.some((value) => !Number.isFinite(value)))
+                throw new import_core33.TileConversionError(
+                  "MESH_TILESET_BOUNDS_INVALID",
+                  "Relative hierarchy transforms must remain finite"
+                );
+              return tiles[child];
+            })
+          } : {}
+        };
+      }
+      const json = JSON.stringify({
+        asset: { version: "1.1" },
+        ...extensions && Object.keys(extensions).length ? { extensions, extensionsUsed: Object.keys(extensions) } : {},
+        ...extensionsRequired?.length ? { extensionsRequired } : {},
+        geometricError: hierarchy.geometricError + maxPositionError,
+        root: tiles[0]
+      });
+      await memory.write({
+        resourceId: "tileset.json",
+        parts: [json],
+        contentType: "application/json"
+      });
+      await memory.finalize(report);
+      state = "closed";
+      completed = true;
+    },
+    /** Discards retained resources and hides all files after failure. */
+    async abort(error) {
+      state = "closed";
+      completed = false;
+      placements.clear();
+      completedContents.clear();
+      primitiveIdentifiers.clear();
+      await memory.abort(error);
+    }
+  };
+}
+
+// src/v5/selected-mesh-source.ts
+var import_core34 = require("@loaders.gl/core");
+var import_d_tiles2 = require("@loaders.gl/tiles-3d/3d-tiles");
+var import_tiles_3d4 = require("@loaders.gl/tiles-3d");
+var import_core35 = require("@loaders.gl/tile-converter/v5/core");
+var import_adapters = require("@loaders.gl/tile-converter/v5/adapters");
+var SELECTED_MESH_LIMITS = {
+  /** Root JSON plus selected content transport bytes; also the decoded geometry/image/feature byte gate. */
+  maxInputBytes: 16 * 1024 * 1024,
+  /** Maximum declared content placements inspected. */
+  maxInputResources: 1e3,
+  /** Maximum inspected root/external document placements. */
+  maxTilesetDocuments: 32,
+  /** Maximum explicitly selected content placements in one partial archive. */
+  maxSelectedResources: 64,
+  /** Maximum primitive placements authored across all selected contents. */
+  maxMeshResources: 64,
+  /** Maximum retained file bytes and final archive bytes. */
+  maxOutputBytes: 32 * 1024 * 1024,
+  /** Maximum measured reconstruction error in meters. */
+  maxPositionError: 0.01
+};
+async function createSelectedMeshConversionSource(inspection, options) {
+  const {
+    resourceIds,
+    signal,
+    dracoLibraryOptions,
+    features,
+    preserveHierarchy,
+    fetcher = fetch
+  } = options;
+  const maxInputBytes = options.maxInputBytes ?? SELECTED_MESH_LIMITS.maxInputBytes;
+  if (!Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1 || maxInputBytes > SELECTED_MESH_LIMITS.maxInputBytes)
+    throw new import_core35.TileConversionError(
+      "INVALID_SELECTED_MESH_OPTIONS",
+      "Selected mesh input budget must be a positive safe integer at most 16 MiB"
+    );
+  if (!resourceIds.length || resourceIds.length > SELECTED_MESH_LIMITS.maxSelectedResources || new Set(resourceIds).size !== resourceIds.length || resourceIds.some(
+    (identifier) => !inspection.resources.some((resource) => resource.resourceId === identifier)
+  ))
+    throw new Error("Select between 1 and 64 distinct content placements.");
+  if (preserveHierarchy !== void 0 && typeof preserveHierarchy !== "boolean")
+    throw new import_core35.TileConversionError(
+      "MESH_HIERARCHY_UNSUPPORTED",
+      "preserveHierarchy must be a boolean"
+    );
+  if (preserveHierarchy) prepareMeshHierarchy(inspection, resourceIds);
+  const descriptors = inspection.resources.filter(
+    (resource) => resourceIds.includes(resource.resourceId)
+  );
+  const selections = descriptors.map(
+    (descriptor) => (0, import_core35.selectBrowserTilesetContent)(inspection, descriptor)
+  );
+  const selectedContents = new Map(
+    descriptors.map((descriptor, index) => [descriptor.resourceId, selections[index]])
+  );
+  if (!preserveHierarchy && resourceIds.length > 1 && selections.some((selection) => !selection.isLeaf))
+    throw new Error(
+      "Multi-selection requires leaf contents; source LOD hierarchy is not exported."
+    );
+  signal.throwIfAborted();
+  const boundedFetcher = (0, import_adapters.createTileConversionResourceFetcher)({
+    maxInputBytes,
+    initialInputBytes: inspection.tilesetBytes,
+    fetcher,
+    signal
+  });
+  const qualification = createSelectedRuntime(
+    inspection.tileset,
+    new Uint8Array(),
+    signal,
+    boundedFetcher,
+    inspection.rootUrl,
+    dracoLibraryOptions
+  );
+  let spatialContext;
+  try {
+    await qualification.tilesetInitializationPromise;
+    const metadata = await (0, import_adapters.createMeshTilesetConversionSource)(qualification).inspect(signal);
+    spatialContext = (0, import_core35.createTiles3DConversionSpatialContext)(metadata.spatialReference);
+  } finally {
+    qualification.destroy();
+  }
+  const rawSource = options.source ?? (0, import_core35.createBrowserTilesetConversionSource)({
+    input: inspection.rootUrl,
+    ...SELECTED_MESH_LIMITS,
+    maxInputBytes,
+    fetcher: boundedFetcher
+  });
+  const selectedInspection = { ...inspection, resources: descriptors };
+  const source = {
+    /** Reuses inspected declarations without fetching the root again. */
+    inspect: async (inspectionSignal) => {
+      signal.throwIfAborted();
+      inspectionSignal?.throwIfAborted();
+      return selectedInspection;
+    },
+    /** Decodes and releases each selected placement in declaration order. */
+    async *read(_inspection, readSignal) {
+      const signal2 = readSignal ? AbortSignal.any([options.signal, readSignal]) : options.signal;
+      signal2.throwIfAborted();
+      let decodedBytes = 0;
+      let primitiveCount = 0;
+      const tileOrigins = /* @__PURE__ */ new Map();
+      for await (const raw of rawSource.read(selectedInspection, signal2)) {
+        const selection = selectedContents.get(raw.resourceId);
+        if (!selection)
+          throw new import_core35.TileConversionError(
+            "INVALID_BROWSER_SELECTION",
+            "Source yielded an uninspected content placement"
+          );
+        const contentUrl = raw.contentUrl ?? selection.contentUrl;
+        const runtime = createSelectedRuntime(
+          selection.tileset,
+          raw.data,
+          signal2,
+          boundedFetcher,
+          contentUrl,
+          dracoLibraryOptions,
+          spatialContext.spatialReference
+        );
+        try {
+          await runtime.tilesetInitializationPromise;
+          const meshSource = (0, import_adapters.createMeshTilesetConversionSource)(runtime, {
+            unloadContent: true,
+            features,
+            readExternalResource: async (uri, _contentUri, resourceSignal) => {
+              const response = await boundedFetcher(new URL(uri, contentUrl), {
+                signal: resourceSignal
+              });
+              return new Uint8Array(await response.arrayBuffer());
+            }
+          });
+          const metadata = await meshSource.inspect(signal2);
+          const selectedContext = (0, import_core35.createTiles3DConversionSpatialContext)(metadata.spatialReference);
+          if (selectedContext.spatialReference.coordinateEpoch !== spatialContext.spatialReference.coordinateEpoch)
+            throw new import_core35.TileConversionError(
+              "MESH_SOURCE_EPOCH_MISMATCH",
+              "Selected content coordinate epoch must match the root; epoch transformations are unsupported"
+            );
+          let meshCount = 0;
+          for await (const resource of meshSource.read(metadata, signal2)) {
+            meshCount++;
+            if (++primitiveCount > SELECTED_MESH_LIMITS.maxMeshResources)
+              throw new Error("Selected contents exceed the mesh primitive placement limit.");
+            decodedBytes += measureMeshBytes(resource);
+            if (decodedBytes > maxInputBytes)
+              throw new import_core35.TileConversionError(
+                "INPUT_RESOURCE_TOO_LARGE",
+                "Selected decoded geometry and encoded images exceed the aggregate input byte limit."
+              );
+            const tileIdentifier = raw.resourceId.replace(/content-\d+$/, "");
+            if (preserveHierarchy && !tileOrigins.has(tileIdentifier))
+              tileOrigins.set(tileIdentifier, [...resource.origin]);
+            yield {
+              ...resource,
+              origin: preserveHierarchy ? tileOrigins.get(tileIdentifier) : resource.origin,
+              id: `${raw.resourceId}/${resource.id}`,
+              contentResourceId: raw.resourceId
+            };
+          }
+          if (!meshCount) throw new Error("Selected content has no mesh primitive.");
+        } finally {
+          runtime.destroy();
+        }
+      }
+    }
+  };
+  return {
+    source,
+    spatialContext,
+    geometricError: Math.max(...selections.map((selection) => selection.geometricError)) + SELECTED_MESH_LIMITS.maxPositionError
+  };
+}
+var SelectedTiles3DSource = class extends import_tiles_3d4.Tiles3DSource {
+  /** Parent frame; explicit, unknown or unresolved child declarations are never replaced. */
+  inheritedSpatialReference;
+  /** Creates a selected source with optional external-document frame inheritance. */
+  constructor(input, options, inheritedSpatialReference) {
+    super(input, options);
+    this.inheritedSpatialReference = inheritedSpatialReference;
+  }
+  /** Returns source metadata with the same absent-CRS inheritance used by external tilesets. */
+  getMetadata() {
+    const metadata = super.getMetadata();
+    const reference = metadata.spatialReference;
+    if (this.inheritedSpatialReference && reference?.crs.state === "absent" && reference.coordinateEpoch === void 0 && !reference.verticalCrs && !reference.warnings.length)
+      return { ...metadata, spatialReference: this.inheritedSpatialReference };
+    return metadata;
+  }
+};
+function createSelectedRuntime(document, data, signal, boundedFetcher, contentUrl, dracoLibraryOptions, inheritedSpatialReference) {
+  const {
+    modules,
+    decoderProfile,
+    CDN: contentDeliveryNetwork,
+    useLocalLibraries
+  } = dracoLibraryOptions;
+  const loadOptions = {
+    modules,
+    core: {
+      worker: false,
+      fetch: boundedFetcher,
+      CDN: contentDeliveryNetwork,
+      useLocalLibraries
+    },
+    // Reuse the full decoder already bundled for output verification.
+    draco: { decoderProfile },
+    // Preserve authored UVs and the transform for the converter's qualified GLB writer.
+    gltf: {
+      loadImages: false,
+      decompressMeshes: true,
+      excludeExtensions: {
+        KHR_texture_transform: false,
+        // Only Draco input compression is qualified by this conversion profile.
+        EXT_meshopt_compression: false,
+        KHR_meshopt_compression: false
+      }
+    },
+    "3d-tiles": { loadGLTF: true }
+  };
+  return new import_tiles_3d4.Tileset3D(
+    new SelectedTiles3DSource(
+      {
+        url: contentUrl,
+        loader: import_d_tiles2.Tiles3DLoader,
+        resolver: {
+          /** Normalizes the selected hierarchy through the format loader, retaining ancestor transforms. */
+          loadRoot: async (_url, loader, options) => (0, import_core34.parse)(new TextEncoder().encode(JSON.stringify(document)), loader, options),
+          /** Decodes only the selected bounded payload; no sibling content can be requested. */
+          loadResource: async (_url, loader, options) => {
+            signal.throwIfAborted();
+            return (0, import_core34.parse)(data, loader, options, {
+              url: contentUrl,
+              baseUrl: contentUrl.startsWith("blob:") ? contentUrl : new URL(".", contentUrl).href,
+              fetch: boundedFetcher,
+              coreApi: import_core34.coreApi,
+              _parse: import_core34.parse
+            });
+          }
+        }
+      },
+      loadOptions,
+      inheritedSpatialReference
+    )
+  );
+}
+function measureMeshBytes(resource) {
+  const featureBytes = resource.features ? resource.features.triangleFeatureIndices.byteLength + resource.features.batches.reduce(
+    (bytes, batch) => bytes + batch.data.schema.fields.reduce(
+      (columnBytes, field) => columnBytes + (batch.data.getChild(field.name)?.byteLength ?? 0),
+      0
+    ),
+    0
+  ) : 0;
+  return Object.values(resource.mesh.attributes).reduce(
+    (bytes, attribute) => bytes + attribute.value.byteLength,
+    (resource.mesh.indices?.value.byteLength ?? 0) + (resource.material?.baseColorTexture?.data.byteLength ?? 0) + featureBytes
+  );
+}
+
+// src/v5/archive-source.ts
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_i3s3 = require("@loaders.gl/tiles-3d/i3s");
+var import_d_tiles3 = require("@loaders.gl/tiles-3d/3d-tiles");
+var import_core36 = require("@loaders.gl/tile-converter/v5/core");
+async function openTileConversionArchive(descriptor, maxInputBytes, signal, fetcher = fetch) {
+  signal.throwIfAborted();
+  if (!["slpk", "3tz"].includes(descriptor.format))
+    throw new import_core36.TileConversionError("INVALID_ARCHIVE_SOURCE", "Select SLPK or 3TZ archive input");
+  validateArchiveEntityTag(descriptor.identity?.etag);
+  const transport = createTileConversionResourceFetcher({
+    maxInputBytes,
+    signal,
+    fetcher: async (url, options) => {
+      const response = await fetcher(url, options);
+      if (response.status !== 206) {
+        await response.body?.cancel();
+        throw new Error("Remote conversion archives require HTTP 206 byte-range responses.");
+      }
+      try {
+        validateArchiveResponseValidator(response.headers);
+      } catch (error) {
+        await response.body?.cancel(error);
+        throw error;
+      }
+      return response;
+    }
+  });
+  let file;
+  let closePromise;
+  async function closeFile() {
+    if (file) {
+      closePromise ??= file.close();
+      await closePromise;
+    }
+  }
+  try {
+    if (typeof descriptor.input === "string") {
+      if (!["http:", "https:"].includes(new URL(descriptor.input).protocol))
+        throw new Error("Use an HTTP(S) archive URL.");
+      const remote = new import_loader_utils.HttpFile(descriptor.input, {
+        fetch: (url, options) => transport(url, options),
+        consistency: "strict",
+        ...descriptor.identity
+      });
+      file = remote;
+      await remote.open(signal);
+    } else file = new import_loader_utils.BlobFile(descriptor.input);
+    const ownedFile = file;
+    file = void 0;
+    return await createTileConversionArchiveTransport(
+      ownedFile,
+      descriptor.format,
+      maxInputBytes,
+      signal,
+      descriptor
+    );
+  } catch (error) {
+    await closeFile();
+    throw error;
+  }
+}
+async function createTileConversionArchiveTransport(file, format, maxInputBytes, signal, descriptor) {
+  const rootUrl = `https://conversion.invalid/input.${format}`;
+  let closed = false;
+  let releasePromise;
+  let closePromise;
+  const closeFile = () => {
+    closed = true;
+    closePromise ??= file.close();
+    return closePromise;
+  };
+  const checkOpen = () => {
+    signal.throwIfAborted();
+    if (closed)
+      throw new import_core36.TileConversionError("ARCHIVE_SOURCE_CLOSED", "Conversion archive is closed");
+  };
+  try {
+    checkOpen();
+    if (!["slpk", "3tz"].includes(format) || !Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1)
+      throw new import_core36.TileConversionError(
+        "INVALID_ARCHIVE_SOURCE",
+        "Archive source requires a supported format and positive safe byte budget"
+      );
+    if (!Number.isSafeInteger(file.size) || file.size < 0 || file.size > maxInputBytes)
+      throw new Error("Conversion archive input must be at most 16 MiB.");
+    let readBytes = 0;
+    const boundedFile = {
+      handle: file.handle,
+      size: file.size,
+      bigsize: file.bigsize,
+      url: file.url,
+      ...file.stat ? { stat: () => file.stat() } : {},
+      close: closeFile,
+      /** Checks indexed reads before allocation and forwards operation cancellation. */
+      read: async (start, length) => {
+        checkOpen();
+        if (!Number.isSafeInteger(length) || length < 0 || length > maxInputBytes - readBytes)
+          throw new import_core36.TileConversionError(
+            "INPUT_RESOURCE_TOO_LARGE",
+            "Archive indexed reads exceed the input budget"
+          );
+        readBytes += length;
+        const bytes = await file.read(start, length, signal);
+        checkOpen();
+        return bytes;
+      }
+    };
+    const archive = format === "slpk" ? await (0, import_i3s3.parseSLPKArchive)(boundedFile) : await (0, import_d_tiles3.parse3DTilesArchive)(boundedFile);
+    const root = new URL(rootUrl);
+    return {
+      rootUrl: format === "3tz" ? `${rootUrl}/tileset.json` : rootUrl,
+      descriptor: descriptor ? {
+        ...descriptor,
+        ...file instanceof import_loader_utils.HttpFile ? { identity: file.getIdentitySnapshot() } : {}
+      } : void 0,
+      /** Resolves only resources belonging to this archive, without external network fallback. */
+      fetcher: (async (input, options) => {
+        checkOpen();
+        options?.signal?.throwIfAborted();
+        const url = new URL(input instanceof Request ? input.url : String(input));
+        if (url.origin !== root.origin || url.pathname !== root.pathname && !url.pathname.startsWith(`${root.pathname}/`))
+          throw new Error("Conversion dependencies must resolve inside the selected archive.");
+        const path = decodeURIComponent(
+          url.pathname.slice(root.pathname.length).replace(/^\//, "")
+        );
+        if (path.includes("\\") || path.split("/").some((segment) => segment === ".." || segment === "."))
+          throw new Error("Archive dependency path cannot escape its root.");
+        const bytes = format === "slpk" ? await archive.getFile(path, "http") : await archive.getFile(path);
+        checkOpen();
+        options?.signal?.throwIfAborted();
+        return new Response(bytes);
+      }),
+      /** Releases the readable file on success, failure or cancellation. */
+      close: async () => {
+        closed = true;
+        releasePromise ??= archive.close();
+        await releasePromise;
+      }
+    };
+  } catch (error) {
+    await closeFile();
+    throw error;
+  }
+}
+function validateArchiveEntityTag(entityTag) {
+  if (entityTag !== void 0 && entityTag !== null && !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(entityTag))
+    throw new import_core36.TileConversionError(
+      "ARCHIVE_VALIDATOR_UNSUPPORTED",
+      "Remote archives require a strong quoted ETag, or Last-Modified without an ETag; weak/malformed ETags are unsupported"
+    );
+}
+function validateArchiveResponseValidator(headers) {
+  const entityTag = headers.get("etag");
+  validateArchiveEntityTag(entityTag);
+  if (entityTag !== null) return;
+  const lastModified = headers.get("last-modified");
+  const responseDate = headers.get("date");
+  const modifiedTime = parseArchiveHttpDate(lastModified);
+  const responseTime = parseArchiveHttpDate(responseDate);
+  if (!Number.isFinite(modifiedTime) || !Number.isFinite(responseTime) || responseTime - modifiedTime < 6e4)
+    throw new import_core36.TileConversionError(
+      "ARCHIVE_VALIDATOR_UNSUPPORTED",
+      "Last-Modified archive identity requires a valid Date at least 60 seconds later; otherwise supply a strong ETag"
+    );
+}
+function parseArchiveHttpDate(value) {
+  const milliseconds = value === null ? NaN : Date.parse(value);
+  return Number.isFinite(milliseconds) && new Date(milliseconds).toUTCString() === value ? milliseconds : NaN;
+}
+
+// src/v5/i3s-selection-source.ts
+var import_core37 = require("@loaders.gl/core");
+var import_i3s4 = require("@loaders.gl/tiles-3d/i3s");
+var import_tiles_3d5 = require("@loaders.gl/tiles-3d");
+var import_core38 = require("@loaders.gl/tile-converter/v5/core");
+function createRuntime(transport, layer, header) {
+  const libraries = transport.dracoLibraryOptions;
+  const sourceUrl = new URL(transport.rootUrl);
+  sourceUrl.search = "";
+  sourceUrl.hash = "";
+  const options = {
+    modules: libraries.modules,
+    core: {
+      worker: false,
+      fetch: transport.fetcher,
+      CDN: libraries.CDN,
+      useLocalLibraries: libraries.useLocalLibraries
+    },
+    draco: { decoderProfile: libraries.decoderProfile },
+    // The injected transport owns credential scope; runtime query parameters apply to every URL.
+    i3s: { geometryMode: "source", decodeTextures: false, useCompressedTextures: false }
+  };
+  const loadResource = async (url, loader, loadOptions) => {
+    const response = await transport.fetcher(url);
+    const contextUrl = new URL(url);
+    contextUrl.search = "";
+    contextUrl.hash = "";
+    return (0, import_core37.parse)(await response.arrayBuffer(), loader, loadOptions, {
+      url: contextUrl.href,
+      fetch: transport.fetcher,
+      coreApi: import_core37.coreApi,
+      _parse: import_core37.parse
+    });
+  };
+  const source = new import_tiles_3d5.I3SSource(
+    header && layer ? {
+      ...layer,
+      root: { ...header, children: [] },
+      type: "I3S",
+      url: sourceUrl.href,
+      basePath: sourceUrl.href,
+      loader: import_i3s4.I3SLoader,
+      coreApi: import_core37.coreApi
+    } : {
+      url: sourceUrl.href,
+      loader: import_i3s4.I3SLoader,
+      coreApi: import_core37.coreApi,
+      resolver: { loadRoot: loadResource, loadResource }
+    },
+    options
+  );
+  source.coreApi = { ...import_core37.coreApi, load: loadResource };
+  return new import_tiles_3d5.Tileset3D(source, { i3s: options.i3s });
+}
+async function inspectI3SMeshConversionSource(options) {
+  const { signal } = options;
+  validateSelectionOptions(options);
+  signal.throwIfAborted();
+  const transport = options;
+  let runtime;
+  try {
+    const response = await transport.fetcher(transport.rootUrl);
+    const layer = await response.json();
+    if (!["3DObject", "IntegratedMesh"].includes(layer.layerType))
+      throw new Error("Conversion accepts I3S 3DObject or IntegratedMesh layers.");
+    const rootFetcher = transport.fetcher;
+    const cachedFetcher = (url, options2) => {
+      const requestUrl = new URL(url instanceof Request ? url.url : String(url));
+      const root = new URL(transport.rootUrl);
+      return requestUrl.origin === root.origin && requestUrl.pathname === root.pathname ? Promise.resolve(new Response(JSON.stringify(layer))) : rootFetcher(url, options2);
+    };
+    runtime = createRuntime({ ...transport, fetcher: cachedFetcher });
+    await runtime.tilesetInitializationPromise;
+    await createI3SMeshTilesetConversionSource(runtime).inspect(signal);
+    const stack = [runtime.root];
+    const identifiers = /* @__PURE__ */ new Set();
+    const resources = [];
+    while (stack.length) {
+      signal.throwIfAborted();
+      const tile = stack.pop();
+      if (!["string", "number"].includes(typeof tile.header.id) || String(tile.header.id).length === 0)
+        throw new Error("I3S nodes require a declared identity.");
+      const identifier = String(tile.header.id);
+      if (identifiers.has(identifier))
+        throw new Error("Repeated I3S node identity is unsupported.");
+      identifiers.add(identifier);
+      if (identifiers.size + stack.length + (tile.header.children?.length ?? 0) > (options.maxInputResources ?? SELECTED_MESH_LIMITS.maxInputResources))
+        throw new Error("I3S inspection exceeds the 1,000 node limit.");
+      await runtime.source.loadTileChildrenForTraversal(tile, signal);
+      if (!tile.children.length && tile.contentUrl)
+        resources.push({
+          resourceId: identifier,
+          uri: tile.contentUrl,
+          header: structuredClone(tile.header)
+        });
+      for (const child of [...tile.children].reverse()) stack.push(child);
+    }
+    signal.throwIfAborted();
+    if (!resources.length) throw new Error("No supported leaf mesh nodes are declared.");
+    return {
+      kind: "i3s",
+      rootUrl: transport.rootUrl,
+      layer,
+      resources,
+      metadataBytes: 0
+    };
+  } finally {
+    runtime?.destroy();
+  }
+}
+async function createSelectedI3SMeshConversionSource(inspection, options) {
+  const { resourceIds, signal, features } = options;
+  validateSelectionOptions(options);
+  signal.throwIfAborted();
+  if (inspection.rootUrl !== options.rootUrl)
+    throw new import_core38.TileConversionError(
+      "INVALID_I3S_SELECTION",
+      "Selection transport must match the inspected layer"
+    );
+  if (!resourceIds.length || resourceIds.length > SELECTED_MESH_LIMITS.maxSelectedResources || new Set(resourceIds).size !== resourceIds.length || resourceIds.some(
+    (identifier) => !inspection.resources.some((resource) => resource.resourceId === identifier)
+  ))
+    throw new Error("Select between 1 and 64 distinct leaf mesh nodes.");
+  const selected = inspection.resources.filter(
+    (resource) => resourceIds.includes(resource.resourceId)
+  );
+  if (selected.some(
+    (resource) => resource.header.children?.length || !resource.header.contentUrl || resource.uri !== resource.header.contentUrl
+  ))
+    throw new Error("Only inspected leaf mesh headers can be converted.");
+  const transport = options;
+  let decodedBytes = 0;
+  let meshCount = 0;
+  {
+    const qualification = createRuntime(transport, inspection.layer, selected[0].header);
+    let spatialContext;
+    try {
+      await qualification.tilesetInitializationPromise;
+      const metadata = await createI3SMeshTilesetConversionSource(qualification).inspect(signal);
+      spatialContext = (0, import_core38.createI3SConversionSpatialContext)(metadata.spatialReference, {
+        targetCrs: "EPSG:4978"
+      });
+    } finally {
+      qualification.destroy();
+    }
+    const source = {
+      /** Reuses only immutable inspected declarations. */
+      inspect: async () => inspection,
+      /** Releases each dedicated node runtime before moving on or closing early. */
+      async *read() {
+        for (const descriptor of selected) {
+          const runtime = createRuntime(transport, inspection.layer, descriptor.header);
+          try {
+            await runtime.tilesetInitializationPromise;
+            const meshSource = createI3SMeshTilesetConversionSource(runtime, {
+              unloadContent: true,
+              features,
+              readExternalResource: async (uri) => new Uint8Array(
+                await (await transport.fetcher(runtime.source.getTileUrl(uri))).arrayBuffer()
+              )
+            });
+            const metadata = await meshSource.inspect(signal);
+            for await (const resource of meshSource.read(metadata, signal)) {
+              decodedBytes += measureMeshBytes(resource);
+              if (++meshCount > SELECTED_MESH_LIMITS.maxMeshResources || decodedBytes > (options.maxInputBytes ?? SELECTED_MESH_LIMITS.maxInputBytes))
+                throw new import_core38.TileConversionError(
+                  "INPUT_RESOURCE_TOO_LARGE",
+                  "Selected I3S decoded resources exceed the input/mesh budget"
+                );
+              yield { ...resource, id: descriptor.resourceId };
+            }
+          } finally {
+            runtime.destroy();
+          }
+        }
+      }
+    };
+    return { source, spatialContext };
+  }
+}
+function validateSelectionOptions(options) {
+  for (const [value, maximum] of [
+    [
+      options.maxInputBytes ?? SELECTED_MESH_LIMITS.maxInputBytes,
+      SELECTED_MESH_LIMITS.maxInputBytes
+    ],
+    [
+      options.maxInputResources ?? SELECTED_MESH_LIMITS.maxInputResources,
+      SELECTED_MESH_LIMITS.maxInputResources
+    ]
+  ])
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+      throw new import_core38.TileConversionError(
+        "INVALID_I3S_SELECTION_LIMIT",
+        "I3S selection limits must be positive safe integers within the bounded profile"
+      );
+}