@genex-ai/embed-sdk 0.12.0 → 0.14.0

package/dist/{chunk-EEOKYBXG.js → chunk-5SVRR26C.js}

@@ -1,11 +1,249 @@
+// ../embed-protocol/src/constants.ts
+var NATIVE_CHANNEL = "genex-native";
+var NATIVE_PROTOCOL_VERSION = 1;
+var NATIVE_MARKER_PARAM = "genex_native";
+var NATIVE_MARKER_VALUE = "1";
+var NATIVE_PROTOCOL_PARAM = "genex_protocol";
+var NATIVE_ATTEMPT_PARAM = "genex_attempt";
+var NATIVE_NONCE_PARAM = "genex_nonce";
+var NATIVE_RECEIVER = "__genexNative";
+var MAX_BRIDGE_MESSAGE_BYTES = 4096;
+var BRIDGE_ID_RE = /^[0-9a-f]{32}$/;
+var SLUG_RE = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+function isBridgeId(value) {
+  return typeof value === "string" && BRIDGE_ID_RE.test(value);
+}
+function isBridgeSlug(value) {
+  return typeof value === "string" && SLUG_RE.test(value);
+}
+
+// ../embed-protocol/src/base64url.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var LOOKUP = (() => {
+  const table = new Array(128).fill(-1);
+  for (let i = 0; i < ALPHABET.length; i++) table[ALPHABET.charCodeAt(i)] = i;
+  return table;
+})();
+function utf8Bytes(text) {
+  const out = [];
+  for (let i = 0; i < text.length; i++) {
+    let code = text.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+      if (next >= 56320 && next <= 57343) {
+        code = 65536 + (code - 55296 << 10) + (next - 56320);
+        i++;
+      } else {
+        code = 65533;
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      code = 65533;
+    }
+    if (code < 128) out.push(code);
+    else if (code < 2048) out.push(192 | code >> 6, 128 | code & 63);
+    else if (code < 65536) {
+      out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    } else {
+      out.push(
+        240 | code >> 18,
+        128 | code >> 12 & 63,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    }
+  }
+  return out;
+}
+function utf8Text(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; ) {
+    const b0 = bytes[i];
+    let code;
+    let size;
+    if (b0 < 128) {
+      code = b0;
+      size = 1;
+    } else if ((b0 & 224) === 192) {
+      code = b0 & 31;
+      size = 2;
+    } else if ((b0 & 240) === 224) {
+      code = b0 & 15;
+      size = 3;
+    } else if ((b0 & 248) === 240) {
+      code = b0 & 7;
+      size = 4;
+    } else return null;
+    if (i + size > bytes.length) return null;
+    for (let k = 1; k < size; k++) {
+      const b = bytes[i + k];
+      if ((b & 192) !== 128) return null;
+      code = code << 6 | b & 63;
+    }
+    if (size === 2 && code < 128) return null;
+    if (size === 3 && (code < 2048 || code >= 55296 && code <= 57343)) return null;
+    if (size === 4 && (code < 65536 || code > 1114111)) return null;
+    if (code > 65535) {
+      const v = code - 65536;
+      out += String.fromCharCode(55296 + (v >> 10), 56320 + (v & 1023));
+    } else {
+      out += String.fromCharCode(code);
+    }
+    i += size;
+  }
+  return out;
+}
+function utf8ByteLength(text) {
+  return utf8Bytes(text).length;
+}
+function encodeBase64UrlJson(value) {
+  const bytes = utf8Bytes(JSON.stringify(value));
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    out += ALPHABET[b0 >> 2];
+    out += ALPHABET[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+    if (b1 === void 0) break;
+    out += ALPHABET[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+    if (b2 === void 0) break;
+    out += ALPHABET[b2 & 63];
+  }
+  return out;
+}
+function decodeBase64UrlJson(encoded) {
+  if (encoded.length % 4 === 1) return void 0;
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (let i = 0; i < encoded.length; i++) {
+    const code = encoded.charCodeAt(i);
+    const value = code < 128 ? LOOKUP[code] : -1;
+    if (value < 0) return void 0;
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  if (bits > 0 && (buffer & (1 << bits) - 1) !== 0) return void 0;
+  const text = utf8Text(bytes);
+  if (text === null) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+
+// ../embed-protocol/src/messages.ts
+var MAX_TICKET_LENGTH = 2048;
+var MAX_EXPIRES_AT_LENGTH = 32;
+var ISO_INSTANT_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+  const own = Object.keys(value);
+  if (own.length !== keys.length) return false;
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) return false;
+  }
+  return true;
+}
+var BASE_KEYS = ["channel", "v", "type", "slug", "attemptId", "nonce"];
+function envelopeBaseIsValid(value) {
+  return value.channel === NATIVE_CHANNEL && value.v === NATIVE_PROTOCOL_VERSION && isBridgeSlug(value.slug) && isBridgeId(value.attemptId) && isBridgeId(value.nonce);
+}
+function parseBridgeNativeCommand(value) {
+  if (!isRecord(value) || !envelopeBaseIsValid(value)) return void 0;
+  switch (value.type) {
+    case "ticket":
+      if (!hasExactKeys(value, [...BASE_KEYS, "ticket", "expiresAt"])) return void 0;
+      if (typeof value.ticket !== "string" || value.ticket.length === 0 || value.ticket.length > MAX_TICKET_LENGTH) {
+        return void 0;
+      }
+      if (typeof value.expiresAt !== "string" || value.expiresAt.length > MAX_EXPIRES_AT_LENGTH || !ISO_INSTANT_RE.test(value.expiresAt)) {
+        return void 0;
+      }
+      return value;
+    case "guest":
+    case "cancel":
+      if (!hasExactKeys(value, BASE_KEYS)) return void 0;
+      return value;
+    case "foreground":
+      if (!hasExactKeys(value, [...BASE_KEYS, "active"])) return void 0;
+      if (typeof value.active !== "boolean") return void 0;
+      return value;
+    case "network":
+      if (!hasExactKeys(value, [...BASE_KEYS, "online"])) return void 0;
+      if (typeof value.online !== "boolean") return void 0;
+      return value;
+    default:
+      return void 0;
+  }
+}
+
+// ../embed-protocol/src/transport.ts
+function read(raw, parse) {
+  if (typeof raw !== "string" || raw.length === 0) return { ok: false, reason: "undecodable" };
+  if (utf8ByteLength(raw) > MAX_BRIDGE_MESSAGE_BYTES) return { ok: false, reason: "too-large" };
+  const decoded = decodeBase64UrlJson(raw);
+  if (decoded === void 0) return { ok: false, reason: "undecodable" };
+  const message = parse(decoded);
+  if (message === void 0) return { ok: false, reason: "invalid" };
+  return { ok: true, message };
+}
+function readBridgeNativeCommand(raw) {
+  return read(raw, parseBridgeNativeCommand);
+}
+function encodeBridgeMessage(message) {
+  const encoded = encodeBase64UrlJson(message);
+  if (encoded.length > MAX_BRIDGE_MESSAGE_BYTES) return void 0;
+  return encoded;
+}
+
+// ../embed-protocol/src/entry-url.ts
+function readParam(search, key) {
+  const query = search.charAt(0) === "?" ? search.slice(1) : search;
+  if (query.length === 0) return null;
+  for (const pair of query.split("&")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) continue;
+    if (pair.slice(0, eq) === key) return pair.slice(eq + 1);
+  }
+  return null;
+}
+function hasNativeMarker(search) {
+  return readParam(search, NATIVE_MARKER_PARAM) === NATIVE_MARKER_VALUE;
+}
+function readNativeEntry(search) {
+  if (!hasNativeMarker(search)) return null;
+  const attemptId = readParam(search, NATIVE_ATTEMPT_PARAM);
+  const nonce = readParam(search, NATIVE_NONCE_PARAM);
+  const protocol = Number(readParam(search, NATIVE_PROTOCOL_PARAM));
+  if (!isBridgeId(attemptId) || !isBridgeId(nonce)) return null;
+  if (protocol !== NATIVE_PROTOCOL_VERSION) return null;
+  return { attemptId, nonce, protocol };
+}
+
 // src/index.ts
 var PROTOCOL_VERSION = 1;
 var RETRY_FLAG = "genex:embed:retry";
 var POPOVER_DISMISSED_FLAG = "genex:guest:popover-dismissed";
