scena3d 0.3.0 → 0.4.0

package/README.md

@@ -56,6 +56,27 @@ game.onUpdate(() => {                                                  // ← SC
 
 Neither library imports the other — the obstacle shape (`{ center, radius }`) is structural. Run the full demo (`npm run dev` — gama3d comes from npm): a day-night cycle over terrain, lakes, a windblown forest, a seeded hamlet whose windows ignite at dusk, and a dirt road whose single authored curve is at once the visual ribbon, the scatter keep-out, and the wardens' patrol route. Append `?t=0.85` to freeze the time of day.
 
+## A world as JSON
+
+Everything above can also be declared instead of coded — a `SceneManifest` is plain data (store it, diff it, send it over the network), and `buildScene` applies all the cross-feature wiring automatically: scatters stay ashore, off roads and out of the village; the village avoids water and paths; its lamps and windows feed the day cycle.
+
+```ts
+const world = buildScene({
+  seed: 18,
+  palette: 'autumn',
+  terrain: { size: 90, amplitude: 5 },
+  water: { level: 0.25 },
+  dayCycle: { dayLength: 120 },
+  paths: [{ points: roadPoints, loop: true }],
+  village: { radius: 9, houses: 5 },
+  scatters: [{ density: 0.05, items: [{ type: 'tree', weight: 4 }, { type: 'rock' }],
+               lod: { distance: 34 } }],   // far tiles collapse to cones
+}, scene);
+game.onUpdate((t) => world.update(t.delta));
+```
+
+Run it: `npm run dev:manifest`. For handcrafted interiors there are kits — `assembleKit(['####', '#.S#', '#..D', '####'])` turns an ASCII map into snapped walls, floors, doorways, torches, spawn points and obstacles. And for levels authored in Blender/glTF, `extractMarkers(gltf.scene)` reads `spawn_*` / `route_*_0` / `obstacle_*` / `keepout_*` empties into spawns, ordered patrol routes and steering/scatter metadata.
+
 ## API
 
 | Area | Exports |
@@ -64,9 +85,11 @@ Neither library imports the other — the obstacle shape (`{ center, radius }`)
 | Environment | `createTerrain` (with `heightAt(x, z)` and `waterLevel` sand bands), `createSky`, `createLightingRig(...)`, `applyFog(...)`, `createWater` + `aboveWater` mask, `createDayCycle` (one `timeOfDay` drives sun/sky/fog/lamps), `applyWind` (vegetation sway), `createPath` (ribbon + patrol route + keep-out from one curve) |
 | Scattering | `scatter({ seed, area, surface, density \| count, items, mask, minSpacing, keepOut })` → `{ group, placements, obstacles, count }` |
 | Generators | `createVillage({ seed, center, radius, houses, surface, mask })` → `{ group, props, obstacles, lamps, keepOut }` — a hamlet whose windows and lamps hand straight to `createDayCycle`, buildings to `ObstacleAvoidance`, clearing to `scatter` |
+| Kits | `KIT_UNIT`, `assembleKit(asciiRows)` → `{ group, obstacles, spawns, torches, floorAt }` — grid-snapped walls/floors/doorways as two InstancedMeshes |
+| Scene assembly | `buildScene(manifest, scene?)` → a whole wired world from plain JSON; `extractMarkers(root)` → `{ spawns, routes, obstacles, keepOut }` from naming conventions |
 | Core | `Rng` (seeded), `valueNoise2`/`fractalNoise2`, `PALETTES`, `collectObstacles` |
 
-Scatter placement uses density noise for natural clumping and clearings, a spatial hash for minimum spacing, and per-item visual variants; rendering merges everything into `InstancedMesh`es (one draw call per prop part).
+Scatter placement uses density noise for natural clumping and clearings, a spatial hash for minimum spacing, and per-item visual variants; rendering merges everything into `InstancedMesh`es (one draw call per prop part). Opt into `lod: { distance, tileSize }` and placements bucket into tiles that swap to each item's `createFar` variant beyond the distance (10% hysteresis; call `result.update(camera)` each frame).
 
 ## Roadmap
 
@@ -80,9 +103,9 @@ Scatter placement uses density noise for natural clumping and clearings, a spati
 - [x] Paths: one curve = visual ribbon + scatter keep-out + GAMA patrol route
 - [x] Seed-stability snapshot tests (output frozen within a minor version)
 - [x] Buildings (house, watchtower, well) and ruins; `createVillage` hamlet generator with the full gameplay handshake
-- [ ] Kits: dungeon/village pieces with shared snap dimensions
-- [ ] Declarative scene manifests (JSON → scene), Blender marker conventions (`spawn_*`, `route_*`, `nav_*`)
-- [ ] LOD tiers for scatter
+- [x] Kits: ASCII maps → grid-snapped dungeon/compound pieces (`assembleKit`)
+- [x] Declarative scene manifests (JSON → scene) and Blender marker conventions (`spawn_*`, `route_*`, `obstacle_*`, `keepout_*`)
+- [x] LOD tiles for scatter (`createFar` variants, hysteresis)
 - [ ] CC0 asset-pack adapters (Kenney/Quaternius) and a KTX2/Draco pipeline
 - [ ] Docs site with live playground (reusing GAMA's runner)
 
@@ -90,10 +113,11 @@ Scatter placement uses density noise for natural clumping and clearings, a spati
 
 ```bash
 npm install
-npm test          # 49 vitest unit tests (determinism, metadata, scatter rules, snapshots)
+npm test          # 62 vitest unit tests (determinism, metadata, scatter rules, snapshots)
 npm run typecheck
 npm run build     # tsup → dist (ESM + CJS + d.ts)
 npm run dev       # the SCENA × GAMA living-forest demo
+npm run dev:manifest  # the same kind of world, built from one JSON manifest
 ```
 
 ## License

package/dist/index.cjs

@@ -21,11 +21,14 @@ 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,
@@ -45,6 +48,7 @@ __export(index_exports, {
   createVillage: () => createVillage,
   createWater: () => createWater,
   createWell: () => createWell,
+  extractMarkers: () => extractMarkers,
   fractalNoise2: () => fractalNoise2,
   hash2: () => hash2,
   scatter: () => scatter,
@@ -1262,8 +1266,139 @@ function createVillage(options = {}) {
   };
 }
 
-// src/scatter/scatter.ts
+// 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_three18 = require("three");
 function scatter(options) {
   const seed = options.seed ?? 1;
   const rng = new Rng(seed);
@@ -1318,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_three17.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
@@ -1328,18 +1463,59 @@ function scatter(options) {
     if (!bucket) occupied.set(key, bucket = []);
     bucket.push({ x, z });
   }
-  const group = new import_three17.Group();
+  const group = new import_three18.Group();
   group.name = "scatter";
   const obstacles = [];
-  const placementMatrix = new import_three17.Matrix4();
-  const composed = new import_three17.Matrix4();
-  const quaternion = new import_three17.Quaternion();
-  const up = new import_three17.Vector3(0, 1, 0);
-  const scaleVector = new import_three17.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;
@@ -1349,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_three17.Mesh)) return;
-        const instanced = new import_three17.InstancedMesh(child.geometry, child.material, list.length);
-        instanced.instanceMatrix.setUsage(import_three17.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({
@@ -1374,16 +1550,243 @@ 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,
@@ -1403,6 +1806,7 @@ function scatter(options) {
   createVillage,
   createWater,
   createWell,
+  extractMarkers,
   fractalNoise2,
   hash2,
   scatter,