@genex-ai/embed-sdk 0.17.0 → 0.21.1

package/dist/chunk-Q476GJHI.js

@@ -0,0 +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 };
+}
+
+// ../embed-protocol/src/runtime-generation.ts
+function isGenerationId(value) {
+  return typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+}
+function isGenerationTerminal(status) {
+  return ["succeeded", "failed", "unknown", "canceled", "expired"].includes(status);
+}
+
+export {
+  NATIVE_CHANNEL,
+  NATIVE_PROTOCOL_VERSION,
+  NATIVE_RECEIVER,
+  readBridgeNativeCommand,
+  encodeBridgeMessage,
+  hasNativeMarker,
+  readNativeEntry,
+  isGenerationId,
+  isGenerationTerminal
+};

package/dist/development.d.ts

@@ -0,0 +1,44 @@
+import { RuntimeWorkflowInput, RuntimeGenerationView } from '@genex/embed-protocol';
+
+/** Server-only benchmarks spend the authenticated creator's own coin wallet. */
+
+interface DevelopmentGenerationConfig {
+    apiUrl: string;
+    /** Full creator bearer credential, kept only in your server or local script. */
+    creatorToken: string;
+    projectId: string;
+}
+interface DevelopmentGenerationOptions extends DevelopmentGenerationConfig {
+    /** Explicit maximum reservation in your own coins. Actual usage is charged. */
+    maxCoins: number;
+    request: {
+        modelId: string;
+        prompt: string;
+        outputFormat: 'text' | 'json';
+        schema?: Record<string, unknown>;
+        idempotencyKey?: string;
+    };
+    /** Waiting time only; timeout returns the last server view without canceling. */
+    timeoutMs?: number;
+}
+interface DevelopmentWorkflowOptions extends DevelopmentGenerationConfig {
+    workflowId: string;
+    maxCoins: number;
+    request: {
+        offeringId: string;
+        input: RuntimeWorkflowInput;
+        idempotencyKey?: string;
+    };
+}
+/** Create a generic benchmark and wait for execution and its actual-usage receipt. */
+declare function developmentGenerate(options: DevelopmentGenerationOptions): Promise<RuntimeGenerationView>;
+/** Returns the accepted workflow so its trusted executor can enqueue before waiting. */
+declare function developmentRequestWorkflow(options: DevelopmentWorkflowOptions): Promise<RuntimeGenerationView>;
+/** Recover a benchmark with the same creator and project; no play token is used. */
+declare function getDevelopmentGeneration(config: DevelopmentGenerationConfig, generationId: string): Promise<RuntimeGenerationView>;
+/** Acknowledges cancellation; the returned receipt determines the charge or remaining hold. */
+declare function cancelDevelopmentGeneration(config: DevelopmentGenerationConfig, generationId: string): Promise<RuntimeGenerationView>;
+/** Wait for execution and final billing; timeout preserves the latest pending receipt. */
+declare function waitForDevelopmentGeneration(config: DevelopmentGenerationConfig, generationId: string, timeoutMs?: number): Promise<RuntimeGenerationView>;
+
+export { type DevelopmentGenerationConfig, type DevelopmentGenerationOptions, type DevelopmentWorkflowOptions, cancelDevelopmentGeneration, developmentGenerate, developmentRequestWorkflow, getDevelopmentGeneration, waitForDevelopmentGeneration };

package/dist/development.js

