stripe-no-webhooks 0.0.8 → 0.0.11

package/dist/index.js

@@ -30,16 +30,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  createStripeHandler: () => createStripeHandler
+  Billing: () => Billing,
+  CreditError: () => CreditError,
+  FasterStripe: () => FasterStripe,
+  createHandler: () => createHandler,
+  credits: () => credits,
+  initCredits: () => initCredits
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/handler.ts
-var import_stripe_sync_engine = require("@supabase/stripe-sync-engine");
+// src/Billing.ts
+var import_stripe_sync_engine = require("@pretzelai/stripe-sync-engine");
 var import_stripe = __toESM(require("stripe"));
+var import_pg = require("pg");
 
-// src/utils.ts
-var getMode = (stripeKey) => {
+// src/helpers.ts
+function getMode(stripeKey) {
   if (stripeKey.includes("_test_")) {
     return "test";
   } else if (stripeKey.includes("_live_")) {
@@ -47,219 +53,2781 @@ var getMode = (stripeKey) => {
   } else {
     throw new Error("Invalid Stripe key");
   }
+}
+function planHasCredits(plan) {
+  return plan?.credits !== void 0 && Object.keys(plan.credits).length > 0;
+}
+function findPlanByPriceId(billingConfig, mode, priceId) {
+  const plans = billingConfig?.[mode]?.plans;
+  return plans?.find((p) => p.price.some((pr) => pr.id === priceId)) ?? null;
+}
+function getPlanFromSubscription(subscription, billingConfig, mode) {
+  const price = subscription.items.data[0]?.price;
+  if (!price) return null;
+  const priceId = typeof price === "string" ? price : price.id;
+  return findPlanByPriceId(billingConfig, mode, priceId);
+}
+function getCustomerIdFromSubscription(subscription) {
+  return typeof subscription.customer === "string" ? subscription.customer : subscription.customer.id;
+}
+async function getActiveSubscription(stripe, customerId) {
+  const subscriptions = await stripe.subscriptions.list({
+    customer: customerId,
+    limit: 10,
+    expand: ["data.items.data.price"]
+  });
+  return subscriptions.data.find(
+    (s) => s.status === "active" || s.status === "trialing"
+  ) ?? null;
+}
+async function getStripeCustomerId(pool2, schema2, userId) {
+  const result = await pool2.query(
+    `SELECT stripe_customer_id FROM ${schema2}.user_stripe_customer_map WHERE user_id = $1`,
+    [userId]
+  );
+  return result.rows[0]?.stripe_customer_id ?? null;
+}
+async function getUserIdFromCustomer(pool2, schema2, customerId) {
+  const result = await pool2.query(
+    `SELECT metadata->>'user_id' as user_id FROM ${schema2}.customers WHERE id = $1`,
+    [customerId]
+  );
+  return result.rows[0]?.user_id ?? null;
+}
+
+// src/credits/types.ts
+var CreditError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "CreditError";
+  }
 };
 
