_generateCompleteRange(rows, totals, startDate, today) {
        const startDateMoment = moment.utc(startDate).startOf('day');
        const endDateMoment = moment.utc(today).startOf('day');
        
        // Create a map of events by date for fast lookup
        const eventsMap = new Map();
        rows.forEach((row) => {
            const date = moment(row.date).format('YYYY-MM-DD');
            eventsMap.set(date, row);
        });

        // Sort rows chronologically to calculate historical totals
        rows.sort((a, b) => moment(a.date).valueOf() - moment(b.date).valueOf());

        // Work backwards from current totals to build historical data for event dates
        let runningPaid = totals.paid;
        let runningFree = totals.free;
        let runningComped = totals.comped;

        const historicalTotalsMap = new Map();
        
        // Calculate totals for each event date by working backwards
        for (let i = rows.length - 1; i >= 0; i -= 1) {
            const row = rows[i];
            const date = moment(row.date).format('YYYY-MM-DD');
            
            if (date > today) {
                continue; // Skip future dates
            }

            // Store the totals for this date
            historicalTotalsMap.set(date, {
                paid: Math.max(0, runningPaid),
                free: Math.max(0, runningFree),
                comped: Math.max(0, runningComped),
                paid_subscribed: row.paid_subscribed,
                paid_canceled: row.paid_canceled
            });

            // Update running totals for previous days
            runningPaid -= row.paid_subscribed - row.paid_canceled;
            runningFree -= row.free_delta;
            runningComped -= row.comped_delta;
        }

        // Generate complete date range from day before startDate to today (includes baseline)
        const results = [];
        const currentDate = moment(startDateMoment).subtract(1, 'day');
        
        // Track the last known values for forward-filling
        let lastKnownTotals = {
            paid: Math.max(0, runningPaid), // Historical baseline before all events
            free: Math.max(0, runningFree),
            comped: Math.max(0, runningComped)
        };

        while (currentDate.isSameOrBefore(endDateMoment)) {
            const dateStr = currentDate.format('YYYY-MM-DD');
            
            if (historicalTotalsMap.has(dateStr)) {
                // Use actual event data and update our last known totals
                const eventData = historicalTotalsMap.get(dateStr);
                lastKnownTotals = {
                    paid: eventData.paid,
                    free: eventData.free,
                    comped: eventData.comped
                };
                results.push({
                    date: dateStr,
                    paid: eventData.paid,
                    free: eventData.free,
                    comped: eventData.comped,
                    paid_subscribed: eventData.paid_subscribed,
                    paid_canceled: eventData.paid_canceled
                });
            } else {
                // Forward-fill with last known totals (no events on this day)
                results.push({
                    date: dateStr,
                    paid: lastKnownTotals.paid,
                    free: lastKnownTotals.free,
                    comped: lastKnownTotals.comped,
                    paid_subscribed: 0,
                    paid_canceled: 0
                });
            }
            
            currentDate.add(1, 'day');
        }

        return {
            data: results,
            meta: {
                totals
            }
        };
    }
Generate complete date range with forward-filling for frontend
@param {Array} rows - Event data from database
@param {Object} totals - Current member totals
@param {string|Date} startDate - Start date for range
@param {string} today - Today's date in YYYY-MM-DD format
@returns {Object} Complete date range data