@adatechnology/game-animals-three 0.3.8 → 0.4.1

package/dist/index.global.js

@@ -45,6 +45,1555 @@ 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-7TLFY7VO.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"
+      ]
+    },
+    {
+      id: "kit",
+      master: 0.85,
+      compressor: {
+        threshold: -12,
+        ratio: 5
+      },
+      reverb: {
+        seconds: 2.2,
+        decay: 3.4,
+        wet: 0.4
+      },
+      noise: {
+        seconds: 2,
+        create: "eager"
+      },
+      sources: [
+        "sdk: the art scene chain (cena L1308-L1312) with a limiter after the compressor: the page has none, and a blast with its debris and a fire catching reached +7 dBFS"
+      ],
+      limiter: {
+        ceiling: -1,
+        knee: -6
+      }
+    }
+  ];
+  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"]
+      }
+    ]
+  };
+  var entries = (category, list2) => list2.map(([id, priority, current]) => ({ id, category, priority, ...current ? { current } : {} }));
+  var SFX_CATALOG = [
+    ...entries("armas", [
+      ["pistol_22lr", 2, "sfx_pistol"],
+      ["pistol_9mm", 1, "sfx_pistol"],
+      ["pistol_45", 1, "sfx_pistol"],
+      ["revolver_38_357", 2, "sfx_pistol"],
+      ["revolver_44_50ae", 3, "sfx_pistol"],
+      ["smg_9mm_auto", 1, "sfx_pistol"],
+      ["shotgun_12", 1, "sfx_shotgun"],
+      ["rifle_5_56", 1, "sfx_rifle"],
+      ["rifle_7_62x39", 1, "sfx_rifle"],
+      ["rifle_auto_burst", 1, "sfx_rifle"],
+      ["rifle_308_3006", 2, "sfx_rifle"],
+      ["sniper_338_300wm", 2, "sfx_rifle"],
+      ["antimateriel_50bmg", 3, "sfx_rifle"],
+      ["suppressed_pistol", 2],
+      ["suppressed_rifle", 2],
+      ["gunshot_far_pistol", 1],
+      ["gunshot_far_rifle", 1],
+      ["gunshot_far_shotgun", 1],
+      ["gunshot_far_heavy", 2],
+      ["gunshot_tail_indoor", 1],
+      ["gunshot_tail_outdoor", 1],
+      ["bullet_crack_by", 2],
+      ["bullet_whiz", 2],
+      ["ricochet_metal", 2, "ping"],
+      ["dry_fire", 1],
+      ["mag_out", 1],
+      ["mag_in", 1],
+      ["slide_pull_release", 1],
+      ["pump_cycle", 1],
+      ["casing_drop_concreto_pistol", 1],
+      ["casing_drop_concreto_rifle", 1],
+      ["casing_drop_concreto_shell", 1],
+      ["casing_drop_madeira_pistol", 1],
+      ["casing_drop_madeira_rifle", 1],
+      ["casing_drop_madeira_shell", 1],
+      ["casing_drop_metal_pistol", 1],
+      ["casing_drop_metal_rifle", 1],
+      ["casing_drop_metal_shell", 1],
+      ["casing_drop_terra_pistol", 1],
+      ["casing_drop_terra_rifle", 1],
+      ["casing_drop_terra_shell", 1],
+      ["rocket_fire", 2]
+    ]),
+    ...entries("explosoes-fogo", [
+      ["explosion_grenade", 1, "boom"],
+      ["explosion_big", 1, "boom_big"],
+      ["explosion_car", 2, "boom_big"],
+      ["explosion_far", 1],
+      ["debris_rain_stone", 1],
+      ["molotov_break_ignite", 1, "glass_shatter"],
+      ["fire_ignite", 1, "hiss"],
+      ["fire_loop_small", 1],
+      ["fire_loop_large", 1],
+      ["fire_extinguish", 2, "hiss"],
+      ["gas_leak_hiss", 2],
+      ["structure_collapse", 2, "crumble"]
+    ]),
+    ...entries("personagem", [
+      ["footstep_concrete_walk", 1, "sfx_step"],
+      ["footstep_wood_walk", 1, "sfx_step"],
+      ["footstep_dirt_walk", 1, "sfx_step"],
+      ["footstep_grass_walk", 1, "sfx_step"],
+      ["footstep_gravel_walk", 1, "sfx_step"],
+      ["land_concrete", 1, "sfx_step"],
+      ["punch_swing", 1],
+      ["punch_hit_body", 1, "sfx_flesh"],
+      ["kick_hit", 1, "sfx_flesh"],
+      ["knife_stab", 1],
+      ["blunt_hit", 1],
+      ["bite", 1, "sfx_flesh"],
+      ["body_fall", 1],
+      ["player_hurt", 2]
+    ]),
+    ...entries("veiculos", [
+      ["engine_loop_car", 1],
+      ["engine_start", 1],
+      ["crash_light", 1, "crash"],
+      ["crash_heavy", 1, "crash"],
+      ["car_door_open", 1, "latch"],
+      ["car_door_close", 1, "shut_metal"],
+      ["horn_car", 2, "horn"],
+      ["tire_skid_asphalt", 2]
+    ]),
+    ...entries("itens-portas", [
+      ["item_pickup_metal", 1],
+      ["can_open", 1],
+      ["can_crush", 1],
+      ["door_wood_open", 1, "latch"],
+      ["door_wood_close", 1, "shut_wood"],
+      ["door_creak", 1, "creak_wood"],
+      ["door_locked_rattle", 1, "rattle"],
+      ["drawer_open", 2, "slide"],
+      ["fridge_close", 2, "shut_metal"]
+    ]),
+    ...entries("ambiente", [
+      ["rain_loop", 2],
+      ["wind_loop", 2],
+      ["thunder_near", 2],
+      ["thunder_far", 2],
+      ["water_splash", 2]
+    ])
+  ];
+  var SFX_MATERIALS = [
+    ["steel", "metal"],
+    ["aluminium", "metal"],
+    ["wood", "wood"],
+    ["plywood", "wood"],
+    ["mdf", "wood"],
+    ["glass", "glass"],
+    ["tempered_glass", "glass"],
+    ["ceramic", "glass"],
+    ["concrete", "masonry"],
+    ["brick", "masonry"],
+    ["plaster", "masonry"],
+    ["plastic", "soft"],
+    ["fabric", "soft"],
+    ["paper", "soft"],
+    ["foliage", "soft"],
+    ["soil", "soft"],
+    ["flesh", "soft"]
+  ];
+  var SFX_BLOWS = ["bullet", "blunt", "blade", "break", "drag"];
+  var CURRENT_BY_GROUP = {
+    metal: { bullet: "clang", blunt: "clang", blade: "clang", break: "clang", drag: "drag_metal" },
+    wood: { bullet: "wood_hit", blunt: "wood_hit", blade: "wood_hit", break: "crack", drag: "drag_wood" },
+    glass: { bullet: "ping", blunt: "ping", break: "glass_shatter", drag: "drag_glass" },
+    masonry: { bullet: "chip", blunt: "chip", blade: "chip", break: "crumble", drag: "drag_masonry" },
+    soft: { bullet: "thud", blunt: "thud", blade: "thud", break: "thud", drag: "drag_soft" }
+  };
+  var impactSoundId = (material, blow) => `impact_${material}_${blow}`;
+  var SFX_IMPACTS = SFX_MATERIALS.flatMap(
+    ([material, group]) => SFX_BLOWS.map((blow) => {
+      const current = CURRENT_BY_GROUP[group]?.[blow];
+      return { id: impactSoundId(material, blow), category: "impactos", priority: ["steel", "wood", "glass", "concrete", "brick", "soil", "flesh"].includes(material) && blow === "bullet" ? 1 : 2, ...current ? { current } : {} };
+    })
+  );
+  var CALIBRATION_ID = "calibration_shot";
+  var PREFIX = "calibration/";
+  var url = (name) => `${PREFIX}${name}`;
+  var CALIBRATION_SOUND = {
+    id: CALIBRATION_ID,
+    bus: "weapons",
+    close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })),
+    far: ["far_1.wav", "far_2.wav"].map((name) => ({ url: url(name) })),
+    tiers: [
+      { name: "light", from: 0, close: ["light_1.wav", "light_2.wav"].map((name) => ({ url: url(name) })) },
+      { name: "medium", from: 0.34, close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })) },
+      { name: "heavy", from: 0.67, close: ["heavy_1.wav", "heavy_2.wav"].map((name) => ({ url: url(name) })) }
+    ],
+    tail: { indoor: [{ url: url("tail_in.wav") }], outdoor: [{ url: url("tail_out.wav") }] },
+    pitch: 0.04,
+    choke: { voices: 2 },
+    fallback: "sfx_pistol",
+    sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+  };
+  var CALIBRATION_LOOP_ID = "calibration_loop";
+  var CALIBRATION_LOOP_SOUND = {
+    id: CALIBRATION_LOOP_ID,
+    bus: "ambience",
+    close: ["loop_1.wav", "loop_2.wav", "loop_3.wav"].map((name) => ({ url: url(name) })),
+    loop: { crossfade: 0.15 },
+    sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+  };
+  var CRITERIA_TARGETS = {
+    /** C1: event to the first sample, and onset to the peak (one 60 fps frame). */
+    syncMs: 20,
+    peakAfterOnsetMs: 1e3 / 60,
+    /** C3: distances measured, metres. */
+    distances: [1, 10, 50, 200],
+    /** C5: plays, distinct takes and the pitch range (fraction). */
+    plays: 10,
+    minTakes: 4,
+    pitch: [0.03, 0.05],
+    /** C6: the highest peak, dBFS. */
+    peakDb: -1,
+    /** C8: the end of each file against its peak, dB. */
+    endDropDb: -40,
+    /** C9: a burst of rapid fire. */
+    burst: 20,
+    burstSpacing: 0.06
+  };
+  var PT = {
+    group: "Som",
+    name: "Painel de som (arquivos e C1\u2013C10)",
+    controls: {
+      category: "1 \xB7 Categoria",
+      sound: "1 \xB7 Som",
+      play: "1 \xB7 \u25B6 Tocar",
+      material: "2 \xB7 Material",
+      blow: "2 \xB7 Golpe",
+      strike: "2 \xB7 \u25B6 Tocar golpe",
+      distance: "3 \xB7 Dist\xE2ncia",
+      bearing: "3 \xB7 Dire\xE7\xE3o",
+      environment: "3 \xB7 Lugar",
+      strength: "3 \xB7 For\xE7a",
+      wall: "3 \xB7 Atr\xE1s da parede",
+      burst: "3 \xB7 Rajada 20\xD7",
+      play_a: "4 \xB7 \u25B6 A (atual)",
+      play_b: "4 \xB7 \u25B6 B (novo)",
+      ab_cycle: "4 \xB7 Alternar A/B",
+      blind: "4 \xB7 \xC0s cegas (X)",
+      reveal: "4 \xB7 Revelar X",
+      prefer_a: "4 \xB7 Prefiro A",
+      prefer_b: "4 \xB7 Prefiro B",
+      measure: "5 \xB7 Medir C1\u2013C10",
+      record: "5 \xB7 Gravar 3 s",
+      approve: "5 \xB7 Aprovo (C10)"
+    },
+    hints: {
+      sound: "A = arquivo, S = sintetizado, F = faltando. O que tem arquivo toca o arquivo; o resto toca o som atual.",
+      strike: "Toca impact_<material>_<golpe>: o arquivo se existir, sen\xE3o o som atual daquele material.",
+      wall: "P\xF5e a parede de casa entre voc\xEA e a fonte: o som fica abafado (C4).",
+      burst: "Vinte vezes a cada 60 ms, como uma rajada (C9).",
+      ab_cycle: "A, B, A, B, um por segundo.",
+      blind: "Toca A ou B sem dizer qual; depois revele.",
+      measure: "Mede o som escolhido no motor real (contexto offline): sincronia, som certo, dist\xE2ncia, lado, varia\xE7\xE3o, volume, for\xE7a, cauda e rajada.",
+      record: "Grava 3 s da sa\xEDda com o som tocando e baixa o arquivo (C10).",
+      approve: "Marca o C10 do som escolhido como aprovado pelo seu ouvido."
+    },
+    categories: {
+      armas: "Armas",
+      impactos: "Impactos",
+      "explosoes-fogo": "Explos\xF5es e fogo",
+      personagem: "Personagem",
+      veiculos: "Ve\xEDculos",
+      "itens-portas": "Itens e portas",
+      ambiente: "Ambiente",
+      calibracao: "Calibra\xE7\xE3o (SDK)"
+    },
+    blows: { bullet: "tiro", blunt: "soco/chute", blade: "faca", break: "quebra", drag: "arrasto/queda" },
+    materials: {
+      steel: "a\xE7o",
+      aluminium: "alum\xEDnio",
+      wood: "madeira",
+      plywood: "compensado",
+      mdf: "MDF",
+      glass: "vidro",
+      tempered_glass: "vidro temperado",
+      ceramic: "cer\xE2mica",
+      concrete: "concreto",
+      brick: "tijolo",
+      plaster: "gesso",
+      plastic: "pl\xE1stico",
+      fabric: "tecido",
+      paper: "papel\xE3o",
+      foliage: "folhagem",
+      soil: "terra",
+      flesh: "carne"
+    },
+    environments: { indoor: "interior", outdoor: "exterior" },
+    strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
+    states: { file: "A", synth: "S", missing: "F" },
+    criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
+    metrics: { chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+    run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
+    words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+    probe: "Fonte do som",
+    wall: "Parede (oclus\xE3o)",
+    scenarios: { pipeline: "Arquivo \u2192 decodifica \u2192 toca (round-robin, cauda)", criteria: "Crit\xE9rios C1\u2013C9 no som de calibra\xE7\xE3o", loop: "Loop de arquivo: emenda sem buraco (crossfade)", panel: "Painel: categorias, matriz, A/B e parede" }
+  };
+  var EN2 = {
+    ...PT,
+    group: "Sound",
+    name: "Sound panel (files and C1\u2013C10)",
+    controls: {
+      category: "1 \xB7 Category",
+      sound: "1 \xB7 Sound",
+      play: "1 \xB7 \u25B6 Play",
+      material: "2 \xB7 Material",
+      blow: "2 \xB7 Blow",
+      strike: "2 \xB7 \u25B6 Play blow",
+      distance: "3 \xB7 Distance",
+      bearing: "3 \xB7 Bearing",
+      environment: "3 \xB7 Place",
+      strength: "3 \xB7 Strength",
+      wall: "3 \xB7 Behind the wall",
+      burst: "3 \xB7 Burst 20\xD7",
+      play_a: "4 \xB7 \u25B6 A (current)",
+      play_b: "4 \xB7 \u25B6 B (new)",
+      ab_cycle: "4 \xB7 Alternate A/B",
+      blind: "4 \xB7 Blind (X)",
+      reveal: "4 \xB7 Reveal X",
+      prefer_a: "4 \xB7 Prefer A",
+      prefer_b: "4 \xB7 Prefer B",
+      measure: "5 \xB7 Measure C1\u2013C10",
+      record: "5 \xB7 Record 3 s",
+      approve: "5 \xB7 Approve (C10)"
+    },
+    hints: {
+      sound: "A = file, S = synthesized, F = missing. A file plays the file; the rest plays the current sound.",
+      strike: "Plays impact_<material>_<blow>: the file if there is one, else the current sound of that material.",
+      wall: "Puts the house wall between you and the source: the sound is muffled (C4).",
+      burst: "Twenty times every 60 ms, like a burst (C9).",
+      ab_cycle: "A, B, A, B, one a second.",
+      blind: "Plays A or B without saying which; reveal it after.",
+      measure: "Measures the chosen sound through the real engine (offline context): sync, right sound, distance, side, variation, level, strength, tail and burst.",
+      record: "Records 3 s of the output with the sound playing and downloads it (C10).",
+      approve: "Marks C10 of the chosen sound as approved by your ear."
+    },
+    categories: { armas: "Weapons", impactos: "Impacts", "explosoes-fogo": "Explosions and fire", personagem: "Character", veiculos: "Vehicles", "itens-portas": "Items and doors", ambiente: "Ambience", calibracao: "Calibration (SDK)" },
+    blows: { bullet: "bullet", blunt: "punch/kick", blade: "knife", break: "break", drag: "drag/fall" },
+    materials: {
+      steel: "steel",
+      aluminium: "aluminium",
+      wood: "wood",
+      plywood: "plywood",
+      mdf: "MDF",
+      glass: "glass",
+      tempered_glass: "tempered glass",
+      ceramic: "ceramic",
+      concrete: "concrete",
+      brick: "brick",
+      plaster: "plaster",
+      plastic: "plastic",
+      fabric: "fabric",
+      paper: "cardboard",
+      foliage: "foliage",
+      soil: "soil",
+      flesh: "flesh"
+    },
+    environments: { indoor: "indoor", outdoor: "outdoor" },
+    strengths: { light: "light", medium: "medium", heavy: "heavy" },
+    criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
+    metrics: { chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+    run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
+    words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+    probe: "Sound source",
+    wall: "Wall (occlusion)",
+    scenarios: { pipeline: "File \u2192 decode \u2192 play (round-robin, tail)", criteria: "Criteria C1\u2013C9 on the calibration sound", loop: "File loop: seamless joins (crossfade)", panel: "Panel: categories, matrix, A/B and wall" }
+  };
+
+  // ../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 sceneMany = (count, make2) => Array.from({ length: count }, make2);
+  var FOLEY_FALLOFF = {
+    model: "inverse_square",
+    k: 0.02,
+    cutoffK: 0.04,
+    minGain: 4e-3
+  };
+  var vary = (f, pct = 0.04) => [Math.round(f * (1 - pct)), Math.round(f * (1 + pct))];
+  var foley = (id, layers, note) => ({
+    id,
+    bus: "world",
+    pan: true,
+    layers,
+    falloff: FOLEY_FALLOFF,
+    sources: [`sdk: ${note}`]
+  });
+  var click = (f, vol, delay = 0) => [
+    sceneNoise({
+      type: "bandpass",
+      f: vary(f, 0.08),
+      q: 4,
+      d: [0.018, 0.03],
+      vol: [vol * 0.85, vol * 1.1],
+      delay
+    }),
+    sceneTone({
+      f: vary(f * 0.8, 0.06),
+      f2: Math.round(f * 0.62),
+      d: [0.015, 0.025],
+      vol: vol * 0.18,
+      delay
+    })
+  ];
+  var meet = (body, panel, vol, latch) => [
+    sceneTone({
+      f: vary(body),
+      f2: Math.round(body * 0.5),
+      d: [0.12, 0.16],
+      vol: [vol * 0.9, vol * 1.1]
+    }),
+    sceneNoise({
+      type: "bandpass",
+      f: vary(panel, 0.06),
+      q: 1.2,
+      d: [0.08, 0.12],
+      vol: [vol * 0.9, vol * 1.1],
+      wet: 0.25
+    }),
+    ...click(latch, vol * 0.45, [0.012, 0.028])
+  ];
+  var LEAF_FOLEY = [
+    // a wooden house door or wardrobe door: latch, a short creak, the leaf on the frame (the hard slam adds the frame rattling)
+    foley("door_wood_open", click(2400, 0.4), "the latch of a wooden door giving"),
+    foley(
+      "door_creak",
+      [
+        sceneTone({ f: [190, 240], f2: 310, d: [0.4, 0.55], vol: [0.04, 0.06] }),
+        sceneNoise({
+          type: "bandpass",
+          f: [480, 560],
+          q: 6,
+          a: 0.05,
+          d: [0.35, 0.5],
+          vol: [0.1, 0.14]
+        })
+      ],
+      "a wooden hinge turning"
+    ),
+    foley("door_wood_close", meet(120, 600, 0.55, 2400), "a wooden leaf meeting its frame"),
+    foley(
+      "door_wood_slam",
+      [
+        ...meet(110, 560, 0.85, 2300),
+        ...sceneMany(
+          3,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [900, 1500],
+            q: 3,
+            d: 0.03,
+            vol: [0.08, 0.14],
+            delay: [0.05, 0.18]
+          })
+        )
+      ],
+      "a wooden door slammed: the frame and the hinges rattle after the hit"
+    ),
+    // a metal door or gate: a hollow panel that rings a little
+    foley("door_metal_open_close", [...meet(160, 900, 0.55, 2e3), sceneTone({ f: vary(1250), f2: 1150, d: [0.1, 0.16], vol: 0.06, wet: 0.3 })], "a metal door or gate meeting its frame"),
+    foley(
+      "door_creak_metal",
+      [
+        sceneTone({ f: [620, 760], f2: 900, d: [0.3, 0.4], vol: [0.03, 0.045] }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1300, 1500],
+          q: 8,
+          a: 0.04,
+          d: [0.25, 0.35],
+          vol: [0.07, 0.09]
+        })
+      ],
+      "a metal hinge turning"
+    ),
+    // the handle of a locked door shaken: the latch knocking in its keeper, five to seven times in half a second
+    foley(
+      "door_locked_rattle",
+      [
+        ...sceneMany(
+          6,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [1600, 2600],
+            q: 3,
+            d: [0.025, 0.04],
+            vol: [0.22, 0.34],
+            delay: [0, 0.45]
+          })
+        ),
+        ...sceneMany(
+          3,
+          () => sceneTone({
+            f: [170, 210],
+            f2: 120,
+            d: 0.05,
+            vol: [0.12, 0.18],
+            delay: [0.02, 0.4]
+          })
+        )
+      ],
+      "the handle of a locked door shaken: latch knocks and the leaf thumping in its frame"
+    ),
+    // a fridge: the rubber seal lets go with a soft suck, the bottles in the door clink; closing it is a soft thump and the seal pulling shut
+    foley(
+      "fridge_open",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [320, 380],
+          a: 0.03,
+          d: [0.14, 0.2],
+          vol: [0.32, 0.4]
+        }),
+        sceneNoise({
+          type: "bandpass",
+          f: [800, 950],
+          f2: 1400,
+          q: 2,
+          a: 0.02,
+          d: 0.12,
+          vol: [0.08, 0.12]
+        }),
+        ...sceneMany(
+          2,
+          () => sceneTone({
+            f: [2600, 4200],
+            d: [0.04, 0.08],
+            vol: [0.015, 0.03],
+            delay: [0.08, 0.22]
+          })
+        )
+      ],
+      "a fridge door: the seal letting go and the bottles in the door"
+    ),
+    foley(
+      "fridge_close",
+      [
+        sceneTone({ f: vary(85), f2: 45, d: [0.1, 0.13], vol: [0.38, 0.46] }),
+        sceneNoise({
+          type: "lowpass",
+          f: [520, 620],
+          d: [0.08, 0.12],
+          vol: [0.3, 0.36]
+        }),
+        sceneNoise({
+          type: "lowpass",
+          f: [260, 320],
+          a: 0.02,
+          d: 0.1,
+          vol: [0.12, 0.18],
+          delay: [0.04, 0.07]
+        }),
+        ...sceneMany(
+          2,
+          () => sceneTone({
+            f: [2600, 4200],
+            d: [0.04, 0.07],
+            vol: [0.015, 0.03],
+            delay: [0.03, 0.12]
+          })
+        )
+      ],
+      "a fridge door shut: a soft thump, the seal pulling and the bottles"
+    ),
+    // a microwave: the spring catch of the door, plastic on plastic
+    foley(
+      "microwave_open",
+      [
+        ...click(1800, 0.34),
+        sceneTone({
+          f: [3e3, 3400],
+          f2: 2800,
+          d: 0.05,
+          vol: 0.025,
+          delay: [0.01, 0.02]
+        })
+      ],
+      "the spring catch of a microwave door"
+    ),
+    foley(
+      "microwave_close",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1200, 1450],
+          q: 2.5,
+          d: [0.04, 0.06],
+          vol: [0.36, 0.44]
+        }),
+        sceneTone({ f: vary(180), f2: 120, d: 0.05, vol: [0.16, 0.22] }),
+        ...click(2200, 0.2, [8e-3, 0.016])
+      ],
+      "a microwave door clacking shut"
+    ),
+    foley("microwave_beep", [sceneTone({ wave: "square", f: 2e3, d: 0.12, vol: 0.05 })], "the beep of a microwave"),
+    // drawers and sliding leaves: the runners, then the stop
+    foley(
+      "drawer_open",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [620, 780],
+          q: 2,
+          a: 0.04,
+          d: [0.28, 0.36],
+          vol: [0.18, 0.24]
+        }),
+        sceneNoise({ type: "bandpass", f: [2e3, 2400], q: 5, d: 0.28, vol: 0.04 }),
+        ...click(1400, 0.16, [0.28, 0.34])
+      ],
+      "a drawer on its runners and its stop"
+    ),
+    foley(
+      "drawer_close",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [620, 780],
+          q: 2,
+          a: 0.03,
+          d: [0.2, 0.28],
+          vol: [0.18, 0.24]
+        }),
+        sceneTone({
+          f: vary(150),
+          f2: 90,
+          d: 0.08,
+          vol: [0.22, 0.3],
+          delay: [0.2, 0.26]
+        })
+      ],
+      "a drawer pushed home"
+    )
+  ];
+  var ITEM_FOLEY = [
+    // the hand closing on the item: a touch of skin and cloth, then the item's own small sound
+    foley(
+      "item_pickup_metal",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneTone({
+          f: [1900, 2600],
+          f2: 1700,
+          d: [0.05, 0.08],
+          vol: [0.06, 0.09],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a metal thing"
+    ),
+    foley(
+      "item_pickup_plastic",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1500, 1900],
+          q: 3,
+          d: 0.03,
+          vol: [0.15, 0.21],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a plastic thing"
+    ),
+    foley(
+      "item_pickup_glass",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.15 }),
+        sceneTone({
+          f: [3200, 4200],
+          d: [0.05, 0.08],
+          vol: [0.038, 0.06],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a glass thing"
+    ),
+    foley(
+      "item_pickup_paper",
+      [
+        sceneNoise({
+          type: "highpass",
+          f: [2600, 3400],
+          a: 0.01,
+          d: [0.1, 0.14],
+          vol: [0.12, 0.18]
+        }),
+        sceneNoise({ type: "bandpass", f: [800, 1e3], q: 1, d: 0.05, vol: 0.12 })
+      ],
+      "picking up paper or cardboard"
+    ),
+    foley(
+      "item_pickup_fabric",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [900, 1300],
+          q: 0.8,
+          a: 0.02,
+          d: [0.12, 0.16],
+          vol: [0.15, 0.21]
+        })
+      ],
+      "picking up cloth"
+    ),
+    foley(
+      "item_pickup_wood",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "bandpass",
+          f: [900, 1100],
+          q: 2,
+          d: 0.04,
+          vol: [0.15, 0.21],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a wooden thing"
+    ),
+    foley(
+      "item_pickup_food",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "lowpass",
+          f: [500, 650],
+          d: 0.05,
+          vol: 0.12,
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up food"
+    ),
+    foley(
+      "item_throw",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [450, 650],
+          f2: 1400,
+          q: 1.5,
+          a: 0.05,
+          d: 0.18,
+          vol: [0.1, 0.14]
+        })
+      ],
+      "the arm throwing something: air"
+    ),
+    // a can: the tab cracks, the gas hisses out; drinking is gulps; crushing it crumples the sheet
+    foley(
+      "can_open",
+      [
+        ...click(3200, 0.36),
+        sceneNoise({
+          type: "highpass",
+          f: [3600, 4400],
+          a: 5e-3,
+          d: [0.22, 0.3],
+          vol: [0.16, 0.22],
+          delay: [0.012, 0.02]
+        }),
+        ...sceneMany(5, () => sceneTone({ f: [4e3, 7e3], d: 0.02, vol: 0.01, delay: [0.05, 0.4] }))
+      ],
+      "the tab of a can and the gas hissing out"
+    ),
+    foley(
+      "can_crush",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1600, 2200],
+          q: 1.2,
+          d: [0.18, 0.25],
+          vol: [0.3, 0.38]
+        }),
+        ...sceneMany(
+          6,
+          () => sceneTone({
+            f: [1200, 3400],
+            f2: 900,
+            d: 0.03,
+            vol: [0.03, 0.06],
+            delay: [0, 0.2]
+          })
+        )
+      ],
+      "a can crushed in the hand"
+    ),
+    foley(
+      "can_puncture_spray",
+      [
+        sceneNoise({
+          type: "highpass",
+          f: [2400, 3e3],
+          a: 5e-3,
+          d: [0.5, 0.7],
+          vol: [0.2, 0.26]
+        }),
+        sceneNoise({ type: "bandpass", f: [600, 800], q: 2, d: 0.4, vol: 0.06 })
+      ],
+      "a can holed: the jet hissing out"
+    ),
+    foley(
+      "bottle_open",
+      [
+        ...sceneMany(
+          5,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [2200, 3e3],
+            q: 4,
+            d: 8e-3,
+            vol: [0.1, 0.16],
+            delay: [0, 0.18]
+          })
+        ),
+        sceneNoise({
+          type: "highpass",
+          f: 3800,
+          a: 5e-3,
+          d: 0.12,
+          vol: [0.06, 0.1],
+          delay: [0.18, 0.22]
+        })
+      ],
+      "the screw cap of a bottle turning off"
+    ),
+    foley(
+      "drink_gulp",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [280, 360],
+          a: 0.02,
+          d: [0.1, 0.14],
+          vol: [0.24, 0.3]
+        }),
+        sceneTone({ f: [140, 170], f2: 85, d: [0.08, 0.11], vol: [0.12, 0.16] })
+      ],
+      "a gulp"
+    ),
+    foley(
+      "eat_crunch",
+      [
+        ...sceneMany(
+          4,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [1800, 3200],
+            q: 1.5,
+            d: [0.02, 0.04],
+            vol: [0.12, 0.2],
+            delay: [0, 0.12]
+          })
+        )
+      ],
+      "a bite of something crunchy"
+    ),
+    foley(
+      "eat_chew",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [450, 600],
+          a: 0.03,
+          d: [0.1, 0.14],
+          vol: [0.12, 0.16]
+        }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1100, 1400],
+          q: 2,
+          d: 0.04,
+          vol: 0.04,
+          delay: [0.03, 0.06]
+        })
+      ],
+      "chewing"
+    ),
+    foley(
+      "bandage_wrap",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1400, 1800],
+          f2: 2400,
+          q: 1,
+          a: 0.04,
+          d: [0.3, 0.4],
+          vol: [0.12, 0.16]
+        })
+      ],
+      "a bandage unrolled round a limb"
+    ),
+    foley(
+      "pills_shake",
+      [
+        ...sceneMany(
+          8,
+          () => sceneTone({
+            f: [2400, 3600],
+            d: 0.015,
+            vol: [0.03, 0.05],
+            delay: [0, 0.25]
+          })
+        ),
+        sceneNoise({ type: "bandpass", f: [1500, 1900], q: 2, d: 0.25, vol: 0.05 })
+      ],
+      "pills shaken in their bottle"
+    ),
+    foley(
+      "medkit_use",
+      [
+        ...click(1700, 0.24),
+        sceneNoise({
+          type: "bandpass",
+          f: [1e3, 1400],
+          q: 1,
+          a: 0.03,
+          d: [0.25, 0.32],
+          vol: [0.08, 0.12],
+          delay: [0.05, 0.08]
+        })
+      ],
+      "a first aid kit opened and rummaged"
+    ),
+    foley("flashlight_click", click(2600, 0.3), "the switch of a flashlight")
+  ];
+  var FOLEY_BANK = {
+    id: "foley",
+    sounds: [...LEAF_FOLEY, ...ITEM_FOLEY]
+  };
+  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 +1641,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;
-  }
-
-  // ../game-shapes/dist/chunk-R4RY23RH.js
+  // 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-M5N2SHNL.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));
@@ -1348,8 +2908,8 @@ var GameAnimalsThree = (() => {
       groups: []
     };
   }
