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

package/dist/v5/adapters.cjs

@@ -25,6 +25,7 @@ __export(adapters_exports, {
   convertPointCloudSource: () => convertPointCloudSource,
   convertPointCloudToPotree: () => convertPointCloudToPotree,
   convertPointCloudToTileset: () => convertPointCloudToTileset,
+  createCOPCConversionCodec: () => createCOPCConversionCodec,
   createI3SMeshConversionCodec: () => createI3SMeshConversionCodec,
   createI3SMeshSink: () => createI3SMeshSink,
   createI3SMeshTilesetConversionSource: () => createI3SMeshTilesetConversionSource,
@@ -43,6 +44,7 @@ __export(adapters_exports, {
   createTileConversionArchiveTransport: () => createTileConversionArchiveTransport,
   createTileConversionResourceFetcher: () => createTileConversionResourceFetcher,
   encodeMeshTile: () => encodeMeshTile,
+  encodePointCloudCOPC: () => encodePointCloudCOPC,
   encodePointCloudSource: () => encodePointCloudSource,
   encodePointCloudSourceTile: () => encodePointCloudSourceTile,
   encodePointCloudTile: () => encodePointCloudTile,
@@ -51,6 +53,7 @@ __export(adapters_exports, {
   encodeTileConversionArchiveInBatches: () => encodeTileConversionArchiveInBatches,
   extractMeshVertices: () => extractMeshVertices,
   inspectI3SMeshConversionSource: () => inspectI3SMeshConversionSource,
+  mapPointCloudAttributes: () => mapPointCloudAttributes,
   measureMeshBytes: () => measureMeshBytes,
   openPointCloudFile: () => openPointCloudFile,
   openTileConversionArchive: () => openTileConversionArchive,
@@ -59,7 +62,7 @@ __export(adapters_exports, {
 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";
@@ -381,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;
@@ -645,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();
@@ -655,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",
@@ -669,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(
@@ -780,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,
@@ -904,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;
@@ -1458,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
@@ -1601,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",
@@ -1945,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);
@@ -1981,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;
@@ -2004,16 +2007,18 @@ async function createSingleMeshTilesetArchive(files, options) {
 
 // src/v5/mesh-source.ts
 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;
@@ -2023,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",
@@ -2048,7 +2053,7 @@ function mapMeshSourceTexture(textureInfo) {
     minFilter: sampler.minFilter
   } : void 0;
   return {
-    ...mapMeshSourceImage(image),
+    ...mapMeshSourceImage(gltf, image),
     ...hasTransform ? {
       transform: {
         offset: transform.offset,
@@ -2059,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]) {
@@ -2081,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",
@@ -2103,16 +2112,39 @@ 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 = {
@@ -2198,9 +2230,9 @@ function createMeshSourceFeatureOptions(gltf, options) {
 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_core18.TileConversionError(
         "MESH_FEATURE_MAPPING_REQUIRED",
@@ -2218,37 +2250,38 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
       "MESH_FEATURE_CLASS_REQUIRED",
       "Feature metadata class must be explicit"
     );
-  const mapping = "schema" in options ? options : createMeshSourceFeatureOptions(gltf, options);
+  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)
+    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)
+    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)
+    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;
-    if (!Number.isSafeInteger(count) || count <= 0 || count > mesh.attributes.POSITION.value.length / 3) {
+    if (!Number.isSafeInteger(count) || count <= 0 || count > 4294967295) {
       throw new import_core18.TileConversionError(
         "MESH_FEATURE_IDS_INVALID",
-        "Feature row count exceeds the available mesh vertices"
+        "Feature row count must fit uint32 indices"
       );
     }
-    properties = {};
+    properties = /* @__PURE__ */ Object.create(null);
     const classProperties = metadata.schema?.classes?.[table.class]?.properties;
     if (!classProperties)
       throw new import_core18.TileConversionError(
@@ -2281,9 +2314,10 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
         );
       }
       const defaultValue = integer64 && property.default !== void 0 ? BigInt(property.default) : property.default ?? null;
-      const decoded = data ?? Array.from({ length: count }, () => defaultValue);
+      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;
@@ -2293,10 +2327,9 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
           `Property ${name} requires a valid decoded noData mapping`
         );
       const comparable = integer64 ? BigInt(sentinel) : sentinel;
-      properties[name] = Array.from(
-        decoded,
-        (value) => value === comparable ? defaultValue : value
-      );
+      const values = decoded;
+      properties[name] = values;
+      propertyMappings.set(name, { noData: comparable, defaultValue });
     }
   } else {
     if (metadata)
@@ -2307,14 +2340,32 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
     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
-  ))
+  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
@@ -2327,39 +2378,70 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
     if (!values || !Array.isArray(values) && !ArrayBuffer.isView(values) || values.length !== count)
       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])
+  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]])
-      )
-    })),
-    mapping
-  );
   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)
