@lunora/payment 1.0.0-alpha.13 → 1.0.0-alpha.130

package/dist/packem_shared/createStripeAdapter-oDvMhpeX.mjs

@@ -1,279 +0,0 @@
-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",
-  // SECURITY: `incomplete` means the FIRST payment has not succeeded (SCA
-  // `requires_action` or a failed initial charge). It must NOT map to an
-  // entitling state — Stripe's recommended `payment_behavior: "default_incomplete"`
-  // makes `incomplete` the initial status of every new subscription, so mapping
-  // it to `trialing` (which is in ACTIVE_STATES) would grant paid entitlements
-  // before any payment. Reserve `trialing` for a genuine Stripe trial (status
-  // `trialing`, mapped below); treat `incomplete` as non-entitling `past_due`.
-  incomplete: "past_due",
-  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") {
-        const paymentStatus = readString(object, "payment_status");
-        const paid = paymentStatus === "paid" || paymentStatus === "no_payment_required";
-        return {
-          ...base,
-          customerId: readString(object, "customer"),
-          referenceId: readReferenceId(object),
-          subscriptionId: readString(object, "subscription"),
-          type: paid ? "subscription.active" : "subscription.updated"
-        };
-      }
-      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 };

package/dist/packem_shared/entitlementsForReference-CzZGXPoZ.mjs

@@ -1,51 +0,0 @@
-const ACTIVE_STATES = /* @__PURE__ */ new Set(["active", "trialing"]);
-const usagePeriodStart = (subscriptions) => {
-  let start = 0;
-  for (const subscription of subscriptions) {
-    if (ACTIVE_STATES.has(subscription.state) && subscription.currentPeriodStart !== void 0) {
-      start = Math.max(start, subscription.currentPeriodStart);
-    }
-  }
-  return start;
-};
-const featureNames = (config) => {
-  const names = /* @__PURE__ */ new Set();
-  for (const plan of Object.values(config.plans)) {
-    for (const feature of plan.features ?? []) {
-      names.add(feature);
-    }
-    for (const key of Object.keys(plan.limits ?? {})) {
-      names.add(key);
-    }
-  }
-  return [...names].toSorted((a, b) => a.localeCompare(b));
-};
-const hasActivePrice = (subscriptions, priceId) => subscriptions.some((subscription) => subscription.priceId === priceId && ACTIVE_STATES.has(subscription.state));
-const resolveEntitlements = (config, subscriptions) => {
-  const activePriceIds = new Set(subscriptions.filter((subscription) => ACTIVE_STATES.has(subscription.state)).map((subscription) => subscription.priceId));
-  const plans = [];
-  const features = /* @__PURE__ */ new Set();
-  const limits = /* @__PURE__ */ new Map();
-  for (const [name, plan] of Object.entries(config.plans)) {
-    if (!plan.priceIds.some((id) => activePriceIds.has(id))) {
-      continue;
-    }
-    plans.push(name);
-    for (const feature of plan.features ?? []) {
-      features.add(feature);
-    }
-    for (const [key, value] of Object.entries(plan.limits ?? {})) {
-      const current = limits.get(key);
-      limits.set(key, current === void 0 ? value : Math.max(current, value));
-    }
-  }
-  return {
-    features,
-    has: (feature) => features.has(feature),
-    limit: (key) => limits.get(key),
-    plans
-  };
-};
-const entitlementsForReference = async (store, config, referenceId) => resolveEntitlements(config, await store.listSubscriptionsByReference(referenceId));
-
-export { entitlementsForReference, featureNames, hasActivePrice, resolveEntitlements, usagePeriodStart };

package/dist/packem_shared/idempotencyKey-BFzDCA7g.mjs

@@ -1,3 +0,0 @@
-const idempotencyKey = (operation, ...parts) => [operation, ...parts.map(String)].join(":");
-
-export { idempotencyKey as default };

package/dist/packem_shared/json-Db337f36.mjs

@@ -1,6 +0,0 @@
-const asRecord = (value) => typeof value === "object" && value !== null ? value : {};
-const readString = (object, key) => typeof object[key] === "string" ? object[key] : void 0;
-const readNumber = (object, key) => typeof object[key] === "number" ? object[key] : void 0;
-const readBoolean = (object, key) => typeof object[key] === "boolean" ? object[key] : void 0;
-
-export { asRecord as a, readBoolean as b, readNumber as c, readString as r };

package/dist/packem_shared/lunoraDatabaseToPaymentDatabase-RlKX3Kcd.mjs