-  function make(kind, p) {
-    switch (kind) {
+  function make(p) {
+    switch (p.kind) {
       case "box": {
         const size = p.size ?? [1, 1, 1];
         const segments = p.segments ?? [1, 1, 1];
@@ -1378,7 +2938,7 @@ var GameAnimalsThree = (() => {
       case "mesh":
         return mesh(p);
       default:
-        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+        throw new Error(`game-shapes: unknown primitive kind "${String(p.kind)}"`);
     }
   }
   var templates = /* @__PURE__ */ new Map();
@@ -1386,7 +2946,7 @@ var GameAnimalsThree = (() => {
   var stats = { hits: 0, misses: 0 };
   function buildPrimitive(node, options = {}) {
     const parameters = primitiveParameters(node, options);
-    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    if (node.kind === "mesh" || templateLimit === 0) return make({ ...node, ...parameters });
     const key = `${node.kind}:${canonicalJson(parameters)}`;
     const cached = templates.get(key);
     if (cached) {
@@ -1396,10 +2956,10 @@ var GameAnimalsThree = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
-    templates.set(key, built);
+    const built2 = make({ ...node, ...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 +3262,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 = [
@@ -2062,112 +3750,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var animateSnake = (THREE, rig, params) => {
     const { time: t, delta: dt, clip } = params;
-    const spacing = rig.segmentLength * (params.split ? 1.5 : 1);
-    if (clip === "walk") rig.phase += dt * 2.4;
-    const points = bodyPath(THREE, rig, params, spacing);
-    const at = (index) => points[index];
-    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 spacing = rig.segmentLength * (params.split ? 1.5 : 1);
+    if (clip === "walk") rig.phase += dt * 2.4;
+    const points = bodyPath(THREE, rig, params, spacing);
+    const at = (index) => points[index];
+    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/bird.ts
@@ -2254,94 +3857,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 = [
@@ -2537,303 +4052,261 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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 +4433,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 +4462,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 +4488,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 +4539,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 +4548,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 +4594,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 +4705,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