@genex-ai/embed-sdk 0.14.0 → 0.15.0

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

@@ -1,3 +1,110 @@
+// src/commerce.ts
+var cfg = null;
+function _initCommerce(c) {
+  cfg = c;
+}
+function must() {
+  if (!cfg) throw new Error("genex commerce: call initEmbed() first");
+  return cfg;
+}
+function authHeaders() {
+  const token = must().getToken();
+  if (!token) throw new Error("genex commerce: no player session");
+  return { Authorization: `Bearer ${token}` };
+}
+async function getShop() {
+  const c = must();
+  if (c.isLocalTest()) return [];
+  const res = await fetch(`${c.apiUrl}/api/coin/catalog`, { headers: authHeaders() });
+  if (!res.ok) throw new Error(`genex shop failed (${res.status})`);
+  return (await res.json()).items;
+}
+async function getEntitlements(opts) {
+  const c = must();
+  if (c.isLocalTest()) return [];
+  const qs = opts?.excludeConsumed ? "?excludeConsumed=true" : "";
+  const res = await fetch(`${c.apiUrl}/api/coin/entitlements${qs}`, { headers: authHeaders() });
+  if (!res.ok) throw new Error(`genex entitlements failed (${res.status})`);
+  return (await res.json()).items;
+}
+async function consumeEntitlement(entitlementId) {
+  const c = must();
+  if (c.isLocalTest()) return { consumed: true, alreadyConsumed: false };
+  const res = await fetch(
+    `${c.apiUrl}/api/coin/entitlements/${encodeURIComponent(entitlementId)}/consume`,
+    { method: "POST", headers: authHeaders() }
+  );
+  if (!res.ok) throw new Error(`genex consume failed (${res.status})`);
+  return await res.json();
+}
+async function awaitOutcome(intentId, timeoutMs) {
+  const c = must();
+  const deadline = Date.now() + timeoutMs;
+  let delay = 400;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, delay));
+    delay = Math.min(delay * 1.4, 2e3);
+    const res = await fetch(`${c.apiUrl}/api/coin/intents/${encodeURIComponent(intentId)}`, {
+      headers: authHeaders()
+    }).catch(() => null);
+    if (!res || !res.ok) continue;
+    const view = await res.json();
+    switch (view.status) {
+      case "succeeded":
+      case "consumed":
+        return { status: "succeeded" };
+      case "canceled":
+        return { status: "canceled" };
+      case "expired":
+        return { status: "expired" };
+      case "failed":
+        return { status: "failed", message: "the purchase could not be completed" };
+      default:
+        break;
+    }
+  }
+  return { status: "expired" };
+}
+function openConfirmSurface(view) {
+  const c = must();
+  const w = typeof window === "undefined" ? null : window;
+  if (!w) return { ok: false, reason: "no_window" };
+  if (c.isNative()) return { ok: false, reason: "native_unsupported" };
+  if (c.isEmbedded() && w.parent) {
+    for (const origin of c.dashboardOrigins) {
+      try {
+        w.parent.postMessage({ type: "genex:commerce:confirm", v: 1, intentId: view.id }, origin);
+      } catch {
+      }
+    }
+    return { ok: true };
+  }
+  const popup = w.open(view.confirmUrl, `genex_confirm_${view.id}`, "popup,width=420,height=640");
+  return popup === null ? { ok: false, reason: "popup_blocked" } : { ok: true };
+}
+async function buy(opts) {
+  const c = must();
+  if (c.isLocalTest()) {
+    return { status: "failed", message: "purchases are unavailable in local test mode" };
+  }
+  const created = await fetch(`${c.apiUrl}/api/coin/intents`, {
+    method: "POST",
+    headers: { ...authHeaders(), "Content-Type": "application/json" },
+    body: JSON.stringify({ skuId: opts.skuId, quantity: opts.quantity ?? 1 })
+  });
+  if (!created.ok) {
+    const body = await created.json().catch(() => ({}));
+    return { status: "failed", message: body.error ?? `intent failed (${created.status})` };
+  }
+  const view = await created.json();
+  const opened = openConfirmSurface(view);
+  if (!opened.ok) {
+    const message = opened.reason === "popup_blocked" ? "the confirmation window was blocked \u2014 tap again to confirm" : opened.reason === "native_unsupported" ? "purchases are not available in the app yet" : "the confirmation window could not be opened";
+    return { status: "failed", message };
+  }
+  return awaitOutcome(view.id, opts.timeoutMs ?? 18e4);
+}
+
 // ../embed-protocol/src/constants.ts
 var NATIVE_CHANNEL = "genex-native";
 var NATIVE_PROTOCOL_VERSION = 1;
