@adatechnology/game-characters-three 0.2.1 → 0.3.1

package/dist/index.global.js

@@ -21,6 +21,7 @@ var GameCharactersThree = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    AVATAR_AREA_ID: () => AVATAR_AREA_ID,
     BAKE_NEUTRAL_POSE: () => BAKE_NEUTRAL_POSE,
     BODY_CHUNK: () => BODY_CHUNK,
     BODY_MATERIAL_DEF: () => BODY_MATERIAL_DEF,
@@ -30,6 +31,10 @@ var GameCharactersThree = (() => {
     CHARACTER_SOUND_BANK: () => CHARACTER_SOUND_BANK,
     EXTRAS: () => EXTRAS,
     FACE_FEATURES: () => FACE_FEATURES,
+    FIRST_PERSON_BOB: () => FIRST_PERSON_BOB,
+    FIRST_PERSON_COLORS: () => FIRST_PERSON_COLORS,
+    FIRST_PERSON_RIG: () => FIRST_PERSON_RIG,
+    FIRST_PERSON_STANCES: () => FIRST_PERSON_STANCES,
     HAND_ITEMS: () => HAND_ITEMS,
     HATS: () => HATS,
     HIT_PRESETS: () => HIT_PRESETS,
@@ -51,6 +56,7 @@ var GameCharactersThree = (() => {
     blobRadii: () => blobRadii,
     bloodLookOfAge: () => bloodLookOfAge,
     buildInstancedBody: () => buildInstancedBody,
+    createAvatarTestModule: () => createAvatarTestModule,
     createBestBuilder: () => createBestBuilder,
     createBodyBatch: () => createBodyBatch,
     createBodyChunk: () => createBodyChunk,
@@ -58,12 +64,14 @@ var GameCharactersThree = (() => {
     createCharacterSound: () => createCharacterSound,
     createCharactersTestModule: () => createCharactersTestModule,
     createEye: () => createEye,
+    createFirstPersonArms: () => createFirstPersonArms,
     createFluidsBridge: () => createFluidsBridge,
     createFlyingLimbs: () => createFlyingLimbs,
     createFlyingPieces: () => createFlyingPieces,
     createGlowTexture: () => createGlowTexture,
     createPendulum: () => createPendulum,
     createPersonBuilder: () => createPersonBuilder,
+    createPlayerAvatar: () => createPlayerAvatar,
     createRigAnimator: () => createRigAnimator,
     createVariantBatches: () => createVariantBatches,
     createWoundMaterials: () => createWoundMaterials,
@@ -78,8 +86,10 @@ var GameCharactersThree = (() => {
     makeStump: () => makeStump,
     registerBodyMaterial: () => registerBodyMaterial,
     ringWound: () => ringWound,
+    solveTwoBone: () => solveTwoBone,
     starGeometry: () => starGeometry,
     stepPendulum: () => stepPendulum,
+    toRoomAvatar: () => toRoomAvatar,
     woundBodyOf: () => woundBodyOf,
     woundDecal: () => woundDecal
   });
@@ -160,7 +170,1540 @@ var GameCharactersThree = (() => {
   var HIP_PIVOT = "vec3(0.,0.95,0.)";
   var createBodyChunk = ({ hipHeight = 0.95 } = {}) => hipHeight === 0.95 ? BODY_CHUNK : BODY_CHUNK.replaceAll(HIP_PIVOT, `vec3(0.,${hipHeight},0.)`);
 
+  // ../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, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube, 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 + tube * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube * Math.cos(v)) * Math.sin(u);
+        const z = tube * 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 p2 = start, again;
+    do {
+      again = false;
+      if (!p2.steiner && (equals(p2, p2.next) || area(p2.prev, p2, p2.next) === 0)) {
+        removeNode(p2);
+        p2 = end = p2.prev;
+        if (p2 === p2.next) break;
+        again = true;
+      } else {
+        p2 = p2.next;
+      }
+    } while (again || p2 !== 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 p2 = c.next;
+    while (p2 !== a) {
+      if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+      p2 = p2.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 p2 = ear.prevZ, n = ear.nextZ;
+    while (p2 && p2.z >= minZ && n && n.z <= maxZ) {
+      if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a && p2 !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+      p2 = p2.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 (p2 && p2.z >= minZ) {
+      if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a && p2 !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+      p2 = p2.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 p2 = start;
+    do {
+      const a = p2.prev, b = p2.next.next;
+      if (!equals(a, b) && intersects(a, p2, p2.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p2.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p2);
+        removeNode(p2.next);
+        p2 = start = b;
+      }
+      p2 = p2.next;
+    } while (p2 !== start);
+    return filterPoints(p2);
+  }
+  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, len, start, end, list2;
+    for (i = 0, len = holeIndices.length; i < len; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len - 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 p2 = outerNode, qx = -Infinity, m;
+    const hx = hole.x, hy = hole.y;
+    do {
+      if (hy <= p2.y && hy >= p2.next.y && p2.next.y !== p2.y) {
+        const x = p2.x + (hy - p2.y) * (p2.next.x - p2.x) / (p2.next.y - p2.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          m = p2.x < p2.next.x ? p2 : p2.next;
+          if (x === hx) return m;
+        }
+      }
+      p2 = p2.next;
+    } while (p2 !== outerNode);
+    if (!m) return null;
+    const stop = m, mx = m.x, my = m.y;
+    let tanMin = Infinity, tan;
+    p2 = m;
+    do {
+      if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) {
+        tan = Math.abs(hy - p2.y) / (hx - p2.x);
+        if (locallyInside(p2, hole) && (tan < tanMin || tan === tanMin && (p2.x > m.x || p2.x === m.x && sectorContainsSector(m, p2)))) {
+          m = p2;
+          tanMin = tan;
+        }
+      }
+      p2 = p2.next;
+    } while (p2 !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p2) {
+    return area(m.prev, m, p2.prev) < 0 && area(p2.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p2 = start;
+    do {
+      if (p2.z === 0) p2.z = zOrder(p2.x, p2.y, minX, minY, invSize);
+      p2.prevZ = p2.prev;
+      p2.nextZ = p2.next;
+      p2 = p2.next;
+    } while (p2 !== start);
+    p2.prevZ.nextZ = null;
+    p2.prevZ = null;
+    sortLinked(p2);
+  }
+  function sortLinked(list2) {
+    let i, p2, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+    do {
+      p2 = list2;
+      list2 = null;
+      tail = null;
+      numMerges = 0;
+      while (p2) {
+        numMerges++;
+        q = p2;
+        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 || p2.z <= q.z)) {
+            e = p2;
+            p2 = p2.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail) tail.nextZ = e;
+          else list2 = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p2 = 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 p2 = start, leftmost = start;
+    do {
+      if (p2.x < leftmost.x || p2.x === leftmost.x && p2.y < leftmost.y) leftmost = p2;
+      p2 = p2.next;
+    } while (p2 !== 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(p2, q, r) {
+    return (q.y - p2.y) * (r.x - q.x) - (q.x - p2.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(p2, q, r) {
+    return q.x <= Math.max(p2.x, r.x) && q.x >= Math.min(p2.x, r.x) && q.y <= Math.max(p2.y, r.y) && q.y >= Math.min(p2.y, r.y);
+  }
+  function sign(num2) {
+    return num2 > 0 ? 1 : num2 < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p2 = a;
+    do {
+      if (p2.i !== a.i && p2.next.i !== a.i && p2.i !== b.i && p2.next.i !== b.i && intersects(p2, p2.next, a, b)) return true;
+      p2 = p2.next;
+    } while (p2 !== 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 p2 = a, inside = false;
+    const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+    do {
+      if (p2.y > py !== p2.next.y > py && p2.next.y !== p2.y && px < (p2.next.x - p2.x) * (py - p2.y) / (p2.next.y - p2.y) + p2.x)
+        inside = !inside;
+      p2 = p2.next;
+    } while (p2 !== 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 p2 = new Node(i, x, y);
+    if (!last) {
+      p2.prev = p2;
+      p2.next = p2;
+    } else {
+      p2.next = last.next;
+      p2.prev = last;
+      last.next.prev = p2;
+      last.next = p2;
+    }
+    return p2;
+  }
+  function removeNode(p2) {
+    p2.next.prev = p2.prev;
+    p2.prev.next = p2.next;
+    if (p2.prevZ) p2.prevZ.nextZ = p2.nextZ;
+    if (p2.nextZ) p2.nextZ.prevZ = p2.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 p2 = n - 1, q = 0; q < n; p2 = q++) a += contour[p2].x * contour[q].y - contour[q].x * contour[p2].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 p2 of contour) vertices.push(p2.x, p2.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 p2 of holes[i]) vertices.push(p2.x, p2.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(p2) {
+    const positions = new Float32Array(p2.positions);
+    const indices = p2.indices ? indexArray(p2.indices) : void 0;
+    return {
+      type: "BufferGeometry",
+      parameters: {},
+      positions,
+      normals: p2.normals ? new Float32Array(p2.normals) : computeVertexNormals(positions, indices),
+      uvs: p2.uvs ? new Float32Array(p2.uvs) : new Float32Array(positions.length / 3 * 2),
+      ...indices ? { indices } : {},
+      groups: []
+    };
+  }
+  function make(kind, p2) {
+    switch (kind) {
+      case "box": {
+        const size = p2.size ?? [1, 1, 1];
+        const segments = p2.segments ?? [1, 1, 1];
+        return box(size[0], size[1], size[2], segments[0], segments[1], segments[2]);
+      }
+      case "cylinder":
+        return cylinder(p2.radiusTop, p2.radiusBottom, p2.height, p2.radialSegments, p2.heightSegments, p2.openEnded, p2.thetaStart, p2.thetaLength);
+      case "cone":
+        return cone(p2.radius, p2.height, p2.radialSegments, p2.heightSegments, p2.openEnded, p2.thetaStart, p2.thetaLength);
+      case "sphere":
+        return sphere(p2.radius, p2.widthSegments, p2.heightSegments, p2.phiStart, p2.phiLength, p2.thetaStart, p2.thetaLength);
+      case "plane":
+        return plane(p2.width, p2.height, p2.widthSegments, p2.heightSegments);
+      case "circle":
+        return circle(p2.radius, p2.segments, p2.thetaStart, p2.thetaLength);
+      case "ring":
+        return ring(p2.innerRadius, p2.outerRadius, p2.thetaSegments, p2.phiSegments, p2.thetaStart, p2.thetaLength);
+      case "lathe":
+        return lathe(p2.points, p2.segments, p2.phiStart, p2.phiLength);
+      case "torus":
+        return torus(p2.radius, p2.tube, p2.radialSegments, p2.tubularSegments, p2.arc);
+      case "extrude":
+        return extrude(p2.shape, p2.depth, p2.steps, p2.bevel);
+      case "difference":
+        return difference(p2.size, p2.subtract ?? []);
+      case "mesh":
+        return mesh(p2);
+      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, p2) {
+    if (p2.type === "LatheGeometry") {
+      const points = p2.parameters.points.map(({ x, y }) => new THREE.Vector2(x, y));
+      return { ...p2.parameters, points };
+    }
+    return { ...p2.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 cache = options.cache !== false;
+    const key = cache ? "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 = (p2) => toGeometry(THREE, p2);
+    const viaCache = (node, direct2) => cache ? buildPrimitive(node) : direct2();
+    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((p2) => [p2.x, p2.y]);
+        return made(viaCache({ kind: "lathe", points: profile, ...defined({ segments, phiStart, phiLength }) }, () => lathe(profile, segments, phiStart, phiLength)));
+      },
+      TorusGeometry: (radius, tube, radialSegments, tubularSegments, arc) => made(viaCache({ kind: "torus", ...defined({ radius, tube, radialSegments, tubularSegments, arc }) }, () => torus(radius, tube, 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-contracts/dist/index.js
+  var DEFAULT_BLAST_SHOVE = { coupling: 0.02, maxSpeed: 20, lift: 0.3, minSpeed: 0.3, falloffPower: 2 };
+  function blastShove(blast2, target, options = {}) {
+    const o = { ...DEFAULT_BLAST_SHOVE, ...options };
+    const dx = target.position[0] - blast2.point[0];
+    const dy = target.position[1] - blast2.point[1];
+    const dz = target.position[2] - blast2.point[2];
+    const distance3 = Math.hypot(dx, dy, dz);
+    if (!(blast2.radius > 0) || distance3 > blast2.radius) return void 0;
+    const falloff = (1 - distance3 / blast2.radius) ** o.falloffPower;
+    const mass = Math.max(target.mass, 0.05);
+    const speed = Math.min(o.maxSpeed, Math.sqrt(2 * blast2.energy * (blast2.reach ?? 1) * o.coupling / mass)) * falloff;
+    if (!(speed >= o.minSpeed)) return void 0;
+    const direction = distance3 > 1e-4 ? [dx / distance3, dy / distance3 + o.lift, dz / distance3] : [0, 1, 0];
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    return { speed, direction: [direction[0] / length, direction[1] / length, direction[2] / length], distance: distance3, falloff };
+  }
   var MISSING_BITS = {
     head: 1,
     armL: 2,
@@ -1231,9 +2774,9 @@ var GameCharactersThree = (() => {
     if (region === "torso") return bodyCount > 1 ? cost.bruteTorso : cost.torso;
     return cost.limb;
   };
-  var teamGameFalloff = (distance22, range) => {
+  var teamGameFalloff = (distance22, range2) => {
     const floor = TEAM_GAME_RULES.falloff.atTwiceRange;
-    return distance22 <= range * TEAM_GAME_RULES.falloff.fullAtRange ? 1 : Math.max(floor, 1 - (distance22 - range) / range * (1 - floor));
+    return distance22 <= range2 * TEAM_GAME_RULES.falloff.fullAtRange ? 1 : Math.max(floor, 1 - (distance22 - range2) / range2 * (1 - floor));
   };
   var NO_HEADSHOT = { headshot: false };
   var HEADSHOT = { headshot: true };
@@ -1286,8 +2829,8 @@ var GameCharactersThree = (() => {
   var DEFAULT_PROJECTILE_GRAMS = 8;
   var RIFLE_JOULES = 1e3;
   var penetrationForce = (energy, grams, diameterMm) => {
-    const area = Math.PI * diameterMm ** 2 / 4;
-    return area > 0 && energy > 0 ? Math.sqrt(energy * grams / area) : 0;
+    const area3 = Math.PI * diameterMm ** 2 / 4;
+    return area3 > 0 && energy > 0 ? Math.sqrt(energy * grams / area3) : 0;
   };
   var projectileOf = (hit, caliber) => {
     const pellets = hit.pellets ?? caliber?.pellets ?? 1;
@@ -1375,7 +2918,15 @@ var GameCharactersThree = (() => {
     if (points >= rules.severity.stunAtPoints) ops.stun();
     return result;
   };
-  var shares = (params, targets, pivot) => targets.map((target) => ({ target, points: params.points * Math.max(0, 1 - distance(params.jointOf(pivot(target)), params.center) / params.radius) })).filter((share) => share.points > params.ops.rules.blast.minimumPoints).sort((a, b) => b.points - a.points);
+  var INJURY_POINTS = 15;
+  var pointsAt = (params, metres) => {
+    const { points, radius, lethalRadius, ops } = params;
+    if (lethalRadius === void 0 || lethalRadius >= radius) return points * Math.max(0, 1 - metres / radius);
+    if (metres <= lethalRadius) return points;
+    const injury = Math.min(points, ops.rules.blast.injuryPoints ?? INJURY_POINTS);
+    return injury * Math.max(0, 1 - (metres - lethalRadius) / (radius - lethalRadius));
+  };
+  var shares = (params, targets, pivot) => targets.map((target) => ({ target, points: pointsAt(params, distance(params.jointOf(pivot(target)), params.center)) })).filter((share) => share.points > params.ops.rules.blast.minimumPoints).sort((a, b) => b.points - a.points);
   var segmentBlast = (params) => {
     const { ops, rule, blow } = params;
     const { blast: blast2, segments } = ops.rules;
@@ -1615,7 +3166,7 @@ var GameCharactersThree = (() => {
   };
   var blast = ({ ops, hit, setup, localPoint, jointOf }) => {
     const points = hit.points ?? pointsFromEnergy(hit.energy ?? 0, setup.rules);
-    const base = { ops, center: localPoint, points, radius: hit.radius ?? 1, jointOf };
+    const base = { ops, center: localPoint, points, radius: hit.radius ?? 1, ...hit.lethalRadius !== void 0 ? { lethalRadius: hit.lethalRadius } : {}, jointOf };
     const common = { cut: hit.cut ?? setup.rules.defaultCut.explosive, damageType: hit.type, model: setup.model, headResistance: HEAD_RESISTANCE };
     const rule = SEGMENT_RULES[setup.rules.segmentRule] ?? kitRule;
     const result = ops.body.detail === "regions" ? regionBlast({ ...base, blow: { ...common, protection: NO_PROTECTION } }) : segmentBlast({ ...base, rule, blow: { ...common, limbFactor: ops.spec.limbFactor } });
@@ -1824,14 +3375,14 @@ var GameCharactersThree = (() => {
   var createCharacters = (options = {}) => {
     const body = createBodySpec(options.body);
     const packs = options.packs ?? [];
-    const presets = mergeById([PERSON_PRESET], packs.flatMap((pack) => pack.presets ?? []));
+    const presets = mergeById([PERSON_PRESET], packs.flatMap((pack2) => pack2.presets ?? []));
     applyPatches(presets, options.patch);
     removeIds(presets, options.remove);
     const damage = resolveDamageRules(options.damage);
     const penetration = modelOf(options.penetration);
-    const protection = mergeById(PROTECTION_PRESETS, [...packs.flatMap((pack) => pack.protection ?? []), ...options.protection ?? []]);
+    const protection = mergeById(PROTECTION_PRESETS, [...packs.flatMap((pack2) => pack2.protection ?? []), ...options.protection ?? []]);
     const shippedCalibers = penetration.id === "team-game" ? TEAM_GAME_CALIBERS : [];
-    const calibers = mergeById(shippedCalibers, [...packs.flatMap((pack) => pack.calibers ?? []), ...options.calibers ?? []]);
+    const calibers = mergeById(shippedCalibers, [...packs.flatMap((pack2) => pack2.calibers ?? []), ...options.calibers ?? []]);
     const setup = { rules: damage, model: penetration, protection, calibers };
     let counter = 0;
     return {
@@ -2271,6 +3822,486 @@ var GameCharactersThree = (() => {
     const apron = random() < APRON_SHARE;
     return { sleeve, hair, headWidth, headHeight, jaw, nose, beard, glasses, cap, capColor, bag, bagColor, torn, apron };
   };
+  var samplePoseClip = (clip, time) => {
+    const keys = clip.keys;
+    if (keys.length === 0) return {};
+    if (keys.length === 1) return { ...keys[0].pose };
+    let index = 0;
+    while (index < keys.length - 2 && time > keys[index + 1].t) index++;
+    const a = keys[index];
+    const b = keys[index + 1];
+    const k = Math.min(1, Math.max(0, (time - a.t) / (b.t - a.t)));
+    const eased = k * k * (3 - 2 * k);
+    return lerpPose(a.pose, b.pose, eased);
+  };
+  var clipEventsBetween = (clip, from, to) => (clip.events ?? []).filter((event) => event.t > from && event.t <= to).sort((x, y) => x.t - y.t);
+  var POSE_CHANNEL_JOINTS = {
+    full: void 0,
+    upper: ["lean", "twist", "side", "headX", "headY", "headZ", "armR", "armL", "elbR", "elbL", "armRz", "armLz"],
+    lower: ["drop", "legL", "legR", "kneeL", "kneeR"]
+  };
+  var filterPoseChannels = (pose, channels = "full") => {
+    const allowed = POSE_CHANNEL_JOINTS[channels];
+    if (!allowed) return pose;
+    const out = {};
+    for (const name of allowed) if (pose[name] !== void 0) out[name] = pose[name];
+    return out;
+  };
+  var MIRROR_PAIRS = [["armR", "armL"], ["elbR", "elbL"], ["armRz", "armLz"], ["legR", "legL"], ["kneeR", "kneeL"]];
+  var MIRROR_NEGATED = /* @__PURE__ */ new Set(["side", "twist", "headY", "headZ"]);
+  var mirrorPoseClip = (clip, id) => ({
+    ...clip,
+    id,
+    keys: clip.keys.map((key) => {
+      const pose = {};
+      for (const [name, value] of Object.entries(key.pose)) pose[name] = MIRROR_NEGATED.has(name) ? -value : value;
+      for (const [a, b] of MIRROR_PAIRS) {
+        const va = key.pose[a];
+        const vb = key.pose[b];
+        const sign2 = a === "armRz" ? -1 : 1;
+        if (vb !== void 0) pose[a] = sign2 * vb;
+        else delete pose[a];
+        if (va !== void 0) pose[b] = sign2 * va;
+        else delete pose[b];
+      }
+      return { t: key.t, pose };
+    }),
+    ...clip.events ? { events: clip.events.map((event) => ({ ...event })) } : {}
+  });
+  var pose_clips_default = {
+    clips: [
+      {
+        id: "grabbed_bitten_human",
+        source: {
+          file: "site/pages/zumbis-personagens/bestiario.html",
+          scene: "ataque (Agarr\xE3o e mordida)",
+          variable: "HK"
+        },
+        duration: 8,
+        loop: false,
+        channels: "full",
+        keys: [
+          {
+            t: 0,
+            pose: {
+              lean: 0,
+              headY: 0,
+              armL: -0.1,
+              armR: 0.05,
+              elbL: -0.2,
+              elbR: -0.2,
+              drop: 0,
+              kneeL: 0.05,
+              kneeR: 0.05,
+              legL: -0.05,
+              legR: 0.05,
+              headX: 0
+            }
+          },
+          {
+            t: 1.5,
+            pose: {
+              lean: -0.1,
+              headY: -0.6,
+              armL: -0.1,
+              armR: 0.05,
+              elbL: -0.2,
+              elbR: -0.2,
+              drop: 0,
+              kneeL: 0.05,
+              kneeR: 0.05,
+              legL: -0.05,
+              legR: 0.05,
+              headX: -0.1
+            }
+          },
+          {
+            t: 2.1,
+            pose: {
+              lean: -0.3,
+              headY: -0.2,
+              armL: -1.3,
+              armR: -1.2,
+              elbL: -1.4,
+              elbR: -1.5,
+              drop: -0.04,
+              kneeL: 0.25,
+              kneeR: 0.2,
+              legL: -0.3,
+              legR: 0.25,
+              headX: -0.25
+            }
+          },
+          {
+            t: 3.6,
+            pose: {
+              lean: -0.35,
+              headY: 0.3,
+              armL: -1.5,
+              armR: -1,
+              elbL: -0.6,
+              elbR: -1.8,
+              drop: -0.05,
+              kneeL: 0.3,
+              kneeR: 0.2,
+              legL: -0.4,
+              legR: 0.35,
+              headX: -0.2
+            }
+          },
+          {
+            t: 4.3,
+            pose: {
+              lean: -0.2,
+              headY: 0.7,
+              headZ: -0.5,
+              armL: -0.6,
+              armR: -1.9,
+              elbL: -0.4,
+              elbR: -1.2,
+              drop: -0.06,
+              kneeL: 0.3,
+              kneeR: 0.3,
+              legL: -0.3,
+              legR: 0.3,
+              headX: -0.3
+            }
+          },
+          {
+            t: 5.6,
+            pose: {
+              lean: 0.55,
+              headY: 0.4,
+              headZ: -0.3,
+              armL: -0.3,
+              armR: -0.5,
+              elbL: -0.6,
+              elbR: -0.8,
+              drop: -0.5,
+              kneeL: 1.9,
+              kneeR: 1.7,
+              legL: -1.1,
+              legR: -0.9,
+              headX: 0.3
+            }
+          },
+          {
+            t: 8,
+            pose: {
+              lean: 0.6,
+              headY: 0.4,
+              headZ: -0.3,
+              armL: -0.25,
+              armR: -0.45,
+              elbL: -0.6,
+              elbR: -0.8,
+              drop: -0.52,
+              kneeL: 1.95,
+              kneeR: 1.75,
+              legL: -1.1,
+              legR: -0.95,
+              headX: 0.4
+            }
+          }
+        ],
+        events: [
+          {
+            t: 0,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.approach"
+            }
+          },
+          {
+            t: 1.7,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.pounce"
+            }
+          },
+          {
+            t: 2.1,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.grab"
+            }
+          },
+          {
+            t: 4.3,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.bite"
+            }
+          },
+          {
+            t: 5.6,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.fall"
+            }
+          },
+          {
+            t: 4.4,
+            type: "impact",
+            data: {
+              kind: "bite",
+              source: "bite.visible=T>4.4 in the scene's step()"
+            }
+          }
+        ]
+      },
+      {
+        id: "grab_bite_zombie",
+        source: {
+          file: "site/pages/zumbis-personagens/bestiario.html",
+          scene: "ataque (Agarr\xE3o e mordida)",
+          variable: "ZK"
+        },
+        duration: 8,
+        loop: false,
+        channels: "full",
+        keys: [
+          {
+            t: 0,
+            pose: {
+              x: -6,
+              lean: 0.75,
+              armL: -1.35,
+              armR: -1.05,
+              elbL: -0.08,
+              elbR: -0.12,
+              headX: -0.55,
+              drop: -0.1,
+              run: 1
+            }
+          },
+          {
+            t: 1.7,
+            pose: {
+              x: -0.9,
+              lean: 0.75,
+              armL: -1.35,
+              armR: -1.05,
+              elbL: -0.08,
+              elbR: -0.12,
+              headX: -0.55,
+              drop: -0.1,
+              run: 1
+            }
+          },
+          {
+            t: 2.1,
+            pose: {
+              x: -0.32,
+              lean: 0.45,
+              armL: -1.65,
+              armR: -1.6,
+              elbL: -0.25,
+              elbR: -0.3,
+              headX: -0.3,
+              drop: -0.08,
+              legL: -0.6,
+              legR: 0.4,
+              kneeL: 0.5,
+              kneeR: 0.6,
+              run: 0
+            }
+          },
+          {
+            t: 3.6,
+            pose: {
+              x: -0.2,
+              lean: 0.35,
+              armL: -1.5,
+              armR: -1.45,
+              elbL: -1.1,
+              elbR: -1.2,
+              headX: -0.2,
+              drop: -0.06,
+              legL: -0.4,
+              legR: 0.3,
+              kneeL: 0.4,
+              kneeR: 0.4,
+              run: 0
+            }
+          },
+          {
+            t: 4.3,
+            pose: {
+              x: -0.1,
+              lean: 0.5,
+              armL: -1.4,
+              armR: -1.3,
+              elbL: -1.5,
+              elbR: -1.5,
+              headX: 0.35,
+              headY: 0.35,
+              drop: -0.08,
+              legL: -0.35,
+              legR: 0.3,
+              kneeL: 0.4,
+              kneeR: 0.4,
+              run: 0
+            }
+          },
+          {
+            t: 5.6,
+            pose: {
+              x: 0,
+              lean: 0.95,
+              armL: -1.2,
+              armR: -1,
+              elbL: -1.4,
+              elbR: -1.3,
+              headX: 0.5,
+              headY: 0.3,
+              drop: -0.45,
+              legL: -1.2,
+              legR: -0.8,
+              kneeL: 1.8,
+              kneeR: 1.5,
+              run: 0
+            }
+          },
+          {
+            t: 8,
+            pose: {
+              x: 0,
+              lean: 1,
+              armL: -1.15,
+              armR: -0.95,
+              elbL: -1.4,
+              elbR: -1.3,
+              headX: 0.55,
+              headY: 0.3,
+              drop: -0.47,
+              legL: -1.2,
+              legR: -0.8,
+              kneeL: 1.85,
+              kneeR: 1.5,
+              run: 0
+            }
+          }
+        ],
+        events: [
+          {
+            t: 0,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.approach"
+            }
+          },
+          {
+            t: 1.7,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.pounce"
+            }
+          },
+          {
+            t: 2.1,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.grab"
+            }
+          },
+          {
+            t: 4.3,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.bite"
+            }
+          },
+          {
+            t: 5.6,
+            type: "phase",
+            data: {
+              label: "pose_clip.grab_bite.phase.fall"
+            }
+          }
+        ]
+      }
+    ],
+    locales: {
+      "pt-BR": {
+        "pose_clip.grab_bite.phase.approach": "1. Aproxima\xE7\xE3o",
+        "pose_clip.grab_bite.phase.pounce": "2. O bote",
+        "pose_clip.grab_bite.phase.grab": "3. Agarr\xE3o: 3 s para se soltar",
+        "pose_clip.grab_bite.phase.bite": "4. Mordida: infec\xE7\xE3o 100%",
+        "pose_clip.grab_bite.phase.fall": "5. Queda"
+      },
+      en: {
+        "pose_clip.grab_bite.phase.approach": "1. Approach",
+        "pose_clip.grab_bite.phase.pounce": "2. The pounce",
+        "pose_clip.grab_bite.phase.grab": "3. Grab: 3 s to break free",
+        "pose_clip.grab_bite.phase.bite": "4. Bite: 100% infection",
+        "pose_clip.grab_bite.phase.fall": "5. The fall"
+      }
+    }
+  };
+  var createPoseClipRegistry = (initial = []) => {
+    const clips = /* @__PURE__ */ new Map();
+    const registry = {
+      register(clip) {
+        clips.set(clip.id, clip);
+        return registry;
+      },
+      get: (id) => clips.get(id),
+      list: () => [...clips.values()],
+      remove: (id) => clips.delete(id)
+    };
+    for (const clip of initial) registry.register(clip);
+    return registry;
+  };
+  var POSE_CLIPS = pose_clips_default.clips;
+  var POSE_CLIP_LOCALES = pose_clips_default.locales;
+  var ease = (k) => k * k * (3 - 2 * k);
+  var mix = (a, b, k) => a + (b - a) * k;
+  var mixTriple = (a, b, k) => [mix(a[0], b[0], k), mix(a[1], b[1], k), mix(a[2], b[2], k)];
+  var trackOf = (clip, side) => {
+    const out = [];
+    for (const key of clip.keys) {
+      if (side === "L") {
+        if (key.L === "mirror") {
+          if (key.R) out.push({ t: key.t, key: key.R, mirror: true });
+        } else if (key.L) out.push({ t: key.t, key: key.L, mirror: false });
+      } else {
+        const entry = key[side];
+        if (entry) out.push({ t: key.t, key: entry, mirror: false });
+      }
+    }
+    return out.sort((a, b) => a.t - b.t);
+  };
+  var sampleTrack = (track, time) => {
+    if (track.length === 0) return void 0;
+    const first = track[0];
+    const last = track[track.length - 1];
+    const of = (entry) => ({ p: [...entry.key.p], r: [...entry.key.r], grip: entry.key.grip, w: entry.key.w ?? 1, mirror: entry.mirror });
+    if (time <= first.t) return of(first);
+    if (time >= last.t) return of(last);
+    let index = 0;
+    while (index < track.length - 2 && time > track[index + 1].t) index++;
+    const a = track[index];
+    const b = track[index + 1];
+    const k = ease(Math.min(1, Math.max(0, (time - a.t) / (b.t - a.t))));
+    const ga = a.key.grip;
+    const gb = b.key.grip;
+    return {
+      p: mixTriple(a.key.p, b.key.p, k),
+      r: mixTriple(a.key.r, b.key.r, k),
+      grip: ga === void 0 ? gb : gb === void 0 ? ga : mix(ga, gb, k),
+      w: mix(a.key.w ?? 1, b.key.w ?? 1, k),
+      mirror: a.mirror
+    };
+  };
+  var sampleFirstPersonClip = (clip, time) => {
+    const out = {};
+    for (const side of ["R", "L", "F"]) {
+      const sample = sampleTrack(trackOf(clip, side), time);
+      if (sample) out[side] = sample;
+    }
+    return out;
+  };
 
   // src/instanced/body-geometry.ts
   var negativeFirst = (first, second) => first[0] <= second[0] ? [first, second] : [second, first];
@@ -2305,13 +4336,13 @@ var GameCharactersThree = (() => {
     return source;
   };
   var MERGED_ATTRIBUTES = [["position", 3], ["normal", 3], ["bone", 1], ["vcol", 4], ["pivot", 3], ["ppivot", 3]];
-  var mergeBody = (list, three) => {
-    const total = list.reduce((sum, geometry) => sum + geometry.attributes.position.count, 0);
+  var mergeBody = (list2, three) => {
+    const total = list2.reduce((sum, geometry) => sum + geometry.attributes.position.count, 0);
     const merged = new three.BufferGeometry();
     for (const [name, size] of MERGED_ATTRIBUTES) {
       const array = new Float32Array(total * size);
       let offset = 0;
-      for (const geometry of list) {
+      for (const geometry of list2) {
         const part = geometry.attributes[name].array;
         array.set(part, offset);
         offset += part.length;
@@ -2321,7 +4352,8 @@ var GameCharactersThree = (() => {
     merged.computeBoundingSphere();
     return merged;
   };
-  var buildInstancedBody = (three, { segments, body = TEAM_GAME }) => {
+  var buildInstancedBody = (host, { segments, body = TEAM_GAME }) => {
+    const three = shapeGeometries(host);
     const joints = jointsOf(body);
     const parts = [];
     const half = Math.max(4, segments >> 1);
@@ -2449,15 +4481,15 @@ var GameCharactersThree = (() => {
       copy.setAttribute(name, attribute);
       attributes[name] = attribute;
     }
-    const mesh = new three.InstancedMesh(copy, createBodyMaterial(three, { time }), max);
-    mesh.customDepthMaterial = createBodyMaterial(three, { depth: true, time });
-    mesh.frustumCulled = false;
-    mesh.castShadow = castShadow;
-    mesh.receiveShadow = true;
-    mesh.count = 0;
+    const mesh2 = new three.InstancedMesh(copy, createBodyMaterial(three, { time }), max);
+    mesh2.customDepthMaterial = createBodyMaterial(three, { depth: true, time });
+    mesh2.frustumCulled = false;
+    mesh2.castShadow = castShadow;
+    mesh2.receiveShadow = true;
+    mesh2.count = 0;
     let count = 0;
     return {
-      mesh,
+      mesh: mesh2,
       max,
       get count() {
         return count;
@@ -2465,7 +4497,7 @@ var GameCharactersThree = (() => {
       begin() {
         count = 0;
       },
-      push({ a, b, c, color, eye, y = 0 }) {
+      push({ a, b, c, color: color2, eye, y = 0 }) {
         if (count >= max) return;
         const index = count++;
         const fourOffset = index * 4;
@@ -2473,11 +4505,11 @@ var GameCharactersThree = (() => {
         attributes.iA.array.set(a, fourOffset);
         attributes.iB.array.set([b[0], b[1], b[2], b[3] + POSE_SLOTS2 * Math.round((Math.min(MAX_HEIGHT2, Math.max(MIN_HEIGHT2, y)) - MIN_HEIGHT2) * HEIGHT_STEPS2)], fourOffset);
         attributes.iC.array.set(c, fourOffset);
-        attributes.iCol.array.set([color.r, color.g, color.b], threeOffset);
+        attributes.iCol.array.set([color2.r, color2.g, color2.b], threeOffset);
         attributes.iEye.array.set(eye ? [eye.r, eye.g, eye.b] : [0, 0, 0], threeOffset);
       },
       end() {
-        mesh.count = count;
+        mesh2.count = count;
         for (const attribute of Object.values(attributes)) {
           attribute.clearUpdateRanges();
           attribute.addUpdateRange(0, count * attribute.itemSize);
@@ -2502,7 +4534,8 @@ var GameCharactersThree = (() => {
   var FAR_LOD = 0.6;
   var EYE_SCALE = 2.2;
   var EYE_DEPTH_SCALE = 1.4;
-  var bakeBody = (three, builders, spec, lod) => {
+  var bakeBody = (host, builders, spec, lod) => {
+    const three = shapeGeometries(host);
     const root = spec.retrato && builders.buildPortrait ? builders.buildPortrait(spec.retrato, lod) : builders.buildBest({ ...spec, pose: { ...BAKE_NEUTRAL_POSE, ...spec.pose ?? {} } }, lod);
     const rig = root.userData.rig;
     const P = rig.P;
@@ -2518,7 +4551,7 @@ var GameCharactersThree = (() => {
       leg.kn.rotation.set(0, 0, 0);
     }
     root.updateMatrixWorld(true);
-    const worldPosition2 = (object) => object.getWorldPosition(new three.Vector3()).toArray();
+    const worldPosition2 = (object2) => object2.getWorldPosition(new three.Vector3()).toArray();
     const bones = /* @__PURE__ */ new Map();
     bones.set(rig.headG, [1, worldPosition2(rig.headG), [0, 0, 0]]);
     for (const arm of rig.arms) {
@@ -2534,13 +4567,13 @@ var GameCharactersThree = (() => {
     const trunk = [0, [0, 0.9 * P.s, 0], [0, 0, 0]];
     const parts = [];
     const topMaterial = spec.retrato ? null : builders.topMaterial();
-    root.traverse((object) => {
-      const mesh = object;
-      const material = mesh.material;
-      if (!mesh.isMesh || !mesh.geometry || material.transparent) return;
-      for (let ancestor = object; ancestor; ancestor = ancestor.parent) if (!ancestor.visible) return;
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      const material = mesh2.material;
+      if (!mesh2.isMesh || !mesh2.geometry || material.transparent) return;
+      for (let ancestor = object2; ancestor; ancestor = ancestor.parent) if (!ancestor.visible) return;
       let tag = trunk;
-      for (let ancestor = object.parent; ancestor; ancestor = ancestor.parent) {
+      for (let ancestor = object2.parent; ancestor; ancestor = ancestor.parent) {
         const found = bones.get(ancestor);
         if (found) {
           tag = found;
@@ -2548,21 +4581,21 @@ var GameCharactersThree = (() => {
         }
       }
       let [bone, pivot, parentPivot] = tag;
-      if (object.userData.bone === 11) {
+      if (object2.userData.bone === 11) {
         bone = 11;
         pivot = bones.get(rig.headG)[1];
         parentPivot = [0, 0, 0];
       }
-      const isEye2 = !!object.userData.eye;
-      const color = material.color;
+      const isEye2 = !!object2.userData.eye;
+      const color2 = material.color;
       const materialId = isEye2 ? 3 : material === topMaterial ? 1 : 6;
       if (isEye2 && bone === 1) bone = 6;
-      const geometry = mesh.geometry.clone();
-      geometry.applyMatrix4(mesh.matrixWorld);
+      const geometry = mesh2.geometry.clone();
+      geometry.applyMatrix4(mesh2.matrixWorld);
       const isBlood = material.polygonOffset && material.isMeshStandardMaterial;
       if (isBlood) liftAlongNormals(geometry, lod < FAR_LOD ? BLOOD_LIFT_FAR : BLOOD_LIFT_NEAR);
       if (isEye2) enlargeEye(three, geometry, lod < FAR_LOD ? 1 : 0.68);
-      const colors = isBlood ? [Math.max(color.r * 1.7, 0.3), Math.min(color.g * 1.7, 0.04), Math.min(color.b * 1.7, 0.04), materialId] : [color.r, color.g, color.b, materialId];
+      const colors = isBlood ? [Math.max(color2.r * 1.7, 0.3), Math.min(color2.g * 1.7, 0.04), Math.min(color2.b * 1.7, 0.04), materialId] : [color2.r, color2.g, color2.b, materialId];
       parts.push({ g: geometry, bone, pv: pivot, pp: parentPivot, col: colors });
     });
     return { geo: mergeBaked(three, parts), s: P.s, bulk: P.bulk, verts: parts.reduce((sum, part) => sum + part.g.attributes.position.count, 0) };
@@ -2588,7 +4621,7 @@ var GameCharactersThree = (() => {
     }
     const position = new Float32Array(vertexTotal * 3);
     const normal = new Float32Array(vertexTotal * 3);
-    const color = new Float32Array(vertexTotal * 4);
+    const color2 = new Float32Array(vertexTotal * 4);
     const bone = new Float32Array(vertexTotal);
     const pivot = new Float32Array(vertexTotal * 3);
     const parentPivot = new Float32Array(vertexTotal * 3);
@@ -2600,7 +4633,7 @@ var GameCharactersThree = (() => {
       position.set(part.g.attributes.position.array, vertexOffset * 3);
       normal.set(part.g.attributes.normal.array, vertexOffset * 3);
       for (let vertex = 0; vertex < count; vertex++) {
-        color.set(part.col, (vertexOffset + vertex) * 4);
+        color2.set(part.col, (vertexOffset + vertex) * 4);
         bone[vertexOffset + vertex] = part.bone;
         pivot.set(part.pv, (vertexOffset + vertex) * 3);
         parentPivot.set(part.pp, (vertexOffset + vertex) * 3);
@@ -2615,7 +4648,7 @@ var GameCharactersThree = (() => {
     const out = new three.BufferGeometry();
     out.setAttribute("position", new three.BufferAttribute(position, 3));
     out.setAttribute("normal", new three.BufferAttribute(normal, 3));
-    out.setAttribute("vcol", new three.BufferAttribute(color, 4));
+    out.setAttribute("vcol", new three.BufferAttribute(color2, 4));
     out.setAttribute("bone", new three.BufferAttribute(bone, 1));
     out.setAttribute("pivot", new three.BufferAttribute(pivot, 3));
     out.setAttribute("ppivot", new three.BufferAttribute(parentPivot, 3));
@@ -2651,20 +4684,21 @@ var GameCharactersThree = (() => {
   var SPIN_DAMPING = 0.5;
   var REST_SPEED = 0.4;
   var LEG_COLOR = 2896704;
-  var createFlyingLimbs = (three, { max = 40, random, effects = {} }) => {
+  var createFlyingLimbs = (host, { max = 40, random, effects = {} }) => {
+    const three = shapeGeometries(host);
     const limbs = [];
-    const mesh = new three.InstancedMesh(new three.CapsuleGeometry(0.065, 0.32, 2, 6), new three.MeshLambertMaterial({ color: 16777215 }), max);
-    mesh.count = 0;
-    mesh.castShadow = true;
-    mesh.setColorAt(0, new three.Color());
+    const mesh2 = new three.InstancedMesh(new three.CapsuleGeometry(0.065, 0.32, 2, 6), new three.MeshLambertMaterial({ color: 16777215 }), max);
+    mesh2.count = 0;
+    mesh2.castShadow = true;
+    mesh2.setColorAt(0, new three.Color());
     const matrix = new three.Matrix4();
     const quaternion = new three.Quaternion();
     const scale = new three.Vector3();
     const position = new three.Vector3();
     const euler = new three.Euler();
-    const color = new three.Color();
+    const color2 = new three.Color();
     return {
-      mesh,
+      mesh: mesh2,
       limbs,
       launch({ x, z, kind, color: sleeve, blood }) {
         const isLeg2 = kind === "leg";
@@ -2717,12 +4751,12 @@ var GameCharactersThree = (() => {
             }
           }
           matrix.compose(position.set(limb2.x, limb2.y, limb2.z), quaternion.setFromEuler(euler.set(limb2.rx, limb2.rz, 0)), scale.set(1, limb2.len, 1));
-          mesh.setMatrixAt(index, matrix);
-          mesh.setColorAt(index, color.set(limb2.col));
+          mesh2.setMatrixAt(index, matrix);
+          mesh2.setColorAt(index, color2.set(limb2.col));
         });
-        mesh.count = limbs.length;
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+        mesh2.count = limbs.length;
+        mesh2.instanceMatrix.needsUpdate = true;
+        if (mesh2.instanceColor) mesh2.instanceColor.needsUpdate = true;
       }
     };
   };
@@ -2837,7 +4871,8 @@ var GameCharactersThree = (() => {
   };
 
   // src/rich/best-builder.ts
-  var createBestBuilder = (THREE, { types, random = Math.random }) => {
+  var createBestBuilder = (host, { types, random = Math.random }) => {
+    const THREE = shapeGeometries(host);
     const options = { types, random };
     let LK = 1, topM_ref = null;
     const SPH = (r, w = 8, h = 6, ...a) => new THREE.SphereGeometry(r, Math.max(4, Math.round(w * LK)), Math.max(3, Math.round(h * LK)), ...a);
@@ -2863,7 +4898,7 @@ var GameCharactersThree = (() => {
     const PANTS = 2896704, GRAY2 = 4868678, RED2 = 8000012;
     const col = (a, b, t) => new THREE.Color(a).lerp(new THREE.Color(b), t);
     const geoBox = (w, h, d) => new THREE.BoxGeometry(w, h, d);
-    const box = (w, h, d, m) => new THREE.Mesh(geoBox(w, h, d), m);
+    const box2 = (w, h, d, m) => new THREE.Mesh(geoBox(w, h, d), m);
     const limbGeo = (w, len) => {
       const g = geoBox(w, len, w);
       g.translate(0, -len / 2, 0);
@@ -3017,7 +5052,7 @@ var GameCharactersThree = (() => {
         st.scale.set(1, 0.35, 1);
         add(p2, CYL(r * 0.32, r * 0.36, 0.07, 10), M(15261900), 0, y + (up ? 0.04 : -0.04), 0);
       };
-      const ring = (p2, r, h, m, y, sx, sz) => {
+      const ring2 = (p2, r, h, m, y, sx, sz) => {
         const o = add(p2, CYL(r, r, h, 24), m, 0, y, 0);
         o.scale.set(sx || 1.12, 1, sz || 0.7);
         return o;
@@ -3141,8 +5176,8 @@ var GameCharactersThree = (() => {
         for (let i = 0; i < 3; i++) add(U, geoBox(0.11, 0.13, 0.05), M(O.vest), -0.15 + i * 0.15, 1.17, 0.17);
       }
       if (O.stripes) {
-        ring(U, 0.205, 0.05, M(O.stripes), 1.03, 1.13, 0.68);
-        ring(U, 0.268, 0.05, M(O.stripes), 1.42, 1.13, 0.67);
+        ring2(U, 0.205, 0.05, M(O.stripes), 1.03, 1.13, 0.68);
+        ring2(U, 0.268, 0.05, M(O.stripes), 1.42, 1.13, 0.67);
       }
       if (d === 3 && !P.bloat) [0, 1, 2].forEach((k) => add(U, geoBox(0.2, 0.022, 0.02), M(14208952), 0, 1.3 + k * 0.065, 0.168));
       if (!spec.human) {
@@ -3436,8 +5471,8 @@ var GameCharactersThree = (() => {
     },
     {
       ids: ["stubble"],
-      apply: ({ Hd, THREE, add, cmat, scaleHex, sp }) => {
-        const b = add(Hd, new THREE.SphereGeometry(0.123, 16, 12), cmat(scaleHex(sp.skin, 0.62)), 0, 1.705, 0.032);
+      apply: ({ Hd, THREE, add, cmat, scaleHex: scaleHex2, sp }) => {
+        const b = add(Hd, new THREE.SphereGeometry(0.123, 16, 12), cmat(scaleHex2(sp.skin, 0.62)), 0, 1.705, 0.032);
         b.scale.set(1, 0.74, 1);
       }
     },
@@ -3755,8 +5790,8 @@ var GameCharactersThree = (() => {
       add(U, Bx(0.1, 0.12, 0.09), m, -0.17, 0.95, -0.15);
       return;
     },
-    belt: ({ U, m, ring }) => {
-      ring(U, 0.212, 0.07, m, 0.95, 1.12, 0.72);
+    belt: ({ U, m, ring: ring2 }) => {
+      ring2(U, 0.212, 0.07, m, 0.95, 1.12, 0.72);
       return;
     },
     holster: ({ Bx, add, cmat, legs }) => {
@@ -3768,9 +5803,9 @@ var GameCharactersThree = (() => {
       add(U, Bx(0.012, 0.1, 0.012), cmat(1710618), 0.17, 1.52, 0.18);
       return;
     },
-    stripes: ({ THREE, U, add, arms, m, ring }) => {
-      ring(U, 0.205, 0.05, m, 1.03, 1.13, 0.68);
-      ring(U, 0.268, 0.05, m, 1.42, 1.13, 0.67);
+    stripes: ({ THREE, U, add, arms, m, ring: ring2 }) => {
+      ring2(U, 0.205, 0.05, m, 1.03, 1.13, 0.68);
+      ring2(U, 0.268, 0.05, m, 1.42, 1.13, 0.67);
       arms.forEach((a) => {
         const r = add(a.el, new THREE.CylinderGeometry(0.058, 0.054, 0.05, 18), m, 0, -0.17, 0);
       });
@@ -3880,17 +5915,17 @@ var GameCharactersThree = (() => {
       add(arms[1].g, new THREE.CylinderGeometry(0.08, 0.078, 0.08, 18), m, 0, -0.12, 0);
       return;
     },
-    tiedsleeves: ({ Bx, U, add, legs, m, ring }) => {
-      ring(U, 0.215, 0.1, m, 0.95, 1.12, 0.74);
+    tiedsleeves: ({ Bx, U, add, legs, m, ring: ring2 }) => {
+      ring2(U, 0.215, 0.1, m, 0.95, 1.12, 0.74);
       legs.forEach((l) => add(l.g, Bx(0.1, 0.26, 0.05), m, l.s * 0.02, -0.1, 0.105));
       return;
     },
-    labcoat: ({ Bx, THREE, U, add, arms, cmat, fem, legs, m, ring, torsoGeo }) => {
+    labcoat: ({ Bx, THREE, U, add, arms, cmat, fem, legs, m, ring: ring2, torsoGeo }) => {
       {
         const g = torsoGeo(fem);
         g.scale(1.06, 1, 1.12);
         add(U, g, m, 0, 0, 0);
-        ring(U, 0.22, 0.14, m, 0.9, 1.12, 0.76);
+        ring2(U, 0.22, 0.14, m, 0.9, 1.12, 0.76);
         legs.forEach((l) => add(l.g, new THREE.CylinderGeometry(0.145, 0.165, 0.46, 20, 1, true).translate(0, -0.21, 0), m, 0, 0, 0));
         add(U, Bx(0.025, 0.62, 0.012), cmat(10132114), 0, 1.2, 0.19);
         arms.forEach((a) => {
@@ -3980,8 +6015,8 @@ var GameCharactersThree = (() => {
       add(U, Bx(0.05, 0.75, 0.02), cmat(4864546), 0, 1.22, 0.195, 0, 0, -0.75);
       return;
     },
-    scarf: ({ PI, THREE, U, add, m, ring }) => {
-      ring(U, 0.1, 0.08, m, 1.57, 1.3, 1.2);
+    scarf: ({ PI, THREE, U, add, m, ring: ring2 }) => {
+      ring2(U, 0.1, 0.08, m, 1.57, 1.3, 1.2);
       add(U, new THREE.ConeGeometry(0.08, 0.14, 3), m, 0, 1.47, 0.15, PI, 0, 0);
       return;
     },
@@ -4024,12 +6059,12 @@ var GameCharactersThree = (() => {
         return;
       }
     },
-    refl: ({ Bx, THREE, U, add, cmat, m, ring }) => {
+    refl: ({ Bx, THREE, U, add, cmat, m, ring: ring2 }) => {
       {
         const v = add(U, new THREE.CylinderGeometry(0.287, 0.252, 0.46, 20), m, 0, 1.3, 0);
         v.scale.set(1.13, 1, 0.72);
-        ring(U, 0.29, 0.035, cmat(13159632, { metalness: 0.3, roughness: 0.4 }), 1.2, 1.13, 0.73);
-        ring(U, 0.3, 0.035, cmat(13159632, { metalness: 0.3, roughness: 0.4 }), 1.37, 1.13, 0.73);
+        ring2(U, 0.29, 0.035, cmat(13159632, { metalness: 0.3, roughness: 0.4 }), 1.2, 1.13, 0.73);
+        ring2(U, 0.3, 0.035, cmat(13159632, { metalness: 0.3, roughness: 0.4 }), 1.37, 1.13, 0.73);
         add(U, Bx(0.17, 0.055, 0.02), cmat(1714794), 0, 1.47, 0.205);
         return;
       }
@@ -4129,9 +6164,10 @@ var GameCharactersThree = (() => {
   EXTRAS.dbl_front = EXTRAS.rifle_front;
 
   // src/rich/person-kit.ts
-  var createPersonKit = (THREE, { random: R, createCanvas = () => document.createElement("canvas") }) => {
+  var createPersonKit = (host, { random: R, createCanvas = () => document.createElement("canvas") }) => {
+    const THREE = shapeGeometries(host);
     const T = THREE;
-    const scaleHex = (hex2, factor) => {
+    const scaleHex2 = (hex2, factor) => {
       const channel = (shift) => (hex2 >> shift & 255) / 255 * factor * 255;
       return channel(16) << 16 ^ channel(8) << 8 ^ channel(0) << 0;
     };
@@ -4188,7 +6224,7 @@ var GameCharactersThree = (() => {
     function ball(parent, r, m, x, y, z) {
       return add(parent, new THREE.SphereGeometry(r, SEG, 12), m, x || 0, y || 0, z || 0);
     }
-    function ring(parent, r, h, m, y, sx, sz) {
+    function ring2(parent, r, h, m, y, sx, sz) {
       const o = add(parent, new THREE.CylinderGeometry(r, r, h, 20), m, 0, y, 0);
       o.scale.set(sx || 1.12, 1, sz || 0.7);
       return o;
@@ -4234,17 +6270,17 @@ var GameCharactersThree = (() => {
       const k = c + "|" + o;
       return stainMs[k] || (stainMs[k] = new THREE.MeshStandardMaterial(Object.assign({ color: c, roughness: 0.95, metalness: 0, polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2, side: THREE.DoubleSide }, o || {})));
     }
-    function splat(parent, x, y, z, r, color, n, out, kind) {
-      const skin = kind === "skin", fresh = color === 9046538, push = (o) => {
+    function splat(parent, x, y, z, r, color2, n, out, kind) {
+      const skin = kind === "skin", fresh = color2 === 9046538, push = (o) => {
         o.castShadow = false;
         if (out) out.push(o);
         return o;
       };
       const sy = 0.8 + R() * 0.4, seed = R() * 10;
-      const core = skin ? stainM(color, { roughness: 0.12, metalness: 0.1 }) : stainM(scaleHex(color, 0.72));
+      const core = skin ? stainM(color2, { roughness: 0.12, metalness: 0.1 }) : stainM(scaleHex2(color2, 0.72));
       const a = push(add(parent, blobGeo(blobR(40, skin ? 0.4 : 0.9, seed), r * 0.82, r * 0.82 * sy), core, x, y, z + 4e-3));
       if (!skin) {
-        push(add(parent, blobGeo(blobR(48, 1.6, seed + 0.3), r * 1.3, r * 1.3 * sy), stainM(color, { transparent: true, opacity: 0.5, depthWrite: false }), x, y, z + 2e-3));
+        push(add(parent, blobGeo(blobR(48, 1.6, seed + 0.3), r * 1.3, r * 1.3 * sy), stainM(color2, { transparent: true, opacity: 0.5, depthWrite: false }), x, y, z + 2e-3));
       }
       for (let k = 0; k < (n || 0); k++) {
         const ang = R() * 6.28, d = r * (1.2 + R() * 0.9), rr = r * (0.16 + R() * 0.2);
@@ -4261,14 +6297,15 @@ var GameCharactersThree = (() => {
       }
       return a;
     }
-    return { THREE, PI, SEG, R, scaleHex, Bx, add, cmat, ball, ring, cap, limb: limb2, mlimb, torsoGeo, splat, stainM, chessTex };
+    return { THREE, PI, SEG, R, scaleHex: scaleHex2, Bx, add, cmat, ball, ring: ring2, cap, limb: limb2, mlimb, torsoGeo, splat, stainM, chessTex };
   };
 
   // src/rich/person-builder.ts
   var PAGE_EYES = { lento: 14926657, corredor: 15022379, brutamonte: 15698474 };
-  var createPersonBuilder = (THREE, options = {}) => {
+  var createPersonBuilder = (host, options = {}) => {
+    const THREE = shapeGeometries(host);
     const kit = createPersonKit(THREE, { random: options.random ?? createRng(77), createCanvas: options.createCanvas });
-    const { PI, R, scaleHex, Bx, add, cmat, ball, ring, cap, limb: limb2, mlimb, torsoGeo, splat, stainM, chessTex } = kit;
+    const { PI, R, scaleHex: scaleHex2, Bx, add, cmat, ball, ring: ring2, cap, limb: limb2, mlimb, torsoGeo, splat, stainM, chessTex } = kit;
     const reduce = options.reducedMotion ?? false;
     const detailed = (options.detail ?? 0) === 0;
     const EYE = { ...PAGE_EYES, ...options.zombieEyes };
@@ -4369,7 +6406,7 @@ var GameCharactersThree = (() => {
       const ridge = ball(Hd, 0.1, skinM, 0, 1.842, 0.105);
       ridge.scale.set(1.3, 0.28, 0.55);
       add(Hd, new THREE.SphereGeometry(0.021, 10, 8), skinM, 0, 1.762, 0.182);
-      add(Hd, Bx(0.064, 0.013, 0.02), cmat(scaleHex(sp.skin, 0.68)), 0, 1.703, 0.156);
+      add(Hd, Bx(0.064, 0.013, 0.02), cmat(scaleHex2(sp.skin, 0.68)), 0, 1.703, 0.156);
       const bags = add(Hd, Bx(0.2, 0.022, 0.012), new THREE.MeshBasicMaterial({ color: 3811882, transparent: true, opacity: 0 }), 0, 1.79, 0.166);
       bags.castShadow = false;
       const hc = cmat(sp.hair.c), hs = sp.hair.s;
@@ -4406,7 +6443,7 @@ var GameCharactersThree = (() => {
         t.rotation.x = 0.25;
       }
       const f = sp.face || [];
-      for (const feature of FACE_FEATURES) if (feature.ids.some((id) => f.includes(id))) feature.apply({ THREE, PI, Hd, add, Bx, cmat, hc, sp, f, scaleHex });
+      for (const feature of FACE_FEATURES) if (feature.ids.some((id) => f.includes(id))) feature.apply({ THREE, PI, Hd, add, Bx, cmat, hc, sp, f, scaleHex: scaleHex2 });
       if (sp.hat) {
         const k = sp.hat.k, c = cmat(sp.hat.c);
         HATS.find((hat) => hat.kinds.includes(k))?.apply({ THREE, PI, Hd, add, Bx, cmat, cap, c, k, sp });
@@ -4445,7 +6482,7 @@ var GameCharactersThree = (() => {
       for (const e of sp.ex || []) {
         const [k, c] = e;
         const m = c !== void 0 ? cmat(c) : null;
-        EXTRAS[k]?.({ THREE, PI, U, Hd, root, add, Bx, cmat, ring, torsoGeo, legs, arms, fem, topM, m, e, k, headG, fig, upper, skinM, sp, splat, R, ball, cap, hc });
+        EXTRAS[k]?.({ THREE, PI, U, Hd, root, add, Bx, cmat, ring: ring2, torsoGeo, legs, arms, fem, topM, m, e, k, headG, fig, upper, skinM, sp, splat, R, ball, cap, hc });
       }
       if (sp.back === "shotgun") {
         const g = new THREE.Group();
@@ -4625,9 +6662,9 @@ var GameCharactersThree = (() => {
   // src/eyes.ts
   var GLOW_SIZE = 64;
   var createGlowTexture = (three, createCanvas) => {
-    const make = createCanvas ?? (typeof document === "undefined" ? void 0 : () => document.createElement("canvas"));
-    if (!make) return null;
-    const canvas = make();
+    const make2 = createCanvas ?? (typeof document === "undefined" ? void 0 : () => document.createElement("canvas"));
+    if (!make2) return null;
+    const canvas = make2();
     canvas.width = canvas.height = GLOW_SIZE;
     const context = canvas.getContext("2d");
     if (!context) return null;
@@ -4639,35 +6676,36 @@ var GameCharactersThree = (() => {
     context.fillRect(0, 0, GLOW_SIZE, GLOW_SIZE);
     return new three.CanvasTexture(canvas);
   };
-  var createEye = (three, { color, radius = 0.02, glow, glowOpacity = 0.55, texture = null }) => {
+  var createEye = (host, { color: color2, radius = 0.02, glow, glowOpacity = 0.55, texture = null }) => {
+    const three = shapeGeometries(host);
     const eye = new three.Group();
-    const ball = new three.Mesh(new three.SphereGeometry(radius, 10, 8), new three.MeshBasicMaterial({ color }));
+    const ball = new three.Mesh(new three.SphereGeometry(radius, 10, 8), new three.MeshBasicMaterial({ color: color2 }));
     ball.userData.eye = 1;
     eye.add(ball);
     const size = glow ?? radius * 5;
     if (size > 0) {
-      const sprite = new three.Sprite(new three.SpriteMaterial({ map: texture, color, transparent: true, blending: three.AdditiveBlending, depthWrite: false, opacity: glowOpacity }));
+      const sprite = new three.Sprite(new three.SpriteMaterial({ map: texture, color: color2, transparent: true, blending: three.AdditiveBlending, depthWrite: false, opacity: glowOpacity }));
       sprite.scale.setScalar(size);
       sprite.userData.eyeGlow = 1;
       eye.add(sprite);
     }
     return eye;
   };
-  var isEye = (object) => object.userData.eye === 1 || object.userData.eye === true;
+  var isEye = (object2) => object2.userData.eye === 1 || object2.userData.eye === true;
   var findEyes = (three, root) => {
     const markable = [];
     const glows = [];
     const base = /* @__PURE__ */ new Map();
-    root.traverse((object) => {
-      const mesh = object;
-      if (mesh.isMesh && isEye(object)) markable.push(mesh);
-      const sprite = object;
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (mesh2.isMesh && isEye(object2)) markable.push(mesh2);
+      const sprite = object2;
       if (sprite.isSprite && sprite.material.blending === three.AdditiveBlending) glows.push(sprite);
     });
     const remember = (material) => {
       if (material.color && !base.has(material)) base.set(material, { color: material.color.clone(), opacity: material.opacity });
     };
-    markable.forEach((mesh) => remember(mesh.material));
+    markable.forEach((mesh2) => remember(mesh2.material));
     glows.forEach((sprite) => remember(sprite.material));
     const setBrightness = (level) => {
       const factor = Math.min(1, Math.max(0, level));
@@ -4687,14 +6725,14 @@ var GameCharactersThree = (() => {
       on: () => setBrightness(1),
       isolate(only) {
         if (!only) {
-          hidden.splice(0).forEach((object) => object.visible = true);
+          hidden.splice(0).forEach((object2) => object2.visible = true);
           return;
         }
-        root.traverse((object) => {
-          const mesh = object;
-          if (mesh.isMesh && !isEye(object) && object.visible) {
-            object.visible = false;
-            hidden.push(object);
+        root.traverse((object2) => {
+          const mesh2 = object2;
+          if (mesh2.isMesh && !isEye(object2) && object2.visible) {
+            object2.visible = false;
+            hidden.push(object2);
           }
         });
       }
@@ -4814,9 +6852,9 @@ var GameCharactersThree = (() => {
       group.add(end);
       strands.push(end);
     }
-    group.traverse((object) => {
-      object.userData.stump = 1;
-      if (object.isMesh) object.castShadow = true;
+    group.traverse((object2) => {
+      object2.userData.stump = 1;
+      if (object2.isMesh) object2.castShadow = true;
     });
     return strands;
   };
@@ -4831,15 +6869,15 @@ var GameCharactersThree = (() => {
     const group = new three.Group();
     group.position.y = y;
     parent.add(group);
-    const torus = new three.Mesh(new three.TorusGeometry(radius, 0.022, 8, 18), materials.wound);
-    torus.rotation.x = Math.PI / 2;
-    group.add(torus);
+    const torus2 = new three.Mesh(new three.TorusGeometry(radius, 0.022, 8, 18), materials.wound);
+    torus2.rotation.x = Math.PI / 2;
+    group.add(torus2);
     for (let k = 0; k < 3; k++) {
       const strip = new three.Mesh(new three.CylinderGeometry(8e-3, 8e-3, 0.12, 6), materials.wound);
       strip.position.set((k - 1) * 0.03, 0.03, 0.02);
       group.add(strip);
     }
-    group.traverse((object) => object.userData.stump = 1);
+    group.traverse((object2) => object2.userData.stump = 1);
     return group;
   };
 
@@ -4858,8 +6896,8 @@ var GameCharactersThree = (() => {
     const trim = () => {
       while (pieces.length > max) pieces.shift()?.object.removeFromParent();
     };
-    const add = (object, velocity, spin, tag) => {
-      const piece = { object, velocity, spin, rest: false, ...tag ? { tag } : {} };
+    const add = (object2, velocity, spin, tag) => {
+      const piece = { object: object2, velocity, spin, rest: false, ...tag ? { tag } : {} };
       pieces.push(piece);
       trim();
       return piece;
@@ -4936,8 +6974,8 @@ var GameCharactersThree = (() => {
   };
   var exitWound = (three, materials, random, segment, point, direction, damage) => {
     const meshes = [];
-    segment.traverse((object) => {
-      if (object.isMesh && !object.userData.wound && !object.userData.stump) meshes.push(object);
+    segment.traverse((object2) => {
+      if (object2.isMesh && !object2.userData.wound && !object2.userData.stump) meshes.push(object2);
     });
     const raycaster = new three.Raycaster(point.clone().addScaledVector(direction, 0.6), direction.clone().negate(), 0, 0.6);
     const hit = raycaster.intersectObjects(meshes)[0];
@@ -4982,9 +7020,9 @@ var GameCharactersThree = (() => {
     crater.userData.wound = 1;
     return crater;
   };
-  var explodeChunks = (three, materials, random, box, direction, fling) => {
-    const centre = box.getCenter(new three.Vector3());
-    const size = box.getSize(new three.Vector3()).length();
+  var explodeChunks = (three, materials, random, box2, direction, fling) => {
+    const centre = box2.getCenter(new three.Vector3());
+    const size = box2.getSize(new three.Vector3()).length();
     const chunkMaterials = [materials.flesh, materials.bruise, materials.bone, materials.flesh, materials.meat];
     for (let i = 0; i < 14; i++) {
       const chunk = new three.Mesh(new three.BoxGeometry(0.015 + random() * size * 0.18, 0.015 + random() * size * 0.14, 0.015 + random() * size * 0.14), chunkMaterials[i % 5]);
@@ -5017,7 +7055,7 @@ var GameCharactersThree = (() => {
   };
 
   // src/wounds/wounds.ts
-  var worldPosition = (three, object) => object.getWorldPosition(new three.Vector3());
+  var worldPosition = (three, object2) => object2.getWorldPosition(new three.Vector3());
   var createWounds = (three, options) => {
     const { random, scene: scene2, bridge, sound } = options;
     const materials = options.materials ?? createWoundMaterials(three);
@@ -5028,11 +7066,11 @@ var GameCharactersThree = (() => {
       if (!found) throw new Error("game-characters-three: this body is not tracked by the wounds (call `track` first)");
       return found;
     };
-    const burstBlood = (state, change, object, direction) => {
-      const point = worldPosition(three, object);
+    const burstBlood = (state, change, object2, direction) => {
+      const point = worldPosition(three, object2);
       bridge?.burst(change, [point.x, point.y, point.z], state.body.blood, direction ? [direction.x, direction.y, direction.z] : void 0);
     };
-    const sideOf2 = (object, body) => new three.Vector3(object.position.x >= 0 ? 1 : -1, 0, 0).applyQuaternion(body.root.quaternion);
+    const sideOf2 = (object2, body) => new three.Vector3(object2.position.x >= 0 ? 1 : -1, 0, 0).applyQuaternion(body.root.quaternion);
     const hideBelow = (state, id) => {
       for (const below2 of segmentsBelow(id)) state.gone.add(below2);
     };
@@ -5066,8 +7104,8 @@ var GameCharactersThree = (() => {
       const target = state.body.nodes[id];
       if (!target || state.gone.has(id)) return;
       const { node, radius, flip } = target;
-      const box = new three.Box3().setFromObject(node);
-      explodeChunks(three, materials, random, box, direction, (chunk, velocity, spin) => {
+      const box2 = new three.Box3().setFromObject(node);
+      explodeChunks(three, materials, random, box2, direction, (chunk, velocity, spin) => {
         scene2.add(chunk);
         flying.throwObject(chunk, velocity, spin, id);
       });
@@ -5726,7 +7764,7 @@ var GameCharactersThree = (() => {
       batches = variants.map((variant) => createVariantBatches(three, variant, time));
       for (const set of batches) for (const batch of set) group.add(batch.mesh);
     };
-    const color = (hex2) => new three.Color(hex2);
+    const color2 = (hex2) => new three.Color(hex2);
     return {
       group,
       spawn(count) {
@@ -5757,7 +7795,7 @@ var GameCharactersThree = (() => {
           const variant = variants[member.variant];
           const distance3 = Math.hypot(member.x - camera.position.x, member.z - camera.position.z);
           const level = lodAt(distance3, LOD_DISTANCES);
-          const eye = color(eyes[variant.typeId] ?? 14926657);
+          const eye = color2(eyes[variant.typeId] ?? 14926657);
           batches[member.variant][level]?.push({ a: [member.x, member.z, member.yaw, member.phase], b: [variant.s, variant.bulk, STRIDE, pose], c: [0, 0.4, 1, member.phase], color: { r: 0.4, g: 0.45, b: 0.5 }, eye });
         }
         for (const set of batches) for (const batch of set) batch.end();
@@ -5822,6 +7860,58 @@ var GameCharactersThree = (() => {
     return spec;
   };
 
+  // src/test-area/knock.ts
+  var KNOCK_DOWN_SPEED = 2.5;
+  var KNOCKED_DOWN_ANGLE = 1.35;
+  var LIE_SECONDS = 1.6;
+  var STAND_UP_PER_SPEED = 0.25;
+  var FALL_SECONDS = 0.25;
+  var RISE_SECONDS = 0.6;
+  var GROUND_FRICTION = 7;
+  var GRAVITY3 = 9.81;
+  var CHEST = 1.1;
+  var bodyMass = (height, build = 1) => 70 * (height / 1.75) ** 2 * build;
+  function knockOf(blast2, feet, mass, options) {
+    const hit = blastShove(blast2, { position: [feet[0], feet[1] + CHEST, feet[2]], mass }, options);
+    if (!hit) return void 0;
+    const [dx, dy, dz] = hit.direction;
+    return { velocity: [dx * hit.speed, Math.max(0, dy * hit.speed), dz * hit.speed], airborne: dy > 0, lying: 0, lieLeft: 0, down: hit.speed >= KNOCK_DOWN_SPEED };
+  }
+  function stepKnock(knock, position, dt, groundAt, alive) {
+    const v = knock.velocity;
+    position.x += v[0] * dt;
+    position.z += v[2] * dt;
+    const ground = groundAt(position.x, position.z);
+    if (knock.airborne || position.y > ground + 1e-4) {
+      v[1] -= GRAVITY3 * dt;
+      position.y += v[1] * dt;
+      if (position.y <= ground) {
+        position.y = ground;
+        v[1] = 0;
+        knock.airborne = false;
+      }
+    } else position.y = ground;
+    const horizontal = Math.hypot(v[0], v[2]);
+    if (!knock.airborne && horizontal > 0) {
+      const slowed = Math.max(0, horizontal - GROUND_FRICTION * dt);
+      v[0] *= slowed / horizontal;
+      v[2] *= slowed / horizontal;
+    }
+    const moving = horizontal > 0.05 || knock.airborne;
+    if (knock.down) {
+      if (moving) knock.lying = Math.min(1, knock.lying + dt / FALL_SECONDS);
+      else {
+        knock.lying = 1;
+        if (alive) {
+          knock.lieLeft = knock.lieLeft > 0 ? knock.lieLeft : LIE_SECONDS + Math.hypot(v[0], v[2]) * STAND_UP_PER_SPEED;
+          knock.lieLeft -= dt;
+          if (knock.lieLeft <= 0) knock.down = false;
+        }
+      }
+    } else if (knock.lying > 0) knock.lying = Math.max(0, knock.lying - dt / RISE_SECONDS);
+    return !moving && !knock.down && knock.lying === 0;
+  }
+
   // src/test-area/scenarios.ts
   var LIMB_SEGMENTS = ["upperArmL", "forearmL", "handL", "upperArmR", "forearmR", "handR", "thighL", "shinL", "footL", "thighR", "shinR", "footR"];
   var BENCHMARK_BODIES = 1e3;
@@ -5899,8 +7989,8 @@ var GameCharactersThree = (() => {
         const colors = (decay) => {
           const root = deps.buildZombie(deps.typeNames()[0], decay);
           const seen = /* @__PURE__ */ new Set();
-          root.traverse((object) => {
-            const material = object.material;
+          root.traverse((object2) => {
+            const material = object2.material;
             if (material?.color) seen.add(material.color.getHexString());
           });
           return [...seen].sort().join(",");
@@ -6155,12 +8245,12 @@ var GameCharactersThree = (() => {
         return built.root;
       },
       impl: (root, id) => {
-        const object = root;
-        const made = builtOf.get(object);
+        const object2 = root;
+        const made = builtOf.get(object2);
         const character = createCharacter(made.kind, made.cardId, id);
         const scale = character.spec.height / kit.body.heightMetres;
-        if (Math.abs(scale - 1) > 0.01) object.scale.setScalar(scale);
-        const entry = { id, kind: made.kind, cardId: made.cardId, root: object, body: woundBodyOf(object), eyes: three ? findEyes(three, object) : null, built: made.built, character, walk: 0, tilt: 0 };
+        if (Math.abs(scale - 1) > 0.01) object2.scale.setScalar(scale);
+        const entry = { id, kind: made.kind, cardId: made.cardId, root: object2, body: woundBodyOf(object2), eyes: three ? findEyes(three, object2) : null, built: made.built, character, walk: 0, tilt: 0 };
         entry.character = wrap(entry, character);
         const age = made.kind === "zombie" ? undead?.traitsOf(character)?.age : void 0;
         const blood = age !== void 0 ? options.bloodOf?.(age) : void 0;
@@ -6178,7 +8268,7 @@ var GameCharactersThree = (() => {
       return undead.speedFor(traits, { moment: MOMENTS_WITH_LIMP.has(moment) ? "chase" : moment, limp: moment === "limp", crawling: moment === "crawl" || entry.character.limping.length > 1 });
     };
     const clearOverlays = () => {
-      for (const object of overlays.values()) object.parent?.remove(object);
+      for (const object2 of overlays.values()) object2.parent?.remove(object2);
       overlays.clear();
     };
     const overlayFor = (layer, entry) => {
@@ -6189,16 +8279,16 @@ var GameCharactersThree = (() => {
         for (const part of entry.character.describe().parts) {
           const shape = part.shape;
           const geometry = shape.kind === "sphere" ? new three.SphereGeometry(shape.radius, 8, 6) : shape.kind === "cylinder" ? new three.CylinderGeometry(shape.radius, shape.radius, shape.height, 8, 1) : new three.BoxGeometry(...shape.size);
-          const mesh = new three.Mesh(geometry, material);
-          mesh.position.set(...part.position);
-          if (part.rotation) mesh.rotation.set(...part.rotation);
-          group.add(mesh);
+          const mesh2 = new three.Mesh(geometry, material);
+          mesh2.position.set(...part.position);
+          if (part.rotation) mesh2.rotation.set(...part.rotation);
+          group.add(mesh2);
         }
       } else if (layer === "joints") {
         for (const joint of Object.values(entry.character.rig.joints)) {
-          const mesh = new three.Mesh(new three.SphereGeometry(0.025, 6, 4), material);
-          mesh.position.set(...joint);
-          group.add(mesh);
+          const mesh2 = new three.Mesh(new three.SphereGeometry(0.025, 6, 4), material);
+          mesh2.position.set(...joint);
+          group.add(mesh2);
         }
       } else if (layer === "speed") {
         const length = Math.max(0.1, speedOf(entry));
@@ -6225,6 +8315,17 @@ var GameCharactersThree = (() => {
     };
     const animate = (entry, dt) => {
       const { root, character } = entry;
+      if (entry.knock) {
+        const rig = root.userData.rig;
+        const ground = (x, z) => host?.groundAt(x, z) ?? 0;
+        const done = stepKnock(entry.knock, root.position, dt, ground, character.alive);
+        if (done) entry.knock = void 0;
+        if (character.alive && rig) rig.fig.rotation.x = -(entry.knock?.lying ?? 0) * KNOCKED_DOWN_ANGLE;
+        if (entry.knock && entry.knock.lying > 0 && character.alive) {
+          entry.eyes?.off();
+          return;
+        }
+      }
       if (!character.alive) {
         entry.tilt = Math.min(1, entry.tilt + dt * 2);
         const rig = root.userData.rig;
@@ -6430,6 +8531,15 @@ var GameCharactersThree = (() => {
         wounds = createWounds(lent.THREE, { random, scene: scene2, groundAt: (x, z) => lent.groundAt(x, z), ...bridge ? { bridge } : {}, ...sound ? { sound } : {} });
         for (const entry of entries.values()) trackEntry(entry);
         const stopChange = lent.bench?.onChange(onChange);
+        const stopEvents = lent.on((event) => {
+          if (event.type !== "explosion") return;
+          for (const entry of entries.values()) {
+            if (!entry.root.parent) continue;
+            const p2 = entry.root.position;
+            const knock = knockOf(event, [p2.x, p2.y, p2.z], bodyMass(entry.character.spec.height, entry.character.spec.build), lent.blastShove);
+            if (knock) entry.knock = entry.knock ? { ...knock, lying: entry.knock.lying } : knock;
+          }
+        });
         const stopFrame = lent.onFrame((dt) => {
           time += dt;
           for (const [id, entry] of entries) {
@@ -6445,6 +8555,7 @@ var GameCharactersThree = (() => {
         });
         return () => {
           stopChange?.();
+          stopEvents();
           stopFrame();
           clearOverlays();
           wounds?.dispose();
@@ -6480,6 +8591,1440 @@ var GameCharactersThree = (() => {
   var registerBodyMaterial = (world) => {
     if (!world.materials.has(BODY_MATERIAL_DEF.id)) world.materials.set(BODY_MATERIAL_DEF.id, BODY_MATERIAL_DEF);
   };
+
+  // src/presets/player-avatar.json
+  var player_avatar_default = {
+    source: {
+      file: "site/pages/jogo/zombiada-modo-livre.html",
+      variable: "PB specs[0] ('voc\xEA') and PLAYER_COR",
+      note: "The team game's player body: the Besti\xE1rio/Elenco human body. Overridable by `createPlayerAvatar(THREE, { spec, shirtColor })`."
+    },
+    spec: {
+      type: "Lento",
+      human: true,
+      decay: 0,
+      seed: 4242,
+      skin: "b07a52",
+      fem: false,
+      life: 1,
+      hs: "short",
+      hair: "2a1e16",
+      pose: {
+        armL: 0,
+        armR: 0,
+        elbL: -0.12,
+        elbR: -0.12,
+        armOut: 0.11,
+        lean: 0.04,
+        headX: 0,
+        headZ: 0
+      }
+    },
+    shirtColor: "3d5a73"
+  };
+
+  // src/player/avatar.ts
+  var TWO_PI2 = Math.PI * 2;
+  var MAX_GAIT = 1.4;
+  var CLIP_BLEND = 0.12;
+  var FALL_SECONDS2 = 0.3;
+  var HIP_HEIGHT = 0.95;
+  var WALK_ARM = 0.28;
+  var WALK_BOB = 0.035;
+  var WALK_LEAN = 0.04;
+  var RUN_LEAN = 0.16;
+  var RUN_BOB = 0.05;
+  var REST_ARM_Z = 0.18;
+  var CROUCH = { thigh: -0.95, thighWalk: 0.3, shin: 1.9, lean: 0.25, drop: -0.35 };
+  var AIMED = { shoulder: -1.42, perAim: 0.85, swing: 0.02, zRight: -0.54, zLeft: 0.36, elbowRight: -0.04, elbowLeft: -0.12 };
+  var DOWN = { thighWalk: 0.5, shinSwing: 0.85, shinBend: 1.3, armHigh: -2.8, armLow: -0.35, armWave: 0.3, armZ: 0.5, armZWave: 0.3, tilt: 1.5, roll: 0.3, hipY: 0.16, hipZ: 0.6, hipZFlip: 1.2 };
+  var HAND_OFFSET = { x: 0, y: -0.33, z: 0.04 };
+  var hexOf = (value) => typeof value === "string" ? Number.parseInt(value, 16) : value;
+  var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+  var fract = (value) => value - Math.floor(value);
+  var createPlayerAvatar = (THREE, options = {}) => {
+    const pose = {
+      armL: 0,
+      armR: 0,
+      elbL: -0.08,
+      elbR: -0.08,
+      lean: 0.04,
+      headX: 0,
+      headZ: 0,
+      ...player_avatar_default.spec.pose,
+      ...options.spec?.pose
+    };
+    const spec = { ...player_avatar_default.spec, ...options.spec, pose };
+    for (const key of ["skin", "hair"]) if (typeof spec[key] === "string") spec[key] = hexOf(spec[key]);
+    const best = createBestBuilder(THREE, { types: [{ name: String(spec.type), eye: 0 }], random: createRng(Number(spec.seed ?? 1)) });
+    const body = best.build(spec);
+    best.topM().color.setHex(options.shirtColor ?? hexOf(player_avatar_default.shirtColor));
+    const rig = body.userData.rig;
+    const profile = { f: 1.1, a: 0.28, k: 0.35, arm: WALK_ARM, bob: WALK_BOB };
+    const animator = createRigAnimator({ gaits: { [rig.type]: profile } });
+    const clips = options.clips ?? createPoseClipRegistry(POSE_CLIPS);
+    const blendDefault = options.blend ?? CLIP_BLEND;
+    const fallSeconds = options.fallSeconds ?? FALL_SECONDS2;
+    const smooth = options.cascade ?? true;
+    const root = new THREE.Group();
+    const tilt = new THREE.Group();
+    tilt.add(body);
+    root.add(tilt);
+    const colorOf2 = (object2) => object2?.material?.color?.getHex();
+    const meshesOf = (node) => node.children.filter((child) => child.isMesh);
+    const shirt = options.shirtColor ?? hexOf(player_avatar_default.shirtColor);
+    const shoe = meshesOf(rig.legs[0].kn).find((mesh2) => mesh2.scale.z > 1.5);
+    const forearm = colorOf2(meshesOf(rig.arms[1].el)[0]);
+    const colors = {
+      skin: Number(spec.skin),
+      shirt,
+      trousers: colorOf2(meshesOf(rig.legs[0].g)[0]) ?? 2962496,
+      shoes: colorOf2(shoe) ?? 1841690,
+      longSleeves: forearm === shirt
+    };
+    const sockets = { R: new THREE.Object3D(), L: new THREE.Object3D() };
+    const armOf = { R: rig.arms[1], L: rig.arms[0] };
+    for (const side of ["R", "L"]) {
+      sockets[side].name = `hand_${side}`;
+      sockets[side].position.set(HAND_OFFSET.x, HAND_OFFSET.y, HAND_OFFSET.z);
+      armOf[side].el.add(sockets[side]);
+    }
+    const addMesh = (parent, geometry, material, x = 0, y = 0, z = 0, rx = 0, ry = 0, rz = 0) => {
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.position.set(x, y, z);
+      if (rx || ry || rz) mesh2.rotation.set(rx, ry, rz);
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      parent.add(mesh2);
+      return mesh2;
+    };
+    const hands = [];
+    rig.arms.forEach((arm, index) => {
+      const el = arm.el;
+      const side = index === 0 ? 1 : -1;
+      const oldHand = meshesOf(el).find((mesh2) => Math.abs(mesh2.position.y + 0.33) < 0.025);
+      const handMaterial = oldHand?.material ?? new THREE.MeshLambertMaterial({ color: colors.skin });
+      if (oldHand) {
+        oldHand.geometry?.dispose();
+        el.remove(oldHand);
+      }
+      const hg = new THREE.Group();
+      hg.name = side > 0 ? "hand_group_L" : "hand_group_R";
+      hg.position.set(side * 0.02, -0.3, 0.01);
+      el.add(hg);
+      const palm = addMesh(hg, new THREE.SphereGeometry(0.048, 14, 10), handMaterial, 0, -0.035, 0);
+      palm.scale.set(0.6, 1.05, 1);
+      const built = buildHand({ THREE, add: addMesh, hg, handM: handMaterial, s: side, detailed: true });
+      hands.push({ side, hg, fingers: built.fingers, th: built.th });
+    });
+    const setHandGrip = (hand, grip, wristX = 0) => {
+      hand.fingers.forEach((finger, j) => {
+        finger.rotation.z = -hand.side * grip * (j % 2 ? 1.1 : 0.9);
+      });
+      if (hand.th) hand.th.rotation.z = -hand.side * (0.32 + grip * 0.25);
+      hand.hg.rotation.x = wristX;
+    };
+    const legRestX = rig.legs.map((leg) => leg.g.position.x);
+    const legSide = (index) => index === 0 ? 1 : -1;
+    let cycles = 0;
+    let time = 0;
+    let fall = 0;
+    let run = null;
+    const listeners = /* @__PURE__ */ new Set();
+    const emit = (event, onEvent) => {
+      onEvent?.(event);
+      for (const listener of listeners) listener(event);
+    };
+    const readPose = () => ({
+      lean: rig.upper.rotation.x,
+      twist: rig.upper.rotation.y,
+      side: rig.upper.rotation.z,
+      drop: rig.fig.position.y - rig.dropBase,
+      headX: rig.headG.rotation.x,
+      headY: rig.headG.rotation.y,
+      headZ: rig.headG.rotation.z,
+      armR: rig.arms[0].g.rotation.x,
+      armL: rig.arms[1].g.rotation.x,
+      elbR: rig.arms[0].el.rotation.x,
+      elbL: rig.arms[1].el.rotation.x,
+      armRz: rig.arms[0].g.rotation.z,
+      armLz: rig.arms[1].g.rotation.z,
+      legL: rig.legs[0].g.rotation.x,
+      legR: rig.legs[1].g.rotation.x,
+      kneeL: rig.legs[0].kn.rotation.x,
+      kneeR: rig.legs[1].kn.rotation.x
+    });
+    const armed = (pitch, gait, hip) => {
+      const aim = clamp((pitch + 1) / 3, 0, 0.99) * 3 - 1;
+      const shoulder = AIMED.shoulder + aim * AIMED.perAim + AIMED.swing * Math.sin(cycles * TWO_PI2) * gait;
+      rig.legs.forEach((leg, index) => {
+        const x = legRestX[index];
+        leg.g.rotation.y = hip;
+        leg.g.position.x = x * Math.cos(hip);
+        leg.g.position.z = -x * Math.sin(hip);
+      });
+      return { armR: shoulder, armL: shoulder, armRz: AIMED.zRight, armLz: AIMED.zLeft, elbR: AIMED.elbowRight, elbL: AIMED.elbowLeft };
+    };
+    const holdingPose = (gait, itemUse) => {
+      const bob = Math.sin(cycles * TWO_PI2) * 0.05 * gait;
+      if (!itemUse) {
+        return { armL: -0.45 + bob, armLz: 0.22, elbL: -1.05 };
+      }
+      const { id, position, rotation } = itemUse;
+      if (id === "drink" || id === "sip" || id === "chug") {
+        const raise2 = clamp((position[1] + 0.2) / 0.22, 0, 1);
+        const tilt3 = clamp(Math.abs(rotation[0]) / 1.22, 0, 1.15);
+        return {
+          armL: -0.45 - 0.95 * raise2 - 0.22 * tilt3,
+          armLz: 0.22 + 0.44 * raise2,
+          elbL: -1.05 - 0.85 * raise2 + 0.12 * tilt3,
+          headX: -0.26 * tilt3
+        };
+      }
+      if (id === "open" || id === "close") {
+        const reach = clamp((0.22 - position[0]) / 0.12, 0, 1);
+        return {
+          armL: -0.45 - 0.35 * reach,
+          armLz: 0.22 + 0.28 * reach,
+          elbL: -1.05 - 0.25 * reach,
+          armR: -0.78 * reach,
+          armRz: -0.48 * reach,
+          elbR: -1.25 * reach
+        };
+      }
+      const raise = clamp((position[1] + 0.2) / 0.25, 0, 1);
+      const tilt2 = clamp(Math.abs(rotation[0]) / 1.75, 0, 1.2);
+      const ext = Math.max(raise, tilt2 * 0.75);
+      return {
+        armL: -0.45 - 0.48 * ext,
+        armLz: 0.22 + 0.08 * ext,
+        elbL: -1.05 + 0.38 * ext
+      };
+    };
+    const resetLegYaw = () => {
+      rig.legs.forEach((leg, index) => {
+        leg.g.rotation.y = 0;
+        leg.g.position.x = legRestX[index];
+        leg.g.position.z = 0;
+      });
+    };
+    const runningPose = (gait, busyHands = false) => {
+      const ph = cycles * TWO_PI2;
+      const sine = Math.sin(ph);
+      const cosine = Math.cos(ph);
+      const legL = sine * 0.65 * gait;
+      const legR = -sine * 0.65 * gait;
+      const kneeL = Math.max(0, -cosine) * 1.15 * gait;
+      const kneeR = Math.max(0, cosine) * 1.15 * gait;
+      const targets = {
+        lean: RUN_LEAN * Math.min(1, gait),
+        drop: Math.abs(cosine) * RUN_BOB * gait,
+        legL,
+        legR,
+        kneeL,
+        kneeR
+      };
+      if (!busyHands) {
+        targets.armR = -0.32 - sine * 0.65 * gait;
+        targets.armL = -0.32 + sine * 0.65 * gait;
+        targets.elbR = -1.25 + Math.max(0, sine) * 0.3 * gait;
+        targets.elbL = -1.25 + Math.max(0, -sine) * 0.3 * gait;
+        targets.armRz = 0.22;
+        targets.armLz = -0.22;
+      }
+      return targets;
+    };
+    const crouchPose = (gait) => {
+      const swing = (leg) => {
+        const legS = legSide(leg);
+        return CROUCH.thigh - Math.sin(cycles * TWO_PI2) * legS * CROUCH.thighWalk * gait;
+      };
+      return {
+        legL: swing(0),
+        legR: swing(1),
+        kneeL: CROUCH.shin,
+        kneeR: CROUCH.shin,
+        lean: WALK_LEAN * gait + CROUCH.lean,
+        drop: Math.abs(Math.sin(cycles * TWO_PI2)) * WALK_BOB * gait + CROUCH.drop
+      };
+    };
+    const downPose = () => {
+      const ph = cycles * TWO_PI2;
+      const gait = 1;
+      const leg = (index) => {
+        const legS = legSide(index);
+        const walkS = Math.sin(ph) * legS;
+        const bend = fract(cycles * 3) * legS > 0.3 ? fract(cycles * 3) * DOWN.shinBend : Math.max(0, Math.cos(ph + (legS > 0 ? 0 : Math.PI))) * DOWN.shinSwing * gait;
+        return { hip: -walkS * DOWN.thighWalk * gait, knee: bend };
+      };
+      const arm = (index) => {
+        const side = index === 0 ? 1 : -1;
+        const armS = Math.sin(ph) * (side > 0 ? 1 : -1);
+        const shoulder = fract(cycles * 5) > 0.5 && side > 0 ? DOWN.armHigh : DOWN.armLow + DOWN.armWave * Math.sin(cycles * 5 + side);
+        return { shoulder, z: side * (DOWN.armZ + DOWN.armZWave * Math.sin(cycles * 3)), elbow: -0.35 - Math.max(0, armS) * 0.4 * gait };
+      };
+      const [l, r] = [leg(0), leg(1)];
+      const [a0, a1] = [arm(0), arm(1)];
+      return {
+        legL: l.hip,
+        kneeL: l.knee,
+        legR: r.hip,
+        kneeR: r.knee,
+        armR: a0.shoulder,
+        armRz: a0.z,
+        elbR: a0.elbow,
+        armL: a1.shoulder,
+        armLz: a1.z,
+        elbL: a1.elbow,
+        lean: WALK_LEAN * gait,
+        drop: Math.abs(Math.sin(ph)) * WALK_BOB * gait
+      };
+    };
+    const placeBody = (progress) => {
+      const fk = progress * progress * (3 - 2 * progress);
+      const flip = fract(cycles * 1.7) >= 0.5 ? 1 : 0;
+      tilt.rotation.set((-DOWN.tilt + flip * 2 * DOWN.tilt) * fk, 0, Math.sin(cycles * 7) * DOWN.roll * fk, "XYZ");
+      const hip = new THREE.Vector3(0, HIP_HEIGHT, 0);
+      const target = new THREE.Vector3(0, DOWN.hipY, -DOWN.hipZ + flip * DOWN.hipZFlip);
+      const place = new THREE.Vector3(0, HIP_HEIGHT * (1 - fk), 0).addScaledVector(target, fk);
+      tilt.position.copy(place.sub(hip.applyEuler(tilt.rotation)));
+    };
+    const fireClipEvents = (r, from, to) => {
+      for (const event of clipEventsBetween(r.clip, from, to)) emit({ ...event, clip: r.clip.id }, r.onEvent);
+    };
+    const stepClip = (dt, down) => {
+      if (!run) return;
+      const r = run;
+      const from = r.time;
+      r.time += dt;
+      const { duration } = r.clip;
+      if (r.clip.loop && r.time > duration) {
+        fireClipEvents(r, from, duration);
+        r.time -= duration * Math.floor(r.time / duration);
+        fireClipEvents(r, -1e-9, r.time);
+      } else {
+        fireClipEvents(r, from, Math.min(r.time, duration));
+        if (r.time >= duration && !r.clip.loop) r.target = 0;
+      }
+      r.weight = r.blend <= 0 ? r.target : clamp(r.weight + (r.target ? dt : -dt) / r.blend, 0, 1);
+      if (r.target === 0 && r.weight <= 0) {
+        run = null;
+        return;
+      }
+      if (down) return;
+      const sampled = filterPoseChannels(samplePoseClip(r.clip, Math.min(r.time, duration)), r.clip.channels ?? "full");
+      const current = readPose();
+      const blended = {};
+      for (const [name, value] of Object.entries(sampled)) if (name in current) blended[name] = current[name] + (value - current[name]) * r.weight;
+      animator.setPose(rig, blended);
+    };
+    return {
+      root,
+      rig,
+      colors,
+      three: THREE,
+      get playing() {
+        return run ? run.clip.id : null;
+      },
+      update(dt, state = {}) {
+        const speed = state.speed ?? 0;
+        const moving = speed >= 0.05;
+        const down = !!state.down;
+        const running = Boolean(state.running && moving && !down && !state.crouch);
+        if (moving) cycles += dt * (running ? walkCadence(speed) * 1.3 : walkCadence(speed));
+        const gait = Math.min(MAX_GAIT, walkGait(speed));
+        profile.arm = (running ? 0.55 : WALK_ARM) * gait;
+        profile.bob = (running ? RUN_BOB : WALK_BOB) * gait;
+        time = cycles / (walkCadence(Math.max(speed, 0)) * (running ? 1.3 : 1));
+        animator.animate(body, time, { speed });
+        fall = fallSeconds <= 0 ? down ? 1 : 0 : clamp(fall + (down ? dt : -dt) / fallSeconds, 0, 1);
+        resetLegYaw();
+        if (down) animator.setPose(rig, downPose());
+        else {
+          if (running) animator.setPose(rig, runningPose(gait, Boolean(state.armed || state.holding || state.itemUse)));
+          if (state.crouch) animator.setPose(rig, crouchPose(gait));
+          if (state.armed) animator.setPose(rig, armed(state.pitch ?? 0, gait, state.hip ?? 0));
+          else if (state.holding || state.itemUse) animator.setPose(rig, holdingPose(gait, state.itemUse));
+          else if (!running) {
+            animator.setPose(rig, {
+              armRz: REST_ARM_Z,
+              armLz: -REST_ARM_Z,
+              elbR: -0.12,
+              elbL: -0.12
+            });
+          }
+        }
+        placeBody(fall);
+        stepClip(dt, down);
+        if (smooth) animator.cascade(rig, dt);
+        const clipId = run ? run.clip.id : null;
+        const ph = cycles * TWO_PI2;
+        hands.forEach((hand) => {
+          const isRight = hand.side < 0;
+          const holdRight = isRight && (!!state.holding || !!state.itemUse);
+          const holdLeft = !isRight && (state.itemUse?.id === "open" || state.itemUse?.id === "close");
+          const grip = clipId === "punch_right" ? 1.4 : clipId === "shove_two_hands" ? 0.15 : state.armed || holdRight || holdLeft ? 1.22 : running ? 0.85 : 0.12;
+          const wristSwing = holdRight || state.armed || running ? 0 : -Math.min(1, gait) * Math.sin(ph - 0.6) * 0.12 * hand.side;
+          setHandGrip(hand, grip, wristSwing);
+        });
+      },
+      play(clip, playOptions = {}) {
+        const found = typeof clip === "string" ? clips.get(clip) : clip;
+        if (!found) throw new Error(`Unknown pose clip: ${String(clip)}`);
+        run = { clip: found, time: 0, weight: run?.weight ?? 0, target: 1, blend: playOptions.blend ?? blendDefault, ...playOptions.onEvent ? { onEvent: playOptions.onEvent } : {} };
+        fireClipEvents(run, -1e-9, 0);
+        run.time = 0;
+      },
+      stop() {
+        if (run) run.target = 0;
+      },
+      hand: (side) => sockets[side],
+      on(_type, listener) {
+        listeners.add(listener);
+        return () => void listeners.delete(listener);
+      },
+      dispose() {
+        run = null;
+        listeners.clear();
+        body.traverse((object2) => {
+          const mesh2 = object2;
+          mesh2.geometry?.dispose();
+          const material = mesh2.material;
+          if (Array.isArray(material)) material.forEach((m) => m.dispose());
+          else material?.dispose();
+        });
+        root.removeFromParent();
+      }
+    };
+  };
+
+  // ../game-characters-people/dist/index.js
+  var attack_clips_default = {
+    clips: [
+      {
+        id: "punch_right",
+        source: { authored: "game-kit", note: "authored in the kit; replace with the Elenco team's clip when delivered" },
+        duration: 0.35,
+        loop: false,
+        channels: "upper",
+        keys: [
+          { t: 0, pose: { lean: 0, twist: 0, side: 0, headX: 0, headY: 0, headZ: 0, armR: 0.05, armL: -0.1, elbR: -0.2, elbL: -0.2, armRz: 0, armLz: 0 } },
+          { t: 0.1, pose: { lean: 0.04, twist: -0.35, side: 0, headX: 0, headY: 0.28, headZ: 0, armR: 0.45, armL: -0.7, elbR: -1.9, elbL: -1.6, armRz: 0, armLz: 0.1 } },
+          { t: 0.16, pose: { lean: 0.2, twist: 0.5, side: 0, headX: 0, headY: -0.38, headZ: 0, armR: -1.5, armL: -0.6, elbR: -0.1, elbL: -1.7, armRz: -0.1, armLz: 0.1 } },
+          { t: 0.22, pose: { lean: 0.16, twist: 0.4, side: 0, headX: 0, headY: -0.3, headZ: 0, armR: -1.35, armL: -0.6, elbR: -0.25, elbL: -1.6, armRz: -0.08, armLz: 0.08 } },
+          { t: 0.35, pose: { lean: 0, twist: 0, side: 0, headX: 0, headY: 0, headZ: 0, armR: 0.05, armL: -0.1, elbR: -0.2, elbL: -0.2, armRz: 0, armLz: 0 } }
+        ],
+        events: [
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.windup" } },
+          { t: 0.1, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.16, type: "impact", data: { kind: "punch" } },
+          { t: 0.22, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      },
+      {
+        id: "shove_two_hands",
+        source: { authored: "game-kit", note: "authored in the kit; replace with the Elenco team's clip when delivered" },
+        duration: 0.5,
+        loop: false,
+        channels: "upper",
+        keys: [
+          { t: 0, pose: { lean: 0, twist: 0, side: 0, headX: 0, headY: 0, headZ: 0, armR: 0.05, armL: -0.1, elbR: -0.2, elbL: -0.2, armRz: 0, armLz: 0 } },
+          { t: 0.15, pose: { lean: -0.08, twist: 0, side: 0, headX: -0.05, headY: 0, headZ: 0, armR: -0.9, armL: -0.9, elbR: -1.9, elbL: -1.9, armRz: -0.12, armLz: 0.12 } },
+          { t: 0.26, pose: { lean: 0.3, twist: 0, side: 0, headX: 0.06, headY: 0, headZ: 0, armR: -1.5, armL: -1.5, elbR: -0.12, elbL: -0.12, armRz: -0.08, armLz: 0.08 } },
+          { t: 0.34, pose: { lean: 0.26, twist: 0, side: 0, headX: 0.05, headY: 0, headZ: 0, armR: -1.4, armL: -1.4, elbR: -0.2, elbL: -0.2, armRz: -0.06, armLz: 0.06 } },
+          { t: 0.5, pose: { lean: 0, twist: 0, side: 0, headX: 0, headY: 0, headZ: 0, armR: 0.05, armL: -0.1, elbR: -0.2, elbL: -0.2, armRz: 0, armLz: 0 } }
+        ],
+        events: [
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.windup" } },
+          { t: 0.15, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.26, type: "impact", data: { kind: "shove" } },
+          { t: 0.34, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      },
+      {
+        id: "front_kick",
+        source: { authored: "game-kit", note: "authored in the kit; replace with the Elenco team's clip when delivered" },
+        duration: 0.6,
+        loop: false,
+        channels: "full",
+        keys: [
+          { t: 0, pose: { lean: 0, twist: 0, side: 0, drop: 0, headX: 0, headY: 0, headZ: 0, armR: 0.05, armL: -0.1, elbR: -0.2, elbL: -0.2, armRz: 0, armLz: 0, legL: -0.05, legR: 0.05, kneeL: 0.05, kneeR: 0.05 } },
+          { t: 0.18, pose: { lean: -0.1, twist: 0, side: 0.04, drop: -0.05, headX: 0.05, headY: 0, headZ: 0, armR: -0.5, armL: 0.4, elbR: -0.5, elbL: -0.4, armRz: -0.1, armLz: 0.1, legL: 0.1, legR: -1.1, kneeL: 0.35, kneeR: 1.8 } },
+          { t: 0.32, pose: { lean: -0.22, twist: 0, side: 0.04, drop: -0.06, headX: 0.1, headY: 0, headZ: 0, armR: -0.7, armL: 0.7, elbR: -0.6, elbL: -0.3, armRz: -0.15, armLz: 0.15, legL: 0.12, legR: -1.45, kneeL: 0.2, kneeR: 0.1 } },
+          { t: 0.42, pose: { lean: -0.18, twist: 0, side: 0.03, drop: -0.05, headX: 0.08, headY: 0, headZ: 0, armR: -0.5, armL: 0.5, elbR: -0.5, elbL: -0.3, armRz: -0.1, armLz: 0.1, legL: 0.1, legR: -1.2, kneeL: 0.3, kneeR: 1.2 } },
+          { t: 0.6, pose: { lean: 0, twist: 0, side: 0, drop: 0, headX: 0, headY: 0, headZ: 0, armR: 0.05, armL: -0.1, elbR: -0.2, elbL: -0.2, armRz: 0, armLz: 0, legL: -0.05, legR: 0.05, kneeL: 0.05, kneeR: 0.05 } }
+        ],
+        events: [
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.windup" } },
+          { t: 0.18, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.32, type: "impact", data: { kind: "kick" } },
+          { t: 0.42, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      },
+      {
+        id: "recoil_rifle",
+        source: { authored: "game-kit", note: "authored in the kit; replace with the Elenco team's clip when delivered. Starts and ends at the armed pose of createPlayerAvatar at pitch 0" },
+        duration: 0.22,
+        loop: false,
+        channels: "upper",
+        keys: [
+          { t: 0, pose: { lean: 0, twist: 0, headX: 0, armR: -1.42, armL: -1.42, elbR: -0.04, elbL: -0.12, armRz: -0.54, armLz: 0.36 } },
+          { t: 0.04, pose: { lean: -0.1, twist: 0.03, headX: -0.06, armR: -1.62, armL: -1.62, elbR: -0.35, elbL: -0.45, armRz: -0.5, armLz: 0.34 } },
+          { t: 0.22, pose: { lean: 0, twist: 0, headX: 0, armR: -1.42, armL: -1.42, elbR: -0.04, elbL: -0.12, armRz: -0.54, armLz: 0.36 } }
+        ],
+        events: [
+          { t: 0, type: "impact", data: { kind: "shot" } },
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.08, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      },
+      {
+        id: "recoil_pistol",
+        source: { authored: "game-kit", note: "authored in the kit; replace with the Elenco team's clip when delivered. Starts and ends at the armed pose of createPlayerAvatar at pitch 0" },
+        duration: 0.18,
+        loop: false,
+        channels: "upper",
+        keys: [
+          { t: 0, pose: { lean: 0, twist: 0, headX: 0, armR: -1.42, armL: -1.42, elbR: -0.04, elbL: -0.12, armRz: -0.54, armLz: 0.36 } },
+          { t: 0.03, pose: { lean: -0.05, twist: 0.02, headX: -0.03, armR: -1.58, armL: -1.52, elbR: -0.22, elbL: -0.25, armRz: -0.52, armLz: 0.35 } },
+          { t: 0.18, pose: { lean: 0, twist: 0, headX: 0, armR: -1.42, armL: -1.42, elbR: -0.04, elbL: -0.12, armRz: -0.54, armLz: 0.36 } }
+        ],
+        events: [
+          { t: 0, type: "impact", data: { kind: "shot" } },
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.06, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      }
+    ],
+    locales: {
+      "pt-BR": {
+        "attack_clip.phase.windup": "Prepara\xE7\xE3o",
+        "attack_clip.phase.strike": "Golpe",
+        "attack_clip.phase.recover": "Recupera\xE7\xE3o"
+      },
+      en: {
+        "attack_clip.phase.windup": "Wind-up",
+        "attack_clip.phase.strike": "Strike",
+        "attack_clip.phase.recover": "Recover"
+      }
+    }
+  };
+  var first_person_clips_default = {
+    clips: [
+      {
+        id: "punch_right",
+        source: { authored: "game-kit", note: "first-person counterpart of attack-clips.json (same duration, same events); authored in the kit, replace with the Elenco team's clips when delivered" },
+        duration: 0.35,
+        keys: [
+          { t: 0, R: { p: [0.15, -0.12, -0.4], r: [0, 1.5, 0.15], grip: 1, w: 0 } },
+          { t: 0.1, R: { p: [0.21, -0.15, -0.29], r: [0.1, 1.45, 0.2], grip: 1 } },
+          { t: 0.16, R: { p: [0.06, -0.09, -0.62], r: [0, 1.5708, -0.05], grip: 1 } },
+          { t: 0.22, R: { p: [0.07, -0.1, -0.56], r: [0, 1.5708, -0.05], grip: 1 } },
+          { t: 0.35, R: { p: [0.15, -0.12, -0.4], r: [0, 1.5, 0.15], grip: 1, w: 0 } }
+        ],
+        events: [
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.windup" } },
+          { t: 0.1, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.16, type: "impact", data: { kind: "punch" } },
+          { t: 0.22, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      },
+      {
+        id: "shove_two_hands",
+        source: { authored: "game-kit", note: "first-person counterpart of attack-clips.json (same duration, same events); authored in the kit, replace with the Elenco team's clips when delivered" },
+        duration: 0.5,
+        keys: [
+          { t: 0, R: { p: [0.17, -0.14, -0.36], r: [0, 1.5708, 1.4], grip: 0.05, w: 0 }, L: "mirror" },
+          { t: 0.15, R: { p: [0.15, -0.09, -0.27], r: [0, 1.5708, 1.5], grip: 0.05 }, L: "mirror" },
+          { t: 0.26, R: { p: [0.11, -0.02, -0.58], r: [0, 1.5708, 1.75], grip: 0.05 }, L: "mirror" },
+          { t: 0.34, R: { p: [0.12, -0.03, -0.54], r: [0, 1.5708, 1.65], grip: 0.05 }, L: "mirror" },
+          { t: 0.5, R: { p: [0.17, -0.14, -0.36], r: [0, 1.5708, 1.4], grip: 0.05, w: 0 }, L: "mirror" }
+        ],
+        events: [
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.windup" } },
+          { t: 0.15, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.26, type: "impact", data: { kind: "shove" } },
+          { t: 0.34, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      },
+      {
+        id: "front_kick",
+        source: { authored: "game-kit", note: "first-person counterpart of attack-clips.json (same duration, same events); authored in the kit, replace with the Elenco team's clips when delivered" },
+        duration: 0.6,
+        keys: [
+          { t: 0, F: { p: [0.13, -0.85, -0.05], r: [0, 1.5708, 0], w: 0 } },
+          { t: 0.18, F: { p: [0.18, -0.58, -0.3], r: [0, 1.5708, 0.6] } },
+          { t: 0.32, F: { p: [0.12, -0.24, -0.65], r: [0, 1.5708, 0.35] } },
+          { t: 0.42, F: { p: [0.12, -0.3, -0.58], r: [0, 1.5708, 0.3] } },
+          { t: 0.6, F: { p: [0.13, -0.85, -0.05], r: [0, 1.5708, 0], w: 0 } }
+        ],
+        events: [
+          { t: 0, type: "phase", data: { label: "attack_clip.phase.windup" } },
+          { t: 0.18, type: "phase", data: { label: "attack_clip.phase.strike" } },
+          { t: 0.32, type: "impact", data: { kind: "kick" } },
+          { t: 0.42, type: "phase", data: { label: "attack_clip.phase.recover" } }
+        ]
+      }
+    ]
+  };
+  var names_default = {
+    sources: {
+      file: "specs/001-migracao-entregas-dos-times/sources/sobreviventes__os-vivos-do-vale.js (site/pages/sobreviventes/os-vivos-do-vale.html)",
+      pools: "NM (lines 610-611): m, f, s, bm, bf",
+      kinship: "RELW (line 612)"
+    },
+    "pt-BR": {
+      male: [
+        "Jo\xE3o",
+        "Paulo",
+        "Marcos",
+        "Andr\xE9",
+        "Rafael",
+        "Thiago",
+        "Bruno",
+        "Luiz",
+        "S\xE9rgio",
+        "Wagner",
+        "C\xEDcero",
+        "Edson",
+        "Igor",
+        "Mateus",
+        "Renan",
+        "Hugo"
+      ],
+      female: [
+        "Ana",
+        "Patr\xEDcia",
+        "Juliana",
+        "Camila",
+        "Sandra",
+        "Luana",
+        "M\xE1rcia",
+        "Fernanda",
+        "Aline",
+        "Rita",
+        "Jaqueline",
+        "Simone",
+        "Larissa",
+        "Bruna",
+        "Tereza",
+        "Vanessa"
+      ],
+      surnames: [
+        "Silva",
+        "Santos",
+        "Oliveira",
+        "Souza",
+        "Pereira",
+        "Lima",
+        "Carvalho",
+        "Gomes",
+        "Ribeiro",
+        "Martins",
+        "Rocha",
+        "Almeida",
+        "Barbosa",
+        "Teixeira",
+        "Moraes",
+        "Cunha"
+      ],
+      babyMale: [
+        "Davi",
+        "Miguel",
+        "Gael",
+        "Bento",
+        "Noah",
+        "Theo"
+      ],
+      babyFemale: [
+        "Esperan\xE7a",
+        "Aurora",
+        "Cec\xEDlia",
+        "Luna",
+        "Maria Luz",
+        "Alice"
+      ],
+      kinship: {
+        male: [
+          "irm\xE3o",
+          "primo",
+          "ex-aluno",
+          "vizinho",
+          "colega de trabalho",
+          "afilhado",
+          "filho"
+        ],
+        female: [
+          "irm\xE3",
+          "prima",
+          "ex-aluna",
+          "vizinha",
+          "colega de trabalho",
+          "afilhada",
+          "filha"
+        ]
+      }
+    }
+  };
+  var ATTACK_CLIPS = attack_clips_default.clips;
+  var ATTACK_CLIP_LOCALES = attack_clips_default.locales;
+  var FIRST_PERSON_CLIPS = first_person_clips_default.clips;
+  var NAME_POOLS = { "pt-BR": names_default["pt-BR"] };
+
+  // src/presets/first-person-arms.json
+  var first_person_arms_default = {
+    source: {
+      note: "Authored in the kit: no team delivered first-person arms. The rig is in metres in the camera's space (x right, y up, the view looks down -z); rest poses use the hand frame of HandPose in game-contracts, Euler [roll, yaw, pitch] in the order YZX (yaw pi/2 points the fingers forward)."
+    },
+    rig: {
+      shoulder: [0.16, -0.36, 0.18],
+      upper: 0.32,
+      fore: 0.3,
+      reachShift: 0.35,
+      wrist: 0.07,
+      elbowPole: [0.45, -1, 0.2],
+      shoulderLeft: [-0.07, -0.46, 0.18],
+      elbowPoleLeft: [-0.1, -1, 0.2],
+      radius: { shoulder: 0.04, elbow: 0.034, wrist: 0.028, cuff: 0.031 },
+      hip: [0.12, -0.82, 0.04],
+      thigh: 0.46,
+      shin: 0.46,
+      kneePole: [0.1, 0.5, -1],
+      foot: { p: [0.13, -0.85, -0.05], r: [0, 1.5708, 0] }
+    },
+    stances: {
+      relaxed: {
+        R: { p: [0.2, -0.22, -0.36], r: [0.05, 1.57, -0.05], grip: 0.2 },
+        L: "mirror"
+      },
+      fists: {
+        R: { p: [0.15, -0.12, -0.4], r: [0, 1.5, 0.15], grip: 1 },
+        L: "mirror"
+      },
+      hold: { follow: true, fallback: "relaxed" }
+    },
+    bob: { frequency: 2.3, x: 6e-3, y: 8e-3, run: 1.5, fullSpeed: 4, crouch: 0.02 }
+  };
+
+  // src/first-person/hand.ts
+  var FINGERS = [
+    { z: -0.03, lengths: [0.034, 0.024, 0.02], width: 0.016 },
+    { z: -0.0105, lengths: [0.038, 0.027, 0.022], width: 0.0165 },
+    { z: 9e-3, lengths: [0.035, 0.025, 0.02], width: 0.0155 },
+    { z: 0.027, lengths: [0.029, 0.02, 0.018], width: 0.0135 }
+  ];
+  var PALM = { length: 0.09, thick: 0.026, width: 0.09, wristWidth: 0.066 };
+  var FINGER_THICK = 0.0135;
+  var CURL = { near: 1.05, mid: 1.25, far: 0.85, spread: 0.06 };
+  var THUMB = { base: [5e-3, -6e-3, -0.044], near: 0.034, far: 0.028, width: 0.019 };
+  var createHandMesh = (THREE, skin, wristSkin = skin) => {
+    const root = new THREE.Group();
+    root.name = "first-person-hand";
+    const geometries = [];
+    const box2 = (parent, sx, sy, sz, x, y, z, material = skin) => {
+      const geometry = new THREE.BoxGeometry(sx, sy, sz);
+      geometries.push(geometry);
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.position.set(x, y, z);
+      mesh2.frustumCulled = false;
+      parent.add(mesh2);
+      return mesh2;
+    };
+    const palmGeometry = new THREE.BoxGeometry(PALM.length, PALM.thick, PALM.width);
+    const palmPosition = palmGeometry.getAttribute("position");
+    for (let i = 0; i < palmPosition.count; i++) {
+      if (palmPosition.getX(i) < 0) palmPosition.setZ(i, palmPosition.getZ(i) * PALM.wristWidth / PALM.width);
+    }
+    palmGeometry.computeVertexNormals();
+    geometries.push(palmGeometry);
+    const palm = new THREE.Mesh(palmGeometry, skin);
+    palm.frustumCulled = false;
+    root.add(palm);
+    const wristGeometry = new THREE.CylinderGeometry(0.03, 0.033, 0.05, 8);
+    wristGeometry.rotateZ(Math.PI / 2);
+    geometries.push(wristGeometry);
+    const wrist = new THREE.Mesh(wristGeometry, wristSkin);
+    wrist.position.set(-PALM.length / 2 - 0.018, 0, 0);
+    wrist.frustumCulled = false;
+    root.add(wrist);
+    const joints = [];
+    FINGERS.forEach((finger, index) => {
+      const segments = [];
+      let parent = root;
+      let at = PALM.length / 2;
+      finger.lengths.forEach((length, k) => {
+        const group = new THREE.Group();
+        group.position.set(at, k === 0 ? 2e-3 : 0, k === 0 ? finger.z : 0);
+        const taper = 1 - k * 0.07;
+        box2(group, length, FINGER_THICK * taper, finger.width * taper, length / 2, 0, 0);
+        parent.add(group);
+        segments.push(group);
+        parent = group;
+        at = length;
+      });
+      joints.push({ segments, weight: 1 + index * (CURL.spread / CURL.near) });
+    });
+    const thumbNear = new THREE.Group();
+    thumbNear.rotation.order = "YZX";
+    thumbNear.position.set(...THUMB.base);
+    box2(thumbNear, THUMB.near, FINGER_THICK * 1.1, THUMB.width, THUMB.near / 2, 0, 0);
+    const thumbFar = new THREE.Group();
+    thumbFar.position.set(THUMB.near, 0, 0);
+    box2(thumbFar, THUMB.far, FINGER_THICK, THUMB.width * 0.9, THUMB.far / 2, 0, 0);
+    thumbNear.add(thumbFar);
+    root.add(thumbNear);
+    let lastGrip = 0;
+    let indexCurl;
+    const curl = [CURL.near, CURL.mid, CURL.far];
+    const applyIndex = () => {
+      const finger = joints[0];
+      if (!finger) return;
+      const k = indexCurl === void 0 ? lastGrip : Math.min(1, Math.max(0, indexCurl));
+      finger.segments.forEach((segment, i) => segment.rotation.z = -curl[i] * k * finger.weight);
+    };
+    const setGrip = (grip) => {
+      const k = Math.min(1, Math.max(0, grip));
+      lastGrip = k;
+      for (const joint of joints) joint.segments.forEach((segment, i) => segment.rotation.z = -curl[i] * k * joint.weight);
+      thumbNear.rotation.set(0, 0.55 - 1.45 * k, -0.1 - 0.75 * k);
+      thumbFar.rotation.z = -0.1 - 0.7 * k;
+      applyIndex();
+    };
+    const setIndex = (value) => {
+      indexCurl = value;
+      applyIndex();
+    };
+    setGrip(0);
+    return {
+      root,
+      setGrip,
+      setIndex,
+      dispose() {
+        for (const geometry of geometries) geometry.dispose();
+      }
+    };
+  };
+
+  // src/first-person/ik.ts
+  var solveTwoBone = (root, target, upper, lower, pole, out) => {
+    const line = out.line.copy(target).sub(root);
+    let distance3 = line.length();
+    if (distance3 < 1e-6) line.set(0, 0, -1);
+    else line.divideScalar(distance3);
+    const min = Math.abs(upper - lower) + 1e-4;
+    const max = upper + lower - 1e-4;
+    out.clamped = distance3 > max || distance3 < min;
+    distance3 = Math.min(max, Math.max(min, distance3));
+    const along = (distance3 * distance3 + upper * upper - lower * lower) / (2 * distance3);
+    const across = Math.sqrt(Math.max(0, upper * upper - along * along));
+    const side = out.side.copy(pole);
+    side.addScaledVector(line, -side.dot(line));
+    if (side.lengthSq() < 1e-8) side.set(0, 1, 0).addScaledVector(line, -line.y);
+    if (side.lengthSq() < 1e-8) side.set(1, 0, 0);
+    side.normalize();
+    out.joint.copy(root).addScaledVector(line, along).addScaledVector(side, across);
+    out.end.copy(root).addScaledVector(line, distance3);
+    return out;
+  };
+  var createTwoBone = (THREE) => ({ joint: new THREE.Vector3(), end: new THREE.Vector3(), clamped: false, line: new THREE.Vector3(), side: new THREE.Vector3() });
+
+  // src/first-person/arms.ts
+  var DEFAULT_BLEND = 0.18;
+  var ELBOW_SEGMENTS = 8;
+  var REACH_SLACK = 0.97;
+  var CONTACT_PROBE = 1.4;
+  var CONTACT_MIN = 0.12;
+  var CONTACT_MARGIN = 5e-3;
+  var CONTACT_PALM = 0.03;
+  var FOOT_LENGTH = 0.24;
+  var FOOT_SHOWN = 1e-3;
+  var AWAY_DROP = 0.55;
+  var AWAY_OUT = 7;
+  var AWAY_IN = 20;
+  var AWAY_HIDDEN = 0.97;
+  var FILL = 0.3;
+  var FIRST_PERSON_STANCES = first_person_arms_default.stances;
+  var FIRST_PERSON_RIG = first_person_arms_default.rig;
+  var FIRST_PERSON_BOB = first_person_arms_default.bob;
+  var hexOf2 = (value) => typeof value === "string" ? Number.parseInt(value, 16) : value;
+  var scaleHex = (hex2, factor) => {
+    const channel = (shift) => Math.round((hex2 >> shift & 255) * factor);
+    return channel(16) << 16 | channel(8) << 8 | channel(0);
+  };
+  var mix2 = (a, b, k) => a + (b - a) * k;
+  var ease2 = (k) => k * k * (3 - 2 * k);
+  var FIRST_PERSON_COLORS = {
+    skin: hexOf2(player_avatar_default.spec.skin),
+    sleeve: hexOf2(player_avatar_default.shirtColor),
+    cuff: scaleHex(hexOf2(player_avatar_default.shirtColor), 0.72),
+    trouser: 2962496,
+    shoe: 1841690
+  };
+  var newPose = (THREE) => ({ p: new THREE.Vector3(), q: new THREE.Quaternion(), grip: 0, scale: 1 });
+  var copyPose = (to, from) => {
+    to.p.copy(from.p);
+    to.q.copy(from.q);
+    to.grip = from.grip;
+    to.scale = from.scale;
+    return to;
+  };
+  var mixPose = (THREE, out, a, b, k) => {
+    out.p.lerpVectors(a.p, b.p, k);
+    out.q.copy(a.q).slerp(b.q, k);
+    out.grip = mix2(a.grip, b.grip, k);
+    out.scale = mix2(a.scale, b.scale, k);
+    return out;
+  };
+  var mirrorRotation = (THREE, q) => {
+    const m = new THREE.Matrix4().makeRotationFromQuaternion(q);
+    const e = m.elements;
+    for (const [i, j] of [[0, 1], [0, 2], [1, 0], [2, 0]]) e[j * 4 + i] = -e[j * 4 + i];
+    return new THREE.Quaternion().setFromRotationMatrix(m);
+  };
+  var mirrorQuaternion = (THREE, q) => {
+    const m = new THREE.Matrix4().makeRotationFromQuaternion(q);
+    const e = m.elements;
+    for (let column = 0; column < 3; column++) e[column * 4] = -e[column * 4];
+    for (let row = 0; row < 3; row++) e[8 + row] = -e[8 + row];
+    return new THREE.Quaternion().setFromRotationMatrix(m);
+  };
+  function createFirstPersonArms(THREE, options = {}) {
+    const colors = { ...FIRST_PERSON_COLORS, ...options.colors };
+    const rig = {
+      ...FIRST_PERSON_RIG,
+      ...options.rig,
+      radius: { ...FIRST_PERSON_RIG.radius, ...options.rig?.radius },
+      foot: options.rig?.foot ?? FIRST_PERSON_RIG.foot
+    };
+    const stances = { ...FIRST_PERSON_STANCES, ...options.stances };
+    const bob = { ...FIRST_PERSON_BOB, ...options.bob };
+    const blendSeconds = options.blend ?? DEFAULT_BLEND;
+    const clips = new Map((options.clips ?? []).map((clip) => [clip.id, clip]));
+    const root = new THREE.Group();
+    root.name = "first-person-arms";
+    root.userData.viewmodel = true;
+    const lit = (color2) => new THREE.MeshLambertMaterial({ color: color2, emissive: scaleHex(color2, FILL) });
+    const materials = {
+      skin: lit(colors.skin),
+      sleeve: lit(colors.sleeve),
+      cuff: lit(colors.cuff),
+      trouser: lit(colors.trouser),
+      shoe: lit(colors.shoe),
+      sole: lit(scaleHex(colors.shoe, 0.55))
+    };
+    const geometries = [];
+    const Y = new THREE.Vector3(0, 1, 0);
+    const limb2 = (parent, wide, narrow, length, material) => {
+      const geometry = new THREE.CylinderGeometry(narrow, wide, length, 8, 1);
+      geometry.translate(0, length / 2, 0);
+      geometries.push(geometry);
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.frustumCulled = false;
+      mesh2.userData.length = length;
+      parent.add(mesh2);
+      return mesh2;
+    };
+    const ball = (parent, radius, material) => {
+      const geometry = new THREE.SphereGeometry(radius, ELBOW_SEGMENTS, 6);
+      geometries.push(geometry);
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.frustumCulled = false;
+      parent.add(mesh2);
+      return mesh2;
+    };
+    const place = (segment, from, to) => {
+      const direction = new THREE.Vector3().subVectors(to, from);
+      const length = direction.length();
+      segment.position.copy(from);
+      if (length > 1e-6) segment.quaternion.setFromUnitVectors(Y, direction.divideScalar(length));
+      segment.scale.y = length / segment.userData.length;
+    };
+    const arms = {};
+    for (const side of ["R", "L"]) {
+      const sign2 = side === "R" ? 1 : -1;
+      const hand = createHandMesh(THREE, materials.skin);
+      const anchor = new THREE.Group();
+      anchor.name = `first-person-hand-${side}`;
+      const mirror = new THREE.Group();
+      mirror.scale.z = sign2;
+      mirror.add(hand.root);
+      anchor.add(mirror);
+      root.add(anchor);
+      const upper = limb2(root, rig.radius.shoulder, rig.radius.elbow, rig.upper, materials.sleeve);
+      const fore = limb2(root, rig.radius.elbow, rig.radius.wrist, rig.fore, materials.sleeve);
+      const cuff = limb2(root, rig.radius.cuff, rig.radius.cuff, 0.03, materials.cuff);
+      const elbow = ball(root, rig.radius.elbow * 1.02, materials.sleeve);
+      elbow.name = `first-person-elbow-${side}`;
+      arms[side] = { side, sign: sign2, hand, anchor, upper, fore, cuff, elbow, shown: newPose(THREE), from: newPose(THREE), mode: null, blend: 1, drawn: newPose(THREE), joints: { shoulder: new THREE.Vector3(), elbow: new THREE.Vector3(), wrist: new THREE.Vector3() }, away: options.hideWhenIdle ? 1 : 0 };
+    }
+    const leg = new THREE.Group();
+    leg.name = "first-person-leg";
+    leg.visible = false;
+    root.add(leg);
+    const thigh = limb2(leg, 0.088, 0.068, rig.thigh, materials.trouser);
+    const shin = limb2(leg, 0.068, 0.05, rig.shin, materials.trouser);
+    const knee = ball(leg, 0.07, materials.trouser);
+    const shoe = new THREE.Group();
+    const shoeBox = (sx, sy, sz, x, y, material) => {
+      const geometry = new THREE.BoxGeometry(sx, sy, sz);
+      geometries.push(geometry);
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.position.set(x, y, 0);
+      mesh2.frustumCulled = false;
+      shoe.add(mesh2);
+    };
+    shoeBox(0.27, 0.07, 0.1, 0.065, -0.05, materials.shoe);
+    shoeBox(0.27, 0.025, 0.104, 0.065, -0.095, materials.sole);
+    shoeBox(0.1, 0.05, 0.088, 0.17, -5e-3, materials.shoe);
+    leg.add(shoe);
+    const shoulderOf = (sign2, out) => sign2 === -1 && rig.shoulderLeft ? out.set(...rig.shoulderLeft) : out.set(rig.shoulder[0] * sign2, rig.shoulder[1], rig.shoulder[2]);
+    const poleOf = (sign2) => sign2 === -1 && rig.elbowPoleLeft ? new THREE.Vector3(...rig.elbowPoleLeft) : new THREE.Vector3(rig.elbowPole[0] * sign2, rig.elbowPole[1], rig.elbowPole[2]);
+    const kneePole = new THREE.Vector3(...rig.kneePole);
+    const hip = new THREE.Vector3(...rig.hip);
+    const euler = new THREE.Euler(0, 0, 0, "YZX");
+    const quaternionOf = (r) => new THREE.Quaternion().setFromEuler(euler.set(r[0], r[1], r[2], "YZX"));
+    const restPose = (rest, mirror, out) => {
+      out.p.set(...rest.p);
+      out.q.copy(quaternionOf(rest.r));
+      if (mirror) {
+        out.p.x = -out.p.x;
+        out.q.copy(mirrorQuaternion(THREE, out.q));
+      }
+      out.grip = rest.grip ?? 0;
+      out.scale = 1;
+      return out;
+    };
+    const DEFAULT_REST = { p: [0.17, -0.3, -0.3], r: [0, 1.5, 0], grip: 0.3 };
+    const stanceRest = (id, side, out) => {
+      const stance = stances[id] ?? stances.relaxed;
+      const right = stance?.R ?? DEFAULT_REST;
+      const left = stance?.L;
+      if (side === "R") return restPose(right, false, out);
+      return left && left !== "mirror" ? restPose(left, false, out) : restPose(right, true, out);
+    };
+    const camPosition = new THREE.Vector3();
+    const camQuaternion = new THREE.Quaternion();
+    const camInverse = new THREE.Quaternion();
+    const clamped = newPose(THREE);
+    const probeAt = new THREE.Vector3();
+    const probeForward = new THREE.Vector3();
+    const probeFingers = new THREE.Vector3();
+    let contact;
+    const keepOutside = (pose, reach) => {
+      if (!contact) return pose;
+      probeAt.set(pose.p.x, pose.p.y, 0).applyQuaternion(camQuaternion).add(camPosition);
+      probeForward.set(0, 0, -1).applyQuaternion(camQuaternion);
+      const distance3 = contact([probeAt.x, probeAt.y, probeAt.z], [probeForward.x, probeForward.y, probeForward.z], CONTACT_PROBE);
+      if (distance3 === null) return pose;
+      const limit = Math.max(CONTACT_MIN, distance3 - reach - CONTACT_MARGIN);
+      if (-pose.p.z <= limit) return pose;
+      copyPose(clamped, pose);
+      clamped.p.z = -limit;
+      return clamped;
+    };
+    const forward = (pose, length) => Math.max(CONTACT_PALM, -probeFingers.set(1, 0, 0).applyQuaternion(pose.q).z * length * pose.scale);
+    const handReach = (pose) => forward(pose, 0.085);
+    const camScale = new THREE.Vector3();
+    const toCamera = (target, grip, scale, out) => {
+      out.p.set(...target.position).sub(camPosition).applyQuaternion(camInverse);
+      out.q.set(...target.quaternion).premultiply(camInverse);
+      out.grip = grip;
+      out.scale = scale;
+      return out;
+    };
+    const listeners = /* @__PURE__ */ new Set();
+    let run = null;
+    const emit = (event) => {
+      for (const listener of listeners) listener(event);
+    };
+    const fire = (clip, from, to) => {
+      for (const event of clipEventsBetween(clip, from, to)) emit({ ...event, clip: clip.id });
+    };
+    let stanceId = "relaxed";
+    let phase = 0;
+    let swing = 0;
+    let sink = 0;
+    let first = true;
+    const bobOffset = new THREE.Vector3();
+    const desired = newPose(THREE);
+    const channelPose = newPose(THREE);
+    const mixed = newPose(THREE);
+    const dropped = newPose(THREE);
+    let indexCurl;
+    const bone = createTwoBone(THREE);
+    const shoulder = new THREE.Vector3();
+    const wristAt = new THREE.Vector3();
+    const palmAt = new THREE.Vector3();
+    const fingers = new THREE.Vector3();
+    const towards = new THREE.Vector3();
+    const fromChannel = (channel, side, base, out) => {
+      out.p.set(...channel.p);
+      out.q.copy(quaternionOf(channel.r));
+      if (channel.mirror && side === "L") {
+        out.p.x = -out.p.x;
+        out.q.copy(mirrorQuaternion(THREE, out.q));
+      }
+      out.grip = channel.grip ?? base.grip;
+      out.scale = base.scale;
+      return out;
+    };
+    const drawArm = (arm, pose) => {
+      copyPose(arm.drawn, pose);
+      const scale = pose.scale;
+      fingers.set(1, 0, 0).applyQuaternion(pose.q);
+      wristAt.copy(pose.p).addScaledVector(fingers, -rig.wrist * scale);
+      shoulderOf(arm.sign, shoulder).add(bobOffset);
+      const excess = shoulder.distanceTo(wristAt) - (rig.upper + rig.fore) * REACH_SLACK;
+      if (excess > 0 && rig.reachShift > 0) shoulder.addScaledVector(towards.subVectors(wristAt, shoulder).normalize(), Math.min(excess, rig.reachShift));
+      solveTwoBone(shoulder, wristAt, rig.upper, rig.fore, poleOf(arm.sign), bone);
+      palmAt.copy(bone.end).addScaledVector(fingers, rig.wrist * scale);
+      arm.drawn.p.copy(palmAt);
+      arm.anchor.position.copy(palmAt);
+      arm.anchor.quaternion.copy(pose.q);
+      arm.anchor.scale.setScalar(scale);
+      arm.hand.setGrip(pose.grip);
+      arm.hand.setIndex(arm.side === "R" ? indexCurl : void 0);
+      arm.joints.shoulder.copy(shoulder);
+      arm.joints.elbow.copy(bone.joint);
+      arm.joints.wrist.copy(bone.end);
+      place(arm.upper, shoulder, bone.joint);
+      place(arm.fore, bone.joint, bone.end);
+      arm.elbow.position.copy(bone.joint);
+      const toWrist = new THREE.Vector3().subVectors(bone.end, bone.joint).normalize();
+      place(arm.cuff, new THREE.Vector3().copy(bone.end).addScaledVector(toWrist, -0.02), new THREE.Vector3().copy(bone.end).addScaledVector(toWrist, 0.012));
+    };
+    const footPose = newPose(THREE);
+    const footRest = newPose(THREE);
+    const ankle = new THREE.Vector3();
+    const hipMirrored = new THREE.Vector3(-hip.x, hip.y, hip.z);
+    const kneePoleMirrored = new THREE.Vector3(-kneePole.x, kneePole.y, kneePole.z);
+    const drawLeg = (pose, left) => {
+      const origin = left ? hipMirrored : hip;
+      solveTwoBone(origin, pose.p, rig.thigh, rig.shin, left ? kneePoleMirrored : kneePole, bone);
+      ankle.copy(bone.end);
+      place(thigh, origin, bone.joint);
+      place(shin, bone.joint, ankle);
+      knee.position.copy(bone.joint);
+      shoe.position.copy(ankle);
+      shoe.quaternion.copy(pose.q);
+    };
+    const modeOf = (key, arm) => {
+      if (arm.mode === key) return;
+      copyPose(arm.from, arm.shown);
+      arm.mode = key;
+      arm.blend = first ? 1 : 0;
+    };
+    return {
+      root,
+      get playing() {
+        return run ? run.clip.id : null;
+      },
+      get stance() {
+        return stanceId;
+      },
+      play(id, options2) {
+        const clip = clips.get(id);
+        if (!clip) return false;
+        run = { clip, time: 0, left: options2?.leg === "left" };
+        fire(clip, -1e-9, 0);
+        return true;
+      },
+      stop() {
+        run = null;
+      },
+      update(dt, state) {
+        const { camera } = state;
+        contact = state.contact;
+        camera.updateWorldMatrix(true, false);
+        camera.matrixWorld.decompose(camPosition, camQuaternion, camScale);
+        camInverse.copy(camQuaternion).invert();
+        root.position.copy(camPosition);
+        root.quaternion.copy(camQuaternion);
+        root.updateMatrixWorld(true);
+        const speed = state.speed ?? 0;
+        const target = Math.min(1, speed / bob.fullSpeed) * (state.running ? bob.run : 1);
+        swing += (target - swing) * Math.min(1, dt * 8);
+        phase += dt * speed * bob.frequency;
+        sink += ((state.crouch ? 1 : 0) - sink) * Math.min(1, dt * 8);
+        bobOffset.set(Math.sin(phase) * bob.x * swing, Math.sin(phase * 2) * bob.y * swing - bob.crouch * sink, 0);
+        stanceId = state.stance ?? "relaxed";
+        const stance = stances[stanceId] ?? stances.relaxed;
+        const targets = state.targets ?? null;
+        if (run) {
+          const from = run.time;
+          run.time += dt;
+          fire(run.clip, from, Math.min(run.time, run.clip.duration));
+        }
+        const sample = run ? sampleFirstPersonClip(run.clip, Math.min(run.time, run.clip.duration)) : null;
+        for (const side of ["R", "L"]) {
+          const arm = arms[side];
+          const target2 = targets?.[side];
+          let mode;
+          if (stance?.follow && target2) {
+            mode = "target";
+            toCamera(target2, (side === "L" ? targets?.gripL : void 0) ?? targets?.grip ?? 1, targets?.scale ?? 1, desired);
+          } else {
+            mode = `rest:${stance?.follow ? stance.fallback ?? "relaxed" : stanceId}`;
+            stanceRest(stance?.follow ? stance.fallback ?? "relaxed" : stanceId, side, desired);
+            desired.p.add(bobOffset);
+          }
+          modeOf(mode, arm);
+          if (side === "R") indexCurl = mode === "target" ? targets?.fingers?.index : void 0;
+          arm.blend = blendSeconds <= 0 ? 1 : Math.min(1, arm.blend + dt / blendSeconds);
+          if (arm.blend >= 1) copyPose(arm.shown, desired);
+          else mixPose(THREE, arm.shown, arm.from, desired, ease2(arm.blend));
+          const channel = sample?.[side];
+          let pose;
+          if (channel && channel.w > 0) {
+            fromChannel(channel, side, arm.shown, channelPose);
+            mixPose(THREE, mixed, arm.shown, channelPose, channel.w);
+            pose = mode === "target" ? mixed : keepOutside(mixed, handReach(mixed));
+          } else pose = mode === "target" ? arm.shown : keepOutside(arm.shown, handReach(arm.shown));
+          const idle = options.hideWhenIdle === true && mode === "rest:relaxed" && !(channel && channel.w > 0);
+          arm.away = options.hideWhenIdle ? Math.min(1, Math.max(0, arm.away + ((idle ? 1 : 0) - arm.away) * Math.min(1, dt * (idle ? AWAY_OUT : AWAY_IN)))) : 0;
+          if (arm.away > 0) {
+            copyPose(dropped, pose);
+            dropped.p.y -= AWAY_DROP * ease2(arm.away);
+            pose = dropped;
+          }
+          drawArm(arm, pose);
+          const shown = arm.away < AWAY_HIDDEN;
+          for (const part of [arm.anchor, arm.upper, arm.fore, arm.cuff, arm.elbow]) part.visible = shown;
+        }
+        const foot = sample?.F;
+        leg.visible = !!foot && foot.w > FOOT_SHOWN;
+        if (foot && leg.visible) {
+          restPose(rig.foot, false, footRest);
+          fromChannel(foot, "R", footRest, footPose);
+          mixPose(THREE, mixed, footRest, footPose, foot.w);
+          copyPose(footPose, mixed);
+          if (run?.left) {
+            footPose.p.x = -footPose.p.x;
+            footPose.q.copy(mirrorRotation(THREE, footPose.q));
+          }
+          drawLeg(contact ? keepOutside(footPose, forward(footPose, FOOT_LENGTH)) : footPose, run?.left ?? false);
+        }
+        if (run && run.time >= run.clip.duration) run = null;
+        first = false;
+      },
+      on(_type, listener) {
+        listeners.add(listener);
+        return () => void listeners.delete(listener);
+      },
+      joints(side) {
+        const { shoulder: shoulder2, elbow, wrist } = arms[side].joints;
+        return { shoulder: shoulder2.clone(), elbow: elbow.clone(), wrist: wrist.clone() };
+      },
+      handPose(side) {
+        const pose = arms[side].drawn;
+        return { position: pose.p.clone(), quaternion: pose.q.clone(), grip: pose.grip };
+      },
+      dispose() {
+        run = null;
+        listeners.clear();
+        for (const arm of Object.values(arms)) arm.hand.dispose();
+        for (const geometry of geometries) geometry.dispose();
+        for (const material of Object.values(materials)) material.dispose();
+        root.removeFromParent();
+      }
+    };
+  }
+
+  // src/player/room-avatar.ts
+  var impactOf = (clip) => clip.events?.find((event) => event.type === "impact")?.t ?? null;
+  var toRoomAvatar = (avatar, options = {}) => {
+    const arms = options.firstPerson === false ? null : createFirstPersonArms(avatar.three, {
+      colors: { skin: avatar.colors.skin, sleeve: avatar.colors.longSleeves ? avatar.colors.shirt : avatar.colors.skin, trouser: avatar.colors.trousers, shoe: avatar.colors.shoes, ...options.firstPerson?.colors },
+      clips: options.firstPersonClips ?? FIRST_PERSON_CLIPS,
+      hideWhenIdle: true,
+      ...options.firstPerson
+    });
+    const strikes = new Map((options.strikeClips ?? ATTACK_CLIPS).map((clip) => [clip.id, clip]));
+    const mirrored = /* @__PURE__ */ new Map();
+    const leftOf = (clip) => {
+      let found = mirrored.get(clip.id);
+      if (!found) mirrored.set(clip.id, found = mirrorPoseClip(clip, `${clip.id}_left`));
+      return found;
+    };
+    return {
+      root: avatar.root,
+      avatar,
+      arms,
+      ...arms ? { firstPerson: { root: arms.root, update: (dt, state) => arms.update(dt, state) } } : {},
+      update: (dt, state) => avatar.update(dt, {
+        speed: state.speed,
+        running: state.running,
+        crouch: state.crouch,
+        down: state.down,
+        armed: state.armed,
+        pitch: -state.pitch,
+        ...state.holding !== void 0 ? { holding: state.holding } : {},
+        ...state.itemUse !== void 0 ? { itemUse: state.itemUse } : {}
+      }),
+      hand: (side) => avatar.hand(side),
+      strike: (clipId, strikeOptions) => {
+        const clip = strikes.get(clipId);
+        if (!clip) return null;
+        const left = strikeOptions?.leg === "left";
+        avatar.play(left ? leftOf(clip) : clip);
+        arms?.play(clipId, left ? { leg: "left" } : void 0);
+        return impactOf(clip);
+      }
+    };
+  };
+
+  // src/player/test-text.ts
+  var AVATAR_TEXT = {
+    en: {
+      group: "Avatar",
+      name: "Player body",
+      actions: {
+        camera_first: "Camera: 1st person",
+        camera_third: "Camera: 3rd person",
+        crouch: "Crouch",
+        stand: "Stand up",
+        fall: "Fall down",
+        get_up: "Get up",
+        armed_on: "Armed: on",
+        armed_off: "Armed: off",
+        stop_clip: "Stop clip"
+      },
+      play: "Play",
+      metrics: { camera: "Camera", clip: "Clip playing", last_event: "Last clip event", state: "State", joints: "Joints" },
+      none: "none"
+    },
+    "pt-BR": {
+      group: "Avatar",
+      name: "Corpo do jogador",
+      actions: {
+        camera_first: "C\xE2mera: 1\xAA pessoa",
+        camera_third: "C\xE2mera: 3\xAA pessoa",
+        crouch: "Agachar",
+        stand: "Levantar",
+        fall: "Cair",
+        get_up: "Levantar do ch\xE3o",
+        armed_on: "Armado: ligado",
+        armed_off: "Armado: desligado",
+        stop_clip: "Parar clipe"
+      },
+      play: "Tocar",
+      metrics: { camera: "C\xE2mera", clip: "Clipe tocando", last_event: "\xDAltimo evento do clipe", state: "Estado", joints: "Juntas" },
+      none: "nenhum"
+    }
+  };
+
+  // src/player/test-module.ts
+  var AVATAR_AREA_ID = "avatar_area";
+  var round = (value) => (Math.round(value * 100) / 100).toString();
+  function createAvatarTestModule(options) {
+    const clips = options.clips ?? POSE_CLIPS;
+    const textOf = (locale) => AVATAR_TEXT[locale ?? options.locale ?? "pt-BR"] ?? AVATAR_TEXT["pt-BR"];
+    const phaseLabel = (label, locale) => {
+      const id = locale ?? options.locale ?? "pt-BR";
+      const table = { ...POSE_CLIP_LOCALES[id] ?? POSE_CLIP_LOCALES["pt-BR"], ...options.clipLocales?.[id] ?? options.clipLocales?.["pt-BR"] };
+      return typeof label === "string" ? table[label] ?? label : "";
+    };
+    const state = { crouch: false, down: false, armed: null };
+    let host = null;
+    let lastEvent = "";
+    const log = (action, extra = {}) => {
+      const entry = { type: "avatar", action, ...extra };
+      host?.log(JSON.stringify(entry), entry);
+    };
+    const push = (action, patch, extra = {}) => {
+      Object.assign(state, patch);
+      options.state?.set(patch);
+      log(action, { crouch: state.crouch, down: state.down, armed: state.armed, ...extra });
+    };
+    const setCamera = (mode) => {
+      options.camera?.set(mode);
+      log(`camera_${mode}`, { mode: options.camera?.mode() ?? null });
+    };
+    const onChange = (change) => {
+      if (change.kind !== "action") return;
+      switch (change.id) {
+        case "camera_first":
+          return setCamera("first");
+        case "camera_third":
+          return setCamera("third");
+        case "crouch":
+          return push("crouch", { crouch: true });
+        case "stand":
+          return push("stand", { crouch: false });
+        case "fall":
+          return push("fall", { down: true });
+        case "get_up":
+          return push("get_up", { down: false });
+        case "armed_on":
+          return push("armed_on", { armed: true });
+        case "armed_off":
+          return push("armed_off", { armed: false });
+        case "stop_clip":
+          options.avatar.stop();
+          return log("stop_clip", { playing: options.avatar.playing });
+        default: {
+          const clip = clips.find((item) => `play_${item.id}` === change.id);
+          if (!clip) return;
+          options.avatar.play(clip);
+          log("play_clip", { clip: clip.id, duration: clip.duration, loop: clip.loop ?? false, channels: clip.channels ?? "full" });
+        }
+      }
+    };
+    const joints = () => {
+      const rig = options.avatar.rig;
+      const [armA, armB] = rig.arms;
+      const [legA, legB] = rig.legs;
+      return `arms ${round(armA.g.rotation.x)}/${round(armB.g.rotation.x)} elbows ${round(armA.el.rotation.x)}/${round(armB.el.rotation.x)} legs ${round(legA.g.rotation.x)}/${round(legB.g.rotation.x)} knees ${round(legA.kn.rotation.x)}/${round(legB.kn.rotation.x)} lean ${round(rig.upper.rotation.x)}`;
+    };
+    return {
+      id: AVATAR_AREA_ID,
+      name: textOf().name,
+      group: textOf().group,
+      state,
+      items: () => [],
+      area: () => ({ placements: [], view: { eye: [0, 1.7, 6], target: [0, 1.2, 0] } }),
+      controls: (locale) => {
+        const text = textOf(locale);
+        const action = (id, name, hint) => ({ kind: "action", id, name, ...hint ? { hint } : {} });
+        return [
+          action("camera_first", text.actions.camera_first),
+          action("camera_third", text.actions.camera_third),
+          action("crouch", text.actions.crouch),
+          action("stand", text.actions.stand),
+          action("fall", text.actions.fall),
+          action("get_up", text.actions.get_up),
+          action("armed_on", text.actions.armed_on),
+          action("armed_off", text.actions.armed_off),
+          ...clips.map((clip) => action(`play_${clip.id}`, `${text.play}: ${clip.id}`)),
+          action("stop_clip", text.actions.stop_clip)
+        ];
+      },
+      metrics: (locale) => {
+        const text = textOf(locale);
+        return [
+          { id: "camera", name: text.metrics.camera, read: () => options.camera?.mode() ?? text.none },
+          { id: "clip", name: text.metrics.clip, read: () => options.avatar.playing ?? text.none },
+          { id: "last_event", name: text.metrics.last_event, read: () => lastEvent || text.none },
+          { id: "state", name: text.metrics.state, read: () => `${state.crouch ? "crouch " : ""}${state.down ? "down " : ""}${state.armed === null ? "" : state.armed ? "armed" : "unarmed"}`.trim() || text.none },
+          { id: "joints", name: text.metrics.joints, read: joints }
+        ];
+      },
+      attach(lent) {
+        host = lent;
+        const stopChange = lent.bench?.onChange(onChange);
+        const stopEvents = options.avatar.on("event", (event) => {
+          lastEvent = `${event.clip} ${event.type} ${round(event.t)}s${event.data && "label" in event.data ? ` ${phaseLabel(event.data.label)}` : ""}`;
+          log("clip_event", { clip: event.clip, event: event.type, t: event.t, data: event.data ?? null });
+          if (event.type === "impact") log("impact", { clip: event.clip, t: event.t, kind: event.data?.kind ?? null });
+        });
+        return () => {
+          stopChange?.();
+          stopEvents();
+          host = null;
+        };
+      }
+    };
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map