@lunora/payment 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,16 @@
+export { createAdapterRegistry } from './packem_shared/createAdapterRegistry-BuDHFCBc.mjs';
+export { lunoraDatabaseToPaymentDatabase, paymentsFromContext } from './packem_shared/lunoraDatabaseToPaymentDatabase-RlKX3Kcd.mjs';
+export { createPayment } from './packem_shared/createPayment-BccfPGyw.mjs';
+export { createDatabasePaymentStore } from './packem_shared/createDatabasePaymentStore-bYB_HUE6.mjs';
+export { entitlementsForReference, featureNames, hasActivePrice, resolveEntitlements, usagePeriodStart } from './packem_shared/entitlementsForReference-CzZGXPoZ.mjs';
+export { LunoraPaymentError } from './packem_shared/LunoraPaymentError-B3hEzXSs.mjs';
+export { default as idempotencyKey } from './packem_shared/idempotencyKey-BFzDCA7g.mjs';
+export { addMoney, allocateMoney, compareMoney, formatMoney, fromMoneyJSON, isZeroDecimalCurrency, isZeroMoney, money, subtractMoney, toMoneyJSON, zeroMoney } from './packem_shared/addMoney-bCcs1nyw.mjs';
+export { createPolarAdapter } from './packem_shared/createPolarAdapter-BJtVGSlF.mjs';
+export { createStripeAdapter } from './packem_shared/createStripeAdapter-D40MVBXg.mjs';
+export { reconcile } from './packem_shared/reconcile-CI1ukJF9.mjs';
+export { default as paymentTables } from './packem_shared/paymentTables-DccHwWr_.mjs';
+export { PAYMENT_TERMINAL_STATES, SUBSCRIPTION_TERMINAL_STATES, canTransitionPayment, canTransitionSubscription, nextPaymentState, nextSubscriptionState } from './packem_shared/PAYMENT_TERMINAL_STATES-DrxV0clv.mjs';
+export { MemoryPaymentStore } from './packem_shared/MemoryPaymentStore-DvgdWa3C.mjs';
+export { default as applyWebhookAction } from './packem_shared/applyWebhookAction-DpAqf3Lw.mjs';
+export { constantTimeEqual, hmacSha256Hex, parseStripeSignatureHeader, verifyStandardWebhook, verifyStripeSignature } from './packem_shared/constantTimeEqual-CfY0jYcL.mjs';

package/dist/packem_shared/LunoraPaymentError-B3hEzXSs.mjs

@@ -0,0 +1,22 @@
+const STATUS_BY_CODE = {
+  CONFIG_INVALID: 500,
+  CURRENCY_MISMATCH: 400,
+  FORBIDDEN: 403,
+  INVALID_TRANSITION: 409,
+  NOT_FOUND: 404,
+  PROVIDER_ERROR: 502,
+  WEBHOOK_SIGNATURE_INVALID: 400,
+  WEBHOOK_TIMESTAMP_INVALID: 400
+};
+class LunoraPaymentError extends Error {
+  code;
+  status;
+  constructor(code, message) {
+    super(message);
+    this.name = "LunoraPaymentError";
+    this.code = code;
+    this.status = STATUS_BY_CODE[code];
+  }
+}
+
+export { LunoraPaymentError };

package/dist/packem_shared/MemoryPaymentStore-DvgdWa3C.mjs

