@adatechnology/game-crowd 0.2.6 → 0.4.0

package/dist/index.js

@@ -161,6 +161,11 @@ function createDoors(grid, options) {
 
 // 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;
@@ -172,11 +177,7 @@ function createNavGrid(options = {}) {
   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;
@@ -230,6 +231,1864 @@ function createNavGrid(options = {}) {
   };
 }
 
+// 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
+import { blastShove } from "@adatechnology/game-contracts";
+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
+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;
@@ -302,7 +2161,38 @@ var createStore = (capacity) => {
     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 = [
@@ -358,26 +2248,39 @@ var AGENT_FIELDS = [
   "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,
@@ -385,6 +2288,7 @@ var CROWD_DEFAULTS = {
   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) {
@@ -406,10 +2310,25 @@ function createCrowd(options) {
   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 = {
@@ -442,7 +2361,7 @@ function createCrowd(options) {
   }
   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 };
@@ -477,7 +2396,7 @@ function createCrowd(options) {
     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;
@@ -560,13 +2479,18 @@ function createCrowd(options) {
     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;
@@ -600,9 +2524,10 @@ function createCrowd(options) {
     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;
@@ -613,6 +2538,7 @@ function createCrowd(options) {
         flow.phase = 2;
         break;
       }
+      if (--cellsLeft < 0) return;
       const c = Q[flow.qh++];
       const cx = c % FW;
       const cz = c / FW | 0;
@@ -632,13 +2558,14 @@ function createCrowd(options) {
             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;
@@ -675,7 +2602,7 @@ function createCrowd(options) {
         }
       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;
       }
@@ -686,14 +2613,14 @@ function createCrowd(options) {
     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;
@@ -713,6 +2640,7 @@ function createCrowd(options) {
     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;
@@ -736,6 +2664,11 @@ function createCrowd(options) {
         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;
@@ -769,9 +2702,9 @@ function createCrowd(options) {
   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;
@@ -780,7 +2713,7 @@ function createCrowd(options) {
     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 {
@@ -791,7 +2724,7 @@ function createCrowd(options) {
   };
   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]];
@@ -818,7 +2751,7 @@ function createCrowd(options) {
       } 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;
@@ -848,7 +2781,8 @@ function createCrowd(options) {
     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];
@@ -865,14 +2799,15 @@ function createCrowd(options) {
     }
     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);
   }
@@ -891,24 +2826,23 @@ function createCrowd(options) {
     }
     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) {
@@ -1114,6 +3048,7 @@ function createCrowd(options) {
     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);
@@ -1125,7 +3060,7 @@ function createCrowd(options) {
   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) => {
@@ -1148,9 +3083,14 @@ function createCrowd(options) {
       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;
@@ -1158,6 +3098,9 @@ function createCrowd(options) {
         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) {
@@ -1181,6 +3124,9 @@ function createCrowd(options) {
     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);
@@ -1192,14 +3138,18 @@ function createCrowd(options) {
       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;
     }
@@ -1211,13 +3161,16 @@ function createCrowd(options) {
       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;
@@ -1241,8 +3194,12 @@ function createCrowd(options) {
           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) {
@@ -1289,6 +3246,7 @@ function createCrowd(options) {
           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;
@@ -1325,7 +3283,7 @@ function createCrowd(options) {
             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);
               }
@@ -1347,6 +3305,7 @@ function createCrowd(options) {
           }
           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) {
@@ -1358,7 +3317,7 @@ function createCrowd(options) {
                 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;
@@ -1373,8 +3332,20 @@ function createCrowd(options) {
               }
           }
           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);
@@ -1386,17 +3357,17 @@ function createCrowd(options) {
         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) {
@@ -1408,7 +3379,7 @@ function createCrowd(options) {
           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);
@@ -1431,12 +3402,18 @@ function createCrowd(options) {
         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;
@@ -1500,6 +3477,31 @@ function createCrowd(options) {
       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,
@@ -1509,6 +3511,9 @@ function createCrowd(options) {
     numbers: N,
     stats,
     pile,
+    mound: moundHeight,
+    thrown: engine.thrown,
+    blast: (blast) => engine.blasts.enqueue(blast),
     pileCount: () => pileN,
     trail,
     variantsOf,
@@ -1525,6 +3530,7 @@ function createCrowd(options) {
     spawn: (x, z, type = -1) => spawn(x, z, type),
     remove,
     update,
+    dispose: () => engine.dispose(),
     emitNoise,
     damage,
     kill: (i, headshot = false) => kill(i, headshot),
@@ -2286,23 +4292,33 @@ function bindInfection(crowd, model, options) {
 }
 export {
   AGENT_FIELDS,
+  BALANCE,
   CELL,
   CIVILIAN_DEFAULTS,
   CROWD_DEFAULTS,
+  CROWD_PHYSICS_DEFAULTS,
   DOOR_DEFAULTS,
+  FALL_CAUSE,
   HERD_DEFAULTS,
   HERD_ROLES,
   MISSING,
   STATE,
+  attachPhysicsWorker,
   bindInfection,
   carrionCenter,
+  contactStep,
   createCivilians,
+  createContactView,
   createCrowd,
   createDoors,
   createFlock,
   createHerd,
   createNavGrid,
   createRng,
-  createStore
+  createStore,
+  identityOf,
+  mix32,
+  resolvePhysics,
+  unit
 };
 //# sourceMappingURL=index.js.map