@irtio/client 0.7.0 → 0.9.0

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS,
   emptyPredictionStats
-} from "./chunk-XWVXZRBS.js";
+} from "./chunk-5OHONPVG.js";
 
 // src/index.ts
 import { EMPTY_PROFILE as EMPTY_PROFILE2 } from "@irtio/protocol";
@@ -1065,6 +1065,7 @@ var DEFAULT_WRITE_INTERVAL_MS = 50;
 var PING_INTERVAL_MS = 2e3;
 var RTT_ALPHA = 0.3;
 var CALL_TIMEOUT_MS = 1e4;
+var LEAVE_CLOSE_TIMEOUT_MS = 1e3;
 var BACKOFF_START_MS = 250;
 var BACKOFF_MAX_MS = 5e3;
 function isThenable(v) {
@@ -1117,7 +1118,7 @@ var Session = class {
     const physics2d = options.physics2d;
     if (physics && hasPhysics) {
       this.predictionRequested = true;
-      void import("./physics-RT5T36P5.js").then(({ PhysicsPredictor }) => {
+      void import("./physics-D65WIHPR.js").then(({ PhysicsPredictor }) => {
         if (this.left) return;
         attach(
           new PhysicsPredictor(
@@ -1130,15 +1131,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-O53E6BHO.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-GIL6YYAY.js").then(({ Physics2dPredictor }) => {
         if (this.left) return;
         attach(
           new Physics2dPredictor(
             this.ext,
             this.store,
-            physics2d,
+            matter2d,
             () => this.me,
             () => this.rtt,
             () => this.tickIntervalMs
@@ -1362,18 +1380,45 @@ var Session = class {
     });
     this.send(FrameType.HELLO, hello);
   }
-  /** Leaves for good: no reconnect, pending calls reject, the socket closes. */
+  /**
+   * Leaves for good: no reconnect, pending calls reject, the socket closes.
+   *
+   * The promise resolves when the socket reports its close (or immediately when there was
+   * nothing open), so `await room.leave()` is a real wait rather than a guessed timeout. A
+   * transport that never reports one is bounded by `LEAVE_CLOSE_TIMEOUT_MS` so the caller cannot
+   * hang on it.
+   */
   leave() {
-    if (this.left) return;
+    if (this.left) return Promise.resolve();
     this.left = true;
     this.stopTimers();
     this.predictor?.free();
     this.rejectPending(new Error("irtio: left the room"));
     this.setStatus("closed");
     if (this.socket && this.joined) this.send(FrameType.LEAVE, new Uint8Array(0));
-    this.socket?.close();
+    const socket = this.socket;
     this.socket = void 0;
     this.socketOpen = false;
+    if (!socket) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      let cancelTimeout;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        cancelTimeout?.();
+        resolve();
+      };
+      const previous = socket.onclose;
+      socket.onclose = (info) => {
+        previous?.(info);
+        finish();
+      };
+      socket.close();
+      if (!settled) cancelTimeout = this.scheduler.setTimeout(finish, LEAVE_CLOSE_TIMEOUT_MS);
+    });
   }
   fatal(error) {
     this.left = true;
@@ -2191,6 +2236,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 {
@@ -2621,6 +2893,8 @@ function makeRoom(session) {
     messages,
     stats,
     on: (event, cb) => session.on(event, cb),
+    onAdd: ((collection, cb) => session.store.onEntityAdd(collection, cb)),
+    onRemove: ((collection, cb) => session.store.onEntityRemove(collection, cb)),
     flush: () => session.flush(),
     leave: () => session.leave()
   };
@@ -2693,6 +2967,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 +2981,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-D65WIHPR.js}

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

package/dist/physics-rapier2d-O53E6BHO.js

@@ -0,0 +1,186 @@
+import {
+  Predictor
+} from "./chunk-VZFJXPVF.js";
+import "./chunk-5OHONPVG.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-GIL6YYAY.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/client",
-  "version": "0.7.0",
+  "version": "0.9.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.9.0",
+    "@irtio/schema": "0.9.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": {