@umituz/web-payment 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,1929 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BILLING_CYCLE: () => BILLING_CYCLE,
+  BILLING_CYCLE_VALUES: () => BILLING_CYCLE_VALUES,
+  BillingApiError: () => BillingApiError,
+  BillingContext: () => BillingContext,
+  BillingHistoryList: () => BillingHistoryList,
+  BillingProvider: () => BillingProvider,
+  CANCELLATION_REASON: () => CANCELLATION_REASON,
+  CANCELLATION_REASON_CATALOG: () => CANCELLATION_REASON_CATALOG,
+  CANCELLATION_REASON_VALUES: () => CANCELLATION_REASON_VALUES,
+  CHECKOUT_ID_PARAM: () => CHECKOUT_ID_PARAM,
+  CancelSubscriptionButton: () => CancelSubscriptionButton,
+  CheckoutButton: () => CheckoutButton,
+  CustomerPortalLink: () => CustomerPortalLink,
+  FREE_SUBSCRIPTION_STATUS: () => FREE_SUBSCRIPTION_STATUS,
+  FetchHttpClient: () => FetchHttpClient,
+  NoopNavigationStrategy: () => NoopNavigationStrategy,
+  PAYMENT_PROVIDER: () => PAYMENT_PROVIDER,
+  PAYMENT_PROVIDER_VALUES: () => PAYMENT_PROVIDER_VALUES,
+  POLAR_AMOUNT_TYPE: () => POLAR_AMOUNT_TYPE,
+  PricingTable: () => PricingTable,
+  ProductRepository: () => ProductRepository,
+  SUBSCRIPTION_STATUS: () => SUBSCRIPTION_STATUS,
+  SUBSCRIPTION_STATUS_VALUES: () => SUBSCRIPTION_STATUS_VALUES,
+  SubscriptionStatusBadge: () => SubscriptionStatusBadge,
+  TONE_PAIRS: () => TONE_PAIRS,
+  VisualTokens: () => VisualTokens,
+  WindowNavigationStrategy: () => WindowNavigationStrategy,
+  applyPercentDiscount: () => applyPercentDiscount,
+  buildCheckoutMetadata: () => buildCheckoutMetadata,
+  checkoutIdFromLocationSearch: () => checkoutIdFromLocationSearch,
+  createMemoryBillingAdapter: () => createMemoryBillingAdapter,
+  formatReceiptNumber: () => formatReceiptNumber,
+  getAllProducts: () => getAllProducts,
+  getProductById: () => getProductById,
+  getProducts: () => getProducts,
+  isActiveSubscription: () => isActiveSubscription,
+  isBillingApiError: () => isBillingApiError,
+  isKnownBillingCycle: () => isKnownBillingCycle,
+  isKnownPaymentProvider: () => isKnownPaymentProvider,
+  isKnownSubscriptionStatus: () => isKnownSubscriptionStatus,
+  isSafeCheckoutUrl: () => isSafeCheckoutUrl,
+  mapProduct: () => mapProduct,
+  mapProductList: () => mapProductList,
+  minorUnitDivisor: () => minorUnitDivisor,
+  normalizeCouponCode: () => normalizeCouponCode,
+  parseBillingCycle: () => parseBillingCycle,
+  readCheckoutMetadata: () => readCheckoutMetadata,
+  redirectToHostedCheckout: () => redirectToHostedCheckout,
+  toMajorUnits: () => toMajorUnits,
+  toMinorUnits: () => toMinorUnits,
+  useBilling: () => useBilling,
+  useCancelSubscription: () => useCancelSubscription,
+  useCheckoutButton: () => useCheckoutButton,
+  useProducts: () => useProducts
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/domain/enums/payment-provider.enum.ts
+var PAYMENT_PROVIDER = {
+  POLAR: "polar",
+  STRIPE: "stripe"
+};
+var PAYMENT_PROVIDER_VALUES = Object.values(PAYMENT_PROVIDER);
+var PAYMENT_PROVIDER_SET = new Set(PAYMENT_PROVIDER_VALUES);
+function isKnownPaymentProvider(value) {
+  return typeof value === "string" && PAYMENT_PROVIDER_SET.has(value);
+}
+
+// src/domain/enums/subscription-status.enum.ts
+var SUBSCRIPTION_STATUS = {
+  ACTIVE: "active",
+  CANCELED: "canceled",
+  REVOKED: "revoked",
+  TRIALING: "trialing",
+  PAST_DUE: "past_due",
+  INCOMPLETE: "incomplete",
+  INCOMPLETE_EXPIRED: "incomplete_expired",
+  UNPAID: "unpaid",
+  NONE: "none"
+};
+var SUBSCRIPTION_STATUS_VALUES = Object.freeze([
+  SUBSCRIPTION_STATUS.ACTIVE,
+  SUBSCRIPTION_STATUS.CANCELED,
+  SUBSCRIPTION_STATUS.REVOKED,
+  SUBSCRIPTION_STATUS.TRIALING,
+  SUBSCRIPTION_STATUS.PAST_DUE,
+  SUBSCRIPTION_STATUS.INCOMPLETE,
+  SUBSCRIPTION_STATUS.INCOMPLETE_EXPIRED,
+  SUBSCRIPTION_STATUS.UNPAID,
+  SUBSCRIPTION_STATUS.NONE
+]);
+var SUBSCRIPTION_STATUS_SET = new Set(SUBSCRIPTION_STATUS_VALUES);
+function isKnownSubscriptionStatus(value) {
+  return typeof value === "string" && SUBSCRIPTION_STATUS_SET.has(value.toLowerCase());
+}
+
+// src/domain/enums/billing-cycle.enum.ts
+var BILLING_CYCLE = Object.freeze({
+  MONTHLY: "monthly",
+  YEARLY: "yearly"
+});
+var BILLING_CYCLE_VALUES = Object.freeze([
+  BILLING_CYCLE.MONTHLY,
+  BILLING_CYCLE.YEARLY
+]);
+var CANONICAL_BILLING_CYCLES = new Set(BILLING_CYCLE_VALUES);
+var BILLING_CYCLE_ALIASES = /* @__PURE__ */ new Map([
+  [BILLING_CYCLE.MONTHLY, BILLING_CYCLE.MONTHLY],
+  ["month", BILLING_CYCLE.MONTHLY],
+  [BILLING_CYCLE.YEARLY, BILLING_CYCLE.YEARLY],
+  ["year", BILLING_CYCLE.YEARLY]
+]);
+function isKnownBillingCycle(value) {
+  return typeof value === "string" && CANONICAL_BILLING_CYCLES.has(value.toLowerCase());
+}
+function parseBillingCycle(value) {
+  if (typeof value !== "string") return null;
+  return BILLING_CYCLE_ALIASES.get(value.toLowerCase()) ?? null;
+}
+
+// src/domain/enums/amount-type.enum.ts
+var POLAR_AMOUNT_TYPE = Object.freeze({
+  FIXED: "fixed",
+  CUSTOM: "custom",
+  FREE: "free",
+  SEAT_BASED: "seat_based",
+  METERED_UNIT: "metered_unit"
+});
+
+// src/domain/entities/cancellation.entity.ts
+var CANCELLATION_REASON = Object.freeze({
+  TOO_EXPENSIVE: "too_expensive",
+  MISSING_FEATURES: "missing_features",
+  SWITCHED_SERVICE: "switched_service",
+  UNUSED: "unused",
+  CUSTOMER_SERVICE: "customer_service",
+  LOW_QUALITY: "low_quality",
+  TOO_COMPLEX: "too_complex",
+  OTHER: "other"
+});
+var CANCELLATION_REASON_VALUES = Object.freeze([
+  CANCELLATION_REASON.TOO_EXPENSIVE,
+  CANCELLATION_REASON.MISSING_FEATURES,
+  CANCELLATION_REASON.SWITCHED_SERVICE,
+  CANCELLATION_REASON.UNUSED,
+  CANCELLATION_REASON.CUSTOMER_SERVICE,
+  CANCELLATION_REASON.LOW_QUALITY,
+  CANCELLATION_REASON.TOO_COMPLEX,
+  CANCELLATION_REASON.OTHER
+]);
+
+// src/domain/entities/subscription.entity.ts
+var FREE_SUBSCRIPTION_STATUS = Object.freeze({
+  plan: "free",
+  subscriptionStatus: "none"
+});
+function isActiveSubscription(status) {
+  return status.subscriptionStatus === "active" || status.subscriptionStatus === "trialing";
+}
+
+// src/infrastructure/services/memory/create-memory-adapter.ts
+function createMemoryBillingAdapter(config = {}) {
+  let status = {
+    plan: "free",
+    subscriptionStatus: "none",
+    billingCycle: "monthly",
+    cancelAtPeriodEnd: false,
+    ...config.initialStatus
+  };
+  const history = config.initialHistory ? [...config.initialHistory] : [];
+  const pending = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  function checkoutUrl(checkout) {
+    if (checkout.params.successUrl) {
+      return checkout.params.successUrl.replace("{CHECKOUT_ID}", checkout.id);
+    }
+    const base = config.checkoutUrlBase ?? "https://checkout.example";
+    return `${base.replace(/\/$/, "")}/${checkout.id}`;
+  }
+  function fulfill(checkout) {
+    const planName = checkout.params.planKey ?? checkout.params.productId ?? checkout.params.productKey ?? "default";
+    return {
+      ...status,
+      plan: planName,
+      subscriptionStatus: "active",
+      subscriptionId: `sub_${checkout.id.slice(4)}`,
+      billingCycle: checkout.params.billingCycle ?? status.billingCycle,
+      cancelAtPeriodEnd: false,
+      currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString()
+    };
+  }
+  return {
+    async getStatus(_userId) {
+      return { ...status };
+    },
+    async createCheckout(params) {
+      config.onCheckout?.(params);
+      sequence += 1;
+      const checkout = {
+        id: `chk_${Date.now()}_${sequence}`,
+        params
+      };
+      pending.set(checkout.id, checkout);
+      return {
+        id: checkout.id,
+        url: checkoutUrl(checkout)
+      };
+    },
+    async syncSubscription(_userId, checkoutId) {
+      const checkout = checkoutId ? pending.get(checkoutId) : void 0;
+      const last = checkout ? void 0 : [...pending.values()].pop();
+      const target = checkout ?? last;
+      if (!target) {
+        return { synced: false, plan: status.plan };
+      }
+      status = fulfill(target);
+      pending.delete(target.id);
+      history.unshift({
+        id: `ord_${target.id}`,
+        amount: 0,
+        currency: "usd",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        productName: target.params.planKey ?? target.params.productId,
+        status: "paid",
+        paid: true
+      });
+      return { synced: true, plan: status.plan };
+    },
+    async getBillingHistory(_userId) {
+      return [...history];
+    },
+    async cancelSubscription(reason) {
+      config.onCancel?.(reason);
+      if (!isActiveSubscription(status)) {
+        return { success: false };
+      }
+      status = {
+        ...status,
+        subscriptionStatus: "canceled",
+        cancelAtPeriodEnd: true
+      };
+      return {
+        success: true,
+        endsAt: status.currentPeriodEnd ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+    },
+    async getPortalUrl(_userId) {
+      return config.portalUrl ?? "https://portal.example/billing";
+    }
+  };
+}
+
+// src/domain/mappers/product.mapper.ts
+var KNOWN_AMOUNT_TYPES = /* @__PURE__ */ new Set([
+  "fixed",
+  "custom",
+  "free",
+  "seat_based",
+  "metered_unit"
+]);
+function toAmountType(raw) {
+  if (raw && KNOWN_AMOUNT_TYPES.has(raw)) return raw;
+  return "fixed";
+}
+function toBillingCycle(interval) {
+  return parseBillingCycle(interval);
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function toPrice(dto) {
+  return {
+    id: String(dto.id),
+    type: toAmountType(dto.type),
+    amountType: toAmountType(dto.amount_type),
+    amount: typeof dto.amount === "number" ? dto.amount : void 0,
+    currency: String(dto.currency),
+    recurringInterval: toBillingCycle(dto.recurring_interval) ?? void 0,
+    isArchived: Boolean(dto.is_archived),
+    productId: String(dto.product_id),
+    legacy: Boolean(dto.legacy)
+  };
+}
+function toBenefit(dto) {
+  return {
+    id: String(dto.id),
+    type: String(dto.type),
+    description: dto.description ?? null,
+    properties: asRecord(dto.properties)
+  };
+}
+function mapProduct(dto) {
+  if (!dto || typeof dto !== "object") {
+    throw new TypeError("mapProduct: expected a product DTO object");
+  }
+  return {
+    id: String(dto.id),
+    name: String(dto.name),
+    description: dto.description ?? null,
+    isRecurring: Boolean(dto.is_recurring),
+    recurringInterval: toBillingCycle(dto.recurring_interval),
+    isArchived: Boolean(dto.is_archived),
+    organizationId: String(dto.organization_id),
+    prices: Array.isArray(dto.prices) ? dto.prices.map(toPrice) : [],
+    benefits: Array.isArray(dto.benefits) ? dto.benefits.map(toBenefit) : [],
+    metadata: asRecord(dto.metadata),
+    createdAt: String(dto.created_at),
+    modifiedAt: dto.modified_at ?? null
+  };
+}
+function mapProductList(dto) {
+  if (!dto || typeof dto !== "object") {
+    return { items: [], pagination: { totalCount: 0, maxPage: 1 } };
+  }
+  return {
+    items: Array.isArray(dto.items) ? dto.items.map(mapProduct) : [],
+    pagination: {
+      totalCount: Number(dto.pagination?.total_count ?? 0),
+      maxPage: Number(dto.pagination?.max_page ?? 1)
+    }
+  };
+}
+
+// src/domain/utils/minor-units.ts
+var MINOR_UNIT_DIVISOR = 100;
+var ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+  "JPY",
+  "KRW",
+  "VND",
+  "CLP",
+  "PYG",
+  "XAF",
+  "XOF",
+  "BIF",
+  "DJF",
+  "GNF",
+  "XPF"
+]);
+function minorUnitDivisor(currency) {
+  return ZERO_DECIMAL_CURRENCIES.has(currency.toUpperCase()) ? 1 : MINOR_UNIT_DIVISOR;
+}
+function toMajorUnits(amount, currency) {
+  return amount / minorUnitDivisor(currency);
+}
+function toMinorUnits(amount, currency) {
+  return Math.round(amount * minorUnitDivisor(currency));
+}
+
+// src/domain/utils/percent-discount.ts
+function normalizeCouponCode(code) {
+  if (typeof code !== "string") return null;
+  const normalized = code.trim().toUpperCase();
+  return normalized.length > 0 ? normalized : null;
+}
+function applyPercentDiscount(baseAmount, percent, minimumAmount) {
+  if (!Number.isFinite(baseAmount) || baseAmount <= 0) return 0;
+  if (!Number.isFinite(percent) || percent <= 0) return Math.round(baseAmount);
+  const discounted = Math.round(baseAmount * (1 - percent / 100));
+  return Math.max(minimumAmount, discounted);
+}
+
+// src/infrastructure/utils/receipt.util.ts
+function formatReceiptNumber(id, prefix = "RCP") {
+  if (!id || typeof id !== "string") return `${prefix}-00000000`;
+  const clean = id.replace(/[^a-zA-Z0-9]/g, "");
+  const tail = clean.length >= 8 ? clean.slice(-8) : clean.padStart(8, "0");
+  return `${prefix}-${tail.toUpperCase()}`;
+}
+
+// src/infrastructure/utils/checkout-metadata.ts
+function asNonEmptyString(value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  return value;
+}
+function buildCheckoutMetadata(input) {
+  const meta = {
+    userId: input.userId,
+    itemType: input.itemType,
+    itemId: input.itemId
+  };
+  if (input.couponCode && input.couponCode.trim().length > 0) {
+    meta.couponCode = input.couponCode.trim();
+  }
+  if (input.extra) {
+    for (const [key, value] of Object.entries(input.extra)) {
+      if (typeof value === "string" && value.length > 0) {
+        meta[key] = value;
+      }
+    }
+  }
+  return meta;
+}
+function readCheckoutMetadata(metadata, allowedItemTypes) {
+  if (metadata === void 0) return null;
+  const userId = asNonEmptyString(metadata.userId);
+  const itemType = asNonEmptyString(metadata.itemType);
+  const itemId = asNonEmptyString(metadata.itemId);
+  if (!userId || !itemType || !itemId) return null;
+  if (!allowedItemTypes.includes(itemType)) return null;
+  const couponCode = asNonEmptyString(metadata.couponCode);
+  return { userId, itemType, itemId, ...couponCode ? { couponCode } : {} };
+}
+
+// src/infrastructure/constants/billing.constants.ts
+var API_BASE_URL = "https://api.polar.sh/v1";
+var API_MAX_PAGE_SIZE = 100;
+
+// src/infrastructure/http/http-client.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var FetchHttpClient = class {
+  async request(request) {
+    const init = {
+      method: request.method,
+      headers: {
+        Accept: "application/json",
+        ...request.headers ?? {}
+      }
+    };
+    if (request.body !== void 0) {
+      init.body = JSON.stringify(request.body);
+      init.headers["Content-Type"] = "application/json";
+    }
+    const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const forwardAbort = () => controller.abort();
+    if (request.signal) {
+      if (request.signal.aborted) controller.abort();
+      else request.signal.addEventListener("abort", forwardAbort);
+    }
+    init.signal = controller.signal;
+    let response;
+    try {
+      response = await fetch(request.url, init);
+    } catch (error) {
+      if (timedOut && error instanceof Error && error.name === "AbortError") {
+        throw new DOMException(`Request timed out after ${timeoutMs}ms`, "TimeoutError");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", forwardAbort);
+    }
+    const bodyText = await response.text();
+    let data = null;
+    if (bodyText.length > 0) {
+      try {
+        data = JSON.parse(bodyText);
+      } catch {
+        data = null;
+      }
+    }
+    return {
+      status: response.status,
+      ok: response.ok,
+      data,
+      text: async () => bodyText
+    };
+  }
+};
+
+// src/infrastructure/query/query-builder.ts
+var QueryBuilder = class {
+  params;
+  constructor(initial) {
+    this.params = new URLSearchParams();
+    if (initial) this.setMany(initial);
+  }
+  set(key, value) {
+    if (value === void 0 || value === null) return this;
+    this.params.set(key, String(value));
+    return this;
+  }
+  setMany(values) {
+    for (const [key, value] of Object.entries(values)) {
+      this.set(key, value);
+    }
+    return this;
+  }
+  toString() {
+    return this.params.toString();
+  }
+};
+
+// src/infrastructure/pagination/page-iterator.ts
+var PageIterator = class {
+  fetcher;
+  limit;
+  signal;
+  constructor(fetcher, options = {}) {
+    this.fetcher = fetcher;
+    this.limit = options.limit ?? 100;
+    this.signal = options.signal;
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = 1;
+    while (true) {
+      if (this.signal?.aborted) return;
+      const current = await this.fetcher.fetchPage(page, this.limit);
+      for (const item of current.items) {
+        if (this.signal?.aborted) return;
+        yield item;
+      }
+      if (current.isLast || page >= current.maxPage) return;
+      page++;
+    }
+  }
+};
+
+// src/infrastructure/utils/pagination-clamp.ts
+var MIN_PAGE_SIZE = 1;
+var PaginationClamp = class {
+  static pageSize(raw, max = API_MAX_PAGE_SIZE) {
+    if (raw === void 0) return max;
+    return Math.min(Math.max(MIN_PAGE_SIZE, raw), max);
+  }
+};
+
+// src/infrastructure/services/product.repository.ts
+var BillingApiError = class _BillingApiError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "BillingApiError";
+    Object.setPrototypeOf(this, _BillingApiError.prototype);
+  }
+};
+function isBillingApiError(error) {
+  return error instanceof BillingApiError;
+}
+var ProductRepository = class {
+  http;
+  apiToken;
+  baseUrl;
+  constructor(config, http = new FetchHttpClient()) {
+    this.http = http;
+    this.apiToken = config.apiToken;
+    this.baseUrl = config.baseUrl ?? API_BASE_URL;
+  }
+  async list(params, options) {
+    const query = new QueryBuilder({
+      organization_id: params?.organizationId,
+      is_recurring: params?.isRecurring,
+      page: params?.page,
+      limit: this.clampLimit(params?.limit)
+    });
+    const url = `${this.baseUrl}/products?${query.toString()}`;
+    const response = await this.http.request({
+      method: "GET",
+      url,
+      headers: this.authHeaders(),
+      signal: options?.signal,
+      timeoutMs: options?.timeoutMs
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new BillingApiError(
+        `Billing API error: ${response.status}`,
+        response.status,
+        body
+      );
+    }
+    return mapProductList(response.data);
+  }
+  async findById(productId, options) {
+    const url = `${this.baseUrl}/products/${encodeURIComponent(productId)}`;
+    const response = await this.http.request({
+      method: "GET",
+      url,
+      headers: this.authHeaders(),
+      signal: options?.signal,
+      timeoutMs: options?.timeoutMs
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      const body = await response.text();
+      throw new BillingApiError(
+        `Billing API error: ${response.status}`,
+        response.status,
+        body
+      );
+    }
+    if (!response.data) {
+      throw new BillingApiError(
+        "Billing API returned an empty product body",
+        response.status
+      );
+    }
+    return mapProduct(response.data);
+  }
+  iterateAll(params, options = {}) {
+    const limit = this.clampLimit(options.limit);
+    const fetcher = {
+      fetchPage: async (page, pageLimit) => {
+        const response = await this.list(
+          { ...params, page, limit: pageLimit },
+          { signal: options.signal }
+        );
+        const pageData = {
+          items: response.items,
+          page,
+          totalCount: response.pagination.totalCount,
+          maxPage: response.pagination.maxPage,
+          isLast: page >= response.pagination.maxPage
+        };
+        return pageData;
+      }
+    };
+    return new PageIterator(fetcher, { limit, signal: options.signal });
+  }
+  async listAll(params, options = {}) {
+    const out = [];
+    for await (const product of this.iterateAll(params, options)) {
+      out.push(product);
+    }
+    return out;
+  }
+  authHeaders() {
+    return { Authorization: `Bearer ${this.apiToken}` };
+  }
+  clampLimit(limit) {
+    return PaginationClamp.pageSize(limit, API_MAX_PAGE_SIZE);
+  }
+};
+var defaultClient = new FetchHttpClient();
+async function getProducts(config, params, options) {
+  return new ProductRepository(config, defaultClient).list(params, options);
+}
+async function getProductById(config, productId, options) {
+  return new ProductRepository(config, defaultClient).findById(productId, options);
+}
+async function getAllProducts(config, params, options = {}) {
+  return new ProductRepository(config, defaultClient).listAll(params, options);
+}
+
+// src/presentation/components/BillingProvider.tsx
+var import_react2 = require("react");
+
+// src/infrastructure/utils/security.util.ts
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "[::1]"]);
+function isValidCheckoutUrl(url) {
+  return typeof url === "string" && (url.startsWith("https://") || url.startsWith("http://"));
+}
+function isInsecureUrl(url) {
+  return typeof url === "string" && url.startsWith("http://");
+}
+function isLoopbackHost(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return LOOPBACK_HOSTS.has(host);
+  } catch {
+    return false;
+  }
+}
+function isProductionInsecureUrl(url) {
+  return isInsecureUrl(url) && !isLoopbackHost(url);
+}
+
+// src/infrastructure/utils/validation.util.ts
+function normalizeUserId(userId) {
+  if (typeof userId !== "string") return void 0;
+  const trimmed = userId.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function isValidProductId(productId) {
+  return typeof productId === "string" && productId.trim().length > 0;
+}
+
+// src/presentation/navigation/navigation.strategy.ts
+var WindowNavigationStrategy = class {
+  redirect(url) {
+    window.location.href = url;
+  }
+};
+var NoopNavigationStrategy = class {
+  redirect(_url) {
+  }
+};
+
+// src/presentation/context/billing-context.ts
+var import_react = require("react");
+var BillingContext = (0, import_react.createContext)(void 0);
+function useBilling() {
+  const ctx = (0, import_react.useContext)(BillingContext);
+  if (!ctx) {
+    throw new Error("useBilling must be used within <BillingProvider>");
+  }
+  return ctx;
+}
+
+// src/presentation/components/BillingProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function defaultNavigation() {
+  if (typeof window === "undefined") return new NoopNavigationStrategy();
+  return {
+    redirect(url) {
+      window.location.href = url;
+    }
+  };
+}
+function BillingProvider({
+  adapter,
+  userId,
+  navigation,
+  children
+}) {
+  const [status, setStatus] = (0, import_react2.useState)(FREE_SUBSCRIPTION_STATUS);
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const adapterRef = (0, import_react2.useRef)(adapter);
+  const userIdRef = (0, import_react2.useRef)(normalizeUserId(userId));
+  const navigationRef = (0, import_react2.useRef)(navigation ?? defaultNavigation());
+  const refreshGenerationRef = (0, import_react2.useRef)(0);
+  adapterRef.current = adapter;
+  userIdRef.current = normalizeUserId(userId);
+  navigationRef.current = navigation ?? navigationRef.current;
+  const refresh = (0, import_react2.useCallback)(async () => {
+    const generation = ++refreshGenerationRef.current;
+    const uid = userIdRef.current;
+    if (!uid) {
+      setStatus(FREE_SUBSCRIPTION_STATUS);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    try {
+      const next = await adapterRef.current.getStatus(uid);
+      if (generation !== refreshGenerationRef.current) return;
+      setStatus(next);
+    } catch {
+      if (generation !== refreshGenerationRef.current) return;
+      setStatus(FREE_SUBSCRIPTION_STATUS);
+    } finally {
+      if (generation === refreshGenerationRef.current) {
+        setLoading(false);
+      }
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    void refresh();
+  }, [userId, refresh]);
+  const startCheckout = (0, import_react2.useCallback)(async (params) => {
+    if (!isValidProductId(params.productId)) {
+      throw new Error("[billing] Invalid productId: must be a non-empty string");
+    }
+    const uid = userIdRef.current;
+    if (!uid) {
+      throw new Error("[billing] Cannot start checkout: no authenticated user");
+    }
+    const result = await adapterRef.current.createCheckout({ ...params, userId: uid });
+    if (!isValidCheckoutUrl(result.url)) {
+      throw new Error("[billing] Invalid checkout URL: must start with https:// or http://");
+    }
+    if (isProductionInsecureUrl(result.url)) {
+      throw new Error("[billing] Insecure http:// checkout URL in production");
+    }
+    navigationRef.current.redirect(result.url);
+  }, []);
+  const syncSubscription = (0, import_react2.useCallback)(async () => {
+    const uid = userIdRef.current;
+    if (!uid) return { synced: false };
+    const checkoutId = typeof window !== "undefined" ? new URLSearchParams(window.location.search).get("checkout_id") ?? void 0 : void 0;
+    const result = await adapterRef.current.syncSubscription(uid, checkoutId);
+    if (result.synced) {
+      await refresh();
+    }
+    return result;
+  }, [refresh]);
+  const getBillingHistory = (0, import_react2.useCallback)(async () => {
+    const uid = userIdRef.current;
+    if (!uid) return [];
+    return adapterRef.current.getBillingHistory(uid);
+  }, []);
+  const cancelSubscription = (0, import_react2.useCallback)(
+    async (reason) => {
+      const result = await adapterRef.current.cancelSubscription(reason);
+      if (result.success) {
+        await refresh();
+      }
+      return result;
+    },
+    [refresh]
+  );
+  const getPortalUrl = (0, import_react2.useCallback)(async () => {
+    const uid = userIdRef.current;
+    if (!uid) {
+      throw new Error("[billing] Cannot get portal URL: no authenticated user");
+    }
+    return adapterRef.current.getPortalUrl(uid);
+  }, []);
+  const value = (0, import_react2.useMemo)(
+    () => ({
+      status,
+      loading,
+      refresh,
+      startCheckout,
+      syncSubscription,
+      getBillingHistory,
+      cancelSubscription,
+      getPortalUrl
+    }),
+    [
+      status,
+      loading,
+      refresh,
+      startCheckout,
+      syncSubscription,
+      getBillingHistory,
+      cancelSubscription,
+      getPortalUrl
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BillingContext.Provider, { value, children });
+}
+
+// src/presentation/components/CheckoutButton.tsx
+var import_react5 = require("react");
+
+// src/presentation/hooks/useCheckoutButton.ts
+var import_react3 = require("react");
+function useCheckoutButton(options) {
+  const { startCheckout } = useBilling();
+  const [loading, setLoading] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const { productId, billingCycle, successUrl, planKey, onError } = options;
+  const start = (0, import_react3.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      await startCheckout({
+        productId,
+        billingCycle,
+        successUrl,
+        planKey
+      });
+    } catch (err) {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      setError(normalized);
+      onError?.(normalized);
+    } finally {
+      setLoading(false);
+    }
+  }, [startCheckout, productId, billingCycle, successUrl, planKey, onError]);
+  return { start, loading, error };
+}
+
+// src/presentation/theme/visual-tokens.ts
+var VisualTokens = Object.freeze({
+  spacing: Object.freeze({
+    none: 0,
+    xs: 4,
+    sm: 6,
+    md: 8,
+    lg: 12,
+    xl: 16,
+    xxl: 20,
+    section: 24,
+    page: 32
+  }),
+  radius: Object.freeze({
+    sm: 6,
+    md: 8,
+    lg: 12,
+    pill: 999
+  }),
+  fontSize: Object.freeze({
+    caption: 12,
+    body: 14,
+    title: 18,
+    display: 24
+  }),
+  fontWeight: Object.freeze({
+    regular: 400,
+    medium: 500,
+    strong: 600
+  }),
+  lineHeight: Object.freeze({
+    tight: 1.25,
+    normal: 1.5
+  }),
+  opacity: Object.freeze({
+    muted: 0.7,
+    disabled: 0.6,
+    hover: 0.85
+  }),
+  color: Object.freeze({
+    textPrimary: "#111827",
+    textMuted: "#6b7280",
+    textOnPrimary: "#ffffff",
+    textInverse: "#ffffff",
+    textError: "#b91c1c",
+    textOnError: "#ffffff",
+    surfacePrimary: "#ffffff",
+    surfaceMuted: "#f9fafb",
+    surfaceSubtle: "#f3f4f6",
+    surfaceWarning: "#fef3c7",
+    surfaceDanger: "#fee2e2",
+    surfaceDangerMuted: "#fef2f2",
+    borderSubtle: "#e5e7eb",
+    borderStrong: "#d1d5db",
+    borderWarning: "#fecaca",
+    brandPrimary: "#2563eb",
+    brandPrimaryHover: "#1d4ed8",
+    brandDanger: "#dc2626",
+    brandDangerHover: "#b91c1c",
+    brandDangerText: "#991b1b",
+    badgeNeutralBg: "#e5e7eb",
+    badgeNeutralFg: "#111827",
+    badgeActiveBg: "#dcfce7",
+    badgeActiveFg: "#166534",
+    badgeWarningBg: "#fef3c7",
+    badgeWarningFg: "#92400e",
+    badgeDangerBg: "#fee2e2",
+    badgeDangerFg: "#991b1b"
+  }),
+  transition: Object.freeze({
+    instant: "120ms ease"
+  }),
+  layout: Object.freeze({
+    cardMinWidth: 260,
+    benefitListMax: 5
+  })
+});
+var TONE_PAIRS = Object.freeze({
+  neutral: { bg: VisualTokens.color.badgeNeutralBg, fg: VisualTokens.color.badgeNeutralFg },
+  active: { bg: VisualTokens.color.badgeActiveBg, fg: VisualTokens.color.badgeActiveFg },
+  warning: { bg: VisualTokens.color.badgeWarningBg, fg: VisualTokens.color.badgeWarningFg },
+  danger: { bg: VisualTokens.color.badgeDangerBg, fg: VisualTokens.color.badgeDangerFg }
+});
+
+// src/presentation/utils/checkout-button-visual.ts
+var VARIANT_COLOR_SCHEMES = Object.freeze({
+  primary: Object.freeze({
+    backgroundColor: VisualTokens.color.brandPrimary,
+    color: VisualTokens.color.textOnPrimary,
+    border: `1px solid ${VisualTokens.color.brandPrimary}`
+  }),
+  secondary: Object.freeze({
+    backgroundColor: VisualTokens.color.surfacePrimary,
+    color: VisualTokens.color.textPrimary,
+    border: `1px solid ${VisualTokens.color.borderStrong}`
+  }),
+  danger: Object.freeze({
+    backgroundColor: VisualTokens.color.brandDanger,
+    color: VisualTokens.color.textOnPrimary,
+    border: `1px solid ${VisualTokens.color.brandDanger}`
+  })
+});
+var CheckoutButtonVisual = class {
+  static resolve({ variant, disabled, loading }) {
+    const scheme = VARIANT_COLOR_SCHEMES[variant];
+    const isInactive = disabled || loading;
+    return {
+      ...scheme,
+      padding: `${VisualTokens.spacing.lg}px ${VisualTokens.spacing.xl}px`,
+      fontSize: VisualTokens.fontSize.body,
+      fontWeight: VisualTokens.fontWeight.strong,
+      borderRadius: VisualTokens.radius.md,
+      cursor: isInactive ? "not-allowed" : "pointer",
+      opacity: isInactive ? VisualTokens.opacity.disabled : 1,
+      transition: VisualTokens.transition.instant
+    };
+  }
+};
+
+// src/presentation/utils/inline-error-visual.ts
+var import_react4 = require("react");
+var InlineErrorVisual = class _InlineErrorVisual {
+  static style() {
+    return {
+      color: VisualTokens.color.textError,
+      fontSize: VisualTokens.fontSize.caption
+    };
+  }
+  static element(message) {
+    if (!message) return null;
+    return (0, import_react4.createElement)(
+      "span",
+      { role: "alert", style: _InlineErrorVisual.style() },
+      message
+    );
+  }
+};
+
+// src/presentation/components/CheckoutButton.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var DEFAULT_LABELS = Object.freeze({
+  loading: "Redirecting\u2026"
+});
+function CheckoutButton({
+  productId,
+  billingCycle,
+  successUrl,
+  planKey,
+  label,
+  variant = "primary",
+  disabled = false,
+  onError,
+  className,
+  labels
+}) {
+  const { start, loading, error } = useCheckoutButton({
+    productId,
+    billingCycle,
+    successUrl,
+    planKey,
+    onError
+  });
+  const style = (0, import_react5.useMemo)(
+    () => CheckoutButtonVisual.resolve({ variant, disabled, loading }),
+    [variant, disabled, loading]
+  );
+  const text = (0, import_react5.useMemo)(
+    () => ({ ...DEFAULT_LABELS, ...labels }),
+    [labels]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: { display: "inline-flex", flexDirection: "column", gap: 4 }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "button",
+      {
+        type: "button",
+        style,
+        className,
+        onClick: () => void start(),
+        disabled: disabled || loading,
+        "aria-busy": loading,
+        children: loading ? text.loading : label
+      }
+    ),
+    InlineErrorVisual.element(error?.message)
+  ] });
+}
+
+// src/presentation/components/SubscriptionStatusBadge.tsx
+var import_react6 = require("react");
+
+// src/presentation/utils/status-tone.ts
+var StatusTone = class _StatusTone {
+  static MAP = Object.freeze({
+    active: "active",
+    trialing: "active",
+    past_due: "warning",
+    incomplete: "warning",
+    canceled: "danger",
+    revoked: "danger",
+    unpaid: "danger",
+    incomplete_expired: "danger",
+    none: "neutral"
+  });
+  static forStatus(status) {
+    return _StatusTone.MAP[status] ?? "neutral";
+  }
+  static pairFor(status) {
+    return TONE_PAIRS[_StatusTone.forStatus(status)];
+  }
+};
+
+// src/presentation/utils/status-label.ts
+var StatusLabel = class _StatusLabel {
+  static MAP = Object.freeze({
+    active: "Active",
+    trialing: "Trial",
+    past_due: "Past due",
+    incomplete: "Incomplete",
+    canceled: "Canceled",
+    revoked: "Revoked",
+    unpaid: "Unpaid",
+    incomplete_expired: "Expired",
+    none: "Free"
+  });
+  static forStatus(status, overrides) {
+    return overrides?.[status] ?? _StatusLabel.MAP[status] ?? "Free";
+  }
+};
+
+// src/infrastructure/utils/date-renderer.ts
+var DEFAULT_LOCALE = "en-US";
+var ISO_DATE_DISPLAY_LENGTH = 10;
+var FALLBACK_DATE_LABEL = "soon";
+var FALLBACK_LONG_DATE = "\u2014";
+var DateRenderer = class _DateRenderer {
+  dateLength;
+  shortFormatter;
+  longFormatter;
+  constructor(locale = DEFAULT_LOCALE, dateLength = ISO_DATE_DISPLAY_LENGTH) {
+    this.dateLength = dateLength;
+    this.shortFormatter = new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+    this.longFormatter = new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  }
+  short(iso) {
+    if (!iso) return FALLBACK_LONG_DATE;
+    return iso.slice(0, this.dateLength);
+  }
+  renewal(iso, fallback = FALLBACK_DATE_LABEL) {
+    const date = _DateRenderer.parse(iso);
+    if (!date) return fallback;
+    return this.shortFormatter.format(date);
+  }
+  long(iso) {
+    if (!iso) return FALLBACK_LONG_DATE;
+    const date = _DateRenderer.parse(iso);
+    if (!date) return iso;
+    return this.longFormatter.format(date);
+  }
+  static parse(iso) {
+    if (!iso) return null;
+    const date = new Date(iso);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+};
+
+// src/presentation/components/SubscriptionStatusBadge.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var DEFAULT_LABELS2 = Object.freeze({
+  loading: "Loading\u2026",
+  endsPrefix: "ends"
+});
+function SubscriptionStatusBadge({
+  status: statusOverride,
+  loading: loadingOverride,
+  locale,
+  labels
+}) {
+  const ctx = useBilling();
+  const status = statusOverride ?? ctx.status;
+  const loading = loadingOverride ?? ctx.loading;
+  const dateRenderer = (0, import_react6.useMemo)(() => new DateRenderer(locale), [locale]);
+  const text = (0, import_react6.useMemo)(
+    () => ({ ...DEFAULT_LABELS2, ...labels }),
+    [labels]
+  );
+  const pillStyle = (0, import_react6.useMemo)(
+    () => ({
+      padding: `${VisualTokens.spacing.xs}px ${VisualTokens.spacing.lg - 2}px`,
+      borderRadius: VisualTokens.radius.pill,
+      fontSize: VisualTokens.fontSize.caption,
+      fontWeight: VisualTokens.fontWeight.strong
+    }),
+    []
+  );
+  if (loading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "span",
+      {
+        style: {
+          ...pillStyle,
+          ...TONE_PAIRS.neutral
+        },
+        children: text.loading
+      }
+    );
+  }
+  const tone = StatusTone.forStatus(status.subscriptionStatus);
+  const color = TONE_PAIRS[tone];
+  const label = StatusLabel.forStatus(status.subscriptionStatus, labels?.statuses);
+  const showPlan = status.plan && status.plan !== "free";
+  const showEnds = status.cancelAtPeriodEnd;
+  const endsLabel = showEnds ? `${text.endsPrefix} ${dateRenderer.renewal(status.currentPeriodEnd)}` : null;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "span",
+    {
+      "aria-label": `Subscription ${label}`,
+      style: {
+        backgroundColor: color.bg,
+        color: color.fg,
+        padding: pillStyle.padding,
+        borderRadius: VisualTokens.radius.pill,
+        fontSize: VisualTokens.fontSize.caption,
+        fontWeight: VisualTokens.fontWeight.strong,
+        display: "inline-flex",
+        alignItems: "center",
+        gap: VisualTokens.spacing.xs + 2
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { textTransform: "capitalize" }, children: label }),
+        showPlan ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { style: { opacity: VisualTokens.opacity.muted }, children: [
+          "\xB7 ",
+          status.plan
+        ] }) : null,
+        endsLabel ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { style: { opacity: VisualTokens.opacity.muted }, children: [
+          "\xB7 ",
+          endsLabel
+        ] }) : null
+      ]
+    }
+  );
+}
+
+// src/presentation/components/PricingTable.tsx
+var import_react8 = require("react");
+
+// src/presentation/hooks/useProducts.ts
+var import_react7 = require("react");
+function useProducts(options) {
+  const { apiToken, organizationId, isRecurring = true, enabled = true } = options;
+  const [products, setProducts] = (0, import_react7.useState)([]);
+  const [loading, setLoading] = (0, import_react7.useState)(enabled);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const optionsRef = (0, import_react7.useRef)({ apiToken, organizationId, isRecurring, enabled });
+  optionsRef.current = { apiToken, organizationId, isRecurring, enabled };
+  const abortRef = (0, import_react7.useRef)(null);
+  const fetchProducts = (0, import_react7.useCallback)(async () => {
+    const { apiToken: token, organizationId: org, isRecurring: recurring, enabled: isEnabled } = optionsRef.current;
+    abortRef.current?.abort();
+    if (!isEnabled) {
+      setLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    abortRef.current = controller;
+    setLoading(true);
+    setError(null);
+    try {
+      const params = { isRecurring: recurring };
+      if (org) params.organizationId = org;
+      const data = await getAllProducts({ apiToken: token }, params, {
+        signal: controller.signal
+      });
+      if (controller.signal.aborted) return;
+      setProducts(data);
+    } catch (err) {
+      if (controller.signal.aborted) return;
+      setError(err instanceof Error ? err : new Error("Failed to fetch products"));
+    } finally {
+      if (!controller.signal.aborted) {
+        setLoading(false);
+      }
+    }
+  }, []);
+  (0, import_react7.useEffect)(() => {
+    void fetchProducts();
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, [apiToken, organizationId, isRecurring, enabled, fetchProducts]);
+  return { products, loading, error, refetch: fetchProducts };
+}
+
+// src/presentation/utils/product-pricing.ts
+var FALLBACK_PRICE_LABEL = "Custom";
+var ProductPricing = class _ProductPricing {
+  static recurringPrice(product, cycle) {
+    const recurring = product.prices.filter(
+      (p) => p.recurringInterval !== void 0
+    );
+    if (recurring.length === 0) {
+      return product.prices[0] ?? null;
+    }
+    if (cycle) {
+      const match = recurring.find((p) => p.recurringInterval === cycle);
+      if (match) return match;
+    }
+    return recurring[0] ?? null;
+  }
+  static displayLine(product, formatter, cycle) {
+    const price = _ProductPricing.recurringPrice(product, cycle);
+    if (!price) {
+      return { amount: FALLBACK_PRICE_LABEL, interval: null };
+    }
+    const amount = formatter(price.amount, price.currency);
+    return { amount, interval: price.recurringInterval ?? null };
+  }
+};
+
+// src/infrastructure/utils/money-formatter.ts
+var DEFAULT_LOCALE2 = "en-US";
+var DEFAULT_CURRENCY = "USD";
+var MoneyFormatter = class {
+  locale;
+  constructor(locale = DEFAULT_LOCALE2) {
+    this.locale = locale;
+  }
+  format(amount, currency, options = {}) {
+    if (amount === void 0 || amount === null) {
+      return "Custom";
+    }
+    const code = (currency ?? options.fallbackCurrency ?? DEFAULT_CURRENCY).toUpperCase();
+    try {
+      return new Intl.NumberFormat(this.locale, {
+        style: "currency",
+        currency: code,
+        maximumFractionDigits: options.maximumFractionDigits ?? 2
+      }).format(amount / minorUnitDivisor(code));
+    } catch {
+      return `${amount} ${code}`;
+    }
+  }
+};
+
+// src/presentation/components/PricingTable.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var DEFAULT_LABELS3 = Object.freeze({
+  loading: "Loading pricing\u2026",
+  empty: "No products available.",
+  errorPrefix: "Failed to load pricing:",
+  retry: "Retry"
+});
+function PricingTable({
+  products: productsOverride,
+  apiToken,
+  organizationId,
+  isRecurring = true,
+  ctaLabel = "Subscribe",
+  onError,
+  filterInterval = "monthly",
+  locale,
+  labels
+}) {
+  const enabled = productsOverride === void 0 && apiToken !== void 0;
+  const { products: fetchedProducts, loading, error, refetch } = useProducts({
+    apiToken: apiToken ?? "",
+    organizationId,
+    isRecurring,
+    enabled
+  });
+  const products = productsOverride ?? fetchedProducts;
+  const moneyFormatter = (0, import_react8.useMemo)(() => new MoneyFormatter(locale), [locale]);
+  const text = (0, import_react8.useMemo)(
+    () => ({ ...DEFAULT_LABELS3, ...labels }),
+    [labels]
+  );
+  const visible = (0, import_react8.useMemo)(() => {
+    if (filterInterval === null) return products;
+    return products.filter((p) => p.recurringInterval === filterInterval);
+  }, [products, filterInterval]);
+  if (enabled && loading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "div",
+      {
+        role: "status",
+        "aria-live": "polite",
+        style: {
+          padding: VisualTokens.spacing.section,
+          textAlign: "center"
+        },
+        children: text.loading
+      }
+    );
+  }
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+      "div",
+      {
+        role: "alert",
+        style: {
+          padding: VisualTokens.spacing.xl,
+          background: VisualTokens.color.surfaceDanger,
+          borderRadius: VisualTokens.radius.md
+        },
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("p", { style: { margin: 0, color: VisualTokens.color.brandDangerText }, children: [
+            text.errorPrefix,
+            " ",
+            error.message
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            "button",
+            {
+              type: "button",
+              onClick: () => void refetch(),
+              style: { marginTop: VisualTokens.spacing.md, padding: "6px 12px" },
+              children: text.retry
+            }
+          )
+        ]
+      }
+    );
+  }
+  if (visible.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "div",
+      {
+        style: {
+          padding: VisualTokens.spacing.section,
+          textAlign: "center",
+          color: VisualTokens.color.textMuted
+        },
+        children: text.empty
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "div",
+    {
+      style: {
+        display: "grid",
+        gridTemplateColumns: `repeat(auto-fit, minmax(${VisualTokens.layout.cardMinWidth}px, 1fr))`,
+        gap: VisualTokens.spacing.xl
+      },
+      children: visible.map((product) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        ProductCard,
+        {
+          product,
+          moneyFormatter,
+          ctaLabel,
+          onError
+        },
+        product.id
+      ))
+    }
+  );
+}
+function ProductCard({ product, moneyFormatter, ctaLabel, onError }) {
+  const { amount, interval } = (0, import_react8.useMemo)(
+    () => ProductPricing.displayLine(
+      product,
+      (amt, cur) => moneyFormatter.format(amt, cur)
+    ),
+    [product, moneyFormatter]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+    "article",
+    {
+      style: {
+        border: `1px solid ${VisualTokens.color.borderSubtle}`,
+        borderRadius: VisualTokens.radius.lg,
+        padding: VisualTokens.spacing.xxl,
+        display: "flex",
+        flexDirection: "column",
+        gap: VisualTokens.spacing.lg
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("header", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h3", { style: { margin: 0, fontSize: VisualTokens.fontSize.title }, children: product.name }),
+          product.description ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            "p",
+            {
+              style: {
+                margin: `${VisualTokens.spacing.xs}px 0 0`,
+                color: VisualTokens.color.textMuted,
+                fontSize: VisualTokens.fontSize.body
+              },
+              children: product.description
+            }
+          ) : null
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: { fontSize: VisualTokens.fontSize.display, fontWeight: VisualTokens.fontWeight.strong }, children: [
+          amount,
+          interval ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+            "span",
+            {
+              style: {
+                fontSize: VisualTokens.fontSize.body,
+                fontWeight: VisualTokens.fontWeight.regular,
+                color: VisualTokens.color.textMuted
+              },
+              children: [
+                " ",
+                "/ ",
+                interval
+              ]
+            }
+          ) : null
+        ] }),
+        product.benefits.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "ul",
+          {
+            style: {
+              paddingLeft: 18,
+              margin: 0,
+              color: "#374151",
+              fontSize: VisualTokens.fontSize.body
+            },
+            children: product.benefits.slice(0, VisualTokens.layout.benefitListMax).map((b) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("li", { children: b.description ?? b.type }, b.id))
+          }
+        ) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { marginTop: "auto" }, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          CheckoutButton,
+          {
+            productId: product.id,
+            billingCycle: product.recurringInterval ?? void 0,
+            label: ctaLabel,
+            onError
+          }
+        ) })
+      ]
+    }
+  );
+}
+
+// src/presentation/components/BillingHistoryList.tsx
+var import_react9 = require("react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var DEFAULT_LABELS4 = Object.freeze({
+  loading: "Loading billing history\u2026",
+  empty: "No invoices yet.",
+  refresh: "Refresh",
+  retry: "Retry",
+  paid: "Paid",
+  invoiceLink: "View",
+  invoiceFallback: "\u2014",
+  colDate: "Date",
+  colProduct: "Product",
+  colStatus: "Status",
+  colAmount: "Amount",
+  colInvoice: "Invoice"
+});
+function BillingHistoryList({
+  autoLoad = true,
+  orders: ordersOverride,
+  loading: loadingOverride,
+  locale,
+  labels
+}) {
+  const { getBillingHistory } = useBilling();
+  const [orders, setOrders] = (0, import_react9.useState)(ordersOverride ?? []);
+  const [loading, setLoading] = (0, import_react9.useState)(autoLoad && ordersOverride === void 0);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const moneyFormatter = (0, import_react9.useMemo)(() => new MoneyFormatter(locale), [locale]);
+  const dateRenderer = (0, import_react9.useMemo)(() => new DateRenderer(locale), [locale]);
+  const text = (0, import_react9.useMemo)(
+    () => ({ ...DEFAULT_LABELS4, ...labels }),
+    [labels]
+  );
+  const refresh = (0, import_react9.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const next = await getBillingHistory();
+      setOrders(next);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load billing history");
+    } finally {
+      setLoading(false);
+    }
+  }, [getBillingHistory]);
+  (0, import_react9.useEffect)(() => {
+    if (autoLoad && ordersOverride === void 0) {
+      void refresh();
+    }
+  }, [autoLoad, ordersOverride, refresh]);
+  if (ordersOverride !== void 0 && ordersOverride.length > 0) {
+    return renderList(ordersOverride, moneyFormatter, dateRenderer, text);
+  }
+  if (loadingOverride !== void 0 && loadingOverride) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { role: "status", children: text.loading });
+  }
+  if (loading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { role: "status", children: text.loading });
+  }
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+      "div",
+      {
+        role: "alert",
+        style: {
+          background: VisualTokens.color.surfaceDanger,
+          padding: VisualTokens.spacing.lg,
+          borderRadius: VisualTokens.radius.md
+        },
+        children: [
+          error,
+          " ",
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("button", { type: "button", onClick: () => void refresh(), children: text.retry })
+        ]
+      }
+    );
+  }
+  if (orders.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: { color: VisualTokens.color.textMuted }, children: text.empty });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: { marginBottom: VisualTokens.spacing.md }, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("button", { type: "button", onClick: () => void refresh(), children: text.refresh }) }),
+    renderList(orders, moneyFormatter, dateRenderer, text)
+  ] });
+}
+function renderList(orders, moneyFormatter, dateRenderer, text) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("table", { style: { width: "100%", borderCollapse: "collapse" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("tr", { style: { textAlign: "left", borderBottom: `1px solid ${VisualTokens.color.borderSubtle}` }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("th", { style: { padding: VisualTokens.spacing.md }, children: text.colDate }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("th", { style: { padding: VisualTokens.spacing.md }, children: text.colProduct }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("th", { style: { padding: VisualTokens.spacing.md }, children: text.colStatus }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("th", { style: { padding: VisualTokens.spacing.md }, children: text.colAmount }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("th", { style: { padding: VisualTokens.spacing.md }, children: text.colInvoice })
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("tbody", { children: orders.map((order) => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("tr", { style: { borderBottom: `1px solid ${VisualTokens.color.surfaceSubtle}` }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("td", { style: { padding: VisualTokens.spacing.md }, children: dateRenderer.short(order.createdAt) }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("td", { style: { padding: VisualTokens.spacing.md }, children: order.productName }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("td", { style: { padding: VisualTokens.spacing.md }, children: order.paid ? text.paid : order.status }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("td", { style: { padding: VisualTokens.spacing.md }, children: moneyFormatter.format(order.amount, order.currency) }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("td", { style: { padding: VisualTokens.spacing.md }, children: order.invoiceUrl ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("a", { href: order.invoiceUrl, target: "_blank", rel: "noreferrer", children: text.invoiceLink }) : text.invoiceFallback })
+    ] }, order.id)) })
+  ] });
+}
+
+// src/presentation/components/CustomerPortalLink.tsx
+var import_react10 = require("react");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var DEFAULT_LABEL = "Manage subscription";
+var DEFAULT_LOADING_LABEL = "Opening\u2026";
+function CustomerPortalLink({
+  label = DEFAULT_LABEL,
+  target = "open",
+  className,
+  labels
+}) {
+  const { getPortalUrl } = useBilling();
+  const [loading, setLoading] = (0, import_react10.useState)(false);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const loadingLabel = labels?.loading ?? DEFAULT_LOADING_LABEL;
+  const open = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const url = await getPortalUrl();
+      if (target === "open") {
+        window.open(url, "_blank", "noopener,noreferrer");
+      } else {
+        window.location.href = url;
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to open portal");
+    } finally {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("span", { style: { display: "inline-flex", flexDirection: "column", gap: VisualTokens.spacing.xs }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      "button",
+      {
+        type: "button",
+        onClick: () => void open(),
+        disabled: loading,
+        className,
+        style: {
+          background: "transparent",
+          color: VisualTokens.color.brandPrimary,
+          border: "none",
+          padding: 0,
+          textDecoration: "underline",
+          cursor: loading ? "wait" : "pointer"
+        },
+        children: loading ? loadingLabel : label
+      }
+    ),
+    InlineErrorVisual.element(error)
+  ] });
+}
+
+// src/presentation/components/CancelSubscriptionButton.tsx
+var import_react12 = require("react");
+
+// src/presentation/hooks/useCancelSubscription.ts
+var import_react11 = require("react");
+function useCancelSubscription(options = {}) {
+  const { cancelSubscription } = useBilling();
+  const [loading, setLoading] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const { onSuccess, onError } = options;
+  const cancel = (0, import_react11.useCallback)(
+    async (reason) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await cancelSubscription(reason);
+        onSuccess?.(result);
+        return result;
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error(String(err));
+        setError(normalized);
+        onError?.(normalized);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [cancelSubscription, onSuccess, onError]
+  );
+  return { cancel, loading, error };
+}
+
+// src/presentation/utils/cancellation-reason-catalog.ts
+var CANCELLATION_REASON_CATALOG = Object.freeze([
+  { value: "too_expensive", label: "Too expensive" },
+  { value: "missing_features", label: "Missing features" },
+  { value: "switched_service", label: "Switched to a different service" },
+  { value: "unused", label: "Not using it" },
+  { value: "customer_service", label: "Poor customer service" },
+  { value: "low_quality", label: "Quality is too low" },
+  { value: "too_complex", label: "Too complex" },
+  { value: "other", label: "Other" }
+]);
+
+// src/presentation/components/CancelSubscriptionButton.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var DEFAULT_LABELS5 = Object.freeze({
+  action: "Cancel subscription",
+  confirm: "Confirm cancel",
+  keep: "Keep subscription",
+  canceling: "Canceling\u2026",
+  promptTitle: "Why are you canceling? (optional)",
+  noReason: "Prefer not to say"
+});
+function CancelSubscriptionButton({
+  label,
+  renderPrompt,
+  onSuccess,
+  reasonCatalog = CANCELLATION_REASON_CATALOG,
+  labels
+}) {
+  const { cancel, loading, error } = useCancelSubscription({
+    onSuccess: () => onSuccess?.()
+  });
+  const [promptOpen, setPromptOpen] = (0, import_react12.useState)(false);
+  const [reason, setReason] = (0, import_react12.useState)("");
+  const text = { ...DEFAULT_LABELS5, ...labels };
+  const triggerLabel = label ?? text.action;
+  const onConfirm = async (selected) => {
+    setPromptOpen(false);
+    const result = await cancel(selected);
+    if (result?.success) {
+      setReason("");
+    }
+  };
+  if (!promptOpen) {
+    return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("span", { style: { display: "inline-flex", flexDirection: "column", gap: VisualTokens.spacing.xs }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+        "button",
+        {
+          type: "button",
+          onClick: () => setPromptOpen(true),
+          style: {
+            background: "transparent",
+            color: VisualTokens.color.brandDangerText,
+            border: `1px solid ${VisualTokens.color.borderWarning}`,
+            borderRadius: VisualTokens.radius.md,
+            padding: `${VisualTokens.spacing.md}px ${VisualTokens.spacing.lg}px`,
+            cursor: "pointer",
+            fontWeight: VisualTokens.fontWeight.strong
+          },
+          children: triggerLabel
+        }
+      ),
+      InlineErrorVisual.element(error?.message)
+    ] });
+  }
+  if (renderPrompt) {
+    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_jsx_runtime7.Fragment, { children: renderPrompt((selected) => void onConfirm(selected)) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    "div",
+    {
+      role: "dialog",
+      "aria-label": "Confirm cancellation",
+      style: {
+        border: `1px solid ${VisualTokens.color.borderWarning}`,
+        background: VisualTokens.color.surfaceDangerMuted,
+        borderRadius: VisualTokens.radius.md,
+        padding: VisualTokens.spacing.lg,
+        display: "flex",
+        flexDirection: "column",
+        gap: VisualTokens.spacing.md
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("label", { style: { fontSize: VisualTokens.fontSize.body, fontWeight: VisualTokens.fontWeight.strong }, children: [
+          text.promptTitle,
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+            "select",
+            {
+              value: reason,
+              onChange: (e) => setReason(e.target.value),
+              style: {
+                display: "block",
+                marginTop: VisualTokens.spacing.xs,
+                width: "100%",
+                padding: VisualTokens.spacing.sm
+              },
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: "", children: text.noReason }),
+                reasonCatalog.map((opt) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("option", { value: opt.value, children: opt.label }, opt.value))
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { display: "flex", gap: VisualTokens.spacing.md }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            "button",
+            {
+              type: "button",
+              onClick: () => void onConfirm(reason || void 0),
+              disabled: loading,
+              style: {
+                background: VisualTokens.color.brandDanger,
+                color: VisualTokens.color.textOnPrimary,
+                border: "none",
+                padding: `${VisualTokens.spacing.sm}px ${VisualTokens.spacing.lg}px`,
+                borderRadius: VisualTokens.radius.sm
+              },
+              children: loading ? text.canceling : text.confirm
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            "button",
+            {
+              type: "button",
+              onClick: () => setPromptOpen(false),
+              disabled: loading,
+              style: {
+                background: "transparent",
+                border: `1px solid ${VisualTokens.color.borderStrong}`,
+                padding: `${VisualTokens.spacing.sm}px ${VisualTokens.spacing.lg}px`,
+                borderRadius: VisualTokens.radius.sm
+              },
+              children: text.keep
+            }
+          )
+        ] }),
+        InlineErrorVisual.element(error?.message)
+      ]
+    }
+  );
+}
+
+// src/infrastructure/config/billing-env.ts
+var CHECKOUT_ID_PARAM = "checkout_id";
+
+// src/infrastructure/browser/hosted-checkout.ts
+function isSafeCheckoutUrl(url) {
+  if (typeof url !== "string" || url.length === 0) return false;
+  if (url.startsWith("https://")) return true;
+  return isInsecureUrl(url) && isLoopbackHost(url);
+}
+function redirectToHostedCheckout(url) {
+  if (!isSafeCheckoutUrl(url)) throw new Error("invalid_checkout_url");
+  window.location.assign(url);
+}
+function checkoutIdFromLocationSearch(search) {
+  const withoutLeading = search.startsWith("?") ? search.slice(1) : search;
+  for (const pair of withoutLeading.split("&")) {
+    const separator = pair.indexOf("=");
+    if (separator === -1) continue;
+    if (pair.slice(0, separator) !== CHECKOUT_ID_PARAM) continue;
+    const value = pair.slice(separator + 1);
+    if (value.length === 0) return null;
+    return decodeURIComponent(value);
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BILLING_CYCLE,
+  BILLING_CYCLE_VALUES,
+  BillingApiError,
+  BillingContext,
+  BillingHistoryList,
+  BillingProvider,
+  CANCELLATION_REASON,
+  CANCELLATION_REASON_CATALOG,
+  CANCELLATION_REASON_VALUES,
+  CHECKOUT_ID_PARAM,
+  CancelSubscriptionButton,
+  CheckoutButton,
+  CustomerPortalLink,
+  FREE_SUBSCRIPTION_STATUS,
+  FetchHttpClient,
+  NoopNavigationStrategy,
+  PAYMENT_PROVIDER,
+  PAYMENT_PROVIDER_VALUES,
+  POLAR_AMOUNT_TYPE,
+  PricingTable,
+  ProductRepository,
+  SUBSCRIPTION_STATUS,
+  SUBSCRIPTION_STATUS_VALUES,
+  SubscriptionStatusBadge,
+  TONE_PAIRS,
+  VisualTokens,
+  WindowNavigationStrategy,
+  applyPercentDiscount,
+  buildCheckoutMetadata,
+  checkoutIdFromLocationSearch,
+  createMemoryBillingAdapter,
+  formatReceiptNumber,
+  getAllProducts,
+  getProductById,
+  getProducts,
+  isActiveSubscription,
+  isBillingApiError,
+  isKnownBillingCycle,
+  isKnownPaymentProvider,
+  isKnownSubscriptionStatus,
+  isSafeCheckoutUrl,
+  mapProduct,
+  mapProductList,
+  minorUnitDivisor,
+  normalizeCouponCode,
+  parseBillingCycle,
+  readCheckoutMetadata,
+  redirectToHostedCheckout,
+  toMajorUnits,
+  toMinorUnits,
+  useBilling,
+  useCancelSubscription,
+  useCheckoutButton,
+  useProducts
+});