@irtio/client 0.7.0 → 0.8.0

package/dist/{chunk-XWVXZRBS.js → chunk-5Z4DHUA3.js}

@@ -11,6 +11,7 @@ function emptyPredictionStats() {
     resimSteps: 0,
     rebases: 0,
     snaps: 0,
+    leadClamped: 0,
     suppressed: 0,
     overCap: 0,
     proxies: 0,

package/dist/{chunk-DABQDR3S.js → chunk-XFD6WYQW.js}

@@ -5,7 +5,7 @@ import {
   RESIM_DEPTH,
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS
-} from "./chunk-XWVXZRBS.js";
+} from "./chunk-5Z4DHUA3.js";
 
 // src/predictor.ts
 var MAX_FREE_STEPS_PER_FRAME = 5;
@@ -133,6 +133,7 @@ var Predictor = class _Predictor {
     resimSteps: 0,
     rebases: 0,
     snaps: 0,
+    leadClamped: 0,
     suppressed: 0,
     overCap: 0,
     proxies: 0,
@@ -951,8 +952,8 @@ var Predictor = class _Predictor {
    * written, so plain state holds exactly what the server said), then re-step the world by the
    * client's lead, applying to each re-stepped tick the intent that was in force *at that tick*:
    * the newest buffered unjudged write stamped at or before it, or the baseline (the newest
-   * judged write) before the first of them. Bounded by `MAX_LEAD`: an outrun lead snaps to
-   * authority and counts (`stats.snaps`).
+   * judged write) before the first of them. Bounded by `MAX_LEAD`: an outrun lead re-steps that
+   * many and counts (`stats.leadClamped`, bugs.md #71).
    */
   rebase() {
     if (!this.worldReady) return;
@@ -966,7 +967,9 @@ var Predictor = class _Predictor {
       const k = key(entry.desc.name, entry.id);
       this.predictedTicks.set(k, Math.max(this.authorityTick, this.authorityTicks.get(k) ?? 0));
     }
-    const lead = this.leadTicks();
+    const wanted = this.leadTicks();
+    const lead = Math.min(wanted, MAX_LEAD);
+    if (wanted > MAX_LEAD) this.stats.leadClamped++;
     if (this.lastLead !== void 0 && lead !== this.lastLead && this.gapMeasured) {
       const delta = lead - this.lastLead;
       this.stampGap = Math.min(RESIM_DEPTH, Math.max(0, this.stampGap + delta));
@@ -975,10 +978,6 @@ var Predictor = class _Predictor {
     }
     this.lastLead = lead;
     this.headTick = this.authorityTick;
-    if (lead > MAX_LEAD) {
-      this.stats.snaps++;
-      return;
-    }
     const replays = /* @__PURE__ */ new Map();
     for (const entry of this.bodies.values()) {
       if (!entry.owned) continue;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { AnySchema, PlainState, CollectionDesc, Delta, EntityCollection, PhysicsBodyChannel, ReadonlyCollection, RoleOf, VisibleKeys, SchemaDefs, EntityDef, DeepReadonly, InferFields, Owned, SingletonDef, ClientImplementations, ClientRpcs, SchemaRpc, MessageChannels, ClientCallProxy } from '@irtio/schema';
+import { AnySchema, PlainState, CollectionDesc, Delta, EntityCollection, PhysicsBodyChannel, ClientImplementations, ClientRpcs, SchemaRpc, RoleOf, VisibleKeys, SchemaDefs, EntityDef, ReadonlyCollection, DeepReadonly, InferFields, Owned, SingletonDef, ClientCallProxy, MessageChannels } from '@irtio/schema';
 import * as _irtio_protocol from '@irtio/protocol';
 import { PresenceRecord, ProfileLedger, ProfileSnapshot } from '@irtio/protocol';
+import RAPIER2D from '@dimforge/rapier2d-compat';
 import * as MATTER from 'matter-js';
 import RAPIER from '@dimforge/rapier3d-compat';
 
@@ -345,8 +346,21 @@ interface PredictionStats {
     resimSteps: number;
     /** Rebase passes (one per authoritative arrival batch). */
     rebases: number;
-    /** Rebases whose lead outran the resim depth: the body snapped to authority. */
+    /**
+     * Rebases that rendered every body at authority. Since bugs.md #71 an outrun lead clamps
+     * instead of snapping (`leadClamped`), so nothing increments this today; the field stays
+     * because a zero here is a fence several suites hold, and a future hard-snap path would count
+     * here again.
+     */
     snaps: number;
+    /**
+     * Rebases whose lead outran `MAX_LEAD` and were re-stepped that many ticks instead (bugs.md
+     * #71). The local character still answers input; the anchor sits closer to authority than the
+     * round trip wants, so releases overshoot by the difference. A value that climbs and keeps
+     * climbing means the measured rtt is past the cap's horizon (667 ms at 60 Hz) — degraded
+     * prediction, where a snap would have been none.
+     */
+    leadClamped: number;
     /** Corrections whose values matched the local prediction within epsilon. */
     suppressed: number;
     /**
@@ -788,8 +802,8 @@ declare class Predictor {
      * written, so plain state holds exactly what the server said), then re-step the world by the
      * client's lead, applying to each re-stepped tick the intent that was in force *at that tick*:
      * the newest buffered unjudged write stamped at or before it, or the baseline (the newest
-     * judged write) before the first of them. Bounded by `MAX_LEAD`: an outrun lead snaps to
-     * authority and counts (`stats.snaps`).
+     * judged write) before the first of them. Bounded by `MAX_LEAD`: an outrun lead re-steps that
+     * many and counts (`stats.leadClamped`, bugs.md #71).
      */
     private rebase;
     /**
@@ -826,6 +840,126 @@ declare class Predictor {
     private isF32;
 }
 
+/**
+ * The rapier2d half of client-side physics prediction: `joinRoom({ physics2d: { engine:
+ * 'rapier2d', … } })`'s option type, the lazy `@dimforge/rapier2d-compat` load, and the adapter
+ * that is the only place in the client where a rapier2d type is touched.
+ *
+ * The loop is `predictor.ts`, shared byte for byte with the other two engines. This file is the
+ * seam list, and it is transcribed from `physics.ts` — the Rapier one — rather than from
+ * `physics2d.ts`, for the same reason `core/rapier2d.ts` is transcribed from `core/physics.ts`:
+ *
+ * - **The world applies gravity**, so there is no `settle` hook here and there must not be one.
+ *   `EngineAdapter.settle` exists for matter2d, whose engine gravity is usually zero and whose
+ *   rooms apply it per body; a rapier2d world that gained one would fall twice as fast on the
+ *   client and be corrected every tick.
+ * - **Velocities are per second**, so `velocityTolerance` is `epsilon / dt`, the 3D answer, not
+ *   matter's per-step one.
+ * - **The step is `world.step()`** against a `world.timestep` fixed once at start.
+ *
+ * What it takes from the 2D side is only the plane: `{ x, y }` gravity, a scalar rotation and a
+ * scalar spin, mapped onto the thirteen 3D pose numbers through `@irtio/schema`'s `channelOf2d` /
+ * `applyChannel2d` / `angleFrom2d`. That mapping is written once, in the schema package, and this
+ * file reads it rather than restating it — a second copy is a way for the two sides to disagree
+ * by a sign.
+ *
+ * There is no planar-lock warning here (bug 6's friction trap needs a third axis to lock, and this
+ * engine has none), and the engine is loaded lazily, so a game predicting with matter2d or rapier3d
+ * never pulls the 2D WASM in.
+ */
+
+type ClientRapier2dModule = typeof RAPIER2D;
+type ClientRapier2dWorld = RAPIER2D.World;
+type ClientRapier2dBody = RAPIER2D.RigidBody;
+interface ClientVector2d {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * What a client-side rapier2d body factory returns — the same shape the room config's factories
+ * use (`Rapier2dBodySpec` in `@irtio/server`). Rapier bodies *have* colliders rather than being
+ * their geometry, which is the one structural difference from the matter2d spec.
+ */
+interface ClientRapier2dBodySpec {
+    readonly body: RAPIER2D.RigidBodyDesc;
+    readonly colliders?: readonly RAPIER2D.ColliderDesc[];
+}
+/**
+ * Method-syntax members check bivariantly, so a builder's factory or intent hook written against
+ * its own instance type (`(body, ball: Ball) => …`) is accepted — the values really passed are
+ * the schema's records for that collection.
+ */
+type ClientRapier2dBodyFactory = {
+    factory(rapier: ClientRapier2dModule, instance: AnyRecord$2, id: string): ClientRapier2dBodySpec;
+}['factory'];
+/**
+ * The client's half of `Rapier2dIntentHook`. Same five parameters in the same order as the server
+ * type, so one hook exported from a shared world module typechecks against both sides without a
+ * cast.
+ */
+type ClientRapier2dIntentHook = {
+    hook(body: ClientRapier2dBody, instance: AnyRecord$2, rapier: ClientRapier2dModule, world: ClientRapier2dWorld, timestep: number): void;
+}['hook'];
+/**
+ * `joinRoom({ physics2d: { engine: 'rapier2d', … } })` — the client half of the shared
+ * world-builder contract for a rapier2d room.
+ *
+ * It rides inside the `physics2d` option rather than beside it because it is the same *option*:
+ * a planar world, a planar gravity, one 2D engine. `engine` is the discriminant, and it is
+ * required here and optional (defaulting to `'matter2d'`) on the matter2d member, so every
+ * matter2d room written before this engine existed still compiles unchanged.
+ *
+ * There is no `settle`. See the module docblock.
+ */
+interface ClientRapier2dOptions {
+    /** The discriminant. Required: `physics2d` without one is a matter2d world. */
+    readonly engine: 'rapier2d';
+    /** Must equal the room config's gravity. Rapier's convention is y-up; nothing flips it. */
+    readonly gravity: ClientVector2d;
+    /** Seconds per step. Defaults to the room's tick interval (from `WELCOME`). */
+    readonly timestep?: number;
+    /** The shared static-geometry builder (the room's `physics.setup`). */
+    readonly setup?: (world: ClientRapier2dWorld, rapier: ClientRapier2dModule) => void;
+    /** Shape factories for the collections this client predicts (the room's `physics.bodies`). */
+    readonly bodies?: Readonly<Record<string, ClientRapier2dBodyFactory>>;
+    /**
+     * Intent → force, applied before every predicted step for bodies this client owns — the same
+     * function the room's `tick()` calls per instance, shared so both simulations agree.
+     */
+    readonly intents?: Readonly<Record<string, ClientRapier2dIntentHook>>;
+    /**
+     * D21 cap: how many **non-owned** predicted bodies this client simulates ahead. Default 64.
+     * Over-cap instances get a kinematic proxy instead (see `maxProxyBodies`), so a predicted body
+     * still stands on them. Counted as `stats.overCap`.
+     */
+    readonly maxPredictedBodies?: number;
+    /**
+     * D71 cap: how many **kinematic proxies** this client keeps. Default `MAX_PROXY_BODIES`. Past
+     * it, instances are absent from the local world and predicted bodies pass through them (warned,
+     * counted as `stats.absent`). See `ClientPhysicsOptions.maxProxyBodies` for why it is its own
+     * number.
+     */
+    readonly maxProxyBodies?: number;
+    /**
+     * A body-field correction whose every value is within this tolerance of the local prediction is
+     * *suppressed*: authority still applies, but it is not a misprediction. Positions compare
+     * against `epsilon` world units; velocity channels against `epsilon / timestep`, because a
+     * rapier2d velocity is per second. Default 0.05, which is sized for a metre-scale world.
+     */
+    readonly epsilon?: number;
+    /**
+     * How fast the drawn position eases back onto the simulation after a re-simulation moved it, as
+     * a half-life in milliseconds. `0` turns the smoothing off. Default 70. See
+     * `ClientPhysicsOptions.smoothingHalfLifeMs` for why this smooths the error and not the motion.
+     */
+    readonly smoothingHalfLifeMs?: number;
+    /**
+     * How far the drawn position may be held from the simulation while an offset eases away, in
+     * world units. Past it the offset is dropped and the body appears where it is. Default 4.
+     */
+    readonly smoothingSnapUnits?: number;
+}
+
 /**
  * The matter2d half of client-side physics prediction (D45, D57): `joinRoom({ physics2d })`'s
  * option type, the lazy `matter-js` load, and the adapter that is the only place in the client
@@ -900,6 +1034,11 @@ type ClientIntent2dHook = {
  * Every function here should be the very export the room config imports.
  */
 interface ClientPhysics2dOptions {
+    /**
+     * The `physics2d` discriminant. Optional and defaulting to `'matter2d'`, so every matter2d
+     * client written before rapier2d existed keeps compiling and keeps predicting with matter.
+     */
+    readonly engine?: 'matter2d';
     /** Must equal the room config's gravity, in matter's own convention (y is down). */
     readonly gravity: ClientVector2;
     /** Seconds per step. Defaults to the room's tick interval (from `WELCOME`). */
@@ -1505,7 +1644,7 @@ interface JoinOptions<S, Role extends string = string> {
      * take different functions; passing both is an error at join. The wire carries no engine
      * name, so passing the one that does not match the room is a game bug the client cannot see.
      */
-    readonly physics2d?: ClientPhysics2dOptions;
+    readonly physics2d?: ClientPhysics2dOptions | ClientRapier2dOptions;
     /** @internal */
     readonly transport?: Transport;
     /** @internal */
@@ -1934,6 +2073,230 @@ declare function matchRoom<S extends AnySchema, Role extends string = RoleOf<S>
 } & {
     readonly identity?: boolean;
 }): Promise<Room<S, Role>>;
+/** What a `mode: "public"` answer carries. */
+interface PublicTicket {
+    readonly room: string;
+    readonly queue: string;
+    /** How many players the queue this lobby belongs to seats. */
+    readonly size: number;
+    /** True when this caller minted the room rather than joining one somebody else was waiting in. */
+    readonly created: boolean;
+}
+/**
+ * Asks the control plane for a public room of `queue`: the oldest open one, or a fresh code.
+ *
+ * The lower half of {@link joinPublic}, exported because the element's chooser is driven by events
+ * rather than by a call, and an app that wires its own **Join a game** button may want the code
+ * without the join.
+ *
+ * `exclude` names a room this caller already failed to join, so the second answer is a different
+ * one. See `joinPublic` for when that happens.
+ */
+declare function findPublic(project: string, options?: Pick<MatchOptions, 'queue' | 'controlUrl' | 'fetch'> & {
+    readonly identity?: string;
+    readonly exclude?: string;
+}): Promise<PublicTicket>;
+/**
+ * Join a game: land in the next open public lobby, or open one and wait in it.
+ *
+ * ```ts
+ * const room = await joinPublic(schema);              // the default queue
+ * const room = await joinPublic(schema, { queue: '4p', identity: true });
+ * ```
+ *
+ * This is the other shape of matchmaking and it is deliberately not `matchRoom`. `matchRoom`
+ * holds a long poll until a whole party is there and answers `E_NO_MATCH` if one never is;
+ * `joinPublic` resolves on the first round trip and puts the player in a room that says "1/4
+ * players". Waiting in a lobby you can see is a different experience from waiting on a spinner,
+ * and it is the one a **Join a game** button should give.
+ *
+ * Nothing about the join differs from a friend sharing a link — the room neither knows nor cares
+ * that the registry sent you — which is the property every part of this feature is built on.
+ *
+ * **The one retry.** The registry answers from an occupancy reading a few seconds old, so the room
+ * may have filled on the way there. That is refused with `E_ROOM_FULL`, and the honest recovery is
+ * to ask once more, naming the room that did not work so the second answer cannot be the same one.
+ * Once, and never a loop: a retry that kept going would turn a busy game into a client that
+ * hammers control, and a second failure means something a third attempt will not fix.
+ */
+declare function joinPublic<S extends AnySchema, Role extends string = RoleOf<S> & string>(schema: S, options?: Pick<MatchOptions, 'queue' | 'controlUrl' | 'fetch'> & JoinOptions<S, Role> & {
+    role?: RoleOf<S> & string;
+} & {
+    readonly identity?: boolean;
+}): Promise<Room<S, Role>>;
+
+/**
+ * D75 (M6 lane H): the client's half of the lobby, and the glue that wires `<irt-lobby>` up.
+ *
+ * Two exports and a clean division between them.
+ *
+ * `lobbyOf(room)` is the **view**: it reads the lobby fragment out of ordinary room state and
+ * answers the structural shape `@irtio/lobby`'s `AttachableRoom.lobby` asks for. It is a reader
+ * plus one owner write (the ready flag), and it holds nothing the room does not already say.
+ *
+ * `attachLobby(element, schema, options)` is the **glue**: it listens for the panel's two chooser
+ * events, makes the calls the panel deliberately cannot make itself, and attaches the room it gets
+ * back. Sugar, not capability — the same rule `matchRoom` is held to. An app that wants to answer
+ * the events itself keeps every part of this and needs none of it.
+ *
+ * ## Why the view polls
+ *
+ * `room.on(...)` has no "state changed" event: the client SDK publishes `status`, `clients`, `rtt`,
+ * `error` and `correct`, and lobby state is ordinary entity state that arrives in a `DELTA` like
+ * everything else. So `on('change')` samples — on every `clients` event, and on a cheap timer in
+ * between — and fires only when a small signature actually differs.
+ *
+ * That is a real cost and it is written here rather than hidden: one shallow string build per
+ * sample, over at most `maxClients` records, for as long as somebody is watching. It is the honest
+ * price of the element importing nothing from this package. A `state` event on `Room` would replace
+ * the timer with a subscription and is recorded as a debt in the lane report rather than smuggled
+ * into this lane's protocol-free budget.
+ */
+
+/**
+ * The two collection names the lobby fragment declares.
+ *
+ * Literals here rather than an import from `@irtio/server`, which is where they are defined. The
+ * client SDK ships to browsers and depends on `@irtio/schema` and `@irtio/protocol` alone; taking
+ * a dependency on the room-file API to read two strings would put the whole of it in every game's
+ * bundle. This is the same fence `@irtio/server`'s own `MAX_AWAKE_MAX` sits behind, and it is
+ * pinned the same way: `test/lobby-view.test.ts` imports both and asserts the pairs equal, from a
+ * package that legitimately depends on both, so a rename is a failing test rather than a lobby
+ * that silently never appears.
+ */
+declare const LOBBY_STATE = "irtLobby";
+declare const LOBBY_MEMBERS = "irtLobbyMembers";
+/** How often the view samples for a change between `clients` events. */
+declare const LOBBY_POLL_MS = 120;
+/** One row of the lobby roster, in join order. */
+interface LobbyPlayer {
+    readonly clientId: string;
+    readonly ready: boolean;
+    readonly connected: boolean;
+    /** True for the row belonging to the client holding this view. */
+    readonly me: boolean;
+}
+/** What `lobbyOf` answers: `@irtio/lobby`'s structural `lobby` member, with names. */
+interface LobbyView {
+    readonly phase: 'lobby' | 'started';
+    readonly players: readonly LobbyPlayer[];
+    readonly public: boolean;
+    readonly readyUi: boolean;
+    /** How many the room starts at under `'when-full'`, or 0 when the room has not said. */
+    readonly capacity: number;
+    ready(value: boolean): void;
+    setPublic?(value: boolean): void;
+    on(event: 'change', cb: () => void): () => void;
+}
+interface StateLike {
+    [collection: string]: unknown;
+}
+interface RoomLike {
+    readonly me: string;
+    readonly state: StateLike;
+    readonly clients: readonly {
+        clientId: string;
+        connected: boolean;
+    }[];
+    on(event: 'clients', cb: (clients: readonly {
+        clientId: string;
+        connected: boolean;
+    }[]) => void): () => void;
+    flush(): void;
+}
+/**
+ * Does this room carry a lobby?
+ *
+ * A schema that did not spread `lobbyCollections` has neither collection, and the honest answer for
+ * such a room is that it has no lobby rather than an empty one — `<irt-lobby>` renders no lobby UI
+ * at all in that case, which is what keeps every existing consumer unchanged.
+ */
+declare function hasLobby(room: unknown): boolean;
+/**
+ * Reads a joined room's lobby.
+ *
+ * ```ts
+ * const room = await joinPublic(schema);
+ * lobby.attach(room, { lobby: lobbyOf(room) });
+ * ```
+ *
+ * `setPublic` is present only when the caller supplies one, and that is a consequence of there
+ * being no built-in RPC for it. The platform never takes a public toggle from a client — that
+ * would be a protocol change — so the room's own game code owns the door. A game that wants the
+ * panel's toggle to work declares its own RPC and passes it here:
+ *
+ * ```ts
+ * lobbyOf(room, { setPublic: (value) => void room.call.setPublic({ value }) })
+ * ```
+ *
+ * Without one, the panel renders the room's public state and no toggle, which is the truthful
+ * rendering of a room whose code has not offered the control.
+ */
+declare function lobbyOf(room: unknown, options?: {
+    readonly setPublic?: (value: boolean) => void;
+}): LobbyView | undefined;
+/** What the panel's `quickmatch` event carries. */
+interface QuickMatchDetail {
+    readonly queue?: string;
+}
+/** The element surface `attachLobby` needs. Structural, so a test can pass a stand-in. */
+interface LobbyElementLike {
+    addEventListener(type: string, cb: (event: Event) => void): void;
+    removeEventListener(type: string, cb: (event: Event) => void): void;
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+    attach(room: unknown): () => void;
+}
+/**
+ * The room, as `<irt-lobby>`'s structural `AttachableRoom` wants it: everything the panel already
+ * read, plus the optional `lobby` member the design's §6 adds.
+ *
+ * A wrapper of getters rather than a spread, because a `Room`'s fields are accessors on a class:
+ * `{ ...room }` would freeze `status`, `id` and `clients` at the moment of the copy, and the panel
+ * re-reads all three on every render precisely so a reconnect that changes the code is picked up.
+ * Mutating the room to hang a `lobby` on it was the other option and is worse — the SDK's own
+ * object would then carry a field its type does not declare.
+ */
+declare function attachable(room: RoomLike & {
+    id: string;
+    link: string;
+    status: string;
+    maxClients?: number;
+    rtt?: number;
+}, view: LobbyView | undefined): unknown;
+interface AttachLobbyOptions<S extends AnySchema, Role extends string> {
+    /** Passed through to `joinRoom` / `joinPublic`. */
+    readonly join?: JoinOptions<S, Role> & {
+        role?: RoleOf<S> & string;
+    };
+    /** Passed through to the control-plane call. */
+    readonly match?: Pick<MatchOptions, 'controlUrl' | 'fetch'> & {
+        readonly identity?: boolean;
+    };
+    /** The room's own public-toggle RPC, if it has one. See `lobbyOf`. */
+    readonly setPublic?: (room: Room<S, Role>, value: boolean) => void;
+    /** Called with the room once it is joined, so game code can start drawing. */
+    readonly onRoom?: (room: Room<S, Role>) => void;
+    /** Called when a join fails. Default: the panel's status goes back to idle and the error is
+     *  rethrown on the microtask queue so it reaches `window.onerror` rather than vanishing. */
+    readonly onError?: (err: unknown) => void;
+}
+/**
+ * Wires `<irt-lobby>`'s chooser to the two calls it deliberately cannot make itself.
+ *
+ * ```ts
+ * attachLobby(document.querySelector('irt-lobby')!, schema, { onRoom: (room) => start(room) });
+ * ```
+ *
+ * The panel emits and this answers: `private` becomes an ordinary `joinRoom` with no code (which
+ * creates one), `quickmatch` becomes `joinPublic`. Both then `attach` the room, exactly as an app
+ * doing it by hand would. Returns an unsubscribe.
+ *
+ * `@irtio/lobby` imports nothing from this package and never will — that is what lets a React or
+ * Svelte app drive the panel with attributes and no SDK. This function is the other side of that
+ * rule rather than an exception to it: the dependency points this way.
+ */
+declare function attachLobby<S extends AnySchema, Role extends string = RoleOf<S> & string>(element: LobbyElementLike, schema: S, options?: AttachLobbyOptions<S, Role>): () => void;
 
 /**
  * The default `Scheduler`. In a browser the write batcher aligns to `requestAnimationFrame` (one
@@ -2135,7 +2498,7 @@ interface SessionOptions {
     /** The shared world-builder half the client predicts with (D22 part 2). */
     readonly physics?: ClientPhysicsOptions | undefined;
     /** The same, for a matter2d room (D57). Never both; `joinRoom` refuses that. */
-    readonly physics2d?: ClientPhysics2dOptions | undefined;
+    readonly physics2d?: ClientPhysics2dOptions | ClientRapier2dOptions | undefined;
     readonly transport?: Transport | undefined;
     readonly scheduler?: Scheduler | undefined;
     readonly onFrame?: FrameHook | undefined;
@@ -2586,4 +2949,4 @@ declare function joinRoom<S extends AnySchema, Role extends string = RoleOf<S> &
  */
 declare function joinRelay<S extends AnySchema = never>(options?: JoinRelayOptions<S extends AnySchema ? S : AnySchema>): Promise<RelayRoom<S>>;
 
-export { ACCOUNT_STORAGE_KEY, CALL_TIMEOUT_MS, type ClientBody2dFactory, type ClientBody2dSpec, type ClientBodySpec, type ClientCollection, type ClientIntent2dHook, type ClientMatterBody, type ClientMatterConstraint, type ClientMatterEngine, type ClientMatterModule, type ClientPhysics2dOptions, type ClientPhysicsOptions, type ClientRapierBody, type ClientRapierModule, type ClientRapierWorld, type ClientState, ClientStore, type ClientVector2, type ClientVector3, type Correction, DEFAULT_CONTROL_URL, DEFAULT_REGION, DEFAULT_WRITE_INTERVAL_MS, DEV_PORT, E_CONNECT_FAILED, E_IDENTITY_RATE_LIMITED, type FrameHook, INTERNAL_VOICE_TRACKS, Identity, IdentityError, type IdentityOptions, type IdentityStorage, type JoinOptions, type JoinRelayOptions, MAX_IDENTITY_RETRY_WAIT_MS, MAX_PREDICTED_BODIES, MAX_PROXY_BODIES, MatchError, type MatchOptions, type MatchTicket, type MessageTarget, PING_INTERVAL_MS, PREDICTION_EPSILON, type PartyTicket, type PredictionStats, type PredictionStatus, REGION_RE, RESIM_DEPTH, type RelayRoom, type Room, type RoomCallProxy, type RoomError, type RoomEvents, type RoomMessageStats, type RoomMessages, type RoomProfile, type RoomStats, SMOOTHING_HALF_LIFE_MS, SMOOTHING_SNAP_UNITS, type Scheduler, Session, type Status, type Transport, type TransportSocket, type Unsubscribe, type VoiceHandle, type VoiceOptions, type VoicePeerState, type VoiceTrackAccess, createParty, defaultScheduler, findMatch, identityStorageKey, joinRelay, joinRoom, joinVoice, linkForUrl, matchRoom, resolveUrl, roomIdFrom, webSocketTransport };
+export { ACCOUNT_STORAGE_KEY, type AttachLobbyOptions, CALL_TIMEOUT_MS, type ClientBody2dFactory, type ClientBody2dSpec, type ClientBodySpec, type ClientCollection, type ClientIntent2dHook, type ClientMatterBody, type ClientMatterConstraint, type ClientMatterEngine, type ClientMatterModule, type ClientPhysics2dOptions, type ClientPhysicsOptions, type ClientRapier2dBody, type ClientRapier2dBodyFactory, type ClientRapier2dBodySpec, type ClientRapier2dIntentHook, type ClientRapier2dModule, type ClientRapier2dOptions, type ClientRapier2dWorld, type ClientRapierBody, type ClientRapierModule, type ClientRapierWorld, type ClientState, ClientStore, type ClientVector2, type ClientVector2d, type ClientVector3, type Correction, DEFAULT_CONTROL_URL, DEFAULT_REGION, DEFAULT_WRITE_INTERVAL_MS, DEV_PORT, E_CONNECT_FAILED, E_IDENTITY_RATE_LIMITED, type FrameHook, INTERNAL_VOICE_TRACKS, Identity, IdentityError, type IdentityOptions, type IdentityStorage, type JoinOptions, type JoinRelayOptions, LOBBY_MEMBERS, LOBBY_POLL_MS, LOBBY_STATE, type LobbyPlayer, type LobbyView, MAX_IDENTITY_RETRY_WAIT_MS, MAX_PREDICTED_BODIES, MAX_PROXY_BODIES, MatchError, type MatchOptions, type MatchTicket, type MessageTarget, PING_INTERVAL_MS, PREDICTION_EPSILON, type PartyTicket, type PredictionStats, type PredictionStatus, type PublicTicket, type QuickMatchDetail, REGION_RE, RESIM_DEPTH, type RelayRoom, type Room, type RoomCallProxy, type RoomError, type RoomEvents, type RoomMessageStats, type RoomMessages, type RoomProfile, type RoomStats, SMOOTHING_HALF_LIFE_MS, SMOOTHING_SNAP_UNITS, type Scheduler, Session, type Status, type Transport, type TransportSocket, type Unsubscribe, type VoiceHandle, type VoiceOptions, type VoicePeerState, type VoiceTrackAccess, attachLobby, attachable, createParty, defaultScheduler, findMatch, findPublic, hasLobby, identityStorageKey, joinPublic, joinRelay, joinRoom, joinVoice, linkForUrl, lobbyOf, matchRoom, resolveUrl, roomIdFrom, webSocketTransport };

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS,
   emptyPredictionStats
-} from "./chunk-XWVXZRBS.js";
+} from "./chunk-5Z4DHUA3.js";
 
 // src/index.ts
 import { EMPTY_PROFILE as EMPTY_PROFILE2 } from "@irtio/protocol";
@@ -1117,7 +1117,7 @@ var Session = class {
     const physics2d = options.physics2d;
     if (physics && hasPhysics) {
       this.predictionRequested = true;
-      void import("./physics-RT5T36P5.js").then(({ PhysicsPredictor }) => {
+      void import("./physics-4SGKNBAC.js").then(({ PhysicsPredictor }) => {
         if (this.left) return;
         attach(
           new PhysicsPredictor(
@@ -1130,15 +1130,32 @@ var Session = class {
           )
         );
       });
-    } else if (physics2d && hasPhysics) {
+    } else if (physics2d !== void 0 && physics2d.engine === "rapier2d" && hasPhysics) {
+      const rapier2d = physics2d;
       this.predictionRequested = true;
-      void import("./physics2d-HOFMWPZV.js").then(({ Physics2dPredictor }) => {
+      void import("./physics-rapier2d-TBOAJMVM.js").then(({ Rapier2dPredictor }) => {
+        if (this.left) return;
+        attach(
+          new Rapier2dPredictor(
+            this.ext,
+            this.store,
+            rapier2d,
+            () => this.me,
+            () => this.rtt,
+            () => this.tickIntervalMs
+          )
+        );
+      });
+    } else if (physics2d !== void 0 && physics2d.engine !== "rapier2d" && hasPhysics) {
+      const matter2d = physics2d;
+      this.predictionRequested = true;
+      void import("./physics2d-CNSEWKP4.js").then(({ Physics2dPredictor }) => {
         if (this.left) return;
         attach(
           new Physics2dPredictor(
             this.ext,
             this.store,
-            physics2d,
+            matter2d,
             () => this.me,
             () => this.rtt,
             () => this.tickIntervalMs
@@ -2191,6 +2208,233 @@ function isRoomFull(err) {
   const message = err instanceof Error ? err.message : String(err);
   return message.startsWith("E_ROOM_FULL");
 }
+async function findPublic(project, options = {}) {
+  const controlUrl = (options.controlUrl ?? DEFAULT_CONTROL_URL).replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? fetch;
+  let res;
+  try {
+    res = await fetchImpl(`${controlUrl}/match`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        project,
+        mode: "public",
+        ...options.queue !== void 0 ? { queue: options.queue } : {},
+        ...options.identity !== void 0 ? { identity: options.identity } : {},
+        ...options.exclude !== void 0 ? { exclude: options.exclude } : {}
+      })
+    });
+  } catch (err) {
+    throw new MatchError(
+      "E_MATCH_UNREACHABLE",
+      `cannot reach the matchmaker at ${controlUrl}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const text = await res.text().catch(() => "");
+  let body = {};
+  try {
+    body = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok) {
+    throw new MatchError(
+      typeof body.code === "string" ? body.code : `E_HTTP_${res.status}`,
+      typeof body.message === "string" ? body.message : `match failed with status ${res.status}`
+    );
+  }
+  if (body.status !== "matched" || typeof body.room !== "string") {
+    throw new MatchError("E_MATCH_MALFORMED", "the matchmaker answered something unexpected");
+  }
+  return {
+    room: body.room,
+    queue: typeof body.queue === "string" ? body.queue : "default",
+    size: typeof body.size === "number" ? body.size : 0,
+    created: body.created === true
+  };
+}
+async function joinPublic(schema, options = {}) {
+  const project = schema.project;
+  const key = options.key ?? (typeof project === "string" ? project : void 0);
+  if (key === void 0 || key === "") {
+    throw new MatchError(
+      "E_MATCH_NO_PROJECT",
+      "joinPublic needs a project key: build your schema with `irtio` so it carries one, or pass { key }"
+    );
+  }
+  const identity = options.identity === true ? new Identity({
+    project: key,
+    controlUrl: options.controlUrl,
+    fetch: options.fetch
+  }) : void 0;
+  const ask = async (exclude) => findPublic(key, {
+    ...options.queue !== void 0 ? { queue: options.queue } : {},
+    ...options.controlUrl !== void 0 ? { controlUrl: options.controlUrl } : {},
+    ...options.fetch !== void 0 ? { fetch: options.fetch } : {},
+    ...identity !== void 0 ? { identity: await identity.ensure() } : {},
+    ...exclude !== void 0 ? { exclude } : {}
+  });
+  const ticket = await ask();
+  try {
+    return await joinRoom(schema, { ...options, room: ticket.room });
+  } catch (err) {
+    if (!isRetryablePublicJoin(err)) throw err;
+    const second = await ask(ticket.room);
+    return joinRoom(schema, { ...options, room: second.room });
+  }
+}
+function isRetryablePublicJoin(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.startsWith("E_ROOM_FULL") || message.startsWith("E_ROOM_NOT_FOUND");
+}
+
+// src/lobby.ts
+var LOBBY_STATE = "irtLobby";
+var LOBBY_MEMBERS = "irtLobbyMembers";
+var LOBBY_POLL_MS = 120;
+function hasLobby(room) {
+  const state = room?.state;
+  return typeof state === "object" && state !== null && state[LOBBY_STATE] !== void 0 && state[LOBBY_MEMBERS] !== void 0;
+}
+function lobbyOf(room, options = {}) {
+  if (!hasLobby(room)) return void 0;
+  const r = room;
+  const singleton = () => r.state[LOBBY_STATE] ?? {};
+  const members = () => r.state[LOBBY_MEMBERS];
+  const players = () => r.clients.map((c) => ({
+    clientId: c.clientId,
+    ready: members().get(c.clientId)?.ready === true,
+    connected: c.connected !== false,
+    me: c.clientId === r.me
+  }));
+  const signature = () => {
+    const s = singleton();
+    let out = `${s.phase ?? ""}|${s.public === true ? 1 : 0}|${s.readyUi === true ? 1 : 0}|${s.capacity ?? 0}`;
+    for (const p of players()) out += `|${p.clientId}${p.ready ? 1 : 0}${p.connected ? 1 : 0}`;
+    return out;
+  };
+  return {
+    get phase() {
+      return singleton().phase === "started" ? "started" : "lobby";
+    },
+    get players() {
+      return players();
+    },
+    get public() {
+      return singleton().public === true;
+    },
+    get readyUi() {
+      return singleton().readyUi === true;
+    },
+    get capacity() {
+      return singleton().capacity ?? 0;
+    },
+    ready(value) {
+      const mine = members().get(r.me);
+      if (!mine) return;
+      mine.ready = value === true;
+      r.flush();
+    },
+    ...options.setPublic !== void 0 ? { setPublic: options.setPublic } : {},
+    on(event, cb) {
+      if (event !== "change") return () => {
+      };
+      let last = signature();
+      const sample = () => {
+        const next = signature();
+        if (next === last) return;
+        last = next;
+        cb();
+      };
+      const offClients = r.on("clients", sample);
+      const timer = setInterval(sample, LOBBY_POLL_MS);
+      timer.unref?.();
+      return () => {
+        offClients();
+        clearInterval(timer);
+      };
+    }
+  };
+}
+function attachable(room, view) {
+  return {
+    get id() {
+      return room.id;
+    },
+    get link() {
+      return room.link;
+    },
+    get status() {
+      return room.status;
+    },
+    get clients() {
+      return room.clients;
+    },
+    get maxClients() {
+      return room.maxClients;
+    },
+    get rtt() {
+      return room.rtt;
+    },
+    on: (event, cb) => room.on(event, cb),
+    ...view !== void 0 ? { lobby: view } : {}
+  };
+}
+function attachLobby(element, schema, options = {}) {
+  let detachRoom;
+  let busy = false;
+  const fail = (err) => {
+    element.removeAttribute("searching");
+    if (options.onError) {
+      options.onError(err);
+      return;
+    }
+    queueMicrotask(() => {
+      throw err;
+    });
+  };
+  const landed = (room) => {
+    element.removeAttribute("searching");
+    const view = lobbyOf(room, {
+      ...options.setPublic !== void 0 ? { setPublic: (value) => options.setPublic?.(room, value) } : {}
+    });
+    detachRoom = element.attach(
+      attachable(room, view)
+    );
+    options.onRoom?.(room);
+  };
+  const run = async (make) => {
+    if (busy) return;
+    busy = true;
+    try {
+      landed(await make());
+    } catch (err) {
+      fail(err);
+    } finally {
+      busy = false;
+    }
+  };
+  const onPrivate = () => {
+    void run(() => joinRoom(schema, { ...options.join ?? {} }));
+  };
+  const onQuickMatch = (event) => {
+    const detail = event.detail;
+    element.setAttribute("searching", "");
+    void run(
+      () => joinPublic(schema, {
+        ...options.join ?? {},
+        ...options.match ?? {},
+        ...detail?.queue !== void 0 ? { queue: detail.queue } : {}
+      })
+    );
+  };
+  element.addEventListener("private", onPrivate);
+  element.addEventListener("quickmatch", onQuickMatch);
+  return () => {
+    element.removeEventListener("private", onPrivate);
+    element.removeEventListener("quickmatch", onQuickMatch);
+    detachRoom?.();
+  };
+}
 
 // src/voice.ts
 import {
@@ -2693,6 +2937,9 @@ export {
   INTERNAL_VOICE_TRACKS,
   Identity,
   IdentityError,
+  LOBBY_MEMBERS,
+  LOBBY_POLL_MS,
+  LOBBY_STATE,
   MAX_IDENTITY_RETRY_WAIT_MS,
   MAX_PREDICTED_BODIES,
   MAX_PROXY_BODIES,
@@ -2704,14 +2951,20 @@ export {
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS,
   Session,
+  attachLobby,
+  attachable,
   createParty,
   defaultScheduler,
   findMatch,
+  findPublic,
+  hasLobby,
   identityStorageKey,
+  joinPublic,
   joinRelay,
   joinRoom,
   joinVoice,
   linkForUrl,
+  lobbyOf,
   matchRoom,
   resolveUrl,
   roomIdFrom,

package/dist/{physics-RT5T36P5.js → physics-4SGKNBAC.js}

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-DABQDR3S.js";
-import "./chunk-XWVXZRBS.js";
+} from "./chunk-XFD6WYQW.js";
+import "./chunk-5Z4DHUA3.js";
 
 // src/physics.ts
 function readPose(body, into) {

package/dist/physics-rapier2d-TBOAJMVM.js

@@ -0,0 +1,186 @@
+import {
+  Predictor
+} from "./chunk-XFD6WYQW.js";
+import "./chunk-5Z4DHUA3.js";
+
+// src/physics-rapier2d.ts
+import {
+  angleFrom2d,
+  applyChannel2d,
+  channelOf2d
+} from "@irtio/schema";
+var engine;
+var loading;
+async function loadEngine() {
+  if (engine) return engine;
+  loading ??= (async () => {
+    const mod = await import("@dimforge/rapier2d-compat");
+    const ns = mod.default ?? mod;
+    await ns.init();
+    engine = ns;
+    return ns;
+  })();
+  return loading;
+}
+var Rapier2dAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engineName = "@dimforge/rapier2d-compat";
+  optionName = "physics2d";
+  rapier;
+  world;
+  timestepSeconds = 1 / 30;
+  /** Reused by `readPose`, which runs per body per step and must not allocate. */
+  state = {
+    x: 0,
+    y: 0,
+    angle: 0,
+    vx: 0,
+    vy: 0,
+    angularVelocity: 0
+  };
+  /** `applyChannel2d`'s target shape, likewise reused. */
+  channels = { x: 0, y: 0, qz: 0, qw: 1, vx: 0, vy: 0, wz: 0 };
+  /** `moveKinematic`'s translation argument, reused: it runs per proxy per step (D71). */
+  moveTarget = { x: 0, y: 0 };
+  get timestep() {
+    return this.options.timestep;
+  }
+  async start(timestepSeconds) {
+    const rapier = await loadEngine();
+    this.rapier = rapier;
+    this.timestepSeconds = timestepSeconds;
+    const world = new rapier.World({ x: this.options.gravity.x, y: this.options.gravity.y });
+    world.timestep = timestepSeconds;
+    if (this.options.setup) this.options.setup(world, rapier);
+    this.world = world;
+  }
+  free() {
+    this.world?.free();
+    this.world = void 0;
+  }
+  hasFactory(collection) {
+    return this.options.bodies?.[collection] !== void 0;
+  }
+  createBody(desc, id, record, _warn) {
+    const world = this.world;
+    const rapier = this.rapier;
+    const factory = this.options.bodies?.[desc.name];
+    if (!world || !rapier || !factory) return void 0;
+    const spec = factory(rapier, record, id);
+    if (!spec || !spec.body) return void 0;
+    const body = world.createRigidBody(spec.body);
+    for (const collider of spec.colliders ?? []) world.createCollider(collider, body);
+    return body;
+  }
+  removeBody(body) {
+    this.world?.removeRigidBody(body);
+  }
+  /**
+   * D71: a proxy is a `KinematicPositionBased` body, exactly as in 3D — driven by the position it
+   * is told to be at next, never by a force, an impulse or a contact, with Rapier deriving the
+   * velocity its contacts see from the move itself. The body is *switched* rather than built
+   * kinematic, so its collider and mass properties are the ones the shared factory produced.
+   */
+  makeKinematic(handle) {
+    const rapier = this.rapier;
+    if (!rapier) return;
+    handle.setBodyType(rapier.RigidBodyType.KinematicPositionBased, true);
+  }
+  moveKinematic(handle, pose) {
+    const body = handle;
+    const to = this.moveTarget;
+    to.x = pose.t.x;
+    to.y = pose.t.y;
+    body.setNextKinematicTranslation(to);
+    body.setNextKinematicRotation(angleFrom2d(pose.r.z, pose.r.w));
+  }
+  step() {
+    this.world?.step();
+  }
+  /**
+   * Server record → body state, through `applyChannel2d` so the plane-to-channel mapping stays
+   * written once, and in `Rapier2dRuntime.applyRecordToBody`'s order — translation, rotation,
+   * linear velocity, spin — so the two sides write the same body the same way. Every setter takes
+   * `wakeUp = true`: a rebase writes state a sleeping body would otherwise ignore.
+   */
+  applyRecord(handle, channels, record) {
+    const body = handle;
+    const t = this.channels;
+    const pos = body.translation();
+    const vel = body.linvel();
+    const angle = body.rotation();
+    t.x = pos.x;
+    t.y = pos.y;
+    t.qz = Math.sin(angle / 2);
+    t.qw = Math.cos(angle / 2);
+    t.vx = vel.x;
+    t.vy = vel.y;
+    t.wz = body.angvel();
+    for (const [channel, field] of channels) {
+      const raw = record[field];
+      if (typeof raw !== "number") continue;
+      applyChannel2d(channel, raw, t);
+    }
+    body.setTranslation({ x: t.x, y: t.y }, true);
+    body.setRotation(angleFrom2d(t.qz, t.qw), true);
+    body.setLinvel({ x: t.vx, y: t.vy }, true);
+    body.setAngvel(t.wz, true);
+  }
+  /**
+   * Body state → a 3D pose, through `channelOf2d`: `t = (x, y, 0)`, `r` a quaternion about Z,
+   * `v = (vx, vy, 0)`, `w = (0, 0, spin)`.
+   */
+  readPose(handle, into) {
+    const body = handle;
+    const s = this.state;
+    const pos = body.translation();
+    const vel = body.linvel();
+    s.x = pos.x;
+    s.y = pos.y;
+    s.angle = body.rotation();
+    s.vx = vel.x;
+    s.vy = vel.y;
+    s.angularVelocity = body.angvel();
+    const b = s;
+    into.t.x = channelOf2d("x", b);
+    into.t.y = channelOf2d("y", b);
+    into.t.z = channelOf2d("z", b);
+    into.r.x = channelOf2d("qx", b);
+    into.r.y = channelOf2d("qy", b);
+    into.r.z = channelOf2d("qz", b);
+    into.r.w = channelOf2d("qw", b);
+    into.v.x = channelOf2d("vx", b);
+    into.v.y = channelOf2d("vy", b);
+    into.v.z = channelOf2d("vz", b);
+    into.w.x = channelOf2d("wx", b);
+    into.w.y = channelOf2d("wy", b);
+    into.w.z = channelOf2d("wz", b);
+  }
+  applyIntent(collection, body, instance) {
+    const hook = this.options.intents?.[collection];
+    const world = this.world;
+    const rapier = this.rapier;
+    if (!hook || !world || !rapier) return;
+    hook(body, instance, rapier, world, this.timestepSeconds);
+  }
+  // No `settle`. The world applies gravity; see the module docblock.
+  /** Rapier velocities are per second, so one tick of error is `epsilon` when `dv = eps / dt`. */
+  velocityTolerance(epsilon, timestepSeconds) {
+    return epsilon / timestepSeconds;
+  }
+};
+var Rapier2dPredictor = class extends Predictor {
+  constructor(ext, store, options, meOf, rttOf, tickIntervalOf, log = (m) => console.warn(m)) {
+    super(ext, store, new Rapier2dAdapter(options), options, meOf, rttOf, tickIntervalOf, log);
+  }
+};
+function createRapier2dAdapter(options) {
+  return new Rapier2dAdapter(options);
+}
+export {
+  Rapier2dPredictor,
+  createRapier2dAdapter
+};

package/dist/{physics2d-HOFMWPZV.js → physics2d-CNSEWKP4.js}

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-DABQDR3S.js";
-import "./chunk-XWVXZRBS.js";
+} from "./chunk-XFD6WYQW.js";
+import "./chunk-5Z4DHUA3.js";
 
 // src/physics2d.ts
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/client",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "irtio client SDK: joinRoom, owned-write batching, corrections, typed RPCs, presence, reconnection",
   "license": "MIT",
   "publishConfig": {
@@ -20,14 +20,18 @@
   ],
   "dependencies": {
     "mediasoup-client": "^3.23.1",
-    "@irtio/protocol": "0.7.0",
-    "@irtio/schema": "0.7.0"
+    "@irtio/protocol": "0.8.0",
+    "@irtio/schema": "0.8.0"
   },
   "peerDependencies": {
+    "@dimforge/rapier2d-compat": ">=0.20.0",
     "@dimforge/rapier3d-compat": ">=0.20.0",
     "matter-js": ">=0.20.0"
   },
   "peerDependenciesMeta": {
+    "@dimforge/rapier2d-compat": {
+      "optional": true
+    },
     "@dimforge/rapier3d-compat": {
       "optional": true
     },
@@ -39,6 +43,7 @@
     "@dimforge/rapier3d-compat": "0.20.0",
     "@types/matter-js": "0.20.2",
     "matter-js": "0.20.0",
+    "@dimforge/rapier2d-compat": "0.20.0",
     "@irtio/sfu": "0.0.0"
   },
   "scripts": {