@genex-ai/multiplayer 0.17.0 → 0.17.6

package/dist/bridge-authority.js

@@ -0,0 +1,286 @@
+import {
+  drainQueueJson,
+  embedIdentity,
+  errorCode,
+  errorMessage,
+  parseObject,
+  push,
+  warningEvent
+} from "./chunk-4R7C2TLH.js";
+import {
+  connectAuthority
+} from "./chunk-Y6XHXDIK.js";
+import "./chunk-UX3F6YTV.js";
+import {
+  firstpersonWorld
+} from "./chunk-5JGRFT2N.js";
+import "./chunk-K3SF5VDS.js";
+import {
+  AuthorityTiming,
+  CloseCode,
+  ServerMessage,
+  isReservedEventType
+} from "./chunk-ZSWF4VCN.js";
+
+// src/bridge-authority.ts
+import { getAuthorityRegions, getAuthorityUrls, getColyseusAuth } from "@genex-ai/embed-sdk";
+var version = 3;
+var embedAuthorityIdentity = {
+  ready: (gameId) => embedIdentity.ready(gameId),
+  auth: () => getColyseusAuth(),
+  urls: () => getAuthorityUrls(),
+  regions: () => getAuthorityRegions()
+};
+var identity = embedAuthorityIdentity;
+function setAuthorityIdentity(next) {
+  identity = next ?? embedAuthorityIdentity;
+}
+var physicsCore;
+function setAuthorityPhysicsCore(load) {
+  physicsCore = load ?? void 0;
+}
+var MAX_RENDER_DELAY_MS = AuthorityTiming.MAX_REWIND_MS;
+var MAX_CAPACITY_RETRIES = 5;
+var MAX_CAPACITY_RETRY_MS = 3e4;
+var INPUT_FIELDS = ["moveX", "moveY", "moveZ", "yaw", "pitch", "buttons"];
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+function retrySchedule(v) {
+  if (!Array.isArray(v) || v.length > MAX_CAPACITY_RETRIES) return void 0;
+  const valid = v.every((ms) => isFiniteNumber(ms) && ms >= 0 && ms <= MAX_CAPACITY_RETRY_MS);
+  return valid ? v : void 0;
+}
+function parseOptions(optsJson) {
+  const o = parseObject(optsJson, "options");
+  const gameId = typeof o.gameId === "string" ? o.gameId : "";
+  if (!gameId) throw new TypeError("genex bridge: `gameId` (the game slug) is required");
+  const delay = o.renderDelayMs;
+  const delayOk = isFiniteNumber(delay) && delay >= 0 && delay <= MAX_RENDER_DELAY_MS;
+  return {
+    gameId,
+    name: typeof o.name === "string" && o.name ? o.name : void 0,
+    urls: Array.isArray(o.urls) ? o.urls.filter((u) => typeof u === "string" && u !== "") : [],
+    predict: o.predict !== false,
+    predictPhysics: o.predictPhysics !== false,
+    renderDelayMs: delayOk ? delay : void 0,
+    capacityRetryMs: retrySchedule(o.capacityRetryMs)
+  };
+}
+var sessions = /* @__PURE__ */ new Map();
+var FIRST_HANDLE = 2 ** 30;
+var lastHandle = FIRST_HANDLE;
+var entry = (handle) => typeof handle === "number" ? sessions.get(handle) : void 0;
+var live = (handle) => {
+  const e = entry(handle);
+  return e && !e.closed ? e.session : null;
+};
+function end(e) {
+  e.closed = true;
+  for (const off of e.unwire.splice(0)) off();
+  e.session = null;
+}
+function onServerMessage(e, type, data) {
+  if (!isReservedEventType(type)) push(e, { type: "message", kind: type, data: data ?? null });
+  else if (type === ServerMessage.SERVER_RESTART) push(e, { type: "serverRestart" });
+}
+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();
+  const regions = o.urls.length ? [] : identity.regions?.() ?? [];
+  if (!urls.length && !regions.length) {
+    throw Object.assign(new Error("genex bridge: no authority server URL (pass urls, or run on a Genex page that serves authority rooms)"), { code: 0 });
+  }
+  const s = await connectAuthority({
+    urls,
+    regions,
+    room: o.gameId,
+    name: o.name,
+    auth: () => identity.auth(),
+    predict: o.predict ? void 0 : false,
+    physicsCore,
+    predictPhysics: o.predictPhysics,
+    renderDelayMs: o.renderDelayMs,
+    capacityRetryMs: o.capacityRetryMs,
+    onEvent: (type, data) => {
+      if (!e.closed) onServerMessage(e, type, data);
+    }
+  });
+  if (e.closed) {
+    await s.leave();
+    return;
+  }
+  e.session = s;
+  e.sessionId = s.id;
+  if (e.world) s.setWorld(e.world);
+  e.unwire.push(
+    s.on("reconnecting", ({ code }) => push(e, { type: "reconnecting", code })),
+    s.on("reconnected", () => push(e, { type: "reconnected" })),
+    s.on("disconnect", (code) => {
+      end(e);
+      push(e, { type: "disconnected", code, reason: "" });
+    })
+  );
+  push(e, { type: "joined", sessionId: s.id });
+}
+function openAuthority(optsJson) {
+  const opts = parseOptions(optsJson);
+  const handle = ++lastHandle;
+  const e = {
+    opts,
+    q: [],
+    overflowed: false,
+    session: null,
+    unwire: [],
+    roster: /* @__PURE__ */ new Set(),
+    sessionId: "",
+    closed: false,
+    world: null
+  };
+  sessions.set(handle, e);
+  join(e).catch((err) => {
+    if (e.closed) return;
+    end(e);
+    push(e, { type: "joinFailed", code: errorCode(err), message: errorMessage(err) });
+  });
+  return handle;
+}
+function setInput(handle, json) {
+  const patch = parseObject(json, "input");
+  const s = live(handle);
+  if (!s) return false;
+  for (const field of INPUT_FIELDS) {
+    const value = patch[field];
+    if (isFiniteNumber(value)) s.input[field] = value;
+  }
+  return true;
+}
+function predictProjectile(handle, json) {
+  const o = parseObject(json, "projectile");
+  const s = live(handle);
+  if (!s) return "";
+  const num = (v) => isFiniteNumber(v) ? v : 0;
+  return s.predictProjectile({
+    kind: typeof o.kind === "string" ? o.kind : "",
+    x: num(o.x),
+    y: num(o.y),
+    z: num(o.z),
+    vx: num(o.vx),
+    vy: num(o.vy),
+    vz: num(o.vz),
+    ...isFiniteNumber(o.g) ? { g: o.g } : {}
+  });
+}
+function setWorld(handle, json) {
+  const raw = parseObject(json, "world");
+  const e = entry(handle);
+  if (!e || e.closed) return false;
+  let world;
+  try {
+    world = firstpersonWorld(raw);
+  } catch (err) {
+    push(e, warningEvent(errorMessage(err)));
+    return false;
+  }
+  e.world = world;
+  e.session?.setWorld(world);
+  return true;
+}
+var NO_FRAME = JSON.stringify({ tick: 0, sent: 0, connected: false, me: null, entities: [] });
+function frame(handle, now) {
+  const s = live(handle);
+  if (!s) return NO_FRAME;
+  const sent = s.frame(isFiniteNumber(now) ? now : performance.now());
+  return JSON.stringify({
+    tick: s.tick,
+    sent,
+    connected: s.connected,
+    me: s.me() ?? null,
+    entities: [...s.entities().values()]
+  });
+}
+var BODY_F32_STRIDE = 8;
+var BodyF32Flag = { PREDICTED: 1, ASLEEP: 2 };
+var NO_BODIES = new Float32Array(0);
+function drawnBodies(s) {
+  return [...s.entities().values()].filter((v) => v.body).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+function bodiesF32(handle) {
+  const s = live(handle);
+  if (!s) return NO_BODIES;
+  const bodies = drawnBodies(s);
+  const out = new Float32Array(bodies.length * BODY_F32_STRIDE);
+  bodies.forEach((b, i) => {
+    const o = i * BODY_F32_STRIDE;
+    out.set([b.x, b.y, b.z, b.qx, b.qy, b.qz, b.qw], o);
+    out[o + 7] = (b.predicted ? BodyF32Flag.PREDICTED : 0) | (b.sleep ? BodyF32Flag.ASLEEP : 0);
+  });
+  return out;
+}
+function bodyKeysJson(handle) {
+  const s = live(handle);
+  return JSON.stringify(s ? drawnBodies(s).map((b) => b.id) : []);
+}
+function authorityJson(handle) {
+  const e = entry(handle);
+  const s = live(handle);
+  return JSON.stringify({
+    sessionId: e?.sessionId ?? "",
+    connected: !!s && s.connected,
+    closed: !e || e.closed,
+    tick: s?.tick ?? 0,
+    queued: e?.q.length ?? 0,
+    players: s ? [...s.players().values()] : [],
+    telemetry: s ? { ...s.telemetry } : null,
+    prediction: s ? s.prediction : null,
+    physicsPrediction: s ? s.physicsPrediction : null
+  });
+}
+function noteRoster(e, s) {
+  const now = new Set(s.players().keys());
+  for (const id of now) if (!e.roster.has(id)) push(e, { type: "playerJoined", id });
+  for (const id of e.roster) if (!now.has(id)) push(e, { type: "playerLeft", id });
+  e.roster = now;
+}
+function drainAuthorityEventsJson(handle) {
+  const e = entry(handle);
+  if (!e) return "[]";
+  try {
+    const s = live(handle);
+    if (s) noteRoster(e, s);
+  } catch (err) {
+    push(e, warningEvent(errorMessage(err)));
+  }
+  return drainQueueJson(e);
+}
+function closeAuthority(handle) {
+  const e = entry(handle);
+  if (!e || e.closed) return;
+  const s = e.session;
+  end(e);
+  void s?.leave().catch(() => {
+  });
+  push(e, { type: "disconnected", code: CloseCode.CONSENTED, reason: "left" });
+}
+function disposeAuthority(handle) {
+  closeAuthority(handle);
+  if (typeof handle === "number") sessions.delete(handle);
+}
+export {
+  BODY_F32_STRIDE,
+  BodyF32Flag,
+  authorityJson,
+  bodiesF32,
+  bodyKeysJson,
+  closeAuthority,
+  disposeAuthority,
+  drainAuthorityEventsJson,
+  frame,
+  openAuthority,
+  predictProjectile,
+  setAuthorityIdentity,
+  setAuthorityPhysicsCore,
+  setInput,
+  setWorld,
+  version
+};

package/dist/bridge-core-Dhc73GC8.d.ts

@@ -0,0 +1,27 @@
+type Json = Record<string, unknown>;
+/** One queued event: `{ type, ...fields }` (BRIDGE.md, "Events"). */
+type BridgeEvent = {
+    type: string;
+} & Json;
+/**
+ * Where the bridge gets the player's identity. The default is `@genex-ai/embed-sdk`; a host page
+ * or a test replaces it with `setIdentity` (relay) or `setAuthorityIdentity` (authority).
+ */
+type BridgeIdentity = {
+    /** Resolves once a player exists (guest or signed in); rejects when there never will be one. */
+    ready(gameId: string): Promise<unknown> | unknown;
+    /** The join credential, read fresh for EVERY join (never cached). `undefined` = tokenless. */
+    auth(): {
+        embedToken: string;
+    } | undefined;
+    /** The server URLs to use when the engine passes none. */
+    urls(): string[];
+    /** The servers by region (authority rooms, PROTOCOL.md §17.1 *Regions*) to use when the engine
+     *  passes no urls. Omitted: none. */
+    regions?(): {
+        region: string;
+        urls: string[];
+    }[];
+};
+
+export type { BridgeIdentity as B, BridgeEvent as a };

package/dist/bridge.d.ts

@@ -1,24 +1,30 @@
-/** The contract version (BRIDGE.md). Bumped only on a breaking change to a signature or a shape. */
-declare const version = 1;
-type Json = Record<string, unknown>;
-/** One queued event: `{ type, ...fields }` (BRIDGE.md, "Events"). */
-type BridgeEvent = {
-    type: string;
-} & Json;
+import { B as BridgeIdentity } from './bridge-core-Dhc73GC8.js';
+export { a as BridgeEvent } from './bridge-core-Dhc73GC8.js';
+
+/**
+ * `@genex-ai/multiplayer/bridge` — a flat facade over this SDK for engines that compile to the web
+ * and cannot hold a JS object graph: Rust (wasm-bindgen), Godot web exports (`JavaScriptBridge`),
+ * Unity WebGL (`.jslib`). The normative contract is `sdks/rust/BRIDGE.md`.
+ *
+ * - Every value crosses as a JSON string, a number or a boolean: one crossing per call.
+ * - A session is an opaque numeric handle. `open()` returns one synchronously (the join outcome
+ *   arrives as a `joined` / `joinFailed` event); `connect()` is the same join as a Promise.
+ * - Everything the session reports is queued and handed over by `drainEventsJson()`, which an
+ *   engine calls once per frame. Event objects are exactly the serde form of the Rust `Event`
+ *   enum, plus a few types only Godot reads (BRIDGE.md, "Events").
+ * - Identity stays in TypeScript: the bridge waits for `@genex-ai/embed-sdk`'s player and reads a
+ *   FRESH embed token for every join. An engine never sees a token.
+ *
+ * The self-registering build (`dist/bridge.global.js`) sets `window.GenexMultiplayerBridge` to
+ * this module's exports, with the SDK and embed-sdk bundled in.
+ */
+
 /**
- * Where the bridge gets the player's identity. The default is `@genex-ai/embed-sdk`; a host page
- * or a test replaces it with {@link setIdentity}.
+ * The contract version (BRIDGE.md). Bumped only on a breaking change to a signature or a shape, or
+ * when calls are added: 2 added the authority calls (`bridge-authority.ts`, in the authority build
+ * only), and every version-1 call is unchanged.
  */
-type BridgeIdentity = {
-    /** Resolves once a player exists (guest or signed in); rejects when there never will be one. */
-    ready(gameId: string): Promise<unknown> | unknown;
-    /** The join credential, read fresh for EVERY join (never cached). `undefined` = tokenless. */
-    auth(): {
-        embedToken: string;
-    } | undefined;
-    /** The relay URLs to use when the engine passes none. */
-    urls(): string[];
-};
+declare const version = 2;
 /**
  * Replace the identity source (`null` restores embed-sdk). For a host page that manages identity
  * itself, and for tests against a token-free local relay. Not part of the engine contract.
@@ -86,4 +92,4 @@ declare function sharedJson(handle: number): string;
  */
 declare function drainEventsJson(handle: number): string;
 
-export { type BridgeEvent, type BridgeIdentity, chatSend, claim, claimAsHost, 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 };
+export { BridgeIdentity, chatSend, claim, claimAsHost, 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 };