@irtio/client 0.8.0 → 0.9.0

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

@@ -121,6 +121,13 @@ var ClientStore = class {
   tracked;
   descs = /* @__PURE__ */ new Map();
   frozen = /* @__PURE__ */ new WeakMap();
+  /**
+   * Per-collection add/remove subscribers (`room.onAdd` / `room.onRemove`). Kept here rather than
+   * in the session because this is the only place that sees a frame's ops against the state the
+   * frame is about to change: a removed row's last values exist for exactly as long as it takes
+   * `applyDelta` to run.
+   */
+  entityListeners = /* @__PURE__ */ new Map();
   /** Live collection facades by name, so a D50 swap can retarget rather than replace them. */
   facades = /* @__PURE__ */ new Map();
   /** The object handed out as `room.state`; identity survives a resync. */
@@ -161,11 +168,13 @@ var ClientStore = class {
   }
   // -- snapshot / resync -----------------------------------------------------
   loadSnapshot(bytes) {
+    const before = this.captureRows();
     this.plain = decodeSnapshot(this.ext, bytes).state;
     this.tracked = track(this.ext, this.plain);
     this.pendingWrites.length = 0;
     this.evictedThroughTick = 0;
     this.baselineIntents.clear();
+    this.emitSnapshotDiff(before);
   }
   /**
    * Captures the field values of every pending owned write, keyed by collection then id then
@@ -294,14 +303,144 @@ var ClientStore = class {
   singletonHint(desc) {
     return `${desc.name} is a singleton and never client-owned; change it with an RPC (room.call.\u2026)`;
   }
+  // -- entity add/remove events ---------------------------------------------
+  listenersFor(name) {
+    let set = this.entityListeners.get(name);
+    if (!set) {
+      set = { add: /* @__PURE__ */ new Set(), remove: /* @__PURE__ */ new Set() };
+      this.entityListeners.set(name, set);
+    }
+    return set;
+  }
+  /**
+   * Subscribes to rows appearing in one entity collection. Rows that are **already present** are
+   * announced synchronously as the subscription is made — the join snapshot has usually landed
+   * before user code runs, and a listener that had to reconcile the initial set by hand would
+   * make the event useless for exactly the case (a spawn effect) it exists for.
+   */
+  onEntityAdd(name, cb) {
+    const desc = this.desc(name);
+    if (desc?.kind === "entity") {
+      const coll = entityOf(this.plain, name);
+      for (const id of [...coll.ids()]) cb(id, this.instance(desc, id));
+    }
+    const set = this.listenersFor(name);
+    set.add.add(cb);
+    return () => {
+      set.add.delete(cb);
+    };
+  }
+  /** Subscribes to rows disappearing from one entity collection (never fires for past removals). */
+  onEntityRemove(name, cb) {
+    const set = this.listenersFor(name);
+    set.remove.add(cb);
+    return () => {
+      set.remove.delete(cb);
+    };
+  }
+  emitAdd(name, id) {
+    const set = this.entityListeners.get(name);
+    if (!set || set.add.size === 0) return;
+    const desc = this.desc(name);
+    if (!desc) return;
+    const row = this.instance(desc, id);
+    for (const cb of [...set.add]) cb(id, row);
+  }
+  emitRemove(name, id, value, hint) {
+    const set = this.entityListeners.get(name);
+    if (!set || set.remove.size === 0) return;
+    const row = this.freeze(value, hint);
+    for (const cb of [...set.remove]) cb(id, row);
+  }
+  /**
+   * The adds and removes a delta is about to make, captured against the state as it stands now:
+   * a remove's last values are only readable before `applyDelta` drops the row.
+   */
+  captureOps(delta) {
+    if (this.entityListeners.size === 0) return void 0;
+    const adds = [];
+    const removes = [];
+    for (const dc of delta.collections) {
+      const set = this.entityListeners.get(dc.name);
+      if (!set || set.add.size === 0 && set.remove.size === 0) continue;
+      const desc = this.desc(dc.name);
+      if (!desc || desc.kind !== "entity") continue;
+      const coll = entityOf(this.plain, dc.name);
+      for (const op of dc.ops) {
+        if (op.op === "add") {
+          if (!coll.has(op.id)) adds.push([dc.name, op.id]);
+        } else if (op.op === "remove") {
+          const value = coll.get(op.id);
+          if (value) removes.push([dc.name, op.id, value]);
+        }
+      }
+    }
+    return adds.length === 0 && removes.length === 0 ? void 0 : { adds, removes };
+  }
+  flushOps(captured) {
+    if (!captured) return;
+    for (const [name, id, value] of captured.removes) {
+      const desc = this.desc(name);
+      this.emitRemove(
+        name,
+        id,
+        value,
+        desc ? `${desc.name}[${id}] has been removed; this is its last value` : name
+      );
+    }
+    for (const [name, id] of captured.adds) this.emitAdd(name, id);
+  }
+  /** Fires adds and removes for the difference a wholesale snapshot load made. */
+  emitSnapshotDiff(before) {
+    if (this.entityListeners.size === 0) return;
+    for (const [name, set] of this.entityListeners) {
+      const desc = this.desc(name);
+      if (!desc || desc.kind !== "entity") continue;
+      const prev = before.get(name) ?? /* @__PURE__ */ new Map();
+      const coll = entityOf(this.plain, name);
+      if (set.remove.size > 0) {
+        for (const [id, value] of prev) {
+          if (!coll.has(id)) {
+            this.emitRemove(
+              name,
+              id,
+              value,
+              `${name}[${id}] has been removed; this is its last value`
+            );
+          }
+        }
+      }
+      if (set.add.size > 0) {
+        for (const id of [...coll.ids()]) {
+          if (!prev.has(id)) this.emitAdd(name, id);
+        }
+      }
+    }
+  }
+  /** The rows every subscribed collection holds right now, for the snapshot diff. */
+  captureRows() {
+    const out = /* @__PURE__ */ new Map();
+    if (this.entityListeners.size === 0) return out;
+    for (const name of this.entityListeners.keys()) {
+      const desc = this.desc(name);
+      if (!desc || desc.kind !== "entity") continue;
+      const coll = entityOf(this.plain, name);
+      const rows = /* @__PURE__ */ new Map();
+      for (const [id, value] of coll) rows.set(id, value);
+      out.set(name, rows);
+    }
+    return out;
+  }
   // -- inbound frames -------------------------------------------------------
   /**
    * Applies a server `DELTA`. Update ops for instances this client owns are dropped field-wise
    * (server wins only through `CORRECT`); adds, removes and owner changes always apply.
    */
   applyServerDelta(delta) {
+    const captured = this.captureOps(delta);
     applyDelta(this.ext, this.plain, this.withoutOwnedUpdates(delta));
     this.replayOverAddEchoes(delta);
+    this.flushOps(captured);
   }
   /**
    * The flushed-write half of the §7.2 in-flight own-write fix: an `add` op for an instance this
@@ -454,7 +593,9 @@ var ClientStore = class {
         });
       }
     }
+    const captured = this.captureOps(delta);
     applyDelta(this.ext, this.plain, delta);
+    this.flushOps(captured);
     let replayed = 0;
     if (replay) {
       for (const pw of [...this.pendingWrites, unflushed]) {

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

@@ -5,7 +5,7 @@ import {
   RESIM_DEPTH,
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS
-} from "./chunk-5Z4DHUA3.js";
+} from "./chunk-5OHONPVG.js";
 
 // src/predictor.ts
 var MAX_FREE_STEPS_PER_FRAME = 5;

package/dist/index.d.ts

@@ -52,6 +52,8 @@ interface CorrectionOp {
     /** `true` when the correction outran the resim window and everything it named snapped. */
     readonly snapped: boolean;
 }
