@nosslabs/iap 0.3.0

package/dist/index.js

@@ -0,0 +1,2067 @@
+import { Capacitor } from '@capacitor/core';
+import 'cordova-plugin-purchase';
+import { z } from 'zod';
+import { Preferences } from '@capacitor/preferences';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/errors.ts
+function errorHint(code) {
+  return HINTS[code];
+}
+function isIAPError(error) {
+  return error instanceof IAPError;
+}
+function toIAPError(error, fallbackMessage, fallbackCode) {
+  if (isIAPError(error)) return error;
+  return new IAPError({
+    code: fallbackCode,
+    message: fallbackMessage,
+    cause: error
+  });
+}
+var IAPErrorCode, RECOVERABLE_CODES, HINTS, IAPError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    IAPErrorCode = {
+      // Configuration
+      INVALID_CONFIG: "INVALID_CONFIG",
+      NOT_INITIALIZED: "NOT_INITIALIZED",
+      // Native plugin
+      PLATFORM_NOT_SUPPORTED: "PLATFORM_NOT_SUPPORTED",
+      BILLING_NOT_AVAILABLE: "BILLING_NOT_AVAILABLE",
+      PRODUCT_NOT_FOUND: "PRODUCT_NOT_FOUND",
+      USER_CANCELLED: "USER_CANCELLED",
+      PURCHASE_PENDING: "PURCHASE_PENDING",
+      ALREADY_PURCHASED: "ALREADY_PURCHASED",
+      STORE_ERROR: "STORE_ERROR",
+      UNACKNOWLEDGED_PENDING: "UNACKNOWLEDGED_PENDING",
+      // Concurrency
+      ALREADY_IN_PROGRESS: "ALREADY_IN_PROGRESS",
+      // Backend
+      BACKEND_UNAVAILABLE: "BACKEND_UNAVAILABLE",
+      BACKEND_TIMEOUT: "BACKEND_TIMEOUT",
+      BACKEND_AUTH_FAILED: "BACKEND_AUTH_FAILED",
+      /** Backend reachable but the response was rejected (non-transient 4xx other
+       *  than auth, malformed JSON, schema violation, 204 No Content on a JSON
+       *  endpoint). Fix the request shape or the backend; do not retry. */
+      BACKEND_BAD_RESPONSE: "BACKEND_BAD_RESPONSE",
+      VERIFICATION_REJECTED: "VERIFICATION_REJECTED",
+      // Storage
+      STORAGE_ERROR: "STORAGE_ERROR",
+      // appUserId pre-attach
+      /**
+       * The supplied `appUserId` (literal or fetcher-returned) is not a valid
+       * UUID v4. Apple requires a UUID for `appAccountToken`; we enforce the
+       * same constraint cross-platform for a consistent contract.
+       */
+      INVALID_APP_USER_ID: "INVALID_APP_USER_ID",
+      /**
+       * The async `appUserId` fetcher threw or rejected. Original error is
+       * attached as `cause` so the caller can introspect (network failure,
+       * backend 5xx, etc.).
+       */
+      APP_USER_ID_FETCH_FAILED: "APP_USER_ID_FETCH_FAILED"
+    };
+    RECOVERABLE_CODES = /* @__PURE__ */ new Set([
+      IAPErrorCode.BACKEND_UNAVAILABLE,
+      IAPErrorCode.BACKEND_TIMEOUT,
+      IAPErrorCode.STORAGE_ERROR,
+      IAPErrorCode.UNACKNOWLEDGED_PENDING
+    ]);
+    HINTS = {
+      // Configuration
+      INVALID_CONFIG: "Check the field paths reported above against the IAPConfig schema (see /api/types).",
+      NOT_INITIALIZED: "Call iap.initialize() before this method, or recreate the instance after destroy().",
+      // Native plugin
+      PLATFORM_NOT_SUPPORTED: "In-app purchases run on iOS/Android only. Web is no-op by design \u2014 guard your purchase UI behind Capacitor.isNativePlatform().",
+      BILLING_NOT_AVAILABLE: "cordova-plugin-purchase failed to initialize. Confirm the plugin is installed and `npx cap sync` has run; check device sandbox/test account is signed in.",
+      PRODUCT_NOT_FOUND: "Ensure the productId is registered in App Store Connect / Play Console AND in your createIAP({ products }) config.",
+      USER_CANCELLED: "No action needed \u2014 the user dismissed the native purchase sheet.",
+      PURCHASE_PENDING: "Android only: payment is awaiting external clearance (e.g. cash payment, bank verification). The backend will receive a Google RTDN webhook when it clears; call iap.refresh() afterward.",
+      ALREADY_PURCHASED: "The user already owns this non-consumable. Use iap.restorePurchases() to re-grant entitlement, or query iap.hasEntitlement(key) before showing the purchase CTA.",
+      STORE_ERROR: "Native store reported an error. Check device connectivity, sandbox account state, and the cause field for the underlying plugin error.",
+      UNACKNOWLEDGED_PENDING: "A Google purchase has been unacknowledged for >2 days and is at risk of auto-refund. Verify the backend can be reached and call iap.refresh() to retry acknowledgement.",
+      // Concurrency
+      ALREADY_IN_PROGRESS: "Await the in-flight iap.purchase(productId) before starting another for the same product.",
+      // Backend
+      BACKEND_UNAVAILABLE: "Backend is unreachable or returning 5xx. Retry will happen automatically per config.retries; if persistent, check your server.",
+      BACKEND_TIMEOUT: "Backend did not respond within timeoutMs. Increase config.backend.timeoutMs or check server response time.",
+      BACKEND_AUTH_FAILED: "Backend returned 401/403. Check that getAuthHeaders() returns a valid Bearer token and that the backend recognizes it.",
+      BACKEND_BAD_RESPONSE: "Backend response did not match the expected shape. Confirm /api/iap/* endpoints follow the contract documented at /guide/backend-contract.",
+      VERIFICATION_REJECTED: "Backend rejected the transaction (valid:false). The transaction stays in unfinished_transactions for retry; the user may have switched accounts or the receipt may be invalid.",
+      // Storage
+      STORAGE_ERROR: "Capacitor Preferences write failed. Check device storage availability; the in-memory state is still updated, only persistence failed.",
+      // appUserId pre-attach
+      INVALID_APP_USER_ID: "appUserId must be a UUID v4 (e.g. crypto.randomUUID()). Apple requires this for appAccountToken; we enforce the same on Android for consistency.",
+      APP_USER_ID_FETCH_FAILED: "The async appUserId fetcher threw or rejected. Inspect the cause field for the underlying error (network failure, backend non-2xx, parse failure)."
+    };
+    IAPError = class _IAPError extends Error {
+      code;
+      recoverable;
+      cause;
+      constructor(options) {
+        const hint = options.includeHint === false ? "" : HINTS[options.code] ?? "";
+        const fullMessage = hint ? `${options.message}
+
+Hint: ${hint}` : options.message;
+        super(fullMessage);
+        this.name = "IAPError";
+        this.code = options.code;
+        this.cause = options.cause;
+        this.recoverable = options.recoverable ?? RECOVERABLE_CODES.has(options.code);
+        Object.setPrototypeOf(this, _IAPError.prototype);
+      }
+    };
+  }
+});
+function getPlatform() {
+  const platform = Capacitor.getPlatform();
+  if (platform === "ios" || platform === "android") return platform;
+  return "web";
+}
+function isNative() {
+  const platform = getPlatform();
+  return platform === "ios" || platform === "android";
+}
+var init_platform = __esm({
+  "src/lib/platform.ts"() {
+  }
+});
+
+// src/adapters/native/cdv/native-adapter.ts
+var native_adapter_exports = {};
+__export(native_adapter_exports, {
+  CdvNativeAdapter: () => CdvNativeAdapter
+});
+function getCdv() {
+  const candidate = globalThis.CdvPurchase;
+  if (!candidate || !candidate.store) {
+    throw new IAPError({
+      code: IAPErrorCode.BILLING_NOT_AVAILABLE,
+      message: "cordova-plugin-purchase is not available. Ensure the plugin is installed and `npx cap sync` has run."
+    });
+  }
+  return candidate;
+}
+function currentCdvPlatform() {
+  const cdv = getCdv();
+  const platform = getPlatform();
+  if (platform === "android") return cdv.Platform.GOOGLE_PLAY;
+  return cdv.Platform.APPLE_APPSTORE;
+}
+function mapProductType(type) {
+  const cdv = getCdv();
+  switch (type) {
+    case "subscription":
+      return cdv.ProductType.PAID_SUBSCRIPTION;
+    case "consumable":
+      return cdv.ProductType.CONSUMABLE;
+    default:
+      return cdv.ProductType.NON_CONSUMABLE;
+  }
+}
+function inferProductType(tx, configured) {
+  const id = tx.products[0]?.id;
+  if (!id) return "product";
+  const match = configured.find((p) => p.id === id);
+  return match?.type ?? "product";
+}
+function normalizeProduct(p, type) {
+  const offer = p.getOffer();
+  const phase = offer?.pricingPhases?.[0];
+  const priceMicros = phase?.priceMicros?.toString() ?? "0";
+  const priceString = phase?.price ?? "";
+  const currency = phase?.currency ?? "";
+  return {
+    id: p.id,
+    type,
+    title: p.title ?? p.id,
+    description: p.description ?? "",
+    priceString,
+    priceMicros,
+    currency
+  };
+}
+function normalizeTransaction(tx, productType, token) {
+  const platform = tx.platform === "ios-appstore" ? "apple" : "google";
+  const productId = tx.products[0]?.id ?? "";
+  const result = {
+    platform,
+    productId,
+    token,
+    productType,
+    raw: tx
+  };
+  if (platform === "google") {
+    const packageName = googlePackageName(tx);
+    if (packageName) result.packageName = packageName;
+  }
+  return result;
+}
+function googlePackageName(tx) {
+  const googleTx = tx;
+  return googleTx.nativePurchase?.packageName;
+}
+function transactionToken(tx) {
+  if (tx.platform === "ios-appstore") {
+    return tx.transactionId || null;
+  }
+  const googleTx = tx;
+  return googleTx.nativePurchase?.purchaseToken ?? googleTx.parentReceipt?.purchaseToken ?? tx.transactionId ?? null;
+}
+function mapOrderError(err, productId) {
+  const cdv = getCdv();
+  const cancelled = cdv.ErrorCode?.PAYMENT_CANCELLED;
+  if (cancelled !== void 0 && err.code === cancelled) {
+    return new IAPError({
+      code: IAPErrorCode.USER_CANCELLED,
+      message: "User cancelled the native purchase sheet.",
+      cause: err
+    });
+  }
+  return new IAPError({
+    code: IAPErrorCode.STORE_ERROR,
+    message: err.message ?? `order() failed for ${productId}.`,
+    cause: err
+  });
+}
+var CdvNativeAdapter;
+var init_native_adapter = __esm({
+  "src/adapters/native/cdv/native-adapter.ts"() {
+    init_errors();
+    init_platform();
+    CdvNativeAdapter = class {
+      products;
+      bootstrapped = false;
+      bootstrapping = null;
+      pendingFinish = /* @__PURE__ */ new Map();
+      /** Long-lived bootstrap-time .approved() listener — kept for dispose(). */
+      bootstrapApprovedHandler = null;
+      constructor(opts) {
+        this.products = opts.products;
+      }
+      async isAvailable() {
+        try {
+          await this.bootstrap();
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async getProducts(requests) {
+        if (requests.length === 0) return [];
+        const store = await this.ensureStore();
+        await store.update();
+        const out = [];
+        for (const req of requests) {
+          const native = store.get(req.id);
+          if (!native) continue;
+          out.push(normalizeProduct(native, req.type));
+        }
+        return out;
+      }
+      async purchaseProduct(opts) {
+        const store = await this.ensureStore();
+        const native = store.get(opts.productId);
+        if (!native) {
+          throw new IAPError({
+            code: IAPErrorCode.PRODUCT_NOT_FOUND,
+            message: `Product "${opts.productId}" not registered or not available from the store.`
+          });
+        }
+        const offer = opts.androidPlanId ? native.getOffer(opts.androidPlanId) ?? native.getOffer() : native.getOffer();
+        if (!offer) {
+          throw new IAPError({
+            code: IAPErrorCode.PRODUCT_NOT_FOUND,
+            message: `Product "${opts.productId}" has no purchasable offer${opts.androidPlanId ? ` (planId="${opts.androidPlanId}")` : ""}.`
+          });
+        }
+        return new Promise((resolve, reject) => {
+          let settled = false;
+          const cleanup = () => {
+            store.off(handleApproved);
+          };
+          const handleApproved = (tx) => {
+            if (settled) return;
+            if (!tx.products.some((p) => p.id === opts.productId)) return;
+            const token = transactionToken(tx);
+            if (!token) {
+              settled = true;
+              cleanup();
+              reject(
+                new IAPError({
+                  code: IAPErrorCode.STORE_ERROR,
+                  message: `Approved transaction for "${opts.productId}" has no token; cannot verify.`
+                })
+              );
+              return;
+            }
+            settled = true;
+            cleanup();
+            const normalized = normalizeTransaction(tx, opts.productType, token);
+            this.pendingFinish.set(token, tx);
+            resolve(normalized);
+          };
+          store.when().approved(handleApproved);
+          const additionalData = opts.appAccountToken ? { applicationUsername: opts.appAccountToken } : void 0;
+          void Promise.resolve(offer.order(additionalData)).then((err) => {
+            if (settled) return;
+            if (!err) return;
+            settled = true;
+            cleanup();
+            reject(mapOrderError(err, opts.productId));
+          }).catch((cause) => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            reject(
+              new IAPError({
+                code: IAPErrorCode.STORE_ERROR,
+                message: `order() rejected for ${opts.productId}.`,
+                cause
+              })
+            );
+          });
+        });
+      }
+      async getOwnedTransactions() {
+        const store = await this.ensureStore();
+        await store.restorePurchases();
+        const out = [];
+        for (const tx of store.localTransactions) {
+          if (tx.state !== getCdv().TransactionState.APPROVED) continue;
+          const token = transactionToken(tx);
+          if (!token) continue;
+          const normalized = normalizeTransaction(tx, inferProductType(tx, this.products), token);
+          this.pendingFinish.set(token, tx);
+          out.push(normalized);
+        }
+        return out;
+      }
+      async acknowledge(transaction) {
+        const cdvTx = this.pendingFinish.get(transaction.token);
+        if (!cdvTx) {
+          return;
+        }
+        try {
+          await cdvTx.finish();
+        } catch (cause) {
+          throw new IAPError({
+            code: IAPErrorCode.STORE_ERROR,
+            message: `Failed to finish transaction for ${transaction.productId}.`,
+            cause,
+            recoverable: true
+          });
+        }
+        this.pendingFinish.delete(transaction.token);
+      }
+      async manageSubscriptions() {
+        const store = await this.ensureStore();
+        const err = await store.manageSubscriptions();
+        if (err) {
+          throw new IAPError({
+            code: IAPErrorCode.STORE_ERROR,
+            message: err.message ?? "Failed to open subscription management."
+          });
+        }
+      }
+      async dispose() {
+        if (this.bootstrapApprovedHandler) {
+          try {
+            const cdv = globalThis.CdvPurchase;
+            cdv?.store?.off(this.bootstrapApprovedHandler);
+          } catch {
+          }
+          this.bootstrapApprovedHandler = null;
+        }
+        this.pendingFinish.clear();
+        this.bootstrapped = false;
+        this.bootstrapping = null;
+      }
+      // ----- internals -----
+      async ensureStore() {
+        await this.bootstrap();
+        return getCdv().store;
+      }
+      bootstrap() {
+        if (this.bootstrapped) return Promise.resolve();
+        if (this.bootstrapping) return this.bootstrapping;
+        this.bootstrapping = (async () => {
+          const cdv = getCdv();
+          const platform = currentCdvPlatform();
+          cdv.store.register(
+            this.products.map((p) => ({
+              id: p.id,
+              type: mapProductType(p.type),
+              platform
+            }))
+          );
+          const errors = await cdv.store.initialize([platform]);
+          if (errors && errors.length > 0) {
+            const first = errors[0];
+            throw new IAPError({
+              code: IAPErrorCode.BILLING_NOT_AVAILABLE,
+              message: first?.message ?? "cordova-plugin-purchase initialize() reported errors."
+            });
+          }
+          const handler = (tx) => {
+            const token = transactionToken(tx);
+            if (!token) return;
+            if (!this.pendingFinish.has(token)) {
+              this.pendingFinish.set(token, tx);
+            }
+          };
+          this.bootstrapApprovedHandler = handler;
+          cdv.store.when().approved(handler);
+          await cdv.store.update();
+          this.bootstrapped = true;
+        })();
+        return this.bootstrapping;
+      }
+    };
+  }
+});
+
+// src/adapters/backend/index.ts
+init_errors();
+
+// src/adapters/backend/http-adapter.ts
+init_errors();
+
+// src/adapters/backend/http-client.ts
+init_errors();
+
+// src/lib/redact.ts
+var VISIBLE_PREFIX_CHARS = 8;
+var ELLIPSIS = "\u2026";
+function maskToken(token) {
+  if (!token) return "";
+  if (token.length <= VISIBLE_PREFIX_CHARS) return token;
+  return token.slice(0, VISIBLE_PREFIX_CHARS) + ELLIPSIS;
+}
+function maskCredential(value) {
+  if (!value) return "";
+  if (value.length <= VISIBLE_PREFIX_CHARS) return ELLIPSIS;
+  return value.slice(0, VISIBLE_PREFIX_CHARS) + ELLIPSIS;
+}
+var SENSITIVE_HEADER_PATTERNS = [
+  /^authorization$/i,
+  /^cookie$/i,
+  /^x-api-key$/i,
+  /^x-auth-token$/i
+];
+function redactHeaders(headers) {
+  const out = {};
+  for (const [name, value] of Object.entries(headers)) {
+    out[name] = isSensitiveHeader(name) ? redactHeaderValue(value) : value;
+  }
+  return out;
+}
+function isSensitiveHeader(name) {
+  return SENSITIVE_HEADER_PATTERNS.some((pattern) => pattern.test(name));
+}
+function redactHeaderValue(value) {
+  const bearerMatch = value.match(/^(Bearer|Basic|Token)\s+(.+)$/i);
+  if (bearerMatch) {
+    const [, scheme, credential] = bearerMatch;
+    return `${scheme} ${maskCredential(credential ?? "")}`;
+  }
+  return maskCredential(value);
+}
+
+// src/adapters/backend/http-client.ts
+var RETRY_BACKOFF_MS = [1e3, 2e3, 4e3];
+var HttpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    const provided = opts.fetch;
+    if (provided) {
+      this.fetchImpl = provided;
+    } else if (typeof globalThis.fetch === "function") {
+      this.fetchImpl = globalThis.fetch.bind(globalThis);
+    } else {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: "globalThis.fetch is unavailable; pass a fetch implementation via config."
+      });
+    }
+  }
+  opts;
+  fetchImpl;
+  /**
+   * Execute the request and parse the response with the given zod schema.
+   * Returns the validated, transformed result.
+   */
+  async request(req, schema) {
+    const transformed = this.opts.requestTransform ? await this.opts.requestTransform(req) : req;
+    const base = this.opts.baseUrl.replace(/\/+$/, "");
+    const path = transformed.path.startsWith("/") ? transformed.path : `/${transformed.path}`;
+    const url = `${base}${path}`;
+    const auth = await this.opts.getAuthHeaders();
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json",
+      ...auth,
+      ...transformed.headers ?? {}
+    };
+    let lastError;
+    const maxAttempts = this.opts.retries + 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await this.singleAttempt(url, transformed, headers, schema);
+      } catch (error) {
+        if (!(error instanceof IAPError) || !error.recoverable) {
+          throw error;
+        }
+        lastError = error;
+        const remaining = maxAttempts - attempt;
+        if (remaining <= 0) break;
+        const delayMs = RETRY_BACKOFF_MS[attempt - 1] ?? RETRY_BACKOFF_MS[RETRY_BACKOFF_MS.length - 1] ?? 4e3;
+        this.opts.logger.debug(
+          `HTTP ${transformed.method} ${transformed.path} retry ${attempt}/${this.opts.retries} after ${delayMs}ms (${error.code})`
+        );
+        await sleep(delayMs);
+      }
+    }
+    throw lastError ?? new IAPError({
+      code: IAPErrorCode.BACKEND_UNAVAILABLE,
+      message: "Backend request failed with no recorded error."
+    });
+  }
+  async singleAttempt(url, req, headers, schema) {
+    this.opts.logger.debug(`HTTP ${req.method} ${req.path}`, { headers: redactHeaders(headers) });
+    let response;
+    try {
+      response = await this.fetchWithTimeout(url, {
+        method: req.method,
+        headers,
+        body: req.body !== void 0 ? JSON.stringify(req.body) : void 0
+      });
+    } catch (cause) {
+      const isAbort = cause?.name === "AbortError";
+      throw new IAPError({
+        code: isAbort ? IAPErrorCode.BACKEND_TIMEOUT : IAPErrorCode.BACKEND_UNAVAILABLE,
+        message: isAbort ? `Backend request timed out after ${this.opts.timeoutMs}ms.` : "Network error while calling backend.",
+        cause,
+        recoverable: true
+      });
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new IAPError({
+        code: IAPErrorCode.BACKEND_AUTH_FAILED,
+        message: `Backend auth failed (${response.status}).`
+      });
+    }
+    if (!response.ok) {
+      const transient = response.status === 408 || response.status === 429 || response.status >= 500;
+      throw new IAPError({
+        // Transient failures (5xx, 408, 429) → BACKEND_UNAVAILABLE so the
+        // retry loop picks them up. Non-transient (other 4xx after auth has
+        // been ruled out) → BACKEND_BAD_RESPONSE so the orchestrator can
+        // surface "fix the request" rather than "try again later".
+        code: transient ? IAPErrorCode.BACKEND_UNAVAILABLE : IAPErrorCode.BACKEND_BAD_RESPONSE,
+        message: `Backend returned ${response.status} ${response.statusText}.`,
+        recoverable: transient
+      });
+    }
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      throw new IAPError({
+        code: IAPErrorCode.BACKEND_BAD_RESPONSE,
+        message: `Backend returned ${response.status} with empty body; expected JSON for ${req.path}.`
+      });
+    }
+    let raw;
+    try {
+      raw = await response.json();
+    } catch (cause) {
+      throw new IAPError({
+        code: IAPErrorCode.BACKEND_BAD_RESPONSE,
+        message: "Backend response was not valid JSON.",
+        cause
+      });
+    }
+    const transformed = this.opts.responseTransform ? await this.opts.responseTransform(raw) : raw;
+    const parsed = schema.safeParse(transformed);
+    if (!parsed.success) {
+      throw new IAPError({
+        code: IAPErrorCode.BACKEND_BAD_RESPONSE,
+        message: `Backend response failed validation: ${parsed.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ")}`,
+        cause: parsed.error
+      });
+    }
+    return parsed.data;
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs);
+    try {
+      return await this.fetchImpl(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var productTypeSchema = z.enum(["subscription", "product", "consumable"]);
+var configuredProductSchema = z.object({
+  id: z.string().min(1),
+  type: productTypeSchema,
+  /**
+   * Optional. Used only by the Android native adapter to disambiguate which
+   * base plan to purchase for multi-plan subscription products (Google Play
+   * Billing). iOS ignores it. When omitted on Android, the native adapter
+   * falls back to `native.getOffer()` (the default offer) — fine for
+   * single-plan subscriptions and for non-subscription products.
+   *
+   * Recommended to set explicitly when a single subscription product has
+   * multiple base plans (e.g. monthly + yearly under one product id).
+   */
+  androidPlanId: z.string().min(1).optional()
+});
+var configuredProductsArraySchema = z.array(configuredProductSchema).min(1);
+var backendEndpointsSchema = z.object({
+  /**
+   * Optional. Set when the consumer supports iOS purchases. iOS-less
+   * (e.g. Android-only) configs may omit it; the HTTP adapter will throw
+   * `INVALID_CONFIG` at runtime if `verifyApple()` is invoked without this
+   * endpoint configured. At least one of `verifyApple` or `verifyGoogle`
+   * must be set.
+   */
+  verifyApple: z.string().min(1).optional(),
+  /**
+   * Optional. Set when the consumer supports Android purchases.
+   * Android-less (e.g. iOS-only) configs may omit it; the HTTP adapter will
+   * throw `INVALID_CONFIG` at runtime if `verifyGoogle()` is invoked
+   * without this endpoint configured. At least one of `verifyApple` or
+   * `verifyGoogle` must be set.
+   */
+  verifyGoogle: z.string().min(1).optional(),
+  entitlements: z.string().min(1),
+  restore: z.string().min(1),
+  /**
+   * Optional. When set, the library fetches the SKU manifest from this
+   * endpoint during `initialize()` if `products` is omitted from config.
+   * See `docs/guide/backend-contract.md` for the response shape.
+   */
+  products: z.string().min(1).optional()
+}).superRefine((data, ctx) => {
+  if (!data.verifyApple && !data.verifyGoogle) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "At least one of backend.endpoints.verifyApple or backend.endpoints.verifyGoogle must be set.",
+      path: []
+    });
+  }
+});
+var backendConfigSchema = z.object({
+  /**
+   * Custom backend transport. If provided, all HTTP-specific fields below
+   * are ignored and the library uses this object directly for backend
+   * operations. Must implement `BackendAdapter`.
+   */
+  adapter: z.unknown().optional(),
+  // ----- HTTP-specific fields (used when `adapter` is not provided) -----
+  baseUrl: z.string().url().optional(),
+  endpoints: backendEndpointsSchema.optional(),
+  /**
+   * Returns auth headers to merge into every backend request. Called fresh
+   * per request so token refresh works automatically. Type is checked at
+   * runtime via shape guard, not zod (zod can't validate function contracts).
+   */
+  getAuthHeaders: z.unknown().optional(),
+  /** Pre-send request transform. See {@link BackendConfig} for the typed shape. */
+  requestTransform: z.unknown().optional(),
+  /** Post-receive response transform. See {@link BackendConfig} for the typed shape. */
+  responseTransform: z.unknown().optional(),
+  entitlementSchema: z.unknown().optional(),
+  // ----- Common (apply to both HTTP and custom adapters where relevant) -----
+  timeoutMs: z.number().int().positive().default(1e4),
+  retries: z.number().int().min(0).max(5).default(2)
+}).superRefine((data, ctx) => {
+  if (data.adapter !== void 0) return;
+  if (!data.baseUrl) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "backend.baseUrl is required when no custom adapter is provided.",
+      path: ["baseUrl"]
+    });
+  }
+  if (!data.endpoints) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "backend.endpoints is required when no custom adapter is provided.",
+      path: ["endpoints"]
+    });
+  }
+  if (typeof data.getAuthHeaders !== "function") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "backend.getAuthHeaders must be a function (() => Record<string, string> | Promise<Record<string, string>>) when no custom adapter is provided.",
+      path: ["getAuthHeaders"]
+    });
+  }
+});
+var storageConfigSchema = z.object({
+  type: z.enum(["preferences", "memory", "custom"]).default("preferences"),
+  namespace: z.string().min(1).default("nosslabs_iap"),
+  adapter: z.unknown().optional()
+});
+var optionsConfigSchema = z.object({
+  refreshOnResume: z.boolean().default(true),
+  entitlementCacheTtlMs: z.number().int().positive().default(60 * 60 * 1e3),
+  recoverUnfinishedTransactions: z.boolean().default(true),
+  /**
+   * Cap on how many unfinished transactions recovery inspects per launch.
+   * Defends against pathological growth if the consumer's backend has been
+   * down for an extended period and the unfinished list keeps growing.
+   * Excess entries stay in storage and are processed on subsequent launches.
+   */
+  recoveryMaxBatch: z.number().int().positive().default(50),
+  productPriceCacheTtlMs: z.number().int().positive().default(24 * 60 * 60 * 1e3),
+  logLevel: z.enum(["silent", "error", "warn", "info", "debug"]).default("info"),
+  logger: z.unknown().optional()
+});
+var iapConfigSchema = z.object({
+  /**
+   * Static SKU manifest. Optional: when omitted, the library calls
+   * `backend.adapter.listProducts()` (custom adapter) or GETs
+   * `backend.endpoints.products` (HTTP) during `initialize()`. Configs
+   * without either path throw `INVALID_CONFIG` at parse time.
+   */
+  products: z.array(configuredProductSchema).min(1).optional(),
+  backend: backendConfigSchema,
+  storage: storageConfigSchema.default({ type: "preferences", namespace: "nosslabs_iap" }),
+  options: optionsConfigSchema.default({
+    refreshOnResume: true,
+    entitlementCacheTtlMs: 60 * 60 * 1e3,
+    recoverUnfinishedTransactions: true,
+    recoveryMaxBatch: 50,
+    productPriceCacheTtlMs: 24 * 60 * 60 * 1e3,
+    logLevel: "info"
+  })
+}).superRefine((data, ctx) => {
+  if (data.products !== void 0) return;
+  const adapter = data.backend.adapter;
+  const adapterCanList = adapter && typeof adapter.listProducts === "function";
+  const httpCanList = !data.backend.adapter && data.backend.endpoints?.products;
+  if (!adapterCanList && !httpCanList) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "products is required unless the backend can supply it: set backend.endpoints.products (HTTP) or implement listProducts() on a custom adapter.",
+      path: ["products"]
+    });
+  }
+});
+var entitlementBaseSchema = z.object({
+  key: z.string().min(1),
+  productId: z.string().min(1),
+  expiresAt: z.string().nullable()
+});
+
+// src/adapters/backend/types.ts
+var passthroughEntitlementSchema = entitlementBaseSchema.passthrough();
+var verifiedTransactionSchema = z.object({
+  id: z.string(),
+  productId: z.string(),
+  /** ISO 8601 timestamp; null for non-expiring transactions. */
+  expiresAt: z.string().nullable().optional()
+}).passthrough();
+var verifySuccessSchema = z.object({
+  valid: z.literal(true),
+  entitlements: z.array(passthroughEntitlementSchema),
+  transaction: verifiedTransactionSchema
+}).passthrough();
+var verifyFailureSchema = z.object({
+  valid: z.literal(false),
+  /** Stable machine-readable code, e.g. "TRANSACTION_NOT_FOUND". */
+  error: z.string(),
+  /** Optional human-readable detail. */
+  message: z.string().optional()
+}).passthrough();
+var verifyResponseSchema = z.discriminatedUnion("valid", [
+  verifySuccessSchema,
+  verifyFailureSchema
+]);
+var restoreSuccessSchema = z.object({
+  valid: z.literal(true),
+  entitlements: z.array(passthroughEntitlementSchema)
+}).passthrough();
+var restoreResponseSchema = z.discriminatedUnion("valid", [
+  restoreSuccessSchema,
+  verifyFailureSchema
+]);
+var entitlementsResponseSchema = z.object({ entitlements: z.array(passthroughEntitlementSchema) }).passthrough();
+var productManifestResponseSchema = z.object({ products: configuredProductsArraySchema }).passthrough();
+function isBackendAdapter(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.verifyApple === "function" && typeof candidate.verifyGoogle === "function" && typeof candidate.getEntitlements === "function" && typeof candidate.restore === "function";
+}
+
+// src/adapters/backend/http-adapter.ts
+var HttpBackendAdapter = class {
+  http;
+  endpoints;
+  constructor(opts) {
+    this.endpoints = opts.endpoints;
+    const httpClientOpts = {
+      baseUrl: opts.baseUrl,
+      getAuthHeaders: opts.getAuthHeaders,
+      timeoutMs: opts.timeoutMs,
+      retries: opts.retries,
+      logger: opts.logger,
+      ...opts.requestTransform ? { requestTransform: opts.requestTransform } : {},
+      ...opts.responseTransform ? { responseTransform: opts.responseTransform } : {},
+      ...opts.fetch ? { fetch: opts.fetch } : {}
+    };
+    this.http = new HttpClient(httpClientOpts);
+  }
+  async verifyApple(req) {
+    if (!this.endpoints.verifyApple) {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: "HttpBackendAdapter.verifyApple() requires backend.endpoints.verifyApple to be configured. Set it on iOS-supporting builds, or skip Apple purchases on this build."
+      });
+    }
+    const result = await this.http.request(
+      { method: "POST", path: this.endpoints.verifyApple, body: req },
+      verifyResponseSchema
+    );
+    return result;
+  }
+  async verifyGoogle(req) {
+    if (!this.endpoints.verifyGoogle) {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: "HttpBackendAdapter.verifyGoogle() requires backend.endpoints.verifyGoogle to be configured. Set it on Android-supporting builds, or skip Google purchases on this build."
+      });
+    }
+    const result = await this.http.request(
+      { method: "POST", path: this.endpoints.verifyGoogle, body: req },
+      verifyResponseSchema
+    );
+    return result;
+  }
+  async getEntitlements() {
+    const result = await this.http.request(
+      { method: "GET", path: this.endpoints.entitlements },
+      entitlementsResponseSchema
+    );
+    return result.entitlements;
+  }
+  async restore(req) {
+    const result = await this.http.request(
+      { method: "POST", path: this.endpoints.restore, body: req },
+      restoreResponseSchema
+    );
+    return result;
+  }
+  async listProducts() {
+    if (!this.endpoints.products) {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: "HttpBackendAdapter.listProducts() requires backend.endpoints.products to be configured."
+      });
+    }
+    const result = await this.http.request(
+      { method: "GET", path: this.endpoints.products },
+      productManifestResponseSchema
+    );
+    return result.products;
+  }
+};
+
+// src/adapters/backend/index.ts
+function selectBackendAdapter(options) {
+  const { config, logger, fetch: fetchImpl } = options;
+  if (config.adapter !== void 0) {
+    if (!isBackendAdapter(config.adapter)) {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: "backend.adapter must implement BackendAdapter (verifyApple, verifyGoogle, getEntitlements, restore)."
+      });
+    }
+    return config.adapter;
+  }
+  if (!config.baseUrl || !config.endpoints || !config.getAuthHeaders) {
+    throw new IAPError({
+      code: IAPErrorCode.INVALID_CONFIG,
+      message: "backend HTTP fields (baseUrl, endpoints, getAuthHeaders) are required when no custom adapter is provided."
+    });
+  }
+  return new HttpBackendAdapter({
+    baseUrl: config.baseUrl,
+    endpoints: config.endpoints,
+    getAuthHeaders: config.getAuthHeaders,
+    requestTransform: config.requestTransform,
+    responseTransform: config.responseTransform,
+    timeoutMs: config.timeoutMs,
+    retries: config.retries,
+    logger,
+    ...fetchImpl ? { fetch: fetchImpl } : {}
+  });
+}
+
+// src/adapters/native/index.ts
+init_platform();
+
+// src/adapters/native/web/web-stub.ts
+init_errors();
+var WebStubAdapter = class {
+  async isAvailable() {
+    return false;
+  }
+  async getProducts(_requests) {
+    return [];
+  }
+  async purchaseProduct(_opts) {
+    throw new IAPError({
+      code: IAPErrorCode.PLATFORM_NOT_SUPPORTED,
+      message: "In-app purchases are not supported on the web platform."
+    });
+  }
+  async getOwnedTransactions() {
+    return [];
+  }
+  async acknowledge(_transaction) {
+  }
+  async manageSubscriptions() {
+    throw new IAPError({
+      code: IAPErrorCode.PLATFORM_NOT_SUPPORTED,
+      message: "Subscription management is not supported on the web platform."
+    });
+  }
+};
+
+// src/adapters/native/index.ts
+async function selectNativeAdapter(options) {
+  const platform = getPlatform();
+  if (platform === "ios" || platform === "android") {
+    const mod = await Promise.resolve().then(() => (init_native_adapter(), native_adapter_exports));
+    return new mod.CdvNativeAdapter({ products: options.products });
+  }
+  return new WebStubAdapter();
+}
+
+// src/adapters/storage/index.ts
+init_errors();
+
+// src/adapters/storage/memory-adapter.ts
+var MemoryAdapter = class {
+  store = /* @__PURE__ */ new Map();
+  prefix;
+  constructor(namespace) {
+    this.prefix = `${namespace}.`;
+  }
+  async get(key) {
+    return this.store.get(this.prefix + key) ?? null;
+  }
+  async set(key, value) {
+    this.store.set(this.prefix + key, value);
+  }
+  async remove(key) {
+    this.store.delete(this.prefix + key);
+  }
+  async clear() {
+    for (const key of [...this.store.keys()]) {
+      if (key.startsWith(this.prefix)) this.store.delete(key);
+    }
+  }
+};
+
+// src/adapters/storage/preferences-adapter.ts
+init_errors();
+var PreferencesAdapter = class {
+  prefix;
+  knownKeys = /* @__PURE__ */ new Set();
+  constructor(namespace) {
+    this.prefix = `${namespace}.`;
+  }
+  async get(key) {
+    try {
+      const result = await Preferences.get({ key: this.prefix + key });
+      return result.value;
+    } catch (cause) {
+      throw wrap(cause, `Preferences.get failed for "${key}".`);
+    }
+  }
+  async set(key, value) {
+    try {
+      await Preferences.set({ key: this.prefix + key, value });
+      this.knownKeys.add(key);
+    } catch (cause) {
+      throw wrap(cause, `Preferences.set failed for "${key}".`);
+    }
+  }
+  async remove(key) {
+    try {
+      await Preferences.remove({ key: this.prefix + key });
+      this.knownKeys.delete(key);
+    } catch (cause) {
+      throw wrap(cause, `Preferences.remove failed for "${key}".`);
+    }
+  }
+  async clear() {
+    const keys = [...this.knownKeys];
+    this.knownKeys.clear();
+    await Promise.all(keys.map((k) => Preferences.remove({ key: this.prefix + k })));
+  }
+};
+function wrap(cause, message) {
+  return new IAPError({
+    code: IAPErrorCode.STORAGE_ERROR,
+    message,
+    cause,
+    recoverable: true
+  });
+}
+
+// src/adapters/storage/index.ts
+function selectStorageAdapter(config) {
+  if (config.type === "memory") {
+    return new MemoryAdapter(config.namespace);
+  }
+  if (config.type === "custom") {
+    if (!isStorageAdapter(config.adapter)) {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: 'storage.type is "custom" but storage.adapter is missing or does not implement StorageAdapter.'
+      });
+    }
+    return config.adapter;
+  }
+  return new PreferencesAdapter(config.namespace);
+}
+function isStorageAdapter(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.get === "function" && typeof candidate.set === "function" && typeof candidate.remove === "function" && typeof candidate.clear === "function";
+}
+
+// src/core/app-resume-listener.ts
+async function attachAppResumeListener(opts) {
+  let mod;
+  try {
+    mod = await import('@capacitor/app');
+  } catch (error) {
+    opts.logger.warn(
+      "refreshOnResume requested but @capacitor/app is not installed; resume listener disabled.",
+      error
+    );
+    return null;
+  }
+  let handle;
+  try {
+    handle = await mod.App.addListener("appStateChange", ({ isActive }) => {
+      if (!isActive) return;
+      void Promise.resolve(opts.onResume()).catch((error) => {
+        opts.logger.warn("refreshOnResume handler threw.", error);
+      });
+    });
+  } catch (error) {
+    opts.logger.warn(
+      "Failed to attach App appStateChange listener; resume refresh disabled.",
+      error
+    );
+    return null;
+  }
+  return {
+    async remove() {
+      try {
+        await handle.remove();
+      } catch (error) {
+        opts.logger.warn("Failed to remove App appStateChange listener.", error);
+      }
+    }
+  };
+}
+
+// src/core/entitlement-cache.ts
+init_errors();
+var ENTITLEMENTS_KEY = "entitlements";
+var EntitlementCache = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+  }
+  storage;
+  logger;
+  async load() {
+    let raw;
+    try {
+      raw = await this.storage.get(ENTITLEMENTS_KEY);
+    } catch (cause) {
+      this.logger.warn("Storage read failed; treating cache as empty.", cause);
+      return null;
+    }
+    if (!raw) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (cause) {
+      this.logger.warn("Cached entitlements payload is not valid JSON; clearing.", cause);
+      await this.safeRemove();
+      return null;
+    }
+    if (!parsed || typeof parsed !== "object" || typeof parsed.cachedAt !== "number" || !Array.isArray(parsed.entitlements)) {
+      this.logger.warn("Cached entitlements envelope has unexpected shape; clearing.");
+      await this.safeRemove();
+      return null;
+    }
+    const validated = [];
+    for (const item of parsed.entitlements) {
+      const result = entitlementBaseSchema.safeParse(item);
+      if (!result.success) {
+        this.logger.warn("Dropping cached entitlement that fails base validation.", result.error);
+        continue;
+      }
+      validated.push(item);
+    }
+    return { entitlements: validated, cachedAt: parsed.cachedAt };
+  }
+  /** Returns the `cachedAt` timestamp written so callers can keep their
+   *  in-memory copy of the timestamp in sync with disk. */
+  async save(entitlements) {
+    const cachedAt = Date.now();
+    const envelope = {
+      entitlements,
+      cachedAt
+    };
+    try {
+      await this.storage.set(ENTITLEMENTS_KEY, JSON.stringify(envelope));
+    } catch (cause) {
+      throw new IAPError({
+        code: IAPErrorCode.STORAGE_ERROR,
+        message: "Failed to persist entitlement cache.",
+        cause,
+        recoverable: true
+      });
+    }
+    return cachedAt;
+  }
+  async clear() {
+    await this.safeRemove();
+  }
+  async safeRemove() {
+    try {
+      await this.storage.remove(ENTITLEMENTS_KEY);
+    } catch (cause) {
+      this.logger.warn("Failed to remove corrupt entitlement cache.", cause);
+    }
+  }
+};
+function entitlementsEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (!x || !y) return false;
+    if (x.key !== y.key || x.productId !== y.productId || x.expiresAt !== y.expiresAt) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/core/purchase-flow.ts
+init_errors();
+
+// src/lib/uuid.ts
+var UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isValidUuidV4(value) {
+  return UUID_V4_REGEX.test(value);
+}
+
+// src/core/verify-helpers.ts
+init_errors();
+async function verifyNativeTransaction(backend, tx) {
+  if (tx.platform === "apple") {
+    return backend.verifyApple({
+      productId: tx.productId,
+      transactionId: tx.token,
+      type: tx.productType
+    });
+  }
+  if (!tx.packageName) {
+    throw new IAPError({
+      code: IAPErrorCode.STORE_ERROR,
+      message: `Google transaction for "${tx.productId}" has no packageName; cannot verify.`
+    });
+  }
+  return backend.verifyGoogle({
+    productId: tx.productId,
+    purchaseToken: tx.token,
+    packageName: tx.packageName,
+    type: tx.productType
+  });
+}
+
+// src/core/purchase-flow.ts
+var PurchaseOrchestrator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  inFlight = /* @__PURE__ */ new Set();
+  async purchase(opts) {
+    const { productId, appUserId } = opts;
+    if (this.inFlight.has(productId)) {
+      throw new IAPError({
+        code: IAPErrorCode.ALREADY_IN_PROGRESS,
+        message: `A purchase of "${productId}" is already in progress.`
+      });
+    }
+    const product = this.deps.products.find((p) => p.id === productId);
+    if (!product) {
+      throw new IAPError({
+        code: IAPErrorCode.PRODUCT_NOT_FOUND,
+        message: `Product "${productId}" is not in the configured catalog.`
+      });
+    }
+    const resolvedAppUserId = appUserId !== void 0 ? await resolveAppUserId(appUserId) : void 0;
+    this.inFlight.add(productId);
+    this.deps.emitter.emit("purchase-started", { productId });
+    try {
+      return await this.runFlow(product, resolvedAppUserId);
+    } finally {
+      this.inFlight.delete(productId);
+    }
+  }
+  async runFlow(product, appUserId) {
+    const { nativeAdapter, logger } = this.deps;
+    let nativeTx;
+    try {
+      nativeTx = await nativeAdapter.purchaseProduct({
+        productId: product.id,
+        productType: product.type,
+        ...product.androidPlanId ? { androidPlanId: product.androidPlanId } : {},
+        ...appUserId ? { appAccountToken: appUserId } : {}
+      });
+    } catch (error) {
+      return this.handleNativeError(product.id, error);
+    }
+    try {
+      await this.deps.unfinished.add(nativeTx);
+    } catch (error) {
+      logger.warn(
+        `Failed to persist unfinished entry for "${product.id}"; verification will still proceed.`,
+        error
+      );
+    }
+    let verifyResult;
+    try {
+      verifyResult = await verifyNativeTransaction(this.deps.backend, nativeTx);
+    } catch (error) {
+      return this.handleVerifyError(product.id, error);
+    }
+    if (!verifyResult.valid) {
+      return this.handleVerificationRejected(product.id, verifyResult);
+    }
+    return this.finalizeSuccess(product.id, nativeTx, verifyResult);
+  }
+  async finalizeSuccess(productId, nativeTx, response) {
+    const { nativeAdapter, cache, unfinished, emitter, logger } = this.deps;
+    const transaction = response.transaction;
+    const entitlements = response.entitlements;
+    try {
+      await nativeAdapter.acknowledge(nativeTx);
+    } catch (error) {
+      logger.warn(`acknowledge() failed for "${productId}"; entitlements still updated.`, error);
+    }
+    const previous = this.deps.getCurrentEntitlements();
+    try {
+      const cachedAt = await cache.save(entitlements);
+      this.deps.setCachePersisted(cachedAt);
+    } catch (error) {
+      logger.warn(
+        `Failed to persist entitlements after purchase of "${productId}"; in-memory state still updated.`,
+        error
+      );
+    }
+    this.deps.setEntitlements(entitlements);
+    try {
+      await unfinished.remove(nativeTx.token);
+    } catch (error) {
+      logger.warn(
+        `Failed to remove "${productId}" from unfinished list; will be skipped on next recovery.`,
+        error
+      );
+    }
+    emitter.emit("purchase-success", { productId, transaction });
+    emitter.emit("entitlements-changed", {
+      entitlements: this.deps.getCurrentEntitlements(),
+      previous
+    });
+    return {
+      status: "success",
+      productId,
+      transaction,
+      entitlements: this.deps.getCurrentEntitlements()
+    };
+  }
+  handleVerificationRejected(productId, response) {
+    const detail = response.message ? `${response.message} [${response.error}]` : `Backend rejected the transaction (${response.error}).`;
+    const error = new IAPError({
+      code: IAPErrorCode.VERIFICATION_REJECTED,
+      message: detail
+    });
+    this.deps.emitter.emit("verification-failed", { productId, error });
+    return { status: "verification_failed", productId, error };
+  }
+  handleNativeError(productId, error) {
+    const iapError = toIAPError(
+      error,
+      `Native purchase of "${productId}" failed.`,
+      IAPErrorCode.STORE_ERROR
+    );
+    if (iapError.code === IAPErrorCode.USER_CANCELLED) {
+      this.deps.emitter.emit("purchase-cancelled", { productId });
+      return { status: "cancelled", productId };
+    }
+    if (iapError.code === IAPErrorCode.PURCHASE_PENDING) {
+      this.deps.emitter.emit("purchase-pending", { productId });
+      return { status: "pending", productId };
+    }
+    this.deps.emitter.emit("purchase-failed", { productId, error: iapError });
+    return { status: "failed", productId, error: iapError };
+  }
+  handleVerifyError(productId, error) {
+    const iapError = toIAPError(
+      error,
+      `Backend verification of "${productId}" failed.`,
+      IAPErrorCode.BACKEND_UNAVAILABLE
+    );
+    this.deps.emitter.emit("verification-failed", { productId, error: iapError });
+    return { status: "verification_failed", productId, error: iapError };
+  }
+};
+async function resolveAppUserId(supply) {
+  let resolved;
+  if (typeof supply === "function") {
+    try {
+      resolved = await supply();
+    } catch (cause) {
+      throw new IAPError({
+        code: IAPErrorCode.APP_USER_ID_FETCH_FAILED,
+        message: "The async appUserId fetcher threw or rejected.",
+        cause
+      });
+    }
+  } else {
+    resolved = supply;
+  }
+  if (typeof resolved !== "string" || !isValidUuidV4(resolved)) {
+    throw new IAPError({
+      code: IAPErrorCode.INVALID_APP_USER_ID,
+      message: `appUserId must be a UUID v4; received ${typeof resolved === "string" ? `"${resolved}"` : typeof resolved}.`
+    });
+  }
+  return resolved;
+}
+
+// src/core/recovery-flow.ts
+var RecoveryOrchestrator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async recoverUnfinishedTransactions() {
+    const { unfinished, logger, maxBatch } = this.deps;
+    const allEntries = await unfinished.list();
+    if (allEntries.length === 0) {
+      return { recovered: 0, failures: 0, inspected: 0 };
+    }
+    const entries = allEntries.slice(0, maxBatch);
+    if (allEntries.length > maxBatch) {
+      logger.info(
+        `Recovery: inspecting ${entries.length}/${allEntries.length} entries; remaining ${allEntries.length - entries.length} will be processed on subsequent launches.`
+      );
+    } else {
+      logger.debug(`Recovery: inspecting ${entries.length} unfinished transaction(s).`);
+    }
+    const settled = await Promise.allSettled(entries.map((entry) => this.processEntry(entry)));
+    let recovered = 0;
+    let failures = 0;
+    let latestEntitlements = null;
+    for (const result of settled) {
+      if (result.status === "rejected") {
+        failures += 1;
+        continue;
+      }
+      if (result.value.kind === "recovered") {
+        recovered += 1;
+        latestEntitlements = result.value.entitlements;
+      } else {
+        failures += 1;
+      }
+    }
+    if (latestEntitlements !== null) {
+      await this.applyEntitlements(latestEntitlements);
+    }
+    logger.debug(
+      `Recovery: ${recovered} recovered, ${failures} left in list (will retry next launch).`
+    );
+    return { recovered, failures, inspected: entries.length };
+  }
+  async processEntry(entry) {
+    const { nativeAdapter, unfinished, logger } = this.deps;
+    const tx = entryToNativeTransaction(entry);
+    const tokenLabel = maskToken(entry.token);
+    try {
+      const response = await verifyNativeTransaction(this.deps.backend, tx);
+      if (!response.valid) {
+        logger.debug(
+          `Recovery: backend rejected token=${tokenLabel} productId=${entry.productId} (${response.error}); leaving in list.`
+        );
+        return { kind: "failed" };
+      }
+      try {
+        await nativeAdapter.acknowledge(tx);
+      } catch (error) {
+        logger.warn(
+          `Recovery: acknowledge() failed for productId=${entry.productId}; entry retained for next launch.`,
+          error
+        );
+        return { kind: "failed" };
+      }
+      try {
+        await unfinished.remove(entry.token);
+      } catch (error) {
+        logger.warn(
+          `Recovery: unfinished.remove() failed for productId=${entry.productId}; will dedupe on next launch.`,
+          error
+        );
+      }
+      return { kind: "recovered", entitlements: response.entitlements };
+    } catch (error) {
+      logger.warn(
+        `Recovery: verify failed for productId=${entry.productId}; will retry next launch.`,
+        error
+      );
+      return { kind: "failed" };
+    }
+  }
+  async applyEntitlements(entitlements) {
+    const { cache, emitter, logger } = this.deps;
+    const previous = this.deps.getCurrentEntitlements();
+    const unchanged = entitlementsEqual(previous, entitlements);
+    try {
+      const cachedAt = await cache.save(entitlements);
+      this.deps.setCachePersisted(cachedAt);
+    } catch (error) {
+      logger.warn("Recovery: cache.save failed; in-memory state still updated.", error);
+    }
+    this.deps.setEntitlements(entitlements);
+    if (unchanged) return;
+    emitter.emit("entitlements-changed", {
+      entitlements: this.deps.getCurrentEntitlements(),
+      previous
+    });
+  }
+};
+function entryToNativeTransaction(entry) {
+  const tx = {
+    platform: entry.platform,
+    productId: entry.productId,
+    token: entry.token,
+    productType: entry.productType
+  };
+  if (entry.packageName) tx.packageName = entry.packageName;
+  return tx;
+}
+
+// src/core/restore-flow.ts
+init_errors();
+var RestoreOrchestrator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async restorePurchases() {
+    const { nativeAdapter, backend, cache, unfinished, emitter, logger } = this.deps;
+    emitter.emit("restore-started", void 0);
+    let owned;
+    try {
+      owned = await nativeAdapter.getOwnedTransactions();
+    } catch (cause) {
+      throw toIAPError(cause, "Failed to fetch owned transactions.", IAPErrorCode.STORE_ERROR);
+    }
+    if (owned.length === 0) {
+      const entitlements2 = this.deps.getCurrentEntitlements();
+      emitter.emit("restore-completed", { restored: 0, entitlements: entitlements2 });
+      return { restored: 0, entitlements: entitlements2 };
+    }
+    const request = {
+      transactions: owned.map((tx) => this.toRestoreEntry(tx))
+    };
+    let response;
+    try {
+      response = await backend.restore(request);
+    } catch (cause) {
+      throw toIAPError(cause, "Backend restore call failed.", IAPErrorCode.BACKEND_UNAVAILABLE);
+    }
+    if (!response.valid) {
+      const detail = response.message ? `${response.message} [${response.error}]` : `Backend rejected restore (${response.error}).`;
+      throw new IAPError({
+        code: IAPErrorCode.VERIFICATION_REJECTED,
+        message: detail
+      });
+    }
+    for (const tx of owned) {
+      try {
+        await nativeAdapter.acknowledge(tx);
+      } catch (error) {
+        logger.warn(`acknowledge() failed for "${tx.productId}" during restore.`, error);
+      }
+    }
+    const entitlements = response.entitlements;
+    const previous = this.deps.getCurrentEntitlements();
+    try {
+      const cachedAt = await cache.save(entitlements);
+      this.deps.setCachePersisted(cachedAt);
+    } catch (error) {
+      logger.warn(
+        "Failed to persist entitlements after restore; in-memory state still updated.",
+        error
+      );
+    }
+    this.deps.setEntitlements(entitlements);
+    for (const tx of owned) {
+      try {
+        await unfinished.remove(tx.token);
+      } catch (error) {
+        logger.warn(
+          `Failed to remove "${tx.productId}" from unfinished list during restore.`,
+          error
+        );
+      }
+    }
+    const next = this.deps.getCurrentEntitlements();
+    emitter.emit("restore-completed", { restored: owned.length, entitlements: next });
+    if (!entitlementsEqual(previous, next)) {
+      emitter.emit("entitlements-changed", { entitlements: next, previous });
+    }
+    return { restored: owned.length, entitlements: next };
+  }
+  toRestoreEntry(tx) {
+    if (tx.platform === "apple") {
+      return {
+        platform: "apple",
+        productId: tx.productId,
+        transactionId: tx.token
+      };
+    }
+    if (!tx.packageName) {
+      throw new IAPError({
+        code: IAPErrorCode.STORE_ERROR,
+        message: `Google owned transaction for "${tx.productId}" has no packageName; cannot restore.`
+      });
+    }
+    return {
+      platform: "google",
+      productId: tx.productId,
+      purchaseToken: tx.token,
+      packageName: tx.packageName
+    };
+  }
+};
+
+// src/core/unfinished-transactions.ts
+init_errors();
+var STORE_KEY = "unfinished_transactions";
+var unfinishedEntrySchema = z.object({
+  platform: z.enum(["apple", "google"]),
+  productId: z.string().min(1),
+  token: z.string().min(1),
+  productType: productTypeSchema,
+  packageName: z.string().optional(),
+  /** ISO 8601 timestamp the entry was first persisted. */
+  recordedAt: z.string()
+});
+var envelopeSchema = z.array(unfinishedEntrySchema);
+var UnfinishedTransactionsStore = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+  }
+  storage;
+  logger;
+  /**
+   * Serializes mutating operations (`add` / `remove`) so concurrent callers
+   * don't race the read-modify-write on the storage key. Phase 6's
+   * parallel recovery exposed this — multiple `remove()` calls in flight
+   * could each `list()` the same snapshot and overwrite each other's
+   * `persist()`.
+   */
+  mutationLock = Promise.resolve();
+  /** Returns the current list, or `[]` if empty / corrupt. */
+  async list() {
+    let raw;
+    try {
+      raw = await this.storage.get(STORE_KEY);
+    } catch (cause) {
+      this.logger.warn("Storage read failed; treating unfinished list as empty.", cause);
+      return [];
+    }
+    if (!raw) return [];
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (cause) {
+      this.logger.warn("unfinished_transactions payload is not valid JSON; clearing.", cause);
+      await this.safeClear();
+      return [];
+    }
+    const result = envelopeSchema.safeParse(parsed);
+    if (!result.success) {
+      this.logger.warn("unfinished_transactions has unexpected shape; clearing.", result.error);
+      await this.safeClear();
+      return [];
+    }
+    return result.data;
+  }
+  /**
+   * Append a transaction to the list. Idempotent: if a same-token entry
+   * already exists, this is a no-op (avoids dupes when restore + active
+   * purchase race for the same StoreKit replay).
+   */
+  async add(tx) {
+    return this.runExclusive(async () => {
+      const current = await this.list();
+      if (current.some((e) => e.token === tx.token)) return;
+      const entry = {
+        platform: tx.platform,
+        productId: tx.productId,
+        token: tx.token,
+        productType: tx.productType,
+        ...tx.packageName ? { packageName: tx.packageName } : {},
+        recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.persist([...current, entry]);
+    });
+  }
+  /** Remove the entry with the given token. No-op if not present. */
+  async remove(token) {
+    return this.runExclusive(async () => {
+      const current = await this.list();
+      const next = current.filter((e) => e.token !== token);
+      if (next.length === current.length) return;
+      await this.persist(next);
+    });
+  }
+  /** Clear every unfinished entry. */
+  async clear() {
+    return this.runExclusive(() => this.safeClear());
+  }
+  /**
+   * Run `fn` with exclusive access to the storage key. Implements a simple
+   * promise chain — every mutation awaits the previous one's completion.
+   * Reads (`list()`) are NOT serialized because they're tolerant of stale
+   * snapshots (callers either compose or accept the read-once semantic).
+   */
+  async runExclusive(fn) {
+    const prev = this.mutationLock;
+    let release;
+    this.mutationLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    try {
+      await prev;
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  async persist(entries) {
+    try {
+      await this.storage.set(STORE_KEY, JSON.stringify(entries));
+    } catch (cause) {
+      throw new IAPError({
+        code: IAPErrorCode.STORAGE_ERROR,
+        message: "Failed to persist unfinished transactions list.",
+        cause,
+        recoverable: true
+      });
+    }
+  }
+  async safeClear() {
+    try {
+      await this.storage.remove(STORE_KEY);
+    } catch (cause) {
+      this.logger.warn("Failed to clear unfinished_transactions key.", cause);
+    }
+  }
+};
+
+// src/events/emitter.ts
+var TypedEventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    const key = event;
+    let set = this.handlers.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(key, set);
+    }
+    set.add(handler);
+    return () => {
+      const current = this.handlers.get(key);
+      if (current) current.delete(handler);
+    };
+  }
+  emit(event, payload) {
+    const set = this.handlers.get(event);
+    if (!set) return;
+    for (const handler of [...set]) {
+      try {
+        handler(payload);
+      } catch {
+      }
+    }
+  }
+  removeAll() {
+    this.handlers.clear();
+  }
+  /** Number of listeners for a given event — used by tests. */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+};
+
+// src/createIAP.ts
+init_errors();
+
+// src/lib/logger.ts
+var LEVEL_PRIORITY = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+var PREFIX = "[@nosslabs/iap]";
+function createDefaultLogger(level) {
+  const minPriority = LEVEL_PRIORITY[level];
+  const enabled = (l) => LEVEL_PRIORITY[l] <= minPriority;
+  return {
+    error(message, ...args) {
+      if (enabled("error")) console.error(PREFIX, message, ...args);
+    },
+    warn(message, ...args) {
+      if (enabled("warn")) console.warn(PREFIX, message, ...args);
+    },
+    info(message, ...args) {
+      if (enabled("info")) console.info(PREFIX, message, ...args);
+    },
+    debug(message, ...args) {
+      if (enabled("debug")) console.debug(PREFIX, message, ...args);
+    }
+  };
+}
+function isLogger(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.error === "function" && typeof candidate.warn === "function" && typeof candidate.info === "function" && typeof candidate.debug === "function";
+}
+
+// src/createIAP.ts
+init_platform();
+function createIAP(input) {
+  const config = parseConfig(input);
+  const logger = resolveLogger(config.options.logLevel, config.options.logger);
+  const storage = selectStorageAdapter(config.storage);
+  const cache = new EntitlementCache(storage, logger);
+  const unfinished = new UnfinishedTransactionsStore(storage, logger);
+  const backend = selectBackendAdapter({ config: config.backend, logger });
+  const emitter = new TypedEventEmitter();
+  if (config.products) {
+    ensureUniqueProductIds(config.products);
+  }
+  const state = {
+    config,
+    adapter: null,
+    backend,
+    storage,
+    cache,
+    unfinished,
+    orchestrator: null,
+    restorer: null,
+    recoverer: null,
+    resumeListener: null,
+    emitter,
+    logger,
+    initialized: false,
+    destroyed: false,
+    entitlements: [],
+    cachedAt: null,
+    products: Object.freeze([...config.products ?? []])
+  };
+  return {
+    async initialize() {
+      if (state.destroyed) {
+        throw new IAPError({
+          code: IAPErrorCode.NOT_INITIALIZED,
+          message: "IAP instance has been destroyed; create a new one with createIAP()."
+        });
+      }
+      if (state.initialized) {
+        state.logger.debug("initialize() called more than once; ignoring.");
+        return;
+      }
+      const platform = getPlatform();
+      if (!isNative()) {
+        state.logger.info(
+          "Native purchases unavailable on web; entitlement queries still functional."
+        );
+      } else {
+        state.logger.debug(`Initializing on platform=${platform}`);
+      }
+      if (!state.config.products) {
+        if (typeof state.backend.listProducts !== "function") {
+          throw new IAPError({
+            code: IAPErrorCode.INVALID_CONFIG,
+            message: "config.products is omitted but backend adapter does not implement listProducts(). This is a library bug; the schema should have caught it."
+          });
+        }
+        const fetched = await state.backend.listProducts();
+        const validated = configuredProductsArraySchema.safeParse(fetched);
+        if (!validated.success) {
+          throw new IAPError({
+            code: IAPErrorCode.BACKEND_BAD_RESPONSE,
+            message: `backend.listProducts() returned an invalid manifest: ${validated.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ")}`,
+            cause: validated.error
+          });
+        }
+        ensureUniqueProductIds(validated.data);
+        state.products = Object.freeze([...validated.data]);
+        state.logger.debug(`Resolved ${validated.data.length} product(s) from backend manifest.`);
+      }
+      state.adapter = await selectNativeAdapter({ products: state.products });
+      const sharedDeps = {
+        nativeAdapter: state.adapter,
+        backend: state.backend,
+        cache: state.cache,
+        unfinished: state.unfinished,
+        emitter: state.emitter,
+        logger: state.logger,
+        getCurrentEntitlements: () => state.entitlements,
+        setEntitlements: (next) => {
+          state.entitlements = freezeAll(next);
+        },
+        setCachePersisted: (cachedAt) => {
+          state.cachedAt = cachedAt;
+        }
+      };
+      state.orchestrator = new PurchaseOrchestrator({
+        ...sharedDeps,
+        products: state.products
+      });
+      state.restorer = new RestoreOrchestrator(sharedDeps);
+      state.recoverer = new RecoveryOrchestrator({
+        ...sharedDeps,
+        maxBatch: state.config.options.recoveryMaxBatch
+      });
+      try {
+        await state.adapter.isAvailable();
+      } catch (error) {
+        state.logger.warn("Native adapter availability check threw; continuing.", error);
+      }
+      const cached = await state.cache.load();
+      if (cached) {
+        state.entitlements = freezeAll(cached.entitlements);
+        state.cachedAt = cached.cachedAt;
+        state.logger.debug(
+          `Loaded ${cached.entitlements.length} cached entitlement(s) from ${new Date(cached.cachedAt).toISOString()}.`
+        );
+      }
+      if (state.config.options.recoverUnfinishedTransactions && isNative()) {
+        try {
+          const result = await state.recoverer.recoverUnfinishedTransactions();
+          if (result.inspected > 0) {
+            state.logger.info(
+              `Recovery inspected ${result.inspected} unfinished transaction(s): ${result.recovered} recovered, ${result.failures} retained.`
+            );
+          }
+        } catch (error) {
+          state.logger.warn("Recovery threw unexpectedly; continuing initialize.", error);
+        }
+      }
+      if (state.config.options.refreshOnResume && isNative()) {
+        state.resumeListener = await attachAppResumeListener({
+          logger: state.logger,
+          onResume: async () => {
+            try {
+              await this.refresh();
+            } catch (error) {
+              state.logger.warn("refreshOnResume: refresh() failed.", error);
+            }
+          }
+        });
+      }
+      if (state.cachedAt !== null && Date.now() - state.cachedAt > state.config.options.entitlementCacheTtlMs) {
+        state.logger.debug("Cache exceeds TTL; scheduling background refresh.");
+        queueMicrotask(() => {
+          if (!state.initialized || state.destroyed) return;
+          this.refresh().catch((error) => {
+            state.logger.warn("TTL background refresh failed.", error);
+          });
+        });
+      }
+      state.initialized = true;
+      state.emitter.emit("ready", void 0);
+    },
+    async refresh() {
+      requireInitialized(state);
+      const previous = state.entitlements;
+      const fetched = await state.backend.getEntitlements();
+      const next = freezeAll(fetched);
+      try {
+        state.cachedAt = await state.cache.save(next);
+      } catch (error) {
+        state.logger.warn(
+          "Failed to persist refreshed entitlements; in-memory state still updated.",
+          error
+        );
+      }
+      state.entitlements = next;
+      if (!entitlementsEqual(previous, next)) {
+        state.emitter.emit("entitlements-changed", { entitlements: next, previous });
+      }
+    },
+    async destroy() {
+      if (state.destroyed) return;
+      state.destroyed = true;
+      state.initialized = false;
+      state.entitlements = [];
+      state.cachedAt = null;
+      state.emitter.removeAll();
+      if (state.resumeListener) {
+        try {
+          await state.resumeListener.remove();
+        } catch (error) {
+          state.logger.warn("Resume listener remove threw; continuing teardown.", error);
+        }
+        state.resumeListener = null;
+      }
+      if (state.adapter?.dispose) {
+        try {
+          await state.adapter.dispose();
+        } catch (error) {
+          state.logger.warn("Adapter dispose threw; continuing teardown.", error);
+        }
+      }
+      state.adapter = null;
+      state.orchestrator = null;
+      state.restorer = null;
+      state.recoverer = null;
+    },
+    async purchase(opts) {
+      requireInitialized(state);
+      if (!state.orchestrator) {
+        throw new IAPError({
+          code: IAPErrorCode.NOT_INITIALIZED,
+          message: "Purchase orchestrator not constructed; this is a library bug."
+        });
+      }
+      return state.orchestrator.purchase(opts);
+    },
+    async restorePurchases() {
+      requireInitialized(state);
+      if (!state.restorer) {
+        throw new IAPError({
+          code: IAPErrorCode.NOT_INITIALIZED,
+          message: "Restore orchestrator not constructed; this is a library bug."
+        });
+      }
+      return state.restorer.restorePurchases();
+    },
+    async getProducts() {
+      requireInitialized(state);
+      if (!state.adapter) {
+        throw new IAPError({
+          code: IAPErrorCode.NOT_INITIALIZED,
+          message: "Native adapter not constructed; this is a library bug."
+        });
+      }
+      return state.adapter.getProducts(state.products.map((p) => ({ id: p.id, type: p.type })));
+    },
+    hasEntitlement(key) {
+      return state.entitlements.some((e) => e.key === key);
+    },
+    getEntitlements() {
+      return [...state.entitlements];
+    },
+    getEntitlement(key) {
+      return state.entitlements.find((e) => e.key === key) ?? null;
+    },
+    on(event, handler) {
+      return state.emitter.on(event, handler);
+    }
+  };
+}
+function freezeAll(items) {
+  return items.map((item) => Object.freeze({ ...item }));
+}
+function parseConfig(input) {
+  try {
+    const parsed = iapConfigSchema.parse(input);
+    return parsed;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const issues = error.issues.map((i) => `  - ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: `Invalid IAP configuration:
+${issues}`,
+        cause: error
+      });
+    }
+    throw error;
+  }
+}
+function ensureUniqueProductIds(products) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const product of products) {
+    if (seen.has(product.id)) {
+      throw new IAPError({
+        code: IAPErrorCode.INVALID_CONFIG,
+        message: `Duplicate product id "${product.id}" in product manifest.`
+      });
+    }
+    seen.add(product.id);
+  }
+}
+function resolveLogger(level, candidate) {
+  if (isLogger(candidate)) return candidate;
+  return createDefaultLogger(level);
+}
+function requireInitialized(state) {
+  if (!state.initialized) {
+    throw new IAPError({
+      code: IAPErrorCode.NOT_INITIALIZED,
+      message: "Call iap.initialize() before this method."
+    });
+  }
+}
+
+// src/index.ts
+init_errors();
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+export { HttpBackendAdapter, HttpClient, IAPError, IAPErrorCode, VERSION, createIAP, errorHint, isIAPError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map