@irtio/client 0.6.0 → 0.8.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-5Z4DHUA3.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-4SGKNBAC.js").then(({ PhysicsPredictor }) => {
         if (this.left) return;
         attach(
           new PhysicsPredictor(
@@ -1060,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("./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-ZV2IRRRZ.js").then(({ Physics2dPredictor }) => {
+      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
@@ -1102,6 +1189,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 +1255,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 +1732,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 +1858,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 +1879,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 +1956,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 +1978,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 +1987,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.
@@ -2032,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 {
@@ -2403,6 +2806,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 +2851,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 +2862,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 +2877,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 +2918,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()
   };
@@ -2522,8 +2937,12 @@ export {
   INTERNAL_VOICE_TRACKS,
   Identity,
   IdentityError,
+  LOBBY_MEMBERS,
+  LOBBY_POLL_MS,
+  LOBBY_STATE,
   MAX_IDENTITY_RETRY_WAIT_MS,
   MAX_PREDICTED_BODIES,
+  MAX_PROXY_BODIES,
   MatchError,
   PING_INTERVAL_MS,
   PREDICTION_EPSILON,
@@ -2532,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-S5LHL3HK.js → physics-4SGKNBAC.js}

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-TE66EDBB.js";
-import "./chunk-6J6PKFUS.js";
+} from "./chunk-XFD6WYQW.js";
+import "./chunk-5Z4DHUA3.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
 };