@genex-ai/multiplayer 0.16.1 → 0.17.0

package/dist/bridge.js

@@ -0,0 +1,558 @@
+import {
+  connect,
+  createPrivate,
+  joinPrivate,
+  matchmake,
+  roomOf
+} from "./chunk-CTDU4IJ5.js";
+import {
+  Limits,
+  RESERVED_SHARED_PREFIX,
+  ServerMessage,
+  isReservedEventType
+} from "./chunk-C52XFIB6.js";
+
+// src/bridge.ts
+import { getColyseusAuth, getColyseusUrls, initEmbed, waitForPlayer } from "@genex-ai/embed-sdk";
+var version = 1;
+var embedIdentity = {
+  ready(gameId) {
+    const cfg = globalThis.__GENEX__;
+    if (gameId && cfg && typeof cfg.apiUrl === "string" && Array.isArray(cfg.dashboardOrigins)) {
+      initEmbed({
+        slug: gameId,
+        apiUrl: cfg.apiUrl,
+        dashboardOrigins: cfg.dashboardOrigins.filter((o) => typeof o === "string")
+      });
+    }
+    return waitForPlayer();
+  },
+  auth: () => getColyseusAuth(),
+  urls: () => getColyseusUrls()
+};
+var identity = embedIdentity;
+function setIdentity(next) {
+  identity = next ?? embedIdentity;
+}
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function parseOptions(optsJson) {
+  const o = JSON.parse(optsJson);
+  if (!isObject(o)) throw new TypeError("genex bridge: options must be a JSON object");
+  const gameId = typeof o.gameId === "string" ? o.gameId : "";
+  if (!gameId) throw new TypeError("genex bridge: `gameId` (the game slug) is required");
+  const urls = Array.isArray(o.urls) ? o.urls.filter((u) => typeof u === "string" && u !== "") : [];
+  let room = "play";
+  if (o.room === "queue" || o.room === "private") room = o.room;
+  else if (isObject(o.room) && typeof o.room.joinById === "string" && o.room.joinById) room = { joinById: o.room.joinById };
+  else if (o.room !== void 0 && o.room !== null && o.room !== "play") {
+    throw new TypeError('genex bridge: `room` must be "play", "queue", "private" or {"joinById": code}');
+  }
+  const timeout = typeof o.controlTimeoutMs === "number" && Number.isFinite(o.controlTimeoutMs) ? o.controlTimeoutMs : void 0;
+  const smoothing = o.smoothing === "genex" || o.smoothing === "predict" || isObject(o.smoothing) ? o.smoothing : void 0;
+  return {
+    gameId,
+    name: typeof o.name === "string" && o.name ? o.name : void 0,
+    urls,
+    room,
+    pose: o.pose === true,
+    smoothing,
+    controlTimeoutMs: timeout,
+    options: isObject(o.options) ? o.options : void 0
+  };
+}
+var MAX_QUEUED_EVENTS = 4096;
+var sessions = /* @__PURE__ */ new Map();
+var nextHandle = 1;
+function push(e, event) {
+  if (e.q.length >= MAX_QUEUED_EVENTS) {
+    if (e.overflowed) e.q.splice(1, 1);
+    else {
+      e.overflowed = true;
+      e.q.splice(0, 2, { type: "warning", message: "genex bridge: event queue full; drain it every frame (oldest events dropped)" });
+    }
+  }
+  e.q.push(event);
+}
+var current = (e) => e.closed ? null : e.mm ? e.mm.session : e.session;
+var errorCode = (err) => {
+  const c = isObject(err) || err instanceof Error ? err.code : void 0;
+  return typeof c === "number" && Number.isFinite(c) ? c : 0;
+};
+var errorMessage = (err) => err instanceof Error ? err.message : typeof err === "string" ? err : "join failed";
+function end(e) {
+  e.closed = true;
+  e.connected = false;
+  for (const off of e.unwire.splice(0)) off();
+  e.wired = null;
+  e.session = null;
+  e.mm = null;
+}
+function wire(e, s) {
+  if (e.wired === s) return;
+  for (const off of e.unwire.splice(0)) off();
+  e.wired = s;
+  e.connected = true;
+  e.lastConnected.clear();
+  e.lastMatch = "";
+  const room = roomOf(s);
+  e.sessionId = s.id;
+  e.roomId = room.roomId;
+  const offs = e.unwire;
+  const connectedOf = (id) => room.state?.players?.get(id)?.connected !== false;
+  const noteConnection = (id) => {
+    const now = connectedOf(id);
+    const before = e.lastConnected.get(id);
+    e.lastConnected.set(id, now);
+    if (before !== void 0 && before !== now) push(e, { type: "playerConnection", id, connected: now });
+  };
+  push(e, { type: "joined", sessionId: s.id });
+  room.state?.players?.forEach((_p, id) => {
+    e.lastConnected.set(id, connectedOf(id));
+    push(e, { type: "playerJoined", id });
+  });
+  for (const id of s.objects.ids()) push(e, { type: "objectChanged", id, owner: s.objects.get(id)?.owner ?? null });
+  if (s.host !== void 0) push(e, { type: "hostChanged", host: s.host });
+  offs.push(
+    s.on("join", (id) => {
+      e.lastConnected.set(id, connectedOf(id));
+      push(e, { type: "playerJoined", id });
+    }),
+    s.on("change", (id) => {
+      noteConnection(id);
+      if (!e.changed.has(id)) {
+        e.changed.add(id);
+        push(e, { type: "playerChanged", id });
+      }
+    }),
+    s.on("leave", (id) => {
+      e.lastConnected.delete(id);
+      push(e, { type: "playerLeft", id });
+    }),
+    s.on("host", (host) => push(e, { type: "hostChanged", host: host ?? null })),
+    s.on("shared", (key, value) => push(e, { type: "sharedChanged", key, value: value ?? null })),
+    s.on("object", (id) => {
+      const o = s.objects.get(id);
+      push(e, o ? { type: "objectChanged", id, owner: o.owner ?? null } : { type: "objectRemoved", id });
+    }),
+    s.on("room:open", ({ open: open2 }) => push(e, { type: "roomOpen", open: open2 })),
+    s.on("reconnecting", ({ attempt, code }) => {
+      e.connected = false;
+      push(e, { type: "reconnecting", code, attempt });
+    }),
+    s.on("reconnected", () => {
+      e.connected = true;
+      push(e, { type: "reconnected" });
+    }),
+    s.on("disconnect", (code) => {
+      e.connected = false;
+      if (e.opts.room === "queue") return;
+      end(e);
+      push(e, { type: "disconnected", code, reason: "" });
+    }),
+    s.on(ServerMessage.SERVER_RESTART, () => push(e, { type: "serverRestart" })),
+    s.on(ServerMessage.MATCH_START, (m) => push(e, { type: "matchStart", roundId: isObject(m) && typeof m.roundId === "number" ? m.roundId : 0 })),
+    s.on(ServerMessage.MATCH_ENDED, (m) => push(e, { type: "matchEnded", data: m ?? null })),
+    s.on(
+      ServerMessage.MATCH_REQUEUE,
+      (m) => push(e, { type: "matchRequeue", reason: isObject(m) && typeof m.reason === "string" ? m.reason : null })
+    ),
+    s.inputs.on((from, data) => push(e, { type: "input", from, data: data ?? null })),
+    s.chat.on((m) => push(e, { type: "chat", id: m.id, from: m.from, name: m.name, text: m.text, at: m.at })),
+    // The relay's per-lane budget refusal (§5.1). The SDK only logs it; engines get an event.
+    room.onMessage(
+      ServerMessage.RATE_DROP,
+      (m) => push(e, { type: "rateDrop", dropped: isObject(m) && typeof m.dropped === "number" ? m.dropped : 0 })
+    ),
+    // Every game event: engines receive all types, as native does. The bridge subscribes to no
+    // game type by name (see `listen`), so Colyseus routes each one here exactly once.
+    room.onMessage("*", (type, data) => {
+      if (typeof type === "string" && !isReservedEventType(type)) push(e, { type: "message", kind: type, data: data ?? null });
+    })
+  );
+}
+function follow(e) {
+  const s = current(e);
+  if (s && s !== e.wired) wire(e, s);
+}
+async function join(e) {
+  const o = e.opts;
+  await identity.ready(o.gameId);
+  if (e.closed) return;
+  const urls = o.urls.length ? o.urls : identity.urls();
+  if (!urls.length) throw Object.assign(new Error("genex bridge: no relay URL (pass urls, or run on a Genex page)"), { code: 0 });
+  const auth = () => identity.auth();
+  const base = { urls, room: o.gameId, name: o.name, auth, pose: o.pose, smoothing: o.smoothing };
+  if (o.room === "play") {
+    const s = await connect({ ...base, options: o.options });
+    if (e.closed) return void s.leave();
+    e.session = s;
+    wire(e, s);
+    return;
+  }
+  const mmOpts = base;
+  const mm = o.room === "queue" ? await matchmake(mmOpts) : o.room === "private" ? await createPrivate(mmOpts) : await joinPrivate(o.room.joinById, mmOpts);
+  if (e.closed) return void mm.cancel();
+  e.mm = mm;
+  mm.on("queue", (m) => {
+    if (isObject(m)) push(e, { type: "queue", position: Number(m.position) || 0, size: Number(m.size) || 0 });
+  });
+  mm.on("matched", () => {
+    push(e, { type: "seated" });
+    follow(e);
+  });
+  mm.on("searching", () => {
+    if (e.wired) {
+      for (const off of e.unwire.splice(0)) off();
+      e.wired = null;
+      e.connected = false;
+    }
+  });
+  mm.on("error", (err) => {
+    const handle = e.mm;
+    end(e);
+    handle?.cancel();
+    push(e, { type: "joinFailed", code: errorCode(err), message: errorMessage(err) });
+  });
+  mm.on("disconnect", (code) => {
+    end(e);
+    push(e, { type: "disconnected", code: typeof code === "number" ? code : 0, reason: "" });
+  });
+  follow(e);
+}
+function start(optsJson) {
+  const opts = parseOptions(optsJson);
+  const handle = nextHandle++;
+  const e = {
+    opts,
+    q: [],
+    overflowed: false,
+    session: null,
+    mm: null,
+    wired: null,
+    unwire: [],
+    changed: /* @__PURE__ */ new Set(),
+    lastConnected: /* @__PURE__ */ new Map(),
+    lastMatch: "",
+    sessionId: "",
+    roomId: "",
+    connected: false,
+    closed: false
+  };
+  sessions.set(handle, e);
+  const done = join(e).catch((err) => {
+    end(e);
+    push(e, { type: "joinFailed", code: errorCode(err), message: errorMessage(err) });
+    throw err;
+  });
+  return { handle, done };
+}
+function open(optsJson) {
+  const { handle, done } = start(optsJson);
+  done.catch(() => {
+  });
+  return handle;
+}
+async function connect2(optsJson) {
+  const { handle, done } = start(optsJson);
+  try {
+    await done;
+  } catch (err) {
+    const out = new Error(errorMessage(err));
+    out.code = errorCode(err);
+    throw out;
+  }
+  return handle;
+}
+var entry = (handle) => sessions.get(handle);
+var live = (handle) => {
+  const e = entry(handle);
+  if (!e) return null;
+  follow(e);
+  return current(e);
+};
+function parseJson(json, what) {
+  if (typeof json !== "string") throw new TypeError(`genex bridge: ${what} must be a JSON string`);
+  return JSON.parse(json);
+}
+function parseObject(json, what) {
+  const v = parseJson(json, what);
+  if (!isObject(v)) throw new TypeError(`genex bridge: ${what} must be a JSON object`);
+  return v;
+}
+function leave(handle) {
+  const e = entry(handle);
+  if (!e || e.closed) return;
+  const { mm, session } = e;
+  end(e);
+  if (mm) mm.cancel();
+  else session?.leave();
+  push(e, { type: "disconnected", code: 4e3, reason: "left" });
+}
+function dispose(handle) {
+  leave(handle);
+  if (typeof handle === "number") sessions.delete(handle);
+}
+function setMe(handle, json) {
+  const state = parseObject(json, "state");
+  const s = live(handle);
+  if (!s) return false;
+  s.me.set(state);
+  return true;
+}
+function snapMe(handle, json) {
+  const state = parseObject(json, "state");
+  const s = live(handle);
+  if (!s) return false;
+  s.me.snap(state);
+  return true;
+}
+function setShared(handle, key, json) {
+  const value = parseJson(json, "value");
+  if (typeof key !== "string" || !key || key.startsWith(RESERVED_SHARED_PREFIX)) return false;
+  const s = live(handle);
+  if (!s) return false;
+  s.shared.set(key, value);
+  return true;
+}
+function setObject(handle, id, json) {
+  const state = parseObject(json, "object state");
+  const s = live(handle);
+  if (!s || !s.objects.get(id)?.isMine) return false;
+  s.objects.set(id, state);
+  return true;
+}
+function snapObject(handle, id, json) {
+  const state = parseObject(json, "object state");
+  const s = live(handle);
+  if (!s || !s.objects.get(id)?.isMine) return false;
+  s.objects.snap(id, state);
+  return true;
+}
+function send(handle, type, json) {
+  const data = parseJson(json, "event data");
+  if (typeof type !== "string" || !type || type.length > Limits.MAX_EVENT_TYPE_CHARS || isReservedEventType(type)) return false;
+  const s = live(handle);
+  if (!s) return false;
+  s.send(type, data);
+  return true;
+}
+function listen(_handle, _type) {
+}
+function sendInput(handle, json) {
+  const data = parseJson(json, "input");
+  const s = live(handle);
+  if (!s) return false;
+  s.inputs.send(data);
+  return true;
+}
+function setRoomOpen(handle, open2) {
+  const s = live(handle);
+  if (!s) return false;
+  s.setRoomOpen(open2 === true);
+  return true;
+}
+function chatSend(handle, text) {
+  const s = live(handle);
+  if (!s || typeof text !== "string") return false;
+  s.chat.send(text);
+  return true;
+}
+function control(handle, operation, id, requestId, host = false) {
+  if (typeof id !== "string" || !id) throw new TypeError("genex bridge: object id must be a non-empty string");
+  const e = entry(handle);
+  const s = live(handle);
+  const settle = (r) => {
+    if (!e) return;
+    const event = {
+      type: "controlResult",
+      requestId: String(requestId),
+      operation,
+      id,
+      accepted: r.accepted,
+      owner: r.owner ?? null,
+      sequence: r.sequence,
+      reason: r.reason
+    };
+    if (typeof r.retryAfterMs === "number") event.retryAfterMs = r.retryAfterMs;
+    push(e, event);
+  };
+  if (!s) {
+    settle({ accepted: false, sequence: 0, reason: "disconnected" });
+    return;
+  }
+  const options = { timeoutMs: e?.opts.controlTimeoutMs, ...host ? { authority: "host" } : {} };
+  const p = operation === "claim" ? s.objects.claimConfirmed(id, options) : operation === "release" ? s.objects.releaseConfirmed(id, options) : s.objects.removeConfirmed(id, options);
+  p.then(settle, () => settle({ accepted: false, sequence: 0, reason: "disconnected" }));
+}
+function claim(handle, id, requestId) {
+  control(handle, "claim", id, requestId);
+}
+function claimAsHost(handle, id, requestId) {
+  control(handle, "claim", id, requestId, true);
+}
+function release(handle, id, requestId) {
+  control(handle, "release", id, requestId);
+}
+function destroy(handle, id, requestId) {
+  control(handle, "remove", id, requestId);
+}
+function reportEliminated(handle) {
+  const e = entry(handle);
+  if (!e?.mm || e.closed) return false;
+  e.mm.eliminated();
+  return true;
+}
+function reportScore(handle, delta = 1) {
+  const e = entry(handle);
+  if (!e?.mm || e.closed || typeof delta !== "number" || !Number.isFinite(delta)) return false;
+  e.mm.score(delta);
+  return true;
+}
+function reportFinish(handle) {
+  const e = entry(handle);
+  if (!e?.mm || e.closed) return false;
+  e.mm.finish();
+  return true;
+}
+function serverNow(handle) {
+  return live(handle)?.serverNow() ?? null;
+}
+function timeUntil(handle, epochMs) {
+  const s = live(handle);
+  return s ? s.timeUntil(epochMs) : epochMs - Date.now();
+}
+var finiteOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+function sessionJson(handle) {
+  const e = entry(handle);
+  const s = live(handle);
+  const room = s ? roomOf(s) : null;
+  const matchText = room?.state?.match;
+  let matchState = null;
+  if (matchText) {
+    try {
+      matchState = JSON.parse(matchText);
+    } catch {
+      matchState = null;
+    }
+  }
+  return JSON.stringify({
+    sessionId: s?.id ?? e?.sessionId ?? "",
+    roomId: room?.roomId ?? e?.roomId ?? "",
+    hostId: s?.host ?? null,
+    isHost: s?.isHost ?? false,
+    connected: !!s && !!e?.connected,
+    closed: !e || e.closed,
+    serverNow: finiteOrNull(s?.serverNow()),
+    rtt: finiteOrNull(s?.rtt),
+    clockSynced: s?.clockSynced ?? false,
+    clockOrigin: room?.state?.clockOrigin ?? 0,
+    matchState
+  });
+}
+function playersJson(handle) {
+  const s = live(handle);
+  if (!s) return "[]";
+  const raw = roomOf(s).state?.players;
+  const out = [];
+  for (const [id, p] of s.players) {
+    const wire2 = raw?.get(id);
+    out.push({
+      id,
+      name: p.name,
+      uid: p.uid,
+      team: p.team,
+      connected: p.connected,
+      avatarUrl: p.avatarUrl,
+      state: p.state ?? {},
+      stateRaw: p.stateRaw ?? {},
+      epoch: wire2?.epoch ?? 0,
+      isMe: id === s.id,
+      posed: wire2?.posed === true
+    });
+  }
+  return JSON.stringify(out);
+}
+function objectsJson(handle) {
+  const s = live(handle);
+  if (!s) return "[]";
+  const raw = roomOf(s).state?.objects;
+  const out = [];
+  for (const id of s.objects.ids()) {
+    const o = s.objects.get(id);
+    if (!o) continue;
+    out.push({
+      id,
+      owner: o.owner ?? null,
+      isMine: o.isMine,
+      seq: raw?.get(id)?.seq ?? 0,
+      epoch: o.epoch,
+      state: o.state ?? null,
+      stateRaw: o.stateRaw ?? null
+    });
+  }
+  return JSON.stringify(out);
+}
+function sharedJson(handle) {
+  const s = live(handle);
+  const out = {};
+  if (s) for (const key of s.shared.keys()) out[key] = s.shared.get(key) ?? null;
+  return JSON.stringify(out);
+}
+function drainEventsJson(handle) {
+  const e = entry(handle);
+  if (!e) return "[]";
+  try {
+    follow(e);
+    const s = current(e);
+    if (s) {
+      const text = roomOf(s).state?.match ?? "";
+      if (text !== e.lastMatch) {
+        e.lastMatch = text;
+        let state = null;
+        try {
+          state = text ? JSON.parse(text) : null;
+        } catch {
+          state = null;
+        }
+        push(e, { type: "matchState", state });
+      }
+    }
+    e.changed.clear();
+    e.overflowed = false;
+    return JSON.stringify(e.q.splice(0));
+  } catch (err) {
+    return JSON.stringify([{ type: "warning", message: `genex bridge: ${errorMessage(err)}` }]);
+  }
+}
+export {
+  chatSend,
+  claim,
+  claimAsHost,
+  connect2 as connect,
+  destroy,
+  dispose,
+  drainEventsJson,
+  leave,
+  listen,
+  objectsJson,
+  open,
+  playersJson,
+  release,
+  reportEliminated,
+  reportFinish,
+  reportScore,
+  send,
+  sendInput,
+  serverNow,
+  sessionJson,
+  setIdentity,
+  setMe,
+  setObject,
+  setRoomOpen,
+  setShared,
+  sharedJson,
+  snapMe,
+  snapObject,
+  timeUntil,
+  version
+};