@irtio/runtime 0.1.0

package/dist/chunk-X5S364FY.js

@@ -0,0 +1,1573 @@
+// src/contract.ts
+var RoomFullError = class extends Error {
+  constructor(maxClients) {
+    super(`room is full (maxClients=${maxClients})`);
+    this.maxClients = maxClients;
+  }
+  maxClients;
+  name = "RoomFullError";
+};
+
+// src/core/inspect.ts
+import { EntityCollection } from "@irtio/schema";
+var EVENT_RING_SIZE = 100;
+var EventRing = class {
+  items = [];
+  push(e) {
+    this.items.push(e);
+    if (this.items.length > EVENT_RING_SIZE) this.items.shift();
+  }
+  list() {
+    return this.items;
+  }
+};
+function inspectState(schema, plain) {
+  const out = {};
+  for (const c of schema.collections) {
+    const v = plain[c.name];
+    if (v instanceof EntityCollection) {
+      const recs = {};
+      for (const [id, value] of v) recs[id] = { owner: v.ownerOf(id), value };
+      out[c.name] = recs;
+    } else {
+      out[c.name] = v;
+    }
+  }
+  return out;
+}
+
+// src/core/rpc.ts
+import {
+  FrameType,
+  decodeCall,
+  decodeReply,
+  encodeCall,
+  encodeFrame,
+  encodeReply,
+  rpcByIdOf,
+  rpcTable
+} from "@irtio/protocol";
+import {
+  SERVER_OWNER,
+  decodeFields,
+  encodeFields,
+  validateValue
+} from "@irtio/schema";
+
+// src/core/internals.ts
+function collectionDescOf(ext, name) {
+  return ext.collections.find((c) => c.name === name);
+}
+function plainEntity(plain, name) {
+  return plain[name];
+}
+function trackedEntity(core, name) {
+  return core.anyState[name];
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+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;
+    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+    return true;
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const k of keys) if (!deepEqual(a[k], b[k])) return false;
+  return true;
+}
+
+// src/core/rpc.ts
+var RPC_TIMEOUT_MS = 5e3;
+var REQUEST_OWNERSHIP = "requestOwnership";
+var states = /* @__PURE__ */ new WeakMap();
+function stateOf(core) {
+  let s = states.get(core);
+  if (!s) {
+    s = { nextReqId: 1, pending: /* @__PURE__ */ new Map() };
+    states.set(core, s);
+  }
+  return s;
+}
+function pendingKey(clientId, reqId) {
+  return `${clientId} ${reqId}`;
+}
+function errorText(code, detail) {
+  return detail === void 0 ? code : `${code}: ${detail}`;
+}
+function sendReply(core, clientId, reqId, result, error) {
+  const payload = result === null ? encodeReply({ reqId, ok: false, error: error ?? errorText("E_INTERNAL") }) : encodeReply({ reqId, ok: true, result });
+  core.send(clientId, encodeFrame(FrameType.REPLY, payload));
+}
+function handleCall(core, clientId, payload) {
+  let call;
+  try {
+    call = decodeCall(payload);
+  } catch (err) {
+    core.log("warn", `CALL from ${clientId} failed to decode:`, err);
+    return false;
+  }
+  let desc;
+  try {
+    desc = rpcByIdOf(core.definition.schema, call.rpcId);
+    core.recordEvent("call", clientId, desc.name);
+  } catch {
+    sendReply(core, clientId, call.reqId, null, errorText("E_RPC_UNKNOWN", `rpcId ${call.rpcId}`));
+    return true;
+  }
+  if (desc.direction !== "server") {
+    sendReply(
+      core,
+      clientId,
+      call.reqId,
+      null,
+      errorText("E_RPC_REJECTED", `${desc.name} is a client-direction rpc`)
+    );
+    return true;
+  }
+  let params;
+  try {
+    params = decodeFields(desc.params, call.params);
+  } catch (err) {
+    sendReply(core, clientId, call.reqId, null, errorText("E_RPC_BAD_PARAMS", String(err)));
+    return true;
+  }
+  for (const f of desc.params) {
+    const problem = validateValue(f.type, params[f.name], f.name);
+    if (problem) {
+      sendReply(core, clientId, call.reqId, null, errorText("E_RPC_BAD_PARAMS", problem));
+      return true;
+    }
+  }
+  const ctx = core.ctxFor(clientId);
+  let result;
+  if (desc.name === REQUEST_OWNERSHIP) {
+    result = runRequestOwnership(core, clientId, params);
+  } else {
+    const impl = core.definition.config.rpc?.[desc.name];
+    if (!impl) {
+      sendReply(core, clientId, call.reqId, null, errorText("E_RPC_UNKNOWN", desc.name));
+      return true;
+    }
+    try {
+      result = impl(core.anyState, params, ctx);
+    } catch (err) {
+      core.stats.handlerErrors++;
+      core.log("error", `rpc.${desc.name} threw:`, err);
+      sendReply(core, clientId, call.reqId, null, err instanceof Error ? err.message : String(err));
+      return true;
+    }
+  }
+  if (!desc.returns) {
+    sendReply(core, clientId, call.reqId, new Uint8Array(0));
+    return true;
+  }
+  try {
+    sendReply(core, clientId, call.reqId, encodeFields(desc.returns, result ?? {}));
+  } catch (err) {
+    core.log("error", `rpc.${desc.name} returned a value that failed to encode:`, err);
+    core.stats.handlerErrors++;
+    sendReply(core, clientId, call.reqId, null, errorText("E_INTERNAL", `rpc ${desc.name}`));
+  }
+  return true;
+}
+function runRequestOwnership(core, clientId, params) {
+  const name = String(params.entity ?? "");
+  const id = String(params.id ?? "");
+  const c = collectionDescOf(core.ext, name);
+  if (!c || c.kind !== "entity" || c.serverOwned) return { granted: false };
+  const plain = plainEntity(core.plain, name);
+  if (!plain.has(id)) return { granted: false };
+  const handler = core.definition.config.onOwnershipRequest;
+  const tracked = trackedEntity(core, name);
+  if (handler) {
+    const ran = core.tryRun(
+      "onOwnershipRequest",
+      () => handler(core.anyState, name, id, core.ctxFor(clientId))
+    );
+    if (ran.ok && ran.value === true && plain.ownerOf(id) !== clientId) {
+      tracked.setOwner(id, clientId);
+    }
+    return { granted: plain.ownerOf(id) === clientId };
+  }
+  const owner = plain.ownerOf(id);
+  if (owner === clientId) return { granted: true };
+  if (owner !== SERVER_OWNER) return { granted: false };
+  tracked.setOwner(id, clientId);
+  return { granted: true };
+}
+function descFor(core, name) {
+  const found = rpcTable(core.definition.schema).find((r) => r.name === name);
+  if (!found) throw new Error(`room.call: unknown rpc ${JSON.stringify(name)}`);
+  if (found.direction !== "client") {
+    throw new Error(`room.call: ${name} is a client\u2192server rpc; call it from the client`);
+  }
+  return found;
+}
+function sendCall(core, clientId, desc, params) {
+  const s = stateOf(core);
+  const reqId = s.nextReqId;
+  s.nextReqId = s.nextReqId + 1 >>> 0 || 1;
+  const bytes = encodeFields(desc.params, params);
+  core.send(
+    clientId,
+    encodeFrame(FrameType.CALL, encodeCall({ reqId, rpcId: desc.index, params: bytes }))
+  );
+  return reqId;
+}
+function createCallProxy(core, clientId) {
+  return new Proxy(
+    {},
+    {
+      get(_t, prop) {
+        if (typeof prop !== "string") return void 0;
+        return (params) => {
+          const desc = descFor(core, prop);
+          return new Promise((resolve, reject2) => {
+            const entry = core.clients.get(clientId);
+            if (!entry || !entry.connected) {
+              reject2(new Error(`room.call: ${clientId} is not connected`));
+              return;
+            }
+            const reqId = sendCall(core, clientId, desc, params ?? {});
+            const s = stateOf(core);
+            s.pending.set(pendingKey(clientId, reqId), {
+              clientId,
+              name: desc.name,
+              returns: desc.returns,
+              deadline: core.host.now() + RPC_TIMEOUT_MS,
+              resolve,
+              reject: reject2
+            });
+            if (core.mode === "event") {
+              core.loop.after(RPC_TIMEOUT_MS, () => checkTimeouts(core));
+            }
+          });
+        };
+      }
+    }
+  );
+}
+function createBroadcastProxy(core) {
+  return new Proxy(
+    {},
+    {
+      get(_t, prop) {
+        if (typeof prop !== "string") return void 0;
+        return (params) => {
+          const desc = descFor(core, prop);
+          for (const entry of core.clients.values()) {
+            if (entry.connected) sendCall(core, entry.clientId, desc, params ?? {});
+          }
+        };
+      }
+    }
+  );
+}
+function handleReply(core, clientId, payload) {
+  let reply;
+  try {
+    reply = decodeReply(payload);
+  } catch (err) {
+    core.log("warn", `REPLY from ${clientId} failed to decode:`, err);
+    return false;
+  }
+  const s = stateOf(core);
+  const key = pendingKey(clientId, reply.reqId);
+  const pending = s.pending.get(key);
+  if (!pending) {
+    core.log("warn", `REPLY from ${clientId} for unknown reqId ${reply.reqId}`);
+    return true;
+  }
+  s.pending.delete(key);
+  if (!reply.ok) {
+    pending.reject(new Error(reply.error));
+    return true;
+  }
+  if (!pending.returns) {
+    pending.resolve(void 0);
+    return true;
+  }
+  try {
+    pending.resolve(decodeFields(pending.returns, reply.result));
+  } catch (err) {
+    pending.reject(new Error(`${pending.name}: bad reply payload: ${String(err)}`));
+  }
+  return true;
+}
+function rejectPendingFor(core, clientId, reason) {
+  const s = stateOf(core);
+  for (const [key, p] of [...s.pending]) {
+    if (p.clientId !== clientId) continue;
+    s.pending.delete(key);
+    p.reject(new Error(reason));
+  }
+}
+function checkTimeouts(core) {
+  const s = stateOf(core);
+  if (s.pending.size === 0) return;
+  const now = core.host.now();
+  for (const [key, p] of [...s.pending]) {
+    if (p.deadline > now) continue;
+    s.pending.delete(key);
+    p.reject(new Error(errorText("E_RPC_TIMEOUT", `rpc ${p.name} timed out`)));
+  }
+}
+function rejectAllPending(core, reason) {
+  const s = stateOf(core);
+  for (const [key, p] of [...s.pending]) {
+    s.pending.delete(key);
+    p.reject(new Error(reason));
+  }
+}
+
+// src/core/loop.ts
+import { FrameType as FrameType2 } from "@irtio/protocol";
+
+// src/core/writes.ts
+import {
+  SERVER_OWNER as SERVER_OWNER2,
+  cloneValue,
+  decodeDelta,
+  encodeDelta,
+  markField,
+  normalizeRecord
+} from "@irtio/schema";
+function structFieldList(desc) {
+  return Object.entries(desc.fields).map(([name, type]) => ({ name, type }));
+}
+function leafPaths(fields, mask) {
+  const out = [];
+  const walk = (list, m, path, names) => {
+    for (const idx of [...m.fields].sort((a, b) => a - b)) {
+      const f = list[idx];
+      if (!f) continue;
+      const nested = m.nested.get(idx);
+      if (nested && f.type.kind === "struct") {
+        walk(structFieldList(f.type), nested, [...path, idx], [...names, f.name]);
+        continue;
+      }
+      out.push({ path: [...path, idx], names: [...names, f.name] });
+    }
+  };
+  walk(fields, mask, [], []);
+  return out;
+}
+function leafKey(leaf) {
+  return leaf.path.join(".");
+}
+function valueAt(record, names) {
+  let cur = record;
+  for (const n of names) {
+    if (!isPlainObject(cur)) return void 0;
+    cur = cur[n];
+  }
+  return cur;
+}
+function fieldList(c) {
+  return c.fields.map((f) => ({ name: f.name, type: f.type }));
+}
+function applyMaskedPatch(fields, target, patch, mask) {
+  for (const idx of [...mask.fields].sort((a, b) => a - b)) {
+    const f = fields[idx];
+    if (!f) continue;
+    const value = patch[f.name];
+    const nested = mask.nested.get(idx);
+    if (nested && f.type.kind === "struct" && isPlainObject(value)) {
+      const current = target[f.name];
+      if (isPlainObject(current)) {
+        applyMaskedPatch(structFieldList(f.type), current, value, nested);
+        continue;
+      }
+    }
+    target[f.name] = cloneValue(value);
+  }
+}
+function assignChanged(desc, target, key, prev, next) {
+  if (desc.kind === "struct" && isPlainObject(prev) && isPlainObject(next)) {
+    const sub = target[key];
+    if (isPlainObject(sub)) {
+      for (const f of structFieldList(desc))
+        assignChanged(f.type, sub, f.name, prev[f.name], next[f.name]);
+      return;
+    }
+  }
+  if (!deepEqual(prev, next)) target[key] = next;
+}
+function applyChanged(fields, target, prev, next) {
+  for (const f of fields) assignChanged(f.type, target, f.name, prev[f.name], next[f.name]);
+}
+function correctLeaves(core, clientId, collection, id, leaves) {
+  if (leaves.length === 0) return;
+  const dirty = core.correctionFor(clientId);
+  if (!dirty) return;
+  for (const leaf of leaves) markField(dirty, collection, id, leaf.path);
+  core.stats.corrections++;
+}
+function recordOf(plain, c, id) {
+  if (c.kind === "singleton") return plain[c.name];
+  return plainEntity(plain, c.name).get(id);
+}
+function applyWrite(core, clientId, payload) {
+  let delta;
+  try {
+    delta = decodeDelta(core.ext, payload);
+  } catch (err) {
+    core.log("warn", `WRITE from ${clientId} failed to decode:`, err);
+    return { ok: false };
+  }
+  const judged = core.clients.get(clientId);
+  if (judged && delta.tick > judged.lastClientTick) judged.lastClientTick = delta.tick;
+  for (const dc of delta.collections) {
+    const c = collectionDescOf(core.ext, dc.name);
+    if (!c) continue;
+    for (const op of dc.ops) applyOp(core, clientId, c, op);
+  }
+  return { ok: true };
+}
+function reject(core, clientId, c, op, reason) {
+  core.recordEvent("write-rejected", clientId, `${c.name}: ${reason}`);
+  core.log("warn", `WRITE rejected (${reason}) from ${clientId} on ${c.name}`);
+  if (op.op !== "update") return;
+  if (!recordOf(core.plain, c, op.id)) return;
+  correctLeaves(core, clientId, c.name, op.id, leafPaths(fieldList(c), op.mask));
+}
+function applyOp(core, clientId, c, op) {
+  if (op.op !== "update") {
+    reject(core, clientId, c, op, `op '${op.op}' is not allowed in a WRITE`);
+    return;
+  }
+  if (c.kind !== "entity") {
+    reject(core, clientId, c, op, "not an entity collection");
+    return;
+  }
+  if (c.serverOwned) {
+    reject(core, clientId, c, op, "collection is serverOwned");
+    return;
+  }
+  if (op.owner !== void 0) {
+    reject(core, clientId, c, op, "owner changes are not allowed in a WRITE");
+    return;
+  }
+  const plainColl = plainEntity(core.plain, c.name);
+  const current = plainColl.get(op.id);
+  if (current === void 0) return;
+  if (plainColl.ownerOf(op.id) !== clientId) {
+    reject(core, clientId, c, op, "not the owner");
+    return;
+  }
+  const fields = fieldList(c);
+  const prev = cloneValue(current);
+  const next = cloneValue(current);
+  applyMaskedPatch(fields, next, op.patch, op.mask);
+  const validator = core.definition.config.validate?.[c.name];
+  let result = next;
+  if (validator) {
+    const ctx = core.ctxFor(clientId);
+    const ran = core.tryRun(`validate.${c.name}`, () => validator(prev, next, ctx));
+    if (!ran.ok) result = prev;
+    else {
+      const returned = ran.value;
+      try {
+        result = normalizeRecord(c, returned ?? next);
+      } catch (err) {
+        core.log("error", `validate.${c.name} returned an invalid record; write rejected:`, err);
+        result = prev;
+      }
+    }
+  }
+  const tracked = trackedEntity(core, c.name).get(op.id);
+  if (tracked) applyChanged(fields, tracked, prev, result);
+  const entry = core.clients.get(clientId);
+  const written = op.owner === void 0 ? leafPaths(fields, op.mask) : [];
+  if (entry) {
+    const key = `${c.name}\0${op.id}`;
+    let map = entry.accepted.get(key);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      entry.accepted.set(key, map);
+    }
+    for (const leaf of written) map.set(leafKey(leaf), cloneValue(valueAt(result, leaf.names)));
+  }
+  const corrected = written.filter(
+    (leaf) => !deepEqual(valueAt(result, leaf.names), valueAt(next, leaf.names))
+  );
+  correctLeaves(core, clientId, c.name, op.id, corrected);
+}
+function serverWinsCorrections(core, dirty) {
+  const ext = core.ext;
+  for (const [name, cd] of dirty) {
+    if (cd.updated.size === 0) continue;
+    const c = collectionDescOf(ext, name);
+    if (!c || c.kind !== "entity" || c.serverOwned) continue;
+    const coll = plainEntity(core.plain, name);
+    const fields = fieldList(c);
+    for (const [id, rd] of cd.updated) {
+      const owner = coll.ownerOf(id);
+      if (owner === void 0 || owner === SERVER_OWNER2) continue;
+      const entry = core.clients.get(owner);
+      if (!entry || !entry.connected) continue;
+      const value = coll.get(id);
+      if (value === void 0) continue;
+      const accepted = entry.accepted.get(`${name}\0${id}`);
+      const stale = [];
+      for (const leaf of leafPaths(fields, rd.mask)) {
+        const key = leafKey(leaf);
+        if (accepted?.has(key) && deepEqual(accepted.get(key), valueAt(value, leaf.names)))
+          continue;
+        stale.push(leaf);
+      }
+      correctLeaves(core, owner, name, id, stale);
+    }
+  }
+}
+function encodeCorrection(core, dirty) {
+  let empty = true;
+  for (const cd of dirty.values()) {
+    if (cd.added.size || cd.removed.size || cd.updated.size) {
+      empty = false;
+      break;
+    }
+  }
+  if (empty) return null;
+  return encodeDelta(core.ext, core.plain, dirty, { tick: core.tick });
+}
+
+// src/core/loop.ts
+var MAX_CATCHUP = 5;
+var CRASH_AFTER_THROWS = 3;
+var Loop = class {
+  constructor(core) {
+    this.core = core;
+  }
+  core;
+  inbound = [];
+  timers = /* @__PURE__ */ new Map();
+  internal = /* @__PURE__ */ new Set();
+  nextTimerId = 1;
+  tickHandle;
+  idleHandle;
+  running = false;
+  lastWake = 0;
+  accumulator = 0;
+  overrunLogged = false;
+  consecutiveThrows = 0;
+  lastActivity = 0;
+  slept = false;
+  get intervalMs() {
+    return 1e3 / this.core.definition.config.tickRate;
+  }
+  start() {
+    if (this.running || this.core.stopped) return;
+    this.running = true;
+    this.lastWake = this.core.host.now();
+    this.lastActivity = this.lastWake;
+    this.accumulator = 0;
+    if (this.core.mode === "tick") this.scheduleTick();
+    else this.armIdle(this.core.definition.config.idleMs);
+  }
+  stop() {
+    this.running = false;
+    if (this.tickHandle !== void 0) {
+      this.core.host.clearTimeout(this.tickHandle);
+      this.tickHandle = void 0;
+    }
+    if (this.idleHandle !== void 0) {
+      this.core.host.clearTimeout(this.idleHandle);
+      this.idleHandle = void 0;
+    }
+    for (const h of this.internal) this.core.host.clearTimeout(h);
+    this.internal.clear();
+    this.clearAllTimers();
+  }
+  // -------------------------------------------------------------------------
+  // Inbound queue (tick mode)
+  // -------------------------------------------------------------------------
+  enqueue(frame) {
+    this.inbound.push(frame);
+  }
+  dropFramesFor(clientId) {
+    for (let i = this.inbound.length - 1; i >= 0; i--) {
+      if (this.inbound[i].clientId === clientId) this.inbound.splice(i, 1);
+    }
+  }
+  drainInbound() {
+    while (this.inbound.length > 0) {
+      const f = this.inbound.shift();
+      if (!this.core.clients.has(f.clientId)) continue;
+      this.applyFrame(f);
+    }
+  }
+  /** Applies one queued/immediate frame. Returns `false` on a malformed payload. */
+  applyFrame(f) {
+    if (f.type === FrameType2.WRITE) return applyWrite(this.core, f.clientId, f.payload).ok;
+    if (f.type === FrameType2.CALL) return handleCall(this.core, f.clientId, f.payload);
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Tick mode
+  // -------------------------------------------------------------------------
+  scheduleTick() {
+    this.tickHandle = this.core.host.setTimeout(() => this.onWake(), this.intervalMs);
+  }
+  onWake() {
+    this.tickHandle = void 0;
+    if (!this.running || this.core.stopped) return;
+    const now = this.core.host.now();
+    this.accumulator += Math.max(0, now - this.lastWake);
+    this.lastWake = now;
+    let steps = Math.floor(this.accumulator / this.intervalMs);
+    if (steps <= 0) steps = 1;
+    if (steps > MAX_CATCHUP) {
+      this.core.stats.overruns++;
+      if (!this.overrunLogged) {
+        this.overrunLogged = true;
+        this.core.log(
+          "warn",
+          `tick overrun: ${steps} ticks behind, dropping the backlog (tickRate=${this.core.definition.config.tickRate})`
+        );
+      }
+      steps = MAX_CATCHUP;
+      this.accumulator = 0;
+    } else {
+      this.overrunLogged = false;
+      this.accumulator -= steps * this.intervalMs;
+    }
+    for (let i = 0; i < steps; i++) {
+      if (!this.running || this.core.stopped) break;
+      this.runTick();
+    }
+    if (this.running && !this.core.stopped) this.scheduleTick();
+  }
+  /** One tick: inbound → room timers → `tick(state, dt, room)` → flush. */
+  runTick() {
+    const host = this.core.host;
+    const started = host.now();
+    this.core.tick++;
+    this.drainInbound();
+    this.fireDueTimers();
+    checkTimeouts(this.core);
+    const config = this.core.definition.config;
+    if (config.tick) {
+      const fn = config.tick;
+      const dt = 1 / config.tickRate;
+      const ran = this.core.tryRun(
+        "tick",
+        () => fn(this.core.anyState, dt, this.core.room)
+      );
+      if (ran.ok) this.consecutiveThrows = 0;
+      else {
+        this.consecutiveThrows++;
+        if (this.consecutiveThrows >= CRASH_AFTER_THROWS) {
+          this.core.flush();
+          const reason = `tick() threw ${this.consecutiveThrows} times in a row`;
+          this.core.stopped = true;
+          this.stop();
+          host.crashed(reason);
+          return;
+        }
+      }
+    }
+    this.core.flush();
+    const elapsed = Math.max(0, host.now() - started);
+    const stats = this.core.stats;
+    stats.ticks++;
+    stats.lastTickMs = elapsed;
+    if (elapsed > stats.maxTickMs) stats.maxTickMs = elapsed;
+  }
+  fireDueTimers() {
+    for (const t of [...this.timers.values()]) {
+      if (t.dueTick > this.core.tick) continue;
+      if (t.repeat) t.dueTick = this.core.tick + t.periodTicks;
+      else this.timers.delete(t.id);
+      this.core.guard("room timer", t.fn);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Event mode
+  // -------------------------------------------------------------------------
+  /** Applies one frame as its own event: tick++, apply, flush. */
+  applyEvent(f) {
+    this.core.tick++;
+    const ok = this.applyFrame(f);
+    this.core.flush();
+    return ok;
+  }
+  noteActivity() {
+    if (this.core.mode !== "event") return;
+    this.lastActivity = this.core.host.now();
+    this.slept = false;
+    if (this.running && this.idleHandle === void 0) {
+      this.armIdle(this.core.definition.config.idleMs);
+    }
+  }
+  armIdle(ms) {
+    this.idleHandle = this.core.host.setTimeout(() => this.onIdleCheck(), Math.max(0, ms));
+  }
+  onIdleCheck() {
+    this.idleHandle = void 0;
+    if (!this.running || this.core.stopped) return;
+    const idleMs = this.core.definition.config.idleMs;
+    const waited = this.core.host.now() - this.lastActivity;
+    if (waited >= idleMs) {
+      if (!this.slept) {
+        this.slept = true;
+        this.core.host.sleep();
+      }
+      return;
+    }
+    this.armIdle(idleMs - waited);
+  }
+  // -------------------------------------------------------------------------
+  // Room timers
+  // -------------------------------------------------------------------------
+  setTimer(ms, fn, repeat) {
+    const id = this.nextTimerId++;
+    const periodTicks = Math.max(1, Math.ceil(ms * this.core.definition.config.tickRate / 1e3));
+    const timer = {
+      id,
+      fn,
+      repeat,
+      periodTicks,
+      periodMs: Math.max(0, ms),
+      dueTick: this.core.tick + periodTicks,
+      handle: void 0
+    };
+    this.timers.set(id, timer);
+    if (this.core.mode === "event") this.armHostTimer(timer);
+    return id;
+  }
+  armHostTimer(timer) {
+    timer.handle = this.core.host.setTimeout(() => {
+      timer.handle = void 0;
+      if (this.core.stopped) return;
+      if (!this.timers.has(timer.id)) return;
+      if (timer.repeat) this.armHostTimer(timer);
+      else this.timers.delete(timer.id);
+      this.core.tick++;
+      this.core.guard("room timer", timer.fn);
+      this.core.flush();
+    }, timer.periodMs);
+  }
+  clearTimer(handle) {
+    const t = this.timers.get(handle);
+    if (!t) return;
+    this.timers.delete(handle);
+    if (t.handle !== void 0) this.core.host.clearTimeout(t.handle);
+  }
+  clearAllTimers() {
+    for (const t of this.timers.values()) {
+      if (t.handle !== void 0) this.core.host.clearTimeout(t.handle);
+    }
+    this.timers.clear();
+  }
+  after(ms, fn) {
+    const handle = this.core.host.setTimeout(() => {
+      this.internal.delete(handle);
+      if (this.core.stopped) return;
+      fn();
+    }, ms);
+    this.internal.add(handle);
+  }
+};
+
+// src/core/random.ts
+var Mulberry32 = class {
+  /** Current internal state (u32). Survives hibernation. */
+  state;
+  constructor(seed) {
+    this.state = seed >>> 0;
+  }
+  /** Next float in `[0, 1)`. */
+  next() {
+    this.state = this.state + 1831565813 >>> 0;
+    let t = this.state;
+    t = Math.imul(t ^ t >>> 15, 1 | t);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+};
+
+// src/core/views.ts
+import {
+  collectionDirty,
+  createDirtySet,
+  createFieldMask,
+  encodeDelta as encodeDelta2,
+  encodeSnapshot,
+  filterDirty,
+  isDirtyEmpty,
+  markAdd,
+  markPath,
+  markRemove
+} from "@irtio/schema";
+var cache = /* @__PURE__ */ new WeakMap();
+function infoOf(ext) {
+  let i = cache.get(ext);
+  if (!i) {
+    const scoped = /* @__PURE__ */ new Set();
+    for (const c of ext.collections) {
+      if (c.visibility === "role") for (const r of c.roles ?? []) scoped.add(r);
+    }
+    i = { scoped, names: /* @__PURE__ */ new Map() };
+    cache.set(ext, i);
+  }
+  return i;
+}
+function isVisible(c, role) {
+  return c.visibility !== "role" || (c.roles ?? []).includes(role);
+}
+function visibleTo(role) {
+  return (c) => isVisible(c, role);
+}
+function visibleNames(ext, role) {
+  const info = infoOf(ext);
+  let set = info.names.get(role);
+  if (!set) {
+    set = new Set(
+      ext.collections.filter((c) => isVisible(c, role)).map((c) => c.name)
+    );
+    info.names.set(role, set);
+  }
+  return set;
+}
+function viewKeyFor(ext, role) {
+  return infoOf(ext).scoped.has(role) ? role : "all";
+}
+function encodeViewSnapshot(ext, plain, role, tick) {
+  return encodeSnapshot(ext, plain, { tick }, { collections: visibleTo(role) });
+}
+function encodeViewDelta(ext, plain, dirty, role, tick) {
+  const keep = visibleNames(ext, role);
+  const filtered = filterDirty(dirty, (name) => keep.has(name));
+  if (isDirtyEmpty(filtered)) return null;
+  return encodeDelta2(ext, plain, filtered, { tick });
+}
+function stripAdds(plain, dirty, suppress) {
+  if (suppress.size === 0) return dirty;
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, cd] of dirty) {
+    const captured = suppress.get(name);
+    if (!captured || captured.size === 0 || cd.added.size === 0) {
+      out.set(name, cd);
+      continue;
+    }
+    const coll = plainEntity(plain, name);
+    let added = cd.added;
+    for (const id of captured.keys()) {
+      if (!added.has(id)) continue;
+      const c = captured.get(id);
+      if (coll.ownerOf(id) !== c.owner || !deepEqual(coll.get(id), c.value)) continue;
+      if (added === cd.added) added = new Set(cd.added);
+      added.delete(id);
+    }
+    out.set(name, added === cd.added ? cd : { added, removed: cd.removed, updated: cd.updated });
+  }
+  return out;
+}
+function catchUpDirty(ext, plain, fromRole, toRole) {
+  const dirty = createDirtySet();
+  for (const c of ext.collections) {
+    const was = isVisible(c, fromRole);
+    const now = isVisible(c, toRole);
+    if (was === now) continue;
+    if (c.kind === "singleton") {
+      if (!now) continue;
+      const mask = createFieldMask();
+      for (const f of c.fields) markPath(mask, [f.index]);
+      collectionDirty(dirty, c.name).updated.set("", { mask, owner: false });
+      continue;
+    }
+    const coll = plainEntity(plain, c.name);
+    for (const id of [...coll.ids()]) {
+      if (now) markAdd(dirty, c.name, id);
+      else markRemove(dirty, c.name, id);
+    }
+  }
+  return dirty;
+}
+
+// src/core/snapshot.ts
+import { ByteReader, ByteWriter } from "@irtio/schema";
+var SNAPSHOT_FORMAT_VERSION = 1;
+function parseHibernationBlob(bytes) {
+  const r = new ByteReader(bytes);
+  const version = r.u8();
+  if (version !== SNAPSHOT_FORMAT_VERSION) {
+    throw new Error(`RoomCore.restore: unsupported snapshot format version ${version}`);
+  }
+  const seed = r.u32();
+  const rngState = r.u32();
+  const tick = r.u32();
+  const mode = r.u8() === 1 ? "event" : "tick";
+  return { seed, rngState, tick, mode, snapshot: r.rest() };
+}
+function writeHibernationBlob(header, snapshot) {
+  const w = new ByteWriter(snapshot.length + 16);
+  w.u8(SNAPSHOT_FORMAT_VERSION);
+  w.u32(header.seed >>> 0);
+  w.u32(header.rngState >>> 0);
+  w.u32(header.tick >>> 0);
+  w.u8(header.mode === "event" ? 1 : 0);
+  w.bytes(snapshot);
+  return w.finish();
+}
+
+// src/core/room.ts
+import {
+  FrameType as FrameType5,
+  PRESENCE_COLLECTION,
+  decodeFrame,
+  encodeCorrectFrame,
+  encodeFrame as encodeFrame4,
+  withBuiltins
+} from "@irtio/protocol";
+import {
+  cloneValue as cloneValue2,
+  createDirtySet as createDirtySet2,
+  createState,
+  decodeSnapshot,
+  encodeSnapshot as encodeSnapshot2,
+  isDirtyEmpty as isDirtyEmpty3,
+  track,
+  validateForDeploy
+} from "@irtio/schema";
+
+// src/core/messages.ts
+import { FrameType as FrameType3, decodeMsg, encodeFrame as encodeFrame2, encodeMsg } from "@irtio/protocol";
+function toRoomTarget(target) {
+  switch (target.kind) {
+    case "all":
+      return "all";
+    case "client":
+      return target.clientId;
+    case "role":
+      return { role: target.role };
+    case "server":
+      return "server";
+  }
+}
+function deliver(core, target, frame, exclude) {
+  for (const entry of core.clients.values()) {
+    if (!entry.connected) continue;
+    if (entry.clientId === exclude) continue;
+    if (target.kind === "client" && entry.clientId !== target.clientId) continue;
+    if (target.kind === "role" && entry.role !== target.role) continue;
+    core.send(entry.clientId, frame);
+  }
+}
+function handleMsg(core, clientId, payload) {
+  core.recordEvent("msg", clientId);
+  let msg;
+  try {
+    msg = decodeMsg(payload);
+  } catch (err) {
+    core.log("warn", `MSG from ${clientId} failed to decode:`, err);
+    return false;
+  }
+  const onMessage = core.definition.config.onMessage;
+  if (onMessage) {
+    const ran = core.tryRun(
+      "onMessage",
+      () => onMessage(
+        core.anyState,
+        clientId,
+        toRoomTarget(msg.target),
+        msg.payload,
+        core.ctxFor(clientId)
+      )
+    );
+    if (!ran.ok || ran.value === false) return true;
+  }
+  if (msg.target.kind === "server") return true;
+  const frame = encodeFrame2(
+    FrameType3.MSG,
+    encodeMsg({ target: { kind: "client", clientId }, payload: msg.payload })
+  );
+  deliver(core, msg.target, frame, clientId);
+  return true;
+}
+function sendMessage(core, target, bytes) {
+  const wire = target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
+  const frame = encodeFrame2(
+    FrameType3.MSG,
+    encodeMsg({ target: { kind: "server" }, payload: bytes })
+  );
+  deliver(core, wire, frame);
+}
+
+// src/core/room-api.ts
+import { FrameType as FrameType4, encodeFrame as encodeFrame3 } from "@irtio/protocol";
+import { encodeDelta as encodeDelta3, isDirtyEmpty as isDirtyEmpty2 } from "@irtio/schema";
+function createRoomApi(core, publicUrl) {
+  let cached;
+  let lastNow = Number.NEGATIVE_INFINITY;
+  const link = () => {
+    const sep = publicUrl.includes("?") ? "&" : "?";
+    return `${publicUrl}${sep}room=${encodeURIComponent(core.roomId)}`;
+  };
+  const room = {
+    get id() {
+      return core.roomId;
+    },
+    get link() {
+      return link();
+    },
+    get tick() {
+      return core.tick;
+    },
+    get now() {
+      const raw = core.host.now();
+      if (raw > lastNow) lastNow = raw;
+      return lastNow;
+    },
+    get clients() {
+      if (!cached) {
+        cached = [...core.clients.values()].map((c) => ({
+          clientId: c.clientId,
+          role: c.role,
+          name: c.name,
+          connected: c.connected
+        }));
+      }
+      return cached;
+    },
+    random() {
+      return core.rng.next();
+    },
+    send(target, bytes) {
+      sendMessage(core, target, bytes);
+    },
+    setRole(clientId, role) {
+      setRole(core, clientId, role);
+      cached = void 0;
+    },
+    kick(clientId, reason) {
+      core.host.kick(clientId, "E_KICKED", reason);
+    },
+    close(reason) {
+      core.host.close(reason);
+    },
+    sleep() {
+      if (core.mode !== "event") {
+        core.log("warn", "room.sleep() is event-mode only; ignored in tick mode");
+        return;
+      }
+      core.host.sleep();
+    },
+    log(...args) {
+      core.host.log("info", args);
+    },
+    setTimeout(ms, fn) {
+      return core.loop.setTimer(ms, fn, false);
+    },
+    setInterval(ms, fn) {
+      return core.loop.setTimer(ms, fn, true);
+    },
+    clearTimeout(handle) {
+      core.loop.clearTimer(handle);
+    },
+    clearInterval(handle) {
+      core.loop.clearTimer(handle);
+    },
+    call(clientId) {
+      return createCallProxy(core, clientId);
+    },
+    get broadcast() {
+      return broadcast;
+    }
+  };
+  const broadcast = createBroadcastProxy(core);
+  return {
+    room,
+    invalidate() {
+      cached = void 0;
+    }
+  };
+}
+function setRole(core, clientId, role) {
+  const entry = core.clients.get(clientId);
+  if (!entry) {
+    core.log("warn", `room.setRole: unknown client ${clientId}`);
+    return;
+  }
+  const roles = core.definition.schema.roles;
+  if (roles.length > 0 && !roles.includes(role)) {
+    core.log("warn", `room.setRole: ${JSON.stringify(role)} is not a schema role; ignored`);
+    return;
+  }
+  if (entry.role === role) return;
+  const dirty = catchUpDirty(core.ext, core.plain, entry.role, role);
+  if (!isDirtyEmpty2(dirty)) {
+    core.send(
+      clientId,
+      encodeFrame3(FrameType4.DELTA, encodeDelta3(core.ext, core.plain, dirty, { tick: core.tick }))
+    );
+  }
+  entry.role = role;
+  const presence = core.anyState.clients.get(clientId);
+  if (presence) presence.role = role;
+  core.invalidateClients();
+}
+
+// src/core/room.ts
+var DEFAULT_PUBLIC_URL = "http://localhost/";
+function ownJoinCapture(plain, name, added, clientId) {
+  const coll = plainEntity(plain, name);
+  let mine;
+  for (const id of added) {
+    const owner = coll.ownerOf(id);
+    if (name === PRESENCE_COLLECTION ? id !== clientId : owner !== clientId) continue;
+    (mine ??= /* @__PURE__ */ new Map()).set(id, { value: cloneValue2(coll.get(id)), owner });
+  }
+  return mine;
+}
+var RoomCore = class _RoomCore {
+  definition;
+  ext;
+  host;
+  roomId;
+  mode;
+  plain;
+  tracked;
+  anyState;
+  rng;
+  clients = /* @__PURE__ */ new Map();
+  loop;
+  stats = {
+    ticks: 0,
+    lastTickMs: 0,
+    maxTickMs: 0,
+    overruns: 0,
+    framesIn: 0,
+    framesOut: 0,
+    bytesOut: 0,
+    bytesOutByClient: /* @__PURE__ */ new Map(),
+    handlerErrors: 0,
+    encodesLastFlush: 0,
+    corrections: 0
+  };
+  tick = 0;
+  stopped = false;
+  seed;
+  api;
+  internals;
+  started = false;
+  constructor(definition, host, options) {
+    this.definition = definition;
+    this.host = host;
+    this.roomId = options.roomId;
+    this.mode = definition.config.mode;
+    this.ext = withBuiltins(definition.schema);
+    for (const issue of validateForDeploy(this.ext)) {
+      if (issue.level === "error") throw new Error(`RoomCore: ${issue.message}`);
+      host.log("warn", [`irtio: ${issue.message}`]);
+    }
+    let restored;
+    let plain;
+    if (options.restoreFrom) {
+      restored = parseHibernationBlob(options.restoreFrom);
+      plain = decodeSnapshot(this.ext, restored.snapshot).state;
+      const presence = plainEntity(plain, PRESENCE_COLLECTION);
+      for (const id of [...presence.ids()]) presence.remove(id);
+      if (restored.mode !== this.mode) {
+        host.log("warn", [
+          `irtio: restoring a '${restored.mode}' snapshot into a '${this.mode}' room`
+        ]);
+      }
+    } else {
+      plain = createState(this.ext);
+    }
+    this.plain = plain;
+    this.tracked = track(this.ext, plain);
+    this.anyState = this.tracked.state;
+    this.seed = restored?.seed ?? options.seed ?? 1;
+    this.rng = new Mulberry32(restored?.rngState ?? this.seed);
+    this.tick = restored?.tick ?? 0;
+    const self = this;
+    this.internals = self;
+    this.loop = new Loop(self);
+    this.api = createRoomApi(self, options.publicUrl ?? DEFAULT_PUBLIC_URL);
+    if (restored) {
+      const onWake = definition.config.onWake;
+      if (onWake) this.guard("onWake", () => onWake(this.state, this.room));
+    } else {
+      const onCreate = definition.config.onCreate;
+      if (onCreate) this.guard("onCreate", () => onCreate(this.state, this.room));
+    }
+  }
+  /** Convenience for hosts: `RoomCore.restore(def, bytes, host, opts)`. */
+  static restore(definition, bytes, host, options) {
+    return new _RoomCore(definition, host, { ...options, restoreFrom: bytes });
+  }
+  get schema() {
+    return this.definition.schema;
+  }
+  get config() {
+    return this.definition.config;
+  }
+  get state() {
+    return this.tracked.state;
+  }
+  get room() {
+    return this.api.room;
+  }
+  // -------------------------------------------------------------------------
+  // Handler safety
+  // -------------------------------------------------------------------------
+  tryRun(name, fn) {
+    try {
+      return { ok: true, value: fn() };
+    } catch (err) {
+      this.stats.handlerErrors++;
+      this.recordEvent(
+        "error",
+        void 0,
+        `${name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      this.host.log("error", [`irtio: ${name} threw`, err]);
+      return { ok: false };
+    }
+  }
+  events = new EventRing();
+  recordEvent(kind, clientId, detail) {
+    const e = {
+      tick: this.tick,
+      kind
+    };
+    if (clientId !== void 0) e.clientId = clientId;
+    if (detail !== void 0) e.detail = detail;
+    this.events.push(e);
+  }
+  /** Live JSON view of the room for the dev page / supervisor admin API. */
+  inspect() {
+    return {
+      tick: this.tick,
+      state: inspectState(this.ext, this.plain),
+      recent: this.events.list()
+    };
+  }
+  guard(name, fn) {
+    const r = this.tryRun(name, fn);
+    return r.ok ? r.value : void 0;
+  }
+  log(level, ...args) {
+    this.host.log(level, args);
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  start() {
+    if (this.stopped) {
+      this.log("warn", "RoomCore.start() after stop(); ignored");
+      return;
+    }
+    if (this.started) return;
+    this.started = true;
+    this.loop.start();
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.started = false;
+    this.loop.stop();
+    rejectAllPending(this.internals, "room stopped");
+  }
+  serialize() {
+    const onSleep = this.definition.config.onSleep;
+    if (onSleep) this.guard("onSleep", () => onSleep(this.state, this.room));
+    this.loop.clearAllTimers();
+    rejectAllPending(this.internals, "room is hibernating");
+    return writeHibernationBlob(
+      { seed: this.seed, rngState: this.rng.state, tick: this.tick, mode: this.mode },
+      encodeSnapshot2(this.ext, this.plain, { tick: this.tick })
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Clients
+  // -------------------------------------------------------------------------
+  get presence() {
+    return this.anyState[PRESENCE_COLLECTION];
+  }
+  resolveRole(requested, existing) {
+    const roles = this.definition.schema.roles;
+    if (requested === void 0) return existing ?? roles[0] ?? "";
+    if (roles.length === 0) {
+      if (requested !== "") {
+        this.log(
+          "warn",
+          `join: role ${JSON.stringify(requested)} but the schema declares no roles`
+        );
+      }
+      return "";
+    }
+    if (roles.includes(requested)) return requested;
+    this.log(
+      "warn",
+      `join: unknown role ${JSON.stringify(requested)}; using ${JSON.stringify(roles[0])}`
+    );
+    return roles[0] ?? "";
+  }
+  join(clientId, options = {}) {
+    const existing = this.clients.get(clientId);
+    if (this.stopped) {
+      this.log("warn", `join(${clientId}) after stop(); ignored`);
+      const role2 = this.resolveRole(options.role, existing?.role);
+      return {
+        tick: this.tick,
+        role: role2,
+        snapshot: encodeViewSnapshot(this.ext, this.plain, role2, this.tick)
+      };
+    }
+    const presence = this.presence;
+    const maxClients = this.definition.config.maxClients;
+    if (!presence.has(clientId) && presence.size >= maxClients) {
+      throw new RoomFullError(maxClients);
+    }
+    const reconnecting = options.reconnecting === true;
+    const role = this.resolveRole(options.role, existing?.role);
+    const name = options.name ?? existing?.name ?? "";
+    const record = presence.get(clientId);
+    if (record) {
+      if (record.role !== role) record.role = role;
+      if (record.name !== name) record.name = name;
+      if (record.connected !== true) record.connected = true;
+    } else {
+      presence.add(clientId, { clientId, role, name, connected: true });
+    }
+    const entry = existing ?? {
+      clientId,
+      role,
+      name,
+      connected: true,
+      correction: void 0,
+      accepted: /* @__PURE__ */ new Map(),
+      lastClientTick: 0,
+      pendingJoinAdds: void 0
+    };
+    entry.role = role;
+    entry.name = name;
+    entry.connected = true;
+    this.clients.set(clientId, entry);
+    this.invalidateClients();
+    const onJoin = this.definition.config.onJoin;
+    if (onJoin) {
+      const ctx = this.ctxFor(clientId, reconnecting);
+      this.guard("onJoin", () => onJoin(this.state, ctx));
+    }
+    this.loop.noteActivity();
+    this.recordEvent("join", clientId, reconnecting ? "reconnect" : void 0);
+    const snapshot = encodeViewSnapshot(this.ext, this.plain, entry.role, this.tick);
+    const pending = /* @__PURE__ */ new Map();
+    for (const [name2, cd] of this.tracked.dirty) {
+      if (cd.added.size === 0) continue;
+      const mine = ownJoinCapture(this.plain, name2, cd.added, clientId);
+      if (mine) pending.set(name2, mine);
+    }
+    entry.pendingJoinAdds = pending.size > 0 ? pending : void 0;
+    this.eventFlush();
+    return { tick: this.tick, role: entry.role, snapshot };
+  }
+  /** Event mode only: presence/lifecycle changes are their own event. No-op in tick mode. */
+  eventFlush() {
+    if (this.mode !== "event" || this.stopped) return;
+    if (isDirtyEmpty3(this.tracked.dirty)) return;
+    this.tick++;
+    this.flush();
+  }
+  leave(clientId, reason) {
+    const entry = this.clients.get(clientId);
+    if (!entry) {
+      this.log("warn", `leave(${clientId}): not joined`);
+      return;
+    }
+    const onLeave = this.definition.config.onLeave;
+    if (onLeave) {
+      const ctx = this.ctxFor(clientId);
+      this.guard("onLeave", () => onLeave(this.state, ctx, reason));
+    }
+    this.presence.remove(clientId);
+    this.recordEvent("leave", clientId, reason);
+    rejectPendingFor(this.internals, clientId, "client disconnected");
+    this.loop.dropFramesFor(clientId);
+    this.clients.delete(clientId);
+    this.stats.bytesOutByClient.delete(clientId);
+    this.invalidateClients();
+    this.eventFlush();
+  }
+  markDisconnected(clientId) {
+    const entry = this.clients.get(clientId);
+    if (!entry) {
+      this.log("warn", `markDisconnected(${clientId}): not joined`);
+      return;
+    }
+    entry.connected = false;
+    entry.correction = void 0;
+    const record = this.presence.get(clientId);
+    if (record && record.connected !== false) record.connected = false;
+    this.invalidateClients();
+    this.eventFlush();
+  }
+  ctxFor(clientId, reconnecting = false) {
+    const entry = this.clients.get(clientId);
+    return {
+      clientId,
+      role: entry?.role ?? "",
+      name: entry?.name ?? "",
+      tick: this.tick,
+      reconnecting,
+      room: this.room
+    };
+  }
+  correctionFor(clientId) {
+    const entry = this.clients.get(clientId);
+    if (!entry) return void 0;
+    if (!entry.correction) entry.correction = createDirtySet2();
+    return entry.correction;
+  }
+  invalidateClients() {
+    this.api.invalidate();
+  }
+  // -------------------------------------------------------------------------
+  // Frames
+  // -------------------------------------------------------------------------
+  send(clientId, frame) {
+    if (this.stopped) return;
+    const entry = this.clients.get(clientId);
+    if (!entry || !entry.connected) return;
+    this.host.send(clientId, frame);
+    this.stats.framesOut++;
+    this.stats.bytesOut += frame.length;
+    const by = this.stats.bytesOutByClient;
+    by.set(clientId, (by.get(clientId) ?? 0) + frame.length);
+  }
+  badFrame(clientId, reason) {
+    this.log("warn", `bad frame from ${clientId}: ${reason}`);
+    this.host.kick(clientId, "E_BAD_FRAME", reason);
+  }
+  receive(clientId, frame) {
+    if (this.stopped) {
+      this.log("warn", `receive(${clientId}) after stop(); ignored`);
+      return;
+    }
+    if (!this.clients.has(clientId)) {
+      this.log("warn", `receive(${clientId}): not joined; frame ignored`);
+      return;
+    }
+    this.stats.framesIn++;
+    this.loop.noteActivity();
+    let type;
+    let payload;
+    try {
+      const decoded = decodeFrame(frame);
+      type = decoded.type;
+      payload = decoded.payload;
+    } catch (err) {
+      this.badFrame(clientId, String(err));
+      return;
+    }
+    switch (type) {
+      case FrameType5.WRITE:
+      case FrameType5.CALL: {
+        if (type === FrameType5.WRITE) this.recordEvent("write", clientId);
+        if (this.mode === "tick") {
+          this.loop.enqueue({ clientId, type, payload: payload.slice() });
+        } else if (!this.loop.applyEvent({ clientId, type, payload })) {
+          this.badFrame(
+            clientId,
+            `malformed ${type === FrameType5.WRITE ? "WRITE" : "CALL"} payload`
+          );
+        }
+        return;
+      }
+      case FrameType5.REPLY: {
+        if (!handleReply(this.internals, clientId, payload)) {
+          this.badFrame(clientId, "malformed REPLY payload");
+        } else if (this.mode === "event") {
+          queueMicrotask(() => {
+            if (this.stopped || isDirtyEmpty3(this.tracked.dirty)) return;
+            this.tick++;
+            this.flush();
+          });
+        }
+        return;
+      }
+      case FrameType5.MSG: {
+        if (this.mode === "event") this.tick++;
+        const ok = handleMsg(this.internals, clientId, payload);
+        if (this.mode === "event") this.flush();
+        if (!ok) this.badFrame(clientId, "malformed MSG payload");
+        return;
+      }
+      default:
+        this.badFrame(clientId, `unexpected frame type ${type}`);
+    }
+  }
+  /**
+   * Hands the tracked dirty set out: server-wins corrections first, then per connected client its
+   * pending `CORRECT` (before the delta, so it sees the correction and then the broadcast) and
+   * its view's `DELTA` — encoded once per distinct view.
+   */
+  flush() {
+    const dirty = this.tracked.flush();
+    serverWinsCorrections(this.internals, dirty);
+    this.stats.encodesLastFlush = 0;
+    const byView = /* @__PURE__ */ new Map();
+    for (const entry of this.clients.values()) {
+      if (entry.connected) {
+        if (entry.correction) {
+          const payload = encodeCorrection(this.internals, entry.correction);
+          if (payload) this.send(entry.clientId, encodeCorrectFrame(payload, entry.lastClientTick));
+        }
+        let delta;
+        if (entry.pendingJoinAdds) {
+          delta = encodeViewDelta(
+            this.ext,
+            this.plain,
+            stripAdds(this.plain, dirty, entry.pendingJoinAdds),
+            entry.role,
+            this.tick
+          );
+          if (delta) this.stats.encodesLastFlush++;
+          entry.pendingJoinAdds = void 0;
+        } else {
+          const key = viewKeyFor(this.ext, entry.role);
+          let cached = byView.get(key);
+          if (cached === void 0) {
+            cached = encodeViewDelta(this.ext, this.plain, dirty, entry.role, this.tick);
+            if (cached) this.stats.encodesLastFlush++;
+            byView.set(key, cached);
+          }
+          delta = cached;
+        }
+        if (delta) this.send(entry.clientId, encodeFrame4(FrameType5.DELTA, delta));
+      }
+      entry.correction = void 0;
+      entry.accepted.clear();
+    }
+  }
+};
+
+export {
+  RoomFullError,
+  EVENT_RING_SIZE,
+  inspectState,
+  RPC_TIMEOUT_MS,
+  MAX_CATCHUP,
+  CRASH_AFTER_THROWS,
+  Mulberry32,
+  isVisible,
+  visibleTo,
+  visibleNames,
+  viewKeyFor,
+  encodeViewSnapshot,
+  encodeViewDelta,
+  catchUpDirty,
+  SNAPSHOT_FORMAT_VERSION,
+  parseHibernationBlob,
+  writeHibernationBlob,
+  RoomCore
+};