@adatechnology/game-vegetation-three 0.2.7 → 0.3.0

package/dist/index.js

@@ -1,1207 +1,23 @@
-// src/test-area/module.ts
-import { discardObject3D } from "@adatechnology/game-shapes-three";
-import { shapeGeometries as shapeGeometries2 } from "@adatechnology/game-shapes-three";
-import * as GameVegetationMain from "@adatechnology/game-vegetation";
-import * as GameVegetationAdapter from "@adatechnology/game-vegetation/three";
-import * as GameVegetationSpeciesMain from "@adatechnology/game-vegetation-species";
-
-// src/test-area/nursery.ts
-import { shapeGeometries } from "@adatechnology/game-shapes-three";
-var LOT = { W: 12, D: 20 };
-var HOUSE = { x0: 2.5, x1: 9.5, z0: 6.5, z1: 13 };
-var WAY = [[6, 1.2], [6, 5.4], [10.8, 5.4], [10.8, 14.2], [8, 18.6], [3, 18.6], [1.2, 14.2], [1.2, 5.4], [4, 3.2], [8, 3.2]];
-var EX_HOUSE = { rect: { x: HOUSE.x0 - 0.7, z: HOUSE.z0 - 0.7, w: HOUSE.x1 - HOUSE.x0 + 1.4, d: HOUSE.z1 - HOUSE.z0 + 1.4 } };
-var EX_PATH = { rect: { x: 5.1, z: 0, w: 1.8, d: HOUSE.z0 } };
-var AREAS = {
-  front_yard: [{ rect: { x: 0.5, z: 0.5, w: 11, d: 5.6 } }],
-  backyard: [{ rect: { x: 0.5, z: 13.7, w: 11, d: 5.8 } }],
-  sides: [{ rect: { x: 0.5, z: 6.2, w: 1.3, d: 7.4 } }, { rect: { x: 10.2, z: 6.2, w: 1.3, d: 7.4 } }],
-  sidewalk_tree: [{ rect: { x: 0.8, z: -1.9, w: 10.4, d: 1.2 } }]
-};
-var PLANTINGS = [
-  { context: "front_yard", areas: AREAS.front_yard, options: { n: 12, noLarge: true, maxCount: { trees: 1, hedges: 10, mid: 14, ground: 40 } }, tag: "f" },
-  { context: "backyard", areas: AREAS.backyard, options: { n: 14, maxCount: { trees: 3, hedges: 4, mid: 12, ground: 50 } }, tag: "b" },
-  { context: "front_yard", areas: AREAS.sides, options: { n: 8, noLarge: true, maxCount: { trees: 0, hedges: 4, mid: 6, ground: 14 } }, tag: "s" },
-  { context: "sidewalk_tree", areas: AREAS.sidewalk_tree, options: { n: 4, treeDensity: 0.3, maxCount: { trees: 2, hedges: 0, mid: 0, ground: 0 } }, tag: "c" }
-];
-function scatterLot(sdk, species, seedNumber, plantings = PLANTINGS) {
-  const seed = `quintal-${seedNumber}`;
-  const placements = [];
-  const used = /* @__PURE__ */ new Set();
-  for (const planting of plantings) {
-    const { rules, picks } = species.scatterRulesFor(species.regions.br, planting.context, seed, planting.options);
-    for (const p of picks) used.add(p.id);
-    planting.areas.forEach((area, i) => {
-      const exclude = [EX_HOUSE, EX_PATH];
-      const perArea = rules.map((rule) => ({ ...rule, maxCount: Math.max(1, Math.ceil(rule.maxCount / planting.areas.length)) }));
-      placements.push(...sdk.scatter(area, perArea, { seed: `${seed}:${planting.tag}:${i}`, exclude }));
-    });
-  }
-  return { placements, used };
-}
-function buildScenery(THREE) {
-  const g = new THREE.Group();
-  g.name = "nursery-scenery";
-  const material = (color, roughness = 0.9) => new THREE.MeshStandardMaterial({ color, roughness, metalness: 0 });
-  const mats = { ground: material(6257989), asphalt: material(3816770), concrete: material(12039080), house: material(14931645), roof: material(10112312), door: material(7031343), glass: material(10471389, 0.2), wall: material(13222578) };
-  const box = (w, h, d, m, x, y, z) => {
-    const mesh = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), m);
-    mesh.position.set(x, y, z);
-    mesh.castShadow = mesh.receiveShadow = true;
-    g.add(mesh);
-    return mesh;
-  };
-  const yard = new THREE.Mesh(new THREE.PlaneGeometry(LOT.W, LOT.D), mats.ground);
-  yard.rotation.x = -Math.PI / 2;
-  yard.position.set(6, 0.01, 10);
-  yard.receiveShadow = true;
-  g.add(yard);
-  box(30, 0.04, 4.6, mats.asphalt, 6, 0, -4.6);
-  box(30, 0.1, 2.2, mats.concrete, 6, 0.04, -1.1);
-  box(1.6, 0.03, 6.6, mats.concrete, 6, 0.02, 3.2);
-  const hw = HOUSE.x1 - HOUSE.x0;
-  const hd = HOUSE.z1 - HOUSE.z0;
-  const hcx = (HOUSE.x0 + HOUSE.x1) / 2;
-  const hcz = (HOUSE.z0 + HOUSE.z1) / 2;
-  box(hw, 2.8, hd, mats.house, hcx, 1.4, hcz);
-  const roof = new THREE.Mesh(new THREE.ConeGeometry(1, 1.5, 4), mats.roof);
-  roof.rotation.y = Math.PI / 4;
-  roof.scale.set((hw + 1.2) / Math.SQRT2, 1, (hd + 1.2) / Math.SQRT2);
-  roof.position.set(hcx, 2.8 + 0.75, hcz);
-  roof.castShadow = roof.receiveShadow = true;
-  g.add(roof);
-  box(1.1, 2.1, 0.08, mats.door, 6, 1.05, HOUSE.z0 - 0.04);
-  box(1.6, 1.1, 0.08, mats.glass, 3.8, 1.5, HOUSE.z0 - 0.04);
-  box(1.6, 1.1, 0.08, mats.glass, 8.2, 1.5, HOUSE.z0 - 0.04);
-  box(5, 1.4, 0.2, mats.wall, 2.5, 0.7, 0);
-  box(5, 1.4, 0.2, mats.wall, 9.5, 0.7, 0);
-  box(0.2, 1.8, LOT.D, mats.wall, 0, 0.9, 10);
-  box(0.2, 1.8, LOT.D, mats.wall, LOT.W, 0.9, 10);
-  box(LOT.W, 1.8, 0.2, mats.wall, 6, 0.9, LOT.D);
-  return g;
-}
-function createNursery(sdk, species, THREE, materials, parent, origin) {
-  const T = shapeGeometries(THREE);
-  const group = new THREE.Group();
-  group.name = "nursery";
-  group.position.set(origin[0], 0, origin[1]);
-  const dynamic = new THREE.Group();
-  const colliders = new THREE.Group();
-  colliders.visible = false;
-  let scenery = null;
-  let lotObject = null;
-  let data = null;
-  let stats = null;
-  let actor = null;
-  const walker = { x: WAY[0][0], z: WAY[0][1], waypoint: 0, on: false };
-  const actors = [{ x: 0, y: 0.8, z: 0, radius: 1.5 }];
-  let attached = false;
-  const disposeObject = (object) => {
-    object.traverse((child) => {
-      child.geometry?.dispose?.();
-    });
-  };
-  const clearGroup = (g) => {
-    for (const child of [...g.children]) {
-      g.remove(child);
-      disposeObject(child);
-      child.material?.dispose?.();
-    }
-  };
-  const ensure = () => {
-    if (attached) return;
-    attached = true;
-    scenery = buildScenery(T);
-    const body = T.CapsuleGeometry ? new T.CapsuleGeometry(0.28, 1, 4, 10) : new T.CylinderGeometry(0.28, 0.28, 1.56, 10);
-    actor = new THREE.Mesh(body, new THREE.MeshStandardMaterial({ color: 14254635, roughness: 0.7 }));
-    actor.castShadow = true;
-    actor.position.set(walker.x, 0.78, walker.z);
-    actor.visible = false;
-    group.add(scenery, dynamic, colliders, actor);
-    parent.add(group);
-  };
-  const blocked = (x, z) => {
-    if (x < 0.55 || x > LOT.W - 0.55 || z < 0.55 || z > LOT.D - 0.55) return true;
-    if (x > HOUSE.x0 - 0.4 && x < HOUSE.x1 + 0.4 && z > HOUSE.z0 - 0.4 && z < HOUSE.z1 + 0.4) return true;
-    if (data) {
-      for (const c of data.colliders) {
-        const dx = x - c.x;
-        const dz = z - c.z;
-        const r = c.r + 0.3;
-        if (dx * dx + dz * dz < r * r) return true;
-      }
-    }
-    return false;
-  };
-  return {
-    group,
-    get stats() {
-      return stats;
-    },
-    get planted() {
-      return lotObject !== null;
-    },
-    get walking() {
-      return walker.on;
-    },
-    get position() {
-      return { x: walker.x, z: walker.z };
-    },
-    /** Plants the lot with the settings (replaces the one standing). */
-    plant(settings) {
-      ensure();
-      if (lotObject) {
-        dynamic.remove(lotObject);
-        disposeObject(lotObject);
-        lotObject = null;
-      }
-      clearGroup(colliders);
-      const { placements, used } = scatterLot(sdk, species, settings.seed);
-      const t0 = Date.now();
-      data = sdk.buildLot(placements, (id) => species.toSpec(id), { seed: `quintal-${settings.seed}`, quality: settings.quality, lod: settings.lod, condition: settings.condition, season: settings.season });
-      const buildMs = Date.now() - t0;
-      lotObject = sdk.createLotObject(THREE, data, materials);
-      lotObject.traverse((c) => {
-        if (c.isMesh) {
-          c.castShadow = true;
-          c.receiveShadow = true;
-        }
-      });
-      dynamic.add(lotObject);
-      for (const c of data.colliders) {
-        const m = new THREE.Mesh(new T.CylinderGeometry(c.r, c.r, c.h, 14, 1, true), new THREE.MeshBasicMaterial({ color: c.damage ? 16742938 : 15017245, wireframe: true }));
-        m.position.set(c.x, c.h / 2, c.z);
-        colliders.add(m);
-      }
-      stats = { triangles: data.triangleCount, plants: data.plantCount, colliders: data.colliders.length, meshes: Object.keys(data.meshes).length, lod: data.lodCounts, buildMs, species: used.size };
-      return stats;
-    },
-    /** The colliders of the lot as wire cylinders. */
-    showColliders(on) {
-      colliders.visible = on;
-    },
-    /** Starts or stops the walker that crosses the lot along `WAY`, bending the plants. */
-    setWalker(on) {
-      ensure();
-      walker.on = on;
-      actor.visible = on;
-      if (!on) {
-        actors[0].radius = 0;
-        materials.setActors(actors);
-      } else actors[0].radius = 1.5;
-    },
-    step(dt) {
-      if (!attached || !walker.on) return;
-      const target = WAY[walker.waypoint];
-      const ddx = target[0] - walker.x;
-      const ddz = target[1] - walker.z;
-      const d = Math.hypot(ddx, ddz);
-      let dx = 0;
-      let dz = 0;
-      if (d < 0.25) walker.waypoint = (walker.waypoint + 1) % WAY.length;
-      else {
-        dx = ddx / d;
-        dz = ddz / d;
-      }
-      if (dx || dz) {
-        const sp = 2 * dt;
-        const nx = walker.x + dx * sp;
-        const nz = walker.z + dz * sp;
-        if (!blocked(nx, walker.z)) walker.x = nx;
-        if (!blocked(walker.x, nz)) walker.z = nz;
-        if (blocked(nx, nz)) walker.waypoint = (walker.waypoint + 1) % WAY.length;
-        actor.rotation.y = Math.atan2(dx, dz);
-      }
-      actor.position.set(walker.x, 0.78, walker.z);
-      const a = actors[0];
-      a.x = origin[0] + walker.x;
-      a.z = origin[1] + walker.z;
-      a.y = 0.8;
-      materials.setActors(actors);
-    },
-    /** Takes the lot, the walker and the scenery away. */
-    clear() {
-      if (walker.on) this.setWalker(false);
-      if (lotObject) {
-        dynamic.remove(lotObject);
-        disposeObject(lotObject);
-        lotObject = null;
-      }
-      clearGroup(colliders);
-      if (attached) {
-        parent.remove(group);
-        clearGroup(group);
-        attached = false;
-        scenery = null;
-        actor = null;
-      }
-      data = null;
-      stats = null;
-      walker.x = WAY[0][0];
-      walker.z = WAY[0][1];
-      walker.waypoint = 0;
-    }
-  };
-}
-
-// src/test-area/plants.ts
-import { markKitOrigin } from "@adatechnology/game-contracts";
-var PLANT_SEED = 3;
-var PLANT_DEFS = [
-  { id: "mango_tree", kind: "tree", sway: true },
-  // young mango trees (same species, thin trunk): the 15 and 30 cm trunks on which the SDK documents the number of axe swings
-  { id: "mango_young_15", base: "mango_tree", kind: "tree", sway: true, over: { height: 1.7, trunkRadius: 0.1, crownRadius: 1 }, name: ["Mangueira jovem (tronco de 15 cm)", "Young mango tree (15 cm trunk)"] },
-  { id: "mango_young_30", base: "mango_tree", kind: "tree", sway: true, over: { height: 1.7, trunkRadius: 0.17, crownRadius: 1.2 }, name: ["Mangueira jovem (tronco de 30 cm)", "Young mango tree (30 cm trunk)"] },
-  { id: "yellow_ipe", kind: "tree", sway: true },
-  { id: "coconut_palm", kind: "tree", sway: true },
-  { id: "banana_with_bunch", kind: "tree", sway: true },
-  { id: "araucaria", kind: "tree", sway: true },
-  { id: "dead_tree", kind: "tree", sway: true, condition: "dead" },
-  { id: "hibiscus_shrub", kind: "shrub", sway: true },
-  { id: "boxwood_hedge", kind: "hedge", sway: true, segments: 4 },
-  { id: "rose_bush_red", kind: "shrub", sway: true },
-  { id: "sunflower", kind: "flower", sway: true },
-  { id: "mandacaru", kind: "cactus", sway: false },
-  { id: "prickly_pear", kind: "cactus", sway: false },
-  { id: "crown_cactus", kind: "cactus", sway: false },
-  { id: "potted_fern", kind: "pot", sway: true, movable: true },
-  { id: "potted_cactus", kind: "pot", sway: false, movable: true },
-  { id: "lawn_tuft", kind: "tuft", sway: true }
-];
-var sanitize = (s) => String(s).toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-var FILL = { green_wood: 0.5, wood_soft: 0.5, foliage: 0.035, flowers: 0.03, flesh_fruit: 0.8, ceramic: 0.2, soil: 0.7, cactus: 0.5 };
-var SWAY_AMPLITUDE = { trunk: 4e-3, branch: 0.012, crown: 0.03, fruit: 0.04, stem: 0.025, arm: 0, pad: 0, pot: 0, soil: 0 };
-function createPlants(sdk, species, materials, seed = PLANT_SEED) {
-  const defs = new Map(PLANT_DEFS.map((def) => [def.id, def]));
-  const specFor = (def) => {
-    const spec = species.toSpec(def.base ?? def.id);
-    return def.over ? { ...spec, ...def.over } : spec;
-  };
-  const cache = /* @__PURE__ */ new Map();
-  const plantFor = (def, segment) => {
-    const key = `${def.id}:${segment}`;
-    let plant = cache.get(key);
-    if (!plant) {
-      plant = sdk.generate(specFor(def), { seed: seed + segment * 7, ...def.condition ? { condition: def.condition } : {} });
-      cache.set(key, plant);
-    }
-    return plant;
-  };
-  function buildObject(THREE, def) {
-    const root = markKitOrigin(new THREE.Group(), { owner: "game-vegetation-three", kind: "plant", id: def.base ?? def.id });
-    root.name = def.id;
-    const segments = def.segments ?? 1;
-    let spacing = 0;
-    for (let s = 0; s < segments; s++) {
-      const plant = plantFor(def, s);
-      const object = sdk.createPlantObject(THREE, plant, materials(THREE), { separable: true });
-      const prefix = segments > 1 ? `s${s}_` : "";
-      const children = object.children.slice();
-      if (s === 0 && segments > 1) {
-        const g0 = children[0].geometry;
-        g0.computeBoundingBox();
-        spacing = (g0.boundingBox.max.x - g0.boundingBox.min.x) * 0.9;
-      }
-      for (const mesh of children) {
-        const piece = mesh.userData.destructionPart;
-        const bits = String(piece.id).split(":");
-        const id = prefix + sanitize(piece.id);
-        mesh.name = id;
-        const dx = (s - (segments - 1) / 2) * spacing;
-        const meta = {
-          id,
-          piece: piece.id,
-          kind: piece.kind,
-          sub: bits[1] ?? null,
-          base: prefix + sanitize(bits[0]),
-          parent: piece.parent ? prefix + sanitize(piece.parent) : null,
-          seg: s,
-          materialKey: piece.materialKey,
-          radius: piece.radius,
-          length: piece.length,
-          axis: piece.axis,
-          dx
-        };
-        mesh.userData.veg = meta;
-        mesh.position.x += dx;
-        mesh.castShadow = true;
-        root.add(mesh);
-      }
-      if (s === 0) {
-        root.userData.collider = plant.collider || null;
-        root.userData.thorny = !!plant.thorny;
-      }
-    }
-    root.userData.speciesId = def.id;
-    root.userData.separable = true;
-    root.userData.segments = segments;
-    return root;
-  }
-  function buildSpec(root, def) {
-    const meshes = root.children.filter((c) => c.isMesh && c.userData.veg);
-    const byId = {};
-    for (const m of meshes) byId[m.userData.veg.id] = m;
-    const parts = [];
-    for (const m of meshes) {
-      const v = m.userData.veg;
-      const g = m.geometry;
-      if (!g.boundingBox) g.computeBoundingBox();
-      const b = g.boundingBox;
-      const mn = [b.min.x + m.position.x, b.min.y + m.position.y, b.min.z + m.position.z];
-      const mx = [b.max.x + m.position.x, b.max.y + m.position.y, b.max.z + m.position.z];
-      const size = [Math.max(mx[0] - mn[0], 0.02), Math.max(mx[1] - mn[1], 0.02), Math.max(mx[2] - mn[2], 0.02)];
-      const c = [(mn[0] + mx[0]) / 2, (mn[1] + mx[1]) / 2, (mn[2] + mx[2]) / 2];
-      const material = m.userData.destructionMaterial;
-      const round = v.kind === "trunk" || v.kind === "pot";
-      let shape = round ? { kind: "cylinder", radius: Math.max(size[0], size[2]) / 2, height: size[1] } : { kind: "box", size };
-      let rotation = null;
-      if (!v.sub && (v.radius ?? 0) > 0 && (v.length ?? 0) > 0 && (v.kind === "trunk" || v.kind === "branch" || v.kind === "arm" || v.kind === "stem")) {
-        const rr = Math.max(v.radius, 0.01);
-        const ll = Math.max(v.length, 0.02);
-        shape = v.kind === "trunk" ? { kind: "cylinder", radius: rr, height: ll } : { kind: "box", size: [rr * 2, ll, rr * 2] };
-        if (v.axis) {
-          const ax = v.axis;
-          const tilt = Math.hypot(ax[0], ax[2]);
-          if (tilt > 0.02 && ax[1] > -0.99) rotation = [Math.atan2(ax[2], ax[1]), 0, -Math.asin(Math.max(-1, Math.min(1, ax[0])))];
-        }
-      }
-      const tags = [];
-      const p = { id: v.id, material, shape, position: c, tags };
-      if (rotation) p.rotation = rotation;
-      p.fill = v.sub === "spines" ? 0.02 : v.sub === "flowers" ? 0.01 : v.kind === "trunk" ? 0.8 : v.kind === "branch" ? 0.1 : v.kind === "arm" ? 0.12 : v.kind === "pad" ? 0.3 : FILL[material] ?? 0.5;
-      if (v.kind === "fruit" || v.sub === "wood") p.mass = 15;
-      if (v.kind === "trunk") {
-        p.grain = "y";
-        tags.push("trunk");
-      }
-      if (v.kind === "branch") tags.push("branch");
-      if (material === "foliage" || v.sub === "foliage") tags.push("leaf");
-      if (v.sub === "flowers") tags.push("flower");
-      if (v.sub === "spines") tags.push("thorns");
-      if (v.kind === "fruit") tags.push("fruit");
-      if (v.kind === "arm") tags.push("arm");
-      if (v.kind === "pad") tags.push("pad");
-      if (v.kind === "pot") {
-        p.mass = 2.4;
-        p.hp = 25;
-        tags.push("pot");
-      }
-      if (v.kind === "soil") {
-        p.mass = 3.2;
-        tags.push("soil");
-      }
-      if (def.kind === "pot" && v.kind === "stem" && !v.sub) p.mass = 0.4;
-      if (def.kind === "pot" && v.sub) p.mass = 0.05;
-      const isRoot = !v.parent && !v.sub && (v.kind === "trunk" || v.kind === "pad" || v.kind === "stem" && def.kind !== "pot");
-      if (isRoot && !def.movable) p.anchored = true;
-      parts.push(p);
-    }
-    const joints = [];
-    const seen = /* @__PURE__ */ new Set();
-    const add = (a, b, kind, extra) => {
-      if (!a || !b || a === b || !byId[a] || !byId[b]) return;
-      const id = `${a}~${b}`;
-      if (seen.has(id)) return;
-      seen.add(id);
-      joints.push({ id, a, b, kind, ...extra });
-    };
-    const firstOf = (seg, kind) => {
-      for (const m of meshes) {
-        const v = m.userData.veg;
-        if (v.seg === seg && v.kind === kind && !v.sub) return v.id;
-      }
-      return null;
-    };
-    for (const m of meshes) {
-      const v = m.userData.veg;
-      if (v.sub) {
-        add(v.base, v.id, "tie");
-        continue;
-      }
-      if (v.kind === "soil") {
-        add(v.parent, v.id, "resting");
-        continue;
-      }
-      if (v.parent) {
-        add(v.parent, v.id, "stem", v.kind === "arm" ? { strength: 60 } : void 0);
-        continue;
-      }
-      if (v.kind === "fruit") {
-        add(firstOf(v.seg, "crown") || firstOf(v.seg, "pad") || firstOf(v.seg, "stem") || firstOf(v.seg, "trunk"), v.id, "stem");
-        continue;
-      }
-      if (def.kind === "pot" && v.kind === "stem") add(firstOf(v.seg, "soil"), v.id, "tie");
-    }
-    const segments = def.segments ?? 1;
-    if (segments > 1) for (let s = 0; s + 1 < segments; s++) add(`s${s}_stem`, `s${s + 1}_stem`, "stem");
-    return { name: def.id, parts, joints, tags: ["plant"] };
-  }
-  function swayClip(def) {
-    const plant = plantFor(def, 0);
-    const segments = def.segments ?? 1;
-    const keys = [];
-    const N = 8;
-    const D = 4;
-    for (let k = 0; k <= N; k++) {
-      const ph = k / N * Math.PI * 2;
-      const parts = {};
-      for (let s = 0; s < segments; s++) {
-        const prefix = segments > 1 ? `s${s}_` : "";
-        for (const pc of plant.pieces) {
-          const a = SWAY_AMPLITUDE[pc.kind] || 0;
-          if (!a) continue;
-          if (pc.kind === "stem" && /(^|:)wood$/.test(pc.id)) continue;
-          if (def.kind === "pot" && pc.kind === "stem" && pc.id.indexOf(":") < 0 && def.id === "potted_cactus") continue;
-          const f = pc.id.indexOf(":flowers") > 0 ? 1.6 : 1;
-          parts[prefix + sanitize(pc.id)] = { rotation: [Math.sin(ph + s) * a * f * 0.6, 0, Math.sin(ph * 1 + 0.7 + s) * a * f] };
-        }
-      }
-      keys.push({ t: k / N * D, parts: k === 0 || k === N ? {} : parts });
-    }
-    return { id: "sway", duration: D, keys, events: [{ t: 0.2, type: "sound", data: { key: "leaves_rustle" } }] };
-  }
-  function items(locale, defsToUse = PLANT_DEFS) {
-    const loc = String(locale || "pt-BR").toLowerCase().indexOf("en") === 0 ? "en" : "pt-BR";
-    return defsToUse.map((def) => {
-      const item = {
-        id: def.id,
-        name: def.name ? def.name[loc === "en" ? 1 : 0] : species.name(def.base ?? def.id, loc),
-        build: (THREE) => buildObject(THREE, def),
-        spec: (root) => {
-          const spec = buildSpec(root, def);
-          root.userData.vegSpec = spec;
-          return spec;
-        },
-        movable: !!def.movable
-      };
-      if (def.sway) item.animations = [swayClip(def)];
-      return item;
-    });
-  }
-  return { defs, specFor, plantFor, buildObject, buildSpec, swayClip, items };
-}
-
-// src/test-area/scenarios.ts
-function createScenarios(locale) {
-  const en = String(locale || "pt-BR").toLowerCase().indexOf("en") === 0;
-  const L = (pt, e) => en ? e : pt;
-  const yn = (b) => b ? L("sim", "yes") : L("n\xE3o", "no");
-  const specOf = (so) => so.root.userData.vegSpec;
-  const partSpec = (so, pid) => specOf(so).parts.filter((p) => p.id === pid)[0];
-  const world = (so, local) => {
-    const r = so.root;
-    return [r.position.x + local[0], r.position.y + local[1], r.position.z + local[2]];
-  };
-  const norm = (v) => {
-    const l = Math.hypot(v[0], v[1], v[2]) || 1;
-    return [v[0] / l, v[1] / l, v[2] / l];
-  };
-  const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
-  const DIRS = [[0, 0, -1], [1, 0, 0], [-1, 0, 0], [0, 0, 1], [0.7, 0, -0.7], [-0.7, 0, -0.7], [0.7, 0, 0.7], [-0.7, 0, 0.7], [0, -1, 0]];
-  const center = (so, pid) => world(so, partSpec(so, pid).position);
-  const aim = (room, so, target, standoff, opt = {}) => {
-    let best = null;
-    for (const dir of DIRS) {
-      const d = norm(dir);
-      const origin = [target[0] - d[0] * standoff, target[1] - d[1] * standoff, target[2] - d[2] * standoff];
-      if (origin[1] < 0.25) continue;
-      const hit = room.world.raycast(origin, d, standoff + (opt.beyond == null ? 0.6 : opt.beyond));
-      if (!hit || hit.object !== so.objectId) continue;
-      let score = dist(hit.point, target);
-      if (opt.joint) {
-        const nj = room.world.nearestJoint(so.objectId, hit.point, opt.jointRange || 0.45);
-        if (!nj || nj.id !== opt.joint) score += 20;
-      }
-      if (!best || score < best.score) best = { score, origin, target, hit };
-    }
-    if (!best) best = { score: 99, origin: [target[0], target[1], target[2] + standoff], target, hit: null };
-    room.look(best.origin, best.target);
-    return best;
-  };
-  const AIMDIRS = [[0, 0, -1], [0.7, 0, -0.7], [-0.7, 0, -0.7], [1, 0, 0], [-1, 0, 0], [0, -1, 0], [0.7, 0, 0.7], [-0.7, 0, 0.7], [0, 0, 1]];
-  const aimPart = (room, so, pidsIn, gap, at) => {
-    const pids = typeof pidsIn === "string" ? [pidsIn] : pidsIn;
-    let best = null;
-    for (const pid of pids) {
-      const c = at ? world(so, at) : center(so, pid);
-      for (const dir of AIMDIRS) {
-        const d = norm(dir);
-        const far = 8;
-        const origin = [c[0] - d[0] * far, c[1] - d[1] * far, c[2] - d[2] * far];
-        if (origin[1] < 0.3) continue;
-        const hit = room.world.raycast(origin, d, far + 3);
-        if (!hit || hit.object !== so.objectId || hit.part !== pid) continue;
-        const score = dist(hit.point, c);
-        if (!best || score < best.score) best = { score, d, hit, pid };
-      }
-    }
-    if (!best) best = { score: 99, d: [0, 0, -1], hit: { point: center(so, pids[0]) }, pid: pids[0] };
-    const H = best.hit.point;
-    const from = [H[0] - best.d[0] * gap, H[1] - best.d[1] * gap, H[2] - best.d[2] * gap];
-    if (from[1] < 0.3) from[1] = 0.3;
-    room.look(from, [H[0] + best.d[0] * 0.3, H[1] + best.d[1] * 0.3, H[2] + best.d[2] * 0.3]);
-    return { origin: from, point: H, found: best.score < 99, pid: best.pid };
-  };
-  const crownsOf = (so) => specOf(so).parts.filter((p) => /^(s\d+_)?crown\d*$/.test(p.id)).map((p) => p.id);
-  const jointPos = (so, jid) => {
-    const j = specOf(so).joints.filter((x) => x.id === jid)[0];
-    const a = partSpec(so, j.a);
-    const b = partSpec(so, j.b);
-    const box = (p) => {
-      const h = p.shape.kind === "box" ? p.shape.size.map((s) => s / 2) : [p.shape.radius, p.shape.height / 2, p.shape.radius];
-      const r = p.rotation || [0, 0, 0];
-      const cx = Math.cos(r[0]), sx = Math.sin(r[0]), cz = Math.cos(r[2]), sz = Math.sin(r[2]);
-      const mn = [Infinity, Infinity, Infinity];
-      const mx = [-Infinity, -Infinity, -Infinity];
-      for (let i = 0; i < 8; i++) {
-        const x = (i & 1 ? 1 : -1) * h[0], y = (i & 2 ? 1 : -1) * h[1], z = (i & 4 ? 1 : -1) * h[2];
-        const x1 = x * cz - y * sz, y1 = x * sz + y * cz;
-        const w = [x1, y1 * cx - z * sx, y1 * sx + z * cx];
-        for (let k = 0; k < 3; k++) {
-          mn[k] = Math.min(mn[k], p.position[k] + w[k]);
-          mx[k] = Math.max(mx[k], p.position[k] + w[k]);
-        }
-      }
-      return { min: mn, max: mx };
-    };
-    const A_ = box(a);
-    const B_ = box(b);
-    return world(so, [0, 1, 2].map((k) => (Math.max(A_.min[k], B_.min[k]) + Math.min(A_.max[k], B_.max[k])) / 2));
-  };
-  const lost = (p) => !p || p.status === "broken" || p.status === "ashes" || p.status === "melted";
-  const snap = (room, so, pid) => {
-    const st = room.world.snapshot(so.objectId);
-    const p = st && st.parts.filter((x) => x.id === pid)[0];
-    if (!p) return null;
-    return { status: p.status, hp: p.hp, maxHp: p.maxHp, temperature: p.temperature, burning: p.burning, char: p.char || 0, fuel: p.fuel, holes: (p.holes || []).length, material: p.material };
-  };
-  const logCount = (room, so, type) => room.log.entries({ type, objectId: so.objectId }).length;
-  const jointsOpened = (room, so) => {
-    let n = 0;
-    for (const e of room.log.entries({ type: "detach", objectId: so.objectId })) n += e.data && e.data.joints ? e.data.joints.length : 1;
-    for (const e of room.log.entries({ type: "fracture", objectId: so.objectId })) n += e.data && e.data.jointsOpened || 0;
-    return n;
-  };
-  const detachedJoint = (room, so, jid) => room.log.entries({ type: "detach", objectId: so.objectId }).some((e) => e.data && (e.data.joint === jid || (e.data.joints || []).indexOf(jid) >= 0));
-  const spawn = (room, id, x, z) => room.spawn(id, [x, 0, z], 0);
-  const split = (room, so) => {
-    const home = room.world.snapshot(so.objectId);
-    const loose = room.world.ids().filter((i) => /^obj_/.test(i)).map((i) => ({ id: i, st: room.world.snapshot(i) }));
-    const anchored = {};
-    for (const p of specOf(so).parts) if (p.anchored) anchored[p.id] = true;
-    const rooted = [];
-    for (const g of home.groups) if (g.some((pid) => anchored[pid])) for (const pid of g) rooted.push(pid);
-    const inLoose = (pid) => loose.some((o) => o.st.parts.some((p) => p.id === pid && !lost(p)));
-    const inHome = (pid) => home.parts.some((p) => p.id === pid && !lost(p));
-    return { home, loose, rooted, inLoose, inHome, sections: home.groups.length + loose.length };
-  };
-  const fell = (room, ctx, so, max) => {
-    take(room, "axe");
-    let swings = 0;
-    const h = partSpec(so, "trunk").shape.height;
-    for (let i = 0; i < max; i++) {
-      aimPart(room, so, "trunk", 0.5, [0, Math.min(0.9, h / 3), 0]);
-      room.use();
-      ctx.step(1.5);
-      swings++;
-      if (lost(room.world.part(so.objectId, "trunk"))) break;
-    }
-    ctx.step(5);
-    return { swings, trunk: snap(room, so, "trunk") };
-  };
-  const sc = (id, ptName, enName, run) => ({ id: `veg_${id}`, name: L(ptName, enName), run });
-  const pct = (x) => `${Math.round((x || 0) * 100)}%`;
-  const take = (room, id) => {
-    room.setTool(id);
-    room.waitUntilReady();
-  };
-  return [
-    // 1 ---------------------------------------------------------------------------------------------------------------
-    sc("axe_fells_crown", "Machado no tronco de 15 cm derruba a copa (8 a 15 golpes)", "Axe on a 15 cm trunk fells the crown (8 to 15 swings)", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mango_young_15", 0, -6);
-      const r = fell(room, ctx, so, 60);
-      const sp = split(room, so);
-      const crownGone = lost(room.world.part(so.objectId, "crown")) || !sp.inHome("crown") || sp.rooted.indexOf("crown") < 0;
-      const branches = specOf(so).parts.filter((p) => p.tags.indexOf("branch") >= 0).map((p) => p.id);
-      const branchesFree = branches.every((b) => sp.rooted.indexOf(b) < 0);
-      const detach = jointsOpened(room, so);
-      ctx.expect(r.trunk.status === "broken" && r.swings >= 8 && r.swings <= 15, L(`Machado no tronco de 15 cm (hp ${Math.round(r.trunk.maxHp)}): tronco ${r.trunk.status} depois de ${r.swings} golpes (esperado: broken em 8 a 15 golpes)`, `Axe on a 15 cm trunk (hp ${Math.round(r.trunk.maxHp)}): trunk ${r.trunk.status} after ${r.swings} swings (expected: broken in 8 to 15 swings)`), { swings: r.swings, status: r.trunk.status, maxHp: r.trunk.maxHp });
-      ctx.expect(sp.rooted.length === 0 && crownGone && branchesFree, L(`Nada da copa continua preso ao ch\xE3o: pe\xE7as ainda enraizadas ${sp.rooted.length}, copa solta ${yn(crownGone)}, ${branches.length} galhos soltos ${yn(branchesFree)} (esperado: 0, sim, sim)`, `Nothing of the crown stays rooted: rooted pieces ${sp.rooted.length}, crown free ${yn(crownGone)}, ${branches.length} branches free ${yn(branchesFree)} (expected: 0, yes, yes)`), { rooted: sp.rooted.length });
-      ctx.expect(detach > 0 && sp.loose.length > 0, L(`Registro: ${detach} soltura(s) de junta (as juntas se abrem quando o tronco se perde) e ${sp.loose.length} peda\xE7o(s) caindo como objeto pr\xF3prio (esperado: 1 ou mais de cada)`, `Log: ${detach} joint detach(es) (joints open when the trunk is lost) and ${sp.loose.length} piece(s) falling as their own object (expected: 1+ each)`), { detach, loose: sp.loose.length });
-    }),
-    sc("axe_fells_30cm", "Machado no tronco de 30 cm (25 a 40 golpes)", "Axe on a 30 cm trunk (25 to 40 swings)", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mango_young_30", 0, -6);
-      const r = fell(room, ctx, so, 90);
-      const sp = split(room, so);
-      ctx.expect(r.trunk.status === "broken" && r.swings >= 25 && r.swings <= 40, L(`Machado no tronco de 30 cm (hp ${Math.round(r.trunk.maxHp)}): tronco ${r.trunk.status} depois de ${r.swings} golpes (esperado: broken em 25 a 40 golpes)`, `Axe on a 30 cm trunk (hp ${Math.round(r.trunk.maxHp)}): trunk ${r.trunk.status} after ${r.swings} swings (expected: broken in 25 to 40 swings)`), { swings: r.swings, status: r.trunk.status, maxHp: r.trunk.maxHp });
-      ctx.expect(sp.rooted.length === 0, L(`\xC1rvore ca\xEDda: pe\xE7as ainda presas ao ch\xE3o ${sp.rooted.length} (esperado: 0)`, `Fallen tree: pieces still rooted ${sp.rooted.length} (expected: 0)`), { rooted: sp.rooted.length });
-    }),
-    sc("axe_cuts_branch_joint", "Machado passa pela junta tronco-galho", "Axe works through the trunk-branch joint", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mango_tree", 0, -6);
-      const jid = "trunk~branch1";
-      take(room, "axe");
-      let swings = 0;
-      let detached = false;
-      for (let i = 0; i < 60 && !detached; i++) {
-        aim(room, so, jointPos(so, jid), 0.5, { joint: jid, beyond: 0.3 });
-        room.use();
-        ctx.step(1.5);
-        swings++;
-        detached = detachedJoint(room, so, jid);
-      }
-      ctx.step(3);
-      const trunk = snap(room, so, "trunk");
-      const sp = split(room, so);
-      const branchOff = sp.inLoose("branch1") && !sp.inHome("branch1");
-      const restStays = sp.inHome("trunk") && sp.rooted.indexOf("trunk") >= 0;
-      ctx.expect(detached && branchOff, L(`Machado na junta ${jid}: galho solto ${yn(branchOff)} depois de ${swings} golpe(s), com o tronco ${trunk.status} (esperado: sim)`, `Axe on joint ${jid}: branch detached ${yn(branchOff)} after ${swings} swing(s), trunk ${trunk.status} (expected: yes)`), { swings });
-      ctx.expect(trunk.status !== "broken" && restStays, L(`A junta cedeu antes do tronco: tronco ${trunk.status}, tronco de p\xE9 e preso ao ch\xE3o ${yn(restStays)} (esperado: n\xE3o quebrado, sim)`, `The joint gave way before the trunk: trunk ${trunk.status}, trunk standing and rooted ${yn(restStays)} (expected: not broken, yes)`), {});
-    }),
-    sc("shot_cannot_fell", "Tiro de 9 mm n\xE3o derruba a \xE1rvore", "A 9 mm shot never fells a tree", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mango_young_15", 0, -6);
-      take(room, "pistol_9mm");
-      let shots = 0;
-      for (let i = 0; i < 30; i++) {
-        aimPart(room, so, "trunk", 2.5, [0, 0.5, 0]);
-        room.use();
-        ctx.step(0.4);
-        shots++;
-      }
-      const trunk = snap(room, so, "trunk");
-      const sp = split(room, so);
-      ctx.expect(trunk.status !== "broken" && trunk.hp > 0, L(`${shots} tiros de 9 mm no tronco de 15 cm: tronco ${trunk.status}, hp ${Math.round(trunk.hp)}/${Math.round(trunk.maxHp)} (esperado: n\xE3o quebrado)`, `${shots} 9 mm shots on the 15 cm trunk: trunk ${trunk.status}, hp ${Math.round(trunk.hp)}/${Math.round(trunk.maxHp)} (expected: not broken)`), { shots, hp: trunk.hp });
-      ctx.expect(sp.loose.length === 0 && sp.inHome("trunk") && sp.rooted.indexOf("crown") >= 0, L(`A \xE1rvore continua de p\xE9: peda\xE7os soltos ${sp.loose.length}, copa presa ao ch\xE3o ${yn(sp.rooted.indexOf("crown") >= 0)} (esperado: 0, sim)`, `The tree still stands: loose pieces ${sp.loose.length}, crown rooted ${yn(sp.rooted.indexOf("crown") >= 0)} (expected: 0, yes)`), {});
-    }),
-    // 2 ---------------------------------------------------------------------------------------------------------------
-    sc("saw_cuts_branch", "Serra no galho", "Saw on a branch", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "yellow_ipe", 0, -6);
-      const jid = "trunk~branch1";
-      take(room, "hacksaw");
-      aim(room, so, jointPos(so, jid), 0.45, { joint: jid });
-      room.use(4);
-      ctx.step(1);
-      const sp = split(room, so);
-      const movedBranch = sp.inLoose("branch1") && !sp.inHome("branch1");
-      const movedCrown = sp.inLoose("crown1");
-      const restStays = ["trunk", "branch0", "branch2", "branch3", "crown"].every((pid) => sp.inHome(pid) && sp.rooted.indexOf(pid) >= 0);
-      const detach = logCount(room, so, "detach");
-      ctx.expect(movedBranch && detach > 0, L(`Serra na junta tronco-galho 1: galho solto do tronco ${yn(movedBranch)}, ${detach} linha(s) de soltura no log (esperado: sim, 1)`, `Saw on the trunk-branch 1 joint: branch detached ${yn(movedBranch)}, ${detach} detach line(s) in the log (expected: yes, 1)`), { detach });
-      ctx.expect(movedCrown, L(`A folhagem do galho cortado foi junto: ${yn(movedCrown)} (esperado: sim)`, `The foliage of the cut branch went with it: ${yn(movedCrown)} (expected: yes)`), {});
-      ctx.expect(restStays, L(`O resto da \xE1rvore (tronco, outros galhos e copa) continua inteiro e preso ao ch\xE3o: ${yn(restStays)} (esperado: sim)`, `The rest of the tree (trunk, other branches, crown) stays whole and rooted: ${yn(restStays)} (expected: yes)`), {});
-    }),
-    // 3 ---------------------------------------------------------------------------------------------------------------
-    sc("lighter_ignites_foliage", "Isqueiro na folhagem pega fogo", "Lighter on the foliage catches fire", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mango_tree", 0, -6);
-      take(room, "lighter");
-      const a = aimPart(room, so, crownsOf(so), 0.08);
-      room.use(6);
-      const crown = snap(room, so, a.pid);
-      const lit = crown.burning || crown.temperature > 300;
-      let peak = 0;
-      let charMax = 0;
-      for (let t = 0; t < 18; t++) {
-        ctx.step(5);
-        for (const p of room.world.state(so.objectId).parts) {
-          if (p.material === "green_wood") {
-            peak = Math.max(peak, p.temperature);
-            charMax = Math.max(charMax, p.char || 0);
-          }
-        }
-      }
-      const st = room.world.state(so.objectId);
-      const burnt = st.parts.filter((p) => p.material === "foliage" && (p.burning || p.char > 0 || p.status === "ashes")).length;
-      ctx.expect(lit, L(`Isqueiro na copa: folhagem acesa ou acima de 300 \xB0C = ${yn(lit)} (${Math.round(crown.temperature)} \xB0C; esperado: sim)`, `Lighter on the crown: foliage lit or above 300 C = ${yn(lit)} (${Math.round(crown.temperature)} C; expected: yes)`), { temperature: crown.temperature });
-      ctx.expect(burnt > 0, L(`Depois de 90 s: ${burnt} pe\xE7a(s) de folhagem queimando, carbonizada(s) ou em cinza (esperado: 1 ou mais)`, `After 90 s: ${burnt} foliage piece(s) burning, charred or ash (expected: 1+)`), { burnt });
-      ctx.expect(peak > 150 || charMax > 0, L(`O fogo da folhagem passa para a madeira verde (tronco e galhos): pico de ${Math.round(peak)} \xB0C, carboniza\xE7\xE3o m\xE1xima ${pct(charMax)} (esperado: pico acima de 150 \xB0C ou carboniza\xE7\xE3o acima de 0; a madeira verde s\xF3 pega fogo acima de 400 \xB0C)`, `Foliage fire reaches the green wood (trunk and branches): peak ${Math.round(peak)} C, max char ${pct(charMax)} (expected: peak above 150 C or char above 0; green wood only ignites above 400 C)`), { peak, charMax });
-    }),
-    // 4 ---------------------------------------------------------------------------------------------------------------
-    sc("shot_strips_leaves", "Tiro na copa arranca folhas", "A shot into the crown strips leaves", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mango_tree", 0, -6);
-      take(room, "pistol_9mm");
-      const tgt = aimPart(room, so, crownsOf(so), 2.5).pid;
-      const before = snap(room, so, tgt);
-      for (let i = 0; i < 3; i++) {
-        aimPart(room, so, tgt, 2.5);
-        room.use();
-        ctx.step(0.6);
-      }
-      const crown = snap(room, so, tgt);
-      const leaves = room.log.entries({ type: "debris", objectId: so.objectId }).filter((e) => e.data && e.data.kind === "leaves").length;
-      const hurt = crown.hp < before.hp || crown.status === "broken";
-      ctx.expect(hurt && crown.status !== "intact", L(`Tr\xEAs tiros na copa: hp ${Math.round(before.hp)} para ${Math.round(crown.hp)}, estado ${crown.status} (esperado: hp menor, n\xE3o intacta)`, `Three shots into the crown: hp ${Math.round(before.hp)} to ${Math.round(crown.hp)}, status ${crown.status} (expected: lower hp, not intact)`), { hp: crown.hp });
-      ctx.expect(leaves > 0 || crown.holes > 0, L(`Folhas arrancadas: ${leaves} linha(s) de folhas voando, ${crown.holes} furo(s) na copa (esperado: 1 ou mais)`, `Leaves torn off: ${leaves} flying-leaf line(s), ${crown.holes} hole(s) in the crown (expected: 1+)`), { leaves, holes: crown.holes });
-    }),
-    // 5 ---------------------------------------------------------------------------------------------------------------
-    sc("shot_breaks_pot", "Tiros quebram o vaso e a terra se espalha", "Shots break the pot and the soil spills", (ctx) => {
-      const room = ctx.room;
-      const so = room.spawn("potted_fern", [0, 0, -4], 0);
-      take(room, "pistol_9mm");
-      let shots = 0;
-      for (let i = 0; i < 12; i++) {
-        const cur = snap(room, so, "pot");
-        if (!cur) break;
-        aimPart(room, so, "pot", 1.5);
-        room.use();
-        ctx.step(0.5);
-        shots++;
-        const after = snap(room, so, "pot");
-        if (after && (after.status === "broken" || after.hp <= 0)) break;
-      }
-      ctx.step(3);
-      const sp = split(room, so);
-      let potNow = snap(room, so, "pot");
-      for (const o of sp.loose) {
-        const q = o.st.parts.filter((x) => x.id === "pot")[0];
-        if (q) potNow = q;
-      }
-      const soilOut = sp.inLoose("soil") || !sp.inHome("soil");
-      const soilApart = !sp.home.groups.some((g) => g.indexOf("soil") >= 0 && g.indexOf("pot") >= 0);
-      const cracks = room.log.entries({ type: "crack", objectId: so.objectId }).length;
-      const dt = jointsOpened(room, so);
-      ctx.expect(!!potNow && (potNow.status === "broken" || potNow.hp <= 0) && shots >= 1 && shots <= 4, L(`Tiros no vaso: o vaso quebra: cer\xE2mica ${potNow && potNow.status} com hp ${potNow ? `${Math.round(potNow.hp)}/${Math.round(potNow.maxHp)}` : "?"} e ${cracks} trinca(s) depois de ${shots} tiro(s) de 9 mm (esperado: vaso quebrado em 1 a 4 tiros)`, `Shots into the pot: the pot breaks: ceramic ${potNow && potNow.status} with hp ${potNow ? `${Math.round(potNow.hp)}/${Math.round(potNow.maxHp)}` : "?"} and ${cracks} crack(s) after ${shots} 9 mm shot(s) (expected: pot broken in 1 to 4 shots)`), { status: potNow && potNow.status, shots, cracks });
-      ctx.expect(soilApart || soilOut, L(`A terra saiu do vaso e caiu junto com a planta: ${yn(soilApart || soilOut)} (esperado: sim)`, `The soil left the pot and fell with the plant: ${yn(soilApart || soilOut)} (expected: yes)`), {});
-      ctx.expect(dt > 0, L(`Registro: ${dt} soltura(s) de junta (esperado: 1 ou mais)`, `Log: ${dt} joint detach(es) (expected: 1+)`), { detach: dt });
-    }),
-    // 6 ---------------------------------------------------------------------------------------------------------------
-    sc("machete_arm", "Machete na junta do bra\xE7o do mandacaru", "Machete on the mandacaru arm joint", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "mandacaru", 0, -5);
-      take(room, "machete");
-      const arm = "arm0";
-      const jid = `stem~${arm}`;
-      let swings = 0;
-      let detached = false;
-      for (let i = 0; i < 40 && !detached; i++) {
-        aim(room, so, jointPos(so, jid), 0.55, { joint: jid, beyond: 0.3 });
-        room.use();
-        ctx.step(1.2);
-        swings++;
-        detached = detachedJoint(room, so, jid) || lost(room.world.part(so.objectId, arm));
-      }
-      ctx.step(3);
-      const a = snap(room, so, arm);
-      const sp = split(room, so);
-      const armOff = !a || a.status === "broken" || sp.inLoose(arm) && !sp.inHome(arm);
-      const stemOk = sp.inHome("stem") && sp.rooted.indexOf("stem") >= 0 && room.world.part(so.objectId, "stem").status !== "broken";
-      const spines = specOf(so).parts.filter((p) => p.tags.indexOf("thorns") >= 0);
-      const thorny = so.root.userData.thorny === true && spines.length > 0;
-      const spinesOff = !sp.rooted.some((pid) => pid.indexOf(`${arm}_spines`) === 0);
-      ctx.expect(armOff, L(`Machete na junta ${jid}: bra\xE7o ${a ? a.status : "solto como objeto pr\xF3prio"} depois de ${swings} golpe(s) (esperado: solto do caule pela junta)`, `Machete on joint ${jid}: arm ${a ? a.status : "loose as its own object"} after ${swings} swing(s) (expected: off the stem through the joint)`), { swings });
-      ctx.expect(stemOk, L(`O caule principal continua de p\xE9 e preso ao ch\xE3o: ${yn(stemOk)} (esperado: sim)`, `The main stem stays standing and rooted: ${yn(stemOk)} (expected: yes)`), {});
-      ctx.expect(thorny && spinesOff, L(`Espinhos: cacto marcado como espinhoso (userData.thorny, ${spines.length} pe\xE7as de espinho) ${yn(thorny)}, espinhos do bra\xE7o sa\xEDram junto ${yn(spinesOff)} (esperado: sim, sim)`, `Thorns: cactus flagged thorny (userData.thorny, ${spines.length} spine pieces) ${yn(thorny)}, the arm spines went with it ${yn(spinesOff)} (expected: yes, yes)`), { spines: spines.length });
-    }),
-    // 7 ---------------------------------------------------------------------------------------------------------------
-    sc("pad_pulled", "Palma arrancada", "Prickly pear pad pulled off", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "prickly_pear", 0, -4);
-      const jid = "pad0~pad1";
-      take(room, "utility_knife");
-      aim(room, so, jointPos(so, jid), 0.25, { joint: jid, beyond: 0.3 });
-      room.use(1.7);
-      ctx.step(1);
-      const sp = split(room, so);
-      const padOff = sp.inLoose("pad1") && !sp.inHome("pad1");
-      const childWith = sp.inLoose("pad3");
-      const spinesWith = sp.inLoose("pad1_spines");
-      const motherOk = sp.inHome("pad0") && sp.rooted.indexOf("pad0") >= 0 && sp.inHome("pad2");
-      ctx.expect(padOff, L(`Raquete 1 cortada da planta-m\xE3e na junta ${jid}: ${yn(padOff)} (esperado: sim)`, `Pad 1 cut off the mother plant at joint ${jid}: ${yn(padOff)} (expected: yes)`), {});
-      ctx.expect(childWith && spinesWith, L(`A raquete filha (3) e os espinhos da raquete 1 v\xE3o junto: ${yn(childWith && spinesWith)} (esperado: sim)`, `The child pad (3) and the spines of pad 1 go with it: ${yn(childWith && spinesWith)} (expected: yes)`), {});
-      ctx.expect(motherOk, L(`A planta-m\xE3e (raquetes 0 e 2) fica presa ao ch\xE3o: ${yn(motherOk)} (esperado: sim)`, `The mother plant (pads 0 and 2) stays rooted: ${yn(motherOk)} (expected: yes)`), {});
-    }),
-    // 8 ---------------------------------------------------------------------------------------------------------------
-    sc("dead_burns_faster", "\xC1rvore morta queima mais r\xE1pido que viva", "A dead tree burns faster than a living one", (ctx) => {
-      const room = ctx.room;
-      const dead = spawn(room, "dead_tree", -4, -6);
-      const live = spawn(room, "mango_tree", 4, -6);
-      take(room, "lighter");
-      for (const so of [dead, live]) {
-        aimPart(room, so, "trunk", 0.08, [0, 0.8, 0]);
-        room.use(8);
-      }
-      const d0 = snap(room, dead, "trunk");
-      const l0 = snap(room, live, "trunk");
-      ctx.step(120);
-      const d = snap(room, dead, "trunk");
-      const l = snap(room, live, "trunk");
-      const score = (p) => p ? Math.max(p.char, p.burning ? 0.01 : 0, (p.temperature - 20) / 2e3) : 0;
-      ctx.expect(d0.material === "wood_soft" && l0.material === "green_wood", L(`Materiais do tronco: \xE1rvore morta ${d0.material}, viva ${l0.material} (esperado: wood_soft, green_wood)`, `Trunk materials: dead tree ${d0.material}, living ${l0.material} (expected: wood_soft, green_wood)`), { dead: d0.material, live: l0.material });
-      ctx.expect(score(d) > score(l), L(`Depois de 8 s de isqueiro e 120 s de espera: morta queimando ${yn(d.burning)}, ${Math.round(d.temperature)} \xB0C, carboniza\xE7\xE3o ${pct(d.char)}; viva queimando ${yn(l.burning)}, ${Math.round(l.temperature)} \xB0C, carboniza\xE7\xE3o ${pct(l.char)} (esperado: a morta mais queimada)`, `After 8 s of lighter and 120 s of waiting: dead burning ${yn(d.burning)}, ${Math.round(d.temperature)} C, char ${pct(d.char)}; living burning ${yn(l.burning)}, ${Math.round(l.temperature)} C, char ${pct(l.char)} (expected: dead burns more)`), { dead: score(d), live: score(l) });
-    }),
-    // 9 ---------------------------------------------------------------------------------------------------------------
-    sc("hedge_cut_pieces", "Cerca viva cortada em partes", "Hedge cut into sections", (ctx) => {
-      const room = ctx.room;
-      const so = spawn(room, "boxwood_hedge", 0, -5);
-      take(room, "hacksaw");
-      for (const jid of ["s0_stem~s1_stem", "s2_stem~s3_stem"]) {
-        aim(room, so, jointPos(so, jid), 0.45, { joint: jid });
-        room.use(1.7);
-        ctx.step(0.3);
-      }
-      ctx.step(1);
-      const sp = split(room, so);
-      const all = [...sp.home.parts];
-      for (const o of sp.loose) all.push(...o.st.parts);
-      const alive = all.filter((p) => !lost(p)).length;
-      const total = specOf(so).parts.length;
-      ctx.expect(sp.sections === 3, L(`Duas serradas na cerca viva: ${sp.sections} parte(s) separada(s) (esperado: 3)`, `Two saw cuts in the hedge: ${sp.sections} separate section(s) (expected: 3)`), { sections: sp.sections });
-      ctx.expect(alive === total, L(`Nenhuma se\xE7\xE3o foi destru\xEDda, s\xF3 separada: ${alive} de ${total} pe\xE7as inteiras (esperado: todas)`, `No section was destroyed, only separated: ${alive} of ${total} pieces intact (expected: all)`), { alive, total });
-    }),
-    // 10 --------------------------------------------------------------------------------------------------------------
-    sc("walk_on_grass", "Pisar na grama n\xE3o colide", "Walking on grass does not collide", (ctx) => {
-      const room = ctx.room;
-      const tuft = spawn(room, "lawn_tuft", 0, -3);
-      const tree = spawn(room, "mango_tree", 4, -3);
-      const noBlock = !tuft.root.userData.collider;
-      const treeBlock = !!(tree.root.userData.collider && tree.root.userData.collider.kind);
-      ctx.expect(noBlock && treeBlock, L(`Colisor do SDK: touceira ${noBlock ? "nenhum" : "tem"}, tronco da mangueira ${treeBlock ? "tem" : "nenhum"} (esperado: nenhum, tem)`, `SDK collider: tuft ${noBlock ? "none" : "has one"}, mango trunk ${treeBlock ? "has one" : "none"} (expected: none, has one)`), {});
-      room.look([0, 1.7, -0.5], [0, 1.7, -6]);
-      const before = room.camera.position.z;
-      room.walk([0, 1.7, -6], 3);
-      ctx.step(3.2);
-      const after = room.camera.position.z;
-      const tp = snap(room, tuft, "stem");
-      ctx.expect(after < -3.3 && !!tp && tp.status === "intact", L(`Andando para a frente (room.walk): z foi de ${before.toFixed(1)} a ${after.toFixed(1)}, atravessou a touceira ${yn(after < -3.3)}, touceira ${tp && tp.status} (esperado: atravessou, intacta)`, `Walking forward (room.walk): z went from ${before.toFixed(1)} to ${after.toFixed(1)}, crossed the tuft ${yn(after < -3.3)}, tuft ${tp && tp.status} (expected: crossed, intact)`), { before, after });
-    })
-  ];
-}
-
-// src/test-area/text.ts
-var TEXT = {
-  en: {
-    group: "Trees, plants and flowers",
-    name: "Vegetation",
-    controls: { seed: "Lot seed", quality: "Lot quality", lod: "Lot detail (LOD)", condition: "Condition", season: "Season", wind: "Wind", gust: "Gusts" },
-    hints: {
-      seed: "The seed of the nursery lot: the same seed plants the same yard",
-      quality: "High: every plant at the detail below. Game: one level for all plants and small ones cheaper, with a triangle budget",
-      lod: "Level of detail of the plants of the lot (0 the most detailed)",
-      condition: "How the lot plants look: healthy, dry, dead or overgrown (decides green or dry wood for the destruction)",
-      season: "Season of the lot (flowers and leaf colours)",
-      wind: "Strength of the wind that sways the leaves, flowers and grass",
-      gust: "Slowly varying extra push on top of the wind"
-    },
-    options: {
-      quality: { high: "High", game: "Game" },
-      lod: { "0": "LOD 0", "1": "LOD 1", "2": "LOD 2" },
-      condition: { healthy: "Healthy", dry: "Dry", dead: "Dead", overgrown: "Overgrown" },
-      season: { spring: "Spring", summer: "Summer", autumn: "Autumn", winter: "Winter" }
-    },
-    actions: { plant_lot: "Plant the nursery lot", clear_lot: "Remove the nursery lot", toggle_walker: "Start or stop the walker" },
-    layers: { colliders: "Colliders (trunks and cactus bodies)", piece_boxes: "Boxes of the pieces", wood_axes: "Wood axes (radius, length, axis)" },
-    metrics: { plants: "Plants placed", pieces: "Pieces", triangles: "Triangles", draw_calls: "Draw calls", lot_triangles: "Lot triangles", lot_plants: "Lot plants", lot_colliders: "Lot colliders", lot_lod0: "Lot plants at LOD 0", lot_lod1: "Lot plants at LOD 1", lot_lod2: "Lot plants at LOD 2", lot_ms: "Lot build time" },
-    lot: { planted: "Nursery lot planted: {0} plants, {1} triangles, {2} colliders", cleared: "Nursery lot removed", walker_on: "The walker crosses the lot and bends the plants", walker_off: "The walker stopped" }
-  },
-  "pt-BR": {
-    group: "\xC1rvores, plantas e flores",
-    name: "Vegeta\xE7\xE3o",
-    controls: { seed: "Semente do canteiro", quality: "Qualidade do canteiro", lod: "Detalhe do canteiro (LOD)", condition: "Condi\xE7\xE3o", season: "Esta\xE7\xE3o", wind: "Vento", gust: "Rajadas" },
-    hints: {
-      seed: "A semente do canteiro: a mesma semente planta o mesmo quintal",
-      quality: "Alta: todas as plantas no detalhe abaixo. Jogo: um n\xEDvel para todas e as pequenas mais baratas, com or\xE7amento de tri\xE2ngulos",
-      lod: "N\xEDvel de detalhe das plantas do canteiro (0 o mais detalhado)",
-      condition: "Como ficam as plantas do canteiro: saud\xE1vel, seca, morta ou malcuidada (decide madeira verde ou seca na destrui\xE7\xE3o)",
-      season: "Esta\xE7\xE3o do canteiro (flores e cor das folhas)",
-      wind: "For\xE7a do vento que balan\xE7a folhas, flores e grama",
-      gust: "Empurr\xE3o extra que varia devagar, somado ao vento"
-    },
-    options: {
-      quality: { high: "Alta", game: "Jogo" },
-      lod: { "0": "LOD 0", "1": "LOD 1", "2": "LOD 2" },
-      condition: { healthy: "Saud\xE1vel", dry: "Seca", dead: "Morta", overgrown: "Malcuidada" },
-      season: { spring: "Primavera", summer: "Ver\xE3o", autumn: "Outono", winter: "Inverno" }
-    },
-    actions: { plant_lot: "Plantar o canteiro", clear_lot: "Tirar o canteiro", toggle_walker: "Ligar ou desligar o caminhante" },
-    layers: { colliders: "Colisores (troncos e corpos de cacto)", piece_boxes: "Caixas das pe\xE7as", wood_axes: "Eixos da madeira (raio, comprimento, eixo)" },
-    metrics: { plants: "Plantas postas", pieces: "Pe\xE7as", triangles: "Tri\xE2ngulos", draw_calls: "Chamadas de desenho", lot_triangles: "Tri\xE2ngulos do canteiro", lot_plants: "Plantas do canteiro", lot_colliders: "Colisores do canteiro", lot_lod0: "Plantas do canteiro em LOD 0", lot_lod1: "Plantas do canteiro em LOD 1", lot_lod2: "Plantas do canteiro em LOD 2", lot_ms: "Tempo de montagem do canteiro" },
-    lot: { planted: "Canteiro plantado: {0} plantas, {1} tri\xE2ngulos, {2} colisores", cleared: "Canteiro retirado", walker_on: "O caminhante cruza o canteiro e dobra as plantas", walker_off: "O caminhante parou" }
-  }
-};
-var fill = (template, ...values) => template.replace(/\{(\d+)\}/g, (_m, i) => String(values[Number(i)]));
-
-// src/test-area/module.ts
-var VEGETATION_AREA_ID = "vegetation";
-var VEGETATION_ITEM_IDS = PLANT_DEFS.map((def) => def.id);
-var VEGETATION_SCENARIO_IDS = [
-  "veg_axe_fells_crown",
-  "veg_axe_fells_30cm",
-  "veg_axe_cuts_branch_joint",
-  "veg_shot_cannot_fell",
-  "veg_saw_cuts_branch",
-  "veg_lighter_ignites_foliage",
-  "veg_shot_strips_leaves",
-  "veg_shot_breaks_pot",
-  "veg_machete_arm",
-  "veg_pad_pulled",
-  "veg_dead_burns_faster",
-  "veg_hedge_cut_pieces",
-  "veg_walk_on_grass"
-];
-var defaultSdk = () => ({ ...GameVegetationMain, ...GameVegetationAdapter });
-var AXIS_COLOURS = { trunk: 14254635, branch: 15057019, arm: 7327599, stem: 7327639, pad: 7321551 };
-function createVegetationTestModule(options = {}) {
-  const locale = options.locale ?? "pt-BR";
-  const text = TEXT[locale.toLowerCase().startsWith("en") ? "en" : "pt-BR"];
-  const sdk = options.GameVegetation ?? defaultSdk();
-  const species = options.GameVegetationSpecies ?? GameVegetationSpeciesMain;
-  let mats = options.materials ?? null;
-  let three = null;
-  let host = null;
-  const materials = (THREE) => {
-    if (!mats) mats = sdk.createVegetationMaterials(THREE ?? three);
-    return mats;
-  };
-  const plants = createPlants(sdk, species, (THREE) => materials(THREE), options.seed ?? PLANT_SEED);
-  const placed = /* @__PURE__ */ new Map();
-  const settings = { seed: 1, quality: "high", lod: 0, condition: "healthy", season: "spring", wind: 0.35, gust: 0.15 };
-  let nursery = null;
-  let clock = 0;
-  let helpersShown = "";
-  const item = (base) => ({
-    ...base,
-    build: (THREE) => {
-      three = THREE;
-      const root = base.build(THREE);
-      placed.set(root.uuid, { root, helpers: [] });
-      return root;
-    }
-  });
-  const clearHelpers = () => {
-    for (const entry of placed.values()) {
-      discardObject3D(entry.helpers);
-      entry.helpers = [];
-    }
-    helpersShown = "";
-  };
-  const boxKey = () => `${host?.bench?.layer("colliders")}|${host?.bench?.layer("piece_boxes")}|${host?.bench?.layer("wood_axes")}|${placed.size}`;
-  const refreshLayers = () => {
-    if (!host?.bench || !three) return;
-    clearHelpers();
-    nursery?.showColliders(host.bench.layer("colliders"));
-    for (const entry of placed.values()) {
-      const root = entry.root;
-      if (!root.parent) continue;
-      const mark = (helper) => {
-        helper.userData.helper = true;
-        root.add(helper);
-        entry.helpers.push(helper);
-      };
-      if (host.bench.layer("colliders") && root.userData.collider && root.userData.collider.kind) {
-        const c = root.userData.collider;
-        const wire = new three.Mesh(new (shapeGeometries2(three)).CylinderGeometry(c.radius, c.radius, c.height, 14, 1, true), new three.MeshBasicMaterial({ color: root.userData.thorny ? 16742938 : 15017245, wireframe: true }));
-        wire.position.set(0, c.height / 2, 0);
-        mark(wire);
-      }
-      for (const mesh of root.children) {
-        const v = mesh.userData?.veg;
-        if (!v || !mesh.geometry) continue;
-        if (host.bench.layer("piece_boxes")) {
-          mesh.geometry.computeBoundingBox();
-          const box = mesh.geometry.boundingBox.clone().translate(mesh.position);
-          mark(new three.Box3Helper(box, 6737151));
-        }
-        if (host.bench.layer("wood_axes") && v.radius !== void 0 && v.length !== void 0 && v.axis && !v.sub) {
-          const base = pieceBase(root, v);
-          if (base) {
-            const from = new three.Vector3(base[0] + v.dx, base[1], base[2]);
-            const to = from.clone().add(new three.Vector3(v.axis[0], v.axis[1], v.axis[2]).multiplyScalar(v.length));
-            const line = new three.Line(new three.BufferGeometry().setFromPoints([from, to]), new three.LineBasicMaterial({ color: AXIS_COLOURS[v.kind] ?? 16777215 }));
-            mark(line);
-          }
-        }
-      }
-    }
-    helpersShown = boxKey();
-  };
-  const pieceBase = (root, v) => {
-    const mesh = root.children.find((c) => c.userData?.veg?.id === v.id);
-    const base = mesh?.userData?.destructionPart?.base;
-    return Array.isArray(base) ? base : null;
-  };
-  const nurseryOf = () => {
-    if (!host || !three) return null;
-    if (!nursery) nursery = createNursery(sdk, species, three, materials(three), host.scene, options.nurseryOrigin ?? [-6, 14]);
-    return nursery;
-  };
-  const plantLot = () => {
-    const n = nurseryOf();
-    if (!n || !host) return;
-    const stats = n.plant(settings);
-    n.showColliders(Boolean(host.bench?.layer("colliders")));
-    host.log(fill(text.lot.planted, stats.plants, stats.triangles, stats.colliders), { plants: stats.plants, triangles: stats.triangles });
-  };
-  const replant = () => {
-    if (nursery?.planted) plantLot();
-  };
-  const applyWind = () => {
-    if (mats) mats.setWind({ strength: settings.wind, gust: settings.gust });
-  };
-  const onChange = (change) => {
-    if (change.kind === "layer") return refreshLayers();
-    if (change.kind === "action") {
-      if (change.id === "plant_lot") plantLot();
-      else if (change.id === "clear_lot") {
-        nursery?.clear();
-        host?.log(text.lot.cleared);
-      } else if (change.id === "toggle_walker") {
-        const n = nurseryOf();
-        if (!n) return;
-        if (!n.planted) plantLot();
-        n.setWalker(!n.walking);
-        host?.log(n.walking ? text.lot.walker_on : text.lot.walker_off);
-      }
-      return;
-    }
-    switch (change.id) {
-      case "seed":
-        settings.seed = Number(change.value);
-        replant();
-        break;
-      case "quality":
-        settings.quality = String(change.value);
-        replant();
-        break;
-      case "lod":
-        settings.lod = Number(change.value);
-        replant();
-        break;
-      case "condition":
-        settings.condition = String(change.value);
-        replant();
-        break;
-      case "season":
-        settings.season = String(change.value);
-        replant();
-        break;
-      case "wind":
-        settings.wind = Number(change.value);
-        applyWind();
-        break;
-      case "gust":
-        settings.gust = Number(change.value);
-        applyWind();
-        break;
-      default:
-        break;
-    }
-  };
-  const frame = (dt) => {
-    clock += dt;
-    if (mats) mats.update(clock);
-    for (const [id, entry] of placed) if (!entry.root.parent) placed.delete(id);
-    if (host?.bench && boxKey() !== helpersShown && (host.bench.layer("colliders") || host.bench.layer("piece_boxes") || host.bench.layer("wood_axes") || helpersShown !== "")) refreshLayers();
-    nursery?.step(dt);
-  };
-  const count = () => {
-    let drawCalls = 0;
-    let triangles = 0;
-    let pieces = 0;
-    for (const entry of placed.values()) {
-      entry.root.traverse((mesh) => {
-        if (!mesh.isMesh || mesh.userData.helper) return;
-        for (let p = mesh; p; p = p.parent) if (p.visible === false) return;
-        drawCalls += 1;
-        if (mesh.userData.veg) pieces += 1;
-        const g = mesh.geometry;
-        triangles += (g.index ? g.index.count : g.attributes.position.count) / 3;
-      });
-    }
-    return { drawCalls, triangles: Math.round(triangles), pieces };
-  };
-  const lotCalls = () => {
-    let calls = 0;
-    nursery?.group.traverse((o) => {
-      if (o.isMesh && o.visible) calls += 1;
-    });
-    return calls;
-  };
-  return {
-    id: VEGETATION_AREA_ID,
-    name: text.name,
-    ground: { surface: "lawn" },
-    group: text.group,
-    get placed() {
-      return placed;
-    },
-    itemIds: VEGETATION_ITEM_IDS,
-    materials,
-    tick: (t) => {
-      if (mats) mats.update(t);
-    },
-    items: (loc) => plants.items(loc || locale).map(item),
-    scenarios: (loc) => createScenarios(loc || locale),
-    area: () => {
-      const rows = [
-        { z: -4, ids: ["hibiscus_shrub", "rose_bush_red", "sunflower", "mandacaru", "prickly_pear", "crown_cactus"] },
-        { z: -9, ids: ["banana_with_bunch", "dead_tree", "boxwood_hedge", "potted_fern", "potted_cactus", "lawn_tuft"] },
-        { z: -16, ids: ["mango_tree", "yellow_ipe", "coconut_palm", "araucaria", "mango_young_30", "mango_young_15"] }
-      ];
-      const widths = { mango_tree: 5, yellow_ipe: 5, coconut_palm: 4.5, araucaria: 4, mango_young_30: 3, mango_young_15: 2.6, banana_with_bunch: 3.5, dead_tree: 3.5, boxwood_hedge: 5.5, hibiscus_shrub: 2, rose_bush_red: 1.6, sunflower: 1.4, mandacaru: 2.2, prickly_pear: 2, crown_cactus: 1.8, potted_fern: 1.4, potted_cactus: 1.2, lawn_tuft: 1.2 };
-      const gap = 1.2;
-      const placements = rows.flatMap((row) => {
-        const total = row.ids.reduce((sum, id) => sum + (widths[id] ?? 2) + gap, -gap);
-        let cursor = -total / 2;
-        return row.ids.map((id) => {
-          const width = widths[id] ?? 2;
-          const x = cursor + width / 2;
-          cursor += width + gap;
-          return { item: id, position: [x, 0, row.z], rotationY: 0 };
-        });
-      });
-      return { placements, view: { eye: [0, 6, 8], target: [0, 1.8, -10] } };
-    },
-    controls: () => [
-      { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 0, max: 99999, step: 1, default: 1 },
-      { kind: "choice", id: "quality", name: text.controls.quality, hint: text.hints.quality, options: ["high", "game"].map((id) => ({ id, name: text.options.quality[id] })), default: "high" },
-      { kind: "choice", id: "lod", name: text.controls.lod, hint: text.hints.lod, options: ["0", "1", "2"].map((id) => ({ id, name: text.options.lod[id] })), default: "0" },
-      { kind: "choice", id: "condition", name: text.controls.condition, hint: text.hints.condition, options: ["healthy", "dry", "dead", "overgrown"].map((id) => ({ id, name: text.options.condition[id] })), default: "healthy" },
-      { kind: "choice", id: "season", name: text.controls.season, hint: text.hints.season, options: ["spring", "summer", "autumn", "winter"].map((id) => ({ id, name: text.options.season[id] })), default: "spring" },
-      { kind: "number", id: "wind", name: text.controls.wind, hint: text.hints.wind, min: 0, max: 1, step: 0.05, default: 0.35 },
-      { kind: "number", id: "gust", name: text.controls.gust, hint: text.hints.gust, min: 0, max: 1, step: 0.05, default: 0.15 },
-      { kind: "action", id: "plant_lot", name: text.actions.plant_lot, slow: true },
-      { kind: "action", id: "clear_lot", name: text.actions.clear_lot },
-      { kind: "action", id: "toggle_walker", name: text.actions.toggle_walker, slow: true }
-    ],
-    layers: () => ["colliders", "piece_boxes", "wood_axes"].map((id) => ({ id, name: text.layers[id], default: false })),
-    metrics: () => [
-      { id: "plants", name: text.metrics.plants, read: () => placed.size },
-      { id: "pieces", name: text.metrics.pieces, read: () => count().pieces },
-      { id: "triangles", name: text.metrics.triangles, read: () => count().triangles },
-      { id: "draw_calls", name: text.metrics.draw_calls, read: () => count().drawCalls + lotCalls() },
-      { id: "lot_triangles", name: text.metrics.lot_triangles, read: () => nursery?.stats?.triangles ?? 0 },
-      { id: "lot_plants", name: text.metrics.lot_plants, read: () => nursery?.stats?.plants ?? 0 },
-      { id: "lot_colliders", name: text.metrics.lot_colliders, read: () => nursery?.stats?.colliders ?? 0 },
-      { id: "lot_lod0", name: text.metrics.lot_lod0, read: () => nursery?.stats?.lod[0] ?? 0 },
-      { id: "lot_lod1", name: text.metrics.lot_lod1, read: () => nursery?.stats?.lod[1] ?? 0 },
-      { id: "lot_lod2", name: text.metrics.lot_lod2, read: () => nursery?.stats?.lod[2] ?? 0 },
-      { id: "lot_ms", name: text.metrics.lot_ms, unit: "ms", read: () => nursery?.stats?.buildMs ?? 0 }
-    ],
-    attach(lent) {
-      host = lent;
-      three = lent.THREE;
-      const stopChange = lent.bench?.onChange(onChange);
-      const stopFrame = lent.onFrame(frame);
-      applyWind();
-      return () => {
-        stopChange?.();
-        stopFrame();
-        clearHelpers();
-        nursery?.clear();
-        nursery = null;
-        host = null;
-      };
-    }
-  };
-}
-function loadVegetationTestModule(room, options = {}) {
-  return room.loadModule(createVegetationTestModule(options));
-}
+import {
+  AREAS,
+  EX_HOUSE,
+  EX_PATH,
+  HOUSE,
+  LOT,
+  PLANTINGS,
+  PLANT_DEFS,
+  PLANT_SEED,
+  VEGETATION_AREA_ID,
+  VEGETATION_ITEM_IDS,
+  VEGETATION_SCENARIO_IDS,
+  WAY,
+  createNursery,
+  createPlants,
+  createVegetationTestModule,
+  loadVegetationTestModule,
+  sanitize,
+  scatterLot
+} from "./chunk-4RHCXAUC.js";
 export {
   AREAS,
   EX_HOUSE,