@adatechnology/game-vegetation-three 0.1.0 → 0.2.1

package/dist/index.global.js

@@ -41,6 +41,1523 @@ var GameVegetationThree = (() => {
     scatterLot: () => scatterLot
   });
 
+  // ../game-shapes/dist/chunk-R4RY23RH.js
+  function canonicalJson(value) {
+    if (value === null) return "null";
+    if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "boolean") return value ? "true" : "false";
+    if (typeof value === "function") throw new Error("game-shapes: a function cannot be part of a shape (register it as a generator)");
+    if (ArrayBuffer.isView(value)) return canonicalJson(Array.from(value));
+    if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : canonicalJson(item)).join(",")}]`;
+    if (typeof value === "object") {
+      const record = value;
+      const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+      return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return "null";
+  }
+  function needsUint32(array) {
+    for (let i = array.length - 1; i >= 0; --i) if (array[i] >= 65535) return true;
+    return false;
+  }
+  var indexArray = (indices) => needsUint32(indices) ? new Uint32Array(indices) : new Uint16Array(indices);
+  function pack(type, parameters, a) {
+    return {
+      type,
+      parameters,
+      positions: new Float32Array(a.vertices),
+      normals: new Float32Array(a.normals),
+      uvs: new Float32Array(a.uvs),
+      ...a.indices ? { indices: indexArray(a.indices) } : {},
+      groups: a.groups
+    };
+  }
+  var normalize3 = (x, y, z) => {
+    const length = Math.sqrt(x * x + y * y + z * z);
+    const s = 1 / (length || 1);
+    return [x * s, y * s, z * s];
+  };
+  function box(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1) {
+    const parameters = { width, height, depth, widthSegments, heightSegments, depthSegments };
+    widthSegments = Math.floor(widthSegments);
+    heightSegments = Math.floor(heightSegments);
+    depthSegments = Math.floor(depthSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let numberOfVertices = 0;
+    let groupStart = 0;
+    const buildPlane = (u, v, w, udir, vdir, width2, height2, depth2, gridX, gridY, materialIndex) => {
+      const segmentWidth = width2 / gridX;
+      const segmentHeight = height2 / gridY;
+      const widthHalf = width2 / 2;
+      const heightHalf = height2 / 2;
+      const depthHalf = depth2 / 2;
+      const gridX1 = gridX + 1;
+      const gridY1 = gridY + 1;
+      let vertexCounter = 0;
+      let groupCount = 0;
+      const vector = { x: 0, y: 0, z: 0 };
+      for (let iy = 0; iy < gridY1; iy++) {
+        const y = iy * segmentHeight - heightHalf;
+        for (let ix = 0; ix < gridX1; ix++) {
+          const x = ix * segmentWidth - widthHalf;
+          vector[u] = x * udir;
+          vector[v] = y * vdir;
+          vector[w] = depthHalf;
+          vertices.push(vector.x, vector.y, vector.z);
+          vector[u] = 0;
+          vector[v] = 0;
+          vector[w] = depth2 > 0 ? 1 : -1;
+          normals.push(vector.x, vector.y, vector.z);
+          uvs.push(ix / gridX);
+          uvs.push(1 - iy / gridY);
+          vertexCounter += 1;
+        }
+      }
+      for (let iy = 0; iy < gridY; iy++) {
+        for (let ix = 0; ix < gridX; ix++) {
+          const a = numberOfVertices + ix + gridX1 * iy;
+          const b = numberOfVertices + ix + gridX1 * (iy + 1);
+          const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1);
+          const d = numberOfVertices + (ix + 1) + gridX1 * iy;
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex });
+      groupStart += groupCount;
+      numberOfVertices += vertexCounter;
+    };
+    buildPlane("z", "y", "x", -1, -1, depth, height, width, depthSegments, heightSegments, 0);
+    buildPlane("z", "y", "x", 1, -1, depth, height, -width, depthSegments, heightSegments, 1);
+    buildPlane("x", "z", "y", 1, 1, width, depth, height, widthSegments, depthSegments, 2);
+    buildPlane("x", "z", "y", 1, -1, width, depth, -height, widthSegments, depthSegments, 3);
+    buildPlane("x", "y", "z", 1, -1, width, height, depth, widthSegments, heightSegments, 4);
+    buildPlane("x", "y", "z", -1, -1, width, height, -depth, widthSegments, heightSegments, 5);
+    return pack("BoxGeometry", parameters, { vertices, normals, uvs, indices, groups });
+  }
+  function cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
+    radialSegments = Math.floor(radialSegments);
+    heightSegments = Math.floor(heightSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let index = 0;
+    const indexArray2 = [];
+    const halfHeight = height / 2;
+    let groupStart = 0;
+    const generateTorso = () => {
+      let groupCount = 0;
+      const slope = (radiusBottom - radiusTop) / height;
+      for (let y = 0; y <= heightSegments; y++) {
+        const indexRow = [];
+        const v = y / heightSegments;
+        const radius = v * (radiusBottom - radiusTop) + radiusTop;
+        for (let x = 0; x <= radialSegments; x++) {
+          const u = x / radialSegments;
+          const theta = u * thetaLength + thetaStart;
+          const sinTheta = Math.sin(theta);
+          const cosTheta = Math.cos(theta);
+          vertices.push(radius * sinTheta, -v * height + halfHeight, radius * cosTheta);
+          const n = normalize3(sinTheta, slope, cosTheta);
+          normals.push(n[0], n[1], n[2]);
+          uvs.push(u, 1 - v);
+          indexRow.push(index++);
+        }
+        indexArray2.push(indexRow);
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        for (let y = 0; y < heightSegments; y++) {
+          const a = indexArray2[y][x];
+          const b = indexArray2[y + 1][x];
+          const c = indexArray2[y + 1][x + 1];
+          const d = indexArray2[y][x + 1];
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: 0 });
+      groupStart += groupCount;
+    };
+    const generateCap = (top) => {
+      const centerIndexStart = index;
+      let groupCount = 0;
+      const radius = top === true ? radiusTop : radiusBottom;
+      const sign2 = top === true ? 1 : -1;
+      for (let x = 1; x <= radialSegments; x++) {
+        vertices.push(0, halfHeight * sign2, 0);
+        normals.push(0, sign2, 0);
+        uvs.push(0.5, 0.5);
+        index++;
+      }
+      const centerIndexEnd = index;
+      for (let x = 0; x <= radialSegments; x++) {
+        const u = x / radialSegments;
+        const theta = u * thetaLength + thetaStart;
+        const cosTheta = Math.cos(theta);
+        const sinTheta = Math.sin(theta);
+        vertices.push(radius * sinTheta, halfHeight * sign2, radius * cosTheta);
+        normals.push(0, sign2, 0);
+        uvs.push(cosTheta * 0.5 + 0.5, sinTheta * 0.5 * sign2 + 0.5);
+        index++;
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        const c = centerIndexStart + x;
+        const i = centerIndexEnd + x;
+        if (top === true) indices.push(i, i + 1, c);
+        else indices.push(i + 1, i, c);
+        groupCount += 3;
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: top === true ? 1 : 2 });
+      groupStart += groupCount;
+    };
+    generateTorso();
+    if (openEnded === false) {
+      if (radiusTop > 0) generateCap(true);
+      if (radiusBottom > 0) generateCap(false);
+    }
+    return { vertices, normals, uvs, indices, groups };
+  }
+  function cylinder(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("CylinderGeometry", parameters, cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function cone(radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("ConeGeometry", parameters, cylinderArrays(0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function sphere(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI) {
+    const parameters = { radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength };
+    widthSegments = Math.max(3, Math.floor(widthSegments));
+    heightSegments = Math.max(2, Math.floor(heightSegments));
+    const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI);
+    let index = 0;
+    const grid = [];
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy <= heightSegments; iy++) {
+      const verticesRow = [];
+      const v = iy / heightSegments;
+      let uOffset = 0;
+      if (iy === 0 && thetaStart === 0) uOffset = 0.5 / widthSegments;
+      else if (iy === heightSegments && thetaEnd === Math.PI) uOffset = -0.5 / widthSegments;
+      for (let ix = 0; ix <= widthSegments; ix++) {
+        const u = ix / widthSegments;
+        const x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        const y = radius * Math.cos(thetaStart + v * thetaLength);
+        const z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        vertices.push(x, y, z);
+        const n = normalize3(x, y, z);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(u + uOffset, 1 - v);
+        verticesRow.push(index++);
+      }
+      grid.push(verticesRow);
+    }
+    for (let iy = 0; iy < heightSegments; iy++) {
+      for (let ix = 0; ix < widthSegments; ix++) {
+        const a = grid[iy][ix + 1];
+        const b = grid[iy][ix];
+        const c = grid[iy + 1][ix];
+        const d = grid[iy + 1][ix + 1];
+        if (iy !== 0 || thetaStart > 0) indices.push(a, b, d);
+        if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d);
+      }
+    }
+    return pack("SphereGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function plane(width = 1, height = 1, widthSegments = 1, heightSegments = 1) {
+    const parameters = { width, height, widthSegments, heightSegments };
+    const widthHalf = width / 2;
+    const heightHalf = height / 2;
+    const gridX = Math.floor(widthSegments);
+    const gridY = Math.floor(heightSegments);
+    const gridX1 = gridX + 1;
+    const gridY1 = gridY + 1;
+    const segmentWidth = width / gridX;
+    const segmentHeight = height / gridY;
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy < gridY1; iy++) {
+      const y = iy * segmentHeight - heightHalf;
+      for (let ix = 0; ix < gridX1; ix++) {
+        const x = ix * segmentWidth - widthHalf;
+        vertices.push(x, -y, 0);
+        normals.push(0, 0, 1);
+        uvs.push(ix / gridX);
+        uvs.push(1 - iy / gridY);
+      }
+    }
+    for (let iy = 0; iy < gridY; iy++) {
+      for (let ix = 0; ix < gridX; ix++) {
+        const a = ix + gridX1 * iy;
+        const b = ix + gridX1 * (iy + 1);
+        const c = ix + 1 + gridX1 * (iy + 1);
+        const d = ix + 1 + gridX1 * iy;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("PlaneGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function circle(radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, segments, thetaStart, thetaLength };
+    segments = Math.max(3, segments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    vertices.push(0, 0, 0);
+    normals.push(0, 0, 1);
+    uvs.push(0.5, 0.5);
+    for (let s = 0, i = 3; s <= segments; s++, i += 3) {
+      const segment = thetaStart + s / segments * thetaLength;
+      vertices.push(radius * Math.cos(segment), radius * Math.sin(segment), 0);
+      normals.push(0, 0, 1);
+      uvs.push((vertices[i] / radius + 1) / 2, (vertices[i + 1] / radius + 1) / 2);
+    }
+    for (let i = 1; i <= segments; i++) indices.push(i, i + 1, 0);
+    return pack("CircleGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function ring(innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength };
+    thetaSegments = Math.max(3, thetaSegments);
+    phiSegments = Math.max(1, phiSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    let radius = innerRadius;
+    const radiusStep = (outerRadius - innerRadius) / phiSegments;
+    for (let j = 0; j <= phiSegments; j++) {
+      for (let i = 0; i <= thetaSegments; i++) {
+        const segment = thetaStart + i / thetaSegments * thetaLength;
+        const x = radius * Math.cos(segment);
+        const y = radius * Math.sin(segment);
+        vertices.push(x, y, 0);
+        normals.push(0, 0, 1);
+        uvs.push((x / outerRadius + 1) / 2, (y / outerRadius + 1) / 2);
+      }
+      radius += radiusStep;
+    }
+    for (let j = 0; j < phiSegments; j++) {
+      const thetaSegmentLevel = j * (thetaSegments + 1);
+      for (let i = 0; i < thetaSegments; i++) {
+        const segment = i + thetaSegmentLevel;
+        const a = segment;
+        const b = segment + thetaSegments + 1;
+        const c = segment + thetaSegments + 2;
+        const d = segment + 1;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("RingGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function lathe(points, segments = 12, phiStart = 0, phiLength = Math.PI * 2) {
+    const parameters = { points: points.map(([x, y]) => ({ x, y })), segments, phiStart, phiLength };
+    segments = Math.floor(segments);
+    phiLength = Math.max(0, Math.min(Math.PI * 2, phiLength));
+    const indices = [];
+    const vertices = [];
+    const uvs = [];
+    const initNormals = [];
+    const normals = [];
+    const inverseSegments = 1 / segments;
+    const normal = { x: 0, y: 0, z: 0 };
+    const curNormal = { x: 0, y: 0, z: 0 };
+    const prevNormal = { x: 0, y: 0, z: 0 };
+    let dx = 0;
+    let dy = 0;
+    const last = points.length - 1;
+    const px = (j) => points[j][0];
+    const py = (j) => points[j][1];
+    const setNormalized = () => {
+      const n = normalize3(normal.x, normal.y, normal.z);
+      normal.x = n[0];
+      normal.y = n[1];
+      normal.z = n[2];
+    };
+    for (let j = 0; j <= last; j++) {
+      if (j === 0) {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        prevNormal.x = normal.x;
+        prevNormal.y = normal.y;
+        prevNormal.z = normal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+      } else if (j === last) {
+        initNormals.push(prevNormal.x, prevNormal.y, prevNormal.z);
+      } else {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        curNormal.x = normal.x;
+        curNormal.y = normal.y;
+        curNormal.z = normal.z;
+        normal.x += prevNormal.x;
+        normal.y += prevNormal.y;
+        normal.z += prevNormal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+        prevNormal.x = curNormal.x;
+        prevNormal.y = curNormal.y;
+        prevNormal.z = curNormal.z;
+      }
+    }
+    for (let i = 0; i <= segments; i++) {
+      const phi = phiStart + i * inverseSegments * phiLength;
+      const sin = Math.sin(phi);
+      const cos = Math.cos(phi);
+      for (let j = 0; j <= last; j++) {
+        vertices.push(px(j) * sin, py(j), px(j) * cos);
+        uvs.push(i / segments, j / (points.length - 1));
+        const x = initNormals[3 * j + 0] * sin;
+        const y = initNormals[3 * j + 1];
+        const z = initNormals[3 * j + 0] * cos;
+        normals.push(x, y, z);
+      }
+    }
+    for (let i = 0; i < segments; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        const base = j + i * points.length;
+        const a = base;
+        const b = base + points.length;
+        const c = base + points.length + 1;
+        const d = base + 1;
+        indices.push(a, b, d);
+        indices.push(c, d, b);
+      }
+    }
+    return pack("LatheGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function torus(radius = 1, tube2 = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube: tube2, radialSegments, tubularSegments, arc };
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let j = 0; j <= radialSegments; j++) {
+      for (let i = 0; i <= tubularSegments; i++) {
+        const u = i / tubularSegments * arc;
+        const v = j / radialSegments * Math.PI * 2;
+        const x = (radius + tube2 * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube2 * Math.cos(v)) * Math.sin(u);
+        const z = tube2 * Math.sin(v);
+        vertices.push(x, y, z);
+        const cx = radius * Math.cos(u);
+        const cy = radius * Math.sin(u);
+        const n = normalize3(x - cx, y - cy, z - 0);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(i / tubularSegments);
+        uvs.push(j / radialSegments);
+      }
+    }
+    for (let j = 1; j <= radialSegments; j++) {
+      for (let i = 1; i <= tubularSegments; i++) {
+        const a = (tubularSegments + 1) * j + i - 1;
+        const b = (tubularSegments + 1) * (j - 1) + i - 1;
+        const c = (tubularSegments + 1) * (j - 1) + i;
+        const d = (tubularSegments + 1) * j + i;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("TorusGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function difference(size, subtract) {
+    const [w, h, d] = size;
+    const hw = w / 2;
+    const hh = h / 2;
+    const hd = d / 2;
+    const holes = subtract.map((hole) => ({ x0: Math.max(-hw, Math.min(hole.min[0], hole.max[0])), x1: Math.min(hw, Math.max(hole.min[0], hole.max[0])), y0: Math.max(-hh, Math.min(hole.min[1], hole.max[1])), y1: Math.min(hh, Math.max(hole.min[1], hole.max[1])) })).filter((hole) => hole.x1 > hole.x0 && hole.y1 > hole.y0);
+    const cuts = (lo, hi, values) => [.../* @__PURE__ */ new Set([lo, hi, ...values.filter((v) => v > lo && v < hi)])].sort((a, b) => a - b);
+    const xs = cuts(-hw, hw, holes.flatMap((hole) => [hole.x0, hole.x1]));
+    const ys = cuts(-hh, hh, holes.flatMap((hole) => [hole.y0, hole.y1]));
+    const nx = xs.length - 1;
+    const ny = ys.length - 1;
+    const solid = (i, j) => {
+      if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+      const cx = (xs[i] + xs[i + 1]) / 2;
+      const cy = (ys[j] + ys[j + 1]) / 2;
+      return !holes.some((hole) => cx > hole.x0 && cx < hole.x1 && cy > hole.y0 && cy < hole.y1);
+    };
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    const quad = (corners, normal, uv) => {
+      const base = positions.length / 3;
+      for (let k = 0; k < 4; k++) {
+        positions.push(...corners[k]);
+        normals.push(...normal);
+        uvs.push(...uv[k]);
+      }
+      indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    };
+    const fu = (x) => (x + hw) / w;
+    const fv = (y) => (y + hh) / h;
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        if (!solid(i, j)) continue;
+        const x0 = xs[i];
+        const x1 = xs[i + 1];
+        const y0 = ys[j];
+        const y1 = ys[j + 1];
+        quad([[x0, y0, hd], [x1, y0, hd], [x1, y1, hd], [x0, y1, hd]], [0, 0, 1], [[fu(x0), fv(y0)], [fu(x1), fv(y0)], [fu(x1), fv(y1)], [fu(x0), fv(y1)]]);
+        quad([[x1, y0, -hd], [x0, y0, -hd], [x0, y1, -hd], [x1, y1, -hd]], [0, 0, -1], [[1 - fu(x1), fv(y0)], [1 - fu(x0), fv(y0)], [1 - fu(x0), fv(y1)], [1 - fu(x1), fv(y1)]]);
+        const zu = (z) => (z + hd) / d;
+        if (!solid(i - 1, j)) quad([[x0, y0, -hd], [x0, y0, hd], [x0, y1, hd], [x0, y1, -hd]], [-1, 0, 0], [[zu(-hd), fv(y0)], [zu(hd), fv(y0)], [zu(hd), fv(y1)], [zu(-hd), fv(y1)]]);
+        if (!solid(i + 1, j)) quad([[x1, y0, hd], [x1, y0, -hd], [x1, y1, -hd], [x1, y1, hd]], [1, 0, 0], [[zu(hd), fv(y0)], [zu(-hd), fv(y0)], [zu(-hd), fv(y1)], [zu(hd), fv(y1)]]);
+        if (!solid(i, j - 1)) quad([[x0, y0, -hd], [x1, y0, -hd], [x1, y0, hd], [x0, y0, hd]], [0, -1, 0], [[fu(x0), zu(-hd)], [fu(x1), zu(-hd)], [fu(x1), zu(hd)], [fu(x0), zu(hd)]]);
+        if (!solid(i, j + 1)) quad([[x0, y1, hd], [x1, y1, hd], [x1, y1, -hd], [x0, y1, -hd]], [0, 1, 0], [[fu(x0), zu(hd)], [fu(x1), zu(hd)], [fu(x1), zu(-hd)], [fu(x0), zu(-hd)]]);
+      }
+    }
+    return {
+      type: "BufferGeometry",
+      parameters: { size: [w, h, d], subtract: holes.map((hole) => ({ min: [hole.x0, hole.y0], max: [hole.x1, hole.y1] })) },
+      positions: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      uvs: new Float32Array(uvs),
+      indices: indexArray(indices),
+      groups: []
+    };
+  }
+  var Earcut = {
+    triangulate: function(data, holeIndices, dim = 2) {
+      const hasHoles = holeIndices && holeIndices.length;
+      const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+      let outerNode = linkedList(data, 0, outerLen, dim, true);
+      const triangles = [];
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+      let minX, minY, maxX, maxY, x, y, invSize;
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+      if (data.length > 80 * dim) {
+        minX = maxX = data[0];
+        minY = maxY = data[1];
+        for (let i = dim; i < outerLen; i += dim) {
+          x = data[i];
+          y = data[i + 1];
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        invSize = Math.max(maxX - minX, maxY - minY);
+        invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+      return triangles;
+    }
+  };
+  function linkedList(data, start, end, dim, clockwise) {
+    let i, last;
+    if (clockwise === signedArea(data, start, end, dim) > 0) {
+      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start) return start;
+    if (!end) end = start;
+    let p = start, again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next) break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear) return;
+    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+    let stop = ear, prev, next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ, n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev, b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+    const queue = [];
+    let i, len2, start, end, list2;
+    for (i = 0, len2 = holeIndices.length; i < len2; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len2 - 1 ? holeIndices[i + 1] * dim : data.length;
+      list2 = linkedList(data, start, end, dim, false);
+      if (list2 === list2.next) list2.steiner = true;
+      queue.push(getLeftmost(list2));
+    }
+    queue.sort(compareX);
+    for (i = 0; i < queue.length; i++) {
+      outerNode = eliminateHole(queue[i], outerNode);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
+    }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode, qx = -Infinity, m;
+    const hx = hole.x, hy = hole.y;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          m = p.x < p.next.x ? p : p.next;
+          if (x === hx) return m;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m) return null;
+    const stop = m, mx = m.x, my = m.y;
+    let tanMin = Infinity, tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list2) {
+    let i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+    do {
+      p = list2;
+      list2 = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i = 0; i < inSize; i++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q) break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail) tail.nextZ = e;
+          else list2 = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list2;
+  }
+  function zOrder(x, y, minX, minY, invSize) {
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    x = (x | x << 8) & 16711935;
+    x = (x | x << 4) & 252645135;
+    x = (x | x << 2) & 858993459;
+    x = (x | x << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x | y << 1;
+  }
+  function getLeftmost(start) {
+    let p = start, leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+    equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4) return true;
+    if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+    if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+    if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+    if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num2) {
+    return num2 > 0 ? 1 : num2 < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a, inside = false;
+    const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i, x, y, last) {
+    const p = new Node(i, x, y);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  }
+  function Node(i, x, y) {
+    this.i = i;
+    this.x = x;
+    this.y = y;
+    this.prev = null;
+    this.next = null;
+    this.z = 0;
+    this.prevZ = null;
+    this.nextZ = null;
+    this.steiner = false;
+  }
+  function signedArea(data, start, end, dim) {
+    let sum = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+      j = i;
+    }
+    return sum;
+  }
+  var equals2 = (a, b) => a.x === b.x && a.y === b.y;
+  var linePoint = (v1, v2, t) => t === 1 ? { x: v2.x, y: v2.y } : { x: (v2.x - v1.x) * t + v1.x, y: (v2.y - v1.y) * t + v1.y };
+  function pathPoints(points) {
+    const out = [];
+    let last;
+    for (let i = 1; i < points.length; i++) {
+      const v1 = { x: points[i - 1][0], y: points[i - 1][1] };
+      const v2 = { x: points[i][0], y: points[i][1] };
+      for (let d = 0; d <= 1; d++) {
+        const point = linePoint(v1, v2, d / 1);
+        if (last && equals2(last, point)) continue;
+        out.push(point);
+        last = point;
+      }
+    }
+    return out;
+  }
+  function area2(contour) {
+    const n = contour.length;
+    let a = 0;
+    for (let p = n - 1, q = 0; q < n; p = q++) a += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
+    return a * 0.5;
+  }
+  var isClockWise = (pts) => area2(pts) < 0;
+  function removeDupEndPts(points) {
+    const l = points.length;
+    if (l > 2 && equals2(points[l - 1], points[0])) points.pop();
+  }
+  function triangulateShape(contour, holes) {
+    const vertices = [];
+    const holeIndices = [];
+    const faces = [];
+    removeDupEndPts(contour);
+    for (const p of contour) vertices.push(p.x, p.y);
+    let holeIndex = contour.length;
+    holes.forEach(removeDupEndPts);
+    for (let i = 0; i < holes.length; i++) {
+      holeIndices.push(holeIndex);
+      holeIndex += holes[i].length;
+      for (const p of holes[i]) vertices.push(p.x, p.y);
+    }
+    const triangles = Earcut.triangulate(vertices, holeIndices);
+    for (let i = 0; i < triangles.length; i += 3) faces.push(triangles.slice(i, i + 3));
+    return faces;
+  }
+  function computeVertexNormals(positions, indices) {
+    const normals = new Float32Array(positions.length);
+    const get = (array, i) => [array[i * 3], array[i * 3 + 1], array[i * 3 + 2]];
+    const face = (vA, vB, vC) => {
+      const pA = get(positions, vA);
+      const pB = get(positions, vB);
+      const pC = get(positions, vC);
+      const cb = [pC[0] - pB[0], pC[1] - pB[1], pC[2] - pB[2]];
+      const ab = [pA[0] - pB[0], pA[1] - pB[1], pA[2] - pB[2]];
+      return [cb[1] * ab[2] - cb[2] * ab[1], cb[2] * ab[0] - cb[0] * ab[2], cb[0] * ab[1] - cb[1] * ab[0]];
+    };
+    const set = (i, x, y, z) => {
+      normals[i * 3] = x;
+      normals[i * 3 + 1] = y;
+      normals[i * 3 + 2] = z;
+    };
+    if (indices) {
+      for (let i = 0; i < indices.length; i += 3) {
+        const vA = indices[i];
+        const vB = indices[i + 1];
+        const vC = indices[i + 2];
+        const cb = face(vA, vB, vC);
+        for (const v of [vA, vB, vC]) {
+          const n = get(normals, v);
+          set(v, n[0] + cb[0], n[1] + cb[1], n[2] + cb[2]);
+        }
+      }
+    } else {
+      for (let i = 0; i < positions.length / 3; i += 3) {
+        const cb = face(i, i + 1, i + 2);
+        set(i, cb[0], cb[1], cb[2]);
+        set(i + 1, cb[0], cb[1], cb[2]);
+        set(i + 2, cb[0], cb[1], cb[2]);
+      }
+    }
+    for (let i = 0; i < normals.length / 3; i++) {
+      const [x, y, z] = get(normals, i);
+      const s = 1 / (Math.sqrt(x * x + y * y + z * z) || 1);
+      set(i, x * s, y * s, z * s);
+    }
+    return normals;
+  }
+  function extrude(outline, depth = 1, steps = 1, bevel = void 0) {
+    const parameters = { shape: outline, depth, steps, bevel: bevel ?? {} };
+    const verticesArray = [];
+    const uvArray = [];
+    const groups = [];
+    const placeholder = [];
+    const bevelEnabled = bevel !== false;
+    const spec = bevel === false || bevel === void 0 ? {} : bevel;
+    let bevelThickness = spec.thickness !== void 0 ? spec.thickness : 0.2;
+    let bevelSize = spec.size !== void 0 ? spec.size : bevelThickness - 0.1;
+    let bevelOffset = spec.offset !== void 0 ? spec.offset : 0;
+    let bevelSegments = spec.segments !== void 0 ? spec.segments : 3;
+    if (!bevelEnabled) {
+      bevelSegments = 0;
+      bevelThickness = 0;
+      bevelSize = 0;
+      bevelOffset = 0;
+    }
+    let vertices = pathPoints(outline.outer);
+    const holes = (outline.holes ?? []).map(pathPoints);
+    const reverse = !isClockWise(vertices);
+    if (reverse) {
+      vertices = vertices.reverse();
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        if (isClockWise(ahole)) holes[h] = ahole.reverse();
+      }
+    }
+    const faces = triangulateShape(vertices, holes);
+    const contour = vertices;
+    for (const ahole of holes) vertices = vertices.concat(ahole);
+    const scalePt2 = (pt, vec, size) => ({ x: pt.x + vec.x * size, y: pt.y + vec.y * size });
+    const vlen = vertices.length;
+    const flen = faces.length;
+    const getBevelVec = (inPt, inPrev, inNext) => {
+      let vTransX;
+      let vTransY;
+      let shrinkBy;
+      const vPrevX = inPt.x - inPrev.x;
+      const vPrevY = inPt.y - inPrev.y;
+      const vNextX = inNext.x - inPt.x;
+      const vNextY = inNext.y - inPt.y;
+      const vPrevLensq = vPrevX * vPrevX + vPrevY * vPrevY;
+      const collinear0 = vPrevX * vNextY - vPrevY * vNextX;
+      if (Math.abs(collinear0) > Number.EPSILON) {
+        const vPrevLen = Math.sqrt(vPrevLensq);
+        const vNextLen = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
+        const ptPrevShiftX = inPrev.x - vPrevY / vPrevLen;
+        const ptPrevShiftY = inPrev.y + vPrevX / vPrevLen;
+        const ptNextShiftX = inNext.x - vNextY / vNextLen;
+        const ptNextShiftY = inNext.y + vNextX / vNextLen;
+        const sf = ((ptNextShiftX - ptPrevShiftX) * vNextY - (ptNextShiftY - ptPrevShiftY) * vNextX) / (vPrevX * vNextY - vPrevY * vNextX);
+        vTransX = ptPrevShiftX + vPrevX * sf - inPt.x;
+        vTransY = ptPrevShiftY + vPrevY * sf - inPt.y;
+        const vTransLensq = vTransX * vTransX + vTransY * vTransY;
+        if (vTransLensq <= 2) return { x: vTransX, y: vTransY };
+        shrinkBy = Math.sqrt(vTransLensq / 2);
+      } else {
+        let directionEq = false;
+        if (vPrevX > Number.EPSILON) {
+          if (vNextX > Number.EPSILON) directionEq = true;
+        } else if (vPrevX < -Number.EPSILON) {
+          if (vNextX < -Number.EPSILON) directionEq = true;
+        } else if (Math.sign(vPrevY) === Math.sign(vNextY)) {
+          directionEq = true;
+        }
+        if (directionEq) {
+          vTransX = -vPrevY;
+          vTransY = vPrevX;
+          shrinkBy = Math.sqrt(vPrevLensq);
+        } else {
+          vTransX = vPrevX;
+          vTransY = vPrevY;
+          shrinkBy = Math.sqrt(vPrevLensq / 2);
+        }
+      }
+      return { x: vTransX / shrinkBy, y: vTransY / shrinkBy };
+    };
+    const movements = (ring2) => {
+      const out = [];
+      for (let i = 0, il = ring2.length, j = il - 1, k = i + 1; i < il; i++, j++, k++) {
+        if (j === il) j = 0;
+        if (k === il) k = 0;
+        out[i] = getBevelVec(ring2[i], ring2[j], ring2[k]);
+      }
+      return out;
+    };
+    const contourMovements = movements(contour);
+    const holesMovements = [];
+    let verticesMovements = contourMovements.concat();
+    for (const ahole of holes) {
+      const oneHoleMovements = movements(ahole);
+      holesMovements.push(oneHoleMovements);
+      verticesMovements = verticesMovements.concat(oneHoleMovements);
+    }
+    const v = (x, y, z) => {
+      placeholder.push(x);
+      placeholder.push(y);
+      placeholder.push(z);
+    };
+    const bevelLayer = (b, zOf) => {
+      const t = b / bevelSegments;
+      const z = bevelThickness * Math.cos(t * Math.PI / 2);
+      const bs2 = bevelSize * Math.sin(t * Math.PI / 2) + bevelOffset;
+      for (let i = 0; i < contour.length; i++) {
+        const vert = scalePt2(contour[i], contourMovements[i], bs2);
+        v(vert.x, vert.y, zOf(z));
+      }
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        const oneHoleMovements = holesMovements[h];
+        for (let i = 0; i < ahole.length; i++) {
+          const vert = scalePt2(ahole[i], oneHoleMovements[i], bs2);
+          v(vert.x, vert.y, zOf(z));
+        }
+      }
+    };
+    for (let b = 0; b < bevelSegments; b++) bevelLayer(b, (z) => -z);
+    const bs = bevelSize + bevelOffset;
+    for (let i = 0; i < vlen; i++) {
+      const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+      v(vert.x, vert.y, 0);
+    }
+    for (let s = 1; s <= steps; s++) {
+      for (let i = 0; i < vlen; i++) {
+        const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+        v(vert.x, vert.y, depth / steps * s);
+      }
+    }
+    for (let b = bevelSegments - 1; b >= 0; b--) bevelLayer(b, (z) => depth + z);
+    const addVertex = (index) => {
+      verticesArray.push(placeholder[index * 3 + 0]);
+      verticesArray.push(placeholder[index * 3 + 1]);
+      verticesArray.push(placeholder[index * 3 + 2]);
+    };
+    const addUV = (x, y) => {
+      uvArray.push(x);
+      uvArray.push(y);
+    };
+    const at = (index, axis) => verticesArray[index * 3 + axis];
+    const f3 = (a, b, c) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(c);
+      const nextIndex = verticesArray.length / 3;
+      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at(index, 0), at(index, 1));
+    };
+    const f4 = (a, b, c, d) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(d);
+      addVertex(b);
+      addVertex(c);
+      addVertex(d);
+      const nextIndex = verticesArray.length / 3;
+      const iA = nextIndex - 6;
+      const iB = nextIndex - 3;
+      const iC = nextIndex - 2;
+      const iD = nextIndex - 1;
+      const byX = Math.abs(at(iA, 1) - at(iB, 1)) < Math.abs(at(iA, 0) - at(iB, 0));
+      const uv = (index) => [byX ? at(index, 0) : at(index, 1), 1 - at(index, 2)];
+      const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
+      for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
+    };
+    let start = verticesArray.length / 3;
+    if (bevelEnabled) {
+      let offset = 0;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2] + offset, face[1] + offset, face[0] + offset);
+      }
+      const layer = steps + bevelSegments * 2;
+      offset = vlen * layer;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + offset, face[1] + offset, face[2] + offset);
+      }
+    } else {
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2], face[1], face[0]);
+      }
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps);
+      }
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 0 });
+    start = verticesArray.length / 3;
+    const sidewalls = (ring2, layeroffset2) => {
+      let i = ring2.length;
+      while (--i >= 0) {
+        const j = i;
+        let k = i - 1;
+        if (k < 0) k = ring2.length - 1;
+        for (let s = 0, sl = steps + bevelSegments * 2; s < sl; s++) {
+          const slen1 = vlen * s;
+          const slen2 = vlen * (s + 1);
+          f4(layeroffset2 + j + slen1, layeroffset2 + k + slen1, layeroffset2 + k + slen2, layeroffset2 + j + slen2);
+        }
+      }
+    };
+    let layeroffset = 0;
+    sidewalls(contour, layeroffset);
+    layeroffset += contour.length;
+    for (const ahole of holes) {
+      sidewalls(ahole, layeroffset);
+      layeroffset += ahole.length;
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 1 });
+    const positions = new Float32Array(verticesArray);
+    return { type: "ExtrudeGeometry", parameters, positions, normals: computeVertexNormals(positions), uvs: new Float32Array(uvArray), groups };
+  }
+  var PARAMETER_KEYS = {
+    box: ["size", "segments"],
+    cylinder: ["radiusTop", "radiusBottom", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    cone: ["radius", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    sphere: ["radius", "widthSegments", "heightSegments", "phiStart", "phiLength", "thetaStart", "thetaLength"],
+    plane: ["width", "height", "widthSegments", "heightSegments"],
+    circle: ["radius", "segments", "thetaStart", "thetaLength"],
+    ring: ["innerRadius", "outerRadius", "thetaSegments", "phiSegments", "thetaStart", "thetaLength"],
+    lathe: ["points", "segments", "phiStart", "phiLength"],
+    torus: ["radius", "tube", "radialSegments", "tubularSegments", "arc"],
+    extrude: ["shape", "depth", "steps", "bevel"],
+    difference: ["size", "subtract"],
+    mesh: ["positions", "normals", "uvs", "indices"]
+  };
+  var SEGMENT_KEYS = {
+    cylinder: ["radialSegments"],
+    cone: ["radialSegments"],
+    sphere: ["widthSegments", "heightSegments"],
+    circle: ["segments"],
+    ring: ["thetaSegments"],
+    lathe: ["segments"],
+    torus: ["radialSegments", "tubularSegments"]
+  };
+  var SEGMENT_DEFAULTS = { radialSegments: 32, widthSegments: 32, heightSegments: 16, segments: 12, thetaSegments: 32, tubularSegments: 48 };
+  var segmentDefault = (kind, key) => kind === "circle" && key === "segments" ? 32 : kind === "torus" && key === "radialSegments" ? 12 : SEGMENT_DEFAULTS[key];
+  function primitiveParameters(node, options = {}) {
+    const out = {};
+    const source = node;
+    for (const key of PARAMETER_KEYS[node.kind]) if (source[key] !== void 0) out[key] = source[key];
+    const detail = options.detail ?? 1;
+    if (detail !== 1) {
+      const floor = options.minSegments ?? 3;
+      for (const key of SEGMENT_KEYS[node.kind] ?? []) {
+        const given = out[key] ?? segmentDefault(node.kind, key);
+        out[key] = Math.max(floor, Math.round(given * detail));
+      }
+    }
+    return out;
+  }
+  function mesh(p) {
+    const positions = new Float32Array(p.positions);
+    const indices = p.indices ? indexArray(p.indices) : void 0;
+    return {
+      type: "BufferGeometry",
+      parameters: {},
+      positions,
+      normals: p.normals ? new Float32Array(p.normals) : computeVertexNormals(positions, indices),
+      uvs: p.uvs ? new Float32Array(p.uvs) : new Float32Array(positions.length / 3 * 2),
+      ...indices ? { indices } : {},
+      groups: []
+    };
+  }
+  function make(kind, p) {
+    switch (kind) {
+      case "box": {
+        const size = p.size ?? [1, 1, 1];
+        const segments = p.segments ?? [1, 1, 1];
+        return box(size[0], size[1], size[2], segments[0], segments[1], segments[2]);
+      }
+      case "cylinder":
+        return cylinder(p.radiusTop, p.radiusBottom, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "cone":
+        return cone(p.radius, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "sphere":
+        return sphere(p.radius, p.widthSegments, p.heightSegments, p.phiStart, p.phiLength, p.thetaStart, p.thetaLength);
+      case "plane":
+        return plane(p.width, p.height, p.widthSegments, p.heightSegments);
+      case "circle":
+        return circle(p.radius, p.segments, p.thetaStart, p.thetaLength);
+      case "ring":
+        return ring(p.innerRadius, p.outerRadius, p.thetaSegments, p.phiSegments, p.thetaStart, p.thetaLength);
+      case "lathe":
+        return lathe(p.points, p.segments, p.phiStart, p.phiLength);
+      case "torus":
+        return torus(p.radius, p.tube, p.radialSegments, p.tubularSegments, p.arc);
+      case "extrude":
+        return extrude(p.shape, p.depth, p.steps, p.bevel);
+      case "difference":
+        return difference(p.size, p.subtract ?? []);
+      case "mesh":
+        return mesh(p);
+      default:
+        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+    }
+  }
+  var templates = /* @__PURE__ */ new Map();
+  var templateLimit = 4096;
+  var stats = { hits: 0, misses: 0 };
+  function buildPrimitive(node, options = {}) {
+    const parameters = primitiveParameters(node, options);
+    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    const key = `${node.kind}:${canonicalJson(parameters)}`;
+    const cached = templates.get(key);
+    if (cached) {
+      stats.hits++;
+      templates.delete(key);
+      templates.set(key, cached);
+      return cached;
+    }
+    stats.misses++;
+    const built = make(node.kind, parameters);
+    templates.set(key, built);
+    if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
+    return built;
+  }
+  var num = (v) => typeof v === "number" && Number.isFinite(v) ? null : "expected a finite number";
+  var bool = (v) => typeof v === "boolean" ? null : "expected a boolean";
+  var str = (v) => typeof v === "string" ? null : "expected a string";
+  var int = (min) => (v) => typeof v === "number" && Number.isInteger(v) && v >= min ? null : `expected an integer >= ${min}`;
+  var range = (lo, hi, loOpen = false) => (v) => typeof v === "number" && (loOpen ? v > lo : v >= lo) && v <= hi ? null : `expected a number in ${loOpen ? "(" : "["}${lo}, ${hi}]`;
+  var tuple = (n, item = num) => (v) => {
+    if (!Array.isArray(v) || v.length !== n) return `expected an array of ${n}`;
+    for (const x of v) if (item(x)) return `expected an array of ${n} numbers`;
+    return null;
+  };
+  var list = (item, min = 0) => (v) => {
+    if (!Array.isArray(v)) return "expected an array";
+    if (v.length < min) return `expected at least ${min} items`;
+    for (let i = 0; i < v.length; i++) {
+      const e = item(v[i]);
+      if (e) return `[${i}]: ${e}`;
+    }
+    return null;
+  };
+  var color = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 16777215 || typeof v === "string" && /^#[0-9a-fA-F]{6}$/.test(v) ? null : 'expected 0xRRGGBB or "#rrggbb"';
+  var oneOf = (values) => (v) => values.includes(v) ? null : `expected one of ${values.map((x) => JSON.stringify(x)).join(", ")}`;
+  var object = (fields, required = []) => (v) => {
+    if (!v || typeof v !== "object" || Array.isArray(v)) return "expected an object";
+    const record = v;
+    for (const key of required) if (record[key] === void 0) return `${key}: required`;
+    for (const key of Object.keys(record)) {
+      if (record[key] === void 0) continue;
+      const check = fields[key];
+      if (!check) return `${key}: unknown field`;
+      const e = check(record[key]);
+      if (e) return `${key}: ${e}`;
+    }
+    return null;
+  };
+  var ORDERS = ["XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"];
+  var TRANSFORM = {
+    position: tuple(3),
+    rotation: tuple(3),
+    rotationOrder: oneOf(ORDERS),
+    scale: (v) => typeof v === "number" ? num(v) : tuple(3)(v),
+    heading: num,
+    matrix: tuple(16)
+  };
+  var UV = object({ u0: num, v0: num, u1: num, v1: num }, ["u0", "v0", "u1", "v1"]);
+  var INSTANCE = object({ ...TRANSFORM, color });
+  var COMMON = {
+    ...TRANSFORM,
+    kind: str,
+    name: str,
+    part: str,
+    material: str,
+    color,
+    uv: UV,
+    instances: list(INSTANCE),
+    minDetail: range(0, 1, true),
+    tags: list(str)
+  };
+  var vec2 = tuple(2);
+  var BEVEL = (v) => v === false ? null : object({ thickness: num, size: num, offset: num, segments: int(1) })(v);
+  var KINDS = {
+    group: { fields: {} },
+    box: { fields: { size: tuple(3), segments: tuple(3, int(1)) } },
+    cylinder: { fields: { radiusTop: num, radiusBottom: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    cone: { fields: { radius: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    sphere: { fields: { radius: num, widthSegments: int(3), heightSegments: int(2), phiStart: num, phiLength: num, thetaStart: num, thetaLength: num } },
+    plane: { fields: { width: num, height: num, widthSegments: int(1), heightSegments: int(1) } },
+    circle: { fields: { radius: num, segments: int(3), thetaStart: num, thetaLength: num } },
+    ring: { fields: { innerRadius: num, outerRadius: num, thetaSegments: int(3), phiSegments: int(1), thetaStart: num, thetaLength: num } },
+    lathe: { fields: { points: list(vec2, 2), segments: int(1), phiStart: num, phiLength: num }, required: ["points"] },
+    torus: { fields: { radius: num, tube: num, radialSegments: int(1), tubularSegments: int(1), arc: num } },
+    extrude: {
+      fields: { shape: object({ outer: list(vec2, 3), holes: list(list(vec2, 3)) }, ["outer"]), depth: num, steps: int(1), bevel: BEVEL },
+      required: ["shape"]
+    },
+    difference: { fields: { size: tuple(3), subtract: list(object({ min: vec2, max: vec2 }, ["min", "max"])) }, required: ["size", "subtract"] },
+    mesh: {
+      fields: {
+        positions: (v) => list(num)(v) ?? (v.length % 3 === 0 ? null : "expected a multiple of 3 numbers"),
+        normals: list(num),
+        uvs: list(num),
+        indices: list(int(0))
+      },
+      required: ["positions"]
+    },
+    point: { fields: { data: () => null } },
+    custom: { fields: { generator: str, params: () => null }, required: ["generator"] }
+  };
+
+  // ../game-shapes-three/dist/index.js
+  var UV_BEFORE_NORMAL = /* @__PURE__ */ new Set(["LatheGeometry", "ExtrudeGeometry"]);
+  var INDEX_FIRST = /* @__PURE__ */ new Set(["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry"]);
+  var isPrimitive = (value) => typeof value.type === "string";
+  function threeParameters(THREE, p) {
+    if (p.type === "LatheGeometry") {
+      const points = p.parameters.points.map(({ x, y }) => new THREE.Vector2(x, y));
+      return { ...p.parameters, points };
+    }
+    return { ...p.parameters };
+  }
+  function toGeometry(THREE, source, options = {}) {
+    const copy = options.copy !== false;
+    const primitive = isPrimitive(source) ? source : null;
+    const ThreeClass = primitive && primitive.type !== "BufferGeometry" ? THREE[primitive.type] : void 0;
+    const geometry = ThreeClass ? Reflect.construct(THREE.BufferGeometry, [], ThreeClass) : new THREE.BufferGeometry();
+    if (primitive && ThreeClass) {
+      Object.assign(geometry, { type: primitive.type, parameters: threeParameters(THREE, primitive) });
+    }
+    const attribute = (array, size) => copy ? new THREE.Float32BufferAttribute(array, size) : new THREE.BufferAttribute(array, size);
+    const index = source.indices;
+    const setIndex = () => {
+      if (!index) return;
+      geometry.setIndex(copy ? index instanceof Uint32Array ? new THREE.Uint32BufferAttribute(index, 1) : new THREE.Uint16BufferAttribute(index, 1) : new THREE.BufferAttribute(index, 1));
+    };
+    const type = primitive?.type ?? "BufferGeometry";
+    if (INDEX_FIRST.has(type)) setIndex();
+    geometry.setAttribute("position", attribute(source.positions, 3));
+    if (UV_BEFORE_NORMAL.has(type)) {
+      geometry.setAttribute("uv", attribute(source.uvs, 2));
+      geometry.setAttribute("normal", attribute(source.normals, 3));
+    } else {
+      geometry.setAttribute("normal", attribute(source.normals, 3));
+      geometry.setAttribute("uv", attribute(source.uvs, 2));
+    }
+    if (!primitive && source.colors) geometry.setAttribute("color", attribute(source.colors, 3));
+    if (!INDEX_FIRST.has(type)) setIndex();
+    if (primitive) for (const group of primitive.groups) geometry.addGroup(group.start, group.count, group.materialIndex);
+    return geometry;
+  }
+  var SHAPE_GEOMETRY_TYPES = ["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry", "ExtrudeGeometry"];
+  function linePoints(path) {
+    if (path.autoClose || path.curves.length === 0) return null;
+    const points = [];
+    for (const [index, curve] of path.curves.entries()) {
+      if (!curve.isLineCurve || !curve.v1 || !curve.v2) return null;
+      if (index === 0) points.push([curve.v1.x, curve.v1.y]);
+      else {
+        const last = points[points.length - 1];
+        if (last[0] !== curve.v1.x || last[1] !== curve.v1.y) return null;
+      }
+      points.push([curve.v2.x, curve.v2.y]);
+    }
+    return points;
+  }
+  function extrudeOf(shapes, options = {}) {
+    if (Array.isArray(shapes) || !shapes || options.extrudePath !== void 0 || options.UVGenerator !== void 0) return null;
+    const shape = shapes;
+    const outer = linePoints(shape);
+    if (!outer) return null;
+    const holes = [];
+    for (const hole of shape.holes ?? []) {
+      const points = linePoints(hole);
+      if (!points) return null;
+      holes.push(points);
+    }
+    const outline = holes.length ? { outer, holes } : { outer };
+    const bevel = options.bevelEnabled === false ? false : {
+      ...options.bevelThickness !== void 0 ? { thickness: options.bevelThickness } : {},
+      ...options.bevelSize !== void 0 ? { size: options.bevelSize } : {},
+      ...options.bevelOffset !== void 0 ? { offset: options.bevelOffset } : {},
+      ...options.bevelSegments !== void 0 ? { segments: options.bevelSegments } : {}
+    };
+    return extrude(outline, options.depth, options.steps, bevel);
+  }
+  var namespaces = /* @__PURE__ */ new WeakMap();
+  var shims = /* @__PURE__ */ new WeakSet();
+  function shapeGeometries(THREE, options = {}) {
+    if (shims.has(THREE)) return THREE;
+    const cache2 = options.cache !== false;
+    const key = cache2 ? "cache" : "nocache";
+    let byKey = namespaces.get(THREE);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      namespaces.set(THREE, byKey);
+    }
+    const existing = byKey.get(key);
+    if (existing) return existing;
+    const made = (p) => toGeometry(THREE, p);
+    const viaCache = (node, direct) => cache2 ? buildPrimitive(node) : direct();
+    const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+    const constructors = {
+      BoxGeometry: (width, height, depth, ws = 1, hs = 1, ds = 1) => made(viaCache({ kind: "box", size: [width ?? 1, height ?? 1, depth ?? 1], segments: [ws, hs, ds] }, () => box(width, height, depth, ws, hs, ds))),
+      CylinderGeometry: (radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cylinder", ...defined({ radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cylinder(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      ConeGeometry: (radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cone", ...defined({ radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cone(radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      SphereGeometry: (radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) => made(viaCache({ kind: "sphere", ...defined({ radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength }) }, () => sphere(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength))),
+      PlaneGeometry: (width, height, widthSegments, heightSegments) => made(viaCache({ kind: "plane", ...defined({ width, height, widthSegments, heightSegments }) }, () => plane(width, height, widthSegments, heightSegments))),
+      CircleGeometry: (radius, segments, thetaStart, thetaLength) => made(viaCache({ kind: "circle", ...defined({ radius, segments, thetaStart, thetaLength }) }, () => circle(radius, segments, thetaStart, thetaLength))),
+      RingGeometry: (innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength) => made(viaCache({ kind: "ring", ...defined({ innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength }) }, () => ring(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength))),
+      LatheGeometry: (points, segments, phiStart, phiLength) => {
+        if (!points) return new THREE.LatheGeometry(void 0, segments, phiStart, phiLength);
+        const profile = points.map((p) => [p.x, p.y]);
+        return made(viaCache({ kind: "lathe", points: profile, ...defined({ segments, phiStart, phiLength }) }, () => lathe(profile, segments, phiStart, phiLength)));
+      },
+      TorusGeometry: (radius, tube2, radialSegments, tubularSegments, arc) => made(viaCache({ kind: "torus", ...defined({ radius, tube: tube2, radialSegments, tubularSegments, arc }) }, () => torus(radius, tube2, radialSegments, tubularSegments, arc))),
+      ExtrudeGeometry: (shapes, extrudeOptions) => {
+        const buffers = shapes === void 0 ? null : extrudeOf(shapes, extrudeOptions);
+        if (!buffers) return new THREE.ExtrudeGeometry(shapes, extrudeOptions);
+        const geometry = toGeometry(THREE, buffers);
+        geometry.parameters = { shapes, options: extrudeOptions ?? {} };
+        return geometry;
+      }
+    };
+    const namespace = { ...THREE };
+    for (const type of SHAPE_GEOMETRY_TYPES) {
+      const make2 = constructors[type];
+      const Constructor = function(...args) {
+        return make2(...args);
+      };
+      Constructor.prototype = THREE[type].prototype;
+      Object.defineProperty(Constructor, "name", { value: type });
+      namespace[type] = Constructor;
+    }
+    const result = namespace;
+    byKey.set(key, result);
+    shims.add(result);
+    return result;
+  }
+
   // ../game-vegetation/dist/index.js
   var dist_exports = {};
   __export(dist_exports, {
@@ -50,7 +1567,7 @@ var GameVegetationThree = (() => {
     createRng: () => createRng,
     distanceToBoundary: () => distanceToBoundary,
     extractPlant: () => extractPlant,
-    generate: () => generate,
+    generate: () => generate2,
     hashString: () => hashString,
     hideLotPlant: () => hideLotPlant,
     materialKeyForPart: () => materialKeyForPart,
@@ -285,7 +1802,7 @@ var GameVegetationThree = (() => {
     const [h, s, v] = toHsv(c);
     return fromHsv(h - amt * 0.03, clamp(s - amt * 0.12, 0, 1), clamp(v + amt * 0.35, 0, 1));
   }
-  function srgbToLinear(v) {
+  function srgbToLinear2(v) {
     return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
   }
   function linearToSrgb(v) {
@@ -467,7 +1984,7 @@ var GameVegetationThree = (() => {
       this.groupTriangles();
       const n = this.pos.length / 3;
       const colors = new Float32Array(n * 3);
-      for (let i = 0; i < n * 3; i++) colors[i] = srgbToLinear(this.col[i]);
+      for (let i = 0; i < n * 3; i++) colors[i] = srgbToLinear2(this.col[i]);
       return {
         positions: new Float32Array(this.pos),
         normals: new Float32Array(this.nor),
@@ -668,16 +2185,16 @@ var GameVegetationThree = (() => {
       const f = frames[k];
       const r = o.radii[k];
       const t = k / (n - 1);
-      const ring = [];
+      const ring2 = [];
       for (let i = 0; i < S; i++) {
         const a = i / S * TAU;
         const ca = Math.cos(a);
         const sa = Math.sin(a);
         const dir = [f.n[0] * ca + f.b[0] * sa, f.n[1] * ca + f.b[1] * sa, f.n[2] * ca + f.b[2] * sa];
         const rr = r * (1 + (o.rough ? o.rough(k, i) : 0));
-        ring.push({ p: add(path[k], mul(dir, rr)), nr: dir, c: o.color(t, i / S) });
+        ring2.push({ p: add(path[k], mul(dir, rr)), nr: dir, c: o.color(t, i / S) });
       }
-      rings.push(ring);
+      rings.push(ring2);
     }
     const sw = (k) => o.sway(k / (n - 1));
     if (smooth2) {
@@ -761,7 +2278,7 @@ var GameVegetationThree = (() => {
     const swayAt = (k) => o.sway(k / (N - 1));
     for (let k = 0; k < N; k++) {
       const f = fr[k];
-      const ring = [];
+      const ring2 = [];
       for (let i = 0; i < S; i++) {
         const ridge = i % 2 === 0;
         const rib = i >> 1;
@@ -771,10 +2288,10 @@ var GameVegetationThree = (() => {
         const rr = radii[k] * (ridge ? 1 + wob : o.valley);
         const p = add(pts[k], mul(dir, rr));
         const c = o.color(Math.min(1, k / (path.length - 1)), ridge, rib);
-        ring.push({ p, nr: dir, c });
+        ring2.push({ p, nr: dir, c });
         if (ridge && k < path.length) info.ridges.push({ p, n: dir, t: k / (path.length - 1), rib, ring: k });
       }
-      rings.push(ring);
+      rings.push(ring2);
     }
     for (let k = 0; k < N - 1; k++) {
       for (let i = 0; i < S; i++) {
@@ -1096,7 +2613,7 @@ var GameVegetationThree = (() => {
       return { p, r, members: g.members };
     });
   }
-  function octa(b, center, radii, color, sway) {
+  function octa(b, center, radii, color2, sway) {
     const pts = [
       [radii[0], 0, 0],
       [0, 0, radii[2]],
@@ -1109,11 +2626,11 @@ var GameVegetationThree = (() => {
       const a = pts[i];
       const c = pts[(i + 1) % 4];
       const out = sub(add(a, c), mul(center, 2));
-      b.flatTri(a, c, top, color(0.5), color(0.5), color(1), sway, sway, sway, add(out, [0, 1, 0]));
-      b.flatTri(c, a, bot, color(0.5), color(0.5), color(0), sway, sway, sway, add(out, [0, -1, 0]));
+      b.flatTri(a, c, top, color2(0.5), color2(0.5), color2(1), sway, sway, sway, add(out, [0, 1, 0]));
+      b.flatTri(c, a, bot, color2(0.5), color2(0.5), color2(0), sway, sway, sway, add(out, [0, -1, 0]));
     }
   }
-  function blossom(b, center, normal, size, color, heart, sway, petals = 5, twist = 0) {
+  function blossom(b, center, normal, size, color2, heart, sway, petals = 5, twist = 0) {
     const f = frameFromAxis(center, normal, twist);
     const peak = toWorld(f, [0, size * 0.3, 0]);
     for (let i = 0; i < petals; i++) {
@@ -1123,7 +2640,7 @@ var GameVegetationThree = (() => {
       const p0 = toWorld(f, [Math.cos(a0) * size * 0.75, 0, Math.sin(a0) * size * 0.75]);
       const p1 = toWorld(f, [Math.cos(a1) * size * 0.75, 0, Math.sin(a1) * size * 0.75]);
       const pm = toWorld(f, [Math.cos(am) * size * 1.1, size * 0.08, Math.sin(am) * size * 1.1]);
-      const c = i % 2 ? shade(color, 0.93) : color;
+      const c = i % 2 ? shade(color2, 0.93) : color2;
       b.flatTri(peak, p0, pm, heart, c, lighten(c, 0.4), sway, sway, sway, normal);
       b.flatTri(peak, pm, p1, heart, lighten(c, 0.4), c, sway, sway, sway, normal);
     }
@@ -2013,8 +3530,8 @@ var GameVegetationThree = (() => {
         const nb = ctx.pick(6, 5, 4);
         for (let i = 0; i < nb; i++) {
           const a = i * 2.2 + 0.4;
-          const ring = i === 0 ? 0 : moundR * 0.5;
-          blobs.push({ c: [Math.cos(a) * ring, moundH * (i === 0 ? 0.55 : 0.28 + 0.07 * (i % 3)), Math.sin(a) * ring], r: moundR * (i === 0 ? 0.62 : 0.52), sq: 0.95 });
+          const ring2 = i === 0 ? 0 : moundR * 0.5;
+          blobs.push({ c: [Math.cos(a) * ring2, moundH * (i === 0 ? 0.55 : 0.28 + 0.07 * (i % 3)), Math.sin(a) * ring2], r: moundR * (i === 0 ? 0.62 : 0.52), sq: 0.95 });
         }
       }
       for (const bl of blobs) clump(ctx.foliage, { center: bl.c, radius: bl.r, squash: bl.sq, detail: ctx.pick(1, 1, 0), seed: rng.seed(), base: dead ? mix(leafBase, [0.42, 0.32, 0.2], 0.7) : dry ? mix(leafBase, [0.55, 0.48, 0.22], 0.45) : mix(leafBase, [0.25, 0.55, 0.22], 0.25), swayK: 0.3, noise: 0.16, flatBottom: 0.8, ao: 0.5 });
@@ -2381,7 +3898,7 @@ var GameVegetationThree = (() => {
       }
     }
     if (o.teeth && o.teeth.count > 0) {
-      const { count, color, size } = o.teeth;
+      const { count, color: color2, size } = o.teeth;
       for (let k = 0; k < count; k++) {
         const t0 = 0.12 + 0.7 * k / count;
         const t1 = t0 + 0.05;
@@ -2392,7 +3909,7 @@ var GameVegetationThree = (() => {
           const e1 = sd < 0 ? rows[i1].L : rows[i1].R;
           const out = mul(right, sd * width * size);
           const tip = add(add(mul(add(e0, e1), 0.5), out), mul(d, length * 0.02));
-          b.flatTri(e0, tip, e1, color, shade(color, 1.3), color, rows[i0].s, rows[i0].s, rows[i1].s, add(out, n2));
+          b.flatTri(e0, tip, e1, color2, shade(color2, 1.3), color2, rows[i0].s, rows[i0].s, rows[i1].s, add(out, n2));
         }
       }
     }
@@ -2421,8 +3938,8 @@ var GameVegetationThree = (() => {
           const az = i / n * TAU * 1 + rng.range(-0.3, 0.3);
           const el = rng.range(1.2, 1.5);
           const len2 = h * rng.range(0.55, 1) * (ctx.condition === "dead" ? 0.6 : 1);
-          const ring = rng.range(0, 0.08);
-          const base0 = [Math.cos(az) * ring, 0, Math.sin(az) * ring];
+          const ring2 = rng.range(0, 0.08);
+          const base0 = [Math.cos(az) * ring2, 0, Math.sin(az) * ring2];
           const band = rng.range(0, TAU);
           fleshyLeaf(ctx.foliage, base0, dirFromAngles(az, el), dirFromAngles(az + Math.PI, 0.2), len2, h * 0.16 * rng.range(0.85, 1.15), {
             rows: ctx.pick(7, 4, 2),
@@ -2444,10 +3961,10 @@ var GameVegetationThree = (() => {
         const base = tintFlesh(rgb(spec.color ?? 7315306), ctx.condition);
         const edge = rgb(spec.edgeColor ?? 15261896);
         for (let i = 0; i < n; i++) {
-          const ring = i < n * 0.4 ? 0 : i < n * 0.75 ? 1 : 2;
+          const ring2 = i < n * 0.4 ? 0 : i < n * 0.75 ? 1 : 2;
           const az = i * 2.4 + rng.range(-0.2, 0.2);
-          const el = [1.15, 0.85, 0.55][ring] + rng.range(-0.1, 0.1);
-          const len2 = h * [0.75, 0.95, 0.85][ring] * rng.range(0.9, 1.1);
+          const el = [1.15, 0.85, 0.55][ring2] + rng.range(-0.1, 0.1);
+          const len2 = h * [0.75, 0.95, 0.85][ring2] * rng.range(0.9, 1.1);
           const c = jitter(base, rng, 0.01, 0.06, 0.04);
           fleshyLeaf(ctx.foliage, [0, 0.02, 0], dirFromAngles(az, el), [0, 1, 0], len2, h * 0.26, {
             rows: ctx.pick(3, 2, 2),
@@ -2534,7 +4051,7 @@ var GameVegetationThree = (() => {
     }
     return { collider: null, bendable: true };
   }
-  function spineTuft(b, p, n, count, length, color, rng, sway = 0) {
+  function spineTuft(b, p, n, count, length, color2, rng, sway = 0) {
     const nn = norm(n);
     const t1 = perp(nn);
     const t2 = norm(cross(nn, t1));
@@ -2547,15 +4064,15 @@ var GameVegetationThree = (() => {
       const side = mul(norm(cross(dir, nn)), w);
       const left = add(p, side);
       const right = add(p, mul(side, -1));
-      b.flatTri(left, right, tip, shade(color, 0.8), shade(color, 0.8), color, sway, sway, sway, nn);
+      b.flatTri(left, right, tip, shade(color2, 0.8), shade(color2, 0.8), color2, sway, sway, sway, nn);
     }
   }
-  function areole(b, p, n, size, color, sway = 0) {
+  function areole(b, p, n, size, color2, sway = 0) {
     const nn = norm(n);
     const t1 = mul(perp(nn), size);
     const t2 = mul(norm(cross(nn, perp(nn))), size);
     const c = add(p, mul(nn, size * 0.1));
-    b.flatTri(add(c, t1), add(c, add(mul(t1, -0.5), t2)), add(c, add(mul(t1, -0.5), mul(t2, -1))), color, color, color, sway, sway, sway, nn);
+    b.flatTri(add(c, t1), add(c, add(mul(t1, -0.5), t2)), add(c, add(mul(t1, -0.5), mul(t2, -1))), color2, color2, color2, sway, sway, sway, nn);
   }
   function generateColumnarCactus(spec, ctx) {
     const rng = ctx.rng;
@@ -2592,7 +4109,7 @@ var GameVegetationThree = (() => {
         dome: domeSteps,
         color: (t, ridge, rib) => bodyColor(t, ridge, rib + seedK),
         sway: () => 0,
-        rough: (ring, rib) => Math.sin(ring * 1.7 + rib * 2.3 + seedK) * 0.03
+        rough: (ring2, rib) => Math.sin(ring2 * 1.7 + rib * 2.3 + seedK) * 0.03
       });
       const last = path[path.length - 1];
       const prev = path[path.length - 2];
@@ -2804,7 +4321,7 @@ var GameVegetationThree = (() => {
         return shade(base, k);
       },
       sway: () => 0,
-      rough: (ring, rib) => Math.sin(ring * 2.1 + rib * 1.3) * 0.02
+      rough: (ring2, rib) => Math.sin(ring2 * 2.1 + rib * 1.3) * 0.02
     });
     if (ctx.lod === 0) {
       for (const rd of res.ridges) {
@@ -2959,9 +4476,9 @@ var GameVegetationThree = (() => {
         sides,
         radii,
         color: (t, a) => {
-          const ring = 0.84 + 0.16 * Math.cos(t * stemH * scars * TAU);
+          const ring2 = 0.84 + 0.16 * Math.cos(t * stemH * scars * TAU);
           const stripe = 0.94 + 0.06 * Math.cos(a * TAU * 3 + t * 4);
-          let c = shade(trunkC, ring * stripe * (0.78 + 0.22 * Math.min(1, t * 6)));
+          let c = shade(trunkC, ring2 * stripe * (0.78 + 0.22 * Math.min(1, t * 6)));
           if (variant === "royal") c = mix(c, [0.62, 0.62, 0.55], 0.25);
           if (dead) c = mix(c, [0.4, 0.37, 0.32], 0.5);
           return c;
@@ -2986,34 +4503,34 @@ var GameVegetationThree = (() => {
       for (let i = 0; i < n; i++) {
         if (ctx.lod === 2 && variant === "fan" && i % 2 === 1) continue;
         const f = srng.fork(i);
-        const ring = i % 3;
+        const ring2 = i % 3;
         const az2 = i / n * TAU * 1 + f.range(-0.2, 0.2) + si;
         let elev;
         let droop;
         if (variant === "royal") {
-          elev = [1.1, 0.65, 0.2][ring] + f.range(-0.1, 0.1);
-          droop = [0.35, 0.65, 1][ring];
+          elev = [1.1, 0.65, 0.2][ring2] + f.range(-0.1, 0.1);
+          droop = [0.35, 0.65, 1][ring2];
         } else if (variant === "date") {
-          elev = [1.15, 0.8, 0.45][ring] + f.range(-0.08, 0.08);
-          droop = [0.3, 0.5, 0.75][ring];
+          elev = [1.15, 0.8, 0.45][ring2] + f.range(-0.08, 0.08);
+          droop = [0.3, 0.5, 0.75][ring2];
         } else if (variant === "areca") {
-          elev = [1.1, 0.8, 0.5][ring] + f.range(-0.1, 0.1);
-          droop = [0.45, 0.8, 1.1][ring];
+          elev = [1.1, 0.8, 0.5][ring2] + f.range(-0.1, 0.1);
+          droop = [0.45, 0.8, 1.1][ring2];
         } else if (variant === "fan") {
-          elev = [1.3, 0.95, 0.6][ring] + f.range(-0.1, 0.1);
-          droop = [0.25, 0.35, 0.5][ring];
+          elev = [1.3, 0.95, 0.6][ring2] + f.range(-0.1, 0.1);
+          droop = [0.25, 0.35, 0.5][ring2];
         } else {
-          elev = [1.15, 0.75, 0.38][ring] + f.range(-0.1, 0.1);
-          droop = [0.45, 0.78, 1.1][ring];
+          elev = [1.15, 0.75, 0.38][ring2] + f.range(-0.1, 0.1);
+          droop = [0.45, 0.78, 1.1][ring2];
         }
         if (dead) {
           elev = elev * 0.4 - 0.3;
           droop *= 1.4;
         }
         if (dry) droop *= 1.15;
-        const len2 = frondL * f.range(0.85, 1.1) * (ring === 2 ? 0.92 : 1);
+        const len2 = frondL * f.range(0.85, 1.1) * (ring2 === 2 ? 0.92 : 1);
         const colA = dead ? mix(c0, deadC, 0.8) : c0;
-        const colB = dead ? mix(c1, deadC, 0.7) : ring === 2 && dry ? mix(c1, deadC, 0.4) : c1;
+        const colB = dead ? mix(c1, deadC, 0.7) : ring2 === 2 && dry ? mix(c1, deadC, 0.4) : c1;
         if (variant === "fan") {
           fanFrond(ctx, f, crownTop, az2, elev, len2, droop, colA, colB);
         } else {
@@ -3124,10 +4641,10 @@ var GameVegetationThree = (() => {
     const rows = ctx.pick(9, 6, 3);
     for (let i = 0; i < nLeaves; i++) {
       const f = rng.fork(i);
-      const ring = i % 3;
+      const ring2 = i % 3;
       const az = i / nLeaves * TAU * 1 + f.range(-0.25, 0.25);
-      const L = H * f.range(0.55, 0.72) * (ring === 2 ? 0.85 : 1);
-      const el = [1.15, 0.8, 0.45][ring] + f.range(-0.12, 0.12);
+      const L = H * f.range(0.55, 0.72) * (ring2 === 2 ? 0.85 : 1);
+      const el = [1.15, 0.8, 0.45][ring2] + f.range(-0.12, 0.12);
       const horiz = dirFromAngles(az, 0);
       const petL = L * 0.18;
       const pEnd = [top[0] + horiz[0] * petL * Math.cos(el), top[1] + petL * Math.sin(el), top[2] + horiz[2] * petL * Math.cos(el)];
@@ -3138,7 +4655,7 @@ var GameVegetationThree = (() => {
       const tearSeed = f.range(0, 10);
       leaf(ctx.foliage, pEnd, norm([horiz[0] * Math.cos(el), Math.sin(el), horiz[2] * Math.cos(el)]), [0, 1, 0], L, L * 0.34, c0, c1, {
         rows,
-        curl: [0.55, 0.7, 0.8][ring] * (dry ? 1.2 : 1),
+        curl: [0.55, 0.7, 0.8][ring2] * (dry ? 1.2 : 1),
         fold: 0.35,
         swayBase: 0.25,
         swayTip: 1,
@@ -3238,8 +4755,8 @@ var GameVegetationThree = (() => {
       if (hit) return hit;
       const m = Math.max(Math.abs(c[0]), Math.abs(c[1]), Math.abs(c[2]));
       const s = norm(c);
-      const sphere = [s[0] * m, s[1] * m, s[2] * m];
-      const q = [lerp(c[0], sphere[0], o.round), lerp(c[1], sphere[1], o.round), lerp(c[2], sphere[2], o.round)];
+      const sphere2 = [s[0] * m, s[1] * m, s[2] * m];
+      const q = [lerp(c[0], sphere2[0], o.round), lerp(c[1], sphere2[1], o.round), lerp(c[2], sphere2[2], o.round)];
       const base = [o.center[0] + q[0] * hx, o.center[1] + q[1] * hy, o.center[2] + q[2] * hz];
       const nz = valueNoise3(base[0] * freq, base[1] * freq, base[2] * freq, seed) * 0.75 + valueNoise3(base[0] * freq * 2.3, base[1] * freq * 2.3, base[2] * freq * 2.3, seed + 7) * 0.25;
       const out = norm([q[0] / Math.max(hx, 1e-6), q[1] / Math.max(hy, 1e-6), q[2] / Math.max(hz, 1e-6)]);
@@ -3445,14 +4962,14 @@ var GameVegetationThree = (() => {
         const dark = shade(col, 0.62);
         const apex = [lean * (y / H) ** 2, y + tierH * 0.55, 0];
         const innerR = r * 0.32;
-        const ring = (rad, yy, k, ph) => [apex[0] + Math.cos(k / K * TAU + ph) * rad, yy, Math.sin(k / K * TAU + ph) * rad];
+        const ring2 = (rad, yy, k, ph) => [apex[0] + Math.cos(k / K * TAU + ph) * rad, yy, Math.sin(k / K * TAU + ph) * rad];
         const tphase = i * 0.7;
         for (let k = 0; k < K; k++) {
           const jag = k % 2 === 0 ? 1 : 0.78;
-          const a0 = ring(innerR, y + tierH * 0.12, k, tphase);
-          const a1 = ring(innerR, y + tierH * 0.12, k + 1, tphase);
-          const o0 = ring(r * jag, y - tierH * 0.42, k, tphase);
-          const o1 = ring(r * (k % 2 === 0 ? 0.78 : 1), y - tierH * 0.42, k + 1, tphase);
+          const a0 = ring2(innerR, y + tierH * 0.12, k, tphase);
+          const a1 = ring2(innerR, y + tierH * 0.12, k + 1, tphase);
+          const o0 = ring2(r * jag, y - tierH * 0.42, k, tphase);
+          const o1 = ring2(r * (k % 2 === 0 ? 0.78 : 1), y - tierH * 0.42, k + 1, tphase);
           const sw = 0.25 + 0.35 * (1 - f);
           foliage.flat(apex, a1, a0, shade(lightTop, 0.85), 0.2, [0, 1, 0]);
           foliage.flatTri(a0, a1, o1, mix(col, lightTop, 0.2), mix(col, lightTop, 0.2), lightTop, 0.2, 0.2, sw, [0, 1, 0]);
@@ -3641,12 +5158,12 @@ var GameVegetationThree = (() => {
       const a1 = (i + 1) / sides * TAU;
       ctx.wood.flatTri([0, soilY, 0], [Math.cos(a1) * rim, soilY, Math.sin(a1) * rim], [Math.cos(a0) * rim, soilY, Math.sin(a0) * rim], shade(soil, 0.9), soil, soil, 0, 0, 0, [0, 1, 0]);
     }
-    const inner = generate(spec.plant, { seed: ctx.rng.fork("plant").seed(), lod: ctx.lod, condition: ctx.condition, season: ctx.season });
+    const inner = generate2(spec.plant, { seed: ctx.rng.fork("plant").seed(), lod: ctx.lod, condition: ctx.condition, season: ctx.season });
     const yOff = soilY - 0.02;
     const tagsOf = (part) => {
-      const mesh = inner.parts[part];
-      if (!mesh) return void 0;
-      const tags = new Array(mesh.triangleCount).fill("");
+      const mesh2 = inner.parts[part];
+      if (!mesh2) return void 0;
+      const tags = new Array(mesh2.triangleCount).fill("");
       for (const pc of inner.pieces) {
         if (pc.part !== part) continue;
         if (!ctx.pieceMeta.has(pc.id)) ctx.pieceMeta.set(pc.id, { kind: pc.kind, parent: pc.parent, pivot: [pc.pivot[0], pc.pivot[1] + yOff, pc.pivot[2]], ...pc.radius === void 0 || pc.length === void 0 || !pc.axis || !pc.base ? {} : { geom: { radius: pc.radius, length: pc.length, axis: pc.axis, base: [pc.base[0], pc.base[1] + yOff, pc.base[2]] } } });
@@ -3686,7 +5203,7 @@ var GameVegetationThree = (() => {
   function archetypes() {
     return Object.keys(GENERATORS);
   }
-  function generate(spec, opts = {}) {
+  function generate2(spec, opts = {}) {
     const gen = GENERATORS[spec.archetype];
     if (!gen) throw new Error(`game-vegetation: unknown archetype "${spec.archetype}"`);
     const seed = toSeed(opts.seed);
@@ -3895,29 +5412,29 @@ var GameVegetationThree = (() => {
     }
     const tagBox = /* @__PURE__ */ new Map();
     for (const part of PART_ORDER) {
-      const mesh = parts[part];
-      if (!mesh) continue;
+      const mesh2 = parts[part];
+      if (!mesh2) continue;
       for (const r of builders[part].ranges) {
         const tag = r.tag || rootId;
-        let box = tagBox.get(tag);
-        if (!box) tagBox.set(tag, box = { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] });
+        let box2 = tagBox.get(tag);
+        if (!box2) tagBox.set(tag, box2 = { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] });
         for (let i = r.indexStart; i < r.indexStart + r.indexCount; i++) {
-          const v = mesh.indices[i] * 3;
+          const v = mesh2.indices[i] * 3;
           for (let a = 0; a < 3; a++) {
-            const c = mesh.positions[v + a];
-            if (c < box.min[a]) box.min[a] = c;
-            if (c > box.max[a]) box.max[a] = c;
+            const c = mesh2.positions[v + a];
+            if (c < box2.min[a]) box2.min[a] = c;
+            if (c > box2.max[a]) box2.max[a] = c;
           }
         }
       }
     }
     const fruitHang = /* @__PURE__ */ new Map();
     const PRIORITY = { branch: 0, pad: 0, arm: 0, stem: 1, trunk: 1, crown: 2 };
-    for (const [tag, box] of tagBox) {
+    for (const [tag, box2] of tagBox) {
       if (meta.get(tag)?.kind !== "fruit") continue;
-      const cx = (box.min[0] + box.max[0]) / 2;
-      const cy = (box.min[1] + box.max[1]) / 2;
-      const cz = (box.min[2] + box.max[2]) / 2;
+      const cx = (box2.min[0] + box2.max[0]) / 2;
+      const cy = (box2.min[1] + box2.max[1]) / 2;
+      const cz = (box2.min[2] + box2.max[2]) / 2;
       let parent;
       let pbox;
       let bd = Infinity;
@@ -3939,24 +5456,24 @@ var GameVegetationThree = (() => {
           pbox = pb;
         }
       }
-      const pc = pbox ? [(pbox.min[0] + pbox.max[0]) / 2, (pbox.min[1] + pbox.max[1]) / 2, (pbox.min[2] + pbox.max[2]) / 2] : [cx, box.max[1], cz];
-      const pivot = [Math.min(box.max[0], Math.max(box.min[0], pc[0])), Math.min(box.max[1], Math.max(box.min[1], pc[1])), Math.min(box.max[2], Math.max(box.min[2], pc[2]))];
+      const pc = pbox ? [(pbox.min[0] + pbox.max[0]) / 2, (pbox.min[1] + pbox.max[1]) / 2, (pbox.min[2] + pbox.max[2]) / 2] : [cx, box2.max[1], cz];
+      const pivot = [Math.min(box2.max[0], Math.max(box2.min[0], pc[0])), Math.min(box2.max[1], Math.max(box2.min[1], pc[1])), Math.min(box2.max[2], Math.max(box2.min[2], pc[2]))];
       fruitHang.set(tag, { parent, pivot });
     }
     const idOf = (tag, part) => primary.get(tag) === part ? tag : `${tag}:${part}`;
     const out = [];
     for (const part of PART_ORDER) {
-      const mesh = parts[part];
-      if (!mesh) continue;
+      const mesh2 = parts[part];
+      if (!mesh2) continue;
       for (const r of builders[part].ranges) {
         const tag = r.tag || rootId;
         const m = meta.get(tag) ?? { kind: "stem" };
         const min = [Infinity, Infinity, Infinity];
         const max = [-Infinity, -Infinity, -Infinity];
         for (let i = r.indexStart; i < r.indexStart + r.indexCount; i++) {
-          const v = mesh.indices[i] * 3;
+          const v = mesh2.indices[i] * 3;
           for (let a = 0; a < 3; a++) {
-            const c = mesh.positions[v + a];
+            const c = mesh2.positions[v + a];
             if (c < min[a]) min[a] = c;
             if (c > max[a]) max[a] = c;
           }
@@ -3968,7 +5485,7 @@ var GameVegetationThree = (() => {
         else if (m.kind === "crown" || m.kind === "fruit") pivot = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
         else pivot = [(min[0] + max[0]) / 2, min[1], (min[2] + max[2]) / 2];
         if (m.kind === "trunk" || m.kind === "stem" || m.kind === "pot" || m.kind === "soil") pivot = [0, min[1], 0];
-        let material = materialKeyForPart(part, mesh.material, condition);
+        let material = materialKeyForPart(part, mesh2.material, condition);
         if (m.kind === "pot") material = "pot";
         else if (m.kind === "soil") material = "soil";
         const parentTag = hang ? hang.parent : m.parent;
@@ -4012,10 +5529,10 @@ var GameVegetationThree = (() => {
       const go = { seed: hashMix(base, p.seed), lod, condition: opts.condition, season: opts.season };
       let plant;
       if (smallLod !== lod) {
-        const cheap = generate(spec, { ...go, lod: smallLod });
+        const cheap = generate2(spec, { ...go, lod: smallLod });
         if (cheap.bounds.height * p.scale <= smallMax) plant = cheap;
       }
-      plant ?? (plant = generate(spec, go));
+      plant ?? (plant = generate2(spec, go));
       total += plant.triangleCount;
       entries.push({ p, plant, go, spec });
     }
@@ -4039,7 +5556,7 @@ var GameVegetationThree = (() => {
         const group = entries.filter((e) => !e.dropped && kindOf(e) === kind && e.plant.lod < 2).sort((a, b) => a.plant.bounds.height * a.p.scale - b.plant.bounds.height * b.p.scale);
         for (const e of group) {
           if (total <= budget) break;
-          const cheap = generate(e.spec, { ...e.go, lod: 2 });
+          const cheap = generate2(e.spec, { ...e.go, lod: 2 });
           total += cheap.triangleCount - e.plant.triangleCount;
           e.plant = cheap;
         }
@@ -4055,9 +5572,9 @@ var GameVegetationThree = (() => {
       lodCounts[plant.lod]++;
       const { parts } = plant;
       const tagsOf = (part) => {
-        const mesh = parts[part];
-        if (!mesh) return void 0;
-        const tags = new Array(mesh.triangleCount).fill("");
+        const mesh2 = parts[part];
+        if (!mesh2) return void 0;
+        const tags = new Array(mesh2.triangleCount).fill("");
         for (const pc of plant.pieces) {
           if (pc.part !== part) continue;
           for (let t = pc.indexStart / 3; t < (pc.indexStart + pc.indexCount) / 3; t++) tags[t] = `${pi}|${pc.id}`;
@@ -4082,8 +5599,8 @@ var GameVegetationThree = (() => {
     };
     for (const k of Object.keys(meshes)) if (!meshes[k]) delete meshes[k];
     const rangeOf = /* @__PURE__ */ new Map();
-    for (const [mesh, b] of [["wood", wood], ["foliage", foliage], ["flowers", flowers]]) {
-      for (const r of b.ranges) if (r.tag) rangeOf.set(r.tag, { mesh, indexStart: r.indexStart, indexCount: r.indexCount });
+    for (const [mesh2, b] of [["wood", wood], ["foliage", foliage], ["flowers", flowers]]) {
+      for (const r of b.ranges) if (r.tag) rangeOf.set(r.tag, { mesh: mesh2, indexStart: r.indexStart, indexCount: r.indexCount });
     }
     const pieceTable = kept.map(({ plantIndex, e }) => ({
       plantIndex,
@@ -4111,7 +5628,7 @@ var GameVegetationThree = (() => {
   function extractPlant(lot, plantIndex) {
     const e = entryOf(lot, plantIndex);
     return {
-      plant: generate(e.spec, { ...e.generateOptions, species: e.species }),
+      plant: generate2(e.spec, { ...e.generateOptions, species: e.species }),
       placement: { species: e.species, x: e.x, z: e.z, ry: e.ry, scale: e.scale },
       ranges: e.pieces
     };
@@ -4173,10 +5690,10 @@ var GameVegetationThree = (() => {
     }
     return w[w.length - 1].id;
   }
-  function scatter(area, rules, opts) {
-    const poly = regionPolygon(area);
+  function scatter(area3, rules, opts) {
+    const poly = regionPolygon(area3);
     const seed = toSeed(opts.seed);
-    const area2 = polygonArea(poly);
+    const area22 = polygonArea(poly);
     let minX = Infinity;
     let minZ = Infinity;
     let maxX = -Infinity;
@@ -4192,11 +5709,11 @@ var GameVegetationThree = (() => {
     const grid = /* @__PURE__ */ new Map();
     const key = (cx, cz) => cx + "," + cz;
     const out = [];
-    const inradius = Math.max(0.5, Math.sqrt(area2) * 0.5);
+    const inradius = Math.max(0.5, Math.sqrt(area22) * 0.5);
     rules.forEach((rule, ri) => {
       const rng = new Rng(hashMix(seed, ri + 1));
       const ex = [...globalEx, ...(rule.exclude ?? []).map(regionPolygon)];
-      let target = Math.round(area2 * rule.density);
+      let target = Math.round(area22 * rule.density);
       if (rule.maxCount !== void 0) target = Math.min(target, rule.maxCount);
       const prefer = rule.prefer ?? "any";
       const edgeW = rule.edgeWidth ?? Math.max(0.4, rule.minDistance * 0.8);
@@ -4243,8 +5760,8 @@ var GameVegetationThree = (() => {
         }
         if (!ok) continue;
         const k = key(cx, cz);
-        const list = grid.get(k);
-        if (list) list.push({ x, z, md: rule.minDistance });
+        const list2 = grid.get(k);
+        if (list2) list2.push({ x, z, md: rule.minDistance });
         else grid.set(k, [{ x, z, md: rule.minDistance }]);
         out.push({ species: spec, x, z, ry, scale, seed: sd });
         placed++;
@@ -4348,7 +5865,7 @@ var GameVegetationThree = (() => {
     toBufferGeometry: () => toBufferGeometry
   });
   var MAX_ACTORS = 4;
-  var COMMON = (
+  var COMMON2 = (
     /* glsl */
     `
 #include <common>
