@irtio/testing 3.1.1 → 4.0.0

package/dist/{chunk-47O3HZBE.js → chunk-LQ5TGD2E.js}

@@ -247,6 +247,7 @@ var DROPPABLE = /* @__PURE__ */ new Set([
 ]);
 var MICROTASK_TURNS = 8;
 var SETTLE_ROUNDS = 64;
+var RUN_HOPS_MAX = 1e4;
 var JOIN_TIMEOUT_MS = 3e4;
 var HELD_FRAMES_MAX = 16;
 var DROPPED_HELD = new Uint8Array(0);
@@ -976,8 +977,30 @@ var TestHarness = class {
       await this.settle();
     }
   }
+  /**
+   * Bug #127: one `clock.advance(ms)` would fire every timer in the window, but a script parked on
+   * `await npc.wait(50)` only resumes in a **microtask**, which cannot run until `advance` has
+   * returned — so the script's next timer was armed after the window had already gone by and a
+   * 1000 ms run took the script exactly one step. So hop instead of leaping: advance to the next
+   * due timer, let microtasks drain (continuations run, new timers get armed), and repeat until
+   * the target. With nothing armed it is still a single leap.
+   */
   async run(ms) {
-    this.clock.advance(ms);
+    const target = this.clock.now() + Math.max(0, ms);
+    for (let hops = 0; ; hops++) {
+      if (hops > RUN_HOPS_MAX) {
+        throw new Error(
+          `testRoom: t.run(${ms}) did not settle \u2014 more than ${RUN_HOPS_MAX} timers came due, which usually means a timer re-arms itself at the same fake time`
+        );
+      }
+      const due = this.clock.nextDueAt();
+      if (due === void 0 || due > target) {
+        this.clock.advance(target - this.clock.now());
+        break;
+      }
+      this.clock.advance(Math.max(0, due - this.clock.now()));
+      await microtasks();
+    }
     await this.settle();
   }
   /**

package/dist/index.d.ts

@@ -566,6 +566,14 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
      */
     private reportHandlerErrors;
     tick(n?: number): Promise<void>;
+    /**
+     * Bug #127: one `clock.advance(ms)` would fire every timer in the window, but a script parked on
+     * `await npc.wait(50)` only resumes in a **microtask**, which cannot run until `advance` has
+     * returned — so the script's next timer was armed after the window had already gone by and a
+     * 1000 ms run took the script exactly one step. So hop instead of leaping: advance to the next
+     * due timer, let microtasks drain (continuations run, new timers get armed), and repeat until
+     * the target. With nothing armed it is still a single leap.
+     */
     run(ms: number): Promise<void>;
     /**
      * Advances until `pred()` holds. In **event mode** a tick is a zero-length clock step, so this

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   toHaveRejected,
   toStayUnderBandwidth,
   toStayWithinPrediction
-} from "./chunk-47O3HZBE.js";
+} from "./chunk-LQ5TGD2E.js";
 
 // src/relay-harness.ts
 import { joinRelay } from "@irtio/client";

package/dist/matchers.js

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

package/package.json

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