+  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,
@@ -2418,7 +2500,8 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
               "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)
           )) {
@@ -2444,19 +2527,20 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
             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_core19.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);
+          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_core20.TileConversionError(
               "MESH_SOURCE_SCENE_UNSUPPORTED",
               "A default scene or exactly one scene is required"
             );
           let primitiveIndex = 0;
-          const primitives = traverseMeshNodes(roots, placement);
+          const primitives = traverseMeshNodes(gltfWithBuffers, roots, placement);
           let current = primitives.next();
           while (!current.done) {
             const selected = current.value;
             const next = primitives.next();
             const resource = await extractPrimitive(
+              gltfWithBuffers,
               selected.primitive,
               selected.transform,
               `${item.tile.id}/${content.index}/${primitiveIndex++}`,
@@ -2465,7 +2549,7 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
               signal
             );
             const features = extractMeshFeatures(
-              gltf,
+              gltfWithBuffers,
               selected.primitive,
               payload,
               resource.mesh,
@@ -2488,9 +2572,10 @@ 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)
+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"
@@ -2498,18 +2583,24 @@ function* traverseMeshNodes(nodes, parent, ancestors = /* @__PURE__ */ new Set()
     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)
+    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_core20.TileConversionError(
       "MESH_SOURCE_PRIMITIVE_UNSUPPORTED",
@@ -2521,7 +2612,8 @@ async function extractPrimitive(primitive, transform, id, readExternalResource,
       "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_core20.TileConversionError(
@@ -2529,17 +2621,17 @@ async function extractPrimitive(primitive, transform, id, readExternalResource,
         `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
   );
@@ -2577,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(
@@ -2609,6 +2702,7 @@ async function mapMeshSourceMaterial(material, readExternalResource, contentUri,
     baseColorFactor: pbr?.baseColorFactor,
     ..."baseColorTexture" in (pbr || {}) ? {
       baseColorTexture: await resolveMeshSourceTexture(
+        gltf,
         pbr.baseColorTexture,
         readExternalResource,
         contentUri,
@@ -2622,13 +2716,14 @@ 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) {
@@ -2640,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;
   }
@@ -2650,7 +2746,7 @@ function createTriangleIndices(primitive, vertexCount) {
 }
 
 // src/v5/i3s-mesh-conversion.ts
-var import_i3s = require("@loaders.gl/i3s");
+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) {
@@ -3264,6 +3360,7 @@ var import_core28 = require("@loaders.gl/tile-converter/v5/core");
 var import_images3 = require("@loaders.gl/images");
 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)
   );
@@ -3330,7 +3427,7 @@ 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)) {
+    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"
@@ -3339,19 +3436,24 @@ 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_core26.TileConversionError(
@@ -3363,7 +3465,7 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
 }
 
 // src/v5/i3s-mesh-source-features.ts
-var import_i3s2 = require("@loaders.gl/i3s");
+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;
@@ -3691,19 +3793,267 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
   };
 }
 
-// src/v5/point-cloud-tileset.ts
-var import_point_cloud_tile_source = require("@loaders.gl/tiles/point-cloud-tile-source");
+// 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_core29.TileConversionError(
+    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_core29.TileConversionError(
+    throw new import_core31.TileConversionError(
       "INVALID_ARCHIVE_BYTE_LIMIT",
       "Archive byte limit must be a non-negative safe integer"
     );
@@ -3754,10 +4104,10 @@ async function convertPointCloudToTileset(input, options) {
 }
 
 // src/v5/point-cloud-file.ts
-var import_copc = require("@loaders.gl/copc");
-var import_potree = require("@loaders.gl/potree");
-var import_schema_utils5 = require("@loaders.gl/schema-utils");
-var import_zip = require("@loaders.gl/zip");
+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 });
@@ -3782,7 +4132,7 @@ async function openPointCloudFile(input, options) {
   if (input.size > options.maxFileBytes) throw new RangeError("Point file input budget exceeded");
   options.signal?.throwIfAborted();
   if (options.format === "copc") {
-    const source2 = import_copc.COPCSourceLoader.createDataSource(input, options.sourceOptions || {});
+    const source2 = import_copc2.COPCSourceLoader.createDataSource(input, options.sourceOptions || {});
     try {
       await source2.metadata;
       options.signal?.throwIfAborted();
@@ -3899,7 +4249,7 @@ function extractMeshVertices(mesh, options) {
       throw new Error(`Invalid selected mesh vertex attribute: ${name}`);
     attributes[name] = attribute;
   }
-  return { topology: "point-list", mode: 0, attributes, schema: (0, import_schema_utils5.deduceMeshSchema)(attributes) };
+  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 === ".."))
@@ -3911,8 +4261,8 @@ function validateLimit(value) {
 }
 
 // src/v5/point-cloud-potree.ts
-var import_schema_utils6 = require("@loaders.gl/schema-utils");
-var import_potree2 = require("@loaders.gl/potree");
+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");
@@ -3930,7 +4280,7 @@ async function convertPointCloudToPotree(input, options) {
     throw new RangeError("Potree authoring requires gathered and encoded byte limits");
   }
   options.signal?.throwIfAborted();
-  const tiler = new import_schema_utils6.PointCloudTiler(input, {
+  const tiler = new import_schema_utils7.PointCloudTiler(input, {
     ...options.tiling,
     maxNodes: Math.min(options.tiling?.maxNodes ?? 1e5, options.potree?.maxNodes ?? 1e5),
     maxTileBytes: Math.min(
@@ -3982,12 +4332,12 @@ async function convertPointCloudToPotree(input, options) {
 }
 
 // src/v5/mesh-hierarchy.ts
-var import_core30 = require("@math.gl/core");
-var import_tiles3 = require("@loaders.gl/tiles");
-var import_core31 = require("@loaders.gl/tile-converter/v5/core");
+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_core31.TileConversionError("MESH_HIERARCHY_UNSUPPORTED", message);
+    throw new import_core33.TileConversionError("MESH_HIERARCHY_UNSUPPORTED", message);
   };
   if (!inspection.documents?.length || inspection.documents.length > 32)
     rejectHierarchy(
@@ -3997,7 +4347,7 @@ function prepareMeshHierarchy(inspection, resourceIds) {
     rejectHierarchy(
       "Hierarchy preservation requires every content placement, without duplicates (at most 64)"
     );
-  const entryTransform = new import_core30.Matrix4();
+  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);
@@ -4022,9 +4372,9 @@ function prepareMeshHierarchy(inspection, resourceIds) {
       rejectHierarchy("Dataset geometricError must be finite nonnegative meters");
   }
   const spatialReferences = documents.map(
-    (document2) => (0, import_tiles3.get3DTilesSpatialReference)(document2)
+    (document2) => (0, import_tiles_3d3.get3DTilesSpatialReference)(document2)
   );
-  const spatialReference = (0, import_core31.createTiles3DConversionSpatialContext)(
+  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"))
@@ -4033,7 +4383,7 @@ function prepareMeshHierarchy(inspection, resourceIds) {
     );
   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_core31.createTiles3DConversionSpatialContext)(inherited ? spatialReference : reference);
+    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");
   }
@@ -4046,7 +4396,7 @@ function prepareMeshHierarchy(inspection, resourceIds) {
       prefix: "",
       path: [],
       parent: -1,
-      transform: new import_core30.Matrix4(),
+      transform: new import_core32.Matrix4(),
       refine: void 0
     }
   ];
@@ -4072,7 +4422,7 @@ function prepareMeshHierarchy(inspection, resourceIds) {
     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_core30.Matrix4(parentTransform).multiplyRight(matrix ?? new import_core30.Matrix4());
+    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)
     );
@@ -4167,11 +4517,11 @@ function createMeshHierarchyTilesetSink(options) {
   );
   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_core31.TileConversionError(
+    throw new import_core33.TileConversionError(
       "MESH_GEOMETRIC_ERROR_INVALID",
       "Hierarchy position allowance and resulting errors must be finite nonnegative meters"
     );
-  const memory = (0, import_core31.createBoundedMemoryTileConversionSink)(options);
+  const memory = (0, import_core33.createBoundedMemoryTileConversionSink)(options);
   const placements = /* @__PURE__ */ new Map();
   const completedContents = /* @__PURE__ */ new Set();
   const primitiveIdentifiers = /* @__PURE__ */ new Set();
@@ -4189,12 +4539,12 @@ function createMeshHierarchyTilesetSink(options) {
         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_core31.TileConversionError(
+        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_core31.TileConversionError(
+        throw new import_core33.TileConversionError(
           "MESH_SOURCE_EPOCH_MISMATCH",
           "Hierarchy output coordinate epoch must match its source"
         );
@@ -4203,7 +4553,7 @@ function createMeshHierarchyTilesetSink(options) {
       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_core31.TileConversionError(
+        throw new import_core33.TileConversionError(
           "MESH_HIERARCHY_PLACEMENT_INVALID",
           "Contents on one tile must share an encoded origin"
         );
@@ -4230,7 +4580,7 @@ function createMeshHierarchyTilesetSink(options) {
     /** 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_core31.TileConversionError(
+        throw new import_core33.TileConversionError(
           "MESH_HIERARCHY_INCOMPLETE",
           "Finalization requires every declared hierarchy content"
         );
@@ -4239,7 +4589,7 @@ function createMeshHierarchyTilesetSink(options) {
       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_core30.Matrix4(placement.transform) : new import_core30.Matrix4();
+        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];
@@ -4268,12 +4618,12 @@ function createMeshHierarchyTilesetSink(options) {
             maximum[axis] = Math.max(maximum[axis], upper[axis]);
           }
         if ([...minimum, ...maximum].some((value) => !Number.isFinite(value)))
-          throw new import_core31.TileConversionError(
+          throw new import_core33.TileConversionError(
             "MESH_TILESET_BOUNDS_INVALID",
             "Hierarchy absolute bounds must remain finite"
           );
         bounds[index] = [minimum, maximum];
-        const inverse = new import_core30.Matrix4(transforms[index]).invert();
+        const inverse = new import_core32.Matrix4(transforms[index]).invert();
         const center = Array.from(
           inverse.transformAsPoint(minimum.map((value, axis) => value / 2 + maximum[axis] / 2))
         );
@@ -4286,7 +4636,7 @@ function createMeshHierarchyTilesetSink(options) {
           )
         );
         if ([...center, ...halfAxes].some((value) => !Number.isFinite(value)))
-          throw new import_core31.TileConversionError(
+          throw new import_core33.TileConversionError(
             "MESH_TILESET_BOUNDS_INVALID",
             "Hierarchy local bounds must remain finite"
           );
@@ -4299,10 +4649,10 @@ function createMeshHierarchyTilesetSink(options) {
           ...node.children.length ? {
             children: node.children.map((child) => {
               tiles[child].transform = Array.from(
-                new import_core30.Matrix4(inverse).multiplyRight(transforms[child])
+                new import_core32.Matrix4(inverse).multiplyRight(transforms[child])
               );
               if (tiles[child].transform.some((value) => !Number.isFinite(value)))
-                throw new import_core31.TileConversionError(
+                throw new import_core33.TileConversionError(
                   "MESH_TILESET_BOUNDS_INVALID",
                   "Relative hierarchy transforms must remain finite"
                 );
@@ -4340,10 +4690,10 @@ function createMeshHierarchyTilesetSink(options) {
 }
 
 // src/v5/selected-mesh-source.ts
-var import_core32 = require("@loaders.gl/core");
-var import_d_tiles2 = require("@loaders.gl/3d-tiles");
-var import_tiles4 = require("@loaders.gl/tiles");
-var import_core33 = require("@loaders.gl/tile-converter/v5/core");
+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. */
@@ -4372,7 +4722,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
   } = options;
   const maxInputBytes = options.maxInputBytes ?? SELECTED_MESH_LIMITS.maxInputBytes;
   if (!Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1 || maxInputBytes > SELECTED_MESH_LIMITS.maxInputBytes)
-    throw new import_core33.TileConversionError(
+    throw new import_core35.TileConversionError(
       "INVALID_SELECTED_MESH_OPTIONS",
       "Selected mesh input budget must be a positive safe integer at most 16 MiB"
     );
@@ -4381,7 +4731,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
   ))
     throw new Error("Select between 1 and 64 distinct content placements.");
   if (preserveHierarchy !== void 0 && typeof preserveHierarchy !== "boolean")
-    throw new import_core33.TileConversionError(
+    throw new import_core35.TileConversionError(
       "MESH_HIERARCHY_UNSUPPORTED",
       "preserveHierarchy must be a boolean"
     );
@@ -4390,7 +4740,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
     (resource) => resourceIds.includes(resource.resourceId)
   );
   const selections = descriptors.map(
-    (descriptor) => (0, import_core33.selectBrowserTilesetContent)(inspection, descriptor)
+    (descriptor) => (0, import_core35.selectBrowserTilesetContent)(inspection, descriptor)
   );
   const selectedContents = new Map(
     descriptors.map((descriptor, index) => [descriptor.resourceId, selections[index]])
@@ -4418,11 +4768,11 @@ async function createSelectedMeshConversionSource(inspection, options) {
   try {
     await qualification.tilesetInitializationPromise;
     const metadata = await (0, import_adapters.createMeshTilesetConversionSource)(qualification).inspect(signal);
-    spatialContext = (0, import_core33.createTiles3DConversionSpatialContext)(metadata.spatialReference);
+    spatialContext = (0, import_core35.createTiles3DConversionSpatialContext)(metadata.spatialReference);
   } finally {
     qualification.destroy();
   }
-  const rawSource = options.source ?? (0, import_core33.createBrowserTilesetConversionSource)({
+  const rawSource = options.source ?? (0, import_core35.createBrowserTilesetConversionSource)({
     input: inspection.rootUrl,
     ...SELECTED_MESH_LIMITS,
     maxInputBytes,
@@ -4446,7 +4796,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
       for await (const raw of rawSource.read(selectedInspection, signal2)) {
         const selection = selectedContents.get(raw.resourceId);
         if (!selection)
-          throw new import_core33.TileConversionError(
+          throw new import_core35.TileConversionError(
             "INVALID_BROWSER_SELECTION",
             "Source yielded an uninspected content placement"
           );
@@ -4473,9 +4823,9 @@ async function createSelectedMeshConversionSource(inspection, options) {
             }
           });
           const metadata = await meshSource.inspect(signal2);
-          const selectedContext = (0, import_core33.createTiles3DConversionSpatialContext)(metadata.spatialReference);
+          const selectedContext = (0, import_core35.createTiles3DConversionSpatialContext)(metadata.spatialReference);
           if (selectedContext.spatialReference.coordinateEpoch !== spatialContext.spatialReference.coordinateEpoch)
-            throw new import_core33.TileConversionError(
+            throw new import_core35.TileConversionError(
               "MESH_SOURCE_EPOCH_MISMATCH",
               "Selected content coordinate epoch must match the root; epoch transformations are unsupported"
             );
@@ -4486,7 +4836,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
               throw new Error("Selected contents exceed the mesh primitive placement limit.");
             decodedBytes += measureMeshBytes(resource);
             if (decodedBytes > maxInputBytes)
-              throw new import_core33.TileConversionError(
+              throw new import_core35.TileConversionError(
                 "INPUT_RESOURCE_TOO_LARGE",
                 "Selected decoded geometry and encoded images exceed the aggregate input byte limit."
               );
@@ -4513,7 +4863,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
     geometricError: Math.max(...selections.map((selection) => selection.geometricError)) + SELECTED_MESH_LIMITS.maxPositionError
   };
 }
-var SelectedTiles3DSource = class extends import_tiles4.Tiles3DSource {
+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. */
@@ -4560,23 +4910,23 @@ function createSelectedRuntime(document, data, signal, boundedFetcher, contentUr
     },
     "3d-tiles": { loadGLTF: true }
   };
-  return new import_tiles4.Tileset3D(
+  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_core32.parse)(new TextEncoder().encode(JSON.stringify(document)), loader, options),
+          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_core32.parse)(data, loader, options, {
+            return (0, import_core34.parse)(data, loader, options, {
               url: contentUrl,
               baseUrl: contentUrl.startsWith("blob:") ? contentUrl : new URL(".", contentUrl).href,
               fetch: boundedFetcher,
-              coreApi: import_core32.coreApi,
-              _parse: import_core32.parse
+              coreApi: import_core34.coreApi,
+              _parse: import_core34.parse
             });
           }
         }
@@ -4601,14 +4951,14 @@ function measureMeshBytes(resource) {
 }
 
 // src/v5/archive-source.ts
-var import_loader_utils = require("@loaders.gl/loader-utils");
-var import_i3s3 = require("@loaders.gl/i3s");
-var import_d_tiles3 = require("@loaders.gl/3d-tiles");
-var import_core34 = require("@loaders.gl/tile-converter/v5/core");
+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_core34.TileConversionError("INVALID_ARCHIVE_SOURCE", "Select SLPK or 3TZ archive input");
+    throw new import_core36.TileConversionError("INVALID_ARCHIVE_SOURCE", "Select SLPK or 3TZ archive input");
   validateArchiveEntityTag(descriptor.identity?.etag);
   const transport = createTileConversionResourceFetcher({
     maxInputBytes,
@@ -4675,12 +5025,12 @@ async function createTileConversionArchiveTransport(file, format, maxInputBytes,
   const checkOpen = () => {
     signal.throwIfAborted();
     if (closed)
-      throw new import_core34.TileConversionError("ARCHIVE_SOURCE_CLOSED", "Conversion archive is 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_core34.TileConversionError(
+      throw new import_core36.TileConversionError(
         "INVALID_ARCHIVE_SOURCE",
         "Archive source requires a supported format and positive safe byte budget"
       );
@@ -4698,7 +5048,7 @@ async function createTileConversionArchiveTransport(file, format, maxInputBytes,
       read: async (start, length) => {
         checkOpen();
         if (!Number.isSafeInteger(length) || length < 0 || length > maxInputBytes - readBytes)
-          throw new import_core34.TileConversionError(
+          throw new import_core36.TileConversionError(
             "INPUT_RESOURCE_TOO_LARGE",
             "Archive indexed reads exceed the input budget"
           );
@@ -4747,7 +5097,7 @@ async function createTileConversionArchiveTransport(file, format, maxInputBytes,
 }
 function validateArchiveEntityTag(entityTag) {
   if (entityTag !== void 0 && entityTag !== null && !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(entityTag))
-    throw new import_core34.TileConversionError(
+    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"
     );
@@ -4761,7 +5111,7 @@ function validateArchiveResponseValidator(headers) {
   const modifiedTime = parseArchiveHttpDate(lastModified);
   const responseTime = parseArchiveHttpDate(responseDate);
   if (!Number.isFinite(modifiedTime) || !Number.isFinite(responseTime) || responseTime - modifiedTime < 6e4)
-    throw new import_core34.TileConversionError(
+    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"
     );
@@ -4772,10 +5122,10 @@ function parseArchiveHttpDate(value) {
 }
 
 // src/v5/i3s-selection-source.ts
-var import_core35 = require("@loaders.gl/core");
-var import_i3s4 = require("@loaders.gl/i3s");
-var import_tiles5 = require("@loaders.gl/tiles");
-var import_core36 = require("@loaders.gl/tile-converter/v5/core");
+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);
@@ -4798,14 +5148,14 @@ function createRuntime(transport, layer, header) {
     const contextUrl = new URL(url);
     contextUrl.search = "";
     contextUrl.hash = "";
-    return (0, import_core35.parse)(await response.arrayBuffer(), loader, loadOptions, {
+    return (0, import_core37.parse)(await response.arrayBuffer(), loader, loadOptions, {
       url: contextUrl.href,
       fetch: transport.fetcher,
-      coreApi: import_core35.coreApi,
-      _parse: import_core35.parse
+      coreApi: import_core37.coreApi,
+      _parse: import_core37.parse
     });
   };
-  const source = new import_tiles5.I3SSource(
+  const source = new import_tiles_3d5.I3SSource(
     header && layer ? {
       ...layer,
       root: { ...header, children: [] },
@@ -4813,17 +5163,17 @@ function createRuntime(transport, layer, header) {
       url: sourceUrl.href,
       basePath: sourceUrl.href,
       loader: import_i3s4.I3SLoader,
-      coreApi: import_core35.coreApi
+      coreApi: import_core37.coreApi
     } : {
       url: sourceUrl.href,
       loader: import_i3s4.I3SLoader,
-      coreApi: import_core35.coreApi,
+      coreApi: import_core37.coreApi,
       resolver: { loadRoot: loadResource, loadResource }
     },
     options
   );
-  source.coreApi = { ...import_core35.coreApi, load: loadResource };
-  return new import_tiles5.Tileset3D(source, { i3s: options.i3s });
+  source.coreApi = { ...import_core37.coreApi, load: loadResource };
+  return new import_tiles_3d5.Tileset3D(source, { i3s: options.i3s });
 }
 async function inspectI3SMeshConversionSource(options) {
   const { signal } = options;
@@ -4886,7 +5236,7 @@ async function createSelectedI3SMeshConversionSource(inspection, options) {
   validateSelectionOptions(options);
   signal.throwIfAborted();
   if (inspection.rootUrl !== options.rootUrl)
-    throw new import_core36.TileConversionError(
+    throw new import_core38.TileConversionError(
       "INVALID_I3S_SELECTION",
       "Selection transport must match the inspected layer"
     );
@@ -4910,7 +5260,7 @@ async function createSelectedI3SMeshConversionSource(inspection, options) {
     try {
       await qualification.tilesetInitializationPromise;
       const metadata = await createI3SMeshTilesetConversionSource(qualification).inspect(signal);
-      spatialContext = (0, import_core36.createI3SConversionSpatialContext)(metadata.spatialReference, {
+      spatialContext = (0, import_core38.createI3SConversionSpatialContext)(metadata.spatialReference, {
         targetCrs: "EPSG:4978"
       });
     } finally {
@@ -4936,7 +5286,7 @@ async function createSelectedI3SMeshConversionSource(inspection, options) {
             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_core36.TileConversionError(
+                throw new import_core38.TileConversionError(
                   "INPUT_RESOURCE_TOO_LARGE",
                   "Selected I3S decoded resources exceed the input/mesh budget"
                 );
@@ -4963,7 +5313,7 @@ function validateSelectionOptions(options) {
     ]
   ])
     if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
-      throw new import_core36.TileConversionError(
+      throw new import_core38.TileConversionError(
         "INVALID_I3S_SELECTION_LIMIT",
         "I3S selection limits must be positive safe integers within the bounded profile"
       );