@lunora/payment 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/createPayment-BccfPGyw.mjs

@@ -0,0 +1,190 @@
+import { usagePeriodStart, resolveEntitlements, featureNames, hasActivePrice } from './entitlementsForReference-CzZGXPoZ.mjs';
+import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+import idempotencyKey from './idempotencyKey-BFzDCA7g.mjs';
+import { n as notifyObserver } from './observability-CvhJ205g.mjs';
+import applyWebhookAction from './applyWebhookAction-DpAqf3Lw.mjs';
+
+const jsonResponse = (body, status) => Response.json(body, { headers: { "content-type": "application/json" }, status });
+const stripReferenceId = (metadata) => metadata && "referenceId" in metadata ? Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== "referenceId")) : metadata;
+const createPayment = (options) => {
+  const { adapter, store } = options;
+  const ensureAuthorized = async (referenceId) => {
+    if (!options.authorize) {
+      return;
+    }
+    let allowed;
+    try {
+      allowed = await options.authorize(referenceId);
+    } catch {
+      throw new LunoraPaymentError("FORBIDDEN", `caller not authorized for reference "${referenceId}"`);
+    }
+    if (!allowed) {
+      throw new LunoraPaymentError("FORBIDDEN", `caller not authorized for reference "${referenceId}"`);
+    }
+  };
+  const startCheckout = async (input) => {
+    await ensureAuthorized(input.referenceId);
+    const metadata = stripReferenceId(input.metadata);
+    let { customerId } = input;
+    if (!customerId) {
+      const existing = await store.getCustomerByReference(adapter.identifier, input.referenceId);
+      if (existing) {
+        customerId = existing.id;
+      } else {
+        const customer = await adapter.getOrCreateCustomer({ referenceId: input.referenceId });
+        customerId = customer.id;
+        await store.upsertCustomer(customer);
+      }
+    }
+    const key = input.idempotencyKey ?? idempotencyKey(
+      "checkout",
+      adapter.identifier,
+      input.referenceId,
+      input.priceId,
+      input.mode,
+      String(input.quantity ?? 1),
+      input.successUrl,
+      input.cancelUrl,
+      metadata ? JSON.stringify(metadata) : ""
+    );
+    return adapter.createCheckout({ ...input, customerId, idempotencyKey: key, metadata });
+  };
+  const evaluateFeature = async (entitlements, subscriptions, referenceId, featureId, need) => {
+    const limit = entitlements.limit(featureId);
+    if (limit !== void 0) {
+      const used = await store.sumUsage(referenceId, featureId, usagePeriodStart(subscriptions));
+      const balance = limit - used;
+      return { allowed: balance >= need, balance, limit, unlimited: false, used };
+    }
+    return { allowed: entitlements.has(featureId), unlimited: entitlements.has(featureId) };
+  };
+  return {
+    adapter,
+    attach: async (input) => startCheckout({ ...input, mode: input.mode ?? "subscription" }),
+    cancelSubscription: async (subscriptionId, cancelOptions) => {
+      const existing = await store.getSubscription(adapter.identifier, subscriptionId);
+      if (!existing) {
+        throw new LunoraPaymentError("NOT_FOUND", `subscription "${subscriptionId}" not found`);
+      }
+      try {
+        await ensureAuthorized(existing.referenceId);
+      } catch {
+        throw new LunoraPaymentError("NOT_FOUND", `subscription "${subscriptionId}" not found`);
+      }
+      const key = cancelOptions?.idempotencyKey ?? idempotencyKey("cancel_subscription", adapter.identifier, subscriptionId);
+      const updated = await adapter.cancelSubscription(subscriptionId, { ...cancelOptions, idempotencyKey: key });
+      await store.upsertSubscription(updated);
+      return updated;
+    },
+    check: async (input) => {
+      await ensureAuthorized(input.referenceId);
+      const subscriptions = await store.listSubscriptionsByReference(input.referenceId);
+      if (input.priceId !== void 0) {
+        return { allowed: hasActivePrice(subscriptions, input.priceId), unlimited: false };
+      }
+      if (input.featureId === void 0) {
+        throw new LunoraPaymentError("CONFIG_INVALID", "check() requires a featureId or priceId");
+      }
+      if (!options.entitlements) {
+        throw new LunoraPaymentError("CONFIG_INVALID", "check() requires `entitlements` to be configured");
+      }
+      const entitlements = resolveEntitlements(options.entitlements, subscriptions);
+      return evaluateFeature(entitlements, subscriptions, input.referenceId, input.featureId, input.quantity ?? 1);
+    },
+    createCheckout: async (input) => startCheckout(input),
+    createPortalSession: async (referenceId, returnUrl) => {
+      await ensureAuthorized(referenceId);
+      const customer = await store.getCustomerByReference(adapter.identifier, referenceId);
+      if (!customer) {
+        throw new LunoraPaymentError("NOT_FOUND", `no customer for reference "${referenceId}"`);
+      }
+      return adapter.createPortalSession({ customerId: customer.id, returnUrl });
+    },
+    handleWebhook: async (request) => {
+      let action;
+      try {
+        const payload = await request.text();
+        action = await adapter.parseWebhook({ headers: request.headers, payload });
+      } catch (error) {
+        if (error instanceof LunoraPaymentError) {
+          return jsonResponse({ error: error.message }, error.status);
+        }
+        return jsonResponse({ error: "webhook error" }, 400);
+      }
+      const result = await applyWebhookAction(store, action, options.observability);
+      return jsonResponse({ applied: result.applied, reason: result.reason }, 200);
+    },
+    listBalances: async (referenceId) => {
+      await ensureAuthorized(referenceId);
+      if (!options.entitlements) {
+        throw new LunoraPaymentError("CONFIG_INVALID", "listBalances() requires `entitlements` to be configured");
+      }
+      const subscriptions = await store.listSubscriptionsByReference(referenceId);
+      const entitlements = resolveEntitlements(options.entitlements, subscriptions);
+      return Promise.all(
+        featureNames(options.entitlements).map(async (featureId) => {
+          return {
+            featureId,
+            ...await evaluateFeature(entitlements, subscriptions, referenceId, featureId, 1)
+          };
+        })
+      );
+    },
+    listSubscriptions: async (referenceId) => {
+      await ensureAuthorized(referenceId);
+      return store.listSubscriptionsByReference(referenceId);
+    },
+    store,
+    track: async (input) => {
+      await ensureAuthorized(input.referenceId);
+      const target = input.quantity ?? 1;
+      const key = input.idempotencyKey ?? crypto.randomUUID();
+      let delta = target;
+      if (input.mode === "set") {
+        const subscriptions = await store.listSubscriptionsByReference(input.referenceId);
+        const current = await store.sumUsage(input.referenceId, input.featureId, usagePeriodStart(subscriptions));
+        delta = target - current;
+      }
+      if (delta === 0) {
+        return { recorded: false, reportedToProvider: false };
+      }
+      const recorded = await store.recordUsage({
+        createdAt: Date.now(),
+        featureId: input.featureId,
+        idempotencyKey: key,
+        provider: adapter.identifier,
+        quantity: delta,
+        referenceId: input.referenceId,
+        reportedToProvider: false
+      });
+      if (!recorded) {
+        return { recorded: false, reportedToProvider: false };
+      }
+      if (delta <= 0 || !adapter.capabilities.usageMetering || !adapter.reportUsage) {
+        return { recorded: true, reportedToProvider: false };
+      }
+      try {
+        const customer = await store.getCustomerByReference(adapter.identifier, input.referenceId);
+        await adapter.reportUsage({
+          customerId: customer?.id,
+          featureId: input.featureId,
+          idempotencyKey: key,
+          quantity: delta,
+          referenceId: input.referenceId
+        });
+        await store.markUsageReported(adapter.identifier, key);
+        return { recorded: true, reportedToProvider: true };
+      } catch {
+        notifyObserver(options.observability, {
+          featureId: input.featureId,
+          provider: adapter.identifier,
+          referenceId: input.referenceId,
+          type: "usage.report_failed"
+        });
+        return { recorded: true, reportedToProvider: false };
+      }
+    }
+  };
+};
+
+export { createPayment };