@@ -234,7 +341,7 @@ 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 SDK_VERSION = "0.15.0";
 var config = null;
 var state = "pending";
 var user = null;
@@ -337,17 +444,25 @@ function playerId() {
     return "no-storage";
   }
 }
-function initEmbed(cfg) {
+function initEmbed(cfg2) {
   const w = win();
   if (!w) return;
   if (initialized) return;
   initialized = true;
   config = {
-    slug: cfg.slug,
-    apiUrl: cfg.apiUrl.replace(/\/$/, ""),
-    dashboardOrigins: [...cfg.dashboardOrigins]
+    slug: cfg2.slug,
+    apiUrl: cfg2.apiUrl.replace(/\/$/, ""),
+    dashboardOrigins: [...cfg2.dashboardOrigins]
   };
   state = "pending";
+  _initCommerce({
+    apiUrl: config.apiUrl,
+    dashboardOrigins: config.dashboardOrigins,
+    getToken: () => embedToken,
+    isEmbedded,
+    isNative: inNativeMode,
+    isLocalTest: () => localTestMode
+  });
   if (wantsLocalTestMode(w)) {
     enterLocalTestMode(w);
     return;
@@ -1391,6 +1506,10 @@ function __resetForTests(overrides) {
 }
 
 export {
+  getShop,
+  getEntitlements,
+  consumeEntitlement,
+  buy,
   initEmbed,
   isEmbedded,
   getAuthState,

package/dist/index.d.ts

@@ -1,3 +1,110 @@
+/** A thing the game sells. Resolved server-side; the game never sets a price. */
+interface ShopItem {
+    id: string;
+    /** 'consumable' — spent on use. 'durable' — owned permanently. */
+    type: string;
+    name: string;
+    iconUrl: string | null;
+    priceCoins: number;
+    /**
+     * The real-money equivalent, in USD cents, from the server.
+     *
+     * Show it next to the coin price. It is not decoration: a currency price
+     * without its real-world value is the practice consumer regulators single
+     * out first, and the platform sends this so a game never has to compute it —
+     * or be tempted to omit it.
+     */
+    priceDisplayUsdCents: number;
+}
+interface Entitlement {
+    id: string;
+    skuId: string;
+    name: string;
+    type: string;
+    quantity: number;
+    consumed: boolean;
+    createdAt: string;
+}
+type PurchaseStatus = 
+/** Settled. The item is owned; consume it, then apply the effect. */
+'succeeded'
+/** The player closed or declined the confirmation. Not an error — say nothing. */
+ | 'canceled'
+/** The confirmation was never completed in time. */
+ | 'expired'
+/** The player does not have enough coin. */
+ | 'insufficient_balance'
+/** Something went wrong. `message` says what, for a log — not for the player. */
+ | 'failed';
+interface PurchaseResult {
+    status: PurchaseStatus;
+    /** Present only on 'succeeded'. */
+    entitlementId?: string;
+    message?: string;
+}
+/**
+ * The items this game sells.
+ *
+ * Render `name`, `iconUrl`, `priceCoins` AND `priceDisplayUsdCents` from here.
+ * Do not hardcode a price in the game: the server charges what its own catalog
+ * says, so a hardcoded one is a number that can silently disagree with what the
+ * player is actually charged.
+ */
+declare function getShop(): Promise<ShopItem[]>;
+/**
+ * Everything this player owns in this game.
+ *
+ * Call it on EVERY boot with `{ excludeConsumed: true }` and deliver whatever
+ * comes back. That is not an optimisation — it is how a purchase survives a
+ * crash between paying and receiving.
+ */
+declare function getEntitlements(opts?: {
+    excludeConsumed?: boolean;
+}): Promise<Entitlement[]>;
+/**
+ * Mark an entitlement used, then apply its effect.
+ *
+ * That order matters and is worth stating plainly: consume FIRST, apply SECOND.
+ * If the game dies in between, the player loses one item — a support ticket. If
+ * you apply first and die before consuming, every boot re-delivers it forever —
+ * an exploit.
+ *
+ * Idempotent. `alreadyConsumed: true` means someone else got there first and
+ * you must NOT apply the effect again.
+ */
+declare function consumeEntitlement(entitlementId: string): Promise<{
+    consumed: boolean;
+    alreadyConsumed: boolean;
+}>;
+/**
+ * Buy something.
+ *
+ * **Call this synchronously from a real click or tap handler.** On a game's own
+ * origin the confirmation is a popup, and browsers only allow one while a user
+ * gesture is live — an `await` before this call loses that gesture and the
+ * purchase cannot open.
+ *
+ * Resolves once the SERVER says what happened. A closed window proves nothing:
+ * this waits for the ledger, not for the UI.
+ *
+ * ```ts
+ * button.addEventListener('click', async () => {
+ *   const result = await buy({ skuId: 'sku_potion' });
+ *   if (result.status !== 'succeeded') return;         // canceled is normal
+ *   for (const e of await getEntitlements({ excludeConsumed: true })) {
+ *     const { alreadyConsumed } = await consumeEntitlement(e.id);
+ *     if (!alreadyConsumed) grantPotion();             // consume, THEN apply
+ *   }
+ * });
+ * ```
+ */
+declare function buy(opts: {
+    skuId: string;
+    quantity?: number;
+    /** How long to wait for the player to decide. Default 3 minutes. */
+    timeoutMs?: number;
+}): Promise<PurchaseResult>;
+
 interface EmbedConfig {
     /** This game's own slug (GENEX.slug) — identifies the project to /play/authorize. */
     slug: string;
@@ -232,4 +339,4 @@ declare function __resetForTests(overrides?: {
     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 };
+export { type AuthState, type EmbedConfig, type EmbedEvent, type EmbedUser, type Entitlement, type Leaderboard, type LeaderboardEntry, type PlayerStateResult, type PurchaseResult, type PurchaseStatus, type SaveStateResult, type ShopItem, type SubmitScoreResult, type WorldStateResult, __resetForTests, _stashTicketFromUrl, buy, consumeEntitlement, getAuthState, getColyseusAuth, getColyseusUrls, getEmbedToken, getEntitlements, getLeaderboard, getShop, getUser, initEmbed, isEmbedded, loadPlayerState, loadWorldState, on, savePlayerState, saveWorldState, submitScore, waitForAuth, waitForPlayer };

package/dist/index.js

@@ -1,11 +1,15 @@
 import {
   __resetForTests,
   _stashTicketFromUrl,
+  buy,
+  consumeEntitlement,
   getAuthState,
   getColyseusAuth,
   getColyseusUrls,
   getEmbedToken,
+  getEntitlements,
   getLeaderboard,
+  getShop,
   getUser,
   initEmbed,
   isEmbedded,
@@ -17,15 +21,19 @@ import {
   submitScore,
   waitForAuth,
   waitForPlayer
-} from "./chunk-5SVRR26C.js";
+} from "./chunk-DWDBRKRS.js";
 export {
   __resetForTests,
   _stashTicketFromUrl,
+  buy,
+  consumeEntitlement,
   getAuthState,
   getColyseusAuth,
   getColyseusUrls,
   getEmbedToken,
+  getEntitlements,
   getLeaderboard,
+  getShop,
   getUser,
   initEmbed,
   isEmbedded,

package/dist/sentry.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/embed-sdk",
-  "version": "0.14.0",
+  "version": "0.15.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",