@irtio/runtime 0.6.0 → 0.7.0

package/dist/{chunk-K42HA75G.js → chunk-EXPFVRD4.js}

@@ -143,10 +143,10 @@ function handleCall(core, clientId, payload) {
       return true;
     }
   }
-  const ctx = core.ctxFor(clientId);
+  const ctx = { ...core.ctxFor(clientId), clientTick: call.clientTick || void 0 };
   let result;
   if (desc.name === REQUEST_OWNERSHIP) {
-    result = runRequestOwnership(core, clientId, params);
+    result = runRequestOwnership(core, clientId, ctx, params);
   } else {
     const impl = core.definition.config.rpc?.[desc.name];
     if (!impl) {
@@ -175,7 +175,7 @@ function handleCall(core, clientId, payload) {
   }
   return true;
 }
-function runRequestOwnership(core, clientId, params) {
+function runRequestOwnership(core, clientId, ctx, params) {
   const name = String(params.entity ?? "");
   const id = String(params.id ?? "");
   const c = collectionDescOf(core.ext, name);
@@ -185,10 +185,7 @@ function runRequestOwnership(core, clientId, params) {
   const handler = core.definition.config.onOwnershipRequest;
   const tracked = trackedEntity(core, name);
   if (handler) {
-    const ran = core.tryRun(
-      "onOwnershipRequest",
-      () => handler(core.anyState, name, id, core.ctxFor(clientId))
-    );
+    const ran = core.tryRun("onOwnershipRequest", () => handler(core.anyState, name, id, ctx));
     if (ran.ok && ran.value === true && plain.ownerOf(id) !== clientId) {
       tracked.setOwner(id, clientId);
     }
@@ -762,6 +759,7 @@ var Loop = class {
         physics.reconcile();
         physics.step();
         physics.sync();
+        this.core.captureHistory();
       });
       if (!ran.ok) {
         failed = failed === void 0 ? "the physics step" : `${failed} and the physics step`;
@@ -1054,6 +1052,20 @@ var MatterRuntime = class {
     }
     return spec.body;
   }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: every tracked body, in the order `sync()` walks them. The matter half of the same
+   * read-only accessor `PhysicsRuntime` carries; see its comment for what calls it and when.
+   */
+  eachTrackedBody(fn) {
+    for (const desc of this.collections) {
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      for (const id of plainColl.ids()) {
+        const attached = this.bodies.get(bodyKey(desc.name, id));
+        if (attached) fn(desc.name, id, attached.body);
+      }
+    }
+  }
   applyState(body, s) {
     const M = this.matter;
     M.Body.setPosition(body, { x: s.x, y: s.y });
@@ -1396,6 +1408,22 @@ var PhysicsRuntime = class {
     this.bodies.set(bodyKey2(desc.name, id), body);
     return body;
   }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
+   * order). Read-only: it hands out the live bodies and nothing else, and the map stays private.
+   * The pose history calls this once per tick and the rewind scratch calls it per rewind; a room
+   * that declares no `physics.history` never calls it at all.
+   */
+  eachTrackedBody(fn) {
+    for (const desc of this.collections) {
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      for (const id of plainColl.ids()) {
+        const body = this.bodies.get(bodyKey2(desc.name, id));
+        if (body) fn(desc.name, id, body);
+      }
+    }
+  }
   applyRecordToBody(desc, body, record) {
     const physics = desc.physics;
     if (!physics) return;
@@ -1963,8 +1991,469 @@ import {
   validateForDeploy
 } from "@irtio/schema";
 
+// src/core/history.ts
+var HISTORY_MAX_TICKS = 240;
+var STRIDE = 13;
+function emptyPose() {
+  return { x: 0, y: 0, z: 0, qx: 0, qy: 0, qz: 0, qw: 1, vx: 0, vy: 0, vz: 0, wx: 0, wy: 0, wz: 0 };
+}
+function newEntry() {
+  return { tick: -1, count: 0, collections: [], ids: [], values: new Float64Array(0) };
+}
+var PoseHistory = class {
+  depth;
+  entries = [];
+  /** Index of the newest entry in `entries`, or -1 when nothing has been captured. */
+  head = -1;
+  size = 0;
+  /** Reused across every body of every capture: the capture path allocates nothing per body. */
+  scratchPose = emptyPose();
+  constructor(depth) {
+    this.depth = Math.max(1, Math.min(HISTORY_MAX_TICKS, Math.floor(depth)));
+    for (let i = 0; i < this.depth; i++) this.entries.push(newEntry());
+  }
+  get length() {
+    return this.size;
+  }
+  /** The newest tick captured, or `undefined` when the buffer is empty. */
+  get newestTick() {
+    return this.size === 0 ? void 0 : this.entries[this.head].tick;
+  }
+  /** The oldest tick still held, or `undefined` when the buffer is empty. */
+  get oldestTick() {
+    if (this.size === 0) return void 0;
+    const i = (this.head - (this.size - 1) + this.depth * 2) % this.depth;
+    return this.entries[i].tick;
+  }
+  /** Drops everything. Used by the hibernation path, where a buffer cannot survive. */
+  clear() {
+    this.head = -1;
+    this.size = 0;
+  }
+  /** Captures one tick's poses off the live runtime. Called right after `physics.sync()`. */
+  capture(tick, physics) {
+    this.head = this.size === 0 ? 0 : (this.head + 1) % this.depth;
+    if (this.size < this.depth) this.size++;
+    const entry = this.entries[this.head];
+    entry.tick = tick;
+    entry.count = 0;
+    const pose = this.scratchPose;
+    const rapier = physics.engineKind === "rapier3d";
+    physics.eachTrackedBody((collection, id, body) => {
+      if (rapier) readRapierPose(body, pose);
+      else readMatterPose(body, pose);
+      this.push(entry, collection, id, pose);
+    });
+  }
+  push(entry, collection, id, pose) {
+    const i = entry.count;
+    const need = (i + 1) * STRIDE;
+    if (entry.values.length < need) {
+      const grown = new Float64Array(Math.max(need, entry.values.length * 2, STRIDE * 8));
+      grown.set(entry.values);
+      entry.values = grown;
+    }
+    entry.collections[i] = collection;
+    entry.ids[i] = id;
+    const v = entry.values;
+    const o = i * STRIDE;
+    v[o] = pose.x;
+    v[o + 1] = pose.y;
+    v[o + 2] = pose.z;
+    v[o + 3] = pose.qx;
+    v[o + 4] = pose.qy;
+    v[o + 5] = pose.qz;
+    v[o + 6] = pose.qw;
+    v[o + 7] = pose.vx;
+    v[o + 8] = pose.vy;
+    v[o + 9] = pose.vz;
+    v[o + 10] = pose.wx;
+    v[o + 11] = pose.wy;
+    v[o + 12] = pose.wz;
+    entry.count = i + 1;
+  }
+  /**
+   * The entry a rewind to `requested` answers from, clamped into the window the buffer actually
+   * holds. `undefined` only when nothing has been captured at all.
+   */
+  resolve(requested) {
+    if (this.size === 0) return void 0;
+    const newest = this.entries[this.head].tick;
+    const oldest = this.oldestTick;
+    const want = Number.isFinite(requested) ? Math.floor(requested) : newest;
+    const tick = want < oldest ? oldest : want > newest ? newest : want;
+    const entry = this.at(tick);
+    if (!entry) return void 0;
+    return { entry, tick: entry.tick, clamped: tick !== want };
+  }
+  /**
+   * The entry for exactly `tick`. Index arithmetic first (captures are one tick apart, so the
+   * offset from the head is the tick difference), with a scan as insurance: a room whose loop
+   * ever skipped a capture would otherwise be answered with the wrong tick's poses, and answering
+   * for a tick that was not recorded is the one thing this buffer must never do.
+   */
+  at(tick) {
+    const newest = this.entries[this.head].tick;
+    const offset = newest - tick;
+    if (offset >= 0 && offset < this.size) {
+      const e = this.entries[(this.head - offset + this.depth * 2) % this.depth];
+      if (e.tick === tick) return e;
+    }
+    for (let k = 0; k < this.size; k++) {
+      const e = this.entries[(this.head - k + this.depth * 2) % this.depth];
+      if (e.tick === tick) return e;
+    }
+    return void 0;
+  }
+};
+function poseAt(entry, index, into) {
+  const v = entry.values;
+  const o = index * STRIDE;
+  into.x = v[o];
+  into.y = v[o + 1];
+  into.z = v[o + 2];
+  into.qx = v[o + 3];
+  into.qy = v[o + 4];
+  into.qz = v[o + 5];
+  into.qw = v[o + 6];
+  into.vx = v[o + 7];
+  into.vy = v[o + 8];
+  into.vz = v[o + 9];
+  into.wx = v[o + 10];
+  into.wy = v[o + 11];
+  into.wz = v[o + 12];
+}
+function readRapierPose(body, into) {
+  const t = body.translation();
+  const r = body.rotation();
+  const v = body.linvel();
+  const w = body.angvel();
+  into.x = t.x;
+  into.y = t.y;
+  into.z = t.z;
+  into.qx = r.x;
+  into.qy = r.y;
+  into.qz = r.z;
+  into.qw = r.w;
+  into.vx = v.x;
+  into.vy = v.y;
+  into.vz = v.z;
+  into.wx = w.x;
+  into.wy = w.y;
+  into.wz = w.z;
+}
+function readMatterPose(body, into) {
+  into.x = body.position.x;
+  into.y = body.position.y;
+  into.z = 0;
+  into.qx = 0;
+  into.qy = 0;
+  into.qz = Math.sin(body.angle / 2);
+  into.qw = Math.cos(body.angle / 2);
+  into.vx = body.velocity.x;
+  into.vy = body.velocity.y;
+  into.vz = 0;
+  into.wx = 0;
+  into.wy = 0;
+  into.wz = body.angularVelocity;
+}
+function historyDepthOf(config) {
+  const declared = config?.history;
+  if (typeof declared !== "number" || !Number.isFinite(declared) || declared <= 0) return void 0;
+  return Math.min(HISTORY_MAX_TICKS, Math.floor(declared));
+}
+function keyOf(collection, id) {
+  return `${collection} ${id}`;
+}
+function angleOf(qz, qw) {
+  return 2 * Math.atan2(qz, qw);
+}
+var BaseScratch = class {
+  constructor(physics, depth, tickNow) {
+    this.physics = physics;
+    this.depth = depth;
+    this.tickNow = tickNow;
+  }
+  physics;
+  depth;
+  tickNow;
+  bodies = /* @__PURE__ */ new Map();
+  present = /* @__PURE__ */ new Set();
+  pose = emptyPose();
+  view(entry, tick, requested, clamped) {
+    this.sync();
+    this.present.clear();
+    for (let i = 0; i < entry.count; i++) {
+      const key = keyOf(entry.collections[i], entry.ids[i]);
+      const e = this.bodies.get(key);
+      if (!e) continue;
+      poseAt(entry, i, this.pose);
+      this.place(e, this.pose);
+      this.present.add(key);
+    }
+    for (const [key, e] of this.bodies) {
+      if (!this.present.has(key)) this.hide(e);
+    }
+    return this.build(tick, requested, clamped);
+  }
+  /**
+   * Brings the scratch's body set in step with the live world: a double for every live body that
+   * has none, a rebuild for one whose collider (or part) count changed, and a prune for one that
+   * has been gone longer than the history is deep and so can no longer appear in any entry.
+   *
+   * The prune is conservative rather than exact: `lastLive` only advances when a rewind happens,
+   * so a room that rewinds rarely holds its dead doubles a little longer than it strictly must.
+   * Over-retention is a few hundred bytes; under-retention would be a wrong answer.
+   */
+  sync() {
+    const now = this.tickNow();
+    const seen = /* @__PURE__ */ new Set();
+    this.physics.eachTrackedBody((collection, id, body) => {
+      const key = keyOf(collection, id);
+      seen.add(key);
+      const parts = this.partsOf(body);
+      const existing = this.bodies.get(key);
+      if (existing && existing.parts === parts) {
+        existing.lastLive = now;
+        return;
+      }
+      if (existing) {
+        this.bodies.delete(key);
+        this.destroy(existing);
+      }
+      const made = this.clone(collection, id, body, parts);
+      if (!made) return;
+      made.lastLive = now;
+      this.bodies.set(key, made);
+    });
+    for (const [key, e] of [...this.bodies]) {
+      if (seen.has(key)) continue;
+      if (now - e.lastLive <= this.depth) continue;
+      this.bodies.delete(key);
+      this.destroy(e);
+    }
+  }
+};
+function qConj(q) {
+  return { x: -q.x, y: -q.y, z: -q.z, w: q.w };
+}
+function qMul(a, b) {
+  return {
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  };
+}
+function qRotate(q, v) {
+  const p = qMul(qMul(q, { x: v.x, y: v.y, z: v.z, w: 0 }), qConj(q));
+  return { x: p.x, y: p.y, z: p.z };
+}
+var RapierScratch = class extends BaseScratch {
+  world;
+  rapier;
+  owners = /* @__PURE__ */ new Map();
+  /** Live rigid-body handles the room tracks, so the statics pass knows what to skip. */
+  trackedLive = /* @__PURE__ */ new Set();
+  staticsCloned = false;
+  constructor(physics, depth, tickNow) {
+    super(physics, depth, tickNow);
+    this.rapier = physics.rapier;
+    this.world = new this.rapier.World({ x: 0, y: 0, z: 0 });
+    this.world.timestep = 0;
+  }
+  partsOf(body) {
+    return body.numColliders();
+  }
+  clone(collection, id, body, parts) {
+    const live = body;
+    this.trackedLive.add(live.handle);
+    const made = this.world.createRigidBody(this.rapier.RigidBodyDesc.fixed());
+    const origin = live.translation();
+    const rot = live.rotation();
+    const inv = qConj(rot);
+    for (let i = 0; i < parts; i++) {
+      const c = live.collider(i);
+      const desc = new this.rapier.ColliderDesc(c.shape);
+      desc.setSensor(c.isSensor());
+      const w = c.translation();
+      const local = qRotate(inv, { x: w.x - origin.x, y: w.y - origin.y, z: w.z - origin.z });
+      desc.setTranslation(local.x, local.y, local.z);
+      desc.setRotation(qMul(inv, c.rotation()));
+      this.world.createCollider(desc, made);
+    }
+    this.owners.set(made.handle, { collection, id });
+    return { collection, id, body: made, parts, lastLive: -1 };
+  }
+  place(entry, pose) {
+    const b = entry.body;
+    if (!b.isEnabled()) b.setEnabled(true);
+    b.setTranslation({ x: pose.x, y: pose.y, z: pose.z }, false);
+    b.setRotation({ x: pose.qx, y: pose.qy, z: pose.qz, w: pose.qw }, false);
+  }
+  /**
+   * A body the requested tick did not have. `setEnabled(false)` takes the body and its colliders
+   * out of the broad phase, so a query cannot hit it, which is the whole point: a body created
+   * after the tick the shooter was looking at was not on their screen and must not be hittable.
+   */
+  hide(entry) {
+    if (entry.body.isEnabled()) entry.body.setEnabled(false);
+  }
+  destroy(entry) {
+    this.owners.delete(entry.body.handle);
+    this.world.removeRigidBody(entry.body);
+  }
+  build(tick, requested, clamped) {
+    this.cloneStatics();
+    this.world.step();
+    const owners = this.owners;
+    return {
+      tick,
+      requested,
+      clamped,
+      rapier: {
+        world: this.world,
+        who: (collider) => {
+          const parent = collider.parent();
+          return parent ? owners.get(parent.handle) : void 0;
+        }
+      }
+    };
+  }
+  /**
+   * The live world's static geometry, everything `physics.setup` built, copied in once at the
+   * first rewind. It is "as it stands now" rather than "as it stood then": static colliders do not
+   * move, and a room that moves one has told the engine something that is not true.
+   */
+  cloneStatics() {
+    if (this.staticsCloned) return;
+    this.staticsCloned = true;
+    const live = this.physics.world;
+    if (!live) return;
+    live.forEachCollider((c) => {
+      const parent = c.parent();
+      if (parent !== null && (!parent.isFixed() || this.trackedLive.has(parent.handle))) return;
+      const desc = new this.rapier.ColliderDesc(c.shape);
+      desc.setSensor(c.isSensor());
+      const t = c.translation();
+      desc.setTranslation(t.x, t.y, t.z);
+      desc.setRotation(c.rotation());
+      this.world.createCollider(desc);
+    });
+  }
+  free() {
+    this.owners.clear();
+    this.world.free();
+  }
+};
+var MatterScratch = class extends BaseScratch {
+  matter;
+  owners = /* @__PURE__ */ new Map();
+  /** Rebuilt per rewind: the doubles the requested tick actually had, plus the live statics. */
+  visible = [];
+  constructor(physics, depth, tickNow) {
+    super(physics, depth, tickNow);
+    this.matter = physics.matter;
+  }
+  partsOf(body) {
+    return body.parts.length;
+  }
+  clone(collection, id, body, parts) {
+    const M = this.matter;
+    const live = body;
+    const made = live.parts.length > 1 ? M.Body.create({ parts: live.parts.slice(1).map((p) => this.clonePart(p, live.angle)) }) : this.clonePart(live, live.angle);
+    M.Body.setPosition(made, { x: 0, y: 0 });
+    made.angle = 0;
+    for (const p of made.parts) p.angle = 0;
+    this.owners.set(made, { collection, id });
+    return { collection, id, body: made, parts, lastLive: -1 };
+  }
+  /** One part, un-rotated by the parent's angle so the double starts at angle 0. */
+  clonePart(part, parentAngle) {
+    const M = this.matter;
+    const verts = part.vertices.map((v) => ({ x: v.x, y: v.y }));
+    if (parentAngle !== 0) M.Vertices.rotate(verts, -parentAngle, part.position);
+    const made = M.Body.create({});
+    M.Body.setVertices(made, verts);
+    return made;
+  }
+  place(entry, pose) {
+    const M = this.matter;
+    M.Body.setAngle(entry.body, angleOf(pose.qz, pose.qw));
+    M.Body.setPosition(entry.body, { x: pose.x, y: pose.y });
+    this.visible.push(entry.body);
+  }
+  /** Nothing to undo: `visible` is rebuilt per rewind, so a body nobody placed is not in it. */
+  hide() {
+  }
+  destroy(entry) {
+    this.owners.delete(entry.body);
+  }
+  view(entry, tick, requested, clamped) {
+    this.visible.length = 0;
+    return super.view(entry, tick, requested, clamped);
+  }
+  build(tick, requested, clamped) {
+    const M = this.matter;
+    const engine3 = this.physics.matterEngine;
+    if (engine3) {
+      for (const b of M.Composite.allBodies(engine3.world)) {
+        if (b.isStatic) this.visible.push(b);
+      }
+    }
+    const owners = this.owners;
+    return {
+      tick,
+      requested,
+      clamped,
+      matter: {
+        bodies: this.visible,
+        who: (body) => owners.get(body)
+      }
+    };
+  }
+  free() {
+    this.owners.clear();
+    this.visible.length = 0;
+  }
+};
+var RewindState = class {
+  history;
+  scratch;
+  inside = false;
+  constructor(depth) {
+    this.history = new PoseHistory(depth);
+  }
+  free() {
+    this.scratch?.free();
+    this.scratch = void 0;
+  }
+  run(physics, tickNow, requested, fn) {
+    if (this.inside) {
+      throw new Error(
+        "room.rewind: already inside a rewind. The second call would repose the same scratch world under the query still reading it, so it is refused rather than answered wrongly."
+      );
+    }
+    const resolved = this.history.resolve(requested);
+    if (!resolved) {
+      throw new Error(
+        `room.rewind: this room has recorded no ticks yet, so there is no past to answer from. A woken room starts with an empty history and fills it over its next ${this.history.depth} tick(s).`
+      );
+    }
+    this.scratch ??= physics.engineKind === "rapier3d" ? new RapierScratch(physics, this.history.depth, tickNow) : new MatterScratch(physics, this.history.depth, tickNow);
+    const view = this.scratch.view(resolved.entry, resolved.tick, requested, resolved.clamped);
+    this.inside = true;
+    try {
+      return fn(view);
+    } finally {
+      this.inside = false;
+    }
+  }
+};
+
 // src/core/messages.ts
 import { FrameType as FrameType3, decodeMsg, encodeFrame as encodeFrame2, encodeMsg } from "@irtio/protocol";
+import { decodeFields as decodeFields2 } from "@irtio/schema";
 function toRoomTarget(target) {
   switch (target.kind) {
     case "all":
@@ -1985,7 +2474,28 @@ function deliver(core, target, frame, exclude) {
     if (entry.clientId === exclude) continue;
     if (target.kind === "client" && entry.clientId !== target.clientId) continue;
     if (target.kind === "role" && entry.role !== target.role) continue;
-    core.send(entry.clientId, frame);
+    core.send(entry.clientId, frame.slice());
+  }
+}
+function messagesOf(core) {
+  return core.definition.schema.messages ?? [];
+}
+function decodeTyped(core, clientId, index, payload) {
+  const desc = messagesOf(core)[index];
+  if (!desc) {
+    core.stats.messagesDropped++;
+    core.log(
+      "warn",
+      `typed MSG from ${clientId}: no message with index ${index} in this schema; dropped`
+    );
+    return void 0;
+  }
+  try {
+    return { name: desc.name, value: decodeFields2(desc.fields, payload) };
+  } catch (err) {
+    core.stats.messagesDropped++;
+    core.log("warn", `typed MSG ${desc.name} from ${clientId} failed to decode:`, err);
+    return void 0;
   }
 }
 function handleMsg(core, clientId, payload) {
@@ -2001,31 +2511,54 @@ function handleMsg(core, clientId, payload) {
     core.log("warn", `voice MSG from ${clientId} reached room code; dropped (supervisor bug)`);
     return true;
   }
+  if (msg.typed && msg.target.kind === "server") {
+    core.stats.messagesDropped++;
+    core.log("warn", `typed MSG from ${clientId} addressed the server; dropped`);
+    return true;
+  }
   const roomTarget = toRoomTarget(msg.target);
   if (roomTarget === void 0) return true;
+  let typed;
+  if (msg.typed) {
+    typed = decodeTyped(core, clientId, msg.typed.index, msg.payload);
+    if (!typed) return true;
+  }
   const onMessage = core.definition.config.onMessage;
   if (onMessage) {
     const ran = core.tryRun(
       "onMessage",
-      () => onMessage(core.anyState, clientId, roomTarget, msg.payload, core.ctxFor(clientId))
+      () => onMessage(core.anyState, clientId, roomTarget, msg.payload, core.ctxFor(clientId), typed)
     );
     if (!ran.ok || ran.value === false) return true;
   }
   if (msg.target.kind === "server") return true;
   const frame = encodeFrame2(
     FrameType3.MSG,
-    encodeMsg({ target: { kind: "client", clientId }, payload: msg.payload })
+    encodeMsg({
+      target: { kind: "client", clientId },
+      payload: msg.payload,
+      ...msg.typed ? { typed: msg.typed } : {}
+    })
   );
   deliver(core, msg.target, frame, clientId);
   return true;
 }
+function wireTargetOf(target) {
+  return target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
+}
 function sendMessage(core, target, bytes) {
-  const wire = target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
   const frame = encodeFrame2(
     FrameType3.MSG,
     encodeMsg({ target: { kind: "server" }, payload: bytes })
   );
-  deliver(core, wire, frame);
+  deliver(core, wireTargetOf(target), frame);
+}
+function sendTypedMessage(core, index, target, payload) {
+  const frame = encodeFrame2(
+    FrameType3.MSG,
+    encodeMsg({ target: { kind: "server" }, payload, typed: { index } })
+  );
+  deliver(core, wireTargetOf(target), frame);
 }
 
 // src/core/room-api.ts
@@ -2035,7 +2568,7 @@ import {
   busPayloadProblem,
   encodeFrame as encodeFrame3
 } from "@irtio/protocol";
-import { encodeDelta as encodeDelta3, isDirtyEmpty as isDirtyEmpty2 } from "@irtio/schema";
+import { encodeDelta as encodeDelta3, encodeFields as encodeFields2, isDirtyEmpty as isDirtyEmpty2 } from "@irtio/schema";
 function makePhysicsApi(p) {
   return {
     get rapier() {
@@ -2083,7 +2616,7 @@ function makeKv(core) {
 }
 function makeLeaderboard(core) {
   return {
-    submit(board, playerId, score) {
+    submit(board, playerId, score, options) {
       if (!Number.isInteger(score)) {
         return rejectAsEvent(
           core,
@@ -2092,7 +2625,17 @@ function makeLeaderboard(core) {
           )
         );
       }
-      return startHostCall(core, { kind: "lbSubmit", board, playerId, score }, () => void 0);
+      return startHostCall(
+        core,
+        {
+          kind: "lbSubmit",
+          board,
+          playerId,
+          score,
+          ...options?.bucket === void 0 ? {} : { bucket: options.bucket }
+        },
+        () => void 0
+      );
     }
   };
 }
@@ -2183,6 +2726,14 @@ function createRoomApi(core, publicUrl) {
     const sep = publicUrl.includes("?") ? "&" : "?";
     return `${publicUrl}${sep}room=${encodeURIComponent(core.roomId)}`;
   };
+  const messages = {};
+  for (const desc of core.definition.schema.messages ?? []) {
+    messages[desc.name] = {
+      send(target, value) {
+        sendTypedMessage(core, desc.index, target, encodeFields2(desc.fields, value));
+      }
+    };
+  }
   const room = {
     get id() {
       return core.roomId;
@@ -2245,9 +2796,17 @@ function createRoomApi(core, publicUrl) {
       }
       return matterApi ?? (matterApi = makeMatterApi(p));
     },
+    // ---- M6 lane F: rewind ----
+    // D72: one line, and deliberately only one. Everything the rewind does — the buffer, the
+    // clamping, the scratch worlds, the reentrancy refusal — lives in `core/history.ts` behind
+    // `RoomCore.rewind`, so this file stays what it says it is: a facade that reads through.
+    rewind(tick, fn) {
+      return core.rewind(tick, fn);
+    },
     send(target, bytes) {
       sendMessage(core, target, bytes);
     },
+    messages,
     setRole(clientId, role) {
       setRole(core, clientId, role);
       cached = void 0;
@@ -2493,7 +3052,8 @@ var RoomCore = class _RoomCore {
     visibleIdsTotal: 0,
     membershipEnters: 0,
     membershipLeaves: 0,
-    corrections: 0
+    corrections: 0,
+    messagesDropped: 0
   };
   tick = 0;
   stopped = false;
@@ -2515,6 +3075,13 @@ var RoomCore = class _RoomCore {
    * cost the profiler has is behind this `undefined`.
    */
   ledger;
+  /**
+   * D72: the pose history and the rewind scratch, present only when the room's physics config
+   * declares `history`. Every cost this lane has is behind this `undefined`, and it is
+   * deliberately not in the hibernation blob: a woken room starts with an empty buffer and fills
+   * it again over its next `history` ticks.
+   */
+  rewindState;
   seed;
   api;
   internals;
@@ -2558,6 +3125,8 @@ var RoomCore = class _RoomCore {
     this.loop = new Loop(self);
     this.api = createRoomApi(self, options.publicUrl ?? DEFAULT_PUBLIC_URL);
     this.physics = this.buildPhysics(restored);
+    const historyDepth = this.physics ? historyDepthOf(definition.config.physics) : void 0;
+    this.rewindState = historyDepth === void 0 ? void 0 : new RewindState(historyDepth);
     this.subscribeDeclaredChannels();
     if (restored) {
       const onWake = definition.config.onWake;
@@ -2763,6 +3332,35 @@ var RoomCore = class _RoomCore {
   captureTimeline() {
     this.recorder?.capture(this.tick, this.ext, this.plain);
   }
+  // ---- M6 lane F: rewind ----
+  /**
+   * D72: record this tick's body poses, right after `physics.sync()` — the poses the clients are
+   * about to be told about, under the tick number they will be told it under, which is the tick a
+   * client later stamps its `CALL` with.
+   */
+  captureHistory() {
+    const physics = this.physics;
+    if (!physics || !this.rewindState) return;
+    this.rewindState.history.capture(this.tick, physics);
+  }
+  /**
+   * D72: `room.rewind(tick, fn)`. The live world is not touched and nothing is re-simulated; `fn`
+   * queries a scratch world holding every tracked body at its pose at `tick`.
+   */
+  rewind(tick, fn) {
+    const physics = this.physics;
+    if (!physics) {
+      throw new Error(
+        "room.rewind: this room has no physics, so there are no poses to rewind. Add physics: { engine, gravity, bodies, history: <ticks> } to defineRoom(...)"
+      );
+    }
+    if (!this.rewindState) {
+      throw new Error(
+        "room.rewind: this room declares no physics.history, so no poses are kept. Add history: <ticks> to the physics config; it is off by default because it costs heap per tick. See irt.io/docs/concepts/lag-compensation for how deep to make it."
+      );
+    }
+    return this.rewindState.run(physics, () => this.tick, tick, fn);
+  }
   /** Live JSON view of the room for the dev page / supervisor admin API. */
   inspect() {
     return {
@@ -2797,6 +3395,7 @@ var RoomCore = class _RoomCore {
     this.loop.stop();
     rejectAllPending(this.internals, "room stopped");
     rejectAllHostCalls(this.internals, "room stopped");
+    this.rewindState?.free();
     this.physics?.free();
   }
   /**
@@ -2986,6 +3585,9 @@ var RoomCore = class _RoomCore {
       role: entry?.role ?? "",
       name: entry?.name ?? "",
       tick: this.tick,
+      // D72: only an RPC has a stamp, and `rpc.ts` puts it on the ctx it hands the handler. Every
+      // other entry point (join, leave, write, ownership) has no client tick by construction.
+      clientTick: void 0,
       reconnecting,
       room: this.room
     };

package/dist/{chunk-VMCE3LRO.js → chunk-ZNNTF7Y3.js}

@@ -1,7 +1,7 @@
 import {
   parseHibernationBlob,
   writeHibernationBlob
-} from "./chunk-K42HA75G.js";
+} from "./chunk-EXPFVRD4.js";
 
 // src/migrate.ts
 import { PRESENCE_COLLECTION, withBuiltins } from "@irtio/protocol";

package/dist/{contract-BjMsoJIV.d.ts → contract-DwxqjeWP.d.ts}

@@ -136,6 +136,10 @@ type HostCall = {
     readonly board: string;
     readonly playerId: string;
     readonly score: number;
+    /** M6 lane B (D69-c): the cohort of a bucketed board. Absent on every board that declares
+     *  no buckets, which is every board that existed before M6. There is deliberately no
+     *  `period` beside it: rotation is control's clock, never the room's. */
+    readonly bucket?: string;
 }
 /**
  * D59: `room.bus.send(roomId, payload)` — directed, durable, at-least-once delivery to one room
@@ -340,6 +344,13 @@ interface RoomStats {
     membershipEnters: number;
     membershipLeaves: number;
     corrections: number;
+    /**
+     * D70: typed peer messages this room refused to hand to `onMessage` — an index its schema does
+     * not have, or a payload the codec would not decode. Every one of them is a peer sending
+     * something this room's schema does not describe, so a number climbing here means a client on a
+     * stale build or one probing, and never a room bug.
+     */
+    messagesDropped: number;
 }
 /** The surface the worker host and the harness drive. Implemented by `RoomCore`. */
 interface RoomCoreApi<S extends AnySchema = AnySchema> {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { D as DEFAULT_TIMELINE_MAX_RECORDS, a as DEFAULT_TIMELINE_MAX_TICKS, E as EVENT_RING_SIZE, H as HOST_CALL_TIMEOUT_MS, b as HostCall, c as HostCallResult, J as JoinOptions, d as JoinResult, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, f as RoomEvent, g as RoomEventKind, h as RoomFullError, i as RoomHost, j as RoomInspection, k as RoomStats, T as TimelineDump, l as TimelineFrame, m as TimelineRecorder, n as TimelineRecorderOptions, o as inspectState } from './contract-BjMsoJIV.js';
-export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as MatterBodyRecord, b as MatterSection, c as Mulberry32, P as PhysicsEngineTag, d as PhysicsSection, R as RoomCore, e as decodeMatterBodies, f as decodeMatterSectionEnvelope, g as decodePhysicsSection, h as encodeMatterBodies, i as encodeMatterSectionEnvelope, j as encodePhysicsSection, k as initMatter, l as initPhysics, m as loadedMatter, n as loadedPhysics, p as physicsSectionEngine, r as resetMatterForTests, o as resetPhysicsForTests } from './room-CfnEjlcg.js';
+export { D as DEFAULT_TIMELINE_MAX_RECORDS, a as DEFAULT_TIMELINE_MAX_TICKS, E as EVENT_RING_SIZE, H as HOST_CALL_TIMEOUT_MS, b as HostCall, c as HostCallResult, J as JoinOptions, d as JoinResult, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, f as RoomEvent, g as RoomEventKind, h as RoomFullError, i as RoomHost, j as RoomInspection, k as RoomStats, T as TimelineDump, l as TimelineFrame, m as TimelineRecorder, n as TimelineRecorderOptions, o as inspectState } from './contract-DwxqjeWP.js';
+export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as MatterBodyRecord, b as MatterSection, c as Mulberry32, P as PhysicsEngineTag, d as PhysicsSection, R as RoomCore, e as decodeMatterBodies, f as decodeMatterSectionEnvelope, g as decodePhysicsSection, h as encodeMatterBodies, i as encodeMatterSectionEnvelope, j as encodePhysicsSection, k as initMatter, l as initPhysics, m as loadedMatter, n as loadedPhysics, p as physicsSectionEngine, r as resetMatterForTests, o as resetPhysicsForTests } from './room-CoQDczh2.js';
 import { CollectionDesc, AnySchema, PlainState, DirtySet } from '@irtio/schema';
 import '@irtio/protocol';
 import '@irtio/server';

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   fromMigrationState,
   migrateSnapshot,
   toMigrationState
-} from "./chunk-VMCE3LRO.js";
+} from "./chunk-ZNNTF7Y3.js";
 import {
   CRASH_AFTER_THROWS,
   DEFAULT_TIMELINE_MAX_RECORDS,
@@ -42,7 +42,7 @@ import {
   visibleNames,
   visibleTo,
   writeHibernationBlob
-} from "./chunk-K42HA75G.js";
+} from "./chunk-EXPFVRD4.js";
 export {
   CRASH_AFTER_THROWS,
   DEFAULT_TIMELINE_MAX_RECORDS,

package/dist/{room-CfnEjlcg.d.ts → room-CoQDczh2.d.ts}

@@ -1,7 +1,7 @@
 import { AttributeOptions, ProfileSnapshot } from '@irtio/protocol';
 import { DirtySet, AnySchema, PlainState, Tracked, State } from '@irtio/schema';
-import { RoomDefinition, RoomMode, Room, Ctx, MatterModule, MatterEngine, MatterBody, RapierModule, RapierWorld, RapierRigidBody, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
-import { i as RoomHost, k as RoomStats, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, g as RoomEventKind, n as TimelineRecorderOptions, T as TimelineDump, j as RoomInspection, J as JoinOptions, d as JoinResult, c as HostCallResult } from './contract-BjMsoJIV.js';
+import { RoomDefinition, RoomMode, Room, RewindView, Ctx, MatterModule, MatterEngine, MatterBody, RapierModule, RapierWorld, RapierRigidBody, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
+import { i as RoomHost, k as RoomStats, L as LogLevel, R as RoomCoreApi, e as RoomCoreOptions, g as RoomEventKind, n as TimelineRecorderOptions, T as TimelineDump, j as RoomInspection, J as JoinOptions, d as JoinResult, c as HostCallResult } from './contract-DwxqjeWP.js';
 
 /**
  * `room.random()` — mulberry32 over a u32 seed. Deterministic, tiny, and serializable: the
@@ -102,6 +102,14 @@ interface PhysicsApi {
     /** Body → schema, through the tracked proxies. */
     sync(): void;
     bodyFor(collection: string, id: string): unknown;
+    /**
+     * D72: every body this runtime tracks, in the same collection-then-instance order `sync()`
+     * walks. Read-only and allocation-free: the pose history calls it once per tick to copy poses
+     * out, and the rewind scratch calls it to keep its doubles in step with the live world. It is
+     * the only thing outside the engine runtimes that sees a live body other than through
+     * `bodyFor`, and it never hands out the map itself.
+     */
+    eachTrackedBody(fn: (collection: string, id: string, body: unknown) => void): void;
     /** rapier3d only. */
     readonly rapier: unknown;
     /** rapier3d only. */
@@ -151,6 +159,13 @@ interface RoomInternals {
     guard<T>(name: string, fn: () => T): T | undefined;
     /** D41: record this tick on the authoritative timeline. A no-op while the recorder is unarmed. */
     captureTimeline(): void;
+    /**
+     * D72: record this tick's body poses. A no-op — and, more to the point, a call that never
+     * reaches the engine runtime at all — in a room whose config declares no `physics.history`.
+     */
+    captureHistory(): void;
+    /** D72: `room.rewind(tick, fn)`. Throws when the room declares no `physics.history`. */
+    rewind<T>(tick: number, fn: (past: RewindView) => T): T;
     recordEvent(kind: 'join' | 'leave' | 'write' | 'write-rejected' | 'correct' | 'call' | 'reply' | 'msg' | 'alarm' | 'bus' | 'error', clientId?: string, detail?: string): void;
     /** `guard` that also reports whether the handler threw (the tick loop needs this). */
     tryRun<T>(name: string, fn: () => T): GuardResult<T>;
@@ -337,6 +352,11 @@ declare class MatterRuntime {
     free(): void;
     bodyFor(collection: string, id: string): MatterBody | undefined;
     private create;
+    /**
+     * D72: every tracked body, in the order `sync()` walks them. The matter half of the same
+     * read-only accessor `PhysicsRuntime` carries; see its comment for what calls it and when.
+     */
+    eachTrackedBody(fn: (collection: string, id: string, body: MatterBody) => void): void;
     private applyState;
     private applyRecordToBody;
     reconcile(): void;
@@ -458,6 +478,13 @@ declare class PhysicsRuntime {
     /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
     bodyFor(collection: string, id: string): RapierRigidBody | undefined;
     private create;
+    /**
+     * D72: every tracked body, in the order `sync()` walks them (collection order, then instance
+     * order). Read-only: it hands out the live bodies and nothing else, and the map stays private.
+     * The pose history calls this once per tick and the rewind scratch calls it per rewind; a room
+     * that declares no `physics.history` never calls it at all.
+     */
+    eachTrackedBody(fn: (collection: string, id: string, body: RapierRigidBody) => void): void;
     private applyRecordToBody;
     /**
      * Creates bodies for new instances and destroys bodies whose instance is gone. Runs once per
@@ -516,6 +543,13 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
      * cost the profiler has is behind this `undefined`.
      */
     private readonly ledger;
+    /**
+     * D72: the pose history and the rewind scratch, present only when the room's physics config
+     * declares `history`. Every cost this lane has is behind this `undefined`, and it is
+     * deliberately not in the hibernation blob: a woken room starts with an empty buffer and fills
+     * it again over its next `history` ticks.
+     */
+    private readonly rewindState;
     private readonly seed;
     private readonly api;
     private readonly internals;
@@ -581,6 +615,17 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
     recording(): TimelineDump | undefined;
     /** D41: called at the end of every tick (and every event-mode flush). No-op when unarmed. */
     captureTimeline(): void;
+    /**
+     * D72: record this tick's body poses, right after `physics.sync()` — the poses the clients are
+     * about to be told about, under the tick number they will be told it under, which is the tick a
+     * client later stamps its `CALL` with.
+     */
+    captureHistory(): void;
+    /**
+     * D72: `room.rewind(tick, fn)`. The live world is not touched and nothing is re-simulated; `fn`
+     * queries a scratch world holding every tracked body at its pose at `tick`.
+     */
+    rewind<T>(tick: number, fn: (past: RewindView) => T): T;
     /** Live JSON view of the room for the dev page / supervisor admin API. */
     inspect(): RoomInspection;
     guard<T>(name: string, fn: () => T): T | undefined;

package/dist/test/index.d.ts

@@ -1,8 +1,8 @@
-import { R as RoomCore } from '../room-CfnEjlcg.js';
-export { k as initMatter, l as initPhysics } from '../room-CfnEjlcg.js';
+import { R as RoomCore } from '../room-CoQDczh2.js';
+export { k as initMatter, l as initPhysics } from '../room-CoQDczh2.js';
 import { ErrorCodeName, FrameType } from '@irtio/protocol';
 import { NpcConfig, LeaveReason, Room, RoomDefinition } from '@irtio/server';
-import { i as RoomHost, L as LogLevel, R as RoomCoreApi, b as HostCall, c as HostCallResult, k as RoomStats } from '../contract-BjMsoJIV.js';
+import { i as RoomHost, L as LogLevel, R as RoomCoreApi, b as HostCall, c as HostCallResult, k as RoomStats } from '../contract-DwxqjeWP.js';
 import { AnySchema, PlainState, EntityCollection, State } from '@irtio/schema';
 
 /**

package/dist/test/index.js

@@ -4,7 +4,7 @@ import {
   initMatter,
   initPhysics,
   visibleNames
-} from "../chunk-K42HA75G.js";
+} from "../chunk-EXPFVRD4.js";
 
 // src/test/clock.ts
 var FakeClock = class {
@@ -197,7 +197,7 @@ var HarnessHost = class {
         return { ok: true };
       }
       case "lbSubmit": {
-        const key = `${call.board} ${call.playerId}`;
+        const key = call.bucket === void 0 ? `${call.board} ${call.playerId}` : `${call.board} ${call.bucket} ${call.playerId}`;
         const existing = this.scores.get(key);
         if (existing === void 0 || call.score > existing) this.scores.set(key, call.score);
         return { ok: true };

package/dist/worker/index.d.ts

@@ -1,4 +1,4 @@
-import { L as LogLevel, T as TimelineDump, k as RoomStats, b as HostCall, c as HostCallResult, R as RoomCoreApi, i as RoomHost } from '../contract-BjMsoJIV.js';
+import { L as LogLevel, T as TimelineDump, k as RoomStats, b as HostCall, c as HostCallResult, R as RoomCoreApi, i as RoomHost } from '../contract-DwxqjeWP.js';
 import { ErrorCodeName, ProfileSnapshot } from '@irtio/protocol';
 import { NpcConfig, LeaveReason } from '@irtio/server';
 import '@irtio/schema';

package/dist/worker/index.js

@@ -1,6 +1,6 @@
 import {
   migrateSnapshot
-} from "../chunk-VMCE3LRO.js";
+} from "../chunk-ZNNTF7Y3.js";
 import {
   RoomCore,
   RoomFullError,
@@ -8,7 +8,7 @@ import {
   initPhysics,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-K42HA75G.js";
+} from "../chunk-EXPFVRD4.js";
 
 // src/worker/index.ts
 import { getHeapStatistics } from "v8";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/runtime",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
   "publishConfig": {
@@ -30,9 +30,9 @@
   "dependencies": {
     "@dimforge/rapier3d-compat": "0.20.0",
     "matter-js": "0.20.0",
-    "@irtio/protocol": "0.6.0",
-    "@irtio/schema": "0.6.0",
-    "@irtio/server": "0.6.0"
+    "@irtio/protocol": "0.7.0",
+    "@irtio/schema": "0.7.0",
+    "@irtio/server": "0.7.0"
   },
   "devDependencies": {
     "@types/matter-js": "0.20.2"