@@ -1,29 +0,0 @@
-import { createPayment } from './createPayment-BccfPGyw.mjs';
-import { createDatabasePaymentStore } from './createDatabasePaymentStore-bYB_HUE6.mjs';
-
-const lunoraDatabaseToPaymentDatabase = (database) => {
-  return {
-    delete: async (id) => database.delete(id),
-    findFirst: async (table, where) => await database.findFirst(table, { where }),
-    findMany: async (table, where) => {
-      const result = await database.findMany(table, { where });
-      return result.page;
-    },
-    insert: async (table, document) => database.insert(table, document),
-    patch: async (id, patch) => database.patch(id, patch)
-  };
-};
-const paymentsFromContext = (context, options) => {
-  const userId = context.auth?.userId ?? void 0;
-  return createPayment({
-    adapter: options.adapter,
-    // The default authorizer fails closed on an empty/whitespace reference: a missing identity or a
-    // blank reference (e.g. webhook-orphaned rows with `referenceId: ""`) is never authorized.
-    authorize: options.authorize ?? ((referenceId) => referenceId.trim() !== "" && userId !== void 0 && referenceId === userId),
-    entitlements: options.entitlements,
-    observability: options.observability,
-    store: createDatabasePaymentStore(lunoraDatabaseToPaymentDatabase(context.db))
-  });
-};
-
-export { lunoraDatabaseToPaymentDatabase, paymentsFromContext };

package/dist/packem_shared/observability-CvhJ205g.mjs

@@ -1,11 +0,0 @@
-const notifyObserver = (observer, event) => {
-  if (!observer) {
-    return;
-  }
-  try {
-    observer(event);
-  } catch {
-  }
-};
-
-export { notifyObserver as n };

package/dist/packem_shared/paymentTables-DccHwWr_.mjs

@@ -1,127 +0,0 @@
-import { defineTable } from '@lunora/server';
-import { v } from '@lunora/values';
-
-const products = defineTable({
-  description: v.optional(v.string()),
-  name: v.string(),
-  provider: v.string(),
-  providerProductId: v.string()
-}).index("by_provider_product", ["provider", "providerProductId"], { unique: true });
-const prices = defineTable({
-  active: v.boolean(),
-  amountMinor: v.bigint(),
-  currency: v.string(),
-  interval: v.optional(v.string()),
-  provider: v.string(),
-  providerPriceId: v.string(),
-  providerProductId: v.string()
-}).index("by_provider_price", ["provider", "providerPriceId"], { unique: true });
-const customers = defineTable({
-  createdAt: v.number(),
-  email: v.optional(v.string()),
-  provider: v.string(),
-  providerCustomerId: v.string(),
-  referenceId: v.string()
-}).index("by_provider_customer", ["provider", "providerCustomerId"], { unique: true }).index("by_reference", ["referenceId"]);
-const subscriptions = defineTable({
-  cancelAtPeriodEnd: v.boolean(),
-  createdAt: v.number(),
-  currentPeriodEnd: v.optional(v.number()),
-  currentPeriodStart: v.optional(v.number()),
-  priceId: v.string(),
-  provider: v.string(),
-  providerSubscriptionId: v.string(),
-  quantity: v.number(),
-  referenceId: v.string(),
-  state: v.string(),
-  updatedAt: v.number()
-}).index("by_provider_subscription", ["provider", "providerSubscriptionId"], { unique: true }).index("by_reference", ["referenceId"]);
-const checkouts = defineTable({
-  createdAt: v.number(),
-  mode: v.string(),
-  priceId: v.string(),
-  provider: v.string(),
-  providerCheckoutId: v.string(),
-  referenceId: v.string(),
-  url: v.string()
-}).index("by_provider_checkout", ["provider", "providerCheckoutId"], { unique: true });
-const paymentSessions = defineTable({
-  amountMinor: v.bigint(),
-  capturedMinor: v.bigint(),
-  createdAt: v.number(),
-  currency: v.string(),
-  provider: v.string(),
-  providerSessionId: v.string(),
-  referenceId: v.string(),
-  refundedMinor: v.bigint(),
-  state: v.string(),
-  updatedAt: v.number()
-}).index("by_provider_session", ["provider", "providerSessionId"], { unique: true }).index("by_reference", ["referenceId"]);
-const payments = defineTable({
-  amountMinor: v.bigint(),
-  createdAt: v.number(),
-  currency: v.string(),
-  provider: v.string(),
-  providerPaymentId: v.string(),
-  referenceId: v.string(),
-  sessionId: v.string(),
-  status: v.string()
-}).index("by_provider_payment", ["provider", "providerPaymentId"], { unique: true });
-const captures = defineTable({
-  amountMinor: v.bigint(),
-  createdAt: v.number(),
-  currency: v.string(),
-  provider: v.string(),
-  providerCaptureId: v.string(),
-  sessionId: v.string()
-}).index("by_session", ["sessionId"]);
-const refunds = defineTable({
-  amountMinor: v.bigint(),
-  createdAt: v.number(),
-  currency: v.string(),
-  provider: v.string(),
-  providerRefundId: v.string(),
-  reason: v.optional(v.string()),
-  sessionId: v.string()
-}).index("by_session", ["sessionId"]);
-const invoices = defineTable({
-  amountMinor: v.bigint(),
-  createdAt: v.number(),
-  currency: v.string(),
-  provider: v.string(),
-  providerInvoiceId: v.string(),
-  referenceId: v.string(),
-  status: v.string(),
-  subscriptionId: v.optional(v.string())
-}).index("by_provider_invoice", ["provider", "providerInvoiceId"], { unique: true });
-const events = defineTable({
-  processedAt: v.number(),
-  provider: v.string(),
-  providerEventId: v.string(),
-  type: v.string()
-}).index("by_provider_event", ["provider", "providerEventId"], { unique: true });
-const usageEvents = defineTable({
-  createdAt: v.number(),
-  featureId: v.string(),
-  idempotencyKey: v.string(),
-  provider: v.string(),
-  quantity: v.number(),
-  referenceId: v.string(),
-  reportedToProvider: v.boolean()
-}).index("by_idempotency", ["provider", "idempotencyKey"], { unique: true }).index("by_reference_feature", ["referenceId", "featureId"]);
-const paymentTables = {
-  captures,
-  checkouts,
-  customers,
-  events,
-  invoices,
-  paymentSessions,
-  payments,
-  prices,
-  products,
-  refunds,
-  subscriptions,
-  usageEvents
-};
-
-export { paymentTables as default };

