@discomedia/utils 1.0.18 → 1.0.20

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import { startOfDay, set, endOfDay, add, sub, format, differenceInMilliseconds, isBefore } from 'date-fns';
-import { toZonedTime, fromZonedTime, formatInTimeZone } from 'date-fns-tz';
 import require$$0$3, { EventEmitter } from 'events';
 import require$$1 from 'https';
 import require$$2 from 'http';
@@ -146,13 +144,11 @@ const marketEarlyCloses = {
     },
 };
 
-// market-time.ts - Refactored for better organization and usability
-// ===== CONFIGURATION =====
-/**
- * Market configuration constants
- */
+// Constants for NY market times (Eastern Time)
 const MARKET_CONFIG = {
     TIMEZONE: 'America/New_York',
+    UTC_OFFSET_STANDARD: -5, // EST
+    UTC_OFFSET_DST: -4, // EDT
     TIMES: {
         EXTENDED_START: { hour: 4, minute: 0 },
         MARKET_OPEN: { hour: 9, minute: 30 },
@@ -163,48 +159,154 @@ const MARKET_CONFIG = {
         EARLY_EXTENDED_END: { hour: 17, minute: 0 },
     },
 };
-// ===== MARKET CALENDAR SERVICE =====
+// Helper: Get NY offset for a given UTC date (DST rules for US)
 /**
- * Service for handling market calendar operations (holidays, early closes, market days)
+ * Returns the NY timezone offset (in hours) for a given UTC date, accounting for US DST rules.
+ * @param date - UTC date
+ * @returns offset in hours (-5 for EST, -4 for EDT)
  */
-class MarketCalendar {
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
+function getNYOffset(date) {
+    // US DST starts 2nd Sunday in March, ends 1st Sunday in November
+    const year = date.getUTCFullYear();
+    const dstStart = getNthWeekdayOfMonth(year, 3, 0, 2); // March, Sunday, 2nd
+    const dstEnd = getNthWeekdayOfMonth(year, 11, 0, 1); // November, Sunday, 1st
+    const utcTime = date.getTime();
+    if (utcTime >= dstStart.getTime() && utcTime < dstEnd.getTime()) {
+        return MARKET_CONFIG.UTC_OFFSET_DST;
+    }
+    return MARKET_CONFIG.UTC_OFFSET_STANDARD;
+}
+// Helper: Get nth weekday of month in UTC
+/**
+ * Returns the nth weekday of a given month in UTC.
+ * @param year - Year
+ * @param month - 1-based month (e.g. March = 3)
+ * @param weekday - 0=Sunday, 1=Monday, ...
+ * @param n - nth occurrence
+ * @returns Date object for the nth weekday
+ */
+function getNthWeekdayOfMonth(year, month, weekday, n) {
+    let count = 0;
+    for (let d = 1; d <= 31; d++) {
+        const date = new Date(Date.UTC(year, month - 1, d));
+        if (date.getUTCMonth() !== month - 1)
+            break;
+        if (date.getUTCDay() === weekday) {
+            count++;
+            if (count === n)
+                return date;
+        }
     }
+    // fallback: last day of month
+    return new Date(Date.UTC(year, month - 1, 28));
+}
+// Helper: Convert UTC date to NY time (returns new Date object)
+/**
+ * Converts a UTC date to NY time (returns a new Date object).
+ * @param date - UTC date
+ * @returns Date object in NY time
+ */
+function toNYTime(date) {
+    const offset = getNYOffset(date);
+    // NY offset in hours
+    const utcMillis = date.getTime();
+    const nyMillis = utcMillis + offset * 60 * 60 * 1000;
+    return new Date(nyMillis);
+}
+// Helper: Convert NY time to UTC (returns new Date object)
+/**
+ * Converts a NY time date to UTC (returns a new Date object).
+ * @param date - NY time date
+ * @returns Date object in UTC
+ */
+function fromNYTime(date) {
+    const offset = getNYOffset(date);
+    const nyMillis = date.getTime();
+    const utcMillis = nyMillis - offset * 60 * 60 * 1000;
+    return new Date(utcMillis);
+}
+// Helper: Format date in ISO, unix, etc.
+/**
+ * Formats a date in ISO, unix-seconds, or unix-ms format.
+ * @param date - Date object
+ * @param outputFormat - Output format ('iso', 'unix-seconds', 'unix-ms')
+ * @returns Formatted date string or number
+ */
+function formatDate(date, outputFormat = 'iso') {
+    switch (outputFormat) {
+        case 'unix-seconds':
+            return Math.floor(date.getTime() / 1000);
+        case 'unix-ms':
+            return date.getTime();
+        case 'iso':
+        default:
+            return date.toISOString();
+    }
+}
+// Helper: Format date in NY locale string
+/**
+ * Formats a date in NY locale string.
+ * @param date - Date object
+ * @returns NY locale string
+ */
+function formatNYLocale(date) {
+    return date.toLocaleString('en-US', { timeZone: 'America/New_York' });
+}
+// Market calendar logic
+/**
+ * Market calendar logic for holidays, weekends, and market days.
+ */
+class MarketCalendar {
     /**
-     * Check if a date is a weekend
+     * Checks if a date is a weekend in NY time.
+     * @param date - Date object
+     * @returns true if weekend, false otherwise
      */
     isWeekend(date) {
-        const day = date.getDay();
-        return day === 0 || day === 6; // Sunday or Saturday
+        const day = toNYTime(date).getUTCDay();
+        return day === 0 || day === 6;
     }
     /**
-     * Check if a date is a market holiday
+     * Checks if a date is a market holiday in NY time.
+     * @param date - Date object
+     * @returns true if holiday, false otherwise
      */
     isHoliday(date) {
-        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-        const year = toZonedTime(date, this.timezone).getFullYear();
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
         const yearHolidays = marketHolidays[year];
         if (!yearHolidays)
             return false;
         return Object.values(yearHolidays).some(holiday => holiday.date === formattedDate);
     }
     /**
-     * Check if a date is an early close day
+     * Checks if a date is an early close day in NY time.
+     * @param date - Date object
+     * @returns true if early close, false otherwise
      */
     isEarlyCloseDay(date) {
-        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-        const year = toZonedTime(date, this.timezone).getFullYear();
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
         const yearEarlyCloses = marketEarlyCloses[year];
         return yearEarlyCloses && yearEarlyCloses[formattedDate] !== undefined;
     }
     /**
-     * Get the early close time for a date (in minutes from midnight)
+     * Gets the early close time (in minutes from midnight) for a given date.
+     * @param date - Date object
+     * @returns minutes from midnight or null
      */
     getEarlyCloseTime(date) {
-        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
-        const year = toZonedTime(date, this.timezone).getFullYear();
+        const nyDate = toNYTime(date);
+        const year = nyDate.getUTCFullYear();
+        const month = nyDate.getUTCMonth() + 1;
+        const day = nyDate.getUTCDate();
+        const formattedDate = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
         const yearEarlyCloses = marketEarlyCloses[year];
         if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
             const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(':').map(Number);
@@ -213,617 +315,572 @@ class MarketCalendar {
         return null;
     }
     /**
-     * Check if a date is a market day (not weekend or holiday)
+     * Checks if a date is a market day (not weekend or holiday).
+     * @param date - Date object
+     * @returns true if market day, false otherwise
      */
     isMarketDay(date) {
         return !this.isWeekend(date) && !this.isHoliday(date);
     }
     /**
-     * Get the next market day from a given date
+     * Gets the next market day after the given date.
+     * @param date - Date object
+     * @returns Date object for next market day
      */
     getNextMarketDay(date) {
-        let nextDay = add(date, { days: 1 });
+        let nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1000);
         while (!this.isMarketDay(nextDay)) {
-            nextDay = add(nextDay, { days: 1 });
+            nextDay = new Date(nextDay.getTime() + 24 * 60 * 60 * 1000);
         }
         return nextDay;
     }
     /**
-     * Get the previous market day from a given date
+     * Gets the previous market day before the given date.
+     * @param date - Date object
+     * @returns Date object for previous market day
      */
     getPreviousMarketDay(date) {
-        let prevDay = sub(date, { days: 1 });
+        let prevDay = new Date(date.getTime() - 24 * 60 * 60 * 1000);
         while (!this.isMarketDay(prevDay)) {
-            prevDay = sub(prevDay, { days: 1 });
+            prevDay = new Date(prevDay.getTime() - 24 * 60 * 60 * 1000);
         }
         return prevDay;
     }
 }
-// ===== TIME FORMATTER SERVICE =====
+// Market open/close times
 /**
- * Service for formatting time outputs
+ * Returns market open/close times for a given date, including extended and early closes.
+ * @param date - Date object
+ * @returns MarketOpenCloseResult
  */
-class TimeFormatter {
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
-    }
-    /**
-     * Format a date based on the output format
-     */
-    formatDate(date, outputFormat = 'iso') {
-        switch (outputFormat) {
-            case 'unix-seconds':
-                return Math.floor(date.getTime() / 1000);
-            case 'unix-ms':
-                return date.getTime();
-            case 'iso':
-            default:
-                return formatInTimeZone(date, this.timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
-        }
-    }
-    /**
-     * Get New York timezone offset
-     */
-    getNYTimeZone(date = new Date()) {
-        const dtf = new Intl.DateTimeFormat('en-US', {
-            timeZone: this.timezone,
-            timeZoneName: 'shortOffset',
-        });
-        const parts = dtf.formatToParts(date);
-        const tz = parts.find(p => p.type === 'timeZoneName')?.value;
-        if (!tz) {
-            throw new Error('Could not determine New York offset');
-        }
-        const shortOffset = tz.replace('GMT', '');
-        if (shortOffset === '-4') {
-            return '-04:00';
-        }
-        else if (shortOffset === '-5') {
-            return '-05:00';
-        }
-        else {
-            throw new Error(`Unexpected timezone offset: ${shortOffset}`);
-        }
+function getMarketTimes(date) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    if (!calendar.isMarketDay(date)) {
+        return {
+            marketOpen: false,
+            open: null,
+            close: null,
+            openExt: null,
+            closeExt: null,
+        };
     }
-    /**
-     * Get trading date in YYYY-MM-DD format
-     */
-    getTradingDate(time) {
-        let date;
-        if (typeof time === 'number') {
-            date = new Date(time);
-        }
-        else if (typeof time === 'string') {
-            date = new Date(time);
-        }
-        else {
-            date = time;
-        }
-        return formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    // Helper to build NY time for a given hour/minute
+    function buildNYTime(hour, minute) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, 0, 0));
+        return fromNYTime(d);
+    }
+    let open = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute);
+    let close = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute);
+    let openExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute);
+    let closeExt = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute);
+    if (calendar.isEarlyCloseDay(date)) {
+        close = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute);
+        closeExt = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute);
     }
