@threenative/terrain 0.0.0-stage → 0.1.1

package/dist/editor/server.js

@@ -0,0 +1,3688 @@
+import { randomUUID, createHash } from 'crypto';
+import { lstatSync, readFileSync, writeFileSync, renameSync, unlinkSync, openSync, fstatSync, readSync, closeSync, mkdirSync } from 'fs';
+import { isAbsolute, resolve, dirname, basename, join } from 'path';
+import { Vector3, Matrix4, Quaternion } from 'three';
+
+// src/editor/server.ts
+
+// src/core/math.ts
+var clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
+var lerp = (a, b, t) => a + (b - a) * t;
+var smoothstep = (a, b, x) => {
+  if (a === b) return x >= b ? 1 : 0;
+  const t = clamp((x - a) / (b - a));
+  return t * t * (3 - 2 * t);
+};
+var hashString = (text3) => {
+  let h = 2166136261;
+  for (const c of text3) h = Math.imul(h ^ c.charCodeAt(0), 16777619);
+  return h >>> 0;
+};
+function random(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var hash2 = (x, z, seed) => {
+  let n = Math.imul(x | 0, 374761393) ^ Math.imul(z | 0, 668265263) ^ seed;
+  n = Math.imul(n ^ n >>> 13, 1274126177);
+  return (n ^ n >>> 16) >>> 0;
+};
+var diagonalGradient = 0.7071;
+var grad = (h, x, z) => {
+  switch (h & 7) {
+    case 0:
+      return x;
+    case 1:
+      return -x;
+    case 2:
+      return z;
+    case 3:
+      return -z;
+    case 4:
+      return (x + z) * diagonalGradient;
+    case 5:
+      return (x - z) * diagonalGradient;
+    case 6:
+      return (-x + z) * diagonalGradient;
+    default:
+      return (-x - z) * diagonalGradient;
+  }
+};
+function noise2(x, z, seed = 1) {
+  const ix = Math.floor(x);
+  const iz = Math.floor(z);
+  const fx = x - ix;
+  const fz = z - iz;
+  const u = fx * fx * fx * (fx * (fx * 6 - 15) + 10);
+  const v = fz * fz * fz * (fz * (fz * 6 - 15) + 10);
+  return lerp(
+    lerp(grad(hash2(ix, iz, seed), fx, fz), grad(hash2(ix + 1, iz, seed), fx - 1, fz), u),
+    lerp(
+      grad(hash2(ix, iz + 1, seed), fx, fz - 1),
+      grad(hash2(ix + 1, iz + 1, seed), fx - 1, fz - 1),
+      u
+    ),
+    v
+  ) * 1.65;
+}
+function fbm(inputX, inputZ, { seed = 1, octaves = 5, persistence = 0.5, lacunarity = 2, mode = "fbm" } = {}) {
+  let x = inputX;
+  let z = inputZ;
+  let value = 0;
+  let amplitude = 1;
+  let total = 0;
+  for (let i = 0; i < octaves; i += 1) {
+    let n = noise2(x + 13.17, z - 8.71, seed + i * 71);
+    if (mode === "ridged") n = (1 - Math.abs(n)) ** 2 * 2 - 1;
+    if (mode === "billow") n = Math.abs(n) * 2 - 1;
+    value += n * amplitude;
+    total += amplitude;
+    amplitude *= persistence;
+    x *= lacunarity;
+    z *= lacunarity;
+  }
+  return total ? value / total : 0;
+}
+var world = (grid, x) => x / (grid.resolution - 1) * grid.size - grid.size / 2;
+function sampleGrid(a, width, height, u, v) {
+  const gx = clamp(u, 0, 1) * (width - 1);
+  const gz = clamp(v, 0, 1) * (height - 1);
+  const x = Math.min(width - 2, Math.floor(gx));
+  const z = Math.min(height - 2, Math.floor(gz));
+  const tx = gx - x;
+  const tz = gz - z;
+  return lerp(
+    lerp(a[z * width + x], a[z * width + x + 1], tx),
+    lerp(a[(z + 1) * width + x], a[(z + 1) * width + x + 1], tx),
+    tz
+  );
+}
+var sampleHeight = (grid, x, z) => sampleGrid(
+  grid.height,
+  grid.resolution,
+  grid.resolution,
+  x / grid.size + 0.5,
+  z / grid.size + 0.5
+);
+function gradientAt(grid, x, z) {
+  const d = grid.size / (grid.resolution - 1);
+  return [
+    (sampleHeight(grid, x + d, z) - sampleHeight(grid, x - d, z)) / (Math.min(grid.size / 2, x + d) - Math.max(-grid.size / 2, x - d) || d),
+    (sampleHeight(grid, x, z + d) - sampleHeight(grid, x, z - d)) / (Math.min(grid.size / 2, z + d) - Math.max(-grid.size / 2, z - d) || d)
+  ];
+}
+function slopeAtIndex(grid, i) {
+  const n = grid.resolution;
+  const x = i % n;
+  const z = Math.floor(i / n);
+  const dx = x > 0 && x < n - 1 ? 2 : 1;
+  const dz = z > 0 && z < n - 1 ? 2 : 1;
+  const cell = grid.size / (n - 1);
+  const gx = (grid.height[z * n + Math.min(x + 1, n - 1)] - grid.height[z * n + Math.max(x - 1, 0)]) / (dx * cell);
+  const gz = (grid.height[Math.min(z + 1, n - 1) * n + x] - grid.height[Math.max(z - 1, 0) * n + x]) / (dz * cell);
+  return Math.atan(Math.hypot(gx, gz)) * (180 / Math.PI);
+}
+function falloff(distance, radius, softness = 0.6) {
+  const d = distance / radius;
+  return d >= 1 ? 0 : 1 - smoothstep(1 - clamp(softness, 1e-5, 1), 1, d);
+}
+function splinePoints(points, step = 3, smooth = true) {
+  const out = [];
+  for (let k = 0; k < points.length - 1; k += 1) {
+    const a = points[Math.max(0, k - 1)];
+    const b = points[k];
+    const c = points[k + 1];
+    const d = points[Math.min(points.length - 1, k + 2)];
+    const count = Math.max(
+      1,
+      Math.min(512, Math.ceil(Math.hypot(c[0] - b[0], c[2] - b[2]) / step))
+    );
+    for (let j = 0; j < count; j += 1) {
+      const t = j / count;
+      const t2 = t * t;
+      const t3 = t2 * t;
+      const cat = (dim) => 0.5 * (2 * b[dim] + (-a[dim] + c[dim]) * t + (2 * a[dim] - 5 * b[dim] + 4 * c[dim] - d[dim]) * t2 + (-a[dim] + 3 * b[dim] - 3 * c[dim] + d[dim]) * t3);
+      out.push([
+        smooth ? cat(0) : lerp(b[0], c[0], t),
+        lerp(b[1], c[1], t),
+        smooth ? cat(2) : lerp(b[2], c[2], t)
+      ]);
+    }
+  }
+  const last = points[points.length - 1];
+  out.push([last[0], last[1], last[2]]);
+  return out;
+}
+
+// src/core/masks.ts
+var MATERIAL_IDS = Object.freeze([
+  "grass",
+  "dirt",
+  "rock",
+  "snow",
+  "sand",
+  "mud",
+  "road",
+  "moss"
+]);
+var range = (v, min, max, fade = 0) => fade > 0 ? smoothstep(min - fade, min, v) * (1 - smoothstep(max, max + fade, v)) : Number(v >= min && v <= max);
+function compileMask(mask, s) {
+  if (!mask || mask.type === "all") return () => 1;
+  switch (mask.type) {
+    case "none":
+      return () => 0;
+    case "circle": {
+      const centre = mask.at;
+      return (i, x, z) => falloff(
+        Math.hypot(x - centre[0], z - centre[1]),
+        mask.radius,
+        mask.falloff ?? 0.6
+      );
+    }
+    case "rectangle": {
+      const centre = mask.at;
+      const rad = (mask.rotation ?? 0) * Math.PI / 180;
+      const c = Math.cos(rad);
+      const sn = Math.sin(rad);
+      const size = Array.isArray(mask.size) ? mask.size : [mask.size, mask.size];
+      return (i, x, z) => {
+        const dx = x - centre[0];
+        const dz = z - centre[1];
+        return falloff(
+          Math.max(
+            Math.abs(dx * c + dz * sn) / (size[0] / 2),
+            Math.abs(-dx * sn + dz * c) / (size[1] / 2)
+          ),
+          1,
+          mask.falloff ?? 0.2
+        );
+      };
+    }
+    case "height":
+      return (i) => range(s.height[i], mask.min ?? -1e9, mask.max ?? 1e9, mask.fade);
+    case "slope":
+      return (i) => range(slopeAtIndex(s, i), mask.min ?? 0, mask.max ?? 90, mask.fade);
+    case "noise":
+      return (i, x, z) => smoothstep(
+        (mask.threshold ?? 0.5) - (mask.fade ?? 0.15),
+        (mask.threshold ?? 0.5) + (mask.fade ?? 0.15),
+        noise2(x / mask.scale, z / mask.scale, mask.seed ?? s.seed) * 0.5 + 0.5
+      );
+    case "biome": {
+      const field2 = s.biomes[mask.name];
+      return (i) => field2?.[i] ?? 0;
+    }
+    case "material": {
+      const channel = MATERIAL_IDS.indexOf(mask.name);
+      if (channel < 0) throw Error(`Unknown material: ${String(mask.name)}`);
+      return (i) => s.splat[i * 8 + channel];
+    }
+    case "not": {
+      const inner = compileMask(mask.mask, s);
+      return (i, x, z) => 1 - inner(i, x, z);
+    }
+    case "and": {
+      const inner = (mask.masks ?? []).map((entry) => compileMask(entry, s));
+      return (i, x, z) => inner.reduce((value, sample) => value * sample(i, x, z), 1);
+    }
+    case "or": {
+      const inner = (mask.masks ?? []).map((entry) => compileMask(entry, s));
+      return (i, x, z) => 1 - inner.reduce((value, sample) => value * (1 - sample(i, x, z)), 1);
+    }
+    default:
+      throw Error(`Unknown mask: ${String(mask.type)}`);
+  }
+}
+function rasterMask(mask, s) {
+  if (!mask || mask.type === "all") return null;
+  const out = new Float32Array(s.height.length);
+  const sample = compileMask(mask, s);
+  for (let z = 0; z < s.resolution; z += 1) {
+    for (let x = 0; x < s.resolution; x += 1) {
+      const i = z * s.resolution + x;
+      out[i] = clamp(sample(i, world(s, x), world(s, z)));
+    }
+  }
+  return out;
+}
+function paintWeights(s, i, channel, weight) {
+  const w = clamp(weight);
+  const base = i * 8;
+  for (let c = 0; c < 8; c += 1)
+    s.splat[base + c] = s.splat[base + c] * (1 - w) + (c === channel ? w : 0);
+}
+
+// src/core/erosion.ts
+function thermal(height, n, size, { iterations = 20, talus = 32, rate = 0.22 } = {}, observations) {
+  const h = height.slice();
+  const delta = new Float64Array(h.length);
+  const limit = Math.tan(talus * Math.PI / 180) * (size / (n - 1));
+  for (let k = 0; k < iterations; k += 1) {
+    delta.fill(0);
+    for (let z = 0; z < n; z += 1) {
+      for (let x = 0; x < n; x += 1) {
+        const i = z * n + x;
+        let best = -1;
+        let diff = limit;
+        for (const j of [
+          x > 0 ? i - 1 : -1,
+          x < n - 1 ? i + 1 : -1,
+          z > 0 ? i - n : -1,
+          z < n - 1 ? i + n : -1
+        ]) {
+          if (j >= 0 && h[i] - h[j] > diff) {
+            diff = h[i] - h[j];
+            best = j;
+          }
+        }
+        if (best >= 0) {
+          const transfer = (diff - limit) * rate;
+          delta[i] = delta[i] - transfer;
+          delta[best] = delta[best] + transfer;
+          if (observations)
+            observations.talus[best] = observations.talus[best] + transfer;
+        }
+      }
+    }
+    for (let i = 0; i < h.length; i += 1) h[i] = h[i] + delta[i];
+  }
+  return h;
+}
+var brushes = /* @__PURE__ */ new Map();
+function brush(radius) {
+  let cells = brushes.get(radius);
+  if (!cells) {
+    cells = [];
+    let total = 0;
+    for (let dz = -radius; dz <= radius; dz += 1) {
+      for (let dx = -radius; dx <= radius; dx += 1) {
+        const d = Math.hypot(dx, dz);
+        if (d > radius) continue;
+        const weight = 1 - d / (radius + 1);
+        cells.push({ dx, dz, weight });
+        total += weight;
+      }
+    }
+    for (const c of cells) c.weight /= total;
+    brushes.set(radius, cells);
+  }
+  return cells;
+}
+function hydraulic(height, n, size, {
+  // Roughly one droplet per cell. Incision saturates near here: more droplets keep cutting the
+  // same drainage lines over, which deepens nothing and spends the bake time.
+  droplets = n * n,
+  // A droplet has to be able to cross the world, so its step budget scales with the grid: a
+  // fixed 40 barely leaves a 257 world while a 65 world would walk off it in a few steps.
+  maxSteps = Math.round(Math.min(64, Math.max(24, n / 4))),
+  inertia = 0.2,
+  capacity = 4,
+  // Each step takes a small bite of the sediment the droplet can carry. A big bite carves
+  // fewer, deeper dimples that stand proud of their neighbours as spikes; many shallow bites
+  // over the same lines incise the same drainage with a smooth surface.
+  erosion = 0.03,
+  deposition = 0.3,
+  evaporation = 0.025,
+  seed = 1,
+  brushRadius = 3
+} = {}, observations) {
+  const h = Float64Array.from(height);
+  const rnd = random(seed);
+  const cell = size / (n - 1);
+  const cells = brush(brushRadius);
+  const spread = (x, z, amount, floor = Number.NEGATIVE_INFINITY) => {
+    let total = 0;
+    for (const c of cells) {
+      const ix = x + c.dx;
+      const iz = z + c.dz;
+      if (ix >= 0 && ix < n && iz >= 0 && iz < n) total += c.weight;
+    }
+    if (total <= 0) return 0;
+    let moved = 0;
+    for (const c of cells) {
+      const ix = x + c.dx;
+      const iz = z + c.dz;
+      if (ix < 0 || ix >= n || iz < 0 || iz >= n) continue;
+      const i = iz * n + ix;
+      const share = amount * c.weight / total;
+      const change = amount < 0 ? -Math.min(-share, Math.max(0, h[i] - floor)) : share;
+      h[i] = h[i] + change;
+      moved += change;
+      if (observations && amount > 0)
+        observations.deposition[i] = observations.deposition[i] + amount * c.weight / total;
+    }
+    return moved;
+  };
+  const get = (x, z) => {
+    const ix = Math.min(n - 2, Math.floor(x));
+    const iz = Math.min(n - 2, Math.floor(z));
+    const tx = x - ix;
+    const tz = z - iz;
+    const i = iz * n + ix;
+    return {
+      value: lerp(
+        lerp(h[i], h[i + 1], tx),
+        lerp(h[i + n], h[i + n + 1], tx),
+        tz
+      ),
+      dx: lerp(
+        h[i + 1] - h[i],
+        h[i + n + 1] - h[i + n],
+        tz
+      ) / cell,
+      dz: lerp(
+        h[i + n] - h[i],
+        h[i + n + 1] - h[i + 1],
+        tx
+      ) / cell,
+      ix,
+      iz
+    };
+  };
+  for (let k = 0; k < droplets; k += 1) {
+    let x = rnd() * (n - 1 - 1e-3);
+    let z = rnd() * (n - 1 - 1e-3);
+    let dx = 0;
+    let dz = 0;
+    let water = 1;
+    let speed = 1;
+    let sediment = 0;
+    for (let step = 0; step < maxSteps; step += 1) {
+      const old = get(x, z);
+      if (observations) {
+        const tx = x - old.ix;
+        const tz = z - old.iz;
+        const i = old.iz * n + old.ix;
+        for (let oz = 0; oz < 2; oz++) {
+          for (let ox = 0; ox < 2; ox++) {
+            const index = i + oz * n + ox;
+            const weight = (ox ? tx : 1 - tx) * (oz ? tz : 1 - tz);
+            observations.flow[index] = observations.flow[index] + water * weight;
+            observations.sediment[index] = observations.sediment[index] + sediment * weight;
+          }
+        }
+      }
+      dx = dx * inertia - old.dx * (1 - inertia);
+      dz = dz * inertia - old.dz * (1 - inertia);
+      let length = Math.hypot(dx, dz);
+      if (length < 1e-9) {
+        const angle = rnd() * Math.PI * 2;
+        dx = Math.cos(angle);
+        dz = Math.sin(angle);
+        length = 1;
+      }
+      dx /= length;
+      dz /= length;
+      const nx = x + dx;
+      const nz = z + dz;
+      if (nx < 0 || nx >= n - 1 || nz < 0 || nz >= n - 1) {
+        sediment = 0;
+        break;
+      }
+      const next = get(nx, nz);
+      const dh = next.value - old.value;
+      const cap = Math.max(-dh, 5e-3 * cell) * speed * water * capacity;
+      if (dh > 0 || sediment > cap) {
+        const amount = dh > 0 ? Math.min(dh, sediment) : (sediment - cap) * deposition;
+        spread(old.ix, old.iz, amount);
+        sediment -= amount;
+      } else {
+        const amount = Math.max(0, Math.min((cap - sediment) * erosion, -dh));
+        sediment -= spread(old.ix, old.iz, -amount, next.value);
+      }
+      speed = Math.sqrt(Math.max(0.01, speed * speed - dh * 3));
+      water *= 1 - evaporation;
+      x = nx;
+      z = nz;
+      if (water < 0.02) break;
+    }
+    if (sediment > 0 && water < 0.02) {
+      const end = get(clamp(x, 0, n - 1.001), clamp(z, 0, n - 1.001));
+      spread(end.ix, end.iz, sediment);
+    }
+  }
+  return Float32Array.from(h);
+}
+
+// src/core/operations.ts
+var OPERATION_TYPES = Object.freeze([
+  "noise",
+  "sculpt",
+  "smooth",
+  "flatten",
+  "ramp",
+  "stamp",
+  "erode",
+  "terrace",
+  "materials",
+  "paint",
+  "biome",
+  "scatter",
+  "clear",
+  "road",
+  "river",
+  "water",
+  "heightmap",
+  "paste"
+]);
+function createState(config, resolution = config.resolution) {
+  const height = new Float32Array(resolution * resolution);
+  const splat = new Float32Array(height.length * 8);
+  for (let i = 0; i < height.length; i += 1) splat[i * 8] = 1;
+  return {
+    size: config.size,
+    resolution,
+    seed: config.seed,
+    height,
+    splat,
+    biomes: {},
+    scatterRules: [],
+    waterRules: [],
+    rivers: [],
+    instances: [],
+    waters: [],
+    diagnostics: []
+  };
+}
+function brushCenters(p, seed) {
+  const source = p.points ?? (p.at ? [p.at] : null);
+  if (!source) return null;
+  const radius = p.radius ?? 30;
+  const first = source[0];
+  if (!first) return null;
+  const out = [[first[0], first[1]]];
+  const step = Math.max(0.1, radius * 2 * (p.spacing ?? 0.15));
+  for (let k = 1; k < source.length; k += 1) {
+    const a = source[k - 1];
+    const b = source[k];
+    const count = Math.max(1, Math.ceil(Math.hypot(b[0] - a[0], b[1] - a[1]) / step));
+    for (let j = 1; j <= count; j += 1)
+      out.push([lerp(a[0], b[0], j / count), lerp(a[1], b[1], j / count)]);
+  }
+  if (p.jitter) {
+    const rnd = random(seed);
+    for (const centre of out) {
+      const angle = rnd() * Math.PI * 2;
+      const offset = Math.sqrt(rnd()) * p.jitter * radius;
+      centre[0] += Math.cos(angle) * offset;
+      centre[1] += Math.sin(angle) * offset;
+    }
+  }
+  return out;
+}
+function brushWeights(s, p, mask, seed) {
+  const centers = brushCenters(p, seed);
+  if (!centers) return mask ?? new Float32Array(s.height.length).fill(1);
+  const n = s.resolution;
+  const r = p.radius ?? 30;
+  const cell = s.size / (n - 1);
+  const weights = new Float32Array(n * n);
+  const angle = (p.rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const bound = r * (p.shape === "square" ? Math.SQRT2 : 1);
+  for (const [cx, cz] of centers) {
+    const x0 = clamp(Math.floor((cx - bound + s.size / 2) / cell), 0, n - 1);
+    const x1 = clamp(Math.ceil((cx + bound + s.size / 2) / cell), 0, n - 1);
+    const z0 = clamp(Math.floor((cz - bound + s.size / 2) / cell), 0, n - 1);
+    const z1 = clamp(Math.ceil((cz + bound + s.size / 2) / cell), 0, n - 1);
+    for (let z = z0; z <= z1; z += 1) {
+      for (let x = x0; x <= x1; x += 1) {
+        const dx = world(s, x) - cx;
+        const dz = world(s, z) - cz;
+        const distance = p.shape === "square" ? Math.max(Math.abs(dx * cos + dz * sin), Math.abs(-dx * sin + dz * cos)) : Math.hypot(dx, dz);
+        const i = z * n + x;
+        weights[i] = Math.max(
+          weights[i],
+          falloff(distance, r, p.falloff ?? 0.6) * (mask?.[i] ?? 1)
+        );
+      }
+    }
+  }
+  return weights;
+}
+function followsTerrain(source, followTerrain) {
+  return followTerrain ?? source.some((point2) => !Number.isFinite(point2[1]));
+}
+function gradeToGround(s, points, p) {
+  const at = (k) => points[k];
+  const run = (k) => {
+    const a = at(k - 1);
+    const b = at(k);
+    return Math.hypot(b[0] - a[0], b[2] - a[2]);
+  };
+  const bed = points.map(([x, , z]) => sampleHeight(s, x, z));
+  let spacing = 0;
+  for (let k = 1; k < points.length && spacing === 0; k += 1) spacing = run(k);
+  spacing ||= 3;
+  const window = Math.max(1, Math.round(Math.max(8, p.width ?? 12) / spacing));
+  const profile2 = bed.slice();
+  for (let pass = 0; pass < 2; pass += 1) {
+    const next = profile2.slice();
+    for (let k = 0; k < profile2.length; k += 1) {
+      let sum = 0;
+      let count = 0;
+      for (let j = Math.max(0, k - window); j <= Math.min(profile2.length - 1, k + window); j += 1) {
+        sum += profile2[j];
+        count += 1;
+      }
+      next[k] = sum / count;
+    }
+    for (let k = 0; k < profile2.length; k += 1) profile2[k] = next[k];
+  }
+  const maxCut = p.maxCut ?? 2.5;
+  const maxFill = p.maxFill ?? 1.5;
+  const grade2 = p.maxGrade ?? 0.12;
+  const limit = (k) => grade2 * Math.max(0.5, run(k));
+  for (let round = 0; round < 16; round += 1) {
+    let moved = 0;
+    for (let k = 1; k < profile2.length; k += 1) {
+      const y = clamp(
+        profile2[k],
+        profile2[k - 1] - limit(k),
+        profile2[k - 1] + limit(k)
+      );
+      moved += Math.abs(y - profile2[k]);
+      profile2[k] = y;
+    }
+    for (let k = profile2.length - 2; k >= 0; k -= 1) {
+      const y = clamp(
+        profile2[k],
+        profile2[k + 1] - limit(k + 1),
+        profile2[k + 1] + limit(k + 1)
+      );
+      moved += Math.abs(y - profile2[k]);
+      profile2[k] = y;
+    }
+    if (moved < 1e-4) break;
+  }
+  for (let k = 0; k < profile2.length; k += 1)
+    profile2[k] = clamp(
+      profile2[k],
+      bed[k] - maxCut,
+      bed[k] + maxFill
+    );
+  for (let k = 0; k < points.length; k += 1) at(k)[1] = profile2[k];
+}
+function applySpline(s, layer, mask) {
+  const p = layer.params;
+  const river = layer.type === "river";
+  const ramp = layer.type === "ramp";
+  const seed = p.seed ?? s.seed;
+  const raw = ramp ? [p.from, p.to] : p.points ?? [];
+  const follows = followsTerrain(raw, p.followTerrain);
+  const source = raw.map(
+    ([x, y, z]) => [x, Number.isFinite(y) ? y : 0, z]
+  );
+  const points = splinePoints(
+    source,
+    Math.max(1, (p.width ?? 12) * 0.22),
+    !ramp && p.smooth !== false
+  );
+  if (follows) gradeToGround(s, points, p);
+  const half = (p.width ?? 12) / 2;
+  const shoulder = p.shoulder ?? half;
+  const extent = half + shoulder;
+  const depth = p.depth ?? 4;
+  const alpha = layer.opacity ?? 1;
+  const n = s.resolution;
+  const cell = s.size / (n - 1);
+  const dist = new Float32Array(n * n).fill(Number.POSITIVE_INFINITY);
+  const target = new Float32Array(n * n);
+  const bed = new Float32Array(n * n);
+  const floor = river ? 1.5 * depth : 0;
+  let reach = extent;
+  const raster = () => {
+    dist.fill(Number.POSITIVE_INFINITY);
+    for (let k = 1; k < points.length; k += 1) {
+      const a = points[k - 1];
+      const b = points[k];
+      const dx = b[0] - a[0];
+      const dz = b[2] - a[2];
+      const den = dx * dx + dz * dz;
+      if (den < 1e-12) continue;
+      const xmin = clamp(Math.floor((Math.min(a[0], b[0]) - reach + s.size / 2) / cell), 0, n - 1);
+      const xmax = clamp(Math.ceil((Math.max(a[0], b[0]) + reach + s.size / 2) / cell), 0, n - 1);
+      const zmin = clamp(Math.floor((Math.min(a[2], b[2]) - reach + s.size / 2) / cell), 0, n - 1);
+      const zmax = clamp(Math.ceil((Math.max(a[2], b[2]) + reach + s.size / 2) / cell), 0, n - 1);
+      for (let z = zmin; z <= zmax; z += 1) {
+        for (let x = xmin; x <= xmax; x += 1) {
+          const wx = world(s, x);
+          const wz = world(s, z);
+          const t = clamp(((wx - a[0]) * dx + (wz - a[2]) * dz) / den);
+          const d = Math.hypot(wx - a[0] - t * dx, wz - a[2] - t * dz);
+          const i = z * n + x;
+          if (d < dist[i]) {
+            dist[i] = d;
+            target[i] = lerp(a[1], b[1], t);
+            bed[i] = s.height[i];
+          }
+        }
+      }
+    }
+  };
+  raster();
+  let worst = 0;
+  for (let i = 0; i < dist.length; i += 1)
+    if (dist[i] <= extent)
+      worst = Math.max(worst, Math.abs(target[i] - bed[i]));
+  if (floor + 1.5 * worst > 0.05) {
+    reach = extent + floor + 1.5 * worst;
+    raster();
+  }
+  const material = MATERIAL_IDS.indexOf(p.material ?? (river ? "mud" : "road"));
+  for (let i = 0; i < s.height.length; i += 1) {
+    const d = dist[i];
+    if (d > reach) continue;
+    const pre = bed[i];
+    const edge = Math.min(reach, extent + floor + 1.5 * Math.abs(target[i] - pre));
+    const blend = 1 - smoothstep(half, edge, d);
+    const w = blend * blend * (mask?.[i] ?? 1) * alpha;
+    let y = target[i];
+    if (river) {
+      const bowl = 1 - 0.35 * clamp(d / half) ** 2;
+      const bars = 1 + 0.22 * noise2(world(s, i % n) / (half * 8), world(s, Math.floor(i / n)) / (half * 8), seed + 7);
+      y = Math.min(pre, y - depth * bowl * bars * blend);
+    }
+    s.height[i] = lerp(pre, y, w);
+    if (material >= 0) paintWeights(s, i, material, w * (river ? 0.85 : 1));
+  }
+  if (river && p.water !== false)
+    s.rivers.push({
+      id: layer.id,
+      points,
+      width: (p.width ?? 12) * (p.waterWidth ?? 0.76),
+      color: p.color,
+      opacity: alpha
+    });
+}
+function applyOperation(s, layer) {
+  const { type, params: p } = layer;
+  const opacity = layer.opacity ?? 1;
+  if (layer.enabled === false || opacity <= 0) return;
+  const mask = rasterMask(layer.mask, s);
+  const weight = (i) => (mask?.[i] ?? 1) * opacity;
+  const n = s.resolution;
+  const seed = p.seed ?? s.seed;
+  switch (type) {
+    case "noise": {
+      const amplitude = p.amplitude ?? 35;
+      const scale2 = p.scale ?? 100;
+      const warp = p.warp ?? 20;
+      for (let z = 0; z < n; z += 1) {
+        for (let x = 0; x < n; x += 1) {
+          const i = z * n + x;
+          const wx = world(s, x);
+          const wz = world(s, z);
+          const ox = noise2(wx / (scale2 * 1.7) + 17, wz / (scale2 * 1.7) - 19, seed + 29) * warp;
+          const oz = noise2(wx / (scale2 * 1.7) - 27, wz / (scale2 * 1.7) + 12, seed + 31) * warp;
+          let value = (p.base ?? 0) + fbm((wx + ox) / scale2, (wz + oz) / scale2, {
+            seed,
+            octaves: p.octaves,
+            persistence: p.persistence,
+            lacunarity: p.lacunarity,
+            mode: p.mode
+          }) * amplitude;
+          if (p.island) {
+            const r = Math.hypot(wx / (s.size * 0.59), wz / (s.size * 0.59));
+            value = value * (1 - smoothstep(0.45, 1, r)) - (p.coastDepth ?? 15) * smoothstep(0.6, 1, r);
+          }
+          s.height[i] = p.blend === "replace" ? lerp(s.height[i], value, weight(i)) : s.height[i] + value * weight(i);
+        }
+      }
+      break;
+    }
+    case "sculpt":
+    case "flatten":
+    case "smooth":
+    case "paint": {
+      const weights = brushWeights(s, p, mask, seed);
+      const w = (i) => (weights?.[i] ?? 1) * opacity;
+      if (type === "sculpt")
+        for (let i = 0; i < s.height.length; i += 1)
+          s.height[i] = s.height[i] + (p.strength ?? 5) * w(i);
+      if (type === "flatten") {
+        const level = "height" in p ? p.height : void 0;
+        if (typeof level !== "number" || !Number.isFinite(level)) {
+          const covered = brushWeights(s, p, mask, seed);
+          let sum = 0;
+          let total = 0;
+          for (let i = 0; i < s.height.length; i += 1) {
+            const share = covered[i] * opacity;
+            sum += s.height[i] * share;
+            total += share;
+          }
+          const target = total > 0 ? sum / total : 0;
+          let delta = 0;
+          for (let i = 0; i < s.height.length; i += 1)
+            if (covered[i] > 0)
+              delta = Math.max(delta, Math.abs(s.height[i] - target));
+          const graded = brushWeights(
+            s,
+            { ...p, radius: (p.radius ?? 30) + 1.5 * delta },
+            mask,
+            seed
+          );
+          for (let i = 0; i < s.height.length; i += 1)
+            s.height[i] = lerp(
+              s.height[i],
+              target,
+              graded[i] * opacity * clamp(p.strength ?? 1)
+            );
+        } else
+          for (let i = 0; i < s.height.length; i += 1)
+            s.height[i] = lerp(s.height[i], level, w(i) * clamp(p.strength ?? 1));
+      }
+      if (type === "paint") {
+        const channel = MATERIAL_IDS.indexOf(("material" in p ? p.material : void 0) ?? "dirt");
+        for (let i = 0; i < s.height.length; i += 1)
+          paintWeights(s, i, channel, w(i) * clamp(p.strength ?? 1));
+      }
+      if (type === "smooth")
+        for (let k = 0; k < (("iterations" in p ? p.iterations : void 0) ?? 3); k += 1) {
+          const old = s.height.slice();
+          for (let z = 0; z < n; z += 1) {
+            for (let x = 0; x < n; x += 1) {
+              const i = z * n + x;
+              if (w(i) === 0) continue;
+              let total = 0;
+              let count = 0;
+              for (let dz = -1; dz <= 1; dz += 1) {
+                for (let dx = -1; dx <= 1; dx += 1) {
+                  const xx = x + dx;
+                  const zz = z + dz;
+                  if (xx >= 0 && xx < n && zz >= 0 && zz < n) {
+                    total += old[zz * n + xx];
+                    count += 1;
+                  }
+                }
+              }
+              s.height[i] = lerp(old[i], total / count, w(i) * clamp(p.strength ?? 0.65));
+            }
+          }
+        }
+      break;
+    }
+    case "stamp":
+    case "paste": {
+      const at = p.at ?? [0, 0];
+      const radius = p.radius ?? (p.size ? typeof p.size === "number" ? p.size / 2 : p.size.map((v) => v / 2) : 60);
+      const extents = Array.isArray(radius) ? [radius[0] / 1, radius[1] / 1] : [radius / 1, radius / 1];
+      const rot = (p.rotation ?? 0) * Math.PI / 180;
+      const c = Math.cos(rot);
+      const sn = Math.sin(rot);
+      const shape = ("shape" in p ? p.shape : void 0) ?? "mountain";
+      for (let z = 0; z < n; z += 1) {
+        for (let x = 0; x < n; x += 1) {
+          const i = z * n + x;
+          const dx = world(s, x) - at[0];
+          const dz = world(s, z) - at[1];
+          const u = (dx * c + dz * sn) / extents[0] * (p.mirrorX ? -1 : 1);
+          const v = (-dx * sn + dz * c) / extents[1] * (p.mirrorZ ? -1 : 1);
+          const d = Math.hypot(u, v);
+          let profile2;
+          let w = 1;
+          if (p.data) {
+            if (Math.abs(u) > 1 || Math.abs(v) > 1) continue;
+            const source = p.data;
+            profile2 = sampleGrid(
+              source.values,
+              source.width,
+              source.height,
+              u * 0.5 + 0.5,
+              v * 0.5 + 0.5
+            );
+            w = falloff(Math.max(Math.abs(u), Math.abs(v)), 1, p.falloff ?? 0.12);
+          } else {
+            if (d >= 1) continue;
+            const rough = 1 + (("roughness" in p ? p.roughness : void 0) ?? 0.13) * fbm(u * 5, v * 5, { seed, octaves: 3 });
+            if (shape === "crater")
+              profile2 = (Math.exp(-(((d - 0.67) / 0.14) ** 2)) * 0.48 - Math.exp(-((d / 0.49) ** 4)) * 0.6) * (1 - smoothstep(0.85, 1, d));
+            else if (shape === "ridge")
+              profile2 = Math.max(0, 1 - Math.abs(v)) ** 1.7 * (1 - smoothstep(0.35, 1, Math.abs(u))) * rough;
+            else if (shape === "mesa") profile2 = (1 - smoothstep(0.5, 1, d)) * rough;
+            else if (shape === "valley") profile2 = -(1 - smoothstep(0, 1, d)) * rough;
+            else if (shape === "dune") profile2 = Math.max(0, 1 - d) ** 1.2 * (1 + 0.25 * u) * rough;
+            else profile2 = Math.max(0, 1 - d) ** 1.65 * rough;
+            profile2 *= ("amplitude" in p ? p.amplitude : void 0) ?? 45;
+            w = falloff(d, 1, p.falloff ?? 0);
+          }
+          const alpha = weight(i) * w;
+          const blend = p.blend ?? (type === "paste" ? "replace" : "add");
+          const height = profile2 * (p.scale ?? 1) + (p.offset ?? 0);
+          const value = blend === "replace" ? height : blend === "max" ? Math.max(s.height[i], height) : blend === "min" ? Math.min(s.height[i], height) : s.height[i] + height;
+          s.height[i] = lerp(s.height[i], value, alpha);
+        }
+      }
+      break;
+    }
+    case "erode": {
+      const observations = {
+        flow: new Float32Array(s.height.length),
+        sediment: new Float32Array(s.height.length),
+        deposition: new Float32Array(s.height.length),
+        talus: new Float32Array(s.height.length)
+      };
+      s.erosion ??= structuredClone(observations);
+      const eroded = p.method === "hydraulic" ? hydraulic(
+        s.height,
+        n,
+        s.size,
+        {
+          seed,
+          droplets: p.droplets,
+          maxSteps: p.maxSteps,
+          inertia: p.inertia,
+          capacity: p.capacity,
+          erosion: p.erosion,
+          deposition: p.deposition,
+          evaporation: p.evaporation
+        },
+        observations
+      ) : thermal(s.height, n, s.size, p, observations);
+      let influence = mask;
+      if (p.at || p.points) influence = brushWeights(s, p, mask, seed);
+      for (let i = 0; i < s.height.length; i += 1) {
+        const alpha = (influence?.[i] ?? 1) * opacity * (p.strength ?? 1);
+        s.height[i] = lerp(s.height[i], eroded[i], alpha);
+        for (const key of ["flow", "sediment", "deposition", "talus"])
+          s.erosion[key][i] = s.erosion[key][i] + observations[key][i] * alpha;
+      }
+      break;
+    }
+    case "terrace": {
+      const step = p.step ?? 8;
+      const softness = p.softness ?? 0.18;
+      for (let i = 0; i < s.height.length; i += 1) {
+        const v = (s.height[i] - (p.offset ?? 0)) / step;
+        const base = Math.floor(v);
+        const f = v - base;
+        const target = (base + smoothstep(0.5 - softness * 0.5, 0.5 + softness * 0.5, f)) * step + (p.offset ?? 0);
+        s.height[i] = lerp(s.height[i], target, weight(i) * (p.strength ?? 1));
+      }
+      break;
+    }
+    case "materials": {
+      if (p.reset !== false)
+        for (let i = 0; i < s.height.length; i += 1)
+          paintWeights(s, i, MATERIAL_IDS.indexOf(p.base ?? "grass"), weight(i));
+      for (const rule of p.rules ?? []) {
+        const ruleMask = rasterMask(rule.mask, s);
+        const channel = MATERIAL_IDS.indexOf(rule.material);
+        for (let i = 0; i < s.height.length; i += 1)
+          paintWeights(s, i, channel, (ruleMask?.[i] ?? 1) * weight(i) * (rule.strength ?? 1));
+      }
+      break;
+    }
+    case "biome": {
+      const name = p.name ?? "forest";
+      s.biomes[name] ??= new Float32Array(s.height.length);
+      const values = s.biomes[name];
+      const weights = brushWeights(s, p, mask, seed);
+      for (let i = 0; i < values.length; i += 1)
+        values[i] = lerp(
+          values[i],
+          p.value ?? 1,
+          (weights?.[i] ?? 1) * opacity * (p.strength ?? 1)
+        );
+      break;
+    }
+    case "scatter":
+      s.scatterRules.push({ id: layer.id, ...p, mask: layer.mask, opacity, clear: [] });
+      break;
+    case "clear": {
+      if (p.target === "scatter" || p.target === "all") {
+        for (const rule of s.scatterRules)
+          if (!p.asset || rule.asset === p.asset)
+            rule.clear.push({ mask: layer.mask ?? { type: "all" }, opacity });
+      }
+      if (p.target === "biome" || p.target === "all")
+        for (const [name, values] of Object.entries(s.biomes)) {
+          if (p.name && p.name !== name) continue;
+          for (let i = 0; i < values.length; i += 1)
+            values[i] = values[i] * (1 - weight(i));
+        }
+      if (p.target === "paint" || p.target === "all")
+        for (let i = 0; i < s.height.length; i += 1) paintWeights(s, i, 0, weight(i));
+      break;
+    }
+    case "road":
+    case "river":
+    case "ramp":
+      applySpline(s, layer, mask);
+      break;
+    case "water":
+      s.waterRules.push({ id: layer.id, ...p, mask: layer.mask, opacity });
+      break;
+    case "heightmap": {
+      if (p.at !== void 0 || p.size !== void 0 || p.rotation !== void 0 || p.falloff !== void 0) {
+        applyOperation(s, {
+          ...layer,
+          type: "paste",
+          params: { ...p, size: p.size ?? s.size, falloff: p.falloff ?? 0 }
+        });
+        break;
+      }
+      const data = p.data;
+      for (let z = 0; z < n; z += 1) {
+        for (let x = 0; x < n; x += 1) {
+          const i = z * n + x;
+          const value = sampleGrid(data.values, data.width, data.height, x / (n - 1), z / (n - 1)) * (p.scale ?? 1) + (p.offset ?? 0);
+          s.height[i] = p.blend === "add" ? s.height[i] + value * weight(i) : lerp(s.height[i], value, weight(i));
+        }
+      }
+      break;
+    }
+    default:
+      throw Error(`Unsupported operation: ${String(layer.type)}`);
+  }
+}
+function finalizeState(s) {
+  const n = s.resolution;
+  const cell = s.size / (n - 1);
+  s.waters = [];
+  s.instances = [];
+  for (const water of s.waterRules) {
+    const mask = new Uint8Array(n * n);
+    const queue = new Int32Array(n * n);
+    const allowed = compileMask(water.mask, s);
+    const level = water.level ?? 0;
+    const at = water.at ?? [0, 0];
+    const radius = water.radius ?? s.size;
+    let front = 0;
+    let back = 0;
+    const eligible = (i) => {
+      const x = world(s, i % n);
+      const z = world(s, Math.floor(i / n));
+      return s.height[i] < level && Math.hypot(x - at[0], z - at[1]) <= radius && allowed(i, x, z) > 0.05;
+    };
+    const push = (i) => {
+      if (i >= 0 && i < n * n && !mask[i] && eligible(i)) {
+        mask[i] = 1;
+        queue[back] = i;
+        back += 1;
+      }
+    };
+    if (water.kind === "ocean") {
+      for (let k = 0; k < n; k += 1) {
+        push(k);
+        push((n - 1) * n + k);
+        push(k * n);
+        push(k * n + n - 1);
+      }
+    } else {
+      const x = clamp(Math.round((at[0] + s.size / 2) / cell), 0, n - 1);
+      const z = clamp(Math.round((at[1] + s.size / 2) / cell), 0, n - 1);
+      push(z * n + x);
+    }
+    while (front < back) {
+      const i = queue[front];
+      front += 1;
+      const x = i % n;
+      const z = Math.floor(i / n);
+      if (x > 0) push(i - 1);
+      if (x < n - 1) push(i + 1);
+      if (z > 0) push(i - n);
+      if (z < n - 1) push(i + n);
+    }
+    s.waters.push({ ...water, level, mask });
+    if (!back)
+      s.diagnostics.push(
+        `Water '${water.id}' has no flooded cells; its seed may be above the water level.`
+      );
+  }
+  const wet = (i, x, z, h) => {
+    if (s.waters.some((water) => water.mask[i])) return true;
+    for (const river of s.rivers) {
+      const half = river.width / 2;
+      for (let k = 1; k < river.points.length; k += 1) {
+        const a = river.points[k - 1];
+        const b = river.points[k];
+        if (x < Math.min(a[0], b[0]) - half || x > Math.max(a[0], b[0]) + half || z < Math.min(a[2], b[2]) - half || z > Math.max(a[2], b[2]) + half)
+          continue;
+        const dx = b[0] - a[0];
+        const dz = b[2] - a[2];
+        const t = clamp(((x - a[0]) * dx + (z - a[2]) * dz) / (dx * dx + dz * dz || 1));
+        if (Math.hypot(x - a[0] - t * dx, z - a[2] - t * dz) < half && h <= lerp(a[1], b[1], t) + 0.2)
+          return true;
+      }
+    }
+    return false;
+  };
+  for (const rule of s.scatterRules) {
+    const count = Math.round((rule.count ?? 300) * (rule.opacity ?? 1));
+    const seed = (rule.seed ?? s.seed ^ hashString(rule.id)) >>> 0;
+    const rnd = random(seed);
+    const accept = compileMask(rule.mask, s);
+    const clears = rule.clear.map((entry) => ({
+      fn: compileMask(entry.mask, s),
+      opacity: entry.opacity
+    }));
+    const distance = rule.minDistance ?? 4;
+    const gridSize = Math.max(distance, 0.1);
+    const buckets = /* @__PURE__ */ new Map();
+    const accepted = [];
+    const maxAttempts = count * 40;
+    const scale2 = rule.scale ?? [0.8, 1.3];
+    for (let attempt = 0; attempt < maxAttempts && accepted.length < count; attempt += 1) {
+      const x = (rnd() - 0.5) * s.size;
+      const z = (rnd() - 0.5) * s.size;
+      const acceptance = rnd();
+      const scaleRandom = rnd();
+      const yaw = rnd() * Math.PI * 2;
+      const ix = clamp(Math.round((x / s.size + 0.5) * (n - 1)), 0, n - 1);
+      const iz = clamp(Math.round((z / s.size + 0.5) * (n - 1)), 0, n - 1);
+      const i = iz * n + ix;
+      let w = accept(i, x, z);
+      for (const clear of clears) w *= 1 - clear.fn(i, x, z) * clear.opacity;
+      if (acceptance > w) continue;
+      const h = sampleHeight(s, x, z);
+      if (rule.avoidWater !== false && wet(i, x, z, h)) continue;
+      if (h < (rule.minHeight ?? -1e9) || h > (rule.maxHeight ?? 1e9)) continue;
+      const g = gradientAt(s, x, z);
+      const slope = Math.atan(Math.hypot(g[0], g[1])) * (180 / Math.PI);
+      if (slope < (rule.minSlope ?? 0) || slope > (rule.maxSlope ?? 90)) continue;
+      const gx = Math.floor(x / gridSize);
+      const gz = Math.floor(z / gridSize);
+      let blocked = false;
+      if (distance > 0)
+        for (let dz = -1; dz <= 1 && !blocked; dz += 1) {
+          for (let dx = -1; dx <= 1 && !blocked; dx += 1) {
+            for (const j of buckets.get(`${gx + dx},${gz + dz}`) ?? []) {
+              const other = accepted[j];
+              if (Math.hypot(other.position[0] - x, other.position[2] - z) < distance) {
+                blocked = true;
+                break;
+              }
+            }
+          }
+        }
+      if (blocked) continue;
+      const index = accepted.length;
+      const itemScale = Array.isArray(scale2) ? lerp(scale2[0], scale2[1], scaleRandom) : scale2;
+      const normal = [-g[0], 1, -g[1]];
+      const length = Math.hypot(normal[0], normal[1], normal[2]);
+      accepted.push({
+        id: `${rule.id}:candidate:${seed}:${attempt}`,
+        layer: rule.id,
+        asset: rule.asset ?? "pine",
+        position: [x, h + (rule.offsetY ?? 0), z],
+        rotation: yaw,
+        scale: itemScale,
+        normal: [normal[0] / length, normal[1] / length, normal[2] / length],
+        alignToNormal: rule.alignToNormal ?? false
+      });
+      const key = `${gx},${gz}`;
+      const bucket = buckets.get(key) ?? [];
+      bucket.push(index);
+      buckets.set(key, bucket);
+    }
+    s.instances.push(...accepted);
+    if (accepted.length < count)
+      s.diagnostics.push(
+        `Scatter '${rule.id}': placed ${accepted.length}/${count}; masks or spacing exhausted the attempt budget.`
+      );
+  }
+  return s;
+}
+
+// src/core/validation.ts
+var RESOLUTIONS = Object.freeze([17, 33, 65, 129, 257, 513, 1025]);
+var brush2 = [
+  "at",
+  "points",
+  "radius",
+  "strength",
+  "falloff",
+  "shape",
+  "rotation",
+  "spacing",
+  "jitter"
+];
+var grade = ["followTerrain", "maxGrade", "maxCut", "maxFill"];
+var PARAMS = Object.freeze({
+  noise: [
+    "amplitude",
+    "scale",
+    "octaves",
+    "persistence",
+    "lacunarity",
+    "mode",
+    "warp",
+    "base",
+    "blend",
+    "island",
+    "coastDepth"
+  ],
+  sculpt: brush2,
+  smooth: [...brush2, "iterations"],
+  flatten: [...brush2, "height"],
+  paint: [...brush2, "material"],
+  stamp: [
+    "at",
+    "radius",
+    "size",
+    "amplitude",
+    "shape",
+    "rotation",
+    "mirrorX",
+    "mirrorZ",
+    "blend",
+    "roughness",
+    "scale",
+    "offset",
+    "data",
+    "falloff"
+  ],
+  paste: [
+    "at",
+    "size",
+    "radius",
+    "rotation",
+    "mirrorX",
+    "mirrorZ",
+    "blend",
+    "offset",
+    "scale",
+    "data",
+    "falloff"
+  ],
+  erode: [
+    ...brush2,
+    "method",
+    "iterations",
+    "talus",
+    "rate",
+    "droplets",
+    "maxSteps",
+    "inertia",
+    "capacity",
+    "erosion",
+    "deposition",
+    "evaporation"
+  ],
+  terrace: ["step", "softness", "strength", "offset"],
+  materials: ["base", "rules", "reset"],
+  biome: [...brush2, "name", "value"],
+  scatter: [
+    "asset",
+    "count",
+    "minDistance",
+    "scale",
+    "minHeight",
+    "maxHeight",
+    "minSlope",
+    "maxSlope",
+    "avoidWater",
+    "offsetY",
+    "alignToNormal"
+  ],
+  clear: ["target", "asset", "name"],
+  road: ["points", "width", "shoulder", "material", "smooth", ...grade],
+  river: [
+    "points",
+    "width",
+    "shoulder",
+    "depth",
+    "material",
+    "smooth",
+    "water",
+    "waterWidth",
+    "color",
+    "enforceDownhill",
+    ...grade
+  ],
+  ramp: ["from", "to", "width", "shoulder", "material", ...grade],
+  water: ["kind", "at", "radius", "level", "color"],
+  heightmap: ["data", "scale", "offset", "blend", "at", "size", "rotation", "falloff"]
+});
+function fail(message) {
+  throw new TypeError(message);
+}
+function finiteTree(value, path = "value", depth = 0) {
+  if (depth > 32) fail(`${path}: nesting is too deep`);
+  if (typeof value === "number" && !Number.isFinite(value)) fail(`${path} must be finite`);
+  if (value === void 0 || typeof value === "function" || typeof value === "bigint" || typeof value === "symbol")
+    fail(`${path} is not JSON-serializable`);
+  if (value && typeof value === "object") {
+    if (ArrayBuffer.isView(value)) fail(`${path}: use a plain array in recipes`);
+    for (const [key, entry] of Object.entries(value)) {
+      if (["__proto__", "prototype", "constructor"].includes(key))
+        fail(`${path}: unsafe object key`);
+      finiteTree(entry, `${path}.${key}`, depth + 1);
+    }
+  }
+}
+var num = (v, name, min = -1e9, max = 1e9, integer = false) => {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < min || v > max || integer && !Number.isInteger(v))
+    fail(`${name} must be ${integer ? "an integer" : "finite"} between ${min} and ${max}`);
+};
+var vec = (v, name, n) => {
+  if (!Array.isArray(v) || v.length !== n) fail(`${name} must contain ${n} numbers`);
+  for (const x of v) num(x, name);
+};
+var identifier = (v, name) => {
+  if (typeof v !== "string" || v.length === 0 || v.length > 100 || ["__proto__", "prototype", "constructor"].includes(v))
+    fail(`${name} must be a nonempty safe string, at most 100 characters`);
+};
+var enumeration = (v, name, choices) => {
+  if (!choices.includes(v)) fail(`${name}: expected ${choices.join(", ")}`);
+};
+function validateConfig(config) {
+  num(config.size, "size", 1, 1e5);
+  if (!RESOLUTIONS.includes(config.resolution))
+    fail(`resolution must be one of ${RESOLUTIONS.join(", ")}`);
+  num(config.seed, "seed", 0, 4294967295, true);
+}
+function validateMask(m, depth = 0) {
+  if (!m || typeof m !== "object" || depth > 20) fail("Invalid mask");
+  enumeration(m.type, "mask.type", [
+    "all",
+    "none",
+    "circle",
+    "rectangle",
+    "height",
+    "slope",
+    "noise",
+    "biome",
+    "material",
+    "and",
+    "or",
+    "not"
+  ]);
+  const allowed = {
+    all: [],
+    none: [],
+    circle: ["at", "radius", "falloff"],
+    rectangle: ["at", "size", "rotation", "falloff"],
+    height: ["min", "max", "fade"],
+    slope: ["min", "max", "fade"],
+    noise: ["scale", "threshold", "seed", "fade"],
+    biome: ["name"],
+    material: ["name"],
+    and: ["masks"],
+    or: ["masks"],
+    not: ["mask"]
+  };
+  for (const key of Object.keys(m))
+    if (key !== "type" && !allowed[m.type].includes(key)) fail(`Unknown mask field '${key}'`);
+  if (m.rotation !== void 0) num(m.rotation, "mask.rotation");
+  if (m.seed !== void 0) num(m.seed, "mask.seed", 0, 4294967295, true);
+  if (m.type === "circle") {
+    vec(m.at, "mask.at", 2);
+    num(m.radius, "mask.radius", 1e-3, 1e6);
+  }
+  if (m.type === "rectangle") {
+    vec(m.at, "mask.at", 2);
+    const size = m.size;
+    if (Array.isArray(size)) {
+      vec(size, "mask.size", 2);
+      for (const value of size) num(value, "mask.size", 1e-3, 1e6);
+    } else num(size, "mask.size", 1e-3, 1e6);
+  }
+  if (["height", "slope"].includes(m.type)) {
+    if (m.min !== void 0) num(m.min, "mask.min");
+    if (m.max !== void 0) num(m.max, "mask.max");
+    if ((m.min ?? -1e9) > (m.max ?? 1e9)) fail("mask.min must not exceed mask.max");
+    if (m.fade !== void 0) num(m.fade, "mask.fade", 0, 1e6);
+  }
+  if (m.type === "noise") {
+    num(m.scale, "mask.scale", 1e-3, 1e6);
+    if (m.threshold !== void 0) num(m.threshold, "mask.threshold", 0, 1);
+    if (m.fade !== void 0) num(m.fade, "mask.fade", 1e-6, 1);
+  }
+  if (m.type === "biome") identifier(m.name, "mask.name");
+  if (m.type === "material") enumeration(m.name, "mask.material", MATERIAL_IDS);
+  if (m.type === "not") validateMask(m.mask, depth + 1);
+  if (["and", "or"].includes(m.type)) {
+    if (!Array.isArray(m.masks) || m.masks.length > 32)
+      fail("mask.masks must be an array of at most 32 masks");
+    for (const entry of m.masks) validateMask(entry, depth + 1);
+  }
+  if (m.falloff !== void 0) num(m.falloff, "mask.falloff", 0, 1);
+}
+function splinePoint(v, name, follows) {
+  if (!Array.isArray(v) || v.length !== 3) fail(`${name} must contain 3 numbers`);
+  num(v[0], name);
+  num(v[2], name);
+  const y = v[1];
+  if (y === null || y === void 0) {
+    if (follows) return;
+    fail(`${name} must contain 3 numbers`);
+  }
+  if (typeof y !== "number") fail(`${name} must contain 3 numbers`);
+  if (!Number.isFinite(y) && !follows) fail(`${name} elevation must be finite`);
+}
+function layerFollowsTerrain(layer) {
+  if (!layer || typeof layer !== "object" || !["road", "river", "ramp"].includes(layer.type))
+    return false;
+  const params = layer.params ?? {};
+  const source = layer.type === "ramp" ? [params.from, params.to] : params.points;
+  if (!Array.isArray(source)) return false;
+  return followsTerrain(source, params.followTerrain);
+}
+function omittedElevations(layer, follows) {
+  if (!follows) return layer;
+  const params = layer.params ?? {};
+  const zero = (p) => Array.isArray(p) && p.length === 3 ? [p[0], 0, p[2]] : p;
+  const points = params.points;
+  const fixes = {
+    ...Array.isArray(points) ? { points: points.map(zero) } : {},
+    ...Array.isArray(params.from) ? { from: zero(params.from) } : {},
+    ...Array.isArray(params.to) ? { to: zero(params.to) } : {}
+  };
+  return Object.keys(fixes).length ? { ...layer, params: { ...params, ...fixes } } : layer;
+}
+function validateLayer(layer) {
+  const follows = layerFollowsTerrain(layer);
+  finiteTree(omittedElevations(layer, follows), "layer");
+  if (!layer || typeof layer !== "object") fail("layer must be an object");
+  for (const k of Object.keys(layer))
+    if (!["id", "name", "type", "params", "enabled", "opacity", "mask"].includes(k))
+      fail(`Unknown layer field '${k}'`);
+  identifier(layer.id, "layer.id");
+  enumeration(layer.type, "operation", OPERATION_TYPES);
+  if (layer.name !== void 0) identifier(layer.name, "layer.name");
+  if (layer.enabled !== void 0 && typeof layer.enabled !== "boolean")
+    fail("enabled must be boolean");
+  if (layer.opacity !== void 0) num(layer.opacity, "opacity", 0, 1);
+  if (layer.mask) validateMask(layer.mask);
+  const params = layer.params ?? {};
+  if (!params || Array.isArray(params) || typeof params !== "object")
+    fail("params must be an object");
+  for (const k of Object.keys(params))
+    if (!PARAMS[layer.type].includes(k) && k !== "seed")
+      fail(`Unknown ${layer.type} parameter '${k}'`);
+  for (const key of [
+    "island",
+    "mirrorX",
+    "mirrorZ",
+    "reset",
+    "avoidWater",
+    "alignToNormal",
+    "smooth",
+    "water",
+    "enforceDownhill",
+    "followTerrain"
+  ])
+    if (params[key] !== void 0 && typeof params[key] !== "boolean")
+      fail(`${key} must be boolean`);
+  if (params.seed !== void 0) num(params.seed, "seed", 0, 4294967295, true);
+  if (params.at !== void 0) vec(params.at, "at", 2);
+  if (params.from !== void 0) splinePoint(params.from, "from", follows);
+  if (params.to !== void 0) splinePoint(params.to, "to", follows);
+  const points = params.points;
+  const isSpline = ["road", "river"].includes(layer.type);
+  if (points) {
+    if (!Array.isArray(points) || !points.length || points.length > 8192)
+      fail("points must have 1..8192 entries");
+    const dimensions = isSpline ? 3 : 2;
+    for (const point2 of points)
+      if (isSpline) splinePoint(point2, "point", follows);
+      else vec(point2, "point", dimensions);
+  }
+  if (Array.isArray(points) && !isSpline) {
+    const stroke = points;
+    const spacing = Math.max(
+      0.1,
+      (params.radius ?? 30) * 2 * (params.spacing ?? 0.15)
+    );
+    let samples = 1;
+    for (let k = 1; k < stroke.length; k += 1) {
+      const next = stroke[k];
+      const previous = stroke[k - 1];
+      samples += Math.max(
+        1,
+        Math.ceil(
+          Math.hypot(
+            next[0] - previous[0],
+            next[1] - previous[1]
+          ) / spacing
+        )
+      );
+    }
+    if (samples > 65536)
+      fail(
+        "Brush interpolation exceeds 65536 samples; increase radius/spacing or shorten the stroke"
+      );
+  }
+  if (isSpline && (!Array.isArray(points) || points.length < 2))
+    fail(`${layer.type} requires at least two [x,y,z] points`);
+  if (layer.type === "ramp" && (!params.from || !params.to)) fail("ramp requires from and to");
+  for (const key of ["radius", "size"]) {
+    const value = params[key];
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      vec(value, key, 2);
+      for (const entry of value) num(entry, key, 1e-3, 1e6);
+    } else num(value, key, 1e-3, 1e6);
+  }
+  if (Array.isArray(params.radius) && !["stamp", "paste"].includes(layer.type))
+    fail("Brush radius must be one number");
+  for (const key of [
+    "amplitude",
+    "height",
+    "base",
+    "offset",
+    "offsetY",
+    "minHeight",
+    "maxHeight",
+    "level",
+    "rotation"
+  ])
+    if (params[key] !== void 0 && !(key === "base" && layer.type === "materials")) {
+      if (params[key] !== null || key !== "height") num(params[key], key);
+    }
+  for (const key of ["width", "step"])
+    if (params[key] !== void 0) num(params[key], key, 1e-3, 1e6);
+  for (const key of [
+    "warp",
+    "shoulder",
+    "roughness",
+    "coastDepth",
+    "minDistance",
+    "depth",
+    "capacity",
+    "maxCut",
+    "maxFill"
+  ])
+    if (params[key] !== void 0) num(params[key], key, 0, 1e6);
+  for (const key of [
+    "falloff",
+    "jitter",
+    "softness",
+    "inertia",
+    "erosion",
+    "deposition",
+    "evaporation",
+    "rate",
+    "value",
+    "waterWidth",
+    "maxGrade"
+  ])
+    if (params[key] !== void 0) num(params[key], key, 0, 1);
+  if (params.spacing !== void 0) num(params.spacing, "spacing", 0.01, 2);
+  if (params.strength !== void 0)
+    num(
+      params.strength,
+      "strength",
+      layer.type === "sculpt" ? -1e4 : 0,
+      layer.type === "sculpt" ? 1e4 : 1
+    );
+  if (params.scale !== void 0) {
+    const scale2 = params.scale;
+    if (layer.type === "scatter") {
+      if (Array.isArray(scale2)) {
+        vec(scale2, "scale", 2);
+        if (scale2[0] > scale2[1]) fail("scale range is inverted");
+        for (const entry of scale2) num(entry, "scale", 1e-3, 1e4);
+      } else num(scale2, "scale", 1e-3, 1e4);
+    } else num(scale2, "scale", 1e-3, 1e6);
+  }
+  for (const [key, max] of [
+    ["octaves", 10],
+    ["iterations", 200],
+    ["droplets", 2e5],
+    ["maxSteps", 128],
+    ["count", 2e4]
+  ])
+    if (params[key] !== void 0) num(params[key], key, key === "count" ? 0 : 1, max, true);
+  if (params.persistence !== void 0) num(params.persistence, "persistence", 0.01, 1);
+  if (params.lacunarity !== void 0) num(params.lacunarity, "lacunarity", 1, 4);
+  for (const key of ["minSlope", "maxSlope", "talus"])
+    if (params[key] !== void 0) num(params[key], key, 0, key === "talus" ? 89.9 : 90);
+  if (params.minHeight !== void 0 && params.maxHeight !== void 0 && params.minHeight > params.maxHeight)
+    fail("height range is inverted");
+  if (params.minSlope !== void 0 && params.maxSlope !== void 0 && params.minSlope > params.maxSlope)
+    fail("slope range is inverted");
+  if (params.material !== void 0) enumeration(params.material, "material", MATERIAL_IDS);
+  if (layer.type === "materials") {
+    if (params.base !== void 0) enumeration(params.base, "base", MATERIAL_IDS);
+    const rules = params.rules;
+    if (!Array.isArray(rules) || rules.length > 64) fail("materials requires a rules array");
+    for (const rule of rules) {
+      enumeration(rule.material, "rule.material", MATERIAL_IDS);
+      if (rule.mask) validateMask(rule.mask);
+      if (rule.strength !== void 0) num(rule.strength, "rule.strength", 0, 1);
+    }
+  }
+  if (params.method !== void 0) enumeration(params.method, "method", ["thermal", "hydraulic"]);
+  if (params.mode !== void 0) enumeration(params.mode, "mode", ["fbm", "ridged", "billow"]);
+  if (params.shape !== void 0)
+    enumeration(
+      params.shape,
+      "shape",
+      ["stamp"].includes(layer.type) ? ["mountain", "crater", "ridge", "valley", "mesa", "dune"] : ["circle", "square"]
+    );
+  if (params.blend !== void 0)
+    enumeration(
+      params.blend,
+      "blend",
+      ["noise", "heightmap"].includes(layer.type) ? ["add", "replace"] : ["add", "replace", "min", "max"]
+    );
+  if (layer.type === "clear")
+    enumeration(params.target, "clear.target", ["scatter", "paint", "biome", "all"]);
+  if (layer.type === "water") enumeration(params.kind ?? "lake", "water.kind", ["lake", "ocean"]);
+  if (layer.type === "river" && params.enforceDownhill && Array.isArray(points)) {
+    const river = points;
+    for (let i = 1; i < river.length; i += 1) {
+      const next = river[i];
+      const previous = river[i - 1];
+      if (next[1] > previous[1])
+        fail("River control-point elevations must be non-increasing");
+    }
+  }
+  if (params.name !== void 0) identifier(params.name, "name");
+  if (params.asset !== void 0) identifier(params.asset, "asset");
+  if (["heightmap", "paste"].includes(layer.type) && !params.data)
+    fail(`${layer.type} requires heightmap data`);
+  const data = params.data;
+  if (data) {
+    num(data.width, "data.width", 2, 4097, true);
+    num(data.height, "data.height", 2, 4097, true);
+    if (!Array.isArray(data.values) || data.values.length !== data.width * data.height)
+      fail("heightmap dimensions do not match values");
+    for (const value of data.values)
+      if (typeof value !== "number" || !Number.isFinite(value))
+        fail("data.values must contain only finite numbers");
+  }
+}
+function validateDocument(doc) {
+  finiteTree(
+    Array.isArray(doc.layers) ? {
+      ...doc,
+      layers: doc.layers.map((layer) => omittedElevations(layer, layerFollowsTerrain(layer)))
+    } : doc,
+    "recipe"
+  );
+  if (doc.version !== 1) fail("Unsupported recipe version; expected 1");
+  validateConfig(doc.config);
+  if (!Array.isArray(doc.layers) || doc.layers.length > 512)
+    fail("layers must be an array of at most 512 layers");
+  const ids = /* @__PURE__ */ new Set();
+  for (const layer of doc.layers) {
+    validateLayer(layer);
+    if (ids.has(layer.id)) fail(`Duplicate layer ID: ${layer.id}`);
+    ids.add(layer.id);
+  }
+}
+
+// src/core/placements.ts
+function validatePlacementOverrides(value = {}) {
+  finiteTree(value, "placementOverrides");
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new Error("Expected placementOverrides object");
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => {
+      if (!key.length || key.length > 256)
+        throw new Error("Placement key must contain 1\u2013256 characters");
+      if (!entry || typeof entry !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(entry)))
+        throw new Error(`Invalid placement override '${key}'`);
+      const input = entry;
+      if (Object.keys(input).some(
+        (field2) => !["position", "quaternion", "scale", "grounding"].includes(field2)
+      ))
+        throw new Error(`Unknown placement override fields '${key}'`);
+      function vector2(field2, length) {
+        const values = input[field2];
+        if (!Array.isArray(values) || values.length !== length || !Array.from(values).every(Number.isFinite))
+          throw new Error(`${key}.${field2} must contain ${length} finite numbers`);
+        return Array.from(values);
+      }
+      const position = vector2("position", 3);
+      const quaternion = vector2("quaternion", 4);
+      const scale2 = vector2("scale", 3);
+      if (scale2.some((item) => item <= 0)) throw new Error(`${key}.scale must be positive`);
+      if (Math.abs(Math.hypot(...quaternion) - 1) > 1e-6)
+        throw new Error(`${key}.quaternion must be a unit quaternion`);
+      const grounding = input.grounding === void 0 ? true : input.grounding;
+      if (typeof grounding !== "boolean") throw new Error(`${key}.grounding must be boolean`);
+      return [key, { position, quaternion, scale: scale2, grounding }];
+    })
+  );
+}
+
+// src/core/terrain.ts
+var TerrainEvaluator = class {
+  cache = /* @__PURE__ */ new Map();
+  bytes = 0;
+  limit;
+  constructor({ cacheMB = 48 } = {}) {
+    if (!Number.isFinite(cacheMB) || cacheMB < 0)
+      throw new RangeError("cacheMB must be finite and nonnegative");
+    this.limit = cacheMB * 1024 * 1024;
+  }
+  clear() {
+    this.cache.clear();
+    this.bytes = 0;
+  }
+  evaluate(doc, { resolution = doc.config.resolution, signal, onProgress } = {}) {
+    validateDocument(doc);
+    validateConfig({ ...doc.config, resolution });
+    const keys = [];
+    let key = JSON.stringify({ ...doc.config, resolution });
+    for (const layer of doc.layers) {
+      key += `|${JSON.stringify(layer)}`;
+      keys.push(key);
+    }
+    let state;
+    let start = 0;
+    for (let i = keys.length - 1; i >= 0; i--) {
+      const k = keys[i];
+      const hit = this.cache.get(k);
+      if (hit) {
+        state = structuredClone(hit.state);
+        start = i + 1;
+        this.cache.delete(k);
+        this.cache.set(k, hit);
+        break;
+      }
+    }
+    state ??= createState(doc.config, resolution);
+    for (let i = start; i < doc.layers.length; i++) {
+      signal?.throwIfAborted();
+      const layer = doc.layers[i];
+      applyOperation(state, layer);
+      onProgress?.({ index: i, total: doc.layers.length, id: layer.id });
+      const bytes = state.height.byteLength + state.splat.byteLength + Object.values(state.erosion ?? {}).reduce((n, a) => n + a.byteLength, 0) + Object.values(state.biomes).reduce((n, a) => n + a.byteLength, 0);
+      if (bytes <= this.limit) {
+        while (this.bytes + bytes > this.limit && this.cache.size) {
+          const first = this.cache.entries().next().value;
+          if (!first) break;
+          this.bytes -= first[1].bytes;
+          this.cache.delete(first[0]);
+        }
+        this.cache.set(keys[i], { state: structuredClone(state), bytes });
+        this.bytes += bytes;
+      }
+    }
+    signal?.throwIfAborted();
+    if (!state.height.every(Number.isFinite))
+      throw new Error("A terrain operation produced a non-finite height");
+    return finalizeState(state);
+  }
+};
+var Terrain = class _Terrain {
+  _doc;
+  _undo = [];
+  _redo = [];
+  _listeners = /* @__PURE__ */ new Set();
+  _historyLimit;
+  _transactionDepth = 0;
+  _evaluator = new TerrainEvaluator();
+  constructor({
+    size = 512,
+    resolution = 257,
+    seed = 73,
+    historyLimit = 60
+  } = {}) {
+    const config = { size, resolution, seed };
+    validateConfig(config);
+    if (!Number.isInteger(historyLimit) || historyLimit < 0)
+      throw new RangeError("historyLimit must be a nonnegative integer");
+    this._doc = { version: 1, config, layers: [] };
+    this._historyLimit = historyLimit;
+  }
+  static fromJSON(json2) {
+    const doc = typeof json2 === "string" ? JSON.parse(json2) : structuredClone(json2);
+    validateDocument(doc);
+    const terrain = new _Terrain(doc.config);
+    terrain._doc = doc;
+    return terrain;
+  }
+  get layers() {
+    return structuredClone(this._doc.layers);
+  }
+  get config() {
+    return structuredClone(this._doc.config);
+  }
+  get canUndo() {
+    return this._undo.length > 0;
+  }
+  get canRedo() {
+    return this._redo.length > 0;
+  }
+  toJSON() {
+    return structuredClone(this._doc);
+  }
+  subscribe(fn) {
+    this._listeners.add(fn);
+    return () => this._listeners.delete(fn);
+  }
+  _emit() {
+    for (const fn of this._listeners) {
+      try {
+        fn(this);
+      } catch (error) {
+        console.error("Terrain subscriber failed:", error);
+      }
+    }
+  }
+  _change(fn) {
+    const before = structuredClone(this._doc);
+    try {
+      fn();
+      validateDocument(this._doc);
+    } catch (error) {
+      this._doc = before;
+      throw error;
+    }
+    if (!this._transactionDepth) {
+      this._undo.push(before);
+      if (this._undo.length > this._historyLimit) this._undo.shift();
+      this._redo = [];
+      this._emit();
+    }
+    return this;
+  }
+  _id(type) {
+    let i = 1;
+    while (this._doc.layers.some((layer) => layer.id === `${type}-${i}`)) i++;
+    return `${type}-${i}`;
+  }
+  add(layer) {
+    const next = { enabled: true, opacity: 1, ...structuredClone(layer) };
+    next.id ??= this._id(next.type);
+    validateLayer(next);
+    return this._change(() => {
+      const i = this._doc.layers.findIndex((layer2) => layer2.id === next.id);
+      if (i < 0) this._doc.layers.push(next);
+      else this._doc.layers[i] = next;
+    });
+  }
+  _operation(type, options) {
+    const { id, label, enabled, opacity, mask, ...params } = options;
+    if ("data" in params && params.data && typeof params.data === "object" && "values" in params.data && ArrayBuffer.isView(params.data.values)) {
+      const data = params.data;
+      Object.assign(params, { data: { ...data, values: Array.from(data.values) } });
+    }
+    const layer = { id: id ?? this._id(type), type, params };
+    const optional = Object.fromEntries(
+      Object.entries({ name: label, enabled, opacity, mask }).filter(
+        ([, value]) => value !== void 0
+      )
+    );
+    return this.add(Object.assign(layer, optional));
+  }
+  layer(id) {
+    const layer = this._doc.layers.find((layer2) => layer2.id === id);
+    if (!layer) throw new Error(`Unknown layer '${id}'`);
+    return structuredClone(layer);
+  }
+  update(id, patch) {
+    const old = this.layer(id);
+    const next = {
+      ...old,
+      ...structuredClone(patch),
+      id,
+      params: { ...old.params, ...structuredClone(patch.params ?? {}) }
+    };
+    const { mask: _mask, ...unmasked } = next;
+    return this.add(patch.mask === null ? unmasked : next);
+  }
+  toggle(id, enabled = this.layer(id).enabled === false) {
+    return this.update(id, { enabled });
+  }
+  move(id, index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this._doc.layers.length)
+      throw new RangeError("Layer index out of bounds");
+    return this._change(() => {
+      const i = this._doc.layers.findIndex((layer2) => layer2.id === id);
+      if (i < 0) throw new Error(`Unknown layer '${id}'`);
+      const layer = this._doc.layers.splice(i, 1)[0];
+      this._doc.layers.splice(index, 0, layer);
+    });
+  }
+  remove(id) {
+    this.layer(id);
+    return this._change(() => {
+      this._doc.layers = this._doc.layers.filter((layer) => layer.id !== id);
+    });
+  }
+  setConfig(patch) {
+    const config = { ...this._doc.config, ...patch };
+    validateConfig(config);
+    return this._change(() => {
+      this._doc.config = config;
+    });
+  }
+  loadJSON(json2) {
+    const next = _Terrain.fromJSON(json2).toJSON();
+    return this._change(() => {
+      this._doc = next;
+    });
+  }
+  transaction(fn) {
+    if (fn.constructor.name === "AsyncFunction")
+      throw new TypeError("Transactions must be synchronous");
+    const before = structuredClone(this._doc);
+    const undo = this._undo.slice();
+    const redo = this._redo.slice();
+    this._transactionDepth++;
+    try {
+      const result = fn(this);
+      if (result && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function")
+        throw new TypeError("Transactions must be synchronous");
+      validateDocument(this._doc);
+      this._transactionDepth--;
+      if (!this._transactionDepth) {
+        this._undo.push(before);
+        if (this._undo.length > this._historyLimit) this._undo.shift();
+        this._redo = [];
+        this._emit();
+      }
+      return this;
+    } catch (error) {
+      this._transactionDepth--;
+      this._doc = before;
+      this._undo = undo;
+      this._redo = redo;
+      throw error;
+    }
+  }
+  applyPatch(commands) {
+    return this.transaction(() => {
+      for (const command of commands) {
+        switch (command.op) {
+          case "upsert":
+            this.add(command.layer);
+            break;
+          case "update":
+            this.update(command.id, command.patch);
+            break;
+          case "remove":
+            this.remove(command.id);
+            break;
+          case "move":
+            this.move(command.id, command.index);
+            break;
+          case "toggle":
+            this.toggle(command.id, command.enabled);
+            break;
+          default:
+            throw new Error("Unknown patch command");
+        }
+      }
+    });
+  }
+  undo() {
+    const prior = this._undo.pop();
+    if (prior) {
+      this._redo.push(structuredClone(this._doc));
+      this._doc = prior;
+      this._emit();
+    }
+    return this;
+  }
+  redo() {
+    const next = this._redo.pop();
+    if (next) {
+      this._undo.push(structuredClone(this._doc));
+      this._doc = next;
+      this._emit();
+    }
+    return this;
+  }
+  evaluate(options) {
+    return this._evaluator.evaluate(this._doc, options);
+  }
+  clearCache() {
+    this._evaluator.clear();
+  }
+  copyRegion({ at = [0, 0], size = 64, resolution = 33 } = {}) {
+    if (!RESOLUTIONS.includes(resolution)) throw new RangeError("Unsupported copy resolution");
+    if (!(size > 0 && Number.isFinite(size))) throw new RangeError("Copy size must be positive");
+    const state = this.evaluate();
+    const values = [];
+    for (let z = 0; z < resolution; z++)
+      for (let x = 0; x < resolution; x++)
+        values.push(
+          sampleHeight(
+            state,
+            at[0] + (x / (resolution - 1) - 0.5) * size,
+            at[1] + (z / (resolution - 1) - 0.5) * size
+          )
+        );
+    return { width: resolution, height: resolution, values };
+  }
+  inspect(options) {
+    const state = this.evaluate(options);
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const height of state.height) {
+      min = Math.min(min, height);
+      max = Math.max(max, height);
+    }
+    return {
+      size: state.size,
+      resolution: state.resolution,
+      layers: this._doc.layers.length,
+      vertices: state.height.length,
+      triangles: 2 * (state.resolution - 1) ** 2,
+      minHeight: min,
+      maxHeight: max,
+      instances: state.instances.length,
+      diagnostics: state.diagnostics
+    };
+  }
+  noise(options = {}) {
+    return this._operation("noise", options);
+  }
+  sculpt(options = {}) {
+    return this._operation("sculpt", options);
+  }
+  smooth(options = {}) {
+    return this._operation("smooth", options);
+  }
+  flatten(options = {}) {
+    return this._operation("flatten", options);
+  }
+  ramp(options) {
+    return this._operation("ramp", options);
+  }
+  stamp(options = {}) {
+    return this._operation("stamp", options);
+  }
+  erode(options = {}) {
+    return this._operation("erode", options);
+  }
+  terrace(options = {}) {
+    return this._operation("terrace", options);
+  }
+  materials(options) {
+    return this._operation("materials", options);
+  }
+  paint(options = {}) {
+    return this._operation("paint", options);
+  }
+  biome(options = {}) {
+    return this._operation("biome", options);
+  }
+  scatter(options = {}) {
+    return this._operation("scatter", options);
+  }
+  clear(options) {
+    return this._operation("clear", options);
+  }
+  road(options) {
+    return this._operation("road", options);
+  }
+  river(options) {
+    return this._operation("river", options);
+  }
+  water(options = {}) {
+    return this._operation("water", options);
+  }
+  heightmap(options) {
+    return this._operation("heightmap", options);
+  }
+  paste(options) {
+    return this._operation("paste", options);
+  }
+};
+
+// src/editor/images.ts
+var SURFACE_CHANNELS = {
+  albedo: "srgb",
+  ao: "linear",
+  height: "linear",
+  metalness: "linear",
+  normal: "linear",
+  opacity: "linear",
+  roughness: "linear"
+};
+function fail2(message) {
+  throw new Error(message);
+}
+var CRC = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (const byte of bytes) c = CRC[(c ^ byte) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function png(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  let sawData = false;
+  let sawEnd = false;
+  const diagnostics = [];
+  for (let offset = 8; offset < bytes.byteLength; ) {
+    if (offset + 12 > bytes.byteLength) fail2("PNG chunk is truncated");
+    const length = view.getUint32(offset);
+    const type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
+    if (offset + 12 + length > bytes.byteLength) fail2(`PNG ${type} chunk runs past the end`);
+    const body2 = bytes.subarray(offset + 4, offset + 8 + length);
+    if (crc32(body2) !== view.getUint32(offset + 8 + length))
+      fail2(`PNG ${type} chunk fails its checksum; the file is damaged`);
+    if (type === "IHDR") {
+      if (length !== 13) fail2("PNG header is malformed");
+      width = view.getUint32(offset + 8);
+      height = view.getUint32(offset + 12);
+      depth = bytes[offset + 16];
+    } else if (type === "IDAT") sawData = true;
+    else if (type === "IEND") {
+      sawEnd = true;
+      break;
+    }
+    offset += 12 + length;
+  }
+  if (!width || !height) fail2("PNG has no header");
+  if (!sawData || !sawEnd) fail2("PNG is missing its image data or end marker");
+  if (depth === 16) diagnostics.push("16-bit PNG: browsers decode it to 8 bits per channel");
+  return { format: "png", width, height, diagnostics };
+}
+function jpeg(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 2;
+  while (offset + 4 <= bytes.byteLength) {
+    if (bytes[offset] !== 255) fail2("JPEG has a damaged marker");
+    const marker = bytes[offset + 1];
+    if (marker === 255) {
+      offset += 1;
+      continue;
+    }
+    const length = view.getUint16(offset + 2);
+    if ([192, 193, 194].includes(marker)) {
+      if (offset + 9 > bytes.byteLength) fail2("JPEG frame header is truncated");
+      const height = view.getUint16(offset + 5);
+      const width = view.getUint16(offset + 7);
+      if (!width || !height) fail2("JPEG has no size");
+      const ended = bytes[bytes.byteLength - 2] === 255 && bytes[bytes.byteLength - 1] === 217;
+      if (!ended) fail2("JPEG is truncated: it has no end marker");
+      return { format: "jpeg", width, height, diagnostics: [] };
+    }
+    offset += 2 + length;
+  }
+  return fail2("JPEG has no frame header");
+}
+function webp(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(4, true) + 8 !== bytes.byteLength)
+    fail2("WebP length header disagrees with the file");
+  const kind = String.fromCharCode(...bytes.subarray(12, 16));
+  if (bytes.byteLength < 30) fail2("WebP header is truncated");
+  if (kind === "VP8X")
+    return {
+      format: "webp",
+      width: 1 + bytes[24] + (bytes[25] << 8) + (bytes[26] << 16),
+      height: 1 + bytes[27] + (bytes[28] << 8) + (bytes[29] << 16),
+      diagnostics: []
+    };
+  if (kind === "VP8 ")
+    return {
+      format: "webp",
+      width: view.getUint16(26, true) & 16383,
+      height: view.getUint16(28, true) & 16383,
+      diagnostics: []
+    };
+  if (kind === "VP8L") {
+    const bits = view.getUint32(21, true);
+    return {
+      format: "webp",
+      width: 1 + (bits & 16383),
+      height: 1 + (bits >> 14 & 16383),
+      diagnostics: []
+    };
+  }
+  return fail2(`WebP chunk '${kind}' is not supported`);
+}
+function hdr(bytes) {
+  const head = new TextDecoder("latin1").decode(
+    bytes.subarray(0, Math.min(bytes.byteLength, 4096))
+  );
+  const end = head.indexOf("\n\n");
+  if (end < 0) fail2("Radiance HDR header is not terminated");
+  if (!/FORMAT=32-bit_rle_rgbe/u.test(head.slice(0, end)))
+    fail2("Radiance HDR must be 32-bit_rle_rgbe");
+  const size = /^([-+])Y (\d+) ([-+])X (\d+)/mu.exec(head.slice(end + 2));
+  if (!size) fail2("Radiance HDR has no resolution line");
+  return { format: "hdr", width: Number(size[4]), height: Number(size[2]), diagnostics: [] };
+}
+function exr(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const text3 = new TextDecoder("latin1");
+  let offset = 8;
+  let window;
+  let compression;
+  while (offset < bytes.byteLength && bytes[offset] !== 0) {
+    const nameEnd = bytes.indexOf(0, offset);
+    const typeEnd = bytes.indexOf(0, nameEnd + 1);
+    if (nameEnd < 0 || typeEnd < 0 || typeEnd + 5 > bytes.byteLength)
+      fail2("EXR header is truncated");
+    const name = text3.decode(bytes.subarray(offset, nameEnd));
+    const size = view.getInt32(typeEnd + 1, true);
+    const value = typeEnd + 5;
+    if (size < 0 || value + size > bytes.byteLength) fail2("EXR attribute runs past the file");
+    if (name === "dataWindow" && size === 16)
+      window = [
+        view.getInt32(value, true),
+        view.getInt32(value + 4, true),
+        view.getInt32(value + 8, true),
+        view.getInt32(value + 12, true)
+      ];
+    if (name === "compression") compression = bytes[value];
+    offset = value + size;
+  }
+  if (!window) fail2("EXR has no data window");
+  const diagnostics = [];
+  if (compression === 6 || compression === 7)
+    diagnostics.push("EXR B44 compression is not read by the loader");
+  return {
+    format: "exr",
+    width: window[2] - window[0] + 1,
+    height: window[3] - window[1] + 1,
+    diagnostics
+  };
+}
+function inspectImage(bytes, format, limits) {
+  const report = format === "png" ? png(bytes) : format === "jpeg" ? jpeg(bytes) : format === "webp" ? webp(bytes) : format === "hdr" ? hdr(bytes) : format === "exr" ? exr(bytes) : fail2(`'${format}' is not a supported image format`);
+  if (report.width > limits.maxDimension || report.height > limits.maxDimension)
+    fail2(
+      `Image is ${report.width}x${report.height}; this project's limit is ${limits.maxDimension} pixels`
+    );
+  if (report.width % 4 || report.height % 4)
+    report.diagnostics.push(
+      "Size is not a multiple of 4: block compression of this image would fail"
+    );
+  return report;
+}
+
+// src/editor/assets.ts
+var DEFAULT_ASSET_LIMITS = {
+  maxBytes: 128 * 1024 * 1024,
+  maxDimension: 16384,
+  maxTriangles: 5e6
+};
+var MAX_ASSETS = 64;
+var ID = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
+var PATH = /^(models|images|environments)\/[a-f0-9]{12}-[a-z0-9_-]+\.(glb|png|jpg|webp|hdr|exr)$/u;
+var FOLDER = {
+  model: "models",
+  image: "images",
+  environment: "environments"
+};
+var GLB_MAGIC = 1179937895;
+var JSON_CHUNK = 1313821514;
+var BIN_CHUNK = 5130562;
+var COMPONENT_BYTES = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+var TYPE_COUNT = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+function fail3(message) {
+  throw new Error(message);
+}
+function inspectGlb(bytes, limits) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.byteLength < 20 || view.getUint32(0, true) !== GLB_MAGIC)
+    fail3("Not a GLB file: missing the glTF binary header");
+  if (view.getUint32(4, true) !== 2) fail3("Unsupported GLB version; expected glTF 2");
+  if (view.getUint32(8, true) !== bytes.byteLength)
+    fail3("GLB length header disagrees with the file size");
+  let json2;
+  let bin;
+  for (let offset = 12; offset < bytes.byteLength; ) {
+    if (offset + 8 > bytes.byteLength) fail3("GLB chunk header is truncated");
+    const length = view.getUint32(offset, true);
+    const type = view.getUint32(offset + 4, true);
+    const start = offset + 8;
+    if (start + length > bytes.byteLength) fail3("GLB chunk runs past the end of the file");
+    if (type === JSON_CHUNK)
+      try {
+        json2 = JSON.parse(new TextDecoder().decode(bytes.subarray(start, start + length)));
+      } catch {
+        fail3("GLB JSON chunk is not valid JSON");
+      }
+    else if (type === BIN_CHUNK && bin === void 0) bin = bytes.subarray(start, start + length);
+    offset = start + length + (4 - length % 4) % 4;
+  }
+  if (!json2 || json2.asset?.version?.startsWith("2") !== true) fail3("GLB has no glTF 2 JSON chunk");
+  const gltf = json2;
+  const diagnostics = [];
+  for (const [index, buffer] of (gltf.buffers ?? []).entries())
+    if (buffer.uri !== void 0 && !buffer.uri.startsWith("data:"))
+      fail3(
+        `GLB references external buffer '${buffer.uri}'; supply a self-contained .glb, dependencies are never fetched (buffer ${index})`
+      );
+  for (const image of gltf.images ?? [])
+    if (image.uri !== void 0 && !image.uri.startsWith("data:"))
+      fail3(`GLB references external image '${image.uri}'; embed it or supply it as a project file`);
+  if (gltf.extensionsRequired?.length)
+    fail3(
+      `GLB requires extensions this editor does not guarantee: ${gltf.extensionsRequired.join(", ")}`
+    );
+  const accessorData = (index) => {
+    const accessor = gltf.accessors?.[index] ?? fail3(`GLB accessor ${index} is missing`);
+    if (accessor.sparse) fail3(`GLB accessor ${index} is sparse, which is not supported`);
+    const width = COMPONENT_BYTES[accessor.componentType] ?? fail3(`GLB accessor ${index} has an unknown component type`);
+    const components = TYPE_COUNT[accessor.type] ?? fail3(`GLB accessor ${index} has an unknown type`);
+    const viewIndex = accessor.bufferView ?? fail3(`GLB accessor ${index} has no buffer view`);
+    const bufferView = gltf.bufferViews?.[viewIndex] ?? fail3(`GLB buffer view ${viewIndex} is missing`);
+    const source = bufferView.buffer === 0 && bin ? bin : fail3("GLB buffer data is not embedded");
+    const stride = bufferView.byteStride ?? width * components;
+    const base = (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+    if (base + stride * Math.max(accessor.count - 1, 0) + width * components > source.byteLength)
+      fail3(`GLB accessor ${index} reads past its buffer`);
+    const data = new DataView(source.buffer, source.byteOffset, source.byteLength);
+    return {
+      count: accessor.count,
+      components,
+      read: (i, c) => {
+        const at = base + stride * i + width * c;
+        switch (accessor.componentType) {
+          case 5126:
+            return data.getFloat32(at, true);
+          case 5125:
+            return data.getUint32(at, true);
+          case 5123:
+            return data.getUint16(at, true);
+          case 5122:
+            return data.getInt16(at, true);
+          case 5121:
+            return data.getUint8(at);
+          default:
+            return data.getInt8(at);
+        }
+      }
+    };
+  };
+  const world2 = (node) => {
+    if (node.matrix?.length === 16) return new Matrix4().fromArray(node.matrix);
+    const t = node.translation ?? [0, 0, 0];
+    const r = node.rotation ?? [0, 0, 0, 1];
+    const s = node.scale ?? [1, 1, 1];
+    return new Matrix4().compose(
+      new Vector3(t[0], t[1], t[2]),
+      new Quaternion(r[0], r[1], r[2], r[3]),
+      new Vector3(s[0], s[1], s[2])
+    );
+  };
+  const low = new Vector3(
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY
+  );
+  const high = new Vector3(
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY
+  );
+  let triangles = 0;
+  let lights = 0;
+  let cameras = 0;
+  const visit = (nodeIndex, parent, depth) => {
+    if (depth > 64) fail3("GLB node hierarchy is too deep");
+    const node = gltf.nodes?.[nodeIndex] ?? fail3(`GLB node ${nodeIndex} is missing`);
+    const matrix = parent.clone().multiply(world2(node));
+    if (node.camera !== void 0) cameras += 1;
+    if (node.extensions?.KHR_lights_punctual) lights += 1;
+    if (node.mesh !== void 0) {
+      const mesh = gltf.meshes?.[node.mesh] ?? fail3(`GLB mesh ${node.mesh} is missing`);
+      for (const primitive of mesh.primitives) {
+        if ((primitive.mode ?? 4) !== 4)
+          fail3("GLB has a non-triangle primitive, which is not supported");
+        const position = accessorData(
+          primitive.attributes.POSITION ?? fail3("GLB primitive has no POSITION")
+        );
+        if (position.components !== 3) fail3("GLB POSITION must be VEC3");
+        const point2 = new Vector3();
+        for (let i = 0; i < position.count; i += 1) {
+          point2.set(position.read(i, 0), position.read(i, 1), position.read(i, 2));
+          if (!Number.isFinite(point2.x + point2.y + point2.z))
+            fail3(`GLB geometry has a non-finite vertex (vertex ${i})`);
+          point2.applyMatrix4(matrix);
+          low.min(point2);
+          high.max(point2);
+        }
+        triangles += primitive.indices === void 0 ? Math.floor(position.count / 3) : Math.floor(accessorData(primitive.indices).count / 3);
+      }
+    }
+    for (const child of node.children ?? []) visit(child, matrix, depth + 1);
+  };
+  const roots = gltf.scenes?.[gltf.scene ?? 0]?.nodes ?? fail3("GLB has no default scene with nodes");
+  for (const root of roots) visit(root, new Matrix4(), 0);
+  if (!Number.isFinite(low.x + high.x) || triangles === 0)
+    fail3("GLB contains no triangle geometry");
+  if (triangles > limits.maxTriangles)
+    fail3(`GLB has ${triangles} triangles; this project's limit is ${limits.maxTriangles}`);
+  if (lights)
+    diagnostics.push(
+      `${lights} imported light(s) stay inactive: lights come from the world's environment`
+    );
+  if (cameras)
+    diagnostics.push(`${cameras} imported camera(s) stay inactive: the editor owns its cameras`);
+  return {
+    bounds: {
+      min: low.toArray(),
+      max: high.toArray()
+    },
+    triangles,
+    diagnostics
+  };
+}
+function text(value, name, max = 512) {
+  if (typeof value !== "string" || !value || value.length > max)
+    throw new Error(`${name} must be a short non-empty string`);
+  return value;
+}
+function validateAsset(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("An asset must be an object");
+  const value = input;
+  const known = [
+    "id",
+    "kind",
+    "name",
+    "path",
+    "sha256",
+    "bytes",
+    "status",
+    "license",
+    "source",
+    "bounds",
+    "triangles",
+    "adjust",
+    "diagnostics",
+    "width",
+    "height",
+    "format"
+  ];
+  const extra = Object.keys(value).filter((key) => !known.includes(key));
+  if (extra.length) throw new Error(`Asset has unknown fields: ${extra.join(", ")}`);
+  const id = text(value.id, "Asset.id", 48);
+  if (!ID.test(id)) throw new Error(`Asset id '${id}' must be lowercase letters, digits, - or _`);
+  if (value.kind !== "model" && value.kind !== "image" && value.kind !== "environment")
+    throw new Error("Asset.kind must be model, image or environment");
+  const path = text(value.path, "Asset.path", 96);
+  if (!PATH.test(path) || !path.startsWith(`${FOLDER[value.kind]}/`))
+    throw new Error(
+      `Asset.path '${path}' must be a content-addressed file under ${FOLDER[value.kind]}/`
+    );
+  if (typeof value.sha256 !== "string" || !/^[a-f0-9]{64}$/u.test(value.sha256))
+    throw new Error("Asset.sha256 must be a 64-digit hex digest");
+  if (!path.includes(`/${value.sha256.slice(0, 12)}-`))
+    throw new Error("Asset.path must carry the first 12 digits of its sha256");
+  if (!Number.isSafeInteger(value.bytes) || value.bytes <= 0)
+    throw new Error("Asset.bytes must be a positive integer");
+  if (value.status !== "ready") throw new Error("Asset.status must be ready");
+  const out = {
+    id,
+    kind: value.kind,
+    name: text(value.name, "Asset.name", 128),
+    path,
+    sha256: value.sha256,
+    bytes: value.bytes,
+    status: "ready"
+  };
+  for (const key of ["license", "source"])
+    if (value[key] !== void 0) out[key] = text(value[key], `Asset.${key}`, 512);
+  if (value.bounds !== void 0) {
+    const bounds = value.bounds;
+    const ok = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number" && Number.isFinite(n));
+    const { min, max } = bounds ?? {};
+    if (!ok(min) || !ok(max) || min.some((n, i) => n > max[i]))
+      throw new Error("Asset.bounds must be finite ordered min/max vectors");
+    out.bounds = { min, max };
+  }
+  for (const key of ["triangles", "width", "height"])
+    if (value[key] !== void 0) {
+      if (!Number.isSafeInteger(value[key]) || value[key] < 0)
+        throw new Error(`Asset.${key} must be a non-negative integer`);
+      out[key] = value[key];
+    }
+  if (value.format !== void 0) out.format = text(value.format, "Asset.format", 16);
+  if (value.adjust !== void 0) {
+    const adjust = value.adjust;
+    if (typeof adjust?.scale !== "number" || !Number.isFinite(adjust.scale) || adjust.scale <= 0 || adjust.scale > 1e4)
+      throw new Error("Asset.adjust.scale must be a positive finite number");
+    if (!["base", "centre", "origin"].includes(adjust.pivot))
+      throw new Error("Asset.adjust.pivot must be base, centre or origin");
+    out.adjust = { scale: adjust.scale, pivot: adjust.pivot };
+  }
+  if (value.diagnostics !== void 0) {
+    if (!Array.isArray(value.diagnostics) || value.diagnostics.length > 16)
+      throw new Error("Asset.diagnostics must list at most 16 messages");
+    out.diagnostics = value.diagnostics.map((entry) => text(entry, "Asset.diagnostics", 256));
+  }
+  return out;
+}
+function validateAssets(input) {
+  if (!Array.isArray(input) || input.length > MAX_ASSETS)
+    throw new Error(`A document holds at most ${MAX_ASSETS} assets`);
+  const assets = input.map((entry) => validateAsset(entry));
+  if (new Set(assets.map((entry) => entry.id)).size !== assets.length)
+    throw new Error("Asset ids must be unique");
+  return assets;
+}
+function sniff(bytes) {
+  const head = (...codes) => codes.every((code, i) => bytes[i] === code);
+  if (head(103, 108, 84, 70)) return { kind: "model", ext: "glb", format: "glb" };
+  if (head(137, 80, 78, 71)) return { kind: "image", ext: "png", format: "png" };
+  if (head(255, 216, 255)) return { kind: "image", ext: "jpg", format: "jpeg" };
+  if (head(82, 73, 70, 70) && bytes[8] === 87 && bytes[9] === 69)
+    return { kind: "image", ext: "webp", format: "webp" };
+  const ascii = new TextDecoder().decode(bytes.subarray(0, 11));
+  if (ascii.startsWith("#?RADIANCE") || ascii.startsWith("#?RGBE"))
+    return { kind: "environment", ext: "hdr", format: "hdr" };
+  if (head(118, 47, 49, 1)) return { kind: "environment", ext: "exr", format: "exr" };
+  return void 0;
+}
+var SURFACE_INPUT = /^[a-z0-9][a-z0-9_-]{0,31}\.([a-z]+)$/u;
+function surfaceSpace(input) {
+  const channel = SURFACE_INPUT.exec(input)?.[1];
+  const space = channel ? SURFACE_CHANNELS[channel] : void 0;
+  if (!space)
+    throw new Error(
+      `Surface input '${input}' must be <surface>.<channel>, channel one of ${Object.keys(SURFACE_CHANNELS).join(", ")}`
+    );
+  return space;
+}
+function validateSurfaces(input, assets) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("surfaces must be an object");
+  const entries = Object.entries(input);
+  if (entries.length > 64) throw new Error("A document holds at most 64 surface mappings");
+  const out = {};
+  for (const [key, value] of entries) {
+    surfaceSpace(key);
+    const mapping = value;
+    if (!mapping || typeof mapping !== "object" || Object.keys(mapping).some((k) => k !== "asset"))
+      throw new Error(`surfaces.${key} must be { asset }`);
+    const asset = assets.find((entry) => entry.id === mapping.asset);
+    if (!asset || asset.kind !== "image")
+      throw new Error(
+        `surfaces.${key} names '${String(mapping.asset)}', which is not a registered image`
+      );
+    out[key] = { asset: asset.id };
+  }
+  return out;
+}
+
+// src/editor/assetStore.ts
+var AssetStore = class {
+  dir;
+  limits;
+  constructor(dir, limits = {}) {
+    if (!isAbsolute(dir)) throw new Error("Assets directory must be absolute");
+    this.dir = resolve(dir);
+    this.limits = { ...DEFAULT_ASSET_LIMITS, ...limits };
+  }
+  /** Read a local source file for registration: a regular file, never a link, within the limit. */
+  readSource(path) {
+    if (!isAbsolute(path)) throw new Error("Asset path must be absolute");
+    const info = lstatSync(path);
+    if (!info.isFile() || info.isSymbolicLink())
+      throw new Error("Asset path must be a regular file");
+    if (info.size > this.limits.maxBytes)
+      throw new Error(
+        `Asset is ${info.size} bytes; this project's limit is ${this.limits.maxBytes}`
+      );
+    const descriptor = openSync(path, "r");
+    try {
+      const bytes = new Uint8Array(fstatSync(descriptor).size);
+      let read = 0;
+      while (read < bytes.length) {
+        const count = readSync(descriptor, bytes, read, bytes.length - read, read);
+        if (!count) break;
+        read += count;
+      }
+      return bytes;
+    } finally {
+      closeSync(descriptor);
+    }
+  }
+  /** The bytes of one stored file, addressed only by a path an entry carries. */
+  read(path) {
+    if (!PATH.test(path)) throw new Error("Unknown asset file");
+    return readFileSync(join(this.dir, path));
+  }
+  /** Measure, hash and store one file; the returned entry is what the document saves. */
+  store(id, name, bytes, extra) {
+    if (!ID.test(id)) throw new Error(`Asset id '${id}' must be lowercase letters, digits, - or _`);
+    if (bytes.byteLength > this.limits.maxBytes)
+      throw new Error(
+        `Asset is ${bytes.byteLength} bytes; this project's limit is ${this.limits.maxBytes}`
+      );
+    const kind = sniff(bytes);
+    if (!kind)
+      throw new Error(`'${name}' is not a supported GLB, PNG, JPEG, WebP, HDR or EXR file`);
+    if (extra.kind && extra.kind !== kind.kind)
+      throw new Error(`'${name}' is a ${kind.kind} file, not a ${extra.kind}`);
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    const measured = kind.kind === "model" ? inspectGlb(bytes, this.limits) : void 0;
+    const picture = kind.kind === "model" ? void 0 : inspectImage(bytes, kind.format, this.limits);
+    const path = `${FOLDER[kind.kind]}/${sha256.slice(0, 12)}-${id}.${kind.ext}`;
+    mkdirSync(join(this.dir, FOLDER[kind.kind]), { recursive: true });
+    const target = join(this.dir, path);
+    const temporary = `${target}.${process.pid}.tmp`;
+    try {
+      lstatSync(target);
+    } catch {
+      writeFileSync(temporary, bytes, { flag: "wx", mode: 384 });
+      renameSync(temporary, target);
+    }
+    return validateAsset({
+      id,
+      kind: kind.kind,
+      name: name.slice(0, 128),
+      path,
+      sha256,
+      bytes: bytes.byteLength,
+      status: "ready",
+      ...extra.license ? { license: extra.license } : {},
+      ...extra.source ? { source: extra.source } : {},
+      ...measured ? {
+        bounds: measured.bounds,
+        triangles: measured.triangles,
+        ...measured.diagnostics.length ? { diagnostics: measured.diagnostics } : {},
+        adjust: { scale: 1, pivot: "base" }
+      } : {},
+      ...picture ? {
+        width: picture.width,
+        height: picture.height,
+        format: picture.format,
+        ...picture.diagnostics.length ? { diagnostics: picture.diagnostics } : {}
+      } : {}
+    });
+  }
+};
+
+// src/editor/cameras.ts
+var MAX_CAMERAS = 32;
+var MIN_VIEW_DISTANCE = 1e-6;
+var MIN_UP_ANGLE = 1e-6;
+function object(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${name} must be an object`);
+  return value;
+}
+function text2(value, name) {
+  if (typeof value !== "string" || !value) throw new Error(`${name} must be a name`);
+  return value;
+}
+function vector(value, name) {
+  if (!Array.isArray(value) || value.length !== 3 || !value.every((entry) => typeof entry === "number" && Number.isFinite(entry)))
+    throw new Error(`${name} must be finite [x, y, z] coordinates`);
+  return [value[0], value[1], value[2]];
+}
+function positive(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    throw new Error(`${name} must be a positive finite number`);
+  return value;
+}
+function unit(value) {
+  return Math.hypot(...value);
+}
+function scale(value, factor) {
+  return [value[0] * factor, value[1] * factor, value[2] * factor];
+}
+function cross(first, second) {
+  return [
+    first[1] * second[2] - first[2] * second[1],
+    first[2] * second[0] - first[0] * second[2],
+    first[0] * second[1] - first[1] * second[0]
+  ];
+}
+var COMMON_FIELDS = ["id", "name", "position", "target", "up", "near", "far"];
+function validateCamera(input, existing = []) {
+  const value = object(input, "Camera");
+  if (value.projection !== "perspective" && value.projection !== "orthographic")
+    throw new Error("Camera.projection must be 'perspective' or 'orthographic'");
+  const projection = value.projection;
+  const fields = projection === "perspective" ? [...COMMON_FIELDS, "projection", "fov"] : [...COMMON_FIELDS, "projection", "extent", "zoom"];
+  const extra = Object.keys(value).filter(
+    (key) => !fields.includes(key)
+  );
+  if (extra.length) throw new Error(`Camera has unknown fields: ${extra.join(", ")}`);
+  const id = text2(value.id, "Camera.id");
+  if (existing.some((camera) => camera.id === id))
+    throw new Error(`Camera id '${id}' already exists`);
+  const position = vector(value.position, "Camera.position");
+  const target = vector(value.target, "Camera.target");
+  const up = vector(value.up, "Camera.up");
+  if (unit([position[0] - target[0], position[1] - target[1], position[2] - target[2]]) < MIN_VIEW_DISTANCE)
+    throw new Error("Camera.position and Camera.target must not coincide");
+  const direction = scale(
+    [position[0] - target[0], position[1] - target[1], position[2] - target[2]],
+    1 / unit([position[0] - target[0], position[1] - target[1], position[2] - target[2]])
+  );
+  if (unit(up) < MIN_UP_ANGLE) throw new Error("Camera.up must be a usable direction");
+  if (unit(cross(up, direction)) < MIN_UP_ANGLE * unit(up))
+    throw new Error("Camera.up is parallel to the view direction");
+  const near = positive(value.near, "Camera.near");
+  const far = positive(value.far, "Camera.far");
+  if (far <= near) throw new Error("Camera.far must be greater than Camera.near");
+  const pose = {
+    id,
+    name: text2(value.name, "Camera.name"),
+    position,
+    target,
+    up,
+    near,
+    far
+  };
+  if (projection === "perspective") {
+    const fov = positive(value.fov, "Camera.fov");
+    if (fov >= 180) throw new Error("Camera.fov must be below 180 degrees");
+    return { ...pose, projection, fov };
+  }
+  return {
+    ...pose,
+    projection,
+    extent: positive(value.extent, "Camera.extent"),
+    zoom: positive(value.zoom, "Camera.zoom")
+  };
+}
+function validateCameras(input) {
+  if (!Array.isArray(input) || input.length > MAX_CAMERAS)
+    throw new Error(`A document holds at most ${MAX_CAMERAS} saved cameras`);
+  const cameras = [];
+  for (const entry of input) cameras.push(validateCamera(entry, cameras));
+  return cameras;
+}
+function require_(cameras, id) {
+  const name = text2(id, "Camera id");
+  const camera = cameras.find((entry) => entry.id === name);
+  if (!camera) throw new Error(`Unknown camera '${name}'`);
+  return camera;
+}
+function runCameraOperation(set, operation) {
+  const request = object(operation, "Camera operation");
+  const op = text2(request.op, "Camera operation op");
+  if (op === "list")
+    return {
+      op,
+      cameras: [...set.cameras],
+      activeCamera: set.activeCamera,
+      camera: null,
+      fallback: null
+    };
+  if (op === "get")
+    return {
+      op,
+      cameras: [...set.cameras],
+      activeCamera: set.activeCamera,
+      camera: require_(set.cameras, request.id),
+      fallback: null
+    };
+  if (op === "create") {
+    if (set.cameras.length >= MAX_CAMERAS)
+      throw new Error(`A document holds at most ${MAX_CAMERAS} saved cameras`);
+    const camera = validateCamera(request.camera, set.cameras);
+    return {
+      op,
+      cameras: [...set.cameras, camera],
+      activeCamera: set.activeCamera,
+      camera,
+      fallback: null
+    };
+  }
+  if (op === "update") {
+    const camera = require_(set.cameras, request.id);
+    const patch = object(request.patch, "Camera patch");
+    const merged = { ...camera, ...patch, id: camera.id };
+    let switched = merged;
+    if (patch.projection !== void 0) {
+      const stale = merged.projection === "perspective" ? ["extent", "zoom"] : ["fov"];
+      switched = Object.fromEntries(Object.entries(merged).filter(([key]) => !stale.includes(key)));
+    }
+    const next = validateCamera(
+      switched,
+      set.cameras.filter((entry) => entry.id !== camera.id)
+    );
+    return {
+      op,
+      cameras: set.cameras.map((entry) => entry.id === camera.id ? next : entry),
+      activeCamera: set.activeCamera,
+      camera: next,
+      fallback: null
+    };
+  }
+  if (op === "delete") {
+    const camera = require_(set.cameras, request.id);
+    const cameras = set.cameras.filter((entry) => entry.id !== camera.id);
+    const deleted = set.activeCamera === camera.id;
+    return {
+      op,
+      cameras,
+      activeCamera: deleted ? null : set.activeCamera,
+      camera,
+      fallback: deleted ? "editor-camera" : null
+    };
+  }
+  if (op === "activate") {
+    if (request.id === null)
+      return {
+        op,
+        cameras: [...set.cameras],
+        activeCamera: null,
+        camera: null,
+        fallback: "editor-camera"
+      };
+    require_(set.cameras, request.id);
+    return {
+      op,
+      cameras: [...set.cameras],
+      activeCamera: request.id,
+      camera: require_(set.cameras, request.id),
+      fallback: null
+    };
+  }
+  throw new Error(`Unknown camera operation '${op}'`);
+}
+
+// src/editor/environment.ts
+var SECTIONS = {
+  sun: ["azimuth", "elevation", "intensity", "colour"],
+  fill: ["intensity"],
+  sky: ["colour", "image", "rotation", "intensity"],
+  lighting: ["image", "rotation", "intensity"],
+  fog: ["mode", "colour", "density"],
+  ocean: ["shallow", "deep"]
+};
+var MAX_INTENSITY = 1e3;
+var MAX_EXPOSURE = 64;
+var MAX_DENSITY = 1;
+function object2(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${name} must be an object`);
+  return value;
+}
+function number(value, name, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max)
+    throw new Error(`${name} must be a finite number from ${min} to ${max}`);
+  return value;
+}
+function colour(value, name) {
+  if (typeof value !== "string" || !/^#[0-9a-fA-F]{6}$/u.test(value))
+    throw new Error(`${name} must be a #rrggbb colour`);
+  return value.toLowerCase();
+}
+function field(section, key, value) {
+  const name = `environment.${section}.${key}`;
+  switch (`${section}.${key}`) {
+    case "sun.azimuth":
+      return number(value, name, -360, 360);
+    case "sun.elevation":
+      return number(value, name, 0, 90);
+    case "sky.image":
+    case "lighting.image":
+      if (typeof value !== "string" || !/^[a-z0-9][a-z0-9_-]{0,47}$/u.test(value))
+        throw new Error(`${name} must be a registered asset id`);
+      return value;
+    case "sky.rotation":
+    case "lighting.rotation":
+      return number(value, name, -360, 360);
+    case "sun.intensity":
+    case "fill.intensity":
+    case "sky.intensity":
+    case "lighting.intensity":
+      return number(value, name, 0, MAX_INTENSITY);
+    case "fog.density":
+      return number(value, name, 0, MAX_DENSITY);
+    case "fog.mode":
+      if (value !== "exp2")
+        throw new Error(
+          `environment.fog.mode '${String(value)}' is not supported by this render source; supported: exp2`
+        );
+      return value;
+    default:
+      return colour(value, name);
+  }
+}
+function validateEnvironment(input) {
+  const value = object2(input, "environment");
+  const extra = Object.keys(value).filter((key) => key !== "exposure" && !(key in SECTIONS));
+  if (extra.length) throw new Error(`environment has unknown fields: ${extra.join(", ")}`);
+  const out = {};
+  if (value.exposure !== void 0)
+    out.exposure = number(value.exposure, "environment.exposure", 2 ** -8, MAX_EXPOSURE);
+  for (const [section, keys] of Object.entries(SECTIONS)) {
+    if (value[section] === void 0) continue;
+    const entries = object2(value[section], `environment.${section}`);
+    const unknown = Object.keys(entries).filter(
+      (key) => !keys.includes(key)
+    );
+    if (unknown.length)
+      throw new Error(`environment.${section} has unknown fields: ${unknown.join(", ")}`);
+    const clean = {};
+    for (const key of keys)
+      if (entries[key] !== void 0) clean[key] = field(section, key, entries[key]);
+    if (Object.keys(clean).length) out[section] = clean;
+  }
+  return out;
+}
+function runEnvironmentOperation(current, operation) {
+  const request = object2(operation, "Environment operation");
+  if (request.op === "get") return { op: "get", environment: current };
+  if (request.op === "reset") return { op: "reset", environment: {} };
+  if (request.op !== "patch") throw new Error("Environment op must be get, patch or reset");
+  const values = object2(request.values, "environment patch");
+  const merged = { ...current };
+  const clear = (value) => value === null ? void 0 : value;
+  for (const [key, patch] of Object.entries(values)) {
+    if (key === "exposure") merged.exposure = clear(patch);
+    else if (key in SECTIONS) {
+      if (patch === null) merged[key] = void 0;
+      else {
+        const entries = object2(patch, `environment.${key}`);
+        const section = { ...merged[key] ?? {} };
+        for (const [name, entry] of Object.entries(entries)) section[name] = clear(entry);
+        merged[key] = section;
+      }
+    } else throw new Error(`environment has unknown fields: ${key}`);
+  }
+  return { op: "patch", environment: validateEnvironment(merged) };
+}
+function checkEnvironmentAssets(environment, assets) {
+  for (const [group, image] of [
+    ["sky", environment.sky?.image],
+    ["lighting", environment.lighting?.image]
+  ]) {
+    if (image === void 0) continue;
+    const found = assets.find((entry) => entry.id === image);
+    if (!found || found.kind !== "environment" && found.kind !== "image")
+      throw new Error(
+        `environment.${group}.image names '${image}', which is not a registered environment or image asset`
+      );
+  }
+}
+
+// src/editor/spatialInspector.ts
+var MAX_PROFILE_SAMPLES = 1024;
+var MAX_CONTROLS = 8;
+var FLAT_SLOPE_DEG = 1e-6;
+function point(value, name) {
+  if (!Array.isArray(value) || value.length !== 2 || !value.every((entry) => typeof entry === "number" && Number.isFinite(entry)))
+    throw new Error(`${name} must be finite [x, z] coordinates`);
+  return [value[0], value[1]];
+}
+function bounded(state, value, name) {
+  const [x, z] = point(value, name);
+  const half = state.size / 2;
+  if (x < -half || x > half || z < -half || z > half)
+    throw new Error(`${name} [${x}, ${z}] is outside the ${state.size} m terrain extent`);
+  return [x, z];
+}
+function normalOf(gradient) {
+  const length = Math.hypot(gradient[0], 1, gradient[1]);
+  return [-gradient[0] / length, 1 / length, -gradient[1] / length];
+}
+function reading(source, height, gradient) {
+  const slopeDeg = Math.atan(Math.hypot(gradient[0], gradient[1])) * 180 / Math.PI;
+  return {
+    source,
+    height,
+    slopeDeg,
+    aspectDeg: slopeDeg < FLAT_SLOPE_DEG ? null : (Math.atan2(-gradient[0], gradient[1]) * 180 / Math.PI + 360) % 360,
+    normal: normalOf(gradient)
+  };
+}
+function bilinear(state, x, z) {
+  return reading("bilinear-heightfield", sampleHeight(state, x, z), gradientAt(state, x, z));
+}
+function triangle(state, x, z) {
+  const n = state.resolution;
+  const cell = state.size / (n - 1);
+  const gx = Math.min(n - 2, Math.max(0, Math.floor((x + state.size / 2) / cell)));
+  const gz = Math.min(n - 2, Math.max(0, Math.floor((z + state.size / 2) / cell)));
+  const tx = Math.min(1, Math.max(0, (x + state.size / 2) / cell - gx));
+  const tz = Math.min(1, Math.max(0, (z + state.size / 2) / cell - gz));
+  const x0 = -state.size / 2 + gx * cell;
+  const z0 = -state.size / 2 + gz * cell;
+  const h = (ix, iz) => state.height[(gz + iz) * n + gx + ix];
+  const a = [x0, h(0, 0), z0];
+  const b = [x0 + cell, h(1, 0), z0];
+  const c = [x0, h(0, 1), z0 + cell];
+  const d = [x0 + cell, h(1, 1), z0 + cell];
+  const [first, second, third] = tx + tz <= 1 ? [a, c, b] : [b, c, d];
+  const u = [second[0] - first[0], second[1] - first[1], second[2] - first[2]];
+  const v = [third[0] - first[0], third[1] - first[1], third[2] - first[2]];
+  const normal = [
+    u[1] * v[2] - u[2] * v[1],
+    u[2] * v[0] - u[0] * v[2],
+    u[0] * v[1] - u[1] * v[0]
+  ];
+  const length = Math.hypot(...normal) || 1;
+  const nx = normal[0] / length;
+  const ny = Math.abs(normal[1] / length) || 1;
+  const nz = normal[2] / length;
+  return reading(
+    "evaluated-triangle",
+    first[1] - (nx * (x - first[0]) + nz * (z - first[2])) / ny,
+    [-nx / ny, -nz / ny]
+  );
+}
+function probeTerrain(state, revision2, at) {
+  const [x, z] = bounded(state, at, "Point");
+  const bilinearValue = bilinear(state, x, z);
+  const triangleValue = triangle(state, x, z);
+  return {
+    kind: "point",
+    revision: revision2,
+    units: "metres",
+    resolution: state.resolution,
+    at: [x, z],
+    bilinear: bilinearValue,
+    triangle: triangleValue,
+    difference: triangleValue.height - bilinearValue.height,
+    datum: null,
+    labels: ["unknown-datum"]
+  };
+}
+function profile(state, revision2, query) {
+  const from = bounded(state, query.from, "Profile from");
+  const to = bounded(state, query.to, "Profile to");
+  const horizontalDistance = Math.hypot(to[0] - from[0], to[1] - from[1]);
+  if (horizontalDistance === 0) throw new Error("Profile endpoints are degenerate");
+  const cell = state.size / (state.resolution - 1);
+  const count = query.samples ?? Math.min(MAX_PROFILE_SAMPLES, Math.ceil(horizontalDistance / cell) + 1);
+  if (!Number.isInteger(count) || count < 2 || count > MAX_PROFILE_SAMPLES)
+    throw new Error(`Profile samples must be an integer 2\u2013${MAX_PROFILE_SAMPLES}`);
+  const step = horizontalDistance / (count - 1);
+  const samples = [];
+  let surfaceDistance = 0;
+  for (let index = 0; index < count; index++) {
+    const distance = index * step;
+    const x = from[0] + (to[0] - from[0]) * (distance / horizontalDistance);
+    const z = from[1] + (to[1] - from[1]) * (distance / horizontalDistance);
+    const value = bilinear(state, x, z);
+    const previous = samples[index - 1];
+    if (previous) {
+      const run = Math.hypot(step, value.height - previous.height);
+      surfaceDistance += run;
+      samples[index - 1] = { ...previous, surfaceDistance };
+    }
+    samples.push({ distance, surfaceDistance, height: value.height, slopeDeg: value.slopeDeg });
+  }
+  let maxGradeDeg = 0;
+  for (let index = 1; index < samples.length; index++) {
+    const previous = samples[index - 1];
+    const sample = samples[index];
+    maxGradeDeg = Math.max(
+      maxGradeDeg,
+      Math.atan(Math.abs(sample.height - previous.height) / step) * 180 / Math.PI
+    );
+  }
+  const heights = samples.map((sample) => sample.height);
+  return {
+    kind: "profile",
+    revision: revision2,
+    units: "metres",
+    resolution: state.resolution,
+    from,
+    to,
+    sampleCount: count,
+    horizontalDistance,
+    surfaceDistance,
+    minElevation: Math.min(...heights),
+    maxElevation: Math.max(...heights),
+    maxGradeDeg,
+    samples,
+    datum: null,
+    labels: ["unknown-datum", "bilinear-samples"]
+  };
+}
+function control(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${name} must be a control point object`);
+  const input = value;
+  const extra = Object.keys(input).filter((key) => !["id", "image", "world"].includes(key));
+  if (extra.length) throw new Error(`${name} has unknown fields: ${extra.join(", ")}`);
+  if (typeof input.id !== "string" || !input.id) throw new Error(`${name}.id must be a name`);
+  return {
+    id: input.id,
+    image: point(input.image, `${name}.image`),
+    world: point(input.world, `${name}.world`)
+  };
+}
+function similarity(first, second) {
+  const image = [second.image[0] - first.image[0], second.image[1] - first.image[1]];
+  const world2 = [second.world[0] - first.world[0], second.world[1] - first.world[1]];
+  const imageLength = Math.hypot(...image);
+  const worldLength = Math.hypot(...world2);
+  if (imageLength === 0 || worldLength === 0)
+    throw new Error("Reference controls must be two distinct image and world positions");
+  const scale2 = worldLength / imageLength;
+  const angle = Math.atan2(world2[1], world2[0]) - Math.atan2(image[1], image[0]);
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const offset = first.world;
+  const place = (u) => {
+    const x = scale2 * (cos * u[0] - sin * u[1]);
+    const z = scale2 * (sin * u[0] + cos * u[1]);
+    return [
+      x + offset[0] - scale2 * (cos * first.image[0] - sin * first.image[1]),
+      z + offset[1] - scale2 * (sin * first.image[0] + cos * first.image[1])
+    ];
+  };
+  return { place, scale: scale2, degrees: angle * 180 / Math.PI };
+}
+function validateSpatialReference(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("Reference must be an object");
+  const value = input;
+  const extra = Object.keys(value).filter(
+    (key) => ![
+      "id",
+      "kind",
+      "hash",
+      "source",
+      "datum",
+      "toleranceMetres",
+      "controls",
+      "checkpoint"
+    ].includes(key)
+  );
+  if (extra.length) throw new Error(`Reference has unknown fields: ${extra.join(", ")}`);
+  if (typeof value.id !== "string" || !value.id) throw new Error("Reference.id must be a name");
+  if (value.kind !== "top-down-map" && value.kind !== "screenshot")
+    throw new Error("Reference.kind must be 'top-down-map' or 'screenshot'");
+  if (typeof value.hash !== "string" || !value.hash) throw new Error("Reference.hash must be set");
+  if (typeof value.source !== "string" || !value.source)
+    throw new Error("Reference.source must describe the image");
+  if (!Array.isArray(value.controls) || !value.controls.length || value.controls.length > MAX_CONTROLS)
+    throw new Error(`Reference.controls must hold 1\u2013${MAX_CONTROLS} control points`);
+  const controls = value.controls.map((entry, index) => control(entry, `controls[${index}]`));
+  const checkpoint = value.checkpoint === void 0 || value.checkpoint === null ? null : control(value.checkpoint, "checkpoint");
+  if (checkpoint && controls.some((entry) => entry.id === checkpoint.id))
+    throw new Error("Reference.checkpoint must be independent of the fit controls");
+  const toleranceMetres = value.toleranceMetres === void 0 ? 1 : value.toleranceMetres;
+  if (typeof toleranceMetres !== "number" || !Number.isFinite(toleranceMetres) || toleranceMetres <= 0)
+    throw new Error("Reference.toleranceMetres must be a positive finite number");
+  const datum = typeof value.datum === "string" && value.datum ? value.datum : null;
+  return {
+    id: value.id,
+    kind: value.kind,
+    hash: value.hash,
+    source: value.source,
+    datum,
+    toleranceMetres,
+    controls,
+    checkpoint
+  };
+}
+function reference(revision2, input) {
+  const saved = validateSpatialReference(input);
+  const labels = [];
+  const { controls, checkpoint, toleranceMetres, datum } = saved;
+  if (!datum) labels.push("unknown-datum");
+  const metric = saved.kind === "top-down-map";
+  if (!metric) labels.push("perspective");
+  let transform = null;
+  if (metric && controls.length >= 2)
+    transform = similarity(
+      controls[0],
+      controls[1]
+    );
+  else if (metric) labels.push("insufficient-controls");
+  const landmarks = [
+    ...controls.map((entry) => ({ entry, role: "control" })),
+    ...checkpoint ? [{ entry: checkpoint, role: "checkpoint" }] : []
+  ].map(({ entry, role }) => {
+    const fitted = transform?.place(entry.image) ?? null;
+    return {
+      id: entry.id,
+      role,
+      image: entry.image,
+      world: entry.world,
+      fitted,
+      horizontalResidualMetres: fitted ? Math.hypot(fitted[0] - entry.world[0], fitted[1] - entry.world[1]) : null
+    };
+  });
+  const residuals = landmarks.filter((entry) => entry.role === "control").map((entry) => entry.horizontalResidualMetres);
+  const checkpointEntry = checkpoint ? landmarks.find((entry) => entry.role === "checkpoint") : void 0;
+  const checkpointObservation = checkpointEntry ? {
+    id: checkpointEntry.id,
+    residualMetres: checkpointEntry.horizontalResidualMetres,
+    withinTolerance: checkpointEntry.horizontalResidualMetres <= toleranceMetres
+  } : null;
+  if (!transform) labels.push("unscaled");
+  if (!checkpoint) labels.push("no-checkpoint");
+  const calibrated = Boolean(metric && transform && checkpointObservation?.withinTolerance);
+  if (!calibrated) labels.push("uncalibrated");
+  return {
+    kind: "reference",
+    revision: revision2,
+    units: "metres",
+    id: saved.id,
+    source: saved.source,
+    hash: saved.hash,
+    metric,
+    fit: transform ? {
+      scaleMetresPerPixel: transform.scale,
+      rotationDegrees: transform.degrees,
+      mirrored: false
+    } : null,
+    controlResidualMetres: residuals.length ? Math.max(...residuals) : null,
+    landmarks,
+    checkpoint: checkpointObservation,
+    toleranceMetres,
+    calibrated,
+    datum,
+    labels
+  };
+}
+function inspectSpatial(state, revision2, query) {
+  if (!query || typeof query !== "object" || Array.isArray(query))
+    throw new Error("Inspection query must be an object");
+  switch (query.kind) {
+    case "point":
+      return probeTerrain(state, revision2, query.at);
+    case "profile":
+      return profile(state, revision2, query);
+    case "reference":
+      return reference(revision2, query.reference);
+    default:
+      throw new Error("Unknown inspection query kind");
+  }
+}
+
+// src/editor/server.ts
+var PREFIX = "/terrain-editor/";
+var MAX_BYTES = 64 * 1024 * 1024;
+var MAX_REFERENCES = 16;
+function validate(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected an authoring document");
+  const input = value;
+  if (input.version !== 1 || Object.keys(input).some(
+    (key) => ![
+      "version",
+      "recipe",
+      "placementOverrides",
+      "references",
+      "cameras",
+      "activeCamera",
+      "environment",
+      "assets",
+      "surfaces"
+    ].includes(key)
+  ))
+    throw new Error("Unsupported authoring document fields/version");
+  const recipe = Terrain.fromJSON(input.recipe).toJSON();
+  const document = { version: 1, recipe };
+  if (input.placementOverrides !== void 0)
+    document.placementOverrides = validatePlacementOverrides(input.placementOverrides);
+  if (input.references !== void 0) {
+    if (!Array.isArray(input.references) || input.references.length > MAX_REFERENCES)
+      throw new Error(`A document holds at most ${MAX_REFERENCES} saved references`);
+    document.references = input.references.map((entry) => validateSpatialReference(entry));
+  }
+  if (input.cameras !== void 0) document.cameras = validateCameras(input.cameras);
+  if (input.activeCamera !== void 0) {
+    const active = input.activeCamera;
+    if (active !== null) {
+      if (typeof active !== "string" || !(document.cameras ?? []).some((entry) => entry.id === active))
+        throw new Error("activeCamera must name a saved camera");
+    }
+    document.activeCamera = active;
+  }
+  if (input.assets !== void 0) document.assets = validateAssets(input.assets);
+  if (input.surfaces !== void 0)
+    document.surfaces = validateSurfaces(input.surfaces, document.assets ?? []);
+  if (input.environment !== void 0) {
+    document.environment = validateEnvironment(input.environment);
+    checkEnvironmentAssets(document.environment, document.assets ?? []);
+  }
+  if (Buffer.byteLength(JSON.stringify(document)) > MAX_BYTES)
+    throw new Error("Authoring document exceeds 64 MiB");
+  return document;
+}
+function revision(document) {
+  return createHash("sha256").update(JSON.stringify(document)).digest("hex");
+}
+var EditorError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var TerrainEditorDocument = class {
+  path;
+  #snapshot;
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(path) {
+    if (!isAbsolute(path)) throw new Error("Document path must be absolute");
+    this.path = resolve(path);
+    const document = this.#read();
+    this.#snapshot = { document, revision: revision(document), diagnostic: null };
+  }
+  #read() {
+    const info = lstatSync(this.path);
+    if (!info.isFile() || info.isSymbolicLink() || info.size > MAX_BYTES)
+      throw new Error("Document must be a regular file of at most 64 MiB");
+    return validate(JSON.parse(readFileSync(this.path, "utf8")));
+  }
+  snapshot() {
+    return structuredClone(this.#snapshot);
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  #emit() {
+    for (const listener of this.#listeners) listener(this.snapshot());
+  }
+  refresh() {
+    try {
+      const document = this.#read();
+      const nextRevision = revision(document);
+      if (nextRevision === this.#snapshot.revision && this.#snapshot.diagnostic === null) return;
+      this.#snapshot = { document, revision: nextRevision, diagnostic: null };
+    } catch (error) {
+      this.#snapshot.diagnostic = error instanceof Error ? error.message : String(error);
+    }
+    this.#emit();
+  }
+  commit(input) {
+    this.refresh();
+    if (this.#snapshot.diagnostic)
+      throw new EditorError(409, "Disk document is invalid; restore a valid save before editing");
+    if (!input || typeof input !== "object" || Array.isArray(input))
+      throw new Error("Expected a transaction");
+    const request = input;
+    if (Object.keys(request).some((key) => !["baseRevision", "commands", "document"].includes(key)))
+      throw new Error("Unknown transaction fields");
+    if (request.baseRevision !== this.#snapshot.revision)
+      throw new EditorError(409, "Stale base revision");
+    if (request.commands === void 0 === (request.document === void 0))
+      throw new Error("Supply commands or document, exclusively");
+    let next;
+    if (request.commands !== void 0) {
+      if (!Array.isArray(request.commands) || !request.commands.length || request.commands.length > 512)
+        throw new Error("Expected 1\u2013512 patch commands");
+      const terrain = Terrain.fromJSON(this.#snapshot.document.recipe);
+      terrain.applyPatch(request.commands);
+      next = validate({ ...this.#snapshot.document, recipe: terrain.toJSON() });
+    } else next = validate(request.document);
+    const nextRevision = revision(next);
+    if (nextRevision === this.#snapshot.revision) return this.snapshot();
+    const temporary = `${this.path}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temporary, `${JSON.stringify(next, null, 2)}
+`, { flag: "wx", mode: 384 });
+      renameSync(temporary, this.path);
+    } catch (error) {
+      try {
+        unlinkSync(temporary);
+      } catch (cleanupError) {
+        if (cleanupError.code !== "ENOENT")
+          throw new AggregateError(
+            [error, cleanupError],
+            "Document save and temporary-file cleanup failed"
+          );
+      }
+      throw error;
+    }
+    this.#snapshot = { document: next, revision: nextRevision, diagnostic: null };
+    this.#emit();
+    return this.snapshot();
+  }
+};
+async function body(request) {
+  if (request.headers["content-type"]?.split(";")[0] !== "application/json")
+    throw new EditorError(415, "Expected application/json");
+  if (Number(request.headers["content-length"]) > MAX_BYTES)
+    throw new EditorError(413, "Request exceeds 64 MiB");
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > MAX_BYTES) throw new EditorError(413, "Request exceeds 64 MiB");
+    chunks.push(buffer);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function json(response, status, value) {
+  response.writeHead(status, {
+    "content-type": "application/json",
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff"
+  });
+  response.end(JSON.stringify(value));
+}
+function terrainEditor(options) {
+  const viewer = options.viewerUrl ? new URL(options.viewerUrl) : void 0;
+  if (viewer && (!["http:", "https:"].includes(viewer.protocol) || viewer.username || viewer.password || viewer.search || viewer.hash || !viewer.pathname.endsWith(PREFIX)))
+    throw new Error("Viewer URL must be an explicit HTTP(S) forwarded terrain-editor URL");
+  const document = new TerrainEditorDocument(options.documentPath);
+  const evaluator = new TerrainEvaluator();
+  const store = new AssetStore(
+    options.assetsDir ?? resolve(dirname(document.path), "assets"),
+    options.assetLimits
+  );
+  const projectId = createHash("sha256").update(document.path).digest("hex");
+  const sessionId = randomUUID();
+  let origin;
+  let url;
+  const clients = /* @__PURE__ */ new Set();
+  const unsubscribe = document.subscribe((snapshot) => {
+    for (const response of clients)
+      if (!response.write(`data: ${JSON.stringify(snapshot)}
+
+`)) response.end();
+  });
+  const activation = () => {
+    if (!origin || !url) throw new EditorError(503, "Editor server is not listening");
+    return { editorUrl: url, projectId, sessionId, revision: document.snapshot().revision };
+  };
+  const activate = async () => {
+    const value = activation();
+    let response;
+    try {
+      response = await fetch(value.editorUrl, { signal: AbortSignal.timeout(5e3) });
+    } catch (error) {
+      throw new EditorError(
+        503,
+        `Editor URL is unreachable: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (!response.ok || !(await response.text()).includes("terrain-editor"))
+      throw new EditorError(503, "Project terrain editor route is not ready");
+    return value;
+  };
+  return {
+    name: "threenative-terrain-editor",
+    activate,
+    config: () => viewer ? { server: { allowedHosts: [viewer.hostname] } } : {},
+    configureServer(vite) {
+      if (vite.config.server.host && !["127.0.0.1", "localhost", "::1"].includes(String(vite.config.server.host)))
+        throw new Error("Terrain editor writes require a loopback bind");
+      const http = vite.httpServer;
+      if (!http) throw new Error("Terrain editor requires a listening loopback HTTP server");
+      http.once("listening", () => {
+        const address = http.address();
+        if (!address || typeof address === "string" || !["127.0.0.1", "::1"].includes(address.address))
+          throw new Error("Terrain editor writes require a loopback bind");
+        origin = `http://${address.address === "::1" ? "[::1]" : address.address}:${address.port}`;
+        url = viewer?.href ?? new URL(PREFIX, origin).href;
+        console.log(`Terrain editor: ${url}`);
+      });
+      vite.watcher.add(document.path);
+      const refresh = (path) => {
+        if (resolve(path) === document.path) document.refresh();
+      };
+      const refreshRaw = (_event, path, details) => {
+        if (typeof path !== "string") return;
+        const watchedPath = details?.watchedPath;
+        if (isAbsolute(path) && resolve(path) === document.path || typeof watchedPath === "string" && (resolve(watchedPath) === document.path || resolve(watchedPath, path) === document.path))
+          refresh(document.path);
+      };
+      vite.watcher.on("add", refresh).on("change", refresh).on("unlink", refresh).on("raw", refreshRaw);
+      const heartbeat = setInterval(() => {
+        for (const response of clients) if (!response.write(": keepalive\n\n")) response.end();
+      }, 15e3);
+      heartbeat.unref();
+      http.once("close", () => {
+        clearInterval(heartbeat);
+        unsubscribe();
+        for (const response of clients) response.end();
+        vite.watcher.off("add", refresh).off("change", refresh).off("unlink", refresh).off("raw", refreshRaw);
+      });
+      vite.middlewares.use((request, response, next) => {
+        const path = request.url?.split("?")[0];
+        if (!path?.startsWith(`${PREFIX}api/`)) return next();
+        void (async () => {
+          try {
+            if (!origin) throw new EditorError(503, "Server is not ready");
+            const remote = request.socket.remoteAddress;
+            if (!["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(remote ?? ""))
+              throw new EditorError(403, "Loopback clients only");
+            const requestUrl = new URL(`http://${request.headers.host}`);
+            const local = new URL(origin);
+            const localhost = new URL(origin.replace("127.0.0.1", "localhost"));
+            const hosts = [local.host, localhost.host, ...viewer ? [viewer.host] : []];
+            const origins = [local.origin, localhost.origin, ...viewer ? [viewer.origin] : []];
+            if (!hosts.includes(requestUrl.host)) throw new EditorError(403, "Untrusted host");
+            if (request.headers.origin && !origins.includes(request.headers.origin))
+              throw new EditorError(403, "Untrusted origin");
+            if (request.method === "GET" && path === `${PREFIX}api/activate`) {
+              json(response, 200, await activate());
+              return;
+            }
+            if (request.method === "GET" && path === `${PREFIX}api/document`) {
+              json(response, 200, document.snapshot());
+              return;
+            }
+            if (request.method === "GET" && path === `${PREFIX}api/events`) {
+              response.writeHead(200, {
+                "content-type": "text/event-stream",
+                "cache-control": "no-store",
+                connection: "keep-alive"
+              });
+              clients.add(response);
+              response.on("close", () => clients.delete(response));
+              response.write(`data: ${JSON.stringify(document.snapshot())}
+
+`);
+              return;
+            }
+            if (request.method === "POST" && path === `${PREFIX}api/document`) {
+              json(response, 200, document.commit(await body(request)));
+              return;
+            }
+            if (request.method === "POST" && path === `${PREFIX}api/cameras`) {
+              const transaction = await body(request);
+              if (!transaction || typeof transaction !== "object" || Array.isArray(transaction) || Object.keys(transaction).some((key) => !["baseRevision", "operation"].includes(key)))
+                throw new Error("Expected { baseRevision, operation }");
+              const cameras = transaction;
+              const current = document.snapshot();
+              if (cameras.baseRevision !== current.revision)
+                throw new EditorError(409, "Stale base revision");
+              const result = runCameraOperation(
+                {
+                  cameras: current.document.cameras ?? [],
+                  activeCamera: current.document.activeCamera ?? null
+                },
+                cameras.operation
+              );
+              const next2 = validate({
+                ...current.document,
+                cameras: result.cameras,
+                activeCamera: result.activeCamera
+              });
+              const changed = JSON.stringify(result.cameras) !== JSON.stringify(current.document.cameras ?? []) || result.activeCamera !== (current.document.activeCamera ?? null);
+              const revision2 = changed ? document.commit({ baseRevision: current.revision, document: next2 }).revision : current.revision;
+              json(response, 200, { ...result, revision: revision2 });
+              return;
+            }
+            if (request.method === "GET" && path.startsWith(`${PREFIX}api/assets/`)) {
+              const name = decodeURIComponent(path.slice(`${PREFIX}api/assets/`.length));
+              const entry = (document.snapshot().document.assets ?? []).find(
+                (asset) => asset.path === name
+              );
+              if (!entry) throw new EditorError(404, `No registered asset file '${name}'`);
+              const bytes = store.read(entry.path);
+              response.writeHead(200, {
+                "content-type": "application/octet-stream",
+                // The file name carries its hash, so a replacement is a different URL.
+                "cache-control": "public, max-age=31536000, immutable",
+                "x-content-type-options": "nosniff"
+              });
+              response.end(bytes);
+              return;
+            }
+            if (request.method === "POST" && path === `${PREFIX}api/assets`) {
+              const transaction = await body(request);
+              if (!transaction || typeof transaction !== "object" || Array.isArray(transaction) || Object.keys(transaction).some((key) => !["baseRevision", "operation"].includes(key)))
+                throw new Error("Expected { baseRevision, operation }");
+              const asset = transaction;
+              const current = document.snapshot();
+              if (asset.baseRevision !== current.revision)
+                throw new EditorError(409, "Stale base revision");
+              const operation = asset.operation;
+              if (!operation || typeof operation !== "object" || typeof operation.op !== "string")
+                throw new Error("Expected an asset operation");
+              const assets = current.document.assets ?? [];
+              let next2 = assets;
+              const surfaces = current.document.surfaces ?? {};
+              let nextSurfaces = surfaces;
+              let touched = null;
+              if (operation.op === "register" || operation.op === "upload") {
+                if (operation.op === "register" && request.headers.origin)
+                  throw new EditorError(
+                    403,
+                    "Registering a local path is for the local agent, not a page"
+                  );
+                const bytes = operation.op === "register" ? store.readSource(operation.path) : Buffer.from(String(operation.data), "base64");
+                const name = operation.op === "register" ? basename(operation.path) : String(operation.name ?? operation.id);
+                const stored = store.store(operation.id, name, bytes, operation);
+                const existing = assets.find((entry) => entry.id === stored.id);
+                if (existing && existing.sha256 !== stored.sha256 && operation.replace !== true)
+                  throw new EditorError(
+                    409,
+                    `Asset '${stored.id}' already exists; pass replace: true or choose a new id`
+                  );
+                if (existing?.sha256 === stored.sha256) touched = existing;
+                else {
+                  touched = existing ? { ...stored, adjust: existing.adjust ?? stored.adjust } : stored;
+                  next2 = [...assets.filter((entry) => entry.id !== stored.id), touched];
+                }
+              } else if (operation.op === "adjust") {
+                const existing = assets.find((entry) => entry.id === operation.id);
+                if (!existing || existing.kind !== "model")
+                  throw new EditorError(404, `No registered model '${operation.id}'`);
+                touched = validateAsset({ ...existing, adjust: operation.adjust });
+                next2 = assets.map(
+                  (entry) => entry.id === touched?.id ? touched : entry
+                );
+              } else if (operation.op === "remove") {
+                touched = assets.find((entry) => entry.id === operation.id) ?? null;
+                if (!touched) throw new EditorError(404, `No registered asset '${operation.id}'`);
+                const used = Object.entries(surfaces).filter(
+                  ([, mapping]) => mapping.asset === operation.id
+                );
+                if (used.length)
+                  throw new EditorError(
+                    409,
+                    `Asset '${operation.id}' is mapped to ${used.map(([input]) => input).join(", ")}; unmap it first`
+                  );
+                const env = current.document.environment;
+                const drawn = [
+                  env?.sky?.image === operation.id ? "environment.sky.image" : "",
+                  env?.lighting?.image === operation.id ? "environment.lighting.image" : ""
+                ].filter(Boolean);
+                if (drawn.length)
+                  throw new EditorError(
+                    409,
+                    `Asset '${operation.id}' is used by ${drawn.join(", ")}; clear it first`
+                  );
+                next2 = assets.filter((entry) => entry.id !== operation.id);
+              } else if (operation.op === "map") {
+                surfaceSpace(operation.input);
+                touched = assets.find((entry) => entry.id === operation.asset) ?? null;
+                if (!touched || touched.kind !== "image")
+                  throw new EditorError(404, `No registered image '${operation.asset}'`);
+                nextSurfaces = { ...surfaces, [operation.input]: { asset: touched.id } };
+              } else if (operation.op === "unmap") {
+                if (!surfaces[operation.input])
+                  throw new EditorError(404, `Surface input '${operation.input}' has no mapping`);
+                nextSurfaces = Object.fromEntries(
+                  Object.entries(surfaces).filter(([input]) => input !== operation.input)
+                );
+              } else if (operation.op !== "list") throw new Error("Unknown asset operation");
+              const changed = JSON.stringify(next2) !== JSON.stringify(assets) || JSON.stringify(nextSurfaces) !== JSON.stringify(surfaces);
+              const revision2 = changed ? document.commit({
+                baseRevision: current.revision,
+                document: JSON.parse(
+                  JSON.stringify({
+                    ...current.document,
+                    assets: next2,
+                    surfaces: Object.keys(nextSurfaces).length ? nextSurfaces : void 0
+                  })
+                )
+              }).revision : current.revision;
+              const result = {
+                op: operation.op,
+                assets: next2,
+                surfaces: nextSurfaces,
+                asset: touched
+              };
+              json(response, 200, { ...result, revision: revision2 });
+              return;
+            }
+            if (request.method === "POST" && path === `${PREFIX}api/environment`) {
+              const transaction = await body(request);
+              if (!transaction || typeof transaction !== "object" || Array.isArray(transaction) || Object.keys(transaction).some((key) => !["baseRevision", "operation"].includes(key)))
+                throw new Error("Expected { baseRevision, operation }");
+              const environment = transaction;
+              const current = document.snapshot();
+              if (environment.baseRevision !== current.revision)
+                throw new EditorError(409, "Stale base revision");
+              const result = runEnvironmentOperation(
+                current.document.environment ?? {},
+                environment.operation
+              );
+              const changed = JSON.stringify(result.environment) !== JSON.stringify(current.document.environment ?? {});
+              const next2 = { ...current.document };
+              if (Object.keys(result.environment).length) next2.environment = result.environment;
+              else next2.environment = void 0;
+              const revision2 = changed ? document.commit({
+                baseRevision: current.revision,
+                document: JSON.parse(JSON.stringify(next2))
+              }).revision : current.revision;
+              json(response, 200, { ...result, revision: revision2 });
+              return;
+            }
+            if (request.method === "POST" && path === `${PREFIX}api/inspect`) {
+              const transaction = await body(request);
+              if (!transaction || typeof transaction !== "object" || Array.isArray(transaction) || Object.keys(transaction).some((key) => !["baseRevision", "query"].includes(key)))
+                throw new Error("Expected { baseRevision, query }");
+              const snapshot = document.snapshot();
+              const inspection = transaction;
+              if (inspection.baseRevision !== snapshot.revision)
+                throw new EditorError(409, "Stale base revision");
+              const state = evaluator.evaluate(snapshot.document.recipe);
+              const result = inspectSpatial(
+                state,
+                snapshot.revision,
+                inspection.query
+              );
+              json(response, 200, { result });
+              return;
+            }
+            throw new EditorError(405, "Unsupported terrain editor route/method");
+          } catch (error) {
+            json(response, error instanceof EditorError ? error.status : 400, {
+              error: error instanceof Error ? error.message : String(error),
+              snapshot: document.snapshot()
+            });
+          }
+        })();
+      });
+    }
+  };
+}
+
+export { TerrainEditorDocument, terrainEditor };