@aippy/runtime 0.4.1-dev.1 → 0.4.2-beta.0

package/README.md

@@ -17,14 +17,19 @@ import { AippyConfig, mergeConfig } from '@aippy/runtime/core';
 
 const config = mergeConfig({
   debug: true,
-  apiBaseUrl: 'https://api.example.com'
+  apiBaseUrl: 'https://api.example.com',
 });
 ```
 
 ### Device APIs
 
 ```typescript
-import { camera, geolocation, sensors, fileSystem } from '@aippy/runtime/device';
+import {
+  camera,
+  geolocation,
+  sensors,
+  fileSystem,
+} from '@aippy/runtime/device';
 
 // Camera
 const stream = await camera.getStream();
@@ -32,13 +37,13 @@ const photo = await camera.capturePhoto({ quality: 'high' });
 
 // Geolocation
 const position = await geolocation.getCurrentPosition();
-const watchId = geolocation.watchPosition((pos) => {
+const watchId = geolocation.watchPosition(pos => {
   console.log('Position:', pos);
 });
 
 // Sensors
 const orientation = await sensors.getOrientation();
-const cleanup = sensors.watchOrientation((data) => {
+const cleanup = sensors.watchOrientation(data => {
   console.log('Orientation:', data);
 });
 
@@ -78,7 +83,7 @@ const patchedCtx = patchAudioContext(ctx);
 // Unlock audio on user interaction (required on iOS)
 button.onclick = async () => {
   await patchedCtx.unlock();
-  
+
   // Use native Web Audio API as normal
   const osc = patchedCtx.createOscillator();
   osc.connect(patchedCtx.destination);
@@ -90,7 +95,9 @@ button.onclick = async () => {
 ### AI (Backend Proxy Adapter)
 
 ```typescript
-// Default base URL: https://api.aippy.dev/api/aisdk/v1
+// Default base URL: https://api.aippy.ai/aisdk/v1/  (no /api prefix)
+// Resolved by core/env.ts at runtime — api.aippy.dev only when the page host
+// ends in .aippynow.com or is localhost; everything else gets prod.
 
 import { streamText, experimental_generateImage as generateImage } from 'ai';
 import { aippyAIProvider } from '@aippy/runtime/ai';
@@ -120,6 +127,27 @@ const image = await generateImage({
 console.log(image.image?.base64);
 ```
 
+`@aippy/runtime/ai` also exports internal-test Viggle generation with automatic recovery and
+`listViggleModels` for the current user's project history. Project ticket keys
+are resolved by the backend; applications do not settle tickets or pass SKU
+constants. Availability depends on the matching backend/shared MiniStore
+contracts and project configuration. See the [AI module](./src/ai/README.md).
+
+### Ministore (Internal Test Only)
+
+`@aippy/runtime/ministore` provides project entitlement catalogs, holdings,
+mall GEM balance, authorization queries, explicit settlement and records.
+The SDK and its Skill are not available to external creators and are not
+advertised in system prompts. An installed export does not authorize public use.
+App or approved website-parent confirmation uses the specified wallet.authorize
+contract and stays separate from settlement. The synchronous support check is
+native-only; parent confirmation needs a matching deployed website handler.
+Non-native recharge hints do not wait for funds or resume settlement.
+Real host support and service acceptance remain pending; no
+package publication or external enablement is performed by this work.
+See the [ministore module](./src/ministore/README.md) for the verified HTTP
+contract, internal-consumer requirements and recovery rules.
+
 ## Packages
 
 - `@aippy/runtime/core` - Core types and configuration
@@ -127,6 +155,7 @@ console.log(image.image?.base64);
 - `@aippy/runtime/utils` - Platform detection, performance monitoring, PWA utilities
 - `@aippy/runtime/audio` - iOS-compatible Web Audio API wrapper
 - `@aippy/runtime/ai` - AI SDK adapter wrapping `ai` package, routes through backend proxy
+- `@aippy/runtime/ministore` - Project entitlements, GEM wallet and authorization (internal test only; App integration pending)
 
 ## Publishing
 

package/dist/ai/errors.d.ts

@@ -2,6 +2,7 @@ import { AISDKError } from 'ai';
 /**
  * Normalizes a backend error response into an AISDKError.
  * Extracts and sends appMessage to container if present in the error response.
+ * Ordinary AI credits are separate from GEM; quota errors never open GEM recharge.
  * Uses [Aippy Runtime] prefix - these errors are NOT reported to LLM.
  */
 export declare function normalizeError(response: Response, body?: unknown): AISDKError;

package/dist/ai/index.d.ts

@@ -41,4 +41,6 @@ export type { AippyOpenAIConfig } from './openai';
 export { aippyChatConfig, type AippyUseChatOptions, type AippyUIConfig, type AippyChatConfig, UI_CHAT_ENDPOINT, } from './ui';
 export { DEFAULT_BASE_URL, DEFAULT_UI_BASE_URL, DEFAULT_CHAT_MODEL, DEFAULT_CHAT_SYSTEM, resolveOpenAIConfig, resolveUIConfig, } from './shared';
 export { normalizeError } from './errors';
+export { generateCharacter3D, generateMotion, createViggleRequestId, resumeViggleGeneration, ViggleGenerationError, type GenerateCharacter3DInput, type GenerateMotionInput, type ViggleAsset, type ViggleKind, type ViggleStage, type ResumeViggleGenerationInput, } from './viggle/generate';
+export { listViggleModels, type ListViggleModelsOptions, type ViggleModel, type ViggleModelValue, type ViggleModelsPage, } from './viggle/models';
 export { type AIConfig, type AIConfigValue, type AIConfigItem, type NumberAIConfigItem, type BooleanAIConfigItem, type TextAIConfigItem, type EnumAIConfigItem, type AIConfigError, type AIConfigValues, validateAIConfig, parseAIConfig, loadAIConfig, getAIConfigValue, sendAIConfigToContainer, createAIConfig, } from './config';

package/dist/ai/index.js

@@ -1,21 +1,26 @@
-import { D as i, d as A, e as r, c as n, U as C, a as I, b as f, h as g, g as _, l as p, n as E, p as T, r as U, f as t, s as l, v as D } from "../helper-CZqFi-QF.js";
-import "react";
-import "../bridge-CtB9L5kL.js";
+import { D as o, d as r, e as i, c as n, U as g, V as A, a as t, b as C, o as l, i as I, g as f, h as E, m as _, l as T, k as U, n as p, p as D, r as d, f as L, j as V, s as m, v } from "../helper-CJ3YV3nf.js";
+import "../bridge-K3HqQwdj.js";
 export {
-  i as DEFAULT_BASE_URL,
-  A as DEFAULT_CHAT_MODEL,
-  r as DEFAULT_CHAT_SYSTEM,
+  o as DEFAULT_BASE_URL,
+  r as DEFAULT_CHAT_MODEL,
+  i as DEFAULT_CHAT_SYSTEM,
   n as DEFAULT_UI_BASE_URL,
-  C as UI_CHAT_ENDPOINT,
-  I as aippyAIProvider,
-  f as aippyChatConfig,
-  g as createAIConfig,
+  g as UI_CHAT_ENDPOINT,
+  A as ViggleGenerationError,
+  t as aippyAIProvider,
+  C as aippyChatConfig,
+  l as createAIConfig,
+  I as createViggleRequestId,
+  f as generateCharacter3D,
+  E as generateMotion,
   _ as getAIConfigValue,
-  p as loadAIConfig,
-  E as normalizeError,
-  T as parseAIConfig,
-  U as resolveOpenAIConfig,
-  t as resolveUIConfig,
-  l as sendAIConfigToContainer,
-  D as validateAIConfig
+  T as listViggleModels,
+  U as loadAIConfig,
+  p as normalizeError,
+  D as parseAIConfig,
+  d as resolveOpenAIConfig,
+  L as resolveUIConfig,
+  V as resumeViggleGeneration,
+  m as sendAIConfigToContainer,
+  v as validateAIConfig
 };

package/dist/ai/viggle/generate.d.ts

@@ -0,0 +1,67 @@
+import { AISDKError } from 'ai';
+export type ViggleKind = 'character' | 'motion';
+export type ViggleStage = 'authorize' | 'create' | 'poll' | 'resume';
+interface GenerationOptions {
+    /** Optional explicit idempotency key. Normal calls manage recovery internally. */
+    requestId?: string;
+    signal?: AbortSignal;
+}
+export interface GenerateCharacter3DInput extends GenerationOptions {
+    image?: Blob;
+    imageUrl?: string;
+    prompt?: string;
+}
+export interface GenerateMotionInput extends GenerationOptions {
+    text: string;
+    durationSeconds?: number;
+}
+export interface ResumeViggleGenerationInput extends GenerationOptions {
+    jobId: string;
+    kind: ViggleKind;
+}
+export interface ViggleAsset {
+    url: string;
+    thumbnailUrl?: string;
+    jobId: string;
+    requestId: string;
+    kind: ViggleKind;
+    /** Prepaid jobs are delivered only after the coupon consume is confirmed. */
+    billingState?: string;
+}
+interface Handle {
+    requestId?: string;
+    jobId?: string;
+    jobConfirmed?: boolean;
+    kind: ViggleKind;
+    stage: ViggleStage;
+    persist?: () => void;
+    clear?: () => void;
+}
+/** Recovery is automatic on the next call with the same input. Handles remain available for diagnostics and explicit recovery. */
+export declare class ViggleGenerationError extends AISDKError {
+    readonly requestId?: string;
+    readonly jobId?: string;
+    /** True only after the backend confirmed that this job was persisted. */
+    readonly jobConfirmed: boolean;
+    readonly kind: ViggleKind;
+    readonly stage: ViggleStage;
+    readonly reason: string;
+    readonly httpStatus?: number;
+    readonly activeJob?: {
+        jobId: string;
+        kind: ViggleKind;
+        requestId: string;
+        sameInput: boolean;
+    };
+    constructor(message: string, handle: Handle, reason: string, cause?: unknown, httpStatus?: number, activeJob?: ViggleGenerationError['activeJob']);
+}
+/** One key per user action. A retry of the same action must reuse the key. */
+export declare function createViggleRequestId(): string;
+/** Persist a job, use/buy its project ticket, then wait for confirmed fulfillment. */
+export declare function generateCharacter3D(input: GenerateCharacter3DInput): Promise<ViggleAsset>;
+/** Generate a 441-joint GLB motion; quantity is one priced generation coupon. */
+export declare function generateMotion(input: GenerateMotionInput): Promise<ViggleAsset>;
+/** Explicit user action: recover a job with GET only, including consent/recharge. */
+export declare function resumeViggleGeneration(input: ResumeViggleGenerationInput): Promise<ViggleAsset>;
+export declare function viggleScope(signal: AbortSignal): () => void;
+export {};

package/dist/ai/viggle/models.d.ts

@@ -0,0 +1,46 @@
+import { ViggleKind } from './generate';
+export interface ListViggleModelsOptions {
+    kind?: ViggleKind;
+    /** Opaque decimal record ID; keep as a string. */
+    cursor?: string;
+    /** Raw records per page, 1–50; default 20. Filtered pages can be empty. */
+    limit?: number;
+    signal?: AbortSignal;
+}
+export interface ViggleModelValue {
+    schemaVersion: 1;
+    source: 'aisdk.viggle';
+    jobId: string;
+    provider: 'viggle';
+    kind: ViggleKind;
+    durationSeconds?: number;
+    asset: {
+        url: string;
+        format: 'vsplat' | 'glb';
+        thumbnailUrl?: string;
+    };
+    generatedAt: string;
+}
+export interface ViggleModel {
+    recordId: string;
+    benefitKey: string;
+    bizOrderNo: string;
+    jobId: string;
+    kind: ViggleKind;
+    url: string;
+    thumbnailUrl?: string;
+    durationSeconds?: number;
+    generatedAt: string;
+    consumedAt: string;
+    /** Original consumed-item value snapshot; independent of job retention. */
+    value: ViggleModelValue;
+}
+export interface ViggleModelsPage {
+    models: ViggleModel[];
+    nextCursor: string;
+}
+/** Read successful model records for the authenticated user/current project.
+ * Product keys are resolved by the backend, including retired products.
+ * This call never authorizes, recharges, purchases, generates or consumes.
+ */
+export declare function listViggleModels(options?: ListViggleModelsOptions): Promise<ViggleModelsPage>;

package/dist/ai/viggle/recovery.d.ts

@@ -0,0 +1,12 @@
+export interface SavedGeneration {
+    requestId: string;
+    jobId?: string;
+}
+export declare function inputDigest(input: unknown): Promise<string>;
+/** Hints only: server ownership, input binding, CAS and purchase authorization
+ * remain authoritative. Never persist prompts, images, tokens or billing data. */
+export declare function recoveryKey(kind: string, digest: string): string | undefined;
+export declare function readGeneration(key?: string): SavedGeneration | undefined;
+export declare function saveGeneration(key: string | undefined, saved: SavedGeneration): void;
+export declare function clearGeneration(key: string | undefined, requestId: string): void;
+export declare function singleGeneration<T>(key: string | undefined, run: () => Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/{app-version-checker-Bz7FrEZz.js → app-version-checker-YVIFbytA.js}

@@ -156,17 +156,18 @@ class A {
     }
   }
 }
-const m = new A(), C = { iOS: "1.6.7", Android: "1.1.8" }, k = { iOS: "1.6.7", Android: "1.1.8" }, d = {
+const m = new A(), C = { iOS: "1.6.7", Android: "1.1.8" }, k = { iOS: "1.6.7", Android: "1.1.8" }, P = { iOS: "1.21.0", Android: "1.3.7.0" }, d = {
   userCredentials: C,
-  userInfo: k
+  userInfo: k,
+  ministore: P
 }, l = "https://cdn.aippy.ai/asset/fd292077086044ee9565bd36ac3a8b78.svg";
-function P() {
+function V() {
   const t = m.parseAippyInfo();
   if (!t) return !1;
   const e = d.userCredentials[t.platform];
   return f(t.version, e) >= 0;
 }
-async function V(t, e = "update") {
+async function _(t, e = "update") {
   const n = document.createElement("div");
   n.style.cssText = "position:fixed;top:0;left:0;right:0;bottom:12px;display:flex;align-items:flex-end;justify-content:center;z-index:999999;pointer-events:none";
   const r = document.createElement("div");
@@ -181,7 +182,7 @@ async function V(t, e = "update") {
     const a = document.createElement("img");
     a.src = l, a.style.cssText = "width:36px;height:36px;flex-shrink:0", r.appendChild(a);
   }
-  const i = e === "signin" || e === "update" && P(), p = i ? t.replace(/\n/g, "") : t, s = document.createElement("span");
+  const i = e === "signin" || e === "update" && V(), p = i ? t.replace(/\n/g, "") : t, s = document.createElement("span");
   if (s.style.cssText = "font-size:14px;font-weight:600;color:#fff;line-height:1.4;white-space:pre-line", s.textContent = p, r.appendChild(s), i) {
     const a = e === "signin" ? "Sign in" : "Update", c = document.createElement("button");
     c.style.cssText = "background:#fff;color:#000;font-size:14px;font-weight:600;border:none;border-radius:32px;height:36px;min-width:80px;padding:0 16px;cursor:pointer;flex-shrink:0;white-space:nowrap", c.textContent = a, c.onclick = () => {
@@ -196,12 +197,12 @@ async function V(t, e = "update") {
   }
   n.appendChild(r), document.body.appendChild(n);
 }
-function _(t) {
+function R(t) {
   const e = d[t];
   return e || (console.warn(`[AppVersionChecker] Unknown feature: ${t}`), { iOS: "999.0.0", Android: "999.0.0" });
 }
-function R(t) {
-  const e = _(t), n = m.checkAppEnvironment(e), r = n.aippyInfo?.version, o = n.aippyInfo ? e[n.aippyInfo.platform] : void 0;
+function I(t) {
+  const e = R(t), n = m.checkAppEnvironment(e), r = n.aippyInfo?.version, o = n.aippyInfo ? e[n.aippyInfo.platform] : void 0;
   switch (n.type) {
     case "new_app":
       return {
@@ -225,24 +226,24 @@ function R(t) {
       };
   }
 }
-function L(t) {
-  const e = R(t);
+function M(t) {
+  const e = I(t);
   if (!e.supported && (e.envCheck.type === "new_app" || e.envCheck.type === "old_ios_app" || e.envCheck.type === "old_android_app"))
-    throw console.warn(`[AppVersionChecker] ${e.message}`), V(`This project needs a newer version.
+    throw console.warn(`[AppVersionChecker] ${e.message}`), _(`This project needs a newer version.
 Update to view it.`, "update"), v(`App version too old: ${e.message}`, x.NOT_SUPPORTED);
   return e;
 }
-function M() {
+function N() {
   return Object.keys(d);
 }
 export {
   A as P,
-  R as a,
-  M as b,
+  I as a,
+  N as b,
   f as c,
-  _ as g,
+  R as g,
   y as i,
   m as p,
-  L as r,
-  V as s
+  M as r,
+  _ as s
 };

package/dist/bridge-K3HqQwdj.js

@@ -0,0 +1,311 @@
+import { a as v } from "./runtime-CmoG3v2m.js";
+import { r as b, s as q, i as w } from "./app-version-checker-YVIFbytA.js";
+import { c as A, a as _ } from "./errors-B3bDbQbD.js";
+const F = ".aippynow.com", k = "https://api.aippy.dev", S = "https://api.aippy.ai";
+function ee(e) {
+  return e === k || e === S;
+}
+let p;
+function j() {
+  if (p) return p;
+  let e = S;
+  if (typeof window < "u" && window.location) {
+    const n = window.location.hostname;
+    (n.endsWith(F) || n === "localhost" || n === "127.0.0.1") && (e = k);
+  }
+  return p = e, e;
+}
+function ne() {
+  p = void 0;
+}
+function I() {
+  if (typeof window > "u" || !window.parent || window.parent === window)
+    return;
+  const e = window.location?.ancestorOrigins?.[0] || (typeof document < "u" ? document.referrer : "");
+  if (e)
+    try {
+      const { origin: n, protocol: t } = new URL(e);
+      return t === "https:" || t === "http:" ? n : void 0;
+    } catch {
+      return;
+    }
+}
+function P(e) {
+  return !!e.data && typeof e.data == "object" && !Array.isArray(e.data);
+}
+function U(e, n = I()) {
+  return typeof window < "u" && !!n && e.source === window.parent && e.origin === n && P(e);
+}
+function N(e) {
+  if (typeof window > "u" || !P(e)) return !1;
+  const n = window.location?.origin;
+  return U(e) || !!n && n !== "null" && e.source === window && e.origin === n;
+}
+const m = {
+  apiBaseUrl: `${j()}/api`,
+  authToken: "",
+  currentUserId: null
+};
+function H(e) {
+  Object.assign(m, e);
+}
+function J(e) {
+  m.authToken = e;
+}
+function V(e) {
+  m.currentUserId = e;
+}
+function te() {
+  return m.currentUserId;
+}
+const O = 3e3, L = 50, f = 500, c = { uid: "", token: "" };
+let l = null, h = !1, a = null, u = null;
+function d(e) {
+  return !!e && typeof e == "object" && !Array.isArray(e);
+}
+function D(e) {
+  return typeof e == "string" && e !== "" ? e : typeof e == "number" && Number.isSafeInteger(e) && e > 0 ? String(e) : null;
+}
+function E(e) {
+  if (!d(e)) return null;
+  let n = e;
+  d(n.credentials) && (n = n.credentials), d(n.user) && n.token && (n = {
+    uid: n.user.uid || n.user.userId || n.user.id,
+    token: n.token,
+    apiBaseUrl: n.apiBaseUrl
+  });
+  const t = D(n.uid || n.userId || n.id), i = n.token || n.authToken;
+  if (!t || typeof i != "string" || i === "") return null;
+  const r = typeof n.apiBaseUrl == "string" ? n.apiBaseUrl : void 0, s = { uid: t, token: i, apiBaseUrl: r };
+  return V(t), J(i), r && H({ apiBaseUrl: r }), s;
+}
+function T(e) {
+  if (!d(e)) return null;
+  let n = e;
+  d(n.userInfo) && (n = n.userInfo), d(n.user) && (n = n.user);
+  const t = D(n.uid || n.userId || n.id);
+  if (!t) return null;
+  const i = { ...n, uid: t };
+  return l = i, h = !0, i;
+}
+function x(e = f) {
+  return a ? new Promise((n) => {
+    const t = a.resolve;
+    a.resolve = (i) => {
+      t(i), n(i);
+    };
+  }) : new Promise((n) => {
+    let t, i;
+    const r = {
+      resolve: (s) => {
+        clearTimeout(t), i?.cancel(), a === r && (a = null), n(s);
+      }
+    };
+    a = r, (async () => {
+      let s = window.webkit?.messageHandlers?.aippyListener;
+      if (s || (s = await M(1500)), a === r) {
+        if (!s) {
+          r.resolve(c);
+          return;
+        }
+        t = setTimeout(() => r.resolve(c), e), i = v.receiveChannel.once(
+          "user.credentials",
+          (o) => {
+            r.resolve(E(o) || c);
+          }
+        );
+        try {
+          s.postMessage({
+            command: "user.getCredentials",
+            parameters: JSON.stringify({
+              timestamp: Date.now(),
+              endpoint: "user.credentials"
+            })
+          });
+        } catch {
+          r.resolve(c);
+        }
+      }
+    })();
+  });
+}
+function z(e = f) {
+  return new Promise((n) => {
+    const t = I();
+    if (!w() || !t) {
+      n(c);
+      return;
+    }
+    const i = setTimeout(() => {
+      window.removeEventListener("message", r), n(c);
+    }, e), r = (s) => {
+      if (!U(s, t) || s.data.type !== "user-credentials-response")
+        return;
+      const o = E(s.data);
+      o && (clearTimeout(i), window.removeEventListener("message", r), n(o));
+    };
+    window.addEventListener("message", r);
+    try {
+      window.parent.postMessage(
+        { type: "user-credentials-request", timestamp: Date.now() },
+        t
+      );
+    } catch {
+      clearTimeout(i), window.removeEventListener("message", r), n(c);
+    }
+  });
+}
+const G = () => /Aippy\/[\d.]+\/\d+\/Android/i.test(navigator.userAgent);
+async function M(e = 1500) {
+  if (!G())
+    return window.webkit?.messageHandlers?.aippyListener || null;
+  const n = Date.now();
+  for (; Date.now() - n < e; ) {
+    const t = window.webkit?.messageHandlers?.aippyListener;
+    if (t) return t;
+    await new Promise((i) => setTimeout(i, 50));
+  }
+  return null;
+}
+function W(e = !1, n = f) {
+  return h && l && !e ? Promise.resolve(l) : u ? new Promise((t) => {
+    const i = u.resolve;
+    u.resolve = (r) => {
+      i(r), t(r);
+    };
+  }) : new Promise((t) => {
+    let i, r;
+    const s = {
+      resolve: (o) => {
+        clearTimeout(i), r?.cancel(), u === s && (u = null), t(o);
+      }
+    };
+    u = s, (async () => {
+      let o = window.webkit?.messageHandlers?.aippyListener;
+      if (o || (o = await M(1500)), u === s) {
+        if (!o) {
+          s.resolve(null);
+          return;
+        }
+        i = setTimeout(() => s.resolve(null), n), r = v.receiveChannel.once("user.info", (B) => {
+          s.resolve(T(B));
+        });
+        try {
+          o.postMessage({
+            command: "user.getUserInfo",
+            parameters: JSON.stringify({
+              timestamp: Date.now(),
+              endpoint: "user.info"
+            })
+          });
+        } catch {
+          s.resolve(null);
+        }
+      }
+    })();
+  });
+}
+function C(e = f) {
+  return new Promise((n) => {
+    const t = I();
+    if (!w() || !t) {
+      n(null);
+      return;
+    }
+    const i = setTimeout(() => {
+      window.removeEventListener("message", r), n(null);
+    }, e), r = (s) => {
+      if (!U(s, t) || s.data.type !== "user-info-response")
+        return;
+      const o = T(s.data);
+      o && (clearTimeout(i), window.removeEventListener("message", r), n(o));
+    };
+    window.addEventListener("message", r);
+    try {
+      window.parent.postMessage(
+        { type: "user-info-request", timestamp: Date.now() },
+        t
+      );
+    } catch {
+      clearTimeout(i), window.removeEventListener("message", r), n(null);
+    }
+  });
+}
+async function R() {
+  const { envCheck: e } = b("userCredentials");
+  switch (e.type) {
+    case "new_app": {
+      const n = await x(O);
+      if (!n?.token)
+        throw A(
+          "Token unavailable in app",
+          _.PERMISSION_DENIED
+        );
+      return n.token;
+    }
+    case "iframe": {
+      const n = await z(L);
+      if (n?.token) return n.token;
+      throw q(
+        "Sign in to continue.Open this project in the app.",
+        "signin"
+      ), A(
+        "Token unavailable: User needs to login",
+        _.PERMISSION_DENIED
+      );
+    }
+    default:
+      return "";
+  }
+}
+async function X(e = !1) {
+  if (h && l && !e)
+    return l;
+  const { envCheck: n } = b("userInfo");
+  switch (n.type) {
+    case "new_app":
+      return await W(e, O);
+    case "iframe":
+      return await C(L);
+    default:
+      return l;
+  }
+}
+async function Y(e = f) {
+  return w() ? await C(e) : null;
+}
+function g(e) {
+  const n = E(e);
+  n && a && (a.resolve(n), a = null);
+}
+function y(e) {
+  const n = T(e);
+  u && (u.resolve(n), u = null);
+}
+function $() {
+  typeof window > "u" || (window.processUserCredentials = g, window.processUserInfo = y, window.addEventListener("message", (e) => {
+    N(e) && (e.data.type === "user-credentials" && g(e.data), e.data.type === "user-info" && y(e.data));
+  }));
+}
+$();
+R().catch(() => {
+});
+const re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getAuthTokenAsync: R,
+  getUserInfoAsync: X,
+  getUserInfoFromParent: Y,
+  isInIframe: w,
+  processUserCredentials: g,
+  processUserInfo: y
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ne as _,
+  I as a,
+  ee as b,
+  te as c,
+  re as d,
+  R as g,
+  U as i,
+  j as r
+};