package/dist/packem_shared/reconcile-CI1ukJF9.mjs

@@ -1,73 +0,0 @@
-import { compareMoney } from './addMoney-bCcs1nyw.mjs';
-import { n as notifyObserver } from './observability-CvhJ205g.mjs';
-
-const sameCurrencyAmount = (a, b) => a.currency === b.currency && compareMoney(a, b) === 0;
-const subscriptionDrifted = (existing, current) => existing?.state !== current.state || existing.cancelAtPeriodEnd !== current.cancelAtPeriodEnd || existing.currentPeriodEnd !== current.currentPeriodEnd || existing.priceId !== current.priceId || existing.quantity !== current.quantity;
-const paymentDrifted = (existing, current) => existing?.state !== current.state || !sameCurrencyAmount(existing.capturedAmount, current.capturedAmount) || !sameCurrencyAmount(existing.refundedAmount, current.refundedAmount);
-const reconcileSubscription = async (adapter, store, id, observer) => {
-  const current = await adapter.getSubscriptionStatus(id);
-  const existing = await store.getSubscription(adapter.identifier, id);
-  if (!subscriptionDrifted(existing, current)) {
-    return false;
-  }
-  await store.upsertSubscription({ ...current, createdAt: existing?.createdAt ?? current.createdAt });
-  notifyObserver(observer, { id, kind: "subscription", provider: adapter.identifier, type: "reconcile.drift" });
-  return true;
-};
-const reconcilePayment = async (adapter, store, id, observer) => {
-  const current = await adapter.getPaymentStatus(id);
-  const existing = await store.getPaymentSession(adapter.identifier, id);
-  if (!paymentDrifted(existing, current)) {
-    return false;
-  }
-  await store.upsertPaymentSession({ ...current, createdAt: existing?.createdAt ?? current.createdAt });
-  notifyObserver(observer, { id, kind: "payment", provider: adapter.identifier, type: "reconcile.drift" });
-  return true;
-};
-const sweep = async (ids, kind, reconcileOne, adapter, observer) => {
-  const settled = await Promise.allSettled(ids.map((id) => reconcileOne(id)));
-  let updated = 0;
-  let failed = 0;
-  for (const [index, result] of settled.entries()) {
-    if (result.status === "fulfilled") {
-      if (result.value) {
-        updated += 1;
-      }
-    } else {
-      failed += 1;
-      notifyObserver(observer, { error: result.reason, id: ids[index] ?? "", kind, provider: adapter.identifier, type: "reconcile.error" });
-    }
-  }
-  return { failed, updated };
-};
-const reconcile = async (input) => {
-  const { adapter, observability, store } = input;
-  const subscriptionIds = input.subscriptionIds ?? [];
-  const paymentSessionIds = input.paymentSessionIds ?? [];
-  const subscriptionCounts = await sweep(
-    subscriptionIds,
-    "subscription",
-    (id) => reconcileSubscription(adapter, store, id, observability),
-    adapter,
-    observability
-  );
-  const paymentCounts = await sweep(paymentSessionIds, "payment", (id) => reconcilePayment(adapter, store, id, observability), adapter, observability);
-  notifyObserver(observability, {
-    failedPayments: paymentCounts.failed,
-    failedSubscriptions: subscriptionCounts.failed,
-    provider: adapter.identifier,
-    type: "reconcile.completed",
-    updatedPayments: paymentCounts.updated,
-    updatedSubscriptions: subscriptionCounts.updated
-  });
-  return {
-    checkedPayments: paymentSessionIds.length,
-    checkedSubscriptions: subscriptionIds.length,
-    failedPayments: paymentCounts.failed,
-    failedSubscriptions: subscriptionCounts.failed,
-    updatedPayments: paymentCounts.updated,
-    updatedSubscriptions: subscriptionCounts.updated
-  };
-};
-
-export { reconcile };