@irtio/runtime 0.6.0 → 0.8.0

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

@@ -136,6 +136,10 @@ type HostCall = {
     readonly board: string;
     readonly playerId: string;
     readonly score: number;
+    /** M6 lane B (D69-c): the cohort of a bucketed board. Absent on every board that declares
+     *  no buckets, which is every board that existed before M6. There is deliberately no
+     *  `period` beside it: rotation is control's clock, never the room's. */
+    readonly bucket?: string;
 }
 /**
  * D59: `room.bus.send(roomId, payload)` — directed, durable, at-least-once delivery to one room
@@ -246,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,
@@ -340,6 +362,13 @@ interface RoomStats {
     membershipEnters: number;
     membershipLeaves: number;
     corrections: number;
+    /**
+     * D70: typed peer messages this room refused to hand to `onMessage` — an index its schema does
+     * not have, or a payload the codec would not decode. Every one of them is a peer sending
+     * something this room's schema does not describe, so a number climbing here means a client on a
+     * stale build or one probing, and never a room bug.
+     */
+    messagesDropped: number;
 }
 /** The surface the worker host and the harness drive. Implemented by `RoomCore`. */
 interface RoomCoreApi<S extends AnySchema = AnySchema> {

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-BjMsoJIV.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-CfnEjlcg.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-VMCE3LRO.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-K42HA75G.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-CfnEjlcg.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, 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-BjMsoJIV.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;
@@ -102,9 +102,17 @@ interface PhysicsApi {
     /** Body → schema, through the tracked proxies. */
     sync(): void;
     bodyFor(collection: string, id: string): unknown;
-    /** rapier3d only. */
+    /**
+     * D72: every body this runtime tracks, in the same collection-then-instance order `sync()`
+     * walks. Read-only and allocation-free: the pose history calls it once per tick to copy poses
+     * out, and the rewind scratch calls it to keep its doubles in step with the live world. It is
+     * the only thing outside the engine runtimes that sees a live body other than through
+     * `bodyFor`, and it never hands out the map itself.
+     */
+    eachTrackedBody(fn: (collection: string, id: string, body: unknown) => void): void;
+    /** 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;
@@ -151,6 +159,13 @@ interface RoomInternals {
     guard<T>(name: string, fn: () => T): T | undefined;
     /** D41: record this tick on the authoritative timeline. A no-op while the recorder is unarmed. */
     captureTimeline(): void;
+    /**
+     * D72: record this tick's body poses. A no-op — and, more to the point, a call that never
+     * reaches the engine runtime at all — in a room whose config declares no `physics.history`.
+     */
+    captureHistory(): void;
+    /** D72: `room.rewind(tick, fn)`. Throws when the room declares no `physics.history`. */
+    rewind<T>(tick: number, fn: (past: RewindView) => T): T;
     recordEvent(kind: 'join' | 'leave' | 'write' | 'write-rejected' | 'correct' | 'call' | 'reply' | 'msg' | 'alarm' | 'bus' | 'error', clientId?: string, detail?: string): void;
     /** `guard` that also reports whether the handler threw (the tick loop needs this). */
     tryRun<T>(name: string, fn: () => T): GuardResult<T>;
@@ -337,6 +352,11 @@ declare class MatterRuntime {
     free(): void;
     bodyFor(collection: string, id: string): MatterBody | undefined;
     private create;
+    /**
+     * D72: every tracked body, in the order `sync()` walks them. The matter half of the same
+     * read-only accessor `PhysicsRuntime` carries; see its comment for what calls it and when.
+     */
+    eachTrackedBody(fn: (collection: string, id: string, body: MatterBody) => void): void;
     private applyState;
     private applyRecordToBody;
     reconcile(): void;
@@ -411,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. */
@@ -458,6 +496,13 @@ 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;
+    /**
+     * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
+     * order). Read-only: it hands out the live bodies and nothing else, and the map stays private.
+     * The pose history calls this once per tick and the rewind scratch calls it per rewind; a room
+     * that declares no `physics.history` never calls it at all.
+     */
+    eachTrackedBody(fn: (collection: string, id: string, body: RapierRigidBody) => void): void;
     private applyRecordToBody;
     /**
      * Creates bodies for new instances and destroys bodies whose instance is gone. Runs once per
@@ -474,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
@@ -494,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;
@@ -516,6 +661,13 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
      * cost the profiler has is behind this `undefined`.
      */
     private readonly ledger;
+    /**
+     * D72: the pose history and the rewind scratch, present only when the room's physics config
+     * declares `history`. Every cost this lane has is behind this `undefined`, and it is
+     * deliberately not in the hibernation blob: a woken room starts with an empty buffer and fills
+     * it again over its next `history` ticks.
+     */
+    private readonly rewindState;
     private readonly seed;
     private readonly api;
     private readonly internals;
@@ -562,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;
@@ -581,6 +739,17 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
     recording(): TimelineDump | undefined;
     /** D41: called at the end of every tick (and every event-mode flush). No-op when unarmed. */
     captureTimeline(): void;
+    /**
+     * D72: record this tick's body poses, right after `physics.sync()` — the poses the clients are
+     * about to be told about, under the tick number they will be told it under, which is the tick a
+     * client later stamps its `CALL` with.
+     */
+    captureHistory(): void;
+    /**
+     * D72: `room.rewind(tick, fn)`. The live world is not touched and nothing is re-simulated; `fn`
+     * queries a scratch world holding every tracked body at its pose at `tick`.
+     */
+    rewind<T>(tick: number, fn: (past: RewindView) => T): T;
     /** Live JSON view of the room for the dev page / supervisor admin API. */
     inspect(): RoomInspection;
     guard<T>(name: string, fn: () => T): T | undefined;
@@ -662,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-CfnEjlcg.js';
-export { k as initMatter, l as initPhysics } from '../room-CfnEjlcg.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-BjMsoJIV.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-K42HA75G.js";
+} from "../chunk-ZCD2TBXB.js";
 
 // src/test/clock.ts
 var FakeClock = class {
@@ -197,7 +198,7 @@ var HarnessHost = class {
         return { ok: true };
       }
       case "lbSubmit": {
-        const key = `${call.board} ${call.playerId}`;
+        const key = call.bucket === void 0 ? `${call.board} ${call.playerId}` : `${call.board} ${call.bucket} ${call.playerId}`;
         const existing = this.scores.get(key);
         if (existing === void 0 || call.score > existing) this.scores.set(key, call.score);
         return { ok: true };
@@ -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-BjMsoJIV.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-VMCE3LRO.js";
+} from "../chunk-DBGMG2S3.js";
 import {
   RoomCore,
   RoomFullError,
   initMatter,
   initPhysics,
+  initRapier2d,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-K42HA75G.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.6.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.6.0",
-    "@irtio/schema": "0.6.0",
-    "@irtio/server": "0.6.0"
+    "@irtio/protocol": "0.8.0",
+    "@irtio/schema": "0.8.0",
+    "@irtio/server": "0.8.0"
   },
   "devDependencies": {
     "@types/matter-js": "0.20.2"