@genex-ai/embed-sdk 0.2.0

package/dist/chunk-KXUDNW6P.js

@@ -0,0 +1,397 @@
+// src/index.ts
+var PROTOCOL_VERSION = 1;
+var RETRY_FLAG = "genex:embed:retry";
+var config = null;
+var state = "pending";
+var user = null;
+var embedToken;
+var colyseusUrl;
+var parentOrigin = null;
+var initialized = false;
+var redeeming = false;
+var handshakeTimeoutMs = 1e4;
+var refreshDelayMs = 10 * 6e4;
+var refreshRetryMs = 6e4;
+var handshakeTimer;
+var refreshTimer;
+var messageHandler;
+var listeners = /* @__PURE__ */ new Map();
+var authWaiters = [];
+var overlayEl = null;
+function win() {
+  return globalThis.window;
+}
+function doc() {
+  return globalThis.document;
+}
+function doFetch(input, init) {
+  return globalThis.fetch(input, init);
+}
+function readRetryFlag() {
+  try {
+    return win()?.sessionStorage?.getItem(RETRY_FLAG) === "1";
+  } catch {
+    return false;
+  }
+}
+function writeRetryFlag() {
+  try {
+    win()?.sessionStorage?.setItem(RETRY_FLAG, "1");
+  } catch {
+  }
+}
+function clearRetryFlag() {
+  try {
+    win()?.sessionStorage?.removeItem(RETRY_FLAG);
+  } catch {
+  }
+}
+function initEmbed(cfg) {
+  const w = win();
+  if (!w) return;
+  if (initialized) return;
+  initialized = true;
+  config = {
+    slug: cfg.slug,
+    apiUrl: cfg.apiUrl.replace(/\/$/, ""),
+    dashboardOrigins: [...cfg.dashboardOrigins]
+  };
+  state = "pending";
+  showOverlay("connecting");
+  if (isEmbedded()) {
+    startEmbeddedHandshake(w);
+  } else {
+    void startStandaloneFlow(w);
+  }
+}
+function isEmbedded() {
+  const w = win();
+  if (!w) return false;
+  try {
+    return w.self !== w.top;
+  } catch {
+    return true;
+  }
+}
+function getAuthState() {
+  return state;
+}
+function getUser() {
+  return user;
+}
+function getEmbedToken() {
+  return embedToken;
+}
+function getColyseusAuth() {
+  return embedToken ? { embedToken } : void 0;
+}
+function waitForAuth() {
+  if (state === "authenticated" && user) return Promise.resolve({ user });
+  if (state === "blocked") return Promise.reject(new Error("genex embed auth: blocked"));
+  return new Promise((resolve, reject) => {
+    authWaiters.push({ resolve, reject });
+  });
+}
+function on(event, cb) {
+  let set = listeners.get(event);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    listeners.set(event, set);
+  }
+  set.add(cb);
+  return () => {
+    set.delete(cb);
+  };
+}
+function emit(event, ctx) {
+  const set = listeners.get(event);
+  if (!set) return;
+  for (const cb of [...set]) {
+    try {
+      cb(ctx);
+    } catch {
+    }
+  }
+}
+function startEmbeddedHandshake(w) {
+  messageHandler = (event) => {
+    void handleParentMessage(event);
+  };
+  w.addEventListener("message", messageHandler);
+  w.parent.postMessage({ type: "genex:embed:ready", v: PROTOCOL_VERSION }, "*");
+  handshakeTimer = setTimeout(() => {
+    enterBlocked();
+  }, handshakeTimeoutMs);
+}
+async function handleParentMessage(event) {
+  if (!config || state !== "pending" || redeeming) return;
+  const data = event.data;
+  if (!data || data.type !== "genex:embed:ticket" || data.v !== PROTOCOL_VERSION) return;
+  if (typeof data.ticket !== "string" || !data.ticket) return;
+  if (!config.dashboardOrigins.includes(event.origin)) {
+    const fresh = await fetchDashboardOrigins();
+    if (state !== "pending" || redeeming) return;
+    if (!fresh.includes(event.origin)) return;
+  }
+  if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+  parentOrigin = event.origin;
+  await redeemTicket(data.ticket);
+}
+function postToParent(message, targetOrigin) {
+  const w = win();
+  if (!w || !isEmbedded()) return;
+  try {
+    w.parent.postMessage(message, targetOrigin);
+  } catch {
+  }
+}
+async function startStandaloneFlow(w) {
+  const ticket = readTicketFromFragment(w);
+  if (ticket) {
+    try {
+      w.history.replaceState(null, "", w.location.pathname + w.location.search);
+    } catch {
+    }
+    await redeemTicket(ticket);
+    return;
+  }
+  showOverlay("redirecting");
+  await redirectToAuthorize(w);
+}
+var stashedTicketHash = null;
+function _stashTicketFromUrl() {
+  const w = win();
+  if (!w) return;
+  const hash = w.location.hash;
+  if (!hash || !hash.includes("genex_ticket")) return;
+  stashedTicketHash = hash;
+  try {
+    w.history.replaceState(null, "", w.location.pathname + w.location.search);
+  } catch {
+  }
+}
+function readTicketFromFragment(w) {
+  const hash = stashedTicketHash ?? w.location.hash;
+  stashedTicketHash = null;
+  if (!hash || hash.length < 2) return null;
+  try {
+    return new URLSearchParams(hash.slice(1)).get("genex_ticket");
+  } catch {
+    return null;
+  }
+}
+async function redirectToAuthorize(w) {
+  if (!config) return;
+  const origins = await fetchDashboardOrigins();
+  const origin = origins[0] ?? config.dashboardOrigins[0];
+  if (!origin) {
+    enterBlocked();
+    return;
+  }
+  const returnTo = w.location.origin + w.location.pathname;
+  const url = `${origin}/play/authorize?returnTo=${encodeURIComponent(returnTo)}&slug=${encodeURIComponent(config.slug)}`;
+  w.location.replace(url);
+}
+async function fetchDashboardOrigins() {
+  if (!config) return [];
+  try {
+    const res = await doFetch(`${config.apiUrl}/api/embed/dashboard-origins`);
+    if (!res.ok) return config.dashboardOrigins;
+    const body = await res.json();
+    if (Array.isArray(body.origins) && body.origins.every((o) => typeof o === "string")) {
+      return body.origins;
+    }
+  } catch {
+  }
+  return config.dashboardOrigins;
+}
+async function redeemTicket(ticket) {
+  if (!config || redeeming || state !== "pending") return;
+  redeeming = true;
+  try {
+    const res = await doFetch(`${config.apiUrl}/api/embed/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ticket })
+    });
+    if (!res.ok) {
+      emit("error", { error: new Error(`ticket redemption failed (${res.status})`) });
+      await handleRedeemFailure();
+      return;
+    }
+    const body = await res.json();
+    embedToken = body.embedToken;
+    user = body.user;
+    colyseusUrl = body.colyseus?.url;
+    void colyseusUrl;
+    state = "authenticated";
+    clearRetryFlag();
+    removeOverlay();
+    scheduleRefresh();
+    if (isEmbedded() && parentOrigin) {
+      postToParent({ type: "genex:embed:authenticated", v: PROTOCOL_VERSION }, parentOrigin);
+    }
+    const ctx = { user };
+    for (const waiter of authWaiters.splice(0)) waiter.resolve(ctx);
+    emit("authenticated", ctx);
+  } catch (error) {
+    emit("error", { error });
+    await handleRedeemFailure();
+  } finally {
+    redeeming = false;
+  }
+}
+async function handleRedeemFailure() {
+  const w = win();
+  if (w && !isEmbedded() && !readRetryFlag()) {
+    writeRetryFlag();
+    showOverlay("redirecting");
+    await redirectToAuthorize(w);
+    return;
+  }
+  enterBlocked();
+}
+function scheduleRefresh() {
+  if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+  refreshTimer = setTimeout(() => {
+    void refreshToken();
+  }, refreshDelayMs);
+}
+async function refreshToken() {
+  if (!config || state !== "authenticated" || !embedToken) return;
+  let status;
+  try {
+    const res = await doFetch(`${config.apiUrl}/api/embed/session/refresh`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${embedToken}` },
+      // Best-effort completion if the tab starts unloading mid-refresh; zero
+      // security consequence either way (worst case the token just expires).
+      keepalive: true
+    });
+    status = res.status;
+    if (res.ok) {
+      const body = await res.json();
+      embedToken = body.embedToken;
+      scheduleRefresh();
+      return;
+    }
+  } catch {
+    status = void 0;
+  }
+  if (status === 401) {
+    emit("error", { error: new Error("embed session expired") });
+    enterBlocked();
+    return;
+  }
+  if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+  refreshTimer = setTimeout(() => {
+    void refreshToken();
+  }, refreshRetryMs);
+}
+function enterBlocked() {
+  if (state === "blocked") return;
+  state = "blocked";
+  user = null;
+  embedToken = void 0;
+  if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+  if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+  showOverlay(isEmbedded() ? "blocked-embedded" : "blocked-standalone");
+  if (isEmbedded()) {
+    postToParent({ type: "genex:embed:blocked", v: PROTOCOL_VERSION }, parentOrigin ?? "*");
+  }
+  const err = new Error("genex embed auth: blocked");
+  for (const waiter of authWaiters.splice(0)) waiter.reject(err);
+  emit("blocked");
+}
+var OVERLAY_TEXT = {
+  connecting: { title: "Connecting to Genex\u2026" },
+  redirecting: { title: "Signing you in\u2026" },
+  "blocked-standalone": { title: "Sign in to play", button: "Sign in" },
+  "blocked-embedded": { title: "Sign in on the Genex dashboard to continue" }
+};
+function showOverlay(kind) {
+  const d = doc();
+  if (!d?.createElement) return;
+  try {
+    if (!overlayEl) overlayEl = buildOverlay(d);
+    overlayEl.setContent(kind);
+  } catch {
+  }
+}
+function removeOverlay() {
+  try {
+    const root = overlayEl?.root;
+    root?.remove?.();
+  } catch {
+  }
+  overlayEl = null;
+}
+function buildOverlay(d) {
+  const root = d.createElement("div");
+  root.setAttribute("data-genex-embed-overlay", "");
+  root.style.cssText = "position:fixed;inset:0;z-index:2147483647;display:flex;align-items:center;justify-content:center;flex-direction:column;gap:16px;background:rgba(8,10,20,0.92);color:#fff;font-family:system-ui,-apple-system,sans-serif;text-align:center;pointer-events:auto;user-select:none";
+  const title = d.createElement("div");
+  title.style.cssText = "font-size:18px;font-weight:600;padding:0 24px";
+  root.appendChild(title);
+  const button = d.createElement("button");
+  button.style.cssText = "font-size:15px;font-weight:600;padding:10px 28px;border-radius:8px;border:none;cursor:pointer;background:#fff;color:#111;display:none";
+  button.addEventListener("click", () => {
+    const w = win();
+    if (!w) return;
+    button.disabled = true;
+    clearRetryFlag();
+    void redirectToAuthorize(w);
+  });
+  root.appendChild(button);
+  const mount = () => {
+    if (d.body && !root.isConnected) d.body.appendChild(root);
+  };
+  if (d.body) mount();
+  else d.addEventListener?.("DOMContentLoaded", mount);
+  return {
+    root,
+    setContent(kind) {
+      const text = OVERLAY_TEXT[kind];
+      title.textContent = text.title;
+      button.style.display = text.button ? "inline-block" : "none";
+      if (text.button) button.textContent = text.button;
+      mount();
+    }
+  };
+}
+function __resetForTests(overrides) {
+  const w = win();
+  if (w && messageHandler) w.removeEventListener("message", messageHandler);
+  messageHandler = void 0;
+  if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
+  if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+  handshakeTimer = void 0;
+  refreshTimer = void 0;
+  removeOverlay();
+  config = null;
+  state = "pending";
+  user = null;
+  embedToken = void 0;
+  colyseusUrl = void 0;
+  parentOrigin = null;
+  initialized = false;
+  redeeming = false;
+  listeners.clear();
+  authWaiters = [];
+  handshakeTimeoutMs = overrides?.handshakeTimeoutMs ?? 1e4;
+  refreshDelayMs = overrides?.refreshDelayMs ?? 10 * 6e4;
+  refreshRetryMs = overrides?.refreshRetryMs ?? 6e4;
+}
+
+export {
+  initEmbed,
+  isEmbedded,
+  getAuthState,
+  getUser,
+  getEmbedToken,
+  getColyseusAuth,
+  waitForAuth,
+  on,
+  _stashTicketFromUrl,
+  __resetForTests
+};

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+interface EmbedConfig {
+    /** This game's own slug (GENEX.slug) — identifies the project to /play/authorize. */
+    slug: string;
+    /** The genex API base URL (GENEX.apiUrl) — for redeem/refresh/origin fetches. */
+    apiUrl: string;
+    /**
+     * EXACT-match allowlist of dashboard origins this game accepts a ticket
+     * postMessage from (GENEX.dashboardOrigins). Never matched by substring/
+     * suffix/regex. Also the fallback standalone redirect target.
+     */
+    dashboardOrigins: string[];
+}
+interface EmbedUser {
+    id: string;
+    name: string;
+    image?: string;
+}
+type AuthState = 'pending' | 'authenticated' | 'blocked';
+type EmbedEvent = 'authenticated' | 'blocked' | 'error';
+interface EventContext {
+    user?: EmbedUser;
+    error?: unknown;
+}
+/**
+ * Initialize embed auth. Call ONCE, first thing in the boot sequence — before
+ * connect() and before any /state call. Scene/asset boot may proceed
+ * immediately (the gate overlay blocks interaction, not execution); await
+ * waitForAuth() before anything identity-dependent.
+ *
+ * Standalone (not in an iframe) with no return-trip ticket present, this
+ * navigates away to the dashboard sign-in — by design, there is no anonymous
+ * play.
+ */
+declare function initEmbed(cfg: EmbedConfig): void;
+/**
+ * Structural "is in a frame" check — deliberately a different question from
+ * "is authenticated". True even before the handshake resolves.
+ */
+declare function isEmbedded(): boolean;
+/** Current auth state. Synchronous; starts 'pending', ends 'authenticated' or 'blocked'. */
+declare function getAuthState(): AuthState;
+/** The signed-in user — non-null only once getAuthState() === 'authenticated'. */
+declare function getUser(): EmbedUser | null;
+/**
+ * The raw scoped embedToken, for Authorization: Bearer calls the game makes
+ * itself (GET/PUT /api/projects/:slug/state — which REQUIRES it; there is no
+ * anonymous save path). undefined unless authenticated.
+ *
+ * NEVER log this value or pass it to crash-reporting/analytics breadcrumb
+ * capture. It is bounded (15 minutes, one project, one scope), but third-party
+ * logging-service retention can outlive that.
+ */
+declare function getEmbedToken(): string | undefined;
+/**
+ * The credential for multiplayer: pass as `connect({ ..., auth: getColyseusAuth() })`
+ * AFTER `await waitForAuth()` — the relay rejects tokenless joins. Read it
+ * fresh at every connect() call (tokens rotate ~every 10 minutes).
+ * NEVER log this value.
+ */
+declare function getColyseusAuth(): {
+    embedToken: string;
+} | undefined;
+/**
+ * Resolves with the signed-in user once authenticated; rejects if the session
+ * ends up blocked. THE gate for connect() and /state calls.
+ */
+declare function waitForAuth(): Promise<{
+    user: EmbedUser;
+}>;
+/** Subscribe to auth lifecycle events. Returns an unsubscribe function. */
+declare function on(event: EmbedEvent, cb: (ctx?: EventContext) => void): () => void;
+/**
+ * @internal — for ./sentry.ts ONLY, not public API (games never call this).
+ * If the URL fragment carries a genex ticket, move it out of the URL (so no
+ * recorder/logger ever sees it) into a stash the standalone flow reads.
+ */
+declare function _stashTicketFromUrl(): void;
+declare function __resetForTests(overrides?: {
+    handshakeTimeoutMs?: number;
+    refreshDelayMs?: number;
+    refreshRetryMs?: number;
+}): void;
+
+export { type AuthState, type EmbedConfig, type EmbedEvent, type EmbedUser, __resetForTests, _stashTicketFromUrl, getAuthState, getColyseusAuth, getEmbedToken, getUser, initEmbed, isEmbedded, on, waitForAuth };

