@irtio/runtime 0.7.0 → 0.8.0

package/dist/{chunk-ZNNTF7Y3.js → chunk-DBGMG2S3.js}

@@ -1,7 +1,7 @@
 import {
   parseHibernationBlob,
   writeHibernationBlob
-} from "./chunk-EXPFVRD4.js";
+} from "./chunk-ZCD2TBXB.js";
 
 // src/migrate.ts
 import { PRESENCE_COLLECTION, withBuiltins } from "@irtio/protocol";

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

@@ -1255,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);
@@ -1627,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,
@@ -2038,9 +2313,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 +2418,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 +2640,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 +2778,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 +2823,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 +2834,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 +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) {
@@ -2716,6 +3261,7 @@ function createRoomApi(core, publicUrl) {
   let lastNow = Number.NEGATIVE_INFINITY;
   let physicsApi;
   let matterApi;
+  let rapier2dApi;
   let kvApi;
   let busApi;
   let leaderboardApi;
@@ -2777,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));
@@ -2791,11 +3337,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 +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)) {
@@ -3209,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
     });
@@ -3247,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.`
         ]);
       }
     }
@@ -3268,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 });
@@ -3756,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();
@@ -3885,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 {
@@ -3908,10 +4528,15 @@ export {
   onFirstRapierStep,
   encodePhysicsSection,
   physicsSectionEngine,
+  encodeRapier2dSectionEnvelope,
+  decodeRapier2dSectionEnvelope,
   encodeMatterSectionEnvelope,
   decodeMatterSectionEnvelope,
   decodePhysicsSection,
   Mulberry32,
+  initRapier2d,
+  loadedRapier2d,
+  resetRapier2dForTests,
   isVisible,
   visibleTo,
   visibleNames,

package/dist/{contract-DwxqjeWP.d.ts → contract-CRilLVdx.d.ts}

@@ -250,6 +250,24 @@ interface RoomHost {
      * A host with no room list (the in-process test harness) records it and does nothing else.
      */
     setBackfill(open: boolean): void;
+    /**
+     * D75: `room.lobby.setPublic(v)`, and the terminal deregistration a game start performs.
+     *
+     * Fire-and-forget, and host state rather than room state, for exactly `setBackfill`'s reason:
+     * the supervisor holds it, reports it on the room list the agent already polls, and control
+     * turns that report into a registry row. None of which the room could arrange for itself and
+     * none of which belongs in the hibernation blob.
+     *
+     * `started` is a one-way door. A room that reports it is deregistered terminally, and no later
+     * report — raced, stale or forged — can put it back in front of a stranger.
+     *
+     * A host with no room list (the in-process test harness) records it and does nothing else.
+     */
+    setLobby(update: {
+        readonly public?: boolean;
+        readonly queue?: string;
+        readonly started?: boolean;
+    }): void;
     /**
      * D44: `room.spawnNPC(config)`. The host opens a loopback client session under `clientId` and
      * runs the named entry of the room definition's `npcs` map against it. The room minted the id,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { D as DEFAULT_TIMELINE_MAX_RECORDS, a as DEFAULT_TIMELINE_MAX_TICKS, E as EVENT_RING_SIZE, H as HOST_CALL_TIMEOUT_MS, b as HostCall, c as HostCallResult, J as JoinOptions, d as JoinResult, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, f as RoomEvent, g as RoomEventKind, h as RoomFullError, i as RoomHost, j as RoomInspection, k as RoomStats, T as TimelineDump, l as TimelineFrame, m as TimelineRecorder, n as TimelineRecorderOptions, o as inspectState } from './contract-DwxqjeWP.js';
-export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as MatterBodyRecord, b as MatterSection, c as Mulberry32, P as PhysicsEngineTag, d as PhysicsSection, R as RoomCore, e as decodeMatterBodies, f as decodeMatterSectionEnvelope, g as decodePhysicsSection, h as encodeMatterBodies, i as encodeMatterSectionEnvelope, j as encodePhysicsSection, k as initMatter, l as initPhysics, m as loadedMatter, n as loadedPhysics, p as physicsSectionEngine, r as resetMatterForTests, o as resetPhysicsForTests } from './room-CoQDczh2.js';
+export { D as DEFAULT_TIMELINE_MAX_RECORDS, a as DEFAULT_TIMELINE_MAX_TICKS, E as EVENT_RING_SIZE, H as HOST_CALL_TIMEOUT_MS, b as HostCall, c as HostCallResult, J as JoinOptions, d as JoinResult, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, f as RoomEvent, g as RoomEventKind, h as RoomFullError, i as RoomHost, j as RoomInspection, k as RoomStats, T as TimelineDump, l as TimelineFrame, m as TimelineRecorder, n as TimelineRecorderOptions, o as inspectState } from './contract-CRilLVdx.js';
+export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as MatterBodyRecord, b as MatterSection, c as Mulberry32, P as PhysicsEngineTag, d as PhysicsSection, R as RoomCore, e as decodeMatterBodies, f as decodeMatterSectionEnvelope, g as decodePhysicsSection, h as decodeRapier2dSectionEnvelope, i as encodeMatterBodies, j as encodeMatterSectionEnvelope, k as encodePhysicsSection, l as encodeRapier2dSectionEnvelope, m as initMatter, n as initPhysics, o as initRapier2d, p as loadedMatter, q as loadedPhysics, r as loadedRapier2d, s as physicsSectionEngine, t as resetMatterForTests, u as resetPhysicsForTests, v as resetRapier2dForTests } from './room-YJGz6Caw.js';
 import { CollectionDesc, AnySchema, PlainState, DirtySet } from '@irtio/schema';
 import '@irtio/protocol';
 import '@irtio/server';
@@ -121,7 +121,7 @@ interface DecodedSave extends SnapshotHeader {
      * there is no section at all. A pre-D45 blob has no discriminant and reads as `'rapier3d'`,
      * which is what it is.
      */
-    readonly physicsEngine: 'rapier3d' | 'matter2d' | undefined;
+    readonly physicsEngine: 'rapier3d' | 'matter2d' | 'rapier2d' | undefined;
     /**
      * The room's authoritative state, in exactly the shape `inspectState` and the recorded
      * timeline use: entity collections as `{ id: { owner, value } }`, singletons as their value.

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   fromMigrationState,
   migrateSnapshot,
   toMigrationState
-} from "./chunk-ZNNTF7Y3.js";
+} from "./chunk-DBGMG2S3.js";
 import {
   CRASH_AFTER_THROWS,
   DEFAULT_TIMELINE_MAX_RECORDS,
@@ -22,27 +22,32 @@ import {
   decodeMatterBodies,
   decodeMatterSectionEnvelope,
   decodePhysicsSection,
+  decodeRapier2dSectionEnvelope,
   decodeSave,
   encodeMatterBodies,
   encodeMatterSectionEnvelope,
   encodePhysicsSection,
+  encodeRapier2dSectionEnvelope,
   encodeViewDelta,
   encodeViewSnapshot,
   initMatter,
   initPhysics,
+  initRapier2d,
   inspectState,
   isVisible,
   loadedMatter,
   loadedPhysics,
+  loadedRapier2d,
   parseHibernationBlob,
   physicsSectionEngine,
   resetMatterForTests,
   resetPhysicsForTests,
+  resetRapier2dForTests,
   viewKeyFor,
   visibleNames,
   visibleTo,
   writeHibernationBlob
-} from "./chunk-EXPFVRD4.js";
+} from "./chunk-ZCD2TBXB.js";
 export {
   CRASH_AFTER_THROWS,
   DEFAULT_TIMELINE_MAX_RECORDS,
@@ -62,24 +67,29 @@ export {
   decodeMatterBodies,
   decodeMatterSectionEnvelope,
   decodePhysicsSection,
+  decodeRapier2dSectionEnvelope,
   decodeSave,
   encodeMatterBodies,
   encodeMatterSectionEnvelope,
   encodePhysicsSection,
+  encodeRapier2dSectionEnvelope,
   encodeViewDelta,
   encodeViewSnapshot,
   fromMigrationState,
   initMatter,
   initPhysics,
+  initRapier2d,
   inspectState,
   isVisible,
   loadedMatter,
   loadedPhysics,
+  loadedRapier2d,
   migrateSnapshot,
   parseHibernationBlob,
   physicsSectionEngine,
   resetMatterForTests,
   resetPhysicsForTests,
+  resetRapier2dForTests,
   toMigrationState,
   viewKeyFor,
   visibleNames,

package/dist/{room-CoQDczh2.d.ts → room-YJGz6Caw.d.ts}

@@ -1,7 +1,7 @@
 import { AttributeOptions, ProfileSnapshot } from '@irtio/protocol';
 import { DirtySet, AnySchema, PlainState, Tracked, State } from '@irtio/schema';
-import { RoomDefinition, RoomMode, Room, RewindView, Ctx, MatterModule, MatterEngine, MatterBody, RapierModule, RapierWorld, RapierRigidBody, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
-import { i as RoomHost, k as RoomStats, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, g as RoomEventKind, n as TimelineRecorderOptions, T as TimelineDump, j as RoomInspection, J as JoinOptions, d as JoinResult, c as HostCallResult } from './contract-DwxqjeWP.js';
+import { RoomDefinition, RoomMode, Room, RewindView, Ctx, MatterModule, MatterEngine, MatterBody, RapierModule, RapierWorld, RapierRigidBody, Rapier2dModule, Rapier2dWorld, Rapier2dRigidBody, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
+import { i as RoomHost, k as RoomStats, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, g as RoomEventKind, n as TimelineRecorderOptions, T as TimelineDump, j as RoomInspection, J as JoinOptions, d as JoinResult, c as HostCallResult } from './contract-CRilLVdx.js';
 
 /**
  * `room.random()` — mulberry32 over a u32 seed. Deterministic, tiny, and serializable: the
@@ -93,8 +93,8 @@ interface QueuedFrame {
 }
 /** What the core modules may do with the physics world (`core/physics.ts` implements it). */
 interface PhysicsApi {
-    /** D45: which of the two blessed engines this room is running. */
-    readonly engineKind: 'rapier3d' | 'matter2d';
+    /** D45: which of the blessed engines this room is running. */
+    readonly engineKind: 'rapier3d' | 'matter2d' | 'rapier2d';
     readonly timestep: number;
     /** Creates bodies for new instances, destroys bodies whose instance is gone. */
     reconcile(): void;
@@ -110,9 +110,9 @@ interface PhysicsApi {
      * `bodyFor`, and it never hands out the map itself.
      */
     eachTrackedBody(fn: (collection: string, id: string, body: unknown) => void): void;
-    /** rapier3d only. */
+    /** rapier3d and rapier2d: the engine namespace. `engineKind` says which module it is. */
     readonly rapier: unknown;
-    /** rapier3d only. */
+    /** rapier3d and rapier2d: the live `World`. */
     readonly world: unknown;
     /** matter2d only: the `matter-js` namespace. */
     readonly matter: unknown;
@@ -431,9 +431,27 @@ declare function encodePhysicsSection(section: PhysicsSection): Uint8Array;
  * pre-D45 blob is therefore byte-identical and reads as Rapier without a version bump, which is
  * what the recommendation in the plan asked for and why format 3 was not needed.
  */
-type PhysicsEngineTag = 'rapier3d' | 'matter2d';
-/** Reads the engine out of an encoded section without decoding the rest of it. */
+type PhysicsEngineTag = 'rapier3d' | 'matter2d' | 'rapier2d';
+/**
+ * Reads the engine out of an encoded section without decoding the rest of it.
+ *
+ * The `else` is deliberately bare rather than a third tag comparison: a pre-D45 blob has no
+ * discriminant at all, and every byte sequence that is not the zero-length-world envelope is a
+ * rapier3d world snapshot. Adding rapier2d must not change that, or every blob written before
+ * this engine existed stops decoding.
+ */
 declare function physicsSectionEngine(bytes: Uint8Array): PhysicsEngineTag;
+/**
+ * Wraps a rapier2d section in the same discriminated envelope, under its own tag.
+ *
+ * The payload is an ordinary {@link encodePhysicsSection} — rapier2d has a real
+ * `world.takeSnapshot()`, so unlike matter2d it has a world to write, and the only thing the
+ * envelope buys is telling the two Rapiers apart. Restoring a 2D snapshot into a 3D world (or the
+ * reverse) does not fail cleanly, which is exactly why the discriminant is not optional here.
+ */
+declare function encodeRapier2dSectionEnvelope(payload: Uint8Array): Uint8Array;
+/** The payload inside a rapier2d envelope. Throws if the section was written by another engine. */
+declare function decodeRapier2dSectionEnvelope(bytes: Uint8Array): Uint8Array;
 /** Wraps a matter2d body-state payload in the discriminated envelope. */
 declare function encodeMatterSectionEnvelope(payload: Uint8Array): Uint8Array;
 /** The payload inside a matter2d envelope. Throws if the section is a Rapier one. */
@@ -501,6 +519,106 @@ declare class PhysicsRuntime {
     serialize(): PhysicsSection;
 }
 
+/**
+ * The rapier2d world inside the room: Rapier, held in a plane.
+ *
+ * It is modelled on `core/physics.ts` rather than on `core/matter.ts`, and the choice is the whole
+ * point of the engine existing. Everything that made the Rapier path good is kept:
+ *
+ * - **A real engine snapshot.** `world.takeSnapshot()` / `World.restoreSnapshot()` exist in the 2D
+ *   build too, so a woken room is byte-for-byte the world that went to sleep, contacts and sleep
+ *   timers included, and `setup` runs only on a genuine rebuild. matter2d has no equivalent and
+ *   rebuilds every wake; that difference is why a settled pile can jolt there and does not here.
+ * - **The world applies gravity.** It goes into the `World` constructor and dynamic bodies fall
+ *   without the room lifting a finger. A matter2d room's hooks apply gravity themselves; a
+ *   rapier2d room that copied that would fall twice as fast.
+ * - **Velocities are per second.** `linvel()` is metres per second, not matter's per-step
+ *   displacement, so nothing here rescales anything.
+ *
+ * What it takes from the 2D side is only the plane: `{ x, y }` gravity, and the channel mapping in
+ * `@irtio/schema` (`channelOf2d` / `applyChannel2d` / `angleFrom2d`), which is the single place the
+ * six planar quantities are written onto the thirteen 3D wire channels. A second copy of that
+ * mapping here would be a way for the two sides to disagree by a sign, so there is not one.
+ *
+ * There is no planar-lock warning in this file. Bug 6's friction trap needs a third axis to lock,
+ * and this engine does not have one.
+ *
+ * ## Async init
+ *
+ * Rapier's WASM needs `await RAPIER.init()`, and room handlers are synchronous, so the engine is
+ * initialized before the room is constructed — by the worker host at bundle-load time, and by
+ * `initRapier2d()` in the test harness. This is `initPhysics()`'s twin, against the 2D module.
+ */
+
+/**
+ * Loads and initializes `@dimforge/rapier2d-compat` once per process. Idempotent and safe to call
+ * concurrently. It is a *separate* WASM module from the 3D build — the two do not share an
+ * instance and loading one does not load the other — so a rapier2d room pays the 2D module's
+ * footprint and nothing else.
+ */
+declare function initRapier2d(): Promise<Rapier2dModule>;
+/** The initialized engine, or `undefined` when `initRapier2d()` has not resolved yet. */
+declare function loadedRapier2d(): Rapier2dModule | undefined;
+/** Test seam: forget the loaded engine (never used in production paths). */
+declare function resetRapier2dForTests(): void;
+interface Rapier2dRuntimeOptions {
+    /** From a v2 hibernation blob's rapier2d section. Absent → a fresh world, and `setup` runs. */
+    readonly restore?: PhysicsSection;
+    /** Seconds per step when the config does not name one (the tick interval). */
+    readonly defaultTimestep: number;
+}
+declare class Rapier2dRuntime {
+    readonly engineKind: "rapier2d";
+    /** matter2d only; present so every runtime satisfies one internal shape. */
+    readonly matter: undefined;
+    readonly matterEngine: undefined;
+    readonly rapier: Rapier2dModule;
+    readonly world: Rapier2dWorld;
+    /** `true` when the world was built from scratch and `setup` has to run. */
+    readonly rebuilt: boolean;
+    /** Rapier restores a whole world, contacts included, so `setup` runs only on a rebuild. */
+    get needsSetup(): boolean;
+    private readonly core;
+    private readonly config;
+    /** Physics-backed collections, in schema (name-sorted) order. */
+    private readonly collections;
+    private readonly bodies;
+    /** See `PhysicsRuntime.sleepSynced`: the one extra sync a body owes on the tick it sleeps. */
+    private readonly sleepSynced;
+    constructor(core: RoomInternals, rapier: Rapier2dModule, options: Rapier2dRuntimeOptions);
+    get timestep(): number;
+    /** Runs the room's `setup` — static geometry — on a world that was built rather than restored. */
+    runSetup(room: Room): void;
+    free(): void;
+    /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
+    bodyFor(collection: string, id: string): Rapier2dRigidBody | undefined;
+    private create;
+    /**
+     * 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: (collection: string, id: string, body: Rapier2dRigidBody) => void): void;
+    private applyRecordToBody;
+    /**
+     * 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(): void;
+    step(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): PhysicsSection;
+}
+
 /**
  * `RoomCore` — the host-agnostic room runtime. It owns the extended schema, the
  * tracked authority state, presence, the loop, and the frame dispatch; everything outside comes
@@ -521,7 +639,7 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
     readonly clients: Map<string, ClientEntry>;
     readonly loop: Loop;
     /** D22: the Rapier world, or `undefined` in a room whose config declares no physics. */
-    readonly physics: PhysicsRuntime | MatterRuntime | undefined;
+    readonly physics: PhysicsRuntime | MatterRuntime | Rapier2dRuntime | undefined;
     readonly stats: RoomStats;
     tick: number;
     stopped: boolean;
@@ -596,6 +714,12 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
      * worth logging.
      */
     private buildMatter;
+    /**
+     * 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.
+     */
+    private buildRapier2d;
     /** Convenience for hosts: `RoomCore.restore(def, bytes, host, opts)`. */
     static restore<S2 extends AnySchema>(definition: RoomDefinition<S2>, bytes: Uint8Array, host: RoomHost, options: Omit<RoomCoreOptions, 'restoreFrom'>): RoomCore<S2>;
     get schema(): S;
@@ -707,4 +831,4 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
     flush(): void;
 }
 
-export { CRASH_AFTER_THROWS as C, MAX_CATCHUP as M, type PhysicsEngineTag as P, RoomCore as R, type MatterBodyRecord as a, type MatterSection as b, Mulberry32 as c, type PhysicsSection as d, decodeMatterBodies as e, decodeMatterSectionEnvelope as f, decodePhysicsSection as g, encodeMatterBodies as h, encodeMatterSectionEnvelope as i, encodePhysicsSection as j, initMatter as k, initPhysics as l, loadedMatter as m, loadedPhysics as n, resetPhysicsForTests as o, physicsSectionEngine as p, resetMatterForTests as r };
+export { CRASH_AFTER_THROWS as C, MAX_CATCHUP as M, type PhysicsEngineTag as P, RoomCore as R, type MatterBodyRecord as a, type MatterSection as b, Mulberry32 as c, type PhysicsSection as d, decodeMatterBodies as e, decodeMatterSectionEnvelope as f, decodePhysicsSection as g, decodeRapier2dSectionEnvelope as h, encodeMatterBodies as i, encodeMatterSectionEnvelope as j, encodePhysicsSection as k, encodeRapier2dSectionEnvelope as l, initMatter as m, initPhysics as n, initRapier2d as o, loadedMatter as p, loadedPhysics as q, loadedRapier2d as r, physicsSectionEngine as s, resetMatterForTests as t, resetPhysicsForTests as u, resetRapier2dForTests as v };

package/dist/test/index.d.ts

@@ -1,8 +1,8 @@
-import { R as RoomCore } from '../room-CoQDczh2.js';
-export { k as initMatter, l as initPhysics } from '../room-CoQDczh2.js';
+import { R as RoomCore } from '../room-YJGz6Caw.js';
+export { m as initMatter, n as initPhysics, o as initRapier2d } from '../room-YJGz6Caw.js';
 import { ErrorCodeName, FrameType } from '@irtio/protocol';
 import { NpcConfig, LeaveReason, Room, RoomDefinition } from '@irtio/server';
-import { i as RoomHost, L as LogLevel, R as RoomCoreApi, b as HostCall, c as HostCallResult, k as RoomStats } from '../contract-DwxqjeWP.js';
+import { i as RoomHost, L as LogLevel, R as RoomCoreApi, b as HostCall, c as HostCallResult, k as RoomStats } from '../contract-CRilLVdx.js';
 import { AnySchema, PlainState, EntityCollection, State } from '@irtio/schema';
 
 /**
@@ -166,6 +166,17 @@ declare class HarnessHost implements RoomHost {
     /** D63-e: the harness has no room list to report on, so it records the value and stops. */
     backfillOpen: boolean | undefined;
     setBackfill(open: boolean): void;
+    /** D75: recorded, like the backfill flag, and for the same reason — no room list to report on. */
+    lobby: {
+        public?: boolean;
+        queue?: string;
+        started?: boolean;
+    };
+    setLobby(update: {
+        readonly public?: boolean;
+        readonly queue?: string;
+        readonly started?: boolean;
+    }): void;
     busPublish(channel: string, payload: string): void;
     busSubscribe(channel: string, subscribed: boolean): void;
     setAlarm(name: string, atMs: number | undefined): void;

package/dist/test/index.js

@@ -3,8 +3,9 @@ import {
   createVisibilityPolicy,
   initMatter,
   initPhysics,
+  initRapier2d,
   visibleNames
-} from "../chunk-EXPFVRD4.js";
+} from "../chunk-ZCD2TBXB.js";
 
 // src/test/clock.ts
 var FakeClock = class {
@@ -235,6 +236,12 @@ var HarnessHost = class {
   setBackfill(open) {
     this.backfillOpen = open;
   }
+  // ---- M6 lane H: lobby front door ----
+  /** D75: recorded, like the backfill flag, and for the same reason — no room list to report on. */
+  lobby = {};
+  setLobby(update) {
+    this.lobby = { ...this.lobby, ...update };
+  }
   busPublish(channel, payload) {
     this.busPublishes.push({ channel, payload });
   }
@@ -974,5 +981,6 @@ export {
   createRoomHarness,
   frameTypeName,
   initMatter,
-  initPhysics
+  initPhysics,
+  initRapier2d
 };

package/dist/worker/index.d.ts

@@ -1,4 +1,4 @@
-import { L as LogLevel, T as TimelineDump, k as RoomStats, b as HostCall, c as HostCallResult, R as RoomCoreApi, i as RoomHost } from '../contract-DwxqjeWP.js';
+import { L as LogLevel, T as TimelineDump, k as RoomStats, b as HostCall, c as HostCallResult, R as RoomCoreApi, i as RoomHost } from '../contract-CRilLVdx.js';
 import { ErrorCodeName, ProfileSnapshot } from '@irtio/protocol';
 import { NpcConfig, LeaveReason } from '@irtio/server';
 import '@irtio/schema';
@@ -151,6 +151,9 @@ type FromWorker = {
         /** D63-e: the room type's declared backfill eligibility. The ceiling on
          *  `room.backfill.set`, and `false` for every room that declares nothing. */
         backfill?: boolean;
+        /** D75: the room type declared a lobby. The ceiling on `setLobby`, and the supervisor
+         *  re-checks it for exactly the reason it re-checks `backfill`. */
+        lobby?: boolean;
         /** D47: the physics engine this room runs, when it declares one. Reported so room-hours
          *  rows carry the engine as a dimension; the supervisor never acts on it. */
         engine?: string;
@@ -289,6 +292,11 @@ type FromWorker = {
  | {
     t: 'setBackfill';
     open: boolean;
+} | {
+    t: 'setLobby';
+    public?: boolean;
+    queue?: string;
+    started?: boolean;
 }
 /**
  * D59: `room.bus.publish(channel, payload)`. Fire-and-forget by design — the room gets no

package/dist/worker/index.js

@@ -1,14 +1,15 @@
 import {
   migrateSnapshot
-} from "../chunk-ZNNTF7Y3.js";
+} from "../chunk-DBGMG2S3.js";
 import {
   RoomCore,
   RoomFullError,
   initMatter,
   initPhysics,
+  initRapier2d,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-EXPFVRD4.js";
+} from "../chunk-ZCD2TBXB.js";
 
 // src/worker/index.ts
 import { getHeapStatistics } from "v8";
@@ -79,6 +80,10 @@ function createWorkerHost(post) {
     setBackfill(open) {
       post({ t: "setBackfill", open });
     },
+    // ---- M6 lane H: lobby front door ----
+    setLobby(update) {
+      post({ t: "setLobby", ...update });
+    },
     setAlarm(name, atMs) {
       if (atMs === void 0) {
         post({ t: "setAlarm", name });
@@ -153,7 +158,8 @@ async function handleMessage(state, host, post, msg) {
           try {
             if (def.config.physics.engine === "matter2d") await initMatter();
             else {
-              await initPhysics();
+              if (def.config.physics.engine === "rapier2d") await initRapier2d();
+              else await initPhysics();
               onFirstRapierStep(() => {
                 const core = state.core;
                 if (core) post(statsPayload(core.stats, void 0, core.profile()));
@@ -211,6 +217,11 @@ async function handleMessage(state, host, post, msg) {
               // `engine` is: `ready.config` replaces the supervisor's copy, so a flag threaded
               // only through `loadBundle` would be dropped the moment a worker started.
               backfill: c.backfill === true,
+              // ---- M6 lane H: lobby front door ----
+              // D75: the declared ceiling on `setLobby`, carried for exactly `backfill`'s reason.
+              // The supervisor re-checks it, because a check only the tenant's own worker makes is
+              // advice rather than a boundary.
+              lobby: c.lobby !== void 0,
               // D47: `ready.config` REPLACES the supervisor's copy of the bundle config, so an
               // engine threaded only through `loadBundle` would be dropped here the moment a
               // worker started. That is exactly how the first known-shape run read `engine: none`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/runtime",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
   "publishConfig": {
@@ -28,11 +28,12 @@
     "dist"
   ],
   "dependencies": {
+    "@dimforge/rapier2d-compat": "0.20.0",
     "@dimforge/rapier3d-compat": "0.20.0",
     "matter-js": "0.20.0",
-    "@irtio/protocol": "0.7.0",
-    "@irtio/schema": "0.7.0",
-    "@irtio/server": "0.7.0"
+    "@irtio/protocol": "0.8.0",
+    "@irtio/schema": "0.8.0",
+    "@irtio/server": "0.8.0"
   },
   "devDependencies": {
     "@types/matter-js": "0.20.2"