@irtio/client 0.6.0 → 0.7.0

package/dist/index.js

@@ -2,12 +2,13 @@ import {
   ClientStore,
   E_CONNECT_FAILED,
   MAX_PREDICTED_BODIES,
+  MAX_PROXY_BODIES,
   PREDICTION_EPSILON,
   RESIM_DEPTH,
   SMOOTHING_HALF_LIFE_MS,
   SMOOTHING_SNAP_UNITS,
   emptyPredictionStats
-} from "./chunk-6J6PKFUS.js";
+} from "./chunk-XWVXZRBS.js";
 
 // src/index.ts
 import { EMPTY_PROFILE as EMPTY_PROFILE2 } from "@irtio/protocol";
@@ -495,6 +496,23 @@ async function errorFrom(res) {
   return new IdentityError(code, message);
 }
 
+// src/messages.ts
+import { encodeFields } from "@irtio/schema";
+function buildMessages(schema, session) {
+  const out = {};
+  for (const desc of schema?.messages ?? []) {
+    out[desc.name] = {
+      send(target, value) {
+        session.typedMessage(desc.index, target, encodeFields(desc.fields, value));
+      },
+      on(cb) {
+        return session.onTypedMessage(desc.index, cb);
+      }
+    };
+  }
+  return out;
+}
+
 // src/session.ts
 import {
   FrameType,
@@ -529,7 +547,7 @@ import {
   decodeDelta,
   decodeDeltaFrom,
   decodeFields,
-  encodeFields,
+  encodeFields as encodeFields2,
   schemaFromCanonical
 } from "@irtio/schema";
 
@@ -764,6 +782,57 @@ var RenderStore = class {
     const alpha = span > 0 ? (renderT - a.t) / span : 1;
     return lerpRecord(desc, a.value, b.value, Math.min(1, Math.max(0, alpha)));
   }
+  /**
+   * M6 lane D (D71): the body-channel values the renderer is drawing for one instance right now,
+   * written into `into`. `true` when there is a pose to draw at all.
+   *
+   * This is what a kinematic proxy is moved to before every local step, and it deliberately does
+   * **not** go through `get`. `get` asks the predictor first — which would recurse, since it calls
+   * `frame()` — and for an owned or predicted instance it answers out of the local world, which is
+   * the one answer a proxy must never be given (a proxy driven by the local world is a body driving
+   * itself). So this is the D20 buffer and nothing else: the authoritative pose interpolated at
+   * `interpDelayMs` behind arrival, held at the newest delta and never extrapolated past it.
+   *
+   * Allocation-free, and only the physics channels: it runs once per proxy per frame.
+   *
+   * Two things `get` does are left out on purpose. `starved` is not counted, because that number
+   * belongs to the render path and a physics read landing in it would double it. And a buffer whose
+   * entity has aged out is not `gc`'d here, because a read that drives physics must not decide when
+   * the render path's buffers die.
+   */
+  drawn(desc, id, into) {
+    const physics = desc.physics;
+    if (!physics) return false;
+    const coll = this.store.plain[desc.name];
+    const fill = (value) => {
+      if (value === void 0) return false;
+      for (const [, field] of physics.channels) {
+        const v = value[field];
+        if (typeof v === "number") into[field] = v;
+      }
+      return true;
+    };
+    if (!desc.interpolate) return fill(coll.get(id));
+    const buffer = this.buffers.get(desc.name)?.get(id);
+    if (!buffer || buffer.frames.length === 0) return fill(coll.get(id));
+    const renderT = this.renderTime();
+    if (buffer.removedAt !== void 0 && renderT >= buffer.removedAt) return false;
+    this.prune(buffer, renderT);
+    const frames = buffer.frames;
+    const a = frames[0];
+    if (renderT < a.t) return false;
+    const b = frames[1];
+    if (!b) return fill(a.value);
+    const span = b.t - a.t;
+    const alpha = span > 0 ? Math.min(1, Math.max(0, (renderT - a.t) / span)) : 1;
+    for (const [, field] of physics.channels) {
+      const av = a.value[field];
+      if (typeof av !== "number") continue;
+      const bv = b.value[field];
+      into[field] = typeof bv === "number" ? av + (bv - av) * alpha : av;
+    }
+    return true;
+  }
   /** Is `collection[id]` visible at the render clock? */
   has(desc, id) {
     const coll = this.store.plain[desc.name];
@@ -1038,6 +1107,7 @@ var Session = class {
       if (this.left) return;
       this.predictor = predictor;
       this.render.attachPredictor(predictor);
+      predictor.setDrawnReader((desc, id, into) => this.render.drawn(desc, id, into));
       if (this.joined) {
         predictor.reset();
         void predictor.start();
@@ -1047,7 +1117,7 @@ var Session = class {
     const physics2d = options.physics2d;
     if (physics && hasPhysics) {
       this.predictionRequested = true;
-      void import("./physics-S5LHL3HK.js").then(({ PhysicsPredictor }) => {
+      void import("./physics-RT5T36P5.js").then(({ PhysicsPredictor }) => {
         if (this.left) return;
         attach(
           new PhysicsPredictor(
@@ -1062,7 +1132,7 @@ var Session = class {
       });
     } else if (physics2d && hasPhysics) {
       this.predictionRequested = true;
-      void import("./physics2d-ZV2IRRRZ.js").then(({ Physics2dPredictor }) => {
+      void import("./physics2d-HOFMWPZV.js").then(({ Physics2dPredictor }) => {
         if (this.left) return;
         attach(
           new Physics2dPredictor(
@@ -1102,6 +1172,9 @@ var Session = class {
    * whatever a `SCHEMA` frame replaced it with. Read instead of `options.schema` everywhere, so a
    * swapped session announces its *current* hash when it reconnects rather than the one it was
    * born with — otherwise a resume after a swap would be refused as a mismatch.
+   *
+   * D70 made it internally readable rather than private: `buildMessages` reads the declared
+   * shapes off it when the room object is built. Still not on the public `Room` type.
    */
   schema;
   /** D50: how many times this session has swapped schema. Test seam and a diagnostic. */
@@ -1165,6 +1238,20 @@ var Session = class {
    * `INTERNAL_SESSION`, the same route the D50 tests use for the session itself.
    */
   voiceListeners = /* @__PURE__ */ new Set();
+  /**
+   * D70: typed-message listeners, by wire index, in their own map for the same structural reason
+   * `voiceListeners` is its own set: a raw `onMessage` callback must never be handed a typed
+   * frame and a typed callback must never be handed raw bytes. Splitting the registries makes
+   * that a fact about the shape of the code rather than a filter somewhere in the fan-out.
+   */
+  typedListeners = /* @__PURE__ */ new Map();
+  /** D70: one warning per session for dropped typed messages — a flood must stay one line. */
+  typedDropWarned = false;
+  /**
+   * D70: what `room.stats.messages` reads. `dropped` is the one worth watching: it counts typed
+   * frames this client could not decode, which is a peer on a schema this one does not have.
+   */
+  messageCounts = { sent: 0, received: 0, dropped: 0 };
   cancelFlush;
   cancelPing;
   cancelRetry;
@@ -1628,15 +1715,62 @@ var Session = class {
     if (pong.serverTick > this.tick) this.tick = pong.serverTick;
   }
   onMsg(payload) {
-    const msg = decodeMsg(payload);
+    let msg;
+    try {
+      msg = decodeMsg(payload);
+    } catch (err) {
+      this.dropTypedMessage(err);
+      return;
+    }
     const bytes = msg.payload.slice();
     if (msg.target.kind === "voice") {
       for (const cb of [...this.voiceListeners]) cb(bytes);
       return;
     }
     const from = msg.target.kind === "client" ? msg.target.clientId : "server";
+    if (msg.typed) {
+      this.deliverTyped(msg.typed.index, from, bytes);
+      return;
+    }
+    this.messageCounts.received++;
     for (const cb of [...this.messageListeners]) cb(from, bytes);
   }
+  /**
+   * D70: decode one typed payload against the current schema and hand it to that shape's
+   * listeners.
+   *
+   * Everything a hostile peer can do here ends in the same place: a counter and a dropped frame.
+   * An index past the schema's list, a truncated payload, an oversize `str`, an over-max `list`,
+   * an unknown enum member, or a well-formed value of the wrong shape — each is caught, none
+   * throws out of the frame loop, none closes the socket, and the next frame is delivered
+   * normally. The `console.warn` fires once per session so a flood stays one line.
+   */
+  deliverTyped(index, from, bytes) {
+    const desc = this.schema?.messages?.[index];
+    if (!desc) {
+      this.dropTypedMessage(new Error(`no message with index ${index} in this schema`));
+      return;
+    }
+    let value;
+    try {
+      value = decodeFields(desc.fields, bytes);
+    } catch (err) {
+      this.dropTypedMessage(err);
+      return;
+    }
+    this.messageCounts.received++;
+    const set = this.typedListeners.get(index);
+    if (!set) return;
+    for (const cb of [...set]) cb(from, value);
+  }
+  dropTypedMessage(err) {
+    this.messageCounts.dropped++;
+    if (this.typedDropWarned) return;
+    this.typedDropWarned = true;
+    console.warn(
+      `irtio: dropped a typed message this client could not read (${err instanceof Error ? err.message : String(err)}). Read room.stats.messages.dropped for the count; further drops are silent.`
+    );
+  }
   // -------------------------------------------------------------------------
   // Timers
   // -------------------------------------------------------------------------
@@ -1707,7 +1841,7 @@ var Session = class {
     let encoded;
     try {
       desc = this.descOf(name);
-      encoded = encodeFields(desc.params, params);
+      encoded = encodeFields2(desc.params, params);
     } catch (err) {
       return Promise.reject(err instanceof Error ? err : new Error(String(err)));
     }
@@ -1728,7 +1862,10 @@ var Session = class {
         reject,
         cancelTimeout
       });
-      this.send(FrameType.CALL, encodeCall({ reqId, rpcId: desc.index, params: encoded }));
+      this.send(
+        FrameType.CALL,
+        encodeCall({ reqId, rpcId: desc.index, clientTick: this.tick, params: encoded })
+      );
     });
   }
   async requestOwnership(entity, id) {
@@ -1802,7 +1939,7 @@ var Session = class {
   replyOk(desc, reqId, result) {
     let bytes;
     try {
-      bytes = desc.returns ? encodeFields(desc.returns, result ?? {}) : new Uint8Array(0);
+      bytes = desc.returns ? encodeFields2(desc.returns, result ?? {}) : new Uint8Array(0);
     } catch (err) {
       this.replyError(reqId, err instanceof Error ? err.message : String(err));
       return;
@@ -1824,6 +1961,7 @@ var Session = class {
   // -------------------------------------------------------------------------
   message(target, bytes) {
     const wire = target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
+    this.messageCounts.sent++;
     this.send(FrameType.MSG, encodeMsg({ target: wire, payload: bytes }));
   }
   onMessage(cb) {
@@ -1832,6 +1970,27 @@ var Session = class {
       this.messageListeners.delete(cb);
     };
   }
+  /**
+   * D70: send one typed message. `payload` is already `encodeFields`'d by the caller
+   * (`buildMessages`), which is where the shape and the throw on a bad value belong.
+   */
+  typedMessage(index, target, payload) {
+    const wire = target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
+    this.messageCounts.sent++;
+    this.send(FrameType.MSG, encodeMsg({ target: wire, payload, typed: { index } }));
+  }
+  /** D70: subscribe to one message shape by wire index. Raw listeners never see these frames. */
+  onTypedMessage(index, cb) {
+    let set = this.typedListeners.get(index);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.typedListeners.set(index, set);
+    }
+    set.add(cb);
+    return () => {
+      set?.delete(cb);
+    };
+  }
   /**
    * D51: write one voice signaling message. Internal — reached only through `INTERNAL_SESSION`,
    * so it is not on the `Room` type and a game cannot call it.
@@ -2403,6 +2562,8 @@ async function joinRoom(schema, options = {}) {
 }
 function makeRoom(session) {
   const call = callProxy(session);
+  const messages = buildMessages(session.schema, session);
+  const stats = { messages: session.messageCounts };
   const room = {
     get me() {
       return session.me;
@@ -2446,6 +2607,8 @@ function makeRoom(session) {
           return session.predictor?.ready ?? false;
         },
         predicts: (collection, id) => session.predictor?.has(collection, id) ?? false,
+        // ---- M6 lane D: proxies ----
+        proxied: (collection, id) => session.predictor?.hasProxy(collection, id) ?? false,
         get stats() {
           return session.predictor?.stats ?? emptyPredictionStats();
         }
@@ -2455,6 +2618,8 @@ function makeRoom(session) {
     requestOwnership: (entity, id) => session.requestOwnership(entity, id),
     message: (target, bytes) => session.message(target, bytes),
     onMessage: (cb) => session.onMessage(cb),
+    messages,
+    stats,
     on: (event, cb) => session.on(event, cb),
     flush: () => session.flush(),
     leave: () => session.leave()
@@ -2468,7 +2633,11 @@ async function joinRelay(options = {}) {
   const fromLocation = !explicitRoom && currentLocation() !== void 0;
   const roomId = explicitRoom ? roomIdFrom(options.room ?? "") : fromLocation ? roomIdFromLocation() : "";
   const session = new Session({
-    schema: void 0,
+    // ---- M6 lane C: typed messages ----
+    // D70: a relay join may now bring the project's deployed schema. This is a type change and a
+    // hash change, not a transport change: the session already chose between the builder's schema
+    // and `relaySchema`, and already put `schema.hash8` or `RELAY_HASH8` in the HELLO.
+    schema: options.schema,
     url,
     key: options.key ?? resolveKey(void 0, void 0, url),
     roomId,
@@ -2505,6 +2674,8 @@ async function joinRelay(options = {}) {
     },
     message: (target, bytes) => session.message(target, bytes),
     onMessage: (cb) => session.onMessage(cb),
+    messages: buildMessages(session.schema, session),
+    stats: { messages: session.messageCounts },
     on: (event, cb) => session.on(event, cb),
     leave: () => session.leave()
   };
@@ -2524,6 +2695,7 @@ export {
   IdentityError,
   MAX_IDENTITY_RETRY_WAIT_MS,
   MAX_PREDICTED_BODIES,
+  MAX_PROXY_BODIES,
   MatchError,
   PING_INTERVAL_MS,
   PREDICTION_EPSILON,

package/dist/{physics-S5LHL3HK.js → physics-RT5T36P5.js}

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-TE66EDBB.js";
-import "./chunk-6J6PKFUS.js";
+} from "./chunk-DABQDR3S.js";
+import "./chunk-XWVXZRBS.js";
 
 // src/physics.ts
 function readPose(body, into) {
@@ -100,6 +100,25 @@ var RapierAdapter = class {
   removeBody(body) {
     this.world?.removeRigidBody(body);
   }
+  /**
+   * D71: a proxy is a `KinematicPositionBased` body — driven by the position it is told to be at
+   * next, never by a force, an impulse or a contact. Rapier derives the velocity its contacts see
+   * from the move itself, which is what carries a predicted body standing on a moving platform.
+   *
+   * The body is *switched* rather than built kinematic, so its collider, mass properties and axis
+   * locks are the ones the shared factory produced. A proxy has to be the server's body, and the
+   * only way to keep that true is to run the same factory call the predicted path runs.
+   */
+  makeKinematic(handle) {
+    const rapier = this.rapier;
+    if (!rapier) return;
+    handle.setBodyType(rapier.RigidBodyType.KinematicPositionBased, true);
+  }
+  moveKinematic(handle, pose) {
+    const body = handle;
+    body.setNextKinematicTranslation(pose.t);
+    body.setNextKinematicRotation(pose.r);
+  }
   step() {
     this.world?.step();
   }
@@ -191,6 +210,10 @@ var PhysicsPredictor = class extends Predictor {
     super(ext, store, new RapierAdapter(options), options, meOf, rttOf, tickIntervalOf, log);
   }
 };
+function createRapierAdapter(options) {
+  return new RapierAdapter(options);
+}
 export {
-  PhysicsPredictor
+  PhysicsPredictor,
+  createRapierAdapter
 };

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

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-TE66EDBB.js";
-import "./chunk-6J6PKFUS.js";
+} from "./chunk-DABQDR3S.js";
+import "./chunk-XWVXZRBS.js";
 
 // src/physics2d.ts
 import {
@@ -47,6 +47,8 @@ var MatterAdapter = class {
   };
   /** `applyChannel2d`'s target shape, likewise reused. */
   channels = { x: 0, y: 0, qz: 0, qw: 1, vx: 0, vy: 0, wz: 0 };
+  /** `moveKinematic`'s position argument, reused: it runs per proxy per step (D71). */
+  moveTarget = { x: 0, y: 0 };
   get timestep() {
     return this.options.timestep;
   }
@@ -95,6 +97,53 @@ var MatterAdapter = class {
     matter.Composite.remove(engine2.world, pinned ? [body, ...pinned] : [body]);
     this.constraints.delete(body);
   }
+  /**
+   * D71: matter.js has no kinematic body type. Static is the only kind it never integrates and
+   * never moves from an impulse, so that is what a proxy is.
+   *
+   * `Body.setStatic` also overwrites the surface properties the factory set — `friction` to 1 and
+   * `restitution` to 0, on every part, and on a body that was *already* static it does that without
+   * even stashing the old values in `_original`. A proxy has to be the server's body rather than a
+   * stickier copy of it (matter pairs friction as the minimum of the two, so a proxy at friction 1
+   * is only invisible while the other body is the grippier one), so the factory's values are
+   * snapshotted here and put back. Mass and inertia keep the infinities that make it immovable.
+   */
+  makeKinematic(handle) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const parts = body.parts;
+    const surfaces = parts.map((p) => ({ friction: p.friction, restitution: p.restitution }));
+    matter.Body.setStatic(body, true);
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const surface = surfaces[i];
+      part.friction = surface.friction;
+      part.restitution = surface.restitution;
+    }
+  }
+  /**
+   * `updateVelocity: true` is the whole mechanism. It leaves `positionPrev` exactly one move behind
+   * the new position, and matter's resolver reads a body's velocity as precisely that difference
+   * (`Resolver.solveVelocity`: `position - positionPrev`), so a predicted body resting on the proxy
+   * is carried by friction the way it is on the server. Given the same pose twice the difference is
+   * zero and the proxy is at rest, which is what holds it still through a rebase's re-steps.
+   *
+   * The third parameter is real in matter-js 0.20 (`src/body/Body.js`) and missing from
+   * `@types/matter-js@0.20.2` on both setters, which is what the two casts are for.
+   */
+  moveKinematic(handle, pose) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const setPosition = matter.Body.setPosition;
+    const setAngle = matter.Body.setAngle;
+    const to = this.moveTarget;
+    to.x = pose.t.x;
+    to.y = pose.t.y;
+    setPosition(body, to, true);
+    setAngle(body, angleFrom2d(pose.r.z, pose.r.w), true);
+  }
   step() {
     if (!this.matter || !this.engine) return;
     this.matter.Engine.update(this.engine, this.stepMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/client",
-  "version": "0.6.0",
+  "version": "0.7.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.6.0",
-    "@irtio/schema": "0.6.0"
+    "@irtio/protocol": "0.7.0",
+    "@irtio/schema": "0.7.0"
   },
   "peerDependencies": {
     "@dimforge/rapier3d-compat": ">=0.20.0",