@irtio/runtime 1.0.0 → 3.0.0

package/dist/worker/index.d.ts

@@ -1,13 +1,8 @@
-import { L as LogLevel, T as TimelineDump, p as RoomStats, c as HostCall, d as HostCallResult, i as RoomCoreApi, n as RoomHost } from '../contract-UEKTud1Z.js';
+import { L as LogLevel, t as RpcTraceDump, T as TimelineDump, r as RoomStats, c as HostCall, d as HostCallResult, k as RoomCoreApi, p as RoomHost } from '../contract-BoCNAPZT.js';
 import { ErrorCodeName, ProfileSnapshot, PlatformNotice } from '@irtio/protocol';
 import { NpcConfig, LeaveReason } from '@irtio/server';
 import '@irtio/schema';
 
-/**
- * Supervisor ↔ room-worker `postMessage` protocol. Every `Uint8Array` is transferred.
- * Keep it additive: deployed supervisors speak exactly this.
- */
-
 /**
  * One deployment in a wake-time migration chain. The worker imports each
  * `migrationUrl` and runs `up` inside its own sandbox — migrations are tenant code and never run
@@ -40,6 +35,11 @@ type ToWorker = {
      * existing supervisor already sends, and a room without it pays nothing.
      */
     profile?: boolean;
+    /**
+     * M7 pf4: run this room with an RPC trace ring. Absent means off — the shape every existing
+     * supervisor already sends — and a room without it pays nothing. `irtio dev --trace-rpc`.
+     */
+    traceRpc?: boolean;
 } | {
     t: 'join';
     clientId: string;
@@ -51,6 +51,9 @@ type ToWorker = {
     reconnecting?: boolean;
     /** D44: this join is a scripted NPC's loopback session. */
     npc?: boolean;
+    /** M8 lane 5: the verified subject, absent for a key join. See `JoinOptions.subject` — it is
+     *  deliberately narrower than `playerId`, which always has a value. */
+    subject?: string;
 } | {
     t: 'leave';
     clientId: string;
@@ -63,12 +66,23 @@ type ToWorker = {
     clientId: string;
     bytes: Uint8Array;
 }
-/** `forSave` (D24) asks for the bytes only: no `onSleep`, no timers cleared, nothing
- *  rejected — the room keeps running. Absent means hibernation, as it always did. */
+/**
+ * `forSave` (D24) asks for the bytes only: no `onSleep`, no timers cleared, nothing rejected —
+ * the room keeps running. `false` is the departure: `onSleep` runs, timers are cleared, pending
+ * work is rejected, and the worker is about to be terminated.
+ *
+ * **Required, deliberately** (bugs.md #82). It was optional, defaulting to the departure, and
+ * the periodic `snapshotEveryMs` snapshot of a *running* event-mode room simply omitted it — so
+ * every such room ran `onSleep` and lost its armed timers every thirty seconds while it kept
+ * running. Only the caller knows which of the two it meant, so the protocol makes it say. Host
+ * and worker are one shipping unit (`@irtio/supervisor` is private and depends on
+ * `@irtio/runtime` by `workspace:*`, and this module is not on `@irtio/runtime`'s export map),
+ * so there is no mixed-version pair for the missing field to have to mean anything to.
+ */
  | {
     t: 'serialize';
     reqId: number;
-    forSave?: boolean;
+    forSave: boolean;
 } | {
     t: 'inspect';
     reqId: number;
@@ -215,6 +229,17 @@ type FromWorker = {
     t: 'serialized';
     reqId: number;
     bytes: Uint8Array;
+    /**
+     * The earliest pending `room.setTimeout`/`setInterval` deadline the departure serialize
+     * just cleared, in **wall-clock ms** (`Date.now()`'s frame, translated in the worker the
+     * same way `setAlarm`'s `atMs` is — the room's own clock is `performance.now()` and means
+     * nothing to a supervisor that outlives the worker).
+     *
+     * Absent when the room had no timers armed, and always absent for `forSave`, which clears
+     * nothing and therefore loses nothing. The supervisor arms an internal wake for it so the
+     * room is up again by the time its timer would have fired.
+     */
+    nextTimerAt?: number;
 } | {
     t: 'inspected';
     reqId: number;
@@ -228,6 +253,13 @@ type FromWorker = {
     }[];
     /** Worker process RSS in bytes. */
     rss: number;
+    /**
+     * M7 pf4: the RPC trace and the per-client stamp-lag table, present only when this room was
+     * armed with `traceRpc`. It rides `inspected` rather than a message of its own because the
+     * dev page already polls `inspect` once a second and a second round trip would buy nothing
+     * — and because a new worker message is a wider change than an additive field on one.
+     */
+    rpcTrace?: RpcTraceDump;
 }
 /** D41: the recorder is armed. `ok: false` when there is no room core to arm. */
  | {

package/dist/worker/index.js

@@ -1,7 +1,8 @@
 import {
   migrateSnapshot
-} from "../chunk-YWDRE77H.js";
+} from "../chunk-3BCTP4YS.js";
 import {
+  AdmissionError,
   RoomCore,
   RoomFullError,
   initMatter,
@@ -9,7 +10,7 @@ import {
   initRapier2d,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-LT46QFLW.js";
+} from "../chunk-NPRIYYNM.js";
 
 // src/worker/index.ts
 import { getHeapStatistics } from "v8";
@@ -196,7 +197,8 @@ async function handleMessage(state, host, post, msg) {
             roomId: msg.roomId,
             ...msg.seed !== void 0 ? { seed: msg.seed } : {},
             ...msg.publicUrl !== void 0 ? { publicUrl: msg.publicUrl } : {},
-            ...msg.profile === true ? { profile: true } : {}
+            ...msg.profile === true ? { profile: true } : {},
+            ...msg.traceRpc === true ? { traceRpc: true } : {}
           };
           const core = snapshot ? RoomCore.restore(def, snapshot, host, options) : new RoomCore(def, host, options);
           state.core = core;
@@ -259,7 +261,10 @@ async function handleMessage(state, host, post, msg) {
             ...msg.name !== void 0 ? { name: msg.name } : {},
             ...msg.playerId !== void 0 ? { playerId: msg.playerId } : {},
             ...msg.reconnecting !== void 0 ? { reconnecting: msg.reconnecting } : {},
-            ...msg.npc === true ? { npc: true } : {}
+            ...msg.npc === true ? { npc: true } : {},
+            // M8 lane 5: absent for a key join, and absent is the answer `onAdmit` and `room.ban`
+            // both need to be able to see.
+            ...msg.subject !== void 0 ? { subject: msg.subject } : {}
           };
           const result = core.join(msg.clientId, joinOptions);
           const snapshot = ownBuffer(result.snapshot);
@@ -276,6 +281,13 @@ async function handleMessage(state, host, post, msg) {
         } catch (err) {
           if (err instanceof RoomFullError) {
             post({ t: "joinRejected", clientId: msg.clientId, code: "E_ROOM_FULL" });
+          } else if (err instanceof AdmissionError) {
+            post({
+              t: "joinRejected",
+              clientId: msg.clientId,
+              code: "E_ADMISSION",
+              reason: err.reason
+            });
           } else {
             post({
               t: "joinRejected",
@@ -302,8 +314,17 @@ async function handleMessage(state, host, post, msg) {
       case "serialize": {
         const core = state.core;
         if (!core) return;
-        const bytes = ownBuffer(msg.forSave === true ? core.snapshot() : core.serialize());
-        post({ t: "serialized", reqId: msg.reqId, bytes }, [bytes.buffer]);
+        const bytes = ownBuffer(msg.forSave ? core.snapshot() : core.serialize());
+        const timerAt = msg.forSave ? void 0 : core.lastSerializeTimerAt;
+        post(
+          {
+            t: "serialized",
+            reqId: msg.reqId,
+            bytes,
+            ...timerAt === void 0 ? {} : { nextTimerAt: Date.now() + (timerAt - performance.now()) }
+          },
+          [bytes.buffer]
+        );
         return;
       }
       case "inspect": {
@@ -316,7 +337,13 @@ async function handleMessage(state, host, post, msg) {
           tick: ins.tick,
           stateJson: ins.state,
           recent: ins.recent,
-          rss: typeof process !== "undefined" ? process.memoryUsage().rss : 0
+          rss: typeof process !== "undefined" ? process.memoryUsage().rss : 0,
+          // M7 pf4: absent unless this room was armed, which is what makes `undefined` mean
+          // "nobody asked" rather than "nobody called".
+          ...(() => {
+            const trace = core.rpcTrace();
+            return trace === void 0 ? {} : { rpcTrace: trace };
+          })()
         });
         return;
       }

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@irtio/runtime",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alex-irt/irtio.git",
+    "directory": "packages/runtime"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -31,9 +36,9 @@
     "@dimforge/rapier2d-compat": "0.20.0",
     "@dimforge/rapier3d-compat": "0.20.0",
     "matter-js": "0.20.0",
-    "@irtio/protocol": "1.0.0",
-    "@irtio/schema": "1.0.0",
-    "@irtio/server": "1.0.0"
+    "@irtio/protocol": "3.0.0",
+    "@irtio/schema": "3.0.0",
+    "@irtio/server": "3.0.0"
   },
   "devDependencies": {
     "@types/matter-js": "0.20.2"