@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/src/kinetix-installed-f64-runtime.mjs

@@ -0,0 +1,607 @@
+// Browser-safe sim core for the deterministic-f64 component runtime
+// (pack v2). This is the semantic oracle for the installed profile: the portable
+// C++ runtime must produce identical canonical per-tick hashes.
+//
+// Numeric contract: IEEE-754 doubles; +,-,*,/ and sqrt only from hardware;
+// every transcendental (sin, cos, atan, atan2, exp, log, hypot) from the
+// deterministic math namespace (battery-proven bit-identical to the C++
+// port). RNG = mulberry32 streams, floats via u32 / 2^32.
+//
+// Tick pipeline (lowered from the reviewed arena fixed-tick order, restricted
+// to the slice mechanics):
+//   1 input components write fields          (AxisInputState, FireInputState)
+//   2 shield + telegraph countdowns
+//   3 driven movement + clamp + heading      (AxisDriveMover, ArenaBounds, HeadingFromVectors)
+//   4 auto-fire weapons spawn bullets        (AutoFireWeapon)
+//   5 linear movers integrate + bounds       (LinearMover + ArenaBounds; bullets cull, shards reflect)
+//   6 pre-AI bullet->enemy collisions
+//   7 enemy AI integrate + bounds            (WanderMover, SeekMover)
+//   8 bullet->enemy, ship->enemy collisions
+//   9 lifetimes, on-death emitters, despawn, scoring, respawn
+//  10 canonical hash
+//
+// Canonical hash layout (must match the portable installed runtime exactly):
+//   u64le tick
+//   for each rng stream in pack order: str(id) u32le state
+//   for each live entity (static entities in pack order, then pooled entities
+//   in ascending spawnId):
+//     str(entityRef) u64le spawnId   (entityRef = entity id or template id)
+//     for each component in pack order: str(type) + type-specific state:
+//       Transform2D: 5 x f64le bits (pos.x pos.y vel.x vel.y heading)
+//       TwinStickInput: 4 x f64le (move.x move.y aim.x aim.y), u8 fire
+//       SpawnShield: f64le remaining
+//       Telegraph: f64le remaining
+//       WanderMover: f64le rerollTimer
+//       SeekMover: f64le aliveSeconds
+//       AutoFireWeapon: f64le cooldown, u64le nextBulletId
+//       Lifetime: f64le age
+//       Health: i64le hp
+//       ResourceCounter: i64le score, i64le deaths
+//       (AxisDriveMover, HeadingFromVectors, ArenaBounds, LinearMover,
+//        Emitter, CollisionCircle, ScoreValue, DecayingMultiplier: no state)
+//   tickHash = sha256(buffer) hex; stream digest = sha256 over ascii hex hashes.
+
+import { DETERMINISTIC_MATH_SOURCE } from './kinetix-deterministic-math.mjs';
+import { f64FromHex } from './shared/f64-bits.mjs';
+
+function createDeterministicMathNamespace() {
+  const shadowMath = {};
+  for (const key of Object.getOwnPropertyNames(Math)) shadowMath[key] = Math[key];
+  const shadowGlobal = {};
+  // The shim is an IIFE that patches the Math object it can see; shadowing
+  // Math and globalThis confines the patch to this namespace.
+  new Function('Math', 'globalThis', DETERMINISTIC_MATH_SOURCE)(shadowMath, shadowGlobal);
+  return shadowMath;
+}
+
+export const detMath = createDeterministicMathNamespace();
+
+const TWO_PI = 6.283185307179586;
+
+export function mulberry32Next(state) {
+  const nextState = (state + 0x6d2b79f5) >>> 0;
+  let t = nextState;
+  t = Math.imul(t ^ (t >>> 15), t | 1) >>> 0;
+  t = (t ^ (t + Math.imul(t ^ (t >>> 7), t | 61))) >>> 0;
+  return { state: nextState, value: (t ^ (t >>> 14)) >>> 0 };
+}
+
+function rngFloat(runtime, streamId) {
+  const stream = runtime.rngStreams.get(streamId);
+  const { state, value } = mulberry32Next(stream.state);
+  stream.state = state;
+  return value / 4294967296;
+}
+
+function gaussian(runtime, streamId) {
+  const u1 = Math.max(rngFloat(runtime, streamId), 1e-9);
+  const u2 = rngFloat(runtime, streamId);
+  return Math.sqrt(-2 * detMath.log(u1)) * detMath.cos(TWO_PI * u2);
+}
+
+function decodeF64(value) {
+  return f64FromHex(value);
+}
+
+function decodeVec2(value) {
+  return { x: decodeF64(value[0]), y: decodeF64(value[1]) };
+}
+
+function instantiateComponents(components) {
+  return components.map((component) => {
+    const properties = component.properties;
+    switch (component.type) {
+      case 'Transform2D':
+        return {
+          type: component.type,
+          position: decodeVec2(properties.position),
+          velocity: decodeVec2(properties.velocity),
+          heading: decodeF64(properties.heading),
+        };
+      case 'TwinStickInput':
+        return {
+          type: component.type,
+          moveField: properties.moveField,
+          aimField: properties.aimField,
+          fireField: properties.fireField,
+          slot: properties.slot,
+          move: { x: 0, y: 0 },
+          aim: { x: 0, y: 0 },
+          fire: false,
+        };
+      case 'AxisDriveMover':
+        return { type: component.type, axisField: properties.axisField, maxSpeedPxPerSec: decodeF64(properties.maxSpeedPxPerSec) };
+      case 'HeadingFromVectors':
+        return { type: component.type, aimField: properties.aimField, moveField: properties.moveField };
+      case 'SpawnShield':
+        return { type: component.type, seconds: decodeF64(properties.seconds), remaining: decodeF64(properties.seconds) };
+      case 'WanderMover':
+        return {
+          type: component.type,
+          speedPx: decodeF64(properties.speedPx),
+          rerollSeconds: decodeF64(properties.rerollSeconds),
+          sigmaRad: decodeF64(properties.sigmaRad),
+          rngStream: properties.rngStream,
+          rerollTimer: decodeF64(properties.rerollSeconds),
+        };
+      case 'SeekMover':
+        return {
+          type: component.type,
+          baseSpeedPx: decodeF64(properties.baseSpeedPx),
+          topSpeedPx: decodeF64(properties.topSpeedPx),
+          accelStartSec: decodeF64(properties.accelStartSec),
+          accelEndSec: decodeF64(properties.accelEndSec),
+          aliveSeconds: 0,
+        };
+      case 'Telegraph':
+        return { type: component.type, remaining: decodeF64(properties.seconds) };
+      case 'ArenaBounds':
+        return { type: component.type, mode: properties.mode, useRadius: properties.useRadius };
+      case 'AutoFireWeapon':
+        return {
+          type: component.type,
+          fireIntervalSec: decodeF64(properties.fireIntervalSec),
+          speedPxPerSec: decodeF64(properties.speedPxPerSec),
+          spreadRad: decodeF64(properties.spreadRad),
+          bulletTemplate: properties.bulletTemplate,
+          aimField: properties.aimField,
+          fireField: properties.fireField,
+          slot: properties.slot,
+          cooldown: 0,
+          nextBulletId: 1,
+        };
+      case 'LinearMover':
+        return { type: component.type };
+      case 'Lifetime':
+        return { type: component.type, maxSeconds: decodeF64(properties.maxSeconds), age: 0 };
+      case 'Health':
+        return { type: component.type, hp: properties.hp };
+      case 'Emitter':
+        return {
+          type: component.type,
+          trigger: properties.trigger,
+          template: properties.template,
+          count: properties.count,
+          speedPx: decodeF64(properties.speedPx),
+          extraOffsetPx: decodeF64(properties.extraOffsetPx),
+          pattern: properties.pattern,
+          rngStream: properties.rngStream,
+        };
+      case 'CollisionCircle':
+        return { type: component.type, radius: decodeF64(properties.radius), layer: properties.layer };
+      case 'ScoreValue':
+        return { type: component.type, basePoints: properties.basePoints };
+      case 'ResourceCounter':
+        return { type: component.type, score: BigInt(properties.score), deaths: 0n };
+      case 'DecayingMultiplier':
+        return {
+          type: component.type,
+          increment: decodeF64(properties.increment),
+          cap: decodeF64(properties.cap),
+          decayWindow: decodeF64(properties.decayWindow),
+          value: 1,
+        };
+      default:
+        throw new Error(`Unknown component type ${component.type}`);
+    }
+  });
+}
+
+function makeEntity(ref, spawnId, components) {
+  const entity = {
+    ref,
+    spawnId,
+    components: instantiateComponents(components),
+    fields: new Map(),
+    alive: true,
+    spawnPosition: null,
+  };
+  entity.byType = new Map(entity.components.map((component) => [component.type, component]));
+  const transform = entity.byType.get('Transform2D');
+  if (transform) entity.spawnPosition = { x: transform.position.x, y: transform.position.y };
+  return entity;
+}
+
+export function createF64Runtime(pack, options = {}) {
+  const runtime = {
+    pack,
+    dt: 1 / 60,
+    width: options.arenaWidth ?? 1280,
+    height: options.arenaHeight ?? 720,
+    tick: 0,
+    rngStreams: new Map(pack.rngStreams.map((stream) => [stream.id, { id: stream.id, state: stream.seed >>> 0 }])),
+    rngStreamOrder: pack.rngStreams.map((stream) => stream.id),
+    staticEntities: pack.entities.map((entity) => makeEntity(entity.id, 0n, entity.components)),
+    pooled: [],
+    nextSpawnId: 1n,
+    templates: new Map(pack.templates.map((template) => [template.id, template])),
+    poolCounts: new Map(pack.templates.map((template) => [template.id, 0])),
+    collisionRules: pack.collisionRules,
+    spawnsThisTick: 0,
+    // Render-facing event log for the current tick (spawns, kills, deaths).
+    // Not part of canonical state or hashing; consumed by render cores.
+    frameEvents: [],
+  };
+  return runtime;
+}
+
+export function liveEntities(runtime) {
+  return [...runtime.staticEntities, ...runtime.pooled.filter((entity) => entity.alive)];
+}
+
+function spawnFromTemplate(runtime, templateId, setup) {
+  const template = runtime.templates.get(templateId);
+  const liveOfTemplate = runtime.poolCounts.get(templateId);
+  if (liveOfTemplate >= template.pool) return null;
+  if (runtime.spawnsThisTick >= runtime.pack.budgets.maxSpawnsPerTick) return null;
+  const entity = makeEntity(templateId, runtime.nextSpawnId, template.components);
+  runtime.nextSpawnId += 1n;
+  runtime.spawnsThisTick += 1;
+  runtime.poolCounts.set(templateId, liveOfTemplate + 1);
+  setup(entity);
+  runtime.pooled.push(entity);
+  {
+    const transform = entity.byType.get('Transform2D');
+    if (transform) runtime.frameEvents.push({ type: 'spawned', ref: templateId, x: transform.position.x, y: transform.position.y });
+  }
+  return entity;
+}
+
+function despawn(runtime, entity) {
+  if (!entity.alive) return;
+  entity.alive = false;
+  runtime.poolCounts.set(entity.ref, runtime.poolCounts.get(entity.ref) - 1);
+}
+
+function shipIsShielded(entity) {
+  const shield = entity.byType.get('SpawnShield');
+  return shield ? shield.remaining > 0 : false;
+}
+
+function entityTelegraphing(entity) {
+  const telegraph = entity.byType.get('Telegraph');
+  return telegraph ? telegraph.remaining > 0 : false;
+}
+
+function nearestShipPosition(runtime, from) {
+  let best = null;
+  let bestDistSq = Infinity;
+  for (const entity of runtime.staticEntities) {
+    if (!entity.byType.get('AxisDriveMover')) continue;
+    const transform = entity.byType.get('Transform2D');
+    const dx = transform.position.x - from.x;
+    const dy = transform.position.y - from.y;
+    const distSq = dx * dx + dy * dy;
+    if (distSq < bestDistSq) {
+      bestDistSq = distSq;
+      best = transform.position;
+    }
+  }
+  return best;
+}
+
+function applyBounds(runtime, entity, bounds) {
+  const transform = entity.byType.get('Transform2D');
+  const collision = entity.byType.get('CollisionCircle');
+  const radius = bounds.useRadius && collision ? collision.radius : 0;
+  const position = transform.position;
+  const velocity = transform.velocity;
+  if (bounds.mode === 'clamp') {
+    if (position.x < radius) position.x = radius;
+    if (position.y < radius) position.y = radius;
+    if (position.x > runtime.width - radius) position.x = runtime.width - radius;
+    if (position.y > runtime.height - radius) position.y = runtime.height - radius;
+    return;
+  }
+  if (bounds.mode === 'cull') {
+    if (position.x < 0 || position.x > runtime.width || position.y < 0 || position.y > runtime.height) {
+      despawn(runtime, entity);
+    }
+    return;
+  }
+  if (bounds.mode === 'reflect-negate') {
+    if (position.x < radius) { position.x = radius; velocity.x = -velocity.x; }
+    if (position.y < radius) { position.y = radius; velocity.y = -velocity.y; }
+    if (position.x > runtime.width - radius) { position.x = runtime.width - radius; velocity.x = -velocity.x; }
+    if (position.y > runtime.height - radius) { position.y = runtime.height - radius; velocity.y = -velocity.y; }
+    return;
+  }
+  // reflect-abs
+  if (position.x < radius) { position.x = radius; velocity.x = Math.abs(velocity.x); }
+  if (position.y < radius) { position.y = radius; velocity.y = Math.abs(velocity.y); }
+  if (position.x > runtime.width - radius) { position.x = runtime.width - radius; velocity.x = -Math.abs(velocity.x); }
+  if (position.y > runtime.height - radius) { position.y = runtime.height - radius; velocity.y = -Math.abs(velocity.y); }
+}
+
+// Installed projectile-family deterministic spread.
+function spreadForBullet(id, spreadRad) {
+  const seeded = detMath.sin(id * 12.9898 + 78.233) * 43758.5453;
+  const unit = seeded - Math.floor(seeded);
+  return (unit * 2 - 1) * spreadRad;
+}
+
+function circleHit(a, ra, b, rb) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const r = ra + rb;
+  return dx * dx + dy * dy <= r * r;
+}
+
+function runCollisionPass(runtime, live, action, events) {
+  for (const rule of runtime.collisionRules) {
+    if (rule.action !== action) continue;
+    const groupA = live.filter((entity) => entity.alive && entity.byType.get('CollisionCircle')?.layer === rule.layerA);
+    const groupB = live.filter((entity) => entity.alive && entity.byType.get('CollisionCircle')?.layer === rule.layerB);
+    if (action === 'bullet-kill') {
+      for (const bullet of groupA) {
+        if (!bullet.alive) continue;
+        const bulletCircle = bullet.byType.get('CollisionCircle');
+        const bulletTransform = bullet.byType.get('Transform2D');
+        for (const enemy of groupB) {
+          if (!enemy.alive || entityTelegraphing(enemy)) continue;
+          const enemyCircle = enemy.byType.get('CollisionCircle');
+          const enemyTransform = enemy.byType.get('Transform2D');
+          if (!circleHit(bulletTransform.position, bulletCircle.radius, enemyTransform.position, enemyCircle.radius)) continue;
+          const health = enemy.byType.get('Health');
+          health.hp -= 1;
+          despawn(runtime, bullet);
+          if (health.hp <= 0) {
+            events.push({ kind: 'enemy-killed', entity: enemy });
+          }
+          break;
+        }
+      }
+    } else if (action === 'ship-death') {
+      for (const ship of groupA) {
+        if (shipIsShielded(ship)) continue;
+        const shipCircle = ship.byType.get('CollisionCircle');
+        const shipTransform = ship.byType.get('Transform2D');
+        for (const enemy of groupB) {
+          if (!enemy.alive || entityTelegraphing(enemy)) continue;
+          const enemyCircle = enemy.byType.get('CollisionCircle');
+          const enemyTransform = enemy.byType.get('Transform2D');
+          if (!circleHit(shipTransform.position, shipCircle.radius, enemyTransform.position, enemyCircle.radius)) continue;
+          events.push({ kind: 'ship-death', entity: ship });
+          break;
+        }
+      }
+    }
+  }
+}
+
+function handleDeathEvents(runtime, events) {
+  const game = runtime.staticEntities.find((entity) => entity.byType.get('ResourceCounter'));
+  for (const event of events) {
+    {
+      const transform = event.entity.byType.get('Transform2D');
+      runtime.frameEvents.push({ type: event.kind, ref: event.entity.ref, x: transform.position.x, y: transform.position.y });
+    }
+    if (event.kind === 'enemy-killed') {
+      const emitter = event.entity.byType.get('Emitter');
+      if (emitter && emitter.trigger === 'on-death') {
+        const transform = event.entity.byType.get('Transform2D');
+        const circle = event.entity.byType.get('CollisionCircle');
+        const speed = Math.hypot(transform.velocity.x, transform.velocity.y);
+        const baseAngle = speed > 1
+          ? detMath.atan2(transform.velocity.y, transform.velocity.x)
+          : rngFloat(runtime, emitter.rngStream) * TWO_PI;
+        const phase = rngFloat(runtime, emitter.rngStream) * TWO_PI;
+        const template = runtime.templates.get(emitter.template);
+        const templateCircle = template.components.find((component) => component.type === 'CollisionCircle');
+        const childRadius = templateCircle ? decodeF64(templateCircle.properties.radius) : 0;
+        const spawnOffset = circle.radius + childRadius + emitter.extraOffsetPx;
+        for (let index = 0; index < emitter.count; index += 1) {
+          const angle = baseAngle + phase + (index / emitter.count) * TWO_PI;
+          const cos = detMath.cos(angle);
+          const sin = detMath.sin(angle);
+          spawnFromTemplate(runtime, emitter.template, (child) => {
+            const childTransform = child.byType.get('Transform2D');
+            childTransform.position.x = transform.position.x + cos * spawnOffset;
+            childTransform.position.y = transform.position.y + sin * spawnOffset;
+            childTransform.velocity.x = cos * emitter.speedPx;
+            childTransform.velocity.y = sin * emitter.speedPx;
+          });
+        }
+      }
+      const scoreValue = event.entity.byType.get('ScoreValue');
+      if (scoreValue && game) {
+        game.byType.get('ResourceCounter').score += BigInt(scoreValue.basePoints);
+      }
+      if (event.entity.spawnId === 0n) {
+        event.entity.alive = false;
+      } else {
+        despawn(runtime, event.entity);
+      }
+    } else if (event.kind === 'ship-death') {
+      if (game) game.byType.get('ResourceCounter').deaths += 1n;
+      const transform = event.entity.byType.get('Transform2D');
+      transform.position.x = event.entity.spawnPosition.x;
+      transform.position.y = event.entity.spawnPosition.y;
+      transform.velocity.x = 0;
+      transform.velocity.y = 0;
+      const shield = event.entity.byType.get('SpawnShield');
+      if (shield) shield.remaining = shield.seconds;
+    }
+  }
+}
+
+export function tickF64Runtime(runtime, inputs) {
+  const dt = runtime.dt;
+  runtime.spawnsThisTick = 0;
+  runtime.frameEvents.length = 0;
+  const live = liveEntities(runtime);
+
+  // 1. inputs
+  for (const entity of live) {
+    const twinStick = entity.byType.get('TwinStickInput');
+    if (!twinStick) continue;
+    const slotInput = inputs[twinStick.slot] ?? { movement: { x: 0, y: 0 }, aim: { x: 0, y: 0 }, fire: false };
+    twinStick.move = { x: slotInput.movement.x, y: slotInput.movement.y };
+    twinStick.aim = { x: slotInput.aim.x, y: slotInput.aim.y };
+    twinStick.fire = slotInput.fire === true;
+    entity.fields.set(twinStick.moveField, twinStick.move);
+    entity.fields.set(twinStick.aimField, twinStick.aim);
+    entity.fields.set(twinStick.fireField, twinStick.fire);
+  }
+
+  // 2. shield + telegraph countdowns
+  for (const entity of live) {
+    const shield = entity.byType.get('SpawnShield');
+    if (shield && shield.remaining > 0) shield.remaining = Math.max(0, shield.remaining - dt);
+    const telegraph = entity.byType.get('Telegraph');
+    if (telegraph && telegraph.remaining > 0) telegraph.remaining = Math.max(0, telegraph.remaining - dt);
+  }
+
+  // 3. driven movement
+  for (const entity of live) {
+    const drive = entity.byType.get('AxisDriveMover');
+    if (!drive) continue;
+    const transform = entity.byType.get('Transform2D');
+    const movement = entity.fields.get(drive.axisField) ?? { x: 0, y: 0 };
+    const mag = detMath.hypot(movement.x, movement.y);
+    if (mag > 0.0001) {
+      const nx = movement.x / Math.max(mag, 1);
+      const ny = movement.y / Math.max(mag, 1);
+      transform.position.x += nx * drive.maxSpeedPxPerSec * dt;
+      transform.position.y += ny * drive.maxSpeedPxPerSec * dt;
+    }
+    const bounds = entity.byType.get('ArenaBounds');
+    if (bounds) applyBounds(runtime, entity, bounds);
+    const headingComponent = entity.byType.get('HeadingFromVectors');
+    if (headingComponent) {
+      const aim = entity.fields.get(headingComponent.aimField) ?? { x: 0, y: 0 };
+      const aimMag = detMath.hypot(aim.x, aim.y);
+      if (aimMag > 0.0001) {
+        transform.heading = detMath.atan2(aim.y, aim.x);
+      } else if (mag > 0.0001) {
+        transform.heading = detMath.atan2(movement.y, movement.x);
+      }
+    }
+  }
+
+  // 4. auto-fire (BulletSwarm.autoFire transcription)
+  for (const entity of live) {
+    const weapon = entity.byType.get('AutoFireWeapon');
+    if (!weapon) continue;
+    const fire = entity.fields.get(weapon.fireField) === true;
+    if (!fire) {
+      weapon.cooldown = 0;
+      continue;
+    }
+    const aim = entity.fields.get(weapon.aimField) ?? { x: 0, y: 0 };
+    const aimMag = detMath.hypot(aim.x, aim.y);
+    if (aimMag < 0.0001) continue;
+    const transform = entity.byType.get('Transform2D');
+    let cooldown = weapon.cooldown - dt;
+    let fired = 0;
+    while (cooldown <= 0) {
+      cooldown += weapon.fireIntervalSec;
+      const nx = aim.x / aimMag;
+      const ny = aim.y / aimMag;
+      const bulletId = weapon.nextBulletId;
+      const spread = spreadForBullet(Number(bulletId), weapon.spreadRad);
+      const cos = detMath.cos(spread);
+      const sin = detMath.sin(spread);
+      const sx = nx * cos - ny * sin;
+      const sy = nx * sin + ny * cos;
+      const spawned = spawnFromTemplate(runtime, weapon.bulletTemplate, (bullet) => {
+        const bulletTransform = bullet.byType.get('Transform2D');
+        bulletTransform.position.x = transform.position.x;
+        bulletTransform.position.y = transform.position.y;
+        bulletTransform.velocity.x = sx * weapon.speedPxPerSec;
+        bulletTransform.velocity.y = sy * weapon.speedPxPerSec;
+        bulletTransform.heading = detMath.atan2(sy, sx);
+      });
+      if (spawned === null) break;
+      weapon.nextBulletId += 1;
+      fired += 1;
+      if (fired > 100) break;
+    }
+    weapon.cooldown = cooldown;
+  }
+
+  // refresh live to include this tick's spawns for integration
+  const liveAfterFire = liveEntities(runtime);
+
+  // 5. linear movers integrate + bounds
+  for (const entity of liveAfterFire) {
+    if (!entity.alive || !entity.byType.get('LinearMover')) continue;
+    const transform = entity.byType.get('Transform2D');
+    transform.position.x += transform.velocity.x * dt;
+    transform.position.y += transform.velocity.y * dt;
+    const lifetime = entity.byType.get('Lifetime');
+    if (lifetime) lifetime.age += dt;
+    const bounds = entity.byType.get('ArenaBounds');
+    if (bounds) applyBounds(runtime, entity, bounds);
+  }
+
+  const events = [];
+  // 6. pre-AI bullet collisions
+  runCollisionPass(runtime, liveAfterFire, 'bullet-kill', events);
+  handleDeathEvents(runtime, events);
+  events.length = 0;
+
+  // 7. steering behaviors
+  for (const entity of liveEntities(runtime)) {
+    if (!entity.alive || entityTelegraphing(entity)) continue;
+    const wander = entity.byType.get('WanderMover');
+    if (wander) {
+      const transform = entity.byType.get('Transform2D');
+      wander.rerollTimer -= dt;
+      if (wander.rerollTimer <= 0) {
+        wander.rerollTimer += wander.rerollSeconds;
+        const current = detMath.atan2(transform.velocity.y, transform.velocity.x);
+        const nudged = current + gaussian(runtime, wander.rngStream) * wander.sigmaRad;
+        transform.velocity.x = detMath.cos(nudged) * wander.speedPx;
+        transform.velocity.y = detMath.sin(nudged) * wander.speedPx;
+      }
+      transform.position.x += transform.velocity.x * dt;
+      transform.position.y += transform.velocity.y * dt;
+      const bounds = entity.byType.get('ArenaBounds');
+      if (bounds) applyBounds(runtime, entity, bounds);
+    }
+    const seek = entity.byType.get('SeekMover');
+    if (seek) {
+      const transform = entity.byType.get('Transform2D');
+      seek.aliveSeconds += dt;
+      const t = seek.aliveSeconds;
+      let speed = seek.baseSpeedPx;
+      if (t > seek.accelStartSec) {
+        const lerp = Math.min(1, (t - seek.accelStartSec) / (seek.accelEndSec - seek.accelStartSec));
+        speed = seek.baseSpeedPx + (seek.topSpeedPx - seek.baseSpeedPx) * lerp;
+      }
+      const target = nearestShipPosition(runtime, transform.position);
+      if (target) {
+        const dx = target.x - transform.position.x;
+        const dy = target.y - transform.position.y;
+        const mag = detMath.hypot(dx, dy);
+        if (mag > 0.0001) {
+          transform.velocity.x = (dx / mag) * speed;
+          transform.velocity.y = (dy / mag) * speed;
+        }
+      }
+      transform.position.x += transform.velocity.x * dt;
+      transform.position.y += transform.velocity.y * dt;
+      const bounds = entity.byType.get('ArenaBounds');
+      if (bounds) applyBounds(runtime, entity, bounds);
+    }
+  }
+
+  // 8. post-AI collisions
+  const liveAfterAi = liveEntities(runtime);
+  runCollisionPass(runtime, liveAfterAi, 'bullet-kill', events);
+  runCollisionPass(runtime, liveAfterAi, 'ship-death', events);
+  handleDeathEvents(runtime, events);
+  events.length = 0;
+
+  // 9. lifetimes
+  for (const entity of liveEntities(runtime)) {
+    const lifetime = entity.byType.get('Lifetime');
+    if (lifetime && lifetime.age >= lifetime.maxSeconds) despawn(runtime, entity);
+  }
+
+  runtime.pooled = runtime.pooled.filter((entity) => entity.alive);
+  runtime.tick += 1;
+}
+
+export { f64FromHex };