+var LOCAL_AUTH_FLAG = "genex:embed:local-auth";
+var PLAYER_ID_KEY = "genex:player";
+var SDK_VERSION = "0.14.0";
 var config = null;
 var state = "pending";
 var user = null;
 var localTestMode = false;
+var nativeEntry = null;
+var nativeReauthPending = false;
+var nativeReauthTimer;
+var heartbeatTimer;
+var nativeBootAt = 0;
 var embedToken;
 var colyseusUrls;
 var parentOrigin = null;
@@ -17,6 +255,8 @@ var handshakeTimeoutMs = 1e4;
 var refreshDelayMs = 10 * 6e4;
 var refreshRetryMs = 6e4;
 var overlayTextDelayMs = 500;
+var nativeReauthTimeoutMs = 3e4;
+var heartbeatIntervalMs = 3e4;
 var handshakeTimer;
 var refreshTimer;
 var messageHandler;
@@ -57,6 +297,19 @@ function clearRetryFlag() {
   } catch {
   }
 }
+function readLocalAuthFlag() {
+  try {
+    return win()?.sessionStorage?.getItem(LOCAL_AUTH_FLAG) === "1";
+  } catch {
+    return false;
+  }
+}
+function writeLocalAuthFlag() {
+  try {
+    win()?.sessionStorage?.setItem(LOCAL_AUTH_FLAG, "1");
+  } catch {
+  }
+}
 function readPopoverDismissed() {
   try {
     return win()?.sessionStorage?.getItem(POPOVER_DISMISSED_FLAG) === "1";
@@ -70,6 +323,20 @@ function writePopoverDismissed() {
   } catch {
   }
 }
+function playerId() {
+  try {
+    const store = win()?.localStorage;
+    if (!store) return "no-storage";
+    let id = store.getItem(PLAYER_ID_KEY);
+    if (!id) {
+      id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+      store.setItem(PLAYER_ID_KEY, id);
+    }
+    return id;
+  } catch {
+    return "no-storage";
+  }
+}
 function initEmbed(cfg) {
   const w = win();
   if (!w) return;
@@ -81,11 +348,16 @@ function initEmbed(cfg) {
     dashboardOrigins: [...cfg.dashboardOrigins]
   };
   state = "pending";
-  if (wantsLocalTest(w)) {
+  if (wantsLocalTestMode(w)) {
     enterLocalTestMode(w);
     return;
   }
   showOverlay("connecting");
+  const entry = detectNativeEntry(w);
+  if (entry) {
+    startNativeHandshake(w, entry);
+    return;
+  }
   if (isEmbedded()) {
     startEmbeddedHandshake(w);
   } else {
@@ -329,6 +601,120 @@ async function handleParentMessage(event) {
   }
   await redeemTicket(data.ticket);
 }
+function nativeBridge(w) {
+  const candidate = w.ReactNativeWebView;
+  if (!candidate || typeof candidate !== "object") return null;
+  const post = candidate.postMessage;
+  return typeof post === "function" ? candidate : null;
+}
+function detectNativeEntry(w) {
+  if (isEmbedded()) return null;
+  let search;
+  try {
+    search = w.location.search ?? "";
+  } catch {
+    return null;
+  }
+  if (!hasNativeMarker(search)) return null;
+  if (!nativeBridge(w)) return null;
+  return readNativeEntry(search);
+}
+function inNativeMode() {
+  return nativeEntry !== null;
+}
+function postToNative(message) {
+  const w = win();
+  if (!w || !config || !nativeEntry) return;
+  const bridge = nativeBridge(w);
+  if (!bridge) return;
+  const encoded = encodeBridgeMessage({
+    channel: NATIVE_CHANNEL,
+    v: NATIVE_PROTOCOL_VERSION,
+    slug: config.slug,
+    attemptId: nativeEntry.attemptId,
+    nonce: nativeEntry.nonce,
+    ...message
+  });
+  if (!encoded) return;
+  try {
+    bridge.postMessage(encoded);
+  } catch {
+  }
+}
+function postNativeError(code) {
+  if (inNativeMode()) postToNative({ type: "error", code });
+}
+function startNativeHandshake(w, entry) {
+  nativeEntry = entry;
+  nativeBootAt = Date.now();
+  w[NATIVE_RECEIVER] = (payload) => {
+    void handleNativeCommand(payload);
+  };
+  const capabilities = ["native-ticket", "native-guest", "heartbeat"];
+  postToNative({ type: "ready", sdkVersion: SDK_VERSION, capabilities });
+  handshakeTimer = setTimeout(() => {
+    void requestGuestSession();
+  }, handshakeTimeoutMs);
+}
+async function handleNativeCommand(payload) {
+  if (!config || !nativeEntry) return;
+  const read2 = readBridgeNativeCommand(payload);
+  if (!read2.ok) return;
+  const command = read2.message;
+  if (command.slug !== config.slug || command.attemptId !== nativeEntry.attemptId || command.nonce !== nativeEntry.nonce) {
+    return;
+  }
+  switch (command.type) {
+    case "ticket":
+      if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+      await redeemTicket(command.ticket);
+      return;
+    case "guest":
+      if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+      await requestGuestSession();
+      return;
+    case "cancel":
+      stopNativeTimers();
+      return;
+    case "foreground":
+    case "network":
+      return;
+  }
+}
+function stopNativeTimers() {
+  if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+  handshakeTimer = void 0;
+  if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+  refreshTimer = void 0;
+  if (nativeReauthTimer !== void 0) clearTimeout(nativeReauthTimer);
+  nativeReauthTimer = void 0;
+  if (heartbeatTimer !== void 0) clearInterval(heartbeatTimer);
+  heartbeatTimer = void 0;
+}
+function startHeartbeat() {
+  if (!inNativeMode() || heartbeatTimer !== void 0) return;
+  heartbeatTimer = setInterval(() => {
+    postToNative({ type: "heartbeat", uptimeMs: Math.max(0, Date.now() - nativeBootAt) });
+  }, heartbeatIntervalMs);
+  heartbeatTimer.unref?.();
+}
+function requestNativeReauth() {
+  if (!inNativeMode() || nativeReauthPending) return;
+  nativeReauthPending = true;
+  postToNative({ type: "reauth-required" });
+  nativeReauthTimer = setTimeout(() => {
+    nativeReauthTimer = void 0;
+    if (!nativeReauthPending) return;
+    nativeReauthPending = false;
+    emit("error", { error: new Error("embed session expired") });
+    enterBlocked("session-expired");
+  }, nativeReauthTimeoutMs);
+}
+function clearNativeReauth() {
+  nativeReauthPending = false;
+  if (nativeReauthTimer !== void 0) clearTimeout(nativeReauthTimer);
+  nativeReauthTimer = void 0;
+}
 function postToParent(message, targetOrigin) {
   const w = win();
   if (!w || !isEmbedded()) return;
@@ -396,6 +782,7 @@ function readFragment(w) {
 }
 async function redirectToAuthorize(w, opts) {
   if (!config || localTestMode) return;
+  if (inNativeMode()) return;
   const origin = opts?.guestOk ? config.dashboardOrigins[0] ?? (await fetchDashboardOrigins())[0] : (await fetchDashboardOrigins())[0] ?? config.dashboardOrigins[0];
   if (!origin) {
     enterBlocked();
@@ -420,7 +807,9 @@ async function fetchDashboardOrigins() {
   return config.dashboardOrigins;
 }
 async function redeemTicket(ticket) {
-  if (!config || localTestMode || redeeming || state !== "pending" && state !== "guest") return;
+  if (!config || localTestMode || redeeming) return;
+  const reauthing = nativeReauthPending && state === "authenticated";
+  if (state !== "pending" && state !== "guest" && !reauthing) return;
   const upgradingFromGuest = state === "guest";
   const epoch = ++identityEpoch;
   redeeming = true;
@@ -449,6 +838,11 @@ async function redeemTicket(ticket) {
     if (isEmbedded() && parentOrigin) {
       postToParent({ type: "genex:embed:authenticated", v: PROTOCOL_VERSION }, parentOrigin);
     }
+    if (inNativeMode()) {
+      clearNativeReauth();
+      postToNative({ type: "authenticated", guest: false });
+      startHeartbeat();
+    }
     if (upgradingFromGuest) await flushGuestQueue();
     const ctx = { user };
     for (const waiter of authWaiters.splice(0)) waiter.resolve(ctx);
@@ -471,12 +865,16 @@ async function requestGuestSession() {
     const res = await doFetch(`${config.apiUrl}/api/embed/guest-session`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ slug: config.slug })
+      // playerId is analytics-only: the SERVER still mints the session's own
+      // guest id and the token is unchanged — this just lets the play event
+      // key on something that survives the tab.
+      body: JSON.stringify({ slug: config.slug, playerId: playerId() })
     });
     if (epoch !== identityEpoch) return;
     if (!res.ok) {
       emit("error", { error: new Error(`guest session failed (${res.status})`) });
-      enterBlocked();
+      postNativeError("guest-failed");
+      enterBlocked(res.status === 404 ? "not-available" : "no-identity");
       return;
     }
     const body = await res.json();
@@ -504,6 +902,9 @@ function enterGuest() {
       { type: "genex:embed:authenticated", v: PROTOCOL_VERSION, guest: true },
       parentOrigin ?? "*"
     );
+  } else if (inNativeMode()) {
+    postToNative({ type: "authenticated", guest: true });
+    startHeartbeat();
   } else if (firstEntry && !readPopoverDismissed()) {
     showGuestPopover();
   }
@@ -521,14 +922,26 @@ function isLoopbackLocation(w) {
     return false;
   }
 }
-function wantsLocalTest(w) {
+function wantsLocalTestMode(w) {
   if (isEmbedded()) return false;
+  if (detectNativeEntry(w)) return false;
   if (!isLoopbackLocation(w)) return false;
+  let params = null;
   try {
-    return new URLSearchParams(w.location.search).get("genex_local_test") === "1";
+    params = new URLSearchParams(w.location.search);
   } catch {
+  }
+  if (params?.get("genex_local_test") === "1") return true;
+  if (params?.get("genex_auth") === "1") {
+    writeLocalAuthFlag();
     return false;
   }
+  if (readLocalAuthFlag()) return false;
+  return !hasGenexFragment(w);
+}
+function hasGenexFragment(w) {
+  const hash = stashedTicketHash ?? w.location.hash;
+  return !!hash && hash.includes("genex_");
 }
 function enterLocalTestMode(w) {
   localTestMode = true;
@@ -548,6 +961,12 @@ function enterLocalTestMode(w) {
 }
 async function handleRedeemFailure() {
   const w = win();
+  if (inNativeMode()) {
+    clearNativeReauth();
+    postNativeError("ticket-rejected");
+    enterBlocked();
+    return;
+  }
   if (w && !isEmbedded() && !readRetryFlag()) {
     writeRetryFlag();
     showOverlay("redirecting");
@@ -593,8 +1012,12 @@ async function refreshToken() {
       void requestGuestSession();
       return;
     }
+    if (inNativeMode()) {
+      requestNativeReauth();
+      return;
+    }
     emit("error", { error: new Error("embed session expired") });
-    enterBlocked();
+    enterBlocked("session-expired");
     return;
   }
   if (refreshTimer !== void 0) clearTimeout(refreshTimer);
@@ -602,7 +1025,7 @@ async function refreshToken() {
     void refreshToken();
   }, refreshRetryMs);
 }
-function enterBlocked() {
+function enterBlocked(reason = "no-identity") {
   if (state === "blocked") return;
   identityEpoch++;
   state = "blocked";
@@ -611,7 +1034,14 @@ function enterBlocked() {
   if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
   if (refreshTimer !== void 0) clearTimeout(refreshTimer);
   removeGuestPopover();
-  showOverlay(isEmbedded() ? "blocked-embedded" : "blocked-standalone");
+  if (inNativeMode()) {
+    stopNativeTimers();
+    clearNativeReauth();
+    removeOverlay();
+    postToNative({ type: "blocked", reason });
+  } else {
+    showOverlay(isEmbedded() ? "blocked-embedded" : "blocked-standalone");
+  }
   if (isEmbedded()) {
     postToParent({ type: "genex:embed:blocked", v: PROTOCOL_VERSION }, parentOrigin ?? "*");
   }
@@ -926,6 +1356,11 @@ function __resetForTests(overrides) {
   if (refreshTimer !== void 0) clearTimeout(refreshTimer);
   handshakeTimer = void 0;
   refreshTimer = void 0;
+  stopNativeTimers();
+  if (w) delete w[NATIVE_RECEIVER];
+  nativeEntry = null;
+  nativeReauthPending = false;
+  nativeBootAt = 0;
   removeOverlay(true);
   removeGuestPopover();
   overlayFontRequested = false;
@@ -951,6 +1386,8 @@ function __resetForTests(overrides) {
   refreshDelayMs = overrides?.refreshDelayMs ?? 10 * 6e4;
   refreshRetryMs = overrides?.refreshRetryMs ?? 6e4;
   overlayTextDelayMs = overrides?.overlayTextDelayMs ?? 500;
+  nativeReauthTimeoutMs = overrides?.nativeReauthTimeoutMs ?? 3e4;
+  heartbeatIntervalMs = overrides?.heartbeatIntervalMs ?? 3e4;
 }
 
 export {

package/dist/index.d.ts

@@ -228,6 +228,8 @@ declare function __resetForTests(overrides?: {
     refreshDelayMs?: number;
     refreshRetryMs?: number;
     overlayTextDelayMs?: number;
+    nativeReauthTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
 }): void;
 
 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, getColyseusUrls, getEmbedToken, getLeaderboard, getUser, initEmbed, isEmbedded, loadPlayerState, loadWorldState, on, savePlayerState, saveWorldState, submitScore, waitForAuth, waitForPlayer };

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   submitScore,
   waitForAuth,
   waitForPlayer
-} from "./chunk-EEOKYBXG.js";
+} from "./chunk-5SVRR26C.js";
 export {
   __resetForTests,
   _stashTicketFromUrl,

package/dist/sentry.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/embed-sdk",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Player identity + durable game state for genex games \u2014 signed-in or guest play, per-player save slots, shared world state, and soft-trust leaderboards.",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,9 +40,11 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.0",
+    "@genex/embed-protocol": "workspace:*",
     "@sentry/browser": "^10.63.0",
     "publint": "^0.3.0",
-    "tsup": "^8.0.0"
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.0"
   },
   "repository": {
     "type": "git",