-// src/handler.ts
-function createStripeHandler(config = {}) {
-  const {
-    stripeSecretKey = process.env.STRIPE_SECRET_KEY,
-    stripeWebhookSecret = process.env.STRIPE_WEBHOOK_SECRET,
-    databaseUrl = process.env.DATABASE_URL,
-    schema = "stripe",
-    billingConfig,
-    successUrl: defaultSuccessUrl,
-    cancelUrl: defaultCancelUrl,
-    automaticTax = true,
-    callbacks
-  } = config;
-  const stripe = new import_stripe.default(stripeSecretKey);
-  const sync = databaseUrl ? new import_stripe_sync_engine.StripeSync({
-    poolConfig: {
-      connectionString: databaseUrl
-    },
-    schema,
-    stripeSecretKey,
-    stripeWebhookSecret
-  }) : null;
-  function resolvePriceId(body, mode) {
-    if (body.priceId) {
-      return body.priceId;
-    }
-    if (!body.interval) {
-      throw new Error("interval is required when using planName or planId");
-    }
-    if (!billingConfig?.[mode]?.plans) {
-      throw new Error(
-        "billingConfig with plans is required when using planName or planId"
+// src/credits/db.ts
+var pool = null;
+var schema = "stripe";
+function setPool(p, s = "stripe") {
+  pool = p;
+  schema = s;
+}
+function ensurePool() {
+  if (!pool) {
+    throw new Error("Database pool not initialized. Call setPool() first.");
+  }
+  return pool;
+}
+async function getBalance(userId, creditType) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT balance FROM ${schema}.credit_balances WHERE user_id = $1 AND credit_type_id = $2`,
+    [userId, creditType]
+  );
+  return result.rows.length > 0 ? Number(result.rows[0].balance) : 0;
+}
+async function getAllBalances(userId) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT credit_type_id, balance FROM ${schema}.credit_balances WHERE user_id = $1`,
+    [userId]
+  );
+  const balances = {};
+  for (const row of result.rows) {
+    balances[row.credit_type_id] = Number(row.balance);
+  }
+  return balances;
+}
+async function hasCredits(userId, creditType, amount) {
+  const balance = await getBalance(userId, creditType);
+  return balance >= amount;
+}
+async function checkIdempotencyKey(key) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT 1 FROM ${schema}.credit_ledger WHERE idempotency_key = $1`,
+    [key]
+  );
+  return result.rows.length > 0;
+}
+async function checkIdempotencyKeyPrefix(prefix) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT 1 FROM ${schema}.credit_ledger WHERE idempotency_key LIKE $1 LIMIT 1`,
+    [prefix + "%"]
+  );
+  return result.rows.length > 0;
+}
+async function countAutoTopUpsThisMonth(userId, creditType) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT COUNT(*) FROM ${schema}.credit_ledger
+     WHERE user_id = $1
+       AND credit_type_id = $2
+       AND source = 'auto_topup'
+       AND created_at >= date_trunc('month', now() AT TIME ZONE 'UTC')`,
+    [userId, creditType]
+  );
+  return parseInt(result.rows[0].count, 10);
+}
+function isUniqueViolation(error) {
+  return error instanceof Error && "code" in error && error.code === "23505";
+}
+async function writeLedgerEntry(client, userId, creditType, amount, balanceAfter, params) {
+  try {
+    await client.query(
+      `INSERT INTO ${schema}.credit_ledger
+       (user_id, credit_type_id, amount, balance_after, transaction_type, source, source_id, description, metadata, idempotency_key)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+      [
+        userId,
+        creditType,
+        amount,
+        balanceAfter,
+        params.transactionType,
+        params.source,
+        params.sourceId ?? null,
+        params.description ?? null,
+        params.metadata ? JSON.stringify(params.metadata) : null,
+        params.idempotencyKey ?? null
+      ]
+    );
+  } catch (error) {
+    if (isUniqueViolation(error) && params.idempotencyKey) {
+      throw new CreditError(
+        "IDEMPOTENCY_CONFLICT",
+        "Operation already processed",
+        {
+          idempotencyKey: params.idempotencyKey
+        }
       );
     }
-    const plan = body.planName ? billingConfig[mode]?.plans?.find((p) => p.name === body.planName) : body.planId ? billingConfig[mode]?.plans?.find((p) => p.id === body.planId) : null;
-    if (!plan) {
-      const identifier = body.planName || body.planId;
-      throw new Error(`Plan not found: ${identifier}`);
+    throw error;
+  }
+}
+async function ensureBalanceRowExists(client, userId, creditType) {
+  await client.query(
+    `INSERT INTO ${schema}.credit_balances (user_id, credit_type_id, balance)
+     VALUES ($1, $2, 0)
+     ON CONFLICT DO NOTHING`,
+    [userId, creditType]
+  );
+}
+async function getBalanceForUpdate(client, userId, creditType) {
+  await ensureBalanceRowExists(client, userId, creditType);
+  const result = await client.query(
+    `SELECT balance FROM ${schema}.credit_balances
+     WHERE user_id = $1 AND credit_type_id = $2
+     FOR UPDATE`,
+    [userId, creditType]
+  );
+  return Number(result.rows[0].balance);
+}
+async function setBalanceValue(client, userId, creditType, newBalance) {
+  await client.query(
+    `UPDATE ${schema}.credit_balances
+     SET balance = $3, updated_at = now()
+     WHERE user_id = $1 AND credit_type_id = $2`,
+    [userId, creditType, newBalance]
+  );
+}
+async function atomicAdd(userId, creditType, amount, params) {
+  const p = ensurePool();
+  const client = await p.connect();
+  try {
+    await client.query("BEGIN");
+    const currentBalance = await getBalanceForUpdate(
+      client,
+      userId,
+      creditType
+    );
+    const newBalance = currentBalance + amount;
+    await setBalanceValue(client, userId, creditType, newBalance);
+    await writeLedgerEntry(
+      client,
+      userId,
+      creditType,
+      amount,
+      newBalance,
+      params
+    );
+    await client.query("COMMIT");
+    return newBalance;
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function atomicConsume(userId, creditType, amount, params) {
+  const p = ensurePool();
+  const client = await p.connect();
+  try {
+    await client.query("BEGIN");
+    const currentBalance = await getBalanceForUpdate(
+      client,
+      userId,
+      creditType
+    );
+    if (currentBalance < amount) {
+      await client.query("ROLLBACK");
+      return { success: false, currentBalance };
     }
-    const price = plan.price.find((p) => p.interval === body.interval);
-    if (!price) {
-      throw new Error(
-        `Price with interval "${body.interval}" not found for plan "${plan.name}"`
+    const newBalance = currentBalance - amount;
+    await setBalanceValue(client, userId, creditType, newBalance);
+    await writeLedgerEntry(
+      client,
+      userId,
+      creditType,
+      -amount,
+      newBalance,
+      params
+    );
+    await client.query("COMMIT");
+    return { success: true, newBalance };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function atomicRevoke(userId, creditType, maxAmount, params) {
+  const p = ensurePool();
+  const client = await p.connect();
+  try {
+    await client.query("BEGIN");
+    const currentBalance = await getBalanceForUpdate(
+      client,
+      userId,
+      creditType
+    );
+    const amountRevoked = Math.min(maxAmount, currentBalance);
+    const newBalance = currentBalance - amountRevoked;
+    if (amountRevoked > 0) {
+      await setBalanceValue(client, userId, creditType, newBalance);
+      await writeLedgerEntry(
+        client,
+        userId,
+        creditType,
+        -amountRevoked,
+        newBalance,
+        params
       );
     }
-    if (!price.id) {
-      throw new Error(
-        `Price ID not set for plan "${plan.name}" with interval "${body.interval}". Run stripe-sync to sync price IDs.`
+    await client.query("COMMIT");
+    return { newBalance, amountRevoked };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function atomicSet(userId, creditType, newBalance, params) {
+  const p = ensurePool();
+  const client = await p.connect();
+  try {
+    await client.query("BEGIN");
+    const previousBalance = await getBalanceForUpdate(
+      client,
+      userId,
+      creditType
+    );
+    const adjustment = newBalance - previousBalance;
+    if (adjustment !== 0) {
+      await setBalanceValue(client, userId, creditType, newBalance);
+      await writeLedgerEntry(
+        client,
+        userId,
+        creditType,
+        adjustment,
+        newBalance,
+        params
       );
     }
-    return price.id;
+    await client.query("COMMIT");
+    return { previousBalance };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
   }
-  async function getPriceMode(priceId) {
-    const price = await stripe.prices.retrieve(priceId);
-    return price.type === "recurring" ? "subscription" : "payment";
+}
+async function getHistory(userId, options) {
+  const { creditType, limit = 50, offset = 0 } = options ?? {};
+  const p = ensurePool();
+  let query = `
+    SELECT id, user_id, credit_type_id, amount, balance_after,
+           transaction_type, source, source_id, description, metadata, created_at
+    FROM ${schema}.credit_ledger
+    WHERE user_id = $1
+  `;
+  const params = [userId];
+  if (creditType) {
+    query += ` AND credit_type_id = $2`;
+    params.push(creditType);
   }
-  async function handleCheckout(request) {
-    try {
-      const body = await request.json();
-      if (!body.priceId && !body.planName && !body.planId) {
-        return new Response(
-          JSON.stringify({
-            error: "Provide either priceId, planName+interval, or planId+interval"
-          }),
-          { status: 400, headers: { "Content-Type": "application/json" } }
-        );
+  query += ` ORDER BY created_at DESC LIMIT $${params.length + 1} OFFSET $${params.length + 2}`;
+  params.push(limit, offset);
+  const result = await p.query(query, params);
+  return result.rows.map((row) => ({
+    id: row.id,
+    userId: row.user_id,
+    creditType: row.credit_type_id,
+    amount: Number(row.amount),
+    balanceAfter: Number(row.balance_after),
+    transactionType: row.transaction_type,
+    source: row.source,
+    sourceId: row.source_id ?? void 0,
+    description: row.description ?? void 0,
+    metadata: row.metadata ?? void 0,
+    createdAt: new Date(row.created_at)
+  }));
+}
+async function getActiveSeatUsers(subscriptionId) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT user_id FROM (
+      SELECT DISTINCT ON (user_id) user_id, source
+      FROM ${schema}.credit_ledger
+      WHERE source_id = $1
+        AND source IN ('seat_grant', 'seat_revoke')
+      ORDER BY user_id, created_at DESC
+    ) active
+    WHERE source = 'seat_grant'`,
+    [subscriptionId]
+  );
+  return result.rows.map((row) => row.user_id);
+}
+async function getUserSeatSubscription(userId) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT source_id as subscription_id FROM (
+      SELECT DISTINCT ON (user_id) user_id, source, source_id
+      FROM ${schema}.credit_ledger
+      WHERE user_id = $1
+        AND source IN ('seat_grant', 'seat_revoke')
+      ORDER BY user_id, created_at DESC
+    ) latest
+    WHERE source = 'seat_grant'`,
+    [userId]
+  );
+  return result.rows[0]?.subscription_id ?? null;
+}
+async function getCreditsGrantedBySource(userId, sourceId) {
+  const p = ensurePool();
+  const result = await p.query(
+    `SELECT credit_type_id, SUM(amount) as net_amount
+     FROM ${schema}.credit_ledger
+     WHERE user_id = $1
+       AND source_id = $2
+       AND source IN ('subscription', 'renewal', 'seat_grant', 'plan_change', 'cancellation', 'seat_revoke')
+     GROUP BY credit_type_id
+     HAVING SUM(amount) > 0`,
+    [userId, sourceId]
+  );
+  const net = {};
+  for (const row of result.rows) {
+    net[row.credit_type_id] = Number(row.net_amount);
+  }
+  return net;
+}
+
+// src/credits/grant.ts
+async function consume(params) {
+  const { userId, creditType, amount, description, metadata, idempotencyKey } = params;
+  if (amount <= 0) {
+    throw new CreditError("INVALID_AMOUNT", "Amount must be positive");
+  }
+  if (idempotencyKey) {
+    const exists = await checkIdempotencyKey(idempotencyKey);
+    if (exists) {
+      throw new CreditError("IDEMPOTENCY_CONFLICT", "Operation already processed", { idempotencyKey });
+    }
+  }
+  const result = await atomicConsume(userId, creditType, amount, {
+    transactionType: "consume",
+    source: "usage",
+    description,
+    metadata,
+    idempotencyKey
+  });
+  if (result.success === false) {
+    return { success: false, balance: result.currentBalance };
+  }
+  return { success: true, balance: result.newBalance };
+}
+async function grant(params) {
+  const {
+    userId,
+    creditType,
+    amount,
+    source = "manual",
+    sourceId,
+    description,
+    metadata,
+    idempotencyKey
+  } = params;
+  if (amount <= 0) {
+    throw new CreditError("INVALID_AMOUNT", "Amount must be positive");
+  }
+  if (idempotencyKey) {
+    const exists = await checkIdempotencyKey(idempotencyKey);
+    if (exists) {
+      throw new CreditError(
+        "IDEMPOTENCY_CONFLICT",
+        "Operation already processed",
+        { idempotencyKey }
+      );
+    }
+  }
+  return atomicAdd(userId, creditType, amount, {
+    transactionType: "grant",
+    source,
+    sourceId,
+    description,
+    metadata,
+    idempotencyKey
+  });
+}
+async function revoke(params) {
+  const {
+    userId,
+    creditType,
+    amount,
+    source = "manual",
+    sourceId,
+    description,
+    metadata,
+    idempotencyKey
+  } = params;
+  if (amount <= 0) {
+    throw new CreditError("INVALID_AMOUNT", "Amount must be positive");
+  }
+  if (idempotencyKey) {
+    const exists = await checkIdempotencyKey(idempotencyKey);
+    if (exists) {
+      throw new CreditError(
+        "IDEMPOTENCY_CONFLICT",
+        "Operation already processed",
+        { idempotencyKey }
+      );
+    }
+  }
+  const result = await atomicRevoke(userId, creditType, amount, {
+    transactionType: "revoke",
+    source,
+    sourceId,
+    description,
+    metadata,
+    idempotencyKey
+  });
+  return { balance: result.newBalance, amountRevoked: result.amountRevoked };
+}
+async function revokeAll(params) {
+  const currentBalance = await getBalance(params.userId, params.creditType);
+  if (currentBalance === 0) {
+    return { previousBalance: 0, amountRevoked: 0 };
+  }
+  const result = await revoke({ ...params, amount: currentBalance });
+  const previousBalance = result.balance + result.amountRevoked;
+  return {
+    previousBalance,
+    amountRevoked: result.amountRevoked
+  };
+}
+async function revokeAllCreditTypesForUser(params) {
+  const allBalances = await getAllBalances(params.userId);
+  const results = {};
+  for (const [creditType, balance] of Object.entries(allBalances)) {
+    if (balance > 0) {
+      const result = await revoke({
+        userId: params.userId,
+        creditType,
+        amount: balance,
+        source: params.source,
+        description: params.description,
+        metadata: params.metadata
+      });
+      results[creditType] = {
+        previousBalance: balance,
+        amountRevoked: result.amountRevoked
+      };
+    }
+  }
+  return results;
+}
+async function setBalance(params) {
+  const { userId, creditType, balance, reason, metadata, idempotencyKey } = params;
+  if (balance < 0) {
+    throw new CreditError("INVALID_AMOUNT", "Balance cannot be negative");
+  }
+  if (idempotencyKey) {
+    const exists = await checkIdempotencyKey(idempotencyKey);
+    if (exists) {
+      throw new CreditError(
+        "IDEMPOTENCY_CONFLICT",
+        "Operation already processed",
+        { idempotencyKey }
+      );
+    }
+  }
+  const result = await atomicSet(userId, creditType, balance, {
+    transactionType: "adjust",
+    source: "manual",
+    description: reason,
+    metadata,
+    idempotencyKey
+  });
+  return { balance, previousBalance: result.previousBalance };
+}
+
+// src/credits/index.ts
+function initCredits(pool2, schema2 = "stripe") {
+  setPool(pool2, schema2);
+}
+var credits = {
+  getBalance,
+  getAllBalances,
+  hasCredits,
+  consume,
+  grant,
+  revoke,
+  revokeAll,
+  revokeAllCreditTypesForUser,
+  setBalance,
+  getHistory
+};
+
+// src/credits/lifecycle.ts
+function createCreditLifecycle(config) {
+  const { pool: pool2, schema: schema2, billingConfig, mode, grantTo, callbacks } = config;
+  async function resolveUserId(subscription) {
+    if (!pool2) return null;
+    const customerId = getCustomerIdFromSubscription(subscription);
+    return getUserIdFromCustomer(pool2, schema2, customerId);
+  }
+  function resolvePlan(subscription) {
+    return getPlanFromSubscription(subscription, billingConfig, mode);
+  }
+  function resolvePlanByPriceId(priceId) {
+    return findPlanByPriceId(billingConfig, mode, priceId);
+  }
+  async function grantPlanCredits(userId, plan, subscriptionId, source, idempotencyPrefix) {
+    if (!plan.credits) return;
+    for (const [creditType, creditConfig] of Object.entries(plan.credits)) {
+      const idempotencyKey = idempotencyPrefix ? `${idempotencyPrefix}:${creditType}` : void 0;
+      const newBalance = await credits.grant({
+        userId,
+        creditType,
+        amount: creditConfig.allocation,
+        source,
+        sourceId: subscriptionId,
+        idempotencyKey
+      });
+      await callbacks?.onCreditsGranted?.({
+        userId,
+        creditType,
+        amount: creditConfig.allocation,
+        newBalance,
+        source,
+        sourceId: subscriptionId
+      });
+    }
+  }
+  async function grantOrResetCreditsForUser(userId, plan, subscriptionId, source, idempotencyPrefix) {
+    if (!plan.credits) return;
+    for (const [creditType, creditConfig] of Object.entries(plan.credits)) {
+      if (source === "renewal" && (creditConfig.onRenewal ?? "reset") === "reset") {
+        const balance = await credits.getBalance(userId, creditType);
+        if (balance > 0) {
+          await credits.revoke({ userId, creditType, amount: balance, source: "renewal" });
+          await callbacks?.onCreditsRevoked?.({
+            userId,
+            creditType,
+            amount: balance,
+            previousBalance: balance,
+            newBalance: 0,
+            source: "renewal"
+          });
+        }
       }
-      const origin = request.headers.get("origin") || "";
-      const successUrl = body.successUrl || defaultSuccessUrl || `${origin}/success?session_id={CHECKOUT_SESSION_ID}`;
-      const cancelUrl = body.cancelUrl || defaultCancelUrl || `${origin}/`;
-      const priceId = resolvePriceId(body, getMode(stripeSecretKey));
-      const mode = await getPriceMode(priceId);
-      const sessionParams = {
-        line_items: [
-          {
-            price: priceId,
-            quantity: body.quantity ?? 1
+      const idempotencyKey = idempotencyPrefix ? `${idempotencyPrefix}:${creditType}` : void 0;
+      const actualSource = grantTo === "seat-users" ? "seat_grant" : source;
+      const newBalance = await credits.grant({
+        userId,
+        creditType,
+        amount: creditConfig.allocation,
+        source: actualSource,
+        sourceId: subscriptionId,
+        idempotencyKey
+      });
+      await callbacks?.onCreditsGranted?.({
+        userId,
+        creditType,
+        amount: creditConfig.allocation,
+        newBalance,
+        source: actualSource,
+        sourceId: subscriptionId
+      });
+    }
+  }
+  async function revokeSubscriptionCredits(userId, subscriptionId, source) {
+    const netFromSubscription = await getCreditsGrantedBySource(userId, subscriptionId);
+    for (const [creditType, netAmount] of Object.entries(netFromSubscription)) {
+      if (netAmount > 0) {
+        const currentBalance = await credits.getBalance(userId, creditType);
+        const amountToRevoke = Math.min(netAmount, currentBalance);
+        if (amountToRevoke > 0) {
+          const result = await credits.revoke({
+            userId,
+            creditType,
+            amount: amountToRevoke,
+            source,
+            sourceId: subscriptionId
+          });
+          await callbacks?.onCreditsRevoked?.({
+            userId,
+            creditType,
+            amount: result.amountRevoked,
+            previousBalance: currentBalance,
+            newBalance: result.balance,
+            source
+          });
+        }
+      }
+    }
+  }
+  async function applyDowngradeCredits(userId, newPlan, subscriptionId, idempotencyPrefix) {
+    const allBalances = await credits.getAllBalances(userId);
+    const newPlanCreditTypes = new Set(Object.keys(newPlan?.credits ?? {}));
+    for (const [creditType, balance] of Object.entries(allBalances)) {
+      if (!newPlanCreditTypes.has(creditType) && balance > 0) {
+        const result = await credits.revoke({
+          userId,
+          creditType,
+          amount: balance,
+          source: "plan_change",
+          sourceId: subscriptionId
+        });
+        await callbacks?.onCreditsRevoked?.({
+          userId,
+          creditType,
+          amount: result.amountRevoked,
+          previousBalance: balance,
+          newBalance: result.balance,
+          source: "plan_change"
+        });
+      }
+    }
+    if (newPlan?.credits) {
+      for (const [creditType, creditConfig] of Object.entries(newPlan.credits)) {
+        const shouldReset = (creditConfig.onRenewal ?? "reset") === "reset";
+        if (shouldReset) {
+          const currentBalance = await credits.getBalance(userId, creditType);
+          if (currentBalance > 0) {
+            await credits.revoke({
+              userId,
+              creditType,
+              amount: currentBalance,
+              source: "plan_change",
+              sourceId: subscriptionId
+            });
+            await callbacks?.onCreditsRevoked?.({
+              userId,
+              creditType,
+              amount: currentBalance,
+              previousBalance: currentBalance,
+              newBalance: 0,
+              source: "plan_change"
+            });
           }
-        ],
-        mode,
-        success_url: successUrl,
-        cancel_url: cancelUrl,
-        automatic_tax: { enabled: automaticTax }
-      };
-      if (body.customerEmail) {
-        sessionParams.customer_email = body.customerEmail;
+        }
+        const idempotencyKey = `${idempotencyPrefix}:${creditType}`;
+        const newBalance = await credits.grant({
+          userId,
+          creditType,
+          amount: creditConfig.allocation,
+          source: "subscription",
+          sourceId: subscriptionId,
+          idempotencyKey
+        });
+        await callbacks?.onCreditsGranted?.({
+          userId,
+          creditType,
+          amount: creditConfig.allocation,
+          newBalance,
+          source: "subscription",
+          sourceId: subscriptionId
+        });
       }
-      if (body.customerId) {
-        sessionParams.customer = body.customerId;
+    }
+  }
+  async function revokeAllCredits(userId, subscriptionId) {
+    const allBalances = await credits.getAllBalances(userId);
+    for (const [creditType, balance] of Object.entries(allBalances)) {
+      if (balance > 0) {
+        const result = await credits.revoke({
+          userId,
+          creditType,
+          amount: balance,
+          source: "cancellation",
+          sourceId: subscriptionId
+        });
+        await callbacks?.onCreditsRevoked?.({
+          userId,
+          creditType,
+          amount: result.amountRevoked,
+          previousBalance: balance,
+          newBalance: result.balance,
+          source: "cancellation"
+        });
       }
-      if (body.metadata) {
-        sessionParams.metadata = body.metadata;
+    }
+  }
+  return {
+    async onSubscriptionCreated(subscription) {
+      if (grantTo === "manual") return;
+      const plan = resolvePlan(subscription);
+      if (!plan?.credits) return;
+      if (grantTo === "seat-users") {
+        const firstSeatUserId = subscription.metadata?.first_seat_user_id;
+        if (firstSeatUserId) {
+          await grantOrResetCreditsForUser(
+            firstSeatUserId,
+            plan,
+            subscription.id,
+            "seat_grant",
+            `seat_${firstSeatUserId}_${subscription.id}`
+          );
+        }
+        return;
       }
-      const session = await stripe.checkout.sessions.create(sessionParams);
-      if (!session.url) {
-        return new Response(
-          JSON.stringify({ error: "Failed to create checkout session" }),
-          { status: 500, headers: { "Content-Type": "application/json" } }
+      const userId = await resolveUserId(subscription);
+      if (!userId) return;
+      await grantPlanCredits(userId, plan, subscription.id, "subscription", subscription.id);
+    },
+    async onSubscriptionRenewed(subscription, invoiceId) {
+      if (grantTo === "manual") return;
+      const plan = resolvePlan(subscription);
+      if (!plan?.credits) return;
+      if (grantTo === "seat-users") {
+        const seatUsers = await getActiveSeatUsers(subscription.id);
+        for (const userId2 of seatUsers) {
+          const alreadyProcessed2 = await checkIdempotencyKeyPrefix(`renewal_${invoiceId}_${userId2}`);
+          if (alreadyProcessed2) {
+            throw new CreditError(
+              "IDEMPOTENCY_CONFLICT",
+              "Operation already processed",
+              { idempotencyKey: `renewal_${invoiceId}_${userId2}` }
+            );
+          }
+          await grantOrResetCreditsForUser(
+            userId2,
+            plan,
+            subscription.id,
+            "renewal",
+            `renewal_${invoiceId}_${userId2}`
+          );
+        }
+        return;
+      }
+      const userId = await resolveUserId(subscription);
+      if (!userId) return;
+      const alreadyProcessed = await checkIdempotencyKeyPrefix(invoiceId);
+      if (alreadyProcessed) {
+        throw new CreditError(
+          "IDEMPOTENCY_CONFLICT",
+          "Operation already processed",
+          { idempotencyKey: invoiceId }
         );
       }
-      const acceptHeader = request.headers.get("accept") || "";
-      if (acceptHeader.includes("application/json")) {
-        return new Response(JSON.stringify({ url: session.url }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+      for (const [creditType, creditConfig] of Object.entries(plan.credits)) {
+        if ((creditConfig.onRenewal ?? "reset") === "reset") {
+          const balance = await credits.getBalance(userId, creditType);
+          if (balance > 0) {
+            await credits.revoke({ userId, creditType, amount: balance, source: "renewal" });
+            await callbacks?.onCreditsRevoked?.({
+              userId,
+              creditType,
+              amount: balance,
+              previousBalance: balance,
+              newBalance: 0,
+              source: "renewal"
+            });
+          }
+        }
+      }
+      await grantPlanCredits(userId, plan, subscription.id, "renewal", invoiceId);
+    },
+    async onSubscriptionCancelled(subscription) {
+      if (grantTo === "manual") return;
+      if (grantTo === "seat-users") {
+        const seatUsers = await getActiveSeatUsers(subscription.id);
+        for (const userId2 of seatUsers) {
+          await revokeAllCredits(userId2, subscription.id);
+        }
+        return;
+      }
+      const userId = await resolveUserId(subscription);
+      if (!userId) return;
+      await revokeAllCredits(userId, subscription.id);
+    },
+    async onSubscriptionPlanChanged(subscription, previousPriceId) {
+      if (grantTo === "manual") return;
+      if (subscription.metadata?.pending_credit_downgrade === "true") {
+        return;
+      }
+      const newPlan = resolvePlan(subscription);
+      const oldPlan = resolvePlanByPriceId(previousPriceId);
+      if (oldPlan?.id === newPlan?.id) return;
+      if (!newPlan?.credits && !oldPlan?.credits) return;
+      const newPriceId = subscription.items.data[0]?.price?.id ?? "unknown";
+      const idempotencyKey = `plan_change_${subscription.id}_${previousPriceId}_to_${newPriceId}`;
+      const upgradeFromAmount = subscription.metadata?.upgrade_from_price_amount;
+      const isUpgradeViaMetadata = upgradeFromAmount !== void 0;
+      const isFreeUpgrade = upgradeFromAmount === "0";
+      const bothHaveCredits = planHasCredits(oldPlan) && planHasCredits(newPlan);
+      const shouldRevokeOnUpgrade = isFreeUpgrade || !bothHaveCredits;
+      if (grantTo === "seat-users") {
+        const seatUsers = await getActiveSeatUsers(subscription.id);
+        for (const seatUserId of seatUsers) {
+          if (oldPlan?.credits && (!isUpgradeViaMetadata || shouldRevokeOnUpgrade)) {
+            await revokeSubscriptionCredits(seatUserId, subscription.id, "plan_change");
+          }
+          if (newPlan?.credits) {
+            await grantOrResetCreditsForUser(
+              seatUserId,
+              newPlan,
+              subscription.id,
+              "subscription",
+              `${idempotencyKey}:${seatUserId}`
+            );
+          }
+        }
+        return;
+      }
+      const userId = await resolveUserId(subscription);
+      if (!userId) return;
+      if (oldPlan?.credits && (!isUpgradeViaMetadata || shouldRevokeOnUpgrade)) {
+        await revokeSubscriptionCredits(userId, subscription.id, "plan_change");
+      }
+      if (newPlan?.credits) {
+        await grantPlanCredits(userId, newPlan, subscription.id, "subscription", idempotencyKey);
+      }
+    },
+    async onDowngradeApplied(subscription, newPriceId) {
+      if (grantTo === "manual") return;
+      const newPlan = resolvePlanByPriceId(newPriceId);
+      const idempotencyKey = `downgrade_${subscription.id}_to_${newPriceId}`;
+      if (grantTo === "seat-users") {
+        const seatUsers = await getActiveSeatUsers(subscription.id);
+        for (const seatUserId of seatUsers) {
+          await applyDowngradeCredits(seatUserId, newPlan, subscription.id, `${idempotencyKey}:${seatUserId}`);
+        }
+        return;
       }
-      return Response.redirect(session.url, 303);
+      const userId = await resolveUserId(subscription);
+      if (!userId) return;
+      await applyDowngradeCredits(userId, newPlan, subscription.id, idempotencyKey);
+    }
+  };
+}
+
+// src/credits/topup.ts
+function createTopUpHandler(deps) {
+  const {
+    stripe,
+    pool: pool2,
+    schema: schema2,
+    billingConfig,
+    mode,
+    successUrl,
+    cancelUrl,
+    onCreditsGranted,
+    onTopUpCompleted,
+    onAutoTopUpFailed,
+    onCreditsLow
+  } = deps;
+  async function getCustomerByUserId(userId) {
+    if (!pool2) return null;
+    const result = await pool2.query(
+      `SELECT c.id, c.deleted, c.invoice_settings->>'default_payment_method' as default_payment_method
+       FROM ${schema2}.user_stripe_customer_map m
+       JOIN ${schema2}.customers c ON c.id = m.stripe_customer_id
+       WHERE m.user_id = $1`,
+      [userId]
+    );
+    if (!result.rows[0]) return null;
+    return {
+      id: result.rows[0].id,
+      deleted: result.rows[0].deleted ?? false,
+      defaultPaymentMethod: result.rows[0].default_payment_method
+    };
+  }
+  async function getActiveSubscription2(customerId) {
+    if (!pool2) return null;
+    const result = await pool2.query(
+      `SELECT s.id, si.price, p.currency
+       FROM ${schema2}.subscriptions s
+       JOIN ${schema2}.subscription_items si ON si.subscription = s.id
+       JOIN ${schema2}.prices p ON p.id = si.price
+       WHERE s.customer = $1 AND s.status IN ('active', 'trialing', 'past_due')
+       ORDER BY s.created DESC
+       LIMIT 1`,
+      [customerId]
+    );
+    if (!result.rows[0]) return null;
+    return {
+      id: result.rows[0].id,
+      priceId: result.rows[0].price,
+      currency: result.rows[0].currency
+    };
+  }
+  async function createRecoveryCheckout(customerId, creditType, amount, totalCents, currency) {
+    if (!successUrl || !cancelUrl) {
+      throw new CreditError(
+        "MISSING_CONFIG",
+        "successUrl and cancelUrl are required for recovery checkout. Configure them in createStripeHandler."
+      );
+    }
+    const displayName = creditType.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    const session = await stripe.checkout.sessions.create({
+      customer: customerId,
+      mode: "payment",
+      payment_method_types: ["card"],
+      line_items: [
+        {
+          price_data: {
+            currency,
+            unit_amount: totalCents,
+            product_data: {
+              name: `${amount} ${displayName}`,
+              description: "Credit top-up"
+            }
+          },
+          quantity: 1
+        }
+      ],
+      metadata: {
+        top_up_credit_type: creditType,
+        top_up_amount: String(amount)
+      },
+      success_url: successUrl,
+      cancel_url: cancelUrl
+    });
+    if (!session.url) {
+      throw new CreditError(
+        "CHECKOUT_ERROR",
+        "Failed to create checkout session URL"
+      );
+    }
+    return session.url;
+  }
+  async function tryCreateRecoveryCheckout(customerId, creditType, amount, totalCents, currency) {
+    try {
+      return await createRecoveryCheckout(
+        customerId,
+        creditType,
+        amount,
+        totalCents,
+        currency
+      );
     } catch (err) {
-      console.error("Checkout error:", err);
-      const message = err instanceof Error ? err.message : "Unknown error";
-      const status = err && typeof err === "object" && "statusCode" in err ? err.statusCode : 500;
-      return new Response(JSON.stringify({ error: message }), {
-        status,
-        headers: { "Content-Type": "application/json" }
-      });
+      console.error("Failed to create recovery checkout:", err);
+      return void 0;
+    }
+  }
+  async function topUp(params) {
+    const { userId, creditType, amount, idempotencyKey } = params;
+    const customer = await getCustomerByUserId(userId);
+    if (!customer) {
+      return {
+        success: false,
+        error: {
+          code: "USER_NOT_FOUND",
+          message: "No Stripe customer found for user"
+        }
+      };
+    }
+    if (customer.deleted) {
+      return {
+        success: false,
+        error: { code: "USER_NOT_FOUND", message: "Customer has been deleted" }
+      };
+    }
+    const subscription = await getActiveSubscription2(customer.id);
+    if (!subscription) {
+      return {
+        success: false,
+        error: {
+          code: "NO_SUBSCRIPTION",
+          message: "No active subscription found"
+        }
+      };
+    }
+    const plan = billingConfig?.[mode]?.plans?.find(
+      (p) => p.price.some((pr) => pr.id === subscription.priceId)
+    );
+    if (!plan) {
+      return {
+        success: false,
+        error: {
+          code: "TOPUP_NOT_CONFIGURED",
+          message: "Could not determine plan from subscription"
+        }
+      };
+    }
+    const topUpConfig = plan.credits?.[creditType]?.topUp;
+    if (!topUpConfig || topUpConfig.mode !== "on_demand") {
+      return {
+        success: false,
+        error: {
+          code: "TOPUP_NOT_CONFIGURED",
+          message: `On-demand top-up not configured for ${creditType}`
+        }
+      };
+    }
+    const {
+      pricePerCreditCents,
+      minPerPurchase = 1,
+      maxPerPurchase
+    } = topUpConfig;
+    if (amount < minPerPurchase) {
+      return {
+        success: false,
+        error: {
+          code: "INVALID_AMOUNT",
+          message: `Minimum purchase is ${minPerPurchase} credits`
+        }
+      };
+    }
+    if (maxPerPurchase !== void 0 && amount > maxPerPurchase) {
+      return {
+        success: false,
+        error: {
+          code: "INVALID_AMOUNT",
+          message: `Maximum purchase is ${maxPerPurchase} credits`
+        }
+      };
+    }
+    const totalCents = amount * pricePerCreditCents;
+    const STRIPE_MIN_CENTS = 60;
+    if (totalCents < STRIPE_MIN_CENTS) {
+      return {
+        success: false,
+        error: {
+          code: "INVALID_AMOUNT",
+          message: `Minimum purchase amount is ${STRIPE_MIN_CENTS} cents (${Math.ceil(STRIPE_MIN_CENTS / pricePerCreditCents)} credits at current price)`
+        }
+      };
+    }
+    const currency = subscription.currency;
+    if (!customer.defaultPaymentMethod) {
+      const recoveryUrl = await tryCreateRecoveryCheckout(
+        customer.id,
+        creditType,
+        amount,
+        totalCents,
+        currency
+      );
+      return {
+        success: false,
+        error: {
+          code: "NO_PAYMENT_METHOD",
+          message: "No payment method on file",
+          recoveryUrl
+        }
+      };
+    }
+    try {
+      const paymentIntent = await stripe.paymentIntents.create(
+        {
+          amount: totalCents,
+          currency,
+          customer: customer.id,
+          payment_method: customer.defaultPaymentMethod,
+          confirm: true,
+          off_session: true,
+          metadata: {
+            top_up_credit_type: creditType,
+            top_up_amount: String(amount),
+            user_id: userId
+          }
+        },
+        idempotencyKey ? { idempotencyKey } : void 0
+      );
+      if (paymentIntent.status === "succeeded") {
+        const newBalance = await grantCreditsFromPayment(paymentIntent);
+        return {
+          success: true,
+          balance: newBalance,
+          charged: { amountCents: totalCents, currency },
+          paymentIntentId: paymentIntent.id
+        };
+      }
+      if (paymentIntent.status === "processing") {
+        return {
+          success: true,
+          status: "pending",
+          paymentIntentId: paymentIntent.id,
+          message: "Payment is processing. Credits will be added once payment completes."
+        };
+      }
+      const recoveryUrl = await tryCreateRecoveryCheckout(
+        customer.id,
+        creditType,
+        amount,
+        totalCents,
+        currency
+      );
+      return {
+        success: false,
+        error: {
+          code: "PAYMENT_FAILED",
+          message: `Payment status: ${paymentIntent.status}`,
+          recoveryUrl
+        }
+      };
+    } catch (err) {
+      const stripeError = err;
+      const isCardError = stripeError.type === "card_error";
+      const isInvalidRequest = stripeError.type === "invalid_request_error";
+      const errorCode = stripeError.code;
+      const message = stripeError.message || "Payment failed";
+      if (isCardError) {
+        const recoveryUrl = await tryCreateRecoveryCheckout(
+          customer.id,
+          creditType,
+          amount,
+          totalCents,
+          currency
+        );
+        return {
+          success: false,
+          error: {
+            code: "PAYMENT_FAILED",
+            message,
+            recoveryUrl
+          }
+        };
+      }
+      return {
+        success: false,
+        error: {
+          code: isInvalidRequest ? "INVALID_AMOUNT" : "PAYMENT_FAILED",
+          message: errorCode ? `${errorCode}: ${message}` : message
+        }
+      };
     }
   }
-  async function handleWebhook(request) {
+  async function grantCreditsFromPayment(paymentIntent) {
+    const creditType = paymentIntent.metadata?.top_up_credit_type;
+    const amountStr = paymentIntent.metadata?.top_up_amount;
+    const userId = paymentIntent.metadata?.user_id;
+    const isAuto = paymentIntent.metadata?.top_up_auto === "true";
+    if (!creditType || !amountStr || !userId) {
+      throw new CreditError(
+        "INVALID_METADATA",
+        "Missing top-up metadata on PaymentIntent"
+      );
+    }
+    const amount = parseInt(amountStr, 10);
+    if (isNaN(amount) || amount <= 0) {
+      throw new CreditError(
+        "INVALID_METADATA",
+        "Invalid top_up_amount in PaymentIntent metadata"
+      );
+    }
+    const source = isAuto ? "auto_topup" : "topup";
+    let newBalance;
+    let alreadyGranted = false;
     try {
-      const body = await request.text();
-      const url = new URL(request.url);
-      const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1";
-      const signature = request.headers.get("stripe-signature");
-      let event;
-      if (isLocalhost) {
-        event = JSON.parse(body);
+      newBalance = await credits.grant({
+        userId,
+        creditType,
+        amount,
+        source,
+        sourceId: paymentIntent.id,
+        idempotencyKey: `topup_${paymentIntent.id}`
+      });
+    } catch (grantErr) {
+      if (grantErr instanceof CreditError && grantErr.code === "IDEMPOTENCY_CONFLICT") {
+        newBalance = await credits.getBalance(userId, creditType);
+        alreadyGranted = true;
       } else {
-        if (!signature) {
-          return new Response("Missing stripe-signature header", {
-            status: 400
-          });
+        throw grantErr;
+      }
+    }
+    if (!alreadyGranted) {
+      await onCreditsGranted?.({
+        userId,
+        creditType,
+        amount,
+        newBalance,
+        source,
+        sourceId: paymentIntent.id
+      });
+      await onTopUpCompleted?.({
+        userId,
+        creditType,
+        creditsAdded: amount,
+        amountCharged: paymentIntent.amount,
+        currency: paymentIntent.currency,
+        newBalance,
+        paymentIntentId: paymentIntent.id
+      });
+    }
+    return newBalance;
+  }
+  async function handlePaymentIntentSucceeded(paymentIntent) {
+    if (!paymentIntent.metadata?.top_up_credit_type) {
+      return;
+    }
+    await grantCreditsFromPayment(paymentIntent);
+  }
+  async function handleTopUpCheckoutCompleted(session) {
+    const creditType = session.metadata?.top_up_credit_type;
+    const amountStr = session.metadata?.top_up_amount;
+    if (!creditType || !amountStr) return;
+    if (session.payment_status !== "paid") {
+      console.warn(
+        `Top-up checkout ${session.id} has payment_status '${session.payment_status}', skipping`
+      );
+      return;
+    }
+    const amount = parseInt(amountStr, 10);
+    if (isNaN(amount) || amount <= 0) {
+      throw new CreditError(
+        "INVALID_METADATA",
+        "Invalid top_up_amount in checkout session metadata"
+      );
+    }
+    const customerId = typeof session.customer === "string" ? session.customer : session.customer?.id;
+    if (!customerId) {
+      throw new CreditError(
+        "MISSING_CUSTOMER",
+        "No customer ID in checkout session"
+      );
+    }
+    if (!pool2) {
+      throw new CreditError("NO_DATABASE", "Database connection required");
+    }
+    const mappingResult = await pool2.query(
+      `SELECT user_id FROM ${schema2}.user_stripe_customer_map WHERE stripe_customer_id = $1`,
+      [customerId]
+    );
+    const userId = mappingResult.rows[0]?.user_id;
+    if (!userId) {
+      throw new CreditError(
+        "MISSING_USER_ID",
+        "No user mapping found for customer"
+      );
+    }
+    const paymentIntentId = typeof session.payment_intent === "string" ? session.payment_intent : session.payment_intent?.id ?? session.id;
+    let newBalance;
+    try {
+      newBalance = await credits.grant({
+        userId,
+        creditType,
+        amount,
+        source: "topup",
+        sourceId: paymentIntentId,
+        idempotencyKey: `topup_${paymentIntentId}`
+      });
+    } catch (grantErr) {
+      if (grantErr instanceof CreditError && grantErr.code === "IDEMPOTENCY_CONFLICT") {
+        return;
+      }
+      throw grantErr;
+    }
+    await onCreditsGranted?.({
+      userId,
+      creditType,
+      amount,
+      newBalance,
+      source: "topup",
+      sourceId: paymentIntentId
+    });
+    await onTopUpCompleted?.({
+      userId,
+      creditType,
+      creditsAdded: amount,
+      amountCharged: session.amount_total ?? 0,
+      currency: session.currency ?? "usd",
+      newBalance,
+      paymentIntentId
+    });
+  }
+  async function hasPaymentMethod2(userId) {
+    const customer = await getCustomerByUserId(userId);
+    return !!customer?.defaultPaymentMethod;
+  }
+  async function triggerAutoTopUpIfNeeded(params) {
+    const { userId, creditType, currentBalance } = params;
+    const customer = await getCustomerByUserId(userId);
+    if (!customer || customer.deleted) {
+      return { triggered: false, reason: "user_not_found" };
+    }
+    const subscription = await getActiveSubscription2(customer.id);
+    if (!subscription) {
+      return { triggered: false, reason: "no_subscription" };
+    }
+    const plan = billingConfig?.[mode]?.plans?.find(
+      (p) => p.price.some((pr) => pr.id === subscription.priceId)
+    );
+    if (!plan) {
+      return { triggered: false, reason: "not_configured" };
+    }
+    const topUpConfig = plan.credits?.[creditType]?.topUp;
+    if (!topUpConfig || topUpConfig.mode !== "auto") {
+      return { triggered: false, reason: "not_configured" };
+    }
+    const {
+      pricePerCreditCents,
+      balanceThreshold,
+      purchaseAmount,
+      maxPerMonth = 10
+    } = topUpConfig;
+    if (purchaseAmount <= 0 || balanceThreshold <= 0 || pricePerCreditCents <= 0) {
+      console.error(
+        `Invalid auto top-up config for ${creditType}: purchaseAmount=${purchaseAmount}, balanceThreshold=${balanceThreshold}, pricePerCreditCents=${pricePerCreditCents}`
+      );
+      return { triggered: false, reason: "not_configured" };
+    }
+    if (currentBalance >= balanceThreshold) {
+      return { triggered: false, reason: "balance_above_threshold" };
+    }
+    await onCreditsLow?.({
+      userId,
+      creditType,
+      balance: currentBalance,
+      threshold: balanceThreshold
+    });
+    if (!customer.defaultPaymentMethod) {
+      await onAutoTopUpFailed?.({
+        userId,
+        creditType,
+        reason: "no_payment_method"
+      });
+      return { triggered: false, reason: "no_payment_method" };
+    }
+    const autoTopUpsThisMonth = await countAutoTopUpsThisMonth(
+      userId,
+      creditType
+    );
+    if (autoTopUpsThisMonth >= maxPerMonth) {
+      await onAutoTopUpFailed?.({
+        userId,
+        creditType,
+        reason: "max_per_month_reached"
+      });
+      return { triggered: false, reason: "max_per_month_reached" };
+    }
+    const totalCents = purchaseAmount * pricePerCreditCents;
+    const currency = subscription.currency;
+    const now = /* @__PURE__ */ new Date();
+    const yearMonth = `${now.getUTCFullYear()}-${String(
+      now.getUTCMonth() + 1
+    ).padStart(2, "0")}`;
+    const idempotencyKey = `auto_topup_${userId}_${creditType}_${yearMonth}_${autoTopUpsThisMonth + 1}`;
+    try {
+      const paymentIntent = await stripe.paymentIntents.create(
+        {
+          amount: totalCents,
+          currency,
+          customer: customer.id,
+          payment_method: customer.defaultPaymentMethod,
+          confirm: true,
+          off_session: true,
+          metadata: {
+            top_up_credit_type: creditType,
+            top_up_amount: String(purchaseAmount),
+            user_id: userId,
+            top_up_auto: "true"
+          }
+        },
+        { idempotencyKey }
+      );
+      if (paymentIntent.status === "succeeded") {
+        await grantCreditsFromPayment(paymentIntent);
+        return {
+          triggered: true,
+          status: "succeeded",
+          paymentIntentId: paymentIntent.id
+        };
+      }
+      if (paymentIntent.status === "processing") {
+        return {
+          triggered: true,
+          status: "pending",
+          paymentIntentId: paymentIntent.id
+        };
+      }
+      const message = `Payment requires action: ${paymentIntent.status}`;
+      await onAutoTopUpFailed?.({
+        userId,
+        creditType,
+        reason: "payment_requires_action",
+        error: message
+      });
+      return {
+        triggered: false,
+        reason: "payment_requires_action",
+        error: message
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Payment failed";
+      await onAutoTopUpFailed?.({
+        userId,
+        creditType,
+        reason: "payment_failed",
+        error: message
+      });
+      return {
+        triggered: false,
+        reason: "payment_failed",
+        error: message
+      };
+    }
+  }
+  return {
+    topUp,
+    hasPaymentMethod: hasPaymentMethod2,
+    triggerAutoTopUpIfNeeded,
+    handlePaymentIntentSucceeded,
+    handleTopUpCheckoutCompleted
+  };
+}
+
+// src/credits/seats.ts
+function createSeatsApi(config) {
+  const { stripe, pool: pool2, schema: schema2, billingConfig, mode, grantTo, callbacks } = config;
+  async function resolveStripeCustomerId(entityId) {
+    if (!pool2) return null;
+    return getStripeCustomerId(pool2, schema2, entityId);
+  }
+  async function resolveActiveSubscription(customerId) {
+    return getActiveSubscription(stripe, customerId);
+  }
+  function resolvePlan(subscription) {
+    return getPlanFromSubscription(subscription, billingConfig, mode);
+  }
+  async function grantSeatCredits(userId, plan, subscriptionId, idempotencyPrefix) {
+    const creditsGranted = {};
+    if (!plan.credits) return creditsGranted;
+    for (const [creditType, creditConfig] of Object.entries(plan.credits)) {
+      const idempotencyKey = idempotencyPrefix ? `${idempotencyPrefix}:${creditType}` : void 0;
+      const newBalance = await credits.grant({
+        userId,
+        creditType,
+        amount: creditConfig.allocation,
+        source: "seat_grant",
+        sourceId: subscriptionId,
+        idempotencyKey
+      });
+      creditsGranted[creditType] = creditConfig.allocation;
+      await callbacks?.onCreditsGranted?.({
+        userId,
+        creditType,
+        amount: creditConfig.allocation,
+        newBalance,
+        source: "seat_grant",
+        sourceId: subscriptionId
+      });
+    }
+    return creditsGranted;
+  }
+  async function add(params) {
+    const { userId, orgId } = params;
+    const customerId = await resolveStripeCustomerId(orgId);
+    if (!customerId) {
+      return { success: false, error: "Org has no Stripe customer" };
+    }
+    const subscription = await resolveActiveSubscription(customerId);
+    if (!subscription) {
+      return { success: false, error: "No active subscription found for org" };
+    }
+    const plan = resolvePlan(subscription);
+    if (!plan) {
+      return { success: false, error: "Could not resolve plan from subscription" };
+    }
+    let creditsGranted = {};
+    let alreadyProcessed = false;
+    if (grantTo !== "manual" && plan.credits) {
+      const creditRecipient = grantTo === "seat-users" ? userId : orgId;
+      const idempotencyPrefix = `seat_${orgId}_${userId}_${subscription.id}`;
+      if (grantTo === "seat-users") {
+        const existingSubscription = await getUserSeatSubscription(userId);
+        if (existingSubscription && existingSubscription !== subscription.id) {
+          return {
+            success: false,
+            error: "User is already a seat of another subscription"
+          };
+        }
+        if (existingSubscription === subscription.id) {
+          alreadyProcessed = true;
         }
+      }
+      if (!alreadyProcessed) {
         try {
-          event = stripe.webhooks.constructEvent(
-            body,
-            signature,
-            stripeWebhookSecret
+          creditsGranted = await grantSeatCredits(
+            creditRecipient,
+            plan,
+            subscription.id,
+            idempotencyPrefix
           );
         } catch (err) {
-          const message = err instanceof Error ? err.message : "Unknown error";
-          return new Response(
-            `Webhook signature verification failed: ${message}`,
-            { status: 400 }
+          if (err instanceof CreditError && err.code === "IDEMPOTENCY_CONFLICT") {
+            alreadyProcessed = true;
+          } else {
+            throw err;
+          }
+        }
+      }
+    }
+    if (plan.perSeat) {
+      const item = subscription.items.data[0];
+      if (item) {
+        await stripe.subscriptions.update(
+          subscription.id,
+          {
+            items: [{ id: item.id, quantity: (item.quantity ?? 1) + 1 }],
+            proration_behavior: "create_prorations"
+          },
+          { idempotencyKey: `add_seat_${orgId}_${userId}_${subscription.id}` }
+        );
+      }
+    }
+    return { success: true, creditsGranted };
+  }
+  async function remove(params) {
+    const { userId, orgId } = params;
+    const customerId = await resolveStripeCustomerId(orgId);
+    if (!customerId) {
+      return { success: false, error: "Org has no Stripe customer" };
+    }
+    const subscription = await resolveActiveSubscription(customerId);
+    if (!subscription) {
+      return { success: false, error: "No active subscription found for org" };
+    }
+    const plan = resolvePlan(subscription);
+    if (!plan) {
+      return { success: false, error: "Could not resolve plan from subscription" };
+    }
+    const creditsRevoked = {};
+    if (grantTo !== "manual" && plan.credits) {
+      const creditHolder = grantTo === "seat-users" ? userId : orgId;
+      const grantsFromSeat = await getCreditsGrantedBySource(creditHolder, subscription.id);
+      for (const [creditType, grantedAmount] of Object.entries(grantsFromSeat)) {
+        if (grantedAmount > 0) {
+          const currentBalance = await credits.getBalance(creditHolder, creditType);
+          const amountToRevoke = Math.min(grantedAmount, currentBalance);
+          if (amountToRevoke > 0) {
+            const result = await credits.revoke({
+              userId: creditHolder,
+              creditType,
+              amount: amountToRevoke,
+              source: "seat_revoke",
+              sourceId: subscription.id
+            });
+            creditsRevoked[creditType] = result.amountRevoked;
+            await callbacks?.onCreditsRevoked?.({
+              userId: creditHolder,
+              creditType,
+              amount: result.amountRevoked,
+              previousBalance: currentBalance,
+              newBalance: result.balance,
+              source: "seat_revoke"
+            });
+          }
+        }
+      }
+    }
+    if (plan.perSeat) {
+      const item = subscription.items.data[0];
+      if (item) {
+        const currentQuantity = item.quantity ?? 1;
+        const newQuantity = Math.max(1, currentQuantity - 1);
+        if (newQuantity !== currentQuantity) {
+          await stripe.subscriptions.update(
+            subscription.id,
+            {
+              items: [{ id: item.id, quantity: newQuantity }],
+              proration_behavior: "create_prorations"
+            },
+            { idempotencyKey: `remove_seat_${orgId}_${userId}_${subscription.id}` }
           );
         }
       }
-      if (sync) {
-        await sync.processEvent(event);
+    }
+    return { success: true, creditsRevoked };
+  }
+  return { add, remove };
+}
+
+// src/subscriptions.ts
+function createSubscriptionsApi(deps) {
+  const { pool: pool2, schema: schema2, billingConfig, mode } = deps;
+  function resolvePlanFromPriceId(priceId) {
+    const plans = billingConfig?.[mode]?.plans;
+    if (!plans) return null;
+    for (const plan of plans) {
+      const matchingPrice = plan.price.find((p) => p.id === priceId);
+      if (matchingPrice) {
+        return { id: plan.id || plan.name, name: plan.name };
+      }
+    }
+    return null;
+  }
+  function rowToSubscription(row) {
+    const priceId = row.items?.data?.[0]?.price?.id;
+    const plan = priceId ? resolvePlanFromPriceId(priceId) : null;
+    return {
+      id: row.id,
+      status: row.status,
+      plan: plan ? { ...plan, priceId } : null,
+      currentPeriodStart: new Date(row.current_period_start * 1e3),
+      currentPeriodEnd: new Date(row.current_period_end * 1e3),
+      cancelAtPeriodEnd: row.cancel_at_period_end
+    };
+  }
+  async function isActive(userId) {
+    if (!pool2) return false;
+    const customerId = await getStripeCustomerId(pool2, schema2, userId);
+    if (!customerId) return false;
+    const result = await pool2.query(
+      `SELECT 1 FROM ${schema2}.subscriptions
+       WHERE customer = $1 AND status IN ('active', 'trialing')
+       LIMIT 1`,
+      [customerId]
+    );
+    return result.rows.length > 0;
+  }
+  async function get(userId) {
+    if (!pool2) return null;
+    const customerId = await getStripeCustomerId(pool2, schema2, userId);
+    if (!customerId) return null;
+    let result = await pool2.query(
+      `SELECT id, status, customer, current_period_start, current_period_end,
+              cancel_at_period_end, items
+       FROM ${schema2}.subscriptions
+       WHERE customer = $1 AND status IN ('active', 'trialing')
+       ORDER BY current_period_end DESC
+       LIMIT 1`,
+      [customerId]
+    );
+    if (result.rows.length === 0) {
+      result = await pool2.query(
+        `SELECT id, status, customer, current_period_start, current_period_end,
+                cancel_at_period_end, items
+         FROM ${schema2}.subscriptions
+         WHERE customer = $1
+         ORDER BY current_period_end DESC
+         LIMIT 1`,
+        [customerId]
+      );
+    }
+    if (result.rows.length === 0) return null;
+    return rowToSubscription(result.rows[0]);
+  }
+  async function list(userId) {
+    if (!pool2) return [];
+    const customerId = await getStripeCustomerId(pool2, schema2, userId);
+    if (!customerId) return [];
+    const result = await pool2.query(
+      `SELECT id, status, customer, current_period_start, current_period_end,
+              cancel_at_period_end, items
+       FROM ${schema2}.subscriptions
+       WHERE customer = $1
+       ORDER BY current_period_end DESC`,
+      [customerId]
+    );
+    return result.rows.map(rowToSubscription);
+  }
+  return { isActive, get, list };
+}
+
+// src/handlers/utils.ts
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function errorResponse(message, status = 500) {
+  return jsonResponse({ error: message }, status);
+}
+function successResponse(request, data, redirectUrl) {
+  const acceptHeader = request.headers.get("accept") || "";
+  if (acceptHeader.includes("application/json")) {
+    return jsonResponse({ ...data, redirectUrl });
+  }
+  return Response.redirect(redirectUrl, 303);
+}
+
+// src/handlers/checkout.ts
+async function hasPaymentMethod(stripe, customerId) {
+  const customer = await stripe.customers.retrieve(customerId);
+  if ("deleted" in customer && customer.deleted) return false;
+  return !!customer.invoice_settings?.default_payment_method;
+}
+function resolvePriceId(body, billingConfig, mode) {
+  if (body.priceId) {
+    return body.priceId;
+  }
+  if (!body.interval) {
+    throw new Error("interval is required when using planName or planId");
+  }
+  if (!billingConfig?.[mode]?.plans) {
+    throw new Error(
+      "billingConfig with plans is required when using planName or planId"
+    );
+  }
+  const plan = body.planName ? billingConfig[mode]?.plans?.find((p) => p.name === body.planName) : body.planId ? billingConfig[mode]?.plans?.find((p) => p.id === body.planId) : null;
+  if (!plan) {
+    const identifier = body.planName || body.planId;
+    throw new Error(`Plan not found: ${identifier}`);
+  }
+  const price = plan.price.find((p) => p.interval === body.interval);
+  if (!price) {
+    throw new Error(
+      `Price with interval "${body.interval}" not found for plan "${plan.name}"`
+    );
+  }
+  if (!price.id) {
+    throw new Error(
+      `Price ID not set for plan "${plan.name}" with interval "${body.interval}". Run stripe-sync to sync price IDs.`
+    );
+  }
+  return price.id;
+}
+async function getPriceMode(stripe, priceId) {
+  const price = await stripe.prices.retrieve(priceId);
+  return price.type === "recurring" ? "subscription" : "payment";
+}
+function shouldDisableProration(billingConfig, mode, oldPriceId, newPriceId) {
+  const oldPlan = findPlanByPriceId(billingConfig, mode, oldPriceId);
+  const newPlan = findPlanByPriceId(billingConfig, mode, newPriceId);
+  return planHasCredits(oldPlan) && planHasCredits(newPlan);
+}
+async function handleCheckout(request, ctx) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    if (!body.priceId && !body.planName && !body.planId) {
+      return errorResponse(
+        "Provide either priceId, planName+interval, or planId+interval",
+        400
+      );
+    }
+    const origin = request.headers.get("origin") || "";
+    const successUrl = body.successUrl || ctx.defaultSuccessUrl || `${origin}/success?session_id={CHECKOUT_SESSION_ID}`;
+    const cancelUrl = body.cancelUrl || ctx.defaultCancelUrl || `${origin}/`;
+    const priceId = resolvePriceId(body, ctx.billingConfig, ctx.mode);
+    const priceMode = await getPriceMode(ctx.stripe, priceId);
+    const user = ctx.resolveUser ? await ctx.resolveUser(request) : null;
+    if (!user) {
+      return errorResponse(
+        "Unauthorized. Configure resolveUser to extract authenticated user.",
+        401
+      );
+    }
+    const orgId = ctx.resolveOrg ? await ctx.resolveOrg(request) : null;
+    const customerId = await ctx.resolveStripeCustomerId({
+      user: orgId ? { id: orgId } : user,
+      createIfNotFound: true
+    });
+    if (customerId && priceMode === "subscription") {
+      const currentSub = await getActiveSubscription(ctx.stripe, customerId);
+      if (currentSub) {
+        const currentPriceId = currentSub.items.data[0]?.price?.id;
+        const currentAmount = currentSub.items.data[0]?.price?.unit_amount ?? 0;
+        if (currentPriceId === priceId) {
+          return jsonResponse({
+            success: true,
+            alreadySubscribed: true,
+            message: "Already on this plan"
+          });
+        }
+        const targetPrice = await ctx.stripe.prices.retrieve(priceId);
+        const targetAmount = targetPrice.unit_amount ?? 0;
+        const customerHasPaymentMethod = await hasPaymentMethod(
+          ctx.stripe,
+          customerId
+        );
+        const isUpgrade = targetAmount > currentAmount;
+        const isDowngrade = targetAmount < currentAmount;
+        if (isDowngrade) {
+          await ctx.stripe.subscriptions.update(currentSub.id, {
+            items: [{ id: currentSub.items.data[0].id, price: priceId }],
+            proration_behavior: "none",
+            metadata: {
+              pending_credit_downgrade: "true",
+              downgrade_from_price: currentPriceId
+            }
+          });
+          const periodEnd = currentSub.current_period_end;
+          return successResponse(
+            request,
+            {
+              success: true,
+              scheduled: true,
+              message: "Downgrade scheduled for end of current billing period",
+              ...periodEnd && {
+                effectiveAt: new Date(periodEnd * 1e3).toISOString()
+              },
+              url: successUrl
+            },
+            successUrl
+          );
+        }
+        const disableProration = shouldDisableProration(
+          ctx.billingConfig,
+          ctx.mode,
+          currentPriceId,
+          priceId
+        );
+        if (customerHasPaymentMethod && isUpgrade) {
+          try {
+            await ctx.stripe.subscriptions.update(currentSub.id, {
+              items: [{ id: currentSub.items.data[0].id, price: priceId }],
+              proration_behavior: disableProration ? "none" : "create_prorations",
+              ...disableProration && { billing_cycle_anchor: "now" },
+              metadata: {
+                upgrade_from_price_id: currentPriceId,
+                upgrade_from_price_amount: currentAmount.toString()
+              }
+            });
+          } catch (err) {
+            console.error("Direct subscription update failed:", err);
+            const portal = await ctx.stripe.billingPortal.sessions.create({
+              customer: customerId,
+              return_url: cancelUrl
+            });
+            return successResponse(
+              request,
+              {
+                error: "Payment issue",
+                portalUrl: portal.url
+              },
+              portal.url
+            );
+          }
+          return successResponse(
+            request,
+            {
+              success: true,
+              upgraded: true,
+              url: successUrl
+            },
+            successUrl
+          );
+        }
+        const session2 = await ctx.stripe.checkout.sessions.create({
+          customer: customerId,
+          mode: "setup",
+          currency: targetPrice.currency,
+          success_url: successUrl,
+          cancel_url: cancelUrl,
+          metadata: {
+            ...body.metadata,
+            upgrade_subscription_id: currentSub.id,
+            upgrade_subscription_item_id: currentSub.items.data[0].id,
+            upgrade_to_price_id: priceId,
+            upgrade_from_price_id: currentPriceId,
+            upgrade_from_price_amount: currentAmount.toString(),
+            upgrade_disable_proration: disableProration ? "true" : "false"
+          }
+        });
+        if (!session2.url) {
+          return errorResponse("Failed to create checkout session", 500);
+        }
+        return successResponse(request, { url: session2.url }, session2.url);
       }
-      if (callbacks) {
-        await handleCallbacks(event, callbacks);
+    }
+    const sessionParams = {
+      line_items: [{ price: priceId, quantity: body.quantity ?? 1 }],
+      mode: priceMode,
+      success_url: successUrl,
+      cancel_url: cancelUrl,
+      automatic_tax: { enabled: ctx.automaticTax },
+      payment_method_collection: "if_required"
+    };
+    if (customerId) {
+      sessionParams.customer = customerId;
+    }
+    const sessionMetadata = { ...body.metadata };
+    if (orgId) {
+      sessionMetadata.org_id = orgId;
+    }
+    if (ctx.grantTo === "seat-users" && orgId) {
+      sessionMetadata.first_seat_user_id = user.id;
+    }
+    if (Object.keys(sessionMetadata).length > 0) {
+      sessionParams.metadata = sessionMetadata;
+      if (priceMode === "subscription") {
+        sessionParams.subscription_data = { metadata: sessionMetadata };
       }
-      return new Response(JSON.stringify({ received: true }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" }
-      });
-    } catch (error) {
-      console.error("Stripe webhook error:", error);
-      const message = error instanceof Error ? error.message : "Internal server error";
-      return new Response(message, { status: 500 });
     }
+    const session = await ctx.stripe.checkout.sessions.create(sessionParams);
+    if (!session.url) {
+      return errorResponse("Failed to create checkout session", 500);
+    }
+    return successResponse(request, { url: session.url }, session.url);
+  } catch (err) {
+    console.error("Checkout error:", err);
+    const message = err instanceof Error ? err.message : "Unknown error";
+    const status = err && typeof err === "object" && "statusCode" in err ? err.statusCode : 500;
+    return errorResponse(message, status);
   }
-  return async function handler(request) {
-    const url = new URL(request.url);
-    const pathSegments = url.pathname.split("/").filter(Boolean);
-    const action = pathSegments[pathSegments.length - 1];
-    if (request.method !== "POST") {
-      return new Response(JSON.stringify({ error: "Method not allowed" }), {
-        status: 405,
-        headers: { "Content-Type": "application/json" }
-      });
+}
+
+// src/handlers/customer-portal.ts
+async function handleCustomerPortal(request, ctx) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const user = ctx.resolveUser ? await ctx.resolveUser(request) : null;
+    if (!user) {
+      return errorResponse(
+        "Unauthorized. Configure resolveUser to extract authenticated user.",
+        401
+      );
     }
-    switch (action) {
-      case "checkout":
-        return handleCheckout(request);
-      case "webhook":
-        return handleWebhook(request);
-      default:
+    const orgId = ctx.resolveOrg ? await ctx.resolveOrg(request) : null;
+    const customerId = await ctx.resolveStripeCustomerId({
+      user: orgId ? { id: orgId } : user,
+      createIfNotFound: false
+    });
+    if (!customerId) {
+      return errorResponse("No billing account found for this user.", 404);
+    }
+    const origin = request.headers.get("origin") || "";
+    const returnUrl = body.returnUrl || `${origin}/`;
+    const session = await ctx.stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: returnUrl
+    });
+    return successResponse(request, { url: session.url }, session.url);
+  } catch (err) {
+    console.error("Customer portal error:", err);
+    const message = err instanceof Error ? err.message : "Unknown error";
+    const status = err && typeof err === "object" && "statusCode" in err ? err.statusCode : 500;
+    return errorResponse(message, status);
+  }
+}
+
+// src/handlers/webhook.ts
+async function handleWebhook(request, ctx) {
+  try {
+    const body = await request.text();
+    const url = new URL(request.url);
+    const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    const signature = request.headers.get("stripe-signature");
+    let event;
+    if (isLocalhost) {
+      event = JSON.parse(body);
+    } else {
+      if (!signature) {
+        return new Response("Missing stripe-signature header", { status: 400 });
+      }
+      try {
+        event = ctx.stripe.webhooks.constructEvent(
+          body,
+          signature,
+          ctx.stripeWebhookSecret
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
         return new Response(
-          JSON.stringify({
-            error: `Unknown action: ${action}. Supported: checkout, webhook`
-          }),
-          { status: 404, headers: { "Content-Type": "application/json" } }
+          `Webhook signature verification failed: ${message}`,
+          { status: 400 }
         );
+      }
+    }
+    if (ctx.sync) {
+      const shouldSkipSync = (
+        // Setup mode checkouts have no line items
+        event.type === "checkout.session.completed" && event.data.object.mode === "setup" || // Upcoming invoices have null IDs
+        event.type === "invoice.upcoming"
+      );
+      if (!shouldSkipSync) {
+        try {
+          await ctx.sync.processEvent(event);
+        } catch (err) {
+          console.error("Stripe sync error (non-fatal):", err);
+        }
+      }
+    }
+    await handleEvent(event, ctx);
+    return new Response(JSON.stringify({ received: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  } catch (error) {
+    console.error("Stripe webhook error:", error);
+    const message = error instanceof Error ? error.message : "Internal server error";
+    return new Response(message, { status: 500 });
+  }
+}
+async function handleDuplicateSubscriptions(ctx, subscription) {
+  const customerId = getCustomerIdFromSubscription(subscription);
+  const allSubs = await ctx.stripe.subscriptions.list({
+    customer: customerId,
+    status: "active",
+    limit: 10
+  });
+  const activeSubs = allSubs.data.filter(
+    (s) => s.status === "active" || s.status === "trialing"
+  );
+  if (activeSubs.length <= 1) return false;
+  const sorted = activeSubs.sort((a, b) => {
+    const aAmount = a.items.data[0]?.price?.unit_amount ?? 0;
+    const bAmount = b.items.data[0]?.price?.unit_amount ?? 0;
+    return bAmount - aAmount;
+  });
+  const toKeep = sorted[0];
+  for (const sub of sorted.slice(1)) {
+    try {
+      await ctx.stripe.subscriptions.update(sub.id, {
+        metadata: { cancelled_as_duplicate: "true" }
+      });
+      await ctx.stripe.subscriptions.cancel(sub.id);
+    } catch (err) {
+      console.error(`Failed to cancel duplicate subscription ${sub.id}:`, err);
+    }
+  }
+  return subscription.id !== toKeep.id;
+}
+async function handleSetupModeUpgrade(ctx, session) {
+  const { metadata } = session;
+  if (!metadata) return;
+  const subId = metadata.upgrade_subscription_id;
+  const itemId = metadata.upgrade_subscription_item_id;
+  const newPriceId = metadata.upgrade_to_price_id;
+  const disableProration = metadata.upgrade_disable_proration === "true";
+  if (!subId || !itemId || !newPriceId) {
+    console.error("Missing upgrade metadata in setup session:", metadata);
+    return;
+  }
+  const paymentMethodId = await getPaymentMethodFromSetupIntent(ctx, session);
+  const updateParams = {
+    items: [{ id: itemId, price: newPriceId }],
+    proration_behavior: disableProration ? "none" : "create_prorations",
+    ...disableProration && { billing_cycle_anchor: "now" },
+    metadata: {
+      upgrade_from_price_id: metadata.upgrade_from_price_id || "",
+      upgrade_from_price_amount: metadata.upgrade_from_price_amount || ""
     }
   };
+  if (paymentMethodId) {
+    updateParams.default_payment_method = paymentMethodId;
+  }
+  await ctx.stripe.subscriptions.update(subId, updateParams);
+  if (paymentMethodId && session.customer) {
+    const customerId = typeof session.customer === "string" ? session.customer : session.customer.id;
+    await ctx.stripe.customers.update(customerId, {
+      invoice_settings: { default_payment_method: paymentMethodId }
+    });
+  }
+}
+async function getPaymentMethodFromSetupIntent(ctx, session) {
+  const setupIntentId = typeof session.setup_intent === "string" ? session.setup_intent : session.setup_intent?.id;
+  if (!setupIntentId) return void 0;
+  const setupIntent = await ctx.stripe.setupIntents.retrieve(setupIntentId);
+  return typeof setupIntent.payment_method === "string" ? setupIntent.payment_method : setupIntent.payment_method?.id;
+}
+async function saveDefaultPaymentMethod(ctx, session) {
+  try {
+    const subscriptionId = typeof session.subscription === "string" ? session.subscription : session.subscription?.id;
+    if (!subscriptionId) return;
+    const subscription = await ctx.stripe.subscriptions.retrieve(
+      subscriptionId
+    );
+    const paymentMethod = subscription.default_payment_method;
+    const customerId = typeof subscription.customer === "string" ? subscription.customer : subscription.customer.id;
+    if (paymentMethod && customerId) {
+      const paymentMethodId = typeof paymentMethod === "string" ? paymentMethod : paymentMethod.id;
+      await ctx.stripe.customers.update(customerId, {
+        invoice_settings: { default_payment_method: paymentMethodId }
+      });
+    }
+  } catch (err) {
+    console.error("Failed to set default payment method:", err);
+  }
 }
-async function handleCallbacks(event, callbacks) {
-  const { onSubscriptionCreated, onSubscriptionCancelled } = callbacks;
+async function handleEvent(event, ctx) {
   switch (event.type) {
-    case "customer.subscription.created":
-      if (onSubscriptionCreated) {
-        await onSubscriptionCreated(event.data.object);
-      }
+    case "customer.subscription.created": {
+      const subscription = event.data.object;
+      const shouldSkipCredits = await handleDuplicateSubscriptions(
+        ctx,
+        subscription
+      );
+      if (shouldSkipCredits) break;
+      await ctx.creditLifecycle.onSubscriptionCreated(subscription);
+      await ctx.callbacks?.onSubscriptionCreated?.(subscription);
       break;
-    case "customer.subscription.deleted":
-      if (onSubscriptionCancelled) {
-        await onSubscriptionCancelled(event.data.object);
+    }
+    case "customer.subscription.deleted": {
+      const subscription = event.data.object;
+      if (subscription.metadata?.cancelled_as_duplicate) {
+        break;
       }
+      await ctx.creditLifecycle.onSubscriptionCancelled(subscription);
+      await ctx.callbacks?.onSubscriptionCancelled?.(subscription);
       break;
-    case "customer.subscription.updated":
+    }
+    case "customer.subscription.updated": {
       const subscription = event.data.object;
-      const previousAttributes = event.data.previous_attributes;
-      if (onSubscriptionCancelled && subscription.status === "canceled" && previousAttributes?.status && previousAttributes.status !== "canceled") {
-        await onSubscriptionCancelled(subscription);
+      const prev = event.data.previous_attributes;
+      const statusChangedToCanceled = subscription.status === "canceled" && prev?.status && prev.status !== "canceled";
+      if (statusChangedToCanceled) {
+        await ctx.creditLifecycle.onSubscriptionCancelled(subscription);
+        await ctx.callbacks?.onSubscriptionCancelled?.(subscription);
+        break;
+      }
+      if (prev?.items) {
+        const oldPriceId = prev.items.data?.[0]?.price?.id;
+        const newPriceId = subscription.items.data[0]?.price?.id;
+        if (oldPriceId && newPriceId && oldPriceId !== newPriceId) {
+          await ctx.creditLifecycle.onSubscriptionPlanChanged(
+            subscription,
+            oldPriceId
+          );
+          await ctx.callbacks?.onSubscriptionPlanChanged?.(
+            subscription,
+            oldPriceId
+          );
+        }
       }
       break;
+    }
+    case "invoice.paid": {
+      const invoice = event.data.object;
+      const subscriptionId = invoice.subscription ?? invoice.parent?.subscription_details?.subscription;
+      if (invoice.billing_reason === "subscription_cycle" && subscriptionId) {
+        const subId = typeof subscriptionId === "string" ? subscriptionId : subscriptionId.id;
+        const subscription = await ctx.stripe.subscriptions.retrieve(subId);
+        const pendingCreditDowngrade = subscription.metadata?.pending_credit_downgrade;
+        if (pendingCreditDowngrade === "true") {
+          const currentPriceId = subscription.items.data[0]?.price?.id;
+          await ctx.stripe.subscriptions.update(subscription.id, {
+            metadata: {
+              pending_credit_downgrade: "",
+              downgrade_from_price: ""
+            }
+          });
+          if (currentPriceId) {
+            await ctx.creditLifecycle.onDowngradeApplied(
+              subscription,
+              currentPriceId
+            );
+          }
+          break;
+        }
+        await ctx.creditLifecycle.onSubscriptionRenewed(
+          subscription,
+          invoice.id
+        );
+        await ctx.callbacks?.onSubscriptionRenewed?.(subscription);
+      }
+      break;
+    }
+    case "checkout.session.completed": {
+      const session = event.data.object;
+      if (session.metadata?.top_up_credit_type) {
+        await ctx.topUpHandler.handleTopUpCheckoutCompleted(session);
+      }
+      if (session.mode === "setup" && session.metadata?.upgrade_subscription_id) {
+        await handleSetupModeUpgrade(ctx, session);
+        break;
+      }
+      if (session.mode === "subscription" && session.subscription) {
+        await saveDefaultPaymentMethod(ctx, session);
+      }
+      break;
+    }
+    case "payment_intent.succeeded": {
+      const paymentIntent = event.data.object;
+      await ctx.topUpHandler.handlePaymentIntentSucceeded(paymentIntent);
+      break;
+    }
   }
 }
+
+// src/Billing.ts
+var Billing = class {
+  constructor(config = {}) {
+    this.resolveStripeCustomerId = async (options) => {
+      const { user, createIfNotFound } = options;
+      const { id: userId, name, email } = user;
+      if (this.pool) {
+        const result = await this.pool.query(
+          `SELECT stripe_customer_id FROM ${this.schema}.user_stripe_customer_map WHERE user_id = $1`,
+          [userId]
+        );
+        if (result.rows.length > 0) {
+          return result.rows[0].stripe_customer_id;
+        }
+      }
+      if (this.mapUserIdToStripeCustomerId) {
+        const customerId = await this.mapUserIdToStripeCustomerId(userId);
+        if (customerId) {
+          return customerId;
+        }
+      }
+      if (createIfNotFound) {
+        const customerParams = {
+          metadata: { user_id: userId }
+        };
+        if (name) customerParams.name = name;
+        if (email) customerParams.email = email;
+        const customer = await this.stripe.customers.create(customerParams);
+        if (this.pool) {
+          await this.pool.query(
+            `INSERT INTO ${this.schema}.user_stripe_customer_map (user_id, stripe_customer_id)
+           VALUES ($1, $2)
+           ON CONFLICT (user_id) DO UPDATE SET stripe_customer_id = $2, updated_at = now()`,
+            [userId, customer.id]
+          );
+        }
+        return customer.id;
+      }
+      return null;
+    };
+    const {
+      stripeSecretKey = process.env.STRIPE_SECRET_KEY,
+      stripeWebhookSecret = process.env.STRIPE_WEBHOOK_SECRET,
+      databaseUrl = process.env.DATABASE_URL,
+      schema: schema2 = "stripe",
+      billingConfig,
+      successUrl,
+      cancelUrl,
+      credits: creditsConfig,
+      callbacks,
+      mapUserIdToStripeCustomerId
+    } = config;
+    this.stripe = new import_stripe.default(stripeSecretKey);
+    this.pool = databaseUrl ? new import_pg.Pool({ connectionString: databaseUrl }) : null;
+    this.schema = schema2;
+    this.billingConfig = billingConfig;
+    this.mode = getMode(stripeSecretKey);
+    this.grantTo = creditsConfig?.grantTo ?? "subscriber";
+    this.defaultSuccessUrl = successUrl;
+    this.defaultCancelUrl = cancelUrl;
+    this.stripeWebhookSecret = stripeWebhookSecret;
+    this.mapUserIdToStripeCustomerId = mapUserIdToStripeCustomerId;
+    this.creditsConfig = creditsConfig;
+    this.callbacks = callbacks;
+    initCredits(this.pool, this.schema);
+    this.sync = databaseUrl ? new import_stripe_sync_engine.StripeSync({
+      poolConfig: { connectionString: databaseUrl },
+      schema: this.schema,
+      stripeSecretKey,
+      stripeWebhookSecret
+    }) : null;
+    this.subscriptions = createSubscriptionsApi({
+      pool: this.pool,
+      schema: this.schema,
+      billingConfig: this.billingConfig,
+      mode: this.mode
+    });
+    const mergedCallbacks = {
+      onTopUpCompleted: callbacks?.onTopUpCompleted ?? creditsConfig?.onTopUpCompleted,
+      onAutoTopUpFailed: callbacks?.onAutoTopUpFailed ?? creditsConfig?.onAutoTopUpFailed,
+      onCreditsLow: callbacks?.onCreditsLow ?? creditsConfig?.onCreditsLow
+    };
+    this.credits = this.createCreditsApi(mergedCallbacks);
+    this.seats = createSeatsApi({
+      stripe: this.stripe,
+      pool: this.pool,
+      schema: this.schema,
+      billingConfig: this.billingConfig,
+      mode: this.mode,
+      grantTo: this.grantTo,
+      callbacks: {
+        onCreditsGranted: callbacks?.onCreditsGranted ?? creditsConfig?.onCreditsGranted,
+        onCreditsRevoked: callbacks?.onCreditsRevoked ?? creditsConfig?.onCreditsRevoked
+      }
+    });
+  }
+  createCreditsApi(callbacks) {
+    const topUpHandler = createTopUpHandler({
+      stripe: this.stripe,
+      pool: this.pool,
+      schema: this.schema,
+      billingConfig: this.billingConfig,
+      mode: this.mode,
+      successUrl: this.defaultSuccessUrl || "",
+      cancelUrl: this.defaultCancelUrl || "",
+      onAutoTopUpFailed: callbacks?.onAutoTopUpFailed,
+      onTopUpCompleted: callbacks?.onTopUpCompleted,
+      onCreditsLow: callbacks?.onCreditsLow
+    });
+    const consumeCredits = async (params) => {
+      const result = await credits.consume(params);
+      if (result.success) {
+        topUpHandler.triggerAutoTopUpIfNeeded({
+          userId: params.userId,
+          creditType: params.creditType,
+          currentBalance: result.balance
+        }).catch((err) => {
+          const message = err instanceof Error ? err.message : "Unknown error";
+          console.error("Auto top-up error:", err);
+          callbacks?.onAutoTopUpFailed?.({
+            userId: params.userId,
+            creditType: params.creditType,
+            reason: "unexpected_error",
+            error: message
+          });
+        });
+      }
+      return result;
+    };
+    return {
+      consume: consumeCredits,
+      grant: credits.grant,
+      revoke: credits.revoke,
+      revokeAll: credits.revokeAll,
+      setBalance: credits.setBalance,
+      getBalance: credits.getBalance,
+      getAllBalances: credits.getAllBalances,
+      hasCredits: credits.hasCredits,
+      getHistory: credits.getHistory,
+      topUp: topUpHandler.topUp,
+      hasPaymentMethod: topUpHandler.hasPaymentMethod
+    };
+  }
+  createHandler(handlerConfig = {}) {
+    const {
+      resolveUser,
+      resolveOrg,
+      callbacks: handlerCallbacks,
+      automaticTax = false
+    } = handlerConfig;
+    const callbacks = { ...this.callbacks, ...handlerCallbacks };
+    const creditLifecycle = createCreditLifecycle({
+      pool: this.pool,
+      schema: this.schema,
+      billingConfig: this.billingConfig,
+      mode: this.mode,
+      grantTo: this.grantTo,
+      callbacks
+    });
+    const topUpHandler = createTopUpHandler({
+      stripe: this.stripe,
+      pool: this.pool,
+      schema: this.schema,
+      billingConfig: this.billingConfig,
+      mode: this.mode,
+      successUrl: this.defaultSuccessUrl || "",
+      cancelUrl: this.defaultCancelUrl || "",
+      onCreditsGranted: callbacks?.onCreditsGranted,
+      onTopUpCompleted: callbacks?.onTopUpCompleted,
+      onAutoTopUpFailed: callbacks?.onAutoTopUpFailed,
+      onCreditsLow: callbacks?.onCreditsLow
+    });
+    const routeContext = {
+      stripe: this.stripe,
+      pool: this.pool,
+      schema: this.schema,
+      billingConfig: this.billingConfig,
+      mode: this.mode,
+      grantTo: this.grantTo,
+      defaultSuccessUrl: this.defaultSuccessUrl,
+      defaultCancelUrl: this.defaultCancelUrl,
+      automaticTax,
+      resolveUser,
+      resolveOrg,
+      resolveStripeCustomerId: this.resolveStripeCustomerId
+    };
+    const webhookContext = {
+      stripe: this.stripe,
+      stripeWebhookSecret: this.stripeWebhookSecret,
+      sync: this.sync,
+      creditLifecycle,
+      topUpHandler,
+      callbacks
+    };
+    return async (request) => {
+      const url = new URL(request.url);
+      const action = url.pathname.split("/").filter(Boolean).pop();
+      if (request.method !== "POST") {
+        return new Response(JSON.stringify({ error: "Method not allowed" }), {
+          status: 405,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      switch (action) {
+        case "checkout":
+          return handleCheckout(request, routeContext);
+        case "webhook":
+          return handleWebhook(request, webhookContext);
+        case "customer_portal":
+          return handleCustomerPortal(request, routeContext);
+        default:
+          return new Response(
+            JSON.stringify({
+              error: `Unknown action: ${action}. Supported: checkout, webhook, customer_portal`
+            }),
+            { status: 404, headers: { "Content-Type": "application/json" } }
+          );
+      }
+    };
+  }
+};
+function createHandler(config) {
+  return new Billing(config).createHandler(config);
+}
+
+// src/fasterStripe.ts
+var import_stripe2 = __toESM(require("stripe"));
+var import_pg2 = require("pg");
+function buildCreatedFilter(created, params, paramIndex) {
+  if (created === void 0) {
+    return { sql: "", params: [], nextIndex: paramIndex };
+  }
+  const conditions = [];
+  const newParams = [];
+  let idx = paramIndex;
+  if (typeof created === "number") {
+    conditions.push(`created = $${idx}`);
+    newParams.push(created);
+    idx++;
+  } else {
+    if (created.gt !== void 0) {
+      conditions.push(`created > $${idx}`);
+      newParams.push(created.gt);
+      idx++;
+    }
+    if (created.gte !== void 0) {
+      conditions.push(`created >= $${idx}`);
+      newParams.push(created.gte);
+      idx++;
+    }
+    if (created.lt !== void 0) {
+      conditions.push(`created < $${idx}`);
+      newParams.push(created.lt);
+      idx++;
+    }
+    if (created.lte !== void 0) {
+      conditions.push(`created <= $${idx}`);
+      newParams.push(created.lte);
+      idx++;
+    }
+  }
+  return {
+    sql: conditions.length > 0 ? conditions.join(" AND ") : "",
+    params: newParams,
+    nextIndex: idx
+  };
+}
+function buildPaginationFilter(startingAfter, endingBefore, params, paramIndex) {
+  let idx = paramIndex;
+  const newParams = [];
+  let sql = "";
+  let orderDesc = true;
+  if (startingAfter) {
+    sql = `id < $${idx}`;
+    newParams.push(startingAfter);
+    idx++;
+    orderDesc = true;
+  } else if (endingBefore) {
+    sql = `id > $${idx}`;
+    newParams.push(endingBefore);
+    idx++;
+    orderDesc = false;
+  }
+  return { sql, params: newParams, nextIndex: idx, orderDesc };
+}
+function createResourceProxy(pool2, schema2, stripeResource, config) {
+  const { tableName, filterMappings = {}, defaultFilters = {} } = config;
+  async function listFromDb(params) {
+    if (!pool2) return null;
+    try {
+      const limit = Math.min(params?.limit ?? 10, 100);
+      const conditions = [];
+      const queryParams = [];
+      let paramIdx = 1;
+      for (const [column, value] of Object.entries(defaultFilters)) {
+        conditions.push(`${column} = $${paramIdx}`);
+        queryParams.push(value);
+        paramIdx++;
+      }
+      const createdResult = buildCreatedFilter(
+        params?.created,
+        queryParams,
+        paramIdx
+      );
+      if (createdResult.sql) {
+        conditions.push(createdResult.sql);
+        queryParams.push(...createdResult.params);
+        paramIdx = createdResult.nextIndex;
+      }
+      const paginationResult = buildPaginationFilter(
+        params?.starting_after,
+        params?.ending_before,
+        queryParams,
+        paramIdx
+      );
+      if (paginationResult.sql) {
+        conditions.push(paginationResult.sql);
+        queryParams.push(...paginationResult.params);
+        paramIdx = paginationResult.nextIndex;
+      }
+      if (params) {
+        for (const [stripeParam, dbColumn] of Object.entries(filterMappings)) {
+          const value = params[stripeParam];
+          if (value !== void 0) {
+            conditions.push(`${dbColumn} = $${paramIdx}`);
+            queryParams.push(value);
+            paramIdx++;
+          }
+        }
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const orderDirection = paginationResult.orderDesc ? "DESC" : "ASC";
+      const query = `
+        SELECT * FROM ${schema2}.${tableName}
+        ${whereClause}
+        ORDER BY id ${orderDirection}
+        LIMIT $${paramIdx}
+      `;
+      queryParams.push(limit + 1);
+      const result = await pool2.query(query, queryParams);
+      const hasMore = result.rows.length > limit;
+      const data = hasMore ? result.rows.slice(0, limit) : result.rows;
+      if (params?.ending_before) {
+        data.reverse();
+      }
+      return {
+        object: "list",
+        data,
+        has_more: hasMore,
+        url: `/v1/${tableName}`
+      };
+    } catch (error) {
+      console.warn(
+        `FasterStripe: DB query failed for ${tableName}.list, falling back to Stripe API:`,
+        error
+      );
+      return null;
+    }
+  }
+  async function retrieveFromDb(id) {
+    if (!pool2) return null;
+    try {
+      const query = `SELECT * FROM ${schema2}.${tableName} WHERE id = $1`;
+      const result = await pool2.query(query, [id]);
+      if (result.rows.length === 0) {
+        return null;
+      }
+      return result.rows[0];
+    } catch (error) {
+      console.warn(
+        `FasterStripe: DB query failed for ${tableName}.retrieve, falling back to Stripe API:`,
+        error
+      );
+      return null;
+    }
+  }
+  const proxy = {
+    async list(params) {
+      const dbResult = await listFromDb(params);
+      if (dbResult) {
+        return dbResult;
+      }
+      return stripeResource.list(params);
+    },
+    async retrieve(id, params) {
+      const dbResult = await retrieveFromDb(id);
+      if (dbResult) {
+        return Object.assign(dbResult, {
+          lastResponse: {
+            headers: {},
+            requestId: "db-cache",
+            statusCode: 200
+          }
+        });
+      }
+      return stripeResource.retrieve(id, params);
+    }
+  };
+  if (stripeResource.create) {
+    proxy.create = stripeResource.create.bind(stripeResource);
+  }
+  if (stripeResource.update) {
+    proxy.update = stripeResource.update.bind(stripeResource);
+  }
+  if (stripeResource.del) {
+    proxy.del = stripeResource.del.bind(stripeResource);
+  }
+  return proxy;
+}
+var FasterStripe = class {
+  /**
+   * Create a new FasterStripe instance.
+   *
+   * @param apiKey - Stripe secret key. If not provided, reads from STRIPE_SECRET_KEY env var.
+   * @param config - Optional configuration (extends Stripe.StripeConfig with databaseUrl and schema)
+   *
+   * @example
+   * // Exact same as official Stripe SDK
+   * const stripe = new Stripe('sk_test_...');
+   * const stripe = new Stripe('sk_test_...', { apiVersion: '2023-10-16' });
+   *
+   * // Bonus: auto-read from env
+   * const stripe = new Stripe(); // reads STRIPE_SECRET_KEY
+   */
+  constructor(apiKey, config) {
+    this.pool = null;
+    const stripeSecretKey = apiKey ?? process.env.STRIPE_SECRET_KEY;
+    if (!stripeSecretKey) {
+      throw new Error(
+        "Stripe secret key is required. Pass it as first argument or set STRIPE_SECRET_KEY env var."
+      );
+    }
+    const { databaseUrl, schema: schema2, ...stripeConfig } = config ?? {};
+    this.stripe = new import_stripe2.default(stripeSecretKey, stripeConfig);
+    this.schema = schema2 ?? "stripe";
+    const dbUrl = databaseUrl ?? process.env.DATABASE_URL;
+    if (dbUrl) {
+      try {
+        this.pool = typeof dbUrl === "string" ? new import_pg2.Pool({ connectionString: dbUrl }) : new import_pg2.Pool(dbUrl);
+      } catch (error) {
+        console.warn(
+          "FasterStripe: Failed to initialize database pool, falling back to Stripe API only:",
+          error
+        );
+      }
+    }
+    this.products = createResourceProxy(this.pool, this.schema, this.stripe.products, {
+      tableName: "products",
+      filterMappings: {
+        active: "active"
+      }
+    });
+    this.prices = createResourceProxy(this.pool, this.schema, this.stripe.prices, {
+      tableName: "prices",
+      filterMappings: {
+        active: "active",
+        product: "product",
+        currency: "currency",
+        type: "type"
+      }
+    });
+    this.customers = createResourceProxy(this.pool, this.schema, this.stripe.customers, {
+      tableName: "customers",
+      filterMappings: {
+        email: "email"
+      },
+      defaultFilters: {
+        deleted: false
+      }
+    });
+    this.subscriptions = createResourceProxy(this.pool, this.schema, this.stripe.subscriptions, {
+      tableName: "subscriptions",
+      filterMappings: {
+        customer: "customer",
+        price: "plan",
+        status: "status"
+      }
+    });
+    this.invoices = createResourceProxy(this.pool, this.schema, this.stripe.invoices, {
+      tableName: "invoices",
+      filterMappings: {
+        customer: "customer",
+        subscription: "subscription",
+        status: "status"
+      }
+    });
+    this.charges = createResourceProxy(this.pool, this.schema, this.stripe.charges, {
+      tableName: "charges",
+      filterMappings: {
+        customer: "customer",
+        payment_intent: "payment_intent"
+      }
+    });
+    this.paymentIntents = createResourceProxy(this.pool, this.schema, this.stripe.paymentIntents, {
+      tableName: "payment_intents",
+      filterMappings: {
+        customer: "customer"
+      }
+    });
+    this.paymentMethods = createResourceProxy(this.pool, this.schema, this.stripe.paymentMethods, {
+      tableName: "payment_methods",
+      filterMappings: {
+        customer: "customer",
+        type: "type"
+      }
+    });
+    this.setupIntents = createResourceProxy(this.pool, this.schema, this.stripe.setupIntents, {
+      tableName: "setup_intents",
+      filterMappings: {
+        customer: "customer",
+        payment_method: "payment_method"
+      }
+    });
+    this.plans = createResourceProxy(this.pool, this.schema, this.stripe.plans, {
+      tableName: "plans",
+      filterMappings: {
+        active: "active",
+        product: "product"
+      }
+    });
+    this.coupons = createResourceProxy(this.pool, this.schema, this.stripe.coupons, {
+      tableName: "coupons"
+    });
+    this.refunds = createResourceProxy(this.pool, this.schema, this.stripe.refunds, {
+      tableName: "refunds",
+      filterMappings: {
+        charge: "charge",
+        payment_intent: "payment_intent"
+      }
+    });
+    this.disputes = createResourceProxy(this.pool, this.schema, this.stripe.disputes, {
+      tableName: "disputes",
+      filterMappings: {
+        charge: "charge",
+        payment_intent: "payment_intent"
+      }
+    });
+    this.checkout = this.stripe.checkout;
+    this.billingPortal = this.stripe.billingPortal;
+    this.webhooks = this.stripe.webhooks;
+    this.webhookEndpoints = this.stripe.webhookEndpoints;
+  }
+  /**
+   * Get the underlying Stripe instance for operations not covered by FasterStripe
+   */
+  get raw() {
+    return this.stripe;
+  }
+  /**
+   * Check if database connection is available
+   */
+  get hasDatabase() {
+    return this.pool !== null;
+  }
+  /**
+   * Close the database pool connection
+   */
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createStripeHandler
+  Billing,
+  CreditError,
+  FasterStripe,
+  createHandler,
+  credits,
+  initCredits
 });