package/dist/packem_shared/createPolarAdapter-BJtVGSlF.mjs

@@ -0,0 +1,217 @@
+import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+import { a as asRecord, r as readString, b as readBoolean, c as readNumber } from './json-Db337f36.mjs';
+import { money, zeroMoney } from './addMoney-bCcs1nyw.mjs';
+import { verifyStandardWebhook } from './constantTimeEqual-CfY0jYcL.mjs';
+
+const PAYMENT_STATE_BY_POLAR_ORDER_STATUS = {
+  paid: "captured",
+  partially_refunded: "partially_refunded",
+  pending: "initiated",
+  refunded: "refunded"
+};
+const SUBSCRIPTION_STATE_BY_POLAR_STATUS = {
+  active: "active",
+  canceled: "canceled",
+  incomplete: "trialing",
+  incomplete_expired: "canceled",
+  past_due: "past_due",
+  trialing: "trialing",
+  unpaid: "past_due"
+};
+const notSupported = (operation) => {
+  throw new LunoraPaymentError("PROVIDER_ERROR", `polar (merchant-of-record) does not support ${operation}`);
+};
+const parseTimestamp = (value) => {
+  const parsed = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+const subscriptionFromPolar = (subscription) => {
+  const now = Date.now();
+  return {
+    cancelAtPeriodEnd: subscription.cancelAtPeriodEnd ?? false,
+    createdAt: now,
+    currentPeriodEnd: parseTimestamp(subscription.currentPeriodEnd),
+    currentPeriodStart: parseTimestamp(subscription.currentPeriodStart),
+    id: subscription.id,
+    priceId: subscription.productId ?? "",
+    provider: "polar",
+    quantity: 1,
+    referenceId: subscription.metadata?.referenceId ?? "",
+    state: SUBSCRIPTION_STATE_BY_POLAR_STATUS[subscription.status] ?? "active",
+    updatedAt: now
+  };
+};
+const orderToSession = (order) => {
+  const now = Date.now();
+  const currency = order.currency ?? "usd";
+  const amount = money(BigInt(order.totalAmount ?? order.amount ?? 0), currency);
+  const state = PAYMENT_STATE_BY_POLAR_ORDER_STATUS[order.status] ?? "initiated";
+  const settled = state === "captured" || state === "partially_refunded" || state === "refunded";
+  return {
+    amount,
+    capturedAmount: settled ? amount : zeroMoney(currency),
+    createdAt: now,
+    id: order.id,
+    provider: "polar",
+    referenceId: "",
+    refundedAmount: state === "refunded" ? amount : zeroMoney(currency),
+    state,
+    updatedAt: now
+  };
+};
+const subscriptionEventType = (status) => {
+  const state = status ? SUBSCRIPTION_STATE_BY_POLAR_STATUS[status] : void 0;
+  if (state === "canceled") {
+    return "subscription.canceled";
+  }
+  if (state === "past_due") {
+    return "subscription.past_due";
+  }
+  if (state === "active" || state === "trialing") {
+    return "subscription.active";
+  }
+  return "subscription.updated";
+};
+const referenceFromMetadata = (object) => readString(asRecord(object.metadata), "referenceId");
+const mapEvent = (eventId, eventType, object) => {
+  const base = { eventId, provider: "polar", raw: { object, type: eventType } };
+  const currency = readString(object, "currency") ?? "usd";
+  switch (eventType) {
+    case "order.created":
+    case "order.paid": {
+      return {
+        ...base,
+        amount: money(BigInt(readNumber(object, "total_amount") ?? readNumber(object, "amount") ?? 0), currency),
+        customerId: readString(object, "customer_id"),
+        referenceId: referenceFromMetadata(object),
+        sessionId: readString(object, "id"),
+        subscriptionId: readString(object, "subscription_id"),
+        type: "payment.captured"
+      };
+    }
+    case "refund.created": {
+      return {
+        ...base,
+        amount: money(BigInt(readNumber(object, "amount") ?? 0), currency),
+        referenceId: referenceFromMetadata(object),
+        sessionId: readString(object, "order_id") ?? readString(object, "id"),
+        type: "payment.refunded"
+      };
+    }
+    case "subscription.active":
+    case "subscription.canceled":
+    case "subscription.created":
+    case "subscription.revoked":
+    case "subscription.updated": {
+      const type = eventType === "subscription.revoked" ? "subscription.canceled" : subscriptionEventType(readString(object, "status"));
+      return {
+        ...base,
+        cancelAtPeriodEnd: readBoolean(object, "cancel_at_period_end"),
+        currentPeriodEnd: parseTimestamp(readString(object, "current_period_end")),
+        currentPeriodStart: parseTimestamp(readString(object, "current_period_start")),
+        customerId: readString(object, "customer_id"),
+        priceId: readString(object, "product_id"),
+        referenceId: referenceFromMetadata(object),
+        subscriptionId: readString(object, "id"),
+        type
+      };
+    }
+    default: {
+      return { ...base, type: "unhandled" };
+    }
+  }
+};
+const createPolarAdapter = (options) => {
+  const { client, webhookSecret } = options;
+  return {
+    cancelPayment: () => notSupported("manual payment cancellation"),
+    cancelSubscription: async (subscriptionId, cancelOptions) => {
+      const subscription = cancelOptions?.atPeriodEnd ? await client.subscriptions.update({ id: subscriptionId, subscriptionUpdate: { cancelAtPeriodEnd: true } }) : await client.subscriptions.revoke({ id: subscriptionId });
+      return subscriptionFromPolar(subscription);
+    },
+    capabilities: { merchantOfRecord: true, portal: true, usageMetering: true },
+    capturePayment: (_input) => notSupported("manual capture"),
+    createCheckout: async (input) => {
+      const checkout = await client.checkouts.create({
+        customerEmail: void 0,
+        // Pin the framework-controlled `referenceId` LAST so caller metadata can never override it.
+        metadata: { ...input.metadata, referenceId: input.referenceId },
+        products: [input.priceId],
+        successUrl: input.successUrl
+      });
+      return { id: checkout.id, provider: "polar", url: checkout.url };
+    },
+    createPortalSession: async (input) => {
+      const session = await client.customerSessions.create({ customerId: input.customerId });
+      return { url: session.customerPortalUrl };
+    },
+    getOrCreateCustomer: async (ref) => {
+      const customer = await client.customers.create({
+        email: ref.email,
+        externalId: ref.referenceId,
+        metadata: { ...ref.metadata, referenceId: ref.referenceId }
+      });
+      return { createdAt: Date.now(), email: customer.email ?? void 0, id: customer.id, provider: "polar", referenceId: ref.referenceId };
+    },
+    getPaymentStatus: async (sessionId) => orderToSession(await client.orders.get({ id: sessionId })),
+    getSubscriptionStatus: async (subscriptionId) => subscriptionFromPolar(await client.subscriptions.get({ id: subscriptionId })),
+    identifier: "polar",
+    parseWebhook: async ({ headers, payload }) => {
+      const webhookId = headers.get("webhook-id") ?? "";
+      await verifyStandardWebhook({
+        payload,
+        secret: webhookSecret,
+        toleranceSeconds: options.webhookToleranceSeconds,
+        webhookId,
+        webhookSignature: headers.get("webhook-signature") ?? "",
+        webhookTimestamp: headers.get("webhook-timestamp") ?? ""
+      });
+      const event = asRecord(JSON.parse(payload));
+      return mapEvent(webhookId, readString(event, "type") ?? "", asRecord(event.data));
+    },
+    refundPayment: async (input) => {
+      await client.refunds.create({
+        amount: input.amount ? Number(input.amount.minorUnits) : void 0,
+        orderId: input.sessionId,
+        reason: input.reason ?? "customer_request"
+      });
+      const refundedAmount = input.amount ?? money(0, "usd");
+      return {
+        amount: refundedAmount,
+        capturedAmount: refundedAmount,
+        createdAt: Date.now(),
+        id: input.sessionId,
+        provider: "polar",
+        referenceId: "",
+        refundedAmount,
+        state: "refunded",
+        updatedAt: Date.now()
+      };
+    },
+    reportUsage: async (input) => {
+      await client.events.ingest({
+        events: [
+          {
+            externalCustomerId: input.referenceId,
+            metadata: { value: input.quantity },
+            name: input.featureId,
+            timestamp: input.timestamp === void 0 ? void 0 : new Date(input.timestamp).toISOString()
+          }
+        ]
+      });
+    },
+    resumeSubscription: async (subscriptionId) => {
+      const subscription = await client.subscriptions.update({ id: subscriptionId, subscriptionUpdate: { cancelAtPeriodEnd: false } });
+      return subscriptionFromPolar(subscription);
+    },
+    updateSubscription: async (subscriptionId, patch) => {
+      const subscription = await client.subscriptions.update({
+        id: subscriptionId,
+        subscriptionUpdate: patch.priceId ? { productId: patch.priceId } : {}
+      });
+      return subscriptionFromPolar(subscription);
+    }
+  };
+};
+
+export { createPolarAdapter };

package/dist/packem_shared/createStripeAdapter-D40MVBXg.mjs

@@ -0,0 +1,270 @@
+import idempotencyKey from './idempotencyKey-BFzDCA7g.mjs';
+import { a as asRecord, r as readString, c as readNumber, b as readBoolean } from './json-Db337f36.mjs';
+import { compareMoney, money, zeroMoney } from './addMoney-bCcs1nyw.mjs';
+import { verifyStripeSignature } from './constantTimeEqual-CfY0jYcL.mjs';
+
+const PAYMENT_STATE_BY_STRIPE_STATUS = {
+  canceled: "canceled",
+  processing: "authorized",
+  requires_action: "authorized",
+  requires_capture: "authorized",
+  requires_confirmation: "initiated",
+  requires_payment_method: "initiated",
+  succeeded: "captured"
+};
+const SUBSCRIPTION_STATE_BY_STRIPE_STATUS = {
+  active: "active",
+  canceled: "canceled",
+  incomplete: "trialing",
+  incomplete_expired: "canceled",
+  past_due: "past_due",
+  paused: "paused",
+  trialing: "trialing",
+  unpaid: "past_due"
+};
+const readReferenceId = (object) => readString(asRecord(object.metadata), "referenceId") ?? readString(object, "client_reference_id");
+const firstItem = (object) => {
+  const items = asRecord(object.items);
+  const data = Array.isArray(items.data) ? items.data : [];
+  return asRecord(data[0]);
+};
+const firstPriceId = (object) => readString(asRecord(firstItem(object).price), "id");
+const firstQuantity = (object) => readNumber(firstItem(object), "quantity");
+const periodEndMs = (object) => {
+  const seconds = readNumber(object, "current_period_end");
+  return seconds === void 0 ? void 0 : seconds * 1e3;
+};
+const periodStartMs = (object) => {
+  const seconds = readNumber(object, "current_period_start");
+  return seconds === void 0 ? void 0 : seconds * 1e3;
+};
+const intentToSession = (intent) => {
+  const amount = money(BigInt(intent.amount), intent.currency);
+  const state = PAYMENT_STATE_BY_STRIPE_STATUS[intent.status] ?? "initiated";
+  const now = Date.now();
+  return {
+    amount,
+    capturedAmount: state === "captured" ? money(BigInt(intent.amount_received ?? intent.amount), intent.currency) : zeroMoney(intent.currency),
+    createdAt: now,
+    id: intent.id,
+    provider: "stripe",
+    referenceId: intent.metadata?.referenceId ?? "",
+    refundedAmount: zeroMoney(intent.currency),
+    state,
+    updatedAt: now
+  };
+};
+const subscriptionFromStripe = (subscription) => {
+  const now = Date.now();
+  return {
+    cancelAtPeriodEnd: subscription.cancel_at_period_end ?? false,
+    createdAt: now,
+    currentPeriodEnd: subscription.current_period_end ? subscription.current_period_end * 1e3 : void 0,
+    currentPeriodStart: subscription.current_period_start ? subscription.current_period_start * 1e3 : void 0,
+    id: subscription.id,
+    priceId: subscription.items?.data[0]?.price?.id ?? "",
+    provider: "stripe",
+    quantity: subscription.items?.data[0]?.quantity ?? 1,
+    referenceId: subscription.metadata?.referenceId ?? "",
+    state: SUBSCRIPTION_STATE_BY_STRIPE_STATUS[subscription.status] ?? "active",
+    updatedAt: now
+  };
+};
+const subscriptionEventType = (status) => {
+  const state = status ? SUBSCRIPTION_STATE_BY_STRIPE_STATUS[status] : void 0;
+  if (state === "canceled") {
+    return "subscription.canceled";
+  }
+  if (state === "past_due") {
+    return "subscription.past_due";
+  }
+  if (state === "paused") {
+    return "subscription.paused";
+  }
+  if (state === "active" || state === "trialing") {
+    return "subscription.active";
+  }
+  return "subscription.updated";
+};
+const mapEvent = (eventId, eventType, object) => {
+  const base = { eventId, provider: "stripe", raw: { object, type: eventType } };
+  const currency = readString(object, "currency") ?? "usd";
+  switch (eventType) {
+    case "charge.refunded": {
+      return {
+        ...base,
+        amount: money(BigInt(readNumber(object, "amount_refunded") ?? 0), currency),
+        amountKind: "absolute",
+        referenceId: readReferenceId(object),
+        sessionId: readString(object, "payment_intent") ?? readString(object, "id"),
+        type: "payment.refunded"
+      };
+    }
+    case "checkout.session.completed": {
+      if (readString(object, "mode") === "subscription") {
+        return {
+          ...base,
+          customerId: readString(object, "customer"),
+          referenceId: readReferenceId(object),
+          subscriptionId: readString(object, "subscription"),
+          type: "subscription.active"
+        };
+      }
+      const amountTotal = readNumber(object, "amount_total");
+      return {
+        ...base,
+        amount: amountTotal === void 0 ? void 0 : money(BigInt(amountTotal), currency),
+        customerId: readString(object, "customer"),
+        referenceId: readReferenceId(object),
+        sessionId: readString(object, "payment_intent") ?? readString(object, "id"),
+        type: "payment.captured"
+      };
+    }
+    case "customer.subscription.created":
+    case "customer.subscription.updated": {
+      return {
+        ...base,
+        cancelAtPeriodEnd: readBoolean(object, "cancel_at_period_end"),
+        currentPeriodEnd: periodEndMs(object),
+        currentPeriodStart: periodStartMs(object),
+        customerId: readString(object, "customer"),
+        priceId: firstPriceId(object),
+        quantity: firstQuantity(object),
+        referenceId: readReferenceId(object),
+        subscriptionId: readString(object, "id"),
+        type: subscriptionEventType(readString(object, "status"))
+      };
+    }
+    case "customer.subscription.deleted": {
+      return { ...base, referenceId: readReferenceId(object), subscriptionId: readString(object, "id"), type: "subscription.canceled" };
+    }
+    case "payment_intent.amount_capturable_updated": {
+      return {
+        ...base,
+        amount: money(BigInt(readNumber(object, "amount") ?? 0), currency),
+        referenceId: readReferenceId(object),
+        sessionId: readString(object, "id"),
+        type: "payment.authorized"
+      };
+    }
+    case "payment_intent.payment_failed": {
+      return { ...base, referenceId: readReferenceId(object), sessionId: readString(object, "id"), type: "payment.failed" };
+    }
+    case "payment_intent.succeeded": {
+      return {
+        ...base,
+        amount: money(BigInt(readNumber(object, "amount_received") ?? readNumber(object, "amount") ?? 0), currency),
+        customerId: readString(object, "customer"),
+        referenceId: readReferenceId(object),
+        sessionId: readString(object, "id"),
+        type: "payment.captured"
+      };
+    }
+    default: {
+      return { ...base, type: "unhandled" };
+    }
+  }
+};
+const createStripeAdapter = (options) => {
+  const { client, webhookSecret } = options;
+  return {
+    cancelPayment: async (sessionId, paymentOptions) => {
+      const intent = await client.paymentIntents.cancel(sessionId, void 0, { idempotencyKey: paymentOptions?.idempotencyKey });
+      return intentToSession(intent);
+    },
+    cancelSubscription: async (subscriptionId, cancelOptions) => {
+      const subscription = cancelOptions?.atPeriodEnd ? await client.subscriptions.update(subscriptionId, { cancel_at_period_end: true }, { idempotencyKey: cancelOptions.idempotencyKey }) : await client.subscriptions.cancel(subscriptionId, void 0, { idempotencyKey: cancelOptions?.idempotencyKey });
+      return subscriptionFromStripe(subscription);
+    },
+    capabilities: { merchantOfRecord: false, portal: true, usageMetering: true },
+    capturePayment: async (input) => {
+      const intent = await client.paymentIntents.capture(
+        input.sessionId,
+        input.amount ? { amount_to_capture: Number(input.amount.minorUnits) } : void 0,
+        { idempotencyKey: input.idempotencyKey }
+      );
+      return intentToSession(intent);
+    },
+    createCheckout: async (input) => {
+      const session = await client.checkout.sessions.create(
+        {
+          cancel_url: input.cancelUrl,
+          client_reference_id: input.referenceId,
+          customer: input.customerId,
+          line_items: [{ price: input.priceId, quantity: input.quantity ?? 1 }],
+          // Pin the framework-controlled `referenceId` LAST so caller metadata can never override it.
+          metadata: { ...input.metadata, referenceId: input.referenceId },
+          mode: input.mode,
+          subscription_data: input.mode === "subscription" ? { metadata: { referenceId: input.referenceId } } : void 0,
+          success_url: input.successUrl
+        },
+        { idempotencyKey: input.idempotencyKey }
+      );
+      return { id: session.id, provider: "stripe", url: session.url ?? "" };
+    },
+    createPortalSession: async (input) => {
+      const session = await client.billingPortal.sessions.create({ customer: input.customerId, return_url: input.returnUrl });
+      return { url: session.url };
+    },
+    getOrCreateCustomer: async (ref) => {
+      const customer = await client.customers.create(
+        { email: ref.email, metadata: { ...ref.metadata, referenceId: ref.referenceId } },
+        { idempotencyKey: idempotencyKey("customer", "stripe", ref.referenceId) }
+      );
+      return { createdAt: Date.now(), email: customer.email ?? void 0, id: customer.id, provider: "stripe", referenceId: ref.referenceId };
+    },
+    getPaymentStatus: async (sessionId) => intentToSession(await client.paymentIntents.retrieve(sessionId)),
+    getSubscriptionStatus: async (subscriptionId) => subscriptionFromStripe(await client.subscriptions.retrieve(subscriptionId)),
+    identifier: "stripe",
+    parseWebhook: async ({ headers, payload }) => {
+      const signatureHeader = headers.get("stripe-signature") ?? "";
+      await verifyStripeSignature({ payload, secret: webhookSecret, signatureHeader, toleranceSeconds: options.webhookToleranceSeconds });
+      const event = asRecord(JSON.parse(payload));
+      const object = asRecord(asRecord(event.data).object);
+      return mapEvent(readString(event, "id") ?? "", readString(event, "type") ?? "", object);
+    },
+    refundPayment: async (input) => {
+      await client.refunds.create(
+        {
+          amount: input.amount ? Number(input.amount.minorUnits) : void 0,
+          payment_intent: input.sessionId,
+          reason: input.reason
+        },
+        { idempotencyKey: input.idempotencyKey }
+      );
+      const intent = await client.paymentIntents.retrieve(input.sessionId);
+      const session = intentToSession(intent);
+      const refundedAmount = input.amount ?? session.capturedAmount;
+      const partial = input.amount !== void 0 && compareMoney(input.amount, session.capturedAmount) < 0;
+      return { ...session, refundedAmount, state: partial ? "partially_refunded" : "refunded" };
+    },
+    reportUsage: async (input) => {
+      await client.billing.meterEvents.create(
+        {
+          event_name: input.featureId,
+          identifier: input.idempotencyKey,
+          payload: { stripe_customer_id: input.customerId, value: String(input.quantity) },
+          timestamp: input.timestamp === void 0 ? void 0 : Math.floor(input.timestamp / 1e3)
+        },
+        { idempotencyKey: input.idempotencyKey }
+      );
+    },
+    resumeSubscription: async (subscriptionId) => {
+      const subscription = await client.subscriptions.update(subscriptionId, { cancel_at_period_end: false });
+      return subscriptionFromStripe(subscription);
+    },
+    updateSubscription: async (subscriptionId, patch) => {
+      const parameters = {};
+      if (patch.quantity !== void 0) {
+        parameters.quantity = patch.quantity;
+      }
+      if (patch.priceId) {
+        parameters.items = [{ price: patch.priceId }];
+      }
+      const subscription = await client.subscriptions.update(subscriptionId, parameters);
+      return subscriptionFromStripe(subscription);
+    }
+  };
+};
+
+export { createStripeAdapter };