+    return {
+        marketOpen: true,
+        open,
+        close,
+        openExt,
+        closeExt,
+    };
 }
-// ===== MARKET TIME CALCULATOR =====
+// Is within market hours
 /**
- * Service for core market time calculations
+ * Checks if a date/time is within market hours, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns true if within hours, false otherwise
  */
-class MarketTimeCalculator {
-    calendar;
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
-        this.calendar = new MarketCalendar(timezone);
-    }
-    /**
-     * Get market open/close times for a date
-     */
-    getMarketTimes(date) {
-        const zonedDate = toZonedTime(date, this.timezone);
-        // Market closed on weekends and holidays
-        if (!this.calendar.isMarketDay(zonedDate)) {
-            return {
-                marketOpen: false,
-                open: null,
-                close: null,
-                openExt: null,
-                closeExt: null,
-            };
-        }
-        const dayStart = startOfDay(zonedDate);
-        // Regular market times
-        const open = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour, minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute }), this.timezone);
-        let close = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, minutes: MARKET_CONFIG.TIMES.MARKET_CLOSE.minute }), this.timezone);
-        // Extended hours
-        const openExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour, minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute }), this.timezone);
-        let closeExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EXTENDED_END.hour, minutes: MARKET_CONFIG.TIMES.EXTENDED_END.minute }), this.timezone);
-        // Handle early close days
-        if (this.calendar.isEarlyCloseDay(zonedDate)) {
-            close = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, minutes: MARKET_CONFIG.TIMES.EARLY_CLOSE.minute }), this.timezone);
-            closeExt = fromZonedTime(set(dayStart, { hours: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, minutes: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute }), this.timezone);
-        }
-        return {
-            marketOpen: true,
-            open,
-            close,
-            openExt,
-            closeExt,
-        };
-    }
-    /**
-     * Check if a time is within market hours based on intraday reporting mode
-     */
-    isWithinMarketHours(date, intradayReporting = 'market_hours') {
-        const zonedDate = toZonedTime(date, this.timezone);
-        // Not a market day
-        if (!this.calendar.isMarketDay(zonedDate)) {
-            return false;
-        }
-        const timeInMinutes = zonedDate.getHours() * 60 + zonedDate.getMinutes();
-        switch (intradayReporting) {
-            case 'extended_hours': {
-                const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-                let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-                }
-                return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
-            }
-            case 'continuous':
-                return true;
-            default: {
-                // 'market_hours'
-                const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-                let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-                }
-                return timeInMinutes >= startMinutes && timeInMinutes <= endMinutes;
+function isWithinMarketHoursImpl(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    if (!calendar.isMarketDay(date))
+        return false;
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    switch (intradayReporting) {
+        case 'extended_hours': {
+            let endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
             }
+            const startMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
         }
-    }
-    /**
-     * Get the last full trading date
-     */
-    getLastFullTradingDate(currentDate = new Date(), extendedHours = true) {
-        const nowET = toZonedTime(currentDate, this.timezone);
-        if (this.calendar.isMarketDay(nowET)) {
-            const timeInMinutes = nowET.getHours() * 60 + nowET.getMinutes();
-            let endMinutes;
-            if (extendedHours) {
-                endMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-                if (this.calendar.isEarlyCloseDay(nowET)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-                }
-            }
-            else {
-                endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-                if (this.calendar.isEarlyCloseDay(nowET)) {
-                    endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-                }
-            }
-            if (timeInMinutes >= endMinutes) {
-                return fromZonedTime(set(nowET, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
+        case 'continuous':
+            return true;
+        default: {
+            let endMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+            if (calendar.isEarlyCloseDay(date)) {
+                endMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
             }
+            const startMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+            return minutes >= startMinutes && minutes <= endMinutes;
         }
-        // Return the last completed trading day
-        const lastMarketDay = this.calendar.getPreviousMarketDay(nowET);
-        return fromZonedTime(set(lastMarketDay, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
     }
-    /**
-     * Get day boundaries based on intraday reporting mode
-     */
-    getDayBoundaries(date, intradayReporting = 'market_hours') {
-        const zonedDate = toZonedTime(date, this.timezone);
-        let start;
-        let end;
-        switch (intradayReporting) {
-            case 'extended_hours': {
-                start = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
-                    minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
-                    seconds: 0,
-                    milliseconds: 0,
-                });
-                end = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.EXTENDED_END.hour,
-                    minutes: MARKET_CONFIG.TIMES.EXTENDED_END.minute,
-                    seconds: 59,
-                    milliseconds: 999,
-                });
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    end = set(zonedDate, {
-                        hours: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour,
-                        minutes: MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute,
-                        seconds: 59,
-                        milliseconds: 999,
-                    });
-                }
-                break;
-            }
-            case 'continuous': {
-                start = startOfDay(zonedDate);
-                end = endOfDay(zonedDate);
-                break;
+}
+// Get last full trading date
+/**
+ * Returns the last full trading date (market close) for a given date.
+ * @param currentDate - Date object (default: now)
+ * @returns Date object for last full trading date
+ */
+function getLastFullTradingDateImpl(currentDate = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(currentDate);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    if (calendar.isEarlyCloseDay(currentDate)) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+    }
+    // If not a market day, or before open, or during market hours, return previous market day's close
+    if (!calendar.isMarketDay(currentDate) || minutes < marketOpenMinutes || (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        const prevMarketDay = calendar.getPreviousMarketDay(currentDate);
+        let prevCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+        if (calendar.isEarlyCloseDay(prevMarketDay)) {
+            prevCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        }
+        const year = prevMarketDay.getUTCFullYear();
+        const month = prevMarketDay.getUTCMonth();
+        const day = prevMarketDay.getUTCDate();
+        const closeHour = Math.floor(prevCloseMinutes / 60);
+        const closeMinute = prevCloseMinutes % 60;
+        return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+    }
+    // After market close or after extended hours, return today's close
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    const closeHour = Math.floor(marketCloseMinutes / 60);
+    const closeMinute = marketCloseMinutes % 60;
+    return fromNYTime(new Date(Date.UTC(year, month, day, closeHour, closeMinute, 0, 0)));
+}
+// Get day boundaries
+/**
+ * Returns the start and end boundaries for a market day, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns Object with start and end Date
+ */
+function getDayBoundaries(date, intradayReporting = 'market_hours') {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const year = nyDate.getUTCFullYear();
+    const month = nyDate.getUTCMonth();
+    const day = nyDate.getUTCDate();
+    function buildNYTime(hour, minute, sec = 0, ms = 0) {
+        const d = new Date(Date.UTC(year, month, day, hour, minute, sec, ms));
+        return fromNYTime(d);
+    }
+    let start;
+    let end;
+    switch (intradayReporting) {
+        case 'extended_hours':
+            start = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_START.hour, MARKET_CONFIG.TIMES.EXTENDED_START.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.EXTENDED_END.hour, MARKET_CONFIG.TIMES.EXTENDED_END.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour, MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute, 59, 999);
             }
-            default: {
-                // 'market_hours'
-                start = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour,
-                    minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute,
-                    seconds: 0,
-                    milliseconds: 0,
-                });
-                end = set(zonedDate, {
-                    hours: MARKET_CONFIG.TIMES.MARKET_CLOSE.hour,
-                    minutes: MARKET_CONFIG.TIMES.MARKET_CLOSE.minute,
-                    seconds: 59,
-                    milliseconds: 999,
-                });
-                // Handle early close
-                if (this.calendar.isEarlyCloseDay(zonedDate)) {
-                    end = set(zonedDate, {
-                        hours: MARKET_CONFIG.TIMES.EARLY_CLOSE.hour,
-                        minutes: MARKET_CONFIG.TIMES.EARLY_CLOSE.minute,
-                        seconds: 59,
-                        milliseconds: 999,
-                    });
-                }
-                break;
+            break;
+        case 'continuous':
+            start = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+            end = new Date(Date.UTC(year, month, day, 23, 59, 59, 999));
+            break;
+        default:
+            start = buildNYTime(MARKET_CONFIG.TIMES.MARKET_OPEN.hour, MARKET_CONFIG.TIMES.MARKET_OPEN.minute, 0, 0);
+            end = buildNYTime(MARKET_CONFIG.TIMES.MARKET_CLOSE.hour, MARKET_CONFIG.TIMES.MARKET_CLOSE.minute, 59, 999);
+            if (calendar.isEarlyCloseDay(date)) {
+                end = buildNYTime(MARKET_CONFIG.TIMES.EARLY_CLOSE.hour, MARKET_CONFIG.TIMES.EARLY_CLOSE.minute, 59, 999);
             }
-        }
-        return {
-            start: fromZonedTime(start, this.timezone),
-            end: fromZonedTime(end, this.timezone),
-        };
+            break;
     }
+    return { start, end };
 }
