@threenative/core 0.2.0 → 0.3.1

package/dist/world.js

@@ -0,0 +1,2686 @@
+import { Object3D, Vector3, LOD, Group, BufferGeometry, BufferAttribute, Mesh } from 'three';
+import { instancedArray, Fn, If, instanceIndex, Return, vec4, min, max, float, clamp, uint, atomicLoad, atomicAdd, log } from 'three/tsl';
+
+// src/world.ts
+
+// src/gpu-readback.ts
+var GPUReadback = class {
+  everyFrames;
+  #attribute;
+  /** Frames observed through `request()`. The clock every other number here is measured against. */
+  #frame = 0;
+  /** The frame whose GPU state the landed bytes hold, or `-1` when nothing has landed. */
+  #sampleFrame = -1;
+  /** The frame the in-flight request was issued on, or `-1` when none is in flight. */
+  #requestedFrame = -1;
+  #pending = false;
+  #data;
+  #requests = 0;
+  #lands = 0;
+  #failures = 0;
+  #released = false;
+  constructor(options) {
+    if (options.attribute === void 0 || options.attribute === null)
+      throw new Error("GPUReadback.attribute is required.");
+    if (!Number.isInteger(options.everyFrames) || options.everyFrames <= 0)
+      throw new Error("GPUReadback.everyFrames must be a positive integer.");
+    this.#attribute = options.attribute;
+    this.everyFrames = options.everyFrames;
+  }
+  get released() {
+    return this.#released;
+  }
+  /** True while a copy is in flight. A game that wants to pace its own work can read it. */
+  get pending() {
+    return this.#pending;
+  }
+  /** The newest landed bytes, or `undefined` before the first copy lands. */
+  get data() {
+    return this.#data;
+  }
+  /**
+   * How many frames old the landed bytes are.
+   *
+   * Before anything has landed this is the number of frames since construction, which grows
+   * without bound on purpose: "no data yet" and "data from frame zero" must not read the same.
+   */
+  get staleFrames() {
+    if (this.#sampleFrame < 0) return this.#frame;
+    return this.#frame - this.#sampleFrame;
+  }
+  /** The newest bytes with their age attached, or `undefined` before the first copy lands. */
+  get sample() {
+    if (this.#data === void 0) return void 0;
+    return { data: this.#data, staleFrames: this.staleFrames };
+  }
+  /** Requests, landings and failures, for a report that has to say why a sample is old. */
+  get stats() {
+    return { requests: this.#requests, lands: this.#lands, failures: this.#failures };
+  }
+  /**
+   * Advances the frame clock and starts a copy when the throttle allows one.
+   *
+   * Safe to call every frame. It returns before the GPU has answered — awaiting it is the one
+   * thing that would turn this class into the stall it exists to avoid.
+   */
+  request(renderer) {
+    if (this.#released) throw new Error("GPUReadback cannot request after release.");
+    this.#frame += 1;
+    if (this.#pending) return;
+    if (this.#requestedFrame >= 0 && this.#frame - this.#requestedFrame < this.everyFrames) return;
+    const issuedFrame = this.#frame;
+    this.#requestedFrame = issuedFrame;
+    this.#pending = true;
+    this.#requests += 1;
+    renderer.readback(this.#attribute).then((bytes) => this.#land(bytes, issuedFrame)).catch(() => this.#fail());
+  }
+  #land(bytes, issuedFrame) {
+    this.#pending = false;
+    if (this.#released) return;
+    this.#data = new Float32Array(bytes);
+    this.#sampleFrame = issuedFrame;
+    this.#lands += 1;
+  }
+  #fail() {
+    this.#pending = false;
+    if (this.#released) return;
+    this.#failures += 1;
+  }
+  /** Drops the attribute reference and the landed bytes. Further requests throw. */
+  dispose() {
+    if (this.#released) return;
+    this.#released = true;
+    this.#pending = false;
+    this.#attribute = void 0;
+    this.#data = void 0;
+  }
+};
+function finite(name, value, minimum = 0) {
+  if (!Number.isFinite(value) || value < minimum)
+    throw new Error(`World passes ${name} must be finite and at least ${minimum}.`);
+  return value;
+}
+function gridCount(name, value) {
+  if (!Number.isInteger(value) || value < 2)
+    throw new Error(`World passes ${name} must be an integer of at least 2.`);
+  return value;
+}
+var CARDINAL = [
+  [-1, 0],
+  [1, 0],
+  [0, -1],
+  [0, 1]
+];
+function neighbourIndex(index, direction, rows, columns) {
+  const pair = CARDINAL[direction];
+  if (pair === void 0) return void 0;
+  const column = index % columns + pair[0];
+  const row = Math.floor(index / columns) + pair[1];
+  if (column < 0 || column >= columns || row < 0 || row >= rows) return void 0;
+  return row * columns + column;
+}
+function simulateWorldPassesCpu(options) {
+  const rows = gridCount("rows", options.rows);
+  const columns = gridCount("columns", options.columns);
+  const count2 = rows * columns;
+  if (options.heights.length !== count2)
+    throw new Error(`World passes expected ${count2} heights, received ${options.heights.length}.`);
+  const cellWidth = finite("cellWidth", options.cellWidth, Number.EPSILON);
+  const cellDepth = finite("cellDepth", options.cellDepth, Number.EPSILON);
+  const tuning = options.erosion;
+  if (!Number.isInteger(tuning.iterations) || tuning.iterations < 0)
+    throw new Error("World passes iterations must be a non-negative integer.");
+  const rainfall = finite("rainfall", tuning.rainfall);
+  const evaporation = finite("evaporation", tuning.evaporation);
+  if (evaporation > 1) throw new Error("World passes evaporation must not exceed 1.");
+  const timeStep = finite("timeStep", tuning.timeStep, Number.EPSILON);
+  const sedimentCapacity = finite("sedimentCapacity", tuning.sedimentCapacity);
+  const erosionRate = finite("erosionRate", tuning.erosionRate);
+  const depositionRate = finite("depositionRate", tuning.depositionRate);
+  let heights = options.heights.slice();
+  for (const height2 of heights) finite("height sample", height2, Number.NEGATIVE_INFINITY);
+  let water = new Float32Array(count2);
+  let sediment = new Float32Array(count2);
+  const outflow = new Float32Array(count2 * CARDINAL.length);
+  for (let iteration = 0; iteration < tuning.iterations; iteration += 1) {
+    outflow.fill(0);
+    for (let index = 0; index < count2; index += 1) {
+      water[index] = water[index] + rainfall * timeStep;
+      const head = heights[index] + water[index];
+      let totalDrop = 0;
+      const drops = [0, 0, 0, 0];
+      for (let direction = 0; direction < CARDINAL.length; direction += 1) {
+        const neighbour = neighbourIndex(index, direction, rows, columns);
+        if (neighbour === void 0) continue;
+        const drop = Math.max(
+          0,
+          head - (heights[neighbour] + water[neighbour])
+        );
+        drops[direction] = drop;
+        totalDrop += drop;
+      }
+      if (totalDrop === 0) continue;
+      const available = Math.min(water[index], totalDrop * timeStep);
+      for (let direction = 0; direction < CARDINAL.length; direction += 1)
+        outflow[index * CARDINAL.length + direction] = available * (drops[direction] / totalDrop);
+    }
+    const nextWater = new Float32Array(count2);
+    const nextSediment = new Float32Array(count2);
+    const nextHeights = heights.slice();
+    for (let index = 0; index < count2; index += 1) {
+      let incomingWater = 0;
+      let outgoingWater = 0;
+      for (let direction = 0; direction < CARDINAL.length; direction += 1) {
+        outgoingWater += outflow[index * CARDINAL.length + direction];
+        const neighbour = neighbourIndex(index, direction, rows, columns);
+        if (neighbour === void 0) continue;
+        incomingWater += outflow[neighbour * CARDINAL.length + (direction ^ 1)];
+      }
+      const remainingWater = Math.max(
+        0,
+        (water[index] + incomingWater - outgoingWater) * (1 - evaporation * timeStep)
+      );
+      nextWater[index] = remainingWater;
+      const speed = outgoingWater / (timeStep * Math.min(cellWidth, cellDepth));
+      const capacity = sedimentCapacity * speed * outgoingWater;
+      let localSediment = sediment[index];
+      if (localSediment < capacity) {
+        const eroded = Math.min(
+          capacity - localSediment,
+          (capacity - localSediment) * erosionRate * timeStep
+        );
+        nextHeights[index] = nextHeights[index] - eroded;
+        localSediment += eroded;
+      } else {
+        const deposited = (localSediment - capacity) * depositionRate * timeStep;
+        nextHeights[index] = nextHeights[index] + deposited;
+        localSediment -= deposited;
+      }
+      const transported = Math.min(localSediment, localSediment * outgoingWater);
+      nextSediment[index] = nextSediment[index] + localSediment - transported;
+      if (outgoingWater === 0) continue;
+      for (let direction = 0; direction < CARDINAL.length; direction += 1) {
+        const neighbour = neighbourIndex(index, direction, rows, columns);
+        const amount = outflow[index * CARDINAL.length + direction];
+        if (neighbour !== void 0)
+          nextSediment[neighbour] = nextSediment[neighbour] + transported * (amount / outgoingWater);
+      }
+    }
+    heights = nextHeights;
+    water = nextWater;
+    sediment = nextSediment;
+  }
+  const flow = accumulateFlow(heights, rows, columns);
+  const moisture = new Float32Array(count2);
+  for (let index = 0; index < count2; index += 1)
+    moisture[index] = Math.min(
+      1,
+      flow[index] * 0.7 + Math.min(1, Math.max(0, water[index])) * 0.3
+    );
+  return { flow, heights, moisture };
+}
+function accumulateFlow(heights, rows, columns) {
+  const targets = new Int32Array(heights.length);
+  targets.fill(-1);
+  const order = Array.from({ length: heights.length }, (_, index) => index).sort(
+    (a, b) => heights[b] - heights[a] || a - b
+  );
+  for (let source = 0; source < heights.length; source += 1) {
+    let destination = source;
+    let lowest = heights[source];
+    for (let direction = 0; direction < CARDINAL.length; direction += 1) {
+      const neighbour = neighbourIndex(source, direction, rows, columns);
+      if (neighbour === void 0) continue;
+      const candidate = heights[neighbour];
+      if (candidate < lowest) {
+        lowest = candidate;
+        destination = neighbour;
+      }
+    }
+    if (destination !== source) targets[source] = destination;
+  }
+  const accumulated = new Float64Array(heights.length);
+  accumulated.fill(1);
+  for (const source of order) {
+    const destination = targets[source];
+    if (destination >= 0)
+      accumulated[destination] = accumulated[destination] + accumulated[source];
+  }
+  const scale = Math.log1p(heights.length);
+  return Float32Array.from(accumulated, (value) => Math.log1p(value) / scale);
+}
+function computeNode(name, count2, body) {
+  const node = Fn(body)().compute(count2);
+  node.setName(name);
+  return node;
+}
+function createWorldGpuPasses(options) {
+  const rows = gridCount("rows", options.rows);
+  const columns = gridCount("columns", options.columns);
+  const count2 = rows * columns;
+  if (options.heights.length !== count2)
+    throw new Error(`World passes expected ${count2} heights, received ${options.heights.length}.`);
+  finite("cellWidth", options.cellWidth, Number.EPSILON);
+  finite("cellDepth", options.cellDepth, Number.EPSILON);
+  simulateWorldPassesCpu({ ...options, erosion: { ...options.erosion, iterations: 0 } });
+  const initial = instancedArray(options.heights, "float").toReadOnly();
+  const heightA = instancedArray(count2, "float");
+  const heightB = instancedArray(count2, "float");
+  const waterA = instancedArray(count2, "float");
+  const waterB = instancedArray(count2, "float");
+  const sedimentA = instancedArray(count2, "float");
+  const sedimentB = instancedArray(count2, "float");
+  const sedimentTemporary = instancedArray(count2, "float");
+  const outflow = instancedArray(count2, "vec4");
+  const flowAtomic = instancedArray(count2, "uint");
+  const flowFrontierA = instancedArray(count2, "uint");
+  const flowFrontierB = instancedArray(count2, "uint");
+  const flow = instancedArray(count2, "float");
+  const moisture = instancedArray(count2, "float");
+  const allStorage = [
+    initial,
+    heightA,
+    heightB,
+    waterA,
+    waterB,
+    sedimentA,
+    sedimentB,
+    sedimentTemporary,
+    outflow,
+    flowAtomic,
+    flowFrontierA,
+    flowFrontierB,
+    flow,
+    moisture
+  ];
+  const guard = (body) => Fn(() => {
+    If(instanceIndex.greaterThanEqual(count2), () => Return());
+    body();
+  })();
+  const at = (index, x, z) => {
+    const column = clamp(float(index.mod(columns)).add(x), 0, columns - 1).toInt();
+    const row = clamp(float(index.div(columns)).add(z), 0, rows - 1).toInt();
+    return row.mul(columns).add(column);
+  };
+  const synthesis = computeNode(
+    "world.synthesis",
+    count2,
+    () => guard(() => {
+      const index = instanceIndex.toInt();
+      heightA.element(index).assign(initial.element(index));
+      waterA.element(index).assign(0);
+      sedimentA.element(index).assign(0);
+      flowAtomic.element(index).assign(uint(1));
+      flowFrontierA.element(index).assign(uint(1));
+      flowFrontierB.element(index).assign(uint(0));
+    })
+  );
+  const erosionNodes = [];
+  const tuning = options.erosion;
+  const rain = tuning.rainfall * tuning.timeStep;
+  const makeIteration = (roles, iteration) => {
+    const flux = computeNode(
+      `world.erosion.${iteration}.flux`,
+      count2,
+      () => guard(() => {
+        const index = instanceIndex.toInt();
+        const water2 = roles.waterSource.element(index).add(rain);
+        const head = roles.heightSource.element(index).add(water2).toVar();
+        const drop = (x, z) => {
+          const neighbour = at(index, x, z);
+          return max(
+            0,
+            head.sub(
+              roles.heightSource.element(neighbour).add(roles.waterSource.element(neighbour)).add(rain)
+            )
+          );
+        };
+        const drops = vec4(drop(-1, 0), drop(1, 0), drop(0, -1), drop(0, 1)).toVar();
+        const totalDrop = drops.x.add(drops.y).add(drops.z).add(drops.w);
+        const available = min(water2, totalDrop.mul(tuning.timeStep));
+        const scale = available.div(max(totalDrop, 1e-6));
+        outflow.element(index).assign(drops.mul(scale));
+      })
+    );
+    const erode = computeNode(
+      `world.erosion.${iteration}.erode`,
+      count2,
+      () => guard(() => {
+        const index = instanceIndex.toInt();
+        const fluxValue = outflow.element(index).toVar();
+        const outgoing = fluxValue.x.add(fluxValue.y).add(fluxValue.z).add(fluxValue.w).toVar();
+        const incoming = outflow.element(at(index, -1, 0)).y.add(outflow.element(at(index, 1, 0)).x).add(outflow.element(at(index, 0, -1)).w).add(outflow.element(at(index, 0, 1)).z);
+        const water2 = max(
+          0,
+          roles.waterSource.element(index).add(rain).add(incoming).sub(outgoing).mul(1 - tuning.evaporation * tuning.timeStep)
+        );
+        roles.waterTarget.element(index).assign(water2);
+        const speed = outgoing.div(
+          tuning.timeStep * Math.min(options.cellWidth, options.cellDepth)
+        );
+        const capacity = float(tuning.sedimentCapacity).mul(speed).mul(outgoing);
+        const sediment = roles.sedimentSource.element(index).toVar();
+        const height3 = roles.heightSource.element(index).toVar();
+        If(sediment.lessThan(capacity), () => {
+          const amount = capacity.sub(sediment).mul(tuning.erosionRate * tuning.timeStep).min(capacity.sub(sediment));
+          height3.subAssign(amount);
+          sediment.addAssign(amount);
+        }).Else(() => {
+          const amount = sediment.sub(capacity).mul(tuning.depositionRate * tuning.timeStep);
+          height3.addAssign(amount);
+          sediment.subAssign(amount);
+        });
+        roles.heightTarget.element(index).assign(height3);
+        sedimentTemporary.element(index).assign(sediment);
+      })
+    );
+    const transport = computeNode(
+      `world.erosion.${iteration}.transport`,
+      count2,
+      () => guard(() => {
+        const index = instanceIndex.toInt();
+        const ownFlux = outflow.element(index).toVar();
+        const ownOut = ownFlux.x.add(ownFlux.y).add(ownFlux.z).add(ownFlux.w);
+        const retained = sedimentTemporary.element(index).mul(min(1, ownOut).oneMinus()).toVar();
+        const gather = (x, z, component) => {
+          const neighbour = at(index, x, z);
+          const neighbourFlux = outflow.element(neighbour).toVar();
+          const total = neighbourFlux.x.add(neighbourFlux.y).add(neighbourFlux.z).add(neighbourFlux.w);
+          return sedimentTemporary.element(neighbour).mul(min(1, total)).mul(neighbourFlux[component].div(max(total, 1e-6)));
+        };
+        retained.addAssign(gather(-1, 0, "y"));
+        retained.addAssign(gather(1, 0, "x"));
+        retained.addAssign(gather(0, -1, "w"));
+        retained.addAssign(gather(0, 1, "z"));
+        roles.sedimentTarget.element(index).assign(retained);
+      })
+    );
+    erosionNodes.push(flux, erode, transport);
+  };
+  for (let iteration = 0; iteration < tuning.iterations; iteration += 1)
+    makeIteration(
+      iteration % 2 === 0 ? {
+        heightSource: heightA,
+        heightTarget: heightB,
+        sedimentSource: sedimentA,
+        sedimentTarget: sedimentB,
+        waterSource: waterA,
+        waterTarget: waterB
+      } : {
+        heightSource: heightB,
+        heightTarget: heightA,
+        sedimentSource: sedimentB,
+        sedimentTarget: sedimentA,
+        waterSource: waterB,
+        waterTarget: waterA
+      },
+      iteration
+    );
+  if (erosionNodes.length === 0)
+    erosionNodes.push(
+      computeNode(
+        "world.erosion.bypass",
+        count2,
+        () => guard(
+          () => heightA.element(instanceIndex.toInt()).assign(heightA.element(instanceIndex.toInt()))
+        )
+      )
+    );
+  const height2 = tuning.iterations % 2 === 0 ? heightA : heightB;
+  const water = tuning.iterations % 2 === 0 ? waterA : waterB;
+  const flowNodes = [];
+  const makeFlowStep = (source, target, step) => {
+    flowNodes.push(
+      computeNode(
+        `world.flow.${step}.clear`,
+        count2,
+        () => guard(() => target.element(instanceIndex.toInt()).assign(uint(0)))
+      ),
+      computeNode(
+        `world.flow.${step}.route`,
+        count2,
+        () => guard(() => {
+          const current = instanceIndex.toInt();
+          const amount = atomicLoad(source.element(current));
+          const best = height2.element(current).toVar();
+          const destination = current.toVar();
+          const consider = (x, z) => {
+            const neighbour = at(current, x, z);
+            const candidate = height2.element(neighbour);
+            If(candidate.lessThan(best), () => {
+              best.assign(candidate);
+              destination.assign(neighbour);
+            });
+          };
+          consider(-1, 0);
+          consider(1, 0);
+          consider(0, -1);
+          consider(0, 1);
+          If(destination.notEqual(current).and(amount.greaterThan(0)), () => {
+            atomicAdd(target.element(destination), amount);
+            atomicAdd(flowAtomic.element(destination), amount);
+          });
+        })
+      )
+    );
+  };
+  for (let step = 0; step < rows + columns; step += 1)
+    makeFlowStep(
+      step % 2 === 0 ? flowFrontierA : flowFrontierB,
+      step % 2 === 0 ? flowFrontierB : flowFrontierA,
+      step
+    );
+  const normalizeFlow = computeNode(
+    "world.flow.normalize",
+    count2,
+    () => guard(() => {
+      const index = instanceIndex.toInt();
+      flow.element(index).assign(log(float(atomicLoad(flowAtomic.element(index))).add(1)).div(Math.log1p(count2)));
+    })
+  );
+  const deriveMoisture = computeNode(
+    "world.moisture",
+    count2,
+    () => guard(() => {
+      const index = instanceIndex.toInt();
+      moisture.element(index).assign(
+        clamp(
+          flow.element(index).mul(0.7).add(clamp(water.element(index), 0, 1).mul(0.3)),
+          0,
+          1
+        )
+      );
+    })
+  );
+  const stages = [
+    { name: "synthesis", nodes: [synthesis] },
+    { name: "erosion", nodes: erosionNodes },
+    { name: "flow", nodes: [...flowNodes, normalizeFlow] },
+    { name: "moisture", nodes: [deriveMoisture] }
+  ];
+  return {
+    flow,
+    height: height2,
+    moisture,
+    queue: new BoundedWorldPassQueue({ dispatchBudget: options.dispatchBudget, stages }),
+    stages,
+    dispose: () => {
+      for (const node of stages.flatMap((stage) => stage.nodes))
+        node.dispose?.();
+      for (const buffer of allStorage) buffer.value.dispose();
+    }
+  };
+}
+var STAGE_ORDER = ["synthesis", "erosion", "flow", "moisture"];
+var BoundedWorldPassQueue = class {
+  dispatchBudget;
+  #nodes;
+  #cursor = 0;
+  constructor(options) {
+    if (!Number.isInteger(options.dispatchBudget) || options.dispatchBudget <= 0)
+      throw new Error("World passes dispatchBudget must be a positive integer.");
+    if (options.stages.length !== STAGE_ORDER.length)
+      throw new Error("World passes require synthesis, erosion, flow, and moisture stages.");
+    options.stages.forEach((stage, index) => {
+      const expected = STAGE_ORDER[index];
+      if (stage.name !== expected)
+        throw new Error(`World passes expected '${expected}' at stage ${index}.`);
+      if (stage.nodes.length === 0)
+        throw new Error(`World passes ${stage.name} stage requires at least one node.`);
+    });
+    this.dispatchBudget = options.dispatchBudget;
+    this.#nodes = options.stages.flatMap((stage) => stage.nodes);
+  }
+  get complete() {
+    return this.#cursor === this.#nodes.length;
+  }
+  get dispatched() {
+    return this.#cursor;
+  }
+  /** Submit at most one fixed step's budget, preserving the declared physical pass order. */
+  process(renderer) {
+    const end = Math.min(this.#nodes.length, this.#cursor + this.dispatchBudget);
+    const start = this.#cursor;
+    while (this.#cursor < end) {
+      renderer.compute(this.#nodes[this.#cursor]);
+      this.#cursor += 1;
+    }
+    return this.#cursor - start;
+  }
+};
+
+// src/world-topology.ts
+function height(field, row, column) {
+  const clampedRow = Math.max(0, Math.min(field.rows - 1, row));
+  const clampedColumn = Math.max(0, Math.min(field.columns - 1, column));
+  const value = field.heights[clampedRow * field.columns + clampedColumn];
+  if (value === void 0 || !Number.isFinite(value))
+    throw new Error("World topology height sample is missing or not finite.");
+  return value;
+}
+function gradient(field, row, column) {
+  const dx = field.width / (field.columns - 1);
+  const dz = field.depth / (field.rows - 1);
+  return [
+    (height(field, row, column + 1) - height(field, row, column - 1)) / (2 * dx),
+    (height(field, row + 1, column) - height(field, row - 1, column)) / (2 * dz)
+  ];
+}
+function variance(values) {
+  if (values.length === 0) return 0;
+  const mean = values.reduce((total, value) => total + value, 0) / values.length;
+  return values.reduce((total, value) => total + (value - mean) ** 2, 0) / values.length;
+}
+function directionalAnisotropy(field) {
+  const x = [];
+  const z = [];
+  for (let row = 0; row < field.rows; row += 1) {
+    for (let column = 0; column < field.columns; column += 1) {
+      const [gradientX, gradientZ] = gradient(field, row, column);
+      x.push(gradientX);
+      z.push(gradientZ);
+    }
+  }
+  const xVariance = variance(x);
+  const zVariance = variance(z);
+  if (xVariance === 0 || zVariance === 0) return Number.POSITIVE_INFINITY;
+  return Math.abs(Math.log(xVariance / zVariance));
+}
+function powerSpectrumSlope(field) {
+  const average = [];
+  for (let column = 0; column < field.columns; column += 1) {
+    let total = 0;
+    for (let row = 0; row < field.rows; row += 1) total += height(field, row, column);
+    average.push(total / field.rows);
+  }
+  const wavelengths = [];
+  const powers = [];
+  for (let frequency = 1; frequency <= Math.floor(field.columns / 2); frequency += 1) {
+    const wavelength = field.width / frequency;
+    if (wavelength < 8 || wavelength > 256) continue;
+    let real = 0;
+    let imaginary = 0;
+    for (let index = 0; index < field.columns; index += 1) {
+      const angle = 2 * Math.PI * frequency * index / field.columns;
+      real += average[index] * Math.cos(angle);
+      imaginary -= average[index] * Math.sin(angle);
+    }
+    const power = real * real + imaginary * imaginary;
+    if (power > 0) {
+      wavelengths.push(Math.log(wavelength));
+      powers.push(Math.log(power));
+    }
+  }
+  if (wavelengths.length < 2) return Number.POSITIVE_INFINITY;
+  const meanWavelength = wavelengths.reduce((total, value) => total + value, 0) / wavelengths.length;
+  const meanPower = powers.reduce((total, value) => total + value, 0) / powers.length;
+  let numerator = 0;
+  let denominator = 0;
+  for (let index = 0; index < wavelengths.length; index += 1) {
+    numerator += (wavelengths[index] - meanWavelength) * (powers[index] - meanPower);
+    denominator += (wavelengths[index] - meanWavelength) ** 2;
+  }
+  return denominator === 0 ? Number.POSITIVE_INFINITY : numerator / denominator;
+}
+function reliefFieldEdge(field) {
+  let minimum = Number.POSITIVE_INFINITY;
+  let maximum = Number.NEGATIVE_INFINITY;
+  let edgeTotal = 0;
+  let edgeCount = 0;
+  for (let row = 0; row < field.rows; row += 1) {
+    for (let column = 0; column < field.columns; column += 1) {
+      const value = height(field, row, column);
+      minimum = Math.min(minimum, value);
+      maximum = Math.max(maximum, value);
+      if (row === 0 || column === 0 || row === field.rows - 1 || column === field.columns - 1) {
+        edgeTotal += value;
+        edgeCount += 1;
+      }
+    }
+  }
+  const relief = maximum - minimum;
+  if (relief === 0) return 0;
+  const edgeMean = edgeTotal / edgeCount;
+  const center = height(field, Math.floor(field.rows / 2), Math.floor(field.columns / 2));
+  return Math.abs(center - edgeMean) / relief;
+}
+function slidingExtrema(read, length, radius, write) {
+  const minimumDeque = [];
+  const maximumDeque = [];
+  let minimumHead = 0;
+  let maximumHead = 0;
+  let right = -1;
+  for (let index = 0; index < length; index += 1) {
+    const desiredRight = Math.min(length - 1, index + radius);
+    while (right < desiredRight) {
+      right += 1;
+      const value = read(right);
+      while (minimumDeque.length > minimumHead && read(minimumDeque[minimumDeque.length - 1]) >= value)
+        minimumDeque.pop();
+      minimumDeque.push(right);
+      while (maximumDeque.length > maximumHead && read(maximumDeque[maximumDeque.length - 1]) <= value)
+        maximumDeque.pop();
+      maximumDeque.push(right);
+    }
+    const left = Math.max(0, index - radius);
+    while (minimumHead < minimumDeque.length && minimumDeque[minimumHead] < left)
+      minimumHead += 1;
+    while (maximumHead < maximumDeque.length && maximumDeque[maximumHead] < left)
+      maximumHead += 1;
+    const minimumIndex = minimumDeque[minimumHead];
+    const maximumIndex = maximumDeque[maximumHead];
+    if (minimumIndex === void 0 || maximumIndex === void 0)
+      throw new Error("World topology sliding window is empty.");
+    write(index, read(minimumIndex), read(maximumIndex));
+    if (minimumHead > 64 && minimumHead * 2 > minimumDeque.length) {
+      minimumDeque.splice(0, minimumHead);
+      minimumHead = 0;
+    }
+    if (maximumHead > 64 && maximumHead * 2 > maximumDeque.length) {
+      maximumDeque.splice(0, maximumHead);
+      maximumHead = 0;
+    }
+  }
+}
+function median64mRelief(field) {
+  let minimum = Number.POSITIVE_INFINITY;
+  let maximum = Number.NEGATIVE_INFINITY;
+  for (let index = 0; index < field.heights.length; index += 1) {
+    const value = field.heights[index];
+    if (value === void 0 || !Number.isFinite(value))
+      throw new Error("World topology height sample is missing or not finite.");
+    minimum = Math.min(minimum, value);
+    maximum = Math.max(maximum, value);
+  }
+  const globalRelief = maximum - minimum;
+  if (globalRelief === 0) return 0;
+  const radiusX = Math.max(1, Math.round(64 / (field.width / (field.columns - 1))));
+  const radiusZ = Math.max(1, Math.round(64 / (field.depth / (field.rows - 1))));
+  const local = [];
+  const horizontalMinimum = new Float64Array(field.rows * field.columns);
+  const horizontalMaximum = new Float64Array(field.rows * field.columns);
+  for (let row = 0; row < field.rows; row += 1)
+    slidingExtrema(
+      (column) => height(field, row, column),
+      field.columns,
+      radiusX,
+      (column, lineMinimum, lineMaximum) => {
+        horizontalMinimum[row * field.columns + column] = lineMinimum;
+        horizontalMaximum[row * field.columns + column] = lineMaximum;
+      }
+    );
+  for (let column = 0; column < field.columns; column += 1) {
+    const localMinimum = new Float64Array(field.rows);
+    const localMaximum = new Float64Array(field.rows);
+    slidingExtrema(
+      (row) => horizontalMinimum[row * field.columns + column],
+      field.rows,
+      radiusZ,
+      (row, lineMinimum) => {
+        localMinimum[row] = lineMinimum;
+      }
+    );
+    slidingExtrema(
+      (row) => horizontalMaximum[row * field.columns + column],
+      field.rows,
+      radiusZ,
+      (row, _lineMinimum, lineMaximum) => {
+        localMaximum[row] = lineMaximum;
+      }
+    );
+    for (let row = 0; row < field.rows; row += 1)
+      local.push((localMaximum[row] - localMinimum[row]) / globalRelief);
+  }
+  local.sort((a, b) => a - b);
+  return local[Math.floor(local.length / 2)];
+}
+function downhill(field, index) {
+  const row = Math.floor(index / field.columns);
+  const column = index % field.columns;
+  const current = height(field, row, column);
+  let destination = index;
+  let lowest = current;
+  for (const [rowOffset, columnOffset] of [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1]
+  ]) {
+    const nextRow = row + rowOffset;
+    const nextColumn = column + columnOffset;
+    if (nextRow < 0 || nextRow >= field.rows || nextColumn < 0 || nextColumn >= field.columns)
+      continue;
+    const candidate = height(field, nextRow, nextColumn);
+    if (candidate < lowest) {
+      lowest = candidate;
+      destination = nextRow * field.columns + nextColumn;
+    }
+  }
+  return destination;
+}
+function streamOrder(field) {
+  const count2 = field.rows * field.columns;
+  const targets = new Int32Array(count2);
+  targets.fill(-1);
+  const order = Array.from({ length: count2 }, (_, index) => index).sort(
+    (a, b) => height(field, Math.floor(b / field.columns), b % field.columns) - height(field, Math.floor(a / field.columns), a % field.columns) || a - b
+  );
+  for (let source = 0; source < count2; source += 1) {
+    const destination = downhill(field, source);
+    targets[source] = destination === source ? -1 : destination;
+  }
+  const accumulation = new Float64Array(count2);
+  for (const source of order) {
+    accumulation[source] = accumulation[source] + 1;
+    const destination = targets[source];
+    if (destination !== void 0 && destination >= 0)
+      accumulation[destination] = accumulation[destination] + accumulation[source];
+  }
+  const cellArea = field.width / (field.columns - 1) * (field.depth / (field.rows - 1));
+  const minimumFlow = Math.log1p(2048 / cellArea) / Math.log1p(count2);
+  const orders = new Int32Array(count2);
+  let maximum = 0;
+  for (const index of order) {
+    if (field.flow[index] < minimumFlow) continue;
+    const row = Math.floor(index / field.columns);
+    const column = index % field.columns;
+    const upstream = [];
+    for (const [rowOffset, columnOffset] of [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1]
+    ]) {
+      const upstreamRow = row + rowOffset;
+      const upstreamColumn = column + columnOffset;
+      if (upstreamRow < 0 || upstreamRow >= field.rows || upstreamColumn < 0 || upstreamColumn >= field.columns)
+        continue;
+      const candidate = upstreamRow * field.columns + upstreamColumn;
+      if (targets[candidate] === index && field.flow[candidate] >= minimumFlow)
+        upstream.push(orders[candidate]);
+    }
+    const highest = Math.max(1, ...upstream);
+    const ties = upstream.filter((value) => value === highest).length;
+    orders[index] = ties > 1 ? highest + 1 : highest;
+    maximum = Math.max(maximum, orders[index]);
+  }
+  return maximum;
+}
+function curvatureExcessKurtosis(field) {
+  const values = [];
+  for (let row = 0; row < field.rows; row += 1) {
+    for (let column = 0; column < field.columns; column += 1) {
+      const center = height(field, row, column);
+      values.push(
+        height(field, row, column - 1) + height(field, row, column + 1) + height(field, row - 1, column) + height(field, row + 1, column) - 4 * center
+      );
+    }
+  }
+  const mean = values.reduce((total, value) => total + value, 0) / values.length;
+  const second = values.reduce((total, value) => total + (value - mean) ** 2, 0) / values.length;
+  if (second === 0) return Number.NEGATIVE_INFINITY;
+  const fourth = values.reduce((total, value) => total + (value - mean) ** 4, 0) / values.length;
+  return fourth / (second * second) - 3;
+}
+function slopeTail(field) {
+  let steep = 0;
+  for (let row = 0; row < field.rows; row += 1) {
+    for (let column = 0; column < field.columns; column += 1) {
+      const [x, z] = gradient(field, row, column);
+      if (Math.atan(Math.hypot(x, z)) > Math.PI / 6) steep += 1;
+    }
+  }
+  return steep / (field.rows * field.columns);
+}
+function summarizeWorldTopology(field) {
+  if (!Number.isInteger(field.rows) || field.rows < 2)
+    throw new Error("World topology rows must be integers of at least 2.");
+  if (!Number.isInteger(field.columns) || field.columns < 2)
+    throw new Error("World topology columns must be integers of at least 2.");
+  if (field.heights.length !== field.rows * field.columns)
+    throw new Error("World topology heights must contain rows times columns samples.");
+  if (field.flow.length !== field.rows * field.columns)
+    throw new Error("World topology flow must contain rows times columns samples.");
+  for (let index = 0; index < field.flow.length; index += 1) {
+    const value = field.flow[index];
+    if (value === void 0 || !Number.isFinite(value) || value < 0 || value > 1)
+      throw new Error("World topology flow samples must be finite values from 0 through 1.");
+  }
+  return {
+    directionalAnisotropy: directionalAnisotropy(field),
+    effectiveVertexDensityPerKm2: field.rows * field.columns * 1e6 / (field.width * field.depth),
+    maxHortonStrahlerOrder: streamOrder(field),
+    median64mRelief: median64mRelief(field),
+    powerSpectrumSlope: powerSpectrumSlope(field),
+    profileCurvatureExcessKurtosis: curvatureExcessKurtosis(field),
+    reliefFieldEdge: reliefFieldEdge(field),
+    slopeTailAbove30Degrees: slopeTail(field)
+  };
+}
+
+// src/world-tiles.ts
+var MAX_RAW_TOPOLOGY_SAMPLES = 1e4;
+var LOD_POP_THRESHOLD = 16;
+var LOD_TRANSITION_FRAMES = 3;
+var BRIDGE_COORDINATE_EPSILON = 1e-4;
+var BRIDGE_COORDINATE_RELATIVE_EPSILON = 2 ** -22;
+var BRIDGE_STRIP_INDEX_PATTERN = [0, 1, 2, 2, 1, 3, 2, 1, 0, 3, 1, 2];
+function bridgeCoordinateMatches(actual, expected) {
+  return Math.abs(actual - expected) <= Math.max(
+    BRIDGE_COORDINATE_EPSILON,
+    Math.max(1, Math.abs(actual), Math.abs(expected)) * BRIDGE_COORDINATE_RELATIVE_EPSILON
+  );
+}
+var EmptyCollider = class {
+  #disposed = false;
+  get disposed() {
+    return this.#disposed;
+  }
+  dispose() {
+    this.#disposed = true;
+  }
+};
+function finite2(value, name) {
+  if (!Number.isFinite(value)) throw new Error(`TerrainTiles ${name} must be finite.`);
+  return value;
+}
+function positive(value, name) {
+  finite2(value, name);
+  if (value <= 0) throw new Error(`TerrainTiles ${name} must be greater than zero.`);
+  return value;
+}
+function integerAtLeast(value, minimum, name) {
+  if (!Number.isInteger(value) || value < minimum)
+    throw new Error(`TerrainTiles ${name} must be an integer of at least ${minimum}.`);
+  return value;
+}
+function keyFor(tileX, tileZ) {
+  return `${String(tileX)}:${String(tileZ)}`;
+}
+function lodLevelForDistance(distance, thresholds) {
+  let level = 0;
+  for (const threshold of thresholds) {
+    if (distance < threshold) break;
+    level += 1;
+  }
+  return level;
+}
+function resolutionFor(tileResolution, factor) {
+  const cells = (tileResolution - 1) / factor;
+  if (!Number.isInteger(cells))
+    throw new Error("TerrainTiles tileResolution minus one must divide every lod factor.");
+  return cells + 1;
+}
+function estimatedLevelBytes(resolution) {
+  const vertices = resolution * resolution + resolution * 4;
+  const triangles = (resolution - 1) * (resolution - 1) + (resolution - 1) * 4;
+  const edgeSampleBytes = resolution * 4 * Float32Array.BYTES_PER_ELEMENT;
+  return vertices * 3 * Float32Array.BYTES_PER_ELEMENT * 2 + triangles * 6 * Uint32Array.BYTES_PER_ELEMENT + edgeSampleBytes;
+}
+function estimatedFieldBytes(tileResolution, worldPasses) {
+  const sampleBytes = tileResolution * tileResolution * Float32Array.BYTES_PER_ELEMENT;
+  if (worldPasses === void 0) return sampleBytes * 2;
+  return sampleBytes * (worldPasses.gpu === false ? 4 : 24);
+}
+function estimatedTileBytes(tileResolution, factors, worldPasses) {
+  return factors.reduce(
+    (total, factor) => total + estimatedLevelBytes(resolutionFor(tileResolution, factor)),
+    estimatedFieldBytes(tileResolution, worldPasses)
+  );
+}
+function tiledObservationResolution(extent, tileSize, tileResolution, axis) {
+  const tileCount = extent / tileSize;
+  if (!Number.isInteger(tileCount) || tileCount < 1)
+    throw new Error(
+      `TerrainTiles topologyObservation ${axis} must cover a positive whole number of rendered tiles.`
+    );
+  return tileCount * (tileResolution - 1) + 1;
+}
+function validateTopologyObservation(observation, tileSize, tileResolution) {
+  const expectedColumns = tiledObservationResolution(
+    observation.width,
+    tileSize,
+    tileResolution,
+    "width"
+  );
+  const expectedRows = tiledObservationResolution(
+    observation.depth,
+    tileSize,
+    tileResolution,
+    "depth"
+  );
+  if (observation.columns !== expectedColumns)
+    throw new Error(
+      `TerrainTiles topologyObservation columns must match the rendered tile grid (expected ${String(expectedColumns)}, received ${String(observation.columns)}).`
+    );
+  if (observation.rows !== expectedRows)
+    throw new Error(
+      `TerrainTiles topologyObservation rows must match the rendered tile grid (expected ${String(expectedRows)}, received ${String(observation.rows)}).`
+    );
+}
+function edgeSamplesFor(values, resolution) {
+  const north = new Float32Array(resolution);
+  const south = new Float32Array(resolution);
+  const west = new Float32Array(resolution);
+  const east = new Float32Array(resolution);
+  for (let index = 0; index < resolution; index += 1) {
+    north[index] = values[index];
+    south[index] = values[(resolution - 1) * resolution + index];
+    west[index] = values[index * resolution];
+    east[index] = values[index * resolution + resolution - 1];
+  }
+  return { east, north, south, west };
+}
+function edgeVertexIndex(level, side, index) {
+  const row = side === "north" ? 0 : side === "south" ? level.resolution - 1 : index;
+  const column = side === "west" ? 0 : side === "east" ? level.resolution - 1 : index;
+  return row * level.resolution + column;
+}
+function appendQuad(indices, topLeft, bottomLeft, topRight, bottomRight) {
+  indices.push(topLeft, bottomLeft, topRight, topRight, bottomLeft, bottomRight);
+}
+function buildLevel(field, resolution, skirtDepth, surface) {
+  const positions = [];
+  const normals = [];
+  const heights = [];
+  const minimumX = field.origin.x - field.width / 2;
+  const minimumZ = field.origin.z - field.depth / 2;
+  const cellWidth = field.width / (resolution - 1);
+  const cellDepth = field.depth / (resolution - 1);
+  const normal = new Vector3();
+  for (let row = 0; row < resolution; row += 1) {
+    const z = minimumZ + row * cellDepth;
+    for (let column = 0; column < resolution; column += 1) {
+      const x = minimumX + column * cellWidth;
+      const height2 = field.heightAt(x, z);
+      heights.push(height2);
+      positions.push(x - field.origin.x, height2, z - field.origin.z);
+      field.normalAt(x, z, normal);
+      normals.push(normal.x, normal.y, normal.z);
+    }
+  }
+  const indices = [];
+  for (let row = 0; row < resolution - 1; row += 1) {
+    for (let column = 0; column < resolution - 1; column += 1) {
+      const topLeft = row * resolution + column;
+      appendQuad(indices, topLeft, topLeft + resolution, topLeft + 1, topLeft + resolution + 1);
+    }
+  }
+  const edges = [
+    (index) => index,
+    (index) => (resolution - 1) * resolution + index,
+    (index) => index * resolution,
+    (index) => index * resolution + resolution - 1
+  ];
+  for (const edge of edges) {
+    const bottom = positions.length / 3;
+    for (let index = 0; index < resolution; index += 1) {
+      const top = edge(index);
+      positions.push(
+        positions[top * 3],
+        positions[top * 3 + 1] - skirtDepth,
+        positions[top * 3 + 2]
+      );
+      normals.push(0, 1, 0);
+    }
+    for (let index = 0; index < resolution - 1; index += 1) {
+      const topLeft = edge(index);
+      const topRight = edge(index + 1);
+      appendQuad(indices, topLeft, bottom + index, topRight, bottom + index + 1);
+    }
+  }
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(Float32Array.from(positions), 3));
+  geometry.setAttribute("normal", new BufferAttribute(Float32Array.from(normals), 3));
+  geometry.setIndex(new BufferAttribute(Uint32Array.from(indices), 1));
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  const skirt = inspectSkirtGeometry(geometry, resolution, edges);
+  return {
+    edgeSamples: edgeSamplesFor(heights, resolution),
+    geometry,
+    mesh: new Mesh(geometry, surface),
+    resolution,
+    skirtDepth: skirt.depth,
+    skirtVertexCount: skirt.vertexCount
+  };
+}
+function inspectSkirtGeometry(geometry, resolution, edges) {
+  const position = geometry.getAttribute("position");
+  const surfaceVertexCount = resolution * resolution;
+  const vertexCount = position.count - surfaceVertexCount;
+  if (vertexCount < 0 || vertexCount % edges.length !== 0)
+    throw new Error("TerrainTiles generated skirt geometry has an invalid vertex count.");
+  if (vertexCount === 0) return { depth: 0, vertexCount: 0 };
+  const edgeVertexCount = vertexCount / edges.length;
+  let depth = Number.POSITIVE_INFINITY;
+  for (const [edgeIndex, edge] of edges.entries()) {
+    for (let index = 0; index < edgeVertexCount; index += 1) {
+      const top = edge(index);
+      const bottom = surfaceVertexCount + edgeIndex * edgeVertexCount + index;
+      depth = Math.min(depth, position.getY(top) - position.getY(bottom));
+    }
+  }
+  if (!Number.isFinite(depth) || depth < 0)
+    throw new Error("TerrainTiles generated skirt geometry has an invalid depth.");
+  return { depth, vertexCount };
+}
+function opposingEdge(a, b) {
+  if (a.tileX < b.tileX) return ["east", "west"];
+  if (a.tileX > b.tileX) return ["west", "east"];
+  if (a.tileZ < b.tileZ) return ["south", "north"];
+  return ["north", "south"];
+}
+function renderedLevel(tile) {
+  return tile.levels.find(({ mesh }) => mesh.visible) ?? tile.levels[tile.lodLevel];
+}
+function edgeVertexHeight(level, side, index) {
+  const value = level.geometry.getAttribute("position").getY(edgeVertexIndex(level, side, index));
+  if (!Number.isFinite(value))
+    throw new Error("TerrainTiles seam diagnostic edge height must be finite.");
+  return value;
+}
+function edgeHeight(level, side, normalized) {
+  const position = Math.max(0, Math.min(1, normalized)) * (level.resolution - 1);
+  const lower = Math.floor(position);
+  const upper = Math.min(level.resolution - 1, lower + 1);
+  const mix = position - lower;
+  return edgeVertexHeight(level, side, lower) * (1 - mix) + edgeVertexHeight(level, side, upper) * mix;
+}
+function edgeWorldVertexHeight(level, side, index, target) {
+  const position = level.geometry.getAttribute("position");
+  const vertex = edgeVertexIndex(level, side, index);
+  const localX = position.getX(vertex);
+  const localY = position.getY(vertex);
+  const localZ = position.getZ(vertex);
+  if (!Number.isFinite(localX) || !Number.isFinite(localY) || !Number.isFinite(localZ))
+    throw new Error("TerrainTiles seam diagnostic bridge coordinates must be finite.");
+  target.set(localX, localY, localZ).applyMatrix4(level.mesh.matrixWorld);
+  if (!Number.isFinite(target.x) || !Number.isFinite(target.y) || !Number.isFinite(target.z))
+    throw new Error("TerrainTiles seam diagnostic bridge world coordinates must be finite.");
+  return target.y;
+}
+function edgeWorldHeight(level, side, normalized, target) {
+  const position = Math.max(0, Math.min(1, normalized)) * (level.resolution - 1);
+  const lower = Math.floor(position);
+  const upper = Math.min(level.resolution - 1, lower + 1);
+  const mix = position - lower;
+  return edgeWorldVertexHeight(level, side, lower, target) * (1 - mix) + edgeWorldVertexHeight(level, side, upper, target) * mix;
+}
+function bridgeEndpointWorldHeight(position, matrixWorld, vertex, expectedX, expectedY, expectedZ, worldPosition) {
+  const localX = position.getX(vertex);
+  const localY = position.getY(vertex);
+  const localZ = position.getZ(vertex);
+  if (!Number.isFinite(localX) || !Number.isFinite(localY) || !Number.isFinite(localZ))
+    throw new Error("TerrainTiles seam diagnostic bridge coordinates must be finite.");
+  worldPosition.set(localX, localY, localZ).applyMatrix4(matrixWorld);
+  if (!Number.isFinite(worldPosition.x) || !Number.isFinite(worldPosition.y) || !Number.isFinite(worldPosition.z))
+    throw new Error("TerrainTiles seam diagnostic bridge world coordinates must be finite.");
+  if (!Number.isFinite(expectedX) || !Number.isFinite(expectedY) || !Number.isFinite(expectedZ) || !bridgeCoordinateMatches(worldPosition.x, expectedX) || !bridgeCoordinateMatches(worldPosition.y, expectedY) || !bridgeCoordinateMatches(worldPosition.z, expectedZ))
+    throw new Error(
+      "TerrainTiles seam diagnostic bridge topology does not match current neighboring edges."
+    );
+  return worldPosition.y;
+}
+function bridgeEndpointHeight(bridge, position, sample, endpoint, tile, side, level, worldPosition, expectedWorldPosition) {
+  const sampleNormalized = sample / (bridge.resolution - 1);
+  const [expectedX, , expectedZ] = edgeWorldPoint(tile.field, side, sampleNormalized, 0);
+  const expectedY = edgeWorldHeight(level, side, sampleNormalized, expectedWorldPosition);
+  return bridgeEndpointWorldHeight(
+    position,
+    bridge.mesh.matrixWorld,
+    sample * 2 + endpoint,
+    expectedX,
+    expectedY,
+    expectedZ,
+    worldPosition
+  );
+}
+function bridgeEndpointPair(a, aSide, b, bSide) {
+  const aLevel = renderedLevel(a);
+  const bLevel = renderedLevel(b);
+  if (aLevel === void 0 || bLevel === void 0)
+    throw new Error(
+      "TerrainTiles seam diagnostic bridge topology has no rendered neighboring edge."
+    );
+  const aEndpoint = { level: aLevel, side: aSide, tile: a };
+  const bEndpoint = { level: bLevel, side: bSide, tile: b };
+  return aLevel.resolution > bLevel.resolution ? [aEndpoint, bEndpoint] : [bEndpoint, aEndpoint];
+}
+function interpolatedEdgeSample(samples, normalized, name) {
+  const position = Math.max(0, Math.min(1, normalized)) * (samples.length - 1);
+  const lower = Math.floor(position);
+  const upper = Math.min(samples.length - 1, lower + 1);
+  const mix = position - lower;
+  const lowerValue = samples[lower];
+  const upperValue = samples[upper];
+  if (!Number.isFinite(lowerValue) || !Number.isFinite(upperValue))
+    throw new Error(`TerrainTiles retained ${name} edge sample must be finite.`);
+  return lowerValue * (1 - mix) + upperValue * mix;
+}
+function refreshEdgeSamples(level) {
+  for (const side of ["east", "north", "south", "west"]) {
+    const samples = level.edgeSamples[side];
+    for (let index = 0; index < level.resolution; index += 1)
+      samples[index] = edgeVertexHeight(level, side, index);
+  }
+}
+function edgeWorldPoint(field, side, normalized, height2) {
+  const minimumX = field.origin.x - field.width / 2;
+  const minimumZ = field.origin.z - field.depth / 2;
+  const x = side === "west" ? minimumX : side === "east" ? minimumX + field.width : minimumX + normalized * field.width;
+  const z = side === "north" ? minimumZ : side === "south" ? minimumZ + field.depth : minimumZ + normalized * field.depth;
+  return [x, height2, z];
+}
+function restoreLevelEdge(field, level, side) {
+  const position = level.geometry.getAttribute("position");
+  const normalAttribute = level.geometry.getAttribute("normal");
+  const normal = new Vector3();
+  let changed = false;
+  for (let index = 0; index < level.resolution; index += 1) {
+    const normalized = index / (level.resolution - 1);
+    const [x, , z] = edgeWorldPoint(field, side, normalized, 0);
+    const vertex = edgeVertexIndex(level, side, index);
+    const height2 = field.heightAt(x, z);
+    field.normalAt(x, z, normal);
+    if (position.getY(vertex) !== height2) {
+      position.setY(vertex, height2);
+      changed = true;
+    }
+    if (normalAttribute.getX(vertex) !== normal.x || normalAttribute.getY(vertex) !== normal.y || normalAttribute.getZ(vertex) !== normal.z) {
+      normalAttribute.setXYZ(vertex, normal.x, normal.y, normal.z);
+      changed = true;
+    }
+  }
+  if (!changed) return false;
+  updateLevelSkirts(level);
+  refreshEdgeSamples(level);
+  position.needsUpdate = true;
+  normalAttribute.needsUpdate = true;
+  level.geometry.computeBoundingBox();
+  level.geometry.computeBoundingSphere();
+  return true;
+}
+function stitchGeometryData(finer, finerLevel, finerSide, coarser, coarserLevel, coarserSide) {
+  const positions = [];
+  const normals = [];
+  const indices = [];
+  let coverageDepth = 0;
+  for (let index = 0; index < finerLevel.resolution; index += 1) {
+    const normalized = index / (finerLevel.resolution - 1);
+    const fineHeight = interpolatedEdgeSample(
+      finerLevel.edgeSamples[finerSide],
+      normalized,
+      `${finerSide} of finer LOD`
+    );
+    const coarseHeight = interpolatedEdgeSample(
+      coarserLevel.edgeSamples[coarserSide],
+      normalized,
+      `${coarserSide} of coarser LOD`
+    );
+    coverageDepth = Math.max(coverageDepth, Math.abs(fineHeight - coarseHeight));
+    positions.push(...edgeWorldPoint(finer.field, finerSide, normalized, fineHeight));
+    positions.push(...edgeWorldPoint(coarser.field, coarserSide, normalized, coarseHeight));
+    normals.push(0, 1, 0, 0, 1, 0);
+  }
+  for (let index = 0; index < finerLevel.resolution - 1; index += 1) {
+    const fine = index * 2;
+    const coarse = fine + 1;
+    const nextFine = fine + 2;
+    const nextCoarse = coarse + 2;
+    indices.push(
+      fine,
+      coarse,
+      nextFine,
+      nextFine,
+      coarse,
+      nextCoarse,
+      nextFine,
+      coarse,
+      fine,
+      nextCoarse,
+      coarse,
+      nextFine
+    );
+  }
+  return {
+    coverageDepth,
+    indices: Uint32Array.from(indices),
+    normals: Float32Array.from(normals),
+    positions: Float32Array.from(positions)
+  };
+}
+function stitchGeometry(data) {
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(data.positions, 3));
+  geometry.setAttribute("normal", new BufferAttribute(data.normals, 3));
+  geometry.setIndex(new BufferAttribute(data.indices, 1));
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+function geometryBytes(geometry) {
+  const index = geometry.getIndex();
+  return geometry.getAttribute("position").array.byteLength + geometry.getAttribute("normal").array.byteLength + (index?.array.byteLength ?? 0);
+}
+function validateBridgeTriangleTopology(geometry, expectedVertexCount) {
+  const position = geometry.getAttribute("position");
+  const index = geometry.getIndex();
+  const drawRange = geometry.drawRange;
+  const positionArray = position?.array;
+  if (position === void 0 || position.itemSize !== 3 || !Number.isInteger(position.count) || position.count < 6 || position.count % 2 !== 0 || positionArray === void 0 || positionArray.length < position.count * position.itemSize || expectedVertexCount !== void 0 && position.count !== expectedVertexCount || index === null || index.itemSize !== 1 || !Number.isInteger(index.count) || index.array.length !== index.count || !(index.array instanceof Uint16Array || index.array instanceof Uint32Array) || !Number.isInteger(drawRange.start) || drawRange.start !== 0 || drawRange.count !== Number.POSITIVE_INFINITY && (!Number.isInteger(drawRange.count) || drawRange.count < index.count || drawRange.count % 3 !== 0))
+    throw new Error(
+      "TerrainTiles seam diagnostic bridge topology has invalid rendered triangle data."
+    );
+  const vertexCount = position.count;
+  const stripResolution = vertexCount / 2;
+  const expectedIndexCount = (stripResolution - 1) * BRIDGE_STRIP_INDEX_PATTERN.length;
+  if (index.count !== expectedIndexCount)
+    throw new Error(
+      "TerrainTiles seam diagnostic bridge topology has invalid rendered triangle data."
+    );
+  for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+    if (!Number.isFinite(position.getX(vertex)) || !Number.isFinite(position.getY(vertex)) || !Number.isFinite(position.getZ(vertex)))
+      throw new Error("TerrainTiles seam diagnostic bridge coordinates must be finite.");
+  }
+  for (let offset = 0; offset < index.count; offset += 1) {
+    const segment = Math.floor(offset / BRIDGE_STRIP_INDEX_PATTERN.length);
+    const pair = segment * 2;
+    const expected = pair + BRIDGE_STRIP_INDEX_PATTERN[offset % BRIDGE_STRIP_INDEX_PATTERN.length];
+    const vertex = index.getX(offset);
+    if (vertex !== expected)
+      throw new Error("TerrainTiles seam diagnostic bridge topology has invalid index data.");
+  }
+  return position;
+}
+function updateStitchBridge(bridge, data) {
+  const position = validateBridgeTriangleTopology(bridge.geometry, bridge.resolution * 2);
+  if (bridge.resolution !== data.positions.length / 6) {
+    const previous = bridge.geometry;
+    bridge.geometry = stitchGeometry(data);
+    bridge.mesh.geometry = bridge.geometry;
+    bridge.resolution = data.positions.length / 6;
+    bridge.bytes = geometryBytes(bridge.geometry);
+    previous.dispose();
+  } else {
+    const normal = bridge.geometry.getAttribute("normal");
+    const index = bridge.geometry.getIndex();
+    if (normal === void 0 || normal.itemSize !== 3 || normal.count !== position.count || index === null)
+      throw new Error(
+        "TerrainTiles seam diagnostic bridge topology has invalid rendered triangle data."
+      );
+    position.array.set(data.positions);
+    normal.array.set(data.normals);
+    index.array.set(data.indices);
+    position.needsUpdate = true;
+    normal.needsUpdate = true;
+    index.needsUpdate = true;
+    bridge.geometry.computeBoundingBox();
+    bridge.geometry.computeBoundingSphere();
+  }
+  bridge.coverageDepth = data.coverageDepth;
+}
+function levelHeight(level, row, column) {
+  const position = level.geometry.getAttribute("position");
+  const value = position.getY(row * level.resolution + column);
+  if (!Number.isFinite(value)) throw new Error("TerrainTiles LOD geometry has an invalid height.");
+  return value;
+}
+function interpolatedLevelHeight(level, x, z) {
+  const column = Math.max(0, Math.min(1, x)) * (level.resolution - 1);
+  const row = Math.max(0, Math.min(1, z)) * (level.resolution - 1);
+  const column0 = Math.floor(column);
+  const row0 = Math.floor(row);
+  const column1 = Math.min(level.resolution - 1, column0 + 1);
+  const row1 = Math.min(level.resolution - 1, row0 + 1);
+  const columnMix = column - column0;
+  const rowMix = row - row0;
+  const upperLeft = levelHeight(level, row0, column0);
+  const upperRight = levelHeight(level, row0, column1);
+  const lowerLeft = levelHeight(level, row1, column0);
+  const lowerRight = levelHeight(level, row1, column1);
+  const upper = upperLeft + (upperRight - upperLeft) * columnMix;
+  const lower = lowerLeft + (lowerRight - lowerLeft) * columnMix;
+  return upper + (lower - upper) * rowMix;
+}
+function interpolatedLevelNormal(level, x, z, target) {
+  const column = Math.max(0, Math.min(1, x)) * (level.resolution - 1);
+  const row = Math.max(0, Math.min(1, z)) * (level.resolution - 1);
+  const column0 = Math.floor(column);
+  const row0 = Math.floor(row);
+  const column1 = Math.min(level.resolution - 1, column0 + 1);
+  const row1 = Math.min(level.resolution - 1, row0 + 1);
+  const columnMix = column - column0;
+  const rowMix = row - row0;
+  const normal = level.geometry.getAttribute("normal");
+  const upperLeft = row0 * level.resolution + column0;
+  const upperRight = row0 * level.resolution + column1;
+  const lowerLeft = row1 * level.resolution + column0;
+  const lowerRight = row1 * level.resolution + column1;
+  const blend = (upper, lower) => upper + (lower - upper) * rowMix;
+  const interpolate = (topLeft, topRight, bottomLeft, bottomRight) => blend(
+    topLeft + (topRight - topLeft) * columnMix,
+    bottomLeft + (bottomRight - bottomLeft) * columnMix
+  );
+  return target.set(
+    interpolate(
+      normal.getX(upperLeft),
+      normal.getX(upperRight),
+      normal.getX(lowerLeft),
+      normal.getX(lowerRight)
+    ),
+    interpolate(
+      normal.getY(upperLeft),
+      normal.getY(upperRight),
+      normal.getY(lowerLeft),
+      normal.getY(lowerRight)
+    ),
+    interpolate(
+      normal.getZ(upperLeft),
+      normal.getZ(upperRight),
+      normal.getZ(lowerLeft),
+      normal.getZ(lowerRight)
+    )
+  ).normalize();
+}
+function updateLevelSkirts(level) {
+  const position = level.geometry.getAttribute("position");
+  const normal = level.geometry.getAttribute("normal");
+  const surfaceVertexCount = level.resolution * level.resolution;
+  const edges = [
+    (index) => index,
+    (index) => (level.resolution - 1) * level.resolution + index,
+    (index) => index * level.resolution,
+    (index) => index * level.resolution + level.resolution - 1
+  ];
+  for (const [edgeIndex, edge] of edges.entries()) {
+    for (let index = 0; index < level.resolution; index += 1) {
+      const top = edge(index);
+      const bottom = surfaceVertexCount + edgeIndex * level.resolution + index;
+      position.setY(bottom, position.getY(top) - level.skirtDepth);
+      normal.setXYZ(bottom, 0, 1, 0);
+    }
+  }
+}
+function restoreLevelSurface(field, level) {
+  const position = level.geometry.getAttribute("position");
+  const normalAttribute = level.geometry.getAttribute("normal");
+  const minimumX = field.origin.x - field.width / 2;
+  const minimumZ = field.origin.z - field.depth / 2;
+  const cellWidth = field.width / (level.resolution - 1);
+  const cellDepth = field.depth / (level.resolution - 1);
+  const normal = new Vector3();
+  for (let row = 0; row < level.resolution; row += 1) {
+    const z = minimumZ + row * cellDepth;
+    for (let column = 0; column < level.resolution; column += 1) {
+      const x = minimumX + column * cellWidth;
+      const index = row * level.resolution + column;
+      position.setY(index, field.heightAt(x, z));
+      field.normalAt(x, z, normal);
+      normalAttribute.setXYZ(index, normal.x, normal.y, normal.z);
+    }
+  }
+  updateLevelSkirts(level);
+  refreshEdgeSamples(level);
+  position.needsUpdate = true;
+  normalAttribute.needsUpdate = true;
+  level.geometry.computeBoundingBox();
+  level.geometry.computeBoundingSphere();
+}
+function updateLodTransitionGeometry(tile, transition, progress) {
+  const from = tile.levels[transition.from];
+  const to = tile.levels[transition.to];
+  if (from === void 0 || to === void 0)
+    throw new Error("TerrainTiles LOD transition references a missing level.");
+  const finer = from.resolution >= to.resolution ? from : to;
+  const coarser = finer === from ? to : from;
+  const fromIsFiner = finer === from;
+  const position = finer.geometry.getAttribute("position");
+  const normalAttribute = finer.geometry.getAttribute("normal");
+  const minimumX = tile.field.origin.x - tile.field.width / 2;
+  const minimumZ = tile.field.origin.z - tile.field.depth / 2;
+  const cellWidth = tile.field.width / (finer.resolution - 1);
+  const cellDepth = tile.field.depth / (finer.resolution - 1);
+  const fineNormal = new Vector3();
+  const coarseNormal = new Vector3();
+  const blendedNormal = new Vector3();
+  for (let row = 0; row < finer.resolution; row += 1) {
+    const z = minimumZ + row * cellDepth;
+    const normalizedZ = row / (finer.resolution - 1);
+    for (let column = 0; column < finer.resolution; column += 1) {
+      const x = minimumX + column * cellWidth;
+      const normalizedX = column / (finer.resolution - 1);
+      const index = row * finer.resolution + column;
+      const fineHeight = tile.field.heightAt(x, z);
+      const coarseHeight = interpolatedLevelHeight(coarser, normalizedX, normalizedZ);
+      const startHeight = fromIsFiner ? fineHeight : coarseHeight;
+      const endHeight = fromIsFiner ? coarseHeight : fineHeight;
+      position.setY(index, startHeight + (endHeight - startHeight) * progress);
+      tile.field.normalAt(x, z, fineNormal);
+      interpolatedLevelNormal(coarser, normalizedX, normalizedZ, coarseNormal);
+      const startNormal = fromIsFiner ? fineNormal : coarseNormal;
+      const endNormal = fromIsFiner ? coarseNormal : fineNormal;
+      blendedNormal.set(
+        startNormal.x + (endNormal.x - startNormal.x) * progress,
+        startNormal.y + (endNormal.y - startNormal.y) * progress,
+        startNormal.z + (endNormal.z - startNormal.z) * progress
+      ).normalize();
+      normalAttribute.setXYZ(index, blendedNormal.x, blendedNormal.y, blendedNormal.z);
+    }
+  }
+  updateLevelSkirts(finer);
+  refreshEdgeSamples(finer);
+  position.needsUpdate = true;
+  normalAttribute.needsUpdate = true;
+  finer.geometry.computeBoundingBox();
+  finer.geometry.computeBoundingSphere();
+}
+function surfaceHeights(level) {
+  const position = level.geometry.getAttribute("position");
+  const heights = new Float32Array(level.resolution * level.resolution);
+  for (let index = 0; index < heights.length; index += 1) heights[index] = position.getY(index);
+  return heights;
+}
+function interpolatedSamplesHeight(samples, resolution, x, z) {
+  const column = Math.max(0, Math.min(1, x)) * (resolution - 1);
+  const row = Math.max(0, Math.min(1, z)) * (resolution - 1);
+  const column0 = Math.floor(column);
+  const row0 = Math.floor(row);
+  const column1 = Math.min(resolution - 1, column0 + 1);
+  const row1 = Math.min(resolution - 1, row0 + 1);
+  const columnMix = column - column0;
+  const rowMix = row - row0;
+  const upperLeft = samples[row0 * resolution + column0];
+  const upperRight = samples[row0 * resolution + column1];
+  const lowerLeft = samples[row1 * resolution + column0];
+  const lowerRight = samples[row1 * resolution + column1];
+  const upper = upperLeft + (upperRight - upperLeft) * columnMix;
+  const lower = lowerLeft + (lowerRight - lowerLeft) * columnMix;
+  return upper + (lower - upper) * rowMix;
+}
+function surfaceDeltaFromSamples(samples, resolution, level) {
+  const sampleCount = Math.max(resolution, level.resolution);
+  let maximum = 0;
+  for (let row = 0; row < sampleCount; row += 1) {
+    for (let column = 0; column < sampleCount; column += 1) {
+      const x = column / (sampleCount - 1);
+      const z = row / (sampleCount - 1);
+      maximum = Math.max(
+        maximum,
+        Math.abs(
+          interpolatedSamplesHeight(samples, resolution, x, z) - interpolatedLevelHeight(level, x, z)
+        )
+      );
+    }
+  }
+  return maximum;
+}
+function seamCoverageDepth(a, b) {
+  const aLevel = a.levels[a.lodLevel];
+  const bLevel = b.levels[b.lodLevel];
+  if (aLevel === void 0 || bLevel === void 0) return 0;
+  return Math.min(aLevel.skirtDepth, bLevel.skirtDepth);
+}
+function bridgeCoverageAt(bridge, a, aSide, b, bSide, normalized) {
+  if (bridge.mesh.geometry !== bridge.geometry)
+    throw new Error("TerrainTiles seam diagnostic bridge geometry is not attached to its mesh.");
+  if (!Number.isInteger(bridge.resolution) || bridge.resolution < 2)
+    throw new Error("TerrainTiles seam diagnostic bridge resolution is invalid.");
+  if (bridge.keys[0] !== (a.key < b.key ? a.key : b.key) || bridge.keys[1] !== (a.key < b.key ? b.key : a.key))
+    throw new Error("TerrainTiles seam diagnostic bridge topology does not match its tile pair.");
+  if (!Number.isFinite(normalized))
+    throw new Error("TerrainTiles seam diagnostic bridge sample coordinate must be finite.");
+  const position = validateBridgeTriangleTopology(bridge.mesh.geometry, bridge.resolution * 2);
+  if (position.count !== bridge.resolution * 2)
+    throw new Error("TerrainTiles seam diagnostic bridge topology has invalid coverage.");
+  const [finer, coarser] = bridgeEndpointPair(a, aSide, b, bSide);
+  bridge.mesh.updateWorldMatrix(true, false);
+  finer.level.mesh.updateWorldMatrix(true, false);
+  coarser.level.mesh.updateWorldMatrix(true, false);
+  const worldPosition = new Vector3();
+  const expectedWorldPosition = new Vector3();
+  const samplePosition = Math.max(0, Math.min(1, normalized)) * (bridge.resolution - 1);
+  const lower = Math.floor(samplePosition);
+  const upper = Math.min(bridge.resolution - 1, lower + 1);
+  const mix = samplePosition - lower;
+  const fine = bridgeEndpointHeight(
+    bridge,
+    position,
+    lower,
+    0,
+    finer.tile,
+    finer.side,
+    finer.level,
+    worldPosition,
+    expectedWorldPosition
+  ) * (1 - mix) + bridgeEndpointHeight(
+    bridge,
+    position,
+    upper,
+    0,
+    finer.tile,
+    finer.side,
+    finer.level,
+    worldPosition,
+    expectedWorldPosition
+  ) * mix;
+  const coarse = bridgeEndpointHeight(
+    bridge,
+    position,
+    lower,
+    1,
+    coarser.tile,
+    coarser.side,
+    coarser.level,
+    worldPosition,
+    expectedWorldPosition
+  ) * (1 - mix) + bridgeEndpointHeight(
+    bridge,
+    position,
+    upper,
+    1,
+    coarser.tile,
+    coarser.side,
+    coarser.level,
+    worldPosition,
+    expectedWorldPosition
+  ) * mix;
+  const coverage = Math.abs(fine - coarse);
+  if (!Number.isFinite(coverage))
+    throw new Error("TerrainTiles seam diagnostic bridge coverage must be finite.");
+  return coverage;
+}
+function seamObservation(a, b, bridge, owner, includeBridgeCoverage) {
+  const [aSide, bSide] = opposingEdge(a, b);
+  const aLevel = renderedLevel(a);
+  const bLevel = renderedLevel(b);
+  if (aLevel === void 0 || bLevel === void 0)
+    throw new Error("TerrainTiles seam diagnostic observation has no rendered level.");
+  const samples = Math.max(aLevel.resolution, bLevel.resolution);
+  const bridgeAttached = includeBridgeCoverage && bridge !== void 0 && bridge.mesh.parent === owner && bridge.mesh.visible === true;
+  let gap = 0;
+  let visualGap = 0;
+  for (let index = 0; index < samples; index += 1) {
+    const normalized = samples === 1 ? 0 : index / (samples - 1);
+    const currentGap = Math.abs(
+      edgeHeight(aLevel, aSide, normalized) - edgeHeight(bLevel, bSide, normalized)
+    );
+    if (!Number.isFinite(currentGap))
+      throw new Error("TerrainTiles seam diagnostic observation must be finite.");
+    gap = Math.max(gap, currentGap);
+    const bridgeCoverage = bridgeAttached ? bridgeCoverageAt(bridge, a, aSide, b, bSide, normalized) : 0;
+    const coverage = Math.max(seamCoverageDepth(a, b), bridgeCoverage);
+    visualGap = Math.max(visualGap, Math.max(0, currentGap - coverage));
+  }
+  if (!Number.isFinite(visualGap))
+    throw new Error("TerrainTiles visual seam diagnostic observation must be finite.");
+  return { gap, visualGap };
+}
+function areNeighbors(a, b) {
+  return Math.abs(a.tileX - b.tileX) + Math.abs(a.tileZ - b.tileZ) === 1;
+}
+function neighborPairKey(pair) {
+  const [a, b] = pair;
+  return a.key < b.key ? `${a.key}|${b.key}` : `${b.key}|${a.key}`;
+}
+function neighborPairs(tiles) {
+  const pairs = [];
+  for (let index = 0; index < tiles.length; index += 1) {
+    const tile = tiles[index];
+    for (let neighborIndex = index + 1; neighborIndex < tiles.length; neighborIndex += 1) {
+      const neighbor = tiles[neighborIndex];
+      if (areNeighbors(tile, neighbor)) pairs.push([tile, neighbor]);
+    }
+  }
+  return pairs;
+}
+function neighborLodCorrection(pair) {
+  const [a, b] = pair;
+  if (Math.abs(a.lodLevel - b.lodLevel) <= 1) return void 0;
+  const finer = a.lodLevel < b.lodLevel ? a : b;
+  const coarser = finer === a ? b : a;
+  return { coarser, level: finer.lodLevel + 1 };
+}
+function reconcileNeighborPair(pair, surface, existingBridge) {
+  const [a, b] = pair;
+  const [aSide, bSide] = opposingEdge(a, b);
+  const aLevel = renderedLevel(a);
+  const bLevel = renderedLevel(b);
+  if (aLevel === void 0 || bLevel === void 0)
+    throw new Error("TerrainTiles cannot reconcile a neighbor with no rendered LOD level.");
+  restoreLevelEdge(a.field, aLevel, aSide);
+  restoreLevelEdge(b.field, bLevel, bSide);
+  if (aLevel.resolution === bLevel.resolution) return void 0;
+  const finer = aLevel.resolution > bLevel.resolution ? a : b;
+  const finerLevel = aLevel.resolution > bLevel.resolution ? aLevel : bLevel;
+  const finerSide = aLevel.resolution > bLevel.resolution ? aSide : bSide;
+  const coarser = finer === a ? b : a;
+  const coarserLevel = finer === a ? bLevel : aLevel;
+  const coarserSide = finer === a ? bSide : aSide;
+  const data = stitchGeometryData(finer, finerLevel, finerSide, coarser, coarserLevel, coarserSide);
+  if (existingBridge === void 0) {
+    const geometry = stitchGeometry(data);
+    const mesh = new Mesh(geometry, surface);
+    mesh.frustumCulled = true;
+    return {
+      bytes: geometryBytes(geometry),
+      coverageDepth: data.coverageDepth,
+      geometry,
+      keys: [a.key, b.key].sort(),
+      mesh,
+      resolution: finerLevel.resolution
+    };
+  }
+  updateStitchBridge(existingBridge, data);
+  return existingBridge;
+}
+function setManualLodLevel(lod, level) {
+  lod._currentLevel = level;
+}
+var TerrainTiles = class extends Object3D {
+  residentTileBudget;
+  residentByteBudget;
+  skirtDepth;
+  tileResolution;
+  tileSize;
+  processCadence = "render";
+  #assets;
+  #assetKey;
+  #createCollider;
+  #factors;
+  #lodDistances;
+  #surface;
+  #sampleHeight;
+  #streamRadius;
+  /** Canonical topology samples retained only for the declared diagnostics region. */
+  #topologyField;
+  #topologyBytes;
+  #worldPasses;
+  #resident = /* @__PURE__ */ new Map();
+  #topologyMetrics;
+  #focus;
+  #peakBytes = 0;
+  #peakTiles = 0;
+  #lodTransitions = 0;
+  #maxLodPop = 0;
+  #maxLodTransitionFrames = 0;
+  // These diagnostics are lifetime maxima for this residency owner. Zero is the deliberate
+  // empty/evicted value; each finite live-geometry observation can only increase it.
+  #maxSeamGap = 0;
+  #maxVisualSeamGap = 0;
+  #stitchedEdges = 0;
+  #stitchBytes = 0;
+  #stitches = /* @__PURE__ */ new Map();
+  #released = false;
+  #renderer;
+  constructor(options) {
+    super();
+    this.tileSize = positive(options.tileSize, "tileSize");
+    this.tileResolution = integerAtLeast(options.tileResolution, 3, "tileResolution");
+    this.residentTileBudget = integerAtLeast(options.residentTileBudget, 1, "residentTileBudget");
+    this.residentByteBudget = integerAtLeast(options.residentByteBudget, 1, "residentByteBudget");
+    this.skirtDepth = positive(options.skirtDepth ?? this.tileSize, "skirtDepth");
+    this.#streamRadius = integerAtLeast(options.streamRadius ?? 1, 0, "streamRadius");
+    this.#surface = options.surface;
+    if (options.surface === void 0 || options.surface === null)
+      throw new Error("TerrainTiles surface is required and must be game-owned.");
+    this.#sampleHeight = options.sampleHeight;
+    if (typeof options.sampleHeight !== "function")
+      throw new Error("TerrainTiles sampleHeight is required.");
+    this.#factors = [...options.lodFactors ?? [1, 2, 4]];
+    if (this.#factors.length < 1) throw new Error("TerrainTiles lodFactors must not be empty.");
+    for (const factor of this.#factors) integerAtLeast(factor, 1, "lod factor");
+    for (const factor of this.#factors) resolutionFor(this.tileResolution, factor);
+    this.#lodDistances = [...options.lodDistances ?? [this.tileSize * 2, this.tileSize * 4]];
+    if (this.#lodDistances.length !== this.#factors.length - 1)
+      throw new Error("TerrainTiles lodDistances must contain one threshold per LOD transition.");
+    this.#lodDistances.forEach((distance, index) => {
+      positive(distance, `lodDistances[${String(index)}]`);
+      if (index > 0 && distance <= this.#lodDistances[index - 1])
+        throw new Error("TerrainTiles lodDistances must be strictly increasing.");
+    });
+    if (options.assetKey !== void 0 && options.assets === void 0)
+      throw new Error("TerrainTiles assetKey requires an assets.release consumer.");
+    this.#assets = options.assets;
+    this.#assetKey = options.assetKey;
+    this.#createCollider = options.createCollider;
+    this.#worldPasses = options.worldPasses;
+    if (options.topologyObservation !== void 0)
+      validateTopologyObservation(options.topologyObservation, this.tileSize, this.tileResolution);
+    this.#topologyField = options.topologyObservation === void 0 ? void 0 : Heightfield.fromSampler({
+      ...options.topologyObservation,
+      sampleHeight: this.#sampleHeight,
+      ...this.#worldPasses === void 0 ? {} : { worldPasses: this.#worldPasses }
+    });
+    this.#topologyBytes = this.#topologyField?.memoryBytes ?? 0;
+    if (this.#topologyBytes > this.residentByteBudget)
+      throw new Error("TerrainTiles residentByteBudget cannot fit the topology observation.");
+    this.#recordPeaks();
+    this.#recordSeamDiagnostics();
+    this.frustumCulled = true;
+  }
+  get released() {
+    return this.#released;
+  }
+  get residentTileCount() {
+    return this.#resident.size;
+  }
+  get residentBytes() {
+    return this.#topologyBytes + this.#stitchBytes + [...this.#resident.values()].reduce((total, tile) => total + tile.bytes, 0);
+  }
+  get peakResidentTileCount() {
+    return this.#peakTiles;
+  }
+  get peakResidentBytes() {
+    return this.#peakBytes;
+  }
+  get residentKeys() {
+    return [...this.#resident.keys()].sort();
+  }
+  get residentColliderKeys() {
+    return [...this.#resident.values()].filter((tile) => tile.collider !== void 0).map((tile) => tile.key).sort();
+  }
+  get lodLevelCount() {
+    return this.#factors.length;
+  }
+  get lodTransitions() {
+    return this.#lodTransitions;
+  }
+  /** Maximum per-render-frame displacement of the visible LOD surface during transitions. */
+  get maxLodPop() {
+    return this.#maxLodPop;
+  }
+  /** Maximum number of rendered frames during which an LOD transition remained observable. */
+  get maxLodTransitionFrames() {
+    return this.#maxLodTransitionFrames;
+  }
+  /** Maximum visible edge gap observed across follow/process calls for this residency owner. */
+  get maxSeamGap() {
+    return this.#maxSeamGap;
+  }
+  /** Maximum remaining visible gap after skirt or bridge coverage observed across follow/process calls. */
+  get maxVisualSeamGap() {
+    return this.#maxVisualSeamGap;
+  }
+  /** Number of mixed-LOD edge reconciliations observed during this residency lifetime. */
+  get stitchedEdgeCount() {
+    return this.#stitchedEdges;
+  }
+  get warmupNodes() {
+    return [
+      ...this.#topologyField?.warmupNodes ?? [],
+      ...[...this.#resident.values()].flatMap((tile) => tile.field.warmupNodes)
+    ];
+  }
+  getTile(key) {
+    return this.#resident.get(key);
+  }
+  follow(position) {
+    if (this.#released) throw new Error("TerrainTiles cannot follow after release.");
+    const x = finite2(position.x, "follow x");
+    const z = finite2(position.z, "follow z");
+    const hadFocus = this.#focus !== void 0;
+    this.#focus = { x, z };
+    const centerX = Math.floor((x + this.tileSize / 2) / this.tileSize);
+    const centerZ = Math.floor((z + this.tileSize / 2) / this.tileSize);
+    const wanted = [];
+    for (let tileZ = centerZ - this.#streamRadius; tileZ <= centerZ + this.#streamRadius; tileZ += 1) {
+      for (let tileX = centerX - this.#streamRadius; tileX <= centerX + this.#streamRadius; tileX += 1) {
+        const tileCenterX = tileX * this.tileSize;
+        const tileCenterZ = tileZ * this.tileSize;
+        wanted.push({
+          distance: Math.hypot(x - tileCenterX, z - tileCenterZ),
+          tileX,
+          tileZ
+        });
+      }
+    }
+    wanted.sort((a, b) => a.distance - b.distance || a.tileZ - b.tileZ || a.tileX - b.tileX);
+    const selected = wanted.slice(0, this.residentTileBudget);
+    const selectedKeys = new Set(selected.map(({ tileX, tileZ }) => keyFor(tileX, tileZ)));
+    for (const tile of [...this.#resident.values()]) {
+      if (!selectedKeys.has(tile.key)) this.#evict(tile);
+    }
+    for (const candidate of selected) {
+      const key = keyFor(candidate.tileX, candidate.tileZ);
+      if (this.#resident.has(key)) {
+        this.#selectLod(this.#resident.get(key), candidate.distance);
+        continue;
+      }
+      const estimate = estimatedTileBytes(this.tileResolution, this.#factors, this.#worldPasses);
+      if (this.residentBytes + estimate > this.residentByteBudget) {
+        if (candidate.tileX === centerX && candidate.tileZ === centerZ)
+          throw new Error("TerrainTiles residentByteBudget cannot fit the followed tile.");
+        continue;
+      }
+      const tile = this.#createTile(candidate.tileX, candidate.tileZ, candidate.distance);
+      if (this.residentBytes + tile.bytes > this.residentByteBudget) {
+        this.#disposeTile(tile);
+        if (candidate.tileX === centerX && candidate.tileZ === centerZ)
+          throw new Error("TerrainTiles residentByteBudget cannot fit the followed tile.");
+        continue;
+      }
+      this.#resident.set(tile.key, tile);
+      this.add(tile.lod);
+      this.#recordPeaks();
+    }
+    this.#recordPeaks();
+    this.#coordinateNeighborLods(hadFocus);
+    this.#recordSeamDiagnostics(false);
+    this.#reconcileNeighbors();
+    this.#recordSeamDiagnostics();
+    this.#recordPeaks();
+  }
+  heightAt(x, z) {
+    return this.#fieldAt(x, z).heightAt(x, z);
+  }
+  normalAt(x, z, target = new Vector3()) {
+    return this.#fieldAt(x, z).normalAt(x, z, target);
+  }
+  sample(channel, x, z) {
+    if (channel === "slope") return 1 - this.normalAt(x, z).y;
+    return this.#fieldAt(x, z).sample(channel, x, z);
+  }
+  attachRenderer(renderer) {
+    if (this.#released) throw new Error("TerrainTiles cannot attach after release.");
+    this.#renderer = renderer;
+    this.#topologyField?.attachRenderer(renderer);
+    for (const tile of this.#resident.values()) tile.field.attachRenderer(renderer);
+  }
+  process(renderer = this.#renderer) {
+    if (this.#released) return;
+    const lodFrame = this.#captureLodFrame();
+    this.#advanceLodTransitions();
+    if (renderer !== void 0) {
+      this.#topologyField?.process(renderer);
+      for (const tile of this.#resident.values()) {
+        tile.field.attachRenderer(renderer);
+        tile.field.process(renderer);
+      }
+    }
+    this.#recordSeamDiagnostics(false);
+    this.#reconcileNeighbors();
+    this.#recordSeamDiagnostics();
+    this.#recordLodPopAfterReconciliation(lodFrame);
+    this.#recordPeaks();
+  }
+  debug() {
+    const topologyField = this.#topologyField;
+    const topology = topologyField === void 0 ? void 0 : (() => {
+      const heights = topologyField.heights;
+      const flow = topologyField.flow;
+      const description = {
+        columns: topologyField.columns,
+        depth: topologyField.depth,
+        origin: topologyField.origin,
+        rows: topologyField.rows,
+        width: topologyField.width
+      };
+      if (heights.length <= MAX_RAW_TOPOLOGY_SAMPLES)
+        return {
+          ...description,
+          heights: Array.from(heights),
+          ...flow === void 0 ? {} : { flow: Array.from(flow) }
+        };
+      if (flow === void 0) return description;
+      if (this.#topologyMetrics === void 0)
+        this.#topologyMetrics = summarizeWorldTopology({
+          columns: topologyField.columns,
+          depth: topologyField.depth,
+          flow,
+          heights,
+          rows: topologyField.rows,
+          width: topologyField.width
+        });
+      return {
+        ...description,
+        metrics: this.#topologyMetrics
+      };
+    })();
+    return {
+      maxSeamGap: this.maxSeamGap,
+      maxVisualSeamGap: this.maxVisualSeamGap,
+      maxLodTransitionFrames: this.#maxLodTransitionFrames,
+      peakResidentBytes: this.#peakBytes,
+      peakResidentTiles: this.#peakTiles,
+      residentBytes: this.residentBytes,
+      residentByteBudget: this.residentByteBudget,
+      residentKeys: this.residentKeys,
+      residentTiles: this.residentTileCount,
+      residentTileBudget: this.residentTileBudget,
+      topologyBytes: this.#topologyBytes,
+      lodTransitions: this.#lodTransitions,
+      maxLodPop: this.#maxLodPop,
+      stitchedEdges: this.#stitchedEdges,
+      skirtVertexCount: [...this.#resident.values()].reduce(
+        (total, tile) => total + tile.skirtVertexCount,
+        0
+      ),
+      released: this.#released,
+      ...topology === void 0 ? {} : { topology }
+    };
+  }
+  detach() {
+    this.dispose();
+  }
+  dispose() {
+    if (this.#released) return;
+    this.#released = true;
+    this.#renderer = void 0;
+    this.#topologyField?.detach();
+    for (const tile of [...this.#resident.values()]) this.#evict(tile);
+    this.#resident.clear();
+    this.removeFromParent();
+  }
+  #createField(origin) {
+    const sampler = {
+      columns: this.tileResolution,
+      depth: this.tileSize,
+      origin,
+      rows: this.tileResolution,
+      sampleHeight: this.#sampleHeight,
+      width: this.tileSize,
+      ...this.#worldPasses === void 0 ? {} : { worldPasses: this.#worldPasses }
+    };
+    return Heightfield.fromSampler(sampler);
+  }
+  #createTile(tileX, tileZ, distance) {
+    const origin = { x: tileX * this.tileSize, z: tileZ * this.tileSize };
+    const assetKey = this.#assetKey === void 0 ? void 0 : typeof this.#assetKey === "function" ? this.#assetKey(tileX, tileZ) : this.#assetKey;
+    if (assetKey !== void 0 && (typeof assetKey !== "string" || assetKey.trim().length === 0))
+      throw new Error("TerrainTiles assetKey must resolve to a non-empty string.");
+    const field = this.#createField(origin);
+    const levels = [];
+    let lod;
+    let collider;
+    try {
+      for (const factor of this.#factors)
+        levels.push(
+          buildLevel(
+            field,
+            resolutionFor(this.tileResolution, factor),
+            this.skirtDepth,
+            this.#surface
+          )
+        );
+      lod = new LOD();
+      lod.autoUpdate = false;
+      lod.position.set(origin.x, 0, origin.z);
+      levels.forEach(({ mesh }, index) => {
+        mesh.visible = index === 0;
+        lod?.addLevel(mesh, index === 0 ? 0 : this.#lodDistances[index - 1]);
+        mesh.frustumCulled = true;
+      });
+      collider = this.#createCollider?.({ field, key: keyFor(tileX, tileZ), object: lod, tileX, tileZ }) ?? new EmptyCollider();
+      const bytes = levels.reduce((total, level) => total + estimatedLevelBytes(level.resolution), 0) + field.memoryBytes;
+      const tile = {
+        ...assetKey === void 0 ? {} : { assetKey },
+        bytes,
+        collider,
+        field,
+        key: keyFor(tileX, tileZ),
+        lod,
+        lodLevel: 0,
+        levels,
+        object: lod,
+        origin,
+        skirtVertexCount: levels.reduce((total, level) => total + level.skirtVertexCount, 0),
+        skirts: this.skirtDepth,
+        tileX,
+        tileZ
+      };
+      this.#selectLod(tile, distance, false);
+      return tile;
+    } catch (error) {
+      collider?.dispose();
+      lod?.removeFromParent();
+      for (const level of levels) level.geometry.dispose();
+      field.detach();
+      throw error;
+    }
+  }
+  #selectLod(tile, distance, countTransition = true) {
+    this.#setLodLevel(tile, lodLevelForDistance(distance, this.#lodDistances), countTransition);
+  }
+  #setLodLevel(tile, level, countTransition = true) {
+    if (level === tile.lodLevel) {
+      setManualLodLevel(tile.lod, level);
+      return;
+    }
+    const interruptedFrame = tile.lodTransition === void 0 ? void 0 : this.#captureLodFrameForTile(tile);
+    if (tile.lodTransition !== void 0) this.#finishLodTransition(tile);
+    const previousLevel = tile.lodLevel;
+    const previous = tile.levels[previousLevel];
+    const next = tile.levels[level];
+    if (previous === void 0 || next === void 0)
+      throw new Error("TerrainTiles LOD transition references a missing level.");
+    tile.lodLevel = level;
+    if (!countTransition) {
+      setManualLodLevel(tile.lod, level);
+      this.#setLodVisibility(tile);
+      this.#recordLodPopAfterRetarget(interruptedFrame);
+      return;
+    }
+    this.#lodTransitions += 1;
+    tile.lodTransition = {
+      elapsedFrames: 0,
+      from: previousLevel,
+      remainingFrames: LOD_TRANSITION_FRAMES,
+      to: level
+    };
+    const finerLevel = previous.resolution >= next.resolution ? previousLevel : level;
+    previous.resolution >= next.resolution ? previous : next;
+    setManualLodLevel(tile.lod, finerLevel);
+    updateLodTransitionGeometry(tile, tile.lodTransition, 0);
+    this.#setLodVisibility(tile, [finerLevel]);
+    this.#recordLodPopAfterRetarget(interruptedFrame);
+  }
+  #setLodVisibility(tile, visibleLevels = [tile.lodLevel]) {
+    const visible = new Set(visibleLevels);
+    tile.levels.forEach(({ mesh }, index) => {
+      mesh.visible = visible.has(index);
+    });
+  }
+  #captureLodFrame() {
+    const snapshots = [];
+    for (const tile of this.#resident.values()) {
+      if (tile.lodTransition === void 0) continue;
+      snapshots.push(this.#captureLodFrameForTile(tile));
+    }
+    return snapshots;
+  }
+  #captureLodFrameForTile(tile) {
+    const level = renderedLevel(tile);
+    if (level === void 0)
+      throw new Error("TerrainTiles cannot measure an LOD transition without a visible level.");
+    return { heights: surfaceHeights(level), resolution: level.resolution, tile };
+  }
+  #recordLodPopAfterReconciliation(snapshots) {
+    for (const snapshot of snapshots) {
+      const level = renderedLevel(snapshot.tile);
+      if (level === void 0)
+        throw new Error("TerrainTiles cannot measure an LOD frame without a visible level.");
+      this.#recordLodPop(surfaceDeltaFromSamples(snapshot.heights, snapshot.resolution, level));
+    }
+  }
+  #recordLodPopAfterRetarget(snapshot) {
+    if (snapshot === void 0) return;
+    const level = renderedLevel(snapshot.tile);
+    if (level === void 0)
+      throw new Error(
+        "TerrainTiles cannot measure a retargeted LOD frame without a visible level."
+      );
+    this.#recordLodPop(surfaceDeltaFromSamples(snapshot.heights, snapshot.resolution, level));
+  }
+  #advanceLodTransitions() {
+    for (const tile of this.#resident.values()) {
+      const transition = tile.lodTransition;
+      if (transition === void 0) continue;
+      const from = tile.levels[transition.from];
+      if (from === void 0 || tile.levels[transition.to] === void 0)
+        throw new Error("TerrainTiles LOD transition references a missing level.");
+      transition.elapsedFrames += 1;
+      transition.remainingFrames -= 1;
+      updateLodTransitionGeometry(
+        tile,
+        transition,
+        Math.min(1, transition.elapsedFrames / LOD_TRANSITION_FRAMES)
+      );
+      if (transition.remainingFrames > 0) continue;
+      this.#maxLodTransitionFrames = Math.max(
+        this.#maxLodTransitionFrames,
+        transition.elapsedFrames
+      );
+      this.#restoreLodTransition(tile, transition);
+      tile.lodTransition = void 0;
+      setManualLodLevel(tile.lod, transition.to);
+      this.#setLodVisibility(tile);
+    }
+  }
+  #coordinateNeighborLods(countTransitions) {
+    const pairs = neighborPairs([...this.#resident.values()]);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const pair of pairs) {
+        const correction = neighborLodCorrection(pair);
+        if (correction === void 0) continue;
+        this.#setLodLevel(correction.coarser, correction.level, countTransitions);
+        changed = true;
+      }
+    }
+  }
+  #reconcileNeighbors() {
+    const pairs = neighborPairs([...this.#resident.values()]);
+    const active = /* @__PURE__ */ new Set();
+    for (const pair of pairs) {
+      const key = neighborPairKey(pair);
+      active.add(key);
+      const previousBytes = this.#stitches.get(key)?.bytes ?? 0;
+      const bridge = reconcileNeighborPair(pair, this.#surface, this.#stitches.get(key));
+      if (bridge === void 0) {
+        this.#removeStitch(key);
+        continue;
+      }
+      if (this.#stitches.has(key)) {
+        this.#stitchBytes += bridge.bytes - previousBytes;
+      } else {
+        this.#stitches.set(key, bridge);
+        this.add(bridge.mesh);
+        this.#stitchBytes += bridge.bytes;
+      }
+      this.#stitchedEdges += 1;
+    }
+    for (const key of this.#stitches.keys()) {
+      if (!active.has(key)) this.#removeStitch(key);
+    }
+    if (this.residentBytes > this.residentByteBudget)
+      throw new Error("TerrainTiles residentByteBudget cannot fit stitched neighbor geometry.");
+  }
+  #finishLodTransition(tile) {
+    const transition = tile.lodTransition;
+    if (transition === void 0) return;
+    this.#maxLodTransitionFrames = Math.max(this.#maxLodTransitionFrames, transition.elapsedFrames);
+    this.#restoreLodTransition(tile, transition);
+    tile.lodTransition = void 0;
+    setManualLodLevel(tile.lod, transition.to);
+    this.#setLodVisibility(tile);
+  }
+  #restoreLodTransition(tile, transition) {
+    const from = tile.levels[transition.from];
+    const to = tile.levels[transition.to];
+    if (from === void 0 || to === void 0) return;
+    restoreLevelSurface(tile.field, from.resolution >= to.resolution ? from : to);
+  }
+  #recordLodPop(pop) {
+    if (!Number.isFinite(pop)) throw new Error("TerrainTiles LOD pop observation must be finite.");
+    this.#maxLodPop = Math.max(this.#maxLodPop, pop);
+    if (pop > LOD_POP_THRESHOLD)
+      throw new Error(
+        `TerrainTiles LOD pop threshold ${String(LOD_POP_THRESHOLD)} exceeded by ${String(pop)}.`
+      );
+  }
+  #removeStitch(key) {
+    const bridge = this.#stitches.get(key);
+    if (bridge === void 0) return;
+    this.#stitches.delete(key);
+    this.remove(bridge.mesh);
+    this.#stitchBytes -= bridge.bytes;
+    bridge.geometry.dispose();
+  }
+  #removeStitchesForTile(tileKey) {
+    for (const [key, bridge] of this.#stitches) {
+      if (bridge.keys.includes(tileKey)) this.#removeStitch(key);
+    }
+  }
+  #recordSeamDiagnostics(includeBridgeCoverage = true) {
+    const tiles = [...this.#resident.values()];
+    for (const tile of tiles) {
+      for (const neighbor of tiles) {
+        if (tile.key >= neighbor.key || !areNeighbors(tile, neighbor)) continue;
+        const { gap, visualGap } = seamObservation(
+          tile,
+          neighbor,
+          this.#stitches.get(neighborPairKey([tile, neighbor])),
+          this,
+          includeBridgeCoverage
+        );
+        this.#maxSeamGap = Math.max(this.#maxSeamGap, gap);
+        this.#maxVisualSeamGap = Math.max(this.#maxVisualSeamGap, visualGap);
+      }
+    }
+  }
+  #fieldAt(x, z) {
+    finite2(x, "query x");
+    finite2(z, "query z");
+    const tileX = Math.floor((x + this.tileSize / 2) / this.tileSize);
+    const tileZ = Math.floor((z + this.tileSize / 2) / this.tileSize);
+    const tile = this.#resident.get(keyFor(tileX, tileZ));
+    if (tile === void 0)
+      throw new Error(`TerrainTiles query (${x}, ${z}) is outside its resident region.`);
+    return tile.field;
+  }
+  #evict(tile) {
+    if (this.#resident.get(tile.key) === tile) this.#resident.delete(tile.key);
+    this.#removeStitchesForTile(tile.key);
+    this.remove(tile.lod);
+    tile.collider.dispose();
+    tile.field.detach();
+    for (const level of tile.levels) level.geometry.dispose();
+    this.#releaseAsset(tile);
+  }
+  #disposeTile(tile) {
+    tile.collider.dispose();
+    tile.field.detach();
+    for (const level of tile.levels) level.geometry.dispose();
+    tile.lod.removeFromParent();
+    this.#releaseAsset(tile);
+  }
+  #releaseAsset(tile) {
+    if (this.#assets === void 0 || tile.assetKey === void 0) return;
+    const stillReferenced = [...this.#resident.values()].some(
+      (resident) => resident !== tile && resident.assetKey === tile.assetKey
+    );
+    if (!stillReferenced) this.#assets.release("model", tile.assetKey);
+  }
+  #recordPeaks() {
+    this.#peakTiles = Math.max(this.#peakTiles, this.residentTileCount);
+    this.#peakBytes = Math.max(this.#peakBytes, this.residentBytes);
+  }
+};
+
+// src/world-capabilities.ts
+var DEFAULT_LIMITS = {
+  maxComputeInvocationsPerWorkgroup: 0,
+  maxComputeWorkgroupsPerDimension: 0,
+  maxStorageBufferBindingSize: 0
+};
+function finite3(value, name, minimum = 0) {
+  if (!Number.isFinite(value) || value < minimum)
+    throw new Error(`World capabilities ${name} must be finite and at least ${String(minimum)}.`);
+  return value;
+}
+function integer(value, name, minimum = 0) {
+  if (!Number.isInteger(value) || value < minimum)
+    throw new Error(
+      `World capabilities ${name} must be an integer of at least ${String(minimum)}.`
+    );
+  return value;
+}
+function resolveLimits(limits) {
+  return {
+    maxComputeInvocationsPerWorkgroup: finite3(
+      limits?.maxComputeInvocationsPerWorkgroup ?? DEFAULT_LIMITS.maxComputeInvocationsPerWorkgroup,
+      "maxComputeInvocationsPerWorkgroup"
+    ),
+    maxComputeWorkgroupsPerDimension: finite3(
+      limits?.maxComputeWorkgroupsPerDimension ?? DEFAULT_LIMITS.maxComputeWorkgroupsPerDimension,
+      "maxComputeWorkgroupsPerDimension"
+    ),
+    maxStorageBufferBindingSize: finite3(
+      limits?.maxStorageBufferBindingSize ?? DEFAULT_LIMITS.maxStorageBufferBindingSize,
+      "maxStorageBufferBindingSize"
+    )
+  };
+}
+function getWorldCapabilities(options = {}) {
+  const minimumWorkgroups = integer(
+    options.minimumWorkgroupsPerDimension ?? 1,
+    "minimumWorkgroupsPerDimension",
+    1
+  );
+  const minimumStorage = finite3(
+    options.minimumStorageBufferBindingSize ?? 1,
+    "minimumStorageBufferBindingSize",
+    1
+  );
+  const fallbackIterations = integer(options.cpuFallbackIterations ?? 0, "cpuFallbackIterations");
+  const limits = resolveLimits(options.limits);
+  const hasReportedLimits = options.limits?.maxComputeInvocationsPerWorkgroup !== void 0 && options.limits?.maxComputeWorkgroupsPerDimension !== void 0 && options.limits?.maxStorageBufferBindingSize !== void 0;
+  const gpuAvailable = options.gpuAvailable ?? false;
+  const meetsRequirements = hasReportedLimits && limits.maxComputeInvocationsPerWorkgroup > 0 && limits.maxComputeWorkgroupsPerDimension >= minimumWorkgroups && limits.maxStorageBufferBindingSize >= minimumStorage;
+  const reason = !gpuAvailable ? "GPU compute is unavailable on this host." : !hasReportedLimits ? "GPU compute limits were not reported by the host." : !meetsRequirements ? `GPU limits are below the required workgroup (${String(minimumWorkgroups)}) or storage-buffer (${String(minimumStorage)}) floor.` : "GPU compute is available, but canonical GPU world-field readback is unsupported.";
+  if (fallbackIterations > 0)
+    return {
+      compute: false,
+      cpuFallbackIterations: fallbackIterations,
+      generation: "cpu-fallback",
+      gpu: gpuAvailable,
+      limits,
+      reason: `${reason} Using ${String(fallbackIterations)} reduced CPU erosion iterations.`
+    };
+  return {
+    compute: false,
+    cpuFallbackIterations: 0,
+    generation: "unsupported",
+    gpu: gpuAvailable,
+    limits,
+    reason
+  };
+}
+
+// src/world.ts
+function finite4(value, name) {
+  if (!Number.isFinite(value)) throw new Error(`Heightfield ${name} must be finite.`);
+  return value;
+}
+function positive2(value, name) {
+  finite4(value, name);
+  if (value <= 0) throw new Error(`Heightfield ${name} must be greater than zero.`);
+  return value;
+}
+function count(value, name) {
+  if (!Number.isInteger(value) || value < 2)
+    throw new Error(`Heightfield ${name} must be an integer of at least 2.`);
+  return value;
+}
+function shouldBuildGpuPasses(options) {
+  return options?.gpu === true;
+}
+function validateWorldPassBudget(options) {
+  if (!Number.isInteger(options.dispatchBudget) || options.dispatchBudget <= 0)
+    throw new Error("Heightfield world passes dispatchBudget must be a positive integer.");
+  if (options.gpu === true) return;
+  if (!Number.isInteger(options.erosion.iterations) || options.erosion.iterations < 0) return;
+  if (options.erosion.iterations > options.dispatchBudget)
+    throw new Error("Heightfield dispatchBudget cannot cover synchronous CPU erosion iterations.");
+}
+var Heightfield = class _Heightfield extends Group {
+  columns;
+  depth;
+  origin;
+  rows;
+  width;
+  processCadence = "render";
+  warmupNodes;
+  #cellDepth;
+  #cellWidth;
+  #colliderHeights;
+  #heights;
+  #minimumX;
+  #minimumZ;
+  #flow;
+  #moisture;
+  #gpu;
+  #heightReadback;
+  #flowReadback;
+  #moistureReadback;
+  #renderer;
+  #gpuCompletionObserved = false;
+  #released = false;
+  constructor(options) {
+    super();
+    this.columns = count(options.columns, "columns");
+    this.rows = count(options.rows, "rows");
+    this.width = positive2(options.width, "width");
+    this.depth = positive2(options.depth, "depth");
+    this.origin = {
+      x: finite4(options.origin.x, "origin.x"),
+      z: finite4(options.origin.z, "origin.z")
+    };
+    const expected = this.rows * this.columns;
+    if (options.heights.length !== expected)
+      throw new Error(
+        `Heightfield expected ${expected} heights, received ${options.heights.length}.`
+      );
+    if (options.flow !== void 0 && options.flow.length !== expected)
+      throw new Error(
+        `Heightfield expected ${expected} flow samples, received ${options.flow.length}.`
+      );
+    if (options.moisture !== void 0 && options.moisture.length !== expected)
+      throw new Error(
+        `Heightfield expected ${expected} moisture samples, received ${options.moisture.length}.`
+      );
+    for (const height2 of options.heights) finite4(height2, "height sample");
+    for (const value of options.flow ?? []) finite4(value, "flow sample");
+    for (const value of options.moisture ?? []) finite4(value, "moisture sample");
+    const baseHeights = options.heights.slice();
+    const storedFlow = options.flow?.slice();
+    const storedMoisture = options.moisture?.slice();
+    const passOptions = options.worldPasses;
+    if (passOptions !== void 0) validateWorldPassBudget(passOptions);
+    if (passOptions?.gpu === true)
+      throw new Error(
+        "Heightfield GPU generation cannot be canonical; use gpu: false until GPU readback owns the field."
+      );
+    const cpu = passOptions === void 0 ? void 0 : simulateWorldPassesCpu({
+      cellDepth: this.depth / (this.rows - 1),
+      cellWidth: this.width / (this.columns - 1),
+      columns: this.columns,
+      erosion: passOptions.erosion,
+      heights: baseHeights,
+      rows: this.rows
+    });
+    this.#heights = cpu?.heights ?? baseHeights;
+    this.#flow = cpu?.flow ?? storedFlow;
+    this.#moisture = cpu?.moisture ?? storedMoisture;
+    this.#gpu = passOptions === void 0 || !shouldBuildGpuPasses(passOptions) ? void 0 : createWorldGpuPasses({
+      cellDepth: this.depth / (this.rows - 1),
+      cellWidth: this.width / (this.columns - 1),
+      columns: this.columns,
+      dispatchBudget: passOptions.dispatchBudget,
+      erosion: passOptions.erosion,
+      heights: baseHeights,
+      rows: this.rows
+    });
+    this.warmupNodes = this.#gpu?.stages.flatMap((stage) => stage.nodes) ?? [];
+    this.#heightReadback = this.#gpu === void 0 ? void 0 : new GPUReadback({ attribute: this.#gpu.height.value, everyFrames: 1 });
+    this.#flowReadback = this.#gpu === void 0 ? void 0 : new GPUReadback({ attribute: this.#gpu.flow.value, everyFrames: 1 });
+    this.#moistureReadback = this.#gpu === void 0 ? void 0 : new GPUReadback({ attribute: this.#gpu.moisture.value, everyFrames: 1 });
+    this.#colliderHeights = new Float32Array(expected);
+    for (let column = 0; column < this.columns; column += 1) {
+      for (let row = 0; row < this.rows; row += 1) {
+        this.#colliderHeights[column * this.rows + row] = this.#height(row * this.columns + column);
+      }
+    }
+    this.#cellWidth = this.width / (this.columns - 1);
+    this.#cellDepth = this.depth / (this.rows - 1);
+    this.#minimumX = this.origin.x - this.width / 2;
+    this.#minimumZ = this.origin.z - this.depth / 2;
+  }
+  static fromSampler(options) {
+    const columns = count(options.columns, "columns");
+    const rows = count(options.rows, "rows");
+    const width = positive2(options.width, "width");
+    const depth = positive2(options.depth, "depth");
+    const originX = finite4(options.origin.x, "origin.x");
+    const originZ = finite4(options.origin.z, "origin.z");
+    const minimumX = originX - width / 2;
+    const minimumZ = originZ - depth / 2;
+    const cellWidth = width / (columns - 1);
+    const cellDepth = depth / (rows - 1);
+    const heights = new Float32Array(rows * columns);
+    for (let row = 0; row < rows; row += 1) {
+      const z = minimumZ + row * cellDepth;
+      for (let column = 0; column < columns; column += 1) {
+        const x = minimumX + column * cellWidth;
+        heights[row * columns + column] = finite4(options.sampleHeight(x, z), "sampleHeight result");
+      }
+    }
+    return new _Heightfield({
+      columns,
+      depth,
+      heights,
+      origin: options.origin,
+      rows,
+      width,
+      ...options.worldPasses === void 0 ? {} : { worldPasses: options.worldPasses }
+    });
+  }
+  sample(channel, x, z) {
+    if (channel === "height") return this.heightAt(x, z);
+    if (channel === "slope") return 1 - this.normalAt(x, z).y;
+    const values = channel === "flow" ? this.#flow : channel === "moisture" ? this.#moisture : void 0;
+    if (values === void 0) throw new Error(`Heightfield unknown channel '${channel}'.`);
+    return this.#interpolateValues(values, x, z);
+  }
+  get released() {
+    return this.#released;
+  }
+  get generationComplete() {
+    return this.#gpu?.queue.complete ?? true;
+  }
+  get gpuHeightSample() {
+    return this.#heightReadback?.sample;
+  }
+  attachRenderer(renderer) {
+    if (this.#released) throw new Error("Heightfield cannot be attached after release.");
+    if (this.#gpu === void 0) return;
+    if (renderer.kind !== "webgpu") throw new Error("Heightfield world passes require WebGPU.");
+    if (this.#renderer !== void 0 && this.#renderer !== renderer)
+      throw new Error("Heightfield is already attached to a renderer.");
+    this.#renderer = renderer;
+  }
+  process(renderer = this.#renderer) {
+    if (this.#released || this.#gpu === void 0) return;
+    if (renderer === void 0) throw new Error("Heightfield is not attached to a renderer.");
+    const submitted = this.#gpu.queue.process(renderer);
+    if (submitted > 0 || !this.#gpu.queue.complete) {
+      this.#gpuCompletionObserved = false;
+      return;
+    }
+    if (!this.#gpuCompletionObserved) {
+      this.#gpuCompletionObserved = true;
+      return;
+    }
+    if (this.#heightReadback?.sample === void 0) {
+      this.#heightReadback?.request(renderer);
+      return;
+    }
+    if (this.#flowReadback?.sample === void 0) {
+      this.#flowReadback?.request(renderer);
+      return;
+    }
+    if (this.#moistureReadback?.sample === void 0) this.#moistureReadback?.request(renderer);
+  }
+  debug() {
+    return {
+      complete: this.generationComplete,
+      dispatched: this.#gpu?.queue.dispatched ?? 0,
+      gpuHeightMaxError: this.#sampleError(this.#heightReadback?.sample, this.#heights),
+      gpuFlowMaxError: this.#sampleError(this.#flowReadback?.sample, this.#flow),
+      gpuMoistureMaxError: this.#sampleError(this.#moistureReadback?.sample, this.#moisture),
+      released: this.#released
+    };
+  }
+  detach() {
+    if (this.#released) return;
+    this.#renderer = void 0;
+    this.#heightReadback?.dispose();
+    this.#flowReadback?.dispose();
+    this.#moistureReadback?.dispose();
+    this.#gpu?.dispose();
+    this.#released = true;
+  }
+  /** A copy of the canonical row-major samples, safe for game-side analysis. */
+  get heights() {
+    return this.#heights.slice();
+  }
+  /** A copy of the normalized routed-flow channel, when world passes were requested. */
+  get flow() {
+    return this.#flow?.slice();
+  }
+  /** Bytes retained by this field's CPU channels and its conservative GPU allowance. */
+  get memoryBytes() {
+    const sampleBytes = this.rows * this.columns * Float32Array.BYTES_PER_ELEMENT;
+    const cpuBytes = sampleBytes * 2 + (this.#flow === void 0 ? 0 : sampleBytes) + (this.#moisture === void 0 ? 0 : sampleBytes);
+    return this.#gpu === void 0 ? cpuBytes : Math.max(cpuBytes, sampleBytes * 24);
+  }
+  heightAt(x, z) {
+    finite4(x, "query x");
+    finite4(z, "query z");
+    const column = (x - this.#minimumX) / this.#cellWidth;
+    const row = (z - this.#minimumZ) / this.#cellDepth;
+    const epsilon = 1e-9;
+    if (column < -epsilon || row < -epsilon || column > this.columns - 1 + epsilon || row > this.rows - 1 + epsilon)
+      throw new Error(`Heightfield query (${x}, ${z}) is outside its resident region.`);
+    return this.#interpolate(
+      Math.min(this.columns - 1, Math.max(0, column)),
+      Math.min(this.rows - 1, Math.max(0, row))
+    );
+  }
+  normalAt(x, z, target = new Vector3()) {
+    this.heightAt(x, z);
+    const leftX = Math.max(this.#minimumX, x - this.#cellWidth);
+    const rightX = Math.min(this.#minimumX + this.width, x + this.#cellWidth);
+    const nearZ = Math.max(this.#minimumZ, z - this.#cellDepth);
+    const farZ = Math.min(this.#minimumZ + this.depth, z + this.#cellDepth);
+    const slopeX = (this.heightAt(rightX, z) - this.heightAt(leftX, z)) / (rightX - leftX);
+    const slopeZ = (this.heightAt(x, farZ) - this.heightAt(x, nearZ)) / (farZ - nearZ);
+    return target.set(-slopeX, 1, -slopeZ).normalize();
+  }
+  /** The same values transposed once into Rapier's column-major height-matrix order. */
+  toColliderHeights() {
+    return this.#colliderHeights.slice();
+  }
+  /** Builds an ordinary Three.js geometry without choosing its surface. */
+  toGeometry() {
+    const count2 = this.rows * this.columns;
+    const positions = new Float32Array(count2 * 3);
+    const normals = new Float32Array(count2 * 3);
+    const normal = new Vector3();
+    for (let row = 0; row < this.rows; row += 1) {
+      const localZ = -this.depth / 2 + row * this.#cellDepth;
+      const worldZ = this.origin.z + localZ;
+      for (let column = 0; column < this.columns; column += 1) {
+        const index = row * this.columns + column;
+        const localX = -this.width / 2 + column * this.#cellWidth;
+        const worldX = this.origin.x + localX;
+        positions[index * 3] = localX;
+        positions[index * 3 + 1] = this.#height(index);
+        positions[index * 3 + 2] = localZ;
+        this.normalAt(worldX, worldZ, normal);
+        normals[index * 3] = normal.x;
+        normals[index * 3 + 1] = normal.y;
+        normals[index * 3 + 2] = normal.z;
+      }
+    }
+    const indices = new Uint32Array((this.rows - 1) * (this.columns - 1) * 6);
+    let offset = 0;
+    for (let row = 0; row < this.rows - 1; row += 1) {
+      for (let column = 0; column < this.columns - 1; column += 1) {
+        const upperLeft = row * this.columns + column;
+        const upperRight = upperLeft + 1;
+        const lowerLeft = upperLeft + this.columns;
+        const lowerRight = lowerLeft + 1;
+        indices.set([upperLeft, lowerLeft, upperRight, upperRight, lowerLeft, lowerRight], offset);
+        offset += 6;
+      }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute("position", new BufferAttribute(positions, 3));
+    geometry.setAttribute("normal", new BufferAttribute(normals, 3));
+    geometry.setIndex(new BufferAttribute(indices, 1));
+    return geometry;
+  }
+  #interpolate(column, row) {
+    const column0 = Math.floor(column);
+    const row0 = Math.floor(row);
+    const column1 = Math.min(this.columns - 1, column0 + 1);
+    const row1 = Math.min(this.rows - 1, row0 + 1);
+    const columnMix = column - column0;
+    const rowMix = row - row0;
+    const upperLeft = this.#height(row0 * this.columns + column0);
+    const upperRight = this.#height(row0 * this.columns + column1);
+    const lowerLeft = this.#height(row1 * this.columns + column0);
+    const lowerRight = this.#height(row1 * this.columns + column1);
+    const upper = upperLeft + (upperRight - upperLeft) * columnMix;
+    const lower = lowerLeft + (lowerRight - lowerLeft) * columnMix;
+    return upper + (lower - upper) * rowMix;
+  }
+  #interpolateValues(values, x, z) {
+    finite4(x, "query x");
+    finite4(z, "query z");
+    const column = (x - this.#minimumX) / this.#cellWidth;
+    const row = (z - this.#minimumZ) / this.#cellDepth;
+    if (column < 0 || row < 0 || column > this.columns - 1 || row > this.rows - 1)
+      throw new Error(`Heightfield query (${x}, ${z}) is outside its resident region.`);
+    const column0 = Math.floor(column);
+    const row0 = Math.floor(row);
+    const column1 = Math.min(this.columns - 1, column0 + 1);
+    const row1 = Math.min(this.rows - 1, row0 + 1);
+    const columnMix = column - column0;
+    const rowMix = row - row0;
+    const upper = values[row0 * this.columns + column0] * (1 - columnMix) + values[row0 * this.columns + column1] * columnMix;
+    const lower = values[row1 * this.columns + column0] * (1 - columnMix) + values[row1 * this.columns + column1] * columnMix;
+    return upper * (1 - rowMix) + lower * rowMix;
+  }
+  #sampleError(sample, expected) {
+    if (sample === void 0 || expected === void 0) return void 0;
+    if (sample.data.length !== expected.length) return Number.POSITIVE_INFINITY;
+    let maximum = 0;
+    for (let index = 0; index < expected.length; index += 1)
+      maximum = Math.max(
+        maximum,
+        Math.abs(sample.data[index] - expected[index])
+      );
+    return maximum;
+  }
+  #height(index) {
+    const height2 = this.#heights[index];
+    if (height2 === void 0) throw new Error(`Heightfield internal sample ${index} is missing.`);
+    return height2;
+  }
+};
+
+export { Heightfield, TerrainTiles, getWorldCapabilities };