@@ -4409,13 +5926,13 @@ gl_Position = projectionMatrix * mvPosition;
     const patch = (m) => {
       m.onBeforeCompile = (shader) => {
         Object.assign(shader.uniforms, uniforms);
-        shader.vertexShader = shader.vertexShader.replace("#include <common>", COMMON).replace("#include <project_vertex>", PROJECT);
+        shader.vertexShader = shader.vertexShader.replace("#include <common>", COMMON2).replace("#include <project_vertex>", PROJECT);
       };
       m.customProgramCacheKey = () => "vegetation-sway-v1";
     };
     const flat = opts.flatShading !== false;
     const rough = typeof opts.roughness === "number" ? opts.roughness : 0.85;
-    const make = (flatShading, double, roughness) => {
+    const make2 = (flatShading, double, roughness) => {
       const m = new THREE.MeshStandardMaterial({
         vertexColors: true,
         flatShading,
@@ -4426,11 +5943,11 @@ gl_Position = projectionMatrix * mvPosition;
       patch(m);
       return m;
     };
-    const wood = make(false, false, 0.95);
-    const foliage = make(flat, true, rough);
-    const flowers = make(flat, true, 0.7);
-    const fruit = make(flat, false, 0.55);
-    const spines = make(true, true, 0.8);
+    const wood = make2(false, false, 0.95);
+    const foliage = make2(flat, true, rough);
+    const flowers = make2(flat, true, 0.7);
+    const fruit = make2(flat, false, 0.55);
+    const spines = make2(true, true, 0.8);
     const dir = uniforms.uWindDir.value;
     return {
       materialIds: resolveMaterialIds(opts.materialIds),
@@ -4468,13 +5985,13 @@ gl_Position = projectionMatrix * mvPosition;
     };
   }
   var PART_ORDER2 = ["wood", "foliage", "flowers", "fruit", "spines"];
-  function toBufferGeometry(THREE, mesh) {
+  function toBufferGeometry(THREE, mesh2) {
     const g = new THREE.BufferGeometry();
-    g.setAttribute("position", new THREE.BufferAttribute(mesh.positions, 3));
-    g.setAttribute("normal", new THREE.BufferAttribute(mesh.normals, 3));
-    g.setAttribute("color", new THREE.BufferAttribute(mesh.colors, 3));
-    g.setAttribute("sway", new THREE.BufferAttribute(mesh.sway, 1));
-    g.setIndex(new THREE.BufferAttribute(mesh.indices, 1));
+    g.setAttribute("position", new THREE.BufferAttribute(mesh2.positions, 3));
+    g.setAttribute("normal", new THREE.BufferAttribute(mesh2.normals, 3));
+    g.setAttribute("color", new THREE.BufferAttribute(mesh2.colors, 3));
+    g.setAttribute("sway", new THREE.BufferAttribute(mesh2.sway, 1));
+    g.setIndex(new THREE.BufferAttribute(mesh2.indices, 1));
     g.computeBoundingSphere();
     g.computeBoundingBox();
     return g;
@@ -4488,18 +6005,18 @@ gl_Position = projectionMatrix * mvPosition;
   function meshFor(THREE, data, material, ids, condition) {
     const geo = toBufferGeometry(THREE, data);
     inflate(geo, 0.4);
-    const mesh = new THREE.Mesh(geo, material);
-    mesh.name = data.kind;
-    mesh.userData.damageable = { material: data.material };
-    if (ids) mesh.userData.destructionMaterial = ids[materialKeyForPart(data.kind, data.material, condition)];
-    return mesh;
+    const mesh2 = new THREE.Mesh(geo, material);
+    mesh2.name = data.kind;
+    mesh2.userData.damageable = { material: data.material };
+    if (ids) mesh2.userData.destructionMaterial = ids[materialKeyForPart(data.kind, data.material, condition)];
+    return mesh2;
   }
-  function slicePiece(mesh, indexStart, indexCount, origin) {
+  function slicePiece(mesh2, indexStart, indexCount, origin) {
     const remap = /* @__PURE__ */ new Map();
     const order = [];
     const indices = new Uint32Array(indexCount);
     for (let i = 0; i < indexCount; i++) {
-      const v = mesh.indices[indexStart + i];
+      const v = mesh2.indices[indexStart + i];
       let n = remap.get(v);
       if (n === void 0) {
         n = order.length;
@@ -4514,14 +6031,14 @@ gl_Position = projectionMatrix * mvPosition;
     const sway = new Float32Array(order.length);
     for (let i = 0; i < order.length; i++) {
       const v = order[i];
-      positions[i * 3] = mesh.positions[v * 3] - origin[0];
-      positions[i * 3 + 1] = mesh.positions[v * 3 + 1] - origin[1];
-      positions[i * 3 + 2] = mesh.positions[v * 3 + 2] - origin[2];
-      normals.set(mesh.normals.subarray(v * 3, v * 3 + 3), i * 3);
-      colors.set(mesh.colors.subarray(v * 3, v * 3 + 3), i * 3);
-      sway[i] = mesh.sway[v];
+      positions[i * 3] = mesh2.positions[v * 3] - origin[0];
+      positions[i * 3 + 1] = mesh2.positions[v * 3 + 1] - origin[1];
+      positions[i * 3 + 2] = mesh2.positions[v * 3 + 2] - origin[2];
+      normals.set(mesh2.normals.subarray(v * 3, v * 3 + 3), i * 3);
+      colors.set(mesh2.colors.subarray(v * 3, v * 3 + 3), i * 3);
+      sway[i] = mesh2.sway[v];
     }
-    return { positions, normals, colors, sway, indices, triangleCount: indexCount / 3, kind: mesh.kind, material: mesh.material };
+    return { positions, normals, colors, sway, indices, triangleCount: indexCount / 3, kind: mesh2.kind, material: mesh2.material };
   }
   function createPlantObject(THREE, plant, materials, options = {}) {
     const mats = materials ?? createVegetationMaterials(THREE);
@@ -4533,13 +6050,13 @@ gl_Position = projectionMatrix * mvPosition;
         const src = plant.parts[pc.part];
         if (!src) continue;
         const data = slicePiece(src, pc.indexStart, pc.indexCount, pc.pivot);
-        const mesh = meshFor(THREE, data, mats[pc.part]);
-        mesh.name = pc.id;
-        mesh.position.set(pc.pivot[0], pc.pivot[1], pc.pivot[2]);
+        const mesh2 = meshFor(THREE, data, mats[pc.part]);
+        mesh2.name = pc.id;
+        mesh2.position.set(pc.pivot[0], pc.pivot[1], pc.pivot[2]);
         const id = ids[pc.material];
-        mesh.userData.destructionMaterial = id;
-        mesh.userData.destructionPart = { id: pc.id, kind: pc.kind, parent: pc.parent, material: id, materialKey: pc.material, ...pc.radius === void 0 ? {} : { radius: pc.radius, length: pc.length, axis: pc.axis, base: pc.base } };
-        g.add(mesh);
+        mesh2.userData.destructionMaterial = id;
+        mesh2.userData.destructionPart = { id: pc.id, kind: pc.kind, parent: pc.parent, material: id, materialKey: pc.material, ...pc.radius === void 0 ? {} : { radius: pc.radius, length: pc.length, axis: pc.axis, base: pc.base } };
+        g.add(mesh2);
       }
       g.userData = { collider: plant.collider, bendable: plant.bendable, thorny: plant.thorny, species: plant.species, bounds: plant.bounds, pieces: plant.pieces, separable: true };
       return g;
@@ -4618,10 +6135,10 @@ gl_Position = projectionMatrix * mvPosition;
     const d = opts.distances ?? [0, 25, 60];
     const lod = new THREE.LOD();
     for (const l of [0, 1, 2]) {
-      const plant = generate(spec, { ...opts, lod: l });
+      const plant = generate2(spec, { ...opts, lod: l });
       lod.addLevel(createPlantObject(THREE, plant, mats), d[l]);
     }
-    lod.userData = { collider: generate(spec, { ...opts, lod: 2 }).collider };
+    lod.userData = { collider: generate2(spec, { ...opts, lod: 2 }).collider };
     return lod;
   }
 
@@ -7830,16 +9347,16 @@ gl_Position = projectionMatrix * mvPosition;
     };
   }
   function pickForContext(region, context, rng) {
-    const list = region.contexts[context];
-    if (!list || list.length === 0) throw new Error(`game-vegetation-species: region "${region.id}" has no context "${context}"`);
+    const list2 = region.contexts[context];
+    if (!list2 || list2.length === 0) throw new Error(`game-vegetation-species: region "${region.id}" has no context "${context}"`);
     const next = toNext(rng);
-    const total = list.reduce((a, b) => a + b.weight, 0);
+    const total = list2.reduce((a, b) => a + b.weight, 0);
     let r = next() * total;
-    for (const it of list) {
+    for (const it of list2) {
       r -= it.weight;
       if (r <= 0) return it.species;
     }
-    return list[list.length - 1].species;
+    return list2[list2.length - 1].species;
   }
 
   // src/test-area/nursery.ts
@@ -7867,10 +9384,10 @@ gl_Position = projectionMatrix * mvPosition;
     for (const planting of plantings) {
       const { rules, picks } = species2.scatterRulesFor(species2.regions.br, planting.context, seed, planting.options);
       for (const p of picks) used.add(p.id);
-      planting.areas.forEach((area, i) => {
+      planting.areas.forEach((area3, 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 }));
+        placements.push(...sdk.scatter(area3, perArea, { seed: `${seed}:${planting.tag}:${i}`, exclude }));
       });
     }
     return { placements, used };
@@ -7878,45 +9395,46 @@ gl_Position = projectionMatrix * mvPosition;
   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 material = (color2, roughness = 0.9) => new THREE.MeshStandardMaterial({ color: color2, 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 box2 = (w, h, d, m, x, y, z) => {
+      const mesh2 = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), m);
+      mesh2.position.set(x, y, z);
+      mesh2.castShadow = mesh2.receiveShadow = true;
+      g.add(mesh2);
+      return mesh2;
     };
     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);
+    box2(30, 0.04, 4.6, mats.asphalt, 6, 0, -4.6);
+    box2(30, 0.1, 2.2, mats.concrete, 6, 0.04, -1.1);
+    box2(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);
+    box2(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);
+    box2(1.1, 2.1, 0.08, mats.door, 6, 1.05, HOUSE.z0 - 0.04);
+    box2(1.6, 1.1, 0.08, mats.glass, 3.8, 1.5, HOUSE.z0 - 0.04);
+    box2(1.6, 1.1, 0.08, mats.glass, 8.2, 1.5, HOUSE.z0 - 0.04);
+    box2(5, 1.4, 0.2, mats.wall, 2.5, 0.7, 0);
+    box2(5, 1.4, 0.2, mats.wall, 9.5, 0.7, 0);
+    box2(0.2, 1.8, LOT.D, mats.wall, 0, 0.9, 10);
+    box2(0.2, 1.8, LOT.D, mats.wall, LOT.W, 0.9, 10);
+    box2(LOT.W, 1.8, 0.2, mats.wall, 6, 0.9, LOT.D);
     return g;
   }
   function createNursery(sdk, species2, THREE, materials, parent, origin) {
+    const T = shapeGeometries(THREE);
     const group = new THREE.Group();
     group.name = "nursery";
     group.position.set(origin[0], 0, origin[1]);
@@ -7926,13 +9444,13 @@ gl_Position = projectionMatrix * mvPosition;
     let scenery = null;
     let lotObject = null;
     let data = null;
-    let stats = null;
+    let stats2 = 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) => {
+    const disposeObject = (object2) => {
+      object2.traverse((child) => {
         child.geometry?.dispose?.();
       });
     };
@@ -7946,8 +9464,8 @@ gl_Position = projectionMatrix * mvPosition;
     const ensure = () => {
       if (attached) return;
       attached = true;
-      scenery = buildScenery(THREE);
-      const body = THREE.CapsuleGeometry ? new THREE.CapsuleGeometry(0.28, 1, 4, 10) : new THREE.CylinderGeometry(0.28, 0.28, 1.56, 10);
+      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);
@@ -7971,7 +9489,7 @@ gl_Position = projectionMatrix * mvPosition;
     return {
       group,
       get stats() {
-        return stats;
+        return stats2;
       },
       get planted() {
         return lotObject !== null;
@@ -8004,12 +9522,12 @@ gl_Position = projectionMatrix * mvPosition;
         });
         dynamic.add(lotObject);
         for (const c of data.colliders) {
-          const m = new THREE.Mesh(new THREE.CylinderGeometry(c.r, c.r, c.h, 14, 1, true), new THREE.MeshBasicMaterial({ color: c.damage ? 16742938 : 15017245, wireframe: true }));
+          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;
+        stats2 = { triangles: data.triangleCount, plants: data.plantCount, colliders: data.colliders.length, meshes: Object.keys(data.meshes).length, lod: data.lodCounts, buildMs, species: used.size };
+        return stats2;
       },
       /** The colliders of the lot as wire cylinders. */
       showColliders(on) {
@@ -8071,7 +9589,7 @@ gl_Position = projectionMatrix * mvPosition;
           actor = null;
         }
         data = null;
-        stats = null;
+        stats2 = null;
         walker.x = WAY[0][0];
         walker.z = WAY[0][1];
         walker.waypoint = 0;
@@ -8079,6 +9597,15 @@ gl_Position = projectionMatrix * mvPosition;
     };
   }
 
+  // ../game-contracts/dist/index.js
+  var KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object2, origin) {
+    const node = object2;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object2;
+  }
+
   // src/test-area/plants.ts
   var PLANT_SEED = 3;
   var PLANT_DEFS = [
@@ -8122,25 +9649,25 @@ gl_Position = projectionMatrix * mvPosition;
       return plant;
     };
     function buildObject(THREE, def) {
-      const root = new THREE.Group();
+      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 object2 = sdk.createPlantObject(THREE, plant, materials(THREE), { separable: true });
         const prefix = segments > 1 ? `s${s}_` : "";
-        const children = object.children.slice();
+        const children = object2.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;
+        for (const mesh2 of children) {
+          const piece = mesh2.userData.destructionPart;
           const bits = String(piece.id).split(":");
           const id = prefix + sanitize(piece.id);
-          mesh.name = id;
+          mesh2.name = id;
           const dx = (s - (segments - 1) / 2) * spacing;
           const meta = {
             id,
@@ -8156,10 +9683,10 @@ gl_Position = projectionMatrix * mvPosition;
             axis: piece.axis,
             dx
           };
-          mesh.userData.veg = meta;
-          mesh.position.x += dx;
-          mesh.castShadow = true;
-          root.add(mesh);
+          mesh2.userData.veg = meta;
+          mesh2.position.x += dx;
+          mesh2.castShadow = true;
+          root.add(mesh2);
         }
         if (s === 0) {
           root.userData.collider = plant.collider || null;
@@ -8381,7 +9908,7 @@ gl_Position = projectionMatrix * mvPosition;
       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 box2 = (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]);
@@ -8398,8 +9925,8 @@ gl_Position = projectionMatrix * mvPosition;
         }
         return { min: mn, max: mx };
       };
