@lunora/payment 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/providers/autumn.mjs

@@ -0,0 +1,294 @@
+import { LunoraPaymentError } from '../packem_shared/LunoraPaymentError-BeQlhkZj.mjs';
+import { a as asRecord, c as readBoolean, r as readString, b as readNumber } from '../packem_shared/json-DhcPm8EO.mjs';
+import { money } from '../packem_shared/addMoney-jSh_7TfF.mjs';
+import { verifyStandardWebhook } from '../packem_shared/constantTimeEqual-BQjoW85H.mjs';
+import { s as stateToEventType } from '../packem_shared/subscription-event-CwEsWRCK.mjs';
+
+const SUBSCRIPTION_STATE_BY_AUTUMN_STATUS = {
+  active: "active",
+  canceled: "canceled",
+  expired: "canceled",
+  past_due: "past_due",
+  // A scheduled product has not started yet — non-entitling until it activates.
+  scheduled: "paused",
+  trialing: "trialing"
+};
+const SUBSCRIPTION_STATE_BY_AUTUMN_ACTION = {
+  activated: "active",
+  canceled: "canceled",
+  cancelled: "canceled",
+  expired: "canceled",
+  scheduled: "paused"
+};
+const SUBSCRIPTION_ID_SEPARATOR = "::";
+const notSupported = (operation) => {
+  throw new LunoraPaymentError("PROVIDER_ERROR", `autumn manages billing through the underlying processor and does not support ${operation}`);
+};
+const autumnSubscriptionId = (customerId, productId) => `${customerId}${SUBSCRIPTION_ID_SEPARATOR}${productId}`;
+const parseAutumnSubscriptionId = (subscriptionId) => {
+  const index = subscriptionId.lastIndexOf(SUBSCRIPTION_ID_SEPARATOR);
+  if (index === -1) {
+    throw new LunoraPaymentError("PROVIDER_ERROR", `malformed autumn subscription id "${subscriptionId}" (expected "<customerId>::<productId>")`);
+  }
+  return { customerId: subscriptionId.slice(0, index), productId: subscriptionId.slice(index + SUBSCRIPTION_ID_SEPARATOR.length) };
+};
+const readAny = (object, ...keys) => {
+  for (const key of keys) {
+    const value = readString(object, key);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+};
+const readAnyNumber = (object, ...keys) => {
+  for (const key of keys) {
+    const value = readNumber(object, key);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+};
+const isCanceling = (product) => readAnyNumber(product, "canceled_at", "canceledAt") !== void 0 || readAny(product, "status") === "scheduled";
+const productToSubscription = (customerId, product) => {
+  const now = Date.now();
+  const productId = readAny(product, "id", "product_id", "productId", "plan_id", "planId") ?? "";
+  const status = readAny(product, "status") ?? "active";
+  const pastDue = readBoolean(product, "past_due") ?? readBoolean(product, "pastDue") ?? false;
+  return {
+    cancelAtPeriodEnd: isCanceling(product),
+    createdAt: now,
+    currentPeriodEnd: readAnyNumber(product, "current_period_end", "currentPeriodEnd") ?? void 0,
+    currentPeriodStart: readAnyNumber(product, "current_period_start", "currentPeriodStart") ?? void 0,
+    id: autumnSubscriptionId(customerId, productId),
+    priceId: productId,
+    provider: "autumn",
+    quantity: readAnyNumber(product, "quantity") ?? 1,
+    referenceId: customerId,
+    // Fail closed: a past-due flag, or an unrecognized Autumn status, is non-entitling `past_due`.
+    state: pastDue ? "past_due" : SUBSCRIPTION_STATE_BY_AUTUMN_STATUS[status] ?? "past_due",
+    updatedAt: now
+  };
+};
+const asRecordList = (value) => Array.isArray(value) ? value.map((entry) => asRecord(entry)) : [];
+const findProduct = (customer, productId) => {
+  const rows = [...asRecordList(customer.products), ...asRecordList(customer.subscriptions)];
+  return rows.find((entry) => (readAny(entry, "id", "product_id", "productId", "plan_id", "planId") ?? "") === productId);
+};
+const balanceFields = (balance) => {
+  return {
+    balance: readAnyNumber(balance, "remaining", "balance"),
+    limit: readAnyNumber(balance, "granted", "included_usage", "limit"),
+    unlimited: readBoolean(balance, "unlimited") ?? false,
+    used: readAnyNumber(balance, "usage", "used")
+  };
+};
+const constructedSubscription = (customerId, productId, state, cancelAtPeriodEnd) => {
+  const now = Date.now();
+  return {
+    cancelAtPeriodEnd,
+    createdAt: now,
+    id: autumnSubscriptionId(customerId, productId),
+    priceId: productId,
+    provider: "autumn",
+    quantity: 1,
+    referenceId: customerId,
+    state,
+    updatedAt: now
+  };
+};
+const readSubscription = async (client, customerId, productId) => {
+  const customer = asRecord(await client.customers.get({ customerId }));
+  const product = findProduct(customer, productId);
+  return product ? productToSubscription(customerId, product) : constructedSubscription(customerId, productId, "canceled", false);
+};
+const referenceFromEvent = (object) => readAny(object, "customer_id", "customerId");
+const mapBillingUpdated = (eventId, object) => {
+  const base = { eventId, provider: "autumn", raw: { object, type: "billing.updated" } };
+  const customerId = referenceFromEvent(object);
+  const change = asRecordList(object.plan_changes)[0] ?? object;
+  const subscription = change.subscription ? asRecord(change.subscription) : change;
+  const planId = readAny(subscription, "plan_id", "planId", "product_id", "productId", "id");
+  const status = readAny(subscription, "status");
+  const action = readAny(change, "action");
+  const pastDue = readBoolean(subscription, "past_due") ?? readBoolean(subscription, "pastDue") ?? false;
+  const fromStatus = status === void 0 ? void 0 : SUBSCRIPTION_STATE_BY_AUTUMN_STATUS[status];
+  const fromAction = action === void 0 ? void 0 : SUBSCRIPTION_STATE_BY_AUTUMN_ACTION[action];
+  const state = pastDue ? "past_due" : fromStatus ?? fromAction;
+  return {
+    ...base,
+    cancelAtPeriodEnd: readBoolean(subscription, "cancel_at_period_end") ?? isCanceling(subscription),
+    currentPeriodEnd: readAnyNumber(subscription, "current_period_end", "currentPeriodEnd"),
+    currentPeriodStart: readAnyNumber(subscription, "current_period_start", "currentPeriodStart"),
+    customerId,
+    priceId: planId,
+    referenceId: customerId,
+    subscriptionId: customerId === void 0 || planId === void 0 ? void 0 : autumnSubscriptionId(customerId, planId),
+    type: stateToEventType(state)
+  };
+};
+const mapEvent = (eventId, eventType, object) => {
+  const base = { eventId, provider: "autumn", raw: { object, type: eventType } };
+  const currency = readAny(object, "currency") ?? "usd";
+  switch (eventType) {
+    // Auto-topup settles a real invoice — surface it as a captured payment.
+    case "billing.auto_topup_succeeded": {
+      const invoice = asRecord(object.invoice);
+      const amount = readAnyNumber(invoice, "total", "amount") ?? readAnyNumber(object, "total", "amount");
+      const invoiceCurrency = readAny(invoice, "currency") ?? currency;
+      return {
+        ...base,
+        amount: amount === void 0 ? void 0 : money(BigInt(Math.round(amount)), invoiceCurrency),
+        customerId: referenceFromEvent(object),
+        referenceId: referenceFromEvent(object),
+        sessionId: readAny(invoice, "id", "stripe_id", "invoice_id") ?? readAny(object, "id"),
+        type: "payment.captured"
+      };
+    }
+    case "billing.updated": {
+      return mapBillingUpdated(eventId, object);
+    }
+    // Product lifecycle — the entitling truth. `data` is the product row (or wraps it).
+    case "customer.product.added":
+    case "customer.product.canceled":
+    case "customer.product.expired":
+    case "customer.product.updated":
+    case "product.attached": {
+      const product = object.product ? asRecord(object.product) : object;
+      const status = eventType === "customer.product.canceled" || eventType === "customer.product.expired" ? "canceled" : readAny(product, "status");
+      const customerId = referenceFromEvent(object) ?? referenceFromEvent(product);
+      return {
+        ...base,
+        cancelAtPeriodEnd: readBoolean(product, "cancel_at_period_end") ?? isCanceling(product),
+        currentPeriodEnd: readAnyNumber(product, "current_period_end", "currentPeriodEnd"),
+        currentPeriodStart: readAnyNumber(product, "current_period_start", "currentPeriodStart"),
+        customerId,
+        priceId: readAny(product, "id", "product_id", "productId"),
+        referenceId: customerId,
+        subscriptionId: customerId === void 0 ? void 0 : autumnSubscriptionId(customerId, readAny(product, "id", "product_id", "productId") ?? ""),
+        type: stateToEventType(SUBSCRIPTION_STATE_BY_AUTUMN_STATUS[status ?? ""])
+      };
+    }
+    // Money movement — Autumn surfaces settled invoices/payments.
+    case "invoice.paid":
+    case "payment.succeeded": {
+      const amount = readAnyNumber(object, "total", "amount", "amount_paid");
+      return {
+        ...base,
+        // Autumn amounts are assumed integer minor units, but the event catalog is unverified —
+        // round defensively so a provider-sent decimal can't throw a RangeError out of
+        // `parseWebhook` (which would 400 the endpoint and wedge Autumn into infinite retries).
+        amount: amount === void 0 ? void 0 : money(BigInt(Math.round(amount)), currency),
+        customerId: referenceFromEvent(object),
+        referenceId: referenceFromEvent(object),
+        sessionId: readAny(object, "id", "invoice_id", "stripe_id"),
+        type: "payment.captured"
+      };
+    }
+    default: {
+      return { ...base, type: "unhandled" };
+    }
+  }
+};
+const checkoutUrlFrom = (result) => readAny(result, "checkout_url", "checkoutUrl", "payment_url", "paymentUrl", "url") ?? "";
+const createAutumnAdapter = (options) => {
+  const { webhookSecret } = options;
+  const client = options.client;
+  return {
+    // Autumn abstracts Stripe money movement; there is no payment intent to cancel/capture/refund.
+    cancelPayment: () => notSupported("manual payment cancellation"),
+    cancelSubscription: async (subscriptionId, cancelOptions) => {
+      const { customerId, productId } = parseAutumnSubscriptionId(subscriptionId);
+      await client.billing.update({
+        cancelAction: cancelOptions?.atPeriodEnd ? "cancel_end_of_cycle" : "cancel_immediately",
+        customerId,
+        planId: productId
+      });
+      if (cancelOptions?.atPeriodEnd) {
+        return { ...await readSubscription(client, customerId, productId), cancelAtPeriodEnd: true };
+      }
+      return constructedSubscription(customerId, productId, "canceled", false);
+    },
+    capabilities: { merchantOfRecord: false, portal: true, usageMetering: true },
+    capturePayment: (_input) => notSupported("manual capture"),
+    checkEntitlement: async (input) => {
+      if (input.featureId === void 0) {
+        const customer = asRecord(await client.customers.get({ customerId: input.referenceId }));
+        const product = findProduct(customer, input.priceId ?? "");
+        const state = product ? productToSubscription(input.referenceId, product).state : void 0;
+        return { allowed: state === "active" || state === "trialing", unlimited: false };
+      }
+      const result = asRecord(await client.check({ customerId: input.referenceId, featureId: input.featureId, requiredBalance: input.quantity ?? 1 }));
+      const allowed = readBoolean(result, "allowed") ?? false;
+      const rawBalance = result.balance;
+      const balance = typeof rawBalance === "object" && rawBalance !== null ? asRecord(rawBalance) : result;
+      return { allowed, ...balanceFields(balance) };
+    },
+    createCheckout: async (input) => {
+      const result = asRecord(await client.billing.attach({ customerId: input.referenceId, planId: input.priceId }));
+      return { id: autumnSubscriptionId(input.referenceId, input.priceId), provider: "autumn", url: checkoutUrlFrom(result) };
+    },
+    createPortalSession: async (input) => {
+      const result = asRecord(await client.billing.openCustomerPortal({ customerId: input.customerId }));
+      return { url: readAny(result, "url") ?? "" };
+    },
+    getBalances: async (referenceId) => {
+      const customer = asRecord(await client.customers.get({ customerId: referenceId }));
+      const balances = asRecord(customer.balances ?? customer.features);
+      return Object.entries(balances).map(([key, raw]) => {
+        const balance = asRecord(raw);
+        const fields = balanceFields(balance);
+        const allowed = fields.unlimited || (fields.balance ?? 0) > 0;
+        return { allowed, featureId: readAny(balance, "featureId", "feature_id") ?? key, ...fields };
+      });
+    },
+    getOrCreateCustomer: async (ref) => {
+      const customer = asRecord(await client.customers.getOrCreate({ customerId: ref.referenceId, email: ref.email, name: ref.metadata?.name }));
+      return {
+        createdAt: Date.now(),
+        email: readAny(customer, "email") ?? ref.email,
+        id: readAny(customer, "id") ?? ref.referenceId,
+        provider: "autumn",
+        referenceId: ref.referenceId
+      };
+    },
+    // Autumn is entitlement-centric; it exposes no standalone one-time payment-session lookup.
+    getPaymentStatus: () => notSupported("payment-session reconciliation"),
+    getSubscriptionStatus: async (subscriptionId) => {
+      const { customerId, productId } = parseAutumnSubscriptionId(subscriptionId);
+      return readSubscription(client, customerId, productId);
+    },
+    identifier: "autumn",
+    parseWebhook: async ({ headers, payload }) => {
+      const webhookId = headers.get("svix-id") ?? headers.get("webhook-id") ?? "";
+      await verifyStandardWebhook({
+        payload,
+        secret: webhookSecret,
+        toleranceSeconds: options.webhookToleranceSeconds,
+        webhookId,
+        webhookSignature: headers.get("svix-signature") ?? headers.get("webhook-signature") ?? "",
+        webhookTimestamp: headers.get("svix-timestamp") ?? headers.get("webhook-timestamp") ?? ""
+      });
+      const event = asRecord(JSON.parse(payload));
+      return mapEvent(webhookId, readString(event, "type") ?? "", asRecord(event.data));
+    },
+    refundPayment: () => notSupported("refunds"),
+    reportUsage: async (input) => {
+      await client.track({ customerId: input.referenceId, featureId: input.featureId, value: input.quantity });
+    },
+    resumeSubscription: async (subscriptionId) => {
+      const { customerId, productId } = parseAutumnSubscriptionId(subscriptionId);
+      await client.billing.update({ cancelAction: "uncancel", customerId, planId: productId });
+      return { ...await readSubscription(client, customerId, productId), cancelAtPeriodEnd: false };
+    },
+    updateSubscription: async (subscriptionId, patch) => {
+      const { customerId, productId } = parseAutumnSubscriptionId(subscriptionId);
+      const targetProduct = patch.priceId ?? productId;
+      await client.billing.attach({ customerId, planId: targetProduct });
+      return readSubscription(client, customerId, targetProduct);
+    }
+  };
+};
+
+export { createAutumnAdapter };

package/dist/providers/creem.d.mts

@@ -0,0 +1,17 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-iFA55DzU.mjs";
+/**
+* The `creem` SDK surface the adapter uses, as a structural type — a real `Creem` instance satisfies
+* it without a cast. Resources are `unknown` (the adapter re-types the client as the real `Creem`
+* internally); this keeps the SDK's full type out of the published declarations.
+*/
+interface CreemClientLike {
+  readonly checkouts: unknown;
+  readonly customers: unknown;
+  readonly subscriptions: unknown;
+}
+interface CreemAdapterOptions {
+  readonly client: CreemClientLike;
+  readonly webhookSecret: string;
+}
+declare const createCreemAdapter: (options: CreemAdapterOptions) => PaymentAdapter;
+export { type CreemAdapterOptions, type CreemClientLike, createCreemAdapter };

package/dist/providers/creem.d.ts

@@ -0,0 +1,17 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-iFA55DzU.js";
+/**
+* The `creem` SDK surface the adapter uses, as a structural type — a real `Creem` instance satisfies
+* it without a cast. Resources are `unknown` (the adapter re-types the client as the real `Creem`
+* internally); this keeps the SDK's full type out of the published declarations.
+*/
+interface CreemClientLike {
+  readonly checkouts: unknown;
+  readonly customers: unknown;
+  readonly subscriptions: unknown;
+}
+interface CreemAdapterOptions {
+  readonly client: CreemClientLike;
+  readonly webhookSecret: string;
+}
+declare const createCreemAdapter: (options: CreemAdapterOptions) => PaymentAdapter;
+export { type CreemAdapterOptions, type CreemClientLike, createCreemAdapter };

package/dist/providers/creem.mjs

@@ -0,0 +1,205 @@
+import { a as asRecord, r as readString, d as referenceFromMetadata, b as readNumber, p as parseTimestamp, c as readBoolean } from '../packem_shared/json-DhcPm8EO.mjs';
+import { money, zeroMoney } from '../packem_shared/addMoney-jSh_7TfF.mjs';
+import { verifyCreemSignature } 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_CREEM_STATUS = {
+  canceled: "canceled",
+  completed: "captured",
+  expired: "canceled",
+  paid: "captured",
+  partially_refunded: "partially_refunded",
+  pending: "initiated",
+  refunded: "refunded"
+};
+const SUBSCRIPTION_STATE_BY_CREEM_STATUS = {
+  active: "active",
+  canceled: "canceled",
+  cancelled: "canceled",
+  expired: "canceled",
+  // SECURITY: `incomplete`/`unpaid`/`past_due` (first or a renewal payment not settled) must not map
+  // to an entitling state — see the equivalent `incomplete` note in the Stripe/Polar adapters. A
+  // `scheduled_cancel` subscription is still active until period end, so it entitles (the pending
+  // cancellation surfaces via `cancelAtPeriodEnd`).
+  incomplete: "past_due",
+  paid: "active",
+  past_due: "past_due",
+  paused: "paused",
+  scheduled_cancel: "active",
+  trialing: "trialing",
+  unpaid: "past_due"
+};
+const notSupported = makeNotSupported("creem (merchant-of-record)");
+const idOf = (value) => typeof value === "string" ? value : readString(asRecord(value), "id");
+const readCheckoutUrl = (checkout) => readString(checkout, "checkout_url") ?? readString(checkout, "checkoutUrl") ?? "";
+const isCanceling = (subscription) => readString(subscription, "canceled_at") !== void 0 || readString(subscription, "canceledAt") !== void 0 || readString(subscription, "status") === "scheduled_cancel";
+const subscriptionFromCreem = (input) => {
+  const subscription = asRecord(input);
+  const now = Date.now();
+  const status = readString(subscription, "status") ?? "";
+  return {
+    cancelAtPeriodEnd: isCanceling(subscription),
+    createdAt: now,
+    currentPeriodEnd: parseTimestamp(readString(subscription, "current_period_end_date") ?? readString(subscription, "currentPeriodEndDate")),
+    currentPeriodStart: parseTimestamp(readString(subscription, "current_period_start_date") ?? readString(subscription, "currentPeriodStartDate")),
+    id: readString(subscription, "id") ?? "",
+    priceId: idOf(subscription.product) ?? "",
+    provider: "creem",
+    quantity: readNumber(subscription, "units") ?? 1,
+    referenceId: referenceFromMetadata(subscription) ?? idOf(subscription.customer) ?? "",
+    // Fail closed: an unrecognized Creem status is treated as non-entitling `past_due`.
+    state: SUBSCRIPTION_STATE_BY_CREEM_STATUS[status] ?? "past_due",
+    updatedAt: now
+  };
+};
+const checkoutToSession = (input) => {
+  const checkout = asRecord(input);
+  const now = Date.now();
+  const order = asRecord(checkout.order);
+  const currency = readString(order, "currency") ?? readString(checkout, "currency") ?? "usd";
+  const amount = money(BigInt(Math.round(readNumber(order, "amount") ?? readNumber(checkout, "amount") ?? 0)), currency);
+  const state = PAYMENT_STATE_BY_CREEM_STATUS[readString(order, "status") ?? readString(checkout, "status") ?? ""] ?? "initiated";
+  const settled = state === "captured" || state === "partially_refunded" || state === "refunded";
+  return {
+    amount,
+    capturedAmount: settled ? amount : zeroMoney(currency),
+    createdAt: now,
+    id: readString(checkout, "id") ?? "",
+    provider: "creem",
+    referenceId: referenceFromMetadata(checkout) ?? "",
+    refundedAmount: state === "refunded" ? amount : zeroMoney(currency),
+    state,
+    updatedAt: now
+  };
+};
+const mapEvent = (eventId, eventType, object) => {
+  const base = { eventId, provider: "creem", raw: { object, type: eventType } };
+  const order = asRecord(object.order);
+  const currency = readString(order, "currency") ?? readString(object, "currency") ?? "usd";
+  switch (eventType) {
+    case "checkout.completed": {
+      const amount = readNumber(order, "amount") ?? readNumber(object, "amount");
+      return {
+        ...base,
+        // Round before BigInt: Creem documents integer minor units, but a stray fractional amount
+        // would throw a RangeError out of `parseWebhook` (a 400 → provider retry loop). Match Autumn.
+        amount: amount === void 0 ? void 0 : money(BigInt(Math.round(amount)), currency),
+        customerId: idOf(object.customer),
+        referenceId: referenceFromMetadata(object),
+        sessionId: readString(object, "id"),
+        subscriptionId: idOf(object.subscription),
+        type: "payment.captured"
+      };
+    }
+    case "refund.created": {
+      const amount = readNumber(object, "refund_amount") ?? readNumber(object, "refundAmount") ?? readNumber(object, "amount") ?? readNumber(order, "amount");
+      const refundCurrency = readString(object, "refund_currency") ?? readString(object, "refundCurrency") ?? currency;
+      return {
+        ...base,
+        amount: amount === void 0 ? void 0 : money(BigInt(Math.round(amount)), refundCurrency),
+        referenceId: referenceFromMetadata(object),
+        sessionId: idOf(object.transaction) ?? idOf(object.subscription) ?? idOf(object.order) ?? idOf(object.checkout) ?? readString(object, "id"),
+        type: "payment.refunded"
+      };
+    }
+    case "subscription.active":
+    case "subscription.canceled":
+    case "subscription.expired":
+    case "subscription.paid":
+    case "subscription.past_due":
+    case "subscription.paused":
+    case "subscription.scheduled_cancel":
+    case "subscription.trialing":
+    case "subscription.unpaid":
+    case "subscription.update": {
+      const status = eventType === "subscription.scheduled_cancel" ? "scheduled_cancel" : readString(object, "status");
+      return {
+        ...base,
+        cancelAtPeriodEnd: readBoolean(object, "cancel_at_period_end") ?? isCanceling(object),
+        currentPeriodEnd: parseTimestamp(readString(object, "current_period_end_date") ?? readString(object, "currentPeriodEndDate")),
+        currentPeriodStart: parseTimestamp(readString(object, "current_period_start_date") ?? readString(object, "currentPeriodStartDate")),
+        customerId: idOf(object.customer),
+        priceId: idOf(object.product),
+        referenceId: referenceFromMetadata(object) ?? idOf(object.customer),
+        subscriptionId: readString(object, "id"),
+        type: stateToEventType(SUBSCRIPTION_STATE_BY_CREEM_STATUS[status ?? ""])
+      };
+    }
+    default: {
+      return { ...base, type: "unhandled" };
+    }
+  }
+};
+const createCreemAdapter = (options) => {
+  const { webhookSecret } = options;
+  const client = options.client;
+  return {
+    // Creem is a Merchant-of-Record: it moves the money, so there is no manual payment-intent flow.
+    cancelPayment: () => notSupported("manual payment cancellation"),
+    cancelSubscription: async (subscriptionId, cancelOptions) => (
+      // Creem supports both immediate and period-end cancellation via `mode`; omitting it defers
+      // to the store's configured default, so pass it explicitly. Default (no `atPeriodEnd`) is
+      // immediate, matching the other adapters. Creem reports the resulting state, which we return.
+      subscriptionFromCreem(await client.subscriptions.cancel(subscriptionId, { mode: cancelOptions?.atPeriodEnd === true ? "scheduled" : "immediate" }))
+    ),
+    capabilities: { merchantOfRecord: true, portal: true, usageMetering: false },
+    capturePayment: (_input) => notSupported("manual capture"),
+    createCheckout: async (input) => {
+      const checkout = await client.checkouts.create({
+        customer: input.customerId ? { id: input.customerId } : void 0,
+        // Pin the framework-controlled `referenceId` LAST so caller metadata can never override it.
+        metadata: { ...input.metadata, referenceId: input.referenceId },
+        productId: input.priceId,
+        requestId: input.idempotencyKey,
+        successUrl: input.successUrl,
+        units: input.quantity
+      });
+      return { id: readString(checkout, "id") ?? "", provider: "creem", url: readCheckoutUrl(checkout) };
+    },
+    createPortalSession: async (input) => {
+      const link = await client.customers.generateBillingLinks({ customerId: input.customerId });
+      return { url: readString(link, "customer_portal_link") ?? readString(link, "customerPortalLink") ?? "" };
+    },
+    getOrCreateCustomer: async (ref) => {
+      const toCustomer = (record) => {
+        return {
+          createdAt: Date.now(),
+          email: readString(record, "email") ?? ref.email,
+          id: readString(record, "id") ?? "",
+          provider: "creem",
+          referenceId: ref.referenceId
+        };
+      };
+      try {
+        return toCustomer(asRecord(await client.customers.create({ email: ref.email ?? "", name: ref.metadata?.name ?? ref.referenceId })));
+      } catch (error) {
+        if (ref.email !== void 0) {
+          return toCustomer(asRecord(await client.customers.retrieve(void 0, ref.email)));
+        }
+        throw error;
+      }
+    },
+    getPaymentStatus: async (sessionId) => checkoutToSession(await client.checkouts.retrieve(sessionId)),
+    getSubscriptionStatus: async (subscriptionId) => subscriptionFromCreem(await client.subscriptions.get(subscriptionId)),
+    identifier: "creem",
+    parseWebhook: async ({ headers, payload }) => {
+      await verifyCreemSignature({ payload, secret: webhookSecret, signature: headers.get("creem-signature") ?? "" });
+      const event = asRecord(JSON.parse(payload));
+      return mapEvent(readString(event, "id") ?? "", readString(event, "eventType") ?? readString(event, "type") ?? "", asRecord(event.object));
+    },
+    // Creem refunds are issued from the dashboard; there is no SDK endpoint to initiate one.
+    refundPayment: () => notSupported("programmatic refunds"),
+    resumeSubscription: async (subscriptionId) => subscriptionFromCreem(await client.subscriptions.resume(subscriptionId)),
+    updateSubscription: async (subscriptionId, patch) => {
+      if (patch.priceId) {
+        return subscriptionFromCreem(
+          await client.subscriptions.upgrade(subscriptionId, { productId: patch.priceId, updateBehavior: "proration-charge-immediately" })
+        );
+      }
+      return subscriptionFromCreem(await client.subscriptions.get(subscriptionId));
+    }
+  };
+};
+
+export { createCreemAdapter };

package/dist/providers/dodopayments.d.mts

@@ -0,0 +1,21 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-iFA55DzU.mjs";
+/**
+* The `dodopayments` SDK surface the adapter uses, as a structural type — a real `DodoPayments`
+* instance satisfies it without a cast. Resources are `unknown` (the adapter re-types the client as
+* the real `DodoPayments` internally); this keeps the SDK's full type out of the published declarations.
+*/
+interface DodoPaymentsClientLike {
+  readonly checkoutSessions: unknown;
+  readonly customers: unknown;
+  readonly payments: unknown;
+  readonly refunds: unknown;
+  readonly subscriptions: unknown;
+  readonly usageEvents: unknown;
+}
+interface DodoPaymentsAdapterOptions {
+  readonly client: DodoPaymentsClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+declare const createDodoPaymentsAdapter: (options: DodoPaymentsAdapterOptions) => PaymentAdapter;
+export { type DodoPaymentsAdapterOptions, type DodoPaymentsClientLike, createDodoPaymentsAdapter };

package/dist/providers/dodopayments.d.ts

@@ -0,0 +1,21 @@
+import { P as PaymentAdapter } from "../packem_shared/adapter.d-iFA55DzU.js";
+/**
+* The `dodopayments` SDK surface the adapter uses, as a structural type — a real `DodoPayments`
+* instance satisfies it without a cast. Resources are `unknown` (the adapter re-types the client as
+* the real `DodoPayments` internally); this keeps the SDK's full type out of the published declarations.
+*/
+interface DodoPaymentsClientLike {
+  readonly checkoutSessions: unknown;
+  readonly customers: unknown;
+  readonly payments: unknown;
+  readonly refunds: unknown;
+  readonly subscriptions: unknown;
+  readonly usageEvents: unknown;
+}
+interface DodoPaymentsAdapterOptions {
+  readonly client: DodoPaymentsClientLike;
+  readonly webhookSecret: string;
+  readonly webhookToleranceSeconds?: number;
+}
+declare const createDodoPaymentsAdapter: (options: DodoPaymentsAdapterOptions) => PaymentAdapter;
+export { type DodoPaymentsAdapterOptions, type DodoPaymentsClientLike, createDodoPaymentsAdapter };