@irtio/runtime 1.0.0 → 3.1.0

package/dist/{chunk-LT46QFLW.js → chunk-NPRIYYNM.js}

@@ -8,6 +8,15 @@ var RoomFullError = class extends Error {
   maxClients;
   name = "RoomFullError";
 };
+var AdmissionError = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+  }
+  reason;
+  name = "AdmissionError";
+};
+var PHYSICS_STEP_EMA_ALPHA = 0.1;
 
 // src/core/caps.ts
 import {
@@ -212,25 +221,73 @@ function inspectState(schema, plain) {
   return out;
 }
 
-// src/core/rpc.ts
-import {
-  ErrorCode as ErrorCode2,
-  FrameType as FrameType2,
-  OWNERSHIP_ASK,
-  decodeCall,
-  decodeReply,
-  encodeCall,
-  encodeFrame as encodeFrame2,
-  encodeReply,
-  isReservedRpcName,
-  rpcByIdOf,
-  rpcTable
-} from "@irtio/protocol";
+// src/core/rpc-trace.ts
+var RPC_TRACE_SIZE = 200;
+var RPC_TRACE_SUMMARY_MAX = 200;
+function summarize(value) {
+  if (value === void 0) return void 0;
+  let text;
+  try {
+    text = JSON.stringify(value) ?? String(value);
+  } catch {
+    text = String(value);
+  }
+  return text.length > RPC_TRACE_SUMMARY_MAX ? `${text.slice(0, RPC_TRACE_SUMMARY_MAX)}\u2026` : text;
+}
+var RpcTraceRing = class {
+  items = [];
+  lastByClient = /* @__PURE__ */ new Map();
+  seq = 0;
+  push(entry) {
+    const filed = { ...entry, seq: ++this.seq };
+    this.items.push(filed);
+    if (this.items.length > RPC_TRACE_SIZE) this.items.shift();
+    this.lastByClient.set(filed.clientId, {
+      tick: filed.tick,
+      clientTick: filed.clientTick,
+      lag: filed.clientTick === void 0 ? void 0 : filed.tick - filed.clientTick,
+      rpc: filed.rpc,
+      seq: filed.seq
+    });
+    if (this.lastByClient.size > RPC_TRACE_SIZE) {
+      const oldest = this.lastByClient.keys().next();
+      if (!oldest.done && oldest.value !== filed.clientId) this.lastByClient.delete(oldest.value);
+    }
+    return filed;
+  }
+  list() {
+    return this.items;
+  }
+  /** Client id → its last traced call. Survives the entry itself being evicted from the ring. */
+  stampLag() {
+    return this.lastByClient;
+  }
+  /** A client that left takes its stamp row with it; the ring entries stay. */
+  forget(clientId) {
+    this.lastByClient.delete(clientId);
+  }
+  /** JSON shape served by `/__irt/rpc-trace.json` and carried on `inspect`. */
+  dump() {
+    return {
+      entries: [...this.items],
+      stampLag: [...this.lastByClient].map(([clientId, lag]) => ({ clientId, ...lag }))
+    };
+  }
+};
+
+// src/core/views.ts
 import {
-  SERVER_OWNER as SERVER_OWNER2,
-  decodeFields,
-  encodeFields,
-  validateValue
+  collectionDirty,
+  createDirtySet,
+  createFieldMask,
+  encodeDelta,
+  encodeSnapshot as encodeSnapshot2,
+  filterDirty,
+  isDirtyEmpty,
+  markAdd,
+  markPath,
+  markRemove,
+  mergeDirty
 } from "@irtio/schema";
 
 // src/core/internals.ts
@@ -259,128 +316,400 @@ function deepEqual(a, b) {
   return true;
 }
 
-// src/core/ownership.ts
-import { SERVER_OWNER, defaultRecord } from "@irtio/schema";
-var ASK_WINDOW_MS = 5e3;
-var states2 = /* @__PURE__ */ new WeakMap();
-function stateOf2(core) {
-  let s = states2.get(core);
-  if (!s) {
-    s = { holds: /* @__PURE__ */ new Map(), asks: /* @__PURE__ */ new Map(), askUnknownWarned: false };
-    states2.set(core, s);
-  }
-  return s;
-}
-function keyOf(collection, id) {
-  return `${collection} ${id}`;
-}
-function policyCollections(core) {
-  return core.ext.collections.filter(
-    (c) => c.kind === "entity" && c.ownership !== void 0
-  );
+// src/core/spatial.ts
+function cellFor(grid, value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const x = record[grid.x];
+  const y = record[grid.y];
+  if (typeof x !== "number" || typeof y !== "number") return void 0;
+  return { x: Math.floor(x / grid.cell), y: Math.floor(y / grid.cell) };
 }
-function wallNow(core) {
-  return core.wallNow();
+function cellKey(cell) {
+  return `${cell.x},${cell.y}`;
 }
-function holdOn(core, collection, id) {
-  return states2.get(core)?.holds.get(keyOf(collection, id));
+function buildSpatialIndex(plain, desc) {
+  if (!desc.grid || desc.kind !== "entity") {
+    throw new Error(`${desc.name}: cannot build an index without an entity grid`);
+  }
+  const collection = plainEntity(plain, desc.name);
+  const buckets = /* @__PURE__ */ new Map();
+  const order = /* @__PURE__ */ new Map();
+  let n = 0;
+  for (const id of collection.ids()) {
+    order.set(id, n++);
+    const cell = cellFor(desc.grid, collection.get(id));
+    if (!cell) continue;
+    const key = cellKey(cell);
+    let ids = buckets.get(key);
+    if (!ids) {
+      ids = /* @__PURE__ */ new Set();
+      buckets.set(key, ids);
+    }
+    ids.add(id);
+  }
+  return { desc, buckets, collection, order };
 }
-function holdCount(core) {
-  return states2.get(core)?.holds.size ?? 0;
+function querySpatialIndex(index, clientId, role) {
+  const grid = index.desc.grid;
+  if ((grid.wideRoles ?? []).includes(role)) return new Set(index.collection.ids());
+  const anchor = index.collection.get(clientId);
+  const anchorCell = cellFor(grid, anchor);
+  if (!anchor || !anchorCell) return /* @__PURE__ */ new Set();
+  const candidates = /* @__PURE__ */ new Set();
+  for (let x = anchorCell.x - grid.radius; x <= anchorCell.x + grid.radius; x++) {
+    for (let y = anchorCell.y - grid.radius; y <= anchorCell.y + grid.radius; y++) {
+      const ids = index.buckets.get(cellKey({ x, y }));
+      if (ids) for (const id of ids) candidates.add(id);
+    }
+  }
+  candidates.add(clientId);
+  const ranked = [];
+  for (const id of candidates) if (index.order.has(id)) ranked.push(id);
+  ranked.sort((a, b) => index.order.get(a) - index.order.get(b));
+  return new Set(ranked);
 }
-function placeHolds(core, clientId, playerId) {
-  const s = stateOf2(core);
-  const now = wallNow(core);
-  for (const c of policyCollections(core)) {
-    const policy = c.ownership;
-    const coll = plainEntity(core.plain, c.name);
-    for (const id of [...coll.ids()]) {
-      if (coll.ownerOf(id) !== clientId) continue;
-      const hold = {
-        collection: c.name,
-        id,
-        holder: playerId,
-        deadlineMs: now + policy.holdMs,
-        // `then` is the D77 spec's own name for the leave action; a hold is plain data nothing
-        // ever awaits.
-        // biome-ignore lint/suspicious/noThenProperty: see above
-        then: policy.then
-      };
-      if (policy.holdMs <= 0) {
-        act(core, hold);
-        continue;
-      }
-      s.holds.set(keyOf(c.name, id), hold);
+function buildSpatialIndexes(collections, plain) {
+  const indexes = /* @__PURE__ */ new Map();
+  for (const desc of collections) {
+    if (desc.visibility === "spatial-grid" && desc.grid) {
+      indexes.set(desc.name, buildSpatialIndex(plain, desc));
     }
   }
+  return indexes;
 }
-function reclaimHolds(core, clientId, playerId) {
-  const s = states2.get(core);
-  if (!s || s.holds.size === 0) return 0;
-  let reclaimed = 0;
-  for (const [key, hold] of [...s.holds]) {
-    if (hold.holder !== playerId) continue;
-    s.holds.delete(key);
-    const coll = plainEntity(core.plain, hold.collection);
-    if (!coll.has(hold.id)) continue;
-    trackedEntity(core, hold.collection).setOwner(hold.id, clientId);
-    reclaimed++;
+
+// src/core/views.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function infoOf(ext) {
+  let i = cache.get(ext);
+  if (!i) {
+    const scoped = /* @__PURE__ */ new Set();
+    for (const c of ext.collections) {
+      if (c.visibility === "role") for (const r of c.roles ?? []) scoped.add(r);
+    }
+    i = { scoped, names: /* @__PURE__ */ new Map() };
+    cache.set(ext, i);
   }
-  return reclaimed;
+  return i;
 }
-function expireHolds(core) {
-  const s = states2.get(core);
-  if (!s || s.holds.size === 0) return;
-  const now = wallNow(core);
-  for (const [key, hold] of [...s.holds]) {
-    if (hold.deadlineMs > now) continue;
-    s.holds.delete(key);
-    act(core, hold);
+function isVisible(c, role) {
+  if (c.visibility === "server") return false;
+  return c.visibility !== "role" || (c.roles ?? []).includes(role);
+}
+function visibleTo(role) {
+  return (c) => isVisible(c, role);
+}
+function visibleNames(ext, role) {
+  const info = infoOf(ext);
+  let set = info.names.get(role);
+  if (!set) {
+    set = new Set(
+      ext.collections.filter((c) => isVisible(c, role)).map((c) => c.name)
+    );
+    info.names.set(role, set);
   }
+  return set;
 }
-function act(core, hold) {
-  const coll = plainEntity(core.plain, hold.collection);
-  if (!coll.has(hold.id)) return;
-  const tracked = trackedEntity(core, hold.collection);
-  switch (hold.then) {
-    case "remove":
-      tracked.remove(hold.id);
-      return;
-    case "release":
-      tracked.setOwner(hold.id, SERVER_OWNER);
-      return;
-    case "nearest": {
-      const to = nearestConnected(core, hold.collection, hold.id);
-      tracked.setOwner(hold.id, to ?? SERVER_OWNER);
-      return;
-    }
-    case "random": {
-      const candidates = connectedClients(core);
-      if (candidates.length === 0) {
-        tracked.setOwner(hold.id, SERVER_OWNER);
-        return;
-      }
-      const pick = candidates[Math.floor(core.rng.next() * candidates.length)];
-      tracked.setOwner(hold.id, pick);
-      return;
+function viewKeyFor(ext, role) {
+  return infoOf(ext).scoped.has(role) ? role : "all";
+}
+function encodeViewSnapshot(ext, plain, role, tick, memberships) {
+  return encodeSnapshot2(
+    ext,
+    plain,
+    { tick },
+    {
+      collections: visibleTo(role),
+      entities: (c, id) => c.visibility !== "spatial-grid" || (memberships?.get(c.name)?.has(id) ?? false)
     }
-    default:
-      return;
-  }
+  );
 }
-function connectedClients(core) {
-  const out = [];
-  for (const entry of core.clients.values()) if (entry.connected) out.push(entry.clientId);
+function spatialMemberships(ext, plain, clientId, role, indexes = buildSpatialIndexes(ext.collections, plain)) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, index] of indexes) out.set(name, querySpatialIndex(index, clientId, role));
   return out;
 }
-function numberAt(record, field) {
-  if (!record) return void 0;
-  const v = record[field];
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var aoiMemo = /* @__PURE__ */ new WeakMap();
+function inClientView(core, clientId, desc, id) {
+  const role = core.clients.get(clientId)?.role ?? "";
+  if (!isVisible(desc, role)) return false;
+  if (desc.visibility !== "spatial-grid") return true;
+  let memo = aoiMemo.get(core);
+  if (!memo || memo.tick !== core.tick) {
+    memo = { tick: core.tick, byClient: /* @__PURE__ */ new Map() };
+    aoiMemo.set(core, memo);
+  }
+  const key = `${clientId}\0${role}`;
+  let mine = memo.byClient.get(key);
+  if (!mine) {
+    mine = spatialMemberships(core.ext, core.plain, clientId, role);
+    memo.byClient.set(key, mine);
+  }
+  return mine.get(desc.name)?.has(id) ?? false;
 }
-function distanceTo(core, policy, object, clientId) {
-  const position = policy.position;
-  if (!position || !object) return void 0;
+function createVisibilityPolicy(ext, plain, clientId, role) {
+  const memberships = spatialMemberships(ext, plain, clientId, role);
+  return {
+    memberships,
+    maySeeCollection: (desc) => isVisible(desc, role),
+    maySeeEntity: (desc, id) => isVisible(desc, role) && (desc.visibility !== "spatial-grid" || (memberships.get(desc.name)?.has(id) ?? false)),
+    describeSpatial: (desc, ids) => {
+      const grid = desc.grid;
+      if (desc.visibility !== "spatial-grid" || !grid) return void 0;
+      const coll = plainEntity(plain, desc.name);
+      const at = (id) => {
+        const cell = cellFor(grid, coll.get(id));
+        return cell ? `${id}@(${cell.x},${cell.y})` : `${id}@(no position)`;
+      };
+      return `viewer ${at(clientId)}, ${desc.name} ${ids.map(at).join(" ")}, radius ${grid.radius}`;
+    }
+  };
+}
+function sharedViewDirty(ext, dirty, role) {
+  return filterDirty(dirty, (name) => {
+    const desc = ext.collection(name);
+    return desc.visibility !== "spatial-grid" && isVisible(desc, role);
+  });
+}
+function aoiViewDirty(ext, dirty, previous, current) {
+  const out = createDirtySet();
+  for (const desc of ext.collections) {
+    if (desc.visibility !== "spatial-grid") continue;
+    const before = previous.get(desc.name) ?? /* @__PURE__ */ new Set();
+    const now = current.get(desc.name) ?? /* @__PURE__ */ new Set();
+    for (const id of before) if (!now.has(id)) markRemove(out, desc.name, id);
+    for (const id of now) if (!before.has(id)) markAdd(out, desc.name, id);
+    const changed = dirty.get(desc.name);
+    if (!changed) continue;
+    const visibleChanges = createDirtySet();
+    const collection = collectionDirty(visibleChanges, desc.name);
+    for (const id of changed.added) if (now.has(id)) collection.added.add(id);
+    for (const id of changed.removed) if (before.has(id)) collection.removed.add(id);
+    for (const [id, record] of changed.updated) {
+      if (before.has(id) && now.has(id)) collection.updated.set(id, record);
+    }
+    mergeDirty(out, visibleChanges);
+  }
+  return out;
+}
+function membershipSafeDirty(ext, dirty, memberships) {
+  const out = createDirtySet();
+  for (const [name, changed] of dirty) {
+    const desc = ext.collection(name);
+    if (desc.visibility !== "spatial-grid") {
+      out.set(name, changed);
+      continue;
+    }
+    const visible = memberships.get(name) ?? /* @__PURE__ */ new Set();
+    const kept = collectionDirty(out, name);
+    for (const id of changed.added) if (visible.has(id)) kept.added.add(id);
+    for (const id of changed.removed) if (visible.has(id)) kept.removed.add(id);
+    for (const [id, record] of changed.updated) if (visible.has(id)) kept.updated.set(id, record);
+  }
+  return out;
+}
+function encodeViewDelta(ext, plain, dirty, role, tick) {
+  const keep = visibleNames(ext, role);
+  const filtered = filterDirty(dirty, (name) => keep.has(name));
+  if (isDirtyEmpty(filtered)) return null;
+  return encodeDelta(ext, plain, filtered, { tick });
+}
+function stripAdds(plain, dirty, suppress) {
+  if (suppress.size === 0) return dirty;
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, cd] of dirty) {
+    const captured = suppress.get(name);
+    if (!captured || captured.size === 0 || cd.added.size === 0) {
+      out.set(name, cd);
+      continue;
+    }
+    const coll = plainEntity(plain, name);
+    let added = cd.added;
+    for (const id of captured.keys()) {
+      if (!added.has(id)) continue;
+      const c = captured.get(id);
+      if (coll.ownerOf(id) !== c.owner || !deepEqual(coll.get(id), c.value)) continue;
+      if (added === cd.added) added = new Set(cd.added);
+      added.delete(id);
+    }
+    out.set(name, added === cd.added ? cd : { added, removed: cd.removed, updated: cd.updated });
+  }
+  return out;
+}
+function catchUpDirty(ext, plain, fromRole, toRole) {
+  const dirty = createDirtySet();
+  for (const c of ext.collections) {
+    const was = isVisible(c, fromRole);
+    const now = isVisible(c, toRole);
+    if (was === now) continue;
+    if (c.kind === "singleton") {
+      if (!now) continue;
+      const mask = createFieldMask();
+      for (const f of c.fields) markPath(mask, [f.index]);
+      collectionDirty(dirty, c.name).updated.set("", { mask, owner: false });
+      continue;
+    }
+    const coll = plainEntity(plain, c.name);
+    for (const id of [...coll.ids()]) {
+      if (now) markAdd(dirty, c.name, id);
+      else markRemove(dirty, c.name, id);
+    }
+  }
+  return dirty;
+}
+
+// src/core/rpc.ts
+import {
+  ErrorCode as ErrorCode2,
+  FrameType as FrameType2,
+  OWNERSHIP_ASK,
+  clampErrorMessage,
+  decodeCall,
+  decodeReply,
+  encodeCall,
+  encodeFrame as encodeFrame2,
+  encodeReply,
+  isReservedRpcName,
+  rpcByIdOf,
+  rpcTable
+} from "@irtio/protocol";
+import {
+  SERVER_OWNER as SERVER_OWNER2,
+  decodeFields,
+  encodeFields,
+  validateValue
+} from "@irtio/schema";
+import { DenyError } from "@irtio/server";
+
+// src/core/ownership.ts
+import { SERVER_OWNER, defaultRecord } from "@irtio/schema";
+var HOLD_ACTIONS = /* @__PURE__ */ new Set([
+  "release",
+  "nearest",
+  "random",
+  "remove"
+]);
+var ASK_WINDOW_MS = 5e3;
+var states2 = /* @__PURE__ */ new WeakMap();
+function stateOf2(core) {
+  let s = states2.get(core);
+  if (!s) {
+    s = { holds: /* @__PURE__ */ new Map(), asks: /* @__PURE__ */ new Map(), askUnknownWarned: false };
+    states2.set(core, s);
+  }
+  return s;
+}
+function keyOf(collection, id) {
+  return `${collection} ${id}`;
+}
+function policyCollections(core) {
+  return core.ext.collections.filter(
+    (c) => c.kind === "entity" && c.ownership !== void 0
+  );
+}
+function wallNow(core) {
+  return core.wallNow();
+}
+function holdOn(core, collection, id) {
+  return states2.get(core)?.holds.get(keyOf(collection, id));
+}
+function holdCount(core) {
+  return states2.get(core)?.holds.size ?? 0;
+}
+function placeHolds(core, clientId, playerId) {
+  const s = stateOf2(core);
+  const now = wallNow(core);
+  for (const c of policyCollections(core)) {
+    const policy = c.ownership;
+    const coll = plainEntity(core.plain, c.name);
+    for (const id of [...coll.ids()]) {
+      if (coll.ownerOf(id) !== clientId) continue;
+      const hold = {
+        collection: c.name,
+        id,
+        holder: playerId,
+        deadlineMs: now + policy.holdMs,
+        // `then` is the D77 spec's own name for the leave action; a hold is plain data nothing
+        // ever awaits.
+        // biome-ignore lint/suspicious/noThenProperty: see above
+        then: policy.then
+      };
+      if (policy.holdMs <= 0) {
+        act(core, hold);
+        continue;
+      }
+      s.holds.set(keyOf(c.name, id), hold);
+    }
+  }
+}
+function reclaimHolds(core, clientId, playerId) {
+  const s = states2.get(core);
+  if (!s || s.holds.size === 0) return 0;
+  let reclaimed = 0;
+  for (const [key, hold] of [...s.holds]) {
+    if (hold.holder !== playerId) continue;
+    s.holds.delete(key);
+    const coll = plainEntity(core.plain, hold.collection);
+    if (!coll.has(hold.id)) continue;
+    trackedEntity(core, hold.collection).setOwner(hold.id, clientId);
+    reclaimed++;
+  }
+  return reclaimed;
+}
+function expireHolds(core) {
+  const s = states2.get(core);
+  if (!s || s.holds.size === 0) return;
+  const now = wallNow(core);
+  for (const [key, hold] of [...s.holds]) {
+    if (hold.deadlineMs > now) continue;
+    s.holds.delete(key);
+    act(core, hold);
+  }
+}
+function act(core, hold) {
+  const coll = plainEntity(core.plain, hold.collection);
+  if (!coll.has(hold.id)) return;
+  const tracked = trackedEntity(core, hold.collection);
+  switch (hold.then) {
+    case "remove":
+      tracked.remove(hold.id);
+      return;
+    case "release":
+      tracked.setOwner(hold.id, SERVER_OWNER);
+      return;
+    case "nearest": {
+      const to = nearestConnected(core, hold.collection, hold.id);
+      tracked.setOwner(hold.id, to ?? SERVER_OWNER);
+      return;
+    }
+    case "random": {
+      const candidates = connectedClients(core);
+      if (candidates.length === 0) {
+        tracked.setOwner(hold.id, SERVER_OWNER);
+        return;
+      }
+      const pick = candidates[Math.floor(core.rng.next() * candidates.length)];
+      tracked.setOwner(hold.id, pick);
+      return;
+    }
+    default:
+      return;
+  }
+}
+function connectedClients(core) {
+  const out = [];
+  for (const entry of core.clients.values()) if (entry.connected) out.push(entry.clientId);
+  return out;
+}
+function numberAt(record, field) {
+  if (!record) return void 0;
+  const v = record[field];
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function distanceTo(core, policy, object, clientId) {
+  const position = policy.position;
+  if (!position || !object) return void 0;
   const players = plainEntity(core.plain, position.players);
   const player = players.get(clientId);
   const px = numberAt(player, position.x);
@@ -511,11 +840,20 @@ function restoreHolds(core, bytes) {
     const parsed = JSON.parse(new TextDecoder().decode(bytes));
     for (const h of parsed) {
       if (typeof h?.collection !== "string" || typeof h.id !== "string" || typeof h.holder !== "string" || typeof h.deadlineMs !== "number") {
+        core.log("warn", "irtio: dropping a hold that is not a hold record:", h);
         continue;
       }
-      s.holds.set(keyOf(h.collection, h.id), h);
-    }
-  } catch (err) {
+      if (!HOLD_ACTIONS.has(h.then)) {
+        core.log(
+          "warn",
+          `irtio: dropping the hold on ${h.collection}.${h.id} \u2014 unknown leave action`,
+          h.then
+        );
+        continue;
+      }
+      s.holds.set(keyOf(h.collection, h.id), h);
+    }
+  } catch (err) {
     core.log("warn", "hold deadlines did not decode; the room wakes holding nothing:", err);
   }
 }
@@ -542,7 +880,11 @@ function errorText(code, detail) {
   return detail === void 0 ? code : `${code}: ${detail}`;
 }
 function sendReply(core, clientId, reqId, result, error) {
-  const payload = result === null ? encodeReply({ reqId, ok: false, error: error ?? errorText("E_INTERNAL") }) : encodeReply({ reqId, ok: true, result });
+  const payload = result === null ? encodeReply({
+    reqId,
+    ok: false,
+    error: clampErrorMessage(error ?? errorText("E_INTERNAL"))
+  }) : encodeReply({ reqId, ok: true, result });
   core.send(clientId, encodeFrame2(FrameType2.REPLY, payload));
 }
 function handleCall(core, clientId, payload) {
@@ -581,21 +923,46 @@ function handleCall(core, clientId, payload) {
     );
     return true;
   }
+  const armed = core.rpcTraceArmed;
+  const traceEarly = armed ? (detail) => {
+    core.recordRpc({
+      clientId,
+      rpc: desc.name,
+      tick: core.tick,
+      outcome: "error",
+      result: detail
+    });
+  } : void 0;
   let params;
   try {
     params = decodeFields(desc.params, call.params);
   } catch (err) {
+    traceEarly?.(errorText("E_RPC_BAD_PARAMS", String(err)));
     sendReply(core, clientId, call.reqId, null, errorText("E_RPC_BAD_PARAMS", String(err)));
     return true;
   }
   for (const f of desc.params) {
     const problem = validateValue(f.type, params[f.name], f.name);
     if (problem) {
+      traceEarly?.(errorText("E_RPC_BAD_PARAMS", problem));
       sendReply(core, clientId, call.reqId, null, errorText("E_RPC_BAD_PARAMS", problem));
       return true;
     }
   }
   const ctx = { ...core.ctxFor(clientId), clientTick: call.clientTick || void 0 };
+  const trace = armed ? (outcome, result2) => {
+    core.recordRpc({
+      clientId,
+      rpc: desc.name,
+      tick: ctx.tick,
+      ...ctx.clientTick !== void 0 ? { clientTick: ctx.clientTick } : {},
+      outcome,
+      ...(() => {
+        const summary = summarize(result2);
+        return summary === void 0 ? {} : { result: summary };
+      })()
+    });
+  } : void 0;
   let result;
   if (desc.name === REQUEST_OWNERSHIP) {
     result = runRequestOwnership(core, clientId, ctx, params, call.reqId, desc);
@@ -603,27 +970,38 @@ function handleCall(core, clientId, payload) {
   } else {
     const impl = core.definition.config.rpc?.[desc.name];
     if (!impl) {
+      trace?.("error", "E_RPC_UNKNOWN");
       sendReply(core, clientId, call.reqId, null, errorText("E_RPC_UNKNOWN", desc.name));
       return true;
     }
     try {
       result = impl(core.anyState, params, ctx);
     } catch (err) {
+      if (err instanceof DenyError) {
+        trace?.(`deny:${err.reason}`);
+        sendReply(core, clientId, call.reqId, null, err.message);
+        return true;
+      }
       core.stats.handlerErrors++;
       core.log("error", `rpc.${desc.name} threw:`, err);
-      sendReply(core, clientId, call.reqId, null, err instanceof Error ? err.message : String(err));
+      trace?.("error", err instanceof Error ? err.message : String(err));
+      sendReply(core, clientId, call.reqId, null, errorText("E_INTERNAL", `rpc ${desc.name}`));
       return true;
     }
   }
   if (!desc.returns) {
+    trace?.("ok");
     sendReply(core, clientId, call.reqId, new Uint8Array(0));
     return true;
   }
   try {
-    sendReply(core, clientId, call.reqId, encodeFields(desc.returns, result ?? {}));
+    const bytes = encodeFields(desc.returns, result ?? {});
+    trace?.("ok", result ?? {});
+    sendReply(core, clientId, call.reqId, bytes);
   } catch (err) {
     core.log("error", `rpc.${desc.name} returned a value that failed to encode:`, err);
     core.stats.handlerErrors++;
+    trace?.("error", `E_INTERNAL: ${String(err)}`);
     sendReply(core, clientId, call.reqId, null, errorText("E_INTERNAL", `rpc ${desc.name}`));
   }
   return true;
@@ -633,8 +1011,11 @@ function runRequestOwnership(core, clientId, ctx, params, reqId, desc) {
   const id = String(params.id ?? "");
   const c = collectionDescOf(core.ext, name);
   if (!c || c.kind !== "entity" || c.serverOwned) return refused("gone");
+  if (!isVisible(c, core.clients.get(clientId)?.role ?? "")) return refused("gone");
   const plain = plainEntity(core.plain, name);
   if (!plain.has(id)) return refused("gone");
+  if (plain.ownerOf(id) !== clientId && !inClientView(core, clientId, c, id))
+    return refused("gone");
   const handler = core.definition.config.onOwnershipRequest;
   const tracked = trackedEntity(core, name);
   if (!handler && c.ownership) {
@@ -891,6 +1272,10 @@ function rejectAllPending(core, reason) {
 import { FrameType as FrameType3 } from "@irtio/protocol";
 
 // src/core/host-calls.ts
+import { clampErrorMessage as clampErrorMessage2 } from "@irtio/protocol";
+function refusal(text) {
+  return new Error(clampErrorMessage2(text));
+}
 var states4 = /* @__PURE__ */ new WeakMap();
 function stateOf4(core) {
   let s = states4.get(core);
@@ -902,6 +1287,7 @@ function stateOf4(core) {
 }
 function rejectAsEvent(core, err) {
   core.scheduleContinuationFlush();
+  err.message = clampErrorMessage2(err.message);
   return Promise.reject(err);
 }
 function resolveAsEvent(core, value) {
@@ -910,7 +1296,7 @@ function resolveAsEvent(core, value) {
 }
 function startHostCall(core, call, map) {
   if (core.stopped) {
-    return rejectAsEvent(core, new Error(`room.${call.kind}: the room is stopped`));
+    return rejectAsEvent(core, refusal(`room.${call.kind}: the room is stopped`));
   }
   return new Promise((resolve, reject2) => {
     const s = stateOf4(core);
@@ -928,7 +1314,8 @@ function startHostCall(core, call, map) {
     } catch (err) {
       s.pending.delete(reqId);
       core.scheduleContinuationFlush();
-      reject2(err instanceof Error ? err : new Error(String(err)));
+      if (err instanceof Error) err.message = clampErrorMessage2(err.message);
+      reject2(err instanceof Error ? err : refusal(String(err)));
       return;
     }
     if (core.mode === "event") {
@@ -942,7 +1329,7 @@ function completeHostCall(core, reqId, result) {
   if (!pending) return false;
   s.pending.delete(reqId);
   if (result.ok) pending.resolve(pending.map(result.value));
-  else pending.reject(new Error(`${result.code}: ${result.message}`));
+  else pending.reject(refusal(`${result.code}: ${result.message}`));
   return true;
 }
 function checkHostCallTimeouts(core) {
@@ -952,14 +1339,14 @@ function checkHostCallTimeouts(core) {
   for (const [reqId, p] of [...s.pending]) {
     if (p.deadline > now) continue;
     s.pending.delete(reqId);
-    p.reject(new Error(`E_HOST_TIMEOUT: room.${p.kind} timed out after ${HOST_CALL_TIMEOUT_MS}ms`));
+    p.reject(refusal(`E_HOST_TIMEOUT: room.${p.kind} timed out after ${HOST_CALL_TIMEOUT_MS}ms`));
   }
 }
 function rejectAllHostCalls(core, reason) {
   const s = stateOf4(core);
   for (const [reqId, p] of [...s.pending]) {
     s.pending.delete(reqId);
-    p.reject(new Error(reason));
+    p.reject(refusal(reason));
   }
 }
 
@@ -968,7 +1355,8 @@ import {
   SERVER_OWNER as SERVER_OWNER3,
   cloneValue,
   decodeDelta,
-  encodeDelta,
+  defaultValue,
+  encodeDelta as encodeDelta2,
   markField,
   normalizeRecord
 } from "@irtio/schema";
@@ -1038,6 +1426,9 @@ function applyChanged(fields, target, prev, next) {
 }
 function correctLeaves(core, clientId, collection, id, leaves) {
   if (leaves.length === 0) return;
+  const entry = core.clients.get(clientId);
+  const desc = collectionDescOf(core.ext, collection);
+  if (desc && !isVisible(desc, entry?.role ?? "")) return;
   const dirty = core.correctionFor(clientId);
   if (!dirty) return;
   for (const leaf of leaves) markField(dirty, collection, id, leaf.path);
@@ -1077,7 +1468,33 @@ function reject(core, clientId, c, op, reason) {
   if (!recordOf(core.plain, c, op.id)) return;
   correctLeaves(core, clientId, c.name, op.id, leafPaths(fieldList(c), op.mask));
 }
+function ownerMayNotWrite(c, field) {
+  const simulated = c.physics;
+  if (simulated) {
+    if (simulated.intents.includes(field)) return void 0;
+    return simulated.bodyFields.has(field) ? `${field} (simulated)` : `${field} (not an intent)`;
+  }
+  if (c.serverFields?.has(field)) return `${field} (serverField)`;
+  return void 0;
+}
 function applyOp(core, clientId, c, op) {
+  const senderRole = core.clients.get(clientId)?.role ?? "";
+  if (!isVisible(c, senderRole)) {
+    core.recordEvent("write-rejected", clientId, `${c.name}: not visible to role`);
+    core.log(
+      "warn",
+      `WRITE rejected (collection not visible to role ${JSON.stringify(senderRole)}) from ${clientId} on ${c.name}`
+    );
+    return;
+  }
+  if (c.kind === "entity" && c.visibility === "spatial-grid") {
+    const coll = plainEntity(core.plain, c.name);
+    if (coll.has(op.id) && coll.ownerOf(op.id) !== clientId && !inClientView(core, clientId, c, op.id)) {
+      core.recordEvent("write-rejected", clientId, `${c.name}: ${op.id} is not in view`);
+      core.log("warn", `WRITE rejected (id not in view) from ${clientId} on ${c.name}`);
+      return;
+    }
+  }
   if (op.op === "add" || op.op === "remove") {
     if (c.kind !== "entity" || c.serverOwned || !c.clientCreate) {
       reject(
@@ -1119,16 +1536,14 @@ function applyOp(core, clientId, c, op) {
   const next = cloneValue(current);
   applyMaskedPatch(fields, next, op.patch, op.mask);
   const requested = cloneValue(next);
-  const simulated = c.physics;
-  if (simulated) {
+  if (c.physics || c.serverFields) {
     const refused2 = [];
     for (const leaf of leafPaths(fields, op.mask)) {
       const field = leaf.names[0];
-      if (simulated.intents.includes(field)) continue;
+      const why = ownerMayNotWrite(c, field);
+      if (why === void 0) continue;
       next[field] = cloneValue(prev[field]);
-      refused2.push(
-        simulated.bodyFields.has(field) ? `${field} (simulated)` : `${field} (not an intent)`
-      );
+      refused2.push(why);
     }
     if (refused2.length > 0) {
       core.recordEvent("write-rejected", clientId, `${c.name}: ${refused2.join(", ")}`);
@@ -1184,8 +1599,32 @@ function applyAdd(core, clientId, c, op) {
     return;
   }
   if (!admitGrowth(core, clientId, maxRecordBytes(c))) return;
+  let value = op.value;
+  if (c.serverFields) {
+    const stripped = [];
+    const copy = { ...value };
+    for (const f of c.fields) {
+      if (!c.serverFields.has(f.name)) continue;
+      const reset = defaultValue(f.type);
+      if (deepEqual(copy[f.name], reset)) continue;
+      copy[f.name] = reset;
+      stripped.push(f.name);
+    }
+    if (stripped.length > 0) {
+      core.recordEvent(
+        "write-rejected",
+        clientId,
+        `${c.name}: ${stripped.join(", ")} (serverField)`
+      );
+      core.log(
+        "warn",
+        `add to ${c.name}.${op.id} from ${clientId} set server-only fields; reset to their defaults: ${stripped.join(", ")}`
+      );
+    }
+    value = copy;
+  }
   try {
-    trackedEntity(core, c.name).add(op.id, op.value, { owner: clientId });
+    trackedEntity(core, c.name).add(op.id, value, { owner: clientId });
   } catch (err) {
     reject(core, clientId, c, op, `add rejected: ${String(err)}`);
     return;
@@ -1245,6 +1684,7 @@ function serverWinsCorrections(core, dirty) {
       if (owner === void 0 || owner === SERVER_OWNER3) continue;
       const entry = core.clients.get(owner);
       if (!entry || !entry.connected) continue;
+      if (!isVisible(c, entry.role)) continue;
       const value = coll.get(id);
       if (value === void 0) continue;
       const accepted = entry.accepted.get(`${name}\0${id}`);
@@ -1268,12 +1708,13 @@ function encodeCorrection(core, dirty) {
     }
   }
   if (empty) return null;
-  return encodeDelta(core.ext, core.plain, dirty, { tick: core.tick });
+  return encodeDelta2(core.ext, core.plain, dirty, { tick: core.tick });
 }
 
 // src/core/loop.ts
 var MAX_CATCHUP = 5;
 var CRASH_AFTER_THROWS = 3;
+var TIMER_SLEEP_GUARD_MS = 250;
 var Loop = class {
   constructor(core) {
     this.core = core;
@@ -1292,6 +1733,14 @@ var Loop = class {
   consecutiveThrows = 0;
   lastActivity = 0;
   slept = false;
+  /**
+   * Whether this idle stretch has already spent its one deferral for a nearly-due room timer.
+   *
+   * Once, deliberately. A `setInterval(100)` in an otherwise silent room must not be able to pin
+   * the room resident forever — pending timers are explicitly *not* a reason to stay awake, the
+   * supervisor wakes the room at the due time instead. Reset by real activity.
+   */
+  timerDeferred = false;
   get intervalMs() {
     return 1e3 / this.core.definition.config.tickRate;
   }
@@ -1336,11 +1785,40 @@ var Loop = class {
       this.applyFrame(f);
     }
   }
-  /** Applies one queued/immediate frame. Returns `false` on a malformed payload. */
+  /**
+   * Applies one queued/immediate frame. Returns `false` on a malformed payload.
+   *
+   * The `try` is containment, not error handling, and it is deliberately *here* rather than around
+   * the whole tick. Room code never throws through this line — `applyWrite` runs its validators
+   * under `core.tryRun`, and `handleCall` wraps the RPC handler in a `try` of its own that does
+   * the same bookkeeping by hand (`DenyError` answered as a refusal, anything else counted on
+   * `core.stats.handlerErrors` and answered `E_INTERNAL`) — so a throw that reaches this frame is by
+   * definition ours: a decode or an apply step that met a value it did not expect. Before this,
+   * such a throw went out through `runTick`/`applyEvent` uncaught and took the worker down, which
+   * meant one crafted frame could end a room (bugs.md: the non-finite `f32`, fixed at the decode
+   * in `@irtio/schema`, reached `normalizeValue` from outside `applyWrite`'s own try).
+   *
+   * Containing it at the frame keeps the blast radius the size of the mistake: the frame is
+   * *this* client's, so it is refused as malformed and the caller kicks that connection, and the
+   * room — every other player in it — keeps ticking. Wrapping the tick instead would have swallowed
+   * the frame's identity along with the throw and left the room running against half-applied
+   * state with nobody to attribute it to.
+   *
+   * Nothing about how a *handler* throw is treated changes: those never arrive here.
+   */
   applyFrame(f) {
-    if (f.type === FrameType3.WRITE) return applyWrite(this.core, f.clientId, f.payload).ok;
-    if (f.type === FrameType3.CALL) return handleCall(this.core, f.clientId, f.payload);
-    return true;
+    try {
+      if (f.type === FrameType3.WRITE) return applyWrite(this.core, f.clientId, f.payload).ok;
+      if (f.type === FrameType3.CALL) return handleCall(this.core, f.clientId, f.payload);
+      return true;
+    } catch (err) {
+      this.core.log(
+        "error",
+        `frame type ${f.type} from ${f.clientId} threw while being applied; refusing it:`,
+        err
+      );
+      return false;
+    }
   }
   // -------------------------------------------------------------------------
   // Tick mode
@@ -1401,7 +1879,12 @@ var Loop = class {
     if (physics) {
       const ran = this.core.tryRun("physics", () => {
         physics.reconcile();
+        const stepStarted = performance.now();
         physics.step();
+        const stepMs = performance.now() - stepStarted;
+        const s = this.core.stats;
+        s.physicsStepMs = stepMs;
+        s.physicsStepMsAvg = s.ticks === 0 ? stepMs : s.physicsStepMsAvg + PHYSICS_STEP_EMA_ALPHA * (stepMs - s.physicsStepMsAvg);
         physics.sync();
         this.core.captureHistory();
       });
@@ -1450,6 +1933,7 @@ var Loop = class {
   noteActivity() {
     this.lastActivity = this.core.host.now();
     this.slept = false;
+    this.timerDeferred = false;
     if (this.running && this.idleHandle === void 0) {
       this.armIdle(this.core.definition.config.idleMs);
     }
@@ -1469,6 +1953,12 @@ var Loop = class {
     }
     const waited = this.core.host.now() - this.lastActivity;
     if (waited >= idleMs) {
+      const earliest = this.earliestTimerAt();
+      if (!this.timerDeferred && earliest !== void 0 && earliest - this.core.host.now() <= TIMER_SLEEP_GUARD_MS) {
+        this.timerDeferred = true;
+        this.armIdle(TIMER_SLEEP_GUARD_MS);
+        return;
+      }
       if (!this.slept) {
         this.slept = true;
         this.core.host.sleep();
@@ -1490,6 +1980,7 @@ var Loop = class {
       periodTicks,
       periodMs: Math.max(0, ms),
       dueTick: this.core.tick + periodTicks,
+      dueAtMs: this.core.host.now() + Math.max(0, ms),
       handle: void 0
     };
     this.timers.set(id, timer);
@@ -1501,8 +1992,10 @@ var Loop = class {
       timer.handle = void 0;
       if (this.core.stopped) return;
       if (!this.timers.has(timer.id)) return;
-      if (timer.repeat) this.armHostTimer(timer);
-      else this.timers.delete(timer.id);
+      if (timer.repeat) {
+        timer.dueAtMs = this.core.host.now() + timer.periodMs;
+        this.armHostTimer(timer);
+      } else this.timers.delete(timer.id);
       this.core.tick++;
       this.core.guard("room timer", timer.fn);
       this.core.flush();
@@ -1514,6 +2007,29 @@ var Loop = class {
     this.timers.delete(handle);
     if (t.handle !== void 0) this.core.host.clearTimeout(t.handle);
   }
+  /**
+   * The earliest pending room timer's due time on `host.now()`'s clock, or `undefined` when the
+   * room has none armed.
+   *
+   * Read at `serialize()`, before `clearAllTimers()` drops the callbacks. The callbacks are
+   * closures and cannot be persisted — but the *time* can, and handing it to the supervisor is
+   * what turns "your timer is gone" into "your room is awake again by then", which is a contract
+   * room code can actually catch up against in `onWake`.
+   *
+   * Event mode reads the absolute due time stamped on the record at arm time; tick mode derives
+   * it from `dueTick`, because there a timer fires on the first tick at or after its deadline and
+   * the tick counter is the clock that decides it.
+   */
+  earliestTimerAt() {
+    if (this.timers.size === 0) return void 0;
+    const now = this.core.host.now();
+    let best;
+    for (const t of this.timers.values()) {
+      const at = this.core.mode === "event" ? t.dueAtMs : now + Math.max(0, t.dueTick - this.core.tick) * this.intervalMs;
+      if (best === void 0 || at < best) best = at;
+    }
+    return best;
+  }
   clearAllTimers() {
     for (const t of this.timers.values()) {
       if (t.handle !== void 0) this.core.host.clearTimeout(t.handle);
@@ -1536,139 +2052,373 @@ function hasHumanClients(core) {
   return false;
 }
 
-// src/core/matter.ts
-import {
-  ByteReader,
-  ByteWriter,
-  applyChannel2d,
-  channelOf2d
-} from "@irtio/schema";
+// src/core/physics.ts
+import { ByteReader, ByteWriter } from "@irtio/schema";
 var engine;
 var loading;
-async function initMatter() {
+async function initPhysics() {
   if (engine) return engine;
   loading ??= (async () => {
-    const mod = await import("matter-js");
+    const mod = await import("@dimforge/rapier3d-compat");
     const ns = mod.default ?? mod;
+    await ns.init();
     engine = ns;
     return ns;
   })();
   return loading;
 }
-function loadedMatter() {
+function loadedPhysics() {
   return engine;
 }
-function resetMatterForTests() {
+function resetPhysicsForTests() {
   engine = void 0;
   loading = void 0;
+  rapierStepped = false;
+  firstStepWaiters.length = 0;
 }
-function encodeMatterBodies(section) {
-  const w = new ByteWriter(section.bodies.length * 72 + 8);
+var rapierStepped = false;
+var firstStepWaiters = [];
+function rapierHasStepped() {
+  return rapierStepped;
+}
+function onFirstRapierStep(cb) {
+  if (rapierStepped) {
+    cb();
+    return;
+  }
+  firstStepWaiters.push(cb);
+}
+function noteRapierStep() {
+  rapierStepped = true;
+  const waiters = firstStepWaiters.splice(0, firstStepWaiters.length);
+  for (const cb of waiters) {
+    try {
+      cb();
+    } catch {
+    }
+  }
+}
+function encodePhysicsSection(section) {
+  const skipped = section.skipped ?? [];
+  const unsynced = section.unsynced ?? [];
+  const w = new ByteWriter(
+    section.world.length + (section.bodies.length + skipped.length + unsynced.length) * 24 + 16
+  );
+  w.blob(section.world);
   w.varint(section.bodies.length);
-  for (const b of section.bodies) {
-    w.str(b.collection);
-    w.str(b.id);
-    w.f64(b.x);
-    w.f64(b.y);
-    w.f64(b.angle);
-    w.f64(b.vx);
-    w.f64(b.vy);
-    w.f64(b.angularVelocity);
-    w.u8(b.sleeping ? 1 : 0);
+  for (const [name, id, handle] of section.bodies) {
+    w.str(name);
+    w.str(id);
+    w.f64(handle);
+  }
+  if (skipped.length > 0 || unsynced.length > 0) {
+    w.varint(skipped.length);
+    for (const key of skipped) w.str(key);
+    w.varint(unsynced.length);
+    for (const [key, handle] of unsynced) {
+      w.str(key);
+      w.f64(handle);
+    }
   }
   return w.finish();
 }
-function decodeMatterBodies(bytes) {
+var MATTER_TAG = 1;
+var RAPIER2D_TAG = 2;
+function physicsSectionEngine(bytes) {
+  const r = new ByteReader(bytes);
+  if (r.varint() !== 0) return "rapier3d";
+  const tag = r.u8();
+  if (tag === MATTER_TAG) return "matter2d";
+  if (tag === RAPIER2D_TAG) return "rapier2d";
+  return "rapier3d";
+}
+function encodeRapier2dSectionEnvelope(payload) {
+  const w = new ByteWriter(payload.length + 8);
+  w.varint(0);
+  w.u8(RAPIER2D_TAG);
+  w.bytes(payload);
+  return w.finish();
+}
+function decodeRapier2dSectionEnvelope(bytes) {
+  const r = new ByteReader(bytes);
+  if (r.varint() !== 0 || r.u8() !== RAPIER2D_TAG) {
+    throw new Error("irtio: this physics section was not written by rapier2d");
+  }
+  return r.rest();
+}
+function encodeMatterSectionEnvelope(payload) {
+  const w = new ByteWriter(payload.length + 8);
+  w.varint(0);
+  w.u8(MATTER_TAG);
+  w.bytes(payload);
+  return w.finish();
+}
+function decodeMatterSectionEnvelope(bytes) {
+  const r = new ByteReader(bytes);
+  if (r.varint() !== 0 || r.u8() !== MATTER_TAG) {
+    throw new Error("irtio: this physics section was not written by matter2d");
+  }
+  return r.rest();
+}
+function decodePhysicsSection(bytes) {
   const r = new ByteReader(bytes);
+  const world = r.blob().slice();
   const count = r.varint();
   const bodies = [];
-  for (let i = 0; i < count; i++) {
-    bodies.push({
-      collection: r.str(),
-      id: r.str(),
-      x: r.f64(),
-      y: r.f64(),
-      angle: r.f64(),
-      vx: r.f64(),
-      vy: r.f64(),
-      angularVelocity: r.f64(),
-      sleeping: r.u8() === 1
-    });
+  for (let i = 0; i < count; i++) bodies.push([r.str(), r.str(), r.f64()]);
+  if (r.eof) return { world, bodies };
+  const skippedCount = r.varint();
+  const skipped = [];
+  for (let i = 0; i < skippedCount; i++) skipped.push(r.str());
+  const unsynced = [];
+  if (!r.eof) {
+    const unsyncedCount = r.varint();
+    for (let i = 0; i < unsyncedCount; i++) unsynced.push([r.str(), r.f64()]);
   }
-  return { bodies };
+  return {
+    world,
+    bodies,
+    ...skipped.length > 0 ? { skipped } : {},
+    ...unsynced.length > 0 ? { unsynced } : {}
+  };
 }
 function bodyKey(collection, id) {
   return `${collection}\0${id}`;
 }
-var PLANAR_CHANNELS = /* @__PURE__ */ new Set(["x", "y", "qz", "qw", "vx", "vy", "wz"]);
-var MatterRuntime = class {
-  engineKind = "matter2d";
-  /** rapier3d only; present so both runtimes satisfy one internal shape. */
-  rapier = void 0;
-  world = void 0;
-  matter;
-  engine;
-  /** Alias under the name `PhysicsApi` uses, so `room.physics2d` reads through one field. */
-  get matterEngine() {
-    return this.engine;
+function planarLockWarning(spec) {
+  const boxed = (spec.colliders ?? []).some(
+    (c) => c.shape.type === CUBOID_SHAPE || c.shape.type === ROUND_CUBOID_SHAPE
+  );
+  if (!boxed) return void 0;
+  const b = spec.body;
+  const t = [b.translationsEnabledX, b.translationsEnabledY, b.translationsEnabledZ];
+  const r = [b.rotationsEnabledX, b.rotationsEnabledY, b.rotationsEnabledZ];
+  const axes = ["x", "y", "z"];
+  for (let i = 0; i < 3; i++) {
+    if (t[i]) continue;
+    if (r[(i + 1) % 3] || r[(i + 2) % 3]) continue;
+    const free = axes[i] === "z" ? "enabledRotations(true, false, true)" : "one of the other two rotations";
+    return `locks translation on ${axes[i]} and both rotations across that plane on a box-shaped body. That removes friction entirely: the box slides at a constant speed until it hits something. Free one out-of-plane rotation \u2014 in the xy plane that is ${free}, and it costs nothing, because geometry symmetric about the plane generates no torque about it.`;
   }
-  /** `true` when the blob carried no world at all: the caller logs it. */
+  return void 0;
+}
+var CUBOID_SHAPE = 1;
+var ROUND_CUBOID_SHAPE = 12;
+function makeUnsyncedRegistry(ops) {
+  const { map, build, destroy, onCreated } = ops;
+  return {
+    create(key, spec) {
+      if (typeof key !== "string" || key.length === 0) {
+        throw new Error("physics.unsynced.create: key must be a non-empty string");
+      }
+      const existing = map.get(key);
+      if (existing !== void 0) return existing;
+      const body = build(spec);
+      map.set(key, body);
+      onCreated?.(key, body);
+      return body;
+    },
+    get(key) {
+      return map.get(key);
+    },
+    has(key) {
+      return map.has(key);
+    },
+    remove(key) {
+      const body = map.get(key);
+      if (body === void 0) return false;
+      map.delete(key);
+      destroy(body);
+      return true;
+    },
+    get size() {
+      return map.size;
+    },
+    keys() {
+      return map.keys();
+    },
+    *[Symbol.iterator]() {
+      for (const entry of map) yield entry;
+    }
+  };
+}
+var PhysicsRuntime = class {
+  engineKind = "rapier3d";
+  /** matter2d only; present so both runtimes satisfy one internal shape. */
+  matter = void 0;
+  matterEngine = void 0;
+  rapier;
+  world;
+  /** `true` when the world was built from scratch and `setup` has to run. */
   rebuilt;
-  /**
-   * Always `true`. Unlike Rapier's, a matter2d world is never restored as a world — only as
-   * per-body state on a world the builder made — so `setup` has to run every time.
-   */
-  needsSetup = true;
+  /** Rapier restores a whole world, contacts included, so `setup` runs only on a rebuild. */
+  get needsSetup() {
+    return this.rebuilt;
+  }
   core;
   config;
+  /** Physics-backed collections, in schema (name-sorted) order. */
   collections;
   bodies = /* @__PURE__ */ new Map();
-  restore;
-  stepMs;
+  /** Collections already warned about the friction-killing 2D lock recipe (bug 6). */
+  warnedPlanar = /* @__PURE__ */ new Set();
+  /**
+   * Bodies whose sleep has already been synced. Rapier zeroes a body's velocity when it puts it
+   * to sleep — *after* the last awake-tick sync — so a body must be synced **once more** on the
+   * tick it falls asleep, or the schema keeps a phantom residual velocity forever (and a
+   * world rebuilt from schema state would wake it with a kick). Found by the drift check.
+   */
   sleepSynced = /* @__PURE__ */ new Set();
   /**
-   * The plain record object each body was built from. See `PhysicsRuntime.sourceRecords`: `add()`
-   * installs a new record object, so an id removed and re-added between two reconciles (a pooled
-   * projectile) is identifiable by identity, and is the one case where a live body has to be
-   * rebuilt so the new row's spawn pose and velocity are honoured.
+   * The plain record object each body was built from, by body key. `add()` always installs a
+   * **new** record object (`normalizeRecord` builds one), so an id that is removed and re-added
+   * between two reconciles — the pooled-projectile shape — is identifiable by identity alone,
+   * which is the only way to see it from here: both edits happened before this module looked.
+   * Without it the old body kept its pose and velocity and the new row's spawn values were lost.
+   *
+   * Unknown means adopt, never rebuild: a world restored from a hibernation blob has bodies with
+   * no recorded source, and rebuilding those would throw away exactly what the blob preserved.
    */
   sourceRecords = /* @__PURE__ */ new Map();
-  /** `collection.field` pairs already warned about a channel a plane cannot hold. */
+  /** `collection.field` pairs already warned about a channel value the engine would not take. */
   warnedChannels = /* @__PURE__ */ new Set();
-  constructor(core, matter, options) {
+  // ---- M7 planned feature 3 (b): per-entity physics skip ----
+  /**
+   * Entities whose body the room has switched off. See {@link setSkipped} for what "off" means and
+   * why it is spelled as "no body" rather than as "a body that is not stepped".
+   */
+  skippedKeys = /* @__PURE__ */ new Set();
+  // ---- end M7 planned feature 3 (b) ----
+  // ---- M7 planned feature 3 (a): physics-only unsynced bodies ----
+  /**
+   * Bodies with no schema row: rope anchors, dead-reckoned proxies, one-off sensors. Keyed by the
+   * room's own string rather than by `collection\0id`, because there is no collection and no id.
+   */
+  unsyncedBodies = /* @__PURE__ */ new Map();
+  unsynced;
+  // ---- end M7 planned feature 3 (a) ----
+  constructor(core, rapier, options) {
     const config = core.definition.config.physics;
-    if (!config) throw new Error("MatterRuntime: the room config declares no physics");
+    if (!config) throw new Error("PhysicsRuntime: the room config declares no physics");
     this.core = core;
     this.config = config;
-    this.matter = matter;
+    this.rapier = rapier;
     this.collections = core.ext.collections.filter(
       (c) => c.physics !== void 0
     );
-    this.engine = matter.Engine.create();
-    this.engine.gravity.x = config.gravity.x;
-    this.engine.gravity.y = config.gravity.y;
-    this.stepMs = (config.timestep ?? options.defaultTimestep) * 1e3;
-    this.rebuilt = options.restore === void 0;
-    this.restore = options.restore ? new Map(options.restore.bodies.map((b) => [bodyKey(b.collection, b.id), b])) : void 0;
+    if (options.restore) {
+      this.world = rapier.World.restoreSnapshot(options.restore.world);
+      this.rebuilt = false;
+      for (const [name, id, handle] of options.restore.bodies) {
+        const body = this.world.getRigidBody(handle);
+        if (body) this.bodies.set(bodyKey(name, id), body);
+      }
+      for (const key of options.restore.skipped ?? []) this.skippedKeys.add(key);
+      for (const [key, handle] of options.restore.unsynced ?? []) {
+        const body = this.world.getRigidBody(handle);
+        if (body) this.unsyncedBodies.set(key, body);
+      }
+    } else {
+      const g = config.gravity;
+      this.world = new rapier.World({ x: g.x, y: g.y, z: g.z });
+      this.rebuilt = true;
+    }
+    this.world.timestep = config.timestep ?? options.defaultTimestep;
+    this.unsynced = makeUnsyncedRegistry({
+      map: this.unsyncedBodies,
+      build: (spec) => {
+        const body = this.world.createRigidBody(spec.body);
+        for (const collider of spec.colliders ?? []) this.world.createCollider(collider, body);
+        return body;
+      },
+      destroy: (body) => this.destroyBody(body)
+    });
   }
   get timestep() {
-    return this.stepMs / 1e3;
+    return this.world.timestep;
   }
+  /** Runs the room's `setup` — static geometry — on a world that was built rather than restored. */
   runSetup(room) {
     const setup = this.config.setup;
     if (!setup) return;
-    this.core.guard("physics.setup", () => setup(this.engine, this.matter, room));
+    this.core.guard("physics.setup", () => setup(this.world, this.rapier, room));
   }
   free() {
     this.bodies.clear();
-    this.matter.Engine.clear(this.engine);
+    this.unsyncedBodies.clear();
+    this.world.free();
   }
   // -------------------------------------------------------------------------
   // Bodies
   // -------------------------------------------------------------------------
+  /**
+   * bugs.md #99: every teardown path goes through here rather than calling `removeRigidBody`
+   * directly.
+   *
+   * A sleeping body is parked in an island wired through the contact graph. Pulling a body out
+   * from under one leaves the sleeper resting on nothing — and, in the failure this guards, leaves
+   * the island holding a body that no longer exists. Waking the contacting bodies first makes the
+   * removal a plain awake-island edit, and it is also what a room wants physically: the crate the
+   * floor vanished under should fall.
+   *
+   * The cost is one narrow-phase lookup per collider of the *victim* — `contactPairsWith` walks
+   * only that collider's own contact pairs — against the alternative of waking the world, which
+   * would un-sleep every dormant body in the room on every teardown. Sensors are skipped
+   * deliberately: an intersection pair is not an island edge, so it cannot be the thing at risk.
+   */
+  destroyBody(body) {
+    const colliders = body.numColliders();
+    for (let i = 0; i < colliders; i++) {
+      this.world.contactPairsWith(body.collider(i), (other) => {
+        other.parent()?.wakeUp();
+      });
+    }
+    this.world.removeRigidBody(body);
+  }
+  // ---- M7 planned feature 3 (b): per-entity physics skip ----
+  /**
+   * Switches one entity's body off, or back on.
+   *
+   * Undercity feedback 29: hundreds of dormant-by-design entities want "exists and syncs, but do
+   * not step or mirror until I say so". Rapier's own sleeping approximates it and still costs a
+   * broadphase entry and a sync slot per row per tick, and a sleeping body wakes on contact,
+   * which a dormant spider must not.
+   *
+   * **Skipped means no body.** The body is destroyed on the way in and rebuilt from the schema
+   * row on the way out, on the next `reconcile`. The alternative — keep the body, exclude it from
+   * the step — is not something an engine offers per body without also excluding it from
+   * collision, and it would leave the cost this exists to remove (a body in the world, in the
+   * broadphase, walked by `sync`) exactly where it was. The row is untouched and goes on syncing
+   * as ordinary state, which is what the ask asked for; a room that moves a skipped entity by
+   * assigning its fields is moving it, and unskipping resumes from wherever the row now says.
+   *
+   * What is lost across a skip is what a body has and a row does not: contacts, and velocity
+   * beyond the f32 the row carries. A skipped entity resumes at rest at its row's pose unless the
+   * row's velocity channels say otherwise.
+   */
+  setSkipped(collection, id, on) {
+    const key = bodyKey(collection, id);
+    if (!on) {
+      this.skippedKeys.delete(key);
+      return;
+    }
+    this.skippedKeys.add(key);
+    const existing = this.bodies.get(key);
+    if (!existing) return;
+    this.bodies.delete(key);
+    this.sleepSynced.delete(key);
+    this.sourceRecords.delete(key);
+    this.destroyBody(existing);
+  }
+  isSkipped(collection, id) {
+    return this.skippedKeys.has(bodyKey(collection, id));
+  }
+  // ---- end M7 planned feature 3 (b) ----
+  /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
   bodyFor(collection, id) {
     const existing = this.bodies.get(bodyKey(collection, id));
-    if (existing) return existing.body;
+    if (existing) return existing;
+    if (this.skippedKeys.has(bodyKey(collection, id))) return void 0;
     const desc = this.collections.find((c) => c.name === collection);
     if (!desc) return void 0;
     const coll = plainEntity(this.core.plain, collection);
@@ -1684,7 +2434,7 @@ var MatterRuntime = class {
     }
     const spec = this.core.guard(
       `physics.bodies.${desc.name}`,
-      () => factory(this.matter, record, id)
+      () => factory(this.rapier, record, id)
     );
     if (!spec || !spec.body) {
       this.core.log(
@@ -1693,83 +2443,145 @@ var MatterRuntime = class {
       );
       return void 0;
     }
-    const key = bodyKey(desc.name, id);
-    const constraints = spec.constraints ?? [];
-    this.matter.Composite.add(this.engine.world, [spec.body, ...constraints]);
-    this.bodies.set(key, { body: spec.body, constraints });
-    const saved = this.restore?.get(key);
-    if (saved) {
-      this.restore?.delete(key);
-      this.applyState(spec.body, saved);
-    } else {
-      this.applyRecordToBody(desc, spec.body, record);
+    const planar = planarLockWarning(spec);
+    if (planar !== void 0 && !this.warnedPlanar.has(desc.name)) {
+      this.warnedPlanar.add(desc.name);
+      this.core.log("warn", `irtio: physics.bodies.${desc.name} ${planar}`);
+    }
+    const body = this.world.createRigidBody(spec.body);
+    for (const collider of spec.colliders ?? []) this.world.createCollider(collider, body);
+    this.warnLockedChannels(desc, spec, record);
+    this.applyRecordToBody(desc, body, record);
+    this.bodies.set(bodyKey(desc.name, id), body);
+    this.sourceRecords.set(bodyKey(desc.name, id), record);
+    return body;
+  }
+  /**
+   * A spawn value the engine will not take, said once per field.
+   *
+   * Rapier accepts `setLinvel` on an axis the body has disabled and then keeps zero, and it
+   * accepts one on a fixed body and then ignores it — both read back as "the field was applied"
+   * and behave as if it never was. The desc says which, before the body exists, so the check is
+   * on the desc: the usual case is the 2D-in-3D recipe (`enabledTranslations(true, true, false)`)
+   * meeting a row that spawns with a `vz`. Named by field, because the field is what the author
+   * wrote and what they will grep for.
+   */
+  warnLockedChannels(desc, spec, record) {
+    const physics = desc.physics;
+    if (!physics) return;
+    const b = spec.body;
+    const frozen = b.status !== 0;
+    const enabled = {
+      vx: b.translationsEnabledX,
+      vy: b.translationsEnabledY,
+      vz: b.translationsEnabledZ,
+      wx: b.rotationsEnabledX,
+      wy: b.rotationsEnabledY,
+      wz: b.rotationsEnabledZ
+    };
+    for (const [channel, field] of physics.channels) {
+      const allowed = enabled[channel];
+      if (allowed === void 0) continue;
+      const raw = record[field];
+      if (typeof raw !== "number" || raw === 0) continue;
+      if (allowed && !frozen) continue;
+      const key = `${desc.name}.${field}`;
+      if (this.warnedChannels.has(key)) continue;
+      this.warnedChannels.add(key);
+      this.core.log(
+        "warn",
+        `irtio: ${desc.name}.${field} (body channel ${channel}) was added as ${raw}, but ` + (frozen ? `physics.bodies.${desc.name} builds a non-dynamic body, which never moves under it` : `that degree of freedom is disabled by physics.bodies.${desc.name}`) + " \u2014 the value was dropped"
+      );
     }
-    this.sourceRecords.set(key, record);
-    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.
+   * 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 attached = this.bodies.get(bodyKey(desc.name, id));
-        if (attached)
-          fn(desc.name, id, attached.body, plainColl.get(id));
+        const body = this.bodies.get(bodyKey(desc.name, id));
+        if (body) fn(desc.name, id, body, plainColl.get(id));
       }
     }
   }
-  applyState(body, s) {
-    const M = this.matter;
-    M.Body.setPosition(body, { x: s.x, y: s.y });
-    M.Body.setAngle(body, s.angle);
-    M.Body.setVelocity(body, { x: s.vx, y: s.vy });
-    M.Body.setAngularVelocity(body, s.angularVelocity);
-    if (s.sleeping) M.Sleeping.set(body, true);
-  }
   applyRecordToBody(desc, body, record) {
     const physics = desc.physics;
     if (!physics) return;
-    const t = {
-      x: body.position.x,
-      y: body.position.y,
-      qz: Math.sin(body.angle / 2),
-      qw: Math.cos(body.angle / 2),
-      vx: body.velocity.x,
-      vy: body.velocity.y,
-      wz: body.angularVelocity
-    };
+    const t = { ...body.translation() };
+    const r = { ...body.rotation() };
+    const v = { ...body.linvel() };
+    const w = { ...body.angvel() };
+    let setT = false;
+    let setR = false;
+    let setV = false;
+    let setW = false;
     for (const [channel, field] of physics.channels) {
       const raw = record[field];
       if (typeof raw !== "number") continue;
-      if (raw !== 0 && !PLANAR_CHANNELS.has(channel)) {
-        const key = `${desc.name}.${field}`;
-        if (!this.warnedChannels.has(key)) {
-          this.warnedChannels.add(key);
-          this.core.log(
-            "warn",
-            `irtio: ${desc.name}.${field} maps body channel ${channel}, which a matter2d room cannot hold (the world is a plane); the ${raw} it was added with was dropped`
-          );
-        }
-        continue;
+      switch (channel) {
+        case "x":
+        case "y":
+        case "z":
+          t[channel] = raw;
+          setT = true;
+          break;
+        case "qx":
+          r.x = raw;
+          setR = true;
+          break;
+        case "qy":
+          r.y = raw;
+          setR = true;
+          break;
+        case "qz":
+          r.z = raw;
+          setR = true;
+          break;
+        case "qw":
+          r.w = raw;
+          setR = true;
+          break;
+        case "vx":
+          v.x = raw;
+          setV = true;
+          break;
+        case "vy":
+          v.y = raw;
+          setV = true;
+          break;
+        case "vz":
+          v.z = raw;
+          setV = true;
+          break;
+        case "wx":
+          w.x = raw;
+          setW = true;
+          break;
+        case "wy":
+          w.y = raw;
+          setW = true;
+          break;
+        case "wz":
+          w.z = raw;
+          setW = true;
+          break;
       }
-      applyChannel2d(channel, raw, t);
     }
-    this.applyState(body, {
-      collection: desc.name,
-      id: "",
-      x: t.x,
-      y: t.y,
-      angle: 2 * Math.atan2(t.qz, t.qw),
-      vx: t.vx,
-      vy: t.vy,
-      angularVelocity: t.wz,
-      sleeping: false
-    });
+    if (setT) body.setTranslation(t, true);
+    if (setR) body.setRotation(r, true);
+    if (setV) body.setLinvel(v, true);
+    if (setW) body.setAngvel(w, true);
   }
+  /**
+   * Creates bodies for new instances and destroys bodies whose instance is gone. Runs once per
+   * tick, right before the step, in collection order then instance order.
+   */
   reconcile() {
     const live = /* @__PURE__ */ new Set();
     for (const desc of this.collections) {
@@ -1777,6 +2589,7 @@ var MatterRuntime = class {
       for (const id of coll.ids()) {
         const key = bodyKey(desc.name, id);
         live.add(key);
+        if (this.skippedKeys.has(key)) continue;
         const record = coll.get(id);
         const existing = this.bodies.get(key);
         if (existing) {
@@ -1790,25 +2603,32 @@ var MatterRuntime = class {
           this.bodies.delete(key);
           this.sleepSynced.delete(key);
           this.sourceRecords.delete(key);
-          this.matter.Composite.remove(this.engine.world, [existing.body, ...existing.constraints]);
+          this.destroyBody(existing);
         }
         if (record !== void 0) this.create(desc, id, record);
       }
     }
-    for (const [key, attached] of [...this.bodies]) {
+    for (const [key, body] of [...this.bodies]) {
       if (live.has(key)) continue;
       this.bodies.delete(key);
       this.sleepSynced.delete(key);
       this.sourceRecords.delete(key);
-      this.matter.Composite.remove(this.engine.world, [attached.body, ...attached.constraints]);
+      this.destroyBody(body);
     }
+    for (const key of [...this.skippedKeys]) if (!live.has(key)) this.skippedKeys.delete(key);
   }
   // -------------------------------------------------------------------------
   // Step and sync
   // -------------------------------------------------------------------------
   step() {
-    this.matter.Engine.update(this.engine, this.stepMs);
+    this.world.step();
+    if (!rapierStepped) noteRapierStep();
   }
+  /**
+   * Body → schema. Writes through the tracked proxies, so movement produces ordinary deltas.
+   * Values are `Math.fround`ed for f32 fields, so what room code reads is exactly what the wire
+   * carries — and so a field that has not really moved does not re-dirty every tick.
+   */
   sync() {
     for (const desc of this.collections) {
       const physics = desc.physics;
@@ -1818,10 +2638,9 @@ var MatterRuntime = class {
       const rounders = roundersFor(desc);
       for (const id of plainColl.ids()) {
         const key = bodyKey(desc.name, id);
-        const attached = this.bodies.get(key);
-        if (!attached) continue;
-        const body = attached.body;
-        if (body.isSleeping) {
+        const body = this.bodies.get(key);
+        if (!body) continue;
+        if (body.isSleeping()) {
           if (this.sleepSynced.has(key)) continue;
           this.sleepSynced.add(key);
         } else {
@@ -1829,16 +2648,12 @@ var MatterRuntime = class {
         }
         const record = tracked.get(id);
         if (!record) continue;
-        const state = {
-          x: body.position.x,
-          y: body.position.y,
-          angle: body.angle,
-          vx: body.velocity.x,
-          vy: body.velocity.y,
-          angularVelocity: body.angularVelocity
-        };
+        const t = body.translation();
+        const r = body.rotation();
+        const v = body.linvel();
+        const w = body.angvel();
         for (const [channel, field] of physics.channels) {
-          const next = (rounders[field] ?? identity)(channelOf2d(channel, state));
+          const next = (rounders[field] ?? identity)(channelValue(channel, t, r, v, w));
           if (record[field] !== next) record[field] = next;
         }
       }
@@ -1849,22 +2664,19 @@ var MatterRuntime = class {
   // -------------------------------------------------------------------------
   serialize() {
     const bodies = [];
-    for (const [key, attached] of this.bodies) {
+    for (const [key, body] of this.bodies) {
       const sep = key.indexOf("\0");
-      const b = attached.body;
-      bodies.push({
-        collection: key.slice(0, sep),
-        id: key.slice(sep + 1),
-        x: b.position.x,
-        y: b.position.y,
-        angle: b.angle,
-        vx: b.velocity.x,
-        vy: b.velocity.y,
-        angularVelocity: b.angularVelocity,
-        sleeping: b.isSleeping === true
-      });
+      bodies.push([key.slice(0, sep), key.slice(sep + 1), body.handle]);
     }
-    return { bodies };
+    const skipped = [...this.skippedKeys];
+    const unsynced = [];
+    for (const [key, body] of this.unsyncedBodies) unsynced.push([key, body.handle]);
+    return {
+      world: this.world.takeSnapshot(),
+      bodies,
+      ...skipped.length > 0 ? { skipped } : {},
+      ...unsynced.length > 0 ? { unsynced } : {}
+    };
   }
 };
 function identity(v) {
@@ -1877,215 +2689,305 @@ function roundersFor(desc) {
   }
   return out;
 }
+function channelValue(channel, t, r, v, w) {
+  switch (channel) {
+    case "x":
+      return t.x;
+    case "y":
+      return t.y;
+    case "z":
+      return t.z;
+    case "qx":
+      return r.x;
+    case "qy":
+      return r.y;
+    case "qz":
+      return r.z;
+    case "qw":
+      return r.w;
+    case "vx":
+      return v.x;
+    case "vy":
+      return v.y;
+    case "vz":
+      return v.z;
+    case "wx":
+      return w.x;
+    case "wy":
+      return w.y;
+    default:
+      return w.z;
+  }
+}
 
-// src/core/physics.ts
-import { ByteReader as ByteReader2, ByteWriter as ByteWriter2 } from "@irtio/schema";
+// src/core/matter.ts
+import {
+  ByteReader as ByteReader2,
+  ByteWriter as ByteWriter2,
+  applyChannel2d,
+  channelOf2d
+} from "@irtio/schema";
 var engine2;
 var loading2;
-async function initPhysics() {
+async function initMatter() {
   if (engine2) return engine2;
   loading2 ??= (async () => {
-    const mod = await import("@dimforge/rapier3d-compat");
+    const mod = await import("matter-js");
     const ns = mod.default ?? mod;
-    await ns.init();
     engine2 = ns;
     return ns;
   })();
   return loading2;
 }
-function loadedPhysics() {
+function loadedMatter() {
   return engine2;
 }
-function resetPhysicsForTests() {
+function resetMatterForTests() {
   engine2 = void 0;
   loading2 = void 0;
-  rapierStepped = false;
-  firstStepWaiters.length = 0;
-}
-var rapierStepped = false;
-var firstStepWaiters = [];
-function rapierHasStepped() {
-  return rapierStepped;
-}
-function onFirstRapierStep(cb) {
-  if (rapierStepped) {
-    cb();
-    return;
-  }
-  firstStepWaiters.push(cb);
-}
-function noteRapierStep() {
-  rapierStepped = true;
-  const waiters = firstStepWaiters.splice(0, firstStepWaiters.length);
-  for (const cb of waiters) {
-    try {
-      cb();
-    } catch {
-    }
-  }
 }
-function encodePhysicsSection(section) {
-  const w = new ByteWriter2(section.world.length + section.bodies.length * 24 + 8);
-  w.blob(section.world);
+function encodeMatterBodies(section) {
+  const skipped = section.skipped ?? [];
+  const unsynced = section.unsynced ?? [];
+  const w = new ByteWriter2(
+    section.bodies.length * 72 + skipped.length * 24 + unsynced.length * 72 + 16
+  );
   w.varint(section.bodies.length);
-  for (const [name, id, handle] of section.bodies) {
-    w.str(name);
-    w.str(id);
-    w.f64(handle);
+  for (const b of section.bodies) {
+    w.str(b.collection);
+    w.str(b.id);
+    w.f64(b.x);
+    w.f64(b.y);
+    w.f64(b.angle);
+    w.f64(b.vx);
+    w.f64(b.vy);
+    w.f64(b.angularVelocity);
+    w.u8(b.sleeping ? 1 : 0);
   }
-  return w.finish();
-}
-var MATTER_TAG = 1;
-var RAPIER2D_TAG = 2;
-function physicsSectionEngine(bytes) {
-  const r = new ByteReader2(bytes);
-  if (r.varint() !== 0) return "rapier3d";
-  const tag = r.u8();
-  if (tag === MATTER_TAG) return "matter2d";
-  if (tag === RAPIER2D_TAG) return "rapier2d";
-  return "rapier3d";
-}
-function encodeRapier2dSectionEnvelope(payload) {
-  const w = new ByteWriter2(payload.length + 8);
-  w.varint(0);
-  w.u8(RAPIER2D_TAG);
-  w.bytes(payload);
-  return w.finish();
-}
-function decodeRapier2dSectionEnvelope(bytes) {
-  const r = new ByteReader2(bytes);
-  if (r.varint() !== 0 || r.u8() !== RAPIER2D_TAG) {
-    throw new Error("irtio: this physics section was not written by rapier2d");
+  if (skipped.length > 0 || unsynced.length > 0) {
+    w.varint(skipped.length);
+    for (const key of skipped) w.str(key);
+    w.varint(unsynced.length);
+    for (const b of unsynced) {
+      w.str(b.key);
+      w.f64(b.x);
+      w.f64(b.y);
+      w.f64(b.angle);
+      w.f64(b.vx);
+      w.f64(b.vy);
+      w.f64(b.angularVelocity);
+      w.u8(b.sleeping ? 1 : 0);
+    }
   }
-  return r.rest();
-}
-function encodeMatterSectionEnvelope(payload) {
-  const w = new ByteWriter2(payload.length + 8);
-  w.varint(0);
-  w.u8(MATTER_TAG);
-  w.bytes(payload);
   return w.finish();
 }
-function decodeMatterSectionEnvelope(bytes) {
-  const r = new ByteReader2(bytes);
-  if (r.varint() !== 0 || r.u8() !== MATTER_TAG) {
-    throw new Error("irtio: this physics section was not written by matter2d");
-  }
-  return r.rest();
-}
-function decodePhysicsSection(bytes) {
+function decodeMatterBodies(bytes) {
   const r = new ByteReader2(bytes);
-  const world = r.blob().slice();
   const count = r.varint();
   const bodies = [];
-  for (let i = 0; i < count; i++) bodies.push([r.str(), r.str(), r.f64()]);
-  return { world, bodies };
+  for (let i = 0; i < count; i++) {
+    bodies.push({
+      collection: r.str(),
+      id: r.str(),
+      x: r.f64(),
+      y: r.f64(),
+      angle: r.f64(),
+      vx: r.f64(),
+      vy: r.f64(),
+      angularVelocity: r.f64(),
+      sleeping: r.u8() === 1
+    });
+  }
+  if (r.eof) return { bodies };
+  const skippedCount = r.varint();
+  const skipped = [];
+  for (let i = 0; i < skippedCount; i++) skipped.push(r.str());
+  const unsynced = [];
+  if (!r.eof) {
+    const unsyncedCount = r.varint();
+    for (let i = 0; i < unsyncedCount; i++) {
+      unsynced.push({
+        key: r.str(),
+        x: r.f64(),
+        y: r.f64(),
+        angle: r.f64(),
+        vx: r.f64(),
+        vy: r.f64(),
+        angularVelocity: r.f64(),
+        sleeping: r.u8() === 1
+      });
+    }
+  }
+  return {
+    bodies,
+    ...skipped.length > 0 ? { skipped } : {},
+    ...unsynced.length > 0 ? { unsynced } : {}
+  };
 }
 function bodyKey2(collection, id) {
   return `${collection}\0${id}`;
 }
-function planarLockWarning(spec) {
-  const boxed = (spec.colliders ?? []).some(
-    (c) => c.shape.type === CUBOID_SHAPE || c.shape.type === ROUND_CUBOID_SHAPE
-  );
-  if (!boxed) return void 0;
-  const b = spec.body;
-  const t = [b.translationsEnabledX, b.translationsEnabledY, b.translationsEnabledZ];
-  const r = [b.rotationsEnabledX, b.rotationsEnabledY, b.rotationsEnabledZ];
-  const axes = ["x", "y", "z"];
-  for (let i = 0; i < 3; i++) {
-    if (t[i]) continue;
-    if (r[(i + 1) % 3] || r[(i + 2) % 3]) continue;
-    const free = axes[i] === "z" ? "enabledRotations(true, false, true)" : "one of the other two rotations";
-    return `locks translation on ${axes[i]} and both rotations across that plane on a box-shaped body. That removes friction entirely: the box slides at a constant speed until it hits something. Free one out-of-plane rotation \u2014 in the xy plane that is ${free}, and it costs nothing, because geometry symmetric about the plane generates no torque about it.`;
+var PLANAR_CHANNELS = /* @__PURE__ */ new Set(["x", "y", "qz", "qw", "vx", "vy", "wz"]);
+var MatterRuntime = class {
+  engineKind = "matter2d";
+  /** rapier3d only; present so both runtimes satisfy one internal shape. */
+  rapier = void 0;
+  world = void 0;
+  matter;
+  engine;
+  /** Alias under the name `PhysicsApi` uses, so `room.physics2d` reads through one field. */
+  get matterEngine() {
+    return this.engine;
   }
-  return void 0;
-}
-var CUBOID_SHAPE = 1;
-var ROUND_CUBOID_SHAPE = 12;
-var PhysicsRuntime = class {
-  engineKind = "rapier3d";
-  /** matter2d only; present so both runtimes satisfy one internal shape. */
-  matter = void 0;
-  matterEngine = void 0;
-  rapier;
-  world;
-  /** `true` when the world was built from scratch and `setup` has to run. */
+  /** `true` when the blob carried no world at all: the caller logs it. */
   rebuilt;
-  /** Rapier restores a whole world, contacts included, so `setup` runs only on a rebuild. */
-  get needsSetup() {
-    return this.rebuilt;
-  }
+  /**
+   * Always `true`. Unlike Rapier's, a matter2d world is never restored as a world — only as
+   * per-body state on a world the builder made — so `setup` has to run every time.
+   */
+  needsSetup = true;
   core;
   config;
-  /** Physics-backed collections, in schema (name-sorted) order. */
   collections;
   bodies = /* @__PURE__ */ new Map();
-  /** Collections already warned about the friction-killing 2D lock recipe (bug 6). */
-  warnedPlanar = /* @__PURE__ */ new Set();
-  /**
-   * Bodies whose sleep has already been synced. Rapier zeroes a body's velocity when it puts it
-   * to sleep — *after* the last awake-tick sync — so a body must be synced **once more** on the
-   * tick it falls asleep, or the schema keeps a phantom residual velocity forever (and a
-   * world rebuilt from schema state would wake it with a kick). Found by the drift check.
-   */
+  restore;
+  stepMs;
   sleepSynced = /* @__PURE__ */ new Set();
   /**
-   * The plain record object each body was built from, by body key. `add()` always installs a
-   * **new** record object (`normalizeRecord` builds one), so an id that is removed and re-added
-   * between two reconciles — the pooled-projectile shape — is identifiable by identity alone,
-   * which is the only way to see it from here: both edits happened before this module looked.
-   * Without it the old body kept its pose and velocity and the new row's spawn values were lost.
-   *
-   * Unknown means adopt, never rebuild: a world restored from a hibernation blob has bodies with
-   * no recorded source, and rebuilding those would throw away exactly what the blob preserved.
+   * The plain record object each body was built from. See `PhysicsRuntime.sourceRecords`: `add()`
+   * installs a new record object, so an id removed and re-added between two reconciles (a pooled
+   * projectile) is identifiable by identity, and is the one case where a live body has to be
+   * rebuilt so the new row's spawn pose and velocity are honoured.
    */
   sourceRecords = /* @__PURE__ */ new Map();
-  /** `collection.field` pairs already warned about a channel value the engine would not take. */
+  /** `collection.field` pairs already warned about a channel a plane cannot hold. */
   warnedChannels = /* @__PURE__ */ new Set();
-  constructor(core, rapier, options) {
+  // ---- M7 planned feature 3 (b): per-entity physics skip ----
+  /** See `PhysicsRuntime.skippedKeys`: entities whose body the room has switched off. */
+  skippedKeys = /* @__PURE__ */ new Set();
+  // ---- end M7 planned feature 3 (b) ----
+  // ---- M7 planned feature 3 (a): physics-only unsynced bodies ----
+  unsyncedBodies = /* @__PURE__ */ new Map();
+  /** Saved unsynced state, consumed as `setup` rebuilds each body under the same key. */
+  restoreUnsynced;
+  /** One-shot: the first reconcile after a wake reports whatever `setup` did not rebuild. */
+  reportedMissingUnsynced = false;
+  unsynced;
+  // ---- end M7 planned feature 3 (a) ----
+  constructor(core, matter, options) {
     const config = core.definition.config.physics;
-    if (!config) throw new Error("PhysicsRuntime: the room config declares no physics");
+    if (!config) throw new Error("MatterRuntime: the room config declares no physics");
     this.core = core;
     this.config = config;
-    this.rapier = rapier;
+    this.matter = matter;
     this.collections = core.ext.collections.filter(
       (c) => c.physics !== void 0
     );
-    if (options.restore) {
-      this.world = rapier.World.restoreSnapshot(options.restore.world);
-      this.rebuilt = false;
-      for (const [name, id, handle] of options.restore.bodies) {
-        const body = this.world.getRigidBody(handle);
-        if (body) this.bodies.set(bodyKey2(name, id), body);
+    this.engine = matter.Engine.create();
+    this.engine.gravity.x = config.gravity.x;
+    this.engine.gravity.y = config.gravity.y;
+    this.stepMs = (config.timestep ?? options.defaultTimestep) * 1e3;
+    this.rebuilt = options.restore === void 0;
+    this.restore = options.restore ? new Map(options.restore.bodies.map((b) => [bodyKey2(b.collection, b.id), b])) : void 0;
+    for (const key of options.restore?.skipped ?? []) this.skippedKeys.add(key);
+    const savedUnsynced = options.restore?.unsynced;
+    this.restoreUnsynced = savedUnsynced ? new Map(savedUnsynced.map((b) => [b.key, b])) : void 0;
+    this.unsynced = makeUnsyncedRegistry({
+      map: this.unsyncedBodies,
+      build: (spec) => {
+        const constraints = spec.constraints ?? [];
+        this.matter.Composite.add(this.engine.world, [spec.body, ...constraints]);
+        return { body: spec.body, constraints };
+      },
+      destroy: (attached) => {
+        this.wakeContactsOf(attached.body);
+        this.matter.Composite.remove(this.engine.world, [attached.body, ...attached.constraints]);
+      },
+      // The matter2d half of surviving hibernation: `setup` rebuilds the body, and the saved pose
+      // and velocity are put back onto it, exactly as they are for an entity-backed body.
+      onCreated: (key, attached) => {
+        const saved = this.restoreUnsynced?.get(key);
+        if (!saved) return;
+        this.restoreUnsynced?.delete(key);
+        this.applyState(attached.body, {
+          collection: "",
+          id: key,
+          x: saved.x,
+          y: saved.y,
+          angle: saved.angle,
+          vx: saved.vx,
+          vy: saved.vy,
+          angularVelocity: saved.angularVelocity,
+          sleeping: saved.sleeping
+        });
       }
-    } else {
-      const g = config.gravity;
-      this.world = new rapier.World({ x: g.x, y: g.y, z: g.z });
-      this.rebuilt = true;
-    }
-    this.world.timestep = config.timestep ?? options.defaultTimestep;
+    });
   }
   get timestep() {
-    return this.world.timestep;
+    return this.stepMs / 1e3;
   }
-  /** Runs the room's `setup` — static geometry — on a world that was built rather than restored. */
   runSetup(room) {
     const setup = this.config.setup;
     if (!setup) return;
-    this.core.guard("physics.setup", () => setup(this.world, this.rapier, room));
+    this.core.guard("physics.setup", () => setup(this.engine, this.matter, room));
   }
   free() {
     this.bodies.clear();
-    this.world.free();
+    this.unsyncedBodies.clear();
+    this.matter.Engine.clear(this.engine);
   }
   // -------------------------------------------------------------------------
   // Bodies
   // -------------------------------------------------------------------------
-  /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
+  /**
+   * bugs.md #100, the matter2d half. Rapier's bindings wake a contact island themselves when a
+   * member is removed (`PhysicsRuntime.destroyBody` / `Rapier2dRuntime.destroyBody`); matter.js
+   * does not, so a body sleeping against a victim about to be removed is left sleeping and
+   * motionless in mid-air once the victim is gone.
+   *
+   * `enableSleeping` is a property the room's own `setup` sets on `engine` (there is no config
+   * flag for it), so this only runs the geometry query when the room has actually turned sleeping
+   * on. `Matter.Query.collides` is matter's public narrow-phase check against a body's current
+   * vertices, run here against every other body in the world; it costs nothing extra to compute
+   * (matter.js does not expose a per-body contact list the way rapier's bindings do) but is bounded
+   * by the same room body count that every reconcile already walks. Sensors are skipped, matching
+   * the rapier fix: an intersection pair is not an island edge.
+   */
+  wakeContactsOf(victim) {
+    if (!this.engine.enableSleeping) return;
+    const M = this.matter;
+    const others = M.Composite.allBodies(this.engine.world).filter((b) => b !== victim);
+    for (const collision of M.Query.collides(victim, others)) {
+      const other = collision.bodyA === victim ? collision.bodyB : collision.bodyA;
+      if (other.isSensor) continue;
+      if (other.isSleeping) M.Sleeping.set(other, false);
+    }
+  }
+  // ---- M7 planned feature 3 (b): per-entity physics skip ----
+  /** The matter.js half of `PhysicsRuntime.setSkipped`; its comment is the whole argument. */
+  setSkipped(collection, id, on) {
+    const key = bodyKey2(collection, id);
+    if (!on) {
+      this.skippedKeys.delete(key);
+      return;
+    }
+    this.skippedKeys.add(key);
+    const existing = this.bodies.get(key);
+    if (!existing) return;
+    this.bodies.delete(key);
+    this.sleepSynced.delete(key);
+    this.sourceRecords.delete(key);
+    this.wakeContactsOf(existing.body);
+    this.matter.Composite.remove(this.engine.world, [existing.body, ...existing.constraints]);
+  }
+  isSkipped(collection, id) {
+    return this.skippedKeys.has(bodyKey2(collection, id));
+  }
+  // ---- end M7 planned feature 3 (b) ----
   bodyFor(collection, id) {
     const existing = this.bodies.get(bodyKey2(collection, id));
-    if (existing) return existing;
+    if (existing) return existing.body;
+    if (this.skippedKeys.has(bodyKey2(collection, id))) return void 0;
     const desc = this.collections.find((c) => c.name === collection);
     if (!desc) return void 0;
     const coll = plainEntity(this.core.plain, collection);
@@ -2101,7 +3003,7 @@ var PhysicsRuntime = class {
     }
     const spec = this.core.guard(
       `physics.bodies.${desc.name}`,
-      () => factory(this.rapier, record, id)
+      () => factory(this.matter, record, id)
     );
     if (!spec || !spec.body) {
       this.core.log(
@@ -2110,152 +3012,102 @@ var PhysicsRuntime = class {
       );
       return void 0;
     }
-    const planar = planarLockWarning(spec);
-    if (planar !== void 0 && !this.warnedPlanar.has(desc.name)) {
-      this.warnedPlanar.add(desc.name);
-      this.core.log("warn", `irtio: physics.bodies.${desc.name} ${planar}`);
-    }
-    const body = this.world.createRigidBody(spec.body);
-    for (const collider of spec.colliders ?? []) this.world.createCollider(collider, body);
-    this.warnLockedChannels(desc, spec, record);
-    this.applyRecordToBody(desc, body, record);
-    this.bodies.set(bodyKey2(desc.name, id), body);
-    this.sourceRecords.set(bodyKey2(desc.name, id), record);
-    return body;
-  }
-  /**
-   * A spawn value the engine will not take, said once per field.
-   *
-   * Rapier accepts `setLinvel` on an axis the body has disabled and then keeps zero, and it
-   * accepts one on a fixed body and then ignores it — both read back as "the field was applied"
-   * and behave as if it never was. The desc says which, before the body exists, so the check is
-   * on the desc: the usual case is the 2D-in-3D recipe (`enabledTranslations(true, true, false)`)
-   * meeting a row that spawns with a `vz`. Named by field, because the field is what the author
-   * wrote and what they will grep for.
-   */
-  warnLockedChannels(desc, spec, record) {
-    const physics = desc.physics;
-    if (!physics) return;
-    const b = spec.body;
-    const frozen = b.status !== 0;
-    const enabled = {
-      vx: b.translationsEnabledX,
-      vy: b.translationsEnabledY,
-      vz: b.translationsEnabledZ,
-      wx: b.rotationsEnabledX,
-      wy: b.rotationsEnabledY,
-      wz: b.rotationsEnabledZ
-    };
-    for (const [channel, field] of physics.channels) {
-      const allowed = enabled[channel];
-      if (allowed === void 0) continue;
-      const raw = record[field];
-      if (typeof raw !== "number" || raw === 0) continue;
-      if (allowed && !frozen) continue;
-      const key = `${desc.name}.${field}`;
-      if (this.warnedChannels.has(key)) continue;
-      this.warnedChannels.add(key);
-      this.core.log(
-        "warn",
-        `irtio: ${desc.name}.${field} (body channel ${channel}) was added as ${raw}, but ` + (frozen ? `physics.bodies.${desc.name} builds a non-dynamic body, which never moves under it` : `that degree of freedom is disabled by physics.bodies.${desc.name}`) + " \u2014 the value was dropped"
-      );
+    const key = bodyKey2(desc.name, id);
+    const constraints = spec.constraints ?? [];
+    this.matter.Composite.add(this.engine.world, [spec.body, ...constraints]);
+    this.bodies.set(key, { body: spec.body, constraints });
+    const saved = this.restore?.get(key);
+    if (saved) {
+      this.restore?.delete(key);
+      this.applyState(spec.body, saved);
+    } else {
+      this.applyRecordToBody(desc, spec.body, record);
     }
+    this.sourceRecords.set(key, record);
+    return spec.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.
+   * 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 body = this.bodies.get(bodyKey2(desc.name, id));
-        if (body) fn(desc.name, id, body, plainColl.get(id));
+        const attached = this.bodies.get(bodyKey2(desc.name, id));
+        if (attached)
+          fn(desc.name, id, attached.body, plainColl.get(id));
       }
     }
   }
+  applyState(body, s) {
+    const M = this.matter;
+    M.Body.setPosition(body, { x: s.x, y: s.y });
+    M.Body.setAngle(body, s.angle);
+    M.Body.setVelocity(body, { x: s.vx, y: s.vy });
+    M.Body.setAngularVelocity(body, s.angularVelocity);
+    if (s.sleeping) M.Sleeping.set(body, true);
+  }
   applyRecordToBody(desc, body, record) {
     const physics = desc.physics;
     if (!physics) return;
-    const t = { ...body.translation() };
-    const r = { ...body.rotation() };
-    const v = { ...body.linvel() };
-    const w = { ...body.angvel() };
-    let setT = false;
-    let setR = false;
-    let setV = false;
-    let setW = false;
+    const t = {
+      x: body.position.x,
+      y: body.position.y,
+      qz: Math.sin(body.angle / 2),
+      qw: Math.cos(body.angle / 2),
+      vx: body.velocity.x,
+      vy: body.velocity.y,
+      wz: body.angularVelocity
+    };
     for (const [channel, field] of physics.channels) {
       const raw = record[field];
       if (typeof raw !== "number") continue;
-      switch (channel) {
-        case "x":
-        case "y":
-        case "z":
-          t[channel] = raw;
-          setT = true;
-          break;
-        case "qx":
-          r.x = raw;
-          setR = true;
-          break;
-        case "qy":
-          r.y = raw;
-          setR = true;
-          break;
-        case "qz":
-          r.z = raw;
-          setR = true;
-          break;
-        case "qw":
-          r.w = raw;
-          setR = true;
-          break;
-        case "vx":
-          v.x = raw;
-          setV = true;
-          break;
-        case "vy":
-          v.y = raw;
-          setV = true;
-          break;
-        case "vz":
-          v.z = raw;
-          setV = true;
-          break;
-        case "wx":
-          w.x = raw;
-          setW = true;
-          break;
-        case "wy":
-          w.y = raw;
-          setW = true;
-          break;
-        case "wz":
-          w.z = raw;
-          setW = true;
-          break;
+      if (raw !== 0 && !PLANAR_CHANNELS.has(channel)) {
+        const key = `${desc.name}.${field}`;
+        if (!this.warnedChannels.has(key)) {
+          this.warnedChannels.add(key);
+          this.core.log(
+            "warn",
+            `irtio: ${desc.name}.${field} maps body channel ${channel}, which a matter2d room cannot hold (the world is a plane); the ${raw} it was added with was dropped`
+          );
+        }
+        continue;
       }
+      applyChannel2d(channel, raw, t);
     }
-    if (setT) body.setTranslation(t, true);
-    if (setR) body.setRotation(r, true);
-    if (setV) body.setLinvel(v, true);
-    if (setW) body.setAngvel(w, true);
+    this.applyState(body, {
+      collection: desc.name,
+      id: "",
+      x: t.x,
+      y: t.y,
+      angle: 2 * Math.atan2(t.qz, t.qw),
+      vx: t.vx,
+      vy: t.vy,
+      angularVelocity: t.wz,
+      sleeping: false
+    });
   }
-  /**
-   * Creates bodies for new instances and destroys bodies whose instance is gone. Runs once per
-   * tick, right before the step, in collection order then instance order.
-   */
   reconcile() {
+    if (!this.reportedMissingUnsynced && this.restoreUnsynced) {
+      this.reportedMissingUnsynced = true;
+      const missing = [...this.restoreUnsynced.keys()];
+      this.restoreUnsynced = void 0;
+      if (missing.length > 0) {
+        this.core.log(
+          "warn",
+          `irtio: matter2d rebuilds its world on every wake, so an unsynced body only comes back if physics.setup creates it again under the same key. These did not come back and their saved state was dropped: ${missing.join(", ")}`
+        );
+      }
+    }
     const live = /* @__PURE__ */ new Set();
     for (const desc of this.collections) {
       const coll = plainEntity(this.core.plain, desc.name);
       for (const id of coll.ids()) {
         const key = bodyKey2(desc.name, id);
         live.add(key);
+        if (this.skippedKeys.has(key)) continue;
         const record = coll.get(id);
         const existing = this.bodies.get(key);
         if (existing) {
@@ -2269,31 +3121,28 @@ var PhysicsRuntime = class {
           this.bodies.delete(key);
           this.sleepSynced.delete(key);
           this.sourceRecords.delete(key);
-          this.world.removeRigidBody(existing);
+          this.wakeContactsOf(existing.body);
+          this.matter.Composite.remove(this.engine.world, [existing.body, ...existing.constraints]);
         }
         if (record !== void 0) this.create(desc, id, record);
       }
     }
-    for (const [key, body] of [...this.bodies]) {
+    for (const [key, attached] of [...this.bodies]) {
       if (live.has(key)) continue;
       this.bodies.delete(key);
       this.sleepSynced.delete(key);
       this.sourceRecords.delete(key);
-      this.world.removeRigidBody(body);
+      this.wakeContactsOf(attached.body);
+      this.matter.Composite.remove(this.engine.world, [attached.body, ...attached.constraints]);
     }
+    for (const key of [...this.skippedKeys]) if (!live.has(key)) this.skippedKeys.delete(key);
   }
   // -------------------------------------------------------------------------
   // Step and sync
   // -------------------------------------------------------------------------
   step() {
-    this.world.step();
-    if (!rapierStepped) noteRapierStep();
+    this.matter.Engine.update(this.engine, this.stepMs);
   }
-  /**
-   * Body → schema. Writes through the tracked proxies, so movement produces ordinary deltas.
-   * Values are `Math.fround`ed for f32 fields, so what room code reads is exactly what the wire
-   * carries — and so a field that has not really moved does not re-dirty every tick.
-   */
   sync() {
     for (const desc of this.collections) {
       const physics = desc.physics;
@@ -2303,9 +3152,10 @@ var PhysicsRuntime = class {
       const rounders = roundersFor2(desc);
       for (const id of plainColl.ids()) {
         const key = bodyKey2(desc.name, id);
-        const body = this.bodies.get(key);
-        if (!body) continue;
-        if (body.isSleeping()) {
+        const attached = this.bodies.get(key);
+        if (!attached) continue;
+        const body = attached.body;
+        if (body.isSleeping) {
           if (this.sleepSynced.has(key)) continue;
           this.sleepSynced.add(key);
         } else {
@@ -2313,12 +3163,16 @@ var PhysicsRuntime = class {
         }
         const record = tracked.get(id);
         if (!record) continue;
-        const t = body.translation();
-        const r = body.rotation();
-        const v = body.linvel();
-        const w = body.angvel();
+        const state = {
+          x: body.position.x,
+          y: body.position.y,
+          angle: body.angle,
+          vx: body.velocity.x,
+          vy: body.velocity.y,
+          angularVelocity: body.angularVelocity
+        };
         for (const [channel, field] of physics.channels) {
-          const next = (rounders[field] ?? identity2)(channelValue(channel, t, r, v, w));
+          const next = (rounders[field] ?? identity2)(channelOf2d(channel, state));
           if (record[field] !== next) record[field] = next;
         }
       }
@@ -2329,52 +3183,52 @@ var PhysicsRuntime = class {
   // -------------------------------------------------------------------------
   serialize() {
     const bodies = [];
-    for (const [key, body] of this.bodies) {
+    for (const [key, attached] of this.bodies) {
       const sep = key.indexOf("\0");
-      bodies.push([key.slice(0, sep), key.slice(sep + 1), body.handle]);
-    }
-    return { world: this.world.takeSnapshot(), bodies };
-  }
-};
-function identity2(v) {
-  return v;
-}
-function roundersFor2(desc) {
-  const out = {};
-  for (const f of desc.fields) {
-    if (f.type.kind === "f32") out[f.name] = Math.fround;
+      const b = attached.body;
+      bodies.push({
+        collection: key.slice(0, sep),
+        id: key.slice(sep + 1),
+        x: b.position.x,
+        y: b.position.y,
+        angle: b.angle,
+        vx: b.velocity.x,
+        vy: b.velocity.y,
+        angularVelocity: b.angularVelocity,
+        sleeping: b.isSleeping === true
+      });
+    }
+    const skipped = [...this.skippedKeys];
+    const unsynced = [];
+    for (const [key, attached] of this.unsyncedBodies) {
+      const b = attached.body;
+      unsynced.push({
+        key,
+        x: b.position.x,
+        y: b.position.y,
+        angle: b.angle,
+        vx: b.velocity.x,
+        vy: b.velocity.y,
+        angularVelocity: b.angularVelocity,
+        sleeping: b.isSleeping === true
+      });
+    }
+    return {
+      bodies,
+      ...skipped.length > 0 ? { skipped } : {},
+      ...unsynced.length > 0 ? { unsynced } : {}
+    };
   }
-  return out;
+};
+function identity2(v) {
+  return v;
 }
-function channelValue(channel, t, r, v, w) {
-  switch (channel) {
-    case "x":
-      return t.x;
-    case "y":
-      return t.y;
-    case "z":
-      return t.z;
-    case "qx":
-      return r.x;
-    case "qy":
-      return r.y;
-    case "qz":
-      return r.z;
-    case "qw":
-      return r.w;
-    case "vx":
-      return v.x;
-    case "vy":
-      return v.y;
-    case "vz":
-      return v.z;
-    case "wx":
-      return w.x;
-    case "wy":
-      return w.y;
-    default:
-      return w.z;
+function roundersFor2(desc) {
+  const out = {};
+  for (const f of desc.fields) {
+    if (f.type.kind === "f32") out[f.name] = Math.fround;
   }
+  return out;
 }
 
 // src/core/random.ts
@@ -2457,6 +3311,15 @@ var Rapier2dRuntime = class {
   sourceRecords = /* @__PURE__ */ new Map();
   /** `collection.field` pairs already warned about a channel value the engine would not take. */
   warnedChannels = /* @__PURE__ */ new Set();
+  // ---- M7 planned feature 3 (b): per-entity physics skip ----
+  /** See `PhysicsRuntime.skippedKeys`: entities whose body the room has switched off. */
+  skippedKeys = /* @__PURE__ */ new Set();
+  // ---- end M7 planned feature 3 (b) ----
+  // ---- M7 planned feature 3 (a): physics-only unsynced bodies ----
+  /** See `PhysicsRuntime.unsyncedBodies`: bodies the world steps that no schema row describes. */
+  unsyncedBodies = /* @__PURE__ */ new Map();
+  unsynced;
+  // ---- end M7 planned feature 3 (a) ----
   constructor(core, rapier, options) {
     const config = core.definition.config.physics;
     if (!config) throw new Error("Rapier2dRuntime: the room config declares no physics");
@@ -2473,12 +3336,26 @@ var Rapier2dRuntime = class {
         const body = this.world.getRigidBody(handle);
         if (body) this.bodies.set(bodyKey3(name, id), body);
       }
+      for (const key of options.restore.skipped ?? []) this.skippedKeys.add(key);
+      for (const [key, handle] of options.restore.unsynced ?? []) {
+        const body = this.world.getRigidBody(handle);
+        if (body) this.unsyncedBodies.set(key, body);
+      }
     } else {
       const g = config.gravity;
       this.world = new rapier.World({ x: g.x, y: g.y });
       this.rebuilt = true;
     }
     this.world.timestep = config.timestep ?? options.defaultTimestep;
+    this.unsynced = makeUnsyncedRegistry({
+      map: this.unsyncedBodies,
+      build: (spec) => {
+        const body = this.world.createRigidBody(spec.body);
+        for (const collider of spec.colliders ?? []) this.world.createCollider(collider, body);
+        return body;
+      },
+      destroy: (body) => this.destroyBody(body)
+    });
   }
   get timestep() {
     return this.world.timestep;
@@ -2491,15 +3368,51 @@ var Rapier2dRuntime = class {
   }
   free() {
     this.bodies.clear();
+    this.unsyncedBodies.clear();
     this.world.free();
   }
   // -------------------------------------------------------------------------
   // Bodies
   // -------------------------------------------------------------------------
+  /**
+   * bugs.md #99, planar half: the teardown door every removal goes through. See
+   * `PhysicsRuntime.destroyBody` for the argument — one narrow-phase walk of the victim's own
+   * contact pairs, so a body resting on what is about to vanish is awake when it does.
+   */
+  destroyBody(body) {
+    const colliders = body.numColliders();
+    for (let i = 0; i < colliders; i++) {
+      this.world.contactPairsWith(body.collider(i), (other) => {
+        other.parent()?.wakeUp();
+      });
+    }
+    this.world.removeRigidBody(body);
+  }
+  // ---- M7 planned feature 3 (b): per-entity physics skip ----
+  /** The planar half of `PhysicsRuntime.setSkipped`; its comment is the whole argument. */
+  setSkipped(collection, id, on) {
+    const key = bodyKey3(collection, id);
+    if (!on) {
+      this.skippedKeys.delete(key);
+      return;
+    }
+    this.skippedKeys.add(key);
+    const existing = this.bodies.get(key);
+    if (!existing) return;
+    this.bodies.delete(key);
+    this.sleepSynced.delete(key);
+    this.sourceRecords.delete(key);
+    this.destroyBody(existing);
+  }
+  isSkipped(collection, id) {
+    return this.skippedKeys.has(bodyKey3(collection, id));
+  }
+  // ---- end M7 planned feature 3 (b) ----
   /** The body behind an instance, created on demand so a handler's own `add` is usable at once. */
   bodyFor(collection, id) {
     const existing = this.bodies.get(bodyKey3(collection, id));
     if (existing) return existing;
+    if (this.skippedKeys.has(bodyKey3(collection, id))) return void 0;
     const desc = this.collections.find((c) => c.name === collection);
     if (!desc) return void 0;
     const coll = plainEntity(this.core.plain, collection);
@@ -2618,6 +3531,7 @@ var Rapier2dRuntime = class {
       for (const id of coll.ids()) {
         const key = bodyKey3(desc.name, id);
         live.add(key);
+        if (this.skippedKeys.has(key)) continue;
         const record = coll.get(id);
         const existing = this.bodies.get(key);
         if (existing) {
@@ -2626,337 +3540,107 @@ var Rapier2dRuntime = class {
           if (source === void 0) {
             this.sourceRecords.set(key, record);
             continue;
-          }
-          if (source === record) continue;
-          this.bodies.delete(key);
-          this.sleepSynced.delete(key);
-          this.sourceRecords.delete(key);
-          this.world.removeRigidBody(existing);
-        }
-        if (record !== void 0) this.create(desc, id, record);
-      }
-    }
-    for (const [key, body] of [...this.bodies]) {
-      if (live.has(key)) continue;
-      this.bodies.delete(key);
-      this.sleepSynced.delete(key);
-      this.sourceRecords.delete(key);
-      this.world.removeRigidBody(body);
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Step and sync
-  // -------------------------------------------------------------------------
-  step() {
-    this.world.step();
-    if (!rapierHasStepped()) noteRapierStep();
-  }
-  /**
-   * Body → schema, through the tracked proxies, so movement leaves the room as an ordinary delta.
-   * Values are `Math.fround`ed for f32 fields, so room code reads exactly what the wire carries.
-   */
-  sync() {
-    for (const desc of this.collections) {
-      const physics = desc.physics;
-      if (!physics) continue;
-      const tracked = this.core.anyState[desc.name];
-      const plainColl = plainEntity(this.core.plain, desc.name);
-      const rounders = roundersFor3(desc);
-      for (const id of plainColl.ids()) {
-        const key = bodyKey3(desc.name, id);
-        const body = this.bodies.get(key);
-        if (!body) continue;
-        if (body.isSleeping()) {
-          if (this.sleepSynced.has(key)) continue;
-          this.sleepSynced.add(key);
-        } else {
-          this.sleepSynced.delete(key);
-        }
-        const record = tracked.get(id);
-        if (!record) continue;
-        const t = body.translation();
-        const v = body.linvel();
-        const state = {
-          x: t.x,
-          y: t.y,
-          angle: body.rotation(),
-          vx: v.x,
-          vy: v.y,
-          angularVelocity: body.angvel()
-        };
-        for (const [channel, field] of physics.channels) {
-          const next = (rounders[field] ?? identity3)(channelOf2d2(channel, state));
-          if (record[field] !== next) record[field] = next;
-        }
-      }
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Hibernation
-  // -------------------------------------------------------------------------
-  /**
-   * The same `PhysicsSection` the 3D runtime writes — a real engine snapshot plus the
-   * entity↔handle map, whose handles must ride as f64 for the reason spelled out on
-   * {@link PhysicsSection}. What tells the two apart on the way back in is the envelope
-   * `core/physics.ts` wraps this in, not anything in here.
-   */
-  serialize() {
-    const bodies = [];
-    for (const [key, body] of this.bodies) {
-      const sep = key.indexOf("\0");
-      bodies.push([key.slice(0, sep), key.slice(sep + 1), body.handle]);
-    }
-    return { world: this.world.takeSnapshot(), bodies };
-  }
-};
-function identity3(v) {
-  return v;
-}
-function roundersFor3(desc) {
-  const out = {};
-  for (const f of desc.fields) {
-    if (f.type.kind === "f32") out[f.name] = Math.fround;
-  }
-  return out;
-}
-
-// src/core/views.ts
-import {
-  collectionDirty,
-  createDirtySet,
-  createFieldMask,
-  encodeDelta as encodeDelta2,
-  encodeSnapshot as encodeSnapshot2,
-  filterDirty,
-  isDirtyEmpty,
-  markAdd,
-  markPath,
-  markRemove,
-  mergeDirty
-} from "@irtio/schema";
-
-// src/core/spatial.ts
-function cellFor(grid, value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  const record = value;
-  const x = record[grid.x];
-  const y = record[grid.y];
-  if (typeof x !== "number" || typeof y !== "number") return void 0;
-  return { x: Math.floor(x / grid.cell), y: Math.floor(y / grid.cell) };
-}
-function cellKey(cell) {
-  return `${cell.x},${cell.y}`;
-}
-function buildSpatialIndex(plain, desc) {
-  if (!desc.grid || desc.kind !== "entity") {
-    throw new Error(`${desc.name}: cannot build an index without an entity grid`);
-  }
-  const collection = plainEntity(plain, desc.name);
-  const buckets = /* @__PURE__ */ new Map();
-  const order = /* @__PURE__ */ new Map();
-  let n = 0;
-  for (const id of collection.ids()) {
-    order.set(id, n++);
-    const cell = cellFor(desc.grid, collection.get(id));
-    if (!cell) continue;
-    const key = cellKey(cell);
-    let ids = buckets.get(key);
-    if (!ids) {
-      ids = /* @__PURE__ */ new Set();
-      buckets.set(key, ids);
-    }
-    ids.add(id);
-  }
-  return { desc, buckets, collection, order };
-}
-function querySpatialIndex(index, clientId, role) {
-  const grid = index.desc.grid;
-  if ((grid.wideRoles ?? []).includes(role)) return new Set(index.collection.ids());
-  const anchor = index.collection.get(clientId);
-  const anchorCell = cellFor(grid, anchor);
-  if (!anchor || !anchorCell) return /* @__PURE__ */ new Set();
-  const candidates = /* @__PURE__ */ new Set();
-  for (let x = anchorCell.x - grid.radius; x <= anchorCell.x + grid.radius; x++) {
-    for (let y = anchorCell.y - grid.radius; y <= anchorCell.y + grid.radius; y++) {
-      const ids = index.buckets.get(cellKey({ x, y }));
-      if (ids) for (const id of ids) candidates.add(id);
-    }
-  }
-  candidates.add(clientId);
-  const ranked = [];
-  for (const id of candidates) if (index.order.has(id)) ranked.push(id);
-  ranked.sort((a, b) => index.order.get(a) - index.order.get(b));
-  return new Set(ranked);
-}
-function buildSpatialIndexes(collections, plain) {
-  const indexes = /* @__PURE__ */ new Map();
-  for (const desc of collections) {
-    if (desc.visibility === "spatial-grid" && desc.grid) {
-      indexes.set(desc.name, buildSpatialIndex(plain, desc));
-    }
-  }
-  return indexes;
-}
-
-// src/core/views.ts
-var cache = /* @__PURE__ */ new WeakMap();
-function infoOf(ext) {
-  let i = cache.get(ext);
-  if (!i) {
-    const scoped = /* @__PURE__ */ new Set();
-    for (const c of ext.collections) {
-      if (c.visibility === "role") for (const r of c.roles ?? []) scoped.add(r);
-    }
-    i = { scoped, names: /* @__PURE__ */ new Map() };
-    cache.set(ext, i);
-  }
-  return i;
-}
-function isVisible(c, role) {
-  return c.visibility !== "role" || (c.roles ?? []).includes(role);
-}
-function visibleTo(role) {
-  return (c) => isVisible(c, role);
-}
-function visibleNames(ext, role) {
-  const info = infoOf(ext);
-  let set = info.names.get(role);
-  if (!set) {
-    set = new Set(
-      ext.collections.filter((c) => isVisible(c, role)).map((c) => c.name)
-    );
-    info.names.set(role, set);
-  }
-  return set;
-}
-function viewKeyFor(ext, role) {
-  return infoOf(ext).scoped.has(role) ? role : "all";
-}
-function encodeViewSnapshot(ext, plain, role, tick, memberships) {
-  return encodeSnapshot2(
-    ext,
-    plain,
-    { tick },
-    {
-      collections: visibleTo(role),
-      entities: (c, id) => c.visibility !== "spatial-grid" || (memberships?.get(c.name)?.has(id) ?? false)
-    }
-  );
-}
-function spatialMemberships(ext, plain, clientId, role, indexes = buildSpatialIndexes(ext.collections, plain)) {
-  const out = /* @__PURE__ */ new Map();
-  for (const [name, index] of indexes) out.set(name, querySpatialIndex(index, clientId, role));
-  return out;
-}
-function createVisibilityPolicy(ext, plain, clientId, role) {
-  const memberships = spatialMemberships(ext, plain, clientId, role);
-  return {
-    memberships,
-    maySeeCollection: (desc) => isVisible(desc, role),
-    maySeeEntity: (desc, id) => isVisible(desc, role) && (desc.visibility !== "spatial-grid" || (memberships.get(desc.name)?.has(id) ?? false)),
-    describeSpatial: (desc, ids) => {
-      const grid = desc.grid;
-      if (desc.visibility !== "spatial-grid" || !grid) return void 0;
-      const coll = plainEntity(plain, desc.name);
-      const at = (id) => {
-        const cell = cellFor(grid, coll.get(id));
-        return cell ? `${id}@(${cell.x},${cell.y})` : `${id}@(no position)`;
-      };
-      return `viewer ${at(clientId)}, ${desc.name} ${ids.map(at).join(" ")}, radius ${grid.radius}`;
-    }
-  };
-}
-function sharedViewDirty(ext, dirty, role) {
-  return filterDirty(dirty, (name) => {
-    const desc = ext.collection(name);
-    return desc.visibility !== "spatial-grid" && isVisible(desc, role);
-  });
-}
-function aoiViewDirty(ext, dirty, previous, current) {
-  const out = createDirtySet();
-  for (const desc of ext.collections) {
-    if (desc.visibility !== "spatial-grid") continue;
-    const before = previous.get(desc.name) ?? /* @__PURE__ */ new Set();
-    const now = current.get(desc.name) ?? /* @__PURE__ */ new Set();
-    for (const id of before) if (!now.has(id)) markRemove(out, desc.name, id);
-    for (const id of now) if (!before.has(id)) markAdd(out, desc.name, id);
-    const changed = dirty.get(desc.name);
-    if (!changed) continue;
-    const visibleChanges = createDirtySet();
-    const collection = collectionDirty(visibleChanges, desc.name);
-    for (const id of changed.added) if (now.has(id)) collection.added.add(id);
-    for (const id of changed.removed) if (before.has(id)) collection.removed.add(id);
-    for (const [id, record] of changed.updated) {
-      if (before.has(id) && now.has(id)) collection.updated.set(id, record);
+          }
+          if (source === record) continue;
+          this.bodies.delete(key);
+          this.sleepSynced.delete(key);
+          this.sourceRecords.delete(key);
+          this.destroyBody(existing);
+        }
+        if (record !== void 0) this.create(desc, id, record);
+      }
     }
-    mergeDirty(out, visibleChanges);
-  }
-  return out;
-}
-function membershipSafeDirty(ext, dirty, memberships) {
-  const out = createDirtySet();
-  for (const [name, changed] of dirty) {
-    const desc = ext.collection(name);
-    if (desc.visibility !== "spatial-grid") {
-      out.set(name, changed);
-      continue;
+    for (const [key, body] of [...this.bodies]) {
+      if (live.has(key)) continue;
+      this.bodies.delete(key);
+      this.sleepSynced.delete(key);
+      this.sourceRecords.delete(key);
+      this.destroyBody(body);
     }
-    const visible = memberships.get(name) ?? /* @__PURE__ */ new Set();
-    const kept = collectionDirty(out, name);
-    for (const id of changed.added) if (visible.has(id)) kept.added.add(id);
-    for (const id of changed.removed) if (visible.has(id)) kept.removed.add(id);
-    for (const [id, record] of changed.updated) if (visible.has(id)) kept.updated.set(id, record);
+    for (const key of [...this.skippedKeys]) if (!live.has(key)) this.skippedKeys.delete(key);
   }
-  return out;
-}
-function encodeViewDelta(ext, plain, dirty, role, tick) {
-  const keep = visibleNames(ext, role);
-  const filtered = filterDirty(dirty, (name) => keep.has(name));
-  if (isDirtyEmpty(filtered)) return null;
-  return encodeDelta2(ext, plain, filtered, { tick });
-}
-function stripAdds(plain, dirty, suppress) {
-  if (suppress.size === 0) return dirty;
-  const out = /* @__PURE__ */ new Map();
-  for (const [name, cd] of dirty) {
-    const captured = suppress.get(name);
-    if (!captured || captured.size === 0 || cd.added.size === 0) {
-      out.set(name, cd);
-      continue;
+  // -------------------------------------------------------------------------
+  // Step and sync
+  // -------------------------------------------------------------------------
+  step() {
+    this.world.step();
+    if (!rapierHasStepped()) noteRapierStep();
+  }
+  /**
+   * Body → schema, through the tracked proxies, so movement leaves the room as an ordinary delta.
+   * Values are `Math.fround`ed for f32 fields, so room code reads exactly what the wire carries.
+   */
+  sync() {
+    for (const desc of this.collections) {
+      const physics = desc.physics;
+      if (!physics) continue;
+      const tracked = this.core.anyState[desc.name];
+      const plainColl = plainEntity(this.core.plain, desc.name);
+      const rounders = roundersFor3(desc);
+      for (const id of plainColl.ids()) {
+        const key = bodyKey3(desc.name, id);
+        const body = this.bodies.get(key);
+        if (!body) continue;
+        if (body.isSleeping()) {
+          if (this.sleepSynced.has(key)) continue;
+          this.sleepSynced.add(key);
+        } else {
+          this.sleepSynced.delete(key);
+        }
+        const record = tracked.get(id);
+        if (!record) continue;
+        const t = body.translation();
+        const v = body.linvel();
+        const state = {
+          x: t.x,
+          y: t.y,
+          angle: body.rotation(),
+          vx: v.x,
+          vy: v.y,
+          angularVelocity: body.angvel()
+        };
+        for (const [channel, field] of physics.channels) {
+          const next = (rounders[field] ?? identity3)(channelOf2d2(channel, state));
+          if (record[field] !== next) record[field] = next;
+        }
+      }
     }
-    const coll = plainEntity(plain, name);
-    let added = cd.added;
-    for (const id of captured.keys()) {
-      if (!added.has(id)) continue;
-      const c = captured.get(id);
-      if (coll.ownerOf(id) !== c.owner || !deepEqual(coll.get(id), c.value)) continue;
-      if (added === cd.added) added = new Set(cd.added);
-      added.delete(id);
+  }
+  // -------------------------------------------------------------------------
+  // Hibernation
+  // -------------------------------------------------------------------------
+  /**
+   * The same `PhysicsSection` the 3D runtime writes — a real engine snapshot plus the
+   * entity↔handle map, whose handles must ride as f64 for the reason spelled out on
+   * {@link PhysicsSection}. What tells the two apart on the way back in is the envelope
+   * `core/physics.ts` wraps this in, not anything in here.
+   */
+  serialize() {
+    const bodies = [];
+    for (const [key, body] of this.bodies) {
+      const sep = key.indexOf("\0");
+      bodies.push([key.slice(0, sep), key.slice(sep + 1), body.handle]);
     }
-    out.set(name, added === cd.added ? cd : { added, removed: cd.removed, updated: cd.updated });
+    const skipped = [...this.skippedKeys];
+    const unsynced = [];
+    for (const [key, body] of this.unsyncedBodies) unsynced.push([key, body.handle]);
+    return {
+      world: this.world.takeSnapshot(),
+      bodies,
+      ...skipped.length > 0 ? { skipped } : {},
+      ...unsynced.length > 0 ? { unsynced } : {}
+    };
   }
-  return out;
+};
+function identity3(v) {
+  return v;
 }
-function catchUpDirty(ext, plain, fromRole, toRole) {
-  const dirty = createDirtySet();
-  for (const c of ext.collections) {
-    const was = isVisible(c, fromRole);
-    const now = isVisible(c, toRole);
-    if (was === now) continue;
-    if (c.kind === "singleton") {
-      if (!now) continue;
-      const mask = createFieldMask();
-      for (const f of c.fields) markPath(mask, [f.index]);
-      collectionDirty(dirty, c.name).updated.set("", { mask, owner: false });
-      continue;
-    }
-    const coll = plainEntity(plain, c.name);
-    for (const id of [...coll.ids()]) {
-      if (now) markAdd(dirty, c.name, id);
-      else markRemove(dirty, c.name, id);
-    }
+function roundersFor3(desc) {
+  const out = {};
+  for (const f of desc.fields) {
+    if (f.type.kind === "f32") out[f.name] = Math.fround;
   }
-  return dirty;
+  return out;
 }
 
 // src/core/snapshot.ts
@@ -3089,15 +3773,17 @@ import {
 } from "@irtio/protocol";
 import {
   cloneValue as cloneValue2,
-  createDirtySet as createDirtySet2,
+  createDirtySet as createDirtySet3,
   createState,
   decodeSnapshot as decodeSnapshot3,
   encodeDelta as encodeDelta5,
   encodeSnapshot as encodeSnapshot4,
+  filterDirty as filterDirty2,
   isDirtyEmpty as isDirtyEmpty4,
   track,
   validateForDeploy
 } from "@irtio/schema";
+import { DenyError as DenyError2 } from "@irtio/server";
 
 // src/core/history.ts
 var HISTORY_MAX_TICKS = 240;
@@ -4541,9 +5227,10 @@ function takeClip(core, seconds) {
   if (!replayArmed(core)) {
     return rejectAsEvent(
       core,
-      new Error(
-        "room.replay.clip: this room type did not declare `replay:`, so nothing is being recorded. Add `replay: { seconds: 60 }` to the room config to arm the ring."
-      )
+      // Bug #81: written to fit the platform's 96-byte bound rather than be clamped to it. Every
+      // refusal below is, for the same reason: a message the clamp cuts loses its fix line, which
+      // is the half worth reading.
+      new Error("room.replay.clip: this room did not declare `replay:`, so nothing is recorded")
     );
   }
   const state = stateOf6(core);
@@ -4558,7 +5245,7 @@ function takeClip(core, seconds) {
     return rejectAsEvent(
       core,
       new Error(
-        `E_CLIP_COOLDOWN: room.replay.clip allows bursts of ${CLIP_BURST}, refilled one every ${CLIP_COOLDOWN_MS}ms per room; this room is out of clip tokens right now`
+        `E_CLIP_COOLDOWN: room.replay.clip allows ${CLIP_BURST} per room, one refilled every ${CLIP_COOLDOWN_MS}ms`
       )
     );
   }
@@ -4566,7 +5253,7 @@ function takeClip(core, seconds) {
     return rejectAsEvent(
       core,
       new Error(
-        `E_CLIP_DISARMED: recording stopped in this room because a single replay keyframe was larger than the ${REPLAY_RING_MAX_BYTES}-byte replay ring; see the warning on this room's log`
+        `E_CLIP_DISARMED: recording stopped: a keyframe was larger than the ${REPLAY_RING_MAX_BYTES}-byte ring`
       )
     );
   }
@@ -4582,7 +5269,7 @@ function takeClip(core, seconds) {
   if (bytes === void 0) {
     return rejectAsEvent(
       core,
-      new Error("E_CLIP_EMPTY: the replay ring is empty \u2014 this room has not flushed a change yet")
+      new Error("E_CLIP_EMPTY: the replay ring is empty; this room has not flushed a change yet")
     );
   }
   if (bytes.length > CLIP_MAX_BYTES) {
@@ -4605,9 +5292,7 @@ function takeExcerpt(core, options) {
   if (!replayArmed(core)) {
     return rejectAsEvent(
       core,
-      new Error(
-        "E_REPLAY_UNARMED: room.replay.excerpt: this room type did not declare `replay:`, so nothing is being recorded. Add `replay: { seconds: 60 }` to the room config to arm the ring."
-      )
+      new Error("E_REPLAY_UNARMED: room.replay.excerpt: this room did not declare `replay:`")
     );
   }
   const seconds = options?.seconds;
@@ -4615,7 +5300,7 @@ function takeExcerpt(core, options) {
     return rejectAsEvent(
       core,
       new Error(
-        "E_EXCERPT_BAD_ARGS: room.replay.excerpt needs { seconds } as a positive number, got " + JSON.stringify(seconds)
+        "E_EXCERPT_BAD_ARGS: room.replay.excerpt needs { seconds } as a positive number, got " + String(JSON.stringify(seconds)).slice(0, 8)
       )
     );
   }
@@ -4623,7 +5308,7 @@ function takeExcerpt(core, options) {
     return rejectAsEvent(
       core,
       new Error(
-        `E_EXCERPT_TOO_LONG: room.replay.excerpt decodes at most ${EXCERPT_MAX_SECONDS} seconds at a time and was asked for ${seconds}. An excerpt is a killcam, not a match; for a whole match use \`replay: { record: true }\`.`
+        `E_EXCERPT_TOO_LONG: at most ${EXCERPT_MAX_SECONDS} seconds an excerpt, and ${seconds} was asked for`
       )
     );
   }
@@ -4632,9 +5317,7 @@ function takeExcerpt(core, options) {
     return rejectAsEvent(
       core,
       new Error(
-        `E_EXCERPT_BAD_ARGS: room.replay.excerpt was asked for the collection ${JSON.stringify(
-          badName
-        )}, which is not an entity collection in this room's schema. Singleton collections are not excerptable.`
+        `E_EXCERPT_BAD_ARGS: ${JSON.stringify(badName)} is not an entity collection here; singletons are not excerptable`
       )
     );
   }
@@ -4643,7 +5326,7 @@ function takeExcerpt(core, options) {
     return rejectAsEvent(
       core,
       new Error(
-        `E_EXCERPT_DISARMED: recording stopped in this room because a single replay keyframe was larger than the ${REPLAY_RING_MAX_BYTES}-byte replay ring; see the warning on this room's log`
+        `E_EXCERPT_DISARMED: recording stopped: a keyframe was larger than the ${REPLAY_RING_MAX_BYTES}-byte ring`
       )
     );
   }
@@ -4658,7 +5341,7 @@ function takeExcerpt(core, options) {
     return rejectAsEvent(
       core,
       new Error(
-        `E_EXCERPT_COOLDOWN: room.replay.excerpt allows bursts of ${EXCERPT_BURST}, refilled one every ${EXCERPT_COOLDOWN_MS}ms per room; this room is out of excerpt tokens right now`
+        `E_EXCERPT_COOLDOWN: room.replay.excerpt allows ${EXCERPT_BURST} per room, one every ${EXCERPT_COOLDOWN_MS}ms`
       )
     );
   }
@@ -4672,7 +5355,7 @@ function takeExcerpt(core, options) {
       return rejectAsEvent(
         core,
         new Error(
-          `E_EXCERPT_TOO_LARGE: this excerpt would materialize about ${err.bytes} bytes of frames and the limit is ${EXCERPT_MAX_BYTES}. Ask for fewer seconds, or name the collections (and ids) you actually need in \`collections\`/\`ids\`.`
+          `E_EXCERPT_TOO_LARGE: about ${err.bytes} bytes and the limit is ${EXCERPT_MAX_BYTES}; narrow collections/ids`
         )
       );
     }
@@ -4848,11 +5531,25 @@ function noteRecordingRepliesDropped(core) {
 // src/core/room-api.ts
 import {
   FrameType as FrameType5,
+  HELLO_ROLE_MAX_BYTES,
   busChannelProblem,
   busPayloadProblem,
   encodeFrame as encodeFrame4
 } from "@irtio/protocol";
-import { encodeDelta as encodeDelta4, encodeFields as encodeFields2, isDirtyEmpty as isDirtyEmpty3 } from "@irtio/schema";
+import { createDirtySet as createDirtySet2, encodeDelta as encodeDelta4, encodeFields as encodeFields2, isDirtyEmpty as isDirtyEmpty3, utf8Length } from "@irtio/schema";
+function skipApi(p) {
+  return {
+    skip(collection, id, on = true) {
+      p.setSkipped(collection, id, on);
+    },
+    skipped(collection, id) {
+      return p.isSkipped(collection, id);
+    },
+    // M7 pf3 (a): handed through untouched. The registry is built by the engine runtime, which is
+    // the only place that knows how to build and destroy one of that engine's bodies.
+    unsynced: p.unsynced
+  };
+}
 function makePhysicsApi(p) {
   return {
     get rapier() {
@@ -4866,7 +5563,8 @@ function makePhysicsApi(p) {
     },
     body(collection, id) {
       return p.bodyFor(collection, id);
-    }
+    },
+    ...skipApi(p)
   };
 }
 function makeMatterApi(p) {
@@ -4882,7 +5580,8 @@ function makeMatterApi(p) {
     },
     body(collection, id) {
       return p.bodyFor(collection, id);
-    }
+    },
+    ...skipApi(p)
   };
 }
 function makeRapier2dApi(p) {
@@ -4898,6 +5597,17 @@ function makeRapier2dApi(p) {
     },
     body(collection, id) {
       return p.bodyFor(collection, id);
+    },
+    ...skipApi(p)
+  };
+}
+function makeMetrics(core) {
+  return {
+    get physicsStepMs() {
+      return core.stats.physicsStepMs;
+    },
+    get physicsStepMsAvg() {
+      return core.stats.physicsStepMsAvg;
     }
   };
 }
@@ -5017,6 +5727,7 @@ function createRoomApi(core, publicUrl) {
   let physicsApi;
   let matterApi;
   let rapier2dApi;
+  let metricsApi;
   let kvApi;
   let busApi;
   let leaderboardApi;
@@ -5076,6 +5787,43 @@ function createRoomApi(core, publicUrl) {
     random() {
       return core.rng.next();
     },
+    // ---- M7 planned feature 3 (f): room.metrics ----
+    // Undercity feedback 2: no timing has ever existed around the platform-stepped world, so a
+    // room that wanted to know what its physics cost had to step its own engine outside the
+    // `physics:` block and lose everything the block does for it. Live getters over `RoomStats`,
+    // not a copied snapshot, so reading `room.metrics` allocates nothing on a tick loop.
+    get metrics() {
+      return metricsApi ?? (metricsApi = makeMetrics(core));
+    },
+    // ---- end M7 planned feature 3 (f) ----
+    // ---- M7 planned feature 3 (g): the stale-writer query ----
+    // Undercity feedback 20. A backgrounded tab stops writing and keeps its socket up, so the
+    // room goes on attacking the last position it reported. Everything needed to see that is
+    // already kept — `lastAppliedTick` is stamped on every judged WRITE for the correction
+    // header (bug 1) — so this is a read over existing bookkeeping and not a new mechanism: no
+    // callback, no config, no wire change, and no opinion about what a room should do about it.
+    // The policy is the room's, and it differs per game (freeze the avatar, stop targeting it,
+    // hand it to an NPC driver, kick it), which is exactly why there is no hook here.
+    writerStaleness(clientId) {
+      const entry = core.clients.get(clientId);
+      if (!entry) return void 0;
+      const since = entry.lastAppliedTick === 0 ? entry.joinedTick : entry.lastAppliedTick;
+      const ticks = core.tick - since;
+      return ticks > 0 ? ticks : 0;
+    },
+    staleWriters(ticks) {
+      if (!Number.isFinite(ticks) || ticks < 0) {
+        throw new Error(`room.staleWriters: ticks must be a non-negative number, got ${ticks}`);
+      }
+      const out = [];
+      for (const entry of core.clients.values()) {
+        if (!entry.connected) continue;
+        const since = entry.lastAppliedTick === 0 ? entry.joinedTick : entry.lastAppliedTick;
+        if (core.tick - since >= ticks) out.push(entry.clientId);
+      }
+      return out;
+    },
+    // ---- end M7 planned feature 3 (g) ----
     // D22. A single object, built once: `room.physics` is read on every tick of a physics room.
     // In a room with no `physics:` config, touching it is a mistake worth naming loudly rather
     // than a silent `undefined` that shows up three frames later as "cannot read world of
@@ -5140,6 +5888,11 @@ function createRoomApi(core, publicUrl) {
     kick(clientId, reason) {
       core.host.kick(clientId, "E_KICKED", reason);
     },
+    // ---- M8 lane 5: moderation ----
+    ban(clientId, options) {
+      return core.banClient(clientId, options?.reason, options?.minutes);
+    },
+    // ---- end M8 lane 5 ----
     close(reason) {
       core.host.close(reason);
     },
@@ -5295,28 +6048,40 @@ function isAlarmName(core, name, where) {
   }
   return true;
 }
+function checkRoleValue(role) {
+  const bytes = utf8Length(role);
+  if (bytes > HELLO_ROLE_MAX_BYTES) {
+    throw new Error(
+      `room.setRole: role exceeds ${HELLO_ROLE_MAX_BYTES} UTF-8 bytes (${bytes}): ${JSON.stringify(role)}. A longer role cannot be encoded into WELCOME, so the room would fail every later wake.`
+    );
+  }
+  for (let i = 0; i < role.length; i++) {
+    const code = role.charCodeAt(i);
+    if (code > 31 && code !== 127) continue;
+    throw new Error(
+      `room.setRole: role contains a control character (0x${code.toString(16)}): ${JSON.stringify(role)}. Roles are printed into logs, events and operator tooling.`
+    );
+  }
+}
 function setRole(core, clientId, role) {
   const entry = core.clients.get(clientId);
   if (!entry) {
     core.log("warn", `room.setRole: unknown client ${clientId}`);
     return;
   }
+  checkRoleValue(role);
   const roles = core.definition.schema.roles;
   if (roles.length > 0 && !roles.includes(role)) {
     core.log("warn", `room.setRole: ${JSON.stringify(role)} is not a schema role; ignored`);
     return;
   }
   if (entry.role === role) return;
-  const dirty = catchUpDirty(core.ext, core.plain, entry.role, role);
-  if (!isDirtyEmpty3(dirty)) {
-    core.send(
-      clientId,
-      encodeFrame4(FrameType5.DELTA, encodeDelta4(core.ext, core.plain, dirty, { tick: core.tick }))
-    );
-  }
-  entry.role = role;
+  const dirty = entry.welcomed ? catchUpDirty(core.ext, core.plain, entry.role, role) : createDirtySet2();
+  const catchUp = isDirtyEmpty3(dirty) ? void 0 : encodeFrame4(FrameType5.DELTA, encodeDelta4(core.ext, core.plain, dirty, { tick: core.tick }));
   const presence = core.anyState.clients.get(clientId);
   if (presence) presence.role = role;
+  entry.role = role;
+  if (catchUp) core.send(clientId, catchUp);
   core.invalidateClients();
 }
 function checkNpcConfig(core, config) {
@@ -5367,6 +6132,7 @@ var NPC_EXAMPLE = "{ brain: { kind: 'script', script: 'chaser' } }";
 // src/core/room.ts
 var DEFAULT_PUBLIC_URL = "http://localhost/";
 var CONTINUATION_FLUSH_TURNS = 8;
+var ADMIT_BUDGET_MS = 50;
 function ownJoinCapture(plain, name, added, clientId) {
   const coll = plainEntity(plain, name);
   let mine;
@@ -5389,7 +6155,14 @@ var RoomCore = class _RoomCore {
   rng;
   clients = /* @__PURE__ */ new Map();
   loop;
-  /** D22: the Rapier world, or `undefined` in a room whose config declares no physics. */
+  /**
+   * D22: the Rapier world, or `undefined` in a room whose config declares no physics.
+   *
+   * Not `readonly`, and the reason is M7 pf3 (a): each builder installs the runtime here *before*
+   * it calls `runSetup`, so `room.physics*` is readable from inside `physics.setup`. That is
+   * where an unsynced body belongs — it is static geometry with a handle — and it is the only
+   * place a matter2d room can put one and have it come back after a wake.
+   */
   physics;
   stats = {
     ticks: 0,
@@ -5406,6 +6179,8 @@ var RoomCore = class _RoomCore {
     gridBuildMs: 0,
     gridQueryMs: 0,
     aoiEncodeMs: 0,
+    physicsStepMs: 0,
+    physicsStepMsAvg: 0,
     visibleIdsTotal: 0,
     membershipEnters: 0,
     membershipLeaves: 0,
@@ -5431,6 +6206,11 @@ var RoomCore = class _RoomCore {
    * end of every tick, which is the only moment in a tick where that state is settled.
    */
   recorder;
+  /**
+   * M7 pf4: the RPC trace ring, constructed only when `RoomCoreOptions.traceRpc` asked for one.
+   * Every cost this lane has is behind this `undefined` — see `core/rpc-trace.ts`.
+   */
+  rpcTraceRing;
   /**
    * D65: the bandwidth ledger, present only when `RoomCoreOptions.profile` asked for one. Every
    * cost the profiler has is behind this `undefined`.
@@ -5456,6 +6236,7 @@ var RoomCore = class _RoomCore {
     this.mode = definition.config.mode;
     this.ext = withBuiltins2(definition.schema);
     this.ledger = options.profile === true ? new ProfileLedger(this.ext, definition.schema) : void 0;
+    this.rpcTraceRing = options.traceRpc === true ? new RpcTraceRing() : void 0;
     for (const issue of validateForDeploy(this.ext)) {
       if (issue.level === "error") throw new Error(`RoomCore: ${issue.message}`);
       host.log("warn", [`irtio: ${issue.message}`]);
@@ -5469,7 +6250,13 @@ var RoomCore = class _RoomCore {
       restored = candidate;
     }
     if (restored) {
-      plain = decodeSnapshot3(this.ext, restored.snapshot).state;
+      plain = decodeSnapshot3(this.ext, restored.snapshot, {
+        onNonFinite: (path, value) => {
+          host.log("warn", [
+            `irtio: room ${options.roomId}: restored ${path} held ${value}; reset to its default`
+          ]);
+        }
+      }).state;
       const presence = plainEntity(plain, PRESENCE_COLLECTION);
       for (const id of [...presence.ids()]) presence.remove(id);
       if (restored.mode !== this.mode) {
@@ -5636,6 +6423,7 @@ var RoomCore = class _RoomCore {
           `irtio: no physics world in this snapshot (format v${restored.version}) \u2014 rebuilding it from schema state and re-running physics.setup; contact state is not restored`
         ]);
       }
+      this.physics = physics;
       physics.runSetup(this.room);
       physics.reconcile();
     }
@@ -5675,6 +6463,7 @@ var RoomCore = class _RoomCore {
         `irtio: no matter2d world in this snapshot (format v${restored.version}). Rebuilding it from schema state and re-running physics.setup; contact state is not restored.`
       ]);
     }
+    this.physics = physics;
     physics.runSetup(this.room);
     physics.reconcile();
     return physics;
@@ -5712,6 +6501,7 @@ var RoomCore = class _RoomCore {
           `irtio: no rapier2d world in this snapshot (format v${restored.version}) \u2014 rebuilding it from schema state and re-running physics.setup; contact state is not restored`
         ]);
       }
+      this.physics = physics;
       physics.runSetup(this.room);
       physics.reconcile();
     }
@@ -5781,6 +6571,25 @@ var RoomCore = class _RoomCore {
   captureTimeline() {
     this.recorder?.capture(this.tick, this.ext, this.plain);
   }
+  /**
+   * M7 pf4: file one RPC on the trace. Called from `core/rpc.ts` on every exit path a call has,
+   * and a no-op — not merely a cheap one, an untaken branch — in a room nobody armed.
+   */
+  recordRpc(entry) {
+    this.rpcTraceRing?.push(entry);
+  }
+  /**
+   * M7 pf4: whether this room has a trace ring at all. Read **before** an entry is built, so an
+   * unarmed room pays one property read per call rather than building an entry object and
+   * serializing a result for `recordRpc` to drop on the floor.
+   */
+  get rpcTraceArmed() {
+    return this.rpcTraceRing !== void 0;
+  }
+  /** M7 pf4: the trace so far, or `undefined` when this room was not armed. */
+  rpcTrace() {
+    return this.rpcTraceRing?.dump();
+  }
   // ---- M6 lane F: rewind ----
   /**
    * D72: record this tick's body poses, right after `physics.sync()` — the poses the clients are
@@ -5879,9 +6688,23 @@ var RoomCore = class _RoomCore {
       // ---- end M6 lane K ----
     );
   }
+  /**
+   * The earliest pending room timer's due time at the last `serialize()`, on `host.now()`'s
+   * clock, or `undefined` if nothing was armed.
+   *
+   * `serialize()` is the departure, and it drops every room timer because a callback is a closure
+   * and there is nothing to persist. The *deadline* is persistable, though, and this is where the
+   * worker reads it to hand to the supervisor, which arms a wake for it. The contract room code
+   * gets: your callback does not survive hibernation, but your room is awake again at or shortly
+   * after the time it would have fired — so keep the deadline in state and catch up in `onWake`.
+   *
+   * Captured before `clearAllTimers()`, which is the only ordering that could ever have worked.
+   */
+  lastSerializeTimerAt;
   serialize() {
     const onSleep = this.definition.config.onSleep;
     if (onSleep) this.guard("onSleep", () => onSleep(this.state, this.room));
+    this.lastSerializeTimerAt = this.loop.earliestTimerAt();
     this.loop.clearAllTimers();
     cancelAllAsks(this.internals);
     rejectAllPending(this.internals, "room is hibernating");
@@ -5914,6 +6737,92 @@ var RoomCore = class _RoomCore {
     );
     return roles[0] ?? "";
   }
+  // ---- M8 lane 5: moderation ----
+  /**
+   * Subjects `room.ban` has excluded, and when each stops being excluded. Values are wall-clock
+   * deadlines from `host.now()`; `Number.POSITIVE_INFINITY` is the default, "until this room
+   * closes".
+   *
+   * In memory and nowhere else, by decision. It is not in `state`, so it is not in a snapshot, so a
+   * hibernation drops it and a wake starts clean — the same call relay audience membership made,
+   * and for the same reason: this is a fact about a sitting, not about a save file. Exclusion that
+   * outlives a wake is what the control plane's `project_bans` is for, and that one is durable
+   * because it is a row in a database rather than a `Map` in a worker.
+   */
+  banned = /* @__PURE__ */ new Map();
+  /**
+   * The room's own refusal, before a seat exists. Throws {@link AdmissionError} or returns.
+   *
+   * Order matters and is deliberate: the cooldown is checked first, so a subject the room already
+   * threw out cannot spend the room's `onAdmit` budget on every reconnect attempt.
+   */
+  admit(clientId, options) {
+    const subject = options.subject;
+    if (subject !== void 0) {
+      const until = this.banned.get(subject);
+      if (until !== void 0) {
+        if (until > this.host.now()) {
+          throw new AdmissionError("banned from this room");
+        }
+        this.banned.delete(subject);
+      }
+    }
+    const onAdmit = this.definition.config.onAdmit;
+    if (!onAdmit) return;
+    const ctx = {
+      clientId,
+      subject,
+      role: this.resolveRole(options.role, void 0),
+      name: options.name ?? "",
+      tick: this.tick,
+      deny: (reason) => {
+        throw new DenyError2(reason);
+      },
+      require: (condition, reason) => {
+        if (!condition) throw new DenyError2(reason);
+      }
+    };
+    const startedAt = this.host.now();
+    let denied;
+    const ran = this.tryRun("onAdmit", () => {
+      try {
+        onAdmit(this.state, ctx);
+      } catch (err) {
+        if (err instanceof DenyError2) {
+          denied = err.reason;
+          return;
+        }
+        throw err;
+      }
+    });
+    const elapsed = this.host.now() - startedAt;
+    if (elapsed > ADMIT_BUDGET_MS) {
+      this.log(
+        "error",
+        `onAdmit took ${Math.round(elapsed)}ms (budget ${ADMIT_BUDGET_MS}ms); join refused`
+      );
+      throw new AdmissionError("admission timed out");
+    }
+    if (denied !== void 0) throw new AdmissionError(denied);
+    if (!ran.ok) throw new AdmissionError("admission check failed");
+  }
+  /**
+   * `room.ban`: kick this client and keep its subject out for a while.
+   *
+   * Returns the subject it excluded, or `undefined` when there was nothing durable to exclude —
+   * a key join, whose only name is a client id it can mint again. The kick happens either way,
+   * because a kick is a real thing to do to a session even when the exclusion cannot follow it.
+   */
+  banClient(clientId, reason, minutes) {
+    this.host.kick(clientId, "E_KICKED", reason);
+    const subject = this.clients.get(clientId)?.subject;
+    if (subject === void 0) return void 0;
+    const until = minutes === void 0 || !Number.isFinite(minutes) || minutes <= 0 ? Number.POSITIVE_INFINITY : this.host.now() + minutes * 6e4;
+    const existing = this.banned.get(subject) ?? 0;
+    this.banned.set(subject, Math.max(existing, until));
+    return subject;
+  }
+  // ---- end M8 lane 5 ----
   join(clientId, options = {}) {
     const existing = this.clients.get(clientId);
     if (this.stopped) {
@@ -5933,6 +6842,8 @@ var RoomCore = class _RoomCore {
     }
     const presence = this.presence;
     const maxClients = this.definition.config.maxClients;
+    const resuming = options.reconnecting === true || presence.has(clientId);
+    if (!resuming) this.admit(clientId, options);
     if (!presence.has(clientId) && presence.size >= maxClients) {
       throw new RoomFullError(maxClients);
     }
@@ -5966,20 +6877,29 @@ var RoomCore = class _RoomCore {
       // the other tab" rather than as a line in this file.
       // ---- end M6 lane K ----
       playerId: options.playerId ?? clientId,
+      // M8 lane 5: the narrower fact beside the one above. See `JoinOptions.subject`.
+      subject: options.subject,
       npc: options.npc === true,
       role,
       name,
       connected: true,
+      welcomed: false,
       correction: void 0,
       accepted: /* @__PURE__ */ new Map(),
       lastClientTick: 0,
       lastAppliedTick: 0,
+      // M7 pf3 (g): the baseline `room.writerStaleness` measures from until this client's first
+      // write lands. Without it a client that has just joined reads as `room.tick` ticks stale,
+      // so in a room that has been up an hour every new joiner is instantly the worst offender.
+      joinedTick: this.tick,
       pendingJoinAdds: void 0,
       spatialMembership: /* @__PURE__ */ new Map()
     };
     entry.role = role;
     entry.name = name;
     entry.connected = true;
+    entry.welcomed = false;
+    entry.joinedTick = this.tick;
     this.clients.set(clientId, entry);
     this.invalidateClients();
     reclaimHolds(this.internals, clientId, entry.playerId);
@@ -5994,6 +6914,7 @@ var RoomCore = class _RoomCore {
     const memberships = spatialMemberships(this.ext, this.plain, clientId, entry.role);
     entry.spatialMembership = memberships;
     const snapshot = encodeViewSnapshot(this.ext, this.plain, entry.role, this.tick, memberships);
+    entry.welcomed = true;
     this.ledger?.attributeSnapshot("out", snapshot);
     const pending = /* @__PURE__ */ new Map();
     for (const [name2, cd] of this.tracked.dirty) {
@@ -6039,6 +6960,7 @@ var RoomCore = class _RoomCore {
     this.presence.remove(clientId);
     this.recordEvent("leave", clientId, reason);
     rejectPendingFor(this.internals, clientId, "client disconnected");
+    this.rpcTraceRing?.forget(clientId);
     this.loop.dropFramesFor(clientId);
     this.clients.delete(clientId);
     this.stats.bytesOutByClient.delete(clientId);
@@ -6071,7 +6993,15 @@ var RoomCore = class _RoomCore {
       // other entry point (join, leave, write, ownership) has no client tick by construction.
       clientTick: void 0,
       reconnecting,
-      room: this.room
+      room: this.room,
+      // M7 pf4 (a): on every ctx rather than only the RPC one, because the type says it is there.
+      // `rpc.ts` is what turns the throw into an `ok: false` reply; anywhere else it is a throw.
+      deny: (reason) => {
+        throw new DenyError2(reason);
+      },
+      require: (condition, reason) => {
+        if (!condition) throw new DenyError2(reason);
+      }
     };
   }
   /**
@@ -6138,7 +7068,7 @@ var RoomCore = class _RoomCore {
   correctionFor(clientId) {
     const entry = this.clients.get(clientId);
     if (!entry) return void 0;
-    if (!entry.correction) entry.correction = createDirtySet2();
+    if (!entry.correction) entry.correction = createDirtySet3();
     return entry.correction;
   }
   invalidateClients() {
@@ -6296,9 +7226,13 @@ var RoomCore = class _RoomCore {
           if (crossed) (churn ??= /* @__PURE__ */ new Map()).set(name, crossed);
         }
         if (entry.correction) {
+          const keep = visibleNames(this.ext, entry.role);
           const payload = encodeCorrection(
             this.internals,
-            membershipSafeDirty(this.ext, entry.correction, memberships)
+            filterDirty2(
+              membershipSafeDirty(this.ext, entry.correction, memberships),
+              (name) => keep.has(name)
+            )
           );
           if (payload) {
             this.send(
@@ -6398,6 +7332,8 @@ function encodeSection(physics) {
 export {
   HOST_CALL_TIMEOUT_MS,
   RoomFullError,
+  AdmissionError,
+  PHYSICS_STEP_EMA_ALPHA,
   RELAY_STATE_BYTES,
   RELAY_RECORDS_PER_COLLECTION,
   RELAY_WRITES_PER_SECOND,
@@ -6405,14 +7341,22 @@ export {
   RELAY_WRITE_CAPS,
   EVENT_RING_SIZE,
   inspectState,
+  HOLD_ACTIONS,
+  RPC_TRACE_SIZE,
+  RPC_TRACE_SUMMARY_MAX,
+  summarize,
+  RpcTraceRing,
+  isVisible,
+  visibleTo,
+  visibleNames,
+  viewKeyFor,
+  encodeViewSnapshot,
+  createVisibilityPolicy,
+  encodeViewDelta,
+  catchUpDirty,
   RPC_TIMEOUT_MS,
   MAX_CATCHUP,
   CRASH_AFTER_THROWS,
-  initMatter,
-  loadedMatter,
-  resetMatterForTests,
-  encodeMatterBodies,
-  decodeMatterBodies,
   initPhysics,
   loadedPhysics,
   resetPhysicsForTests,
@@ -6425,21 +7369,19 @@ export {
   encodeMatterSectionEnvelope,
   decodeMatterSectionEnvelope,
   decodePhysicsSection,
+  initMatter,
+  loadedMatter,
+  resetMatterForTests,
+  encodeMatterBodies,
+  decodeMatterBodies,
   Mulberry32,
   initRapier2d,
   loadedRapier2d,
   resetRapier2dForTests,
-  isVisible,
-  visibleTo,
-  visibleNames,
-  viewKeyFor,
-  encodeViewSnapshot,
-  createVisibilityPolicy,
-  encodeViewDelta,
-  catchUpDirty,
   SNAPSHOT_FORMAT_VERSION,
   READABLE_SNAPSHOT_VERSIONS,
   parseHibernationBlob,
+  sameSchemaHash,
   writeHibernationBlob,
   decodeSave,
   DEFAULT_TIMELINE_MAX_TICKS,