@@ -0,0 +1,99 @@
+import {
+  isGenerationId,
+  isGenerationTerminal
+} from "./chunk-Q476GJHI.js";
+
+// src/development.ts
+function assertIdentifier(value) {
+  if (!/^[A-Za-z0-9_.:-]{1,120}$/.test(value) || value === "." || value === "..") throw new Error("invalid_development_identifier");
+}
+function baseUrl(config) {
+  if (typeof window !== "undefined") throw new Error("development_server_only");
+  assertIdentifier(config.projectId);
+  if (!config.creatorToken || /\s/.test(config.creatorToken)) throw new Error("creator_token_required");
+  const url = new URL(config.apiUrl);
+  if (url.username || url.password || url.search || url.hash || url.pathname !== "/" || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+    throw new Error("invalid_api_url");
+  }
+  return url.origin + "/api/runtime/development/projects/" + encodeURIComponent(config.projectId);
+}
+function validateMaximum(maxCoins) {
+  if (!Number.isSafeInteger(maxCoins) || maxCoins <= 0 || maxCoins > 1e6) throw new Error("invalid_max_coins");
+}
+async function request(config, path, body) {
+  const response = await fetch(baseUrl(config) + path, {
+    method: body === void 0 ? "GET" : "POST",
+    credentials: "omit",
+    cache: "no-store",
+    redirect: "error",
+    headers: { Authorization: "Bearer " + config.creatorToken, ...body === void 0 ? {} : { "Content-Type": "application/json" } },
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  });
+  const result = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(typeof result.error === "string" ? result.error : "development_generation_unavailable");
+  const view = result;
+  if (!isGenerationId(view.id) || view.projectId !== config.projectId || view.development !== true || view.quote?.billingPolicy !== "consumed-v1" || view.funding !== "coins") throw new Error("invalid_development_response");
+  return view;
+}
+async function developmentGenerate(options) {
+  validateMaximum(options.maxCoins);
+  if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) throw new Error("invalid_timeout");
+  const input = options.request;
+  const view = await request(options, "/generations", { maxCoins: options.maxCoins, request: {
+    modelId: input.modelId,
+    prompt: input.prompt,
+    outputFormat: input.outputFormat,
+    ...input.schema === void 0 ? {} : { schema: input.schema },
+    idempotencyKey: input.idempotencyKey ?? crypto.randomUUID()
+  } });
+  return wait(options, view, options.timeoutMs ?? 6e5);
+}
+async function developmentRequestWorkflow(options) {
+  validateMaximum(options.maxCoins);
+  assertIdentifier(options.workflowId);
+  assertIdentifier(options.request.offeringId);
+  const view = await request(options, "/workflows/" + encodeURIComponent(options.workflowId) + "/requests", {
+    maxCoins: options.maxCoins,
+    request: {
+      offeringId: options.request.offeringId,
+      input: options.request.input,
+      idempotencyKey: options.request.idempotencyKey ?? crypto.randomUUID()
+    }
+  });
+  if (view.kind !== "workflow" || view.workflow?.id !== options.workflowId || view.workflow.offeringId !== options.request.offeringId) {
+    throw new Error("invalid_development_response");
+  }
+  return view;
+}
+async function getDevelopmentGeneration(config, generationId) {
+  if (!isGenerationId(generationId)) throw new Error("invalid_generation_id");
+  const view = await request(config, "/generations/" + encodeURIComponent(generationId));
+  if (view.id !== generationId) throw new Error("invalid_development_response");
+  return view;
+}
+async function cancelDevelopmentGeneration(config, generationId) {
+  if (!isGenerationId(generationId)) throw new Error("invalid_generation_id");
+  const view = await request(config, "/generations/" + encodeURIComponent(generationId) + "/cancel", {});
+  if (view.id !== generationId) throw new Error("invalid_development_response");
+  return view;
+}
+async function wait(config, initial, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) throw new Error("invalid_timeout");
+  const deadline = Date.now() + timeoutMs;
+  let view = initial;
+  while (!(isGenerationTerminal(view.status) && view.billingStatus === "final") && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, Math.min(750, deadline - Date.now())));
+    view = await getDevelopmentGeneration(config, view.id);
+  }
+  return view;
+}
+async function waitForDevelopmentGeneration(config, generationId, timeoutMs = 6e5) {
+  return wait(config, await getDevelopmentGeneration(config, generationId), timeoutMs);
+}
+export {
+  cancelDevelopmentGeneration,
+  developmentGenerate,
+  developmentRequestWorkflow,
+  getDevelopmentGeneration,
+  waitForDevelopmentGeneration
+};

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+import { RuntimeWorkflowInput, RuntimeGenerationBilling, RuntimeGenerationFunding, RuntimeGenerationView, RuntimeGenerationModels, RuntimeWorkflowOfferings } from '@genex/embed-protocol';
+export { RuntimeBillingPolicy, RuntimeExternalProvider, RuntimeGenerationBilling, RuntimeGenerationFunding, RuntimeGenerationModels, RuntimeGenerationStatus, RuntimeGenerationView, RuntimeWorkflowInput, RuntimeWorkflowOfferings } from '@genex/embed-protocol';
+
 /** A thing the game sells. Resolved server-side; the game never sets a price. */
 interface ShopItem {
     id: string;
@@ -118,6 +121,75 @@ declare function buy(opts: {
     timeoutMs?: number;
 }): Promise<PurchaseResult>;
 
+interface GenerateOptions {
+    /** Fixed coin price of a started attempt. Zero is accepted only for server-authorized free options. */
+    estimateCoins: number;
+    modelId: string;
+    prompt: string;
+    outputFormat: 'text' | 'json';
+    schema?: Record<string, unknown>;
+    /** Allow player-supplied results through their own configured Claude or ChatGPT account. Defaults off. */
+    allowExternal?: boolean;
+    /** Reuse for retries of the same operation, including after a game reload. */
+    idempotencyKey?: string;
+    /** Waiting time only. Reaching it does not cancel an accepted generation. */
+    timeoutMs?: number;
+}
+interface RuntimeGenerationResult extends RuntimeGenerationBilling {
+    status: 'succeeded' | 'failed' | 'unknown' | 'canceled' | 'expired' | 'pending';
+    generationId?: string;
+    output?: unknown;
+    /** External output is user-supplied; never use it as authority for rewards or money. */
+    source?: 'openrouter' | 'external';
+    modelProvenance?: 'unverified';
+    error?: string;
+}
+interface RequestWorkflowOptions {
+    /** Fixed coin price of a started attempt, including failed or canceled work. */
+    estimateCoins: number;
+    /** Offer configured personal Claude/ChatGPT funding on the same quote. Defaults off. */
+    allowExternal?: boolean;
+    workflowId: string;
+    offeringId: string;
+    input: RuntimeWorkflowInput;
+    /** Reuse for the exact same operation after sign-in, cancellation or reload. */
+    idempotencyKey?: string;
+    /** Approval waiting time only. A timeout does not cancel an accepted request. */
+    timeoutMs?: number;
+}
+interface RuntimeWorkflowAuthorization extends RuntimeGenerationBilling {
+    status: 'authorized' | 'canceled' | 'expired' | 'failed' | 'pending';
+    generationId?: string;
+    funding?: RuntimeGenerationFunding;
+    error?: string;
+}
+/** Available models and pricing; the confirmation always uses a fresh server quote. */
+declare function getGenerationModels(): Promise<RuntimeGenerationModels>;
+/** Server-owned estimates, reservation maxima and availability. Confirmation seals the quote. */
+declare function getWorkflowOfferings(workflowId: string): Promise<RuntimeWorkflowOfferings>;
+/** Recover an operation by ID after a reload. Scoped to this player AND this game. */
+declare function getGeneration(generationId: string): Promise<RuntimeGenerationView>;
+/** Resume waiting for execution. A terminal result can still carry pending billing; read getGeneration() for settlement. */
+declare function waitForGeneration(generationId: string, timeoutMs?: number): Promise<RuntimeGenerationResult>;
+/**
+ * Call directly from a click handler. The trusted popup is reserved BEFORE any
+ * asynchronous work, so standalone games retain the browser's user gesture.
+ * The player approves on Genex. Cancellation resolves normally; only API state
+ * can return an output. Store generationId to recover a pending result on boot.
+ */
+declare function generate(options: GenerateOptions): Promise<RuntimeGenerationResult>;
+/**
+ * Call directly from the player's click, before awaiting anything. Returns when
+ * Genex authorizes the entire workflow, so the game can enqueue its executor.
+ * Personal-provider instructions stay open after authorization. Store the ID;
+ * getGeneration()/waitForGeneration() recover the eventual result without a new charge.
+ */
+declare function requestWorkflow(options: RequestWorkflowOptions): Promise<RuntimeWorkflowAuthorization>;
+/** Reopen a saved approval without repricing or submitting a new request. Call directly from a click. */
+declare function resumeWorkflow(generationId: string, options?: {
+    timeoutMs?: number;
+}): Promise<RuntimeWorkflowAuthorization>;
+
 interface EmbedConfig {
     /** This game's own slug (GENEX.slug) — identifies the project to /play/authorize. */
     slug: string;
@@ -357,4 +429,4 @@ declare function __resetForTests(overrides?: {
     heartbeatIntervalMs?: number;
 }): void;
 
-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 };
+export { type AuthState, type EmbedConfig, type EmbedEvent, type EmbedUser, type Entitlement, type GenerateOptions, type Leaderboard, type LeaderboardEntry, type PlayerStateResult, type PurchaseResult, type PurchaseStatus, type RequestWorkflowOptions, type RuntimeGenerationResult, type RuntimeWorkflowAuthorization, type SaveStateResult, type ShopItem, type SubmitScoreResult, type WorldStateResult, __resetForTests, _stashTicketFromUrl, buy, consumeEntitlement, generate, getAuthState, getColyseusAuth, getColyseusUrls, getEmbedToken, getEntitlements, getGeneration, getGenerationModels, getLeaderboard, getShop, getUser, getWorkflowOfferings, initEmbed, isEmbedded, loadPlayerState, loadWorldState, on, requestWorkflow, resumeWorkflow, savePlayerState, saveWorldState, submitScore, waitForAuth, waitForGeneration, waitForPlayer };

package/dist/index.js

@@ -3,46 +3,61 @@ import {
   _stashTicketFromUrl,
   buy,
   consumeEntitlement,
+  generate,
   getAuthState,
   getColyseusAuth,
   getColyseusUrls,
   getEmbedToken,
   getEntitlements,
+  getGeneration,
+  getGenerationModels,
   getLeaderboard,
   getShop,
   getUser,
+  getWorkflowOfferings,
   initEmbed,
   isEmbedded,
   loadPlayerState,
   loadWorldState,
   on,
+  requestWorkflow,
+  resumeWorkflow,
   savePlayerState,
   saveWorldState,
   submitScore,
   waitForAuth,
+  waitForGeneration,
   waitForPlayer
-} from "./chunk-DNLXNEPL.js";
+} from "./chunk-CKFZQ7AP.js";
+import "./chunk-Q476GJHI.js";
 export {
   __resetForTests,
   _stashTicketFromUrl,
   buy,
   consumeEntitlement,
+  generate,
   getAuthState,
   getColyseusAuth,
   getColyseusUrls,
   getEmbedToken,
   getEntitlements,
+  getGeneration,
+  getGenerationModels,
   getLeaderboard,
   getShop,
   getUser,
+  getWorkflowOfferings,
   initEmbed,
   isEmbedded,
   loadPlayerState,
   loadWorldState,
   on,
+  requestWorkflow,
+  resumeWorkflow,
   savePlayerState,
   saveWorldState,
   submitScore,
   waitForAuth,
+  waitForGeneration,
   waitForPlayer
 };

package/dist/sentry.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genex-ai/embed-sdk",
-  "version": "0.17.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.",
+  "version": "0.21.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",
@@ -15,6 +15,12 @@
       "@genex-ai/source": "./src/sentry.ts",
       "types": "./dist/sentry.d.ts",
       "import": "./dist/sentry.js"
+    },
+    "./development": {
+      "types": "./dist/development.d.ts",
+      "browser": null,
+      "@genex-ai/source": "./src/development.ts",
+      "import": "./dist/development.js"
     }
   },
   "files": [