package/dist/index.js

@@ -0,0 +1,24 @@
+import {
+  __resetForTests,
+  _stashTicketFromUrl,
+  getAuthState,
+  getColyseusAuth,
+  getEmbedToken,
+  getUser,
+  initEmbed,
+  isEmbedded,
+  on,
+  waitForAuth
+} from "./chunk-KXUDNW6P.js";
+export {
+  __resetForTests,
+  _stashTicketFromUrl,
+  getAuthState,
+  getColyseusAuth,
+  getEmbedToken,
+  getUser,
+  initEmbed,
+  isEmbedded,
+  on,
+  waitForAuth
+};

package/dist/sentry.d.ts

@@ -0,0 +1,34 @@
+interface GameSentryOptions {
+    /** The game's slug — use GENEX.slug. Becomes the game_slug tag. */
+    slug: string;
+    /** Override the shared genex-games project DSN. */
+    dsn?: string;
+    /** Sentry environment. Published bundles are 'production' (the default). */
+    environment?: string;
+}
+/**
+ * Initialize crash reporting + session replay for a game. Call ONCE, BEFORE
+ * initEmbed() — so even auth-boot failures are reported. Safe in any context
+ * the game runs in: dashboard iframe, standalone tab, local dev preview.
+ *
+ * Replay records the DOM; the game's WebGL/WebGPU canvas needs explicit
+ * snapshots — call sentryCanvasSnapshot(renderer.domElement) in the render
+ * loop (see below).
+ */
+declare function initGameSentry(opts: GameSentryOptions): void;
+/**
+ * Renderer-agnostic canvas capture for session replay: call once per frame at
+ * the END of the render loop, right after renderer.render(scene, camera),
+ * passing renderer.domElement. Throttled internally (default: one capture per
+ * 500ms), so calling at 60fps is fine.
+ *
+ * skipRequestAnimationFrame captures synchronously in the SAME task as the
+ * draw — REQUIRED for WebGPU (canvas textures expire when the task completes)
+ * and safe for WebGL (the buffer is still valid within the task, so no
+ * preserveDrawingBuffer needed). One code path for both renderers.
+ */
+declare function sentryCanvasSnapshot(canvas: HTMLCanvasElement, opts?: {
+    intervalMs?: number;
+}): void;
+
+export { type GameSentryOptions, initGameSentry, sentryCanvasSnapshot };

