@loaders.gl/tile-converter 5.0.0-alpha.6 → 5.0.0-alpha.8

package/dist/v5/index.js

@@ -0,0 +1,3928 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// ../../modules/loader-utils/src/lib/env-utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loader assertion failed.");
+  }
+}
+var init_assert = __esm({
+  "../../modules/loader-utils/src/lib/env-utils/assert.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/loader-utils/src/lib/binary-utils/memory-copy-utils.ts
+function padToNBytes(byteLength, padding) {
+  assert(byteLength >= 0);
+  assert(padding > 0);
+  return byteLength + (padding - 1) & ~(padding - 1);
+}
+var init_memory_copy_utils = __esm({
+  "../../modules/loader-utils/src/lib/binary-utils/memory-copy-utils.ts"() {
+    "use strict";
+    init_assert();
+  }
+});
+
+// ../../modules/loader-utils/src/lib/binary-utils/dataview-copy-utils.ts
+function padStringToByteAlignment(string, byteAlignment) {
+  const length = string.length;
+  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
+  const padding = paddedLength - length;
+  let whitespace = "";
+  for (let i = 0; i < padding; ++i) {
+    whitespace += " ";
+  }
+  return string + whitespace;
+}
+function copyStringToDataView(dataView, byteOffset, string, byteLength) {
+  if (dataView) {
+    for (let i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
+  if (dataView) {
+    for (let i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, binary[i]);
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
+  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
+  const padLength = paddedLength - sourceBuffer.byteLength;
+  if (dataView) {
+    const targetArray = new Uint8Array(
+      dataView.buffer,
+      dataView.byteOffset + byteOffset,
+      sourceBuffer.byteLength
+    );
+    const sourceArray = new Uint8Array(sourceBuffer);
+    targetArray.set(sourceArray);
+    for (let i = 0; i < padLength; ++i) {
+      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 32);
+    }
+  }
+  byteOffset += paddedLength;
+  return byteOffset;
+}
+function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
+  const textEncoder = new TextEncoder();
+  const stringBuffer = textEncoder.encode(string);
+  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
+  return byteOffset;
+}
+var init_dataview_copy_utils = __esm({
+  "../../modules/loader-utils/src/lib/binary-utils/dataview-copy-utils.ts"() {
+    "use strict";
+    init_memory_copy_utils();
+  }
+});
+
+// ../../modules/loader-utils/src/index.ts
+var init_src = __esm({
+  "../../modules/loader-utils/src/index.ts"() {
+    "use strict";
+    init_assert();
+    init_memory_copy_utils();
+    init_dataview_copy_utils();
+  }
+});
+
+// ../../modules/tiles/src/spatial/normalize-crs-identifier.ts
+function normalizeCrsIdentifier(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;
+}
+var WGS84_GEOGRAPHIC_CRS, WGS84_GEOCENTRIC_CRS;
+var init_normalize_crs_identifier = __esm({
+  "../../modules/tiles/src/spatial/normalize-crs-identifier.ts"() {
+    "use strict";
+    WGS84_GEOGRAPHIC_CRS = "EPSG:4326";
+    WGS84_GEOCENTRIC_CRS = "EPSG:4978";
+  }
+});
+
+// ../../modules/tiles/src/spatial/get-spatial-coordinate-frame.ts
+import {
+  inferCRSRepresentation,
+  parsePROJString,
+  parseWKTCRS
+} from "@math.gl/crs";
+function getSpatialCoordinateFrame(definition) {
+  if (typeof definition === "string") {
+    const representation = inferCRSRepresentation(definition);
+    if (representation === "wkt") {
+      return getWktCoordinateFrame(definition);
+    }
+    if (representation === "proj-string") {
+      return getProjStringCoordinateFrame(definition);
+    }
+    return getKnownCrsIdentifierCoordinateFrame(definition) || "projected";
+  }
+  const projJsonDefinition = definition;
+  if (projJsonDefinition.type === "BoundCRS" && projJsonDefinition.source_crs) {
+    return getSpatialCoordinateFrame(projJsonDefinition.source_crs);
+  }
+  if (projJsonDefinition.type === "CompoundCRS" && projJsonDefinition.components?.[0]) {
+    return getSpatialCoordinateFrame(projJsonDefinition.components[0]);
+  }
+  if (String(projJsonDefinition.type).includes("Projected")) {
+    return "projected";
+  }
+  if (String(projJsonDefinition.type).includes("Geographic")) {
+    return "geographic";
+  }
+  if (String(projJsonDefinition.type).includes("Geodetic")) {
+    return projJsonDefinition.coordinate_system?.subtype === "Cartesian" ? "geocentric" : "geographic";
+  }
+  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 = 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?.values[0];
+      if (subtype?.type !== "enumeration" && subtype?.type !== "string") {
+        return "unknown";
+      }
+      return subtype.value.toUpperCase() === "CARTESIAN" ? "geocentric" : subtype.value.toUpperCase() === "ELLIPSOIDAL" ? "geographic" : "unknown";
+    }
+    default:
+      return "unknown";
+  }
+}
+function getProjStringCoordinateFrame(definition) {
+  try {
+    const projection = parsePROJString(definition).parameters.find(
+      (parameter) => parameter.name.toLowerCase() === "proj"
+    )?.value;
+    switch (projection?.toLowerCase()) {
+      case "longlat":
+      case "latlong":
+        return "geographic";
+      case "geocent":
+        return "geocentric";
+      default:
+        return projection ? "projected" : "unknown";
+    }
+  } catch {
+    return "unknown";
+  }
+}
+var init_get_spatial_coordinate_frame = __esm({
+  "../../modules/tiles/src/spatial/get-spatial-coordinate-frame.ts"() {
+    "use strict";
+    init_normalize_crs_identifier();
+  }
+});
+
+// ../../modules/tiles/src/spatial/spatial-types.ts
+import {
+  createSpatialReference,
+  inferCRSRepresentation as inferCRSRepresentation2
+} from "@math.gl/crs";
+function createTilesetSpatialReference(discovered, options = {}) {
+  const hasSourceCrsOverride = options.sourceCrs !== void 0;
+  const sourceCrs = options.sourceCrs || discovered.sourceCrs;
+  const outputCoordinates = options.outputCoordinates || "auto";
+  const targetCrs = options.targetCrs || (outputCoordinates === "ecef" ? "EPSG:4978" : void 0);
+  const targetHeightReference = options.targetHeightReference || "native";
+  const verticalUnitScale = discovered.verticalUnitScale ?? 1;
+  const elevationUnitScale = discovered.elevationUnitScale ?? 1;
+  const elevationOffset = discovered.elevationOffset || 0;
+  const requiresSurface = discovered.elevationMode === "onTheGround" || discovered.elevationMode === "relativeToGround" || discovered.elevationMode === "relativeToScene";
+  const hasElevationProvider = discovered.elevationMode === "relativeToScene" ? Boolean(options.sceneElevationProvider) : !requiresSurface || Boolean(options.terrainElevationProvider);
+  const hasFormatVerticalOperation = verticalUnitScale !== 1 || elevationUnitScale !== 1 || discovered.elevationMode !== void 0 && (requiresSurface || discovered.elevationMode === "absoluteHeight" && elevationOffset !== 0);
+  const needsHeightTransform = targetHeightReference !== "native" && targetHeightReference !== discovered.heightReference;
+  const hasRequestedTransform = Boolean(targetCrs) || targetHeightReference !== "native" || outputCoordinates !== "auto" || hasFormatVerticalOperation;
+  const hasRequiredTarget = outputCoordinates !== "target-crs" || Boolean(targetCrs);
+  const hasHeightMetadata = !needsHeightTransform || (discovered.heightReference || "unknown") !== "unknown";
+  const hasVerticalUnits = Number.isFinite(verticalUnitScale) && verticalUnitScale > 0 && Number.isFinite(elevationUnitScale) && elevationUnitScale > 0;
+  const canTransform = Boolean(sourceCrs) && hasRequestedTransform && hasRequiredTarget && hasHeightMetadata && hasVerticalUnits && hasElevationProvider && outputCoordinates !== "local-enu";
+  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 = createSpatialReference({
+    crs: sourceCrs ? {
+      state: sourceCrsState === "default" ? "default" : "explicit",
+      definition: sourceCrs,
+      representation: !hasSourceCrsOverride && discovered.sourceCrsRepresentation || inferCRSRepresentation2(sourceCrs),
+      provenance,
+      alternatives: hasSourceCrsOverride ? void 0 : discovered.sourceCrsAlternatives
+    } : {
+      state: sourceCrsState === "unknown" ? "unknown" : "absent",
+      provenance
+    },
+    vertical: discovered.verticalCrs ? {
+      state: "explicit",
+      definition: discovered.verticalCrs,
+      representation: inferCRSRepresentation2(discovered.verticalCrs),
+      provenance: discovered.provenance || "metadata"
+    } : void 0,
+    coordinateEpoch: options.coordinateEpoch ?? discovered.coordinateEpoch,
+    coordinateFrame,
+    coordinateOrder: getCoordinateOrder(discovered.axisOrder),
+    units: hasSourceCrsOverride ? void 0 : discovered.units
+  });
+  const normalizedSourceCrs = getKnownCRSDefinition(spatialReference.crs);
+  const normalizedVerticalCrs = spatialReference.vertical ? getKnownCRSDefinition(spatialReference.vertical) : void 0;
+  const normalizedTargetCrs = targetCrs ? cloneReadonlyCRSDefinition(targetCrs) : void 0;
+  return Object.freeze({
+    ...spatialReference,
+    sourceCrs: normalizedSourceCrs,
+    verticalCrs: normalizedVerticalCrs,
+    verticalUnitScale,
+    coordinateEpoch: options.coordinateEpoch ?? discovered.coordinateEpoch,
+    heightReference: discovered.heightReference || "unknown",
+    elevationMode: discovered.elevationMode,
+    elevationOffset: discovered.elevationOffset,
+    elevationUnit: discovered.elevationUnit,
+    elevationUnitScale,
+    coordinateFrame: coordinateFrame || "unknown",
+    axisOrder: discovered.axisOrder || "unknown",
+    provenance,
+    targetCrs: normalizedTargetCrs,
+    targetHeightReference,
+    outputCoordinates,
+    status: hasRequestedTransform ? canTransform ? "transformable" : "unresolved" : "native",
+    warnings: Object.freeze([...discovered.warnings || []])
+  });
+}
+function getKnownCRSDefinition(reference) {
+  return reference.state === "explicit" || reference.state === "default" ? reference.definition : void 0;
+}
+function cloneReadonlyCRSDefinition(definition) {
+  const spatialReference = createSpatialReference({
+    crs: {
+      state: "explicit",
+      definition,
+      representation: inferCRSRepresentation2(definition),
+      provenance: "caller-override"
+    }
+  });
+  const clonedDefinition = getKnownCRSDefinition(spatialReference.crs);
+  if (!clonedDefinition) {
+    throw new Error("Failed to normalize a known target CRS definition");
+  }
+  return clonedDefinition;
+}
+function getCoordinateOrder(axisOrder) {
+  switch (axisOrder) {
+    case "xy":
+      return ["x", "y"];
+    case "yx":
+      return ["y", "x"];
+    case "xyz":
+      return ["x", "y", "z"];
+    default:
+      return [];
+  }
+}
+function markTilesetSpatialReferenceTransformed(spatialReference) {
+  if (spatialReference.status !== "transformable" && spatialReference.status !== "transformed") {
+    throw new Error("Only a transformable spatial reference can be marked as transformed");
+  }
+  return Object.freeze({ ...spatialReference, status: "transformed" });
+}
+var init_spatial_types = __esm({
+  "../../modules/tiles/src/spatial/spatial-types.ts"() {
+    "use strict";
+    init_get_spatial_coordinate_frame();
+  }
+});
+
+// ../../modules/tiles/src/tileset-3d/common/tileset-content-traversal.ts
+async function* traverseTilesetContents(tileset, options = {}) {
+  await tileset.tilesetInitializationPromise;
+  throwIfAborted2(options.signal);
+  if (!tileset.root) {
+    throw new Error("Tileset initialization completed without a root tile");
+  }
+  const stack = [tileset.root];
+  const visitedTiles = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    throwIfAborted2(options.signal);
+    const tile = stack.pop();
+    if (visitedTiles.has(tile)) {
+      continue;
+    }
+    visitedTiles.add(tile);
+    if (tile.header.implicitSubtree && tile.childrenState !== "ready") {
+      const loadChildren = tileset.source.loadTileChildrenForTraversal;
+      if (!loadChildren) {
+        throw new Error("Tileset source does not support camera-independent subtree loading");
+      }
+      const result = await loadChildren.call(tileset.source, tile, options.signal);
+      if (!result.loaded) {
+        throw new Error(`Unable to load implicit subtree for tile ${tile.id}`);
+      }
+      tile.childrenState = "ready";
+    }
+    if (tileset.type === "I3S" /* I3S */ && tileset.source.loadTileChildrenForTraversal) {
+      const result = await tileset.source.loadTileChildrenForTraversal(tile, options.signal);
+      if (!result.loaded) {
+        throw new Error(`Unable to load I3S child nodes for tile ${tile.id}`);
+      }
+    }
+    throwIfAborted2(options.signal);
+    const loadsContent = tile.contentUrls.length > 0 && !tile.content;
+    try {
+      if (loadsContent) {
+        const loadResult = await tile.loadContentForTraversal();
+        throwIfAborted2(options.signal);
+        if (!loadResult.loaded) {
+          throw new Error(`Unable to load tile content for tile ${tile.id}`);
+        }
+        tileset.source.onTileLoaded?.(tileset, tile, loadResult);
+      }
+      yield { tile, contents: tile.contentEntries };
+    } finally {
+      if (options.unloadContent && loadsContent) {
+        tile.unloadContent();
+      }
+    }
+    for (let childIndex = tile.children.length - 1; childIndex >= 0; childIndex--) {
+      stack.push(tile.children[childIndex]);
+    }
+  }
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+var init_tileset_content_traversal = __esm({
+  "../../modules/tiles/src/tileset-3d/common/tileset-content-traversal.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/tiles/src/spatial/i3s-elevation.ts
+function getI3SLinearUnitScale(unit) {
+  if (!unit) {
+    return void 0;
+  }
+  const normalized = unit.trim().toLowerCase().replaceAll("_", "-");
+  const canonical = LINEAR_UNIT_ALIASES[normalized] || normalized;
+  return LINEAR_UNIT_TO_METERS[canonical];
+}
+var LINEAR_UNIT_TO_METERS, LINEAR_UNIT_ALIASES;
+var init_i3s_elevation = __esm({
+  "../../modules/tiles/src/spatial/i3s-elevation.ts"() {
+    "use strict";
+    LINEAR_UNIT_TO_METERS = Object.freeze({
+      meter: 1,
+      millimeter: 1e-3,
+      centimeter: 0.01,
+      decimeter: 0.1,
+      kilometer: 1e3,
+      foot: 0.3048,
+      yard: 0.9144,
+      mile: 1609.344,
+      "us-foot": 1200 / 3937,
+      "us-inch": 0.0254000508001016,
+      "us-yard": 3600 / 3937,
+      "us-mile": 6336e3 / 3937,
+      "clarke-foot": 0.3047972654,
+      "clarke-yard": 0.9143917962,
+      "clarke-link": 0.201166195164,
+      "sears-yard": 0.914398414616,
+      "sears-foot": 0.304799471539,
+      "sears-chain": 20.1167651216,
+      "sears-1922-truncated-chain": 20.116756,
+      "benoit-1895-b-chain": 20.1167824944,
+      "indian-yard": 0.914398530744,
+      "indian-1937-yard": 0.91439523,
+      "gold-coast-foot": 0.304799710181
+    });
+    LINEAR_UNIT_ALIASES = Object.freeze({
+      m: "meter",
+      metre: "meter",
+      meters: "meter",
+      metres: "meter",
+      mm: "millimeter",
+      millimetre: "millimeter",
+      millimeters: "millimeter",
+      millimetres: "millimeter",
+      cm: "centimeter",
+      centimetre: "centimeter",
+      centimeters: "centimeter",
+      centimetres: "centimeter",
+      dm: "decimeter",
+      decimetre: "decimeter",
+      decimeters: "decimeter",
+      decimetres: "decimeter",
+      km: "kilometer",
+      kilometre: "kilometer",
+      kilometers: "kilometer",
+      kilometres: "kilometer",
+      ft: "foot",
+      feet: "foot",
+      "us-survey-foot": "us-foot",
+      "us-survey-feet": "us-foot",
+      yd: "yard",
+      yards: "yard",
+      mi: "mile",
+      miles: "mile"
+    });
+  }
+});
+
+// ../../modules/tiles/src/spatial/spatial-resource-registry.ts
+import { parsePGM } from "@math.gl/geoid";
+import { Projection } from "@math.gl/proj4";
+function getGeoidModel(name) {
+  return geoidModels.get(name);
+}
+var geoidModels;
+var init_spatial_resource_registry = __esm({
+  "../../modules/tiles/src/spatial/spatial-resource-registry.ts"() {
+    "use strict";
+    geoidModels = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../../modules/tiles/src/spatial/spatial-coordinate-transformer.ts
+import { Vector3 } from "@math.gl/core";
+import { Ellipsoid } from "@math.gl/geospatial";
+import { Projection as Projection2 } from "@math.gl/proj4";
+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");
+  }
+  if (typeof definition !== "string" && definition.type === "CompoundCRS") {
+    const horizontalComponents = definition.components.filter(
+      (component) => component.type !== "VerticalCRS"
+    );
+    if (horizontalComponents.length !== 1) {
+      throw new Error("CompoundCRS requires exactly one horizontal component");
+    }
+    return getHorizontalProj4Definition(horizontalComponents[0]);
+  }
+  return definition;
+}
+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 SpatialCoordinateTransformer;
+var init_spatial_coordinate_transformer = __esm({
+  "../../modules/tiles/src/spatial/spatial-coordinate-transformer.ts"() {
+    "use strict";
+    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 Projection2({
+            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 Projection2({
+              from: getHorizontalProj4Definition(spatialReference.sourceCrs),
+              to: WGS84_GEOGRAPHIC_CRS,
+              enforceAxis: false
+            });
+          }
+          if (!this.outputIsGeographic && !this.outputIsGeocentric) {
+            this.heightOutputProjection = new Projection2({
+              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(Ellipsoid.WGS84.cartesianToCartographic(new 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(Ellipsoid.WGS84.cartographicToCartesian(new Vector3(coordinate)));
+        }
+        if (this.outputIsGeographic) {
+          return coordinate.slice(0, 3);
+        }
+        return this.heightOutputProjection.project(coordinate.slice(0, 3));
+      }
+    };
+  }
+});
+
+// ../../modules/tiles/src/spatial/tiles-3d-spatial-transformer.ts
+import { Matrix4 } from "@math.gl/core";
+import { Ellipsoid as Ellipsoid2 } from "@math.gl/geospatial";
+function getRegionSamples(region) {
+  if (region.length < 6 || region.some((value) => !Number.isFinite(value))) {
+    return [];
+  }
+  const [west, south, east, north, minimumHeight, maximumHeight] = region;
+  const longitudeEnd = east < west ? east + Math.PI * 2 : east;
+  const longitudes = getIntervalSamples(west, longitudeEnd);
+  const latitudes = getIntervalSamples(south, north);
+  const samples = [];
+  for (const longitude of longitudes) {
+    for (const latitude of latitudes) {
+      for (const height of [minimumHeight, maximumHeight]) {
+        samples.push([longitude * 180 / Math.PI, latitude * 180 / Math.PI, height]);
+      }
+    }
+  }
+  return samples;
+}
+function getIntervalSamples(start, end) {
+  const samples = [start, (start + end) / 2, end];
+  const angularStep = Math.PI / 2;
+  const firstCriticalIndex = Math.ceil(start / angularStep);
+  const lastCriticalIndex = Math.floor(end / angularStep);
+  for (let criticalIndex = firstCriticalIndex; criticalIndex <= lastCriticalIndex; criticalIndex++) {
+    samples.push(criticalIndex * angularStep);
+  }
+  return samples;
+}
+function getVolumeSamples(volume) {
+  if (volume.box && volume.box.length >= 12) {
+    const center = volume.box.slice(0, 3);
+    const axes = [volume.box.slice(3, 6), volume.box.slice(6, 9), volume.box.slice(9, 12)];
+    const samples = [];
+    for (let firstIndex = 0; firstIndex <= 4; firstIndex++) {
+      for (let secondIndex = 0; secondIndex <= 4; secondIndex++) {
+        for (let thirdIndex = 0; thirdIndex <= 4; thirdIndex++) {
+          const first = firstIndex / 2 - 1;
+          const second = secondIndex / 2 - 1;
+          const third = thirdIndex / 2 - 1;
+          samples.push([
+            center[0] + first * axes[0][0] + second * axes[1][0] + third * axes[2][0],
+            center[1] + first * axes[0][1] + second * axes[1][1] + third * axes[2][1],
+            center[2] + first * axes[0][2] + second * axes[1][2] + third * axes[2][2]
+          ]);
+        }
+      }
+    }
+    return samples;
+  }
+  if (volume.sphere && volume.sphere.length >= 4) {
+    const [x, y, z, radius] = volume.sphere;
+    const samples = [
+      [x - radius, y, z],
+      [x + radius, y, z],
+      [x, y - radius, z],
+      [x, y + radius, z],
+      [x, y, z - radius],
+      [x, y, z + radius]
+    ];
+    for (let longitudeIndex = 0; longitudeIndex < 16; longitudeIndex++) {
+      const longitude = longitudeIndex * Math.PI * 2 / 16;
+      samples.push([x + radius * Math.cos(longitude), y + radius * Math.sin(longitude), z]);
+    }
+    return samples;
+  }
+  return [];
+}
+function createAxisAlignedBox(samples) {
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (const sample of samples) {
+    for (let axis = 0; axis < 3; axis++) {
+      minimum[axis] = Math.min(minimum[axis], sample[axis]);
+      maximum[axis] = Math.max(maximum[axis], sample[axis]);
+    }
+  }
+  const padding = [
+    Math.max((maximum[0] - minimum[0]) * 0.01, 1e-9),
+    Math.max((maximum[1] - minimum[1]) * 0.01, 1e-9),
+    Math.max((maximum[2] - minimum[2]) * 0.01, 1e-9)
+  ];
+  const center = [
+    (minimum[0] + maximum[0]) / 2,
+    (minimum[1] + maximum[1]) / 2,
+    (minimum[2] + maximum[2]) / 2
+  ];
+  return [
+    ...center,
+    (maximum[0] - minimum[0]) / 2 + padding[0],
+    0,
+    0,
+    0,
+    (maximum[1] - minimum[1]) / 2 + padding[1],
+    0,
+    0,
+    0,
+    (maximum[2] - minimum[2]) / 2 + padding[2]
+  ];
+}
+var Tiles3DSpatialTransformer;
+var init_tiles_3d_spatial_transformer = __esm({
+  "../../modules/tiles/src/spatial/tiles-3d-spatial-transformer.ts"() {
+    "use strict";
+    init_spatial_coordinate_transformer();
+    init_get_spatial_coordinate_frame();
+    Tiles3DSpatialTransformer = class {
+      /** Normalized reference describing the completed operation. */
+      spatialReference;
+      coordinateTransformer;
+      geographicCoordinateTransformer;
+      /** Creates a 3D Tiles transformer for a requested target CRS. */
+      constructor(spatialReference, options = {}) {
+        this.coordinateTransformer = new SpatialCoordinateTransformer(spatialReference, options);
+        const geographicSpatialReference = {
+          ...spatialReference,
+          sourceCrs: "EPSG:4326",
+          targetCrs: spatialReference.targetCrs || spatialReference.sourceCrs,
+          coordinateFrame: "geographic",
+          axisOrder: "xy"
+        };
+        this.geographicCoordinateTransformer = new SpatialCoordinateTransformer(
+          geographicSpatialReference,
+          options
+        );
+        this.spatialReference = spatialReference;
+      }
+      /** Transform packed POSITION values into the target CRS. */
+      transformPositions(positions) {
+        return this.coordinateTransformer.transformPositions(positions);
+      }
+      /** Transform packed NORMAL values using the corresponding source positions. */
+      transformNormals(normals, positions) {
+        return this.coordinateTransformer.transformNormals(normals, positions);
+      }
+      /** Rebuild a conservative target-frame volume from a source volume. */
+      transformBoundingVolume(volume, sourceTransform) {
+        const transform = sourceTransform ? new Matrix4(Array.from(sourceTransform)) : void 0;
+        const samples = volume.region ? getRegionSamples(volume.region) : getVolumeSamples(volume).map(
+          (sample) => transform ? Array.from(transform.transformAsPoint(sample)) : sample
+        );
+        if (!samples.length) {
+          return volume;
+        }
+        const transformed = volume.region ? samples.map((sample) => this.transformRegionSample(sample)) : samples.map((sample) => this.coordinateTransformer.transformPosition(sample));
+        return { box: createAxisAlignedBox(transformed) };
+      }
+      /** Transforms one WGS84 region sample into the selected output frame. */
+      transformRegionSample(sample) {
+        const [longitudeDegrees, latitudeDegrees, height] = sample;
+        const targetCrs = this.spatialReference.targetCrs || this.spatialReference.sourceCrs;
+        if (targetCrs && getSpatialCoordinateFrame(targetCrs) === "geocentric") {
+          const cartesian = Ellipsoid2.WGS84.cartographicToCartesian([
+            longitudeDegrees,
+            latitudeDegrees,
+            height
+          ]);
+          return Array.from(cartesian);
+        }
+        return this.geographicCoordinateTransformer.transformPosition(sample);
+      }
+    };
+  }
+});
+
+// ../../modules/tiles/src/spatial/i3s-spatial-transformer.ts
+import { Matrix3, Matrix4 as Matrix42, Quaternion, Vector3 as Vector32 } from "@math.gl/core";
+import { Ellipsoid as Ellipsoid3 } from "@math.gl/geospatial";
+function getElevationProvider(mode, options) {
+  return mode === "relativeToScene" ? options.sceneElevationProvider : requiresElevationSurface(mode) ? options.terrainElevationProvider : void 0;
+}
+function requiresElevationSurface(mode) {
+  return mode === "onTheGround" || mode === "relativeToGround" || mode === "relativeToScene";
+}
+function toPositionArrays(positions) {
+  if (positions.length % 3 !== 0) {
+    throw new Error("I3S position arrays must contain complete XYZ tuples");
+  }
+  const result = [];
+  for (let index = 0; index < positions.length; index += 3) {
+    result.push([positions[index], positions[index + 1], positions[index + 2]]);
+  }
+  return result;
+}
+function getElevationBounds(geographicSamples) {
+  const region = getGeographicRegion(geographicSamples);
+  return {
+    west: region[0] * 180 / Math.PI,
+    south: region[1] * 180 / Math.PI,
+    east: region[2] * 180 / Math.PI,
+    north: region[3] * 180 / Math.PI
+  };
+}
+function getGeographicBoundingSphere(geographicSamples) {
+  if (!geographicSamples.length) {
+    throw new Error("I3S spatial transformation requires at least one bound sample");
+  }
+  const cartesianSamples = geographicSamples.map(
+    (position) => Ellipsoid3.WGS84.cartographicToCartesian(new Vector32(position))
+  );
+  const cartesianCenter = new Vector32();
+  for (const sample of cartesianSamples) {
+    cartesianCenter.add(sample);
+  }
+  cartesianCenter.scale(1 / cartesianSamples.length);
+  let radius = 0;
+  for (const sample of cartesianSamples) {
+    radius = Math.max(radius, new Vector32(sample).subtract(cartesianCenter).magnitude());
+  }
+  const geographicCenter = Ellipsoid3.WGS84.cartesianToCartographic(cartesianCenter);
+  return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
+}
+function getSourceBoundSamples(bounds, sourceFrame, sourceToGeographicTransformer, sourceVerticalUnitScale) {
+  const obb = bounds.obb;
+  if (obb) {
+    const center2 = Array.from(obb.center).slice(0, 3);
+    center2[2] *= sourceVerticalUnitScale;
+    const halfSize = Array.from(obb.halfSize).slice(0, 3);
+    const quaternion = new Quaternion().fromArray(Array.from(obb.quaternion));
+    const axes = [
+      new Vector32([halfSize[0], 0, 0]).transformByQuaternion(quaternion),
+      new Vector32([0, halfSize[1], 0]).transformByQuaternion(quaternion),
+      new Vector32([0, 0, halfSize[2]]).transformByQuaternion(quaternion)
+    ];
+    if (sourceFrame === "geographic") {
+      const geographicCenter = sourceToGeographicTransformer.transformPosition(center2);
+      const cartesianCenter = Ellipsoid3.WGS84.cartographicToCartesian(
+        new Vector32(geographicCenter)
+      );
+      const cartesianAxes = bounds.normalReferenceFrame === "vertex-reference-frame" ? axes.map((axis) => localEnuVectorToEcef(axis, geographicCenter)) : axes;
+      return getBoxSigns().map((signs) => {
+        const corner = new Vector32(cartesianCenter);
+        for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
+          corner.add(new Vector32(cartesianAxes[axisIndex]).scale(signs[axisIndex]));
+        }
+        return Array.from(Ellipsoid3.WGS84.cartesianToCartographic(corner));
+      });
+    }
+    return getBoxSigns().map((signs) => {
+      const corner = new Vector32(center2);
+      for (let axisIndex = 0; axisIndex < 3; axisIndex++) {
+        corner.add(new Vector32(axes[axisIndex]).scale(signs[axisIndex]));
+      }
+      return Array.from(corner);
+    });
+  }
+  const mbs = bounds.mbs ? Array.from(bounds.mbs) : [];
+  if (mbs.length < 4) {
+    return [];
+  }
+  const center = mbs.slice(0, 3);
+  center[2] *= sourceVerticalUnitScale;
+  const radius = mbs[3];
+  if (sourceFrame === "geographic") {
+    const geographicCenter = sourceToGeographicTransformer.transformPosition(center);
+    const cartesianCenter = Ellipsoid3.WGS84.cartographicToCartesian(new Vector32(geographicCenter));
+    return getAxisDirections().map(
+      (direction) => Array.from(
+        Ellipsoid3.WGS84.cartesianToCartographic(
+          new Vector32(cartesianCenter).add(new Vector32(direction).scale(radius))
+        )
+      )
+    );
+  }
+  return getAxisDirections().map(
+    (direction) => Array.from(new Vector32(center).add(new Vector32(direction).scale(radius)))
+  );
+}
+function getBoxSigns() {
+  return [-1, 1].flatMap((x) => [-1, 1].flatMap((y) => [-1, 1].map((z) => [x, y, z])));
+}
+function getAxisDirections() {
+  return [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1]
+  ];
+}
+function getPositiveAxisDirections() {
+  return [new Vector32([1, 0, 0]), new Vector32([0, 1, 0]), new Vector32([0, 0, 1])];
+}
+function localEnuVectorToEcef(vector, geographic) {
+  const longitude = geographic[0] * Math.PI / 180;
+  const latitude = geographic[1] * Math.PI / 180;
+  const east = new Vector32([-Math.sin(longitude), Math.cos(longitude), 0]);
+  const north = new Vector32([
+    -Math.sin(latitude) * Math.cos(longitude),
+    -Math.sin(latitude) * Math.sin(longitude),
+    Math.cos(latitude)
+  ]);
+  const up = new Vector32([
+    Math.cos(latitude) * Math.cos(longitude),
+    Math.cos(latitude) * Math.sin(longitude),
+    Math.sin(latitude)
+  ]);
+  return east.scale(vector[0]).add(north.scale(vector[1])).add(up.scale(vector[2]));
+}
+function ecefVectorToLocalEnu(vector, geographic) {
+  const longitude = geographic[0] * Math.PI / 180;
+  const latitude = geographic[1] * Math.PI / 180;
+  const east = new Vector32([-Math.sin(longitude), Math.cos(longitude), 0]);
+  const north = new Vector32([
+    -Math.sin(latitude) * Math.cos(longitude),
+    -Math.sin(latitude) * Math.sin(longitude),
+    Math.cos(latitude)
+  ]);
+  const up = new Vector32([
+    Math.cos(latitude) * Math.cos(longitude),
+    Math.cos(latitude) * Math.sin(longitude),
+    Math.sin(latitude)
+  ]);
+  return new Vector32([east.dot(vector), north.dot(vector), up.dot(vector)]);
+}
+function getAxisAlignedBox(positions) {
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (const position of positions) {
+    for (let component = 0; component < 3; component++) {
+      minimum[component] = Math.min(minimum[component], position[component]);
+      maximum[component] = Math.max(maximum[component], position[component]);
+    }
+  }
+  const center = minimum.map((value, index) => (value + maximum[index]) / 2);
+  const halfSize = minimum.map((value, index) => (maximum[index] - value) / 2);
+  return [center[0], center[1], center[2], halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]];
+}
+function getGeographicRegion(positions) {
+  const referenceLongitude = positions[0][0];
+  let minimumLongitude = Infinity;
+  let maximumLongitude = -Infinity;
+  let minimumLatitude = Infinity;
+  let maximumLatitude = -Infinity;
+  let minimumHeight = Infinity;
+  let maximumHeight = -Infinity;
+  for (const position of positions) {
+    const longitude = referenceLongitude + normalizeLongitude(position[0] - referenceLongitude);
+    minimumLongitude = Math.min(minimumLongitude, longitude);
+    maximumLongitude = Math.max(maximumLongitude, longitude);
+    minimumLatitude = Math.min(minimumLatitude, position[1]);
+    maximumLatitude = Math.max(maximumLatitude, position[1]);
+    minimumHeight = Math.min(minimumHeight, position[2]);
+    maximumHeight = Math.max(maximumHeight, position[2]);
+  }
+  return [
+    normalizeLongitude(minimumLongitude) * Math.PI / 180,
+    minimumLatitude * Math.PI / 180,
+    normalizeLongitude(maximumLongitude) * Math.PI / 180,
+    maximumLatitude * Math.PI / 180,
+    minimumHeight,
+    maximumHeight
+  ];
+}
+function normalizeLongitude(longitude) {
+  return ((longitude + 180) % 360 + 360) % 360 - 180;
+}
+var I3SSpatialTransformer;
+var init_i3s_spatial_transformer = __esm({
+  "../../modules/tiles/src/spatial/i3s-spatial-transformer.ts"() {
+    "use strict";
+    init_spatial_coordinate_transformer();
+    init_spatial_types();
+    init_i3s_elevation();
+    I3SSpatialTransformer = class {
+      /** Descriptor attached to output after all adapter-owned spatial values have been transformed. */
+      spatialReference;
+      /** Broad coordinate frame of the selected output CRS. */
+      targetCoordinateFrame;
+      /** Source-to-target position operation. */
+      positionTransformer;
+      /** Source-to-WGS84 geographic operation used for vector-frame conversion. */
+      sourceToGeographicTransformer;
+      /** WGS84-geographic-to-target operation used for normal finite differences. */
+      geographicToTargetTransformer;
+      /** Source frame recorded by I3S metadata. */
+      sourceCoordinateFrame;
+      /** Source Z multiplier that normalizes stored elevation values to meters. */
+      sourceVerticalUnitScale;
+      /** I3S elevation placement mode. */
+      elevationMode;
+      /** I3S elevation offset normalized to meters. */
+      elevationOffset;
+      /** Terrain or scene provider selected for the declared placement mode. */
+      elevationProvider;
+      /** Provider height multiplier that normalizes returned values to meters. */
+      providerUnitScale;
+      /** Optional provider-height to layer-height datum operation. */
+      providerHeightTransformer;
+      /**
+       * Creates an I3S spatial adapter.
+       *
+       * @param spatialReference - Transformable I3S spatial descriptor.
+       * @param options - Registered geoid and custom resource options used by the shared transformer.
+       */
+      constructor(spatialReference, options = {}) {
+        if (spatialReference.status !== "transformable" && spatialReference.status !== "transformed") {
+          throw new Error("I3SSpatialTransformer requires a requested, transformable spatial output");
+        }
+        const targetCrs = spatialReference.targetCrs || spatialReference.sourceCrs;
+        if (!targetCrs) {
+          throw new Error("I3S spatial transformation requires a target CRS");
+        }
+        this.positionTransformer = new SpatialCoordinateTransformer(spatialReference, options);
+        this.sourceCoordinateFrame = spatialReference.coordinateFrame;
+        this.sourceVerticalUnitScale = spatialReference.verticalUnitScale;
+        this.elevationMode = spatialReference.elevationMode;
+        this.elevationOffset = (spatialReference.elevationOffset || 0) * spatialReference.elevationUnitScale;
+        this.elevationProvider = getElevationProvider(this.elevationMode, options);
+        if (this.elevationProvider && (typeof this.elevationProvider.sampleElevations !== "function" || typeof this.elevationProvider.getElevationRange !== "function")) {
+          throw new Error(
+            "An I3S elevation provider must implement sampleElevations() and getElevationRange()"
+          );
+        }
+        const providerUnitScale = getI3SLinearUnitScale(this.elevationProvider?.unit || "meter");
+        if (this.elevationProvider && providerUnitScale === void 0) {
+          throw new Error(`Unsupported elevation-provider unit ${this.elevationProvider.unit}`);
+        }
+        this.providerUnitScale = providerUnitScale || 1;
+        this.targetCoordinateFrame = getSpatialCoordinateFrame(targetCrs);
+        this.spatialReference = markTilesetSpatialReferenceTransformed(spatialReference);
+        const sourceToGeographicReference = createTilesetSpatialReference(
+          {
+            sourceCrs: spatialReference.sourceCrs,
+            heightReference: spatialReference.heightReference,
+            coordinateFrame: spatialReference.coordinateFrame,
+            axisOrder: spatialReference.axisOrder,
+            provenance: spatialReference.provenance
+          },
+          { targetCrs: "EPSG:4326" }
+        );
+        this.sourceToGeographicTransformer = new SpatialCoordinateTransformer(
+          sourceToGeographicReference
+        );
+        if (requiresElevationSurface(this.elevationMode)) {
+          if (!this.elevationProvider) {
+            const providerName = this.elevationMode === "relativeToScene" ? "scene" : "terrain";
+            throw new Error(
+              `I3S elevation mode ${this.elevationMode} requires a ${providerName} elevation provider`
+            );
+          }
+          if (spatialReference.heightReference === "unknown") {
+            throw new Error(
+              `I3S elevation mode ${this.elevationMode} requires a known source height reference`
+            );
+          }
+          const providerHeightReference = this.elevationProvider.heightReference || spatialReference.heightReference;
+          if (providerHeightReference !== spatialReference.heightReference) {
+            if (spatialReference.heightReference !== "ellipsoidal" && spatialReference.heightReference !== "orthometric") {
+              throw new Error(
+                "Converting elevation-provider heights requires an ellipsoidal or orthometric source height reference"
+              );
+            }
+            const providerHeightSpatialReference = createTilesetSpatialReference(
+              {
+                sourceCrs: "EPSG:4326",
+                heightReference: providerHeightReference,
+                coordinateFrame: "geographic",
+                axisOrder: "xyz",
+                provenance: "caller-override"
+              },
+              {
+                targetCrs: "EPSG:4326",
+                targetHeightReference: spatialReference.heightReference,
+                geoidModel: options.geoidModel
+              }
+            );
+            this.providerHeightTransformer = new SpatialCoordinateTransformer(
+              providerHeightSpatialReference,
+              options
+            );
+          }
+        }
+        const geographicToTargetReference = createTilesetSpatialReference(
+          {
+            sourceCrs: "EPSG:4326",
+            heightReference: spatialReference.heightReference,
+            coordinateFrame: "geographic",
+            axisOrder: "xyz",
+            provenance: "format-default"
+          },
+          {
+            targetCrs,
+            targetHeightReference: spatialReference.targetHeightReference,
+            geoidModel: options.geoidModel
+          }
+        );
+        this.geographicToTargetTransformer = new SpatialCoordinateTransformer(
+          geographicToTargetReference,
+          options
+        );
+      }
+      /** Transform one absolute I3S source position. */
+      transformPosition(position) {
+        const placedPosition = this.placeSourcePositionsSync(position);
+        const transformed = this.positionTransformer.transformPosition([
+          placedPosition[0],
+          placedPosition[1],
+          placedPosition[2]
+        ]);
+        return [transformed[0], transformed[1], transformed[2]];
+      }
+      /** Transform one absolute I3S source position after asynchronous surface placement. */
+      async transformPositionAsync(position) {
+        const placedPosition = await this.placeSourcePositions(position);
+        const transformed = this.positionTransformer.transformPosition([
+          placedPosition[0],
+          placedPosition[1],
+          placedPosition[2]
+        ]);
+        return [transformed[0], transformed[1], transformed[2]];
+      }
+      /** Transform an already placed, meter-normalized position to the requested target. */
+      transformPlacedPosition(position) {
+        const transformed = this.positionTransformer.transformPosition([
+          position[0],
+          position[1],
+          position[2]
+        ]);
+        return [transformed[0], transformed[1], transformed[2]];
+      }
+      /** Transform one absolute I3S source position to WGS84 longitude, latitude, and height. */
+      transformSourcePositionToGeographic(position) {
+        const placedPosition = this.placeSourcePositionsSync(position);
+        const transformed = this.sourceToGeographicTransformer.transformPosition([
+          placedPosition[0],
+          placedPosition[1],
+          placedPosition[2]
+        ]);
+        return [transformed[0], transformed[1], transformed[2]];
+      }
+      /** Transform one source position to WGS84 after asynchronous elevation placement. */
+      async transformSourcePositionToGeographicAsync(position) {
+        const placedPosition = await this.placeSourcePositions(position);
+        const transformed = this.sourceToGeographicTransformer.transformPosition([
+          placedPosition[0],
+          placedPosition[1],
+          placedPosition[2]
+        ]);
+        return [transformed[0], transformed[1], transformed[2]];
+      }
+      /**
+       * Transform absolute Float64 positions and return stable Float32 offsets around a target origin.
+       *
+       * @param sourcePositions - Absolute positions in source CRS order.
+       * @param sourceOrigin - Stable source origin, normally the node MBS or OBB center.
+       */
+      transformPositions(sourcePositions, sourceOrigin) {
+        const placedSourcePositions = this.placeSourcePositionsSync(sourcePositions);
+        const placedSourceOrigin = this.placeSourcePositionsSync(sourceOrigin);
+        return this.transformPlacedPositions(placedSourcePositions, placedSourceOrigin);
+      }
+      /**
+       * Transform positions after asynchronously sampling any requested terrain or scene surface.
+       *
+       * @param sourcePositions - Absolute positions in source CRS order.
+       * @param sourceOrigin - Stable source origin, normally the node MBS or OBB center.
+       * @returns Renderer-ready target-frame offsets and stable origin metadata.
+       */
+      async transformPositionsAsync(sourcePositions, sourceOrigin) {
+        const combinedPositions = new Float64Array(sourcePositions.length + 3);
+        combinedPositions.set(Array.from(sourcePositions), 0);
+        combinedPositions.set(Array.from(sourceOrigin).slice(0, 3), sourcePositions.length);
+        const placedPositions = await this.placeSourcePositions(combinedPositions);
+        return this.transformPlacedPositions(
+          placedPositions.subarray(0, sourcePositions.length),
+          placedPositions.subarray(sourcePositions.length)
+        );
+      }
+      /** Transform already placed positions into renderer-relative target coordinates. */
+      transformPlacedPositions(sourcePositions, sourceOrigin) {
+        const origin = this.transformPlacedPosition(sourceOrigin);
+        const positions = new Float32Array(sourcePositions.length);
+        const absoluteSourcePositions = Float64Array.from(sourcePositions);
+        for (let index = 0; index < sourcePositions.length; index += 3) {
+          const transformed = this.transformPlacedPosition([
+            sourcePositions[index],
+            sourcePositions[index + 1],
+            sourcePositions[index + 2]
+          ]);
+          positions[index] = transformed[0] - origin[0];
+          positions[index + 1] = transformed[1] - origin[1];
+          positions[index + 2] = transformed[2] - origin[2];
+        }
+        const isGeographic = this.targetCoordinateFrame === "geographic";
+        const modelMatrix = isGeographic ? new Matrix42() : new Matrix42().translate(origin);
+        return {
+          positions,
+          sourcePositions: absoluteSourcePositions,
+          origin,
+          cartographicOrigin: isGeographic ? origin : [0, 0, 0],
+          coordinateSystem: isGeographic ? "lnglat-offsets" : "cartesian",
+          modelMatrix
+        };
+      }
+      /**
+       * Transform I3S normals into the selected target basis.
+       *
+       * Earth-centered normals are rotated directly. Vertex-reference-frame normals are first mapped
+       * through the local east/north/up basis at each source position.
+       *
+       * @param normals - Three-component normal vectors.
+       * @param sourcePositions - Absolute source position paired with each normal.
+       * @param normalReferenceFrame - I3S normal frame declaration.
+       */
+      transformNormals(normals, sourcePositions, normalReferenceFrame = "earth-centered") {
+        const transformedNormals = new Float32Array(normals.length);
+        for (let index = 0; index < normals.length; index += 3) {
+          const geographic = this.sourceToGeographicTransformer.transformPosition([
+            sourcePositions[index],
+            sourcePositions[index + 1],
+            sourcePositions[index + 2]
+          ]);
+          const inputNormal = new Vector32([
+            normals[index],
+            normals[index + 1],
+            normals[index + 2]
+          ]).normalize();
+          const ecefNormal = normalReferenceFrame === "earth-centered" ? inputNormal : localEnuVectorToEcef(inputNormal, geographic);
+          const outputNormal = this.transformEcefNormal(ecefNormal, geographic);
+          transformedNormals.set(outputNormal, index);
+        }
+        return transformedNormals;
+      }
+      /**
+       * Rebuild an I3S node bound from transformed corner or sphere-axis samples.
+       *
+       * @param bounds - Source MBS/OBB fields.
+       * @returns A generic tile `region` for geographic output or axis-aligned `box` otherwise.
+       */
+      transformBoundingVolume(bounds) {
+        const geographicSamples = this.getGeographicBoundSamples(bounds);
+        const targetSamples = geographicSamples.map(
+          (position) => this.geographicToTargetTransformer.transformPosition(position)
+        );
+        return this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) };
+      }
+      /** Rebuild an I3S bound in the target frame after asynchronous elevation placement. */
+      async transformBoundingVolumeAsync(bounds) {
+        const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
+        const targetSamples = geographicSamples.map(
+          (position) => this.geographicToTargetTransformer.transformPosition(position)
+        );
+        return this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) };
+      }
+      /** Rebuild an I3S bound as a WGS84 geographic region for geographic traversal algorithms. */
+      transformBoundingVolumeToGeographic(bounds) {
+        return { region: getGeographicRegion(this.getGeographicBoundSamples(bounds)) };
+      }
+      /** Rebuild an I3S bound as WGS84 geographic after asynchronous elevation placement. */
+      async transformBoundingVolumeToGeographicAsync(bounds) {
+        return { region: getGeographicRegion(await this.getGeographicBoundSamplesAsync(bounds)) };
+      }
+      /** Rebuild an I3S bound as a WGS84 ECEF box for generic `Tileset3D` traversal. */
+      transformBoundingVolumeToGeocentric(bounds) {
+        const cartesianSamples = this.getGeographicBoundSamples(bounds).map(
+          (position) => Array.from(Ellipsoid3.WGS84.cartographicToCartesian(new Vector32(position)))
+        );
+        return { box: getAxisAlignedBox(cartesianSamples) };
+      }
+      /** Rebuild an I3S bound as WGS84 ECEF after asynchronous elevation placement. */
+      async transformBoundingVolumeToGeocentricAsync(bounds) {
+        const cartesianSamples = (await this.getGeographicBoundSamplesAsync(bounds)).map(
+          (position) => Array.from(Ellipsoid3.WGS84.cartographicToCartesian(new Vector32(position)))
+        );
+        return { box: getAxisAlignedBox(cartesianSamples) };
+      }
+      /** Return a WGS84 geographic MBS used by the I3S screen-threshold calculation. */
+      transformBoundingSphereToGeographic(bounds) {
+        const sourceCenter = bounds.mbs?.length ? Array.from(bounds.mbs).slice(0, 3) : bounds.obb ? Array.from(bounds.obb.center).slice(0, 3) : null;
+        if (!sourceCenter) {
+          throw new Error("I3S spatial transformation requires an MBS or OBB bound");
+        }
+        const placedCenter = this.placeSourcePositionsSync(sourceCenter);
+        const geographicCenter = this.sourceToGeographicTransformer.transformPosition(
+          Array.from(placedCenter)
+        );
+        const radius = bounds.mbs?.length ? bounds.mbs[3] : Math.hypot(...Array.from(bounds.obb.halfSize).slice(0, 3));
+        return [geographicCenter[0], geographicCenter[1], geographicCenter[2], radius];
+      }
+      /** Return a placed WGS84 MBS used by the I3S screen-threshold calculation. */
+      async transformBoundingSphereToGeographicAsync(bounds) {
+        return getGeographicBoundingSphere(await this.getGeographicBoundSamplesAsync(bounds));
+      }
+      /**
+       * Rebuild traversal, target-output, and I3S LOD bounds from one elevation-sampling batch.
+       *
+       * @param bounds - Source MBS/OBB fields.
+       * @returns Parallel bounds in WGS84 ECEF, the selected output frame, and WGS84 geographic.
+       */
+      async transformBoundsAsync(bounds) {
+        const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
+        const cartesianSamples = geographicSamples.map(
+          (position) => Array.from(Ellipsoid3.WGS84.cartographicToCartesian(new Vector32(position)))
+        );
+        const targetSamples = geographicSamples.map(
+          (position) => this.geographicToTargetTransformer.transformPosition(position)
+        );
+        return {
+          boundingVolume: { box: getAxisAlignedBox(cartesianSamples) },
+          spatialBoundingVolume: this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) },
+          i3sLodMbs: requiresElevationSurface(this.elevationMode) ? getGeographicBoundingSphere(geographicSamples) : this.transformBoundingSphereToGeographic(bounds)
+        };
+      }
+      /**
+       * Rebuild Point Cloud traversal and target-output bounds from one elevation-sampling batch.
+       *
+       * @param bounds - Source OBB fields.
+       * @returns WGS84 geographic traversal bound plus the selected output-frame bound.
+       */
+      async transformPointCloudBoundsAsync(bounds) {
+        const geographicSamples = await this.getGeographicBoundSamplesAsync(bounds);
+        const targetSamples = geographicSamples.map(
+          (position) => this.geographicToTargetTransformer.transformPosition(position)
+        );
+        return {
+          boundingVolume: { region: getGeographicRegion(geographicSamples) },
+          spatialBoundingVolume: this.targetCoordinateFrame === "geographic" ? { region: getGeographicRegion(targetSamples) } : { box: getAxisAlignedBox(targetSamples) }
+        };
+      }
+      /** Sample a source I3S bound and normalize every sample to WGS84 geographic coordinates. */
+      getGeographicBoundSamples(bounds) {
+        const sourceSamples = getSourceBoundSamples(
+          bounds,
+          this.sourceCoordinateFrame,
+          this.sourceToGeographicTransformer,
+          this.sourceVerticalUnitScale
+        );
+        if (!sourceSamples.length) {
+          throw new Error("I3S spatial transformation requires an MBS or OBB bound");
+        }
+        const placedSourceSamples = this.placeSourcePositionsSync(sourceSamples.flat(), true);
+        const placedSamples = toPositionArrays(placedSourceSamples);
+        return this.sourceCoordinateFrame === "geographic" ? placedSamples : placedSamples.map(
+          (position) => this.sourceToGeographicTransformer.transformPosition(position)
+        );
+      }
+      /** Sample, place, and normalize one source bound to WGS84 geographic coordinates. */
+      async getGeographicBoundSamplesAsync(bounds) {
+        const sourceSamples = getSourceBoundSamples(
+          bounds,
+          this.sourceCoordinateFrame,
+          this.sourceToGeographicTransformer,
+          this.sourceVerticalUnitScale
+        );
+        if (!sourceSamples.length) {
+          throw new Error("I3S spatial transformation requires an MBS or OBB bound");
+        }
+        if (requiresElevationSurface(this.elevationMode)) {
+          const geographicSamples = this.sourceCoordinateFrame === "geographic" ? sourceSamples : sourceSamples.map(
+            (position) => this.sourceToGeographicTransformer.transformPosition(position)
+          );
+          return await this.placeGeographicBoundSamples(geographicSamples);
+        }
+        const placedSamples = toPositionArrays(
+          await this.placeSourcePositions(sourceSamples.flat(), true)
+        );
+        return this.sourceCoordinateFrame === "geographic" ? placedSamples : placedSamples.map(
+          (position) => this.sourceToGeographicTransformer.transformPosition(position)
+        );
+      }
+      /** Apply a provider's conservative surface range to an entire geographic bound footprint. */
+      async placeGeographicBoundSamples(geographicSamples) {
+        const elevationProvider = this.elevationProvider;
+        const elevationRange = await elevationProvider.getElevationRange(
+          getElevationBounds(geographicSamples)
+        );
+        const minimumProviderHeight = elevationRange.minimum * this.providerUnitScale;
+        const maximumProviderHeight = elevationRange.maximum * this.providerUnitScale;
+        if (!Number.isFinite(minimumProviderHeight) || !Number.isFinite(maximumProviderHeight) || minimumProviderHeight > maximumProviderHeight) {
+          throw new Error(
+            "Elevation provider returned an invalid range; minimum and maximum must be finite and ordered"
+          );
+        }
+        const sourceHeights = geographicSamples.map((position) => position[2]);
+        const minimumSourceHeight = Math.min(...sourceHeights);
+        const maximumSourceHeight = Math.max(...sourceHeights);
+        const placedSamples = [];
+        for (const [longitude, latitude] of geographicSamples) {
+          const convertedMinimum = this.providerHeightTransformer ? this.providerHeightTransformer.transformPosition([
+            longitude,
+            latitude,
+            minimumProviderHeight
+          ])[2] : minimumProviderHeight;
+          const convertedMaximum = this.providerHeightTransformer ? this.providerHeightTransformer.transformPosition([
+            longitude,
+            latitude,
+            maximumProviderHeight
+          ])[2] : maximumProviderHeight;
+          const minimumSurfaceHeight = Math.min(convertedMinimum, convertedMaximum);
+          const maximumSurfaceHeight = Math.max(convertedMinimum, convertedMaximum);
+          const minimumHeight = this.elevationMode === "onTheGround" ? minimumSurfaceHeight : minimumSurfaceHeight + minimumSourceHeight + this.elevationOffset;
+          const maximumHeight = this.elevationMode === "onTheGround" ? maximumSurfaceHeight : maximumSurfaceHeight + maximumSourceHeight + this.elevationOffset;
+          placedSamples.push(
+            [longitude, latitude, minimumHeight],
+            [longitude, latitude, maximumHeight]
+          );
+        }
+        return placedSamples;
+      }
+      /** Apply source units and non-surface placement without awaiting external resources. */
+      placeSourcePositionsSync(sourcePositions, sourceHeightsAreMeters = false) {
+        if (requiresElevationSurface(this.elevationMode)) {
+          throw new Error(
+            `I3S elevation mode ${this.elevationMode} requires asynchronous surface placement`
+          );
+        }
+        const positions = Float64Array.from(sourcePositions);
+        const offset = this.elevationMode === "absoluteHeight" ? this.elevationOffset : 0;
+        for (let index = 2; index < positions.length; index += 3) {
+          positions[index] = positions[index] * (sourceHeightsAreMeters ? 1 : this.sourceVerticalUnitScale) + offset;
+        }
+        return positions;
+      }
+      /** Apply source units and all I3S elevation-placement modes. */
+      async placeSourcePositions(sourcePositions, sourceHeightsAreMeters = false) {
+        if (!requiresElevationSurface(this.elevationMode)) {
+          return this.placeSourcePositionsSync(sourcePositions, sourceHeightsAreMeters);
+        }
+        const positions = Float64Array.from(sourcePositions);
+        const geographicLocations = toPositionArrays(positions).map((position) => {
+          const geographic = this.sourceToGeographicTransformer.transformPosition(position);
+          return [geographic[0], geographic[1]];
+        });
+        const sampledHeights = await this.elevationProvider.sampleElevations(geographicLocations);
+        if (sampledHeights.length !== geographicLocations.length) {
+          throw new Error(
+            `Elevation provider returned ${sampledHeights.length} heights for ${geographicLocations.length} positions`
+          );
+        }
+        for (let positionIndex = 0; positionIndex < geographicLocations.length; positionIndex++) {
+          const sampledHeight = sampledHeights[positionIndex] * this.providerUnitScale;
+          if (!Number.isFinite(sampledHeight)) {
+            throw new Error(
+              `Elevation provider returned a non-finite height at index ${positionIndex}`
+            );
+          }
+          const [longitude, latitude] = geographicLocations[positionIndex];
+          const surfaceHeight = this.providerHeightTransformer ? this.providerHeightTransformer.transformPosition([longitude, latitude, sampledHeight])[2] : sampledHeight;
+          const sourceHeight = positions[positionIndex * 3 + 2] * (sourceHeightsAreMeters ? 1 : this.sourceVerticalUnitScale);
+          positions[positionIndex * 3 + 2] = this.elevationMode === "onTheGround" ? surfaceHeight : surfaceHeight + sourceHeight + this.elevationOffset;
+        }
+        return positions;
+      }
+      /** Transform one earth-centered normal to the selected target basis. */
+      transformEcefNormal(ecefNormal, geographic) {
+        if (this.targetCoordinateFrame === "geocentric") {
+          return ecefNormal.normalize();
+        }
+        if (this.targetCoordinateFrame === "geographic") {
+          return ecefVectorToLocalEnu(ecefNormal, geographic).normalize();
+        }
+        const cartesian = Ellipsoid3.WGS84.cartographicToCartesian(new Vector32(geographic));
+        const jacobianColumns = [];
+        for (const direction of getPositiveAxisDirections()) {
+          const positiveGeographic = Ellipsoid3.WGS84.cartesianToCartographic(
+            new Vector32(cartesian).add(direction)
+          );
+          const negativeGeographic = Ellipsoid3.WGS84.cartesianToCartographic(
+            new Vector32(cartesian).subtract(direction)
+          );
+          const positiveTarget = this.geographicToTargetTransformer.transformPosition(positiveGeographic);
+          const negativeTarget = this.geographicToTargetTransformer.transformPosition(negativeGeographic);
+          jacobianColumns.push(
+            (positiveTarget[0] - negativeTarget[0]) / 2,
+            (positiveTarget[1] - negativeTarget[1]) / 2,
+            (positiveTarget[2] - negativeTarget[2]) / 2
+          );
+        }
+        const normalMatrix = new Matrix3(jacobianColumns);
+        if (Math.abs(normalMatrix.determinant()) < 1e-12) {
+          throw new Error("Cannot transform an I3S normal through a singular local projection");
+        }
+        normalMatrix.invert().transpose();
+        return new Vector32(ecefNormal).transformByMatrix3(normalMatrix).normalize();
+      }
+    };
+  }
+});
+
+// ../../modules/tiles/src/index.ts
+var init_src2 = __esm({
+  "../../modules/tiles/src/index.ts"() {
+    "use strict";
+    init_tileset_content_traversal();
+    init_spatial_types();
+    init_tiles_3d_spatial_transformer();
+    init_i3s_spatial_transformer();
+  }
+});
+
+// ../../modules/schema-utils/src/lib/schema/convert-arrow-schema.ts
+import * as arrow from "apache-arrow";
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function convertSchemaToArrow(schema, options) {
+  return deserializeArrowSchema(schema, options);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function deserializeArrowSchema(schema, options) {
+  return new arrow.Schema(
+    schema.fields.map((field) => deserializeArrowField(field, options)),
+    deserializeArrowMetadata(schema.metadata)
+  );
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function deserializeArrowField(field, options) {
+  return new arrow.Field(
+    field.name,
+    deserializeArrowType(field.type, options),
+    field.nullable,
+    deserializeArrowMetadata(field.metadata)
+  );
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  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 arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function deserializeArrowType(dataType, options) {
+  if (typeof dataType === "object") {
+    switch (dataType.type) {
+      case "decimal":
+        return new arrow.Decimal(dataType.scale, dataType.precision, dataType.bitWidth);
+      case "map": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return new arrow.Map_(children[0], dataType.keysSorted);
+      }
+      case "list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        return new arrow.List(field);
+      }
+      case "large-list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        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);
+        return new arrow.FixedSizeList(dataType.listSize, child);
+      }
+      case "fixed-size-binary":
+        return new arrow.FixedSizeBinary(dataType.byteWidth);
+      case "struct": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return new arrow.Struct(children);
+      }
+      case "sparse-union":
+      case "dense-union": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return dataType.type === "dense-union" ? new arrow.DenseUnion(dataType.typeIds, children) : new arrow.SparseUnion(dataType.typeIds, children);
+      }
+      case "dictionary": {
+        return new arrow.Dictionary(
+          deserializeArrowType(dataType.dictionary, options),
+          deserializeArrowDictionaryKeyType(dataType.indices),
+          dataType.id,
+          dataType.isOrdered
+        );
+      }
+      default:
+        throw new Error("array type not supported");
+    }
+  }
+  switch (dataType) {
+    case "null":
+      return new arrow.Null();
+    case "binary":
+      return makeVariableWidthArrowType("BinaryView", new arrow.Binary(), options);
+    case "binary-view":
+      return makeRequiredArrowViewType("BinaryView");
+    case "bool":
+      return new arrow.Bool();
+    case "int8":
+      return new arrow.Int8();
+    case "int16":
+      return new arrow.Int16();
+    case "int32":
+      return new arrow.Int32();
+    case "int64":
+      return new arrow.Int64();
+    case "uint8":
+      return new arrow.Uint8();
+    case "uint16":
+      return new arrow.Uint16();
+    case "uint32":
+      return new arrow.Uint32();
+    case "uint64":
+      return new arrow.Uint64();
+    case "float16":
+      return new arrow.Float16();
+    case "float32":
+      return new arrow.Float32();
+    case "float64":
+      return new arrow.Float64();
+    case "utf8":
+      return makeVariableWidthArrowType("Utf8View", new arrow.Utf8(), options);
+    case "utf8-view":
+      return makeRequiredArrowViewType("Utf8View");
+    case "date-day":
+      return new arrow.DateDay();
+    case "date-millisecond":
+      return new arrow.DateMillisecond();
+    case "time-second":
+      return new arrow.TimeSecond();
+    case "time-millisecond":
+      return new arrow.TimeMillisecond();
+    case "time-microsecond":
+      return new arrow.TimeMicrosecond();
+    case "time-nanosecond":
+      return new arrow.TimeNanosecond();
+    case "timestamp-second":
+      return new arrow.TimestampSecond();
+    case "timestamp-millisecond":
+      return new arrow.TimestampMillisecond();
+    case "timestamp-microsecond":
+      return new arrow.TimestampMicrosecond();
+    case "timestamp-nanosecond":
+      return new arrow.TimestampNanosecond();
+    case "interval-daytime":
+      return new arrow.IntervalDayTime();
+    case "interval-yearmonth":
+      return new arrow.IntervalYearMonth();
+    default:
+      throw new Error("array type not supported");
+  }
+}
+function getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard?.(arrowType));
+}
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
+function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
+  const viewTypeMode = options?.viewTypes || "never";
+  if (viewTypeMode === "never") {
+    return fallbackType;
+  }
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor) {
+    return new constructor();
+  }
+  if (viewTypeMode === "require") {
+    throw new Error(
+      `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+    );
+  }
+  return fallbackType;
+}
+function makeRequiredArrowViewType(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`
+    );
+  }
+  return new constructor();
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+function deserializeArrowDictionaryKeyType(keyType) {
+  switch (keyType) {
+    case "int8":
+      return new arrow.Int8();
+    case "int16":
+      return new arrow.Int16();
+    case "int32":
+      return new arrow.Int32();
+    case "uint8":
+      return new arrow.Uint8();
+    case "uint16":
+      return new arrow.Uint16();
+    case "uint32":
+      return new arrow.Uint32();
+    default:
+      throw new Error(`schema dictionary index type not supported: ${keyType}`);
+  }
+}
+var init_convert_arrow_schema = __esm({
+  "../../modules/schema-utils/src/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema-utils/src/lib/mesh/mesh-utils.ts
+function getMeshBoundingBox(attributes) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  const positions = attributes.POSITION ? attributes.POSITION.value : [];
+  const len = positions && positions.length;
+  for (let i = 0; i < len; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    minX = x < minX ? x : minX;
+    minY = y < minY ? y : minY;
+    minZ = z < minZ ? z : minZ;
+    maxX = x > maxX ? x : maxX;
+    maxY = y > maxY ? y : maxY;
+    maxZ = z > maxZ ? z : maxZ;
+  }
+  return [
+    [minX, minY, minZ],
+    [maxX, maxY, maxZ]
+  ];
+}
+var init_mesh_utils = __esm({
+  "../../modules/schema-utils/src/lib/mesh/mesh-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema/src/float16.ts
+import { getFloat16ArrayConstructor, NativeFloat16ArrayConstructor } from "@math.gl/types";
+function createFloat16Array(length) {
+  const ArrayConstructor = getFloat16ArrayConstructor();
+  return new ArrayConstructor(length);
+}
+function isNativeFloat16Array(value) {
+  return Boolean(NativeFloat16ArrayConstructor && value instanceof NativeFloat16ArrayConstructor);
+}
+function setFloat16Value(array, index, value) {
+  if (isNativeFloat16Array(array)) {
+    array[index] = value;
+  } else {
+    array[index] = encodeFloat16(value);
+  }
+}
+function getFloat16Value(array, index) {
+  if (isNativeFloat16Array(array)) {
+    return array[index];
+  }
+  return decodeFloat16(array[index]);
+}
+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;
+}
+function decodeFloat16(value) {
+  const sign = value & 32768 ? -1 : 1;
+  const exponent = value >> 10 & 31;
+  const mantissa = value & 1023;
+  if (exponent === 0) {
+    return sign * mantissa * 2 ** -24;
+  }
+  if (exponent === 31) {
+    return mantissa ? NaN : sign * Infinity;
+  }
+  return sign * (1 + mantissa / 1024) * 2 ** (exponent - 15);
+}
+var init_float16 = __esm({
+  "../../modules/schema/src/float16.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema/src/index.ts
+var init_src3 = __esm({
+  "../../modules/schema/src/index.ts"() {
+    "use strict";
+    init_float16();
+  }
+});
+
+// ../../modules/schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts
+import * as arrow2 from "apache-arrow";
+function getFixedSizeListSize(vector) {
+  return vector.type instanceof arrow2.FixedSizeList ? vector.type.listSize : 1;
+}
+var init_arrow_fixed_size_list_utils = __esm({
+  "../../modules/schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../../modules/schema-utils/src/lib/mesh/convert-table-to-mesh.ts
+import * as arrow3 from "apache-arrow";
+function convertTableToMesh(table) {
+  switch (table.shape) {
+    // case 'columnar-table':
+    //   return convertColumnarTableToMesh(table);
+    case "arrow-table":
+      return convertArrowTableToMesh(table);
+    default:
+      throw new Error(table.shape);
+  }
+}
+function convertArrowTableToMesh(table) {
+  const arrowTable = table.data;
+  const schema = serializeArrowSchema(arrowTable.schema);
+  const fields = schema.fields;
+  const attributes = {};
+  for (const field of fields) {
+    const { name } = field;
+    if (name === "indices") {
+      continue;
+    }
+    const attributeData = arrowTable.getChild(name);
+    const size = getFixedSizeListSize(attributeData);
+    const typedArray = getAttributeTypedArray(attributeData, size);
+    const metadata = getMeshAttributeMetadata(field.metadata);
+    attributes[name] = {
+      value: metadata.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray,
+      size,
+      ...metadata
+    };
+  }
+  fixMetadata(schema);
+  const topology = schema.metadata.topology;
+  const mode = getMeshMode(schema);
+  const indices = getIndices(arrowTable);
+  const boundingBox = attributes.POSITION?.transform?.type === "quantization" ? getMeshBoundingBoxFromSchema(schema) || getMeshBoundingBox(attributes) : getMeshBoundingBox(attributes);
+  return {
+    schema,
+    attributes,
+    topology,
+    mode,
+    indices,
+    header: {
+      vertexCount: arrowTable.numRows,
+      boundingBox
+    }
+  };
+}
+function getMeshBoundingBoxFromSchema(schema) {
+  const serializedBoundingBox = schema.metadata?.boundingBox;
+  if (!serializedBoundingBox) {
+    return null;
+  }
+  try {
+    const boundingBox = JSON.parse(serializedBoundingBox);
+    if (Array.isArray(boundingBox) && boundingBox.length === 2 && boundingBox.every(
+      (corner) => Array.isArray(corner) && corner.length === 3 && corner.every((value) => typeof value === "number")
+    )) {
+      return boundingBox;
+    }
+  } catch {
+  }
+  return null;
+}
+function getMeshAttributeMetadata(metadata = {}) {
+  const result = {};
+  if (metadata.byteOffset !== void 0) {
+    result.byteOffset = Number(metadata.byteOffset);
+  }
+  if (metadata.byteStride !== void 0) {
+    result.byteStride = Number(metadata.byteStride);
+  }
+  if (metadata.normalized !== void 0) {
+    result.normalized = metadata.normalized === "true";
+  }
+  if (metadata.componentType === "float16") {
+    result.componentType = "float16";
+  }
+  if (metadata["loaders.gl.transform"]) {
+    try {
+      const transform = JSON.parse(metadata["loaders.gl.transform"]);
+      if (isMeshAttributeTransform(transform)) {
+        result.transform = transform;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function isMeshAttributeTransform(value) {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  const transform = value;
+  if (transform.type === "octahedron") {
+    return Number.isInteger(transform.bits) && transform.bits >= 1 && transform.bits <= 30;
+  }
+  return transform.type === "quantization" && Number.isInteger(transform.bits) && transform.bits >= 1 && transform.bits <= 30 && Array.isArray(transform.origin) && transform.origin.every((component) => typeof component === "number") && typeof transform.range === "number";
+}
+function fixMetadata(schema) {
+  schema.metadata ||= {};
+  schema.metadata.topology ||= "point-list";
+  schema.metadata.mode ||= "0";
+}
+function getAttributeTypedArray(attributeData, size) {
+  if (!(attributeData.type instanceof arrow3.FixedSizeList)) {
+    return attributeData.toArray();
+  }
+  const values = attributeData.data[0].children[0].values;
+  const TypedArrayConstructor = values.constructor;
+  const typedArray = new TypedArrayConstructor(attributeData.length * size);
+  let targetOffset = 0;
+  for (const data of attributeData.data) {
+    const child = data.children[0];
+    const sourceLength = data.length * size;
+    const sourceOffset = child.offset || data.offset * size;
+    const sourceStart = sourceOffset + sourceLength <= child.values.length ? sourceOffset : 0;
+    const source = child.values.subarray(sourceStart, sourceStart + sourceLength);
+    typedArray.set(source, targetOffset);
+    targetOffset += sourceLength;
+  }
+  return typedArray;
+}
+function restoreFloat16Array(typedArray) {
+  const result = createFloat16Array(typedArray.length);
+  for (let index = 0; index < typedArray.length; index++) {
+    setFloat16Value(result, index, getFloat16Value(typedArray, index));
+  }
+  return result;
+}
+function getMeshMode(schema) {
+  const mode = Number(schema.metadata?.mode);
+  return Number.isFinite(mode) ? mode : 0;
+}
+function getIndices(arrowTable) {
+  const indicesColumn = arrowTable.getChild("indices");
+  if (!indicesColumn?.isValid(0)) {
+    return void 0;
+  }
+  const indicesData = indicesColumn.data[0];
+  const valueOffsets = indicesData.valueOffsets;
+  const start = valueOffsets[indicesData.offset];
+  const end = valueOffsets[indicesData.offset + 1];
+  const values = indicesData.children[0].values.subarray(start, end);
+  return { value: values, size: 1 };
+}
+var init_convert_table_to_mesh = __esm({
+  "../../modules/schema-utils/src/lib/mesh/convert-table-to-mesh.ts"() {
+    "use strict";
+    init_src3();
+    init_arrow_fixed_size_list_utils();
+    init_convert_arrow_schema();
+    init_mesh_utils();
+  }
+});
+
+// ../../modules/schema-utils/src/lib/table/batch-builder/arrow-table-builder.ts
+import * as arrow4 from "apache-arrow";
+var ArrowTableBuilder;
+var init_arrow_table_builder = __esm({
+  "../../modules/schema-utils/src/lib/table/batch-builder/arrow-table-builder.ts"() {
+    "use strict";
+    init_src4();
+    ArrowTableBuilder = class {
+      schema;
+      arrowSchema;
+      arrowBuilders;
+      length;
+      constructor(schema, options) {
+        this.arrowSchema = convertSchemaToArrow(schema, options);
+        this.schema = options?.viewTypes && options.viewTypes !== "never" ? convertArrowToSchema(this.arrowSchema) : schema;
+        this.arrowBuilders = this.arrowSchema.fields.map(
+          (field) => arrow4.makeBuilder({ type: field.type, nullValues: [null] })
+        );
+        this.length = 0;
+      }
+      addObjectRow(row) {
+        for (let i = 0; i < this.arrowBuilders.length; i++) {
+          const columnName = this.schema.fields[i].name;
+          const value = row[columnName];
+          this.arrowBuilders[i].append(value);
+        }
+        this.length++;
+      }
+      addArrayRow(row) {
+        for (let i = 0; i < this.arrowBuilders.length; i++) {
+          this.arrowBuilders[i].append(row[i]);
+        }
+        this.length++;
+      }
+      /** Makes sure that a first batch with schema is sent even if no rows */
+      firstBatch() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        if (arrowRecordBatch.numCols !== 0) {
+          return null;
+        }
+        return {
+          shape: "arrow-table",
+          batchType: "data",
+          length: arrowRecordBatch.numRows,
+          schema: this.schema,
+          data: new arrow4.Table(arrowRecordBatch)
+        };
+      }
+      /** Flush the current batch if conditions are right */
+      flushBatch() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        if (arrowRecordBatch.numCols === 0) {
+          return null;
+        }
+        return {
+          shape: "arrow-table",
+          batchType: "data",
+          length: arrowRecordBatch.numRows,
+          schema: this.schema,
+          data: new arrow4.Table(arrowRecordBatch)
+        };
+      }
+      /** Get a last batch if any data is left */
+      finishBatch() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        this.arrowBuilders.forEach((builder) => builder.finish());
+        if (arrowRecordBatch.numCols === 0 && arrowRecordBatch.numRows === 0) {
+          return null;
+        }
+        return {
+          shape: "arrow-table",
+          batchType: "data",
+          length: arrowRecordBatch.numRows,
+          schema: this.schema,
+          data: new arrow4.Table(arrowRecordBatch)
+        };
+      }
+      /** Return a table with all the accumulated data */
+      finishTable() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        this.arrowBuilders.forEach((builder) => builder.finish());
+        return {
+          shape: "arrow-table",
+          schema: this.schema,
+          data: new arrow4.Table(arrowRecordBatch)
+        };
+      }
+      /** Extract a record batch flushing the currently accumulated data in the builders */
+      _getArrowRecordBatch() {
+        const { arrowBuilders, arrowSchema } = this;
+        const arrowDatas = arrowBuilders.map((builder) => builder.flush());
+        const length = arrowDatas[0]?.length || this.length;
+        this.length = 0;
+        const structField = new arrow4.Struct(arrowSchema.fields);
+        const arrowStructData = new arrow4.Data(structField, 0, length, 0, void 0, arrowDatas);
+        const arrowRecordBatch = new arrow4.RecordBatch(arrowSchema, arrowStructData);
+        return arrowRecordBatch;
+      }
+    };
+  }
+});
+
+// ../../modules/schema-utils/src/index.ts
+var init_src4 = __esm({
+  "../../modules/schema-utils/src/index.ts"() {
+    "use strict";
+    init_convert_arrow_schema();
+    init_convert_table_to_mesh();
+    init_arrow_table_builder();
+  }
+});
+
+// ../../modules/3d-tiles/src/lib/utils/version.ts
+var VERSION;
+var init_version = __esm({
+  "../../modules/3d-tiles/src/lib/utils/version.ts"() {
+    "use strict";
+    VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  }
+});
+
+// ../../modules/3d-tiles/src/lib/constants.ts
+var TILE3D_TYPE, TILE3D_TYPES, MAGIC_ARRAY;
+var init_constants = __esm({
+  "../../modules/3d-tiles/src/lib/constants.ts"() {
+    "use strict";
+    TILE3D_TYPE = {
+      COMPOSITE: "cmpt",
+      POINT_CLOUD: "pnts",
+      BATCHED_3D_MODEL: "b3dm",
+      INSTANCED_3D_MODEL: "i3dm",
+      GEOMETRY: "geom",
+      VECTOR: "vect",
+      GLTF: "glTF"
+    };
+    TILE3D_TYPES = Object.keys(TILE3D_TYPE);
+    MAGIC_ARRAY = {
+      BATCHED_MODEL: [98, 51, 100, 109],
+      INSTANCED_MODEL: [105, 51, 100, 109],
+      POINT_CLOUD: [112, 110, 116, 115],
+      COMPOSITE: [99, 109, 112, 116]
+    };
+  }
+});
+
+// src/v5/conversion-api.ts
+var TileConversionError = class extends Error {
+  /** Stable machine-readable failure code. */
+  code;
+  /** Diagnostics associated with this failure. */
+  diagnostics;
+  /** Creates a typed conversion failure. */
+  constructor(code, message, diagnostics = []) {
+    super(message);
+    this.name = "TileConversionError";
+    this.code = code;
+    this.diagnostics = diagnostics;
+  }
+};
+async function inspectTileset(source, signal) {
+  throwIfAborted(signal);
+  const inspection = await source.inspect(signal);
+  throwIfAborted(signal);
+  return inspection;
+}
+async function convertTileset(options) {
+  const {
+    source,
+    codec,
+    sink,
+    measureInputBytes,
+    measureOutputBytes,
+    maxInputResourceBytes = Number.POSITIVE_INFINITY,
+    maxOutputResourceBytes = Number.POSITIVE_INFINITY,
+    signal,
+    onProgress
+  } = options;
+  let inputResources = 0;
+  let outputResources = 0;
+  let inputBytes = 0;
+  let outputBytes = 0;
+  let largestOutputResourceBytes = 0;
+  const diagnostics = [];
+  const reportProgress = (phase) => {
+    onProgress?.({ phase, inputResources, outputResources, inputBytes, outputBytes });
+  };
+  try {
+    if (maxInputResourceBytes !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxInputResourceBytes) || maxInputResourceBytes < 0)) {
+      throw new TileConversionError(
+        "INVALID_INPUT_RESOURCE_LIMIT",
+        "maxInputResourceBytes must be a nonnegative safe integer or Infinity"
+      );
+    }
+    reportProgress("inspect");
+    const inspection = await inspectTileset(source, signal);
+    for await (const inputResource of source.read(inspection, signal)) {
+      throwIfAborted(signal);
+      const inputResourceBytes = measureInputBytes(inputResource);
+      if (!Number.isSafeInteger(inputResourceBytes) || inputResourceBytes < 0) {
+        throw new TileConversionError(
+          "INVALID_INPUT_RESOURCE_SIZE",
+          "measureInputBytes must return a nonnegative safe integer"
+        );
+      }
+      if (inputResourceBytes > maxInputResourceBytes) {
+        throw new TileConversionError(
+          "INPUT_RESOURCE_TOO_LARGE",
+          `Input resource is ${inputResourceBytes} bytes, exceeding the configured limit of ${maxInputResourceBytes} bytes`
+        );
+      }
+      inputResources++;
+      inputBytes += inputResourceBytes;
+      reportProgress("convert");
+      const convertedResources = await codec.convert(inputResource, inspection, signal);
+      for await (const outputResource of convertedResources) {
+        throwIfAborted(signal);
+        reportProgress("validate");
+        const resourceDiagnostics = await codec.validateOutput?.(outputResource, signal) || [];
+        diagnostics.push(...resourceDiagnostics);
+        const outputResourceBytes = measureOutputBytes(outputResource);
+        largestOutputResourceBytes = Math.max(largestOutputResourceBytes, outputResourceBytes);
+        if (outputResourceBytes > maxOutputResourceBytes) {
+          throw new TileConversionError(
+            "OUTPUT_RESOURCE_TOO_LARGE",
+            `Output resource is ${outputResourceBytes} bytes, exceeding the configured limit of ${maxOutputResourceBytes} bytes`
+          );
+        }
+        if (resourceDiagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+          throw new TileConversionError(
+            "OUTPUT_VALIDATION_FAILED",
+            "Output resource validation failed",
+            resourceDiagnostics
+          );
+        }
+        throwIfAborted(signal);
+        await sink.write(outputResource, signal);
+        throwIfAborted(signal);
+        outputResources++;
+        outputBytes += outputResourceBytes;
+        reportProgress("convert");
+      }
+    }
+    const report = {
+      state: "completed",
+      inputResources,
+      outputResources,
+      inputBytes,
+      outputBytes,
+      largestOutputResourceBytes,
+      diagnostics
+    };
+    throwIfAborted(signal);
+    reportProgress("finalize");
+    await sink.finalize(report);
+    return report;
+  } catch (error) {
+    try {
+      await sink.abort(error);
+    } catch (abortError) {
+      throw new AggregateError(
+        [error, abortError],
+        "Conversion failed and the destination could not abort"
+      );
+    }
+    throw error;
+  }
+}
+async function validateTileset(options) {
+  throwIfAborted(options.signal);
+  const diagnostics = await options.validate(options.tileset, options.signal);
+  throwIfAborted(options.signal);
+  return {
+    valid: !diagnostics.some((diagnostic) => diagnostic.severity === "error"),
+    diagnostics
+  };
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/tileset-source.ts
+init_src2();
+function createTilesetConversionSource(tileset, options = {}) {
+  return {
+    async inspect(signal) {
+      signal?.throwIfAborted();
+      await tileset.tilesetInitializationPromise;
+      signal?.throwIfAborted();
+      if (!tileset.root) {
+        throw new TileConversionError(
+          "TILESET_ROOT_REQUIRED",
+          "Tileset initialization completed without a root tile"
+        );
+      }
+      return tileset.source.getMetadata();
+    },
+    read: (_inspection, signal) => traverseTilesetContents(tileset, { unloadContent: options.unloadContent, signal })
+  };
+}
+
+// src/v5/spatial-conversion.ts
+init_src2();
+import { Matrix4 as Matrix43 } from "@math.gl/core";
+function createTiles3DConversionSpatialContext(discovered, options = {}) {
+  const spatialReference = createConversionSpatialReference(discovered, options);
+  if (spatialReference.status === "unresolved") {
+    throw createSpatialConversionError(spatialReference);
+  }
+  const transformer = spatialReference.status === "native" ? void 0 : createSpatialTransformer(
+    spatialReference,
+    () => new Tiles3DSpatialTransformer(spatialReference, options)
+  );
+  const outputSpatialReference = transformer ? markTilesetSpatialReferenceTransformed(spatialReference) : spatialReference;
+  return {
+    spatialReference: outputSpatialReference,
+    transformPositions: (positions) => transformer ? transformer.transformPositions(positions) : Float64Array.from(positions),
+    transformNormals: (normals, positions) => transformer ? transformer.transformNormals(normals, positions) : Float32Array.from(normals),
+    transformBoundingVolume: (volume, sourceTransform) => transformer ? transformer.transformBoundingVolume(volume, sourceTransform) : cloneBoundingVolume(volume)
+  };
+}
+function createI3SConversionSpatialContext(discovered, options = {}) {
+  const spatialReference = createConversionSpatialReference(discovered, options);
+  if (spatialReference.status === "unresolved") {
+    throw createSpatialConversionError(spatialReference);
+  }
+  const transformer = spatialReference.status === "native" ? void 0 : createSpatialTransformer(
+    spatialReference,
+    () => new I3SSpatialTransformer(spatialReference, options)
+  );
+  const outputSpatialReference = transformer ? transformer.spatialReference : spatialReference;
+  return {
+    spatialReference: outputSpatialReference,
+    transformPositions: (positions, sourceOrigin) => transformer ? transformer.transformPositions(positions, sourceOrigin) : createNativeI3SPositions(positions, sourceOrigin, spatialReference),
+    transformPositionsAsync: (positions, sourceOrigin) => transformer ? transformer.transformPositionsAsync(positions, sourceOrigin) : Promise.resolve(createNativeI3SPositions(positions, sourceOrigin, spatialReference)),
+    transformNormals: (normals, positions, normalReferenceFrame) => transformer ? transformer.transformNormals(normals, positions, normalReferenceFrame) : Float32Array.from(normals),
+    transformBoundingVolume: (bounds) => transformer ? transformer.transformBoundingVolume(bounds) : cloneI3SBounds(bounds),
+    transformBoundingVolumeAsync: (bounds) => transformer ? transformer.transformBoundingVolumeAsync(bounds) : Promise.resolve(cloneI3SBounds(bounds))
+  };
+}
+function createSpatialConversionError(spatialReference, cause) {
+  const diagnostics = spatialReference.warnings.map((message2) => ({
+    code: "SPATIAL_REFERENCE_WARNING",
+    message: message2,
+    severity: "warning"
+  }));
+  const causeMessage = cause instanceof Error ? `: ${cause.message}` : "";
+  const message = causeMessage ? `Spatial conversion could not be initialized${causeMessage}` : "The requested spatial conversion cannot be resolved from the available metadata";
+  diagnostics.push({
+    code: "SPATIAL_REFERENCE_UNRESOLVED",
+    message,
+    severity: "error"
+  });
+  return new TileConversionError("SPATIAL_REFERENCE_UNRESOLVED", message, diagnostics);
+}
+function createConversionSpatialReference(discovered, options) {
+  if (!("status" in discovered)) {
+    return createTilesetSpatialReference(discovered, options);
+  }
+  if (discovered.status === "transformed") {
+    throw createSpatialConversionError(
+      discovered,
+      new Error("coordinates are already transformed")
+    );
+  }
+  const sourceMetadata = {
+    sourceCrs: discovered.sourceCrs,
+    sourceCrsState: discovered.crs.state,
+    sourceCrsRepresentation: discovered.crs.state === "explicit" || discovered.crs.state === "default" ? discovered.crs.representation : void 0,
+    sourceCrsAlternatives: discovered.crs.state === "explicit" || discovered.crs.state === "default" ? discovered.crs.alternatives : void 0,
+    verticalCrs: discovered.verticalCrs,
+    units: discovered.units,
+    verticalUnitScale: discovered.verticalUnitScale,
+    coordinateEpoch: discovered.coordinateEpoch,
+    heightReference: discovered.heightReference,
+    elevationMode: discovered.elevationMode,
+    elevationOffset: discovered.elevationOffset,
+    elevationUnit: discovered.elevationUnit,
+    elevationUnitScale: discovered.elevationUnitScale,
+    coordinateFrame: discovered.coordinateFrame,
+    axisOrder: discovered.axisOrder,
+    provenance: discovered.provenance,
+    warnings: discovered.warnings
+  };
+  const retainedOptions = {
+    ...options,
+    targetCrs: options.targetCrs ?? discovered.targetCrs,
+    targetHeightReference: options.targetHeightReference ?? discovered.targetHeightReference,
+    outputCoordinates: options.outputCoordinates ?? discovered.outputCoordinates
+  };
+  return createTilesetSpatialReference(sourceMetadata, retainedOptions);
+}
+function createSpatialTransformer(spatialReference, createTransformer) {
+  try {
+    return createTransformer();
+  } catch (error) {
+    throw createSpatialConversionError(spatialReference, error);
+  }
+}
+function cloneBoundingVolume(volume) {
+  return {
+    ...volume,
+    box: volume.box ? [...volume.box] : void 0,
+    sphere: volume.sphere ? [...volume.sphere] : void 0,
+    region: volume.region ? [...volume.region] : void 0
+  };
+}
+function cloneI3SBounds(bounds) {
+  return {
+    ...bounds,
+    mbs: bounds.mbs ? Array.from(bounds.mbs) : void 0,
+    obb: bounds.obb ? {
+      center: Array.from(bounds.obb.center),
+      halfSize: Array.from(bounds.obb.halfSize),
+      quaternion: Array.from(bounds.obb.quaternion)
+    } : void 0
+  };
+}
+function createNativeI3SPositions(sourcePositions, sourceOrigin, spatialReference) {
+  if (sourcePositions.length % 3 !== 0 || sourceOrigin.length < 3) {
+    throw new Error("I3S positions and origin must contain complete xyz coordinates");
+  }
+  const origin = [
+    Number(sourceOrigin[0]),
+    Number(sourceOrigin[1]),
+    Number(sourceOrigin[2])
+  ];
+  const sourcePositions64 = Float64Array.from(sourcePositions);
+  const positions = new Float32Array(sourcePositions.length);
+  for (let index = 0; index < sourcePositions.length; index += 3) {
+    positions[index] = Number(sourcePositions[index]) - origin[0];
+    positions[index + 1] = Number(sourcePositions[index + 1]) - origin[1];
+    positions[index + 2] = Number(sourcePositions[index + 2]) - origin[2];
+  }
+  const isGeographic = spatialReference.coordinateFrame === "geographic";
+  const modelMatrix = isGeographic ? new Matrix43() : new Matrix43().translate(origin);
+  return {
+    positions,
+    sourcePositions: sourcePositions64,
+    origin,
+    cartographicOrigin: isGeographic ? origin : [0, 0, 0],
+    coordinateSystem: isGeographic ? "lnglat-offsets" : "cartesian",
+    modelMatrix
+  };
+}
+
+// src/v5/feature-arrow.ts
+init_src4();
+var DEFAULT_FEATURE_ID_FIELD = "feature_id";
+var FEATURE_CLASS_METADATA_KEY = "loaders.gl:feature-class";
+function convertFeatureAttributesToArrowBatches(features, options) {
+  const featureIdField = options.featureIdField || DEFAULT_FEATURE_ID_FIELD;
+  const batchSize = options.batchSize ?? 65536;
+  if (!Number.isInteger(batchSize) || batchSize <= 0) {
+    throw new TileConversionError(
+      "INVALID_FEATURE_BATCH_SIZE",
+      "Feature Arrow batch size must be a positive integer"
+    );
+  }
+  const featureClasses = new Set(features.map((feature) => feature.metadataClass));
+  if (featureClasses.size > 1) {
+    throw new TileConversionError(
+      "MULTIPLE_FEATURE_CLASSES",
+      "Build separate Arrow batches for each source metadata class"
+    );
+  }
+  const metadataClass = features[0]?.metadataClass;
+  const schema = makeFeatureSchema(
+    options.schema,
+    featureIdField,
+    options.rawMetadataField,
+    metadataClass
+  );
+  const fieldsByName = new Map(schema.fields.map((field) => [field.name, field]));
+  const propertyFieldNames = new Set(
+    schema.fields.filter((field) => field.name !== featureIdField && field.name !== options.rawMetadataField).map((field) => field.name)
+  );
+  for (const feature of features) {
+    validateFeatureIdentifier(feature.featureId, fieldsByName.get(featureIdField)?.type);
+    if (feature.rawMetadata && !options.rawMetadataField) {
+      throw new TileConversionError(
+        "RAW_METADATA_FIELD_REQUIRED",
+        "A rawMetadataField must be declared to preserve encoded source metadata"
+      );
+    }
+    for (const propertyName of Object.keys(feature.properties)) {
+      if (!propertyFieldNames.has(propertyName)) {
+        throw new TileConversionError(
+          "FEATURE_PROPERTY_NOT_MAPPED",
+          `Feature property "${propertyName}" is not declared in the Arrow schema`
+        );
+      }
+    }
+  }
+  const batches = [];
+  for (let batchStart = 0; batchStart < features.length; batchStart += batchSize) {
+    const tableBuilder = new ArrowTableBuilder(schema);
+    const batchFeatures = features.slice(batchStart, batchStart + batchSize);
+    for (const feature of batchFeatures) {
+      const row = {
+        ...feature.properties,
+        [featureIdField]: feature.featureId
+      };
+      if (options.rawMetadataField) {
+        row[options.rawMetadataField] = feature.rawMetadata || null;
+      }
+      for (const field of schema.fields) {
+        if (row[field.name] === void 0) {
+          row[field.name] = null;
+        }
+        validateFeatureValue(field, row[field.name], field.name);
+      }
+      tableBuilder.addObjectRow(row);
+    }
+    const batch = tableBuilder.finishBatch();
+    if (batch) {
+      batches.push(batch);
+    }
+  }
+  return batches;
+}
+function makeFeatureSchema(sourceSchema, featureIdField, rawMetadataField, metadataClass) {
+  const fieldsByName = new Map(sourceSchema.fields.map((field) => [field.name, field]));
+  if (fieldsByName.size !== sourceSchema.fields.length) {
+    throw new TileConversionError(
+      "DUPLICATE_FEATURE_FIELDS",
+      "Arrow schema fields must have unique names"
+    );
+  }
+  for (const field of sourceSchema.fields) {
+    validateFeatureSchemaType(field);
+  }
+  const featureIdType = fieldsByName.get(featureIdField)?.type;
+  if (!featureIdType) {
+    throw new TileConversionError(
+      "FEATURE_ID_FIELD_REQUIRED",
+      `Arrow schema must declare the feature identifier field "${featureIdField}"`
+    );
+  }
+  if (rawMetadataField && !fieldsByName.has(rawMetadataField)) {
+    throw new TileConversionError(
+      "RAW_METADATA_FIELD_NOT_DECLARED",
+      `Arrow schema does not declare the raw metadata field "${rawMetadataField}"`
+    );
+  }
+  if (rawMetadataField === featureIdField) {
+    throw new TileConversionError(
+      "FEATURE_FIELDS_COLLIDE",
+      "The feature identifier and raw metadata require separate Arrow fields"
+    );
+  }
+  if (rawMetadataField && !isBinaryType(fieldsByName.get(rawMetadataField)?.type)) {
+    throw new TileConversionError(
+      "RAW_METADATA_FIELD_NOT_BINARY",
+      `Arrow schema field "${rawMetadataField}" must use binary or fixed-size-binary type`
+    );
+  }
+  return {
+    ...sourceSchema,
+    metadata: {
+      ...sourceSchema.metadata || {},
+      ...metadataClass ? { [FEATURE_CLASS_METADATA_KEY]: metadataClass } : {}
+    }
+  };
+}
+function validateFeatureIdentifier(featureId, dataType) {
+  const isStringIdentifier = typeof featureId === "string";
+  const isIntegerIdentifier2 = typeof featureId === "bigint" || Number.isSafeInteger(featureId);
+  const isStringType = dataType === "utf8" || dataType === "utf8-view";
+  if (isStringIdentifier && isStringType || isIntegerIdentifier2 && isIntegerDataType(dataType)) {
+    return;
+  }
+  throw new TileConversionError(
+    "FEATURE_ID_TYPE_MISMATCH",
+    `Feature identifier ${String(featureId)} is not compatible with the declared Arrow type`
+  );
+}
+function validateFeatureValue(field, value, fieldPath) {
+  if (value === null || value === void 0) {
+    if (field.nullable !== true) {
+      throw new TileConversionError(
+        "FEATURE_VALUE_REQUIRED",
+        `Required Arrow field "${fieldPath}" has no value`
+      );
+    }
+    return;
+  }
+  const dataType = field.type;
+  if (typeof dataType === "object") {
+    if (dataType.type === "dictionary") {
+      validateFeatureValue({ ...field, type: dataType.dictionary }, value, fieldPath);
+      return;
+    }
+    if (dataType.type === "list" || dataType.type === "large-list") {
+      if (!Array.isArray(value)) {
+        throw createFeatureValueTypeError(fieldPath, "an array");
+      }
+      const childField = dataType.children[0];
+      for (let index = 0; index < value.length; index++) {
+        validateFeatureValue(childField, value[index], `${fieldPath}[${index}]`);
+      }
+      return;
+    }
+    if (dataType.type === "fixed-size-list") {
+      if (!Array.isArray(value) || value.length !== dataType.listSize) {
+        throw createFeatureValueTypeError(fieldPath, `an array of length ${dataType.listSize}`);
+      }
+      const childField = dataType.children[0];
+      for (let index = 0; index < value.length; index++) {
+        validateFeatureValue(childField, value[index], `${fieldPath}[${index}]`);
+      }
+      return;
+    }
+    if (dataType.type === "struct") {
+      if (!isRecord(value)) {
+        throw createFeatureValueTypeError(fieldPath, "an object");
+      }
+      const childNames = new Set(dataType.children.map((childField) => childField.name));
+      const unknownNames = Object.keys(value).filter((name) => !childNames.has(name));
+      if (unknownNames.length > 0) {
+        throw new TileConversionError(
+          "FEATURE_PROPERTY_NOT_MAPPED",
+          `Nested feature properties "${unknownNames.join(", ")}" are not declared under "${fieldPath}"`
+        );
+      }
+      for (const childField of dataType.children) {
+        validateFeatureValue(childField, value[childField.name], `${fieldPath}.${childField.name}`);
+      }
+      return;
+    }
+    if (dataType.type === "decimal") {
+      if (typeof value !== "bigint") {
+        throw createFeatureValueTypeError(fieldPath, "an unscaled bigint decimal value");
+      }
+      if (value <= -(10n ** BigInt(dataType.precision)) || value >= 10n ** BigInt(dataType.precision)) {
+        throw new TileConversionError(
+          "FEATURE_VALUE_OUT_OF_RANGE",
+          `Value for Arrow decimal field "${fieldPath}" exceeds precision ${dataType.precision}`
+        );
+      }
+      return;
+    }
+    if (dataType.type === "fixed-size-binary") {
+      const byteLength = getByteLength(value);
+      if (byteLength !== dataType.byteWidth) {
+        throw createFeatureValueTypeError(fieldPath, `exactly ${dataType.byteWidth} bytes`);
+      }
+      return;
+    }
+    throw new TileConversionError(
+      "FEATURE_VALUE_MAPPING_UNSUPPORTED",
+      `Arrow schema type "${dataType.type}" has no feature value mapping for "${fieldPath}"`
+    );
+  }
+  if (isIntegerDataType(dataType)) {
+    if (!isIntegerIdentifier(value)) {
+      throw createFeatureValueTypeError(fieldPath, "an integer");
+    }
+    const [minimum, maximum] = getIntegerBounds(dataType);
+    const integerValue = typeof value === "bigint" ? value : BigInt(value);
+    if (integerValue < minimum || integerValue > maximum) {
+      throw new TileConversionError(
+        "FEATURE_VALUE_OUT_OF_RANGE",
+        `Value for Arrow field "${fieldPath}" is outside the range of ${dataType}`
+      );
+    }
+    return;
+  }
+  if (dataType === "utf8" || dataType === "utf8-view") {
+    if (typeof value !== "string") throw createFeatureValueTypeError(fieldPath, "a string");
+    return;
+  }
+  if (dataType === "bool") {
+    if (typeof value !== "boolean") throw createFeatureValueTypeError(fieldPath, "a boolean");
+    return;
+  }
+  if (dataType === "binary" || dataType === "binary-view") {
+    if (getByteLength(value) < 0) throw createFeatureValueTypeError(fieldPath, "binary data");
+    return;
+  }
+  if (dataType === "float" || dataType === "float16" || dataType === "float32" || dataType === "float64") {
+    if (typeof value !== "number") throw createFeatureValueTypeError(fieldPath, "a number");
+    return;
+  }
+  if (dataType === "null") {
+    throw createFeatureValueTypeError(fieldPath, "null");
+  }
+  if (dataType === "date-day" || dataType === "date-millisecond" || dataType.startsWith("timestamp-")) {
+    if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+      throw createFeatureValueTypeError(fieldPath, "a valid Date");
+    }
+    return;
+  }
+  throw new TileConversionError(
+    "FEATURE_VALUE_MAPPING_UNSUPPORTED",
+    `Arrow schema type "${dataType}" has no feature value mapping for "${fieldPath}"`
+  );
+}
+function isIntegerIdentifier(value) {
+  return typeof value === "bigint" || typeof value === "number" && Number.isSafeInteger(value);
+}
+function isIntegerDataType(dataType) {
+  return dataType === "int8" || dataType === "int16" || dataType === "int32" || dataType === "int64" || dataType === "uint8" || dataType === "uint16" || dataType === "uint32" || dataType === "uint64";
+}
+function validateFeatureSchemaType(field) {
+  const dataType = field.type;
+  if (dataType === "int") {
+    throw new TileConversionError(
+      "FEATURE_INTEGER_TYPE_UNSUPPORTED",
+      `Arrow field "${field.name}" must declare an explicit integer width and signedness`
+    );
+  }
+  if (typeof dataType !== "object") {
+    return;
+  }
+  let childFields = [];
+  if (dataType.type === "dictionary" && dataType.indices) {
+    childFields = [{ name: `${field.name} index`, type: dataType.indices, nullable: false }];
+  } else if ("children" in dataType) {
+    childFields = dataType.children;
+  }
+  for (const childField of childFields) {
+    validateFeatureSchemaType(childField);
+  }
+}
+function getIntegerBounds(dataType) {
+  switch (dataType) {
+    case "int8":
+      return [-128n, 127n];
+    case "uint8":
+      return [0n, 255n];
+    case "int16":
+      return [-32768n, 32767n];
+    case "uint16":
+      return [0n, 65535n];
+    case "int32":
+      return [-2147483648n, 2147483647n];
+    case "uint32":
+      return [0n, 4294967295n];
+    case "int64":
+      return [-(2n ** 63n), 2n ** 63n - 1n];
+    case "uint64":
+      return [0n, 2n ** 64n - 1n];
+    default:
+      return [-(2n ** 31n), 2n ** 31n - 1n];
+  }
+}
+function createFeatureValueTypeError(fieldPath, expected) {
+  return new TileConversionError(
+    "FEATURE_VALUE_TYPE_MISMATCH",
+    `Arrow field "${fieldPath}" requires ${expected}`
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getByteLength(value) {
+  if (value instanceof Uint8Array) return value.byteLength;
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  return -1;
+}
+function isBinaryType(dataType) {
+  return dataType === "binary" || dataType === "binary-view" || typeof dataType === "object" && dataType.type === "fixed-size-binary";
+}
+
+// ../../modules/3d-tiles/src/tile-3d-writer.ts
+init_version();
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile.ts
+init_constants();
+init_src();
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-composite.ts
+init_constants();
+
+// ../../modules/3d-tiles/src/lib/encoders/helpers/encode-3d-tile-header.ts
+init_src();
+function encode3DTileHeader(tile, dataView, byteOffset) {
+  const HEADER_SIZE = 12;
+  if (!dataView) {
+    return byteOffset + HEADER_SIZE;
+  }
+  const { magic, version = 1, byteLength = 12 } = tile;
+  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));
+  dataView.setUint8(byteOffset + 0, magic[0]);
+  dataView.setUint8(byteOffset + 1, magic[1]);
+  dataView.setUint8(byteOffset + 2, magic[2]);
+  dataView.setUint8(byteOffset + 3, magic[3]);
+  dataView.setUint32(byteOffset + 4, version, true);
+  dataView.setUint32(byteOffset + 8, byteLength, true);
+  byteOffset += HEADER_SIZE;
+  return byteOffset;
+}
+function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
+  if (!dataView) {
+    return;
+  }
+  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true);
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-composite.ts
+function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile2) {
+  tile = { magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(byteOffset, tile.tiles.length, true);
+  }
+  byteOffset += 4;
+  for (let i = 0; i < tile.tiles.length; ++i) {
+    byteOffset += encode3DTile2(tile.tiles[i], dataView, byteOffset, options);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-batched-model.ts
+init_src();
+init_constants();
+function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {
+  const { featuresLength = 0, batchTable } = tile;
+  const featureTableJson = {
+    BATCH_LENGTH: featuresLength
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : "";
+  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);
+  const batchTableJsonByteLength = batchTableJsonString ? padToNBytes(batchTableJsonString.length, 8) : 0;
+  tile = { magic: MAGIC_ARRAY.BATCHED_MODEL, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, batchTableJsonByteLength, true);
+    dataView.setUint32(24, 0, true);
+  }
+  byteOffset += 16;
+  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);
+  if (batchTable) {
+    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);
+  }
+  const gltfEncoded = tile.gltfEncoded;
+  if (gltfEncoded) {
+    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-instanced-model.ts
+init_src();
+init_constants();
+function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {
+  const { featuresLength = 1, gltfFormat = 1, gltfUri = "" } = tile;
+  const gltfUriByteLength = gltfUri.length;
+  const featureTableJson = {
+    INSTANCES_LENGTH: featuresLength,
+    POSITION: new Array(featuresLength * 3).fill(0)
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const featureTableJsonByteLength = featureTableJsonString.length;
+  tile = { magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, 0);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, 0, true);
+    dataView.setUint32(24, 0, true);
+    dataView.setUint32(28, gltfFormat, true);
+  }
+  byteOffset += 20;
+  byteOffset += copyStringToDataView(
+    dataView,
+    byteOffset,
+    featureTableJsonString,
+    featureTableJsonByteLength
+  );
+  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile-point-cloud.ts
+init_constants();
+init_src();
+var DEFAULT_FEATURE_TABLE_JSON = {
+  POINTS_LENGTH: 1,
+  POSITIONS: {
+    byteOffset: 0
+  }
+};
+function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
+  const pointData = getPointCloudFeatureTable(tile);
+  const featureTableJsonString = padStringToByteAlignment(JSON.stringify(pointData.json), 4);
+  const featureTableJsonByteLength = tile.featureTableJsonByteLength ?? featureTableJsonString.length;
+  const featureTableBinary = pointData.binary;
+  const featureTableBinaryByteLength = featureTableBinary.byteLength;
+  const batchTableJsonString = tile.batchTableJson ? JSON.stringify(tile.batchTableJson) : "";
+  const batchTableJsonByteLength = batchTableJsonString ? padStringToByteAlignment(batchTableJsonString, 4).length : 0;
+  const paddedBatchTableJsonString = batchTableJsonByteLength ? padStringToByteAlignment(batchTableJsonString, 4) : "";
+  const batchTableBinary = tile.batchTableBinary || new Uint8Array();
+  tile = { magic: MAGIC_ARRAY.POINT_CLOUD, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true);
+    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true);
+    dataView.setUint32(byteOffset + 8, batchTableJsonByteLength, true);
+    dataView.setUint32(byteOffset + 12, batchTableBinary.byteLength, true);
+  }
+  byteOffset += 16;
+  byteOffset = copyStringToDataView(
+    dataView,
+    byteOffset,
+    featureTableJsonString,
+    featureTableJsonByteLength
+  );
+  byteOffset = copyBinaryToDataView(
+    dataView,
+    byteOffset,
+    featureTableBinary,
+    featureTableBinaryByteLength
+  );
+  if (batchTableJsonByteLength > 0) {
+    byteOffset = copyStringToDataView(
+      dataView,
+      byteOffset,
+      paddedBatchTableJsonString,
+      batchTableJsonByteLength
+    );
+  }
+  byteOffset = copyBinaryToDataView(
+    dataView,
+    byteOffset,
+    batchTableBinary,
+    batchTableBinary.byteLength
+  );
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+function getPointCloudFeatureTable(tile) {
+  const positions = tile.attributes?.positions;
+  if (!positions) {
+    const json2 = tile.featureTableJson || DEFAULT_FEATURE_TABLE_JSON;
+    return { json: json2, binary: new Uint8Array(12) };
+  }
+  if (positions.length === 0 || positions.length % 3 !== 0) {
+    throw new Error("3D Tiles point cloud positions must contain one or more xyz triples");
+  }
+  const pointCount = positions.length / 3;
+  const properties = [];
+  properties.push({ name: "POSITION", alignment: 4, bytes: encodeFloat32Array(positions) });
+  const colors = tile.attributes?.colors;
+  if (colors) {
+    const colorValues = Array.isArray(colors) ? colors : colors.value;
+    const colorSize = Array.isArray(colors) ? colorValues.length / pointCount : colors.size;
+    if (colorSize !== 3 && colorSize !== 4) {
+      throw new Error("3D Tiles point cloud colors must contain RGB or RGBA values");
+    }
+    const colorBytes = encodeColorBytes(
+      colorValues,
+      !Array.isArray(colors) && colors.normalized,
+      pointCount,
+      colorSize
+    );
+    properties.push({ name: colorSize === 4 ? "RGBA" : "RGB", alignment: 1, bytes: colorBytes });
+  }
+  const normals = tile.attributes?.normals;
+  if (normals) {
+    const normalValues = Array.isArray(normals) ? normals : normals.value;
+    if (normalValues.length !== pointCount * 3) {
+      throw new Error("3D Tiles point cloud normal count does not match the position count");
+    }
+    properties.push({ name: "NORMAL", alignment: 4, bytes: encodeFloat32Array(normalValues) });
+  }
+  const batchIds = tile.attributes?.batchIds;
+  let batchLength = 0;
+  if (batchIds) {
+    if (batchIds.length !== pointCount) {
+      throw new Error("3D Tiles point cloud batch ID count does not match the position count");
+    }
+    const batchIdValues = new Uint16Array(batchIds.length);
+    for (let index = 0; index < batchIds.length; index++) {
+      const batchId = batchIds[index];
+      if (!Number.isInteger(batchId) || batchId < 0 || batchId > 65535) {
+        throw new Error("3D Tiles point cloud batch IDs must be unsigned 16-bit integers");
+      }
+      batchIdValues[index] = batchId;
+      batchLength = Math.max(batchLength, batchId + 1);
+    }
+    const batchIdBytes = new Uint8Array(batchIdValues.length * 2);
+    const dataView = new DataView(batchIdBytes.buffer);
+    for (let index = 0; index < batchIdValues.length; index++) {
+      dataView.setUint16(index * 2, batchIdValues[index], true);
+    }
+    properties.push({ name: "BATCH_ID", alignment: 2, bytes: batchIdBytes });
+  }
+  const json = {
+    ...tile.featureTableJson || {},
+    POINTS_LENGTH: pointCount
+  };
+  if (batchIds) {
+    json.BATCH_LENGTH = batchLength;
+  }
+  const binaryByteLength = getPointCloudFeatureTableByteLength(properties);
+  const binary = new Uint8Array(binaryByteLength);
+  let byteOffset = 0;
+  for (const property of properties) {
+    byteOffset = align(byteOffset, property.alignment);
+    json[property.name] = { byteOffset };
+    binary.set(property.bytes, byteOffset);
+    byteOffset += property.bytes.byteLength;
+  }
+  return { json, binary };
+}
+function getPointCloudFeatureTableByteLength(properties) {
+  let byteLength = 0;
+  for (const property of properties) {
+    byteLength = align(byteLength, property.alignment) + property.bytes.byteLength;
+  }
+  return byteLength;
+}
+function align(byteOffset, alignment) {
+  return Math.ceil(byteOffset / alignment) * alignment;
+}
+function encodeFloat32Array(values) {
+  const bytes = new Uint8Array(values.length * 4);
+  const dataView = new DataView(bytes.buffer);
+  for (let index = 0; index < values.length; index++) {
+    const value = values[index];
+    if (!Number.isFinite(value)) {
+      throw new Error("3D Tiles point cloud attributes must contain finite values");
+    }
+    dataView.setFloat32(index * 4, value, true);
+  }
+  return bytes;
+}
+function encodeColorBytes(colors, normalized, pointCount, colorSize) {
+  if (colors.length !== pointCount * colorSize) {
+    throw new Error("3D Tiles point cloud color count does not match the position count");
+  }
+  const bytes = new Uint8Array(colors.length);
+  for (let index = 0; index < colors.length; index++) {
+    const value = colors[index];
+    const scaledValue = normalized ? value * 255 : value;
+    if (!Number.isFinite(scaledValue) || scaledValue < 0 || scaledValue > 255) {
+      throw new Error("3D Tiles point cloud color components must be between 0 and 255");
+    }
+    bytes[index] = Math.round(scaledValue);
+  }
+  return bytes;
+}
+
+// ../../modules/3d-tiles/src/lib/encoders/encode-3d-tile.ts
+function encode3DTile(tile, options) {
+  const byteLength = encode3DTileToDataView(tile, null, 0, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  encode3DTileToDataView(tile, dataView, 0, options);
+  return arrayBuffer;
+}
+function encode3DTileToDataView(tile, dataView, byteOffset, options) {
+  assert(typeof tile.type === "string");
+  switch (tile.type) {
+    case TILE3D_TYPE.COMPOSITE:
+      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);
+    case TILE3D_TYPE.POINT_CLOUD:
+      return encodePointCloud3DTile(tile, dataView, byteOffset, options);
+    case TILE3D_TYPE.BATCHED_3D_MODEL:
+      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);
+    case TILE3D_TYPE.INSTANCED_3D_MODEL:
+      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);
+    default:
+      throw new Error("3D Tiles: unknown tile type");
+  }
+}
+
+// ../../modules/3d-tiles/src/tile-3d-writer.ts
+var Tile3DWriter = {
+  name: "3D Tile",
+  id: "3d-tiles",
+  module: "3d-tiles",
+  version: VERSION,
+  extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
+  mimeTypes: ["application/octet-stream"],
+  binary: true,
+  options: {
+    ["3d-tiles"]: {}
+  },
+  encode: async (tile, options) => encodeSync(tile, options),
+  encodeSync
+};
+function encodeSync(tile, options) {
+  return encode3DTile(tile, options);
+}
+
+// ../../modules/3d-tiles/src/index.ts
+init_constants();
+
+// src/v5/point-cloud.ts
+init_src4();
+function encodePointCloudTile(pointBatch, options = {}) {
+  const mesh = "attributes" in pointBatch ? pointBatch : convertTableToMesh(pointBatch);
+  validatePointAttributes(mesh.attributes);
+  const positionAttribute = mesh.attributes.POSITION;
+  if (!positionAttribute || positionAttribute.size !== 3) {
+    throw new TileConversionError(
+      "POINT_CLOUD_POSITION_REQUIRED",
+      "Point cloud batches must contain a three-component POSITION attribute"
+    );
+  }
+  const positions = getPositionValues(positionAttribute, options.rtcCenter);
+  const pointCount = positions.length / 3;
+  if (pointCount === 0 || !Number.isInteger(pointCount)) {
+    throw new TileConversionError(
+      "POINT_CLOUD_POSITION_COUNT_INVALID",
+      "Point cloud POSITION must contain one or more xyz triples"
+    );
+  }
+  const colors = getColorAttribute(mesh.attributes.COLOR_0 || mesh.attributes.COLOR, pointCount);
+  const constantRGBA = colors ? null : getConstantRgba(options.constantRGBA);
+  const normals = getNormalAttribute(mesh.attributes.NORMAL, pointCount);
+  const batchIds = getBatchIds(mesh.attributes.BATCH_ID, pointCount);
+  const batchTableJson = validateBatchTable(options.batchTableJson, batchIds);
+  return Tile3DWriter.encodeSync(
+    {
+      type: TILE3D_TYPE.POINT_CLOUD,
+      featureTableJson: options.rtcCenter || constantRGBA ? {
+        ...options.rtcCenter ? { RTC_CENTER: [...options.rtcCenter] } : {},
+        ...constantRGBA ? { CONSTANT_RGBA: constantRGBA } : {}
+      } : void 0,
+      batchTableJson,
+      attributes: { positions, colors, normals, batchIds }
+    },
+    {}
+  );
+}
+function validatePointAttributes(attributes) {
+  const supportedAttributes = /* @__PURE__ */ new Set([
+    "POSITION",
+    "NORMAL",
+    "BATCH_ID",
+    attributes.COLOR_0 ? "COLOR_0" : "COLOR"
+  ]);
+  const unsupportedAttributes = Object.keys(attributes).filter(
+    (name) => !supportedAttributes.has(name)
+  );
+  if (unsupportedAttributes.length > 0) {
+    throw new TileConversionError(
+      "POINT_CLOUD_ATTRIBUTE_UNSUPPORTED",
+      `PNTS encoding does not support these point attributes: ${unsupportedAttributes.join(", ")}`
+    );
+  }
+}
+function getConstantRgba(constantRGBA) {
+  if (!constantRGBA) {
+    return null;
+  }
+  if (constantRGBA.length !== 4 || constantRGBA.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) {
+    throw new TileConversionError(
+      "POINT_CLOUD_CONSTANT_RGBA_INVALID",
+      "Point cloud constantRGBA must contain four unsigned byte values"
+    );
+  }
+  return [constantRGBA[0], constantRGBA[1], constantRGBA[2], constantRGBA[3]];
+}
+function getPositionValues(attribute, rtcCenter) {
+  if (rtcCenter && (rtcCenter.length !== 3 || rtcCenter.some((value) => !Number.isFinite(value)))) {
+    throw new TileConversionError(
+      "POINT_CLOUD_RTC_CENTER_INVALID",
+      "Point cloud RTC_CENTER must contain three finite values"
+    );
+  }
+  const values = attribute.value;
+  const result = new Float32Array(values.length);
+  const transform = attribute.transform;
+  for (let index = 0; index < values.length; index++) {
+    const component = index % 3;
+    const value = values[index];
+    const absoluteValue = transform?.type === "quantization" ? transform.origin[component] + value / (2 ** transform.bits - 1) * transform.range : value;
+    result[index] = absoluteValue - (rtcCenter?.[component] ?? 0);
+  }
+  return result;
+}
+function getColorAttribute(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 3 && attribute.size !== 4) {
+    throw new TileConversionError(
+      "POINT_CLOUD_COLOR_SIZE_UNSUPPORTED",
+      "Point cloud color attributes must contain three or four components"
+    );
+  }
+  if (attribute.value.length !== pointCount * attribute.size) {
+    throw new TileConversionError(
+      "POINT_CLOUD_COLOR_COUNT_MISMATCH",
+      "Point cloud color count does not match the POSITION count"
+    );
+  }
+  const colors = new Uint8Array(attribute.value.length);
+  const maximum = getIntegerColorMaximum(attribute.value);
+  for (let index = 0; index < attribute.value.length; index++) {
+    const value = attribute.value[index];
+    const scaledValue = maximum ? value / maximum * 255 : value <= 1 ? value * 255 : value;
+    if (!Number.isFinite(scaledValue) || scaledValue < 0 || scaledValue > 255) {
+      throw new TileConversionError(
+        "POINT_CLOUD_COLOR_VALUE_INVALID",
+        "Point cloud color components must be finite values from 0 through 255"
+      );
+    }
+    colors[index] = Math.round(scaledValue);
+  }
+  return { type: 5121, value: colors, size: attribute.size, normalized: false };
+}
+function getIntegerColorMaximum(values) {
+  if (values instanceof Uint8Array || values instanceof Uint8ClampedArray) {
+    return 255;
+  }
+  if (values instanceof Uint16Array) {
+    return 65535;
+  }
+  if (values instanceof Uint32Array) {
+    return 4294967295;
+  }
+  return null;
+}
+function getNormalAttribute(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 3 || attribute.value.length !== pointCount * 3) {
+    throw new TileConversionError(
+      "POINT_CLOUD_NORMAL_COUNT_MISMATCH",
+      "Point cloud normals must contain one xyz triple per position"
+    );
+  }
+  return { type: 5126, value: Float32Array.from(attribute.value), size: 3 };
+}
+function getBatchIds(attribute, pointCount) {
+  if (!attribute) {
+    return null;
+  }
+  if (attribute.size !== 1 || attribute.value.length !== pointCount) {
+    throw new TileConversionError(
+      "POINT_CLOUD_BATCH_ID_COUNT_MISMATCH",
+      "Point cloud BATCH_ID must contain one value per position"
+    );
+  }
+  const batchIds = new Uint16Array(pointCount);
+  for (let index = 0; index < pointCount; index++) {
+    const batchId = attribute.value[index];
+    if (!Number.isInteger(batchId) || batchId < 0 || batchId > 65535) {
+      throw new TileConversionError(
+        "POINT_CLOUD_BATCH_ID_OUT_OF_RANGE",
+        "Point cloud BATCH_ID values must be unsigned 16-bit integers"
+      );
+    }
+    batchIds[index] = batchId;
+  }
+  return batchIds;
+}
+function validateBatchTable(batchTableJson, batchIds) {
+  if (!batchTableJson) {
+    if (batchIds) {
+      throw new TileConversionError(
+        "POINT_CLOUD_BATCH_TABLE_REQUIRED",
+        "BATCH_ID values require matching batchTableJson properties"
+      );
+    }
+    return void 0;
+  }
+  if (!batchIds) {
+    throw new TileConversionError(
+      "POINT_CLOUD_BATCH_ID_REQUIRED",
+      "batchTableJson requires a BATCH_ID attribute"
+    );
+  }
+  let batchLength = 0;
+  for (const batchId of batchIds) {
+    batchLength = Math.max(batchLength, batchId + 1);
+  }
+  const normalizedBatchTable = {};
+  for (const [name, values] of Object.entries(batchTableJson)) {
+    if (values.length !== batchLength) {
+      throw new TileConversionError(
+        "POINT_CLOUD_BATCH_TABLE_LENGTH_MISMATCH",
+        `Batch table property "${name}" must contain ${batchLength} values`
+      );
+    }
+    normalizedBatchTable[name] = [...values];
+  }
+  return normalizedBatchTable;
+}
+
+// src/v5/point-cloud-source.ts
+async function* traversePointCloudSource(source, options = {}) {
+  const { maxDepth = Number.POSITIVE_INFINITY, signal } = options;
+  if (maxDepth !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxDepth) || maxDepth < 0)) {
+    throw new RangeError("Point-cloud source maxDepth must be a non-negative integer");
+  }
+  throwIfAborted3(signal);
+  if (!source.isReady) {
+    await source.initialize();
+  }
+  throwIfAborted3(signal);
+  const root = await source.getRootTile();
+  const pendingTiles = [root];
+  const visitedTileIds = /* @__PURE__ */ new Set();
+  while (pendingTiles.length > 0) {
+    throwIfAborted3(signal);
+    const header = pendingTiles.pop();
+    if (visitedTileIds.has(header.id)) {
+      continue;
+    }
+    visitedTileIds.add(header.id);
+    const content = await source.loadTileContent(header);
+    throwIfAborted3(signal);
+    yield { header, content };
+    throwIfAborted3(signal);
+    if (header.level >= maxDepth) {
+      continue;
+    }
+    const children = await source.getChildren(header);
+    throwIfAborted3(signal);
+    for (let index = children.length - 1; index >= 0; index--) {
+      pendingTiles.push(children[index]);
+    }
+  }
+}
+function throwIfAborted3(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/point-cloud-source-encoder.ts
+async function* encodePointCloudSource(source, options = {}) {
+  for await (const sourceTile of traversePointCloudSource(source, options)) {
+    const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
+    const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
+    if (encodedTile) {
+      yield encodedTile;
+    }
+  }
+}
+function encodePointCloudSourceTile(sourceTile, options = {}) {
+  const { header, content } = sourceTile;
+  if (!content) {
+    return null;
+  }
+  return {
+    id: header.id,
+    header,
+    pnts: encodePointCloudTile(content.data, {
+      ...options,
+      constantRGBA: options.constantRGBA ?? content.constantRGBA
+    }),
+    pointCount: content.pointCount,
+    coordinateSystem: content.coordinateSystem,
+    cartographicOrigin: [...content.cartographicOrigin],
+    modelMatrix: content.modelMatrix ? Array.from(content.modelMatrix) : void 0,
+    spatialReference: content.spatialReference,
+    spatialBoundingVolume: content.spatialBoundingVolume || header.spatialBoundingVolume
+  };
+}
+
+// src/v5/point-cloud-conversion.ts
+function convertPointCloudSource(source, options) {
+  return convertTileset({
+    source: {
+      async inspect() {
+        if (!source.isReady) {
+          await source.initialize();
+        }
+      },
+      read: (_inspection, signal) => traversePointCloudSource(source, { maxDepth: options.maxDepth, signal })
+    },
+    codec: {
+      async *convert(sourceTile) {
+        const encodingOptions = sourceTile.content ? options.getTileEncodingOptions?.(sourceTile) : void 0;
+        const encodedTile = encodePointCloudSourceTile(sourceTile, encodingOptions);
+        if (encodedTile) {
+          yield encodedTile;
+        }
+      }
+    },
+    sink: options.sink,
+    measureInputBytes: options.measureInputBytes,
+    measureOutputBytes: (resource) => resource.pnts.byteLength,
+    maxInputResourceBytes: options.maxInputResourceBytes,
+    maxOutputResourceBytes: options.maxOutputResourceBytes,
+    signal: options.signal,
+    onProgress: options.onProgress
+  });
+}
+
+// src/v5/resource-manifest.ts
+var TILE_RESOURCE_MANIFEST_VERSION = 1;
+async function createManifestBackedTileConversionSink(options) {
+  const priorManifest = await options.manifestStore.load();
+  const resources = /* @__PURE__ */ new Map();
+  if (priorManifest) {
+    validateManifest(priorManifest);
+    for (const entry of priorManifest.resources) {
+      resources.set(entry.resourceId, entry);
+    }
+  }
+  let writeChain = Promise.resolve();
+  let writeFailed = false;
+  let writeFailure;
+  let closed = false;
+  const persistManifest = async (complete, report) => {
+    await options.manifestStore.save({
+      version: TILE_RESOURCE_MANIFEST_VERSION,
+      complete,
+      resources: [...resources.values()].sort(
+        (left, right) => left.resourceId < right.resourceId ? -1 : left.resourceId > right.resourceId ? 1 : 0
+      ),
+      ...report ? { report } : {}
+    });
+  };
+  const writeResource = async (resource, signal) => {
+    if (closed) {
+      throw new TileConversionError("RESOURCE_SINK_CLOSED", "Cannot write after sink finalization");
+    }
+    if (writeFailed) {
+      throw writeFailure;
+    }
+    const entry = createManifestEntry(options, resource);
+    const priorEntry = resources.get(entry.resourceId);
+    if (priorEntry) {
+      if (priorEntry.byteLength !== entry.byteLength || priorEntry.fingerprint !== entry.fingerprint) {
+        throw new TileConversionError(
+          "RESOURCE_RESUME_MISMATCH",
+          `Resource "${entry.resourceId}" changed since the saved manifest`
+        );
+      }
+      return;
+    }
+    await options.sink.write(resource, signal);
+    resources.set(entry.resourceId, entry);
+    await persistManifest(false);
+  };
+  return {
+    write(resource, signal) {
+      const operation = writeChain.then(() => writeResource(resource, signal));
+      writeChain = operation.catch((error) => {
+        writeFailed = true;
+        writeFailure = error;
+      });
+      return operation;
+    },
+    async finalize(report) {
+      await writeChain;
+      if (writeFailed) {
+        throw writeFailure;
+      }
+      if (closed) {
+        throw new TileConversionError("RESOURCE_SINK_CLOSED", "Sink has already been finalized");
+      }
+      await options.sink.finalize(report);
+      await persistManifest(true, report);
+      closed = true;
+    },
+    async abort(reason) {
+      await writeChain;
+      if (closed) return;
+      closed = true;
+      resources.clear();
+      await persistManifest(false);
+      await options.sink.abort(reason);
+    }
+  };
+}
+function createManifestEntry(options, resource) {
+  const resourceId = options.getResourceId(resource);
+  const byteLength = options.measureResourceBytes(resource);
+  const fingerprint = options.fingerprintResource(resource);
+  if (typeof resourceId !== "string" || resourceId.length === 0 || typeof fingerprint !== "string" || fingerprint.length === 0 || !Number.isSafeInteger(byteLength) || byteLength < 0) {
+    throw new TileConversionError(
+      "INVALID_RESOURCE_MANIFEST_ENTRY",
+      "Resource manifest entries require an ID, a fingerprint, and a non-negative safe byte length"
+    );
+  }
+  return { resourceId, byteLength, fingerprint };
+}
+function validateManifest(manifest) {
+  if (typeof manifest !== "object" || manifest === null || manifest.version !== TILE_RESOURCE_MANIFEST_VERSION || typeof manifest.complete !== "boolean" || !Array.isArray(manifest.resources)) {
+    throw new TileConversionError(
+      "UNSUPPORTED_RESOURCE_MANIFEST",
+      `Unsupported or malformed resource manifest version: ${String(manifest.version)}`
+    );
+  }
+  const resourceIds = /* @__PURE__ */ new Set();
+  for (const entry of manifest.resources) {
+    if (typeof entry?.resourceId !== "string" || entry.resourceId.length === 0 || typeof entry?.fingerprint !== "string" || entry.fingerprint.length === 0 || !Number.isSafeInteger(entry.byteLength) || entry.byteLength < 0 || resourceIds.has(entry.resourceId)) {
+      throw new TileConversionError(
+        "INVALID_RESOURCE_MANIFEST",
+        "Resource manifest contains an invalid or duplicate entry"
+      );
+    }
+    resourceIds.add(entry.resourceId);
+  }
+}
+export {
+  TileConversionError,
+  convertFeatureAttributesToArrowBatches,
+  convertPointCloudSource,
+  convertTileset,
+  createI3SConversionSpatialContext,
+  createManifestBackedTileConversionSink,
+  createTiles3DConversionSpatialContext,
+  createTilesetConversionSource,
+  encodePointCloudSource,
+  encodePointCloudSourceTile,
+  encodePointCloudTile,
+  inspectTileset,
+  traversePointCloudSource,
+  validateTileset
+};