@parsrun/payments 0.1.0

package/dist/dunning/index.js

@@ -0,0 +1,2677 @@
+// src/dunning/dunning-sequence.ts
+var DunningStepBuilder = class {
+  step = {
+    actions: [],
+    notificationChannels: []
+  };
+  constructor(id, name) {
+    this.step.id = id;
+    this.step.name = name;
+  }
+  /**
+   * Set days after initial failure
+   */
+  afterDays(days) {
+    this.step.daysAfterFailure = days;
+    return this;
+  }
+  /**
+   * Set hours offset within the day
+   */
+  atHour(hour) {
+    this.step.hoursOffset = hour;
+    return this;
+  }
+  /**
+   * Add actions to take
+   */
+  withActions(...actions) {
+    this.step.actions = actions;
+    return this;
+  }
+  /**
+   * Add notification channels
+   */
+  notify(...channels) {
+    this.step.notificationChannels = channels;
+    return this;
+  }
+  /**
+   * Set notification template
+   */
+  withTemplate(templateId) {
+    this.step.notificationTemplateId = templateId;
+    return this;
+  }
+  /**
+   * Enable payment retry in this step
+   */
+  retryPayment(retry = true) {
+    this.step.retryPayment = retry;
+    if (retry && !this.step.actions?.includes("retry_payment")) {
+      this.step.actions = [...this.step.actions || [], "retry_payment"];
+    }
+    return this;
+  }
+  /**
+   * Set access level for this step
+   */
+  setAccessLevel(level) {
+    this.step.accessLevel = level;
+    if (!this.step.actions?.includes("limit_features")) {
+      this.step.actions = [...this.step.actions || [], "limit_features"];
+    }
+    return this;
+  }
+  /**
+   * Mark this as the final step
+   */
+  final(isFinal = true) {
+    this.step.isFinal = isFinal;
+    return this;
+  }
+  /**
+   * Add custom action handler
+   */
+  withCustomAction(handler) {
+    this.step.customAction = handler;
+    if (!this.step.actions?.includes("custom")) {
+      this.step.actions = [...this.step.actions || [], "custom"];
+    }
+    return this;
+  }
+  /**
+   * Add condition for this step
+   */
+  when(condition) {
+    this.step.condition = condition;
+    return this;
+  }
+  /**
+   * Add metadata
+   */
+  withMetadata(metadata) {
+    this.step.metadata = metadata;
+    return this;
+  }
+  /**
+   * Build the step
+   */
+  build() {
+    if (!this.step.id || !this.step.name || this.step.daysAfterFailure === void 0) {
+      throw new Error("DunningStep requires id, name, and daysAfterFailure");
+    }
+    const result = {
+      id: this.step.id,
+      name: this.step.name,
+      daysAfterFailure: this.step.daysAfterFailure,
+      actions: this.step.actions || []
+    };
+    if (this.step.hoursOffset !== void 0) result.hoursOffset = this.step.hoursOffset;
+    if (this.step.notificationChannels !== void 0)
+      result.notificationChannels = this.step.notificationChannels;
+    if (this.step.notificationTemplateId !== void 0)
+      result.notificationTemplateId = this.step.notificationTemplateId;
+    if (this.step.retryPayment !== void 0) result.retryPayment = this.step.retryPayment;
+    if (this.step.accessLevel !== void 0) result.accessLevel = this.step.accessLevel;
+    if (this.step.isFinal !== void 0) result.isFinal = this.step.isFinal;
+    if (this.step.customAction !== void 0) result.customAction = this.step.customAction;
+    if (this.step.condition !== void 0) result.condition = this.step.condition;
+    if (this.step.metadata !== void 0) result.metadata = this.step.metadata;
+    return result;
+  }
+};
+function step(id, name) {
+  return new DunningStepBuilder(id, name);
+}
+var DunningSequenceBuilder = class {
+  sequence = {
+    steps: [],
+    isActive: true
+  };
+  constructor(id, name) {
+    this.sequence.id = id;
+    this.sequence.name = name;
+  }
+  /**
+   * Set description
+   */
+  describe(description) {
+    this.sequence.description = description;
+    return this;
+  }
+  /**
+   * Add steps
+   */
+  withSteps(...steps) {
+    this.sequence.steps = steps;
+    return this;
+  }
+  /**
+   * Set maximum duration before auto-cancel
+   */
+  maxDays(days) {
+    this.sequence.maxDurationDays = days;
+    return this;
+  }
+  /**
+   * Set active status
+   */
+  active(isActive = true) {
+    this.sequence.isActive = isActive;
+    return this;
+  }
+  /**
+   * Add metadata
+   */
+  withMetadata(metadata) {
+    this.sequence.metadata = metadata;
+    return this;
+  }
+  /**
+   * Build the sequence
+   */
+  build() {
+    if (!this.sequence.id || !this.sequence.name || !this.sequence.maxDurationDays) {
+      throw new Error("DunningSequence requires id, name, and maxDurationDays");
+    }
+    const sortedSteps = [...this.sequence.steps || []].sort(
+      (a, b) => a.daysAfterFailure - b.daysAfterFailure
+    );
+    const result = {
+      id: this.sequence.id,
+      name: this.sequence.name,
+      steps: sortedSteps,
+      maxDurationDays: this.sequence.maxDurationDays,
+      isActive: this.sequence.isActive ?? true
+    };
+    if (this.sequence.description !== void 0) result.description = this.sequence.description;
+    if (this.sequence.metadata !== void 0) result.metadata = this.sequence.metadata;
+    return result;
+  }
+};
+function sequence(id, name) {
+  return new DunningSequenceBuilder(id, name);
+}
+var standardSaasSequence = sequence("standard-saas", "Standard SaaS Dunning").describe("Standard 28-day dunning sequence for SaaS applications").maxDays(28).withSteps(
+  step("immediate-retry", "Immediate Retry").afterDays(0).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-payment-failed").retryPayment().build(),
+  step("day-1-reminder", "Day 1 Reminder").afterDays(1).atHour(10).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-reminder").retryPayment().build(),
+  step("day-3-warning", "Day 3 Warning").afterDays(3).atHour(10).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-warning").retryPayment().build(),
+  step("day-7-limit", "Day 7 Feature Limit").afterDays(7).atHour(10).withActions("retry_payment", "notify", "limit_features").notify("email", "in_app").withTemplate("dunning-feature-limit").retryPayment().setAccessLevel("limited").build(),
+  step("day-14-suspend", "Day 14 Suspension").afterDays(14).atHour(10).withActions("retry_payment", "notify", "suspend").notify("email", "in_app").withTemplate("dunning-suspension").retryPayment().setAccessLevel("read_only").build(),
+  step("day-21-final-warning", "Day 21 Final Warning").afterDays(21).atHour(10).withActions("notify").notify("email").withTemplate("dunning-final-warning").build(),
+  step("day-28-cancel", "Day 28 Cancellation").afterDays(28).atHour(10).withActions("notify", "cancel").notify("email").withTemplate("dunning-canceled").final().setAccessLevel("none").build()
+).build();
+var aggressiveSequence = sequence("aggressive", "Aggressive Dunning").describe("Aggressive 14-day dunning sequence").maxDays(14).withSteps(
+  step("immediate", "Immediate Retry").afterDays(0).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-payment-failed").retryPayment().build(),
+  step("day-1", "Day 1").afterDays(1).withActions("retry_payment", "notify").notify("email", "sms").withTemplate("dunning-urgent").retryPayment().build(),
+  step("day-3-limit", "Day 3 Limit").afterDays(3).withActions("retry_payment", "notify", "limit_features").notify("email", "in_app").withTemplate("dunning-feature-limit").retryPayment().setAccessLevel("limited").build(),
+  step("day-7-suspend", "Day 7 Suspend").afterDays(7).withActions("retry_payment", "notify", "suspend").notify("email", "sms", "in_app").withTemplate("dunning-suspension").retryPayment().setAccessLevel("read_only").build(),
+  step("day-14-cancel", "Day 14 Cancel").afterDays(14).withActions("notify", "cancel").notify("email").withTemplate("dunning-canceled").final().setAccessLevel("none").build()
+).build();
+var lenientSequence = sequence("lenient", "Lenient Dunning").describe("Lenient 45-day dunning sequence for enterprise customers").maxDays(45).withSteps(
+  step("immediate", "Immediate Retry").afterDays(0).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-payment-failed-enterprise").retryPayment().build(),
+  step("day-3", "Day 3 Reminder").afterDays(3).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-reminder-enterprise").retryPayment().build(),
+  step("day-7", "Day 7 Reminder").afterDays(7).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-reminder-enterprise").retryPayment().build(),
+  step("day-14", "Day 14 Warning").afterDays(14).withActions("retry_payment", "notify").notify("email", "in_app").withTemplate("dunning-warning-enterprise").retryPayment().build(),
+  step("day-21-limit", "Day 21 Feature Limit").afterDays(21).withActions("retry_payment", "notify", "limit_features").notify("email", "in_app").withTemplate("dunning-feature-limit-enterprise").retryPayment().setAccessLevel("limited").build(),
+  step("day-30-suspend", "Day 30 Suspension").afterDays(30).withActions("retry_payment", "notify", "suspend").notify("email", "in_app").withTemplate("dunning-suspension-enterprise").retryPayment().setAccessLevel("read_only").build(),
+  step("day-40-final", "Day 40 Final Warning").afterDays(40).withActions("notify").notify("email").withTemplate("dunning-final-warning-enterprise").build(),
+  step("day-45-cancel", "Day 45 Cancel").afterDays(45).withActions("notify", "cancel").notify("email").withTemplate("dunning-canceled-enterprise").final().setAccessLevel("none").build()
+).build();
+var minimalSequence = sequence("minimal", "Minimal Dunning").describe("Minimal 7-day dunning sequence").maxDays(7).withSteps(
+  step("immediate", "Immediate Retry").afterDays(0).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-payment-failed").retryPayment().build(),
+  step("day-3", "Day 3").afterDays(3).withActions("retry_payment", "notify").notify("email").withTemplate("dunning-reminder").retryPayment().build(),
+  step("day-7-cancel", "Day 7 Cancel").afterDays(7).withActions("notify", "cancel").notify("email").withTemplate("dunning-canceled").final().setAccessLevel("none").build()
+).build();
+var defaultSequences = {
+  standard: standardSaasSequence,
+  aggressive: aggressiveSequence,
+  lenient: lenientSequence,
+  minimal: minimalSequence
+};
+function getSequenceByTier(tier) {
+  if (tier >= 3) return lenientSequence;
+  if (tier >= 2) return standardSaasSequence;
+  if (tier >= 1) return aggressiveSequence;
+  return minimalSequence;
+}
+
+// src/dunning/payment-retry.ts
+var stripeErrorCodes = {
+  provider: "stripe",
+  codes: {
+    // Card declined
+    card_declined: "card_declined",
+    generic_decline: "card_declined",
+    do_not_honor: "card_declined",
+    transaction_not_allowed: "card_declined",
+    // Insufficient funds
+    insufficient_funds: "insufficient_funds",
+    // Card expired/invalid
+    expired_card: "card_expired",
+    invalid_expiry_month: "card_expired",
+    invalid_expiry_year: "card_expired",
+    invalid_number: "invalid_card",
+    invalid_cvc: "invalid_card",
+    incorrect_number: "invalid_card",
+    incorrect_cvc: "invalid_card",
+    // Processing errors (retry immediately)
+    processing_error: "processing_error",
+    try_again_later: "processing_error",
+    bank_not_supported: "processing_error",
+    // Authentication required
+    authentication_required: "authentication_required",
+    card_not_supported: "authentication_required",
+    // Fraud
+    fraudulent: "fraud_suspected",
+    merchant_blacklist: "fraud_suspected",
+    stolen_card: "fraud_suspected",
+    lost_card: "fraud_suspected",
+    // Rate limits
+    rate_limit: "velocity_exceeded"
+  }
+};
+var paddleErrorCodes = {
+  provider: "paddle",
+  codes: {
+    declined: "card_declined",
+    insufficient_funds: "insufficient_funds",
+    card_expired: "card_expired",
+    invalid_card: "invalid_card",
+    processing_error: "processing_error",
+    authentication_required: "authentication_required",
+    fraud: "fraud_suspected"
+  }
+};
+var iyzicoErrorCodes = {
+  provider: "iyzico",
+  codes: {
+    // Turkish bank error codes
+    "10051": "insufficient_funds",
+    // Yetersiz bakiye
+    "10054": "card_expired",
+    // Süresi dolmuş kart
+    "10057": "card_declined",
+    // İşlem onaylanmadı
+    "10005": "invalid_card",
+    // Geçersiz kart
+    "10012": "invalid_card",
+    // Geçersiz işlem
+    "10041": "fraud_suspected",
+    // Kayıp kart
+    "10043": "fraud_suspected",
+    // Çalıntı kart
+    "10058": "card_declined",
+    // Terminal işlem yapma yetkisi yok
+    "10034": "fraud_suspected"
+    // Dolandırıcılık şüphesi
+  }
+};
+var allErrorCodeMappings = [
+  stripeErrorCodes,
+  paddleErrorCodes,
+  iyzicoErrorCodes
+];
+var defaultRetryStrategies = [
+  {
+    category: "card_declined",
+    shouldRetry: true,
+    initialDelayHours: 24,
+    // Wait a day
+    maxRetries: 4,
+    backoffMultiplier: 2,
+    maxDelayHours: 168,
+    // 1 week max
+    optimalRetryHours: [10, 14, 18],
+    // Business hours
+    optimalRetryDays: [1, 2, 3, 4, 5]
+    // Weekdays
+  },
+  {
+    category: "insufficient_funds",
+    shouldRetry: true,
+    initialDelayHours: 72,
+    // Wait until likely payday
+    maxRetries: 4,
+    backoffMultiplier: 1.5,
+    maxDelayHours: 168,
+    // Optimal times: end of month, mid-month (paydays)
+    optimalRetryDays: [0, 1, 15, 16, 28, 29, 30, 31].map((d) => d % 7)
+    // Around paydays
+  },
+  {
+    category: "card_expired",
+    shouldRetry: false,
+    // Don't retry - needs card update
+    initialDelayHours: 0,
+    maxRetries: 0,
+    backoffMultiplier: 1,
+    maxDelayHours: 0
+  },
+  {
+    category: "invalid_card",
+    shouldRetry: false,
+    // Don't retry - needs card update
+    initialDelayHours: 0,
+    maxRetries: 0,
+    backoffMultiplier: 1,
+    maxDelayHours: 0
+  },
+  {
+    category: "processing_error",
+    shouldRetry: true,
+    initialDelayHours: 1,
+    // Retry soon
+    maxRetries: 5,
+    backoffMultiplier: 2,
+    maxDelayHours: 24
+  },
+  {
+    category: "authentication_required",
+    shouldRetry: false,
+    // Needs customer action (3DS)
+    initialDelayHours: 0,
+    maxRetries: 0,
+    backoffMultiplier: 1,
+    maxDelayHours: 0
+  },
+  {
+    category: "fraud_suspected",
+    shouldRetry: false,
+    // Never retry fraud
+    initialDelayHours: 0,
+    maxRetries: 0,
+    backoffMultiplier: 1,
+    maxDelayHours: 0
+  },
+  {
+    category: "velocity_exceeded",
+    shouldRetry: true,
+    initialDelayHours: 6,
+    // Wait for rate limit reset
+    maxRetries: 3,
+    backoffMultiplier: 2,
+    maxDelayHours: 48
+  },
+  {
+    category: "unknown",
+    shouldRetry: true,
+    // Cautious retry
+    initialDelayHours: 24,
+    maxRetries: 2,
+    backoffMultiplier: 2,
+    maxDelayHours: 72
+  }
+];
+var PaymentRetryCalculator = class {
+  strategies;
+  errorMappings;
+  logger;
+  constructor(strategies = defaultRetryStrategies, errorMappings = allErrorCodeMappings, logger) {
+    this.strategies = new Map(strategies.map((s) => [s.category, s]));
+    this.errorMappings = /* @__PURE__ */ new Map();
+    if (logger) {
+      this.logger = logger;
+    }
+    for (const mapping of errorMappings) {
+      this.errorMappings.set(mapping.provider, new Map(Object.entries(mapping.codes)));
+    }
+  }
+  /**
+   * Map error code to failure category
+   */
+  categorizeError(provider, errorCode) {
+    const providerMapping = this.errorMappings.get(provider.toLowerCase());
+    if (providerMapping) {
+      const category = providerMapping.get(errorCode.toLowerCase());
+      if (category) return category;
+    }
+    return "unknown";
+  }
+  /**
+   * Get retry strategy for failure category
+   */
+  getStrategy(category) {
+    return this.strategies.get(category) ?? {
+      category: "unknown",
+      shouldRetry: true,
+      initialDelayHours: 24,
+      maxRetries: 2,
+      backoffMultiplier: 2,
+      maxDelayHours: 72
+    };
+  }
+  /**
+   * Check if a failure should be retried
+   */
+  shouldRetry(failure) {
+    const strategy = this.getStrategy(failure.category);
+    if (!strategy.shouldRetry) {
+      this.logger?.debug("Retry not allowed for category", {
+        category: failure.category,
+        failureId: failure.id
+      });
+      return false;
+    }
+    if (failure.retryCount >= strategy.maxRetries) {
+      this.logger?.debug("Max retries reached", {
+        category: failure.category,
+        retryCount: failure.retryCount,
+        maxRetries: strategy.maxRetries
+      });
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Calculate next retry time
+   */
+  calculateNextRetry(failure) {
+    if (!this.shouldRetry(failure)) {
+      return null;
+    }
+    const strategy = this.getStrategy(failure.category);
+    const baseDelay = strategy.initialDelayHours;
+    const multiplier = Math.pow(strategy.backoffMultiplier, failure.retryCount);
+    let delayHours = Math.min(baseDelay * multiplier, strategy.maxDelayHours);
+    let retryTime = new Date(failure.failedAt.getTime() + delayHours * 60 * 60 * 1e3);
+    retryTime = this.optimizeRetryTime(retryTime, strategy);
+    this.logger?.debug("Calculated next retry time", {
+      failureId: failure.id,
+      category: failure.category,
+      retryCount: failure.retryCount,
+      delayHours,
+      nextRetry: retryTime.toISOString()
+    });
+    return retryTime;
+  }
+  /**
+   * Optimize retry time based on strategy
+   */
+  optimizeRetryTime(baseTime, strategy) {
+    const optimalHours = strategy.optimalRetryHours;
+    const optimalDays = strategy.optimalRetryDays;
+    if (!optimalHours?.length && !optimalDays?.length) {
+      return baseTime;
+    }
+    let optimizedTime = new Date(baseTime);
+    if (optimalHours?.length) {
+      const currentHour = optimizedTime.getHours();
+      const nearestOptimalHour = this.findNearestValue(currentHour, optimalHours);
+      if (nearestOptimalHour !== currentHour) {
+        optimizedTime.setHours(nearestOptimalHour, 0, 0, 0);
+        if (nearestOptimalHour < currentHour) {
+          optimizedTime.setDate(optimizedTime.getDate() + 1);
+        }
+      }
+    }
+    if (optimalDays?.length) {
+      const currentDay = optimizedTime.getDay();
+      const nearestOptimalDay = this.findNearestValue(currentDay, optimalDays);
+      if (nearestOptimalDay !== currentDay) {
+        const daysToAdd = (nearestOptimalDay - currentDay + 7) % 7;
+        optimizedTime.setDate(optimizedTime.getDate() + (daysToAdd || 7));
+      }
+    }
+    if (optimizedTime < baseTime) {
+      return baseTime;
+    }
+    return optimizedTime;
+  }
+  /**
+   * Find nearest value in array
+   */
+  findNearestValue(current, values) {
+    const firstValue = values[0];
+    if (firstValue === void 0) {
+      return current;
+    }
+    let nearest = firstValue;
+    let minDiff = Math.abs(current - nearest);
+    for (const value of values) {
+      const diff = Math.abs(current - value);
+      if (diff < minDiff) {
+        minDiff = diff;
+        nearest = value;
+      }
+    }
+    return nearest;
+  }
+  /**
+   * Check if failure is recoverable (can be retried eventually)
+   */
+  isRecoverable(category) {
+    const strategy = this.getStrategy(category);
+    return strategy.shouldRetry;
+  }
+  /**
+   * Get recommendation message for failure category
+   */
+  getRecommendation(category) {
+    switch (category) {
+      case "card_declined":
+        return "The payment was declined. We'll retry automatically.";
+      case "insufficient_funds":
+        return "There were insufficient funds. We'll retry around payday.";
+      case "card_expired":
+        return "Your card has expired. Please update your payment method.";
+      case "invalid_card":
+        return "The card information is invalid. Please update your payment method.";
+      case "processing_error":
+        return "A temporary processing error occurred. We'll retry shortly.";
+      case "authentication_required":
+        return "Additional authentication is required. Please complete the payment manually.";
+      case "fraud_suspected":
+        return "The payment was flagged. Please contact your bank or use a different card.";
+      case "velocity_exceeded":
+        return "Too many payment attempts. We'll retry later.";
+      default:
+        return "An error occurred. We'll retry the payment.";
+    }
+  }
+};
+var PaymentRetrier = class {
+  calculator;
+  retryPayment;
+  logger;
+  maxSessionRetries;
+  constructor(config) {
+    this.calculator = config.calculator ?? new PaymentRetryCalculator(void 0, void 0, config.logger);
+    this.retryPayment = config.retryPayment;
+    if (config.logger) {
+      this.logger = config.logger;
+    }
+    this.maxSessionRetries = config.maxSessionRetries ?? 10;
+  }
+  /**
+   * Attempt to retry a payment
+   */
+  async retry(context) {
+    const failure = context.latestFailure;
+    if (!this.calculator.shouldRetry(failure)) {
+      this.logger?.info("Payment retry skipped - not recoverable", {
+        failureId: failure.id,
+        category: failure.category,
+        reason: this.calculator.getRecommendation(failure.category)
+      });
+      return {
+        success: false,
+        failure,
+        attemptedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    if (context.state.totalRetryAttempts >= this.maxSessionRetries) {
+      this.logger?.warn("Payment retry skipped - session limit reached", {
+        customerId: context.customer.id,
+        totalAttempts: context.state.totalRetryAttempts,
+        maxAttempts: this.maxSessionRetries
+      });
+      return {
+        success: false,
+        failure,
+        attemptedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    this.logger?.info("Attempting payment retry", {
+      failureId: failure.id,
+      customerId: context.customer.id,
+      amount: failure.amount,
+      retryCount: failure.retryCount
+    });
+    try {
+      const result = await this.retryPayment(context);
+      if (result.success) {
+        this.logger?.info("Payment retry successful", {
+          failureId: failure.id,
+          transactionId: result.transactionId
+        });
+      } else {
+        this.logger?.info("Payment retry failed", {
+          failureId: failure.id,
+          newFailure: result.failure
+        });
+      }
+      return result;
+    } catch (error) {
+      this.logger?.error("Payment retry error", {
+        failureId: failure.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        failure,
+        attemptedAt: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  /**
+   * Get next retry time for a failure
+   */
+  getNextRetryTime(failure) {
+    return this.calculator.calculateNextRetry(failure);
+  }
+  /**
+   * Check if failure is recoverable
+   */
+  isRecoverable(failure) {
+    return this.calculator.isRecoverable(failure.category);
+  }
+  /**
+   * Categorize an error code
+   */
+  categorizeError(provider, errorCode) {
+    return this.calculator.categorizeError(provider, errorCode);
+  }
+};
+function createPaymentRetryCalculator(strategies, errorMappings, logger) {
+  return new PaymentRetryCalculator(strategies, errorMappings, logger);
+}
+function createPaymentRetrier(config) {
+  return new PaymentRetrier(config);
+}
+
+// src/dunning/dunning-manager.ts
+var DunningManager = class {
+  config;
+  storage;
+  eventHandlers = [];
+  logger;
+  constructor(config, storage) {
+    this.config = config;
+    this.storage = storage;
+    if (config.logger) {
+      this.logger = config.logger;
+    }
+    if (config.onEvent) {
+      this.eventHandlers.push(config.onEvent);
+    }
+  }
+  // ============================================================================
+  // Dunning Lifecycle
+  // ============================================================================
+  /**
+   * Start dunning process for a payment failure
+   */
+  async startDunning(failure) {
+    const existingState = await this.storage.getDunningState(failure.customerId);
+    if (existingState && existingState.status === "active") {
+      this.logger?.info("Dunning already active, adding failure", {
+        customerId: failure.customerId,
+        dunningId: existingState.id
+      });
+      existingState.failures.push(failure);
+      await this.storage.updateDunningState(existingState.id, {
+        failures: existingState.failures
+      });
+      return existingState;
+    }
+    const sequence2 = await this.getSequenceForCustomer(failure.customerId);
+    const firstStep = sequence2.steps[0];
+    if (!firstStep) {
+      throw new Error(`Dunning sequence ${sequence2.id} has no steps`);
+    }
+    const state = {
+      id: this.generateId(),
+      customerId: failure.customerId,
+      subscriptionId: failure.subscriptionId,
+      sequenceId: sequence2.id,
+      currentStepIndex: 0,
+      currentStepId: firstStep.id,
+      status: "active",
+      initialFailure: failure,
+      failures: [failure],
+      executedSteps: [],
+      startedAt: /* @__PURE__ */ new Date(),
+      nextStepAt: this.calculateStepTime(firstStep, failure.failedAt),
+      totalRetryAttempts: 0
+    };
+    await this.storage.saveDunningState(state);
+    await this.storage.recordPaymentFailure(failure);
+    await this.emitEvent({
+      type: "dunning.started",
+      customerId: state.customerId,
+      subscriptionId: state.subscriptionId,
+      dunningStateId: state.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        sequenceId: sequence2.id,
+        initialFailure: failure
+      }
+    });
+    this.logger?.info("Dunning started", {
+      customerId: state.customerId,
+      dunningId: state.id,
+      sequenceId: sequence2.id
+    });
+    return state;
+  }
+  /**
+   * Execute the next step in dunning sequence
+   */
+  async executeStep(stateId) {
+    const state = await this.getDunningStateById(stateId);
+    if (!state || state.status !== "active") {
+      this.logger?.warn("Cannot execute step - invalid state", {
+        stateId,
+        status: state?.status
+      });
+      return null;
+    }
+    const sequence2 = this.getSequence(state.sequenceId);
+    const step2 = sequence2.steps[state.currentStepIndex];
+    if (!step2) {
+      this.logger?.warn("No step found at index", {
+        stateId,
+        stepIndex: state.currentStepIndex
+      });
+      return null;
+    }
+    const context = await this.buildContext(state, step2);
+    if (step2.condition) {
+      const shouldExecute = await step2.condition(context);
+      if (!shouldExecute) {
+        this.logger?.info("Step condition not met, skipping", {
+          stateId,
+          stepId: step2.id
+        });
+        return this.advanceToNextStep(state);
+      }
+    }
+    const executedStep = await this.performStepActions(context, step2);
+    state.executedSteps.push(executedStep);
+    state.lastStepAt = executedStep.executedAt;
+    state.totalRetryAttempts += executedStep.paymentRetried ? 1 : 0;
+    if (executedStep.paymentSucceeded) {
+      await this.recoverDunning(state, "payment_recovered");
+      return executedStep;
+    }
+    if (step2.isFinal) {
+      await this.exhaustDunning(state);
+      return executedStep;
+    }
+    await this.advanceToNextStep(state);
+    return executedStep;
+  }
+  /**
+   * Recover from dunning (payment successful)
+   */
+  async recoverDunning(stateOrId, reason = "payment_recovered") {
+    const state = typeof stateOrId === "string" ? await this.getDunningStateById(stateOrId) : stateOrId;
+    if (!state) return;
+    state.status = "recovered";
+    state.endedAt = /* @__PURE__ */ new Date();
+    state.endReason = reason;
+    await this.storage.updateDunningState(state.id, {
+      status: state.status,
+      endedAt: state.endedAt,
+      endReason: state.endReason
+    });
+    if (this.config.onAccessUpdate) {
+      await this.config.onAccessUpdate(state.customerId, "full");
+    }
+    await this.emitEvent({
+      type: "dunning.payment_recovered",
+      customerId: state.customerId,
+      subscriptionId: state.subscriptionId,
+      dunningStateId: state.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: { reason }
+    });
+    this.logger?.info("Dunning recovered", {
+      dunningId: state.id,
+      customerId: state.customerId
+    });
+  }
+  /**
+   * Pause dunning process
+   */
+  async pauseDunning(stateId) {
+    await this.storage.updateDunningState(stateId, {
+      status: "paused"
+    });
+    const state = await this.getDunningStateById(stateId);
+    if (state) {
+      await this.emitEvent({
+        type: "dunning.paused",
+        customerId: state.customerId,
+        subscriptionId: state.subscriptionId,
+        dunningStateId: state.id,
+        timestamp: /* @__PURE__ */ new Date(),
+        data: {}
+      });
+    }
+  }
+  /**
+   * Resume paused dunning
+   */
+  async resumeDunning(stateId) {
+    const state = await this.getDunningStateById(stateId);
+    if (!state || state.status !== "paused") return;
+    const sequence2 = this.getSequence(state.sequenceId);
+    const step2 = sequence2.steps[state.currentStepIndex];
+    const updates = { status: "active" };
+    if (step2) {
+      updates.nextStepAt = this.calculateStepTime(step2, /* @__PURE__ */ new Date());
+    }
+    await this.storage.updateDunningState(stateId, updates);
+    await this.emitEvent({
+      type: "dunning.resumed",
+      customerId: state.customerId,
+      subscriptionId: state.subscriptionId,
+      dunningStateId: state.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {}
+    });
+  }
+  /**
+   * Cancel dunning manually
+   */
+  async cancelDunning(stateId, reason) {
+    const state = await this.getDunningStateById(stateId);
+    if (!state) return;
+    state.status = "canceled";
+    state.endedAt = /* @__PURE__ */ new Date();
+    state.endReason = "manually_canceled";
+    await this.storage.updateDunningState(stateId, {
+      status: state.status,
+      endedAt: state.endedAt,
+      endReason: state.endReason,
+      metadata: { ...state.metadata, cancelReason: reason }
+    });
+    await this.emitEvent({
+      type: "dunning.canceled",
+      customerId: state.customerId,
+      subscriptionId: state.subscriptionId,
+      dunningStateId: state.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: { reason }
+    });
+  }
+  // ============================================================================
+  // State Queries
+  // ============================================================================
+  /**
+   * Get dunning state by customer ID
+   */
+  async getDunningState(customerId) {
+    return this.storage.getDunningState(customerId);
+  }
+  /**
+   * Get dunning state by ID
+   */
+  async getDunningStateById(stateId) {
+    const states = await this.storage.getActiveDunningStates();
+    return states.find((s) => s.id === stateId) ?? null;
+  }
+  /**
+   * Get all active dunning states
+   */
+  async getActiveDunningStates() {
+    return this.storage.getActiveDunningStates();
+  }
+  /**
+   * Get dunning states by status
+   */
+  async getDunningStatesByStatus(status) {
+    return this.storage.getDunningStatesByStatus(status);
+  }
+  /**
+   * Get scheduled steps due for execution
+   */
+  async getScheduledSteps(before) {
+    return this.storage.getScheduledSteps(before);
+  }
+  // ============================================================================
+  // Events
+  // ============================================================================
+  /**
+   * Register event handler
+   */
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+    return this;
+  }
+  /**
+   * Emit dunning event
+   */
+  async emitEvent(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        await handler(event);
+      } catch (error) {
+        this.logger?.error("Event handler error", {
+          eventType: event.type,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  // ============================================================================
+  // Internal Methods
+  // ============================================================================
+  /**
+   * Perform step actions
+   */
+  async performStepActions(context, step2) {
+    const executed = {
+      stepId: step2.id,
+      stepName: step2.name,
+      executedAt: /* @__PURE__ */ new Date(),
+      actionsTaken: [],
+      paymentRetried: false,
+      notificationsSent: []
+    };
+    for (const action of step2.actions) {
+      try {
+        switch (action) {
+          case "notify":
+            const notifyResults = await this.sendNotifications(context, step2);
+            executed.notificationsSent = notifyResults.filter((r) => r.success).map((r) => r.channel);
+            executed.actionsTaken.push("notify");
+            break;
+          case "retry_payment":
+            if (this.config.onRetryPayment) {
+              const retryResult = await this.config.onRetryPayment(context);
+              executed.paymentRetried = true;
+              executed.paymentSucceeded = retryResult.success;
+              executed.actionsTaken.push("retry_payment");
+              await this.emitEvent({
+                type: "dunning.payment_retried",
+                customerId: context.customer.id,
+                subscriptionId: context.subscription.id,
+                dunningStateId: context.state.id,
+                timestamp: /* @__PURE__ */ new Date(),
+                data: {
+                  success: retryResult.success,
+                  transactionId: retryResult.transactionId
+                }
+              });
+              if (retryResult.success) {
+                return executed;
+              }
+            }
+            break;
+          case "limit_features":
+            if (this.config.onAccessUpdate && step2.accessLevel) {
+              await this.config.onAccessUpdate(context.customer.id, step2.accessLevel);
+              executed.actionsTaken.push("limit_features");
+              await this.emitEvent({
+                type: "dunning.access_limited",
+                customerId: context.customer.id,
+                subscriptionId: context.subscription.id,
+                dunningStateId: context.state.id,
+                timestamp: /* @__PURE__ */ new Date(),
+                data: { accessLevel: step2.accessLevel }
+              });
+            }
+            break;
+          case "suspend":
+            if (this.config.onAccessUpdate) {
+              await this.config.onAccessUpdate(context.customer.id, "read_only");
+              executed.actionsTaken.push("suspend");
+              await this.emitEvent({
+                type: "dunning.suspended",
+                customerId: context.customer.id,
+                subscriptionId: context.subscription.id,
+                dunningStateId: context.state.id,
+                timestamp: /* @__PURE__ */ new Date(),
+                data: {}
+              });
+            }
+            break;
+          case "cancel":
+            if (this.config.onCancelSubscription) {
+              await this.config.onCancelSubscription(
+                context.subscription.id,
+                "dunning_exhausted"
+              );
+              executed.actionsTaken.push("cancel");
+            }
+            break;
+          case "custom":
+            if (step2.customAction) {
+              await step2.customAction(context);
+              executed.actionsTaken.push("custom");
+            }
+            break;
+        }
+      } catch (error) {
+        this.logger?.error("Step action failed", {
+          stepId: step2.id,
+          action,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        executed.error = error instanceof Error ? error.message : String(error);
+      }
+    }
+    await this.emitEvent({
+      type: "dunning.step_executed",
+      customerId: context.customer.id,
+      subscriptionId: context.subscription.id,
+      dunningStateId: context.state.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        stepId: step2.id,
+        stepName: step2.name,
+        actionsTaken: executed.actionsTaken
+      }
+    });
+    return executed;
+  }
+  /**
+   * Send notifications for a step
+   */
+  async sendNotifications(context, step2) {
+    if (!step2.notificationChannels?.length || !this.config.onNotification) {
+      return [];
+    }
+    const results = [];
+    for (const channel of step2.notificationChannels) {
+      const recipient = {
+        customerId: context.customer.id
+      };
+      if (context.customer.email) {
+        recipient.email = context.customer.email;
+      }
+      const variables = {
+        amount: context.amountOwed,
+        currency: context.currency,
+        daysSinceFailure: context.daysSinceFailure
+      };
+      if (context.customer.name) {
+        variables.customerName = context.customer.name;
+      }
+      if (this.config.urls?.updatePayment) {
+        variables.updatePaymentUrl = this.config.urls.updatePayment;
+      }
+      if (this.config.urls?.viewInvoice) {
+        variables.invoiceUrl = this.config.urls.viewInvoice;
+      }
+      if (this.config.urls?.support) {
+        variables.supportUrl = this.config.urls.support;
+      }
+      const notification = {
+        channel,
+        templateId: step2.notificationTemplateId ?? `dunning-${step2.id}`,
+        recipient,
+        variables,
+        context
+      };
+      try {
+        const result = await this.config.onNotification(notification);
+        results.push(result);
+        if (result.success) {
+          await this.emitEvent({
+            type: "dunning.notification_sent",
+            customerId: context.customer.id,
+            subscriptionId: context.subscription.id,
+            dunningStateId: context.state.id,
+            timestamp: /* @__PURE__ */ new Date(),
+            data: {
+              channel,
+              templateId: notification.templateId
+            }
+          });
+        }
+      } catch (error) {
+        results.push({
+          success: false,
+          channel,
+          error: error instanceof Error ? error.message : String(error),
+          sentAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Advance to next step
+   */
+  async advanceToNextStep(state) {
+    const sequence2 = this.getSequence(state.sequenceId);
+    const nextIndex = state.currentStepIndex + 1;
+    if (nextIndex >= sequence2.steps.length) {
+      await this.exhaustDunning(state);
+      return null;
+    }
+    const nextStep = sequence2.steps[nextIndex];
+    if (!nextStep) {
+      await this.exhaustDunning(state);
+      return null;
+    }
+    const nextStepTime = this.calculateStepTime(nextStep, state.startedAt);
+    await this.storage.updateDunningState(state.id, {
+      currentStepIndex: nextIndex,
+      currentStepId: nextStep.id,
+      nextStepAt: nextStepTime
+    });
+    await this.storage.scheduleStep(state.id, nextStep.id, nextStepTime);
+    return null;
+  }
+  /**
+   * Mark dunning as exhausted (all steps completed without recovery)
+   */
+  async exhaustDunning(state) {
+    state.status = "exhausted";
+    state.endedAt = /* @__PURE__ */ new Date();
+    state.endReason = "max_retries";
+    await this.storage.updateDunningState(state.id, {
+      status: state.status,
+      endedAt: state.endedAt,
+      endReason: state.endReason
+    });
+    await this.emitEvent({
+      type: "dunning.exhausted",
+      customerId: state.customerId,
+      subscriptionId: state.subscriptionId,
+      dunningStateId: state.id,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        totalRetries: state.totalRetryAttempts,
+        stepsExecuted: state.executedSteps.length
+      }
+    });
+    this.logger?.info("Dunning exhausted", {
+      dunningId: state.id,
+      customerId: state.customerId
+    });
+  }
+  /**
+   * Build dunning context for step execution
+   */
+  async buildContext(state, step2) {
+    const latestFailure = state.failures[state.failures.length - 1] ?? state.initialFailure;
+    const customer = {
+      id: state.customerId
+    };
+    const customerEmail = state.metadata?.["customerEmail"];
+    if (typeof customerEmail === "string") {
+      customer.email = customerEmail;
+    }
+    const customerName = state.metadata?.["customerName"];
+    if (typeof customerName === "string") {
+      customer.name = customerName;
+    }
+    const customerMetadata = state.metadata?.["customer"];
+    if (customerMetadata && typeof customerMetadata === "object") {
+      customer.metadata = customerMetadata;
+    }
+    const subscription = {
+      id: state.subscriptionId,
+      status: "past_due"
+    };
+    const planId = state.metadata?.["planId"];
+    if (typeof planId === "string") {
+      subscription.planId = planId;
+    }
+    return {
+      state,
+      step: step2,
+      latestFailure,
+      customer,
+      subscription,
+      daysSinceFailure: Math.floor(
+        (Date.now() - state.initialFailure.failedAt.getTime()) / (1e3 * 60 * 60 * 24)
+      ),
+      amountOwed: state.failures.reduce((sum, f) => sum + f.amount, 0),
+      currency: latestFailure.currency
+    };
+  }
+  /**
+   * Calculate when a step should execute
+   */
+  calculateStepTime(step2, baseTime) {
+    const time = new Date(baseTime);
+    time.setDate(time.getDate() + step2.daysAfterFailure);
+    if (step2.hoursOffset !== void 0) {
+      time.setHours(step2.hoursOffset, 0, 0, 0);
+    }
+    return time;
+  }
+  /**
+   * Get sequence for a customer (by tier if configured)
+   */
+  async getSequenceForCustomer(_customerId) {
+    return this.config.defaultSequence;
+  }
+  /**
+   * Get sequence by ID
+   */
+  getSequence(sequenceId) {
+    if (sequenceId === this.config.defaultSequence.id) {
+      return this.config.defaultSequence;
+    }
+    if (this.config.sequencesByPlanTier) {
+      for (const seq of Object.values(this.config.sequencesByPlanTier)) {
+        if (seq.id === sequenceId) return seq;
+      }
+    }
+    return this.config.defaultSequence;
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `dun_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+};
+function createDunningManager(config, storage) {
+  return new DunningManager(config, storage);
+}
+function createDefaultDunningConfig(overrides) {
+  return {
+    defaultSequence: standardSaasSequence,
+    ...overrides
+  };
+}
+
+// src/dunning/dunning-scheduler.ts
+var DunningScheduler = class {
+  manager;
+  pollInterval;
+  batchSize;
+  maxConcurrent;
+  logger;
+  onError;
+  beforeStep;
+  afterStep;
+  isRunning = false;
+  pollTimer;
+  processingStates = /* @__PURE__ */ new Set();
+  /** Timezone for scheduling (reserved for future use) */
+  timezone;
+  constructor(config) {
+    this.manager = config.manager;
+    this.pollInterval = config.pollInterval ?? 6e4;
+    this.batchSize = config.batchSize ?? 50;
+    this.maxConcurrent = config.maxConcurrent ?? 5;
+    this.timezone = config.timezone ?? "UTC";
+    if (config.logger) {
+      this.logger = config.logger;
+    }
+    if (config.onError) {
+      this.onError = config.onError;
+    }
+    if (config.beforeStep) {
+      this.beforeStep = config.beforeStep;
+    }
+    if (config.afterStep) {
+      this.afterStep = config.afterStep;
+    }
+  }
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  /**
+   * Start the scheduler
+   */
+  start() {
+    if (this.isRunning) {
+      this.logger?.warn("Scheduler already running");
+      return;
+    }
+    this.isRunning = true;
+    this.logger?.info("Dunning scheduler started", {
+      pollInterval: this.pollInterval,
+      batchSize: this.batchSize,
+      maxConcurrent: this.maxConcurrent
+    });
+    this.poll();
+  }
+  /**
+   * Stop the scheduler
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      delete this.pollTimer;
+    }
+    this.logger?.info("Dunning scheduler stopped");
+  }
+  /**
+   * Check if scheduler is running
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * Get current processing count
+   */
+  get processingCount() {
+    return this.processingStates.size;
+  }
+  // ============================================================================
+  // Processing
+  // ============================================================================
+  /**
+   * Poll for scheduled steps
+   */
+  async poll() {
+    if (!this.isRunning) return;
+    try {
+      await this.processScheduledSteps();
+    } catch (error) {
+      this.logger?.error("Poll error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    if (this.isRunning) {
+      this.pollTimer = setTimeout(() => this.poll(), this.pollInterval);
+    }
+  }
+  /**
+   * Process all scheduled steps that are due
+   */
+  async processScheduledSteps() {
+    const now = /* @__PURE__ */ new Date();
+    const scheduled = await this.manager.getScheduledSteps(now);
+    if (scheduled.length === 0) {
+      return 0;
+    }
+    this.logger?.debug("Found scheduled steps", {
+      count: scheduled.length,
+      before: now.toISOString()
+    });
+    const toProcess = scheduled.filter((s) => !this.processingStates.has(s.stateId)).slice(0, this.batchSize);
+    if (toProcess.length === 0) {
+      return 0;
+    }
+    let processed = 0;
+    const batches = this.chunk(toProcess, this.maxConcurrent);
+    for (const batch of batches) {
+      const results = await Promise.allSettled(
+        batch.map((item) => this.executeScheduledStep(item.stateId, item.stepId))
+      );
+      processed += results.filter((r) => r.status === "fulfilled").length;
+    }
+    return processed;
+  }
+  /**
+   * Execute a single scheduled step
+   */
+  async executeScheduledStep(stateId, stepId) {
+    this.processingStates.add(stateId);
+    try {
+      if (this.beforeStep) {
+        await this.beforeStep(stateId, stepId);
+      }
+      this.logger?.debug("Executing scheduled step", { stateId, stepId });
+      const result = await this.manager.executeStep(stateId);
+      const success = result !== null;
+      this.logger?.info("Scheduled step executed", {
+        stateId,
+        stepId,
+        success,
+        actionsTaken: result?.actionsTaken
+      });
+      if (this.afterStep) {
+        await this.afterStep(stateId, stepId, success);
+      }
+    } catch (error) {
+      this.logger?.error("Step execution failed", {
+        stateId,
+        stepId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (this.onError) {
+        await this.onError(error instanceof Error ? error : new Error(String(error)), stateId);
+      }
+    } finally {
+      this.processingStates.delete(stateId);
+    }
+  }
+  /**
+   * Manually trigger processing (for testing or cron jobs)
+   */
+  async trigger() {
+    return this.processScheduledSteps();
+  }
+  /**
+   * Process a specific dunning state immediately
+   */
+  async processNow(stateId) {
+    const state = await this.manager.getDunningState(stateId);
+    if (!state) {
+      this.logger?.warn("State not found for immediate processing", { stateId });
+      return false;
+    }
+    try {
+      await this.executeScheduledStep(state.id, state.currentStepId);
+      return true;
+    } catch (error) {
+      this.logger?.error("Immediate processing failed", {
+        stateId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  /**
+   * Split array into chunks
+   */
+  chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+function createDunningScheduler(config) {
+  return new DunningScheduler(config);
+}
+function createDunningCronHandler(manager, options) {
+  return async () => {
+    const config = {
+      manager,
+      batchSize: options?.batchSize ?? 100,
+      maxConcurrent: options?.maxConcurrent ?? 10
+    };
+    if (options?.logger) {
+      config.logger = options.logger;
+    }
+    const scheduler = new DunningScheduler(config);
+    let errors = 0;
+    const originalOnError = scheduler["onError"];
+    scheduler["onError"] = async (error, stateId) => {
+      errors++;
+      if (originalOnError) await originalOnError(error, stateId);
+    };
+    const processed = await scheduler.trigger();
+    return { processed, errors };
+  };
+}
+function createDunningEdgeHandler(manager, options) {
+  const maxDuration = options?.maxDurationMs ?? 3e4;
+  const batchSize = options?.batchSize ?? 25;
+  return async () => {
+    const startTime = Date.now();
+    let processed = 0;
+    let errors = 0;
+    let timedOut = false;
+    const now = /* @__PURE__ */ new Date();
+    const scheduled = await manager.getScheduledSteps(now);
+    for (let i = 0; i < scheduled.length; i += batchSize) {
+      if (Date.now() - startTime > maxDuration) {
+        timedOut = true;
+        options?.logger?.warn("Edge handler timed out", {
+          processed,
+          remaining: scheduled.length - i
+        });
+        break;
+      }
+      const batch = scheduled.slice(i, i + batchSize);
+      const results = await Promise.allSettled(
+        batch.map(async (item) => {
+          try {
+            await manager.executeStep(item.stateId);
+            return true;
+          } catch (error) {
+            options?.logger?.error("Step execution error", {
+              stateId: item.stateId,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          }
+        })
+      );
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          processed++;
+        } else {
+          errors++;
+        }
+      }
+    }
+    const duration = Date.now() - startTime;
+    return { processed, errors, duration, timedOut };
+  };
+}
+
+// src/dunning/memory-storage.ts
+var MemoryDunningStorage = class {
+  states = /* @__PURE__ */ new Map();
+  failures = /* @__PURE__ */ new Map();
+  scheduledSteps = [];
+  // ============================================================================
+  // Dunning State Methods
+  // ============================================================================
+  async getDunningState(customerId) {
+    for (const state of this.states.values()) {
+      if (state.customerId === customerId) {
+        return state;
+      }
+    }
+    return null;
+  }
+  async getActiveDunningStates() {
+    return Array.from(this.states.values()).filter((s) => s.status === "active");
+  }
+  async getDunningStatesByStatus(status) {
+    return Array.from(this.states.values()).filter((s) => s.status === status);
+  }
+  async saveDunningState(state) {
+    this.states.set(state.id, { ...state });
+  }
+  async updateDunningState(id, updates) {
+    const state = this.states.get(id);
+    if (state) {
+      this.states.set(id, { ...state, ...updates });
+    }
+  }
+  // ============================================================================
+  // Payment Failure Methods
+  // ============================================================================
+  async recordPaymentFailure(failure) {
+    const customerFailures = this.failures.get(failure.customerId) ?? [];
+    customerFailures.push({ ...failure });
+    this.failures.set(failure.customerId, customerFailures);
+  }
+  async getPaymentFailures(customerId, limit = 50) {
+    const customerFailures = this.failures.get(customerId) ?? [];
+    return customerFailures.sort((a, b) => b.failedAt.getTime() - a.failedAt.getTime()).slice(0, limit);
+  }
+  // ============================================================================
+  // Scheduled Steps Methods
+  // ============================================================================
+  async getScheduledSteps(before) {
+    return this.scheduledSteps.filter((s) => s.scheduledAt <= before);
+  }
+  async scheduleStep(stateId, stepId, scheduledAt) {
+    await this.removeScheduledStep(stateId, stepId);
+    this.scheduledSteps.push({ stateId, stepId, scheduledAt });
+  }
+  async removeScheduledStep(stateId, stepId) {
+    this.scheduledSteps = this.scheduledSteps.filter(
+      (s) => !(s.stateId === stateId && s.stepId === stepId)
+    );
+  }
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.states.clear();
+    this.failures.clear();
+    this.scheduledSteps = [];
+  }
+  /**
+   * Get state by ID
+   */
+  getStateById(id) {
+    return this.states.get(id);
+  }
+  /**
+   * Get all states (for debugging)
+   */
+  getAllStates() {
+    return Array.from(this.states.values());
+  }
+  /**
+   * Get all scheduled steps (for debugging)
+   */
+  getAllScheduledSteps() {
+    return [...this.scheduledSteps];
+  }
+};
+function createMemoryDunningStorage() {
+  return new MemoryDunningStorage();
+}
+
+// src/dunning/drizzle-storage.ts
+import { eq, and, lt, desc } from "drizzle-orm";
+
+// src/dunning/schema.ts
+import {
+  pgTable,
+  text,
+  integer,
+  boolean,
+  timestamp,
+  jsonb,
+  uniqueIndex,
+  index
+} from "drizzle-orm/pg-core";
+var dunningSequences = pgTable("dunning_sequences", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+  description: text("description"),
+  maxDurationDays: integer("max_duration_days").notNull().default(28),
+  isActive: boolean("is_active").notNull().default(true),
+  isDefault: boolean("is_default").notNull().default(false),
+  planTier: integer("plan_tier"),
+  // null = default for all, otherwise specific tier
+  metadata: jsonb("metadata").$type(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+var dunningSteps = pgTable(
+  "dunning_steps",
+  {
+    id: text("id").primaryKey(),
+    sequenceId: text("sequence_id").notNull().references(() => dunningSequences.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    stepOrder: integer("step_order").notNull(),
+    // Order within sequence
+    daysAfterFailure: integer("days_after_failure").notNull().default(0),
+    hoursOffset: integer("hours_offset"),
+    // Hour of day to execute (0-23)
+    actions: jsonb("actions").$type().notNull().default([]),
+    // Array of action types
+    notificationChannels: jsonb("notification_channels").$type(),
+    // email, sms, in_app, webhook, push
+    notificationTemplateId: text("notification_template_id"),
+    accessLevel: text("access_level"),
+    // full, limited, read_only, none
+    isFinal: boolean("is_final").notNull().default(false),
+    metadata: jsonb("metadata").$type()
+  },
+  (table) => ({
+    sequenceOrderIdx: uniqueIndex("dunning_steps_sequence_order_idx").on(
+      table.sequenceId,
+      table.stepOrder
+    ),
+    sequenceIdx: index("dunning_steps_sequence_idx").on(table.sequenceId)
+  })
+);
+var paymentFailures = pgTable(
+  "dunning_payment_failures",
+  {
+    id: text("id").primaryKey(),
+    customerId: text("customer_id").notNull(),
+    subscriptionId: text("subscription_id").notNull(),
+    invoiceId: text("invoice_id"),
+    amount: integer("amount").notNull(),
+    // cents
+    currency: text("currency").notNull().default("usd"),
+    category: text("category").notNull(),
+    // card_declined, insufficient_funds, etc.
+    errorCode: text("error_code").notNull(),
+    errorMessage: text("error_message").notNull(),
+    provider: text("provider").notNull(),
+    // stripe, paddle, iyzico
+    failedAt: timestamp("failed_at").notNull(),
+    retryCount: integer("retry_count").notNull().default(0),
+    nextRetryAt: timestamp("next_retry_at"),
+    isRecoverable: boolean("is_recoverable").notNull().default(true),
+    metadata: jsonb("metadata").$type()
+  },
+  (table) => ({
+    customerIdx: index("dunning_payment_failures_customer_idx").on(table.customerId),
+    subscriptionIdx: index("dunning_payment_failures_subscription_idx").on(
+      table.subscriptionId
+    ),
+    failedAtIdx: index("dunning_payment_failures_failed_at_idx").on(table.failedAt),
+    categoryIdx: index("dunning_payment_failures_category_idx").on(table.category)
+  })
+);
+var dunningStates = pgTable(
+  "dunning_states",
+  {
+    id: text("id").primaryKey(),
+    customerId: text("customer_id").notNull(),
+    subscriptionId: text("subscription_id").notNull(),
+    sequenceId: text("sequence_id").notNull().references(() => dunningSequences.id),
+    currentStepIndex: integer("current_step_index").notNull().default(0),
+    currentStepId: text("current_step_id").notNull(),
+    status: text("status").notNull().default("active"),
+    // active, recovered, exhausted, canceled, paused
+    initialFailureId: text("initial_failure_id").notNull().references(() => paymentFailures.id),
+    failureIds: jsonb("failure_ids").$type().notNull().default([]),
+    // All failure IDs
+    startedAt: timestamp("started_at").notNull(),
+    lastStepAt: timestamp("last_step_at"),
+    nextStepAt: timestamp("next_step_at"),
+    endedAt: timestamp("ended_at"),
+    endReason: text("end_reason"),
+    // payment_recovered, max_retries, manually_canceled, subscription_canceled
+    totalRetryAttempts: integer("total_retry_attempts").notNull().default(0),
+    metadata: jsonb("metadata").$type()
+  },
+  (table) => ({
+    customerIdx: uniqueIndex("dunning_states_customer_idx").on(table.customerId),
+    statusIdx: index("dunning_states_status_idx").on(table.status),
+    nextStepIdx: index("dunning_states_next_step_idx").on(table.nextStepAt),
+    subscriptionIdx: index("dunning_states_subscription_idx").on(table.subscriptionId)
+  })
+);
+var executedSteps = pgTable(
+  "dunning_executed_steps",
+  {
+    id: text("id").primaryKey(),
+    dunningStateId: text("dunning_state_id").notNull().references(() => dunningStates.id, { onDelete: "cascade" }),
+    stepId: text("step_id").notNull(),
+    stepName: text("step_name").notNull(),
+    executedAt: timestamp("executed_at").notNull(),
+    actionsTaken: jsonb("actions_taken").$type().notNull().default([]),
+    paymentRetried: boolean("payment_retried").notNull().default(false),
+    paymentSucceeded: boolean("payment_succeeded"),
+    notificationsSent: jsonb("notifications_sent").$type().notNull().default([]),
+    error: text("error"),
+    metadata: jsonb("metadata").$type()
+  },
+  (table) => ({
+    stateIdx: index("dunning_executed_steps_state_idx").on(table.dunningStateId),
+    executedAtIdx: index("dunning_executed_steps_executed_at_idx").on(table.executedAt)
+  })
+);
+var scheduledSteps = pgTable(
+  "dunning_scheduled_steps",
+  {
+    id: text("id").primaryKey(),
+    dunningStateId: text("dunning_state_id").notNull().references(() => dunningStates.id, { onDelete: "cascade" }),
+    stepId: text("step_id").notNull(),
+    scheduledAt: timestamp("scheduled_at").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (table) => ({
+    stateStepIdx: uniqueIndex("dunning_scheduled_steps_state_step_idx").on(
+      table.dunningStateId,
+      table.stepId
+    ),
+    scheduledAtIdx: index("dunning_scheduled_steps_scheduled_at_idx").on(
+      table.scheduledAt
+    )
+  })
+);
+var dunningEvents = pgTable(
+  "dunning_events",
+  {
+    id: text("id").primaryKey(),
+    type: text("type").notNull(),
+    // dunning.started, dunning.step_executed, etc.
+    customerId: text("customer_id").notNull(),
+    subscriptionId: text("subscription_id").notNull(),
+    dunningStateId: text("dunning_state_id").notNull().references(() => dunningStates.id, { onDelete: "cascade" }),
+    timestamp: timestamp("timestamp").notNull(),
+    data: jsonb("data").$type().notNull().default({})
+  },
+  (table) => ({
+    typeIdx: index("dunning_events_type_idx").on(table.type),
+    customerIdx: index("dunning_events_customer_idx").on(table.customerId),
+    timestampIdx: index("dunning_events_timestamp_idx").on(table.timestamp),
+    stateIdx: index("dunning_events_state_idx").on(table.dunningStateId)
+  })
+);
+var retryStrategies = pgTable(
+  "dunning_retry_strategies",
+  {
+    id: text("id").primaryKey(),
+    category: text("category").notNull().unique(),
+    // failure category
+    shouldRetry: boolean("should_retry").notNull().default(true),
+    initialDelayHours: integer("initial_delay_hours").notNull().default(24),
+    maxRetries: integer("max_retries").notNull().default(4),
+    backoffMultiplier: integer("backoff_multiplier").notNull().default(2),
+    // stored as x100 for decimals
+    maxDelayHours: integer("max_delay_hours").notNull().default(168),
+    optimalRetryHours: jsonb("optimal_retry_hours").$type(),
+    optimalRetryDays: jsonb("optimal_retry_days").$type(),
+    metadata: jsonb("metadata").$type(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (table) => ({
+    categoryIdx: uniqueIndex("dunning_retry_strategies_category_idx").on(table.category)
+  })
+);
+var dunningSchema = {
+  dunningSequences,
+  dunningSteps,
+  paymentFailures,
+  dunningStates,
+  executedSteps,
+  scheduledSteps,
+  dunningEvents,
+  retryStrategies
+};
+
+// src/dunning/drizzle-storage.ts
+var DrizzleDunningStorage = class {
+  db;
+  constructor(config) {
+    this.db = config.db;
+  }
+  // ============================================================================
+  // Dunning State Methods
+  // ============================================================================
+  async getDunningState(customerId) {
+    const rows = await this.db.select().from(dunningStates).where(eq(dunningStates.customerId, customerId));
+    const row = rows[0];
+    if (!row) return null;
+    return this.mapRowToState(row);
+  }
+  async getActiveDunningStates() {
+    const rows = await this.db.select().from(dunningStates).where(eq(dunningStates.status, "active"));
+    return Promise.all(rows.map((row) => this.mapRowToState(row)));
+  }
+  async getDunningStatesByStatus(status) {
+    const rows = await this.db.select().from(dunningStates).where(eq(dunningStates.status, status));
+    return Promise.all(rows.map((row) => this.mapRowToState(row)));
+  }
+  async saveDunningState(state) {
+    await this.db.insert(dunningStates).values({
+      id: state.id,
+      customerId: state.customerId,
+      subscriptionId: state.subscriptionId,
+      sequenceId: state.sequenceId,
+      currentStepIndex: state.currentStepIndex,
+      currentStepId: state.currentStepId,
+      status: state.status,
+      initialFailureId: state.initialFailure.id,
+      failureIds: state.failures.map((f) => f.id),
+      startedAt: state.startedAt,
+      lastStepAt: state.lastStepAt,
+      nextStepAt: state.nextStepAt,
+      endedAt: state.endedAt,
+      endReason: state.endReason,
+      totalRetryAttempts: state.totalRetryAttempts,
+      metadata: state.metadata
+    });
+    for (const step2 of state.executedSteps) {
+      await this.saveExecutedStep(state.id, step2);
+    }
+  }
+  async updateDunningState(id, updates) {
+    const setValues = {};
+    if (updates["currentStepIndex"] !== void 0)
+      setValues["currentStepIndex"] = updates["currentStepIndex"];
+    if (updates["currentStepId"] !== void 0)
+      setValues["currentStepId"] = updates["currentStepId"];
+    if (updates["status"] !== void 0) setValues["status"] = updates["status"];
+    if (updates["lastStepAt"] !== void 0) setValues["lastStepAt"] = updates["lastStepAt"];
+    if (updates["nextStepAt"] !== void 0) setValues["nextStepAt"] = updates["nextStepAt"];
+    if (updates["endedAt"] !== void 0) setValues["endedAt"] = updates["endedAt"];
+    if (updates["endReason"] !== void 0) setValues["endReason"] = updates["endReason"];
+    if (updates["totalRetryAttempts"] !== void 0)
+      setValues["totalRetryAttempts"] = updates["totalRetryAttempts"];
+    if (updates["metadata"] !== void 0) setValues["metadata"] = updates["metadata"];
+    if (updates["failures"] !== void 0)
+      setValues["failureIds"] = updates["failures"].map((f) => f.id);
+    if (Object.keys(setValues).length > 0) {
+      await this.db.update(dunningStates).set(setValues).where(eq(dunningStates.id, id));
+    }
+  }
+  // ============================================================================
+  // Payment Failure Methods
+  // ============================================================================
+  async recordPaymentFailure(failure) {
+    await this.db.insert(paymentFailures).values({
+      id: failure.id,
+      customerId: failure.customerId,
+      subscriptionId: failure.subscriptionId,
+      invoiceId: failure.invoiceId,
+      amount: failure.amount,
+      currency: failure.currency,
+      category: failure.category,
+      errorCode: failure.errorCode,
+      errorMessage: failure.errorMessage,
+      provider: failure.provider,
+      failedAt: failure.failedAt,
+      retryCount: failure.retryCount,
+      nextRetryAt: failure.nextRetryAt,
+      isRecoverable: failure.isRecoverable,
+      metadata: failure.metadata
+    });
+  }
+  async getPaymentFailures(customerId, limit = 50) {
+    const rows = await this.db.select().from(paymentFailures).where(eq(paymentFailures.customerId, customerId)).orderBy(desc(paymentFailures.failedAt)).limit(limit);
+    return rows.map((row) => this.mapRowToFailure(row));
+  }
+  // ============================================================================
+  // Scheduled Steps Methods
+  // ============================================================================
+  async getScheduledSteps(before) {
+    const rows = await this.db.select().from(scheduledSteps).where(lt(scheduledSteps.scheduledAt, before));
+    return rows.map((row) => ({
+      stateId: row.dunningStateId,
+      stepId: row.stepId,
+      scheduledAt: row.scheduledAt
+    }));
+  }
+  async scheduleStep(stateId, stepId, scheduledAt) {
+    const id = `sched_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    await this.db.insert(scheduledSteps).values({
+      id,
+      dunningStateId: stateId,
+      stepId,
+      scheduledAt
+    });
+  }
+  async removeScheduledStep(stateId, stepId) {
+    await this.db.delete(scheduledSteps).where(
+      and(eq(scheduledSteps.dunningStateId, stateId), eq(scheduledSteps.stepId, stepId))
+    );
+  }
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+  async saveExecutedStep(stateId, step2) {
+    const id = `exec_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    await this.db.insert(executedSteps).values({
+      id,
+      dunningStateId: stateId,
+      stepId: step2.stepId,
+      stepName: step2.stepName,
+      executedAt: step2.executedAt,
+      actionsTaken: step2.actionsTaken,
+      paymentRetried: step2.paymentRetried,
+      paymentSucceeded: step2.paymentSucceeded,
+      notificationsSent: step2.notificationsSent,
+      error: step2.error
+    });
+  }
+  async mapRowToState(row) {
+    const failureRows = await this.db.select().from(paymentFailures).where(eq(paymentFailures.id, row.initialFailureId));
+    const initialFailureRow = failureRows[0];
+    if (!initialFailureRow) {
+      throw new Error(`Initial failure not found: ${row.initialFailureId}`);
+    }
+    const initialFailure = this.mapRowToFailure(initialFailureRow);
+    const failures = [initialFailure];
+    const failureIds = row.failureIds || [];
+    for (const failureId of failureIds) {
+      if (failureId !== row.initialFailureId) {
+        const additionalRows = await this.db.select().from(paymentFailures).where(eq(paymentFailures.id, failureId));
+        const additionalRow = additionalRows[0];
+        if (additionalRow) {
+          failures.push(this.mapRowToFailure(additionalRow));
+        }
+      }
+    }
+    const execStepRows = await this.db.select().from(executedSteps).where(eq(executedSteps.dunningStateId, row.id)).orderBy(executedSteps.executedAt);
+    const executedStepsList = execStepRows.map((es) => {
+      const step2 = {
+        stepId: es.stepId,
+        stepName: es.stepName,
+        executedAt: es.executedAt,
+        actionsTaken: es.actionsTaken || [],
+        paymentRetried: es.paymentRetried,
+        notificationsSent: es.notificationsSent || []
+      };
+      if (es.paymentSucceeded !== null) step2.paymentSucceeded = es.paymentSucceeded;
+      if (es.error !== null) step2.error = es.error;
+      return step2;
+    });
+    const result = {
+      id: row.id,
+      customerId: row.customerId,
+      subscriptionId: row.subscriptionId,
+      sequenceId: row.sequenceId,
+      currentStepIndex: row.currentStepIndex,
+      currentStepId: row.currentStepId,
+      status: row.status,
+      initialFailure,
+      failures,
+      executedSteps: executedStepsList,
+      startedAt: row.startedAt,
+      totalRetryAttempts: row.totalRetryAttempts
+    };
+    if (row.lastStepAt) result.lastStepAt = row.lastStepAt;
+    if (row.nextStepAt) result.nextStepAt = row.nextStepAt;
+    if (row.endedAt) result.endedAt = row.endedAt;
+    const endReason = row.endReason;
+    if (endReason === "payment_recovered" || endReason === "max_retries" || endReason === "manually_canceled" || endReason === "subscription_canceled") {
+      result.endReason = endReason;
+    }
+    if (row.metadata) result.metadata = row.metadata;
+    return result;
+  }
+  mapRowToFailure(row) {
+    const result = {
+      id: row.id,
+      customerId: row.customerId,
+      subscriptionId: row.subscriptionId,
+      amount: row.amount,
+      currency: row.currency,
+      category: row.category,
+      errorCode: row.errorCode,
+      errorMessage: row.errorMessage,
+      provider: row.provider,
+      failedAt: row.failedAt,
+      retryCount: row.retryCount,
+      isRecoverable: row.isRecoverable
+    };
+    if (row.invoiceId) result.invoiceId = row.invoiceId;
+    if (row.nextRetryAt) result.nextRetryAt = row.nextRetryAt;
+    if (row.metadata) result.metadata = row.metadata;
+    return result;
+  }
+};
+function createDrizzleDunningStorage(config) {
+  return new DrizzleDunningStorage(config);
+}
+
+// src/dunning/email-templates.ts
+function renderTemplate(template, data) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = data[key];
+    return value !== void 0 && value !== null ? String(value) : "";
+  });
+}
+function formatAmount(amountCents, currency) {
+  const amount = amountCents / 100;
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: currency.toUpperCase()
+  }).format(amount);
+}
+var paymentFailedTemplate = {
+  id: "dunning-payment-failed",
+  name: "Payment Failed",
+  subject: "Action required: Your payment failed",
+  html: `
+<h1>Your payment didn't go through</h1>
+<p>Hi{{customerName}},</p>
+<p>We weren't able to process your payment of <strong>{{amount}}</strong> for your subscription.</p>
+{{cardInfo}}
+<p>Don't worry - we'll automatically retry your payment. In the meantime, please make sure your payment information is up to date.</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: {{brandColor}}; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Update Payment Method</a>
+</div>
+<p style="color: #666; font-size: 14px;">If you have any questions, please <a href="{{supportUrl}}">contact our support team</a>.</p>
+`,
+  text: `Your payment didn't go through
+
+Hi{{customerName}},
+
+We weren't able to process your payment of {{amount}} for your subscription.
+
+Don't worry - we'll automatically retry your payment. In the meantime, please make sure your payment information is up to date.
+
+Update your payment method: {{updatePaymentUrl}}
+
+If you have any questions, please contact our support team: {{supportUrl}}`
+};
+var paymentReminderTemplate = {
+  id: "dunning-reminder",
+  name: "Payment Reminder",
+  subject: "Reminder: Please update your payment method",
+  html: `
+<h1>Friendly reminder about your payment</h1>
+<p>Hi{{customerName}},</p>
+<p>We wanted to remind you that we were unable to process your payment of <strong>{{amount}}</strong>. It's been {{daysSinceFailure}} days since we first tried.</p>
+<p>To keep your subscription active, please update your payment information.</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: {{brandColor}}; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Update Payment Method</a>
+</div>
+<p style="color: #666; font-size: 14px;">Need help? <a href="{{supportUrl}}">Contact support</a></p>
+`,
+  text: `Friendly reminder about your payment
+
+Hi{{customerName}},
+
+We wanted to remind you that we were unable to process your payment of {{amount}}. It's been {{daysSinceFailure}} days since we first tried.
+
+To keep your subscription active, please update your payment information.
+
+Update your payment method: {{updatePaymentUrl}}
+
+Need help? Contact support: {{supportUrl}}`
+};
+var paymentWarningTemplate = {
+  id: "dunning-warning",
+  name: "Payment Warning",
+  subject: "Urgent: Your account access may be limited",
+  html: `
+<h1>Your account access may be limited soon</h1>
+<p>Hi{{customerName}},</p>
+<p>We've been trying to process your payment of <strong>{{amount}}</strong> for {{daysSinceFailure}} days without success.</p>
+<p style="background: #fff3cd; border: 1px solid #ffc107; border-radius: 6px; padding: 16px; margin: 16px 0;">
+  <strong>\u26A0\uFE0F Important:</strong> If we don't receive payment within {{daysUntilLimit}} days, some features will be limited.
+</p>
+<p>Please update your payment method to avoid any service interruption.</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: {{brandColor}}; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Update Payment Now</a>
+</div>
+<p style="color: #666; font-size: 14px;">Having trouble? <a href="{{supportUrl}}">We're here to help</a></p>
+`,
+  text: `Your account access may be limited soon
+
+Hi{{customerName}},
+
+We've been trying to process your payment of {{amount}} for {{daysSinceFailure}} days without success.
+
+\u26A0\uFE0F Important: If we don't receive payment within {{daysUntilLimit}} days, some features will be limited.
+
+Please update your payment method to avoid any service interruption.
+
+Update your payment method: {{updatePaymentUrl}}
+
+Having trouble? We're here to help: {{supportUrl}}`
+};
+var featuresLimitedTemplate = {
+  id: "dunning-feature-limit",
+  name: "Features Limited",
+  subject: "Some features have been limited on your account",
+  html: `
+<h1>Some features have been limited</h1>
+<p>Hi{{customerName}},</p>
+<p>Due to the outstanding payment of <strong>{{amount}}</strong>, we've had to limit some features on your account.</p>
+<p style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 6px; padding: 16px; margin: 16px 0;">
+  <strong>Current status:</strong> Limited access<br>
+  <strong>Outstanding amount:</strong> {{amount}}<br>
+  <strong>Days until suspension:</strong> {{daysUntilSuspension}}
+</p>
+<p>To restore full access, please update your payment method immediately.</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: #dc3545; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Restore Full Access</a>
+</div>
+`,
+  text: `Some features have been limited
+
+Hi{{customerName}},
+
+Due to the outstanding payment of {{amount}}, we've had to limit some features on your account.
+
+Current status: Limited access
+Outstanding amount: {{amount}}
+Days until suspension: {{daysUntilSuspension}}
+
+To restore full access, please update your payment method immediately.
+
+Restore full access: {{updatePaymentUrl}}`
+};
+var accountSuspendedTemplate = {
+  id: "dunning-suspension",
+  name: "Account Suspended",
+  subject: "Your account has been suspended",
+  html: `
+<h1>Your account has been suspended</h1>
+<p>Hi{{customerName}},</p>
+<p>We've suspended your account due to an outstanding payment of <strong>{{amount}}</strong>.</p>
+<p style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 6px; padding: 16px; margin: 16px 0;">
+  <strong>\u26D4 Your account is now suspended</strong><br>
+  You have read-only access to your data.<br>
+  <strong>Days until cancellation:</strong> {{daysUntilCancellation}}
+</p>
+<p>To reactivate your account and regain full access, please pay the outstanding balance.</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: #dc3545; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Reactivate Account</a>
+</div>
+<p style="color: #666; font-size: 14px;">If you need to discuss payment options, please <a href="{{supportUrl}}">contact us</a>.</p>
+`,
+  text: `Your account has been suspended
+
+Hi{{customerName}},
+
+We've suspended your account due to an outstanding payment of {{amount}}.
+
+\u26D4 Your account is now suspended
+You have read-only access to your data.
+Days until cancellation: {{daysUntilCancellation}}
+
+To reactivate your account and regain full access, please pay the outstanding balance.
+
+Reactivate account: {{updatePaymentUrl}}
+
+If you need to discuss payment options, please contact us: {{supportUrl}}`
+};
+var finalWarningTemplate = {
+  id: "dunning-final-warning",
+  name: "Final Warning",
+  subject: "Final notice: Your subscription will be canceled",
+  html: `
+<h1>Final notice before cancellation</h1>
+<p>Hi{{customerName}},</p>
+<p>This is your final notice. Your subscription will be <strong>automatically canceled</strong> in {{daysUntilCancellation}} days due to an unpaid balance of <strong>{{amount}}</strong>.</p>
+<p style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 6px; padding: 16px; margin: 16px 0;">
+  <strong>\u{1F6A8} Action required immediately</strong><br>
+  After cancellation, your data may be permanently deleted according to our data retention policy.
+</p>
+<p>Please pay now to keep your account and data.</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: #dc3545; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Pay Now - Prevent Cancellation</a>
+</div>
+<p style="color: #666; font-size: 14px;">Questions? <a href="{{supportUrl}}">Contact us immediately</a></p>
+`,
+  text: `Final notice before cancellation
+
+Hi{{customerName}},
+
+This is your final notice. Your subscription will be automatically canceled in {{daysUntilCancellation}} days due to an unpaid balance of {{amount}}.
+
+\u{1F6A8} Action required immediately
+After cancellation, your data may be permanently deleted according to our data retention policy.
+
+Please pay now to keep your account and data.
+
+Pay now: {{updatePaymentUrl}}
+
+Questions? Contact us immediately: {{supportUrl}}`
+};
+var subscriptionCanceledTemplate = {
+  id: "dunning-canceled",
+  name: "Subscription Canceled",
+  subject: "Your subscription has been canceled",
+  html: `
+<h1>Your subscription has been canceled</h1>
+<p>Hi{{customerName}},</p>
+<p>Your subscription has been canceled due to non-payment of <strong>{{amount}}</strong>.</p>
+<p style="background: #f8f9fa; border-radius: 6px; padding: 16px; margin: 16px 0;">
+  Your data will be retained for 30 days. After that, it may be permanently deleted.
+</p>
+<p>If you'd like to resubscribe, you can do so at any time:</p>
+<div style="text-align: center; margin: 24px 0;">
+  <a href="{{updatePaymentUrl}}" style="display: inline-block; background: {{brandColor}}; color: #ffffff; text-decoration: none; padding: 14px 32px; border-radius: 6px; font-weight: 600;">Resubscribe</a>
+</div>
+<p>We're sorry to see you go. If there's anything we can do to help, please <a href="{{supportUrl}}">let us know</a>.</p>
+`,
+  text: `Your subscription has been canceled
+
+Hi{{customerName}},
+
+Your subscription has been canceled due to non-payment of {{amount}}.
+
+Your data will be retained for 30 days. After that, it may be permanently deleted.
+
+If you'd like to resubscribe, you can do so at any time: {{updatePaymentUrl}}
+
+We're sorry to see you go. If there's anything we can do to help, please let us know: {{supportUrl}}`
+};
+var paymentRecoveredTemplate = {
+  id: "dunning-recovered",
+  name: "Payment Recovered",
+  subject: "Good news! Your payment was successful",
+  html: `
+<h1>Your payment was successful! \u{1F389}</h1>
+<p>Hi{{customerName}},</p>
+<p>Great news! We've successfully processed your payment of <strong>{{amount}}</strong>.</p>
+<p style="background: #d4edda; border: 1px solid #c3e6cb; border-radius: 6px; padding: 16px; margin: 16px 0;">
+  <strong>\u2713 Payment received:</strong> {{amount}}<br>
+  <strong>\u2713 Account status:</strong> Active
+</p>
+<p>Your subscription is now fully active. Thank you for being a valued customer!</p>
+<p style="color: #666; font-size: 14px;">If you have any questions, we're always here to help at <a href="{{supportUrl}}">support</a>.</p>
+`,
+  text: `Your payment was successful! \u{1F389}
+
+Hi{{customerName}},
+
+Great news! We've successfully processed your payment of {{amount}}.
+
+\u2713 Payment received: {{amount}}
+\u2713 Account status: Active
+
+Your subscription is now fully active. Thank you for being a valued customer!
+
+If you have any questions, we're always here to help: {{supportUrl}}`
+};
+var dunningEmailTemplates = {
+  "dunning-payment-failed": paymentFailedTemplate,
+  "dunning-reminder": paymentReminderTemplate,
+  "dunning-warning": paymentWarningTemplate,
+  "dunning-feature-limit": featuresLimitedTemplate,
+  "dunning-suspension": accountSuspendedTemplate,
+  "dunning-final-warning": finalWarningTemplate,
+  "dunning-canceled": subscriptionCanceledTemplate,
+  "dunning-recovered": paymentRecoveredTemplate
+};
+function renderDunningEmail(templateId, data, customTemplates) {
+  const templates = { ...dunningEmailTemplates, ...customTemplates };
+  const template = templates[templateId];
+  if (!template) {
+    throw new Error(`Dunning email template not found: ${templateId}`);
+  }
+  const templateData = {
+    ...data,
+    customerName: data.customerName ? ` ${data.customerName}` : "",
+    brandColor: data.brandColor ?? "#0070f3",
+    brandName: data.brandName ?? "Your Service"
+  };
+  if (data.cardLast4 && data.cardBrand) {
+    templateData["cardInfo"] = `<p style="color: #666;">Card ending in ${data.cardLast4} (${data.cardBrand})</p>`;
+  } else {
+    templateData["cardInfo"] = "";
+  }
+  return {
+    subject: renderTemplate(template.subject, templateData),
+    html: renderTemplate(template.html, templateData),
+    text: renderTemplate(template.text, templateData)
+  };
+}
+function buildTemplateData(context, options) {
+  const result = {
+    amount: formatAmount(context.amountOwed, context.currency),
+    currency: context.currency,
+    daysSinceFailure: context.daysSinceFailure
+  };
+  if (context.customer.name) result.customerName = context.customer.name;
+  if (options?.daysUntilLimit !== void 0) result.daysUntilLimit = options.daysUntilLimit;
+  if (options?.daysUntilSuspension !== void 0) result.daysUntilSuspension = options.daysUntilSuspension;
+  if (options?.daysUntilCancellation !== void 0) result.daysUntilCancellation = options.daysUntilCancellation;
+  if (options?.updatePaymentUrl) result.updatePaymentUrl = options.updatePaymentUrl;
+  if (options?.invoiceUrl) result.invoiceUrl = options.invoiceUrl;
+  if (options?.supportUrl) result.supportUrl = options.supportUrl;
+  if (options?.brandName) result.brandName = options.brandName;
+  if (options?.brandColor) result.brandColor = options.brandColor;
+  return result;
+}
+
+// src/dunning/email-integration.ts
+function createDunningEmailHandler(config) {
+  const { emailService, logger } = config;
+  const buildUrls = (notification) => {
+    const { urls } = config;
+    if (!urls) return {};
+    const result = {};
+    const customerId = notification.recipient.customerId;
+    const invoiceId = notification.context.state.initialFailure.invoiceId;
+    const updatePaymentUrl = typeof urls.updatePayment === "function" ? urls.updatePayment(customerId) : urls.updatePayment;
+    if (updatePaymentUrl) result.updatePaymentUrl = updatePaymentUrl;
+    if (invoiceId && typeof urls.viewInvoice === "function") {
+      result.invoiceUrl = urls.viewInvoice(invoiceId);
+    } else if (typeof urls.viewInvoice === "string") {
+      result.invoiceUrl = urls.viewInvoice;
+    }
+    if (urls.support) result.supportUrl = urls.support;
+    return result;
+  };
+  const calculateDaysUntil = (context) => {
+    const result = {};
+    const stepMeta = context.step.metadata;
+    if (stepMeta) {
+      if (typeof stepMeta["daysUntilLimit"] === "number") {
+        result.daysUntilLimit = stepMeta["daysUntilLimit"];
+      }
+      if (typeof stepMeta["daysUntilSuspension"] === "number") {
+        result.daysUntilSuspension = stepMeta["daysUntilSuspension"];
+      }
+      if (typeof stepMeta["daysUntilCancellation"] === "number") {
+        result.daysUntilCancellation = stepMeta["daysUntilCancellation"];
+      }
+    }
+    return result;
+  };
+  const sendEmail = async (templateId, to, context) => {
+    try {
+      const urls = buildUrls({
+        channel: "email",
+        templateId,
+        recipient: { customerId: context.customer.id, email: to },
+        variables: {
+          amount: context.amountOwed,
+          currency: context.currency,
+          daysSinceFailure: context.daysSinceFailure
+        },
+        context
+      });
+      const daysUntil = calculateDaysUntil(context);
+      const templateOptions = {};
+      if (config.brand?.name) templateOptions.brandName = config.brand.name;
+      if (config.brand?.color) templateOptions.brandColor = config.brand.color;
+      if (urls.updatePaymentUrl) templateOptions.updatePaymentUrl = urls.updatePaymentUrl;
+      if (urls.invoiceUrl) templateOptions.invoiceUrl = urls.invoiceUrl;
+      if (urls.supportUrl) templateOptions.supportUrl = urls.supportUrl;
+      if (daysUntil.daysUntilLimit !== void 0) templateOptions.daysUntilLimit = daysUntil.daysUntilLimit;
+      if (daysUntil.daysUntilSuspension !== void 0) templateOptions.daysUntilSuspension = daysUntil.daysUntilSuspension;
+      if (daysUntil.daysUntilCancellation !== void 0) templateOptions.daysUntilCancellation = daysUntil.daysUntilCancellation;
+      let emailData = buildTemplateData(context, templateOptions);
+      if (config.enrichData) {
+        emailData = config.enrichData(emailData, context);
+      }
+      const rendered = renderDunningEmail(templateId, emailData, config.customTemplates);
+      const sendOptions = {
+        to,
+        subject: rendered.subject,
+        html: rendered.html,
+        text: rendered.text,
+        tags: config.tags ?? ["dunning"]
+      };
+      if (config.replyTo) sendOptions.replyTo = config.replyTo;
+      const result = await emailService.send(sendOptions);
+      logger?.debug("Dunning email sent", {
+        templateId,
+        to,
+        success: result.success,
+        messageId: result.messageId
+      });
+      const notificationResult = {
+        success: result.success,
+        channel: "email",
+        sentAt: /* @__PURE__ */ new Date()
+      };
+      if (result.messageId) notificationResult.externalId = result.messageId;
+      if (result.error) notificationResult.error = result.error;
+      return notificationResult;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger?.error("Failed to send dunning email", {
+        templateId,
+        to,
+        error: errorMessage
+      });
+      return {
+        success: false,
+        channel: "email",
+        error: errorMessage,
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+  };
+  const handler = async (notification) => {
+    if (notification.channel !== "email") {
+      return {
+        success: false,
+        channel: notification.channel,
+        error: `Channel ${notification.channel} not supported by email integration`,
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    if (config.skip?.(notification)) {
+      logger?.debug("Skipping dunning notification", {
+        customerId: notification.recipient.customerId,
+        templateId: notification.templateId
+      });
+      return {
+        success: true,
+        channel: "email",
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    const email = notification.recipient.email;
+    if (!email) {
+      logger?.warn("No email address for dunning notification", {
+        customerId: notification.recipient.customerId
+      });
+      return {
+        success: false,
+        channel: "email",
+        error: "No email address available",
+        sentAt: /* @__PURE__ */ new Date()
+      };
+    }
+    return sendEmail(notification.templateId, email, notification.context);
+  };
+  const sendRecoveryEmail = async (to, context) => {
+    return sendEmail("dunning-recovered", to, context);
+  };
+  return {
+    handler,
+    sendEmail,
+    sendRecoveryEmail
+  };
+}
+function createMultiChannelHandler(config) {
+  const emailHandler = config.email ? createDunningEmailHandler(config.email) : void 0;
+  return async (notification) => {
+    const { channel } = notification;
+    switch (channel) {
+      case "email":
+        if (!emailHandler) {
+          config.logger?.warn("Email channel not configured", {
+            templateId: notification.templateId
+          });
+          return {
+            success: false,
+            channel: "email",
+            error: "Email channel not configured",
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        return emailHandler.handler(notification);
+      case "sms":
+        if (!config.sms) {
+          return {
+            success: false,
+            channel: "sms",
+            error: "SMS channel not configured",
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        const phone = notification.recipient.phone;
+        if (!phone) {
+          return {
+            success: false,
+            channel: "sms",
+            error: "No phone number available",
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        const template = config.sms.templates?.[notification.templateId];
+        if (!template) {
+          return {
+            success: false,
+            channel: "sms",
+            error: `SMS template not found: ${notification.templateId}`,
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        const smsResult = await config.sms.service.send({
+          to: phone,
+          message: template
+          // TODO: render template
+        });
+        const smsNotificationResult = {
+          success: smsResult.success,
+          channel: "sms",
+          sentAt: /* @__PURE__ */ new Date()
+        };
+        if (smsResult.messageId) smsNotificationResult.externalId = smsResult.messageId;
+        if (smsResult.error) smsNotificationResult.error = smsResult.error;
+        return smsNotificationResult;
+      case "in_app":
+        if (!config.inApp) {
+          return {
+            success: false,
+            channel: "in_app",
+            error: "In-app channel not configured",
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        return config.inApp(notification);
+      case "webhook":
+        if (!config.webhook) {
+          return {
+            success: false,
+            channel: "webhook",
+            error: "Webhook channel not configured",
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        return config.webhook(notification);
+      case "push":
+        if (!config.push) {
+          return {
+            success: false,
+            channel: "push",
+            error: "Push channel not configured",
+            sentAt: /* @__PURE__ */ new Date()
+          };
+        }
+        return config.push(notification);
+      default:
+        return {
+          success: false,
+          channel,
+          error: `Unknown channel: ${channel}`,
+          sentAt: /* @__PURE__ */ new Date()
+        };
+    }
+  };
+}
+function simpleEmailHandler(emailService, options) {
+  const config = {
+    emailService
+  };
+  if (options?.brandName || options?.brandColor) {
+    const brand = {};
+    if (options.brandName) brand.name = options.brandName;
+    if (options.brandColor) brand.color = options.brandColor;
+    config.brand = brand;
+  }
+  if (options?.updatePaymentUrl || options?.supportUrl) {
+    const urls = {};
+    if (options.updatePaymentUrl) urls.updatePayment = options.updatePaymentUrl;
+    if (options.supportUrl) urls.support = options.supportUrl;
+    config.urls = urls;
+  }
+  if (options?.replyTo) {
+    config.replyTo = options.replyTo;
+  }
+  const handler = createDunningEmailHandler(config);
+  return handler.handler;
+}
+export {
+  DrizzleDunningStorage,
+  DunningManager,
+  DunningScheduler,
+  DunningSequenceBuilder,
+  DunningStepBuilder,
+  MemoryDunningStorage,
+  PaymentRetrier,
+  PaymentRetryCalculator,
+  accountSuspendedTemplate,
+  aggressiveSequence,
+  allErrorCodeMappings,
+  buildTemplateData,
+  createDefaultDunningConfig,
+  createDrizzleDunningStorage,
+  createDunningCronHandler,
+  createDunningEdgeHandler,
+  createDunningEmailHandler,
+  createDunningManager,
+  createDunningScheduler,
+  createMemoryDunningStorage,
+  createMultiChannelHandler,
+  createPaymentRetrier,
+  createPaymentRetryCalculator,
+  defaultRetryStrategies,
+  defaultSequences,
+  dunningEmailTemplates,
+  dunningEvents,
+  dunningSchema,
+  dunningSequences,
+  dunningStates,
+  dunningSteps,
+  executedSteps,
+  featuresLimitedTemplate,
+  finalWarningTemplate,
+  formatAmount,
+  getSequenceByTier,
+  iyzicoErrorCodes,
+  lenientSequence,
+  minimalSequence,
+  paddleErrorCodes,
+  paymentFailedTemplate,
+  paymentFailures,
+  paymentRecoveredTemplate,
+  paymentReminderTemplate,
+  paymentWarningTemplate,
+  renderDunningEmail,
+  retryStrategies,
+  scheduledSteps,
+  sequence,
+  simpleEmailHandler,
+  standardSaasSequence,
+  step,
+  stripeErrorCodes,
+  subscriptionCanceledTemplate
+};
+//# sourceMappingURL=index.js.map