+/** A row appeared (`onAdd`) or disappeared (`onRemove`) in one entity collection. */
+type EntityCallback = (id: string, row: unknown) => void;
 declare class ClientStore {
     /** D50: not `readonly` — a schema swap replaces it in place (`swapSchema`). */
     ext: AnySchema;
@@ -61,6 +63,13 @@ declare class ClientStore {
     private tracked;
     private readonly descs;
     private readonly frozen;
+    /**
+     * Per-collection add/remove subscribers (`room.onAdd` / `room.onRemove`). Kept here rather than
+     * in the session because this is the only place that sees a frame's ops against the state the
+     * frame is about to change: a removed row's last values exist for exactly as long as it takes
+     * `applyDelta` to run.
+     */
+    private readonly entityListeners;
     /** Live collection facades by name, so a D50 swap can retarget rather than replace them. */
     private readonly facades;
     /** The object handed out as `room.state`; identity survives a resync. */
@@ -124,6 +133,28 @@ declare class ClientStore {
     private freeze;
     private entityHint;
     private singletonHint;
+    private listenersFor;
+    /**
+     * Subscribes to rows appearing in one entity collection. Rows that are **already present** are
+     * announced synchronously as the subscription is made — the join snapshot has usually landed
+     * before user code runs, and a listener that had to reconcile the initial set by hand would
+     * make the event useless for exactly the case (a spawn effect) it exists for.
+     */
+    onEntityAdd(name: string, cb: EntityCallback): () => void;
+    /** Subscribes to rows disappearing from one entity collection (never fires for past removals). */
+    onEntityRemove(name: string, cb: EntityCallback): () => void;
+    private emitAdd;
+    private emitRemove;
+    /**
+     * The adds and removes a delta is about to make, captured against the state as it stands now:
+     * a remove's last values are only readable before `applyDelta` drops the row.
+     */
+    private captureOps;
+    private flushOps;
+    /** Fires adds and removes for the difference a wholesale snapshot load made. */
+    private emitSnapshotDiff;
+    /** The rows every subscribed collection holds right now, for the snapshot diff. */
+    private captureRows;
     /**
      * Applies a server `DELTA`. Update ops for instances this client owns are dropped field-wise
      * (server wins only through `CORRECT`); adds, removes and owner changes always apply.
@@ -1453,6 +1484,12 @@ type ClientState<S, Role extends string = RoleOf<S> & string> = {
         serverOwned: true;
     } ? ClientCollection<DeepReadonly<InferFields<F>>> : ClientCollection<Owned<InferFields<F>>> : SchemaDefs<S>[K] extends SingletonDef<infer F, any> ? DeepReadonly<InferFields<F>> : never;
 };
+/** The entity-collection names visible to `Role` — the keys `room.onAdd`/`room.onRemove` take. */
+type EntityKeys<S, Role extends string = RoleOf<S> & string> = {
+    [K in keyof ClientState<S, Role>]: ClientState<S, Role>[K] extends ReadonlyCollection<any> ? K : never;
+}[keyof ClientState<S, Role>];
+/** The row type of one entity collection, as `room.state` hands it out. */
+type RowOf<S, Role extends string, K extends keyof ClientState<S, Role>> = ClientState<S, Role>[K] extends ReadonlyCollection<infer T> ? T : never;
 /** `connecting` → `starting`? → `connected` ⇄ `reconnecting` → `closed`. */
 type Status = 'connecting' | 'starting' | 'connected' | 'reconnecting' | 'closed';
 /**
@@ -1873,9 +1910,29 @@ interface Room<S, Role extends string = RoleOf<S> & string> {
     /** D70: this socket's message counters, including typed frames it could not read. */
     readonly stats: RoomStats;
     on<K extends keyof RoomEvents>(event: K, cb: (value: RoomEvents[K]) => void): Unsubscribe;
+    /**
+     * Fires when a row appears in one entity collection — a server-owned spawn, another client's
+     * entity, a resync that brought a row this client had not seen.
+     *
+     * Rows that are **already present** when you subscribe are announced synchronously, inside the
+     * `onAdd` call itself: the join snapshot has landed by the time `joinRoom` resolves, so a
+     * listener registered right after the join sees the whole initial set and then every later
+     * arrival, with no separate pass over `room.state`.
+     */
+    onAdd<K extends EntityKeys<S, Role>>(collection: K, cb: (id: string, row: RowOf<S, Role, K>) => void): Unsubscribe;
+    /**
+     * Fires when a row disappears from one entity collection, carrying its **last values** — the
+     * row itself is the death event, so a corpse stain or a score tick needs no parallel RPC. The
+     * row handed to the callback is read-only and is not in `room.state` any more.
+     */
+    onRemove<K extends EntityKeys<S, Role>>(collection: K, cb: (id: string, lastRow: RowOf<S, Role, K>) => void): Unsubscribe;
     /** Sends any pending owned writes immediately instead of at the next flush window. */
     flush(): void;
-    leave(): void;
+    /**
+     * Leaves for good. The returned promise resolves once the socket has closed (immediately if it
+     * was already closed), so a script can `await room.leave()` before exiting.
+     */
+    leave(): Promise<void>;
 }
 /**
  * What `joinRelay` returns: presence and the message channel, nothing else.
@@ -1905,7 +1962,8 @@ interface RelayRoom<S = never> {
     /** D70: this socket's message counters, including typed frames it could not read. */
     readonly stats: RoomStats;
     on<K extends keyof RoomEvents>(event: K, cb: (value: RoomEvents[K]) => void): Unsubscribe;
-    leave(): void;
+    /** Leaves for good; resolves once the socket has closed (immediately if it already had). */
+    leave(): Promise<void>;
 }
 
 /**
@@ -2635,8 +2693,15 @@ declare class Session {
     private connect;
     private transportFailed;
     private sendHello;
-    /** Leaves for good: no reconnect, pending calls reject, the socket closes. */
-    leave(): void;
+    /**
+     * 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(): Promise<void>;
     private fatal;
     private onSocketClosed;
     private stopTimers;
@@ -2949,4 +3014,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, 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 };
+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 EntityKeys, 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, type RowOf, 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-5Z4DHUA3.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-4SGKNBAC.js").then(({ PhysicsPredictor }) => {
+      void import("./physics-D65WIHPR.js").then(({ PhysicsPredictor }) => {
         if (this.left) return;
         attach(
           new PhysicsPredictor(
@@ -1133,7 +1134,7 @@ var Session = class {
     } else if (physics2d !== void 0 && physics2d.engine === "rapier2d" && hasPhysics) {
       const rapier2d = physics2d;
       this.predictionRequested = true;
-      void import("./physics-rapier2d-TBOAJMVM.js").then(({ Rapier2dPredictor }) => {
+      void import("./physics-rapier2d-O53E6BHO.js").then(({ Rapier2dPredictor }) => {
         if (this.left) return;
         attach(
           new Rapier2dPredictor(
@@ -1149,7 +1150,7 @@ var Session = class {
     } else if (physics2d !== void 0 && physics2d.engine !== "rapier2d" && hasPhysics) {
       const matter2d = physics2d;
       this.predictionRequested = true;
-      void import("./physics2d-CNSEWKP4.js").then(({ Physics2dPredictor }) => {
+      void import("./physics2d-GIL6YYAY.js").then(({ Physics2dPredictor }) => {
         if (this.left) return;
         attach(
           new Physics2dPredictor(
@@ -1379,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;
@@ -2865,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()
   };

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

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

package/dist/{physics-rapier2d-TBOAJMVM.js → physics-rapier2d-O53E6BHO.js}

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-XFD6WYQW.js";
-import "./chunk-5Z4DHUA3.js";
+} from "./chunk-VZFJXPVF.js";
+import "./chunk-5OHONPVG.js";
 
 // src/physics-rapier2d.ts
 import {

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

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-XFD6WYQW.js";
-import "./chunk-5Z4DHUA3.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.8.0",
+  "version": "0.9.0",
   "description": "irtio client SDK: joinRoom, owned-write batching, corrections, typed RPCs, presence, reconnection",
   "license": "MIT",
   "publishConfig": {
@@ -20,8 +20,8 @@
   ],
   "dependencies": {
     "mediasoup-client": "^3.23.1",
-    "@irtio/protocol": "0.8.0",
-    "@irtio/schema": "0.8.0"
+    "@irtio/protocol": "0.9.0",
+    "@irtio/schema": "0.9.0"
   },
   "peerDependencies": {
     "@dimforge/rapier2d-compat": ">=0.20.0",