@aippy/runtime 0.4.2-dev.2 → 0.4.2-dev.4

package/dist/ministore/order.d.ts

@@ -0,0 +1 @@
+export declare function createBizOrderNo(value?: string): string;

package/dist/ministore/purchase.d.ts

@@ -0,0 +1,5 @@
+import { MinistorePurchaseInput, MinistoreRequestOptions, MinistoreResult, MinistoreSettlement } from './types';
+/** Native bridge and shared auth version floor; not wallet capability or API readiness. */
+export declare function isPurchaseSupported(): boolean;
+/** Settle an explicit purchase; mall enforces its server-recorded authorization. */
+export declare function purchase(input: MinistorePurchaseInput, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreSettlement>>;

package/dist/ministore/queries.d.ts

@@ -0,0 +1,13 @@
+import { MinistoreAuthorization, MinistoreAuthorizationQuery, MinistoreBenefits, MinistoreCatalog, MinistoreRecordsPage, MinistoreRecordsQuery, MinistoreRequestOptions, MinistoreResult } from './types';
+/**
+ * Read the user's GEM balance from the mall wallet.
+ * The mall wallet endpoint returns { balance: number, assetType: 'GEM' }.
+ * No account is a real zero; wallet failures are never replaced with a fake zero.
+ */
+export declare function getGemBalance(options?: MinistoreRequestOptions): Promise<number>;
+/** Read mall authorization state; this endpoint never writes authorization. */
+export declare function getAuthorization(query: MinistoreAuthorizationQuery, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreAuthorization>>;
+export declare function listCatalog(options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreCatalog>>;
+/** Includes previously used benefits even when their current quantity is zero. */
+export declare function listBenefits(options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreBenefits>>;
+export declare function listRecords(query?: MinistoreRecordsQuery, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreRecordsPage>>;

package/dist/ministore/recharge.d.ts

@@ -0,0 +1,12 @@
+import { MinistoreRequestOptions, MinistoreResult } from './types';
+interface Scope {
+    options: MinistoreRequestOptions;
+    check: () => void;
+    prepareContinuation: () => void;
+    available: () => boolean;
+}
+/** Bind continuation to the fresh credential identity of the original request. */
+export declare function rechargeScope(options: MinistoreRequestOptions): Scope;
+/** One recharge and one original-order continuation, never an authorization or retry loop. */
+export declare function withRecharge<T>(request: () => Promise<MinistoreResult<T>>, scope: Scope, bizOrderNo: string, enabled?: boolean): Promise<MinistoreResult<T>>;
+export {};

package/dist/ministore/transport.d.ts

@@ -0,0 +1,14 @@
+import { MinistoreRequestOptions } from './types';
+/** Internal per-operation guard; never a public option or a credential cache. */
+export declare const REQUEST_SCOPE_CHECK: unique symbol;
+interface RequestInit {
+    method: 'GET' | 'POST';
+    body?: unknown;
+    bizOrderNo?: string;
+}
+/** Validate before requesting credentials or opening native authorization UI. */
+export declare function ministoreApiBaseUrl(baseUrl?: string): string;
+/** Keep the same finite JSON contents across a recharge continuation. */
+export declare function snapshotRequestBody<T>(body: T): T;
+export declare function requestMinistore<T>(path: string, options: MinistoreRequestOptions, init: RequestInit, parse: (body: unknown) => T): Promise<T>;
+export {};

package/dist/ministore/types.d.ts

@@ -0,0 +1,166 @@
+export interface MinistoreRequestOptions {
+    /** Official HTTPS Aippy API origin with /aisdk/v1/; arbitrary proxies are rejected. */
+    baseUrl?: string;
+    /** Explicit App-Language. Omit to use the backend's default language. */
+    language?: string;
+    signal?: AbortSignal;
+}
+export type MinistoreReason = 'project_unresolved' | 'unknown_action' | 'inactive' | 'limit_reached' | 'limit_exceeded' | 'user_purchase_limit' | 'total_purchase_limit' | 'purchase_interval' | 'purchase_window_limit' | 'authorization_required' | 'not_consumable' | 'out_of_stock' | 'insufficient_balance' | 'payment_rejected' | 'idempotency_conflict' | (string & {});
+export type MinistoreResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    reason: MinistoreReason;
+    data: T;
+};
+export interface CatalogDisplay {
+    title: string;
+    subtitle: string;
+    iconUrl: string;
+}
+export type MinistoreAuthMode = 'none' | 'once' | 'every' | (string & {});
+export interface BenefitHolding {
+    orderId: string;
+    bizOrderNo: string;
+    value: unknown;
+    quantity: number;
+    createdAt: string;
+    source: 'PURCHASE' | 'FREE' | (string & {});
+}
+export interface BenefitItem {
+    itemId: string;
+    value: unknown;
+    orderId: string;
+    bizOrderNo: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface BenefitState {
+    benefitKey: string;
+    kind: 'fixed' | 'inventory' | 'item' | (string & {});
+    /** Entitlement snapshot; its shape is defined by the project. */
+    value: unknown;
+    quantity: number;
+    used: number;
+    display: CatalogDisplay;
+    holdings: BenefitHolding[];
+    items: BenefitItem[];
+}
+export interface CatalogItem extends Omit<BenefitState, 'holdings' | 'items'> {
+    price: number;
+    freeQuota: number;
+    /** Zero means no configured inventory limit. Fixed benefits follow server rules. */
+    maxQuantity: number;
+    consumable: boolean;
+    maxUserPurchase: number;
+    userPurchased: number;
+    maxTotalPurchase: number;
+    totalSold: number;
+    authMode: MinistoreAuthMode;
+    authRequired: boolean;
+    authorized: boolean;
+    authorizedAt: string;
+}
+export interface BenefitRecord {
+    id: string;
+    op: 'PURCHASE' | 'CONSUME' | (string & {});
+    benefitKey: string;
+    quantity: number;
+    charged: number;
+    projectName: string;
+    createdAt: string;
+    bizOrderNo: string;
+    value: unknown;
+}
+export interface MinistoreAuthorizationQuery {
+    benefitKey: string;
+    /** Required by mall for every-order authorization; optional for once. */
+    bizOrderNo?: string;
+}
+export interface MinistoreAuthorization {
+    benefitKey: string;
+    authMode: MinistoreAuthMode;
+    authorized: boolean;
+    authorizedAt: string;
+    bizOrderNo: string;
+    quantity: number;
+    amount: number;
+    expireAt: string;
+    used: boolean;
+}
+/** Native confirmation input. App login credentials and project IDs stay native. */
+export interface MinistoreAuthorizationInput {
+    operation: 'purchase' | 'consume';
+    benefitKey: string;
+    quantity: number;
+    /** Stable business order, distinct from the SDK-generated bridge requestId. */
+    bizOrderNo: string;
+    title: string;
+    buttonText: string;
+    content?: string;
+}
+export interface MinistoreCatalog {
+    enabled: boolean;
+    items: CatalogItem[];
+}
+export interface MinistoreBenefits {
+    benefits: BenefitState[];
+}
+export interface MinistoreRecordsPage {
+    records: BenefitRecord[];
+    nextCursor: string;
+}
+export interface MinistoreRecordsQuery {
+    cursor?: string;
+    limit?: number;
+}
+export interface MinistoreConsumeInput {
+    benefitKey: string;
+    /** SDK-generated when omitted; retain one order per action for retries. */
+    bizOrderNo?: string;
+    /** Buy the inventory deficit if needed; ignored for explicit itemIds. */
+    autoPurchase?: boolean;
+    /** Consume this many inventory units; defaults to one. */
+    quantity?: number;
+    /** For item benefits, consume these exact item IDs instead of FIFO selection. */
+    itemIds?: string[];
+}
+export interface MinistoreSettlement {
+    benefit: BenefitState;
+    charged: number;
+    walletBalance?: number;
+    idempotentHit: boolean;
+    bizOrderNo: string;
+}
+export interface MinistorePurchaseInput {
+    benefitKey: string;
+    quantity?: number;
+    /** For item benefits, the value of each purchased item. */
+    itemValues?: unknown[];
+    /** SDK-generated when omitted; retain one order per action for retries. */
+    bizOrderNo?: string;
+}
+export interface MinistoreUpdateItemInput {
+    benefitKey: string;
+    itemId: string;
+    value: unknown;
+}
+export interface MinistoreUpdateItem {
+    item?: BenefitItem;
+}
+export type MinistoreErrorKind = 'validation' | 'auth' | 'http' | 'network' | 'protocol' | 'unsupported' | 'abort' | 'authorization' | 'recharge';
+export interface MinistoreErrorDetails {
+    httpStatus?: number;
+    code?: number | string;
+    type?: string;
+    /** Native business refusal reason, distinct from transport type/code. */
+    reason?: MinistoreReason;
+    appMessage?: string;
+    traceId?: string;
+    retryAfterMs?: number;
+    bizOrderNo?: string;
+    settlementUnknown?: boolean;
+    authorizationUnknown?: boolean;
+    cause?: unknown;
+}

package/dist/ministore/update-item.d.ts

@@ -0,0 +1,3 @@
+import { MinistoreRequestOptions, MinistoreResult, MinistoreUpdateItem, MinistoreUpdateItemInput } from './types';
+/** Update one still-owned item; mall returns a business refusal in the envelope. */
+export declare function updateItem(input: MinistoreUpdateItemInput, options?: MinistoreRequestOptions): Promise<MinistoreResult<MinistoreUpdateItem>>;

package/dist/ministore/validation.d.ts

@@ -0,0 +1,19 @@
+import { BenefitItem, BenefitState, MinistoreAuthorization, MinistoreConsumeInput, MinistorePurchaseInput, MinistoreResult, MinistoreUpdateItemInput } from './types';
+export declare function object(value: unknown): Record<string, unknown>;
+export declare function string(value: unknown): string;
+export declare function integer(value: unknown, signed?: boolean): number;
+export declare function boolean(value: unknown): boolean;
+export declare function array<T>(value: unknown, parse: (value: unknown) => T): T[];
+export declare function benefitSummary(value: unknown): Omit<BenefitState, 'holdings' | 'items'>;
+export declare function benefitItem(value: unknown): BenefitItem;
+export declare function optionalBenefitItem(value: unknown): BenefitItem | undefined;
+export declare function benefit(value: unknown): BenefitState;
+export declare function result<T>(value: unknown, parse: (body: Record<string, unknown>) => T): MinistoreResult<T>;
+export declare function authorization(body: Record<string, unknown>): MinistoreAuthorization;
+export declare function action(input: MinistoreConsumeInput): void;
+export declare function purchaseAction(input: MinistorePurchaseInput): void;
+export declare function updateItemAction(input: MinistoreUpdateItemInput): void;
+export declare function identity(value: unknown, name: string, maxLength?: number): asserts value is string;
+export declare function quantity(value: unknown): number;
+export declare function isCursor(value: string): boolean;
+export declare function isItemId(value: string): boolean;

package/dist/ministore.d.ts

@@ -0,0 +1,2 @@
+export * from './ministore/index'
+export {}

package/dist/user/bridge.d.ts

@@ -1,6 +1,3 @@
-/**
- * User SDK Bridge
- */
 export { isInIframe } from '../utils/platform';
 export interface IOSUserCredentials {
     uid: string;
@@ -17,13 +14,11 @@ export interface IOSUserInfo {
     avatar?: string;
     [key: string]: unknown;
 }
-/** Get auth token async, auto-detects environment */
+/** Get a fresh auth token; native/iframe failures retain sign-in/upgrade UX. */
 export declare function getAuthTokenAsync(): Promise<string>;
-/** Get user info async, auto-detects environment */
 export declare function getUserInfoAsync(forceRefresh?: boolean): Promise<IOSUserInfo | null>;
-/** Get user info from parent window (iframe only, no cache) */
 export declare function getUserInfoFromParent(timeoutMs?: number): Promise<IOSUserInfo | null>;
-/** Called by iOS/Android: window.processUserCredentials(data) */
+/** Called by iOS/Android: window.processUserCredentials(data). */
 export declare function processUserCredentials(data: unknown): void;
-/** Called by iOS/Android: window.processUserInfo(data) */
+/** Called by iOS/Android: window.processUserInfo(data). */
 export declare function processUserInfo(data: unknown): void;

package/dist/user/config.d.ts

@@ -9,4 +9,6 @@ interface UserSdkConfig {
 export declare function initUserSdk(partial: Partial<UserSdkConfig>): void;
 export declare function setAuthToken(token: string): void;
 export declare function setCurrentUserId(userId: string | null): void;
+/** Internal identity check; API requests still acquire fresh credentials. */
+export declare function getCurrentUserId(): string | null;
 export {};

package/dist/user/index.js

@@ -1,5 +1,5 @@
-import { c as o, u as s } from "../hooks-D5lkty5r.js";
-import { g as f } from "../bridge-CtB9L5kL.js";
+import { c as o, u as s } from "../hooks-Ct9qEjM6.js";
+import { g as f } from "../bridge-D_-7nPNC.js";
 import { i as t } from "../app-version-checker-Bz7FrEZz.js";
 export {
   o as clearUserInfoCache,

package/dist/wallet-recharge-BqOljLWn.js

@@ -0,0 +1,140 @@
+import { a as v } from "./bridge-D_-7nPNC.js";
+const l = "wallet.showRecharge", R = 3e5;
+class s extends Error {
+  constructor(t, r) {
+    super(r), this.type = t, this.name = "WalletRechargeError";
+  }
+}
+const c = /* @__PURE__ */ new WeakMap();
+function h() {
+  if (typeof window > "u" || typeof document < "u" && document.visibilityState === "hidden")
+    return;
+  const e = window.webkit?.messageHandlers?.aippyListener;
+  if (typeof e?.postMessage == "function")
+    return { host: window, listener: e };
+}
+function y(e) {
+  e.host.processRechargeResult === e.dispatch && (e.hadPrevious ? e.host.processRechargeResult = e.previous : delete e.host.processRechargeResult), c.delete(e.host);
+}
+function p(e) {
+  const t = {
+    host: e,
+    previous: e.processRechargeResult,
+    hadPrevious: Object.prototype.hasOwnProperty.call(
+      e,
+      "processRechargeResult"
+    ),
+    dispatch: (r) => {
+      const a = r && typeof r == "object" && !Array.isArray(r) ? r : void 0;
+      if (a?.status === "success" ? t.succeeded = !0 : a?.status === "closed" && typeof a.purchased == "boolean" ? (y(t), t.succeeded && !a.purchased ? t.waiter?.reject(
+        new s("protocol", "Inconsistent recharge closure")
+      ) : t.waiter?.resolve(a.purchased)) : (t.quarantined = !0, t.waiter?.reject(
+        new s("protocol", "Invalid recharge result")
+      )), typeof t.previous == "function")
+        try {
+          t.previous.call(e, r);
+        } catch {
+          console.warn("Native recharge observer failed");
+        }
+    },
+    succeeded: !1,
+    quarantined: !1
+  };
+  return e.processRechargeResult = t.dispatch, c.set(e, t), t;
+}
+function m() {
+  let e;
+  try {
+    if (typeof document < "u" && document.visibilityState === "hidden")
+      return;
+    const t = h();
+    if (t) {
+      if (c.has(t.host)) return;
+      e = p(t.host), t.listener.postMessage({ command: l });
+      return;
+    }
+    const r = v();
+    if (!r) return;
+    window.parent.postMessage({ type: l }, r);
+  } catch {
+    e && (e.quarantined = !0), console.warn("Failed to request native recharge");
+  }
+}
+function E(e) {
+  return new Promise((t, r) => {
+    if (e?.aborted) {
+      r(new s("cancelled", "Recharge wait cancelled"));
+      return;
+    }
+    const a = h();
+    if (!a) {
+      r(
+        new s("unavailable", "Native recharge is unavailable")
+      );
+      return;
+    }
+    let n = c.get(a.host);
+    if (n?.waiter || n?.quarantined) {
+      r(
+        new s(
+          "busy",
+          "Another recharge continuation is active"
+        )
+      );
+      return;
+    }
+    if (n && a.host.processRechargeResult !== n.dispatch) {
+      n.quarantined = !0, r(
+        new s(
+          "protocol",
+          "Native recharge callback was replaced"
+        )
+      );
+      return;
+    }
+    const f = !n;
+    try {
+      n ?? (n = p(a.host));
+    } catch {
+      r(
+        new s(
+          "unavailable",
+          "Native recharge callback is unavailable"
+        )
+      );
+      return;
+    }
+    let d = !1;
+    const o = (i, g = !1) => {
+      i && (n.quarantined = !0), !d && (d = !0, clearTimeout(w), e?.removeEventListener("abort", u), i ? r(i) : t(g));
+    }, u = () => o(new s("cancelled", "Recharge wait cancelled")), w = setTimeout(
+      () => o(
+        new s(
+          "timeout",
+          "Recharge closure was not received"
+        )
+      ),
+      R
+    );
+    if (n.waiter = {
+      resolve: (i) => o(void 0, i),
+      reject: (i) => o(i)
+    }, e?.addEventListener("abort", u, { once: !0 }), e?.aborted) {
+      u();
+      return;
+    }
+    if (f)
+      try {
+        a.listener.postMessage({ command: l });
+      } catch {
+        o(
+          new s("bridge", "Native recharge request failed")
+        );
+      }
+  });
+}
+export {
+  s as W,
+  m as s,
+  E as w
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/runtime",
-  "version": "0.4.2-dev.2",
+  "version": "0.4.2-dev.4",
   "description": "Aippy Runtime SDK - Runtime SDK for Aippy projects",
   "private": false,
   "type": "module",
@@ -40,6 +40,10 @@
       "import": "./dist/ai/index.js",
       "types": "./dist/ai.d.ts"
     },
+    "./ministore": {
+      "types": "./dist/ministore/index.d.ts",
+      "import": "./dist/ministore/index.js"
+    },
     "./user": {
       "import": "./dist/user/index.js",
       "types": "./dist/user/index.d.ts"

package/dist/ai/credits.d.ts

@@ -1,12 +0,0 @@
-import { AippyOpenAIConfig } from './shared';
-export interface CreditsRequestOptions extends AippyOpenAIConfig {
-    signal?: AbortSignal;
-}
-export interface DeductCreditsOptions extends CreditsRequestOptions {
-    /** One UUID per business action. Retries must reuse both the UUID and amount. */
-    eventId: string;
-}
-/** Return the authenticated user's VIP plus regular credit balance. */
-export declare function getCredits(options?: CreditsRequestOptions): Promise<number>;
-/** Deduct a positive integer amount. The server checks the balance atomically. */
-export declare function deductCredits(amount: number, options: DeductCreditsOptions): Promise<void>;