@adatechnology/game-crowd 0.2.6 → 0.4.0

package/dist/index.global.js

@@ -22,27 +22,54 @@ var GameCrowd = (() => {
   var index_exports = {};
   __export(index_exports, {
     AGENT_FIELDS: () => AGENT_FIELDS,
+    BALANCE: () => BALANCE,
     CELL: () => CELL,
     CIVILIAN_DEFAULTS: () => CIVILIAN_DEFAULTS,
     CROWD_DEFAULTS: () => CROWD_DEFAULTS,
+    CROWD_PHYSICS_DEFAULTS: () => CROWD_PHYSICS_DEFAULTS,
     DOOR_DEFAULTS: () => DOOR_DEFAULTS,
+    FALL_CAUSE: () => FALL_CAUSE,
     HERD_DEFAULTS: () => HERD_DEFAULTS,
     HERD_ROLES: () => HERD_ROLES,
     MISSING: () => MISSING,
     STATE: () => STATE,
+    attachPhysicsWorker: () => attachPhysicsWorker,
     bindInfection: () => bindInfection,
     carrionCenter: () => carrionCenter,
+    contactStep: () => contactStep,
     createCivilians: () => createCivilians,
+    createContactView: () => createContactView,
     createCrowd: () => createCrowd,
     createDoors: () => createDoors,
     createFlock: () => createFlock,
     createHerd: () => createHerd,
     createNavGrid: () => createNavGrid,
     createRng: () => createRng,
-    createStore: () => createStore
+    createStore: () => createStore,
+    identityOf: () => identityOf,
+    mix32: () => mix32,
+    resolvePhysics: () => resolvePhysics,
+    unit: () => unit
   });
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_BLAST_SHOVE = { coupling: 0.02, maxSpeed: 20, lift: 0.3, minSpeed: 0.3, falloffPower: 2 };
+  function blastShove(blast, target, options = {}) {
+    const o = { ...DEFAULT_BLAST_SHOVE, ...options };
+    const dx = target.position[0] - blast.point[0];
+    const dy = target.position[1] - blast.point[1];
+    const dz = target.position[2] - blast.point[2];
+    const distance = Math.hypot(dx, dy, dz);
+    if (!(blast.radius > 0) || distance > blast.radius) return void 0;
+    const falloff = (1 - distance / blast.radius) ** o.falloffPower;
+    const mass = Math.max(target.mass, 0.05);
+    const speed = Math.min(o.maxSpeed, Math.sqrt(2 * blast.energy * (blast.reach ?? 1) * o.coupling / mass)) * falloff;
+    if (!(speed >= o.minSpeed)) return void 0;
+    const direction = distance > 1e-4 ? [dx / distance, dy / distance + o.lift, dz / distance] : [0, 1, 0];
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    return { speed, direction: [direction[0] / length, direction[1] / length, direction[2] / length], distance, falloff };
+  }
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var MISSING_BITS = {
     head: 1,
     armL: 2,
@@ -55,6 +82,54 @@ var GameCrowd = (() => {
     legRBroken: 256,
     jaw: 512
   };
+  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 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((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
   // ../game-characters/dist/index.js
   var __defProp2 = Object.defineProperty;
@@ -1527,6 +1602,11 @@ var GameCrowd = (() => {
 
   // src/grid.ts
   var CELL = { FREE: 0, SOLID: 1, LOW_WALL: 2, OPEN_DOOR: 3, GLASS: 4, CLOSED_DOOR: 5 };
+  var createCellOf = (half, cell, n) => (x, z) => {
+    const gx = Math.floor((x + half) / cell);
+    const gz = Math.floor((z + half) / cell);
+    return gx < 0 || gz < 0 || gx >= n || gz >= n ? -1 : gz * n + gx;
+  };
   var BORDER_WIDTH = 1;
   var BORDER_HEIGHT = 50;
   var LOS_STEP = 0.5;
@@ -1538,11 +1618,7 @@ var GameCrowd = (() => {
     const n = size / cell;
     const occ = new Uint8Array(n * n);
     const occH = new Float32Array(n * n);
-    const cellOf = (x, z) => {
-      const gx = Math.floor((x + half) / cell);
-      const gz = Math.floor((z + half) / cell);
-      return gx < 0 || gz < 0 || gx >= n || gz >= n ? -1 : gz * n + gx;
-    };
+    const cellOf = createCellOf(half, cell, n);
     const solidAt = (x, z, y = 0.5) => {
       const c = cellOf(x, z);
       return c < 0 || occ[c] !== 0 && occ[c] !== 3 && occH[c] > y;
@@ -1596,6 +1672,1864 @@ var GameCrowd = (() => {
     };
   }
 
+  // src/identity.ts
+  var mix32 = (value) => {
+    let hash = value >>> 0;
+    hash ^= hash >>> 16;
+    hash = Math.imul(hash, 2246822507);
+    hash ^= hash >>> 13;
+    hash = Math.imul(hash, 3266489909);
+    hash ^= hash >>> 16;
+    return hash >>> 0;
+  };
+  var unit = (identity, step, salt) => (mix32(mix32(identity ^ salt) + Math.imul(step + 1, 2654435769) >>> 0) >>> 0) / 4294967296;
+  var identityOf = (seed, serial) => mix32(seed ^ mix32(serial));
+  var SALT = {
+    FALL: 62481,
+    TRIP: 29209,
+    LIMB: 110848,
+    REGION: 189968,
+    JAW: 239536,
+    CORPSE: 311518,
+    SPIN: 364922,
+    SPEED: 413981,
+    REACTION: 466972,
+    STABILITY: 569886,
+    TRIP_FACTOR: 605021,
+    DRIVE: 655571,
+    CADENCE: 728142,
+    AGGRESSION: 797335,
+    IDLE: 867848,
+    GAIT: 937753
+  };
+
+  // src/types.ts
+  var STATE = {
+    WANDER: 0,
+    CHASE: 1,
+    GRAB: 2,
+    STUNNED: 3,
+    CALLING: 4,
+    AIRBORNE: 5,
+    DORMANT: 6,
+    SWELLING: 7,
+    SWING: 8,
+    EATING: 9,
+    PILE_STEP: 10,
+    SEEKING_SOUND: 12
+  };
+  var BALANCE = { STANDING: 0, STAGGERING: 1, FALLEN: 2, GETTING_UP: 3, THROWN: 4 };
+  var FALL_CAUSE = { NONE: 0, PRESSURE: 1, SHOVE: 2, TRIP: 3, LANDING: 4, COLLAPSE: 5, BLAST: 6 };
+  var MISSING = { SKULL: 1, ARM_L: 2, ARM_R: 4, LEG_L: 8, LEG_R: 16, ARM_L_BROKEN: 32, ARM_R_BROKEN: 64, LEG_L_BROKEN: 128, LEG_R_BROKEN: 256, JAW: 512 };
+
+  // src/physics/balance.ts
+  var GRAVITY_FORCE = 9.8;
+  var GROUND_MASS_FACTOR = 3;
+  var TRIP_MIN_SPEED = 0.5;
+  var TRIP_REFERENCE_SPEED = 1.4;
+  var TRIP_MOUND = 150;
+  var TRIP_CLEARANCE = 0.1;
+  var COLLAPSE_STAGGER = 0.6;
+  var COLLAPSE_FALL = 1;
+  var CAUSE_ORDER = [FALL_CAUSE.PRESSURE, FALL_CAUSE.SHOVE, FALL_CAUSE.TRIP, FALL_CAUSE.LANDING, FALL_CAUSE.COLLAPSE, FALL_CAUSE.BLAST];
+  var CHAIN_WINDOW_STEPS = 240;
+  var CARRY_STEPS = 24;
+  var isCarried = (cause) => cause !== FALL_CAUSE.PRESSURE && cause !== FALL_CAUSE.TRIP;
+  function createBalance(ctx) {
+    const { store } = ctx;
+    const requests = [];
+    const balanceOptions = () => ctx.options.balance;
+    const stabilityOf = (i) => (ctx.typeOf(i).balance?.stability ?? 1) * store.stability[i];
+    const canFall = (i) => ctx.typeOf(i).balance?.canFall !== false;
+    const criticalOf = (i) => balanceOptions().criticalFactor * store.mass[i] * GRAVITY_FORCE * stabilityOf(i);
+    const requestFall = (i, cause, score) => {
+      if (!canFall(i)) return;
+      requests.push({ index: i, identity: store.identity[i], cause, score, born: ctx.step });
+    };
+    const stagger = (i) => {
+      if (store.balance[i] !== BALANCE.STANDING || !canFall(i)) return;
+      store.balance[i] = BALANCE.STAGGERING;
+      store.balanceTimer[i] = 0;
+    };
+    const shove = (i, speed, cause) => {
+      const options = balanceOptions();
+      const knockSpeed = options.shoveFall * stabilityOf(i);
+      if (store.balance[i] !== BALANCE.STANDING && store.balance[i] !== BALANCE.STAGGERING) return;
+      if (speed > knockSpeed) requestFall(i, cause, speed / knockSpeed);
+      else if (speed > options.shoveStagger) stagger(i);
+    };
+    const countsAsChainFall = (i, cause) => {
+      if (cause === FALL_CAUSE.PRESSURE || cause === FALL_CAUSE.BLAST) return false;
+      if (ctx.step - ctx.lastBlastStep > CHAIN_WINDOW_STEPS) return false;
+      const direct = store.blastStep[i] === ctx.lastBlastStep ? store.directShove[i] : 0;
+      return direct < balanceOptions().shoveStagger;
+    };
+    const goDown = (i, cause) => {
+      ctx.stats.falls[CAUSE_ORDER.indexOf(cause)]++;
+      if (countsAsChainFall(i, cause)) ctx.stats.fallsBeyondBlast++;
+      if (store.state[i] === STATE.PILE_STEP) ctx.releasePileStep(i);
+      store.balance[i] = BALANCE.FALLEN;
+      store.balanceTimer[i] = 0;
+      store.fallCause[i] = cause;
+      store.vx[i] = store.vz[i] = 0;
+      store.pushX[i] /= GROUND_MASS_FACTOR;
+      store.pushZ[i] /= GROUND_MASS_FACTOR;
+      store.aimX[i] = store.aimZ[i] = 0;
+      const target = ctx.target();
+      if (target && target.state.grabbedBy === i) target.release();
+      ctx.emit("fall", { agent: i, cause, x: store.x[i], z: store.z[i], identity: store.identity[i] });
+    };
+    const flush = () => {
+      if (!requests.length) return;
+      const options = balanceOptions();
+      requests.sort((a, b) => b.score - a.score || a.identity - b.identity);
+      let fallen = ctx.stats.fallen;
+      let fallsLeft = options.maxFallsPerStep;
+      const waiting = [];
+      for (const request of requests) {
+        const i = request.index;
+        if (i >= store.n || store.identity[i] !== request.identity) continue;
+        const balance = store.balance[i];
+        if (balance !== BALANCE.STANDING && balance !== BALANCE.STAGGERING) continue;
+        if (fallsLeft > 0 && fallen < options.maxFallen) {
+          goDown(i, request.cause);
+          fallsLeft--;
+          fallen++;
+          continue;
+        }
+        stagger(i);
+        if (isCarried(request.cause) && ctx.step - request.born < CARRY_STEPS) waiting.push(request);
+      }
+      requests.length = 0;
+      requests.push(...waiting);
+    };
+    const hasBodyOnTop = (i) => {
+      const cell = ctx.grid.cellOf(store.x[i], store.z[i]);
+      if (cell < 0) return false;
+      const options = ctx.options.mound;
+      if (!options) return false;
+      const top = store.y[i] + options.bodyThickness * store.build[i];
+      return ctx.moundAt(cell) / 1e3 > top + 0.05 || ctx.weightOn(i) > 0;
+    };
+    const stepStanding = (i, ratio, contactShove, options) => {
+      if (contactShove > options.shoveFall * stabilityOf(i)) return requestFall(i, FALL_CAUSE.SHOVE, contactShove / (options.shoveFall * stabilityOf(i)));
+      if (ratio > options.staggerEnter || contactShove > options.shoveStagger) stagger(i);
+      else tryTrip(i);
+    };
+    const tryTrip = (i) => {
+      const cell = ctx.grid.cellOf(store.x[i], store.z[i]);
+      if (cell < 0 || cell === ctx.grid.cellOf(store.prevX[i], store.prevZ[i])) return;
+      const mound = ctx.moundAt(cell);
+      if (mound < TRIP_MOUND || store.y[i] >= mound / 1e3 - TRIP_CLEARANCE) return;
+      const speed = Math.hypot(store.vx[i] + store.pushX[i], store.vz[i] + store.pushZ[i]);
+      if (speed <= TRIP_MIN_SPEED) return;
+      const chance = (ctx.typeOf(i).balance?.trip ?? 0.04) * store.tripFactor[i] * (speed / TRIP_REFERENCE_SPEED);
+      if (unit(store.identity[i], ctx.step, SALT.TRIP) < chance) requestFall(i, FALL_CAUSE.TRIP, 1);
+    };
+    const stepStaggering = (i, ratio, contactShove, options) => {
+      store.balanceTimer[i] += ctx.h;
+      if (contactShove > options.shoveFall * stabilityOf(i)) return requestFall(i, FALL_CAUSE.SHOVE, contactShove / (options.shoveFall * stabilityOf(i)));
+      if (ratio > 1 && unit(store.identity[i], ctx.step, SALT.FALL) < 1 - Math.exp(-options.fallRate * (ratio - 1) ** 2 * ctx.h)) return requestFall(i, FALL_CAUSE.PRESSURE, ratio);
+      if (ratio < options.staggerLeave && store.balanceTimer[i] >= options.staggerMin) {
+        store.balance[i] = BALANCE.STANDING;
+        store.balanceTimer[i] = 0;
+      }
+    };
+    const stepFallen = (i, ratio, options) => {
+      store.balanceTimer[i] += ctx.h;
+      if (store.balanceTimer[i] < options.fallenMin + store.reaction[i] || ratio >= options.releaseFactor || hasBodyOnTop(i)) return;
+      store.balance[i] = BALANCE.GETTING_UP;
+      store.balanceTimer[i] = 0;
+    };
+    const step = (options, contactShove) => {
+      const smoothing = 1 - Math.exp(-ctx.h / options.pressureTau);
+      let fallen = 0;
+      let staggering = 0;
+      for (let i = 0; i < store.n; i++) {
+        const state = store.balance[i];
+        if (state === BALANCE.THROWN) continue;
+        store.pressure[i] += (store.field[i] - store.pressure[i]) * smoothing;
+        const ratio = store.pressure[i] / criticalOf(i);
+        if (state === BALANCE.STANDING) stepStanding(i, ratio, contactShove[i], options);
+        else if (state === BALANCE.STAGGERING) stepStaggering(i, ratio, contactShove[i], options);
+        else if (state === BALANCE.FALLEN) stepFallen(i, ratio, options);
+        else if ((store.balanceTimer[i] += ctx.h) >= options.getUpSeconds) {
+          store.balance[i] = BALANCE.STANDING;
+          store.balanceTimer[i] = 0;
+        }
+        if (store.balance[i] === BALANCE.STAGGERING) staggering++;
+        else if (store.balance[i] === BALANCE.FALLEN || store.balance[i] === BALANCE.GETTING_UP) fallen++;
+      }
+      ctx.stats.fallen = fallen;
+      ctx.stats.staggering = staggering;
+    };
+    const landed = (i, height) => {
+      if (store.balance[i] !== BALANCE.STANDING && store.balance[i] !== BALANCE.STAGGERING) return;
+      if (height > COLLAPSE_FALL) requestFall(i, FALL_CAUSE.COLLAPSE, height / COLLAPSE_FALL);
+      else if (height > COLLAPSE_STAGGER) stagger(i);
+    };
+    return { requestFall, stagger, shove, step, flush, landed, pending: () => requests.length };
+  }
+
+  // src/physics/blast.ts
+  var CENTRE_HEIGHT = 1;
+  var SHELTERED = 0.5;
+  var DISMEMBER_SHARE = 0.5;
+  var LIMB_CHANCE = 0.5;
+  var STUN_BASE = 0.45;
+  var BLOOD_PER_BODY = 60;
+  var LIMBS = [
+    { bit: MISSING.ARM_L, region: 2 },
+    { bit: MISSING.ARM_R, region: 3 },
+    { bit: MISSING.LEG_L, region: 4 },
+    { bit: MISSING.LEG_R, region: 5 }
+  ];
+  function createBlasts(ctx, hooks) {
+    const { store } = ctx;
+    const options = ctx.options.blast;
+    const queue = [];
+    const emitLimb = (tally, i, region) => {
+      if (tally.limbEffects++ >= options.limbEffectsPerBlast) return;
+      ctx.emit("effect", { effect: "limb", point: [store.x[i], store.height[i] * 0.9, store.z[i]], agent: i, region, severed: true });
+    };
+    const emitBlood = (tally, i) => {
+      if (tally.bloodEffects++ >= options.bloodEffectsPerBlast) {
+        tally.bloodSum += BLOOD_PER_BODY;
+        return;
+      }
+      ctx.emit("effect", { effect: "blood", point: [store.x[i], store.height[i] * 1.2, store.z[i]], agent: i, amount: BLOOD_PER_BODY, died: true });
+    };
+    const kill = (i, blast, distance, tally) => {
+      tally.killed++;
+      store.hp[i] = 0;
+      if (blast.lethalRadius !== void 0 && distance < DISMEMBER_SHARE * blast.lethalRadius) {
+        for (let k = 0; k < LIMBS.length; k++) {
+          if (unit(store.identity[i], ctx.step, SALT.LIMB + k) >= LIMB_CHANCE) continue;
+          store.missing[i] |= LIMBS[k].bit;
+          emitLimb(tally, i, LIMBS[k].region);
+        }
+      }
+      emitBlood(tally, i);
+      ctx.deferKill(i);
+    };
+    const hurt = (i, blast, distance, index, reach = 1) => {
+      const falloff = (1 - distance / blast.radius) ** 2 * reach;
+      const amount = blast.energy / 1e3 * options.pointsPerKilojoule * falloff;
+      const draw = (salt) => () => unit(store.identity[i], ctx.step, salt);
+      if (ctx.damage(i, { region: 1, amount, distance, cut: falloff }, draw(SALT.JAW + index)).died) return true;
+      const region = Math.floor(unit(store.identity[i], ctx.step, SALT.REGION + index) * 6);
+      return ctx.damage(i, { region, amount: amount / 2, distance, cut: falloff }, draw(SALT.JAW + 8 + index)).died;
+    };
+    const shoveOf = (i, blasts, reaches) => {
+      const position = [store.x[i], store.y[i] + CENTRE_HEIGHT * store.height[i], store.z[i]];
+      let vx = 0;
+      let vy = 0;
+      let vz = 0;
+      let falloff = 0;
+      for (let b = 0; b < blasts.length; b++) {
+        const blast = blasts[b];
+        const shove = blastShove({ point: blast.point, energy: blast.energy, radius: blast.radius, reach: reaches?.[b] ?? 1 }, { position, mass: store.mass[i] }, options.shove);
+        if (!shove) continue;
+        vx += shove.speed * shove.direction[0];
+        vy += shove.speed * shove.direction[1];
+        vz += shove.speed * shove.direction[2];
+        falloff = Math.max(falloff, shove.falloff);
+      }
+      return vx || vy || vz ? { vx, vy, vz, falloff } : void 0;
+    };
+    const distanceTo = (i, blast) => Math.hypot(store.x[i] - blast.point[0], store.y[i] + CENTRE_HEIGHT * store.height[i] - blast.point[1], store.z[i] - blast.point[2]);
+    const applyShove = (i, shove, candidates, tallies, blasts) => {
+      const horizontal = Math.hypot(shove.vx, shove.vz);
+      const speed = Math.hypot(horizontal, shove.vy);
+      store.directShove[i] = horizontal;
+      store.blastStep[i] = ctx.step;
+      const { balance, thrown } = hooks;
+      if (thrown && speed >= options.throwSpeed && (store.x[i] - ctx.centre.x) ** 2 + (store.z[i] - ctx.centre.z) ** 2 <= ctx.options.thrown.radius ** 2) {
+        candidates.push({ index: i, speed, vx: shove.vx, vy: shove.vy, vz: shove.vz, distance: Math.hypot(store.x[i] - ctx.centre.x, store.z[i] - ctx.centre.z) });
+        return;
+      }
+      if (store.hp[i] <= 0) return;
+      if (!balance) {
+        store.state[i] = STATE.STUNNED;
+        store.stateTimer[i] = STUN_BASE + shove.falloff;
+        store.vx[i] = shove.vx;
+        store.vz[i] = shove.vz;
+        return;
+      }
+      store.pushX[i] += shove.vx;
+      store.pushZ[i] += shove.vz;
+      balance.shove(i, horizontal, FALL_CAUSE.BLAST);
+      for (let b = 0; b < blasts.length; b++) if (distanceTo(i, blasts[b]) <= blasts[b].radius && horizontal > ctx.options.balance.shoveFall) tallies[b].fallen++;
+    };
+    const affect = (i, blasts, tallies, candidates) => {
+      let dead = store.hp[i] <= 0;
+      const reaches = blasts.map(
+        (blast) => blast.reach && distanceTo(i, blast) <= blast.radius ? blast.reach([store.x[i], store.y[i] + CENTRE_HEIGHT * store.height[i], store.z[i]]) : 1
+      );
+      for (let b = 0; b < blasts.length && !dead; b++) {
+        const blast = blasts[b];
+        const distance = distanceTo(i, blast);
+        if (distance > blast.radius) continue;
+        tallies[b].reached++;
+        if (blast.lethalRadius !== void 0 && distance < blast.lethalRadius && reaches[b] >= SHELTERED) kill(i, blast, distance, tallies[b]);
+        else if (hurt(i, blast, distance, b, reaches[b])) tallies[b].killed++;
+        dead = store.hp[i] <= 0 || dead;
+      }
+      const shove = shoveOf(i, blasts, reaches);
+      if (shove) applyShove(i, shove, candidates, tallies, blasts);
+    };
+    const resolve = () => {
+      if (!queue.length) return;
+      const blasts = queue.splice(0, options.maxBlastsPerStep);
+      const tallies = blasts.map(() => ({ reached: 0, killed: 0, fallen: 0, limbEffects: 0, bloodEffects: 0, bloodSum: 0 }));
+      const candidates = [];
+      ctx.lastBlastStep = ctx.step;
+      ctx.stats.blastChecks = store.n * blasts.length;
+      for (let i = 0; i < store.n; i++) if (store.balance[i] !== BALANCE.THROWN) affect(i, blasts, tallies, candidates);
+      const thrown = hooks.thrown?.assign(candidates) ?? 0;
+      blasts.forEach((blast, b) => {
+        const tally = tallies[b];
+        if (tally.bloodSum > 0) ctx.emit("effect", { effect: "blood", point: [blast.point[0], blast.point[1], blast.point[2]], amount: tally.bloodSum, died: true });
+        hooks.pileBlast(blast.point[0], blast.point[2], blast.radius);
+        ctx.emit("blasted", {
+          point: [blast.point[0], blast.point[1], blast.point[2]],
+          radius: blast.radius,
+          reached: tally.reached,
+          killed: tally.killed,
+          thrown: b === 0 ? thrown : 0,
+          fallen: tally.fallen,
+          ...blast.chain === void 0 ? {} : { chain: blast.chain }
+        });
+        if (blast.chain !== void 0) ctx.stats.chainLinks++;
+      });
+    };
+    return { enqueue: (blast) => void queue.push(blast), resolve, pending: () => queue.length };
+  }
+
+  // src/physics/contact.ts
+  var GROUND_MASS_FACTOR2 = 3;
+  var PAIR_MARGIN = 0.15;
+  var MAX_LEVEL_GAP = 0.15;
+  var PAIRS_PER_AGENT = 12;
+  var MIN_DISTANCE = 1e-6;
+  var createContactWorkspace = (capacity, grid) => ({
+    head: new Int32Array(Math.floor(grid.size) ** 2).fill(-1),
+    next: new Int32Array(capacity),
+    touched: new Int32Array(capacity),
+    touchedCount: 0,
+    pairI: new Int32Array(capacity * PAIRS_PER_AGENT),
+    pairJ: new Int32Array(capacity * PAIRS_PER_AGENT),
+    pairCount: 0,
+    deltaX: new Float32Array(capacity),
+    deltaZ: new Float32Array(capacity),
+    count: new Uint8Array(capacity),
+    pushBeforeX: new Float32Array(capacity),
+    pushBeforeZ: new Float32Array(capacity),
+    shove: new Float32Array(capacity),
+    takesPart: new Uint8Array(capacity),
+    radiusOf: new Float64Array(capacity),
+    massOf: new Float64Array(capacity),
+    pairReach: new Float64Array(capacity * PAIRS_PER_AGENT),
+    pairDistance: new Float64Array(capacity * PAIRS_PER_AGENT),
+    pairNormalX: new Float64Array(capacity * PAIRS_PER_AGENT),
+    pairNormalZ: new Float64Array(capacity * PAIRS_PER_AGENT)
+  });
+  var createContactView = (store, grid) => ({ n: 0, store, grid, workspace: createContactWorkspace(store.x.length, grid) });
+  var takesPartInContact = (store, i) => store.band[i] === 0 && store.balance[i] !== BALANCE.THROWN && store.state[i] !== STATE.PILE_STEP && store.state[i] !== STATE.DORMANT;
+  var isOnGround = (store, i) => store.balance[i] === BALANCE.FALLEN || store.balance[i] === BALANCE.GETTING_UP;
+  var effectiveMass = (store, i) => store.mass[i] * (isOnGround(store, i) ? GROUND_MASS_FACTOR2 : 1);
+  var bodyRadius = (store, i, radius) => radius * store.build[i];
+  function readBodies(view, radius) {
+    const { store, workspace } = view;
+    const { takesPart, radiusOf, massOf } = workspace;
+    for (let i = 0; i < view.n; i++) {
+      const takes = takesPartInContact(store, i);
+      takesPart[i] = takes ? 1 : 0;
+      radiusOf[i] = bodyRadius(store, i, radius);
+      massOf[i] = effectiveMass(store, i);
+    }
+  }
+  function rebuildHash(view) {
+    const { store, grid, workspace } = view;
+    const side = Math.floor(grid.size);
+    for (let k = 0; k < workspace.touchedCount; k++) workspace.head[workspace.touched[k]] = -1;
+    workspace.touchedCount = 0;
+    for (let i = 0; i < view.n; i++) {
+      if (!workspace.takesPart[i]) continue;
+      const hx = Math.floor(store.x[i] + grid.half);
+      const hz = Math.floor(store.z[i] + grid.half);
+      if (hx < 0 || hz < 0 || hx >= side || hz >= side) continue;
+      const cell = hz * side + hx;
+      if (workspace.head[cell] === -1) workspace.touched[workspace.touchedCount++] = cell;
+      workspace.next[i] = workspace.head[cell];
+      workspace.head[cell] = i;
+    }
+  }
+  var FORWARD_CELLS = [1, 0, -1, 1, 0, 1, 1, 1];
+  function addPairsOfCell(view, i, cell, sameCell) {
+    const { store, workspace } = view;
+    const { head, next, radiusOf, pairI, pairJ } = workspace;
+    const { x, z, y } = store;
+    const xi = x[i];
+    const zi = z[i];
+    const yi = y[i];
+    const reachBase = radiusOf[i] + PAIR_MARGIN;
+    for (let j = head[cell]; j !== -1; j = next[j]) {
+      if (sameCell && j <= i || Math.abs(yi - y[j]) > MAX_LEVEL_GAP) continue;
+      const reach = reachBase + radiusOf[j];
+      const ex = x[j] - xi;
+      const ez = z[j] - zi;
+      if (ex * ex + ez * ez >= reach * reach || workspace.pairCount >= pairI.length) continue;
+      pairI[workspace.pairCount] = i;
+      pairJ[workspace.pairCount++] = j;
+    }
+  }
+  function collectPairs(view) {
+    const { store, grid, workspace } = view;
+    const side = Math.floor(grid.size);
+    workspace.pairCount = 0;
+    for (let i = 0; i < view.n; i++) {
+      if (!workspace.takesPart[i]) continue;
+      const hx = Math.floor(store.x[i] + grid.half);
+      const hz = Math.floor(store.z[i] + grid.half);
+      if (hx < 0 || hz < 0 || hx >= side || hz >= side) continue;
+      addPairsOfCell(view, i, hz * side + hx, true);
+      for (let k = 0; k < FORWARD_CELLS.length; k += 2) {
+        const qx = hx + FORWARD_CELLS[k];
+        const qz = hz + FORWARD_CELLS[k + 1];
+        if (qx >= 0 && qz >= 0 && qx < side && qz < side) addPairsOfCell(view, i, qz * side + qx, false);
+      }
+    }
+  }
+  function measurePairs(view) {
+    const { store, workspace } = view;
+    const { pairI, pairJ, radiusOf, pairReach, pairDistance, pairNormalX, pairNormalZ } = workspace;
+    const { x, z, identity } = store;
+    for (let p = 0; p < workspace.pairCount; p++) {
+      const i = pairI[p];
+      const j = pairJ[p];
+      const reach = radiusOf[i] + radiusOf[j];
+      const ex = x[i] - x[j];
+      const ez = z[i] - z[j];
+      const distance = Math.sqrt(ex * ex + ez * ez);
+      pairReach[p] = reach;
+      pairDistance[p] = distance;
+      if (distance >= reach) continue;
+      if (distance > MIN_DISTANCE) {
+        pairNormalX[p] = ex / distance;
+        pairNormalZ[p] = ez / distance;
+        continue;
+      }
+      const angle = 2 * Math.PI * unit(identity[i] ^ identity[j], 0, SALT.SPIN);
+      pairNormalX[p] = Math.cos(angle);
+      pairNormalZ[p] = Math.sin(angle);
+    }
+  }
+  function solveImpulse(store, workspace, p) {
+    if (workspace.pairDistance[p] >= workspace.pairReach[p]) return;
+    const i = workspace.pairI[p];
+    const j = workspace.pairJ[p];
+    const nx = workspace.pairNormalX[p];
+    const nz = workspace.pairNormalZ[p];
+    const { vx, vz, pushX, pushZ } = store;
+    const closing = (vx[i] + pushX[i] - vx[j] - pushX[j]) * nx + (vz[i] + pushZ[i] - vz[j] - pushZ[j]) * nz;
+    if (closing >= 0) return;
+    const massI = workspace.massOf[i];
+    const massJ = workspace.massOf[j];
+    const impulse = -closing * massI * massJ / (massI + massJ);
+    pushX[i] += impulse * nx / massI;
+    pushZ[i] += impulse * nz / massI;
+    pushX[j] -= impulse * nx / massJ;
+    pushZ[j] -= impulse * nz / massJ;
+  }
+  function accumulateCorrection(workspace, p, relaxation) {
+    const distance = workspace.pairDistance[p];
+    const reach = workspace.pairReach[p];
+    if (distance >= reach) return;
+    const i = workspace.pairI[p];
+    const j = workspace.pairJ[p];
+    const massI = workspace.massOf[i];
+    const massJ = workspace.massOf[j];
+    const move = relaxation * (reach - distance);
+    const nx = workspace.pairNormalX[p];
+    const nz = workspace.pairNormalZ[p];
+    workspace.deltaX[i] += move * nx * (massJ / (massI + massJ));
+    workspace.deltaZ[i] += move * nz * (massJ / (massI + massJ));
+    workspace.deltaX[j] -= move * nx * (massI / (massI + massJ));
+    workspace.deltaZ[j] -= move * nz * (massI / (massI + massJ));
+    workspace.count[i]++;
+    workspace.count[j]++;
+  }
+  var isOpen = (grid, x, z) => {
+    const cell = grid.cellOf(x, z);
+    return cell >= 0 && (grid.occ[cell] === 0 || grid.occ[cell] === 3);
+  };
+  function applyCorrection(view, agent, params) {
+    const { store, grid, workspace } = view;
+    const count = workspace.count[agent];
+    if (!count) return;
+    workspace.count[agent] = 0;
+    const cap = params.maxCorrection;
+    const dx = Math.max(-cap, Math.min(cap, workspace.deltaX[agent] / count));
+    const dz = Math.max(-cap, Math.min(cap, workspace.deltaZ[agent] / count));
+    if (isOpen(grid, store.x[agent] + dx, store.z[agent])) store.x[agent] += dx;
+    if (isOpen(grid, store.x[agent], store.z[agent] + dz)) store.z[agent] += dz;
+  }
+  function resetCorrection(workspace, agent) {
+    workspace.deltaX[agent] = 0;
+    workspace.deltaZ[agent] = 0;
+    workspace.count[agent] = 0;
+  }
+  function correctPositions(view, params) {
+    const { workspace } = view;
+    for (let p = 0; p < workspace.pairCount; p++) {
+      resetCorrection(workspace, workspace.pairI[p]);
+      resetCorrection(workspace, workspace.pairJ[p]);
+    }
+    for (let p = 0; p < workspace.pairCount; p++) accumulateCorrection(workspace, p, params.relaxation);
+    for (let p = 0; p < workspace.pairCount; p++) {
+      applyCorrection(view, workspace.pairI[p], params);
+      applyCorrection(view, workspace.pairJ[p], params);
+    }
+  }
+  function measureOverlaps(view, out) {
+    const { store, workspace } = view;
+    for (let p = 0; p < workspace.pairCount; p++) {
+      const i = workspace.pairI[p];
+      const j = workspace.pairJ[p];
+      if (isOnGround(store, i) && isOnGround(store, j)) continue;
+      const reach = workspace.radiusOf[i] + workspace.radiusOf[j];
+      const overlap = reach - Math.hypot(store.x[i] - store.x[j], store.z[i] - store.z[j]);
+      if (overlap <= 0) continue;
+      out.contacts++;
+      out.overlapSum += overlap;
+      if (overlap > out.maxOverlap) out.maxOverlap = overlap;
+    }
+  }
+  function dampPush(view, params) {
+    const { store, workspace } = view;
+    const lambda = Math.exp(-params.friction * params.h);
+    for (let i = 0; i < view.n; i++) {
+      workspace.shove[i] = Math.hypot(store.pushX[i] - workspace.pushBeforeX[i], store.pushZ[i] - workspace.pushBeforeZ[i]);
+      store.pushX[i] *= lambda;
+      store.pushZ[i] *= lambda;
+      const speed = Math.hypot(store.pushX[i], store.pushZ[i]);
+      if (speed <= params.maxPush) continue;
+      store.pushX[i] *= params.maxPush / speed;
+      store.pushZ[i] *= params.maxPush / speed;
+    }
+  }
+  function prepareHash(view, radius) {
+    readBodies(view, radius);
+    rebuildHash(view);
+  }
+  function contactStep(view, params, out) {
+    const { store, workspace } = view;
+    out.contacts = 0;
+    out.maxOverlap = 0;
+    out.overlapSum = 0;
+    for (let i = 0; i < view.n; i++) {
+      workspace.pushBeforeX[i] = store.pushX[i];
+      workspace.pushBeforeZ[i] = store.pushZ[i];
+    }
+    readBodies(view, params.radius);
+    rebuildHash(view);
+    collectPairs(view);
+    for (let iteration = 0; iteration < params.iterations; iteration++) {
+      measurePairs(view);
+      for (let p = 0; p < workspace.pairCount; p++) solveImpulse(store, workspace, p);
+      for (let p = workspace.pairCount - 1; p >= 0; p--) solveImpulse(store, workspace, p);
+      correctPositions(view, params);
+    }
+    measureOverlaps(view, out);
+    dampPush(view, params);
+  }
+
+  // src/physics/context.ts
+  var createPhysicsStats = () => ({
+    contacts: 0,
+    maxOverlap: 0,
+    meanOverlap: 0,
+    falls: [0, 0, 0, 0, 0, 0],
+    fallsBeyondBlast: 0,
+    fallen: 0,
+    staggering: 0,
+    climbers: 0,
+    moundMax: 0,
+    thrownActive: 0,
+    thrownPeak: 0,
+    blastChecks: 0,
+    chainLinks: 0,
+    fieldMax: 0,
+    playerPressure: 0
+  });
+
+  // src/physics/density.ts
+  var DECISION_STEPS = 12;
+  var FAR_BAND = 1;
+  function createDensity(ctx, options) {
+    const { store, grid } = ctx;
+    const side = Math.ceil(grid.size / options.cell);
+    const bodies = new Uint16Array(side * side);
+    const touched = [];
+    const half = grid.half;
+    const cellOf = (i) => {
+      const gx = Math.floor((store.x[i] + half) / options.cell);
+      const gz = Math.floor((store.z[i] + half) / options.cell);
+      return gx < 0 || gz < 0 || gx >= side || gz >= side ? -1 : gz * side + gx;
+    };
+    const isWalking = (i) => store.band[i] === FAR_BAND && (store.balance[i] === BALANCE.STANDING || store.balance[i] === BALANCE.STAGGERING) && store.state[i] !== STATE.PILE_STEP && store.state[i] !== STATE.DORMANT;
+    const count = () => {
+      for (let k = 0; k < touched.length; k++) bodies[touched[k]] = 0;
+      touched.length = 0;
+      for (let i = 0; i < store.n; i++) {
+        if (!isWalking(i)) continue;
+        const cell = cellOf(i);
+        if (cell < 0) continue;
+        if (bodies[cell] === 0) touched.push(cell);
+        bodies[cell]++;
+      }
+    };
+    const step = () => {
+      if (ctx.step % DECISION_STEPS === 0) count();
+      if (!touched.length) return;
+      for (let i = 0; i < store.n; i++) {
+        if (!isWalking(i)) continue;
+        const cell = cellOf(i);
+        const around = cell < 0 ? 0 : bodies[cell];
+        store.field[i] = around > options.capacity ? (around - options.capacity) * options.pressurePerBody : 0;
+      }
+    };
+    const bodiesAround = (i) => {
+      const cell = cellOf(i);
+      return cell < 0 ? 0 : bodies[cell];
+    };
+    const slowdown = (i, band) => {
+      if (band !== FAR_BAND) return 1;
+      const around = bodiesAround(i);
+      return around > options.capacity ? options.capacity / around : 1;
+    };
+    return { step, slowdown, bodiesAround };
+  }
+
+  // src/physics/mound.ts
+  var CELLS_PER_BODY = 3;
+  var BODY_PART_SPACING = 0.5;
+  var CLIMB_HEIGHT = 0.25;
+  var ELEVATED = 0.05;
+  var NEUTRAL_MASS = 70;
+  var NEIGHBOURS = [-1, 1, -1, 0, -1, -1, 0, -1, 0, 1, 1, -1, 1, 0, 1, 1];
+  var BODY_IDENTITY_SCALE = 1e6;
+  function createMound(ctx, extraBodies, height) {
+    const { store, grid } = ctx;
+    const options = ctx.options.mound;
+    const balance = ctx.options.balance;
+    const cellCount = grid.n * grid.n;
+    const touched = new Int32Array((store.capacity + extraBodies) * CELLS_PER_BODY * 2);
+    let touchedCount = 0;
+    const entryCapacity = (store.capacity + extraBodies) * CELLS_PER_BODY;
+    const entries = { count: 0, cell: new Int32Array(entryCapacity), thickness: new Uint16Array(entryCapacity), identity: new Uint32Array(entryCapacity), agent: new Int32Array(entryCapacity) };
+    const standMass = new Float32Array(cellCount);
+    const standTouched = new Int32Array(store.capacity);
+    let standTouchedCount = 0;
+    const maxMillimetres = Math.round(options.maxHeight * 1e3);
+    const cells = [0, 0, 0];
+    const cellsOfBody = (x, z, yaw) => {
+      const sin = Math.sin(yaw);
+      const cos = Math.cos(yaw);
+      for (let part2 = 0; part2 < CELLS_PER_BODY; part2++) {
+        const offset = (part2 - 1) * BODY_PART_SPACING;
+        cells[part2] = grid.cellOf(x + sin * offset, z + cos * offset);
+      }
+    };
+    const addBody = (x, z, yaw, millimetres, identity, agent) => {
+      cellsOfBody(x, z, yaw);
+      for (const cell of cells) {
+        if (cell < 0) continue;
+        if (height[cell] === 0) touched[touchedCount++] = cell;
+        height[cell] += millimetres;
+        const index = entries.count++;
+        entries.cell[index] = cell;
+        entries.thickness[index] = millimetres;
+        entries.identity[index] = identity;
+        entries.agent[index] = agent;
+      }
+    };
+    const sumBodies = () => {
+      for (let k = 0; k < touchedCount; k++) height[touched[k]] = 0;
+      touchedCount = 0;
+      entries.count = 0;
+      for (let i = 0; i < store.n; i++) {
+        const state = store.balance[i];
+        if (store.band[i] !== 0 || state !== BALANCE.FALLEN && state !== BALANCE.GETTING_UP) continue;
+        addBody(store.x[i], store.z[i], store.renderYaw[i], Math.round(options.bodyThickness * store.build[i] * 1e3), store.identity[i], i);
+      }
+      const reach = options.corpseRadius * options.corpseRadius;
+      for (const { data } of ctx.corpseList()) {
+        if ((data.x - ctx.centre.x) ** 2 + (data.z - ctx.centre.z) ** 2 > reach) continue;
+        addBody(data.x, data.z, data.yaw, Math.round(options.corpseThickness * data.build * 1e3), mix32(Math.floor(data.seed * BODY_IDENTITY_SCALE)), -1);
+      }
+    };
+    const isOpenCell = (cell) => grid.occ[cell] === 0 || grid.occ[cell] === 3;
+    const lowestNeighbour = (cell, millimetres) => {
+      const cx = cell % grid.n;
+      const cz = Math.floor(cell / grid.n);
+      let best = -1;
+      for (let k = 0; k < NEIGHBOURS.length; k += 2) {
+        const nx = cx + NEIGHBOURS[k];
+        const nz = cz + NEIGHBOURS[k + 1];
+        if (nx < 0 || nz < 0 || nx >= grid.n || nz >= grid.n) continue;
+        const neighbour = nz * grid.n + nx;
+        if (!isOpenCell(neighbour) || height[neighbour] + millimetres > maxMillimetres) continue;
+        if (best < 0 || height[neighbour] < height[best] || height[neighbour] === height[best] && neighbour < best) best = neighbour;
+      }
+      return best;
+    };
+    const slideEntry = (index) => {
+      const cell = entries.cell[index];
+      const target = lowestNeighbour(cell, entries.thickness[index]);
+      if (target < 0) return;
+      if (height[target] === 0) touched[touchedCount++] = target;
+      height[target] += entries.thickness[index];
+      height[cell] -= entries.thickness[index];
+      entries.cell[index] = target;
+      const agent = entries.agent[index];
+      if (agent < 0) return;
+      store.x[agent] += (target % grid.n - cell % grid.n) * grid.cell;
+      store.z[agent] += (Math.floor(target / grid.n) - Math.floor(cell / grid.n)) * grid.cell;
+    };
+    const capHeights = () => {
+      let over = false;
+      for (let k = 0; k < touchedCount && !over; k++) over = height[touched[k]] > maxMillimetres;
+      if (!over) return;
+      const order = Array.from({ length: entries.count }, (_, index) => index).sort((a, b) => entries.cell[a] - entries.cell[b] || entries.identity[a] - entries.identity[b] || a - b);
+      let current = -1;
+      let running = 0;
+      for (const index of order) {
+        const cell = entries.cell[index];
+        if (cell !== current) {
+          current = cell;
+          running = 0;
+        }
+        if (height[cell] <= maxMillimetres) continue;
+        if (running + entries.thickness[index] <= maxMillimetres) running += entries.thickness[index];
+        else slideEntry(index);
+      }
+      for (let k = 0; k < touchedCount; k++) if (height[touched[k]] > maxMillimetres) height[touched[k]] = maxMillimetres;
+    };
+    const seatFallen = () => {
+      let top = 0;
+      for (let k = 0; k < touchedCount; k++) top = Math.max(top, height[touched[k]]);
+      ctx.stats.moundMax = top / 1e3;
+      for (let i = 0; i < store.n; i++) {
+        const state = store.balance[i];
+        if (store.band[i] !== 0 || state !== BALANCE.FALLEN && state !== BALANCE.GETTING_UP) continue;
+        const cell = grid.cellOf(store.x[i], store.z[i]);
+        if (cell >= 0) store.y[i] = Math.max(0, height[cell] / 1e3 - options.bodyThickness * store.build[i]);
+      }
+    };
+    const weighStanding = () => {
+      for (let k = 0; k < standTouchedCount; k++) standMass[standTouched[k]] = 0;
+      standTouchedCount = 0;
+      let climbers = 0;
+      for (let i = 0; i < store.n; i++) {
+        const state = store.balance[i];
+        if (store.band[i] !== 0 || store.state[i] === STATE.PILE_STEP || state !== BALANCE.STANDING && state !== BALANCE.STAGGERING) continue;
+        if (store.y[i] >= CLIMB_HEIGHT) climbers++;
+        if (store.y[i] <= ELEVATED) continue;
+        const cell = grid.cellOf(store.x[i], store.z[i]);
+        if (cell < 0) continue;
+        if (standMass[cell] === 0) standTouched[standTouchedCount++] = cell;
+        standMass[cell] += store.mass[i];
+      }
+      ctx.stats.climbers = climbers;
+    };
+    const trample = () => {
+      if (!standTouchedCount) return;
+      for (let i = 0; i < store.n; i++) {
+        const state = store.balance[i];
+        if (store.band[i] !== 0 || state !== BALANCE.FALLEN && state !== BALANCE.GETTING_UP) continue;
+        const mass = weightOn(i);
+        if (!mass) continue;
+        store.hp[i] -= balance.trampleDps * (mass / NEUTRAL_MASS) * ctx.h;
+        if (store.hp[i] <= 0) ctx.deferKill(i);
+      }
+    };
+    const step = () => {
+      sumBodies();
+      capHeights();
+      seatFallen();
+      weighStanding();
+      trample();
+    };
+    const weightOn = (i) => {
+      cellsOfBody(store.x[i], store.z[i], store.renderYaw[i]);
+      let mass = 0;
+      for (const cell of cells) if (cell >= 0) mass += standMass[cell];
+      return mass;
+    };
+    return { height, step, weightOn };
+  }
+
+  // src/physics/offload/default-worker.ts
+  var import_meta = {};
+  function createDefaultWorkerFactory() {
+    if (typeof Worker === "undefined") return null;
+    let url;
+    try {
+      url = new URL("./physics-worker.js", import_meta.url);
+    } catch {
+      return null;
+    }
+    return () => {
+      const worker = new Worker(url, { type: "module" });
+      return {
+        postMessage: (message, transfer) => worker.postMessage(message, transfer ?? []),
+        onMessage: (listener) => worker.addEventListener("message", (event) => listener(event.data)),
+        terminate: () => worker.terminate()
+      };
+    };
+  }
+
+  // src/physics/offload/frame.ts
+  var F32_INPUTS = ["x", "z", "y", "vx", "vz", "pushX", "pushZ", "mass", "build", "aimX", "aimZ", "driveFactor", "fieldPrev"];
+  var U8_INPUTS = ["band", "balance", "state", "type"];
+  var F32_OUTPUTS = ["deltaX", "deltaZ", "deltaPushX", "deltaPushZ", "deltaVx", "deltaVz", "field", "shove", "doorLoad"];
+  var HEADER = { n: 0, h: 1, playerOn: 2, playerX: 3, playerZ: 4, contacts: 5, maxOverlap: 6, overlapSum: 7, playerLoad: 8, drivers: 9, fieldMax: 10, size: 16 };
+  var align8 = (bytes) => Math.ceil(bytes / 8) * 8;
+  var frameBytes = ({ capacity, cells }) => HEADER.size * 8 + (F32_INPUTS.length + F32_OUTPUTS.length + 2) * align8(capacity * 4) + U8_INPUTS.length * align8(capacity) + align8(cells);
+  function createFrame(buffer, shape) {
+    const { capacity, cells } = shape;
+    let offset = 0;
+    const take = (make, bytesPerElement, length) => {
+      const view = make(buffer, offset, length);
+      offset += align8(length * bytesPerElement);
+      return view;
+    };
+    const f64 = (b, o, l) => new Float64Array(b, o, l);
+    const f32 = (b, o, l) => new Float32Array(b, o, l);
+    const u8 = (b, o, l) => new Uint8Array(b, o, l);
+    const header = take(f64, 8, HEADER.size);
+    const floats = {};
+    for (const key of [...F32_INPUTS, ...F32_OUTPUTS]) floats[key] = take(f32, 4, capacity);
+    const identity = take((b, o, l) => new Uint32Array(b, o, l), 4, capacity);
+    const doorCell = take((b, o, l) => new Int32Array(b, o, l), 4, capacity);
+    const bytes = {};
+    for (const key of U8_INPUTS) bytes[key] = take(u8, 1, capacity);
+    const occ = take(u8, 1, cells);
+    return { header, f32: floats, u8: bytes, identity, doorCell, occ };
+  }
+  var INPUT_KEYS = { f32: F32_INPUTS, u8: U8_INPUTS };
+
+  // src/physics/offload/offload.ts
+  var isOpen2 = (grid, x, z) => {
+    const cell = grid.cellOf(x, z);
+    return cell >= 0 && (grid.occ[cell] === 0 || grid.occ[cell] === 3);
+  };
+  function writeSnapshot(frame, source, h, player) {
+    const { store, grid } = source;
+    const n = store.n;
+    for (const key of INPUT_KEYS.f32) frame.f32[key].set(store[key].subarray(0, n));
+    for (const key of INPUT_KEYS.u8) frame.u8[key].set(store[key].subarray(0, n));
+    frame.identity.set(store.identity.subarray(0, n));
+    frame.occ.set(grid.occ);
+    frame.header[HEADER.n] = n;
+    frame.header[HEADER.h] = h;
+    frame.header[HEADER.playerOn] = player ? 1 : 0;
+    frame.header[HEADER.playerX] = player?.x ?? 0;
+    frame.header[HEADER.playerZ] = player?.z ?? 0;
+  }
+  function createOffload(runner, host, latency = 1) {
+    const { store, grid, stats, contact } = host;
+    const queue = [];
+    const spare = Array.from({ length: latency }, () => ({ count: 0, origin: null, originBuffer: new Int32Array(store.capacity) }));
+    const result = { playerLoad: 0 };
+    const apply = (frame, pending) => {
+      const { f32, header } = frame;
+      const { origin, count } = pending;
+      for (let agent = 0; agent < store.n; agent++) {
+        const from = origin ? origin[agent] : agent < count ? agent : -1;
+        if (from < 0) {
+          contact.workspace.shove[agent] = 0;
+          continue;
+        }
+        const dx = f32.deltaX[from];
+        const dz = f32.deltaZ[from];
+        if (dx !== 0 && isOpen2(grid, store.x[agent] + dx, store.z[agent])) store.x[agent] += dx;
+        if (dz !== 0 && isOpen2(grid, store.x[agent], store.z[agent] + dz)) store.z[agent] += dz;
+        store.pushX[agent] += f32.deltaPushX[from];
+        store.pushZ[agent] += f32.deltaPushZ[from];
+        store.vx[agent] += f32.deltaVx[from];
+        store.vz[agent] += f32.deltaVz[from];
+        store.field[agent] = f32.field[from];
+        store.fieldPrev[agent] = f32.field[from];
+        contact.workspace.shove[agent] = f32.shove[from];
+        const cell = frame.doorCell[from];
+        if (cell >= 0) host.addDoorLoad(cell, f32.doorLoad[from]);
+      }
+      stats.contacts = header[HEADER.contacts];
+      stats.maxOverlap = header[HEADER.maxOverlap];
+      stats.meanOverlap = header[HEADER.contacts] ? header[HEADER.overlapSum] / header[HEADER.contacts] : 0;
+      stats.fieldMax = header[HEADER.fieldMax];
+      result.playerLoad = header[HEADER.playerLoad];
+    };
+    const step = (h, player) => {
+      result.playerLoad = 0;
+      if (queue.length >= latency) {
+        const frame2 = runner.settle();
+        if (frame2) {
+          const pending = queue.shift();
+          apply(frame2, pending);
+          pending.origin = null;
+          spare.push(pending);
+        }
+      }
+      const frame = runner.frame();
+      if (frame && spare.length) {
+        writeSnapshot(frame, { store, grid }, h, player);
+        runner.submit();
+        const pending = spare.shift();
+        pending.count = store.n;
+        queue.push(pending);
+      }
+      return result;
+    };
+    const remap = (removed, moved) => {
+      queue.forEach((pending) => {
+        if (!pending.origin) {
+          pending.origin = pending.originBuffer.fill(-1);
+          for (let agent = 0; agent < pending.count; agent++) pending.origin[agent] = agent;
+        }
+        pending.origin[removed] = removed === moved ? -1 : pending.origin[moved];
+        if (removed !== moved) pending.origin[moved] = -1;
+      });
+    };
+    return { step, remap, dispose: () => runner.dispose() };
+  }
+
+  // src/physics/pressure.ts
+  var TOUCH_SLACK = 0.08;
+  var WALL_PROBE = 0.12;
+  var PLAYER_REACH = 1.3;
+  var PLAYER_RADIUS_SQUARED = PLAYER_REACH * PLAYER_REACH;
+  var createPressureWorkspace = (capacity, pairCapacity) => ({
+    weightSum: new Float32Array(capacity),
+    pressing: new Uint8Array(capacity),
+    wallKind: new Uint8Array(capacity),
+    wallDoor: new Int32Array(capacity),
+    playerWeight: new Float32Array(capacity),
+    cutExcess: new Float32Array(capacity),
+    cutX: new Float32Array(capacity),
+    cutZ: new Float32Array(capacity),
+    pairWeightForward: new Float32Array(pairCapacity),
+    pairWeightBackward: new Float32Array(pairCapacity),
+    canPress: new Uint8Array(capacity)
+  });
+  var isPressing = (store, i) => takesPartInContact(store, i) && (store.balance[i] === BALANCE.STANDING || store.balance[i] === BALANCE.STAGGERING);
+  function readPressing(view, workspace) {
+    for (let i = 0; i < view.n; i++) workspace.canPress[i] = isPressing(view.store, i) ? 1 : 0;
+  }
+  var frontWeight = (alignment, cone) => alignment > cone ? (alignment - cone) / (1 - cone) : 0;
+  var hasAim = (store, i) => store.aimX[i] !== 0 || store.aimZ[i] !== 0;
+  function noteCut(store, workspace, i, j, nx, nz) {
+    const excess = (store.vx[i] - store.vx[j]) * nx + (store.vz[i] - store.vz[j]) * nz;
+    if (excess <= workspace.cutExcess[i]) return;
+    workspace.cutExcess[i] = excess;
+    workspace.cutX[i] = nx;
+    workspace.cutZ[i] = nz;
+  }
+  function weighPairs(view, workspace, params) {
+    const { store } = view;
+    for (let p = 0; p < view.workspace.pairCount; p++) {
+      workspace.pairWeightForward[p] = 0;
+      workspace.pairWeightBackward[p] = 0;
+      const i = view.workspace.pairI[p];
+      const j = view.workspace.pairJ[p];
+      if (!workspace.canPress[i] || !workspace.canPress[j]) continue;
+      const ex = store.x[j] - store.x[i];
+      const ez = store.z[j] - store.z[i];
+      const distance = Math.sqrt(ex * ex + ez * ez);
+      if (distance < 1e-6 || distance > (store.build[i] + store.build[j]) * params.radius + TOUCH_SLACK) continue;
+      const nx = ex / distance;
+      const nz = ez / distance;
+      const forward = frontWeight(store.aimX[i] * nx + store.aimZ[i] * nz, params.frontCone);
+      const backward = frontWeight(-(store.aimX[j] * nx + store.aimZ[j] * nz), params.frontCone);
+      if (forward > 0) {
+        workspace.pressing[i] = 1;
+        noteCut(store, workspace, i, j, nx, nz);
+      }
+      if (backward > 0) {
+        workspace.pressing[j] = 1;
+        noteCut(store, workspace, j, i, -nx, -nz);
+      }
+      if (forward > 0 && backward > 0) continue;
+      workspace.pairWeightForward[p] = forward;
+      workspace.pairWeightBackward[p] = backward;
+      workspace.weightSum[i] += forward;
+      workspace.weightSum[j] += backward;
+    }
+  }
+  function weighWalls(view, workspace, params, doorAt) {
+    const { store, grid } = view;
+    for (let i = 0; i < view.n; i++) {
+      if (!workspace.canPress[i] || !hasAim(store, i)) continue;
+      const reach = store.build[i] * params.radius + WALL_PROBE;
+      const cell = grid.cellOf(store.x[i] + store.aimX[i] * reach, store.z[i] + store.aimZ[i] * reach);
+      if (cell >= 0 && (grid.occ[cell] === 0 || grid.occ[cell] === 3)) continue;
+      workspace.wallKind[i] = 1;
+      workspace.wallDoor[i] = cell >= 0 && grid.occ[cell] === 5 ? doorAt(cell) : -1;
+      workspace.pressing[i] = 1;
+      workspace.weightSum[i] += 1;
+    }
+  }
+  function weighPlayer(view, workspace, params, player) {
+    const { store } = view;
+    for (let i = 0; i < view.n; i++) {
+      if (!workspace.canPress[i]) continue;
+      const ex = player.x - store.x[i];
+      const ez = player.z - store.z[i];
+      const squared = ex * ex + ez * ez;
+      if (squared > PLAYER_RADIUS_SQUARED || squared < 1e-6) continue;
+      const distance = Math.sqrt(squared);
+      const weight = hasAim(store, i) ? frontWeight((store.aimX[i] * ex + store.aimZ[i] * ez) / distance, params.frontCone) : 1;
+      workspace.playerWeight[i] = weight;
+      if (weight > 0) workspace.pressing[i] = 1;
+      workspace.weightSum[i] += weight;
+    }
+  }
+  function clearWorkspace(view, workspace) {
+    const { store } = view;
+    for (let i = 0; i < view.n; i++) {
+      workspace.weightSum[i] = 0;
+      workspace.pressing[i] = 0;
+      workspace.wallKind[i] = 0;
+      workspace.playerWeight[i] = 0;
+      workspace.cutExcess[i] = 0;
+      store.field[i] = 0;
+    }
+  }
+  function ownDrive(store, context, workspace, i) {
+    if (!hasAim(store, i) || !workspace.pressing[i]) return 0;
+    return context.driveForceOfType[store.type[i]] * store.driveFactor[i];
+  }
+  function spreadField(view, workspace, params, context, out) {
+    const { store } = view;
+    for (let i = 0; i < view.n; i++) {
+      if (!workspace.canPress[i]) continue;
+      store.field[i] = ownDrive(store, context, workspace, i);
+      if (store.field[i] > 0) out.drivers++;
+    }
+    for (let p = 0; p < view.workspace.pairCount; p++) {
+      const i = view.workspace.pairI[p];
+      const j = view.workspace.pairJ[p];
+      const forward = workspace.pairWeightForward[p];
+      const backward = workspace.pairWeightBackward[p];
+      if (forward > 0) store.field[j] += params.transmission * store.fieldPrev[i] * forward * forward / workspace.weightSum[i];
+      if (backward > 0) store.field[i] += params.transmission * store.fieldPrev[j] * backward * backward / workspace.weightSum[j];
+    }
+    for (let i = 0; i < view.n; i++) {
+      if (!workspace.canPress[i]) continue;
+      const passed = params.transmission * store.fieldPrev[i] / (workspace.weightSum[i] || 1);
+      if (workspace.wallKind[i] && workspace.wallDoor[i] >= 0) {
+        if (context.doorOut) {
+          context.doorOut.cell[i] = workspace.wallDoor[i];
+          context.doorOut.load[i] = passed * params.h;
+        } else context.doorLoad[workspace.wallDoor[i]] += passed * params.h;
+      }
+      if (workspace.playerWeight[i] > 0) out.playerLoad += passed * workspace.playerWeight[i] * workspace.playerWeight[i];
+      if (store.field[i] > params.cap) store.field[i] = params.cap;
+    }
+  }
+  function applyCuts(view, workspace) {
+    const { store } = view;
+    for (let i = 0; i < view.n; i++) {
+      const excess = workspace.cutExcess[i];
+      if (excess <= 0) continue;
+      store.vx[i] -= excess * workspace.cutX[i];
+      store.vz[i] -= excess * workspace.cutZ[i];
+    }
+  }
+  function pressureStep(view, workspace, params, context, out) {
+    out.playerLoad = 0;
+    out.drivers = 0;
+    clearWorkspace(view, workspace);
+    readPressing(view, workspace);
+    weighPairs(view, workspace, params);
+    weighWalls(view, workspace, params, context.doorAt);
+    if (context.player) weighPlayer(view, workspace, params, context.player);
+    spreadField(view, workspace, params, context, out);
+    applyCuts(view, workspace);
+    for (let i = 0; i < view.n; i++) view.store.fieldPrev[i] = view.store.field[i];
+  }
+
+  // src/physics/offload/kernel.ts
+  var PAIRS_PER_AGENT2 = 12;
+  var STORE_KEYS = ["x", "z", "y", "vx", "vz", "pushX", "pushZ", "mass", "build", "aimX", "aimZ", "driveFactor", "fieldPrev"];
+  function createKernel(setup) {
+    const { capacity } = setup;
+    const side = Math.floor(setup.gridSize / setup.gridCell);
+    const half = setup.gridSize / 2;
+    const before = { x: new Float32Array(capacity), z: new Float32Array(capacity), pushX: new Float32Array(capacity), pushZ: new Float32Array(capacity), vx: new Float32Array(capacity), vz: new Float32Array(capacity) };
+    const driveForceOfType = Float32Array.from(setup.driveForceOfType);
+    const contactResult = { contacts: 0, maxOverlap: 0, overlapSum: 0 };
+    const pressureResult = { playerLoad: 0, drivers: 0 };
+    const workspace = setup.pressure ? createPressureWorkspace(capacity, capacity * PAIRS_PER_AGENT2) : null;
+    const cellOf = createCellOf(half, setup.gridCell, side);
+    const doorLoadUnused = new Float32Array(0);
+    const store = {};
+    const grid = { size: setup.gridSize, half, occ: new Uint8Array(0), cellOf };
+    const view = { n: 0, store, grid, workspace: createContactWorkspace(capacity, grid) };
+    const bind = (frame) => {
+      Object.assign(store, frame.u8, { identity: frame.identity, field: frame.f32.field });
+      for (const key of STORE_KEYS) store[key] = frame.f32[key];
+      grid.occ = frame.occ;
+      return view;
+    };
+    const run = (frame) => {
+      const { header } = frame;
+      const n = header[HEADER.n];
+      const contact = bind(frame);
+      contact.n = n;
+      for (let i = 0; i < n; i++) {
+        before.x[i] = frame.f32.x[i];
+        before.z[i] = frame.f32.z[i];
+        before.pushX[i] = frame.f32.pushX[i];
+        before.pushZ[i] = frame.f32.pushZ[i];
+        before.vx[i] = frame.f32.vx[i];
+        before.vz[i] = frame.f32.vz[i];
+      }
+      const h = header[HEADER.h];
+      const params = { ...setup.contact, h };
+      contactStep(contact, params, contactResult);
+      header[HEADER.contacts] = contactResult.contacts;
+      header[HEADER.maxOverlap] = contactResult.maxOverlap;
+      header[HEADER.overlapSum] = contactResult.overlapSum;
+      frame.doorCell.fill(-1, 0, n);
+      frame.f32.doorLoad.fill(0, 0, n);
+      if (workspace && setup.pressure) {
+        const player = header[HEADER.playerOn] ? { x: header[HEADER.playerX], z: header[HEADER.playerZ] } : void 0;
+        const doorOut = { cell: frame.doorCell, load: frame.f32.doorLoad };
+        pressureStep(contact, workspace, { ...setup.pressure, h, radius: setup.contact.radius }, { driveForceOfType, doorAt: (cell) => cell, doorLoad: doorLoadUnused, player, doorOut }, pressureResult);
+        let top = 0;
+        for (let i = 0; i < n; i++) top = Math.max(top, frame.f32.field[i]);
+        header[HEADER.fieldMax] = top;
+      } else header[HEADER.fieldMax] = 0;
+      header[HEADER.playerLoad] = pressureResult.playerLoad;
+      header[HEADER.drivers] = pressureResult.drivers;
+      const { f32 } = frame;
+      for (let i = 0; i < n; i++) {
+        f32.deltaX[i] = f32.x[i] - before.x[i];
+        f32.deltaZ[i] = f32.z[i] - before.z[i];
+        f32.deltaPushX[i] = f32.pushX[i] - before.pushX[i];
+        f32.deltaPushZ[i] = f32.pushZ[i] - before.pushZ[i];
+        f32.deltaVx[i] = f32.vx[i] - before.vx[i];
+        f32.deltaVz[i] = f32.vz[i] - before.vz[i];
+        f32.shove[i] = contact.workspace.shove[i];
+      }
+    };
+    return { run };
+  }
+
+  // src/physics/offload/worker-host.ts
+  var CONTROL = { IDLE: 0, SUBMITTED: 1, DONE: 2, STOP: 3 };
+  function attachPhysicsWorker(port) {
+    let kernel = null;
+    let shape = null;
+    port.onMessage((data) => {
+      const message = data;
+      if (message.type === "init") {
+        kernel = createKernel(message.setup);
+        shape = message.shape;
+        if (message.frames && message.control) runShared(kernel, message.frames.map((buffer) => createFrame(buffer, message.shape)), new Int32Array(message.control));
+        return;
+      }
+      if (!kernel || !shape) return;
+      const frame = createFrame(message.buffer, shape);
+      kernel.run(frame);
+      port.postMessage({ type: "done", buffer: message.buffer }, [message.buffer]);
+    });
+  }
+  function runShared(kernel, frames, control) {
+    for (let turn = 0; ; turn++) {
+      const slot = turn % frames.length;
+      for (; ; ) {
+        const state = Atomics.load(control, slot);
+        if (state === CONTROL.STOP) return;
+        if (state === CONTROL.SUBMITTED) break;
+        Atomics.wait(control, slot, state);
+      }
+      kernel.run(frames[slot]);
+      Atomics.store(control, slot, CONTROL.DONE);
+      Atomics.notify(control, slot);
+    }
+  }
+
+  // src/physics/offload/runner.ts
+  var WAIT_LIMIT_MS = 5e3;
+  var canBlock = (() => {
+    try {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 1, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  var isSharedAvailable = () => typeof SharedArrayBuffer !== "undefined" && globalThis.crossOriginIsolated !== false;
+  function createInlineRunner(setup, shape, slots = 1) {
+    const kernel = createKernel(setup);
+    const frames = Array.from({ length: slots }, () => createFrame(new ArrayBuffer(frameBytes(shape)), shape));
+    let submitted = 0;
+    let settled = 0;
+    const runner = {
+      transport: "inline",
+      get inFlight() {
+        return submitted - settled;
+      },
+      frame: () => submitted - settled < slots ? frames[submitted % slots] : null,
+      submit: () => kernel.run(frames[submitted++ % slots]),
+      settle: () => submitted > settled ? frames[settled++ % slots] : null,
+      dispose: () => void 0
+    };
+    return runner;
+  }
+  function createSharedRunner(setup, shape, factory, slots = 1) {
+    const buffers = Array.from({ length: slots }, () => new SharedArrayBuffer(frameBytes(shape)));
+    const control = new Int32Array(new SharedArrayBuffer(4 * slots));
+    const frames = buffers.map((buffer) => createFrame(buffer, shape));
+    const worker = factory();
+    worker.postMessage({ type: "init", setup, shape, frames: buffers, control: control.buffer });
+    let submitted = 0;
+    let settled = 0;
+    return {
+      transport: "shared",
+      get inFlight() {
+        return submitted - settled;
+      },
+      frame: () => submitted - settled < slots ? frames[submitted % slots] : null,
+      submit: () => {
+        const slot = submitted++ % slots;
+        Atomics.store(control, slot, CONTROL.SUBMITTED);
+        Atomics.notify(control, slot);
+      },
+      settle: () => {
+        if (submitted === settled) return null;
+        const slot = settled++ % slots;
+        const started = Date.now();
+        while (Atomics.load(control, slot) !== CONTROL.DONE) {
+          if (Date.now() - started > WAIT_LIMIT_MS) throw new Error("crowd physics worker did not answer");
+          if (canBlock) Atomics.wait(control, slot, CONTROL.SUBMITTED, 50);
+        }
+        Atomics.store(control, slot, CONTROL.IDLE);
+        return frames[slot];
+      },
+      dispose: () => {
+        for (let slot = 0; slot < slots; slot++) {
+          Atomics.store(control, slot, CONTROL.STOP);
+          Atomics.notify(control, slot);
+        }
+        worker.terminate();
+      }
+    };
+  }
+  function createTransferRunner(setup, shape, factory, slots = 1) {
+    const worker = factory();
+    const free = Array.from({ length: slots }, () => new ArrayBuffer(frameBytes(shape)));
+    const done = [];
+    const views = /* @__PURE__ */ new WeakMap();
+    const viewOf = (buffer) => {
+      let view = views.get(buffer);
+      if (!view) views.set(buffer, view = createFrame(buffer, shape));
+      return view;
+    };
+    let inFlight = 0;
+    worker.postMessage({ type: "init", setup, shape });
+    worker.onMessage((data) => {
+      const message = data;
+      if (message.type === "done") done.push(message.buffer);
+    });
+    return {
+      transport: "transfer",
+      get inFlight() {
+        return inFlight;
+      },
+      frame: () => free.length ? viewOf(free[0]) : null,
+      submit: () => {
+        const buffer = free.shift();
+        if (!buffer) return;
+        worker.postMessage({ type: "frame", buffer }, [buffer]);
+        inFlight++;
+      },
+      settle: () => {
+        const buffer = done.shift();
+        if (!buffer) return null;
+        inFlight--;
+        free.push(buffer);
+        return viewOf(buffer);
+      },
+      dispose: () => worker.terminate()
+    };
+  }
+
+  // src/physics/player-pressure.ts
+  var KNOCK_SECONDS = 1.5;
+  var KNOCK_COOLDOWN = 2;
+  var CRUSH_BLOW_EVERY = 0.25;
+  function createPlayerPressure(ctx) {
+    const options = ctx.options.playerPressure;
+    const tau = ctx.options.balance?.pressureTau ?? 0.3;
+    let knockCooldown = 0;
+    let crushed = 0;
+    let crushClock = 0;
+    const crush = (excess) => {
+      crushed += options.crushDamagePerSecond * excess * ctx.h;
+      crushClock += ctx.h;
+      if (crushClock < CRUSH_BLOW_EVERY) return;
+      crushClock = 0;
+      if (crushed <= 0) return;
+      ctx.target()?.hurt(crushed);
+      crushed = 0;
+    };
+    const step = (load) => {
+      ctx.stats.playerPressure += (load - ctx.stats.playerPressure) * (1 - Math.exp(-ctx.h / tau));
+      if (!options.enabled) return;
+      const target = ctx.target();
+      knockCooldown = Math.max(0, knockCooldown - ctx.h);
+      if (!target || !target.state.alive || ctx.stats.playerPressure <= options.knockThreshold) {
+        crushed = 0;
+        return;
+      }
+      if (knockCooldown === 0) {
+        target.knock(KNOCK_SECONDS);
+        knockCooldown = KNOCK_COOLDOWN;
+      }
+      crush(ctx.stats.playerPressure / options.knockThreshold - 1);
+    };
+    return { step };
+  }
+
+  // src/physics/thrown.ts
+  var FREE_SLOT = -2;
+  var CARRIED_BODY = -1;
+  var MAX_SPIN = 8;
+  var SWEEP_DISTANCE = 0.25;
+  var LANDING_DAMAGE_SPEED = 6;
+  var CENTRE_HEIGHT2 = 1;
+  var MAX_POOL = 127;
+  var createThrownPool = (size) => {
+    const f32 = () => new Float32Array(size);
+    const pool = {
+      size,
+      agent: new Int32Array(size).fill(FREE_SLOT),
+      identity: new Uint32Array(size),
+      corpse: Array.from({ length: size }, () => null),
+      x: f32(),
+      y: f32(),
+      z: f32(),
+      prevX: f32(),
+      prevY: f32(),
+      prevZ: f32(),
+      vx: f32(),
+      vy: f32(),
+      vz: f32(),
+      pitch: f32(),
+      roll: f32(),
+      spinPitch: f32(),
+      spinRoll: f32(),
+      active: () => pool.agent.reduce((count, agent) => count + (agent === FREE_SLOT ? 0 : 1), 0)
+    };
+    return pool;
+  };
+  var byFastest = (a, b, identityOf2) => b.speed - a.speed || identityOf2(a.index) - identityOf2(b.index);
+  var byNearest = (a, b, identityOf2) => a.distance - b.distance || identityOf2(a.index) - identityOf2(b.index);
+  function chooseCandidates(candidates, free, options, identityOf2) {
+    if (candidates.length <= free) return candidates;
+    if (options.priority === "fastest") return candidates.sort((a, b) => byFastest(a, b, identityOf2)).slice(0, free);
+    if (options.priority === "nearest") return candidates.sort((a, b) => byNearest(a, b, identityOf2)).slice(0, free);
+    const fast = Math.round(free * options.mixedRatio);
+    const sorted = candidates.sort((a, b) => byFastest(a, b, identityOf2));
+    const rest = sorted.slice(fast).sort((a, b) => byNearest(a, b, identityOf2));
+    return [...sorted.slice(0, fast), ...rest.slice(0, free - fast)];
+  }
+  function createThrown(ctx) {
+    const { store, grid } = ctx;
+    const options = ctx.options.thrown;
+    const size = Math.min(MAX_POOL, options.pool);
+    const pool = createThrownPool(size);
+    const identityOf2 = (i) => store.identity[i];
+    const assign = (candidates) => {
+      let free = 0;
+      for (let slot2 = 0; slot2 < size; slot2++) if (pool.agent[slot2] === FREE_SLOT) free++;
+      const chosen = chooseCandidates(candidates, free, options, identityOf2);
+      let slot = 0;
+      for (const candidate of chosen) {
+        while (pool.agent[slot] !== FREE_SLOT) slot++;
+        const i = candidate.index;
+        pool.agent[slot] = i;
+        pool.identity[slot] = store.identity[i];
+        pool.corpse[slot] = null;
+        pool.x[slot] = pool.prevX[slot] = store.x[i];
+        pool.y[slot] = pool.prevY[slot] = store.y[i] + CENTRE_HEIGHT2 * store.height[i];
+        pool.z[slot] = pool.prevZ[slot] = store.z[i];
+        pool.vx[slot] = candidate.vx;
+        pool.vy[slot] = candidate.vy;
+        pool.vz[slot] = candidate.vz;
+        pool.pitch[slot] = pool.roll[slot] = 0;
+        pool.spinPitch[slot] = (unit(store.identity[i], ctx.step, SALT.SPIN) * 2 - 1) * MAX_SPIN;
+        pool.spinRoll[slot] = (unit(store.identity[i], ctx.step, SALT.SPIN + 1) * 2 - 1) * MAX_SPIN;
+        if (store.state[i] === STATE.PILE_STEP) ctx.releasePileStep(i);
+        store.balance[i] = BALANCE.THROWN;
+        store.thrown[i] = slot;
+        store.vx[i] = store.vz[i] = store.pushX[i] = store.pushZ[i] = 0;
+        store.aimX[i] = store.aimZ[i] = 0;
+      }
+      return chosen.length;
+    };
+    const remap = (removed, moved) => {
+      var _a;
+      for (let slot = 0; slot < size; slot++) {
+        const agent = pool.agent[slot];
+        if (agent === removed) {
+          (_a = pool.corpse)[slot] ?? (_a[slot] = ctx.corpseOf(removed, unit(pool.identity[slot], ctx.step, SALT.CORPSE) * 10));
+          pool.agent[slot] = CARRIED_BODY;
+        } else if (agent === moved && moved !== removed) pool.agent[slot] = removed;
+      }
+    };
+    const sweepWall = (x0, z0, x1, z1, y) => {
+      const cell = grid.cell;
+      let gx = Math.floor((x0 + grid.half) / cell);
+      let gz = Math.floor((z0 + grid.half) / cell);
+      const dx = x1 - x0;
+      const dz = z1 - z0;
+      const stepX = dx > 0 ? 1 : -1;
+      const stepZ = dz > 0 ? 1 : -1;
+      const deltaX = dx === 0 ? Infinity : Math.abs(cell / dx);
+      const deltaZ = dz === 0 ? Infinity : Math.abs(cell / dz);
+      let nextX = dx === 0 ? Infinity : ((dx > 0 ? gx + 1 : gx) * cell - grid.half - x0) / dx;
+      let nextZ = dz === 0 ? Infinity : ((dz > 0 ? gz + 1 : gz) * cell - grid.half - z0) / dz;
+      let t = 0;
+      while (Math.min(nextX, nextZ) <= 1) {
+        if (nextX < nextZ) {
+          t = nextX;
+          nextX += deltaX;
+          gx += stepX;
+        } else {
+          t = nextZ;
+          nextZ += deltaZ;
+          gz += stepZ;
+        }
+        const hitX = x0 + dx * t;
+        const hitZ = z0 + dz * t;
+        if (grid.solidAt(hitX + Math.sign(dx) * 1e-4, hitZ + Math.sign(dz) * 1e-4, y)) return { x: x0 + dx * Math.max(0, t - 1e-3), z: z0 + dz * Math.max(0, t - 1e-3) };
+      }
+      return void 0;
+    };
+    const fly = (slot) => {
+      pool.prevX[slot] = pool.x[slot];
+      pool.prevY[slot] = pool.y[slot];
+      pool.prevZ[slot] = pool.z[slot];
+      pool.vy[slot] -= ctx.gravity * ctx.h;
+      pool.pitch[slot] += pool.spinPitch[slot] * ctx.h;
+      pool.roll[slot] += pool.spinRoll[slot] * ctx.h;
+      const nx = pool.x[slot] + pool.vx[slot] * ctx.h;
+      const nz = pool.z[slot] + pool.vz[slot] * ctx.h;
+      const ny = pool.y[slot] + pool.vy[slot] * ctx.h;
+      const speed = Math.hypot(pool.vx[slot], pool.vy[slot], pool.vz[slot]);
+      const wall = speed * ctx.h > SWEEP_DISTANCE ? sweepWall(pool.x[slot], pool.z[slot], nx, nz, ny) : grid.solidAt(nx, nz, ny) ? { x: pool.x[slot], z: pool.z[slot] } : void 0;
+      pool.x[slot] = wall ? wall.x : nx;
+      pool.z[slot] = wall ? wall.z : nz;
+      pool.y[slot] = ny;
+      if (wall) pool.vx[slot] = pool.vz[slot] = 0;
+    };
+    const massOf = (slot) => {
+      const agent = pool.agent[slot];
+      if (agent >= 0) return store.mass[agent];
+      const body = pool.corpse[slot];
+      return ctx.options.contact.baseMass * body.height * body.build * body.build;
+    };
+    const knockNeighbours = (contact, balance, slot) => {
+      const side = Math.floor(grid.size);
+      const x = pool.x[slot];
+      const z = pool.z[slot];
+      const hx = Math.floor(x + grid.half);
+      const hz = Math.floor(z + grid.half);
+      const mass = massOf(slot);
+      const speed = Math.hypot(pool.vx[slot], pool.vz[slot]);
+      const reach = options.landingRadius * options.landingRadius;
+      for (let oz = -1; oz <= 1; oz++)
+        for (let ox = -1; ox <= 1; ox++) {
+          if (hx + ox < 0 || hz + oz < 0 || hx + ox >= side || hz + oz >= side) continue;
+          for (let j = contact.workspace.head[(hz + oz) * side + hx + ox]; j !== -1; j = contact.workspace.next[j]) {
+            const ex = store.x[j] - x;
+            const ez = store.z[j] - z;
+            if (j === pool.agent[slot] || ex * ex + ez * ez > reach || !takesPartInContact(store, j)) continue;
+            const away = Math.hypot(ex, ez);
+            const along = away > 1e-6 ? [ex / away, ez / away] : [pool.vx[slot] / (speed || 1), pool.vz[slot] / (speed || 1)];
+            const delta = mass / (mass + store.mass[j]) * speed;
+            store.pushX[j] += delta * along[0];
+            store.pushZ[j] += delta * along[1];
+            balance.shove(j, delta, FALL_CAUSE.LANDING);
+          }
+        }
+    };
+    const land = (contact, balance, slot, ground) => {
+      knockNeighbours(contact, balance, slot);
+      const x = pool.x[slot];
+      const z = pool.z[slot];
+      ctx.emit("sound", { sound: "impact", volume: 1.2, position: [x, ground, z], distance: Math.hypot(x - ctx.centre.x, z - ctx.centre.z) });
+      ctx.emit("effect", { effect: "dust", point: [x, ground, z], color: 9075302 });
+      const agent = pool.agent[slot];
+      if (agent >= 0) {
+        store.balance[agent] = BALANCE.FALLEN;
+        store.balanceTimer[agent] = 0;
+        store.fallCause[agent] = FALL_CAUSE.BLAST;
+        store.x[agent] = x;
+        store.z[agent] = z;
+        store.y[agent] = ground;
+        store.vy[agent] = 0;
+        store.thrown[agent] = -1;
+        const amount = Math.max(0, -pool.vy[slot] - LANDING_DAMAGE_SPEED) * options.fallDamage;
+        if (amount > 0) ctx.damage(agent, { region: 1, amount, distance: 0 }, () => unit(store.identity[agent], ctx.step, SALT.JAW));
+      } else {
+        ctx.emit("effect", { effect: "blood", point: [x, ground + 0.1, z], amount: 30, died: true });
+        ctx.addCorpse({ ...pool.corpse[slot], x, z });
+      }
+      pool.agent[slot] = FREE_SLOT;
+      pool.corpse[slot] = null;
+    };
+    const step = (contact, balance) => {
+      let active = 0;
+      for (let slot = 0; slot < size; slot++) {
+        if (pool.agent[slot] === FREE_SLOT) continue;
+        fly(slot);
+        const cell = grid.cellOf(pool.x[slot], pool.z[slot]);
+        const ground = cell < 0 ? 0 : ctx.groundAt(cell, pool.y[slot]);
+        const agent = pool.agent[slot];
+        if (pool.y[slot] <= ground) {
+          land(contact, balance, slot, ground);
+          continue;
+        }
+        active++;
+        if (agent < 0) continue;
+        store.x[agent] = pool.x[slot];
+        store.z[agent] = pool.z[slot];
+        store.y[agent] = Math.max(ground, pool.y[slot] - CENTRE_HEIGHT2 * store.height[agent]);
+      }
+      ctx.stats.thrownActive = active;
+      ctx.stats.thrownPeak = Math.max(ctx.stats.thrownPeak, active);
+    };
+    return { pool, assign, step, remap };
+  }
+
+  // src/physics/engine.ts
+  var DEFAULT_DRIVE_FORCE = 250;
+  var GRAVITY_FORCE2 = 9.8;
+  var EXTRA_BODIES = 500;
+  var PAIRS_PER_AGENT3 = 12;
+  function createPhysics(base, options, stats = createPhysicsStats()) {
+    const moundOn = options.mound !== null;
+    const ctx = { ...base, options, stats, step: -1, h: 0, centre: { x: 0, z: 0 }, lastBlastStep: -1e3, moundAt: (cell) => moundOn ? base.moundHeight[cell] : 0, weightOn: () => 0 };
+    const { store, grid } = base;
+    const balance = options.balance ? createBalance(ctx) : null;
+    const thrown = options.thrown ? createThrown(ctx) : null;
+    const contact = options.contact ? createContactView(store, grid) : null;
+    const pressure = options.pressure && contact ? createPressureWorkspace(store.capacity, store.capacity * PAIRS_PER_AGENT3) : null;
+    const mound = options.mound ? createMound(ctx, Math.max(EXTRA_BODIES, base.corpsesMax), base.moundHeight) : null;
+    if (mound) ctx.weightOn = mound.weightOn;
+    const density = options.density && balance ? createDensity(ctx, options.density) : null;
+    const playerPressure = pressure ? createPlayerPressure(ctx) : null;
+    const blasts = createBlasts(ctx, { balance, thrown, pileBlast: base.pileBlast });
+    const contactResult = { contacts: 0, maxOverlap: 0, overlapSum: 0 };
+    const pressureResult = { playerLoad: 0, drivers: 0 };
+    const driveForceOfType = Float32Array.from(base.types, (type) => type.balance?.driveForce ?? DEFAULT_DRIVE_FORCE);
+    const offload = options.worker !== "off" && contact ? createOffloadFor() : null;
+    let doorLoad = new Float32Array(0);
+    let doorSince = new Float32Array(0);
+    const keepPositions = options.contact !== null || options.deterministic;
+    function createRunner() {
+      const gridCells = grid.occ.length;
+      const shape = { capacity: store.capacity, cells: gridCells };
+      const setup = { capacity: store.capacity, gridSize: grid.size, gridCell: grid.cell, contact: options.contact, pressure: options.pressure, driveForceOfType: Array.from(driveForceOfType) };
+      const transport = options.workerTransport ?? (isSharedAvailable() ? "shared" : "transfer");
+      const slots = options.workerLatency;
+      if (transport === "inline") return createInlineRunner(setup, shape, slots);
+      const factory = options.workerFactory ?? createDefaultWorkerFactory();
+      if (!factory) {
+        if (options.worker === "on") throw new Error('crowd physics: worker "on" but no Worker can be made here (give physics.workerFactory)');
+        return null;
+      }
+      return transport === "shared" ? createSharedRunner(setup, shape, factory, slots) : createTransferRunner(setup, shape, factory, slots);
+    }
+    function createOffloadFor() {
+      const runner = createRunner();
+      if (!runner) return null;
+      const host = {
+        store,
+        grid,
+        stats,
+        contact,
+        addDoorLoad: (cell, load) => {
+          const door = ctx.doors.at(cell);
+          if (door < 0) return;
+          growDoorArrays();
+          doorLoad[door] += load;
+        }
+      };
+      return createOffload(runner, host, options.workerLatency);
+    }
+    const beginStep = (h, centre) => {
+      ctx.step++;
+      ctx.h = h;
+      ctx.centre = { x: centre.x, z: centre.z };
+      if (keepPositions) {
+        for (let i = 0; i < store.n; i++) {
+          store.prevX[i] = store.x[i];
+          store.prevZ[i] = store.z[i];
+          store.prevY[i] = store.y[i];
+        }
+      }
+      blasts.resolve();
+    };
+    const hitDoors = () => {
+      for (let door = 0; door < ctx.doors.list.length; door++) {
+        if (doorLoad[door] <= 0) continue;
+        doorSince[door] += ctx.h;
+        if (doorSince[door] < ctx.attackEvery) continue;
+        ctx.doors.hit(door, doorLoad[door] * options.doorPressureDamage);
+        doorLoad[door] = 0;
+        doorSince[door] = 0;
+      }
+    };
+    const growDoorArrays = () => {
+      if (doorLoad.length >= ctx.doors.list.length) return;
+      const length = Math.max(64, ctx.doors.list.length * 2);
+      doorLoad = Float32Array.from({ length }, (_, door) => doorLoad[door] ?? 0);
+      doorSince = Float32Array.from({ length }, (_, door) => doorSince[door] ?? 0);
+    };
+    const runPressure = (view, workspace) => {
+      growDoorArrays();
+      const target = ctx.target();
+      const player = options.playerPressure.enabled && target && target.state.alive ? { x: target.state.x, z: target.state.z } : void 0;
+      pressureStep(view, workspace, { ...options.pressure, h: ctx.h, radius: options.contact.radius }, { driveForceOfType, doorAt: ctx.doors.at, doorLoad, player }, pressureResult);
+      let top = 0;
+      for (let i = 0; i < store.n; i++) top = Math.max(top, store.field[i]);
+      stats.fieldMax = top;
+      hitDoors();
+    };
+    const stepOffloaded = (running, view) => {
+      growDoorArrays();
+      const target = ctx.target();
+      const player = options.playerPressure.enabled && target && target.state.alive ? { x: target.state.x, z: target.state.z } : void 0;
+      const result = running.step(ctx.h, player);
+      pressureResult.playerLoad = result.playerLoad;
+      prepareHash(view, options.contact.radius);
+      if (pressure) hitDoors();
+    };
+    const measureLean = () => {
+      const maxPush = options.contact.maxPush;
+      for (let i = 0; i < store.n; i++) {
+        store.leanX[i] = store.pushX[i] / maxPush;
+        store.leanZ[i] = store.pushZ[i] / maxPush;
+      }
+    };
+    const endStep = () => {
+      if (!contact) return;
+      contact.n = store.n;
+      if (offload) stepOffloaded(offload, contact);
+      else {
+        contactStep(contact, { ...options.contact, h: ctx.h }, contactResult);
+        stats.contacts = contactResult.contacts;
+        stats.maxOverlap = contactResult.maxOverlap;
+        stats.meanOverlap = contactResult.contacts ? contactResult.overlapSum / contactResult.contacts : 0;
+        if (pressure) runPressure(contact, pressure);
+      }
+      density?.step();
+      measureLean();
+      balance?.step(options.balance, contact.workspace.shove);
+      mound?.step();
+      thrown?.step(contact, balance);
+      balance?.flush();
+      playerPressure?.step(pressureResult.playerLoad);
+    };
+    const criticalOf = (i) => options.balance.criticalFactor * store.mass[i] * GRAVITY_FORCE2 * (base.typeOf(i).balance?.stability ?? 1) * store.stability[i];
+    return {
+      ctx,
+      active: contact !== null,
+      stats,
+      blasts,
+      thrown: thrown?.pool ?? createThrownPool(0),
+      contact,
+      balance,
+      beginStep,
+      endStep,
+      remap: (removed, moved) => {
+        thrown?.remap(removed, moved);
+        offload?.remap(removed, moved);
+      },
+      dispose: () => offload?.dispose(),
+      densitySlowdown: (i, band) => density?.slowdown(i, band) ?? 1,
+      pressureRatio: (i) => options.balance ? store.pressure[i] / criticalOf(i) : 0
+    };
+  }
+
+  // src/physics/pile-column.ts
+  var COLLAPSE_MARK = -7;
+  function collapsePileColumns(store, columns, cellCount, release) {
+    const owners = /* @__PURE__ */ new Map();
+    for (let i = 0; i < store.n; i++) if (store.state[i] === STATE.PILE_STEP && store.stepCell[i] >= 0) owners.set(store.stepCell[i], i);
+    for (const column of columns.splice(0)) {
+      if (column.dir === 0) continue;
+      for (let k = 1, cell = column.cell - column.dir; cell >= 0 && cell < cellCount; k++, cell = column.cell - column.dir * k) {
+        const j = owners.get(cell);
+        if (j === void 0) break;
+        owners.delete(cell);
+        release(j);
+        store.state[j] = STATE.AIRBORNE;
+        store.vy[j] = 0;
+        store.stateTimer[j] = COLLAPSE_MARK;
+      }
+    }
+  }
+
+  // src/personality.ts
+  var GAIT_WEIGHTS = [6, 1, 1, 1, 1, 2];
+  var triangular = (identity, salt, range) => range[0] + (range[1] - range[0]) * ((unit(identity, 0, salt) + unit(identity, 1, salt)) / 2);
+  var weighted = (identity, salt, weights) => {
+    const total = weights.reduce((sum, weight) => sum + weight, 0);
+    let pick = unit(identity, 0, salt) * total;
+    for (let index = 0; index < weights.length; index++) {
+      pick -= weights[index];
+      if (pick < 0) return index;
+    }
+    return weights.length - 1;
+  };
+  function applyNeutralPersonality(store, i) {
+    store.stability[i] = store.tripFactor[i] = store.driveFactor[i] = store.cadenceFactor[i] = store.aggression[i] = 1;
+    store.reaction[i] = 0;
+    store.idle[i] = 0;
+    store.gaitStyle[i] = 0;
+  }
+  function applyPersonality(store, i, options) {
+    const identity = store.identity[i];
+    const speed = triangular(identity, SALT.SPEED, options.speed);
+    store.chaseSpeed[i] *= speed;
+    store.wanderSpeed[i] *= speed;
+    store.reaction[i] = triangular(identity, SALT.REACTION, options.reaction);
+    store.stability[i] = triangular(identity, SALT.STABILITY, options.stability);
+    store.tripFactor[i] = triangular(identity, SALT.TRIP_FACTOR, options.trip);
+    store.driveFactor[i] = triangular(identity, SALT.DRIVE, options.drive);
+    store.cadenceFactor[i] = triangular(identity, SALT.CADENCE, options.cadence);
+    store.aggression[i] = triangular(identity, SALT.AGGRESSION, options.aggression);
+    store.idle[i] = weighted(identity, SALT.IDLE, options.idle);
+    store.gaitStyle[i] = weighted(identity, SALT.GAIT, GAIT_WEIGHTS);
+  }
+
+  // src/physics/seat.ts
+  function seatPhysics(store, i, born) {
+    store.identity[i] = identityOf(born.seed, born.serial);
+    store.mass[i] = born.baseMass * store.height[i] * store.build[i] ** 2;
+    store.balance[i] = BALANCE.STANDING;
+    store.balanceTimer[i] = store.pushX[i] = store.pushZ[i] = store.pressure[i] = store.field[i] = store.fieldPrev[i] = store.aimX[i] = store.aimZ[i] = store.directShove[i] = store.leanX[i] = store.leanZ[i] = 0;
+    store.fallCause[i] = 0;
+    store.blastStep[i] = -1;
+    store.thrown[i] = -1;
+    store.wounds[i] = 0;
+    store.stepDir[i] = 0;
+    store.prevX[i] = store.x[i];
+    store.prevZ[i] = store.z[i];
+    store.prevY[i] = 0;
+    if (born.personality) applyPersonality(store, i, born.personality);
+    else applyNeutralPersonality(store, i);
+  }
+
+  // src/physics/options.ts
+  var CONTACT_DEFAULTS = { radius: 0.25, iterations: 2, friction: 6, maxPush: 3, maxCorrection: 0.1, relaxation: 1, baseMass: 70, separationMax: 1.5 };
+  var PRESSURE_DEFAULTS = { transmission: 0.97, cap: 6e3, frontCone: 0.5, staggerSpeed: 0.35 };
+  var BALANCE_DEFAULTS = {
+    criticalFactor: 2,
+    staggerEnter: 0.7,
+    staggerLeave: 0.4,
+    staggerMin: 0.5,
+    fallRate: 1.5,
+    shoveStagger: 1.2,
+    shoveFall: 2.5,
+    fallenMin: 1.5,
+    releaseFactor: 0.3,
+    getUpSeconds: 1.2,
+    pressureTau: 0.3,
+    maxFallsPerStep: 8,
+    maxFallen: 300,
+    trampleDps: 6
+  };
+  var MOUND_DEFAULTS = { bodyThickness: 0.28, corpseThickness: 0.25, maxHeight: 1.6, corpseRadius: 35 };
+  var THROWN_DEFAULTS = { pool: 32, radius: 30, landingRadius: 1.2, fallDamage: 8, priority: "mixed", mixedRatio: 0.5 };
+  var DENSITY_DEFAULTS = { cell: 2, capacity: 4, pressurePerBody: 150 };
+  var BLAST_DEFAULTS = { pointsPerKilojoule: 0.6, throwSpeed: 4, maxBlastsPerStep: 8, limbEffectsPerBlast: 24, bloodEffectsPerBlast: 32, shove: {} };
+  var PERSONALITY_DEFAULTS = {
+    speed: [0.9, 1.1],
+    reaction: [0.05, 0.35],
+    stability: [0.75, 1.25],
+    trip: [0.5, 1.5],
+    drive: [0.7, 1.3],
+    cadence: [0.85, 1.15],
+    aggression: [0.8, 1.2],
+    idle: [3, 2, 2, 1]
+  };
+  var PLAYER_PRESSURE_DEFAULTS = { enabled: false, knockThreshold: 1500, crushDamagePerSecond: 6 };
+  var DOOR_PRESSURE_DAMAGE = 4e-3;
+  var DETERMINISTIC_FLOW_CELLS = 2e4;
+  var CROWD_PHYSICS_DEFAULTS = {
+    contact: CONTACT_DEFAULTS,
+    pressure: PRESSURE_DEFAULTS,
+    balance: BALANCE_DEFAULTS,
+    mound: MOUND_DEFAULTS,
+    thrown: THROWN_DEFAULTS,
+    density: DENSITY_DEFAULTS,
+    blast: BLAST_DEFAULTS,
+    personality: PERSONALITY_DEFAULTS,
+    door: { pressureDamage: DOOR_PRESSURE_DAMAGE },
+    playerPressure: PLAYER_PRESSURE_DEFAULTS,
+    deterministic: true
+  };
+  var part = (option, defaults) => {
+    if (option === void 0 || option === false) return null;
+    return option === true ? defaults : { ...defaults, ...option };
+  };
+  function resolvePhysics(physics = {}) {
+    const contact = part(physics.contact, CONTACT_DEFAULTS);
+    const pressure = part(physics.pressure, PRESSURE_DEFAULTS);
+    const balance = part(physics.balance, BALANCE_DEFAULTS);
+    const mound = part(physics.mound, MOUND_DEFAULTS);
+    const thrown = part(physics.thrown, THROWN_DEFAULTS);
+    const density = part(physics.density, DENSITY_DEFAULTS);
+    const playerPressure = { ...PLAYER_PRESSURE_DEFAULTS, ...physics.playerPressure };
+    const missing = [];
+    if (!contact && pressure) missing.push("pressure needs contact");
+    if (!contact && balance) missing.push("balance needs contact");
+    if (!balance && mound) missing.push("mound needs balance");
+    if (!balance && thrown) missing.push("thrown needs balance");
+    if (!balance && density) missing.push("density needs balance");
+    if (!pressure && playerPressure.enabled) missing.push("playerPressure needs pressure");
+    if (!contact && physics.worker === "on") missing.push("worker needs contact");
+    if (missing.length) throw new Error(`crowd physics: ${missing.join("; ")}`);
+    return {
+      contact,
+      pressure,
+      balance,
+      mound,
+      thrown,
+      density,
+      blast: { ...BLAST_DEFAULTS, ...physics.blast },
+      personality: part(physics.personality, PERSONALITY_DEFAULTS),
+      doorPressureDamage: physics.door?.pressureDamage ?? DOOR_PRESSURE_DAMAGE,
+      playerPressure,
+      deterministic: physics.deterministic ?? false,
+      worker: physics.worker ?? "off",
+      workerFactory: physics.workerFactory,
+      workerTransport: physics.workerTransport,
+      workerLatency: physics.workerLatency ?? 1
+    };
+  }
+
   // src/rng.ts
   function createRng(seed) {
     let state = seed >>> 0;
@@ -1668,7 +3602,38 @@ var GameCrowd = (() => {
       lod: u8(),
       variant: u8(),
       attackPose: u8(),
-      arms: f32()
+      arms: f32(),
+      stepDir: new Int32Array(capacity),
+      // physics (CrowdOptions.physics): they exist with it off, so the store keeps its shape; the game replays never read them
+      pushX: f32(),
+      pushZ: f32(),
+      mass: f32(),
+      pressure: f32(),
+      field: f32(),
+      fieldPrev: f32(),
+      aimX: f32(),
+      aimZ: f32(),
+      directShove: f32(),
+      blastStep: new Int32Array(capacity),
+      balance: u8(),
+      balanceTimer: f32(),
+      fallCause: u8(),
+      identity: new Uint32Array(capacity),
+      stability: f32(),
+      tripFactor: f32(),
+      driveFactor: f32(),
+      reaction: f32(),
+      cadenceFactor: f32(),
+      aggression: f32(),
+      idle: u8(),
+      gaitStyle: u8(),
+      wounds: new Uint16Array(capacity),
+      leanX: f32(),
+      leanZ: f32(),
+      thrown: new Int8Array(capacity),
+      prevX: f32(),
+      prevZ: f32(),
+      prevY: f32()
     };
   };
   var AGENT_FIELDS = [
@@ -1724,26 +3689,39 @@ var GameCrowd = (() => {
     "lod",
     "variant",
     "attackPose",
-    "arms"
+    "arms",
+    "stepDir",
+    "pushX",
+    "pushZ",
+    "mass",
+    "pressure",
+    "field",
+    "fieldPrev",
+    "aimX",
+    "aimZ",
+    "directShove",
+    "blastStep",
+    "balance",
+    "balanceTimer",
+    "fallCause",
+    "identity",
+    "stability",
+    "tripFactor",
+    "driveFactor",
+    "reaction",
+    "cadenceFactor",
+    "aggression",
+    "idle",
+    "gaitStyle",
+    "wounds",
+    "leanX",
+    "leanZ",
+    "thrown",
+    "prevX",
+    "prevZ",
+    "prevY"
   ];
 
-  // src/types.ts
-  var STATE = {
-    WANDER: 0,
-    CHASE: 1,
-    GRAB: 2,
-    STUNNED: 3,
-    CALLING: 4,
-    AIRBORNE: 5,
-    DORMANT: 6,
-    SWELLING: 7,
-    SWING: 8,
-    EATING: 9,
-    PILE_STEP: 10,
-    SEEKING_SOUND: 12
-  };
-  var MISSING = { SKULL: 1, ARM_L: 2, ARM_R: 4, LEG_L: 8, LEG_R: 16, ARM_L_BROKEN: 32, ARM_R_BROKEN: 64, LEG_L_BROKEN: 128, LEG_R_BROKEN: 256, JAW: 512 };
-
   // src/crowd.ts
   var CROWD_DEFAULTS = {
     sources: defaults_default.sources,
@@ -1751,6 +3729,7 @@ var GameCrowd = (() => {
     numbers: defaults_default.numbers
   };
   var clamp = (v, a, b) => v < a ? a : v > b ? b : v;
+  var NO_TRAITS = {};
   var TAU_APPROX = 6.2832;
   var TURN = 6.28;
   function createCrowd(options) {
@@ -1772,10 +3751,25 @@ var GameCrowd = (() => {
     const HALF = grid.half;
     const GC = grid.cell;
     const FW = grid.n;
+    const physics = resolvePhysics(options.physics);
+    const flowCells = options.flow?.cellsPerStep ?? (physics.deterministic ? DETERMINISTIC_FLOW_CELLS : void 0);
+    const seed32 = (options.seed ?? 1) >>> 0;
+    let serial = 0;
+    const moundHeight = new Uint16Array(physics.mound ? FW * FW : 0);
+    const moundOn = physics.mound !== null;
+    const balanceOn = physics.balance !== null;
+    const staggerSpeed = physics.pressure?.staggerSpeed ?? 1;
+    const separationMax = physics.contact?.separationMax ?? Infinity;
+    const RESERVED_SLOTS = 2;
+    const WALK_DOWN = 0.6;
+    const ATTACK_ENTER = 2.56;
+    const ATTACK_LEAVE = 4.84;
     const HC = N.hashCell;
     const HN = Math.floor(grid.size / HC);
-    const hHead = new Int32Array(HN * HN);
+    const hHead = new Int32Array(HN * HN).fill(-1);
     const hNext = new Int32Array(Z.capacity);
+    const hashTouched = new Int32Array(Z.capacity);
+    let hashTouchedN = 0;
     const pile = new Float32Array(FW * FW);
     let pileN = 0;
     const flow = {
@@ -1808,7 +3802,7 @@ var GameCrowd = (() => {
     }
     const typeIndexById = new Map(types.map((type, index) => [type.id, index]));
     const noises = [];
-    const stats = { bands: [0, 0, 0, 0], slots: 0, kills: 0, heads: 0 };
+    const stats = { bands: [0, 0, 0, 0], slots: 0, kills: 0, heads: 0, physics: createPhysicsStats() };
     const corpses = createCorpseLedger({ max: N.corpsesMax, seconds: N.corpseSeconds });
     const trail = [];
     let trailLast = { x: 1e9, z: 1e9 };
@@ -1843,7 +3837,7 @@ var GameCrowd = (() => {
       return list[0];
     };
     const T = (i) => types[Z.type[i]];
-    const traits = (i) => T(i).traits ?? {};
+    const traits = (i) => T(i).traits ?? NO_TRAITS;
     const special = (i) => {
       const tr = traits(i);
       Z.y[i] = 0;
@@ -1926,13 +3920,18 @@ var GameCrowd = (() => {
       Z.wz[i] = z;
       Z.color[i] = RO.color || pack.palette[Math.floor(R() * pack.palette.length)];
       Z.skin[i] = R();
+      seatPhysics(Z, i, { seed: seed32, serial: serial++, baseMass: physics.contact?.baseMass ?? 70, personality: physics.personality });
       special(i);
       emit("spawn", { agent: i, type: C.id });
       return i;
     };
     const remove = (i) => {
-      if (Z.state[i] === STATE.PILE_STEP) stepRelease(i);
+      if (Z.state[i] === STATE.PILE_STEP) {
+        if (engine.active) releasePileStep(i);
+        else stepRelease(i);
+      }
       const j = --Z.n;
+      engine.remap(i, j);
       if (i === j) {
         emit("remove", { agent: i, moved: -1 });
         return;
@@ -1966,9 +3965,10 @@ var GameCrowd = (() => {
       flow.c = 0;
       flow.t = 0;
     };
-    const flowStep = (budget) => {
+    const flowStep = (budget, cellsPerStep) => {
       if (!flow.phase) return;
       const t0 = clock();
+      let cellsLeft = cellsPerStep ?? Infinity;
       const D = flow.dist;
       const Q = flow.q;
       const F = flow.back;
@@ -1979,6 +3979,7 @@ var GameCrowd = (() => {
           flow.phase = 2;
           break;
         }
+        if (--cellsLeft < 0) return;
         const c = Q[flow.qh++];
         const cx = c % FW;
         const cz = c / FW | 0;
@@ -1998,13 +3999,14 @@ var GameCrowd = (() => {
               if (flow.qt < Q.length) Q[flow.qt++] = k;
             }
           }
-        if ((++n & 2047) === 0 && clock() - t0 > budget) {
+        if (cellsPerStep === void 0 && (++n & 2047) === 0 && clock() - t0 > budget) {
           flow.t += clock() - t0;
           return;
         }
       }
       const ww = W[2] - W[0] + 1;
       while (flow.phase === 2) {
+        if (--cellsLeft < 0) return;
         const j = flow.c++;
         if (j >= ww * (W[3] - W[1] + 1)) {
           const tmp = flow.dir;
@@ -2041,7 +4043,7 @@ var GameCrowd = (() => {
           }
         F[c * 2] = bx;
         F[c * 2 + 1] = bz;
-        if ((j & 8191) === 0 && clock() - t0 > budget) {
+        if (cellsPerStep === void 0 && (j & 8191) === 0 && clock() - t0 > budget) {
           flow.t += clock() - t0;
           return;
         }
@@ -2052,14 +4054,14 @@ var GameCrowd = (() => {
       if (c < 0) return 0;
       const k = occ[c];
       if (k === 2 || k === 1 && occH[c] <= _y + 0.05) return occH[c];
-      return pile[c];
+      return moundOn ? pile[c] + moundHeight[c] / 1e3 : pile[c];
     };
     const blockedAt = (i, x, z) => {
       const c = cellOf(x, z);
       if (c < 0) return true;
       const k = occ[c];
       const y = Z.y[i];
-      if (k === 0 || k === 3) return pile[c] > y + 0.5 && Z.state[i] !== STATE.AIRBORNE;
+      if (k === 0 || k === 3) return (moundOn ? pile[c] + moundHeight[c] / 1e3 : pile[c]) > y + 0.5 && Z.state[i] !== STATE.AIRBORNE;
       if (k === 2 && y + 0.5 >= occH[c]) return false;
       if (Z.state[i] === STATE.AIRBORNE && occH[c] <= y) return false;
       return true;
@@ -2079,6 +4081,7 @@ var GameCrowd = (() => {
       pileN++;
       Z.state[i] = STATE.PILE_STEP;
       Z.stepCell[i] = c;
+      Z.stepDir[i] = dir;
       Z.vx[i] = Z.vz[i] = 0;
       Z.y[i] = h - N.pileStep;
       Z.stateTimer[i] = 6 + R() * 6;
@@ -2102,6 +4105,11 @@ var GameCrowd = (() => {
           Z.stateTimer[i] = 1.2;
         }
     };
+    const pileColumns = [];
+    const releasePileStep = (i) => {
+      if (Z.stepCell[i] >= 0) pileColumns.push({ cell: Z.stepCell[i], dir: Z.stepDir[i] });
+      stepRelease(i);
+    };
     const voice = (i) => traits(i).voice ?? "groan";
     const groan = (i, d) => {
       const r2 = N.alertRadius * N.alertRadius;
@@ -2135,9 +4143,9 @@ var GameCrowd = (() => {
     const attack = (i, d, tdt) => {
       Z.attackTimer[i] -= tdt;
       if (Z.attackTimer[i] > 0) return;
-      Z.attackTimer[i] = N.attackEvery;
+      Z.attackTimer[i] = N.attackEvery / Z.aggression[i];
       const C = T(i);
-      const tr = C.traits ?? {};
+      const tr = C.traits ?? NO_TRAITS;
       if (tr.heavySwing && R() < tr.heavySwing.chance) {
         Z.state[i] = STATE.SWING;
         Z.stateTimer[i] = tr.heavySwing.windUp;
@@ -2146,7 +4154,7 @@ var GameCrowd = (() => {
       const noJaw = Z.missing[i] & 512;
       const noArms = (Z.missing[i] & 6) === 6;
       const P = target;
-      if (P.state.grabbedBy < 0 && !noArms && !Z.crawl[i] && R() < C.bite * (P.state.crouch ? N.crouchBite : 1)) {
+      if (P.state.grabbedBy < 0 && !noArms && !Z.crawl[i] && R() < C.bite * (P.state.crouch ? N.crouchBite : 1) * Z.aggression[i]) {
         P.grab(i, !!noJaw, !!tr.drownGrab && water(P.state.x, P.state.z));
         Z.state[i] = STATE.GRAB;
       } else {
@@ -2157,7 +4165,7 @@ var GameCrowd = (() => {
     };
     const effect = (payload) => emit("effect", payload);
     const blood = (x, y, z, age, amount, died, agent) => effect({ effect: "blood", point: [x, y, z], age, amount, died, ...agent === void 0 ? {} : { agent } });
-    const damage = (i, hit) => {
+    const damageWith = (i, hit, draw, deferDeath = false) => {
       const C = T(i);
       const A = pack.ages[Z.age[i]];
       const RO = pack.outfits[Z.outfit[i]];
@@ -2184,7 +4192,7 @@ var GameCrowd = (() => {
         } else {
           Z.hp[i] -= dano * 3;
           Z.headHp[i] -= dano;
-          if (dano > N.jawDamage && R() < N.jawChance) Z.missing[i] |= 512;
+          if (dano > N.jawDamage && draw() < N.jawChance) Z.missing[i] |= 512;
         }
       } else if (regiao === 1) {
         let m = C.multipliers.torso;
@@ -2214,7 +4222,8 @@ var GameCrowd = (() => {
       if (Z.hp[i] <= 0) morreu = true;
       blood(Z.x[i], regiao === 0 ? Z.height[i] * 1.65 : regiao === 1 ? Z.height[i] * 1.2 : Z.height[i] * 0.7, Z.z[i], Z.age[i], regiao === 0 ? 120 : 30, morreu, i);
       if (morreu) {
-        kill(i, headshot);
+        if (deferDeath) deferKill(i);
+        else kill(i, headshot, draw);
         return { died: morreu, headshot };
       }
       const st = Z.state[i];
@@ -2231,14 +4240,15 @@ var GameCrowd = (() => {
       }
       return { died: morreu };
     };
-    function kill(i, headshot = false) {
+    const damage = (i, hit) => damageWith(i, hit, R);
+    function kill(i, headshot = false, draw = R) {
       stats.kills++;
       if (headshot) stats.heads++;
       const tr = traits(i);
       if (tr.burst) burstAt(i, Z.x[i], Z.z[i]);
       const C = T(i);
       emit("kill", { agent: i, type: C.id, headshot, x: Z.x[i], z: Z.z[i] });
-      corpseAdd(i);
+      if (Z.balance[i] !== BALANCE.THROWN) corpseAdd(i, draw);
       if (target && target.state.grabbedBy === i) target.release();
       remove(i);
     }
@@ -2257,24 +4267,23 @@ var GameCrowd = (() => {
       }
       emitNoise(x, z, b.noise);
     };
-    const corpseAdd = (i) => {
-      corpses.add({
-        x: Z.x[i],
-        z: Z.z[i],
-        yaw: Z.renderYaw[i],
-        height: Z.height[i],
-        build: Z.build[i],
-        named: Z.named[i],
-        missing: Z.missing[i],
-        color: Z.color[i],
-        variant: Z.variant[i],
-        skin: Z.skin[i],
-        seed: R() * 10
-      });
-    };
+    const corpseOf = (i, seed) => ({
+      x: Z.x[i],
+      z: Z.z[i],
+      yaw: Z.renderYaw[i],
+      height: Z.height[i],
+      build: Z.build[i],
+      named: Z.named[i],
+      missing: Z.missing[i],
+      color: Z.color[i],
+      variant: Z.variant[i],
+      skin: Z.skin[i],
+      seed
+    });
+    const corpseAdd = (i, draw = R) => void corpses.add(corpseOf(i, draw() * 10));
     const ability = (i, d, dx, dz, tdt, b, alive) => {
       const C = T(i);
-      const tr = C.traits ?? {};
+      const tr = C.traits ?? NO_TRAITS;
       const st = Z.state[i];
       const P = target;
       if (st === STATE.DORMANT) {
@@ -2480,6 +4489,7 @@ var GameCrowd = (() => {
       if (tr.submerged && water(Z.x[i], Z.z[i])) return tr.submerged.swim;
       return Z.chaseSpeed[i];
     };
+    const physicsDraw = (i, salt) => engine.active ? () => unit(Z.identity[i], engine.ctx.step, salt) : R;
     const hurtOther = (j, amount) => {
       Z.hp[j] -= amount;
       blood(Z.x[j], Z.height[j] * 1.2, Z.z[j], Z.age[j], 30, false, j);
@@ -2491,7 +4501,7 @@ var GameCrowd = (() => {
     const killQFlush = () => {
       if (!killQ.length) return;
       killQ.sort((a, b) => b - a);
-      for (const j of killQ) if (j < Z.n) kill(j, false);
+      for (const j of killQ) if (j < Z.n) kill(j, false, physicsDraw(j, SALT.CORPSE));
       killQ.length = 0;
     };
     const frame = (i, dt, d, alive) => {
@@ -2514,9 +4524,14 @@ var GameCrowd = (() => {
         Z.hp[i] *= tr.waterWeak.keep;
         effect({ effect: "cloud", point: [Z.x[i], 0, Z.z[i]], radius: 1.5, color: tr.waterWeak.cloud, amount: 3, agent: i });
       }
+      if (engine.active && (Z.balance[i] === BALANCE.FALLEN || Z.balance[i] === BALANCE.GETTING_UP)) return;
       const c = cellOf(Z.x[i], Z.z[i]);
       const gy = groundAt(c, Z.y[i]);
       if (st === STATE.DORMANT || Z.floorLocked[i]) return;
+      if (engine.active && st !== STATE.AIRBORNE && Z.vy[i] === 0 && Z.y[i] > gy + 0.02 && Z.y[i] - gy <= WALK_DOWN) {
+        Z.y[i] = Math.max(gy, Z.y[i] - N.climbSpeed * dt);
+        return;
+      }
       if (st === STATE.AIRBORNE || Z.y[i] > gy + 0.02 || Z.vy[i] > 0) {
         Z.vy[i] -= N.gravity * dt;
         Z.y[i] += Z.vy[i] * dt;
@@ -2524,6 +4539,9 @@ var GameCrowd = (() => {
           const fall = -Z.vy[i];
           Z.y[i] = gy;
           Z.vy[i] = 0;
+          const collapsed = st === STATE.AIRBORNE && Z.stateTimer[i] === COLLAPSE_MARK;
+          if (collapsed) Z.stateTimer[i] = 0;
+          if (engine.active && balanceOn && (st !== STATE.AIRBORNE || collapsed)) engine.balance.landed(i, fall * fall / (2 * N.gravity));
           if (st === STATE.AIRBORNE) {
             Z.state[i] = STATE.CHASE;
             if (tr.pounce && alive && d < tr.pounce.landRange && target) {
@@ -2547,6 +4565,9 @@ var GameCrowd = (() => {
       const pz = P ? P.state.z : context.flowTarget?.[1] ?? 0;
       const alive = !!P && P.state.alive && !P.state.turned;
       viewYaw = context.viewYaw ?? (P ? P.state.yaw - Math.PI : 0);
+      const bandX = context.bandCentre?.[0] ?? px;
+      const bandZ = context.bandCentre?.[1] ?? pz;
+      engine.beginStep(dt, { x: bandX, z: bandZ });
       const fx0 = context.flowTarget?.[0] ?? px;
       const fz0 = context.flowTarget?.[1] ?? pz;
       const pc = cellOf(fx0, fz0);
@@ -2558,14 +4579,18 @@ var GameCrowd = (() => {
         flowStart(fx0, fz0);
         flow.cell = pc;
       }
-      flowStep(N.flowBudgetMs);
-      hHead.fill(-1);
+      flowStep(N.flowBudgetMs, flowCells);
+      if (engine.active) {
+        for (let k = 0; k < hashTouchedN; k++) hHead[hashTouched[k]] = -1;
+        hashTouchedN = 0;
+      } else hHead.fill(-1);
       for (let i = 0; i < Z.n; i++) {
-        if (Z.band[i] !== 0) continue;
+        if (Z.band[i] !== 0 || engine.active && Z.balance[i] === BALANCE.THROWN) continue;
         const hx = Math.floor(Z.x[i] + HALF);
         const hz = Math.floor(Z.z[i] + HALF);
         if (hx < 0 || hz < 0 || hx >= HN || hz >= HN) continue;
         const h = hz * HN + hx;
+        if (engine.active && hHead[h] === -1) hashTouched[hashTouchedN++] = h;
         hNext[i] = hHead[h];
         hHead[h] = i;
       }
@@ -2577,13 +4602,16 @@ var GameCrowd = (() => {
         const dx = Z.x[i] - px;
         const dz = Z.z[i] - pz;
         const d = Math.sqrt(dx * dx + dz * dz);
+        const bandD = context.bandCentre ? Math.hypot(Z.x[i] - bandX, Z.z[i] - bandZ) : d;
         let b = Z.band[i];
-        while (b > 0 && d < BANDS[b - 1].max - HYST) b--;
-        while (b < 3 && d > BANDS[b].max + HYST) b++;
+        while (b > 0 && bandD < BANDS[b - 1].max - HYST) b--;
+        while (b < 3 && bandD > BANDS[b].max + HYST) b++;
         Z.band[i] = b;
         B[b]++;
+        if (engine.active && Z.balance[i] === BALANCE.THROWN) continue;
+        const grounded = engine.active && balanceOn && (Z.balance[i] === BALANCE.FALLEN || Z.balance[i] === BALANCE.GETTING_UP);
         const C = T(i);
-        const tr = C.traits ?? {};
+        const tr = C.traits ?? NO_TRAITS;
         if (Z.state[i] === STATE.STUNNED) {
           Z.stateTimer[i] -= dt;
           if (Z.stateTimer[i] <= 0) Z.state[i] = STATE.CHASE;
@@ -2607,8 +4635,12 @@ var GameCrowd = (() => {
             Z.lost[i] = 0;
           }
         }
-        Z.next[i] -= dt;
-        if (Z.next[i] <= 0) {
+        if (!grounded) Z.next[i] -= dt;
+        else {
+          Z.vx[i] = Z.vz[i] = Z.dvx[i] = Z.dvz[i] = Z.aimX[i] = Z.aimZ[i] = 0;
+          Z.steering[i] = 0;
+        }
+        if (Z.next[i] <= 0 && !grounded) {
           const tdt = BANDS[b].dt;
           Z.next[i] += tdt;
           if (alive && b <= 1 && Z.state[i] <= 1) {
@@ -2655,6 +4687,7 @@ var GameCrowd = (() => {
             Z.stateTimer[i] = tr.caller.windUp;
           }
           Z.steering[i] = 0;
+          Z.aimX[i] = Z.aimZ[i] = 0;
           if (!ability(i, d, dx, dz, tdt, b, alive)) {
             let tx = 0;
             let tz = 0;
@@ -2691,7 +4724,7 @@ var GameCrowd = (() => {
               if (!alive) sp = Z.wanderSpeed[i];
               if (d < N.attackRange && alive && Math.abs(P.state.y - Z.y[i]) < N.attackHeight) {
                 sp = 0;
-                if (slots < N.attackSlots) {
+                if (slots < N.attackSlots - (Z.aggression[i] < 1 ? RESERVED_SLOTS : 0)) {
                   slots++;
                   attack(i, d, tdt);
                 }
@@ -2713,6 +4746,7 @@ var GameCrowd = (() => {
             }
             if (Z.crawl[i]) sp = Math.min(sp, N.crawlSpeed);
             else if (Z.limp[i]) sp *= N.limpSpeed;
+            if (Z.balance[i] === BALANCE.STAGGERING) sp *= staggerSpeed;
             let sx = 0;
             let sz = 0;
             if (b === 0) {
@@ -2724,7 +4758,7 @@ var GameCrowd = (() => {
                   const qz = hz + oz;
                   if (qx < 0 || qz < 0 || qx >= HN || qz >= HN) continue;
                   for (let j = hHead[qz * HN + qx]; j !== -1; j = hNext[j]) {
-                    if (j === i || Z.state[j] === STATE.PILE_STEP || Z.state[j] === STATE.DORMANT) continue;
+                    if (j === i || Z.state[j] === STATE.PILE_STEP || Z.state[j] === STATE.DORMANT || balanceOn && (Z.balance[j] === BALANCE.FALLEN || Z.balance[j] === BALANCE.GETTING_UP)) continue;
                     const ex = Z.x[i] - Z.x[j];
                     const ez = Z.z[i] - Z.z[j];
                     const e2 = ex * ex + ez * ez;
@@ -2739,8 +4773,20 @@ var GameCrowd = (() => {
                 }
             }
             if (Z.state[i] <= 2) {
-              Z.dvx[i] = tx * sp + sx * N.separationPush;
-              Z.dvz[i] = tz * sp + sz * N.separationPush;
+              if (separationMax !== Infinity) {
+                const push = Math.hypot(sx, sz) * N.separationPush;
+                if (push > separationMax) {
+                  sx *= separationMax / push;
+                  sz *= separationMax / push;
+                }
+              }
+              if (engine.active && sp > 0.05) {
+                Z.aimX[i] = tx;
+                Z.aimZ[i] = tz;
+              }
+              const slow = engine.densitySlowdown(i, b);
+              Z.dvx[i] = (tx * sp + sx * N.separationPush) * slow;
+              Z.dvz[i] = (tz * sp + sz * N.separationPush) * slow;
               Z.steering[i] = 1;
               if (sp > 0.05) Z.yaw[i] = Math.atan2(tx, tz);
               else if (d < 3 && alive) Z.yaw[i] = Math.atan2(-dx, -dz);
@@ -2752,17 +4798,17 @@ var GameCrowd = (() => {
           Z.vx[i] += (Z.dvx[i] - Z.vx[i]) * k;
           Z.vz[i] += (Z.dvz[i] - Z.vz[i]) * k;
         }
-        const nx = Z.x[i] + Z.vx[i] * dt;
-        const nz = Z.z[i] + Z.vz[i] * dt;
+        const nx = Z.x[i] + (Z.vx[i] + Z.pushX[i]) * dt;
+        const nz = Z.z[i] + (Z.vz[i] + Z.pushZ[i]) * dt;
         let hitCell = -1;
         if (!blockedAt(i, nx, Z.z[i])) Z.x[i] = nx;
         else {
-          if (Z.state[i] !== STATE.AIRBORNE) Z.vx[i] = 0;
+          if (Z.state[i] !== STATE.AIRBORNE) Z.vx[i] = Z.pushX[i] = 0;
           hitCell = cellOf(nx, Z.z[i]);
         }
         if (!blockedAt(i, Z.x[i], nz)) Z.z[i] = nz;
         else {
-          if (Z.state[i] !== STATE.AIRBORNE) Z.vz[i] = 0;
+          if (Z.state[i] !== STATE.AIRBORNE) Z.vz[i] = Z.pushZ[i] = 0;
           hitCell = cellOf(Z.x[i], nz);
         }
         if (hitCell >= 0 && Z.state[i] === STATE.CHASE && b === 0) {
@@ -2774,7 +4820,7 @@ var GameCrowd = (() => {
             Z.vx[i] = Math.sin(Z.yaw[i]) * s2;
             Z.vz[i] = Math.cos(Z.yaw[i]) * s2;
           } else if (occ[hitCell] === 2 || occ[hitCell] === 0 && pile[hitCell] > 0) {
-            Z.stuck[i] += dt;
+            Z.stuck[i] += engine.active && balanceOn ? dt * (1 + engine.pressureRatio(i)) : dt;
             if (Z.stuck[i] > 0.35 + 0.5 * Z.skin[i]) {
               Z.stuck[i] = 0;
               tryStep(i, hitCell);
@@ -2797,12 +4843,18 @@ var GameCrowd = (() => {
           if (goal && solidAt(Z.x[i] + Math.sin(Z.renderYaw[i]) * 0.62, Z.z[i] + Math.cos(Z.renderYaw[i]) * 0.62, 1)) goal = 0.1;
           Z.arms[i] += (goal - Z.arms[i]) * Math.min(1, dt * (goal > Z.arms[i] ? 3 : 5));
         }
-        Z.phase[i] += dt * (Z.renderSpeed[i] < 0.05 ? 0.15 : N.cadenceBase + N.cadencePerSpeed * Z.renderSpeed[i]);
+        Z.phase[i] += dt * (Z.renderSpeed[i] < 0.05 ? 0.15 : N.cadenceBase + N.cadencePerSpeed * Z.renderSpeed[i]) * Z.cadenceFactor[i];
+        if (physics.deterministic) {
+          const attacking = Z.state[i] === STATE.CHASE && alive;
+          Z.attackPose[i] = attacking && (Z.x[i] - P.state.x) ** 2 + (Z.z[i] - P.state.z) ** 2 < (Z.attackPose[i] ? ATTACK_LEAVE : ATTACK_ENTER) ? 1 : 0;
+        }
         if (spd > 0.35 && Z.state[i] <= 1 && !Z.attackPose[i]) Z.yaw[i] = Math.atan2(Z.vx[i], Z.vz[i]);
         let dy = Z.yaw[i] - Z.renderYaw[i];
         dy -= Math.round(dy / TAU_APPROX) * TAU_APPROX;
         Z.renderYaw[i] += dy * Math.min(1, dt * (Z.state[i] === STATE.AIRBORNE ? 20 : 9));
       }
+      engine.endStep();
+      if (pileColumns.length) collapsePileColumns(Z, pileColumns, FW * FW, stepRelease);
       killQFlush();
       noises.length = 0;
       stats.slots = slots;
@@ -2866,6 +4918,31 @@ var GameCrowd = (() => {
         if (m) emit("message", { id: "migration", seconds: 4 });
       }
     };
+    const engine = createPhysics(
+      {
+        store: Z,
+        grid,
+        doors,
+        gravity: N.gravity,
+        attackEvery: N.attackEvery,
+        types,
+        moundHeight,
+        corpsesMax: N.corpsesMax,
+        typeOf: T,
+        target: () => target,
+        emit,
+        damage: (i, hit, draw) => damageWith(i, hit, draw, true),
+        deferKill,
+        releasePileStep,
+        corpseOf,
+        corpseList: () => corpses.entries,
+        addCorpse: (corpse) => void corpses.add(corpse),
+        groundAt,
+        pileBlast
+      },
+      physics,
+      stats.physics
+    );
     const crowd = {
       store: Z,
       pack,
@@ -2875,6 +4952,9 @@ var GameCrowd = (() => {
       numbers: N,
       stats,
       pile,
+      mound: moundHeight,
+      thrown: engine.thrown,
+      blast: (blast) => engine.blasts.enqueue(blast),
       pileCount: () => pileN,
       trail,
       variantsOf,
@@ -2891,6 +4971,7 @@ var GameCrowd = (() => {
       spawn: (x, z, type = -1) => spawn(x, z, type),
       remove,
       update,
+      dispose: () => engine.dispose(),
       emitNoise,
       damage,
       kill: (i, headshot = false) => kill(i, headshot),