-// ===== PERIOD CALCULATOR =====
+// Period calculator
 /**
- * Service for calculating time periods
+ * Calculates the start date for a given period ending at endDate.
+ * @param endDate - Date object
+ * @param period - Period string
+ * @returns Date object for period start
  */
-class PeriodCalculator {
-    calendar;
-    timeCalculator;
-    formatter;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.calendar = new MarketCalendar(timezone);
-        this.timeCalculator = new MarketTimeCalculator(timezone);
-        this.formatter = new TimeFormatter(timezone);
-    }
-    /**
-     * Calculate the start date for a given period
-     */
-    calculatePeriodStartDate(endDate, period) {
-        let startDate;
-        switch (period) {
-            case 'YTD':
-                startDate = set(endDate, { month: 0, date: 1 });
-                break;
-            case '1D':
-                startDate = this.calendar.getPreviousMarketDay(endDate);
-                break;
-            case '3D':
-                startDate = sub(endDate, { days: 3 });
-                break;
-            case '1W':
-                startDate = sub(endDate, { weeks: 1 });
-                break;
-            case '2W':
-                startDate = sub(endDate, { weeks: 2 });
-                break;
-            case '1M':
-                startDate = sub(endDate, { months: 1 });
-                break;
-            case '3M':
-                startDate = sub(endDate, { months: 3 });
-                break;
-            case '6M':
-                startDate = sub(endDate, { months: 6 });
-                break;
-            case '1Y':
-                startDate = sub(endDate, { years: 1 });
-                break;
-            default:
-                throw new Error(`Invalid period: ${period}`);
-        }
-        // Ensure start date is a market day
-        while (!this.calendar.isMarketDay(startDate)) {
-            startDate = this.calendar.getNextMarketDay(startDate);
-        }
-        return startDate;
+function calculatePeriodStartDate(endDate, period) {
+    const calendar = new MarketCalendar();
+    let startDate;
+    switch (period) {
+        case 'YTD':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), 0, 1));
+            break;
+        case '1D':
+            startDate = calendar.getPreviousMarketDay(endDate);
+            break;
+        case '3D':
+            startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);
+            break;
+        case '1W':
+            startDate = new Date(endDate.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case '2W':
+            startDate = new Date(endDate.getTime() - 14 * 24 * 60 * 60 * 1000);
+            break;
+        case '1M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 1, endDate.getUTCDate()));
+            break;
+        case '3M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 3, endDate.getUTCDate()));
+            break;
+        case '6M':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - 6, endDate.getUTCDate()));
+            break;
+        case '1Y':
+            startDate = new Date(Date.UTC(endDate.getUTCFullYear() - 1, endDate.getUTCMonth(), endDate.getUTCDate()));
+            break;
+        default:
+            throw new Error(`Invalid period: ${period}`);
     }
