@adatechnology/game-animals-three 0.3.8 → 0.4.0

package/dist/index.global.js

@@ -45,6 +45,618 @@ var GameAnimalsThree = (() => {
     updateSplit: () => updateSplit
   });
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var KIT_ORIGIN_KEY = "kitOrigin";
+  function markKitOrigin(object2, origin) {
+    const node = object2;
+    node.userData = node.userData ?? {};
+    node.userData[KIT_ORIGIN_KEY] = { ...origin };
+    return object2;
+  }
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing2) => `land_${surface}_${landing2}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+  var SWING_LEAD_SECONDS = { punch: 0.07, kick: 0.09, shove: 0, blade: 0.05, blunt: 0.1, chop: 0.11 };
+
+  // ../game-audio/dist/chunk-DZITVFMJ.js
+  var DISTANCE_CURVES = {
+    /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
+    game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
+    /** The game's `grito`: `1 / (1 + d² × 0.006)`, silent below 0.02 (jogo L62129–62130). */
+    game_scream: { model: "inverse_square", k: 6e-3, minGain: 0.02 },
+    /** The game's `voz`: `1 / (1 + d² × 0.01)`, silent below 0.02 (jogo L62146–62147). */
+    game_voice: { model: "inverse_square", k: 0.01, minGain: 0.02 },
+    /** The game's `boom`: `1.4 / (1 + d² × 0.002)`, never silent (jogo L68280). */
+    game_boom: { model: "inverse_square", k: 2e-3, scale: 1.4 },
+    /** The art scene's `outAt`: `vol / (1 + d² × 0.008)` (cena L1320). */
+    art_scene: { model: "inverse_square", k: 8e-3 },
+    /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
+    animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
+  };
+  var game_sfx_default = {
+    sources: ["jogo:L62089-62107"],
+    note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
+    classes: [
+      { id: "pistol", team: "pistola", bus: "weapons", cutoff: 1800, gain: 0.9, seconds: 0.18 },
+      { id: "shotgun", team: "escopeta", bus: "weapons", cutoff: 900, gain: 1.2, seconds: 0.35 },
+      { id: "rifle", team: "fuzil", bus: "weapons", cutoff: 1400, gain: 1.1, seconds: 0.28 },
+      { id: "long_rifle", team: "rifle", bus: "weapons", cutoff: 1100, gain: 1.3, seconds: 0.45 },
+      { id: "impact", team: "impacto", bus: "world", cutoff: 2500, gain: 0.25, seconds: 0.05 },
+      { id: "flesh", team: "carne", bus: "world", cutoff: 600, gain: 0.35, seconds: 0.08 },
+      { id: "step", team: "passo", bus: "world", cutoff: 400, gain: 0.08, seconds: 0.05 },
+      { id: "glass", team: "vidro", bus: "world", cutoff: 5e3, gain: 0.5, seconds: 0.3 },
+      { id: "wood", team: "madeira", bus: "world", cutoff: 700, gain: 0.5, seconds: 0.2 },
+      { id: "reload", team: "recarga", bus: "weapons", cutoff: 3e3, gain: 0.15, seconds: 0.06 },
+      { id: "empty", team: "vazio", bus: "weapons", cutoff: 4e3, gain: 0.12, seconds: 0.03 },
+      { id: "explosion", team: "explosao", bus: "world", cutoff: 200, gain: 1.6, seconds: 1.4 }
+    ],
+    fallback: { id: "unknown", team: "(any other name)", bus: "world", cutoff: 1e3, gain: 0.5, seconds: 0.1 }
+  };
+  var GAME_SFX = game_sfx_default;
+  var GAME_SFX_CLASSES = GAME_SFX.classes;
+  var GAME_SFX_FALLBACK = GAME_SFX.fallback;
+  function noiseClassRecipe(row, id = `sfx_${row.id}`) {
+    return {
+      id,
+      bus: row.bus,
+      order: "burst",
+      duration: row.seconds,
+      tail: 0.05,
+      layers: [
+        {
+          source: { kind: "noise", offset: "random" },
+          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: row.cutoff } }] },
+          envelope: [
+            [0, row.gain, "set"],
+            ["1d", 1e-3, "exp", "fixed"]
+          ]
+        }
+      ],
+      falloff: DISTANCE_CURVES.game_sfx,
+      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
+    };
+  }
+  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
+  var mix_profiles_default = [
+    {
+      id: "game",
+      master: 0.5,
+      noise: { seconds: 1.5, create: "lazy" },
+      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+    },
+    {
+      id: "art_scene",
+      master: 0.85,
+      compressor: { threshold: -12, ratio: 5 },
+      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
+      noise: { seconds: 2, create: "eager" },
+      sources: [
+        "cena:L1308 compressor -12 dB, ratio 5",
+        "cena:L1309 master 0.85",
+        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
+        "cena:L1311 wet 0.4",
+        "cena:L1312 noise 2 s made with the chain"
+      ]
+    }
+  ];
+  var MIX_PROFILES = Object.fromEntries(
+    mix_profiles_default.map((profile) => [profile.id, profile])
+  );
+  var BENCH_BANK = {
+    id: "audio_bench",
+    sounds: [
+      {
+        id: "bench_ping",
+        bus: "ui",
+        pan: true,
+        duration: 0.25,
+        layers: [
+          {
+            gain: 0.5,
+            wet: 0.3,
+            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
+      },
+      {
+        id: "bench_hiss",
+        bus: "ui",
+        pan: true,
+        duration: [0.3, 0.9],
+        layers: [
+          {
+            gain: 0.4,
+            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
+            envelope: [
+              [0, 1e-4, "set", "fixed"],
+              [2e-3, 1, "exp"],
+              ["1d", 1e-4, "exp", "fixed"]
+            ]
+          }
+        ],
+        falloff: DISTANCE_CURVES.art_scene,
+        sources: ["sdk: bench probe, a highpass hiss of random length"]
+      }
+    ]
+  };
+
+  // ../game-audio/dist/index.js
+  var ATTACK = 2e-3;
+  function lengthOf(d, attack) {
+    if (typeof d === "number") return attack + d;
+    if (Array.isArray(d)) return [attack + d[0], attack + d[1]];
+    return { ...d, add: (d.add ?? 0) + attack };
+  }
+  var envelope = (attack) => [
+    [0, 1e-4, "set", "fixed"],
+    [attack, 1, "exp"],
+    ["1d", 1e-4, "exp", "fixed"]
+  ];
+  function sceneNoise(o) {
+    const a = o.a ?? ATTACK;
+    const over = typeof o.d === "number" ? o.d : 0;
+    return {
+      filters: {
+        mode: "serial",
+        bank: [{ type: o.type ?? "lowpass", frequency: o.f2 === void 0 ? { set: o.f } : { set: o.f, to: o.f2, curve: "exp", over }, q: o.q ?? 0.7 }]
+      },
+      duration: lengthOf(o.d, a),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
+      envelope: envelope(a)
+    };
+  }
+  function sceneTone(o) {
+    return {
+      source: { kind: "osc", wave: o.wave ?? "sine", frequency: { from: o.f, to: o.f2 ?? "from", curve: "exp", over: "duration" } },
+      duration: lengthOf(o.d, ATTACK),
+      gain: o.vol,
+      ...o.delay === void 0 ? {} : { at: o.delay },
+      ...o.wet === void 0 ? {} : { wet: o.wet },
+      envelope: envelope(ATTACK)
+    };
+  }
+  function sceneVoice(o) {
+    return {
+      duration: lengthOf(o.d, 0),
+      gain: o.vol,
+      wet: 0.45,
+      source: {
+        kind: "formant_voice",
+        wave: o.wave ?? "sawtooth",
+        frequency: { from: o.f0, to: o.f1, curve: "linear", over: "duration" },
+        vibrato: { rate: [4, 10], depth: 0.08 },
+        formants: [
+          { frequency: o.fA, q: 4 },
+          { frequency: o.fB, q: 6 }
+        ],
+        breath: { frequency: o.fB, q: 1.1, gain: o.noise },
+        mix: 3.2
+      },
+      envelope: [
+        [0, 1e-4, "set", "fixed"],
+        [0.1, 1, "exp"],
+        ["0.6d", 1, "set"],
+        ["1d", 1e-4, "exp", "fixed"]
+      ]
+    };
+  }
+  var TAKES = [
+    { f: 1, t: 1, v: 1 },
+    { f: 1.08, t: 0.9, v: 0.92 },
+    { f: 0.93, t: 1.12, v: 1.05 },
+    { f: 1.03, t: 1.05, v: 0.88 }
+  ];
+  var FOOTSTEP_FALLOFF = { model: "inverse_square", k: 0.03, cutoffK: 0.03, minGain: 4e-3 };
+  var BODY_FALLOFF = { model: "inverse_square", k: 0.012, cutoffK: 0.015, minGain: 4e-3 };
+  var SURFACES = {
+    concrete: { heel: { f: 95, d: 0.05, vol: 0.55 }, roll: { type: "bandpass", f: 2300, q: 1.1, d: 0.05, vol: 0.38 }, grains: { count: 2, f: 4200, q: 2, spread: 0.04, vol: 0.08 } },
+    asphalt: { heel: { f: 90, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 1700, q: 0.9, d: 0.06, vol: 0.36 }, grains: { count: 4, f: 3600, q: 2.5, spread: 0.06, vol: 0.1 } },
+    wood: { heel: { f: 130, d: 0.08, vol: 0.55 }, roll: { type: "lowpass", f: 1300, q: 0.8, d: 0.06, vol: 0.3 }, ring: [{ f: 210, d: 0.1, vol: 0.18 }, { f: 470, d: 0.06, vol: 0.06 }] },
+    tile: { heel: { f: 110, d: 0.04, vol: 0.45 }, roll: { type: "bandpass", f: 3600, q: 2, d: 0.03, vol: 0.42 }, ring: [{ f: 1900, d: 0.03, vol: 0.05 }] },
+    dirt: { heel: { f: 75, d: 0.06, vol: 0.45 }, roll: { type: "lowpass", f: 750, q: 0.7, d: 0.09, vol: 0.4 }, grains: { count: 3, f: 1800, q: 1.5, spread: 0.07, vol: 0.06 } },
+    grass: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "highpass", f: 2600, q: 0.7, d: 0.13, vol: 0.28 }, grains: { count: 4, f: 5200, q: 1.2, spread: 0.1, vol: 0.07 } },
+    gravel: { heel: { f: 80, d: 0.05, vol: 0.4 }, roll: { type: "lowpass", f: 950, q: 0.8, d: 0.1, vol: 0.3 }, grains: { count: 8, f: 2600, q: 3, spread: 0.13, vol: 0.2 } },
+    sand: { heel: { f: 65, d: 0.06, vol: 0.3 }, roll: { type: "bandpass", f: 1500, q: 0.6, d: 0.16, vol: 0.3 }, grains: { count: 5, f: 4800, q: 1.5, spread: 0.12, vol: 0.05 } },
+    metal: { heel: { f: 120, d: 0.05, vol: 0.5 }, roll: { type: "bandpass", f: 2800, q: 1.5, d: 0.03, vol: 0.25 }, ring: [{ f: 420, d: 0.25, vol: 0.16 }, { f: 1130, d: 0.18, vol: 0.09 }, { f: 2470, d: 0.1, vol: 0.04 }] },
+    water: { heel: { f: 70, d: 0.04, vol: 0.25 }, roll: { type: "bandpass", f: 3e3, q: 1.2, d: 0.1, vol: 0.18 }, splash: { f: 1100, f2: 380, d: 0.22, vol: 0.55 }, grains: { count: 4, f: 2400, q: 6, spread: 0.18, vol: 0.12 } },
+    glass: { heel: { f: 90, d: 0.04, vol: 0.4 }, roll: { type: "highpass", f: 4500, q: 0.8, d: 0.06, vol: 0.2 }, grains: { count: 9, f: 6200, q: 5, spread: 0.12, vol: 0.22 }, ring: [{ f: 3900, d: 0.04, vol: 0.04 }, { f: 5300, d: 0.03, vol: 0.03 }] },
+    carpet: { heel: { f: 70, d: 0.05, vol: 0.32 }, roll: { type: "lowpass", f: 420, q: 0.7, d: 0.07, vol: 0.3 } }
+  };
+  var GAITS = {
+    walk: { vol: 1, bright: 1, toe: 0.075, short: 1 },
+    run: { vol: 1.35, bright: 1.25, toe: 0.035, short: 0.75 }
+  };
+  var grainLayers = (g, take, start, scale) => Array.from(
+    { length: g.count },
+    (_, i) => sceneNoise({ type: "bandpass", f: [g.f * take.f * 0.85, g.f * take.f * 1.15], q: g.q, d: [8e-3, 0.02], vol: g.vol * scale * take.v, delay: start + (i + 0.5) / g.count * g.spread * take.t })
+  );
+  var ringLayers = (rings, take, scale, at = 0) => rings.map((r) => sceneTone({ f: r.f * take.f, d: r.d * take.t, vol: r.vol * scale * take.v, delay: at }));
+  function footLayers(surface, take, gait, weight = 1) {
+    const s = SURFACES[surface];
+    const toe = gait.toe * take.t;
+    return [
+      sceneTone({ f: s.heel.f * take.f * weight ** -0.3, f2: s.heel.f * take.f * 0.6, d: s.heel.d * gait.short * take.t * weight ** 0.5, vol: s.heel.vol * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: "lowpass", f: 500 * gait.bright, d: 0.02 * take.t, vol: 0.18 * gait.vol * take.v * weight ** 0.5 }),
+      sceneNoise({ type: s.roll.type, f: [s.roll.f * take.f * gait.bright * 0.92, s.roll.f * take.f * gait.bright * 1.08], q: s.roll.q, d: s.roll.d * gait.short * take.t * weight ** 0.3, vol: s.roll.vol * gait.vol * take.v, delay: toe }),
+      ...s.grains ? grainLayers(s.grains, take, toe * 0.5, gait.vol * weight ** 0.5) : [],
+      ...s.ring ? ringLayers(s.ring, take, gait.vol * weight ** 0.5) : [],
+      ...s.splash ? [sceneNoise({ type: "bandpass", f: s.splash.f * take.f, f2: s.splash.f2 * take.f, q: 1.4, d: s.splash.d * take.t * weight ** 0.4, vol: s.splash.vol * gait.vol * take.v * weight ** 0.5 })] : []
+    ];
+  }
+  var quieter = (level, layers) => layers.map((layer) => {
+    const gain = layer.gain ?? 1;
+    if (typeof gain === "number") return { ...layer, gain: gain * level };
+    if (Array.isArray(gain)) return { ...layer, gain: [gain[0] * level, gain[1] * level] };
+    return layer;
+  });
+  var recipe = (id, layers, falloff, bus = "world") => ({ id, bus, pan: true, layers, falloff, sources: ["sdk"] });
+  var takeId = (id, index) => `${id}_${String(index + 1).padStart(2, "0")}`;
+  function takes(id, layersOf, falloff, rate = [0.96, 1.04], bus) {
+    const sounds = TAKES.map((take, index) => recipe(takeId(id, index), layersOf(take, index), falloff, bus));
+    return { sounds, set: { id, variants: sounds.map((sound) => sound.id), rate } };
+  }
+  var footstep = (surface, gait) => takes(footstepSoundId(surface, gait), (take) => footLayers(surface, take, GAITS[gait]), FOOTSTEP_FALLOFF);
+  var LANDINGS = { light: { weight: 1.4, cloth: 0.12 }, heavy: { weight: 2.4, cloth: 0.22 } };
+  var LANDING_LEVEL = 0.65;
+  var landing = (surface, landing2) => takes(
+    `land_${surface}_${landing2}`,
+    (take) => quieter(LANDING_LEVEL, [
+      // both feet, a hair apart, then the knees taking the weight (a low body thump) and the clothes settling
+      ...footLayers(surface, take, GAITS.run, LANDINGS[landing2].weight),
+      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer) => ({ ...layer, at: (typeof layer.at === "number" ? layer.at : 0) + 0.018 * take.t })),
+      sceneTone({ f: 60 * take.f, f2: 38, d: 0.14 * LANDINGS[landing2].weight * take.t, vol: 0.22 * LANDINGS[landing2].weight ** 0.7 * take.v, delay: 0.02 }),
+      sceneNoise({ type: "bandpass", f: [1800, 2600], q: 0.8, d: 0.18, vol: LANDINGS[landing2].cloth * take.v, delay: 0.04 })
+    ]),
+    FOOTSTEP_FALLOFF
+  );
+  var whoosh = (blow, from, to, d, vol, q = 1.6) => (take) => [
+    // the air: a band sweeping up as the limb speeds up; it peaks `SWING_LEAD_SECONDS` in, the moment before the contact, then dies away
+    sceneNoise({ type: "bandpass", f: from * take.f, f2: to * take.f, q, a: SWING_LEAD_SECONDS[blow], d: d * take.t, vol: vol * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, a: SWING_LEAD_SECONDS[blow], d: d * take.t * 0.8, vol: vol * 0.35 * take.v })
+  ];
+  var fleshHit = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.slapF * take.f, q: 1.2, d: 0.03 * take.t, vol: o.slap * take.v }),
+    sceneNoise({ type: "highpass", f: 3500 * take.f, d: 0.012, vol: o.slap * 0.4 * take.v }),
+    sceneTone({ f: o.thudF * take.f, f2: o.thudF * 0.5, d: o.thudD * take.t, vol: o.thud * take.v }),
+    sceneNoise({ type: "lowpass", f: 600 * take.f, d: o.thudD * 1.2 * take.t, vol: o.thud * 0.5 * take.v }),
+    ...o.crack ? [sceneNoise({ type: "highpass", f: 2500, d: 0.015, vol: o.crack * take.v, delay: 6e-3 }), sceneTone({ wave: "square", f: 900 * take.f, f2: 300, d: 0.02, vol: o.crack * 0.15 * take.v, delay: 6e-3 })] : [],
+    ...o.wet ? [sceneNoise({ type: "bandpass", f: 1400 * take.f, f2: 500, q: 2.5, d: 0.12 * take.t, vol: o.wet * take.v, delay: 0.01 })] : []
+  ];
+  var knock = (o) => (take) => [
+    sceneNoise({ type: "bandpass", f: o.clickF * take.f, q: 1.5, d: 0.018, vol: o.click * take.v }),
+    ...o.tones.map(([f, d, vol]) => sceneTone({ f: f * take.f, d: d * take.t, vol: vol * take.v }))
+  ];
+  var voice = (o) => (take) => [
+    sceneVoice({ f0: o.f0 * take.f, f1: o.f1 * take.f, d: o.d * take.t, fA: o.fA * take.f, fB: o.fB * take.f, noise: o.noise, vol: o.vol * take.v })
+  ];
+  var BODY = {
+    jump: (take) => [
+      sceneNoise({ type: "bandpass", f: 900 * take.f, f2: 1700 * take.f, q: 1, a: 0.03, d: 0.12, vol: 0.18 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2200 * take.f, q: 0.8, d: 0.04, vol: 0.12 * take.v }),
+      sceneTone({ f: 85 * take.f, f2: 60, d: 0.04, vol: 0.2 * take.v })
+    ],
+    cloth_rustle: (take) => [
+      { ...sceneNoise({ type: "bandpass", f: 2400 * take.f, q: 0.8, a: 0.06, d: 0.22 * take.t, vol: 0.12 * take.v }), modulators: [{ target: "gain", wave: "triangle", rate: [9, 14], depth: 0.5 }] }
+    ],
+    body_fall: (take) => [
+      sceneTone({ f: 58 * take.f, f2: 35, d: 0.28 * take.t, vol: 0.9 * take.v }),
+      sceneNoise({ type: "lowpass", f: 480 * take.f, d: 0.3 * take.t, vol: 0.55 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, q: 1, d: 0.05, vol: 0.3 * take.v }),
+      // the limbs a moment later, and the clothes
+      sceneTone({ f: 75 * take.f, f2: 45, d: 0.12, vol: 0.4 * take.v, delay: 0.13 * take.t }),
+      sceneNoise({ type: "bandpass", f: 2200, q: 0.8, d: 0.2, vol: 0.12 * take.v, delay: 0.05 })
+    ],
+    fall_damage: (take) => [
+      ...BODY.body_fall(take),
+      sceneNoise({ type: "highpass", f: 2800, d: 0.02, vol: 0.35 * take.v, delay: 0.01 }),
+      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer) => ({ ...layer, at: 0.08 }))
+    ],
+    player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
+    player_breath_run: (take) => [
+      sceneNoise({ type: "bandpass", f: 1200 * take.f, q: 1, a: 0.08, d: 0.22 * take.t, vol: 0.25 * take.v }),
+      sceneNoise({ type: "bandpass", f: 900 * take.f, q: 1, a: 0.06, d: 0.26 * take.t, vol: 0.3 * take.v, delay: 0.3 * take.t })
+    ],
+    player_death: voice({ f0: 135, f1: 68, d: 1, fA: 560, fB: 980, noise: 0.35, vol: 0.4 }),
+    bite: (take) => [
+      sceneNoise({ type: "highpass", f: 2600, d: 0.015, vol: 0.4 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1600 * take.f, f2: 450, q: 2.2, d: 0.16 * take.t, vol: 0.55 * take.v, delay: 0.01 }),
+      sceneNoise({ type: "bandpass", f: 3200 * take.f, f2: 1800, q: 1.2, d: 0.22 * take.t, vol: 0.25 * take.v, delay: 0.09 }),
+      sceneTone({ f: 120 * take.f, f2: 70, d: 0.06, vol: 0.3 * take.v })
+    ],
+    grab: (take) => [
+      sceneNoise({ type: "bandpass", f: 1900 * take.f, q: 0.9, a: 4e-3, d: 0.13 * take.t, vol: 0.32 * take.v }),
+      sceneTone({ f: 95 * take.f, f2: 60, d: 0.07, vol: 0.3 * take.v }),
+      sceneNoise({ type: "lowpass", f: 700, d: 0.08, vol: 0.2 * take.v })
+    ],
+    punch_swing: whoosh("punch", 450, 1500, 0.16, 0.9),
+    punch_hit_body: fleshHit({ slap: 0.55, slapF: 1500, thud: 0.6, thudF: 115, thudD: 0.09 }),
+    punch_hit_face: fleshHit({ slap: 0.75, slapF: 2300, thud: 0.45, thudF: 150, thudD: 0.07, crack: 0.25 }),
+    punch_hit_object: knock({ clickF: 1800, click: 0.3, tones: [[210, 0.04, 0.25]] }),
+    kick_swing: whoosh("kick", 280, 950, 0.22, 1, 1.3),
+    kick_hit: fleshHit({ slap: 0.45, slapF: 1100, thud: 0.85, thudF: 82, thudD: 0.14 }),
+    kick_hit_object: knock({ clickF: 1e3, click: 0.3, tones: [[92, 0.08, 0.5]] }),
+    shove_two_hands: (take) => [
+      sceneNoise({ type: "bandpass", f: 950 * take.f, q: 0.9, a: 0.01, d: 0.13 * take.t, vol: 0.38 * take.v }),
+      sceneTone({ f: 100 * take.f, f2: 60, d: 0.1 * take.t, vol: 0.45 * take.v }),
+      sceneNoise({ type: "bandpass", f: 2300, q: 0.8, d: 0.16, vol: 0.12 * take.v, delay: 0.03 })
+    ],
+    knife_swing: whoosh("blade", 1900, 4600, 0.12, 1.1, 2.2),
+    knife_stab: fleshHit({ slap: 0.2, slapF: 1200, thud: 0.4, thudF: 160, thudD: 0.06, wet: 0.5 }),
+    knife_slash: (take) => [
+      sceneNoise({ type: "highpass", f: 3200 * take.f, f2: 1800, d: 0.13 * take.t, vol: 0.35 * take.v }),
+      sceneNoise({ type: "bandpass", f: 1300 * take.f, f2: 600, q: 2.5, d: 0.12 * take.t, vol: 0.35 * take.v, delay: 0.02 })
+    ],
+    knife_hit_object: knock({ clickF: 3200, click: 0.25, tones: [[2800, 0.08, 0.07], [4150, 0.06, 0.05]] }),
+    blunt_swing: whoosh("blunt", 220, 760, 0.28, 1.1, 1.5),
+    blunt_hit: fleshHit({ slap: 0.35, slapF: 900, thud: 1, thudF: 70, thudD: 0.18, crack: 0.3 }),
+    blunt_hit_object: knock({ clickF: 1400, click: 0.35, tones: [[300, 0.12, 0.25], [760, 0.08, 0.12]] }),
+    axe_swing: whoosh("chop", 190, 620, 0.3, 1.2, 1.4),
+    axe_chop: fleshHit({ slap: 0.3, slapF: 1400, thud: 0.75, thudF: 140, thudD: 0.1, crack: 0.35, wet: 0.45 }),
+    axe_hit_object: knock({ clickF: 2200, click: 0.4, tones: [[1500, 0.15, 0.1], [2300, 0.1, 0.06], [140, 0.1, 0.35]] })
+  };
+  var BODY_BUS = { player_hurt: "voices", player_death: "voices", player_breath_run: "voices", fall_damage: "voices" };
+  var built = [
+    ...SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstep(surface, gait))),
+    ...SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((l) => landing(surface, l))),
+    ...BODY_SOUND_IDS.map((id) => takes(id, BODY[id], BODY_FALLOFF, id.endsWith("_swing") ? [0.94, 1.06] : [0.96, 1.04], BODY_BUS[id]))
+  ];
+  var BODY_FOLEY_BANK = {
+    id: "body_foley",
+    sounds: built.flatMap((entry) => entry.sounds),
+    sets: built.map((entry) => entry.set)
+  };
+  var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
+  // src/audio/recipes.ts
+  var call = (o) => ({
+    id: o.id,
+    bus: "world",
+    order: "calls",
+    duration: o.seconds,
+    tail: 0.02,
+    // the page makes its gain and filter before it looks at the level
+    keepSilent: true,
+    layers: [
+      {
+        repeat: { count: o.count, spacing: o.spacing },
+        source: { kind: "osc", wave: o.wave, frequency: { from: o.frequency, to: o.frequency * o.drop, curve: "exp", over: "duration" } },
+        filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: o.frequency * 1.2 }, q: 3 }] },
+        envelope: [
+          [0, 1e-4, "set", "fixed"],
+          [0.015, 1, "exp"],
+          ["1d", 1e-4, "exp", "fixed"]
+        ]
+      }
+    ],
+    falloff: DISTANCE_CURVES.animals,
+    sources: [`jogo:L66625-66639 bichoSom('${o.team}')`]
+  });
+  var DOG_BARK = call({ id: "dog_bark", team: "latido", count: 2, spacing: 0.22, seconds: 0.12, wave: "square", frequency: 520, drop: 0.6 });
+  var LAPWING_CALL = call({ id: "lapwing_call", team: "queroquero", count: 3, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 2400, drop: 0.6 });
+  var HEN_CLUCK = call({ id: "hen_cluck", team: "cacarejo", count: 4, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 900, drop: 0.6 });
+  var COW_MOO = call({ id: "cow_moo", team: "mugido", count: 1, spacing: 0.14, seconds: 1.2, wave: "sawtooth", frequency: 140, drop: 0.8 });
+  var ANIMAL_SOUNDS = [DOG_BARK, LAPWING_CALL, HEN_CLUCK, COW_MOO];
+  var ANIMAL_SOUND_BANK = { id: "animals_three", sounds: ANIMAL_SOUNDS };
+
+  // src/audio/calls.json
+  var calls_default = {
+    sources: [
+      "jogo:L66677 galinha: cacarejo, 6 s between calls, noise 30 m",
+      "jogo:L66680 quero-quero: queroquero when the player is near (alarme), 8 s, noise 40 m",
+      "jogo:L66681 vaca: mugido, 30 s, noise 80 m",
+      "jogo:L66683 cachorro: latido when a zombie is within 12 m, 3 s, noise 60 m"
+    ],
+    species: {
+      chicken: { sound: "hen_cluck", cooldown: 6, noiseMetres: 30 },
+      southern_lapwing: { sound: "lapwing_call", cooldown: 8, noiseMetres: 40 },
+      cow: { sound: "cow_moo", cooldown: 30, noiseMetres: 80 },
+      dog: { sound: "dog_bark", cooldown: 3, noiseMetres: 60 }
+    }
+  };
+
+  // src/audio/sound.ts
+  var DATA = calls_default;
+  var ANIMAL_CALLS = DATA.species;
+  var ANIMAL_CALL_SOURCES = DATA.sources;
+  function createAnimalSound(sink, options = {}) {
+    sink.register?.(ANIMAL_SOUND_BANK);
+    const calls = { ...ANIMAL_CALLS, ...options.calls };
+    const waiting = /* @__PURE__ */ new Map();
+    const callOf = (speciesId) => calls[speciesId] ?? void 0;
+    return {
+      callOf,
+      call(speciesId, position, o = {}) {
+        const found = callOf(speciesId);
+        if (!found) return false;
+        const key = o.key ?? speciesId;
+        if ((waiting.get(key) ?? 0) > 0) return false;
+        waiting.set(key, found.cooldown);
+        sink.play({ sound: found.sound, position, ...o.volume === void 0 ? {} : { volume: o.volume } });
+        return true;
+      },
+      update(dt) {
+        for (const [key, seconds] of waiting) {
+          if (seconds - dt <= 0) waiting.delete(key);
+          else waiting.set(key, seconds - dt);
+        }
+      },
+      dispose: () => waiting.clear()
+    };
+  }
+
+  // src/context.ts
+  var createStream = (seed) => {
+    let state = seed;
+    return () => {
+      state |= 0;
+      state = state + 1831565813 | 0;
+      let t = Math.imul(state ^ state >>> 15, 1 | state);
+      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  };
+  var addMesh = (THREE, parent, geometry, material, x, y, z, rx, ry, rz) => {
+    const mesh2 = new THREE.Mesh(geometry, material);
+    mesh2.position.set(x || 0, y || 0, z || 0);
+    if (rx || ry || rz) mesh2.rotation.set(rx || 0, ry || 0, rz || 0);
+    mesh2.castShadow = true;
+    mesh2.receiveShadow = true;
+    parent.add(mesh2);
+    return mesh2;
+  };
+  var createRigTools = (THREE, rig) => {
+    const tools = {
+      material(color2, extras) {
+        const material = new THREE.MeshStandardMaterial(Object.assign({ color: color2, roughness: 0.8, metalness: 0, flatShading: false }, extras || {}));
+        material.userData.base = material.color.clone();
+        rig.materials.push(material);
+        return material;
+      },
+      ball(parent, radius, material, x, y, z, sx, sy, sz) {
+        const mesh2 = addMesh(THREE, parent, new THREE.SphereGeometry(radius, 16, 12), material, x, y, z);
+        if (sx) mesh2.scale.set(sx, sy, sz);
+        return mesh2;
+      },
+      limb: (parent, radius1, radius2, length, material) => addMesh(THREE, parent, new THREE.CylinderGeometry(radius2, radius1, length, 14, 1).translate(0, -length / 2, 0), material),
+      joint(parent, radius, material, x, y, z) {
+        const joint = tools.ball(parent, radius, material, x, y, z);
+        joint.userData.joint = 1;
+        rig.joints.push(joint);
+        return joint;
+      },
+      pivot(parent, x, y, z, offset) {
+        const group = new THREE.Group();
+        group.position.set(x, y, z);
+        parent.add(group);
+        rig.pivots.push({ group, rest: group.position.clone(), offset: offset || new THREE.Vector3() });
+        return group;
+      },
+      eyes(head, radius, x, y, z) {
+        const eyeMaterial = tools.material(1118481, { roughness: 0.25 });
+        rig.eyeMaterial = eyeMaterial;
+        for (const side of [-1, 1]) rig.eyes.push(tools.ball(head, radius, eyeMaterial, side * x, y, z));
+      }
+    };
+    return tools;
+  };
+  var createRig = (THREE, species, options) => {
+    const rig = {
+      species,
+      root: new THREE.Group(),
+      trunk: new THREE.Group(),
+      materials: [],
+      joints: [],
+      pivots: [],
+      legs: [],
+      tail: [],
+      ears: [],
+      infectionParts: [],
+      eyes: [],
+      wings: [],
+      segments: [],
+      phase: options.phase,
+      size: 1,
+      segmentLength: 0,
+      segmentCount: 0,
+      home: new THREE.Vector3(),
+      infected: false,
+      dead: false,
+      neckAngle: 0,
+      headAngle: 0,
+      triangles: 0
+    };
+    rig.root.add(rig.trunk);
+    return rig;
+  };
+
+  // src/extras.ts
+  var cow = ({ THREE, tools }, k) => {
+    tools.ball(k.bodyGroup, 0.2, k.main, 0, k.Rb * 1.1, k.L * 0.33, 0.95, 1.1, 1.1);
+    tools.ball(k.neck, 0.13, k.main, 0, 0.12, 0.08, 0.55, 1.4, 1.05);
+    for (const side of [-1, 1]) addMesh(THREE, k.head, new THREE.ConeGeometry(0.025, 0.13, 8), tools.material(13616808), side * 0.12, k.hd.r * 1.05, k.hd.r * 0.05, 0, 0, side * -0.9);
+  };
+  var horse = ({ THREE, rig, tools }, k) => {
+    for (let index = 0; index < 9; index++) addMesh(THREE, k.neck, new THREE.BoxGeometry(0.035, 0.16, 0.08), k.dark, 0, 0.06 + index * 0.065, -0.12 + index * 4e-3, -0.25, 0, 0);
+    addMesh(THREE, k.head, new THREE.BoxGeometry(0.03, 0.12, 0.06), k.dark, 0, k.hd.r * 1.05, k.hd.r * 0.3, 0.6, 0, 0);
+    const last = rig.tail[rig.tail.length - 1];
+    tools.ball(last, 0.08, k.dark, 0, -0.42, 0, 0.7, 4.5, 0.7);
+  };
+  var wildBoar = ({ THREE, tools }, k) => {
+    for (let index = 0; index < 12; index++) addMesh(THREE, k.bodyGroup, new THREE.BoxGeometry(0.03, 0.1, 0.06), k.dark, 0, k.Rb * 1.12 - index * 4e-3, k.L * 0.38 - index * 0.06, -0.2, 0, 0);
+    for (const side of [-1, 1])
+      addMesh(THREE, k.head, new THREE.ConeGeometry(0.012, 0.09, 6), tools.material(15261900), side * 0.07, k.hd.r * -0.25 + 0.03, k.hd.r * 0.25 + k.hd.r * k.hd.s[2] * 0.55 + 0.13, -0.6, 0, side * 0.5);
+  };
+  var chicken = ({ tools }, k) => {
+    const red = tools.material(12593182);
+    for (let index = 0; index < 4; index++) tools.ball(k.head, 0.014, red, 0, 0.045, -0.012 + index * 0.014, 0.5, 1, 0.8);
+    tools.ball(k.head, 0.012, red, 0, -0.04, 0.04, 0.5, 1.3, 0.7);
+  };
+  var southernLapwing = ({ THREE, tools }, k) => {
+    const black = tools.material(1447446);
+    tools.ball(k.bodyGroup, 0.05, black, 0, 0.03, 0.08, 1.1, 0.9, 0.6);
+    addMesh(THREE, k.head, new THREE.BoxGeometry(6e-3, 6e-3, 0.06).translate(0, 0, -0.03), black, 0, 0.025, -0.01, 0.5, 0, 0);
+    tools.ball(k.head, 0.026, black, 0, -5e-3, 0.02, 1.05, 0.7, 0.9);
+  };
+  var QUADRUPED_EXTRAS = { cow, horse, wild_boar: wildBoar };
+  var BIRD_EXTRAS = { chicken, southern_lapwing: southernLapwing };
+
   // ../game-animals/dist/index.js
   var gaits_default = {
     walk: [
@@ -92,16 +704,27 @@ var GameAnimalsThree = (() => {
     return outcome === "dies" ? "dead" : "alive";
   };
 
-  // ../game-contracts/dist/index.js
-  var KIT_ORIGIN_KEY = "kitOrigin";
-  function markKitOrigin(object2, origin) {
-    const node = object2;
-    node.userData = node.userData ?? {};
-    node.userData[KIT_ORIGIN_KEY] = { ...origin };
-    return object2;
-  }
+  // src/line-up.ts
+  var lineUpAnimals = (rigs, options = {}) => {
+    const start = options.start ?? -19;
+    const gap = options.gap ?? 0.85;
+    let cursor = start;
+    for (const rig of rigs) {
+      const length = lineUpLength(rig.species.body);
+      cursor += length / 2;
+      rig.root.position.set(cursor, 0, 0);
+      rig.home = rig.root.position.clone();
+      rig.root.rotation.y = rig.species.body.kind === "snake" ? options.snakeYaw ?? 2.2 : options.yaw ?? 1.1;
+      cursor += length / 2 + gap;
+    }
+    const offset = -(cursor - gap + start) / 2;
+    for (const rig of rigs) {
+      rig.root.position.x += offset;
+      rig.home.x += offset;
+    }
+  };
 
-  // ../game-shapes/dist/chunk-R4RY23RH.js
+  // ../game-shapes/dist/chunk-IFXQIDSA.js
   function canonicalJson(value) {
     if (value === null) return "null";
     if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
@@ -1396,10 +2019,10 @@ var GameAnimalsThree = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
-    templates.set(key, built);
+    const built2 = make(node.kind, parameters);
+    templates.set(key, built2);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
-    return built;
+    return built2;
   }
   var num = (v) => typeof v === "number" && Number.isFinite(v) ? null : "expected a finite number";
   var bool = (v) => typeof v === "boolean" ? null : "expected a boolean";
@@ -1702,6 +2325,134 @@ var GameAnimalsThree = (() => {
     return releaseObject3D(list2, { keep });
   }
 
+  // src/profile.ts
+  var profileGeometry = (THREE, length, profile, segments) => {
+    const points = profile.map((radius, index) => new THREE.Vector2(index / (profile.length - 1), radius));
+    const curve = new THREE.SplineCurve(points);
+    const outline = [];
+    outline.push(new THREE.Vector2(1e-3, -length / 2 - 0));
+    for (let step = 0; step <= 30; step++) {
+      const point = curve.getPoint(step / 30);
+      outline.push(new THREE.Vector2(Math.max(1e-3, point.y), -length / 2 + point.x * length));
+    }
+    outline.push(new THREE.Vector2(1e-3, length / 2));
+    return new (shapeGeometries(THREE)).LatheGeometry(outline, segments || 22).rotateX(Math.PI / 2);
+  };
+
+  // src/textures.ts
+  var canvasTexture = (THREE, document2, width, height, draw) => {
+    const canvas = document2.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    draw(canvas.getContext("2d"), width, height);
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    return texture;
+  };
+  var spotsTexture = (THREE, document2, base, spot) => canvasTexture(THREE, document2, 256, 256, (painter, width, height) => {
+    painter.fillStyle = base;
+    painter.fillRect(0, 0, width, height);
+    const next = createStream(11);
+    for (let index = 0; index < 70; index++) {
+      const x = next() * width;
+      const y = next() * height;
+      const radius = 5 + next() * 7;
+      painter.strokeStyle = spot;
+      painter.lineWidth = 3;
+      painter.beginPath();
+      painter.arc(x, y, radius, 0, 7);
+      painter.stroke();
+      painter.fillStyle = "rgba(120,70,20,.45)";
+      painter.beginPath();
+      painter.arc(x, y, radius * 0.6, 0, 7);
+      painter.fill();
+    }
+    for (let index = 0; index < 60; index++) {
+      painter.fillStyle = spot;
+      painter.beginPath();
+      painter.arc(next() * width, next() * height, 1.5 + next() * 2.5, 0, 7);
+      painter.fill();
+    }
+  });
+  var stripesTexture = (THREE, document2, base, stripe) => canvasTexture(THREE, document2, 128, 128, (painter, width) => {
+    painter.fillStyle = base;
+    painter.fillRect(0, 0, width, 128);
+    painter.fillStyle = stripe;
+    for (let index = 0; index < 9; index++) painter.fillRect(0, index * 14 + index % 2 * 3, width, 4);
+  });
+  var createCoatTexture = (THREE, document2, marker) => marker.kind === "stripes" ? stripesTexture(THREE, document2, marker.base, marker.stripe) : spotsTexture(THREE, document2, marker.base, marker.spot);
+
+  // src/visual-state.ts
+  var INFECTED_TINT = 8227430;
+  var POOL_COLOR = 3803142;
+  var applyVisualState = (THREE, rig, state) => {
+    rig.infected = state === "infected";
+    rig.dead = state === "dead";
+    const tint = new THREE.Color(INFECTED_TINT);
+    rig.materials.forEach((material) => {
+      if (material === rig.eyeMaterial || material === rig.woundMaterial) return;
+      material.color.copy(material.userData.base);
+      if (rig.infected) material.color.lerp(tint, 0.45).multiplyScalar(0.72);
+    });
+    const eye = rig.eyeMaterial;
+    if (eye) {
+      if (rig.infected) {
+        eye.color.set(14473392);
+        eye.emissive = new THREE.Color(9078368);
+        eye.emissiveIntensity = 0.8;
+      } else {
+        eye.color.copy(eye.userData.base);
+        eye.emissive = new THREE.Color(0);
+      }
+    }
+    rig.infectionParts.forEach((part) => part.visible = rig.infected);
+    const firstEar = rig.ears[0];
+    if (firstEar) firstEar.visible = !rig.infected;
+    if (!rig.dead) {
+      rig.root.rotation.z = 0;
+      rig.root.position.y = 0;
+    }
+    if (rig.pool) {
+      rig.pool.visible = rig.dead;
+      return;
+    }
+    if (!rig.dead) return;
+    const pool = new THREE.Mesh(new THREE.CircleGeometry(1, 22).rotateX(-Math.PI / 2), new THREE.MeshStandardMaterial({ color: POOL_COLOR, roughness: 0.25 }));
+    pool.position.set(rig.home.x, 5e-3, rig.home.z + 0.1);
+    pool.receiveShadow = true;
+    pool.scale.setScalar(rig.size * 0.45);
+    rig.root.parent?.add(pool);
+    rig.pool = pool;
+  };
+
+  // src/views.ts
+  var setJointView = (rig, on, jointMaterial) => {
+    rig.materials.forEach((material) => {
+      if (material === rig.eyeMaterial) return;
+      material.transparent = on;
+      material.opacity = on ? 0.28 : 1;
+      material.depthWrite = !on;
+      material.needsUpdate = true;
+    });
+    rig.joints.forEach((joint) => {
+      var _a;
+      if (on) (_a = joint.userData).restMaterial ?? (_a.restMaterial = joint.material);
+      joint.material = on ? jointMaterial : joint.userData.restMaterial;
+      joint.renderOrder = on ? 2 : 0;
+    });
+  };
+  var setSplit = (rig, on) => {
+    rig.pivots.forEach((pivot) => {
+      pivot.group.userData.target = on ? pivot.rest.clone().add(pivot.offset) : pivot.rest.clone();
+    });
+  };
+  var updateSplit = (rig, delta) => {
+    rig.pivots.forEach((pivot) => {
+      const target = pivot.group.userData.target;
+      if (target) pivot.group.position.lerp(target, Math.min(1, delta * 5));
+    });
+  };
+
   // ../game-props3d/dist/index.js
   var T = (id, interior, w, d, h, y, solid, group) => ({ id, interior, w, d, h, y, solid, group });
   var TYPE_DEFS = [
@@ -2069,105 +2820,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     for (let index = 0; index < rig.segmentCount; index++) {
       const group = rig.segments[index].group;
       group.position.copy(at(index));
-      const direction = index === 0 ? at(0).clone().sub(at(1)) : at(index - 1).clone().sub(at(index));
-      group.rotation.set(0, Math.atan2(direction.x, direction.z), 0);
-      group.rotateX(-Math.atan2(direction.y, Math.hypot(direction.x, direction.z)));
-    }
-    const head = rig.head;
-    const headDirection = at(0).clone().sub(at(1)).normalize();
-    head.position.copy(at(0)).addScaledVector(headDirection, 0.02);
-    head.rotation.set(0, Math.atan2(headDirection.x, headDirection.z), 0);
-    head.rotateX(-Math.atan2(headDirection.y, Math.hypot(headDirection.x, headDirection.z)) * 0.5);
-    const jaw = rig.jaw;
-    jaw.rotation.x = clip === "run" ? Math.max(0, Math.sin(t * 2.2)) ** 6 * 0.9 : 0;
-    const tongue = rig.tongue;
-    tongue.visible = Math.sin(t * 5) > 0.3;
-    tongue.scale.z = 1 + Math.sin(t * 20) * 0.3;
-  };
-
-  // src/context.ts
-  var createStream = (seed) => {
-    let state = seed;
-    return () => {
-      state |= 0;
-      state = state + 1831565813 | 0;
-      let t = Math.imul(state ^ state >>> 15, 1 | state);
-      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-      return ((t ^ t >>> 14) >>> 0) / 4294967296;
-    };
-  };
-  var addMesh = (THREE, parent, geometry, material, x, y, z, rx, ry, rz) => {
-    const mesh2 = new THREE.Mesh(geometry, material);
-    mesh2.position.set(x || 0, y || 0, z || 0);
-    if (rx || ry || rz) mesh2.rotation.set(rx || 0, ry || 0, rz || 0);
-    mesh2.castShadow = true;
-    mesh2.receiveShadow = true;
-    parent.add(mesh2);
-    return mesh2;
-  };
-  var createRigTools = (THREE, rig) => {
-    const tools = {
-      material(color2, extras) {
-        const material = new THREE.MeshStandardMaterial(Object.assign({ color: color2, roughness: 0.8, metalness: 0, flatShading: false }, extras || {}));
-        material.userData.base = material.color.clone();
-        rig.materials.push(material);
-        return material;
-      },
-      ball(parent, radius, material, x, y, z, sx, sy, sz) {
-        const mesh2 = addMesh(THREE, parent, new THREE.SphereGeometry(radius, 16, 12), material, x, y, z);
-        if (sx) mesh2.scale.set(sx, sy, sz);
-        return mesh2;
-      },
-      limb: (parent, radius1, radius2, length, material) => addMesh(THREE, parent, new THREE.CylinderGeometry(radius2, radius1, length, 14, 1).translate(0, -length / 2, 0), material),
-      joint(parent, radius, material, x, y, z) {
-        const joint = tools.ball(parent, radius, material, x, y, z);
-        joint.userData.joint = 1;
-        rig.joints.push(joint);
-        return joint;
-      },
-      pivot(parent, x, y, z, offset) {
-        const group = new THREE.Group();
-        group.position.set(x, y, z);
-        parent.add(group);
-        rig.pivots.push({ group, rest: group.position.clone(), offset: offset || new THREE.Vector3() });
-        return group;
-      },
-      eyes(head, radius, x, y, z) {
-        const eyeMaterial = tools.material(1118481, { roughness: 0.25 });
-        rig.eyeMaterial = eyeMaterial;
-        for (const side of [-1, 1]) rig.eyes.push(tools.ball(head, radius, eyeMaterial, side * x, y, z));
-      }
-    };
-    return tools;
-  };
-  var createRig = (THREE, species, options) => {
-    const rig = {
-      species,
-      root: new THREE.Group(),
-      trunk: new THREE.Group(),
-      materials: [],
-      joints: [],
-      pivots: [],
-      legs: [],
-      tail: [],
-      ears: [],
-      infectionParts: [],
-      eyes: [],
-      wings: [],
-      segments: [],
-      phase: options.phase,
-      size: 1,
-      segmentLength: 0,
-      segmentCount: 0,
-      home: new THREE.Vector3(),
-      infected: false,
-      dead: false,
-      neckAngle: 0,
-      headAngle: 0,
-      triangles: 0
-    };
-    rig.root.add(rig.trunk);
-    return rig;
+      const direction = index === 0 ? at(0).clone().sub(at(1)) : at(index - 1).clone().sub(at(index));
+      group.rotation.set(0, Math.atan2(direction.x, direction.z), 0);
+      group.rotateX(-Math.atan2(direction.y, Math.hypot(direction.x, direction.z)));
+    }
+    const head = rig.head;
+    const headDirection = at(0).clone().sub(at(1)).normalize();
+    head.position.copy(at(0)).addScaledVector(headDirection, 0.02);
+    head.rotation.set(0, Math.atan2(headDirection.x, headDirection.z), 0);
+    head.rotateX(-Math.atan2(headDirection.y, Math.hypot(headDirection.x, headDirection.z)) * 0.5);
+    const jaw = rig.jaw;
+    jaw.rotation.x = clip === "run" ? Math.max(0, Math.sin(t * 2.2)) ** 6 * 0.9 : 0;
+    const tongue = rig.tongue;
+    tongue.visible = Math.sin(t * 5) > 0.3;
+    tongue.scale.z = 1 + Math.sin(t * 20) * 0.3;
   };
 
   // src/bird.ts
@@ -2254,94 +2920,6 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return rig;
   };
 
-  // src/extras.ts
-  var cow = ({ THREE, tools }, k) => {
-    tools.ball(k.bodyGroup, 0.2, k.main, 0, k.Rb * 1.1, k.L * 0.33, 0.95, 1.1, 1.1);
-    tools.ball(k.neck, 0.13, k.main, 0, 0.12, 0.08, 0.55, 1.4, 1.05);
-    for (const side of [-1, 1]) addMesh(THREE, k.head, new THREE.ConeGeometry(0.025, 0.13, 8), tools.material(13616808), side * 0.12, k.hd.r * 1.05, k.hd.r * 0.05, 0, 0, side * -0.9);
-  };
-  var horse = ({ THREE, rig, tools }, k) => {
-    for (let index = 0; index < 9; index++) addMesh(THREE, k.neck, new THREE.BoxGeometry(0.035, 0.16, 0.08), k.dark, 0, 0.06 + index * 0.065, -0.12 + index * 4e-3, -0.25, 0, 0);
-    addMesh(THREE, k.head, new THREE.BoxGeometry(0.03, 0.12, 0.06), k.dark, 0, k.hd.r * 1.05, k.hd.r * 0.3, 0.6, 0, 0);
-    const last = rig.tail[rig.tail.length - 1];
-    tools.ball(last, 0.08, k.dark, 0, -0.42, 0, 0.7, 4.5, 0.7);
-  };
-  var wildBoar = ({ THREE, tools }, k) => {
-    for (let index = 0; index < 12; index++) addMesh(THREE, k.bodyGroup, new THREE.BoxGeometry(0.03, 0.1, 0.06), k.dark, 0, k.Rb * 1.12 - index * 4e-3, k.L * 0.38 - index * 0.06, -0.2, 0, 0);
-    for (const side of [-1, 1])
-      addMesh(THREE, k.head, new THREE.ConeGeometry(0.012, 0.09, 6), tools.material(15261900), side * 0.07, k.hd.r * -0.25 + 0.03, k.hd.r * 0.25 + k.hd.r * k.hd.s[2] * 0.55 + 0.13, -0.6, 0, side * 0.5);
-  };
-  var chicken = ({ tools }, k) => {
-    const red = tools.material(12593182);
-    for (let index = 0; index < 4; index++) tools.ball(k.head, 0.014, red, 0, 0.045, -0.012 + index * 0.014, 0.5, 1, 0.8);
-    tools.ball(k.head, 0.012, red, 0, -0.04, 0.04, 0.5, 1.3, 0.7);
-  };
-  var southernLapwing = ({ THREE, tools }, k) => {
-    const black = tools.material(1447446);
-    tools.ball(k.bodyGroup, 0.05, black, 0, 0.03, 0.08, 1.1, 0.9, 0.6);
-    addMesh(THREE, k.head, new THREE.BoxGeometry(6e-3, 6e-3, 0.06).translate(0, 0, -0.03), black, 0, 0.025, -0.01, 0.5, 0, 0);
-    tools.ball(k.head, 0.026, black, 0, -5e-3, 0.02, 1.05, 0.7, 0.9);
-  };
-  var QUADRUPED_EXTRAS = { cow, horse, wild_boar: wildBoar };
-  var BIRD_EXTRAS = { chicken, southern_lapwing: southernLapwing };
-
-  // src/textures.ts
-  var canvasTexture = (THREE, document2, width, height, draw) => {
-    const canvas = document2.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-    draw(canvas.getContext("2d"), width, height);
-    const texture = new THREE.CanvasTexture(canvas);
-    texture.colorSpace = THREE.SRGBColorSpace;
-    return texture;
-  };
-  var spotsTexture = (THREE, document2, base, spot) => canvasTexture(THREE, document2, 256, 256, (painter, width, height) => {
-    painter.fillStyle = base;
-    painter.fillRect(0, 0, width, height);
-    const next = createStream(11);
-    for (let index = 0; index < 70; index++) {
-      const x = next() * width;
-      const y = next() * height;
-      const radius = 5 + next() * 7;
-      painter.strokeStyle = spot;
-      painter.lineWidth = 3;
-      painter.beginPath();
-      painter.arc(x, y, radius, 0, 7);
-      painter.stroke();
-      painter.fillStyle = "rgba(120,70,20,.45)";
-      painter.beginPath();
-      painter.arc(x, y, radius * 0.6, 0, 7);
-      painter.fill();
-    }
-    for (let index = 0; index < 60; index++) {
-      painter.fillStyle = spot;
-      painter.beginPath();
-      painter.arc(next() * width, next() * height, 1.5 + next() * 2.5, 0, 7);
-      painter.fill();
-    }
-  });
-  var stripesTexture = (THREE, document2, base, stripe) => canvasTexture(THREE, document2, 128, 128, (painter, width) => {
-    painter.fillStyle = base;
-    painter.fillRect(0, 0, width, 128);
-    painter.fillStyle = stripe;
-    for (let index = 0; index < 9; index++) painter.fillRect(0, index * 14 + index % 2 * 3, width, 4);
-  });
-  var createCoatTexture = (THREE, document2, marker) => marker.kind === "stripes" ? stripesTexture(THREE, document2, marker.base, marker.stripe) : spotsTexture(THREE, document2, marker.base, marker.spot);
-
-  // src/profile.ts
-  var profileGeometry = (THREE, length, profile, segments) => {
-    const points = profile.map((radius, index) => new THREE.Vector2(index / (profile.length - 1), radius));
-    const curve = new THREE.SplineCurve(points);
-    const outline = [];
-    outline.push(new THREE.Vector2(1e-3, -length / 2 - 0));
-    for (let step = 0; step <= 30; step++) {
-      const point = curve.getPoint(step / 30);
-      outline.push(new THREE.Vector2(Math.max(1e-3, point.y), -length / 2 + point.x * length));
-    }
-    outline.push(new THREE.Vector2(1e-3, length / 2));
-    return new (shapeGeometries(THREE)).LatheGeometry(outline, segments || 22).rotateX(Math.PI / 2);
-  };
-
   // src/quadruped.ts
   var RIB_COUNT = 4;
   var LEG_DEFINITIONS = [
@@ -2535,305 +3113,263 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     tools.eyes(head, 6e-3, 0.03, 0.04, 0.045);
     rig.tongue = addMesh(THREE, head, new THREE.BoxGeometry(4e-3, 2e-3, 0.05), tools.material(11542560), 0, 0.024, 0.1);
     return rig;
-  };
-
-  // src/visual-state.ts
-  var INFECTED_TINT = 8227430;
-  var POOL_COLOR = 3803142;
-  var applyVisualState = (THREE, rig, state) => {
-    rig.infected = state === "infected";
-    rig.dead = state === "dead";
-    const tint = new THREE.Color(INFECTED_TINT);
-    rig.materials.forEach((material) => {
-      if (material === rig.eyeMaterial || material === rig.woundMaterial) return;
-      material.color.copy(material.userData.base);
-      if (rig.infected) material.color.lerp(tint, 0.45).multiplyScalar(0.72);
-    });
-    const eye = rig.eyeMaterial;
-    if (eye) {
-      if (rig.infected) {
-        eye.color.set(14473392);
-        eye.emissive = new THREE.Color(9078368);
-        eye.emissiveIntensity = 0.8;
-      } else {
-        eye.color.copy(eye.userData.base);
-        eye.emissive = new THREE.Color(0);
-      }
-    }
-    rig.infectionParts.forEach((part) => part.visible = rig.infected);
-    const firstEar = rig.ears[0];
-    if (firstEar) firstEar.visible = !rig.infected;
-    if (!rig.dead) {
-      rig.root.rotation.z = 0;
-      rig.root.position.y = 0;
-    }
-    if (rig.pool) {
-      rig.pool.visible = rig.dead;
-      return;
-    }
-    if (!rig.dead) return;
-    const pool = new THREE.Mesh(new THREE.CircleGeometry(1, 22).rotateX(-Math.PI / 2), new THREE.MeshStandardMaterial({ color: POOL_COLOR, roughness: 0.25 }));
-    pool.position.set(rig.home.x, 5e-3, rig.home.z + 0.1);
-    pool.receiveShadow = true;
-    pool.scale.setScalar(rig.size * 0.45);
-    rig.root.parent?.add(pool);
-    rig.pool = pool;
-  };
-
-  // src/views.ts
-  var setJointView = (rig, on, jointMaterial) => {
-    rig.materials.forEach((material) => {
-      if (material === rig.eyeMaterial) return;
-      material.transparent = on;
-      material.opacity = on ? 0.28 : 1;
-      material.depthWrite = !on;
-      material.needsUpdate = true;
-    });
-    rig.joints.forEach((joint) => {
-      var _a;
-      if (on) (_a = joint.userData).restMaterial ?? (_a.restMaterial = joint.material);
-      joint.material = on ? jointMaterial : joint.userData.restMaterial;
-      joint.renderOrder = on ? 2 : 0;
-    });
-  };
-  var setSplit = (rig, on) => {
-    rig.pivots.forEach((pivot) => {
-      pivot.group.userData.target = on ? pivot.rest.clone().add(pivot.offset) : pivot.rest.clone();
-    });
-  };
-  var updateSplit = (rig, delta) => {
-    rig.pivots.forEach((pivot) => {
-      const target = pivot.group.userData.target;
-      if (target) pivot.group.position.lerp(target, Math.min(1, delta * 5));
-    });
-  };
-
-  // ../game-audio/dist/index.js
-  var DISTANCE_CURVES = {
-    /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
-    game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
-    /** The game's `grito`: `1 / (1 + d² × 0.006)`, silent below 0.02 (jogo L62129–62130). */
-    game_scream: { model: "inverse_square", k: 6e-3, minGain: 0.02 },
-    /** The game's `voz`: `1 / (1 + d² × 0.01)`, silent below 0.02 (jogo L62146–62147). */
-    game_voice: { model: "inverse_square", k: 0.01, minGain: 0.02 },
-    /** The game's `boom`: `1.4 / (1 + d² × 0.002)`, never silent (jogo L68280). */
-    game_boom: { model: "inverse_square", k: 2e-3, scale: 1.4 },
-    /** The art scene's `outAt`: `vol / (1 + d² × 0.008)` (cena L1320). */
-    art_scene: { model: "inverse_square", k: 8e-3 },
-    /** The game's animal calls: `max(0, 1 − d / 70) × 0.25`, silent at or below 0.005 (jogo L66627–66628). */
-    animals: { model: "linear", range: 70, scale: 0.25, minGain: 5e-3 }
-  };
-  var mix_profiles_default = [
-    {
-      id: "game",
-      master: 0.5,
-      noise: { seconds: 1.5, create: "lazy" },
-      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
-    },
-    {
-      id: "art_scene",
-      master: 0.85,
-      compressor: { threshold: -12, ratio: 5 },
-      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
-      noise: { seconds: 2, create: "eager" },
-      sources: [
-        "cena:L1308 compressor -12 dB, ratio 5",
-        "cena:L1309 master 0.85",
-        "cena:L1310 convolver, impulse 2.2 s of (1 - i/len)^3.4",
-        "cena:L1311 wet 0.4",
-        "cena:L1312 noise 2 s made with the chain"
-      ]
-    }
-  ];
-  var MIX_PROFILES = Object.fromEntries(
-    mix_profiles_default.map((profile) => [profile.id, profile])
-  );
-  var game_sfx_default = {
-    sources: ["jogo:L62089-62107"],
-    note: "The game's sfx table P: [lowpass cutoff Hz, peak gain, seconds]. Played as a noise burst with the game's distance curve (falloff game_sfx) and a 0.05 s tail. Team names in `team`.",
-    classes: [
-      { id: "pistol", team: "pistola", bus: "weapons", cutoff: 1800, gain: 0.9, seconds: 0.18 },
-      { id: "shotgun", team: "escopeta", bus: "weapons", cutoff: 900, gain: 1.2, seconds: 0.35 },
-      { id: "rifle", team: "fuzil", bus: "weapons", cutoff: 1400, gain: 1.1, seconds: 0.28 },
-      { id: "long_rifle", team: "rifle", bus: "weapons", cutoff: 1100, gain: 1.3, seconds: 0.45 },
-      { id: "impact", team: "impacto", bus: "world", cutoff: 2500, gain: 0.25, seconds: 0.05 },
-      { id: "flesh", team: "carne", bus: "world", cutoff: 600, gain: 0.35, seconds: 0.08 },
-      { id: "step", team: "passo", bus: "world", cutoff: 400, gain: 0.08, seconds: 0.05 },
-      { id: "glass", team: "vidro", bus: "world", cutoff: 5e3, gain: 0.5, seconds: 0.3 },
-      { id: "wood", team: "madeira", bus: "world", cutoff: 700, gain: 0.5, seconds: 0.2 },
-      { id: "reload", team: "recarga", bus: "weapons", cutoff: 3e3, gain: 0.15, seconds: 0.06 },
-      { id: "empty", team: "vazio", bus: "weapons", cutoff: 4e3, gain: 0.12, seconds: 0.03 },
-      { id: "explosion", team: "explosao", bus: "world", cutoff: 200, gain: 1.6, seconds: 1.4 }
-    ],
-    fallback: { id: "unknown", team: "(any other name)", bus: "world", cutoff: 1e3, gain: 0.5, seconds: 0.1 }
-  };
-  var GAME_SFX = game_sfx_default;
-  var GAME_SFX_CLASSES = GAME_SFX.classes;
-  var GAME_SFX_FALLBACK = GAME_SFX.fallback;
-  function noiseClassRecipe(row, id = `sfx_${row.id}`) {
-    return {
-      id,
-      bus: row.bus,
-      order: "burst",
-      duration: row.seconds,
-      tail: 0.05,
-      layers: [
-        {
-          source: { kind: "noise", offset: "random" },
-          filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: row.cutoff } }] },
-          envelope: [
-            [0, row.gain, "set"],
-            ["1d", 1e-3, "exp", "fixed"]
-          ]
-        }
-      ],
-      falloff: DISTANCE_CURVES.game_sfx,
-      sources: [...GAME_SFX.sources.map((source) => `${source} ${row.team}`)]
+  };
+
+  // src/animals-three.ts
+  var countTriangles = (root) => {
+    let triangles = 0;
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh) return;
+      const geometry = mesh2.geometry;
+      triangles += geometry.index ? geometry.index.count / 3 : geometry.attributes.position.count / 3;
+    });
+    return Math.round(triangles);
+  };
+  var createAnimalsThree = (host, options = {}) => {
+    const THREE = shapeGeometries(host);
+    const random = options.random ?? createStream(options.seed ?? 7);
+    const documentOf = () => {
+      const found = options.document ?? globalThis.document;
+      if (!found) throw new Error("game-animals-three: a species with a coat texture needs `options.document` (no global document found)");
+      return found;
     };
-  }
-  var GAME_SFX_BANK = { id: "game_sfx", sounds: [...GAME_SFX_CLASSES, GAME_SFX_FALLBACK].map((row) => noiseClassRecipe(row)) };
-  var BENCH_BANK = {
-    id: "audio_bench",
-    sounds: [
-      {
-        id: "bench_ping",
-        bus: "ui",
-        pan: true,
-        duration: 0.25,
-        layers: [
-          {
-            gain: 0.5,
-            wet: 0.3,
-            source: { kind: "osc", wave: "sine", frequency: { from: 880 } },
-            envelope: [
-              [0, 1e-4, "set", "fixed"],
-              [2e-3, 1, "exp"],
-              ["1d", 1e-4, "exp", "fixed"]
-            ]
-          }
-        ],
-        falloff: DISTANCE_CURVES.art_scene,
-        sources: ["sdk: bench probe, a 880 Hz ping through the art scene output stage"]
+    const jointMaterial = new THREE.MeshStandardMaterial({ color: 14722376, emissive: 14722376, emissiveIntensity: 0.8, roughness: 0.4 });
+    const gaits = GAIT_PHASES;
+    return {
+      jointMaterial,
+      build(species, buildOptions = {}) {
+        const rig = createRig(THREE, species, { phase: buildOptions.phase ?? random() * 6 });
+        if (species.body.kind === "snake") buildSnake(THREE, rig);
+        else if (species.body.kind === "bird") buildBird(THREE, rig, { extra: BIRD_EXTRAS[species.id] });
+        else buildQuadruped(THREE, rig, { document: species.body.texture ? documentOf() : void 0, extra: QUADRUPED_EXTRAS[species.id] });
+        rig.triangles = countTriangles(rig.root);
+        markKitOrigin(rig.root, { owner: "game-animals-three", kind: "animal", id: species.id });
+        rig.root.traverse((object2) => {
+          if (object2.isMesh) object2.userData.speciesId = species.id;
+        });
+        return rig;
       },
-      {
-        id: "bench_hiss",
-        bus: "ui",
-        pan: true,
-        duration: [0.3, 0.9],
-        layers: [
-          {
-            gain: 0.4,
-            source: { kind: "noise", offset: "random", offsetScale: 1.5, loop: true },
-            filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 3e3 }, q: 0.7 }] },
-            envelope: [
-              [0, 1e-4, "set", "fixed"],
-              [2e-3, 1, "exp"],
-              ["1d", 1e-4, "exp", "fixed"]
-            ]
-          }
-        ],
-        falloff: DISTANCE_CURVES.art_scene,
-        sources: ["sdk: bench probe, a highpass hiss of random length"]
-      }
-    ]
+      animate(rig, params) {
+        const kind = rig.species.body.kind;
+        if (kind === "snake") animateSnake(THREE, rig, params);
+        else if (kind === "bird") animateBird(rig, params);
+        else animateQuadruped(rig, params, gaits);
+      },
+      setVisualState: (rig, state) => applyVisualState(THREE, rig, state),
+      setJointView: (rig, on) => setJointView(rig, on, jointMaterial),
+      setSplit,
+      updateSplit,
+      createSkin: (rig) => createNodeSkin(THREE, rig.root, { nodes: collectReferencedNodes(rig, ["species"]) })
+    };
   };
 
-  // src/audio/recipes.ts
-  var call = (o) => ({
-    id: o.id,
-    bus: "world",
-    order: "calls",
-    duration: o.seconds,
-    tail: 0.02,
-    // the page makes its gain and filter before it looks at the level
-    keepSilent: true,
-    layers: [
-      {
-        repeat: { count: o.count, spacing: o.spacing },
-        source: { kind: "osc", wave: o.wave, frequency: { from: o.frequency, to: o.frequency * o.drop, curve: "exp", over: "duration" } },
-        filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: o.frequency * 1.2 }, q: 3 }] },
-        envelope: [
-          [0, 1e-4, "set", "fixed"],
-          [0.015, 1, "exp"],
-          ["1d", 1e-4, "exp", "fixed"]
-        ]
-      }
-    ],
-    falloff: DISTANCE_CURVES.animals,
-    sources: [`jogo:L66625-66639 bichoSom('${o.team}')`]
-  });
-  var DOG_BARK = call({ id: "dog_bark", team: "latido", count: 2, spacing: 0.22, seconds: 0.12, wave: "square", frequency: 520, drop: 0.6 });
-  var LAPWING_CALL = call({ id: "lapwing_call", team: "queroquero", count: 3, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 2400, drop: 0.6 });
-  var HEN_CLUCK = call({ id: "hen_cluck", team: "cacarejo", count: 4, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 900, drop: 0.6 });
-  var COW_MOO = call({ id: "cow_moo", team: "mugido", count: 1, spacing: 0.14, seconds: 1.2, wave: "sawtooth", frequency: 140, drop: 0.8 });
-  var ANIMAL_SOUNDS = [DOG_BARK, LAPWING_CALL, HEN_CLUCK, COW_MOO];
-  var ANIMAL_SOUND_BANK = { id: "animals_three", sounds: ANIMAL_SOUNDS };
-
-  // src/audio/calls.json
-  var calls_default = {
-    sources: [
-      "jogo:L66677 galinha: cacarejo, 6 s between calls, noise 30 m",
-      "jogo:L66680 quero-quero: queroquero when the player is near (alarme), 8 s, noise 40 m",
-      "jogo:L66681 vaca: mugido, 30 s, noise 80 m",
-      "jogo:L66683 cachorro: latido when a zombie is within 12 m, 3 s, noise 60 m"
-    ],
-    species: {
-      chicken: { sound: "hen_cluck", cooldown: 6, noiseMetres: 30 },
-      southern_lapwing: { sound: "lapwing_call", cooldown: 8, noiseMetres: 40 },
-      cow: { sound: "cow_moo", cooldown: 30, noiseMetres: 80 },
-      dog: { sound: "dog_bark", cooldown: 3, noiseMetres: 60 }
+  // ../game-render-three/dist/index.js
+  var DEFAULT_ANGLE = Math.PI / 3;
+  var EFFECT_STEP_SECONDS = 1 / 50;
+  var BATCHED_LAYER = 30;
+  var MATRIX_EPSILON = 1e-6;
+  var ATTRIBUTES = ["position", "normal", "uv", "color"];
+  var isShown = (object2, root) => {
+    for (let node = object2; node; node = node.parent) {
+      if (node === root) return true;
+      if (!node.visible) return false;
     }
+    return false;
   };
-
-  // src/audio/sound.ts
-  var DATA = calls_default;
-  var ANIMAL_CALLS = DATA.species;
-  var ANIMAL_CALL_SOURCES = DATA.sources;
-  function createAnimalSound(sink, options = {}) {
-    sink.register?.(ANIMAL_SOUND_BANK);
-    const calls = { ...ANIMAL_CALLS, ...options.calls };
-    const waiting = /* @__PURE__ */ new Map();
-    const callOf = (speciesId) => calls[speciesId] ?? void 0;
+  var isBatchable = (mesh2) => {
+    const flags = mesh2;
+    if (flags.isInstancedMesh === true || flags.isSkinnedMesh === true || Array.isArray(mesh2.material)) return false;
+    const geometry = mesh2.geometry;
+    return geometry.attributes.position !== void 0 && Object.keys(geometry.morphAttributes).length === 0;
+  };
+  var signatureOf = (mesh2) => {
+    const { attributes } = mesh2.geometry;
+    const present = ATTRIBUTES.filter((name) => attributes[name] !== void 0).map((name) => `${name}${attributes[name].itemSize}`);
+    return `${mesh2.material.uuid}|${present.join(",")}|${mesh2.castShadow ? 1 : 0}${mesh2.receiveShadow ? 1 : 0}`;
+  };
+  var sameMatrix = (a, b) => a.elements.every((value, index) => Math.abs(value - b.elements[index]) < MATRIX_EPSILON);
+  function createStaticBatcher(THREE, root, options = {}) {
+    const include = options.include ?? (() => true);
+    const follow = options.followMeshes === true;
+    root.updateMatrixWorld(true);
+    const inverse = new THREE.Matrix4().copy(root.matrixWorld).invert();
+    const groups = /* @__PURE__ */ new Map();
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || !isShown(mesh2, root) || !isBatchable(mesh2) || !include(mesh2)) return;
+      const key = signatureOf(mesh2);
+      groups.set(key, [...groups.get(key) ?? [], mesh2]);
+    });
+    const group = new THREE.Group();
+    group.name = "static-batches";
+    const sources = [];
+    const pending = [...groups.values()].filter((meshes) => meshes.length >= 2);
+    const mergeSome = (deadline) => {
+      while (pending.length > 0) {
+        const meshes = pending.shift();
+        if (meshes.every((mesh2) => isShown(mesh2, root))) sources.push(...mergeGroup(THREE, { meshes, inverse: new THREE.Matrix4().copy(root.matrixWorld).invert(), group, follow }));
+        if (performance.now() >= deadline) return;
+      }
+    };
+    if (options.budgetMs === void 0) mergeSome(Number.POSITIVE_INFINITY);
+    root.add(group);
+    const scratch = new THREE.Matrix4();
+    let released = 0;
+    const release = (source) => {
+      source.released = true;
+      source.mesh.layers.mask = source.mask;
+      const { index } = source.batch;
+      const first = index.array[source.start];
+      for (let at = source.start; at < source.start + source.count; at++) index.array[at] = first;
+      index.needsUpdate = true;
+      if (--source.batch.live === 0) source.batch.mesh.visible = false;
+      released++;
+    };
+    const hasChanged = (source) => {
+      const { mesh: mesh2 } = source;
+      if (mesh2.geometry !== source.geometry || mesh2.material !== source.material || !isShown(mesh2, root)) return true;
+      if (mesh2.geometry.attributes.position.version !== source.version) return true;
+      if (follow || sameMatrix(mesh2.matrixWorld, source.world)) return false;
+      if (!sameMatrix(scratch.multiplyMatrices(inverse, mesh2.matrixWorld), source.local)) return true;
+      source.world.copy(mesh2.matrixWorld);
+      return false;
+    };
     return {
-      callOf,
-      call(speciesId, position, o = {}) {
-        const found = callOf(speciesId);
-        if (!found) return false;
-        const key = o.key ?? speciesId;
-        if ((waiting.get(key) ?? 0) > 0) return false;
-        waiting.set(key, found.cooldown);
-        sink.play({ sound: found.sound, position, ...o.volume === void 0 ? {} : { volume: o.volume } });
-        return true;
+      group,
+      update() {
+        if (pending.length > 0) mergeSome(performance.now() + (options.budgetMs ?? Number.POSITIVE_INFINITY));
+        const before = released;
+        inverse.copy(root.matrixWorld).invert();
+        for (const source of sources) if (!source.released && hasChanged(source)) release(source);
+        return released - before;
       },
-      update(dt) {
-        for (const [key, seconds] of waiting) {
-          if (seconds - dt <= 0) waiting.delete(key);
-          else waiting.set(key, seconds - dt);
+      stats: () => ({ batches: group.children.length, batched: sources.filter((source) => !source.released).length, released }),
+      dispose() {
+        for (const source of sources) if (!source.released) source.mesh.layers.mask = source.mask;
+        group.removeFromParent();
+        for (const child of group.children) {
+          ;
+          child.geometry.dispose();
+          child.skeleton?.dispose();
         }
-      },
-      dispose: () => waiting.clear()
+      }
     };
   }
-
-  // src/line-up.ts
-  var lineUpAnimals = (rigs, options = {}) => {
-    const start = options.start ?? -19;
-    const gap = options.gap ?? 0.85;
-    let cursor = start;
-    for (const rig of rigs) {
-      const length = lineUpLength(rig.species.body);
-      cursor += length / 2;
-      rig.root.position.set(cursor, 0, 0);
-      rig.home = rig.root.position.clone();
-      rig.root.rotation.y = rig.species.body.kind === "snake" ? options.snakeYaw ?? 2.2 : options.yaw ?? 1.1;
-      cursor += length / 2 + gap;
+  function copyAttribute(name, attribute, target, offset, matrix, normalMatrix2) {
+    const size = attribute.itemSize;
+    const source = attribute.array;
+    const flat = !attribute.isInterleavedBufferAttribute && source.length === attribute.count * size;
+    if (name !== "position" && name !== "normal") {
+      if (flat) target.set(source, offset * size);
+      else for (let at = 0; at < attribute.count; at++) for (let k = 0; k < size; k++) target[(offset + at) * size + k] = attribute.getComponent(at, k);
+      return;
     }
-    const offset = -(cursor - gap + start) / 2;
-    for (const rig of rigs) {
-      rig.root.position.x += offset;
-      rig.home.x += offset;
+    const e = (name === "position" ? matrix : normalMatrix2).elements;
+    const isNormal = name === "normal";
+    for (let at = 0; at < attribute.count; at++) {
+      const x = attribute.getX(at);
+      const y = attribute.getY(at);
+      const z = attribute.getZ(at);
+      const out = (offset + at) * 3;
+      if (isNormal) {
+        const nx = e[0] * x + e[3] * y + e[6] * z;
+        const ny = e[1] * x + e[4] * y + e[7] * z;
+        const nz = e[2] * x + e[5] * y + e[8] * z;
+        const length = Math.hypot(nx, ny, nz) || 1;
+        target[out] = nx / length;
+        target[out + 1] = ny / length;
+        target[out + 2] = nz / length;
+      } else {
+        target[out] = e[0] * x + e[4] * y + e[8] * z + e[12];
+        target[out + 1] = e[1] * x + e[5] * y + e[9] * z + e[13];
+        target[out + 2] = e[2] * x + e[6] * y + e[10] * z + e[14];
+      }
     }
-  };
+  }
+  function skinnedBatch(THREE, merged, material, meshes) {
+    const vertices = merged.attributes.position.count;
+    const skinIndex = new Uint16Array(vertices * 4);
+    const skinWeight = new Float32Array(vertices * 4);
+    let at = 0;
+    meshes.forEach((mesh22, bone) => {
+      for (let k = 0; k < mesh22.geometry.attributes.position.count; k++, at++) {
+        skinIndex[at * 4] = bone;
+        skinWeight[at * 4] = 1;
+      }
+    });
+    merged.setAttribute("skinIndex", new THREE.BufferAttribute(skinIndex, 4));
+    merged.setAttribute("skinWeight", new THREE.BufferAttribute(skinWeight, 4));
+    const mesh2 = new THREE.SkinnedMesh(merged, material);
+    const identities = meshes.map(() => new THREE.Matrix4());
+    mesh2.bind(new THREE.Skeleton(meshes, identities), new THREE.Matrix4());
+    mesh2.frustumCulled = false;
+    return mesh2;
+  }
+  function mergeGroup(THREE, { meshes, inverse: rootInverse, group, follow }) {
+    const identity = new THREE.Matrix4();
+    const inverse = follow ? identity : rootInverse;
+    const first = meshes[0];
+    const names = ATTRIBUTES.filter((name) => first.geometry.attributes[name] !== void 0);
+    const pieces = meshes.map((mesh22) => {
+      const local = new THREE.Matrix4().multiplyMatrices(inverse, mesh22.matrixWorld);
+      const vertices = mesh22.geometry.attributes.position.count;
+      const indexCount = mesh22.geometry.index ? mesh22.geometry.index.count : vertices;
+      return { mesh: mesh22, local, vertices, indexCount };
+    });
+    const totalVertices = pieces.reduce((sum, piece) => sum + piece.vertices, 0);
+    const totalIndices = pieces.reduce((sum, piece) => sum + piece.indexCount, 0);
+    const merged = new THREE.BufferGeometry();
+    const normalMatrix2 = new THREE.Matrix3();
+    for (const name of names) {
+      const size = first.geometry.attributes[name].itemSize;
+      const array = new Float32Array(totalVertices * size);
+      let offset = 0;
+      for (const piece of pieces) {
+        const matrix = follow ? identity : piece.local;
+        copyAttribute(name, piece.mesh.geometry.attributes[name], array, offset, matrix, normalMatrix2.getNormalMatrix(matrix));
+        offset += piece.vertices;
+      }
+      merged.setAttribute(name, new THREE.BufferAttribute(array, size));
+    }
+    const indexArray2 = totalVertices > 65535 ? new Uint32Array(totalIndices) : new Uint16Array(totalIndices);
+    const indexAttribute = new THREE.BufferAttribute(indexArray2, 1);
+    merged.setIndex(indexAttribute);
+    const mesh2 = follow ? skinnedBatch(THREE, merged, first.material, meshes) : new THREE.Mesh(merged, first.material);
+    mesh2.name = `batch:${first.material.name || first.material.type}`;
+    mesh2.castShadow = first.castShadow;
+    mesh2.receiveShadow = first.receiveShadow;
+    mesh2.raycast = () => void 0;
+    merged.computeBoundingBox();
+    merged.computeBoundingSphere();
+    group.add(mesh2);
+    const batch = { mesh: mesh2, live: pieces.length, index: indexAttribute };
+    const sources = [];
+    let vertexOffset = 0;
+    let indexOffset = 0;
+    for (const piece of pieces) {
+      const index = piece.mesh.geometry.index;
+      if (index) for (let at = 0; at < piece.indexCount; at++) indexArray2[indexOffset + at] = index.getX(at) + vertexOffset;
+      else for (let at = 0; at < piece.indexCount; at++) indexArray2[indexOffset + at] = at + vertexOffset;
+      sources.push({
+        mesh: piece.mesh,
+        geometry: piece.mesh.geometry,
+        material: piece.mesh.material,
+        version: piece.mesh.geometry.attributes.position.version,
+        local: piece.local,
+        world: piece.mesh.matrixWorld.clone(),
+        mask: piece.mesh.layers.mask,
+        batch,
+        start: indexOffset,
+        count: piece.indexCount,
+        released: false
+      });
+      piece.mesh.layers.set(BATCHED_LAYER);
+      vertexOffset += piece.vertices;
+      indexOffset += piece.indexCount;
+    }
+    return sources;
+  }
 
   // src/test-area/scenarios.ts
   var SKIN_COUNT = 40;
@@ -2960,6 +3496,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var SKIN_COUNT2 = 40;
   var SKIN_FIELD = { x0: -18, z0: -10, columns: 8, gap: 4.5 };
   var DEFAULT_TIME_SCALE = 60;
+  var BATCH_BUDGET_MS = 1;
   function createAnimalsTestModule(options = {}) {
     const locale = options.locale ?? "pt-BR";
     const text = TEXT[locale] ?? TEXT["pt-BR"];
@@ -2988,14 +3525,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       outbreak = options.createOutbreak ? options.createOutbreak({ species, enabled: settings.outbreak, timeScale: settings.timeScale }) : null;
     };
     rebuildOutbreak();
+    const batch = (entry) => {
+      entry.batcher?.dispose();
+      if (three) entry.batcher = createStaticBatcher(three, entry.rig.root, { followMeshes: true, budgetMs: BATCH_BUDGET_MS });
+    };
+    const look = (entry, state) => {
+      animals?.setVisualState(entry.rig, state);
+      batch(entry);
+    };
     const item = (animal) => ({
       id: `${ANIMAL_ITEM_PREFIX}${animal.id}`,
       name: animal.name[locale] ?? animal.id,
       movable: false,
       build: (THREE) => {
         const rig = ensure(THREE).build(animal);
-        placed.set(rig.root.uuid, { id: rig.root.uuid, rig });
+        const entry = { id: rig.root.uuid, rig };
+        placed.set(rig.root.uuid, entry);
         if (settings.visual !== "alive") animals?.setVisualState(rig, settings.visual);
+        batch(entry);
         return rig.root;
       }
     });
@@ -3004,7 +3551,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const state = outbreak.stateOf(entry.fate, clock);
       if (state === "incubating") return;
       entry.counted = state === "turned" ? "turned" : "dead";
-      animals?.setVisualState(entry.rig, visualStateOf(entry.rig.species.outcome, true, state === "dead"));
+      look(entry, visualStateOf(entry.rig.species.outcome, true, state === "dead"));
     };
     const clearRings = () => {
       discardObject3D(rings);
@@ -3055,7 +3602,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const applyVisual = () => {
       for (const entry of placed.values()) {
         if (entry.fate) continue;
-        animals?.setVisualState(entry.rig, settings.visual);
+        look(entry, settings.visual);
       }
     };
     const onChange = (change) => {
@@ -3064,13 +3611,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (change.id === "bite_all") {
           for (const entry of placed.values()) {
             entry.fate = outbreak?.bite(entry.rig.species.id, random, clock);
-            if (entry.fate) animals?.setVisualState(entry.rig, visualStateOf(entry.rig.species.outcome, true));
+            if (entry.fate) look(entry, visualStateOf(entry.rig.species.outcome, true));
           }
         } else if (change.id === "recover") {
           for (const entry of placed.values()) {
             delete entry.fate;
             delete entry.counted;
-            animals?.setVisualState(entry.rig, settings.visual);
+            look(entry, settings.visual);
           }
         } else if (change.id === "call" && sound) {
           for (const [id, entry] of placed) {
@@ -3110,12 +3657,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       sound?.update(dt);
       for (const [id, entry] of placed) {
         if (!entry.rig.root.parent) {
+          entry.batcher?.dispose();
           placed.delete(id);
           continue;
         }
         statusOf(entry);
         animals?.animate(entry.rig, { time, delta: dt * settings.speed, clip: settings.gait, split: host?.bench?.layer("split") ?? false });
         animals?.updateSplit(entry.rig, dt);
+        entry.batcher?.update();
       }
       for (const { rig, skin } of skins) {
         animals?.animate(rig, { time, delta: dt * settings.speed, clip: settings.gait });
@@ -3219,55 +3768,6 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     };
   }
-
-  // src/index.ts
-  var countTriangles = (root) => {
-    let triangles = 0;
-    root.traverse((object2) => {
-      const mesh2 = object2;
-      if (!mesh2.isMesh) return;
-      const geometry = mesh2.geometry;
-      triangles += geometry.index ? geometry.index.count / 3 : geometry.attributes.position.count / 3;
-    });
-    return Math.round(triangles);
-  };
-  var createAnimalsThree = (host, options = {}) => {
-    const THREE = shapeGeometries(host);
-    const random = options.random ?? createStream(options.seed ?? 7);
-    const documentOf = () => {
-      const found = options.document ?? globalThis.document;
-      if (!found) throw new Error("game-animals-three: a species with a coat texture needs `options.document` (no global document found)");
-      return found;
-    };
-    const jointMaterial = new THREE.MeshStandardMaterial({ color: 14722376, emissive: 14722376, emissiveIntensity: 0.8, roughness: 0.4 });
-    const gaits = GAIT_PHASES;
-    return {
-      jointMaterial,
-      build(species, buildOptions = {}) {
-        const rig = createRig(THREE, species, { phase: buildOptions.phase ?? random() * 6 });
-        if (species.body.kind === "snake") buildSnake(THREE, rig);
-        else if (species.body.kind === "bird") buildBird(THREE, rig, { extra: BIRD_EXTRAS[species.id] });
-        else buildQuadruped(THREE, rig, { document: species.body.texture ? documentOf() : void 0, extra: QUADRUPED_EXTRAS[species.id] });
-        rig.triangles = countTriangles(rig.root);
-        markKitOrigin(rig.root, { owner: "game-animals-three", kind: "animal", id: species.id });
-        rig.root.traverse((object2) => {
-          if (object2.isMesh) object2.userData.speciesId = species.id;
-        });
-        return rig;
-      },
-      animate(rig, params) {
-        const kind = rig.species.body.kind;
-        if (kind === "snake") animateSnake(THREE, rig, params);
-        else if (kind === "bird") animateBird(rig, params);
-        else animateQuadruped(rig, params, gaits);
-      },
-      setVisualState: (rig, state) => applyVisualState(THREE, rig, state),
-      setJointView: (rig, on) => setJointView(rig, on, jointMaterial),
-      setSplit,
-      updateSplit,
-      createSkin: (rig) => createNodeSkin(THREE, rig.root, { nodes: collectReferencedNodes(rig, ["species"]) })
-    };
-  };
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map