@irtio/testing 0.1.0

package/dist/chunk-O3OZKC3D.js

@@ -0,0 +1,851 @@
+// src/compare.ts
+import {
+  cloneValue,
+  computeDirty,
+  createState,
+  defaultRecord
+} from "@irtio/schema";
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const ra = a;
+  const rb = b;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(ra), ...Object.keys(rb)]);
+  for (const k of keys) if (!deepEqual(ra[k], rb[k])) return false;
+  return true;
+}
+function materialize(ext, view) {
+  const out = createState(ext);
+  for (const c of ext.collections) {
+    const value = view[c.name];
+    if (value === void 0 || value === null) continue;
+    if (c.kind === "entity") {
+      const src = value;
+      const dst = out[c.name];
+      for (const id of [...src.ids()]) {
+        const record = src.get(id);
+        if (!record) continue;
+        const values = {};
+        for (const f of c.fields) values[f.name] = cloneValue(record[f.name]);
+        dst.add(id, values, { owner: src.ownerOf(id) ?? "" });
+      }
+    } else {
+      const record = value;
+      const dst = out[c.name];
+      for (const f of c.fields) dst[f.name] = cloneValue(record[f.name]);
+    }
+  }
+  return out;
+}
+function divergence(ext, authority, client, visible) {
+  const out = [];
+  for (const [name, cd] of computeDirty(ext, authority, client)) {
+    if (!visible.has(name)) continue;
+    for (const id of cd.added) out.push(`${name}[${id}]: only in the client's view`);
+    for (const id of cd.removed) out.push(`${name}[${id}]: missing from the client's view`);
+    for (const [id, rd] of cd.updated) {
+      const fields = [...rd.mask.fields].map((i) => fieldNameAt(ext, name, i)).filter((n) => n !== void 0);
+      const what = rd.owner ? [...fields, "owner"] : fields;
+      out.push(`${name}[${id}]: ${what.join(", ")}`);
+    }
+  }
+  return out;
+}
+function fieldNameAt(ext, collection, index) {
+  const c = ext.collections.find((x) => x.name === collection);
+  return c?.fields[index]?.name;
+}
+function singletonIsDefault(desc, value) {
+  return deepEqual(value, defaultRecord(desc));
+}
+
+// src/scheduler.ts
+function clockScheduler(clock) {
+  return {
+    now: () => clock.now(),
+    setTimeout(fn, ms) {
+      const handle = clock.setTimeout(fn, ms);
+      return () => clock.clearTimeout(handle);
+    }
+  };
+}
+
+// src/harness.ts
+import { joinRoom } from "@irtio/client";
+import {
+  ErrorCode,
+  FrameType,
+  decodeCall,
+  decodeFrame,
+  decodeHello,
+  decodePing,
+  decodeReply,
+  encodeErrorPayload,
+  encodeFrame,
+  encodePong,
+  encodeWelcome,
+  formatError,
+  rpcTable
+} from "@irtio/protocol";
+import { Mulberry32, RoomCore, RoomFullError, visibleNames } from "@irtio/runtime";
+import { FakeClock, HarnessHost, frameTypeName } from "@irtio/runtime/test";
+import { decodeDelta } from "@irtio/schema";
+
+// src/link.ts
+var InProcessSocket = class {
+  constructor(outbound, onLocalClose) {
+    this.outbound = outbound;
+    this.onLocalClose = onLocalClose;
+  }
+  outbound;
+  onLocalClose;
+  onopen = null;
+  onmessage = null;
+  onclose = null;
+  onerror = null;
+  /** `true` once either end has closed the link. */
+  closed = false;
+  send(bytes) {
+    if (this.closed) return;
+    this.outbound(bytes);
+  }
+  /** `room.leave()` and `t.stop()` come through here. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.onLocalClose();
+    this.onclose?.();
+  }
+  /** Harness → client: the socket is up, send `HELLO`. */
+  open() {
+    if (!this.closed) this.onopen?.();
+  }
+  /** Harness → client: one frame arrived. */
+  deliver(bytes) {
+    if (!this.closed) this.onmessage?.(bytes);
+  }
+  /**
+   * Harness → client: the server hung up — `t.stop()` after the room closed, or `client.drop()`
+   * simulating a network drop. Unlike `close()` this never calls `onLocalClose`: the harness
+   * decides for itself whether that meant a leave (`stop()`) or a disconnect (`drop()`).
+   */
+  hangUp(info) {
+    if (this.closed) return;
+    this.closed = true;
+    this.onclose?.(info);
+  }
+};
+
+// src/harness.ts
+var TEST_URL = "ws://localhost:7070";
+var TEST_KEY = "test";
+var DROPPABLE = /* @__PURE__ */ new Set([
+  FrameType.WRITE,
+  FrameType.DELTA,
+  FrameType.CORRECT,
+  FrameType.MSG
+]);
+var MICROTASK_TURNS = 8;
+var SETTLE_ROUNDS = 64;
+var JOIN_TIMEOUT_MS = 3e4;
+async function microtasks(turns = MICROTASK_TURNS) {
+  for (let i = 0; i < turns; i++) await Promise.resolve();
+}
+var TestHarness = class {
+  clock = new FakeClock();
+  host;
+  coreRef;
+  scheduler;
+  rng;
+  definition;
+  links = [];
+  byId = /* @__PURE__ */ new Map();
+  resumeTokens = /* @__PURE__ */ new Map();
+  clientList = [];
+  roleById = /* @__PURE__ */ new Map();
+  roleOverrides = /* @__PURE__ */ new Map();
+  traceLog = [];
+  frameLeaks = [];
+  rejectionLog = [];
+  /** Reconnects completed per client id — bumped in `handleHello` on a resumed `WELCOME`. */
+  reconnectCounts = /* @__PURE__ */ new Map();
+  nextClientId = 1;
+  droppedFrames = 0;
+  /** Bumped whenever a frame is scheduled or delivered; the settle loop watches it. */
+  activity = 0;
+  inCore = false;
+  deferred = [];
+  roomId;
+  writeIntervalMs;
+  latency;
+  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.rng = new Mulberry32(options.seed ?? 1);
+    this.scheduler = clockScheduler(this.clock);
+    this.host = new HarnessHost(this.clock);
+    this.host.onSend = (clientId, frame) => {
+      const link = this.byId.get(clientId);
+      if (link?.connected) this.toClient(link, frame);
+    };
+    this.coreRef = new RoomCore(this.definition, this.host, {
+      roomId: this.roomId,
+      seed: options.seed ?? 1
+    });
+    this.coreRef.start();
+  }
+  // -------------------------------------------------------------------------
+  // Accessors
+  // -------------------------------------------------------------------------
+  get core() {
+    return this.coreRef;
+  }
+  get state() {
+    return this.coreRef.state;
+  }
+  get plain() {
+    return this.coreRef.plain;
+  }
+  get trace() {
+    return this.traceLog;
+  }
+  get rejections() {
+    return this.rejectionLog;
+  }
+  get dropped() {
+    return this.droppedFrames;
+  }
+  get now() {
+    return this.clock.time;
+  }
+  get tickCount() {
+    return this.coreRef.tick;
+  }
+  get mode() {
+    return this.coreRef.mode;
+  }
+  get clients() {
+    return this.clientList;
+  }
+  get intervalMs() {
+    return 1e3 / this.definition.config.tickRate;
+  }
+  /** The extended schema every frame is encoded against. */
+  get ext() {
+    return this.coreRef.ext;
+  }
+  // -------------------------------------------------------------------------
+  // The core is never re-entered
+  // -------------------------------------------------------------------------
+  enterCore(fn) {
+    if (this.inCore) {
+      this.deferred.push(fn);
+      return;
+    }
+    this.inCore = true;
+    try {
+      fn();
+    } finally {
+      this.inCore = false;
+    }
+    while (this.deferred.length > 0) {
+      const next = this.deferred.shift();
+      if (next) this.enterCore(next);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // The link
+  // -------------------------------------------------------------------------
+  /** A `Transport` bound to one `t.join()`; reconnects call `connect` again with the same spec. */
+  transportFor(spec) {
+    return {
+      connect: () => {
+        const link = {
+          socket: void 0,
+          clientId: `c${this.nextClientId++}`,
+          role: "",
+          joined: false,
+          connected: true,
+          latency: spec.latency,
+          nextIn: this.clock.time,
+          nextOut: this.clock.time,
+          calls: /* @__PURE__ */ new Map()
+        };
+        link.socket = new InProcessSocket(
+          (bytes) => this.fromClient(link, bytes),
+          () => this.linkClosed(link)
+        );
+        this.links.push(link);
+        this.clock.setTimeout(() => link.socket.open(), 0);
+        this.activity++;
+        return link.socket;
+      }
+    };
+  }
+  /** 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);
+    if (!link.joined || this.stopped) return;
+    link.joined = false;
+    this.enterCore(() => this.coreRef.leave(link.clientId, "left"));
+  }
+  /**
+   * `TestClient.drop()`: severs the transport out from under a client, the way a network drop
+   * would — the room only learns the client is *disconnected* (`RoomCore.markDisconnected`, the
+   * same call the real supervisor makes when a socket closes mid-session), not that it left. The
+   * client's own `onclose` handler then arms its reconnect backoff on the fake clock, exactly as
+   * it would over a real killed socket.
+   */
+  dropClient(clientId, options) {
+    const link = this.byId.get(clientId);
+    if (!link || !link.connected || link.socket.closed) return;
+    link.connected = false;
+    this.byId.delete(clientId);
+    this.enterCore(() => this.coreRef.markDisconnected(clientId));
+    link.socket.hangUp(options);
+  }
+  /**
+   * Schedules one frame's arrival on the fake clock. Returns `false` when the loss die dropped it.
+   * The `next*` clamp keeps a jittered stream in order: a WebSocket never reorders.
+   */
+  schedule(link, dir, type, run) {
+    const spec = link.latency ?? this.latency;
+    const loss = spec?.loss ?? 0;
+    if (loss > 0 && DROPPABLE.has(type) && this.rng.next() < loss) {
+      this.droppedFrames++;
+      return false;
+    }
+    const jitterMs = spec?.jitterMs ?? 0;
+    const oneWay = (spec?.rttMs ?? 0) / 2 + (jitterMs > 0 ? this.rng.next() * jitterMs : 0);
+    const floor = dir === "in" ? link.nextIn : link.nextOut;
+    const at = Math.max(this.clock.time + oneWay, floor);
+    if (dir === "in") link.nextIn = at;
+    else link.nextOut = at;
+    this.activity++;
+    this.clock.setTimeout(() => {
+      this.activity++;
+      run();
+    }, at - this.clock.time);
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Client to room
+  // -------------------------------------------------------------------------
+  fromClient(link, frame) {
+    let type;
+    let payload;
+    try {
+      const decoded = decodeFrame(frame);
+      type = decoded.type;
+      payload = decoded.payload;
+    } catch {
+      return;
+    }
+    if (type === FrameType.HELLO) this.preresolve(link, payload);
+    if (type === FrameType.CALL) this.noteCall(link, payload);
+    this.record("in", link.clientId, type, frame.length);
+    this.schedule(link, "in", type, () => this.toRoom(link, type, payload, frame));
+  }
+  preresolve(link, payload) {
+    try {
+      const hello = decodeHello(payload);
+      const resumed = hello.resumeToken ? this.resumeTokens.get(hello.resumeToken) : void 0;
+      if (resumed) link.clientId = resumed;
+    } catch {
+    }
+  }
+  noteCall(link, payload) {
+    try {
+      const call = decodeCall(payload);
+      const desc = rpcTable(this.definition.schema).find((r) => r.index === call.rpcId);
+      if (desc) link.calls.set(call.reqId, desc.name);
+    } catch {
+    }
+  }
+  toRoom(link, type, payload, frame) {
+    if (!link.connected || this.stopped) return;
+    if (type === FrameType.HELLO) {
+      this.handleHello(link, payload);
+      return;
+    }
+    if (type === FrameType.PING) {
+      let t = 0;
+      try {
+        t = decodePing(payload).t;
+      } catch {
+      }
+      this.toClient(
+        link,
+        encodeFrame(FrameType.PONG, encodePong({ t, serverTick: this.coreRef.tick }))
+      );
+      return;
+    }
+    if (type === FrameType.LEAVE) {
+      this.handleLeaveFrame(link);
+      return;
+    }
+    if (!link.joined) return;
+    this.enterCore(() => this.coreRef.receive(link.clientId, frame));
+  }
+  /**
+   * `LEAVE`, the wire counterpart of `linkClosed`'s deliberate-leave branch: call
+   * `RoomCore.leave` with `'left'` right away instead of routing the frame into
+   * `RoomCore.receive` (which has no case for it — that would hit its `badFrame` fallback) or
+   * waiting for the socket's close event. Marks the link gone first so the close that follows
+   * moments later (`leave()` always closes its socket) finds `linkClosed` a no-op.
+   */
+  handleLeaveFrame(link) {
+    if (!link.connected || !link.joined) return;
+    link.connected = false;
+    link.joined = false;
+    this.byId.delete(link.clientId);
+    this.enterCore(() => this.coreRef.leave(link.clientId, "left"));
+  }
+  /**
+   * The whole supervisor: allocate an id, `RoomCore.join`, answer with a real `WELCOME`. The
+   * resume token is the client id — there is nothing to sign in-process.
+   */
+  handleHello(link, payload) {
+    let role;
+    let name;
+    let reconnecting = false;
+    try {
+      const hello = decodeHello(payload);
+      role = hello.role;
+      name = hello.name;
+      reconnecting = hello.resumeToken !== void 0 && this.resumeTokens.has(hello.resumeToken);
+    } catch {
+      this.fail(link, "E_BAD_FRAME", "malformed HELLO");
+      return;
+    }
+    let result;
+    let failure;
+    this.enterCore(() => {
+      try {
+        result = this.coreRef.join(link.clientId, {
+          ...role !== void 0 ? { role } : {},
+          ...name !== void 0 ? { name } : {},
+          ...reconnecting ? { reconnecting: true } : {}
+        });
+      } catch (err) {
+        failure = err;
+      }
+    });
+    if (!result) {
+      const full = failure instanceof RoomFullError;
+      this.fail(
+        link,
+        full ? "E_ROOM_FULL" : "E_INTERNAL",
+        full ? formatError("E_ROOM_FULL", { roomId: this.roomId }) : failure instanceof Error ? failure.message : String(failure)
+      );
+      return;
+    }
+    const joined = result;
+    link.joined = true;
+    link.connected = true;
+    link.role = joined.role;
+    this.byId.set(link.clientId, link);
+    this.roleById.set(link.clientId, joined.role);
+    if (reconnecting) {
+      this.reconnectCounts.set(link.clientId, (this.reconnectCounts.get(link.clientId) ?? 0) + 1);
+    }
+    const resumeToken = `resume:${link.clientId}`;
+    this.resumeTokens.set(resumeToken, link.clientId);
+    this.toClient(
+      link,
+      encodeFrame(
+        FrameType.WELCOME,
+        encodeWelcome({
+          clientId: link.clientId,
+          role: joined.role,
+          tick: joined.tick,
+          snapshot: joined.snapshot,
+          resumeToken,
+          roomId: this.roomId,
+          tickIntervalMs: Math.round(this.intervalMs)
+        })
+      )
+    );
+  }
+  fail(link, code, message) {
+    this.toClient(
+      link,
+      encodeFrame(
+        FrameType.ERROR,
+        encodeErrorPayload({ code: ErrorCode[code].code, message, fatal: true })
+      )
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Room to client
+  // -------------------------------------------------------------------------
+  toClient(link, frame) {
+    const type = frame[0] ?? -1;
+    if (type === FrameType.DELTA || type === FrameType.CORRECT) this.checkFrame(link, frame);
+    if (type === FrameType.REPLY) this.noteReply(link, frame);
+    this.record("out", link.clientId, type, frame.length);
+    this.schedule(link, "out", type, () => link.socket.deliver(frame));
+  }
+  /** A `DELTA`/`CORRECT` naming a collection this client's role may not see is a leak. */
+  checkFrame(link, frame) {
+    let delta;
+    try {
+      delta = decodeDelta(this.ext, decodeFrame(frame).payload);
+    } catch {
+      return;
+    }
+    const keep = visibleNames(this.ext, link.role);
+    for (const dc of delta.collections) {
+      if (keep.has(dc.name) || dc.ops.length === 0) continue;
+      this.frameLeaks.push({
+        clientId: link.clientId,
+        role: link.role,
+        collection: dc.name,
+        kind: "frame",
+        ids: dc.ops.map((o) => o.id),
+        tick: delta.tick
+      });
+    }
+  }
+  noteReply(link, frame) {
+    try {
+      const reply = decodeReply(decodeFrame(frame).payload);
+      const rpc = link.calls.get(reply.reqId);
+      if (rpc === void 0) return;
+      link.calls.delete(reply.reqId);
+      if (reply.ok) return;
+      this.rejectionLog.push({
+        clientId: link.clientId,
+        rpc,
+        error: reply.error,
+        tick: this.coreRef.tick
+      });
+    } catch {
+    }
+  }
+  record(dir, clientId, type, bytes) {
+    let frame;
+    try {
+      frame = frameTypeName(type);
+    } catch {
+      return;
+    }
+    this.traceLog.push({
+      dir,
+      clientId,
+      frame,
+      tick: this.coreRef.tick,
+      bytes,
+      at: this.clock.time
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Clock
+  // -------------------------------------------------------------------------
+  /** Fires everything due, then lets the clients' promises run, until nothing new is in flight. */
+  async settle() {
+    for (let i = 0; i < SETTLE_ROUNDS; i++) {
+      const before = this.activity;
+      await microtasks();
+      this.clock.advance(0);
+      if (this.activity === before) return;
+    }
+    throw new Error("testRoom: the frame pump did not settle");
+  }
+  async tick(n = 1) {
+    for (let i = 0; i < n; i++) {
+      this.clock.advance(this.mode === "tick" ? this.intervalMs : 0);
+      await this.settle();
+    }
+  }
+  async run(ms) {
+    this.clock.advance(ms);
+    await this.settle();
+  }
+  /**
+   * Advances until `pred()` holds. In **event mode** a tick is a zero-length clock step, so this
+   * advances `stepMs` (1 ms by default) of fake time per attempt instead — otherwise a condition
+   * that depends on a timer, such as a dropped client's 250 ms reconnect backoff, could never
+   * become true no matter how large `maxTicks` was. Found when a test spent its whole budget
+   * on `t.until: predicate still false after 1000 ticks`.
+   */
+  async until(pred, options = {}) {
+    const maxTicks = options.maxTicks ?? 1e3;
+    const stepMs = options.stepMs ?? (this.mode === "tick" ? this.intervalMs : 1);
+    await this.settle();
+    if (pred()) return;
+    for (let i = 0; i < maxTicks; i++) {
+      this.clock.advance(stepMs);
+      await this.settle();
+      if (pred()) return;
+    }
+    throw new Error(
+      `t.until: predicate still false after ${maxTicks} attempts (${maxTicks * stepMs} ms of fake time, mode=${this.mode})`
+    );
+  }
+  async join(a, b) {
+    if (typeof a === "number") {
+      const out = [];
+      for (let i = 0; i < a; i++) out.push(await this.joinOne(b ?? {}));
+      return out;
+    }
+    return this.joinOne(a ?? {});
+  }
+  async joinOne(spec) {
+    const options = {
+      url: TEST_URL,
+      key: TEST_KEY,
+      room: this.roomId,
+      transport: this.transportFor(spec),
+      scheduler: this.scheduler,
+      ...this.writeIntervalMs !== void 0 ? { writeIntervalMs: this.writeIntervalMs } : {},
+      ...spec.role !== void 0 ? { role: spec.role } : {},
+      ...spec.name !== void 0 ? { name: spec.name } : {},
+      ...spec.rpc !== void 0 ? { rpc: spec.rpc } : {}
+    };
+    const room = await this.awaitJoin(joinRoom(this.definition.schema, options));
+    const client = Object.create(room);
+    Object.defineProperties(client, {
+      id: { get: () => room.me, enumerable: true },
+      roomId: { get: () => room.id, enumerable: true },
+      view: { get: () => room.state, enumerable: true },
+      reconnects: { get: () => this.reconnectCounts.get(room.me) ?? 0, enumerable: true },
+      drop: {
+        value: (options2) => this.dropClient(room.me, options2),
+        enumerable: true
+      }
+    });
+    this.clientList.push(client);
+    return client;
+  }
+  /**
+   * Drives the clock until `joinRoom` settles. A zero-latency join lands inside the first
+   * `advance(0)`; a slow link needs the 1 ms steps.
+   */
+  async awaitJoin(promise) {
+    let settled = false;
+    let value;
+    let error;
+    promise.then(
+      (v) => {
+        settled = true;
+        value = v;
+      },
+      (e) => {
+        settled = true;
+        error = e instanceof Error ? e : new Error(String(e));
+      }
+    );
+    this.clock.advance(0);
+    await microtasks();
+    for (let ms = 0; ms < JOIN_TIMEOUT_MS && !settled; ms++) {
+      this.clock.advance(1);
+      await microtasks();
+    }
+    if (error !== void 0) throw error;
+    if (!settled) throw new Error("testRoom: join never resolved");
+    await this.settle();
+    return value;
+  }
+  // -------------------------------------------------------------------------
+  // Visibility, convergence, bandwidth
+  // -------------------------------------------------------------------------
+  /**
+   * Judges `clientId` as `role` in `checkVisibility` from now on, without telling the room. The
+   * only way to prove the leak detector fires: a correct room never produces a leak, so a test
+   * that asserts the checker works has to assert a client against a role it did not join as.
+   */
+  pretendRole(clientId, role) {
+    this.roleOverrides.set(clientId, role);
+  }
+  roleFor(clientId) {
+    return this.roleOverrides.get(clientId) ?? this.roleById.get(clientId) ?? "";
+  }
+  checkVisibility() {
+    const leaks = [...this.frameLeaks];
+    for (const client of this.clientList) {
+      const role = this.roleFor(client.id);
+      const keep = visibleNames(this.ext, role);
+      const view = client.view;
+      for (const c of this.ext.collections) {
+        if (keep.has(c.name)) continue;
+        if (c.kind === "entity") {
+          const coll = view[c.name];
+          if (!coll || coll.size === 0) continue;
+          leaks.push({
+            clientId: client.id,
+            role,
+            collection: c.name,
+            kind: "view",
+            ids: [...coll.ids()],
+            tick: this.coreRef.tick
+          });
+        } else {
+          if (singletonIsDefault(c, view[c.name])) continue;
+          leaks.push({
+            clientId: client.id,
+            role,
+            collection: c.name,
+            kind: "view",
+            ids: [""],
+            tick: this.coreRef.tick
+          });
+        }
+      }
+    }
+    return leaks;
+  }
+  /** Per-client divergence from the authority, restricted to what that client's role may see. */
+  convergence() {
+    const out = [];
+    for (const client of this.clientList) {
+      const role = this.roleFor(client.id);
+      const view = materialize(this.ext, client.view);
+      out.push({
+        clientId: client.id,
+        differences: divergence(this.ext, this.plain, view, visibleNames(this.ext, role))
+      });
+    }
+    return out;
+  }
+  /** Outbound bytes per client, and the ticks they were spread over. */
+  bandwidth() {
+    const ticks = Math.max(1, this.coreRef.tick);
+    const totals = /* @__PURE__ */ new Map();
+    for (const entry of this.traceLog) {
+      if (entry.dir !== "out") continue;
+      totals.set(entry.clientId, (totals.get(entry.clientId) ?? 0) + entry.bytes);
+    }
+    return [...totals].map(([clientId, bytes]) => ({ clientId, bytes, perTick: bytes / ticks }));
+  }
+  stop() {
+    this.stopped = true;
+    for (const client of this.clientList) client.leave();
+    for (const link of this.links) link.socket.hangUp();
+    this.coreRef.stop();
+  }
+};
+function configure(definition, options) {
+  if (options.mode === void 0 && options.tickRate === void 0) return definition;
+  return {
+    ...definition,
+    config: {
+      ...definition.config,
+      ...options.mode !== void 0 ? { mode: options.mode } : {},
+      ...options.tickRate !== void 0 ? { tickRate: options.tickRate } : {}
+    }
+  };
+}
+
+// src/assertions.ts
+var TRACE_TAIL = 10;
+function harnessOf(received) {
+  if (!(received instanceof TestHarness)) {
+    throw new TypeError("irtio matchers expect the object returned by testRoom()");
+  }
+  return received;
+}
+function traceTail(t) {
+  const tail = t.trace.slice(-TRACE_TAIL);
+  if (tail.length === 0) return "trace: empty";
+  const lines = tail.map(
+    (e) => `  ${Math.round(e.at)}ms tick ${e.tick} ${e.dir === "in" ? "\u2192" : "\u2190"} ${e.clientId} ${e.frame} ${e.bytes}B`
+  );
+  return `trace (last ${tail.length}):
+${lines.join("\n")}`;
+}
+function withTrace(t, body) {
+  return `${body}
+
+${traceTail(t)}`;
+}
+function toHaveNoVisibilityLeaks(received) {
+  const t = harnessOf(received);
+  const leaks = t.checkVisibility();
+  return {
+    pass: leaks.length === 0,
+    message: () => leaks.length === 0 ? withTrace(t, "expected the room to leak something, but every view was role-clean") : withTrace(
+      t,
+      `expected no visibility leaks, found ${leaks.length}:
+${leaks.map(
+        (l) => `  ${l.clientId} (${l.role}) saw ${l.collection} [${l.ids.join(", ")}] in its ${l.kind} at tick ${l.tick}`
+      ).join("\n")}`
+    )
+  };
+}
+function toHaveConverged(received) {
+  const t = harnessOf(received);
+  const behind = t.convergence().filter((r) => r.differences.length > 0);
+  return {
+    pass: behind.length === 0,
+    message: () => behind.length === 0 ? withTrace(t, "expected at least one client to differ from the authority, none did") : withTrace(
+      t,
+      `expected every client to have converged, ${behind.length} had not:
+${behind.map((r) => `  ${r.clientId}:
+${r.differences.map((d) => `    ${d}`).join("\n")}`).join("\n")}`
+    )
+  };
+}
+function toHaveRejected(received, rpcName) {
+  const t = harnessOf(received);
+  const hits = t.rejections.filter((r) => r.rpc === rpcName);
+  const seen = [...new Set(t.rejections.map((r) => r.rpc))];
+  return {
+    pass: hits.length > 0,
+    message: () => hits.length > 0 ? withTrace(
+      t,
+      `expected no call to ${JSON.stringify(rpcName)} to be rejected, but ${hits.length} was: ${hits.map((h) => `${h.clientId}: ${h.error}`).join("; ")}`
+    ) : withTrace(
+      t,
+      `expected some call to ${JSON.stringify(rpcName)} to be rejected; ` + (seen.length === 0 ? "no rpc was rejected at all" : `rejected rpcs so far: ${seen.join(", ")}`)
+    )
+  };
+}
+function toStayUnderBandwidth(received, bytesPerTick) {
+  const t = harnessOf(received);
+  const usage = t.bandwidth();
+  const worst = usage.reduce(
+    (acc, u) => acc === void 0 || u.perTick > acc.perTick ? u : acc,
+    void 0
+  );
+  const perTick = worst?.perTick ?? 0;
+  return {
+    pass: perTick <= bytesPerTick,
+    message: () => perTick <= bytesPerTick ? withTrace(
+      t,
+      `expected some client to exceed ${bytesPerTick} B/tick, the worst was ${worst?.clientId ?? "nobody"} at ${perTick.toFixed(1)} B/tick`
+    ) : withTrace(
+      t,
+      `expected every client to stay under ${bytesPerTick} B/tick, but ${worst?.clientId} received ${worst?.bytes} B over ${t.tickCount} ticks (${perTick.toFixed(1)} B/tick)`
+    )
+  };
+}
+var matchers = {
+  toHaveNoVisibilityLeaks,
+  toHaveConverged,
+  toHaveRejected,
+  toStayUnderBandwidth
+};
+
+export {
+  materialize,
+  divergence,
+  InProcessSocket,
+  clockScheduler,
+  TestHarness,
+  TRACE_TAIL,
+  toHaveNoVisibilityLeaks,
+  toHaveConverged,
+  toHaveRejected,
+  toStayUnderBandwidth,
+  matchers
+};