@@ -0,0 +1,72 @@
+const customerKey = (provider, referenceId) => `${provider}:${referenceId}`;
+const recordKey = (provider, id) => `${provider}:${id}`;
+class MemoryPaymentStore {
+  customers = /* @__PURE__ */ new Map();
+  processedEvents = /* @__PURE__ */ new Set();
+  sessions = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Map();
+  usageEvents = /* @__PURE__ */ new Map();
+  getCustomerByReference(provider, referenceId) {
+    return Promise.resolve(this.customers.get(customerKey(provider, referenceId)));
+  }
+  getPaymentSession(provider, id) {
+    return Promise.resolve(this.sessions.get(recordKey(provider, id)));
+  }
+  getSubscription(provider, id) {
+    return Promise.resolve(this.subscriptions.get(recordKey(provider, id)));
+  }
+  listSubscriptionsByReference(referenceId) {
+    return Promise.resolve([...this.subscriptions.values()].filter((subscription) => subscription.referenceId === referenceId));
+  }
+  markEventProcessed(provider, eventId) {
+    const key = recordKey(provider, eventId);
+    if (this.processedEvents.has(key)) {
+      return Promise.resolve(false);
+    }
+    this.processedEvents.add(key);
+    return Promise.resolve(true);
+  }
+  releaseEvent(provider, eventId) {
+    this.processedEvents.delete(recordKey(provider, eventId));
+    return Promise.resolve();
+  }
+  markUsageReported(provider, idempotencyKey) {
+    const key = recordKey(provider, idempotencyKey);
+    const existing = this.usageEvents.get(key);
+    if (existing) {
+      this.usageEvents.set(key, { ...existing, reportedToProvider: true });
+    }
+    return Promise.resolve();
+  }
+  recordUsage(event) {
+    const key = recordKey(event.provider, event.idempotencyKey);
+    if (this.usageEvents.has(key)) {
+      return Promise.resolve(false);
+    }
+    this.usageEvents.set(key, event);
+    return Promise.resolve(true);
+  }
+  sumUsage(referenceId, featureId, since) {
+    let total = 0;
+    for (const event of this.usageEvents.values()) {
+      if (event.referenceId === referenceId && event.featureId === featureId && event.createdAt >= since) {
+        total += event.quantity;
+      }
+    }
+    return Promise.resolve(total);
+  }
+  upsertCustomer(customer) {
+    this.customers.set(customerKey(customer.provider, customer.referenceId), customer);
+    return Promise.resolve();
+  }
+  upsertPaymentSession(session) {
+    this.sessions.set(recordKey(session.provider, session.id), session);
+    return Promise.resolve();
+  }
+  upsertSubscription(subscription) {
+    this.subscriptions.set(recordKey(subscription.provider, subscription.id), subscription);
+    return Promise.resolve();
+  }
+}
+
+export { MemoryPaymentStore };

package/dist/packem_shared/PAYMENT_TERMINAL_STATES-DrxV0clv.mjs

@@ -0,0 +1,26 @@
+const PAYMENT_TRANSITIONS = {
+  authorized: { cancel: "canceled", capture: "captured", fail: "failed" },
+  canceled: {},
+  captured: { partial_refund: "partially_refunded", refund: "refunded" },
+  failed: {},
+  // A webhook can land before our local record exists, so "initiated" accepts the same
+  // outcomes a fresh intent could reach directly.
+  initiated: { authorize: "authorized", cancel: "canceled", capture: "captured", fail: "failed" },
+  partially_refunded: { partial_refund: "partially_refunded", refund: "refunded" },
+  refunded: {}
+};
+const SUBSCRIPTION_TRANSITIONS = {
+  active: { cancel: "canceled", mark_past_due: "past_due", pause: "paused", renew: "active" },
+  canceled: {},
+  past_due: { activate: "active", cancel: "canceled", pause: "paused", renew: "active" },
+  paused: { cancel: "canceled", resume: "active" },
+  trialing: { activate: "active", cancel: "canceled", mark_past_due: "past_due" }
+};
+const PAYMENT_TERMINAL_STATES = /* @__PURE__ */ new Set(["canceled", "failed", "refunded"]);
+const SUBSCRIPTION_TERMINAL_STATES = /* @__PURE__ */ new Set(["canceled"]);
+const nextPaymentState = (from, action) => PAYMENT_TRANSITIONS[from][action];
+const canTransitionPayment = (from, action) => nextPaymentState(from, action) !== void 0;
+const nextSubscriptionState = (from, action) => SUBSCRIPTION_TRANSITIONS[from][action];
+const canTransitionSubscription = (from, action) => nextSubscriptionState(from, action) !== void 0;
+
+export { PAYMENT_TERMINAL_STATES, SUBSCRIPTION_TERMINAL_STATES, canTransitionPayment, canTransitionSubscription, nextPaymentState, nextSubscriptionState };

