scena3d 0.1.0 → 0.4.0

package/dist/index.cjs

@@ -21,18 +21,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   DEFAULT_PALETTE: () => DEFAULT_PALETTE,
+  KIT_UNIT: () => KIT_UNIT,
   PALETTES: () => PALETTES,
   Rng: () => Rng,
+  aboveWater: () => aboveWater,
   applyFog: () => applyFog,
+  applyWind: () => applyWind,
+  assembleKit: () => assembleKit,
+  buildScene: () => buildScene,
   collectObstacles: () => collectObstacles,
+  createBush: () => createBush,
   createCrate: () => createCrate,
+  createDayCycle: () => createDayCycle,
   createFence: () => createFence,
+  createGrassTuft: () => createGrassTuft,
+  createHouse: () => createHouse,
   createLamp: () => createLamp,
   createLightingRig: () => createLightingRig,
+  createPath: () => createPath,
   createRock: () => createRock,
+  createRuin: () => createRuin,
   createSky: () => createSky,
   createTerrain: () => createTerrain,
+  createTower: () => createTower,
   createTree: () => createTree,
+  createVillage: () => createVillage,
+  createWater: () => createWater,
+  createWell: () => createWell,
+  extractMarkers: () => extractMarkers,
   fractalNoise2: () => fractalNoise2,
   hash2: () => hash2,
   scatter: () => scatter,