-      const A_ = box(a);
-      const B_ = box(b);
+      const A_ = box2(a);
+      const B_ = box2(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";
@@ -8828,17 +10355,17 @@ gl_Position = projectionMatrix * mvPosition;
         };
         if (host.bench.layer("colliders") && root.userData.collider && root.userData.collider.kind) {
           const c = root.userData.collider;
-          const wire = new three.Mesh(new three.CylinderGeometry(c.radius, c.radius, c.height, 14, 1, true), new three.MeshBasicMaterial({ color: root.userData.thorny ? 16742938 : 15017245, wireframe: true }));
+          const wire = new three.Mesh(new (shapeGeometries(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;
+        for (const mesh2 of root.children) {
+          const v = mesh2.userData?.veg;
+          if (!v || !mesh2.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));
+            mesh2.geometry.computeBoundingBox();
+            const box2 = mesh2.geometry.boundingBox.clone().translate(mesh2.position);
+            mark(new three.Box3Helper(box2, 6737151));
           }
           if (host.bench.layer("wood_axes") && v.radius !== void 0 && v.length !== void 0 && v.axis && !v.sub) {
             const base = pieceBase(root, v);
@@ -8854,8 +10381,8 @@ gl_Position = projectionMatrix * mvPosition;
       helpersShown = boxKey();
     };
     const pieceBase = (root, v) => {
-      const mesh = root.children.find((c) => c.userData?.veg?.id === v.id);
-      const base = mesh?.userData?.destructionPart?.base;
+      const mesh2 = root.children.find((c) => c.userData?.veg?.id === v.id);
+      const base = mesh2?.userData?.destructionPart?.base;
       return Array.isArray(base) ? base : null;
     };
     const nurseryOf = () => {
@@ -8866,9 +10393,9 @@ gl_Position = projectionMatrix * mvPosition;
     const plantLot = () => {
       const n = nurseryOf();
       if (!n || !host) return;
-      const stats = n.plant(settings);
+      const stats2 = 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 });
+      host.log(fill(text.lot.planted, stats2.plants, stats2.triangles, stats2.colliders), { plants: stats2.plants, triangles: stats2.triangles });
     };
     const replant = () => {
       if (nursery?.planted) plantLot();
@@ -8937,12 +10464,12 @@ gl_Position = projectionMatrix * mvPosition;
       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;
+        entry.root.traverse((mesh2) => {
+          if (!mesh2.isMesh || mesh2.userData.helper) return;
+          for (let p = mesh2; p; p = p.parent) if (p.visible === false) return;
           drawCalls += 1;
-          if (mesh.userData.veg) pieces += 1;
-          const g = mesh.geometry;
+          if (mesh2.userData.veg) pieces += 1;
+          const g = mesh2.geometry;
           triangles += (g.index ? g.index.count : g.attributes.position.count) / 3;
         });
       }
@@ -8997,9 +10524,9 @@ gl_Position = projectionMatrix * mvPosition;
         { 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 },
+        { 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 }
+        { 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: () => [