@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/deliverability/classes.ipwarmupmanager.js

@@ -0,0 +1,639 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+import { LRUCache } from 'lru-cache';
+/**
+ * Default IP warmup configuration with industry standard stages
+ */
+const DEFAULT_WARMUP_CONFIG = {
+    enabled: true,
+    ipAddresses: [],
+    targetDomains: [],
+    stages: [
+        { stage: 1, maxDailyVolume: 50, durationDays: 2, targetMetrics: { maxBounceRate: 8, minOpenRate: 15 } },
+        { stage: 2, maxDailyVolume: 100, durationDays: 2, targetMetrics: { maxBounceRate: 7, minOpenRate: 18 } },
+        { stage: 3, maxDailyVolume: 500, durationDays: 3, targetMetrics: { maxBounceRate: 6, minOpenRate: 20 } },
+        { stage: 4, maxDailyVolume: 1000, durationDays: 3, targetMetrics: { maxBounceRate: 5, minOpenRate: 20 } },
+        { stage: 5, maxDailyVolume: 5000, durationDays: 5, targetMetrics: { maxBounceRate: 3, minOpenRate: 22 } },
+        { stage: 6, maxDailyVolume: 10000, durationDays: 5, targetMetrics: { maxBounceRate: 2, minOpenRate: 25 } },
+        { stage: 7, maxDailyVolume: 20000, durationDays: 5, targetMetrics: { maxBounceRate: 1, minOpenRate: 25 } },
+        { stage: 8, maxDailyVolume: 50000, durationDays: 5, targetMetrics: { maxBounceRate: 1, minOpenRate: 25 } },
+    ],
+    startDate: new Date(),
+    // Default hourly distribution (percentage per hour, sums to 100%)
+    hourlyDistribution: [
+        1, 1, 1, 1, 1, 2, 3, 5, 7, 8, 10, 11,
+        10, 9, 8, 6, 5, 4, 3, 2, 1, 1, 1, 0
+    ],
+    autoAdvanceStages: true,
+    suspendOnMetricDecline: true,
+    fallbackPercentage: 50,
+    prioritizeEngagedSubscribers: true
+};
+/**
+ * Manages the IP warming process for new sending IPs
+ */
+export class IPWarmupManager {
+    /**
+     * Constructor for IPWarmupManager
+     * @param config Warmup configuration
+     */
+    constructor(config = {}) {
+        this.warmupStatuses = new Map();
+        this.dailySendCounts = new Map();
+        this.hourlySendCounts = new Map();
+        this.isInitialized = false;
+        this.allocationPolicies = new Map();
+        this.activePolicy = 'balanced';
+        this.config = {
+            ...DEFAULT_WARMUP_CONFIG,
+            ...config,
+            stages: config.stages || [...DEFAULT_WARMUP_CONFIG.stages]
+        };
+        // Register default allocation policies
+        this.registerAllocationPolicy('balanced', new BalancedAllocationPolicy());
+        this.registerAllocationPolicy('roundRobin', new RoundRobinAllocationPolicy());
+        this.registerAllocationPolicy('dedicated', new DedicatedDomainPolicy());
+        this.initialize();
+    }
+    /**
+     * Get the singleton instance of IPWarmupManager
+     * @param config Warmup configuration
+     * @returns Singleton instance
+     */
+    static getInstance(config = {}) {
+        if (!IPWarmupManager.instance) {
+            IPWarmupManager.instance = new IPWarmupManager(config);
+        }
+        return IPWarmupManager.instance;
+    }
+    /**
+     * Initialize the warmup manager
+     */
+    initialize() {
+        if (this.isInitialized)
+            return;
+        try {
+            // Load warmup statuses from storage
+            this.loadWarmupStatuses();
+            // Initialize any new IPs that might have been added to config
+            for (const ip of this.config.ipAddresses) {
+                if (!this.warmupStatuses.has(ip)) {
+                    this.initializeIPWarmup(ip);
+                }
+            }
+            // Initialize daily and hourly counters
+            const today = new Date().toISOString().split('T')[0];
+            for (const ip of this.config.ipAddresses) {
+                this.dailySendCounts.set(ip, 0);
+                this.hourlySendCounts.set(ip, Array(24).fill(0));
+            }
+            // Schedule daily reset of counters
+            this.scheduleDailyReset();
+            // Schedule daily evaluation of warmup progress
+            this.scheduleDailyEvaluation();
+            this.isInitialized = true;
+            logger.log('info', `IP Warmup Manager initialized with ${this.config.ipAddresses.length} IPs`);
+        }
+        catch (error) {
+            logger.log('error', `Failed to initialize IP Warmup Manager: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+    /**
+     * Initialize warmup status for a new IP address
+     * @param ipAddress IP address to initialize
+     */
+    initializeIPWarmup(ipAddress) {
+        const startDate = new Date();
+        let targetCompletionDate = new Date(startDate);
+        // Calculate target completion date based on stages
+        let totalDays = 0;
+        for (const stage of this.config.stages) {
+            totalDays += stage.durationDays;
+        }
+        targetCompletionDate.setDate(targetCompletionDate.getDate() + totalDays);
+        const warmupStatus = {
+            ipAddress,
+            currentStage: 1,
+            startDate,
+            currentStageStartDate: new Date(),
+            targetCompletionDate,
+            currentDailyAllocation: this.config.stages[0].maxDailyVolume,
+            sentInCurrentStage: 0,
+            totalSent: 0,
+            isActive: true,
+            dailyStats: [],
+            metrics: {
+                openRate: 0,
+                bounceRate: 0,
+                complaintRate: 0
+            }
+        };
+        this.warmupStatuses.set(ipAddress, warmupStatus);
+        this.saveWarmupStatuses();
+        logger.log('info', `Initialized warmup for IP ${ipAddress}`, {
+            currentStage: 1,
+            targetCompletion: targetCompletionDate.toISOString().split('T')[0]
+        });
+    }
+    /**
+     * Schedule daily reset of send counters
+     */
+    scheduleDailyReset() {
+        // Calculate time until midnight
+        const now = new Date();
+        const tomorrow = new Date(now);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        tomorrow.setHours(0, 0, 0, 0);
+        const timeUntilMidnight = tomorrow.getTime() - now.getTime();
+        // Schedule reset
+        setTimeout(() => {
+            this.resetDailyCounts();
+            // Reschedule for next day
+            this.scheduleDailyReset();
+        }, timeUntilMidnight);
+        logger.log('info', `Scheduled daily counter reset in ${Math.floor(timeUntilMidnight / 60000)} minutes`);
+    }
+    /**
+     * Reset daily send counters
+     */
+    resetDailyCounts() {
+        for (const ip of this.config.ipAddresses) {
+            // Save yesterday's count to history before resetting
+            const status = this.warmupStatuses.get(ip);
+            if (status) {
+                const yesterday = new Date();
+                yesterday.setDate(yesterday.getDate() - 1);
+                // Update daily stats with yesterday's data
+                const sentCount = this.dailySendCounts.get(ip) || 0;
+                status.dailyStats.push({
+                    date: yesterday.toISOString().split('T')[0],
+                    sent: sentCount,
+                    opened: Math.floor(sentCount * status.metrics.openRate / 100),
+                    bounces: Math.floor(sentCount * status.metrics.bounceRate / 100),
+                    complaints: Math.floor(sentCount * status.metrics.complaintRate / 100)
+                });
+                // Keep only the last 7 days of stats
+                if (status.dailyStats.length > 7) {
+                    status.dailyStats.shift();
+                }
+            }
+            // Reset counters for today
+            this.dailySendCounts.set(ip, 0);
+            this.hourlySendCounts.set(ip, Array(24).fill(0));
+        }
+        // Save updated statuses
+        this.saveWarmupStatuses();
+        logger.log('info', 'Daily send counters reset');
+    }
+    /**
+     * Schedule daily evaluation of warmup progress
+     */
+    scheduleDailyEvaluation() {
+        // Calculate time until 1 AM (do evaluation after midnight)
+        const now = new Date();
+        const evaluationTime = new Date(now);
+        evaluationTime.setDate(evaluationTime.getDate() + 1);
+        evaluationTime.setHours(1, 0, 0, 0);
+        const timeUntilEvaluation = evaluationTime.getTime() - now.getTime();
+        // Schedule evaluation
+        setTimeout(() => {
+            this.evaluateWarmupProgress();
+            // Reschedule for next day
+            this.scheduleDailyEvaluation();
+        }, timeUntilEvaluation);
+        logger.log('info', `Scheduled daily warmup evaluation in ${Math.floor(timeUntilEvaluation / 60000)} minutes`);
+    }
+    /**
+     * Evaluate warmup progress and possibly advance stages
+     */
+    evaluateWarmupProgress() {
+        if (!this.config.autoAdvanceStages) {
+            logger.log('info', 'Auto-advance stages is disabled, skipping evaluation');
+            return;
+        }
+        // Convert entries to array for compatibility with older JS versions
+        Array.from(this.warmupStatuses.entries()).forEach(([ip, status]) => {
+            if (!status.isActive)
+                return;
+            // Check if current stage duration has elapsed
+            const currentStage = this.config.stages[status.currentStage - 1];
+            const now = new Date();
+            const daysSinceStageStart = Math.floor((now.getTime() - status.currentStageStartDate.getTime()) / (24 * 60 * 60 * 1000));
+            if (daysSinceStageStart >= currentStage.durationDays) {
+                // Check if metrics meet requirements for advancing
+                const metricsOK = this.checkStageMetrics(status, currentStage);
+                if (metricsOK) {
+                    // Advance to next stage if not at the final stage
+                    if (status.currentStage < this.config.stages.length) {
+                        this.advanceToNextStage(ip);
+                    }
+                    else {
+                        logger.log('info', `IP ${ip} has completed the warmup process`);
+                    }
+                }
+                else if (this.config.suspendOnMetricDecline) {
+                    // Suspend warmup if metrics don't meet requirements
+                    status.isActive = false;
+                    logger.log('warn', `Suspended warmup for IP ${ip} due to poor metrics`, {
+                        openRate: status.metrics.openRate,
+                        bounceRate: status.metrics.bounceRate,
+                        complaintRate: status.metrics.complaintRate
+                    });
+                }
+                else {
+                    // Extend current stage if metrics don't meet requirements
+                    logger.log('info', `Extending stage ${status.currentStage} for IP ${ip} due to metrics not meeting requirements`);
+                }
+            }
+        });
+        // Save updated statuses
+        this.saveWarmupStatuses();
+    }
+    /**
+     * Check if the current metrics meet the requirements for the stage
+     * @param status Warmup status to check
+     * @param stage Stage to check against
+     * @returns Whether metrics meet requirements
+     */
+    checkStageMetrics(status, stage) {
+        // If no target metrics specified, assume met
+        if (!stage.targetMetrics)
+            return true;
+        const metrics = status.metrics;
+        let meetsRequirements = true;
+        // Check each metric against requirements
+        if (stage.targetMetrics.minOpenRate !== undefined &&
+            metrics.openRate < stage.targetMetrics.minOpenRate) {
+            meetsRequirements = false;
+            logger.log('info', `Open rate ${metrics.openRate}% below target ${stage.targetMetrics.minOpenRate}% for IP ${status.ipAddress}`);
+        }
+        if (stage.targetMetrics.maxBounceRate !== undefined &&
+            metrics.bounceRate > stage.targetMetrics.maxBounceRate) {
+            meetsRequirements = false;
+            logger.log('info', `Bounce rate ${metrics.bounceRate}% above target ${stage.targetMetrics.maxBounceRate}% for IP ${status.ipAddress}`);
+        }
+        if (stage.targetMetrics.maxComplaintRate !== undefined &&
+            metrics.complaintRate > stage.targetMetrics.maxComplaintRate) {
+            meetsRequirements = false;
+            logger.log('info', `Complaint rate ${metrics.complaintRate}% above target ${stage.targetMetrics.maxComplaintRate}% for IP ${status.ipAddress}`);
+        }
+        return meetsRequirements;
+    }
+    /**
+     * Advance IP to the next warmup stage
+     * @param ipAddress IP address to advance
+     */
+    advanceToNextStage(ipAddress) {
+        const status = this.warmupStatuses.get(ipAddress);
+        if (!status)
+            return;
+        // Store metrics for the completed stage
+        const completedStage = status.currentStage;
+        // Advance to next stage
+        status.currentStage++;
+        status.currentStageStartDate = new Date();
+        status.sentInCurrentStage = 0;
+        // Update allocation
+        const newStage = this.config.stages[status.currentStage - 1];
+        status.currentDailyAllocation = newStage.maxDailyVolume;
+        logger.log('info', `Advanced IP ${ipAddress} to warmup stage ${status.currentStage}`, {
+            previousStage: completedStage,
+            newDailyLimit: status.currentDailyAllocation,
+            durationDays: newStage.durationDays
+        });
+    }
+    /**
+     * Get warmup status for all IPs or a specific IP
+     * @param ipAddress Optional specific IP to get status for
+     * @returns Warmup status information
+     */
+    getWarmupStatus(ipAddress) {
+        if (ipAddress) {
+            return this.warmupStatuses.get(ipAddress);
+        }
+        return this.warmupStatuses;
+    }
+    /**
+     * Add a new IP address to the warmup process
+     * @param ipAddress IP address to add
+     */
+    addIPToWarmup(ipAddress) {
+        if (this.config.ipAddresses.includes(ipAddress)) {
+            logger.log('info', `IP ${ipAddress} is already in warmup`);
+            return;
+        }
+        // Add to configuration
+        this.config.ipAddresses.push(ipAddress);
+        // Initialize warmup
+        this.initializeIPWarmup(ipAddress);
+        // Initialize counters
+        this.dailySendCounts.set(ipAddress, 0);
+        this.hourlySendCounts.set(ipAddress, Array(24).fill(0));
+        logger.log('info', `Added IP ${ipAddress} to warmup process`);
+    }
+    /**
+     * Remove an IP address from the warmup process
+     * @param ipAddress IP address to remove
+     */
+    removeIPFromWarmup(ipAddress) {
+        const index = this.config.ipAddresses.indexOf(ipAddress);
+        if (index === -1) {
+            logger.log('info', `IP ${ipAddress} is not in warmup`);
+            return;
+        }
+        // Remove from configuration
+        this.config.ipAddresses.splice(index, 1);
+        // Remove from statuses and counters
+        this.warmupStatuses.delete(ipAddress);
+        this.dailySendCounts.delete(ipAddress);
+        this.hourlySendCounts.delete(ipAddress);
+        this.saveWarmupStatuses();
+        logger.log('info', `Removed IP ${ipAddress} from warmup process`);
+    }
+    /**
+     * Update metrics for an IP address
+     * @param ipAddress IP address to update
+     * @param metrics New metrics
+     */
+    updateMetrics(ipAddress, metrics) {
+        const status = this.warmupStatuses.get(ipAddress);
+        if (!status) {
+            logger.log('warn', `Cannot update metrics for IP ${ipAddress} - not in warmup`);
+            return;
+        }
+        // Update metrics
+        if (metrics.openRate !== undefined) {
+            status.metrics.openRate = metrics.openRate;
+        }
+        if (metrics.bounceRate !== undefined) {
+            status.metrics.bounceRate = metrics.bounceRate;
+        }
+        if (metrics.complaintRate !== undefined) {
+            status.metrics.complaintRate = metrics.complaintRate;
+        }
+        this.saveWarmupStatuses();
+        logger.log('info', `Updated metrics for IP ${ipAddress}`, {
+            openRate: status.metrics.openRate,
+            bounceRate: status.metrics.bounceRate,
+            complaintRate: status.metrics.complaintRate
+        });
+    }
+    /**
+     * Record a send event for an IP address
+     * @param ipAddress IP address used for sending
+     */
+    recordSend(ipAddress) {
+        if (!this.config.ipAddresses.includes(ipAddress)) {
+            logger.log('warn', `Cannot record send for IP ${ipAddress} - not in warmup`);
+            return;
+        }
+        // Increment daily counter
+        const currentCount = this.dailySendCounts.get(ipAddress) || 0;
+        this.dailySendCounts.set(ipAddress, currentCount + 1);
+        // Increment hourly counter
+        const hourlyCount = this.hourlySendCounts.get(ipAddress) || Array(24).fill(0);
+        const currentHour = new Date().getHours();
+        hourlyCount[currentHour]++;
+        this.hourlySendCounts.set(ipAddress, hourlyCount);
+        // Update warmup status
+        const status = this.warmupStatuses.get(ipAddress);
+        if (status) {
+            status.sentInCurrentStage++;
+            status.totalSent++;
+        }
+    }
+    /**
+     * Check if an IP can send more emails today
+     * @param ipAddress IP address to check
+     * @returns Whether the IP can send more emails
+     */
+    canSendMoreToday(ipAddress) {
+        if (!this.config.enabled)
+            return true;
+        if (!this.config.ipAddresses.includes(ipAddress)) {
+            // If not in warmup, assume it can send
+            return true;
+        }
+        const status = this.warmupStatuses.get(ipAddress);
+        if (!status || !status.isActive) {
+            return false;
+        }
+        const currentCount = this.dailySendCounts.get(ipAddress) || 0;
+        return currentCount < status.currentDailyAllocation;
+    }
+    /**
+     * Check if an IP can send more emails in the current hour
+     * @param ipAddress IP address to check
+     * @returns Whether the IP can send more emails this hour
+     */
+    canSendMoreThisHour(ipAddress) {
+        if (!this.config.enabled)
+            return true;
+        if (!this.config.ipAddresses.includes(ipAddress)) {
+            // If not in warmup, assume it can send
+            return true;
+        }
+        const status = this.warmupStatuses.get(ipAddress);
+        if (!status || !status.isActive) {
+            return false;
+        }
+        const currentDailyLimit = status.currentDailyAllocation;
+        const currentHour = new Date().getHours();
+        const hourlyAllocation = Math.ceil((currentDailyLimit * this.config.hourlyDistribution[currentHour]) / 100);
+        const hourlyCount = this.hourlySendCounts.get(ipAddress) || Array(24).fill(0);
+        const currentHourCount = hourlyCount[currentHour];
+        return currentHourCount < hourlyAllocation;
+    }
+    /**
+     * Get the best IP to use for sending an email
+     * @param emailInfo Information about the email being sent
+     * @returns The best IP to use, or null if no suitable IP is available
+     */
+    getBestIPForSending(emailInfo) {
+        // If warmup is disabled, return null (caller will use default IP)
+        if (!this.config.enabled || this.config.ipAddresses.length === 0) {
+            return null;
+        }
+        // Prepare information for allocation policy
+        const availableIPs = this.config.ipAddresses
+            .filter(ip => this.canSendMoreToday(ip) && this.canSendMoreThisHour(ip))
+            .map(ip => {
+            const status = this.warmupStatuses.get(ip);
+            return {
+                ip,
+                priority: status ? status.currentStage : 1,
+                capacity: status ? (status.currentDailyAllocation - (this.dailySendCounts.get(ip) || 0)) : 0
+            };
+        });
+        // Use the active allocation policy to determine the best IP
+        const policy = this.allocationPolicies.get(this.activePolicy);
+        if (!policy) {
+            logger.log('warn', `No allocation policy named ${this.activePolicy} found`);
+            return null;
+        }
+        return policy.allocateIP(availableIPs, {
+            ...emailInfo,
+            isTransactional: emailInfo.isTransactional || false,
+            isWarmup: true
+        });
+    }
+    /**
+     * Register a new IP allocation policy
+     * @param name Policy name
+     * @param policy Policy implementation
+     */
+    registerAllocationPolicy(name, policy) {
+        this.allocationPolicies.set(name, policy);
+        logger.log('info', `Registered IP allocation policy: ${name}`);
+    }
+    /**
+     * Set the active IP allocation policy
+     * @param name Policy name
+     */
+    setActiveAllocationPolicy(name) {
+        if (!this.allocationPolicies.has(name)) {
+            logger.log('warn', `No allocation policy named ${name} found`);
+            return;
+        }
+        this.activePolicy = name;
+        logger.log('info', `Set active IP allocation policy to ${name}`);
+    }
+    /**
+     * Get the total number of stages in the warmup process
+     * @returns Number of stages
+     */
+    getStageCount() {
+        return this.config.stages.length;
+    }
+    /**
+     * Load warmup statuses from storage
+     */
+    loadWarmupStatuses() {
+        try {
+            const warmupDir = plugins.path.join(paths.dataDir, 'warmup');
+            plugins.smartfile.fs.ensureDirSync(warmupDir);
+            const statusFile = plugins.path.join(warmupDir, 'ip_warmup_status.json');
+            if (plugins.fs.existsSync(statusFile)) {
+                const data = plugins.fs.readFileSync(statusFile, 'utf8');
+                const statuses = JSON.parse(data);
+                for (const status of statuses) {
+                    // Restore date objects
+                    status.startDate = new Date(status.startDate);
+                    status.currentStageStartDate = new Date(status.currentStageStartDate);
+                    status.targetCompletionDate = new Date(status.targetCompletionDate);
+                    this.warmupStatuses.set(status.ipAddress, status);
+                }
+                logger.log('info', `Loaded ${this.warmupStatuses.size} IP warmup statuses from storage`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to load warmup statuses: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+    /**
+     * Save warmup statuses to storage
+     */
+    saveWarmupStatuses() {
+        try {
+            const warmupDir = plugins.path.join(paths.dataDir, 'warmup');
+            plugins.smartfile.fs.ensureDirSync(warmupDir);
+            const statusFile = plugins.path.join(warmupDir, 'ip_warmup_status.json');
+            const statuses = Array.from(this.warmupStatuses.values());
+            plugins.smartfile.memory.toFsSync(JSON.stringify(statuses, null, 2), statusFile);
+            logger.log('debug', `Saved ${statuses.length} IP warmup statuses to storage`);
+        }
+        catch (error) {
+            logger.log('error', `Failed to save warmup statuses: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+}
+/**
+ * Policy that balances traffic across IPs based on stage and capacity
+ */
+class BalancedAllocationPolicy {
+    constructor() {
+        this.name = 'balanced';
+    }
+    allocateIP(availableIPs, emailInfo) {
+        if (availableIPs.length === 0)
+            return null;
+        // Sort IPs by priority (prefer higher stage IPs) and capacity
+        const sortedIPs = [...availableIPs].sort((a, b) => {
+            // First by priority (descending)
+            if (b.priority !== a.priority) {
+                return b.priority - a.priority;
+            }
+            // Then by remaining capacity (descending)
+            return b.capacity - a.capacity;
+        });
+        // Prioritize higher-stage IPs for transactional emails
+        if (emailInfo.isTransactional) {
+            return sortedIPs[0].ip;
+        }
+        // For marketing emails, spread across IPs with preference for higher stages
+        // Use weighted random selection based on stage
+        const totalWeight = sortedIPs.reduce((sum, ip) => sum + ip.priority, 0);
+        let randomPoint = Math.random() * totalWeight;
+        for (const ip of sortedIPs) {
+            randomPoint -= ip.priority;
+            if (randomPoint <= 0) {
+                return ip.ip;
+            }
+        }
+        // Fallback to the highest priority IP
+        return sortedIPs[0].ip;
+    }
+}
+/**
+ * Policy that rotates through IPs in a round-robin fashion
+ */
+class RoundRobinAllocationPolicy {
+    constructor() {
+        this.name = 'roundRobin';
+        this.lastIndex = -1;
+    }
+    allocateIP(availableIPs, emailInfo) {
+        if (availableIPs.length === 0)
+            return null;
+        // Sort by capacity to ensure even distribution
+        const sortedIPs = [...availableIPs].sort((a, b) => b.capacity - a.capacity);
+        // Move to next IP
+        this.lastIndex = (this.lastIndex + 1) % sortedIPs.length;
+        return sortedIPs[this.lastIndex].ip;
+    }
+}
+/**
+ * Policy that dedicates specific IPs to specific domains
+ */
+class DedicatedDomainPolicy {
+    constructor() {
+        this.name = 'dedicated';
+        this.domainAssignments = new Map();
+    }
+    allocateIP(availableIPs, emailInfo) {
+        if (availableIPs.length === 0)
+            return null;
+        // Check if we have a dedicated IP for this domain
+        if (this.domainAssignments.has(emailInfo.domain)) {
+            const dedicatedIP = this.domainAssignments.get(emailInfo.domain);
+            // Check if the dedicated IP is in the available list
+            const isAvailable = availableIPs.some(ip => ip.ip === dedicatedIP);
+            if (isAvailable) {
+                return dedicatedIP;
+            }
+        }
+        // If not, assign one and save the assignment
+        const sortedIPs = [...availableIPs].sort((a, b) => b.capacity - a.capacity);
+        const assignedIP = sortedIPs[0].ip;
+        this.domainAssignments.set(emailInfo.domain, assignedIP);
+        return assignedIP;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.ipwarmupmanager.js","sourceRoot":"","sources":["../../../ts/deliverability/classes.ipwarmupmanager.ts"],"names":[],"mappings":"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"}