@irtio/runtime 0.6.0 → 0.8.0

package/dist/{chunk-K42HA75G.js → chunk-ZCD2TBXB.js}

@@ -143,10 +143,10 @@ function handleCall(core, clientId, payload) {
       return true;
     }
   }
-  const ctx = core.ctxFor(clientId);
+  const ctx = { ...core.ctxFor(clientId), clientTick: call.clientTick || void 0 };
   let result;
   if (desc.name === REQUEST_OWNERSHIP) {
-    result = runRequestOwnership(core, clientId, params);
+    result = runRequestOwnership(core, clientId, ctx, params);
   } else {
     const impl = core.definition.config.rpc?.[desc.name];
     if (!impl) {
@@ -175,7 +175,7 @@ function handleCall(core, clientId, payload) {
   }
   return true;
 }
-function runRequestOwnership(core, clientId, params) {
+function runRequestOwnership(core, clientId, ctx, params) {
   const name = String(params.entity ?? "");
   const id = String(params.id ?? "");
   const c = collectionDescOf(core.ext, name);
@@ -185,10 +185,7 @@ function runRequestOwnership(core, clientId, params) {
   const handler = core.definition.config.onOwnershipRequest;
   const tracked = trackedEntity(core, name);
   if (handler) {
-    const ran = core.tryRun(
-      "onOwnershipRequest",
-      () => handler(core.anyState, name, id, core.ctxFor(clientId))
-    );
+    const ran = core.tryRun("onOwnershipRequest", () => handler(core.anyState, name, id, ctx));
     if (ran.ok && ran.value === true && plain.ownerOf(id) !== clientId) {
       tracked.setOwner(id, clientId);
     }
@@ -762,6 +759,7 @@ var Loop = class {
         physics.reconcile();
         physics.step();
         physics.sync();
+        this.core.captureHistory();
       });
       if (!ran.ok) {
         failed = failed === void 0 ? "the physics step" : `${failed} and the physics step`;
@@ -1054,6 +1052,20 @@ var MatterRuntime = class {
     }
     return spec.body;
   }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: every tracked body, in the order `sync()` walks them. The matter half of the same
+   * read-only accessor `PhysicsRuntime` carries; see its comment for what calls it and when.
+   */
+  eachTrackedBody(fn) {
+    for (const desc of this.collections) {
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      for (const id of plainColl.ids()) {
+        const attached = this.bodies.get(bodyKey(desc.name, id));
+        if (attached) fn(desc.name, id, attached.body);
+      }
+    }
+  }
   applyState(body, s) {
     const M = this.matter;
     M.Body.setPosition(body, { x: s.x, y: s.y });
@@ -1243,9 +1255,28 @@ function encodePhysicsSection(section) {
   return w.finish();
 }
 var MATTER_TAG = 1;
+var RAPIER2D_TAG = 2;
 function physicsSectionEngine(bytes) {
   const r = new ByteReader2(bytes);
-  return r.varint() === 0 && r.u8() === MATTER_TAG ? "matter2d" : "rapier3d";
+  if (r.varint() !== 0) return "rapier3d";
+  const tag = r.u8();
+  if (tag === MATTER_TAG) return "matter2d";
+  if (tag === RAPIER2D_TAG) return "rapier2d";
+  return "rapier3d";
+}
+function encodeRapier2dSectionEnvelope(payload) {
+  const w = new ByteWriter2(payload.length + 8);
+  w.varint(0);
+  w.u8(RAPIER2D_TAG);
+  w.bytes(payload);
+  return w.finish();
+}
+function decodeRapier2dSectionEnvelope(bytes) {
+  const r = new ByteReader2(bytes);
+  if (r.varint() !== 0 || r.u8() !== RAPIER2D_TAG) {
+    throw new Error("irtio: this physics section was not written by rapier2d");
+  }
+  return r.rest();
 }
 function encodeMatterSectionEnvelope(payload) {
   const w = new ByteWriter2(payload.length + 8);
@@ -1396,6 +1427,22 @@ var PhysicsRuntime = class {
     this.bodies.set(bodyKey2(desc.name, id), body);
     return body;
   }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
+   * order). Read-only: it hands out the live bodies and nothing else, and the map stays private.
+   * The pose history calls this once per tick and the rewind scratch calls it per rewind; a room
+   * that declares no `physics.history` never calls it at all.
+   */
+  eachTrackedBody(fn) {
+    for (const desc of this.collections) {
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      for (const id of plainColl.ids()) {
+        const body = this.bodies.get(bodyKey2(desc.name, id));
+        if (body) fn(desc.name, id, body);
+      }
+    }
+  }
   applyRecordToBody(desc, body, record) {
     const physics = desc.physics;
     if (!physics) return;
@@ -1599,6 +1646,262 @@ var Mulberry32 = class {
   }
 };
 
+// src/core/rapier2d.ts
+import { angleFrom2d, applyChannel2d as applyChannel2d2, channelOf2d as channelOf2d2 } from "@irtio/schema";
+var engine3;
+var loading3;
+async function initRapier2d() {
+  if (engine3) return engine3;
+  loading3 ??= (async () => {
+    const mod = await import("@dimforge/rapier2d-compat");
+    const ns = mod.default ?? mod;
+    await ns.init();
+    engine3 = ns;
+    return ns;
+  })();
+  return loading3;
+}
+function loadedRapier2d() {
+  return engine3;
+}
+function resetRapier2dForTests() {
+  engine3 = void 0;
+  loading3 = void 0;
+}
+function bodyKey3(collection, id) {
+  return `${collection}\0${id}`;
+}
+var Rapier2dRuntime = class {
+  engineKind = "rapier2d";
+  /** matter2d only; present so every runtime satisfies one internal shape. */
+  matter = void 0;
+  matterEngine = void 0;
+  rapier;
+  world;
+  /** `true` when the world was built from scratch and `setup` has to run. */
+  rebuilt;
+  /** Rapier restores a whole world, contacts included, so `setup` runs only on a rebuild. */
+  get needsSetup() {
+    return this.rebuilt;
+  }
+  core;
+  config;
+  /** Physics-backed collections, in schema (name-sorted) order. */
+  collections;
+  bodies = /* @__PURE__ */ new Map();
+  /** See `PhysicsRuntime.sleepSynced`: the one extra sync a body owes on the tick it sleeps. */
+  sleepSynced = /* @__PURE__ */ new Set();
+  constructor(core, rapier, options) {
+    const config = core.definition.config.physics;
+    if (!config) throw new Error("Rapier2dRuntime: the room config declares no physics");
+    this.core = core;
+    this.config = config;
+    this.rapier = rapier;
+    this.collections = core.ext.collections.filter(
+      (c) => c.physics !== void 0
+    );
+    if (options.restore) {
+      this.world = rapier.World.restoreSnapshot(options.restore.world);
+      this.rebuilt = false;
+      for (const [name, id, handle] of options.restore.bodies) {
+        const body = this.world.getRigidBody(handle);
+        if (body) this.bodies.set(bodyKey3(name, id), body);
+      }
+    } else {
+      const g = config.gravity;
+      this.world = new rapier.World({ x: g.x, y: g.y });
+      this.rebuilt = true;
+    }
+    this.world.timestep = config.timestep ?? options.defaultTimestep;
+  }
+  get timestep() {
+    return this.world.timestep;
+  }
+  /** Runs the room's `setup` — static geometry — on a world that was built rather than restored. */
+  runSetup(room) {
+    const setup = this.config.setup;
+    if (!setup) return;
+    this.core.guard("physics.setup", () => setup(this.world, this.rapier, room));
+  }
+  free() {
+    this.bodies.clear();
+    this.world.free();
+  }
+  // -------------------------------------------------------------------------
+  // Bodies
+  // -------------------------------------------------------------------------
+  /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
+  bodyFor(collection, id) {
+    const existing = this.bodies.get(bodyKey3(collection, id));
+    if (existing) return existing;
+    const desc = this.collections.find((c) => c.name === collection);
+    if (!desc) return void 0;
+    const coll = plainEntity(this.core.plain, collection);
+    const record = coll.get(id);
+    if (record === void 0) return void 0;
+    return this.create(desc, id, record);
+  }
+  create(desc, id, record) {
+    const factory = this.config.bodies?.[desc.name];
+    if (!factory) {
+      this.core.log("error", `irtio: physics.bodies.${desc.name} is missing; no body created`);
+      return void 0;
+    }
+    const spec = this.core.guard(
+      `physics.bodies.${desc.name}`,
+      () => factory(this.rapier, record, id)
+    );
+    if (!spec || !spec.body) {
+      this.core.log(
+        "error",
+        `irtio: physics.bodies.${desc.name} returned no { body } for ${JSON.stringify(id)}`
+      );
+      return void 0;
+    }
+    const body = this.world.createRigidBody(spec.body);
+    for (const collider of spec.colliders ?? []) this.world.createCollider(collider, body);
+    this.applyRecordToBody(desc, body, record);
+    this.bodies.set(bodyKey3(desc.name, id), body);
+    return body;
+  }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
+   * order). The rapier2d third of the same read-only accessor the other two runtimes carry.
+   */
+  eachTrackedBody(fn) {
+    for (const desc of this.collections) {
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      for (const id of plainColl.ids()) {
+        const body = this.bodies.get(bodyKey3(desc.name, id));
+        if (body) fn(desc.name, id, body);
+      }
+    }
+  }
+  applyRecordToBody(desc, body, record) {
+    const physics = desc.physics;
+    if (!physics) return;
+    const t = body.translation();
+    const v = body.linvel();
+    const angle = body.rotation();
+    const target = {
+      x: t.x,
+      y: t.y,
+      qz: Math.sin(angle / 2),
+      qw: Math.cos(angle / 2),
+      vx: v.x,
+      vy: v.y,
+      wz: body.angvel()
+    };
+    for (const [channel, field] of physics.channels) {
+      const raw = record[field];
+      if (typeof raw !== "number") continue;
+      applyChannel2d2(channel, raw, target);
+    }
+    body.setTranslation({ x: target.x, y: target.y }, true);
+    body.setRotation(angleFrom2d(target.qz, target.qw), true);
+    body.setLinvel({ x: target.vx, y: target.vy }, true);
+    body.setAngvel(target.wz, true);
+  }
+  /**
+   * Creates bodies for new instances and destroys bodies whose instance is gone. Runs once per
+   * tick, right before the step, in collection order then instance order.
+   */
+  reconcile() {
+    const live = /* @__PURE__ */ new Set();
+    for (const desc of this.collections) {
+      const coll = plainEntity(this.core.plain, desc.name);
+      for (const id of coll.ids()) {
+        const key = bodyKey3(desc.name, id);
+        live.add(key);
+        if (this.bodies.has(key)) continue;
+        const record = coll.get(id);
+        if (record !== void 0) this.create(desc, id, record);
+      }
+    }
+    for (const [key, body] of [...this.bodies]) {
+      if (live.has(key)) continue;
+      this.bodies.delete(key);
+      this.sleepSynced.delete(key);
+      this.world.removeRigidBody(body);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Step and sync
+  // -------------------------------------------------------------------------
+  step() {
+    this.world.step();
+    if (!rapierHasStepped()) noteRapierStep();
+  }
+  /**
+   * Body → schema, through the tracked proxies, so movement leaves the room as an ordinary delta.
+   * Values are `Math.fround`ed for f32 fields, so room code reads exactly what the wire carries.
+   */
+  sync() {
+    for (const desc of this.collections) {
+      const physics = desc.physics;
+      if (!physics) continue;
+      const tracked = this.core.anyState[desc.name];
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      const rounders = roundersFor3(desc);
+      for (const id of plainColl.ids()) {
+        const key = bodyKey3(desc.name, id);
+        const body = this.bodies.get(key);
+        if (!body) continue;
+        if (body.isSleeping()) {
+          if (this.sleepSynced.has(key)) continue;
+          this.sleepSynced.add(key);
+        } else {
+          this.sleepSynced.delete(key);
+        }
+        const record = tracked.get(id);
+        if (!record) continue;
+        const t = body.translation();
+        const v = body.linvel();
+        const state = {
+          x: t.x,
+          y: t.y,
+          angle: body.rotation(),
+          vx: v.x,
+          vy: v.y,
+          angularVelocity: body.angvel()
+        };
+        for (const [channel, field] of physics.channels) {
+          const next = (rounders[field] ?? identity3)(channelOf2d2(channel, state));
+          if (record[field] !== next) record[field] = next;
+        }
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Hibernation
+  // -------------------------------------------------------------------------
+  /**
+   * The same `PhysicsSection` the 3D runtime writes — a real engine snapshot plus the
+   * entity↔handle map, whose handles must ride as f64 for the reason spelled out on
+   * {@link PhysicsSection}. What tells the two apart on the way back in is the envelope
+   * `core/physics.ts` wraps this in, not anything in here.
+   */
+  serialize() {
+    const bodies = [];
+    for (const [key, body] of this.bodies) {
+      const sep = key.indexOf("\0");
+      bodies.push([key.slice(0, sep), key.slice(sep + 1), body.handle]);
+    }
+    return { world: this.world.takeSnapshot(), bodies };
+  }
+};
+function identity3(v) {
+  return v;
+}
+function roundersFor3(desc) {
+  const out = {};
+  for (const f of desc.fields) {
+    if (f.type.kind === "f32") out[f.name] = Math.fround;
+  }
+  return out;
+}
+
 // src/core/views.ts
 import {
   collectionDirty,
@@ -1963,8 +2266,723 @@ import {
   validateForDeploy
 } from "@irtio/schema";
 
+// src/core/history.ts
+var HISTORY_MAX_TICKS = 240;
+var STRIDE = 13;
+function emptyPose() {
+  return { x: 0, y: 0, z: 0, qx: 0, qy: 0, qz: 0, qw: 1, vx: 0, vy: 0, vz: 0, wx: 0, wy: 0, wz: 0 };
+}
+function newEntry() {
+  return { tick: -1, count: 0, collections: [], ids: [], values: new Float64Array(0) };
+}
+var PoseHistory = class {
+  depth;
+  entries = [];
+  /** Index of the newest entry in `entries`, or -1 when nothing has been captured. */
+  head = -1;
+  size = 0;
+  /** Reused across every body of every capture: the capture path allocates nothing per body. */
+  scratchPose = emptyPose();
+  constructor(depth) {
+    this.depth = Math.max(1, Math.min(HISTORY_MAX_TICKS, Math.floor(depth)));
+    for (let i = 0; i < this.depth; i++) this.entries.push(newEntry());
+  }
+  get length() {
+    return this.size;
+  }
+  /** The newest tick captured, or `undefined` when the buffer is empty. */
+  get newestTick() {
+    return this.size === 0 ? void 0 : this.entries[this.head].tick;
+  }
+  /** The oldest tick still held, or `undefined` when the buffer is empty. */
+  get oldestTick() {
+    if (this.size === 0) return void 0;
+    const i = (this.head - (this.size - 1) + this.depth * 2) % this.depth;
+    return this.entries[i].tick;
+  }
+  /** Drops everything. Used by the hibernation path, where a buffer cannot survive. */
+  clear() {
+    this.head = -1;
+    this.size = 0;
+  }
+  /** Captures one tick's poses off the live runtime. Called right after `physics.sync()`. */
+  capture(tick, physics) {
+    this.head = this.size === 0 ? 0 : (this.head + 1) % this.depth;
+    if (this.size < this.depth) this.size++;
+    const entry = this.entries[this.head];
+    entry.tick = tick;
+    entry.count = 0;
+    const pose = this.scratchPose;
+    const kind = physics.engineKind;
+    physics.eachTrackedBody((collection, id, body) => {
+      if (kind === "rapier3d") readRapierPose(body, pose);
+      else if (kind === "rapier2d") readRapier2dPose(body, pose);
+      else readMatterPose(body, pose);
+      this.push(entry, collection, id, pose);
+    });
+  }
+  push(entry, collection, id, pose) {
+    const i = entry.count;
+    const need = (i + 1) * STRIDE;
+    if (entry.values.length < need) {
+      const grown = new Float64Array(Math.max(need, entry.values.length * 2, STRIDE * 8));
+      grown.set(entry.values);
+      entry.values = grown;
+    }
+    entry.collections[i] = collection;
+    entry.ids[i] = id;
+    const v = entry.values;
+    const o = i * STRIDE;
+    v[o] = pose.x;
+    v[o + 1] = pose.y;
+    v[o + 2] = pose.z;
+    v[o + 3] = pose.qx;
+    v[o + 4] = pose.qy;
+    v[o + 5] = pose.qz;
+    v[o + 6] = pose.qw;
+    v[o + 7] = pose.vx;
+    v[o + 8] = pose.vy;
+    v[o + 9] = pose.vz;
+    v[o + 10] = pose.wx;
+    v[o + 11] = pose.wy;
+    v[o + 12] = pose.wz;
+    entry.count = i + 1;
+  }
+  /**
+   * The entry a rewind to `requested` answers from, clamped into the window the buffer actually
+   * holds. `undefined` only when nothing has been captured at all.
+   */
+  resolve(requested) {
+    if (this.size === 0) return void 0;
+    const newest = this.entries[this.head].tick;
+    const oldest = this.oldestTick;
+    const want = Number.isFinite(requested) ? Math.floor(requested) : newest;
+    const tick = want < oldest ? oldest : want > newest ? newest : want;
+    const entry = this.at(tick);
+    if (!entry) return void 0;
+    return { entry, tick: entry.tick, clamped: tick !== want };
+  }
+  /**
+   * The entry for exactly `tick`. Index arithmetic first (captures are one tick apart, so the
+   * offset from the head is the tick difference), with a scan as insurance: a room whose loop
+   * ever skipped a capture would otherwise be answered with the wrong tick's poses, and answering
+   * for a tick that was not recorded is the one thing this buffer must never do.
+   */
+  at(tick) {
+    const newest = this.entries[this.head].tick;
+    const offset = newest - tick;
+    if (offset >= 0 && offset < this.size) {
+      const e = this.entries[(this.head - offset + this.depth * 2) % this.depth];
+      if (e.tick === tick) return e;
+    }
+    for (let k = 0; k < this.size; k++) {
+      const e = this.entries[(this.head - k + this.depth * 2) % this.depth];
+      if (e.tick === tick) return e;
+    }
+    return void 0;
+  }
+};
+function poseAt(entry, index, into) {
+  const v = entry.values;
+  const o = index * STRIDE;
+  into.x = v[o];
+  into.y = v[o + 1];
+  into.z = v[o + 2];
+  into.qx = v[o + 3];
+  into.qy = v[o + 4];
+  into.qz = v[o + 5];
+  into.qw = v[o + 6];
+  into.vx = v[o + 7];
+  into.vy = v[o + 8];
+  into.vz = v[o + 9];
+  into.wx = v[o + 10];
+  into.wy = v[o + 11];
+  into.wz = v[o + 12];
+}
+function readRapierPose(body, into) {
+  const t = body.translation();
+  const r = body.rotation();
+  const v = body.linvel();
+  const w = body.angvel();
+  into.x = t.x;
+  into.y = t.y;
+  into.z = t.z;
+  into.qx = r.x;
+  into.qy = r.y;
+  into.qz = r.z;
+  into.qw = r.w;
+  into.vx = v.x;
+  into.vy = v.y;
+  into.vz = v.z;
+  into.wx = w.x;
+  into.wy = w.y;
+  into.wz = w.z;
+}
+function readRapier2dPose(body, into) {
+  const t = body.translation();
+  const angle = body.rotation();
+  const v = body.linvel();
+  into.x = t.x;
+  into.y = t.y;
+  into.z = 0;
+  into.qx = 0;
+  into.qy = 0;
+  into.qz = Math.sin(angle / 2);
+  into.qw = Math.cos(angle / 2);
+  into.vx = v.x;
+  into.vy = v.y;
+  into.vz = 0;
+  into.wx = 0;
+  into.wy = 0;
+  into.wz = body.angvel();
+}
+function readMatterPose(body, into) {
+  into.x = body.position.x;
+  into.y = body.position.y;
+  into.z = 0;
+  into.qx = 0;
+  into.qy = 0;
+  into.qz = Math.sin(body.angle / 2);
+  into.qw = Math.cos(body.angle / 2);
+  into.vx = body.velocity.x;
+  into.vy = body.velocity.y;
+  into.vz = 0;
+  into.wx = 0;
+  into.wy = 0;
+  into.wz = body.angularVelocity;
+}
+function historyDepthOf(config) {
+  const declared = config?.history;
+  if (typeof declared !== "number" || !Number.isFinite(declared) || declared <= 0) return void 0;
+  return Math.min(HISTORY_MAX_TICKS, Math.floor(declared));
+}
+function keyOf(collection, id) {
+  return `${collection} ${id}`;
+}
+function angleOf(qz, qw) {
+  return 2 * Math.atan2(qz, qw);
+}
+var BaseScratch = class {
+  constructor(physics, depth, tickNow) {
+    this.physics = physics;
+    this.depth = depth;
+    this.tickNow = tickNow;
+  }
+  physics;
+  depth;
+  tickNow;
+  bodies = /* @__PURE__ */ new Map();
+  present = /* @__PURE__ */ new Set();
+  pose = emptyPose();
+  view(entry, tick, requested, clamped) {
+    this.sync();
+    this.present.clear();
+    for (let i = 0; i < entry.count; i++) {
+      const key = keyOf(entry.collections[i], entry.ids[i]);
+      const e = this.bodies.get(key);
+      if (!e) continue;
+      poseAt(entry, i, this.pose);
+      this.place(e, this.pose);
+      this.present.add(key);
+    }
+    for (const [key, e] of this.bodies) {
+      if (!this.present.has(key)) this.hide(e);
+    }
+    return this.build(tick, requested, clamped);
+  }
+  /**
+   * Brings the scratch's body set in step with the live world: a double for every live body that
+   * has none, a rebuild for one whose collider (or part) count changed, and a prune for one that
+   * has been gone longer than the history is deep and so can no longer appear in any entry.
+   *
+   * The prune is conservative rather than exact: `lastLive` only advances when a rewind happens,
+   * so a room that rewinds rarely holds its dead doubles a little longer than it strictly must.
+   * Over-retention is a few hundred bytes; under-retention would be a wrong answer.
+   */
+  sync() {
+    const now = this.tickNow();
+    const seen = /* @__PURE__ */ new Set();
+    this.physics.eachTrackedBody((collection, id, body) => {
+      const key = keyOf(collection, id);
+      seen.add(key);
+      const parts = this.partsOf(body);
+      const existing = this.bodies.get(key);
+      if (existing && existing.parts === parts) {
+        existing.lastLive = now;
+        return;
+      }
+      if (existing) {
+        this.bodies.delete(key);
+        this.destroy(existing);
+      }
+      const made = this.clone(collection, id, body, parts);
+      if (!made) return;
+      made.lastLive = now;
+      this.bodies.set(key, made);
+    });
+    for (const [key, e] of [...this.bodies]) {
+      if (seen.has(key)) continue;
+      if (now - e.lastLive <= this.depth) continue;
+      this.bodies.delete(key);
+      this.destroy(e);
+    }
+  }
+};
+function qConj(q) {
+  return { x: -q.x, y: -q.y, z: -q.z, w: q.w };
+}
+function qMul(a, b) {
+  return {
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  };
+}
+function qRotate(q, v) {
+  const p = qMul(qMul(q, { x: v.x, y: v.y, z: v.z, w: 0 }), qConj(q));
+  return { x: p.x, y: p.y, z: p.z };
+}
+var RapierScratch = class extends BaseScratch {
+  world;
+  rapier;
+  owners = /* @__PURE__ */ new Map();
+  /** Live rigid-body handles the room tracks, so the statics pass knows what to skip. */
+  trackedLive = /* @__PURE__ */ new Set();
+  staticsCloned = false;
+  constructor(physics, depth, tickNow) {
+    super(physics, depth, tickNow);
+    this.rapier = physics.rapier;
+    this.world = new this.rapier.World({ x: 0, y: 0, z: 0 });
+    this.world.timestep = 0;
+  }
+  partsOf(body) {
+    return body.numColliders();
+  }
+  clone(collection, id, body, parts) {
+    const live = body;
+    this.trackedLive.add(live.handle);
+    const made = this.world.createRigidBody(this.rapier.RigidBodyDesc.fixed());
+    const origin = live.translation();
+    const rot = live.rotation();
+    const inv = qConj(rot);
+    for (let i = 0; i < parts; i++) {
+      const c = live.collider(i);
+      const desc = new this.rapier.ColliderDesc(c.shape);
+      desc.setSensor(c.isSensor());
+      const w = c.translation();
+      const local = qRotate(inv, { x: w.x - origin.x, y: w.y - origin.y, z: w.z - origin.z });
+      desc.setTranslation(local.x, local.y, local.z);
+      desc.setRotation(qMul(inv, c.rotation()));
+      this.world.createCollider(desc, made);
+    }
+    this.owners.set(made.handle, { collection, id });
+    return { collection, id, body: made, parts, lastLive: -1 };
+  }
+  place(entry, pose) {
+    const b = entry.body;
+    if (!b.isEnabled()) b.setEnabled(true);
+    b.setTranslation({ x: pose.x, y: pose.y, z: pose.z }, false);
+    b.setRotation({ x: pose.qx, y: pose.qy, z: pose.qz, w: pose.qw }, false);
+  }
+  /**
+   * A body the requested tick did not have. `setEnabled(false)` takes the body and its colliders
+   * out of the broad phase, so a query cannot hit it, which is the whole point: a body created
+   * after the tick the shooter was looking at was not on their screen and must not be hittable.
+   */
+  hide(entry) {
+    if (entry.body.isEnabled()) entry.body.setEnabled(false);
+  }
+  destroy(entry) {
+    this.owners.delete(entry.body.handle);
+    this.world.removeRigidBody(entry.body);
+  }
+  build(tick, requested, clamped) {
+    this.cloneStatics();
+    this.world.step();
+    const owners = this.owners;
+    return {
+      tick,
+      requested,
+      clamped,
+      rapier: {
+        world: this.world,
+        who: (collider) => {
+          const parent = collider.parent();
+          return parent ? owners.get(parent.handle) : void 0;
+        }
+      }
+    };
+  }
+  /**
+   * The live world's static geometry, everything `physics.setup` built, copied in once at the
+   * first rewind. It is "as it stands now" rather than "as it stood then": static colliders do not
+   * move, and a room that moves one has told the engine something that is not true.
+   */
+  cloneStatics() {
+    if (this.staticsCloned) return;
+    this.staticsCloned = true;
+    const live = this.physics.world;
+    if (!live) return;
+    live.forEachCollider((c) => {
+      const parent = c.parent();
+      if (parent !== null && (!parent.isFixed() || this.trackedLive.has(parent.handle))) return;
+      const desc = new this.rapier.ColliderDesc(c.shape);
+      desc.setSensor(c.isSensor());
+      const t = c.translation();
+      desc.setTranslation(t.x, t.y, t.z);
+      desc.setRotation(c.rotation());
+      this.world.createCollider(desc);
+    });
+  }
+  free() {
+    this.owners.clear();
+    this.world.free();
+  }
+};
+var Rapier2dScratch = class extends BaseScratch {
+  world;
+  rapier;
+  owners = /* @__PURE__ */ new Map();
+  /** Live rigid-body handles the room tracks, so the statics pass knows what to skip. */
+  trackedLive = /* @__PURE__ */ new Set();
+  staticsCloned = false;
+  constructor(physics, depth, tickNow) {
+    super(physics, depth, tickNow);
+    this.rapier = physics.rapier;
+    this.world = new this.rapier.World({ x: 0, y: 0 });
+    this.world.timestep = 0;
+  }
+  partsOf(body) {
+    return body.numColliders();
+  }
+  clone(collection, id, body, parts) {
+    const live = body;
+    this.trackedLive.add(live.handle);
+    const made = this.world.createRigidBody(this.rapier.RigidBodyDesc.fixed());
+    const origin = live.translation();
+    const angle = live.rotation();
+    const cos = Math.cos(-angle);
+    const sin = Math.sin(-angle);
+    for (let i = 0; i < parts; i++) {
+      const c = live.collider(i);
+      const desc = new this.rapier.ColliderDesc(c.shape);
+      desc.setSensor(c.isSensor());
+      const w = c.translation();
+      const dx = w.x - origin.x;
+      const dy = w.y - origin.y;
+      desc.setTranslation(dx * cos - dy * sin, dx * sin + dy * cos);
+      desc.setRotation(c.rotation() - angle);
+      this.world.createCollider(desc, made);
+    }
+    this.owners.set(made.handle, { collection, id });
+    return { collection, id, body: made, parts, lastLive: -1 };
+  }
+  place(entry, pose) {
+    const b = entry.body;
+    if (!b.isEnabled()) b.setEnabled(true);
+    b.setTranslation({ x: pose.x, y: pose.y }, false);
+    b.setRotation(angleOf(pose.qz, pose.qw), false);
+  }
+  hide(entry) {
+    if (entry.body.isEnabled()) entry.body.setEnabled(false);
+  }
+  destroy(entry) {
+    this.owners.delete(entry.body.handle);
+    this.world.removeRigidBody(entry.body);
+  }
+  build(tick, requested, clamped) {
+    this.cloneStatics();
+    this.world.step();
+    const owners = this.owners;
+    return {
+      tick,
+      requested,
+      clamped,
+      rapier2d: {
+        world: this.world,
+        who: (collider) => {
+          const parent = collider.parent();
+          return parent ? owners.get(parent.handle) : void 0;
+        }
+      }
+    };
+  }
+  cloneStatics() {
+    if (this.staticsCloned) return;
+    this.staticsCloned = true;
+    const live = this.physics.world;
+    if (!live) return;
+    live.forEachCollider((c) => {
+      const parent = c.parent();
+      if (parent !== null && (!parent.isFixed() || this.trackedLive.has(parent.handle))) return;
+      const desc = new this.rapier.ColliderDesc(c.shape);
+      desc.setSensor(c.isSensor());
+      const t = c.translation();
+      desc.setTranslation(t.x, t.y);
+      desc.setRotation(c.rotation());
+      this.world.createCollider(desc);
+    });
+  }
+  free() {
+    this.owners.clear();
+    this.world.free();
+  }
+};
+var MatterScratch = class extends BaseScratch {
+  matter;
+  owners = /* @__PURE__ */ new Map();
+  /** Rebuilt per rewind: the doubles the requested tick actually had, plus the live statics. */
+  visible = [];
+  constructor(physics, depth, tickNow) {
+    super(physics, depth, tickNow);
+    this.matter = physics.matter;
+  }
+  partsOf(body) {
+    return body.parts.length;
+  }
+  clone(collection, id, body, parts) {
+    const M = this.matter;
+    const live = body;
+    const made = live.parts.length > 1 ? M.Body.create({ parts: live.parts.slice(1).map((p) => this.clonePart(p, live.angle)) }) : this.clonePart(live, live.angle);
+    M.Body.setPosition(made, { x: 0, y: 0 });
+    made.angle = 0;
+    for (const p of made.parts) p.angle = 0;
+    this.owners.set(made, { collection, id });
+    return { collection, id, body: made, parts, lastLive: -1 };
+  }
+  /** One part, un-rotated by the parent's angle so the double starts at angle 0. */
+  clonePart(part, parentAngle) {
+    const M = this.matter;
+    const verts = part.vertices.map((v) => ({ x: v.x, y: v.y }));
+    if (parentAngle !== 0) M.Vertices.rotate(verts, -parentAngle, part.position);
+    const made = M.Body.create({});
+    M.Body.setVertices(made, verts);
+    return made;
+  }
+  place(entry, pose) {
+    const M = this.matter;
+    M.Body.setAngle(entry.body, angleOf(pose.qz, pose.qw));
+    M.Body.setPosition(entry.body, { x: pose.x, y: pose.y });
+    this.visible.push(entry.body);
+  }
+  /** Nothing to undo: `visible` is rebuilt per rewind, so a body nobody placed is not in it. */
+  hide() {
+  }
+  destroy(entry) {
+    this.owners.delete(entry.body);
+  }
+  view(entry, tick, requested, clamped) {
+    this.visible.length = 0;
+    return super.view(entry, tick, requested, clamped);
+  }
+  build(tick, requested, clamped) {
+    const M = this.matter;
+    const engine4 = this.physics.matterEngine;
+    if (engine4) {
+      for (const b of M.Composite.allBodies(engine4.world)) {
+        if (b.isStatic) this.visible.push(b);
+      }
+    }
+    const owners = this.owners;
+    return {
+      tick,
+      requested,
+      clamped,
+      matter: {
+        bodies: this.visible,
+        who: (body) => owners.get(body)
+      }
+    };
+  }
+  free() {
+    this.owners.clear();
+    this.visible.length = 0;
+  }
+};
+var RewindState = class {
+  history;
+  scratch;
+  inside = false;
+  constructor(depth) {
+    this.history = new PoseHistory(depth);
+  }
+  free() {
+    this.scratch?.free();
+    this.scratch = void 0;
+  }
+  run(physics, tickNow, requested, fn) {
+    if (this.inside) {
+      throw new Error(
+        "room.rewind: already inside a rewind. The second call would repose the same scratch world under the query still reading it, so it is refused rather than answered wrongly."
+      );
+    }
+    const resolved = this.history.resolve(requested);
+    if (!resolved) {
+      throw new Error(
+        `room.rewind: this room has recorded no ticks yet, so there is no past to answer from. A woken room starts with an empty history and fills it over its next ${this.history.depth} tick(s).`
+      );
+    }
+    this.scratch ??= physics.engineKind === "rapier3d" ? new RapierScratch(physics, this.history.depth, tickNow) : physics.engineKind === "rapier2d" ? new Rapier2dScratch(physics, this.history.depth, tickNow) : new MatterScratch(physics, this.history.depth, tickNow);
+    const view = this.scratch.view(resolved.entry, resolved.tick, requested, resolved.clamped);
+    this.inside = true;
+    try {
+      return fn(view);
+    } finally {
+      this.inside = false;
+    }
+  }
+};
+
+// src/core/lobby.ts
+import {
+  LOBBY_MEMBERS,
+  LOBBY_MIN_PLAYERS,
+  LOBBY_STATE,
+  schemaHasLobby
+} from "@irtio/server";
+var runtimes = /* @__PURE__ */ new WeakMap();
+function runtimeOf(core) {
+  let r = runtimes.get(core);
+  if (!r) {
+    r = { onStart: [], started: false };
+    runtimes.set(core, r);
+  }
+  return r;
+}
+function lobbyConfigOf(core) {
+  const declared = core.definition.config.lobby;
+  if (declared === void 0) return void 0;
+  if (!schemaHasLobby(core.definition.schema)) return void 0;
+  return declared;
+}
+function stateOf3(core) {
+  return core.anyState[LOBBY_STATE];
+}
+function evaluateLobby(core) {
+  const config = lobbyConfigOf(core);
+  if (config === void 0) return;
+  const state = stateOf3(core);
+  if (state === void 0) return;
+  const members = trackedEntity(core, LOBBY_MEMBERS);
+  const policy = config.start ?? "when-full";
+  const present = [];
+  for (const [clientId, entry] of core.clients) {
+    if (!entry.connected) continue;
+    present.push(clientId);
+    if (!members.has(clientId)) members.add(clientId, { ready: false }, { owner: clientId });
+    else if (members.ownerOf(clientId) !== clientId) members.setOwner(clientId, clientId);
+  }
+  const here = new Set(present);
+  for (const id of [...members.ids()]) {
+    if (!here.has(id)) members.remove(id);
+  }
+  const readyCount = policy === "when-ready" ? present.filter((id) => members.get(id)?.ready === true).length : 0;
+  const capacity = Math.min(
+    255,
+    config.size ?? core.definition.config.maxClients,
+    core.definition.config.maxClients
+  );
+  const min = Math.max(LOBBY_MIN_PLAYERS, config.min ?? LOBBY_MIN_PLAYERS);
+  if (state.readyUi !== (policy === "when-ready")) state.readyUi = policy === "when-ready";
+  if (state.present !== present.length) state.present = Math.min(255, present.length);
+  if (state.ready !== readyCount) state.ready = readyCount;
+  if (state.capacity !== capacity) state.capacity = capacity;
+  if (state.phase !== "lobby") return;
+  if (policy === "when-full") {
+    if (present.length >= capacity && capacity >= LOBBY_MIN_PLAYERS) startLobby(core, "when-full");
+    return;
+  }
+  if (policy === "when-ready") {
+    if (present.length >= min && readyCount === present.length) startLobby(core, "when-ready");
+    return;
+  }
+}
+function startLobby(core, why) {
+  const runtime = runtimeOf(core);
+  if (runtime.started) return;
+  const state = stateOf3(core);
+  if (state === void 0 || state.phase === "started") {
+    runtime.started = true;
+    return;
+  }
+  runtime.started = true;
+  state.phase = "started";
+  state.public = false;
+  core.host.setLobby({ started: true });
+  core.log("info", `lobby: the game started (${why})`);
+  const declared = lobbyConfigOf(core)?.onStart;
+  if (declared) {
+    core.guard("lobby.onStart", () => declared(core.anyState, core.room));
+  }
+  for (const cb of [...runtime.onStart]) core.guard("lobby.onStart(cb)", cb);
+}
+function makeLobby(core) {
+  const config = lobbyConfigOf(core);
+  if (config === void 0) {
+    throw new Error(
+      "room.lobby: this room has no lobby. Spread lobbyCollections into the schema and declare lobby: {} in defineRoom \u2014 both are needed, and defineRoom refuses either one alone"
+    );
+  }
+  const state = stateOf3(core);
+  const members = trackedEntity(core, LOBBY_MEMBERS);
+  return {
+    get phase() {
+      return state.phase ?? "lobby";
+    },
+    get ready() {
+      const out = [];
+      for (const [clientId, entry] of core.clients) {
+        if (!entry.connected) continue;
+        out.push({
+          clientId,
+          ready: members.get(clientId)?.ready === true
+        });
+      }
+      return out;
+    },
+    get public() {
+      return state.public === true;
+    },
+    start() {
+      startLobby(core, "room.lobby.start()");
+    },
+    onStart(cb) {
+      if (typeof cb !== "function") {
+        core.log("warn", "room.lobby.onStart: expects a function; ignored");
+        return;
+      }
+      runtimeOf(core).onStart.push(cb);
+    },
+    setPublic(value) {
+      setLobbyPublic(core, value === true);
+    }
+  };
+}
+function setLobbyPublic(core, value) {
+  const config = lobbyConfigOf(core);
+  if (config === void 0) return;
+  const state = stateOf3(core);
+  if (state === void 0) return;
+  if (state.phase === "started") {
+    core.log(
+      "warn",
+      "room.lobby.setPublic: the game has started; the room stays out of the registry"
+    );
+    return;
+  }
+  const veto = config.onSetPublic;
+  if (veto) {
+    const outcome = core.tryRun("lobby.onSetPublic", () => veto(core.anyState, value));
+    if (!outcome.ok || outcome.value === false) return;
+  }
+  if (state.public !== value) state.public = value;
+  core.host.setLobby({ public: value, queue: config.queue ?? "default" });
+}
+
 // src/core/messages.ts
 import { FrameType as FrameType3, decodeMsg, encodeFrame as encodeFrame2, encodeMsg } from "@irtio/protocol";
+import { decodeFields as decodeFields2 } from "@irtio/schema";
 function toRoomTarget(target) {
   switch (target.kind) {
     case "all":
@@ -1985,7 +3003,28 @@ function deliver(core, target, frame, exclude) {
     if (entry.clientId === exclude) continue;
     if (target.kind === "client" && entry.clientId !== target.clientId) continue;
     if (target.kind === "role" && entry.role !== target.role) continue;
-    core.send(entry.clientId, frame);
+    core.send(entry.clientId, frame.slice());
+  }
+}
+function messagesOf(core) {
+  return core.definition.schema.messages ?? [];
+}
+function decodeTyped(core, clientId, index, payload) {
+  const desc = messagesOf(core)[index];
+  if (!desc) {
+    core.stats.messagesDropped++;
+    core.log(
+      "warn",
+      `typed MSG from ${clientId}: no message with index ${index} in this schema; dropped`
+    );
+    return void 0;
+  }
+  try {
+    return { name: desc.name, value: decodeFields2(desc.fields, payload) };
+  } catch (err) {
+    core.stats.messagesDropped++;
+    core.log("warn", `typed MSG ${desc.name} from ${clientId} failed to decode:`, err);
+    return void 0;
   }
 }
 function handleMsg(core, clientId, payload) {
@@ -2001,31 +3040,54 @@ function handleMsg(core, clientId, payload) {
     core.log("warn", `voice MSG from ${clientId} reached room code; dropped (supervisor bug)`);
     return true;
   }
+  if (msg.typed && msg.target.kind === "server") {
+    core.stats.messagesDropped++;
+    core.log("warn", `typed MSG from ${clientId} addressed the server; dropped`);
+    return true;
+  }
   const roomTarget = toRoomTarget(msg.target);
   if (roomTarget === void 0) return true;
+  let typed;
+  if (msg.typed) {
+    typed = decodeTyped(core, clientId, msg.typed.index, msg.payload);
+    if (!typed) return true;
+  }
   const onMessage = core.definition.config.onMessage;
   if (onMessage) {
     const ran = core.tryRun(
       "onMessage",
-      () => onMessage(core.anyState, clientId, roomTarget, msg.payload, core.ctxFor(clientId))
+      () => onMessage(core.anyState, clientId, roomTarget, msg.payload, core.ctxFor(clientId), typed)
     );
     if (!ran.ok || ran.value === false) return true;
   }
   if (msg.target.kind === "server") return true;
   const frame = encodeFrame2(
     FrameType3.MSG,
-    encodeMsg({ target: { kind: "client", clientId }, payload: msg.payload })
+    encodeMsg({
+      target: { kind: "client", clientId },
+      payload: msg.payload,
+      ...msg.typed ? { typed: msg.typed } : {}
+    })
   );
   deliver(core, msg.target, frame, clientId);
   return true;
 }
+function wireTargetOf(target) {
+  return target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
+}
 function sendMessage(core, target, bytes) {
-  const wire = target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
   const frame = encodeFrame2(
     FrameType3.MSG,
     encodeMsg({ target: { kind: "server" }, payload: bytes })
   );
-  deliver(core, wire, frame);
+  deliver(core, wireTargetOf(target), frame);
+}
+function sendTypedMessage(core, index, target, payload) {
+  const frame = encodeFrame2(
+    FrameType3.MSG,
+    encodeMsg({ target: { kind: "server" }, payload, typed: { index } })
+  );
+  deliver(core, wireTargetOf(target), frame);
 }
 
 // src/core/room-api.ts
@@ -2035,7 +3097,7 @@ import {
   busPayloadProblem,
   encodeFrame as encodeFrame3
 } from "@irtio/protocol";
-import { encodeDelta as encodeDelta3, isDirtyEmpty as isDirtyEmpty2 } from "@irtio/schema";
+import { encodeDelta as encodeDelta3, encodeFields as encodeFields2, isDirtyEmpty as isDirtyEmpty2 } from "@irtio/schema";
 function makePhysicsApi(p) {
   return {
     get rapier() {
@@ -2068,6 +3130,22 @@ function makeMatterApi(p) {
     }
   };
 }
+function makeRapier2dApi(p) {
+  return {
+    get rapier() {
+      return p.rapier;
+    },
+    get world() {
+      return p.world;
+    },
+    get timestep() {
+      return p.timestep;
+    },
+    body(collection, id) {
+      return p.bodyFor(collection, id);
+    }
+  };
+}
 function makeKv(core) {
   return {
     get(playerId, key) {
@@ -2083,7 +3161,7 @@ function makeKv(core) {
 }
 function makeLeaderboard(core) {
   return {
-    submit(board, playerId, score) {
+    submit(board, playerId, score, options) {
       if (!Number.isInteger(score)) {
         return rejectAsEvent(
           core,
@@ -2092,7 +3170,17 @@ function makeLeaderboard(core) {
           )
         );
       }
-      return startHostCall(core, { kind: "lbSubmit", board, playerId, score }, () => void 0);
+      return startHostCall(
+        core,
+        {
+          kind: "lbSubmit",
+          board,
+          playerId,
+          score,
+          ...options?.bucket === void 0 ? {} : { bucket: options.bucket }
+        },
+        () => void 0
+      );
     }
   };
 }
@@ -2173,6 +3261,7 @@ function createRoomApi(core, publicUrl) {
   let lastNow = Number.NEGATIVE_INFINITY;
   let physicsApi;
   let matterApi;
+  let rapier2dApi;
   let kvApi;
   let busApi;
   let leaderboardApi;
@@ -2183,6 +3272,14 @@ function createRoomApi(core, publicUrl) {
     const sep = publicUrl.includes("?") ? "&" : "?";
     return `${publicUrl}${sep}room=${encodeURIComponent(core.roomId)}`;
   };
+  const messages = {};
+  for (const desc of core.definition.schema.messages ?? []) {
+    messages[desc.name] = {
+      send(target, value) {
+        sendTypedMessage(core, desc.index, target, encodeFields2(desc.fields, value));
+      }
+    };
+  }
   const room = {
     get id() {
       return core.roomId;
@@ -2226,7 +3323,7 @@ function createRoomApi(core, publicUrl) {
       }
       if (p.engineKind !== "rapier3d") {
         throw new Error(
-          "room.physics: this room runs matter2d. Read room.physics2d instead (it has .matter and .engine, where this one has .rapier and .world)"
+          p.engineKind === "matter2d" ? "room.physics: this room runs matter2d. Read room.physics2d instead (it has .matter and .engine, where this one has .rapier and .world)" : "room.physics: this room runs rapier2d. Read room.physicsRapier2d instead (same .rapier and .world, but the 2D module: a Vector2 world, not a Vector3 one)"
         );
       }
       return physicsApi ?? (physicsApi = makePhysicsApi(p));
@@ -2240,14 +3337,36 @@ function createRoomApi(core, publicUrl) {
       }
       if (p.engineKind !== "matter2d") {
         throw new Error(
-          "room.physics2d: this room runs rapier3d. Read room.physics instead (it has .rapier and .world, where this one has .matter and .engine)"
+          p.engineKind === "rapier2d" ? "room.physics2d: this room runs rapier2d, not matter2d. Read room.physicsRapier2d instead (it has .rapier and .world, where this one has .matter and .engine)" : "room.physics2d: this room runs rapier3d. Read room.physics instead (it has .rapier and .world, where this one has .matter and .engine)"
         );
       }
       return matterApi ?? (matterApi = makeMatterApi(p));
     },
+    get physicsRapier2d() {
+      const p = core.physics;
+      if (!p) {
+        throw new Error(
+          "room.physicsRapier2d: this room has no physics \u2014 add physics: { engine: 'rapier2d', gravity, bodies } to defineRoom(...)"
+        );
+      }
+      if (p.engineKind !== "rapier2d") {
+        throw new Error(
+          p.engineKind === "matter2d" ? "room.physicsRapier2d: this room runs matter2d. Read room.physics2d instead (it has .matter and .engine, where this one has .rapier and .world)" : "room.physicsRapier2d: this room runs rapier3d. Read room.physics instead (same .rapier and .world, but the 3D module: a Vector3 world, not a Vector2 one)"
+        );
+      }
+      return rapier2dApi ?? (rapier2dApi = makeRapier2dApi(p));
+    },
+    // ---- M6 lane F: rewind ----
+    // D72: one line, and deliberately only one. Everything the rewind does — the buffer, the
+    // clamping, the scratch worlds, the reentrancy refusal — lives in `core/history.ts` behind
+    // `RoomCore.rewind`, so this file stays what it says it is: a facade that reads through.
+    rewind(tick, fn) {
+      return core.rewind(tick, fn);
+    },
     send(target, bytes) {
       sendMessage(core, target, bytes);
     },
+    messages,
     setRole(clientId, role) {
       setRole(core, clientId, role);
       cached = void 0;
@@ -2313,6 +3432,10 @@ function createRoomApi(core, publicUrl) {
     get bus() {
       return busApi ?? (busApi = makeBus(core));
     },
+    // ---- M6 lane H: lobby front door ----
+    get lobby() {
+      return makeLobby(core);
+    },
     alarm(name, atMs) {
       if (!isAlarmName(core, name, "room.alarm")) return;
       if (!Number.isFinite(atMs)) {
@@ -2493,7 +3616,8 @@ var RoomCore = class _RoomCore {
     visibleIdsTotal: 0,
     membershipEnters: 0,
     membershipLeaves: 0,
-    corrections: 0
+    corrections: 0,
+    messagesDropped: 0
   };
   tick = 0;
   stopped = false;
@@ -2515,6 +3639,13 @@ var RoomCore = class _RoomCore {
    * cost the profiler has is behind this `undefined`.
    */
   ledger;
+  /**
+   * D72: the pose history and the rewind scratch, present only when the room's physics config
+   * declares `history`. Every cost this lane has is behind this `undefined`, and it is
+   * deliberately not in the hibernation blob: a woken room starts with an empty buffer and fills
+   * it again over its next `history` ticks.
+   */
+  rewindState;
   seed;
   api;
   internals;
@@ -2558,6 +3689,8 @@ var RoomCore = class _RoomCore {
     this.loop = new Loop(self);
     this.api = createRoomApi(self, options.publicUrl ?? DEFAULT_PUBLIC_URL);
     this.physics = this.buildPhysics(restored);
+    const historyDepth = this.physics ? historyDepthOf(definition.config.physics) : void 0;
+    this.rewindState = historyDepth === void 0 ? void 0 : new RewindState(historyDepth);
     this.subscribeDeclaredChannels();
     if (restored) {
       const onWake = definition.config.onWake;
@@ -2640,14 +3773,24 @@ var RoomCore = class _RoomCore {
     const config = this.definition.config.physics;
     if (!config) return void 0;
     if (config.engine === "matter2d") return this.buildMatter(config, restored);
-    const engine3 = loadedPhysics();
-    if (!engine3) {
+    if (config.engine === "rapier2d") return this.buildRapier2d(restored);
+    const engine4 = loadedPhysics();
+    if (!engine4) {
       throw new Error(
         "RoomCore: this room declares physics but the engine is not initialized \u2014 the host must `await initPhysics()` (from '@irtio/runtime') before constructing the room; handlers are synchronous, so the WASM cannot be loaded later"
       );
     }
-    const section = restored?.physics ? decodePhysicsSection(restored.physics) : void 0;
-    const physics = new PhysicsRuntime(this.internals, engine3, {
+    let section;
+    if (restored?.physics) {
+      const wrote = physicsSectionEngine(restored.physics);
+      if (wrote === "rapier3d") section = decodePhysicsSection(restored.physics);
+      else {
+        this.host.log("warn", [
+          `irtio: this snapshot carries a ${wrote} world and the room now runs rapier3d. The world is rebuilt from schema state and physics.setup runs again.`
+        ]);
+      }
+    }
+    const physics = new PhysicsRuntime(this.internals, engine4, {
       ...section ? { restore: section } : {},
       defaultTimestep: 1 / this.definition.config.tickRate
     });
@@ -2678,11 +3821,12 @@ var RoomCore = class _RoomCore {
     }
     let section;
     if (restored?.physics) {
-      if (physicsSectionEngine(restored.physics) === "matter2d") {
+      const wrote = physicsSectionEngine(restored.physics);
+      if (wrote === "matter2d") {
         section = decodeMatterBodies(decodeMatterSectionEnvelope(restored.physics));
       } else {
         this.host.log("warn", [
-          "irtio: this snapshot carries a rapier3d world and the room now runs matter2d. The world is rebuilt from schema state and physics.setup runs again."
+          `irtio: this snapshot carries a ${wrote} world and the room now runs matter2d. The world is rebuilt from schema state and physics.setup runs again.`
         ]);
       }
     }
@@ -2699,6 +3843,44 @@ var RoomCore = class _RoomCore {
     physics.reconcile();
     return physics;
   }
+  /**
+   * The rapier2d half. It follows the *rapier3d* shape rather than matter2d's, because the 2D
+   * build has a real `takeSnapshot()`: a restored world comes back whole and `setup` does not run
+   * again. The only thing that differs from `buildPhysics` is which engine and which envelope.
+   */
+  buildRapier2d(restored) {
+    const engine4 = loadedRapier2d();
+    if (!engine4) {
+      throw new Error(
+        "RoomCore: this room declares rapier2d physics but the engine is not initialized \u2014 the host must `await initRapier2d()` (from '@irtio/runtime') before constructing the room; handlers are synchronous, so the WASM cannot be loaded later"
+      );
+    }
+    let section;
+    if (restored?.physics) {
+      const wrote = physicsSectionEngine(restored.physics);
+      if (wrote === "rapier2d") {
+        section = decodePhysicsSection(decodeRapier2dSectionEnvelope(restored.physics));
+      } else {
+        this.host.log("warn", [
+          `irtio: this snapshot carries a ${wrote} world and the room now runs rapier2d. The world is rebuilt from schema state and physics.setup runs again.`
+        ]);
+      }
+    }
+    const physics = new Rapier2dRuntime(this.internals, engine4, {
+      ...section ? { restore: section } : {},
+      defaultTimestep: 1 / this.definition.config.tickRate
+    });
+    if (physics.rebuilt) {
+      if (restored) {
+        this.host.log("info", [
+          `irtio: no rapier2d world in this snapshot (format v${restored.version}) \u2014 rebuilding it from schema state and re-running physics.setup; contact state is not restored`
+        ]);
+      }
+      physics.runSetup(this.room);
+      physics.reconcile();
+    }
+    return physics;
+  }
   /** Convenience for hosts: `RoomCore.restore(def, bytes, host, opts)`. */
   static restore(definition, bytes, host, options) {
     return new _RoomCore(definition, host, { ...options, restoreFrom: bytes });
@@ -2763,6 +3945,35 @@ var RoomCore = class _RoomCore {
   captureTimeline() {
     this.recorder?.capture(this.tick, this.ext, this.plain);
   }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: record this tick's body poses, right after `physics.sync()` — the poses the clients are
+   * about to be told about, under the tick number they will be told it under, which is the tick a
+   * client later stamps its `CALL` with.
+   */
+  captureHistory() {
+    const physics = this.physics;
+    if (!physics || !this.rewindState) return;
+    this.rewindState.history.capture(this.tick, physics);
+  }
+  /**
+   * D72: `room.rewind(tick, fn)`. The live world is not touched and nothing is re-simulated; `fn`
+   * queries a scratch world holding every tracked body at its pose at `tick`.
+   */
+  rewind(tick, fn) {
+    const physics = this.physics;
+    if (!physics) {
+      throw new Error(
+        "room.rewind: this room has no physics, so there are no poses to rewind. Add physics: { engine, gravity, bodies, history: <ticks> } to defineRoom(...)"
+      );
+    }
+    if (!this.rewindState) {
+      throw new Error(
+        "room.rewind: this room declares no physics.history, so no poses are kept. Add history: <ticks> to the physics config; it is off by default because it costs heap per tick. See irt.io/docs/concepts/lag-compensation for how deep to make it."
+      );
+    }
+    return this.rewindState.run(physics, () => this.tick, tick, fn);
+  }
   /** Live JSON view of the room for the dev page / supervisor admin API. */
   inspect() {
     return {
@@ -2797,6 +4008,7 @@ var RoomCore = class _RoomCore {
     this.loop.stop();
     rejectAllPending(this.internals, "room stopped");
     rejectAllHostCalls(this.internals, "room stopped");
+    this.rewindState?.free();
     this.physics?.free();
   }
   /**
@@ -2986,6 +4198,9 @@ var RoomCore = class _RoomCore {
       role: entry?.role ?? "",
       name: entry?.name ?? "",
       tick: this.tick,
+      // D72: only an RPC has a stamp, and `rpc.ts` puts it on the ctx it hands the handler. Every
+      // other entry point (join, leave, write, ownership) has no client tick by construction.
+      clientTick: void 0,
       reconnecting,
       room: this.room
     };
@@ -3154,6 +4369,7 @@ var RoomCore = class _RoomCore {
    * its view's `DELTA` — encoded once per distinct view.
    */
   flush() {
+    evaluateLobby(this.internals);
     const dirty = this.tracked.flush();
     serverWinsCorrections(this.internals, dirty);
     this.ledger?.newFlush();
@@ -3283,7 +4499,13 @@ var RoomCore = class _RoomCore {
   }
 };
 function encodeSection(physics) {
-  return physics.engineKind === "matter2d" ? encodeMatterSectionEnvelope(encodeMatterBodies(physics.serialize())) : encodePhysicsSection(physics.serialize());
+  if (physics.engineKind === "matter2d") {
+    return encodeMatterSectionEnvelope(encodeMatterBodies(physics.serialize()));
+  }
+  if (physics.engineKind === "rapier2d") {
+    return encodeRapier2dSectionEnvelope(encodePhysicsSection(physics.serialize()));
+  }
+  return encodePhysicsSection(physics.serialize());
 }
 
 export {
@@ -3306,10 +4528,15 @@ export {
   onFirstRapierStep,
   encodePhysicsSection,
   physicsSectionEngine,
+  encodeRapier2dSectionEnvelope,
+  decodeRapier2dSectionEnvelope,
   encodeMatterSectionEnvelope,
   decodeMatterSectionEnvelope,
   decodePhysicsSection,
   Mulberry32,
+  initRapier2d,
+  loadedRapier2d,
+  resetRapier2dForTests,
   isVisible,
   visibleTo,
   visibleNames,