@lunora/payment 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/providers/dodopayments.mjs

@@ -0,0 +1,259 @@
+import { LunoraPaymentError } from '../packem_shared/LunoraPaymentError-BeQlhkZj.mjs';
+import { idempotencyKey } from '../packem_shared/idempotencyKey-BzaHGdHD.mjs';
+import { a as asRecord, b as readNumber, r as readString, f as referenceFromMetadata, p as parseTimestamp, e as readBoolean } from '../packem_shared/json-D0Cb5aMv.mjs';
+import { money, zeroMoney } from '../packem_shared/addMoney-jSh_7TfF.mjs';
+import { verifyStandardWebhook } from '../packem_shared/constantTimeEqual-BQjoW85H.mjs';
+import { m as makeNotSupported } from '../packem_shared/not-supported-C0onRyia.mjs';
+import { s as stateToEventType } from '../packem_shared/subscription-event-CwEsWRCK.mjs';
+
+const PAYMENT_STATE_BY_DODO_STATUS = {
+  cancelled: "canceled",
+  failed: "failed",
+  partially_captured: "captured",
+  partially_captured_and_capturable: "captured",
+  processing: "initiated",
+  requires_capture: "authorized",
+  requires_confirmation: "initiated",
+  requires_customer_action: "authorized",
+  requires_merchant_action: "authorized",
+  requires_payment_method: "initiated",
+  succeeded: "captured"
+};
+const SUBSCRIPTION_STATE_BY_DODO_STATUS = {
+  active: "active",
+  cancelled: "canceled",
+  expired: "canceled",
+  // SECURITY: `pending` (first payment not completed), `failed`, and `on_hold` (dunning) must not
+  // map to an entitling state — see the equivalent `incomplete` note in the Stripe/Polar adapters.
+  // Treat them as non-entitling `past_due`; Dodo has no trial status in this enum.
+  failed: "past_due",
+  on_hold: "past_due",
+  // A paused subscription is non-entitling until it resumes, but distinct from dunning — it maps to
+  // the `paused` state so a `subscription.paused` webhook routes to `subscription.paused` (not the
+  // generic `subscription.updated`) and stays consistent with `subscriptionFromDodo`.
+  paused: "paused",
+  pending: "past_due"
+};
+const notSupported = makeNotSupported("dodopayments (merchant-of-record)");
+const customerIdOf = (object) => readString(asRecord(object.customer), "customer_id") ?? readString(object, "customer_id");
+const subscriptionFromDodo = (input) => {
+  const subscription = asRecord(input);
+  const now = Date.now();
+  const status = readString(subscription, "status") ?? "";
+  return {
+    cancelAtPeriodEnd: readBoolean(subscription, "cancel_at_next_billing_date") ?? false,
+    createdAt: now,
+    currentPeriodEnd: parseTimestamp(readString(subscription, "next_billing_date")),
+    currentPeriodStart: parseTimestamp(readString(subscription, "previous_billing_date")),
+    id: readString(subscription, "subscription_id") ?? "",
+    priceId: readString(subscription, "product_id") ?? "",
+    provider: "dodopayments",
+    quantity: readNumber(subscription, "quantity") ?? 1,
+    referenceId: referenceFromMetadata(subscription) ?? customerIdOf(subscription) ?? "",
+    // Fail closed: an unrecognized Dodo status is treated as non-entitling `past_due`.
+    state: SUBSCRIPTION_STATE_BY_DODO_STATUS[status] ?? "past_due",
+    updatedAt: now
+  };
+};
+const paymentFromDodo = (input) => {
+  const payment = asRecord(input);
+  const now = Date.now();
+  const currency = readString(payment, "currency") ?? "usd";
+  const amount = money(BigInt(Math.round(readNumber(payment, "total_amount") ?? 0)), currency);
+  const state = PAYMENT_STATE_BY_DODO_STATUS[readString(payment, "status") ?? ""] ?? "initiated";
+  return {
+    amount,
+    capturedAmount: state === "captured" ? amount : zeroMoney(currency),
+    createdAt: now,
+    id: readString(payment, "payment_id") ?? "",
+    provider: "dodopayments",
+    referenceId: referenceFromMetadata(payment) ?? "",
+    refundedAmount: zeroMoney(currency),
+    state,
+    updatedAt: now
+  };
+};
+const mapEvent = (eventId, eventType, object) => {
+  const base = { eventId, provider: "dodopayments", raw: { object, type: eventType } };
+  const currency = readString(object, "currency") ?? "usd";
+  switch (eventType) {
+    // A lost chargeback (`dispute.lost`) is a definitive funds reversal carrying `amount` +
+    // `payment_id` — economically a refund, so it shares the refund mapping (record it so a customer
+    // who charges back doesn't stay entitled). Provisional dispute stages move no money and stay
+    // `unhandled`; a won dispute needs no transition.
+    case "dispute.lost":
+    case "refund.succeeded": {
+      return {
+        ...base,
+        amount: money(BigInt(Math.round(readNumber(object, "amount") ?? 0)), currency),
+        referenceId: referenceFromMetadata(object),
+        sessionId: readString(object, "payment_id"),
+        type: "payment.refunded"
+      };
+    }
+    // A cancelled payment never settled — record it as a non-entitling failure (there is no
+    // dedicated `payment.canceled` action; `failed` is the closest terminal, non-entitling state).
+    case "payment.cancelled":
+    case "payment.failed": {
+      return { ...base, referenceId: referenceFromMetadata(object), sessionId: readString(object, "payment_id"), type: "payment.failed" };
+    }
+    case "payment.succeeded": {
+      return {
+        ...base,
+        amount: money(BigInt(Math.round(readNumber(object, "total_amount") ?? 0)), currency),
+        customerId: customerIdOf(object),
+        referenceId: referenceFromMetadata(object),
+        sessionId: readString(object, "payment_id"),
+        subscriptionId: readString(object, "subscription_id"),
+        type: "payment.captured"
+      };
+    }
+    case "subscription.active":
+    case "subscription.cancelled":
+    case "subscription.expired":
+    case "subscription.failed":
+    case "subscription.on_hold":
+    case "subscription.paused":
+    case "subscription.plan_changed":
+    case "subscription.renewed":
+    case "subscription.updated": {
+      const status = readString(object, "status");
+      return {
+        ...base,
+        cancelAtPeriodEnd: readBoolean(object, "cancel_at_next_billing_date"),
+        currentPeriodEnd: parseTimestamp(readString(object, "next_billing_date")),
+        currentPeriodStart: parseTimestamp(readString(object, "previous_billing_date")),
+        customerId: customerIdOf(object),
+        priceId: readString(object, "product_id"),
+        quantity: readNumber(object, "quantity"),
+        referenceId: referenceFromMetadata(object) ?? customerIdOf(object),
+        subscriptionId: readString(object, "subscription_id"),
+        type: stateToEventType(SUBSCRIPTION_STATE_BY_DODO_STATUS[status ?? ""])
+      };
+    }
+    default: {
+      return { ...base, type: "unhandled" };
+    }
+  }
+};
+const createDodoPaymentsAdapter = (options) => {
+  const { webhookSecret } = options;
+  const client = options.client;
+  return {
+    // Dodo is a Merchant-of-Record: it moves the money, so there is no manual payment-intent
+    // authorize/capture/cancel. Refunds, however, are supported below.
+    cancelPayment: () => notSupported("manual payment cancellation"),
+    cancelSubscription: async (subscriptionId, cancelOptions) => {
+      const body = cancelOptions?.atPeriodEnd ? { cancel_at_next_billing_date: true } : { status: "cancelled" };
+      return subscriptionFromDodo(await client.subscriptions.update(subscriptionId, body));
+    },
+    capabilities: { merchantOfRecord: true, portal: true, usageMetering: true },
+    capturePayment: (_input) => notSupported("manual capture"),
+    createCheckout: async (input) => {
+      const session = asRecord(
+        await client.checkoutSessions.create({
+          // An existing Dodo customer is attached by id; otherwise Dodo collects one at checkout.
+          customer: input.customerId ? { customer_id: input.customerId } : void 0,
+          // Pin the framework-controlled `referenceId` LAST so caller metadata can never override it.
+          metadata: { ...input.metadata, referenceId: input.referenceId },
+          product_cart: [{ product_id: input.priceId, quantity: input.quantity ?? 1 }],
+          return_url: input.successUrl
+        })
+      );
+      return { id: readString(session, "session_id") ?? "", provider: "dodopayments", url: readString(session, "checkout_url") ?? "" };
+    },
+    createPortalSession: async (input) => {
+      const session = asRecord(await client.customers.customerPortal.create(input.customerId, { return_url: input.returnUrl }));
+      return { url: readString(session, "link") ?? readString(session, "url") ?? "" };
+    },
+    getOrCreateCustomer: async (ref) => {
+      const customer = asRecord(
+        await client.customers.create(
+          { email: ref.email ?? "", name: ref.metadata?.name ?? ref.referenceId },
+          { idempotencyKey: idempotencyKey("customer", "dodopayments", ref.referenceId) }
+        )
+      );
+      return {
+        createdAt: Date.now(),
+        email: readString(customer, "email") ?? ref.email,
+        id: readString(customer, "customer_id") ?? "",
+        provider: "dodopayments",
+        referenceId: ref.referenceId
+      };
+    },
+    getPaymentStatus: async (sessionId) => paymentFromDodo(await client.payments.retrieve(sessionId)),
+    getSubscriptionStatus: async (subscriptionId) => subscriptionFromDodo(await client.subscriptions.retrieve(subscriptionId)),
+    identifier: "dodopayments",
+    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) => {
+      if (input.amount !== void 0) {
+        throw new LunoraPaymentError(
+          "PROVIDER_ERROR",
+          "dodopayments refunds a payment in full; partial refunds require line items and aren't supported here"
+        );
+      }
+      const refund = asRecord(await client.refunds.create({ payment_id: input.sessionId, reason: input.reason }));
+      const currency = readString(refund, "currency") ?? "usd";
+      const refundedAmount = money(BigInt(Math.round(readNumber(refund, "amount") ?? 0)), currency);
+      let state = "captured";
+      if (readString(refund, "status") === "succeeded") {
+        state = "refunded";
+      }
+      return {
+        amount: refundedAmount,
+        capturedAmount: refundedAmount,
+        createdAt: Date.now(),
+        id: input.sessionId,
+        provider: "dodopayments",
+        referenceId: "",
+        refundedAmount,
+        state,
+        updatedAt: Date.now()
+      };
+    },
+    reportUsage: async (input) => {
+      await client.usageEvents.ingest({
+        events: [
+          {
+            customer_id: input.customerId ?? input.referenceId,
+            event_id: input.idempotencyKey,
+            event_name: input.featureId,
+            metadata: { value: input.quantity },
+            timestamp: input.timestamp === void 0 ? void 0 : new Date(input.timestamp).toISOString()
+          }
+        ]
+      });
+    },
+    resumeSubscription: async (subscriptionId) => {
+      const subscription = await client.subscriptions.update(subscriptionId, { cancel_at_next_billing_date: false });
+      return subscriptionFromDodo(subscription);
+    },
+    updateSubscription: async (subscriptionId, patch) => {
+      if (patch.priceId !== void 0 || patch.quantity !== void 0) {
+        const current = asRecord(
+          patch.priceId !== void 0 && patch.quantity !== void 0 ? void 0 : await client.subscriptions.retrieve(subscriptionId)
+        );
+        await client.subscriptions.changePlan(subscriptionId, {
+          product_id: patch.priceId ?? readString(current, "product_id") ?? "",
+          proration_billing_mode: "prorated_immediately",
+          quantity: patch.quantity ?? readNumber(current, "quantity") ?? 1
+        });
+      }
+      return subscriptionFromDodo(await client.subscriptions.retrieve(subscriptionId));
+    }
+  };
+};
+
+export { createDodoPaymentsAdapter };

