@irtio/runtime 0.7.0 → 0.9.0

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

@@ -1,7 +1,7 @@
 import {
   parseHibernationBlob,
   writeHibernationBlob
-} from "./chunk-EXPFVRD4.js";
+} from "./chunk-ADZZEVJU.js";
 
 // src/migrate.ts
 import { PRESENCE_COLLECTION, withBuiltins } from "@irtio/protocol";
@@ -53,7 +53,15 @@ function migrateSnapshot(blob, chain, options) {
   }
   plain = fromMigrationState(withBuiltins(schema), state, last.version);
   const bytes = writeHibernationBlob(
-    { seed: parsed.seed, rngState: parsed.rngState, tick: parsed.tick, mode: parsed.mode },
+    {
+      seed: parsed.seed,
+      rngState: parsed.rngState,
+      tick: parsed.tick,
+      mode: parsed.mode,
+      // Stamped with the *target* schema: these bytes are now that schema's, and a room waking on
+      // it must not see them as a mismatch.
+      schemaHash8: withBuiltins(schema).hash8
+    },
     encodeSnapshot(withBuiltins(schema), plain, { tick: parsed.tick })
   );
   return {

package/dist/{contract-DwxqjeWP.d.ts → contract-C5aqs49-.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,
@@ -284,7 +302,11 @@ interface RoomHost {
 }
 interface RoomCoreOptions {
     readonly roomId: string;
-    /** Seed for `room.random()`; default 1. */
+    /**
+     * Seed for `room.random()`. Defaults to a stable 32-bit hash of `roomId`, so two rooms of the
+     * same game generate different worlds; pass a number to pin the sequence instead. A room
+     * restored from a snapshot ignores both and keeps the seed it was created with.
+     */
     readonly seed?: number;
     /** Base URL for `room.link` (`<publicUrl>?room=<id>`); default `http://localhost/`. */
     readonly publicUrl?: string;

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-C5aqs49-.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-C4RZJ2KO.js';
 import { CollectionDesc, AnySchema, PlainState, DirtySet } from '@irtio/schema';
 import '@irtio/protocol';
 import '@irtio/server';
@@ -70,9 +70,16 @@ declare function catchUpDirty(ext: AnySchema, plain: PlainState, fromRole: strin
  *   u32 rng state
  *   u32 tick
  *   u8  mode (1 = event, 0 = tick)
+ *   [v3] 8 bytes schema hash (`withBuiltins(schema).hash8`)
  *   [v2] blob physics section (varint length + bytes; length 0 = no world)
  *   ... encodeSnapshot(withBuiltins(schema), state)
  *
+ * **v3** adds the schema hash. Before it, restoring a snapshot written under a different schema
+ * fed the old bytes to the new decoder and surfaced as a `TypeError` from deep inside the string
+ * decoder; the room could only be started again by hand-deleting `.irtio/snapshots`. The hash is
+ * in the envelope (not only in the codec payload) so the check costs no decode: a mismatch is
+ * seen, logged and the snapshot discarded before anything is parsed against the wrong schema.
+ *
  * **v2 (week 9, D22)** adds the physics section: the Rapier world snapshot plus the entity↔handle
  * map (`core/physics.ts` encodes it). It rides *inside* this blob rather than beside it so that
  * wake is atomic — state and world always come back from the same bytes, and every store, cache
@@ -89,8 +96,8 @@ declare function catchUpDirty(ext: AnySchema, plain: PlainState, fromRole: strin
  * instead of parsing bytes it may not yet know how to read.
  */
 
-/** Written when the blob carries a physics world; v1 otherwise (and v1 is still read). */
-declare const SNAPSHOT_FORMAT_VERSION = 2;
+/** Written when the header carries a schema hash (every room does); older versions still read. */
+declare const SNAPSHOT_FORMAT_VERSION = 3;
 /** Versions this build can parse. */
 declare const READABLE_SNAPSHOT_VERSIONS: readonly number[];
 type SnapshotMode = 'tick' | 'event';
@@ -99,6 +106,12 @@ interface SnapshotHeader {
     readonly rngState: number;
     readonly tick: number;
     readonly mode: SnapshotMode;
+    /**
+     * `withBuiltins(schema).hash8` of the schema these bytes were written under. Omitted only by a
+     * writer that has no schema in hand; a restore that finds it absent cannot check and proceeds
+     * as pre-v3 builds did.
+     */
+    readonly schemaHash8?: Uint8Array | undefined;
 }
 interface ParsedSnapshot extends SnapshotHeader {
     /** The blob's own format version (1 or 2). */
@@ -121,7 +134,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-SBDZ45JG.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-ADZZEVJU.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-C4RZJ2KO.d.ts}

@@ -1,12 +1,8 @@
 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-C5aqs49-.js';
 
-/**
- * `room.random()` — mulberry32 over a u32 seed. Deterministic, tiny, and serializable: the
- * generator's whole state is one u32, so `serialize()`/`restore()` round-trip it exactly.
- */
 declare class Mulberry32 {
     /** Current internal state (u32). Survives hibernation. */
     state: number;
@@ -93,8 +89,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 +106,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;
@@ -139,6 +135,8 @@ interface RoomInternals {
     readonly ext: AnySchema;
     readonly host: RoomHost;
     readonly roomId: string;
+    /** The resolved RNG seed: explicit option, else derived from the room id; restored on wake. */
+    readonly seed: number;
     readonly mode: RoomMode;
     /** The plain state the tracked proxies wrap (what the codec reads). */
     readonly plain: PlainState;
@@ -346,6 +344,15 @@ declare class MatterRuntime {
     private readonly restore;
     private readonly stepMs;
     private readonly sleepSynced;
+    /**
+     * 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.
+     */
+    private readonly sourceRecords;
+    /** `collection.field` pairs already warned about a channel a plane cannot hold. */
+    private readonly warnedChannels;
     constructor(core: RoomInternals, matter: MatterModule, options: MatterRuntimeOptions);
     get timestep(): number;
     runSetup(room: Room): void;
@@ -431,9 +438,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. */
@@ -470,6 +495,19 @@ declare class PhysicsRuntime {
      * world rebuilt from schema state would wake it with a kick). Found by the drift check.
      */
     private readonly sleepSynced;
+    /**
+     * 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.
+     */
+    private readonly sourceRecords;
+    /** `collection.field` pairs already warned about a channel value the engine would not take. */
+    private readonly warnedChannels;
     constructor(core: RoomInternals, rapier: RapierModule, options: PhysicsRuntimeOptions);
     get timestep(): number;
     /** Runs the room's `setup` — static geometry — on a world that was built rather than restored. */
@@ -478,6 +516,17 @@ declare class PhysicsRuntime {
     /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
     bodyFor(collection: string, id: string): RapierRigidBody | undefined;
     private create;
+    /**
+     * 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.
+     */
+    private warnLockedChannels;
     /**
      * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
      * order). Read-only: it hands out the live bodies and nothing else, and the map stays private.
@@ -501,6 +550,128 @@ 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;
+    /**
+     * 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.
+     */
+    private readonly sourceRecords;
+    /** `collection.field` pairs already warned about a channel value the engine would not take. */
+    private readonly warnedChannels;
+    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;
+    /**
+     * 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.
+     */
+    private warnLockedChannels;
+    /**
+     * 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 +692,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;
@@ -550,7 +721,7 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
      * it again over its next `history` ticks.
      */
     private readonly rewindState;
-    private readonly seed;
+    readonly seed: number;
     private readonly api;
     private readonly internals;
     private started;
@@ -596,6 +767,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 +884,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-C4RZJ2KO.js';
+export { m as initMatter, n as initPhysics, o as initRapier2d } from '../room-C4RZJ2KO.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-C5aqs49-.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;
@@ -320,7 +331,7 @@ interface FakeClient<S extends AnySchema = AnySchema> {
  */
 
 interface HarnessOptions {
-    /** `room.random()` seed; default 1 (same as `RoomCore`). */
+    /** `room.random()` seed; defaults to a hash of `roomId`, exactly as `RoomCore` does. */
     readonly seed?: number;
     /** Base URL for `room.link`. */
     readonly publicUrl?: string;

package/dist/test/index.js

@@ -3,8 +3,9 @@ import {
   createVisibilityPolicy,
   initMatter,
   initPhysics,
+  initRapier2d,
   visibleNames
-} from "../chunk-EXPFVRD4.js";
+} from "../chunk-ADZZEVJU.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 });
   }
@@ -670,7 +677,7 @@ var Harness = class {
     this.host.onSend = (clientId, frame) => this.deliver(clientId, frame);
     this.coreRef = new RoomCore(definition, this.host, {
       roomId: options.roomId ?? "test-room",
-      seed: options.seed ?? 1,
+      ...options.seed !== void 0 ? { seed: options.seed } : {},
       ...options.publicUrl !== void 0 ? { publicUrl: options.publicUrl } : {},
       ...options.restoreFrom !== void 0 ? { restoreFrom: options.restoreFrom } : {}
     });
@@ -956,7 +963,7 @@ var Harness = class {
     this.nextClientId = 1;
     this.coreRef = RoomCore.restore(this.definition, bytes, this.host, {
       roomId: this.options.roomId ?? "test-room",
-      seed: this.options.seed ?? 1,
+      ...this.options.seed !== void 0 ? { seed: this.options.seed } : {},
       ...this.options.publicUrl !== void 0 ? { publicUrl: this.options.publicUrl } : {}
     });
     this.coreRef.start();
@@ -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-C5aqs49-.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-SBDZ45JG.js";
 import {
   RoomCore,
   RoomFullError,
   initMatter,
   initPhysics,
+  initRapier2d,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-EXPFVRD4.js";
+} from "../chunk-ADZZEVJU.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`