@irtio/runtime 0.2.0 → 0.4.0

package/dist/{chunk-GKMD3ICD.js → chunk-5ZDQAAFJ.js}

@@ -421,7 +421,10 @@ function applyWrite(core, clientId, payload) {
     return { ok: false };
   }
   const judged = core.clients.get(clientId);
-  if (judged && delta.tick > judged.lastClientTick) judged.lastClientTick = delta.tick;
+  if (judged && delta.tick > judged.lastClientTick) {
+    judged.lastClientTick = delta.tick;
+    judged.lastAppliedTick = core.tick;
+  }
   for (const dc of delta.collections) {
     const c = collectionDescOf(core.ext, dc.name);
     if (!c) continue;
@@ -672,6 +675,7 @@ var Loop = class {
     this.fireDueTimers();
     checkTimeouts(this.core);
     const config = this.core.definition.config;
+    let failed;
     if (config.tick) {
       const fn = config.tick;
       const dt = 1 / config.tickRate;
@@ -679,26 +683,30 @@ var Loop = class {
         "tick",
         () => fn(this.core.anyState, dt, this.core.room)
       );
-      if (ran.ok) this.consecutiveThrows = 0;
-      else {
-        this.consecutiveThrows++;
-        if (this.consecutiveThrows >= CRASH_AFTER_THROWS) {
-          this.core.flush();
-          const reason = `tick() threw ${this.consecutiveThrows} times in a row`;
-          this.core.stopped = true;
-          this.stop();
-          host.crashed(reason);
-          return;
-        }
-      }
+      if (!ran.ok) failed = "tick()";
     }
     const physics = this.core.physics;
     if (physics) {
-      this.core.tryRun("physics", () => {
+      const ran = this.core.tryRun("physics", () => {
         physics.reconcile();
         physics.step();
         physics.sync();
       });
+      if (!ran.ok) {
+        failed = failed === void 0 ? "the physics step" : `${failed} and the physics step`;
+      }
+    }
+    if (failed === void 0) this.consecutiveThrows = 0;
+    else {
+      this.consecutiveThrows++;
+      if (this.consecutiveThrows >= CRASH_AFTER_THROWS) {
+        this.core.flush();
+        const reason = `${failed} threw ${this.consecutiveThrows} times in a row`;
+        this.core.stopped = true;
+        this.stop();
+        host.crashed(reason);
+        return;
+      }
     }
     this.core.flush();
     const elapsed = Math.max(0, host.now() - started);
@@ -852,6 +860,25 @@ function decodePhysicsSection(bytes) {
 function bodyKey(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.`;
+  }
+  return void 0;
+}
+var CUBOID_SHAPE = 1;
+var ROUND_CUBOID_SHAPE = 12;
 var PhysicsRuntime = class {
   rapier;
   world;
@@ -862,6 +889,8 @@ var PhysicsRuntime = class {
   /** 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
@@ -936,6 +965,11 @@ 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.applyRecordToBody(desc, body, record);
@@ -1809,6 +1843,13 @@ var RoomCore = class _RoomCore {
   };
   tick = 0;
   stopped = false;
+  /**
+   * Called for every handler throw `tryRun` swallows, before it is logged. A test harness sets
+   * this so a room that breaks fails the test that broke it (bug 2): the runtime's job is to
+   * keep the room up in production, but under test that same guarding turns a broken handler
+   * into a timeout in an unrelated assertion ten seconds later. Unset in production.
+   */
+  onHandlerError;
   seed;
   api;
   internals;
@@ -1925,6 +1966,10 @@ var RoomCore = class _RoomCore {
         `${name}: ${err instanceof Error ? err.message : String(err)}`
       );
       this.host.log("error", [`irtio: ${name} threw`, err]);
+      try {
+        this.onHandlerError?.(name, err);
+      } catch {
+      }
       return { ok: false };
     }
   }
@@ -2072,6 +2117,7 @@ var RoomCore = class _RoomCore {
       correction: void 0,
       accepted: /* @__PURE__ */ new Map(),
       lastClientTick: 0,
+      lastAppliedTick: 0,
       pendingJoinAdds: void 0,
       spatialMembership: /* @__PURE__ */ new Map()
     };
@@ -2335,7 +2381,12 @@ var RoomCore = class _RoomCore {
             this.internals,
             membershipSafeDirty(this.ext, entry.correction, memberships)
           );
-          if (payload) this.send(entry.clientId, encodeCorrectFrame(payload, entry.lastClientTick));
+          if (payload) {
+            this.send(
+              entry.clientId,
+              encodeCorrectFrame(payload, entry.lastClientTick, entry.lastAppliedTick)
+            );
+          }
         }
         let delta;
         if (spatialDescs.length > 0) {

package/dist/{chunk-FA4IOC2Z.js → chunk-HFOMXKSO.js}

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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { E as EVENT_RING_SIZE, H as HOST_CALL_TIMEOUT_MS, a as HostCall, b as HostCallResult, J as JoinOptions, c as JoinResult, L as LogLevel, R as RoomCoreApi, d as RoomCoreOptions, e as RoomEvent, f as RoomEventKind, g as RoomFullError, h as RoomHost, i as RoomInspection, j as RoomStats, k as inspectState } from './contract-B8QSO0MH.js';
-export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as Mulberry32, P as PhysicsSection, R as RoomCore, d as decodePhysicsSection, e as encodePhysicsSection, i as initPhysics, l as loadedPhysics, r as resetPhysicsForTests } from './room-BfALTh7M.js';
+export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as Mulberry32, P as PhysicsSection, R as RoomCore, d as decodePhysicsSection, e as encodePhysicsSection, i as initPhysics, l as loadedPhysics, r as resetPhysicsForTests } from './room-9ZQoy9yi.js';
 import { CollectionDesc, AnySchema, PlainState, DirtySet } from '@irtio/schema';
 import '@irtio/protocol';
 import '@irtio/server';

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   fromMigrationState,
   migrateSnapshot,
   toMigrationState
-} from "./chunk-FA4IOC2Z.js";
+} from "./chunk-HFOMXKSO.js";
 import {
   CRASH_AFTER_THROWS,
   EVENT_RING_SIZE,
@@ -30,7 +30,7 @@ import {
   visibleNames,
   visibleTo,
   writeHibernationBlob
-} from "./chunk-GKMD3ICD.js";
+} from "./chunk-5ZDQAAFJ.js";
 export {
   CRASH_AFTER_THROWS,
   EVENT_RING_SIZE,

package/dist/{room-BfALTh7M.d.ts → room-9ZQoy9yi.d.ts}

@@ -47,6 +47,13 @@ interface ClientEntry {
      * unchanged — for a client that never wrote, that is `0`.
      */
     lastClientTick: number;
+    /**
+     * The room tick `lastClientTick`'s write was applied at, `0` before this client's first write.
+     * Sent alongside it on every `CORRECT` (bug 1). The two are a pair — one number on the
+     * client's stamp clock, one on the room's — and the client uses the gap between them to learn
+     * where on the server's tick stream its still-unjudged intents will land.
+     */
+    lastAppliedTick: number;
     /**
      * Set at `join`: this client's own record(s) — its presence row and whatever entities its own
      * `onJoin` added, owned by it — as they stood right after join, per collection. Consumed once
@@ -164,7 +171,18 @@ interface RoomInternals {
 
 /** Most ticks one wake may run before the backlog is dropped. */
 declare const MAX_CATCHUP = 5;
-/** Consecutive `tick()` throws before the host is told the room crashed. */
+/**
+ * Consecutive ticks in which a guarded stage threw before the host is told the room crashed.
+ *
+ * Any of them counts, not just `tick()` (bug 2). A room that cannot step its physics is not
+ * running — it is a socket that answers with a frozen world — and the runtime is the only thing
+ * that can tell the difference, because it is the only thing that sees the throw. The specific
+ * way this was found is worth keeping: one Rapier getter called from a room handler at the wrong
+ * moment leaves the rigid-body set borrowed in WASM, and *every* Rapier call after it throws.
+ * Nothing in JS can un-poison that world, so the honest response is to stop claiming to be up:
+ * crashing hands the room to the supervisor, which restarts it from its snapshot with a fresh
+ * world, and gives up out loud if the same thing happens again (`maxRestartsPerMin`).
+ */
 declare const CRASH_AFTER_THROWS = 3;
 declare class Loop implements LoopApi {
     private readonly core;
@@ -280,6 +298,8 @@ declare class PhysicsRuntime {
     /** Physics-backed collections, in schema (name-sorted) order. */
     private readonly collections;
     private readonly bodies;
+    /** Collections already warned about the friction-killing 2D lock recipe (bug 6). */
+    private readonly warnedPlanar;
     /**
      * 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
@@ -335,6 +355,13 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
     readonly stats: RoomStats;
     tick: number;
     stopped: boolean;
+    /**
+     * Called for every handler throw `tryRun` swallows, before it is logged. A test harness sets
+     * this so a room that breaks fails the test that broke it (bug 2): the runtime's job is to
+     * keep the room up in production, but under test that same guarding turns a broken handler
+     * into a timeout in an unrelated assertion ten seconds later. Unset in production.
+     */
+    onHandlerError: ((name: string, err: unknown) => void) | undefined;
     private readonly seed;
     private readonly api;
     private readonly internals;

package/dist/test/index.d.ts

@@ -1,5 +1,5 @@
-import { R as RoomCore } from '../room-BfALTh7M.js';
-export { i as initPhysics } from '../room-BfALTh7M.js';
+import { R as RoomCore } from '../room-9ZQoy9yi.js';
+export { i as initPhysics } from '../room-9ZQoy9yi.js';
 import { ErrorCodeName, FrameType } from '@irtio/protocol';
 import { h as RoomHost, L as LogLevel, R as RoomCoreApi, a as HostCall, b as HostCallResult, j as RoomStats } from '../contract-B8QSO0MH.js';
 import { AnySchema, PlainState, EntityCollection, State } from '@irtio/schema';

package/dist/test/index.js

@@ -3,7 +3,7 @@ import {
   createVisibilityPolicy,
   initPhysics,
   visibleNames
-} from "../chunk-GKMD3ICD.js";
+} from "../chunk-5ZDQAAFJ.js";
 
 // src/test/clock.ts
 var FakeClock = class {

package/dist/worker/index.js

@@ -1,11 +1,11 @@
 import {
   migrateSnapshot
-} from "../chunk-FA4IOC2Z.js";
+} from "../chunk-HFOMXKSO.js";
 import {
   RoomCore,
   RoomFullError,
   initPhysics
-} from "../chunk-GKMD3ICD.js";
+} from "../chunk-5ZDQAAFJ.js";
 
 // src/worker/index.ts
 import { isMainThread, parentPort } from "worker_threads";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/runtime",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
   "publishConfig": {
@@ -29,9 +29,9 @@
   ],
   "dependencies": {
     "@dimforge/rapier3d-compat": "0.20.0",
-    "@irtio/protocol": "0.2.0",
-    "@irtio/schema": "0.2.0",
-    "@irtio/server": "0.2.0"
+    "@irtio/protocol": "0.4.0",
+    "@irtio/server": "0.4.0",
+    "@irtio/schema": "0.4.0"
   },
   "scripts": {
     "build": "tsup",