package/dist/packem_shared/addMoney-bCcs1nyw.mjs

@@ -0,0 +1,60 @@
+import { toSnapshot } from 'dinero.js';
+import { add, allocate, compare, subtract, dinero } from 'dinero.js/bigint';
+import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+
+const ZERO_DECIMAL = /* @__PURE__ */ new Set(["BIF", "CLP", "DJF", "GNF", "JPY", "KMF", "KRW", "MGA", "PYG", "RWF", "UGX", "VND", "VUV", "XAF", "XOF", "XPF"]);
+const THREE_DECIMAL = /* @__PURE__ */ new Set(["BHD", "IQD", "JOD", "KWD", "LYD", "OMR", "TND"]);
+const exponentFor = (code) => {
+  if (ZERO_DECIMAL.has(code)) {
+    return 0n;
+  }
+  return THREE_DECIMAL.has(code) ? 3n : 2n;
+};
+const currencyFor = (code) => {
+  return { base: 10n, code: code.toUpperCase(), exponent: exponentFor(code.toUpperCase()) };
+};
+const toDinero = (value) => dinero({ amount: value.minorUnits, currency: currencyFor(value.currency) });
+const fromDinero = (value) => {
+  const snapshot = toSnapshot(value);
+  return { currency: snapshot.currency.code, minorUnits: snapshot.amount };
+};
+const assertSameCurrency = (a, b) => {
+  if (a.currency !== b.currency) {
+    throw new LunoraPaymentError("CURRENCY_MISMATCH", `cannot combine ${a.currency} with ${b.currency}`);
+  }
+};
+const isZeroDecimalCurrency = (currency) => exponentFor(currency.toUpperCase()) === 0n;
+const money = (minorUnits, currency) => {
+  const units = typeof minorUnits === "bigint" ? minorUnits : BigInt(Math.trunc(minorUnits));
+  return { currency: currency.toUpperCase(), minorUnits: units };
+};
+const zeroMoney = (currency) => money(0n, currency);
+const formatMoney = (value, locale = "en-US") => {
+  const exponent = Number(exponentFor(value.currency.toUpperCase()));
+  const amount = Number(value.minorUnits) / 10 ** exponent;
+  try {
+    return new Intl.NumberFormat(locale, { currency: value.currency, style: "currency" }).format(amount);
+  } catch {
+    return `${amount.toFixed(exponent)} ${value.currency}`;
+  }
+};
+const addMoney = (a, b) => {
+  assertSameCurrency(a, b);
+  return fromDinero(add(toDinero(a), toDinero(b)));
+};
+const subtractMoney = (a, b) => {
+  assertSameCurrency(a, b);
+  return fromDinero(subtract(toDinero(a), toDinero(b)));
+};
+const compareMoney = (a, b) => {
+  assertSameCurrency(a, b);
+  return compare(toDinero(a), toDinero(b));
+};
+const allocateMoney = (amount, ratios) => allocate(toDinero(amount), [...ratios]).map((part) => fromDinero(part));
+const isZeroMoney = (a) => a.minorUnits === 0n;
+const toMoneyJSON = (m) => {
+  return { currency: m.currency, minorUnits: m.minorUnits.toString() };
+};
+const fromMoneyJSON = (json) => money(BigInt(json.minorUnits), json.currency);
+
+export { addMoney, allocateMoney, compareMoney, formatMoney, fromMoneyJSON, isZeroDecimalCurrency, isZeroMoney, money, subtractMoney, toMoneyJSON, zeroMoney };

package/dist/packem_shared/applyWebhookAction-DpAqf3Lw.mjs

