@irtio/runtime 0.11.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-Hk4SkDtW.js';
-import { ErrorCodeName, ProfileSnapshot } from '@irtio/protocol';
+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;
@@ -132,6 +146,17 @@ type ToWorker = {
     name: string;
     from: string;
     payload: string;
+}
+/**
+ * M7 D-P2: the platform has something to tell this room's players, and the room gets the first
+ * look. Carries a `reqId` because the answer decides whether the supervisor broadcasts, so this
+ * is a request and not a notification — a rare thing on this side of the wire, and the reason is
+ * that a veto only means anything before the frame goes out.
+ */
+ | {
+    t: 'platformNotice';
+    reqId: number;
+    notice: PlatformNotice;
 } | {
     t: 'stop';
 };
@@ -204,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;
@@ -217,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. */
  | {
@@ -224,6 +267,17 @@ type FromWorker = {
     reqId: number;
     ok: boolean;
 }
+/**
+ * M7 D-P2: the room's answer to a `platformNotice`. `broadcast: false` only when the handler
+ * returned exactly `false`. A handler that threw, a room with no handler, and a room whose core
+ * is not up all answer `true`, because the veto is a room saying "I will tell them myself" and
+ * none of those three said anything.
+ */
+ | {
+    t: 'platformNoticeResult';
+    reqId: number;
+    broadcast: boolean;
+}
 /** D41: the recorded timeline. `dump` absent when nobody armed the recorder. */
  | {
     t: 'timeline';
@@ -368,5 +422,17 @@ interface WorkerState {
  * killing the worker.
  */
 declare function handleMessage(state: WorkerState, host: RoomHost, post: (msg: FromWorker, transfer?: ArrayBuffer[]) => void, msg: ToWorker): Promise<void>;
+/**
+ * Replaces `Math.random` with sfc32 seeded from 16 host-supplied bytes.
+ *
+ * Box day 2 (2026-09-08) measured why this exists: two VMs restored from one golden snapshot
+ * handed their room workers **bit-for-bit identical `Math.random` streams** — V8 seeds a new
+ * isolate's PRNG from process state that a memory snapshot clones, and the kernel's VMGenID
+ * reseed does not reach it. `Math.random` is the only random primitive room code has (the
+ * sandbox refuses `node:crypto`), so an unseeded clone gives two different projects the same
+ * dice. The seed comes from the supervisor's clone-safe entropy mixer via `workerData`, so
+ * every worker — cold boot or restore, same VM or sibling clones — rolls its own.
+ */
+declare function seedMathRandom(seedHex: string): void;
 
-export { type FromWorker, type MigrationChainStep, type ToWorker, type WorkerState, createWorkerHost, handleMessage, transferList };
+export { type FromWorker, type MigrationChainStep, type ToWorker, type WorkerState, createWorkerHost, handleMessage, seedMathRandom, transferList };

package/dist/worker/index.js

@@ -1,7 +1,8 @@
 import {
   migrateSnapshot
-} from "../chunk-ACC3SDIO.js";
+} from "../chunk-3BCTP4YS.js";
 import {
+  AdmissionError,
   RoomCore,
   RoomFullError,
   initMatter,
@@ -9,11 +10,11 @@ import {
   initRapier2d,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-GYPUNTQN.js";
+} from "../chunk-NPRIYYNM.js";
 
 // src/worker/index.ts
 import { getHeapStatistics } from "v8";
-import { isMainThread, parentPort } from "worker_threads";
+import { isMainThread, parentPort, workerData } from "worker_threads";
 import { isRoomDefinition } from "@irtio/server";
 
 // src/worker/protocol.ts
@@ -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;
       }
@@ -352,6 +379,11 @@ async function handleMessage(state, host, post, msg) {
         state.core?.fireAlarm(msg.name);
         return;
       }
+      case "platformNotice": {
+        const broadcast = state.core?.deliverPlatformNotice(msg.notice) ?? true;
+        post({ t: "platformNoticeResult", reqId: msg.reqId, broadcast });
+        return;
+      }
       case "busEvent": {
         state.core?.deliverBusEvent(msg.channel, msg.from, msg.payload);
         return;
@@ -390,7 +422,32 @@ async function handleMessage(state, host, post, msg) {
     });
   }
 }
+function seedMathRandom(seedHex) {
+  if (!/^[0-9a-f]{32}$/.test(seedHex)) return;
+  const u32 = (i) => Number.parseInt(seedHex.slice(i * 8, i * 8 + 8), 16) >>> 0;
+  let a = u32(0);
+  let b = u32(1);
+  let c = u32(2);
+  let d = u32(3);
+  const sfc32 = () => {
+    a >>>= 0;
+    b >>>= 0;
+    c >>>= 0;
+    d >>>= 0;
+    const t = a + b + d >>> 0;
+    d = d + 1 >>> 0;
+    a = b ^ b >>> 9;
+    b = c + (c << 3) >>> 0;
+    c = (c << 21 | c >>> 11) >>> 0;
+    c = c + t >>> 0;
+    return t / 4294967296;
+  };
+  for (let i = 0; i < 12; i++) sfc32();
+  Math.random = sfc32;
+}
 if (!isMainThread && parentPort) {
+  const seed = workerData?.mathRandomSeed;
+  if (typeof seed === "string") seedMathRandom(seed);
   const port = parentPort;
   const post = (msg, transfer) => {
     port.postMessage(msg, transfer ?? transferList(msg));
@@ -404,5 +461,6 @@ if (!isMainThread && parentPort) {
 export {
   createWorkerHost,
   handleMessage,
+  seedMathRandom,
   transferList
 };

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@irtio/runtime",
-  "version": "0.11.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": "0.11.0",
-    "@irtio/schema": "0.11.0",
-    "@irtio/server": "0.11.0"
+    "@irtio/protocol": "3.0.0",
+    "@irtio/schema": "3.0.0",
+    "@irtio/server": "3.0.0"
   },
   "devDependencies": {
     "@types/matter-js": "0.20.2"