@onceworlds/cli 0.9.5 → 0.11.0

package/dist/v1/host.js

@@ -0,0 +1,547 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../sdk/src/helpers/random.ts
+function hashString(text) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 2654435761);
+    h2 = Math.imul(h2 ^ c, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 ^ h1) >>> 0;
+}
+function createRandom(seed) {
+  const s = typeof seed === "number" && Number.isFinite(seed) ? Math.floor(seed) >>> 0 : hashString(String(seed));
+  let a = 2654435769;
+  let b = 608135816;
+  let c = 3084996962;
+  let d = s;
+  const next = () => {
+    a >>>= 0;
+    b >>>= 0;
+    c >>>= 0;
+    d >>>= 0;
+    let t2 = a + b | 0;
+    a = b ^ b >>> 9;
+    b = c + (c << 3) | 0;
+    c = c << 21 | c >>> 11;
+    d = d + 1 | 0;
+    t2 = t2 + d | 0;
+    c = c + t2 | 0;
+    return (t2 >>> 0) / 4294967296;
+  };
+  for (let i = 0; i < 12; i++) next();
+  const int = (n) => Number.isFinite(n) && n > 0 ? Math.floor(next() * Math.floor(n)) : 0;
+  return {
+    next,
+    int,
+    range: (min, max) => min + next() * (max - min),
+    chance: (p) => next() < p,
+    pick: (items) => Array.isArray(items) && items.length > 0 ? items[int(items.length)] : void 0,
+    shuffle(items) {
+      const out = Array.isArray(items) ? [...items] : [];
+      for (let i = out.length - 1; i > 0; i--) {
+        const j = int(i + 1);
+        [out[i], out[j]] = [out[j], out[i]];
+      }
+      return out;
+    }
+  };
+}
+
+// ../sdk/src/helpers/util.ts
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function jsonSize(value) {
+  try {
+    const text = JSON.stringify(value);
+    return text === void 0 ? 0 : text.length;
+  } catch {
+    return Infinity;
+  }
+}
+function copy(value) {
+  try {
+    return value === void 0 ? void 0 : JSON.parse(JSON.stringify(value));
+  } catch {
+    return void 0;
+  }
+}
+var said = /* @__PURE__ */ new Map();
+function warn(key, message, level = "warn", error) {
+  const now = Date.now();
+  if (now - (said.get(key) ?? -Infinity) < 5e3) return;
+  said.set(key, now);
+  if (said.size > 500) said.delete(said.keys().next().value);
+  try {
+    const text = `[onceworlds] ${message}`;
+    if (level === "error") console.error(text, error);
+    else if (level === "debug") console.debug(text);
+    else console.warn(text);
+  } catch {
+  }
+}
+function guard(where, fn, fallback) {
+  try {
+    return fn();
+  } catch (error) {
+    warn(`threw:${where}`, `${where} threw (the helper carries on)`, "error", error);
+    return fallback;
+  }
+}
+var Bucket = class {
+  constructor(perSecond, burst, now) {
+    __publicField(this, "perSecond", perSecond);
+    __publicField(this, "burst", burst);
+    __publicField(this, "tokens");
+    __publicField(this, "last");
+    this.tokens = burst;
+    this.last = now;
+  }
+  take(now) {
+    this.tokens = Math.min(this.burst, this.tokens + Math.max(0, now - this.last) / 1e3 * this.perSecond);
+    this.last = now;
+    if (this.tokens < 1) return false;
+    this.tokens -= 1;
+    return true;
+  }
+};
+var Limits = class {
+  constructor(perSecond, burst) {
+    __publicField(this, "perSecond", perSecond);
+    __publicField(this, "burst", burst);
+    __publicField(this, "buckets", /* @__PURE__ */ new Map());
+  }
+  take(id, now) {
+    let bucket = this.buckets.get(id);
+    if (!bucket) {
+      if (this.buckets.size > 256) this.buckets.clear();
+      this.buckets.set(id, bucket = new Bucket(this.perSecond, this.burst, now));
+    }
+    return bucket.take(now);
+  }
+};
+function token() {
+  const words = new Uint32Array(2);
+  const crypto = globalThis.crypto;
+  if (crypto?.getRandomValues) crypto.getRandomValues(words);
+  else for (let i = 0; i < words.length; i++) words[i] = Math.floor(Math.random() * 4294967296);
+  return words[0].toString(36) + words[1].toString(36);
+}
+
+// ../sdk/src/helpers/schema.ts
+var schema = (check2, optional = false) => ({ check: check2, optional });
+function toSchema(like) {
+  if (like === void 0 || like === null) return null;
+  if (typeof like === "function") {
+    return schema((value, path) => {
+      let verdict;
+      try {
+        verdict = like(value);
+      } catch {
+        return `${path} failed its check`;
+      }
+      if (verdict === false) return `${path} failed its check`;
+      return typeof verdict === "string" ? `${path}: ${verdict}` : null;
+    });
+  }
+  if (typeof like.check === "function") return like;
+  return t.object(like);
+}
+function check(like, value, path = "value") {
+  const s = toSchema(like);
+  if (!s) return null;
+  try {
+    return s.check(value, path);
+  } catch {
+    return `${path} could not be checked`;
+  }
+}
+var DANGEROUS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var t = {
+  /** A finite number in [min, max] (default: any finite number). */
+  number(min = -1e15, max = 1e15) {
+    return schema((v, path) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max ? null : `${path} must be a number from ${min} to ${max}`);
+  },
+  /** A whole number in [min, max]. */
+  int(min = -2147483648, max = 2147483647) {
+    return schema((v, path) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max ? null : `${path} must be a whole number from ${min} to ${max}`);
+  },
+  /** A string of at most `max` characters (default 200), matching `pattern` when given. */
+  string(max = 200, pattern) {
+    return schema((v, path) => {
+      if (typeof v !== "string" || v.length > max) return `${path} must be text of at most ${max} characters`;
+      return pattern && !pattern.test(v) ? `${path} is not in the right form` : null;
+    });
+  },
+  boolean() {
+    return schema((v, path) => typeof v === "boolean" ? null : `${path} must be true or false`);
+  },
+  /** One of these exact values (strings, numbers, booleans or null). */
+  oneOf(...values) {
+    return schema((v, path) => values.includes(v) ? null : `${path} must be one of ${values.map((x) => JSON.stringify(x)).join(", ")}`);
+  },
+  /** A player id (or a bot's seat id): text of up to 128 characters. Whether they are in the room is for `validate` to say. */
+  id() {
+    return schema((v, path) => typeof v === "string" && v.length > 0 && v.length <= 128 ? null : `${path} must be a player id`);
+  },
+  /** A list of at most `max` items (default 64), each passing `item`. */
+  array(item, max = 64) {
+    const inner = toSchema(item);
+    return schema((v, path) => {
+      if (!Array.isArray(v) || v.length > max) return `${path} must be a list of at most ${max}`;
+      for (let i = 0; i < v.length; i++) {
+        const problem = inner.check(v[i], `${path}[${i}]`);
+        if (problem) return problem;
+      }
+      return null;
+    });
+  },
+  /** An object with exactly these fields (unknown fields are refused; t.optional ones may be left out). */
+  object(shape) {
+    const fields = Object.entries(shape).map(([key, like]) => [key, toSchema(like)]);
+    const known = new Set(fields.map(([key]) => key));
+    return schema((v, path) => {
+      if (!isObject(v)) return `${path} must be an object`;
+      for (const key of Object.keys(v)) if (!known.has(key) || DANGEROUS.has(key)) return `${path} has an unknown field '${key.slice(0, 40)}'`;
+      for (const [key, inner] of fields) {
+        if (!Object.hasOwn(v, key) || v[key] === void 0) {
+          if (inner.optional) continue;
+          return `${path}.${key} is missing`;
+        }
+        const problem = inner.check(v[key], `${path}.${key}`);
+        if (problem) return problem;
+      }
+      return null;
+    });
+  },
+  /** An object used as a map: at most `maxKeys` keys (default 64) of up to 128 characters, each value passing `value`. */
+  record(value, maxKeys = 64) {
+    const inner = toSchema(value);
+    return schema((v, path) => {
+      if (!isObject(v)) return `${path} must be an object`;
+      const keys = Object.keys(v);
+      if (keys.length > maxKeys) return `${path} has more than ${maxKeys} keys`;
+      for (const key of keys) {
+        if (key.length > 128 || DANGEROUS.has(key)) return `${path} has a bad key`;
+        const problem = inner.check(v[key], `${path}.${key}`);
+        if (problem) return problem;
+      }
+      return null;
+    });
+  },
+  /** The field may be left out (or undefined). */
+  optional(inner) {
+    const s = toSchema(inner);
+    return schema((v, path) => v === void 0 ? null : s.check(v, path), true);
+  },
+  /** null, or a value passing `inner`. */
+  nullable(inner) {
+    const s = toSchema(inner);
+    return schema((v, path) => v === null ? null : s.check(v, path), s.optional);
+  },
+  /** Any plain data of up to `maxBytes` as JSON (default 1024). Prefer a real shape: this only bounds the size. */
+  any(maxBytes = 1024) {
+    return schema((v, path) => jsonSize(v) <= maxBytes ? null : `${path} is bigger than ${maxBytes} bytes`);
+  }
+};
+
+// ../sdk/src/helpers/host.ts
+var MESSAGE_TAG = "$ow";
+var NAME_RE = /^[A-Za-z0-9_.:-]{1,48}$/;
+var STATE_NAME_RE = /^[A-Za-z0-9_.:-]{1,59}$/;
+var BOT_ID_RE = /^bot:[A-Za-z0-9_.-]{1,24}$/;
+var CLAIM_TIMEOUT_MS = 5e3;
+var STATE_MAX_BYTES = 15e3;
+function platformNow() {
+  try {
+    const now = globalThis.onceworlds?.now?.();
+    if (typeof now === "number" && Number.isFinite(now)) return now;
+  } catch {
+  }
+  return Date.now();
+}
+var callerOf = (player) => ({ id: player.id, name: player.name, team: player.team ?? 0, bot: false });
+function createHost(room, options = {}) {
+  const rpcs = /* @__PURE__ */ new Map();
+  const claims = /* @__PURE__ */ new Map();
+  const open = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const waiting = /* @__PURE__ */ new Map();
+  const offs = [];
+  let disposed = false;
+  const now = () => {
+    try {
+      return options.now ? options.now() : platformNow();
+    } catch {
+      return Date.now();
+    }
+  };
+  const reject = (playerId, reason) => {
+    if (options.onReject) guard("onReject", () => options.onReject(playerId, reason), void 0);
+    else warn(`reject:${playerId}`, `refused a message from ${playerId}: ${reason}`, "debug");
+  };
+  const mayCall = (from, spectators) => {
+    if (from.bot || spectators || room.match.phase === "lobby") return true;
+    return from.id === room.host || room.isParticipant(from.id);
+  };
+  function runRpc(name, entry, from, raw, info) {
+    if (!mayCall(from, entry.def.spectators)) return reject(from.id, `'${name}' from a player who is only watching`), false;
+    if (!entry.limits.take(from.id, now())) return reject(from.id, `'${name}' called too often`), false;
+    if (jsonSize(raw) > (entry.def.maxBytes ?? 2048)) return reject(from.id, `'${name}' arguments are too big`), false;
+    const args = raw === void 0 && entry.schema ? {} : raw;
+    if (entry.schema) {
+      const problem = entry.schema.check(args, `'${name}' args`);
+      if (problem) return reject(from.id, problem), false;
+    } else if (args !== void 0 && args !== null && !(isObject(args) && Object.keys(args).length === 0)) {
+      return reject(from.id, `'${name}' takes no arguments`), false;
+    }
+    const verdict = guard(`rpc '${name}' validate`, () => entry.def.validate?.(from, args, info), false);
+    if (verdict === false || typeof verdict === "string") return reject(from.id, typeof verdict === "string" ? verdict : `'${name}' refused`), false;
+    guard(`rpc '${name}' run`, () => entry.def.run(from, args, info), void 0);
+    return true;
+  }
+  function rpc(name, def) {
+    if (typeof name !== "string" || !NAME_RE.test(name) || !def || typeof def.run !== "function") {
+      warn(`rpc-def:${String(name)}`, `host.rpc('${String(name)}', { run(from, args) {...} }) needs a name of 1-48 letters, digits or _.:- and a run function`, "error");
+      return () => false;
+    }
+    if (rpcs.has(name)) warn(`rpc-twice:${name}`, `host.rpc('${name}') was defined twice: the second replaces the first. Define each once, where the game starts.`);
+    const rate = def.rate && def.rate > 0 ? def.rate : 10;
+    const entry = { def, schema: toSchema(def.args), limits: new Limits(rate, Math.max(4, rate * 2)) };
+    rpcs.set(name, entry);
+    return (args) => {
+      if (disposed || room.closed) return false;
+      const wire = args === void 0 ? void 0 : copy(args);
+      if (args !== void 0 && wire === void 0) return warn(`rpc-args:${name}`, `rpc '${name}': arguments must be plain data`), false;
+      if (entry.schema) {
+        const problem = check(entry.schema, wire === void 0 ? {} : wire, `'${name}' args`);
+        if (problem) return warn(`rpc-args:${name}`, `rpc '${name}' not sent: ${problem}`), false;
+      }
+      if (room.isHost) {
+        const me = room.players.get(room.me.id) ?? room.me;
+        return runRpc(name, entry, callerOf(me), wire, { at: now(), ...room.running ? { matchTime: room.matchNow() } : {} });
+      }
+      room.send({ [MESSAGE_TAG]: "rpc", n: name, ...wire === void 0 ? {} : { a: wire } }, { to: room.host });
+      return true;
+    };
+  }
+  function claim(name, def) {
+    if (typeof name !== "string" || !NAME_RE.test(name) || !def || typeof def.apply !== "function") {
+      warn(`claim-def:${String(name)}`, `host.claim('${String(name)}', { apply(winner, rivals) {...} }) needs a name of 1-48 letters, digits or _.:- and an apply function`, "error");
+      return async () => "rejected";
+    }
+    const rate = def.rate && def.rate > 0 ? def.rate : 10;
+    const entry = { def, schema: toSchema(def.args), limits: new Limits(rate, Math.max(4, rate * 2)) };
+    claims.set(name, entry);
+    return (args) => {
+      if (disposed || room.closed) return Promise.resolve("rejected");
+      const wire = copy(args === void 0 ? {} : args);
+      const problem = wire === void 0 ? "arguments must be plain data" : entry.schema ? check(entry.schema, wire, `'${name}' args`) : null;
+      if (problem) {
+        warn(`claim-args:${name}`, `claim '${name}' not sent: ${problem}`);
+        return Promise.resolve("rejected");
+      }
+      const id = token();
+      const message = { [MESSAGE_TAG]: "claim", n: name, i: id, a: wire };
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => settleMine(id, "timeout"), CLAIM_TIMEOUT_MS);
+        waiting.set(id, { resolve, message, sentTo: [room.host], timer });
+        if (room.isHost) receiveClaim(callerOf(room.players.get(room.me.id) ?? room.me), name, id, wire, { at: now(), ...room.running ? { matchTime: room.matchNow() } : {} });
+        else room.send(message, { to: room.host });
+      });
+    };
+  }
+  function settleMine(id, result) {
+    const w = waiting.get(id);
+    if (!w) return;
+    waiting.delete(id);
+    clearTimeout(w.timer);
+    w.resolve(result);
+  }
+  function answer(playerId, id, result) {
+    if (playerId === room.me.id) settleMine(id, result);
+    else if (!playerId.startsWith("bot:")) room.send({ [MESSAGE_TAG]: "ans", i: id, r: result }, { to: playerId });
+  }
+  function receiveClaim(from, name, id, raw, info) {
+    const entry = claims.get(name);
+    if (!entry) return false;
+    const seenKey = `${from.id}:${id}`;
+    if (seen.has(seenKey)) return false;
+    seen.add(seenKey);
+    if (seen.size > 512) seen.delete(seen.values().next().value);
+    const refuse = (reason) => (reject(from.id, reason), answer(from.id, id, "rejected"), false);
+    if (!mayCall(from, entry.def.spectators)) return refuse(`claim '${name}' from a player who is only watching`);
+    if (!entry.limits.take(from.id, now())) return refuse(`claim '${name}' made too often`);
+    if (jsonSize(raw) > (entry.def.maxBytes ?? 2048)) return refuse(`claim '${name}' arguments are too big`);
+    const args = raw === void 0 ? {} : raw;
+    const problem = entry.schema?.check(args, `'${name}' args`);
+    if (problem) return refuse(problem);
+    const made = { id, from, args, at: info.at, ...info.matchTime !== void 0 ? { matchTime: info.matchTime } : {} };
+    const keyed = entry.def.key ? guard(`claim '${name}' key`, () => String(entry.def.key(args)), "") : "";
+    const key = keyed ? `${name}|${keyed}` : `${name}|#${seenKey}`;
+    const group = open.get(key);
+    if (group) {
+      group.claims.push(made);
+      return true;
+    }
+    const window = Math.max(0, Math.min(5e3, entry.def.window ?? (keyed ? 150 : 0)));
+    open.set(key, { entry, claims: [made], timer: setTimeout(() => settle(key), window) });
+    return true;
+  }
+  function settle(key) {
+    const group = open.get(key);
+    if (!group) return;
+    open.delete(key);
+    if (!room.isHost || disposed) return;
+    const sorted = group.claims.sort((a, b) => a.at - b.at || (a.from.id < b.from.id ? -1 : a.from.id > b.from.id ? 1 : 0));
+    let winner;
+    const rivals = [];
+    for (const c of sorted) {
+      if (winner) {
+        rivals.push(c);
+        continue;
+      }
+      const verdict = guard("claim validate", () => group.entry.def.validate?.(c), false);
+      if (verdict === false || typeof verdict === "string") {
+        reject(c.from.id, typeof verdict === "string" ? verdict : "claim refused");
+        answer(c.from.id, c.id, "rejected");
+      } else winner = c;
+    }
+    if (!winner) return;
+    guard("claim apply", () => group.entry.def.apply(winner, rivals), void 0);
+    for (const rival of rivals) answer(rival.from.id, rival.id, "lost");
+    answer(winner.from.id, winner.id, "won");
+  }
+  offs.push(
+    room.on("message", (data, player, at, matchTime) => {
+      if (disposed || !isObject(data) || typeof data[MESSAGE_TAG] !== "string") return;
+      const kind = data[MESSAGE_TAG];
+      const info = { at: typeof at === "number" ? at : now(), ...typeof matchTime === "number" ? { matchTime } : {} };
+      if (kind === "ans") {
+        const id = data.i;
+        if (typeof id !== "string") return;
+        const w = waiting.get(id);
+        if (!w) return;
+        if (!w.sentTo.includes(player.id)) return reject(player.id, "an answer to a claim that was not sent to them");
+        if (data.r === "won" || data.r === "lost" || data.r === "rejected") settleMine(id, data.r);
+        return;
+      }
+      if (!room.isHost || typeof data.n !== "string" || data.n.length > 48) return;
+      if (!room.players.has(player.id)) return reject(player.id, "a message from somebody who is not in the room");
+      const from = callerOf(player);
+      if (kind === "rpc") {
+        const entry = rpcs.get(data.n);
+        if (entry) runRpc(data.n, entry, from, data.a, info);
+      } else if (kind === "claim") {
+        if (typeof data.i !== "string" || data.i.length > 32) return reject(player.id, "a claim without an id");
+        if (claims.has(data.n)) receiveClaim(from, data.n, data.i, data.a, info);
+      }
+    })
+  );
+  offs.push(
+    room.on("host", (hostId) => {
+      for (const [id, w] of waiting) {
+        if (w.sentTo[w.sentTo.length - 1] === hostId) continue;
+        w.sentTo.push(hostId);
+        const message = w.message;
+        if (hostId === room.me.id && room.isHost) receiveClaim(callerOf(room.players.get(room.me.id) ?? room.me), message.n, id, message.a, { at: now() });
+        else room.send(w.message, { to: hostId });
+      }
+    })
+  );
+  offs.push(room.on("close", () => dispose()));
+  function state(name, opts = {}) {
+    const ok = typeof name === "string" && STATE_NAME_RE.test(name);
+    if (!ok) warn(`state-name:${String(name)}`, `host.state('${String(name)}'): a name is 1-59 letters, digits or _.:-`, "error");
+    const key = `host:${ok ? name : "invalid"}`;
+    const schema2 = toSchema(opts.schema);
+    let lastRaw = void 0;
+    let lastGood = void 0;
+    const initial = () => copy(opts.initial);
+    const get = () => {
+      const raw = room.state[key];
+      if (raw === void 0 || raw === null) return lastGood ?? initial();
+      if (raw === lastRaw) return lastGood ?? initial();
+      lastRaw = raw;
+      const problem = schema2 ? check(schema2, raw, key) : null;
+      if (problem) {
+        warn(`state-bad:${key}`, `ignored ${key} from the host: ${problem}`);
+        return lastGood ?? initial();
+      }
+      lastGood = raw;
+      return lastGood;
+    };
+    const set = (value) => {
+      if (!ok || disposed || room.closed) return false;
+      if (!room.isHost) return warn(`state-host:${key}`, `${key}.set() did nothing: only the host writes it (check host.isHost)`), false;
+      const clean = value === void 0 ? null : copy(value);
+      if (value !== void 0 && value !== null && clean === void 0) return warn(`state-data:${key}`, `${key}.set(): the value must be plain data`), false;
+      if (schema2 && clean !== null) {
+        const problem = check(schema2, clean, key);
+        if (problem) return warn(`state-schema:${key}`, `${key}.set() did nothing: ${problem}`), false;
+      }
+      if (jsonSize(clean) > STATE_MAX_BYTES) return warn(`state-size:${key}`, `${key}.set() did nothing: the value is over ${STATE_MAX_BYTES} bytes (split it over several states)`), false;
+      room.setState(key, clean);
+      return true;
+    };
+    return {
+      key,
+      get: () => guard(`${key}.get`, get, initial()),
+      set: (value) => guard(`${key}.set`, () => set(value), false),
+      update(fn) {
+        if (!room.isHost) return warn(`state-host:${key}`, `${key}.update() did nothing: only the host writes it (check host.isHost)`), false;
+        const draft = copy(get());
+        const out = guard(`${key}.update`, () => fn(draft), void 0);
+        return set(out === void 0 ? draft : out);
+      },
+      on(listener) {
+        return room.on("state", (k) => {
+          if (k === key) guard(`${key} listener`, () => listener(get()), void 0);
+        });
+      }
+    };
+  }
+  function callAs(bot, name, args) {
+    const id = typeof bot === "string" ? bot : bot?.id;
+    if (!room.isHost || disposed || typeof id !== "string" || !BOT_ID_RE.test(id)) return false;
+    const from = { id, name: typeof bot === "object" && typeof bot.name === "string" ? bot.name : id, team: 0, bot: true };
+    const info = { at: now(), ...room.running ? { matchTime: room.matchNow() } : {} };
+    const wire = args === void 0 ? void 0 : copy(args);
+    const entry = rpcs.get(name);
+    if (entry) return runRpc(name, entry, from, wire, info);
+    if (claims.has(name)) return receiveClaim(from, name, token(), wire, info);
+    warn(`callAs:${name}`, `callAs: no rpc or claim named '${name}'`);
+    return false;
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    for (const off of offs) off();
+    for (const group of open.values()) clearTimeout(group.timer);
+    open.clear();
+    for (const id of [...waiting.keys()]) settleMine(id, "timeout");
+  }
+  return {
+    get isHost() {
+      return room.isHost;
+    },
+    state,
+    rpc,
+    claim,
+    callAs: (bot, name, args) => guard("callAs", () => callAs(bot, name, args), false),
+    random: (name) => createRandom(`${room.match.seed ?? 0}:${String(name)}`),
+    dispose
+  };
+}
+export {
+  MESSAGE_TAG,
+  check,
+  createHost,
+  createRandom,
+  t
+};