@adatechnology/game-characters-three 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,3857 @@
+// src/instanced/body-chunk.ts
+var BODY_CHUNK = `
+  attribute float bone; attribute vec4 vcol; attribute vec3 pivot; attribute vec3 ppivot;
+  attribute vec4 iA; attribute vec4 iB; attribute vec4 iC; attribute vec3 iCol; attribute vec3 iEye;
+  uniform float uTime;
+  varying vec3 vTint; varying float vGlow;
+  mat3 rX(float a){ float c=cos(a), s=sin(a); return mat3(1.,0.,0., 0.,c,s, 0.,-s,c); }
+  mat3 rY(float a){ float c=cos(a), s=sin(a); return mat3(c,0.,-s, 0.,1.,0., s,0.,c); }
+  mat3 rZ(float a){ float c=cos(a), s=sin(a); return mat3(c,s,0., -s,c,0., 0.,0.,1.); }
+  bool miss(float bit){ if (iC.z > 1.5) return false; return mod(floor(iC.x / bit), 2.) > 0.5; }
+  vec3 bodyAnim(vec3 p, inout vec3 nrm){
+    float ph = iA.w*6.2831, gait = iB.z, pose = iB.w - floor(iB.w/16.)*16., zomb = iC.z;
+    float side = (bone==2.||bone==4.||bone==7.||bone==9.) ? -1. : 1.;
+    // cascata: cada junta atrasa em rela\xE7\xE3o ao quadril (Besti\xE1rio 12.3)
+    float lag = bone==1.||bone==6.||bone==11. ? 0.55 : (bone>=7.&&bone<=8. ? 0.35 : (bone==2.||bone==3. ? 0.2 : 0.));
+    float sw = sin(ph - lag);
+    mat3 Rp = mat3(1.), Rc = mat3(1.);
+    bool isArm = bone==2.||bone==3., isFore = bone==7.||bone==8., isThigh = bone==4.||bone==5., isShin = bone==9.||bone==10.;
+    float legS = (bone==4.||bone==9.) ? 1. : -1.;
+    float walkS = sin(ph) * legS;
+    if (isThigh || isShin) Rp = rX(-walkS*0.5*gait);
+    if (isShin) Rc = rX(max(0., cos(ph + (legS>0.?0.:3.1416)))*0.85*gait);
+    if (pose==6.) { if (isThigh) Rp = rX(-1.1); if (isShin) Rc = rX(1.4); }
+    if (pose==5.) { if (isThigh) Rp = rX(-0.95 - walkS*0.3*gait); if (isShin) Rc = rX(1.9); } // agachado: joelho dobra, o p\xE9 fica no ch\xE3o
+    if (pose==7.) { if (isThigh) Rp = rX(-1.15); if (isShin) Rc = rX(2.3); } // ajoelhado comendo
+    if (pose==2. && isShin && fract(iA.w*3.)*legS > 0.3) Rc = rX(fract(iA.w*3.)*1.3); // corpo com um joelho dobrado
+    float armS = sin(ph) * (side>0. ? 1. : -1.);
+    if (isArm || isFore) {
+      // zumbi: bra\xE7os ca\xEDdos vagando; levanta (iC.z = 1 + 0,4 \xD7 alcance) quando percebe algu\xE9m ou vai agarrar
+      float raise = clamp((zomb - 1.)/0.4, 0., 1.);
+      float fwd = zomb > 0.5 && zomb < 1.5 ? mix(-0.12 + armS*0.3*gait + 0.05*sin(uTime*1.3+iA.w), -1.35 + armS*0.18 + 0.1*sin(uTime*2.+iA.w), raise) : armS*0.45*gait;
+      if (pose==3.) fwd = -1.55 + 0.35*sin(uTime*9.+iA.w);
+      if (pose==4.) fwd = -2.6;
+      if (pose==6.) fwd = -2.0;
+      if (pose==2.) fwd = (fract(iA.w*5.) > 0.5 && side > 0.) ? -2.8 : -0.35 + 0.3*sin(iA.w*5. + side);
+      if (pose==1.) fwd = -2.6 + 0.5*sin(ph)*side; // puxa o corpo com os bra\xE7os
+      if (pose==7.) fwd = -0.9 + 0.3*sin(uTime*6.+iA.w);
+      Rp = rX(fwd) * rZ(side*(pose==2. ? 0.5 + 0.3*sin(iA.w*3.) : 0.08));
+      // armado (iC.z = 2 + pitch codificado): as duas m\xE3os na arma, bra\xE7os seguem a mira
+      if (zomb > 1.5 && pose != 2.) { float aim = (zomb - 2.)*3. - 1.; Rp = rX(-1.42 + aim*0.85 + 0.02*sin(ph)*gait) * rZ(side < 0. ? 0.36 : -0.54); } // arma na m\xE3o direita de verdade (o osso 'D' fica em +x, que \xE9 a esquerda do boneco virado para +z); a esquerda encontra na empunhadura
+    }
+    if (isFore) Rc = rX(zomb > 1.5 && pose != 2. ? (side < 0. ? -0.12 : -0.04) : zomb > 0.5 ? mix(-0.3 - max(0., armS)*0.3*gait, -0.15, clamp((zomb - 1.)/0.4, 0., 1.)) : -0.35 - max(0., armS)*0.4*gait);
+    if (bone==11.) Rc = rX(pose==3.||pose==4. ? 0.35 + 0.2*sin(uTime*14.) : 0.05);
+    vec3 q = p; vec3 n = nrm;
+    if (isFore || isShin) { q = Rc*(q - pivot) + pivot; n = Rc*n; q = Rp*(q - ppivot) + ppivot; n = Rp*n; }
+    else if (isArm || isThigh || bone==11.) { q = Rp*(q - pivot) + pivot; n = Rp*n; q = Rc*(q - pivot) + pivot; n = Rc*n; }
+    // humano armado andando de lado: quadril e pernas giram para a dire\xE7\xE3o do passo (iC.x leva o \xE2ngulo)
+    if (zomb > 1.5 && (isThigh || isShin)) { mat3 hy = rY((iC.x - 0.5)*10.); q = hy*(q - vec3(0.,0.9,0.)) + vec3(0.,0.9,0.); n = hy*n; }
+    // partes faltando: colapsa no piv\xF4
+    if ((bone==1.||bone==6.||bone==11.) && miss(1.)) q = pivot;
+    if (bone==11. && miss(512.)) q = pivot;
+    if ((bone==2.||bone==7.) && miss(2.)) q = pivot; if ((bone==3.||bone==8.) && miss(4.)) q = pivot;
+    if ((bone==4.||bone==9.) && miss(8.)) q = pivot; if ((bone==5.||bone==10.) && miss(16.)) q = pivot;
+    if (bone==7. && miss(32.)) q = pivot; if (bone==8. && miss(64.)) q = pivot;
+    if (bone==9. && miss(128.)) q = pivot; if (bone==10. && miss(256.)) q = pivot;
+    // corpo: inclina\xE7\xE3o, balan\xE7o, agachar, rastejar, ca\xEDdo
+    bool upper = !(isThigh || isShin);
+    float zz = zomb > 0.5 && zomb < 1.5 ? 1. : 0.;
+    float lean = zz > 0.5 ? 0.12 + 0.3*min(1., gait) : 0.04*gait;
+    if (pose==3.) lean += 0.15;
+    if (pose==5.) lean += 0.25;
+    if (pose==7.) lean += 0.8;
+    if (upper) { q -= vec3(0.,0.95,0.); q = rX(lean)*q; n = rX(lean)*n; q += vec3(0.,0.95,0.); }
+    vec3 hp = rX(lean)*(pivot - vec3(0.,0.95,0.)) + vec3(0.,0.95,0.); // pesco\xE7o j\xE1 inclinado: a cabe\xE7a n\xE3o descola
+    if (bone==1.||bone==6.||bone==11.) { q -= hp; mat3 h = rY(sin(uTime*0.7+iA.w)*0.25*zz) * rZ(0.18*zz*sin(iA.w*3.)); q = h*q; n = h*n; q += hp; }
+    q.y += abs(sin(ph))*0.035*gait - (pose==5. ? 0.35 : pose==7. ? 0.5 : 0.);
+    if (pose==1. && (bone==1.||bone==6.||bone==11.)) { mat3 hc = rX(-1.25); q = hc*(q - hp) + hp; n = hc*n; } // rastejante levanta a cabe\xE7a
+    if (pose==1.) { mat3 c = rX(1.42); q = c*(q - vec3(0.,0.95,0.)) + vec3(0.,0.2,0.); n = c*n; }
+    if (pose==2.) { float flip = step(0.5, fract(iA.w*1.7)); float fk = clamp(gait, 0., 1.); fk = fk*fk*(3.-2.*fk); /* queda animada: passada leva o progresso */ mat3 c = rX((-1.5 + flip*3.0)*fk) * rZ(sin(iA.w*7.)*0.3*fk); /* de costas ou de bru\xE7os */ q = c*(q - vec3(0.,0.95,0.)) + mix(vec3(0.,0.95,0.), vec3(0.,0.16,-0.6 + flip*1.2), fk); n = c*n; }
+    nrm = n;
+    return q;
+  }
+`;
+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.)`);
+
+// src/instanced/body-geometry.ts
+import { TEAM_GAME } from "@adatechnology/game-characters";
+var negativeFirst = (first, second) => first[0] <= second[0] ? [first, second] : [second, first];
+var jointsOf = (body) => {
+  const at = (id) => body.joints[id];
+  const [shoulderE, shoulderD] = negativeFirst(at("shoulderL"), at("shoulderR"));
+  const [elbowE, elbowD] = negativeFirst(at("elbowL"), at("elbowR"));
+  const [thighE, thighD] = negativeFirst(at("hipL"), at("hipR"));
+  const [kneeE, kneeD] = negativeFirst(at("kneeL"), at("kneeR"));
+  return { hip: at("hip"), neck: at("neck"), shoulderE, shoulderD, elbowE, elbowD, thighE, thighD, kneeE, kneeD };
+};
+var GAME_UPPER_ARM = 0.31;
+var GAME_THIGH = 0.42;
+var scaleOf = (length, gameLength) => Math.abs(length - gameLength) < 1e-9 ? 1 : length / gameLength;
+var distance = (from, to) => Math.abs(from[1] - to[1]);
+var tagGeometry = (geometry, bone, pivot, material, parent = [0, 0, 0], three) => {
+  const source = geometry.index ? geometry.toNonIndexed() : geometry;
+  const count = source.attributes.position.count;
+  source.setAttribute("bone", new three.Float32BufferAttribute(new Float32Array(count).fill(bone), 1));
+  const colors = new Float32Array(count * 4);
+  for (let index = 0; index < count; index++) colors[index * 4 + 3] = material;
+  source.setAttribute("vcol", new three.Float32BufferAttribute(colors, 4));
+  const pivots = new Float32Array(count * 3);
+  const parents = new Float32Array(count * 3);
+  for (let index = 0; index < count; index++) {
+    pivots.set(pivot, index * 3);
+    parents.set(parent, index * 3);
+  }
+  source.setAttribute("pivot", new three.Float32BufferAttribute(pivots, 3));
+  source.setAttribute("ppivot", new three.Float32BufferAttribute(parents, 3));
+  source.deleteAttribute("uv");
+  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);
+  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) {
+      const part = geometry.attributes[name].array;
+      array.set(part, offset);
+      offset += part.length;
+    }
+    merged.setAttribute(name, new three.BufferAttribute(array, size));
+  }
+  merged.computeBoundingSphere();
+  return merged;
+};
+var buildInstancedBody = (three, { segments, body = TEAM_GAME }) => {
+  const joints = jointsOf(body);
+  const parts = [];
+  const half = Math.max(4, segments >> 1);
+  const { Vector2, LatheGeometry, CylinderGeometry, SphereGeometry } = three;
+  const limb = (radiusA, radiusB, length, radial) => {
+    const geometry = new CylinderGeometry(radiusB, radiusA, length, radial, 1, false);
+    geometry.translate(0, -length / 2, 0);
+    return geometry;
+  };
+  const ball = (radius, radial) => new SphereGeometry(radius, radial, Math.max(3, Math.round(radial * 0.75)));
+  const tag = (geometry, bone, pivot, material, parent) => void parts.push(tagGeometry(geometry, bone, pivot, material, parent, three));
+  const profile = (points) => points.map(([radius, height]) => new Vector2(radius, height));
+  const hip = joints.hip;
+  const neck = joints.neck;
+  const torso = new LatheGeometry(profile([[0, 0.86], [0.17, 0.88], [0.165, 0.98], [0.15, 1.1], [0.175, 1.26], [0.19, 1.38], [0.14, 1.47], [0.06, 1.52], [0, 1.53]]), segments);
+  torso.scale(1.12, 1, 0.64);
+  tag(torso, 0, hip, 1);
+  const pelvis = new LatheGeometry(profile([[0, 0.78], [0.15, 0.8], [0.172, 0.88], [0.165, 0.97], [0, 0.98]]), segments);
+  pelvis.scale(1.12, 1, 0.7);
+  tag(pelvis, 0, hip, 2);
+  const neckPart = limb(0.055, 0.05, 0.12, half);
+  neckPart.translate(0, 1.6, 0);
+  tag(neckPart, 1, neck, 0);
+  const head = ball(0.13, segments);
+  head.scale(0.96, 1.1, 1.02);
+  head.translate(0, 1.67, 0.01);
+  tag(head, 1, neck, 0);
+  const hair = new SphereGeometry(0.137, segments, Math.max(3, segments >> 1), 0, Math.PI * 2, 0, Math.PI * 0.42);
+  hair.scale(0.98, 1.1, 1.04);
+  hair.rotateX(-0.35);
+  hair.translate(0, 1.68, -0.01);
+  tag(hair, 1, neck, 4);
+  const jaw = ball(0.085, half);
+  jaw.scale(1, 0.55, 1);
+  jaw.translate(0, 1.58, 0.05);
+  tag(jaw, 11, neck, 0);
+  for (const side of [-1, 1]) {
+    const eye = ball(0.02, 4);
+    eye.scale(1.2, 0.7, 0.5);
+    eye.translate(side * 0.045, 1.69, 0.125);
+    tag(eye, 6, neck, 3);
+  }
+  const armLengthScale = scaleOf(distance(joints.shoulderE, joints.elbowE), GAME_UPPER_ARM);
+  const legLengthScale = scaleOf(distance(joints.thighE, joints.kneeE), GAME_THIGH);
+  const arms = [[-1, 2, 7, joints.shoulderE, joints.elbowE], [1, 3, 8, joints.shoulderD, joints.elbowD]];
+  for (const [, bone, forearmBone, shoulder, elbow] of arms) {
+    const upper = limb(0.074, 0.06, 0.31 * armLengthScale, half);
+    upper.translate(shoulder[0], shoulder[1], 0);
+    tag(upper, bone, shoulder, 1);
+    const joint = ball(0.07, half);
+    joint.translate(shoulder[0], shoulder[1], 0);
+    tag(joint, bone, shoulder, 1);
+    const forearm = limb(0.06, 0.046, 0.29 * armLengthScale, half);
+    forearm.translate(elbow[0], elbow[1], 0);
+    tag(forearm, forearmBone, elbow, 0, shoulder);
+    const hand = ball(0.05, half);
+    hand.scale(0.8, 1.2, 0.6);
+    hand.translate(elbow[0], elbow[1] - 0.33 * armLengthScale, 0);
+    tag(hand, forearmBone, elbow, 0, shoulder);
+  }
+  const legs = [[-1, 4, 9, joints.thighE, joints.kneeE], [1, 5, 10, joints.thighD, joints.kneeD]];
+  for (const [, bone, shinBone, hipJoint, knee] of legs) {
+    const thigh = limb(0.105, 0.078, 0.42 * legLengthScale, half);
+    thigh.translate(hipJoint[0], hipJoint[1], 0);
+    tag(thigh, bone, hipJoint, 2);
+    const kneeJoint = ball(0.075, half);
+    kneeJoint.translate(knee[0], knee[1], 0);
+    tag(kneeJoint, shinBone, knee, 2, hipJoint);
+    const shin = limb(0.077, 0.056, knee[1] - 0.1, half);
+    shin.translate(knee[0], knee[1], 0);
+    tag(shin, shinBone, knee, 2, hipJoint);
+    const foot = ball(0.06, half);
+    foot.scale(0.95, 0.72, 1.85);
+    foot.translate(knee[0], 0.06, 0.05);
+    tag(foot, shinBone, knee, 5, hipJoint);
+  }
+  return mergeBody(parts, three);
+};
+
+// src/instanced/body-material.ts
+var createBodyMaterial = (three, { depth = false, time, chunk }) => {
+  const bodyChunk = createBodyChunk(chunk);
+  const material = depth ? new three.MeshDepthMaterial({ depthPacking: three.RGBADepthPacking }) : new three.MeshLambertMaterial({ color: 16777215 });
+  material.onBeforeCompile = (shader) => {
+    shader.uniforms.uTime = time;
+    shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\n" + bodyChunk).replace(
+      "#include <begin_vertex>",
+      `
+        vec3 _n = normal;
+        vec3 transformed = bodyAnim(position, _n);
+        transformed *= vec3(iB.y, iB.x, iB.y);
+        transformed = rY(iA.z)*transformed + vec3(iA.x, floor(iB.w/16.)/1000. - 2., iA.y);
+        // pele: tons brasileiros variados, vai para cinza esverdeado (0x6f7a5c) com a infec\xE7\xE3o
+        vec3 skin = mix(vec3(0.93,0.74,0.6), vec3(0.42,0.27,0.18), iC.w);
+        skin = mix(skin, vec3(0.435,0.478,0.36), iC.y);
+        vec3 pants = iCol*0.45 + vec3(0.08,0.09,0.12);
+        float mat = vcol.w;
+        vTint = mat==6. ? vcol.rgb : mat==0. ? skin : mat==1. ? (dot(vcol.rgb, vcol.rgb) > 0. ? mix(iCol, vcol.rgb, 0.3) : iCol) : mat==2. ? pants : mat==4. ? mix(vec3(0.12,0.09,0.07), vec3(0.5), iC.y*0.4) : mat==5. ? vec3(0.13) : vec3(0.9);
+        vGlow = mat==3. && dot(iEye, iEye) > 0.01 ? 1. : 0.;
+        if (mat==3. && vGlow < 0.5) vTint = vec3(0.08);
+        `
+    ).replace("#include <beginnormal_vertex>", "#include <beginnormal_vertex>\n { vec3 _nn = objectNormal; bodyAnim(position, _nn); objectNormal = rY(iA.z)*_nn; }");
+    if (!depth) {
+      shader.fragmentShader = shader.fragmentShader.replace("#include <common>", "#include <common>\nvarying vec3 vTint; varying float vGlow;").replace("#include <color_fragment>", "#include <color_fragment>\n diffuseColor.rgb = vTint;").replace("#include <dithering_fragment>", "#include <dithering_fragment>\n if (vGlow > 0.5) gl_FragColor = vec4(vTint*0.0 + gl_FragColor.rgb*0.0 + EYE*2.4, 1.);");
+      shader.vertexShader = shader.vertexShader.replace("varying vec3 vTint;", "varying vec3 vTint; varying vec3 vEyeC;").replace("vGlow = mat==3.", "vEyeC = iEye; vGlow = mat==3.");
+      shader.fragmentShader = shader.fragmentShader.replace("varying vec3 vTint;", "varying vec3 vTint; varying vec3 vEyeC;").replace("EYE", "vEyeC");
+    }
+  };
+  return material;
+};
+
+// src/instanced/body-batch.ts
+var ATTRIBUTES = [["iA", 4], ["iB", 4], ["iC", 4], ["iCol", 3], ["iEye", 3]];
+var MIN_HEIGHT = -2;
+var MAX_HEIGHT = 8;
+var HEIGHT_STEPS = 1e3;
+var POSE_SLOTS = 16;
+var createBodyBatch = (three, geometry, options) => {
+  const { max, castShadow = true, time } = options;
+  const copy = geometry.clone();
+  const attributes = {};
+  for (const [name, size] of ATTRIBUTES) {
+    const attribute = new three.InstancedBufferAttribute(new Float32Array(max * size), size);
+    attribute.setUsage(three.DynamicDrawUsage);
+    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;
+  let count = 0;
+  return {
+    mesh,
+    max,
+    get count() {
+      return count;
+    },
+    begin() {
+      count = 0;
+    },
+    push({ a, b, c, color, eye, y = 0 }) {
+      if (count >= max) return;
+      const index = count++;
+      const fourOffset = index * 4;
+      const threeOffset = index * 3;
+      attributes.iA.array.set(a, fourOffset);
+      attributes.iB.array.set([b[0], b[1], b[2], b[3] + POSE_SLOTS * Math.round((Math.min(MAX_HEIGHT, Math.max(MIN_HEIGHT, y)) - MIN_HEIGHT) * HEIGHT_STEPS)], fourOffset);
+      attributes.iC.array.set(c, fourOffset);
+      attributes.iCol.array.set([color.r, color.g, color.b], threeOffset);
+      attributes.iEye.array.set(eye ? [eye.r, eye.g, eye.b] : [0, 0, 0], threeOffset);
+    },
+    end() {
+      mesh.count = count;
+      for (const attribute of Object.values(attributes)) {
+        attribute.clearUpdateRanges();
+        attribute.addUpdateRange(0, count * attribute.itemSize);
+        attribute.needsUpdate = true;
+      }
+    }
+  };
+};
+
+// src/instanced/lod.ts
+var LOD_SEGMENTS = [16, 10, 5];
+var LOD_BAKE = [1, 0.5, 0.28];
+var LOD_DISTANCES = [18, 55];
+var LOD_BATCH_CAPACITY = [160, 700, 2600];
+var LOD_CASTS_SHADOW = [true, true, false];
+var lodAt = (distance2, distances = LOD_DISTANCES) => distance2 < distances[0] ? 0 : distance2 < distances[1] ? 1 : 2;
+
+// src/instanced/bake.ts
+var BAKE_NEUTRAL_POSE = { lean: 0, armL: 0, armR: 0, elbL: 0, elbR: 0, legL: 0, legR: 0, kneeL: 0, kneeR: 0, headX: 0, headZ: 0, drop: 0, armOut: 0, neck: 0, headFwd: 0 };
+var BLOOD_LIFT_NEAR = 6e-3;
+var BLOOD_LIFT_FAR = 0.012;
+var FAR_LOD = 0.6;
+var EYE_SCALE = 2.2;
+var EYE_DEPTH_SCALE = 1.4;
+var bakeBody = (three, builders, spec, lod) => {
+  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;
+  rig.fig.position.y = 0;
+  rig.upper.rotation.set(0, 0, 0);
+  rig.headG.rotation.set(0, 0, 0);
+  for (const arm of rig.arms) {
+    arm.g.rotation.set(0, 0, 0);
+    arm.el.rotation.set(0, 0, 0);
+  }
+  for (const leg of rig.legs) {
+    leg.g.rotation.set(0, 0, 0);
+    leg.kn.rotation.set(0, 0, 0);
+  }
+  root.updateMatrixWorld(true);
+  const worldPosition2 = (object) => object.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) {
+    const shoulder = worldPosition2(arm.g);
+    bones.set(arm.g, [arm.s < 0 ? 2 : 3, shoulder, [0, 0, 0]]);
+    bones.set(arm.el, [arm.s < 0 ? 7 : 8, worldPosition2(arm.el), shoulder]);
+  }
+  for (const leg of rig.legs) {
+    const hip = worldPosition2(leg.g);
+    bones.set(leg.g, [leg.s < 0 ? 4 : 5, hip, [0, 0, 0]]);
+    bones.set(leg.kn, [leg.s < 0 ? 9 : 10, worldPosition2(leg.kn), hip]);
+  }
+  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;
+    let tag = trunk;
+    for (let ancestor = object.parent; ancestor; ancestor = ancestor.parent) {
+      const found = bones.get(ancestor);
+      if (found) {
+        tag = found;
+        break;
+      }
+    }
+    let [bone, pivot, parentPivot] = tag;
+    if (object.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 materialId = isEye2 ? 3 : material === topMaterial ? 1 : 6;
+    if (isEye2 && bone === 1) bone = 6;
+    const geometry = mesh.geometry.clone();
+    geometry.applyMatrix4(mesh.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];
+    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) };
+};
+var liftAlongNormals = (geometry, lift) => {
+  const positions = geometry.attributes.position;
+  const normals = geometry.attributes.normal;
+  for (let index = 0; index < positions.count; index++) positions.setXYZ(index, positions.getX(index) + normals.getX(index) * lift, positions.getY(index) + normals.getY(index) * lift, positions.getZ(index) + normals.getZ(index) * lift);
+};
+var enlargeEye = (three, geometry, factor) => {
+  geometry.computeBoundingBox();
+  const center = geometry.boundingBox.getCenter(new three.Vector3());
+  geometry.translate(-center.x, -center.y, -center.z);
+  geometry.scale(EYE_SCALE * factor, EYE_SCALE * factor, EYE_DEPTH_SCALE * factor);
+  geometry.translate(center.x, center.y, center.z);
+};
+var mergeBaked = (three, parts) => {
+  let vertexTotal = 0;
+  let indexTotal = 0;
+  for (const part of parts) {
+    vertexTotal += part.g.attributes.position.count;
+    indexTotal += part.g.index ? part.g.index.count : part.g.attributes.position.count;
+  }
+  const position = new Float32Array(vertexTotal * 3);
+  const normal = new Float32Array(vertexTotal * 3);
+  const color = new Float32Array(vertexTotal * 4);
+  const bone = new Float32Array(vertexTotal);
+  const pivot = new Float32Array(vertexTotal * 3);
+  const parentPivot = new Float32Array(vertexTotal * 3);
+  const index = vertexTotal > 65535 ? new Uint32Array(indexTotal) : new Uint16Array(indexTotal);
+  let vertexOffset = 0;
+  let indexOffset = 0;
+  for (const part of parts) {
+    const count = part.g.attributes.position.count;
+    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);
+      bone[vertexOffset + vertex] = part.bone;
+      pivot.set(part.pv, (vertexOffset + vertex) * 3);
+      parentPivot.set(part.pp, (vertexOffset + vertex) * 3);
+    }
+    if (part.g.index) {
+      const source = part.g.index.array;
+      for (let item = 0; item < source.length; item++) index[indexOffset++] = source[item] + vertexOffset;
+    } else for (let vertex = 0; vertex < count; vertex++) index[indexOffset++] = vertexOffset + vertex;
+    vertexOffset += count;
+    part.g.dispose();
+  }
+  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("bone", new three.BufferAttribute(bone, 1));
+  out.setAttribute("pivot", new three.BufferAttribute(pivot, 3));
+  out.setAttribute("ppivot", new three.BufferAttribute(parentPivot, 3));
+  out.setIndex(new three.BufferAttribute(index, 1));
+  out.computeBoundingSphere();
+  return out;
+};
+
+// src/instanced/variants.ts
+import { variantCountFor, variantDecay, variantSeed } from "@adatechnology/game-characters";
+var bakeVariants = (three, builders, types) => {
+  const variants = [];
+  const byType = /* @__PURE__ */ new Map();
+  for (const type of types) {
+    const indexes = [];
+    for (let variant = 0; variant < variantCountFor(type.id); variant++) {
+      const decay = variantDecay(variant);
+      const seed = variantSeed(type.index, variant);
+      const baked = LOD_BAKE.map((lod) => bakeBody(three, builders, { type: type.name, decay, seed }, lod));
+      indexes.push(variants.length);
+      variants.push({ typeId: type.id, variant, seed, decay, s: baked[0].s, bulk: baked[0].bulk, verts: baked.map((body) => body.verts), geometries: baked.map((body) => body.geo) });
+    }
+    byType.set(type.id, indexes);
+  }
+  return { variants, byType };
+};
+var createVariantBatches = (three, variant, time) => variant.geometries.map((geometry, level) => createBodyBatch(three, geometry, { max: LOD_BATCH_CAPACITY[level], castShadow: LOD_CASTS_SHADOW[level], time }));
+
+// src/instanced/flying-limbs.ts
+var GRAVITY = 9.8;
+var FLOOR_Y = 0.07;
+var BOUNCE = -0.3;
+var FRICTION = 0.6;
+var SPIN_DAMPING = 0.5;
+var REST_SPEED = 0.4;
+var LEG_COLOR = 2896704;
+var createFlyingLimbs = (three, { max = 40, random, effects = {} }) => {
+  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 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();
+  return {
+    mesh,
+    limbs,
+    launch({ x, z, kind, color: sleeve, blood }) {
+      const isLeg = kind === "leg";
+      const limb = limbs.length < max ? {} : limbs.shift();
+      Object.assign(limb, {
+        x,
+        y: isLeg ? 0.5 : 1.2,
+        z,
+        vx: (random() - 0.5) * 3,
+        vy: 2 + random() * 2,
+        vz: (random() - 0.5) * 3,
+        rx: random() * 6,
+        rz: random() * 6,
+        w: (random() - 0.5) * 10,
+        t: 0,
+        rest: false,
+        len: isLeg ? 1.3 : 1,
+        col: isLeg ? LEG_COLOR : sleeve
+      });
+      limbs.push(limb);
+      limb.cor = blood.color;
+      limb.seco = blood.dried;
+      limb.splat = !blood.bleeds;
+      effects.onLaunch?.(limb, kind);
+      return limb;
+    },
+    update(dt) {
+      limbs.forEach((limb, index) => {
+        if (!limb.rest) {
+          limb.t += dt;
+          limb.vy -= GRAVITY * dt;
+          limb.x += limb.vx * dt;
+          limb.y += limb.vy * dt;
+          limb.z += limb.vz * dt;
+          limb.rx += limb.w * dt;
+          if (limb.y < FLOOR_Y) {
+            limb.y = FLOOR_Y;
+            limb.vy *= BOUNCE;
+            limb.vx *= FRICTION;
+            limb.vz *= FRICTION;
+            limb.w *= SPIN_DAMPING;
+            if (!limb.splat) {
+              limb.splat = true;
+              effects.onSplat?.({ x: limb.x, z: limb.z, radius: 0.2 + random() * 0.2, rotation: random() * 6.28, color: limb.cor, dried: limb.seco });
+            }
+            if (Math.abs(limb.vy) < REST_SPEED) {
+              limb.rest = true;
+              limb.rx = Math.PI / 2;
+            }
+          }
+        }
+        matrix.compose(position.set(limb.x, limb.y, limb.z), quaternion.setFromEuler(euler.set(limb.rx, limb.rz, 0)), scale.set(1, limb.len, 1));
+        mesh.setMatrixAt(index, matrix);
+        mesh.setColorAt(index, color.set(limb.col));
+      });
+      mesh.count = limbs.length;
+      mesh.instanceMatrix.needsUpdate = true;
+      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+    }
+  };
+};
+
+// src/rich/animator.ts
+import { CASCADE, animateProfile, lerpPose, stepCascade } from "@adatechnology/game-characters";
+var rigOf = (root) => root.userData.rig;
+var apply = (rig, sample) => {
+  if (sample.hipY !== void 0) rig.fig.position.y = sample.hipY;
+  if (sample.upper.x !== void 0) rig.upper.rotation.x = sample.upper.x;
+  if (sample.upper.y !== void 0) rig.upper.rotation.y = sample.upper.y;
+  if (sample.upper.z !== void 0) rig.upper.rotation.z = sample.upper.z;
+  if (sample.head.x !== void 0) rig.headG.rotation.x = sample.head.x;
+  if (sample.head.y !== void 0) rig.headG.rotation.y = sample.head.y;
+  rig.arms.forEach((arm, index) => {
+    const target = sample.arms[index];
+    if (target?.shoulder !== void 0) arm.g.rotation.x = target.shoulder;
+    if (target?.elbow !== void 0) arm.el.rotation.x = target.elbow;
+  });
+  rig.legs.forEach((leg, index) => {
+    const target = sample.legs[index];
+    if (target?.hip !== void 0) leg.g.rotation.x = target.hip;
+    if (target?.knee !== void 0) leg.kn.rotation.x = target.knee;
+  });
+};
+var createRigAnimator = (options = {}) => {
+  const gaits = options.gaits ?? {};
+  const rates = options.cascade ?? CASCADE;
+  const restOf = (rig) => ({
+    hipY: rig.dropBase,
+    lean: rig.leanBase,
+    headX: rig.hxBase,
+    arms: [
+      { shoulder: rig.arms[0].base, elbow: rig.arms[0].eBase },
+      { shoulder: rig.arms[1].base, elbow: rig.arms[1].eBase }
+    ],
+    legs: [
+      { hip: rig.legs[0].base, knee: rig.legs[0].kBase, ...rig.legs[0].lost ? { lost: true } : {} },
+      { hip: rig.legs[1].base, knee: rig.legs[1].kBase, ...rig.legs[1].lost ? { lost: true } : {} }
+    ]
+  });
+  const animate0 = (root, time, stride) => {
+    const rig = rigOf(root);
+    if (!rig) return void 0;
+    const profile = gaits[rig.type];
+    const sample = animateProfile({ ...profile ? { profile } : {}, rest: restOf(rig), time, phase: rig.ph, ...stride ? { stride } : {} });
+    apply(rig, sample);
+    return sample;
+  };
+  return {
+    restOf,
+    animate0,
+    animate(root, time, stride) {
+      const rig = rigOf(root);
+      if (!rig) return;
+      animate0(root, time, stride);
+      rig.dangles.forEach((arm) => {
+        arm.el.rotation.x = -(arm.g.rotation.x + rig.upper.rotation.x) + Math.sin(time * 3.2 + rig.ph) * 0.3;
+      });
+      rig.flaps.forEach((flap, index) => {
+        var _a;
+        const base = (_a = flap.userData).rx0 ?? (_a.rx0 = flap.rotation.x);
+        flap.rotation.x = base + Math.sin(time * 4 + index + rig.ph) * 0.18;
+      });
+    },
+    cascade(rig, dt) {
+      if (!rig.cur) {
+        const joints = [
+          [rig.fig.position, "y", "hip"],
+          [rig.upper.rotation, "x", "spine"],
+          [rig.upper.rotation, "y", "spine"],
+          [rig.upper.rotation, "z", "spine"],
+          [rig.headG.rotation, "x", "head"],
+          [rig.headG.rotation, "y", "head"],
+          [rig.headG.rotation, "z", "head"]
+        ];
+        rig.arms.forEach((arm) => joints.push([arm.g.rotation, "x", "shoulder"], [arm.el.rotation, "x", "elbow"]));
+        rig.legs.forEach((leg) => joints.push([leg.g.rotation, "x", "leg"], [leg.kn.rotation, "x", "knee"]));
+        rig.jl = joints;
+        rig.cur = new Map(joints.map((joint) => [joint, joint[0][joint[1]]]));
+        return;
+      }
+      for (const joint of rig.jl) {
+        const target = joint[0][joint[1]];
+        const value = stepCascade(rig.cur.get(joint), target, dt, joint[2], rates);
+        rig.cur.set(joint, value);
+        joint[0][joint[1]] = value;
+      }
+    },
+    setPose(rig, q) {
+      if (q.lean != null) rig.upper.rotation.x = q.lean;
+      if (q.twist != null) rig.upper.rotation.y = q.twist;
+      if (q.side != null) rig.upper.rotation.z = q.side;
+      if (q.drop != null) rig.fig.position.y = rig.dropBase + q.drop;
+      if (q.headX != null) rig.headG.rotation.x = q.headX;
+      if (q.headY != null) rig.headG.rotation.y = q.headY;
+      if (q.headZ != null) rig.headG.rotation.z = q.headZ;
+      const [armR, armL] = rig.arms;
+      if (q.armR != null) armR.g.rotation.x = q.armR;
+      if (q.armL != null) armL.g.rotation.x = q.armL;
+      if (q.elbR != null) armR.el.rotation.x = q.elbR;
+      if (q.elbL != null) armL.el.rotation.x = q.elbL;
+      if (q.armRz != null) armR.g.rotation.z = q.armRz;
+      if (q.armLz != null) armL.g.rotation.z = q.armLz;
+      const [legL, legR] = rig.legs;
+      if (q.legL != null) legL.g.rotation.x = q.legL;
+      if (q.legR != null) legR.g.rotation.x = q.legR;
+      if (q.kneeL != null) legL.kn.rotation.x = q.kneeL;
+      if (q.kneeR != null) legR.kn.rotation.x = q.kneeR;
+    },
+    lerpPose
+  };
+};
+
+// src/rich/best-builder.ts
+import { createBloodStream, createRng, drawAppearance } from "@adatechnology/game-characters";
+var createBestBuilder = (THREE, { types, random = Math.random }) => {
+  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);
+  const CYL = (a, b, h, rs = 8, ...x) => new THREE.CylinderGeometry(a, b, h, Math.max(4, Math.round(rs * LK)), ...x);
+  const TOR = (r, t, rs = 8, ts = 6, ...x) => new THREE.TorusGeometry(r, t, Math.max(3, Math.round(rs * LK)), Math.max(4, Math.round(ts * LK)), ...x);
+  const BCARDS = options.types.map((c) => ({ n: c.name, eye: "#" + c.eye.toString(16).padStart(6, "0") }));
+  const glowTex = null;
+  const rng = createRng;
+  const BLOB = (() => {
+    const sh = new THREE.Shape(), N = 24, R = rng(123), a = [R() * 6, R() * 6, R() * 6];
+    for (let i = 0; i < N; i++) {
+      const t = i / N * 6.2832, r = 1 + 0.14 * Math.sin(3 * t + a[0]) + 0.08 * Math.sin(5 * t + a[1]) + 0.05 * Math.sin(9 * t + a[2]) + (R() - 0.5) * 0.1 + (i % 5 === 0 ? R() * 0.22 : 0);
+      i ? sh.lineTo(Math.cos(t) * r, Math.sin(t) * r) : sh.moveTo(Math.cos(t) * r, Math.sin(t) * r);
+    }
+    sh.closePath();
+    const g = new THREE.ShapeGeometry(sh);
+    g.rotateX(-Math.PI / 2);
+    return g;
+  })();
+  const SKIN = [13482920, 9740420, 8090698, 9206878];
+  const BLOOD = [10361618, 7214096, 4860440, 1840658];
+  const CLOTH = [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162];
+  const PANTS = 2896704, GRAY = 4868678, RED = 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 limbGeo = (w, len) => {
+    const g = geoBox(w, len, w);
+    g.translate(0, -len / 2, 0);
+    return g;
+  };
+  const basic = (c, o) => new THREE.MeshBasicMaterial(Object.assign({ color: c }, o || {}));
+  const glow = (c, s, op) => {
+    const sp = new THREE.Sprite(new THREE.SpriteMaterial({ map: glowTex, color: c, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, opacity: op ?? 0.9 }));
+    sp.scale.setScalar(s);
+    return sp;
+  };
+  const PI = Math.PI;
+  let SEG = 16;
+  const TORSO_P = [[0.18, 0.86], [0.205, 0.95], [0.195, 1.03], [0.19, 1.12], [0.225, 1.27], [0.26, 1.4], [0.265, 1.47], [0.21, 1.55], [0.085, 1.6]];
+  const TORSO_F = [[0.17, 0.86], [0.215, 0.95], [0.2, 1.02], [0.165, 1.1], [0.2, 1.25], [0.245, 1.38], [0.25, 1.46], [0.2, 1.54], [0.085, 1.6]];
+  const torsoGeo = (sx, sz, fem) => {
+    const g = new THREE.LatheGeometry(new THREE.SplineCurve((fem ? TORSO_F : TORSO_P).map((p) => new THREE.Vector2(p[0], p[1]))).getPoints(Math.max(8, Math.round(30 * LK))), Math.max(6, Math.round(24 * LK)));
+    g.scale(1.12 * (sx || 1), 1, 0.64 * (sz || 1));
+    return g;
+  };
+  const cylDown = (r1, r2, len) => CYL(r1, r2, len, SEG, 1).translate(0, -len / 2, 0);
+  const capGeo = (r, len) => SPH(r, 20, 10, 0, PI * 2, 0, len || PI / 2);
+  const BASE = { s: 1, bulk: 1, lean: 0.15, armL: -1.15, armR: -0.85, elbL: -0.25, elbR: -0.4, legL: -0.15, legR: 0.25, kneeL: 0.15, kneeR: 0.35, headX: 0.08, headZ: 0.22, drop: -0.02, neck: 0 };
+  const TYPES = {
+    Lento: {},
+    Corredor: { s: 0.97, bulk: 0.88, lean: 0.75, armL: -1.35, armR: -1.05, elbL: -0.08, elbR: -0.12, legL: -0.75, legR: 0.55, kneeL: 0.45, kneeR: 1.25, headX: -0.55, headZ: 0, drop: -0.1 },
+    Brutamonte: { s: 1.42, bulk: 1.32, lean: 0.3, armL: -0.4, armR: -0.25, elbL: -0.35, elbR: -0.25, legL: -0.12, legR: 0.12, kneeL: 0.12, kneeR: 0.12, headX: -0.2, headZ: 0, neck: -0.07, drop: -0.02 },
+    Rastejante: { noLegs: true, lean: 1.42, drop: -0.74, armL: -2.75, armR: -2.35, elbL: -0.5, elbR: -0.3, headX: -1.35, headZ: 0.1 },
+    Gritador: { bulk: 0.84, lean: -0.18, armL: 0.35, armR: 0.45, elbL: -0.6, elbR: -0.5, legL: -0.05, legR: 0.1, kneeL: 0.05, kneeR: 0.1, headX: -0.65, headZ: 0, neck: 0.12, mouth: true, drop: 0 },
+    Inchado: { bloat: true, s: 1.03, bulk: 1.15, lean: 0, armL: -0.55, armR: -0.45, elbL: -0.3, elbR: -0.3, legL: 0, legR: 0, kneeL: 0.05, kneeR: 0.05, headZ: 0.1, drop: 0, armOut: 0.45 },
+    Espreitador: { bulk: 0.86, lean: 1.2, drop: -0.36, legL: -1.05, legR: -0.85, kneeL: 1.75, kneeR: 1.6, armL: -1.1, armR: -1.35, elbL: -0.05, elbR: -0.1, headX: -1.05, headZ: 0, dim: true },
+    Farejador: { lean: 0.45, headX: -0.75, headFwd: 0.07, armL: -0.35, armR: -0.2, elbL: -0.45, elbR: -0.4, legL: -0.25, legR: 0.2, kneeL: 0.3, kneeR: 0.45, headZ: 0.12, nose: true, drop: -0.04 },
+    Saltador: { bulk: 0.86, lean: 0.65, drop: -0.36, legL: -1.15, legR: -0.9, kneeL: 1.9, kneeR: 1.7, armL: 0.7, armR: 0.5, elbL: -0.6, elbR: -0.5, headX: -0.7, headZ: 0 },
+    Cego: { lean: 0.05, armL: -0.6, armR: -0.35, elbL: -0.5, elbR: -0.7, legL: -0.08, legR: 0.1, kneeL: 0.08, kneeR: 0.12, headX: -0.25, headZ: 0.45, blind: true, mouth: true },
+    Afogado: { bulk: 1.08, lean: 0.22, armL: -0.25, armR: -0.15, elbL: -0.1, elbR: -0.15, headX: 0.35, headZ: 0.3, wet: true },
+    Carbonizado: { lean: 0.2, armL: -1, armR: -0.6, elbL: -0.6, elbR: -0.9, headX: 0.05, headZ: -0.15, char: true },
+    Devorador: { lean: 0.95, drop: -0.42, legL: -1.45, legR: -1.3, kneeL: 2.3, kneeR: 2.2, armL: -1.55, armR: -1.35, elbL: -0.7, elbR: -0.9, headX: 0.25, headZ: 0, gore: true }
+  };
+  const OUTFITS = {
+    policial: { cloth: 2042436, pants: 1711916, vest: 1382170, hat: "cap", hatC: 1778232 },
+    militar: { cloth: 4938290, pants: 4147755, vest: 3752234, hat: "helmet", hatC: 4871474 },
+    bombeiro: { cloth: 11044682, pants: 9401152, stripes: 14275146, hat: "fire", hatC: 10691612 },
+    motociclista: { cloth: 1579034, pants: 2237739, hat: "moto", hatC: 1118740 },
+    operario: { cloth: 7040888, pants: 2896704, vest: 14708778, hat: "hardhat", hatC: 15122746 },
+    medico: { cloth: 8368328, pants: 7314096, mask: true },
+    cacador: { cloth: 5917230, pants: 4866096, hat: "cap", hatC: 14708778 }
+  };
+  function build(spec) {
+    const ti = Math.max(0, BCARDS.findIndex((x) => x.n === spec.type)), z = BCARDS[ti];
+    const P = Object.assign({}, BASE, TYPES[spec.type] || {}, spec.pose || {}), d = spec.decay ?? 0, life = spec.life ?? 1, cut = spec.cut || {};
+    P.s *= spec.h ?? 1;
+    P.bulk *= spec.bulk ?? 1;
+    if (life === 0) {
+      P.s *= 0.94;
+      P.bulk *= 0.9;
+    }
+    if (life === 2) {
+      P.lean += 0.28;
+      P.headX -= 0.18;
+      P.armL *= 0.8;
+      P.armR *= 0.8;
+      P.kneeL += 0.1;
+      P.kneeR += 0.1;
+    }
+    if (spec.lying) Object.assign(P, { armL: 0.2, armR: -0.15, elbL: -0.15, elbR: -0.3, legL: -0.05, legR: 0.12, kneeL: 0.05, kneeR: 0.2, lean: 0, drop: 0, headX: 0, headZ: 0.35 });
+    const op = spec.opacity ?? 1;
+    const cache = {};
+    const M = (c) => {
+      const k = new THREE.Color(c).getHex();
+      if (cache[k]) return cache[k];
+      const m = new THREE.MeshLambertMaterial({ color: c });
+      if (op < 1) {
+        m.transparent = true;
+        m.opacity = op;
+      }
+      return cache[k] = m;
+    };
+    const O = spec.outfit ? OUTFITS[spec.outfit] || {} : {};
+    const BR = createBloodStream(spec.seed ?? 7);
+    const uni = !!spec.uniform;
+    const { traits: T, random: VR } = drawAppearance({
+      seed: spec.seed ?? options.random() * 1e9 | 0,
+      outfit: { cloth: O.cloth, pants: O.pants, hat: O.hat },
+      uniform: uni,
+      typeIndex: ti,
+      clothIndex: spec.clothIdx,
+      female: spec.fem,
+      allowFemale: spec.type !== "Brutamonte",
+      tone: spec.tone,
+      hairStyle: spec.hs || void 0,
+      hairColor: spec.hair,
+      wet: !!P.wet,
+      charred: !!P.char,
+      human: !!spec.human,
+      life
+    });
+    const fem = T.female, tone = T.tone;
+    const skinC = spec.skin ?? (uni ? SKIN[d] : col(tone, SKIN[d], [0.45, 0.65, 0.8, 0.88][d]));
+    const topC = T.topColor, pantC = T.pantsColor;
+    const V = { sleeve: T.sleeve, hair: T.hair, hx: T.headWidth, hy: T.headHeight, jaw: T.jaw, nose: T.nose, beard: T.beard, glasses: T.glasses, cap: T.cap, capC: T.capColor, bag: T.bag, bagC: T.bagColor, torn: T.torn, apron: T.apron };
+    const hairC = T.hairColor;
+    const skinFinal = P.char ? 1840658 : P.wet ? col(skinC, 8032160, 0.55) : skinC;
+    const skinM = M(skinFinal);
+    const topM = M(P.char ? col(topC, 1380880, 0.75) : P.wet ? col(topC, 1712688, 0.45) : col(topC, GRAY, d * 0.3)), pantsM = M(col(pantC, GRAY, d * 0.3)), shoeM = M(T.shoeColor), red = M(RED);
+    const add = (p, geo, m, x, y, z2, rx, ry, rz) => {
+      const o = new THREE.Mesh(geo, m);
+      o.position.set(x || 0, y || 0, z2 || 0);
+      if (rx || ry || rz) o.rotation.set(rx || 0, ry || 0, rz || 0);
+      p.add(o);
+      return o;
+    };
+    const ball = (p, r, m, x, y, z2) => add(p, SPH(r, SEG, 12), m, x, y, z2);
+    topM_ref = topM;
+    const SKM = {}, skM = (c) => SKM[c] || (SKM[c] = new THREE.MeshStandardMaterial({ color: c, roughness: 0.3, metalness: 0, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+    const flat = (p, x, y, zz, sx, sy, c) => {
+      const m = new THREE.Mesh(BLOB, skM(c));
+      m.rotation.set(PI / 2, 0, BR() * 6.28);
+      m.scale.set(sx, 1, sy);
+      m.position.set(x, y, zz);
+      p.add(m);
+      return m;
+    };
+    const splat = (p, x, y, zz, r, c, n) => {
+      const a = flat(p, x, y, zz + 4e-3, r, r * (0.7 + BR() * 0.5), c);
+      for (let k = 0; k < (n || 0); k++) {
+        const an = BR() * 6.28, dd = r * (1.2 + BR() * 0.9), q = r * (0.12 + BR() * 0.18);
+        flat(p, x + Math.cos(an) * dd, y + Math.sin(an) * dd, zz + 4e-3, q, q * 0.7, c);
+      }
+      if (n) run(p, x + r * 0.15, y - r * 0.5, y - r * (2.2 + BR() * 1.2), zz + 3e-3, zz, c, r * 0.35);
+      return a;
+    };
+    const run = (p, x, y0, y1, z0, z1, c, w) => {
+      const L = y0 - y1, sh = new THREE.Shape();
+      sh.moveTo(-w / 2, 0);
+      sh.lineTo(w / 2, 0);
+      sh.quadraticCurveTo(w * 0.3, -L * 0.5, w * 0.18, -L);
+      sh.lineTo(-w * 0.12, -L);
+      sh.quadraticCurveTo(-w * 0.35, -L * 0.5, -w / 2, 0);
+      const g = new THREE.ShapeGeometry(sh), m = new THREE.Mesh(g, skM(c));
+      m.position.set(x, y0, z0);
+      m.rotation.x = -Math.atan2(z0 - z1, L);
+      p.add(m);
+      const bl = new THREE.Mesh(SPH(w * 0.42, 10, 8), skM(c));
+      bl.scale.set(1, 1.35, 0.5);
+      bl.position.set(x + w * 0.03, y1, z1);
+      p.add(bl);
+      return bl;
+    };
+    const stump = (p, r, y, up) => {
+      const st = ball(p, r * 1.02, red, 0, y, 0);
+      st.scale.set(1, 0.35, 1);
+      add(p, CYL(r * 0.32, r * 0.36, 0.07, 10), M(15261900), 0, y + (up ? 0.04 : -0.04), 0);
+    };
+    const ring = (p, r, h, m, y, sx, sz) => {
+      const o = add(p, CYL(r, r, h, 24), m, 0, y, 0);
+      o.scale.set(sx || 1.12, 1, sz || 0.7);
+      return o;
+    };
+    const root = new THREE.Group(), fig = new THREE.Group();
+    const drip = (p, x, y, zz, kind, every) => {
+      if (d >= 3 && kind !== "bile") return;
+      const o = new THREE.Object3D();
+      o.position.set(x, y, zz);
+      o.userData.drip = { kind: kind || (d < 1 ? "blood" : "old"), every: every || (d < 1 ? 1.2 : 2.4) };
+      p.add(o);
+    };
+    fig.scale.set(P.s * P.bulk, P.s, P.s * Math.min(1.15, P.bulk));
+    fig.position.y = P.drop * P.s;
+    root.add(fig);
+    const pel = ball(fig, 0.2, pantsM, 0, 0.92, 0);
+    pel.scale.set(fem ? 1.16 : 1.08, 0.62, 0.74);
+    const legs = [];
+    [[-1, P.legL, P.kneeL], [1, P.legR, P.kneeR]].forEach(([s, r, kr]) => {
+      const g = new THREE.Group();
+      g.position.set(s * (fem ? 0.115 : 0.105), 0.9, 0);
+      fig.add(g);
+      add(g, cylDown(P.bloat ? 0.13 : fem ? 0.11 : 0.105, P.bloat ? 0.095 : 0.078, 0.42), pantsM);
+      const kn = new THREE.Group();
+      kn.position.y = -0.42;
+      g.add(kn);
+      ball(kn, 0.078, pantsM);
+      const lost = P.noLegs || cut.legs;
+      if (lost) {
+        stump(kn, 0.08, -0.01);
+        drip(kn, 0, -0.05, 0, null, 1);
+        g.rotation.x = 1.45;
+      } else {
+        add(kn, cylDown(0.077, 0.056, 0.38), pantsM);
+        const sh = ball(kn, 0.075, shoeM, 0, -0.43, 0.06);
+        sh.scale.set(0.95, 0.7, 1.75);
+        g.rotation.x = r;
+        kn.rotation.x = kr;
+      }
+      legs.push({ g, kn, s, base: g.rotation.x, kBase: kn.rotation.x, lost });
+    });
+    const upper = new THREE.Group();
+    upper.position.y = 0.9;
+    upper.rotation.x = P.lean;
+    fig.add(upper);
+    const U = new THREE.Group();
+    U.position.y = -0.9;
+    upper.add(U);
+    let frontZ = 0.175;
+    if (P.bloat) {
+      const sick = col(skinC, 8362578, 0.45), sickM = M(sick), veinM = M(col(sick, 2767386, 0.55));
+      const chest = add(U, torsoGeo(1.25, 1.35), topM);
+      chest.scale.set(1, 1, 1);
+      const belly = add(U, SPH(0.34, 24, 18), sickM, 0, 1.06, 0.1);
+      belly.scale.set(1.12, 1, 1.08);
+      const shirt = add(U, SPH(0.355, 24, 10, 0, PI * 2, 0, PI * 0.42), topM, 0, 1.08, 0.1);
+      shirt.scale.set(1.12, 1, 1.08);
+      for (let k = 0; k < 7; k++) {
+        const a = -1 + k * 0.33 + Math.sin(k * 3.1) * 0.12, b = 0.05 + k * 37 % 5 * 0.11;
+        const vv = add(U, SPH(0.012, 8, 6), veinM, Math.sin(a) * 0.36, 1 - b * 0.5, 0.1 + Math.cos(a) * 0.36);
+        vv.scale.set(1, 6, 1);
+        vv.rotation.z = a * 0.8;
+      }
+      const pus = [[0.12, 1], [-0.17, 0.92], [0.02, 0.86], [-0.06, 1.12], [0.2, 0.88], [-0.22, 1.05]];
+      drip(U, 0.05, 0.8, 0.3, "bile", 1.6);
+      pus.forEach(([x, y], k) => {
+        const zz = 0.1 + Math.sqrt(Math.max(0.01, 0.34 * 0.34 - x * x / 1.25 - (y - 1.06) ** 2)) * 1.08;
+        const r = 0.022 + k % 3 * 0.01;
+        add(U, SPH(r, 10, 8), basic(z.eye), x, y, zz).userData.eye = 1;
+        const g = glow(z.eye, r * 5, 0.55);
+        g.position.set(x, y, zz + 0.02);
+        U.add(g);
+      });
+      add(U, CYL(0.09, 0.1, 0.12, 16), sickM, 0, 1.62, 0);
+      frontZ = 0.38;
+    } else add(U, torsoGeo(1, 1, fem), topM);
+    if (P.char) {
+      const emb = [[0.1, 1.2, 0.17], [-0.12, 1.35, 0.17], [0.02, 1.02, 0.16], [-0.15, 1.08, 0.15], [0.16, 1.42, 0.15], [0, 1.5, -0.15], [0.12, 1.1, -0.16]];
+      emb.forEach(([x, y, zz]) => {
+        const c = add(U, SPH(0.018, 8, 6), basic(16738842), x, y, zz);
+        c.userData.eye = 1;
+        c.scale.set(2.2, 0.6, 0.5);
+        const g = glow(16734736, 0.12, 0.7);
+        g.position.set(x, y, zz * 1.1);
+        U.add(g);
+      });
+      emb.forEach(([x, y, zz], k) => {
+        if (k % 2) return;
+        const o = new THREE.Object3D();
+        o.position.set(x, y, zz * 1.1);
+        o.userData.ember = { smoke: k === 0 || k === 4 };
+        U.add(o);
+      });
+    }
+    if (P.gore) {
+      splat(U, 0, 1.4, frontZ + 0.01, 0.07, 9046538, 5);
+      splat(U, -0.08, 1.18, frontZ + 0.01, 0.05, 9046538, 3);
+    }
+    if (V.bag && !P.bloat) {
+      const bm = M(V.bagC), sm = M(col(V.bagC, 1118481, 0.5));
+      const b = ball(U, 0.2, bm, 0, 1.22, -0.25);
+      b.scale.set(1.05, 1.25, 0.62);
+      const f = ball(U, 0.12, bm, 0, 1.12, -0.36);
+      f.scale.set(1.2, 0.8, 0.5);
+      [-1, 1].forEach((sx) => {
+        const st = add(U, TOR(0.2, 0.018, 6, 18, PI * 1.1), sm, sx * 0.14, 1.3, 0);
+        st.rotation.set(0, PI / 2, 0);
+      });
+    }
+    if (spec.type === "Brutamonte") {
+      [-1, 1].forEach((sx) => {
+        const t = ball(U, 0.17, topM, sx * 0.2, 1.53, -0.03);
+        t.scale.set(1.2, 0.8, 1);
+      });
+      const hb = ball(U, 0.2, topM, 0, 1.45, -0.12);
+      hb.scale.set(1.5, 0.9, 0.8);
+    }
+    if (O.vest) {
+      const v = add(U, CYL(0.275, 0.24, 0.48, 24), M(O.vest), 0, 1.3, 0);
+      v.scale.set(1.12, 1, 0.7);
+      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);
+    }
+    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) {
+      const bk = new THREE.Group();
+      bk.rotation.y = PI;
+      U.add(bk);
+      splat(bk, -0.05, 1.3, frontZ + 0.01, 0.07, col(BLOOD[Math.min(d, 2)], 1705990, 0.2), 2);
+    }
+    if (!spec.human) {
+      const wy = P.bloat ? 1.25 : 1.36, hy = P.bloat ? 1.02 : 0.98;
+      run(U, 0.08, wy - 0.03, hy, frontZ + 0.012, frontZ - 0.01, col(BLOOD[d], 1705990, 0.35), 0.022);
+      drip(U, 0.083, hy - 0.012, frontZ - 5e-3);
+      const bs = 0.07 + 0.05 * (3 - d);
+      splat(U, 0.07, P.bloat ? 1.25 : 1.36, frontZ + (O.vest ? 0.02 : 0), bs * 0.42, col(BLOOD[d], 1705990, 0.35), d < 2 ? 3 : 1);
+    }
+    for (let k = 0; k < (spec.wounds || 0); k++) splat(U, -0.13 + k * 0.13, 1.15 + 0.13 * (k % 2), frontZ + 0.012, 0.032, 2753795, 2);
+    if (cut.gut) {
+      const gm = M(11553360);
+      for (let k = 0; k < 6; k++) {
+        const q = add(U, TOR(0.05, 0.022, 6, 10), gm, k % 2 ? 0.04 : -0.03, 1 - k * 0.06, frontZ + 0.02, 0, k * 0.7, 0);
+        q.userData.flap = true;
+      }
+      const hole = ball(U, 0.1, red, 0, 1.05, frontZ - 0.03);
+      hole.scale.set(1.2, 1, 0.3);
+      drip(U, 0, 0.75, frontZ + 0.02, null, 0.5);
+    }
+    if (cut.flaps) {
+      [[0.12, 1.2], [-0.1, 1.35], [0.02, 0.98]].forEach(([x, y], k) => {
+        const f = add(U, geoBox(0.07, 0.12, 0.012), k % 2 ? skinM : M(10103338), x, y, frontZ + 0.03);
+        f.geometry.translate(0, -0.06, 0);
+        f.userData.flap = true;
+        drip(U, x, y - 0.12, frontZ + 0.03, null, 1.5);
+      });
+    }
+    const neckLen = 0.14 + Math.max(0, P.neck);
+    if (!cut.head) add(U, CYL(0.058, 0.068, neckLen, SEG), skinM, 0, 1.63 + Math.max(0, P.neck) / 2, 0);
+    const headG = new THREE.Group();
+    headG.position.set(0, 1.64 + P.neck, P.headFwd || 0);
+    headG.rotation.x = P.headX;
+    headG.rotation.z = P.headZ;
+    U.add(headG);
+    const Hd = new THREE.Group();
+    Hd.position.y = -1.64;
+    headG.add(Hd);
+    if (cut.head) {
+      const jaw = add(Hd, SPH(0.12, 16, 12), skinM, 0, 1.69, 0.03);
+      jaw.scale.set(1, 0.6, 1);
+      drip(U, 0, 1.6, 0.1, null, 0.6);
+      const hst = ball(Hd, 0.11, red, 0, 1.74, 0.02);
+      hst.scale.set(1, 0.35, 1);
+      add(Hd, CYL(0.03, 0.035, 0.08, 10), M(15261900), 0, 1.78, 0);
+      splat(U, 0, 1.5, 0.2, 0.05, BLOOD[0], 3);
+    } else {
+      if (cut.blown) {
+        head0: {
+          const hb = add(Hd, SPH(0.165, 20, 16, 0, PI * 2, PI * 0.55, PI * 0.45), skinM, 0, 1.8, 0);
+          hb.scale.set(0.96, 1.1, 1.02);
+          const cv = ball(Hd, 0.15, red, 0, 1.82, 0);
+          cv.scale.set(0.95, 0.3, 0.95);
+          for (let k = 0; k < 5; k++) {
+            const f = ball(Hd, 0.03, k % 2 ? M(15261900) : red, Math.cos(k * 1.3) * 0.13, 1.86, Math.sin(k * 1.3) * 0.13);
+            f.scale.set(1.4, 0.6, 0.9);
+          }
+          ;
+          drip(Hd, 0, 1.7, 0.1, null, 0.4);
+        }
+      }
+      const head = add(Hd, SPH(0.165, 20, 16), skinM, 0, 1.8, 0);
+      if (cut.blown) head.visible = false;
+      head.scale.set(0.96 * V.hx * (P.bloat ? 1.12 : 1), 1.1 * V.hy, 1.02 * (P.bloat ? 1.08 : 1));
+      const jaw = add(Hd, SPH(0.12, 16, 12), skinM, 0, 1.715, 0.03);
+      jaw.userData.bone = 11;
+      jaw.scale.set(V.jaw * (P.bloat ? 1.3 : 1), 0.72 * (P.bloat ? 1.25 : 1), 1);
+      if (cut.jaw) {
+        jaw.geometry.translate(0, 0, 0.06);
+        jaw.position.set(0.03, 1.7, -0.04);
+        jaw.rotation.set(0.75, 0, 0.35);
+        add(Hd, SPH(0.07, 10, 8), red, 0, 1.72, 0.11).scale.set(1.3, 0.5, 0.4);
+        drip(Hd, 0.02, 1.6, 0.12, null, 0.6);
+        jaw.userData.flap = true;
+      }
+      [-1, 1].forEach((s) => {
+        const e = ball(Hd, 0.038, skinM, s * 0.158, 1.79, -5e-3);
+        e.scale.set(0.6, 1, 0.9);
+      });
+      const nose = add(Hd, geoBox(0.045, 0.065, 0.05), skinM, 0, 1.765, 0.172);
+      nose.scale.set(V.nose, V.nose, 1);
+      if (P.nose) nose.scale.set(1.5, 1.4, 2.2);
+      let covered = false;
+      if (O.hat) {
+        const c = M(O.hatC);
+        covered = true;
+        if (O.hat === "cap") {
+          const o = add(Hd, capGeo(0.182), c, 0, 1.84, 0);
+          o.scale.set(1, 0.78, 1.02);
+          add(Hd, geoBox(0.28, 0.022, 0.17), c, 0, 1.85, 0.2, 0.12, 0, 0);
+        }
+        if (O.hat === "helmet") {
+          const o = add(Hd, capGeo(0.205, PI * 0.55), c, 0, 1.82, -0.01);
+          o.scale.set(1, 1, 1.08);
+        }
+        if (O.hat === "hardhat") {
+          const o = add(Hd, capGeo(0.198), c, 0, 1.86, 0);
+          o.scale.set(1, 1.02, 1.08);
+          add(Hd, CYL(0.25, 0.25, 0.02, 24), c, 0, 1.865, 0.02);
+        }
+        if (O.hat === "fire") {
+          const o = add(Hd, capGeo(0.205), c, 0, 1.86, 0);
+          o.scale.set(1, 1.02, 1.1);
+          const br = add(Hd, CYL(0.27, 0.27, 0.02, 24), c, 0, 1.86, -0.06);
+          br.scale.set(1, 1, 1.25);
+          add(Hd, geoBox(0.09, 0.08, 0.02), M(14200896), 0, 1.96, 0.205);
+        }
+        if (O.hat === "moto") {
+          const o = add(Hd, SPH(0.235, 20, 16), c, 0, 1.81, -0.01);
+          o.scale.set(0.98, 1.04, 1.06);
+          add(Hd, SPH(0.226, 20, 6, PI * 0.18, PI * 0.64, PI * 0.36, PI * 0.2), new THREE.MeshLambertMaterial({ color: 2240572 }), 0, 1.81, 0.02);
+        }
+      }
+      if (O.mask) add(Hd, geoBox(0.24, 0.12, 0.04), M(15265520), 0, 1.72, 0.15);
+      if (!covered && V.cap) {
+        const c = M(V.capC);
+        const o = add(Hd, capGeo(0.182), c, 0, 1.84, 0);
+        o.scale.set(1, 0.78, 1.02);
+        add(Hd, geoBox(0.28, 0.022, 0.17), c, 0, 1.85, 0.2, 0.12, 0, 0);
+        covered = true;
+      }
+      const hc = M(hairC);
+      if (!cut.blown && !(d === 3 && VR() < 0.6)) {
+        const hairCap = (r, len, tilt) => {
+          const o = add(Hd, capGeo(r + 8e-3, len), hc, 0, 1.8, -4e-3);
+          o.scale.set(0.97 * V.hx, 1.15 * V.hy, 1.04);
+          o.rotation.x = tilt;
+          return o;
+        };
+        const backBand = (t0, tl) => {
+          const o = add(Hd, SPH(0.172, 20, 8, PI * 0.85, PI * 1.3, t0, tl), hc, 0, 1.8, 0);
+          o.scale.set(0.97 * V.hx, 1.1 * V.hy, 1.04);
+          return o;
+        };
+        const hs = V.hair;
+        if (!covered && (hs === "short" || hs === "bun" || hs === "long")) hairCap(0.174, PI / 2, -0.38);
+        if (hs === "short" || hs === "bun" || hs === "long") backBand(PI * 0.45, PI * 0.22);
+        if (!covered && hs === "bun") ball(Hd, 0.085, hc, 0, 1.92, -0.15);
+        if (hs === "long") {
+          const l = add(Hd, CYL(0.15, 0.12, 0.42, 16, 1, false, PI * 0.6, PI * 0.8), hc, 0, 1.66, -0.02);
+          l.scale.set(1.05, 1, 1.1);
+        }
+        if (!covered && hs === "buzz") hairCap(0.17, PI * 0.45, -0.32);
+        if (hs === "bald") backBand(PI * 0.42, PI * 0.2);
+        if (!covered && hs === "afro") {
+          const a = add(Hd, SPH(0.23, 16, 12, 0, PI * 2, 0, PI * 0.62), hc, 0, 1.93, -0.08);
+          a.scale.set(1.08, 0.85, 0.95);
+        }
+      }
+      if (V.beard) {
+        const b = add(Hd, SPH(0.128, 16, 12), hc, 0, 1.7, 0.035);
+        b.scale.set(1.02 * V.jaw, 0.78, 1);
+      }
+      if (V.glasses) {
+        add(Hd, geoBox(0.27, 0.012, 0.015), M(1710618), 0, 1.84, 0.175);
+        [-1, 1].forEach((s) => {
+          add(Hd, geoBox(0.09, 0.055, 0.012), new THREE.MeshLambertMaterial({ color: 9416896, transparent: true, opacity: 0.3 }), s * 0.06, 1.817, 0.18);
+          add(Hd, geoBox(0.012, 0.012, 0.17), M(1710618), s * 0.15, 1.83, 0.09);
+        });
+      }
+      if (P.mouth) {
+        const m = add(Hd, geoBox(0.1, 0.09, 0.03), basic(328965), 0, 1.69, 0.14);
+      }
+      if (P.gore) splat(Hd, 0, 1.7, 0.15, 0.05, 9046538, 3);
+      else if (!spec.human) {
+        add(Hd, geoBox(0.125, 0.055, 0.014), M(10115666), 0, 1.69, 0.143);
+        add(Hd, geoBox(0.085, 0.03, 0.014), M(1311491), 0, 1.69, 0.151);
+      }
+      const moto = O.hat === "moto", eyeZ = moto ? 0.245 : 0.162, dim = spec.eyeDim ?? (P.dim || moto), eye = spec.eye ?? z.eye;
+      [-1, 1].forEach((s) => {
+        if (cut.blown) return;
+        if (P.blind && !spec.human) {
+          add(Hd, SPH(0.03, 10, 8), M(15262936), s * 0.058, 1.815, 0.152);
+          return;
+        }
+        if (spec.human) {
+          add(Hd, geoBox(0.05, 0.03, 0.012), M(15262940), s * 0.058, 1.815, 0.156);
+          add(Hd, geoBox(0.022, 0.024, 0.012), M(1709074), s * 0.058, 1.814, 0.163);
+          add(Hd, geoBox(0.06, 0.012, 0.02), M(hairC), s * 0.058, 1.85, 0.158, 0, 0, -s * 0.12);
+          return;
+        }
+        if (spec.eyesOff) {
+          add(Hd, geoBox(0.05, 0.028, 0.02), basic(2763298), s * 0.058, 1.815, 0.158);
+          return;
+        }
+        add(Hd, geoBox(0.052, 0.03, 0.02), basic(eye), s * 0.058, 1.815, eyeZ).userData.eye = 1;
+        const g = glow(eye, dim ? 0.1 : 0.15, dim ? 0.3 : 0.85);
+        g.position.set(s * 0.058, 1.815, eyeZ + 0.025);
+        Hd.add(g);
+      });
+    }
+    const arms = [];
+    [[1, P.armR, P.elbR, cut.armR], [-1, P.armL, P.elbL, cut.armL]].forEach(([s, r, er, isCut]) => {
+      const g = new THREE.Group();
+      g.position.set(s * (P.bloat ? 0.37 : fem ? 0.285 : 0.305), 1.475, 0);
+      U.add(g);
+      const upM = V.sleeve === "tank" ? skinM : topM, foreM = V.sleeve === "long" ? topM : skinM, ab = P.bloat ? 1.35 : 1;
+      ball(g, 0.088 * ab, upM);
+      add(g, cylDown(0.083 * ab, 0.075 * ab, 0.31), upM);
+      const el = new THREE.Group();
+      el.position.y = -0.31;
+      g.add(el);
+      if (isCut) {
+        stump(el, 0.07, 0);
+        drip(el, 0, -0.05, 0, null, 0.9);
+      } else {
+        ball(el, 0.06 * ab, foreM);
+        add(el, cylDown(0.06 * ab, 0.046 * ab, 0.29), foreM);
+        const h = ball(el, 0.055 * ab, skinM, 0, -0.33, 5e-3);
+        h.scale.set(0.85, 1.15, 0.7);
+        if (spec.bandage && s < 0) add(el, CYL(0.068, 0.064, 0.09, SEG), M(15262936), 0, -0.17, 0);
+      }
+      const dang = s > 0 ? cut.dangleR : cut.dangleL;
+      if (dang && !isCut) {
+        const fl = add(el, CYL(0.065, 0.05, 0.06, 10), red, 0, 0.01, 0);
+        drip(el, 0, -0.33, 0, null, 0.8);
+        el.userData.dangle = true;
+      }
+      if (s > 0 ? cut.shoulderR : cut.shoulderL) {
+        g.children.slice().forEach((c) => {
+          if (c !== el) g.remove(c);
+        });
+        el.visible = false;
+        stump(g, 0.085, 0);
+        drip(g, 0, -0.05, 0, null, 0.7);
+      }
+      g.rotation.x = r;
+      g.rotation.z = s * (0.07 + (P.armOut || 0));
+      el.rotation.x = isCut ? 0 : er;
+      arms.push({ g, el, s, base: r, eBase: el.rotation.x });
+    });
+    const flaps = [];
+    root.traverse((o) => {
+      if (o.userData.flap) flaps.push(o);
+    });
+    const rig = { flaps, dangles: arms.filter((a) => a.el.userData.dangle), type: spec.type || "Lento", fig, upper, headG, arms, legs, P, ph: spec.phase ?? options.random() * 6, dropBase: fig.position.y, leanBase: P.lean, hxBase: P.headX };
+    if (spec.lying) {
+      root.rotation.x = -PI / 2;
+      root.position.set(0, 0.16 * P.s, 0.9 * P.s);
+      const w = new THREE.Group();
+      w.add(root);
+      return w;
+    }
+    root.userData.rig = rig;
+    return root;
+  }
+  return { build, TYPES, setLOD(k) {
+    LK = k;
+    SEG = Math.max(5, Math.round(16 * k));
+  }, topM: () => topM_ref };
+};
+
+// src/rich/person-builder.ts
+import { MOVES, createRng as createRng2 } from "@adatechnology/game-characters";
+
+// src/rich/accessories/face-features.ts
+var FACE_FEATURES = [
+  {
+    ids: ["glasses", "glasses_y"],
+    apply: ({ Bx, Hd, THREE, add, cmat, f }) => {
+      const lens = new THREE.MeshStandardMaterial({ color: f.includes("glasses_y") ? 14200880 : 9416896, roughness: 0.15, metalness: 0.3, transparent: true, opacity: 0.35 });
+      add(Hd, Bx(0.27, 0.012, 0.015), cmat(1710618), 0, 1.84, 0.175);
+      for (const s of [-1, 1]) {
+        add(Hd, Bx(0.09, 0.055, 0.012), lens, s * 0.06, 1.817, 0.178);
+        add(Hd, Bx(0.012, 0.012, 0.17), cmat(1710618), s * 0.15, 1.83, 0.09);
+      }
+      ;
+    }
+  },
+  {
+    ids: ["mustache"],
+    apply: ({ Bx, Hd, add, hc }) => {
+      add(Hd, Bx(0.13, 0.035, 0.03), hc, 0, 1.728, 0.165);
+    }
+  },
+  {
+    ids: ["mustache_w"],
+    apply: ({ Bx, Hd, add, cmat }) => {
+      add(Hd, Bx(0.17, 0.045, 0.03), cmat(15131868), 0, 1.726, 0.166);
+    }
+  },
+  {
+    ids: ["beard_g"],
+    apply: ({ Hd, THREE, add, cmat }) => {
+      const b = add(Hd, new THREE.SphereGeometry(0.128, 16, 12), cmat(9079430), 0, 1.7, 0.035);
+      b.scale.set(1.02, 0.78, 1);
+    }
+  },
+  {
+    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);
+      b.scale.set(1, 0.74, 1);
+    }
+  },
+  {
+    ids: ["mask"],
+    apply: ({ Bx, Hd, add, cmat }) => {
+      add(Hd, Bx(0.24, 0.12, 0.04), cmat(11456734), 0, 1.72, 0.15);
+    }
+  },
+  {
+    ids: ["goggles"],
+    apply: ({ Hd, PI, THREE, add, cmat }) => {
+      const b = add(Hd, new THREE.CylinderGeometry(0.168, 0.168, 0.035, 20, 1, true), cmat(1710618), 0, 1.9, 0);
+      b.scale.set(0.97, 1, 1.04);
+      for (const s of [-1, 1]) add(Hd, new THREE.CylinderGeometry(0.04, 0.04, 0.04, 16).rotateX(PI / 2), cmat(4876890, { roughness: 0.2, metalness: 0.5 }), s * 0.06, 1.91, 0.165);
+    }
+  },
+  {
+    ids: ["earrings"],
+    apply: ({ Hd, PI, THREE, add, cmat }) => {
+      for (const s of [-1, 1]) add(Hd, new THREE.TorusGeometry(0.028, 7e-3, 4, 8), cmat(14200896, { metalness: 0.8, roughness: 0.3 }), s * 0.162, 1.74, 0, 0, PI / 2, 0);
+    }
+  },
+  {
+    ids: ["cig"],
+    apply: ({ Bx, Hd, THREE, add, cmat }) => {
+      add(Hd, Bx(0.014, 0.014, 0.09), cmat(15658734), 0.05, 1.7, 0.19);
+      const e = add(Hd, Bx(0.017, 0.017, 0.017), new THREE.MeshBasicMaterial({ color: 16738858 }), 0.05, 1.7, 0.237);
+      e.castShadow = false;
+    }
+  },
+  {
+    ids: ["mirror"],
+    apply: ({ Bx, Hd, add, cmat }) => {
+      add(Hd, Bx(0.27, 0.012, 0.015), cmat(1710618), 0, 1.84, 0.175);
+      for (const s of [-1, 1]) {
+        add(Hd, Bx(0.095, 0.06, 0.014), cmat(13159632, { metalness: 0.95, roughness: 0.12 }), s * 0.06, 1.817, 0.179);
+        add(Hd, Bx(0.012, 0.012, 0.17), cmat(1710618), s * 0.15, 1.83, 0.09);
+      }
+      ;
+    }
+  },
+  {
+    ids: ["labgoggles"],
+    apply: ({ Hd, PI, THREE, add, cmat }) => {
+      const b = add(Hd, new THREE.CylinderGeometry(0.168, 0.168, 0.03, 10, 1, true), cmat(2779786), 0, 1.92, 0);
+      b.scale.set(0.97, 1, 1.04);
+      for (const s of [-1, 1]) add(Hd, new THREE.CylinderGeometry(0.045, 0.045, 0.04, 8).rotateX(PI / 2), cmat(10470616, { roughness: 0.1, transparent: true, opacity: 0.7 }), s * 0.06, 1.93, 0.165);
+    }
+  },
+  {
+    ids: ["beard"],
+    apply: ({ Hd, THREE, add, hc }) => {
+      const b = add(Hd, new THREE.SphereGeometry(0.128, 8, 6), hc, 0, 1.7, 0.035);
+      b.scale.set(1.02, 0.8, 1);
+    }
+  }
+];
+
+// src/rich/accessories/hands.ts
+var buildHand = ({ THREE, add, hg, handM, s, detailed }) => {
+  const fingers = [];
+  if (!detailed) return { fingers, th: null };
+  for (let f = 0; f < 4; f++) {
+    const fg = new THREE.Group();
+    fg.position.set(0, -0.078, 0.027 - f * 0.018);
+    hg.add(fg);
+    const len = [0.034, 0.038, 0.036, 0.03][f];
+    add(fg, new THREE.CylinderGeometry(0.0105, 0.0105, len, 8).translate(0, -len / 2, 0), handM, 0, 0, 0);
+    const f2 = new THREE.Group();
+    f2.position.y = -len;
+    fg.add(f2);
+    add(f2, new THREE.CylinderGeometry(0.0105, 9e-3, len * 0.85, 8).translate(0, -len * 0.42, 0), handM, 0, 0, 0);
+    add(f2, new THREE.SphereGeometry(95e-4, 8, 6), handM, 0, -len * 0.85, 0);
+    fingers.push(fg, f2);
+  }
+  const th = new THREE.Group();
+  th.position.set(-s * 0.018, -0.03, 0.034);
+  th.rotation.set(-0.5, 0, -s * 0.45);
+  hg.add(th);
+  add(th, new THREE.CylinderGeometry(0.012, 0.01, 0.045, 8).translate(0, -0.022, 0), handM, 0, 0, 0);
+  add(th, new THREE.SphereGeometry(0.01, 8, 6), handM, 0, -0.045, 0);
+  return { fingers, th };
+};
+
+// src/rich/accessories/hand-items.ts
+var HAND_ITEMS = {
+  axe: ({ Bx, add, cmat, g, metal, woodM }) => {
+    add(g, Bx(0.05, 0.78, 0.05), woodM, 0, -0.18, 0);
+    add(g, Bx(0.04, 0.14, 0.26), cmat(10103328), 0, -0.55, 0.09);
+    add(g, Bx(0.045, 0.14, 0.05), metal, 0, -0.55, 0.23);
+    return;
+  },
+  machete: ({ Bx, add, cmat, g, metal }) => {
+    add(g, Bx(0.05, 0.14, 0.06), cmat(1118481), 0, -0.02, 0);
+    add(g, Bx(0.015, 0.5, 0.08), metal, 0, -0.34, 0.015);
+    return;
+  },
+  wrench: ({ Bx, add, g, metal }) => {
+    add(g, Bx(0.05, 0.5, 0.07), metal, 0, -0.18, 0);
+    add(g, Bx(0.05, 0.08, 0.18), metal, 0, -0.45, 0.04);
+    return;
+  },
+  hammer: ({ Bx, add, dark, g, woodM }) => {
+    add(g, Bx(0.04, 0.34, 0.04), woodM, 0, -0.13, 0);
+    add(g, Bx(0.055, 0.07, 0.18), dark, 0, -0.3, 0.02);
+    return;
+  },
+  hoe: ({ Bx, add, g, metal, woodM }) => {
+    add(g, Bx(0.04, 1.42, 0.04), woodM, 0, -0.06, 0);
+    add(g, Bx(0.24, 0.04, 0.14), metal, 0, -0.74, 0.07, 0.35, 0, 0);
+    return;
+  },
+  baton: ({ THREE, add, cmat, g }) => {
+    add(g, new THREE.CylinderGeometry(0.022, 0.022, 0.55, 16), cmat(1118481), 0, -0.2, 0);
+    return;
+  },
+  knife: ({ Bx, add, cmat, g, metal }) => {
+    add(g, Bx(0.035, 0.1, 0.04), cmat(1118481), 0, -0.02, 0);
+    add(g, Bx(0.01, 0.24, 0.05), metal, 0, -0.18, 5e-3);
+    return;
+  },
+  pistol: ({ Bx, add, dark, g }) => {
+    add(g, Bx(0.04, 0.11, 0.06), dark, 0, -0.04, 0);
+    add(g, Bx(0.04, 0.06, 0.2), dark, 0, 0.02, 0.07);
+    return;
+  },
+  pliers: ({ Bx, add, cmat, g, metal }) => {
+    add(g, Bx(0.03, 0.2, 0.03), cmat(12595754), 0.015, -0.08, 0);
+    add(g, Bx(0.03, 0.2, 0.03), cmat(12595754), -0.015, -0.08, 0);
+    add(g, Bx(0.04, 0.08, 0.03), metal, 0, -0.21, 0);
+    return;
+  },
+  medbag: ({ Bx, add, cmat, g }) => {
+    add(g, Bx(0.36, 0.24, 0.18), cmat(15000282), 0, -0.16, 0);
+    add(g, Bx(0.03, 0.09, 0.01), cmat(12071466), 0, -0.16, 0.095);
+    add(g, Bx(0.09, 0.03, 0.01), cmat(12071466), 0, -0.16, 0.095);
+    add(g, Bx(0.18, 0.04, 0.03), cmat(2763306), 0, -0.02, 0);
+    return;
+  },
+  toolbox: ({ Bx, add, cmat, dark, g }) => {
+    add(g, Bx(0.42, 0.2, 0.2), cmat(11745834, { metalness: 0.3, roughness: 0.5 }), 0, -0.14, 0);
+    add(g, Bx(0.24, 0.04, 0.04), dark, 0, -0.01, 0);
+    return;
+  },
+  book: ({ Bx, add, cmat, g }) => {
+    add(g, Bx(0.05, 0.26, 0.2), cmat(2771562), 0, -0.12, 0.02);
+    add(g, Bx(0.052, 0.24, 0.01), cmat(14736587), 0, -0.12, 0.12);
+    return;
+  },
+  bottle: ({ THREE, add, cmat, g }) => {
+    add(g, new THREE.CylinderGeometry(0.045, 0.045, 0.2, 16), new THREE.MeshStandardMaterial({ color: 3828282, roughness: 0.15, metalness: 0.2, transparent: true, opacity: 0.85, flatShading: false }), 0, -0.1, 0.02);
+    add(g, new THREE.CylinderGeometry(0.018, 0.03, 0.08, 16), cmat(3828282), 0, 0.03, 0.02);
+    return;
+  },
+  clipboard: ({ Bx, add, cmat, g }) => {
+    add(g, Bx(0.03, 0.32, 0.24), cmat(6965802), 0, -0.12, 0.04);
+    add(g, Bx(0.035, 0.26, 0.2), cmat(15263452), 0, -0.13, 0.04);
+    return;
+  },
+  shovel: ({ Bx, THREE, add, cmat, g, metal, woodM }) => {
+    add(g, new THREE.CylinderGeometry(0.022, 0.022, 1.3, 6), woodM, 0, -0.3, 0);
+    add(g, Bx(0.05, 0.18, 0.05), cmat(12855338), 0, 0.22, 0);
+    add(g, Bx(0.22, 0.28, 0.03), metal, 0, -1, 0.03);
+    return;
+  },
+  slingshot: ({ Bx, add, cmat, g, woodM }) => {
+    add(g, Bx(0.03, 0.16, 0.03), woodM, 0, -0.02, 0);
+    add(g, Bx(0.03, 0.12, 0.03), woodM, -0.04, -0.14, 0, 0, 0, -0.4);
+    add(g, Bx(0.03, 0.12, 0.03), woodM, 0.04, -0.14, 0, 0, 0, 0.4);
+    add(g, Bx(0.1, 0.015, 0.015), cmat(12855338), 0, -0.2, 0);
+    return;
+  },
+  bible: ({ Bx, add, cmat, g }) => {
+    add(g, Bx(0.06, 0.24, 0.18), cmat(3810326), 0, -0.12, 0.03);
+    add(g, Bx(0.062, 0.02, 0.182), cmat(13673018), 0, -0.02, 0.03);
+    return;
+  },
+  flare: ({ THREE, add, cmat, g }) => {
+    {
+      add(g, new THREE.CylinderGeometry(0.03, 0.03, 0.26, 6), cmat(15230506), 0, -0.06, 0.02);
+      add(g, new THREE.CylinderGeometry(0.035, 0.02, 0.06, 6), new THREE.MeshBasicMaterial({ color: 16756848 }), 0, 0.1, 0.02);
+      const L = new THREE.PointLight(16738858, 1.4, 4, 2);
+      L.position.set(0, 0.15, 0.05);
+      g.add(L);
+      g.rotation.x = -0.5;
+      return;
+    }
+  },
+  radio_h: ({ Bx, THREE, add, cmat, g }) => {
+    add(g, Bx(0.07, 0.2, 0.11), cmat(3816768), 0, -0.08, 0.03);
+    add(g, new THREE.CylinderGeometry(8e-3, 8e-3, 0.34, 4), cmat(10132122), 0, 0.15, 0.05);
+    add(g, Bx(0.075, 0.05, 0.115), cmat(14204992), 0, -0.12, 0.03);
+    return;
+  },
+  pump: ({ Bx, add, cmat, dark, g }) => {
+    add(g, Bx(0.05, 0.82, 0.05), dark, 0, -0.22, 0.02);
+    add(g, Bx(0.07, 0.15, 0.09), cmat(2763306), 0, -0.05, 0.02);
+    add(g, Bx(0.065, 0.14, 0.07), cmat(3811868), 0, -0.5, 0.02);
+    add(g, Bx(0.03, 0.7, 0.03), dark, 0, -0.2, 0.07);
+    return;
+  },
+  mic: ({ THREE, add, cmat, g }) => {
+    add(g, new THREE.CylinderGeometry(0.022, 0.028, 0.18, 16), cmat(1710618), 0, 0, 0);
+    add(g, new THREE.DodecahedronGeometry(0.045, 0), cmat(6975090, { metalness: 0.6 }), 0, 0.1, 0);
+    g.rotation.x = -0.4;
+    return;
+  }
+};
+
+// src/rich/accessories/hats.ts
+var HATS = [
+  {
+    kinds: ["cap", "capback"],
+    apply: ({ Bx, Hd, PI, add, c, cap, k }) => {
+      const o = add(Hd, cap(0.182, PI / 2), c, 0, 1.84, 0);
+      o.scale.set(1, 0.78, 1.02);
+      add(Hd, Bx(0.28, 0.022, 0.17), c, 0, 1.85, k === "cap" ? 0.2 : -0.2, k === "cap" ? 0.12 : -0.12, 0, 0);
+    }
+  },
+  {
+    kinds: ["beret"],
+    apply: ({ Hd, THREE, add, c }) => {
+      const o = add(Hd, new THREE.CylinderGeometry(0.2, 0.185, 0.07, 20), c, 0.025, 1.95, 0, 0, 0, 0.16);
+      o.scale.set(1, 1, 1.05);
+    }
+  },
+  {
+    kinds: ["hardhat"],
+    apply: ({ Bx, Hd, PI, THREE, add, c, cap }) => {
+      const o = add(Hd, cap(0.198, PI / 2), c, 0, 1.86, 0);
+      o.scale.set(1, 1.02, 1.08);
+      add(Hd, new THREE.CylinderGeometry(0.25, 0.25, 0.02, 20), c, 0, 1.865, 0.02);
+      add(Hd, Bx(0.03, 0.06, 0.38), c, 0, 2.04, 0);
+    }
+  },
+  {
+    kinds: ["fire"],
+    apply: ({ Bx, Hd, PI, THREE, add, c, cap, cmat }) => {
+      const o = add(Hd, cap(0.205, PI / 2), c, 0, 1.86, 0);
+      o.scale.set(1, 1.02, 1.1);
+      const br = add(Hd, new THREE.CylinderGeometry(0.27, 0.27, 0.02, 20), c, 0, 1.86, -0.06);
+      br.scale.set(1, 1, 1.25);
+      add(Hd, Bx(0.09, 0.08, 0.02), cmat(14200896, { metalness: 0.7 }), 0, 1.96, 0.205);
+    }
+  },
+  {
+    kinds: ["straw"],
+    apply: ({ Hd, THREE, add, c, cmat }) => {
+      add(Hd, new THREE.CylinderGeometry(0.38, 0.38, 0.022, 24), c, 0, 1.93, 0);
+      add(Hd, new THREE.CylinderGeometry(0.155, 0.18, 0.15, 20), c, 0, 2.01, 0);
+      add(Hd, new THREE.CylinderGeometry(0.182, 0.182, 0.03, 20), cmat(5913122), 0, 1.955, 0);
+    }
+  },
+  {
+    kinds: ["moto"],
+    apply: ({ Hd, PI, THREE, add, c, cmat }) => {
+      const o = add(Hd, new THREE.SphereGeometry(0.235, 20, 16), c, 0, 1.81, -0.01);
+      o.scale.set(0.98, 1.04, 1.06);
+      add(Hd, new THREE.SphereGeometry(0.226, 20, 10, PI * 0.18, PI * 0.64, PI * 0.36, PI * 0.2), new THREE.MeshStandardMaterial({ color: 1053722, roughness: 0.1, metalness: 0.8, flatShading: false }), 0, 1.81, 0.02);
+      add(Hd, new THREE.CylinderGeometry(0.215, 0.2, 0.05, 20), cmat(12071466), 0, 1.6, -0.01);
+    }
+  },
+  {
+    kinds: ["bandana"],
+    apply: ({ Bx, Hd, PI, add, c, cap }) => {
+      const o = add(Hd, cap(0.18, PI * 0.48), c, 0, 1.8, -5e-3);
+      o.scale.set(0.98, 1.1, 1.05);
+      o.rotation.x = -0.4;
+      add(Hd, Bx(0.07, 0.12, 0.03), c, 0, 1.76, -0.19, 0.3, 0, 0);
+    }
+  },
+  {
+    kinds: ["helmet"],
+    apply: ({ Bx, Hd, PI, THREE, add, c, cap, cmat, sp }) => {
+      const o = add(Hd, cap(0.205, PI / 2), c, 0, 1.835, -5e-3);
+      o.scale.set(1, 0.98, 1.08);
+      add(Hd, new THREE.CylinderGeometry(0.208, 0.212, 0.04, 20), c, 0, 1.84, -5e-3);
+      if (sp.hat.tape) add(Hd, new THREE.CylinderGeometry(0.205, 0.207, 0.035, 20), cmat(sp.hat.tape), 0, 1.9, -5e-3);
+      if (sp.hat.photo) {
+        add(Hd, Bx(0.07, 0.08, 0.012), cmat(16052448), 0.13, 1.9, 0.14, 0, 0.75, 0);
+        add(Hd, Bx(0.05, 0.055, 0.014), cmat(9071184), 0.13, 1.9, 0.141, 0, 0.75, 0);
+      }
+      if (sp.hat.nvg) {
+        add(Hd, Bx(0.07, 0.05, 0.06), cmat(1710618), 0, 2, 0.175);
+        for (const s of [-1, 1]) add(Hd, new THREE.CylinderGeometry(0.024, 0.024, 0.09, 10).rotateX(PI / 2), cmat(2767402), s * 0.032, 1.965, 0.235);
+      }
+      for (const s of [-1, 1]) add(Hd, Bx(0.012, 0.15, 0.012), cmat(1710618), s * 0.16, 1.74, 0.04);
+    }
+  }
+];
+
+// src/rich/accessories/extras.ts
+var EXTRAS = {
+  steth: ({ Bx, PI, THREE, U, add, cmat }) => {
+    add(U, Bx(0.022, 0.24, 0.022), cmat(2763824), 0.085, 1.45, 0.17);
+    add(U, Bx(0.022, 0.24, 0.022), cmat(2763824), -0.085, 1.45, 0.17);
+    add(U, new THREE.CylinderGeometry(0.038, 0.038, 0.02, 16).rotateX(PI / 2), cmat(10133670, { metalness: 0.8, roughness: 0.3 }), 0.03, 1.31, 0.18);
+    return;
+  },
+  mask_chin: ({ Bx, Hd, add, m }) => {
+    add(Hd, Bx(0.24, 0.07, 0.04), m, 0, 1.645, 0.12);
+    return;
+  },
+  vest: ({ Bx, THREE, U, add, m }) => {
+    {
+      const v = add(U, new THREE.CylinderGeometry(0.275, 0.24, 0.48, 20), m, 0, 1.3, 0);
+      v.scale.set(1.12, 1, 0.7);
+      for (let i = 0; i < 3; i++) add(U, Bx(0.11, 0.13, 0.05), m, -0.15 + i * 0.15, 1.17, 0.17);
+      return;
+    }
+  },
+  pouches: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.1, 0.12, 0.09), m, 0.17, 0.95, -0.15);
+    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);
+    return;
+  },
+  holster: ({ Bx, add, cmat, legs }) => {
+    add(legs[1].g, Bx(0.06, 0.2, 0.11), cmat(1118481), 0.105, -0.1, 0);
+    return;
+  },
+  radio: ({ Bx, U, add, cmat }) => {
+    add(U, Bx(0.075, 0.12, 0.05), cmat(1710618), 0.15, 1.42, 0.18);
+    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);
+    arms.forEach((a) => {
+      const r = add(a.el, new THREE.CylinderGeometry(0.058, 0.054, 0.05, 18), m, 0, -0.17, 0);
+    });
+    return;
+  },
+  legstripes: ({ THREE, add, legs, m }) => {
+    legs.forEach((l) => add(l.kn, new THREE.CylinderGeometry(0.07, 0.067, 0.05, 18), m, 0, -0.22, 0));
+    return;
+  },
+  stains: ({ R, U, splat }) => {
+    for (let i = 0; i < 4; i++) splat(U, -0.16 + R() * 0.32, 1.15 + R() * 0.3, 0.158, 0.025 + R() * 0.02, 1381653, 2);
+    return;
+  },
+  stains_y: ({ R, U, splat }) => {
+    for (let i = 0; i < 4; i++) splat(U, -0.2 + R() * 0.4, 1 + R() * 0.4, 0.2, 0.03 + R() * 0.02, 13217856, 2);
+    return;
+  },
+  rag: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.08, 0.16, 0.03), m, -0.17, 0.92, 0.15);
+    return;
+  },
+  apron: ({ Bx, U, add, legs, m }) => {
+    add(U, Bx(0.4, 0.38, 0.025), m, 0, 1.2, 0.158, -0.07, 0, 0);
+    add(U, Bx(0.42, 0.2, 0.025), m, 0, 0.95, 0.158);
+    legs.forEach((l) => add(l.g, Bx(0.2, 0.36, 0.025), m, -l.s * 0.01, -0.19, 0.112));
+    add(U, Bx(0.02, 0.2, 0.02), m, 0.11, 1.52, 0.15);
+    add(U, Bx(0.02, 0.2, 0.02), m, -0.11, 1.52, 0.15);
+    return;
+  },
+  buttons: ({ Bx, U, add, cmat }) => {
+    for (let i = 0; i < 3; i++) add(U, Bx(0.03, 0.03, 0.02), cmat(2763306), 0.1, 1.48 - i * 0.08, 0.165);
+    return;
+  },
+  earpro: ({ PI, THREE, U, add, m }) => {
+    {
+      const r = add(U, new THREE.TorusGeometry(0.13, 0.022, 8, 20, PI), m, 0, 1.6, -0.02, -PI / 2 + 0.3, 0, 0);
+      for (const s of [-1, 1]) add(U, new THREE.CylinderGeometry(0.055, 0.055, 0.06, 16).rotateZ(PI / 2), m, s * 0.14, 1.57, 0.05);
+      return;
+    }
+  },
+  coil: ({ PI, THREE, U, add, m }) => {
+    add(U, new THREE.TorusGeometry(0.16, 0.032, 8, 20), m, 0.2, 1.38, 0, 0, PI / 2, 0.5);
+    return;
+  },
+  deliverybox: ({ Bx, U, add, cmat, m }) => {
+    add(U, Bx(0.52, 0.5, 0.44), m, 0, 1.32, -0.38);
+    add(U, Bx(0.53, 0.06, 0.45), cmat(15263970), 0, 1.43, -0.38);
+    for (const s of [-1, 1]) add(U, Bx(0.04, 0.46, 0.03), cmat(1118481), s * 0.14, 1.3, 0.17, -0.1, 0, 0);
+    return;
+  },
+  backpack: ({ Bx, THREE, U, add, cmat, m }) => {
+    {
+      const b = add(U, new THREE.CylinderGeometry(0.2, 0.22, 0.54, 16), m, 0, 1.24, -0.26);
+      b.scale.set(1.15, 1, 0.6);
+      add(U, Bx(0.3, 0.16, 0.07), m, 0, 1.08, -0.4);
+      for (const s of [-1, 1]) add(U, Bx(0.045, 0.46, 0.03), cmat(1710618), s * 0.15, 1.3, 0.17, -0.1, 0, 0);
+      return;
+    }
+  },
+  helmetpack: ({ Bx, THREE, U, add, cmat, m }) => {
+    {
+      const h = add(U, new THREE.SphereGeometry(0.15, 18, 14), m, 0.2, 0.98, -0.42);
+      h.scale.set(1, 1.05, 1.05);
+      add(U, Bx(0.09, 0.07, 0.02), cmat(14729248), 0.24, 1, -0.565, 0, 0.25, 0);
+      add(U, new THREE.CylinderGeometry(0.14, 0.13, 0.04, 18), cmat(12071466), 0.2, 0.85, -0.42);
+      return;
+    }
+  },
+  hood: ({ PI, THREE, U, add, m }) => {
+    {
+      const h = add(U, new THREE.TorusGeometry(0.13, 0.06, 8, 20, PI * 1.2), m, 0, 1.6, -0.03, PI / 2, 0, PI * -0.1);
+      h.scale.set(1.1, 1.2, 1);
+      return;
+    }
+  },
+  pocket: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.32, 0.13, 0.03), m, 0, 1.03, 0.135);
+    return;
+  },
+  sweatervest: ({ U, add, fem, m, torsoGeo }) => {
+    {
+      const g = torsoGeo(fem);
+      g.scale(1.04, 1, 1.1);
+      add(U, g, m, 0, 0, 0);
+      return;
+    }
+  },
+  collar: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.18, 0.05, 0.05), m, 0, 1.58, 0.1);
+    return;
+  },
+  satchel: ({ Bx, U, add, cmat, m }) => {
+    add(U, Bx(0.045, 0.82, 0.02), cmat(3811866), 0, 1.2, 0.18, 0, 0, 0.68);
+    add(U, Bx(0.28, 0.24, 0.1), m, -0.1, 0.92, -0.2);
+    return;
+  },
+  blouse: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.12, 0.26, 0.02), m, 0, 1.38, 0.157);
+    return;
+  },
+  cross: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.022, 0.085, 0.015), m, 0, 1.37, 0.178);
+    add(U, Bx(0.055, 0.02, 0.015), m, 0, 1.39, 0.178);
+    return;
+  },
+  armband: ({ THREE, add, arms, m }) => {
+    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);
+    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 }) => {
+    {
+      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);
+      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) => {
+        add(a.g, new THREE.CylinderGeometry(0.085, 0.075, 0.31, 18).translate(0, -0.155, 0), m, 0, 0, 0);
+        add(a.el, new THREE.CylinderGeometry(0.072, 0.064, 0.27, 18).translate(0, -0.135, 0), m, 0, 0, 0);
+      });
+      add(U, Bx(0.1, 0.09, 0.02), m, -0.15, 1.4, 0.19);
+      return;
+    }
+  },
+  rosary: ({ Bx, PI, THREE, add, arms, m }) => {
+    add(arms[1].el, new THREE.TorusGeometry(0.055, 0.012, 4, 10), m, 0, -0.27, 0, PI / 2, 0, 0);
+    add(arms[1].el, Bx(0.015, 0.06, 0.01), m, 0, -0.33, 0.06);
+    return;
+  },
+  watch: ({ Bx, PI, THREE, U, add, cmat }) => {
+    {
+      const g = cmat(13673018, { metalness: 0.8, roughness: 0.3 });
+      add(U, new THREE.CylinderGeometry(0.05, 0.05, 0.02, 10).rotateX(PI / 2), g, 0.12, 1.06, 0.135);
+      add(U, Bx(0.015, 0.14, 0.01), g, 0.06, 1.1, 0.135, 0, 0, 0.9);
+      return;
+    }
+  },
+  chain: ({ PI, THREE, add, legs, m, root }) => {
+    {
+      add(legs[0].kn, new THREE.TorusGeometry(0.085, 0.015, 4, 8), m, 0, -0.34, 0, PI / 2, 0, 0);
+      for (let i = 0; i < 6; i++) add(root, new THREE.TorusGeometry(0.045, 0.012, 4, 8), m, 0.2 + i * 0.07, 0.03, -0.06 - i * 0.06, i % 2 ? PI / 2 : 0, 0.6, 0);
+      return;
+    }
+  },
+  unicorn: ({ Bx, THREE, U, add, cmat, m }) => {
+    add(U, Bx(0.32, 0.36, 0.16), m, 0, 1.24, -0.24);
+    add(U, new THREE.ConeGeometry(0.035, 0.16, 5), cmat(15910986), 0, 1.5, -0.24);
+    for (const s of [-1, 1]) {
+      add(U, Bx(0.05, 0.07, 0.04), cmat(15239864), s * 0.09, 1.45, -0.24);
+      add(U, Bx(0.04, 0.42, 0.03), cmat(11561672), s * 0.13, 1.3, 0.16, -0.1, 0, 0);
+    }
+    return;
+  },
+  whistle: ({ Bx, PI, THREE, U, add, cmat }) => {
+    for (const s of [-1, 1]) add(U, Bx(0.012, 0.22, 0.01), cmat(10133670), s * 0.06, 1.48, 0.17, 0, 0, -s * 0.35);
+    add(U, new THREE.CylinderGeometry(0.022, 0.022, 0.08, 6).rotateZ(PI / 2), cmat(13685976, { metalness: 0.9, roughness: 0.2 }), 0, 1.36, 0.19);
+    return;
+  },
+  pen: ({ Hd, THREE, add, cmat }) => {
+    add(Hd, new THREE.CylinderGeometry(0.01, 0.01, 0.26, 5), cmat(2773192), 0, 1.92, -0.15, 0, 0, 1.3);
+    return;
+  },
+  photo: ({ Bx, U, add, cmat }) => {
+    for (const s of [-1, 1]) add(U, Bx(0.012, 0.22, 0.01), cmat(13673018), s * 0.05, 1.48, 0.17, 0, 0, -s * 0.3);
+    add(U, Bx(0.07, 0.09, 0.01), cmat(16052448), 0, 1.34, 0.185);
+    return;
+  },
+  pins: ({ PI, THREE, U, add, cmat, k }) => {
+    [[14174778, 0.1, 1.38], [15913030, 0.17, 1.3], [4898954, 0.12, 1.22], [15790320, -0.15, 1.36]].forEach(([k2, x, y]) => add(U, new THREE.CylinderGeometry(0.028, 0.028, 0.02, 8).rotateX(PI / 2), cmat(k2), x, y, 0.185));
+    return;
+  },
+  recorder: ({ Bx, PI, THREE, U, add, cmat }) => {
+    add(U, Bx(0.13, 0.09, 0.05), cmat(1710618), 0.15, 1.28, 0.215);
+    for (const s of [-1, 1]) add(U, new THREE.CylinderGeometry(0.02, 0.02, 0.052, 8).rotateX(PI / 2), cmat(14191146), 0.15 + s * 0.03, 1.29, 0.22);
+    return;
+  },
+  beads: ({ Bx, PI, add, arms, cmat }) => {
+    {
+      const cs = [15222842, 15913030, 4890848, 5947498, 15239864, 16777215];
+      for (let i = 0; i < 8; i++) {
+        const a = i / 8 * PI * 2;
+        add(arms[0].el, Bx(0.03, 0.03, 0.03), cmat(cs[i % 6]), Math.cos(a) * 0.055, -0.26, Math.sin(a) * 0.055);
+      }
+      return;
+    }
+  },
+  badge: ({ Bx, U, add, cmat }) => {
+    for (const s of [-1, 1]) add(U, Bx(0.012, 0.22, 0.01), cmat(2775720), s * 0.05, 1.48, 0.17, 0, 0, -s * 0.3);
+    add(U, Bx(0.08, 0.11, 0.01), cmat(16053492), 0, 1.34, 0.185);
+    add(U, Bx(0.04, 0.04, 0.012), cmat(5933768), 0, 1.36, 0.19);
+    return;
+  },
+  stethc: ({ Bx, PI, THREE, U, add, cmat, m }) => {
+    add(U, new THREE.TorusGeometry(0.14, 0.018, 5, 10, PI), m, 0, 1.6, -0.02, -PI / 2 + 0.3, 0, 0);
+    add(U, Bx(0.02, 0.2, 0.02), m, -0.1, 1.42, 0.19);
+    add(U, new THREE.CylinderGeometry(0.035, 0.035, 0.02, 8).rotateX(PI / 2), cmat(12633288, { metalness: 0.9, roughness: 0.2 }), -0.1, 1.31, 0.2);
+    return;
+  },
+  bandolier: ({ Bx, U, add, cmat }) => {
+    for (let i = 0; i < 9; i++) add(U, Bx(0.035, 0.08, 0.035), cmat(12855338), -0.22 + i * 0.055, 1.44 - i * 0.055, 0.2, 0, 0, -0.75);
+    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);
+    add(U, new THREE.ConeGeometry(0.08, 0.14, 3), m, 0, 1.47, 0.15, PI, 0, 0);
+    return;
+  },
+  feather: ({ Bx, Hd, add, cmat }) => {
+    add(Hd, Bx(0.02, 0.24, 0.06), cmat(657932), 0.17, 2, -0.04, 0, 0, -0.3);
+    return;
+  },
+  amulet: ({ Bx, U, add, cmat }) => {
+    for (const s of [-1, 1]) add(U, Bx(0.012, 0.22, 0.01), cmat(5913122), s * 0.05, 1.48, 0.17, 0, 0, -s * 0.3);
+    add(U, Bx(0.07, 0.09, 0.03), cmat(8014378), 0, 1.34, 0.19);
+    return;
+  },
+  rifle_front: ({ Bx, THREE, U, add, arms, cmat, k }) => {
+    {
+      const g = new THREE.Group();
+      g.position.set(0.02, 1.15, 0.26);
+      g.rotation.z = 0.95;
+      U.add(g);
+      const dk = cmat(1842463, { metalness: 0.6, roughness: 0.45 });
+      add(g, Bx(0.08, 0.3, 0.06), cmat(k === "dbl_front" ? 5913122 : 2763816), 0, -0.38, 0);
+      add(g, Bx(0.05, 0.85, 0.05), dk, 0, 0.2, 0);
+      if (k === "dbl_front") {
+        add(g, Bx(0.05, 0.6, 0.05), dk, 0.05, 0.3, 0);
+        add(g, Bx(0.11, 0.06, 0.08), cmat(15262936), 0, -0.25, 0);
+      } else {
+        add(g, Bx(0.07, 0.14, 0.09), dk, 0, -0.08, 0.04);
+        if (k === "rifle_tape") {
+          add(g, Bx(0.08, 0.08, 0.08), cmat(4872762), 0, 0.3, 0);
+          add(g, Bx(0.08, 0.08, 0.08), cmat(6974026), 0, 0.08, 0);
+        }
+      }
+      arms.forEach((a) => a.grip = true);
+      return;
+    }
+  },
+  belly: ({ U, ball, topM }) => {
+    {
+      const b = ball(U, 0.16, topM, 0, 1.03, 0.105);
+      b.scale.set(1.05, 1.08, 0.95);
+      return;
+    }
+  },
+  refl: ({ Bx, THREE, U, add, cmat, m, ring }) => {
+    {
+      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);
+      add(U, Bx(0.17, 0.055, 0.02), cmat(1714794), 0, 1.47, 0.205);
+      return;
+    }
+  },
+  plate: ({ Bx, THREE, U, add, cmat, m }) => {
+    {
+      const v = add(U, new THREE.CylinderGeometry(0.28, 0.25, 0.44, 20), m, 0, 1.3, 0);
+      v.scale.set(1.12, 1, 0.72);
+      for (let i = 0; i < 3; i++) add(U, Bx(0.08, 0.14, 0.06), m, -0.1 + i * 0.1, 1.16, 0.2);
+      add(U, Bx(0.07, 0.11, 0.045), cmat(1710618), 0.16, 1.42, 0.2);
+      for (const s of [-1, 1]) add(U, Bx(0.07, 0.04, 0.2), m, s * 0.17, 1.53, 0);
+      return;
+    }
+  },
+  keyring: ({ Bx, PI, THREE, U, add, cmat }) => {
+    {
+      add(U, new THREE.TorusGeometry(0.12, 9e-3, 4, 14, PI), cmat(2763306), 0, 1.5, 0.07, PI / 2 + 0.6, 0, 0);
+      add(U, new THREE.TorusGeometry(0.05, 8e-3, 4, 12), cmat(12103840, { metalness: 0.9, roughness: 0.25 }), 0, 1.34, 0.2);
+      for (let i = 0; i < 7; i++) add(U, Bx(0.013, 0.075, 6e-3), cmat(i % 2 ? 13676640 : 12106944, { metalness: 0.9, roughness: 0.3 }), -0.045 + i * 0.015, 1.28, 0.21, 0, 0, (i - 3) * 0.18);
+      return;
+    }
+  },
+  satradio: ({ Bx, U, add, cmat, m }) => {
+    {
+      add(U, Bx(0.3, 0.4, 0.18), m, 0, 1.28, -0.25);
+      add(U, Bx(0.012, 0.62, 0.012), cmat(1710618), 0.1, 1.72, -0.3, 0, 0, 0.15);
+      add(U, Bx(0.08, 0.06, 0.03), cmat(3815994), -0.08, 1.4, -0.35);
+      for (const s of [-1, 1]) add(U, Bx(0.045, 0.46, 0.03), cmat(1710618), s * 0.15, 1.3, 0.17, -0.1, 0, 0);
+      return;
+    }
+  },
+  binoc: ({ Bx, PI, THREE, U, add, cmat }) => {
+    for (const s of [-1, 1]) add(U, new THREE.CylinderGeometry(0.03, 0.034, 0.12, 10).rotateX(PI / 2), cmat(2500644), s * 0.038, 1.38, 0.26);
+    add(U, Bx(0.03, 0.03, 0.04), cmat(2500644), 0, 1.38, 0.25);
+    return;
+  },
+  tq: ({ Bx, THREE, add, arms, cmat }) => {
+    add(arms[1].g, new THREE.CylinderGeometry(0.09, 0.087, 0.055, 16), cmat(14165546), 0, -0.05, 0);
+    add(arms[1].g, Bx(0.03, 0.05, 0.04), cmat(1710618), 0, -0.05, 0.09);
+    return;
+  },
+  cuia: ({ THREE, U, add, cmat }) => {
+    add(U, new THREE.SphereGeometry(0.055, 12, 10), cmat(6978106), -0.21, 0.9, 0.12);
+    add(U, new THREE.CylinderGeometry(6e-3, 6e-3, 0.13, 6), cmat(12633288, { metalness: 0.9, roughness: 0.2 }), -0.21, 0.99, 0.12, 0, 0, 0.3);
+    add(U, new THREE.CylinderGeometry(0.04, 0.04, 0.015, 12), cmat(12099696), -0.21, 0.95, 0.12);
+    return;
+  },
+  card: ({ Bx, U, add, cmat }) => {
+    for (const s of [-1, 1]) add(U, Bx(0.012, 0.22, 0.01), cmat(2763306), s * 0.05, 1.5, 0.2, 0, 0, -s * 0.3);
+    add(U, Bx(0.08, 0.11, 0.01), cmat(14164e3), 0, 1.36, 0.235);
+    add(U, Bx(0.05, 0.012, 0.012), cmat(15790320), 0, 1.34, 0.24);
+    return;
+  },
+  mapfold: ({ Bx, U, add, cmat }) => {
+    add(U, Bx(0.1, 0.13, 0.025), cmat(15260848), -0.13, 1.33, 0.215, 0, 0, 0.1);
+    add(U, Bx(0.1, 0.012, 0.027), cmat(9071162), -0.13, 1.35, 0.215);
+    return;
+  },
+  motoband: ({ Hd, THREE, add, cmat }) => {
+    add(Hd, new THREE.CylinderGeometry(0.238, 0.238, 0.045, 20), cmat(14729248), 0, 1.84, -0.01);
+    return;
+  },
+  rifle_sup: ({ Bx, THREE, U, add, arms, cmat }) => {
+    {
+      const g = new THREE.Group();
+      g.position.set(0.02, 1.15, 0.27);
+      g.rotation.z = 0.95;
+      U.add(g);
+      const dk = cmat(1842463, { metalness: 0.6, roughness: 0.45 });
+      add(g, Bx(0.07, 0.26, 0.06), cmat(3815988), 0, -0.36, 0);
+      add(g, Bx(0.06, 0.5, 0.06), dk, 0, 0, 0);
+      add(g, Bx(0.07, 0.14, 0.09), dk, 0, -0.06, 0.05);
+      add(g, Bx(0.05, 0.08, 0.07), cmat(2763306), 0, 0.12, 0.06);
+      add(g, new THREE.CylinderGeometry(0.03, 0.03, 0.24, 10), cmat(2763564, { metalness: 0.5, roughness: 0.5 }), 0, 0.37, 0);
+      add(g, Bx(0.04, 0.08, 0.05), cmat(1710618), 0, 0.05, -0.05);
+      arms.forEach((a) => a.grip = true);
+      return;
+    }
+  },
+  gloves: () => {
+  },
+  blood: ({ R, U, splat }) => {
+    for (let i = 0; i < 3; i++) splat(U, 0.06 + R() * 0.14, 1.1 + R() * 0.3, 0.2, 0.022 + R() * 0.02, 3874068, 3);
+    return;
+  },
+  shirtpeek: ({ Bx, U, add, m }) => {
+    add(U, Bx(0.16, 0.26, 0.02), m, 0, 1.38, 0.163);
+    return;
+  },
+  suspenders: ({ Bx, U, add, m }) => {
+    for (const s of [-1, 1]) add(U, Bx(0.035, 0.3, 0.02), m, s * 0.11, 1.4, 0.163);
+    return;
+  }
+};
+EXTRAS.headphones = EXTRAS.earpro;
+EXTRAS.rifle_tape = EXTRAS.rifle_front;
+EXTRAS.dbl_front = EXTRAS.rifle_front;
+
+// src/rich/person-kit.ts
+var createPersonKit = (THREE, { random: R, createCanvas = () => document.createElement("canvas") }) => {
+  const T = THREE;
+  const scaleHex = (hex2, factor) => {
+    const channel = (shift) => (hex2 >> shift & 255) / 255 * factor * 255;
+    return channel(16) << 16 ^ channel(8) << 8 ^ channel(0) << 0;
+  };
+  const Bx = (x, y, z) => new T.BoxGeometry(x, y, z);
+  function add(parent, geo, m, x, y, z, rx, ry, rz) {
+    const o = new T.Mesh(geo, m);
+    o.position.set(x, y, z);
+    if (rx || ry || rz) o.rotation.set(rx || 0, ry || 0, rz || 0);
+    o.castShadow = true;
+    o.receiveShadow = true;
+    parent.add(o);
+    return o;
+  }
+  function canvasTex(w, h, draw) {
+    const cv = createCanvas();
+    cv.width = w;
+    cv.height = h;
+    const context = cv.getContext("2d");
+    if (context) draw(context, w, h);
+    return new T.CanvasTexture(cv);
+  }
+  function chessTex(c1, c2) {
+    const a = new THREE.Color(c1), b = new THREE.Color(c2);
+    return canvasTex(32, 32, (g) => {
+      g.fillStyle = "#" + a.getHexString();
+      g.fillRect(0, 0, 32, 32);
+      g.fillStyle = "#" + b.getHexString();
+      g.globalAlpha = 0.75;
+      g.fillRect(0, 6, 32, 4);
+      g.fillRect(0, 22, 32, 4);
+      g.fillRect(6, 0, 4, 32);
+      g.fillRect(22, 0, 4, 32);
+      g.globalAlpha = 1;
+    });
+  }
+  const SEG = 16;
+  const ccache = {};
+  function cmat(c, o) {
+    if (!o && ccache[c]) return ccache[c];
+    const m = new THREE.MeshStandardMaterial(Object.assign({ color: c, roughness: 0.82, metalness: 0, flatShading: false }, o || {}));
+    if (!o) ccache[c] = m;
+    return m;
+  }
+  const PI = Math.PI;
+  function limb(parent, r1, r2, len, m) {
+    return add(parent, new THREE.CylinderGeometry(r1, r2, len, SEG, 1).translate(0, -len / 2, 0), m, 0, 0, 0);
+  }
+  function mlimb(parent, prof, len, m) {
+    const pts = prof.map((r, i) => new THREE.Vector2(r, -len + i / (prof.length - 1) * len)).reverse();
+    pts.reverse();
+    const sm = new THREE.SplineCurve(prof.slice().reverse().map((r, i) => new THREE.Vector2(r, -len + i / (prof.length - 1) * len))).getPoints(14);
+    return add(parent, new THREE.LatheGeometry(sm, SEG), m, 0, 0, 0);
+  }
+  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) {
+    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;
+  }
+  function cap(r, len) {
+    return new THREE.SphereGeometry(r, 20, 10, 0, PI * 2, 0, len || PI / 2);
+  }
+  function torsoGeo(fem) {
+    const P = fem ? [[0.17, 0.86], [0.215, 0.95], [0.2, 1.02], [0.165, 1.1], [0.2, 1.25], [0.245, 1.38], [0.25, 1.46], [0.2, 1.54], [0.085, 1.6]] : [[0.18, 0.86], [0.205, 0.95], [0.195, 1.03], [0.19, 1.12], [0.225, 1.27], [0.26, 1.4], [0.265, 1.47], [0.21, 1.55], [0.085, 1.6]];
+    const pts = new THREE.SplineCurve(P.map((p) => new THREE.Vector2(p[0], p[1]))).getPoints(30);
+    const g = new THREE.LatheGeometry(pts, 24);
+    g.scale(1.12, 1, 0.64);
+    return g;
+  }
+  function blobR(n, rough, seed) {
+    const f = [];
+    const ph = [seed * 1.7, seed * 3.1, seed * 5.3, seed * 7.9];
+    const sp = [];
+    const ns = rough > 0.5 ? Math.floor(R() * 4) : 0;
+    for (let k = 0; k < ns; k++) sp.push([R() * 6.28, 0.45 + R() * 0.7]);
+    for (let i = 0; i < n; i++) {
+      const a = i / n * PI * 2;
+      let r = 1 + 0.16 * Math.sin(2 * a + ph[0]) + 0.1 * Math.sin(3 * a + ph[1]) + rough * (0.08 * Math.sin(7 * a + ph[2]) + 0.05 * Math.sin(13 * a + ph[3])) + rough * 0.05 * (R() - 0.5);
+      sp.forEach(([sa, l]) => {
+        const d = Math.atan2(Math.sin(a - sa), Math.cos(a - sa));
+        r += l * Math.exp(-d * d * 90);
+      });
+      f.push(Math.max(0.35, r));
+    }
+    return f;
+  }
+  function blobGeo(rad, rx, ry) {
+    const sh = new THREE.Shape();
+    rad.forEach((r, i) => {
+      const a = i / rad.length * PI * 2;
+      const x = Math.cos(a) * r * rx, y = Math.sin(a) * r * ry;
+      i ? sh.lineTo(x, y) : sh.moveTo(x, y);
+    });
+    return new THREE.ShapeGeometry(sh);
+  }
+  const stainMs = {};
+  function stainM(c, o) {
+    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) => {
+      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 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));
+    }
+    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);
+      push(add(parent, blobGeo(blobR(14, 0.5, R() * 10), rr, rr * (1 + R() * 0.6)), core, x + Math.cos(ang) * d, y + Math.sin(ang) * d - (k === 0 ? r * 0.6 : 0), z + 4e-3, 0, 0, ang));
+    }
+    if (n && (fresh || skin)) {
+      const L = r * (1.4 + R() * 1.2), w = r * 0.16;
+      const g = new THREE.Shape();
+      g.moveTo(-w, 0);
+      g.quadraticCurveTo(-w * 0.6, -L * 0.6, -w * 0.35, -L);
+      g.absarc(0, -L, w * 0.6, PI, 0, false);
+      g.quadraticCurveTo(w * 0.6, -L * 0.6, w, 0);
+      push(add(parent, new THREE.ShapeGeometry(g), core, x + r * 0.15, y - r * 0.55, z + 5e-3));
+    }
+    return a;
+  }
+  return { THREE, PI, SEG, R, scaleHex, Bx, add, cmat, ball, ring, cap, limb, mlimb, torsoGeo, splat, stainM, chessTex };
+};
+
+// src/rich/person-builder.ts
+var PAGE_EYES = { lento: 14926657, corredor: 15022379, brutamonte: 15698474 };
+var createPersonBuilder = (THREE, options = {}) => {
+  const kit = createPersonKit(THREE, { random: options.random ?? createRng2(77), createCanvas: options.createCanvas });
+  const { PI, R, scaleHex, Bx, add, cmat, ball, ring, cap, limb, mlimb, torsoGeo, splat, stainM, chessTex } = kit;
+  const reduce = options.reducedMotion ?? false;
+  const detailed = (options.detail ?? 0) === 0;
+  const EYE = { ...PAGE_EYES, ...options.zombieEyes };
+  const T = THREE;
+  const ZSKIN2 = new T.Color(7305820);
+  function build(sp, idx) {
+    const root = new THREE.Group();
+    const H = sp.h || 1, B = sp.bulk || 1, fem = !!sp.fem;
+    const fig = new THREE.Group();
+    fig.scale.set(B, H, Math.min(1.12, B));
+    root.add(fig);
+    const skinM = new THREE.MeshStandardMaterial({ color: sp.skin, roughness: 0.8, flatShading: false });
+    const topM = sp.top.plaid ? new THREE.MeshStandardMaterial({ map: chessTex(sp.top.c, sp.top.plaid), roughness: 0.9, flatShading: false }) : cmat(sp.top.c);
+    const pantsM = cmat(sp.pants.c), shoeM = cmat(sp.shoes);
+    const exHas = (k) => (sp.ex || []).some((e) => e[0] === k);
+    const pel = ball(fig, 0.2, sp.pants.skirt ? cmat(sp.pants.c) : pantsM, 0, 0.92, 0);
+    pel.scale.set(fem ? 1.16 : 1.08, 0.62, 0.74);
+    const legs = [];
+    for (const s of [-1, 1]) {
+      const g = new THREE.Group();
+      g.position.set(s * (fem ? 0.115 : 0.105), 0.9, 0);
+      fig.add(g);
+      const thighM = sp.pants.skirt ? skinM : pantsM;
+      mlimb(g, fem ? [0.113, 0.117, 0.106, 0.09, 0.078] : [0.106, 0.112, 0.104, 0.09, 0.078], 0.42, thighM);
+      const kn = new THREE.Group();
+      kn.position.y = -0.42;
+      g.add(kn);
+      ball(kn, 0.078, thighM);
+      const shinM = sp.pants.skirt ? skinM : pantsM;
+      mlimb(kn, [0.077, 0.081, 0.07, 0.058, 0.052], 0.38, shinM);
+      const kc = ball(kn, 0.04, shinM, 0, -5e-3, 0.058);
+      kc.scale.set(1.05, 1.15, 0.7);
+      const calf = ball(kn, 0.05, shinM, 0, -0.13, -0.03);
+      calf.scale.set(1.05, 1.8, 1);
+      const sh = ball(kn, 0.074, shoeM, 0, -0.425, 0.055);
+      sh.scale.set(0.95, 0.72, 1.85);
+      const so = add(kn, new THREE.CylinderGeometry(0.071, 0.071, 0.022, 18), cmat(1447446), 0, -0.468, 0.055);
+      so.scale.set(1, 1, 1.95);
+      if (sp.pants.skirt) add(g, new THREE.CylinderGeometry(0.135, 0.178, 0.62, 20, 1, true).translate(0, -0.28, 0), pantsM, 0, 0, 0);
+      legs.push({ g, kn, s });
+    }
+    for (const s of [-1, 1]) {
+      const gl = ball(fig, 0.1, pantsM, s * 0.085, 0.87, -0.075);
+      gl.scale.set(1, 0.9, 0.72);
+    }
+    if (sp.pants.skirt) {
+      const sk = add(fig, new THREE.CylinderGeometry(0.2, 0.245, 0.2, 24), pantsM, 0, 0.87, 0);
+      sk.scale.set(1.12, 1, 0.8);
+    }
+    const upper = new THREE.Group();
+    upper.position.y = 0.9;
+    fig.add(upper);
+    const U = new THREE.Group();
+    U.position.y = -0.9;
+    upper.add(U);
+    add(U, torsoGeo(fem), topM, 0, 0, 0);
+    {
+      const trapM = sp.top.sl === "tank" ? skinM : topM;
+      for (const s of [-1, 1]) {
+        const tp = ball(U, 0.1, trapM, s * 0.12, 1.545, -0.02);
+        tp.scale.set(1.35, 0.5, 0.85);
+        const pc = ball(U, fem ? 0.072 : 0.09, topM, s * (fem ? 0.072 : 0.085), fem ? 1.36 : 1.38, fem ? 0.088 : 0.1);
+        pc.scale.set(fem ? 1 : 1.1, fem ? 0.85 : 0.55, fem ? 0.6 : 0.35);
+      }
+      if (sp.top.sl === "tank") for (const s of [-1, 1]) add(U, new THREE.CylinderGeometry(0.011, 0.011, 0.16, 8), skinM, s * 0.08, 1.565, 0.1, 0, 0, s * 1.35);
+    }
+    add(U, new THREE.CylinderGeometry(0.058, 0.068, 0.14, 16), skinM, 0, 1.63, 0);
+    const headG = new THREE.Group();
+    headG.position.set(0, 1.64, 0);
+    U.add(headG);
+    const Hd = new THREE.Group();
+    Hd.position.y = -1.64;
+    headG.add(Hd);
+    const head = add(Hd, new THREE.SphereGeometry(0.165, 20, 16), skinM, 0, 1.8, 0);
+    head.scale.set(0.96, 1.1, 1.02);
+    const jaw = add(Hd, new THREE.SphereGeometry(0.12, 16, 12), skinM, 0, 1.715, 0.03);
+    jaw.scale.set(1, 0.72, 1);
+    for (const s of [-1, 1]) {
+      const e = ball(Hd, 0.038, skinM, s * 0.158, 1.79, -5e-3);
+      e.scale.set(0.6, 1, 0.9);
+    }
+    add(Hd, Bx(0.045, 0.065, 0.05), skinM, 0, 1.765, 0.172);
+    const eyeM = new THREE.MeshBasicMaterial({ color: 1710618 });
+    const whiteM = cmat(15328472);
+    for (const s of [-1, 1]) {
+      const w = add(Hd, new THREE.SphereGeometry(0.022, 12, 8), whiteM, s * 0.058, 1.815, 0.146);
+      w.scale.set(1.25, 0.8, 0.6);
+      w.castShadow = false;
+      const e = add(Hd, new THREE.SphereGeometry(0.011, 10, 8), eyeM, s * 0.058, 1.814, 0.159);
+      e.scale.set(1, 1, 0.5);
+      e.castShadow = false;
+      const lid = add(Hd, new THREE.SphereGeometry(0.024, 12, 6, 0, PI * 2, 0, PI * 0.45), skinM, s * 0.058, 1.818, 0.143);
+      lid.scale.set(1.25, 0.85, 0.65);
+      add(Hd, Bx(0.058, 0.013, 0.022), cmat(sp.hair.c), s * 0.06, 1.852, 0.155, 0, 0, -s * 0.12);
+      const ck = ball(Hd, 0.045, skinM, s * 0.078, 1.772, 0.098);
+      ck.scale.set(1, 0.7, 0.8);
+    }
+    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);
+    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;
+    const hairCap = (r, len, tilt) => {
+      const o = add(Hd, cap(r, len), hc, 0, 1.8, -4e-3);
+      o.scale.set(0.97, 1.1, 1.04);
+      o.rotation.x = tilt;
+      return o;
+    };
+    const backBand = (t0, tl) => {
+      const o = add(Hd, new THREE.SphereGeometry(0.172, 20, 10, PI * 0.85, PI * 1.3, t0, tl), hc, 0, 1.8, 0);
+      o.scale.set(0.97, 1.1, 1.04);
+      return o;
+    };
+    if (hs === "short" || hs === "bun" || hs === "long") {
+      hairCap(0.174, PI / 2, -0.38);
+      backBand(PI * 0.45, PI * 0.22);
+    }
+    if (hs === "bun") ball(Hd, 0.085, hc, 0, 1.92, -0.15);
+    if (hs === "long") {
+      const l = add(Hd, new THREE.CylinderGeometry(0.15, 0.12, 0.42, 16, 1, false, PI * 0.6, PI * 0.8), hc, 0, 1.66, -0.02);
+      l.scale.set(1.05, 1, 1.1);
+    }
+    if (hs === "buzz") hairCap(0.17, PI * 0.45, -0.32);
+    if (hs === "bald") backBand(PI * 0.42, PI * 0.2);
+    if (hs === "afro") {
+      const a = add(Hd, new THREE.DodecahedronGeometry(0.25, 0), hc, 0, 1.9, -0.045);
+      a.scale.set(1.08, 0.9, 1.02);
+    }
+    if (hs === "pony") {
+      hairCap(0.174, PI / 2, -0.38);
+      backBand(PI * 0.45, PI * 0.22);
+      const t = add(Hd, new THREE.CylinderGeometry(0.04, 0.025, 0.3, 6), hc, 0, 1.7, -0.2);
+      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 });
+    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 });
+    }
+    const arms = [];
+    const glove = (sp.ex || []).find((e) => e[0] === "gloves");
+    for (const s of [1, -1]) {
+      const g = new THREE.Group();
+      g.position.set(s * (fem ? 0.285 : 0.305), 1.475, 0);
+      U.add(g);
+      const sl = sp.top.sl;
+      const upM = sl === "tank" ? skinM : topM, foreM = sl === "long" ? topM : skinM;
+      const dl = ball(g, sl === "short" ? 0.09 : 0.083, upM, 0, -0.015, 0);
+      dl.scale.set(1.08, 1.2, 1.05);
+      mlimb(g, sl === "short" ? [0.085, 0.089, 0.086, 0.08, 0.076] : [0.074, 0.08, 0.078, 0.066, 0.06], 0.31, upM);
+      const bi = ball(g, 0.042, upM, 0, -0.13, 0.026);
+      bi.scale.set(1, 1.7, 1);
+      const el = new THREE.Group();
+      el.position.y = -0.31;
+      g.add(el);
+      ball(el, 0.06, foreM);
+      mlimb(el, [0.06, 0.067, 0.06, 0.05, 0.044], 0.29, foreM);
+      const hg = new THREE.Group();
+      hg.position.y = -0.3;
+      el.add(hg);
+      const handM = glove ? cmat(glove[1]) : skinM;
+      const palm = ball(hg, 0.048, handM, 0, -0.035, 0);
+      palm.scale.set(0.6, 1.05, 1);
+      const { fingers, th } = buildHand({ THREE, add, hg, handM, s, detailed });
+      const mount = new THREE.Group();
+      mount.position.set(0, -0.04, 0.015);
+      hg.add(mount);
+      g.rotation.z = s * 0.07;
+      arms.push({ g, el, hg, mount, s, fingers, th });
+    }
+    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 });
+    }
+    if (sp.back === "shotgun") {
+      const g = new THREE.Group();
+      g.position.set(0, 1.22, -0.2 - (exHas("backpack") ? 0.22 : 0));
+      g.rotation.z = 0.75;
+      U.add(g);
+      add(g, Bx(0.05, 0.9, 0.05), cmat(1842463, { metalness: 0.6, roughness: 0.45 }), 0, 0.15, 0);
+      add(g, Bx(0.07, 0.36, 0.09), cmat(6961692), 0, -0.45, 0);
+      add(g, Bx(0.06, 0.22, 0.07), cmat(6961692), 0, 0.15, 0.03);
+      add(U, Bx(0.04, 0.9, 0.02), cmat(3811866), 0, 1.22, 0.175, 0, 0, -0.75);
+    }
+    function item(kind, mount) {
+      if (!kind) return;
+      const g = new THREE.Group();
+      mount.add(g);
+      const metal = cmat(9080982, { metalness: 0.7, roughness: 0.35 }), dark = cmat(1842463, { metalness: 0.6, roughness: 0.45 }), woodM = cmat(6961692);
+      HAND_ITEMS[kind]?.({ THREE, PI, add, Bx, cmat, g, metal, dark, woodM });
+    }
+    item(sp.hand, arms[0].mount);
+    item(sp.lhand, arms[1].mount);
+    if (sp.hand) arms[0].hold = true;
+    if (sp.lhand) arms[1].hold = true;
+    const zb = [];
+    for (let i = 0; i < 4; i++) splat(U, -0.15 + R() * 0.3, 1.2 + R() * 0.25, 0.17, 0.035 + R() * 0.025, 3874068, 3, zb);
+    {
+      const mb = stainM(9046538, { roughness: 0.1, metalness: 0.15 });
+      splat(Hd, 0, 1.672, 0.152, 0.026, 9046538, 2, zb, "skin");
+      const st = add(Hd, new THREE.CylinderGeometry(35e-4, 25e-4, 0.05, 6).translate(0, -0.025, 0), mb, 0.03, 1.676, 0.15);
+      zb.push(st);
+      const dg = add(Hd, new THREE.SphereGeometry(7e-3, 8, 6), mb, 0.03, 1.626, 0.15);
+      dg.userData.zdrop = 1;
+      zb.push(dg);
+    }
+    zb.forEach((b) => b.visible = false);
+    const tag = (o, seg) => o.traverse((m) => {
+      if (m.isMesh && m.userData.seg === void 0) m.userData.seg = seg;
+    });
+    arms.forEach((a, k) => {
+      tag(a.mount, "item");
+      tag(a.hg, "hand" + k);
+      tag(a.el, "fArm" + k);
+      tag(a.g, "uArm" + k);
+      a.g.children[0].userData.joint = 1;
+      a.el.children[0].userData.joint = 1;
+    });
+    legs.forEach((l, k) => {
+      tag(l.kn, "shin" + k);
+      tag(l.g, "thigh" + k);
+      l.kn.children[0].userData.joint = 1;
+    });
+    tag(headG, "head");
+    tag(U, "torso");
+    tag(fig, "pelvis");
+    const SIDE2 = ["esquerdo", "direito"], LSIDE = ["direita", "esquerda"];
+    const segs = { head: { node: headG, label: "Cabe\xE7a", hp: 40, r: 0.07, flip: 1 }, torso: { label: "Tronco", hp: 120 }, pelvis: { label: "Quadril", hp: 90 } };
+    arms.forEach((a, k) => {
+      segs["uArm" + k] = { node: a.g, label: "Bra\xE7o " + SIDE2[k], hp: 60, r: 0.085, arm: k, kind: "shoulder" };
+      segs["fArm" + k] = { node: a.el, label: "Antebra\xE7o " + SIDE2[k], hp: 45, r: 0.065, arm: k, kind: "elbow" };
+      segs["hand" + k] = { node: a.hg, label: "M\xE3o " + SIDE2[k], hp: 25, r: 0.05, arm: k, kind: "wrist" };
+    });
+    legs.forEach((l, k) => {
+      segs["thigh" + k] = { node: l.g, label: "Coxa " + LSIDE[k], hp: 80, r: 0.1, leg: k };
+      segs["shin" + k] = { node: l.kn, label: "Canela e p\xE9 " + LSIDE[k], hp: 55, r: 0.08, leg: k };
+    });
+    for (const k in segs) {
+      segs[k].max = segs[k].hp;
+      segs[k].state = "ok";
+    }
+    const mouth = add(Hd, Bx(0.1, 0.04, 0.02), cmat(3803656), 0, 1.69, 0.145);
+    mouth.visible = false;
+    let dog = null;
+    if (sp.dog) {
+      dog = new THREE.Group();
+      dog.position.set(0.78, 0, 0.3);
+      dog.rotation.y = -0.5;
+      root.add(dog);
+      const dm = cmat(11565630), dl = cmat(14200954);
+      const body = add(dog, new THREE.CylinderGeometry(0.12, 0.11, 0.56, 16).rotateX(PI / 2), dm, 0, 0.42, 0);
+      body.scale.set(1, 1.05, 1);
+      ball(dog, 0.12, dm, 0, 0.43, 0.26);
+      const hd = ball(dog, 0.1, dm, 0, 0.6, 0.38);
+      add(dog, new THREE.CylinderGeometry(0.045, 0.055, 0.12, 16).rotateX(PI / 2), dl, 0, 0.57, 0.5);
+      add(dog, Bx(0.03, 0.03, 0.02), cmat(1118481), 0, 0.585, 0.565);
+      for (const s of [-1, 1]) {
+        add(dog, new THREE.ConeGeometry(0.035, 0.09, 5), dm, s * 0.06, 0.7, 0.36, 0, 0, s * -0.3);
+      }
+      const dlegs = [];
+      for (const a of [-1, 1]) for (const b of [-1, 1]) {
+        const lg = new THREE.Group();
+        lg.position.set(a * 0.075, 0.36, b * 0.21);
+        dog.add(lg);
+        limb(lg, 0.035, 0.028, 0.34, dm);
+        dlegs.push({ lg, ph: a * b > 0 ? 0 : PI });
+      }
+      const tail = new THREE.Group();
+      tail.position.set(0, 0.48, -0.28);
+      dog.add(tail);
+      add(tail, new THREE.CylinderGeometry(0.02, 0.012, 0.24, 16).rotateX(PI / 2).translate(0, 0, -0.1), dm, 0, 0, 0, 0.6, 0, 0);
+      dog.userData = { tail, dlegs };
+    }
+    root.traverse((o) => {
+      if (o.isMesh) o.userData.idx = idx;
+    });
+    return { mv: Object.assign({}, MOVES_IDLE), phase: 0, turnA: 0, segs, dmg: { leg: 0, dead: 0 }, pends: [], limp: [0, 0], skirt: !!sp.pants.skirt, root, fig, upper, headG, arms, legs, skinM, base: new THREE.Color(sp.skin), eyeM, bags, zb, mouth, dog, hunch: sp.hunch || 0, ph: R() * 6 };
+  }
+  const MOVES_IDLE = MOVES.idle;
+  function pose(c, z, W, t) {
+    const p = c.ph + t, freq = z ? 3.4 : 5.6, ph = t * freq + c.ph;
+    const breathe = reduce ? 0 : Math.sin(p * 1.6) * 0.012;
+    c.upper.scale.y = 1 + breathe;
+    const hunch = c.hunch + (z ? 0.38 : 0) + W * 0.05;
+    c.upper.rotation.x = hunch;
+    c.upper.rotation.y = W * Math.sin(ph) * 0.1;
+    c.upper.rotation.z = z ? Math.sin(ph * 0.5) * 0.06 * W + 0.05 : 0;
+    c.fig.position.y = -W * Math.abs(Math.sin(ph)) * 0.035;
+    c.headG.rotation.y = reduce ? 0 : Math.sin(p * 0.5) * 0.25 * (z ? 0.3 : 1) * (W ? 0.4 : 1) * (t ? 1 : 0);
+    c.headG.rotation.x = -hunch * 0.6 + (z ? 0.15 : 0);
+    c.headG.rotation.z = z ? 0.22 : 0;
+    c.legs.forEach((l, k) => {
+      const phi = ph + (k ? Math.PI : 0);
+      const amp = z && k === 0 ? 0.18 : c.skirt ? 0.3 : 0.42;
+      l.g.rotation.x = -W * Math.sin(phi) * amp + (z && !W ? k ? -0.1 : 0.08 : 0);
+      l.kn.rotation.x = W * (Math.max(0, Math.cos(phi)) * (z && k === 0 ? 0.25 : 0.85) + 0.06) + (W ? 0 : 0.03);
+    });
+    c.arms.forEach((a) => {
+      const raise = z ? 1 : 0;
+      const base = a.hold ? -0.2 : 0;
+      const swing = -a.s * Math.sin(ph) * (z ? 0.12 : 0.42) * W * (a.grip ? 0 : 1);
+      a.g.rotation.x = (a.grip && !z ? -0.75 : base - raise * (z ? 1.12 : 1.3)) + swing + (z && !reduce && t ? Math.sin(p * 3 + a.s * 2) * 0.08 : 0);
+      a.g.rotation.z = a.s * (0.07 + (z ? 0.1 : 0)) + (a.grip && !z ? -a.s * 0.35 : 0);
+      a.el.rotation.x = z ? -0.18 : a.grip ? -1.1 : -(0.12 + (a.hold ? 0.25 : 0) + W * (0.25 + Math.max(0, a.s * Math.sin(ph)) * 0.3));
+      if (a.fingers) {
+        const gr = (a.hold || a.grip ? 1.25 : 0.4) * (z ? 0.5 : 1);
+        a.fingers.forEach((f, j) => f.rotation.z = -a.s * gr * (j % 2 ? 1.1 : 0.9));
+        a.th.rotation.z = -a.s * (0.45 + gr * 0.25);
+        a.hg.rotation.x = reduce ? 0 : -W * Math.sin(ph - 0.6) * 0.15 * a.s;
+      }
+    });
+    if (c.dog && !reduce && t) {
+      const d = c.dog.userData;
+      d.tail.rotation.y = Math.sin(t * 9) * 0.5;
+      d.dlegs.forEach((l) => {
+        l.lg.rotation.x = W * Math.sin(t * 7 + l.ph) * 0.45;
+      });
+    }
+  }
+  function zombify(c, cat) {
+    c.skinM.color.copy(c.base).lerp(ZSKIN2, 1);
+    c.eyeM.color.set(EYE[cat || "lento"]);
+    c.zb.forEach((b) => b.visible = true);
+    c.mouth.visible = true;
+    c.bags.material.opacity = 0.9;
+  }
+  function buildPerson(p, zed) {
+    const root = new THREE.Group(), chars = [];
+    if (p.b) {
+      const c = build(p.b, 0);
+      chars.push(c);
+      root.add(c.root);
+      if (zed && !p.kid) zombify(c, p.zcat);
+      c.z = zed && !p.kid;
+    }
+    (p.kids || []).forEach((k) => {
+      const c = build(k, 0);
+      c.root.position.x = k.x;
+      c.root.rotation.y = -k.x * 0.4;
+      c.z = false;
+      chars.push(c);
+      root.add(c.root);
+    });
+    chars.forEach((c) => pose(c, c.z, 0, 0));
+    return { root, chars };
+  }
+  return { build, pose, zombify, buildPerson };
+};
+
+// 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();
+  canvas.width = canvas.height = GLOW_SIZE;
+  const context = canvas.getContext("2d");
+  if (!context) return null;
+  const gradient = context.createRadialGradient(GLOW_SIZE / 2, GLOW_SIZE / 2, 0, GLOW_SIZE / 2, GLOW_SIZE / 2, GLOW_SIZE / 2);
+  gradient.addColorStop(0, "rgba(255,255,255,1)");
+  gradient.addColorStop(0.35, "rgba(255,255,255,.45)");
+  gradient.addColorStop(1, "rgba(255,255,255,0)");
+  context.fillStyle = gradient;
+  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 }) => {
+  const eye = new three.Group();
+  const ball = new three.Mesh(new three.SphereGeometry(radius, 10, 8), new three.MeshBasicMaterial({ color }));
+  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 }));
+    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 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;
+    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));
+  glows.forEach((sprite) => remember(sprite.material));
+  const setBrightness = (level) => {
+    const factor = Math.min(1, Math.max(0, level));
+    base.forEach((rest, material) => {
+      const target = material;
+      target.color.copy(rest.color).multiplyScalar(factor);
+      if (material.isSpriteMaterial) material.opacity = rest.opacity * factor;
+    });
+  };
+  const hidden = [];
+  return {
+    markable,
+    glows,
+    setBrightness,
+    dim: () => setBrightness(0.25),
+    off: () => setBrightness(0),
+    on: () => setBrightness(1),
+    isolate(only) {
+      if (!only) {
+        hidden.splice(0).forEach((object) => object.visible = true);
+        return;
+      }
+      root.traverse((object) => {
+        const mesh = object;
+        if (mesh.isMesh && !isEye(object) && object.visible) {
+          object.visible = false;
+          hidden.push(object);
+        }
+      });
+    }
+  };
+};
+
+// src/wounds/pendulum.ts
+var PENDULUM = {
+  /** Spring toward the pose of the body: `-26 (angle + base)`. */
+  spring: 26,
+  /** Damping: `-1.8 v`. */
+  damping: 1.8,
+  /** Angular speed the blow gives the arm. */
+  kick: 6,
+  /** Sway added while the body walks: `sin(2 phase) * 9`. */
+  walkSway: 9,
+  /** Sideways swing of the node: `sin(3 angle) * 0.12`; a shoulder also keeps its side * 0.12. */
+  sideSwing: 0.12,
+  /** The forearm of a broken shoulder hangs at this angle. */
+  forearmHang: -0.05
+};
+var createPendulum = (node, kind, side, forearm) => ({
+  node,
+  kind,
+  side,
+  ...forearm ? { forearm } : {},
+  a: node.rotation.x,
+  v: PENDULUM.kick
+});
+var stepPendulum = (pendulum, base, dt, walkPhase) => {
+  const acceleration = -PENDULUM.spring * (pendulum.a + base) - PENDULUM.damping * pendulum.v + (walkPhase === void 0 ? 0 : Math.sin(walkPhase * 2) * PENDULUM.walkSway);
+  pendulum.v += acceleration * dt;
+  pendulum.a += pendulum.v * dt;
+  pendulum.node.rotation.x = pendulum.a;
+  pendulum.node.rotation.z = (pendulum.kind === "shoulder" ? pendulum.side * PENDULUM.sideSwing : 0) + Math.sin(pendulum.a * 3) * PENDULUM.sideSwing;
+  if (pendulum.kind === "shoulder" && pendulum.forearm) pendulum.forearm.rotation.x = PENDULUM.forearmHang;
+};
+
+// src/wounds/cut.ts
+var blobRadii = (n, rough, seed, random) => {
+  const phases = [seed * 1.7, seed * 3.1, seed * 5.3, seed * 7.9];
+  const spikes = [];
+  const spikeCount = rough > 0.5 ? Math.floor(random() * 4) : 0;
+  for (let k = 0; k < spikeCount; k++) spikes.push([random() * 6.28, 0.45 + random() * 0.7]);
+  const radii = [];
+  for (let i = 0; i < n; i++) {
+    const angle = i / n * Math.PI * 2;
+    let radius = 1 + 0.16 * Math.sin(2 * angle + phases[0]) + 0.1 * Math.sin(3 * angle + phases[1]) + rough * (0.08 * Math.sin(7 * angle + phases[2]) + 0.05 * Math.sin(13 * angle + phases[3])) + rough * 0.05 * (random() - 0.5);
+    for (const [spikeAngle, length] of spikes) {
+      const distance2 = Math.atan2(Math.sin(angle - spikeAngle), Math.cos(angle - spikeAngle));
+      radius += length * Math.exp(-distance2 * distance2 * 90);
+    }
+    radii.push(Math.max(0.35, radius));
+  }
+  return radii;
+};
+var blobGeometry = (three, radii, rx, ry) => {
+  const shape = new three.Shape();
+  radii.forEach((radius, index) => {
+    const angle = index / radii.length * Math.PI * 2;
+    const x = Math.cos(angle) * radius * rx;
+    const y = Math.sin(angle) * radius * ry;
+    if (index) shape.lineTo(x, y);
+    else shape.moveTo(x, y);
+  });
+  return new three.ShapeGeometry(shape);
+};
+var createWoundMaterials = (three) => {
+  const wound = new three.MeshStandardMaterial({ color: 9046538, roughness: 0.18, metalness: 0.08 });
+  const bone = new three.MeshStandardMaterial({ color: 15261900, roughness: 0.6 });
+  const meat = new three.MeshStandardMaterial({ color: 4851206, roughness: 0.75, side: three.DoubleSide });
+  const fat = new three.MeshStandardMaterial({ color: 12031338, roughness: 0.7 });
+  const rim = new three.MeshStandardMaterial({ color: 9046538, roughness: 0.3, side: three.DoubleSide });
+  const hole = new three.MeshStandardMaterial({ color: 1180676, roughness: 0.9 });
+  const bruise = new three.MeshStandardMaterial({ color: 4857638, roughness: 0.6, transparent: true, opacity: 0.85 });
+  const flesh = new three.MeshStandardMaterial({ color: 9316906, roughness: 0.55 });
+  const all = [wound, bone, meat, fat, rim, hole, bruise, flesh];
+  return { wound, bone, meat, fat, rim, hole, bruise, flesh, dispose: () => all.forEach((material) => material.dispose()) };
+};
+var makeCut = (three, materials, random, group, radius, up) => {
+  const s = up ? 1 : -1;
+  const { PI } = Math;
+  const rim = new three.Mesh(blobGeometry(three, blobRadii(30, 1.4, random() * 10, random), radius * 1.12, radius * 1.12).rotateX(-s * PI / 2), materials.rim);
+  rim.position.y = s * 1e-3;
+  group.add(rim);
+  const meat = new three.Mesh(blobGeometry(three, blobRadii(24, 0.6, random() * 10, random), radius * 0.9, radius * 0.9).rotateX(-s * PI / 2), materials.meat);
+  meat.position.y = s * 4e-3;
+  group.add(meat);
+  const fat = new three.Mesh(new three.TorusGeometry(radius * 0.86, radius * 0.06, 6, 22), materials.fat);
+  fat.rotation.x = PI / 2;
+  fat.position.y = s * 5e-3;
+  group.add(fat);
+  const bone = new three.Mesh(new three.CylinderGeometry(radius * 0.26, radius * 0.3, radius * 0.7, 9), materials.bone);
+  bone.position.set(radius * 0.12, s * radius * 0.3, 0);
+  bone.rotation.z = 0.12;
+  group.add(bone);
+  const tip = new three.Mesh(new three.ConeGeometry(radius * 0.26, radius * 0.35, 7), materials.bone);
+  tip.position.set(radius * 0.16, s * radius * 0.75, 0);
+  tip.rotation.set(up ? 0 : PI, 0, 0.3);
+  group.add(tip);
+  for (let k = 0; k < 5; k++) {
+    const angle = k / 5 * PI * 2 + random() * 0.6;
+    const flap = new three.Mesh(new three.ConeGeometry(radius * 0.16, radius * (0.35 + random() * 0.35), 4), k % 2 ? materials.rim : materials.meat);
+    flap.position.set(Math.cos(angle) * radius * 0.98, s * radius * 0.12, Math.sin(angle) * radius * 0.98);
+    if (!up) flap.rotation.x = PI;
+    group.add(flap);
+  }
+  const strands = [];
+  for (let k = 0; k < 2; k++) {
+    const angle = random() * PI * 2;
+    const length = radius * (0.5 + random() * 0.6);
+    const strand = new three.Mesh(new three.CylinderGeometry(radius * 0.05, radius * 0.03, length, 6).translate(0, -length / 2, 0), materials.rim);
+    strand.position.set(Math.cos(angle) * radius, 0, Math.sin(angle) * radius);
+    group.add(strand);
+    const end = new three.Object3D();
+    end.position.set(Math.cos(angle) * radius, -length, Math.sin(angle) * radius);
+    group.add(end);
+    strands.push(end);
+  }
+  group.traverse((object) => {
+    object.userData.stump = 1;
+    if (object.isMesh) object.castShadow = true;
+  });
+  return strands;
+};
+var makeStump = (three, materials, random, parent, position, radius, flip = false) => {
+  const group = new three.Group();
+  group.position.copy(position);
+  if (flip) group.rotation.x = Math.PI;
+  parent.add(group);
+  return { group, strands: makeCut(three, materials, random, group, radius, false) };
+};
+var ringWound = (three, materials, parent, radius, y = 0) => {
+  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);
+  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);
+  return group;
+};
+
+// src/wounds/flying.ts
+var GRAVITY2 = 9.8;
+var FLOOR_OFFSET = 0.08;
+var BOUNCE_LIMIT = 1.2;
+var BOUNCE_VERTICAL = -0.25;
+var BOUNCE_HORIZONTAL = 0.5;
+var BOUNCE_SPIN = 0.4;
+var LAUNCH = { sideways: 1.6, up: 2.6, forward: 0.6, spin: [9, 6, 9] };
+var createFlyingPieces = (three, { random, groundAt = () => 0, onRest, max = 40 }) => {
+  const pieces = [];
+  const quaternion = new three.Quaternion();
+  const euler = new three.Euler();
+  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 } : {} };
+    pieces.push(piece);
+    trim();
+    return piece;
+  };
+  return {
+    pieces,
+    launch(source, scene, direction, dress, tag) {
+      source.updateWorldMatrix(true, true);
+      const clone = source.clone(true);
+      source.matrixWorld.decompose(clone.position, clone.quaternion, clone.scale);
+      scene.add(clone);
+      dress?.(clone);
+      return add(
+        clone,
+        new three.Vector3(direction.x * LAUNCH.sideways, LAUNCH.up, direction.z * LAUNCH.sideways + LAUNCH.forward),
+        new three.Vector3((random() - 0.5) * LAUNCH.spin[0], (random() - 0.5) * LAUNCH.spin[1], (random() - 0.5) * LAUNCH.spin[2]),
+        tag
+      );
+    },
+    throwObject: add,
+    update(dt) {
+      for (const piece of pieces) {
+        if (piece.rest) continue;
+        piece.velocity.y -= GRAVITY2 * dt;
+        piece.object.position.addScaledVector(piece.velocity, dt);
+        quaternion.setFromEuler(euler.set(piece.spin.x * dt, piece.spin.y * dt, piece.spin.z * dt));
+        piece.object.quaternion.multiply(quaternion);
+        const ground = groundAt(piece.object.position.x, piece.object.position.z) + FLOOR_OFFSET;
+        if (piece.object.position.y >= ground) continue;
+        piece.object.position.y = ground;
+        if (Math.abs(piece.velocity.y) > BOUNCE_LIMIT) {
+          piece.velocity.y *= BOUNCE_VERTICAL;
+          piece.velocity.x *= BOUNCE_HORIZONTAL;
+          piece.velocity.z *= BOUNCE_HORIZONTAL;
+          piece.spin.multiplyScalar(BOUNCE_SPIN);
+        } else {
+          piece.rest = true;
+          const yaw = euler.setFromQuaternion(piece.object.quaternion).y;
+          piece.object.rotation.set(Math.PI / 2 * (random() < 0.5 ? 1 : -1), yaw, 0);
+          piece.object.position.y = ground;
+          onRest?.(piece, piece.object.position);
+        }
+      }
+    },
+    clear() {
+      pieces.splice(0).forEach((piece) => piece.object.removeFromParent());
+    }
+  };
+};
+
+// src/wounds/marks.ts
+var starGeometry = (three, random, radius, points) => {
+  const outline = [];
+  for (let i = 0; i < points * 2; i++) {
+    const angle = i / (points * 2) * Math.PI * 2 + (random() - 0.5) * 0.25;
+    const r = i % 2 ? radius * (0.3 + random() * 0.2) : radius * (0.7 + random() * 0.6);
+    outline.push(new three.Vector2(Math.cos(angle) * r, Math.sin(angle) * r));
+  }
+  return new three.ShapeGeometry(new three.Shape(outline));
+};
+var woundDecal = (three, materials, segment, point, normal, radius) => {
+  const decal = new three.Mesh(new three.CircleGeometry(radius * 0.62, 14), materials.bruise);
+  segment.add(decal);
+  decal.position.copy(segment.worldToLocal(point.clone().addScaledVector(normal, 2e-3)));
+  decal.lookAt(point.clone().addScaledVector(normal, 1));
+  const rim = new three.Mesh(new three.RingGeometry(radius * 0.2, radius * 0.34, 12), materials.wound);
+  rim.position.z = 3e-4;
+  decal.add(rim);
+  const hole = new three.Mesh(new three.CircleGeometry(radius * 0.22, 10), materials.hole);
+  hole.position.z = 5e-4;
+  decal.add(hole);
+  decal.userData.wound = 1;
+  return decal;
+};
+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);
+  });
+  const raycaster = new three.Raycaster(point.clone().addScaledVector(direction, 0.6), direction.clone().negate(), 0, 0.6);
+  const hit = raycaster.intersectObjects(meshes)[0];
+  if (!hit?.face) return void 0;
+  const normal = hit.face.normal.clone().transformDirection(hit.object.matrixWorld);
+  const radius = 0.012 + Math.min(0.035, damage * 28e-5);
+  const star = new three.Mesh(starGeometry(three, random, radius, 5 + (Math.floor(random() * 3) | 0)), materials.flesh);
+  segment.add(star);
+  star.position.copy(segment.worldToLocal(hit.point.clone().addScaledVector(normal, 2e-3)));
+  star.lookAt(hit.point.clone().addScaledVector(normal, 1));
+  star.rotateZ(random() * 6);
+  star.userData.wound = 1;
+  const inner = new three.Mesh(starGeometry(three, random, radius * 0.45, 4), materials.hole);
+  inner.position.z = 5e-4;
+  star.add(inner);
+  return { point: hit.point.clone(), normal, radius };
+};
+var gouge = (three, materials, random, segment, segmentKind, point, normal, direction, damage, fling) => {
+  const count = damage >= 150 ? 7 : damage >= 55 ? 4 : 2;
+  const chunkMaterials = [materials.flesh, materials.bruise, materials.flesh, materials.bone, materials.meat];
+  for (let i = 0; i < count; i++) {
+    const size = 0.012 + random() * (damage >= 150 ? 0.04 : 0.022);
+    const chunk = new three.Mesh(new three.BoxGeometry(size, size * (0.6 + random() * 0.6), size * (0.6 + random() * 0.6)), chunkMaterials[i % 5]);
+    chunk.position.copy(point);
+    const velocity = direction.clone().multiplyScalar(0.8 + random() * 1.5).add(normal.clone().multiplyScalar(0.6 + random())).add(new three.Vector3((random() - 0.5) * 0.8, random() * 0.8, (random() - 0.5) * 0.8));
+    fling(chunk, velocity, new three.Vector3(random() * 14, random() * 14, random() * 14));
+  }
+  const radius = 0.018 + Math.min(0.04, damage * 25e-5);
+  const crater = new three.Mesh(new three.CircleGeometry(radius, 12), materials.hole);
+  segment.add(crater);
+  crater.position.copy(segment.worldToLocal(point.clone().addScaledVector(normal, 3e-3)));
+  crater.lookAt(point.clone().addScaledVector(normal, 1));
+  const rim = new three.Mesh(new three.RingGeometry(radius, radius * 1.5, 12), materials.flesh);
+  rim.position.z = -5e-4;
+  crater.add(rim);
+  if (["upperArm", "forearm", "thigh", "shin"].includes(segmentKind) && damage >= 55) {
+    const splinter = new three.Mesh(new three.CylinderGeometry(6e-3, 6e-3, 0.03, 6), materials.bone);
+    splinter.rotation.x = Math.PI / 2;
+    splinter.position.z = -4e-3;
+    crater.add(splinter);
+  }
+  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();
+  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]);
+    chunk.position.copy(centre).add(new three.Vector3((random() - 0.5) * size * 0.4, (random() - 0.5) * size * 0.4, (random() - 0.5) * size * 0.4));
+    const velocity = direction.clone().multiplyScalar(1.5).add(new three.Vector3((random() - 0.5) * 3, random() * 2.5, (random() - 0.5) * 3));
+    fling(chunk, velocity, new three.Vector3(random() * 15, random() * 15, random() * 15));
+  }
+  return centre;
+};
+
+// src/wounds/segment-nodes.ts
+var RADIUS = { head: 0.07, upperArm: 0.085, forearm: 0.065, hand: 0.05, thigh: 0.1, shin: 0.08 };
+var SIDE = (x) => x >= 0 ? "L" : "R";
+var woundBodyOf = (root) => {
+  const rig = root.userData.rig;
+  if (!rig) return void 0;
+  const nodes = {};
+  rig.arms.forEach((arm, index) => {
+    const side = SIDE(arm.g.position.x);
+    nodes[`upperArm${side}`] = { node: arm.g, radius: RADIUS.upperArm, arm: { index, joint: "shoulder" } };
+    nodes[`forearm${side}`] = { node: arm.el, radius: RADIUS.forearm, arm: { index, joint: "elbow" } };
+  });
+  rig.legs.forEach((leg, index) => {
+    const side = SIDE(leg.g.position.x);
+    nodes[`thigh${side}`] = { node: leg.g, radius: RADIUS.thigh, leg: index };
+    nodes[`shin${side}`] = { node: leg.kn, radius: RADIUS.shin, leg: index };
+  });
+  nodes.head = { node: rig.headG, radius: RADIUS.head, flip: true };
+  return { root, rig, nodes };
+};
+
+// src/wounds/wounds.ts
+import { segmentsBelow } from "@adatechnology/game-characters";
+var worldPosition = (three, object) => object.getWorldPosition(new three.Vector3());
+var createWounds = (three, options) => {
+  const { random, scene, bridge } = options;
+  const materials = options.materials ?? createWoundMaterials(three);
+  const flying = createFlyingPieces(three, { random, ...options.groundAt ? { groundAt: options.groundAt } : {}, ...options.maxPieces ? { max: options.maxPieces } : {} });
+  const states = /* @__PURE__ */ new Map();
+  const stateOf = (body) => {
+    const found = states.get(body);
+    if (!found) throw new Error("game-characters-three: this body is not tracked by the wounds (call `track` first)");
+    return found;
+  };
+  const burstBlood = (change, object) => {
+    const point = worldPosition(three, object);
+    bridge?.burst(change, [point.x, point.y, point.z]);
+  };
+  const sideOf = (object, body) => new three.Vector3(object.position.x >= 0 ? 1 : -1, 0, 0).applyQuaternion(body.root.quaternion);
+  const hideBelow = (state, id) => {
+    for (const below of segmentsBelow(id)) state.gone.add(below);
+  };
+  const sever = (state, id) => {
+    const target = state.body.nodes[id];
+    if (!target || state.gone.has(id)) {
+      state.gone.add(id);
+      hideBelow(state, id);
+      return;
+    }
+    const { node, radius, flip } = target;
+    const direction = sideOf(node, state.body);
+    const fell = flying.launch(node, scene, direction, (clone) => {
+      makeCut(three, materials, random, clone, radius, true);
+    }, id);
+    void fell;
+    node.visible = false;
+    makeStump(three, materials, random, node.parent, node.position, radius, flip);
+    state.gone.add(id);
+    hideBelow(state, id);
+    for (let i = state.pendulums.length - 1; i >= 0; i--) {
+      const pendulum = state.pendulums[i];
+      let shown = true;
+      for (let o = pendulum.node; o; o = o.parent) if (!o.visible) shown = false;
+      if (!shown) state.pendulums.splice(i, 1);
+    }
+    burstBlood("severed", node);
+    if (id === "head") state.dead = true;
+  };
+  const destroy = (state, id, direction) => {
+    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) => {
+      scene.add(chunk);
+      flying.throwObject(chunk, velocity, spin, id);
+    });
+    node.visible = false;
+    makeStump(three, materials, random, node.parent, node.position, radius, flip);
+    state.gone.add(id);
+    hideBelow(state, id);
+    burstBlood("destroyed", node);
+    if (id === "head") state.dead = true;
+  };
+  const breakBone = (state, id) => {
+    const target = state.body.nodes[id];
+    if (!target || state.gone.has(id)) return;
+    if (target.arm) {
+      const { index, joint } = target.arm;
+      const arm = state.body.rig.arms[index];
+      const node = joint === "shoulder" ? arm.g : arm.el;
+      ringWound(three, materials, node, joint === "shoulder" ? 0.078 : 0.064, joint === "shoulder" ? -0.06 : -0.01);
+      const kept = state.pendulums.filter((pendulum) => pendulum.node !== node);
+      state.pendulums.length = 0;
+      state.pendulums.push(...kept, createPendulum(node, joint, arm.s ?? 1, joint === "shoulder" ? arm.el : void 0));
+    }
+    if (target.leg !== void 0) state.limp[target.leg] = true;
+  };
+  const split = (state, direction) => {
+    const upper = state.body.rig.upper;
+    if (!upper.visible) return;
+    flying.launch(upper, scene, direction, (clone) => {
+      makeCut(three, materials, random, clone, 0.16, false);
+    }, "torso");
+    upper.visible = false;
+    makeStump(three, materials, random, upper.parent, upper.position, 0.16);
+    for (const id of ["torso", "neck", "head", "jaw", "upperArmL", "upperArmR", "forearmL", "forearmR", "handL", "handR"]) state.gone.add(id);
+    state.pendulums.length = 0;
+    state.dead = true;
+    burstBlood("split", upper);
+  };
+  const direction3 = (v, fallback) => v ? new three.Vector3(v[0], v[1], v[2]).normalize() : fallback;
+  return {
+    materials,
+    flying,
+    track(body) {
+      states.set(body, { body, pendulums: [], limp: [false, false], gone: /* @__PURE__ */ new Set(), dead: false, crawling: false });
+      return body;
+    },
+    untrack: (body) => void states.delete(body),
+    handle(body, event) {
+      const state = stateOf(body);
+      if (event.type === "leak") {
+        bridge?.handle(event);
+        return;
+      }
+      if (event.type === "hole") {
+        const target = body.nodes[event.part];
+        const node = target?.node ?? body.root;
+        const point = new three.Vector3(...event.worldPoint);
+        const centre = worldPosition(three, node);
+        const normal = point.clone().sub(centre).normalize();
+        if (normal.lengthSq() < 0.5) normal.set(0, 0, 1);
+        woundDecal(three, materials, node, point, normal, 0.014);
+        if (event.exitPoint) {
+          const exit = new three.Vector3(...event.exitPoint);
+          const through = exit.clone().sub(point).normalize();
+          exitWound(three, materials, random, node, exit, through, 40);
+        }
+        return;
+      }
+      if (event.type !== "body") return;
+      const id = event.part;
+      const fallback = new three.Vector3(0, 0.2, 1);
+      const direction = direction3(event.exit, fallback);
+      switch (event.change) {
+        case "severed":
+          if (id) sever(state, id);
+          break;
+        case "destroyed":
+          if (id) destroy(state, id, direction);
+          break;
+        case "broken":
+          if (id) breakBone(state, id);
+          break;
+        case "split":
+          split(state, direction);
+          break;
+        case "limp":
+          if (id) breakBone(state, id);
+          break;
+        case "crawl":
+          state.crawling = true;
+          break;
+        case "killed":
+          state.dead = true;
+          break;
+        case "wound": {
+          const target = id ? body.nodes[id] : void 0;
+          if (target && event.exit) gouge(three, materials, random, target.node, id.replace(/[LR]$/, ""), worldPosition(three, target.node), direction.clone().negate(), direction, 60, (chunk, velocity, spin) => {
+            scene.add(chunk);
+            flying.throwObject(chunk, velocity, spin, id);
+          });
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    setWalkPhase(body, phase) {
+      const state = stateOf(body);
+      if (phase === void 0) delete state.walkPhase;
+      else state.walkPhase = phase;
+    },
+    goneOf: (body) => stateOf(body).gone,
+    update(dt) {
+      flying.update(dt);
+      for (const state of states.values()) {
+        const { rig } = state.body;
+        for (const pendulum of state.pendulums) {
+          const arm = rig.arms.find((candidate) => candidate.g === pendulum.node || candidate.el === pendulum.node);
+          const base = pendulum.kind === "shoulder" ? rig.upper.rotation.x + rig.fig.rotation.x : arm.g.rotation.x + rig.upper.rotation.x + rig.fig.rotation.x;
+          stepPendulum(pendulum, base, dt, state.walkPhase);
+        }
+      }
+    },
+    applyLimp(body) {
+      const state = stateOf(body);
+      const bothLost = state.limp[0] && state.limp[1];
+      state.limp.forEach((hurt, index) => {
+        if (!hurt || bothLost) return;
+        const leg = body.rig.legs[index];
+        leg.g.rotation.x *= 0.3;
+        leg.kn.rotation.x = 0.05;
+        body.rig.upper.rotation.z += index ? -0.07 : 0.07;
+      });
+    },
+    dispose() {
+      flying.clear();
+      materials.dispose();
+      states.clear();
+    }
+  };
+};
+
+// src/wounds/fluids-bridge.ts
+var BURST_LITERS = { severed: 0.35, destroyed: 0.6, split: 0.9 };
+var createFluidsBridge = ({ sink, liquid = "blood", spurtSpeed = 1.4 }) => {
+  const bleed = (point, litersPerSecond, dt, direction = [0, -1, 0], pressurized = false) => {
+    const liters = litersPerSecond * dt;
+    if (liters <= 0) return;
+    const speed = pressurized ? spurtSpeed : 0.15;
+    sink.splash(liquid, point, liters, [direction[0] * speed, direction[1] * speed, direction[2] * speed]);
+  };
+  return {
+    bleed,
+    handle(event) {
+      if (event.type === "leak" && event.fluid === "blood") bleed(event.point, event.rate, 1, event.direction, event.pressurized);
+    },
+    burst: (change, point) => sink.splash(liquid, point, BURST_LITERS[change])
+  };
+};
+
+// src/test-area/module.ts
+import { createCharacters, createRng as createRng3 } from "@adatechnology/game-characters";
+
+// src/test-area/crowd.ts
+import { encodePoseHeight } from "@adatechnology/game-characters";
+var FIELD = { x0: 12, x1: 30, z0: -16, z1: 16 };
+var STRIDE = 1;
+var createCrowd = (three, builders, types, eyes, random) => {
+  const group = new three.Group();
+  const time = { value: 0 };
+  let variants = [];
+  let byType = /* @__PURE__ */ new Map();
+  let batches = [];
+  let members = [];
+  let bakeMs = 0;
+  const ensure = () => {
+    if (variants.length > 0) return;
+    const started = typeof performance === "undefined" ? Date.now() : performance.now();
+    const baked = bakeVariants(three, builders, types);
+    bakeMs = (typeof performance === "undefined" ? Date.now() : performance.now()) - started;
+    variants = baked.variants;
+    byType = baked.byType;
+    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);
+  return {
+    group,
+    spawn(count) {
+      ensure();
+      for (let i = 0; i < count; i++) {
+        const type = types[Math.floor(random() * types.length)];
+        const pool = byType.get(type.id);
+        members.push({ variant: pool[Math.floor(random() * pool.length)], x: FIELD.x0 + random() * (FIELD.x1 - FIELD.x0), z: FIELD.z0 + random() * (FIELD.z1 - FIELD.z0), yaw: random() * Math.PI * 2, phase: random(), speed: 0.6 + random() * 0.8 });
+      }
+    },
+    clear() {
+      members = [];
+      for (const set of batches) for (const batch of set) {
+        batch.begin();
+        batch.end();
+      }
+    },
+    update(dt, camera) {
+      time.value += dt;
+      if (variants.length === 0) return;
+      for (const set of batches) for (const batch of set) batch.begin();
+      const pose = encodePoseHeight("walk", 0);
+      for (const member of members) {
+        member.x += Math.sin(member.yaw) * member.speed * dt;
+        member.z += Math.cos(member.yaw) * member.speed * dt;
+        if (member.x < FIELD.x0 || member.x > FIELD.x1) member.yaw = -member.yaw;
+        if (member.z < FIELD.z0 || member.z > FIELD.z1) member.yaw = Math.PI - member.yaw;
+        const variant = variants[member.variant];
+        const distance2 = Math.hypot(member.x - camera.position.x, member.z - camera.position.z);
+        const level = lodAt(distance2, LOD_DISTANCES);
+        const eye = color(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();
+    },
+    get count() {
+      return members.length;
+    },
+    get bakeMs() {
+      return bakeMs;
+    },
+    get drawCalls() {
+      return batches.reduce((sum, set) => sum + set.filter((batch) => batch.count > 0).length, 0);
+    },
+    get triangles() {
+      return batches.reduce((sum, set, index) => sum + set.reduce((inner, batch, level) => inner + batch.count * ((variants[index]?.verts[level] ?? 0) / 3), 0), 0);
+    },
+    trianglesPerLevel(typeId) {
+      const first = byType.get(typeId)?.[0];
+      return first === void 0 ? [] : variants[first].verts.map((verts) => verts / 3);
+    }
+  };
+};
+
+// src/test-area/hits.ts
+var HIT_PRESETS = [
+  { id: "9x19", hit: { type: "ballistic", energy: 500, mass: 7.5, caliber: 9, caliberId: "9x19" } },
+  { id: "12ga_3", hit: { type: "ballistic", energy: 3e3, mass: 32, caliber: 8.4, pellets: 9, distance: 3, caliberId: "12ga_00buck" } },
+  { id: "7_62x39", hit: { type: "ballistic", energy: 2100, mass: 7.9, caliber: 7.62, caliberId: "7.62x39" } },
+  { id: "308", hit: { type: "ballistic", energy: 3504, mass: 9.7, caliber: 7.8, caliberId: "308" } },
+  { id: "5_56x45", hit: { type: "ballistic", energy: 1800, mass: 4, caliber: 5.56, caliberId: "5.56x45" } },
+  { id: "machete", hit: { type: "slash", energy: 120 } },
+  { id: "axe", hit: { type: "slash", energy: 220 } },
+  { id: "m67_1", hit: { type: "explosive", energy: 6e3, radius: 15 }, range: 1 },
+  { id: "m67_3", hit: { type: "explosive", energy: 6e3, radius: 15 }, range: 3 },
+  { id: "m67_6", hit: { type: "explosive", energy: 6e3, radius: 15 }, range: 6 }
+];
+var hitPresetOf = (id) => HIT_PRESETS.find((preset2) => preset2.id === id) ?? HIT_PRESETS[0];
+var hitFor = (preset2, origin, y, known) => {
+  const { caliberId, ...rest } = preset2.hit;
+  const withId = caliberId !== void 0 && known.has(caliberId) ? { ...rest, caliberId } : rest;
+  if (preset2.hit.type === "explosive") return { ...withId, point: [origin[0] + (preset2.range ?? 3), origin[1] + 0.2, origin[2]] };
+  return { ...withId, point: [origin[0], origin[1] + y, origin[2] + 0.4], direction: [0, 0, -1] };
+};
+
+// src/test-area/person-spec.ts
+var hex = (value) => parseInt(value, 16);
+var personSpecOf = (profession) => {
+  const { look } = profession;
+  const spec = {
+    skin: hex(look.skin),
+    hair: { s: look.hair.style, c: hex(look.hair.color) },
+    top: { c: hex(look.top.color), sl: look.top.sleeve, ...look.top.plaid ? { plaid: hex(look.top.plaid) } : {} },
+    pants: { c: hex(look.pants.color) },
+    shoes: hex(look.shoes),
+    ex: profession.accessories.map((accessory) => accessory.color ? [accessory.id, hex(accessory.color)] : [accessory.id])
+  };
+  if (profession.female) spec.fem = 1;
+  if (look.hat) spec.hat = { k: look.hat.kind, c: hex(look.hat.color) };
+  if (look.face && look.face.length > 0) spec.face = [...look.face];
+  if (profession.hand) spec.hand = profession.hand;
+  if (profession.leftHand) spec.lhand = profession.leftHand;
+  return spec;
+};
+
+// src/test-area/scenarios.ts
+import { SEGMENT_IDS } from "@adatechnology/game-characters";
+var LIMB_SEGMENTS = ["upperArmL", "forearmL", "handL", "upperArmR", "forearmR", "handR", "thighL", "shinL", "footL", "thighR", "shinR", "footR"];
+var BENCHMARK_BODIES = 1e3;
+var preset = (id) => HIT_PRESETS.find((entry) => entry.id === id);
+var bodyChanges = (events) => events.flatMap((event) => event.type === "body" ? [`${event.change}${event.part ? `:${event.part}` : ""}`] : []);
+var createScenarios = (deps) => {
+  const person = (extra = {}, seed = 1) => deps.kit().create({ seed, kind: "person", ...extra });
+  const shoot = (character, id, part) => {
+    character.hit({ ...hitFor(preset(id), [0, 0, 0], 1.3, deps.kit().calibers), part });
+  };
+  const scenario = (id, run) => ({ id, name: deps.text[id] ?? id, run });
+  return [
+    scenario("region_x_caliber", ({ expect }) => {
+      for (const ammo of ["9x19", "308"]) {
+        for (const part of ["head", "torso", "upperArmL", "thighL"]) {
+          const character = person();
+          shoot(character, ammo, part);
+          expect((character.lastHit?.points ?? 0) > 0, `${ammo} on ${part} does damage`, { points: character.lastHit?.points });
+        }
+      }
+      const head = person();
+      shoot(head, "308", "head");
+      expect(!head.alive, "a .308 to the head kills");
+    }),
+    scenario("cut_at_every_joint", ({ expect }) => {
+      for (const part of LIMB_SEGMENTS) {
+        const character = person();
+        character.hit({ type: "slash", point: [0, 1, 0], part, points: 100 });
+        const segment = character.segments.find((entry) => entry.id === part);
+        expect(segment?.status === "severed" || segment?.status === "destroyed", `${part} is cut off`, { status: segment?.status });
+      }
+      expect(LIMB_SEGMENTS.every((part) => SEGMENT_IDS.includes(part)), "every joint is a segment of the body");
+    }),
+    scenario("broken_bone_dangles", ({ expect }) => {
+      const character = person();
+      const changes = [];
+      for (let blow = 0; blow < 3; blow++) changes.push(...bodyChanges(character.hit({ type: "blunt", point: [0, 1.2, 0], part: "forearmL", points: 20 })));
+      expect(changes.some((change) => change.startsWith("broken")), "three blows break the forearm", { changes });
+      expect(character.segments.find((entry) => entry.id === "forearmL")?.attached === true, "the broken forearm stays attached (it dangles)");
+    }),
+    scenario("leg_limp_crawl", ({ expect }) => {
+      const character = person();
+      expect(bodyChanges(character.hit({ type: "blunt", point: [0, 0.5, 0], part: "thighL", points: 40 })).includes("limp"), "a hurt leg limps");
+      expect(bodyChanges(character.hit({ type: "slash", point: [0, 0.5, 0], part: "thighL", points: 40 })).includes("crawl"), "a lost thigh crawls");
+    }),
+    scenario("head_kill", ({ expect }) => {
+      const character = person();
+      shoot(character, "9x19", "head");
+      expect(!character.alive, "a 9x19 to the head kills");
+      const torso = person();
+      shoot(torso, "9x19", "torso");
+      expect(torso.alive, "a 9x19 to the torso does not");
+    }),
+    scenario("grenade_by_radius", ({ expect }) => {
+      const lost = (id) => {
+        const character = person();
+        character.hit(hitFor(preset(id), [0, 0, 0], 1, deps.kit().calibers));
+        return character.segments.reduce((sum, segment) => sum + (segment.max - segment.hp), 0);
+      };
+      const [near, middle, far] = [lost("m67_1"), lost("m67_3"), lost("m67_6")];
+      expect(near > middle && middle >= far, "the nearer the blast, the more it takes", { near, middle, far });
+    }),
+    scenario("penetration_line", ({ expect }) => {
+      const kit = deps.kit();
+      const targets = Array.from({ length: 5 }, (_, index) => ({ character: person({}, index + 1), part: "torso", distance: 5 + index * 1.2 }));
+      const result = kit.penetrateLine({ energyAt: () => 3504, mass: 9.7, caliber: 7.8, caliberId: "308" }, targets);
+      expect(result.hits.length >= 1, "the bullet hits the first body", { hits: result.hits.length });
+      const energies = result.hits.map((hit) => hit.energy);
+      expect(energies.every((energy, index) => index === 0 || energy <= energies[index - 1]), "it keeps less energy at each body", { energies });
+    }),
+    scenario("age_0_3", ({ expect }) => {
+      const THREE = deps.three();
+      if (!THREE) return expect(false, "the area is not attached to a room");
+      deps.ensureBuilders(THREE);
+      const colors = (decay) => {
+        const root = deps.buildZombie(deps.typeNames()[0], decay);
+        const seen = /* @__PURE__ */ new Set();
+        root.traverse((object) => {
+          const material = object.material;
+          if (material?.color) seen.add(material.color.getHexString());
+        });
+        return [...seen].sort().join(",");
+      };
+      const fresh = colors(0);
+      expect(fresh.length > 0, "a fresh body is built");
+      expect(colors(3) !== fresh, "a decrepit body looks different from a fresh one");
+    }),
+    scenario("vest_and_helmet", ({ expect }) => {
+      const bare = person();
+      const dressed = person({ protection: ["vest_police", "helmet_combat"] });
+      shoot(bare, "9x19", "torso");
+      shoot(dressed, "9x19", "torso");
+      expect((dressed.lastHit?.points ?? 0) < (bare.lastHit?.points ?? 0), "the vest takes points off a torso hit", { bare: bare.lastHit?.points, dressed: dressed.lastHit?.points });
+      shoot(dressed, "9x19", "head");
+      expect(dressed.alive, "the helmet stops a 9x19 to the head", { absorbedBy: dressed.lastHit?.absorbedBy });
+    }),
+    scenario("bite_to_turn", ({ expect }) => {
+      const undead = deps.undead();
+      if (!undead?.infect) return expect(false, "no undead pack in this area");
+      for (const age of ["adult", "child"]) {
+        const victim = person({ age }, 9);
+        const infection = undead.infect("bite", () => 0);
+        expect(infection !== void 0, `a bite infects (${age})`);
+        if (!infection) continue;
+        infection.advance(1e3);
+        expect(infection.reanimated, `the case ends in reanimation (${age})`);
+        const turned = undead.turn(victim);
+        expect(turned.alive && undead.traitsOf(turned) !== void 0, `the ${age} turns into a zombie`, { type: undead.traitsOf(turned)?.type });
+      }
+    }),
+    scenario("benchmark_1000", ({ expect }) => {
+      const THREE = deps.three();
+      if (!THREE) return expect(false, "the area is not attached to a room");
+      const crowd = deps.crowd();
+      crowd.spawn(BENCHMARK_BODIES);
+      expect(crowd.count >= BENCHMARK_BODIES, `${BENCHMARK_BODIES} bodies are in the field`, { count: crowd.count });
+      const levels = crowd.trianglesPerLevel(deps.undead() ? "walker" : "");
+      levels.forEach((triangles, level) => {
+        const budget = deps.triangleBudget[level];
+        if (level === levels.length - 1 && deps.triangleBudgetSoftFar) expect(true, `level ${level} body has ${Math.round(triangles)} triangles (budget ${budget})`, { triangles, budget, over: triangles > budget });
+        else expect(triangles <= budget, `level ${level} body is inside ${budget} triangles`, { triangles });
+      });
+      crowd.clear();
+    })
+  ];
+};
+
+// src/test-area/text.ts
+var PRESETS_EN = { "9x19": "9x19 mm", "12ga_3": "12 ga 00 at 3 m", "7_62x39": "7.62x39", "308": ".308", "5_56x45": "5.56x45", machete: "Machete", axe: "Axe", m67_1: "M67 at 1 m", m67_3: "M67 at 3 m", m67_6: "M67 at 6 m" };
+var PRESETS_PT = { "9x19": "9x19 mm", "12ga_3": "12 ga 00 a 3 m", "7_62x39": "7,62x39", "308": ".308", "5_56x45": "5,56x45", machete: "Fac\xE3o", axe: "Machado", m67_1: "M67 a 1 m", m67_3: "M67 a 3 m", m67_6: "M67 a 6 m" };
+var TEXT = {
+  en: {
+    group: "Characters",
+    name: "Characters area",
+    bodies: {},
+    child: "Child",
+    elder: "Elder",
+    controls: { decay: "Decay", age: "Age group", penetration: "Penetration model", death_rule: "Death rule", detail: "Damage detail", moment: "Moment", pose: "Pose", cascade: "Cascade", hit_preset: "Hit", protection: "Protection", path: "Drawing path" },
+    hints: {
+      decay: "0 fresh .. 3 decrepit: skin, blood and cloth of bodies built from now on",
+      penetration: "physical: P = sqrt(E m / A). team-game: the points of the game. Applies to bodies created from now on",
+      death_rule: "vitality-or-head (the game) or head-only (the golden rule of the pages)",
+      detail: "segments: the 17 parts of the near path. regions: the 6 regions of the crowd",
+      moment: "The speed of the selected zombie at that moment, in the readout",
+      hit_preset: "What the Fire hit button does to the body you look at",
+      protection: "Worn by the bodies created from now on"
+    },
+    actions: { heal: "Heal the aimed body", kill: "Kill the aimed body", infect: "Bite the aimed person (accelerated)", spawn_100: "Spawn 100 in the crowd", spawn_1000: "Spawn 1000 in the crowd", fire_preset: "Fire the hit" },
+    options: {
+      penetration: { physical: "Physical", "team-game": "Team game" },
+      death_rule: { "vitality-or-head": "Vitality or head", "head-only": "Head only" },
+      detail: { segments: "Segments", regions: "Regions" },
+      moment: { wander: "Wander", alert: "Alert", chase: "Chase", sprint: "Sprint", frenzy: "Frenzy", limp: "Limping", crawl: "Crawling" },
+      pose: { walk: "Walk", stand: "Stand" },
+      protection: { none: "None", vest_police: "Police vest", vest_military: "Military vest", helmet_combat: "Helmet", turnout_gear: "Firefighter gear", vest_helmet: "Vest and helmet" },
+      path: { rich: "Rich", lod0: "Instanced LOD 0", lod1: "Instanced LOD 1", lod2: "Instanced LOD 2" },
+      age: { child: "Child", young: "Young", adult: "Adult", elder: "Elder" },
+      hit_preset: PRESETS_EN
+    },
+    layers: { capsules: "Hit capsules", joints: "Joints", bleed: "Bleed emitters", eyes_only: "Eyes only", speed: "Speed vectors" },
+    metrics: { bodies: "Bodies", instances: "Instances", triangles: "Triangles", draw_calls: "Draw calls", bake_ms: "Bake time", speed: "Speed of the selected", vitality: "Vitality", bleed: "Bleed rate", segments_hp: "Segments hit points", last_crossed: "Bodies crossed by the last shot", last_energy: "Energy kept" },
+    scenarios: {
+      region_x_caliber: "Region x calibre",
+      cut_at_every_joint: "A cut at every joint",
+      broken_bone_dangles: "A broken bone dangles",
+      leg_limp_crawl: "Leg: limp, then crawl",
+      head_kill: "Head kills",
+      grenade_by_radius: "Grenade by radius",
+      penetration_line: "Penetration through a line of 5",
+      age_0_3: "Decay 0 to 3",
+      vest_and_helmet: "Vest and helmet",
+      bite_to_turn: "Bite, fever, delirium, turn (child too)",
+      benchmark_1000: "1000 bodies against the triangle budget"
+    },
+    log: { crossed: "Hit: {bodies} bodies crossed, {energy} of the energy kept", turned: "{from} turned into {to}" }
+  },
+  "pt-BR": {
+    group: "Personagens",
+    name: "\xC1rea de personagens",
+    bodies: {},
+    child: "Crian\xE7a",
+    elder: "Idoso",
+    controls: { decay: "Decomposi\xE7\xE3o", age: "Faixa de idade", penetration: "Modelo de penetra\xE7\xE3o", death_rule: "Regra de morte", detail: "Detalhe do dano", moment: "Momento", pose: "Pose", cascade: "Cascata", hit_preset: "Golpe", protection: "Prote\xE7\xE3o", path: "Caminho de desenho" },
+    hints: {
+      decay: "0 fresco .. 3 decr\xE9pito: pele, sangue e roupa dos corpos feitos daqui em diante",
+      penetration: "physical: P = raiz(E m / A). team-game: os pontos do jogo. Vale para os corpos criados daqui em diante",
+      death_rule: "vitality-or-head (o jogo) ou head-only (a regra de ouro das p\xE1ginas)",
+      detail: "segments: as 17 partes do caminho de perto. regions: as 6 regi\xF5es da multid\xE3o",
+      moment: "A velocidade do zumbi selecionado nesse momento, no mostrador",
+      hit_preset: "O que o bot\xE3o Disparar faz no corpo para o qual voc\xEA olha",
+      protection: "Vestida pelos corpos criados daqui em diante"
+    },
+    actions: { heal: "Curar o corpo mirado", kill: "Matar o corpo mirado", infect: "Morder a pessoa mirada (acelerado)", spawn_100: "P\xF4r 100 na multid\xE3o", spawn_1000: "P\xF4r 1000 na multid\xE3o", fire_preset: "Disparar o golpe" },
+    options: {
+      penetration: { physical: "F\xEDsica", "team-game": "Do jogo" },
+      death_rule: { "vitality-or-head": "Vitalidade ou cabe\xE7a", "head-only": "S\xF3 a cabe\xE7a" },
+      detail: { segments: "Segmentos", regions: "Regi\xF5es" },
+      moment: { wander: "Vagando", alert: "Alerta", chase: "Persegui\xE7\xE3o", sprint: "Disparada", frenzy: "Frenesi", limp: "Mancando", crawl: "Rastejando" },
+      pose: { walk: "Andar", stand: "Parado" },
+      protection: { none: "Nenhuma", vest_police: "Colete policial", vest_military: "Colete militar", helmet_combat: "Capacete", turnout_gear: "Roupa de bombeiro", vest_helmet: "Colete e capacete" },
+      path: { rich: "Rico", lod0: "Instanciado LOD 0", lod1: "Instanciado LOD 1", lod2: "Instanciado LOD 2" },
+      age: { child: "Crian\xE7a", young: "Jovem", adult: "Adulto", elder: "Idoso" },
+      hit_preset: PRESETS_PT
+    },
+    layers: { capsules: "C\xE1psulas de acerto", joints: "Juntas", bleed: "Pontos de sangramento", eyes_only: "S\xF3 os olhos", speed: "Vetores de velocidade" },
+    metrics: { bodies: "Corpos", instances: "Inst\xE2ncias", triangles: "Tri\xE2ngulos", draw_calls: "Chamadas de desenho", bake_ms: "Tempo de assar", speed: "Velocidade do selecionado", vitality: "Vitalidade", bleed: "Taxa de sangramento", segments_hp: "Vida dos segmentos", last_crossed: "Corpos atravessados pelo \xFAltimo tiro", last_energy: "Energia que ficou" },
+    scenarios: {
+      region_x_caliber: "Regi\xE3o x calibre",
+      cut_at_every_joint: "Um corte em cada junta",
+      broken_bone_dangles: "Osso quebrado balan\xE7a",
+      leg_limp_crawl: "Perna: manca, depois rasteja",
+      head_kill: "A cabe\xE7a mata",
+      grenade_by_radius: "Granada por raio",
+      penetration_line: "Penetra\xE7\xE3o em fila de 5",
+      age_0_3: "Decomposi\xE7\xE3o de 0 a 3",
+      vest_and_helmet: "Colete e capacete",
+      bite_to_turn: "Mordida, febre, del\xEDrio, vira (crian\xE7a tamb\xE9m)",
+      benchmark_1000: "1000 corpos contra o or\xE7amento de tri\xE2ngulos"
+    },
+    log: { crossed: "Golpe: {bodies} corpos atravessados, {energy} da energia ficou", turned: "{from} virou {to}" }
+  }
+};
+
+// src/test-area/module.ts
+var CHARACTERS_AREA_ID = "characters_area";
+var ZOMBIE_ITEM_PREFIX = "zombie_";
+var PERSON_ITEM_PREFIX = "person_";
+var LANE_ITEM_COUNT = 5;
+var GAIT_MOMENT_STRIDE = 1.4;
+var DEFAULT_TRIANGLE_BUDGET = [2500, 800, 250];
+var MOMENTS_WITH_LIMP = /* @__PURE__ */ new Set(["limp", "crawl"]);
+function createCharactersTestModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const text = TEXT[locale] ?? TEXT["pt-BR"];
+  const undeadTypes = options.undeadTypes ?? [];
+  const professions = options.professions ?? [];
+  const settings = { decay: 0, age: "adult", penetration: "physical", deathRule: "vitality-or-head", detail: "segments", moment: "wander", pose: "walk", cascade: true, hit: "9x19", protection: "none" };
+  const makeKit = () => options.createKit ? options.createKit({ penetration: settings.penetration, deathRule: settings.deathRule }) : createCharacters({ ...options.packs ? { packs: options.packs } : {}, penetration: settings.penetration, damage: { deathRule: settings.deathRule } });
+  let kit = makeKit();
+  let undead = options.createUndead ? options.createUndead(kit) : null;
+  const random = createRng3(options.seed ?? 1);
+  let seedCounter = 100;
+  let host = null;
+  let three = null;
+  let best = null;
+  let people = null;
+  let wounds = null;
+  let crowd = null;
+  let selected = null;
+  let time = 0;
+  let lastCrossed = 0;
+  let lastEnergy = 1;
+  const entries = /* @__PURE__ */ new Map();
+  const builtOf = /* @__PURE__ */ new WeakMap();
+  const overlays = /* @__PURE__ */ new Map();
+  const gaits = Object.fromEntries(undeadTypes.map((card) => [card.name["pt-BR"] ?? card.id, card.gait]));
+  const animator = createRigAnimator({ gaits });
+  const typeName = (card) => card.name["pt-BR"] ?? card.id;
+  const eyeOf = (card) => parseInt(card.eye.color, 16);
+  const ensureBuilders = (THREE) => {
+    three = THREE;
+    best ?? (best = createBestBuilder(THREE, { types: undeadTypes.map((card) => ({ name: typeName(card), eye: eyeOf(card) })), random }));
+    people ?? (people = createPersonBuilder(THREE, { random, createCanvas: () => document.createElement("canvas") }));
+  };
+  const nextSeed = () => seedCounter += 1;
+  const protectionList = () => settings.protection === "none" ? [] : settings.protection === "vest_helmet" ? ["vest_police", "helmet_combat"] : [settings.protection];
+  const createCharacter = (kind, cardId, id) => {
+    const seed = nextSeed();
+    const common = { seed, id, age: settings.age, protection: protectionList(), detail: settings.detail };
+    if (kind === "zombie" && undead) return undead.create(common, { type: cardId });
+    return kit.create({ ...common, kind: kind === "zombie" ? cardId : "person", ...kind === "person" ? { preset: cardId } : {} });
+  };
+  const trackEntry = (entry) => {
+    if (entry.body) wounds?.track(entry.body);
+  };
+  const wrap = (entry, character) => {
+    const syncTransform = () => {
+      const root = entry.root;
+      character.setTransform([root.position.x, root.position.y, root.position.z], [root.quaternion.x, root.quaternion.y, root.quaternion.z, root.quaternion.w]);
+    };
+    const draw = (events) => {
+      if (entry.body) for (const event of events) wounds?.handle(entry.body, event);
+    };
+    return Object.create(character, {
+      hit: {
+        value: (hit) => {
+          syncTransform();
+          selected = entry;
+          const events = character.hit(hit);
+          draw(events);
+          const report = character.lastHit;
+          lastCrossed = report?.through ? 2 : 1;
+          lastEnergy = report && "exitEnergy" in report ? report.exitEnergy : lastEnergy;
+          return events;
+        }
+      },
+      update: {
+        value: (dt) => {
+          syncTransform();
+          const events = character.update(dt);
+          draw(events);
+          return events;
+        }
+      },
+      reset: {
+        value: () => {
+          character.reset();
+          entry.root.visible = true;
+        }
+      }
+    });
+  };
+  const makeItem = (kind, cardId, name) => ({
+    id: `${kind === "zombie" ? ZOMBIE_ITEM_PREFIX : PERSON_ITEM_PREFIX}${cardId}`,
+    name,
+    movable: false,
+    build: (THREE) => {
+      ensureBuilders(THREE);
+      const seed = nextSeed();
+      if (kind === "zombie") {
+        const card = undeadTypes.find((entry) => entry.id === cardId);
+        const root = best.build({ type: typeName(card), seed, decay: settings.decay });
+        builtOf.set(root, { kind, cardId, built: root });
+        return root;
+      }
+      const profession = professions.find((entry) => entry.id === cardId);
+      const built = people.build(profession ? personSpecOf(profession) : { skin: 12882032, hair: { s: "short", c: 2236962 }, top: { c: 4478310, sl: "long" }, pants: { c: 3355443 }, shoes: 1118481 });
+      if (!built.root.userData.rig) built.root.userData.rig = built;
+      builtOf.set(built.root, { kind, cardId, built });
+      return built.root;
+    },
+    impl: (root, id) => {
+      const object = root;
+      const made = builtOf.get(object);
+      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 };
+      entry.character = wrap(entry, character);
+      entries.set(id, entry);
+      selected ?? (selected = entry);
+      trackEntry(entry);
+      return entry.character;
+    }
+  });
+  const speedOf = (entry) => {
+    const traits = undead?.traitsOf(entry.character);
+    if (!traits || !undead) return entry.kind === "person" ? 1.4 : 0;
+    const moment = settings.moment;
+    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);
+    overlays.clear();
+  };
+  const overlayFor = (layer, entry) => {
+    if (!three) return null;
+    const group = new three.Group();
+    const material = new three.MeshBasicMaterial({ color: layer === "capsules" ? 4513279 : layer === "joints" ? 16772676 : 16729190, wireframe: layer === "capsules", depthTest: false, transparent: true, opacity: 0.8 });
+    if (layer === "capsules") {
+      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);
+      }
+    } 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);
+      }
+    } else if (layer === "speed") {
+      const length = Math.max(0.1, speedOf(entry));
+      const arrow = new three.ArrowHelper(new three.Vector3(0, 0, 1), new three.Vector3(0, 2.1, 0), length, 6750054);
+      group.add(arrow);
+    } else return null;
+    group.renderOrder = 10;
+    return group;
+  };
+  const refreshLayers = () => {
+    clearOverlays();
+    if (!host?.bench) return;
+    for (const layer of ["capsules", "joints", "speed"]) {
+      if (!host.bench.layer(layer)) continue;
+      for (const entry of entries.values()) {
+        const overlay = overlayFor(layer, entry);
+        if (!overlay) continue;
+        entry.root.add(overlay);
+        overlays.set(`${layer}:${entry.id}`, overlay);
+      }
+    }
+    const eyesOnly = host.bench.layer("eyes_only");
+    for (const entry of entries.values()) entry.eyes?.isolate(eyesOnly);
+  };
+  const animate = (entry, dt) => {
+    const { root, character } = entry;
+    if (!character.alive) {
+      entry.tilt = Math.min(1, entry.tilt + dt * 2);
+      const rig = root.userData.rig;
+      if (rig) rig.fig.rotation.x = -entry.tilt * 1.35;
+      entry.eyes?.off();
+      return;
+    }
+    const speed = settings.pose === "walk" ? speedOf(entry) : 0;
+    entry.walk += dt * speed;
+    if (entry.kind === "person") people.pose(entry.built, false, settings.pose === "walk" ? 1 : 0, time);
+    else if (settings.pose === "walk") {
+      animator.animate(root, time, { speed: speed || GAIT_MOMENT_STRIDE });
+      if (settings.cascade) animator.cascade(root.userData.rig, dt);
+    }
+    if (entry.body) {
+      wounds?.setWalkPhase(entry.body, settings.pose === "walk" ? entry.walk : void 0);
+      wounds?.applyLimp(entry.body);
+    }
+  };
+  const selectedOrFirst = () => selected ?? entries.values().next().value ?? null;
+  const fireOn = (entry) => {
+    const preset2 = hitPresetOf(settings.hit);
+    const p = entry.root.position;
+    entry.character.hit(hitFor(preset2, [p.x, p.y, p.z], 1.3, kit.calibers));
+  };
+  const ensureCrowd = () => {
+    if (crowd) return crowd;
+    const built = three;
+    const builders = {
+      buildBest: (spec, lod) => {
+        ;
+        best.setLOD(lod);
+        return best.build(spec);
+      },
+      topMaterial: () => best.topM()
+    };
+    const wanted = options.crowdTypes ?? ["walker", "runner"];
+    const variantTypes = undeadTypes.map((card, index) => ({ id: card.id, name: typeName(card), index })).filter((type) => wanted.includes(type.id));
+    crowd = createCrowd(built, builders, variantTypes, Object.fromEntries(undeadTypes.map((card) => [card.id, eyeOf(card)])), random);
+    if (host) host.scene.add(crowd.group);
+    return crowd;
+  };
+  const onChange = (change) => {
+    if (change.kind === "layer") {
+      refreshLayers();
+      return;
+    }
+    if (change.kind === "action") {
+      const target = selectedOrFirst();
+      if (change.id === "heal") target?.character.reset();
+      else if (change.id === "kill" && target) target.character.hit({ type: "ballistic", point: [target.root.position.x, 1.7, target.root.position.z + 0.3], direction: [0, 0, -1], part: "head", energy: 3504, mass: 9.7, caliber: 7.8 });
+      else if (change.id === "infect" && target && undead?.infect) {
+        const infection = undead.infect("bite", () => 0);
+        if (infection) {
+          infection.advance(1e3);
+          if (infection.reanimated) target.character = wrap(target, undead.turn(target.character));
+        }
+      } else if (change.id === "fire_preset" && target) fireOn(target);
+      else if (change.id === "spawn_100" || change.id === "spawn_1000") {
+        ensureBuilders(host?.THREE ?? three);
+        ensureCrowd().spawn(change.id === "spawn_100" ? 100 : 1e3);
+      }
+      return;
+    }
+    const value = change.value;
+    switch (change.id) {
+      case "decay":
+        settings.decay = Number(value);
+        break;
+      case "age":
+        settings.age = String(value);
+        break;
+      case "penetration":
+        settings.penetration = String(value);
+        kit = makeKit();
+        undead = options.createUndead ? options.createUndead(kit) : null;
+        break;
+      case "death_rule":
+        settings.deathRule = String(value);
+        kit = makeKit();
+        undead = options.createUndead ? options.createUndead(kit) : null;
+        break;
+      case "detail":
+        settings.detail = String(value);
+        break;
+      case "moment":
+        settings.moment = String(value);
+        refreshLayers();
+        break;
+      case "pose":
+        settings.pose = String(value);
+        break;
+      case "cascade":
+        settings.cascade = Boolean(value);
+        break;
+      case "hit_preset":
+        settings.hit = String(value);
+        break;
+      case "protection":
+        settings.protection = String(value);
+        break;
+      default:
+        break;
+    }
+  };
+  const choice = (id, ids, fallback) => ({
+    kind: "choice",
+    id,
+    name: text.controls[id],
+    options: ids.map((optionId) => ({ id: optionId, name: text.options[id][optionId] ?? optionId })),
+    default: fallback
+  });
+  const withHint = (control, hint) => hint ? { ...control, hint } : control;
+  const scenarioDeps = {
+    text: text.scenarios,
+    kit: () => kit,
+    undead: () => undead,
+    three: () => three ?? host?.THREE,
+    ensureBuilders,
+    buildZombie: (name, decay) => best.build({ type: name, seed: 7, decay }),
+    typeNames: () => undeadTypes.map(typeName),
+    crowd: () => {
+      ensureBuilders(three ?? host?.THREE);
+      return ensureCrowd();
+    },
+    random,
+    triangleBudget: options.triangleBudget ?? DEFAULT_TRIANGLE_BUDGET,
+    triangleBudgetSoftFar: options.triangleBudget === void 0
+  };
+  const lane = () => professions.slice(0, LANE_ITEM_COUNT).map((profession) => `${PERSON_ITEM_PREFIX}${profession.id}`);
+  return {
+    id: CHARACTERS_AREA_ID,
+    name: text.name,
+    group: text.group,
+    get entries() {
+      return entries;
+    },
+    get crowd() {
+      return crowd;
+    },
+    items: () => [
+      ...undeadTypes.map((card) => makeItem("zombie", card.id, card.name[locale] ?? card.id)),
+      ...professions.map((profession) => makeItem("person", profession.id, profession.name[locale] ?? profession.id))
+    ],
+    area: () => {
+      const placements = [];
+      undeadTypes.forEach((card, index) => placements.push({ item: `${ZOMBIE_ITEM_PREFIX}${card.id}`, position: [-6 + index * 1.1, 0, 3], rotationY: Math.PI }));
+      professions.forEach((profession, index) => placements.push({ item: `${PERSON_ITEM_PREFIX}${profession.id}`, position: [-5.45 + index * 1.1, 0, 7], rotationY: Math.PI }));
+      lane().forEach((item, index) => placements.push({ item, position: [0, 0, -3 - index * 1.4], rotationY: 0 }));
+      return { placements, view: { eye: [0, 5.5, 13], target: [0, 0.6, 3] } };
+    },
+    controls: () => [
+      withHint({ kind: "number", id: "decay", name: text.controls.decay, min: 0, max: 3, step: 1, default: 0 }, text.hints.decay),
+      choice("age", ["child", "young", "adult", "elder"], "adult"),
+      withHint(choice("penetration", ["physical", "team-game"], "physical"), text.hints.penetration),
+      withHint(choice("death_rule", ["vitality-or-head", "head-only"], "vitality-or-head"), text.hints.death_rule),
+      withHint(choice("detail", ["segments", "regions"], "segments"), text.hints.detail),
+      withHint(choice("moment", ["wander", "alert", "chase", "sprint", "frenzy", "limp", "crawl"], "wander"), text.hints.moment),
+      choice("pose", ["walk", "stand"], "walk"),
+      { kind: "boolean", id: "cascade", name: text.controls.cascade, default: true },
+      withHint(choice("hit_preset", HIT_PRESETS.map((preset2) => preset2.id), "9x19"), text.hints.hit_preset),
+      withHint(choice("protection", ["none", "vest_police", "vest_military", "helmet_combat", "turnout_gear", "vest_helmet"], "none"), text.hints.protection),
+      { kind: "action", id: "fire_preset", name: text.actions.fire_preset },
+      { kind: "action", id: "heal", name: text.actions.heal },
+      { kind: "action", id: "kill", name: text.actions.kill },
+      { kind: "action", id: "infect", name: text.actions.infect },
+      { kind: "action", id: "spawn_100", name: text.actions.spawn_100 },
+      { kind: "action", id: "spawn_1000", name: text.actions.spawn_1000 }
+    ],
+    layers: () => ["capsules", "joints", "bleed", "eyes_only", "speed"].map((id) => ({ id, name: text.layers[id], default: false })),
+    metrics: () => [
+      { id: "bodies", name: text.metrics.bodies, read: () => entries.size },
+      { id: "instances", name: text.metrics.instances, read: () => crowd?.count ?? 0 },
+      { id: "triangles", name: text.metrics.triangles, max: 25e4, read: () => Math.round(crowd?.triangles ?? 0) },
+      { id: "draw_calls", name: text.metrics.draw_calls, read: () => crowd?.drawCalls ?? 0 },
+      { id: "bake_ms", name: text.metrics.bake_ms, unit: "ms", digits: 0, read: () => crowd?.bakeMs ?? 0 },
+      { id: "speed_now", name: text.metrics.speed, unit: "m/s", digits: 2, read: () => {
+        const entry = selectedOrFirst();
+        return entry ? speedOf(entry) : 0;
+      } },
+      { id: "vitality", name: text.metrics.vitality, read: () => selectedOrFirst()?.character.state().body?.vitality ?? 0 },
+      { id: "bleed_rate", name: text.metrics.bleed, digits: 3, read: () => selectedOrFirst()?.character.bleeders().reduce((sum, bleeder) => sum + (bleeder.rate ?? 0), 0) ?? 0 },
+      { id: "segments_hp", name: text.metrics.segments_hp, read: () => Math.round(selectedOrFirst()?.character.segments.reduce((sum, segment) => sum + segment.hp, 0) ?? 0) },
+      { id: "last_crossed", name: text.metrics.last_crossed, read: () => lastCrossed },
+      { id: "last_energy", name: text.metrics.last_energy, digits: 2, read: () => lastEnergy }
+    ],
+    scenarios: () => createScenarios(scenarioDeps),
+    attach(lent) {
+      host = lent;
+      ensureBuilders(lent.THREE);
+      const scene = lent.scene;
+      const bridge = options.fluids ? createFluidsBridge({ sink: options.fluids }) : void 0;
+      wounds = createWounds(lent.THREE, { random, scene, groundAt: (x, z) => lent.groundAt(x, z), ...bridge ? { bridge } : {} });
+      for (const entry of entries.values()) trackEntry(entry);
+      const stopChange = lent.bench?.onChange(onChange);
+      const stopFrame = lent.onFrame((dt) => {
+        time += dt;
+        for (const [id, entry] of entries) {
+          if (!entry.root.parent) {
+            entries.delete(id);
+            continue;
+          }
+          animate(entry, dt);
+        }
+        wounds?.update(dt);
+        crowd?.update(dt, lent.camera);
+      });
+      return () => {
+        stopChange?.();
+        stopFrame();
+        clearOverlays();
+        wounds?.dispose();
+        wounds = null;
+        if (crowd) {
+          crowd.group.parent?.remove(crowd.group);
+          crowd = null;
+        }
+        host = null;
+      };
+    }
+  };
+}
+
+// src/test-area/material.ts
+var BODY_MATERIAL_DEF = {
+  id: "flesh",
+  density: 1050,
+  hpPerKg: 15,
+  penetration: 1.2,
+  ductility: 0.8,
+  fracture: "tear",
+  fragmentSize: [0.03, 0.1],
+  damageScale: { slash: 1.6 },
+  hitDebris: "drips",
+  breakDebris: "drips",
+  thermal: { ignitionC: 260, flameC: 700, fuelFraction: 0.25, burnRate: 4e-3, conductivity: 0.5, heatCapacity: 3.5, smoke: "grey" },
+  tags: ["organic", "body"],
+  compressive: 1e3
+};
+var registerBodyMaterial = (world) => {
+  if (!world.materials.has(BODY_MATERIAL_DEF.id)) world.materials.set(BODY_MATERIAL_DEF.id, BODY_MATERIAL_DEF);
+};
+export {
+  BAKE_NEUTRAL_POSE,
+  BODY_CHUNK,
+  BODY_MATERIAL_DEF,
+  CHARACTERS_AREA_ID,
+  EXTRAS,
+  FACE_FEATURES,
+  HAND_ITEMS,
+  HATS,
+  HIT_PRESETS,
+  LOD_BAKE,
+  LOD_BATCH_CAPACITY,
+  LOD_CASTS_SHADOW,
+  LOD_DISTANCES,
+  LOD_SEGMENTS,
+  PENDULUM,
+  PERSON_ITEM_PREFIX,
+  ZOMBIE_ITEM_PREFIX,
+  bakeBody,
+  bakeVariants,
+  blobGeometry,
+  blobRadii,
+  buildInstancedBody,
+  createBestBuilder,
+  createBodyBatch,
+  createBodyChunk,
+  createBodyMaterial,
+  createCharactersTestModule,
+  createEye,
+  createFluidsBridge,
+  createFlyingLimbs,
+  createFlyingPieces,
+  createGlowTexture,
+  createPendulum,
+  createPersonBuilder,
+  createRigAnimator,
+  createVariantBatches,
+  createWoundMaterials,
+  createWounds,
+  exitWound,
+  explodeChunks,
+  findEyes,
+  gouge,
+  jointsOf,
+  lodAt,
+  makeCut,
+  makeStump,
+  registerBodyMaterial,
+  ringWound,
+  starGeometry,
+  stepPendulum,
+  woundBodyOf,
+  woundDecal
+};
+//# sourceMappingURL=index.js.map