package/dist/providers/polar.d.mts

@@ -0,0 +1,31 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-CMjjkTGB.mjs";
+/**
+ * The `@polar-sh/sdk` surface the adapter uses, as a structural type — a real `Polar` instance
+ * satisfies it without a cast. Resources are `unknown` (the adapter re-types the client as the real
+ * `Polar` internally); this keeps the SDK's full type out of the published declarations.
+ * @experimental
+ */
+interface PolarClientLike {
+  readonly checkouts: unknown;
+  readonly customers: unknown;
+  readonly customerSessions: unknown;
+  readonly events: unknown;
+  readonly orders: unknown;
+  readonly refunds: unknown;
+  readonly subscriptions: unknown;
+}
+/**
+ * `PolarAdapterOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface PolarAdapterOptions {
+  readonly client: PolarClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+/**
+ * `createPolarAdapter` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+declare const createPolarAdapter: (options: PolarAdapterOptions) => PaymentAdapter;
+export { type PolarAdapterOptions, type PolarClientLike, createPolarAdapter };

package/dist/providers/polar.d.ts

@@ -0,0 +1,31 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-CMjjkTGB.js";
+/**
+ * The `@polar-sh/sdk` surface the adapter uses, as a structural type — a real `Polar` instance
+ * satisfies it without a cast. Resources are `unknown` (the adapter re-types the client as the real
+ * `Polar` internally); this keeps the SDK's full type out of the published declarations.
+ * @experimental
+ */
+interface PolarClientLike {
+  readonly checkouts: unknown;
+  readonly customers: unknown;
+  readonly customerSessions: unknown;
+  readonly events: unknown;
+  readonly orders: unknown;
+  readonly refunds: unknown;
+  readonly subscriptions: unknown;
+}
+/**
+ * `PolarAdapterOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface PolarAdapterOptions {
+  readonly client: PolarClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+/**
+ * `createPolarAdapter` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+declare const createPolarAdapter: (options: PolarAdapterOptions) => PaymentAdapter;
+export { type PolarAdapterOptions, type PolarClientLike, createPolarAdapter };

package/dist/{packem_shared/createPolarAdapter-BJtVGSlF.mjs → providers/polar.mjs}

@@ -1,84 +1,83 @@
-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';
+import { a as asRecord, r as readString, f as referenceFromMetadata, e as readBoolean, p as parseTimestamp, b as readNumber } from '../packem_shared/json-D0Cb5aMv.mjs';
+import { money, zeroMoney } from '../packem_shared/addMoney-jSh_7TfF.mjs';
+import { verifyStandardWebhook } from '../packem_shared/constantTimeEqual-BQjoW85H.mjs';
+import { m as makeNotSupported } from '../packem_shared/not-supported-C0onRyia.mjs';
+import { s as stateToEventType } from '../packem_shared/subscription-event-CwEsWRCK.mjs';
 
+const toEpochMs = (value) => {
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  return parseTimestamp(typeof value === "string" ? value : void 0);
+};
 const PAYMENT_STATE_BY_POLAR_ORDER_STATUS = {
+  draft: "initiated",
   paid: "captured",
   partially_refunded: "partially_refunded",
   pending: "initiated",
-  refunded: "refunded"
+  refunded: "refunded",
+  void: "canceled"
 };
 const SUBSCRIPTION_STATE_BY_POLAR_STATUS = {
   active: "active",
   canceled: "canceled",
-  incomplete: "trialing",
+  // SECURITY: `incomplete` (first payment not completed) must not map to an
+  // entitling state — see the equivalent note in the Stripe adapter. Treat it as
+  // non-entitling `past_due`; reserve `trialing` for a genuine trial.
+  incomplete: "past_due",
   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 notSupported = makeNotSupported("polar (merchant-of-record)");
+const subscriptionFromPolar = (input) => {
+  const subscription = asRecord(input);
   const now = Date.now();
   return {
-    cancelAtPeriodEnd: subscription.cancelAtPeriodEnd ?? false,
+    cancelAtPeriodEnd: readBoolean(subscription, "cancelAtPeriodEnd") ?? false,
     createdAt: now,
-    currentPeriodEnd: parseTimestamp(subscription.currentPeriodEnd),
-    currentPeriodStart: parseTimestamp(subscription.currentPeriodStart),
-    id: subscription.id,
-    priceId: subscription.productId ?? "",
+    currentPeriodEnd: toEpochMs(subscription.currentPeriodEnd),
+    currentPeriodStart: toEpochMs(subscription.currentPeriodStart),
+    id: readString(subscription, "id") ?? "",
+    priceId: readString(subscription, "productId") ?? "",
     provider: "polar",
     quantity: 1,
-    referenceId: subscription.metadata?.referenceId ?? "",
-    state: SUBSCRIPTION_STATE_BY_POLAR_STATUS[subscription.status] ?? "active",
+    referenceId: referenceFromMetadata(subscription) ?? "",
+    state: SUBSCRIPTION_STATE_BY_POLAR_STATUS[readString(subscription, "status") ?? ""] ?? "active",
     updatedAt: now
   };
 };
-const orderToSession = (order) => {
+const orderToSession = (input) => {
+  const order = asRecord(input);
   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 currency = readString(order, "currency") ?? "usd";
+  const amount = money(BigInt(Math.round(readNumber(order, "totalAmount") ?? readNumber(order, "amount") ?? 0)), currency);
+  const state = PAYMENT_STATE_BY_POLAR_ORDER_STATUS[readString(order, "status") ?? ""] ?? "initiated";
   const settled = state === "captured" || state === "partially_refunded" || state === "refunded";
   return {
     amount,
     capturedAmount: settled ? amount : zeroMoney(currency),
     createdAt: now,
-    id: order.id,
+    id: readString(order, "id") ?? "",
     provider: "polar",
-    referenceId: "",
+    // Polar copies checkout metadata onto the order, so recover the framework-pinned `referenceId`
+    // rather than blanking it — a reconcile sweep would otherwise orphan the row from `by_reference`.
+    referenceId: referenceFromMetadata(order) ?? "",
     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": {
+      if (eventType === "order.created" && PAYMENT_STATE_BY_POLAR_ORDER_STATUS[readString(object, "status") ?? ""] !== "captured") {
+        return { ...base, type: "unhandled" };
+      }
       return {
         ...base,
         amount: money(BigInt(readNumber(object, "total_amount") ?? readNumber(object, "amount") ?? 0), currency),
@@ -102,8 +101,9 @@ const mapEvent = (eventId, eventType, object) => {
     case "subscription.canceled":
     case "subscription.created":
     case "subscription.revoked":
+    case "subscription.uncanceled":
     case "subscription.updated": {
-      const type = eventType === "subscription.revoked" ? "subscription.canceled" : subscriptionEventType(readString(object, "status"));
+      const type = eventType === "subscription.revoked" ? "subscription.canceled" : stateToEventType(SUBSCRIPTION_STATE_BY_POLAR_STATUS[readString(object, "status") ?? ""]);
       return {
         ...base,
         cancelAtPeriodEnd: readBoolean(object, "cancel_at_period_end"),
@@ -122,7 +122,8 @@ const mapEvent = (eventId, eventType, object) => {
   }
 };
 const createPolarAdapter = (options) => {
-  const { client, webhookSecret } = options;
+  const { webhookSecret } = options;
+  const client = options.client;
   return {
     cancelPayment: () => notSupported("manual payment cancellation"),
     cancelSubscription: async (subscriptionId, cancelOptions) => {
@@ -133,10 +134,18 @@ const createPolarAdapter = (options) => {
     capturePayment: (_input) => notSupported("manual capture"),
     createCheckout: async (input) => {
       const checkout = await client.checkouts.create({
-        customerEmail: void 0,
+        // Bind the checkout to the customer the facade already reused/minted for this reference,
+        // else Polar mints a SECOND orphan customer at completion (leaving the stored customer
+        // with no subscription — its portal empty, its metered usage misrouted). `externalCustomerId`
+        // carries our reference for the direct-adapter path; `customerEmail` pre-fills when neither is known.
+        customerEmail: input.customerId ? void 0 : input.email,
+        customerId: input.customerId,
+        externalCustomerId: input.referenceId,
         // Pin the framework-controlled `referenceId` LAST so caller metadata can never override it.
         metadata: { ...input.metadata, referenceId: input.referenceId },
         products: [input.priceId],
+        // Polar shows a back button to this URL; map the caller's cancel URL onto it.
+        returnUrl: input.cancelUrl,
         successUrl: input.successUrl
       });
       return { id: checkout.id, provider: "polar", url: checkout.url };
@@ -147,9 +156,10 @@ const createPolarAdapter = (options) => {
     },
     getOrCreateCustomer: async (ref) => {
       const customer = await client.customers.create({
-        email: ref.email,
+        email: ref.email ?? "",
         externalId: ref.referenceId,
-        metadata: { ...ref.metadata, referenceId: ref.referenceId }
+        metadata: { ...ref.metadata, referenceId: ref.referenceId },
+        type: "individual"
       });
       return { createdAt: Date.now(), email: customer.email ?? void 0, id: customer.id, provider: "polar", referenceId: ref.referenceId };
     },
@@ -170,12 +180,16 @@ const createPolarAdapter = (options) => {
       return mapEvent(webhookId, readString(event, "type") ?? "", asRecord(event.data));
     },
     refundPayment: async (input) => {
+      const order = input.amount ? void 0 : await client.orders.get({ id: input.sessionId });
+      const currency = input.amount?.currency ?? order?.currency ?? "usd";
+      const amountMinor = input.amount ? Number(input.amount.minorUnits) : order?.totalAmount ?? 0;
       await client.refunds.create({
-        amount: input.amount ? Number(input.amount.minorUnits) : void 0,
+        amount: amountMinor,
         orderId: input.sessionId,
+        // `reason` is an open enum; a caller-supplied string is cast onto it (defaults to customer_request).
         reason: input.reason ?? "customer_request"
       });
-      const refundedAmount = input.amount ?? money(0, "usd");
+      const refundedAmount = input.amount ?? money(BigInt(Math.round(amountMinor)), currency);
       return {
         amount: refundedAmount,
         capturedAmount: refundedAmount,
@@ -195,7 +209,7 @@ const createPolarAdapter = (options) => {
             externalCustomerId: input.referenceId,
             metadata: { value: input.quantity },
             name: input.featureId,
-            timestamp: input.timestamp === void 0 ? void 0 : new Date(input.timestamp).toISOString()
+            timestamp: input.timestamp === void 0 ? void 0 : new Date(input.timestamp)
           }
         ]
       });

package/dist/providers/stripe.d.mts

@@ -0,0 +1,32 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-CMjjkTGB.mjs";
+/**
+ * The Stripe SDK surface the adapter uses, as a structural type — a real `Stripe` instance satisfies
+ * it without a cast. Resources are `unknown` here (the adapter re-types the client as the real
+ * `Stripe` internally); this keeps the SDK's full type out of the published declaration files.
+ * @experimental
+ */
+interface StripeClientLike {
+  readonly billing: unknown;
+  readonly billingPortal: unknown;
+  readonly checkout: unknown;
+  readonly customers: unknown;
+  readonly paymentIntents: unknown;
+  readonly refunds: unknown;
+  readonly subscriptions: unknown;
+  readonly webhooks: unknown;
+}
+/**
+ * `StripeAdapterOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface StripeAdapterOptions {
+  readonly client: StripeClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+/**
+ * `createStripeAdapter` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+declare const createStripeAdapter: (options: StripeAdapterOptions) => PaymentAdapter;
+export { type StripeAdapterOptions, type StripeClientLike, createStripeAdapter };

package/dist/providers/stripe.d.ts

@@ -0,0 +1,32 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-CMjjkTGB.js";
+/**
+ * The Stripe SDK surface the adapter uses, as a structural type — a real `Stripe` instance satisfies
+ * it without a cast. Resources are `unknown` here (the adapter re-types the client as the real
+ * `Stripe` internally); this keeps the SDK's full type out of the published declaration files.
+ * @experimental
+ */
+interface StripeClientLike {
+  readonly billing: unknown;
+  readonly billingPortal: unknown;
+  readonly checkout: unknown;
+  readonly customers: unknown;
+  readonly paymentIntents: unknown;
+  readonly refunds: unknown;
+  readonly subscriptions: unknown;
+  readonly webhooks: unknown;
+}
+/**
+ * `StripeAdapterOptions` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+interface StripeAdapterOptions {
+  readonly client: StripeClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+/**
+ * `createStripeAdapter` is part of the experimental `@lunora/payment` API and may change without a major version bump.
+ * @experimental
+ */
+declare const createStripeAdapter: (options: StripeAdapterOptions) => PaymentAdapter;
+export { type StripeAdapterOptions, type StripeClientLike, createStripeAdapter };