@adatechnology/game-crowd-three 0.3.8 → 0.4.0

package/dist/chunk-PXT6DYGJ.js

@@ -0,0 +1,1707 @@
+// src/bench/module.ts
+import { CROWD_PHYSICS_DEFAULTS, HERD_ROLES, STATE as STATE3, bindInfection, carrionCenter, createCivilians, createCrowd, createFlock, createHerd, createRng } from "@adatechnology/game-crowd";
+import { createPlayer } from "@adatechnology/game-player";
+
+// src/audio/bank.ts
+import { DISTANCE_CURVES } from "@adatechnology/game-audio";
+var scream = {
+  id: "scream_hoarse",
+  bus: "voices",
+  order: "scream",
+  duration: [1, 1.4],
+  layers: [
+    {
+      source: { kind: "noise", offset: "random" },
+      filters: {
+        mode: "parallel",
+        bank: [
+          { type: "bandpass", q: 6, frequency: { from: 700 * 1.15, to: 700 * 0.8, curve: "linear", over: "duration" }, level: 1 },
+          { type: "bandpass", q: 8, frequency: { from: 1150 * 1.15, to: 1150 * 0.8, curve: "linear", over: "duration" }, level: 0.7 },
+          { type: "bandpass", q: 10, frequency: { from: 2600 * 1.15, to: 2600 * 0.8, curve: "linear", over: "duration" }, level: 0.35 }
+        ]
+      },
+      modulators: [{ target: "gain", wave: "square", rate: [31, 40], depth: 0.35 }],
+      envelope: [
+        [0, 0, "set"],
+        [0.06, 0.9, "linear"],
+        ["0.6d", 0.9, "set"],
+        ["1d", 1e-3, "exp", "fixed"]
+      ]
+    }
+  ],
+  falloff: DISTANCE_CURVES.game_scream,
+  sources: ["jogo:L62128-62142"]
+};
+var groanLayer = (base) => ({
+  source: {
+    kind: "osc",
+    wave: "sawtooth",
+    frequency: typeof base === "number" ? { from: base, to: base * 0.7, curve: "linear", over: "duration" } : { from: base, to: { ...base, scale: 0.7 }, curve: "linear", over: "duration" }
+  },
+  filters: { mode: "serial", bank: [{ type: "bandpass", q: 3, frequency: { set: typeof base === "number" ? base * 3 : { ...base, scale: 3 } } }] },
+  envelope: [
+    [0, 0, "set"],
+    [0.15, 0.25, "linear"],
+    ["1d", 1e-3, "exp", "fixed"]
+  ]
+});
+var groan = {
+  id: "groan",
+  bus: "voices",
+  order: "groan",
+  vars: { base: [95, 135], dur: [0.9, 1.5] },
+  duration: { param: "dur" },
+  layers: [groanLayer({ param: "base" })],
+  falloff: DISTANCE_CURVES.game_voice,
+  sources: ["jogo:L62143-62155 gemido"]
+};
+var runnerGroan = {
+  id: "runner_groan",
+  bus: "voices",
+  order: "groan",
+  vars: { dur: [0.9, 1.5] },
+  duration: { param: "dur" },
+  layers: [groanLayer(300)],
+  falloff: DISTANCE_CURVES.game_voice,
+  sources: ["jogo:L62143-62155 corredor"]
+};
+var call = (id, options) => ({
+  id,
+  bus: "world",
+  order: "calls",
+  duration: options.seconds,
+  tail: 0.02,
+  keepSilent: true,
+  layers: [
+    {
+      repeat: { count: options.count, spacing: options.spacing },
+      source: { kind: "osc", wave: options.wave, frequency: { from: options.frequency, to: options.frequency * options.drop, curve: "exp", over: "duration" } },
+      filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: options.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"]
+});
+var CROWD_SOUND_BANK = {
+  id: "crowd",
+  sounds: [
+    scream,
+    groan,
+    runnerGroan,
+    call("dog_bark", { count: 2, spacing: 0.22, seconds: 0.12, wave: "square", frequency: 520, drop: 0.6 }),
+    call("lapwing_call", { count: 3, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 2400, drop: 0.6 }),
+    call("hen_cluck", { count: 4, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 900, drop: 0.6 }),
+    call("cow_moo", { count: 1, spacing: 0.14, seconds: 1.2, wave: "sawtooth", frequency: 140, drop: 0.8 })
+  ]
+};
+var HERD_SOUND_IDS = { bark: "dog_bark", lapwing: "lapwing_call", cluck: "hen_cluck", moo: "cow_moo" };
+
+// src/herd-view.ts
+function createHerdView(three, options) {
+  const group = new three.Group();
+  group.name = "herd";
+  const drawn = /* @__PURE__ */ new Map();
+  const sky = [];
+  const build = (E) => {
+    const species = options.species(E.spec.species);
+    if (!species) return null;
+    const rig = options.drawer.build(species);
+    rig.root.position.set(E.x, 0, E.z);
+    if (E.dead) options.drawer.setVisualState?.(rig, "dead");
+    group.add(rig.root);
+    drawn.set(E, rig);
+    if (E.spec.sky) sky.push(E);
+    return rig;
+  };
+  return {
+    group,
+    update(dt) {
+      for (const E of options.herd.list) if (!drawn.has(E)) build(E);
+      const time = options.herd.time;
+      for (const [E, rig] of drawn) {
+        if (E.spec.sky) continue;
+        rig.root.position.set(E.x, 0, E.z);
+        rig.root.rotation.y = E.yaw;
+        options.drawer.animate(rig, { time, delta: dt, clip: E.clip });
+      }
+      sky.forEach((E, i) => {
+        const rig = drawn.get(E);
+        const U = options.flock?.birds[i];
+        if (!rig || !U) return;
+        rig.root.position.set(U.x, U.y, U.z);
+        rig.root.rotation.set(0, U.yaw, U.roll);
+        rig.root.visible = U.visible;
+        if (!U.visible) return;
+        rig.phase = U.wing;
+        for (const w of rig.wings) {
+          w.shoulder.rotation.y = 0;
+          w.elbow.rotation.y = 0;
+          w.shoulder.rotation.z = w.side * (0.18 + Math.sin(U.wing * 0.4) * 0.05);
+        }
+      });
+    },
+    get count() {
+      return drawn.size;
+    },
+    clear() {
+      for (const rig of drawn.values()) group.remove(rig.root);
+      drawn.clear();
+      sky.length = 0;
+    }
+  };
+}
+
+// src/instances.ts
+import { INSTANCE_POSES, walkGait } from "@adatechnology/game-characters";
+import { STAGGER_POSE } from "@adatechnology/game-characters-three";
+import { MISSING, STATE } from "@adatechnology/game-crowd";
+
+// src/data/render.json
+var render_default = {
+  sources: {
+    agents: "jogo.js G 67098-67121 hordeRender: view cull (behind beyond 0.35\xB7d + 3 m once past \u221A30 m, nothing past 200 m), LOD [18, 55] m with 1.5 m of hysteresis, attack pose in at 1.6 m and out at 2.2 m, the pose by state, the bloater's swelling, the eye only with the skull and awake",
+    corpses: "jogo.js G 67122-67131 hordeRender: an agent's body on its variant at the near level within 18 m (else the middle), the fallen pose, the colour darkening 70% over the body's life, the last 60 s shrinking it; a body that was not an agent on the plain body batch",
+    civilians: "jogo.js G 70177-70184 npcRender: one baked body per survivor, a child 0.66 high and 0.75 wide, the bite showing as 0.3 of age",
+    batches: "jogo.js G 67079-67094 ZVAR, CB: each variant at 1, 0.5 and 0.28 of detail in batches of 160, 700 and 2600; the plain corpse batch at the middle body (BODY_LOD[1]) for 400; G 68469 PB: survivors baked at 0.8 in batches of 4"
+  },
+  numbers: {
+    lodDistances: [18, 55],
+    lodHysteresis: 1.5,
+    behindFrom: 30,
+    behindFactor: 0.35,
+    behindMargin: 3,
+    farCull: 200,
+    gaitMax: 1.4,
+    attackEnter: 2.56,
+    attackLeave: 4.84,
+    swell: 0.9,
+    swellPivot: 0.5,
+    ageBase: 0.75,
+    agePer: 0.08,
+    armBase: 1,
+    armPer: 0.4,
+    corpseNear: 18,
+    corpseFade: 60,
+    corpseDarken: 0.7,
+    corpseRise: 1.8,
+    corpseAgeBase: 0.8,
+    corpseAgeDark: 0.2,
+    childHeight: 0.66,
+    childBuild: 0.75,
+    bittenLook: 0.3,
+    civilianSkinStep: 0.25,
+    civilianBake: 0.8,
+    civilianBatch: 4
+  },
+  poses: {
+    dormant: "fallen",
+    airborne: "leap",
+    eating: "eat",
+    pileStep: "attack",
+    swing: "scream",
+    crawl: "crawl",
+    grab: "attack",
+    calling: "scream",
+    default: "walk",
+    corpse: "fallen",
+    civilian: "walk"
+  }
+};
+
+// src/variety/look.ts
+import { BALANCE, unit } from "@adatechnology/game-crowd";
+import { ACCESSORY_BIT, packIdentity } from "@adatechnology/game-characters-three";
+var VARIETY_DEFAULTS = {
+  capChance: 0.16,
+  backpackChance: 0.2,
+  hoodChance: 0.1,
+  /** Chance of a wound in a region at the youngest infection age, and how much each age step adds. */
+  woundBase: 0.05,
+  woundPerAge: 0.12,
+  /** Share of the wounds that are severe. */
+  severeShare: 0.35,
+  /** Steps of the infection age of the pack (0 .. ageSteps). */
+  ageSteps: 3,
+  /** How much of a shove's push (0..1) tilts the body. */
+  leanScale: 0.3
+};
+var LOOK_SALT = { TROUSERS: 499969, CAP: 500226, BACKPACK: 500483, HOOD: 500740, WOUND: 500997, FRESH: 501254 };
+var REGIONS = 6;
+var TROUSER_COUNT = 16;
+var WOUND_BITS = 2;
+var FRESHEST = 15;
+var FRESH_STEPS = 12;
+var LEAN_MIN = 0.02;
+var woundsOf = (store, i, identity, ageNorm, N) => {
+  const own = store.wounds[i];
+  const chance = N.woundBase + N.woundPerAge * ageNorm;
+  let wounds = 0;
+  for (let region = 0; region < REGIONS; region++) {
+    const draw = unit(identity, region, LOOK_SALT.WOUND);
+    const drawn = draw < chance * N.severeShare ? 2 : draw < chance ? 1 : 0;
+    wounds |= Math.max(own >> region * WOUND_BITS & 3, drawn) << region * WOUND_BITS;
+  }
+  return wounds;
+};
+var accessoriesOf = (store, i, identity, N) => {
+  let bits = store.helmet[i] ? ACCESSORY_BIT.HELMET : unit(identity, 0, LOOK_SALT.CAP) < N.capChance ? ACCESSORY_BIT.CAP : 0;
+  if (!bits && unit(identity, 0, LOOK_SALT.HOOD) < N.hoodChance) bits |= ACCESSORY_BIT.EXTRA;
+  if (unit(identity, 0, LOOK_SALT.BACKPACK) < N.backpackChance) bits |= ACCESSORY_BIT.BACKPACK;
+  return bits;
+};
+var leanOf = (store, i, N) => {
+  const lx = store.leanX[i];
+  const lz = store.leanZ[i];
+  const size = Math.min(1, Math.hypot(lx, lz));
+  if (size < LEAN_MIN) return { leanAngle: 0, leanAmount: 0 };
+  const yaw = store.renderYaw[i];
+  const cos = Math.cos(yaw);
+  const sin = Math.sin(yaw);
+  return { leanAngle: Math.atan2(cos * lx - sin * lz, sin * lx + cos * lz), leanAmount: size * N.leanScale };
+};
+var lookOfAgent = (store, i, N, extra = {}) => {
+  const identity = store.identity[i];
+  const ageNorm = Math.min(1, store.age[i] / N.ageSteps);
+  const wounds = woundsOf(store, i, identity, ageNorm, N);
+  const fresh = store.wounds[i] ? FRESHEST : Math.max(0, Math.min(FRESHEST, FRESHEST - Math.round(ageNorm * FRESH_STEPS) + Math.floor(unit(identity, 0, LOOK_SALT.FRESH) * 4)));
+  return {
+    wounds,
+    freshness: fresh,
+    trousers: Math.floor(unit(identity, 0, LOOK_SALT.TROUSERS) * TROUSER_COUNT),
+    gaitStyle: store.gaitStyle[i],
+    accessories: accessoriesOf(store, i, identity, N),
+    ...leanOf(store, i, N),
+    ...extra
+  };
+};
+var isStaggering = (store, i) => store.balance[i] === BALANCE.STAGGERING;
+var packLook = (look) => packIdentity(look);
+
+// src/instances.ts
+var CROWD_RENDER_DEFAULTS = {
+  sources: render_default.sources,
+  numbers: render_default.numbers,
+  poses: render_default.poses
+};
+var IMPOSTOR_LEVEL = 3;
+var BUDGET_BIN = 0.25;
+var SORT_BINS = 130;
+var sortBin = (distance) => distance < 0 ? 0 : Math.min(SORT_BINS - 1, 1 + Math.floor(distance * 2));
+var CORPSE_REACH = 60;
+var EDGE_SHRINK = 0.3;
+var EDGE_GROW = 0.15;
+var poseIndex = (pose) => INSTANCE_POSES.indexOf(pose);
+var STAGGER_FAMILY = 6;
+var clipsOf = (store, i, staggering) => {
+  const family = staggering ? STAGGER_FAMILY : Math.min(store.gaitStyle[i], STAGGER_FAMILY - 1);
+  return { clips: true, clipA: family * 2, clipB: family * 2 + 1, clipBlend: Math.min(1, Math.max(0, store.arms[i])) };
+};
+var lookFields = (store, i, numbers, clips, staggering) => {
+  const look = lookOfAgent(store, i, numbers, clips ? clipsOf(store, i, staggering) : {});
+  return { d: packLook(look), accessories: look.accessories, type: store.type[i] };
+};
+function createCrowdInstances(options) {
+  const N = { ...render_default.numbers, ...options.numbers };
+  const P = { ...render_default.poses, ...options.poses };
+  const pose = {
+    dormant: poseIndex(P.dormant),
+    airborne: poseIndex(P.airborne),
+    eating: poseIndex(P.eating),
+    pileStep: poseIndex(P.pileStep),
+    swing: poseIndex(P.swing),
+    crawl: poseIndex(P.crawl),
+    grab: poseIndex(P.grab),
+    calling: poseIndex(P.calling),
+    walk: poseIndex(P.default),
+    corpse: poseIndex(P.corpse),
+    civilian: poseIndex(P.civilian)
+  };
+  const [near, middle] = N.lodDistances;
+  const variety = options.variety ? { ...VARIETY_DEFAULTS, ...options.variety.numbers } : null;
+  const impostorFrom = options.variety?.impostorFrom;
+  const segmentClips = options.variety?.segmentClips === true;
+  const lodEdges = impostorFrom === void 0 ? [near, middle] : [near, middle, impostorFrom];
+  const lastLevel = lodEdges.length;
+  const budget = options.variety?.budget;
+  const edges = [...lodEdges];
+  const bands = lodEdges.map(() => N.lodHysteresis);
+  const histogram = new Uint32Array(budget ? Math.max(1, Math.ceil(lodEdges[lastLevel - 1] / BUDGET_BIN) + 1) : 0);
+  let distances = new Float32Array(0);
+  let order = new Uint32Array(0);
+  const sortStarts = new Uint32Array(SORT_BINS + 1);
+  const behindFrom = N.behindFrom;
+  const farSquared = N.farCull * N.farCull;
+  const fitEdges = (scale) => {
+    let allowed = 0;
+    let seen = 0;
+    let bin = 0;
+    let previous = 0;
+    for (let level = 0; level < lastLevel; level++) {
+      allowed += Math.round((budget[level] ?? Infinity) * scale);
+      while (bin < histogram.length && seen + histogram[bin] <= allowed) seen += histogram[bin++];
+      const reach = bin < histogram.length ? bin * BUDGET_BIN : lodEdges[level];
+      const target = Math.max(previous, Math.min(lodEdges[level], reach));
+      edges[level] = Math.min(edges[level] + EDGE_GROW, Math.max(edges[level] - EDGE_SHRINK, target));
+      bands[level] = N.lodHysteresis * Math.min(1, edges[level] / lodEdges[level]);
+      previous = target;
+    }
+  };
+  const nearestFirst = (count) => {
+    sortStarts.fill(0);
+    for (let i = 0; i < count; i++) sortStarts[sortBin(distances[i]) + 1]++;
+    for (let b = 0; b < SORT_BINS; b++) sortStarts[b + 1] += sortStarts[b];
+    for (let i = 0; i < count; i++) order[sortStarts[sortBin(distances[i])]++] = i;
+  };
+  const corpseHistogram = new Uint32Array(budget ? Math.ceil(CORPSE_REACH / BUDGET_BIN) + 1 : 0);
+  const fitCorpseEdges = (entries, cx, cz, scale) => {
+    if (!budget) return [N.corpseNear, Infinity];
+    corpseHistogram.fill(0);
+    for (const { data } of entries) {
+      const distance = Math.hypot(data.x - cx, data.z - cz);
+      if (distance < CORPSE_REACH) corpseHistogram[Math.floor(distance / BUDGET_BIN)]++;
+    }
+    let seen = 0;
+    let bin = 0;
+    const edgeFor = (allowed, nominal) => {
+      while (bin < corpseHistogram.length && seen + corpseHistogram[bin] <= allowed) seen += corpseHistogram[bin++];
+      return bin < corpseHistogram.length ? Math.min(nominal, bin * BUDGET_BIN) : nominal;
+    };
+    const near2 = edgeFor(Math.round((budget[3] ?? (budget[0] ?? Infinity) / 2) * scale), N.corpseNear);
+    const middle2 = edgeFor(Math.round(((budget[3] ?? (budget[0] ?? Infinity) / 2) + (budget[4] ?? (budget[1] ?? Infinity) / 2)) * scale), Infinity);
+    return [near2, Math.max(near2, middle2)];
+  };
+  return {
+    numbers: N,
+    agents(Z, variants, frame, sink) {
+      const cx = frame.camera.x;
+      const cz = frame.camera.z;
+      const fx = -Math.sin(frame.viewYaw);
+      const fz = -Math.cos(frame.viewYaw);
+      const target = frame.target;
+      let written = 0;
+      if (distances.length < Z.n) distances = new Float32Array(Math.max(Z.n, distances.length * 2));
+      if (budget) histogram.fill(0);
+      for (let i = 0; i < Z.n; i++) {
+        const dx = Z.x[i] - cx;
+        const dz = Z.z[i] - cz;
+        const d2 = dx * dx + dz * dz;
+        distances[i] = -1;
+        if (d2 > behindFrom && dx * fx + dz * fz < -Math.sqrt(d2) * N.behindFactor - N.behindMargin) continue;
+        if (d2 > farSquared) continue;
+        if (frame.hidden?.(i)) continue;
+        const seen = Math.sqrt(d2);
+        distances[i] = seen;
+        if (budget && seen < lodEdges[lastLevel - 1]) histogram[Math.floor(seen / BUDGET_BIN)]++;
+      }
+      if (budget) fitEdges(frame.detailScale ?? 1);
+      if (budget) {
+        if (order.length < Z.n) order = new Uint32Array(distances.length);
+        nearestFirst(Z.n);
+      }
+      for (let k = 0; k < Z.n; k++) {
+        const i = budget ? order[k] : k;
+        const dd = distances[i];
+        if (dd < 0) continue;
+        let l = Z.lod[i];
+        while (l > 0 && dd < edges[l - 1] - bands[l - 1]) l--;
+        while (l < lastLevel && dd > edges[l] + bands[l]) l++;
+        Z.lod[i] = l;
+        const sp = Z.renderSpeed[i];
+        const gait = Math.min(N.gaitMax, walkGait(sp, Z.height[i]));
+        const st = Z.state[i];
+        if (st === STATE.CHASE && target?.alive) {
+          const px = Z.x[i] - target.x;
+          const pz = Z.z[i] - target.z;
+          const p2 = px * px + pz * pz;
+          Z.attackPose[i] = p2 < (Z.attackPose[i] ? N.attackLeave : N.attackEnter) ? 1 : 0;
+        } else Z.attackPose[i] = 0;
+        const p = st === STATE.DORMANT ? pose.dormant : st === STATE.AIRBORNE ? pose.airborne : st === STATE.EATING ? pose.eating : st === STATE.PILE_STEP ? pose.pileStep : st === STATE.SWING ? pose.swing : Z.crawl[i] ? pose.crawl : st === STATE.GRAB || Z.attackPose[i] ? pose.grab : st === STATE.CALLING ? pose.calling : pose.walk;
+        const staggering = variety !== null && p === pose.walk && isStaggering(Z, i);
+        const bb = st === STATE.SWELLING ? Z.build[i] * (1 + (N.swellPivot - Z.stateTimer[i]) * N.swell) : Z.build[i];
+        const eyeOn = !(Z.missing[i] & MISSING.SKULL);
+        const V = variants[Z.variant[i]];
+        const level = l === IMPOSTOR_LEVEL && p !== pose.walk ? IMPOSTOR_LEVEL - 1 : l;
+        sink(Z.variant[i], level, {
+          a: [Z.x[i], Z.z[i], Z.renderYaw[i], Z.phase[i]],
+          b: [Z.height[i] / V.s, bb / V.bulk, gait, staggering ? STAGGER_POSE : p],
+          c: [Z.missing[i], N.ageBase + Z.age[i] * N.agePer, N.armBase + N.armPer * Z.arms[i], Z.skin[i]],
+          color: Z.color[i],
+          shade: 1,
+          eye: eyeOn && st !== STATE.DORMANT ? options.eyes[Z.type[i]] ?? null : null,
+          y: Z.y[i],
+          ...variety ? lookFields(Z, i, variety, segmentClips, staggering) : {}
+        });
+        written++;
+      }
+      return written;
+    },
+    corpses(entries, variants, frame, life, sink, plain) {
+      const cx = frame.camera.x;
+      const cz = frame.camera.z;
+      const [nearEdge, middleEdge] = fitCorpseEdges(entries, cx, cz, frame.detailScale ?? 1);
+      for (const { age: t, data: C } of entries) {
+        const dark = Math.min(1, t / life);
+        const shade = 1 - dark * N.corpseDarken;
+        const fade = t > life - N.corpseFade ? (life - t) / N.corpseFade : 1;
+        const c = [C.missing, N.corpseAgeBase + dark * N.corpseAgeDark, 1, C.skin];
+        if (C.variant >= 0) {
+          const V = variants[C.variant];
+          const dx = C.x - cx;
+          const dz = C.z - cz;
+          const distance = Math.hypot(dx, dz);
+          const l = distance < nearEdge ? 0 : distance < middleEdge ? 1 : 2;
+          sink(C.variant, l, { a: [C.x, C.z, C.yaw, C.seed], b: [C.height / V.s * fade, C.build / V.bulk, Math.min(1, t * N.corpseRise), pose.corpse], c, color: C.color, shade, eye: null, y: 0 });
+          continue;
+        }
+        plain({ a: [C.x, C.z, C.yaw, C.seed], b: [C.height * fade, C.build, Math.min(1, t * N.corpseRise), pose.corpse], c, color: C.color, shade, eye: null, y: 0 });
+      }
+    },
+    civilians(list, colorOf, sink) {
+      for (const n of list) {
+        if (n.state === "undead" || n.state === "gone" || n.state === "dead") continue;
+        const sp = Math.hypot(n.vx, n.vz);
+        const child = !!n.spec.child;
+        sink(n, {
+          a: [n.x, n.z, n.yaw, n.phase],
+          b: [child ? N.childHeight : 1, child ? N.childBuild : 1, Math.min(N.gaitMax, walkGait(sp, child ? N.childHeight : 1)), pose.civilian],
+          c: [0, n.biteTimer > 0 ? N.bittenLook : 0, 0, n.k * N.civilianSkinStep],
+          color: colorOf(n),
+          shade: 1,
+          eye: null,
+          y: 0
+        });
+      }
+    }
+  };
+}
+
+// src/renderer.ts
+import { variantDecay, variantSeed } from "@adatechnology/game-characters";
+import { markKitOrigin } from "@adatechnology/game-contracts";
+import { KIT_ACCESSORIES, createSegmentClipUniforms, LOD_BAKE, LOD_SEGMENTS, accessoryPlacement, bakeBody, bakeImpostorAtlas, buildInstancedBody, buildKitAccessory, createBlobShadowBatch, createBodyBatch, createImpostorBatch, createVariantBatches } from "@adatechnology/game-characters-three";
+
+// src/gpu-cost.ts
+var NANOSECONDS_PER_MILLISECOND = 1e6;
+var MAX_PENDING = 512;
+function createGpuCostProbe() {
+  let context = null;
+  let timer = null;
+  let isReady = false;
+  let active = null;
+  let drawFrame = 0;
+  let lastRenderFrame = -1;
+  const pending = [];
+  const free = [];
+  let sumFrame = -1;
+  let sum = 0;
+  let last;
+  const begin = (renderer) => {
+    if (!isReady) {
+      isReady = true;
+      const gl = renderer.getContext();
+      const extension = gl.getExtension("EXT_disjoint_timer_query_webgl2");
+      if (extension) {
+        context = gl;
+        timer = extension;
+      }
+    }
+    if (!context || !timer || active || pending.length >= MAX_PENDING) return;
+    const frame = renderer.info.render.frame;
+    if (frame !== lastRenderFrame) {
+      lastRenderFrame = frame;
+      drawFrame++;
+    }
+    active = free.pop() ?? context.createQuery();
+    context.beginQuery(timer.TIME_ELAPSED_EXT, active);
+  };
+  const end = () => {
+    if (!context || !timer || !active) return;
+    context.endQuery(timer.TIME_ELAPSED_EXT);
+    pending.push({ query: active, frame: drawFrame });
+    active = null;
+  };
+  const poll = () => {
+    if (!context || !timer) return void 0;
+    const disjoint = context.getParameter(timer.GPU_DISJOINT_EXT);
+    while (pending.length > 0) {
+      const { query, frame } = pending[0];
+      if (!context.getQueryParameter(query, context.QUERY_RESULT_AVAILABLE)) break;
+      pending.shift();
+      free.push(query);
+      if (disjoint) continue;
+      if (frame !== sumFrame) {
+        if (sumFrame >= 0) last = sum;
+        sumFrame = frame;
+        sum = 0;
+      }
+      sum += context.getQueryParameter(query, context.QUERY_RESULT) / NANOSECONDS_PER_MILLISECOND;
+    }
+    return last;
+  };
+  return {
+    attach(mesh) {
+      mesh.onBeforeRender = (renderer) => begin(renderer);
+      mesh.onAfterRender = () => end();
+    },
+    poll
+  };
+}
+
+// src/renderer.ts
+var ACCESSORY_CAPACITY = [480, 1400];
+var BLOB_CAPACITY = 4e3;
+var IMPOSTOR_FROM = 90;
+var IMPOSTOR_CAPACITY = 4e3;
+var NEAR_SHADOWS = [true, false, false];
+var NEAR_PREPASS = [true, false, false];
+var BUDGET_LEVELS = [160, 320, 600];
+var ADAPT = { gpuHighMs: 3.5, gpuLowMs: 2.2, highMs: 24, lowMs: 19, minScale: 0.1, shrinkPerSecond: 1.2, growPerSecond: 0.5, smoothing: 0.1 };
+var now = () => typeof performance === "undefined" ? Date.now() : performance.now();
+function createCrowdRenderer(three, options) {
+  const { crowd } = options;
+  const group = markKitOrigin(new three.Group(), { owner: "game-crowd-three", kind: "person" });
+  group.name = "crowd";
+  const time = { value: 0 };
+  const eyes = crowd.pack.types.map((type) => type.eye ?? null);
+  const variety = options.variety;
+  const accessoryKinds = variety ? variety.accessories === false ? [] : variety.accessories ?? KIT_ACCESSORIES : [];
+  const accessoryCapacity = variety?.accessoryCapacity ?? ACCESSORY_CAPACITY;
+  const nearShadows = variety ? variety.nearShadows ?? true : false;
+  const impostorOptions = variety && variety.impostor !== false ? variety.impostor ?? {} : null;
+  const budgetOptions = variety && variety.budget !== false ? variety.budget ?? {} : null;
+  const adaptOptions = budgetOptions && budgetOptions.adapt !== false ? { ...ADAPT, ...budgetOptions.adapt } : null;
+  let detailScale = 1;
+  let frameMs = 0;
+  let gpuMs = 0;
+  const probe = adaptOptions ? createGpuCostProbe() : null;
+  const tracked = /* @__PURE__ */ new WeakSet();
+  const track = (mesh) => {
+    if (!probe || tracked.has(mesh)) return;
+    tracked.add(mesh);
+    probe.attach(mesh);
+  };
+  const instances = createCrowdInstances({
+    eyes,
+    ...options.numbers ? { numbers: options.numbers } : {},
+    ...options.poses ? { poses: options.poses } : {},
+    ...variety ? { variety: { ...variety.numbers ? { numbers: variety.numbers } : {}, ...impostorOptions ? { impostorFrom: impostorOptions.from ?? IMPOSTOR_FROM } : {}, ...variety.segmentClips ? { segmentClips: true } : {}, ...budgetOptions ? { budget: budgetOptions.levels ?? BUDGET_LEVELS } : {} } } : {}
+  });
+  const N = instances.numbers;
+  const variants = [];
+  const batches = [];
+  let plain = null;
+  const people = /* @__PURE__ */ new Map();
+  const accessoryBatches = /* @__PURE__ */ new Map();
+  const accessoryGeometry = /* @__PURE__ */ new Map();
+  const placements = /* @__PURE__ */ new Map();
+  let blobs = null;
+  let atlas = null;
+  let impostors = null;
+  let impostorCount = 0;
+  const clipUniforms = variety?.segmentClips ? createSegmentClipUniforms(three) : null;
+  let bakeMs = 0;
+  const lodCounts = [0, 0, 0];
+  const shirt = new three.Color();
+  const eyeColors = /* @__PURE__ */ new Map();
+  const eyeOf = (hex) => {
+    let color = eyeColors.get(hex);
+    if (!color) eyeColors.set(hex, color = new three.Color(hex));
+    return color;
+  };
+  const push = (batch, instance) => {
+    if (!batch) return;
+    shirt.setHex(instance.color).multiplyScalar(instance.shade);
+    batch.push({ a: instance.a, b: instance.b, c: instance.c, color: shirt, ...instance.eye !== null ? { eye: eyeOf(instance.eye) } : {}, y: instance.y, ...instance.d ? { d: instance.d } : {} });
+  };
+  const pushAccessories = (variant, level, instance) => {
+    const bits = instance.accessories ?? 0;
+    if (!bits || level > 1) return;
+    shirt.setHex(instance.color).multiplyScalar(instance.shade);
+    for (const accessory of accessoryKinds) {
+      if (!(bits & accessory.bit)) continue;
+      accessoryBatch(accessory, level).push({ a: instance.a, b: instance.b, c: instance.c, color: shirt, y: instance.y, ...instance.d ? { d: instance.d } : {}, acc: placementOf(variant, level, accessory) });
+    }
+  };
+  const accessoryBatch = (accessory, level) => {
+    const key = `${accessory.id}|${level}`;
+    const made = accessoryBatches.get(key);
+    if (made) return made;
+    let geometry = accessoryGeometry.get(accessory.id);
+    if (!geometry) accessoryGeometry.set(accessory.id, geometry = buildKitAccessory(three, accessory));
+    const batch = createBodyBatch(three, geometry, { max: accessoryCapacity[level] ?? ACCESSORY_CAPACITY[1], castShadow: level === 0, time, accessory: true, ...clipUniforms ? { segmentClips: clipUniforms } : {} });
+    accessoryBatches.set(key, batch);
+    group.add(batch.mesh);
+    return batch;
+  };
+  const placementOf = (variant, level, accessory) => {
+    const key = `${variant}|${level}|${accessory.attach}`;
+    let placed = placements.get(key);
+    if (!placed) placements.set(key, placed = accessoryPlacement(variants[variant].geometries[level], accessory.attach));
+    return placed;
+  };
+  const ensureImpostors = () => {
+    if (impostors) return impostors;
+    bake();
+    const bodies = crowd.pack.types.map((_, c) => {
+      const variant = variants[crowd.variantsOf[c][0]];
+      return { geometry: variant.geometries[2] };
+    });
+    atlas = bakeImpostorAtlas(three, bodies);
+    impostors = createImpostorBatch(three, atlas, { max: impostorOptions?.capacity ?? IMPOSTOR_CAPACITY, ...impostorOptions?.light ? { light: impostorOptions.light } : {} });
+    group.add(impostors.mesh);
+    return impostors;
+  };
+  const pushImpostor = (instance) => {
+    shirt.setHex(instance.color).multiplyScalar(instance.shade);
+    ensureImpostors().push({ a: instance.a, scale: [instance.b[0], instance.b[1]], silhouette: instance.type ?? 0, y: instance.y, c: instance.c, color: shirt, ...instance.d ? { d: instance.d } : {} });
+    impostorCount++;
+  };
+  const ensureBlobs = () => {
+    if (!blobs) {
+      blobs = createBlobShadowBatch(three, { max: BLOB_CAPACITY });
+      group.add(blobs.mesh);
+    }
+    return blobs;
+  };
+  const typeOfVariant = [];
+  crowd.variantsOf.forEach((list, c) => list.forEach((g) => typeOfVariant[g] = c));
+  const baked = /* @__PURE__ */ new Set();
+  const ensurePlain = () => {
+    if (!plain) {
+      plain = createBodyBatch(three, options.plainBody ?? buildInstancedBody(three, { segments: LOD_SEGMENTS[1] }), { max: crowd.numbers.corpsesMax, castShadow: false, time });
+      group.add(plain.mesh);
+    }
+    return plain;
+  };
+  const bakeType = (c) => {
+    if (baked.has(c)) return;
+    baked.add(c);
+    const type = crowd.pack.types[c];
+    const name = options.typeName?.(type, c) ?? type.id;
+    const started = now();
+    crowd.variantsOf[c].forEach((g, v) => {
+      const decay = variantDecay(v);
+      const seed = variantSeed(c, v);
+      const bodies = LOD_BAKE.map((lod) => bakeBody(three, options.builders, { type: name, decay, seed }, lod));
+      const variant = { typeId: type.id, variant: v, seed, decay, s: bodies[0].s, bulk: bodies[0].bulk, verts: bodies.map((body) => body.verts), geometries: bodies.map((body) => body.geo) };
+      variants[g] = variant;
+      batches[g] = createVariantBatches(three, variant, time, variety ? { identity: true, ...clipUniforms ? { segmentClips: clipUniforms } : {}, ...nearShadows ? { castsShadow: NEAR_SHADOWS } : {}, ...variety.nearDepthPrepass ?? true ? { depthPrepass: NEAR_PREPASS } : {} } : {});
+      for (const batch of batches[g]) group.add(batch.mesh, ...batch.prepass ? [batch.prepass] : []);
+    });
+    bakeMs += now() - started;
+  };
+  const bake = () => crowd.pack.types.forEach((_, c) => bakeType(c));
+  const bakeSeen = () => {
+    const Z = crowd.store;
+    for (let i = 0; i < Z.n; i++) if (!baked.has(Z.type[i])) bakeType(Z.type[i]);
+    for (const { data } of crowd.corpses.entries) if (data.variant >= 0 && !baked.has(typeOfVariant[data.variant])) bakeType(typeOfVariant[data.variant]);
+  };
+  const personBatch = (civilian) => {
+    const made = people.get(civilian.id);
+    if (made) return made;
+    const spec = options.civilians?.body(civilian);
+    if (!spec) return void 0;
+    const batch = createBodyBatch(three, bakeBody(three, options.builders, spec, N.civilianBake).geo, { max: N.civilianBatch, time });
+    people.set(civilian.id, batch);
+    group.add(batch.mesh);
+    return batch;
+  };
+  const all = () => [...batches.flatMap((set) => set ?? []), ...plain ? [plain] : [], ...people.values(), ...accessoryBatches.values()];
+  return {
+    group,
+    instances,
+    bake,
+    prepare() {
+      bake();
+      ensurePlain();
+      if (!variety) return;
+      if (variety.blobShadows ?? true) ensureBlobs();
+      if (impostorOptions) ensureImpostors();
+      for (const accessory of accessoryKinds) for (const level of [0, 1]) accessoryBatch(accessory, level);
+    },
+    update(dt, frame) {
+      if (adaptOptions && probe && dt > 0) {
+        const measured = probe.poll();
+        if (measured !== void 0) gpuMs += (measured - gpuMs) * (gpuMs === 0 ? 1 : adaptOptions.smoothing);
+        frameMs += (dt * 1e3 - frameMs) * (frameMs === 0 ? 1 : adaptOptions.smoothing);
+        const [high, low, load] = measured === void 0 ? [adaptOptions.highMs, adaptOptions.lowMs, frameMs] : [adaptOptions.gpuHighMs, adaptOptions.gpuLowMs, gpuMs];
+        if (load > high) detailScale = Math.max(adaptOptions.minScale, detailScale * (1 - adaptOptions.shrinkPerSecond * dt));
+        else if (load < low) detailScale = Math.min(1, detailScale * (1 + adaptOptions.growPerSecond * dt));
+      }
+      if (budgetOptions) frame = { ...frame, detailScale };
+      bakeSeen();
+      time.value += dt;
+      for (const batch of all()) batch.begin();
+      blobs?.begin();
+      impostors?.begin();
+      impostorCount = 0;
+      const drawBlobs = variety ? variety.blobShadows ?? true : false;
+      instances.agents(crowd.store, variants, frame, (v, l, instance) => {
+        if (l === IMPOSTOR_LEVEL) pushImpostor(instance);
+        else push(batches[v]?.[l], instance);
+        if (!variety) return;
+        pushAccessories(v, l, instance);
+        if (drawBlobs && l > 0) ensureBlobs().push(instance.a[0], instance.y, instance.a[1], instance.b[0] * (variants[v]?.s ?? 1));
+      });
+      if (options.drawCorpses?.() !== false) instances.corpses(crowd.corpses.entries, variants, frame, crowd.numbers.corpseSeconds, (v, l, instance) => push(batches[v]?.[l], instance), (instance) => push(ensurePlain(), instance));
+      for (let l = 0; l < 3; l++) lodCounts[l] = batches.reduce((sum, set) => sum + (set?.[l]?.count ?? 0), 0);
+      const list = options.civilians?.list();
+      if (list) instances.civilians(list, options.civilians?.color ?? ((n) => n.spec.color ?? 8421504), (n, instance) => push(personBatch(n), instance));
+      for (const batch of all()) batch.end();
+      blobs?.end();
+      impostors?.end();
+      if (probe) {
+        for (const batch of all()) {
+          track(batch.mesh);
+          if (batch.prepass) track(batch.prepass);
+        }
+        if (blobs) track(blobs.mesh);
+        if (impostors) track(impostors.mesh);
+      }
+    },
+    get detailScale() {
+      return detailScale;
+    },
+    get gpuMs() {
+      return gpuMs;
+    },
+    get impostorCount() {
+      return impostorCount;
+    },
+    get lodCounts() {
+      return lodCounts;
+    },
+    get drawCalls() {
+      return all().filter((batch) => batch.count > 0).length + (blobs && blobs.count > 0 ? 1 : 0) + (impostors && impostors.count > 0 ? 1 : 0);
+    },
+    get bakeMs() {
+      return bakeMs;
+    },
+    get variants() {
+      return variants;
+    },
+    dispose() {
+      for (const batch of all()) {
+        batch.mesh.geometry.dispose();
+        group.remove(batch.mesh);
+        if (batch.prepass) group.remove(batch.prepass);
+      }
+      variants.length = 0;
+      batches.length = 0;
+      baked.clear();
+      plain = null;
+      people.clear();
+      accessoryBatches.clear();
+      accessoryGeometry.clear();
+      placements.clear();
+      blobs?.mesh.geometry.dispose();
+      if (blobs) group.remove(blobs.mesh);
+      blobs = null;
+      impostors?.mesh.geometry.dispose();
+      if (impostors) group.remove(impostors.mesh);
+      atlas?.dispose();
+      clipUniforms?.uClips.value.dispose();
+      impostors = null;
+      atlas = null;
+    }
+  };
+}
+
+// src/bench/locale.ts
+var EN = {
+  group: "Crowd",
+  name: "Crowd area",
+  mix: "Mixed (by weight)",
+  controls: {
+    scene: "Scene",
+    physics: "Crowd physics",
+    count: "Agents",
+    type: "Type of the new ones",
+    night: "Night",
+    seed: "Seed",
+    spawn: "Add 100",
+    noise: "Noise here (80 m)",
+    hit: "Shoot the nearest in the head",
+    kill_all: "Kill all",
+    join: "Civilians join you",
+    flee: "Civilians run away",
+    herd: "Bring the animals",
+    materialize: "Bring 50 from the region",
+    push: "Push (break a grab)",
+    reset: "Start again"
+  },
+  hints: {
+    scene: "Where the crowd is born: the open ring, a horde pressed against a wall and a door, or a horde coming down a street at a row of gas cylinders and a car. Applied before the physics and the count.",
+    physics: "Contact, pressure, falls, mounds, thrown bodies and blasts (the crowd is rebuilt with them).",
+    count: "The crowd grows or shrinks to this many, born 10 to 90 m from the area centre. Only the near ones think every frame (relevance bands).",
+    type: "The type of the agents added from now on; mixed draws them by the weights of the pack.",
+    night: "At night sight drops by 40%.",
+    noise: "A noise heard 80 m around you: the ones that hear it come.",
+    hit: "A headshot to the nearest agent: a body on the ground, blood through the room effects.",
+    join: "The civilians follow you; bitten, they turn after the bite time.",
+    flee: "The civilians run off along a path out of the area and are gone.",
+    herd: "A companion dog, hens, a lapwing, cows, a horse, a pig, a capybara, a carcass and the vultures over it.",
+    materialize: "The region model turns 50 of its numbers into agents near you; the far ones go back.",
+    push: "What holds you lets go after six pushes."
+  },
+  layers: { corpses: "Bodies on the ground", civilians: "Civilians", animals: "Animals" },
+  metrics: {
+    agents: "Agents",
+    drawn: "Drawn",
+    lod_near: "Near level",
+    lod_middle: "Middle level",
+    lod_far: "Far level",
+    draw_calls: "Draw calls",
+    bake_ms: "Bake",
+    detail_scale: "Detail budget",
+    crowd_gpu_ms: "Crowd GPU time",
+    active: "Thinking every frame",
+    kills: "Kills",
+    corpses: "Bodies",
+    civilians: "Civilians alive",
+    health: "Your health",
+    grabbed: "Grabbed",
+    message: "Last message",
+    falls_pressure: "Falls by pressure",
+    falls_chain: "Chain falls beyond a blast",
+    falls_landing: "Falls by a landing body",
+    climbers: "On the mound, peak",
+    mound_max: "Highest mound, peak",
+    thrown_peak: "Thrown bodies, peak",
+    max_overlap: "Largest overlap, peak",
+    chain_links: "Chain links",
+    crowd_ms_p99: "Crowd step, p99"
+  },
+  sceneNames: { open: "Open ring", dense_wall: "Dense wall", chain_line: "Chain line" },
+  scenarios: {
+    relevance: "Relevance: 500 agents, only the near ones every frame",
+    lod: "Level of detail with 1.5 m of hysteresis",
+    attack_pose: "Attack pose in at 1.6 m, out at 2.2 m",
+    corpse_darkens: "A body darkens and shrinks at the end of its life",
+    civilians_flee: "Civilians follow, then run away and are gone",
+    herd_calls: "The hen flees and clucks, the lapwing raises the alarm",
+    vultures: "The vultures circle the bodies",
+    infection: "Region numbers become agents and go back",
+    determinism: "The same seed, the same crowd"
+  },
+  messages: {
+    called: "A screamer called the crowd",
+    burst_hit: "Hit by a bloater burst",
+    swing_knock: "A brute knocked you down",
+    pounce_knock: "A leaper knocked you down",
+    migration: "A crowd is on the move",
+    door_broken: "A door gave way",
+    alarm: "A bird raises the alarm",
+    bark: "The dog is barking",
+    growl: "The dog is growling",
+    bitten: "A civilian was bitten",
+    turned: "A civilian turned",
+    died: "A civilian died"
+  },
+  yes: "yes",
+  no: "no"
+};
+var PT_BR = {
+  group: "Multid\xE3o",
+  name: "\xC1rea da multid\xE3o",
+  mix: "Misturado (pelo peso)",
+  controls: {
+    scene: "Cena",
+    physics: "F\xEDsica da multid\xE3o",
+    count: "Agentes",
+    type: "Tipo dos novos",
+    night: "Noite",
+    seed: "Semente",
+    spawn: "Mais 100",
+    noise: "Barulho aqui (80 m)",
+    hit: "Tiro na cabe\xE7a do mais perto",
+    kill_all: "Matar todos",
+    join: "Civis v\xEAm com voc\xEA",
+    flee: "Civis fogem",
+    herd: "Trazer os bichos",
+    materialize: "Trazer 50 da regi\xE3o",
+    push: "Empurrar (soltar-se)",
+    reset: "Recome\xE7ar"
+  },
+  hints: {
+    scene: "Onde a multid\xE3o nasce: o anel aberto, uma horda espremida contra um muro e uma porta, ou uma horda descendo uma rua em dire\xE7\xE3o a uma fileira de botij\xF5es e um carro. Vale antes da f\xEDsica e da contagem.",
+    physics: "Contato, press\xE3o, quedas, montes, corpos arremessados e explos\xF5es (a multid\xE3o \xE9 refeita com elas).",
+    count: "A multid\xE3o cresce ou diminui at\xE9 esse n\xFAmero, nascendo de 10 a 90 m do centro da \xE1rea. S\xF3 os de perto pensam todo quadro (faixas de relev\xE2ncia).",
+    type: "O tipo dos agentes acrescentados daqui em diante; misturado sorteia pelos pesos do pacote.",
+    night: "\xC0 noite a vis\xE3o cai 40%.",
+    noise: "Um barulho ouvido a 80 m de voc\xEA: quem ouve vem.",
+    hit: "Um tiro na cabe\xE7a do agente mais perto: um corpo no ch\xE3o, sangue pelos efeitos da sala.",
+    join: "Os civis seguem voc\xEA; mordidos, viram depois do tempo da mordida.",
+    flee: "Os civis fogem por um caminho para fora da \xE1rea e somem.",
+    herd: "Um c\xE3o companheiro, galinhas, um quero-quero, vacas, um cavalo, um porco, uma capivara, uma carca\xE7a e os urubus sobre ela.",
+    materialize: "O modelo da regi\xE3o transforma 50 dos seus n\xFAmeros em agentes perto de voc\xEA; os de longe voltam.",
+    push: "Quem segura voc\xEA solta depois de seis empurr\xF5es."
+  },
+  layers: { corpses: "Corpos no ch\xE3o", civilians: "Civis", animals: "Bichos" },
+  metrics: {
+    agents: "Agentes",
+    drawn: "Desenhados",
+    lod_near: "N\xEDvel perto",
+    lod_middle: "N\xEDvel meio",
+    lod_far: "N\xEDvel longe",
+    draw_calls: "Chamadas de desenho",
+    bake_ms: "Cozimento",
+    detail_scale: "Or\xE7amento de detalhe",
+    crowd_gpu_ms: "Tempo de GPU da horda",
+    active: "Pensando todo quadro",
+    kills: "Mortes",
+    corpses: "Corpos",
+    civilians: "Civis vivos",
+    health: "Sua vida",
+    grabbed: "Agarrado",
+    message: "\xDAltima mensagem",
+    falls_pressure: "Quedas por press\xE3o",
+    falls_chain: "Quedas em cadeia al\xE9m da explos\xE3o",
+    falls_landing: "Quedas por corpo que pousa",
+    climbers: "No monte, pico",
+    mound_max: "Maior monte, pico",
+    thrown_peak: "Arremessados, pico",
+    max_overlap: "Maior sobreposi\xE7\xE3o, pico",
+    chain_links: "Elos da cadeia",
+    crowd_ms_p99: "Passo da multid\xE3o, p99"
+  },
+  sceneNames: { open: "Anel aberto", dense_wall: "Muro denso", chain_line: "Rua em cadeia" },
+  scenarios: {
+    relevance: "Relev\xE2ncia: 500 agentes, s\xF3 os de perto todo quadro",
+    lod: "N\xEDvel de detalhe com 1,5 m de histerese",
+    attack_pose: "Pose de ataque entra a 1,6 m e sai a 2,2 m",
+    corpse_darkens: "O corpo escurece e encolhe no fim da vida",
+    civilians_flee: "Civis seguem, depois fogem e somem",
+    herd_calls: "A galinha foge e cacareja, o quero-quero d\xE1 o alarme",
+    vultures: "Os urubus circulam os corpos",
+    infection: "N\xFAmeros da regi\xE3o viram agentes e voltam",
+    determinism: "A mesma semente, a mesma multid\xE3o"
+  },
+  messages: {
+    called: "Um gritador chamou a multid\xE3o",
+    burst_hit: "Atingido pelo estouro de um inchado",
+    swing_knock: "Um brutamonte derrubou voc\xEA",
+    pounce_knock: "Um saltador derrubou voc\xEA",
+    migration: "Uma multid\xE3o est\xE1 migrando",
+    door_broken: "Uma porta cedeu",
+    alarm: "Um p\xE1ssaro d\xE1 o alarme",
+    bark: "O c\xE3o est\xE1 latindo",
+    growl: "O c\xE3o est\xE1 rosnando",
+    bitten: "Um civil foi mordido",
+    turned: "Um civil virou",
+    died: "Um civil morreu"
+  },
+  yes: "sim",
+  no: "n\xE3o"
+};
+var TEXT = { en: EN, "pt-BR": PT_BR };
+var crowdBenchTextOf = (locale) => TEXT[locale] ?? PT_BR;
+
+// src/bench/scenes.ts
+import { STATE as STATE2, CELL } from "@adatechnology/game-crowd";
+import { discardObject3D } from "@adatechnology/game-shapes-three";
+var WALL_LENGTH = 30;
+var WALL_HEIGHT = 3;
+var WALL_THICKNESS = 0.5;
+var DOOR_WIDTH = 1.2;
+var BODY_COLUMNS = 50;
+var COLUMN_GAP = 0.6;
+var ROW_GAP = 0.55;
+var STREET_HALF_WIDTH = 6;
+var STREET_COLUMNS = 18;
+var STREET_LENGTH = 90;
+var CYLINDERS = 6;
+var CYLINDER_GAP = 1.5;
+var bear = (crowd, x, z, type) => {
+  const i = crowd.spawn(x, z, type);
+  if (i >= 0) crowd.store.state[i] = STATE2.CHASE;
+};
+var removers = (list) => () => {
+  for (const remove of list) remove();
+};
+var DENSE_WALL = {
+  id: "dense_wall",
+  layout(crowd, { cx, cz }) {
+    const half = WALL_LENGTH / 2;
+    crowd.grid.fillRect(cx - half, cz - WALL_THICKNESS / 2, cx - DOOR_WIDTH / 2, cz + WALL_THICKNESS / 2, CELL.SOLID, WALL_HEIGHT);
+    crowd.grid.fillRect(cx + DOOR_WIDTH / 2, cz - WALL_THICKNESS / 2, cx + half, cz + WALL_THICKNESS / 2, CELL.SOLID, WALL_HEIGHT);
+    crowd.doors.add(cx, cz, "x", DOOR_WIDTH);
+  },
+  spawn(crowd, { first, count, type }, { cx, cz }) {
+    for (let k = first; k < first + count; k++) {
+      const row = Math.floor(k / BODY_COLUMNS);
+      bear(crowd, cx + (k % BODY_COLUMNS - BODY_COLUMNS / 2 + row % 2 * 0.5) * COLUMN_GAP, cz - 1.5 - row * ROW_GAP, type);
+    }
+  },
+  context: ({ cx, cz }) => ({ bandCentre: [cx, cz - 8] }),
+  view: ({ cx, cz }) => ({ eye: [cx, 1.7, cz + 9], target: [cx, 1.2, cz - 10] }),
+  props(host, { cx, cz }, props) {
+    const three = host.THREE;
+    const side = (WALL_LENGTH - DOOR_WIDTH) / 2;
+    const made = [];
+    for (const sign of [-1, 1]) {
+      const wall = props.wall?.(three, { length: side, height: WALL_HEIGHT });
+      if (!wall) continue;
+      wall.position.set(cx + sign * (DOOR_WIDTH / 2 + side / 2), 0, cz);
+      host.scene.add(wall);
+      made.push(wall);
+    }
+    return () => {
+      discardObject3D(made);
+    };
+  }
+};
+var CHAIN_LINE = {
+  id: "chain_line",
+  layout(crowd, { cx, cz }) {
+    for (const sign of [-1, 1]) crowd.grid.fillRect(cx + sign * STREET_HALF_WIDTH, cz - STREET_LENGTH, cx + sign * (STREET_HALF_WIDTH + WALL_THICKNESS), cz + 20, CELL.SOLID, WALL_HEIGHT);
+  },
+  spawn(crowd, { first, count, type }, { cx, cz }) {
+    for (let k = first; k < first + count; k++) {
+      const row = Math.floor(k / STREET_COLUMNS);
+      bear(crowd, cx + (k % STREET_COLUMNS - STREET_COLUMNS / 2 + row % 2 * 0.5) * COLUMN_GAP, cz - 10 - row * ROW_GAP, type);
+    }
+  },
+  context: ({ cx, cz }) => ({ bandCentre: [cx, cz - 14] }),
+  view: ({ cx, cz }) => ({ eye: [cx, 1.7, cz + 14], target: [cx, 1.2, cz - 10] }),
+  props(host, { cx, cz }, props) {
+    const items = props.items;
+    const placed = [];
+    if (!host.addObject || !items) return removers(placed);
+    if (items.gasCylinder) {
+      for (let k = 0; k < CYLINDERS; k++) {
+        const object = host.addObject(items.gasCylinder, { position: [cx + (k - (CYLINDERS - 1) / 2) * CYLINDER_GAP, 0, cz - 4] });
+        if (object) placed.push(() => object.remove());
+      }
+    }
+    for (const id of [items.car, items.carTank]) {
+      const object = id ? host.addObject(id, { position: [cx, 0, cz + 2], rotationY: Math.PI / 2 }) : null;
+      if (object) placed.push(() => object.remove());
+    }
+    return removers(placed);
+  }
+};
+var BUILTIN_SCENES = { dense_wall: DENSE_WALL, chain_line: CHAIN_LINE };
+
+// src/bench/module.ts
+var CROWD_AREA_ID = "crowd_area";
+var CROWD_EFFECTS = {
+  blood: { effect: "blood_hit" },
+  limb: { effect: "dismember" },
+  cloud: { effect: "bloater_cloud" },
+  spark: { effect: "impact", param: "metal" },
+  dust: { effect: "impact", param: "concrete" }
+};
+var CAPACITY = 4e3;
+var FRAME = 1 / 30;
+var STEP_WINDOW = 600;
+var LETHAL_SHARE = 1 / 3;
+var HORDE_BUDGET_LEVELS = [160, 320, 600];
+var RING = [10, 90];
+var LOTS = { home: { x: -14, z: -14, w: 8, d: 10, house: true, front: 1 }, shop: { x: 8, z: -14, w: 10, d: 10, front: 1 } };
+var CIVILIANS = [
+  { id: "civilian_1", home: "home", color: 4090506 },
+  { id: "civilian_2", home: "home", color: 13672496, child: true },
+  { id: "civilian_3", home: "shop", color: 6969914 },
+  { id: "civilian_4", home: "shop", color: 9058906 }
+];
+var WAY_OUT = [
+  [0, 4],
+  [30, 4],
+  [60, 20]
+];
+var FARM = [
+  ["dog", 2, 3, { companion: true }],
+  ["cat", 12, -6],
+  ["chicken", -8, 4],
+  ["chicken", -8.5, 5],
+  ["chicken", -7.5, 4.6],
+  ["southern_lapwing", 8, 5],
+  ["cow", -20, -10],
+  ["cow", -24, -12],
+  ["horse", -26, -4],
+  ["pig", -14, -16],
+  ["capybara", 18, 14],
+  ["cow", -18, -24, { dead: true }],
+  ["vulture", 0, 0],
+  ["vulture", 0, 0],
+  ["vulture", 0, 0]
+];
+var messageText = (text, id) => text.messages[id] ?? id;
+function createCrowdTestModule(options) {
+  const locale = options.locale ?? "pt-BR";
+  const text = crowdBenchTextOf(locale);
+  const effects = options.effects ?? CROWD_EFFECTS;
+  const [cx, cz] = options.center ?? [0, -45];
+  const settings = { count: options.startCount ?? 0, type: "mix", night: false, seed: options.seed ?? 1, scene: "open", physics: options.crowdPhysics !== void 0 };
+  const scenes = { ...BUILTIN_SCENES, ...options.scenes };
+  const sceneOf = () => settings.scene === "open" ? void 0 : scenes[settings.scene];
+  const layers = { corpses: true, civilians: true, animals: true };
+  let host = null;
+  let three = null;
+  let renderer = null;
+  let herdView = null;
+  let lastMessage = "";
+  let isDirty = false;
+  let removeProps = null;
+  const stepTimes = [];
+  const peaks = { climbers: 0, moundMax: 0, maxOverlap: 0 };
+  let isBaked = false;
+  let frameStepMs = 0;
+  let pending = {};
+  let last = null;
+  const offs = [];
+  const typeOfSetting = (crowd) => settings.type === "mix" ? -1 : crowd.typeIndex(settings.type);
+  const build = (seed) => {
+    const player = createPlayer({ seed });
+    const physics = settings.physics ? options.crowdPhysics ?? CROWD_PHYSICS_DEFAULTS : void 0;
+    const crowd = createCrowd({ pack: options.pack, seed, capacity: CAPACITY, target: player, ...physics ? { physics } : {} });
+    sceneOf()?.layout(crowd, { cx, cz });
+    const civilians = createCivilians(crowd, { people: CIVILIANS.map((c) => ({ ...c })), buildings: LOTS });
+    const herd = createHerd(crowd, { view: () => ({ x: player.state.x, z: player.state.z }) });
+    const flock = createFlock({ count: 0, mode: "carrion" });
+    const model = options.infection?.create() ?? null;
+    const spot = createRng(seed + 7);
+    const binding = model ? bindInfection(crowd, model, { place: () => [cx + (spot() - 0.5) * 40, cz - 20 - spot() * 40], civilians, regionOf: () => options.infection.region }) : null;
+    const place = () => {
+      const a = spot() * Math.PI * 2;
+      const r = RING[0] + spot() * (RING[1] - RING[0]);
+      const type = typeOfSetting(crowd);
+      return crowd.spawn(cx + Math.cos(a) * r, cz + Math.sin(a) * r, type);
+    };
+    return { crowd, player, civilians, herd, flock, vultures: 0, binding, model, place, physics: physics !== void 0, sceneUnit: createRng(seed + 13) };
+  };
+  let world = build(settings.seed);
+  const wire = () => {
+    for (const off of offs.splice(0)) off();
+    const { crowd, herd, civilians } = world;
+    offs.push(crowd.on("sound", (e) => void host?.audio?.play({ sound: e.sound, volume: e.volume, position: e.position })));
+    offs.push(herd.on("sound", (e) => void host?.audio?.play({ sound: HERD_SOUND_IDS[e.sound] ?? e.sound, volume: e.volume, position: e.position })));
+    offs.push(crowd.on("effect", (e) => playEffect(e)));
+    offs.push(crowd.on("message", (e) => void (lastMessage = messageText(text, e.id))));
+    offs.push(herd.on("message", (e) => void (lastMessage = messageText(text, e.id))));
+    offs.push(civilians.on("bitten", () => void (lastMessage = text.messages.bitten)));
+    offs.push(civilians.on("turned", () => void (lastMessage = text.messages.turned)));
+    offs.push(civilians.on("died", () => void (lastMessage = text.messages.died)));
+    offs.push(crowd.on("kill", (e) => host?.log(`crowd kill: ${e.type}`, { agent: e.agent, headshot: e.headshot })));
+  };
+  const playEffect = (e) => {
+    const map = effects[e.effect];
+    if (!map || !host?.effects) return;
+    host.effects.play({ effect: map.effect, point: e.point, ...map.param !== void 0 ? { param: map.param } : {}, ...e.amount !== void 0 ? { scale: Math.max(0.3, Math.min(2, e.amount / 30)) } : {} });
+  };
+  const fit = () => {
+    settle();
+    const { crowd } = world;
+    const scene = sceneOf();
+    if (scene) {
+      const missing = Math.min(settings.count, CAPACITY) - crowd.store.n;
+      if (missing > 0) scene.spawn(crowd, { first: crowd.store.n, count: missing, type: typeOfSetting(crowd), unit: world.sceneUnit }, { cx, cz });
+    } else {
+      while (crowd.store.n < settings.count && world.place() >= 0) {
+      }
+    }
+    while (crowd.store.n > settings.count) crowd.remove(crowd.store.n - 1);
+  };
+  const bringHerd = () => {
+    const animals = options.animals;
+    if (!animals || world.herd.list.length) return;
+    for (const [id, dx, dz, extra] of FARM) {
+      const species = animals.species(id);
+      if (!species) continue;
+      world.herd.add({ ...HERD_ROLES[id], ...extra, species: id, x: cx + dx, z: cz + 30 + dz, walkHz: species.walkHz, runHz: species.runHz, size: animals.size(species) });
+    }
+    world.vultures = world.herd.list.filter((E) => E.spec.sky).length;
+    world.flock = createFlock({ count: world.vultures, mode: "carrion" });
+    herdView?.clear();
+    herdView = null;
+  };
+  const sceneView = () => {
+    const view2 = sceneOf()?.view({ cx, cz });
+    return view2 ? { eye: [...view2.eye], target: [...view2.target] } : void 0;
+  };
+  const settle = () => {
+    if (isDirty) reset();
+  };
+  const reset = () => {
+    isDirty = false;
+    stepTimes.length = 0;
+    peaks.climbers = peaks.moundMax = peaks.maxOverlap = 0;
+    removeProps?.();
+    removeProps = null;
+    world.binding?.unbind();
+    renderer?.dispose();
+    if (renderer) host?.scene?.remove(renderer.group);
+    renderer = null;
+    herdView?.clear();
+    if (herdView) host?.scene?.remove(herdView.group);
+    herdView = null;
+    world = build(settings.seed);
+    wire();
+    if (host) removeProps = sceneOf()?.props?.(host, { cx, cz }, options.props ?? {}) ?? null;
+    fit();
+    lastMessage = "";
+    const view2 = sceneView();
+    if (view2) host?.bench?.look?.(view2.eye, view2.target);
+  };
+  const view = () => {
+    const camera = host?.camera;
+    if (!camera?.position) return null;
+    const Vector3 = host?.THREE?.Vector3;
+    if (camera.getWorldDirection && Vector3) {
+      const look = camera.getWorldDirection(new Vector3());
+      return { x: camera.position.x, z: camera.position.z, yaw: Math.atan2(-look.x, -look.z) };
+    }
+    return { x: camera.position.x, z: camera.position.z, yaw: camera.rotation?.y ?? 0 };
+  };
+  const varietyFor = (detail) => {
+    const variety = options.variety;
+    if (!variety || detail === "auto" || variety.budget === false) return variety;
+    const levels = (variety.budget?.levels ?? HORDE_BUDGET_LEVELS).map((n) => Math.max(1, Math.round(n * detail)));
+    return { ...variety, budget: { ...variety.budget, levels, adapt: false } };
+  };
+  const ensureDrawing = () => {
+    if (!host || !three) return;
+    const scene = host.scene;
+    if (!renderer && options.builders) {
+      const bodies = options.civilianBodies ?? [];
+      const variety = varietyFor(host.graphics?.hordeDetail() ?? "auto");
+      renderer = createCrowdRenderer(three, {
+        crowd: world.crowd,
+        builders: options.builders(three),
+        ...options.typeName ? { typeName: options.typeName } : {},
+        drawCorpses: () => layers.corpses,
+        ...variety ? { variety } : {},
+        ...bodies.length ? { civilians: { list: () => layers.civilians ? world.civilians.list : [], body: (n) => bodies[n.k % bodies.length] } } : {}
+      });
+      scene.add(renderer.group);
+      isBaked = false;
+    }
+    if (!herdView && options.animals?.drawer && world.herd.list.length) {
+      herdView = createHerdView(three, { herd: world.herd, flock: world.flock, drawer: options.animals.drawer(three), species: options.animals.species });
+      scene.add(herdView.group);
+    }
+  };
+  const updateContext = () => ({
+    viewYaw: view()?.yaw ?? 0,
+    nightFactor: settings.night ? 1 : 0,
+    ...sceneOf()?.context?.({ cx, cz })
+  });
+  const stepCrowd = (dt) => {
+    const started = performance.now();
+    world.crowd.update(dt, updateContext());
+    frameStepMs += performance.now() - started;
+  };
+  const recordPeaks = () => {
+    const physics = world.crowd.stats.physics;
+    peaks.climbers = Math.max(peaks.climbers, physics.climbers);
+    peaks.moundMax = Math.max(peaks.moundMax, physics.moundMax);
+    peaks.maxOverlap = Math.max(peaks.maxOverlap, physics.maxOverlap);
+    if (frameStepMs <= 0) return;
+    stepTimes.push(frameStepMs);
+    if (stepTimes.length > STEP_WINDOW) stepTimes.shift();
+    frameStepMs = 0;
+  };
+  const stepMsP99 = () => {
+    if (stepTimes.length === 0) return 0;
+    const sorted = [...stepTimes].sort((a, b) => a - b);
+    return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.99))];
+  };
+  const prepareDrawing = () => {
+    if (!host) return;
+    settle();
+    ensureDrawing();
+    if (!renderer || isBaked) return;
+    renderer.prepare();
+    isBaked = true;
+  };
+  const frame = (dt) => {
+    settle();
+    const { crowd, player, civilians, herd, flock } = world;
+    const here = view();
+    const speed = here && last && dt > 0 ? Math.hypot(here.x - last.x, here.z - last.z) / dt : 0;
+    if (here) {
+      player.state.x = here.x;
+      player.state.z = here.z;
+    }
+    player.update(dt, { forward: speed > 0.2 ? 1 : 0, run: speed > 3.4, yaw: here?.yaw ?? 0, pressed: pending }, { crowd: crowd.asPlayerCrowd() });
+    pending = {};
+    if (here) {
+      player.state.x = here.x;
+      player.state.z = here.z;
+      last = { x: here.x, z: here.z };
+    }
+    crowd.updateTrail(dt);
+    civilians.update(dt);
+    if (herd.list.length) {
+      herd.update(dt);
+      const carcass = herd.list.find((E) => E.dead);
+      flock.update(herd.time, dt, carrionCenter(crowd.corpses.entries.map((e) => e.data), carcass ? [carcass.x, carcass.z] : null), [player.state.x, player.state.z]);
+    }
+    if (!world.physics) stepCrowd(dt);
+    recordPeaks();
+    crowd.updateCorpses(dt);
+    if (options.eager) prepareDrawing();
+    else ensureDrawing();
+    if (renderer && (crowd.store.n || crowd.corpses.count || civilians.list.length)) {
+      renderer.update(dt, { camera: { x: player.state.x, z: player.state.z }, viewYaw: here?.yaw ?? 0, target: { x: player.state.x, z: player.state.z, alive: player.state.alive } });
+      const detail = host?.graphics?.hordeDetail() ?? "auto";
+      host?.graphics?.report("hordeDetail", detail === "auto" ? renderer.detailScale : detail);
+    }
+    if (herdView) {
+      herdView.group.visible = layers.animals;
+      herdView.update(dt);
+    }
+  };
+  const hitNearest = () => {
+    const { crowd, player } = world;
+    const Z = crowd.store;
+    let best = -1;
+    let bd = Infinity;
+    for (let i = 0; i < Z.n; i++) {
+      const d = Math.hypot(Z.x[i] - player.state.x, Z.z[i] - player.state.z);
+      if (d < bd) [best, bd] = [i, d];
+    }
+    if (best >= 0) crowd.damage(best, { region: 0, amount: 200, distance: bd, cut: 0, caliber: null });
+  };
+  const onChange = (change) => {
+    if (change.kind === "layer") {
+      if (change.id in layers) layers[change.id] = change.on;
+      return;
+    }
+    if (change.kind === "action") {
+      const id2 = change.id;
+      if (id2 === "spawn") {
+        settings.count = Math.min(CAPACITY, world.crowd.store.n + 100);
+        host?.bench?.patch("count", { value: settings.count });
+        fit();
+      } else if (id2 === "noise") world.crowd.emitNoise(world.player.state.x, world.player.state.z, 80);
+      else if (id2 === "hit") hitNearest();
+      else if (id2 === "kill_all") for (let i = world.crowd.store.n - 1; i >= 0; i--) world.crowd.kill(i);
+      else if (id2 === "join") for (const n of world.civilians.list) world.civilians.join(n.id);
+      else if (id2 === "flee") for (const n of world.civilians.list) world.civilians.flee(n.id, WAY_OUT.map(([x, z]) => [cx + x, cz + 40 + z]));
+      else if (id2 === "herd") bringHerd();
+      else if (id2 === "materialize" && world.binding && options.infection) world.binding.materialize(options.infection.region, 50);
+      else if (id2 === "push") pending = { ...pending, push: true };
+      else if (id2 === "reset") reset();
+      return;
+    }
+    const { id, value } = change;
+    if (id === "count" && typeof value === "number") {
+      settings.count = value;
+      fit();
+    } else if (id === "scene" && typeof value === "string" && value !== settings.scene) {
+      settings.scene = value;
+      isDirty = true;
+    } else if (id === "physics" && typeof value === "boolean" && value !== settings.physics) {
+      settings.physics = value;
+      isDirty = true;
+    } else if (id === "type" && typeof value === "string") settings.type = value;
+    else if (id === "night" && typeof value === "boolean") settings.night = value;
+    else if (id === "seed" && typeof value === "number" && value !== settings.seed) {
+      settings.seed = value;
+      isDirty = true;
+    }
+  };
+  const typeOptions = () => [{ id: "mix", name: text.mix }, ...options.pack.types.map((type) => ({ id: type.id, name: options.typeLabel?.(type, locale) ?? type.id }))];
+  const sceneOptions = () => [{ id: "open", name: text.sceneNames.open }, ...Object.keys(scenes).map((id) => ({ id, name: text.sceneNames[id] ?? id }))];
+  const controls = () => [
+    // the order is the order the bench state is applied in (`sendInitial`): the seed makes the world, the scene writes its grid, the physics rebuilds the crowd, the count bears the agents
+    { kind: "number", id: "seed", name: text.controls.seed, min: 1, max: 9999, step: 1, default: settings.seed },
+    { kind: "choice", id: "scene", name: text.controls.scene, hint: text.hints.scene, options: sceneOptions(), default: settings.scene },
+    { kind: "boolean", id: "physics", name: text.controls.physics, hint: text.hints.physics, default: settings.physics },
+    { kind: "number", id: "count", name: text.controls.count, hint: text.hints.count, min: 0, max: CAPACITY, step: 100, default: settings.count },
+    { kind: "choice", id: "type", name: text.controls.type, hint: text.hints.type, options: typeOptions(), default: "mix" },
+    { kind: "boolean", id: "night", name: text.controls.night, hint: text.hints.night, default: false },
+    { kind: "action", id: "spawn", name: text.controls.spawn, slow: true },
+    { kind: "action", id: "noise", name: text.controls.noise, hint: text.hints.noise },
+    { kind: "action", id: "hit", name: text.controls.hit, hint: text.hints.hit },
+    { kind: "action", id: "kill_all", name: text.controls.kill_all },
+    { kind: "action", id: "join", name: text.controls.join, hint: text.hints.join },
+    { kind: "action", id: "flee", name: text.controls.flee, hint: text.hints.flee },
+    ...options.animals ? [{ kind: "action", id: "herd", name: text.controls.herd, hint: text.hints.herd }] : [],
+    ...options.infection ? [{ kind: "action", id: "materialize", name: text.controls.materialize, hint: text.hints.materialize }] : [],
+    { kind: "action", id: "push", name: text.controls.push, hint: text.hints.push },
+    { kind: "action", id: "reset", name: text.controls.reset, slow: true }
+  ];
+  const benchLayers = () => [
+    { id: "corpses", name: text.layers.corpses },
+    { id: "civilians", name: text.layers.civilians },
+    { id: "animals", name: text.layers.animals }
+  ];
+  const metrics = () => [
+    { id: "agents", name: text.metrics.agents, digits: 0, max: CAPACITY, read: () => world.crowd.store.n },
+    { id: "drawn", name: text.metrics.drawn, digits: 0, read: () => renderer ? renderer.lodCounts[0] + renderer.lodCounts[1] + renderer.lodCounts[2] : 0 },
+    { id: "lod_near", name: text.metrics.lod_near, digits: 0, read: () => renderer?.lodCounts[0] ?? 0 },
+    { id: "lod_middle", name: text.metrics.lod_middle, digits: 0, read: () => renderer?.lodCounts[1] ?? 0 },
+    { id: "lod_far", name: text.metrics.lod_far, digits: 0, read: () => renderer?.lodCounts[2] ?? 0 },
+    { id: "draw_calls", name: text.metrics.draw_calls, digits: 0, read: () => renderer?.drawCalls ?? 0 },
+    { id: "bake_ms", name: text.metrics.bake_ms, unit: "ms", digits: 0, read: () => renderer?.bakeMs ?? 0 },
+    { id: "detail_scale", name: text.metrics.detail_scale, digits: 2, read: () => renderer?.detailScale ?? 1 },
+    { id: "crowd_gpu_ms", name: text.metrics.crowd_gpu_ms, unit: "ms", digits: 1, read: () => renderer?.gpuMs ?? 0 },
+    { id: "active", name: text.metrics.active, digits: 0, read: () => world.crowd.stats.bands[0] },
+    { id: "kills", name: text.metrics.kills, digits: 0, read: () => world.crowd.stats.kills },
+    { id: "bodies", name: text.metrics.corpses, digits: 0, read: () => world.crowd.corpses.count },
+    { id: "civilians_alive", name: text.metrics.civilians, digits: 0, read: () => world.civilians.list.filter((n) => n.state !== "dead" && n.state !== "undead" && n.state !== "gone").length },
+    { id: "health", name: text.metrics.health, digits: 0, read: () => Math.max(0, world.player.state.health) },
+    { id: "grabbed", name: text.metrics.grabbed, read: () => world.player.state.grabbedBy >= 0 ? text.yes : text.no },
+    { id: "message", name: text.metrics.message, read: () => lastMessage },
+    { id: "falls_pressure", name: text.metrics.falls_pressure, digits: 0, read: () => world.crowd.stats.physics.falls[0] },
+    { id: "falls_chain", name: text.metrics.falls_chain, digits: 0, read: () => world.crowd.stats.physics.fallsBeyondBlast },
+    { id: "falls_landing", name: text.metrics.falls_landing, digits: 0, read: () => world.crowd.stats.physics.falls[3] },
+    { id: "climbers", name: text.metrics.climbers, digits: 0, read: () => peaks.climbers },
+    { id: "mound_max", name: text.metrics.mound_max, unit: "m", digits: 2, read: () => peaks.moundMax },
+    { id: "thrown_peak", name: text.metrics.thrown_peak, digits: 0, read: () => world.crowd.stats.physics.thrownPeak },
+    { id: "max_overlap", name: text.metrics.max_overlap, unit: "m", digits: 2, read: () => peaks.maxOverlap },
+    { id: "chain_links", name: text.metrics.chain_links, digits: 0, read: () => world.crowd.stats.physics.chainLinks },
+    { id: "crowd_ms_p99", name: text.metrics.crowd_ms_p99, unit: "ms", digits: 2, read: () => stepMsP99() }
+  ];
+  const fresh = (seed = 1, capacity = 600) => {
+    const player = createPlayer({ seed });
+    return { crowd: createCrowd({ pack: options.pack, seed, capacity, flow: { clock: () => 0 }, target: player }), player };
+  };
+  const run = (crowd, seconds) => {
+    for (let t = 0; t < seconds; t += FRAME) {
+      crowd.update(FRAME);
+      crowd.updateCorpses(FRAME);
+    }
+  };
+  const eyes = options.pack.types.map((type) => type.eye ?? null);
+  const sizes = Array.from({ length: options.pack.types.reduce((sum, type) => sum + (type.variants ?? 1), 0) }, () => ({ s: 1.7, bulk: 1 }));
+  const drawOnce = (crowd, player) => {
+    const out = [];
+    createCrowdInstances({ eyes }).agents(crowd.store, sizes, { camera: { x: player.state.x, z: player.state.z }, viewYaw: 0, target: { x: player.state.x, z: player.state.z, alive: true } }, (_v, level, instance) => out.push({ level, pose: instance.b[3] }));
+    return out;
+  };
+  const scenarios = () => [
+    {
+      id: "crowd_relevance",
+      name: text.scenarios.relevance,
+      run: ({ expect }) => {
+        const { crowd } = fresh(3);
+        const spot = createRng(3);
+        for (let k = 0; k < 500; k++) crowd.spawn((spot() - 0.5) * 600, (spot() - 0.5) * 600);
+        run(crowd, 1);
+        const [near, , mid, far] = crowd.stats.bands;
+        expect(crowd.store.n === 500, "500 agents", { n: crowd.store.n });
+        expect(near < 50 && mid + far > 400, "few think every frame, most are far and slow", { bands: [...crowd.stats.bands] });
+      }
+    },
+    {
+      id: "crowd_lod",
+      name: text.scenarios.lod,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(1, 4);
+        player.state.x = 0;
+        player.state.z = 0;
+        const i = crowd.spawn(0, -17, 0);
+        const levels = [];
+        for (const z of [-17, -19, -19.6, -17.5, -16]) {
+          crowd.store.z[i] = z;
+          levels.push(drawOnce(crowd, player)[0].level);
+        }
+        expect(levels.join() === "0,0,1,1,0", "in at 19.5 m, back under 16.5 m", { levels });
+      }
+    },
+    {
+      id: "crowd_attack_pose",
+      name: text.scenarios.attack_pose,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(1, 4);
+        const i = crowd.spawn(0, -1.5, 0);
+        crowd.store.state[i] = STATE3.CHASE;
+        const poses = [];
+        for (const z of [-1.5, -2, -2.3, -1.9]) {
+          crowd.store.z[i] = z;
+          poses.push(drawOnce(crowd, player)[0].pose);
+        }
+        expect(poses.join() === "3,3,0,0", "the attack pose holds to 2.2 m and comes back under 1.6 m", { poses });
+      }
+    },
+    {
+      id: "crowd_corpse_darkens",
+      name: text.scenarios.corpse_darkens,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(1, 4);
+        crowd.kill(crowd.spawn(0, -5, 0));
+        const life = crowd.numbers.corpseSeconds;
+        crowd.updateCorpses(life / 2);
+        const shades = [];
+        const heights = [];
+        const take = (_v, _l, instance) => {
+          shades.push(instance.shade);
+          heights.push(instance.b[0]);
+        };
+        const instances = createCrowdInstances({ eyes });
+        const frameOf = { camera: { x: player.state.x, z: player.state.z }, viewYaw: 0 };
+        instances.corpses(crowd.corpses.entries, sizes, frameOf, life, take, (i) => take(-1, 1, i));
+        crowd.updateCorpses(life / 2 - 30);
+        instances.corpses(crowd.corpses.entries, sizes, frameOf, life, take, (i) => take(-1, 1, i));
+        expect(Math.abs(shades[0] - 0.65) < 1e-9, "half its life: 65% of the colour", { shades });
+        expect(Math.abs(heights[1] / heights[0] - 0.5) < 1e-6, "30 s before the end: half its height", { heights });
+      }
+    },
+    {
+      id: "crowd_civilians_flee",
+      name: text.scenarios.civilians_flee,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(2, 4);
+        player.state.x = 0;
+        player.state.z = 6;
+        const civilians = createCivilians(crowd, { people: [{ id: "c", home: "home" }], buildings: LOTS });
+        civilians.join("c");
+        for (let t = 0; t < 10; t += 0.05) civilians.update(0.05);
+        const c = civilians.get("c");
+        expect(Math.hypot(c.x - 0, c.z - 6) < 2.5, "it follows", { x: c.x, z: c.z });
+        civilians.flee("c", [[5, 6], [10, 6]]);
+        for (let t = 0; t < 20; t += 0.05) civilians.update(0.05);
+        expect(c.state === "gone", "it ran off and is gone", { state: c.state });
+      }
+    },
+    {
+      id: "crowd_herd_calls",
+      name: text.scenarios.herd_calls,
+      run: ({ expect }) => {
+        const { crowd } = fresh(4, 4);
+        const herd = createHerd(crowd);
+        const hen = herd.add({ ...HERD_ROLES.chicken, species: "chicken", x: 20, z: 0, walkHz: 2.2, runHz: 4, size: 0.4 });
+        herd.add({ ...HERD_ROLES.southern_lapwing, species: "southern_lapwing", x: 5, z: 0, walkHz: 2.5, runHz: 1.6, size: 0.35 });
+        crowd.spawn(21.5, 0, 0);
+        const sounds = [];
+        herd.on("sound", (e) => sounds.push(HERD_SOUND_IDS[e.sound] ?? e.sound));
+        for (let f = 0; f < 40; f++) herd.update(0.05);
+        expect(sounds.includes("hen_cluck") && sounds.includes("lapwing_call"), "the hen clucks, the lapwing calls", { sounds });
+        expect(hen.x < 20, "the hen ran", { x: hen.x });
+      }
+    },
+    {
+      id: "crowd_vultures",
+      name: text.scenarios.vultures,
+      run: ({ expect }) => {
+        const centre = carrionCenter([{ x: 0, z: 0 }, { x: 3, z: 0 }, { x: 0, z: 3 }], null);
+        const vultures = createFlock({ count: 3, mode: "carrion" });
+        vultures.update(10, 0.05, centre, [0, 0]);
+        const r = vultures.birds.map((U) => Math.hypot(U.x - centre[0], U.z - centre[1]));
+        expect(r.every((d, i) => Math.abs(d - (7 + i * 2)) < 1e-9), "each at its radius over the centre of the bodies", { r });
+      }
+    },
+    ...options.infection ? [
+      {
+        id: "crowd_infection",
+        name: text.scenarios.infection,
+        run: ({ expect }) => {
+          const infection = options.infection;
+          const model = infection.create();
+          const { crowd } = fresh(6, 64);
+          const binding = bindInfection(crowd, model, { place: (_r, seed, k) => [seed % 100 - 50 + k * 0.01, 500 + k] });
+          const before = infection.active?.(model);
+          const born = binding.materialize(infection.region, 10);
+          crowd.update(0.1);
+          const back = binding.giveBack(infection.region);
+          expect(born.length > 0 && back === born.length && crowd.store.n === 0, "brought out, given back", { born: born.length, back });
+          if (before !== void 0) expect(infection.active(model) === before, "the region keeps its numbers", { before, after: infection.active(model) });
+          binding.unbind();
+        }
+      }
+    ] : [],
+    {
+      id: "crowd_determinism",
+      name: text.scenarios.determinism,
+      run: ({ expect }) => {
+        const trace = (seed) => {
+          const { crowd } = fresh(seed, 40);
+          for (let k = 0; k < 30; k++) crowd.spawn(k % 6 * 3 - 8, -10 - Math.floor(k / 6) * 3);
+          run(crowd, 3);
+          return Array.from({ length: crowd.store.n }, (_, i) => `${crowd.store.x[i].toFixed(4)},${crowd.store.z[i].toFixed(4)}`).join(";");
+        };
+        expect(trace(9) === trace(9), "the same seed gives the same crowd");
+        expect(trace(9) !== trace(10), "another seed gives another");
+      }
+    }
+  ];
+  wire();
+  fit();
+  const module = {
+    id: CROWD_AREA_ID,
+    name: text.name,
+    ground: { surface: "road" },
+    group: text.group,
+    get crowd() {
+      return world.crowd;
+    },
+    get player() {
+      return world.player;
+    },
+    get renderer() {
+      return renderer;
+    },
+    items: () => [],
+    area: () => ({ placements: [], view: sceneView() ?? { eye: [0, 1.7, 6], target: [cx, 1.2, cz] } }),
+    controls: () => controls(),
+    layers: () => benchLayers(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    attach(lent) {
+      host = lent;
+      three = lent.THREE;
+      last = null;
+      lent.audio?.register?.(CROWD_SOUND_BANK);
+      const off = lent.bench?.onChange(onChange);
+      const offFrame = lent.onFrame(frame);
+      const offGraphics = lent.graphics?.onChange(() => {
+        if (!renderer) return;
+        lent.scene.remove(renderer.group);
+        renderer.dispose();
+        renderer = null;
+        isBaked = false;
+      });
+      const offFixed = lent.onFrame((step) => world.physics ? stepCrowd(step) : void 0, { phase: "fixedSimulate" });
+      const offBlast = lent.on((event) => {
+        if (event.type !== "explosion") return;
+        world.crowd.blast({ point: event.point, energy: event.energy, radius: event.radius, lethalRadius: event.radius * LETHAL_SHARE, source: event.source, ...event.cause === "part" ? { chain: event.source } : {} });
+      });
+      if (host) removeProps = sceneOf()?.props?.(host, { cx, cz }, options.props ?? {}) ?? null;
+      if (options.eager) queueMicrotask(() => prepareDrawing());
+      return () => {
+        off?.();
+        offFrame();
+        offGraphics?.();
+        offFixed();
+        offBlast();
+        removeProps?.();
+        removeProps = null;
+        if (renderer) lent.scene.remove(renderer.group);
+        if (herdView) lent.scene.remove(herdView.group);
+        renderer?.dispose();
+        renderer = null;
+        herdView = null;
+        host = null;
+      };
+    }
+  };
+  return module;
+}
+
+export {
+  VARIETY_DEFAULTS,
+  lookOfAgent,
+  CROWD_RENDER_DEFAULTS,
+  createCrowdInstances,
+  createCrowdRenderer,
+  createHerdView,
+  CROWD_SOUND_BANK,
+  HERD_SOUND_IDS,
+  crowdBenchTextOf,
+  DENSE_WALL,
+  CHAIN_LINE,
+  BUILTIN_SCENES,
+  CROWD_AREA_ID,
+  CROWD_EFFECTS,
+  createCrowdTestModule
+};
+//# sourceMappingURL=chunk-PXT6DYGJ.js.map