@genex-ai/embed-sdk 0.3.2 → 0.4.1

package/dist/{chunk-A2RFRR7H.js → chunk-LWEYUUBS.js}

@@ -22,6 +22,9 @@ var authWaiters = [];
 var playerWaiters = [];
 var overlayEl = null;
 var popoverEl = null;
+var pendingPlayerSave;
+var hasPendingPlayerSave = false;
+var pendingScores = /* @__PURE__ */ new Map();
 function win() {
   return globalThis.window;
 }
@@ -129,6 +132,145 @@ function on(event, cb) {
     set.delete(cb);
   };
 }
+var KEEPALIVE_MAX_BYTES = 32 * 1024;
+async function ensurePlayer() {
+  if (!config) throw new Error("genex embed: call initEmbed() first");
+  if (state === "pending") await waitForPlayer();
+  if (state === "blocked") throw new Error("genex embed auth: blocked");
+}
+var lastWorldVersion;
+function stateFetch(path, init = {}) {
+  const headers = { Authorization: `Bearer ${embedToken}` };
+  if (init.body !== void 0) headers["Content-Type"] = "application/json";
+  if (init.ifVersion !== void 0) headers["If-Match"] = String(init.ifVersion);
+  return doFetch(`${config.apiUrl}/api/projects/${encodeURIComponent(config.slug)}${path}`, {
+    method: init.method ?? "GET",
+    headers,
+    body: init.body,
+    keepalive: init.body !== void 0 && init.body.length <= KEEPALIVE_MAX_BYTES ? true : void 0
+  });
+}
+async function decodeSave(res) {
+  if (res.status === 409) {
+    const body2 = await res.json().catch(() => ({}));
+    return { saved: false, conflict: true, version: body2.version };
+  }
+  if (!res.ok) {
+    emit("error", { error: new Error(`genex state save failed (${res.status})`) });
+    return { saved: false };
+  }
+  const body = await res.json();
+  return { saved: true, version: body.version };
+}
+async function loadPlayerState() {
+  await ensurePlayer();
+  if (state === "guest") {
+    return { data: hasPendingPlayerSave ? pendingPlayerSave : null, version: 0, guest: true };
+  }
+  const res = await stateFetch("/state/me");
+  if (!res.ok) throw new Error(`genex load player state failed (${res.status})`);
+  const body = await res.json();
+  return { data: body.data, version: body.version };
+}
+async function savePlayerState(data, opts) {
+  await ensurePlayer();
+  if (state === "guest") {
+    pendingPlayerSave = data;
+    hasPendingPlayerSave = true;
+    return { saved: false, guest: true, queued: true };
+  }
+  return decodeSave(
+    await stateFetch("/state/me", {
+      method: "PUT",
+      body: JSON.stringify(data),
+      ifVersion: opts?.ifVersion
+    })
+  );
+}
+async function loadWorldState() {
+  await ensurePlayer();
+  if (state === "guest") return { data: null, version: 0, guest: true };
+  const res = await stateFetch("/state");
+  if (!res.ok) throw new Error(`genex load world state failed (${res.status})`);
+  const body = await res.json();
+  lastWorldVersion = body.version;
+  return { data: body.data, version: body.version };
+}
+async function saveWorldState(data, opts) {
+  await ensurePlayer();
+  if (state === "guest") return { saved: false, guest: true };
+  const guard = opts && "ifVersion" in opts ? opts.ifVersion : lastWorldVersion;
+  const result = await decodeSave(
+    await stateFetch("/state", {
+      method: "PUT",
+      body: JSON.stringify(data),
+      ifVersion: guard == null ? void 0 : guard
+    })
+  );
+  if (result.version !== void 0) lastWorldVersion = result.version;
+  return result;
+}
+async function submitScore(score, opts) {
+  const board = opts?.board ?? "main";
+  const mode = opts?.mode ?? "max";
+  await ensurePlayer();
+  if (state === "guest") {
+    const prev = pendingScores.get(board);
+    if (!prev || (mode === "min" ? score < prev.score : score > prev.score)) {
+      pendingScores.set(board, { score, mode });
+    }
+    return { submitted: false, guest: true, queued: true };
+  }
+  const res = await stateFetch("/scores", {
+    method: "POST",
+    body: JSON.stringify({ score, board, mode })
+  });
+  if (!res.ok) {
+    emit("error", { error: new Error(`genex score submit failed (${res.status})`) });
+    return { submitted: false };
+  }
+  const body = await res.json();
+  return { submitted: true, best: body.best, improved: body.improved };
+}
+async function getLeaderboard(opts) {
+  if (!config) throw new Error("genex embed: call initEmbed() first");
+  if (state === "pending") {
+    try {
+      await waitForPlayer();
+    } catch {
+    }
+  }
+  const params = new URLSearchParams();
+  if (opts?.board !== void 0) params.set("board", opts.board);
+  if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+  if (opts?.order !== void 0) params.set("order", opts.order);
+  const qs = params.toString();
+  const headers = {};
+  if (embedToken) headers.Authorization = `Bearer ${embedToken}`;
+  const res = await doFetch(
+    `${config.apiUrl}/api/projects/${encodeURIComponent(config.slug)}/leaderboard${qs ? `?${qs}` : ""}`,
+    { headers }
+  );
+  if (!res.ok) throw new Error(`genex leaderboard failed (${res.status})`);
+  return await res.json();
+}
+async function flushGuestQueue() {
+  try {
+    if (hasPendingPlayerSave) {
+      const save = pendingPlayerSave;
+      pendingPlayerSave = void 0;
+      hasPendingPlayerSave = false;
+      await savePlayerState(save);
+    }
+    const queued = [...pendingScores.entries()];
+    pendingScores.clear();
+    for (const [board, { score, mode }] of queued) {
+      await submitScore(score, { board, mode });
+    }
+  } catch (error) {
+    emit("error", { error });
+  }
+}
 function emit(event, ctx) {
   const set = listeners.get(event);
   if (!set) return;
@@ -293,6 +435,7 @@ async function redeemTicket(ticket) {
     if (isEmbedded() && parentOrigin) {
       postToParent({ type: "genex:embed:authenticated", v: PROTOCOL_VERSION }, parentOrigin);
     }
+    if (upgradingFromGuest) await flushGuestQueue();
     const ctx = { user };
     for (const waiter of authWaiters.splice(0)) waiter.resolve(ctx);
     for (const waiter of playerWaiters.splice(0)) waiter.resolve({ user, guest: false });
@@ -550,6 +693,9 @@ function __resetForTests(overrides) {
   authWaiters = [];
   playerWaiters = [];
   stashedTicketHash = null;
+  pendingPlayerSave = void 0;
+  hasPendingPlayerSave = false;
+  pendingScores.clear();
   handshakeTimeoutMs = overrides?.handshakeTimeoutMs ?? 1e4;
   refreshDelayMs = overrides?.refreshDelayMs ?? 10 * 6e4;
   refreshRetryMs = overrides?.refreshRetryMs ?? 6e4;
@@ -565,6 +711,12 @@ export {
   waitForAuth,
   waitForPlayer,
   on,
+  loadPlayerState,
+  savePlayerState,
+  loadWorldState,
+  saveWorldState,
+  submitScore,
+  getLeaderboard,
   _stashTicketFromUrl,
   __resetForTests
 };

package/dist/index.d.ts

@@ -17,6 +17,56 @@ interface EmbedUser {
 }
 type AuthState = 'pending' | 'authenticated' | 'guest' | 'blocked';
 type EmbedEvent = 'authenticated' | 'guest' | 'blocked' | 'error';
+interface PlayerStateResult {
+    /** The saved blob, or null when this player never saved. For guests: the queued pending save, if any. */
+    data: unknown;
+    /** Optimistic-concurrency version — pass to savePlayerState({ ifVersion }) to detect races. 0 = never saved. */
+    version: number;
+    /** True when the current identity is a guest (server storage untouched). */
+    guest?: boolean;
+}
+interface WorldStateResult {
+    data: unknown;
+    version: number;
+    guest?: boolean;
+}
+interface SaveStateResult {
+    /** True when the write landed on the server. */
+    saved: boolean;
+    /** The row's version after a successful write — or the CURRENT server version on a conflict. */
+    version?: number;
+    /** True when If-Match lost the race (reload, merge, retry with the fresh version). */
+    conflict?: boolean;
+    /** True when the caller is a guest — accounts save, guests don't. */
+    guest?: boolean;
+    /** True when the value was queued to auto-flush if this guest signs in mid-game. */
+    queued?: boolean;
+}
+interface SubmitScoreResult {
+    submitted: boolean;
+    /** The standing best after this submit (may be an older, better score). */
+    best?: number;
+    /** True when this submit improved the player's best. */
+    improved?: boolean;
+    guest?: boolean;
+    /** True when the score was queued to auto-submit if this guest signs in mid-game. */
+    queued?: boolean;
+}
+interface LeaderboardEntry {
+    userId: string;
+    name: string;
+    image?: string | null;
+    score: number;
+    updatedAt: string;
+}
+interface Leaderboard {
+    items: LeaderboardEntry[];
+    /** This player's rank + best — null for guests, tokenless reads, and players with no score. */
+    me: {
+        rank: number;
+        score: number;
+    } | null;
+}
 interface EventContext {
     user?: EmbedUser;
     error?: unknown;
@@ -92,6 +142,68 @@ declare function waitForPlayer(): Promise<{
 }>;
 /** Subscribe to auth lifecycle events. Returns an unsubscribe function. */
 declare function on(event: EmbedEvent, cb: (ctx?: EventContext) => void): () => void;
+/**
+ * Load THIS player's own save slot (per-player, per-game — another player can
+ * never read or clobber it). Resolves { data: null, version: 0 } when they
+ * never saved. Guests get their queued pending save (if any) so a round-trip
+ * works mid-session; the server is untouched. Await-safe from boot: resolves
+ * after identity exists, rejects only when the session is blocked.
+ */
+declare function loadPlayerState(): Promise<PlayerStateResult>;
+/**
+ * Save THIS player's own slot (any JSON ≤ 256KB; last-write-wins on their own
+ * row). Guests: the value is QUEUED in memory and auto-flushed if they sign in
+ * mid-game ({ saved: false, guest: true, queued: true }) — no extra game code.
+ * Pass { ifVersion } (from the last load/save) to detect same-account
+ * two-device races: a losing write resolves { conflict: true, version } —
+ * reload, merge, retry. Small saves survive tab close (fetch keepalive).
+ */
+declare function savePlayerState(data: unknown, opts?: {
+    ifVersion?: number;
+}): Promise<SaveStateResult>;
+/**
+ * Load the game's SHARED world slot (one blob per game — every player reads
+ * the same world). Guests resolve { data: null, guest: true } — the server
+ * refuses guest reads; in multiplayer, guests receive the live world through
+ * the room instead.
+ */
+declare function loadWorldState(): Promise<WorldStateResult>;
+/**
+ * Save the game's SHARED world slot (any JSON ≤ 1MB, any signed-in player may
+ * write — let ONE authority do it, e.g. the multiplayer host, and debounce).
+ * If-Match is sent BY DEFAULT (from the last version this SDK loaded/saved), so a
+ * shared write can't silently clobber a newer one — a lost race resolves
+ * { conflict: true, version }: reload, merge, retry. Pass { ifVersion: n } to
+ * guard against a specific version, or { ifVersion: null } to force an
+ * unconditional overwrite (the old last-write-wins behaviour). Guests:
+ * { saved: false, guest: true } — world saves are NEVER queued (flushing a stale
+ * world later would clobber the live one; the eventual account host keeps saving).
+ */
+declare function saveWorldState(data: unknown, opts?: {
+    ifVersion?: number | null;
+}): Promise<SaveStateResult>;
+/**
+ * Submit a score (soft-trust leaderboards: identity is verified server-side,
+ * one row per real player per board). Keep-best: only a strictly better score
+ * moves the row — `mode: "min"` for lap-time-style boards (send a consistent
+ * mode per board). Guests: the BEST value per board is queued and
+ * auto-submitted if they sign in mid-game.
+ */
+declare function submitScore(score: number, opts?: {
+    board?: string;
+    mode?: 'max' | 'min';
+}): Promise<SubmitScoreResult>;
+/**
+ * Read a leaderboard: top entries (verified display names) + this player's
+ * own rank when signed in. Works for EVERYONE on published games — guests and
+ * even tokenless contexts read the public board (me: null). limit ≤ 100;
+ * order "asc" for lower-is-better boards.
+ */
+declare function getLeaderboard(opts?: {
+    board?: string;
+    limit?: number;
+    order?: 'desc' | 'asc';
+}): Promise<Leaderboard>;
 /**
  * @internal — for ./sentry.ts ONLY, not public API (games never call this).
  * If the URL fragment carries any genex marker (`genex_ticket` — a secret —
@@ -105,4 +217,4 @@ declare function __resetForTests(overrides?: {
     refreshRetryMs?: number;
 }): void;
 
-export { type AuthState, type EmbedConfig, type EmbedEvent, type EmbedUser, __resetForTests, _stashTicketFromUrl, getAuthState, getColyseusAuth, getEmbedToken, getUser, initEmbed, isEmbedded, on, waitForAuth, waitForPlayer };
+export { type AuthState, type EmbedConfig, type EmbedEvent, type EmbedUser, type Leaderboard, type LeaderboardEntry, type PlayerStateResult, type SaveStateResult, type SubmitScoreResult, type WorldStateResult, __resetForTests, _stashTicketFromUrl, getAuthState, getColyseusAuth, getEmbedToken, getLeaderboard, getUser, initEmbed, isEmbedded, loadPlayerState, loadWorldState, on, savePlayerState, saveWorldState, submitScore, waitForAuth, waitForPlayer };

package/dist/index.js

@@ -4,23 +4,35 @@ import {
   getAuthState,
   getColyseusAuth,
   getEmbedToken,
+  getLeaderboard,
   getUser,
   initEmbed,
   isEmbedded,
+  loadPlayerState,
+  loadWorldState,
   on,
+  savePlayerState,
+  saveWorldState,
+  submitScore,
   waitForAuth,
   waitForPlayer
-} from "./chunk-A2RFRR7H.js";
+} from "./chunk-LWEYUUBS.js";
 export {
   __resetForTests,
   _stashTicketFromUrl,
   getAuthState,
   getColyseusAuth,
   getEmbedToken,
+  getLeaderboard,
   getUser,
   initEmbed,
   isEmbedded,
+  loadPlayerState,
+  loadWorldState,
   on,
+  savePlayerState,
+  saveWorldState,
+  submitScore,
   waitForAuth,
   waitForPlayer
 };

package/dist/sentry.js

@@ -2,7 +2,7 @@ import {
   _stashTicketFromUrl,
   getUser,
   on
-} from "./chunk-A2RFRR7H.js";
+} from "./chunk-LWEYUUBS.js";
 
 // src/sentry.ts
 import * as Sentry from "@sentry/browser";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genex-ai/embed-sdk",
-  "version": "0.3.2",
-  "description": "Player identity for genex games — signed-in (dashboard iframe postMessage handshake or sign-in redirect) or guest (accountless play for published games, sign in to save).",
+  "version": "0.4.1",
+  "description": "Player identity + durable game state for genex games — signed-in or guest play, per-player save slots, shared world state, and soft-trust leaderboards.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,6 +20,13 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test test/*.test.ts",
+    "check": "pnpm build && publint && attw --pack . --profile esm-only",
+    "prepack": "pnpm build && publint"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -42,11 +49,5 @@
     "url": "git+https://github.com/me-ai-org/genex-demo.git",
     "directory": "packages/embed-sdk"
   },
-  "license": "MIT",
-  "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "test": "node --test test/*.test.ts",
-    "check": "pnpm build && publint && attw --pack . --profile esm-only"
-  }
-}
+  "license": "MIT"
+}