-    /**
-     * Get period dates for market time calculations
-     */
-    getMarketTimePeriod(params) {
-        const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso', } = params;
-        if (!period) {
-            throw new Error('Period is required');
-        }
-        const zonedEndDate = toZonedTime(end, MARKET_CONFIG.TIMEZONE);
-        // Determine effective end date based on current market conditions
-        let endDate;
-        const isCurrentMarketDay = this.calendar.isMarketDay(zonedEndDate);
-        const isWithinHours = this.timeCalculator.isWithinMarketHours(end, intraday_reporting);
-        const timeInMinutes = zonedEndDate.getHours() * 60 + zonedEndDate.getMinutes();
-        const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-        if (isCurrentMarketDay) {
-            if (timeInMinutes < marketStartMinutes) {
-                // Before market open - use previous day's close
-                const lastMarketDay = this.calendar.getPreviousMarketDay(zonedEndDate);
-                const { end: dayEnd } = this.timeCalculator.getDayBoundaries(lastMarketDay, intraday_reporting);
-                endDate = dayEnd;
-            }
-            else if (isWithinHours) {
-                // During market hours - use current time
-                endDate = end;
-            }
-            else {
-                // After market close - use today's close
-                const { end: dayEnd } = this.timeCalculator.getDayBoundaries(zonedEndDate, intraday_reporting);
-                endDate = dayEnd;
-            }
-        }
-        else {
-            // Not a market day - use previous market day's close
-            const lastMarketDay = this.calendar.getPreviousMarketDay(zonedEndDate);
-            const { end: dayEnd } = this.timeCalculator.getDayBoundaries(lastMarketDay, intraday_reporting);
-            endDate = dayEnd;
-        }
-        // Calculate start date
-        const periodStartDate = this.calculatePeriodStartDate(endDate, period);
-        const { start: dayStart } = this.timeCalculator.getDayBoundaries(periodStartDate, intraday_reporting);
-        // Ensure start is not after end
-        if (isBefore(endDate, dayStart)) {
-            throw new Error('Start date cannot be after end date');
-        }
-        return {
-            start: this.formatter.formatDate(dayStart, outputFormat),
-            end: this.formatter.formatDate(endDate, outputFormat),
-        };
+    // Ensure start date is a market day
+    while (!calendar.isMarketDay(startDate)) {
+        startDate = calendar.getNextMarketDay(startDate);
     }
+    return startDate;
 }
