@loaders.gl/services 5.0.0-alpha.6 → 5.0.0-alpha.7

package/dist/index.cjs

@@ -991,6 +991,65 @@ var init_convert_geometry_to_wkt = __esm({
   }
 });
 
+// ../schema/src/float16.ts
+function createFloat16Array(length) {
+  const ArrayConstructor = (0, import_types.getFloat16ArrayConstructor)();
+  return new ArrayConstructor(length);
+}
+function isNativeFloat16Array(value) {
+  return Boolean(import_types.NativeFloat16ArrayConstructor && value instanceof import_types.NativeFloat16ArrayConstructor);
+}
+function setFloat16Value(array, index, value) {
+  if (isNativeFloat16Array(array)) {
+    array[index] = value;
+  } else {
+    array[index] = encodeFloat16(value);
+  }
+}
+function getFloat16Storage(array) {
+  return isNativeFloat16Array(array) ? new Uint16Array(array.buffer, array.byteOffset, array.length) : array;
+}
+function convertColorArrayToFloat16(values, sourceScale) {
+  const result = createFloat16Array(values.length);
+  for (let index = 0; index < values.length; index++) {
+    setFloat16Value(result, index, values[index] / sourceScale);
+  }
+  return result;
+}
+function encodeFloat16(value) {
+  if (!Number.isFinite(value)) {
+    return value === Infinity ? 31744 : value === -Infinity ? 64512 : 32256;
+  }
+  const sign = value < 0 || Object.is(value, -0) ? 32768 : 0;
+  const absoluteValue = Math.abs(value);
+  if (absoluteValue === 0) {
+    return sign;
+  }
+  if (absoluteValue >= 65520) {
+    return sign | 31744;
+  }
+  if (absoluteValue >= 65504) {
+    return sign | 31743;
+  }
+  const exponent = Math.floor(Math.log2(absoluteValue));
+  if (exponent < -14) {
+    return sign | Math.round(absoluteValue / 2 ** -24);
+  }
+  const normalizedExponent = exponent + 15;
+  const mantissa = Math.round((absoluteValue / 2 ** exponent - 1) * 1024);
+  if (mantissa === 1024) {
+    return sign | normalizedExponent + 1 << 10;
+  }
+  return sign | normalizedExponent << 10 | mantissa;
+}
+var import_types;
+var init_float16 = __esm({
+  "../schema/src/float16.ts"() {
+    "use strict";
+    import_types = require("@math.gl/types");
+  }
+});
+
 // ../schema/src/metadata.ts
 function getMetadataValue(metadata, key) {
   return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
@@ -1036,6 +1095,7 @@ var init_category_mesh = __esm({
 var init_src = __esm({
   "../schema/src/index.ts"() {
     "use strict";
+    init_float16();
     init_metadata();
     init_category_mesh();
   }
@@ -1244,6 +1304,9 @@ function getDataTypeFromArray(array) {
   return { type: "null", nullable: true };
 }
 function getDataTypeFromTypedArray(array) {
+  if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
+    return "float16";
+  }
   switch (array.constructor) {
     case Int8Array:
       return "int8";
@@ -1266,9 +1329,11 @@ function getDataTypeFromTypedArray(array) {
       return "null";
   }
 }
+var import_types2;
 var init_data_type = __esm({
   "../schema-utils/src/lib/schema/data-type.ts"() {
     "use strict";
+    import_types2 = require("@math.gl/types");
   }
 });
 
@@ -1320,6 +1385,13 @@ function serializeArrowType(arrowType) {
   if (isArrowViewType(arrowType, "Utf8View")) {
     return "utf8-view";
   }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
   switch (arrowType.constructor) {
     case arrow2.Null:
       return "null";
@@ -1458,12 +1530,6 @@ function serializeArrowType(arrowType) {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow2.LargeList:
-      const largeListType = arrowType;
-      return {
-        type: "large-list",
-        children: [serializeArrowField(largeListType.valueField)]
-      };
     case arrow2.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
@@ -1516,7 +1582,13 @@ function deserializeArrowType(dataType, options) {
       }
       case "large-list": {
         const field = deserializeArrowField(dataType.children[0], options);
-        return new arrow2.LargeList(field);
+        const LargeList = getOptionalArrowConstructor("LargeList");
+        if (!LargeList) {
+          throw new Error(
+            "LargeList requires an Apache Arrow runtime that exports the LargeList constructor"
+          );
+        }
+        return new LargeList(field);
       }
       case "fixed-size-list": {
         const child = deserializeArrowField(dataType.children[0], options);
@@ -1612,11 +1684,11 @@ function deserializeArrowType(dataType, options) {
       throw new Error("array type not supported");
   }
 }
-function getArrowViewConstructors() {
-  return arrow2;
+function getOptionalArrowConstructor(typeName) {
+  return arrow2[typeName];
 }
 function isArrowViewType(arrowType, viewTypeName) {
-  const constructor = getArrowViewConstructors()[viewTypeName];
+  const constructor = getOptionalArrowConstructor(viewTypeName);
   if (constructor && arrowType instanceof constructor) {
     return true;
   }
@@ -1624,12 +1696,16 @@ function isArrowViewType(arrowType, viewTypeName) {
   const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
   return Boolean(guard == null ? void 0 : guard(arrowType));
 }
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
 function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
   const viewTypeMode = (options == null ? void 0 : options.viewTypes) || "never";
   if (viewTypeMode === "never") {
     return fallbackType;
   }
-  const constructor = getArrowViewConstructors()[viewTypeName];
+  const constructor = getOptionalArrowConstructor(viewTypeName);
   if (constructor) {
     return new constructor();
   }
@@ -1641,7 +1717,7 @@ function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
   return fallbackType;
 }
 function makeRequiredArrowViewType(viewTypeName) {
-  const constructor = getArrowViewConstructors()[viewTypeName];
+  const constructor = getOptionalArrowConstructor(viewTypeName);
   if (!constructor) {
     throw new Error(
       `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
@@ -1790,33 +1866,34 @@ var init_mesh_utils = __esm({
 });
 
 // ../schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts
-function getFixedSizeListVector(typedArray, stride) {
-  const data = getFixedSizeListData(typedArray, stride);
+function getFixedSizeListVector(typedArray, stride, logicalType) {
+  const data = getFixedSizeListData(typedArray, stride, logicalType);
   return new arrow3.Vector([data]);
 }
-function getFixedSizeListData(typedArray, stride) {
-  const listType = getFixedSizeListType(typedArray, stride);
+function getFixedSizeListData(typedArray, stride, logicalType) {
+  const listType = getFixedSizeListType(typedArray, stride, logicalType);
   const nestedType = listType.children[0].type;
+  const storage = logicalType === "float16" && isNativeFloat16Array(typedArray) ? getFloat16Storage(typedArray) : typedArray;
   const buffers = {
     // valueOffsets: undefined,
-    [arrow3.BufferType.DATA]: typedArray
+    [arrow3.BufferType.DATA]: storage
     // values
     // nullBitmap: undefined,
     // typeIds: undefined
   };
-  const nestedData = new arrow3.Data(nestedType, 0, typedArray.length, 0, buffers);
+  const nestedData = new arrow3.Data(nestedType, 0, storage.length, 0, buffers);
   const data = new arrow3.Data(
     listType,
     0,
-    typedArray.length / stride,
+    storage.length / stride,
     0,
     void 0,
     [nestedData]
   );
   return data;
 }
-function getFixedSizeListType(typedArray, stride) {
-  const { type } = getDataTypeFromArray(typedArray);
+function getFixedSizeListType(typedArray, stride, logicalType) {
+  const type = logicalType || getDataTypeFromArray(typedArray).type;
   const arrowType = deserializeArrowType(type);
   const listType = new arrow3.FixedSizeList(stride, new arrow3.Field("value", arrowType, false));
   return listType;
@@ -1825,6 +1902,7 @@ var arrow3;
 var init_arrow_fixed_size_list_utils = __esm({
   "../schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts"() {
     "use strict";
+    init_src();
     arrow3 = __toESM(require("apache-arrow"), 1);
     init_data_type();
     init_convert_arrow_schema();
@@ -1874,9 +1952,11 @@ function makeMeshArrowTable(attributes, options = {}) {
   for (const attributeName of attributeNames) {
     const attribute = attributes[attributeName];
     const { value, size = 1 } = attribute;
-    const column = getAttributeArrowVector(value, size);
+    const column = getAttributeArrowVector(value, size, attribute.componentType);
     columns[attributeName] = column;
-    fields.push(getAttributeArrowField(options.schema, attributeName, column));
+    fields.push(
+      getAttributeArrowField(options.schema, attributeName, column, attribute.componentType)
+    );
     if (attributeName === "POSITION" && ((_b = (_a2 = options.indices) == null ? void 0 : _a2.value) == null ? void 0 : _b.length)) {
       const indicesField = indexedMeshArrowSchema.fields.find((field) => field.name === "indices");
       columns.indices = getIndicesVector(options.indices.value, column.length, indicesField.type);
@@ -1894,7 +1974,17 @@ function makeMeshArrowTable(attributes, options = {}) {
     indices: options.indices
   };
 }
-function getAttributeArrowVector(value, size) {
+function getAttributeArrowVector(value, size, componentType) {
+  if (componentType === "float16") {
+    const storage = isNativeFloat16Array(value) ? getFloat16Storage(value) : value;
+    if (size === 1) {
+      const data = new arrow4.Data(new arrow4.Float16(), 0, storage.length, 0, {
+        [arrow4.BufferType.DATA]: storage
+      });
+      return new arrow4.Vector([data]);
+    }
+    return getFixedSizeListVector(value, size, componentType);
+  }
   return size === 1 ? arrow4.makeVector(value) : getFixedSizeListVector(value, size);
 }
 function getOrderedAttributeNames(attributes) {
@@ -1911,7 +2001,7 @@ function hasMeshIndices(mesh) {
   var _a2, _b;
   return Boolean((_b = (_a2 = mesh.indices) == null ? void 0 : _a2.value) == null ? void 0 : _b.length);
 }
-function getAttributeArrowField(schema, attributeName, column) {
+function getAttributeArrowField(schema, attributeName, column, componentType) {
   if (attributeName === "POSITION" && isMeshPositionColumn(column)) {
     const canonicalField = meshArrowSchema.fields[0];
     const suppliedField = schema == null ? void 0 : schema.fields.find((schemaField) => schemaField.name === attributeName);
@@ -1930,6 +2020,20 @@ function getAttributeArrowField(schema, attributeName, column) {
     );
   }
   const field = schema == null ? void 0 : schema.fields.find((schemaField) => schemaField.name === attributeName);
+  if (componentType === "float16") {
+    const metadata = new Map(Object.entries((field == null ? void 0 : field.metadata) || {}));
+    metadata.set("componentType", "float16");
+    return new arrow4.Field(attributeName, column.type, false, metadata);
+  }
+  if (field && field.type.toString() !== column.type.toString()) {
+    const deserializedField = deserializeArrowField(field);
+    return new arrow4.Field(
+      attributeName,
+      column.type,
+      deserializedField.nullable,
+      deserializedField.metadata
+    );
+  }
   return field ? deserializeArrowField(field) : new arrow4.Field(attributeName, column.type, false);
 }
 function isMeshPositionColumn(column) {
@@ -1985,6 +2089,7 @@ var init_convert_mesh_to_table = __esm({
   "../schema-utils/src/lib/mesh/convert-mesh-to-table.ts"() {
     "use strict";
     init_src();
+    init_src();
     arrow4 = __toESM(require("apache-arrow"), 1);
     init_arrow_fixed_size_list_utils();
     init_convert_arrow_schema();
@@ -1994,7 +2099,7 @@ var init_convert_mesh_to_table = __esm({
 
 // ../schema-utils/src/lib/mesh/deduce-mesh-schema.ts
 function deduceMeshField(name, attribute, optionalMetadata) {
-  const type = getDataTypeFromTypedArray(attribute.value);
+  const type = attribute.componentType || getDataTypeFromTypedArray(attribute.value);
   const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
   const dataType = attribute.size === 1 ? type : { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] };
   return {
@@ -2015,6 +2120,9 @@ function makeMeshAttributeMetadata(attribute) {
   if ("normalized" in attribute) {
     result.normalized = attribute.normalized.toString();
   }
+  if (attribute.componentType) {
+    result.componentType = attribute.componentType;
+  }
   if (attribute.transform) {
     result["loaders.gl.transform"] = JSON.stringify(attribute.transform);
   }
@@ -2135,7 +2243,6 @@ var init_src2 = __esm({
   "../schema-utils/src/index.ts"() {
     "use strict";
     init_convert_arrow_schema();
-    init_data_type();
     init_make_table_batch_iterator();
     init_table_accessors();
     init_mesh_utils();
@@ -2197,11 +2304,23 @@ function makeBoxData(values, dimension) {
 }
 function makeListData(child, offsets, fieldName, offsetType) {
   return arrow6.makeData({
-    type: offsetType === "int64" ? new arrow6.LargeList(new arrow6.Field(fieldName, child.type, false)) : new arrow6.List(new arrow6.Field(fieldName, child.type, false)),
+    type: offsetType === "int64" ? makeLargeListType(new arrow6.Field(fieldName, child.type, false)) : new arrow6.List(new arrow6.Field(fieldName, child.type, false)),
     valueOffsets: offsets,
     child
   });
 }
+function makeLargeListType(field) {
+  const LargeList = getOptionalArrowConstructor2("LargeList");
+  if (!LargeList) {
+    throw new Error(
+      "64-bit GeoArrow offsets require an Apache Arrow runtime that exports LargeList"
+    );
+  }
+  return new LargeList(field);
+}
+function getOptionalArrowConstructor2(typeName) {
+  return arrow6[typeName];
+}
 function makeCoordinateBuffers(coordinateCount, dimension, coordinateLayout) {
   if (coordinateLayout === "interleaved") {
     return new Float64Array(coordinateCount * getCoordinateSize2(dimension));
@@ -3317,7 +3436,14 @@ function convertFeaturesToWKBArrowTable(features, options = {}) {
   if (encodingPreference && encodingPreference !== "geoarrow.wkb") {
     return convertFeaturesToGeoArrowTable(features, options);
   }
-  const propertyRows = features.map((feature) => normalizeProperties2(feature.properties));
+  const hasFeatureIds = features.some((feature) => feature.id !== void 0);
+  const propertyRows = features.map((feature) => {
+    const properties = normalizeProperties2(feature.properties);
+    if (hasFeatureIds) {
+      properties.id = normalizePropertyValue2(feature.id);
+    }
+    return properties;
+  });
   const propertySchema = getPropertySchema2(propertyRows);
   const schema = buildFeatureArrowSchema(propertySchema, features);
   const arrowTableBuilder = new ArrowTableBuilder(schema);
@@ -3368,9 +3494,12 @@ function getPropertySchema2(propertyRows) {
   return {
     metadata: {},
     fields: fieldNames.map((fieldName) => {
-      const inferredType = getDataTypeFromArray(
-        propertyRows.map((propertyRow) => propertyRow[fieldName])
-      );
+      const values = propertyRows.map((propertyRow) => propertyRow[fieldName]);
+      const firstDefinedValue = values.find((value) => value !== null && value !== void 0);
+      const inferredType = {
+        type: getPropertyDataType(firstDefinedValue),
+        nullable: true
+      };
       return {
         name: fieldName,
         type: inferredType.type === "float32" ? "float64" : inferredType.type,
@@ -3379,6 +3508,18 @@ function getPropertySchema2(propertyRows) {
     })
   };
 }
+function getPropertyDataType(value) {
+  if (typeof value === "number") {
+    return "float64";
+  }
+  if (typeof value === "boolean") {
+    return "bool";
+  }
+  if (typeof value === "string") {
+    return "utf8";
+  }
+  return "null";
+}
 function getFieldNames2(propertyRows) {
   const fieldNames = /* @__PURE__ */ new Set();
   for (const propertyRow of propertyRows) {
@@ -4010,6 +4151,7 @@ var init_worker_pool = __esm({
       props = {};
       jobQueue = [];
       idleQueue = [];
+      activeJobs = /* @__PURE__ */ new Set();
       count = 0;
       isDestroyed = false;
       /** Checks if workers are supported on this platform */
@@ -4028,10 +4170,14 @@ var init_worker_pool = __esm({
         this.setProps(props);
       }
       /**
-       * Terminates all workers in the pool
+       * Terminates all workers in the pool and aborts active jobs.
+       * @param reason Optional error delivered to active jobs.
        * @note Can free up significant memory
        */
-      destroy() {
+      destroy(reason = new Error("Worker pool was destroyed")) {
+        this.activeJobs.forEach((job) => job.abort(reason));
+        const queuedJobs = this.jobQueue.splice(0);
+        queuedJobs.forEach((queuedJob) => queuedJob.onReject(reason));
         this.idleQueue.forEach((worker) => worker.destroy());
         this.isDestroyed = true;
       }
@@ -4054,8 +4200,11 @@ var init_worker_pool = __esm({
         }
       }
       async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
-        const startPromise = new Promise((onStart) => {
-          this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+        if (this.isDestroyed) {
+          return Promise.reject(new Error("Worker pool was destroyed"));
+        }
+        const startPromise = new Promise((onStart, onReject) => {
+          this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart, onReject });
           return this;
         });
         this._startQueuedJob();
@@ -4083,6 +4232,7 @@ var init_worker_pool = __esm({
             backlog: this.jobQueue.length
           });
           const job = new WorkerJob(queuedJob.name, workerThread);
+          this.activeJobs.add(job);
           workerThread.ref();
           workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
           workerThread.onError = (error) => queuedJob.onError(job, error);
@@ -4091,6 +4241,7 @@ var init_worker_pool = __esm({
             await job.result;
           } catch {
           } finally {
+            this.activeJobs.delete(job);
             this.returnWorkerToQueue(workerThread);
           }
         }
@@ -4204,12 +4355,13 @@ var init_worker_farm = __esm({
         this.workerPools = /* @__PURE__ */ new Map();
       }
       /**
-       * Terminate all workers in the farm
+       * Terminate all workers in the farm and abort active jobs.
+       * @param reason Optional error delivered to active jobs.
        * @note Can free up significant memory
        */
-      destroy() {
+      destroy(reason) {
         for (const workerPool of this.workerPools.values()) {
-          workerPool.destroy();
+          workerPool.destroy(reason);
         }
         this.workerPools = /* @__PURE__ */ new Map();
       }
@@ -4682,7 +4834,12 @@ function getCDNOption(cdn, coreCDN) {
   return void 0;
 }
 async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
+  var _a2;
   if (moduleName) {
+    const injectedLibrary = (_a2 = options.modules) == null ? void 0 : _a2[libraryName || libraryUrl];
+    if (injectedLibrary !== void 0 && typeof injectedLibrary !== "string") {
+      return injectedLibrary;
+    }
     libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
   }
   loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -4693,14 +4850,14 @@ function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
   if (options == null ? void 0 : options.core) {
     throw new Error("loadLibrary: options.core must be pre-normalized");
   }
-  if (!options.useLocalLibraries && library.startsWith("http")) {
-    return library;
-  }
   libraryName = libraryName || library;
   const modules = options.modules || {};
-  if (modules[libraryName]) {
+  if (typeof modules[libraryName] === "string") {
     return modules[libraryName];
   }
+  if (!options.useLocalLibraries && library.startsWith("http")) {
+    return library;
+  }
   if (!isBrowser2) {
     return `modules/${moduleName}/dist/libs/${libraryName}`;
   }
@@ -4818,13 +4975,13 @@ var init_src4 = __esm({
 
 // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
 function canParseWithWorker(loader, options) {
-  var _a2, _b;
+  var _a2;
   const workerOptions = getWorkerOptions(options);
   const nodeWorkers = workerOptions._nodeWorkers;
   if (!isBrowser2 && !nodeWorkers) {
     return false;
   }
-  if (loader.id === "excel" && ((_a2 = options == null ? void 0 : options.excel) == null ? void 0 : _a2.shape) === "arrow-table" || loader.id === "ply" && ((_b = options == null ? void 0 : options.ply) == null ? void 0 : _b.shape) === "arrow-table") {
+  if (loader.id === "las" && (((_a2 = options == null ? void 0 : options.las) == null ? void 0 : _a2.shape) ?? "arrow-table") === "arrow-table") {
     return false;
   }
   if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
@@ -7633,6 +7790,36 @@ function hydrateArrowTable(table) {
   );
   return new arrow9.Table(schema, recordBatches);
 }
+function serializeArrowWorkerResult(result, options) {
+  var _a2;
+  if (!isArrowTableWrapper(result)) {
+    return result;
+  }
+  const workerOptions = options;
+  const bufferCopyMode = ((_a2 = workerOptions == null ? void 0 : workerOptions.core) == null ? void 0 : _a2.workerTransferBufferCopy) ?? (workerOptions == null ? void 0 : workerOptions.workerTransferBufferCopy);
+  return {
+    ...result,
+    data: dehydrateArrowTable(result.data, bufferCopyMode ? { copy: bufferCopyMode } : void 0)
+  };
+}
+function deserializeArrowWorkerResult(result) {
+  if (!isDehydratedArrowTableWrapper(result)) {
+    return result;
+  }
+  return { ...result, data: hydrateArrowTable(result.data) };
+}
+function isArrowTableWrapper(value) {
+  const table = value;
+  return Boolean(
+    table && table.shape === "arrow-table" && table.data && typeof table.data === "object" && "batches" in table.data
+  );
+}
+function isDehydratedArrowTableWrapper(value) {
+  const table = value;
+  return Boolean(
+    table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
+  );
+}
 function dehydrateArrowRecordBatch(recordBatch) {
   return { data: dehydrateArrowData(recordBatch.data) };
 }
@@ -8282,9 +8469,9 @@ var init_vector_tile = __esm({
 
 // ../mvt/src/lib/parse-mvt.ts
 function parseMVT(arrayBuffer, options) {
-  var _a2, _b, _c, _d;
+  var _a2, _b, _c;
   const mvtOptions = checkOptions(options);
-  const shape = ((_a2 = options == null ? void 0 : options.gis) == null ? void 0 : _a2.format) || ((_b = options == null ? void 0 : options.mvt) == null ? void 0 : _b.shape) || (options == null ? void 0 : options.shape);
+  const shape = ((_a2 = options == null ? void 0 : options.mvt) == null ? void 0 : _a2.shape) || (options == null ? void 0 : options.shape) || "arrow-table";
   switch (shape) {
     case "columnar-table":
       return { shape: "columnar-table", data: parseToBinary(arrayBuffer, mvtOptions) };
@@ -8300,7 +8487,7 @@ function parseMVT(arrayBuffer, options) {
       const table = convertFeaturesToWKBArrowTable(
         parseToGeojsonFeatures(arrayBuffer, mvtOptions),
         {
-          encodingPreference: ((_c = options == null ? void 0 : options.geoarrow) == null ? void 0 : _c.encodingPreference) || ((_d = mvtOptions.geoarrow) == null ? void 0 : _d.encodingPreference)
+          encodingPreference: ((_b = options == null ? void 0 : options.geoarrow) == null ? void 0 : _b.encodingPreference) || ((_c = mvtOptions.geoarrow) == null ? void 0 : _c.encodingPreference)
         }
       );
       return table;
@@ -8417,19 +8604,14 @@ __export(mvt_loader_with_parser_exports, {
   MVTLoaderWithParser: () => MVTLoaderWithParser,
   MVTWorkerLoaderWithParser: () => MVTWorkerLoaderWithParser
 });
-var _MVTWorkerLoaderPreload, MVTWorkerLoaderMetadataWithoutPreload, _MVTLoaderPreload, MVTLoaderMetadataWithoutPreload, MVTWorkerLoaderWithParser, MVTLoaderWithParser;
+var _MVTLoaderPreload, MVTLoaderMetadataWithoutPreload, MVTLoaderWithParser, MVTWorkerLoaderWithParser;
 var init_mvt_loader_with_parser = __esm({
   "../mvt/src/mvt-loader-with-parser.ts"() {
     "use strict";
     init_parse_mvt();
     init_mvt_worker_transport();
     init_mvt_loader();
-    init_mvt_loader();
-    ({ preload: _MVTWorkerLoaderPreload, ...MVTWorkerLoaderMetadataWithoutPreload } = MVTWorkerLoader);
     ({ preload: _MVTLoaderPreload, ...MVTLoaderMetadataWithoutPreload } = MVTLoader);
-    MVTWorkerLoaderWithParser = {
-      ...MVTWorkerLoaderMetadataWithoutPreload
-    };
     MVTLoaderWithParser = {
       ...MVTLoaderMetadataWithoutPreload,
       parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),
@@ -8437,6 +8619,7 @@ var init_mvt_loader_with_parser = __esm({
       serializeWorkerResult: serializeMVTWorkerResult,
       deserializeWorkerResult: deserializeMVTWorkerResult
     };
+    MVTWorkerLoaderWithParser = MVTLoaderWithParser;
   }
 });
 
@@ -8445,14 +8628,14 @@ async function preload4() {
   const { MVTLoaderWithParser: MVTLoaderWithParser2 } = await Promise.resolve().then(() => (init_mvt_loader_with_parser(), mvt_loader_with_parser_exports));
   return MVTLoaderWithParser2;
 }
-var VERSION5, MVTWorkerLoader, MVTLoader;
+var VERSION5, MVTLoader;
 var init_mvt_loader = __esm({
   "../mvt/src/mvt-loader.ts"() {
     "use strict";
     init_mvt_format();
     init_mvt_worker_transport();
     VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    MVTWorkerLoader = {
+    MVTLoader = {
       ...MVTFormat,
       dataType: null,
       batchType: null,
@@ -8460,7 +8643,7 @@ var init_mvt_loader = __esm({
       worker: true,
       options: {
         mvt: {
-          shape: "geojson-table",
+          shape: "arrow-table",
           coordinates: "local",
           layerProperty: "layerName",
           layers: void 0,
@@ -8469,12 +8652,8 @@ var init_mvt_loader = __esm({
       },
       serializeWorkerResult: serializeMVTWorkerResult,
       deserializeWorkerResult: deserializeMVTWorkerResult,
-      preload: preload4
-    };
-    MVTLoader = {
-      ...MVTWorkerLoader,
-      binary: true,
-      preload: preload4
+      preload: preload4,
+      binary: true
     };
   }
 });
@@ -8781,6 +8960,7 @@ var init_i3s_loader_options = __esm({
       useDracoGeometry: true,
       useCompressedTextures: true,
       decodeTextures: true,
+      colorFormat: "uint8norm",
       coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS
     };
   }
@@ -9025,10 +9205,9 @@ var init_draco_loader_options = __esm({
     "use strict";
     DRACO_LOADER_DEFAULT_OPTIONS = {
       backend: typeof WebAssembly === "object" ? "wasm" : "javascript",
-      decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
       extraAttributes: {},
       attributeNameEntry: void 0,
-      shape: "mesh",
+      shape: "arrow-table",
       decoderProfile: "full"
     };
   }
@@ -9801,38 +9980,34 @@ async function preload5(_url, options) {
   }
 }
 function getDracoBackend(options) {
-  var _a2, _b;
+  var _a2;
   if ((_a2 = options == null ? void 0 : options.draco) == null ? void 0 : _a2.backend) {
     return options.draco.backend === "js" ? "javascript" : options.draco.backend;
   }
-  if ((_b = options == null ? void 0 : options.draco) == null ? void 0 : _b.decoderType) {
-    return options.draco.decoderType === "js" ? "javascript" : options.draco.decoderType;
-  }
   return DracoLoader.options.draco.backend;
 }
-var DracoWorkerLoader, DracoLoader;
+var DracoLoader;
 var init_draco_loader = __esm({
   "../draco/src/draco-loader.ts"() {
     "use strict";
+    init_transport();
     init_version3();
     init_draco_format();
     init_draco_loader_options();
-    DracoWorkerLoader = {
+    DracoLoader = {
       dataType: null,
       batchType: null,
       ...DracoFormat,
       // shapes: ['mesh'],
       version: VERSION6,
       worker: true,
+      serializeWorkerResult: serializeArrowWorkerResult,
+      deserializeWorkerResult: deserializeArrowWorkerResult,
       options: {
         draco: DRACO_LOADER_DEFAULT_OPTIONS
       },
       preload: preload5
     };
-    DracoLoader = {
-      ...DracoWorkerLoader,
-      preload: preload5
-    };
   }
 });
 
@@ -11133,13 +11308,13 @@ async function preload6() {
   const { BasisLoaderWithParser: BasisLoaderWithParser2 } = await Promise.resolve().then(() => (init_basis_loader_with_parser(), basis_loader_with_parser_exports));
   return BasisLoaderWithParser2;
 }
-var BasisWorkerLoader, BasisLoader;
+var BasisLoader, BasisWorkerLoader;
 var init_basis_loader = __esm({
   "../textures/src/basis-loader.ts"() {
     "use strict";
     init_texture_format();
     init_version4();
-    BasisWorkerLoader = {
+    BasisLoader = {
       ...BasisTextureFormat,
       dataType: null,
       batchType: null,
@@ -11160,10 +11335,7 @@ var init_basis_loader = __esm({
       },
       preload: preload6
     };
-    BasisLoader = {
-      ...BasisWorkerLoader,
-      preload: preload6
-    };
+    BasisWorkerLoader = BasisLoader;
   }
 });
 
@@ -11492,13 +11664,13 @@ async function preload7() {
   const { CompressedTextureLoaderWithParser: CompressedTextureLoaderWithParser2 } = await Promise.resolve().then(() => (init_compressed_texture_loader_with_parser(), compressed_texture_loader_with_parser_exports));
   return CompressedTextureLoaderWithParser2;
 }
-var CompressedTextureWorkerLoader, CompressedTextureLoader;
+var CompressedTextureLoader, CompressedTextureWorkerLoader;
 var init_compressed_texture_loader = __esm({
   "../textures/src/compressed-texture-loader.ts"() {
     "use strict";
     init_texture_format();
     init_version4();
-    CompressedTextureWorkerLoader = {
+    CompressedTextureLoader = {
       ...CompressedTextureFormat,
       dataType: null,
       batchType: null,
@@ -11536,10 +11708,7 @@ var init_compressed_texture_loader = __esm({
       },
       preload: preload7
     };
-    CompressedTextureLoader = {
-      ...CompressedTextureWorkerLoader,
-      preload: preload7
-    };
+    CompressedTextureWorkerLoader = CompressedTextureLoader;
   }
 });
 
@@ -11736,7 +11905,7 @@ var init_tiles_3d_request_priority = __esm({
   }
 });
 
-// ../tiles/src/spatial/get-spatial-coordinate-frame.ts
+// ../tiles/src/spatial/normalize-crs-identifier.ts
 function normalizeCrsIdentifier(identifier) {
   const normalizedIdentifier = identifier.trim().toUpperCase();
   const ogcMatch = normalizedIdentifier.match(
@@ -11744,20 +11913,27 @@ function normalizeCrsIdentifier(identifier) {
   );
   return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
 }
+var WGS84_GEOGRAPHIC_CRS, WGS84_GEOCENTRIC_CRS;
+var init_normalize_crs_identifier = __esm({
+  "../tiles/src/spatial/normalize-crs-identifier.ts"() {
+    "use strict";
+    WGS84_GEOGRAPHIC_CRS = "EPSG:4326";
+    WGS84_GEOCENTRIC_CRS = "EPSG:4978";
+  }
+});
+
+// ../tiles/src/spatial/get-spatial-coordinate-frame.ts
 function getSpatialCoordinateFrame(definition) {
   var _a2, _b;
   if (typeof definition === "string") {
-    const normalized = normalizeCrsIdentifier(definition);
-    if (normalized === GEOCENTRIC_CRS || /^GEOCCS\s*[\[(]/.test(normalized)) {
-      return "geocentric";
-    }
-    if (normalized === GEOGRAPHIC_CRS || normalized === "EPSG:4490" || normalized === "EPSG:4979" || normalized === "OGC:CRS84" || normalized.includes("+PROJ=LONGLAT") || normalized.includes("+PROJ=LATLONG") || /^(?:GEOGCS|GEOGCRS|GEOGRAPHICCRS|GEOGRAPHIC2DCRS|GEOGRAPHIC3DCRS)\s*[\[(]/.test(normalized)) {
-      return "geographic";
+    const representation = (0, import_crs.inferCRSRepresentation)(definition);
+    if (representation === "wkt") {
+      return getWktCoordinateFrame(definition);
     }
-    if (/^(?:GEODCRS|GEODETICCRS)\s*[\[(]/.test(normalized)) {
-      return /CS\s*[\[(]\s*CARTESIAN/.test(normalized) ? "geocentric" : "geographic";
+    if (representation === "proj-string") {
+      return getProjStringCoordinateFrame(definition);
     }
-    return "projected";
+    return getKnownCrsIdentifierCoordinateFrame(definition) || "projected";
   }
   const projJsonDefinition = definition;
   if (projJsonDefinition.type === "BoundCRS" && projJsonDefinition.source_crs) {
@@ -11775,14 +11951,95 @@ function getSpatialCoordinateFrame(definition) {
   if (String(projJsonDefinition.type).includes("Geodetic")) {
     return ((_b = projJsonDefinition.coordinate_system) == null ? void 0 : _b.subtype) === "Cartesian" ? "geocentric" : "geographic";
   }
-  return "projected";
+  return "unknown";
+}
+function getKnownCrsIdentifierCoordinateFrame(definition) {
+  if (typeof definition !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeCrsIdentifier(definition);
+  if (normalized === WGS84_GEOCENTRIC_CRS) {
+    return "geocentric";
+  }
+  if (normalized === WGS84_GEOGRAPHIC_CRS || normalized === "OGC:CRS84") {
+    return "geographic";
+  }
+  const epsgMatch = /^EPSG:(\d+)$/.exec(normalized);
+  if (!epsgMatch) {
+    return void 0;
+  }
+  const identifier = Number(epsgMatch[1]);
+  if (identifier === 7789) {
+    return "geocentric";
+  }
+  if (identifier === 4490 || identifier === 4979) {
+    return "geographic";
+  }
+  if (identifier === 3857 || identifier >= 32601 && identifier <= 32660 || identifier >= 32701 && identifier <= 32760) {
+    return "projected";
+  }
+  return void 0;
+}
+function getWktCoordinateFrame(definition) {
+  let root;
+  try {
+    root = (0, import_crs.parseWKTCRS)(definition).root;
+  } catch {
+    return "unknown";
+  }
+  switch (root.keyword.toUpperCase()) {
+    case "GEOCCS":
+      return "geocentric";
+    case "GEOGCS":
+    case "GEOGCRS":
+    case "GEOGRAPHICCRS":
+    case "GEOGRAPHIC2DCRS":
+    case "GEOGRAPHIC3DCRS":
+      return "geographic";
+    case "PROJCS":
+    case "PROJCRS":
+    case "PROJECTEDCRS":
+      return "projected";
+    case "GEODCRS":
+    case "GEODETICCRS": {
+      const coordinateSystem = root.values.find(
+        (value) => value.type === "node" && value.keyword.toUpperCase() === "CS"
+      );
+      const subtype = coordinateSystem == null ? void 0 : coordinateSystem.values[0];
+      if ((subtype == null ? void 0 : subtype.type) !== "enumeration" && (subtype == null ? void 0 : subtype.type) !== "string") {
+        return "unknown";
+      }
+      return subtype.value.toUpperCase() === "CARTESIAN" ? "geocentric" : subtype.value.toUpperCase() === "ELLIPSOIDAL" ? "geographic" : "unknown";
+    }
+    default:
+      return "unknown";
+  }
+}
+function getProjStringCoordinateFrame(definition) {
+  var _a2;
+  try {
+    const projection = (_a2 = (0, import_crs.parsePROJString)(definition).parameters.find(
+      (parameter) => parameter.name.toLowerCase() === "proj"
+    )) == null ? void 0 : _a2.value;
+    switch (projection == null ? void 0 : projection.toLowerCase()) {
+      case "longlat":
+      case "latlong":
+        return "geographic";
+      case "geocent":
+        return "geocentric";
+      default:
+        return projection ? "projected" : "unknown";
+    }
+  } catch {
+    return "unknown";
+  }
 }
-var GEOGRAPHIC_CRS, GEOCENTRIC_CRS;
+var import_crs;
 var init_get_spatial_coordinate_frame = __esm({
   "../tiles/src/spatial/get-spatial-coordinate-frame.ts"() {
     "use strict";
-    GEOGRAPHIC_CRS = "EPSG:4326";
-    GEOCENTRIC_CRS = "EPSG:4978";
+    import_crs = require("@math.gl/crs");
+    init_normalize_crs_identifier();
   }
 });
 
@@ -11808,11 +12065,11 @@ function createTilesetSpatialReference(discovered, options = {}) {
   const provenance = hasSourceCrsOverride ? "caller-override" : discovered.provenance || "unknown";
   const coordinateFrame = hasSourceCrsOverride && sourceCrs ? getSpatialCoordinateFrame(sourceCrs) : discovered.coordinateFrame;
   const sourceCrsState = hasSourceCrsOverride ? "explicit" : discovered.sourceCrsState || (sourceCrs ? provenance === "format-default" ? "default" : "explicit" : "absent");
-  const spatialReference = (0, import_crs.createSpatialReference)({
+  const spatialReference = (0, import_crs2.createSpatialReference)({
     crs: sourceCrs ? {
       state: sourceCrsState === "default" ? "default" : "explicit",
       definition: sourceCrs,
-      representation: !hasSourceCrsOverride && discovered.sourceCrsRepresentation || (0, import_crs.inferCRSRepresentation)(sourceCrs),
+      representation: !hasSourceCrsOverride && discovered.sourceCrsRepresentation || (0, import_crs2.inferCRSRepresentation)(sourceCrs),
       provenance,
       alternatives: hasSourceCrsOverride ? void 0 : discovered.sourceCrsAlternatives
     } : {
@@ -11822,7 +12079,7 @@ function createTilesetSpatialReference(discovered, options = {}) {
     vertical: discovered.verticalCrs ? {
       state: "explicit",
       definition: discovered.verticalCrs,
-      representation: (0, import_crs.inferCRSRepresentation)(discovered.verticalCrs),
+      representation: (0, import_crs2.inferCRSRepresentation)(discovered.verticalCrs),
       provenance: discovered.provenance || "metadata"
     } : void 0,
     coordinateEpoch: options.coordinateEpoch ?? discovered.coordinateEpoch,
@@ -11882,11 +12139,11 @@ function getKnownCRSDefinition(reference) {
   return reference.state === "explicit" || reference.state === "default" ? reference.definition : void 0;
 }
 function cloneReadonlyCRSDefinition(definition) {
-  const spatialReference = (0, import_crs.createSpatialReference)({
+  const spatialReference = (0, import_crs2.createSpatialReference)({
     crs: {
       state: "explicit",
       definition,
-      representation: (0, import_crs.inferCRSRepresentation)(definition),
+      representation: (0, import_crs2.inferCRSRepresentation)(definition),
       provenance: "caller-override"
     }
   });
@@ -11914,34 +12171,87 @@ function markTilesetSpatialReferenceTransformed(spatialReference) {
   }
   return Object.freeze({ ...spatialReference, status: "transformed" });
 }
-var import_crs;
+var import_crs2;
 var init_spatial_types = __esm({
   "../tiles/src/spatial/spatial-types.ts"() {
     "use strict";
-    import_crs = require("@math.gl/crs");
+    import_crs2 = require("@math.gl/crs");
     init_get_spatial_coordinate_frame();
   }
 });
 
+// ../tiles/src/tileset-3d/common/tile-3d-contracts.ts
+function getTile3DFeatureIdSets(payload) {
+  const featureIdSets = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    var _a2, _b;
+    if (!value || typeof value !== "object") {
+      return;
+    }
+    if (visited.has(value)) {
+      return;
+    }
+    visited.add(value);
+    const record = value;
+    const declarations = (_b = (_a2 = record.extensions) == null ? void 0 : _a2.EXT_mesh_features) == null ? void 0 : _b.featureIds;
+    if (Array.isArray(declarations)) {
+      for (const declaration of declarations) {
+        if (!declaration || typeof declaration !== "object") {
+          continue;
+        }
+        const source = declaration.texture ? "texture" : declaration.implicit ? "implicit" : declaration.attribute !== void 0 ? "attribute" : declaration.propertyTable !== void 0 ? "property-table" : "constant";
+        featureIdSets.push({
+          source,
+          attribute: declaration.attribute,
+          propertyTable: declaration.propertyTable,
+          constant: declaration.constant,
+          texture: declaration.texture,
+          implicit: declaration.implicit,
+          values: declaration.values,
+          details: declaration
+        });
+      }
+    }
+    for (const child of Object.values(record)) {
+      visit(child);
+    }
+  };
+  visit(payload);
+  return featureIdSets;
+}
+var init_tile_3d_contracts = __esm({
+  "../tiles/src/tileset-3d/common/tile-3d-contracts.ts"() {
+    "use strict";
+  }
+});
+
 // ../tiles/src/tileset-3d/helpers/bounding-volume.ts
 function defined(x) {
   return x !== void 0 && x !== null;
 }
-function createBoundingVolume(boundingVolumeHeader, transform, result) {
+function createBoundingVolume(boundingVolumeHeader, transform, result, initialTransform = transform) {
   assert(boundingVolumeHeader, "3D Tile: boundingVolume must be defined");
   if (boundingVolumeHeader.box) {
-    return createBox(boundingVolumeHeader.box, transform, result);
+    const boxTransform = boundingVolumeHeader.s2VolumeInfo ? identityTransform : transform;
+    return createBox(boundingVolumeHeader.box, boxTransform, result);
   }
   if (boundingVolumeHeader.region) {
-    return (0, import_geospatial.makeOBBFromRegion)(boundingVolumeHeader.region);
+    const boundingVolume = (0, import_geospatial.makeOBBFromRegion)(boundingVolumeHeader.region);
+    const regionTransform = transform.equals(initialTransform) ? identityTransform : transform.clone().multiplyRight(initialTransform.clone().invert());
+    return createBox(
+      [...boundingVolume.center, ...boundingVolume.halfAxes],
+      regionTransform,
+      result
+    );
   }
   if (boundingVolumeHeader.sphere) {
     return createSphere(boundingVolumeHeader.sphere, transform, result);
   }
   throw new Error("3D Tile: boundingVolume must contain a sphere, region, or box");
 }
-function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
-  if (boundingVolumeHeader.box) {
+function getCartographicBounds(boundingVolumeHeader, boundingVolume, isRegionTransformed = false) {
+  if (boundingVolumeHeader.box || boundingVolumeHeader.region && isRegionTransformed) {
     return orientedBoundingBoxToCartographicBounds(boundingVolume);
   }
   if (boundingVolumeHeader.region) {
@@ -12076,7 +12386,7 @@ function addToCartographicBounds(target, cartesian) {
   target[1][1] = Math.max(target[1][1], scratchPoint[1]);
   target[1][2] = Math.max(target[1][2], scratchPoint[2]);
 }
-var import_core3, import_culling2, import_geospatial, scratchPoint, scratchScale;
+var import_core3, import_culling2, import_geospatial, scratchPoint, scratchScale, identityTransform;
 var init_bounding_volume = __esm({
   "../tiles/src/tileset-3d/helpers/bounding-volume.ts"() {
     "use strict";
@@ -12086,6 +12396,7 @@ var init_bounding_volume = __esm({
     init_src5();
     scratchPoint = new import_core3.Vector3();
     scratchScale = new import_core3.Vector3();
+    identityTransform = new import_core3.Matrix4();
   }
 });
 
@@ -12462,7 +12773,7 @@ var init_tileset_traverser = __esm({
             }
             stack.push(child);
             hasVisibleChild = true;
-          } else if (checkRefines || loadSiblings) {
+          } else if ((checkRefines || loadSiblings) && child._inRequestVolume) {
             this.loadTile(child, frameState);
             this.touchTile(child, frameState);
           }
@@ -12650,6 +12961,13 @@ function getContentVisibility(contentVolumes, fallbackVolume, cullingVolume, vis
   }
   return intersectingVolume ? "intersecting" : "inside";
 }
+function isNestedTilesetPayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const record = payload;
+  return record.shape === "tileset3d" || record.type === "tileset3d" || Boolean(record.tileset);
+}
 function defined2(x) {
   return x !== void 0 && x !== null;
 }
@@ -12659,6 +12977,7 @@ var init_tile_3d = __esm({
     "use strict";
     import_core5 = require("@math.gl/core");
     import_culling3 = require("@math.gl/culling");
+    init_tile_3d_contracts();
     init_constants2();
     init_bounding_volume();
     init_tiles_3d_lod();
@@ -12690,6 +13009,8 @@ var init_tile_3d = __esm({
        * separate ensures transform updates never compound an already-scaled geometric error.
        */
       _unscaledLodMetricValue = 0;
+      /** Whether the source format defines geometric error in transform-local units. */
+      _scaleGeometricError = true;
       /** @todo math.gl is not exporting BoundingVolume base type? */
       boundingVolume = null;
       /**
@@ -12699,6 +13020,14 @@ var init_tile_3d = __esm({
       content = null;
       /** Loaded payloads in the same order as {@link contentUrls}; `content` remains the primary payload. */
       contents = [];
+      /** Ordered renderer-neutral descriptors for each source content entry. */
+      contentEntries = [];
+      /** Raw metadata references inherited by this tile and its content. */
+      metadataContext = {};
+      /** Feature-id declarations normalized from supported content extensions. */
+      featureIdSets = [];
+      /** Decoded 3D Tiles vector topology for the primary loaded content, when present. */
+      vectorContent = null;
       /**
        * Metadata entity attached to this tile in the source tileset, if present.
        *
@@ -12765,6 +13094,7 @@ var init_tile_3d = __esm({
       get viewerRequestVolume() {
         return this._viewerRequestVolume;
       }
+      /** Accumulated tile transforms from the source JSON, excluding the tileset model matrix. */
       _initialTransform = new import_core5.Matrix4();
       // Used by traverser, cannot be marked private
       _priority = 0;
@@ -12806,15 +13136,14 @@ var init_tile_3d = __esm({
         this.type = header.type;
         this.contentUrl = header.contentUrl;
         this.contentUrls = header.contentUrls || (header.contentUrl ? [header.contentUrl] : []);
-        this.metadata = header.metadata || null;
-        const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
-        this.contentMetadata = contentHeaders.filter(Boolean).map((contentHeader) => contentHeader.metadata || null);
+        this._initializeMetadata(header);
         this.childrenState = header.implicitSubtree ? "unloaded" : "ready";
         this._initializeLodMetric(header);
         this._initializeTransforms(header);
         this._updateLodMetricScale();
         this._initializeBoundingVolumes(header);
         this._initializeContent(header);
+        this._initializeContentEntries(header);
         this._initializeRenderingState(header);
         Object.seal(this);
       }
@@ -12903,12 +13232,16 @@ var init_tile_3d = __esm({
         return this._screenSpaceError;
       }
       /**
-       * Get bounding box in cartographic coordinates
+       * Get the current world-space bounding volume in cartographic coordinates.
        * @returns [min, max] each in [longitude, latitude, altitude]
        */
       get boundingBox() {
         if (!this._boundingBox) {
-          this._boundingBox = getCartographicBounds(this.header.boundingVolume, this.boundingVolume);
+          this._boundingBox = getCartographicBounds(
+            this.header.boundingVolume,
+            this.boundingVolume,
+            !this.computedTransform.equals(this._initialTransform)
+          );
         }
         return this._boundingBox;
       }
@@ -13016,6 +13349,7 @@ var init_tile_3d = __esm({
        */
       // eslint-disable-next-line max-statements, complexity
       async loadContent() {
+        var _a2;
         if (this.hasEmptyContent) {
           return { loaded: false };
         }
@@ -13041,11 +13375,13 @@ var init_tile_3d = __esm({
             this.contents = loadResult.contents;
             this.content = this.contents[0] || null;
           }
+          this.vectorContent = ((_a2 = this.contents.find((content) => Boolean(content == null ? void 0 : content.vectorContent))) == null ? void 0 : _a2.vectorContent) || null;
           if (this.tileset.options.contentLoader) {
             await this.tileset.options.contentLoader(this);
           }
           this.contentState = TILE_CONTENT_STATE.READY;
           this._onContentLoaded();
+          this._updateContentEntriesAfterLoad(loadResult);
           return loadResult;
         } catch (error) {
           this.contentState = TILE_CONTENT_STATE.FAILED;
@@ -13111,30 +13447,116 @@ var init_tile_3d = __esm({
       /**
        * Replaces a contentless implicit placeholder with its materialized subtree-root header.
        *
-       * Transform state is intentionally preserved: the placeholder already owns the composed
-       * transform, and reapplying the root transform here would double-transform bounds and geometric
-       * error. Content and raw geometric error are reinitialized from the newly available header.
+       * The placeholder transform is preserved when the subtree omits a root transform. An explicit
+       * subtree-root transform replaces it and is recomposed against the runtime parent. Content,
+       * metadata, bounds, and raw geometric error are reinitialized from the available header.
        *
        * @param materializedHeader - Available root header produced from one subtree resource.
        */
       applyImplicitSubtreeHeader(materializedHeader) {
         const existingTransform = this.header.transform;
         const existingTransformMatrix = this.header.transformMatrix;
+        const hasMaterializedTransform = materializedHeader.transform !== void 0;
         this.header = {
           ...this.header,
           ...materializedHeader,
-          transform: existingTransform,
-          transformMatrix: existingTransformMatrix,
+          transform: hasMaterializedTransform ? materializedHeader.transform : existingTransform,
+          transformMatrix: hasMaterializedTransform ? materializedHeader.transformMatrix : existingTransformMatrix,
           implicitSubtree: void 0
         };
+        if (hasMaterializedTransform) {
+          this._initializeTransforms(this.header);
+        }
         this.refine = this._getRefine(materializedHeader.refine);
         this.type = materializedHeader.type;
         this.contentUrl = materializedHeader.contentUrl;
         this.contentUrls = materializedHeader.contentUrls || (materializedHeader.contentUrl ? [materializedHeader.contentUrl] : []);
+        this._initializeMetadata(this.header);
         this._initializeLodMetric(materializedHeader);
         this._updateLodMetricScale();
         this._initializeBoundingVolumes(this.header);
+        this._boundingBox = void 0;
         this._initializeContent(this.header);
+        this._initializeContentEntries(this.header);
+      }
+      /** Refreshes tile and content metadata from a source or materialized tile header. */
+      _initializeMetadata(header) {
+        var _a2;
+        this.metadata = header.metadata || null;
+        const contentHeaders = Array.isArray(header.content) ? header.content : [header.content];
+        this.contentMetadata = contentHeaders.filter(Boolean).map((contentHeader) => contentHeader.metadata || null);
+        const firstContentHeader = contentHeaders.find(Boolean) || {};
+        const groupReference = firstContentHeader.group;
+        const group = typeof groupReference === "number" ? ((_a2 = this.tileset.groups) == null ? void 0 : _a2[groupReference]) || null : groupReference || null;
+        const metadataContext = {
+          tileset: this.tileset.metadata || null,
+          group,
+          tile: this.metadata,
+          content: this.contentMetadata[0] || null,
+          subtree: header.implicitMetadata || null
+        };
+        if (this.tileset.groups) {
+          metadataContext.groups = this.tileset.groups;
+        }
+        this.metadataContext = metadataContext;
+      }
+      /** Updates payload and renderability while retaining immutable metadata descriptors. */
+      _updateContentEntriesAfterLoad(loadResult) {
+        if (loadResult.contentEntries) {
+          this.contentEntries = loadResult.contentEntries.map((entry, index) => {
+            var _a2;
+            return {
+              ...entry,
+              index,
+              boundingVolume: entry.boundingVolume || this._contentBoundingVolumes[index] || this.boundingVolume,
+              payload: entry.payload ?? this.contents[index] ?? null,
+              featureIds: ((_a2 = entry.featureIds) == null ? void 0 : _a2.length) ? entry.featureIds : getTile3DFeatureIdSets(entry.payload ?? this.contents[index]),
+              renderable: Boolean(
+                entry.renderable !== false && (entry.payload ?? this.contents[index]) && !isNestedTilesetPayload(entry.payload ?? this.contents[index])
+              )
+            };
+          });
+          this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
+          return;
+        }
+        this.contentEntries = this.contentEntries.map((entry, index) => ({
+          ...entry,
+          payload: this.contents[index] ?? null,
+          featureIds: getTile3DFeatureIdSets(this.contents[index]),
+          renderable: Boolean(this.contents[index]) && !isNestedTilesetPayload(this.contents[index])
+        }));
+        this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
+      }
+      /** Returns one ordered content descriptor, or null when the index is out of range. */
+      getContentEntry(index) {
+        return this.contentEntries[index] || null;
+      }
+      /** Returns whether an ordered content entry currently has renderable payload. */
+      isContentRenderable(index) {
+        var _a2;
+        return Boolean((_a2 = this.contentEntries[index]) == null ? void 0 : _a2.renderable);
+      }
+      /** Initializes additive renderer-neutral descriptors from a normalized tile header. */
+      _initializeContentEntries(tileHeader) {
+        const headers = Array.isArray(tileHeader.content) ? tileHeader.content : tileHeader.content ? [tileHeader.content] : [];
+        this.contentEntries = headers.map((contentHeader, index) => {
+          const normalizedContentHeader = contentHeader || {};
+          return {
+            index,
+            uri: this.contentUrls[index] || normalizedContentHeader.uri || normalizedContentHeader.url,
+            group: normalizedContentHeader.group,
+            type: normalizedContentHeader.type,
+            payload: null,
+            metadata: normalizedContentHeader.metadata || null,
+            boundingVolume: this._contentBoundingVolumes[index] || this.boundingVolume,
+            featureIds: this._getFeatureIdSets(normalizedContentHeader),
+            renderable: false
+          };
+        });
+      }
+      /** Extracts renderer-neutral feature-id declarations without decoding property values. */
+      _getFeatureIdSets(contentHeader) {
+        return getTile3DFeatureIdSets(contentHeader);
       }
       // Unloads the tile's content.
       unloadContent() {
@@ -13145,6 +13567,13 @@ var init_tile_3d = __esm({
         }
         this.contents = [];
         this.content = null;
+        this.vectorContent = null;
+        this.contentEntries = this.contentEntries.map((entry) => ({
+          ...entry,
+          payload: null,
+          renderable: false
+        }));
+        this.featureIdSets = this.contentEntries.flatMap((entry) => entry.featureIds);
         if (this.header.content && this.header.content.destroy) {
           this.header.content.destroy();
         }
@@ -13254,9 +13683,10 @@ var init_tile_3d = __esm({
        * @param frameState Current camera, culling, and optional clipping-plane state.
        * @returns The content visibility classification.
        */
-      contentVisibility(frameState) {
+      contentVisibility(frameState, contentIndex) {
+        const contentVolumes = contentIndex === void 0 ? this._contentBoundingVolumes : this._contentBoundingVolumes[contentIndex] ? [this._contentBoundingVolumes[contentIndex]] : [];
         return getContentVisibility(
-          this._contentBoundingVolumes,
+          contentVolumes,
           this.boundingVolume,
           frameState.cullingVolume,
           this._visibilityPlaneMask,
@@ -13308,6 +13738,8 @@ var init_tile_3d = __esm({
       // INTERNAL METHODS
       /** Initializes the tile's LOD metric from its header or its nearest available ancestor. */
       _initializeLodMetric(header) {
+        var _a2;
+        this._scaleGeometricError = typeof header._scaleGeometricError === "boolean" ? header._scaleGeometricError : ((_a2 = this.parent) == null ? void 0 : _a2._scaleGeometricError) ?? true;
         if ("lodMetricType" in header) {
           this.lodMetricType = header.lodMetricType;
         } else {
@@ -13345,7 +13777,7 @@ var init_tile_3d = __esm({
        * I3S `maxScreenThreshold` is already a screen-space metric and must not be transform-scaled.
        */
       _updateLodMetricScale() {
-        if (this.lodMetricType !== "geometricError" /* GEOMETRIC_ERROR */) {
+        if (this.lodMetricType !== "geometricError" /* GEOMETRIC_ERROR */ || !this._scaleGeometricError) {
           this.lodMetricValue = this._unscaledLodMetricValue;
           return;
         }
@@ -13427,16 +13859,19 @@ var init_tile_3d = __esm({
         }
       }
       _updateBoundingVolume(header) {
+        this._boundingBox = void 0;
         this.boundingVolume = createBoundingVolume(
           header.boundingVolume,
           this.computedTransform,
-          this.boundingVolume
+          this.boundingVolume,
+          this._initialTransform
         );
         if (header.viewerRequestVolume) {
           this._viewerRequestVolume = createBoundingVolume(
             header.viewerRequestVolume,
             this.computedTransform,
-            this._viewerRequestVolume
+            this._viewerRequestVolume,
+            this._initialTransform
           );
         }
         const content = header.content;
@@ -13445,7 +13880,12 @@ var init_tile_3d = __esm({
         }
         const contentHeaders = content ? Array.isArray(content) ? content : [content] : this._contentBoundingVolumeHeaders;
         this._contentBoundingVolumes = contentHeaders.length ? contentHeaders.map(
-          (headerEntry) => (headerEntry == null ? void 0 : headerEntry.boundingVolume) ? createBoundingVolume(headerEntry.boundingVolume, this.computedTransform) : this.boundingVolume
+          (headerEntry) => (headerEntry == null ? void 0 : headerEntry.boundingVolume) ? createBoundingVolume(
+            headerEntry.boundingVolume,
+            this.computedTransform,
+            void 0,
+            this._initialTransform
+          ) : this.boundingVolume
         ) : [this.boundingVolume];
         this._contentBoundingVolume = this._contentBoundingVolumes[0] || null;
       }
@@ -13586,7 +14026,7 @@ function getI3SSpatialReference(layer) {
   const verticalUnitScale = getI3SVerticalUnitScale(verticalUnit, layer.ZFactor);
   const heightReference = heightModel === "ellipsoidal" ? "ellipsoidal" : heightModel === "gravity_related_height" ? "orthometric" : "unknown";
   const sourceIdentifier = getCrsIdentifier(spatialReference);
-  const coordinateFrame = sourceIdentifier === void 0 ? getWktCoordinateFrame(spatialReference == null ? void 0 : spatialReference.wkt) : getIdentifierCoordinateFrame(sourceIdentifier);
+  const coordinateFrame = sourceIdentifier === void 0 ? sourceCrs ? getSpatialCoordinateFrame(sourceCrs) : "unknown" : getSpatialCoordinateFrame(`EPSG:${sourceIdentifier}`);
   const units = getI3SCoordinateUnits(coordinateFrame, verticalUnit, layer.ZFactor);
   const warnings = [];
   const elevationMode = getI3SElevationMode((_e = layer.elevationInfo) == null ? void 0 : _e.mode);
@@ -13660,57 +14100,315 @@ function getI3SVerticalCrsDefinition(spatialReference) {
 function getCrsIdentifier(spatialReference) {
   return (spatialReference == null ? void 0 : spatialReference.latestWkid) ?? (spatialReference == null ? void 0 : spatialReference.wkid);
 }
-function getIdentifierCoordinateFrame(identifier) {
-  if (identifier === 4978) {
-    return "geocentric";
-  }
-  if (identifier === 4326 || identifier === 4490 || identifier === 4979) {
-    return "geographic";
-  }
-  return "projected";
-}
-function getWktCoordinateFrame(wkt) {
-  var _a2;
-  if (!wkt) {
-    return "unknown";
-  }
-  const normalizedWkt = wkt.trim().toUpperCase();
-  const rootKeyword = (_a2 = normalizedWkt.match(/^([A-Z][A-Z0-9_]*)\s*[\[(]/)) == null ? void 0 : _a2[1];
-  if (rootKeyword === "GEOCCS") {
-    return "geocentric";
-  }
-  if (rootKeyword === "GEOGCS" || rootKeyword === "GEOGRAPHICCRS" || rootKeyword === "GEOGRAPHIC2DCRS" || rootKeyword === "GEOGRAPHIC3DCRS") {
-    return "geographic";
-  }
-  if (rootKeyword === "PROJCS" || rootKeyword === "PROJCRS" || rootKeyword === "PROJECTEDCRS") {
-    return "projected";
-  }
-  if (rootKeyword === "GEODCRS" || rootKeyword === "GEODETICCRS") {
-    if (/\bCS\s*[\[(]\s*CARTESIAN\s*,\s*3\b/.test(normalizedWkt)) {
-      return "geocentric";
-    }
-    if (/\bCS\s*[\[(]\s*ELLIPSOIDAL\s*,\s*[23]\b/.test(normalizedWkt)) {
-      return "geographic";
-    }
-  }
-  return "unknown";
-}
 var init_format_spatial_reference = __esm({
   "../tiles/src/spatial/format-spatial-reference.ts"() {
     "use strict";
     init_i3s_elevation();
+    init_get_spatial_coordinate_frame();
     init_spatial_types();
   }
 });
 
-// ../tiles/src/tileset-3d/format-i3s/i3s-pending-tiles-register.ts
-var I3SPendingTilesRegister;
-var init_i3s_pending_tiles_register = __esm({
-  "../tiles/src/tileset-3d/format-i3s/i3s-pending-tiles-register.ts"() {
-    "use strict";
-    I3SPendingTilesRegister = class {
-      frameNumberMap = /* @__PURE__ */ new Map();
-      /**
+// ../tiles/src/spatial/spatial-resource-registry.ts
+function getGeoidModel(name) {
+  return geoidModels.get(name);
+}
+var import_geoid, import_proj4, geoidModels;
+var init_spatial_resource_registry = __esm({
+  "../tiles/src/spatial/spatial-resource-registry.ts"() {
+    "use strict";
+    import_geoid = require("@math.gl/geoid");
+    import_proj4 = require("@math.gl/proj4");
+    geoidModels = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../tiles/src/spatial/spatial-coordinate-transformer.ts
+function getFiniteDifferenceJacobian(transformer, position, epsilon) {
+  const columns = [];
+  for (let axis = 0; axis < 3; axis++) {
+    const plus = position.slice();
+    const minus = position.slice();
+    plus[axis] += epsilon;
+    minus[axis] -= epsilon;
+    const plusPosition = transformer.transformPosition(plus);
+    const minusPosition = transformer.transformPosition(minus);
+    columns.push([
+      (plusPosition[0] - minusPosition[0]) / (2 * epsilon),
+      (plusPosition[1] - minusPosition[1]) / (2 * epsilon),
+      (plusPosition[2] - minusPosition[2]) / (2 * epsilon)
+    ]);
+  }
+  return columns;
+}
+function inverseTransposeMultiply(jacobianColumns, vector) {
+  const [a, b, c] = jacobianColumns;
+  const determinant = a[0] * (b[1] * c[2] - b[2] * c[1]) - b[0] * (a[1] * c[2] - a[2] * c[1]) + c[0] * (a[1] * b[2] - a[2] * b[1]);
+  if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-15) {
+    return vector;
+  }
+  const inverseTranspose = [
+    [b[1] * c[2] - b[2] * c[1], a[2] * c[1] - a[1] * c[2], a[1] * b[2] - a[2] * b[1]],
+    [b[2] * c[0] - b[0] * c[2], a[0] * c[2] - a[2] * c[0], a[2] * b[0] - a[0] * b[2]],
+    [b[0] * c[1] - b[1] * c[0], a[1] * c[0] - a[0] * c[1], a[0] * b[1] - a[1] * b[0]]
+  ];
+  return inverseTranspose.map(
+    (row) => (row[0] * vector[0] + row[1] * vector[1] + row[2] * vector[2]) / determinant
+  );
+}
+function getHorizontalProj4Definition(definition) {
+  if (!definition) {
+    throw new Error("Cannot construct a projection because the CRS is unknown");
+  }
+  return (0, import_proj42.toProj4CRSDefinition)(definition, { mode: "horizontal" });
+}
+function validateTransformRequest(spatialReference) {
+  if (spatialReference.outputCoordinates === "local-enu") {
+    throw new Error(
+      "local-enu output requires a dataset-derived local origin and must be created by a tileset source"
+    );
+  }
+  if (spatialReference.outputCoordinates === "target-crs" && !spatialReference.targetCrs) {
+    throw new Error("target-crs output requires targetCrs");
+  }
+  if (!spatialReference.sourceCrs && spatialReference.status === "unresolved") {
+    throw new Error("Cannot transform coordinates because the source CRS is unknown");
+  }
+  if (requiresHeightTransformation(spatialReference) && spatialReference.heightReference === "unknown") {
+    throw new Error("Cannot convert heights because the source height reference is unknown");
+  }
+  if (spatialReference.coordinateFrame === "geocentric" && !isWgs84Geocentric(spatialReference.sourceCrs)) {
+    throw new Error(
+      "Only EPSG:4978 geocentric coordinates are supported by the current spatial transformer"
+    );
+  }
+  if (spatialReference.status === "unresolved") {
+    throw new Error("The requested spatial output cannot be resolved from the available metadata");
+  }
+}
+function isWgs84Geocentric(definition) {
+  return typeof definition === "string" && normalizeCrsIdentifier(definition) === WGS84_GEOCENTRIC_CRS;
+}
+function isWgs84Geographic(definition) {
+  if (typeof definition !== "string") {
+    return false;
+  }
+  const identifier = normalizeCrsIdentifier(definition);
+  return identifier === WGS84_GEOGRAPHIC_CRS || identifier === "EPSG:4979" || identifier === "OGC:CRS84";
+}
+function requiresHeightTransformation(spatialReference) {
+  const target = spatialReference.targetHeightReference;
+  return target !== "native" && target !== spatialReference.heightReference;
+}
+function resolveGeoid(model) {
+  return typeof model === "string" ? getGeoidModel(model) : model;
+}
+function transformHeight(height, geoidUndulation, source, target) {
+  if (source === target || target === "native") {
+    return height;
+  }
+  if (source === "orthometric" && target === "ellipsoidal") {
+    return height + geoidUndulation;
+  }
+  if (source === "ellipsoidal" && target === "orthometric") {
+    return height - geoidUndulation;
+  }
+  throw new Error(`Unsupported height conversion from ${source} to ${target}`);
+}
+var import_core7, import_geospatial4, import_proj42, SpatialCoordinateTransformer;
+var init_spatial_coordinate_transformer = __esm({
+  "../tiles/src/spatial/spatial-coordinate-transformer.ts"() {
+    "use strict";
+    import_core7 = require("@math.gl/core");
+    import_geospatial4 = require("@math.gl/geospatial");
+    import_proj42 = require("@math.gl/proj4");
+    init_spatial_resource_registry();
+    init_normalize_crs_identifier();
+    init_get_spatial_coordinate_frame();
+    SpatialCoordinateTransformer = class {
+      /** Normalized spatial metadata describing this transformation. */
+      spatialReference;
+      /** Projection from the source CRS directly to the requested horizontal target CRS. */
+      horizontalProjection;
+      /** Projection from the source CRS to geographic longitude, latitude, and ellipsoidal height. */
+      geographicProjection;
+      /** Projection from adjusted geographic coordinates to the requested output CRS. */
+      heightOutputProjection;
+      /** Whether source coordinates use the WGS84 geocentric frame handled by math.gl. */
+      sourceIsGeocentric;
+      /** Whether output coordinates use the WGS84 geocentric frame handled by math.gl. */
+      outputIsGeocentric;
+      /** Whether source coordinates already use conventional WGS84 longitude/latitude order. */
+      sourceIsGeographic;
+      /** Whether output coordinates use conventional WGS84 longitude/latitude order. */
+      outputIsGeographic;
+      /** Geoid model used to convert between ellipsoidal and orthometric heights. */
+      geoid;
+      /**
+       * Creates a coordinate transformer.
+       *
+       * @param spatialReference - Format-discovered and option-normalized spatial metadata.
+       * @param options - Application options containing an optional geoid model.
+       */
+      constructor(spatialReference, options = {}) {
+        this.spatialReference = spatialReference;
+        validateTransformRequest(spatialReference);
+        const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
+        this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
+        this.outputIsGeocentric = isWgs84Geocentric(outputCrs);
+        this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
+        this.outputIsGeographic = isWgs84Geographic(outputCrs);
+        if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
+          this.horizontalProjection = new import_proj42.Proj4Projection({
+            from: getHorizontalProj4Definition(spatialReference.sourceCrs),
+            to: getHorizontalProj4Definition(spatialReference.targetCrs),
+            enforceAxis: false
+          });
+        }
+        if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
+          if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
+            this.geographicProjection = new import_proj42.Proj4Projection({
+              from: getHorizontalProj4Definition(spatialReference.sourceCrs),
+              to: WGS84_GEOGRAPHIC_CRS,
+              enforceAxis: false
+            });
+          }
+          if (!this.outputIsGeographic && !this.outputIsGeocentric) {
+            this.heightOutputProjection = new import_proj42.Proj4Projection({
+              from: WGS84_GEOGRAPHIC_CRS,
+              to: getHorizontalProj4Definition(outputCrs),
+              enforceAxis: false
+            });
+          }
+        }
+        if (requiresHeightTransformation(spatialReference)) {
+          this.geoid = resolveGeoid(options.geoidModel);
+          if (!this.geoid) {
+            const modelName = typeof options.geoidModel === "string" ? ` "${options.geoidModel}"` : "";
+            throw new Error(
+              `Height conversion requires a registered geoid model${modelName}; call registerGeoidModel() or pass a parsed Geoid instance`
+            );
+          }
+        }
+      }
+      /**
+       * Transforms one `[x, y, z?]` coordinate while retaining additional components.
+       *
+       * @param coordinate - Source coordinate in the format adapter's normalized `x/y/z` order.
+       * @returns A new transformed coordinate array.
+       */
+      transformPosition(coordinate) {
+        if (coordinate.length < 2) {
+          throw new Error("A spatial coordinate must contain at least x and y components");
+        }
+        const result = [...coordinate];
+        if (requiresHeightTransformation(this.spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
+          if (result.length < 3 || !Number.isFinite(result[2])) {
+            throw new Error("Three-dimensional CRS conversion requires a finite z coordinate");
+          }
+          const geographic = this.toGeographic(result);
+          if (requiresHeightTransformation(this.spatialReference)) {
+            const geoidUndulation = this.geoid.getHeight(geographic[1], geographic[0]);
+            geographic[2] = transformHeight(
+              geographic[2],
+              geoidUndulation,
+              this.spatialReference.heightReference,
+              this.spatialReference.targetHeightReference
+            );
+          }
+          const projected = this.fromGeographic(geographic);
+          result.splice(0, projected.length, ...projected);
+          return result;
+        }
+        if (this.horizontalProjection) {
+          const projected = this.horizontalProjection.project(result.slice(0, 3));
+          result.splice(0, projected.length, ...projected);
+        }
+        return result;
+      }
+      /** Transform a packed sequence of xyz positions, preserving the input array type only when safe. */
+      transformPositions(positions) {
+        if (positions.length % 3 !== 0) {
+          throw new Error("Packed spatial positions must contain a multiple of three components");
+        }
+        const transformedPositions = new Float64Array(positions.length);
+        for (let index = 0; index < positions.length; index += 3) {
+          const transformed = this.transformPosition([
+            Number(positions[index]),
+            Number(positions[index + 1]),
+            Number(positions[index + 2])
+          ]);
+          transformedPositions[index] = transformed[0];
+          transformedPositions[index + 1] = transformed[1];
+          transformedPositions[index + 2] = transformed[2];
+        }
+        return transformedPositions;
+      }
+      /** Transform packed xyz normals using a local finite-difference tangent approximation. */
+      transformNormals(normals, positions) {
+        if (normals.length !== positions.length || normals.length % 3 !== 0) {
+          throw new Error("Spatial normals and positions must have matching xyz component counts");
+        }
+        const transformedNormals = new Float32Array(normals.length);
+        const epsilon = 1e-5;
+        for (let index = 0; index < normals.length; index += 3) {
+          const position = [
+            Number(positions[index]),
+            Number(positions[index + 1]),
+            Number(positions[index + 2])
+          ];
+          const normal = [
+            Number(normals[index]),
+            Number(normals[index + 1]),
+            Number(normals[index + 2])
+          ];
+          const jacobian = getFiniteDifferenceJacobian(this, position, epsilon);
+          const transformedNormal = inverseTransposeMultiply(jacobian, normal);
+          const length = Math.hypot(...transformedNormal);
+          if (length > 0 && Number.isFinite(length)) {
+            transformedNormals[index] = transformedNormal[0] / length;
+            transformedNormals[index + 1] = transformedNormal[1] / length;
+            transformedNormals[index + 2] = transformedNormal[2] / length;
+          } else {
+            transformedNormals[index] = normal[0];
+            transformedNormals[index + 1] = normal[1];
+            transformedNormals[index + 2] = normal[2];
+          }
+        }
+        return transformedNormals;
+      }
+      /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
+      toGeographic(coordinate) {
+        if (this.sourceIsGeocentric) {
+          return Array.from(import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(new import_core7.Vector3(coordinate)));
+        }
+        if (this.sourceIsGeographic) {
+          return coordinate.slice(0, 3);
+        }
+        return this.geographicProjection.project(coordinate.slice(0, 3));
+      }
+      /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
+      fromGeographic(coordinate) {
+        if (this.outputIsGeocentric) {
+          return Array.from(import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core7.Vector3(coordinate)));
+        }
+        if (this.outputIsGeographic) {
+          return coordinate.slice(0, 3);
+        }
+        return this.heightOutputProjection.project(coordinate.slice(0, 3));
+      }
+    };
+  }
+});
+
+// ../tiles/src/tileset-3d/format-i3s/i3s-pending-tiles-register.ts
+var I3SPendingTilesRegister;
+var init_i3s_pending_tiles_register = __esm({
+  "../tiles/src/tileset-3d/format-i3s/i3s-pending-tiles-register.ts"() {
+    "use strict";
+    I3SPendingTilesRegister = class {
+      frameNumberMap = /* @__PURE__ */ new Map();
+      /**
        * Register a new pending tile header for the particular frameNumber
        * @param viewportId
        * @param frameNumber
@@ -13924,223 +14622,6 @@ var init_i3s_tileset_traverser = __esm({
   }
 });
 
-// ../tiles/src/spatial/spatial-resource-registry.ts
-function getGeoidModel(name) {
-  return geoidModels.get(name);
-}
-var import_geoid, import_proj4, geoidModels;
-var init_spatial_resource_registry = __esm({
-  "../tiles/src/spatial/spatial-resource-registry.ts"() {
-    "use strict";
-    import_geoid = require("@math.gl/geoid");
-    import_proj4 = require("@math.gl/proj4");
-    geoidModels = /* @__PURE__ */ new Map();
-  }
-});
-
-// ../tiles/src/spatial/spatial-coordinate-transformer.ts
-function getHorizontalProj4Definition(definition) {
-  if (!definition) {
-    throw new Error("Cannot construct a projection because the CRS is unknown");
-  }
-  return (0, import_proj42.toProj4CRSDefinition)(definition, { mode: "horizontal" });
-}
-function validateTransformRequest(spatialReference) {
-  if (spatialReference.outputCoordinates === "local-enu") {
-    throw new Error(
-      "local-enu output requires a dataset-derived local origin and must be created by a tileset source"
-    );
-  }
-  if (spatialReference.outputCoordinates === "target-crs" && !spatialReference.targetCrs) {
-    throw new Error("target-crs output requires targetCrs");
-  }
-  if (!spatialReference.sourceCrs && spatialReference.status === "unresolved") {
-    throw new Error("Cannot transform coordinates because the source CRS is unknown");
-  }
-  if (requiresHeightTransformation(spatialReference) && spatialReference.heightReference === "unknown") {
-    throw new Error("Cannot convert heights because the source height reference is unknown");
-  }
-  if (spatialReference.coordinateFrame === "geocentric" && !isWgs84Geocentric(spatialReference.sourceCrs)) {
-    throw new Error(
-      "Only EPSG:4978 geocentric coordinates are supported by the current spatial transformer"
-    );
-  }
-  if (spatialReference.status === "unresolved") {
-    throw new Error("The requested spatial output cannot be resolved from the available metadata");
-  }
-}
-function isWgs84Geocentric(definition) {
-  return typeof definition === "string" && normalizeCrsIdentifier2(definition) === GEOCENTRIC_CRS2;
-}
-function isWgs84Geographic(definition) {
-  if (typeof definition !== "string") {
-    return false;
-  }
-  const identifier = normalizeCrsIdentifier2(definition);
-  return identifier === GEOGRAPHIC_CRS2 || identifier === "EPSG:4979" || identifier === "OGC:CRS84";
-}
-function normalizeCrsIdentifier2(identifier) {
-  const normalizedIdentifier = identifier.trim().toUpperCase();
-  const ogcMatch = normalizedIdentifier.match(
-    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
-  );
-  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
-}
-function requiresHeightTransformation(spatialReference) {
-  const target = spatialReference.targetHeightReference;
-  return target !== "native" && target !== spatialReference.heightReference;
-}
-function resolveGeoid(model) {
-  return typeof model === "string" ? getGeoidModel(model) : model;
-}
-function transformHeight(height, geoidUndulation, source, target) {
-  if (source === target || target === "native") {
-    return height;
-  }
-  if (source === "orthometric" && target === "ellipsoidal") {
-    return height + geoidUndulation;
-  }
-  if (source === "ellipsoidal" && target === "orthometric") {
-    return height - geoidUndulation;
-  }
-  throw new Error(`Unsupported height conversion from ${source} to ${target}`);
-}
-var import_core7, import_geospatial4, import_proj42, GEOGRAPHIC_CRS2, GEOCENTRIC_CRS2, SpatialCoordinateTransformer;
-var init_spatial_coordinate_transformer = __esm({
-  "../tiles/src/spatial/spatial-coordinate-transformer.ts"() {
-    "use strict";
-    import_core7 = require("@math.gl/core");
-    import_geospatial4 = require("@math.gl/geospatial");
-    import_proj42 = require("@math.gl/proj4");
-    init_spatial_resource_registry();
-    init_get_spatial_coordinate_frame();
-    GEOGRAPHIC_CRS2 = "EPSG:4326";
-    GEOCENTRIC_CRS2 = "EPSG:4978";
-    SpatialCoordinateTransformer = class {
-      /** Normalized spatial metadata describing this transformation. */
-      spatialReference;
-      /** Projection from the source CRS directly to the requested horizontal target CRS. */
-      horizontalProjection;
-      /** Projection from the source CRS to geographic longitude, latitude, and ellipsoidal height. */
-      geographicProjection;
-      /** Projection from adjusted geographic coordinates to the requested output CRS. */
-      heightOutputProjection;
-      /** Whether source coordinates use the WGS84 geocentric frame handled by math.gl. */
-      sourceIsGeocentric;
-      /** Whether output coordinates use the WGS84 geocentric frame handled by math.gl. */
-      outputIsGeocentric;
-      /** Whether source coordinates already use conventional WGS84 longitude/latitude order. */
-      sourceIsGeographic;
-      /** Whether output coordinates use conventional WGS84 longitude/latitude order. */
-      outputIsGeographic;
-      /** Geoid model used to convert between ellipsoidal and orthometric heights. */
-      geoid;
-      /**
-       * Creates a coordinate transformer.
-       *
-       * @param spatialReference - Format-discovered and option-normalized spatial metadata.
-       * @param options - Application options containing an optional geoid model.
-       */
-      constructor(spatialReference, options = {}) {
-        this.spatialReference = spatialReference;
-        validateTransformRequest(spatialReference);
-        const outputCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
-        this.sourceIsGeocentric = isWgs84Geocentric(spatialReference.sourceCrs);
-        this.outputIsGeocentric = isWgs84Geocentric(outputCrs);
-        this.sourceIsGeographic = isWgs84Geographic(spatialReference.sourceCrs);
-        this.outputIsGeographic = isWgs84Geographic(outputCrs);
-        if (spatialReference.sourceCrs && spatialReference.targetCrs && !this.sourceIsGeocentric && !this.outputIsGeocentric) {
-          this.horizontalProjection = new import_proj42.Proj4Projection({
-            from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-            to: getHorizontalProj4Definition(spatialReference.targetCrs),
-            enforceAxis: false
-          });
-        }
-        if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
-          if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
-            this.geographicProjection = new import_proj42.Proj4Projection({
-              from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-              to: GEOGRAPHIC_CRS2,
-              enforceAxis: false
-            });
-          }
-          if (!this.outputIsGeographic && !this.outputIsGeocentric) {
-            this.heightOutputProjection = new import_proj42.Proj4Projection({
-              from: GEOGRAPHIC_CRS2,
-              to: getHorizontalProj4Definition(outputCrs),
-              enforceAxis: false
-            });
-          }
-        }
-        if (requiresHeightTransformation(spatialReference)) {
-          this.geoid = resolveGeoid(options.geoidModel);
-          if (!this.geoid) {
-            const modelName = typeof options.geoidModel === "string" ? ` "${options.geoidModel}"` : "";
-            throw new Error(
-              `Height conversion requires a registered geoid model${modelName}; call registerGeoidModel() or pass a parsed Geoid instance`
-            );
-          }
-        }
-      }
-      /**
-       * Transforms one `[x, y, z?]` coordinate while retaining additional components.
-       *
-       * @param coordinate - Source coordinate in the format adapter's normalized `x/y/z` order.
-       * @returns A new transformed coordinate array.
-       */
-      transformPosition(coordinate) {
-        if (coordinate.length < 2) {
-          throw new Error("A spatial coordinate must contain at least x and y components");
-        }
-        const result = [...coordinate];
-        if (requiresHeightTransformation(this.spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
-          if (result.length < 3 || !Number.isFinite(result[2])) {
-            throw new Error("Three-dimensional CRS conversion requires a finite z coordinate");
-          }
-          const geographic = this.toGeographic(result);
-          if (requiresHeightTransformation(this.spatialReference)) {
-            const geoidUndulation = this.geoid.getHeight(geographic[1], geographic[0]);
-            geographic[2] = transformHeight(
-              geographic[2],
-              geoidUndulation,
-              this.spatialReference.heightReference,
-              this.spatialReference.targetHeightReference
-            );
-          }
-          const projected = this.fromGeographic(geographic);
-          result.splice(0, projected.length, ...projected);
-          return result;
-        }
-        if (this.horizontalProjection) {
-          const projected = this.horizontalProjection.project(result.slice(0, 3));
-          result.splice(0, projected.length, ...projected);
-        }
-        return result;
-      }
-      /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
-      toGeographic(coordinate) {
-        if (this.sourceIsGeocentric) {
-          return Array.from(import_geospatial4.Ellipsoid.WGS84.cartesianToCartographic(new import_core7.Vector3(coordinate)));
-        }
-        if (this.sourceIsGeographic) {
-          return coordinate.slice(0, 3);
-        }
-        return this.geographicProjection.project(coordinate.slice(0, 3));
-      }
-      /** Convert one conventional WGS84 geographic coordinate to the selected output CRS. */
-      fromGeographic(coordinate) {
-        if (this.outputIsGeocentric) {
-          return Array.from(import_geospatial4.Ellipsoid.WGS84.cartographicToCartesian(new import_core7.Vector3(coordinate)));
-        }
-        if (this.outputIsGeographic) {
-          return coordinate.slice(0, 3);
-        }
-        return this.heightOutputProjection.project(coordinate.slice(0, 3));
-      }
-    };
-  }
-});
-
 // ../tiles/src/spatial/i3s-spatial-transformer.ts
 function getElevationProvider(mode, options) {
   return mode === "relativeToScene" ? options.sceneElevationProvider : requiresElevationSurface(mode) ? options.terrainElevationProvider : void 0;
@@ -15449,7 +15930,7 @@ async function loadI3STexture(textureUrl, textureFormat, tileOptions, options, c
   };
 }
 async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options, context) {
-  var _a2, _b, _c, _d, _e;
+  var _a2, _b, _c, _d, _e, _f;
   const contentByteLength = arrayBuffer.byteLength;
   let attributes;
   let vertexCount;
@@ -15463,6 +15944,8 @@ async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOp
       DracoLoader,
       {
         draco: {
+          // I3S geometry processing consumes the legacy mesh contract.
+          shape: "mesh",
           attributeNameEntry: I3S_ATTRIBUTE_TYPE
         }
       },
@@ -15572,8 +16055,7 @@ async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOp
   content.attributes = {
     positions: attributes.position,
     normals: attributes.normal,
-    colors: normalizeAttribute(attributes.color),
-    // Normalize from UInt8
+    colors: normalizeAttribute(attributes.color, ((_f = options == null ? void 0 : options.i3s) == null ? void 0 : _f.colorFormat) || "uint8norm"),
     uvRegions: normalizeAttribute(attributes.uvRegion || attributes.region)
     // Normalize from UInt16
   };
@@ -15684,12 +16166,26 @@ function updateAttributesMetadata(attributes, decompressedGeometry) {
 function concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes) {
   return { ...normalizedVertexAttributes, ...normalizedFeatureAttributes };
 }
-function normalizeAttribute(attribute) {
+function normalizeAttribute(attribute, colorFormat = "uint8norm") {
   if (!attribute) {
     return attribute;
   }
-  attribute.normalized = true;
-  return attribute;
+  if (colorFormat === "float16" && !attribute.componentType) {
+    return {
+      ...attribute,
+      value: convertColorArrayToFloat16(attribute.value, 255),
+      normalized: false,
+      componentType: "float16"
+    };
+  }
+  if (colorFormat === "float32" && !attribute.componentType) {
+    return {
+      ...attribute,
+      value: Float32Array.from(attribute.value, (value) => value / 255),
+      normalized: false
+    };
+  }
+  return { ...attribute, normalized: true };
 }
 function parseHeaders(arrayBuffer, geometrySchema) {
   let byteOffset = 0;
@@ -15965,6 +16461,7 @@ var import_core10, import_geospatial7, scratchVector3, I3S_ATTRIBUTE_TYPE;
 var init_parse_i3s_tile_content = __esm({
   "../i3s/src/lib/parsers/parse-i3s-tile-content.ts"() {
     "use strict";
+    init_src();
     import_core10 = require("@math.gl/core");
     import_geospatial7 = require("@math.gl/geospatial");
     init_src5();
@@ -21827,13 +22324,14 @@ var ArcGISVectorSource = class extends DataSource {
   getFeaturesURL(parameters) {
     var _a2;
     const defaultParameters = ((_a2 = this.options["arcgis-feature-server"]) == null ? void 0 : _a2.queryParameters) || {};
-    const spatialReference = normalizeArcGISSpatialReference(parameters.crs) || 4326;
+    const outputSpatialReference = normalizeArcGISSpatialReference(parameters.crs) || 4326;
+    const requestSpatialReference = normalizeArcGISSpatialReference(parameters.requestCrs) || outputSpatialReference;
     const queryParameters = {
       returnGeometry: true,
       where: "1=1",
       outFields: "*",
-      outSR: spatialReference,
-      inSR: spatialReference,
+      outSR: outputSpatialReference,
+      inSR: requestSpatialReference,
       f: "geojson",
       ...defaultParameters
     };
@@ -21992,10 +22490,10 @@ var ArcGISImageSource = class extends DataSource {
   }
   /** Requests an image from generic ImageSource parameters. */
   async getImage(parameters) {
-    const { boundingBox, bbox, width, height, crs, format, signal } = parameters;
+    const { boundingBox, width, height, crs, format, signal } = parameters;
     const spatialReference = normalizeArcGISSpatialReference2(crs) || "4326";
     const imageParameters = {
-      bbox: boundingBox ? [...boundingBox[0], ...boundingBox[1]] : bbox,
+      bbox: [...boundingBox[0], ...boundingBox[1]],
       bboxSR: spatialReference,
       imageSR: spatialReference,
       width,
@@ -22573,6 +23071,7 @@ init_src5();
 // ../i3s/src/i3s-point-cloud-source.ts
 init_src5();
 init_src2();
+init_src();
 var import_core12 = require("@math.gl/core");
 var import_geospatial9 = require("@math.gl/geospatial");
 init_src9();
@@ -22717,6 +23216,7 @@ var I3SPointCloudSource = class extends DataSource {
     const descriptors = this.getAttributeDescriptors();
     await Promise.all(
       descriptors.map(async (descriptor) => {
+        var _a3, _b2;
         const bytes = await this.readBinaryOptional(
           this.resourceCandidates(
             `nodes/${resourceId}/attributes/${descriptor.key || descriptor.name || ""}/${descriptor.resource ?? 0}`,
@@ -22733,10 +23233,16 @@ var I3SPointCloudSource = class extends DataSource {
           );
         }
         const attributeName = this.getAttributeName(descriptor, decoded.kind);
-        attributes[attributeName] = {
-          value: decoded.value,
-          size: decoded.size
-        };
+        attributes[attributeName] = attributeName === "COLOR_0" && ((_a3 = this.options.i3s) == null ? void 0 : _a3.colorFormat) === "float16" ? {
+          value: convertColorArrayToFloat16(decoded.value, 255),
+          size: decoded.size,
+          normalized: false,
+          componentType: "float16"
+        } : attributeName === "COLOR_0" && ((_b2 = this.options.i3s) == null ? void 0 : _b2.colorFormat) === "float32" ? {
+          value: Float32Array.from(decoded.value, (value) => value / 255),
+          size: decoded.size,
+          normalized: false
+        } : { value: decoded.value, size: decoded.size };
       })
     );
     const volume = tile.spatialBoundingVolume || tile.boundingVolume;