@@ -0,0 +1,177 @@
+import { compareMoney, zeroMoney, addMoney } from './addMoney-bCcs1nyw.mjs';
+import { n as notifyObserver } from './observability-CvhJ205g.mjs';
+import { nextPaymentState, nextSubscriptionState } from './PAYMENT_TERMINAL_STATES-DrxV0clv.mjs';
+
+const PAYMENT_ACTION_BY_TYPE = {
+  "payment.authorized": "authorize",
+  "payment.captured": "capture",
+  "payment.failed": "fail",
+  "payment.refunded": "refund"
+};
+const SUBSCRIPTION_STATE_BY_TYPE = {
+  "subscription.active": "active",
+  "subscription.canceled": "canceled",
+  "subscription.past_due": "past_due",
+  "subscription.paused": "paused"
+};
+const SUBSCRIPTION_ACTION_BY_TYPE = {
+  "subscription.active": "activate",
+  "subscription.canceled": "cancel",
+  "subscription.past_due": "mark_past_due",
+  "subscription.paused": "pause"
+};
+const maxMoney = (a, b) => compareMoney(a, b) > 0 ? a : b;
+const refundedTotalFor = (base, action) => {
+  if (!action.amount) {
+    return void 0;
+  }
+  if (base.refundedAmount.currency !== action.amount.currency || base.capturedAmount.currency !== action.amount.currency) {
+    return void 0;
+  }
+  const prospective = action.amountKind === "absolute" ? maxMoney(action.amount, base.refundedAmount) : addMoney(base.refundedAmount, action.amount);
+  if (compareMoney(prospective, base.capturedAmount) > 0) {
+    return void 0;
+  }
+  return prospective;
+};
+const applyPayment = async (store, action, paymentAction) => {
+  if (!action.sessionId) {
+    return { applied: false, reason: "unhandled" };
+  }
+  const existing = await store.getPaymentSession(action.provider, action.sessionId);
+  const fromState = existing?.state ?? "initiated";
+  const now = Date.now();
+  const currency = action.amount?.currency ?? existing?.amount.currency ?? "USD";
+  let resolvedAction = paymentAction;
+  if (paymentAction === "refund" && existing) {
+    const prospective = refundedTotalFor(existing, action);
+    if (prospective && compareMoney(prospective, existing.capturedAmount) < 0) {
+      resolvedAction = "partial_refund";
+    }
+  }
+  const toState = nextPaymentState(fromState, resolvedAction);
+  if (!toState) {
+    return { applied: false, reason: "illegal_transition" };
+  }
+  const base = existing ?? {
+    amount: action.amount ?? zeroMoney(currency),
+    capturedAmount: zeroMoney(currency),
+    createdAt: now,
+    id: action.sessionId,
+    provider: action.provider,
+    referenceId: action.referenceId ?? "",
+    refundedAmount: zeroMoney(currency),
+    state: fromState,
+    updatedAt: now
+  };
+  let { capturedAmount, refundedAmount } = base;
+  if (resolvedAction === "capture" && action.amount) {
+    capturedAmount = action.amount;
+  }
+  if ((resolvedAction === "partial_refund" || resolvedAction === "refund") && action.amount) {
+    const prospective = refundedTotalFor(base, action);
+    if (!prospective) {
+      return { applied: false, reason: "invalid_refund_amount" };
+    }
+    refundedAmount = prospective;
+  }
+  await store.upsertPaymentSession({
+    ...base,
+    capturedAmount,
+    referenceId: action.referenceId ?? base.referenceId,
+    refundedAmount,
+    state: toState,
+    updatedAt: now
+  });
+  return { applied: true, reason: "ok" };
+};
+const applySubscription = async (store, action) => {
+  if (!action.subscriptionId) {
+    return { applied: false, reason: "unhandled" };
+  }
+  const existing = await store.getSubscription(action.provider, action.subscriptionId);
+  const now = Date.now();
+  if (action.type === "subscription.updated") {
+    if (!existing) {
+      return { applied: false, reason: "unhandled" };
+    }
+    await store.upsertSubscription({
+      ...existing,
+      cancelAtPeriodEnd: action.cancelAtPeriodEnd ?? existing.cancelAtPeriodEnd,
+      currentPeriodEnd: action.currentPeriodEnd ?? existing.currentPeriodEnd,
+      currentPeriodStart: action.currentPeriodStart ?? existing.currentPeriodStart,
+      priceId: action.priceId ?? existing.priceId,
+      quantity: action.quantity ?? existing.quantity,
+      updatedAt: now
+    });
+    return { applied: true, reason: "ok" };
+  }
+  const targetState = SUBSCRIPTION_STATE_BY_TYPE[action.type];
+  if (!targetState) {
+    return { applied: false, reason: "unhandled" };
+  }
+  if (!existing) {
+    await store.upsertSubscription({
+      cancelAtPeriodEnd: action.cancelAtPeriodEnd ?? false,
+      createdAt: now,
+      currentPeriodEnd: action.currentPeriodEnd,
+      currentPeriodStart: action.currentPeriodStart ?? now,
+      id: action.subscriptionId,
+      priceId: action.priceId ?? "",
+      provider: action.provider,
+      quantity: action.quantity ?? 1,
+      referenceId: action.referenceId ?? "",
+      state: targetState,
+      updatedAt: now
+    });
+    return { applied: true, reason: "ok" };
+  }
+  const subscriptionAction = existing.state === "active" && targetState === "active" ? "renew" : SUBSCRIPTION_ACTION_BY_TYPE[action.type];
+  const nextState = subscriptionAction ? nextSubscriptionState(existing.state, subscriptionAction) : void 0;
+  if (!nextState) {
+    return { applied: false, reason: "illegal_transition" };
+  }
+  await store.upsertSubscription({
+    ...existing,
+    cancelAtPeriodEnd: action.cancelAtPeriodEnd ?? existing.cancelAtPeriodEnd,
+    currentPeriodEnd: action.currentPeriodEnd ?? existing.currentPeriodEnd,
+    currentPeriodStart: action.currentPeriodStart ?? existing.currentPeriodStart,
+    priceId: action.priceId ?? existing.priceId,
+    quantity: action.quantity ?? existing.quantity,
+    state: nextState,
+    updatedAt: now
+  });
+  return { applied: true, reason: "ok" };
+};
+const applyWebhookAction = async (store, action, observer) => {
+  if (action.type === "unhandled") {
+    return { applied: false, reason: "unhandled" };
+  }
+  const fresh = await store.markEventProcessed(action.provider, action.eventId);
+  if (!fresh) {
+    notifyObserver(observer, { eventId: action.eventId, provider: action.provider, type: "webhook.duplicate" });
+    return { applied: false, reason: "duplicate" };
+  }
+  const paymentAction = PAYMENT_ACTION_BY_TYPE[action.type];
+  let result;
+  try {
+    result = paymentAction ? await applyPayment(store, action, paymentAction) : await applySubscription(store, action);
+  } catch (error) {
+    await store.releaseEvent(action.provider, action.eventId);
+    throw error;
+  }
+  notifyObserver(observer, { action: action.type, eventId: action.eventId, provider: action.provider, reason: result.reason, type: "webhook.applied" });
+  if (action.type === "payment.failed") {
+    notifyObserver(observer, { provider: action.provider, referenceId: action.referenceId, sessionId: action.sessionId, type: "payment.failed" });
+  } else if (action.type === "subscription.past_due") {
+    notifyObserver(observer, {
+      provider: action.provider,
+      referenceId: action.referenceId,
+      subscriptionId: action.subscriptionId,
+      type: "subscription.past_due"
+    });
+  }
+  return result;
+};
+
+export { applyWebhookAction as default };