-// ===== MARKET STATUS SERVICE =====
+// Get market time period
 /**
- * Service for determining market status
+ * Returns the start and end dates for a market time period.
+ * @param params - MarketTimeParams
+ * @returns PeriodDates object
  */
-class MarketStatusService {
-    calendar;
-    timeCalculator;
-    timezone;
-    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
-        this.timezone = timezone;
-        this.calendar = new MarketCalendar(timezone);
-        this.timeCalculator = new MarketTimeCalculator(timezone);
-    }
-    /**
-     * Get current market status
-     */
-    getMarketStatus(date = new Date()) {
-        const nyTime = toZonedTime(date, this.timezone);
-        const timeInMinutes = nyTime.getHours() * 60 + nyTime.getMinutes();
-        const isMarketDay = this.calendar.isMarketDay(nyTime);
-        const isEarlyCloseDay = this.calendar.isEarlyCloseDay(nyTime);
-        // Time boundaries
-        const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
-        const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
-        const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
-        let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
-        let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
-        if (isEarlyCloseDay) {
-            marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
-            extendedEndMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
-        }
-        let status;
-        let nextStatus;
-        let nextStatusTime;
-        let marketPeriod;
-        if (!isMarketDay) {
-            // Market is closed (holiday/weekend)
-            status = 'closed';
-            nextStatus = 'extended hours';
-            marketPeriod = 'closed';
-            const nextMarketDay = this.calendar.getNextMarketDay(nyTime);
-            nextStatusTime = set(nextMarketDay, {
-                hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
-                minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
-            });
-        }
-        else if (timeInMinutes < extendedStartMinutes) {
-            // Before extended hours
-            status = 'closed';
-            nextStatus = 'extended hours';
-            marketPeriod = 'closed';
-            nextStatusTime = set(nyTime, {
-                hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
-                minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
-            });
-        }
-        else if (timeInMinutes < marketStartMinutes) {
-            // Pre-market extended hours
-            status = 'extended hours';
-            nextStatus = 'open';
-            marketPeriod = 'preMarket';
-            nextStatusTime = set(nyTime, {
-                hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour,
-                minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute,
-            });
+function getMarketTimePeriod(params) {
+    const { period, end = new Date(), intraday_reporting = 'market_hours', outputFormat = 'iso', } = params;
+    if (!period)
+        throw new Error('Period is required');
+    const calendar = new MarketCalendar();
+    const nyEndDate = toNYTime(end);
+    let endDate;
+    const isCurrentMarketDay = calendar.isMarketDay(end);
+    const isWithinHours = isWithinMarketHours(end, intraday_reporting);
+    const minutes = nyEndDate.getUTCHours() * 60 + nyEndDate.getUTCMinutes();
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    if (isCurrentMarketDay) {
+        if (minutes < marketStartMinutes) {
+            // Before market open - use previous day's close
+            const lastMarketDay = calendar.getPreviousMarketDay(end);
+            const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+            endDate = dayEnd;
         }
-        else if (timeInMinutes < marketCloseMinutes) {
-            // Market is open
-            status = 'open';
-            nextStatus = 'extended hours';
-            marketPeriod = timeInMinutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
-            nextStatusTime = set(nyTime, {
-                hours: isEarlyCloseDay ? MARKET_CONFIG.TIMES.EARLY_CLOSE.hour : MARKET_CONFIG.TIMES.MARKET_CLOSE.hour,
-                minutes: isEarlyCloseDay ? MARKET_CONFIG.TIMES.EARLY_CLOSE.minute : MARKET_CONFIG.TIMES.MARKET_CLOSE.minute,
-            });
-        }
-        else if (timeInMinutes < extendedEndMinutes) {
-            // After-market extended hours
-            status = 'extended hours';
-            nextStatus = 'closed';
-            marketPeriod = 'afterMarket';
-            nextStatusTime = set(nyTime, {
-                hours: isEarlyCloseDay ? MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour : MARKET_CONFIG.TIMES.EXTENDED_END.hour,
-                minutes: isEarlyCloseDay ? MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute : MARKET_CONFIG.TIMES.EXTENDED_END.minute,
-            });
+        else if (isWithinHours) {
+            // During market hours - use current time
+            endDate = end;
         }
         else {
-            // After extended hours
-            status = 'closed';
-            nextStatus = 'extended hours';
-            marketPeriod = 'closed';
-            const nextMarketDay = this.calendar.getNextMarketDay(nyTime);
-            nextStatusTime = set(nextMarketDay, {
-                hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
-                minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
-            });
+            // After market close - use today's close
+            const { end: dayEnd } = getDayBoundaries(end, intraday_reporting);
+            endDate = dayEnd;
         }
-        const nextStatusTimeUTC = fromZonedTime(nextStatusTime, this.timezone);
-        const dateFormat = 'MMMM dd, yyyy, HH:mm:ss a';
-        return {
-            time: date,
-            timeString: format(nyTime, dateFormat),
-            status,
-            nextStatus,
-            marketPeriod,
-            nextStatusTime: nextStatusTimeUTC,
-            nextStatusTimeDifference: differenceInMilliseconds(nextStatusTime, nyTime),
-            nextStatusTimeString: format(nextStatusTime, dateFormat),
-        };
     }
+    else {
+        // Not a market day - use previous market day's close
+        const lastMarketDay = calendar.getPreviousMarketDay(end);
+        const { end: dayEnd } = getDayBoundaries(lastMarketDay, intraday_reporting);
+        endDate = dayEnd;
+    }
+    // Calculate start date
+    const periodStartDate = calculatePeriodStartDate(endDate, period);
+    const { start: dayStart } = getDayBoundaries(periodStartDate, intraday_reporting);
+    if (endDate.getTime() < dayStart.getTime()) {
+        throw new Error('Start date cannot be after end date');
+    }
+    return {
+        start: formatDate(dayStart, outputFormat),
+        end: formatDate(endDate, outputFormat),
+    };
 }
-// ===== FUNCTIONAL API =====
+// Market status
 /**
- * Simple functional API that uses the services above
+ * Returns the current market status for a given date.
+ * @param date - Date object (default: now)
+ * @returns MarketStatus object
  */
-// Create service instances
-const marketCalendar = new MarketCalendar();
-const marketTimeCalculator = new MarketTimeCalculator();
-const periodCalculator = new PeriodCalculator();
-const marketStatusService = new MarketStatusService();
-const timeFormatter = new TimeFormatter();
+function getMarketStatusImpl(date = new Date()) {
+    const calendar = new MarketCalendar();
+    const nyDate = toNYTime(date);
+    const minutes = nyDate.getUTCHours() * 60 + nyDate.getUTCMinutes();
+    const isMarketDay = calendar.isMarketDay(date);
+    const isEarlyCloseDay = calendar.isEarlyCloseDay(date);
+    const extendedStartMinutes = MARKET_CONFIG.TIMES.EXTENDED_START.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_START.minute;
+    const marketStartMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const earlyMarketEndMinutes = MARKET_CONFIG.TIMES.EARLY_MARKET_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_MARKET_END.minute;
+    let marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+    if (isEarlyCloseDay) {
+        marketCloseMinutes = MARKET_CONFIG.TIMES.EARLY_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.EARLY_CLOSE.minute;
+        extendedEndMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+    }
+    let status;
+    let nextStatus;
+    let nextStatusTime;
+    let marketPeriod;
+    if (!isMarketDay) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    else if (minutes < extendedStartMinutes) {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').start;
+    }
+    else if (minutes < marketStartMinutes) {
+        status = 'extended hours';
+        nextStatus = 'open';
+        marketPeriod = 'preMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').start;
+    }
+    else if (minutes < marketCloseMinutes) {
+        status = 'open';
+        nextStatus = 'extended hours';
+        marketPeriod = minutes < earlyMarketEndMinutes ? 'earlyMarket' : 'regularMarket';
+        nextStatusTime = getDayBoundaries(date, 'market_hours').end;
+    }
+    else if (minutes < extendedEndMinutes) {
+        status = 'extended hours';
+        nextStatus = 'closed';
+        marketPeriod = 'afterMarket';
+        nextStatusTime = getDayBoundaries(date, 'extended_hours').end;
+    }
+    else {
+        status = 'closed';
+        nextStatus = 'extended hours';
+        marketPeriod = 'closed';
+        const nextMarketDay = calendar.getNextMarketDay(date);
+        nextStatusTime = getDayBoundaries(nextMarketDay, 'extended_hours').start;
+    }
+    const nextStatusTimeDifference = nextStatusTime.getTime() - nyDate.getTime();
+    return {
+        time: date,
+        timeString: formatNYLocale(nyDate),
+        status,
+        nextStatus,
+        marketPeriod,
+        nextStatusTime,
+        nextStatusTimeDifference,
+        nextStatusTimeString: formatNYLocale(nextStatusTime),
+    };
+}
+// API exports
 /**
- * Get market open/close times for a given date
+ * Returns market open/close times for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketOpenCloseResult
  */
 function getMarketOpenClose(options = {}) {
     const { date = new Date() } = options;
-    return marketTimeCalculator.getMarketTimes(date);
+    return getMarketTimes(date);
 }
 /**
- * Get start and end dates for a given market time period
+ * Returns the start and end dates for a market time period as Date objects.
+ * @param params - MarketTimeParams
+ * @returns Object with start and end Date
  */
 function getStartAndEndDates(params = {}) {
-    const { start, end } = periodCalculator.getMarketTimePeriod(params);
+    const { start, end } = getMarketTimePeriod(params);
     return {
-        start: new Date(start),
-        end: new Date(end),
+        start: typeof start === 'string' || typeof start === 'number' ? new Date(start) : start,
+        end: typeof end === 'string' || typeof end === 'number' ? new Date(end) : end,
     };
 }
 /**
- * Get the last full trading date
+ * Returns the last full trading date as a Date object.
+ */
+/**
+ * Returns the last full trading date as a Date object.
+ * @param currentDate - Date object (default: now)
+ * @returns Date object for last full trading date
  */
 function getLastFullTradingDate(currentDate = new Date()) {
-    const date = marketTimeCalculator.getLastFullTradingDate(currentDate);
-    return {
-        date,
-        YYYYMMDD: timeFormatter.getTradingDate(date),
-    };
+    return getLastFullTradingDateImpl(currentDate);
 }
 /**
- * Get the next market day
+ * Returns the next market day after the reference date.
+ * @param referenceDate - Date object (default: now)
+ * @returns Object with date, yyyymmdd string, and ISO string
  */
 function getNextMarketDay({ referenceDate } = {}) {
+    const calendar = new MarketCalendar();
     const startDate = referenceDate || new Date();
-    const nextDate = marketCalendar.getNextMarketDay(startDate);
-    // Convert to start of day in NY time
-    const startOfDayNY = startOfDay(toZonedTime(nextDate, MARKET_CONFIG.TIMEZONE));
-    const dateInET = fromZonedTime(startOfDayNY, MARKET_CONFIG.TIMEZONE);
+    const nextDate = calendar.getNextMarketDay(startDate);
+    const yyyymmdd = `${nextDate.getUTCFullYear()}-${String(nextDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nextDate.getUTCDate()).padStart(2, '0')}`;
     return {
-        date: dateInET,
-        yyyymmdd: timeFormatter.getTradingDate(dateInET),
-        dateISOString: dateInET.toISOString(),
+        date: nextDate,
+        yyyymmdd,
+        dateISOString: nextDate.toISOString(),
     };
 }
 /**
- * Get trading date in YYYY-MM-DD format
+ * Returns the trading date for a given time. Note: Just trims the date string; does not validate if the date is a market day.
+ * @param time - a string, number (unix timestamp), or Date object representing the time
+ * @returns the trading date as a string in YYYY-MM-DD format
+ */
+/**
+ * Returns the trading date for a given time in YYYY-MM-DD format (NY time).
+ * @param time - string, number, or Date
+ * @returns trading date string
  */
 function getTradingDate(time) {
-    return timeFormatter.getTradingDate(time);
+    const date = typeof time === 'number' ? new Date(time) : typeof time === 'string' ? new Date(time) : time;
+    const nyDate = toNYTime(date);
+    return `${nyDate.getUTCFullYear()}-${String(nyDate.getUTCMonth() + 1).padStart(2, '0')}-${String(nyDate.getUTCDate()).padStart(2, '0')}`;
 }
 /**
- * Get New York timezone offset
+ * Returns the NY timezone offset string for a given date.
+ * @param date - Date object (default: now)
+ * @returns '-04:00' for EDT, '-05:00' for EST
  */
 function getNYTimeZone(date) {
-    return timeFormatter.getNYTimeZone(date);
+    const offset = getNYOffset(date || new Date());
+    return offset === -4 ? '-04:00' : '-05:00';
 }
 /**
- * Get current market status
+ * Returns the current market status for a given date.
+ * @param options - { date?: Date }
+ * @returns MarketStatus object
  */
 function getMarketStatus(options = {}) {
     const { date = new Date() } = options;
-    return marketStatusService.getMarketStatus(date);
+    return getMarketStatusImpl(date);
 }
 /**
- * Check if a date is a market day
+ * Checks if a date/time is within market hours, extended hours, or continuous.
+ * @param date - Date object
+ * @param intradayReporting - 'market_hours', 'extended_hours', or 'continuous'
+ * @returns true if within hours, false otherwise
  */
-function isMarketDay(date) {
-    return marketCalendar.isMarketDay(date);
+function isWithinMarketHours(date, intradayReporting = 'market_hours') {
+    return isWithinMarketHoursImpl(date, intradayReporting);
 }
 /**
- * Check if a date is within market hours
+ * Returns full trading days from market open to market close.
+ * endDate is always the most recent market close (previous day's close if before open, today's close if after open).
+ * days: 1 or not specified = that day's open; 2 = previous market day's open, etc.
  */
-function isWithinMarketHours(date, intradayReporting = 'market_hours') {
-    return marketTimeCalculator.isWithinMarketHours(date, intradayReporting);
-}
 /**
- * Function to find complete trading date periods, starting at the beginning of one trading date and ending at the last.
- * By default, it gets the last trading date, returning the beginning and end. But we can also a) define the end date
- * on which to look (which is the end market date, e.g. for 8 july 2025 we'd return an end of 16:00 NY time on that date),
- * and to go back x days before, e.g. 7 would just subtract raw 7 days, giving us 4-5 trading days (depending on holidays).
- * @param options.endDate - The end date to use, defaults to today
- * @param options.days - The number of days to go back, defaults to 1
- * @returns The start and end dates with proper market open/close times
+ * Returns full trading days from market open to market close.
+ * @param options - { endDate?: Date, days?: number }
+ * @returns Object with startDate and endDate
  */
 function getTradingStartAndEndDates(options = {}) {
     const { endDate = new Date(), days = 1 } = options;
-    // Get the last full trading date for the end date
-    let endTradingDate;
-    // If within market hours, on a trading day, use the current date as end
-    if (isWithinMarketHours(endDate, 'market_hours')) {
-        endTradingDate = endDate;
-    }
-    else {
-        // If after market hours, use the last full trading date, which should be the previous trading day, or after extended hours, the same trading day
-        const lastFullTradingDate = marketTimeCalculator.getLastFullTradingDate(endDate, false);
-        endTradingDate = getMarketOpenClose({ date: lastFullTradingDate }).close;
-    }
-    let startDate;
-    if (days <= 1) {
-        // For 1 day, start is market open of the same trading day as end
-        startDate = getMarketOpenClose({ date: endTradingDate }).open;
+    const calendar = new MarketCalendar();
+    // Find the most recent market close
+    let endMarketDay = endDate;
+    const nyEnd = toNYTime(endDate);
+    const marketOpenMinutes = MARKET_CONFIG.TIMES.MARKET_OPEN.hour * 60 + MARKET_CONFIG.TIMES.MARKET_OPEN.minute;
+    const marketCloseMinutes = MARKET_CONFIG.TIMES.MARKET_CLOSE.hour * 60 + MARKET_CONFIG.TIMES.MARKET_CLOSE.minute;
+    const minutes = nyEnd.getUTCHours() * 60 + nyEnd.getUTCMinutes();
+    if (!calendar.isMarketDay(endDate) || minutes < marketOpenMinutes || (minutes >= marketOpenMinutes && minutes < marketCloseMinutes)) {
+        // Before market open, not a market day, or during market hours: use previous market day
+        endMarketDay = calendar.getPreviousMarketDay(endDate);
     }
     else {
-        // For multiple days, go back the specified number of trading days
-        let currentDate = new Date(endTradingDate);
-        let tradingDaysBack = 0;
-        // Count back trading days
-        while (tradingDaysBack < days - 1) {
-            currentDate = sub(currentDate, { days: 1 });
-            if (isMarketDay(currentDate)) {
-                tradingDaysBack++;
+        // After market close: use today
+        endMarketDay = endDate;
+    }
+    // Get market close for endMarketDay
+    const endClose = getMarketOpenClose({ date: endMarketDay }).close;
+    // Find start market day by iterating back over market days
+    let startMarketDay = endMarketDay;
+    let count = Math.max(1, days);
+    for (let i = 1; i < count; i++) {
+        startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+    }
+    // If days > 1, we need to go back (days-1) market days from endMarketDay
+    if (days > 1) {
+        startMarketDay = endMarketDay;
+        for (let i = 1; i < days; i++) {
+            startMarketDay = calendar.getPreviousMarketDay(startMarketDay);
+        }
+    }
+    const startOpen = getMarketOpenClose({ date: startMarketDay }).open;
+    return { startDate: startOpen, endDate: endClose };
+}
+/**
+ * Counts trading time between two dates (passed as standard Date objects), excluding weekends and holidays, and closed market hours, using other functions in this library.
+ *
+ * This function calculates the actual trading time between two dates by:
+ * 1. Iterating through each calendar day between startDate and endDate (inclusive)
+ * 2. For each day that is a market day (not weekend/holiday), getting market open/close times
+ * 3. Calculating the overlap between the time range and market hours for that day
+ * 4. Summing up all the trading minutes across all days
+ *
+ * The function automatically handles:
+ * - Weekends (Saturday/Sunday) - skipped entirely
+ * - Market holidays - skipped entirely
+ * - Early close days (e.g. day before holidays) - uses early close time
+ * - Times outside market hours - only counts time within 9:30am-4pm ET (or early close)
+ *
+ * Examples:
+ * - 12pm to 3:30pm same day = 3.5 hours = 210 minutes = 0.54 days
+ * - 9:30am to 4pm same day = 6.5 hours = 390 minutes = 1 day
+ * - Friday 2pm to Monday 2pm = 6.5 hours (Friday 2pm-4pm + Monday 9:30am-2pm)
+ *
+ * @param startDate - Start date/time
+ * @param endDate - End date/time (default: now)
+ * @returns Object containing:
+ *   - days: Trading time as fraction of full trading days (6.5 hours = 1 day)
+ *   - hours: Trading time in hours
+ *   - minutes: Trading time in minutes
+ */
+function countTradingDays(startDate, endDate = new Date()) {
+    const calendar = new MarketCalendar();
+    // Ensure start is before end
+    if (startDate.getTime() > endDate.getTime()) {
+        throw new Error('Start date must be before end date');
+    }
+    let totalMinutes = 0;
+    // Get the NY dates for iteration
+    const startNY = toNYTime(startDate);
+    const endNY = toNYTime(endDate);
+    // Create date at start of first day (in NY time)
+    const currentNY = new Date(Date.UTC(startNY.getUTCFullYear(), startNY.getUTCMonth(), startNY.getUTCDate(), 0, 0, 0, 0));
+    // Iterate through each calendar day
+    while (currentNY.getTime() <= endNY.getTime()) {
+        const currentUTC = fromNYTime(currentNY);
+        // Check if this is a market day
+        if (calendar.isMarketDay(currentUTC)) {
+            // Get market hours for this day
+            const marketTimes = getMarketTimes(currentUTC);
+            if (marketTimes.marketOpen && marketTimes.open && marketTimes.close) {
+                // Calculate the overlap between our time range and market hours
+                const dayStart = Math.max(startDate.getTime(), marketTimes.open.getTime());
+                const dayEnd = Math.min(endDate.getTime(), marketTimes.close.getTime());
+                // Only count if there's actual overlap
+                if (dayStart < dayEnd) {
+                    totalMinutes += (dayEnd - dayStart) / (1000 * 60);
+                }
             }
         }
-        // Get the market open time for the start date
-        startDate = getMarketOpenClose({ date: currentDate }).open;
+        // Move to next day
+        currentNY.setUTCDate(currentNY.getUTCDate() + 1);
     }
-    return { startDate, endDate: endTradingDate };
+    // Convert to days, hours, minutes
+    const MINUTES_PER_TRADING_DAY = 390; // 6.5 hours
+    const days = totalMinutes / MINUTES_PER_TRADING_DAY;
+    const hours = totalMinutes / 60;
+    const minutes = totalMinutes;
+    return {
+        days: Math.round(days * 1000) / 1000, // Round to 3 decimal places
+        hours: Math.round(hours * 100) / 100, // Round to 2 decimal places
+        minutes: Math.round(minutes)
+    };
 }
-// Export the MARKET_TIMES constant for backward compatibility
+// Export MARKET_TIMES for compatibility
 const MARKET_TIMES = {
     TIMEZONE: MARKET_CONFIG.TIMEZONE,
     PRE: {
@@ -1250,6 +1307,12 @@ class Queue {
 			current = current.next;
 		}
 	}
+
+	* drain() {
+		while (this.#head) {
+			yield this.dequeue();
+		}
+	}
 }
 
 function pLimit(concurrency) {
@@ -1737,7 +1800,7 @@ symbol, date = new Date(), options) => {
  * @returns {Promise<{ close: number; date: Date }>} The previous close price and date.
  */
 async function getPreviousClose(symbol, referenceDate, options) {
-    const previousDate = getLastFullTradingDate(referenceDate).date;
+    const previousDate = getLastFullTradingDate(referenceDate);
     const lastOpenClose = await fetchDailyOpenClose(symbol, previousDate, options);
     if (!lastOpenClose) {
         throw new Error(`Could not fetch last trade price for ${symbol}`);
@@ -2279,7 +2342,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '5.10.1'; // x-release-please-version
+const VERSION = '5.10.2'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -15399,7 +15462,7 @@ var config = {};
 
 var main = {exports: {}};
 
-var version = "17.2.0";
+var version = "17.2.1";
 var require$$4 = {
 	version: version};
 
@@ -15418,9 +15481,12 @@ function requireMain () {
 
 	// Array of tips to display randomly
 	const TIPS = [
-	  '🔐 encrypt with dotenvx: https://dotenvx.com',
+	  '🔐 encrypt with Dotenvx: https://dotenvx.com',
 	  '🔐 prevent committing .env to code: https://dotenvx.com/precommit',
 	  '🔐 prevent building .env in docker: https://dotenvx.com/prebuild',
+	  '📡 observe env with Radar: https://dotenvx.com/radar',
+	  '📡 auto-backup env with Radar: https://dotenvx.com/radar',
+	  '📡 version env with Radar: https://dotenvx.com/radar',
 	  '🛠️  run anywhere with `dotenvx run -- yourcommand`',
 	  '⚙️  specify custom .env file path with { path: \'/custom/path/.env\' }',
 	  '⚙️  enable debug logging with { debug: true }',
@@ -15721,7 +15787,7 @@ function requireMain () {
 	      }
 	    }
 
-	    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')} ${dim(`(tip: ${_getRandomTip()})`)}`);
+	    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')} ${dim(`-- tip: ${_getRandomTip()}`)}`);
 	  }
 
 	  if (lastError) {
@@ -16318,8 +16384,8 @@ class AlpacaMarketDataAPI extends EventEmitter {
         const response = await this.getHistoricalBars({
             symbols: [symbol],
             timeframe: '1Day',
-            start: prevMarketDate.date.toISOString(),
-            end: prevMarketDate.date.toISOString(),
+            start: prevMarketDate.toISOString(),
+            end: prevMarketDate.toISOString(),
             limit: 1,
         });
         if (!response.bars[symbol] || response.bars[symbol].length === 0) {
@@ -18206,6 +18272,7 @@ const disco = {
         getNYTimeZone: getNYTimeZone,
         getTradingDate: getTradingDate,
         getTradingStartAndEndDates: getTradingStartAndEndDates,
+        countTradingDays: countTradingDays,
         MARKET_TIMES: MARKET_TIMES,
     },
     utils: {