@irtio/testing 0.5.1 → 0.6.0

package/dist/{chunk-Q44LJTMZ.js → chunk-TPT2EBEZ.js}

@@ -166,6 +166,15 @@ var DROPPABLE = /* @__PURE__ */ new Set([
 var MICROTASK_TURNS = 8;
 var SETTLE_ROUNDS = 64;
 var JOIN_TIMEOUT_MS = 3e4;
+var HELD_FRAMES_MAX = 16;
+var DROPPED_HELD = new Uint8Array(0);
+function frameNameOf(frame) {
+  try {
+    return frameTypeName(frame[0] ?? -1);
+  } catch {
+    return `type ${String(frame[0])}`;
+  }
+}
 async function microtasks(turns = MICROTASK_TURNS) {
   for (let i = 0; i < turns; i++) await Promise.resolve();
 }
@@ -182,6 +191,15 @@ var TestHarness = class {
   links = [];
   byId = /* @__PURE__ */ new Map();
   resumeTokens = /* @__PURE__ */ new Map();
+  /**
+   * Bug #49: frames the core sent a client it knows but this harness has not welcomed yet, by
+   * client id. `RoomCore.join` runs `onJoin` before it returns and `byId` is set after, so a
+   * `room.call(ctx.clientId)` made from `onJoin` arrives here with no link to deliver to. The
+   * client refuses frames before its WELCOME, so they wait for it (`handleHello` drains).
+   */
+  heldOut = /* @__PURE__ */ new Map();
+  /** Client ids a frame was dropped for because nobody knows them, each warned about once. */
+  unknownSendWarned = /* @__PURE__ */ new Set();
   clientList = [];
   roleById = /* @__PURE__ */ new Map();
   roleOverrides = /* @__PURE__ */ new Map();
@@ -221,11 +239,16 @@ var TestHarness = class {
     this.host = new HarnessHost(this.clock);
     this.host.onSend = (clientId, frame) => {
       const link = this.byId.get(clientId);
-      if (link?.connected) this.toClient(link, frame);
+      if (link) {
+        if (link.connected) this.toClient(link, frame);
+        return;
+      }
+      this.holdOrDrop(clientId, frame);
     };
     this.coreRef = new RoomCore(this.definition, this.host, {
       roomId: this.roomId,
-      seed: options.seed ?? 1
+      seed: options.seed ?? 1,
+      ...options.profile === true ? { profile: true } : {}
     });
     this.host.core = this.coreRef;
     this.host.serializeForSave = () => this.coreRef.snapshot();
@@ -281,6 +304,10 @@ var TestHarness = class {
   get ext() {
     return this.coreRef.ext;
   }
+  /** D65: the room's bandwidth ledger, or `undefined` unless `profile: true` asked for one. */
+  get profile() {
+    return this.coreRef.profile();
+  }
   // -------------------------------------------------------------------------
   // The core is never re-entered
   // -------------------------------------------------------------------------
@@ -329,11 +356,38 @@ var TestHarness = class {
       }
     };
   }
+  /**
+   * Bug #49: a frame for a client with no link. Held when the core has the client and counts it
+   * connected, which is exactly the window between `RoomCore.join` running `onJoin` and
+   * `handleHello` sending the WELCOME; dropped otherwise, with one `warn` per client id so the
+   * next silent path is visible from `t.host.logsOf('warn')`.
+   */
+  holdOrDrop(clientId, frame) {
+    const entry = this.coreRef.clients.get(clientId);
+    if (entry?.connected) {
+      const held = this.heldOut.get(clientId) ?? [];
+      if (held.length < HELD_FRAMES_MAX) held.push(frame);
+      else if (held.length === HELD_FRAMES_MAX) {
+        held.push(DROPPED_HELD);
+        this.host.log("warn", [
+          `irtio: dropped a ${frameNameOf(frame)} frame for ${clientId}: more than ${HELD_FRAMES_MAX} frames sent while it was still joining`
+        ]);
+      }
+      this.heldOut.set(clientId, held);
+      return;
+    }
+    if (this.unknownSendWarned.has(clientId)) return;
+    this.unknownSendWarned.add(clientId);
+    this.host.log("warn", [
+      `irtio: dropped a ${frameNameOf(frame)} frame for unknown client ${clientId}`
+    ]);
+  }
   /** The client end hung up: a deliberate `leave()`, or `t.stop()`. Treated as a graceful leave. */
   linkClosed(link) {
     if (!link.connected) return;
     link.connected = false;
     this.byId.delete(link.clientId);
+    this.heldOut.delete(link.clientId);
     if (!link.joined || this.stopped) return;
     link.joined = false;
     this.enterCore(() => this.coreRef.leave(link.clientId, "left"));
@@ -481,6 +535,10 @@ var TestHarness = class {
       }
     });
     if (!result) {
+      this.heldOut.delete(link.clientId);
+      if (this.coreRef.clients.has(link.clientId)) {
+        this.enterCore(() => this.coreRef.leave(link.clientId, "timeout"));
+      }
       const full = failure instanceof RoomFullError;
       this.fail(
         link,
@@ -519,10 +577,16 @@ var TestHarness = class {
           snapshot: joined.snapshot,
           resumeToken,
           roomId: this.roomId,
-          tickIntervalMs: Math.round(this.intervalMs)
+          tickRate: this.definition.config.tickRate,
+          maxClients: 0
         })
       )
     );
+    const held = this.heldOut.get(link.clientId);
+    if (held) {
+      this.heldOut.delete(link.clientId);
+      for (const frame of held) if (frame !== DROPPED_HELD) this.toClient(link, frame);
+    }
   }
   fail(link, code, message) {
     this.toClient(
@@ -709,7 +773,7 @@ var TestHarness = class {
     const latency = spec.latency ?? this.latency;
     this.renderMeta.set(room.me, {
       // The client's own default: 2 × the tick interval it learned from WELCOME, floored at 50.
-      interpDelayMs: spec.interpDelayMs ?? Math.max(50, 2 * Math.round(this.intervalMs)),
+      interpDelayMs: spec.interpDelayMs ?? Math.max(50, 2 * this.intervalMs),
       marginMs: (latency?.rttMs ?? 0) + (latency?.jitterMs ?? 0)
     });
     const client = Object.create(room);

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { RoleOf, AnySchema, State, PlainState } from '@irtio/schema';
 import { RoomDefinition } from '@irtio/server';
 import { Room, ClientState, RelayRoom, Scheduler } from '@irtio/client';
+import { ProfileSnapshot } from '@irtio/protocol';
 import { RoomCore } from '@irtio/runtime';
 import { TraceEntry, HarnessHost, VisibilityLeak, FakeClock } from '@irtio/runtime/test';
-export { TraceEntry, VisibilityLeak, initPhysics } from '@irtio/runtime/test';
+export { TraceEntry, VisibilityLeak, initMatter, initPhysics } from '@irtio/runtime/test';
 export { M as MatcherResult, P as PredictionBounds, T as TRACE_TAIL, m as matchers, t as toHaveConverged, a as toHaveNoVisibilityLeaks, b as toHaveRejected, c as toStayUnderBandwidth, d as toStayWithinPrediction } from './assertions-Cj1Sejhj.js';
 
 /**
@@ -69,6 +70,11 @@ interface TestRoomOptions {
      * either way.
      */
     readonly failOnHandlerError?: boolean;
+    /**
+     * D65: run the room with a bandwidth ledger, readable as `t.profile`. Off by default, and off
+     * costs nothing — the room constructs no ledger and walks no frame.
+     */
+    readonly profile?: boolean;
 }
 interface TestJoinSpec<Role extends string = string> {
     readonly role?: Role;
@@ -192,6 +198,12 @@ interface TestRoom<S extends AnySchema> {
     until(pred: () => boolean, options?: UntilOptions): Promise<void>;
     /** `withBuiltins(schema)`: the schema every frame is encoded against. */
     readonly ext: AnySchema;
+    /**
+     * D65: the room's bandwidth ledger, or `undefined` unless `testRoom({ profile: true })` asked
+     * for one. Cumulative from the room's first frame; the room's own view, so `out` counts what
+     * the room sent and the join snapshots it handed the host, and `in` counts what it accepted.
+     */
+    readonly profile: ProfileSnapshot | undefined;
     /** Collections a client can see that its role must not. `[]` when the room is clean. */
     checkVisibility(): VisibilityLeak[];
     /**
@@ -313,6 +325,15 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
     private readonly links;
     private readonly byId;
     private readonly resumeTokens;
+    /**
+     * Bug #49: frames the core sent a client it knows but this harness has not welcomed yet, by
+     * client id. `RoomCore.join` runs `onJoin` before it returns and `byId` is set after, so a
+     * `room.call(ctx.clientId)` made from `onJoin` arrives here with no link to deliver to. The
+     * client refuses frames before its WELCOME, so they wait for it (`handleHello` drains).
+     */
+    private readonly heldOut;
+    /** Client ids a frame was dropped for because nobody knows them, each warned about once. */
+    private readonly unknownSendWarned;
     private readonly clientList;
     private readonly roleById;
     private readonly roleOverrides;
@@ -356,9 +377,18 @@ declare class TestHarness<S extends AnySchema> implements TestRoom<S> {
     private get intervalMs();
     /** The extended schema every frame is encoded against. */
     get ext(): AnySchema;
+    /** D65: the room's bandwidth ledger, or `undefined` unless `profile: true` asked for one. */
+    get profile(): ProfileSnapshot | undefined;
     private enterCore;
     /** A `Transport` bound to one `t.join()`; reconnects call `connect` again with the same spec. */
     private transportFor;
+    /**
+     * Bug #49: a frame for a client with no link. Held when the core has the client and counts it
+     * connected, which is exactly the window between `RoomCore.join` running `onJoin` and
+     * `handleHello` sending the WELCOME; dropped otherwise, with one `warn` per client id so the
+     * next silent path is visible from `t.host.logsOf('warn')`.
+     */
+    private holdOrDrop;
     /** The client end hung up: a deliberate `leave()`, or `t.stop()`. Treated as a graceful leave. */
     private linkClosed;
     /**

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   toHaveRejected,
   toStayUnderBandwidth,
   toStayWithinPrediction
-} from "./chunk-Q44LJTMZ.js";
+} from "./chunk-TPT2EBEZ.js";
 
 // src/relay-harness.ts
 import { joinRelay } from "@irtio/client";
@@ -284,8 +284,9 @@ var TestRelayHarness = class {
           snapshot: this.relay.snapshot(),
           resumeToken,
           roomId: this.roomId,
-          tickIntervalMs: 0
+          tickRate: 0,
           // relay rooms have no tick
+          maxClients: this.maxClients
         })
       )
     );
@@ -448,6 +449,7 @@ var TestRelayHarness = class {
 
 // src/index.ts
 import { initPhysics } from "@irtio/runtime/test";
+import { initMatter } from "@irtio/runtime/test";
 async function testRoom(definition, options = {}) {
   return new TestHarness(definition, options);
 }
@@ -460,6 +462,7 @@ export {
   TestRelayHarness,
   clockScheduler,
   divergence,
+  initMatter,
   initPhysics,
   matchers,
   materialize,

package/dist/matchers.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/testing",
-  "version": "0.5.1",
+  "version": "0.6.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.5.1",
-    "@irtio/protocol": "0.5.1",
-    "@irtio/runtime": "0.5.1",
-    "@irtio/schema": "0.5.1",
-    "@irtio/server": "0.5.1"
+    "@irtio/client": "0.6.0",
+    "@irtio/protocol": "0.6.0",
+    "@irtio/runtime": "0.6.0",
+    "@irtio/schema": "0.6.0",
+    "@irtio/server": "0.6.0"
   },
   "peerDependencies": {
     "vitest": ">=3"