@irtio/testing 0.2.0 → 0.4.0

package/dist/{chunk-6EHPS7A5.js → chunk-Q44LJTMZ.js}

@@ -189,6 +189,10 @@ var TestHarness = class {
   frameLeaks = [];
   spatialSeen = /* @__PURE__ */ new Map();
   rejectionLog = [];
+  /** Every handler throw the runtime caught, in order (bug 2). */
+  handlerErrorLog = [];
+  /** How many of them `reportHandlerErrors` has already raised. */
+  reportedErrors = 0;
   /** Reconnects completed per client id — bumped in `handleHello` on a resumed `WELCOME`. */
   reconnectCounts = /* @__PURE__ */ new Map();
   /** Prediction accounting per client id, fed by each room's `correct` events. */
@@ -204,12 +208,14 @@ var TestHarness = class {
   roomId;
   writeIntervalMs;
   latency;
+  failOnHandlerError;
   stopped = false;
   constructor(definition, options) {
     this.definition = configure(definition, options);
     this.roomId = options.roomId ?? "test-room";
     this.latency = options.latency;
     this.writeIntervalMs = options.writeIntervalMs;
+    this.failOnHandlerError = options.failOnHandlerError ?? true;
     this.rng = new Mulberry32(options.seed ?? 1);
     this.scheduler = clockScheduler(this.clock);
     this.host = new HarnessHost(this.clock);
@@ -223,6 +229,13 @@ var TestHarness = class {
     });
     this.host.core = this.coreRef;
     this.host.serializeForSave = () => this.coreRef.snapshot();
+    this.coreRef.onHandlerError = (handler, err) => {
+      this.handlerErrorLog.push({
+        handler,
+        message: err instanceof Error ? err.message : String(err),
+        tick: this.coreRef.tick
+      });
+    };
     this.coreRef.start();
   }
   // -------------------------------------------------------------------------
@@ -243,6 +256,9 @@ var TestHarness = class {
   get rejections() {
     return this.rejectionLog;
   }
+  get handlerErrors() {
+    return this.handlerErrorLog;
+  }
   get dropped() {
     return this.droppedFrames;
   }
@@ -610,10 +626,32 @@ var TestHarness = class {
       const before = this.activity;
       await microtasks();
       this.clock.advance(0);
-      if (this.activity === before) return;
+      if (this.activity === before) return this.reportHandlerErrors();
     }
     throw new Error("testRoom: the frame pump did not settle");
   }
+  /**
+   * Bug 2: the runtime catches a throwing handler so the room stays up, which in a test means
+   * the failure arrives later, somewhere else, wearing a disguise (the one that found this was a
+   * frozen tick counter reported ten seconds on as a `t.until` timeout). Every clock method ends
+   * here, so the throw surfaces at the line that ran the tick that broke.
+   */
+  reportHandlerErrors() {
+    if (!this.failOnHandlerError) return;
+    const fresh = this.handlerErrorLog.slice(this.reportedErrors);
+    this.reportedErrors = this.handlerErrorLog.length;
+    if (fresh.length === 0) return;
+    const lines = fresh.map((e) => `  ${e.handler} (tick ${e.tick}): ${e.message}`);
+    const what = fresh.length === 1 ? "a handler" : `${fresh.length} handlers`;
+    throw new Error(
+      [
+        `testRoom: the room threw in ${what}`,
+        ...lines,
+        "The runtime caught it and the room kept running, which is what it does in production.",
+        "Pass `failOnHandlerError: false` to testRoom if a throwing handler is what this test is about."
+      ].join("\n")
+    );
+  }
   async tick(n = 1) {
     for (let i = 0; i < n; i++) {
       this.clock.advance(this.mode === "tick" ? this.intervalMs : 0);

package/dist/index.d.ts

@@ -58,6 +58,17 @@ interface TestRoomOptions {
     readonly roomId?: string;
     /** The clients' owned-write flush window, in ms of fake time. Default 50 (the client's own). */
     readonly writeIntervalMs?: number;
+    /**
+     * Throw out of `t.tick` / `t.run` / `t.until` / `t.join` when a room handler throws. Default
+     * `true`.
+     *
+     * The runtime guards handlers on purpose: one bad `onJoin` must not take a live room down. In
+     * a test that same guarding hides the failure — the room limps on and the test fails ten
+     * seconds later on an unrelated `t.until` timeout, pointing at the wrong thing (bug 2). Set
+     * `false` for a test whose *subject* is a throwing handler; `t.handlerErrors` records them
+     * either way.
+     */
+    readonly failOnHandlerError?: boolean;
 }
 interface TestJoinSpec<Role extends string = string> {
     readonly role?: Role;
@@ -124,6 +135,13 @@ interface PredictionStats {
     /** Total pending local writes re-applied over corrections. */
     readonly replayed: number;
 }
+/** One handler throw the runtime caught and the room survived. See `failOnHandlerError`. */
+interface HandlerError {
+    /** What was running: `tick`, `physics`, `onJoin`, `room timer`, `alarms.<name>`, … */
+    readonly handler: string;
+    readonly message: string;
+    readonly tick: number;
+}
 /** One `REPLY` that came back with `ok: false`, keyed by the rpc the client had called. */
 interface RejectedCall {
     readonly clientId: string;
@@ -141,6 +159,12 @@ interface TestRoom<S extends AnySchema> {
     readonly trace: readonly TraceEntry[];
     /** Error replies seen so far, for `toHaveRejected`. */
     readonly rejections: readonly RejectedCall[];
+    /**
+     * Handler throws the runtime caught, in order. Empty in a healthy room; with the default
+     * `failOnHandlerError` the first one has already failed the test by the time you could read
+     * this, so it is for tests that opted out.
+     */
+    readonly handlerErrors: readonly HandlerError[];
     /** Frames the `latency.loss` die dropped. */
     readonly dropped: number;
     /** Escape hatch: the real `RoomCore`. */
@@ -296,6 +320,10 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
     private readonly frameLeaks;
     private readonly spatialSeen;
     private readonly rejectionLog;
+    /** Every handler throw the runtime caught, in order (bug 2). */
+    private readonly handlerErrorLog;
+    /** How many of them `reportHandlerErrors` has already raised. */
+    private reportedErrors;
     /** Reconnects completed per client id — bumped in `handleHello` on a resumed `WELCOME`. */
     private readonly reconnectCounts;
     /** Prediction accounting per client id, fed by each room's `correct` events. */
@@ -311,6 +339,7 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
     private readonly roomId;
     private readonly writeIntervalMs;
     private readonly latency;
+    private readonly failOnHandlerError;
     private stopped;
     constructor(definition: RoomDefinition<S>, options: TestRoomOptions);
     get core(): RoomCore<S>;
@@ -318,6 +347,7 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
     get plain(): PlainState;
     get trace(): readonly TraceEntry[];
     get rejections(): readonly RejectedCall[];
+    get handlerErrors(): readonly HandlerError[];
     get dropped(): number;
     get now(): number;
     get tickCount(): number;
@@ -369,6 +399,13 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
     private record;
     /** Fires everything due, then lets the clients' promises run, until nothing new is in flight. */
     private settle;
+    /**
+     * Bug 2: the runtime catches a throwing handler so the room stays up, which in a test means
+     * the failure arrives later, somewhere else, wearing a disguise (the one that found this was a
+     * frozen tick counter reported ten seconds on as a `t.until` timeout). Every clock method ends
+     * here, so the throw surfaces at the line that ran the tick that broke.
+     */
+    private reportHandlerErrors;
     tick(n?: number): Promise<void>;
     run(ms: number): Promise<void>;
     /**
@@ -581,4 +618,4 @@ declare function testRoom<S extends AnySchema>(definition: RoomDefinition<S>, op
 /** Starts a schema-less relay room in-process and returns the test handle. See the module docblock. */
 declare function testRelay(options?: TestRelayOptions): Promise<TestRelay>;
 
-export { type LatencySpec, type PredictionStats, type RejectedCall, type TestClient, TestHarness, type TestJoinSpec, type TestRelay, type TestRelayClient, TestRelayHarness, type TestRelayJoinSpec, type TestRelayOptions, type TestRoom, type TestRoomOptions, type UntilOptions, clockScheduler, divergence, materialize, testRelay, testRoom };
+export { type HandlerError, type LatencySpec, type PredictionStats, type RejectedCall, type TestClient, TestHarness, type TestJoinSpec, type TestRelay, type TestRelayClient, TestRelayHarness, type TestRelayJoinSpec, type TestRelayOptions, type TestRoom, type TestRoomOptions, type UntilOptions, clockScheduler, divergence, materialize, testRelay, testRoom };

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   toHaveRejected,
   toStayUnderBandwidth,
   toStayWithinPrediction
-} from "./chunk-6EHPS7A5.js";
+} from "./chunk-Q44LJTMZ.js";
 
 // src/relay-harness.ts
 import { joinRelay } from "@irtio/client";

package/dist/matchers.js

@@ -5,7 +5,7 @@ import {
   toHaveRejected,
   toStayUnderBandwidth,
   toStayWithinPrediction
-} from "./chunk-6EHPS7A5.js";
+} from "./chunk-Q44LJTMZ.js";
 
 // src/matchers.ts
 import { expect } from "vitest";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/testing",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "irtio's blessed test API: testRoom() in-process rooms with real client semantics, plus Vitest matchers",
   "license": "MIT",
   "publishConfig": {
@@ -23,11 +23,11 @@
     "dist"
   ],
   "dependencies": {
-    "@irtio/client": "0.2.0",
-    "@irtio/protocol": "0.2.0",
-    "@irtio/runtime": "0.2.0",
-    "@irtio/schema": "0.2.0",
-    "@irtio/server": "0.2.0"
+    "@irtio/client": "0.4.0",
+    "@irtio/protocol": "0.4.0",
+    "@irtio/schema": "0.4.0",
+    "@irtio/server": "0.4.0",
+    "@irtio/runtime": "0.4.0"
   },
   "peerDependencies": {
     "vitest": ">=3"