@threenative/terrain 0.0.0-stage → 0.1.1

package/dist/editor/worker.js

@@ -0,0 +1,2212 @@
+// 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 = (text) => {
+  let h = 2166136261;
+  for (const c of text) 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/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/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 field = s.biomes[mask.name];
+      return (i) => field?.[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/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((point) => !Number.isFinite(point[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 profile = bed.slice();
+  for (let pass = 0; pass < 2; pass += 1) {
+    const next = profile.slice();
+    for (let k = 0; k < profile.length; k += 1) {
+      let sum = 0;
+      let count = 0;
+      for (let j = Math.max(0, k - window); j <= Math.min(profile.length - 1, k + window); j += 1) {
+        sum += profile[j];
+        count += 1;
+      }
+      next[k] = sum / count;
+    }
+    for (let k = 0; k < profile.length; k += 1) profile[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 < profile.length; k += 1) {
+      const y = clamp(
+        profile[k],
+        profile[k - 1] - limit(k),
+        profile[k - 1] + limit(k)
+      );
+      moved += Math.abs(y - profile[k]);
+      profile[k] = y;
+    }
+    for (let k = profile.length - 2; k >= 0; k -= 1) {
+      const y = clamp(
+        profile[k],
+        profile[k + 1] - limit(k + 1),
+        profile[k + 1] + limit(k + 1)
+      );
+      moved += Math.abs(y - profile[k]);
+      profile[k] = y;
+    }
+    if (moved < 1e-4) break;
+  }
+  for (let k = 0; k < profile.length; k += 1)
+    profile[k] = clamp(
+      profile[k],
+      bed[k] - maxCut,
+      bed[k] + maxFill
+    );
+  for (let k = 0; k < points.length; k += 1) at(k)[1] = profile[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 scale = 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 / (scale * 1.7) + 17, wz / (scale * 1.7) - 19, seed + 29) * warp;
+          const oz = noise2(wx / (scale * 1.7) - 27, wz / (scale * 1.7) + 12, seed + 31) * warp;
+          let value = (p.base ?? 0) + fbm((wx + ox) / scale, (wz + oz) / scale, {
+            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 profile;
+          let w = 1;
+          if (p.data) {
+            if (Math.abs(u) > 1 || Math.abs(v) > 1) continue;
+            const source = p.data;
+            profile = 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")
+              profile = (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")
+              profile = Math.max(0, 1 - Math.abs(v)) ** 1.7 * (1 - smoothstep(0.35, 1, Math.abs(u))) * rough;
+            else if (shape === "mesa") profile = (1 - smoothstep(0.5, 1, d)) * rough;
+            else if (shape === "valley") profile = -(1 - smoothstep(0, 1, d)) * rough;
+            else if (shape === "dune") profile = Math.max(0, 1 - d) ** 1.2 * (1 + 0.25 * u) * rough;
+            else profile = Math.max(0, 1 - d) ** 1.65 * rough;
+            profile *= ("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 = profile * (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 scale = 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(scale) ? lerp(scale[0], scale[1], scaleRandom) : scale;
+      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 point of points)
+      if (isSpline) splinePoint(point, "point", follows);
+      else vec(point, "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 scale = params.scale;
+    if (layer.type === "scatter") {
+      if (Array.isArray(scale)) {
+        vec(scale, "scale", 2);
+        if (scale[0] > scale[1]) fail("scale range is inverted");
+        for (const entry of scale) num(entry, "scale", 1e-3, 1e4);
+      } else num(scale, "scale", 1e-3, 1e4);
+    } else num(scale, "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/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);
+  }
+};
+
+// src/core/bake.ts
+var toLinear = (color) => color <= 0.04045 ? color / 12.92 : ((color + 0.055) / 1.055) ** 2.4;
+function bakeMesh(state, {
+  step = 1,
+  x = 0,
+  z = 0,
+  cells = state.resolution - 1,
+  skirtDepth = 0,
+  palette
+} = {}) {
+  if (!Number.isFinite(skirtDepth) || skirtDepth < 0)
+    throw new RangeError("skirtDepth must be finite and nonnegative");
+  const n = state.resolution;
+  if (!Number.isInteger(n) || n < 2 || !Number.isFinite(state.size) || state.size <= 0)
+    throw new RangeError("Invalid heightfield extent");
+  if (!Number.isInteger(step) || step < 1 || (step & step - 1) !== 0 || cells % step !== 0)
+    throw new RangeError("step must be a power of two dividing chunk cells");
+  if (![x, z, cells].every(Number.isInteger) || x < 0 || z < 0 || cells < 1 || x + cells >= n || z + cells >= n)
+    throw new RangeError("Chunk outside heightfield");
+  if (state.height.length !== n * n || !state.height.every(Number.isFinite))
+    throw new RangeError("Invalid heightfield samples");
+  if (palette && (palette.length !== 8 || Array.from(palette).some(
+    (rgb) => !Array.isArray(rgb) || rgb.length !== 3 || Array.from(rgb).some((value) => !Number.isFinite(value) || value < 0 || value > 1)
+  )))
+    throw new RangeError("palette requires eight finite sRGB triples in 0..1");
+  if (palette && (state.splat.length !== n * n * 8 || !state.splat.every(Number.isFinite)))
+    throw new RangeError("Invalid splat samples");
+  const side = cells / step + 1;
+  const base = side * side;
+  const ring = [];
+  if (skirtDepth > 0) {
+    for (let k2 = 0; k2 < side - 1; k2++) ring.push(k2);
+    for (let k2 = 0; k2 < side - 1; k2++) ring.push(k2 * side + side - 1);
+    for (let k2 = side - 1; k2 > 0; k2--) ring.push((side - 1) * side + k2);
+    for (let k2 = side - 1; k2 > 0; k2--) ring.push(k2 * side);
+  }
+  const count = base + ring.length;
+  const positions = new Float32Array(count * 3);
+  const normals = new Float32Array(count * 3);
+  const uvs = new Float32Array(count * 2);
+  const indices = new Uint32Array((side - 1) ** 2 * 6 + ring.length * 6);
+  const colors = palette ? new Float32Array(count * 3) : void 0;
+  const cell = state.size / (n - 1);
+  for (let zz = 0; zz < side; zz++)
+    for (let xx = 0; xx < side; xx++) {
+      const gx = x + xx * step;
+      const gz = z + zz * step;
+      const i = gz * n + gx;
+      const j = zz * side + xx;
+      const dx = (state.height[gz * n + Math.min(n - 1, gx + 1)] - state.height[gz * n + Math.max(0, gx - 1)]) / ((gx > 0 && gx < n - 1 ? 2 : 1) * cell);
+      const dz = (state.height[Math.min(n - 1, gz + 1) * n + gx] - state.height[Math.max(0, gz - 1) * n + gx]) / ((gz > 0 && gz < n - 1 ? 2 : 1) * cell);
+      const length = Math.hypot(dx, 1, dz);
+      positions.set([world(state, gx), state.height[i], world(state, gz)], j * 3);
+      normals.set([-dx / length, 1 / length, -dz / length], j * 3);
+      if (colors && palette)
+        for (let k2 = 0; k2 < 3; k2++) {
+          let color = 0;
+          for (let c = 0; c < 8; c++)
+            color += toLinear(palette[c]?.[k2]) * state.splat[i * 8 + c];
+          colors[j * 3 + k2] = color;
+        }
+      uvs.set([gx / (n - 1), 1 - gz / (n - 1)], j * 2);
+    }
+  let k = 0;
+  for (let zz = 0; zz < side - 1; zz++)
+    for (let xx = 0; xx < side - 1; xx++) {
+      const a = zz * side + xx;
+      const b = a + 1;
+      const c = a + side;
+      const d = c + 1;
+      indices.set([a, c, b, b, c, d], k);
+      k += 6;
+    }
+  for (let j = 0; j < ring.length; j++) {
+    const top = ring[j];
+    const bottom = base + j;
+    positions.set(positions.subarray(top * 3, top * 3 + 3), bottom * 3);
+    positions[bottom * 3 + 1] = positions[bottom * 3 + 1] - skirtDepth;
+    normals.set(normals.subarray(top * 3, top * 3 + 3), bottom * 3);
+    colors?.set(colors.subarray(top * 3, top * 3 + 3), bottom * 3);
+    uvs.set(uvs.subarray(top * 2, top * 2 + 2), bottom * 2);
+    const next = (j + 1) % ring.length;
+    indices.set([top, ring[next], bottom, ring[next], base + next, bottom], k);
+    k += 6;
+  }
+  return {
+    name: `terrain_${x}_${z}_step${step}`,
+    positions,
+    normals,
+    colors,
+    uvs,
+    indices,
+    side,
+    topVertexCount: base,
+    bounds: { x, z, cells, step },
+    skirtDepth
+  };
+}
+function bakeTerrain(state, {
+  chunkCells = Math.min(64, state.resolution - 1),
+  lodSteps = [1, 2, 4],
+  skirtDepth = 6,
+  palette
+} = {}) {
+  if (!Number.isInteger(chunkCells) || chunkCells < 1 || (state.resolution - 1) % chunkCells !== 0)
+    throw new RangeError("chunkCells must divide resolution - 1");
+  if (!lodSteps.length) throw new RangeError("lodSteps must not be empty");
+  const lods = lodSteps.map((step) => {
+    const chunks = [];
+    for (let z = 0; z < state.resolution - 1; z += chunkCells)
+      for (let x = 0; x < state.resolution - 1; x += chunkCells)
+        chunks.push(bakeMesh(state, { x, z, cells: chunkCells, step, skirtDepth, palette }));
+    return { step, chunks };
+  });
+  return {
+    version: 1,
+    size: state.size,
+    resolution: state.resolution,
+    lods,
+    collision: {
+      type: "heightfield",
+      size: state.size,
+      resolution: state.resolution,
+      cellSize: state.size / (state.resolution - 1),
+      origin: [-state.size / 2, 0, -state.size / 2],
+      heights: state.height.slice()
+    },
+    instances: structuredClone(state.instances),
+    materialChannels: [...MATERIAL_IDS]
+  };
+}
+function validateBakedMesh(mesh) {
+  if (![mesh.positions, mesh.normals, mesh.uvs, ...mesh.colors ? [mesh.colors] : []].every(
+    (array) => array instanceof Float32Array
+  ) || !(mesh.indices instanceof Uint32Array))
+    throw new TypeError("Baked mesh requires Float32 attributes and Uint32 indices");
+  const count = mesh.positions.length / 3;
+  if (!count || !Number.isInteger(count) || mesh.normals.length !== count * 3 || mesh.uvs.length !== count * 2 || mesh.colors && mesh.colors.length !== count * 3 || !mesh.indices.length || mesh.indices.length % 3)
+    throw new RangeError("Baked mesh attribute counts do not agree");
+  for (const array of [
+    mesh.positions,
+    mesh.normals,
+    mesh.uvs,
+    ...mesh.colors ? [mesh.colors] : []
+  ])
+    if (!array.every(Number.isFinite)) throw new RangeError("Baked mesh attributes must be finite");
+  if (mesh.indices.some((index) => index >= count))
+    throw new RangeError("Baked mesh index outside vertex range");
+}
+
+// src/core/io.ts
+var encoder = new TextEncoder();
+new TextDecoder();
+var crcTable = Uint32Array.from({ length: 256 }, (_, initial) => {
+  let n = initial;
+  for (let k = 0; k < 8; k++) n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+  return n >>> 0;
+});
+var crc32 = (bytes) => {
+  let c = 4294967295;
+  for (const b of bytes) c = crcTable[(c ^ b) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+};
+var join = (arrays) => {
+  const out = new Uint8Array(arrays.reduce((n, a) => n + a.length, 0));
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+};
+function heightRange(values, { min, max } = {}) {
+  for (const v of values) if (!Number.isFinite(v)) throw TypeError("Height data must be finite");
+  if (min === void 0 || max === void 0) {
+    let lo = Number.POSITIVE_INFINITY;
+    let hi = Number.NEGATIVE_INFINITY;
+    for (const v of values) {
+      if (!Number.isFinite(v)) throw TypeError("Height data must be finite");
+      lo = Math.min(lo, v);
+      hi = Math.max(hi, v);
+    }
+    min ??= lo;
+    max ??= hi > lo ? hi : lo + 1;
+  }
+  if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min)
+    throw RangeError("Height range must be finite and max > min");
+  return { min, max };
+}
+function encodeRAW16(values, options = {}) {
+  const { min, max } = heightRange(values, options);
+  const bytes = new Uint8Array(values.length * 2);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < values.length; i++)
+    view.setUint16(
+      i * 2,
+      Math.round(clamp((values[i] - min) / (max - min)) * 65535),
+      options.littleEndian !== false
+    );
+  return bytes;
+}
+function chunk(type, content) {
+  const bytes = new Uint8Array(content.length + 12);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, content.length);
+  bytes.set(encoder.encode(type), 4);
+  bytes.set(content, 8);
+  view.setUint32(bytes.length - 4, crc32(bytes.subarray(4, bytes.length - 4)));
+  return bytes;
+}
+async function compress(bytes) {
+  if (typeof CompressionStream === "undefined")
+    throw Error("PNG export requires CompressionStream (modern browser or Node 22+)");
+  return new Uint8Array(
+    await new Response(
+      new Blob([new Uint8Array(bytes)]).stream().pipeThrough(new CompressionStream("deflate"))
+    ).arrayBuffer()
+  );
+}
+async function encodePNG(width, height, bytes, bitDepth, colorType, metadata) {
+  const channels = colorType === 6 ? 4 : 1;
+  const rowBytes = width * channels * (bitDepth / 8);
+  if (bytes.length !== rowBytes * height) throw RangeError("PNG pixel byte count mismatch");
+  const raw = new Uint8Array((rowBytes + 1) * height);
+  for (let y = 0; y < height; y++)
+    raw.set(bytes.subarray(y * rowBytes, (y + 1) * rowBytes), y * (rowBytes + 1) + 1);
+  const ihdr = new Uint8Array(13);
+  const v = new DataView(ihdr.buffer);
+  v.setUint32(0, width);
+  v.setUint32(4, height);
+  ihdr[8] = bitDepth;
+  ihdr[9] = colorType;
+  const parts = [new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), chunk("IHDR", ihdr)];
+  if (metadata)
+    parts.push(chunk("tEXt", encoder.encode(`StrataHeightRange\0${JSON.stringify(metadata)}`)));
+  parts.push(chunk("IDAT", await compress(raw)), chunk("IEND", new Uint8Array()));
+  return join(parts);
+}
+async function encodeHeightPNG(state, options = {}) {
+  const values = state.height;
+  const range2 = heightRange(values, options);
+  const bytes = encodeRAW16(values, { ...range2, littleEndian: false });
+  return encodePNG(state.resolution, state.resolution, bytes, 16, 0, range2);
+}
+async function encodeSplatPNGs(state) {
+  const maps = [];
+  for (let pack = 0; pack < 2; pack++) {
+    const bytes = new Uint8Array(state.height.length * 4);
+    for (let i = 0; i < state.height.length; i++)
+      for (let c = 0; c < 4; c++)
+        bytes[i * 4 + c] = Math.round(clamp(state.splat[i * 8 + pack * 4 + c]) * 255);
+    maps.push({
+      channels: MATERIAL_IDS.slice(pack * 4, pack * 4 + 4),
+      bytes: await encodePNG(state.resolution, state.resolution, bytes, 8, 6)
+    });
+  }
+  return maps;
+}
+function encodeGLB(input) {
+  const meshes = Array.isArray(input) ? input : [input];
+  if (!meshes.length) throw new RangeError("GLB requires at least one baked mesh");
+  for (const mesh of meshes) validateBakedMesh(mesh);
+  const chunks = [];
+  const bufferViews = [];
+  const accessors = [];
+  const gltfMeshes = [];
+  let offset = 0;
+  const add = (array, type, componentType, target, minMax = false) => {
+    const aligned = offset + 3 & -4;
+    if (aligned > offset) {
+      chunks.push(new Uint8Array(aligned - offset));
+      offset = aligned;
+    }
+    const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength).slice();
+    const view = bufferViews.length;
+    bufferViews.push({ buffer: 0, byteOffset: offset, byteLength: bytes.length, target });
+    chunks.push(bytes);
+    offset += bytes.length;
+    const size = type === "VEC3" ? 3 : type === "VEC2" ? 2 : 1;
+    const accessor = {
+      bufferView: view,
+      componentType,
+      count: array.length / size,
+      type
+    };
+    if (minMax) {
+      accessor.min = Array(size).fill(Number.POSITIVE_INFINITY);
+      accessor.max = Array(size).fill(Number.NEGATIVE_INFINITY);
+      for (let i = 0; i < array.length; i++) {
+        const c = i % size;
+        accessor.min[c] = Math.min(accessor.min[c], array[i]);
+        accessor.max[c] = Math.max(accessor.max[c], array[i]);
+      }
+    }
+    accessors.push(accessor);
+    return accessors.length - 1;
+  };
+  for (const m of meshes) {
+    const attributes = {
+      POSITION: add(m.positions, "VEC3", 5126, 34962, true),
+      NORMAL: add(m.normals, "VEC3", 5126, 34962),
+      TEXCOORD_0: add(m.uvs, "VEC2", 5126, 34962)
+    };
+    if (m.colors) attributes.COLOR_0 = add(m.colors, "VEC3", 5126, 34962);
+    gltfMeshes.push({
+      name: m.name ?? "Terrain",
+      primitives: [{ attributes, indices: add(m.indices, "SCALAR", 5125, 34963), mode: 4 }]
+    });
+  }
+  const binary = join(chunks);
+  const doc = {
+    asset: { version: "2.0", generator: "Strata Terrain 0.1.0" },
+    scene: 0,
+    scenes: [{ nodes: meshes.map((_, i) => i) }],
+    nodes: meshes.map((m, i) => ({ mesh: i, name: m.name ?? `Terrain ${i}` })),
+    meshes: gltfMeshes,
+    buffers: [{ byteLength: binary.length }],
+    bufferViews,
+    accessors
+  };
+  const json2 = encoder.encode(JSON.stringify(doc));
+  const jsonLength = json2.length + 3 & -4;
+  const binLength = binary.length + 3 & -4;
+  const out = new Uint8Array(12 + 8 + jsonLength + 8 + binLength);
+  const v = new DataView(out.buffer);
+  v.setUint32(0, 1179937895, true);
+  v.setUint32(4, 2, true);
+  v.setUint32(8, out.length, true);
+  v.setUint32(12, jsonLength, true);
+  v.setUint32(16, 1313821514, true);
+  out.fill(32, 20, 20 + jsonLength);
+  out.set(json2, 20);
+  const start = 20 + jsonLength;
+  v.setUint32(start, binLength, true);
+  v.setUint32(start + 4, 5130562, true);
+  out.set(binary, start + 8);
+  return out;
+}
+
+// src/core/export.ts
+var enc = new TextEncoder();
+var table = Uint32Array.from({ length: 256 }, (_, initial) => {
+  let n = initial;
+  for (let k = 0; k < 8; k++) n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+  return n >>> 0;
+});
+function crc322(b) {
+  let c = 4294967295;
+  for (const v of b) c = table[(c ^ v) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function concat(parts) {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+function encodeZIP(files) {
+  if (files.length > 65535) throw RangeError("Too many ZIP entries");
+  const parts = [];
+  const central = [];
+  const names = /* @__PURE__ */ new Set();
+  let offset = 0;
+  for (const { name, bytes } of files) {
+    if (!/^[a-zA-Z0-9_.\/-]+$/.test(name) || name.startsWith("/") || name.split("/").includes("..") || names.has(name))
+      throw Error("Unsafe or duplicate ZIP filename");
+    if (!(bytes instanceof Uint8Array)) throw TypeError("ZIP bytes must be Uint8Array");
+    names.add(name);
+    const nb = enc.encode(name);
+    const crc = crc322(bytes);
+    const h = new Uint8Array(30 + nb.length);
+    const v = new DataView(h.buffer);
+    v.setUint32(0, 67324752, true);
+    v.setUint16(4, 20, true);
+    v.setUint16(12, 33, true);
+    v.setUint32(14, crc, true);
+    v.setUint32(18, bytes.length, true);
+    v.setUint32(22, bytes.length, true);
+    v.setUint16(26, nb.length, true);
+    h.set(nb, 30);
+    parts.push(h, bytes);
+    const c = new Uint8Array(46 + nb.length);
+    const cv = new DataView(c.buffer);
+    cv.setUint32(0, 33639248, true);
+    cv.setUint16(4, 20, true);
+    cv.setUint16(6, 20, true);
+    cv.setUint16(14, 33, true);
+    cv.setUint32(16, crc, true);
+    cv.setUint32(20, bytes.length, true);
+    cv.setUint32(24, bytes.length, true);
+    cv.setUint16(28, nb.length, true);
+    cv.setUint32(42, offset, true);
+    c.set(nb, 46);
+    central.push(c);
+    offset += h.length + bytes.length;
+    if (offset > 4294967295) throw RangeError("ZIP64 is not supported");
+  }
+  const directory = concat(central);
+  const end = new Uint8Array(22);
+  const e = new DataView(end.buffer);
+  e.setUint32(0, 101010256, true);
+  e.setUint16(8, files.length, true);
+  e.setUint16(10, files.length, true);
+  e.setUint32(12, directory.length, true);
+  e.setUint32(16, offset, true);
+  return concat([...parts, directory, end]);
+}
+var json = (name, data) => ({
+  name,
+  bytes: enc.encode(JSON.stringify(data, null, 2))
+});
+async function makeExport(state, recipe, kind) {
+  const result = (name, type, bytes) => ({
+    name,
+    type,
+    bytes
+  });
+  if (kind === "project")
+    return result("terrain-recipe.json", "application/json", json("", recipe).bytes);
+  if (kind === "png")
+    return result("terrain-height16.png", "image/png", await encodeHeightPNG(state));
+  if (kind === "glb") return result("terrain.glb", "model/gltf-binary", encodeGLB(bakeMesh(state)));
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  for (const h of state.height) {
+    min = Math.min(min, h);
+    max = Math.max(max, h);
+  }
+  if (max === min) max = min + 1;
+  const range2 = {
+    resolution: state.resolution,
+    size: state.size,
+    min,
+    max,
+    littleEndian: true,
+    units: "metres",
+    rowOrder: "z increases from -size/2 to +size/2",
+    columnOrder: "x increases from -size/2 to +size/2"
+  };
+  if (kind === "raw")
+    return result(
+      "terrain-raw16.zip",
+      "application/zip",
+      encodeZIP([
+        { name: "height.raw", bytes: encodeRAW16(state.height, { min, max }) },
+        json("heightfield.json", range2)
+      ])
+    );
+  const splats = await encodeSplatPNGs(state);
+  const splatFiles = splats.map((s, i) => ({ name: `splat-${i}.png`, bytes: s.bytes }));
+  if (kind === "splat")
+    return result(
+      "terrain-splatmaps.zip",
+      "application/zip",
+      encodeZIP([
+        ...splatFiles,
+        json(
+          "channels.json",
+          splats.map((s, i) => ({ file: `splat-${i}.png`, rgba: s.channels }))
+        )
+      ])
+    );
+  if (kind !== "runtime") throw Error(`Unknown export '${kind}'`);
+  const baked = bakeTerrain(state);
+  const collision = new Uint8Array(state.height.length * 4);
+  const dv = new DataView(collision.buffer);
+  state.height.forEach((h, i) => dv.setFloat32(i * 4, h, true));
+  const manifest = {
+    version: 1,
+    size: state.size,
+    resolution: state.resolution,
+    units: "metres",
+    axis: "Y up",
+    lods: baked.lods.map((l) => ({
+      step: l.step,
+      file: `lod-${l.step}.glb`,
+      chunks: l.chunks.map((c) => ({ name: c.name, ...c.bounds, skirtDepth: c.skirtDepth }))
+    })),
+    collision: {
+      format: "float32-le",
+      file: "collision.f32le",
+      resolution: state.resolution,
+      cellSize: baked.collision.cellSize,
+      origin: baked.collision.origin
+    },
+    heightRange: range2,
+    splats: splats.map((s, i) => ({ file: `splat-${i}.png`, rgba: s.channels })),
+    placements: "placements.json",
+    water: "water.json",
+    limitations: [
+      "Static LODs; runtime selection and streaming not provided",
+      "GLBs contain terrain only; supply assets for placement IDs",
+      "No navigation mesh"
+    ]
+  };
+  const water = state.waters.map((w, i) => {
+    const { mask, ...rest } = w;
+    return { ...rest, maskFile: `water-${i}.mask8` };
+  });
+  const files = [
+    json("manifest.json", manifest),
+    json("recipe.json", recipe),
+    json("placements.json", baked.instances),
+    json("water.json", { bodies: water, rivers: state.rivers }),
+    { name: "collision.f32le", bytes: collision },
+    { name: "height16.png", bytes: await encodeHeightPNG(state) },
+    ...splatFiles,
+    ...baked.lods.map((l) => ({ name: `lod-${l.step}.glb`, bytes: encodeGLB(l.chunks) }))
+  ];
+  for (let i = 0; i < water.length; i++)
+    files.push({
+      name: water[i]?.maskFile,
+      bytes: new Uint8Array(state.waters[i]?.mask ?? [])
+    });
+  return result("terrain-runtime.zip", "application/zip", encodeZIP(files));
+}
+
+// src/editor/worker.js
+var evaluator = new TerrainEvaluator({ cacheMB: 48 });
+self.onmessage = async ({ data }) => {
+  const { id, type, recipe, resolution, kind } = data;
+  try {
+    validateDocument(recipe);
+    const start = performance.now();
+    const state = evaluator.evaluate(recipe, {
+      resolution,
+      onProgress: (p) => self.postMessage({ id, type: "progress", progress: p })
+    });
+    if (type === "export") {
+      const output = await makeExport(state, recipe, kind);
+      self.postMessage({ id, type: "exported", output }, [output.bytes.buffer]);
+    } else self.postMessage({ id, type: "evaluated", state, ms: performance.now() - start });
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};