@irtio/runtime 0.7.0 → 0.9.0

package/dist/{chunk-EXPFVRD4.js → chunk-ADZZEVJU.js}

@@ -250,7 +250,7 @@ function createCallProxy(core, clientId) {
     }
   );
 }
-function createBroadcastProxy(core) {
+function createBroadcastProxy(core, except) {
   return new Proxy(
     {},
     {
@@ -259,13 +259,19 @@ function createBroadcastProxy(core) {
         return (params) => {
           const desc = descFor(core, prop);
           for (const entry of core.clients.values()) {
-            if (entry.connected) sendCall(core, entry.clientId, desc, params ?? {});
+            if (!entry.connected) continue;
+            if (except?.has(entry.clientId)) continue;
+            sendCall(core, entry.clientId, desc, params ?? {});
           }
         };
       }
     }
   );
 }
+function createBroadcastExceptProxy(core, except) {
+  const ids = typeof except === "string" ? [except] : except;
+  return createBroadcastProxy(core, new Set(ids));
+}
 function handleReply(core, clientId, payload) {
   let reply;
   try {
@@ -956,6 +962,7 @@ function decodeMatterBodies(bytes) {
 function bodyKey(collection, id) {
   return `${collection}\0${id}`;
 }
+var PLANAR_CHANNELS = /* @__PURE__ */ new Set(["x", "y", "qz", "qw", "vx", "vy", "wz"]);
 var MatterRuntime = class {
   engineKind = "matter2d";
   /** rapier3d only; present so both runtimes satisfy one internal shape. */
@@ -981,6 +988,15 @@ var MatterRuntime = class {
   restore;
   stepMs;
   sleepSynced = /* @__PURE__ */ new Set();
+  /**
+   * The plain record object each body was built from. See `PhysicsRuntime.sourceRecords`: `add()`
+   * installs a new record object, so an id removed and re-added between two reconciles (a pooled
+   * projectile) is identifiable by identity, and is the one case where a live body has to be
+   * rebuilt so the new row's spawn pose and velocity are honoured.
+   */
+  sourceRecords = /* @__PURE__ */ new Map();
+  /** `collection.field` pairs already warned about a channel a plane cannot hold. */
+  warnedChannels = /* @__PURE__ */ new Set();
   constructor(core, matter, options) {
     const config = core.definition.config.physics;
     if (!config) throw new Error("MatterRuntime: the room config declares no physics");
@@ -1050,6 +1066,7 @@ var MatterRuntime = class {
     } else {
       this.applyRecordToBody(desc, spec.body, record);
     }
+    this.sourceRecords.set(key, record);
     return spec.body;
   }
   // ---- M6 lane F: rewind ----
@@ -1089,6 +1106,17 @@ var MatterRuntime = class {
     for (const [channel, field] of physics.channels) {
       const raw = record[field];
       if (typeof raw !== "number") continue;
+      if (raw !== 0 && !PLANAR_CHANNELS.has(channel)) {
+        const key = `${desc.name}.${field}`;
+        if (!this.warnedChannels.has(key)) {
+          this.warnedChannels.add(key);
+          this.core.log(
+            "warn",
+            `irtio: ${desc.name}.${field} maps body channel ${channel}, which a matter2d room cannot hold (the world is a plane); the ${raw} it was added with was dropped`
+          );
+        }
+        continue;
+      }
       applyChannel2d(channel, raw, t);
     }
     this.applyState(body, {
@@ -1110,8 +1138,21 @@ var MatterRuntime = class {
       for (const id of coll.ids()) {
         const key = bodyKey(desc.name, id);
         live.add(key);
-        if (this.bodies.has(key)) continue;
         const record = coll.get(id);
+        const existing = this.bodies.get(key);
+        if (existing) {
+          if (record === void 0) continue;
+          const source = this.sourceRecords.get(key);
+          if (source === void 0) {
+            this.sourceRecords.set(key, record);
+            continue;
+          }
+          if (source === record) continue;
+          this.bodies.delete(key);
+          this.sleepSynced.delete(key);
+          this.sourceRecords.delete(key);
+          this.matter.Composite.remove(this.engine.world, [existing.body, ...existing.constraints]);
+        }
         if (record !== void 0) this.create(desc, id, record);
       }
     }
@@ -1119,6 +1160,7 @@ var MatterRuntime = class {
       if (live.has(key)) continue;
       this.bodies.delete(key);
       this.sleepSynced.delete(key);
+      this.sourceRecords.delete(key);
       this.matter.Composite.remove(this.engine.world, [attached.body, ...attached.constraints]);
     }
   }
@@ -1255,9 +1297,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);
@@ -1330,6 +1391,19 @@ var PhysicsRuntime = class {
    * world rebuilt from schema state would wake it with a kick). Found by the drift check.
    */
   sleepSynced = /* @__PURE__ */ new Set();
+  /**
+   * The plain record object each body was built from, by body key. `add()` always installs a
+   * **new** record object (`normalizeRecord` builds one), so an id that is removed and re-added
+   * between two reconciles — the pooled-projectile shape — is identifiable by identity alone,
+   * which is the only way to see it from here: both edits happened before this module looked.
+   * Without it the old body kept its pose and velocity and the new row's spawn values were lost.
+   *
+   * Unknown means adopt, never rebuild: a world restored from a hibernation blob has bodies with
+   * no recorded source, and rebuilding those would throw away exactly what the blob preserved.
+   */
+  sourceRecords = /* @__PURE__ */ new Map();
+  /** `collection.field` pairs already warned about a channel value the engine would not take. */
+  warnedChannels = /* @__PURE__ */ new Set();
   constructor(core, rapier, options) {
     const config = core.definition.config.physics;
     if (!config) throw new Error("PhysicsRuntime: the room config declares no physics");
@@ -1404,10 +1478,50 @@ var PhysicsRuntime = class {
     }
     const body = this.world.createRigidBody(spec.body);
     for (const collider of spec.colliders ?? []) this.world.createCollider(collider, body);
+    this.warnLockedChannels(desc, spec, record);
     this.applyRecordToBody(desc, body, record);
     this.bodies.set(bodyKey2(desc.name, id), body);
+    this.sourceRecords.set(bodyKey2(desc.name, id), record);
     return body;
   }
+  /**
+   * A spawn value the engine will not take, said once per field.
+   *
+   * Rapier accepts `setLinvel` on an axis the body has disabled and then keeps zero, and it
+   * accepts one on a fixed body and then ignores it — both read back as "the field was applied"
+   * and behave as if it never was. The desc says which, before the body exists, so the check is
+   * on the desc: the usual case is the 2D-in-3D recipe (`enabledTranslations(true, true, false)`)
+   * meeting a row that spawns with a `vz`. Named by field, because the field is what the author
+   * wrote and what they will grep for.
+   */
+  warnLockedChannels(desc, spec, record) {
+    const physics = desc.physics;
+    if (!physics) return;
+    const b = spec.body;
+    const frozen = b.status !== 0;
+    const enabled = {
+      vx: b.translationsEnabledX,
+      vy: b.translationsEnabledY,
+      vz: b.translationsEnabledZ,
+      wx: b.rotationsEnabledX,
+      wy: b.rotationsEnabledY,
+      wz: b.rotationsEnabledZ
+    };
+    for (const [channel, field] of physics.channels) {
+      const allowed = enabled[channel];
+      if (allowed === void 0) continue;
+      const raw = record[field];
+      if (typeof raw !== "number" || raw === 0) continue;
+      if (allowed && !frozen) continue;
+      const key = `${desc.name}.${field}`;
+      if (this.warnedChannels.has(key)) continue;
+      this.warnedChannels.add(key);
+      this.core.log(
+        "warn",
+        `irtio: ${desc.name}.${field} (body channel ${channel}) was added as ${raw}, but ` + (frozen ? `physics.bodies.${desc.name} builds a non-dynamic body, which never moves under it` : `that degree of freedom is disabled by physics.bodies.${desc.name}`) + " \u2014 the value was dropped"
+      );
+    }
+  }
   // ---- M6 lane F: rewind ----
   /**
    * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
@@ -1503,8 +1617,21 @@ var PhysicsRuntime = class {
       for (const id of coll.ids()) {
         const key = bodyKey2(desc.name, id);
         live.add(key);
-        if (this.bodies.has(key)) continue;
         const record = coll.get(id);
+        const existing = this.bodies.get(key);
+        if (existing) {
+          if (record === void 0) continue;
+          const source = this.sourceRecords.get(key);
+          if (source === void 0) {
+            this.sourceRecords.set(key, record);
+            continue;
+          }
+          if (source === record) continue;
+          this.bodies.delete(key);
+          this.sleepSynced.delete(key);
+          this.sourceRecords.delete(key);
+          this.world.removeRigidBody(existing);
+        }
         if (record !== void 0) this.create(desc, id, record);
       }
     }
@@ -1512,6 +1639,7 @@ var PhysicsRuntime = class {
       if (live.has(key)) continue;
       this.bodies.delete(key);
       this.sleepSynced.delete(key);
+      this.sourceRecords.delete(key);
       this.world.removeRigidBody(body);
     }
   }
@@ -1611,6 +1739,14 @@ function channelValue(channel, t, r, v, w) {
 }
 
 // src/core/random.ts
+function seedFromRoomId(roomId) {
+  let h = 2166136261;
+  for (let i = 0; i < roomId.length; i++) {
+    h ^= roomId.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h === 0 ? 2654435769 : h >>> 0;
+}
 var Mulberry32 = class {
   /** Current internal state (u32). Survives hibernation. */
   state;
@@ -1627,6 +1763,324 @@ 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();
+  /**
+   * See `PhysicsRuntime.sourceRecords`: the plain record object each body was built from. `add()`
+   * always installs a new record object, so an id removed and re-added between two reconciles —
+   * the pooled-projectile shape — is identifiable by identity alone, and its body is rebuilt so
+   * the new row's spawn pose and velocity are what the world gets. Unknown means adopt, never
+   * rebuild: a world restored from a hibernation blob has bodies with no recorded source.
+   */
+  sourceRecords = /* @__PURE__ */ new Map();
+  /** `collection.field` pairs already warned about a channel value the engine would not take. */
+  warnedChannels = /* @__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.warnLockedChannels(desc, spec, record);
+    this.applyRecordToBody(desc, body, record);
+    this.bodies.set(bodyKey3(desc.name, id), body);
+    this.sourceRecords.set(bodyKey3(desc.name, id), record);
+    return body;
+  }
+  /**
+   * A spawn value the engine will not take, said once per field — the planar half of
+   * `PhysicsRuntime.warnLockedChannels`.
+   *
+   * Rapier accepts `setLinvel` on an axis the body has disabled and then keeps zero, and it
+   * accepts one on a fixed body and then ignores it: both read back as "the field was applied"
+   * and behave as if it never was. The desc says which, before the body exists, so the check is on
+   * the desc. In the plane there are three movable channels — `vx`, `vy` and the one rotation
+   * `wz` — and the desc carries exactly those three flags. Named by field, because the field is
+   * what the author wrote and what they will grep for.
+   */
+  warnLockedChannels(desc, spec, record) {
+    const physics = desc.physics;
+    if (!physics) return;
+    const b = spec.body;
+    const frozen = b.status !== 0;
+    const enabled = {
+      vx: b.translationsEnabledX,
+      vy: b.translationsEnabledY,
+      wz: b.rotationsEnabled
+    };
+    for (const [channel, field] of physics.channels) {
+      const allowed = enabled[channel];
+      if (allowed === void 0) continue;
+      const raw = record[field];
+      if (typeof raw !== "number" || raw === 0) continue;
+      if (allowed && !frozen) continue;
+      const key = `${desc.name}.${field}`;
+      if (this.warnedChannels.has(key)) continue;
+      this.warnedChannels.add(key);
+      this.core.log(
+        "warn",
+        `irtio: ${desc.name}.${field} (body channel ${channel}) was added as ${raw}, but ` + (frozen ? `physics.bodies.${desc.name} builds a non-dynamic body, which never moves under it` : `that degree of freedom is disabled by physics.bodies.${desc.name}`) + " \u2014 the value was dropped"
+      );
+    }
+  }
+  // ---- 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);
+        const record = coll.get(id);
+        const existing = this.bodies.get(key);
+        if (existing) {
+          if (record === void 0) continue;
+          const source = this.sourceRecords.get(key);
+          if (source === void 0) {
+            this.sourceRecords.set(key, record);
+            continue;
+          }
+          if (source === record) continue;
+          this.bodies.delete(key);
+          this.sleepSynced.delete(key);
+          this.sourceRecords.delete(key);
+          this.world.removeRigidBody(existing);
+        }
+        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.sourceRecords.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,
@@ -1869,8 +2323,8 @@ function catchUpDirty(ext, plain, fromRole, toRole) {
 // src/core/snapshot.ts
 import { withBuiltins } from "@irtio/protocol";
 import { ByteReader as ByteReader3, ByteWriter as ByteWriter3, decodeSnapshot } from "@irtio/schema";
-var SNAPSHOT_FORMAT_VERSION = 2;
-var READABLE_SNAPSHOT_VERSIONS = [1, 2];
+var SNAPSHOT_FORMAT_VERSION = 3;
+var READABLE_SNAPSHOT_VERSIONS = [1, 2, 3];
 function parseHibernationBlob(bytes) {
   const r = new ByteReader3(bytes);
   const version = r.u8();
@@ -1881,22 +2335,31 @@ function parseHibernationBlob(bytes) {
   const rngState = r.u32();
   const tick = r.u32();
   const mode = r.u8() === 1 ? "event" : "tick";
+  const schemaHash8 = version >= 3 ? r.bytes(8).slice() : void 0;
   let physics;
   if (version >= 2) {
     const section = r.blob();
     if (section.length > 0) physics = section;
   }
-  return { version, seed, rngState, tick, mode, physics, snapshot: r.rest() };
+  return { version, seed, rngState, tick, mode, schemaHash8, physics, snapshot: r.rest() };
+}
+function sameSchemaHash(a, b) {
+  if (!a || !b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
 }
 function writeHibernationBlob(header, snapshot, physics) {
-  const version = physics ? 2 : 1;
-  const w = new ByteWriter3(snapshot.length + (physics?.length ?? 0) + 24);
+  const hash = header.schemaHash8;
+  const version = hash ? 3 : physics ? 2 : 1;
+  const w = new ByteWriter3(snapshot.length + (physics?.length ?? 0) + 32);
   w.u8(version);
   w.u32(header.seed >>> 0);
   w.u32(header.rngState >>> 0);
   w.u32(header.tick >>> 0);
   w.u8(header.mode === "event" ? 1 : 0);
-  if (physics) w.blob(physics);
+  if (hash) w.bytes(hash);
+  if (version >= 2) w.blob(physics ?? new Uint8Array(0));
   w.bytes(snapshot);
   return w.finish();
 }
@@ -2038,9 +2501,10 @@ var PoseHistory = class {
     entry.tick = tick;
     entry.count = 0;
     const pose = this.scratchPose;
-    const rapier = physics.engineKind === "rapier3d";
+    const kind = physics.engineKind;
     physics.eachTrackedBody((collection, id, body) => {
-      if (rapier) readRapierPose(body, pose);
+      if (kind === "rapier3d") readRapierPose(body, pose);
+      else if (kind === "rapier2d") readRapier2dPose(body, pose);
       else readMatterPose(body, pose);
       this.push(entry, collection, id, pose);
     });
@@ -2142,6 +2606,24 @@ function readRapierPose(body, into) {
   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;
@@ -2346,6 +2828,95 @@ var RapierScratch = class extends BaseScratch {
     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();
@@ -2395,9 +2966,9 @@ var MatterScratch = class extends BaseScratch {
   }
   build(tick, requested, clamped) {
     const M = this.matter;
-    const engine3 = this.physics.matterEngine;
-    if (engine3) {
-      for (const b of M.Composite.allBodies(engine3.world)) {
+    const engine4 = this.physics.matterEngine;
+    if (engine4) {
+      for (const b of M.Composite.allBodies(engine4.world)) {
         if (b.isStatic) this.visible.push(b);
       }
     }
@@ -2440,7 +3011,7 @@ var RewindState = class {
         `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) : new MatterScratch(physics, this.history.depth, tickNow);
+    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 {
@@ -2451,6 +3022,152 @@ var RewindState = class {
   }
 };
 
+// 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";
@@ -2601,6 +3318,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) {
@@ -2716,6 +3449,7 @@ function createRoomApi(core, publicUrl) {
   let lastNow = Number.NEGATIVE_INFINITY;
   let physicsApi;
   let matterApi;
+  let rapier2dApi;
   let kvApi;
   let busApi;
   let leaderboardApi;
@@ -2738,9 +3472,20 @@ function createRoomApi(core, publicUrl) {
     get id() {
       return core.roomId;
     },
+    /**
+     * The same tracked state object handlers get. The one caller that has no other way to it is
+     * `physics.setup`, which runs before `onCreate` on a fresh room and after the snapshot is
+     * decoded on a rebuild — see the doc on `Room.state`.
+     */
+    get state() {
+      return core.anyState;
+    },
     get link() {
       return link();
     },
+    get seed() {
+      return core.seed;
+    },
     get tick() {
       return core.tick;
     },
@@ -2777,7 +3522,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));
@@ -2791,11 +3536,25 @@ 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
@@ -2872,6 +3631,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)) {
@@ -2913,6 +3676,9 @@ function createRoomApi(core, publicUrl) {
     },
     get broadcast() {
       return broadcast;
+    },
+    broadcastExcept(clientId) {
+      return createBroadcastExceptProxy(core, clientId);
     }
   };
   const broadcast = createBroadcastProxy(core);
@@ -3101,8 +3867,13 @@ var RoomCore = class _RoomCore {
     }
     let restored;
     let plain;
-    if (options.restoreFrom) {
-      restored = parseHibernationBlob(options.restoreFrom);
+    const candidate = options.restoreFrom ? parseHibernationBlob(options.restoreFrom) : void 0;
+    if (candidate && !sameSchemaHash(candidate.schemaHash8, this.ext.hash8)) {
+      host.log("warn", [`irtio: room ${options.roomId}: schema changed, snapshot discarded`]);
+    } else if (candidate) {
+      restored = candidate;
+    }
+    if (restored) {
       plain = decodeSnapshot2(this.ext, restored.snapshot).state;
       const presence = plainEntity(plain, PRESENCE_COLLECTION);
       for (const id of [...presence.ids()]) presence.remove(id);
@@ -3117,7 +3888,7 @@ var RoomCore = class _RoomCore {
     this.plain = plain;
     this.tracked = track(this.ext, plain);
     this.anyState = this.tracked.state;
-    this.seed = restored?.seed ?? options.seed ?? 1;
+    this.seed = restored?.seed ?? options.seed ?? seedFromRoomId(this.roomId);
     this.rng = new Mulberry32(restored?.rngState ?? this.seed);
     this.tick = restored?.tick ?? 0;
     const self = this;
@@ -3209,14 +3980,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
     });
@@ -3247,11 +4028,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.`
         ]);
       }
     }
@@ -3268,6 +4050,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 });
@@ -3412,7 +4232,13 @@ var RoomCore = class _RoomCore {
   snapshot() {
     const physics = this.physics ? encodeSection(this.physics) : void 0;
     return writeHibernationBlob(
-      { seed: this.seed, rngState: this.rng.state, tick: this.tick, mode: this.mode },
+      {
+        seed: this.seed,
+        rngState: this.rng.state,
+        tick: this.tick,
+        mode: this.mode,
+        schemaHash8: this.ext.hash8
+      },
       encodeSnapshot2(this.ext, this.plain, { tick: this.tick }),
       physics
     );
@@ -3756,6 +4582,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();
@@ -3885,7 +4712,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 {
@@ -3908,10 +4741,15 @@ export {
   onFirstRapierStep,
   encodePhysicsSection,
   physicsSectionEngine,
+  encodeRapier2dSectionEnvelope,
+  decodeRapier2dSectionEnvelope,
   encodeMatterSectionEnvelope,
   decodeMatterSectionEnvelope,
   decodePhysicsSection,
   Mulberry32,
+  initRapier2d,
+  loadedRapier2d,
+  resetRapier2dForTests,
   isVisible,
   visibleTo,
   visibleNames,