@@ -121,7 +137,12 @@ var PALETTES = {
     peak: 15265007,
     skyTop: 4026552,
     skyBottom: 12573160,
-    fog: 12111837
+    fog: 12111837,
+    water: 4161454,
+    sand: 13220234,
+    path: 10125663,
+    wall: 14273712,
+    roof: 11032126
   },
   autumn: {
     foliage: [13202735, 14257722, 11754538, 14722373],
@@ -137,7 +158,12 @@ var PALETTES = {
     peak: 14933716,
     skyTop: 9333928,
     skyBottom: 15255976,
-    fog: 14270888
+    fog: 14270888,
+    water: 4881042,
+    sand: 13348995,
+    path: 9270356,
+    wall: 13416596,
+    roof: 9062960
   },
   dusk: {
     foliage: [2055750, 2385999, 1724992, 2978904],
@@ -153,7 +179,33 @@ var PALETTES = {
     peak: 12105945,
     skyTop: 1909061,
     skyBottom: 13199946,
-    fog: 6969978
+    fog: 6969978,
+    water: 2968168,
+    sand: 9075306,
+    path: 6969938,
+    wall: 9274009,
+    roof: 4535640
+  },
+  winter: {
+    foliage: [3038280, 3696986, 5405288, 8889750],
+    trunk: 4864563,
+    rock: [10134701, 8687256, 11581632],
+    wood: 7823433,
+    woodDark: 5522746,
+    metal: 3752013,
+    lampGlow: 16767113,
+    grassLow: 13621726,
+    grassHigh: 15002606,
+    cliff: 7764349,
+    peak: 16054266,
+    skyTop: 5929894,
+    skyBottom: 14214380,
+    fog: 13424864,
+    water: 4878470,
+    sand: 12108486,
+    path: 9143160,
+    wall: 13814203,
+    roof: 7030328
   }
 };
 var DEFAULT_PALETTE = PALETTES.meadow;
@@ -368,8 +420,321 @@ function createLamp(options = {}) {
   return { object: group, obstacleRadius: 0.25 };
 }
 
-// src/environment/terrain.ts
+// src/props/grass.ts
 var import_three7 = require("three");
+function createGrassTuft(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const blades = options.blades ?? rng.int(4, 6);
+  const group = new import_three7.Group();
+  group.name = "grass";
+  const material = new import_three7.MeshStandardMaterial({
+    color: rng.next() < 0.5 ? palette.grassHigh : rng.pick(palette.foliage),
+    flatShading: true
+  });
+  for (let i = 0; i < blades; i++) {
+    const height = rng.range(0.25, 0.5);
+    const blade = new import_three7.Mesh(new import_three7.ConeGeometry(0.035, height, 3), material);
+    blade.position.set(rng.jitter(0, 0.12), height / 2, rng.jitter(0, 0.12));
+    blade.rotation.set(rng.range(-0.25, 0.25), rng.range(0, Math.PI), rng.range(-0.25, 0.25));
+    group.add(blade);
+  }
+  return { object: group, obstacleRadius: 0 };
+}
+function createBush(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const size = options.size ?? rng.range(0.4, 0.7);
+  const group = new import_three7.Group();
+  group.name = "bush";
+  const material = new import_three7.MeshStandardMaterial({ color: rng.pick(palette.foliage), flatShading: true });
+  const blobs = rng.int(2, 3);
+  for (let i = 0; i < blobs; i++) {
+    const radius = size * rng.range(0.55, 0.85);
+    const blob = new import_three7.Mesh(new import_three7.IcosahedronGeometry(radius, 0), material);
+    blob.position.set(rng.jitter(0, size * 0.4), radius * 0.7, rng.jitter(0, size * 0.4));
+    blob.scale.y = rng.range(0.7, 0.85);
+    blob.rotation.y = rng.range(0, Math.PI);
+    group.add(blob);
+  }
+  return { object: group, obstacleRadius: size * 0.6 };
+}
+
+// src/props/building.ts
+var import_three8 = require("three");
+function prismGeometry(width, height, depth) {
+  const w = width / 2;
+  const d = depth / 2;
+  const positions = new Float32Array([
+    // front gable (z = +d)
+    -w,
+    0,
+    d,
+    w,
+    0,
+    d,
+    0,
+    height,
+    d,
+    // back gable (z = -d)
+    w,
+    0,
+    -d,
+    -w,
+    0,
+    -d,
+    0,
+    height,
+    -d,
+    // left slope
+    -w,
+    0,
+    -d,
+    -w,
+    0,
+    d,
+    0,
+    height,
+    d,
+    -w,
+    0,
+    -d,
+    0,
+    height,
+    d,
+    0,
+    height,
+    -d,
+    // right slope
+    w,
+    0,
+    d,
+    w,
+    0,
+    -d,
+    0,
+    height,
+    -d,
+    w,
+    0,
+    d,
+    0,
+    height,
+    -d,
+    0,
+    height,
+    d,
+    // bottom
+    -w,
+    0,
+    -d,
+    w,
+    0,
+    -d,
+    w,
+    0,
+    d,
+    -w,
+    0,
+    -d,
+    w,
+    0,
+    d,
+    -w,
+    0,
+    d
+  ]);
+  const geometry = new import_three8.BufferGeometry();
+  geometry.setAttribute("position", new import_three8.BufferAttribute(positions, 3));
+  geometry.computeVertexNormals();
+  return geometry;
+}
+function createHouse(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const width = options.width ?? rng.range(3.2, 4.2);
+  const depth = options.depth ?? width * rng.range(0.75, 0.9);
+  const wallHeight = options.wallHeight ?? rng.range(2.1, 2.4);
+  const group = new import_three8.Group();
+  group.name = "house";
+  const wall = new import_three8.MeshStandardMaterial({ color: palette.wall, flatShading: true });
+  wall.color.offsetHSL(0, 0, rng.range(-0.03, 0.03));
+  const roof = new import_three8.MeshStandardMaterial({ color: palette.roof, flatShading: true });
+  roof.color.offsetHSL(0, 0, rng.range(-0.04, 0.04));
+  const stone = new import_three8.MeshStandardMaterial({ color: palette.rock[0], flatShading: true });
+  const wood = new import_three8.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const foundation = new import_three8.Mesh(new import_three8.BoxGeometry(width + 0.3, 1.6, depth + 0.3), stone);
+  foundation.position.y = -0.55;
+  group.add(foundation);
+  const body = new import_three8.Mesh(new import_three8.BoxGeometry(width, wallHeight, depth), wall);
+  body.position.y = wallHeight / 2;
+  group.add(body);
+  const ridgeHeight = width * rng.range(0.32, 0.4);
+  const roofMesh = new import_three8.Mesh(prismGeometry(width + 0.5, ridgeHeight, depth + 0.6), roof);
+  roofMesh.position.y = wallHeight - 0.02;
+  group.add(roofMesh);
+  const chimney = new import_three8.Mesh(new import_three8.BoxGeometry(0.34, ridgeHeight + 0.8, 0.34), stone);
+  chimney.position.set(rng.pick([-1, 1]) * width * 0.22, wallHeight + ridgeHeight * 0.45, depth * 0.12);
+  group.add(chimney);
+  const door = new import_three8.Mesh(new import_three8.BoxGeometry(0.85, 1.5, 0.08), wood);
+  door.position.set(rng.range(-0.4, 0.4), 0.75, depth / 2 + 0.02);
+  group.add(door);
+  const glass = new import_three8.MeshStandardMaterial({
+    color: palette.lampGlow,
+    emissive: palette.lampGlow,
+    emissiveIntensity: 1
+  });
+  const windowGeometry = new import_three8.BoxGeometry(0.6, 0.62, 0.08);
+  const front = new import_three8.Mesh(windowGeometry, glass);
+  front.position.set(door.position.x < 0 ? width * 0.28 : -width * 0.28, 1.35, depth / 2 + 0.02);
+  group.add(front);
+  for (const side of [-1, 1]) {
+    if (rng.next() < 0.35) continue;
+    const pane = new import_three8.Mesh(windowGeometry, glass);
+    pane.position.set(side * (width / 2 + 0.02), 1.35, rng.range(-0.3, 0.3) * depth);
+    pane.rotation.y = Math.PI / 2;
+    group.add(pane);
+  }
+  return { object: group, obstacleRadius: Math.hypot(width + 0.5, depth + 0.5) / 2 };
+}
+function createTower(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const height = options.height ?? rng.range(4.2, 5.2);
+  const group = new import_three8.Group();
+  group.name = "tower";
+  const wood = new import_three8.MeshStandardMaterial({ color: palette.wood, flatShading: true });
+  const woodDark = new import_three8.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const roof = new import_three8.MeshStandardMaterial({ color: palette.roof, flatShading: true });
+  const spread = 1;
+  for (const x of [-1, 1]) {
+    for (const z of [-1, 1]) {
+      const leg = new import_three8.Mesh(new import_three8.CylinderGeometry(0.09, 0.12, height, 6), woodDark);
+      leg.position.set(x * spread * 0.75, height / 2 - 0.6, z * spread * 0.75);
+      leg.rotation.z = -x * 0.1;
+      leg.rotation.x = z * 0.1;
+      group.add(leg);
+    }
+  }
+  for (const level of [0.3, 0.62]) {
+    const brace = new import_three8.Mesh(new import_three8.BoxGeometry(spread * 2.1, 0.09, 0.07), wood);
+    brace.position.set(0, height * level, spread * 0.82 * (1 - level * 0.35));
+    brace.rotation.z = rng.pick([-0.5, 0.5]);
+    group.add(brace);
+    const braceSide = new import_three8.Mesh(new import_three8.BoxGeometry(0.07, 0.09, spread * 2.1), wood);
+    braceSide.position.set(spread * 0.82 * (1 - level * 0.35), height * level, 0);
+    braceSide.rotation.x = rng.pick([-0.5, 0.5]);
+    group.add(braceSide);
+  }
+  const platform = new import_three8.Mesh(new import_three8.BoxGeometry(spread * 2.2, 0.14, spread * 2.2), wood);
+  platform.position.y = height - 0.5;
+  group.add(platform);
+  for (const x of [-1, 1]) {
+    for (const z of [-1, 1]) {
+      const post = new import_three8.Mesh(new import_three8.BoxGeometry(0.08, 0.9, 0.08), woodDark);
+      post.position.set(x * spread * 1, height - 0.05, z * spread * 1);
+      group.add(post);
+    }
+  }
+  for (const [rx, rz, w, d] of [
+    [0, 1, spread * 2.1, 0.06],
+    [0, -1, spread * 2.1, 0.06],
+    [1, 0, 0.06, spread * 2.1],
+    [-1, 0, 0.06, spread * 2.1]
+  ]) {
+    const rail = new import_three8.Mesh(new import_three8.BoxGeometry(w, 0.07, d), wood);
+    rail.position.set(rx * spread, height + 0.28, rz * spread);
+    group.add(rail);
+  }
+  const cap = new import_three8.Mesh(new import_three8.CylinderGeometry(0, spread * 1.55, 1, 4), roof);
+  cap.position.y = height + 1.15;
+  cap.rotation.y = Math.PI / 4;
+  group.add(cap);
+  return { object: group, obstacleRadius: spread * 1.35 };
+}
+function createWell(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const group = new import_three8.Group();
+  group.name = "well";
+  const stone = new import_three8.MeshStandardMaterial({ color: rng.pick(palette.rock), flatShading: true });
+  const wood = new import_three8.MeshStandardMaterial({ color: palette.woodDark, flatShading: true });
+  const roof = new import_three8.MeshStandardMaterial({ color: palette.roof, flatShading: true });
+  const ring = new import_three8.Mesh(new import_three8.CylinderGeometry(0.85, 0.95, 0.75, 10), stone);
+  ring.position.y = 0.375;
+  group.add(ring);
+  const inner = new import_three8.Mesh(
+    new import_three8.CylinderGeometry(0.62, 0.62, 0.05, 10),
+    new import_three8.MeshStandardMaterial({ color: 1450542 })
+  );
+  inner.position.y = 0.76;
+  group.add(inner);
+  for (const side of [-1, 1]) {
+    const post = new import_three8.Mesh(new import_three8.CylinderGeometry(0.06, 0.075, 1.9, 5), wood);
+    post.position.set(side * 0.72, 0.95, 0);
+    group.add(post);
+  }
+  const bar = new import_three8.Mesh(new import_three8.CylinderGeometry(0.045, 0.045, 1.5, 5), wood);
+  bar.rotation.z = Math.PI / 2;
+  bar.position.y = 1.72;
+  group.add(bar);
+  const cap = new import_three8.Mesh(prismGeometry(2, 0.55, 0.65), roof);
+  cap.position.y = 1.86;
+  cap.rotation.y = Math.PI / 2;
+  group.add(cap);
+  const rope = new import_three8.Mesh(new import_three8.CylinderGeometry(0.012, 0.012, 0.6, 4), wood);
+  rope.position.y = 1.42;
+  group.add(rope);
+  const bucket = new import_three8.Mesh(new import_three8.CylinderGeometry(0.13, 0.1, 0.2, 7), wood);
+  bucket.position.y = 1.05;
+  group.add(bucket);
+  return { object: group, obstacleRadius: 1 };
+}
+function createRuin(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const size = options.size ?? rng.range(3.5, 5);
+  const depth = size * rng.range(0.7, 0.9);
+  const group = new import_three8.Group();
+  group.name = "ruin";
+  const stone = new import_three8.MeshStandardMaterial({ color: rng.pick(palette.rock), flatShading: true });
+  stone.color.offsetHSL(0, 0, rng.range(-0.04, 0.02));
+  const thickness = 0.35;
+  const runs = [
+    [0, -depth / 2, size, true],
+    [-size / 2, 0, depth, false],
+    [size / 2, 0, depth, false],
+    [size * 0.3, depth / 2, size * 0.35, true]
+  ];
+  for (const [cx, cz, length, alongX] of runs) {
+    const segments = Math.max(2, Math.round(length / 1.1));
+    const step = length / segments;
+    for (let i = 0; i < segments; i++) {
+      if (rng.next() < 0.22) continue;
+      const height = rng.range(0.5, 2.2);
+      const wall = new import_three8.Mesh(
+        new import_three8.BoxGeometry(alongX ? step * 0.96 : thickness, height, alongX ? thickness : step * 0.96),
+        stone
+      );
+      const offset = -length / 2 + step * (i + 0.5);
+      wall.position.set(alongX ? cx + offset : cx, height / 2, alongX ? cz : cz + offset);
+      wall.rotation.y = rng.range(-0.03, 0.03);
+      group.add(wall);
+    }
+  }
+  const blocks = rng.int(4, 7);
+  for (let i = 0; i < blocks; i++) {
+    const s = rng.range(0.25, 0.55);
+    const block = new import_three8.Mesh(new import_three8.BoxGeometry(s, s * rng.range(0.6, 1), s * rng.range(0.7, 1.2)), stone);
+    block.position.set(rng.range(-size * 0.6, size * 0.6), s * 0.3, rng.range(-depth * 0.6, depth * 0.7));
+    block.rotation.set(rng.range(-0.3, 0.3), rng.range(0, Math.PI), rng.range(-0.3, 0.3));
+    group.add(block);
+  }
+  return { object: group, obstacleRadius: Math.hypot(size, depth) / 2 };
+}
+
+// src/environment/terrain.ts
+var import_three9 = require("three");
 function createTerrain(options = {}) {
   const seed = options.seed ?? 1;
   const size = options.size ?? 80;
@@ -384,7 +749,7 @@ function createTerrain(options = {}) {
     const shaped = Math.pow(n, 1 + flatness * 2);
     return shaped * amplitude;
   };
-  const geometry = new import_three7.PlaneGeometry(size, size, resolution - 1, resolution - 1);
+  const geometry = new import_three9.PlaneGeometry(size, size, resolution - 1, resolution - 1);
   geometry.rotateX(-Math.PI / 2);
   const positions = geometry.getAttribute("position");
   for (let i = 0; i < positions.count; i++) {
@@ -393,40 +758,46 @@ function createTerrain(options = {}) {
   geometry.computeVertexNormals();
   const normals = geometry.getAttribute("normal");
   const colors = new Float32Array(positions.count * 3);
-  const grassLow = new import_three7.Color(palette.grassLow);
-  const grassHigh = new import_three7.Color(palette.grassHigh);
-  const cliff = new import_three7.Color(palette.cliff);
-  const peak = new import_three7.Color(palette.peak);
-  const scratch = new import_three7.Color();
+  const grassLow = new import_three9.Color(palette.grassLow);
+  const grassHigh = new import_three9.Color(palette.grassHigh);
+  const cliff = new import_three9.Color(palette.cliff);
+  const peak = new import_three9.Color(palette.peak);
+  const sand = new import_three9.Color(palette.sand);
+  const waterLevel = options.waterLevel;
+  const scratch = new import_three9.Color();
   for (let i = 0; i < positions.count; i++) {
-    const h = positions.getY(i) / amplitude;
+    const y = positions.getY(i);
+    const h = y / amplitude;
     const slope = 1 - normals.getY(i);
     scratch.copy(grassLow).lerp(grassHigh, Math.min(1, h * 1.6));
     if (h > 0.75) scratch.lerp(peak, (h - 0.75) * 4);
     if (slope > 0.15) scratch.lerp(cliff, Math.min(1, (slope - 0.15) * 4));
+    if (waterLevel !== void 0 && y < waterLevel + 0.5) {
+      scratch.lerp(sand, Math.min(1, (waterLevel + 0.5 - y) * 1.6));
+    }
     colors[i * 3] = scratch.r;
     colors[i * 3 + 1] = scratch.g;
     colors[i * 3 + 2] = scratch.b;
   }
-  geometry.setAttribute("color", new import_three7.BufferAttribute(colors, 3));
-  const mesh = new import_three7.Mesh(
+  geometry.setAttribute("color", new import_three9.BufferAttribute(colors, 3));
+  const mesh = new import_three9.Mesh(
     geometry,
-    new import_three7.MeshStandardMaterial({ vertexColors: true, flatShading: true })
+    new import_three9.MeshStandardMaterial({ vertexColors: true, flatShading: true })
   );
   mesh.name = "terrain";
   return { mesh, heightAt, size, seed };
 }
 
 // src/environment/sky.ts
-var import_three8 = require("three");
+var import_three10 = require("three");
 function createSky(options = {}) {
   const palette = options.palette ?? DEFAULT_PALETTE;
-  const material = new import_three8.ShaderMaterial({
-    side: import_three8.BackSide,
+  const material = new import_three10.ShaderMaterial({
+    side: import_three10.BackSide,
     depthWrite: false,
     uniforms: {
-      topColor: { value: new import_three8.Color(options.topColor ?? palette.skyTop) },
-      bottomColor: { value: new import_three8.Color(options.bottomColor ?? palette.skyBottom) }
+      topColor: { value: new import_three10.Color(options.topColor ?? palette.skyTop) },
+      bottomColor: { value: new import_three10.Color(options.bottomColor ?? palette.skyBottom) }
     },
     vertexShader: (
       /* glsl */
@@ -449,7 +820,7 @@ function createSky(options = {}) {
       }`
     )
   });
-  const mesh = new import_three8.Mesh(new import_three8.SphereGeometry(options.radius ?? 400, 16, 12), material);
+  const mesh = new import_three10.Mesh(new import_three10.SphereGeometry(options.radius ?? 400, 16, 12), material);
   mesh.name = "sky";
   return {
     mesh,
@@ -461,7 +832,7 @@ function createSky(options = {}) {
 }
 
 // src/environment/lighting.ts
-var import_three9 = require("three");
+var import_three11 = require("three");
 var PRESETS = {
   day: {
     sun: 16774368,
@@ -502,12 +873,12 @@ var PRESETS = {
 };
 function createLightingRig(preset = "day") {
   const config = PRESETS[preset];
-  const group = new import_three9.Group();
+  const group = new import_three11.Group();
   group.name = `lighting-${preset}`;
-  const sun = new import_three9.DirectionalLight(config.sun, config.sunIntensity);
+  const sun = new import_three11.DirectionalLight(config.sun, config.sunIntensity);
   sun.position.set(...config.sunPos);
-  const ambient = new import_three9.AmbientLight(config.ambient, config.ambientIntensity);
-  const hemisphere = new import_three9.HemisphereLight(config.skyTint, config.groundTint, 0.5);
+  const ambient = new import_three11.AmbientLight(config.ambient, config.ambientIntensity);
+  const hemisphere = new import_three11.HemisphereLight(config.skyTint, config.groundTint, 0.5);
   group.add(sun, ambient, hemisphere);
   return { group, sun, ambient, hemisphere };
 }
@@ -522,11 +893,512 @@ function applyFog(scene, preset, palette = DEFAULT_PALETTE) {
     return;
   }
   const { near, far } = FOG[preset];
-  scene.fog = new import_three9.Fog(palette.fog, near, far);
+  scene.fog = new import_three11.Fog(palette.fog, near, far);
+}
+
+// src/environment/water.ts
+var import_three12 = require("three");
+function createWater(options = {}) {
+  const level = options.level ?? 0.8;
+  const size = options.size ?? 200;
+  const resolution = options.resolution ?? 40;
+  const amplitude = options.amplitude ?? 0.06;
+  const speed = options.speed ?? 1;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const geometry = new import_three12.PlaneGeometry(size, size, resolution, resolution);
+  geometry.rotateX(-Math.PI / 2);
+  const positions = geometry.getAttribute("position");
+  const mesh = new import_three12.Mesh(
+    geometry,
+    new import_three12.MeshStandardMaterial({
+      color: palette.water,
+      transparent: true,
+      opacity: 0.85,
+      flatShading: true,
+      metalness: 0.35,
+      roughness: 0.4
+    })
+  );
+  mesh.name = "water";
+  mesh.position.y = level;
+  let time = 0;
+  const update = (dt) => {
+    time += dt * speed;
+    for (let i = 0; i < positions.count; i++) {
+      const x = positions.getX(i);
+      const z = positions.getZ(i);
+      positions.setY(
+        i,
+        Math.sin(x * 0.35 + time) * Math.cos(z * 0.3 + time * 0.8) * amplitude
+      );
+    }
+    positions.needsUpdate = true;
+    geometry.computeVertexNormals();
+  };
+  update(0);
+  return {
+    mesh,
+    level,
+    update,
+    isUnderwater: (groundHeight) => groundHeight < level
+  };
+}
+function aboveWater(terrain, water, margin = 0.25) {
+  return (x, z) => terrain.heightAt(x, z) > water.level + margin;
+}
+
+// src/environment/dayCycle.ts
+var import_three13 = require("three");
+function createDayCycle(options = {}) {
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const dayLength = options.dayLength ?? 60;
+  const frames = [
+    { t: 0, skyTop: 725030, skyBottom: 1712960, sun: 9348824, sunIntensity: 0.03, ambientIntensity: 0.06, fog: 1317422 },
+    { t: 0.23, skyTop: 2569052, skyBottom: 6968432, sun: 13605490, sunIntensity: 0.3, ambientIntensity: 0.12, fog: 4866648 },
+    { t: 0.3, skyTop: 4877216, skyBottom: 15247738, sun: 16758881, sunIntensity: 1, ambientIntensity: 0.26, fog: 11569778 },
+    { t: 0.5, skyTop: palette.skyTop, skyBottom: palette.skyBottom, sun: 16774368, sunIntensity: 1.9, ambientIntensity: 0.45, fog: palette.fog },
+    { t: 0.7, skyTop: 4872852, skyBottom: 14718302, sun: 16752720, sunIntensity: 1, ambientIntensity: 0.26, fog: 10517096 },
+    { t: 0.78, skyTop: 2304594, skyBottom: 9065824, sun: 14191194, sunIntensity: 0.25, ambientIntensity: 0.11, fog: 4603476 },
+    { t: 1, skyTop: 725030, skyBottom: 1712960, sun: 9348824, sunIntensity: 0.03, ambientIntensity: 0.06, fog: 1317422 }
+  ];
+  const lampLights = [];
+  const lampBulbs = [];
+  for (const entry of options.lamps ?? []) {
+    const root = entry.isObject3D ? entry : entry.object;
+    root.traverse((child) => {
+      if (child instanceof import_three13.PointLight) {
+        lampLights.push({ light: child, base: child.intensity || 6 });
+      }
+      const material = child.material;
+      if (material?.emissive && material.emissiveIntensity > 0.5) {
+        lampBulbs.push({ material, base: material.emissiveIntensity });
+      }
+    });
+  }
+  const colorA = new import_three13.Color();
+  const colorB = new import_three13.Color();
+  let timeOfDay = options.timeOfDay ?? 0.5;
+  let sunElevation = 0;
+  const sample = (t) => {
+    let a = frames[0];
+    let b = frames[frames.length - 1];
+    for (let i = 0; i < frames.length - 1; i++) {
+      if (t >= frames[i].t && t <= frames[i + 1].t) {
+        a = frames[i];
+        b = frames[i + 1];
+        break;
+      }
+    }
+    const f = b.t === a.t ? 0 : (t - a.t) / (b.t - a.t);
+    const lerpHex = (ha, hb) => colorA.setHex(ha).lerp(colorB.setHex(hb), f).getHex();
+    return {
+      t,
+      skyTop: lerpHex(a.skyTop, b.skyTop),
+      skyBottom: lerpHex(a.skyBottom, b.skyBottom),
+      sun: lerpHex(a.sun, b.sun),
+      sunIntensity: a.sunIntensity + (b.sunIntensity - a.sunIntensity) * f,
+      ambientIntensity: a.ambientIntensity + (b.ambientIntensity - a.ambientIntensity) * f,
+      fog: lerpHex(a.fog, b.fog)
+    };
+  };
+  const apply = () => {
+    const t = timeOfDay;
+    const frame = sample(t);
+    const sunAngle = (t - 0.25) * Math.PI * 2;
+    sunElevation = Math.sin(sunAngle);
+    options.sky?.setColors(frame.skyTop, frame.skyBottom);
+    if (options.rig) {
+      const { sun, ambient, hemisphere } = options.rig;
+      sun.color.setHex(frame.sun);
+      sun.intensity = frame.sunIntensity;
+      sun.position.set(Math.cos(sunAngle) * 40, Math.max(sunElevation, -0.2) * 45 + 6, 16);
+      ambient.intensity = frame.ambientIntensity;
+      hemisphere.intensity = frame.ambientIntensity * 1.4;
+    }
+    if (options.scene?.fog && "color" in options.scene.fog) {
+      options.scene.fog.color.setHex(frame.fog);
+    }
+    const night = Math.min(1, Math.max(0, (0.06 - sunElevation) / 0.16));
+    for (const { light, base } of lampLights) light.intensity = base * night;
+    for (const { material, base } of lampBulbs) {
+      material.emissiveIntensity = 0.15 * base + 0.85 * base * night;
+    }
+  };
+  apply();
+  return {
+    get timeOfDay() {
+      return timeOfDay;
+    },
+    set timeOfDay(t) {
+      timeOfDay = (t % 1 + 1) % 1;
+      apply();
+    },
+    get sunElevation() {
+      return sunElevation;
+    },
+    get isNight() {
+      return sunElevation < 0;
+    },
+    update(dt) {
+      timeOfDay = (timeOfDay + dt / dayLength) % 1;
+      apply();
+    },
+    set(t) {
+      timeOfDay = (t % 1 + 1) % 1;
+      apply();
+    }
+  };
 }
 
+// src/environment/wind.ts
+var import_three14 = require("three");
+function applyWind(target, options = {}) {
+  const strength = options.strength ?? 0.06;
+  const frequency = options.frequency ?? 1.2;
+  const anchor = options.anchorHeight ?? 0.6;
+  const time = { value: 0 };
+  const patched = /* @__PURE__ */ new Set();
+  target.traverse((child) => {
+    if (!(child instanceof import_three14.Mesh)) return;
+    const materials = Array.isArray(child.material) ? child.material : [child.material];
+    for (const material of materials) {
+      if (patched.has(material)) continue;
+      patched.add(material);
+      material.onBeforeCompile = (shader) => {
+        shader.uniforms.uWindTime = time;
+        shader.vertexShader = shader.vertexShader.replace(
+          "#include <common>",
+          `#include <common>
+             uniform float uWindTime;`
+        ).replace(
+          "#include <begin_vertex>",
+          `#include <begin_vertex>
+             {
+               float sway = max(position.y - ${anchor.toFixed(3)}, 0.0);
+               float phase = 0.0;
+               #ifdef USE_INSTANCING
+                 phase = instanceMatrix[3].x * 0.7 + instanceMatrix[3].z * 1.3;
+               #endif
+               float w = sin(uWindTime * ${(frequency * 2).toFixed(3)} + phase + position.y * 0.8);
+               transformed.x += w * sway * ${strength.toFixed(4)} * 4.0;
+               transformed.z += cos(uWindTime * ${(frequency * 1.4).toFixed(3)} + phase) * sway * ${strength.toFixed(4)} * 2.0;
+             }`
+        );
+      };
+      material.needsUpdate = true;
+    }
+  });
+  return {
+    update(dt) {
+      time.value += dt;
+    },
+    materials: [...patched]
+  };
+}
+
+// src/environment/path.ts
+var import_three15 = require("three");
+function createPath(points, options = {}) {
+  const width = options.width ?? 1.8;
+  const surface = options.surface ?? 0;
+  const heightAt = typeof surface === "number" ? () => surface : (x, z) => surface(x, z);
+  const loop = options.loop ?? false;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const controls = points.map((p) => new import_three15.Vector3(p.x, 0, "z" in p ? p.z : 0));
+  const curve = new import_three15.CatmullRomCurve3(controls, loop, "centripetal");
+  const length = curve.getLength();
+  const samples = Math.max(8, Math.ceil(length * (options.samplesPerUnit ?? 1)));
+  const route = [];
+  for (let i = 0; i <= samples; i++) {
+    if (loop && i === samples) break;
+    const p = curve.getPoint(i / samples);
+    route.push(new import_three15.Vector3(p.x, heightAt(p.x, p.z), p.z));
+  }
+  const edgeCount = loop ? route.length + 1 : route.length;
+  const positions = new Float32Array(edgeCount * 2 * 3);
+  const direction = new import_three15.Vector3();
+  const perp = new import_three15.Vector3();
+  for (let i = 0; i < edgeCount; i++) {
+    const current = route[i % route.length];
+    const previous = route[(i - 1 + route.length) % route.length];
+    const next = route[(i + 1) % route.length];
+    if (!loop && i === 0) direction.subVectors(next, current);
+    else if (!loop && i === edgeCount - 1) direction.subVectors(current, previous);
+    else direction.subVectors(next, previous);
+    perp.set(-direction.z, 0, direction.x).normalize().multiplyScalar(width / 2);
+    const left = i * 6;
+    positions[left] = current.x - perp.x;
+    positions[left + 1] = heightAt(current.x - perp.x, current.z - perp.z) + 0.05;
+    positions[left + 2] = current.z - perp.z;
+    positions[left + 3] = current.x + perp.x;
+    positions[left + 4] = heightAt(current.x + perp.x, current.z + perp.z) + 0.05;
+    positions[left + 5] = current.z + perp.z;
+  }
+  const indices = [];
+  for (let i = 0; i < edgeCount - 1; i++) {
+    const a = i * 2;
+    indices.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+  }
+  const geometry = new import_three15.BufferGeometry();
+  geometry.setAttribute("position", new import_three15.BufferAttribute(positions, 3));
+  geometry.setIndex(indices);
+  geometry.computeVertexNormals();
+  const mesh = new import_three15.Mesh(
+    geometry,
+    new import_three15.MeshStandardMaterial({
+      color: palette.path,
+      flatShading: true,
+      polygonOffset: true,
+      polygonOffsetFactor: -1
+    })
+  );
+  mesh.name = "path";
+  const keepOutMargin = options.keepOutMargin ?? 0.6;
+  const keepOut = route.filter((_p, i) => i % 2 === 0 || i === route.length - 1).map((p) => ({ center: { x: p.x, z: p.z }, radius: width / 2 + keepOutMargin }));
+  const half = width / 2;
+  const contains = (x, z) => {
+    const count = loop ? route.length : route.length - 1;
+    for (let i = 0; i < count; i++) {
+      const a = route[i];
+      const b = route[(i + 1) % route.length];
+      const abx = b.x - a.x;
+      const abz = b.z - a.z;
+      const lengthSq = abx * abx + abz * abz || 1e-9;
+      const t = Math.max(0, Math.min(1, ((x - a.x) * abx + (z - a.z) * abz) / lengthSq));
+      const dx = x - (a.x + abx * t);
+      const dz = z - (a.z + abz * t);
+      if (dx * dx + dz * dz <= half * half) return true;
+    }
+    return false;
+  };
+  return { mesh, route, keepOut, contains, loop };
+}
+
+// src/generators/village.ts
+var import_three16 = require("three");
+function createVillage(options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const center = options.center ?? { x: 0, z: 0 };
+  const radius = options.radius ?? 12;
+  const houseCount = options.houses ?? 5;
+  const surface = options.surface ?? 0;
+  const heightAt = typeof surface === "number" ? () => surface : (x, z) => surface(x, z);
+  const group = new import_three16.Group();
+  group.name = "village";
+  const props = [];
+  const lamps = [];
+  const place = (prop, x, z, rotY) => {
+    prop.object.position.set(x, heightAt(x, z), z);
+    prop.object.rotation.y = rotY;
+    group.add(prop.object);
+    props.push(prop);
+    return prop;
+  };
+  const findSpot = (angle, distance, footprint) => {
+    let x = center.x;
+    let z = center.z;
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const a = angle + rng.range(-0.25, 0.25) * (attempt > 0 ? 1 : 0.3);
+      const d = distance * rng.range(attempt > 0 ? 0.8 : 0.95, 1.1);
+      x = center.x + Math.cos(a) * d;
+      z = center.z + Math.sin(a) * d;
+      const y = heightAt(x, z);
+      if (options.mask && !options.mask(x, z, y)) continue;
+      let min = y;
+      let max = y;
+      for (const [dx, dz] of [[footprint, 0], [-footprint, 0], [0, footprint], [0, -footprint]]) {
+        const h = heightAt(x + dx, z + dz);
+        min = Math.min(min, h);
+        max = Math.max(max, h);
+      }
+      if (max - min <= Math.max(0.9, footprint * 0.35)) break;
+    }
+    return { x, z };
+  };
+  const well = createWell({ seed: rng.int(1, 1e9), palette });
+  place(well, center.x, center.z, rng.range(0, Math.PI * 2));
+  let lightBudget = options.lampLights ?? 3;
+  for (let i = 0; i < houseCount; i++) {
+    const angle = i / houseCount * Math.PI * 2 + rng.range(-0.15, 0.15);
+    const house = createHouse({ seed: rng.int(1, 1e9), palette });
+    const spot = findSpot(angle, radius * rng.range(0.7, 0.95), house.obstacleRadius);
+    const facing = Math.atan2(center.x - spot.x, center.z - spot.z);
+    place(house, spot.x, spot.z, facing);
+    lamps.push(house);
+    if (rng.next() < 0.7) {
+      const crateAngle = angle + rng.range(-0.5, 0.5);
+      const crateDistance = Math.hypot(spot.x - center.x, spot.z - center.z) - house.obstacleRadius - 0.7;
+      place(
+        createCrate({ seed: rng.int(1, 1e9), size: rng.range(0.7, 1), palette }),
+        center.x + Math.cos(crateAngle) * crateDistance,
+        center.z + Math.sin(crateAngle) * crateDistance,
+        rng.range(0, Math.PI)
+      );
+    }
+    if (i % 2 === 0) {
+      const lampDistance = Math.hypot(spot.x - center.x, spot.z - center.z) * 0.55;
+      const lamp = createLamp({ seed: rng.int(1, 1e9), light: lightBudget > 0, palette });
+      lightBudget--;
+      place(lamp, center.x + Math.cos(angle) * lampDistance, center.z + Math.sin(angle) * lampDistance, 0);
+      lamps.push(lamp);
+    }
+  }
+  if (options.tower ?? true) {
+    const angle = rng.range(0, Math.PI * 2);
+    const tower = createTower({ seed: rng.int(1, 1e9), palette });
+    const spot = findSpot(angle, radius * 1.05, tower.obstacleRadius);
+    place(tower, spot.x, spot.z, rng.range(0, Math.PI * 2));
+  }
+  if (options.ruin ?? true) {
+    const angle = rng.range(0, Math.PI * 2);
+    const ruin = createRuin({ seed: rng.int(1, 1e9), palette });
+    const spot = findSpot(angle, radius * 1.35, ruin.obstacleRadius);
+    place(ruin, spot.x, spot.z, rng.range(0, Math.PI * 2));
+  }
+  return {
+    group,
+    props,
+    obstacles: collectObstacles(props),
+    lamps,
+    keepOut: [{ center: { ...center }, radius: radius * 1.5 }],
+    center
+  };
+}
+
+// src/kits/kit.ts
+var import_three17 = require("three");
+var KIT_UNIT = 2;
+function assembleKit(rows, options = {}) {
+  const rng = new Rng(options.seed ?? 1);
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const unit = options.unit ?? KIT_UNIT;
+  const wallHeight = options.wallHeight ?? 2.6;
+  let torchLights = options.torchLights ?? 4;
+  const height = rows.length;
+  const width = Math.max(...rows.map((r) => r.length), 0);
+  const originX = (-width / 2 + 0.5) * unit;
+  const originZ = (-height / 2 + 0.5) * unit;
+  const worldOf = (col, row) => ({
+    x: originX + col * unit,
+    z: originZ + row * unit
+  });
+  const group = new import_three17.Group();
+  group.name = "kit";
+  const obstacles = [];
+  const spawns = [];
+  const torches = [];
+  const floorCells = /* @__PURE__ */ new Set();
+  const wallCells = [];
+  const floorTiles = [];
+  for (let row = 0; row < height; row++) {
+    for (let col = 0; col < (rows[row] ?? "").length; col++) {
+      const cell = rows[row][col];
+      if (cell === " " || cell === void 0) continue;
+      const { x, z } = worldOf(col, row);
+      if (cell === "#") {
+        wallCells.push({ x, z });
+        obstacles.push({ center: new import_three17.Vector3(x, wallHeight / 2, z), radius: unit * 0.71 });
+        continue;
+      }
+      floorTiles.push({ x, z });
+      floorCells.add(`${col},${row}`);
+      if (cell === "D") {
+        const horizontalRun = rows[row][col - 1] === "#" || rows[row][col + 1] === "#";
+        const lintel = new import_three17.Mesh(
+          new import_three17.BoxGeometry(
+            horizontalRun ? unit : unit * 0.4,
+            wallHeight * 0.25,
+            horizontalRun ? unit * 0.4 : unit
+          ),
+          new import_three17.MeshStandardMaterial({ color: palette.woodDark, flatShading: true })
+        );
+        lintel.position.set(x, wallHeight * 0.875, z);
+        group.add(lintel);
+      } else if (cell === "T") {
+        group.add(createTorch(x, z, palette, rng, torchLights > 0));
+        torchLights--;
+        torches.push(new import_three17.Vector3(x, 0, z));
+        obstacles.push({ center: new import_three17.Vector3(x, 0, z), radius: 0.3 });
+      } else if (cell === "S") {
+        spawns.push(new import_three17.Vector3(x, 0, z));
+      }
+    }
+  }
+  const stone = new import_three17.MeshStandardMaterial({ color: rng.pick(palette.rock), flatShading: true });
+  const stoneDark = new import_three17.MeshStandardMaterial({ color: palette.cliff, flatShading: true });
+  const matrix = new import_three17.Matrix4();
+  if (wallCells.length > 0) {
+    const walls = new import_three17.InstancedMesh(
+      new import_three17.BoxGeometry(unit, wallHeight, unit),
+      stone,
+      wallCells.length
+    );
+    wallCells.forEach((cell, i) => {
+      walls.setMatrixAt(i, matrix.makeTranslation(cell.x, wallHeight / 2, cell.z));
+    });
+    walls.instanceMatrix.needsUpdate = true;
+    group.add(walls);
+  }
+  if (floorTiles.length > 0) {
+    const floors = new import_three17.InstancedMesh(
+      new import_three17.BoxGeometry(unit, 0.2, unit),
+      stoneDark,
+      floorTiles.length
+    );
+    floorTiles.forEach((cell, i) => {
+      floors.setMatrixAt(i, matrix.makeTranslation(cell.x, -0.1, cell.z));
+    });
+    floors.instanceMatrix.needsUpdate = true;
+    group.add(floors);
+  }
+  return {
+    group,
+    obstacles,
+    spawns,
+    torches,
+    floorAt(x, z) {
+      const col = Math.round((x - originX) / unit);
+      const row = Math.round((z - originZ) / unit);
+      return floorCells.has(`${col},${row}`);
+    },
+    size: { width: width * unit, depth: height * unit }
+  };
+}
+function createTorch(x, z, palette, rng, light) {
+  const torch = new import_three17.Group();
+  torch.name = "torch";
+  const pole = new import_three17.Mesh(
+    new import_three17.CylinderGeometry(0.04, 0.06, 1.5, 5),
+    new import_three17.MeshStandardMaterial({ color: palette.woodDark, flatShading: true })
+  );
+  pole.position.y = 0.75;
+  torch.add(pole);
+  const flame = new import_three17.Mesh(
+    new import_three17.SphereGeometry(0.1, 6, 5),
+    new import_three17.MeshStandardMaterial({
+      color: palette.lampGlow,
+      emissive: palette.lampGlow,
+      emissiveIntensity: 1.8
+    })
+  );
+  flame.position.y = 1.58;
+  flame.scale.y = rng.range(1.2, 1.5);
+  torch.add(flame);
+  if (light) {
+    const point = new import_three17.PointLight(palette.lampGlow, 5, 9, 1.9);
+    point.position.y = 1.6;
+    torch.add(point);
+  }
+  torch.position.set(x, 0, z);
+  return torch;
+}
+
+// src/scene/manifest.ts
+var import_three19 = require("three");
+
 // src/scatter/scatter.ts
-var import_three10 = require("three");
+var import_three18 = require("three");
 function scatter(options) {
   const seed = options.seed ?? 1;
   const rng = new Rng(seed);
@@ -581,7 +1453,7 @@ function scatter(options) {
     const itemIndex = pickItem();
     const [minScale, maxScale2] = options.items[itemIndex].scale ?? [0.8, 1.25];
     placements.push({
-      position: new import_three10.Vector3(x, y, z),
+      position: new import_three18.Vector3(x, y, z),
       rotationY: rng.range(0, Math.PI * 2),
       scale: rng.range(minScale, maxScale2),
       itemIndex
@@ -591,18 +1463,59 @@ function scatter(options) {
     if (!bucket) occupied.set(key, bucket = []);
     bucket.push({ x, z });
   }
-  const group = new import_three10.Group();
+  const group = new import_three18.Group();
   group.name = "scatter";
   const obstacles = [];
-  const placementMatrix = new import_three10.Matrix4();
-  const composed = new import_three10.Matrix4();
-  const quaternion = new import_three10.Quaternion();
-  const up = new import_three10.Vector3(0, 1, 0);
-  const scaleVector = new import_three10.Vector3();
+  const placementMatrix = new import_three18.Matrix4();
+  const composed = new import_three18.Matrix4();
+  const quaternion = new import_three18.Quaternion();
+  const up = new import_three18.Vector3(0, 1, 0);
+  const scaleVector = new import_three18.Vector3();
+  const emit = (variant, list, parent) => {
+    variant.object.updateMatrixWorld(true);
+    variant.object.traverse((child) => {
+      if (!(child instanceof import_three18.Mesh)) return;
+      const instanced = new import_three18.InstancedMesh(child.geometry, child.material, list.length);
+      instanced.instanceMatrix.setUsage(import_three18.DynamicDrawUsage);
+      list.forEach((placement, index) => {
+        quaternion.setFromAxisAngle(up, placement.rotationY);
+        scaleVector.setScalar(placement.scale);
+        placementMatrix.compose(placement.position, quaternion, scaleVector);
+        composed.multiplyMatrices(placementMatrix, child.matrixWorld);
+        instanced.setMatrixAt(index, composed);
+      });
+      instanced.instanceMatrix.needsUpdate = true;
+      parent.add(instanced);
+    });
+  };
+  const tileSize = options.lod?.tileSize ?? 16;
+  const tileMap = /* @__PURE__ */ new Map();
+  const tileFor = (x, z) => {
+    const tx = Math.floor(x / tileSize);
+    const tz = Math.floor(z / tileSize);
+    const key = `${tx},${tz}`;
+    let tile = tileMap.get(key);
+    if (!tile) {
+      tile = {
+        center: { x: (tx + 0.5) * tileSize, z: (tz + 0.5) * tileSize },
+        near: new import_three18.Group(),
+        far: new import_three18.Group()
+      };
+      tile.far.visible = false;
+      group.add(tile.near, tile.far);
+      tileMap.set(key, tile);
+    }
+    return tile;
+  };
   options.items.forEach((item, itemIndex) => {
     const variantCount = item.variants ?? 4;
     const variants = [];
     for (let v = 0; v < variantCount; v++) variants.push(item.create(rng.fork()));
+    const useLod = options.lod !== void 0 && item.createFar !== void 0;
+    const farVariants = [];
+    if (useLod) {
+      for (let v = 0; v < variantCount; v++) farVariants.push(item.createFar(rng.fork()));
+    }
     const byVariant = variants.map(() => []);
     for (const placement of placements) {
       if (placement.itemIndex !== itemIndex) continue;
@@ -612,21 +1525,21 @@ function scatter(options) {
     variants.forEach((variant, v) => {
       const list = byVariant[v];
       if (list.length === 0) return;
-      variant.object.updateMatrixWorld(true);
-      variant.object.traverse((child) => {
-        if (!(child instanceof import_three10.Mesh)) return;
-        const instanced = new import_three10.InstancedMesh(child.geometry, child.material, list.length);
-        instanced.instanceMatrix.setUsage(import_three10.DynamicDrawUsage);
-        list.forEach((placement, index) => {
-          quaternion.setFromAxisAngle(up, placement.rotationY);
-          scaleVector.setScalar(placement.scale);
-          placementMatrix.compose(placement.position, quaternion, scaleVector);
-          composed.multiplyMatrices(placementMatrix, child.matrixWorld);
-          instanced.setMatrixAt(index, composed);
-        });
-        instanced.instanceMatrix.needsUpdate = true;
-        group.add(instanced);
-      });
+      if (useLod) {
+        const byTile = /* @__PURE__ */ new Map();
+        for (const placement of list) {
+          const tile = tileFor(placement.position.x, placement.position.z);
+          let bucket = byTile.get(tile);
+          if (!bucket) byTile.set(tile, bucket = []);
+          bucket.push(placement);
+        }
+        for (const [tile, bucket] of byTile) {
+          emit(variant, bucket, tile.near);
+          emit(farVariants[v], bucket, tile.far);
+        }
+      } else {
+        emit(variant, list, group);
+      }
       if (variant.obstacleRadius > 0) {
         for (const placement of list) {
           obstacles.push({
@@ -637,23 +1550,263 @@ function scatter(options) {
       }
     });
   });
-  return { group, placements, obstacles, count: placements.length };
+  const result = { group, placements, obstacles, count: placements.length };
+  if (options.lod) {
+    const tiles = [...tileMap.values()];
+    const swapOut = options.lod.distance * 1.1;
+    const swapIn = options.lod.distance * 0.9;
+    result.tiles = tiles;
+    result.update = (camera) => {
+      for (const tile of tiles) {
+        const dx = camera.position.x - tile.center.x;
+        const dz = camera.position.z - tile.center.z;
+        const distance = Math.hypot(dx, dz);
+        if (tile.near.visible && distance > swapOut) {
+          tile.near.visible = false;
+          tile.far.visible = true;
+        } else if (!tile.near.visible && distance < swapIn) {
+          tile.near.visible = true;
+          tile.far.visible = false;
+        }
+      }
+    };
+  }
+  return result;
+}
+
+// src/scene/manifest.ts
+var PROP_FACTORIES = {
+  tree: (seed, palette) => createTree({ seed, palette }),
+  rock: (seed, palette) => createRock({ seed, palette }),
+  bush: (seed, palette) => createBush({ seed, palette }),
+  grass: (seed, palette) => createGrassTuft({ seed, palette }),
+  crate: (seed, palette) => createCrate({ seed, palette }),
+  fence: (seed, palette) => createFence({ seed, palette }),
+  lamp: (seed, palette) => createLamp({ seed, palette })
+};
+var FAR_FACTORIES = {
+  tree: (seed, palette) => {
+    const rng = new Rng(seed);
+    const group = new import_three19.Group();
+    const cone = new import_three19.Mesh(
+      new import_three19.CylinderGeometry(0, rng.range(1, 1.4), rng.range(2.6, 3.8), 5),
+      new import_three19.MeshStandardMaterial({ color: rng.pick(palette.foliage), flatShading: true })
+    );
+    cone.position.y = cone.geometry.parameters.height / 2 + 0.3;
+    group.add(cone);
+    return { object: group, obstacleRadius: 0 };
+  },
+  bush: (seed, palette) => {
+    const rng = new Rng(seed);
+    const group = new import_three19.Group();
+    const cone = new import_three19.Mesh(
+      new import_three19.CylinderGeometry(0.1, rng.range(0.5, 0.7), rng.range(0.5, 0.8), 5),
+      new import_three19.MeshStandardMaterial({ color: rng.pick(palette.foliage), flatShading: true })
+    );
+    cone.position.y = 0.3;
+    group.add(cone);
+    return { object: group, obstacleRadius: 0 };
+  },
+  grass: () => ({ object: new import_three19.Group(), obstacleRadius: 0 })
+};
+function buildScene(manifest, scene) {
+  const seed = manifest.seed ?? 1;
+  const palette = manifest.palette ? PALETTES[manifest.palette] : DEFAULT_PALETTE;
+  const group = new import_three19.Group();
+  group.name = "scena-scene";
+  const updates = [];
+  let terrain;
+  if (manifest.terrain) {
+    terrain = createTerrain({
+      ...manifest.terrain,
+      seed,
+      waterLevel: manifest.water?.level,
+      palette
+    });
+    group.add(terrain.mesh);
+  }
+  const heightAt = terrain ? terrain.heightAt : () => 0;
+  let water;
+  if (manifest.water) {
+    water = createWater({
+      level: manifest.water.level,
+      size: manifest.water.size ?? (terrain ? terrain.size * 1.4 : 200),
+      palette
+    });
+    group.add(water.mesh);
+    updates.push((dt) => water.update(dt));
+  }
+  const dryLand = terrain && water ? aboveWater(terrain, water, 0.3) : () => true;
+  let sky;
+  if (manifest.sky ?? true) {
+    sky = createSky({ palette });
+    group.add(sky.mesh);
+  }
+  const rig = createLightingRig(manifest.lighting ?? "day");
+  group.add(rig.group);
+  if (scene && manifest.fog !== false) applyFog(scene, manifest.fog ?? "haze", palette);
+  const paths = (manifest.paths ?? []).map((spec) => {
+    const path = createPath(spec.points, {
+      surface: heightAt,
+      width: spec.width,
+      loop: spec.loop,
+      palette
+    });
+    group.add(path.mesh);
+    return path;
+  });
+  const onAnyPath = (x, z) => paths.some((p) => p.contains(x, z));
+  let village;
+  if (manifest.village) {
+    village = createVillage({
+      ...manifest.village,
+      seed: seed + 1,
+      surface: heightAt,
+      mask: (x, z) => dryLand(x, z) && !onAnyPath(x, z),
+      palette
+    });
+    group.add(village.group);
+  }
+  const wind = manifest.wind ?? true;
+  const scatters = (manifest.scatters ?? []).map((spec, index) => {
+    const inset = terrain ? terrain.size * 0.45 : 40;
+    const avoidWater = spec.avoidWater ?? true;
+    const avoidPaths = spec.avoidPaths ?? true;
+    const result = scatter({
+      seed: seed + 10 + index,
+      area: spec.area ?? { min: { x: -inset, z: -inset }, max: { x: inset, z: inset } },
+      surface: heightAt,
+      density: spec.density,
+      count: spec.count,
+      minSpacing: spec.minSpacing,
+      clumpScale: spec.clumpScale,
+      lod: spec.lod,
+      items: spec.items.map((item) => {
+        const far = spec.lod ? FAR_FACTORIES[item.type] : void 0;
+        return {
+          create: (rng) => PROP_FACTORIES[item.type](rng.int(1, 1e9), palette),
+          createFar: far && ((rng) => far(rng.int(1, 1e9), palette)),
+          weight: item.weight,
+          variants: item.variants,
+          scale: item.scale
+        };
+      }),
+      mask: (x, z, y) => (spec.maxHeight === void 0 || y < spec.maxHeight) && (!avoidWater || dryLand(x, z)) && (!avoidPaths || !onAnyPath(x, z)),
+      keepOut: [
+        ...avoidPaths ? paths.flatMap((p) => p.keepOut) : [],
+        ...village ? village.keepOut : []
+      ]
+    });
+    group.add(result.group);
+    if (wind !== false) {
+      const sway = applyWind(result.group, {
+        strength: typeof wind === "object" ? wind.strength ?? 0.05 : 0.05
+      });
+      updates.push((dt) => sway.update(dt));
+    }
+    return result;
+  });
+  let cycle;
+  if (manifest.dayCycle) {
+    cycle = createDayCycle({
+      sky,
+      rig,
+      scene,
+      lamps: village?.lamps,
+      palette,
+      dayLength: manifest.dayCycle.dayLength,
+      timeOfDay: manifest.dayCycle.timeOfDay
+    });
+    updates.push((dt) => cycle.update(dt));
+  }
+  scene?.add(group);
+  return {
+    group,
+    palette,
+    terrain,
+    water,
+    sky,
+    rig,
+    cycle,
+    paths,
+    village,
+    scatters,
+    obstacles: [
+      ...village ? village.obstacles : [],
+      ...scatters.flatMap((s) => s.obstacles)
+    ],
+    heightAt,
+    update(dt) {
+      for (const fn of updates) fn(dt);
+    }
+  };
+}
+
+// src/scene/markers.ts
+var import_three20 = require("three");
+function extractMarkers(root) {
+  root.updateWorldMatrix(true, true);
+  const spawns = {};
+  const routePoints = {};
+  const obstacles = [];
+  const keepOut = [];
+  root.traverse((node) => {
+    const name = node.name.replace(/\.\d+$/, "");
+    const match = /^(spawn|route|obstacle|keepout)_(.+)$/.exec(name);
+    if (!match) return;
+    const [, kind, rest] = match;
+    const position = node.getWorldPosition(new import_three20.Vector3());
+    const radius = Math.max(node.scale.x, node.scale.z);
+    if (kind === "spawn") {
+      spawns[rest] = position;
+    } else if (kind === "route") {
+      const step = /^(.*)_(\d+)$/.exec(rest);
+      const routeName = step ? step[1] : rest;
+      const index = step ? parseInt(step[2], 10) : 0;
+      (routePoints[routeName] ?? (routePoints[routeName] = [])).push({ index, position });
+    } else if (kind === "obstacle") {
+      obstacles.push({ center: position, radius });
+    } else {
+      keepOut.push({ center: { x: position.x, z: position.z }, radius });
+    }
+  });
+  const routes = {};
+  for (const [name, points] of Object.entries(routePoints)) {
+    routes[name] = points.sort((a, b) => a.index - b.index).map((p) => p.position);
+  }
+  return { spawns, routes, obstacles, keepOut };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_PALETTE,
+  KIT_UNIT,
   PALETTES,
   Rng,
+  aboveWater,
   applyFog,
+  applyWind,
+  assembleKit,
+  buildScene,
   collectObstacles,
+  createBush,
   createCrate,
+  createDayCycle,
   createFence,
+  createGrassTuft,
+  createHouse,
   createLamp,
   createLightingRig,
+  createPath,
   createRock,
+  createRuin,
   createSky,
   createTerrain,
+  createTower,
   createTree,
+  createVillage,
+  createWater,
+  createWell,
+  extractMarkers,
   fractalNoise2,
   hash2,
   scatter,