package/dist/packem_shared/constantTimeEqual-CfY0jYcL.mjs

@@ -0,0 +1,95 @@
+import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+
+const encoder = new TextEncoder();
+const toHex = (buffer) => [...new Uint8Array(buffer)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+const SYMMETRIC_PREFIX = "whsec_";
+const base64ToBytes = (value) => new Uint8Array(Array.from(atob(value), (character) => character.codePointAt(0) ?? 0));
+const bytesToBase64 = (buffer) => btoa(String.fromCodePoint(...new Uint8Array(buffer)));
+const hmacSha256Base64 = async (keyBytes, payload) => {
+  const key = await crypto.subtle.importKey("raw", keyBytes, { hash: "SHA-256", name: "HMAC" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return bytesToBase64(signature);
+};
+const constantTimeEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let mismatch = 0;
+  for (let index = 0; index < a.length; index += 1) {
+    mismatch |= (a.codePointAt(index) ?? 0) ^ (b.codePointAt(index) ?? 0);
+  }
+  return mismatch === 0;
+};
+const hmacSha256Hex = async (secret, payload) => {
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return toHex(signature);
+};
+const parseStripeSignatureHeader = (header) => {
+  let timestamp = Number.NaN;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const index = part.indexOf("=");
+    if (index === -1) {
+      continue;
+    }
+    const scheme = part.slice(0, index).trim();
+    const value = part.slice(index + 1).trim();
+    if (scheme === "t") {
+      timestamp = Number(value);
+    } else if (scheme === "v1") {
+      signatures.push(value);
+    }
+  }
+  return { signatures, timestamp };
+};
+const verifyStripeSignature = async (input) => {
+  if (!input.secret) {
+    throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
+  }
+  const toleranceSeconds = input.toleranceSeconds ?? 300;
+  const nowMs = input.now ?? Date.now();
+  const { signatures, timestamp } = parseStripeSignatureHeader(input.signatureHeader);
+  if (!Number.isFinite(timestamp) || signatures.length === 0) {
+    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "malformed signature header");
+  }
+  if (Math.abs(Math.floor(nowMs / 1e3) - timestamp) > toleranceSeconds) {
+    throw new LunoraPaymentError("WEBHOOK_TIMESTAMP_INVALID", "signature timestamp outside tolerance");
+  }
+  const expected = await hmacSha256Hex(input.secret, `${String(timestamp)}.${input.payload}`);
+  if (!signatures.some((candidate) => constantTimeEqual(candidate, expected))) {
+    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "no matching signature");
+  }
+};
+const verifyStandardWebhook = async (input) => {
+  if (!input.secret) {
+    throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
+  }
+  const toleranceSeconds = input.toleranceSeconds ?? 300;
+  const nowMs = input.now ?? Date.now();
+  const timestamp = Number(input.webhookTimestamp);
+  if (!input.webhookId || !input.webhookSignature || !Number.isFinite(timestamp)) {
+    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "missing standard-webhooks headers");
+  }
+  if (Math.abs(Math.floor(nowMs / 1e3) - timestamp) > toleranceSeconds) {
+    throw new LunoraPaymentError("WEBHOOK_TIMESTAMP_INVALID", "signature timestamp outside tolerance");
+  }
+  const rawSecret = input.secret.startsWith(SYMMETRIC_PREFIX) ? input.secret.slice(SYMMETRIC_PREFIX.length) : input.secret;
+  if (!rawSecret) {
+    throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
+  }
+  const keyBytes = base64ToBytes(rawSecret);
+  if (keyBytes.length === 0) {
+    throw new LunoraPaymentError("CONFIG_INVALID", "webhook secret not configured");
+  }
+  const expected = await hmacSha256Base64(keyBytes, `${input.webhookId}.${input.webhookTimestamp}.${input.payload}`);
+  const provided = input.webhookSignature.split(" ").map((entry) => {
+    const comma = entry.indexOf(",");
+    return comma === -1 ? "" : entry.slice(comma + 1);
+  }).filter(Boolean);
+  if (!provided.some((candidate) => constantTimeEqual(candidate, expected))) {
+    throw new LunoraPaymentError("WEBHOOK_SIGNATURE_INVALID", "no matching signature");
+  }
+};
+
+export { constantTimeEqual, hmacSha256Hex, parseStripeSignatureHeader, verifyStandardWebhook, verifyStripeSignature };

