@onceworlds/cli 0.9.4 → 0.10.0

package/dist/v1/match.js

@@ -0,0 +1,1259 @@
+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);
+}
+function numberFrom(value, settings, fallback) {
+  const v = typeof value === "string" ? settings[value] : value;
+  return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : fallback;
+}
+
+// ../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
+  };
+}
+
+// ../sdk/src/helpers/match.ts
+var MATCH_KEY = "host:ow.match";
+var RECORD_PHASES = ["intro", "round", "roundEnd", "results"];
+var MAX_SEATS = 64;
+var RECORD_MAX_BYTES = 15e3;
+var ADOPT_MS = 600;
+var str = (v, max) => typeof v === "string" && v.length <= max;
+var num = (v, min = -1e12, max = 1e12) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max;
+var ids = (v) => Array.isArray(v) && v.length <= MAX_SEATS && v.every((id) => str(id, 128));
+function numbers(v) {
+  if (!isObject(v) || Object.keys(v).length > MAX_SEATS * 2) return null;
+  for (const [key, value] of Object.entries(v)) if (key.length > 128 || !num(value)) return null;
+  return v;
+}
+var standingSchema = t.array(t.object({ id: t.id(), name: t.string(64), points: t.number(), place: t.int(1, 1e3), bot: t.boolean() }), MAX_SEATS);
+function readRecord(raw, dataSchema) {
+  if (!isObject(raw) || raw.v !== 1) return null;
+  const r = raw;
+  if (!str(r.mid, 200) || !num(r.n, 0) || !str(r.by, 128) || typeof r.phase !== "string" || !RECORD_PHASES.includes(r.phase)) return null;
+  if (!num(r.round, 0, 1e5) || !num(r.rounds, 0, 1e5) || !num(r.until, 0) || !num(r.started, 0) || typeof r.done !== "boolean") return null;
+  if (!isObject(r.names) || Object.keys(r.names).length > MAX_SEATS * 2 || !Object.values(r.names).every((name) => str(name, 64))) return null;
+  if (!Array.isArray(r.bots) || r.bots.length > MAX_SEATS || !r.bots.every((b) => isObject(b) && str(b.id, 32) && b.id.startsWith("bot:") && str(b.name, 32) && num(b.skill, 0, 1))) return null;
+  const scores = numbers(r.scores);
+  if (!scores) return null;
+  if (r.last !== null) {
+    if (!isObject(r.last) || !Array.isArray(r.last.ranking) || r.last.ranking.length > MAX_SEATS || !r.last.ranking.every(ids) || !numbers(r.last.points)) return null;
+  }
+  if (r.turn !== null) {
+    const tr = r.turn;
+    if (!isObject(tr) || !num(tr.n, 0, 1e6) || !ids(tr.order) || !num(tr.i, 0, MAX_SEATS) || !str(tr.id, 128) || !num(tr.until, 0)) return null;
+  }
+  if (r.results !== null && check(standingSchema, r.results)) return null;
+  let data = r.data ?? null;
+  if (dataSchema && data !== null && check(dataSchema, data, "match.data")) {
+    warn("match-data", `ignored match.data from the host: ${check(dataSchema, data, "match.data")}`);
+    data = null;
+  }
+  return { ...r, data };
+}
+function rankingOf(outcome, known) {
+  const ok = new Set(known);
+  const seen = /* @__PURE__ */ new Set();
+  const clean = (list) => {
+    const out = [];
+    for (const id of list) if (typeof id === "string" && ok.has(id) && !seen.has(id)) seen.add(id), out.push(id);
+    return out;
+  };
+  if (!outcome || typeof outcome !== "object") return [];
+  if (Array.isArray(outcome)) {
+    if (outcome.length === 0) return [];
+    if (outcome.every((item) => typeof item === "string")) {
+      const winners = clean(outcome);
+      return winners.length ? [winners] : [];
+    }
+    return outcome.filter(Array.isArray).map((group) => clean(group)).filter((group) => group.length > 0);
+  }
+  const entries = Object.entries(outcome).filter((e) => ok.has(e[0]) && num(e[1]));
+  entries.sort((a, b) => b[1] - a[1]);
+  const groups = [];
+  let previous;
+  for (const [id, value] of entries) {
+    if (value === previous) groups[groups.length - 1].push(id);
+    else groups.push([id]);
+    previous = value;
+  }
+  return groups;
+}
+function pointsOf(outcome, ranking, known, table) {
+  const out = {};
+  if (outcome && typeof outcome === "object" && !Array.isArray(outcome)) {
+    const ok = new Set(known);
+    for (const [id, value] of Object.entries(outcome)) if (ok.has(id) && num(value, -1e6, 1e6)) out[id] = value;
+    return out;
+  }
+  let place = 0;
+  for (const group of ranking) {
+    const points = table[place] ?? 0;
+    for (const id of group) out[id] = points;
+    place += group.length;
+  }
+  return out;
+}
+function standingsOf(seats, scores, placings) {
+  const rows = seats.map((s) => ({ id: s.id, name: s.name.slice(0, 64), points: scores[s.id] ?? 0, place: 0, bot: s.bot }));
+  if (placings && placings.length > 0) {
+    const placeOf = /* @__PURE__ */ new Map();
+    let place = 1;
+    for (const group of placings) {
+      for (const id of group) placeOf.set(id, place);
+      place += group.length;
+    }
+    for (const row of rows) row.place = placeOf.get(row.id) ?? place;
+    rows.sort((a, b) => a.place - b.place || b.points - a.points);
+    return rows;
+  }
+  rows.sort((a, b) => b.points - a.points);
+  rows.forEach((row, i) => row.place = i > 0 && rows[i - 1].points === row.points ? rows[i - 1].place : i + 1);
+  return rows;
+}
+var BOT_NAMES = ["Mox", "Juno", "Pip", "Rook", "Vega", "Tilly", "Bram", "Nix", "Sable", "Otto", "Wren", "Kit", "Lumo", "Dash", "Fern", "Zed"];
+function platformNow2() {
+  try {
+    const now = globalThis.onceworlds?.now?.();
+    if (typeof now === "number" && Number.isFinite(now)) return now;
+  } catch {
+  }
+  return Date.now();
+}
+function createMatch(room, rules = {}) {
+  const listeners = /* @__PURE__ */ new Map();
+  const host = createHost(room);
+  const offs = [];
+  const dataSchema = rules.data === void 0 ? void 0 : toSchema(rules.data) ?? void 0;
+  let disposed = false;
+  let mem = null;
+  let cache = { raw: void 0, rec: null };
+  let lastGood = null;
+  let adoptSince = 0;
+  let confirmed = void 0;
+  let lastTick = null;
+  let ended = "";
+  let pendingEnd = null;
+  let turnEnd = 0;
+  let awaySince = /* @__PURE__ */ new Map();
+  let tickQueued = false;
+  let shownPhase = "lobby";
+  let shownRound = "";
+  let shownTurn = "";
+  let firstRecord = true;
+  let banked = "";
+  let reported = "";
+  let botFill = 0;
+  let botNames = BOT_NAMES;
+  let botSkill = [0.3, 0.7];
+  const me = () => room.me.id;
+  const settings = () => room.settings ?? {};
+  const matchMs = () => room.matchNow();
+  const emit = (event, ...args) => {
+    for (const listener of [...listeners.get(event) ?? []]) guard(`match '${event}' listener`, () => listener(...args), void 0);
+  };
+  function record() {
+    const raw = room.state[MATCH_KEY];
+    if (raw !== cache.raw) cache = { raw, rec: readRecord(raw, dataSchema) };
+    return cache.rec;
+  }
+  function current() {
+    const m = room.match;
+    if (room.isHost && mem && m.phase === "playing" && mem.mid === m.id && mem.by === me()) return mem;
+    const rec = record();
+    if (m.phase !== "lobby") {
+      if (rec && rec.mid === m.id) return lastGood = rec;
+      return room.state[MATCH_KEY] !== void 0 && lastGood?.mid === m.id ? lastGood : null;
+    }
+    return rec && rec.n === m.n && rec.phase === "results" ? rec : null;
+  }
+  function seatsOf(rec) {
+    const m = room.match;
+    if (m.phase === "lobby" && !rec) return [];
+    const humans = m.phase !== "lobby" ? m.participants ?? [] : (rec?.results ?? []).filter((s) => !s.bot).map((s) => s.id);
+    const seats = humans.map((id, index) => {
+      const p = room.players.get(id);
+      return { id, name: p?.name ?? rec?.names[id] ?? "Player", bot: false, me: id === me(), index, team: p?.team ?? 0, away: p?.connected === false, idle: !!p?.idle, left: !p, skill: 0 };
+    });
+    for (const b of rec?.bots ?? []) seats.push({ id: b.id, name: b.name, bot: true, me: false, index: seats.length, team: 0, away: false, idle: false, left: false, skill: b.skill });
+    return seats;
+  }
+  function phaseOf(rec) {
+    const m = room.match;
+    if (m.phase === "lobby") return "lobby";
+    if (m.phase === "starting") return "countdown";
+    return rec ? rec.phase : "countdown";
+  }
+  const total = () => Math.floor(numberFrom(rules.rounds ?? 3, settings(), 3));
+  function write(patch) {
+    if (!mem) return false;
+    const next = { ...mem, ...patch, by: me() };
+    if (jsonSize(next) > RECORD_MAX_BYTES) {
+      warn("match-size", `the match record is over ${RECORD_MAX_BYTES} bytes (match.data is too big): keep big things in host.state() instead`, "error");
+      if (!("data" in patch)) return false;
+      next.data = mem.data;
+    }
+    mem = next;
+    room.setState(MATCH_KEY, mem);
+    requestSync();
+    return true;
+  }
+  function acting() {
+    const m = room.match;
+    return !disposed && room.isHost && m.phase === "playing" && room.running && !!mem && mem.mid === m.id && mem.by === me() && adoptSince === 0;
+  }
+  function requestTick() {
+    if (tickQueued) return;
+    tickQueued = true;
+    queueMicrotask(() => {
+      tickQueued = false;
+      tick();
+    });
+  }
+  function tick() {
+    if (disposed) return;
+    const m = room.match;
+    if (!room.isHost || m.phase !== "playing" || !room.running) {
+      adoptSince = 0;
+      lastTick = null;
+      return;
+    }
+    let rec = record();
+    if (!rec && room.state[MATCH_KEY] !== void 0 && lastGood?.mid === m.id) rec = lastGood;
+    if (!rec || rec.mid !== m.id) {
+      if (mem && mem.mid === m.id && mem.by === me()) rec = mem;
+      else return beginMatch(m);
+    }
+    if (!mem || mem.mid !== rec.mid || rec.by !== me()) {
+      const now = Date.now();
+      adoptSince || (adoptSince = now);
+      mem = rec;
+      if (now - adoptSince < ADOPT_MS) return;
+      adoptSince = 0;
+      write({});
+      awaySince = /* @__PURE__ */ new Map();
+      guard("match resume", () => rules.resume?.(api), void 0);
+      requestSync();
+    }
+    const raw = room.state[MATCH_KEY];
+    if (raw !== mem && raw !== confirmed) {
+      if (JSON.stringify(raw) === JSON.stringify(mem)) confirmed = raw;
+      else write({});
+    }
+    step();
+  }
+  function beginMatch(m) {
+    const humans = m.participants ?? [];
+    const count = Math.max(0, Math.min(30 - humans.length, botFill - humans.length));
+    const rng = createRandom(`${m.seed ?? 0}:ow.bots`);
+    const names = rng.shuffle(botNames.length ? botNames : BOT_NAMES);
+    const bots = Array.from({ length: count }, (_, i) => {
+      const skill = typeof botSkill === "number" ? botSkill : botSkill[0] + rng.next() * (botSkill[1] - botSkill[0]);
+      const base = String(names[i % names.length]).slice(0, 24);
+      return { id: `bot:${i + 1}`, name: i < names.length ? base : `${base} ${Math.floor(i / names.length) + 1}`, skill: Math.round(Math.min(1, Math.max(0, skill)) * 100) / 100 };
+    });
+    mem = {
+      v: 1,
+      mid: m.id ?? "",
+      n: m.n,
+      by: me(),
+      phase: "intro",
+      round: 0,
+      rounds: total(),
+      until: 0,
+      started: 0,
+      names: {},
+      bots,
+      scores: {},
+      last: null,
+      turn: null,
+      done: false,
+      data: null,
+      results: null
+    };
+    ended = "";
+    adoptSince = 0;
+    beginRound(1);
+  }
+  function beginRound(round) {
+    if (!mem) return;
+    const humans = room.match.participants ?? [];
+    const bots = mem.bots.slice(0, Math.max(0, Math.min(mem.bots.length, botFill - humans.length)));
+    const names = { ...mem.names };
+    for (const id of humans) {
+      const p = room.players.get(id);
+      if (p) names[id] = p.name.slice(0, 64);
+    }
+    const scores = { ...mem.scores };
+    for (const id of [...humans, ...bots.map((b) => b.id)]) scores[id] ?? (scores[id] = 0);
+    const intro = Math.max(0, (rules.introSeconds ?? 0) * 1e3);
+    const patch = { phase: "intro", round, until: matchMs() + intro, last: null, turn: null, data: null, bots, names, scores };
+    if (intro > 0) write(patch);
+    else {
+      mem = { ...mem, ...patch };
+      startPlay();
+    }
+  }
+  function startPlay() {
+    if (!mem) return;
+    const now = matchMs();
+    pendingEnd = null;
+    turnEnd = 0;
+    const secs = numberFrom(rules.roundSeconds ?? 0, settings(), 0);
+    mem = { ...mem, phase: "round", started: now, until: secs > 0 ? now + secs * 1e3 : 0, data: null };
+    const out = guard("startRound", () => rules.startRound?.(api), void 0);
+    const data = out === void 0 ? mem.data : copy(out) ?? null;
+    write({ phase: "round", data, turn: rules.turns ? firstTurn(now) : null });
+    if (mem.turn) beginTurn();
+  }
+  function step() {
+    if (!mem) return;
+    const now = matchMs();
+    const dt = lastTick === null ? 0 : Math.max(0, (now - lastTick) / 1e3);
+    lastTick = now;
+    switch (mem.phase) {
+      case "intro":
+        if (now >= mem.until) startPlay();
+        return;
+      case "round": {
+        if (pendingEnd) return endRoundNow(pendingEnd);
+        guard("onTick", () => rules.onTick?.(api, dt), void 0);
+        if (pendingEnd) return endRoundNow(pendingEnd);
+        if (mem.turn) tickTurn(now);
+        if (mem.phase === "round" && pendingEnd) return endRoundNow(pendingEnd);
+        if (mem.phase === "round" && mem.until > 0 && now >= mem.until) endRoundNow({ outcome: void 0, given: false });
+        return;
+      }
+      case "roundEnd":
+        if (now >= mem.until) {
+          if (mem.done) finish();
+          else beginRound(mem.round + 1);
+        }
+        return;
+      case "results":
+        if (mem.until > 0 && now >= mem.until && ended !== mem.mid) {
+          ended = mem.mid;
+          room.endMatch();
+        }
+        return;
+    }
+  }
+  function endRoundNow(end) {
+    pendingEnd = null;
+    if (!mem || mem.phase !== "round") return;
+    const seats = seatsOf(mem);
+    const known = seats.map((s) => s.id);
+    const outcome = end.given ? end.outcome : guard("score", () => rules.score?.(api), void 0);
+    const ranking = rankingOf(outcome, known);
+    const points = pointsOf(outcome, ranking, known, rules.points ?? [3, 2, 1]);
+    const scores = { ...mem.scores };
+    for (const [id, p] of Object.entries(points)) scores[id] = (scores[id] ?? 0) + p;
+    mem = { ...mem, scores, last: { ranking, points } };
+    const max = Math.max(1, rules.maxRounds ?? 50);
+    const done = mem.rounds > 0 && mem.round >= mem.rounds || mem.round >= max || guard("over", () => !!rules.over?.(api), false);
+    if (!done && rules.admit === "round") {
+      const ready = room.online.filter((p) => !p.idle && !room.isParticipant(p.id)).map((p) => p.id);
+      if (ready.length > 0) room.admit(ready);
+    }
+    write({ phase: "roundEnd", until: matchMs() + Math.max(0, (rules.roundEndSeconds ?? 3) * 1e3), turn: null, done });
+  }
+  function finish() {
+    if (!mem) return;
+    const seats = seatsOf(mem);
+    const final = rules.final ? guard("final", () => rules.final(api), void 0) : void 0;
+    const placings = final ? rankingOf(final, seats.map((s) => s.id)) : null;
+    const results = standingsOf(seats, mem.scores, placings);
+    const wait = Math.max(0, (rules.resultsSeconds ?? 10) * 1e3);
+    write({ phase: "results", until: wait > 0 ? matchMs() + wait : 0, results, turn: null });
+  }
+  const turnLimit = () => numberFrom(rules.turns?.seconds ?? 30, settings(), 30) * 1e3;
+  function firstTurn(now) {
+    const seats = seatsOf(mem).filter((s) => !s.left);
+    if (seats.length === 0) return null;
+    const order = rules.turns?.order === "random" ? createRandom(`${room.match.seed ?? 0}:ow.order:${mem.round}`).shuffle(seats.map((s) => s.id)) : seats.map((s) => s.id);
+    const limit = turnLimit();
+    return { n: 1, order, i: 0, id: order[0], until: limit > 0 ? now + limit : 0 };
+  }
+  function beginTurn() {
+    const seat = mem?.turn ? seatsOf(mem).find((s) => s.id === mem.turn.id) : void 0;
+    if (seat) guard("onTurn", () => rules.onTurn?.(api, seat), void 0);
+  }
+  function tickTurn(now) {
+    const turn = mem.turn;
+    const seat = seatsOf(mem).find((s) => s.id === turn.id);
+    let advance = turnEnd === turn.n || !seat || seat.left;
+    if (!advance && seat && !seat.bot) {
+      if (seat.away) {
+        if (!awaySince.has(seat.id)) awaySince.set(seat.id, now);
+        if (now - awaySince.get(seat.id) >= Math.max(0, rules.turns?.awaySeconds ?? 10) * 1e3) advance = true;
+      } else awaySince.delete(seat.id);
+    }
+    if (!advance && turn.until > 0 && now >= turn.until && seat) {
+      guard("turnTimeout", () => rules.turnTimeout?.(api, seat), void 0);
+      advance = true;
+    }
+    if (!advance || pendingEnd || !mem || mem.phase !== "round" || mem.turn?.n !== turn.n) return;
+    const perRound = Math.max(0, rules.turns?.perRound ?? 0);
+    if (perRound > 0 && turn.n >= perRound) return endRoundNow({ outcome: void 0, given: false });
+    const seats = seatsOf(mem);
+    let i = turn.i;
+    for (let tries = 0; tries < turn.order.length; tries++) {
+      i = (i + 1) % turn.order.length;
+      if (seats.some((s) => s.id === turn.order[i] && !s.left)) break;
+    }
+    const limit = turnLimit();
+    write({ turn: { n: turn.n + 1, order: turn.order, i, id: turn.order[i], until: limit > 0 ? now + limit : 0 } });
+    beginTurn();
+  }
+  const endTurnCall = host.rpc("ow.endTurn", {
+    args: { r: t.int(0, 1e5), n: t.int(0, 1e6) },
+    rate: 5,
+    validate: (from, args) => mem?.phase === "round" && mem.round === args.r && mem.turn?.id === from.id && mem.turn.n === args.n || "not your turn",
+    run: (_from, args) => {
+      turnEnd = args.n;
+      requestTick();
+    }
+  });
+  let syncQueued = false;
+  function requestSync() {
+    if (syncQueued || disposed) return;
+    syncQueued = true;
+    queueMicrotask(() => {
+      syncQueued = false;
+      sync();
+    });
+  }
+  function sync() {
+    if (disposed) return;
+    const rec = current();
+    const phase = phaseOf(rec);
+    if (phase !== shownPhase) {
+      const previous = shownPhase;
+      shownPhase = phase;
+      emit("phase", phase, previous);
+    }
+    if (rec && phase === "round") {
+      const key = `${rec.mid}.${rec.round}`;
+      if (key !== shownRound) {
+        shownRound = key;
+        emit("round", rec.round, { resumed: firstRecord && room.matchNow() - rec.started > 1500 });
+      }
+      const turn = api.turn;
+      const turnKey = turn ? `${key}.${turn.n}` : "";
+      if (turn && turnKey !== shownTurn) {
+        shownTurn = turnKey;
+        emit("turn", turn);
+      }
+    }
+    if (rec) firstRecord = false;
+    if (rec && phase === "results" && rec.results && room.match.phase === "playing") bank(rec);
+    emit("change");
+  }
+  function bank(rec) {
+    const results = rec.results;
+    const mine = results.find((s) => s.id === me()) ?? null;
+    if (room.ranked && mine && reported !== rec.mid) {
+      reported = rec.mid;
+      const groups = /* @__PURE__ */ new Map();
+      for (const s of results) if (!s.bot) (groups.get(s.place) ?? groups.set(s.place, []).get(s.place)).push(s.id);
+      const ranking = [...groups.entries()].sort((a, b) => a[0] - b[0]).map(([, group]) => group);
+      if (ranking.length >= 2) room.reportResult({ ranking });
+      else if (ranking.length === 1 && ranking[0].length >= 2) room.reportResult({ draw: true });
+    }
+    if (banked === rec.mid || room.private?.["ow.done"] === rec.mid) return;
+    banked = rec.mid;
+    room.setPrivate("ow.done", rec.mid);
+    emit("results", results, mine);
+  }
+  const view = () => current();
+  const api = {
+    get room() {
+      return room;
+    },
+    get phase() {
+      return phaseOf(view());
+    },
+    get paused() {
+      return room.match.phase === "playing" && !room.running;
+    },
+    get isHost() {
+      return acting();
+    },
+    get round() {
+      return view()?.round ?? 0;
+    },
+    get rounds() {
+      return view()?.rounds ?? (room.match.phase === "lobby" ? total() : 0);
+    },
+    get roundId() {
+      const rec = view();
+      return rec ? `${rec.mid}.${rec.round}` : "";
+    },
+    get seats() {
+      return seatsOf(view());
+    },
+    get present() {
+      return seatsOf(view()).filter((s) => s.bot || !s.away && !s.idle && !s.left);
+    },
+    get me() {
+      return room.match.phase === "lobby" ? null : seatsOf(view()).find((s) => s.me) ?? null;
+    },
+    get spectating() {
+      return room.spectating;
+    },
+    get scores() {
+      return view()?.scores ?? {};
+    },
+    get standings() {
+      const rec = view();
+      if (!rec) return [];
+      return rec.phase === "results" && rec.results ? rec.results : standingsOf(seatsOf(rec), rec.scores, null);
+    },
+    get results() {
+      const rec = view();
+      return rec?.phase === "results" ? rec.results : null;
+    },
+    get last() {
+      const rec = view();
+      return rec?.phase === "roundEnd" ? rec.last : null;
+    },
+    get turn() {
+      const rec = view();
+      if (!rec || rec.phase !== "round" || !rec.turn) return null;
+      const seat = seatsOf(rec).find((s) => s.id === rec.turn.id) ?? null;
+      return { n: rec.turn.n, id: rec.turn.id, seat, mine: rec.turn.id === me() };
+    },
+    get data() {
+      return view()?.data ?? null;
+    },
+    get settings() {
+      return settings();
+    },
+    get countdown() {
+      const m = room.match;
+      return m.phase === "starting" && m.startsAt !== void 0 ? Math.max(0, (m.startsAt - platformNow2()) / 1e3) : null;
+    },
+    get secondsLeft() {
+      const rec = view();
+      if (!rec || room.match.phase !== "playing") return null;
+      const until = rec.phase === "round" && rec.turn && rec.turn.until > 0 ? rec.turn.until : rec.until;
+      return until > 0 ? Math.max(0, (until - matchMs()) / 1e3) : null;
+    },
+    get elapsed() {
+      const rec = view();
+      return rec && rec.phase === "round" ? Math.max(0, matchMs() - rec.started) : 0;
+    },
+    get lobby() {
+      const humans = room.online.length;
+      return {
+        players: [...room.players.values()].map((p) => ({ id: p.id, name: p.name, ready: !!p.ready || room.kind !== "public" && p.id === room.host, host: p.id === room.host, me: p.id === me(), away: p.connected === false })),
+        canStart: room.canStart,
+        waitingFor: room.notReady.map((p) => p.name),
+        bots: Math.max(0, Math.min(30 - humans, botFill - humans))
+      };
+    },
+    ready(on = true) {
+      guard("match.ready", () => room.setReady(on !== false), void 0);
+    },
+    start() {
+      guard("match.start", () => room.startMatch(), void 0);
+    },
+    endTurn() {
+      const turn = view()?.turn;
+      if (!turn || view()?.phase !== "round") return;
+      if (acting()) {
+        turnEnd = turn.n;
+        requestTick();
+      } else if (turn.id === me()) endTurnCall({ r: view()?.round ?? 0, n: turn.n });
+    },
+    random(name) {
+      return createRandom(`${room.match.seed ?? 0}:${String(name)}`);
+    },
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => void set.delete(listener);
+    },
+    setData(value) {
+      if (!room.isHost || !mem || mem.by !== me() || mem.mid !== room.match.id || mem.phase === "results") {
+        return warn("match-setData", "match.setData() did nothing: only the host writes the round data, during a match (check match.isHost)");
+      }
+      const next = typeof value === "function" ? guard("setData", () => {
+        const draft = copy(mem.data);
+        const out = value(draft);
+        return out === void 0 ? draft : out;
+      }, mem.data) : value;
+      const clean = next === void 0 ? null : copy(next);
+      if (clean === void 0) return warn("match-setData-plain", "match.setData(): the data must be plain data (numbers, text, lists, objects)");
+      if (dataSchema && clean !== null) {
+        const problem = check(dataSchema, clean, "match.data");
+        if (problem) return warn("match-setData-schema", `match.setData() did nothing: ${problem}`);
+      }
+      write({ data: clean });
+    },
+    endRound(outcome) {
+      if (!acting() || !mem || mem.phase !== "round") return;
+      pendingEnd = { outcome, given: outcome !== void 0 };
+      requestTick();
+    },
+    skip() {
+      if (!acting() || !mem || mem.phase === "round") return;
+      if (mem.phase === "results") return api.endMatch();
+      write({ until: matchMs() });
+      requestTick();
+    },
+    endMatch() {
+      if (!room.isHost) return;
+      if (mem) ended = mem.mid;
+      guard("match.endMatch", () => room.endMatch(), void 0);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      clearInterval(timer);
+      for (const off of offs) off();
+      host.dispose();
+      listeners.clear();
+    },
+    _useBots(fill, names, skill) {
+      botFill = Math.max(0, Math.min(30, Math.floor(Number(fill) || 0)));
+      if (Array.isArray(names) && names.length > 0) botNames = names.map((n) => String(n).slice(0, 24));
+      if (typeof skill === "number" || Array.isArray(skill) && skill.length === 2) botSkill = skill;
+    }
+  };
+  const timer = setInterval(tick, Math.max(16, rules.tick ?? 100));
+  offs.push(room.on("state", (key) => key === MATCH_KEY && requestSync()));
+  for (const event of ["match", "join", "leave", "away", "back", "idle", "ready", "settings", "reconnect", "disconnect"]) offs.push(room.on(event, () => requestSync()));
+  offs.push(
+    room.on("host", () => {
+      adoptSince = 0;
+      requestSync();
+      requestTick();
+    })
+  );
+  offs.push(room.on("match", () => requestTick()));
+  offs.push(room.on("starting", () => void (rules.admit === "round" && room.isHost && room.kind !== "public" && room.setOpen(true))));
+  offs.push(room.on("close", () => api.dispose()));
+  requestSync();
+  return api;
+}
+function defaultView(match, options = {}) {
+  const doc = globalThis.document;
+  if (!doc) return { remove() {
+  } };
+  const box = doc.createElement("div");
+  box.setAttribute("data-onceworlds-match", "");
+  box.style.cssText = "position:fixed;left:8px;top:8px;z-index:10;max-width:60vw;padding:6px 8px;font:13px/1.4 system-ui,sans-serif;color:#fff;background:rgba(0,0,0,.55);border-radius:6px;white-space:pre-line";
+  (options.parent ?? doc.body).appendChild(box);
+  const button = (label, onClick) => {
+    const b = doc.createElement("button");
+    b.textContent = label;
+    b.style.cssText = "margin:4px 4px 0 0;font:inherit";
+    b.addEventListener("click", onClick);
+    box.appendChild(b);
+  };
+  const name = (id) => match.seats.find((s) => s.id === id)?.name ?? "Someone";
+  const table = (rows) => rows.map((s) => `${s.place}. ${s.name}  ${s.points}`).join("\n");
+  const draw = () => {
+    const left = match.secondsLeft;
+    const clock = left === null ? "" : `  ${Math.ceil(left)}s`;
+    let text = "";
+    switch (match.phase) {
+      case "lobby":
+        text = match.results ? `Last match
+${table(match.results)}
+` : "";
+        text += match.lobby.waitingFor.length ? `Waiting for ${match.lobby.waitingFor.join(", ")}` : "Lobby";
+        break;
+      case "countdown":
+        text = options.countdown && match.countdown !== null ? String(Math.ceil(match.countdown)) : "Starting";
+        break;
+      case "intro":
+        text = match.round ? `Round ${match.round}${match.rounds ? ` of ${match.rounds}` : ""}` : "Get ready";
+        break;
+      case "round": {
+        const turn = match.turn;
+        text = `Round ${match.round}${match.rounds ? `/${match.rounds}` : ""}${clock}`;
+        if (turn) text += turn.mine ? "\nYour turn" : `
+${turn.seat?.name ?? "Someone"}'s turn`;
+        text += `
+${table(match.standings)}`;
+        break;
+      }
+      case "roundEnd": {
+        const first = match.last?.ranking[0];
+        text = first?.length ? `${first.map(name).join(" and ")} ${first.length > 1 ? "tie" : "wins"} the round` : "No winner";
+        text += `
+${table(match.standings)}`;
+        break;
+      }
+      case "results":
+        text = `Results${clock}
+${table(match.standings)}`;
+        break;
+    }
+    if (match.paused) text += "\nWaiting for players";
+    if (match.spectating) text += "\nWatching: you play the next match";
+    box.textContent = text;
+    if (match.phase === "lobby" && options.lobby) {
+      if (match.lobby.canStart) button("Start", () => match.start());
+      else if (!match.room.isHost || match.room.kind === "public") {
+        const ready = !!match.room.me.ready;
+        button(ready ? "Not ready" : "Ready", () => match.ready(!ready));
+      }
+    }
+    if (match.turn?.mine) button("End turn", () => match.endTurn());
+  };
+  const off = match.on("change", draw);
+  const timer = setInterval(draw, 250);
+  draw();
+  return {
+    remove() {
+      off();
+      clearInterval(timer);
+      box.remove();
+    }
+  };
+}
+export {
+  MATCH_KEY,
+  check,
+  createHost,
+  createMatch,
+  createRandom,
+  defaultView,
+  rankingOf,
+  t
+};