@discomedia/utils 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -1,181 +1,47 @@
-import ms from 'ms';
-import { fromZonedTime, formatInTimeZone, toZonedTime } from 'date-fns-tz';
-import { set, format, differenceInMilliseconds, startOfDay, sub, add, endOfDay, isBefore } from 'date-fns';
+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$1 from 'https';
+import require$$1 from 'https';
 import require$$2 from 'http';
-import require$$3 from 'net';
-import require$$4 from 'tls';
-import require$$1 from 'crypto';
+import require$$3$1 from 'net';
+import require$$4$1 from 'tls';
+import require$$3 from 'crypto';
 import require$$0$2 from 'stream';
 import require$$7 from 'url';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
+import require$$0$4 from 'fs';
+import require$$1$1 from 'path';
+import require$$2$1 from 'os';
 
-// time-utils.ts
-// Helper function to convert timestamp to Unix timestamp in seconds
-const toUnixTimestamp = (ts) => {
-    return Math.floor(new Date(ts).getTime() / 1000);
-};
-function getTimeAgo(dateString) {
-    // if format is like this: '20240919T102005', then first convert to '2024-09-19T10:20:05' format
-    let dateValue = dateString;
-    if (dateString && dateString.length === 15) {
-        dateValue = dateString.replace(/(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})/, '$1-$2-$3T$4:$5:$6');
-    }
-    const date = new Date(dateValue);
-    const now = new Date();
-    const diff = now.getTime() - date.getTime();
-    const seconds = Math.floor(diff / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    const months = Math.floor(days / 30);
-    const years = Math.floor(months / 12);
-    if (years > 0) {
-        return years === 1 ? '1 year ago' : `${years} years ago`;
-    }
-    else if (months > 0) {
-        return months === 1 ? '1 month ago' : `${months} months ago`;
-    }
-    else if (days > 0) {
-        return days === 1 ? '1 day ago' : `${days} days ago`;
-    }
-    else if (hours > 0) {
-        return hours === 1 ? '1 hr ago' : `${hours} hrs ago`;
-    }
-    else if (minutes > 0) {
-        return minutes === 1 ? '1 min ago' : `${minutes} mins ago`;
-    }
-    else {
-        return 'A few seconds ago';
-    }
-}
-function normalizeDate(timestamp) {
-    const date = new Date(timestamp);
-    return date.toISOString().split('T')[0]; // Returns 'YYYY-MM-DD'
-}
-// the function formerly known as CalculateRange, like a camel with two humps. Gross
-function calculateTimeRange(range) {
-    const currentDate = new Date();
-    switch (range) {
-        case '1d':
-            currentDate.setDate(currentDate.getDate() - 1);
-            break;
-        case '3d':
-            currentDate.setDate(currentDate.getDate() - 3);
-            break;
-        case '1w':
-            currentDate.setDate(currentDate.getDate() - 7);
-            break;
-        case '1m':
-            currentDate.setMonth(currentDate.getMonth() - 1);
-            break;
-        case '3m':
-            currentDate.setMonth(currentDate.getMonth() - 3);
-            break;
-        case '1y':
-            currentDate.setFullYear(currentDate.getFullYear() - 1);
-            break;
-        default:
-            throw new Error(`Invalid range: ${range}`);
+/**
+ * Logs a message to the console.
+ * @param message The message to log.
+ * @param options Optional options.
+ * @param options.source The source of the message.
+ * @param options.type The type of message to log.
+ * @param options.symbol The trading symbol associated with this log.
+ * @param options.account The account associated with this log.
+ */
+function log$1(message, options = { source: 'App', type: 'info' }) {
+    // Format the timestamp
+    const date = new Date();
+    const timestamp = date.toLocaleString('en-US', { timeZone: 'America/New_York' });
+    const account = options?.account;
+    const symbol = options?.symbol;
+    // Build the log message
+    const logMessage = `[${timestamp}]${options?.source ? ` [${options.source}] ` : ''}${account ? ` [${account}] ` : ''}${symbol ? ` [${symbol}] ` : ''}${message}`;
+    // Use appropriate console method based on type
+    if (options?.type === 'error') {
+        console.error(logMessage);
     }
-    return currentDate.toISOString().split('T')[0]; // format date to 'YYYY-MM-DD'
-}
-const daysLeft = (accountCreationDate, maxDays) => {
-    const now = new Date();
-    const endPeriodDate = new Date(accountCreationDate);
-    endPeriodDate.setDate(accountCreationDate.getDate() + maxDays);
-    const diffInMilliseconds = endPeriodDate.getTime() - now.getTime();
-    // Convert milliseconds to days and return
-    return Math.ceil(diffInMilliseconds / (1000 * 60 * 60 * 24));
-};
-const cutoffDate = new Date('2023-10-17T00:00:00.000Z');
-const calculateDaysLeft = (accountCreationDate) => {
-    let maxDays;
-    if (accountCreationDate < cutoffDate) {
-        maxDays = 30;
-        accountCreationDate = new Date('2023-10-01T00:00:00.000Z');
+    else if (options?.type === 'warn') {
+        console.warn(logMessage);
     }
     else {
-        maxDays = 14;
-    }
-    return daysLeft(accountCreationDate, maxDays);
-};
-const timeAgo = (timestamp) => {
-    if (!timestamp)
-        return 'Just now';
-    const diff = Date.now() - new Date(timestamp).getTime();
-    if (diff < 60000) {
-        // less than 1 second
-        return 'Just now';
-    }
-    else if (diff > 82800000) {
-        // more than 23 hours – similar to how Twitter displays timestamps
-        return new Date(timestamp).toLocaleDateString('en-US', {
-            month: 'short',
-            day: 'numeric',
-            year: new Date(timestamp).getFullYear() !== new Date().getFullYear() ? 'numeric' : undefined,
-        });
-    }
-    return `${ms(diff)} ago`;
-};
-// returns date utc
-const formatDate = (dateString, updateDate) => {
-    return new Date(dateString).toLocaleDateString('en-US', {
-        day: 'numeric',
-        month: 'long',
-        year: updateDate && new Date(dateString).getFullYear() === new Date().getFullYear() ? undefined : 'numeric',
-        timeZone: 'UTC',
-    });
-};
-const parseETDateFromAV = (dateString) => {
-    // Time zone identifier for Eastern Time
-    const timeZone = 'America/New_York';
-    // Split the input string into date and time components
-    const [datePart, timePart] = dateString.split(' ');
-    // Construct a full date-time string in ISO format
-    const fullString = `${datePart}T${timePart}`;
-    // Convert the string to a UTC Date object using date-fns-tz
-    const utcDate = fromZonedTime(fullString, timeZone); // Convert to UTC
-    return utcDate;
-};
-const formatToUSEastern = (date, justDate) => {
-    const options = {
-        timeZone: 'America/New_York',
-        month: 'short',
-        day: 'numeric',
-        year: 'numeric',
-    };
-    if (!justDate) {
-        options.hour = 'numeric';
-        options.minute = '2-digit';
-        options.hour12 = true;
+        console.log(logMessage);
     }
-    return date.toLocaleString('en-US', options);
-};
-const unixTimetoUSEastern = (timestamp) => {
-    const date = new Date(timestamp);
-    const timeString = formatToUSEastern(date);
-    const dateString = formatToUSEastern(date, true);
-    return { date, timeString, dateString };
-};
-const timeDiffString = (milliseconds) => {
-    const seconds = Math.floor(milliseconds / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    const remainingHours = hours % 24;
-    const remainingMinutes = minutes % 60;
-    const parts = [];
-    if (days > 0)
-        parts.push(`${days} day${days > 1 ? 's' : ''}`);
-    if (remainingHours > 0)
-        parts.push(`${remainingHours} hour${remainingHours > 1 ? 's' : ''}`);
-    if (remainingMinutes > 0)
-        parts.push(`${remainingMinutes} minute${remainingMinutes > 1 ? 's' : ''}`);
-    return parts.join(', ');
-};
+}
 
 // market-hours.ts
 const marketHolidays = {
@@ -280,99 +146,66 @@ const marketEarlyCloses = {
     },
 };
 
-// market-time.ts
+// market-time.ts - Refactored for better organization and usability
+// ===== CONFIGURATION =====
 /**
- * Market times for NYSE
- * Regular market hours are 9:30am-4:00pm
- * Early market hours are 9:30am-10:00am (first 30 minutes)
- * Extended market hours are 4:00am to 9:30am and 4:00pm-8:00pm
- * On days before some holidays, the market closes early at 1:00pm
- * Early extended market hours are 1:00pm-5:00pm on early close days
+ * Market configuration constants
  */
-const MARKET_TIMES = {
+const MARKET_CONFIG = {
     TIMEZONE: 'America/New_York',
-    PRE: { START: { HOUR: 4, MINUTE: 0, MINUTES: 240 }, END: { HOUR: 9, MINUTE: 30, MINUTES: 570 } },
-    EARLY_MORNING: { START: { HOUR: 9, MINUTE: 30, MINUTES: 570 }, END: { HOUR: 10, MINUTE: 0, MINUTES: 600 } }, // early market trading
-    EARLY_CLOSE_BEFORE_HOLIDAY: {
-        START: { HOUR: 9, MINUTE: 30, MINUTES: 570 },
-        END: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
-    }, // early market trading end
-    EARLY_EXTENDED_BEFORE_HOLIDAY: {
-        START: { HOUR: 13, MINUTE: 0, MINUTES: 780 },
-        END: { HOUR: 17, MINUTE: 0, MINUTES: 1020 },
-    }, // extended hours trading on early close days
-    REGULAR: { START: { HOUR: 9, MINUTE: 30, MINUTES: 570 }, END: { HOUR: 16, MINUTE: 0, MINUTES: 960 } },
-    EXTENDED: { START: { HOUR: 4, MINUTE: 0, MINUTES: 240 }, END: { HOUR: 20, MINUTE: 0, MINUTES: 1200 } },
+    TIMES: {
+        EXTENDED_START: { hour: 4, minute: 0 },
+        MARKET_OPEN: { hour: 9, minute: 30 },
+        EARLY_MARKET_END: { hour: 10, minute: 0 },
+        MARKET_CLOSE: { hour: 16, minute: 0 },
+        EARLY_CLOSE: { hour: 13, minute: 0 },
+        EXTENDED_END: { hour: 20, minute: 0 },
+        EARLY_EXTENDED_END: { hour: 17, minute: 0 },
+    },
 };
+// ===== MARKET CALENDAR SERVICE =====
 /**
- * Utility class for handling market time-related operations
+ * Service for handling market calendar operations (holidays, early closes, market days)
  */
-class MarketTimeUtil {
+class MarketCalendar {
     timezone;
-    intradayReporting;
-    /**
-     * Creates a new MarketTimeUtil instance
-     * @param {string} [timezone='America/New_York'] - The timezone to use for market time calculations
-     * @param {IntradayReporting} [intradayReporting='market_hours'] - The intraday reporting mode
-     */
-    constructor(timezone = MARKET_TIMES.TIMEZONE, intradayReporting = 'market_hours') {
-        this.validateTimezone(timezone);
+    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
         this.timezone = timezone;
-        this.intradayReporting = intradayReporting;
     }
     /**
-     * Validates the provided timezone
-     * @private
-     * @param {string} timezone - The timezone to validate
-     * @throws {Error} If the timezone is invalid
+     * Check if a date is a weekend
      */
-    validateTimezone(timezone) {
-        try {
-            Intl.DateTimeFormat(undefined, { timeZone: timezone });
-        }
-        catch (error) {
-            throw new Error(`Invalid timezone: ${timezone}`);
-        }
-    }
-    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 with timezone offset
-                return formatInTimeZone(date, this.timezone, "yyyy-MM-dd'T'HH:mm:ssXXX");
-        }
-    }
     isWeekend(date) {
         const day = date.getDay();
-        return day === 0 || day === 6;
+        return day === 0 || day === 6; // Sunday or Saturday
     }
+    /**
+     * Check if a date is a market holiday
+     */
     isHoliday(date) {
-        const formattedDate = format(date, 'yyyy-MM-dd');
-        const yearHolidays = marketHolidays[date.getFullYear()];
-        for (const holiday in yearHolidays) {
-            if (yearHolidays[holiday].date === formattedDate) {
-                return true;
-            }
-        }
-        return false;
+        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+        const year = toZonedTime(date, this.timezone).getFullYear();
+        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
+     */
     isEarlyCloseDay(date) {
-        const formattedDate = format(date, 'yyyy-MM-dd');
-        const yearEarlyCloses = marketEarlyCloses[date.getFullYear()];
+        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+        const year = toZonedTime(date, this.timezone).getFullYear();
+        const yearEarlyCloses = marketEarlyCloses[year];
         return yearEarlyCloses && yearEarlyCloses[formattedDate] !== undefined;
     }
     /**
-     * Get the early close time for a given date
-     * @param date - The date to get the early close time for
-     * @returns The early close time in minutes from midnight, or null if there is no early close
+     * Get the early close time for a date (in minutes from midnight)
      */
     getEarlyCloseTime(date) {
-        const formattedDate = format(date, 'yyyy-MM-dd');
-        const yearEarlyCloses = marketEarlyCloses[date.getFullYear()];
+        const formattedDate = formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
+        const year = toZonedTime(date, this.timezone).getFullYear();
+        const yearEarlyCloses = marketEarlyCloses[year];
         if (yearEarlyCloses && yearEarlyCloses[formattedDate]) {
             const [hours, minutes] = yearEarlyCloses[formattedDate].time.split(':').map(Number);
             return hours * 60 + minutes;
@@ -380,194 +213,283 @@ class MarketTimeUtil {
         return null;
     }
     /**
-     * Check if a given date is a market day
-     * @param date - The date to check
-     * @returns true if the date is a market day, false otherwise
+     * Check if a date is a market day (not weekend or holiday)
      */
     isMarketDay(date) {
-        const isWeekendDay = this.isWeekend(date);
-        const isHolidayDay = this.isHoliday(date);
-        const returner = !isWeekendDay && !isHolidayDay;
-        return returner;
+        return !this.isWeekend(date) && !this.isHoliday(date);
     }
     /**
-     * Check if a given date is within market hours
-     * @param date - The date to check
-     * @returns true if the date is within market hours, false otherwise
+     * Get the next market day from a given date
      */
-    isWithinMarketHours(date) {
-        // Check for holidays first
-        if (this.isHoliday(date)) {
-            return false;
+    getNextMarketDay(date) {
+        let nextDay = add(date, { days: 1 });
+        while (!this.isMarketDay(nextDay)) {
+            nextDay = add(nextDay, { days: 1 });
         }
-        const timeInMinutes = date.getHours() * 60 + date.getMinutes();
-        // Check for early closure
-        if (this.isEarlyCloseDay(date)) {
-            const earlyCloseMinutes = this.getEarlyCloseTime(date);
-            if (earlyCloseMinutes !== null && timeInMinutes > earlyCloseMinutes) {
-                return false;
-            }
+        return nextDay;
+    }
+    /**
+     * Get the previous market day from a given date
+     */
+    getPreviousMarketDay(date) {
+        let prevDay = sub(date, { days: 1 });
+        while (!this.isMarketDay(prevDay)) {
+            prevDay = sub(prevDay, { days: 1 });
         }
-        // Regular market hours logic
-        let returner;
-        switch (this.intradayReporting) {
-            case 'extended_hours': {
-                const extendedStartMinutes = MARKET_TIMES.EXTENDED.START.HOUR * 60 + MARKET_TIMES.EXTENDED.START.MINUTE;
-                const extendedEndMinutes = MARKET_TIMES.EXTENDED.END.HOUR * 60 + MARKET_TIMES.EXTENDED.END.MINUTE;
-                // Comprehensive handling of times crossing midnight
-                const adjustedDate = timeInMinutes < extendedStartMinutes ? sub(date, { days: 1 }) : date;
-                const adjustedTimeInMinutes = adjustedDate.getHours() * 60 + adjustedDate.getMinutes();
-                returner = adjustedTimeInMinutes >= extendedStartMinutes && adjustedTimeInMinutes <= extendedEndMinutes;
-                break;
-            }
-            case 'continuous':
-                returner = true;
-                break;
-            default: {
-                // market_hours
-                const regularStartMinutes = MARKET_TIMES.REGULAR.START.HOUR * 60 + MARKET_TIMES.REGULAR.START.MINUTE;
-                const regularEndMinutes = MARKET_TIMES.REGULAR.END.HOUR * 60 + MARKET_TIMES.REGULAR.END.MINUTE;
-                returner = timeInMinutes >= regularStartMinutes && timeInMinutes <= regularEndMinutes;
-                break;
-            }
+        return prevDay;
+    }
+}
+// ===== TIME FORMATTER SERVICE =====
+/**
+ * Service for formatting time outputs
+ */
+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");
         }
-        return returner;
     }
     /**
-     * Check if a given date is before market hours
-     * @param date - The date to check
-     * @returns true if the date is before market hours, false otherwise
+     * Get New York timezone offset
      */
-    isBeforeMarketHours(date) {
-        const timeInMinutes = date.getHours() * 60 + date.getMinutes();
-        const startMinutes = this.intradayReporting === 'extended_hours'
-            ? MARKET_TIMES.EXTENDED.START.HOUR * 60 + MARKET_TIMES.EXTENDED.START.MINUTE
-            : MARKET_TIMES.REGULAR.START.HOUR * 60 + MARKET_TIMES.REGULAR.START.MINUTE;
-        return timeInMinutes < startMinutes;
+    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}`);
+        }
     }
     /**
-     * Get the last trading date, i.e. the last date that was a market day
-     * @param currentDate - The current date
-     * @returns The last trading date
+     * Get trading date in YYYY-MM-DD format
      */
-    getLastTradingDate(currentDate = new Date()) {
-        const nowET = toZonedTime(currentDate, this.timezone);
-        const isMarketDayToday = this.isMarketDay(nowET);
-        const currentMinutes = nowET.getHours() * 60 + nowET.getMinutes();
-        const marketOpenMinutes = MARKET_TIMES.REGULAR.START.HOUR * 60 + MARKET_TIMES.REGULAR.START.MINUTE;
-        if (isMarketDayToday && currentMinutes >= marketOpenMinutes) {
-            // After market open on a market day, return today
-            return nowET;
+    getTradingDate(time) {
+        let date;
+        if (typeof time === 'number') {
+            date = new Date(time);
+        }
+        else if (typeof time === 'string') {
+            date = new Date(time);
         }
         else {
-            // Before market open, or not a market day, return previous trading day
-            let lastTradingDate = sub(nowET, { days: 1 });
-            while (!this.isMarketDay(lastTradingDate)) {
-                lastTradingDate = sub(lastTradingDate, { days: 1 });
-            }
-            return lastTradingDate;
+            date = time;
         }
+        return formatInTimeZone(date, this.timezone, 'yyyy-MM-dd');
     }
-    getLastMarketDay(date) {
-        let currentDate = sub(date, { days: 1 });
-        while (!this.isMarketDay(currentDate)) {
-            currentDate = sub(currentDate, { days: 1 });
+}
+// ===== MARKET TIME CALCULATOR =====
+/**
+ * Service for core market time calculations
+ */
+class MarketTimeCalculator {
+    calendar;
+    formatter;
+    timezone;
+    constructor(timezone = MARKET_CONFIG.TIMEZONE) {
+        this.timezone = timezone;
+        this.calendar = new MarketCalendar(timezone);
+        this.formatter = new TimeFormatter(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;
+            }
         }
-        return currentDate;
     }
+    /**
+     * Get the last full trading date
+     */
     getLastFullTradingDate(currentDate = new Date()) {
         const nowET = toZonedTime(currentDate, this.timezone);
-        // If today is a market day and we're after extended hours close
-        // then return today since it's a completed trading day
-        if (this.isMarketDay(nowET)) {
+        // If today is a market day and we're after extended hours close, return today
+        if (this.calendar.isMarketDay(nowET)) {
             const timeInMinutes = nowET.getHours() * 60 + nowET.getMinutes();
-            const extendedEndMinutes = MARKET_TIMES.EXTENDED.END.HOUR * 60 + MARKET_TIMES.EXTENDED.END.MINUTE;
-            // Check if we're after market close (including extended hours)
+            let extendedEndMinutes = MARKET_CONFIG.TIMES.EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EXTENDED_END.minute;
+            if (this.calendar.isEarlyCloseDay(nowET)) {
+                extendedEndMinutes = MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.hour * 60 + MARKET_CONFIG.TIMES.EARLY_EXTENDED_END.minute;
+            }
             if (timeInMinutes >= extendedEndMinutes) {
-                // Set to midnight ET while preserving the date
                 return fromZonedTime(set(nowET, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
             }
         }
-        // In all other cases (during trading hours, before market open, holidays, weekends),
-        // we want the last completed trading day
-        let lastFullDate = this.getLastMarketDay(nowET);
-        // Set to midnight ET while preserving the date
-        return fromZonedTime(set(lastFullDate, { hours: 0, minutes: 0, seconds: 0, milliseconds: 0 }), this.timezone);
+        // 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);
     }
     /**
-     * Gets the next market day from a reference date
-     * @param {Object} [options] - Options object
-     * @param {Date} [options.referenceDate] - The reference date (defaults to current date)
-     * @returns {Object} The next market day information
-     * @property {Date} date - The date object (start of day in NY time)
-     * @property {string} yyyymmdd - The date in YYYY-MM-DD format
-     * @property {string} dateISOString - Full ISO date string
+     * Get day boundaries based on intraday reporting mode
      */
-    getNextMarketDay(date) {
-        let currentDate = add(date, { days: 1 });
-        while (!this.isMarketDay(currentDate)) {
-            currentDate = add(currentDate, { days: 1 });
-        }
-        return currentDate;
-    }
-    getDayBoundaries(date) {
+    getDayBoundaries(date, intradayReporting = 'market_hours') {
+        const zonedDate = toZonedTime(date, this.timezone);
         let start;
         let end;
-        switch (this.intradayReporting) {
+        switch (intradayReporting) {
             case 'extended_hours': {
-                start = set(date, {
-                    hours: MARKET_TIMES.EXTENDED.START.HOUR,
-                    minutes: MARKET_TIMES.EXTENDED.START.MINUTE,
+                start = set(zonedDate, {
+                    hours: MARKET_CONFIG.TIMES.EXTENDED_START.hour,
+                    minutes: MARKET_CONFIG.TIMES.EXTENDED_START.minute,
                     seconds: 0,
                     milliseconds: 0,
                 });
-                end = set(date, {
-                    hours: MARKET_TIMES.EXTENDED.END.HOUR,
-                    minutes: MARKET_TIMES.EXTENDED.END.MINUTE,
+                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(date);
-                end = endOfDay(date);
+                start = startOfDay(zonedDate);
+                end = endOfDay(zonedDate);
                 break;
             }
             default: {
-                // market_hours
-                start = set(date, {
-                    hours: MARKET_TIMES.REGULAR.START.HOUR,
-                    minutes: MARKET_TIMES.REGULAR.START.MINUTE,
+                // 'market_hours'
+                start = set(zonedDate, {
+                    hours: MARKET_CONFIG.TIMES.MARKET_OPEN.hour,
+                    minutes: MARKET_CONFIG.TIMES.MARKET_OPEN.minute,
                     seconds: 0,
                     milliseconds: 0,
                 });
-                // Check for early close
-                if (this.isEarlyCloseDay(date)) {
-                    const earlyCloseMinutes = this.getEarlyCloseTime(date);
-                    if (earlyCloseMinutes !== null) {
-                        const earlyCloseHours = Math.floor(earlyCloseMinutes / 60);
-                        const earlyCloseMinutesRemainder = earlyCloseMinutes % 60;
-                        end = set(date, {
-                            hours: earlyCloseHours,
-                            minutes: earlyCloseMinutesRemainder,
-                            seconds: 59,
-                            milliseconds: 999,
-                        });
-                        break;
-                    }
-                }
-                end = set(date, {
-                    hours: MARKET_TIMES.REGULAR.END.HOUR,
-                    minutes: MARKET_TIMES.REGULAR.END.MINUTE,
+                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;
             }
         }
-        return { start, end };
+        return {
+            start: fromZonedTime(start, this.timezone),
+            end: fromZonedTime(end, this.timezone),
+        };
+    }
+}
+// ===== PERIOD CALCULATOR =====
+/**
+ * Service for calculating time periods
+ */
+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) {
@@ -575,7 +497,7 @@ class MarketTimeUtil {
                 startDate = set(endDate, { month: 0, date: 1 });
                 break;
             case '1D':
-                startDate = this.getLastMarketDay(endDate);
+                startDate = this.calendar.getPreviousMarketDay(endDate);
                 break;
             case '3D':
                 startDate = sub(endDate, { days: 3 });
@@ -601,405 +523,286 @@ class MarketTimeUtil {
             default:
                 throw new Error(`Invalid period: ${period}`);
         }
-        while (!this.isMarketDay(startDate)) {
-            startDate = this.getNextMarketDay(startDate);
+        // Ensure start date is a market day
+        while (!this.calendar.isMarketDay(startDate)) {
+            startDate = this.calendar.getNextMarketDay(startDate);
         }
         return startDate;
     }
-    getMarketTimePeriod({ period, end = new Date(), intraday_reporting, outputFormat = 'iso', }) {
+    /**
+     * 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');
         }
-        if (intraday_reporting) {
-            this.intradayReporting = intraday_reporting;
-        }
-        // Convert end date to specified timezone
-        const zonedEndDate = toZonedTime(end, this.timezone);
-        let startDate;
+        const zonedEndDate = toZonedTime(end, MARKET_CONFIG.TIMEZONE);
+        // Determine effective end date based on current market conditions
         let endDate;
-        const isCurrentMarketDay = this.isMarketDay(zonedEndDate);
-        const isWithinHours = this.isWithinMarketHours(zonedEndDate);
-        const isBeforeHours = this.isBeforeMarketHours(zonedEndDate);
-        // First determine the end date based on current market conditions
+        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 (isBeforeHours) {
-                // Case 1: Market day before open hours - use previous full trading day
-                const lastMarketDay = this.getLastMarketDay(zonedEndDate);
-                const { end: dayEnd } = this.getDayBoundaries(lastMarketDay);
+            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) {
-                // Case 2: Market day during hours - use current time
-                endDate = zonedEndDate;
+                // During market hours - use current time
+                endDate = end;
             }
             else {
-                // Case 3: Market day after close - use today's close
-                const { end: dayEnd } = this.getDayBoundaries(zonedEndDate);
+                // After market close - use today's close
+                const { end: dayEnd } = this.timeCalculator.getDayBoundaries(zonedEndDate, intraday_reporting);
                 endDate = dayEnd;
             }
         }
         else {
-            // Case 4: Not a market day - use previous market day's close
-            const lastMarketDay = this.getLastMarketDay(zonedEndDate);
-            const { end: dayEnd } = this.getDayBoundaries(lastMarketDay);
+            // 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;
         }
-        // Now calculate the start date based on the period
+        // Calculate start date
         const periodStartDate = this.calculatePeriodStartDate(endDate, period);
-        const { start: dayStart } = this.getDayBoundaries(periodStartDate);
-        startDate = dayStart;
-        // Convert boundaries back to UTC for final output
-        const utcStart = fromZonedTime(startDate, this.timezone);
-        const utcEnd = fromZonedTime(endDate, this.timezone);
+        const { start: dayStart } = this.timeCalculator.getDayBoundaries(periodStartDate, intraday_reporting);
         // Ensure start is not after end
-        if (isBefore(utcEnd, utcStart)) {
+        if (isBefore(endDate, dayStart)) {
             throw new Error('Start date cannot be after end date');
         }
         return {
-            start: this.formatDate(utcStart, outputFormat),
-            end: this.formatDate(utcEnd, outputFormat),
+            start: this.formatter.formatDate(dayStart, outputFormat),
+            end: this.formatter.formatDate(endDate, outputFormat),
         };
     }
-    getMarketOpenClose(options = {}) {
-        const { date = new Date() } = options;
-        const zonedDate = toZonedTime(date, this.timezone);
-        // Check if market is closed for the day
-        if (this.isWeekend(zonedDate) || this.isHoliday(zonedDate)) {
-            return {
-                marketOpen: false,
-                open: null,
-                close: null,
-                openExt: null,
-                closeExt: null,
-            };
+}
+// ===== MARKET STATUS SERVICE =====
+/**
+ * Service for determining market status
+ */
+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,
+            });
         }
-        const dayStart = startOfDay(zonedDate);
-        const regularOpenTime = MARKET_TIMES.REGULAR.START;
-        let regularCloseTime = MARKET_TIMES.REGULAR.END;
-        const extendedOpenTime = MARKET_TIMES.EXTENDED.START;
-        let extendedCloseTime = MARKET_TIMES.EXTENDED.END;
-        // Check for early close
-        const isEarlyClose = this.isEarlyCloseDay(zonedDate);
-        if (isEarlyClose) {
-            const earlyCloseMinutes = this.getEarlyCloseTime(zonedDate);
-            if (earlyCloseMinutes !== null) {
-                // For regular hours, use the early close time
-                regularCloseTime = {
-                    HOUR: Math.floor(earlyCloseMinutes / 60),
-                    MINUTE: earlyCloseMinutes % 60,
-                    MINUTES: earlyCloseMinutes,
-                };
-                // For extended hours on early close days, close at 5:00 PM
-                extendedCloseTime = {
-                    HOUR: 17,
-                    MINUTE: 0,
-                    MINUTES: 1020,
-                };
-            }
+        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,
+            });
         }
-        const open = fromZonedTime(set(dayStart, { hours: regularOpenTime.HOUR, minutes: regularOpenTime.MINUTE }), this.timezone);
-        const close = fromZonedTime(set(dayStart, { hours: regularCloseTime.HOUR, minutes: regularCloseTime.MINUTE }), this.timezone);
-        const openExt = fromZonedTime(set(dayStart, { hours: extendedOpenTime.HOUR, minutes: extendedOpenTime.MINUTE }), this.timezone);
-        const closeExt = fromZonedTime(set(dayStart, { hours: extendedCloseTime.HOUR, minutes: extendedCloseTime.MINUTE }), this.timezone);
+        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,
+            });
+        }
+        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 {
+            // 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,
+            });
+        }
+        const nextStatusTimeUTC = fromZonedTime(nextStatusTime, this.timezone);
+        const dateFormat = 'MMMM dd, yyyy, HH:mm:ss a';
         return {
-            marketOpen: true,
-            open,
-            close,
-            openExt,
-            closeExt,
+            time: date,
+            timeString: format(nyTime, dateFormat),
+            status,
+            nextStatus,
+            marketPeriod,
+            nextStatusTime: nextStatusTimeUTC,
+            nextStatusTimeDifference: differenceInMilliseconds(nextStatusTime, nyTime),
+            nextStatusTimeString: format(nextStatusTime, dateFormat),
         };
     }
 }
+// ===== FUNCTIONAL API =====
 /**
- * Creates a new MarketTimeUtil instance
- * @param {string} [timezone] - The timezone to use for market time calculations
- * @param {IntradayReporting} [intraday_reporting] - The intraday reporting mode
- * @returns {MarketTimeUtil} A new MarketTimeUtil instance
- */
-function createMarketTimeUtil(timezone, intraday_reporting) {
-    return new MarketTimeUtil(timezone, intraday_reporting);
-}
-/**
- * Gets start and end timestamps for a given market time period
- * @param {MarketTimeParams} [params] - The market time parameters
- * @returns {PeriodDates} The start and end timestamps
+ * Simple functional API that uses the services above
  */
-function getStartAndEndTimestamps(params = {}) {
-    const util = createMarketTimeUtil(params.timezone, params.intraday_reporting);
-    const effectiveParams = {
-        ...params,
-        end: params.referenceDate || params.end || new Date(),
-    };
-    return util.getMarketTimePeriod(effectiveParams);
-}
+// Create service instances
+const marketCalendar = new MarketCalendar();
+const marketTimeCalculator = new MarketTimeCalculator();
+const periodCalculator = new PeriodCalculator();
+const marketStatusService = new MarketStatusService();
+const timeFormatter = new TimeFormatter();
 /**
- * Gets the market open/close times for a given date
- * @param {Object} [options] - Options object
- * @param {Date} [options.date] - The date to check (defaults to current date)
- * @returns {MarketOpenCloseResult} The market open/close times
+ * Get market open/close times for a given date
  */
 function getMarketOpenClose(options = {}) {
-    const marketTimeUtil = new MarketTimeUtil();
-    return marketTimeUtil.getMarketOpenClose(options);
+    const { date = new Date() } = options;
+    return marketTimeCalculator.getMarketTimes(date);
 }
 /**
- * Gets the start and end dates for a given market time period
- * @param {MarketTimeParams} [params] - The market time parameters
- * @returns {Object} The start and end dates
- * @property {Date} start - The start date
- * @property {Date} end - The end date
+ * Get start and end dates for a given market time period
  */
 function getStartAndEndDates(params = {}) {
-    const util = createMarketTimeUtil(params.timezone, params.intraday_reporting);
-    const effectiveParams = {
-        ...params,
-        end: params.referenceDate || params.end || new Date(),
-    };
-    const { start, end } = util.getMarketTimePeriod(effectiveParams);
-    // Ensure the returned values are Dates
+    const { start, end } = periodCalculator.getMarketTimePeriod(params);
     return {
         start: new Date(start),
         end: new Date(end),
     };
 }
 /**
- * Gets the last trading date in YYYY-MM-DD format
- * @returns {string} The last trading date in YYYY-MM-DD format
- */
-function getLastTradingDateYYYYMMDD() {
-    const util = new MarketTimeUtil();
-    const lastTradingDate = util.getLastTradingDate();
-    return format(lastTradingDate, 'yyyy-MM-dd');
-}
-/**
- * Gets the last full trading date
- * @param {Date} [currentDate] - The current date (defaults to now)
- * @returns {Object} The last full trading date
- * @property {Date} date - The date object
- * @property {string} YYYYMMDD - The date in YYYY-MM-DD format
+ * Get the last full trading date
  */
 function getLastFullTradingDate(currentDate = new Date()) {
-    const util = new MarketTimeUtil();
-    const date = util.getLastFullTradingDate(currentDate);
-    // Format the date in NY timezone to ensure consistency
+    const date = marketTimeCalculator.getLastFullTradingDate(currentDate);
     return {
         date,
-        YYYYMMDD: formatInTimeZone(date, MARKET_TIMES.TIMEZONE, 'yyyy-MM-dd'),
+        YYYYMMDD: timeFormatter.getTradingDate(date),
     };
 }
 /**
- * Gets the next market day from a reference date
- * @param {Object} [options] - Options object
- * @param {Date} [options.referenceDate] - The reference date (defaults to current date)
- * @returns {Object} The next market day information
- * @property {Date} date - The date object (start of day in NY time)
- * @property {string} yyyymmdd - The date in YYYY-MM-DD format
- * @property {string} dateISOString - Full ISO date string
+ * Get the next market day
  */
 function getNextMarketDay({ referenceDate } = {}) {
-    const util = new MarketTimeUtil();
     const startDate = referenceDate || new Date();
-    const nextDate = util.getNextMarketDay(startDate);
+    const nextDate = marketCalendar.getNextMarketDay(startDate);
     // Convert to start of day in NY time
-    const startOfDayNY = startOfDay(toZonedTime(nextDate, MARKET_TIMES.TIMEZONE));
-    const dateInET = fromZonedTime(startOfDayNY, MARKET_TIMES.TIMEZONE);
+    const startOfDayNY = startOfDay(toZonedTime(nextDate, MARKET_CONFIG.TIMEZONE));
+    const dateInET = fromZonedTime(startOfDayNY, MARKET_CONFIG.TIMEZONE);
     return {
         date: dateInET,
-        yyyymmdd: formatInTimeZone(dateInET, MARKET_TIMES.TIMEZONE, 'yyyy-MM-dd'),
+        yyyymmdd: timeFormatter.getTradingDate(dateInET),
         dateISOString: dateInET.toISOString(),
     };
 }
 /**
- * Gets the current time in Eastern Time
- * @returns {Date} The current time in Eastern Time
+ * Get trading date in YYYY-MM-DD format
  */
-const currentTimeET = () => {
-    return toZonedTime(new Date(), MARKET_TIMES.TIMEZONE);
-};
+function getTradingDate(time) {
+    return timeFormatter.getTradingDate(time);
+}
 /**
- * Gets a date in New York timezone, rezoned using date-fns-tz
- * @param {number|string|Date} time - The time to convert
- * @returns {Date} The date in New York timezone
+ * Get New York timezone offset
  */
-function getDateInNY(time) {
-    let date;
-    if (typeof time === 'number' || typeof time === 'string' || time instanceof Date) {
-        // Assuming Unix timestamp in epoch milliseconds, string date, or Date object
-        date = new Date(time);
-    }
-    else {
-        // Assuming object with year, month, and day
-        date = new Date(time.year, time.month - 1, time.day);
-    }
-    return toZonedTime(date, 'America/New_York');
+function getNYTimeZone(date) {
+    return timeFormatter.getNYTimeZone(date);
 }
 /**
- * Gets the trading date in YYYY-MM-DD format for New York timezone, for grouping of data
- * @param {string|number|Date} time - The time to convert (string, unix timestamp in ms, or Date object)
- * @returns {string} The trading date in YYYY-MM-DD format
+ * Get current market status
  */
-function getTradingDate(time) {
-    let date;
-    if (typeof time === 'number') {
-        // Assuming Unix timestamp in milliseconds
-        date = new Date(time);
-    }
-    else if (typeof time === 'string') {
-        date = new Date(time);
-    }
-    else {
-        date = time;
-    }
-    // Convert to NY timezone and format as YYYY-MM-DD
-    return formatInTimeZone(date, MARKET_TIMES.TIMEZONE, 'yyyy-MM-dd');
+function getMarketStatus(options = {}) {
+    const { date = new Date() } = options;
+    return marketStatusService.getMarketStatus(date);
 }
 /**
- * Returns the New York timezone offset based on whether daylight savings is active
- * @param dateString - The date string to check
- * @returns "-04:00" during daylight savings (EDT) or "-05:00" during standard time (EST)
+ * Check if a date is a market day
  */
-const getNYTimeZone = (date) => {
-    if (!date) {
-        date = new Date();
-    }
-    const dtf = new Intl.DateTimeFormat('en-US', {
-        timeZone: 'America/New_York',
-        timeZoneName: 'shortOffset',
-    });
-    const parts = dtf.formatToParts(date);
-    const tz = parts.find((p) => p.type === 'timeZoneName')?.value;
-    // tz will be "GMT-5" or "GMT-4"
-    if (!tz) {
-        throw new Error('Could not determine New York offset');
-    }
-    // extract the -4 or -5 from the string
-    const shortOffset = tz.replace('GMT', '');
-    // return the correct offset
-    if (shortOffset === '-4') {
-        console.log(`New York is on EDT; using -04:00. Full date: ${date.toLocaleString('en-US', {
-            timeZone: 'America/New_York',
-        })}, time zone part: ${tz}`);
-        return '-04:00';
-    }
-    else if (shortOffset === '-5') {
-        console.log(`New York is on EST; using -05:00. Full date: ${date.toLocaleString('en-US', {
-            timeZone: 'America/New_York',
-        })}, time zone part: ${tz}`);
-        return '-05:00';
-    }
-    else {
-        throw new Error('Could not determine New York offset');
-    }
-};
+function isMarketDay(date) {
+    return marketCalendar.isMarketDay(date);
+}
 /**
- * Gets the current market status
- * @param {Object} [options] - Options object
- * @param {Date} [options.date] - The date to check (defaults to current date)
- * @returns {MarketStatus} The current market status
+ * 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
  */
-function getMarketStatus(options = {}) {
-    const util = new MarketTimeUtil();
-    const now = options.date || new Date();
-    const nyTime = toZonedTime(now, MARKET_TIMES.TIMEZONE);
-    const isEarlyCloseDay = util.isEarlyCloseDay(nyTime);
-    const timeInMinutes = nyTime.getHours() * 60 + nyTime.getMinutes();
-    const extendedStartMinutes = MARKET_TIMES.EXTENDED.START.MINUTES;
-    const marketStartMinutes = MARKET_TIMES.REGULAR.START.MINUTES;
-    MARKET_TIMES.EARLY_MORNING.END.MINUTES;
-    const marketRegularCloseMinutes = isEarlyCloseDay
-        ? MARKET_TIMES.EARLY_CLOSE_BEFORE_HOLIDAY.END.MINUTES
-        : MARKET_TIMES.REGULAR.END.MINUTES;
-    const extendedEndMinutes = isEarlyCloseDay
-        ? MARKET_TIMES.EARLY_EXTENDED_BEFORE_HOLIDAY.END.MINUTES
-        : MARKET_TIMES.EXTENDED.END.MINUTES;
-    let status;
-    let nextStatus;
-    let nextStatusTime;
-    let marketPeriod;
-    const nextMarketDay = util.getNextMarketDay(nyTime);
-    // Determine current status and market period
-    if (!util.isMarketDay(nyTime)) {
-        // Not a market day! market is closed
-        marketPeriod = 'closed';
-        status = 'closed';
-        nextStatus = 'extended hours';
-        // Find next market day and set to extended hours start time
-        nextStatusTime = set(nextMarketDay, {
-            hours: MARKET_TIMES.EXTENDED.START.HOUR,
-            minutes: MARKET_TIMES.EXTENDED.START.MINUTE,
-        });
-    } // check if the market isn't in extended hours yet
-    else if (timeInMinutes >= 0 && timeInMinutes < extendedStartMinutes) {
-        marketPeriod = 'closed';
-        status = 'closed';
-        nextStatus = 'extended hours';
-        nextStatusTime = set(nyTime, {
-            hours: MARKET_TIMES.EXTENDED.START.HOUR,
-            minutes: MARKET_TIMES.EXTENDED.START.MINUTE,
-        });
-        // check if we're in pre-market hours
-    }
-    else if (timeInMinutes >= extendedStartMinutes && timeInMinutes < marketStartMinutes) {
-        marketPeriod = 'preMarket';
-        status = 'extended hours';
-        nextStatus = 'open';
-        nextStatusTime = set(nyTime, {
-            hours: MARKET_TIMES.REGULAR.START.HOUR,
-            minutes: MARKET_TIMES.REGULAR.START.MINUTE,
-        });
-        // check if market is open
-    }
-    else if (timeInMinutes >= marketStartMinutes && timeInMinutes < marketRegularCloseMinutes) {
-        status = 'open';
-        nextStatus = 'extended hours';
-        // market is open, but just check the marketPeriod - could be earlyMarket or regularMarket
-        marketPeriod = timeInMinutes < MARKET_TIMES.EARLY_MORNING.END.MINUTES ? 'earlyMarket' : 'regularMarket';
-        nextStatusTime = isEarlyCloseDay
-            ? set(nyTime, {
-                hours: MARKET_TIMES.EARLY_CLOSE_BEFORE_HOLIDAY.END.HOUR,
-                minutes: MARKET_TIMES.EARLY_CLOSE_BEFORE_HOLIDAY.END.MINUTE,
-            })
-            : set(nyTime, {
-                hours: MARKET_TIMES.REGULAR.END.HOUR,
-                minutes: MARKET_TIMES.REGULAR.END.MINUTE,
-            });
-        // check if it's after-market extended hours
-    }
-    else if (timeInMinutes >= marketRegularCloseMinutes && timeInMinutes < extendedEndMinutes) {
-        status = 'extended hours';
-        nextStatus = 'closed';
-        marketPeriod = 'afterMarket';
-        nextStatusTime = isEarlyCloseDay
-            ? set(nyTime, {
-                hours: MARKET_TIMES.EARLY_EXTENDED_BEFORE_HOLIDAY.END.HOUR,
-                minutes: MARKET_TIMES.EARLY_EXTENDED_BEFORE_HOLIDAY.END.MINUTE,
-            })
-            : set(nyTime, {
-                hours: MARKET_TIMES.EXTENDED.END.HOUR,
-                minutes: MARKET_TIMES.EXTENDED.END.MINUTE,
-            });
-        // otherwise, the market is closed
+function getTradingStartAndEndDates(options = {}) {
+    const { endDate = new Date(), days = 1 } = options;
+    // Get the last full trading date for the end date
+    const endTradingDate = getLastFullTradingDate(endDate).date;
+    // Get the market close time for the end date (4:00 PM ET or 1:00 PM on short days)
+    const endMarketClose = getMarketOpenClose({ date: endTradingDate }).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;
     }
     else {
-        status = 'closed';
-        nextStatus = 'extended hours';
-        marketPeriod = 'closed';
-        nextStatusTime = set(nextMarketDay, {
-            hours: MARKET_TIMES.EXTENDED.START.HOUR,
-            minutes: MARKET_TIMES.EXTENDED.START.MINUTE,
-        });
+        // 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++;
+            }
+        }
+        // Get the market open time for the start date
+        startDate = getMarketOpenClose({ date: currentDate }).open;
     }
-    const dateFormat = 'MMMM dd, yyyy, HH:mm:ss a';
-    return {
-        time: now,
-        timeString: format(nyTime, dateFormat),
-        status,
-        nextStatus,
-        marketPeriod,
-        nextStatusTime: fromZonedTime(nextStatusTime, MARKET_TIMES.TIMEZONE),
-        nextStatusTimeDifference: differenceInMilliseconds(nextStatusTime, nyTime),
-        nextStatusTimeString: format(nextStatusTime, dateFormat),
-    };
+    return { startDate, endDate: endMarketClose };
 }
 
 // format-tools.ts
@@ -2429,7 +2232,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.8.2'; // x-release-please-version
+const VERSION = '5.8.3'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -3181,13 +2984,95 @@ function findDoubleNewlineIndex(buffer) {
     return -1;
 }
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+const levelNumbers = {
+    off: 0,
+    error: 200,
+    warn: 300,
+    info: 400,
+    debug: 500,
+};
+const parseLogLevel = (maybeLevel, sourceName, client) => {
+    if (!maybeLevel) {
+        return undefined;
+    }
+    if (hasOwn(levelNumbers, maybeLevel)) {
+        return maybeLevel;
+    }
+    loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
+    return undefined;
+};
+function noop() { }
+function makeLogFn(fnLevel, logger, logLevel) {
+    if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+        return noop;
+    }
+    else {
+        // Don't wrap logger functions, we want the stacktrace intact!
+        return logger[fnLevel].bind(logger);
+    }
+}
+const noopLogger = {
+    error: noop,
+    warn: noop,
+    info: noop,
+    debug: noop,
+};
+let cachedLoggers = /* @__PURE__ */ new WeakMap();
+function loggerFor(client) {
+    const logger = client.logger;
+    const logLevel = client.logLevel ?? 'off';
+    if (!logger) {
+        return noopLogger;
+    }
+    const cachedLogger = cachedLoggers.get(logger);
+    if (cachedLogger && cachedLogger[0] === logLevel) {
+        return cachedLogger[1];
+    }
+    const levelLogger = {
+        error: makeLogFn('error', logger, logLevel),
+        warn: makeLogFn('warn', logger, logLevel),
+        info: makeLogFn('info', logger, logLevel),
+        debug: makeLogFn('debug', logger, logLevel),
+    };
+    cachedLoggers.set(logger, [logLevel, levelLogger]);
+    return levelLogger;
+}
+const formatRequestDetails = (details) => {
+    if (details.options) {
+        details.options = { ...details.options };
+        delete details.options['headers']; // redundant + leaks internals
+    }
+    if (details.headers) {
+        details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
+            name,
+            (name.toLowerCase() === 'authorization' ||
+                name.toLowerCase() === 'cookie' ||
+                name.toLowerCase() === 'set-cookie') ?
+                '***'
+                : value,
+        ]));
+    }
+    if ('retryOfRequestLogID' in details) {
+        if (details.retryOfRequestLogID) {
+            details.retryOf = details.retryOfRequestLogID;
+        }
+        delete details.retryOfRequestLogID;
+    }
+    return details;
+};
+
+var _Stream_client;
 class Stream {
-    constructor(iterator, controller) {
+    constructor(iterator, controller, client) {
         this.iterator = iterator;
+        _Stream_client.set(this, void 0);
         this.controller = controller;
+        __classPrivateFieldSet(this, _Stream_client, client);
     }
-    static fromSSEResponse(response, controller) {
+    static fromSSEResponse(response, controller, client) {
         let consumed = false;
+        const logger = client ? loggerFor(client) : console;
         async function* iterator() {
             if (consumed) {
                 throw new OpenAIError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
@@ -3210,8 +3095,8 @@ class Stream {
                             data = JSON.parse(sse.data);
                         }
                         catch (e) {
-                            console.error(`Could not parse message into JSON:`, sse.data);
-                            console.error(`From chunk:`, sse.raw);
+                            logger.error(`Could not parse message into JSON:`, sse.data);
+                            logger.error(`From chunk:`, sse.raw);
                             throw e;
                         }
                         if (data && data.error) {
@@ -3250,13 +3135,13 @@ class Stream {
                     controller.abort();
             }
         }
-        return new Stream(iterator, controller);
+        return new Stream(iterator, controller, client);
     }
     /**
      * Generates a Stream from a newline-separated ReadableStream
      * where each item is a JSON value.
      */
-    static fromReadableStream(readableStream, controller) {
+    static fromReadableStream(readableStream, controller, client) {
         let consumed = false;
         async function* iterLines() {
             const lineDecoder = new LineDecoder();
@@ -3297,9 +3182,9 @@ class Stream {
                     controller.abort();
             }
         }
-        return new Stream(iterator, controller);
+        return new Stream(iterator, controller, client);
     }
-    [Symbol.asyncIterator]() {
+    [(_Stream_client = new WeakMap(), Symbol.asyncIterator)]() {
         return this.iterator();
     }
     /**
@@ -3323,8 +3208,8 @@ class Stream {
             };
         };
         return [
-            new Stream(() => teeIterator(left), this.controller),
-            new Stream(() => teeIterator(right), this.controller),
+            new Stream(() => teeIterator(left), this.controller, __classPrivateFieldGet(this, _Stream_client, "f")),
+            new Stream(() => teeIterator(right), this.controller, __classPrivateFieldGet(this, _Stream_client, "f")),
         ];
     }
     /**
@@ -3444,97 +3329,19 @@ class SSEDecoder {
         if (fieldname === 'event') {
             this.event = value;
         }
-        else if (fieldname === 'data') {
-            this.data.push(value);
-        }
-        return null;
-    }
-}
-function partition(str, delimiter) {
-    const index = str.indexOf(delimiter);
-    if (index !== -1) {
-        return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
-    }
-    return [str, '', ''];
-}
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-const levelNumbers = {
-    off: 0,
-    error: 200,
-    warn: 300,
-    info: 400,
-    debug: 500,
-};
-const parseLogLevel = (maybeLevel, sourceName, client) => {
-    if (!maybeLevel) {
-        return undefined;
-    }
-    if (hasOwn(levelNumbers, maybeLevel)) {
-        return maybeLevel;
-    }
-    loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
-    return undefined;
-};
-function noop() { }
-function makeLogFn(fnLevel, logger, logLevel) {
-    if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
-        return noop;
-    }
-    else {
-        // Don't wrap logger functions, we want the stacktrace intact!
-        return logger[fnLevel].bind(logger);
-    }
-}
-const noopLogger = {
-    error: noop,
-    warn: noop,
-    info: noop,
-    debug: noop,
-};
-let cachedLoggers = /** @__PURE__ */ new WeakMap();
-function loggerFor(client) {
-    const logger = client.logger;
-    const logLevel = client.logLevel ?? 'off';
-    if (!logger) {
-        return noopLogger;
-    }
-    const cachedLogger = cachedLoggers.get(logger);
-    if (cachedLogger && cachedLogger[0] === logLevel) {
-        return cachedLogger[1];
+        else if (fieldname === 'data') {
+            this.data.push(value);
+        }
+        return null;
     }
-    const levelLogger = {
-        error: makeLogFn('error', logger, logLevel),
-        warn: makeLogFn('warn', logger, logLevel),
-        info: makeLogFn('info', logger, logLevel),
-        debug: makeLogFn('debug', logger, logLevel),
-    };
-    cachedLoggers.set(logger, [logLevel, levelLogger]);
-    return levelLogger;
 }
-const formatRequestDetails = (details) => {
-    if (details.options) {
-        details.options = { ...details.options };
-        delete details.options['headers']; // redundant + leaks internals
-    }
-    if (details.headers) {
-        details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
-            name,
-            (name.toLowerCase() === 'authorization' ||
-                name.toLowerCase() === 'cookie' ||
-                name.toLowerCase() === 'set-cookie') ?
-                '***'
-                : value,
-        ]));
-    }
-    if ('retryOfRequestLogID' in details) {
-        if (details.retryOfRequestLogID) {
-            details.retryOf = details.retryOfRequestLogID;
-        }
-        delete details.retryOfRequestLogID;
+function partition(str, delimiter) {
+    const index = str.indexOf(delimiter);
+    if (index !== -1) {
+        return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
     }
-    return details;
-};
+    return [str, '', ''];
+}
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 async function defaultParseResponse(client, props) {
@@ -3545,9 +3352,9 @@ async function defaultParseResponse(client, props) {
             // Note: there is an invariant here that isn't represented in the type system
             // that if you set `stream: true` the response type must also be `Stream<T>`
             if (props.options.__streamClass) {
-                return props.options.__streamClass.fromSSEResponse(response, props.controller);
+                return props.options.__streamClass.fromSSEResponse(response, props.controller, client);
             }
-            return Stream.fromSSEResponse(response, props.controller);
+            return Stream.fromSSEResponse(response, props.controller, client);
         }
         // fetch refuses to read the body when the status code is 204.
         if (response.status === 204) {
@@ -3801,7 +3608,7 @@ const isAsyncIterable = (value) => value != null && typeof value === 'object' &&
 const multipartFormRequestOptions = async (opts, fetch) => {
     return { ...opts, body: await createForm(opts.body, fetch) };
 };
-const supportsFormDataMap = /** @__PURE__ */ new WeakMap();
+const supportsFormDataMap = /* @__PURE__ */ new WeakMap();
 /**
  * node-fetch doesn't support the global FormData object in recent node versions. Instead of sending
  * properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]".
@@ -3977,21 +3784,38 @@ class APIResource {
 function encodeURIPath(str) {
     return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
 }
+const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
 const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(statics, ...params) {
     // If there are no params, no processing is needed.
     if (statics.length === 1)
         return statics[0];
     let postPath = false;
+    const invalidSegments = [];
     const path = statics.reduce((previousValue, currentValue, index) => {
         if (/[?#]/.test(currentValue)) {
             postPath = true;
         }
-        return (previousValue +
-            currentValue +
-            (index === params.length ? '' : (postPath ? encodeURIComponent : pathEncoder)(String(params[index]))));
+        const value = params[index];
+        let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value);
+        if (index !== params.length &&
+            (value == null ||
+                (typeof value === 'object' &&
+                    // handle values from other realms
+                    value.toString ===
+                        Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)
+                            ?.toString))) {
+            encoded = value + '';
+            invalidSegments.push({
+                start: previousValue.length + currentValue.length,
+                length: encoded.length,
+                error: `Value of type ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)} is not a valid path parameter`,
+            });
+        }
+        return previousValue + currentValue + (index === params.length ? '' : encoded);
     }, '');
     const pathOnly = path.split(/[?#]/, 1)[0];
-    const invalidSegments = [];
     const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
     let match;
     // Find all invalid segments
@@ -3999,8 +3823,10 @@ const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(sta
         invalidSegments.push({
             start: match.index,
             length: match[0].length,
+            error: `Value "${match[0]}" can\'t be safely passed as a path parameter`,
         });
     }
+    invalidSegments.sort((a, b) => a.start - b.start);
     if (invalidSegments.length > 0) {
         let lastEnd = 0;
         const underline = invalidSegments.reduce((acc, segment) => {
@@ -4009,7 +3835,9 @@ const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(sta
             lastEnd = segment.start + segment.length;
             return acc + spaces + arrows;
         }, '');
-        throw new OpenAIError(`Path parameters result in path with invalid segments:\n${path}\n${underline}`);
+        throw new OpenAIError(`Path parameters result in path with invalid segments:\n${invalidSegments
+            .map((e) => e.error)
+            .join('\n')}\n${path}\n${underline}`);
     }
     return path;
 };
@@ -12053,7 +11881,7 @@ function requireSender () {
 	hasRequiredSender = 1;
 
 	const { Duplex } = require$$0$2;
-	const { randomFillSync } = require$$1;
+	const { randomFillSync } = require$$3;
 
 	const PerMessageDeflate = requirePermessageDeflate();
 	const { EMPTY_BUFFER, kWebSocket, NOOP } = requireConstants();
@@ -13174,11 +13002,11 @@ function requireWebsocket () {
 	hasRequiredWebsocket = 1;
 
 	const EventEmitter = require$$0$3;
-	const https = require$$1$1;
+	const https = require$$1;
 	const http = require$$2;
-	const net = require$$3;
-	const tls = require$$4;
-	const { randomBytes, createHash } = require$$1;
+	const net = require$$3$1;
+	const tls = require$$4$1;
+	const { randomBytes, createHash } = require$$3;
 	const { Duplex, Readable } = require$$0$2;
 	const { URL } = require$$7;
 
@@ -14821,7 +14649,7 @@ function requireWebsocketServer () {
 	const EventEmitter = require$$0$3;
 	const http = require$$2;
 	const { Duplex } = require$$0$2;
-	const { createHash } = require$$1;
+	const { createHash } = require$$3;
 
 	const extension = requireExtension();
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -15369,35 +15197,522 @@ function requireWebsocketServer () {
 
 requireWebsocketServer();
 
-/**
- * Logs a message to the console.
- * @param message The message to log.
- * @param options Optional options.
- * @param options.source The source of the message.
- * @param options.type The type of message to log.
- * @param options.symbol The trading symbol associated with this log.
- * @param options.account The account associated with this log.
- */
-function log$1(message, options = { source: 'App', type: 'info' }) {
-    // Format the timestamp
-    const date = new Date();
-    const timestamp = date.toLocaleString('en-US', { timeZone: 'America/New_York' });
-    const account = options?.account;
-    const symbol = options?.symbol;
-    // Build the log message
-    const logMessage = `[${timestamp}]${options?.source ? ` [${options.source}] ` : ''}${account ? ` [${account}] ` : ''}${symbol ? ` [${symbol}] ` : ''}${message}`;
-    // Use appropriate console method based on type
-    if (options?.type === 'error') {
-        console.error(logMessage);
-    }
-    else if (options?.type === 'warn') {
-        console.warn(logMessage);
-    }
-    else {
-        console.log(logMessage);
-    }
+var config = {};
+
+var main = {exports: {}};
+
+var version = "17.1.0";
+var require$$4 = {
+	version: version};
+
+var hasRequiredMain;
+
+function requireMain () {
+	if (hasRequiredMain) return main.exports;
+	hasRequiredMain = 1;
+	const fs = require$$0$4;
+	const path = require$$1$1;
+	const os = require$$2$1;
+	const crypto = require$$3;
+	const packageJson = require$$4;
+
+	const version = packageJson.version;
+
+	// Array of tips to display randomly
+	const TIPS = [
+	  '🔐 encrypt with dotenvx: https://dotenvx.com',
+	  '🔐 prevent committing .env to code: https://dotenvx.com/precommit',
+	  '🔐 prevent building .env in docker: https://dotenvx.com/prebuild',
+	  '🛠️  run anywhere with `dotenvx run -- yourcommand`',
+	  '⚙️  specify custom .env file path with { path: \'/custom/path/.env\' }',
+	  '⚙️  enable debug logging with { debug: true }',
+	  '⚙️  override existing env vars with { override: true }',
+	  '⚙️  suppress all logs with { quiet: true }',
+	  '⚙️  write to custom object with { processEnv: myObject }',
+	  '⚙️  load multiple .env files with { path: [\'.env.local\', \'.env\'] }'
+	];
+
+	// Get a random tip from the tips array
+	function _getRandomTip () {
+	  return TIPS[Math.floor(Math.random() * TIPS.length)]
+	}
+
+	function supportsAnsi () {
+	  return process.stdout.isTTY // && process.env.TERM !== 'dumb'
+	}
+
+	function dim (text) {
+	  return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text
+	}
+
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+
+	// Parse src into an Object
+	function parse (src) {
+	  const obj = {};
+
+	  // Convert buffer to string
+	  let lines = src.toString();
+
+	  // Convert line breaks to same format
+	  lines = lines.replace(/\r\n?/mg, '\n');
+
+	  let match;
+	  while ((match = LINE.exec(lines)) != null) {
+	    const key = match[1];
+
+	    // Default undefined or null to empty string
+	    let value = (match[2] || '');
+
+	    // Remove whitespace
+	    value = value.trim();
+
+	    // Check if double quoted
+	    const maybeQuote = value[0];
+
+	    // Remove surrounding quotes
+	    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+
+	    // Expand newlines if double quoted
+	    if (maybeQuote === '"') {
+	      value = value.replace(/\\n/g, '\n');
+	      value = value.replace(/\\r/g, '\r');
+	    }
+
+	    // Add to object
+	    obj[key] = value;
+	  }
+
+	  return obj
+	}
+
+	function _parseVault (options) {
+	  options = options || {};
+
+	  const vaultPath = _vaultPath(options);
+	  options.path = vaultPath; // parse .env.vault
+	  const result = DotenvModule.configDotenv(options);
+	  if (!result.parsed) {
+	    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+	    err.code = 'MISSING_DATA';
+	    throw err
+	  }
+
+	  // handle scenario for comma separated keys - for use with key rotation
+	  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+	  const keys = _dotenvKey(options).split(',');
+	  const length = keys.length;
+
+	  let decrypted;
+	  for (let i = 0; i < length; i++) {
+	    try {
+	      // Get full key
+	      const key = keys[i].trim();
+
+	      // Get instructions for decrypt
+	      const attrs = _instructions(result, key);
+
+	      // Decrypt
+	      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+
+	      break
+	    } catch (error) {
+	      // last key
+	      if (i + 1 >= length) {
+	        throw error
+	      }
+	      // try next key
+	    }
+	  }
+
+	  // Parse decrypted .env string
+	  return DotenvModule.parse(decrypted)
+	}
+
+	function _warn (message) {
+	  console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+
+	function _debug (message) {
+	  console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+
+	function _log (message) {
+	  console.log(`[dotenv@${version}] ${message}`);
+	}
+
+	function _dotenvKey (options) {
+	  // prioritize developer directly setting options.DOTENV_KEY
+	  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+	    return options.DOTENV_KEY
+	  }
+
+	  // secondary infra already contains a DOTENV_KEY environment variable
+	  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+	    return process.env.DOTENV_KEY
+	  }
+
+	  // fallback to empty string
+	  return ''
+	}
+
+	function _instructions (result, dotenvKey) {
+	  // Parse DOTENV_KEY. Format is a URI
+	  let uri;
+	  try {
+	    uri = new URL(dotenvKey);
+	  } catch (error) {
+	    if (error.code === 'ERR_INVALID_URL') {
+	      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
+	      err.code = 'INVALID_DOTENV_KEY';
+	      throw err
+	    }
+
+	    throw error
+	  }
+
+	  // Get decrypt key
+	  const key = uri.password;
+	  if (!key) {
+	    const err = new Error('INVALID_DOTENV_KEY: Missing key part');
+	    err.code = 'INVALID_DOTENV_KEY';
+	    throw err
+	  }
+
+	  // Get environment
+	  const environment = uri.searchParams.get('environment');
+	  if (!environment) {
+	    const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
+	    err.code = 'INVALID_DOTENV_KEY';
+	    throw err
+	  }
+
+	  // Get ciphertext payload
+	  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+	  const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
+	  if (!ciphertext) {
+	    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+	    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
+	    throw err
+	  }
+
+	  return { ciphertext, key }
+	}
+
+	function _vaultPath (options) {
+	  let possibleVaultPath = null;
+
+	  if (options && options.path && options.path.length > 0) {
+	    if (Array.isArray(options.path)) {
+	      for (const filepath of options.path) {
+	        if (fs.existsSync(filepath)) {
+	          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
+	        }
+	      }
+	    } else {
+	      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
+	    }
+	  } else {
+	    possibleVaultPath = path.resolve(process.cwd(), '.env.vault');
+	  }
+
+	  if (fs.existsSync(possibleVaultPath)) {
+	    return possibleVaultPath
+	  }
+
+	  return null
+	}
+
+	function _resolveHome (envPath) {
+	  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+	}
+
+	function _configVault (options) {
+	  const debug = Boolean(options && options.debug);
+	  const quiet = Boolean(options && options.quiet);
+
+	  if (debug || !quiet) {
+	    _log('Loading env from encrypted .env.vault');
+	  }
+
+	  const parsed = DotenvModule._parseVault(options);
+
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+
+	  DotenvModule.populate(processEnv, parsed, options);
+
+	  return { parsed }
+	}
+
+	function configDotenv (options) {
+	  const dotenvPath = path.resolve(process.cwd(), '.env');
+	  let encoding = 'utf8';
+	  const debug = Boolean(options && options.debug);
+	  const quiet = Boolean(options && options.quiet);
+
+	  if (options && options.encoding) {
+	    encoding = options.encoding;
+	  } else {
+	    if (debug) {
+	      _debug('No encoding is specified. UTF-8 is used by default');
+	    }
+	  }
+
+	  let optionPaths = [dotenvPath]; // default, look for .env
+	  if (options && options.path) {
+	    if (!Array.isArray(options.path)) {
+	      optionPaths = [_resolveHome(options.path)];
+	    } else {
+	      optionPaths = []; // reset default
+	      for (const filepath of options.path) {
+	        optionPaths.push(_resolveHome(filepath));
+	      }
+	    }
+	  }
+
+	  // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+	  // parsed data, we will combine it with process.env (or options.processEnv if provided).
+	  let lastError;
+	  const parsedAll = {};
+	  for (const path of optionPaths) {
+	    try {
+	      // Specifying an encoding returns a string instead of a buffer
+	      const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }));
+
+	      DotenvModule.populate(parsedAll, parsed, options);
+	    } catch (e) {
+	      if (debug) {
+	        _debug(`Failed to load ${path} ${e.message}`);
+	      }
+	      lastError = e;
+	    }
+	  }
+
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+
+	  const populated = DotenvModule.populate(processEnv, parsedAll, options);
+
+	  if (debug || !quiet) {
+	    const keysCount = Object.keys(populated).length;
+	    const shortPaths = [];
+	    for (const filePath of optionPaths) {
+	      try {
+	        const relative = path.relative(process.cwd(), filePath);
+	        shortPaths.push(relative);
+	      } catch (e) {
+	        if (debug) {
+	          _debug(`Failed to load ${filePath} ${e.message}`);
+	        }
+	        lastError = e;
+	      }
+	    }
+
+	    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')} ${dim(`(tip: ${_getRandomTip()})`)}`);
+	  }
+
+	  if (lastError) {
+	    return { parsed: parsedAll, error: lastError }
+	  } else {
+	    return { parsed: parsedAll }
+	  }
+	}
+
+	// Populates process.env from .env file
+	function config (options) {
+	  // fallback to original dotenv if DOTENV_KEY is not set
+	  if (_dotenvKey(options).length === 0) {
+	    return DotenvModule.configDotenv(options)
+	  }
+
+	  const vaultPath = _vaultPath(options);
+
+	  // dotenvKey exists but .env.vault file does not exist
+	  if (!vaultPath) {
+	    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+
+	    return DotenvModule.configDotenv(options)
+	  }
+
+	  return DotenvModule._configVault(options)
+	}
+
+	function decrypt (encrypted, keyStr) {
+	  const key = Buffer.from(keyStr.slice(-64), 'hex');
+	  let ciphertext = Buffer.from(encrypted, 'base64');
+
+	  const nonce = ciphertext.subarray(0, 12);
+	  const authTag = ciphertext.subarray(-16);
+	  ciphertext = ciphertext.subarray(12, -16);
+
+	  try {
+	    const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+	    aesgcm.setAuthTag(authTag);
+	    return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
+	  } catch (error) {
+	    const isRange = error instanceof RangeError;
+	    const invalidKeyLength = error.message === 'Invalid key length';
+	    const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data';
+
+	    if (isRange || invalidKeyLength) {
+	      const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)');
+	      err.code = 'INVALID_DOTENV_KEY';
+	      throw err
+	    } else if (decryptionFailed) {
+	      const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY');
+	      err.code = 'DECRYPTION_FAILED';
+	      throw err
+	    } else {
+	      throw error
+	    }
+	  }
+	}
+
+	// Populate process.env with parsed values
+	function populate (processEnv, parsed, options = {}) {
+	  const debug = Boolean(options && options.debug);
+	  const override = Boolean(options && options.override);
+	  const populated = {};
+
+	  if (typeof parsed !== 'object') {
+	    const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate');
+	    err.code = 'OBJECT_REQUIRED';
+	    throw err
+	  }
+
+	  // Set process.env
+	  for (const key of Object.keys(parsed)) {
+	    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+	      if (override === true) {
+	        processEnv[key] = parsed[key];
+	        populated[key] = parsed[key];
+	      }
+
+	      if (debug) {
+	        if (override === true) {
+	          _debug(`"${key}" is already defined and WAS overwritten`);
+	        } else {
+	          _debug(`"${key}" is already defined and was NOT overwritten`);
+	        }
+	      }
+	    } else {
+	      processEnv[key] = parsed[key];
+	      populated[key] = parsed[key];
+	    }
+	  }
+
+	  return populated
+	}
+
+	const DotenvModule = {
+	  configDotenv,
+	  _configVault,
+	  _parseVault,
+	  config,
+	  decrypt,
+	  parse,
+	  populate
+	};
+
+	main.exports.configDotenv = DotenvModule.configDotenv;
+	main.exports._configVault = DotenvModule._configVault;
+	main.exports._parseVault = DotenvModule._parseVault;
+	main.exports.config = DotenvModule.config;
+	main.exports.decrypt = DotenvModule.decrypt;
+	main.exports.parse = DotenvModule.parse;
+	main.exports.populate = DotenvModule.populate;
+
+	main.exports = DotenvModule;
+	return main.exports;
+}
+
+var envOptions;
+var hasRequiredEnvOptions;
+
+function requireEnvOptions () {
+	if (hasRequiredEnvOptions) return envOptions;
+	hasRequiredEnvOptions = 1;
+	// ../config.js accepts options via environment variables
+	const options = {};
+
+	if (process.env.DOTENV_CONFIG_ENCODING != null) {
+	  options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	}
+
+	if (process.env.DOTENV_CONFIG_PATH != null) {
+	  options.path = process.env.DOTENV_CONFIG_PATH;
+	}
+
+	if (process.env.DOTENV_CONFIG_QUIET != null) {
+	  options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	}
+
+	if (process.env.DOTENV_CONFIG_DEBUG != null) {
+	  options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	}
+
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+	  options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	}
+
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+	  options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	}
+
+	envOptions = options;
+	return envOptions;
+}
+
+var cliOptions;
+var hasRequiredCliOptions;
+
+function requireCliOptions () {
+	if (hasRequiredCliOptions) return cliOptions;
+	hasRequiredCliOptions = 1;
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+
+	cliOptions = function optionMatcher (args) {
+	  const options = args.reduce(function (acc, cur) {
+	    const matches = cur.match(re);
+	    if (matches) {
+	      acc[matches[1]] = matches[2];
+	    }
+	    return acc
+	  }, {});
+
+	  if (!('quiet' in options)) {
+	    options.quiet = 'true';
+	  }
+
+	  return options
+	};
+	return cliOptions;
+}
+
+var hasRequiredConfig;
+
+function requireConfig () {
+	if (hasRequiredConfig) return config;
+	hasRequiredConfig = 1;
+	(function () {
+	  requireMain().config(
+	    Object.assign(
+	      {},
+	      requireEnvOptions(),
+	      requireCliOptions()(process.argv)
+	    )
+	  );
+	})();
+	return config;
 }
 
+requireConfig();
+
 const log = (message, options = { type: 'info' }) => {
     log$1(message, { ...options, source: 'AlpacaMarketDataAPI' });
 };
@@ -15421,22 +15736,16 @@ class AlpacaMarketDataAPI extends EventEmitter {
     optionWs = null;
     stockSubscriptions = { trades: [], quotes: [], bars: [] };
     optionSubscriptions = { trades: [], quotes: [], bars: [] };
-    apiKey;
-    secretKey;
-    accountType;
     setMode(mode = 'production') {
-        if (mode === 'sandbox') {
-            // sandbox mode
+        if (mode === 'sandbox') { // sandbox mode
             this.stockStreamUrl = 'wss://stream.data.sandbox.alpaca.markets/v2/sip';
             this.optionStreamUrl = 'wss://stream.data.sandbox.alpaca.markets/v1beta3/options';
         }
-        else if (mode === 'test') {
-            // test mode, can only use ticker FAKEPACA
+        else if (mode === 'test') { // test mode, can only use ticker FAKEPACA
             this.stockStreamUrl = 'wss://stream.data.alpaca.markets/v2/test';
             this.optionStreamUrl = 'wss://stream.data.alpaca.markets/v1beta3/options'; // there's no test mode for options
         }
-        else {
-            // production
+        else { // production
             this.stockStreamUrl = 'wss://stream.data.alpaca.markets/v2/sip';
             this.optionStreamUrl = 'wss://stream.data.alpaca.markets/v1beta3/options';
         }
@@ -15452,30 +15761,24 @@ class AlpacaMarketDataAPI extends EventEmitter {
             return 'production';
         }
     }
-    constructor(config) {
+    constructor() {
         super();
-        this.apiKey = config.apiKey;
-        this.secretKey = config.secretKey;
-        this.accountType = config.accountType || 'LIVE';
         this.dataURL = 'https://data.alpaca.markets/v2';
         this.apiURL =
-            this.accountType === 'PAPER'
+            process.env.ALPACA_ACCOUNT_TYPE === 'PAPER'
                 ? 'https://paper-api.alpaca.markets/v2'
                 : 'https://api.alpaca.markets/v2'; // used by some, e.g. getAssets
         this.v1beta1url = 'https://data.alpaca.markets/v1beta1'; // used for options endpoints
         this.setMode('production'); // sets stockStreamUrl and optionStreamUrl
         this.headers = {
-            'APCA-API-KEY-ID': this.apiKey,
-            'APCA-API-SECRET-KEY': this.secretKey,
+            'APCA-API-KEY-ID': process.env.ALPACA_API_KEY,
+            'APCA-API-SECRET-KEY': process.env.ALPACA_SECRET_KEY,
             'Content-Type': 'application/json',
         };
     }
-    static getInstance(config) {
+    static getInstance() {
         if (!AlpacaMarketDataAPI.instance) {
-            if (!config) {
-                throw new Error('AlpacaMarketDataAPI config is required for first initialization');
-            }
-            AlpacaMarketDataAPI.instance = new AlpacaMarketDataAPI(config);
+            AlpacaMarketDataAPI.instance = new AlpacaMarketDataAPI();
         }
         return AlpacaMarketDataAPI.instance;
     }
@@ -15498,8 +15801,8 @@ class AlpacaMarketDataAPI extends EventEmitter {
             log(`${streamType} stream connected`, { type: 'info' });
             const authMessage = {
                 action: 'auth',
-                key: this.apiKey,
-                secret: this.secretKey,
+                key: process.env.ALPACA_API_KEY,
+                secret: process.env.ALPACA_SECRET_KEY,
             };
             ws.send(JSON.stringify(authMessage));
         });
@@ -15590,7 +15893,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
         const currentSubscriptions = streamType === 'stock' ? this.stockSubscriptions : this.optionSubscriptions;
         Object.entries(subscriptions).forEach(([key, value]) => {
             if (value) {
-                currentSubscriptions[key] = (currentSubscriptions[key] || []).filter((s) => !value.includes(s));
+                currentSubscriptions[key] = (currentSubscriptions[key] || []).filter(s => !value.includes(s));
             }
         });
         const unsubMessage = {
@@ -15653,11 +15956,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
         let pageCount = 0;
         let currency = '';
         // Initialize bar arrays for each symbol
-        symbols.forEach((symbol) => {
+        symbols.forEach(symbol => {
             allBars[symbol] = [];
         });
         log(`Starting historical bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || 'no start'} to ${params.end || 'no end'})`, {
-            type: 'info',
+            type: 'info'
         });
         while (hasMorePages) {
             pageCount++;
@@ -15685,7 +15988,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                     allBars[symbol] = [...allBars[symbol], ...bars];
                     pageBarsCount += bars.length;
                     // Track date range for this page
-                    bars.forEach((bar) => {
+                    bars.forEach(bar => {
                         const barDate = new Date(bar.t);
                         if (!earliestTimestamp || barDate < earliestTimestamp) {
                             earliestTimestamp = barDate;
@@ -15704,7 +16007,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? `${earliestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })} to ${latestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })}`
                 : 'unknown range';
             log(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ', more pages available' : ', complete'}`, {
-                type: 'info',
+                type: 'info'
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
@@ -15713,11 +16016,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
             }
         }
         // Final summary
-        const symbolCounts = Object.entries(allBars)
-            .map(([symbol, bars]) => `${symbol}: ${bars.length}`)
-            .join(', ');
+        const symbolCounts = Object.entries(allBars).map(([symbol, bars]) => `${symbol}: ${bars.length}`).join(', ');
         log(`Historical bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
-            type: 'info',
+            type: 'info'
         });
         return {
             bars: allBars,
@@ -15985,11 +16286,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
         let totalBarsCount = 0;
         let pageCount = 0;
         // Initialize bar arrays for each symbol
-        symbols.forEach((symbol) => {
+        symbols.forEach(symbol => {
             allBars[symbol] = [];
         });
         log(`Starting historical options bars fetch for ${symbolsStr} (${params.timeframe}, ${params.start || 'no start'} to ${params.end || 'no end'})`, {
-            type: 'info',
+            type: 'info'
         });
         while (hasMorePages) {
             pageCount++;
@@ -16011,7 +16312,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                     allBars[symbol] = [...allBars[symbol], ...bars];
                     pageBarsCount += bars.length;
                     // Track date range for this page
-                    bars.forEach((bar) => {
+                    bars.forEach(bar => {
                         const barDate = new Date(bar.t);
                         if (!earliestTimestamp || barDate < earliestTimestamp) {
                             earliestTimestamp = barDate;
@@ -16030,7 +16331,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? `${earliestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })} to ${latestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })}`
                 : 'unknown range';
             log(`Page ${pageCount}: Fetched ${pageBarsCount.toLocaleString()} option bars (total: ${totalBarsCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ', more pages available' : ', complete'}`, {
-                type: 'info',
+                type: 'info'
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
@@ -16039,11 +16340,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
             }
         }
         // Final summary
-        const symbolCounts = Object.entries(allBars)
-            .map(([symbol, bars]) => `${symbol}: ${bars.length}`)
-            .join(', ');
+        const symbolCounts = Object.entries(allBars).map(([symbol, bars]) => `${symbol}: ${bars.length}`).join(', ');
         log(`Historical options bars fetch complete: ${totalBarsCount.toLocaleString()} total bars across ${pageCount} pages (${symbolCounts})`, {
-            type: 'info',
+            type: 'info'
         });
         return {
             bars: allBars,
@@ -16067,11 +16366,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
         let totalTradesCount = 0;
         let pageCount = 0;
         // Initialize trades arrays for each symbol
-        symbols.forEach((symbol) => {
+        symbols.forEach(symbol => {
             allTrades[symbol] = [];
         });
         log(`Starting historical options trades fetch for ${symbolsStr} (${params.start || 'no start'} to ${params.end || 'no end'})`, {
-            type: 'info',
+            type: 'info'
         });
         while (hasMorePages) {
             pageCount++;
@@ -16093,7 +16392,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                     allTrades[symbol] = [...allTrades[symbol], ...trades];
                     pageTradesCount += trades.length;
                     // Track date range for this page
-                    trades.forEach((trade) => {
+                    trades.forEach(trade => {
                         const tradeDate = new Date(trade.t);
                         if (!earliestTimestamp || tradeDate < earliestTimestamp) {
                             earliestTimestamp = tradeDate;
@@ -16112,7 +16411,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ? `${earliestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })} to ${latestTimestamp.toLocaleDateString('en-US', { timeZone: 'America/New_York' })}`
                 : 'unknown range';
             log(`Page ${pageCount}: Fetched ${pageTradesCount.toLocaleString()} option trades (total: ${totalTradesCount.toLocaleString()}) for ${symbolsStr}, date range: ${dateRangeStr}${hasMorePages ? ', more pages available' : ', complete'}`, {
-                type: 'info',
+                type: 'info'
             });
             // Prevent infinite loops
             if (pageCount > 1000) {
@@ -16121,11 +16420,9 @@ class AlpacaMarketDataAPI extends EventEmitter {
             }
         }
         // Final summary
-        const symbolCounts = Object.entries(allTrades)
-            .map(([symbol, trades]) => `${symbol}: ${trades.length}`)
-            .join(', ');
+        const symbolCounts = Object.entries(allTrades).map(([symbol, trades]) => `${symbol}: ${trades.length}`).join(', ');
         log(`Historical options trades fetch complete: ${totalTradesCount.toLocaleString()} total trades across ${pageCount} pages (${symbolCounts})`, {
-            type: 'info',
+            type: 'info'
         });
         return {
             trades: allTrades,
@@ -16270,9 +16567,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 ...(symbol && { symbols: symbol }),
                 ...(mergedParams.limit && { limit: Math.min(50, maxLimit - fetchedCount).toString() }),
                 ...(mergedParams.sort && { sort: mergedParams.sort }),
-                ...(mergedParams.include_content !== undefined
-                    ? { include_content: mergedParams.include_content.toString() }
-                    : {}),
+                ...(mergedParams.include_content !== undefined ? { include_content: mergedParams.include_content.toString() } : {}),
                 ...(pageToken && { page_token: pageToken }),
             });
             const url = `${this.v1beta1url}/news?${queryParams}`;
@@ -16316,6 +16611,8 @@ class AlpacaMarketDataAPI extends EventEmitter {
         return newsArticles;
     }
 }
+// Export the singleton instance
+const marketDataAPI = AlpacaMarketDataAPI.getInstance();
 
 const limitPriceSlippagePercent100 = 0.1; // 0.1%
 /**
@@ -16327,11 +16624,11 @@ Websocket example
   alpacaAPI.connectWebsocket(); // necessary to connect to the WebSocket
 */
 class AlpacaTradingAPI {
-    static new(credentials, marketDataConfig) {
-        return new AlpacaTradingAPI(credentials, marketDataConfig);
+    static new(credentials) {
+        return new AlpacaTradingAPI(credentials);
     }
-    static getInstance(credentials, marketDataConfig) {
-        return new AlpacaTradingAPI(credentials, marketDataConfig);
+    static getInstance(credentials) {
+        return new AlpacaTradingAPI(credentials);
     }
     ws = null;
     headers;
@@ -16345,7 +16642,6 @@ class AlpacaTradingAPI {
     reconnectTimeout = null;
     messageHandlers = new Map();
     debugLogging = false;
-    marketDataAPI;
     /**
      * Constructor for AlpacaTradingAPI
      * @param credentials - Alpaca credentials,
@@ -16354,14 +16650,11 @@ class AlpacaTradingAPI {
      *   apiSecret: string; // Alpaca API secret
      *   type: AlpacaAccountType;
      *   orderType: AlpacaOrderType;
-     * @param marketDataConfig - Market data API configuration
      * @param options - Optional options
      *   debugLogging: boolean; // Whether to log messages of type 'debug'
      */
-    constructor(credentials, marketDataConfig, options) {
+    constructor(credentials, options) {
         this.credentials = credentials;
-        // Initialize market data API instance
-        this.marketDataAPI = AlpacaMarketDataAPI.getInstance(marketDataConfig);
         // Set URLs based on account type
         this.apiBaseUrl =
             credentials.type === 'PAPER' ? 'https://paper-api.alpaca.markets/v2' : 'https://api.alpaca.markets/v2';
@@ -16900,7 +17193,7 @@ class AlpacaTradingAPI {
             this.log(`Found ${positions.length} positions to close`);
             // Get latest quotes for all positions
             const symbols = positions.map((position) => position.symbol);
-            const quotesResponse = await this.marketDataAPI.getLatestQuotes(symbols);
+            const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
             const lengthOfQuotes = Object.keys(quotesResponse.quotes).length;
             if (lengthOfQuotes === 0) {
                 this.log('No quotes available for positions, received 0 quotes', {
@@ -16967,7 +17260,7 @@ class AlpacaTradingAPI {
         this.log(`Cancelled all open orders`);
         // Get latest quotes for all positions
         const symbols = positions.map((position) => position.symbol);
-        const quotesResponse = await this.marketDataAPI.getLatestQuotes(symbols);
+        const quotesResponse = await marketDataAPI.getLatestQuotes(symbols);
         // Create limit orders to close each position
         for (const position of positions) {
             const quote = quotesResponse.quotes[position.symbol];
@@ -17650,13 +17943,6 @@ class AlpacaTradingAPI {
     }
 }
 
-// Export factory functions for easier instantiation
-const createAlpacaTradingAPI = (credentials, marketDataConfig) => {
-    return new AlpacaTradingAPI(credentials, marketDataConfig);
-};
-const createAlpacaMarketDataAPI = (config) => {
-    return AlpacaMarketDataAPI.getInstance(config);
-};
 const disco = {
     types: Types,
     alpaca: {
@@ -17704,31 +17990,14 @@ const disco = {
         calculateFibonacciLevels: calculateFibonacciLevels,
     },
     time: {
-        toUnixTimestamp: toUnixTimestamp,
-        getTimeAgo: getTimeAgo,
-        timeAgo: timeAgo,
-        normalizeDate: normalizeDate,
-        getDateInNY: getDateInNY,
-        createMarketTimeUtil: createMarketTimeUtil,
-        getStartAndEndTimestamps: getStartAndEndTimestamps,
         getStartAndEndDates: getStartAndEndDates,
         getMarketOpenClose: getMarketOpenClose,
-        calculateTimeRange: calculateTimeRange,
-        calculateDaysLeft: calculateDaysLeft,
-        formatDate: formatDate /* move to format, keeping here for compatibility  */,
-        currentTimeET: currentTimeET,
-        MarketTimeUtil: MarketTimeUtil,
-        MARKET_TIMES: MARKET_TIMES,
-        getLastTradingDateYYYYMMDD: getLastTradingDateYYYYMMDD,
         getLastFullTradingDate: getLastFullTradingDate,
         getNextMarketDay: getNextMarketDay,
-        parseETDateFromAV: parseETDateFromAV,
-        formatToUSEastern: formatToUSEastern,
-        unixTimetoUSEastern: unixTimetoUSEastern,
         getMarketStatus: getMarketStatus,
-        timeDiffString: timeDiffString,
         getNYTimeZone: getNYTimeZone,
         getTradingDate: getTradingDate,
+        getTradingStartAndEndDates: getTradingStartAndEndDates,
     },
     utils: {
         logIfDebug: logIfDebug,
@@ -17737,5 +18006,5 @@ const disco = {
     },
 };
 
-export { AlpacaMarketDataAPI, AlpacaTradingAPI, createAlpacaMarketDataAPI, createAlpacaTradingAPI, disco };
+export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco };
 //# sourceMappingURL=index.mjs.map