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

package/dist/v5/adapters.js

@@ -1,5 +1,5 @@
 // src/v5/feature-arrow.ts
-import { ArrowTableBuilder } from "@loaders.gl/schema-utils";
+import { ArrowTableBuilder } from "@loaders.gl/core/schema-utils";
 import { TileConversionError } from "@loaders.gl/tile-converter/v5/core";
 var DEFAULT_FEATURE_ID_FIELD = "feature_id";
 var FEATURE_CLASS_METADATA_KEY = "loaders.gl:feature-class";
@@ -321,8 +321,8 @@ function isBinaryType(dataType) {
 }
 
 // src/v5/point-cloud.ts
-import { Tile3DWriter, TILE3D_TYPE } from "@loaders.gl/3d-tiles";
-import { convertTableToMesh } from "@loaders.gl/schema-utils";
+import { Tile3DWriter, TILE3D_TYPE } from "@loaders.gl/tiles-3d/3d-tiles";
+import { convertTableToMesh } from "@loaders.gl/core/schema-utils";
 import { TileConversionError as TileConversionError2 } from "@loaders.gl/tile-converter/v5/core";
 function encodePointCloudTile(pointBatch, options = {}) {
   return encodePointCloudTileWithMetadata(pointBatch, options).pnts;
@@ -585,8 +585,8 @@ function validateBatchTable(batchTableJson, batchIds) {
 
 // src/v5/point-cloud-spatial.ts
 import { Matrix4 } from "@math.gl/core";
-import { getSpatialCoordinateFrame, createTilesetSpatialReference } from "@loaders.gl/tiles";
-import { convertTableToMesh as convertTableToMesh2, makeMeshArrowTable } from "@loaders.gl/schema-utils";
+import { getSpatialCoordinateFrame, createTilesetSpatialReference } from "@loaders.gl/tiles-3d";
+import { convertTableToMesh as convertTableToMesh2, makeMeshArrowTable } from "@loaders.gl/core/schema-utils";
 import { TileConversionError as TileConversionError3 } from "@loaders.gl/tile-converter/v5/core";
 async function transformPointCloudSourceTile(sourceTile, options) {
   options.signal?.throwIfAborted();
@@ -844,7 +844,7 @@ import { GLTFScenegraph, GLTFWriter } from "@loaders.gl/gltf";
 import { getBinaryImageMetadata } from "@loaders.gl/images";
 
 // src/v5/mesh-features.ts
-import { convertArrowToSchema } from "@loaders.gl/schema-utils";
+import { convertArrowToSchema } from "@loaders.gl/core/schema-utils";
 import { TileConversionError as TileConversionError5 } from "@loaders.gl/tile-converter/v5/core";
 function prepareMeshFeatureGeometry(mesh, features) {
   if (!features) return mesh;
@@ -1398,7 +1398,7 @@ function validateMeshTextureTransform(transform) {
 }
 
 // src/v5/mesh-conversion.ts
-import { getSpatialCoordinateFrame as getSpatialCoordinateFrame2 } from "@loaders.gl/tiles";
+import { getSpatialCoordinateFrame as getSpatialCoordinateFrame2 } from "@loaders.gl/tiles-3d";
 import { TileConversionError as TileConversionError8 } from "@loaders.gl/tile-converter/v5/core";
 
 // src/v5/mesh-draco.ts
@@ -1888,8 +1888,8 @@ function createMeshTilesetSink(options) {
 import {
   Tiles3DArchiveWriter,
   encodeTiles3DArchiveInBatches
-} from "@loaders.gl/3d-tiles/3d-tiles-archive-writer";
-import { SLPKWriter, encodeSLPKArchiveInBatches } from "@loaders.gl/i3s/i3s-slpk-writer";
+} from "@loaders.gl/tiles-3d/3d-tiles/3d-tiles-archive-writer";
+import { SLPKWriter, encodeSLPKArchiveInBatches } from "@loaders.gl/tiles-3d/i3s/i3s-slpk-writer";
 import { TileConversionError as TileConversionError10 } from "@loaders.gl/tile-converter/v5/core";
 async function createTileConversionArchive(files, options) {
   const { resources, format, maxArchiveBytes, signal } = prepareArchiveInput(files, options);
@@ -1924,7 +1924,7 @@ function prepareArchiveInput(files, options) {
 }
 
 // src/v5/mesh-tileset-archive.ts
-import { Tiles3DArchiveWriter as Tiles3DArchiveWriter2 } from "@loaders.gl/3d-tiles/3d-tiles-archive-writer";
+import { Tiles3DArchiveWriter as Tiles3DArchiveWriter2 } from "@loaders.gl/tiles-3d/3d-tiles/3d-tiles-archive-writer";
 import { TileConversionError as TileConversionError11 } from "@loaders.gl/tile-converter/v5/core";
 async function createSingleMeshTilesetArchive(files, options) {
   const { maxArchiveBytes, signal } = options;
@@ -1947,16 +1947,18 @@ async function createSingleMeshTilesetArchive(files, options) {
 
 // src/v5/mesh-source.ts
 import { Matrix4 as Matrix42 } from "@math.gl/core";
+import { getGLTFAccessor as getGLTFAccessor2, getGLTFAccessorValue as getGLTFAccessorValue2 } from "@loaders.gl/gltf";
 import { TileConversionError as TileConversionError15 } from "@loaders.gl/tile-converter/v5/core";
 import { createTilesetConversionSource } from "@loaders.gl/tile-converter/v5/core";
 
 // src/v5/mesh-source-texture.ts
 import { getBinaryImageMetadata as getBinaryImageMetadata2 } from "@loaders.gl/images";
+import { GLTFScenegraph as GLTFScenegraph2 } from "@loaders.gl/gltf";
 import { TileConversionError as TileConversionError12 } from "@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;
@@ -1966,7 +1968,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",
@@ -1991,7 +1993,7 @@ function mapMeshSourceTexture(textureInfo) {
     minFilter: sampler.minFilter
   } : void 0;
   return {
-    ...mapMeshSourceImage(image),
+    ...mapMeshSourceImage(gltf, image),
     ...hasTransform ? {
       transform: {
         offset: transform.offset,
@@ -2002,9 +2004,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 GLTFScenegraph2(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]) {
@@ -2024,10 +2029,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 TileConversionError12(
       "MESH_SOURCE_TEXTURE_UNSUPPORTED",
@@ -2046,16 +2052,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
+import { getGLTFAccessor, getGLTFAccessorValue } from "@loaders.gl/gltf";
+
 // src/v5/mesh-source-schema.ts
 import { TileConversionError as TileConversionError13 } from "@loaders.gl/tile-converter/v5/core";
 var SCALAR_TYPES = {
@@ -2141,9 +2170,9 @@ function createMeshSourceFeatureOptions(gltf, options) {
 import { TileConversionError as TileConversionError14 } from "@loaders.gl/tile-converter/v5/core";
 function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
   const declarations = primitive.extensions?.EXT_mesh_features?.featureIds;
-  const metadata = gltf.extensions?.EXT_structural_metadata;
+  const 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 TileConversionError14(
         "MESH_FEATURE_MAPPING_REQUIRED",
@@ -2161,37 +2190,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 TileConversionError14(
         "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 TileConversionError14(
         "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 TileConversionError14(
         "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 TileConversionError14(
         "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 TileConversionError14(
@@ -2224,9 +2254,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;
@@ -2236,10 +2267,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)
@@ -2250,14 +2280,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 : getGLTFAccessor(gltf, attributeReference);
+  const attribute = accessor ? {
+    ...accessor,
+    components: accessor.type === "SCALAR" ? 1 : Number(accessor.type.slice(3)),
+    value: 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 TileConversionError14(
       "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 TileConversionError14(
+        "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 TileConversionError14(
+      "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
@@ -2270,39 +2318,70 @@ function extractMeshFeatures(gltf, primitive, payload, mesh, options) {
     if (!values || !Array.isArray(values) && !ArrayBuffer.isView(values) || values.length !== count)
       throw new TileConversionError14(
         "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 TileConversionError14(
       "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 TileConversionError14(
+      "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 TileConversionError14(
+        "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 TileConversionError14(
         "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,
@@ -2361,7 +2440,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)
           )) {
@@ -2387,19 +2467,20 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
             placement.multiplyRight(new Matrix42([1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]));
           if (axis === "X")
             placement.multiplyRight(new Matrix42([0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]));
-          const roots = gltf.scene?.nodes || (gltf.scenes?.length === 1 ? gltf.scenes[0].nodes : void 0);
+          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 TileConversionError15(
               "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++}`,
@@ -2408,7 +2489,7 @@ function createMeshTilesetConversionSource(tileset, options = {}) {
               signal
             );
             const features = extractMeshFeatures(
-              gltf,
+              gltfWithBuffers,
               selected.primitive,
               payload,
               resource.mesh,
@@ -2431,9 +2512,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 TileConversionError15(
         "MESH_SOURCE_NODE_UNSUPPORTED",
         "Cyclic, skinned, morphed, or extended nodes are unsupported"
@@ -2441,18 +2523,24 @@ function* traverseMeshNodes(nodes, parent, ancestors = /* @__PURE__ */ new Set()
     const transform = new Matrix42(parent).multiplyRight(
       node.matrix ? new Matrix42(node.matrix) : new Matrix42().translate(node.translation || [0, 0, 0]).multiplyRight(new Matrix42().fromQuaternion(node.rotation || [0, 0, 0, 1])).scale(node.scale || [1, 1, 1])
     );
-    if (node.mesh) {
-      if (node.mesh.weights || Object.keys(node.mesh.extensions || {}).length)
+    if (node.mesh !== void 0) {
+      const mesh = gltf.json.meshes[node.mesh];
+      if (mesh.weights || Object.keys(mesh.extensions || {}).length)
         throw new TileConversionError15(
           "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 TileConversionError15(
       "MESH_SOURCE_PRIMITIVE_UNSUPPORTED",
@@ -2464,7 +2552,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 = getGLTFAccessor2(gltf, reference);
     if (name === "_BATCHID" || /^_FEATURE_ID_\d+$/.test(name)) continue;
     if (!["POSITION", "NORMAL", "COLOR_0", "TEXCOORD_0"].includes(name))
       throw new TileConversionError15(
@@ -2472,17 +2561,17 @@ async function extractPrimitive(primitive, transform, id, readExternalResource,
         `Unsupported mesh attribute ${name}`
       );
     attributes[name] = {
-      value: accessor.value,
-      size: accessor.components,
+      value: getGLTFAccessorValue2(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
   );
@@ -2520,14 +2609,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(
@@ -2552,6 +2642,7 @@ async function mapMeshSourceMaterial(material, readExternalResource, contentUri,
     baseColorFactor: pbr?.baseColorFactor,
     ..."baseColorTexture" in (pbr || {}) ? {
       baseColorTexture: await resolveMeshSourceTexture(
+        gltf,
         pbr.baseColorTexture,
         readExternalResource,
         contentUri,
@@ -2565,13 +2656,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 : getGLTFAccessor2(gltf, primitive.indices);
+  const attribute = accessor ? {
+    value: getGLTFAccessorValue2(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) {
@@ -2583,9 +2675,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;
   }
@@ -2597,7 +2690,7 @@ import {
   encodeI3SMeshLayer,
   encodeI3SMeshLayerWithDraco,
   preloadI3SMeshCompression
-} from "@loaders.gl/i3s";
+} from "@loaders.gl/tiles-3d/i3s";
 import { TileConversionError as TileConversionError16 } from "@loaders.gl/tile-converter/v5/core";
 import { createBoundedMemoryTileConversionSink as createBoundedMemoryTileConversionSink2 } from "@loaders.gl/tile-converter/v5/core";
 function createI3SMeshConversionCodec(options) {
@@ -3220,6 +3313,7 @@ import {
 import { getBinaryImageMetadata as getBinaryImageMetadata3 } from "@loaders.gl/images";
 import { TileConversionError as TileConversionError20 } from "@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)
   );
@@ -3286,7 +3380,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 TileConversionError20(
         "I3S_MESH_SOURCE_TEXTURE_UNSUPPORTED",
         "I3S base-color bytes must have matching PNG/JPEG headers"
@@ -3295,19 +3389,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 TileConversionError20(
@@ -3319,7 +3418,7 @@ async function mapI3SMeshSourceMaterial(content, header, readExternalResource, c
 }
 
 // src/v5/i3s-mesh-source-features.ts
-import { I3SAttributeLoader } from "@loaders.gl/i3s";
+import { I3SAttributeLoader } from "@loaders.gl/tiles-3d/i3s";
 import { TileConversionError as TileConversionError21 } from "@loaders.gl/tile-converter/v5/core";
 async function extractI3SMeshFeatures(content, item, metadata, options, readExternalResource, contentUri, signal) {
   const maximumAttributeBytes = options.maxAttributeBytes;
@@ -3647,19 +3746,267 @@ function createI3SMeshTilesetConversionSource(tileset, options = {}) {
   };
 }
 
-// src/v5/point-cloud-tileset.ts
-import { PointCloudTileSource } from "@loaders.gl/tiles/point-cloud-tile-source";
+// src/v5/point-cloud-attributes.ts
+import { convertTableToMesh as convertTableToMesh3 } from "@loaders.gl/core/schema-utils";
 import { TileConversionError as TileConversionError23 } from "@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 TileConversionError23(
+        "POINT_CLOUD_MAPPING_INVALID",
+        `Invalid point attribute mapping ${target}: ${source}`
+      );
+    if (Object.hasOwn(mapping.drop || {}, source))
+      throw new TileConversionError23(
+        "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 TileConversionError23(
+        "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 TileConversionError23(
+      "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 TileConversionError23("POINT_CLOUD_INPUT_BUDGET", "Point input byte budget exceeded");
+  };
+  if ("shape" in input) {
+    const checkColumn = (column) => {
+      if (column.nullCount)
+        throw new TileConversionError23(
+          "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 ? convertTableToMesh3(input) : input;
+  if (mesh.topology !== "point-list" || mesh.indices)
+    throw new TileConversionError23(
+      "POINT_CLOUD_INPUT_INVALID",
+      "Decoded unindexed point-list input is required"
+    );
+  return mesh;
+}
+
+// src/v5/point-cloud-copc.ts
+import { COPCWriter } from "@loaders.gl/tiles-3d/copc";
+import { TileConversionError as TileConversionError24 } from "@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 TileConversionError24(
+      "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 TileConversionError24(
+      "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 TileConversionError24(
+      "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 TileConversionError24(
+      "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 TileConversionError24(
+        "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 TileConversionError24(
+        "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 TileConversionError24(
+        "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 TileConversionError24(
+          "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 TileConversionError24(
+            "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 TileConversionError24(
+            "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 TileConversionError24(
+          "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 TileConversionError24(
+        "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 TileConversionError24("POINT_CLOUD_BOUNDS_INVALID", "COPC coordinate extent overflow");
+  options.signal?.throwIfAborted();
+  const color = mesh.attributes.COLOR_0;
+  const 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 TileConversionError24(
+      "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
+import { PointCloudTileSource } from "@loaders.gl/tiles-3d/point-cloud-tile-source";
+import { TileConversionError as TileConversionError25 } from "@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 TileConversionError23(
+    throw new TileConversionError25(
       "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 TileConversionError23(
+    throw new TileConversionError25(
       "INVALID_ARCHIVE_BYTE_LIMIT",
       "Archive byte limit must be a non-negative safe integer"
     );
@@ -3710,10 +4057,10 @@ async function convertPointCloudToTileset(input, options) {
 }
 
 // src/v5/point-cloud-file.ts
-import { COPCSourceLoader } from "@loaders.gl/copc";
-import { PotreeSourceLoader, encodePotreeDataset } from "@loaders.gl/potree";
-import { deduceMeshSchema } from "@loaders.gl/schema-utils";
-import { encodeZip, openZipArchive } from "@loaders.gl/zip";
+import { COPCSourceLoader } from "@loaders.gl/tiles-3d/copc";
+import { PotreeSourceLoader, encodePotreeDataset } from "@loaders.gl/tiles-3d/potree";
+import { deduceMeshSchema } from "@loaders.gl/core/schema-utils";
+import { encodeZip, openZipArchive } from "@loaders.gl/archives/zip";
 async function encodePotreeArchive(input, options) {
   validateLimit(options.maxArchiveBytes);
   const dataset = await encodePotreeDataset(input, { potree: options.potree });
@@ -3867,8 +4214,8 @@ function validateLimit(value) {
 }
 
 // src/v5/point-cloud-potree.ts
-import { PointCloudTiler } from "@loaders.gl/schema-utils";
-import { encodePotreeDataset as encodePotreeDataset2 } from "@loaders.gl/potree";
+import { PointCloudTiler } from "@loaders.gl/core/schema-utils";
+import { encodePotreeDataset as encodePotreeDataset2 } from "@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");
@@ -3939,15 +4286,15 @@ async function convertPointCloudToPotree(input, options) {
 
 // src/v5/mesh-hierarchy.ts
 import { Matrix4 as Matrix43 } from "@math.gl/core";
-import { get3DTilesSpatialReference } from "@loaders.gl/tiles";
+import { get3DTilesSpatialReference } from "@loaders.gl/tiles-3d";
 import {
-  TileConversionError as TileConversionError24,
+  TileConversionError as TileConversionError26,
   createBoundedMemoryTileConversionSink as createBoundedMemoryTileConversionSink5,
   createTiles3DConversionSpatialContext
 } from "@loaders.gl/tile-converter/v5/core";
 function prepareMeshHierarchy(inspection, resourceIds) {
   const rejectHierarchy = (message) => {
-    throw new TileConversionError24("MESH_HIERARCHY_UNSUPPORTED", message);
+    throw new TileConversionError26("MESH_HIERARCHY_UNSUPPORTED", message);
   };
   if (!inspection.documents?.length || inspection.documents.length > 32)
     rejectHierarchy(
@@ -4127,7 +4474,7 @@ 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 TileConversionError24(
+    throw new TileConversionError26(
       "MESH_GEOMETRIC_ERROR_INVALID",
       "Hierarchy position allowance and resulting errors must be finite nonnegative meters"
     );
@@ -4149,12 +4496,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 TileConversionError24(
+        throw new TileConversionError26(
           "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 TileConversionError24(
+        throw new TileConversionError26(
           "MESH_SOURCE_EPOCH_MISMATCH",
           "Hierarchy output coordinate epoch must match its source"
         );
@@ -4163,7 +4510,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 TileConversionError24(
+        throw new TileConversionError26(
           "MESH_HIERARCHY_PLACEMENT_INVALID",
           "Contents on one tile must share an encoded origin"
         );
@@ -4190,7 +4537,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 TileConversionError24(
+        throw new TileConversionError26(
           "MESH_HIERARCHY_INCOMPLETE",
           "Finalization requires every declared hierarchy content"
         );
@@ -4228,7 +4575,7 @@ function createMeshHierarchyTilesetSink(options) {
             maximum[axis] = Math.max(maximum[axis], upper[axis]);
           }
         if ([...minimum, ...maximum].some((value) => !Number.isFinite(value)))
-          throw new TileConversionError24(
+          throw new TileConversionError26(
             "MESH_TILESET_BOUNDS_INVALID",
             "Hierarchy absolute bounds must remain finite"
           );
@@ -4246,7 +4593,7 @@ function createMeshHierarchyTilesetSink(options) {
           )
         );
         if ([...center, ...halfAxes].some((value) => !Number.isFinite(value)))
-          throw new TileConversionError24(
+          throw new TileConversionError26(
             "MESH_TILESET_BOUNDS_INVALID",
             "Hierarchy local bounds must remain finite"
           );
@@ -4262,7 +4609,7 @@ function createMeshHierarchyTilesetSink(options) {
                 new Matrix43(inverse).multiplyRight(transforms[child])
               );
               if (tiles[child].transform.some((value) => !Number.isFinite(value)))
-                throw new TileConversionError24(
+                throw new TileConversionError26(
                   "MESH_TILESET_BOUNDS_INVALID",
                   "Relative hierarchy transforms must remain finite"
                 );
@@ -4301,13 +4648,13 @@ function createMeshHierarchyTilesetSink(options) {
 
 // src/v5/selected-mesh-source.ts
 import { coreApi, parse } from "@loaders.gl/core";
-import { Tiles3DLoader } from "@loaders.gl/3d-tiles";
-import { Tiles3DSource, Tileset3D } from "@loaders.gl/tiles";
+import { Tiles3DLoader } from "@loaders.gl/tiles-3d/3d-tiles";
+import { Tiles3DSource, Tileset3D } from "@loaders.gl/tiles-3d";
 import {
   createBrowserTilesetConversionSource,
   selectBrowserTilesetContent,
   createTiles3DConversionSpatialContext as createTiles3DConversionSpatialContext2,
-  TileConversionError as TileConversionError25
+  TileConversionError as TileConversionError27
 } from "@loaders.gl/tile-converter/v5/core";
 import {
   createMeshTilesetConversionSource as createMeshTilesetConversionSource2,
@@ -4340,7 +4687,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 TileConversionError25(
+    throw new TileConversionError27(
       "INVALID_SELECTED_MESH_OPTIONS",
       "Selected mesh input budget must be a positive safe integer at most 16 MiB"
     );
@@ -4349,7 +4696,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 TileConversionError25(
+    throw new TileConversionError27(
       "MESH_HIERARCHY_UNSUPPORTED",
       "preserveHierarchy must be a boolean"
     );
@@ -4414,7 +4761,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 TileConversionError25(
+          throw new TileConversionError27(
             "INVALID_BROWSER_SELECTION",
             "Source yielded an uninspected content placement"
           );
@@ -4443,7 +4790,7 @@ async function createSelectedMeshConversionSource(inspection, options) {
           const metadata = await meshSource.inspect(signal2);
           const selectedContext = createTiles3DConversionSpatialContext2(metadata.spatialReference);
           if (selectedContext.spatialReference.coordinateEpoch !== spatialContext.spatialReference.coordinateEpoch)
-            throw new TileConversionError25(
+            throw new TileConversionError27(
               "MESH_SOURCE_EPOCH_MISMATCH",
               "Selected content coordinate epoch must match the root; epoch transformations are unsupported"
             );
@@ -4454,7 +4801,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 TileConversionError25(
+              throw new TileConversionError27(
                 "INPUT_RESOURCE_TOO_LARGE",
                 "Selected decoded geometry and encoded images exceed the aggregate input byte limit."
               );
@@ -4569,14 +4916,14 @@ function measureMeshBytes(resource) {
 }
 
 // src/v5/archive-source.ts
-import { BlobFile, HttpFile } from "@loaders.gl/loader-utils";
-import { parseSLPKArchive } from "@loaders.gl/i3s";
-import { parse3DTilesArchive } from "@loaders.gl/3d-tiles";
-import { TileConversionError as TileConversionError26 } from "@loaders.gl/tile-converter/v5/core";
+import { BlobFile, HttpFile } from "@loaders.gl/core/loader-utils";
+import { parseSLPKArchive } from "@loaders.gl/tiles-3d/i3s";
+import { parse3DTilesArchive } from "@loaders.gl/tiles-3d/3d-tiles";
+import { TileConversionError as TileConversionError28 } from "@loaders.gl/tile-converter/v5/core";
 async function openTileConversionArchive(descriptor, maxInputBytes, signal, fetcher = fetch) {
   signal.throwIfAborted();
   if (!["slpk", "3tz"].includes(descriptor.format))
-    throw new TileConversionError26("INVALID_ARCHIVE_SOURCE", "Select SLPK or 3TZ archive input");
+    throw new TileConversionError28("INVALID_ARCHIVE_SOURCE", "Select SLPK or 3TZ archive input");
   validateArchiveEntityTag(descriptor.identity?.etag);
   const transport = createTileConversionResourceFetcher({
     maxInputBytes,
@@ -4643,12 +4990,12 @@ async function createTileConversionArchiveTransport(file, format, maxInputBytes,
   const checkOpen = () => {
     signal.throwIfAborted();
     if (closed)
-      throw new TileConversionError26("ARCHIVE_SOURCE_CLOSED", "Conversion archive is closed");
+      throw new TileConversionError28("ARCHIVE_SOURCE_CLOSED", "Conversion archive is closed");
   };
   try {
     checkOpen();
     if (!["slpk", "3tz"].includes(format) || !Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1)
-      throw new TileConversionError26(
+      throw new TileConversionError28(
         "INVALID_ARCHIVE_SOURCE",
         "Archive source requires a supported format and positive safe byte budget"
       );
@@ -4666,7 +5013,7 @@ async function createTileConversionArchiveTransport(file, format, maxInputBytes,
       read: async (start, length) => {
         checkOpen();
         if (!Number.isSafeInteger(length) || length < 0 || length > maxInputBytes - readBytes)
-          throw new TileConversionError26(
+          throw new TileConversionError28(
             "INPUT_RESOURCE_TOO_LARGE",
             "Archive indexed reads exceed the input budget"
           );
@@ -4715,7 +5062,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 TileConversionError26(
+    throw new TileConversionError28(
       "ARCHIVE_VALIDATOR_UNSUPPORTED",
       "Remote archives require a strong quoted ETag, or Last-Modified without an ETag; weak/malformed ETags are unsupported"
     );
@@ -4729,7 +5076,7 @@ function validateArchiveResponseValidator(headers) {
   const modifiedTime = parseArchiveHttpDate(lastModified);
   const responseTime = parseArchiveHttpDate(responseDate);
   if (!Number.isFinite(modifiedTime) || !Number.isFinite(responseTime) || responseTime - modifiedTime < 6e4)
-    throw new TileConversionError26(
+    throw new TileConversionError28(
       "ARCHIVE_VALIDATOR_UNSUPPORTED",
       "Last-Modified archive identity requires a valid Date at least 60 seconds later; otherwise supply a strong ETag"
     );
@@ -4741,11 +5088,11 @@ function parseArchiveHttpDate(value) {
 
 // src/v5/i3s-selection-source.ts
 import { coreApi as coreApi2, parse as parse2 } from "@loaders.gl/core";
-import { I3SLoader } from "@loaders.gl/i3s";
-import { I3SSource, Tileset3D as Tileset3D2 } from "@loaders.gl/tiles";
+import { I3SLoader } from "@loaders.gl/tiles-3d/i3s";
+import { I3SSource, Tileset3D as Tileset3D2 } from "@loaders.gl/tiles-3d";
 import {
   createI3SConversionSpatialContext,
-  TileConversionError as TileConversionError27
+  TileConversionError as TileConversionError29
 } from "@loaders.gl/tile-converter/v5/core";
 function createRuntime(transport, layer, header) {
   const libraries = transport.dracoLibraryOptions;
@@ -4857,7 +5204,7 @@ async function createSelectedI3SMeshConversionSource(inspection, options) {
   validateSelectionOptions(options);
   signal.throwIfAborted();
   if (inspection.rootUrl !== options.rootUrl)
-    throw new TileConversionError27(
+    throw new TileConversionError29(
       "INVALID_I3S_SELECTION",
       "Selection transport must match the inspected layer"
     );
@@ -4907,7 +5254,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 TileConversionError27(
+                throw new TileConversionError29(
                   "INPUT_RESOURCE_TOO_LARGE",
                   "Selected I3S decoded resources exceed the input/mesh budget"
                 );
@@ -4934,7 +5281,7 @@ function validateSelectionOptions(options) {
     ]
   ])
     if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
-      throw new TileConversionError27(
+      throw new TileConversionError29(
         "INVALID_I3S_SELECTION_LIMIT",
         "I3S selection limits must be positive safe integers within the bounded profile"
       );
@@ -4945,6 +5292,7 @@ export {
   convertPointCloudSource,
   convertPointCloudToPotree,
   convertPointCloudToTileset,
+  createCOPCConversionCodec,
   createI3SMeshConversionCodec,
   createI3SMeshSink,
   createI3SMeshTilesetConversionSource,
@@ -4963,6 +5311,7 @@ export {
   createTileConversionArchiveTransport,
   createTileConversionResourceFetcher,
   encodeMeshTile,
+  encodePointCloudCOPC,
   encodePointCloudSource,
   encodePointCloudSourceTile,
   encodePointCloudTile,
@@ -4971,6 +5320,7 @@ export {
   encodeTileConversionArchiveInBatches,
   extractMeshVertices,
   inspectI3SMeshConversionSource,
+  mapPointCloudAttributes,
   measureMeshBytes,
   openPointCloudFile,
   openTileConversionArchive,