@math.gl/geospatial 5.0.0-alpha.9 → 5.0.0-beta.1

package/dist/terrain/index.cjs

@@ -0,0 +1,3099 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/terrain/index.js
+var index_exports = {};
+__export(index_exports, {
+  GeographicHeightField: () => GeographicHeightField,
+  HeightField: () => HeightField,
+  HeightFieldGeometry: () => HeightFieldGeometry,
+  HeightFieldMinMax: () => HeightFieldMinMax,
+  TERRAIN_BUFFER_VERSION: () => TERRAIN_BUFFER_VERSION,
+  TerrainSampleStatus: () => TerrainSampleStatus,
+  TerrainSurface: () => TerrainSurface,
+  TiledHeightField: () => TiledHeightField,
+  createDelatinTerrainMesh: () => createDelatinTerrainMesh,
+  createMartiniTerrainMesh: () => createMartiniTerrainMesh,
+  createTerrainContours: () => createTerrainContours,
+  createTerrainGradientGrid: () => createTerrainGradientGrid,
+  createTerrainMesh: () => createTerrainMesh,
+  createTerrainSkirt: () => createTerrainSkirt,
+  createTerrainSlopeAspectGrid: () => createTerrainSlopeAspectGrid,
+  createTerrainSurface: () => createTerrainSurface,
+  getTerrainMeshEdge: () => getTerrainMeshEdge,
+  getTerrainSlopeAspect: () => getTerrainSlopeAspect,
+  measureTerrainMeshError: () => measureTerrainMeshError,
+  measureTerrainProfile: () => measureTerrainProfile,
+  packTerrainHeightField: () => packTerrainHeightField,
+  reconcileTerrainVertexTiles: () => reconcileTerrainVertexTiles,
+  sampleTerrainProfile: () => sampleTerrainProfile,
+  simplifyTerrainContourPaths: () => simplifyTerrainContourPaths,
+  stitchTerrainContours: () => stitchTerrainContours,
+  stitchTerrainMeshEdges: () => stitchTerrainMeshEdges,
+  unpackTerrainHeightField: () => unpackTerrainHeightField
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/terrain/types.js
+var TerrainSampleStatus = {
+  VALID: 0,
+  OUTSIDE_DOMAIN: 1,
+  NO_DATA: 2,
+  INVALID_INPUT: 3,
+  NUMERIC_ERROR: 4,
+  UNAVAILABLE: 5,
+  NOT_RESIDENT: 6
+};
+
+// dist/terrain/height-field.js
+var HeightField = class {
+  constructor(props) {
+    this.batchSample = createSample();
+    const { width, height, heights, validity, offset = 0, stride = width } = props;
+    if (!Number.isSafeInteger(width) || width < 2 || !Number.isSafeInteger(height) || height < 2) {
+      throw new Error("HeightField width and height must be integers >= 2");
+    }
+    if (!isTerrainArray(heights) || validity !== void 0 && !(validity instanceof Uint8Array)) {
+      throw new Error("HeightField requires Float32/Float64 heights and an optional Uint8 validity mask");
+    }
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(stride) || stride < width) {
+      throw new Error("HeightField offset must be nonnegative and stride must be >= width");
+    }
+    const end = offset + (height - 1) * stride + width;
+    if (!Number.isSafeInteger(end) || end > heights.length || validity && end > validity.length) {
+      throw new Error("HeightField input buffers are too small");
+    }
+    this.width = width;
+    this.height = height;
+    this.origin = copyVector(props.origin ?? [0, 0]);
+    this.columnStep = copyVector(props.columnStep ?? [1, 0]);
+    this.rowStep = copyVector(props.rowStep ?? [0, 1]);
+    this.registration = props.registration ?? "vertex";
+    this.diagonal = props.diagonal ?? "00-11";
+    this.heightReference = props.heightReference ?? "unknown";
+    if (this.registration !== "vertex" && this.registration !== "cell") {
+      throw new Error("HeightField registration must be vertex or cell");
+    }
+    if (this.diagonal !== "00-11" && this.diagonal !== "10-01") {
+      throw new Error("HeightField diagonal must be 00-11 or 10-01");
+    }
+    if (typeof this.heightReference !== "string") {
+      throw new Error("HeightField heightReference must be a string");
+    }
+    const [a, c] = this.columnStep;
+    const [b, d] = this.rowStep;
+    const determinant = a * d - b * c;
+    const scale = Math.hypot(a, c) * Math.hypot(b, d);
+    if (!Number.isFinite(determinant) || Math.abs(determinant) <= Number.EPSILON * scale) {
+      throw new Error("HeightField grid transform must be finite and nonsingular");
+    }
+    this.inverse = [d / determinant, -b / determinant, -c / determinant, a / determinant];
+    if (!this.inverse.every(Number.isFinite)) {
+      throw new Error("HeightField inverse transform must be finite");
+    }
+    this.heights = heights instanceof Float64Array ? new Float64Array(width * height) : new Float32Array(width * height);
+    this.validity = new Uint8Array(width * height);
+    let min = Infinity;
+    let max = -Infinity;
+    let validCount = 0;
+    for (let row = 0; row < height; row++) {
+      for (let column = 0; column < width; column++) {
+        const input = offset + row * stride + column;
+        const output = row * width + column;
+        const value = heights[input];
+        if (Number.isFinite(value) && (!validity || validity[input] !== 0)) {
+          this.heights[output] = value;
+          this.validity[output] = 1;
+          min = Math.min(min, value);
+          max = Math.max(max, value);
+          validCount++;
+        }
+      }
+    }
+    this.validCount = validCount;
+    this.heightRange = validCount ? Object.freeze([min, max]) : void 0;
+  }
+  /** Reads an original grid sample, independently of interpolation footprints. */
+  getHeight(column, row) {
+    if (!Number.isInteger(column) || !Number.isInteger(row) || column < 0 || row < 0 || column >= this.width || row >= this.height)
+      return void 0;
+    const index = row * this.width + column;
+    return this.validity[index] ? this.heights[index] : void 0;
+  }
+  /** Independent, tightly packed copies, suitable for worker transfer or GPU preparation. */
+  copyData() {
+    return { heights: this.heights.slice(), validity: this.validity.slice() };
+  }
+  /** Samples world XY in meters. Supply result to avoid allocating a result object. */
+  sample(x, y, options, result = createSample()) {
+    resetSample(result, TerrainSampleStatus.INVALID_INPUT);
+    const interpolation = (options == null ? void 0 : options.interpolation) ?? "bilinear";
+    if (interpolation !== "nearest" && interpolation !== "bilinear" && interpolation !== "triangle") {
+      throw new Error("Unknown terrain interpolation");
+    }
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+      return result;
+    const dx = x - this.origin[0];
+    const dy = y - this.origin[1];
+    const offset = this.registration === "cell" ? 0.5 : 0;
+    let u = this.inverse[0] * dx + this.inverse[1] * dy - offset;
+    let v = this.inverse[2] * dx + this.inverse[3] * dy - offset;
+    if (!Number.isFinite(u) || !Number.isFinite(v))
+      return resetSample(result, TerrainSampleStatus.NUMERIC_ERROR);
+    const tolerance = 8 * Number.EPSILON * Math.max(this.width, this.height);
+    const errorX = 4 * Number.EPSILON * Math.abs(x) + 4 * Number.EPSILON * Math.abs(this.origin[0]);
+    const errorY = 4 * Number.EPSILON * Math.abs(y) + 4 * Number.EPSILON * Math.abs(this.origin[1]);
+    const toleranceU = tolerance + Math.abs(this.inverse[0]) * errorX + Math.abs(this.inverse[1]) * errorY;
+    const toleranceV = tolerance + Math.abs(this.inverse[2]) * errorX + Math.abs(this.inverse[3]) * errorY;
+    if (u < -toleranceU || v < -toleranceV || u > this.width - 1 + toleranceU || v > this.height - 1 + toleranceV) {
+      return resetSample(result, TerrainSampleStatus.OUTSIDE_DOMAIN);
+    }
+    u = Math.max(0, Math.min(this.width - 1, u));
+    v = Math.max(0, Math.min(this.height - 1, v));
+    if (interpolation === "nearest") {
+      const value = this.getHeight(Math.floor(u + 0.5), Math.floor(v + 0.5));
+      if (value === void 0)
+        return resetSample(result, TerrainSampleStatus.NO_DATA);
+      result.status = TerrainSampleStatus.VALID;
+      result.height = value;
+      result.gradientStatus = TerrainSampleStatus.UNAVAILABLE;
+      return result;
+    }
+    const column = Math.min(Math.floor(u), this.width - 2);
+    const row = Math.min(Math.floor(v), this.height - 2);
+    u -= column;
+    v -= row;
+    const a = row * this.width + column;
+    const b = a + 1;
+    const c = a + this.width;
+    const d = c + 1;
+    const za = this.heights[a];
+    const zb = this.heights[b];
+    const zc = this.heights[c];
+    const zd = this.heights[d];
+    let du;
+    let dv;
+    if (interpolation === "bilinear") {
+      if (!this.validity[a] || !this.validity[b] || !this.validity[c] || !this.validity[d]) {
+        return resetSample(result, TerrainSampleStatus.NO_DATA);
+      }
+      result.height = (1 - v) * ((1 - u) * za + u * zb) + v * ((1 - u) * zc + u * zd);
+      du = (1 - v) * (zb - za) + v * (zd - zc);
+      dv = (1 - u) * (zc - za) + u * (zd - zb);
+    } else if (this.diagonal === "00-11" ? v <= u : u + v <= 1) {
+      const last = this.diagonal === "00-11" ? d : c;
+      if (!this.validity[a] || !this.validity[b] || !this.validity[last]) {
+        return resetSample(result, TerrainSampleStatus.NO_DATA);
+      }
+      du = zb - za;
+      dv = this.diagonal === "00-11" ? zd - zb : zc - za;
+      result.height = this.diagonal === "00-11" ? (1 - u) * za + (u - v) * zb + v * zd : (1 - u - v) * za + u * zb + v * zc;
+    } else {
+      const first = this.diagonal === "00-11" ? a : b;
+      if (!this.validity[first] || !this.validity[c] || !this.validity[d]) {
+        return resetSample(result, TerrainSampleStatus.NO_DATA);
+      }
+      du = zd - zc;
+      dv = this.diagonal === "00-11" ? zc - za : zd - zb;
+      result.height = this.diagonal === "00-11" ? (1 - v) * za + u * zd + (v - u) * zc : (1 - v) * zb + (1 - u) * zc + (u + v - 1) * zd;
+    }
+    if (!Number.isFinite(result.height))
+      return resetSample(result, TerrainSampleStatus.NUMERIC_ERROR);
+    result.status = TerrainSampleStatus.VALID;
+    const gx = du * this.inverse[0] + dv * this.inverse[2];
+    const gy = du * this.inverse[1] + dv * this.inverse[3];
+    if (!Number.isFinite(gx) || !Number.isFinite(gy)) {
+      result.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+      return result;
+    }
+    const normalScale = Math.max(Math.abs(gx), Math.abs(gy), 1);
+    const nx = -gx / normalScale;
+    const ny = -gy / normalScale;
+    const nz = 1 / normalScale;
+    const length = Math.hypot(nx, ny, nz);
+    result.gradientStatus = TerrainSampleStatus.VALID;
+    result.gradientX = gx;
+    result.gradientY = gy;
+    result.normalX = nx / length;
+    result.normalY = ny / length;
+    result.normalZ = nz / length;
+    return result;
+  }
+  /** Interleaved XY inputs and caller-owned outputs, with no per-sample allocation. */
+  sampleBatch(positions, output, options) {
+    validateBatch(positions, output);
+    for (let i = 0; i < positions.length / 2; i++) {
+      const sample = this.sample(positions[2 * i], positions[2 * i + 1], options, this.batchSample);
+      output.heights[i] = sample.height;
+      if (!Number.isFinite(output.heights[i])) {
+        resetSample(sample, TerrainSampleStatus.NUMERIC_ERROR);
+        output.heights[i] = 0;
+      }
+      if (output.gradients) {
+        output.gradients[2 * i] = sample.gradientX;
+        output.gradients[2 * i + 1] = sample.gradientY;
+        if (!Number.isFinite(output.gradients[2 * i]) || !Number.isFinite(output.gradients[2 * i + 1])) {
+          output.gradients[2 * i] = output.gradients[2 * i + 1] = 0;
+          sample.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+          sample.normalX = sample.normalY = sample.normalZ = 0;
+        }
+      }
+      if (output.normals) {
+        output.normals[3 * i] = sample.normalX;
+        output.normals[3 * i + 1] = sample.normalY;
+        output.normals[3 * i + 2] = sample.normalZ;
+      }
+      output.statuses[i] = sample.status;
+      if (output.gradientStatuses)
+        output.gradientStatuses[i] = sample.gradientStatus;
+    }
+    return output;
+  }
+};
+function copyVector(value) {
+  if (value.length !== 2 || !value.every(Number.isFinite))
+    throw new Error("Grid vectors must be finite XY pairs");
+  return Object.freeze([value[0], value[1]]);
+}
+function createSample() {
+  return {
+    status: TerrainSampleStatus.NO_DATA,
+    height: 0,
+    gradientStatus: TerrainSampleStatus.NO_DATA,
+    gradientX: 0,
+    gradientY: 0,
+    normalX: 0,
+    normalY: 0,
+    normalZ: 0
+  };
+}
+function resetSample(result, status) {
+  result.status = status;
+  result.gradientStatus = status;
+  result.height = result.gradientX = result.gradientY = result.normalX = result.normalY = result.normalZ = 0;
+  return result;
+}
+function isTerrainArray(value) {
+  return value instanceof Float32Array || value instanceof Float64Array;
+}
+function validateBatch(positions, output) {
+  if (!isTerrainArray(positions) || positions.length % 2 !== 0) {
+    throw new Error("Terrain batch positions must contain Float32/Float64 XY pairs");
+  }
+  const count = positions.length / 2;
+  const buffers = [positions];
+  for (const [key, size] of [
+    ["heights", 1],
+    ["statuses", 1],
+    ["gradients", 2],
+    ["normals", 3],
+    ["gradientStatuses", 1]
+  ]) {
+    const buffer = output[key];
+    if (buffer === void 0 && key !== "heights" && key !== "statuses")
+      continue;
+    const byte = key === "statuses" || key === "gradientStatuses";
+    if ((byte ? !(buffer instanceof Uint8Array) : !isTerrainArray(buffer)) || buffer.length < count * size) {
+      throw new Error(`Terrain batch ${key} has an invalid type or insufficient length`);
+    }
+    for (const other of buffers) {
+      if (buffer.buffer === other.buffer && buffer.byteOffset < other.byteOffset + other.byteLength && other.byteOffset < buffer.byteOffset + buffer.byteLength) {
+        throw new Error("Terrain batch input and output buffers must not overlap");
+      }
+    }
+    buffers.push(buffer);
+  }
+  if ((output.gradients || output.normals) && !output.gradientStatuses) {
+    throw new Error("Terrain batch derivatives require gradientStatuses");
+  }
+}
+
+// dist/terrain/mesh-skirts.js
+function createTerrainSkirt(mesh, options) {
+  const { positions, indices } = mesh, { height, edges } = options;
+  const maxVertices = options.maxVertices ?? 2e6, maxTriangles = options.maxTriangles ?? 4e6;
+  if (!Number.isFinite(height) || height <= 0 || !Number.isSafeInteger(maxVertices) || maxVertices < 0 || maxVertices > 4294967295 || !Number.isSafeInteger(maxTriangles) || maxTriangles < 0 || maxTriangles > 4294967295)
+    throw new Error("Invalid terrain skirt height or capacity");
+  if (!(positions instanceof Float32Array || positions instanceof Float64Array) || positions.length < 3 || positions.length % 3 || !positions.every(Number.isFinite) || !(indices instanceof Uint16Array || indices instanceof Uint32Array) || indices.length % 3 || positions.length / 3 > maxVertices || indices.length / 3 > maxTriangles)
+    throw new Error("Invalid terrain skirt mesh or capacity");
+  if (edges !== void 0 && (!(edges instanceof Uint16Array || edges instanceof Uint32Array) || edges.length % 2))
+    throw new Error("Invalid terrain skirt edge pairs");
+  const vertexCount = positions.length / 3, triangleCount = indices.length / 3;
+  const boundary = /* @__PURE__ */ new Map();
+  for (let i = 0; i < indices.length; i += 3) {
+    const ids = [indices[i], indices[i + 1], indices[i + 2]];
+    if (ids.some((id) => id >= vertexCount))
+      throw new Error("Terrain skirt index out of range");
+    const [a, b, c] = ids.map((id) => id * 3);
+    const area = (positions[b] - positions[a]) * (positions[c + 1] - positions[a + 1]) - (positions[b + 1] - positions[a + 1]) * (positions[c] - positions[a]);
+    if (!Number.isFinite(area) || area <= 0)
+      throw new Error("Terrain skirt requires upward nondegenerate XY triangles");
+    for (let j = 0; j < 3; j++) {
+      const u = ids[j], v = ids[(j + 1) % 3], key = edgeKey(u, v), prior = boundary.get(key);
+      if (!prior)
+        boundary.set(key, { a: u, b: v, count: 1 });
+      else {
+        if (prior.count !== 1 || prior.a !== v || prior.b !== u)
+          throw new Error("Terrain skirt mesh has nonmanifold or inconsistent edges");
+        prior.count++;
+      }
+    }
+  }
+  let selected;
+  if (edges) {
+    selected = [];
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < edges.length; i += 2) {
+      const key = edgeKey(edges[i], edges[i + 1]), edge = boundary.get(key);
+      if (!edge || edge.count !== 1 || used.has(key))
+        throw new Error("Terrain skirt selection must contain unique boundary edges");
+      used.add(key);
+      selected.push(edge);
+    }
+  } else
+    selected = [...boundary.values()].filter((edge) => edge.count === 1);
+  const outputVertices = vertexCount + selected.length * 2, outputTriangles = triangleCount + selected.length * 2;
+  if (!Number.isSafeInteger(outputVertices) || outputVertices > maxVertices || outputVertices > 4294967295 || !Number.isSafeInteger(outputTriangles) || outputTriangles > maxTriangles)
+    throw new Error("Terrain skirt output capacity exceeded");
+  const resultPositions = positions instanceof Float32Array ? new Float32Array(outputVertices * 3) : new Float64Array(outputVertices * 3);
+  resultPositions.set(positions);
+  const resultIndices = indices instanceof Uint16Array && outputVertices <= 65536 ? new Uint16Array(outputTriangles * 3) : new Uint32Array(outputTriangles * 3);
+  resultIndices.set(indices);
+  const sourceVertexIndices = new Uint32Array(selected.length * 2), triangleValidity = new Uint8Array(outputTriangles);
+  triangleValidity.fill(1, 0, triangleCount);
+  for (let i = 0; i < selected.length; i++) {
+    const { a, b } = selected[i], lowerA = vertexCount + 2 * i, lowerB = lowerA + 1;
+    for (const [source, target] of [
+      [a, lowerA],
+      [b, lowerB]
+    ]) {
+      resultPositions.set(positions.subarray(3 * source, 3 * source + 3), 3 * target);
+      resultPositions[3 * target + 2] = positions[3 * source + 2] - height;
+      if (!Number.isFinite(resultPositions[3 * target + 2]) || resultPositions[3 * target + 2] >= positions[3 * source + 2])
+        throw new Error("Terrain skirt height cannot be represented in position precision");
+      sourceVertexIndices[target - vertexCount] = source;
+    }
+    resultIndices.set([a, lowerB, b, lowerB, a, lowerA], indices.length + i * 6);
+  }
+  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < resultPositions.length; i++) {
+    const axis = i % 3;
+    min[axis] = Math.min(min[axis], resultPositions[i]);
+    max[axis] = Math.max(max[axis], resultPositions[i]);
+  }
+  return {
+    positions: resultPositions,
+    indices: resultIndices,
+    sourceVertexIndices,
+    skirtVertexOffset: vertexCount,
+    skirtTriangleOffset: triangleCount,
+    triangleValidity,
+    bounds: [min, max]
+  };
+}
+function edgeKey(a, b) {
+  return a < b ? `${a},${b}` : `${b},${a}`;
+}
+
+// dist/terrain/geometry.js
+var import_geometry = require("@math.gl/geometry");
+var HeightFieldGeometry = class extends import_geometry.Geometry {
+  constructor(field, options = {}) {
+    const origin = options.origin ?? [field.origin[0], field.origin[1], 0];
+    if (origin.length !== 3 || !origin.every(Number.isFinite))
+      throw new Error("Mesh origin must be a finite XYZ triple");
+    const precision = options.precision ?? "float32";
+    if (precision !== "float32" && precision !== "float64")
+      throw new Error("Unknown terrain mesh precision");
+    const count = field.width * field.height;
+    const positions = precision === "float64" ? new Float64Array(count * 3) : new Float32Array(count * 3);
+    const normals = new Float32Array(count * 3);
+    const accumulatedNormals = new Float64Array(count * 3);
+    const uv = new Float32Array(count * 2);
+    const valid = new Uint8Array(count);
+    const indices = count > 65535 ? new Uint32Array((field.width - 1) * (field.height - 1) * 6) : new Uint16Array((field.width - 1) * (field.height - 1) * 6);
+    const shift = field.registration === "cell" ? 0.5 : 0;
+    for (let row = 0; row < field.height; row++) {
+      for (let column = 0; column < field.width; column++) {
+        const i = row * field.width + column;
+        const height = field.getHeight(column, row);
+        valid[i] = height === void 0 ? 0 : 1;
+        positions[3 * i] = field.origin[0] - origin[0] + (column + shift) * field.columnStep[0] + (row + shift) * field.rowStep[0];
+        positions[3 * i + 1] = field.origin[1] - origin[1] + (column + shift) * field.columnStep[1] + (row + shift) * field.rowStep[1];
+        positions[3 * i + 2] = height === void 0 ? 0 : height - origin[2];
+        uv[2 * i] = (column + shift) / (field.registration === "cell" ? field.width : field.width - 1);
+        uv[2 * i + 1] = (row + shift) / (field.registration === "cell" ? field.height : field.height - 1);
+      }
+    }
+    if (!positions.every(Number.isFinite))
+      throw new Error("Terrain mesh positions overflow the selected precision");
+    const reverse = field.columnStep[0] * field.rowStep[1] - field.columnStep[1] * field.rowStep[0] < 0;
+    let indexCount = 0;
+    const addTriangle = (a, b, c) => {
+      if (!valid[a] || !valid[b] || !valid[c])
+        return;
+      if (reverse)
+        [b, c] = [c, b];
+      indices[indexCount++] = a;
+      indices[indexCount++] = b;
+      indices[indexCount++] = c;
+      const abx = positions[3 * b] - positions[3 * a];
+      const aby = positions[3 * b + 1] - positions[3 * a + 1];
+      const abz = positions[3 * b + 2] - positions[3 * a + 2];
+      const acx = positions[3 * c] - positions[3 * a];
+      const acy = positions[3 * c + 1] - positions[3 * a + 1];
+      const acz = positions[3 * c + 2] - positions[3 * a + 2];
+      const nx = aby * acz - abz * acy;
+      const ny = abz * acx - abx * acz;
+      const nz = abx * acy - aby * acx;
+      if (!Number.isFinite(nx) || !Number.isFinite(ny) || !Number.isFinite(nz) || nz <= 0) {
+        throw new Error("Terrain triangle degenerates or overflows at the selected precision; use a local origin");
+      }
+      for (const i of [a, b, c]) {
+        accumulatedNormals[3 * i] += nx;
+        accumulatedNormals[3 * i + 1] += ny;
+        accumulatedNormals[3 * i + 2] += nz;
+      }
+    };
+    for (let row = 0; row < field.height - 1; row++) {
+      for (let column = 0; column < field.width - 1; column++) {
+        const a = row * field.width + column;
+        const b = a + 1;
+        const c = a + field.width;
+        const d = c + 1;
+        if (field.diagonal === "00-11") {
+          addTriangle(a, b, d);
+          addTriangle(a, d, c);
+        } else {
+          addTriangle(a, b, c);
+          addTriangle(b, d, c);
+        }
+      }
+    }
+    for (let i = 0; i < count; i++) {
+      const nx = accumulatedNormals[3 * i];
+      const ny = accumulatedNormals[3 * i + 1];
+      const nz = accumulatedNormals[3 * i + 2];
+      const length = Math.hypot(nx, ny, nz);
+      if (!Number.isFinite(length))
+        throw new Error("Terrain normal accumulation overflow");
+      normals[3 * i] = length ? nx / length : 0;
+      normals[3 * i + 1] = length ? ny / length : 0;
+      normals[3 * i + 2] = length ? nz / length : 1;
+    }
+    super({
+      id: options.id,
+      topology: "triangle-list",
+      indices: indexCount === indices.length ? indices : indices.slice(0, indexCount),
+      attributes: {
+        POSITION: { size: 3, value: positions },
+        NORMAL: { size: 3, value: normals },
+        TEXCOORD_0: { size: 2, value: uv }
+      }
+    });
+    this.origin = Object.freeze([...origin]);
+  }
+};
+
+// dist/terrain/geographic.js
+var RADIANS = Math.PI / 180;
+var RADIUS = 6378137;
+var ECCENTRICITY_SQUARED = 0.0066943799901413165;
+var MAX_MERCATOR_LATITUDE = Math.atan(Math.sinh(Math.PI)) / RADIANS;
+var GeographicHeightField = class {
+  constructor(props) {
+    const { bounds } = props;
+    this.projection = props.projection ?? "geographic";
+    this.heightReference = props.heightReference ?? "unknown";
+    const limit = this.projection === "web-mercator" ? MAX_MERCATOR_LATITUDE : 90;
+    if (bounds.length !== 4 || !bounds.every(Number.isFinite) || bounds[2] <= bounds[0] || bounds[2] - bounds[0] > 360 || bounds[3] <= bounds[1] || bounds[1] < -limit || bounds[3] > limit || this.projection === "geographic" && (bounds[1] === -90 || bounds[3] === 90)) {
+      throw new Error("Terrain bounds must be increasing, span at most 360 degrees and exclude the projection limits");
+    }
+    if (this.projection !== "geographic" && this.projection !== "web-mercator")
+      throw new Error("Unknown terrain projection");
+    const direction = props.rowDirection ?? "north-to-south";
+    if (direction !== "north-to-south" && direction !== "south-to-north")
+      throw new Error("Unknown terrain row direction");
+    this.bounds = Object.freeze([...bounds]);
+    const west = this.projectX(bounds[0]);
+    const east = this.projectX(bounds[2]);
+    const south = this.projectY(bounds[1]);
+    const north = this.projectY(bounds[3]);
+    const cell = props.registration === "cell";
+    const descending = direction === "north-to-south";
+    this.field = new HeightField({
+      ...props,
+      origin: [west, descending ? north : south],
+      columnStep: [(east - west) / (props.width - (cell ? 0 : 1)), 0],
+      rowStep: [0, (descending ? south - north : north - south) / (props.height - (cell ? 0 : 1))]
+    });
+  }
+  /** Longitude must use the bounds' unwrapped interval; no implicit wrapping or clamping. */
+  sample(longitude, latitude, options, result) {
+    const valid = Number.isFinite(longitude) && Number.isFinite(latitude);
+    const inside = valid && longitude >= this.bounds[0] && longitude <= this.bounds[2] && latitude >= this.bounds[1] && latitude <= this.bounds[3];
+    const sample = this.field.sample(inside ? this.projectX(longitude) : NaN, inside ? this.projectY(latitude) : NaN, options, result);
+    if (!inside) {
+      sample.status = sample.gradientStatus = valid ? TerrainSampleStatus.OUTSIDE_DOMAIN : TerrainSampleStatus.INVALID_INPUT;
+      return sample;
+    }
+    if (sample.gradientStatus !== TerrainSampleStatus.VALID)
+      return sample;
+    const phi = latitude * RADIANS;
+    const denominator = 1 - ECCENTRICITY_SQUARED * Math.sin(phi) ** 2;
+    const n = RADIUS / Math.sqrt(denominator);
+    const m = RADIUS * (1 - ECCENTRICITY_SQUARED) / denominator ** 1.5;
+    const mercator = this.projection === "web-mercator";
+    const gx = sample.gradientX * (mercator ? RADIUS : 1 / RADIANS) / (n * Math.cos(phi));
+    const gy = sample.gradientY * (mercator ? RADIUS / Math.cos(phi) : 1 / RADIANS) / m;
+    if (!Number.isFinite(gx) || !Number.isFinite(gy)) {
+      sample.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+      sample.gradientX = sample.gradientY = sample.normalX = sample.normalY = sample.normalZ = 0;
+      return sample;
+    }
+    sample.gradientX = gx;
+    sample.gradientY = gy;
+    const scale = Math.max(1, Math.abs(gx), Math.abs(gy));
+    const length = Math.hypot(gx / scale, gy / scale, 1 / scale);
+    sample.normalX = -gx / scale / length;
+    sample.normalY = -gy / scale / length;
+    sample.normalZ = 1 / scale / length;
+    return sample;
+  }
+  projectX(longitude) {
+    return this.projection === "web-mercator" ? RADIUS * longitude * RADIANS : longitude;
+  }
+  projectY(latitude) {
+    return this.projection === "web-mercator" ? RADIUS * Math.asinh(Math.tan(latitude * RADIANS)) : latitude;
+  }
+};
+
+// dist/tile-matrix.js
+function validateTileMatrix(matrix) {
+  validateTileMatrixGeometry(matrix);
+}
+function validateTileMatrixGeometry(matrix) {
+  if (!matrix || typeof matrix.id !== "string" || !Array.isArray(matrix.origin) || !Array.isArray(matrix.tileSize) || !Array.isArray(matrix.matrixSize) || matrix.variableMatrixWidths !== void 0 && !Array.isArray(matrix.variableMatrixWidths) || !matrix.id || matrix.origin.length !== 2 || matrix.tileSize.length !== 2 || matrix.matrixSize.length !== 2 || !Number.isFinite(matrix.resolution) || matrix.resolution <= 0 || matrix.resolutionY !== void 0 && (!Number.isFinite(matrix.resolutionY) || matrix.resolutionY <= 0) || !matrix.origin.every(Number.isFinite) || ![...matrix.tileSize, ...matrix.matrixSize].every((value) => Number.isSafeInteger(value) && value > 0) || !["topLeft", "bottomLeft"].includes(matrix.cornerOfOrigin)) {
+    throw new RangeError("Invalid tile matrix geometry");
+  }
+  const bands = [...matrix.variableMatrixWidths ?? []];
+  if (bands.some((band) => !band))
+    throw new RangeError("Invalid variable matrix width");
+  bands.sort((first, second) => first.minTileRow - second.minTileRow);
+  let previousRow = -1;
+  for (const band of bands) {
+    if (!Number.isSafeInteger(band.coalesce) || band.coalesce <= 1 || matrix.matrixSize[0] % band.coalesce !== 0 || !Number.isSafeInteger(band.minTileRow) || !Number.isSafeInteger(band.maxTileRow) || band.minTileRow <= previousRow || band.maxTileRow < band.minTileRow || band.maxTileRow >= matrix.matrixSize[1])
+      throw new RangeError("Invalid variable matrix width");
+    previousRow = band.maxTileRow;
+  }
+  for (let axis = 0; axis < 2; axis++) {
+    const resolution = axis === 1 ? matrix.resolutionY ?? matrix.resolution : matrix.resolution;
+    const tileSpan = resolution * matrix.tileSize[axis];
+    const span = tileSpan * matrix.matrixSize[axis];
+    const direction = axis === 1 && matrix.cornerOfOrigin === "topLeft" ? -1 : 1;
+    const end = matrix.origin[axis] + direction * span;
+    if (!Number.isFinite(span) || span <= 0 || !Number.isFinite(end) || matrix.origin[axis] + direction * tileSpan === matrix.origin[axis] || end - direction * tileSpan === end) {
+      throw new RangeError("Tile matrix extent must be finite");
+    }
+  }
+  return bands;
+}
+
+// dist/terrain/tiled.js
+var TiledHeightField = class _TiledHeightField {
+  constructor(props) {
+    this.changes = Object.freeze([]);
+    this.tiles = /* @__PURE__ */ new Map();
+    this.halos = /* @__PURE__ */ new Map();
+    if (typeof props.revision !== "string")
+      throw new Error("Terrain revision must be a string");
+    this.revision = props.revision;
+    this.crs = props.matrixSet.crs;
+    this.diagonal = props.diagonal ?? "00-11";
+    if (this.diagonal !== "00-11" && this.diagonal !== "10-01")
+      throw new Error("Unknown terrain diagonal");
+    this.heightReference = props.heightReference ?? "unknown";
+    this.matrices = props.matrixSet.matrices.map((matrix) => {
+      var _a;
+      validateTileMatrix(matrix);
+      if ((_a = matrix.variableMatrixWidths) == null ? void 0 : _a.length)
+        throw new Error("Terrain does not yet support coalesced tile rows");
+      if (matrix.tileSize.some((size, axis) => size * matrix.matrixSize[axis] < 2))
+        throw new Error("Terrain matrices need at least two samples per axis");
+      return {
+        ...matrix,
+        variableMatrixWidths: matrix.variableMatrixWidths ? [] : void 0,
+        origin: [...matrix.origin],
+        tileSize: [...matrix.tileSize],
+        matrixSize: [...matrix.matrixSize]
+      };
+    });
+    if (!this.matrices.length || new Set(this.matrices.map((matrix) => matrix.id)).size !== this.matrices.length)
+      throw new Error("Terrain requires unique matrix identifiers");
+    for (const tile of props.tiles) {
+      const matrix = this.validateTileId(tile);
+      const key = tileKey(tile.matrixId, tile.column, tile.row);
+      if (this.tiles.has(key))
+        throw new Error("Duplicate terrain tile");
+      this.tiles.set(key, copyTileData(tile, matrix));
+    }
+    for (const tile of props.tiles)
+      this.buildHalo(this.getMatrix(tile.matrixId), tile.column, tile.row, props.diagonal);
+    this.changes = freezeChanges(props.tiles.map((tile) => ({
+      matrixId: tile.matrixId,
+      column: tile.column,
+      row: tile.row,
+      resident: true
+    })));
+  }
+  /** Number of resident source tiles. */
+  get tileCount() {
+    return this.tiles.size;
+  }
+  /** Halos to upload or evict relative to the preceding snapshot; initial snapshots list all tiles. */
+  get haloChanges() {
+    return this.changes;
+  }
+  /** Copy-on-write update. Only changed sources and resident one-tile neighborhoods rebuild halos.
+   * Old snapshots keep their original source buffers and halos. Map copying is O(resident tiles).
+   */
+  withTiles(update) {
+    if (typeof update.revision !== "string" || update.revision === this.revision)
+      throw new Error("Terrain updates require a different revision string");
+    const replacements = /* @__PURE__ */ new Map();
+    const touched = /* @__PURE__ */ new Map();
+    for (const tile of [...update.tiles ?? [], ...update.remove ?? []]) {
+      this.validateTileId(tile);
+      const key = tileKey(tile.matrixId, tile.column, tile.row);
+      if (touched.has(key))
+        throw new Error("Terrain update contains duplicate or conflicting tile identifiers");
+      touched.set(key, tile);
+    }
+    for (const tile of update.tiles ?? [])
+      replacements.set(tileKey(tile.matrixId, tile.column, tile.row), copyTileData(tile, this.getMatrix(tile.matrixId)));
+    const next = new _TiledHeightField({
+      matrixSet: { crs: this.crs, matrices: this.matrices },
+      tiles: [],
+      revision: update.revision,
+      diagonal: this.diagonal,
+      heightReference: this.heightReference
+    });
+    for (const [key, tile] of this.tiles)
+      next.tiles.set(key, tile);
+    for (const [key, halo] of this.halos)
+      next.halos.set(key, halo);
+    const affected = /* @__PURE__ */ new Map();
+    for (const [key, tile] of touched) {
+      if (replacements.has(key))
+        next.tiles.set(key, replacements.get(key));
+      else {
+        if (!next.tiles.delete(key))
+          continue;
+        next.halos.delete(key);
+      }
+      for (let row = tile.row - 1; row <= tile.row + 1; row++)
+        for (let column = tile.column - 1; column <= tile.column + 1; column++) {
+          affected.set(tileKey(tile.matrixId, column, row), {
+            matrixId: tile.matrixId,
+            column,
+            row,
+            resident: false
+          });
+        }
+    }
+    const changes = [];
+    for (const [key, tile] of affected) {
+      if (next.tiles.has(key)) {
+        next.buildHalo(next.getMatrix(tile.matrixId), tile.column, tile.row, this.diagonal);
+        changes.push({ ...tile, resident: true });
+      } else if (this.tiles.has(key))
+        changes.push(tile);
+    }
+    next.changes = freezeChanges(changes);
+    return next;
+  }
+  /** Independent finite halo buffers for workers or GPU upload; missing values use validity zero.
+   * Origin is the first sample center in local meters. No GPU resources are created.
+   */
+  copyTileHalo(matrixId, column, row) {
+    const matrix = this.getMatrix(matrixId);
+    const halo = this.halos.get(tileKey(matrixId, column, row));
+    if (!halo)
+      return void 0;
+    const dy = (matrix.resolutionY ?? matrix.resolution) * (matrix.cornerOfOrigin === "topLeft" ? -1 : 1);
+    return {
+      ...halo.field.copyData(),
+      width: halo.field.width,
+      height: halo.field.height,
+      origin: [
+        matrix.origin[0] + (column * matrix.tileSize[0] + halo.field.origin[0] - 0.5) * matrix.resolution,
+        matrix.origin[1] + (row * matrix.tileSize[1] + halo.field.origin[1] - 0.5) * dy
+      ],
+      columnStep: [matrix.resolution, 0],
+      rowStep: [0, dy],
+      revision: this.revision,
+      diagonal: this.diagonal,
+      registration: "vertex",
+      heightReference: this.heightReference
+    };
+  }
+  /** Queries never mix resolutions. Only absent residency permits coarser fallback. */
+  sample(x, y, options) {
+    const requested = this.getMatrix(options.matrixId);
+    if (options.fallback !== void 0 && options.fallback !== "none" && options.fallback !== "coarser")
+      throw new Error("Unknown terrain fallback");
+    const candidates = [requested];
+    if (options.fallback === "coarser")
+      candidates.push(...this.matrices.filter((matrix) => matrix.resolution >= requested.resolution && (matrix.resolutionY ?? matrix.resolution) >= (requested.resolutionY ?? requested.resolution) && (matrix.resolution > requested.resolution || (matrix.resolutionY ?? matrix.resolution) > (requested.resolutionY ?? requested.resolution))).sort((a, b) => a.resolution - b.resolution || (a.resolutionY ?? a.resolution) - (b.resolutionY ?? b.resolution) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)));
+    let result = this.sampleMatrix(requested, x, y, options);
+    for (let i = 1; result.status === TerrainSampleStatus.NOT_RESIDENT && i < candidates.length; i++) {
+      const candidate = this.sampleMatrix(candidates[i], x, y, options);
+      if (candidate.status !== TerrainSampleStatus.OUTSIDE_DOMAIN)
+        result = candidate;
+    }
+    return {
+      ...result,
+      revision: this.revision,
+      matrixId: result.matrixId,
+      fallback: result.matrixId !== requested.id
+    };
+  }
+  sampleMatrix(matrix, x, y, options) {
+    const invalid = (status) => ({
+      status,
+      gradientStatus: status,
+      height: 0,
+      gradientX: 0,
+      gradientY: 0,
+      normalX: 0,
+      normalY: 0,
+      normalZ: 0,
+      matrixId: matrix.id
+    });
+    const interpolation = options.interpolation ?? "bilinear";
+    if (!["nearest", "bilinear", "triangle"].includes(interpolation))
+      throw new Error("Unknown terrain interpolation");
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+      return invalid(TerrainSampleStatus.INVALID_INPUT);
+    const [width, height] = matrix.tileSize;
+    const dy = (matrix.resolutionY ?? matrix.resolution) * (matrix.cornerOfOrigin === "topLeft" ? -1 : 1);
+    let u = (x - matrix.origin[0]) * (1 / matrix.resolution);
+    let v = (y - matrix.origin[1]) * (1 / dy);
+    if (!Number.isFinite(u) || !Number.isFinite(v))
+      return invalid(TerrainSampleStatus.NUMERIC_ERROR);
+    const tolerance = 8 * Number.EPSILON * Math.max(width * matrix.matrixSize[0], height * matrix.matrixSize[1]);
+    const toleranceU = tolerance + (4 * Number.EPSILON * Math.abs(x) + 4 * Number.EPSILON * Math.abs(matrix.origin[0])) / matrix.resolution;
+    const toleranceV = tolerance + (4 * Number.EPSILON * Math.abs(y) + 4 * Number.EPSILON * Math.abs(matrix.origin[1])) / Math.abs(dy);
+    if (u < 0.5 - toleranceU || v < 0.5 - toleranceV || u > width * matrix.matrixSize[0] - 0.5 + toleranceU || v > height * matrix.matrixSize[1] - 0.5 + toleranceV)
+      return invalid(TerrainSampleStatus.OUTSIDE_DOMAIN);
+    u = Math.max(0.5, Math.min(width * matrix.matrixSize[0] - 0.5, u));
+    v = Math.max(0.5, Math.min(height * matrix.matrixSize[1] - 0.5, v));
+    const gridU = u - 0.5;
+    const gridV = v - 0.5;
+    const c = Math.min(Math.floor(gridU), width * matrix.matrixSize[0] - 2);
+    const r = Math.min(Math.floor(gridV), height * matrix.matrixSize[1] - 2);
+    const first = this.diagonal === "00-11" ? gridV - r <= gridU - c : gridU - c + gridV - r <= 1;
+    const a = [c, r];
+    const b = [c + 1, r];
+    const cc = [c, r + 1];
+    const d = [c + 1, r + 1];
+    const taps = interpolation === "nearest" ? [[Math.floor(gridU + 0.5), Math.floor(gridV + 0.5)]] : interpolation === "bilinear" ? [a, b, cc, d] : first ? [a, b, this.diagonal === "00-11" ? d : cc] : [this.diagonal === "00-11" ? a : b, cc, d];
+    let missing = false;
+    const values = [];
+    for (const [column, row] of taps) {
+      const tileColumn = Math.floor(column / width);
+      const tileRow = Math.floor(row / height);
+      const tile = this.tiles.get(tileKey(matrix.id, tileColumn, tileRow));
+      if (!tile) {
+        missing = true;
+        continue;
+      }
+      const index = (row - tileRow * height) * width + column - tileColumn * width;
+      if (!tile.validity[index])
+        return invalid(TerrainSampleStatus.NO_DATA);
+      values.push(tile.heights[index]);
+    }
+    if (missing)
+      return invalid(TerrainSampleStatus.NOT_RESIDENT);
+    if (interpolation === "nearest")
+      return { ...invalid(TerrainSampleStatus.VALID), height: values[0], gradientStatus: TerrainSampleStatus.UNAVAILABLE };
+    const fu = gridU - c;
+    const fv = gridV - r;
+    const [za, zb, zc, zd] = values;
+    const result = invalid(TerrainSampleStatus.VALID);
+    if (interpolation === "bilinear") {
+      result.height = (1 - fv) * ((1 - fu) * za + fu * zb) + fv * ((1 - fu) * zc + fu * zd);
+      result.gradientX = (1 - fv) * (zb - za) + fv * (zd - zc);
+      result.gradientY = (1 - fu) * (zc - za) + fu * (zd - zb);
+    } else if (first) {
+      result.gradientX = zb - za;
+      result.gradientY = this.diagonal === "00-11" ? zc - zb : zc - za;
+      result.height = this.diagonal === "00-11" ? (1 - fu) * za + (fu - fv) * zb + fv * zc : (1 - fu - fv) * za + fu * zb + fv * zc;
+    } else {
+      result.gradientX = zc - zb;
+      result.gradientY = this.diagonal === "00-11" ? zb - za : zc - za;
+      result.height = this.diagonal === "00-11" ? (1 - fv) * za + fu * zc + (fv - fu) * zb : (1 - fv) * za + (1 - fu) * zb + (fu + fv - 1) * zc;
+    }
+    if (!Number.isFinite(result.height))
+      return invalid(TerrainSampleStatus.NUMERIC_ERROR);
+    if (result.gradientStatus === TerrainSampleStatus.VALID) {
+      result.gradientX /= matrix.resolution;
+      result.gradientY /= dy;
+      const scale = Math.max(1, Math.abs(result.gradientX), Math.abs(result.gradientY));
+      if (!Number.isFinite(scale)) {
+        result.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+        result.gradientX = result.gradientY = result.normalX = result.normalY = result.normalZ = 0;
+      } else {
+        const length = Math.hypot(result.gradientX / scale, result.gradientY / scale, 1 / scale);
+        result.normalX = -result.gradientX / scale / length;
+        result.normalY = -result.gradientY / scale / length;
+        result.normalZ = 1 / scale / length;
+      }
+    }
+    return { ...result, matrixId: matrix.id };
+  }
+  buildHalo(matrix, column, row, diagonal) {
+    const [width, height] = matrix.tileSize;
+    const left = column > 0 ? 1 : 0;
+    const top = row > 0 ? 1 : 0;
+    const right = column < matrix.matrixSize[0] - 1 ? 1 : 0;
+    const bottom = row < matrix.matrixSize[1] - 1 ? 1 : 0;
+    const haloWidth = width + left + right;
+    const haloHeight = height + top + bottom;
+    const heights = new Float64Array(haloWidth * haloHeight);
+    const validity = new Uint8Array(heights.length);
+    for (let y = -top; y < height + bottom; y++)
+      for (let x = -left; x < width + right; x++) {
+        const globalX = column * width + x;
+        const globalY = row * height + y;
+        const ownerX = Math.floor(globalX / width);
+        const ownerY = Math.floor(globalY / height);
+        const tile = this.tiles.get(tileKey(matrix.id, ownerX, ownerY));
+        const index = (y + top) * haloWidth + x + left;
+        if (tile) {
+          const source = (globalY - ownerY * height) * width + globalX - ownerX * width;
+          heights[index] = tile.heights[source];
+          validity[index] = tile.validity[source];
+        }
+      }
+    this.halos.set(tileKey(matrix.id, column, row), {
+      field: new HeightField({
+        width: haloWidth,
+        height: haloHeight,
+        origin: [1 - left, 1 - top],
+        heights,
+        validity,
+        diagonal
+      })
+    });
+  }
+  validateTileId(tile) {
+    const matrix = this.getMatrix(tile.matrixId);
+    if (!Number.isInteger(tile.column) || !Number.isInteger(tile.row) || tile.column < 0 || tile.row < 0 || tile.column >= matrix.matrixSize[0] || tile.row >= matrix.matrixSize[1])
+      throw new Error("Terrain tile index is outside its matrix");
+    return matrix;
+  }
+  getMatrix(id) {
+    const matrix = this.matrices.find((candidate) => candidate.id === id);
+    if (!matrix)
+      throw new Error(`Unknown terrain matrix: ${id}`);
+    return matrix;
+  }
+};
+function tileKey(id, column, row) {
+  return JSON.stringify([id, column, row]);
+}
+function copyTileData(tile, matrix) {
+  const [width, height] = matrix.tileSize;
+  if (tile.heights.length !== width * height || tile.validity && tile.validity.length !== width * height)
+    throw new Error("Terrain tile buffers must match tileSize");
+  if (!(tile.heights instanceof Float32Array || tile.heights instanceof Float64Array) || tile.validity !== void 0 && !(tile.validity instanceof Uint8Array))
+    throw new Error("Invalid terrain tile buffer types");
+  const heights = new Float64Array(width * height);
+  const validity = new Uint8Array(width * height);
+  for (let index = 0; index < heights.length; index++) {
+    if (Number.isFinite(tile.heights[index]) && (!tile.validity || tile.validity[index])) {
+      heights[index] = tile.heights[index];
+      validity[index] = 1;
+    }
+  }
+  return { heights, validity };
+}
+function freezeChanges(changes) {
+  changes.sort((a, b) => (a.matrixId < b.matrixId ? -1 : a.matrixId > b.matrixId ? 1 : 0) || a.row - b.row || a.column - b.column);
+  return Object.freeze(changes.map((change) => Object.freeze(change)));
+}
+
+// dist/terrain/packed.js
+var TERRAIN_BUFFER_VERSION = 1;
+function packTerrainHeightField(field, options = {}) {
+  const heightOrigin = options.heightOrigin ?? 0;
+  const maxBytes = options.maxBytes ?? 64 * 1024 * 1024;
+  const maxHeightError = options.maxHeightError ?? Infinity;
+  const count = field.width * field.height;
+  if (!Number.isFinite(heightOrigin))
+    throw new Error("Terrain height origin must be finite");
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+    throw new Error("Terrain byte budget must be a nonnegative safe integer");
+  if (!(maxHeightError >= 0))
+    throw new Error("Terrain height error budget must be nonnegative");
+  if (!Number.isSafeInteger(count) || count > 4294967295 || count * 8 + 64 > maxBytes)
+    throw new Error("Terrain upload exceeds the sample or byte budget");
+  const transform = createTransform([...field.columnStep, ...field.rowStep]);
+  const header = new Uint32Array([
+    TERRAIN_BUFFER_VERSION,
+    field.width,
+    field.height,
+    field.registration === "cell" ? 1 : 0,
+    field.diagonal === "10-01" ? 1 : 0,
+    count,
+    0,
+    0
+  ]);
+  const heights = new Float32Array(count);
+  const validity = new Uint32Array(count);
+  let error = 0;
+  for (let row = 0; row < field.height; row++)
+    for (let column = 0; column < field.width; column++) {
+      const value = field.getHeight(column, row);
+      if (value === void 0)
+        continue;
+      const index = row * field.width + column;
+      heights[index] = value - heightOrigin;
+      const reconstructed = heights[index] + heightOrigin;
+      if (!Number.isFinite(heights[index]) || !Number.isFinite(reconstructed))
+        throw new Error("Terrain height is not representable in the packed frame");
+      const difference2 = Math.abs(reconstructed - value);
+      if (!Number.isFinite(difference2) || difference2 > maxHeightError)
+        throw new Error("Terrain upload exceeds the height error budget");
+      error = Math.max(error, difference2);
+      validity[index] = 1;
+    }
+  return {
+    header,
+    transform,
+    heights,
+    validity,
+    origin: Object.freeze([field.origin[0], field.origin[1], heightOrigin]),
+    heightReference: field.heightReference,
+    maxHeightError: error
+  };
+}
+function unpackTerrainHeightField(packed) {
+  const { header, transform, heights, validity, origin } = packed;
+  if (!(header instanceof Uint32Array) || header.length !== 8 || header[0] !== TERRAIN_BUFFER_VERSION || header[1] < 2 || header[2] < 2 || header[3] > 1 || header[4] > 1 || header[5] !== header[1] * header[2] || header[6] !== 0 || header[7] !== 0)
+    throw new Error("Invalid terrain buffer header");
+  if (!(transform instanceof Float32Array) || transform.length !== 8 || !transform.every(Number.isFinite))
+    throw new Error("Invalid terrain buffer transform");
+  const expected = createTransform(Array.from(transform.subarray(0, 4)));
+  if (!transform.every((value, index) => value === expected[index]))
+    throw new Error("Terrain inverse transform does not match its grid");
+  if (!(heights instanceof Float32Array) || heights.length !== header[5] || !(validity instanceof Uint32Array) || validity.length !== header[5])
+    throw new Error("Invalid terrain sample buffers");
+  if (!origin || origin.length !== 3 || !Number.isFinite(origin[0]) || !Number.isFinite(origin[1]) || !Number.isFinite(origin[2]) || typeof packed.heightReference !== "string" || !Number.isFinite(packed.maxHeightError) || packed.maxHeightError < 0)
+    throw new Error("Invalid terrain host metadata");
+  const values = new Float64Array(heights.length);
+  const mask = new Uint8Array(heights.length);
+  for (let i = 0; i < heights.length; i++) {
+    if (!Number.isFinite(heights[i]) || validity[i] > 1 || !validity[i] && heights[i] !== 0)
+      throw new Error("Invalid terrain height or validity value");
+    if (validity[i]) {
+      values[i] = heights[i] + origin[2];
+      if (!Number.isFinite(values[i]))
+        throw new Error("Terrain height reconstruction overflow");
+      mask[i] = 1;
+    }
+  }
+  return new HeightField({
+    width: header[1],
+    height: header[2],
+    heights: values,
+    validity: mask,
+    origin: [origin[0], origin[1]],
+    columnStep: [transform[0], transform[1]],
+    rowStep: [transform[2], transform[3]],
+    registration: header[3] ? "cell" : "vertex",
+    diagonal: header[4] ? "10-01" : "00-11",
+    heightReference: packed.heightReference
+  });
+}
+function createTransform(steps) {
+  const transform = new Float32Array(8);
+  transform.set(steps);
+  const [a, c, b, d] = transform;
+  const determinant = a * d - b * c;
+  const scale = Math.hypot(a, c) * Math.hypot(b, d);
+  if (!Number.isFinite(determinant) || Math.abs(determinant) <= Number.EPSILON * scale)
+    throw new Error("Terrain grid is singular after float32 conversion");
+  transform.set([d / determinant, -b / determinant, -c / determinant, a / determinant], 4);
+  if (!transform.every(Number.isFinite))
+    throw new Error("Terrain transform is not representable in float32");
+  return transform;
+}
+
+// dist/terrain/surface.js
+var import_geometry2 = require("@math.gl/geometry");
+
+// dist/terrain/mesh-data.js
+function assembleTerrainMesh(field, gridCoordinates, indices, options) {
+  const origin = options.origin ?? [field.origin[0], field.origin[1], 0];
+  if (origin.length !== 3 || !Number.isFinite(origin[0]) || !Number.isFinite(origin[1]) || !Number.isFinite(origin[2]))
+    throw new Error("Terrain mesh origin must be finite XYZ");
+  const positions = new Float64Array(gridCoordinates.length / 2 * 3);
+  for (let i = 0; i < gridCoordinates.length / 2; i++) {
+    const column = gridCoordinates[2 * i], row = gridCoordinates[2 * i + 1];
+    const shift = field.registration === "cell" ? 0.5 : 0;
+    positions[3 * i] = field.origin[0] - origin[0] + (column + shift) * field.columnStep[0] + (row + shift) * field.rowStep[0];
+    positions[3 * i + 1] = field.origin[1] - origin[1] + (column + shift) * field.columnStep[1] + (row + shift) * field.rowStep[1];
+    const height = field.getHeight(column, row);
+    positions[3 * i + 2] = height === void 0 ? 0 : height - origin[2];
+  }
+  if (!positions.every(Number.isFinite))
+    throw new Error("Terrain mesh coordinate overflow");
+  const reverse = field.columnStep[0] * field.rowStep[1] - field.columnStep[1] * field.rowStep[0] < 0;
+  for (let i = 0; i < indices.length; i += 3) {
+    if (reverse)
+      [indices[i + 1], indices[i + 2]] = [indices[i + 2], indices[i + 1]];
+    const a = indices[i] * 3, b = indices[i + 1] * 3, c = indices[i + 2] * 3;
+    const area = (positions[b] - positions[a]) * (positions[c + 1] - positions[a + 1]) - (positions[b + 1] - positions[a + 1]) * (positions[c] - positions[a]);
+    if (!Number.isFinite(area) || area <= 0)
+      throw new Error("Terrain mesh triangles degenerate or overflow; use a local origin");
+  }
+  return {
+    positions,
+    indices,
+    gridCoordinates,
+    width: field.width,
+    height: field.height,
+    origin: Object.freeze([...origin]),
+    heightReference: field.heightReference
+  };
+}
+function validateTerrainGridMesh(mesh) {
+  if (!Number.isSafeInteger(mesh.width) || !Number.isSafeInteger(mesh.height) || mesh.width < 2 || mesh.height < 2 || mesh.width * mesh.height > 4294967295)
+    throw new Error("Invalid terrain mesh grid dimensions");
+  if (!(mesh.positions instanceof Float64Array) || mesh.positions.length % 3 || !mesh.positions.every(Number.isFinite) || !(mesh.indices instanceof Uint32Array) || mesh.indices.length % 3 || !(mesh.gridCoordinates instanceof Uint32Array) || mesh.gridCoordinates.length !== mesh.positions.length / 3 * 2)
+    throw new Error("Invalid terrain mesh buffers");
+  if (mesh.origin.length !== 3 || !Number.isFinite(mesh.origin[0]) || !Number.isFinite(mesh.origin[1]) || !Number.isFinite(mesh.origin[2]))
+    throw new Error("Invalid terrain mesh origin");
+  for (let i = 0; i < mesh.gridCoordinates.length; i += 2)
+    if (mesh.gridCoordinates[i] >= mesh.width || mesh.gridCoordinates[i + 1] >= mesh.height)
+      throw new Error("Terrain mesh grid coordinate out of bounds");
+  for (const i of mesh.indices)
+    if (i >= mesh.positions.length / 3)
+      throw new Error("Terrain mesh vertex index out of bounds");
+}
+
+// dist/terrain/mesh.js
+function createTerrainMesh(field, options = {}) {
+  const count = field.width * field.height;
+  if (count > 4294967295)
+    throw new Error("Terrain mesh exceeds uint32 capacity");
+  const coordinates = new Uint32Array(count * 2);
+  for (let row = 0; row < field.height; row++)
+    for (let column = 0; column < field.width; column++)
+      coordinates.set([column, row], (row * field.width + column) * 2);
+  const output = new Uint32Array((field.width - 1) * (field.height - 1) * 6);
+  let used = 0;
+  const add = (a, b, c) => {
+    for (const i of [a, b, c])
+      if (field.getHeight(i % field.width, Math.floor(i / field.width)) === void 0)
+        return;
+    output[used++] = a;
+    output[used++] = b;
+    output[used++] = c;
+  };
+  for (let row = 0; row < field.height - 1; row++)
+    for (let column = 0; column < field.width - 1; column++) {
+      const a = row * field.width + column, b = a + 1, c = a + field.width, d = c + 1;
+      if (field.diagonal === "00-11") {
+        add(a, b, d);
+        add(a, d, c);
+      } else {
+        add(a, b, c);
+        add(b, d, c);
+      }
+    }
+  return assembleTerrainMesh(field, coordinates, used === output.length ? output : output.slice(0, used), options);
+}
+
+// dist/terrain/surface.js
+var TerrainSurface = class {
+  constructor(props) {
+    if (!(props.positions instanceof Float32Array || props.positions instanceof Float64Array) || props.positions.length % 3)
+      throw new Error("Terrain positions must be packed Float32/Float64 XYZ");
+    if (!(props.indices instanceof Uint16Array || props.indices instanceof Uint32Array) || props.indices.length % 3 || props.indices.length > 2147483647)
+      throw new Error("Terrain indices must form a Uint16/Uint32 triangle list within int32 topology capacity");
+    const origin = props.origin ?? [0, 0, 0];
+    if (origin.length !== 3 || !Number.isFinite(origin[0]) || !Number.isFinite(origin[1]) || !Number.isFinite(origin[2]))
+      throw new Error("Terrain origin must be finite XYZ");
+    this.origin = Object.freeze([origin[0], origin[1], origin[2]]);
+    this.heightReference = props.heightReference ?? "unknown";
+    if (typeof this.heightReference !== "string")
+      throw new Error("Terrain height reference must be a string");
+    this.positions = Float64Array.from(props.positions);
+    if (!this.positions.every(Number.isFinite))
+      throw new Error("Terrain positions must be finite");
+    this.indices = Uint32Array.from(props.indices);
+    this.triangleCount = this.indices.length / 3;
+    if (props.triangleValidity !== void 0 && (!(props.triangleValidity instanceof Uint8Array) || props.triangleValidity.length !== this.triangleCount))
+      throw new Error("Terrain triangle validity must match triangle count");
+    this.validity = Uint8Array.from({ length: this.triangleCount }, (_, i) => !props.triangleValidity || props.triangleValidity[i] ? 1 : 0);
+    for (const index of this.indices)
+      if (index >= this.positions.length / 3)
+        throw new Error("Terrain vertex index out of bounds");
+    this.gradients = new Float64Array(this.triangleCount * 2);
+    this.normals = new Float64Array(this.triangleCount * 3);
+    const bounds = new Float64Array(this.triangleCount * 4);
+    let active = 0;
+    for (let i = 0; i < this.triangleCount; i++) {
+      const [a, b, c] = this.triangle(i);
+      bounds.set([
+        Math.min(a[0], b[0], c[0]),
+        Math.min(a[1], b[1], c[1]),
+        Math.max(a[0], b[0], c[0]),
+        Math.max(a[1], b[1], c[1])
+      ], i * 4);
+      if (!this.validity[i])
+        continue;
+      const ax = b[0] - a[0], ay = b[1] - a[1], az = b[2] - a[2];
+      const bx = c[0] - a[0], by = c[1] - a[1], bz = c[2] - a[2];
+      const determinant = ax * by - ay * bx;
+      const scale = Math.hypot(ax, ay) * Math.hypot(bx, by);
+      if (!Number.isFinite(determinant) || Math.abs(determinant) <= Number.EPSILON * scale)
+        throw new Error("Active terrain triangles need finite, nondegenerate XY projections; use a local frame");
+      const gx = (az * by - ay * bz) / determinant;
+      const gy = (ax * bz - az * bx) / determinant;
+      if (!Number.isFinite(gx) || !Number.isFinite(gy))
+        throw new Error("Terrain gradient overflow");
+      this.gradients.set([gx, gy], i * 2);
+      const s = Math.max(1, Math.abs(gx), Math.abs(gy));
+      const length = Math.hypot(gx / s, gy / s, 1 / s);
+      this.normals.set([-gx / s / length, -gy / s / length, 1 / s / length], i * 3);
+      active++;
+    }
+    this.activeTriangleCount = active;
+    this.topology = buildTopology(this.indices, this.validity);
+    this.xyIndex = new import_geometry2.BoxIndex({ bounds, dimension: 2 });
+    this.bvh = new import_geometry2.TriangleBVH({ positions: this.positions, indices: this.indices });
+  }
+  /** Detached source data; changing these buffers never changes this surface. */
+  copyData() {
+    return {
+      positions: this.positions.slice(),
+      indices: this.indices.slice(),
+      triangleValidity: this.validity.slice()
+    };
+  }
+  copyTopology() {
+    return {
+      halfedges: this.topology.halfedges.slice(),
+      boundaryHalfedges: this.topology.boundaryHalfedges.slice()
+    };
+  }
+  /** World XY height, planar gradient and contact normal. Highest local Z wins; exact ties use the lowest triangle index. */
+  sample(x, y) {
+    const result = {
+      status: TerrainSampleStatus.INVALID_INPUT,
+      height: 0,
+      gradientStatus: TerrainSampleStatus.INVALID_INPUT,
+      gradientX: 0,
+      gradientY: 0,
+      normalX: 0,
+      normalY: 0,
+      normalZ: 0,
+      triangleIndex: -1,
+      barycentric: [0, 0, 0]
+    };
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+      return result;
+    const px = x - this.origin[0], py = y - this.origin[1];
+    if (!Number.isFinite(px) || !Number.isFinite(py)) {
+      result.status = result.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+      return result;
+    }
+    result.status = result.gradientStatus = TerrainSampleStatus.NO_DATA;
+    let best = -Infinity;
+    for (const i2 of this.xyIndex.search([px, py], [px, py])) {
+      if (!this.validity[i2])
+        continue;
+      const [a, b, c] = this.triangle(i2);
+      const ax = b[0] - a[0], ay = b[1] - a[1], bx = c[0] - a[0], by = c[1] - a[1];
+      const determinant = ax * by - ay * bx;
+      const dx = px - a[0], dy = py - a[1];
+      const u = (dx * by - dy * bx) / determinant;
+      const v = (ax * dy - ay * dx) / determinant;
+      if (u < 0 || v < 0 || u + v > 1 || !Number.isFinite(u) || !Number.isFinite(v))
+        continue;
+      const weights = [1 - u - v, u, v];
+      const height2 = weights[0] * a[2] + u * b[2] + v * c[2];
+      if (!Number.isFinite(height2)) {
+        result.status = result.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+        result.triangleIndex = -1;
+        result.barycentric = [0, 0, 0];
+        return result;
+      }
+      if (height2 <= best)
+        continue;
+      best = height2;
+      result.triangleIndex = i2;
+      result.barycentric = weights;
+    }
+    if (result.triangleIndex < 0)
+      return result;
+    const height = best + this.origin[2];
+    if (!Number.isFinite(height)) {
+      result.triangleIndex = -1;
+      result.barycentric = [0, 0, 0];
+      result.status = result.gradientStatus = TerrainSampleStatus.NUMERIC_ERROR;
+      return result;
+    }
+    const i = result.triangleIndex;
+    result.status = result.gradientStatus = TerrainSampleStatus.VALID;
+    result.height = height;
+    result.gradientX = this.gradients[i * 2];
+    result.gradientY = this.gradients[i * 2 + 1];
+    result.normalX = this.normals[i * 3];
+    result.normalY = this.normals[i * 3 + 1];
+    result.normalZ = this.normals[i * 3 + 2];
+    return result;
+  }
+  /** Two-sided ray query; distance limits are Euclidean meters, independent of direction magnitude. */
+  intersectRay(origin, direction, options = {}) {
+    return this.intersectRayQuery(origin, direction, { ...options, maxWork: Infinity }).result;
+  }
+  /** A partial hit is provisional; an incomplete null result does not establish a miss. */
+  intersectRayQuery(origin, direction, options = {}) {
+    const query = this.bvh.intersectRayQuery(this.localPoint(origin), direction, {
+      ...options,
+      filter: (i) => Boolean(this.validity[i])
+    });
+    const hit = query.result;
+    return { ...query, result: hit ? { ...this.toHit(hit), barycentric: [...hit.barycentric] } : null };
+  }
+  /** Closed segment query. A zero-length segment has no directional intersection. */
+  intersectSegment(start, end) {
+    return this.intersectSegmentQuery(start, end).result;
+  }
+  intersectSegmentQuery(start, end, options = {}) {
+    this.localPoint(start);
+    this.localPoint(end);
+    const direction = [
+      end[0] - start[0],
+      end[1] - start[1],
+      end[2] - start[2]
+    ];
+    const distance = Math.hypot(...direction);
+    if (!Number.isFinite(distance))
+      throw new Error("Terrain segment length overflow");
+    if (!distance) {
+      const limit = options.maxWork ?? Infinity;
+      if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0))
+        throw new Error("Invalid terrain query work limit");
+      return { result: null, complete: true, work: 0 };
+    }
+    return this.intersectRayQuery(start, direction, { ...options, maxDistance: distance });
+  }
+  /** Exact Euclidean nearest point, not vertical ground clearance. */
+  nearest(point, options = {}) {
+    return this.nearestQuery(point, { ...options, maxWork: Infinity }).result;
+  }
+  nearestQuery(point, options = {}) {
+    const query = this.bvh.nearestQuery(this.localPoint(point), {
+      ...options,
+      filter: (i) => Boolean(this.validity[i])
+    });
+    return { ...query, result: query.result ? this.toHit(query.result) : null };
+  }
+  /** Two-sided contacts with the triangle sheet, not solid-ground penetration or swept collision.
+   * Adjacent triangles may contribute coincident contacts. Incomplete lists are not manifolds.
+   */
+  intersectSphere(center, radius, options = {}) {
+    const local = this.localPoint(center);
+    const query = this.bvh.intersectSphere(local, radius, {
+      maxWork: options.maxWork,
+      maxResults: options.maxContacts,
+      filter: (i) => Boolean(this.validity[i])
+    });
+    return {
+      ...query,
+      result: query.result.map((hit) => {
+        const contact = this.toHit(hit);
+        const normal = hit.distance ? [
+          (local[0] - hit.point[0]) / hit.distance,
+          (local[1] - hit.point[1]) / hit.distance,
+          (local[2] - hit.point[2]) / hit.distance
+        ] : [...contact.normal];
+        return { ...contact, faceNormal: contact.normal, normal, penetration: radius - hit.distance };
+      })
+    };
+  }
+  /** Minimum Euclidean clearance along a closed segment; this is not vertical clearance. */
+  nearestSegment(start, end, options = {}) {
+    return this.nearestSegmentQuery(start, end, { ...options, maxWork: Infinity }).result;
+  }
+  nearestSegmentQuery(start, end, options = {}) {
+    const query = this.bvh.nearestSegmentQuery(this.localPoint(start), this.localPoint(end), {
+      ...options,
+      filter: (i) => Boolean(this.validity[i])
+    });
+    const hit = query.result;
+    return {
+      ...query,
+      result: hit ? {
+        ...this.toHit(hit),
+        segmentPoint: this.worldPoint(hit.segmentPoint),
+        segmentFraction: hit.segmentFraction
+      } : null
+    };
+  }
+  /** Contacts with a closed capsule's entire axis, including its interior and both caps.
+   * Fractions locate minimum separation, not the first time a translating sphere touches terrain.
+   */
+  intersectCapsule(start, end, radius, options = {}) {
+    const query = this.bvh.intersectCapsule(this.localPoint(start), this.localPoint(end), radius, {
+      maxWork: options.maxWork,
+      maxResults: options.maxContacts,
+      filter: (i) => Boolean(this.validity[i])
+    });
+    return {
+      ...query,
+      result: query.result.map((hit) => {
+        const contact = this.toHit(hit);
+        const normal = hit.distance ? [
+          (hit.segmentPoint[0] - hit.point[0]) / hit.distance,
+          (hit.segmentPoint[1] - hit.point[1]) / hit.distance,
+          (hit.segmentPoint[2] - hit.point[2]) / hit.distance
+        ] : [...contact.normal];
+        return {
+          ...contact,
+          normal,
+          faceNormal: contact.normal,
+          penetration: radius - hit.distance,
+          segmentPoint: this.worldPoint(hit.segmentPoint),
+          segmentFraction: hit.segmentFraction
+        };
+      })
+    };
+  }
+  worldPoint(point) {
+    const world = [
+      point[0] + this.origin[0],
+      point[1] + this.origin[1],
+      point[2] + this.origin[2]
+    ];
+    if (!world.every(Number.isFinite))
+      throw new Error("Terrain query result overflow");
+    return world;
+  }
+  localPoint(point) {
+    if (point.length !== 3 || !Number.isFinite(point[0]) || !Number.isFinite(point[1]) || !Number.isFinite(point[2]))
+      throw new Error("Terrain query point must be finite XYZ");
+    const local = [
+      point[0] - this.origin[0],
+      point[1] - this.origin[1],
+      point[2] - this.origin[2]
+    ];
+    if (!local.every(Number.isFinite))
+      throw new Error("Terrain query coordinate overflow");
+    return local;
+  }
+  toHit(hit) {
+    const point = this.worldPoint(hit.point);
+    if (!Number.isFinite(hit.distance))
+      throw new Error("Terrain query result overflow");
+    const i = hit.index * 3;
+    return {
+      triangleIndex: hit.index,
+      distance: hit.distance,
+      point,
+      normal: [this.normals[i], this.normals[i + 1], this.normals[i + 2]]
+    };
+  }
+  triangle(index) {
+    return [0, 1, 2].map((j) => {
+      const start = this.indices[index * 3 + j] * 3;
+      return this.positions.subarray(start, start + 3);
+    });
+  }
+};
+function buildTopology(indices, validity) {
+  const halfedges = new Int32Array(indices.length).fill(-1);
+  const edges = /* @__PURE__ */ new Map();
+  for (let i = 0; i < indices.length; i++) {
+    const triangle = Math.floor(i / 3);
+    if (!validity[triangle])
+      continue;
+    const a = indices[i], b = indices[triangle * 3 + (i % 3 + 1) % 3];
+    const key = a < b ? `${a}/${b}` : `${b}/${a}`;
+    const opposite = edges.get(key);
+    if (opposite === void 0)
+      edges.set(key, i);
+    else {
+      if (halfedges[opposite] !== -1)
+        throw new Error("Nonmanifold terrain edge");
+      if (indices[opposite] === a)
+        throw new Error("Inconsistent terrain triangle winding");
+      halfedges[i] = opposite;
+      halfedges[opposite] = i;
+    }
+  }
+  const boundary = [];
+  for (let i = 0; i < halfedges.length; i++)
+    if (validity[Math.floor(i / 3)] && halfedges[i] === -1)
+      boundary.push(i);
+  return { halfedges, boundaryHalfedges: Uint32Array.from(boundary) };
+}
+function createTerrainSurface(field, options = {}) {
+  const mesh = createTerrainMesh(field, options);
+  return new TerrainSurface({
+    positions: mesh.positions,
+    indices: mesh.indices,
+    origin: mesh.origin,
+    heightReference: field.heightReference
+  });
+}
+
+// dist/terrain/bounds.js
+var HeightFieldMinMax = class {
+  constructor(field) {
+    this.levels = [];
+    this.width = field.width - 1;
+    this.height = field.height - 1;
+    if (this.width * this.height > 4294967295)
+      throw new Error("Terrain bounds exceed uint32 cell capacity");
+    const base = createLevel(this.width, this.height, 1);
+    for (let row = 0; row < this.height; row++)
+      for (let column = 0; column < this.width; column++) {
+        const index = row * this.width + column;
+        let min = Infinity, max = -Infinity, count = 0;
+        for (const [x, y] of [
+          [column, row],
+          [column + 1, row],
+          [column, row + 1],
+          [column + 1, row + 1]
+        ]) {
+          const value = field.getHeight(x, y);
+          if (value === void 0)
+            continue;
+          min = Math.min(min, value);
+          max = Math.max(max, value);
+          count++;
+        }
+        if (count) {
+          base.minimums[index] = min;
+          base.maximums[index] = max;
+          base.populatedCellCounts[index] = 1;
+        }
+        if (count === 4)
+          base.completeCellCounts[index] = 1;
+      }
+    this.levels.push(base);
+    let previous = base;
+    while (previous.width > 1 || previous.height > 1) {
+      const next = createLevel(Math.ceil(previous.width / 2), Math.ceil(previous.height / 2), previous.blockSize * 2);
+      for (let row = 0; row < next.height; row++)
+        for (let column = 0; column < next.width; column++) {
+          const index = row * next.width + column;
+          let min = Infinity, max = -Infinity;
+          for (let y = row * 2; y < Math.min(row * 2 + 2, previous.height); y++)
+            for (let x = column * 2; x < Math.min(column * 2 + 2, previous.width); x++) {
+              const child = y * previous.width + x;
+              if (previous.populatedCellCounts[child]) {
+                min = Math.min(min, previous.minimums[child]);
+                max = Math.max(max, previous.maximums[child]);
+              }
+              next.populatedCellCounts[index] += previous.populatedCellCounts[child];
+              next.completeCellCounts[index] += previous.completeCellCounts[child];
+            }
+          if (next.populatedCellCounts[index]) {
+            next.minimums[index] = min;
+            next.maximums[index] = max;
+          }
+        }
+      this.levels.push(next);
+      previous = next;
+    }
+    this.levelCount = this.levels.length;
+  }
+  /** Exact rectangular aggregation through fully covered hierarchy nodes; no clipping or truncation. */
+  query(window = {
+    minColumn: 0,
+    minRow: 0,
+    maxColumn: this.width - 1,
+    maxRow: this.height - 1
+  }) {
+    const { minColumn, minRow, maxColumn, maxRow } = window;
+    if (![minColumn, minRow, maxColumn, maxRow].every(Number.isInteger) || minColumn < 0 || minRow < 0 || maxColumn >= this.width || maxRow >= this.height || minColumn > maxColumn || minRow > maxRow)
+      throw new Error("Invalid terrain cell window");
+    let min = Infinity, max = -Infinity, populated = 0, complete = 0;
+    const stack = [[this.levelCount - 1, 0, 0]];
+    while (stack.length) {
+      const [levelIndex, column, row] = stack.pop();
+      const level = this.levels[levelIndex];
+      const left = column * level.blockSize, bottom = row * level.blockSize;
+      const right = Math.min(left + level.blockSize, this.width) - 1;
+      const top = Math.min(bottom + level.blockSize, this.height) - 1;
+      if (left > maxColumn || bottom > maxRow || right < minColumn || top < minRow)
+        continue;
+      const index = row * level.width + column;
+      if (left >= minColumn && bottom >= minRow && right <= maxColumn && top <= maxRow) {
+        if (level.populatedCellCounts[index]) {
+          min = Math.min(min, level.minimums[index]);
+          max = Math.max(max, level.maximums[index]);
+        }
+        populated += level.populatedCellCounts[index];
+        complete += level.completeCellCounts[index];
+      } else {
+        const child = this.levels[levelIndex - 1];
+        for (let y = row * 2; y < Math.min(row * 2 + 2, child.height); y++)
+          for (let x = column * 2; x < Math.min(column * 2 + 2, child.width); x++)
+            stack.push([levelIndex - 1, x, y]);
+      }
+    }
+    return {
+      heightRange: populated ? [min, max] : void 0,
+      cellCount: (maxColumn - minColumn + 1) * (maxRow - minRow + 1),
+      populatedCellCount: populated,
+      completeCellCount: complete
+    };
+  }
+  /** Detached hierarchy arrays, suitable for inspection, transfer or a separate device adapter. */
+  copyLevel(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.levelCount)
+      throw new Error("Invalid terrain hierarchy level");
+    const level = this.levels[index];
+    return {
+      ...level,
+      minimums: level.minimums.slice(),
+      maximums: level.maximums.slice(),
+      populatedCellCounts: level.populatedCellCounts.slice(),
+      completeCellCounts: level.completeCellCounts.slice()
+    };
+  }
+};
+function createLevel(width, height, blockSize) {
+  const count = width * height;
+  return {
+    width,
+    height,
+    blockSize,
+    minimums: new Float64Array(count),
+    maximums: new Float64Array(count),
+    populatedCellCounts: new Uint32Array(count),
+    completeCellCounts: new Uint32Array(count)
+  };
+}
+
+// dist/terrain/mesh-error.js
+function measureTerrainMeshError(field, mesh, options = {}) {
+  validateTerrainGridMesh(mesh);
+  if (mesh.width !== field.width || mesh.height !== field.height || mesh.heightReference !== field.heightReference)
+    throw new Error("Terrain mesh and field metadata differ");
+  const limit = options.maxSampleTests ?? 1e7;
+  if (!Number.isSafeInteger(limit) || limit < 0)
+    throw new Error("Invalid terrain mesh sample-test limit");
+  const shift = field.registration === "cell" ? 0.5 : 0;
+  for (let i = 0; i < mesh.positions.length / 3; i++) {
+    const x = mesh.gridCoordinates[i * 2] + shift, y = mesh.gridCoordinates[i * 2 + 1] + shift;
+    for (let axis = 0; axis < 2; axis++) {
+      const expected = field.origin[axis] - mesh.origin[axis] + x * field.columnStep[axis] + y * field.rowStep[axis];
+      if (!Number.isFinite(expected) || mesh.positions[i * 3 + axis] !== expected)
+        throw new Error("Terrain mesh XY does not match the source grid frame");
+    }
+  }
+  const baseX = field.origin[0] - mesh.origin[0], baseY = field.origin[1] - mesh.origin[1];
+  const [columnX, columnY] = field.columnStep, [rowX, rowY] = field.rowStep;
+  const frameArea = Math.abs(columnX * rowY - columnY * rowX);
+  const roundX = 16 * Number.EPSILON * (Math.abs(baseX) + (field.width + 1) * Math.abs(columnX) + (field.height + 1) * Math.abs(rowX));
+  const roundY = 16 * Number.EPSILON * (Math.abs(baseY) + (field.width + 1) * Math.abs(columnY) + (field.height + 1) * Math.abs(rowY));
+  const gridRoundoff = Math.max((Math.abs(rowY) * roundX + Math.abs(rowX) * roundY) / frameArea, (Math.abs(columnY) * roundX + Math.abs(columnX) * roundY) / frameArea);
+  if (!Number.isFinite(gridRoundoff) || gridRoundoff >= 0.125)
+    throw new Error("Terrain mesh XY precision is insufficient; use a local origin and a well-conditioned frame");
+  const errors = new Float64Array(field.width * field.height);
+  const covered = new Uint8Array(errors.length);
+  let sampleTests = 0, coveredSampleCount = 0, maxSampleError = 0;
+  for (let t = 0; t < mesh.indices.length; t += 3) {
+    const a = mesh.indices[t], b = mesh.indices[t + 1], c = mesh.indices[t + 2];
+    const ax = mesh.gridCoordinates[a * 2], ay = mesh.gridCoordinates[a * 2 + 1];
+    const bx = mesh.gridCoordinates[b * 2], by = mesh.gridCoordinates[b * 2 + 1];
+    const cx = mesh.gridCoordinates[c * 2], cy = mesh.gridCoordinates[c * 2 + 1];
+    const determinant = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    if (!Number.isFinite(determinant) || determinant === 0)
+      throw new Error("Degenerate terrain mesh grid triangle");
+    const px = mesh.positions[a * 3], py = mesh.positions[a * 3 + 1];
+    const ux = mesh.positions[b * 3] - px, uy = mesh.positions[b * 3 + 1] - py;
+    const vx = mesh.positions[c * 3] - px, vy = mesh.positions[c * 3 + 1] - py;
+    const xyArea = ux * vy - uy * vx;
+    if (!Number.isFinite(xyArea) || xyArea === 0)
+      throw new Error("Degenerate terrain mesh XY triangle");
+    for (let row = Math.max(0, Math.min(ay, by, cy) - 1); row <= Math.min(field.height - 1, Math.max(ay, by, cy) + 1); row++)
+      for (let column = Math.max(0, Math.min(ax, bx, cx) - 1); column <= Math.min(field.width - 1, Math.max(ax, bx, cx) + 1); column++) {
+        if (sampleTests++ === limit)
+          throw new Error("Terrain mesh sample-test budget exceeded");
+        const dx = baseX + (column + shift) * columnX + (row + shift) * rowX - px;
+        const dy = baseY + (column + shift) * columnY + (row + shift) * rowY - py;
+        const sign = Math.sign(xyArea), area = Math.abs(xyArea);
+        const nu = (dx * vy - dy * vx) * sign;
+        const nv = (ux * dy - uy * dx) * sign;
+        const tolerance = 16 * Number.EPSILON * (Math.abs(dx * vy) + Math.abs(dy * vx) + Math.abs(ux * dy) + Math.abs(uy * dx) + area);
+        if (nu < -tolerance || nv < -tolerance || nu + nv > area + tolerance)
+          continue;
+        const u = nu / area, v = nv / area, w = (area - nu - nv) / area;
+        const height = field.getHeight(column, row);
+        if (height === void 0)
+          continue;
+        const predicted = w * mesh.positions[a * 3 + 2] + u * mesh.positions[b * 3 + 2] + v * mesh.positions[c * 3 + 2];
+        const localHeight = height - mesh.origin[2];
+        const virtualOrigin = height - localHeight;
+        const remainder = height - (localHeight + virtualOrigin) + (virtualOrigin - mesh.origin[2]);
+        const error = Math.abs(predicted - localHeight - remainder);
+        if (!Number.isFinite(error))
+          throw new Error("Terrain mesh error arithmetic overflow");
+        const index = row * field.width + column;
+        if (!covered[index]) {
+          covered[index] = 1;
+          coveredSampleCount++;
+        }
+        errors[index] = Math.max(errors[index], error);
+        maxSampleError = Math.max(maxSampleError, error);
+      }
+  }
+  let squares = 0;
+  if (maxSampleError)
+    for (const error of errors)
+      squares += (error / maxSampleError) ** 2;
+  return {
+    maxSampleError,
+    rmsSampleError: coveredSampleCount ? maxSampleError * Math.sqrt(squares / coveredSampleCount) : 0,
+    coveredSampleCount,
+    uncoveredSampleCount: field.validCount - coveredSampleCount,
+    sampleTests
+  };
+}
+
+// dist/terrain/mesh-edges.js
+function getTerrainMeshEdge(mesh, edge) {
+  validateTerrainGridMesh(mesh);
+  if (!["minColumn", "maxColumn", "minRow", "maxRow"].includes(edge))
+    throw new Error("Unknown terrain mesh edge");
+  const column = edge === "minColumn" || edge === "maxColumn";
+  const axis = column ? 0 : 1;
+  const value = edge.startsWith("min") ? 0 : (column ? mesh.width : mesh.height) - 1;
+  const vertices = /* @__PURE__ */ new Set();
+  for (const index of mesh.indices)
+    if (mesh.gridCoordinates[2 * index + axis] === value)
+      vertices.add(index);
+  return Uint32Array.from([...vertices].sort((a, b) => mesh.gridCoordinates[2 * a + 1 - axis] - mesh.gridCoordinates[2 * b + 1 - axis] || a - b));
+}
+
+// dist/terrain/martini.js
+var import_martini = __toESM(require("@mapbox/martini"), 1);
+function createMartiniTerrainMesh(field, options) {
+  const size = field.width, cells = size - 1;
+  const maxSamples = options.maxSamples ?? 11e5, maxTriangles = options.maxTriangles ?? 2 * cells * cells;
+  if (!Number.isFinite(options.maxError) || options.maxError < 0)
+    throw new Error("Adaptive terrain maxError must be finite and nonnegative");
+  for (const value of [maxSamples, maxTriangles])
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new Error("Invalid adaptive terrain capacity");
+  if (size !== field.height || cells < 1 || cells > 32768 || (cells & cells - 1) !== 0)
+    throw new Error("Adaptive terrain requires a square (2^k+1) grid within uint16 coordinates");
+  if (size * size > maxSamples)
+    throw new Error("Adaptive terrain sample capacity exceeded");
+  if (field.validCount !== size * size)
+    throw new Error("Adaptive terrain requires complete source data; use a regular mesh for holes");
+  const edges = options.fullEdges ?? [];
+  for (const edge of edges)
+    if (!["minColumn", "maxColumn", "minRow", "maxRow"].includes(edge))
+      throw new Error("Unknown adaptive terrain edge");
+  const { heights } = field.copyData();
+  const tile = new import_martini.default(size).createTile(heights);
+  for (const edge of edges)
+    for (let i = 0; i < size; i++) {
+      const column = edge === "minColumn" ? 0 : edge === "maxColumn" ? cells : i;
+      const row = edge === "minRow" ? 0 : edge === "maxRow" ? cells : i;
+      tile.errors[row * size + column] = Infinity;
+    }
+  if (edges.length)
+    tile.update();
+  let threshold = options.maxError;
+  for (let pass = 0; pass <= 8; pass++) {
+    const { vertices, triangles } = tile.getMesh(pass === 8 ? -1 : threshold);
+    if (triangles.length / 3 > maxTriangles)
+      throw new Error("Adaptive terrain triangle capacity exceeded");
+    const indices = Uint32Array.from(triangles);
+    for (let i = 0; i < indices.length; i += 3)
+      [indices[i + 1], indices[i + 2]] = [indices[i + 2], indices[i + 1]];
+    const mesh = assembleTerrainMesh(field, Uint32Array.from(vertices), indices, options);
+    const error = measureTerrainMeshError(field, mesh, { maxSampleTests: options.maxSampleTests });
+    if (!error.uncoveredSampleCount && error.maxSampleError <= options.maxError)
+      return {
+        ...mesh,
+        error,
+        requestedMaxError: options.maxError,
+        refinementPasses: pass + 1,
+        tessellator: "martini"
+      };
+    threshold /= 2;
+  }
+  throw new Error("Adaptive terrain could not meet the requested sample error");
+}
+
+// dist/terrain/vendor/delatin.js
+var Delatin = class {
+  constructor(data, width, height = width) {
+    this.data = data;
+    this.width = width;
+    this.height = height;
+    this.coords = [];
+    this.triangles = [];
+    this._halfedges = [];
+    this._candidates = [];
+    this._queueIndices = [];
+    this._queue = [];
+    this._errors = [];
+    this._rms = [];
+    this._pending = [];
+    this._pendingLen = 0;
+    this._rmsSum = 0;
+    const x1 = width - 1;
+    const y1 = height - 1;
+    const p0 = this._addPoint(0, 0);
+    const p1 = this._addPoint(x1, 0);
+    const p2 = this._addPoint(0, y1);
+    const p3 = this._addPoint(x1, y1);
+    const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
+    this._addTriangle(p0, p3, p1, t0, -1, -1);
+    this._flush();
+  }
+  // refine the mesh until its maximum error gets below the given one
+  run(maxError = 1) {
+    while (this.getMaxError() > maxError) {
+      this.refine();
+    }
+  }
+  // refine the mesh with a single point
+  refine() {
+    this._step();
+    this._flush();
+  }
+  // max error of the current mesh
+  getMaxError() {
+    return this._errors[0];
+  }
+  // root-mean-square deviation of the current mesh
+  getRMSD() {
+    return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
+  }
+  // height value at a given position
+  heightAt(x, y) {
+    return this.data[this.width * y + x];
+  }
+  // rasterize and queue all triangles that got added or updated in _step
+  _flush() {
+    const coords = this.coords;
+    for (let i = 0; i < this._pendingLen; i++) {
+      const t = this._pending[i];
+      const a = 2 * this.triangles[t * 3 + 0];
+      const b = 2 * this.triangles[t * 3 + 1];
+      const c = 2 * this.triangles[t * 3 + 2];
+      this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
+    }
+    this._pendingLen = 0;
+  }
+  // rasterize a triangle, find its max error, and queue it for processing
+  _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
+    const minX = Math.min(p0x, p1x, p2x);
+    const minY = Math.min(p0y, p1y, p2y);
+    const maxX = Math.max(p0x, p1x, p2x);
+    const maxY = Math.max(p0y, p1y, p2y);
+    let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
+    let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
+    let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
+    const a01 = p1y - p0y;
+    const b01 = p0x - p1x;
+    const a12 = p2y - p1y;
+    const b12 = p1x - p2x;
+    const a20 = p0y - p2y;
+    const b20 = p2x - p0x;
+    const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
+    const z0 = this.heightAt(p0x, p0y) / a;
+    const z1 = this.heightAt(p1x, p1y) / a;
+    const z2 = this.heightAt(p2x, p2y) / a;
+    let maxError = 0;
+    let mx = 0;
+    let my = 0;
+    let rms = 0;
+    for (let y = minY; y <= maxY; y++) {
+      let dx = 0;
+      if (w00 < 0 && a12 !== 0) {
+        dx = Math.max(dx, Math.floor(-w00 / a12));
+      }
+      if (w01 < 0 && a20 !== 0) {
+        dx = Math.max(dx, Math.floor(-w01 / a20));
+      }
+      if (w02 < 0 && a01 !== 0) {
+        dx = Math.max(dx, Math.floor(-w02 / a01));
+      }
+      let w0 = w00 + a12 * dx;
+      let w1 = w01 + a20 * dx;
+      let w2 = w02 + a01 * dx;
+      let wasInside = false;
+      for (let x = minX + dx; x <= maxX; x++) {
+        if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
+          wasInside = true;
+          const z = z0 * w0 + z1 * w1 + z2 * w2;
+          const dz = Math.abs(z - this.heightAt(x, y));
+          rms += dz * dz;
+          if (dz > maxError) {
+            maxError = dz;
+            mx = x;
+            my = y;
+          }
+        } else if (wasInside) {
+          break;
+        }
+        w0 += a12;
+        w1 += a20;
+        w2 += a01;
+      }
+      w00 += b12;
+      w01 += b20;
+      w02 += b01;
+    }
+    if (mx === p0x && my === p0y || mx === p1x && my === p1y || mx === p2x && my === p2y) {
+      maxError = 0;
+    }
+    this._candidates[2 * t] = mx;
+    this._candidates[2 * t + 1] = my;
+    this._rms[t] = rms;
+    this._queuePush(t, maxError, rms);
+  }
+  // process the next triangle in the queue, splitting it with a new point
+  _step() {
+    const t = this._queuePop();
+    const e0 = t * 3 + 0;
+    const e1 = t * 3 + 1;
+    const e2 = t * 3 + 2;
+    const p0 = this.triangles[e0];
+    const p1 = this.triangles[e1];
+    const p2 = this.triangles[e2];
+    const ax = this.coords[2 * p0];
+    const ay = this.coords[2 * p0 + 1];
+    const bx = this.coords[2 * p1];
+    const by = this.coords[2 * p1 + 1];
+    const cx = this.coords[2 * p2];
+    const cy = this.coords[2 * p2 + 1];
+    const px = this._candidates[2 * t];
+    const py = this._candidates[2 * t + 1];
+    const pn = this._addPoint(px, py);
+    if (orient(ax, ay, bx, by, px, py) === 0) {
+      this._handleCollinear(pn, e0);
+    } else if (orient(bx, by, cx, cy, px, py) === 0) {
+      this._handleCollinear(pn, e1);
+    } else if (orient(cx, cy, ax, ay, px, py) === 0) {
+      this._handleCollinear(pn, e2);
+    } else {
+      const h0 = this._halfedges[e0];
+      const h1 = this._halfedges[e1];
+      const h2 = this._halfedges[e2];
+      const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
+      const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
+      const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
+      this._legalize(t0);
+      this._legalize(t1);
+      this._legalize(t2);
+    }
+  }
+  // add coordinates for a new vertex
+  _addPoint(x, y) {
+    const i = this.coords.length >> 1;
+    this.coords.push(x, y);
+    return i;
+  }
+  // add or update a triangle in the mesh
+  _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
+    const t = e / 3;
+    this.triangles[e + 0] = a;
+    this.triangles[e + 1] = b;
+    this.triangles[e + 2] = c;
+    this._halfedges[e + 0] = ab;
+    this._halfedges[e + 1] = bc;
+    this._halfedges[e + 2] = ca;
+    if (ab >= 0) {
+      this._halfedges[ab] = e + 0;
+    }
+    if (bc >= 0) {
+      this._halfedges[bc] = e + 1;
+    }
+    if (ca >= 0) {
+      this._halfedges[ca] = e + 2;
+    }
+    this._candidates[2 * t + 0] = 0;
+    this._candidates[2 * t + 1] = 0;
+    this._queueIndices[t] = -1;
+    this._rms[t] = 0;
+    this._pending[this._pendingLen++] = t;
+    return e;
+  }
+  _legalize(a) {
+    const b = this._halfedges[a];
+    if (b < 0) {
+      return;
+    }
+    const a0 = a - a % 3;
+    const b0 = b - b % 3;
+    const al = a0 + (a + 1) % 3;
+    const ar = a0 + (a + 2) % 3;
+    const bl = b0 + (b + 2) % 3;
+    const br = b0 + (b + 1) % 3;
+    const p0 = this.triangles[ar];
+    const pr = this.triangles[a];
+    const pl = this.triangles[al];
+    const p1 = this.triangles[bl];
+    const coords = this.coords;
+    if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
+      return;
+    }
+    const hal = this._halfedges[al];
+    const har = this._halfedges[ar];
+    const hbl = this._halfedges[bl];
+    const hbr = this._halfedges[br];
+    this._queueRemove(a0 / 3);
+    this._queueRemove(b0 / 3);
+    const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
+    const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
+    this._legalize(t0 + 1);
+    this._legalize(t1 + 2);
+  }
+  // handle a case where new vertex is on the edge of a triangle
+  _handleCollinear(pn, a) {
+    const a0 = a - a % 3;
+    const al = a0 + (a + 1) % 3;
+    const ar = a0 + (a + 2) % 3;
+    const p0 = this.triangles[ar];
+    const pr = this.triangles[a];
+    const pl = this.triangles[al];
+    const hal = this._halfedges[al];
+    const har = this._halfedges[ar];
+    const b = this._halfedges[a];
+    if (b < 0) {
+      const t02 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
+      const t12 = this._addTriangle(p0, pn, pl, t02, -1, hal);
+      this._legalize(t02 + 1);
+      this._legalize(t12 + 2);
+      return;
+    }
+    const b0 = b - b % 3;
+    const bl = b0 + (b + 2) % 3;
+    const br = b0 + (b + 1) % 3;
+    const p1 = this.triangles[bl];
+    const hbl = this._halfedges[bl];
+    const hbr = this._halfedges[br];
+    this._queueRemove(b0 / 3);
+    const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
+    const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
+    const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
+    const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
+    this._legalize(t0);
+    this._legalize(t1);
+    this._legalize(t2);
+    this._legalize(t3);
+  }
+  // priority queue methods
+  _queuePush(t, error, rms) {
+    const i = this._queue.length;
+    this._queueIndices[t] = i;
+    this._queue.push(t);
+    this._errors.push(error);
+    this._rmsSum += rms;
+    this._queueUp(i);
+  }
+  _queuePop() {
+    const n = this._queue.length - 1;
+    this._queueSwap(0, n);
+    this._queueDown(0, n);
+    return this._queuePopBack();
+  }
+  _queuePopBack() {
+    const t = this._queue.pop();
+    this._errors.pop();
+    this._rmsSum -= this._rms[t];
+    this._queueIndices[t] = -1;
+    return t;
+  }
+  _queueRemove(t) {
+    const i = this._queueIndices[t];
+    if (i < 0) {
+      const it = this._pending.indexOf(t);
+      if (it !== -1) {
+        this._pending[it] = this._pending[--this._pendingLen];
+      } else {
+        throw new Error("Broken triangulation (something went wrong).");
+      }
+      return;
+    }
+    const n = this._queue.length - 1;
+    if (n !== i) {
+      this._queueSwap(i, n);
+      if (!this._queueDown(i, n)) {
+        this._queueUp(i);
+      }
+    }
+    this._queuePopBack();
+  }
+  _queueLess(i, j) {
+    return this._errors[i] > this._errors[j];
+  }
+  _queueSwap(i, j) {
+    const pi = this._queue[i];
+    const pj = this._queue[j];
+    this._queue[i] = pj;
+    this._queue[j] = pi;
+    this._queueIndices[pi] = j;
+    this._queueIndices[pj] = i;
+    const e = this._errors[i];
+    this._errors[i] = this._errors[j];
+    this._errors[j] = e;
+  }
+  _queueUp(j0) {
+    let j = j0;
+    while (true) {
+      const i = j - 1 >> 1;
+      if (i === j || !this._queueLess(j, i)) {
+        break;
+      }
+      this._queueSwap(i, j);
+      j = i;
+    }
+  }
+  _queueDown(i0, n) {
+    let i = i0;
+    while (true) {
+      const j1 = 2 * i + 1;
+      if (j1 >= n || j1 < 0) {
+        break;
+      }
+      const j2 = j1 + 1;
+      let j = j1;
+      if (j2 < n && this._queueLess(j2, j1)) {
+        j = j2;
+      }
+      if (!this._queueLess(j, i)) {
+        break;
+      }
+      this._queueSwap(i, j);
+      i = j;
+    }
+    return i > i0;
+  }
+};
+function orient(ax, ay, bx, by, cx, cy) {
+  return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
+}
+function inCircle(ax, ay, bx, by, cx, cy, px, py) {
+  const dx = ax - px;
+  const dy = ay - py;
+  const ex = bx - px;
+  const ey = by - py;
+  const fx = cx - px;
+  const fy = cy - py;
+  const ap = dx * dx + dy * dy;
+  const bp = ex * ex + ey * ey;
+  const cp = fx * fx + fy * fy;
+  return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
+}
+
+// dist/terrain/delatin.js
+function createDelatinTerrainMesh(field, options) {
+  const count = field.width * field.height;
+  const maxSamples = options.maxSamples ?? 11e5;
+  const maxTriangles = options.maxTriangles ?? 2 * (field.width - 1) * (field.height - 1);
+  const maxRefinements = options.maxRefinements ?? count - 4;
+  if (!Number.isFinite(options.maxError) || options.maxError < 0)
+    throw new Error("Delatin terrain maxError must be finite and nonnegative");
+  for (const limit of [maxSamples, maxTriangles, maxRefinements])
+    if (!Number.isSafeInteger(limit) || limit < 0)
+      throw new Error("Invalid Delatin terrain capacity");
+  if (count > maxSamples || count > 4294967295)
+    throw new Error("Delatin terrain sample capacity exceeded");
+  if (field.validCount !== count)
+    throw new Error("Delatin terrain requires complete source data; use a regular mesh for holes");
+  if (maxTriangles < 2)
+    throw new Error("Delatin terrain triangle capacity exceeded");
+  if (options.fullEdges !== void 0)
+    throw new Error("Delatin does not support fullEdges; use MARTINI for forced boundary refinement");
+  const { heights } = field.copyData();
+  const tin = new Delatin(heights, field.width, field.height);
+  let threshold = options.maxError, refinements = 0;
+  for (let pass = 0; pass <= 8; pass++) {
+    if (pass < 8) {
+      while (true) {
+        const error2 = tin.getMaxError();
+        if (!Number.isFinite(error2))
+          throw new Error("Delatin error arithmetic overflow");
+        if (error2 <= threshold)
+          break;
+        if (refinements >= maxRefinements)
+          throw new Error("Delatin terrain refinement budget exceeded");
+        tin.refine();
+        refinements++;
+        if (tin.triangles.length / 3 > maxTriangles)
+          throw new Error("Delatin terrain triangle capacity exceeded");
+      }
+    }
+    if (pass === 8 && 2 * (field.width - 1) * (field.height - 1) > maxTriangles)
+      throw new Error("Delatin terrain fallback triangle capacity exceeded");
+    const indices = Uint32Array.from(tin.triangles);
+    for (let i = 0; i < indices.length; i += 3)
+      [indices[i + 1], indices[i + 2]] = [indices[i + 2], indices[i + 1]];
+    const mesh = pass === 8 ? createTerrainMesh(field, options) : assembleTerrainMesh(field, Uint32Array.from(tin.coords), indices, options);
+    const error = measureTerrainMeshError(field, mesh, { maxSampleTests: options.maxSampleTests });
+    if (!error.uncoveredSampleCount && error.maxSampleError <= options.maxError)
+      return {
+        ...mesh,
+        error,
+        requestedMaxError: options.maxError,
+        refinementPasses: pass + 1,
+        tessellator: pass === 8 ? "regular" : "delatin"
+      };
+    threshold /= 2;
+  }
+  throw new Error("Delatin terrain could not meet the requested sample error");
+}
+
+// dist/terrain/derivatives.js
+function createTerrainGradientGrid(field, options = {}) {
+  const method = options.method ?? "horn";
+  if (method !== "horn" && method !== "zevenbergen-thorne")
+    throw new Error("Unknown terrain gradient method");
+  const count = field.width * field.height, limit = options.maxSamples ?? 11e5;
+  if (!Number.isSafeInteger(limit) || limit < 0 || count > limit)
+    throw new Error("Terrain gradient sample capacity exceeded");
+  const gradients = new Float64Array(count * 2), statuses = new Uint8Array(count).fill(TerrainSampleStatus.OUTSIDE_DOMAIN);
+  const [a, c] = field.columnStep, [b, d] = field.rowStep;
+  const determinant = a * d - b * c;
+  const ix = d / determinant, iy = -c / determinant, jx = -b / determinant, jy = a / determinant;
+  const window = new Float64Array(9);
+  for (let row = 1; row < field.height - 1; row++)
+    for (let column = 1; column < field.width - 1; column++) {
+      const index = row * field.width + column;
+      let valid = true;
+      for (let y = -1; y <= 1; y++)
+        for (let x = -1; x <= 1; x++) {
+          const value = field.getHeight(column + x, row + y);
+          if (value === void 0)
+            valid = false;
+          window[(y + 1) * 3 + x + 1] = value ?? 0;
+        }
+      if (!valid) {
+        statuses[index] = TerrainSampleStatus.NO_DATA;
+        continue;
+      }
+      const dc = method === "horn" ? difference(window[2], window[0], 8) + difference(window[5], window[3], 4) + difference(window[8], window[6], 8) : difference(window[5], window[3], 2);
+      const dr = method === "horn" ? difference(window[6], window[0], 8) + difference(window[7], window[1], 4) + difference(window[8], window[2], 8) : difference(window[7], window[1], 2);
+      const gx = dc * ix + dr * iy, gy = dc * jx + dr * jy;
+      if (!Number.isFinite(gx) || !Number.isFinite(gy)) {
+        statuses[index] = TerrainSampleStatus.NUMERIC_ERROR;
+        continue;
+      }
+      gradients[2 * index] = gx;
+      gradients[2 * index + 1] = gy;
+      statuses[index] = TerrainSampleStatus.VALID;
+    }
+  return {
+    width: field.width,
+    height: field.height,
+    gradients,
+    statuses,
+    method,
+    origin: field.origin,
+    columnStep: field.columnStep,
+    rowStep: field.rowStep,
+    registration: field.registration,
+    heightReference: field.heightReference
+  };
+}
+function difference(a, b, divisor) {
+  const delta = a - b;
+  return Number.isFinite(delta) ? delta / divisor : a / divisor - b / divisor;
+}
+
+// dist/terrain/slope-aspect.js
+function getTerrainSlopeAspect(gradientX, gradientY) {
+  if (!Number.isFinite(gradientX) || !Number.isFinite(gradientY))
+    throw new Error("Terrain gradient must be finite");
+  const slope = Math.atan(Math.hypot(gradientX, gradientY));
+  const angle = Math.atan2(-gradientX, -gradientY);
+  return {
+    slope,
+    aspect: gradientX === 0 && gradientY === 0 ? void 0 : (angle < 0 ? angle + 2 * Math.PI : angle || 0) % (2 * Math.PI)
+  };
+}
+function createTerrainSlopeAspectGrid(grid, options = {}) {
+  const count = grid.width * grid.height, limit = options.maxSamples ?? 11e5;
+  if (!Number.isSafeInteger(grid.width) || grid.width < 2 || !Number.isSafeInteger(grid.height) || grid.height < 2 || !Number.isSafeInteger(limit) || limit < 0 || count > limit)
+    throw new Error("Invalid terrain slope grid dimensions or capacity");
+  if (!(grid.gradients instanceof Float64Array) || grid.gradients.length !== 2 * count || !(grid.statuses instanceof Uint8Array) || grid.statuses.length !== count)
+    throw new Error("Invalid terrain slope grid buffers");
+  const slopes = new Float64Array(count), aspects = new Float64Array(count);
+  const statuses = grid.statuses.slice(), aspectStatuses = grid.statuses.slice();
+  for (let i = 0; i < count; i++) {
+    if (statuses[i] > TerrainSampleStatus.NOT_RESIDENT)
+      throw new Error("Invalid terrain gradient status");
+    if (statuses[i] !== TerrainSampleStatus.VALID)
+      continue;
+    const value = getTerrainSlopeAspect(grid.gradients[2 * i], grid.gradients[2 * i + 1]);
+    slopes[i] = value.slope;
+    if (value.aspect === void 0)
+      aspectStatuses[i] = TerrainSampleStatus.NO_DATA;
+    else
+      aspects[i] = value.aspect;
+  }
+  return { width: grid.width, height: grid.height, slopes, aspects, statuses, aspectStatuses };
+}
+
+// dist/terrain/profile.js
+function sampleTerrainProfile(sample, path, options) {
+  const limit = options.maxSamples ?? 1e6;
+  if (!Number.isFinite(options.spacing) || options.spacing <= 0 || !Number.isSafeInteger(limit) || limit < 1)
+    throw new Error("Invalid terrain profile spacing or capacity");
+  if (!Number.isSafeInteger(path.length) || path.length < 2 || path.length % 2 || path.length / 2 > limit)
+    throw new Error("Invalid terrain profile path or vertex capacity");
+  for (let i = 0; i < path.length; i++)
+    if (!Number.isFinite(path[i]))
+      throw new Error("Terrain profile coordinates must be finite");
+  const points = Float64Array.from(path), lengths = new Float64Array(points.length / 2 - 1), divisions = new Float64Array(lengths.length);
+  let count = 1, length = 0;
+  for (let i = 0; i < lengths.length; i++) {
+    const distance = Math.hypot(points[2 * i + 2] - points[2 * i], points[2 * i + 3] - points[2 * i + 1]);
+    const nextLength = length + distance;
+    if (!Number.isFinite(nextLength) || distance > 0 && nextLength <= length)
+      throw new Error("Terrain profile distance overflow or loss of precision");
+    const steps = distance === 0 ? 0 : Math.max(1, Math.ceil(distance / options.spacing));
+    if (!Number.isSafeInteger(steps) || count + steps > limit)
+      throw new Error("Terrain profile sample capacity exceeded");
+    lengths[i] = distance;
+    divisions[i] = steps;
+    count += steps;
+    length = nextLength;
+  }
+  const positions = new Float64Array(count * 2), distances = new Float64Array(count), heights = new Float64Array(count), statuses = new Uint8Array(count);
+  let index = 0;
+  const emit = (x, y, distance) => {
+    if (index > 0 && (distance <= distances[index - 1] || x === positions[2 * index - 2] && y === positions[2 * index - 1]))
+      throw new Error("Terrain profile samples lose coordinate or distance precision");
+    positions[2 * index] = x;
+    positions[2 * index + 1] = y;
+    distances[index] = distance;
+    const value = sample(x, y);
+    if (!Number.isInteger(value.status) || value.status < 0 || value.status > TerrainSampleStatus.NOT_RESIDENT)
+      throw new Error("Invalid terrain profile sample status");
+    statuses[index] = value.status;
+    if (value.status === TerrainSampleStatus.VALID) {
+      if (Number.isFinite(value.height))
+        heights[index] = value.height;
+      else
+        statuses[index] = TerrainSampleStatus.NUMERIC_ERROR;
+    }
+    index++;
+  };
+  emit(points[0], points[1], 0);
+  let start = 0;
+  for (let i = 0; i < lengths.length; i++) {
+    const steps = divisions[i];
+    for (let j = 1; j <= steps; j++) {
+      const fraction = j / steps;
+      emit(j === steps ? points[2 * i + 2] : points[2 * i] + (points[2 * i + 2] - points[2 * i]) * fraction, j === steps ? points[2 * i + 3] : points[2 * i + 1] + (points[2 * i + 3] - points[2 * i + 1]) * fraction, start + lengths[i] * fraction);
+    }
+    start += lengths[i];
+  }
+  return { positions, distances, heights, statuses, length };
+}
+
+// dist/terrain/contours.js
+function createTerrainContours(field, levels, options = {}) {
+  const maxSamples = options.maxSamples ?? 11e5, maxLevels = options.maxLevels ?? 256;
+  const maxVertices = options.maxVertices ?? 2e6, maxSegments = options.maxSegments ?? 1e6;
+  const maxTriangleTests = options.maxTriangleTests ?? 1e7;
+  for (const limit of [maxSamples, maxLevels, maxVertices, maxSegments, maxTriangleTests])
+    if (!Number.isSafeInteger(limit) || limit < 0)
+      throw new Error("Invalid terrain contour capacity");
+  const count = field.width * field.height;
+  if (count > maxSamples || count > 4294967295 || maxVertices > 4294967295 || maxSegments > 4294967295)
+    throw new Error("Terrain contour sample or index capacity exceeded");
+  if (!Number.isSafeInteger(levels.length) || levels.length < 0 || levels.length > maxLevels)
+    throw new Error("Terrain contour level capacity exceeded");
+  for (let i = 0; i < levels.length; i++)
+    if (!Number.isFinite(levels[i]) || i > 0 && levels[i] <= levels[i - 1])
+      throw new Error("Terrain contour levels must be finite and strictly increasing");
+  if (levels.length * 2 * (field.width - 1) * (field.height - 1) > maxTriangleTests)
+    throw new Error("Terrain contour triangle-test budget exceeded");
+  const origin = options.origin ?? [field.origin[0], field.origin[1], 0];
+  if (origin.length !== 3 || !Number.isFinite(origin[0]) || !Number.isFinite(origin[1]) || !Number.isFinite(origin[2]))
+    throw new Error("Terrain contour origin must be finite XYZ");
+  const outputLevels = Float64Array.from(levels), positions = [], coordinates = [], segments = [], levelIndices = [];
+  const shift = field.registration === "cell" ? 0.5 : 0;
+  for (let levelIndex = 0; levelIndex < outputLevels.length; levelIndex++) {
+    const level = outputLevels[levelIndex], vertices = /* @__PURE__ */ new Map(), edges = /* @__PURE__ */ new Set();
+    const height = (i) => field.getHeight(i % field.width, Math.floor(i / field.width));
+    const intersection = (a, b) => {
+      if (a > b)
+        [a, b] = [b, a];
+      const exact = height(a) === level ? a : height(b) === level ? b : void 0;
+      return exact === void 0 ? { a, b, key: `e${a}/${b}` } : { a: exact, b: exact, key: `v${exact}` };
+    };
+    const vertex = ({ a, b, key }) => {
+      const existing = vertices.get(key);
+      if (existing !== void 0)
+        return existing;
+      if (positions.length / 3 >= maxVertices)
+        throw new Error("Terrain contour vertex capacity exceeded");
+      let fraction = 0;
+      if (a !== b) {
+        const ha = height(a), hb = height(b), delta = hb - ha, offset = level - ha;
+        if (Number.isFinite(delta) && Number.isFinite(offset))
+          fraction = offset / delta;
+        else {
+          const scale = Math.max(Math.abs(ha), Math.abs(hb), Math.abs(level));
+          fraction = (level / scale - ha / scale) / (hb / scale - ha / scale);
+        }
+        if (!Number.isFinite(fraction) || fraction <= 0 || fraction >= 1)
+          throw new Error("Terrain contour intersection loses precision");
+      }
+      const ax = a % field.width, ay = Math.floor(a / field.width);
+      const x = ax + (b % field.width - ax) * fraction, y = ay + (Math.floor(b / field.width) - ay) * fraction;
+      const px = field.origin[0] - origin[0] + (x + shift) * field.columnStep[0] + (y + shift) * field.rowStep[0];
+      const py = field.origin[1] - origin[1] + (x + shift) * field.columnStep[1] + (y + shift) * field.rowStep[1];
+      const pz = level - origin[2];
+      if (!Number.isFinite(px) || !Number.isFinite(py) || !Number.isFinite(pz))
+        throw new Error("Terrain contour coordinate overflow");
+      const index = positions.length / 3;
+      positions.push(px, py, pz);
+      coordinates.push(x, y);
+      vertices.set(key, index);
+      return index;
+    };
+    const triangle = (a, b, c) => {
+      const ha = height(a), hb = height(b), hc = height(c);
+      if (ha === void 0 || hb === void 0 || hc === void 0)
+        return;
+      const hits = [];
+      if (ha < level !== hb < level)
+        hits.push(intersection(a, b));
+      if (hb < level !== hc < level)
+        hits.push(intersection(b, c));
+      if (hc < level !== ha < level)
+        hits.push(intersection(c, a));
+      if (hits.length !== 2 || hits[0].key === hits[1].key)
+        return;
+      const va = vertex(hits[0]), vb = vertex(hits[1]);
+      const key = va < vb ? `${va}/${vb}` : `${vb}/${va}`;
+      if (edges.has(key))
+        return;
+      if (segments.length / 2 >= maxSegments)
+        throw new Error("Terrain contour segment capacity exceeded");
+      if (positions[3 * va] === positions[3 * vb] && positions[3 * va + 1] === positions[3 * vb + 1])
+        throw new Error("Terrain contour segment collapses; use a local origin");
+      edges.add(key);
+      segments.push(va, vb);
+      levelIndices.push(levelIndex);
+    };
+    for (let row = 0; row < field.height - 1; row++)
+      for (let column = 0; column < field.width - 1; column++) {
+        const a = row * field.width + column, b = a + 1, c = a + field.width, d = c + 1;
+        if (field.diagonal === "00-11") {
+          triangle(a, b, d);
+          triangle(a, d, c);
+        } else {
+          triangle(a, b, c);
+          triangle(b, d, c);
+        }
+      }
+  }
+  return {
+    positions: Float64Array.from(positions),
+    gridCoordinates: Float64Array.from(coordinates),
+    segments: Uint32Array.from(segments),
+    levelIndices: Uint32Array.from(levelIndices),
+    levels: outputLevels,
+    origin: Object.freeze([...origin]),
+    heightReference: field.heightReference
+  };
+}
+
+// dist/terrain/contour-path-data.js
+function contourPathLimits(options) {
+  const limits = {
+    maxVertices: options.maxVertices ?? 2e6,
+    maxSegments: options.maxSegments ?? 1e6,
+    maxPaths: options.maxPaths ?? 1e6,
+    maxIndices: options.maxIndices ?? 2e6,
+    maxLevels: options.maxLevels ?? 256
+  };
+  for (const value of Object.values(limits))
+    if (!Number.isSafeInteger(value) || value < 0 || value > 4294967294)
+      throw new Error("Invalid terrain contour path capacity");
+  return limits;
+}
+function validateContourData(data, limits) {
+  if (!(data.positions instanceof Float64Array) || data.positions.length % 3 || data.positions.length / 3 > limits.maxVertices || !data.positions.every(Number.isFinite))
+    throw new Error("Invalid terrain contour positions or capacity");
+  const count = data.positions.length / 3;
+  if (!(data.gridCoordinates instanceof Float64Array) || data.gridCoordinates.length !== count * 2 || !data.gridCoordinates.every(Number.isFinite))
+    throw new Error("Invalid terrain contour grid coordinates");
+  if (!(data.levels instanceof Float64Array) || data.levels.length > limits.maxLevels)
+    throw new Error("Invalid terrain contour levels or capacity");
+  for (let i = 0; i < data.levels.length; i++)
+    if (!Number.isFinite(data.levels[i]) || i > 0 && data.levels[i] <= data.levels[i - 1])
+      throw new Error("Invalid terrain contour levels");
+  if (data.origin.length !== 3 || !Number.isFinite(data.origin[0]) || !Number.isFinite(data.origin[1]) || !Number.isFinite(data.origin[2]) || typeof data.heightReference !== "string")
+    throw new Error("Invalid terrain contour frame");
+  return count;
+}
+function validateContourVertex(data, vertex, level, assignments) {
+  if (vertex >= assignments.length || level >= data.levels.length)
+    throw new Error("Terrain contour index out of range");
+  if (assignments[vertex] !== 4294967295 && assignments[vertex] !== level)
+    throw new Error("Terrain contour vertex belongs to multiple levels");
+  if (data.positions[vertex * 3 + 2] !== data.levels[level] - data.origin[2])
+    throw new Error("Terrain contour vertex height does not match its level");
+  assignments[vertex] = level;
+}
+function copyContourData(data) {
+  return {
+    positions: data.positions.slice(),
+    gridCoordinates: data.gridCoordinates.slice(),
+    levels: data.levels.slice(),
+    origin: Object.freeze([...data.origin]),
+    heightReference: data.heightReference
+  };
+}
+
+// dist/terrain/contour-paths.js
+function stitchTerrainContours(contours, options = {}) {
+  const limits = contourPathLimits(options), count = validateContourData(contours, limits);
+  if (!(contours.segments instanceof Uint32Array) || contours.segments.length % 2 || contours.segments.length > 4294967294 || contours.segments.length / 2 > limits.maxSegments || !(contours.levelIndices instanceof Uint32Array) || contours.levelIndices.length !== contours.segments.length / 2)
+    throw new Error("Invalid terrain contour segments or capacity");
+  const edgeCount = contours.segments.length / 2, degrees = new Uint32Array(count), assignments = new Uint32Array(count).fill(4294967295), unique = /* @__PURE__ */ new Set();
+  for (let i = 0; i < edgeCount; i++) {
+    const a = contours.segments[2 * i], b = contours.segments[2 * i + 1], level = contours.levelIndices[i];
+    validateContourVertex(contours, a, level, assignments);
+    validateContourVertex(contours, b, level, assignments);
+    if (a === b || contours.positions[3 * a] === contours.positions[3 * b] && contours.positions[3 * a + 1] === contours.positions[3 * b + 1])
+      throw new Error("Degenerate terrain contour segment");
+    const key = a < b ? `${a}/${b}` : `${b}/${a}`;
+    if (unique.has(key))
+      throw new Error("Duplicate terrain contour segment");
+    unique.add(key);
+    degrees[a]++;
+    degrees[b]++;
+  }
+  const starts = new Uint32Array(count + 1);
+  for (let i = 0; i < count; i++)
+    starts[i + 1] = starts[i] + degrees[i];
+  const cursor = starts.slice(), adjacency = new Uint32Array(edgeCount * 2);
+  for (let i = 0; i < edgeCount; i++)
+    for (let j = 0; j < 2; j++)
+      adjacency[cursor[contours.segments[2 * i + j]]++] = i;
+  const visited = new Uint8Array(edgeCount), indices = [], offsets = [0], levels = [], closed = [];
+  const append = (vertex) => {
+    if (indices.length >= limits.maxIndices)
+      throw new Error("Terrain contour path index capacity exceeded");
+    indices.push(vertex);
+  };
+  const trace = (start, firstEdge) => {
+    if (levels.length >= limits.maxPaths)
+      throw new Error("Terrain contour path capacity exceeded");
+    levels.push(assignments[start]);
+    append(start);
+    let vertex = start, edge = firstEdge;
+    while (!visited[edge]) {
+      visited[edge] = 1;
+      const a = contours.segments[2 * edge], b = contours.segments[2 * edge + 1];
+      vertex = vertex === a ? b : a;
+      append(vertex);
+      if (vertex === start || degrees[vertex] !== 2)
+        break;
+      const e0 = adjacency[starts[vertex]], e1 = adjacency[starts[vertex] + 1];
+      edge = visited[e0] ? e1 : e0;
+    }
+    closed.push(vertex === start ? 1 : 0);
+    offsets.push(indices.length);
+  };
+  for (let vertex = 0; vertex < count; vertex++)
+    if (degrees[vertex] !== 2) {
+      for (let j = starts[vertex]; j < starts[vertex + 1]; j++)
+        if (!visited[adjacency[j]])
+          trace(vertex, adjacency[j]);
+    }
+  for (let vertex = 0; vertex < count; vertex++)
+    for (let j = starts[vertex]; j < starts[vertex + 1]; j++)
+      if (!visited[adjacency[j]])
+        trace(vertex, adjacency[j]);
+  return {
+    ...copyContourData(contours),
+    indices: Uint32Array.from(indices),
+    offsets: Uint32Array.from(offsets),
+    levelIndices: Uint32Array.from(levels),
+    closed: Uint8Array.from(closed)
+  };
+}
+
+// dist/terrain/contour-simplify.js
+function simplifyTerrainContourPaths(paths, options) {
+  const limits = contourPathLimits(options), count = validateContourData(paths, limits);
+  const budget = options.maxDistanceTests ?? 1e7;
+  if (!Number.isFinite(options.maxError) || options.maxError < 0 || !Number.isSafeInteger(budget) || budget < 0)
+    throw new Error("Invalid contour simplification error or work limit");
+  if (!(paths.indices instanceof Uint32Array) || paths.indices.length > limits.maxIndices || !(paths.offsets instanceof Uint32Array) || paths.offsets.length < 1 || paths.offsets.length - 1 > limits.maxPaths || paths.offsets[0] !== 0 || paths.offsets[paths.offsets.length - 1] !== paths.indices.length)
+    throw new Error("Invalid terrain contour path indices or offsets");
+  const pathCount = paths.offsets.length - 1;
+  if (paths.indices.length - pathCount > limits.maxSegments || !(paths.levelIndices instanceof Uint32Array) || paths.levelIndices.length !== pathCount || !(paths.closed instanceof Uint8Array) || paths.closed.length !== pathCount)
+    throw new Error("Invalid terrain contour path metadata or segment capacity");
+  const uses = new Uint32Array(count), assignments = new Uint32Array(count).fill(4294967295);
+  for (let p = 0; p < pathCount; p++) {
+    const start = paths.offsets[p], end = paths.offsets[p + 1], closed = paths.closed[p];
+    if (end > paths.indices.length || end < start || closed > 1 || end - start < (closed ? 4 : 2) || Boolean(closed) !== (paths.indices[start] === paths.indices[end - 1]))
+      throw new Error("Invalid terrain contour path closure");
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = start; i < end; i++) {
+      const vertex = paths.indices[i];
+      validateContourVertex(paths, vertex, paths.levelIndices[p], assignments);
+      if (i > start) {
+        const previous = paths.indices[i - 1];
+        if (paths.positions[3 * previous] === paths.positions[3 * vertex] && paths.positions[3 * previous + 1] === paths.positions[3 * vertex + 1])
+          throw new Error("Degenerate terrain contour path edge");
+      }
+      if (closed && i === end - 1)
+        continue;
+      if (seen.has(vertex))
+        throw new Error("Repeated interior terrain contour path vertex");
+      seen.add(vertex);
+      uses[vertex]++;
+    }
+  }
+  const keep = new Uint8Array(paths.indices.length);
+  let distanceTests = 0, maxDeviation = 0;
+  for (let p = 0; p < pathCount; p++) {
+    const start = paths.offsets[p], end = paths.offsets[p + 1] - 1;
+    keep[start] = keep[end] = 1;
+    if (paths.closed[p]) {
+      keep[start + Math.floor((end - start) / 3)] = 1;
+      keep[start + Math.floor(2 * (end - start) / 3)] = 1;
+    }
+    for (let i = start; i <= end; i++)
+      if (uses[paths.indices[i]] > 1)
+        keep[i] = 1;
+    const stack = [];
+    let previous = start;
+    for (let i = start + 1; i <= end; i++)
+      if (keep[i]) {
+        stack.push(previous, i);
+        previous = i;
+      }
+    while (stack.length) {
+      const b = stack.pop(), a = stack.pop();
+      let farthest = -1, maximum = 0;
+      for (let i = a + 1; i < b; i++) {
+        if (distanceTests++ === budget)
+          throw new Error("Terrain contour simplification work budget exceeded");
+        const distance = pointSegmentDistance(paths.positions, paths.indices[i], paths.indices[a], paths.indices[b]);
+        if (distance > maximum) {
+          maximum = distance;
+          farthest = i;
+        }
+      }
+      const va = paths.indices[a], vb = paths.indices[b];
+      const collapsed = paths.positions[3 * va] === paths.positions[3 * vb] && paths.positions[3 * va + 1] === paths.positions[3 * vb + 1];
+      if (maximum > options.maxError || collapsed && farthest >= 0) {
+        keep[farthest] = 1;
+        stack.push(a, farthest, farthest, b);
+      } else
+        maxDeviation = Math.max(maxDeviation, maximum);
+    }
+  }
+  const selected = new Uint8Array(count);
+  for (let i = 0; i < keep.length; i++)
+    if (keep[i])
+      selected[paths.indices[i]] = 1;
+  const vertices = [];
+  for (let i = 0; i < count; i++)
+    if (selected[i])
+      vertices.push(i);
+  const mapping = new Uint32Array(count), positions = new Float64Array(vertices.length * 3), gridCoordinates = new Float64Array(vertices.length * 2);
+  for (let i = 0; i < vertices.length; i++) {
+    const source = vertices[i];
+    mapping[source] = i;
+    positions.set(paths.positions.subarray(3 * source, 3 * source + 3), 3 * i);
+    gridCoordinates.set(paths.gridCoordinates.subarray(2 * source, 2 * source + 2), 2 * i);
+  }
+  const indices = [], offsets = [0];
+  for (let p = 0; p < pathCount; p++) {
+    for (let i = paths.offsets[p]; i < paths.offsets[p + 1]; i++)
+      if (keep[i])
+        indices.push(mapping[paths.indices[i]]);
+    offsets.push(indices.length);
+  }
+  return {
+    positions,
+    gridCoordinates,
+    indices: Uint32Array.from(indices),
+    offsets: Uint32Array.from(offsets),
+    levelIndices: paths.levelIndices.slice(),
+    closed: paths.closed.slice(),
+    levels: paths.levels.slice(),
+    origin: Object.freeze([...paths.origin]),
+    heightReference: paths.heightReference,
+    sourceVertexIndices: Uint32Array.from(vertices),
+    requestedMaxError: options.maxError,
+    maxDeviation,
+    distanceTests
+  };
+}
+function pointSegmentDistance(positions, p, a, b) {
+  const dx = positions[3 * b] - positions[3 * a], dy = positions[3 * b + 1] - positions[3 * a + 1];
+  const px = positions[3 * p] - positions[3 * a], py = positions[3 * p + 1] - positions[3 * a + 1];
+  const length = Math.hypot(dx, dy);
+  if (!Number.isFinite(length) || !Number.isFinite(px) || !Number.isFinite(py))
+    throw new Error("Terrain contour distance arithmetic overflow");
+  const projection = length ? px * (dx / length) + py * (dy / length) : 0;
+  const t = length ? Math.max(0, Math.min(1, projection / length)) : 0;
+  const distance = Math.hypot(px - dx * t, py - dy * t);
+  if (!Number.isFinite(distance))
+    throw new Error("Terrain contour distance arithmetic overflow");
+  return distance;
+}
+
+// dist/terrain/profile-measure.js
+function measureTerrainProfile(profile, options = {}) {
+  const limit = options.maxSamples ?? 1e6;
+  if (!Number.isSafeInteger(limit) || limit < 0 || !(profile.distances instanceof Float64Array) || profile.distances.length < 1 || profile.distances.length > limit)
+    throw new Error("Invalid terrain profile sample capacity");
+  const count = profile.distances.length;
+  if (!(profile.positions instanceof Float64Array) || profile.positions.length !== 2 * count || !profile.positions.every(Number.isFinite) || !(profile.heights instanceof Float64Array) || profile.heights.length !== count || !(profile.statuses instanceof Uint8Array) || profile.statuses.length !== count)
+    throw new Error("Invalid terrain profile buffers");
+  if (!Number.isFinite(profile.length) || profile.length < 0 || profile.distances[0] !== 0 || profile.distances[count - 1] !== profile.length)
+    throw new Error("Invalid terrain profile stationing");
+  let validSampleCount = 0, minimum = Infinity, maximum = -Infinity, coveredSegmentCount = 0, missingSegmentCount = 0;
+  let meanHeight = 0;
+  const sums = new Float64Array(6), corrections = new Float64Array(6);
+  const add = (index, value) => {
+    const y = value - corrections[index], next = sums[index] + y;
+    if (!Number.isFinite(value) || !Number.isFinite(next))
+      throw new Error("Terrain profile measurement arithmetic overflow");
+    corrections[index] = next - sums[index] - y;
+    sums[index] = next;
+  };
+  for (let i = 0; i < count; i++) {
+    const distance = profile.distances[i], status = profile.statuses[i], height = profile.heights[i];
+    if (!Number.isFinite(distance) || i > 0 && distance <= profile.distances[i - 1])
+      throw new Error("Invalid terrain profile stationing");
+    if (status > TerrainSampleStatus.NOT_RESIDENT)
+      throw new Error("Invalid terrain profile status");
+    if (status === TerrainSampleStatus.VALID) {
+      if (!Number.isFinite(height))
+        throw new Error("Invalid terrain profile height");
+      validSampleCount++;
+      minimum = Math.min(minimum, height);
+      maximum = Math.max(maximum, height);
+    }
+    if (i === 0)
+      continue;
+    const ds = distance - profile.distances[i - 1];
+    if (status !== TerrainSampleStatus.VALID || profile.statuses[i - 1] !== TerrainSampleStatus.VALID) {
+      missingSegmentCount++;
+      add(1, ds);
+      continue;
+    }
+    coveredSegmentCount++;
+    const previousCovered = sums[0];
+    add(0, ds);
+    const previous = profile.heights[i - 1], dh = height - previous;
+    add(dh >= 0 ? 2 : 3, Math.abs(dh));
+    add(4, Math.hypot(ds, dh));
+    const average = previous + dh / 2;
+    add(5, average * ds);
+    if (previousCovered === 0)
+      meanHeight = average;
+    else {
+      const newWeight = ds / sums[0];
+      const delta = average - meanHeight;
+      meanHeight = Number.isFinite(delta) ? newWeight <= 0.5 ? meanHeight + weighted(delta, ds, sums[0]) : average - weighted(delta, previousCovered, sums[0]) : weighted(meanHeight, previousCovered, sums[0]) + weighted(average, ds, sums[0]);
+      if (!Number.isFinite(meanHeight))
+        throw new Error("Terrain profile measurement arithmetic overflow");
+    }
+  }
+  return {
+    length: profile.length,
+    coveredLength: sums[0],
+    missingLength: sums[1],
+    coveredSegmentCount,
+    missingSegmentCount,
+    validSampleCount,
+    minimumHeight: validSampleCount ? minimum : void 0,
+    maximumHeight: validSampleCount ? maximum : void 0,
+    ascent: sums[2],
+    descent: sums[3],
+    surfaceLength: sums[4],
+    heightIntegral: sums[5],
+    meanHeight: sums[0] ? meanHeight : void 0,
+    complete: validSampleCount === count
+  };
+}
+function weighted(value, part, total) {
+  const ratio = part / total;
+  if (ratio < Number.MIN_VALUE / Number.EPSILON) {
+    const product = value * part;
+    if (Number.isFinite(product) && product !== 0)
+      return product / total;
+  }
+  return value * ratio;
+}
+
+// dist/terrain/vertex-tiles.js
+function reconcileTerrainVertexTiles(tiles, options) {
+  const { width, height } = options;
+  const maxTiles = options.maxTiles ?? 4096, maxSamples = options.maxSamples ?? 4e6;
+  const tolerance = options.maxHeightDifference ?? 0;
+  if (![width, height, maxTiles, maxSamples].every(Number.isSafeInteger) || width < 2 || height < 2 || maxTiles < 0 || maxSamples < 0 || tiles.length > maxTiles || !Number.isSafeInteger(width * height * tiles.length) || width * height * tiles.length > maxSamples || !Number.isFinite(tolerance) || tolerance < 0)
+    throw new Error("Invalid vertex tile dimensions, capacity or height tolerance");
+  const origin = options.origin ?? [0, 0], columnStep = options.columnStep ?? [1, 0], rowStep = options.rowStep ?? [0, 1];
+  for (const vector of [origin, columnStep, rowStep])
+    if (vector.length !== 2 || !vector.every(Number.isFinite))
+      throw new Error("Invalid vertex tile transform");
+  const determinant = columnStep[0] * rowStep[1] - columnStep[1] * rowStep[0];
+  if (!Number.isFinite(determinant) || Math.abs(determinant) <= Number.EPSILON * Math.hypot(...columnStep) * Math.hypot(...rowStep))
+    throw new Error("Singular vertex tile transform");
+  const heightReference = options.heightReference ?? "unknown";
+  if (typeof heightReference !== "string")
+    throw new Error("Invalid vertex tile height reference");
+  const sorted = [...tiles].sort((a, b) => a.column - b.column || a.row - b.row);
+  const seen = /* @__PURE__ */ new Set();
+  const shared = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const tile of sorted) {
+    const key = `${tile.column},${tile.row}`;
+    if (!Number.isSafeInteger(tile.column) || !Number.isSafeInteger(tile.row) || seen.has(key))
+      throw new Error("Invalid or duplicate vertex tile address");
+    seen.add(key);
+    const x = tile.column * (width - 1), y = tile.row * (height - 1);
+    if (![x, y, x + width - 1, y + height - 1].every(Number.isSafeInteger))
+      throw new Error("Vertex tile lattice overflow");
+    if (!(tile.heights instanceof Float32Array || tile.heights instanceof Float64Array) || tile.heights.length !== width * height || tile.validity !== void 0 && (!(tile.validity instanceof Uint8Array) || tile.validity.length !== width * height))
+      throw new Error("Invalid vertex tile buffers");
+    const heights = Float64Array.from(tile.heights), validity = new Uint8Array(heights.length);
+    const tileOrigin = [
+      origin[0] + x * columnStep[0] + y * rowStep[0],
+      origin[1] + x * columnStep[1] + y * rowStep[1]
+    ];
+    if (!tileOrigin.every(Number.isFinite))
+      throw new Error("Vertex tile coordinate overflow");
+    const index = result.length;
+    result.push({
+      column: tile.column,
+      row: tile.row,
+      field: {
+        width,
+        height,
+        heights,
+        validity,
+        origin: tileOrigin,
+        columnStep: [...columnStep],
+        rowStep: [...rowStep],
+        registration: "vertex",
+        heightReference
+      }
+    });
+    for (let r = 0; r < height; r++)
+      for (let c = 0; c < width; c++) {
+        const i = r * width + c, valid = Number.isFinite(heights[i]) && (!tile.validity || tile.validity[i] !== 0);
+        validity[i] = Number(valid);
+        if (!valid)
+          heights[i] = 0;
+        if (r !== 0 && c !== 0 && r !== height - 1 && c !== width - 1)
+          continue;
+        const address = `${x + c},${y + r}`;
+        let vertex = shared.get(address);
+        if (!vertex) {
+          vertex = {
+            height: heights[i],
+            valid,
+            min: valid ? heights[i] : Infinity,
+            max: valid ? heights[i] : -Infinity,
+            copies: []
+          };
+          shared.set(address, vertex);
+        } else {
+          vertex.valid && (vertex.valid = valid);
+          if (valid) {
+            vertex.min = Math.min(vertex.min, heights[i]);
+            vertex.max = Math.max(vertex.max, heights[i]);
+          }
+        }
+        vertex.copies.push([index, i]);
+      }
+  }
+  let sharedVertices = 0, maxHeightDifference = 0;
+  for (const vertex of shared.values()) {
+    if (vertex.copies.length < 2)
+      continue;
+    sharedVertices++;
+    const difference2 = vertex.min === Infinity ? 0 : vertex.max - vertex.min;
+    if (!Number.isFinite(difference2) || difference2 > tolerance)
+      throw new Error("Shared vertex height disagreement exceeds tolerance");
+    maxHeightDifference = Math.max(maxHeightDifference, difference2);
+    for (const [tile, i] of vertex.copies) {
+      result[tile].field.heights[i] = vertex.valid ? vertex.height : 0;
+      result[tile].field.validity[i] = Number(vertex.valid);
+    }
+  }
+  return { tiles: result, sharedVertices, maxHeightDifference };
+}
+
+// dist/terrain/mesh-stitch.js
+function stitchTerrainMeshEdges(a, edgeA, b, edgeB, options = {}) {
+  const maxVertices = options.maxVertices ?? 2e6, maxTriangles = options.maxTriangles ?? 4e6, maxBoundary = options.maxBoundaryVertices ?? 1e5;
+  const tolerance = options.coordinateTolerance ?? 1e-8, heightLimit = options.maxHeightAdjustment ?? 0;
+  if (![maxVertices, maxTriangles, maxBoundary].every((n) => Number.isSafeInteger(n) && n >= 0 && n <= 4294967294) || !Number.isFinite(tolerance) || tolerance < 0 || !Number.isFinite(heightLimit) || heightLimit < 0)
+    throw new Error("Invalid terrain stitching limits");
+  const prepare = (mesh, side, range) => {
+    if (range.length !== 2 || !range.every(Number.isFinite) || range[0] < 0 || range[1] > 1 || range[1] <= range[0])
+      throw new Error("Invalid stitching side range");
+    if (!["minColumn", "maxColumn", "minRow", "maxRow"].includes(side) || !Number.isSafeInteger(mesh.width) || !Number.isSafeInteger(mesh.height) || mesh.width < 2 || mesh.height < 2 || !(mesh.positions instanceof Float64Array) || mesh.positions.length % 3 || mesh.positions.length / 3 > maxVertices || !(mesh.indices instanceof Uint32Array) || mesh.indices.length % 3 || mesh.indices.length / 3 > maxTriangles || !(mesh.gridCoordinates instanceof Float64Array || mesh.gridCoordinates instanceof Uint32Array) || mesh.gridCoordinates.length !== mesh.positions.length / 3 * 2 || mesh.origin.length !== 3 || !mesh.origin.every(Number.isFinite) || !mesh.positions.every(Number.isFinite) || typeof mesh.heightReference !== "string")
+      throw new Error("Invalid terrain stitching mesh");
+    const positions = mesh.positions.slice();
+    for (let i = 0; i < positions.length; i++)
+      positions[i] += mesh.origin[i % 3] - a.origin[i % 3];
+    if (!positions.every(Number.isFinite))
+      throw new Error("Terrain stitching coordinate overflow");
+    const axis = side.endsWith("Column") ? 0 : 1, extent = axis ? mesh.height - 1 : mesh.width - 1, along = axis ? mesh.width - 1 : mesh.height - 1;
+    const value = side.startsWith("min") ? 0 : extent;
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < mesh.gridCoordinates.length; i += 2)
+      if (!Number.isFinite(mesh.gridCoordinates[i]) || !Number.isFinite(mesh.gridCoordinates[i + 1]) || mesh.gridCoordinates[i] < 0 || mesh.gridCoordinates[i] > mesh.width - 1 || mesh.gridCoordinates[i + 1] < 0 || mesh.gridCoordinates[i + 1] > mesh.height - 1)
+        throw new Error("Invalid stitching grid coordinates");
+    for (let i = 0; i < mesh.indices.length; i += 3) {
+      const ids2 = [mesh.indices[i], mesh.indices[i + 1], mesh.indices[i + 2]];
+      for (const id of ids2) {
+        if (id >= positions.length / 3)
+          throw new Error("Stitching index out of range");
+        if (mesh.gridCoordinates[2 * id + axis] === value)
+          used.add(id);
+      }
+      const [p, q, r] = ids2.map((id) => id * 3);
+      const area = (positions[q] - positions[p]) * (positions[r + 1] - positions[p + 1]) - (positions[q + 1] - positions[p + 1]) * (positions[r] - positions[p]);
+      if (!Number.isFinite(area) || area <= 0)
+        throw new Error("Stitching requires positive nondegenerate XY triangles");
+    }
+    if (used.size < 2 || used.size > maxBoundary)
+      throw new Error("Invalid stitching boundary capacity");
+    const ids = [...used].sort((u, v) => mesh.gridCoordinates[2 * u + 1 - axis] - mesh.gridCoordinates[2 * v + 1 - axis]);
+    const ts2 = ids.map((id) => mesh.gridCoordinates[2 * id + 1 - axis] / along);
+    if (ts2[0] !== 0 || ts2[ts2.length - 1] !== 1 || ts2.some((t, i) => i > 0 && t <= ts2[i - 1]))
+      throw new Error("Stitching requires a complete unique side");
+    const pairs = /* @__PURE__ */ new Map();
+    for (let i = 1; i < ids.length; i++)
+      pairs.set(pair(ids[i - 1], ids[i]), 0);
+    let direction = 0;
+    for (let i = 0; i < mesh.indices.length; i += 3)
+      for (let j = 0; j < 3; j++) {
+        const u = mesh.indices[i + j], v = mesh.indices[i + (j + 1) % 3], key = pair(u, v);
+        if (pairs.has(key)) {
+          pairs.set(key, pairs.get(key) + 1);
+          const nextDirection = Math.sign(mesh.gridCoordinates[2 * v + 1 - axis] - mesh.gridCoordinates[2 * u + 1 - axis]);
+          if (direction && direction !== nextDirection)
+            throw new Error("Inconsistent stitching boundary orientation");
+          direction = nextDirection;
+        } else if (used.has(u) && used.has(v))
+          throw new Error("Nonconforming input boundary");
+      }
+    if ([...pairs.values()].some((count) => count !== 1))
+      throw new Error("Stitching boundary has holes or nonmanifold edges");
+    return {
+      mesh,
+      positions,
+      ids,
+      ts: ts2.map((t) => (t - range[0]) / (range[1] - range[0])),
+      axis,
+      along,
+      value,
+      direction,
+      range
+    };
+  };
+  const pa = prepare(a, edgeA, options.rangeA ?? [0, 1]), pb = prepare(b, edgeB, options.rangeB ?? [0, 1]);
+  if (a.heightReference !== b.heightReference)
+    throw new Error("Stitching height references differ");
+  const endpoint = (p, t) => {
+    let i = 0;
+    while (i + 1 < p.ts.length - 1 && t > p.ts[i + 1])
+      i++;
+    const f = (t - p.ts[i]) / (p.ts[i + 1] - p.ts[i]);
+    return [0, 1, 2].map((k) => {
+      const z0 = p.positions[3 * p.ids[i] + k], z1 = p.positions[3 * p.ids[i + 1] + k];
+      return f === 0 ? z0 : f === 1 ? z1 : z0 + (z1 - z0) * f;
+    });
+  };
+  const first = endpoint(pa, 0), last = endpoint(pa, 1);
+  const xyDistance = (p, q) => Math.hypot(p[0] - q[0], p[1] - q[1]);
+  const reversed = xyDistance(first, endpoint(pb, 0)) > tolerance;
+  if (reversed) {
+    pb.ids.reverse();
+    pb.ts = pb.ts.reverse().map((t) => 1 - t);
+    pb.direction *= -1;
+  }
+  const canonicalize = (values, anchors) => {
+    let cursor = 0;
+    const result = values.map((t) => {
+      while (cursor + 1 < anchors.length && anchors[cursor + 1] <= t)
+        cursor++;
+      let nearest = anchors[cursor];
+      if (cursor + 1 < anchors.length && Math.abs(anchors[cursor + 1] - t) < Math.abs(nearest - t))
+        nearest = anchors[cursor + 1];
+      return Math.abs(t - nearest) <= 8 * Number.EPSILON * Math.max(1, Math.abs(t)) ? nearest : t;
+    });
+    if (result.some((t, i) => i > 0 && t <= result[i - 1]))
+      throw new Error("Stitching knots are numerically indistinguishable");
+    return result;
+  };
+  pa.ts = canonicalize(pa.ts, [0, 1]);
+  pb.ts = canonicalize(pb.ts, [.../* @__PURE__ */ new Set([0, 1, ...pa.ts])].sort((x, y) => x - y));
+  if (xyDistance(first, endpoint(pb, 0)) > tolerance || xyDistance(last, endpoint(pb, 1)) > tolerance || pa.direction === pb.direction)
+    throw new Error("Stitching sides must coincide and have opposite interiors");
+  const startX = first[0], startY = first[1], dx = last[0] - startX, dy = last[1] - startY;
+  if (!Number.isFinite(Math.hypot(dx, dy)) || Math.hypot(dx, dy) === 0)
+    throw new Error("Invalid stitching side length");
+  for (const p of [pa, pb])
+    for (let i = 0; i < p.ids.length; i++)
+      if (Math.hypot(p.positions[3 * p.ids[i]] - (startX + dx * p.ts[i]), p.positions[3 * p.ids[i] + 1] - (startY + dy * p.ts[i])) > tolerance)
+        throw new Error("Stitching requires straight affine sides");
+  const ts = [...new Set([0, 1, ...pa.ts, ...pb.ts].filter((t) => t >= 0 && t <= 1))].sort((u, v) => u - v);
+  if (ts.length > maxBoundary)
+    throw new Error("Stitching boundary capacity exceeded");
+  const xyz = new Float64Array(ts.length * 3);
+  let segment = 0, maxHeightAdjustment = 0;
+  for (let i = 0; i < ts.length; i++) {
+    while (segment + 1 < pa.ts.length - 1 && ts[i] > pa.ts[segment + 1])
+      segment++;
+    const fraction = (ts[i] - pa.ts[segment]) / (pa.ts[segment + 1] - pa.ts[segment]);
+    for (let k = 0; k < 3; k++) {
+      const v0 = pa.positions[3 * pa.ids[segment] + k], v1 = pa.positions[3 * pa.ids[segment + 1] + k];
+      xyz[3 * i + k] = fraction === 0 ? v0 : fraction === 1 ? v1 : v0 + (v1 - v0) * fraction;
+    }
+  }
+  if (!xyz.every(Number.isFinite))
+    throw new Error("Stitching interpolation overflow");
+  segment = 0;
+  for (let i = 0; i < ts.length; i++) {
+    while (segment + 1 < pb.ts.length - 1 && ts[i] > pb.ts[segment + 1])
+      segment++;
+    const t = (ts[i] - pb.ts[segment]) / (pb.ts[segment + 1] - pb.ts[segment]);
+    const z0 = pb.positions[3 * pb.ids[segment] + 2], z1 = pb.positions[3 * pb.ids[segment + 1] + 2];
+    const z = t === 0 ? z0 : t === 1 ? z1 : z0 + (z1 - z0) * t;
+    const adjustment = Math.abs(z - xyz[3 * i + 2]);
+    if (!Number.isFinite(adjustment) || adjustment > heightLimit)
+      throw new Error("Stitching height adjustment exceeds limit");
+    maxHeightAdjustment = Math.max(maxHeightAdjustment, adjustment);
+  }
+  const rebuild = (p, reverse) => {
+    const lookup = new Map(p.ts.map((t, i) => [t, p.ids[i]]));
+    const added = ts.filter((t) => !lookup.has(t)).length;
+    if (p.ids.length + added > maxBoundary)
+      throw new Error("Stitching output boundary capacity exceeded");
+    if (p.positions.length / 3 + added > maxVertices || p.mesh.indices.length / 3 + added > maxTriangles)
+      throw new Error("Stitching output capacity exceeded");
+    const positions = new Float64Array(p.positions.length + 3 * added), gridCoordinates = new Float64Array(p.mesh.gridCoordinates.length + 2 * added);
+    positions.set(p.positions);
+    gridCoordinates.set(p.mesh.gridCoordinates);
+    const seam = new Uint32Array(ts.length);
+    let next = p.positions.length / 3;
+    for (let i = 0; i < ts.length; i++) {
+      const existing = lookup.get(ts[i]), id = existing ?? next++;
+      positions.set(xyz.subarray(3 * i, 3 * i + 3), 3 * id);
+      if (existing === void 0) {
+        gridCoordinates[2 * id + p.axis] = p.value;
+        gridCoordinates[2 * id + 1 - p.axis] = (p.range[0] + (reverse ? 1 - ts[i] : ts[i]) * (p.range[1] - p.range[0])) * p.along;
+      }
+      seam[i] = id;
+      lookup.set(ts[i], id);
+    }
+    const splits = /* @__PURE__ */ new Map();
+    const allTs = [...lookup.keys()].sort((x, y) => x - y);
+    let cursor = 0;
+    for (let i = 1; i < p.ids.length; i++) {
+      const list = [lookup.get(allTs[cursor++])];
+      while (cursor < allTs.length && allTs[cursor] <= p.ts[i])
+        list.push(lookup.get(allTs[cursor++]));
+      cursor--;
+      splits.set(pair(p.ids[i - 1], p.ids[i]), list);
+    }
+    const indices = [];
+    for (let i = 0; i < p.mesh.indices.length; i += 3) {
+      let split = false;
+      for (let j = 0; j < 3; j++) {
+        const u = p.mesh.indices[i + j], v = p.mesh.indices[i + (j + 1) % 3], w = p.mesh.indices[i + (j + 2) % 3];
+        const list = splits.get(pair(u, v));
+        if (!list || list.length === 2)
+          continue;
+        const ordered = list[0] === u ? list : [...list].reverse();
+        for (let k = 1; k < ordered.length; k++)
+          indices.push(ordered[k - 1], ordered[k], w);
+        split = true;
+        break;
+      }
+      if (!split)
+        indices.push(p.mesh.indices[i], p.mesh.indices[i + 1], p.mesh.indices[i + 2]);
+    }
+    for (let i = 0; i < indices.length; i += 3) {
+      const [u, v, w] = indices.slice(i, i + 3).map((id) => id * 3);
+      const area = (positions[v] - positions[u]) * (positions[w + 1] - positions[u + 1]) - (positions[v + 1] - positions[u + 1]) * (positions[w] - positions[u]);
+      if (!Number.isFinite(area) || area <= 0)
+        throw new Error("Stitching produced a degenerate or inverted triangle");
+    }
+    return {
+      mesh: {
+        positions,
+        gridCoordinates,
+        indices: Uint32Array.from(indices),
+        width: p.mesh.width,
+        height: p.mesh.height,
+        origin: Object.freeze([...a.origin]),
+        heightReference: a.heightReference
+      },
+      seam
+    };
+  };
+  const ra = rebuild(pa, false), rb = rebuild(pb, reversed);
+  return { a: ra.mesh, b: rb.mesh, seamA: ra.seam, seamB: rb.seam, maxHeightAdjustment };
+}
+function pair(a, b) {
+  return a < b ? `${a},${b}` : `${b},${a}`;
+}
+//# sourceMappingURL=index.cjs.map