package/dist/packem_shared/createAdapterRegistry-BuDHFCBc.mjs

@@ -0,0 +1,24 @@
+import { LunoraPaymentError } from './LunoraPaymentError-B3hEzXSs.mjs';
+
+const createAdapterRegistry = (adapters) => {
+  const byId = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    if (byId.has(adapter.identifier)) {
+      throw new LunoraPaymentError("CONFIG_INVALID", `duplicate adapter for provider "${adapter.identifier}"`);
+    }
+    byId.set(adapter.identifier, adapter);
+  }
+  return {
+    all: () => [...byId.values()],
+    get: (provider) => {
+      const adapter = byId.get(provider);
+      if (!adapter) {
+        throw new LunoraPaymentError("CONFIG_INVALID", `no adapter registered for provider "${provider}"`);
+      }
+      return adapter;
+    },
+    has: (provider) => byId.has(provider)
+  };
+};
+
+export { createAdapterRegistry };

package/dist/packem_shared/createDatabasePaymentStore-bYB_HUE6.mjs

@@ -0,0 +1,172 @@
+import { money } from './addMoney-bCcs1nyw.mjs';
+
+const readString = (row, key) => typeof row[key] === "string" ? row[key] : "";
+const readOptionalString = (row, key) => typeof row[key] === "string" ? row[key] : void 0;
+const readNumber = (row, key) => typeof row[key] === "number" ? row[key] : 0;
+const readOptionalNumber = (row, key) => typeof row[key] === "number" ? row[key] : void 0;
+const readBoolean = (row, key) => row[key] === true;
+const readBigint = (row, key) => {
+  const value = row[key];
+  if (typeof value === "bigint") {
+    return value;
+  }
+  return typeof value === "number" || typeof value === "string" ? BigInt(value) : 0n;
+};
+const customerToRow = (customer) => {
+  return {
+    createdAt: customer.createdAt,
+    email: customer.email,
+    provider: customer.provider,
+    providerCustomerId: customer.id,
+    referenceId: customer.referenceId
+  };
+};
+const rowToCustomer = (row) => {
+  return {
+    createdAt: readNumber(row, "createdAt"),
+    email: readOptionalString(row, "email"),
+    id: readString(row, "providerCustomerId"),
+    provider: readString(row, "provider"),
+    referenceId: readString(row, "referenceId")
+  };
+};
+const sessionToRow = (session) => {
+  return {
+    amountMinor: session.amount.minorUnits,
+    capturedMinor: session.capturedAmount.minorUnits,
+    createdAt: session.createdAt,
+    currency: session.amount.currency,
+    provider: session.provider,
+    providerSessionId: session.id,
+    referenceId: session.referenceId,
+    refundedMinor: session.refundedAmount.minorUnits,
+    state: session.state,
+    updatedAt: session.updatedAt
+  };
+};
+const rowToSession = (row) => {
+  const currency = readString(row, "currency");
+  return {
+    amount: money(readBigint(row, "amountMinor"), currency),
+    capturedAmount: money(readBigint(row, "capturedMinor"), currency),
+    createdAt: readNumber(row, "createdAt"),
+    id: readString(row, "providerSessionId"),
+    provider: readString(row, "provider"),
+    referenceId: readString(row, "referenceId"),
+    refundedAmount: money(readBigint(row, "refundedMinor"), currency),
+    state: readString(row, "state"),
+    updatedAt: readNumber(row, "updatedAt")
+  };
+};
+const subscriptionToRow = (subscription) => {
+  return {
+    cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
+    createdAt: subscription.createdAt,
+    currentPeriodEnd: subscription.currentPeriodEnd,
+    currentPeriodStart: subscription.currentPeriodStart,
+    priceId: subscription.priceId,
+    provider: subscription.provider,
+    providerSubscriptionId: subscription.id,
+    quantity: subscription.quantity,
+    referenceId: subscription.referenceId,
+    state: subscription.state,
+    updatedAt: subscription.updatedAt
+  };
+};
+const rowToSubscription = (row) => {
+  return {
+    cancelAtPeriodEnd: readBoolean(row, "cancelAtPeriodEnd"),
+    createdAt: readNumber(row, "createdAt"),
+    currentPeriodEnd: readOptionalNumber(row, "currentPeriodEnd"),
+    currentPeriodStart: readOptionalNumber(row, "currentPeriodStart"),
+    id: readString(row, "providerSubscriptionId"),
+    priceId: readString(row, "priceId"),
+    provider: readString(row, "provider"),
+    quantity: readNumber(row, "quantity"),
+    referenceId: readString(row, "referenceId"),
+    state: readString(row, "state"),
+    updatedAt: readNumber(row, "updatedAt")
+  };
+};
+const usageEventToRow = (event) => {
+  return {
+    createdAt: event.createdAt,
+    featureId: event.featureId,
+    idempotencyKey: event.idempotencyKey,
+    provider: event.provider,
+    quantity: event.quantity,
+    referenceId: event.referenceId,
+    reportedToProvider: event.reportedToProvider
+  };
+};
+const createDatabasePaymentStore = (database) => {
+  const upsert = async (table, where, row) => {
+    const existing = await database.findFirst(table, where);
+    if (existing) {
+      await database.patch(existing._id, row);
+      return;
+    }
+    await database.insert(table, row);
+  };
+  return {
+    getCustomerByReference: async (provider, referenceId) => {
+      const row = await database.findFirst("customers", { provider, referenceId });
+      return row ? rowToCustomer(row) : void 0;
+    },
+    getPaymentSession: async (provider, id) => {
+      const row = await database.findFirst("paymentSessions", { provider, providerSessionId: id });
+      return row ? rowToSession(row) : void 0;
+    },
+    getSubscription: async (provider, id) => {
+      const row = await database.findFirst("subscriptions", { provider, providerSubscriptionId: id });
+      return row ? rowToSubscription(row) : void 0;
+    },
+    listSubscriptionsByReference: async (referenceId) => {
+      const rows = await database.findMany("subscriptions", { referenceId });
+      return rows.map((row) => rowToSubscription(row));
+    },
+    markEventProcessed: async (provider, eventId) => {
+      const existing = await database.findFirst("events", { provider, providerEventId: eventId });
+      if (existing) {
+        return false;
+      }
+      await database.insert("events", { processedAt: Date.now(), provider, providerEventId: eventId, type: "" });
+      return true;
+    },
+    releaseEvent: async (provider, eventId) => {
+      const existing = await database.findFirst("events", { provider, providerEventId: eventId });
+      if (existing) {
+        await database.delete(existing._id);
+      }
+    },
+    markUsageReported: async (provider, idempotencyKey) => {
+      const existing = await database.findFirst("usageEvents", { idempotencyKey, provider });
+      if (existing) {
+        await database.patch(existing._id, { reportedToProvider: true });
+      }
+    },
+    recordUsage: async (event) => {
+      const existing = await database.findFirst("usageEvents", { idempotencyKey: event.idempotencyKey, provider: event.provider });
+      if (existing) {
+        return false;
+      }
+      await database.insert("usageEvents", usageEventToRow(event));
+      return true;
+    },
+    sumUsage: async (referenceId, featureId, since) => {
+      const rows = await database.findMany("usageEvents", { featureId, referenceId });
+      let total = 0;
+      for (const row of rows) {
+        if (readNumber(row, "createdAt") >= since) {
+          total += readNumber(row, "quantity");
+        }
+      }
+      return total;
+    },
+    upsertCustomer: async (customer) => upsert("customers", { provider: customer.provider, providerCustomerId: customer.id }, customerToRow(customer)),
+    upsertPaymentSession: async (session) => upsert("paymentSessions", { provider: session.provider, providerSessionId: session.id }, sessionToRow(session)),
+    upsertSubscription: async (subscription) => upsert("subscriptions", { provider: subscription.provider, providerSubscriptionId: subscription.id }, subscriptionToRow(subscription))
+  };
+};
+
+export { createDatabasePaymentStore };