package/dist/sentry.js

@@ -0,0 +1,113 @@
+import {
+  _stashTicketFromUrl,
+  getUser,
+  on
+} from "./chunk-KXUDNW6P.js";
+
+// src/sentry.ts
+import * as Sentry from "@sentry/browser";
+
+// src/sentry-scrub.ts
+var TOKENISH = /((?:genex_ticket|ticket|embedToken|token)=)[^&#\s"']+/gi;
+function scrubTokens(s) {
+  return s.replace(TOKENISH, "$1[redacted]");
+}
+
+// src/sentry.ts
+var DEFAULT_GAMES_DSN = "https://d1414cfcdc09bf1c1d124e86f8087251@o4511115493900288.ingest.us.sentry.io/4511662569160704";
+var initialized = false;
+function initGameSentry(opts) {
+  if (typeof window === "undefined") return;
+  if (initialized) return;
+  initialized = true;
+  _stashTicketFromUrl();
+  Sentry.init({
+    dsn: opts.dsn ?? DEFAULT_GAMES_DSN,
+    environment: opts.environment ?? "production",
+    tracesSampleRate: 1,
+    // low-traffic demo; first knobs to lower: replays, then this
+    replaysSessionSampleRate: 1,
+    // record EVERY session (demo decision 2026-07-02)
+    replaysOnErrorSampleRate: 1,
+    dataCollection: { userInfo: true },
+    initialScope: { tags: { game_slug: opts.slug } },
+    integrations: [
+      Sentry.browserTracingIntegration(),
+      // Unmasked (demo decision 2026-07-02): game UI is the product. Replay
+      // network capture stays at its default (URLs only, never bodies or
+      // headers) — do NOT add networkDetailAllowUrls for the genex API, or
+      // ticket/embedToken response bodies would be recorded.
+      Sentry.replayIntegration({
+        maskAllText: false,
+        blockAllMedia: false,
+        // Scrub token-ish URLs from replay CUSTOM recording events (navigation
+        // breadcrumbs, resource spans). rrweb's own DOM events can't be
+        // modified here — that's what _stashTicketFromUrl above is for.
+        beforeAddRecordingEvent: (event) => {
+          try {
+            const payload = event.data?.payload;
+            if (payload) {
+              if (typeof payload.description === "string") {
+                payload.description = scrubTokens(payload.description);
+              }
+              const d = payload.data;
+              if (d) {
+                for (const k of ["url", "to", "from"]) {
+                  if (typeof d[k] === "string") d[k] = scrubTokens(d[k]);
+                }
+              }
+            }
+          } catch {
+          }
+          return event;
+        }
+      }),
+      // Canvas frames are captured manually from the render loop — automatic
+      // capture would need preserveDrawingBuffer (WebGL perf hit) and misses
+      // WebGPU entirely. See sentryCanvasSnapshot.
+      Sentry.replayCanvasIntegration({ enableManualSnapshot: true })
+    ],
+    // The auth ticket travels in the URL fragment on the standalone flow —
+    // scrub token-ish values from everything URL- or message-shaped.
+    beforeSend(event) {
+      if (event.request?.url) event.request.url = scrubTokens(event.request.url);
+      if (event.message) event.message = scrubTokens(event.message);
+      return event;
+    },
+    beforeBreadcrumb(crumb) {
+      if (typeof crumb.data?.url === "string") crumb.data.url = scrubTokens(crumb.data.url);
+      if (typeof crumb.data?.to === "string") crumb.data.to = scrubTokens(crumb.data.to);
+      if (typeof crumb.data?.from === "string") crumb.data.from = scrubTokens(crumb.data.from);
+      if (typeof crumb.message === "string") crumb.message = scrubTokens(crumb.message);
+      return crumb;
+    }
+  });
+  Sentry.addEventProcessor((event) => {
+    const e = event;
+    if (Array.isArray(e.urls)) {
+      e.urls = e.urls.map((u) => typeof u === "string" ? scrubTokens(u) : u);
+    }
+    if (e.request?.url) e.request.url = scrubTokens(e.request.url);
+    return event;
+  });
+  on("authenticated", (ctx) => {
+    const u = ctx?.user ?? getUser();
+    if (u) Sentry.setUser({ id: u.id, username: u.name });
+  });
+  on("blocked", () => Sentry.setUser(null));
+  on("error", (ctx) => {
+    if (ctx?.error) Sentry.captureException(ctx.error);
+  });
+}
+var lastSnapshot = 0;
+function sentryCanvasSnapshot(canvas, opts) {
+  const now = Date.now();
+  if (now - lastSnapshot < (opts?.intervalMs ?? 500)) return;
+  lastSnapshot = now;
+  const replayCanvas = Sentry.getClient()?.getIntegrationByName("ReplayCanvas");
+  void replayCanvas?.snapshot(canvas, { skipRequestAnimationFrame: true });
+}
+export {
+  initGameSentry,
+  sentryCanvasSnapshot
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@genex-ai/embed-sdk",
+  "version": "0.2.0",
+  "description": "Signed-in identity for genex games — embedded (dashboard iframe postMessage handshake) or standalone (sign-in redirect). No anonymous play.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@genex-ai/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./sentry": {
+      "@genex-ai/source": "./src/sentry.ts",
+      "types": "./dist/sentry.d.ts",
+      "import": "./dist/sentry.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@sentry/browser": "^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@sentry/browser": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.0",
+    "@sentry/browser": "^10.63.0",
+    "publint": "^0.3.0",
+    "tsup": "^8.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "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"
+  }
+}